

DIRECTORY
BasicTime USING [GMT],
FS,
IO,
IOTrueCommentFilter,
MakeDo,
MakeDoParsing,
PBasics,
RefTab,
Rope,
RopeHash;

MakeDoParsingImpl: CEDAR MONITOR
IMPORTS FS, IO, IOTrueCommentFilter, MakeDo, MakeDoParsing, PBasics, RefTab, Rope, RopeHash
EXPORTS MakeDoParsing
~ BEGIN

ROPE: TYPE ~ Rope.ROPE;
STREAM: TYPE ~ IO.STREAM;

parseCache: RefTab.Ref ~ RefTab.Create[equal: EqualParses, hash: HashParse];
parsers: LIST OF Parser;

Parser: TYPE ~ REF ParserRep; ParserRep: TYPE ~ MakeDoParsing.ParserRep;

ParserProc: TYPE ~ MakeDoParsing.ParserProc;
ParseEntry: TYPE ~ REF ParseEntryRep; ParseEntryRep: TYPE ~ MakeDoParsing.ParseEntryRep;
End: TYPE ~ MakeDo.End;

ParserClass: TYPE ~ MakeDoParsing.ParserClass;
ParseData: TYPE ~ MakeDoParsing.ParseData;
Node: TYPE ~ MakeDoParsing.Node;

ParserClassFail: PUBLIC ERROR ~ CODE;
SyntaxError: PUBLIC SIGNAL[synMsg: ROPE] = CODE;

GotoSyntaxError: ERROR = CODE;

CardsPerRef: INT ~ SIZE[REF]/SIZE[CARDINAL];

Munch: PROC [in: REF] RETURNS [out: CARDINAL] ~ {
temp: ARRAY [0..CardsPerRef) OF CARDINAL ~ LOOPHOLE[in];
out Ź temp[0];
FOR i: INT IN (0..CardsPerRef) DO
out Ź PBasics.BITXOR[out, temp[i]];
ENDLOOP;
};

EqualParses: PROC [key1, key2: REF] RETURNS [BOOL] ~ {
pe1: ParseEntry ~ NARROW[key1];
pe2: ParseEntry ~ NARROW[key2];
IF pe1 = NIL OR pe2 = NIL THEN RETURN [pe1 = pe2];
RETURN [pe1.source.Equal[pe2.source] AND pe1.parserClass = pe2.parserClass]; 
};

HashParse: PROC [key: REF] RETURNS [CARDINAL] ~ {
pe: ParseEntry ~ NARROW[key];
w1: CARDINAL ~ RopeHash.FromRope[pe.source];
w2: CARDINAL ~ Munch[pe.parserClass];
RETURN [PBasics.BITXOR[w1, w2]];
};
GetParseEntry: PUBLIC PROC [node: Node, class: ParserClass] RETURNS [parseEntry: ParseEntry] ~ {
createTime: BasicTime.GMT ~ MakeDo.InnerGetCreated[node];
nodeName: ROPE ~ node.PublicPartsOfNode[].name;
IF createTime = MakeDo.notExistTime THEN RETURN [NIL];
{
parser: Parser ~ GetParser[class];
key: ParseEntry ~ NEW [ParseEntryRep Ź [source: nodeName, parserClass: class, parseData: NIL]];
inStream: STREAM Ź NIL;
pe: ParseEntry;
IF parser = NIL THEN ERROR ParserClassFail;
pe Ź NARROW[parseCache.Fetch[key].val];
IF pe = NIL THEN pe Ź NEW [ParseEntryRep Ź [source: nodeName, parserClass: class, parseData: RefTab.Create[]]];
IF pe.stamp = createTime THEN RETURN [pe];
inStream Ź FS.StreamOpen[fileName: nodeName, accessOptions: $read !FS.Error => {inStream Ź NIL; CONTINUE}];
IF inStream = NIL THEN RETURN [NIL];
pe.stamp Ź createTime;
pe.parseData Ź parser.parserProc[inStream, parser.parserData !
FS.Error => { pe Ź NIL; CONTINUE};
MakeDoParsing.SyntaxError => { SIGNAL MakeDo.Warning[IO.PutFR["In %g: %g", IO.rope[nodeName], IO.rope[synMsg]]]; RESUME };
];
inStream.Close[];
IF pe # NIL THEN [] Ź parseCache.Insert[pe, pe];
RETURN [parseEntry: pe];
};
};

