DIRECTORY Rope USING[ROPE], SafeStorage USING[Type, nullType], WorldVM USING[World, LocalWorld]; AMTypes: CEDAR DEFINITIONS IMPORTS WorldVM = BEGIN OPEN Rope; Type: TYPE = SafeStorage.Type; nullType: Type = SafeStorage.nullType; TypedVariable: TYPE = REF ANY; TV: TYPE = TypedVariable; Status: TYPE = {mutable, readOnly, const}; Index: TYPE = NAT; --index range for records, enumerations, etc is [1..n] Class: TYPE = { definition, -- e.g. TypeClass[CODE[T]] where T: TYPE = ...-- cardinal, longCardinal, integer, longInteger, real, character, --basic-- atom, rope, list, ref, pointer, longPointer, descriptor, longDescriptor, basePointer, relativePointer, --address-- procedure, signal, error, program, port, --transfer-- enumerated, subrange, union, sequence, record, structure, array, countedZone, uncountedZone, nil, -- e.g. TypeClass[TVType[NIL]] unspecified, process, type, opaque, any, -- e.g. TypeClass[Range[CODE[REF ANY]]] globalFrame, localFrame --frame-- }; Error: ERROR[ reason: ErrorReason, msg: ROPE _ NIL, type: Type _ nullType, -- used with TypeFault, IncompatibleTypes otherType: Type _ nullType -- used with IncompatibleTypes ]; ErrorReason: TYPE = { noSymbols, -- msg has moduleName notImplemented, -- mostly DefaultInitialValue cases incompatibleTypes, -- raised by Assign rangeFault, -- e.g. empty subrange, Apply bounds check notMutable, -- raised by (e.g.) Assign internalTV, -- raised by (e.g.) RefFromTV badName, -- raised by NameToIndex badIndex, -- raised by (e.g.) IndexToType typeFault -- general applicability violation }; Size: PROC[type: Type, length: CARDINAL _ 0--sequence only: number of elements--] RETURNS[words: CARDINAL--max for unions--]; DefaultInitialValue: PROC[type: Type] RETURNS[TypedVariable]; IndexToDefaultInitialValue: PROC[type: Type--record, structure--, index: Index] RETURNS[TypedVariable]; TypeClass: PROC[type: Type] RETURNS[Class]; UnderClass: PROC[type: Type] RETURNS[Class] = INLINE {RETURN[TypeClass[UnderType[type]]]}; IsPainted: PROC[type: Type] RETURNS[BOOL]; TVType: PROC[tv: TypedVariable] RETURNS[Type]; TVStatus: PROC[tv: TypedVariable] RETURNS[Status]; TVSize: PROC[tv: TypedVariable] RETURNS[words: INT]; GetEmptyTV: PROC RETURNS[TypedVariable]; New: PROC[ type: Type, status: Status _ mutable, world: WorldVM.World _ WorldVM.LocalWorld[], tag: TV _ NIL ] RETURNS[TypedVariable]; Copy: PROC[tv: TypedVariable] RETURNS[TypedVariable]; Assign: PROC[lhs, rhs: TypedVariable]; AssignNew: PUBLIC PROC[lhs, rhs: TypedVariable]; TVEq: PROC[tv1, tv2: TypedVariable] RETURNS [BOOL]; TVEqual: PROC[tv1, tv2: TypedVariable] RETURNS [BOOL]; NComponents: PROC[type: Type--record, structure--] RETURNS[Index]; VariableType: PROC[type: Type--record, structure--] RETURNS[v: Type, c: Class--union, sequence, or nil--]; IndexToTV: PROC[tv: TypedVariable--record, structure--, index: Index] RETURNS[TypedVariable]; IndexToType: PROC[type: Type--record, structure, union--, index: Index] RETURNS[Type]; NameToIndex: PROC[type: Type--record, structure, union, enumerated--, name: ROPE] RETURNS[CARDINAL]; IndexToName: PROC[type: Type--record, structure, union, enumerated--, index: CARDINAL] RETURNS[ROPE]; TVToType: PROC[tv: TypedVariable--type--] RETURNS[Type]; TVToName: PROC[tv: TypedVariable] RETURNS[ans: ROPE]; Tag: PROC[tv: TypedVariable--union--] RETURNS[TypedVariable--enumerated--]; Variant: PROC[tv: TypedVariable--union--] RETURNS[TypedVariable--record--]; IsOverlaid: PROC[type: Type--union--] RETURNS[BOOL]; IsMachineDependent: PROC[type: Type] RETURNS[BOOL]; Domain: PROC[type: Type--array, sequence, transfer, union--] RETURNS[Type]; Range: PROC[type: Type] RETURNS[Type]; IsPacked: PROC[type: Type--array, sequence--] RETURNS[BOOL]; IsComputed: PROC[type: Type--union, sequence--] RETURNS[BOOL]; Apply: PROC[mapper: TypedVariable--array, sequence--, arg: TypedVariable] RETURNS[TypedVariable]; Length: PROC[tv: TypedVariable--sequence, rope--] RETURNS[INT]; Fetch: PROC[tv: TypedVariable--rope--, index: INT] RETURNS[CHAR]; Referent: PROC[ tv: TypedVariable--ref, list, pointer, longPointer, relativePointer--, base: TypedVariable _ NIL--non-nil only if ref is a relativePointer. UNSAFE ] RETURNS[TypedVariable]; ConcreteRef: PROC[tv: TypedVariable--ref any--] RETURNS[TypedVariable]; ReferentStatus: PROC[type: Type--address (not basePointer, atom)--] RETURNS[Status]; IsRefAny: PROC[type: Type--ref--] RETURNS[BOOL]; IsInterface: PROC[type: Type--record--] RETURNS[BOOL]; IsAtom: PROC[tv: TypedVariable--ref any--] RETURNS[BOOL]; IsRope: PROC[tv: TypedVariable--ref any--] RETURNS[BOOL]; IsNil: PROC[tv: TypedVariable--address--] RETURNS[BOOL]; IsOrdered: PROC[type: Type--basePointer, relativePointer--] RETURNS[BOOL]; PropertyList: PROC[tv: TypedVariable--atom--] RETURNS[TypedVariable--list, nil--]; Coerce: PROC[tv: TypedVariable, targetType: Type] RETURNS[TypedVariable]; TypeToName: PROC[ type: Type--definition--, moduleName: REF ROPE _ NIL, fileName: REF ROPE _ NIL ] RETURNS[ROPE]; Ground: PROC[type: Type--definition, subrange--] RETURNS[Type]; GroundStar: PUBLIC PROC[type: Type--definition, subrange--] RETURNS[Type]; UnderType: PUBLIC PROC[type: Type--definition--] RETURNS[Type]; InRange: PROC[type: Type--subrange--, groundTV: TypedVariable] RETURNS[BOOL]; First: PROC[type: Type--enumerated, subrange, basic--] RETURNS[TypedVariable]; Last: PROC[type: Type--enumerated, subrange, basic--] RETURNS[TypedVariable]; Next: PROC[tv: TypedVariable--enumerated, subrange, basic--] RETURNS[TypedVariable]; NValues: PROC[type: Type--enumerated--] RETURNS[INT]; Value: PROC[type: Type--enumerated--, index: CARDINAL] RETURNS[TypedVariable]; StaticParent: PROC[tv: TypedVariable--procedure--] RETURNS[TypedVariable--procedure--]; Locals: PROC[tv: TypedVariable--localFrame--] RETURNS[TypedVariable--record--]; EnclosingBody: PROC[tv: TypedVariable--localFrame--] RETURNS[TypedVariable--localFrame--]; Argument: PROC[tv: TypedVariable--local or catch frame--, index: Index] RETURNS[TypedVariable]; Result: PROC[tv: TypedVariable--local or catch frame--, index: Index] RETURNS[TypedVariable]; Procedure: PROC[tv: TypedVariable--localFrame--] RETURNS[TypedVariable--procedure--]; Signal: PROC[tv: TypedVariable--catch frame--] RETURNS[TypedVariable--signal descriptor--]; DynamicParent: PROC[tv: TypedVariable--localFrame--] RETURNS[TypedVariable--localFrame--]; GlobalParent: PROC[tv: TypedVariable--transfer or local frame--] RETURNS[TypedVariable--globalFrame--]; Globals: PROC[tv: TypedVariable--globalFrame--] RETURNS[TypedVariable--record--]; END. ͺAMTypes.Mesa last modified on July 22, 1983 2:39 pm by Paul Rovner T Y P E S E R R O R S P R O C E D U R E S Access to general Type characteristics. Enumerated types and records declared in interfaces are painted. Access to general TV characteristics. Returns a predefined, special TV that is used to indicate the "empty" value. The procedures below are applicable to all but the frame types, opaque and any. New creates and returns a cleared object. tag has meaning only for union or sequence-containing record types. See DefaultInitialValue. Two TypedVariables are Eq if assignment to one is equivalent to assignment to the other; i.e, they address the same bits. Two TypedVariables are Equal if the values have the same size and same bits. NOTE no type checking is done. Procedures with applicability restrictions (based on Class, noted as comments) index range is [1..NComponents[TVType[tv]]] IndexToType returns the specified component of the type. SPECIAL CASE for union types: index = 0 gets you the tag type (redundant: Tag does this too). SPECIAL CASE for union types: index = 0 gets you the tag name applicable to enumerated, transfer, program, globalFrame, atom, rope record, structure, union, enumerated, sequence applicable to array, sequence, procedure, signal, process, address (not atom, rope) For a rope, Length returns an INT for the number of characters in the given rope. For a sequence, Length returns an INT specifying the (max) number of elements in the sequence. Use Tag[tv] to obtain the actual sequence tag field. Their values may differ if the tag type has a non-zero lower bound. ConcreteRef returns a TV for the REF . NIL -> NIL. ConcreteRef is implemented only for REFANY's that are really ATOM, LIST or ROPE guys (Error[reason: notImplemented] is raised otherwise) use Coerce to Narrow or Widen IF name exists and REFs to moduleName and/or fileName ROPEs are provided, TypeToName provides that info too. peels off one layer of definition peels off all layers of definition returns first non-definition type returns NIL if no next index range is [1..NValues[type]] may return NIL Access to local and global frames may return NIL may return NIL Κ ς– "cedar" style˜Iprocšœ ™ Kšœ5™5K˜šΟk ˜ Kšœœœ˜Kšœ œ˜"Kšœœ˜!—K˜Kšœ œ œœ˜*šœœœ˜K™šœ ™ šœœ˜Kšœ&˜&—K˜Kšœœœœ˜K˜Kšœœ˜K˜Kšœœ˜*K˜KšœœœΟc6˜JK˜šœœ˜Kšœ ž0˜=Kšœ?ž ˜HKšœUžœž ˜rKšœ)ž œ˜6Kšœ˜Kšœ˜Kšœ˜Kšœ˜Kšœ˜Kšœž˜%Kšœ ˜ Kšœ˜Kšœ˜Kšœ˜Kšœž'˜-Kšœž ˜"Kšœ˜——K™šœ ™ šœœ˜ Kšœ˜Kšœœœ˜Kšœž)˜AKšœž˜9Kšœ˜—šœ œ˜Kšœ ž˜"Kšœž#˜4Kšœž˜&Kšœž*˜8Kšœž˜(Kšœž˜+Kšœ ž˜$Kšœ ž˜,Kšœ ž"˜/Kšœ˜——K™šœ™K™Kšœ'™'˜šΟnœœœž%œ˜QKšœžœ˜+—K˜KšŸœœ œ˜=K˜šŸœœ žœ˜OKšœ˜—K˜KšŸ œœ œ˜+K˜šŸ œœ œ ˜-Kšœœ˜,—˜Kšœ@™@—KšŸ œœ œœ˜*K™—Kšœ%™%˜KšŸœœœ˜.K˜KšŸœœœ ˜2K˜KšŸœœœœ˜4™Kšœœ,™L—KšŸ œœœ˜(K™K™KšœO™O˜Kšœ†™†—šŸœœ˜ Kšœ ˜ Kšœ˜Kšœ,˜,Kšœœ˜ Kšœ˜Kšœ˜—K˜KšŸœœœ˜5K˜KšŸœœ˜&K˜KšŸ œœœ˜0™Kšœε™ε—KšŸœœœœ˜3K˜KšŸœœœœ˜6K™—KšœN™N˜KšŸ œœ žœœ˜BK˜šŸ œœ žœ˜3Kšœžœ˜6—˜Kšœ+™+—šŸ œœžœ˜EKšœ˜—˜Kšœ–™–—šŸ œœ žœ˜GKšœ˜—K˜šŸ œ˜ Kšœ ž(œœœ˜DKšœœ˜—˜Kšœ=™=—šŸ œ˜ Kšœ ž(œ œ˜IKšœœ˜—˜KšœD™D—KšŸœœžœœ˜8K˜KšŸœœœœ˜5K˜Kš Ÿœœž œœžœ˜KK˜Kš Ÿœœž œœž œ˜KK˜Kš Ÿ œœ ž œœœ˜4˜Kšœ.™.—KšŸœœ œœ˜3˜KšœBŸœ™S—KšŸœœ ž$œœ˜KK˜KšŸœœ œ˜&K˜Kš Ÿœœ žœœœ˜K˜šŸœœžœ˜IKšœ˜—™Kšœ«™«—Kš Ÿœœžœœœ˜?K˜Kš Ÿœœžœ œœœ˜AK˜šŸœœ˜Kšœž4œ˜FKšœž2˜KKšœ˜Kšœ˜—˜KšœŸŸœ3™Σ—KšŸ œœž œœ˜GK˜KšŸœœ ž#œœ ˜TK˜Kš Ÿœœ žœœœ˜0K˜Kš Ÿ œœ ž œœœ˜6K˜Kš Ÿœœž œœœ˜9K˜Kš Ÿœœž œœœ˜9K˜Kš Ÿœœž œœœ˜8K˜Kš Ÿ œœ ž œœœ˜JK˜Kš Ÿ œœžœœž œ˜R˜Kšœ™—KšŸœœ&œ˜I˜Kšœl™l—šŸ œœ˜Kšœ žœ˜Kšœ œœœ˜Kšœ œœ˜Kšœ˜Kšœœ˜—˜Kšœ!™!—Kš Ÿœœ žœžœ˜?˜Kšœ"™"—Kš Ÿ œœœ žœœ˜J˜Kšœ!™!—Kš Ÿ œœœ žœœ˜?K˜Kš Ÿœœ ž œœœ˜MK˜KšŸœœ žœœ˜NK˜KšŸœœ žœœ˜M˜Kšœ™—Kš Ÿœœžœžœ˜TK˜Kš Ÿœœ žœœœ˜5˜Kšœ!™!—Kš Ÿœœ žœ œœ˜N˜Kšœ™—šŸ œœž œ˜2Kšœž œ˜$—K˜—šœ!™!˜Kšœ™—šŸœœžœ˜-Kšœž œ˜!—˜Kšœ™—šŸ œœžœ˜4Kšœžœ˜&—K˜šŸœœžœ˜GKšœ˜—K˜šŸœœžœ˜EKšœ˜—K˜šŸ œœžœ˜0Kšœž œ˜$—K˜šŸœœžœ˜.Kšœžœ˜,—K˜šŸ œœžœ˜4Kšœžœ˜%—K˜šŸ œœžœ˜@Kšœžœ˜&K˜—Kš Ÿœœžœœž œ˜QK˜———Kšœ˜K˜—…—δ-€