DIRECTORY
Basics USING [LowHalf, LowByte],
IO USING [STREAM],
Rope USING [ROPE];


PasPrivate: CEDAR DEFINITIONS IMPORTS Basics =

BEGIN


ROPE: TYPE = Rope.ROPE;  --short names for Cedar things
STREAM: TYPE = IO.STREAM;

PascalInteger: TYPE = INT;
PascalReal: TYPE = REAL;

PascalMaxSetSize: NAT = 256;

PascalIdentLength: NAT = 8;

Standards: TYPE = -- Pascal standard files/procedures/functions/constants
{
Input, Output, Tty, ExtraFile1, ExtraFile2,

Halt, Get, Put, Reset, Rewrite, Read, ReadLn, Write, WriteLn, Break, Pack,
Unpack, New, Dispose, Page, Release, Assign, Concat, PutChar, GetFileName,
Date, Time, ExtraProc1, ExtraProc2, ExtraProc3, ExtraProc4, ExtraProc5,

Clock, Abs, Sqr, Sin, Cos, Exp, Ln, Sqrt, Arctan, Odd, Ord, Chr, Pred, Succ,
EOF, EOLn, EOPage, Card, LowerBound, UpperBound, Min, Max, First, Last, Round,
Trunc, Length, GetChar, ExtraFn1, ExtraFn2, ExtraFn3, ExtraFn4, ExtraFn5,

MaxInteger, False, True, Nil, ExtraConst1, ExtraConst2};

StandardFiles: TYPE = Standards [Input..ExtraFile2];
StandardProcedures: TYPE = Standards [Halt..ExtraProc5];
StandardFunctions: TYPE = Standards [Clock..ExtraFn5];
StandardConstants: TYPE = Standards [False..ExtraConst2];

PascalStandardFileNames: ARRAY StandardFiles OF ROPE;
PascalStandardProcedureNames: ARRAY StandardProcedures OF ROPE;
PascalStandardFunctionNames: ARRAY StandardFunctions OF ROPE;

Symbol: TYPE = -- scanner tokens
{
identSy, intConstSy, realConstSy, stringConstSy, notSy, mulOpSy, addOpSy,
relOpSy, lParentSy, rParentSy, lBrackSy, rBrackSy, commaSy, semiColonSy,
periodSy, arrowSy, colonSy, becomesSy, labelSy, constSy, typeSy, varSy,
functionSy, procedureSy, packedSy, setSy, arraySy, recordSy, fileSy,
forwardSy, beginSy, ifSy, caseSy, repeatSy, whileSy, forSy, withSy, loopSy,
gotoSy, exitSy, endSy, elseSy, untilSy, ofSy, doSy, toSy, downToSy, externSy,
programSy, thenSy, otherSy, othersSy, eofSy, CRSy};

Operator: TYPE = -- Pascal operators
{
noOp, plusOp, minusOp, mulOp, rDivOp, iDivOp, modOp, andOp, orOp, ltOp, gtOp,
leOp, geOp, neOp, eqOp, inOp, notOp};

Errors: TYPE = -- various error types
{
MalformedProgram, MalformedBlock, MalformedStatement, MalformedAssignment,
MalformedParameterList, MalformedProcedureCall, MultipleTypeDefinition,
ShouldBeRecord, CantComputeConstant, MalformedVariable, MalformedArrayAccess,
MalformedRecordAccess, MalformedExpression, MalformedSimpleExpression,
MalformedTerm, MalformedFactor, MalformedConstant, MalformedSetConstructor,
IllegalOperation, IncompatibleOperands, IllegalOperand, UnknownType,
IllegalValue, IncompatibleTypes, CantExpressString, NotASet, Undefined,
MultipleDefinition, MalformedInstr, MalformedStandard, MalformedNewDispose,
ImproperType, MalformedPack, BadArgumentCount, MalformedIdList,
MalformedSimpleType, MalformedRangeType, MalformedType, MalformedScalar,
UnexpectedType, NotFiniteType, SetTooLarge, UndefinedType,
MultiplyDefinedLabel, MalformedNonLocalGoTo, MalformedProcArrayDeclaration,
MalformedComputedSeqArrayDeclaration, MalformedComputedSeqArrayAccess,
MalformedProcArrayAccess, IdentifierMismatch, MalformedExternalProc, Confusion};

Name: TYPE = ROPE; 

LexLevel: TYPE = CARDINAL [0..31];

Position: TYPE = {outer, inner}; -- for generating the interfaces

TypeFlavor: TYPE = 
{unknown, scalar, subRange, pointer, power, array, procArray, computedSeqArray, record, file, procedure};

