-- RTWalkSymbolsImpl.mesa
-- Last Modified On July 6, 1983 12:29 pm by Paul Rovner

DIRECTORY
  BcdDefs USING [VersionStamp],
  BrandXSymbolDefs USING[SymbolTableBase, SymbolIndex, SymbolIdIndex,
                                 symbolIndexForTYPE, SymbolRecordIndex, SymbolContextIndex,
                                 nullHandle, nullModuleIndex, ExtensionClass, TreeLink,
                                 rootBodyIndex, nullBodyIndex],
  BrandYSymbolDefs USING[SymbolTableBase, SymbolIndex, SymbolIdIndex,
                                 symbolIndexForTYPE, SymbolRecordIndex, SymbolContextIndex,
                                 nullHandle, nullModuleIndex, ExtensionClass, TreeLink,
                                 rootBodyIndex, nullBodyIndex],
  ConvertUnsafe USING[SubString, SubStringToRope],
  PrincOps USING[EPRange, MaxNGfi],
  Rope USING[ROPE],
  RTSymbolDefs USING[SymbolTableBase, SymbolIndex, SymbolContextIndex,
                           SymbolIdIndex, SymbolRecordIndex, SymbolNameIndex, nullXSymbolIndex,
                           nullYSymbolIndex, nullXSymbolNameIndex, nullYSymbolNameIndex,
                           nullXSymbolContextIndex, nullYSymbolContextIndex,
                           SymbolConstructorIndex, SymbolTableHandle, SymbolModuleIndex,
                           ExtensionClass, TreeLink, BodyIndex, BlockContextLevel,
                           CallableBodyIndex],
  RTSymbolOps USING[Xfm],
  RTSymbols USING[Outer];

RTWalkSymbolsImpl: PROGRAM
  IMPORTS ConvertUnsafe, RTSymbols
  EXPORTS RTSymbolOps

= BEGIN OPEN bx: BrandXSymbolDefs, by: BrandYSymbolDefs, Rope, RTSymbolDefs, RTSymbols;

--Procedures--

IsRC: PUBLIC PROC[stb: SymbolTableBase,
                       seIndex: SymbolIndex,
                       checkCommon: BOOL _ TRUE]
        RETURNS[BOOL] =
  {WITH stb SELECT FROM
      t: SymbolTableBase.x =>
              RETURN[IsRCX[t.e, NARROW[seIndex, SymbolIndex.x].e, checkCommon]];
      t: SymbolTableBase.y =>
              RETURN[IsRCY[t.e, NARROW[seIndex, SymbolIndex.y].e, checkCommon]];
     ENDCASE => ERROR};

IsRCX: PROC[stb: bx.SymbolTableBase, seIndex: bx.SymbolIndex, checkCommon: BOOL _ TRUE]
        RETURNS[BOOL] =
{ WITH cr: stb.seb[stb.UnderType[seIndex]] SELECT FROM
    record =>
      { rcP: PROC[stb: SymbolTableBase, isei: SymbolIdIndex] RETURNS[stop: BOOL] =
        { sei: bx.SymbolIndex _ NARROW[ISEType[stb, isei], SymbolIndex.x].e;
          nstb: bx.SymbolTableBase _ NARROW[stb, SymbolTableBase.x].e;
          WITH cse1: nstb.seb[nstb.UnderType[sei]] SELECT FROM
            union =>
                  {urcP: PROC[stb: SymbolTableBase, isei: SymbolIdIndex]
                          RETURNS[stop: BOOL _ FALSE] =
                        {stop _ IsRC[stb, LOOPHOLE[isei], FALSE]};
                   tagCardinality: CARDINAL _ nstb.Cardinality[nstb.seb[cse1.tagSei].idType];
                   RETURN[EnumerateCtxIseis[stb, [x[cse1.caseCtx]], urcP,
                                                   (tagCardinality = nstb.CtxEntries[cse1.caseCtx])]]};
            sequence => IF IsRC[stb, [x[cse1.componentType]]]
                            THEN RETURN[TRUE]; -- here 'tis
           ENDCASE => IF IsRC[stb, [x[sei]]] THEN RETURN[TRUE]; -- stop looking. This is it
          RETURN[FALSE]};  -- end rcP

        IF checkCommon
         THEN RETURN[cr.hints.refField] -- easy if the common parts are to be included
         ELSE RETURN[EnumerateCtxIseis[[x[stb]], [x[cr.fieldCtx]], rcP]]};
                             -- look individually at the fields
    sequence, union => ERROR;
    transfer => RETURN[FALSE];  -- NOTE for now
    relative => RETURN[FALSE];  -- NOTE for now
    long => RETURN[WITH rse: stb.seb[stb.UnderType[cr.rangeType] ] SELECT FROM
                          ref => rse.counted,
                         ENDCASE => FALSE];
    zone => RETURN[cr.counted];
    array => RETURN[IsRC[[x[stb]], [x[cr.componentType]]]];
    ENDCASE => RETURN[FALSE]};

