-- MDSupportImpl.mesa
-- last edit by Schmidt,  4-Mar-82 14:13:41
-- last edit by Satterthwaite, January 31, 1983 9:56 am
-- Pilot 6.0/ Mesa 7.0
-- mdsupportimpl for the system modeller
-- this module is also used in DesignModel.Config

DIRECTORY
  CompilerOps: TYPE USING [LetterSwitches],
  CWF: TYPE USING [SWF1, SWF2, WF0, WF1, WF2],
  Dir: TYPE USING [FileInfo, FileInfoRecord],
  Directory: TYPE USING [Error, Handle, ignore, Lookup],
  Environment: TYPE USING [wordsPerPage],
  File: TYPE USING [Capability, nullCapability],
  Inline: TYPE USING [LowHalf],
  LongString: TYPE USING [EqualString, EquivalentString],
  MDModel: TYPE USING [APPLSymbol, CkType, LETSymbol, LISTSymbol, ListType, LocForType, 
  	LOCSymbol, ModelSeqRecord, MODELSymbol, NarrowToLET, NarrowToLIST, 
	NarrowToLOC, NarrowToMODEL, NarrowToTYPE, OPENSymbol, PROCSymbol, 
	STRINGSymbol, SubType, Sym, Symbol, SymbolRecord, SymbolSeq, SymbolSeqRecord, TYPESymbol],
  PilotLoadStateOps: TYPE USING [NullConfig],
  Runtime: TYPE USING [CallDebugger],
  Space: TYPE USING [Create, CreateUniformSwapUnits, Delete, GetHandle, Handle, LongPointer, Map, 
  	nullHandle, PageFromLongPointer, virtualMemory],
  String: TYPE USING [LowerCase],
  Subr: TYPE USING [CopyString, debugflg, FindMappedSpace, FreeString, GetCreateDateWithSpace, 
  	LongZone, Prefix, SubStrCopy],
  TimeStamp: TYPE USING [Null, Stamp];

MDSupportImpl: PROGRAM  
IMPORTS CWF, Directory, Inline, LongString, MDModel, Runtime, Space, String, 
	Subr
