-- CrossBcdControl.mesa
-- Last edited by Satterthwaite on August 1, 1983 12:10 pm	

DIRECTORY
  Alloc: TYPE USING [Create, Chunkify, Destroy, Failure, Reset, TableInfo],
  BcdBindDefs: TYPE USING [RelocHandle],
  BcdComData: TYPE USING [
    aborted, bcdName, binderVersion, codeName, commandArgs, copyCode, copySymbols,
    currentName, debug, errors, errorStream, logStream, nConfigs, nErrors,
    nExports, nImports, nModules, nPages, nWarnings, objectStamp, op,
    outputFile, outputFti, rootName, sourceName, sourceStream,
    sourceVersion, symbolName, table, textIndex, warnings, zone],
  BcdControlDefs: TYPE USING [
    BindRoot, BuildSemanticEntries, LoadRoot, WriteBcd,
    PrintBcd, PrintRelocations, PrintSemanticEntries, PrintTree],
  BcdDefs: TYPE USING [
    BinderNTables, httype, MTNull, NullName, sstype, treetype, VersionStamp],
  BcdErrorDefs: TYPE USING [Finalize, GetModule, GetSti, Initialize],
  BcdFileDefs: TYPE USING [BuildFileTable, EraseFileTable],
  BcdLiterals: TYPE USING [Initialize, Finalize, SealLiterals],
  BcdParseData: TYPE,
  BcdUtilDefs: TYPE USING [EnterFile, Init, Reset],
  CharIO: TYPE USING [PutChar, PutDecimal, PutLine, PutString],
  CommandUtil: TYPE USING [
    CommandObject, CopyString, Echo, Failed, FreePairList, FreeString,
    GetNthPair, ListLength, PairList, Parse, SetExtension],
  ExecOps: TYPE USING [Command, Outcome],
  Feedback: TYPE USING [Handle, Outcome, Procs, ProcsHandle],
  File: TYPE USING [Capability, nullCapability],
  FileStream: TYPE USING [Create, GetLeaderProperties, SetLength],
  HashOps: TYPE USING [Finalize, Initialize],
  Heap: TYPE USING [Create, Delete],
  IO: TYPE USING [UserAborted],
  LongString: TYPE USING [AppendDecimal],
  OSMiscOps: TYPE USING [
    BcdCreateTime, DeleteFile, FileError, FindFile, --ImageId,-- MergeStamps,
    TimeToStamp],
  P1: TYPE USING [InstallParseTable, Parse],
  Runtime: TYPE USING [CallDebugger, GetTableBase], 
  Stream: TYPE USING [Handle, Object, PutByteProcedure, Delete, PutByte],
  Strings: TYPE USING [
    AppendChar, AppendString, EquivalentSubString, String, SubStringDescriptor],
  Symbols: TYPE USING [stNull],
  SymbolTable: TYPE USING [anySpan, Forget, Locked],
  TemporarySpecialExecOps: TYPE USING [],
  Time: TYPE USING [Append, AppendCurrent, Current, Unpack],
  Tree: TYPE USING [Link],
  TreeOps: TYPE USING [PopTree, Finalize, Initialize];