AddParser: PUBLIC ENTRY PROC [parser: Parser, end: End] ~ {
ENABLE UNWIND => {};
SELECT end FROM
front => parsers Ź CONS[parser, parsers];
back => {
list : LIST OF Parser;
IF parsers = NIL THEN {parsers Ź LIST[parser]; RETURN};
FOR list Ź parsers, list.rest WHILE list.rest # NIL DO NULL ENDLOOP;
list.rest Ź LIST[parser]};
ENDCASE => ERROR;
};

GetParser: PUBLIC ENTRY PROC [class: ParserClass] RETURNS [parser: Parser] ~ {
ENABLE UNWIND => {};
FOR list: LIST OF Parser Ź parsers, list.rest WHILE list # NIL DO
IF class = list.first.parserClass THEN RETURN [list.first];
ENDLOOP;
RETURN;
};
EnumerateParsers: PUBLIC ENTRY PROC [to: PROC [parser: Parser] RETURNS [stop: BOOL Ź FALSE]] ~ {
ENABLE UNWIND => {};
FOR list: LIST OF Parser Ź parsers, list.rest WHILE list # NIL DO
IF to[list.first] THEN EXIT;
ENDLOOP;
RETURN
};

ClearCache: PUBLIC ENTRY PROC ~ {
ENABLE UNWIND => {};
parseCache.Erase[];
};

mesaParser: Parser ~ NEW [ParserRep Ź [
parserClass: $Mesa,
parserName: "Cedar/Mesa Parser",
parserProc: MesaParseProc,
parserData: NIL
]];

MesaBreak: IO.BreakProc = {RETURN [SELECT char FROM
IN ['a .. 'z], IN ['A .. 'Z], IN ['0 .. '9] => other,
IO.SP, IO.CR, IO.TAB, IO.LF, IO.FF => sepr,
ENDCASE => break]};

MesaLetter: PROC [c: CHAR] RETURNS [letter: BOOLEAN] = INLINE
{letter Ź (c IN ['a .. 'z]) OR (c IN ['A .. 'Z])};