IsRCY: PROC[stb: by.SymbolTableBase, seIndex: by.SymbolIndex, checkCommon: BOOL _ TRUE]
        RETURNS[BOOL] =
{ WITH cr: stb.seb[stb.UnderType[seIndex]] SELECT FROM
    record =>
      { rcP: PROC[stb: SymbolTableBase, isei: SymbolIdIndex] RETURNS[stop: BOOL] =
        { sei: bx.SymbolIndex _ NARROW[ISEType[stb, isei], SymbolIndex.y].e;
          nstb: bx.SymbolTableBase _ NARROW[stb, SymbolTableBase.y].e;
          WITH cse1: nstb.seb[nstb.UnderType[sei]] SELECT FROM
            union =>
                  {urcP: PROC[stb: SymbolTableBase, isei: SymbolIdIndex]
                          RETURNS[stop: BOOL _ FALSE] =
                        {stop _ IsRC[stb, LOOPHOLE[isei], FALSE]};
                   tagCardinality: CARDINAL _ nstb.Cardinality[nstb.seb[cse1.tagSei].idType];
                   RETURN[EnumerateCtxIseis[stb, [y[cse1.caseCtx]], urcP,
                                                   (tagCardinality = nstb.CtxEntries[cse1.caseCtx])]]};
            sequence => IF IsRC[stb, [y[cse1.componentType]]]
                            THEN RETURN[TRUE]; -- here 'tis
           ENDCASE => IF IsRC[stb, [y[sei]]] THEN RETURN[TRUE]; -- stop looking. This is it
          RETURN[FALSE]};  -- end rcP

        IF checkCommon
         THEN RETURN[cr.hints.refField] -- easy if the common parts are to be included
         ELSE RETURN[EnumerateCtxIseis[[y[stb]], [y[cr.fieldCtx]], rcP]]};
                             -- look individually at the fields
    sequence, union => ERROR;
    transfer => RETURN[FALSE];  -- NOTE for now
    relative => RETURN[FALSE];  -- NOTE for now
    long => RETURN[WITH rse: stb.seb[stb.UnderType[cr.rangeType] ] SELECT FROM
                          ref => rse.counted,
                         ENDCASE => FALSE];
    zone => RETURN[cr.counted];
    array => RETURN[IsRC[[y[stb]], [y[cr.componentType]]]];
    ENDCASE => RETURN[FALSE]};

IsUnion: PUBLIC PROC [stb: SymbolTableBase, seIndex: SymbolIndex]
      RETURNS[BOOL] =
  {WITH stb SELECT FROM
      t: SymbolTableBase.x =>
          RETURN[t.e.seb[t.e.UnderType[NARROW[seIndex, SymbolIndex.x].e]].typeTag = union];
      t: SymbolTableBase.y =>
          RETURN[t.e.seb[t.e.UnderType[NARROW[seIndex, SymbolIndex.y].e]].typeTag = union];
     ENDCASE => ERROR};

IsSequence: PUBLIC PROC [stb: SymbolTableBase, seIndex: SymbolIndex]
      RETURNS[BOOL] =
  {WITH stb SELECT FROM
      t: SymbolTableBase.x =>
        RETURN[t.e.seb[t.e.UnderType[NARROW[seIndex, SymbolIndex.x].e]].typeTag = sequence];
      t: SymbolTableBase.y =>
        RETURN[t.e.seb[t.e.UnderType[NARROW[seIndex, SymbolIndex.y].e]].typeTag = sequence];
     ENDCASE => ERROR};

