-- file Pass1.Mesa  For debugger
-- last modified by Bruce, October 17, 1980  11:32 AM
-- last modified by Satterthwaite, September 16, 1980  9:42 AM
-- last modified by Sweet, October 17, 1980  10:03 AM

DIRECTORY
  BcdDefs: TYPE USING [Link, EPIndex, GFTNull],
  ComData: TYPE USING [
    idANY, idATOM, idBOOL, idCARDINAL, idCHAR, idINT,
    idLOCK, idREAL, idSTRING, idUNWIND,
    outerCtx, seAnon, tC0, tC1,
    typeATOM, typeBOOL, typeCARDINAL, typeCHAR, typeCONDITION,
    typeINT, typeLOCK, typeREAL, typeSTRING, typeStringBody, typeTEXT],
  CompilerUtil USING [],
  LiteralOps: TYPE USING [Find],
  P1: TYPE USING [],
  Strings: TYPE USING [SubStringDescriptor],
  Symbols: TYPE USING [
    BitAddress, ByteLength, WordLength, SERecord,
    HTIndex, SEIndex, ISEIndex, CSEIndex, RecordSEIndex, CTXIndex,
    codeANY, codeINT, codeCHAR, typeANY, typeTYPE,
    HTNull, ISENull, RecordSENull, CTXNull, lZ, ctxType, seType],
  SymbolOps: TYPE USING [
    EnterExtension, EnterString, FillCtxSe, NewCtx, MakeNonCtxSe,
    MakeSeChain, NextSe],
  Table: TYPE USING [Base, Notifier, AddNotify, DropNotify],
  Tree: TYPE USING [Link, Null];
  
Pass1: PROGRAM
    IMPORTS
      LiteralOps, SymbolOps, Table, dataPtr: ComData
    EXPORTS CompilerUtil, P1 =
  BEGIN
  OPEN SymbolOps, Symbols;
  
-- symbol table bases
  seb: Table.Base;	-- semantic entry base
  ctxb: Table.Base;	-- context table base
  
  P1Notify: Table.Notifier = {seb _ base[seType]; ctxb _ base[ctxType]};
  
  