MesaParseProc: MakeDoParsing.ParserProc ~ {
Consume: PROC [fileName: ROPE] ~ {
directoryFileList Ź CONS[fileName, directoryFileList];
RETURN;
};
NextToken: PROC RETURNS [ROPE] =
{RETURN [source.GetTokenRope[MesaBreak].token]};
ParseDirectory: PROC RETURNS [next: ROPE] =
BEGIN
firstClause: BOOL Ź TRUE;
ParseClause: PROC RETURNS [next: ROPE] =
BEGIN
fileName: ROPE Ź "?";
next Ź NextToken[];
IF firstClause THEN
{firstClause Ź FALSE; IF next.Equal[";"] THEN RETURN};
IF NOT MesaLetter[next.Fetch[0]] THEN ERROR GotoSyntaxError;
fileName Ź next;
next Ź NextToken[];
IF next.Equal[":"] THEN
BEGIN
next Ź NextToken[];
IF next.Equal["TYPE"] THEN {
next Ź NextToken[];
IF MesaLetter[next.Fetch[0]] AND NOT next.Equal["USING"] THEN next Ź NextToken[];
}
ELSE IF next.Equal["FROM"] THEN {
fileName Ź source.GetRopeLiteral[];
next Ź NextToken[];
}
ELSE ERROR GotoSyntaxError;
END;
IF next.Equal["USING"] THEN
BEGIN
IF NOT (next Ź NextToken[]).Equal["["] THEN ERROR GotoSyntaxError;
WHILE NOT (next Ź NextToken[]).Equal["]"] DO NULL ENDLOOP;
next Ź NextToken[];
END;
Consume[fileName];
END;
IF (next Ź NextToken[]).Equal["DIRECTORY"] THEN
BEGIN
DO
IF (next Ź ParseClause[]).Equal[";"] THEN EXIT;
IF NOT next.Equal[","] THEN ERROR GotoSyntaxError;
ENDLOOP;
next Ź NextToken[];
END;
IF NOT MesaLetter[next.Fetch[0]] THEN ERROR GotoSyntaxError;
END;
ParseMesaHead: PROC RETURNS [next: ROPE] ~ {
type: ATOM Ź $Unknown;
next Ź NextToken[];
WHILE next.Equal[","] DO
next Ź NextToken[];
next Ź NextToken[]
ENDLOOP;
IF NOT next.Equal[":"] THEN ERROR GotoSyntaxError;
next Ź NextToken[];
IF next.Equal["CEDAR"] THEN next Ź NextToken[];
SELECT TRUE FROM
next.Equal["DEFINITIONS"] => sourceType Ź $CedarDefs;
next.Equal["PROGRAM"] => sourceType Ź $CedarProg;
next.Equal["MONITOR"] => sourceType Ź $CedarMonitor;
ENDCASE => ERROR GotoSyntaxError;
};
DoIt: PROC ~ {
[] Ź ParseDirectory[!
GotoSyntaxError => {
SIGNAL MakeDoParsing.SyntaxError[IO.PutFR["Syntax error; parse aborted at %g", [integer[source.GetIndex[]]]]];
GOTO Done
};
IO.EndOfStream => {
SIGNAL MakeDoParsing.SyntaxError[IO.PutFR["Premature end-of-file; parse aborted at %g", [integer[source.GetIndex[]]]]];
GOTO Done
};
];
[] Ź ParseMesaHead[!
GotoSyntaxError => {
SIGNAL MakeDoParsing.SyntaxError[IO.PutFR["Syntax error; parse aborted at %g", [integer[source.GetIndex[]]]]];
GOTO Done
};
IO.EndOfStream => {
SIGNAL MakeDoParsing.SyntaxError[IO.PutFR["Premature end-of-file; parse aborted at %g", [integer[source.GetIndex[]]]]];
GOTO Done
};
];
EXITS
Done => NULL;
};
source: STREAM ~ IOTrueCommentFilter.CreateCommentFilterStream[stream];
sourceType: ATOM Ź $Unknown;
directoryFileList: LIST OF ROPE Ź NIL;
[] Ź source.GetIndex[];
DoIt[];
parseData Ź RefTab.Create[];
[] Ź parseData.Insert[$SourceType, sourceType];
[] Ź parseData.Insert[$Directory, directoryFileList];
RETURN [parseData];
};
configParser: Parser ~ NEW [ParserRep Ź [
parserClass: $Config,
parserName: "Config Parser",
parserProc: ConfigParseProc,
parserData: NIL
]];

ListOfListsToList: PROC [listOfLists: LIST OF LIST OF ROPE] RETURNS [list: LIST OF ROPE Ź NIL] ~ {
FOR l: LIST OF LIST OF ROPE Ź listOfLists, l.rest WHILE l # NIL DO
FOR m: LIST OF ROPE Ź l.first, m.rest WHILE m # NIL DO
list Ź CONS[m.first, list];
ENDLOOP;
ENDLOOP;
};

