home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cocktail / rex.lha / rex / m2c / ScanGen.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-08-18  |  31.7 KB  |  1,060 lines
  1. #include "SYSTEM_.h"
  2.  
  3. #ifndef DEFINITION_Checks
  4. #include "Checks.h"
  5. #endif
  6.  
  7. #ifndef DEFINITION_IO
  8. #include "IO.h"
  9. #endif
  10.  
  11. #ifndef DEFINITION_Texts
  12. #include "Texts.h"
  13. #endif
  14.  
  15. #ifndef DEFINITION_Sets
  16. #include "Sets.h"
  17. #endif
  18.  
  19. #ifndef DEFINITION_Strings
  20. #include "Strings.h"
  21. #endif
  22.  
  23. #ifndef DEFINITION_StringMem
  24. #include "StringMem.h"
  25. #endif
  26.  
  27. #ifndef DEFINITION_Idents
  28. #include "Idents.h"
  29. #endif
  30.  
  31. #ifndef DEFINITION_Errors
  32. #include "Errors.h"
  33. #endif
  34.  
  35. #ifndef DEFINITION_DefTable
  36. #include "DefTable.h"
  37. #endif
  38.  
  39. #ifndef DEFINITION_Dfa
  40. #include "Dfa.h"
  41. #endif
  42.  
  43. #ifndef DEFINITION_ScanTabs
  44. #include "ScanTabs.h"
  45. #endif
  46.  
  47. #ifndef DEFINITION_GenTabs
  48. #include "GenTabs.h"
  49. #endif
  50.  
  51. #ifndef DEFINITION_Texts
  52. #include "Texts.h"
  53. #endif
  54.  
  55. #ifndef DEFINITION_Strings
  56. #include "Strings.h"
  57. #endif
  58.  
  59. #ifndef DEFINITION_Idents
  60. #include "Idents.h"
  61. #endif
  62.  
  63. #ifndef DEFINITION_ScanGen
  64. #include "ScanGen.h"
  65. #endif
  66.  
  67. Texts_tText ScanGen_Export, ScanGen_Global, ScanGen_Local, ScanGen_Begin, ScanGen_Close, ScanGen_Default, ScanGen_Eof, ScanGen_BlankText, ScanGen_TabText, ScanGen_EolText;
  68. SHORTCARD ScanGen_ExportLine, ScanGen_GlobalLine, ScanGen_LocalLine, ScanGen_BeginLine, ScanGen_CloseLine, ScanGen_DefaultLine, ScanGen_EofLine;
  69. Idents_tIdent ScanGen_ScannerName;
  70. ScanGen_tLanguage ScanGen_Language;
  71. Strings_tString ScanGen_RexLib;
  72. struct ScanGen_1 ScanGen_SourceFile;
  73.  
  74. static CHAR ScannerMd [] = "Scanner.md";
  75. static CHAR ScannerMi [] = "Scanner.mi";
  76. static CHAR SourceMd [] = "Source.md";
  77. static CHAR SourceMi [] = "Source.mi";
  78. static CHAR ScanDrvMi [] = "ScanDrv.mi";
  79. static CHAR ScannerH [] = "Scanner.h";
  80. static CHAR ScannerC [] = "Scanner.c";
  81. static CHAR SourceH [] = "Source.h";
  82. static CHAR SourceC [] = "Source.c";
  83. static CHAR ScanDrvC [] = "ScanDrv.c";
  84. static CHAR Scanner [] = "Scanner";
  85. static CHAR Source [] = "Source";
  86. static CHAR Drv [] = "Drv";
  87. static CHAR ExtMd [] = ".md";
  88. static CHAR ExtMi [] = ".mi";
  89. static CHAR ExtH [] = ".h";
  90. static CHAR ExtC [] = ".c";
  91. #define PatternNoMatch    15
  92. #define Warning    4
  93. static Texts_tText Case1, Case2, Context1, Context2, Context3, Context4, Leader, Trailer;
  94. static CARDINAL LabelCount, DummyCount;
  95. static BOOLEAN gGenLine;
  96. static void ExpandLine ARGS((IO_tFile Out, Strings_tString Line));
  97. static void CopyFile ARGS((CHAR InputA[], LONGCARD , Strings_tString OutputS, CHAR SuffixA[], LONGCARD ));
  98. struct S_6 {
  99.     CHAR A[127 + 1];
  100. };
  101. struct S_7 {
  102.     CHAR A[127 + 1];
  103. };
  104. struct S_8 {
  105.     CHAR A[127 + 1];
  106. };
  107. static void GenerateConstants ARGS((IO_tFile Out));
  108. static void GenerateActions ARGS((IO_tFile Out, BOOLEAN ReduceCaseSize, BOOLEAN Warnings));
  109. static void GenerateDecConstDef ARGS((IO_tFile Out, Strings_tString Name, INTEGER Value));
  110. static void GenerateCharConstDef ARGS((IO_tFile Out, Strings_tString Name, CHAR Value));
  111. static void GenerateDecrement ARGS((IO_tFile Out, Strings_tString Name, INTEGER Value));
  112. static void GenerateCaseLabel ARGS((IO_tFile Out, INTEGER Label));
  113. static void GenerateCaseLabels ARGS((IO_tFile Out, Sets_tSet Set));
  114. static CARDINAL MakeLabel ARGS(());
  115. static void GenerateGoto ARGS((IO_tFile Out, CARDINAL Label));
  116. static void GenerateLabel ARGS((IO_tFile Out, CARDINAL Label));
  117. static void WriteLine ARGS((IO_tFile Out, SHORTCARD Line));
  118. static void ConvertAppend ARGS((CHAR a[], LONGCARD , Texts_tText *Text));
  119. static void ConvertAppend2 ARGS((CHAR a1[], LONGCARD , CHAR a2[], LONGCARD , Texts_tText *Text));
  120. static void ConvertAppend3 ARGS((CHAR a1[], LONGCARD , CHAR a2[], LONGCARD , CHAR a3[], LONGCARD , Texts_tText *Text));
  121.  
  122.  
  123. static void ExpandLine
  124. # ifdef __STDC__
  125. (IO_tFile Out, Strings_tString Line)
  126. # else
  127. (Out, Line)
  128. IO_tFile Out;
  129. Strings_tString Line;
  130. # endif
  131. {
  132.   CHAR Ch;
  133.   CARDINAL i;
  134.  
  135.   i = 3;
  136.   for (;;) {
  137.     INC(i);
  138.     if (i > Strings_Length(&Line)) {
  139.       IO_WriteNl(Out);
  140.       goto EXIT_1;
  141.     }
  142.     Ch = Strings_Char(&Line, (Strings_tStringIndex)i);
  143.     switch (Ch) {
  144.     case '@':;
  145.       if (ScanGen_ScannerName == Idents_NoIdent) {
  146.         IO_WriteS(Out, Scanner, 7L);
  147.       } else {
  148.         Idents_WriteIdent(Out, ScanGen_ScannerName);
  149.       }
  150.       break;
  151.     case '$':;
  152.       if (ScanGen_ScannerName == Idents_NoIdent) {
  153.         if (Strings_Char(&Line, (Strings_tStringIndex)(i + 1)) == '_') {
  154.           INC(i);
  155.         }
  156.       } else {
  157.         Idents_WriteIdent(Out, ScanGen_ScannerName);
  158.       }
  159.       break;
  160.     default :
  161.       IO_WriteC(Out, Ch);
  162.       break;
  163.     }
  164.   } EXIT_1:;
  165. }
  166.  
  167. static void CopyFile
  168. # ifdef __STDC__
  169. (CHAR InputA[], LONGCARD O_2, Strings_tString OutputS, CHAR SuffixA[], LONGCARD O_1)
  170. # else
  171. (InputA, O_2, OutputS, SuffixA, O_1)
  172. CHAR InputA[];
  173. LONGCARD O_2;
  174. Strings_tString OutputS;
  175. CHAR SuffixA[];
  176. LONGCARD O_1;
  177. # endif
  178. {
  179.   IO_tFile In, Out;
  180.   Strings_tString FileNameS, PathS, Line;
  181.   struct S_6 PathA;
  182.   OPEN_ARRAY_LOCALS
  183.  
  184.   ALLOC_OPEN_ARRAYS(O_1 * sizeof(CHAR) + O_2 * sizeof(CHAR), 2)
  185.   COPY_OPEN_ARRAY(SuffixA, O_1, CHAR)
  186.   COPY_OPEN_ARRAY(InputA, O_2, CHAR)
  187.   Strings_ArrayToString(InputA, O_2, &FileNameS);
  188.   Strings_Assign(&PathS, &ScanGen_RexLib);
  189.   Strings_Concatenate(&PathS, &FileNameS);
  190.   Strings_Append(&PathS, '\0');
  191.   Strings_StringToArray(&PathS, PathA.A, 128L);
  192.   In = IO_ReadOpen(PathA.A, 128L);
  193.   Checks_ErrorCheck(PathA.A, 128L, In);
  194.   Strings_ArrayToString(SuffixA, O_1, &FileNameS);
  195.   Strings_Concatenate(&OutputS, &FileNameS);
  196.   Strings_Append(&OutputS, '\0');
  197.   Strings_StringToArray(&OutputS, PathA.A, 128L);
  198.   Out = IO_WriteOpen(PathA.A, 128L);
  199.   Checks_ErrorCheck(PathA.A, 128L, Out);
  200.   while (!IO_EndOfFile(In)) {
  201.     Strings_ReadL(In, &Line);
  202.     if (Strings_Length(&Line) >= 2 && Strings_Char(&Line, 1) == '$' && Strings_Char(&Line, 2) == '@') {
  203.       ExpandLine(Out, Line);
  204.     } else {
  205.       Strings_WriteL(Out, &Line);
  206.     }
  207.   }
  208.   IO_ReadClose(In);
  209.   IO_WriteClose(Out);
  210.   FREE_OPEN_ARRAYS
  211. }
  212.  
  213. void ScanGen_GenerateSupport
  214. # ifdef __STDC__
  215. ()
  216. # else
  217. ()
  218. # endif
  219. {
  220.   Strings_tString SourceName, DriverName, Suffix;
  221.  
  222.   Idents_GetString(ScanGen_ScannerName, &SourceName);
  223.   Strings_ArrayToString(Source, 6L, &Suffix);
  224.   Strings_Concatenate(&SourceName, &Suffix);
  225.   if (ScanGen_ScannerName == Idents_NoIdent) {
  226.     Strings_ArrayToString(Scanner, 7L, &DriverName);
  227.   } else {
  228.     Idents_GetString(ScanGen_ScannerName, &DriverName);
  229.   }
  230.   Strings_ArrayToString(Drv, 3L, &Suffix);
  231.   Strings_Concatenate(&DriverName, &Suffix);
  232.   switch (ScanGen_Language) {
  233.   case ScanGen_Modula:;
  234.     CopyFile(SourceMd, 9L, SourceName, ExtMd, 3L);
  235.     CopyFile(SourceMi, 9L, SourceName, ExtMi, 3L);
  236.     CopyFile(ScanDrvMi, 10L, DriverName, ExtMi, 3L);
  237.     break;
  238.   case ScanGen_C:;
  239.     CopyFile(SourceH, 8L, SourceName, ExtH, 2L);
  240.     CopyFile(SourceC, 8L, SourceName, ExtC, 2L);
  241.     CopyFile(ScanDrvC, 9L, DriverName, ExtC, 2L);
  242.     break;
  243.   }
  244. }
  245.  
  246. void ScanGen_GenerateInterface
  247. # ifdef __STDC__
  248. ()
  249. # else
  250. ()
  251. # endif
  252. {
  253.   IO_tFile In, Out;
  254.   Strings_tString FileNameS, PathS, Line;
  255.   struct S_7 PathA;
  256.  
  257.   switch (ScanGen_Language) {
  258.   case ScanGen_Modula:;
  259.     Strings_ArrayToString(ScannerMd, 10L, &FileNameS);
  260.     break;
  261.   case ScanGen_C:;
  262.     Strings_ArrayToString(ScannerH, 9L, &FileNameS);
  263.     break;
  264.   }
  265.   Strings_Assign(&PathS, &ScanGen_RexLib);
  266.   Strings_Concatenate(&PathS, &FileNameS);
  267.   Strings_Append(&PathS, '\0');
  268.   Strings_StringToArray(&PathS, PathA.A, 128L);
  269.   In = IO_ReadOpen(PathA.A, 128L);
  270.   Checks_ErrorCheck(PathA.A, 128L, In);
  271.   if (ScanGen_ScannerName == Idents_NoIdent) {
  272.     Strings_ArrayToString(Scanner, 7L, &PathS);
  273.   } else {
  274.     Idents_GetString(ScanGen_ScannerName, &PathS);
  275.   }
  276.   switch (ScanGen_Language) {
  277.   case ScanGen_Modula:;
  278.     Strings_ArrayToString(ExtMd, 3L, &FileNameS);
  279.     break;
  280.   case ScanGen_C:;
  281.     Strings_ArrayToString(ExtH, 2L, &FileNameS);
  282.     break;
  283.   }
  284.   Strings_Concatenate(&PathS, &FileNameS);
  285.   Strings_Append(&PathS, '\0');
  286.   Strings_StringToArray(&PathS, PathA.A, 128L);
  287.   Out = IO_WriteOpen(PathA.A, 128L);
  288.   Checks_ErrorCheck(PathA.A, 128L, Out);
  289.   while (!IO_EndOfFile(In)) {
  290.     Strings_ReadL(In, &Line);
  291.     if (Strings_Length(&Line) >= 2 && Strings_Char(&Line, 1) == '$') {
  292.       switch (Strings_Char(&Line, 2)) {
  293.       case 'E':;
  294.         WriteLine(Out, ScanGen_ExportLine);
  295.         Texts_WriteText(Out, ScanGen_Export);
  296.         break;
  297.       case '@':;
  298.         ExpandLine(Out, Line);
  299.         break;
  300.       }
  301.     } else {
  302.       Strings_WriteL(Out, &Line);
  303.     }
  304.   }
  305.   IO_ReadClose(In);
  306.   IO_WriteClose(Out);
  307. }
  308.  
  309. void ScanGen_GenerateScanner
  310. # ifdef __STDC__
  311. (BOOLEAN ReduceCaseSize, BOOLEAN Warnings, BOOLEAN GenLine)
  312. # else
  313. (ReduceCaseSize, Warnings, GenLine)
  314. BOOLEAN ReduceCaseSize, Warnings, GenLine;
  315. # endif
  316. {
  317.   IO_tFile In, Out;
  318.   Strings_tString FileNameS, PathS, Line;
  319.   struct S_8 PathA;
  320.  
  321.   gGenLine = GenLine;
  322.   switch (ScanGen_Language) {
  323.   case ScanGen_Modula:;
  324.     Strings_ArrayToString(ScannerMi, 10L, &FileNameS);
  325.     break;
  326.   case ScanGen_C:;
  327.     Strings_ArrayToString(ScannerC, 9L, &FileNameS);
  328.     break;
  329.   }
  330.   Strings_Assign(&PathS, &ScanGen_RexLib);
  331.   Strings_Concatenate(&PathS, &FileNameS);
  332.   Strings_Append(&PathS, '\0');
  333.   Strings_StringToArray(&PathS, PathA.A, 128L);
  334.   In = IO_ReadOpen(PathA.A, 128L);
  335.   Checks_ErrorCheck(PathA.A, 128L, In);
  336.   if (ScanGen_ScannerName == Idents_NoIdent) {
  337.     Strings_ArrayToString(Scanner, 7L, &PathS);
  338.   } else {
  339.     Idents_GetString(ScanGen_ScannerName, &PathS);
  340.   }
  341.   switch (ScanGen_Language) {
  342.   case ScanGen_Modula:;
  343.     Strings_ArrayToString(ExtMi, 3L, &FileNameS);
  344.     break;
  345.   case ScanGen_C:;
  346.     Strings_ArrayToString(ExtC, 2L, &FileNameS);
  347.     break;
  348.   }
  349.   Strings_Concatenate(&PathS, &FileNameS);
  350.   Strings_Append(&PathS, '\0');
  351.   Strings_StringToArray(&PathS, PathA.A, 128L);
  352.   Out = IO_WriteOpen(PathA.A, 128L);
  353.   Checks_ErrorCheck(PathA.A, 128L, Out);
  354.   while (!IO_EndOfFile(In)) {
  355.     Strings_ReadL(In, &Line);
  356.     if (Strings_Length(&Line) >= 2 && Strings_Char(&Line, 1) == '$') {
  357.       switch (Strings_Char(&Line, 2)) {
  358.       case 'G':;
  359.         WriteLine(Out, ScanGen_GlobalLine);
  360.         Texts_WriteText(Out, ScanGen_Global);
  361.         break;
  362.       case 'C':;
  363.         GenerateConstants(Out);
  364.         break;
  365.       case 'M':;
  366.         if (ReduceCaseSize) {
  367.           Line.Chars.A[1] = ' ';
  368.           Line.Chars.A[2] = ' ';
  369.           Strings_WriteL(Out, &Line);
  370.         }
  371.         break;
  372.       case 'L':;
  373.         WriteLine(Out, ScanGen_LocalLine);
  374.         Texts_WriteText(Out, ScanGen_Local);
  375.         break;
  376.       case 'J':;
  377.         if (GenTabs_LeftJustUsed) {
  378.           Line.Chars.A[1] = ' ';
  379.           Line.Chars.A[2] = ' ';
  380.           Strings_WriteL(Out, &Line);
  381.         }
  382.         break;
  383.       case 'A':;
  384.         GenerateActions(Out, ReduceCaseSize, Warnings);
  385.         break;
  386.       case 'N':;
  387.         if (ReduceCaseSize) {
  388.           GenerateCaseLabel(Out, (LONGINT)(GenTabs_PatternCount + 1));
  389.         } else {
  390.           GenerateCaseLabels(Out, GenTabs_PatternTablePtr->A[0].Finals);
  391.         }
  392.         break;
  393.       case 'P':;
  394.         if (ReduceCaseSize) {
  395.           GenerateCaseLabel(Out, (LONGINT)GenTabs_DefaultAction);
  396.         } else {
  397.           GenerateCaseLabel(Out, (LONGINT)Sets_Select(&GenTabs_PatternTablePtr->A[GenTabs_DefaultAction].Finals));
  398.         }
  399.         break;
  400.       case 'D':;
  401.         WriteLine(Out, ScanGen_DefaultLine);
  402.         Texts_WriteText(Out, ScanGen_Default);
  403.         break;
  404.       case 'O':;
  405.         if (ReduceCaseSize) {
  406.           GenerateCaseLabel(Out, (LONGINT)GenTabs_EobAction);
  407.         } else {
  408.           GenerateCaseLabel(Out, (LONGINT)Sets_Select(&GenTabs_PatternTablePtr->A[GenTabs_EobAction].Finals));
  409.         }
  410.         break;
  411.       case 'E':;
  412.         WriteLine(Out, ScanGen_EofLine);
  413.         Texts_WriteText(Out, ScanGen_Eof);
  414.         break;
  415.       case 'I':;
  416.         WriteLine(Out, ScanGen_BeginLine);
  417.         Texts_WriteText(Out, ScanGen_Begin);
  418.         break;
  419.       case 'F':;
  420.         WriteLine(Out, ScanGen_CloseLine);
  421.         Texts_WriteText(Out, ScanGen_Close);
  422.         break;
  423.       case 'T':;
  424.         ScanTabs_PutComb(Out);
  425.         break;
  426.       case 'B':;
  427.         ScanTabs_PutBase(Out);
  428.         break;
  429.       case 'U':;
  430.         ScanTabs_PutDefault(Out);
  431.         break;
  432.       case 'R':;
  433.         ScanTabs_PutEobTrans(Out);
  434.         break;
  435.       case 'Q':;
  436.         if (ReduceCaseSize) {
  437.           ScanTabs_PutAction(Out);
  438.         }
  439.         break;
  440.       case '@':;
  441.         ExpandLine(Out, Line);
  442.         break;
  443.       }
  444.     } else {
  445.       Strings_WriteL(Out, &Line);
  446.     }
  447.   }
  448.   IO_ReadClose(In);
  449.   IO_WriteClose(Out);
  450. }
  451.  
  452. static void GenerateConstants
  453. # ifdef __STDC__
  454. (IO_tFile Out)
  455. # else
  456. (Out)
  457. IO_tFile Out;
  458. # endif
  459. {
  460.   DefTable_DefRange Definition;
  461.   Strings_tString String;
  462.   Idents_tIdent Ident;
  463.   SHORTCARD Number;
  464.  
  465.   Strings_ArrayToString((STRING)"yyFirstCh", 9L, &String);
  466.   GenerateCharConstDef(Out, String, Dfa_FirstCh);
  467.   Strings_ArrayToString((STRING)"yyLastCh", 8L, &String);
  468.   GenerateCharConstDef(Out, String, Dfa_OldLastCh);
  469.   Strings_ArrayToString((STRING)"yyEolCh", 7L, &String);
  470.   GenerateCharConstDef(Out, String, Dfa_EolCh);
  471.   Strings_ArrayToString((STRING)"yyEobCh", 7L, &String);
  472.   GenerateCharConstDef(Out, String, Dfa_EobCh);
  473.   Strings_ArrayToString((STRING)"yyDStateCount", 13L, &String);
  474.   GenerateDecConstDef(Out, String, (LONGINT)Dfa_DStateCount);
  475.   Strings_ArrayToString((STRING)"yyTableSize", 11L, &String);
  476.   GenerateDecConstDef(Out, String, (LONGINT)ScanTabs_TableSize);
  477.   Strings_ArrayToString((STRING)"yyEobState", 10L, &String);
  478.   GenerateDecConstDef(Out, String, (LONGINT)Sets_Select(&GenTabs_PatternTablePtr->A[GenTabs_EobAction].Finals));
  479.   Strings_ArrayToString((STRING)"yyDefaultState", 14L, &String);
  480.   GenerateDecConstDef(Out, String, (LONGINT)Sets_Select(&GenTabs_PatternTablePtr->A[GenTabs_DefaultAction].Finals));
  481.   {
  482.     LONGINT B_1 = 1, B_2 = DefTable_DefCount;
  483.  
  484.     if (B_1 <= B_2)
  485.       for (Definition = B_1;; Definition += 1) {
  486.         if (DefTable_GetKind(Definition) == DefTable_Start) {
  487.           DefTable_GetStartDef(Definition, &Ident, &Number);
  488.           Idents_GetString(Ident, &String);
  489.           GenerateDecConstDef(Out, String, (LONGINT)Number);
  490.         }
  491.         if (Definition >= B_2) break;
  492.       }
  493.   }
  494. }
  495.  
  496. static void GenerateActions
  497. # ifdef __STDC__
  498. (IO_tFile Out, BOOLEAN ReduceCaseSize, BOOLEAN Warnings)
  499. # else
  500. (Out, ReduceCaseSize, Warnings)
  501. IO_tFile Out;
  502. BOOLEAN ReduceCaseSize, Warnings;
  503. # endif
  504. {
  505.   SHORTCARD Rule, Pattern;
  506.   Strings_tString String, String2;
  507.   CARDINAL Label;
  508.  
  509.   if (ReduceCaseSize) {
  510.     Texts_WriteText(Out, Case2);
  511.   } else {
  512.     Texts_WriteText(Out, Case1);
  513.   }
  514.   {
  515.     SHORTCARD B_3 = 1, B_4 = GenTabs_PatternCount - 2;
  516.  
  517.     if (B_3 <= B_4)
  518.       for (Pattern = B_3;; Pattern += 1) {
  519.         if (!Sets_IsEmpty(GenTabs_PatternTablePtr->A[Pattern].Finals)) {
  520.           if (ReduceCaseSize) {
  521.             GenerateCaseLabel(Out, (LONGINT)Pattern);
  522.           } else {
  523.             GenerateCaseLabels(Out, GenTabs_PatternTablePtr->A[Pattern].Finals);
  524.           }
  525.           if (GenTabs_PatternTablePtr->A[Pattern].ContextLng == GenTabs_VariableContext) {
  526.             if (Sets_Card(&GenTabs_PatternTablePtr->A[Pattern].DContext) == 1) {
  527.               Texts_WriteText(Out, Context1);
  528.               IO_WriteI(Out, (LONGINT)Sets_Select(&GenTabs_PatternTablePtr->A[Pattern].DContext), 0L);
  529.               Texts_WriteText(Out, Context2);
  530.             } else {
  531.               Texts_WriteText(Out, Context3);
  532.               GenerateCaseLabels(Out, GenTabs_PatternTablePtr->A[Pattern].DContext);
  533.               if (ScanGen_Language == ScanGen_C) {
  534.                 Label = MakeLabel();
  535.                 GenerateGoto(Out, Label);
  536.               }
  537.               Texts_WriteText(Out, Context4);
  538.               if (ScanGen_Language == ScanGen_C) {
  539.                 GenerateLabel(Out, Label);
  540.               }
  541.             }
  542.           } else if (GenTabs_PatternTablePtr->A[Pattern].ContextLng > 0) {
  543.             Strings_ArrayToString((STRING)"yyChBufferIndex", 15L, &String);
  544.             GenerateDecrement(Out, String, (LONGINT)GenTabs_PatternTablePtr->A[Pattern].ContextLng);
  545.             if (ScanGen_Language == ScanGen_C) {
  546.               if (ScanGen_ScannerName == Idents_NoIdent) {
  547.                 Strings_ArrayToString((STRING)"TokenLength", 11L, &String);
  548.               } else {
  549.                 Idents_GetString(ScanGen_ScannerName, &String);
  550.                 Strings_Append(&String, '_');
  551.                 Strings_ArrayToString((STRING)"TokenLength", 11L, &String2);
  552.                 Strings_Concatenate(&String, &String2);
  553.               }
  554.             } else {
  555.               Strings_ArrayToString((STRING)"TokenLength", 11L, &String);
  556.             }
  557.             GenerateDecrement(Out, String, (LONGINT)GenTabs_PatternTablePtr->A[Pattern].ContextLng);
  558.           } else if (GenTabs_PatternTablePtr->A[Pattern].ContextLng < 0) {
  559.             IO_WriteS(Out, (STRING)"yyLess (", 8L);
  560.             IO_WriteI(Out, (LONGINT)(-GenTabs_PatternTablePtr->A[Pattern].ContextLng), 0L);
  561.             IO_WriteS(Out, (STRING)");", 2L);
  562.             IO_WriteNl(Out);
  563.           }
  564.           Rule = GenTabs_PatternTablePtr->A[Pattern].Rule;
  565.           if (GenTabs_RuleToCodePtr->A[Rule].CodeMode == ScanGen_Position) {
  566.             Texts_WriteText(Out, Leader);
  567.           }
  568.           WriteLine(Out, GenTabs_RuleToCodePtr->A[Rule].TextLine);
  569.           if (ScanGen_Language == ScanGen_C) {
  570.             IO_WriteC(Out, '{');
  571.           }
  572.           Texts_WriteText(Out, GenTabs_RuleToCodePtr->A[Rule].Text);
  573.           if (ScanGen_Language == ScanGen_C) {
  574.             INC(DummyCount);
  575.             IO_WriteS(Out, (STRING)"} yy", 4L);
  576.             IO_WriteI(Out, (LONGINT)DummyCount, 0L);
  577.             IO_WriteS(Out, (STRING)": ", 2L);
  578.           }
  579.           Texts_WriteText(Out, Trailer);
  580.         } else if (GenTabs_PatternTablePtr->A[Pattern].Position.Line != 0 && Warnings) {
  581.           Errors_ErrorMessage((LONGCARD)PatternNoMatch, (LONGCARD)Warning, GenTabs_PatternTablePtr->A[Pattern].Position);
  582.         }
  583.         if (Pattern >= B_4) break;
  584.       }
  585.   }
  586. }
  587.  
  588. static void GenerateDecConstDef
  589. # ifdef __STDC__
  590. (IO_tFile Out, Strings_tString Name, INTEGER Value)
  591. # else
  592. (Out, Name, Value)
  593. IO_tFile Out;
  594. Strings_tString Name;
  595. INTEGER Value;
  596. # endif
  597. {
  598.   switch (ScanGen_Language) {
  599.   case ScanGen_Modula:;
  600.     Strings_WriteS(Out, &Name);
  601.     IO_WriteS(Out, (STRING)"    = ", 3L);
  602.     IO_WriteI(Out, Value, 0L);
  603.     IO_WriteC(Out, ';');
  604.     IO_WriteNl(Out);
  605.     break;
  606.   case ScanGen_C:;
  607.     IO_WriteS(Out, (STRING)"# define ", 9L);
  608.     Strings_WriteS(Out, &Name);
  609.     IO_WriteC(Out, '\t');
  610.     IO_WriteI(Out, Value, 0L);
  611.     IO_WriteNl(Out);
  612.     break;
  613.   }
  614. }
  615.  
  616. static void GenerateCharConstDef
  617. # ifdef __STDC__
  618. (IO_tFile Out, Strings_tString Name, CHAR Value)
  619. # else
  620. (Out, Name, Value)
  621. IO_tFile Out;
  622. Strings_tString Name;
  623. CHAR Value;
  624. # endif
  625. {
  626.   switch (ScanGen_Language) {
  627.   case ScanGen_Modula:;
  628.     Strings_WriteS(Out, &Name);
  629.     IO_WriteS(Out, (STRING)"    = ", 3L);
  630.     IO_WriteN(Out, ORD(Value), 1L, 8L);
  631.     IO_WriteS(Out, (STRING)"C;", 2L);
  632.     IO_WriteNl(Out);
  633.     break;
  634.   case ScanGen_C:;
  635.     IO_WriteS(Out, (STRING)"# define ", 9L);
  636.     Strings_WriteS(Out, &Name);
  637.     IO_WriteS(Out, (STRING)"    (unsigned char) '\\", 19L);
  638.     IO_WriteN(Out, ORD(Value), 1L, 8L);
  639.     IO_WriteC(Out, '\'');
  640.     IO_WriteNl(Out);
  641.     break;
  642.   }
  643. }
  644.  
  645. static void GenerateDecrement
  646. # ifdef __STDC__
  647. (IO_tFile Out, Strings_tString Name, INTEGER Value)
  648. # else
  649. (Out, Name, Value)
  650. IO_tFile Out;
  651. Strings_tString Name;
  652. INTEGER Value;
  653. # endif
  654. {
  655.   switch (ScanGen_Language) {
  656.   case ScanGen_Modula:;
  657.     IO_WriteS(Out, (STRING)"DEC (", 5L);
  658.     Strings_WriteS(Out, &Name);
  659.     IO_WriteS(Out, (STRING)", ", 2L);
  660.     IO_WriteI(Out, Value, 0L);
  661.     IO_WriteS(Out, (STRING)");", 2L);
  662.     IO_WriteNl(Out);
  663.     break;
  664.   case ScanGen_C:;
  665.     Strings_WriteS(Out, &Name);
  666.     IO_WriteS(Out, (STRING)" -= ", 4L);
  667.     IO_WriteI(Out, Value, 0L);
  668.     IO_WriteC(Out, ';');
  669.     IO_WriteNl(Out);
  670.     break;
  671.   }
  672. }
  673.  
  674. static void GenerateCaseLabel
  675. # ifdef __STDC__
  676. (IO_tFile Out, INTEGER Label)
  677. # else
  678. (Out, Label)
  679. IO_tFile Out;
  680. INTEGER Label;
  681. # endif
  682. {
  683.   switch (ScanGen_Language) {
  684.   case ScanGen_Modula:;
  685.     IO_WriteS(Out, (STRING)"| ", 2L);
  686.     IO_WriteI(Out, Label, 0L);
  687.     IO_WriteC(Out, ':');
  688.     IO_WriteNl(Out);
  689.     break;
  690.   case ScanGen_C:;
  691.     IO_WriteS(Out, (STRING)"case ", 5L);
  692.     IO_WriteI(Out, Label, 0L);
  693.     IO_WriteC(Out, ':');
  694.     IO_WriteNl(Out);
  695.     break;
  696.   }
  697. }
  698.  
  699. static void GenerateCaseLabels
  700. # ifdef __STDC__
  701. (IO_tFile Out, Sets_tSet Set)
  702. # else
  703. (Out, Set)
  704. IO_tFile Out;
  705. Sets_tSet Set;
  706. # endif
  707. {
  708.   BOOLEAN FirstTime;
  709.  
  710.   switch (ScanGen_Language) {
  711.   case ScanGen_Modula:;
  712.     FirstTime = TRUE;
  713.     IO_WriteC(Out, '|');
  714.     while (!Sets_IsEmpty(Set)) {
  715.       if (FirstTime) {
  716.         FirstTime = FALSE;
  717.       } else {
  718.         IO_WriteC(Out, ',');
  719.       }
  720.       IO_WriteI(Out, (LONGINT)Sets_Extract(&Set), 0L);
  721.       IO_WriteNl(Out);
  722.     }
  723.     IO_WriteC(Out, ':');
  724.     IO_WriteNl(Out);
  725.     break;
  726.   case ScanGen_C:;
  727.     while (!Sets_IsEmpty(Set)) {
  728.       IO_WriteS(Out, (STRING)"case ", 5L);
  729.       IO_WriteI(Out, (LONGINT)Sets_Extract(&Set), 0L);
  730.       IO_WriteS(Out, (STRING)":;", 2L);
  731.       IO_WriteNl(Out);
  732.     }
  733.     break;
  734.   }
  735. }
  736.  
  737. static CARDINAL MakeLabel
  738. # ifdef __STDC__
  739. ()
  740. # else
  741. ()
  742. # endif
  743. {
  744.   INC(LabelCount);
  745.   return LabelCount;
  746. }
  747.  
  748. static void GenerateGoto
  749. # ifdef __STDC__
  750. (IO_tFile Out, CARDINAL Label)
  751. # else
  752. (Out, Label)
  753. IO_tFile Out;
  754. CARDINAL Label;
  755. # endif
  756. {
  757.   IO_WriteS(Out, (STRING)"goto L", 6L);
  758.   IO_WriteI(Out, (LONGINT)Label, 0L);
  759.   IO_WriteC(Out, ';');
  760.   IO_WriteNl(Out);
  761. }
  762.  
  763. static void GenerateLabel
  764. # ifdef __STDC__
  765. (IO_tFile Out, CARDINAL Label)
  766. # else
  767. (Out, Label)
  768. IO_tFile Out;
  769. CARDINAL Label;
  770. # endif
  771. {
  772.   IO_WriteC(Out, 'L');
  773.   IO_WriteI(Out, (LONGINT)Label, 0L);
  774.   IO_WriteS(Out, (STRING)": ;", 3L);
  775.   IO_WriteNl(Out);
  776. }
  777.  
  778. static void WriteLine
  779. # ifdef __STDC__
  780. (IO_tFile Out, SHORTCARD Line)
  781. # else
  782. (Out, Line)
  783. IO_tFile Out;
  784. SHORTCARD Line;
  785. # endif
  786. {
  787.   if (Line != 0) {
  788.     switch (ScanGen_Language) {
  789.     case ScanGen_Modula:;
  790.       IO_WriteS(Out, (STRING)"(* line ", 8L);
  791.       IO_WriteI(Out, (LONGINT)Line, 0L);
  792.       IO_WriteS(Out, (STRING)" \"", 2L);
  793.       IO_WriteS(Out, ScanGen_SourceFile.A, 128L);
  794.       IO_WriteS(Out, (STRING)"\" *)", 4L);
  795.       IO_WriteNl(Out);
  796.       break;
  797.     case ScanGen_C:;
  798.       if (gGenLine) {
  799.         IO_WriteS(Out, (STRING)"# line ", 7L);
  800.         IO_WriteI(Out, (LONGINT)Line, 0L);
  801.         IO_WriteS(Out, (STRING)" \"", 2L);
  802.         IO_WriteS(Out, ScanGen_SourceFile.A, 128L);
  803.         IO_WriteS(Out, (STRING)"\"", 1L);
  804.       } else {
  805.         IO_WriteS(Out, (STRING)"/* line ", 8L);
  806.         IO_WriteI(Out, (LONGINT)Line, 0L);
  807.         IO_WriteS(Out, (STRING)" \"", 2L);
  808.         IO_WriteS(Out, ScanGen_SourceFile.A, 128L);
  809.         IO_WriteS(Out, (STRING)"\" */", 4L);
  810.       }
  811.       IO_WriteNl(Out);
  812.       break;
  813.     }
  814.   }
  815. }
  816.  
  817. static void ConvertAppend
  818. # ifdef __STDC__
  819. (CHAR a[], LONGCARD O_3, Texts_tText *Text)
  820. # else
  821. (a, O_3, Text)
  822. CHAR a[];
  823. LONGCARD O_3;
  824. Texts_tText *Text;
  825. # endif
  826. {
  827.   Strings_tString String;
  828.   OPEN_ARRAY_LOCALS
  829.  
  830.   ALLOC_OPEN_ARRAYS(O_3 * sizeof(CHAR), 1)
  831.   COPY_OPEN_ARRAY(a, O_3, CHAR)
  832.   Strings_ArrayToString(a, O_3, &String);
  833.   Texts_Append(Text, &String);
  834.   FREE_OPEN_ARRAYS
  835. }
  836.  
  837. static void ConvertAppend2
  838. # ifdef __STDC__
  839. (CHAR a1[], LONGCARD O_5, CHAR a2[], LONGCARD O_4, Texts_tText *Text)
  840. # else
  841. (a1, O_5, a2, O_4, Text)
  842. CHAR a1[];
  843. LONGCARD O_5;
  844. CHAR a2[];
  845. LONGCARD O_4;
  846. Texts_tText *Text;
  847. # endif
  848. {
  849.   Strings_tString String1, String2;
  850.   OPEN_ARRAY_LOCALS
  851.  
  852.   ALLOC_OPEN_ARRAYS(O_4 * sizeof(CHAR) + O_5 * sizeof(CHAR), 2)
  853.   COPY_OPEN_ARRAY(a2, O_4, CHAR)
  854.   COPY_OPEN_ARRAY(a1, O_5, CHAR)
  855.   Strings_ArrayToString(a1, O_5, &String1);
  856.   if (ScanGen_ScannerName != Idents_NoIdent) {
  857.     Idents_GetString(ScanGen_ScannerName, &String2);
  858.     Strings_Concatenate(&String1, &String2);
  859.     Strings_Append(&String1, '_');
  860.   }
  861.   Strings_ArrayToString(a2, O_4, &String2);
  862.   Strings_Concatenate(&String1, &String2);
  863.   Texts_Append(Text, &String1);
  864.   FREE_OPEN_ARRAYS
  865. }
  866.  
  867. static void ConvertAppend3
  868. # ifdef __STDC__
  869. (CHAR a1[], LONGCARD O_8, CHAR a2[], LONGCARD O_7, CHAR a3[], LONGCARD O_6, Texts_tText *Text)
  870. # else
  871. (a1, O_8, a2, O_7, a3, O_6, Text)
  872. CHAR a1[];
  873. LONGCARD O_8;
  874. CHAR a2[];
  875. LONGCARD O_7;
  876. CHAR a3[];
  877. LONGCARD O_6;
  878. Texts_tText *Text;
  879. # endif
  880. {
  881.   Strings_tString String1, String2;
  882.   OPEN_ARRAY_LOCALS
  883.  
  884.   ALLOC_OPEN_ARRAYS(O_6 * sizeof(CHAR) + O_7 * sizeof(CHAR) + O_8 * sizeof(CHAR), 3)
  885.   COPY_OPEN_ARRAY(a3, O_6, CHAR)
  886.   COPY_OPEN_ARRAY(a2, O_7, CHAR)
  887.   COPY_OPEN_ARRAY(a1, O_8, CHAR)
  888.   Strings_ArrayToString(a1, O_8, &String1);
  889.   if (ScanGen_ScannerName != Idents_NoIdent) {
  890.     Idents_GetString(ScanGen_ScannerName, &String2);
  891.     Strings_Concatenate(&String1, &String2);
  892.     Strings_Append(&String1, '_');
  893.   }
  894.   Strings_ArrayToString(a2, O_7, &String2);
  895.   Strings_Concatenate(&String1, &String2);
  896.   if (ScanGen_ScannerName != Idents_NoIdent) {
  897.     Idents_GetString(ScanGen_ScannerName, &String2);
  898.     Strings_Concatenate(&String1, &String2);
  899.     Strings_Append(&String1, '_');
  900.   }
  901.   Strings_ArrayToString(a3, O_6, &String2);
  902.   Strings_Concatenate(&String1, &String2);
  903.   Texts_Append(Text, &String1);
  904.   FREE_OPEN_ARRAYS
  905. }
  906.  
  907. void ScanGen_InitScanGen
  908. # ifdef __STDC__
  909. ()
  910. # else
  911. ()
  912. # endif
  913. {
  914.   switch (ScanGen_Language) {
  915.   case ScanGen_Modula:;
  916.     ConvertAppend((STRING)"CASE yyStateStack^ [TokenLength] OF", 35L, &Case1);
  917.     ConvertAppend((STRING)"CASE yyAction [yyStateStack^ [TokenLength]] OF", 46L, &Case2);
  918.     ConvertAppend((STRING)"Attribute.Position.Line   := yyLineCount;", 41L, &Leader);
  919.     ConvertAppend((STRING)"Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;", 73L, &Leader);
  920.     ConvertAppend((STRING)"yyRestartFlag := FALSE; EXIT;", 29L, &Trailer);
  921.     ConvertAppend((STRING)"(* BlankAction *)", 17L, &ScanGen_BlankText);
  922.     ConvertAppend((STRING)"WHILE yyChBufferPtr^ [yyChBufferIndex] = ' ' DO INC (yyChBufferIndex); END;", 75L, &ScanGen_BlankText);
  923.     ConvertAppend((STRING)"(* TabAction *)", 15L, &ScanGen_TabText);
  924.     ConvertAppend((STRING)"DEC (yyLineStart, 7 - (yyChBufferIndex - yyLineStart - 2) MOD 8);", 65L, &ScanGen_TabText);
  925.     ConvertAppend((STRING)"(* EolAction *)", 15L, &ScanGen_EolText);
  926.     ConvertAppend((STRING)"INC (yyLineCount);", 18L, &ScanGen_EolText);
  927.     ConvertAppend((STRING)"yyLineStart := yyChBufferIndex - 1;", 35L, &ScanGen_EolText);
  928.     ConvertAppend((STRING)"WHILE yyStateStack^ [TokenLength] # ", 36L, &Context1);
  929.     ConvertAppend((STRING)" DO", 3L, &Context2);
  930.     ConvertAppend((STRING)"   DEC (yyChBufferIndex);", 25L, &Context2);
  931.     ConvertAppend((STRING)"   DEC (TokenLength);", 21L, &Context2);
  932.     ConvertAppend((STRING)"END;", 4L, &Context2);
  933.     ConvertAppend((STRING)"LOOP", 4L, &Context3);
  934.     ConvertAppend((STRING)"   CASE yyStateStack^ [TokenLength] OF", 38L, &Context3);
  935.     ConvertAppend((STRING)"      EXIT;", 11L, &Context4);
  936.     ConvertAppend((STRING)"   ELSE", 7L, &Context4);
  937.     ConvertAppend((STRING)"      DEC (yyChBufferIndex);", 28L, &Context4);
  938.     ConvertAppend((STRING)"      DEC (TokenLength);", 24L, &Context4);
  939.     ConvertAppend((STRING)"   END;", 7L, &Context4);
  940.     ConvertAppend((STRING)"END;", 4L, &Context4);
  941.     if (Texts_IsEmpty(&ScanGen_Export)) {
  942.       ConvertAppend((STRING)"IMPORT Positions;", 17L, &ScanGen_Export);
  943.       ConvertAppend((STRING)"TYPE tScanAttribute    = RECORD Position: Positions.tPosition; END;", 64L, &ScanGen_Export);
  944.       ConvertAppend((STRING)"PROCEDURE ErrorAttribute (Token: INTEGER; VAR Attribute: tScanAttribute);", 73L, &ScanGen_Export);
  945.     }
  946.     if (Texts_IsEmpty(&ScanGen_Global)) {
  947.       ConvertAppend((STRING)"PROCEDURE ErrorAttribute (Token: INTEGER; VAR Attribute: tScanAttribute);", 73L, &ScanGen_Global);
  948.       ConvertAppend((STRING)"   BEGIN", 8L, &ScanGen_Global);
  949.       ConvertAppend((STRING)"   END ErrorAttribute;", 22L, &ScanGen_Global);
  950.     }
  951.     if (Texts_IsEmpty(&ScanGen_Default)) {
  952.       ConvertAppend((STRING)"IO.WriteC (IO.StdOutput, yyChBufferPtr^ [yyChBufferIndex-1]);", 61L, &ScanGen_Default);
  953.     }
  954.     break;
  955.   case ScanGen_C:;
  956.     ConvertAppend((STRING)"switch (* -- yyStatePtr) {", 26L, &Case1);
  957.     ConvertAppend((STRING)"switch (yyAction [* -- yyStatePtr]) {", 37L, &Case2);
  958.     ConvertAppend2((STRING)"", 1L, (STRING)"Attribute.Position.Line   = yyLineCount;", 40L, &Leader);
  959.     ConvertAppend3((STRING)"", 1L, (STRING)"Attribute.Position.Column = (unsigned char *) ", 46L, (STRING)"TokenPtr - yyLineStart;", 23L, &Leader);
  960.     ConvertAppend((STRING)"goto yyBegin;", 13L, &Trailer);
  961.     ConvertAppend((STRING)"/* BlankAction */", 17L, &ScanGen_BlankText);
  962.     ConvertAppend((STRING)"while (* yyChBufferIndexReg ++ == ' ') ;", 40L, &ScanGen_BlankText);
  963.     ConvertAppend2((STRING)"", 1L, (STRING)"TokenPtr = (char *) -- yyChBufferIndexReg;", 42L, &ScanGen_BlankText);
  964.     ConvertAppend((STRING)"yyState = yyStartState;", 23L, &ScanGen_BlankText);
  965.     ConvertAppend((STRING)"yyStatePtr = & yyStateStack [1];", 32L, &ScanGen_BlankText);
  966.     ConvertAppend((STRING)"goto yyContinue;", 16L, &ScanGen_BlankText);
  967.     ConvertAppend((STRING)"/* TabAction */", 15L, &ScanGen_TabText);
  968.     ConvertAppend2((STRING)"yyLineStart -= 7 - ((unsigned char *) ", 38L, (STRING)"TokenPtr - yyLineStart - 1) & 0x7; /* % 8 */", 44L, &ScanGen_TabText);
  969.     ConvertAppend((STRING)"/* EolAction */", 15L, &ScanGen_EolText);
  970.     ConvertAppend((STRING)"yyLineCount ++;", 15L, &ScanGen_EolText);
  971.     ConvertAppend((STRING)"yyLineStart = yyChBufferIndexReg - 1;", 37L, &ScanGen_EolText);
  972.     ConvertAppend((STRING)"while (* yyStatePtr != ", 23L, &Context1);
  973.     ConvertAppend((STRING)") {", 3L, &Context2);
  974.     ConvertAppend((STRING)"   yyChBufferIndex --;", 22L, &Context2);
  975.     ConvertAppend2((STRING)"   ", 3L, (STRING)"TokenLength --;", 15L, &Context2);
  976.     ConvertAppend((STRING)"   yyStatePtr --;", 17L, &Context2);
  977.     ConvertAppend((STRING)"}", 1L, &Context2);
  978.     ConvertAppend((STRING)"for (;;) {", 10L, &Context3);
  979.     ConvertAppend((STRING)"   switch (* yyStatePtr) {", 26L, &Context3);
  980.     ConvertAppend((STRING)"   default:", 11L, &Context4);
  981.     ConvertAppend((STRING)"      yyChBufferIndex --;", 25L, &Context4);
  982.     ConvertAppend2((STRING)"      ", 6L, (STRING)"TokenLength --;", 15L, &Context4);
  983.     ConvertAppend((STRING)"      yyStatePtr --;", 20L, &Context4);
  984.     ConvertAppend((STRING)"   }", 4L, &Context4);
  985.     ConvertAppend((STRING)"}", 1L, &Context4);
  986.     if (Texts_IsEmpty(&ScanGen_Export)) {
  987.       ConvertAppend((STRING)"# include \"Positions.h\"", 23L, &ScanGen_Export);
  988.       ConvertAppend2((STRING)"typedef struct { tPosition Position; } ", 39L, (STRING)"tScanAttribute;", 15L, &ScanGen_Export);
  989.       ConvertAppend3((STRING)"extern void ", 12L, (STRING)"ErrorAttribute ARGS((int Token, ", 32L, (STRING)"tScanAttribute * Attribute));", 29L, &ScanGen_Export);
  990.     }
  991.     if (Texts_IsEmpty(&ScanGen_Global)) {
  992.       ConvertAppend2((STRING)"void ", 5L, (STRING)"ErrorAttribute (Token, Attribute)", 33L, &ScanGen_Global);
  993.       ConvertAppend((STRING)"   int Token;", 13L, &ScanGen_Global);
  994.       ConvertAppend2((STRING)"   ", 3L, (STRING)"tScanAttribute * Attribute;", 27L, &ScanGen_Global);
  995.       ConvertAppend((STRING)"   { }", 6L, &ScanGen_Global);
  996.     }
  997.     if (Texts_IsEmpty(&ScanGen_Default)) {
  998.       ConvertAppend((STRING)"(void) putchar ((int) yyChBufferIndexReg [-1]);", 47L, &ScanGen_Default);
  999.     }
  1000.     break;
  1001.   }
  1002. }
  1003.  
  1004. void BEGIN_ScanGen()
  1005. {
  1006.   static BOOLEAN has_been_called = FALSE;
  1007.  
  1008.   if (!has_been_called) {
  1009.     has_been_called = TRUE;
  1010.  
  1011.     BEGIN_Texts();
  1012.     BEGIN_Strings();
  1013.     BEGIN_Idents();
  1014.     BEGIN_Checks();
  1015.     BEGIN_IO();
  1016.     BEGIN_Texts();
  1017.     BEGIN_Sets();
  1018.     BEGIN_Strings();
  1019.     BEGIN_StringMem();
  1020.     BEGIN_Idents();
  1021.     BEGIN_Errors();
  1022.     BEGIN_DefTable();
  1023.     BEGIN_Dfa();
  1024.     BEGIN_ScanTabs();
  1025.     BEGIN_GenTabs();
  1026.     BEGIN_Texts();
  1027.     BEGIN_Strings();
  1028.     BEGIN_Idents();
  1029.  
  1030.     ScanGen_ScannerName = Idents_NoIdent;
  1031.     ScanGen_BeginLine = 0;
  1032.     ScanGen_CloseLine = 0;
  1033.     ScanGen_DefaultLine = 0;
  1034.     DummyCount = 0;
  1035.     ScanGen_EofLine = 0;
  1036.     ScanGen_ExportLine = 0;
  1037.     ScanGen_GlobalLine = 0;
  1038.     LabelCount = 0;
  1039.     ScanGen_LocalLine = 0;
  1040.     Texts_MakeText(&ScanGen_Begin);
  1041.     Texts_MakeText(&ScanGen_BlankText);
  1042.     Texts_MakeText(&Case1);
  1043.     Texts_MakeText(&Case2);
  1044.     Texts_MakeText(&ScanGen_Close);
  1045.     Texts_MakeText(&Context1);
  1046.     Texts_MakeText(&Context2);
  1047.     Texts_MakeText(&Context3);
  1048.     Texts_MakeText(&Context4);
  1049.     Texts_MakeText(&ScanGen_Default);
  1050.     Texts_MakeText(&ScanGen_Eof);
  1051.     Texts_MakeText(&ScanGen_EolText);
  1052.     Texts_MakeText(&ScanGen_Export);
  1053.     Texts_MakeText(&ScanGen_Global);
  1054.     Texts_MakeText(&Leader);
  1055.     Texts_MakeText(&ScanGen_Local);
  1056.     Texts_MakeText(&ScanGen_TabText);
  1057.     Texts_MakeText(&Trailer);
  1058.   }
  1059. }
  1060.