开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 编译器/解释器 > 查看源码
main.c
资源名称：pccts133.zip　[点击查看]
上传用户：itx_2006
上传日期：2007-01-06
资源大小：493k
文件大小：48k
源码类别：

编译器/解释器

开发平台：

Others

main.c：源码内容
  1. /*
  2.  * main.c -- main program for PCCTS ANTLR.
  3.  *
  4.  * SOFTWARE RIGHTS
  5.  *
  6.  * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
  7.  * Set (PCCTS) -- PCCTS is in the public domain.  An individual or
  8.  * company may do whatever they wish with source code distributed with
  9.  * PCCTS or the code generated by PCCTS, including the incorporation of
  10.  * PCCTS, or its output, into commerical software.
  11.  *
  12.  * We encourage users to develop software with PCCTS.  However, we do ask
  13.  * that credit is given to us for developing PCCTS.  By "credit",
  14.  * we mean that if you incorporate our source code into one of your
  15.  * programs (commercial product, research project, or otherwise) that you
  16.  * acknowledge this fact somewhere in the documentation, research report,
  17.  * etc...  If you like PCCTS and have developed a nice tool with the
  18.  * output, please mention that you developed it using PCCTS.  In
  19.  * addition, we ask that this header remain intact in our source code.
  20.  * As long as these guidelines are kept, we expect to continue enhancing
  21.  * this system and expect to make other tools available as they are
  22.  * completed.
  23.  *
  24.  * ANTLR 1.33
  25.  * Terence Parr
  26.  * Parr Research Corporation
  27.  * with Purdue University and AHPCRC, University of Minnesota
  28.  * 1989-1998
  29.  */
  31. #include <stdio.h>
  32. #ifdef __cplusplus
  33. #ifndef __STDC__
  34. #define __STDC__
  35. #endif
  36. #endif
  37. #include "stdpccts.h"
  39. #define MAX_INT_STACK 50
  40. static int istack[MAX_INT_STACK]; /* Int stack */
  41. static int isp = MAX_INT_STACK;
  43. static int DontAcceptFiles = 0; /* if stdin, don't read files */
  44. static int DontAcceptStdin = 0; /* if files seen first, don't accept stdin */
  46. static int tnodes_used_in_guard_predicates_etc;     /* MR10 */
  48. /* C m d - L i n e  O p t i o n  S t r u c t  &  F u n c s */
  50. typedef struct _Opt {
  51. char *option;
  52. int  arg;
  53. #ifdef __cplusplus
  54. void (*process)(...);
  55. #else
  56. void (*process)();
  57. #endif
  58. char *descr;
  59. } Opt;
  61. #ifdef __STDC__
  62. extern void ProcessArgs(int, char **, Opt *);
  63. #else
  64. extern void ProcessArgs();
  65. #endif
  67. #ifdef __STDC__
  68. int ci_strequ(char *a,char *b)
  69. #else
  70. int ci_strequ(a,b)
  71.   char  *a;
  72.   char  *b;
  73. #endif
  74. {
  75.   for ( ;*a != 0 && *b != 0; a++, b++) {
  76.     if (toupper(*a) != toupper(*b)) return 0;
  77.   }
  78.   return (*a == *b);
  79. }
  81. static void
  82. #ifdef __STDC__
  83. pStdin( void )
  84. #else
  85. pStdin( )
  86. #endif
  87. {
  88. if ( DontAcceptStdin )
  89. {
  90. warnNoFL("'-' (stdin) ignored as files were specified first");
  91. return;
  92. }
  94. require(NumFiles<MaxNumFiles,"exceeded max # of input files");
  95. FileStr[NumFiles++] = "stdin";
  96. DontAcceptFiles = 1;
  97. }
  99. static void
  100. #ifdef __STDC__
  101. pFile( char *s )
  102. #else
  103. pFile( s )
  104. char *s;
  105. #endif
  106. {
  107. if ( *s=='-' ) { warnNoFL( eMsg1("invalid option: '%s'",s) ); return; }
  108. if ( DontAcceptFiles )
  109. {
  110. warnNoFL(eMsg1("file '%s' ignored as '-' (stdin option) was specified first",s));
  111. return;
  112. }
  114. require(NumFiles<MaxNumFiles,"exceeded max # of input files");
  115. FileStr[NumFiles++] = s;
  116. DontAcceptStdin = 1;
  117. }
  119. /* MR14
  120.         Allow input to be a file containing a list of files
  121.         Bernard Giroud (b_giroud@decus.ch)
  122. */
  124. static void
  125. #ifdef __STDC__
  126. pFileList( char *s, char *t )
  127. #else
  128. pFileList( s, t )
  129. char *s;
  130. char *t;
  131. #endif
  132. {
  133. #define MaxFLArea 1024
  134. FILE *fl;
  135. static char Fn_in_Fl[MaxFLArea] = "";
  136.         char one_fn[MaxFileName];
  137. char *flp = &Fn_in_Fl[0];
  138. int fnl, left = MaxFLArea, i;
  140. if ( *t=='-' ) { warnNoFL( eMsg1("invalid option: '%s'",t) ); return; }
  141. if ( DontAcceptFiles )
  142. {
  143. warnNoFL(eMsg1("file '%s' ignored as '-' (stdin option) was specified first",t));
  144. return;
  145. }
  147.         if ((fl = fopen(t, "r")) == NULL)
  148. {
  149. warnNoFL(eMsg1("file '%s' can't be opened", t));
  150. return;
  151. }
  152.         for (;;)
  153. {
  154. if (fgets(one_fn, 128 - 1, fl) == NULL)
  155. break;
  156. fnl = strlen(one_fn);
  157. require(fnl<=left, "no more room in File List Area");
  158. /* drop the trailing LF */
  159. if (one_fn[fnl - 1] == 0x0a) one_fn[fnl - 1] = ' ';
  160. strcat(Fn_in_Fl, one_fn);
  161. left = left - fnl;
  162. require(NumFiles<MaxNumFiles,"exceeded max # of input files");
  163. FileStr[NumFiles++] = flp;
  164. flp = flp + fnl;
  165. }
  166. fclose(fl);
  167. for (i=0;i < MaxFLArea;i++) if (Fn_in_Fl[i] == ' ') Fn_in_Fl[i] = '';
  168. DontAcceptStdin = 1;
  169. }
  171. static void
  172. #ifdef __STDC__
  173. pLLK( char *s, char *t )
  174. #else
  175. pLLK( s, t )
  176. char *s;
  177. char *t;
  178. #endif
  179. {
  180. LL_k = atoi(t);
  181. if ( LL_k <= 0 ) {
  182. warnNoFL("must have at least one token of lookahead (setting to 1)");
  183. LL_k = 1;
  184. }
  185. }
  187. static void
  188. #ifdef __STDC__
  189. pCk( char *s, char *t )
  190. #else
  191. pCk( s, t )
  192. char *s;
  193. char *t;
  194. #endif
  195. {
  196. CLL_k = atoi(t);
  197. if ( CLL_k <= 0 ) {
  198. warnNoFL("must have at least one token of look-ahead (setting to 1)");
  199. CLL_k = 1;
  200. }
  201. }
  203. static void                                      /* MR6 */
  204. #ifdef __STDC__
  205. pTab( char *s, char *t )                               /* MR6 */
  206. #else
  207. pTab( s, t )                                   /* MR6 */
  208. char *s;                                  /* MR6 */
  209. char *t;                                  /* MR6 */
  210. #endif
  211. {                                      /* MR6 */
  212. TabWidth = atoi(t);                              /* MR6 */
  213. if ( TabWidth < 0 || TabWidth > 8 ) {                   /* MR6 */
  214. warnNoFL("tab width must be between 1 and 8");               /* MR6 */
  215.   TabWidth=0;                              /* MR6 */
  216. }                                      /* MR6 */
  217. }                                          /* MR6 */
  219. static int ambAidDepthSpecified=0;                                   /* MR11 */
  221. static void                                      /* MR11 */
  222. #ifdef __STDC__
  223. pAAd( char *s, char *t )                               /* MR11 */
  224. #else
  225. pAAd( s, t )                                   /* MR11 */
  226. char *s;                                  /* MR11 */
  227. char *t;                                  /* MR11 */
  228. #endif
  229. {                                      /* MR11 */
  230.     ambAidDepthSpecified=1;                                          /* MR11 */
  231. MR_AmbAidDepth = atoi(t);                          /* MR11 */
  232. }                                          /* MR11 */
  234. static void                                      /* MR11 */
  235. #ifdef __STDC__
  236. pTreport( char *s, char *t )                              /* MR11 */
  237. #else
  238. pTreport( s, t )                                 /* MR11 */
  239.     char *s;                              /* MR11 */
  240.     char *t;                              /* MR11 */
  241. #endif
  242. {                                      /* MR11 */
  243. TnodesReportThreshold = atoi(t);                  /* MR11 */
  244. }                                          /* MR11 */
  246. #ifdef __STDC__
  247. void chkGTFlag(void)                                     /* 7-Apr-97 MR1 */
  248. #else
  249. void chkGTFlag()                                            /* 7-Apr-97 MR1 */
  250. #endif
  251. {
  252. if ( !GenAST )
  253. warn("#-variable or other AST item referenced w/o -gt option");
  254. }
  257. #ifdef __STDC__
  258. static void pInfo(char *s, char *t)                         /* MR10 */
  259. #else
  260. static void pInfo(s,t)                                      /* MR10 */
  261.   char  *s;
  262.   char  *t;
  263. #endif
  264. {
  265.   char  *p;
  266.   int   q;
  267.   for (p=t; *p != 0; p++) {
  268.     q=tolower(*p);
  269.     if (q=='t') {
  270.       InfoT=1;
  271.     } else if (q=='p') {
  272.       InfoP=1;
  273.     } else if (q=='m') {
  274.       InfoM=1;
  275.     } else if (q=='o') {
  276.       InfoO=1;
  277.     } else if (q=='0') {
  278.       ; /* nothing */
  279.     } else if (q=='f') {
  280.       InfoF=1;
  281.     } else {
  282.       warnNoFL(eMsgd("unrecognized -info option "%c"",(int)*p));
  283.     };
  284.   };
  285. }
  287. #ifdef __STDC__
  288. static void pCGen(void) { CodeGen = FALSE; LexGen = FALSE; }
  289. static void pLGen(void) { LexGen = FALSE; }
  290. static void pXTGen(void){ MR_Inhibit_Tokens_h_Gen = TRUE; }
  291. static void pTGen(void) { TraceGen = TRUE; }
  292. static void pSGen(void) { GenExprSetsOpt = FALSE; }
  293. static void pPrt(void) { PrintOut = TRUE; pCGen(); pLGen(); }
  294. static void pPrtA(void) { PrintOut = TRUE; PrintAnnotate = TRUE; pCGen(); pLGen(); }
  295. static void pAst(void) { GenAST = TRUE; }
  296. static void pANSI(void) { GenANSI = TRUE; }
  297. static void pCr(void) { GenCR = TRUE; }
  298. /*static void pCt(void) { warnNoFL("-ct option is now the default"); }*/
  299. static void pLI(void) { GenLineInfo = TRUE; GenLineInfoMS = FALSE; } /* MR14 */
  300. static void pLIms(void) { GenLineInfo = TRUE; GenLineInfoMS = TRUE; }  /* MR14 */
  301. static void pFr(char *s, char *t) {RemapFileName = t;}
  302. static void pFe(char *s, char *t) {ErrFileName = t;}
  303. static void pFl(char *s, char *t) {DlgFileName = t;}
  304. static void pFm(char *s, char *t) {ModeFileName = t;}
  305. static void pFt(char *s, char *t) {DefFileName = t;}
  307. static void pE1(void) { elevel = 1; }
  308. static void pE2(void) { elevel = 2; }
  309. static void pE3(void) { elevel = 3; }
  310. static void pEGen(void) { GenEClasseForRules = 1; }
  311. static void pDL(void)
  312. {
  313.     DemandLookahead = 1;
  314.     if ( GenCC ) {
  315. warnNoFL("-gk does not work currently in C++ mode; -gk turned off");
  316. DemandLookahead = 0;
  317.     }
  318. }
  320. static void pAA(char *s,char *t) {MR_AmbAidRule = t;}               /* MR11 */
  321. static void pAAm(char *s){MR_AmbAidMultiple = 1;}                   /* MR11 */
  322. static void pGHdr(void) { GenStdPccts = 1; }
  323. static void pFHdr(char *s, char *t) { stdpccts = t; pGHdr(); }
  324. static void pW1(void) { WarningLevel = 1; }
  325. static void pNewAST(void) { NewAST = 1; }                           /* MR13 */
  326. static void pAlpha(void) { AlphaBetaTrace = 1; }                    /* MR14 */
  327. static void pStdout(void) {UseStdout = 1; }                     /* MR6 */
  328. static void pW2(void) { WarningLevel = 2; }
  329. static void pCC(void) { GenCC = TRUE; }
  330. #else
  331. static void pCGen() { CodeGen = FALSE; LexGen = FALSE; }
  332. static void pLGen() { LexGen = FALSE; }
  333. static void pXTGen(){ MR_Inhibit_Tokens_h_Gen = TRUE; }             /* MR14 */
  334. static void pTGen() { TraceGen = TRUE; }
  335. static void pSGen() { GenExprSetsOpt = FALSE; }
  336. static void pPrt() { PrintOut = TRUE; pCGen(); pLGen(); }
  337. static void pPrtA() { PrintOut = TRUE; PrintAnnotate = TRUE; pCGen(); pLGen(); }
  338. static void pAst() { GenAST = TRUE; }
  339. static void pANSI() { GenANSI = TRUE; }
  340. static void pCr() { GenCR = TRUE; }
  341. /*static void pCt() { warnNoFL("-ct option is now the default"); }*/
  342. static void pLI()     { GenLineInfo = TRUE; GenLineInfoMS = FALSE; }  /* MR14 */
  343. static void pLIms()     { GenLineInfo = TRUE; GenLineInfoMS = TRUE; }   /* MR14 */
  344. static void pFr(s,t) char *s, *t; {RemapFileName = t;}
  345. static void pFe(s,t) char *s, *t; {ErrFileName = t;}
  346. static void pFl(s,t) char *s, *t; {DlgFileName = t;}
  347. static void pFm(s,t) char *s, *t; {ModeFileName = t;}
  348. static void pFt(s,t) char *s, *t; {DefFileName = t;}
  350. static void pE1() { elevel = 1; }
  351. static void pE2() { elevel = 2; }
  352. static void pE3() { elevel = 3; }
  353. static void pEGen() { GenEClasseForRules = 1; }
  354. static void pDL()
  355. {
  356.     DemandLookahead = 1;
  357.     if ( GenCC ) {
  358.           warnNoFL("-gk does not work currently in C++ mode; -gk turned off");
  359.       DemandLookahead = 0;
  360.     }
  361. }
  363. static void pAA(s,t) char *s; char *t; {MR_AmbAidRule = t;}          /* MR11 BJS 20-Mar-98 */
  364. static void pAAm(s) char *s; {MR_AmbAidMultiple = 1;}                /* MR11 BJS 20-Mar-98 */
  365. static void pGHdr() { GenStdPccts = 1; }
  366. static void pFHdr(s,t) char *s, *t; { stdpccts = t; pGHdr(); }
  367. static void pW1() { WarningLevel = 1; }
  368. static void pNewAST() { NewAST = 1; }                                /* MR13 */
  369. static void pAlpha() { AlphaBetaTrace = 1; }                         /* MR14 */
  370. static void pStdout() {UseStdout = 1; }                              /* MR6 */
  371. static void pW2() { WarningLevel = 2; }
  372. static void pCC() { GenCC = TRUE; }
  373. #endif
  375. static void
  376. #ifdef __STDC__
  377. pPre( char *s, char *t )
  378. #else
  379. pPre( s, t )
  380. char *s;
  381. char *t;
  382. #endif
  383. {
  384. RulePrefix = t;
  385. }
  387. static void
  388. #ifdef __STDC__
  389. pOut( char *s, char *t )
  390. #else
  391. pOut( s, t )
  392. char *s;
  393. char *t;
  394. #endif
  395. {
  396. OutputDirectory = t;
  397. }
  399. static void
  400. #ifdef __STDC__
  401. pPred( void )
  402. #else
  403. pPred( )
  404. #endif
  405. {
  406. warnNoFL("-pr is no longer used (predicates employed if present); see -prc, -mrhoist, -mrhoistk");
  407. /*
  408. ** if ( DemandLookahead )
  409. ** warnNoFL("-gk conflicts with -pr; -gk turned off");
  410. ** DemandLookahead = 0;
  411. ** HoistPredicateContext = 0;
  412. */
  413. }
  415. static void
  416. #ifdef __STDC__
  417. pPredCtx( char *s, char *t )
  418. #else
  419. pPredCtx(s,t)
  420. char *s;
  421. char *t;
  422. #endif
  423. {
  424. if ( ci_strequ(t,"on")) HoistPredicateContext = 1;
  425. else if ( ci_strequ(t,"off")) HoistPredicateContext = 0;
  426. if ( DemandLookahead )
  427. {
  428. warnNoFL("-gk incompatible with semantic predicate usage; -gk turned off");
  429. DemandLookahead = 0;
  430. }
  431. }
  433. static void
  434. #ifdef __STDC__
  435. pMRhoist( char *s, char *t )
  436. #else
  437. pMRhoist(s,t)
  438. char *s;
  439. char *t;
  440. #endif
  441. {
  442. if ( ci_strequ(t,"on")) MRhoisting = 1;
  443. else if ( ci_strequ(t,"off")==0 ) MRhoisting = 0;
  444.     if (MRhoisting) {
  445.         fprintf(stderr,"Maintenance Release style hoisting enabled for predicates with lookahead depth = 1n");
  446.         fprintf(stderr,"  No longer considered experimentaln");
  447.         fprintf(stderr,"  Can't consider suppression for predicates with lookahead depth > 1n");
  448.         fprintf(stderr,"  Implies -prc on but does *not* imply -mrhoistk for k>1 predicatesn");
  449.     };
  450. }
  452. static void
  453. #ifdef __STDC__
  454. pMRhoistk( char *s, char *t )
  455. #else
  456. pMRhoistk(s,t)
  457. char *s;
  458. char *t;
  459. #endif
  460. {
  461. if ( ci_strequ(t,"on")) MRhoistingk = 1;
  462. else if ( ci_strequ(t,"off")==0 ) MRhoistingk = 0;
  463.     if (MRhoistingk) {
  464.         fprintf(stderr,"EXPERIMENTAL Maintenance Release style hoisting enabledn");
  465.         fprintf(stderr,"  Applies to predicates with lookahead depth > 1n");
  466.         fprintf(stderr,"  Implies -prc on and -mrhoist onn");
  467.     };
  468. }
  470. static void
  471. #ifdef __STDC__
  472. pTRes( char *s, char *t )
  473. #else
  474. pTRes( s, t )
  475. char *s;
  476. char *t;
  477. #endif
  478. {
  479. TreeResourceLimit = atoi(t);
  480. if ( TreeResourceLimit <= 0 )
  481. {
  482. warnNoFL("analysis resource limit (# of tree nodes) must be greater than 0");
  483. TreeResourceLimit = -1; /* set to no limit */
  484. }
  485. }
  487. Opt options[] = {
  488. #ifdef __cplusplus
  489.     { "-CC", 0, (void (*)(...)) pCC, "Generate C++ output (default=FALSE)"},
  490.     { "-ck", 1, (void (*)(...)) pCk, "Set compressed lookahead depth; fast approximate lookahead"},
  491.     { "-cr", 0, (void (*)(...)) pCr, "Generate cross reference (default=FALSE)"},
  492.     { "-e1", 0, (void (*)(...)) pE1, "Ambiguities/errors shown in low detail (default)"},
  493.     { "-e2", 0, (void (*)(...)) pE2, "Ambiguities/errors shown in more detail"},
  494.     { "-e3", 0, (void (*)(...)) pE3,
  495.      "Ambiguities for k>1 grammars shown with exact tuples (not lookahead sets)"},
  496.     { "-f",  1, (void (*)(...)) pFileList,"Read names of grammar files from specified file"}, /* MR14 */
  497.     { "-fe", 1, (void (*)(...)) pFe, "Rename err.c"},
  498.     { "-fh", 1, (void (*)(...)) pFHdr, "Rename stdpccts.h header (turns on -gh)"},
  499.     { "-fl", 1, (void (*)(...)) pFl, "Rename lexical output--parser.dlg"},
  500.     { "-fm", 1, (void (*)(...)) pFm, "Rename mode.h"},
  501.     { "-fr", 1, (void (*)(...)) pFr, "Rename remap.h"},
  502.     { "-ft", 1, (void (*)(...)) pFt, "Rename tokens.h"},
  503.     { "-ga", 0, (void (*)(...)) pANSI, "Generate ANSI-compatible code (default=FALSE)"},
  504.     { "-gc", 0, (void (*)(...)) pCGen, "Do not generate output parser code (default=FALSE)"},
  505.     { "-gd", 0, (void (*)(...)) pTGen, "Generate code to trace rule invocation (default=FALSE)"},
  506.     { "-ge", 0, (void (*)(...)) pEGen, "Generate an error class for each non-terminal (default=FALSE)"},
  507.     { "-gh", 0, (void (*)(...)) pGHdr, "Generate stdpccts.h for non-ANTLR-generated-files to include"},
  508.     { "-gk", 0, (void (*)(...)) pDL, "Generate parsers that delay lookahead fetches until needed"},
  509.     { "-gl", 0, (void (*)(...)) pLI, "Generate line info about grammar actions in parser"},
  510.     { "-glms", 0, (void (*)(...)) pLIms,"Like -gl but replace '\' with '/' in #line filenames for MS C/C++ systems"},
  511.     { "-gp", 1, (void (*)(...)) pPre, "Prefix all generated rule functions with a string"},
  512.     { "-gs", 0, (void (*)(...)) pSGen, "Do not generate sets for token expression lists (default=FALSE)"},
  513.     { "-gt", 0, (void (*)(...)) pAst, "Generate code for Abstract-Syntax-Trees (default=FALSE)"},
  514.     { "-gx", 0, (void (*)(...)) pLGen, "Do not generate lexical (dlg-related) files (default=FALSE)"},
  515.     { "-gxt",0, (void (*)(...)) pXTGen, "Do not generate tokens.h (default=FALSE)"},
  516.     { "-k",  1, (void (*)(...)) pLLK, "Set full LL(k) lookahead depth (default==1)"},
  517.     { "-o",  1, (void (*)(...)) pOut, OutputDirectoryOption},
  518.     { "-p",  0, (void (*)(...)) pPrt, "Print out the grammar w/o actions (default=no)"},
  519.     { "-pa", 0, (void (*)(...)) pPrtA, "Print out the grammar w/o actions & w/FIRST sets (default=no)"},
  520.     { "-pr",0, (void (*)(...)) pPred, "no longer used; predicates employed if present"},
  521.     { "-prc", 1, (void (*)(...)) pPredCtx,"Turn on/off computation of context for hoisted predicates"},
  522.     { "-rl", 1, (void (*)(...)) pTRes, "Limit max # of tree nodes used by grammar analysis"},
  523.     { "-stdout",0,  (void (*)(...)) pStdout,"Send grammar.c/grammar.cpp to stdout"},           /* MR6 */
  524. { "-tab", 1, (void (*)(...)) pTab, "Width of tabs (1 to 8) for grammar.c/grammar.cpp files"}, /* MR6 */
  525. { "-w1", 0, (void (*)(...)) pW1, "Set the warning level to 1 (default)"},
  526. { "-w2", 0, (void (*)(...)) pW2, "Ambiguities yield warnings even if predicates or (...)? block"},
  527. { "-",   0, (void (*)(...)) pStdin, "Read grammar from stdin" },
  528.     { "-mrhoist",1, (void (*)(...)) pMRhoist,                                                  /* MR9 */
  529.                                         "Turn on/off k=1 Maintenance Release style hoisting"},  /* MR9 */
  530.     { "-mrhoistk",1, (void (*)(...)) pMRhoistk,                                                  /* MR9 */
  531.                                         "Turn on/off EXPERIMENTAL k>1 Maintenance Release style hoisting"},  /* MR13 */
  532.     { "-aa"  , 1, (void (*)(...)) pAA,  "Ambiguity aid for a rule (rule name or line number)"},          /* MR11 */
  533.     { "-aam" , 0, (void (*)(...)) pAAm,
  534.                                          "Lookahead token may appear multiple times in -aa listing"},    /* MR11 */
  535.     { "-aad" , 1, (void (*)(...)) pAAd,
  536.                                          "Limits exp growth of -aa listing - default=1 (max=ck value)"}, /* MR11 */
  537. { "-info", 1, (void (*)(...)) pInfo,
  538.       "Extra info: p=pred t=tnodes f=first/follow m=monitor o=orphans 0=noop"},                          /* MR12 */
  539.     { "-treport",1,(void (*)(...)) pTreport,
  540.                         "Report when tnode usage exceeds value during ambiguity resolution"},            /* MR11 */
  541. { "-newAST", 0, (void (*)(...)) pNewAST,
  542.                  "In C++ mode use "newAST(...)" rather than "new AST(...)""},                        /* MR13 */
  543.     { "-alpha",0,(void (*)(...)) pAlpha,
  544.                  "Provide additional information for "(alpha)? beta" error messages"},                 /* MR14 */
  545. { "*",   0, (void (*)(...)) pFile,  "" }, /* anything else is a file */
  546. #else
  547.     { "-CC", 0, pCC, "Generate C++ output (default=FALSE)"},
  548.     { "-cr", 0, pCr, "Generate cross reference (default=FALSE)"},
  549.     { "-ck", 1, pCk, "Set compressed lookahead depth; fast approximate lookahead"},
  550.     { "-e1", 0, pE1, "Ambiguities/errors shown in low detail (default)"},
  551.     { "-e2", 0, pE2, "Ambiguities/errors shown in more detail"},
  552.     { "-e3", 0, pE3,    "Ambiguities for k>1 grammars shown with exact tuples (not lookahead sets)"},
  553.     { "-f",  1, pFileList,"Read names of grammar files from specified file"},   /* MR14 */
  554.     { "-fe", 1, pFe, "Rename err.c"},
  555.     { "-fh", 1, pFHdr, "Rename stdpccts.h header (turns on -gh)"},
  556.     { "-fl", 1, pFl, "Rename lexical output--parser.dlg"},
  557.     { "-fm", 1, pFm, "Rename mode.h"},
  558.     { "-fr", 1, pFr, "Rename remap.h"},
  559.     { "-ft", 1, pFt, "Rename tokens.h"},
  560.     { "-ga", 0, pANSI, "Generate ANSI-compatible code (default=FALSE)"},
  561.     { "-gc", 0, pCGen, "Do not generate output parser code (default=FALSE)"},
  562.     { "-gd", 0, pTGen, "Generate code to trace rule invocation (default=FALSE)"},
  563.     { "-ge", 0, pEGen, "Generate an error class for each non-terminal (default=FALSE)"},
  564.     { "-gh", 0, pGHdr, "Generate stdpccts.h for non-ANTLR-generated-files to include"},
  565.     { "-gk", 0, pDL, "Generate parsers that delay lookahead fetches until needed"},
  566.     { "-gl", 0, pLI, "Generate line info about grammar actions in C parser"},
  567.     { "-glms", 0, pLIms,"Like -gl but replace '\' with '/' in #line filenames for MS C/C++ systems"},
  568.     { "-gp", 1, pPre, "Prefix all generated rule functions with a string"},
  569.     { "-gs", 0, pSGen, "Do not generate sets for token expression lists (default=FALSE)"},
  570.     { "-gt", 0, pAst, "Generate code for Abstract-Syntax-Trees (default=FALSE)"},
  571.     { "-gx", 0, pLGen, "Do not generate lexical (dlg-related) files (default=FALSE)"},
  572.     { "-gxt",0, pXTGen, "Do not generate tokens.h (default=FALSE)"},
  573.     { "-k",  1, pLLK, "Set full LL(k) lookahead depth (default==1)"},
  574.     { "-o",  1, pOut, OutputDirectoryOption},
  575.     { "-p",  0, pPrt, "Print out the grammar w/o actions (default=no)"},
  576.     { "-pa", 0, pPrtA, "Print out the grammar w/o actions & w/FIRST sets (default=no)"},
  577.     { "-pr",0, pPred, "no longer used; predicates employed if present"},
  578.     { "-prc", 1, pPredCtx,"Turn on/off computation of context for hoisted predicates"},
  579.     { "-rl", 1, pTRes, "Limit max # of tree nodes used by grammar analysis"},
  580.     { "-stdout",0, pStdout, "Send grammar.c/grammar.cpp to stdout"},               /* MR6 */
  581.     { "-tab", 1, pTab, "Width of tabs (1 to 8) for grammar.c/grammar.cpp files"}, /* MR6 */
  582. { "-w1", 0, pW1, "Set the warning level to 1 (default)"},
  583. { "-w2", 0, pW2, "Ambiguities yield warnings even if predicates or (...)? block"},
  584.     { "-mrhoist",1,pMRhoist,                                                       /* MR9 */
  585.                          "Turn on/off k=1 Maintenance Release style hoisting"},  /* MR9 */
  586.     { "-mrhoistk",1,pMRhoistk,                                                       /* MR13 */
  587.                          "Turn on/off k>1 EXPERIMENTAL Maintenance Release style hoisting"},  /* MR13 */
  588.     { "-aa"  ,1,pAA,     "Ambiguity aid for a rule (rule name or line number)"},          /* MR11 */
  589.     { "-aam" ,0,pAAm,
  590.                          "Lookahead token may appear multiple times in -aa listing"},     /* MR11 */
  591.     { "-aad" ,1,pAAd,
  592.                          "Limits exp growth of -aa listing - default=1 (max=ck value)"},  /* MR11 */
  593. { "-info",1,pInfo,
  594.       "Extra info: p=pred t=tnodes f=first/follow m=monitor o=orphans 0=noop"},           /* MR11 */
  595.     { "-treport",1,pTreport,
  596.                         "Report when tnode usage exceeds value during ambiguity resolution"},   /* MR11 */
  597. { "-newAST", 0, pNewAST,
  598.                  "In C++ mode use "newAST(...)" rather than "new AST(...)""},         /* MR13 */
  599.     { "-alpha",0, pAlpha,
  600.                  "Provide additional information for "(alpha)? beta" error messages"},  /* MR14 */
  601. { "-",   0, pStdin, "Read grammar from stdin" },
  602. { "*",   0, pFile,  "" }, /* anything else is a file */
  603. #endif
  604. { NULL,  0, NULL }
  605.  };
  607. void readDescr();
  608. void cleanUp();
  610. #ifdef __STDC__
  611. static void buildRulePtr( void );
  612. static void help( void );
  613. static void init( void );
  614. static void CompleteTokenSetRefs( void );
  615. static void ensure_no_C_file_collisions(char *);
  616. static void CompleteContextGuards();
  617. #else
  618. static void buildRulePtr( );
  619. static void help( );
  620. static void init( );
  621. static void CompleteTokenSetRefs( );
  622. static void ensure_no_C_file_collisions();
  623. static void CompleteContextGuards();
  624. #endif
  626. static void
  627. #ifdef __STDC__  /* <BJS> */
  628. report_numericPredLabels(ActionNode *a)
  629. #else
  630. report_numericPredLabels(a)
  631. ActionNode *a;
  632. #endif
  633. {                                                                           /* MR10 */
  634.   warnFL("numeric references to attributes (e.g. $i or $i.j) in semantic pred will be null during guess mode",  /* MR10 */
  635.             FileStr[a->file],a->line);                                      /* MR10 */
  636. }                                                                           /* MR10 */
  638. /* M a i n */
  640. int
  641. #ifdef __STDC__
  642. main( int argc, char *argv[] )
  643. #else
  644. main( argc, argv )
  645. int argc;
  646. char *argv[];
  647. #endif
  648. {
  649. int i;
  650. static char EPSTR[] = "[Ep]";
  652.     Save_argc=argc;                                                  /* MR10 */
  653.     Save_argv=argv;                                                  /* MR10 */
  655. /* malloc_debug(8);*/
  657. #ifdef SPECIAL_INITS
  658.     special_inits();                                                 /* MR1 */
  659. #endif
  660. fprintf(stderr, "Antlr parser generator   Version %s   1989-1998n", Version);
  661. if ( argc == 1 ) { help(); zzDIE; }
  662. ProcessArgs(argc-1, &(argv[1]), options);
  664. /* MR14 */    if (MR_AmbAidRule && AlphaBetaTrace) {
  665. /* MR14 */       fatal("Can't specify both -aa (ambiguity aid) and -alpha ("(alpha)? beta" aid)");
  666. /* MR14 */    }
  668.     if (MRhoistingk) {              /* MR13 */
  669.       HoistPredicateContext=1;      /* MR13 */
  670.       MRhoisting=1;                 /* MR13 */
  671.     };                              /* MR13 */
  672.     if (MRhoisting && ! HoistPredicateContext) {
  673. /***      warnNoFL("Using "-mrhoist" forces "-prc on"");    ***/
  674.       HoistPredicateContext=1;
  675.     };
  676.     if (HoistPredicateContext && ! MRhoisting) {
  677.         warnNoFL("When using predicate context (-prc on) -mrhoist on is recommended");
  678.     }
  679. /* Fix lookahead depth */
  680. /* Compressed lookahead must always be larger than or equal to full lookahead */
  681. if ( CLL_k < LL_k  && CLL_k>0 )
  682. {
  683. warnNoFL("must have compressed lookahead >= full LL(k) lookahead (setting -ck to -k)");
  684. CLL_k = LL_k;
  685. }
  686. if ( CLL_k == -1 ) CLL_k = LL_k;
  687. OutputLL_k = CLL_k;
  688. if ( ((CLL_k-1)&CLL_k)!=0 ) { /* output ll(k) must be power of 2 */
  689. int n;
  690. for(n=1; n<CLL_k; n<<=1) {;}
  691. OutputLL_k = n;
  692. };
  694.     if ( ! ambAidDepthSpecified) {
  695.       MR_AmbAidDepth=1;
  696.     } else {
  697.       if (MR_AmbAidDepth > CLL_k || MR_AmbAidDepth <= 0) {
  698.         warnNoFL(eMsgd(
  699.             "Ambiguity aid depth ("-aad ...") must be a number between 1 and max(k,ck)=%d",CLL_k));
  700.         MR_AmbAidDepth=1;
  701.       };
  702.       if (MR_AmbAidDepth == 0) {
  703.         MR_AmbAidDepth=2;
  704.       };
  705.     };
  707.     if (MR_AmbAidRule != NULL) MR_AmbAidLine=atoi(MR_AmbAidRule);
  709. fpTrans = &(C_Trans[0]); /* Translate to C Language */
  710. fpJTrans = &(C_JTrans[0]);
  711. init();
  712. lexclass(LexStartSymbol);
  714. readDescr();
  715. LastTokenCounted = TokenNum;
  716. RemapForcedTokens();
  717. if ( CannotContinue ) {cleanUp(); zzDIE;}
  718. if ( GenCC && no_classes_found ) fatal("required grammar class not found (exiting...)");
  719. if ( WarningLevel>1 && HdrAction == NULL )
  720.    warnNoFL("no #header action was found");
  721. if ( FoundAtOperator && ! FoundExceptionGroup) {
  722.    warnNoFL("found the exception operator '@' - but no exception group was found");
  723. };
  724. EpToken = addTname(EPSTR); /* add imaginary token epsilon */
  725. set_orel(EpToken, &imag_tokens);
  727. /* this won't work for hand-built scanners since EofToken is not
  728.  * known.  Forces EOF to be token type 1.
  729.  */
  730. set_orel(EofToken, &imag_tokens);
  732. set_size(NumWords(TokenNum-1));
  734. /* compute the set of all known token types
  735.  * It represents the set of tokens from 1 to last_token_num + the
  736.  * reserved positions above that (if any).  Don't include the set of
  737.  * imaginary tokens such as the token/error classes or EOF.
  738.  */
  739. {
  740. set a;
  741. a = set_dup(reserved_positions);
  742. for (i=1; i<TokenNum; i++) { set_orel(i, &a); }
  743. all_tokens = set_dif(a, imag_tokens);
  744. set_free(a);
  745. }
  747. ComputeTokSets(); /* Compute #tokclass sets */
  748. CompleteTokenSetRefs(); /* Change complex nodes in syn diag */
  749.     CompleteContextGuards();        /* MR13 */
  751. if ( CodeGen ) genDefFile(); /* create tokens.h */
  752. if ( LexGen ) genLexDescr(); /* create parser.dlg */
  754. if ( GenStdPccts )
  755. {
  756. FILE *f = fopen(OutMetaName(stdpccts), "w");
  757. if ( f==NULL ) {warnNoFL( eMsg1("can't create %s",OutMetaName(stdpccts)) );}
  758. else
  759. {
  760. #ifdef SPECIAL_FOPEN
  761. special_fopen_actions(OutMetaName(stdpccts));            /* MR1 */
  762. #endif
  763.             if (strcmp(stdpccts,"stdpccts.h") == 0) {                /* MR10 */
  764.            genStdPCCTSIncludeFile(f,NULL);                        /* MR10 */
  765.             } else {                                                 /* MR10 */
  766.            genStdPCCTSIncludeFile(f,baseName(stdpccts));          /* MR10 */
  767.             };
  768. fclose(f);
  769. }
  770. }
  772. buildRulePtr(); /* create mapping from rule # to RuleBlk junction */
  773. ComputeErrorSets();
  774. FoLink( (Node *)SynDiag ); /* add follow links to end of all rules */
  776. if ( GenCR ) GenCrossRef( SynDiag );
  778. if ( CodeGen )
  779. {
  780. if ( SynDiag == NULL )
  781. {
  782. warnNoFL("no grammar description recognized");
  783. cleanUp();
  784. zzDIE;
  785. }
  786. else if ( !GenCC ) {
  787. ErrFile = fopen(OutMetaName(ErrFileName), "w");
  788. require(ErrFile != NULL, "main: can't open err file");
  789. #ifdef SPECIAL_FOPEN
  790.               special_fopen_actions(OutMetaName(ErrFileName));   /* MR1 */
  791. #endif
  792. NewSetWd();
  793. GenErrHdr();
  794. TRANS(SynDiag); /* Translate to the target language */
  795. DumpSetWd();
  796. DumpRemainingTokSets();
  797. fclose( ErrFile );
  798. }
  799. else {
  800. strcpy(Parser_h_Name, CurrentClassName);
  801. strcat(Parser_h_Name, ".h");
  802. strcpy(Parser_c_Name, CurrentClassName);
  803. strcat(Parser_c_Name, CPP_FILE_SUFFIX);
  804. ensure_no_C_file_collisions(Parser_c_Name);
  805. Parser_h = fopen(OutMetaName(Parser_h_Name), "w");
  806. require(Parser_h != NULL, "main: can't open class Parserx.h file");
  807. #ifdef SPECIAL_FOPEN
  808.     special_fopen_actions(OutMetaName(Parser_h_Name));       /* MR1 */
  809. #endif
  810. Parser_c = fopen(OutMetaName(Parser_c_Name), "w");
  811. require(Parser_c != NULL, "main: can't open class Parserx.c file");
  812. #ifdef SPECIAL_FOPEN
  813.     special_fopen_actions(OutMetaName(Parser_c_Name));       /* MR1 */
  814. #endif
  815. GenParser_h_Hdr();
  816. if ( class_before_actions != NULL )
  817. {
  818. ListNode *p;
  819. for (p = class_before_actions->next; p!=NULL; p=p->next)
  820. {
  821. UserAction *ua = (UserAction *)p->elem;
  822. dumpAction( ua->action, Parser_h, 0, ua->file, ua->line, 1);
  823. }
  824. }
  825. GenParser_c_Hdr();
  826. NewSetWd();
  827. TRANS(SynDiag); /* Translate to the target language */
  828. DumpSetWd();
  829. GenRuleMemberDeclarationsForCC(Parser_h, SynDiag);
  830. if ( class_after_actions != NULL )
  831. {
  832. ListNode *p;
  833. for (p = class_after_actions->next; p!=NULL; p=p->next)
  834. {
  835. UserAction *ua = (UserAction *)p->elem;
  836. dumpAction( ua->action, Parser_h, 0, ua->file, ua->line, 1);
  837. }
  838. }
  839. DumpRemainingTokSets();
  840. fprintf(Parser_h, "};n");
  841. fprintf(Parser_h, "n#endif /* %s_h */n", CurrentClassName);
  842. fclose( Parser_h );
  843. fclose( Parser_c );
  844. }
  845. }
  847.     MR_orphanRules(stderr);
  849. if ( PrintOut )
  850. {
  851. if ( SynDiag == NULL ) {warnNoFL("no grammar description recognized");}
  852. else PRINT(SynDiag);
  853. }
  855. #ifdef DBG_LL1
  856. #endif
  857. GenRemapFile(); /* create remap.h */
  858. /* MR10 */    if (FoundGuessBlk) {
  859. #ifdef __cplusplus__
  860. /* MR10 */      list_apply(NumericPredLabels, (void (*)(void *))report_numericPredLabels);
  861. #else
  862. #ifdef __STDC__
  863. /* MR10 */      list_apply(NumericPredLabels, (void (*)(void *))report_numericPredLabels);
  864. #else
  865. /* MR10 */      list_apply(NumericPredLabels,report_numericPredLabels);
  866. #endif
  867. #endif
  868. /* MR10 */    };
  870.     if (InfoT && TnodesAllocated > 0) {
  871.       if (TnodesPeak > 10000) {
  872.         fprintf(stdout,"nTree Nodes:  peak %dk  created %dk  lost %dn",
  873.                         (TnodesPeak/1000),
  874.                         (TnodesAllocated/1000),
  875.                         TnodesInUse-tnodes_used_in_guard_predicates_etc);
  876.        } else {
  877.          fprintf(stdout,"nTree Nodes:  peak %d  created %d  lost %dn",
  878.                         TnodesPeak,
  879.                         TnodesAllocated,
  880.                         TnodesInUse-tnodes_used_in_guard_predicates_etc);
  881.        };
  882.     };
  883.     if (InfoF) {
  884.       DumpFcache();
  885.     };
  886.     if (MR_skipped_e3_report) {
  887.       fprintf(stderr,"note: use -e3 to get exact information on ambiguous tuplesn");
  888.     };
  889.     if (MR_BadExprSets != 0) {
  890.       fprintf(stderr,"note: Unreachable C or C++ code was generated for empty expression sets,n");
  891.       fprintf(stderr,"        probably due to undefined rules or infinite left recursion.n");
  892.       fprintf(stderr,"      To locate: search the generated code for "empty set expression"n");
  893.     };
  894.     if (MR_AmbAidRule != NULL && MR_matched_AmbAidRule==0) {
  895.       RuleEntry *q = (RuleEntry *) hash_get(Rname,MR_AmbAidRule);
  896.       if (MR_AmbAidLine == 0 && q == NULL) {
  897.          warnNoFL(eMsg2("there is no rule "%s" so "-aa %s" will never match",
  898.                                                         MR_AmbAidRule,MR_AmbAidRule));
  899.       } else {
  900.         warnNoFL(eMsg1("there was no ambiguity that matched "-aa %s"",MR_AmbAidRule));
  901.       };
  902.     };
  903.     if (AlphaBetaTrace) {
  905.       if (MR_AlphaBetaMessageCount == 0) {
  906.          fprintf(stderr,"note: there were no messages about "(alpha)? beta" blocks added to the generated coden");
  907.       } else {
  908.          fprintf(stderr,"note: there were %d messages about "(alpha)? beta" blocks added to the generated coden",
  909.                     MR_AlphaBetaMessageCount);
  910.       }
  912.       if (set_null(MR_CompromisedRules)) {
  913.          fprintf(stderr,"note: the list of rules with compromised follow sets is emptyn");
  914.       } else {
  915.          fprintf(stderr,"note: the following is a list of rules which *may* have incorrectn");
  916.          fprintf(stderr,"      follow sets computed as a result of an "(alpha)? beta" blockn");
  917.          fprintf(stderr,"n");
  918.          MR_dumpRuleSet(MR_CompromisedRules);
  919.          fprintf(stderr,"n");
  920.       }
  921.     }
  922. cleanUp();
  923. exit(PCCTS_EXIT_SUCCESS);
  924.     return 0;           /* MR11 make compilers happy */
  925. }
  927. static void
  928. #ifdef __STDC__
  929. init( void )
  930. #else
  931. init( )
  932. #endif
  933. {
  934. SignalEntry *q;
  936. Tname = newHashTable();
  937. Rname = newHashTable();
  938. Fcache = newHashTable();
  939. Tcache = newHashTable();
  940. Sname = newHashTable();
  941.     Pname = newHashTable();     /* MR11 */
  943. /* Add default signal names */
  944. q = (SignalEntry *)hash_add(Sname,
  945.   "NoViableAlt",
  946.   (Entry *)newSignalEntry("NoViableAlt"));
  947. require(q!=NULL, "cannot alloc signal entry");
  948. q->signum = sigNoViableAlt;
  949. q = (SignalEntry *)hash_add(Sname,
  950.   "MismatchedToken",
  951.   (Entry *)newSignalEntry("MismatchedToken"));
  952. require(q!=NULL, "cannot alloc signal entry");
  953. q->signum = sigMismatchedToken;
  954. q = (SignalEntry *)hash_add(Sname,
  955.   "NoSemViableAlt",
  956.   (Entry *)newSignalEntry("NoSemViableAlt"));
  957. require(q!=NULL, "cannot alloc signal entry");
  958. q->signum = sigNoSemViableAlt;
  960. reserved_positions = empty;
  961. all_tokens = empty;
  962. imag_tokens = empty;
  963. tokclasses = empty;
  964. TokenStr = (char **) calloc(TSChunk, sizeof(char *));
  965. require(TokenStr!=NULL, "main: cannot allocate TokenStr");
  966. FoStack = (int **) calloc(CLL_k+1, sizeof(int *));
  967. require(FoStack!=NULL, "main: cannot allocate FoStack");
  968. FoTOS = (int **) calloc(CLL_k+1, sizeof(int *));
  969. require(FoTOS!=NULL, "main: cannot allocate FoTOS");
  970. Cycles = (ListNode **) calloc(CLL_k+1, sizeof(ListNode *));
  971. require(Cycles!=NULL, "main: cannot allocate Cycles List");
  972.     MR_CompromisedRules=empty;  /* MR14 */
  973. }
  975. static void
  976. #ifdef __STDC__
  977. help( void )
  978. #else
  979. help( )
  980. #endif
  981. {
  982. Opt *p = options;
  983. fprintf(stderr, "antlr [options] f1 f2 ... fnn");
  984. while ( *(p->option) != '*' )
  985. {
  986. fprintf(stderr, "    %-9s%s   %sn",
  987. p->option,
  988. (p->arg)?"___":"   ",
  989. p->descr);
  990. p++;
  991. }
  992. }
  994. /* The RulePtr array is filled in here.  RulePtr exists primarily
  995.  * so that sets of rules can be maintained for the FOLLOW caching
  996.  * mechanism found in rJunc().  RulePtr maps a rule num from 1 to n
  997.  * to a pointer to its RuleBlk junction where n is the number of rules.
  998.  */
  999. static void
  1000. #ifdef __STDC__
  1001. buildRulePtr( void )
  1002. #else
  1003. buildRulePtr( )
  1004. #endif
  1005. {
  1006. int r=1;
  1007. Junction *p  = SynDiag;
  1008. RulePtr = (Junction **) calloc(NumRules+1, sizeof(Junction *));
  1009. require(RulePtr!=NULL, "cannot allocate RulePtr array");
  1011. while ( p!=NULL )
  1012. {
  1013. require(r<=NumRules, "too many rules???");
  1014. RulePtr[r++] = p;
  1015. p = (Junction *)p->p2;
  1016. }
  1017. }
  1019. void
  1020. #ifdef __STDC__
  1021. dlgerror(const char *s)
  1022. #else
  1023. dlgerror(s)
  1024. char *s;
  1025. #endif
  1026. {
  1027. fprintf(stderr, ErrHdr, FileStr[CurFile], zzline);
  1028. fprintf(stderr, " lexical error: %s (text was '%s')n",
  1029. ((s == NULL) ? "Lexical error" : s), zzlextext);
  1030. }
  1032. void
  1033. #ifdef __STDC__
  1034. readDescr( void )
  1035. #else
  1036. readDescr( )
  1037. #endif
  1038. {
  1039. zzerr = dlgerror;
  1040. input = NextFile();
  1041. if ( input==NULL ) fatal("No grammar description found (exiting...)");
  1042. ANTLR(grammar(), input);
  1043.     tnodes_used_in_guard_predicates_etc=TnodesInUse;    /* MR10 */
  1044. }
  1046. FILE *
  1047. #ifdef __STDC__
  1048. NextFile( void )
  1049. #else
  1050. NextFile( )
  1051. #endif
  1052. {
  1053. FILE *f;
  1055. for (;;)
  1056. {
  1057. CurFile++;
  1058. if ( CurFile >= NumFiles ) return(NULL);
  1059. if ( ci_strequ(FileStr[CurFile],"stdin")) return stdin;
  1060. f = fopen(FileStr[CurFile], "r");
  1061. if ( f == NULL )
  1062. {
  1063. warnNoFL( eMsg1("file %s doesn't exist; ignored", FileStr[CurFile]) );
  1064. }
  1065. else
  1066. {
  1067. return(f);
  1068. }
  1069. }
  1070. }
  1072. /*
  1073.  * Return a string corresponding to the output file name associated
  1074.  * with the input file name passed in.
  1075.  *
  1076.  * Observe the following rules:
  1077.  *
  1078.  * f.e --> f".c"
  1079.  * f --> f".c"
  1080.  * f. --> f".c"
  1081.  * f.e.g --> f.e".c"
  1082.  *
  1083.  * Where f,e,g are arbitrarily long sequences of characters in a file
  1084.  * name.
  1085.  *
  1086.  * In other words, if a ".x" appears on the end of a file name, make it
  1087.  * ".c".  If no ".x" appears, append ".c" to the end of the file name.
  1088.  *
  1089.  * C++ mode using .cpp not .c.
  1090.  *
  1091.  * Use malloc() for new string.
  1092.  */
  1094. char *
  1095. #ifdef __STDC__
  1096. outname( char *fs )
  1097. #else
  1098. outname( fs )
  1099. char *fs;
  1100. #endif
  1101. {
  1102.     if ( GenCC) {
  1103.       return outnameX(fs,CPP_FILE_SUFFIX);
  1104.     } else {
  1105.       return outnameX(fs,".c");
  1106.     };
  1107. }
  1109. char *
  1110. #ifdef __STDC__
  1111. outnameX( char *fs ,char *suffix)
  1112. #else
  1113. outnameX( fs , suffix )
  1114. char *fs;
  1115. char *suffix;
  1116. #endif
  1117. {
  1118. static char buf[MaxFileName+1];
  1119. char *p;
  1120. require(fs!=NULL&&*fs!='', "outname: NULL filename");
  1122. p = buf;
  1123. strcpy(buf, fs);
  1124. while ( *p != '' )  {p++;} /* Stop on '' */
  1125. while ( *p != '.' && p != buf ) {--p;} /* Find '.' */
  1126. if ( p != buf ) *p = ''; /* Found '.' */
  1127. require(strlen(buf) + 2 < (size_t)MaxFileName, "outname: filename too big");
  1128.     strcat(buf,suffix);
  1129. return( buf );
  1130. }
  1132. void
  1133. #ifdef __STDC__
  1134. fatalFL( char *err_, char *f, int l )
  1135. #else
  1136. fatalFL( err_, f, l )
  1137. char *err_;
  1138. char *f;
  1139. int l;
  1140. #endif
  1141. {
  1142. fprintf(stderr, ErrHdr, f, l);
  1143. fprintf(stderr, " %sn", err_);
  1144. cleanUp();
  1145. exit(PCCTS_EXIT_FAILURE);
  1146. }
  1148. void
  1149. #ifdef __STDC__
  1150. fatal_intern( char *err_, char *f, int l )
  1151. #else
  1152. fatal_intern( err_, f, l )
  1153. char *err_;
  1154. char *f;
  1155. int l;
  1156. #endif
  1157. {
  1158. fprintf(stderr, ErrHdr, f, l);
  1159. fprintf(stderr, " #$%%*&@# internal error: %sn", err_);
  1160. fprintf(stderr, ErrHdr, f, l);
  1161. fprintf(stderr, " [complain to nearest government officialn");
  1162. fprintf(stderr, ErrHdr, f, l);
  1163. fprintf(stderr, "  or send hate-mail to parrt@parr-research.com;n");
  1164. fprintf(stderr, ErrHdr, f, l);
  1165. fprintf(stderr, "  please pray to the ``bug'' gods that there is a trival fix.]n");
  1166. cleanUp();
  1167. exit(PCCTS_EXIT_FAILURE);
  1168. }
  1170. void
  1171. #ifdef __STDC__
  1172. cleanUp( void )
  1173. #else
  1174. cleanUp( )
  1175. #endif
  1176. {
  1177. if ( DefFile != NULL) fclose( DefFile );
  1178. }
  1180. /* sprintf up to 3 strings */
  1181. char *
  1182. #ifdef __STDC__
  1183. eMsg3( char *s, char *a1, char *a2, char *a3 )
  1184. #else
  1185. eMsg3( s, a1, a2, a3 )
  1186. char *s;
  1187. char *a1;
  1188. char *a2;
  1189. char *a3;
  1190. #endif
  1191. {
  1192. static char buf[250]; /* DANGEROUS as hell !!!!!! */
  1194. sprintf(buf, s, a1, a2, a3);
  1195. return( buf );
  1196. }
  1198. /* sprintf a decimal */
  1199. char *
  1200. #ifdef __STDC__
  1201. eMsgd( char *s, int d )
  1202. #else
  1203. eMsgd( s, d )
  1204. char *s;
  1205. int d;
  1206. #endif
  1207. {
  1208. static char buf[250]; /* DANGEROUS as hell !!!!!! */
  1210. sprintf(buf, s, d);
  1211. return( buf );
  1212. }
  1214. char *
  1215. #ifdef __STDC__
  1216. eMsgd2( char *s, int d1,int d2)
  1217. #else
  1218. eMsgd2( s, d1, d2 )
  1219. char *s;
  1220. int d1;
  1221. int d2;
  1222. #endif
  1223. {
  1224. static char buf[250]; /* DANGEROUS as hell !!!!!! */
  1226. sprintf(buf, s, d1, d2);
  1227. return( buf );
  1228. }
  1230. void
  1231. #ifdef __STDC__
  1232. s_fprT( FILE *f, set e )
  1233. #else
  1234. s_fprT( f, e )
  1235. FILE *f;
  1236. set e;
  1237. #endif
  1238. {
  1239. register unsigned *p;
  1240. unsigned *q;
  1242. if ( set_nil(e) ) return;
  1243. if ( (q=p=set_pdq(e)) == NULL ) fatal_internal("Can't alloc space for set_pdq");
  1244. fprintf(f, "{");
  1245. while ( *p != nil )
  1246. {
  1247. fprintf(f, " %s", TerminalString(*p));
  1248. p++;
  1249. }
  1250. fprintf(f, " }");
  1251. free((char *)q);
  1252. }
  1254. /* Return the token name or regular expression for a token number. */
  1255. char *
  1256. #ifdef __STDC__
  1257. TerminalString( int token )
  1258. #else
  1259. TerminalString( token )
  1260. int token;
  1261. #endif
  1262. {
  1263. int     j;
  1264.     static char    imag_name[20];
  1266. /* look in all lexclasses for the token */
  1267. if ( TokenString(token) != NULL ) return TokenString(token);
  1268. for (j=0; j<NumLexClasses; j++)
  1269. {
  1270. lexmode(j);
  1271. if ( ExprString(token) != NULL ) return ExprString(token);
  1272. }
  1274.     if (1) {
  1275.       sprintf(imag_name,"UnknownToken#%d",token);           /* MR13 */
  1276.       return imag_name;                                     /* MR13 */
  1277.     }
  1279. require(j<NumLexClasses, eMsgd("No label or expr for token %d",token));
  1280. return "invalid";
  1281. }
  1283.                     /* S i m p l e  I n t  S t a c k */
  1285. void
  1286. #ifdef __STDC__
  1287. pushint( int i )
  1288. #else
  1289. pushint( i )
  1290. int i;
  1291. #endif
  1292. {
  1293. require(isp>0, "pushint: stack overflow");
  1294. istack[--isp] = i;
  1295. }
  1297. int
  1298. #ifdef __STDC__
  1299. popint( void )
  1300. #else
  1301. popint( )
  1302. #endif
  1303. {
  1304. require(isp<MAX_INT_STACK, "popint: stack underflow");
  1305. return istack[isp++];
  1306. }
  1308. int
  1309. #ifdef __STDC__
  1310. istacksize( void )
  1311. #else
  1312. istacksize( )
  1313. #endif
  1314. {
  1315. return MAX_INT_STACK-isp;
  1316. }
  1318. void
  1319. #ifdef __STDC__
  1320. istackreset( void )
  1321. #else
  1322. istackreset( )
  1323. #endif
  1324. {
  1325. isp = MAX_INT_STACK;
  1326. }
  1328. int
  1329. #ifdef __STDC__
  1330. istackempty( void )
  1331. #else
  1332. istackempty( )
  1333. #endif
  1334. {
  1335. return isp==MAX_INT_STACK;
  1336. }
  1338. int
  1339. #ifdef __STDC__
  1340. topint( void )
  1341. #else
  1342. topint( )
  1343. #endif
  1344. {
  1345. require(isp<MAX_INT_STACK, "topint: stack underflow");
  1346. return istack[isp];
  1347. }
  1349. void
  1350. #ifdef __STDC__
  1351. ProcessArgs( int argc, char **argv, Opt *options )
  1352. #else
  1353. ProcessArgs( argc, argv, options )
  1354. int argc;
  1355. char **argv;
  1356. Opt *options;
  1357. #endif
  1358. {
  1359. Opt *p;
  1360. require(argv!=NULL, "ProcessArgs: command line NULL");
  1362. while ( argc-- > 0 )
  1363. {
  1364. p = options;
  1365. while ( p->option != NULL )
  1366. {
  1367. if ( strcmp(p->option, "*") == 0 ||
  1368.  ci_strequ(p->option, *argv) == 1 )
  1369. {
  1370. if ( p->arg )
  1371. {
  1372. /* MR9  26-Sep-97   Check for argv valid                */
  1373.                     if (argc-- > 0) {
  1374.          (*p->process)( *argv, *(argv+1) );
  1375.     argv++;
  1376.                     } else {
  1377. fprintf(stderr,"error: required argument for option %s omittedn",*argv);
  1378. exit(PCCTS_EXIT_FAILURE);
  1379.                     };
  1380. }
  1381. else
  1382. (*p->process)( *argv );
  1383. break;
  1384. }
  1385. p++;
  1386. }
  1387. argv++;
  1388. }
  1389. }
  1391. static void CompleteContextGuards()
  1392. {
  1393.     ListNode *      p;
  1394.     Predicate *     pred;
  1396.     if (ContextGuardPredicateList == NULL) return;
  1398.     for (p=ContextGuardPredicateList->next; p != NULL; p=p->next) {
  1399.       pred=(Predicate *)p->elem;
  1400.       recomputeContextGuard(pred);
  1401.     }
  1402. }
  1404. /* Go back into the syntax diagram and compute all meta tokens; i.e.
  1405.  * turn all '.', ranges, token class refs etc... into actual token sets
  1406.  */
  1407. static void
  1408. CompleteTokenSetRefs()
  1409. {
  1410. ListNode *p;
  1412. if ( MetaTokenNodes==NULL ) return;
  1413. for (p = MetaTokenNodes->next; p!=NULL; p=p->next)
  1414. {
  1415. set a,b;
  1417. TokNode *q = (TokNode *)p->elem;
  1418. if ( q->wild_card )
  1419. {
  1420. q->tset = all_tokens;
  1421. }
  1422. else if ( q->tclass!=NULL )
  1423. {
  1424. if ( q->complement ) q->tset = set_dif(all_tokens, q->tclass->tset);
  1425. else q->tset = q->tclass->tset;
  1426. }
  1427. else if ( q->upper_range!=0 )
  1428. {
  1429. /* we have a range on our hands: make a set from q->token .. q->upper_range */
  1430. int i;
  1431. a = empty;
  1432. for (i=q->token; i<=q->upper_range; i++) { set_orel(i, &a); }   /* MR13 */
  1434. /* MR13 */    if (q->complement) {
  1435. /* MR13 */      q->tset = set_dif(all_tokens, a);
  1436. /* MR13 */        set_free(a);
  1437. /* MR13 */      } else {
  1438. /* MR13 */       q->tset = a;
  1439. /* MR13 */      }
  1441.         }
  1443. /* at this point, it can only be a complemented single token */
  1444. else if ( q->complement )
  1445. {
  1446. a = set_of(q->token);
  1447. b = set_dif(all_tokens, a);
  1448. set_free(a);
  1449. q->tset=b;
  1450. }
  1451. else fatal("invalid meta token");
  1452. }
  1453. }
  1455. /* MR10: Jeff Vincent
  1456.    MR10: Changed to remove directory information from n only if
  1457.    MR10: if OutputDirectory was changed by user (-o option)
  1458. */
  1460. char *
  1461. #ifdef __USE_PROTOS
  1462. OutMetaName(char *n)
  1463. #else
  1464. OutMetaName(n)
  1465. char *n;
  1466. #endif
  1467. {
  1468.     static char *dir_sym = DirectorySymbol;
  1469.     static char newname[MaxFileName+1];
  1470.     char *p;
  1472. /* If OutputDirectory is same as TopDirectory (platform default) then leave n alone. */
  1473.     if (strcmp(OutputDirectory, TopDirectory) == 0)
  1474. return n;
  1476. /* p will point to filename without path information */
  1477. if ((p = strrchr(n, *dir_sym)) != NULL)
  1478. p++;
  1479. else
  1480. p = n;
  1482. /* Copy new output directory into newname[] */
  1483. strcpy(newname, OutputDirectory);
  1485. /* if new output directory does not have trailing dir_sym, add it! */
  1486. if (newname[strlen(newname)-1] != *dir_sym)
  1487. strcat(newname, dir_sym);
  1489. /* contatenate FILE NAME ONLY to new output directory */
  1490. strcat(newname, p);
  1492. return newname;
  1493. }
  1495. char *
  1496. #ifdef __STDC__
  1497. baseName(char *n)
  1498. #else
  1499. baseName(n)
  1500. char *n;
  1501. #endif
  1502. {
  1503.     static char newname[MaxFileName+1];
  1504.     static char* dir_sym = DirectorySymbol;
  1505.     int count = 0;
  1506.     char *p;
  1508.     p = n;
  1510.     while ( *p != '' )  {p++;}                    /* go to end of string */
  1511.     while ( (*p != *dir_sym) && (p != n) ) {--p;}   /* Find last DirectorySymbol */
  1512.     while ( *p == *dir_sym) p++;                    /* step forward if we're on a dir symbol */
  1513.     while ( *p != '' && *p != '.')
  1514.     {
  1515.         newname[count++] = *p;
  1516.         p++;
  1517.     }                                               /* create a new name */
  1518.     newname[count] = '';
  1519.     return newname;
  1520. }
  1522. static void
  1523. #ifdef __STDC__
  1524. ensure_no_C_file_collisions(char *class_c_file)
  1525. #else
  1526. ensure_no_C_file_collisions(class_c_file)
  1527. char *class_c_file;
  1528. #endif
  1529. {
  1530. int i;
  1532. for (i=0; i<NumFiles; i++)
  1533. {
  1534. #ifdef PC
  1535. /* assume that file names are case insensitive */
  1536. if ( stricmp(outname(FileStr[i]), class_c_file)==0 )
  1537. #else
  1538. if ( strcmp(outname(FileStr[i]), class_c_file)==0 )
  1539. #endif
  1540. {
  1541. fatal(eMsg1("class def output file conflicts with parser output file: %s",
  1542. outname(FileStr[i])));
  1543. }
  1544. }
  1545. }
  1547. void
  1548. #ifdef __STDC__
  1549. warnNoFL(char *err)
  1550. #else
  1551. warnNoFL(err)
  1552. char *err;
  1553. #endif
  1554. {
  1555. fprintf(stderr, "warning: %sn", err);
  1556. }
  1558. void
  1559. #ifdef __STDC__
  1560. warnFL(char *err,char *f,int l)
  1561. #else
  1562. warnFL(err,f,l)
  1563. char *f;
  1564. int l;
  1565. char *err;
  1566. #endif
  1567. {
  1568. fprintf(stderr, ErrHdr, f, l);
  1569. fprintf(stderr, " warning: %sn", err);
  1570. }
  1572. void
  1573. #ifdef __STDC__
  1574. warn(char *err)
  1575. #else
  1576. warn(err)
  1577. char *err;
  1578. #endif
  1579. {
  1580. /* back up the file number if we hit an error at the end of the last file */
  1581. if ( CurFile >= NumFiles && CurFile >= 1 ) CurFile--;
  1582. fprintf(stderr, ErrHdr, FileStr[CurFile], zzline);
  1583. fprintf(stderr, " warning: %sn", err);
  1584. }
  1586. void
  1587. #ifdef __STDC__
  1588. warnNoCR( char *err )
  1589. #else
  1590. warnNoCR( err )
  1591. char *err;
  1592. #endif
  1593. {
  1594. /* back up the file number if we hit an error at the end of the last file */
  1595. if ( CurFile >= NumFiles && CurFile >= 1 ) CurFile--;
  1596. fprintf(stderr, ErrHdr, FileStr[CurFile], zzline);
  1597. fprintf(stderr, " warning: %s", err);
  1598. }
  1600. void
  1601. #ifdef __STDC__
  1602. errNoFL(char *err)
  1603. #else
  1604. errNoFL(err)
  1605. char *err;
  1606. #endif
  1607. {
  1608. fprintf(stderr, "error: %sn", err);
  1609. }
  1611. void
  1612. #ifdef __STDC__
  1613. errFL(char *err,char *f,int l)
  1614. #else
  1615. errFL(err,f,l)
  1616. char *err;
  1617. char *f;
  1618. int l;
  1619. #endif
  1620. {
  1621. fprintf(stderr, ErrHdr, f, l);
  1622. fprintf(stderr, " error: %sn", err);
  1623. }
  1625. void
  1626. #ifdef __STDC__
  1627. err(char *err)
  1628. #else
  1629. err(err)
  1630. char *err;
  1631. #endif
  1632. {
  1633. /* back up the file number if we hit an error at the end of the last file */
  1634. if ( CurFile >= NumFiles && CurFile >= 1 ) CurFile--;
  1635. fprintf(stderr, ErrHdr, FileStr[CurFile], zzline);
  1636. fprintf(stderr, " error: %sn", err);
  1637. }
  1639. void
  1640. #ifdef __STDC__
  1641. errNoCR( char *err )
  1642. #else
  1643. errNoCR( err )
  1644. char *err;
  1645. #endif
  1646. {
  1647. /* back up the file number if we hit an error at the end of the last file */
  1648. if ( CurFile >= NumFiles && CurFile >= 1 ) CurFile--;
  1649. fprintf(stderr, ErrHdr, FileStr[CurFile], zzline);
  1650. fprintf(stderr, " error: %s", err);
  1651. }
  1653. UserAction *
  1654. #ifdef __STDC__
  1655. newUserAction(char *s)
  1656. #else
  1657. newUserAction(s)
  1658. char *s;
  1659. #endif
  1660. {
  1661. UserAction *ua = (UserAction *) calloc(1, sizeof(UserAction));
  1662. require(ua!=NULL, "cannot allocate UserAction");
  1664. ua->action = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  1665. strcpy(ua->action, s);
  1666. return ua;
  1667. }
  1669. /* Added by TJP September 1994 */
  1670. /* Take in file.h and return file_h; names w/o '.'s are left alone */
  1671. char *
  1672. #ifdef __USE_PROTOS
  1673. gate_symbol(char *name)
  1674. #else
  1675. gate_symbol(name)
  1676. char *name;
  1677. #endif
  1678. {
  1679. static char buf[100];
  1680. char *p;
  1681. sprintf(buf, "%s", name);
  1683. for (p=buf; *p!=''; p++)
  1684. {
  1685. if ( *p=='.' ) *p = '_';
  1686. }
  1687. return buf;
  1688. }
  1690. char *
  1691. #ifdef __USE_PROTOS
  1692. makeAltID(int blockid, int altnum)
  1693. #else
  1694. makeAltID(blockid, altnum)
  1695. int blockid;
  1696. int altnum;
  1697. #endif
  1698. {
  1699. static char buf[100];
  1700. char *p;
  1701. sprintf(buf, "_blk%d_alt%d", blockid, altnum);
  1702. p = (char *)malloc(strlen(buf)+1);
  1703. strcpy(p, buf);
  1704. return p;
  1705. }