TabGen:
PUBLIC
PROC [cedar:
BOOL, cusp: BOOL]
RETURNS [success:
BOOL¬
TRUE] = {
Error:
PROC [sel:
CARDINAL] = {
OutString["\nFAIL - "];
OutString[
SELECT sel
FROM
1 => "more than 255 terminal symbols",
2 => "more than 254 nonterminal symbols",
3 => "more than 2047 states or productions",
4 => "more than 15 symbols in a production right part",
ENDCASE => "NPGS error"];
NPGSConDefs.outeol[1]; success ¬ FALSE;
};
PrefixItem:
PROC [init:
CARDINAL, nItems:
CARDINAL] = {
IO.PutF1[st, " i: CARDINAL ¬ %d;\n", [cardinal[init]] ];
IO.PutRope[st, " dup: PROC = {tab[i] ¬ tab[i-1]; i ¬ i + 1};\n"];
IO.PutRope[st, " app0: PROC [transition: CARDINAL] = {\n"];
IO.PutRope[st, " tab[i] ¬ [[FALSE, 0], transition];\n"];
IO.PutRope[st, " i ¬ i + 1;\n"];
IO.PutRope[st, " };\n"];
IO.PutRope[st, " app1: PROC [pLength: CARDINAL, transition: CARDINAL] = {\n"];
IO.PutRope[st, " tab[i] ¬ [[FALSE, pLength], transition];\n"];
IO.PutRope[st, " i ¬ i + 1;\n"];
IO.PutRope[st, " };\n"];
IO.PutRope[st, " app1t: PROC [transition: CARDINAL] = {\n"];
IO.PutRope[st, " tab[i] ¬ [[FALSE, 1], transition];\n"];
IO.PutRope[st, " i ¬ i + 1;\n"];
IO.PutRope[st, " };\n"];
IO.PutRope[st, " app2: PROC [pLength: CARDINAL, transition: CARDINAL] = {\n"];
IO.PutRope[st, " tab[i] ¬ [[TRUE, pLength], transition];\n"];
IO.PutRope[st, " i ¬ i + 1;\n"];
IO.PutRope[st, " };\n"];
lagItem ¬ NPGSTypes.nullItemRec;
needSplits ¬ nItems >= splitTrigger;
splitNum ¬ 0;
};
PutItem:
PROC [i:
CARDINAL, item: NPGSTypes.ItemRec, first:
CARDINAL] = {
IF (i
MOD 5) = 0
OR i = first
THEN {
IF needSplits THEN
IF i = first
OR sinceSplit >= splitTrigger
THEN {
IF splitNum # 0 THEN IO.PutRope[st, "\n };"];
IO.PutF1[st, "\n split%d: PROC = {", [cardinal[splitNum]]];
sinceSplit ¬ 0;
splitNum ¬ splitNum + 1;
};
IO.PutRope[st, "\n"];
};
IF needSplits THEN IO.PutRope[st, " "] ELSE IO.PutRope[st, " "];
IF (i
MOD 20) = 0
THEN {
IO.PutF1[st, "-- %d\n", [cardinal[i]] ];
IF needSplits THEN IO.PutRope[st, " "] ELSE IO.PutRope[st, " "];
};
SELECT
TRUE
FROM
item = NPGSTypes.nullItemRec => IO.PutRope[st, "i ¬ i + 1;"];
item = lagItem => IO.PutRope[st, "dup[];"];
ENDCASE =>
SELECT item.tag
FROM
0 =>
IO.PutF1[st, "app0[%d];", [cardinal[item.pss]] ];
1 =>
IF item.jf = 1
THEN IO.PutF1[st, "app1t[%d];", [cardinal[item.pss]] ]
ELSE IO.PutF[st, "app1[%d, %d];", [cardinal[item.jf]], [cardinal[item.pss]] ];
2 =>
IO.PutF[st, "app2[%d, %d];", [cardinal[item.jf]], [cardinal[item.pss]] ];
ENDCASE => ERROR;
lagItem ¬ item;
sinceSplit ¬ sinceSplit + 1;
};
PostfixItem:
PROC = {
IF needSplits
THEN {
IO.PutRope[st, "\n };"];
FOR i:
NAT
IN [0..splitNum)
DO
IO.PutF1[st, "\n split%d[];", [cardinal[i]]];
ENDLOOP;
};
IO.PutRope[st, "\n RETURN [tab];\n };\n"];
};
PutProc:
PROC [type:
ROPE] = {
IO.PutRope[st, "\nInit"];
IO.PutRope[st, type];
IF cedar
THEN IO.PutRope[st, ": PUBLIC PROC RETURNS ["]
ELSE IO.PutRope[st, ": PUBLIC PROC [uz: UNCOUNTED ZONE] RETURNS ["];
IO.PutRope[st, type];
IO.PutRope[st, "Ref] = {\n"];
};
PutAlloc:
PROC [type:
ROPE, cons:
BOOL ¬
FALSE, count:
CARDINAL ¬ 0, all:
ROPE ¬
NIL] = {
IO.PutF[st, " tab: %gRef ¬ %gNEW[%g", [rope[type]], [rope[zone]], [rope[type]] ];
IF cons
THEN {
IO.PutRope[st, " ¬ [\n"];
IF count # 0 THEN IO.PutF1[st, " -- %d entries\n", [cardinal[count]] ];
RETURN;
};
IF all = NIL
THEN {
IF count # 0 THEN IO.PutF1[st, "[%d]", [cardinal[count]] ];
IO.PutRope[st, "];\n"];
}
ELSE {
IO.PutF1[st, " ¬ ALL[%g]];\n", [rope[all]] ];
IF count # 0 THEN IO.PutF1[st, " -- %d entries\n", [cardinal[count]] ];
};
};
PutRtn:
PROC [cons:
BOOL ¬
TRUE] = {
IF cons THEN IO.PutRope[st, "]];\n"];
IO.PutRope[st, " RETURN [tab];\n };\n"];
};
PutWord:
PROC [i:
CARDINAL, w:
WORD] = {
IF i # 0 THEN IO.PutChar[st, ',];
IF (i MOD 10) = 0 THEN IO.PutF1[st, "\n -- %d\n ", [cardinal[i]]]
ELSE IO.PutChar[st, ' ];
IO.Put1[st, [cardinal[w]]];
};
PutErrorMsg:
PROC [i:
CARDINAL, e: NPGSTypes.ErrorType] = {
IF i # 0 THEN IO.PutChar[st, ',];
IF (i MOD 10) = 0 THEN IO.PutF1[st, "\n -- %d\n ", [cardinal[i]]]
ELSE IO.PutChar[st, ' ];
IO.PutRope[st, errMsgStr[e]];
};
st: IO.STREAM;
defaultLim: CARDINAL;
lagItem: NPGSTypes.ItemRec;
needSplits: BOOL ¬ FALSE;
sinceSplit: CARDINAL ¬ 0;
splitNum: CARDINAL ¬ 0;
zone: ROPE ¬ IF cedar THEN NIL ELSE "uz.";
IF NPGSConDefs.eofMark > 255 THEN Error[1];
defaultLim ¬ NPGSConDefs.totalTokens-NPGSConDefs.eofMark+1;
IF defaultLim > 255 THEN Error[2];
IF NPGSConDefs.pssLim > 2047 THEN Error[3];
IF NPGSConDefs.rhsLim > 15 THEN Error[4];
IF ~success THEN RETURN [success];
ntab ¬ NPGSConDefs.MakeTab[NPGSConDefs.ntEntries];
ttab ¬ NPGSConDefs.MakeTab[NPGSConDefs.tEntries];
statedata ¬ NPGSConDefs.MakeStateData[NPGSConDefs.sLim];
ntdefaults ¬ NPGSConDefs.MakeNTDefaults[defaultLim+1];
column ¬ NPGSConDefs.MakeColumn[NPGSConDefs.ntEntries+1];
TableSetup[]; NPGSConDefs.closewordstream[]; SquashNTab[];
OutString["\nParse Table Data\n"];
IF NPGSConDefs.flags[printLALR] THEN {PrintNDef[]; TableOverlays[]};
vocabindex ¬ NPGSConDefs.MakeVocabIndex[NPGSConDefs.eofMark+1];
hashval ¬ 3*NPGSConDefs.eofMark/2;
hashval ¬ MIN[251, IF hashval MOD 2 = 0 THEN hashval+1 ELSE hashval];
hashtab ¬ NPGSConDefs.MakeHashTab[hashval+1];
HashTabSetup[];
start output file
NPGSConDefs.openwordstream[scratch: FALSE];
Output header of the implementation file
st ¬ NPGSConDefs.tabStream;
IO.PutF1[st, "-- %gImpl.mesa\n", [rope[NPGSConDefs.typeName]] ];
IO.PutF[st, " -- an NPGS production from %g, %g.\n\n",
[rope[NPGSConDefs.sourceName]], [time[BasicTime.Now[]]] ];
IO.PutF1[st, "DIRECTORY %g;\n\n", [rope[NPGSConDefs.typeName]] ];
IO.PutF1[st, "%gImpl: ", [rope[NPGSConDefs.typeName]]];
IF cedar THEN IO.PutRope[st, "CEDAR "];
IO.PutF1[st, "PROGRAM\n EXPORTS %g\n", [rope[NPGSConDefs.typeName]] ];
IO.PutF1[st, " = { OPEN %g;\n", [rope[NPGSConDefs.typeName]] ];
StatePartition[]; -- compute lastntstate
PutProc["ScanTable"];
PutAlloc[type: "ScanTable", count: ScanTabIndex.LAST-ScanTabIndex.FIRST-1, all: "0"];
FOR i: ScanTabIndex
IN ScanTabIndex
DO
w: WORD ¬ scantab[i];
IF w # 0 THEN IO.PutF[st, " tab[%bC] ¬ %d;\n", [cardinal[i]], [cardinal[w]]];
ENDLOOP;
PutRtn[FALSE];
PutProc["HashTable"];
IO.PutRope[st, " null: VocabHashEntry = [0, 0];\n"];
PutAlloc[type: "HashTable", count: hashval+1, all: "null"];
FOR i:
CARDINAL
IN [0..hashval]
DO
w: NPGSTypes.HashTabRec ¬ hashtab[i];
IF w # [0, 0] THEN
IO.PutF[st, " tab[%d] ¬ [%d, %d];\n",
[cardinal[i]], [cardinal[w.symPtr]], [cardinal[w.link]]];
ENDLOOP;
PutRtn[FALSE];
PutProc["IndexTable"];
PutAlloc[type: "IndexTable", cons: TRUE, count: NPGSConDefs.eofMark+1];
IO.PutF1[st, " %d", [cardinal[vocabindex[0]]]];
FOR i:
CARDINAL
IN [1..NPGSConDefs.eofMark]
DO
w: WORD ¬ vocabindex[i];
PutWord[i, w];
ENDLOOP;
PutRtn[];
PutProc["Vocabulary"];
IO.PutRope[st, " i: CARDINAL ¬ 0;\n"];
IF cedar
THEN IO.PutRope[st, " appText: PROC [r: REF TEXT] = {\n"]
ELSE IO.PutRope[st, " appText: PROC [r: STRING] = {\n"];
IO.PutRope[st, " FOR k: NAT IN [0..r.length) DO tab[i+k] ¬ r[k]; ENDLOOP;\n"];
IO.PutRope[st, " i ¬ i + r.length;\n"];
IO.PutRope[st, " };\n"];
PutAlloc[type: "Vocabulary", count: vocabspace];
IO.PutF1[st, " -- %d chars\n", [cardinal[vocabspace]]];
FOR i:
CARDINAL
IN [0..vocabspace)
DO
c: CHAR ¬ NPGSConDefs.symTab[i];
IF (i
MOD 50) = 0
THEN {
IF i # 0 THEN IO.PutRope[st, "\"];\n"];
IO.PutF1[st, " -- %d\n", [cardinal[i]]];
IO.PutRope[st, " appText[\""];
};
SELECT c
FROM
< 10C => IO.PutF1[st, "\\00%b", [cardinal[c.ORD]]];
< 40C => IO.PutF1[st, "\\0%b", [cardinal[c.ORD]]];
< 177C => IO.PutChar[st, c];
ENDCASE => IO.PutF1[st, "\\%b", [cardinal[c.ORD]]];
ENDLOOP;
IO.PutRope[st, "\"];\n tab.length ¬ i;\n"];
PutRtn[FALSE];
hashtab ¬ NIL;
vocabindex ¬ NIL;
NPGSConDefs.symInfo ¬ NIL;
renumber ¬ NPGSConDefs.MakeRenumber[NPGSConDefs.sLim];
StateRenumber[cusp];
PutProc["ProdData"];
IO.PutRope[st, " i: CARDINAL ¬ 1;\n"];
IO.PutRope[st, " lag: ProductionInfo ¬ [0, 0];\n"];
IO.PutRope[st, " dup: PROC = {tab[i] ¬ lag; i ¬ i + 1};\n"];
IO.PutRope[st, " appR: PROC [r: CARDINAL] = {lag.rule ¬ r; tab[i] ¬ lag; i ¬ i + 1};\n"];
IO.PutRope[st, " appL: PROC [lhs: CARDINAL] = {lag.lhs ¬ lhs; tab[i] ¬ lag; i ¬ i + 1};\n"];
IO.PutRope[st, " appRL: PROC [r, lhs: CARDINAL] = {tab[i] ¬ lag ¬ [r, lhs]; i ¬ i + 1};\n"];
PutAlloc[type: "ProdData", count: NPGSConDefs.numProd+1, all: "lag"];
IO.PutRope[st, " "];
{
lag: NPGSTypes.ProdEntry ¬ NPGSTypes.nullProdEntry;
FOR i:
CARDINAL
IN [1..NPGSConDefs.numProd]
DO
w: NPGSTypes.ProdEntry = NPGSConDefs.prodInfo[i];
wr: CARDINAL ¬ w.rule;
wl: CARDINAL ¬ w.lhs-NPGSConDefs.eofMark+1;
IF i MOD 5 = 0 THEN
IO.PutF1[st, "\n -- %d\n ", [cardinal[i]] ];
SELECT
TRUE
FROM
lag.rule # w.rule AND lag.lhs # w.lhs =>
IO.PutF[st, " appRL[%d, %d];", [cardinal[wr]], [cardinal[wl]] ];
lag.rule # w.rule =>
IO.PutF1[st, " appR[%d];", [cardinal[wr]] ];
lag.lhs # w.lhs =>
IO.PutF1[st, " appL[%d];", [cardinal[wl]] ];
ENDCASE =>
IO.PutRope[st, " dup[];"];
lag ¬ w;
ENDLOOP;
};
PutRtn[FALSE];
PutProc["NStarts"];
PutAlloc[type: "NStarts", cons: TRUE, count: lastntstate+1];
IO.PutF1[st, " %d", [cardinal[0]]];
FOR i:
CARDINAL
IN [1..lastntstate]
DO
w: WORD = statedata[i].ntIndex;
PutWord[i, w];
ENDLOOP;
PutRtn[];
PutProc["NLengths"];
PutAlloc[type: "NLengths", cons: TRUE, count: lastntstate+1];
IO.PutF1[st, " %d", [cardinal[0]] ];
FOR i:
CARDINAL
IN [1..lastntstate]
DO
w: WORD = statedata[i].ntLink;
PutWord[i, w];
ENDLOOP;
PutRtn[];
PutProc["NSymbols"];
PutAlloc[type: "NSymbols", cons: TRUE, count: nlim];
IO.PutF1[st, " %d", [cardinal[ntab[0].symbol]]];
FOR i:
CARDINAL
IN [1..nlim)
DO
w: WORD ¬ ntab[i].symbol;
PutWord[i, w];
ENDLOOP;
PutRtn[];
PutProc["NActions"];
PrefixItem[0, nlim];
IO.PutRope[st, " null: ActionEntry ¬ [[FALSE, 0], 0];\n"];
PutAlloc[type: "NActions", count: nlim, all: "null"];
FOR i:
CARDINAL
IN [0..nlim)
DO
PutItem[i, ntab[i].item, 0];
ENDLOOP;
PostfixItem[];
PutProc["NTDefaults"];
PrefixItem[2, defaultLim+1];
IO.PutRope[st, " null: ActionEntry ¬ [[FALSE, 0], 0];\n"];
PutAlloc[type: "NTDefaults", count: defaultLim+1, all: "null"];
<<IO.PutF1[st, " -- %d entries", [cardinal[defaultLim+1]]];>>
FOR i:
CARDINAL
IN [2..defaultLim]
DO
PutItem[i, ntdefaults[i].item, 2];
ENDLOOP;
PostfixItem[];
PutProc["TStarts"];
PutAlloc[type: "TStarts", cons: TRUE, count: NPGSConDefs.sLim];
IO.PutRope[st, " 0"];
FOR i:
CARDINAL
IN [1..NPGSConDefs.sLim)
DO
w: WORD ¬ statedata[i].tIndex;
PutWord[i, w];
ENDLOOP;
PutRtn[];
PutProc["TLengths"];
PutAlloc[type: "TLengths", cons: TRUE, count: NPGSConDefs.sLim];
IO.PutRope[st, " 0"];
FOR i:
CARDINAL
IN [1..NPGSConDefs.sLim)
DO
w: WORD ¬ statedata[i].tLink;
PutWord[i, w];
ENDLOOP;
PutRtn[];
-- new for CUSP
IF cusp THEN {
PutProc["ErrorMsgs"];
PutAlloc[type: "ErrorMsgs", cons: TRUE, count: NPGSConDefs.sLim];
IO.PutRope[st, " tl"];
FOR i:
CARDINAL
IN [1..NPGSConDefs.sLim)
DO
e: NPGSTypes.ErrorType ¬ NPGSConDefs.CuspPreGetErrorMsg[i];
PutErrorMsg[i, e];
ENDLOOP;
NPGSConDefs.CuspPreClearErrorMsgArray[];
PutRtn[];
};
-- end of CUSP additions
PutProc["TSymbols"];
PutAlloc[type: "TSymbols", cons: TRUE, count: tlim];
IO.PutF1[st, " %d", [cardinal[ttab[0].symbol]]];
FOR i:
CARDINAL
IN [1..tlim)
DO
w: WORD ¬ ttab[i].symbol;
PutWord[i, w];
ENDLOOP;
PutRtn[];
PutProc["TActions"];
PrefixItem[0, tlim];
IO.PutRope[st, " null: ActionEntry ¬ [[FALSE, 0], 0];\n"];
PutAlloc[type: "TActions", count: tlim, all: "null"];
FOR i:
CARDINAL
IN [0..tlim)
DO
PutItem[i, ttab[i].item, 0];
ENDLOOP;
PostfixItem[];
IO.PutRope[st, "\n}.\n"];
NPGSConDefs.prodInfo ¬ NIL; ntab ¬ NIL;
ntdefaults ¬ NIL; renumber ¬ NIL;
statedata ¬ NIL; ttab ¬ NIL;
scantab ¬ NIL;
};
OutModule:
PUBLIC
PROC [cedar:
BOOL, cusp:
BOOL] = {
i,j,k: CARDINAL;
OutCuspErrorType:
PROC = {
OutString[" ErrorType: TYPE = {MAgg, MCalled, MDotLB, MExpr, MId, MOpd,\n"];
OutString[" MOptn, MRArrow, MThe, MTxt, MTypeId, MFieldTypeId, CloseIconExpr,\n"];
OutString[" CopyIconExpr, MoveIconExpr, SelectIconExpr, IconExpr,\n"];
OutString[" Stmt, MSecs, tl};\n"];
};
OutRange:
PROC [id, cover: Rope.
ROPE, ulim:
CARDINAL] = {
NPGSConDefs.outchar[' ,2]; NPGSConDefs.outstring[id]; OutString[": TYPE = "];
IF cover = NIL THEN OutString["CARDINAL"] ELSE NPGSConDefs.outstring[cover];
OutString["[0.."]; NPGSConDefs.outnum[ulim,1]; OutString["];\n"];
};
OutArray:
PROC [id, index, range: Rope.
ROPE] = {
NPGSConDefs.outchar[' ,2]; NPGSConDefs.outstring[id]; OutString[": TYPE = ARRAY "];
NPGSConDefs.outstring[index]; OutString[" OF "]; NPGSConDefs.outstring[range];
NPGSConDefs.outchar[';,1]; NPGSConDefs.outeol[1];
};
OutRefProc:
PROC [referent: Rope.
ROPE] = {
First, output the type definition
NPGSConDefs.outchar[' ,2];
NPGSConDefs.outstring[referent];
IF cedar
THEN OutString["Ref: TYPE = REF "]
ELSE OutString["Ref: TYPE = LONG POINTER TO "];
NPGSConDefs.outstring[referent];
OutString[";"];
NPGSConDefs.outeol[1];
Second output the procedure to call for initialization
NPGSConDefs.outchar[' ,2];
OutString["Init"];
NPGSConDefs.outstring[referent];
IF cedar
THEN OutString[": PROC RETURNS ["]
ELSE OutString[": PROC [uz: UNCOUNTED ZONE] RETURNS ["];
NPGSConDefs.outstring[referent];
OutString["Ref];"];
NPGSConDefs.outeol[2];
};
Output header of the definitions file
OutString["-- "];
NPGSConDefs.outstring[NPGSConDefs.modName];
NPGSConDefs.outeol[1];
OutString["-- an NPGS production from "];
NPGSConDefs.outstring[NPGSConDefs.sourceName];
OutString[", "];
NPGSConDefs.outtime[];
NPGSConDefs.outeol[2];
NPGSConDefs.outstring[NPGSConDefs.typeName];
IF cedar
THEN OutString[": CEDAR DEFINITIONS = {\n\n"]
ELSE OutString[": DEFINITIONS = {\n\n"];
OutRange["Symbol", NIL, NPGSConDefs.maxSymbolIndex];
OutRange["TSymbol", "Symbol", NPGSConDefs.eofMark];
OutRange["NTSymbol", "Symbol", NPGSConDefs.totalTokens-NPGSConDefs.eofMark+1];
OutString["\n-- Token indices for the scanner and parser\n"];
FOR i
IN [0..NPGSConDefs.nextAlias)
DO
NPGSConDefs.outchar[' ,2]; k ¬ NPGSConDefs.aliases[i].alias*NPGSConDefs.tokenSize;
FOR j IN [k..k+NPGSConDefs.tokenSize) WHILE NPGSConDefs.symTab[j]#0c DO NPGSConDefs.outchar[NPGSConDefs.symTab[j],1] ENDLOOP;
OutString[": TSymbol ="]; NPGSConDefs.outnum[NPGSConDefs.aliases[i].terminal,3]; NPGSConDefs.outchar[';,1]; NPGSConDefs.outeol[1];
ENDLOOP;
NPGSConDefs.symTab ¬ NIL; NPGSConDefs.aliases ¬ NIL;
OutString["\n defaultMarker: TSymbol = TSymbol.FIRST;"];
OutString["\n endMarker: TSymbol = TSymbol.LAST;"];
NPGSConDefs.outeol[2];
OutRange["HashIndex", NIL, hashval];
OutRange["VIndex", NIL, vocabspace-1];
NPGSConDefs.outeol[1];
OutString["\n VocabHashEntry: TYPE = RECORD ["];
OutString["\n symbol: TSymbol, -- symbol index"];
OutString["\n link: HashIndex]; -- link to next entry"];
NPGSConDefs.outeol[2];
OutRange["State", NIL, NPGSConDefs.sLim-1];
OutRange["NTState", "State", lastntstate];
OutRange["TIndex", NIL, tlim-1];
OutRange["NTIndex", NIL, nlim-1];
OutRange["Production", NIL, NPGSConDefs.numProd];
OutRange["Rule", NIL, NPGSConDefs.numRules];
IF cusp THEN OutCuspErrorType[]; -- New for CUSP
OutString["\n ActionTag: TYPE = RECORD ["];
OutString["\n reduce: BOOL, -- TRUE iff reduce entry"];
OutString["\n pLength: [0..15]]; -- number of symbols in production rhs\n"];
OutString["\n ActionEntry: TYPE = RECORD ["];
OutString["\n tag: ActionTag, -- [FALSE,0] if a shift entry"];
OutString["\n transition: [0..2047]]; -- production number / next state\n"];
OutString["\n ProductionInfo: TYPE = RECORD ["];
OutString["\n rule: Rule, -- reduction rule"];
OutString["\n lhs: NTSymbol]; -- production lhs symbol\n\n"];
OutArray["ScanTable", "CHAR['\\040..'\\177]", "TSymbol"];
OutArray["HashTable", "HashIndex", "VocabHashEntry"];
OutArray["IndexTable", "TSymbol", "CARDINAL"];
OutString[" Vocabulary: TYPE = TEXT;\n"];
OutArray["ProdData","Production","ProductionInfo"];
OutArray["NStarts", "NTState", "NTIndex"];
OutArray["NLengths", "NTState", "CARDINAL"];
OutArray["NSymbols", "NTIndex", "NTSymbol"];
OutArray["NActions", "NTIndex", "ActionEntry"];
OutArray["NTDefaults", "NTSymbol", "ActionEntry"];
OutArray["TStarts", "State", "TIndex"];
OutArray["TLengths", "State", "CARDINAL"];
IF cusp THEN OutArray["ErrorMsgs", "State", "ErrorType"];
OutArray["TSymbols", "TIndex", "TSymbol"];
OutArray["TActions", "TIndex", "ActionEntry"];
NPGSConDefs.outeol[1];
OutString[" initialState: State = "]; NPGSConDefs.outnum[1,1]; NPGSConDefs.outchar[';,1];
NPGSConDefs.outeol[1];
OutString[" finalState: State = "]; NPGSConDefs.outnum[0,1]; NPGSConDefs.outchar[';,1];
NPGSConDefs.outeol[2];
OutRefProc["ScanTable"];
OutRefProc["HashTable"];
OutRefProc["IndexTable"];
OutRefProc["Vocabulary"];
OutRefProc["ProdData"];
OutRefProc["NStarts"];
OutRefProc["NLengths"];
OutRefProc["NSymbols"];
OutRefProc["NActions"];
OutRefProc["NTDefaults"];
OutRefProc["TStarts"];
OutRefProc["TLengths"];
IF cusp THEN OutRefProc["ErrorMsgs"];
OutRefProc["TSymbols"];
OutRefProc["TActions"];
OutString["\n}.\n"];
};