EnumerateRecordIseis: PUBLIC PROC
              [ stb: SymbolTableBase,
                rsei: SymbolRecordIndex,
                p: PROC[stb: SymbolTableBase, isei: SymbolIdIndex] RETURNS[stop: BOOL],
                level: CARDINAL _ 0] 
        RETURNS [stopped: BOOL] =
{ proc: PROC[stb: SymbolTableBase, isei: SymbolIdIndex] RETURNS[stop: BOOL] =
        { sei: SymbolIndex _ ISEType[stb, isei];
          IF NOT (IsUnion[stb, sei] OR IsSequence[stb, sei]) OR level = 0
           THEN RETURN[p[stb, isei]];
          RETURN[FALSE]};

  IF NullISEI[LOOPHOLE[rsei]] THEN RETURN[FALSE];
  WITH stb SELECT FROM
      t: SymbolTableBase.x =>
            {WITH lrc: t.e.seb[NARROW[rsei, SymbolRecordIndex.x].e] SELECT FROM
                linked =>
                     { stopped _ EnumerateRecordIseis
                                                  [stb,
                                                   [x[LOOPHOLE[t.e.UnderType[lrc.linkType],
                                                                    bx.SymbolRecordIndex]]],
                                                   p,
                                                   level + 1];
                       IF stopped THEN RETURN[TRUE]};
               ENDCASE;
              RETURN[EnumerateCtxIseis
                             [stb,
                              [x[t.e.seb[NARROW[rsei, SymbolRecordIndex.x].e].fieldCtx]],
                              proc]];
             };
      t: SymbolTableBase.y =>
            {WITH lrc: t.e.seb[NARROW[rsei, SymbolRecordIndex.y].e] SELECT FROM
                 linked =>
                    { stopped _ EnumerateRecordIseis
                                                  [stb,
                                                   [y[LOOPHOLE[t.e.UnderType[lrc.linkType],
                                                                    by.SymbolRecordIndex]]],
                                                   p,
                                                   level + 1];
                      IF stopped THEN RETURN[TRUE]};
                ENDCASE;
              RETURN[EnumerateCtxIseis
                             [stb,
                              [y[t.e.seb[NARROW[rsei, SymbolRecordIndex.y].e].fieldCtx]],
                              proc]];
             };
     ENDCASE => ERROR};

  -- copied in RCMapBuilderImpl
EnumerateCtxIseis: PUBLIC PROC
        [stb: SymbolTableBase,
         ctx: SymbolContextIndex,
         proc: PROC[stb: SymbolTableBase, isei: SymbolIdIndex] RETURNS[stop: BOOL],
         reallyComplete: BOOL _ FALSE]
      RETURNS[stopped: BOOL]  =
{ isei: SymbolIdIndex;
  IF NullCtx[ctx] THEN RETURN[FALSE];
  IF NOT reallyComplete THEN
  { WITH stb SELECT FROM
      t: SymbolTableBase.x =>
               WITH c: t.e.ctxb[NARROW[ctx, SymbolContextIndex.x].e] SELECT FROM
                included => 
                  IF ~c.complete THEN
                  {  p: PROC[base: SymbolTableBase] =  -- called once
                          {stopped _ EnumerateCtxIseis[base, [x[c.map]], proc]};
                      Outer[stb, [x[c.module]], p];
                      RETURN[stopped];
                  };
                simple => NULL;
               ENDCASE => ERROR;
      t: SymbolTableBase.y =>
               WITH c: t.e.ctxb[NARROW[ctx, SymbolContextIndex.y].e] SELECT FROM
                included => 
                  IF ~c.complete THEN
                  {  p: PROC[base: SymbolTableBase] =  -- called once
                          {stopped _ EnumerateCtxIseis[base, [y[c.map]], proc]};
                      Outer[stb, [y[c.module]], p];
                      RETURN[stopped];
                  };
                simple => NULL;
               ENDCASE => ERROR;
     ENDCASE => ERROR;
  };
  FOR isei _ FirstCtxSe[stb, ctx], NextSe[stb, isei] UNTIL NullISEI[isei]
    DO IF NullName[ISEName[stb, isei]] AND NullCtx[ISECtx[stb, isei]]
          THEN LOOP;  -- padding
        IF proc[stb, isei] THEN RETURN[TRUE];
   ENDLOOP;
  RETURN[FALSE]};

CountComponents: PUBLIC PROC [stb: SymbolTableBase, rsei: SymbolRecordIndex] 
        RETURNS [n: NAT] =
    { n _ CountCommonComponents[stb, rsei];
      IF RSEVariant[stb, rsei] THEN n _ n + 1};

CountCommonComponents: PROC [stb: SymbolTableBase, rsei: SymbolRecordIndex]
      RETURNS [n: CARDINAL] =
    { count: PROC[stb: SymbolTableBase, isei: SymbolIdIndex] RETURNS[stop: BOOL] =
        { sei: SymbolIndex _ ISEType[stb, isei];
          IF NOT (IsUnion[stb, sei] OR IsSequence[stb, sei]) THEN n _ n + 1;
          RETURN[FALSE];  -- keep counting
        };
      n _ 0;
      [] _ EnumerateRecordIseis[stb, rsei, count]};

  -- peel layers of id until the last one before either the underlying cons or a change of name
  -- or a specification of default initialization
