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-2001 29 */ 30 31 /* To set a breakpoint just before exit look for "cleanUp". */ 32 /* To set a breakpoint for fatal error look for "fatal_intern" */ 33 34 #include <stdio.h> 35 36 #include "pcctscfg.h" 37 #include "stdpccts.h" 38 39 #define MAX_INT_STACK 50 40 static int istack[MAX_INT_STACK]; /* Int stack */ 41 static int isp = MAX_INT_STACK; 42 43 static int DontAcceptFiles = 0; /* if stdin, don't read files */ 44 static int DontAcceptStdin = 0; /* if files seen first, don't accept stdin */ 45 46 static int tnodes_used_in_guard_predicates_etc; /* MR10 */ 47 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 */ 49 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; 60 61 #ifdef __USE_PROTOS 62 extern void ProcessArgs(int, char **, Opt *); 63 #else 64 extern void ProcessArgs(); 65 #endif 66 67 #ifdef __USE_PROTOS 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 } 80 81 static void 82 #ifdef __USE_PROTOS 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 } 93 94 require(NumFiles<MaxNumFiles,"exceeded max # of input files"); 95 FileStr[NumFiles++] = "stdin"; 96 DontAcceptFiles = 1; 97 } 98 99 static void 100 #ifdef __USE_PROTOS 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 } 113 114 require(NumFiles<MaxNumFiles,"exceeded max # of input files"); 115 FileStr[NumFiles++] = s; 116 DontAcceptStdin = 1; 117 } 118 119 /* MR14 120 Allow input to be a file containing a list of files 121 Bernard Giroud (b_giroud (at) decus.ch) 122 */ 123 124 static void 125 #ifdef __USE_PROTOS 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; 139 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 } 146 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] = '\0'; 168 DontAcceptStdin = 1; 169 } 170 171 static void 172 #ifdef __USE_PROTOS 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 } 186 187 static void 188 #ifdef __USE_PROTOS 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 } 202 203 static void /* MR6 */ 204 #ifdef __USE_PROTOS 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 */ 218 219 static int ambAidDepthSpecified=0; /* MR11 */ 220 221 static void /* MR11 */ 222 #ifdef __USE_PROTOS 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 */ 233 234 static void /* MR11 */ 235 #ifdef __USE_PROTOS 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 */ 245 246 #ifdef __USE_PROTOS 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 } 255 256 257 #ifdef __USE_PROTOS 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 } 286 287 #ifdef __USE_PROTOS 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 pNOPURIFY(void) { PURIFY = FALSE; } 299 /*static void pCt(void) { warnNoFL("-ct option is now the default"); }*/ 300 static void pLI(void) { GenLineInfo = TRUE; GenLineInfoMS = FALSE; } /* MR14 */ 301 static void pLIms(void) { GenLineInfo = TRUE; GenLineInfoMS = TRUE; } /* MR14 */ 302 static void pFr(char *s, char *t) {RemapFileName = t;} 303 static void pFe(char *s, char *t) {ErrFileName = t;} 304 static void pFl(char *s, char *t) {DlgFileName = t;} 305 static void pFm(char *s, char *t) {ModeFileName = t;} 306 static void pFt(char *s, char *t) {DefFileName = t;} 307 308 static void pE1(void) { elevel = 1; } 309 static void pE2(void) { elevel = 2; } 310 static void pE3(void) { elevel = 3; } 311 static void pEGen(void) { GenEClasseForRules = 1; } 312 static void pDL(void) 313 { 314 DemandLookahead = 1; 315 if ( GenCC ) { 316 warnNoFL("-gk does not work currently in C++ mode; -gk turned off"); 317 DemandLookahead = 0; 318 } 319 } 320 321 static void pAA(char *s,char *t) {MR_AmbAidRule = t;} /* MR11 */ 322 static void pAAm(char *s){MR_AmbAidMultiple = 1;} /* MR11 */ 323 static void pGHdr(void) { GenStdPccts = 1; } 324 static void pFHdr(char *s, char *t) { stdpccts = t; pGHdr(); } 325 static void pW1(void) { WarningLevel = 1; } 326 static void pNewAST(void) { NewAST = 1; } /* MR13 */ 327 static void ptmakeInParser(void) { tmakeInParser = 1; } /* MR23 */ 328 static void pAlpha(void) { AlphaBetaTrace = 1; } /* MR14 */ 329 static void pMR_BlkErr(void) { MR_BlkErr = 1; } /* MR21 */ 330 static void pStdout(void) {UseStdout = 1; } /* MR6 */ 331 static void pW2(void) { WarningLevel = 2; } 332 static void pCC(void) { GenCC = TRUE; } 333 #else 334 static void pCGen() { CodeGen = FALSE; LexGen = FALSE; } 335 static void pLGen() { LexGen = FALSE; } 336 static void pXTGen(){ MR_Inhibit_Tokens_h_Gen = TRUE; } /* MR14 */ 337 static void pTGen() { TraceGen = TRUE; } 338 static void pSGen() { GenExprSetsOpt = FALSE; } 339 static void pPrt() { PrintOut = TRUE; pCGen(); pLGen(); } 340 static void pPrtA() { PrintOut = TRUE; PrintAnnotate = TRUE; pCGen(); pLGen(); } 341 static void pAst() { GenAST = TRUE; } 342 static void pANSI() { GenANSI = TRUE; } 343 static void pCr() { GenCR = TRUE; } 344 static void pNOPURIFY() { PURIFY = FALSE; } 345 346 /*static void pCt() { warnNoFL("-ct option is now the default"); }*/ 347 static void pLI() { GenLineInfo = TRUE; GenLineInfoMS = FALSE; } /* MR14 */ 348 static void pLIms() { GenLineInfo = TRUE; GenLineInfoMS = TRUE; } /* MR14 */ 349 static void pFr(s,t) char *s, *t; {RemapFileName = t;} 350 static void pFe(s,t) char *s, *t; {ErrFileName = t;} 351 static void pFl(s,t) char *s, *t; {DlgFileName = t;} 352 static void pFm(s,t) char *s, *t; {ModeFileName = t;} 353 static void pFt(s,t) char *s, *t; {DefFileName = t;} 354 355 static void pE1() { elevel = 1; } 356 static void pE2() { elevel = 2; } 357 static void pE3() { elevel = 3; } 358 static void pEGen() { GenEClasseForRules = 1; } 359 static void pDL() 360 { 361 DemandLookahead = 1; 362 if ( GenCC ) { 363 warnNoFL("-gk does not work currently in C++ mode; -gk turned off"); 364 DemandLookahead = 0; 365 } 366 } 367 368 static void pAA(s,t) char *s; char *t; {MR_AmbAidRule = t;} /* MR11 BJS 20-Mar-98 */ 369 static void pAAm(s) char *s; {MR_AmbAidMultiple = 1;} /* MR11 BJS 20-Mar-98 */ 370 static void pGHdr() { GenStdPccts = 1; } 371 static void pFHdr(s,t) char *s, *t; { stdpccts = t; pGHdr(); } 372 static void pW1() { WarningLevel = 1; } 373 static void pNewAST() { NewAST = 1; } /* MR13 */ 374 static void ptmakeInParser() { tmakeInParser = 1; } /* MR23 */ 375 static void pAlpha() { AlphaBetaTrace = 1; } /* MR14 */ 376 static void pMR_BlkErr() { MR_BlkErr = 1; } /* MR21 */ 377 static void pStdout() {UseStdout = 1; } /* MR6 */ 378 static void pW2() { WarningLevel = 2; } 379 static void pCC() { GenCC = TRUE; } 380 #endif 381 382 static void 383 #ifdef __USE_PROTOS 384 pPre( char *s, char *t ) 385 #else 386 pPre( s, t ) 387 char *s; 388 char *t; 389 #endif 390 { 391 RulePrefix = t; 392 } 393 394 static void 395 #ifdef __USE_PROTOS 396 pOut( char *s, char *t ) 397 #else 398 pOut( s, t ) 399 char *s; 400 char *t; 401 #endif 402 { 403 OutputDirectory = t; 404 } 405 406 static void 407 #ifdef __USE_PROTOS 408 pPred( void ) 409 #else 410 pPred( ) 411 #endif 412 { 413 warnNoFL("-pr is no longer used (predicates employed if present); see -prc, -mrhoist, -mrhoistk"); 414 /* 415 ** if ( DemandLookahead ) 416 ** warnNoFL("-gk conflicts with -pr; -gk turned off"); 417 ** DemandLookahead = 0; 418 ** HoistPredicateContext = 0; 419 */ 420 } 421 422 static void 423 #ifdef __USE_PROTOS 424 pPredCtx( char *s, char *t ) 425 #else 426 pPredCtx(s,t) 427 char *s; 428 char *t; 429 #endif 430 { 431 if ( ci_strequ(t,"on")) HoistPredicateContext = 1; 432 else if ( ci_strequ(t,"off")) HoistPredicateContext = 0; 433 if ( DemandLookahead ) 434 { 435 warnNoFL("-gk incompatible with semantic predicate usage; -gk turned off"); 436 DemandLookahead = 0; 437 } 438 } 439 440 static void 441 #ifdef __USE_PROTOS 442 pMRhoist( char *s, char *t ) 443 #else 444 pMRhoist(s,t) 445 char *s; 446 char *t; 447 #endif 448 { 449 if ( ci_strequ(t,"on")) MRhoisting = 1; 450 else if ( ci_strequ(t,"off")==0 ) MRhoisting = 0; 451 if (MRhoisting) { 452 fprintf(stderr,"Maintenance Release style hoisting enabled for predicates with lookahead depth = 1\n"); 453 fprintf(stderr," No longer considered experimental\n"); 454 fprintf(stderr," Can't consider suppression for predicates with lookahead depth > 1\n"); 455 fprintf(stderr," Implies -prc on but does *not* imply -mrhoistk for k>1 predicates\n"); 456 fprintf(stderr," This is a reminder, not a warning or error.\n"); 457 }; 458 } 459 460 static void 461 #ifdef __USE_PROTOS 462 pMRhoistk( char *s, char *t ) 463 #else 464 pMRhoistk(s,t) 465 char *s; 466 char *t; 467 #endif 468 { 469 if ( ci_strequ(t,"on")) MRhoistingk = 1; 470 else if ( ci_strequ(t,"off")==0 ) MRhoistingk = 0; 471 if (MRhoistingk) { 472 fprintf(stderr,"EXPERIMENTAL Maintenance Release style hoisting enabled\n"); 473 fprintf(stderr," Applies to predicates with lookahead depth > 1\n"); 474 fprintf(stderr," Implies -prc on and -mrhoist on\n"); 475 }; 476 } 477 478 static void 479 #ifdef __USE_PROTOS 480 pTRes( char *s, char *t ) 481 #else 482 pTRes( s, t ) 483 char *s; 484 char *t; 485 #endif 486 { 487 TreeResourceLimit = atoi(t); 488 if ( TreeResourceLimit <= 0 ) 489 { 490 warnNoFL("analysis resource limit (# of tree nodes) must be greater than 0"); 491 TreeResourceLimit = -1; /* set to no limit */ 492 } 493 } 494 495 Opt options[] = { 496 #ifdef __cplusplus 497 { "-CC", 0, (void (*)(...)) pCC, "Generate C++ output (default=FALSE)"}, 498 { "-ck", 1, (void (*)(...)) pCk, "Set compressed lookahead depth; fast approximate lookahead"}, 499 { "-cr", 0, (void (*)(...)) pCr, "Generate cross reference (default=FALSE)"}, 500 { "-e1", 0, (void (*)(...)) pE1, "Ambiguities/errors shown in low detail (default)"}, 501 { "-e2", 0, (void (*)(...)) pE2, "Ambiguities/errors shown in more detail"}, 502 { "-e3", 0, (void (*)(...)) pE3, 503 "Ambiguities for k>1 grammars shown with exact tuples (not lookahead sets)"}, 504 { "-f", 1, (void (*)(...)) pFileList,"Read names of grammar files from specified file"}, /* MR14 */ 505 { "-fe", 1, (void (*)(...)) pFe, "Rename err.c"}, 506 { "-fh", 1, (void (*)(...)) pFHdr, "Rename stdpccts.h header (turns on -gh)"}, 507 { "-fl", 1, (void (*)(...)) pFl, "Rename lexical output--parser.dlg"}, 508 { "-fm", 1, (void (*)(...)) pFm, "Rename mode.h"}, 509 { "-fr", 1, (void (*)(...)) pFr, "Rename remap.h"}, 510 { "-ft", 1, (void (*)(...)) pFt, "Rename tokens.h"}, 511 { "-ga", 0, (void (*)(...)) pANSI, "Generate ANSI-compatible code (default=FALSE)"}, 512 { "-gc", 0, (void (*)(...)) pCGen, "Do not generate output parser code (default=FALSE)"}, 513 { "-gd", 0, (void (*)(...)) pTGen, "Generate code to trace rule invocation (default=FALSE)"}, 514 { "-ge", 0, (void (*)(...)) pEGen, "Generate an error class for each non-terminal (default=FALSE)"}, 515 { "-gh", 0, (void (*)(...)) pGHdr, "Generate stdpccts.h for non-ANTLR-generated-files to include"}, 516 { "-gk", 0, (void (*)(...)) pDL, "Generate parsers that delay lookahead fetches until needed"}, 517 { "-gl", 0, (void (*)(...)) pLI, "Generate line info about grammar actions in parser"}, 518 { "-glms", 0, (void (*)(...)) pLIms,"Like -gl but replace '\\' with '/' in #line filenames for MS C/C++ systems"}, 519 { "-gp", 1, (void (*)(...)) pPre, "Prefix all generated rule functions with a string"}, 520 { "-gs", 0, (void (*)(...)) pSGen, "Do not generate sets for token expression lists (default=FALSE)"}, 521 { "-gt", 0, (void (*)(...)) pAst, "Generate code for Abstract-Syntax-Trees (default=FALSE)"}, 522 { "-gx", 0, (void (*)(...)) pLGen, "Do not generate lexical (dlg-related) files (default=FALSE)"}, 523 { "-gxt",0, (void (*)(...)) pXTGen, "Do not generate tokens.h (default=FALSE)"}, 524 { "-k", 1, (void (*)(...)) pLLK, "Set full LL(k) lookahead depth (default==1)"}, 525 { "-o", 1, (void (*)(...)) pOut, OutputDirectoryOption}, 526 { "-p", 0, (void (*)(...)) pPrt, "Print out the grammar w/o actions (default=no)"}, 527 { "-pa", 0, (void (*)(...)) pPrtA, "Print out the grammar w/o actions & w/FIRST sets (default=no)"}, 528 { "-pr",0, (void (*)(...)) pPred, "no longer used; predicates employed if present"}, 529 { "-prc", 1, (void (*)(...)) pPredCtx,"Turn on/off computation of context for hoisted predicates"}, 530 { "-rl", 1, (void (*)(...)) pTRes, "Limit max # of tree nodes used by grammar analysis"}, 531 { "-stdout",0, (void (*)(...)) pStdout,"Send grammar.c/grammar.cpp to stdout"}, /* MR6 */ 532 { "-tab", 1, (void (*)(...)) pTab, "Width of tabs (1 to 8) for grammar.c/grammar.cpp files"}, /* MR6 */ 533 { "-w1", 0, (void (*)(...)) pW1, "Set the warning level to 1 (default)"}, 534 { "-w2", 0, (void (*)(...)) pW2, "Ambiguities yield warnings even if predicates or (...)? block"}, 535 { "-", 0, (void (*)(...)) pStdin, "Read grammar from stdin" }, 536 { "-mrhoist",1, (void (*)(...)) pMRhoist, /* MR9 */ 537 "Turn on/off k=1 Maintenance Release style hoisting"}, /* MR9 */ 538 { "-mrhoistk",1, (void (*)(...)) pMRhoistk, /* MR9 */ 539 "Turn on/off EXPERIMENTAL k>1 Maintenance Release style hoisting"}, /* MR13 */ 540 { "-aa" , 1, (void (*)(...)) pAA, "Ambiguity aid for a rule (rule name or line number)"}, /* MR11 */ 541 { "-aam" , 0, (void (*)(...)) pAAm, 542 "Lookahead token may appear multiple times in -aa listing"}, /* MR11 */ 543 { "-aad" , 1, (void (*)(...)) pAAd, 544 "Limits exp growth of -aa listing - default=1 (max=ck value)"}, /* MR11 */ 545 { "-info", 1, (void (*)(...)) pInfo, 546 "Extra info: p=pred t=tnodes f=first/follow m=monitor o=orphans 0=noop"}, /* MR12 */ 547 { "-treport",1,(void (*)(...)) pTreport, 548 "Report when tnode usage exceeds value during ambiguity resolution"}, /* MR11 */ 549 { "-newAST", 0, (void (*)(...)) pNewAST, 550 "In C++ mode use \"newAST(...)\" rather than \"new AST(...)\""}, /* MR13 */ 551 { "-tmake", 0, (void (*)(...)) ptmakeInParser, 552 "In C++ mode use parser's tmake method rather than \"ASTBase::tmake(...)\""}, /* MR23 */ 553 { "-alpha",0,(void (*)(...)) pAlpha, 554 "Provide additional information for \"(alpha)? beta\" error messages"}, /* MR14 */ 555 { "-mrblkerr",0,(void (*)(...)) pMR_BlkErr, /* MR21 */ 556 "EXPERIMENTAL change to (...)* and (...)+ syntax error sets"}, /* MR21 */ 557 { "-nopurify",0,(void (*)(...)) pNOPURIFY, 558 "Don't use the notorious PURIFY macro (replaced by MR23 initial value syntax) to zero return arguments of rules"}, /* MR23 */ 559 { "*", 0, (void (*)(...)) pFile, "" }, /* anything else is a file */ 560 #else 561 { "-CC", 0, pCC, "Generate C++ output (default=FALSE)"}, 562 { "-cr", 0, pCr, "Generate cross reference (default=FALSE)"}, 563 { "-ck", 1, pCk, "Set compressed lookahead depth; fast approximate lookahead"}, 564 { "-e1", 0, pE1, "Ambiguities/errors shown in low detail (default)"}, 565 { "-e2", 0, pE2, "Ambiguities/errors shown in more detail"}, 566 { "-e3", 0, pE3, "Ambiguities for k>1 grammars shown with exact tuples (not lookahead sets)"}, 567 { "-f", 1, pFileList,"Read names of grammar files from specified file"}, /* MR14 */ 568 { "-fe", 1, pFe, "Rename err.c"}, 569 { "-fh", 1, pFHdr, "Rename stdpccts.h header (turns on -gh)"}, 570 { "-fl", 1, pFl, "Rename lexical output--parser.dlg"}, 571 { "-fm", 1, pFm, "Rename mode.h"}, 572 { "-fr", 1, pFr, "Rename remap.h"}, 573 { "-ft", 1, pFt, "Rename tokens.h"}, 574 { "-ga", 0, pANSI, "Generate ANSI-compatible code (default=FALSE)"}, 575 { "-gc", 0, pCGen, "Do not generate output parser code (default=FALSE)"}, 576 { "-gd", 0, pTGen, "Generate code to trace rule invocation (default=FALSE)"}, 577 { "-ge", 0, pEGen, "Generate an error class for each non-terminal (default=FALSE)"}, 578 { "-gh", 0, pGHdr, "Generate stdpccts.h for non-ANTLR-generated-files to include"}, 579 { "-gk", 0, pDL, "Generate parsers that delay lookahead fetches until needed"}, 580 { "-gl", 0, pLI, "Generate line info about grammar actions in C parser"}, 581 { "-glms", 0, pLIms,"Like -gl but replace '\\' with '/' in #line filenames for MS C/C++ systems"}, 582 { "-gp", 1, pPre, "Prefix all generated rule functions with a string"}, 583 { "-gs", 0, pSGen, "Do not generate sets for token expression lists (default=FALSE)"}, 584 { "-gt", 0, pAst, "Generate code for Abstract-Syntax-Trees (default=FALSE)"}, 585 { "-gx", 0, pLGen, "Do not generate lexical (dlg-related) files (default=FALSE)"}, 586 { "-gxt",0, pXTGen, "Do not generate tokens.h (default=FALSE)"}, 587 { "-k", 1, pLLK, "Set full LL(k) lookahead depth (default==1)"}, 588 { "-o", 1, pOut, OutputDirectoryOption}, 589 { "-p", 0, pPrt, "Print out the grammar w/o actions (default=no)"}, 590 { "-pa", 0, pPrtA, "Print out the grammar w/o actions & w/FIRST sets (default=no)"}, 591 { "-pr",0, pPred, "no longer used; predicates employed if present"}, 592 { "-prc", 1, pPredCtx,"Turn on/off computation of context for hoisted predicates"}, 593 { "-rl", 1, pTRes, "Limit max # of tree nodes used by grammar analysis"}, 594 { "-stdout",0, pStdout, "Send grammar.c/grammar.cpp to stdout"}, /* MR6 */ 595 { "-tab", 1, pTab, "Width of tabs (1 to 8) for grammar.c/grammar.cpp files"}, /* MR6 */ 596 { "-w1", 0, pW1, "Set the warning level to 1 (default)"}, 597 { "-w2", 0, pW2, "Ambiguities yield warnings even if predicates or (...)? block"}, 598 { "-mrhoist",1,pMRhoist, /* MR9 */ 599 "Turn on/off k=1 Maintenance Release style hoisting"}, /* MR9 */ 600 { "-mrhoistk",1,pMRhoistk, /* MR13 */ 601 "Turn on/off k>1 EXPERIMENTAL Maintenance Release style hoisting"}, /* MR13 */ 602 { "-aa" ,1,pAA, "Ambiguity aid for a rule (rule name or line number)"}, /* MR11 */ 603 { "-aam" ,0,pAAm, 604 "Lookahead token may appear multiple times in -aa listing"}, /* MR11 */ 605 { "-aad" ,1,pAAd, 606 "Limits exp growth of -aa listing - default=1 (max=ck value)"}, /* MR11 */ 607 { "-info",1,pInfo, 608 "Extra info: p=pred t=tnodes f=first/follow m=monitor o=orphans 0=noop"}, /* MR11 */ 609 { "-treport",1,pTreport, 610 "Report when tnode usage exceeds value during ambiguity resolution"}, /* MR11 */ 611 { "-newAST", 0, pNewAST, 612 "In C++ mode use \"newAST(...)\" rather than \"new AST(...)\""}, /* MR13 */ 613 { "-tmake", 0, ptmakeInParser, 614 "In C++ mode use parser's tmake method rather than \"ASTBase::tmake(...)\""}, /* MR23 */ 615 { "-alpha",0, pAlpha, 616 "Provide additional information for \"(alpha)? beta\" error messages"}, /* MR14 */ 617 { "-mrblkerr",0,pMR_BlkErr, /* MR21 */ 618 "EXPERIMENTAL change to (...)* and (...)+ syntax error sets"}, /* MR21 */ 619 { "-nopurify",0,pNOPURIFY, 620 "Don't use the notorious PURIFY macro (replaced by MR23 initial value syntax) to zero return arguments of rules"}, /* MR23 */ 621 { "-", 0, pStdin, "Read grammar from stdin" }, 622 { "*", 0, pFile, "" }, /* anything else is a file */ 623 #endif 624 { NULL, 0, NULL } 625 }; 626 627 void readDescr(); 628 void cleanUp(); 629 630 #ifdef __USE_PROTOS 631 static void buildRulePtr( void ); 632 static void help( void ); 633 static void init( void ); 634 static void CompleteTokenSetRefs( void ); 635 static void ensure_no_C_file_collisions(char *); 636 static void CompleteContextGuards(void); 637 #else 638 static void buildRulePtr( ); 639 static void help( ); 640 static void init( ); 641 static void CompleteTokenSetRefs( ); 642 static void ensure_no_C_file_collisions(); 643 static void CompleteContextGuards(); 644 #endif 645 646 static void 647 #ifdef __USE_PROTOS /* <BJS> */ 648 report_numericPredLabels(ActionNode *a) 649 #else 650 report_numericPredLabels(a) 651 ActionNode *a; 652 #endif 653 { /* MR10 */ 654 warnFL("numeric references to attributes (e.g. $i or $i.j) in semantic pred will be null during guess mode", /* MR10 */ 655 FileStr[a->file],a->line); /* MR10 */ 656 } /* MR10 */ 657 658 /* M a i n */ 659 660 int 661 #ifdef __USE_PROTOS 662 main( int argc, char *argv[] ) 663 #else 664 main( argc, argv ) 665 int argc; 666 char *argv[]; 667 #endif 668 { 669 int i; 670 static char EPSTR[] = "[Ep]"; 671 672 Save_argc=argc; /* MR10 */ 673 Save_argv=argv; /* MR10 */ 674 675 /* malloc_debug(8);*/ 676 677 #ifdef SPECIAL_INITS 678 special_inits(); /* MR1 */ 679 #endif 680 fprintf(stderr, "Antlr parser generator Version %s 1989-2001\n", Version); 681 if ( argc == 1 ) { help(); zzDIE; } 682 ProcessArgs(argc-1, &(argv[1]), options); 683 684 /* MR14 */ if (MR_AmbAidRule && AlphaBetaTrace) { 685 /* MR14 */ fatal("Can't specify both -aa (ambiguity aid) and -alpha (\"(alpha)? beta\" aid)"); 686 /* MR14 */ } 687 688 if (MRhoistingk) { /* MR13 */ 689 HoistPredicateContext=1; /* MR13 */ 690 MRhoisting=1; /* MR13 */ 691 }; /* MR13 */ 692 if (MRhoisting && ! HoistPredicateContext) { 693 /*** warnNoFL("Using \"-mrhoist\" forces \"-prc on\""); ***/ 694 HoistPredicateContext=1; 695 }; 696 if (HoistPredicateContext && ! MRhoisting) { 697 warnNoFL("When using predicate context (-prc on) -mrhoist on is recommended"); 698 } 699 /* Fix lookahead depth */ 700 /* Compressed lookahead must always be larger than or equal to full lookahead */ 701 if ( CLL_k < LL_k && CLL_k>0 ) 702 { 703 warnNoFL("must have compressed lookahead >= full LL(k) lookahead (setting -ck to -k)"); 704 CLL_k = LL_k; 705 } 706 if ( CLL_k == -1 ) CLL_k = LL_k; 707 OutputLL_k = CLL_k; 708 if ( ((CLL_k-1)&CLL_k)!=0 ) { /* output ll(k) must be power of 2 */ 709 int n; 710 for(n=1; n<CLL_k; n<<=1) {;} 711 OutputLL_k = n; 712 }; 713 714 if (MR_BlkErr) { 715 warnNoFL("The -mrblkerr option is EXPERIMENTAL"); 716 if (LL_k > 1) { 717 warnNoFL("The -mrblkerr option is designed only for k=1 ck=1 grammars"); 718 } 719 }; 720 721 if ( ! ambAidDepthSpecified) { 722 MR_AmbAidDepth=1; 723 } else { 724 if (MR_AmbAidDepth > CLL_k || MR_AmbAidDepth <= 0) { 725 warnNoFL(eMsgd( 726 "Ambiguity aid depth (\"-aad ...\") must be a number between 1 and max(k,ck)=%d",CLL_k)); 727 MR_AmbAidDepth=1; 728 }; 729 if (MR_AmbAidDepth == 0) { 730 MR_AmbAidDepth=2; 731 }; 732 }; 733 734 if (MR_AmbAidRule != NULL) MR_AmbAidLine=atoi(MR_AmbAidRule); 735 736 fpTrans = &(C_Trans[0]); /* Translate to C Language */ 737 fpJTrans = &(C_JTrans[0]); 738 init(); 739 lexclass(LexStartSymbol); 740 741 readDescr(); 742 LastTokenCounted = TokenNum; 743 RemapForcedTokens(); 744 if ( CannotContinue ) {cleanUp(); zzDIE;} 745 if ( GenCC && no_classes_found ) fatal("required grammar class not found (exiting...)"); 746 if ( WarningLevel>1 && HdrAction == NULL ) 747 warnNoFL("no #header action was found"); 748 if ( FoundAtOperator && ! FoundExceptionGroup) { 749 warnNoFL("found the exception operator '@' - but no exception group was found"); 750 }; 751 EpToken = addTname(EPSTR); /* add imaginary token epsilon */ 752 set_orel(EpToken, &imag_tokens); 753 754 /* this won't work for hand-built scanners since EofToken is not 755 * known. Forces EOF to be token type 1. 756 */ 757 set_orel(EofToken, &imag_tokens); 758 759 set_size(NumWords(TokenNum-1)); 760 761 /* compute the set of all known token types 762 * It represents the set of tokens from 1 to last_token_num + the 763 * reserved positions above that (if any). Don't include the set of 764 * imaginary tokens such as the token/error classes or EOF. 765 */ 766 { 767 set a; 768 a = set_dup(reserved_positions); 769 for (i=1; i<TokenNum; i++) { set_orel(i, &a); } 770 all_tokens = set_dif(a, imag_tokens); 771 set_free(a); 772 } 773 774 ComputeTokSets(); /* Compute #tokclass sets */ 775 CompleteTokenSetRefs(); /* Change complex nodes in syn diag */ 776 CompleteContextGuards(); /* MR13 */ 777 778 if ( CodeGen ) genDefFile(); /* create tokens.h */ 779 if ( LexGen ) genLexDescr(); /* create parser.dlg */ 780 781 if ( GenStdPccts ) 782 { 783 FILE *f = fopen(OutMetaName(stdpccts), "w"); 784 if ( f==NULL ) {warnNoFL( eMsg1("can't create %s",OutMetaName(stdpccts)) );} 785 else 786 { 787 #ifdef SPECIAL_FOPEN 788 special_fopen_actions(OutMetaName(stdpccts)); /* MR1 */ 789 #endif 790 if (strcmp(stdpccts,"stdpccts.h") == 0) { /* MR10 */ 791 genStdPCCTSIncludeFile(f,NULL); /* MR10 */ 792 } else { /* MR10 */ 793 genStdPCCTSIncludeFile(f,pcctsBaseName(stdpccts)); /* MR32 */ 794 }; 795 fclose(f); 796 } 797 } 798 799 buildRulePtr(); /* create mapping from rule # to RuleBlk junction */ 800 ComputeErrorSets(); 801 FoLink( (Node *)SynDiag ); /* add follow links to end of all rules */ 802 803 if ( GenCR ) GenCrossRef( SynDiag ); 804 805 if ( CodeGen ) 806 { 807 if ( SynDiag == NULL ) 808 { 809 warnNoFL("no grammar description recognized"); 810 cleanUp(); 811 zzDIE; 812 } 813 else if ( !GenCC ) { 814 ErrFile = fopen(OutMetaName(ErrFileName), "w"); 815 require(ErrFile != NULL, "main: can't open err file"); 816 #ifdef SPECIAL_FOPEN 817 special_fopen_actions(OutMetaName(ErrFileName)); /* MR1 */ 818 #endif 819 NewSetWd(); 820 GenErrHdr(); 821 TRANS(SynDiag); /* Translate to the target language */ 822 DumpSetWd(); 823 DumpRemainingTokSets(); 824 fclose( ErrFile ); 825 } 826 else { 827 strcpy(Parser_h_Name, CurrentClassName); 828 strcat(Parser_h_Name, ".h"); 829 strcpy(Parser_c_Name, CurrentClassName); 830 strcat(Parser_c_Name, CPP_FILE_SUFFIX); 831 ensure_no_C_file_collisions(Parser_c_Name); 832 Parser_h = fopen(OutMetaName(Parser_h_Name), "w"); 833 require(Parser_h != NULL, "main: can't open class Parserx.h file"); 834 #ifdef SPECIAL_FOPEN 835 special_fopen_actions(OutMetaName(Parser_h_Name)); /* MR1 */ 836 #endif 837 Parser_c = fopen(OutMetaName(Parser_c_Name), "w"); 838 require(Parser_c != NULL, "main: can't open class Parserx.c file"); 839 #ifdef SPECIAL_FOPEN 840 special_fopen_actions(OutMetaName(Parser_c_Name)); /* MR1 */ 841 #endif 842 GenParser_h_Hdr(); 843 if ( class_before_actions != NULL ) 844 { 845 ListNode *p; 846 for (p = class_before_actions->next; p!=NULL; p=p->next) 847 { 848 UserAction *ua = (UserAction *)p->elem; 849 dumpAction( ua->action, Parser_h, 0, ua->file, ua->line, 1); 850 } 851 } 852 GenParser_c_Hdr(); 853 fprintf(Parser_h, "protected:\n"); /* MR20 */ 854 NewSetWd(); 855 TRANS(SynDiag); /* Translate to the target language */ 856 DumpSetWd(); 857 GenRuleMemberDeclarationsForCC(Parser_h, SynDiag); 858 if ( class_after_actions != NULL ) 859 { 860 ListNode *p; 861 for (p = class_after_actions->next; p!=NULL; p=p->next) 862 { 863 UserAction *ua = (UserAction *)p->elem; 864 dumpAction( ua->action, Parser_h, 0, ua->file, ua->line, 1); 865 } 866 } 867 DumpRemainingTokSets(); 868 fprintf(Parser_h, "};\n"); 869 fprintf(Parser_h, "\n#endif /* %s_h */\n", CurrentClassName); 870 fclose( Parser_h ); 871 fclose( Parser_c ); 872 } 873 } 874 875 MR_orphanRules(stderr); 876 if (LTinTokenAction && WarningLevel >= 2) { 877 if (GenCC) { 878 warnNoFL("At least one <<action>> following a token match contains a reference to LT(...)\n this will reference the immediately preceding token,\n not the one which follows as is the case with semantic predicates."); 879 } 880 warnNoFL("At least one <<action>> following a token match contains a reference to LA(...) or LATEXT(...)\n this will reference the immediately preceding token,\n not the one which follows as is the case with semantic predicates."); 881 } 882 883 if ( PrintOut ) 884 { 885 if ( SynDiag == NULL ) {warnNoFL("no grammar description recognized");} 886 else PRINT(SynDiag); 887 } 888 889 #ifdef DBG_LL1 890 #endif 891 GenRemapFile(); /* create remap.h */ 892 /* MR10 */ if (FoundGuessBlk) { 893 #ifdef __cplusplus__ 894 /* MR10 */ list_apply(NumericPredLabels, (void (*)(void *))report_numericPredLabels); 895 #else 896 #ifdef __USE_PROTOS 897 /* MR10 */ list_apply(NumericPredLabels, (void (*)(void *))report_numericPredLabels); 898 #else 899 /* MR10 */ list_apply(NumericPredLabels,report_numericPredLabels); 900 #endif 901 #endif 902 /* MR10 */ }; 903 904 if (InfoT && TnodesAllocated > 0) { 905 if (TnodesPeak > 10000) { 906 fprintf(stdout,"\nTree Nodes: peak %dk created %dk lost %d\n", 907 (TnodesPeak/1000), 908 (TnodesAllocated/1000), 909 TnodesInUse-tnodes_used_in_guard_predicates_etc); 910 } else { 911 fprintf(stdout,"\nTree Nodes: peak %d created %d lost %d\n", 912 TnodesPeak, 913 TnodesAllocated, 914 TnodesInUse-tnodes_used_in_guard_predicates_etc); 915 }; 916 }; 917 if (InfoF) { 918 DumpFcache(); 919 }; 920 if (MR_skipped_e3_report) { 921 fprintf(stderr,"note: use -e3 to get exact information on ambiguous tuples\n"); 922 }; 923 if (MR_BadExprSets != 0) { 924 fprintf(stderr,"note: Unreachable C or C++ code was generated for empty expression sets,\n"); 925 fprintf(stderr," probably due to undefined rules or infinite left recursion.\n"); 926 fprintf(stderr," To locate: search the generated code for \"empty set expression\"\n"); 927 }; 928 if (MR_AmbAidRule != NULL && MR_matched_AmbAidRule==0) { 929 RuleEntry *q = (RuleEntry *) hash_get(Rname,MR_AmbAidRule); 930 if (MR_AmbAidLine == 0 && q == NULL) { 931 warnNoFL(eMsg2("there is no rule \"%s\" so \"-aa %s\" will never match", 932 MR_AmbAidRule,MR_AmbAidRule)); 933 } else { 934 warnNoFL(eMsg1("there was no ambiguity that matched \"-aa %s\"",MR_AmbAidRule)); 935 }; 936 }; 937 if (AlphaBetaTrace) { 938 939 if (MR_AlphaBetaMessageCount == 0) { 940 fprintf(stderr,"note: there were no messages about \"(alpha)? beta\" blocks added to the generated code\n"); 941 } else { 942 fprintf(stderr,"note: there were %d messages about \"(alpha)? beta\" blocks added to the generated code\n", 943 MR_AlphaBetaMessageCount); 944 } 945 946 if (set_null(MR_CompromisedRules)) { 947 fprintf(stderr,"note: the list of rules with compromised follow sets is empty\n"); 948 } else { 949 fprintf(stderr,"note: the following is a list of rules which *may* have incorrect\n"); 950 fprintf(stderr," follow sets computed as a result of an \"(alpha)? beta\" block\n"); 951 fprintf(stderr,"\n"); 952 MR_dumpRuleSet(MR_CompromisedRules); 953 fprintf(stderr,"\n"); 954 } 955 } 956 cleanUp(); 957 exit(PCCTS_EXIT_SUCCESS); 958 return 0; /* MR11 make compilers happy */ 959 } 960 961 static void 962 #ifdef __USE_PROTOS 963 init( void ) 964 #else 965 init( ) 966 #endif 967 { 968 SignalEntry *q; 969 970 Tname = newHashTable(); 971 Rname = newHashTable(); 972 Fcache = newHashTable(); 973 Tcache = newHashTable(); 974 Sname = newHashTable(); 975 Pname = newHashTable(); /* MR11 */ 976 977 /* Add default signal names */ 978 q = (SignalEntry *)hash_add(Sname, 979 "NoViableAlt", 980 (Entry *)newSignalEntry("NoViableAlt")); 981 require(q!=NULL, "cannot alloc signal entry"); 982 q->signum = sigNoViableAlt; 983 q = (SignalEntry *)hash_add(Sname, 984 "MismatchedToken", 985 (Entry *)newSignalEntry("MismatchedToken")); 986 require(q!=NULL, "cannot alloc signal entry"); 987 q->signum = sigMismatchedToken; 988 q = (SignalEntry *)hash_add(Sname, 989 "NoSemViableAlt", 990 (Entry *)newSignalEntry("NoSemViableAlt")); 991 require(q!=NULL, "cannot alloc signal entry"); 992 q->signum = sigNoSemViableAlt; 993 994 reserved_positions = empty; 995 all_tokens = empty; 996 imag_tokens = empty; 997 tokclasses = empty; 998 TokenStr = (char **) calloc(TSChunk, sizeof(char *)); 999 require(TokenStr!=NULL, "main: cannot allocate TokenStr"); 1000 FoStack = (int **) calloc(CLL_k+1, sizeof(int *)); 1001 require(FoStack!=NULL, "main: cannot allocate FoStack"); 1002 FoTOS = (int **) calloc(CLL_k+1, sizeof(int *)); 1003 require(FoTOS!=NULL, "main: cannot allocate FoTOS"); 1004 Cycles = (ListNode **) calloc(CLL_k+1, sizeof(ListNode *)); 1005 require(Cycles!=NULL, "main: cannot allocate Cycles List"); 1006 MR_CompromisedRules=empty; /* MR14 */ 1007 } 1008 1009 static void 1010 #ifdef __USE_PROTOS 1011 help( void ) 1012 #else 1013 help( ) 1014 #endif 1015 { 1016 Opt *p = options; 1017 fprintf(stderr, "antlr [options] f1 f2 ... fn\n"); 1018 while ( *(p->option) != '*' ) 1019 { 1020 fprintf(stderr, " %-9s%s %s\n", 1021 p->option, 1022 (p->arg)?"___":" ", 1023 p->descr); 1024 p++; 1025 } 1026 } 1027 1028 /* The RulePtr array is filled in here. RulePtr exists primarily 1029 * so that sets of rules can be maintained for the FOLLOW caching 1030 * mechanism found in rJunc(). RulePtr maps a rule num from 1 to n 1031 * to a pointer to its RuleBlk junction where n is the number of rules. 1032 */ 1033 static void 1034 #ifdef __USE_PROTOS 1035 buildRulePtr( void ) 1036 #else 1037 buildRulePtr( ) 1038 #endif 1039 { 1040 int r=1; 1041 Junction *p = SynDiag; 1042 RulePtr = (Junction **) calloc(NumRules+1, sizeof(Junction *)); 1043 require(RulePtr!=NULL, "cannot allocate RulePtr array"); 1044 1045 while ( p!=NULL ) 1046 { 1047 require(r<=NumRules, "too many rules???"); 1048 RulePtr[r++] = p; 1049 p = (Junction *)p->p2; 1050 } 1051 } 1052 1053 void 1054 #ifdef __USE_PROTOS 1055 dlgerror(const char *s) 1056 #else 1057 dlgerror(s) 1058 char *s; 1059 #endif 1060 { 1061 fprintf(stderr, ErrHdr, FileStr[CurFile], zzline); 1062 fprintf(stderr, " lexical error: %s (text was '%s')\n", 1063 ((s == NULL) ? "Lexical error" : s), zzlextext); 1064 } 1065 1066 void 1067 #ifdef __USE_PROTOS 1068 readDescr( void ) 1069 #else 1070 readDescr( ) 1071 #endif 1072 { 1073 zzerr = dlgerror; 1074 input = NextFile(); 1075 if ( input==NULL ) fatal("No grammar description found (exiting...)"); 1076 ANTLR(grammar(), input); 1077 tnodes_used_in_guard_predicates_etc=TnodesInUse; /* MR10 */ 1078 } 1079 1080 FILE * 1081 #ifdef __USE_PROTOS 1082 NextFile( void ) 1083 #else 1084 NextFile( ) 1085 #endif 1086 { 1087 FILE *f; 1088 1089 for (;;) 1090 { 1091 CurFile++; 1092 if ( CurFile >= NumFiles ) return(NULL); 1093 if ( ci_strequ(FileStr[CurFile],"stdin")) return stdin; 1094 f = fopen(FileStr[CurFile], "r"); 1095 if ( f == NULL ) 1096 { 1097 warnNoFL( eMsg1("file %s doesn't exist; ignored", FileStr[CurFile]) ); 1098 } 1099 else 1100 { 1101 return(f); 1102 } 1103 } 1104 } 1105 1106 /* 1107 * Return a string corresponding to the output file name associated 1108 * with the input file name passed in. 1109 * 1110 * Observe the following rules: 1111 * 1112 * f.e --> f".c" 1113 * f --> f".c" 1114 * f. --> f".c" 1115 * f.e.g --> f.e".c" 1116 * 1117 * Where f,e,g are arbitrarily long sequences of characters in a file 1118 * name. 1119 * 1120 * In other words, if a ".x" appears on the end of a file name, make it 1121 * ".c". If no ".x" appears, append ".c" to the end of the file name. 1122 * 1123 * C++ mode using .cpp not .c. 1124 * 1125 * Use malloc() for new string. 1126 */ 1127 1128 char * 1129 #ifdef __USE_PROTOS 1130 outname( char *fs ) 1131 #else 1132 outname( fs ) 1133 char *fs; 1134 #endif 1135 { 1136 if ( GenCC) { 1137 return outnameX(fs,CPP_FILE_SUFFIX); 1138 } else { 1139 return outnameX(fs,".c"); 1140 }; 1141 } 1142 1143 char * 1144 #ifdef __USE_PROTOS 1145 outnameX( char *fs ,char *suffix) 1146 #else 1147 outnameX( fs , suffix ) 1148 char *fs; 1149 char *suffix; 1150 #endif 1151 { 1152 static char buf[MaxFileName+1]; 1153 char *p; 1154 require(fs!=NULL&&*fs!='\0', "outname: NULL filename"); 1155 1156 p = buf; 1157 strcpy(buf, fs); 1158 while ( *p != '\0' ) {p++;} /* Stop on '\0' */ 1159 while ( *p != '.' && p != buf ) {--p;} /* Find '.' */ 1160 if ( p != buf ) *p = '\0'; /* Found '.' */ 1161 require(strlen(buf) + 2 < (size_t)MaxFileName, "outname: filename too big"); 1162 strcat(buf,suffix); 1163 return( buf ); 1164 } 1165 1166 void 1167 #ifdef __USE_PROTOS 1168 fatalFL( char *err_, char *f, int l ) 1169 #else 1170 fatalFL( err_, f, l ) 1171 char *err_; 1172 char *f; 1173 int l; 1174 #endif 1175 { 1176 fprintf(stderr, ErrHdr, f, l); 1177 fprintf(stderr, " %s\n", err_); 1178 cleanUp(); 1179 exit(PCCTS_EXIT_FAILURE); 1180 } 1181 1182 void 1183 #ifdef __USE_PROTOS 1184 fatal_intern( char *err_, char *f, int l ) 1185 #else 1186 fatal_intern( err_, f, l ) 1187 char *err_; 1188 char *f; 1189 int l; 1190 #endif 1191 { 1192 fprintf(stderr, ErrHdr, f, l); 1193 fprintf(stderr, " #$%%*&@# internal error: %s\n", err_); 1194 fprintf(stderr, ErrHdr, f, l); 1195 fprintf(stderr, " [complain to nearest government official\n"); 1196 fprintf(stderr, ErrHdr, f, l); 1197 fprintf(stderr, " or send hate-mail to parrt (at) parr-research.com;\n"); 1198 fprintf(stderr, ErrHdr, f, l); 1199 fprintf(stderr, " please pray to the ``bug'' gods that there is a trival fix.]\n"); 1200 cleanUp(); 1201 exit(PCCTS_EXIT_FAILURE); 1202 } 1203 1204 void 1205 #ifdef __USE_PROTOS 1206 cleanUp( void ) 1207 #else 1208 cleanUp( ) 1209 #endif 1210 { 1211 if ( DefFile != NULL) fclose( DefFile ); 1212 } 1213 1214 /* sprintf up to 3 strings */ 1215 char * 1216 #ifdef __USE_PROTOS 1217 eMsg3( char *s, char *a1, char *a2, char *a3 ) 1218 #else 1219 eMsg3( s, a1, a2, a3 ) 1220 char *s; 1221 char *a1; 1222 char *a2; 1223 char *a3; 1224 #endif 1225 { 1226 static char buf[250]; /* DANGEROUS as hell !!!!!! */ 1227 1228 sprintf(buf, s, a1, a2, a3); 1229 return( buf ); 1230 } 1231 1232 /* sprintf a decimal */ 1233 char * 1234 #ifdef __USE_PROTOS 1235 eMsgd( char *s, int d ) 1236 #else 1237 eMsgd( s, d ) 1238 char *s; 1239 int d; 1240 #endif 1241 { 1242 static char buf[250]; /* DANGEROUS as hell !!!!!! */ 1243 1244 sprintf(buf, s, d); 1245 return( buf ); 1246 } 1247 1248 char * 1249 #ifdef __USE_PROTOS 1250 eMsgd2( char *s, int d1,int d2) 1251 #else 1252 eMsgd2( s, d1, d2 ) 1253 char *s; 1254 int d1; 1255 int d2; 1256 #endif 1257 { 1258 static char buf[250]; /* DANGEROUS as hell !!!!!! */ 1259 1260 sprintf(buf, s, d1, d2); 1261 return( buf ); 1262 } 1263 1264 void 1265 #ifdef __USE_PROTOS 1266 s_fprT( FILE *f, set e ) 1267 #else 1268 s_fprT( f, e ) 1269 FILE *f; 1270 set e; 1271 #endif 1272 { 1273 register unsigned *p; 1274 unsigned *q; 1275 1276 if ( set_nil(e) ) return; 1277 if ( (q=p=set_pdq(e)) == NULL ) fatal_internal("Can't alloc space for set_pdq"); 1278 fprintf(f, "{"); 1279 while ( *p != nil ) 1280 { 1281 fprintf(f, " %s", TerminalString(*p)); 1282 p++; 1283 } 1284 fprintf(f, " }"); 1285 free((char *)q); 1286 } 1287 1288 /* Return the token name or regular expression for a token number. */ 1289 char * 1290 #ifdef __USE_PROTOS 1291 TerminalString( int token ) 1292 #else 1293 TerminalString( token ) 1294 int token; 1295 #endif 1296 { 1297 int j; 1298 static char imag_name[20]; 1299 1300 /* look in all lexclasses for the token */ 1301 if ( TokenString(token) != NULL ) return TokenString(token); 1302 for (j=0; j<NumLexClasses; j++) 1303 { 1304 lexmode(j); 1305 if ( ExprString(token) != NULL ) return ExprString(token); 1306 } 1307 1308 if (1) { 1309 sprintf(imag_name,"UnknownToken#%d",token); /* MR13 */ 1310 return imag_name; /* MR13 */ 1311 } 1312 1313 require(j<NumLexClasses, eMsgd("No label or expr for token %d",token)); 1314 return "invalid"; 1315 } 1316 1317 /* S i m p l e I n t S t a c k */ 1318 1319 void 1320 #ifdef __USE_PROTOS 1321 pushint( int i ) 1322 #else 1323 pushint( i ) 1324 int i; 1325 #endif 1326 { 1327 require(isp>0, "pushint: stack overflow"); 1328 istack[--isp] = i; 1329 } 1330 1331 int 1332 #ifdef __USE_PROTOS 1333 popint( void ) 1334 #else 1335 popint( ) 1336 #endif 1337 { 1338 require(isp<MAX_INT_STACK, "popint: stack underflow"); 1339 return istack[isp++]; 1340 } 1341 1342 int 1343 #ifdef __USE_PROTOS 1344 istacksize( void ) 1345 #else 1346 istacksize( ) 1347 #endif 1348 { 1349 return MAX_INT_STACK-isp; 1350 } 1351 1352 void 1353 #ifdef __USE_PROTOS 1354 istackreset( void ) 1355 #else 1356 istackreset( ) 1357 #endif 1358 { 1359 isp = MAX_INT_STACK; 1360 } 1361 1362 int 1363 #ifdef __USE_PROTOS 1364 istackempty( void ) 1365 #else 1366 istackempty( ) 1367 #endif 1368 { 1369 return isp==MAX_INT_STACK; 1370 } 1371 1372 int 1373 #ifdef __USE_PROTOS 1374 topint( void ) 1375 #else 1376 topint( ) 1377 #endif 1378 { 1379 require(isp<MAX_INT_STACK, "topint: stack underflow"); 1380 return istack[isp]; 1381 } 1382 1383 void 1384 #ifdef __USE_PROTOS 1385 ProcessArgs( int argc, char **argv, Opt *options ) 1386 #else 1387 ProcessArgs( argc, argv, options ) 1388 int argc; 1389 char **argv; 1390 Opt *options; 1391 #endif 1392 { 1393 Opt *p; 1394 require(argv!=NULL, "ProcessArgs: command line NULL"); 1395 1396 while ( argc-- > 0 ) 1397 { 1398 p = options; 1399 while ( p->option != NULL ) 1400 { 1401 if ( strcmp(p->option, "*") == 0 || 1402 ci_strequ(p->option, *argv) == 1 ) 1403 { 1404 if ( p->arg ) 1405 { 1406 /* MR9 26-Sep-97 Check for argv valid */ 1407 if (argc-- > 0) { 1408 (*p->process)( *argv, *(argv+1) ); 1409 argv++; 1410 } else { 1411 fprintf(stderr,"error: required argument for option %s omitted\n",*argv); 1412 exit(PCCTS_EXIT_FAILURE); 1413 }; 1414 } 1415 else 1416 (*p->process)( *argv ); 1417 break; 1418 } 1419 p++; 1420 } 1421 argv++; 1422 } 1423 } 1424 1425 static void 1426 #ifdef __USE_PROTOS 1427 CompleteContextGuards(void) 1428 #else 1429 CompleteContextGuards() 1430 #endif 1431 { 1432 ListNode * p; 1433 Predicate * pred; 1434 1435 if (ContextGuardPredicateList == NULL) return; 1436 1437 for (p=ContextGuardPredicateList->next; p != NULL; p=p->next) { 1438 pred=(Predicate *)p->elem; 1439 recomputeContextGuard(pred); 1440 } 1441 } 1442 1443 /* Go back into the syntax diagram and compute all meta tokens; i.e. 1444 * turn all '.', ranges, token class refs etc... into actual token sets 1445 */ 1446 static void 1447 #ifdef __USE_PROTOS 1448 CompleteTokenSetRefs(void) 1449 #else 1450 CompleteTokenSetRefs() 1451 #endif 1452 { 1453 ListNode *p; 1454 1455 if ( MetaTokenNodes==NULL ) return; 1456 for (p = MetaTokenNodes->next; p!=NULL; p=p->next) 1457 { 1458 set a,b; 1459 1460 TokNode *q = (TokNode *)p->elem; 1461 if ( q->wild_card ) 1462 { 1463 q->tset = all_tokens; 1464 } 1465 else if ( q->tclass!=NULL ) 1466 { 1467 if ( q->complement ) q->tset = set_dif(all_tokens, q->tclass->tset); 1468 else q->tset = q->tclass->tset; 1469 } 1470 else if ( q->upper_range!=0 ) 1471 { 1472 /* we have a range on our hands: make a set from q->token .. q->upper_range */ 1473 int i; 1474 a = empty; 1475 for (i=q->token; i<=q->upper_range; i++) { set_orel(i, &a); } /* MR13 */ 1476 1477 /* MR13 */ if (q->complement) { 1478 /* MR13 */ q->tset = set_dif(all_tokens, a); 1479 /* MR13 */ set_free(a); 1480 /* MR13 */ } else { 1481 /* MR13 */ q->tset = a; 1482 /* MR13 */ } 1483 1484 } 1485 1486 /* at this point, it can only be a complemented single token */ 1487 else if ( q->complement ) 1488 { 1489 a = set_of(q->token); 1490 b = set_dif(all_tokens, a); 1491 set_free(a); 1492 q->tset=b; 1493 } 1494 else fatal("invalid meta token"); 1495 } 1496 } 1497 1498 /* MR10: Jeff Vincent 1499 MR10: Changed to remove directory information from n only if 1500 MR10: if OutputDirectory was changed by user (-o option) 1501 */ 1502 1503 char * 1504 #ifdef __USE_PROTOS 1505 OutMetaName(char *n) 1506 #else 1507 OutMetaName(n) 1508 char *n; 1509 #endif 1510 { 1511 static char *dir_sym = DirectorySymbol; 1512 static char newname[MaxFileName+1]; 1513 char *p; 1514 1515 /* If OutputDirectory is same as TopDirectory (platform default) then leave n alone. */ 1516 if (strcmp(OutputDirectory, TopDirectory) == 0) /* TopDirectory is "." on Unix. */ 1517 return n; 1518 1519 /* p will point to filename without path information */ 1520 if ((p = strrchr(n, *dir_sym)) != NULL) /* Directory symbol is "/" on Unix. */ 1521 p++; 1522 else 1523 p = n; 1524 1525 /* Copy new output directory into newname[] */ 1526 strcpy(newname, OutputDirectory); 1527 1528 /* if new output directory does not have trailing dir_sym, add it! */ 1529 if (newname[strlen(newname)-1] != *dir_sym) { 1530 strcat(newname, dir_sym); 1531 } 1532 strcat(newname, p); 1533 return newname; 1534 } 1535 1536 char * 1537 #ifdef __USE_PROTOS 1538 pcctsBaseName(char *n) /* MR32 */ 1539 #else 1540 pcctsBaseName(n) 1541 char *n; 1542 #endif 1543 { 1544 static char newname[MaxFileName+1]; 1545 static char* dir_sym = DirectorySymbol; 1546 int count = 0; 1547 char *p; 1548 1549 p = n; 1550 1551 while ( *p != '\0' ) {p++;} /* go to end of string */ 1552 while ( (*p != *dir_sym) && (p != n) ) {--p;} /* Find last DirectorySymbol */ 1553 while ( *p == *dir_sym) p++; /* step forward if we're on a dir symbol */ 1554 while ( *p != '\0' && *p != '.') 1555 { 1556 newname[count++] = *p; 1557 p++; 1558 } /* create a new name */ 1559 newname[count] = '\0'; 1560 return newname; 1561 } 1562 1563 static void 1564 #ifdef __USE_PROTOS 1565 ensure_no_C_file_collisions(char *class_c_file) 1566 #else 1567 ensure_no_C_file_collisions(class_c_file) 1568 char *class_c_file; 1569 #endif 1570 { 1571 int i; 1572 1573 for (i=0; i<NumFiles; i++) 1574 { 1575 1576 #ifdef PCCTS_CASE_INSENSITIVE_FILE_NAME 1577 /* assume that file names are case insensitive */ 1578 if ( STRICMP(outname(FileStr[i]), class_c_file)==0 ) 1579 #else 1580 if ( strcmp(outname(FileStr[i]), class_c_file)==0 ) 1581 #endif 1582 { 1583 fatal(eMsg1("class def output file conflicts with parser output file: %s", 1584 outname(FileStr[i]))); 1585 } 1586 } 1587 } 1588 1589 void 1590 #ifdef __USE_PROTOS 1591 warnNoFL(char *err) 1592 #else 1593 warnNoFL(err) 1594 char *err; 1595 #endif 1596 { 1597 fprintf(stderr, "warning: %s\n", err); 1598 } 1599 1600 void 1601 #ifdef __USE_PROTOS 1602 warnFL(char *err,char *f,int l) 1603 #else 1604 warnFL(err,f,l) 1605 char *f; 1606 int l; 1607 char *err; 1608 #endif 1609 { 1610 fprintf(stderr, ErrHdr, f, l); 1611 fprintf(stderr, " warning: %s\n", err); 1612 } 1613 1614 void 1615 #ifdef __USE_PROTOS 1616 warn(char *err) 1617 #else 1618 warn(err) 1619 char *err; 1620 #endif 1621 { 1622 /* back up the file number if we hit an error at the end of the last file */ 1623 if ( CurFile >= NumFiles && CurFile >= 1 ) CurFile--; 1624 fprintf(stderr, ErrHdr, FileStr[CurFile], zzline); 1625 fprintf(stderr, " warning: %s\n", err); 1626 } 1627 1628 void 1629 #ifdef __USE_PROTOS 1630 warnNoCR( char *err ) 1631 #else 1632 warnNoCR( err ) 1633 char *err; 1634 #endif 1635 { 1636 /* back up the file number if we hit an error at the end of the last file */ 1637 if ( CurFile >= NumFiles && CurFile >= 1 ) CurFile--; 1638 fprintf(stderr, ErrHdr, FileStr[CurFile], zzline); 1639 fprintf(stderr, " warning: %s", err); 1640 } 1641 1642 void 1643 #ifdef __USE_PROTOS 1644 errNoFL(char *err) 1645 #else 1646 errNoFL(err) 1647 char *err; 1648 #endif 1649 { 1650 fprintf(stderr, "error: %s\n", err); 1651 } 1652 1653 void 1654 #ifdef __USE_PROTOS 1655 errFL(char *err,char *f,int l) 1656 #else 1657 errFL(err,f,l) 1658 char *err; 1659 char *f; 1660 int l; 1661 #endif 1662 { 1663 fprintf(stderr, ErrHdr, f, l); 1664 fprintf(stderr, " error: %s\n", err); 1665 } 1666 1667 void 1668 #ifdef __USE_PROTOS 1669 err(char *err) 1670 #else 1671 err(err) 1672 char *err; 1673 #endif 1674 { 1675 /* back up the file number if we hit an error at the end of the last file */ 1676 if ( CurFile >= NumFiles && CurFile >= 1 ) CurFile--; 1677 fprintf(stderr, ErrHdr, FileStr[CurFile], zzline); 1678 fprintf(stderr, " error: %s\n", err); 1679 } 1680 1681 void 1682 #ifdef __USE_PROTOS 1683 errNoCR( char *err ) 1684 #else 1685 errNoCR( err ) 1686 char *err; 1687 #endif 1688 { 1689 /* back up the file number if we hit an error at the end of the last file */ 1690 if ( CurFile >= NumFiles && CurFile >= 1 ) CurFile--; 1691 fprintf(stderr, ErrHdr, FileStr[CurFile], zzline); 1692 fprintf(stderr, " error: %s", err); 1693 } 1694 1695 UserAction * 1696 #ifdef __USE_PROTOS 1697 newUserAction(char *s) 1698 #else 1699 newUserAction(s) 1700 char *s; 1701 #endif 1702 { 1703 UserAction *ua = (UserAction *) calloc(1, sizeof(UserAction)); 1704 require(ua!=NULL, "cannot allocate UserAction"); 1705 1706 ua->action = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char)); 1707 strcpy(ua->action, s); 1708 return ua; 1709 } 1710 1711 /* Added by TJP September 1994 */ 1712 /* Take in file.h and return file_h; names w/o '.'s are left alone */ 1713 char * 1714 #ifdef __USE_PROTOS 1715 gate_symbol(char *name) 1716 #else 1717 gate_symbol(name) 1718 char *name; 1719 #endif 1720 { 1721 static char buf[100]; 1722 char *p; 1723 sprintf(buf, "%s", name); 1724 1725 for (p=buf; *p!='\0'; p++) 1726 { 1727 if ( *p=='.' ) *p = '_'; 1728 } 1729 return buf; 1730 } 1731 1732 char * 1733 #ifdef __USE_PROTOS 1734 makeAltID(int blockid, int altnum) 1735 #else 1736 makeAltID(blockid, altnum) 1737 int blockid; 1738 int altnum; 1739 #endif 1740 { 1741 static char buf[100]; 1742 char *p; 1743 sprintf(buf, "_blk%d_alt%d", blockid, altnum); 1744 p = (char *)malloc(strlen(buf)+1); 1745 strcpy(p, buf); 1746 return p; 1747 } 1748
