-- tempBcdOperations.mesa
-- Last Modified by Sandman,  July 17, 1980  11:55 AM 
-- Last Modified by Paul Rovner, 4-Feb-82 11:28:51
-- Last Modified by Satterthwaite, December 23, 1982 3:08 pm

DIRECTORY
  BcdDefs: TYPE USING [
    Base, CTIndex, CTNull, CTRecord, EVIndex, EVNull, EVRecord,
    EXPIndex, EXPNull, EXPRecord, FTIndex, FTNull, FTRecord, IMPIndex, IMPNull,
    IMPRecord, Link, MTIndex, MTNull, MTRecord, Namee, NameRecord,
    NTIndex, NTNull, NTRecord, NullName, SGIndex, SGNull, SGRecord, SpaceID,
    SPIndex, SPNull, SPRecord, VersionStamp, FPIndex, FPRecord, FPNull],
  BcdOps: TYPE USING [
    BcdBase, CTHandle, EVHandle, EXPHandle, FTHandle, IMPHandle, MTHandle,
    NTHandle, SGHandle, SPHandle, FPHandle];

BcdOperations: PROGRAM EXPORTS BcdOps = PUBLIC

  BEGIN OPEN BcdOps, BcdDefs;

  ProcessConfigs: PROC [
    bcd: BcdBase, proc: PROC [CTHandle, CTIndex] RETURNS [BOOL]]
    RETURNS [cth: CTHandle, cti: CTIndex] =
    BEGIN
    ctb: Base = LOOPHOLE[bcd + bcd.ctOffset];
    i: CARDINAL;
    cti _ CTIndex.FIRST;
    FOR i IN [0..bcd.nConfigs) DO
      cth _ @ctb[cti];
      IF proc[cth, cti] THEN RETURN;
      cti _ cti + CTRecord.SIZE + cth.nControls*Namee.SIZE;
      ENDLOOP;
    RETURN[NIL, CTNull];
    END;

  ProcessExternals: PROC [
    bcd: BcdBase, proc: PROC [EVHandle, EVIndex] RETURNS [BOOL]]
    RETURNS [evh: EVHandle, evi: EVIndex] =
    BEGIN
    evb: Base = LOOPHOLE[bcd + bcd.evOffset];
    FOR evi _ EVIndex.FIRST, evi + EVRecord.SIZE + evh.length*CARDINAL.SIZE
     UNTIL evi = bcd.evLimit DO
      evh _ @evb[evi]; IF proc[evh, evi] THEN RETURN; ENDLOOP;
    RETURN[NIL, EVNull];
    END;

  ProcessExports: PROC [
    bcd: BcdBase, proc: PROC [EXPHandle, EXPIndex] RETURNS [BOOL]]
    RETURNS [eth: EXPHandle, eti: EXPIndex] =
    BEGIN
    etb: Base = LOOPHOLE[bcd + bcd.expOffset];
    i: CARDINAL;
    eti _ EXPIndex.FIRST;
    FOR i IN [0..bcd.nExports) DO
      eth _ @etb[eti];
      IF proc[eth, eti] THEN RETURN;
      eti _ eti + EXPRecord.SIZE + eth.size*Link.SIZE;
      ENDLOOP;
    RETURN[NIL, EXPNull];
    END;

  ProcessFiles: PROC [
    bcd: BcdBase, proc: PROC [FTHandle, FTIndex] RETURNS [BOOL]]
    RETURNS [fth: FTHandle, fti: FTIndex] =
    BEGIN
    ftb: Base = LOOPHOLE[bcd + bcd.ftOffset];
    FOR fti _ FTIndex.FIRST, fti + FTRecord.SIZE UNTIL fti = bcd.ftLimit DO
      fth _ @ftb[fti]; IF proc[fth, fti] THEN RETURN; ENDLOOP;
    RETURN[NIL, FTNull];
    END;

  ProcessImports: PROC [
    bcd: BcdBase, proc: PROC [IMPHandle, IMPIndex] RETURNS [BOOL]]
    RETURNS [ith: IMPHandle, iti: IMPIndex] =
    BEGIN
    itb: Base = LOOPHOLE[bcd + bcd.impOffset];
    i: CARDINAL;
    iti _ IMPIndex.FIRST;
    FOR i IN [0..bcd.nImports) DO
      ith _ @itb[iti];
      IF proc[ith, iti] THEN RETURN;
      iti _ iti + IMPRecord.SIZE;
      ENDLOOP;
    RETURN[NIL, IMPNull];
    END;

  ProcessModules: PROC [
    bcd: BcdBase, proc: PROC [MTHandle, MTIndex] RETURNS [BOOL]]
    RETURNS [mth: MTHandle, mti: MTIndex] =
    BEGIN
    mtb: Base = LOOPHOLE[bcd + bcd.mtOffset];
    i: CARDINAL;
    mti _ MTIndex.FIRST;
    FOR i IN [0..bcd.nModules) DO
      mth _ @mtb[mti];
      IF proc[mth, mti] THEN RETURN;
      mti _ mti + MTRecord.SIZE;