PeelAllButLast: PUBLIC PROC [stb: SymbolTableBase, isei: SymbolIdIndex]
      RETURNS[SymbolIdIndex] =
  { WITH stb SELECT FROM
      t: SymbolTableBase.x => RETURN[PeelAllButLastX[t.e, NARROW[isei, SymbolIdIndex.x].e]];
      t: SymbolTableBase.y => RETURN[PeelAllButLastY[t.e, NARROW[isei, SymbolIdIndex.y].e]];
     ENDCASE => ERROR};

PeelAllButLastX: PROC [stb: bx.SymbolTableBase, isei: bx.SymbolIdIndex]
      RETURNS[SymbolIdIndex] =
  { FOR sei: bx.SymbolIndex _ stb.seb[isei].idInfo, stb.seb[isei].idInfo
     UNTIL stb.seb[isei].extended  -- i.e. isei has default initialization specified
     DO
       WITH se: stb.seb[sei] SELECT FROM
         id => IF se.idType # bx.symbolIndexForTYPE THEN ERROR
                ELSE IF stb.seb[isei].hash # stb.seb[LOOPHOLE[sei, bx.SymbolIdIndex]].hash
                       THEN EXIT
                ELSE isei _ LOOPHOLE[sei, bx.SymbolIdIndex];
         cons =>  EXIT;
        ENDCASE =>  ERROR;
     ENDLOOP;
    RETURN[[x[isei]]]};

PeelAllButLastY: PROC [stb: by.SymbolTableBase, isei: by.SymbolIdIndex]
      RETURNS[SymbolIdIndex] =
  { FOR sei: by.SymbolIndex _ stb.seb[isei].idInfo, stb.seb[isei].idInfo
     UNTIL stb.seb[isei].extended  -- i.e. isei has default initialization specified
     DO
       WITH se: stb.seb[sei] SELECT FROM
         id => IF se.idType # by.symbolIndexForTYPE THEN ERROR
                ELSE IF stb.seb[isei].hash # stb.seb[LOOPHOLE[sei, by.SymbolIdIndex]].hash
                       THEN EXIT
                ELSE isei _ LOOPHOLE[sei, by.SymbolIdIndex];
         cons =>  EXIT;
        ENDCASE =>  ERROR;
     ENDLOOP;
    RETURN[[y[isei]]]};

SEUnderType: PUBLIC PROC[stb: SymbolTableBase, sei: SymbolIndex]
      RETURNS[SymbolConstructorIndex] =
  {WITH stb SELECT FROM
      t: SymbolTableBase.x => RETURN[[x[t.e.UnderType[NARROW[sei, SymbolIndex.x].e]]]];
      t: SymbolTableBase.y => RETURN[[y[t.e.UnderType[NARROW[sei, SymbolIndex.y].e]]]];
     ENDCASE => ERROR;
  };

ISEType: PUBLIC PROC[stb: SymbolTableBase, isei: SymbolIdIndex] RETURNS[SymbolIndex] =
  {WITH stb SELECT FROM
      t: SymbolTableBase.x => RETURN[[x[t.e.seb[NARROW[isei, SymbolIdIndex.x].e].idType]]];
      t: SymbolTableBase.y => RETURN[[y[t.e.seb[NARROW[isei, SymbolIdIndex.y].e].idType]]];
     ENDCASE => ERROR;
  };

BodyType: PUBLIC PROC[stb: SymbolTableBase, bti: BodyIndex] RETURNS[SymbolIndex] =
  {WITH stb SELECT FROM
      t: SymbolTableBase.x => RETURN[[x[t.e.bb[NARROW[bti, BodyIndex.x].e].type]]];
      t: SymbolTableBase.y => RETURN[[y[t.e.bb[NARROW[bti, BodyIndex.y].e].type]]];
     ENDCASE => ERROR;
  };

CallableBodyEntryIndex: PUBLIC PROC[stb: SymbolTableBase, cbti: CallableBodyIndex]
      RETURNS[[0..PrincOps.EPRange*PrincOps.MaxNGfi)] =
  {WITH stb SELECT FROM
      t: SymbolTableBase.x => RETURN[t.e.bb[NARROW[cbti, CallableBodyIndex.x].e].entryIndex];
      t: SymbolTableBase.y => RETURN[t.e.bb[NARROW[cbti, CallableBodyIndex.y].e].entryIndex];
     ENDCASE => ERROR;
  };