EXPORTS MDModel = {

NumberOfModels: CARDINAL = 10;
NumberOfFileInfoRecords: CARDINAL = 300;

-- declarations used throughout this module
TooManySymbols: ERROR = CODE;

FileInfoSeq: TYPE = LONG POINTER TO FileInfoSeqRecord;
FileInfoSeqRecord: TYPE = RECORD[
	size: CARDINAL _ 0,
	body: SEQUENCE maxsize: CARDINAL OF Dir.FileInfo
	];
	
-- MDS Usage!!
-- these are set by StartMDSupport and freed by StopMDSupport
traversetreecalled: PUBLIC CARDINAL _ 0;
numberofbcdsmapped: PUBLIC CARDINAL _ 0;
numberofsourcesparsed: PUBLIC CARDINAL _ 0;
globalLDSpace: Space.Handle _ Space.nullHandle;	-- should be monitored
fileInfoSeq: FileInfoSeq _ NIL;
-- end of MDS usage

-- for FileInfo
-- takes a LOC, returns its fi if already calculated
-- if not, will look on local disk for bcd and src files
-- does not compute bcdvers or depseq's or the moduleName, which would require it to analyze the 
-- contents of the source or bcd files
GetFileInfo: PUBLIC PROC[sploc: MDModel.LOCSymbol] RETURNS[fi: Dir.FileInfo] = {
MDModel.CkType[sploc, $typeLOC];
IF sploc.fi ~= NIL THEN RETURN[sploc.fi];
{
longzone: UNCOUNTED ZONE _ Subr.LongZone[];
srcsfn: STRING _ [100];
bcdsfn: STRING _ [100];
sploc.fi _ fi _ AllocateFileInfo[];
-- look for source
IF NOT LongString.EquivalentString[sploc.sext, "bcd"L] THEN {
	CWF.SWF2[srcsfn, "%s.%s"L, sploc.tail, sploc.sext];
	fi.srcFileName _ Subr.CopyString[srcsfn];
	fi.srcCap _ Directory.Lookup[fileName: srcsfn, permissions: Directory.ignore
		! Directory.Error => CONTINUE];
	IF fi.srcCap ~= File.nullCapability THEN 
		fi.srcPresent _ TRUE;
	-- does not set bcdCreate, depseq or modulename
	}
ELSE fi.isBcd _ TRUE;
CWF.SWF1[bcdsfn, "%s.Bcd"L, sploc.tail];
fi.bcdCap _ Directory.Lookup[fileName: bcdsfn, permissions: Directory.ignore
	! Directory.Error => CONTINUE];
IF fi.bcdCap = File.nullCapability AND Subr.Prefix[bcdsfn, "pilot"L] THEN {
	Subr.SubStrCopy[bcdsfn, bcdsfn, 5];
	fi.bcdCap _ Directory.Lookup[fileName: bcdsfn, permissions: Directory.ignore
		! Directory.Error => CONTINUE];
	};
IF fi.bcdCap = File.nullCapability AND Subr.Prefix[bcdsfn, "long"L] THEN {
	Subr.SubStrCopy[bcdsfn, bcdsfn, 4];
	fi.bcdCap _ Directory.Lookup[fileName: bcdsfn, permissions: Directory.ignore
		! Directory.Error => CONTINUE];
	};
fi.bcdFileName _ Subr.CopyString[bcdsfn];
IF fi.bcdCap ~= File.nullCapability THEN 
	fi.bcdPresent _ TRUE;
}};

AllocateFileInfo: PROC RETURNS[fi: Dir.FileInfo] = {
longzone: UNCOUNTED ZONE _ Subr.LongZone[];
IF fileInfoSeq.size >= fileInfoSeq.maxsize THEN ERROR
ELSE {
	fi _ fileInfoSeq[fileInfoSeq.size] _ longzone.NEW[Dir.FileInfoRecord _ []];
	fileInfoSeq.size _ fileInfoSeq.size + 1;
	};
};

-- frees the data structure and NIL's out LOC's fi
GetBcdCreate: PUBLIC PROC[fi: Dir.FileInfo] RETURNS[bcdCreate: LONG CARDINAL] = {
IF fi.bcdCreate ~= 0 OR NOT fi.bcdPresent THEN RETURN[fi.bcdCreate]
ELSE RETURN[fi.bcdCreate _ Subr.GetCreateDateWithSpace[fi.bcdCap, globalLDSpace]];
};

GetSrcCreate: PUBLIC PROC[fi: Dir.FileInfo] RETURNS[srcCreate: LONG CARDINAL] = {
IF fi.srcCreate ~= 0 OR NOT fi.srcPresent THEN RETURN[fi.srcCreate]
ELSE RETURN[fi.srcCreate _ Subr.GetCreateDateWithSpace[fi.srcCap, globalLDSpace]];
};

EraseCacheEntry: PUBLIC PROC[fi: Dir.FileInfo, src: BOOL] = {
IF src THEN {
	fi.srcCap _ File.nullCapability;
	fi.srcPresent _ FALSE;
	fi.srcDepSeq _ NIL;
	fi.srcCreate _ 0;
	}
ELSE {
	oldCap: File.Capability _ fi.bcdCap;
	fi.bcdCap _ File.nullCapability;
	fi.bcdPresent _ FALSE;
	fi.bcdDepSeq _ NIL;
	fi.bcdCreate _ 0;		
	fi.bcdVers _ TimeStamp.Null;
	IF oldCap ~= File.nullCapability THEN ResetFileEntries[oldCap, fi];
	};
};

-- will make sure that entries in the fileInfo data structure
-- that mention the same bcd file are reset to point to the version "fi" wants
-- oldCapability is the old capability for the file
ResetFileEntries: PUBLIC PROC[oldCapability: File.Capability, fi: Dir.FileInfo] = {
f: Dir.FileInfo;
IF oldCapability = File.nullCapability THEN RETURN;
FOR i: CARDINAL IN [0 .. fileInfoSeq.size) DO
	f _ fileInfoSeq[i];
	IF f.bcdCap = oldCapability THEN {
		f.bcdPresent _ fi.bcdPresent;
		f.bcdVers _ fi.bcdVers;
		f.bcdCreate _ fi.bcdCreate;
		f.bcdDepSeq _ fi.bcdDepSeq;
		f.bcdCap _ fi.bcdCap;
		};
	ENDLOOP;
};

LookupFileInfo: PUBLIC PROC[bcdFileName: LONG STRING, bcdVers: TimeStamp.Stamp] 
	RETURNS[fi: Dir.FileInfo] = {
FOR i: CARDINAL IN [0 .. fileInfoSeq.size) DO
	fi _ fileInfoSeq[i];
	IF fi.bcdVers = bcdVers
	AND LongString.EquivalentString[fi.bcdFileName, bcdFileName] THEN 
		RETURN[fi];
	ENDLOOP;
RETURN[NIL];
};
	
LocForType: PUBLIC PROC[sptype: MDModel.TYPESymbol] RETURNS[sploc: MDModel.LOCSymbol] = {
IF sptype.typeval = NIL AND sptype.letparent = NIL THEN RETURN[NIL];
sploc _ MDModel.NarrowToLOC[IF sptype.letparent ~= NIL
	THEN sptype.letparent.letval ELSE sptype.typeval];
};

LocForAppl: PUBLIC PROC[spappl: MDModel.APPLSymbol] RETURNS[sploc: MDModel.LOCSymbol] = {
IF spappl.applval = NIL AND spappl.letparent = NIL THEN RETURN[NIL];
sploc _ MDModel.NarrowToLOC[IF spappl.letparent ~= NIL
	THEN spappl.letparent.letval ELSE spappl.applval];
};


-- stick in a Defs file
-- formal is X and typeName is X1 in 
--	X: TYPE X1,	 in directory stmt of source file
-- we look for a statement X: TYPE X1 == @file already in the model
-- returns sptype = NIL if not found
LookForTypeSource: PUBLIC PROC[formal, typeName: LONG STRING, symbolseq: MDModel.SymbolSeq, 
	spmodel: MDModel.MODELSymbol] 
	RETURNS[sptype: MDModel.TYPESymbol, sptypeloc: MDModel.LOCSymbol, spproc: MDModel.PROCSymbol] = {

	ProcAnalyze: PROC[sp: MDModel.Symbol, innermodel: MDModel.MODELSymbol] 
		RETURNS[proceed: BOOL _ TRUE] = {
	fiInner: Dir.FileInfo;
	IF sptype ~= NIL THEN RETURN[FALSE];
	WITH sp SELECT FROM
	spt: MDModel.TYPESymbol => {
		sploc: MDModel.LOCSymbol = MDModel.LocForType[spt];
		-- in case this symbol has not been defined
		IF sploc = NIL THEN RETURN[TRUE];
		fiInner _ GetFileInfo[sploc];
		IF LongString.EqualString[spt.typesym, formal]
		AND LongString.EqualString[spt.typeName, typeName]
		THEN {
		    	sptypeloc _ sploc;
			sptype _ spt;
			RETURN[FALSE];
			};
		};
	spt: MDModel.PROCSymbol => spproc _ spt;
	ENDCASE => NULL;
	RETURN[TRUE];
	};

spproc _ NIL;
sptypeloc _ NIL;
sptype _ NIL;
-- postorder is important here
TraverseTree[spmodel, symbolseq, ProcAnalyze, FALSE, TRUE];
};

-- stick in a Defs file
-- we look for an entry with stamp bcdVers
-- or, if a file has not been analyzed, we accept a bcdFileName match (wrong!)
-- returns NIL if not found
LookForTypeBcd: PUBLIC PROC[bcdFileName: LONG STRING, bcdVers: TimeStamp.Stamp,
	symbolseq: MDModel.SymbolSeq, spmodel: MDModel.MODELSymbol] 
	RETURNS[sptype: MDModel.TYPESymbol, sptypeloc: MDModel.LOCSymbol, spproc: MDModel.PROCSymbol] = {
bcdfilename: STRING _ [200];

	ProcAnalyze: PROC[sp: MDModel.Symbol, innermodel: MDModel.MODELSymbol] 
		RETURNS[proceed: BOOL _ TRUE] = {
	fiInner: Dir.FileInfo;
	IF sptype ~= NIL THEN RETURN[FALSE];
	WITH sp SELECT FROM
	spt: MDModel.TYPESymbol => {
		sploc: MDModel.LOCSymbol = MDModel.LocForType[spt];
		-- in case this symbol has not been defined
		IF sploc = NIL THEN RETURN[TRUE];
		fiInner _ GetFileInfo[sploc];
		IF (fiInner.bcdVers.time = bcdVers.time
		     OR (fiInner.bcdVers = TimeStamp.Null 
			 -- handles case where fInner has not been anal
			 AND LongString.EquivalentString[fiInner.bcdFileName, bcdFileName])) 
		THEN {
		    	sptypeloc _ sploc;
			sptype _ spt;
			RETURN[FALSE];
			};
		};
	spt: MDModel.PROCSymbol => spproc _ spt;
	ENDCASE => NULL;
	RETURN[TRUE];
	};

spproc _ NIL;
sptypeloc _ NIL;
sptype _ NIL;
-- postorder is important here
TraverseTree[spmodel, symbolseq, ProcAnalyze, FALSE, TRUE];
};

-- spimpl is either APPL or LET
-- if sptype is not NIL, then use sptype as the type of the instance
-- formal and type are from IMPORTS formal: type
-- we look for formalImpl: type in the model
-- returns spappl = NIL if not found
LookForInstSource: PUBLIC PROC[formal, type: LONG STRING, 
	symbolseq: MDModel.SymbolSeq, spmodel: MDModel.MODELSymbol, sptype: MDModel.TYPESymbol] 
RETURNS[spappl: MDModel.APPLSymbol, spnewtype: MDModel.TYPESymbol, spproc: MDModel.PROCSymbol] ={
intname: STRING _ [100];

	ProcAnalyze: PROC[sp: MDModel.Symbol, innermodel: MDModel.MODELSymbol] 
		RETURNS[proceed: BOOL _ TRUE] = {
	IF spappl ~= NIL THEN RETURN[FALSE];
	WITH sp SELECT FROM
	spt: MDModel.LETSymbol => {
		FOR splist: MDModel.LISTSymbol _ spt.letgrp, splist.rest UNTIL splist = NIL DO
			WITH splist.first SELECT FROM
			spa1: MDModel.APPLSymbol => {
				-- the types must agree
				-- the interface record names must agree
				IF spa1.appltype = sptype 
				AND LongString.EqualString[intname, spa1.applsym] THEN {
					spappl _ spa1;
					RETURN[FALSE];
					};
				};
	 		ENDCASE;
	 		ENDLOOP;
		};
	spt: MDModel.APPLSymbol => {
		-- the types must agree
		-- the interface record names must agree
		IF spt.appltype = sptype 
		AND LongString.EqualString[intname, spt.applsym] THEN {
			spappl _ spt;
			RETURN[FALSE];
			};
		};
	spt: MDModel.PROCSymbol => spproc _ spt;
	ENDCASE => NULL;
	RETURN[TRUE];
	};

spappl _ NIL;
spproc _ NIL;
IF sptype = NIL THEN {
	-- this is buggy: we should call LookForType with
	-- the formal and typeNames for the corresponding Defs that is
	-- mentioned in IMPORTS Y: Defs = 
	-- instead we pass the string "defs" as both formal and typename
	[sptype] _ LookForTypeSource[type, type, symbolseq, spmodel];
	IF sptype = NIL THEN RETURN[NIL, NIL, NIL];	-- can't be found
	};
spnewtype _ sptype;
MDModel.CkType[sptype, $typeTYPE];
CWF.SWF1[intname, "%sImpl"L, formal];
-- postorder is important here
TraverseTree[spmodel, symbolseq, ProcAnalyze, FALSE, TRUE];
};

-- spimpl is either APPL or LET
-- if sptype is not NIL, then use sptype as the type of the instance
-- just looks for any instance with a bcdVers timestamp
-- (more precisely, any instance with type sptype)
LookForInstBcd: PUBLIC PROC[bcdFileName: LONG STRING, bcdVers: TimeStamp.Stamp, 
	symbolseq: MDModel.SymbolSeq, spmodel: MDModel.MODELSymbol, sptype: MDModel.TYPESymbol] 
RETURNS[spappl: MDModel.APPLSymbol, spnewtype: MDModel.TYPESymbol, spproc: MDModel.PROCSymbol] ={

	ProcAnalyze: PROC[sp: MDModel.Symbol, innermodel: MDModel.MODELSymbol] 
		RETURNS[proceed: BOOL _ TRUE] = {
	IF spappl ~= NIL THEN RETURN[FALSE];
	WITH sp SELECT FROM
	spt: MDModel.LETSymbol => {
		FOR splist: MDModel.LISTSymbol _ spt.letgrp, splist.rest UNTIL splist = NIL DO
			WITH splist.first SELECT FROM
			spa1: MDModel.APPLSymbol => {
				-- the types must agree
				-- the interface record names must agree
				IF spa1.appltype = sptype THEN {
					spappl _ spa1;
					RETURN[FALSE];
					};
				};
	 		ENDCASE;
			ENDLOOP;
		};
	spt: MDModel.APPLSymbol => {
		-- the types must agree
		IF spt.appltype = sptype THEN {
			spappl _ spt;
			RETURN[FALSE];
			};
		};
	spt: MDModel.PROCSymbol => spproc _ spt;
	ENDCASE => NULL;
	RETURN[TRUE];
	};

spappl _ NIL;
spproc _ NIL;
IF sptype = NIL THEN {
	[sptype] _ LookForTypeBcd[bcdFileName, bcdVers, symbolseq, spmodel];
	IF sptype = NIL THEN RETURN[NIL, NIL, NIL];	-- can't be found
	};
spnewtype _ sptype;
MDModel.CkType[sptype, $typeTYPE];
-- postorder is important here
TraverseTree[spmodel, symbolseq, ProcAnalyze, FALSE, TRUE];
};

ValidateModel: PUBLIC PROC[symbolseq: MDModel.SymbolSeq] = {

	AnalProc: PROC[sp1: MDModel.Symbol, spmodel: MDModel.MODELSymbol]
	RETURNS[proceed: BOOL _ TRUE] = {
	WITH sp~~sp1 SELECT FROM
	typeTYPE => {
		CkS[sp.typesym];
		CkS[sp.typeName];
		VerifyLoc[sp.typeval];
		VerifyLet[sp1, sp.letparent];
		IF sp.letparent = NIL AND sp.typeval = NIL 
		AND sp1 ~= symbolseq.controlv THEN 
			CWF.WF1["%s is undefined.\n"L, sp.typesym];
		};
	typeLOC => {
		CkT[sp.parmlist, $typeLIST];
		CkT[sp.nestedmodel, $typeMODEL];
		CkS[sp.tail];
		CkS[sp.sext];
		};
	typePROC => {
		CkS[sp.procsym];
		CkT[sp.procparm, $typeLIST];
		CkT[sp.procret, $typeLIST];
		CkT[sp.procval, $typeLIST];
		};
	typeSTRING => {
		CkS[sp.strval];
		};
	typeAPPL => {
		CkS[sp.applsym];
		CkT[sp.appltype, $typeTYPE];
		VerifyLoc[sp.applval];
		VerifyLet[sp1, sp.letparent];
		IF sp.letparent = NIL AND sp.applval = NIL AND Subr.debugflg THEN 
			CWF.WF1["Check: %s is a parameter.\n"L, sp.applsym];
		};
	typeLET => {
		splist: MDModel.LISTSymbol;
		splist _ sp.letgrp;
		WHILE splist ~= NIL DO
			WITH spi~~splist.first SELECT FROM
			typeTYPE => VerifyLet[splist.first, MDModel.NarrowToLET[sp1]];
			typeAPPL => VerifyLet[splist.first, MDModel.NarrowToLET[sp1]];
			ENDCASE => NULL;
			splist _ splist.rest;
			ENDLOOP;
		VerifyLoc[sp.letval];
		};
	typeLIST => {
		CkT[sp.rest, $typeLIST];
		};
	typeOPEN => NULL;
	typeMODEL => {
		CkS[sp.modelfilename];
		CkT[sp.model, $typeLIST];
		};
	ENDCASE => NULL;
	};
	
TraverseTree[symbolseq.toploc, symbolseq, AnalProc, FALSE, FALSE];
};

CkS: PROC[s: LONG STRING] = {
IF s = NIL THEN 
	IF Subr.debugflg THEN Runtime.CallDebugger["A String is NIL"L]
		ELSE CWF.WF0["A String is NIL\n"L];
};

CkT: PROC[sp: MDModel.Symbol, st: MDModel.SubType] = {
IF sp ~= NIL AND sp.stype ~= st THEN
	IF Subr.debugflg THEN Runtime.CallDebugger["Bad type"L]
		ELSE CWF.WF1["Bad type %s\n"L, MDModel.Sym[sp]];
};
-- verify spelem is on splet.letgrp
VerifyLet: PROC[spelem: MDModel.Symbol, splet: MDModel.LETSymbol] = {
splist: MDModel.LISTSymbol;
IF splet = NIL THEN RETURN;
splist _ splet.letgrp;
WHILE splist ~= NIL DO
	IF splist.first = spelem THEN EXIT;
	splist _ splist.rest;
	ENDLOOP;
IF splist = NIL THEN {
	CWF.WF1["%s is not on LET list.\n"L, MDModel.Sym[spelem]];
	RETURN;
	};
WITH spt~~spelem SELECT FROM
typeTYPE => IF spt.letparent ~= splet THEN
		-- type letparent is not filled in
		IF Subr.debugflg THEN Runtime.CallDebugger["Bad letparent"L] 
		ELSE CWF.WF1["Bad letparent for %s\n"L, spt.typesym]; 
typeAPPL => IF spt.letparent ~= splet THEN
		-- type letparent is not filled in
		IF Subr.debugflg THEN Runtime.CallDebugger["Bad letparent"L] 
		ELSE CWF.WF1["Bad letparent for %s\n"L, spt.applsym]; 
ENDCASE => ERROR;
};

-- calls itself recursively
VerifyLoc: PROC[sp: MDModel.Symbol] = {
IF sp = NIL THEN RETURN;
WITH sp SELECT FROM
spt: MDModel.LISTSymbol => TraverseList[spt, VerifyLoc];
ENDCASE => IF sp.stype # $typeLOC AND sp.stype # $typeAPPL THEN
	IF Subr.debugflg THEN Runtime.CallDebugger["Loc is neither a LOC nor an APPL\n"L] 
	ELSE CWF.WF0["Loc is neither a LOC nor an APPL\n"L];
}; 
	
GenerateUniqueName: PUBLIC PROC[spappl: MDModel.APPLSymbol] 
	RETURNS[sym: LONG STRING] = {
stemp: STRING _ [100];
u: CARDINAL;
sptype: MDModel.TYPESymbol = MDModel.NarrowToTYPE[spappl.appltype];
sptype.uniqueno _ sptype.uniqueno + 1;
u _ sptype.uniqueno;
CWF.SWF2[stemp, "%s%u"L, spappl.applsym, @u];
RETURN[Subr.CopyString[stemp]];
};


-- returns TRUE if first occurs after second in list sptoplist
After: PUBLIC PROC[first, second: MDModel.Symbol, sptoplist: MDModel.LISTSymbol] 
	RETURNS[BOOL] = {
splist: MDModel.LISTSymbol _ sptoplist;
IF first = NIL OR second = NIL THEN ERROR;
WHILE splist ~= NIL DO
	IF first = splist.first THEN {
		WHILE splist ~= NIL DO
			IF second = splist.first THEN RETURN[FALSE];
			splist _ splist.rest;
			ENDLOOP;
		RETURN[FALSE];	-- second not in list
		};
	IF second = splist.first THEN {
		-- second is in list, if first is after then TRUE
		-- if first is not on list at all, then FALSE
		WHILE splist ~= NIL DO
			IF first = splist.first THEN RETURN[TRUE];
			splist _ splist.rest;
			ENDLOOP;
		RETURN[FALSE];
		};
	splist _ splist.rest;
	ENDLOOP;
RETURN[FALSE];		-- neither is in list
};

-- return TRUE if spnode is on the list beginning at splist
IsOnList: PUBLIC PROC[spnode: MDModel.Symbol, splist: MDModel.LISTSymbol] 
	RETURNS[BOOL] = {
WHILE splist ~= NIL DO
	IF splist.first = spnode THEN RETURN[TRUE];
	splist _ splist.rest;
	ENDLOOP;
RETURN[FALSE];
};

-- remove spremove from the list descending from psptoplist^
-- returns spparent, a list node, parent of spremove and no longer on the list 
-- as well as spremove; returns NIL if spremove is not on the root list
-- returns also a new list with the element removed
RemoveFromList: PUBLIC PROC[spremove: MDModel.Symbol, oldlist: MDModel.LISTSymbol] 
	RETURNS[spparent, newlist: MDModel.LISTSymbol] = {
splist, splast: MDModel.LISTSymbol;
splist _ newlist _ splast _ oldlist;
WHILE splist ~= NIL DO
	MDModel.CkType[splist, $typeLIST];
	IF splist.first = spremove THEN {
		-- delete it
		IF splist = oldlist THEN
			newlist _ splist.rest
		ELSE IF splast.stype = typeLIST THEN
			splast.rest _ splist.rest
		ELSE ERROR;
		spparent _ splist;
		RETURN[spparent, newlist];
		}
	ELSE splast _ splist;
	splist _ splist.rest;
	ENDLOOP;
RETURN[NIL, newlist];
};

SaveBitArray: TYPE = PACKED ARRAY[0..0) OF BOOL;

-- proceed here means don't anlayze any sons of this node
-- it doesn't mean abort the whole tree search

-- if followscopingrules then it will only follow LOC's for models
-- if they are preceded by an OPEN; this is a crock
TraverseTree: PUBLIC PROC[sproot: MDModel.Symbol, symbolseq: MDModel.SymbolSeq,
	proc: PROC[MDModel.Symbol, MDModel.MODELSymbol] RETURNS[BOOL],
	preorder, followscopingrules: BOOL] = {
oldsize: CARDINAL;
savebit: LONG POINTER TO SaveBitArray _ NIL;
longzone: UNCOUNTED ZONE;
nearopen: BOOL;
arrtype: TYPE = RECORD[
	SEQUENCE maxl: CARDINAL OF CARDINAL
	];

	RecurTraverseTree: PROC[sp: MDModel.Symbol, spmodel: MDModel.MODELSymbol,
		proc: PROC[MDModel.Symbol, MDModel.MODELSymbol] RETURNS[BOOL]] = {
	proceed: BOOL;
	IF sp = NIL OR sp.visited THEN RETURN;
	sp.visited _ TRUE;
	IF preorder THEN {
		proceed _ proc[sp, spmodel];
		IF NOT proceed THEN RETURN;
		};
	WITH spt~~sp SELECT FROM
	typeTYPE => {
		RecurTraverseTree[spt.typeval, spmodel, proc];
		};
	typePROC => {
		RecurTraverseTree[spt.procparm, spmodel, proc];
		RecurTraverseTree[spt.procret, spmodel, proc];
		RecurTraverseTree[spt.procval, spmodel, proc];
		};
	typeAPPL => {
		RecurTraverseTree[spt.appltype, spmodel, proc];
		RecurTraverseTree[spt.applval, spmodel, proc];
		};
	typeLIST => {
			RunThruList: PROC[spelem: MDModel.Symbol] = {
			RecurTraverseTree[spelem, spmodel, proc];
			};
		
		TraverseList[MDModel.NarrowToLIST[sp], RunThruList];
		};
	typeLET => {
		RecurTraverseTree[spt.letgrp, spmodel, proc];
		RecurTraverseTree[spt.letval, spmodel, proc];
		};
	typeLOC => {
		-- IF Subr.debugflg THEN
			-- CWF.WF2["%s is in %s.\n"L, spt.tail, 
				-- IF spmodel = NIL THEN "-NIL-"L 
					-- ELSE spmodel.modelfilename];
		RecurTraverseTree[spt.parmlist, spmodel, proc];
		IF NOT followscopingrules OR nearopen THEN
			RecurTraverseTree[spt.nestedmodel, spmodel, proc];
		nearopen _ FALSE;
		};
	typeOPEN => {
		nearopen _ TRUE;
		RecurTraverseTree[spt.open, spmodel, proc];
		nearopen _ FALSE;
		};
	typeMODEL => {
		RecurTraverseTree[spt.model, MDModel.NarrowToMODEL[sp], proc];
		};
	typeSTRING => NULL;
	ENDCASE => ERROR;	-- Unknown stype
	IF NOT preorder THEN {
		[] _ proc[sp, spmodel];
		sp.visited _ TRUE;
		};
	};

{
ENABLE UNWIND => IF savebit = NIL THEN symbolseq.traversalInProgress _ FALSE;
IF sproot = NIL THEN RETURN;
traversetreecalled _ traversetreecalled + 1;
-- IF Subr.debugflg THEN
	-- CWF.WF0["~~~Traverse Tree Begun.\n"L];
IF symbolseq.traversalInProgress THEN {
	longzone _ Subr.LongZone[];
	-- this is to be able to allocate PACKED SEQUENCES
	-- 16 bits ber cardinal
	oldsize _ symbolseq.size;
	IF NOT symbolseq.savedInUse THEN {
		symbolseq.savedInUse _ TRUE;
		savebit _ symbolseq.savedVisited;
		}
	ELSE {
		nwords: CARDINAL _ (oldsize / 16) + 1;
		savebit _ LOOPHOLE[longzone.NEW[arrtype[nwords]]];
		};
	FOR i: CARDINAL IN [0.. symbolseq.size) DO
		savebit[i] _ symbolseq[i].visited;
		ENDLOOP;
	};
symbolseq.traversalInProgress _ TRUE;
FOR i: CARDINAL IN [0.. symbolseq.size) DO
	symbolseq[i].visited _ FALSE;
	ENDLOOP;
nearopen _ TRUE;
RecurTraverseTree[sproot, 
	IF sproot.stype = $typeMODEL THEN MDModel.NarrowToMODEL[sproot] ELSE NIL, proc];
IF savebit ~= NIL THEN {
	FOR i: CARDINAL IN [0.. oldsize) DO
		symbolseq[i].visited _ savebit[i];
		ENDLOOP;
	-- is this necessary?
	FOR i: CARDINAL IN [oldsize .. symbolseq.size) DO
		symbolseq[i].visited _ FALSE;
		ENDLOOP;
	IF savebit ~= symbolseq.savedVisited THEN 
		longzone.FREE[@savebit];
	}
ELSE symbolseq.traversalInProgress _ FALSE;
-- IF Subr.debugflg THEN
	-- CWF.WF0["~~~Traverse Tree Finished.\n"L];
}};

-- the null list is simply sp = NIL
-- the unit list is one list node with a NIL sp.rest
-- lists are always terminated by sp.rest = NIL
-- sp.rest is always of type typeLIST
TraverseList: PUBLIC PROC[sp: MDModel.LISTSymbol, proc: PROC[MDModel.Symbol]] = {
nelem: CARDINAL _ 0;
spnext: MDModel.LISTSymbol;
WHILE sp ~= NIL DO
	MDModel.CkType[sp, $typeLIST];
	nelem _ nelem + 1;
	IF nelem > 1000 THEN ERROR;	-- cycling
	spnext _ sp.rest;	-- in case he deletes it
	proc[sp.first];
	sp _ spnext;
	ENDLOOP;
};

TraverseAndRemove: PUBLIC PROC[oldlist: MDModel.LISTSymbol,
	proc: PROC[sp: MDModel.Symbol] RETURNS[remove: BOOL]]
	RETURNS[newlist: MDModel.LISTSymbol]  = {
splist, splast: MDModel.LISTSymbol;
splast _ splist _ newlist _ oldlist;
WHILE splist ~= NIL DO
	MDModel.CkType[splist, $typeLIST];
	IF proc[splist.first] THEN {
		-- remove it from the list
		IF splist = newlist THEN 
			newlist _ splist.rest
		ELSE IF splast.stype = $typeLIST THEN
			splast.rest _ splist.rest
		ELSE ERROR;
		}
	ELSE splast _ splist;
	splist _ splist.rest;
	ENDLOOP;
RETURN[newlist];
};

-- add to the end of a list
-- psp is a pointer to a node that is the beginning of a list
-- if non-NIL then psp^ must be of type typeLIST
AddToEndOfList: PUBLIC PROC[oldlist: MDModel.LISTSymbol, 
	spadd: MDModel.Symbol, listtype: MDModel.ListType, 
	symbolseq: MDModel.SymbolSeq] 
	RETURNS[newlist: MDModel.LISTSymbol]= {
sp, spbin: MDModel.LISTSymbol;
sp _ newlist _ oldlist;
IF spadd = NIL THEN ERROR;
spbin _ NewSymLIST[symbolseq];
spbin.first _ spadd;
spbin.rest _ NIL;
spbin.listtype _ listtype;
IF sp = NIL THEN newlist _ spbin
ELSE {
	WHILE sp.rest ~= NIL DO
		MDModel.CkType[sp.rest, $typeLIST];
		IF sp.listtype ~= listtype THEN ERROR;
		sp _ sp.rest;
		ENDLOOP;
	sp.rest _ spbin;
	};
RETURN[newlist];
};

-- behaves unusually depending on slist's form
-- if slist = NIL then returns sadd
-- if slist is not a list, the returns a list of slist and sadd
-- if slist is a list, appends sadd to slist and returns slist
-- if sadd is a list, the list is appended, 
-- if not, sadd is added to the list
MergeIntoList: PUBLIC PROC[slist, sadd: MDModel.Symbol, 
	symbolseq: MDModel.SymbolSeq, listtype: MDModel.ListType]
	RETURNS[MDModel.Symbol] = {
CheckNotNil[sadd];
IF slist = NIL THEN RETURN[sadd];
IF slist.stype ~= $typeLIST THEN {
	stop: MDModel.LISTSymbol;
	stop _ AddToEndOfList[NIL, slist, listtype, symbolseq];
	IF sadd.stype = $typeLIST THEN
		stop.rest _ MDModel.NarrowToLIST[sadd]
	ELSE
		stop _ AddToEndOfList[stop, sadd, listtype, symbolseq];
	RETURN[stop];
	}
ELSE {
	sl: MDModel.LISTSymbol _ MDModel.NarrowToLIST[slist];
	IF sadd.stype = $typeLIST THEN {
		sp: MDModel.LISTSymbol _ sl;
		WHILE sp.rest ~= NIL DO
			sp _ sp.rest;
			ENDLOOP;
		sp.rest _ MDModel.NarrowToLIST[sadd];
		}
	ELSE
		sl _ AddToEndOfList[sl, sadd, listtype, symbolseq];
	RETURN[sl];
	};
};

-- the beginning of the list is "sptoplist"
-- spmove is a MDModel.Symbol, spstay is a typeList MDModel.Symbol
-- move "spmove" before "spstay" in symbolseq
-- spmove does not have to be in the list already
SpliceBefore: PUBLIC PROC[symbolseq: MDModel.SymbolSeq, 
	spmove: MDModel.Symbol, spstay: MDModel.LISTSymbol,
	oldlist: MDModel.LISTSymbol] 
	RETURNS[newlist: MDModel.LISTSymbol] = {
spl, spparent, splast: MDModel.LISTSymbol;
[spparent, newlist] _ RemoveFromList[spmove, oldlist];
IF spparent = NIL THEN {
	-- not on list already, must make a new list node first
	spparent _ NewSymLIST[symbolseq];
	spparent.first _ spmove;
	};
splast _ spl _ newlist;
WHILE spl ~= NIL DO
	IF spl = spstay THEN {
		-- stick in front of spstay
		spparent.rest _ spstay;
		IF spl = newlist THEN
			newlist _ spparent
		ELSE IF splast.stype = $typeLIST THEN
			splast.rest _ spparent
		ELSE ERROR;
		EXIT;
		}
	ELSE splast _ spl;
	spl _ spl.rest;
	ENDLOOP;
RETURN[newlist];
};

ZeroOut: PUBLIC PROC[sp: MDModel.Symbol] = {
IF sp = NIL THEN ERROR;
LongZero[sp, MDModel.SymbolRecord.SIZE];
sp.vpart _ typeBAD[];
};

LongZero: PROC[lp: LONG POINTER, size: CARDINAL] = {
IF lp = NIL THEN ERROR;
FOR i: CARDINAL IN [0..size) DO
	(lp+i)^ _ 0;
	ENDLOOP;
};

CheckNotNil: PUBLIC PROC[p: LONG POINTER] = {
IF p = NIL THEN ERROR;
};

-- returns the zone used by the symbolseq
AllocateSymbolSeq: PUBLIC PROC[nsym: CARDINAL] 
	RETURNS[symbolseq: MDModel.SymbolSeq] = {
arrtype: TYPE = RECORD[
	SEQUENCE maxl: CARDINAL OF CARDINAL
	];
space: Space.Handle;
longzone: UNCOUNTED ZONE _ Subr.LongZone[];
npages: LONG CARDINAL;
npages _ (MDModel.SymbolRecord.SIZE.LONG * nsym + MDModel.SymbolSeqRecord[0].SIZE)
	/Environment.wordsPerPage + 1;
space _ Space.Create[size: Inline.LowHalf[npages], parent: Space.virtualMemory];
Space.Map[space];
IF npages > 20 THEN Space.CreateUniformSwapUnits[10, space];
symbolseq _ Space.LongPointer[space];
-- assign to the MAX SIZE !!!!
(LOOPHOLE[symbolseq, LONG POINTER] + MDModel.SymbolSeqRecord[0].SIZE - 1)^ _ nsym;
symbolseq.toploc _ NIL;
symbolseq.controlv _ NIL;
symbolseq.traversalInProgress _ FALSE;
symbolseq.modelSeq _ longzone.NEW[MDModel.ModelSeqRecord[NumberOfModels]];
symbolseq.savedInUse _ FALSE;
symbolseq.savedVisited _ longzone.NEW[arrtype[(symbolseq.maxsize / 16) + 1]];
symbolseq.size _ 0;
RETURN[symbolseq];
};

FreeSymbolSeq: PUBLIC PROC[psymbolseq: LONG POINTER TO MDModel.SymbolSeq] = {
longzone: UNCOUNTED ZONE _ Subr.LongZone[];
space: Space.Handle;
s: MDModel.Symbol;
IF psymbolseq^ = NIL THEN RETURN;
FOR i: CARDINAL IN [0.. psymbolseq^.size) DO
	s _ @(psymbolseq^)[i];
	FreeStringsOf[s];
	ENDLOOP;
longzone.FREE[@psymbolseq.savedVisited];
longzone.FREE[@psymbolseq.modelSeq];
-- this frees symbolseq
space _ Subr.FindMappedSpace[Space.GetHandle[Space.PageFromLongPointer[psymbolseq^]]];
Space.Delete[space: space];
psymbolseq^ _ NIL;
};

FreeStringsOf: PUBLIC PROC[sp1: MDModel.Symbol] = {
WITH sp~~sp1 SELECT FROM
typeTYPE => {
	Subr.FreeString[sp.typesym];
	Subr.FreeString[sp.typeName];
	};
typeLOC => {
	Subr.FreeString[sp.host];
	Subr.FreeString[sp.path];
	Subr.FreeString[sp.tail];
	Subr.FreeString[sp.sext];
	};
typePROC => Subr.FreeString[sp.procsym];
typeSTRING => {
	Subr.FreeString[sp.strsym];
	Subr.FreeString[sp.strval];
	};
typeAPPL => {
	Subr.FreeString[sp.applsym];
	Subr.FreeString[sp.configname];
	};
typeMODEL => Subr.FreeString[sp.modelfilename];
typeLET, typeLIST, typeBAD, typeOPEN => NULL;
ENDCASE => ERROR;
};

-- create new Symbol's
NewSym: PROC[symbolseq: MDModel.SymbolSeq] 
	RETURNS[sym: MDModel.Symbol] = {
sym _ @symbolseq[symbolseq.size];
-- fill in with defaulted values
sym^ _ [vpart: typeBAD[]];
symbolseq.size _ symbolseq.size + 1;
IF symbolseq.size >= symbolseq.maxsize THEN TooManySymbols;
RETURN[sym];
};

NewSymTYPE: PUBLIC PROC[symbolseq: MDModel.SymbolSeq] 
	RETURNS[sym: MDModel.TYPESymbol] = {
sym _ LOOPHOLE[NewSym[symbolseq]];
-- fill in with defaulted values
sym^ _ [vpart: typeTYPE[NIL, NIL, NIL, FALSE, NIL, 0]];
};

NewSymLOC: PUBLIC PROC[symbolseq: MDModel.SymbolSeq] 
	RETURNS[sym: MDModel.LOCSymbol] = {
sym _ LOOPHOLE[NewSym[symbolseq]];
-- fill in with defaulted values
sym^ _ [vpart: typeLOC[NIL, NIL, NIL, NIL, 0, NIL, NIL, NIL, FALSE, 0]];
};

NewSymPROC: PUBLIC PROC[symbolseq: MDModel.SymbolSeq] 
	RETURNS[sym: MDModel.PROCSymbol] = {
sym _ LOOPHOLE[NewSym[symbolseq]];
-- fill in with defaulted values
sym^ _ [vpart: typePROC[NIL, NIL, NIL, NIL]];
};

NewSymSTRING: PUBLIC PROC[symbolseq: MDModel.SymbolSeq] 
	RETURNS[sym: MDModel.STRINGSymbol] = {
sym _ LOOPHOLE[NewSym[symbolseq]];
-- fill in with defaulted values
sym^ _ [vpart: typeSTRING[NIL, NIL]];
};

NewSymAPPL: PUBLIC PROC[symbolseq: MDModel.SymbolSeq] 
	RETURNS[sym: MDModel.APPLSymbol] = {
sym _ LOOPHOLE[NewSym[symbolseq]];
-- fill in with defaulted values
sym^ _ [vpart: typeAPPL[NIL, NIL, NIL, NIL, NIL, NIL]];
};

NewSymLET: PUBLIC PROC[symbolseq: MDModel.SymbolSeq] 
	RETURNS[sym: MDModel.LETSymbol] = {
sym _ LOOPHOLE[NewSym[symbolseq]];
-- fill in with defaulted values
sym^ _ [vpart: typeLET[NIL, NIL]];
};

NewSymLIST: PUBLIC PROC[symbolseq: MDModel.SymbolSeq] 
	RETURNS[sym: MDModel.LISTSymbol] = {
sym _ LOOPHOLE[NewSym[symbolseq]];
-- fill in with defaulted values
sym^ _ [vpart: typeLIST[normal, NIL, NIL]];
};

NewSymOPEN: PUBLIC PROC[symbolseq: MDModel.SymbolSeq] 
	RETURNS[sym: MDModel.OPENSymbol] = {
sym _ LOOPHOLE[NewSym[symbolseq]];
-- fill in with defaulted values
sym^ _ [vpart: typeOPEN[NIL]];
};

NewSymMODEL: PUBLIC PROC[symbolseq: MDModel.SymbolSeq] 
	RETURNS[sym: MDModel.MODELSymbol] = {
sym _ LOOPHOLE[NewSym[symbolseq]];
-- fill in with defaulted values
sym^ _ [vpart: typeMODEL[NIL, FALSE, File.nullCapability, 0, NIL, 
	Space.nullHandle, PilotLoadStateOps.NullConfig, FALSE]];
};

-- discover which nodes are recursive
-- callable from the Debugger
ValidateList: PROC[spl: MDModel.LISTSymbol, print: BOOL _ FALSE] = {
nelem: CARDINAL _ 0;
WHILE spl ~= NIL DO
	MDModel.CkType[spl, $typeLIST];
	nelem _ nelem + 1;
	IF nelem > 1000 THEN ERROR;	-- cycling
	IF print THEN {
		s: LONG STRING;
		spa: MDModel.Symbol _ spl.first;
		s _ MDModel.Sym[spa];
		CWF.WF2["Node %lb, str <%s>\n"L, @spa, s];
		};
	spl _ spl.rest;
	ENDLOOP;
CWF.WF1["%u links.\n"L, @nelem];
};

-- parse command line compiler switches
FoldInParms: PUBLIC PROC[parms: LONG STRING] 
	RETURNS[switches: CompilerOps.LetterSwitches, explicitSortSwitch: BOOL] = {
i: CARDINAL _ 0;
on: BOOL;
ch: CHAR;
  StandardDefaults: CompilerOps.LetterSwitches = [
    TRUE , -- A  Address faults for Nil checks
    TRUE , -- B  Bounds checking
    TRUE , -- C  Compile for Cedar (special FORK)
    FALSE, -- D  Call debugger on compiler error (FALSE => just log error)
    TRUE , -- E  Fixed (big eval stack)
    TRUE , -- F  Floating point microcode
    TRUE , -- G  TRUE => errlog goes to compiler.log, FALSE => use foo.errlog
    FALSE, -- H  Unused
    FALSE, -- I  Unused
    FALSE, -- J  cross-Jumping optimization
    FALSE, -- K  Unused
    TRUE , -- L  Fixed (handle Long pointers)
    TRUE , -- M  Reference counting microcode
    TRUE , -- N  Nil pointer checking
    FALSE, -- O  Unused
    FALSE, -- P  Pause after compilation with errors
    FALSE, -- Q  Unused
    FALSE, -- R  Unused
    TRUE , -- S  Sort (by static frequency) global vars & entry indexes
    FALSE, -- T  Unused
    FALSE, -- U  Uninitialized variable checking
    FALSE, -- V  Unused
    TRUE , -- W  log Warning messages
    FALSE, -- X  Unused
    FALSE, -- Y  complain about KFCB
    FALSE  -- Z  Unused
    ];
-- set defaults
switches _ -- CompilerOps.DefaultSwitches[]; -- StandardDefaults;
switches['s] _ FALSE;	-- the modeller defaults to /-s
explicitSortSwitch _ FALSE;
IF parms = NIL THEN RETURN;
WHILE i < parms.length DO
	on _ TRUE;
	IF parms[i] = '- THEN {
		i _ i + 1;
		on _ FALSE;
		};
	ch _ String.LowerCase[parms[i]];
	IF ch IN ['a .. 'z] THEN {
		switches[ch] _ on;
		IF ch = 's THEN explicitSortSwitch _ TRUE;
		};
	i _ i + 1;
	ENDLOOP;
};

StartMDSupport: PUBLIC PROC = {
longzone: UNCOUNTED ZONE _ Subr.LongZone[];
globalLDSpace _ Space.Create[1, Space.virtualMemory];
Space.Map[globalLDSpace];
fileInfoSeq _ longzone.NEW[FileInfoSeqRecord[NumberOfFileInfoRecords]];
};


StopMDSupport: PUBLIC PROC = {
f: Dir.FileInfo;
longzone: UNCOUNTED ZONE _ Subr.LongZone[];
IF globalLDSpace ~= Space.nullHandle THEN Space.Delete[globalLDSpace];
globalLDSpace _ Space.nullHandle;
FOR i: CARDINAL IN [0 .. fileInfoSeq.size) DO
	f _ fileInfoSeq[i];
	Subr.FreeString[f.bcdFileName];
	Subr.FreeString[f.srcFileName];
	Subr.FreeString[f.moduleName];
	longzone.FREE[@f];
	ENDLOOP;
longzone.FREE[@fileInfoSeq];
};


}.