ConfigParseProc: MakeDoParsing.ParserProc ~ {
AddDef: PROC [name: ROPE] = {locals.first Ź CONS[name, locals.first]};
MaybeConsume: PROC [moduleName: ROPE] = {
FOR l: LIST OF LIST OF ROPE Ź locals, l.rest WHILE l # NIL DO
FOR m: LIST OF ROPE Ź l.first, m.rest WHILE m # NIL DO
IF m.first.Equal[moduleName] THEN RETURN;
ENDLOOP;
ENDLOOP;
requestsFileList Ź CONS[moduleName, requestsFileList];
};
Consume: PROC [fileName: ROPE] ~ {
requestsFileList Ź CONS[fileName, requestsFileList];
};
ConsumeSimple: PROC [fileName: ROPE] ~ {
staticRequestsFileList Ź CONS[fileName, staticRequestsFileList];
};
NextToken: PROC RETURNS [ROPE] = {RETURN [source.GetTokenRope[MesaBreak].token]};
IsConfig: PROC [word: ROPE] RETURNS [is: BOOLEAN] = {
is Ź word.Equal["CONFIGURATION"] OR word.Equal["CONFIG"];
sourceType Ź $Config
};
ParseConfigDescription: PROC = {
next: ROPE Ź ParseCDirectory[];
next Ź ParseCPacking[next];
next Ź ParseConfiguration[next];
IF NOT next.Equal["."] THEN ERROR GotoSyntaxError;
};
ParseConfiguration: PROC [first: ROPE] RETURNS [next: ROPE] = {
IF NOT MesaLetter[first.Fetch[0]] THEN ERROR GotoSyntaxError;
IF NOT (next Ź NextToken[]).Equal[":"] THEN ERROR GotoSyntaxError;
IF NOT IsConfig[next Ź NextToken[]] THEN ERROR GotoSyntaxError;
next Ź ParseConfigurationRemains[];
};
ParseConfigurationRemains: PROC RETURNS [next: ROPE] = {
next Ź ParseCHeadRemains[];
IF NOT (next.Equal["="] OR next.Equal["~"]) THEN ERROR GotoSyntaxError;
ParseCBody[];
next Ź NextToken[];
};
ParseCBody: PROC = {
next: ROPE Ź NextToken[];
curly: BOOLEAN;
IF next.Equal["BEGIN"] THEN curly Ź FALSE
ELSE IF next.Equal["{"] THEN curly Ź TRUE
ELSE ERROR GotoSyntaxError;
locals Ź CONS[NIL, locals];
next Ź NextToken[];
DO
semiSeen: BOOL Ź FALSE;
next Ź ParseCStatement[next];
WHILE next.Equal[";"] DO
next Ź NextToken[];
semiSeen Ź TRUE;
ENDLOOP;
IF next.Equal[IF curly THEN "}" ELSE "END"] THEN EXIT;
IF NOT semiSeen THEN ERROR GotoSyntaxError;
ENDLOOP;
locals Ź locals.rest;
};
ParseCStatement: PROC [first: ROPE] RETURNS [next: ROPE] = {
next Ź first;
IF next.Equal["["] THEN
BEGIN
next Ź ParseItemList[FALSE];
IF NOT next.Equal["]"] THEN ERROR GotoSyntaxError;
next Ź NextToken[];
IF NOT next.Equal["_"] THEN ERROR GotoSyntaxError;
next Ź ParseCExpression[];
END
ELSE BEGIN
lhs, rhs: ROPE;
named: BOOL Ź FALSE;
lhs Ź rhs Ź next;
IF named Ź (next Ź NextToken[]).Equal[":"] THEN
BEGIN
IF IsConfig[rhs Ź NextToken[]] THEN {
AddDef[lhs];
next Ź ParseConfigurationRemains[];
RETURN};
next Ź NextToken[];
END;
IF next.Equal["_"] THEN
BEGIN
AddDef[lhs];
next Ź ParseCExpression[];
END
ELSE BEGIN
IF named THEN AddDef[lhs];
MaybeConsume[rhs];
IF next.Equal["["] THEN
BEGIN
IF NOT (next Ź NextToken[]).Equal["]"] THEN next Ź EatIDList[next, FALSE];
IF NOT next.Equal["]"] THEN ERROR GotoSyntaxError;
next Ź ParseCLinks[];
END
ELSE IF next.Equal["LINKS"] THEN {
SIGNAL MakeDoParsing.SyntaxError[IO.PutFR["[] missing before %g", IO.int[source.GetIndex[]]]];
next Ź ParseCLinks[next];
};
END;
END;
};
ParseCExpression: PROC RETURNS [next: ROPE] = {
next Ź ParseCRightSide[];
WHILE next.Equal["PLUS"] DO
next Ź ParseCRightSide[];
ENDLOOP;
WHILE next.Equal["THEN"] DO
next Ź ParseCRightSide[];
ENDLOOP;
};
ParseCRightSide: PROC RETURNS [next: ROPE] = {
next Ź ParseItem[NIL, TRUE];
IF next.Equal["["] THEN
BEGIN
IF NOT (next Ź NextToken[]).Equal["]"] THEN next Ź EatIDList[next, FALSE];
IF NOT next.Equal["]"] THEN ERROR GotoSyntaxError;
next Ź ParseCLinks[];
END;
};
ParseCHeadRemains: PROC RETURNS [next: ROPE] = {
next Ź ParseCLinks[];
next Ź ParseImports[next];
next Ź ParseCExports[next];
next Ź ParseStatics[next];
next Ź ParseDynamics[next];
next Ź ParseControlClause[next];
};
ParseCLinks: PROC [first: ROPE Ź NIL] RETURNS [next: ROPE] = {
next Ź IF first # NIL THEN first ELSE NextToken[];
IF NOT next.Equal["LINKS"] THEN RETURN;
IF NOT (next Ź NextToken[]).Equal[":"] THEN ERROR GotoSyntaxError;
next Ź NextToken[];
IF NOT (next.Equal["CODE"] OR next.Equal["FRAME"]) THEN ERROR GotoSyntaxError;
next Ź NextToken[];
};
ParseImports: PROC [first: ROPE] RETURNS [next: ROPE] = {
IF NOT first.Equal["IMPORTS"] THEN RETURN [first];
next Ź ParseItemList[FALSE];
};
ParseCExports: PROC [first: ROPE] RETURNS [next: ROPE] = {
IF NOT first.Equal["EXPORTS"] THEN RETURN [first];
next Ź ParseItemList[FALSE];
};
ParseStatics: PROC [first: ROPE] RETURNS [next: ROPE] = {
IF NOT first.Equal["STATIC"] THEN RETURN [first];
IF NOT (next Ź NextToken[]).Equal["REQUESTS"] THEN ERROR GotoSyntaxError;
next Ź ParseStringList[TRUE];
};
ParseDynamics: PROC [first: ROPE] RETURNS [next: ROPE] = {
IF NOT first.Equal["DYNAMIC"] THEN RETURN [first];
IF NOT (next Ź NextToken[]).Equal["REQUESTS"] THEN ERROR GotoSyntaxError;
next Ź ParseStringList[FALSE];
};
ParseControlClause: PROC [first: ROPE] RETURNS [next: ROPE] = {
IF NOT first.Equal["CONTROL"] THEN RETURN [first];
next Ź EatIDList[NIL, FALSE];
};
ParseItemList: PROC [notice: BOOLEAN] RETURNS [next: ROPE] = {
DO
next Ź ParseItem[NIL, notice];
IF NOT next.Equal[","] THEN EXIT;
ENDLOOP;
};
ParseItem: PROC [first: ROPE, notice: BOOLEAN] RETURNS [next: ROPE] = {
lhs, rhs: ROPE;
named: BOOL Ź FALSE;
lhs Ź rhs Ź IF first = NIL THEN NextToken[] ELSE first;
IF named Ź (next Ź NextToken[]).Equal[":"] THEN
BEGIN
rhs Ź NextToken[];
next Ź NextToken[];
END;
IF notice THEN {
IF named THEN AddDef[lhs];
MaybeConsume[rhs]};
};
ParseStringList: PROC [notice: BOOLEAN] RETURNS [next: ROPE] = {
DO
next Ź ParseString[notice];
IF NOT next.Equal[","] THEN EXIT;
ENDLOOP;
};
ParseString: PROC [notice: BOOLEAN] RETURNS [next: ROPE] = {
string: ROPE;
string Ź source.GetRopeLiteral[ !IO.Error => ERROR GotoSyntaxError];
next Ź NextToken[];
IF notice THEN {
ConsumeSimple[string]};
};
ParseCDirectory: PROC RETURNS [next: ROPE] = {
firstClause: BOOL Ź TRUE;
ParseClause: PROC RETURNS [next: ROPE] = {
moduleName: ROPE Ź "?";
fileName: ROPE Ź "?";
next Ź NextToken[];
IF firstClause THEN
{firstClause Ź FALSE; IF next.Equal[";"] THEN RETURN};
IF NOT MesaLetter[next.Fetch[0]] THEN ERROR GotoSyntaxError;
moduleName Ź fileName Ź next;
next Ź NextToken[];
IF next.Equal[":"] THEN
BEGIN
next Ź NextToken[];
IF next.Equal["TYPE"] THEN {
next Ź NextToken[];
IF MesaLetter[next.Fetch[0]] THEN next Ź NextToken[];
}
ELSE IF next.Equal["FROM"] THEN {
fileName Ź source.GetRopeLiteral[];
next Ź NextToken[];
}
ELSE ERROR GotoSyntaxError;
END;
Consume[fileName];
AddDef[moduleName];
};
locals Ź CONS[NIL, locals];
IF NOT (next Ź NextToken[]).Equal["DIRECTORY"] THEN RETURN;
DO
IF (next Ź ParseClause[]).Equal[";"] THEN EXIT;
IF NOT next.Equal[","] THEN ERROR GotoSyntaxError;
ENDLOOP;
next Ź NextToken[];
};
ParseCPacking: PROC [first: ROPE] RETURNS [next: ROPE] = {
next Ź first;
WHILE next.Equal["PACK"] DO
next Ź EatIDList[NIL, FALSE];
IF NOT next.Equal[";"] THEN ERROR GotoSyntaxError;
next Ź NextToken[];
ENDLOOP;
};
EatIDList: PROC [first: ROPE, notice: BOOLEAN] RETURNS [next: ROPE] = {
next Ź IF first = NIL THEN NextToken[] ELSE first;
DO
IF NOT MesaLetter[next.Fetch[0]] THEN ERROR GotoSyntaxError;
IF notice THEN Consume[next];
next Ź NextToken[];
IF NOT next.Equal[","] THEN EXIT;
next Ź NextToken[];
ENDLOOP;
};
DoIt: PROC ~ {
ParseConfigDescription[!
GotoSyntaxError => {
SIGNAL MakeDoParsing.SyntaxError[IO.PutFR["Syntax error in; parse aborted at %g", [integer[source.GetIndex[]]]]];
GOTO Done
};
IO.EndOfStream => {
SIGNAL MakeDoParsing.SyntaxError[IO.PutFR["Premature end-of-file; parse aborted at %g", [integer[source.GetIndex[]]]]];
GOTO Done
};
];
EXITS
Done => NULL;
};
source: IO.STREAM ~ IOTrueCommentFilter.CreateCommentFilterStream[stream];
sourceType: ATOM Ź $Unknown;
locals: LIST OF LIST OF ROPE Ź NIL;
requestsFileList: LIST OF ROPE Ź NIL;
staticRequestsFileList: LIST OF ROPE Ź NIL;
[] Ź source.GetIndex[];
DoIt[];
parseData Ź RefTab.Create[];
[] Ź parseData.Insert[$SourceType, sourceType];
[] Ź parseData.Insert[$Requests, requestsFileList];
[] Ź parseData.Insert[$StaticRequests, staticRequestsFileList];
[] Ź parseData.Insert[$Locals, ListOfListsToList[locals]];
RETURN [parseData];
};
cParser: Parser ~ NEW [ParserRep Ź [
parserClass: $C,
parserName: "C Parser",
parserProc: CParseProc,
parserData: NIL
]];