SEBitsForType: PUBLIC PROC[stb: SymbolTableBase, sei: SymbolIndex]
      RETURNS[INT] =
  {WITH stb SELECT FROM
      t: SymbolTableBase.x => RETURN[t.e.BitsForType[NARROW[sei, SymbolIndex.x].e]];
      t: SymbolTableBase.y => RETURN[t.e.BitsForType[NARROW[sei, SymbolIndex.y].e]];
     ENDCASE => ERROR;
  };

IDCardinalValue: PUBLIC PROC[stb: SymbolTableBase, isei: SymbolIdIndex]
      RETURNS[CARDINAL] =
  {WITH stb SELECT FROM
      t: SymbolTableBase.x => RETURN[t.e.seb[NARROW[isei, SymbolIdIndex.x].e].idValue];
      t: SymbolTableBase.y => RETURN[t.e.seb[NARROW[isei, SymbolIdIndex.y].e].idValue];
     ENDCASE => ERROR;
  };

IDCardinalInfo: PUBLIC PROC[stb: SymbolTableBase, isei: SymbolIdIndex]
      RETURNS[CARDINAL] =
  {WITH stb SELECT FROM
      t: SymbolTableBase.x => RETURN[t.e.seb[NARROW[isei, SymbolIdIndex.x].e].idInfo];
      t: SymbolTableBase.y => RETURN[t.e.seb[NARROW[isei, SymbolIdIndex.y].e].idInfo];
     ENDCASE => ERROR;
  };

BodyLevel: PUBLIC PROC[stb: SymbolTableBase, bti: BodyIndex] RETURNS[BlockContextLevel] =
  {WITH stb SELECT FROM
      t: SymbolTableBase.x => RETURN[[x[t.e.bb[NARROW[bti, BodyIndex.x].e].level]]];
      t: SymbolTableBase.y => RETURN[[y[t.e.bb[NARROW[bti, BodyIndex.y].e].level]]];
     ENDCASE => ERROR;
  };

ParentBody: PUBLIC PROC[stb: SymbolTableBase, bti: BodyIndex] RETURNS[BodyIndex] =
  {WITH stb SELECT FROM
      t: SymbolTableBase.x => RETURN[[x[t.e.ParentBti[NARROW[bti, BodyIndex.x].e]]]];
      t: SymbolTableBase.y => RETURN[[y[t.e.ParentBti[NARROW[bti, BodyIndex.y].e]]]];
     ENDCASE => ERROR;
  };

BodyName: PUBLIC PROC[stb: SymbolTableBase, cbti: CallableBodyIndex]
      RETURNS[SymbolNameIndex] =
  {RETURN
      [ISEName[stb, WITH stb SELECT FROM
                          t: SymbolTableBase.x => [x[t.e.bb[NARROW[cbti,
                                                                             CallableBodyIndex.x].e].id]],
                          t: SymbolTableBase.y =>[y[t.e.bb[NARROW[cbti,
                                                                             CallableBodyIndex.y].e].id]]
                         ENDCASE => ERROR]];
  };

RootBodyType: PUBLIC PROC[stb: SymbolTableBase] RETURNS[SymbolIndex] =
  {WITH stb SELECT FROM
      t: SymbolTableBase.x => RETURN[[x[t.e.bb[bx.rootBodyIndex].type]]];
      t: SymbolTableBase.y => RETURN[[y[t.e.bb[by.rootBodyIndex].type]]];
     ENDCASE => ERROR;
  };

ISEInfo: PUBLIC PROC[stb: SymbolTableBase, isei: SymbolIdIndex] RETURNS[SymbolIndex] =
  {WITH stb SELECT FROM
      t: SymbolTableBase.x => RETURN[[x[t.e.seb[NARROW[isei, SymbolIdIndex.x].e].idInfo]]];
      t: SymbolTableBase.y => RETURN[[y[t.e.seb[NARROW[isei, SymbolIdIndex.y].e].idInfo]]];
     ENDCASE => ERROR;
  };

ISECtx: PUBLIC PROC[stb: SymbolTableBase, isei: SymbolIdIndex] RETURNS[SymbolContextIndex] =
  {WITH stb SELECT FROM
      t: SymbolTableBase.x => RETURN[[x[t.e.seb[NARROW[isei, SymbolIdIndex.x].e].idCtx]]];
      t: SymbolTableBase.y => RETURN[[y[t.e.seb[NARROW[isei, SymbolIdIndex.y].e].idCtx]]];
     ENDCASE => ERROR;
  };