Type: TYPE = RECORD [
SELECT form: TypeFlavor FROM
unknown => NULL,
scalar => -- integer, real, char, and boolean are instances of this
[
firstId: ConstantIdentifierPtr, -- for boolean or user-defined type
size: CARDINAL -- for boolean, char, and user-defined type
],
subRange => [
hostType: GeneralTypePtr, -- host type: non-real scalar
lower, upper: PascalInteger],
pointer => [elType: GeneralTypePtr], -- pointed-to element type: any
power => [baseType: GeneralTypePtr],
array => [
aIsPacked: BOOLEAN _ FALSE,
aIsDynamic: BOOLEAN _ FALSE, -- represented as pointer
aElType: GeneralTypePtr, -- element type: any type
aIxType: GeneralTypePtr
],
procArray => [
aElType: GeneralTypePtr, -- any type
indices: IdentifierSetPtr],
computedSeqArray => [
aElType: GeneralTypePtr], -- any type
record => [recIsPacked: BOOLEAN _ FALSE, fieldList: FieldListPtr],
file => [
fileIsPacked: BOOLEAN _ FALSE,
textFile: BOOLEAN _ FALSE,
fileType: GeneralTypePtr -- file element type: any type
],
procedure => [
result: GeneralTypePtr, -- = nilGeneralTypePtr if non-function
formals: IdentifierSetPtr],
ENDCASE] _ [unknown[]]; -- Type

TypePtr: TYPE = REF Type;
ScalarTypePtr: TYPE = REF scalar Type;
SubRangeTypePtr: TYPE = REF subRange Type;
PointerTypePtr: TYPE = REF pointer Type;
PowerTypePtr: TYPE = REF power Type;
ArrayTypePtr: TYPE = REF array Type;
ProcArrayTypePtr: TYPE = REF procArray Type;
ComputedSeqArrayTypePtr: TYPE = REF computedSeqArray Type;
RecordTypePtr: TYPE = REF record Type;
FileTypePtr: TYPE = REF file Type;
ProcedureTypePtr: TYPE = REF procedure Type;

FieldList: TYPE = RECORD [
fieldSet: IdentifierSetPtr, -- set of fields
firstVariant: VariantPtr _ NIL, -- NIL if no variants
tagSpecific:
SELECT tagStatus: * FROM
identified => [tagId: VariableIdentifierPtr],
unidentified => [tagType: GeneralTypePtr],
ENDCASE] _ nilFieldList;
nilFieldList: FieldList =
[fieldSet: NIL, firstVariant: NIL,
tagSpecific: unidentified[tagType: nilGeneralTypePtr]];
FieldListPtr: TYPE = REF FieldList;

Variant: TYPE = RECORD [
nextVariant: VariantPtr, -- to next variant in this record
tagValue: PascalInteger, -- that activates this variant
fieldList: FieldListPtr];
VariantPtr: TYPE = REF Variant;

IdentifierFlavor: TYPE = --possible tag fields for Identifier variant record
{unknown, type, constant, realConstant, charArrayConstant, variable, procedure, label,
config, defsModule, implModule, outerItem, compileDifferently, programSegment};

Identifier: TYPE = RECORD [
name: Name, -- the actual name
hash: INTEGER _ , -- a hash code, to make searching lists of identifiers faster
type: GeneralTypePtr, -- the type descriptor
class: IdentifierTailPtr];

IdentifierTail: TYPE = RECORD [
t: SELECT idClass: IdentifierFlavor FROM
unknown, type => NULL,
constant => [scalarLink: ConstantIdentifierPtr, value: PascalInteger],
realConstant => NULL,
charArrayConstant => NULL,
variable => [kind: {normal, var} _ normal],
procedure => [
source:
SELECT declKind: * FROM
standard => [key: Standards],
parameter => NULL,
declared => [
forward: BOOLEAN _ FALSE,
defining: BOOLEAN _ FALSE, -- now within definition
inline: BOOLEAN _ FALSE, -- translate as an INLINE
headerQ: OutputQueuePtr -- translation of header
],
ENDCASE],
label => [
nonLocal: BOOL _ FALSE,  -- NonLocal goto's are implemented with Signals.
forwardTarget: BOOL _ FALSE,
backwardTarget: BOOL _ FALSE,
alreadyDefined: BOOL _ FALSE
],
defsModule => [
openees: IdentifierSetPtr, -- these go into the directory and open clause of this defs
importees: IdentifierSetPtr, -- these go into the imports clause
compileMe: BOOL _ TRUE,  -- false for either a trash or an external defs
exportMe: BOOL _ TRUE,  --false for a trash defs
q: OutputQueuePtr
],
implModule => [
openedDefs: IdentifierSetPtr, -- these go into the directory and open clause of this impl
importedDefs: IdentifierSetPtr, -- these go into the imports clause
openedAndImportedImpls: IdentifierSetPtr, -- these too, in case of importing pointer to frame
exportees: IdentifierSetPtr,  -- and these are the exports
compileMe: BOOL _ TRUE,  -- false for either a trash or an external impl
bindMe: BOOL _ TRUE,  -- false for a trash impl
q: OutputQueuePtr
],
compileDifferently => 
[
arrayHow: ArrayDifferentlyMethod _ notAtAll,
procHow: ProcDifferentlyMethod _ notAtAll
],
programSegment => -- constructed from command file
[
mentionedProcedures: IdentifierSetPtr, -- consisting of programSegments
mentionedVariables: IdentifierSetPtr -- consisting of compileDifferently's
],
config => -- constructed from command files that ask for modularization
[
mentionedIdents: IdentifierSetPtr -- consisting of outerItem's
],
outerItem => -- something in the outer block
[
dest: DestinationPtr  -- says where the item should go
],
ENDCASE _ unknown[]]; -- Identifier