--   mti _ mti + (WITH m: mtb[mti] SELECT FROM
--		     direct => MTRecord.direct.SIZE + m.length*Link.SIZE,
--		     indirect => MTRecord.indirect.SIZE,
--		     multiple => MTRecord.multiple.SIZE,
--		    ENDCASE => ERROR)
      ENDLOOP;
    RETURN[NIL, MTNull];
    END;

  ProcessNames: PROC [
    bcd: BcdBase, proc: PROC [NTHandle, NTIndex] RETURNS [BOOL]]
    RETURNS [nth: NTHandle, nti: NTIndex] =
    BEGIN
    ntb: Base = LOOPHOLE[bcd + bcd.ntOffset];
    FOR nti _ NTIndex.FIRST, nti + NTRecord.SIZE UNTIL nti = bcd.ntLimit DO
      nth _ @ntb[nti]; IF proc[nth, nti] THEN RETURN; ENDLOOP;
    RETURN[NIL, NTNull];
    END;

  ProcessSegs: PROC [
    bcd: BcdBase, proc: PROC [SGHandle, SGIndex] RETURNS [BOOL]]
    RETURNS [sgh: SGHandle, sgi: SGIndex] =
    BEGIN
    sgb: Base = LOOPHOLE[bcd + bcd.sgOffset];
    FOR sgi _ SGIndex.FIRST, sgi + SGRecord.SIZE UNTIL sgi = bcd.sgLimit DO
      sgh _ @sgb[sgi]; IF proc[sgh, sgi] THEN RETURN; ENDLOOP;
    RETURN[NIL, SGNull];
    END;

  ProcessSpaces: PROC [
    bcd: BcdBase, proc: PROC [SPHandle, SPIndex] RETURNS [BOOL]]
    RETURNS [sph: SPHandle, spi: SPIndex] =
    BEGIN
    spb: Base = LOOPHOLE[bcd + bcd.spOffset];
    FOR spi _ SPIndex.FIRST, spi + SPRecord.SIZE + sph.length*SpaceID.SIZE
      UNTIL spi = bcd.spLimit DO
      sph _ @spb[spi]; IF proc[sph, spi] THEN RETURN; ENDLOOP;
    RETURN[NIL, SPNull];
    END;

  FindName: PROC [bcd: BcdBase, owner: Namee] RETURNS [name: NameRecord] =
    BEGIN
    n: NTHandle;

    FindOwner: PROC [nth: NTHandle, nti: NTIndex] RETURNS [BOOL] =
      BEGIN RETURN[owner = nth.item]; END;

    RETURN[
      IF (n _ ProcessNames[bcd, FindOwner].nth) = NIL THEN NullName ELSE n.name]
    END;

  ModuleVersion: PROC [bcd: BcdBase, mti: MTIndex]
    RETURNS [version: VersionStamp] =
    BEGIN
    mtb: Base = LOOPHOLE[bcd + bcd.mtOffset];
    ftb: Base = LOOPHOLE[bcd + bcd.ftOffset];
    RETURN[ftb[mtb[mti].file].version];
    END;

  ProcessFramePacks: PUBLIC PROC [
    bcd: BcdBase, proc: PROC [fph: FPHandle, fpi: FPIndex] RETURNS [BOOL]] 
    RETURNS [fph: FPHandle, fpi: FPIndex] = {
    fpb: Base = LOOPHOLE[bcd + bcd.fpOffset];
    FOR fpi: FPIndex _ FPIndex.FIRST, fpi + FPRecord.SIZE + fph.length*MTIndex.SIZE
    UNTIL fpi = bcd.fpLimit DO
      fph _ @fpb[fpi];
      IF proc[fph, fpi] THEN RETURN[fph, fpi];
      ENDLOOP;
    RETURN[NIL, FPNull]};


  END.