
    <<OneCasabaParserDataImpl.Mesa>>
        <<Copyright Ó 1988 by Xerox Corporation.  All rights reserved.>>
        <<Bill Jackson (bj) November 13, 1988 10:42:21 pm PST>>
        <<>>
    DIRECTORY
        KipperSupport USING [ UnKipperer, UnKipperRef, UnKipperRope, RecordUnKipperedRef, Kipperer, KipperRope, KipperRef ],
        Basics USING [ RawBytes ],
        IO USING [ STREAM, UnsafeGetBlock, UnsafePutBlock ],
        OneCasabaParserData USING [],
        OneCasabaParserPrivate USING [ TokenTable, TokenCellBody, ParserTable, ParserTableBody, TokenTableBody, ActionTable, 
        ActionTableBody, SymbolTable, SymbolTableBody, ActionCell, SymbolCell, TokenCell, ActionCellBody, SymbolCellBody ],
        Rope USING [ ROPE ];

    OneCasabaParserDataImpl: CEDAR PROGRAM
        IMPORTS KipperSupport, IO
        EXPORTS OneCasabaParserData = {
        OPEN Basics, IO, KipperSupport, OneCasabaParserPrivate, Rope;

        RawBytes: PROC [ local: POINTER ] RETURNS [ raw: LONG POINTER TO Basics.RawBytes ] ~
        TRUSTED INLINE { raw _ LOOPHOLE[LONG[local], LONG POINTER TO Basics.RawBytes] };

        InternalPut16: PROC [ k: Kipperer, ptr: LONG POINTER ] ~ TRUSTED INLINE {
        k.stream.UnsafePutBlock[[RawBytes[ptr], 2, 2]]; -- magic here: dorado: 0, sparc: 2!
            };

        InternalGet16: PROC [ u: UnKipperer, ptr: POINTER ] ~ TRUSTED INLINE {
        IF ( u.stream.UnsafeGetBlock[[RawBytes[ptr], 2, 2]] # 2 ) THEN ERROR;
            };

        KipperActionCellBodyRef: PUBLIC PROC [ kipperer: Kipperer,
        ActionCellBodyRef: REF ActionCellBody ] ~ TRUSTED {
            word: CARD16 _ 0;
            doubleWord: CARD32 _ 0;
            refAny: REF _ NIL;
            flag: BOOL _ FALSE;
            IF KipperRef[kipperer, ActionCellBodyRef] THEN {
                InternalPut16[kipperer, @(ActionCellBodyRef.state)];
                InternalPut16[kipperer, @(ActionCellBodyRef.terminal)];
                word _ ORD[(ActionCellBodyRef.action)];
                InternalPut16[kipperer, @(word)];
                InternalPut16[kipperer, @(ActionCellBodyRef.nextState)];
                InternalPut16[kipperer, @(ActionCellBodyRef.ruleNumber)];
                InternalPut16[kipperer, @(ActionCellBodyRef.leftSide)];
                InternalPut16[kipperer, @(ActionCellBodyRef.ruleSize)];
                KipperActionCell[kipperer, (ActionCellBodyRef.next)];
                };
            };

        UnKipperActionCellBodyRef: PUBLIC PROC [ unKipperer: UnKipperer ]
        RETURNS [ ActionCellBodyRef: REF ActionCellBody ] ~ TRUSTED {
            word: CARD16 _ 0;
            doubleWord: CARD32 _ 0;
            refAny: REF _ NIL;
            flag: BOOL _ FALSE;
            [flag, refAny] _ UnKipperRef[unKipperer];
            IF ( flag )
                THEN {
                    refAny _ NEW[ActionCellBody];
                    RecordUnKipperedRef[unKipperer, refAny];
                    ActionCellBodyRef _ NARROW[refAny];
                    InternalGet16[unKipperer, @(ActionCellBodyRef.state)];
                    InternalGet16[unKipperer, @(ActionCellBodyRef.terminal)];
                    InternalGet16[unKipperer, @(word)];
                    (ActionCellBodyRef.action) _ VAL[word];
                    InternalGet16[unKipperer, @(ActionCellBodyRef.nextState)];
                    InternalGet16[unKipperer, @(ActionCellBodyRef.ruleNumber)];
                    InternalGet16[unKipperer, @(ActionCellBodyRef.leftSide)];
                    InternalGet16[unKipperer, @(ActionCellBodyRef.ruleSize)];
                    (ActionCellBodyRef.next) _ UnKipperActionCell[unKipperer];
                    }
                ELSE ActionCellBodyRef _ NARROW[refAny];
            };

        KipperActionTableBodyRef: PUBLIC PROC [ kipperer: Kipperer,
        ActionTableBodyRef: REF ActionTableBody ] ~ TRUSTED {
            word: CARD16 _ 0;
            doubleWord: CARD32 _ 0;
            refAny: REF _ NIL;
            flag: BOOL _ FALSE;
            IF ( KipperRef[kipperer, ActionTableBodyRef] ) THEN {
                count: CARD16 _ ActionTableBodyRef.nSlots;
                InternalPut16[kipperer, @(count)];
                FOR i: CARD16 IN[0..(ActionTableBodyRef.nSlots)) DO
                    KipperActionCell[kipperer, (ActionTableBodyRef.actions[i])];
                    ENDLOOP;
                };
            };

        UnKipperActionTableBodyRef: PUBLIC PROC [ unKipperer: UnKipperer ] RETURNS [ ActionTableBodyRef: REF ActionTableBody ] ~ TRUSTED {
            word: CARD16 _ 0;
            doubleWord: CARD32 _ 0;
            refAny: REF _ NIL;
            flag: BOOL _ FALSE;
            [flag, refAny] _ UnKipperRef[unKipperer];
            IF ( flag )
                THEN {
                    count: CARD16;
                    InternalGet16[unKipperer, @(count)];
                    refAny _ NEW[ActionTableBody[count]];
                    RecordUnKipperedRef[unKipperer, refAny];
                    ActionTableBodyRef _ NARROW[refAny];
                    FOR i: CARD16 IN[0..(ActionTableBodyRef.nSlots)) DO
                        (ActionTableBodyRef.actions[i]) _ UnKipperActionCell[unKipperer];
                        ENDLOOP;
                    }
                ELSE ActionTableBodyRef _ NARROW[refAny];
            };

        KipperTokenCellBodyRef: PUBLIC PROC [ kipperer: Kipperer,
        TokenCellBodyRef: REF TokenCellBody ] ~ TRUSTED {
            word: CARD16 _ 0;
            doubleWord: CARD32 _ 0;
            refAny: REF _ NIL;
            flag: BOOL _ FALSE;
            IF ( KipperRef[kipperer, TokenCellBodyRef] ) THEN {
                KipperRope[kipperer, (TokenCellBodyRef.name)];
                InternalPut16[kipperer, @(TokenCellBodyRef.symbolCode)];
                word _ ORD[(TokenCellBodyRef.kind)];
                InternalPut16[kipperer, @(word)];
                KipperRope[kipperer, (TokenCellBodyRef.spelling)];
                word _ ORD[(TokenCellBodyRef.case)];
                InternalPut16[kipperer, @(word)];
                KipperTokenCell[kipperer, (TokenCellBodyRef.next)];
                };
            };

        UnKipperTokenCellBodyRef: PUBLIC PROC [ unKipperer: UnKipperer ]
        RETURNS [ TokenCellBodyRef: REF TokenCellBody ] ~ TRUSTED {
            word: CARD16 _ 0;
            doubleWord: CARD32 _ 0;
            refAny: REF _ NIL;
            flag: BOOL _ FALSE;
            [flag, refAny] _ UnKipperRef[unKipperer];
            IF ( flag )
                THEN {
                    refAny _ NEW[TokenCellBody];
                    RecordUnKipperedRef[unKipperer, refAny];
                    TokenCellBodyRef _ NARROW[refAny];
                    (TokenCellBodyRef.name)_ UnKipperRope[unKipperer];
                    InternalGet16[unKipperer, @(TokenCellBodyRef.symbolCode)];
                    InternalGet16[unKipperer, @(word)];
                    (TokenCellBodyRef.kind) _ VAL[word];
                    (TokenCellBodyRef.spelling)_ UnKipperRope[unKipperer];
                    InternalGet16[unKipperer, @(word)];
                    (TokenCellBodyRef.case) _ VAL[word];
                    (TokenCellBodyRef.next) _ UnKipperTokenCell[unKipperer];
                    }
                ELSE TokenCellBodyRef _ NARROW[refAny];
            };

        KipperTokenTableBodyRef: PUBLIC PROC [ kipperer: Kipperer,
        TokenTableBodyRef: REF TokenTableBody ] ~ TRUSTED {
            word: CARD16 _ 0;
            doubleWord: CARD32 _ 0;
            refAny: REF _ NIL;
            flag: BOOL _ FALSE;
            IF ( KipperRef[kipperer, TokenTableBodyRef] ) THEN {
                count: CARD16 _ TokenTableBodyRef.nSlots;
                InternalPut16[kipperer, @(count)];
                KipperTokenCell[kipperer, (TokenTableBodyRef.idToken)];
                FOR i: CARD16 IN[0..(TokenTableBodyRef.nSlots)) DO
                    KipperTokenCell[kipperer, (TokenTableBodyRef.tokens[i])];
                    ENDLOOP;
                };
            };

        UnKipperTokenTableBodyRef: PUBLIC PROC [ unKipperer: UnKipperer ]
        RETURNS [ TokenTableBodyRef: REF TokenTableBody ] ~ TRUSTED {
            word: CARD16 _ 0;
            doubleWord: CARD32 _ 0;
            refAny: REF _ NIL;
            flag: BOOL _ FALSE;
            [flag, refAny] _ UnKipperRef[unKipperer];
            IF ( flag )
                THEN {
                    count: CARD16;
                    InternalGet16[unKipperer, @(count)];
                    refAny _ NEW[TokenTableBody[count]];
                    RecordUnKipperedRef[unKipperer, refAny];
                    TokenTableBodyRef _ NARROW[refAny];
                    (TokenTableBodyRef.idToken) _ UnKipperTokenCell[unKipperer];
                    FOR i: CARD16 IN[0..(TokenTableBodyRef.nSlots)) DO
                        (TokenTableBodyRef.tokens[i]) _ UnKipperTokenCell[unKipperer];
                        ENDLOOP;
                    }
                ELSE TokenTableBodyRef _ NARROW[refAny];
            };

        KipperSymbolCellBodyRef: PUBLIC PROC [ kipperer: Kipperer,
        SymbolCellBodyRef: REF SymbolCellBody ] ~ TRUSTED {
            word: CARD16 _ 0;
            doubleWord: CARD32 _ 0;
            refAny: REF _ NIL;
            flag: BOOL _ FALSE;
            IF ( KipperRef[kipperer, SymbolCellBodyRef] ) THEN {
                KipperRope[kipperer, (SymbolCellBodyRef.name)];
                InternalPut16[kipperer, @(SymbolCellBodyRef.code)];
                KipperSymbolCell[kipperer, (SymbolCellBodyRef.next)];
                };
            };

        UnKipperSymbolCellBodyRef: PUBLIC PROC [ unKipperer: UnKipperer ]
        RETURNS [ SymbolCellBodyRef: REF SymbolCellBody ] ~ TRUSTED {
            word: CARD16 _ 0;
            doubleWord: CARD32 _ 0;
            refAny: REF _ NIL;
            flag: BOOL _ FALSE;
            [flag, refAny] _ UnKipperRef[unKipperer];
            IF ( flag )
                THEN {
                    refAny _ NEW[SymbolCellBody];
                    RecordUnKipperedRef[unKipperer, refAny];
                    SymbolCellBodyRef _ NARROW[refAny];
                    (SymbolCellBodyRef.name)_ UnKipperRope[unKipperer];
                    InternalGet16[unKipperer, @(SymbolCellBodyRef.code)];
                    (SymbolCellBodyRef.next) _ UnKipperSymbolCell[unKipperer];
                    }
                ELSE SymbolCellBodyRef _ NARROW[refAny];
            };

        KipperSymbolTableBodyRef: PUBLIC PROC [ kipperer: Kipperer, SymbolTableBodyRef: REF SymbolTableBody ] ~ TRUSTED {
            word: CARD16 _ 0;
            doubleWord: CARD32 _ 0;
            refAny: REF _ NIL;
            flag: BOOL _ FALSE;
            IF ( KipperRef[kipperer, SymbolTableBodyRef] ) THEN {
                count: CARD16 _ SymbolTableBodyRef.nSlots;
                InternalPut16[kipperer, @(count)];
                FOR i: CARD16 IN[0..(SymbolTableBodyRef.nSlots)) DO
                    KipperSymbolCell[kipperer, (SymbolTableBodyRef.symbols[i])];
                    ENDLOOP;
                };
            };

        UnKipperSymbolTableBodyRef: PUBLIC PROC [ unKipperer: UnKipperer ]
        RETURNS [ SymbolTableBodyRef: REF SymbolTableBody ] ~ TRUSTED {
            word: CARD16 _ 0;
            doubleWord: CARD32 _ 0;
            refAny: REF _ NIL;
            flag: BOOL _ FALSE;
            [flag, refAny] _ UnKipperRef[unKipperer];
            IF ( flag )
                THEN {
                    count: CARD16;
                    InternalGet16[unKipperer, @(count)];
                    refAny _ NEW[SymbolTableBody[count]];
                    RecordUnKipperedRef[unKipperer, refAny];
                    SymbolTableBodyRef _ NARROW[refAny];
                    FOR i: CARD16 IN[0..(SymbolTableBodyRef.nSlots)) DO
                        (SymbolTableBodyRef.symbols[i]) _ UnKipperSymbolCell[unKipperer];
                        ENDLOOP;
                    }
                ELSE SymbolTableBodyRef _ NARROW[refAny];
            };

        KipperParserTableBodyRef: PUBLIC PROC [ kipperer: Kipperer,
        ParserTableBodyRef: REF ParserTableBody ] ~ TRUSTED {
            word: CARD16 _ 0;
            doubleWord: CARD32 _ 0;
            refAny: REF _ NIL;
            flag: BOOL _ FALSE;
            IF ( KipperRef[kipperer, ParserTableBodyRef] ) THEN {
                KipperSymbolCell[kipperer, (ParserTableBodyRef.unAnalyzedSymbols)];
                InternalPut16[kipperer, @(ParserTableBodyRef.nSymbols)];
                KipperTokenCell[kipperer, (ParserTableBodyRef.unAnalyzedTokens)];
                InternalPut16[kipperer, @(ParserTableBodyRef.nTokens)];
                KipperActionCell[kipperer, (ParserTableBodyRef.unAnalyzedActions)];
                InternalPut16[kipperer, @(ParserTableBodyRef.nActions)];
                InternalPut16[kipperer, @(ParserTableBodyRef.startState)];
                KipperSymbolTable[kipperer, (ParserTableBodyRef.symbolTable)];
                KipperTokenTable[kipperer, (ParserTableBodyRef.tokenTable)];
                KipperActionTable[kipperer, (ParserTableBodyRef.actionTable)];
                };
            };

        UnKipperParserTableBodyRef: PUBLIC PROC [ unKipperer: UnKipperer ]
        RETURNS [ ParserTableBodyRef: REF ParserTableBody ] ~ TRUSTED {
            word: CARD16 _ 0;
            doubleWord: CARD32 _ 0;
            refAny: REF _ NIL;
            flag: BOOL _ FALSE;
            [flag, refAny] _ UnKipperRef[unKipperer];
            IF ( flag )
                THEN {
                    refAny _ NEW[ParserTableBody];
                    RecordUnKipperedRef[unKipperer, refAny];
                    ParserTableBodyRef _ NARROW[refAny];
                    (ParserTableBodyRef.unAnalyzedSymbols) _ UnKipperSymbolCell[unKipperer];
                    InternalGet16[unKipperer, @(ParserTableBodyRef.nSymbols)];
                    (ParserTableBodyRef.unAnalyzedTokens) _ UnKipperTokenCell[unKipperer];
                    InternalGet16[unKipperer, @(ParserTableBodyRef.nTokens)];
                    (ParserTableBodyRef.unAnalyzedActions) _ UnKipperActionCell[unKipperer];
                    InternalGet16[unKipperer, @(ParserTableBodyRef.nActions)];
                    InternalGet16[unKipperer, @(ParserTableBodyRef.startState)];
                    (ParserTableBodyRef.symbolTable) _ UnKipperSymbolTable[unKipperer];
                    (ParserTableBodyRef.tokenTable) _ UnKipperTokenTable[unKipperer];
                    (ParserTableBodyRef.actionTable) _ UnKipperActionTable[unKipperer];
                    }
                ELSE ParserTableBodyRef _ NARROW[refAny];
            };

        KipperActionCell: PUBLIC PROC [ kipperer: Kipperer, ActionCellVal: ActionCell ] ~ TRUSTED {
            word: CARD16 _ 0;
            doubleWord: CARD32 _ 0;
            refAny: REF _ NIL;
            flag: BOOL _ FALSE;
            IF ( KipperRef[kipperer, ActionCellVal] ) THEN {
                InternalPut16[kipperer, @(ActionCellVal.state)];
                InternalPut16[kipperer, @(ActionCellVal.terminal)];
                word _ ORD[(ActionCellVal.action)];
                InternalPut16[kipperer, @(word)];
                InternalPut16[kipperer, @(ActionCellVal.nextState)];
                InternalPut16[kipperer, @(ActionCellVal.ruleNumber)];
                InternalPut16[kipperer, @(ActionCellVal.leftSide)];
                InternalPut16[kipperer, @(ActionCellVal.ruleSize)];
                KipperActionCell[kipperer, (ActionCellVal.next)];
                };
            };

        UnKipperActionCell: PUBLIC PROC [ unKipperer: UnKipperer ]
        RETURNS [ ActionCellVal: ActionCell ] ~ TRUSTED {
            word: CARD16 _ 0;
            doubleWord: CARD32 _ 0;
            refAny: REF _ NIL;
            flag: BOOL _ FALSE;
            [flag, refAny] _ UnKipperRef[unKipperer];
            IF ( flag )
                THEN {
                    refAny _ NEW[ActionCellBody];
                    RecordUnKipperedRef[unKipperer, refAny];
                    ActionCellVal _ NARROW[refAny];
                    InternalGet16[unKipperer, @(ActionCellVal.state)];
                    InternalGet16[unKipperer, @(ActionCellVal.terminal)];
                    InternalGet16[unKipperer, @(word)];
                    (ActionCellVal.action) _ VAL[word];
                    InternalGet16[unKipperer, @(ActionCellVal.nextState)];
                    InternalGet16[unKipperer, @(ActionCellVal.ruleNumber)];
                    InternalGet16[unKipperer, @(ActionCellVal.leftSide)];
                    InternalGet16[unKipperer, @(ActionCellVal.ruleSize)];
                    (ActionCellVal.next) _ UnKipperActionCell[unKipperer];
                    }
                ELSE ActionCellVal _ NARROW[refAny];
            };

        KipperActionTable: PUBLIC PROC [ kipperer: Kipperer, ActionTableVal: ActionTable ] ~ TRUSTED {
            word: CARD16 _ 0;
            doubleWord: CARD32 _ 0;
            refAny: REF _ NIL;
            flag: BOOL _ FALSE;
            IF ( KipperRef[kipperer, ActionTableVal] ) THEN {
                count: CARD16 _ ActionTableVal.nSlots;
                InternalPut16[kipperer, @(count)];
                FOR i: CARD16 IN[0..(ActionTableVal.nSlots)) DO
                    KipperActionCell[kipperer, (ActionTableVal.actions[i])];
                    ENDLOOP;
                };
            };

        UnKipperActionTable: PUBLIC PROC [ unKipperer: UnKipperer ]
        RETURNS [ ActionTableVal: ActionTable ] ~ TRUSTED {
            word: CARD16 _ 0;
            doubleWord: CARD32 _ 0;
            refAny: REF _ NIL;
            flag: BOOL _ FALSE;
            [flag, refAny] _ UnKipperRef[unKipperer];
            IF ( flag )
                THEN {
                    count: CARD16;
                    InternalGet16[unKipperer, @(count)];
                    refAny _ NEW[ActionTableBody[count]];
                    RecordUnKipperedRef[unKipperer, refAny];
                    ActionTableVal _ NARROW[refAny];
                    FOR i: CARD16 IN[0..(ActionTableVal.nSlots)) DO
                        (ActionTableVal.actions[i]) _ UnKipperActionCell[unKipperer];
                        ENDLOOP;
                    }
                ELSE ActionTableVal _ NARROW[refAny];
            };
        KipperTokenCell: PUBLIC PROC [ kipperer: Kipperer, TokenCellVal: TokenCell ] ~ TRUSTED {
            word: CARD16 _ 0;
            doubleWord: CARD32 _ 0;
            refAny: REF _ NIL;
            flag: BOOL _ FALSE;
            IF ( KipperRef[kipperer, TokenCellVal] ) THEN {
                KipperRope[kipperer, (TokenCellVal.name)];
                InternalPut16[kipperer, @(TokenCellVal.symbolCode)];
                word _ ORD[(TokenCellVal.kind)];
                InternalPut16[kipperer, @(word)];
                KipperRope[kipperer, (TokenCellVal.spelling)];
                word _ ORD[(TokenCellVal.case)];
                InternalPut16[kipperer, @(word)];
                KipperTokenCell[kipperer, (TokenCellVal.next)];
                };
            };

        UnKipperTokenCell: PUBLIC PROC [ unKipperer: UnKipperer ]
        RETURNS [ TokenCellVal: TokenCell ] ~ TRUSTED {
            word: CARD16 _ 0;
            doubleWord: CARD32 _ 0;
            refAny: REF _ NIL;
            flag: BOOL _ FALSE;
            [flag, refAny] _ UnKipperRef[unKipperer];
            IF ( flag )
                THEN {
                    refAny _ NEW[TokenCellBody];
                    RecordUnKipperedRef[unKipperer, refAny];
                    TokenCellVal _ NARROW[refAny];
                    (TokenCellVal.name)_ UnKipperRope[unKipperer];
                    InternalGet16[unKipperer, @(TokenCellVal.symbolCode)];
                    InternalGet16[unKipperer, @(word)];
                    (TokenCellVal.kind) _ VAL[word];
                    (TokenCellVal.spelling)_ UnKipperRope[unKipperer];
                    InternalGet16[unKipperer, @(word)];
                    (TokenCellVal.case) _ VAL[word];
                    (TokenCellVal.next) _ UnKipperTokenCell[unKipperer];
                    }
                ELSE TokenCellVal _ NARROW[refAny];
            };

        KipperTokenTable: PUBLIC PROC [ kipperer: Kipperer, TokenTableVal: TokenTable ] ~ TRUSTED {
            word: CARD16 _ 0;
            doubleWord: CARD32 _ 0;
            refAny: REF _ NIL;
            flag: BOOL _ FALSE;
            IF ( KipperRef[kipperer, TokenTableVal] ) THEN {
                count: CARD16 _ TokenTableVal.nSlots;
                InternalPut16[kipperer, @(count)];
                KipperTokenCell[kipperer, (TokenTableVal.idToken)];
                FOR i: CARD16 IN[0..(TokenTableVal.nSlots)) DO
                    KipperTokenCell[kipperer, (TokenTableVal.tokens[i])];
                    ENDLOOP;
                };
            };

        UnKipperTokenTable: PUBLIC PROC [ unKipperer: UnKipperer ]
        RETURNS [ TokenTableVal: TokenTable ] ~ TRUSTED {
            word: CARD16 _ 0;
            doubleWord: CARD32 _ 0;
            refAny: REF _ NIL;
            flag: BOOL _ FALSE;
            [flag, refAny] _ UnKipperRef[unKipperer];
            IF ( flag )
                THEN {
                    count: CARD16;
                    InternalGet16[unKipperer, @(count)];
                    refAny _ NEW[TokenTableBody[count]];
                    RecordUnKipperedRef[unKipperer, refAny];
                    TokenTableVal _ NARROW[refAny];
                    (TokenTableVal.idToken) _ UnKipperTokenCell[unKipperer];
                    FOR i: CARD16 IN[0..(TokenTableVal.nSlots)) DO
                        (TokenTableVal.tokens[i]) _ UnKipperTokenCell[unKipperer];
                        ENDLOOP;
                    }
                ELSE TokenTableVal _ NARROW[refAny];
            };

        KipperSymbolCell: PUBLIC PROC [ kipperer: Kipperer, SymbolCellVal: SymbolCell ] ~ TRUSTED {
            word: CARD16 _ 0;
            doubleWord: CARD32 _ 0;
            refAny: REF _ NIL;
            flag: BOOL _ FALSE;
            IF ( KipperRef[kipperer, SymbolCellVal] ) THEN {
                KipperRope[kipperer, (SymbolCellVal.name)];
                InternalPut16[kipperer, @(SymbolCellVal.code)];
                KipperSymbolCell[kipperer, (SymbolCellVal.next)];
                };
            };

        UnKipperSymbolCell: PUBLIC PROC [ unKipperer: UnKipperer ]
        RETURNS [ SymbolCellVal: SymbolCell ] ~ TRUSTED {
            word: CARD16 _ 0;
            doubleWord: CARD32 _ 0;
            refAny: REF _ NIL;
            flag: BOOL _ FALSE;
            [flag, refAny] _ UnKipperRef[unKipperer];
            IF ( flag )
                THEN {
                    refAny _ NEW[SymbolCellBody];
                    RecordUnKipperedRef[unKipperer, refAny];
                    SymbolCellVal _ NARROW[refAny];
                    (SymbolCellVal.name)_ UnKipperRope[unKipperer];
                    InternalGet16[unKipperer, @(SymbolCellVal.code)];
                    (SymbolCellVal.next) _ UnKipperSymbolCell[unKipperer];
                    }
                ELSE SymbolCellVal _ NARROW[refAny];
            };

        KipperSymbolTable: PUBLIC PROC [ kipperer: Kipperer, SymbolTableVal: SymbolTable ] ~ TRUSTED {
            word: CARD16 _ 0;
            doubleWord: CARD32 _ 0;
            refAny: REF _ NIL;
            flag: BOOL _ FALSE;
            IF ( KipperRef[kipperer, SymbolTableVal] ) THEN {
                count: CARD16 _ SymbolTableVal.nSlots;
                InternalPut16[kipperer, @(count)];
                FOR i: CARD16 IN[0..(SymbolTableVal.nSlots)) DO
                    KipperSymbolCell[kipperer, (SymbolTableVal.symbols[i])];
                    ENDLOOP;
                };
            };

        UnKipperSymbolTable: PUBLIC PROC [ unKipperer: UnKipperer ]
        RETURNS [ SymbolTableVal: SymbolTable ] ~ TRUSTED {
            word: CARD16 _ 0;
            doubleWord: CARD32 _ 0;
            refAny: REF _ NIL;
            flag: BOOL _ FALSE;
            [flag, refAny] _ UnKipperRef[unKipperer];
            IF ( flag )
                THEN {
                    count: CARD16;
                    InternalGet16[unKipperer, @(count)];
                    refAny _ NEW[SymbolTableBody[count]];
                    RecordUnKipperedRef[unKipperer, refAny];
                    SymbolTableVal _ NARROW[refAny];
                    FOR i: CARD16 IN[0..(SymbolTableVal.nSlots)) DO
                        (SymbolTableVal.symbols[i]) _ UnKipperSymbolCell[unKipperer];
                        ENDLOOP;
                    }
                ELSE SymbolTableVal _ NARROW[refAny];
            };

        KipperParserTable: PUBLIC PROC [ kipperer: Kipperer, ParserTableVal: ParserTable ] ~ TRUSTED {
            word: CARD16 _ 0;
            doubleWord: CARD32 _ 0;
            refAny: REF _ NIL;
            flag: BOOL _ FALSE;
            IF ( KipperRef[kipperer, ParserTableVal] ) THEN {
                KipperSymbolCell[kipperer, (ParserTableVal.unAnalyzedSymbols)];
                InternalPut16[kipperer, @(ParserTableVal.nSymbols)];
                KipperTokenCell[kipperer, (ParserTableVal.unAnalyzedTokens)];
                InternalPut16[kipperer, @(ParserTableVal.nTokens)];
                KipperActionCell[kipperer, (ParserTableVal.unAnalyzedActions)];
                InternalPut16[kipperer, @(ParserTableVal.nActions)];
                InternalPut16[kipperer, @(ParserTableVal.startState)];
                KipperSymbolTable[kipperer, (ParserTableVal.symbolTable)];
                KipperTokenTable[kipperer, (ParserTableVal.tokenTable)];
                KipperActionTable[kipperer, (ParserTableVal.actionTable)];
                };
            };

        UnKipperParserTable: PUBLIC PROC [ unKipperer: UnKipperer ]
        RETURNS [ ParserTableVal: ParserTable ] ~ TRUSTED {
            word: CARD16 _ 0;
            doubleWord: CARD32 _ 0;
            refAny: REF _ NIL;
            flag: BOOL _ FALSE;
            [flag, refAny] _ UnKipperRef[unKipperer];
            IF ( flag )
                THEN {
                    refAny _ NEW[ParserTableBody];
                    RecordUnKipperedRef[unKipperer, refAny];
                    ParserTableVal _ NARROW[refAny];
                    (ParserTableVal.unAnalyzedSymbols) _ UnKipperSymbolCell[unKipperer];
                    InternalGet16[unKipperer, @(ParserTableVal.nSymbols)];
                    (ParserTableVal.unAnalyzedTokens) _ UnKipperTokenCell[unKipperer];
                    InternalGet16[unKipperer, @(ParserTableVal.nTokens)];
                    (ParserTableVal.unAnalyzedActions) _ UnKipperActionCell[unKipperer];
                    InternalGet16[unKipperer, @(ParserTableVal.nActions)];
                    InternalGet16[unKipperer, @(ParserTableVal.startState)];
                    (ParserTableVal.symbolTable) _ UnKipperSymbolTable[unKipperer];
                    (ParserTableVal.tokenTable) _ UnKipperTokenTable[unKipperer];
                    (ParserTableVal.actionTable) _ UnKipperActionTable[unKipperer];
                    }
                ELSE ParserTableVal _ NARROW[refAny];
            };

        }.