ArrayDifferentlyMethod: TYPE = {notAtAll, specialArray, procArray, computedSeqArray};
ProcDifferentlyMethod: TYPE = {notAtAll, inlineProc};

IdentifierPtr: TYPE = REF Identifier;
IdentifierTailPtr:  TYPE = REF IdentifierTail;

ConstantIdentifierPtr:  TYPE = IdentifierPtr;
VariableIdentifierPtr:  TYPE = IdentifierPtr;
ProcedureIdentifierPtr:  TYPE = IdentifierPtr;
DeclaredProcedureIdentifierPtr:  TYPE = IdentifierPtr;
SegmentIdentifierPtr:  TYPE = IdentifierPtr;
ConstantIdentifierTailPtr:  TYPE = REF constant IdentifierTail;
VariableIdentifierTailPtr:  TYPE = REF variable IdentifierTail;
ProcedureIdentifierTailPtr:  TYPE = REF procedure IdentifierTail;
DeclaredProcedureIdentifierTailPtr:  TYPE = REF declared procedure IdentifierTail;
SegmentIdentifierTailPtr:  TYPE = REF programSegment IdentifierTail;



IdentifierSet: TYPE = LIST OF IdentifierPtr _ NIL; -- default is empty
IdentifierSetPtr: TYPE = REF IdentifierSet;

Destination: TYPE = RECORD [
defsModule: IdentifierPtr,
implModule: IdentifierPtr];
DestinationPtr: TYPE = REF Destination;

GeneralTypePtr: TYPE = REF ANY;
nilGeneralTypePtr: GeneralTypePtr = NIL;


Value: TYPE = RECORD [
type: GeneralTypePtr,
value: ValueTailPtr];
ValueTail: TYPE = RECORD [
SELECT binding: * FROM
unknown => NULL,
variable, nonConstant, otherConstant => [
translation: OutputQueuePtr _ NIL],
scalarConstant => [v: ScalarConstant],
stringConstant => [v: ROPE], -- turns into otherConstant on translation
setConstructor => [v: SetIntervalPtr], -- a chain of SetIntervals
ENDCASE] _ [unknown[]];
ValuePtr: TYPE = REF Value;
ValueTailPtr: TYPE = REF ValueTail;

ScalarConstantValueTailPtr: TYPE = REF scalarConstant ValueTail; -- can be checked
ScalarConstantValuePtr: TYPE = REF Value; -- but this one just indicates our intentions

ScalarConstant: TYPE = RECORD [
value: PascalInteger _ 0, -- used only for non-real scalars, or subranges
translation: OutputQueuePtr _ NIL];


SetInterval: TYPE = RECORD [
next: SetIntervalPtr,
lower: ValuePtr,
rest:
SELECT case: * FROM singleton => NULL, interval => [upper: ValuePtr], ENDCASE];
SetIntervalPtr: TYPE = REF SetInterval;


DisplayEntry: TYPE = RECORD [
locals: IdentifierSetPtr,
formals:
SELECT formalSource: * FROM
call => [
programSegment: SegmentIdentifierPtr _ NIL, isp: IdentifierSetPtr],
with => [flp: FieldListPtr],
ENDCASE] _
[locals: NIL, formals: call[isp: NIL]];
DisplayEntryPtr: TYPE = REF DisplayEntry;

OutputQueue: TYPE = RECORD [
contents: ROPE _ NIL,
fileName: ROPE _ NIL --  NIL means that this Queue is purely temporary
];

OutputQueuePtr: TYPE = REF OutputQueue;

SourceFileSeqPtr: TYPE = REF SourceFileSeq;
SourceFileSeq: TYPE = RECORD [
next: SourceFileSeqPtr,
name: ROPE
];

TargetLanguage: TYPE = {mesa, longMesa, cedar};

ItemType: TYPE = {globalLabel, type, const, var, proc, main};




TranslateProgram: PROCEDURE;

TranslateBlock: PROCEDURE [position: Position];


TranslateConstantDeclaration: PROCEDURE [position: Position]
RETURNS [saySemiColon: BOOL _ TRUE];
TranslateTypeDeclaration: PROCEDURE [position: Position]
RETURNS [saySemiColon: BOOL _ TRUE];
TranslateVariableDeclaration: PROCEDURE [position: Position]
RETURNS [saySemiColon: BOOL _ TRUE];
TranslateProcedureDeclaration: PROCEDURE [position: Position, isFunction: BOOL];

TranslateProcedureCall: PROCEDURE [id: IdentifierPtr] RETURNS [ValuePtr];
ExtractResultType: PROCEDURE [id: IdentifierPtr] RETURNS [GeneralTypePtr];


Error: PROCEDURE [reason: Errors];

Warning: PROCEDURE [reason: Errors, extraInfo: ROPE _ NIL];

PasMesaError: ERROR [reason: ROPE];



TranslateVariable: PROCEDURE [isLHS: BOOL _ FALSE] RETURNS [ValuePtr];
ParseVariable: PROCEDURE [isLHS: BOOL _ FALSE] RETURNS [ValuePtr];