ISEFindExtension: PUBLIC PROC[stb: SymbolTableBase, isei: SymbolIdIndex]
      RETURNS[ec: ExtensionClass, tl: TreeLink] =
  {WITH stb SELECT FROM
      t: SymbolTableBase.x =>
            {ecx: bx.ExtensionClass;
             tlx: bx.TreeLink;
             [ecx, tlx] _ t.e.FindExtension[NARROW[isei, SymbolIdIndex.x].e];
             ec _ [x[ecx]];
             tl _ [x[tlx]]};
      t: SymbolTableBase.y =>
            {ecy: by.ExtensionClass;
             tly: by.TreeLink;
             [ecy, tly] _ t.e.FindExtension[NARROW[isei, SymbolIdIndex.y].e];
             ec _ [y[ecy]];
             tl _ [y[tly]]};
     ENDCASE => ERROR;
  };

STBDirectoryCtx: PUBLIC PROC[stb: SymbolTableBase] RETURNS[SymbolContextIndex] =
  {WITH stb SELECT FROM
      t: SymbolTableBase.x => RETURN[[x[t.e.stHandle.directoryCtx]]];
      t: SymbolTableBase.y => RETURN[[y[t.e.stHandle.directoryCtx]]];
     ENDCASE => ERROR;
  };

STBVersion: PUBLIC PROC[stb: SymbolTableBase] RETURNS[BcdDefs.VersionStamp] =
  {WITH stb SELECT FROM
      t: SymbolTableBase.x => RETURN[t.e.stHandle.version];
      t: SymbolTableBase.y => RETURN[t.e.stHandle.version];
     ENDCASE => ERROR;
  };

STBSourceVersion: PUBLIC PROC[stb: SymbolTableBase] RETURNS[BcdDefs.VersionStamp] =
  {WITH stb SELECT FROM
      t: SymbolTableBase.x => RETURN[t.e.stHandle.sourceVersion];
      t: SymbolTableBase.y => RETURN[t.e.stHandle.sourceVersion];
     ENDCASE => ERROR;
  };

ISEName: PUBLIC PROC[stb: SymbolTableBase, isei: SymbolIdIndex] RETURNS[SymbolNameIndex] =
  {WITH stb SELECT FROM
      t: SymbolTableBase.x => RETURN[[x[t.e.seb[NARROW[isei, SymbolIdIndex.x].e].hash]]];
      t: SymbolTableBase.y => RETURN[[y[t.e.seb[NARROW[isei, SymbolIdIndex.y].e].hash]]];
     ENDCASE => ERROR;
  };

ISEPublic: PUBLIC PROC[stb: SymbolTableBase, isei: SymbolIdIndex] RETURNS[BOOL] =
  {WITH stb SELECT FROM
      t: SymbolTableBase.x => RETURN[t.e.seb[NARROW[isei, SymbolIdIndex.x].e].public];
      t: SymbolTableBase.y => RETURN[t.e.seb[NARROW[isei, SymbolIdIndex.y].e].public];
     ENDCASE => ERROR;
  };

SETypeXferMode: PUBLIC PROC[stb: SymbolTableBase, sei: SymbolIndex]
      RETURNS[RTSymbolOps.Xfm] =
  {WITH stb SELECT FROM
      t: SymbolTableBase.x =>
         RETURN[SELECT t.e.XferMode[NARROW[sei, SymbolIndex.x].e] FROM
                     none => none,
                     signal, error => signalOrError,
                     proc => proc,
                    ENDCASE => other];
      t: SymbolTableBase.y =>
         RETURN[SELECT t.e.XferMode[NARROW[sei, SymbolIndex.y].e] FROM
                     none => none,
                     signal, error => signalOrError,
                     proc => proc,
                    ENDCASE => other];
      ENDCASE => ERROR;
  };

SETagIDP: PUBLIC PROC[stb: SymbolTableBase, sei: SymbolIndex] RETURNS[BOOL] =
  {WITH stb SELECT FROM
      t: SymbolTableBase.x =>
         RETURN[WITH t.e.seb[NARROW[sei, SymbolIndex.x].e] SELECT FROM
                      id => TRUE,
                     ENDCASE => FALSE];
      t: SymbolTableBase.y =>
         RETURN[WITH t.e.seb[NARROW[sei, SymbolIndex.y].e] SELECT FROM
                      id => TRUE,
                     ENDCASE => FALSE];
     ENDCASE => ERROR;
  };

