
    <<MakeDoParsingImpl.mesa>>
        <<Copyright Ó 1989, 1991 by Xerox Corporation.  All rights reserved.>>
        <<Eduardo Pelegri-Llopart, August 20, 1989 9:26:14 pm PDT>>

    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;

    <<Auxiliary Procs>>
        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]];
            };
    <<Public Procs>>
        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];
                <<pe _ NARROW[parseCache.Lookup[key]];>>
                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];
                    <<should it be an error?>>
                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[];
            };

    <<Mesa/Cedar parser>>
        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 ~ {
            <<PROC [stream: STREAM, parserData: REF] RETURNS [parseData: ParseData] >>
            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];
            };
    <<Config parser>>
        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 ~ {
            <<PROC [stream: STREAM, parserData: REF] RETURNS [parseData: ParseData] >>
            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];
            };
    <<C parser (sort-of)>>
        cParser: Parser ~ NEW [ParserRep Ź [
            parserClass: $C,
            parserName: "C Parser",
            parserProc: CParseProc,
            parserData: NIL
            ]];

        CParseProc: MakeDoParsing.ParserProc ~ {
            <<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>>

            ParseCFile: PROC = {
                <<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>>
                <<>>
                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;
                    <<IF string.SkipTo[0, "/"] # string.Length[] THEN RETURN;>>
                    includesFileList Ź CONS[string, includesFileList];
                    };
                WHILE NOT IO.EndOf[source] DO
                    <<We exit the loop by finding the end of the source stream>>
                    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]; 
            };

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

        Init[];
    END.