CParseProc: MakeDoParsing.ParserProc ~ {

ParseCFile: PROC = {
IncludeSep: ROPE ~ """<";
WhiteSpace: ROPE ~ "	 ";	-- that is a tab and a blank --
WhiteSpaceOrSep: ROPE ~ "\t ""<";
SharpSign: CHAR ~ '#;
IncludeString: ROPE ~ "include";
Consume: PROC [string: ROPE, sepChar: CHAR] ~ {
IF sepChar # '" THEN RETURN;
IF string.Fetch[0] = '/ THEN RETURN;
includesFileList Ź CONS[string, includesFileList];
};
WHILE NOT IO.EndOf[source] DO
currentLine: ROPE;
lineLength: INT;
currentLine Ź IO.GetLineRope[source];
IF currentLine = NIL THEN LOOP;
lineLength Ź currentLine.Length[];
WHILE currentLine.Fetch[lineLength-1] = '\\ DO
currentLine Ź currentLine.Cat[IO.GetLineRope[source ! IO.EndOfStream => ERROR GotoSyntaxError]];
lineLength Ź currentLine.Length[];
ENDLOOP;
IF currentLine.Fetch[0] = SharpSign THEN {
tokStart, tokEnd: INT;
tokStart Ź currentLine.SkipOver[1, WhiteSpace];
IF tokStart = lineLength THEN LOOP;
tokEnd Ź currentLine.SkipTo[tokStart+1, WhiteSpaceOrSep];
IF NOT Rope.Equal[currentLine.Substr[tokStart, tokEnd-tokStart], IncludeString] THEN LOOP;
BEGIN
ENABLE {IO.EndOfStream => ERROR GotoSyntaxError};
matchSep: ROPE;
sepChar: CHAR;
tokStart Ź currentLine.SkipTo[tokEnd, IncludeSep];
sepChar Ź currentLine.Fetch[tokStart];
matchSep Ź IF sepChar = '" THEN """" ELSE ">";
tokEnd Ź currentLine.SkipTo[tokStart+1, matchSep];
Consume[currentLine.Substr[tokStart+1, tokEnd-(1+tokStart)], sepChar];
END;
};
ENDLOOP;
};
DoIt: PROC ~ {
ParseCFile[!
GotoSyntaxError => {
SIGNAL MakeDoParsing.SyntaxError[IO.PutFR["Syntax error at %g", [integer[source.GetIndex[]]]]];
GOTO Done
};
IO.EndOfStream => {
SIGNAL MakeDoParsing.SyntaxError[IO.PutFR["Premature end-of-file; parse aborted at %g", [integer[source.GetIndex[]]]]];
GOTO Done
};
];
EXITS
Done => NULL;
};
source: IO.STREAM ~ IOTrueCommentFilter.CreateCommentFilterStream[stream];
sourceType: ATOM Ź $C;
includesFileList: LIST OF ROPE Ź NIL;
[] Ź source.GetIndex[];
DoIt[];
parseData Ź RefTab.Create[];
[] Ź parseData.Insert[$SourceType, sourceType];
[] Ź parseData.Insert[$Includes, includesFileList];
RETURN [parseData]; 
};