ISEExtended: PUBLIC PROC[stb: SymbolTableBase, isei: SymbolIdIndex] RETURNS[BOOL] =
  {WITH stb SELECT FROM
      t: SymbolTableBase.x => RETURN[t.e.seb[NARROW[isei, SymbolIdIndex.x].e].extended];
      t: SymbolTableBase.y => RETURN[t.e.seb[NARROW[isei, SymbolIdIndex.y].e].extended];
     ENDCASE => ERROR;
  };

ISEConstant: PUBLIC PROC[stb: SymbolTableBase, isei: SymbolIdIndex] RETURNS[BOOL] =
  {WITH stb SELECT FROM
      t: SymbolTableBase.x => RETURN[t.e.seb[NARROW[isei, SymbolIdIndex.x].e].constant];
      t: SymbolTableBase.y => RETURN[t.e.seb[NARROW[isei, SymbolIdIndex.y].e].constant];
     ENDCASE => ERROR;
  };

ISEImmutable: PUBLIC PROC[stb: SymbolTableBase, isei: SymbolIdIndex] RETURNS[BOOL] =
  {WITH stb SELECT FROM
      t: SymbolTableBase.x => RETURN[t.e.seb[NARROW[isei, SymbolIdIndex.x].e].immutable];
      t: SymbolTableBase.y => RETURN[t.e.seb[NARROW[isei, SymbolIdIndex.y].e].immutable];
     ENDCASE => ERROR;
  };

IsTypeSEI: PUBLIC PROC[sei: SymbolIndex] RETURNS[BOOL] =
  {WITH sei SELECT FROM
      t: SymbolIndex.x => RETURN[t.e = bx.symbolIndexForTYPE];
      t: SymbolIndex.y => RETURN[t.e = by.symbolIndexForTYPE];
     ENDCASE => ERROR;
  };

IsTransferConstructorSEI: PUBLIC PROC[stb: SymbolTableBase, sei: SymbolConstructorIndex]
      RETURNS[BOOL] =
  {WITH stb SELECT FROM
      t: SymbolTableBase.x =>
            RETURN[t.e.seb[NARROW[sei, SymbolConstructorIndex.x].e].typeTag = transfer];
      t: SymbolTableBase.y =>
            RETURN[t.e.seb[NARROW[sei, SymbolConstructorIndex.y].e].typeTag = transfer];
     ENDCASE => ERROR;
  };

RSEVariant: PUBLIC PROC[stb: SymbolTableBase, rsei: SymbolRecordIndex] RETURNS[BOOL] =
  {WITH stb SELECT FROM
      t: SymbolTableBase.x => RETURN[t.e.seb[NARROW[rsei, SymbolRecordIndex.x].e].hints.variant];
      t: SymbolTableBase.y => RETURN[t.e.seb[NARROW[rsei, SymbolRecordIndex.y].e].hints.variant];
     ENDCASE => ERROR;
  };

STBDirectoryCTX: PUBLIC PROC[stb: SymbolTableBase] RETURNS[SymbolContextIndex] =
  {WITH stb SELECT FROM
      t: SymbolTableBase.x => RETURN[[x[t.e.stHandle.directoryCtx]]];
      t: SymbolTableBase.y => RETURN[[y[t.e.stHandle.directoryCtx]]];
     ENDCASE => ERROR;
  };

FirstCtxSe: PUBLIC PROC[stb: SymbolTableBase, ctx: SymbolContextIndex]
      RETURNS[SymbolIdIndex] =
  {WITH stb SELECT FROM
      t: SymbolTableBase.x => RETURN[[x[t.e.FirstCtxSe[NARROW[ctx, SymbolContextIndex.x].e]]]];
      t: SymbolTableBase.y => RETURN[[y[t.e.FirstCtxSe[NARROW[ctx, SymbolContextIndex.y].e]]]];
     ENDCASE => ERROR;
  };

NextSe: PUBLIC PROC[stb: SymbolTableBase, isei: SymbolIdIndex] RETURNS[SymbolIdIndex] =
  {WITH stb SELECT FROM
      t: SymbolTableBase.x => RETURN[[x[t.e.NextSe[NARROW[isei, SymbolIdIndex.x].e]]]];
      t: SymbolTableBase.y => RETURN[[y[t.e.NextSe[NARROW[isei, SymbolIdIndex.y].e]]]];
     ENDCASE => ERROR;
  };

NullISEI: PUBLIC PROC[isei: SymbolIdIndex] RETURNS[BOOL] =
  {WITH isei SELECT FROM
      t: SymbolIdIndex.x => RETURN[t.e = nullXSymbolIndex];
      t: SymbolIdIndex.y => RETURN[t.e = nullYSymbolIndex];
     ENDCASE => ERROR;
  };