-- construction of predeclared symbols

  SubStringDescriptor: TYPE = Strings.SubStringDescriptor;
  
  MakeBasicType: PROC [code: [0..16), ordered: BOOLEAN, nBits: CARDINAL]
      RETURNS [sei: CSEIndex] = {
    sei _ MakeNonCtxSe[SIZE[basic cons SERecord]];
    seb[sei] _ [mark3: TRUE, mark4: TRUE,
	body: cons[basic[ordered:ordered, code:code, length:nBits]]];
    RETURN};
    
  MakeRecordType: PROC [nBits: CARDINAL, default: BOOLEAN]
      RETURNS [rSei: RecordSEIndex] = {
    rSei _ LOOPHOLE[MakeNonCtxSe[SIZE[notLinked record cons SERecord]]];
    seb[rSei] _ [mark3: TRUE, mark4: TRUE,
	body: cons[record[
		machineDep: TRUE,
		argument: FALSE,  monitored: FALSE, painted: TRUE,
		hints: [
		  comparable: FALSE, assignable: FALSE,
		  variant: FALSE, unifield: FALSE, privateFields: FALSE,
		  refField: FALSE, default: default, voidable: ~default],
		fieldCtx: NewCtx[lZ],
		length: nBits,
		linkPart: notLinked[]]]];
    RETURN};
    
  MakeRefType: PROC [refType: SEIndex] RETURNS [sei: CSEIndex] = {
    sei _ MakeNonCtxSe[SIZE[ref cons SERecord]];
    seb[sei] _ [mark3: TRUE, mark4: TRUE,
	body: cons[ref[
		counted: FALSE, ordered: FALSE, list: FALSE, basing: FALSE,
		readOnly: FALSE,
		refType: refType]]];
    RETURN};
    
  MakeSubrangeType: PROC [origin: INTEGER, range: CARDINAL, empty: BOOLEAN]
      RETURNS [sei: CSEIndex] = {
    sei _ MakeNonCtxSe[SIZE[subrange cons SERecord]];
    seb[sei] _ [mark3: TRUE, mark4: TRUE,
	body: cons[subrange[
		filled: TRUE, empty: empty,
		rangeType: dataPtr.idINT,
		origin: origin,  range: range]]];
    RETURN};
    
    
  SetIdAttr: PROC [sei: ISEIndex, const: BOOLEAN] = {
    seb[sei].immutable _ seb[sei].constant _ const;
    seb[sei].extended _ seb[sei].public _ seb[sei].linkSpace _ FALSE;
    seb[sei].mark3 _ seb[sei].mark4 _ TRUE};
    
  FillVariable: PROC [
      sei: ISEIndex, name: STRING, type: SEIndex, offset: BitAddress, nBits: CARDINAL] = {
    desc: SubStringDescriptor;
    hti: HTIndex;
    IF name # NIL
      THEN {desc _ [base:name, offset:0, length:name.length]; hti _ EnterString[@desc]}
      ELSE hti _ HTNull;
    FillCtxSe[sei, hti, FALSE];
    seb[sei].idType _ type;  seb[sei].idValue _ offset;  seb[sei].idInfo _ nBits;
    SetIdAttr[sei, FALSE]};
    
  FillConstant: PROC [sei: ISEIndex, name: STRING, type: SEIndex, value: WORD] = {
    desc: SubStringDescriptor _ [base:name, offset:0, length:name.length];
    FillCtxSe[sei, EnterString[@desc], FALSE];
    seb[sei].idType _ type;  seb[sei].idInfo _ 0;  seb[sei].idValue _ value;
    SetIdAttr[sei, TRUE]};
    
  FillNamedType: PROC [sei: ISEIndex, s: STRING, type: SEIndex] = {
    desc: SubStringDescriptor _ [base:s, offset:0, length:s.length];
    FillCtxSe[sei, EnterString[@desc], FALSE];  SetIdAttr[sei, TRUE];
    seb[sei].idType _ typeTYPE;  seb[sei].idInfo _ type;  seb[sei].idValue _ Tree.Null;
    SetIdAttr[sei, TRUE]};
    
  MakeTreeLiteral: PROC [val: WORD] RETURNS [Tree.Link] = {
    RETURN [[literal[info:[word[LiteralOps.Find[val]]]]]]};
    
    
  NOuterSymbols: CARDINAL = 20;	-- number of predeclared ids (outer level only)
  
  
  PrefillSymbols: PUBLIC PROC = { 
    OPEN dataPtr;
    tSei: CSEIndex;
    rSei: RecordSEIndex;
    tCtx: CTXIndex;
    sei, seChain: ISEIndex;
    
    outerChain: ISEIndex;
    NextOuterSe: PROC RETURNS [next: ISEIndex] = {
      IF outerChain = ISENull THEN ERROR;
      next _ outerChain;  outerChain _ NextSe[outerChain];  RETURN};
      
    idNAT: ISEIndex;
    Table.AddNotify[P1Notify];
    tSei _ MakeBasicType[codeANY, TRUE, WordLength];	-- guaranteed position
    outerCtx _ NewCtx[lZ];
    outerChain _ ctxb[outerCtx].seList _ MakeSeChain[outerCtx, NOuterSymbols, FALSE];
    -- make some constants
      {tC0 _ MakeTreeLiteral[0]; tC1 _ MakeTreeLiteral[1]};
      
    idANY _ NextOuterSe[];
      FillNamedType[idANY, "UNSPECIFIED"L, tSei];
      IF tSei # typeANY THEN ERROR;
    idINT _ NextOuterSe[];  typeINT _ MakeBasicType[codeINT, TRUE, WordLength];
      FillNamedType[idINT, "INTEGER"L, typeINT];
    idCHAR _ NextOuterSe[];  typeCHAR _ MakeBasicType[codeCHAR, TRUE, ByteLength];
      FillNamedType[idCHAR, "CHARACTER"L, typeCHAR];
    idBOOL _ NextOuterSe[];
      typeBOOL _ MakeNonCtxSe[SIZE[enumerated cons SERecord]];
      tCtx _ NewCtx[lZ];
      seb[typeBOOL] _ [mark3: TRUE, mark4: TRUE,
	body: cons[enumerated[
		ordered: TRUE, machineDep: TRUE, sparse: FALSE,
		valueCtx: tCtx, nValues: 2]]];
      ctxb[tCtx].seList _ seChain _ MakeSeChain[tCtx, 2, FALSE];
      FillConstant[seChain, "FALSE"L, idBOOL, 0];  seChain _ NextSe[seChain];
      FillConstant[seChain, "TRUE"L, idBOOL, 1];
      FillNamedType[idBOOL, "BOOLEAN"L, typeBOOL];
    idCARDINAL _ NextOuterSe[];
      typeCARDINAL _ MakeSubrangeType[0, 177777B, FALSE];
      FillNamedType[idCARDINAL, "CARDINAL"L, typeCARDINAL];
    FillNamedType[NextOuterSe[], "WORD"L, typeCARDINAL];
    idREAL _ NextOuterSe[];
      typeREAL _ MakeNonCtxSe[SIZE[real cons SERecord]];
      seb[typeREAL] _ [mark3:TRUE, mark4:TRUE, body:cons[real[rangeType:idINT]]];
      FillNamedType[idREAL, "REAL"L, typeREAL];
    idNAT _ sei _ NextOuterSe[];	-- NAT
      FillNamedType[sei, "***"L, MakeSubrangeType[0, 77777B, FALSE]];
    sei _ NextOuterSe[];	-- TEXT
      typeTEXT _ rSei _ MakeRecordType[nBits:2*WordLength, default:TRUE];
      seb[rSei].hints.variant _ TRUE;
      tCtx _ seb[rSei].fieldCtx; ctxb[tCtx].seList _ seChain _ MakeSeChain[tCtx, 2, FALSE];
      FillVariable[seChain, "length"L, idNAT, [wd:0, bd:0], WordLength];
	EnterExtension[seChain, default, tC0];
      seChain _ NextSe[seChain];
	BEGIN
	tag: ISEIndex = MakeSeChain[CTXNull, 1, FALSE];
	seqSei: CSEIndex = MakeNonCtxSe[SIZE[sequence cons SERecord]];
	FillVariable[tag, "maxLength"L, idNAT, [wd:1, bd:0], WordLength];
	  seb[tag].immutable _ TRUE;
	seb[seqSei] _ [mark3: TRUE, mark4: TRUE,
	    body: cons[sequence[
		packed: TRUE, machineDep: TRUE,
		controlled: TRUE, tagSei: tag,
		componentType: idCHAR]]];
	FillVariable[seChain, "text"L, seqSei, [wd:1, bd:0], WordLength];
	END;
      FillNamedType[sei, "TEXT"L, rSei];
    idSTRING _ NextOuterSe[];
    sei _ NextOuterSe[];	-- StringBody
      typeStringBody _ rSei _ MakeRecordType[nBits:2*WordLength, default:TRUE];
      seb[rSei].hints.assignable _ TRUE;	-- compatibility
      tCtx _ seb[rSei].fieldCtx; ctxb[tCtx].seList _ seChain _ MakeSeChain[tCtx, 3, FALSE];
      FillVariable[seChain, "length"L, idCARDINAL, [wd:0, bd:0], WordLength];
	EnterExtension[seChain, default, tC0];
      seChain _ NextSe[seChain];
      FillVariable[seChain, "maxlength"L, idCARDINAL, [wd:1, bd:0], WordLength];
	seb[seChain].immutable _ TRUE;
      seChain _ NextSe[seChain];
      tSei _ MakeNonCtxSe[SIZE[array cons SERecord]];
      seb[tSei] _ [mark3: TRUE, mark4: TRUE,
	body: cons[array[
		packed: TRUE,
		indexType: MakeSubrangeType[0, 0, TRUE],
		componentType: idCHAR]]];
      FillVariable[seChain, "text"L, tSei, [wd:2, bd:0], 0];
      FillNamedType[sei, "StringBody"L, rSei];  typeSTRING _ MakeRefType[sei];
      FillNamedType[idSTRING, "STRING"L, typeSTRING];
    idLOCK _ NextOuterSe[];
      rSei _ MakeRecordType[nBits:WordLength, default:TRUE];
      tCtx _ seb[rSei].fieldCtx; ctxb[tCtx].seList _ seChain _ MakeSeChain[tCtx, 1, FALSE];
      FillVariable[seChain, NIL, idANY, [wd:0, bd:0], WordLength];
	EnterExtension[seChain, default, MakeTreeLiteral[100000B]];
      FillNamedType[idLOCK, "MONITORLOCK"L, rSei];  typeLOCK _ rSei;
    sei _ NextOuterSe[];	-- CONDITION
      rSei _ MakeRecordType[nBits:2*WordLength, default:TRUE];
      typeCONDITION _ rSei;
      tCtx _ seb[rSei].fieldCtx; ctxb[tCtx].seList _ seChain _ MakeSeChain[tCtx, 2, FALSE];
      FillVariable[seChain, "timeout"L, idCARDINAL, [wd:1, bd:0], WordLength];
	EnterExtension[seChain, default, MakeTreeLiteral[100]];
      seChain _ NextSe[seChain];
      FillVariable[seChain, NIL, idANY, [wd:0, bd:0], WordLength];
	EnterExtension[seChain, default, tC0];
      FillNamedType[sei, "CONDITION"L, rSei];  typeCONDITION _ rSei;
    sei _ NextOuterSe[];	-- MDSZone
      tSei _ MakeNonCtxSe[SIZE[zone cons SERecord]];
      seb[tSei] _ [mark3:TRUE, mark4:TRUE, body:cons[zone[counted:FALSE, mds:TRUE]]];
      FillNamedType[sei, "MDSZone"L, tSei];
    idATOM _ sei _ NextOuterSe[];
      tSei _ MakeNonCtxSe[SIZE[opaque cons SERecord]];
      seb[tSei] _ [mark3: TRUE, mark4: TRUE,
	body: cons[opaque[
	  id: NextSe[sei],	-- seAnon
	  length: 0, lengthKnown: FALSE]]];
      tSei _ MakeRefType[tSei];
      typeATOM _ MakeNonCtxSe[SIZE[long cons SERecord]];
      seb[typeATOM] _ [mark3: TRUE, mark4: TRUE, body: cons[long[rangeType: tSei]]];
      FillNamedType[idATOM, "****"L, typeATOM]; -- so you can't say ATOM
    seAnon _ NextOuterSe[];
      FillVariable[seAnon, "?"L,  typeANY, [wd:0, bd:0], WordLength];
    FillConstant[NextOuterSe[], "TRUE"L, idBOOL, 1];	-- TRUE
    FillConstant[NextOuterSe[], "FALSE"L, idBOOL, 0];	-- FALSE
    idUNWIND _ NextOuterSe[];
      tSei _ MakeNonCtxSe[SIZE[transfer cons SERecord]];
      seb[tSei] _ [mark3: TRUE, mark4: TRUE,
	body: cons[transfer[mode:error, inRecord:RecordSENull, outRecord:RecordSENull]]];
      FillConstant[idUNWIND, "UNWIND"L, tSei,
	    LOOPHOLE[BcdDefs.Link[procedure[gfi:BcdDefs.GFTNull, ep:1, tag:TRUE]]]];
    FillConstant[NextOuterSe[], "ABORTED"L, tSei,
	    LOOPHOLE[BcdDefs.Link[procedure[gfi:BcdDefs.GFTNull, ep:2, tag:TRUE]]]];
	    
    IF outerChain # ISENull THEN ERROR;
    Table.DropNotify[P1Notify]};
    
    
  LockId: PUBLIC PROC RETURNS [HTIndex] = {
    desc: SubStringDescriptor _ [base:"LOCK"L, offset:0, length:("LOCK"L).length];
    RETURN [EnterString[@desc]]};
    
    
    
  EnterHashMark: PROC = INLINE {
    -- marks end of symbols from source file in hash table
    desc: SubStringDescriptor _ [base:"  "L, offset:1, length:0];
    [] _ EnterString[@desc]};
    
    
END.