TranslateExpression: PROCEDURE [st: GeneralTypePtr _ nilGeneralTypePtr] RETURNS [ValuePtr];
ParseExpression: PROCEDURE [st: GeneralTypePtr _ nilGeneralTypePtr] RETURNS [ValuePtr];

ParseConstant: PROCEDURE RETURNS [ValuePtr];
ParseConstantExpression: PROCEDURE RETURNS [ValuePtr];

ParseCountableConstant: PROCEDURE RETURNS [ScalarConstantValuePtr];
ParseFiniteConstant: PROCEDURE RETURNS [ScalarConstantValuePtr];

CoerceToReal: PROCEDURE [vp: ValuePtr];
CoerceToLong: PROCEDURE [vp: ValuePtr];

ExpressStringConstant: PROCEDURE [v: ValuePtr, st: GeneralTypePtr];

ExtractTranslation: PROCEDURE [
v: ValuePtr, st: GeneralTypePtr _ nilGeneralTypePtr] RETURNS [OutputQueuePtr];

SayTranslation: PROCEDURE [v: ValuePtr, st: GeneralTypePtr _ nilGeneralTypePtr];



CreateIdentifierSet: PROCEDURE RETURNS [pset: IdentifierSetPtr];
InitIdentifierSet: PROCEDURE [pset: IdentifierSetPtr];
DisposeIdentifierSet: PROCEDURE [pset: IdentifierSetPtr];
EmptyIdentifierSet: PROCEDURE [pset: IdentifierSetPtr] RETURNS [BOOL];

EnumerateIdentifierSet: PROCEDURE [
pset: IdentifierSetPtr, p: PROCEDURE [IdentifierPtr]]; -- in insertion order

MergeIdentifierSets: PROCEDURE [
into: IdentifierSetPtr _ NIL, from: IdentifierSetPtr];

AssignTypeToIdSet: PROCEDURE [pset: IdentifierSetPtr, type: GeneralTypePtr];

NewIdent: PROCEDURE [
name: Name _ NIL,
pset: IdentifierSetPtr _ NIL] RETURNS [IdentifierPtr];

InsertOldIdent: PROCEDURE [
id: IdentifierPtr,
pset: IdentifierSetPtr];

IdentLookup: PROCEDURE [
name: Name _ NIL, pset: IdentifierSetPtr _ NIL, pfl: FieldListPtr _ NIL,
couldFail: BOOLEAN _ FALSE] RETURNS [IdentifierPtr];



InitializeStandards: PROCEDURE;

InitializeModules: PROCEDURE;
FinishModules: PROCEDURE;



CharToQueue: PROCEDURE [c: CHARACTER, q: OutputQueuePtr _ NIL];
CharToQueueStart: PROCEDURE [c: CHARACTER, q: OutputQueuePtr _ NIL];

StringToQueue: PROCEDURE [s: ROPE, q: OutputQueuePtr _ NIL];
StringToQueueStart: PROCEDURE [s: ROPE, q: OutputQueuePtr _ NIL];

MergeQueue: PROCEDURE [from: OutputQueuePtr, to: OutputQueuePtr _ NIL];
MergeQueueStart: PROCEDURE [from: OutputQueuePtr, to: OutputQueuePtr _ NIL];
CopyQueue: PROCEDURE [from: OutputQueuePtr, to: OutputQueuePtr _ NIL];

ClearQueue: PROCEDURE [q: OutputQueuePtr _ NIL];

BalanceQueue: PROCEDURE [q: OutputQueuePtr _ NIL];

PushOut: PROCEDURE [q: OutputQueuePtr _ NIL];

PopOut: PROCEDURE;

CopyAndPopOut: PROCEDURE RETURNS [OutputQueuePtr];



SourceFromStream: PROCEDURE [stream: STREAM, name: ROPE];

SourceFromNextStream: PROCEDURE; -- uses sourceFileSeq

InSymbol: PROCEDURE [stopAtCR: BOOLEAN _ FALSE];

StringToPascalInteger: PROCEDURE [s: ROPE] RETURNS [PascalInteger];

SayPascalInteger: PROCEDURE [i: PascalInteger];

NarrowPascalInteger: PROCEDURE [i: PascalInteger] RETURNS [NAT] =
INLINE {RETURN[i]};

PascalIntegerToCh: PROCEDURE [i: PascalInteger] RETURNS [CHARACTER] = INLINE {
RETURN[LOOPHOLE[Basics.LowByte[
Basics.LowHalf[LOOPHOLE[i,LONG CARDINAL]]], CHARACTER]]};

CouldBe: PROCEDURE [testSy: Symbol, string: ROPE _ NIL] RETURNS [BOOLEAN];

MustBe: PROCEDURE [testSy: Symbol, string: ROPE _ NIL, e: Errors];

SequenceOf: PROCEDURE [
p: PROCEDURE, separatorSy: Symbol _ semiColonSy,
separatorString: ROPE _ NIL];

RespondCh: PROCEDURE [c: CHARACTER] = INLINE {SayCh[c]; InSymbol[]};