Init: PROC ~ {
MakeDoParsing.AddParser[mesaParser, front];
MakeDoParsing.AddParser[configParser, front];
MakeDoParsing.AddParser[cParser, front];
};

Init[];
END.


    MakeDoParsingImpl.mesa
Copyright Ó 1989, 1991 by Xerox Corporation.  All rights reserved.
Eduardo Pelegri-Llopart, August 20, 1989 9:26:14 pm PDT
Auxiliary Procs
Public Procs
pe _ NARROW[parseCache.Lookup[key]];
should it be an error?

Mesa/Cedar parser
PROC [stream: STREAM, parserData: REF] RETURNS [parseData: ParseData] 
Config parser
PROC [stream: STREAM, parserData: REF] RETURNS [parseData: ParseData] 
C parser (sort-of)
PROC [stream: STREAM, parserData: REF] RETURNS [parseData: ParseData] 
This procedure does NOT take into account all the /lib/cpp tricks that can actually be done.

Actually, the correct way to do this is to use /lib/cpp, which, strictly speaking,
would not work because files may not exist yet and /lib/cpp will complain.
Which takes us to comparing the real differences between the binding models of C and Mesa, but this is not the moment to discuss them
currentLine _ source.GetLineRope;
IF currentLine.... THEN currentLine _ currentLine.Cat[source.GetLineRope ! IO.EndOfStream => ERROR GotoSyntaxError];
--- repeat
if currentLine.Fetch[0] = SharpSign then
SkipOverBlanks
SkipToBlank
if inbetween is "include"
SkipOverBlanks		- if not found here is SyntaxError --
GetSeparatorCharacter		- too
SkipToSeparatorCharater		- too
CONSUME;
REPEAT ALL