-- UNUSED or OLD code
-ReplaceBy: PUBLIC PROC[spold, spnew: MDModel.Symbol, 
	symbolseq: MDModel.SymbolSeq] = {
IF spold = spnew THEN ERROR;
FOR i: CARDINAL IN [0.. symbolseq.size) DO
	WITH sp~~(@symbolseq[i]) SELECT FROM
	typeTYPE => {
		IF sp.typeval = spold THEN sp.typeval _ spnew;
		};
	typePROC => {
		IF sp.procparm = spold THEN 
			sp.procparm _ MDModel.NarrowToLIST[spnew];
		IF sp.procret = spold THEN 
			sp.procret _ MDModel.NarrowToLIST[spnew];
		IF sp.procval = spold THEN sp.procval _ spnew;
		};
	typeAPPL => {
		IF sp.appltype = spold THEN sp.appltype _ spnew;
		IF sp.applval = spold THEN sp.applval _ spnew;
		};
	typeLIST => {
		IF sp.first = spold THEN sp.first _ spnew;
		IF sp.rest = spold THEN 
			sp.rest _ MDModel.NarrowToLIST[spnew];
		};
	typeLET => {
		IF sp.letgrp = spold THEN 
			sp.letgrp _ MDModel.NarrowToLIST[spnew];
		IF sp.letval = spold THEN sp.letval _ spnew;
		};
	typeLOC => {
		IF sp.parmlist = spold THEN 
			sp.parmlist _ MDModel.NarrowToLIST[spnew];
		IF sp.nestedmodel = spold THEN 
			sp.nestedmodel _ MDModel.NarrowToMODEL[spnew];
		};
	typeOPEN => {
		IF sp.open = spold THEN sp.open _ spnew;
		};
	typeMODEL => {
		IF sp.model = spold THEN sp.model _ MDModel.NarrowToLIST[spnew];
		};
	typeSTRING => NULL;
	typeBAD => NULL;
	ENDCASE => ERROR;
	ENDLOOP;
};