NullSEI: PUBLIC PROC[sei: SymbolIndex] RETURNS[BOOL] =
  {WITH sei SELECT FROM
      t: SymbolIndex.x => RETURN[t.e = nullXSymbolIndex];
      t: SymbolIndex.y => RETURN[t.e = nullYSymbolIndex];
     ENDCASE => ERROR;
  };

NullBTI: PUBLIC PROC[bti: BodyIndex] RETURNS[BOOL] =
  {WITH bti SELECT FROM
      t: BodyIndex.x => RETURN[t.e = bx.nullBodyIndex];
      t: BodyIndex.y => RETURN[t.e = by.nullBodyIndex];
     ENDCASE => ERROR;
  };

CallableBTI: PUBLIC PROC[stb: SymbolTableBase, bti: BodyIndex] RETURNS[BOOL] =
  {WITH stb SELECT FROM
      t: SymbolTableBase.x => RETURN[WITH t.e.bb[NARROW[bti, BodyIndex.x].e] SELECT FROM
                                               Callable => TRUE,
                                              ENDCASE => FALSE];
      t: SymbolTableBase.y => RETURN[WITH t.e.bb[NARROW[bti, BodyIndex.y].e] SELECT FROM
                                               Callable => TRUE,
                                              ENDCASE => FALSE];
     ENDCASE => ERROR;
  };

IsRootBTI: PUBLIC PROC[bti: BodyIndex] RETURNS[BOOL] =
  {WITH bti SELECT FROM
      t: BodyIndex.x => RETURN[t.e = bx.rootBodyIndex];
      t: BodyIndex.y => RETURN[t.e = by.rootBodyIndex];
     ENDCASE => ERROR;
  };

NullName: PUBLIC PROC[hti: SymbolNameIndex] RETURNS[BOOL] =
  {WITH hti SELECT FROM
      t: SymbolNameIndex.x => RETURN[t.e = nullXSymbolNameIndex];
      t: SymbolNameIndex.y => RETURN[t.e = nullYSymbolNameIndex];
     ENDCASE => ERROR;
  };

NullCtx: PUBLIC PROC[ctx: SymbolContextIndex] RETURNS[BOOL] =
  {WITH ctx SELECT FROM
      t: SymbolContextIndex.x => RETURN[t.e = nullXSymbolContextIndex];
      t: SymbolContextIndex.y => RETURN[t.e = nullYSymbolContextIndex];
     ENDCASE => ERROR;
  };

NullStb: PUBLIC PROC[stb: SymbolTableBase] RETURNS[BOOL] =
  {WITH stb SELECT FROM
      t: SymbolTableBase.x => RETURN[t.e = NIL];
      t: SymbolTableBase.y => RETURN[t.e = NIL];
     ENDCASE => ERROR;
  };

NullSth: PUBLIC PROC[sth: SymbolTableHandle] RETURNS[BOOL] =
  {WITH sth SELECT FROM
      t: SymbolTableHandle.x => RETURN[t.e = bx.nullHandle];
      t: SymbolTableHandle.y => RETURN[t.e = by.nullHandle];
     ENDCASE => ERROR;
  };

NullModuleIndex: PUBLIC PROC[mdi: SymbolModuleIndex] RETURNS[BOOL] =
  {WITH mdi SELECT FROM
      t: SymbolModuleIndex.x => RETURN[t.e = bx.nullModuleIndex];
      t: SymbolModuleIndex.y => RETURN[t.e = by.nullModuleIndex];
     ENDCASE => ERROR;
  };

SubStringForName: PUBLIC PROC[stb: SymbolTableBase, hti: SymbolNameIndex]
      RETURNS[ans: ConvertUnsafe.SubString] =
  {WITH stb SELECT FROM
      t: SymbolTableBase.x =>
            ans _ t.e.SubStringForName[NARROW[hti, SymbolNameIndex.x].e];
      t: SymbolTableBase.y =>
            ans _ t.e.SubStringForName[NARROW[hti, SymbolNameIndex.y].e];
     ENDCASE => ERROR;
  };

STBToModuleName: PUBLIC PROC[stb: SymbolTableBase] RETURNS[ROPE]= {
   FOR isei: SymbolIdIndex _ FirstCtxSe[stb, STBDirectoryCTX[stb]], NextSe[stb, isei]
    UNTIL NullISEI[isei]
    DO
      IF ISEPublic[stb, isei]
       THEN RETURN[ConvertUnsafe.SubStringToRope[SubStringForName[stb, ISEName[stb, isei]]]];
    ENDLOOP;
   ERROR;
   };
  
END.