SayCh: PROCEDURE [c: CHARACTER] = INLINE {CharToQueue[c]};

Respond: PROCEDURE [s: ROPE] = INLINE {Say[s]; InSymbol[]};

Say: PROCEDURE [s: ROPE] = INLINE {StringToQueue[s]};

SayIdent: PROCEDURE [s: ROPE _ NIL];

RopeSayIdent: PROCEDURE [s: ROPE _ NIL] RETURNS [r: ROPE];

SayLine: PROCEDURE [s: ROPE _ NIL] = INLINE {Say[s]; SayCh['\n]};



TranslateStandardProcedure: PROCEDURE [key: Standards];

TranslateStandardFunction: PROCEDURE [key: Standards] RETURNS [ValuePtr];



SayScalar: PROCEDURE [t: GeneralTypePtr, i: PascalInteger];
SayScalarAsInteger: PROCEDURE [t: GeneralTypePtr, i: PascalInteger];

SayType: PROCEDURE [gtp: GeneralTypePtr]; -- elaborates a type translation

SaySetType: PROCEDURE [t: TypePtr];

SaySetOriginOffset: PROCEDURE [baseType: GeneralTypePtr];

IsScalarType: PROCEDURE [gtp: GeneralTypePtr] RETURNS [BOOLEAN];
IsCountableType: PROCEDURE [gtp: GeneralTypePtr] RETURNS [BOOLEAN];
IsCountableHostType: PROCEDURE [gtp: GeneralTypePtr] RETURNS [BOOLEAN];
IsFiniteType: PROCEDURE [gtp: GeneralTypePtr] RETURNS [BOOLEAN];

GenScalarType: PROCEDURE [gtp: GeneralTypePtr] RETURNS [GeneralTypePtr];
GenCountableType: PROCEDURE [gtp: GeneralTypePtr] RETURNS [GeneralTypePtr];
GenCountableHostType: PROCEDURE [gtp: GeneralTypePtr] RETURNS [GeneralTypePtr];

GenFiniteType: PROCEDURE [gtp: GeneralTypePtr]
RETURNS [t: GeneralTypePtr, lower, upper: PascalInteger];

GetConcreteType: PROCEDURE [gtp: GeneralTypePtr] RETURNS [TypePtr];

GetScalarType: PROCEDURE [gtp: GeneralTypePtr] RETURNS [TypePtr] = INLINE {
RETURN[GetConcreteType[GenScalarType[gtp]]]};

GetCountableType: PROCEDURE [gtp: GeneralTypePtr] RETURNS [TypePtr] = INLINE {
RETURN[GetConcreteType[GenCountableType[gtp]]]};

GetCountableHostType: PROCEDURE [gtp: GeneralTypePtr] RETURNS [TypePtr] = INLINE
{RETURN[GetConcreteType[GenCountableHostType[gtp]]]};

GetFiniteType: PROCEDURE [gtp: GeneralTypePtr]
RETURNS [t: TypePtr, lower, upper: PascalInteger] = INLINE {
g: GeneralTypePtr;
[g, lower, upper] _ GenFiniteType[gtp];
t _ GetConcreteType[g]};

GetConcreteTypeOfValue: PROCEDURE [v: ValuePtr] RETURNS [TypePtr] = INLINE {
RETURN[GetConcreteType[gtp: v.type]]};

ConcreteValue: PROCEDURE [
t: TypePtr, translation: OutputQueuePtr _ NIL] RETURNS [ValuePtr] =
INLINE {
RETURN[NEW[Value_[type: t, 
value: NEW[ValueTail _[nonConstant[translation: translation]]]]]]};

LikeValue: PROCEDURE [
id: IdentifierPtr, translation: OutputQueuePtr _ NIL]
RETURNS [ValuePtr] = INLINE {
RETURN[NEW[Value_[type: id,
value: NEW[ValueTail _[nonConstant[translation: translation]]]]]]};

CheckForPascalString: PROCEDURE [t: GeneralTypePtr]
RETURNS [is: BOOLEAN, length: PascalInteger];

PowerSetOf: PROCEDURE [t: GeneralTypePtr] RETURNS [GeneralTypePtr];

IsTextFile: PROCEDURE [t: GeneralTypePtr] RETURNS [BOOLEAN];

TranslateIdList: PROCEDURE [pset: IdentifierSetPtr _ NIL];

TranslateVariableList: PROCEDURE [
pset: IdentifierSetPtr _ NIL, fwdOK: BOOLEAN _ FALSE];

TranslateType: PROCEDURE [id: IdentifierPtr _ NIL, fwdOK: BOOLEAN _ FALSE,
packArrays: BOOLEAN _ FALSE,
outerArrayIsFunny: ArrayDifferentlyMethod _ notAtAll] RETURNS [GeneralTypePtr];

DisposeType: PROCEDURE [gtp: GeneralTypePtr];


END. -- Pas




Pfile:  PasPrivate.mesa
modified by Ramshaw, January 20, 1984 2:35 pm
written by McCreight, September 15, 1980  1:51 PM
T Y P E S
This many characters of each identifier must be correct.  Characters beyond
this point are significant, but in a forgiving way. 
set element type: scalar (except real and integer), or subrange
index type: scalar (except real and integer), or subrange
identified tag field rules variant part
unidentified tag field rules variant part
tag type: scalar (except real and integer), or subrange
std may need unusual parsing, type returned by ParseStandardFunction
At present, non-local goto's may only go forward.
For cedar, the default array is allocated in the heap, and a specialArray goes
into the frame.  For mesa and longMesa, the default is frame and specialArrays
come from the heap.   A procArray is implemented as a procedure call.  A 
computedSeqArray is for arrays bigger than 64K 16-bit words, which cannot be
allocated by our current allocators.  PasMesa makes no attempt to allocate such an array.
And it uses a SEQUENCE COMPUTED CARDINAL to convince the compiler not to
try and do bounds checking.
An inlineProc turns into an INLINE, as you might expect. 
Although the following won't be checked by the compiler, they indicate
our intentions:
These, the compiler can check:
An IdentifierSet must support both alphabetic string equality searches
and enumeration in insertion order. The initial implementation of this
set is as a linked list.
A Destination is where our output should be going if we are modularizing
two possibilities will actually occur:
REF Identifier means "like the id's type"
REF Type means "a concrete type"
P R O C E D U R E S
** Implemented in PasBlock
** Implemented in PasDecl
** Implemented in PasErrs
** Implemented in PasExpr
Parsing something leaves the translated code in the Value
Translating it puts it in the output queue stack top
** Implemented in PasIdent
puts the "from" identifiers after the "into" identifiers
puts "like" types in all but the last-inserted identifier in the set
pset default is display[lexLevel].lid, the current local variables
inserts id at the end of pset
default is the entire display
** Implemented in PasInit
** Implemented in PasOut
** Implemented in PasScanner
results in PasVars.sy, PasVars.op, and PasVars.ident
copies the character to the current output queue
copies the string to the current output queue
says it, but avoids all Mesa reserved words by using lower case
just like SayIdent, except returns Rope instead of saying it
copies the string to the current output queue
** Implemented in PasStd
** Implemented in PasType
�Ê8˜Jš
œ™Jš
œ-™-Jš
œ1™1J˜š
Ïk	˜	Jšœ�œ˜ Jš�œ
�œ�œ˜Jšœ�œ�œ˜J˜J˜—Jšœ�œ
�œ
�œ	˜.˜Jš
�˜J˜Jš
œ	™	J˜Jš�œ�œ�œÏc˜7Jš�œ�œ�œ
�œ
˜J˜Jšœ�œ�œ
˜Jšœ�œ�œ
˜J˜Jšœ�œ˜J˜šœ�œ˜Jš
œK™KJš
œ4™4J˜—šœ�œž7˜IJ˜
J˜+J˜J˜JJ˜JJ˜GJ˜J˜LJš�œK˜NJ˜IJ˜J˜8J˜—Jšœ�œ!˜4Jšœ�œ ˜8Jšœ�œ˜6Jšœ�œ"˜9J˜Jšœ�œ�œ
�œ
˜5Jšœ�œ�œ
�œ
˜?Jšœ�œ�œ
�œ
˜=J˜šœ�œž˜ J˜
J˜IJ˜HJ˜GJ˜DJ˜KJ˜MJ˜3J˜—šœ
�œž˜$J˜
J˜MJ˜%J˜—šœ�œž˜%J˜
J˜JJ˜GJ˜MJ˜FJ˜KJ˜DJ˜GJ˜KJ˜?J˜HJ˜:J˜KJ˜FJ˜PJ˜—Jšœ�œ�œ˜J˜Jšœ
�œ�œ	˜"J˜Jšœ
�œž ˜AJ˜šœ�œ˜J˜iJ˜—šœ�œ�œ˜š�œ�˜Jšœ�œ
˜šœ
ž9˜CJ˜
Jšœ ž#˜CJšœ�œ
ž+˜:J˜—˜
Jšœž˜7J˜—Jšœ%ž˜DJ˜$Jš
œ?™?˜
Jšœ�œ�œ
˜Jšœ�œ�œž˜6Jšœž˜2J˜Jš
œ9™9J˜—˜Jšœž˜$J˜—˜Jšœž˜%—Jšœ�œ�œ˜B˜	Jšœ�œ�œ
˜Jšœ
�œ�œ
˜Jšœž˜7J˜—˜Jšœž&˜>J˜—Jš�œž˜J˜——Jšœ	�œ�œ˜Jšœ�œ�œ
˜&Jšœ�œ�œ˜*Jšœ�œ�œ˜(Jšœ�œ�œ˜$Jšœ�œ�œ˜$Jšœ�œ�œ˜,Jšœ�œ�œ˜:Jšœ�œ�œ
˜&Jšœ
�œ�œ˜"Jšœ�œ�œ˜,J˜šœ�œ�œ˜Jšœž˜,Jšœ�œž˜5˜š�œ�˜J˜-Jš
œ'™'J˜*Jš
œ)™)Jš
œ7™7Jš�œ˜———˜šœ�œ�œ
˜"J˜7——Jšœ�œ�œ˜#J˜šœ	�œ�œ˜Jšœž!˜:Jšœž˜7J˜—Jšœ�œ�œ	˜J˜šœ�œž3˜L˜VJ˜OJ˜——šœ�œ�œ˜Jšœž˜Jšœ�œž=˜OJšœž˜,J˜J˜—šœ�œ�œ˜šœ�œ�˜(Jšœ�œ
˜J˜FJšœ�œ
˜Jšœ�œ
˜J˜+˜˜š�œ
�˜J˜Jš
œD™DJšœ
�œ
˜˜
Jšœ	�œ�œ
˜Jšœ
�œ�œž˜3Jšœ�œ�œž˜2Jšœž˜0J˜—Jš�œ˜	———˜
šœ
�œ�œž0˜IJš
œ1™1—Jšœ�œ�œ
˜Jšœ�œ�œ
˜Jšœ�œ�˜J˜—˜Jšœž;˜VJšœž#˜@Jšœ�œ�œž/˜HJšœ
�œ�œž˜0J˜J˜—˜Jšœž;˜YJšœ ž#˜CJšœ*ž3˜]Jšœž˜:Jšœ�œ�œž/˜HJšœ�œ�œž˜/J˜J˜—˜J˜
J˜,J˜)J˜—šœž ˜2J˜
Jšœ'ž ˜GJšœ%ž%˜JJ˜—šœ
ž=˜GJ˜
Jšœ"ž˜>J˜—šœ
ž˜,J˜
Jšœž ˜6J˜—Jš�œž
˜#J˜——šœ�œ9˜UJš
œN™NJš
œN™NJš
œI™IJ™LJ™YJ™HJ™—šœ�œ˜5Jš
œ9™9J˜—Jšœ�œ�œ˜%Jšœ�œ�œ˜.J˜Jš
œF™FJš
œ™Jšœ�œ˜-Jšœ�œ˜-Jšœ�œ˜.Jšœ!�œ˜6Jšœ�œ˜,Jš
œ™Jšœ�œ�œ˜?Jšœ�œ�œ˜?Jšœ�œ�œ˜AJšœ%�œ�œ#˜RJšœ�œ�œ˜DJ˜J˜J˜Jš
œF™FJš
œF™FJš
œ™Jš
œ�œ�œ
�œ�œž˜FJšœ�œ�œ˜+J˜Jš
œH™Hšœ
�œ�œ˜J˜J˜—Jšœ�œ�œ
˜'J˜šœ�œ�œ
�œ
˜š
œ&™&Jš
œ)™)Jš
œ ™ —Jšœ$�œ
˜(J˜J˜—šœ�œ�œ˜J˜J˜—šœ�œ�œ˜š�œ�˜Jšœ�œ
˜˜)Jšœ�œ˜#—J˜&Jšœ�œž*˜GJšœ'ž˜AJš�œ˜——Jšœ
�œ�œ˜Jšœ�œ�œ˜#J˜Jšœ�œ�œž˜RJšœ�œ�œž-˜WJ˜šœ�œ�œ˜Jšœž/˜IJšœ�œ˜#J˜J˜—šœ
�œ�œ˜J˜J˜˜Jš�œ	�œ�œ!�œ˜O——Jšœ�œ�œ
˜'J˜J˜šœ�œ�œ˜J˜˜š�œ�˜˜	Jšœ'�œ˜C—J˜Jš�œ˜
——Jšœ	�œ�œ˜'—Jšœ�œ�œ˜)J˜šœ
�œ�œ˜Jšœ
�œ�œ
˜šœ
�œ�œ
ž1˜FJ˜J˜——Jšœ�œ�œ
˜'J˜Jšœ�œ�œ˜+šœ�œ�œ˜J˜Jšœ�˜
J˜J˜—Jšœ�œ˜/J˜Jšœ
�œ/˜=J˜Jš
œ™J˜J˜Jš
œ™J˜JšÏnœ�	œ
˜J˜JšŸœ�	œ˜/J˜Jš
œ™J˜šŸœ�	œ˜<Jš�œ�œ�œ˜$—šŸœ�	œ˜8Jš�œ�œ�œ˜$—šŸœ�	œ˜<Jš�œ�œ�œ˜$—JšŸœ�	œ"�œ˜PJ˜JšŸœ�	œ�œ˜IJšŸœ�	œ�œ˜JJ˜Jš
œ™J˜JšŸœ�	œ˜"J˜JšŸœ�	œ�œ�œ˜;J˜Jšœ�œ
�œ˜#J˜J˜Jš
œ™J˜Jš
Ÿœ�	œ	�œ�œ�œ˜FJš
Ÿ
œ�	œ	�œ�œ�œ˜BJš
œ9™9Jš
œ4™4J˜JšŸœ�	œ*�œ˜[JšŸœ�	œ*�œ˜WJ˜JšŸ
œ�	œ
�œ˜,JšŸœ�	œ
�œ˜6J˜JšŸœ�	œ
�œ˜CJšŸœ�	œ
�œ˜@J˜JšŸœ�	œ˜'JšŸœ�	œ˜'J˜JšŸœ�	œ#˜CJ˜šŸœ�	œ˜Jšœ5�œ˜NJ˜—JšŸœ�	œ7˜PJ˜J˜Jš
œ™J˜JšŸœ�	œ
�œ˜@JšŸœ�	œ˜6JšŸœ�	œ˜9JšŸœ�	œ�œ�œ˜FJ˜šŸœ�	œ˜#Jšœ�	œž˜LJ˜—šŸœ�	œ˜ Jšœ�œ˜6—Jš
œ8™8J˜JšŸœ�	œ0˜LJš
œD™DJ˜šŸœ�	œ˜Jšœ
�œ
˜Jšœ�œ�œ˜6—Jš
œB™BJ˜šŸœ�	œ˜J˜J˜—Jš
œ™J˜šŸœ�	œ˜Jšœ
�œ�œ�œ
˜HJšœ�œ�œ�œ˜4—Jš
œ™J˜J˜Jš
œ™J˜JšŸœ�	œ
˜J˜JšŸœ�	œ
˜JšŸ
œ�	œ
˜J˜J˜Jš
œ™J˜JšŸœ�	œ�	œ�œ˜?JšŸœ�	œ�	œ�œ˜DJ˜JšŸ
œ�	œ�œ�œ˜<JšŸœ�	œ�œ�œ˜AJ˜JšŸ
œ�	œ-�œ˜GJšŸœ�	œ-�œ˜LJšŸ	œ�	œ-�œ˜FJ˜JšŸ
œ�	œ�œ˜0J˜JšŸœ�	œ�œ˜2J˜JšŸœ�	œ�œ˜-J˜JšŸœ�	œ
˜J˜JšŸ
œ�	œ
�œ˜2J˜J˜Jš
œ™J˜JšŸœ�	œ
�œ�œ˜9J˜JšŸœ�	œž˜6J˜JšŸœ�	œ�œ�œ˜0Jš
œ4™4J˜JšŸœ�	œ�œ�œ˜CJ˜JšŸœ�	œ˜/J˜šŸœ�	œ�œ�œ˜AJš�œ�œ˜J˜—š
Ÿœ�	œ�œ�	œ�œ˜Nš�œ
�œ˜Jš	œ�œ�œ
�œ�	œ˜9—J˜—JšŸœ�	œ�œ�œ�œ�œ˜JJ˜JšŸœ�	œ�œ�œ
˜BJ˜šŸ
œ�	œ˜Jšœ�	œ$˜0Jšœ�œ�œ˜J˜—JšŸ	œ�	œ�	œ�œ˜DJ˜JšŸœ�	œ�	œ�œ˜:Jš
œ0™0J˜JšŸœ�	œ�œ�œ˜;J˜JšŸœ�	œ�œ�œ˜5Jš
œ-™-J˜JšŸœ�	œ�œ�œ˜$Jš
œ?™?J˜JšŸœ�	œ�œ�œ�œ�œ˜:Jš
œ<™<J˜Jš
Ÿœ�	œ�œ�œ�œ˜AJš
œ-™-J˜J˜Jš
œ™J˜JšŸœ�	œ˜7J˜JšŸœ�	œ�œ˜IJ˜J˜Jš
œ™J˜JšŸ	œ�	œ'˜;JšŸœ�	œ'˜DJ˜JšŸœ�	œž ˜JJ˜JšŸ
œ�	œ˜#J˜JšŸœ�	œ˜9J˜JšŸœ�	œ�œ�œ˜@JšŸœ�	œ�œ�œ˜CJšŸœ�	œ�œ�œ˜GJšŸœ�	œ�œ�œ˜@J˜JšŸ
œ�	œ�œ˜HJšŸœ�	œ�œ˜KJšŸœ�	œ�œ˜OJ˜šŸ
œ�	œ˜.Jš�œ2˜9J˜—JšŸœ�	œ�œ˜CJ˜šŸ
œ�	œ�œ
�œ˜KJš�œ'˜-J˜—šŸœ�	œ�œ
�œ˜NJš�œ*˜0J˜—šŸœ�	œ�œ
�˜PJšœ
�œ.˜5J˜—šŸ
œ�	œ˜.Jš�œ-�œ˜<J˜J˜'J˜J˜—šŸœ�	œ�œ
�œ˜LJš�œ ˜&J˜—šŸ
œ�	œ˜Jšœ*�œ�œ
˜CJš�œ˜š�œ
�œ˜Jšœ�œ9˜CJ˜——šŸ	œ�	œ˜Jšœ1�œ
˜5Jš�œ�œ˜š�œ
�œ˜Jšœ�œ9˜CJ˜——šŸœ�	œ˜3Jš�œ�œ˜-J˜—JšŸ
œ�	œ�œ˜CJ˜JšŸ
œ�	œ�œ�œ˜<J˜JšŸœ�	œ�œ˜:J˜šŸœ�	œ˜"Jšœ�œ	�œ�œ˜6J˜—š
Ÿ
œ�	œ�œ	�œ�œ
˜JJšœ�œ�œ
˜Jšœ�œ�œ�œ˜OJ˜—JšŸœ�	œ˜-J˜J˜Jš�œž˜J˜J˜J˜——…—Glfô