- uses a POSTORDER tree walk
OldReplaceBy: PROC[spold, spnew: MDModel.Symbol, symbolseq: MDModel.SymbolSeq] = {

	ProcAnalyze: PROC[sp: MDModel.Symbol] RETURNS[proceed: BOOL _ TRUE] = {
	SELECT sp.stype FROM
	$typeTYPE => {
		IF sp.subid = spold THEN sp.subid _ spnew;
		IF sp.typeval = spold THEN sp.typeval _ spnew;
		};
	$typePROC => {
		IF sp.procparm = spold THEN sp.procparm _ spnew;
		IF sp.procret = spold THEN sp.procret _ spnew;
		IF sp.procval = spold THEN sp.procval _ spnew;
		};
	$typeAPPL => {
		IF sp.appltype = spold THEN sp.appltype _ spnew;
		IF sp.applval = spold THEN sp.applval _ spnew;
		};
	$typeLIST => {
		IF sp.first = spold THEN sp.first _ spnew;
		IF sp.rest = spold THEN sp.rest _ spnew;
		};
	$typeLET => {
		IF sp.letgrp = spold THEN sp.letgrp _ spnew;
		IF sp.letval = spold THEN sp.letval _ spnew;
		};
	$typeLOC => {
		IF sp.parmlist = spold THEN sp.parmlist _ spnew;
		};
	$typeSTRING => NULL;
	ENDCASE => ERROR;
	RETURN[TRUE];
	};

IF spold = spnew THEN ERROR;
TraverseTree[symbolseq.toploc, symbolseq, ProcAnalyze, FALSE];
};