IF string.SkipTo[0, "/"] # string.Length[] THEN RETURN;
We exit the loop by finding the end of the source stream
Initialization
 Ęđ  (cedarcode) styleNewlineDelimiter
 codeK
Ďe7BK7K Ďk		K
KKKKKKKKK		K KĐln KM[KK ItypeLL KLK	K HK K,KXKK K.K*K K KĎn%K
 	0K KĐbnK headK ,K 
 1K	8K!K#KKK 
 6KKK2K%MKK 
 	1KK ,K%K

 K "`K 9K
!/K"6K"KD_K
KK
+K'K$KVoK*KCk
$KK>>K"KzKKK 0KKKK  	;KK)		KK

7KDK
KKK 
 	NKAK ;KKKK  `KAKKKKK  
!KKKK 'KK KKKK 	 	3K5K	+KK  

=K2K K  +K	
ĎsF "K6KK 	 K 	
0 +KK (KK
KK	6K<KKKKKKQK!K#KKKKKK!BK
!:KKKK)/KK#/K2KKKK<K ,KKKKKK2KK/K55K11K44K!K KKnK	KKTwK	KKKKnK	KKTwK	KKKKK9GKK	&KKKK/K5KK)KKKKKK  bB6KKKKK  -K	
˘FK F )=6K)KKK6K "K4K (K#@KK
 	)Q
 5K!9KK  KKK K2K
 	?K=K!BK?K##K 8KK
GKKK 
KKK	)K	)KK	
KK
KKKKK6K
+KKK
 	<KKKK2KK2KK
K
KK)/K%KK##KKKKKKK
KKKK!JK2KK"K^KKKKK /KKKKKK .KKK!JK2KKK 0KKKKKK K 	>K		2K'K!BKK
NKK
 	9K	2KK
 	:K	2KK
 	9K	1K(IKK
 	:K	2K(IKK
 	?K	2KK
 
>K
K!KK 		
GK
KK		7)/KKKKKKK
 
@KK!KK
 
<KK!
DKKK .K *KK
KK	6K<KKKKKK5K!K#KKKKKKKK	
K);K#/K2KKK
 	:KKK2KKK 		
GK		2K<KKK!KKK KNqK	KKTwK	KKKKK9JKK#K	%K	+KKKK/K3K?K:KK$KKKKKK  
(K	
˘FK\K KRKJKK  
K!K4tK
(KKKK5KKKK
K K 
	K 
	Ďc8KĎb!K 	K   
/KK$K)7K2KK+8KKK%KK"'.K6`K"K¤	*KK#¤
/K#K(¤9K
; ZK1K
K	K&¤
2K&K.K2KFFKKKK K<_K	KKTwK	KKKKK9JKK	%KKKK/K3KKK  K+K-K(KK KKK K K K      ER  fĆ  