CrossBcdControl: PROGRAM
    IMPORTS
      Alloc, BcdControlDefs, BcdErrorDefs, BcdFileDefs, BcdLiterals,
      BcdParseData, BcdUtilDefs, CharIO, CommandUtil,
      FileStream, HashOps, Heap, IO, OSMiscOps, P1, Runtime, Stream,
      String: LongString, Strings, SymbolTable, Time, TreeOps,
      data: BcdComData
    EXPORTS ExecOps, TemporarySpecialExecOps = {

  EquivalentString: PROC [s1, s2: Strings.String] RETURNS [BOOL] ~ {
    ss1: Strings.SubStringDescriptor _ [base~s1, offset~0, length~s1.length];
    ss2: Strings.SubStringDescriptor _ [base~s2, offset~0, length~s2.length];
    RETURN [Strings.EquivalentSubString[@ss1, @ss2]]};


 -- feedback control

  feedback: Feedback.ProcsHandle;
  fbh: Feedback.Handle _ NIL;
 
 
 -- command gathering and logging

  log: Stream.Handle _ NIL;
  logFile: File.Capability _ File.nullCapability;

  SetLogStream: PROC ~ {
    IF logFile = File.nullCapability THEN 
      logFile _ OSMiscOps.FindFile["Binder.Log"L, $write];
    log _ FileStream.Create[logFile]; FileStream.SetLength[log, 0]};

  LogString: PROC [s: Strings.String] ~ {CharIO.PutString[log, s]};
  LogChar: PROC [c: CHAR] ~ {CharIO.PutChar[log, c]};
  LogNumber: PROC [n: INTEGER] ~ {CharIO.PutDecimal[log, n]};

  renamedOutput: BOOL _ FALSE;

  RepeatCommand: PROC [s: Stream.Handle] ~ {
    OPEN CharIO;
    PutString[s, "\nBinding "L]; PutString[s, data.sourceName];
    IF renamedOutput THEN {PutString[s, ", BCD to "L]; PutString[s, data.bcdName]};
    IF data.copyCode THEN {
      PutString[s, ", code to "L];
      PutString[s, IF data.codeName = NIL THEN "BCD"L ELSE data.codeName]};
    IF data.copySymbols THEN {
      PutString[s, ", symbols to "L];
      PutString[s, IF data.symbolName = NIL THEN "BCD"L ELSE data.symbolName]};
    PutChar[s, '\n]};


 -- error logging

  errorName: Strings.String _ NIL;
  errorFile: File.Capability _ File.nullCapability;
  errorStream: Stream.Handle _ NIL;
  errorStreamObject: Stream.Object;

  SetErrorName: PROC ~ {
    IF errorName = NIL THEN {
      errorName _ CommandUtil.CopyString[data.rootName, 1+("errlog"L).length];
      errorName _ CommandUtil.SetExtension[errorName, "errlog"L]}};

  DummyErrorStream: PROC [
      putProc: Stream.PutByteProcedure] RETURNS [Stream.Handle] ~ { 
    errorStreamObject _ [
      options~TRASH, 
      getByte~TRASH, putByte~putProc, 
      getWord~TRASH, putWord~TRASH,
      get~TRASH, put~TRASH, 
      setSST~TRASH, sendAttention~TRASH, waitAttention~TRASH, 
      delete~TRASH];
    RETURN [@errorStreamObject]};

  OpenErrorStream: PROC ~ {
    IF errorName = NIL THEN SetErrorName[];
    IF errorFile = File.nullCapability THEN
      errorFile _ OSMiscOps.FindFile[errorName, $write];
    errorStream _ FileStream.Create[errorFile];
    FileStream.SetLength[errorStream, 0];
    WriteHerald[errorStream, errorName];  RepeatCommand[errorStream]};

  CloseErrorStream: PROC ~ INLINE {IF data.errorStream # NIL THEN ErrorDestroy[]};

  ErrorPut: Stream.PutByteProcedure ~ {
    IF errorStream = NIL THEN OpenErrorStream[];
    errorStream.PutByte[byte]};

  ErrorDestroy: PROC ~ {
    IF errorFile # File.nullCapability AND errorStream # NIL THEN {
      Stream.Delete[errorStream]; errorStream _ NIL}};


  WriteHerald: PROC [s: Stream.Handle, id: Strings.String] ~ {
    OPEN Time, CharIO;
    herald: STRING _ [80];
    Strings.AppendString[herald, "Cedar Trinity Cross Binder of "L];
    Time.Append[herald, Time.Unpack[[OSMiscOps.BcdCreateTime[]]]];
    herald.length _ herald.length-3;
    Strings.AppendString[herald, " (Pilot Version)"L];
    PutLine[s, herald];
    IF fbh = NIL AND feedback.create # NIL
      THEN fbh _ feedback.create[system~"Binder"L, herald~herald];
    IF id # NIL THEN {PutString[s, id]; PutString[s, " -- "L]};
    herald.length _ 0; Time.AppendCurrent[herald]; PutLine[s, herald]};

  Logger: PROC [proc: PROC [log: Stream.Handle]] = {
    proc[data.errorStream]};
 
 
 -- file bookkeeping

  sourceFile: File.Capability;

  SetRoot: PROC [root, s: Strings.String] ~ {
    root.length _ 0;
    FOR i: CARDINAL IN [0..s.length) DO 
      IF s[i] = '. THEN EXIT;  
      Strings.AppendChar[root, s[i]]; 
      ENDLOOP};

  SetFileName: PROC [
      fileName, extension: Strings.String] RETURNS [Strings.String] ~ {
    root: Strings.String ~ 
      (IF fileName = NIL THEN 
	 CommandUtil.CopyString[data.rootName, 1+extension.length]
       ELSE fileName);
    RETURN [CommandUtil.SetExtension[root, extension]]};


 -- switches
 
  StandardDefaults: PACKED ARRAY CHAR ['a..'z] OF BOOL ~ [
    FALSE, -- A  Copy all (code and symbols)
    FALSE, -- B  Unused
    TRUE , -- C  Copy code
    FALSE, -- D  Call debugger error
    FALSE, -- E  Unused
    FALSE, -- F  Unused
    TRUE , -- G  TRUE => errlog goes to binder.log, FALSE => use root.errlog
    FALSE, -- H  Unused
    FALSE, -- I  Unused
    FALSE, -- J  Unused
    FALSE, -- K  Unused
    FALSE, -- L  Unused
    FALSE, -- M  Unused
    FALSE, -- N  Unused
    FALSE, -- O  Unused
    FALSE, -- P  Pause after config with errors
    FALSE, -- Q  Unused
    FALSE, -- R  Unused
    FALSE, -- S  Copy symbols
    FALSE, -- T  Unused
    FALSE, -- U  Unused
    FALSE, -- V  Unused
    FALSE, -- W  Pause after config with warnings
    FALSE, -- X  Copy compressed symbols (not implemented)
    FALSE, -- Y  Unused
    FALSE  -- Z  Unused
    ];
  

-- Exec interfaces

Bind: PUBLIC PROC [cmd: ExecOps.Command] RETURNS [outcome: ExecOps.Outcome] ~ { 
  fProcs: Feedback.Procs _ [];	-- all NIL
  RETURN [BindUsingFeedback[cmd, @fProcs]]};
    

BindUsingFeedback: PUBLIC PROC [cmd: ExecOps.Command, feedbackProcs: Feedback.ProcsHandle] 
    RETURNS [outcome: ExecOps.Outcome] ~ { 
  theCommand: CommandUtil.CommandObject _ [pos~0, len~0, data~cmd];
  results: CommandUtil.PairList;
  switches: Strings.String;
  key, value: Strings.String;
  anyErrors, anyWarnings: BOOL _ FALSE;
  localPause: BOOL;
  
  defaultSwitches: PACKED ARRAY CHAR ['a..'z] OF BOOL _ StandardDefaults;
  defaultDebugPass: CARDINAL _ CARDINAL.LAST;
  localSwitches: PACKED ARRAY CHAR ['a..'z] OF BOOL;
  debugPass: CARDINAL;

  fbh _ NIL; feedback _ feedbackProcs;
  
  IF cmd = NIL THEN ERROR;
  WHILE theCommand.data[theCommand.len] # '\n DO
    theCommand.len _ theCommand.len + 1;
    ENDLOOP;
  
  SetLogStream[];
  WriteHerald[log, NIL];
  
  data.op _ $bind;
  data.zone _ Heap.Create[initial~16, increment~8];
  data.table _ NIL;
  data.rootName _ (data.zone).NEW[StringBody[100]];

 -- main loop

  DO {

    Initialize: PROC ~ {
      weights: ARRAY [0..BcdDefs.BinderNTables) OF Alloc.TableInfo _ [	-- empirical (SDD)
        [4], [2], [10], [4], [5], [4], [4], [4], [2], [1],
	[4], [4], [4], [2], [4], [2], [4], [5], [1], [1]];
      RepeatCommand[log];
      data.errors _ data.warnings _ FALSE;
      data.nErrors _ data.nWarnings _ 0;
      data.textIndex _ 0;
      data.currentName _ BcdDefs.NullName;
      IF data.table = NIL THEN {
        data.table _ Alloc.Create[weights~DESCRIPTOR[weights]];
        (data.table).Chunkify[BcdDefs.treetype]}
      ELSE (data.table).Reset[];
      HashOps.Initialize[data.table, BcdDefs.httype, BcdDefs.sstype];
      TreeOps.Initialize[data.table, data.zone];
      BcdUtilDefs.Init[data.table];
      BcdLiterals.Initialize[data.table, data.zone];
      BcdErrorDefs.Initialize[];
      errorStream _ NIL};

    Finalize: PROC ~ {
      TreeOps.Finalize[];  HashOps.Finalize[];
      BcdErrorDefs.Finalize[];
      BcdLiterals.Finalize[];  BcdUtilDefs.Reset[];
      (data.table).Reset[];
      anyErrors _ data.errors OR anyErrors;  anyWarnings _ data.warnings OR anyWarnings;
      IF data.aborted THEN LogString["Binding aborted\n"L]
      ELSE IF data.errors THEN LogString["Errors detected; BCD not written\n"L]
      ELSE {
	IF data.nConfigs > 1 THEN {
	  LogNumber[data.nConfigs]; LogString[" configs, "L]};
        LogNumber[data.nModules]; LogString[" modules, "L];
        LogNumber[data.nImports]; LogString[" imports, "L];
        LogNumber[data.nExports]; LogString[" exports, "L];
        LogNumber[data.nPages]; LogString[" pages, "L];
	LogNumber[Time.Current[] - startTime]; LogString[" seconds\n"L]};
      IF errorStream # NIL THEN {
	LogString["See "L]; LogString[data.rootName]; LogString[".errlog\n"L]};
      IF log # data.errorStream THEN CloseErrorStream[];
      IF errorName = NIL THEN {SetErrorName[]; OSMiscOps.DeleteFile[errorName]};
      Stream.Delete[data.sourceStream];
      IF data.nErrors # 0 OR data.aborted THEN OSMiscOps.DeleteFile[data.bcdName];
      data.outputFile _ File.nullCapability;
      IF feedback.finishItem # NIL THEN {
	outcome: ExecOps.Outcome ~
	  SELECT TRUE FROM
	    data.aborted => $aborted,
	    data.errors AND data.warnings => $errorsAndWarnings,
	    data.errors => $errors,
	    data.warnings => $warnings,
	    ENDCASE => $ok;
	msg: STRING _ [30];
	IF ~data.errors
	  THEN Strings.AppendString[msg, "no"L]
	  ELSE String.AppendDecimal[msg, data.nErrors];
	Strings.AppendString[msg, " errors"L];
	IF data.nWarnings # 0
	  THEN {
	    Strings.AppendString[msg, ", "L];
	    String.AppendDecimal[msg, data.nWarnings];
	    Strings.AppendString[msg, " warnings"L]};
	feedback.finishItem[fbh, outcome, msg]}};

    Debug: PROC [printRel, printBcd: BOOL] ~ {
      BcdControlDefs.PrintTree[root];
      BcdControlDefs.PrintSemanticEntries[];
      IF printRel THEN BcdControlDefs.PrintRelocations[relocationHead];
      IF printBcd THEN BcdControlDefs.PrintBcd[]};

    parsed: BOOL;
    root: Tree.Link;
    relocationHead: BcdBindDefs.RelocHandle;
    startTime: LONG CARDINAL;

    localSwitches _ defaultSwitches;
    localPause _ FALSE;  debugPass _ defaultDebugPass;
    renamedOutput _ FALSE;
    data.aborted _ FALSE;

    [data.sourceName, data.commandArgs, results, switches] _
      CommandUtil.Parse[
		s~@theCommand,
		opX~2+("config"L).length, resultX~2+("symbols"L).length
	  ! CommandUtil.Failed => {GO TO badSyntax}];
    IF data.sourceName = NIL AND switches = NIL THEN EXIT;  -- done binding
    LogString["\nCommand: "L];
    CommandUtil.Echo[
      d~log, operator~data.sourceName, argList~data.commandArgs, 
      resultList~results, switches~switches];
    IF data.sourceName = NIL THEN GO TO globalSwitches;
    FOR n: CARDINAL IN [0..CommandUtil.ListLength[results]) DO
      [key, value] _ CommandUtil.GetNthPair[list~results, n~n];
      SELECT TRUE FROM
	(key = NIL), EquivalentString[key, "bcd"L] => { 
	  data.bcdName _ value; renamedOutput _ TRUE};
	EquivalentString[key, "code"L] => { 
	  data.codeName _ value; localSwitches['c] _ TRUE};
	EquivalentString[key, "symbols"L] => {  
	  data.symbolName _ value; localSwitches['s] _ TRUE};
	ENDCASE => GO TO badSemantics;
      ENDLOOP;
    SetRoot[
      data.rootName,
      (IF data.bcdName # NIL THEN data.bcdName ELSE data.sourceName)];
    IF switches # NIL THEN {
	i: CARDINAL _ 0;
	sense: BOOL _ TRUE;
	WHILE i < switches.length DO
	  c: CHAR ~ switches[i];
	  SELECT c FROM
	    '-, '~ => sense _ ~sense;
	    IN ['a..'z] => {localSwitches[c] _ sense; sense _ TRUE};
	    IN ['A..'Z] => {localSwitches[c + ('a-'A)] _ sense; sense _ TRUE};
	    '! => {Runtime.CallDebugger[NIL]; sense _ TRUE};
	    IN ['1..'4] => {debugPass _ c-'0; sense _ TRUE};
	    ENDCASE;
	  i _ i+1;
	  ENDLOOP;
	switches _ CommandUtil.FreeString[switches]};

    data.sourceName _ SetFileName[data.sourceName, "config"L];
    data.bcdName _ SetFileName[data.bcdName, "bcd"L];
    data.copyCode _ (localSwitches['c] OR localSwitches['a]);
    data.copySymbols _ (localSwitches['s] OR localSwitches['x] OR localSwitches['a]);
    IF localSwitches['x] THEN
      LogString["\nSymbol compression not available in this version"L];
    IF data.copyCode AND data.codeName # NIL THEN {
      data.codeName _ SetFileName[data.codeName, "code"L];
      IF EquivalentString[data.codeName, data.bcdName] THEN
        data.codeName _ CommandUtil.FreeString[data.codeName]};
    IF data.copySymbols AND ~(localSwitches['a] AND data.symbolName = NIL) THEN {
      data.symbolName _ SetFileName[data.symbolName, "symbols"L];
      IF EquivalentString[data.symbolName, data.bcdName] THEN
        data.symbolName _ CommandUtil.FreeString[data.symbolName]};

    IF feedback.beginItem # NIL THEN {
      item: STRING _ [100];
      first: BOOL _ TRUE;
      Strings.AppendString[item, "Binding: "L]; Strings.AppendString[item, data.rootName];
      FOR c: CHAR IN ['a..'z] DO
	IF localSwitches[c] # StandardDefaults[c] THEN {
	  IF first THEN {first _ FALSE; Strings.AppendChar[item, '/]};
	  IF StandardDefaults[c] THEN Strings.AppendChar[item, '-];
	  Strings.AppendChar[item, c]};
	ENDLOOP;
      feedback.beginItem[fbh, item]}; 

    startTime _ Time.Current[];

    BEGIN
    ENABLE ANY => {CONTINUE};
    sourceFile _ errorFile _ data.outputFile _ File.nullCapability;
    data.sourceStream _ NIL;
    sourceFile _ OSMiscOps.FindFile[data.sourceName, $read
      ! OSMiscOps.FileError => {CONTINUE}];
    IF sourceFile # File.nullCapability THEN {
      data.sourceStream _ FileStream.Create[sourceFile];
      data.sourceVersion _ BcdDefs.VersionStamp[
	net~0, host~0,
	time~FileStream.GetLeaderProperties[data.sourceStream].create]};
    IF data.sourceStream = NIL THEN GO TO noSource;
    data.outputFile _ OSMiscOps.FindFile[data.bcdName, $write];
    SymbolTable.Forget[[data.outputFile, SymbolTable.anySpan]
      ! SymbolTable.Locked => {CONTINUE}];	-- for now
    END;

    data.logStream _ log;
    data.errorStream _
      IF localSwitches['g] THEN log ELSE DummyErrorStream[putProc~ErrorPut];
    localPause _ localSwitches['p];  data.debug _ localSwitches['d];
    localSwitches['g] _ localSwitches['p] _ localSwitches['d] _ FALSE;
    
    data.objectStamp _ OSMiscOps.TimeToStamp[data.sourceVersion];
    -- encode switches, binder version (see BcdLoad processing also)
      data.objectStamp _ OSMiscOps.MergeStamps[
        data.objectStamp, OSMiscOps.TimeToStamp[[0, 0, LOOPHOLE[localSwitches]]]];
      data.objectStamp _ OSMiscOps.MergeStamps[
        data.objectStamp, OSMiscOps.TimeToStamp[data.binderVersion]];

    Initialize[];
      BEGIN
	ENABLE {
	  BcdErrorDefs.GetModule => {RESUME [BcdDefs.MTNull, 0]};
	  BcdErrorDefs.GetSti => {RESUME [Symbols.stNull]};
	  Alloc.Failure => {
	    data.errors _ TRUE;
	    IF ~data.debug THEN {
	      LogString["Storage Overflow\n"L]; GOTO Overflow}};
	  UNWIND => {Finalize[]}};

      IF feedback.noteProgress # NIL THEN
        feedback.noteProgress[fbh, 1 ! IO.UserAborted => {GOTO Abort}];
      [complete~parsed, nErrors~data.nErrors] _ P1.Parse[data.sourceStream, data.zone, Logger];
      IF ~parsed THEN GO TO Failed;
      IF data.nErrors > 0 THEN data.errors _ TRUE;
      root _ TreeOps.PopTree[];
      BcdControlDefs.BuildSemanticEntries[root];

      data.outputFti _ BcdUtilDefs.EnterFile[data.bcdName];
      BcdFileDefs.BuildFileTable[data.table, data.zone];
        IF debugPass <= 1 THEN Debug[printRel~FALSE, printBcd~FALSE];

      IF feedback.noteProgress # NIL THEN
        feedback.noteProgress[fbh, 2 ! IO.UserAborted => {GOTO AbortAndEraseFileTable}];
      relocationHead _ BcdControlDefs.LoadRoot[root];
      BcdLiterals.SealLiterals[];
        IF debugPass <= 2 THEN Debug[printRel~TRUE, printBcd~TRUE];

      IF feedback.noteProgress # NIL THEN
        feedback.noteProgress[fbh, 3 ! IO.UserAborted => {GOTO AbortAndEraseFileTable}];
      BcdControlDefs.BindRoot[relocationHead];
        IF debugPass <= 3 THEN Debug[printRel~FALSE, printBcd~TRUE];

      IF ~data.errors THEN { 
        IF feedback.noteProgress # NIL THEN
          feedback.noteProgress[fbh, 4 ! IO.UserAborted=>{GOTO AbortAndEraseFileTable}];
        BcdControlDefs.WriteBcd[root]};
      BcdFileDefs.EraseFileTable[];
      EXITS
        Overflow => NULL;
        Failed => data.errors _ TRUE;
	Abort => {data.aborted _ TRUE};
	AbortAndEraseFileTable => { 
	  BcdFileDefs.EraseFileTable[];
	  data.aborted _ TRUE};
      END;
    Finalize[];

    EXITS
      noSource => {
        LogString["\nCan't open "L]; LogString[data.sourceName]; LogChar['\n];
        data.errors _ TRUE};
      globalSwitches => {
	sense: BOOL _ TRUE;
        results _ CommandUtil.FreePairList[results];
        FOR i: CARDINAL IN [0..switches.length) DO
	  c: CHAR ~ switches[i];
	  SELECT c FROM
	    '-, '~ => sense _ ~sense;
	    '! => Runtime.CallDebugger[NIL];
	    IN ['a..'z] => {defaultSwitches[c] _ sense; sense _ TRUE};
	    IN ['A..'Z] => {defaultSwitches[c + ('a-'A)] _ sense; sense _ TRUE};
	    IN ['1..'5] => {defaultDebugPass _ c-'0; sense _ TRUE};
	    ENDCASE => EXIT;
	  ENDLOOP;
        switches _ CommandUtil.FreeString[switches]};
      badSemantics => {
        results _ CommandUtil.FreePairList[results];
        data.errors _ TRUE;
        LogString["\n -- Illegal command"L]}};
    data.sourceName _ CommandUtil.FreeString[data.sourceName];
    data.bcdName _ CommandUtil.FreeString[data.bcdName];
    data.codeName _ CommandUtil.FreeString[data.codeName];
    data.symbolName _ CommandUtil.FreeString[data.symbolName];
    data.commandArgs _ CommandUtil.FreePairList[data.commandArgs];
    errorName _ CommandUtil.FreeString[errorName];
    IF data.aborted THEN EXIT;  -- stop binding
    IF (data.errors OR (data.warnings AND localSwitches['w])) AND localPause THEN EXIT;
    REPEAT
      badSyntax => {anyErrors _ data.errors _ TRUE; LogString["-- Illegal syntax"L]};
    ENDLOOP;

  IF data.table # NIL THEN Alloc.Destroy[data.table];  data.table _ NIL;
  (data.zone).FREE[@data.rootName];
  Heap.Delete[data.zone]; data.zone _ NIL;
  Stream.Delete[log];  logFile _ File.nullCapability;
  IF feedback.destroy # NIL THEN feedback.destroy[fbh, "End of binding"L];
  RETURN [SELECT TRUE FROM
    data.aborted => $aborted,
    (anyErrors AND anyWarnings) => $errorsAndWarnings,
    anyErrors => $errors,
    anyWarnings => $warnings,
    ENDCASE => $ok]};
  
  
-- global Binder initialization
  
  Init: PROC ~ { 
    START data;
--  data.binderVersion _ OSMiscOps.ImageId[];
    data.binderVersion _ [net~0Ch, host~0Bh, time~00000005h]; -- Cedar release
    P1.InstallParseTable[Runtime.GetTableBase[LOOPHOLE[BcdParseData]]]};
  
  
  Init[];

  }.