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

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

编译器/解释器

开发平台：

Others

lex.c：源码内容
  1. /*
  2.  * lex.c -- Generate all of the lexical type files: parser.dlg tokens.h
  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. #include <ctype.h>
  33. /* MR1                                                 */
  34. /* MR1  10-Apr-97  MR1 Replace use of __STDC__ with __USE_PROTOS     */
  35. /* MR1                                                         */
  36. #include "pcctscfg.h"
  37. #include "set.h"
  38. #include "syn.h"
  39. #include "hash.h"
  40. #include "generic.h"
  42. #define DLGErrorString "invalid token"
  44. /* Generate a complete lexical description of the lexemes found in the grammar */
  45. void
  46. #ifdef __USE_PROTOS
  47. genLexDescr( void )
  48. #else
  49. genLexDescr( )
  50. #endif
  51. {
  52. ListNode *p;
  53. FILE *dlgFile = fopen(OutMetaName(DlgFileName), "w");
  54. require(dlgFile!=NULL, eMsg1("genLexFile: cannot open %s", OutMetaName(DlgFileName)) );
  55. #if SPECIAL_FOPEN
  56. special_fopen_actions(OutMetaName(DlgFileName));              /* MR1 */
  57. #endif
  58. fprintf(dlgFile, "<<n");
  59. fprintf(dlgFile, "/* %s -- DLG Description of scannern", DlgFileName);
  60. fprintf(dlgFile, " *n");
  61. fprintf(dlgFile, " * Generated from:");
  62. {int i; for (i=0; i<NumFiles; i++) fprintf(dlgFile, " %s", FileStr[i]);}
  63. fprintf(dlgFile, "n");
  64. fprintf(dlgFile, " *n");
  65. fprintf(dlgFile, " * Terence Parr, Will Cohen, and Hank Dietz: 1989-1998n");
  66. fprintf(dlgFile, " * Purdue University Electrical Engineeringn");
  67. fprintf(dlgFile, " * With AHPCRC, University of Minnesotan");
  68. fprintf(dlgFile, " * ANTLR Version %sn", Version);
  69. fprintf(dlgFile, " */nn");
  70.     fprintf(dlgFile, "#define ANTLR_VERSION %sn", VersionDef);
  71.     if (FirstAction != NULL ) dumpAction( FirstAction, dlgFile, 0, -1, 0, 1 );  /* MR11 */
  72. if ( GenCC )
  73. {
  74. if ( !UserDefdTokens ) fprintf(dlgFile, "#include "%s"n", DefFileName);
  75. else fprintf(dlgFile, "#include %sn", UserTokenDefsFile);
  76. fprintf(dlgFile, "#include "%s"n", ATOKEN_H);
  77. if ( GenAST ) fprintf(dlgFile, "#include "%s"n", ASTBASE_H);
  78. if ( HdrAction != NULL ) dumpAction( HdrAction, dlgFile, 0, -1, 0, 1 );
  79. }
  80. else
  81. {
  82. fprintf(dlgFile, "#include "pcctscfg.h"n");
  83. fprintf(dlgFile, "#include PCCTS_STDIO_Hn");
  84. if ( strcmp(ParserName, DefaultParserName)!=0 )
  85. fprintf(dlgFile, "#define %s %sn", DefaultParserName, ParserName);
  86. if ( strcmp(ParserName, DefaultParserName)!=0 )
  87. fprintf(dlgFile, "#include "%s"n", RemapFileName);
  88. if ( HdrAction != NULL ) dumpAction( HdrAction, dlgFile, 0, -1, 0, 1 );
  89. if ( FoundGuessBlk )
  90. {
  91. fprintf(dlgFile, "#define ZZCAN_GUESSn");
  92. fprintf(dlgFile, "#include PCCTS_SETJMP_Hn");
  93. }
  94. if ( OutputLL_k > 1 ) fprintf(dlgFile, "#define LL_K %dn", OutputLL_k);
  95. if ( DemandLookahead ) fprintf(dlgFile, "#define DEMAND_LOOKn");
  96. fprintf(dlgFile, "#include "antlr.h"n");
  97. if ( GenAST ) {
  98. fprintf(dlgFile, "#include "ast.h"n");
  99. }
  100. if ( UserDefdTokens )
  101. fprintf(dlgFile, "#include %sn", UserTokenDefsFile);
  102. /* still need this one as it has the func prototypes */
  103. fprintf(dlgFile, "#include "%s"n", DefFileName);
  104. fprintf(dlgFile, "#include "dlgdef.h"n");
  105. fprintf(dlgFile, "LOOKAHEADn");
  106. fprintf(dlgFile, "void zzerraction()n");
  107. fprintf(dlgFile, "{n");
  108. fprintf(dlgFile, "t(*zzerr)("%s");n", DLGErrorString);
  109. fprintf(dlgFile, "tzzadvance();n");
  110. fprintf(dlgFile, "tzzskip();n");
  111. fprintf(dlgFile, "}n");
  112. }
  113. fprintf(dlgFile, ">>nn");
  115. /* dump all actions */
  117. /* MR1                                     */
  118. /* MR1  11-Apr-97 Provide mechanism for inserting code into DLG class     */
  119. /* MR1         via <<%%lexmember ....>> & <<%%lexprefix ...>>            */
  120. /* MR1                      */
  121.           if (LexActions != NULL) {
  122.             for (p = LexActions->next; p!=NULL; p=p->next)
  123. {
  124. /* MR1 */ fprintf(dlgFile, "<<%%%%lexactionn");
  125. dumpAction( (char *)p->elem, dlgFile, 0, -1, 0, 1 );
  126. fprintf(dlgFile, ">>nn");
  127. }
  128.   };
  130. /* MR1 */ if (GenCC) {
  131. /* MR1 */   fprintf(dlgFile,"<<%%%%parserclass %s>>nn",CurrentClassName);
  132. /* MR1 */ };
  134. /* MR1 */ if (LexPrefixActions != NULL) {
  135. /* MR1 */   for (p = LexPrefixActions->next; p!=NULL; p=p->next)
  136. /* MR1 */       {
  137. /* MR1 */               fprintf(dlgFile, "<<%%%%lexprefixn");
  138. /* MR1 */               dumpAction( (char *)p->elem, dlgFile, 0, -1, 0, 1 );
  139. /* MR1 */               fprintf(dlgFile, ">>nn");
  140. /* MR1 */       }
  141. /* MR1 */ };
  143. /* MR1 */ if (LexMemberActions != NULL) {
  144. /* MR1 */   for (p = LexMemberActions->next; p!=NULL; p=p->next)
  145. /* MR1 */       {
  146. /* MR1 */               fprintf(dlgFile, "<<%%%%lexmembern");
  147. /* MR1 */               dumpAction( (char *)p->elem, dlgFile, 0, -1, 0, 1 );
  148. /* MR1 */               fprintf(dlgFile, ">>nn");
  149. /* MR1 */       }
  150. /* MR1 */ };
  152. /* dump all regular expression rules/actions (skip sentinel node) */
  153. if ( ExprOrder == NULL ) {
  154. warnNoFL("no regular expressions found in grammar");
  155. }
  156. else dumpLexClasses(dlgFile);
  157. fprintf(dlgFile, "%%%%n");
  158. fclose( dlgFile );
  159. }
  161. /* For each lexical class, scan ExprOrder looking for expressions
  162.  * in that lexical class.  Print out only those that match.
  163.  * Each element of the ExprOrder list has both an expr and an lclass
  164.  * field.
  165.  */
  166. void
  167. #ifdef __USE_PROTOS
  168. dumpLexClasses( FILE *dlgFile )
  169. #else
  170. dumpLexClasses( dlgFile )
  171. FILE *dlgFile;
  172. #endif
  173. {
  174. int i;
  175. TermEntry *t;
  176. ListNode *p;
  177. Expr *q;
  179. for (i=0; i<NumLexClasses; i++)
  180. {
  181. fprintf(dlgFile, "n%%%%%snn", lclass[i].classnum);
  182. for (p=ExprOrder->next; p!=NULL; p=p->next)
  183. {
  184. q = (Expr *) p->elem;
  185. if ( q->lclass != i ) continue;
  186. lexmode(i);
  187. t = (TermEntry *) hash_get(Texpr, q->expr);
  188. require(t!=NULL, eMsg1("genLexDescr: rexpr %s not in hash table",q->expr) );
  189. if ( t->token == EpToken ) continue;
  190. fprintf(dlgFile, "%snt<<n", StripQuotes(q->expr));
  191. /* replace " killed by StripQuotes() */
  192. q->expr[ strlen(q->expr) ] = '"';
  193. if ( !GenCC ) {
  194. if ( TokenString(t->token) != NULL )
  195. fprintf(dlgFile, "ttNLA = %s;n", TokenString(t->token));
  196. else
  197. fprintf(dlgFile, "ttNLA = %d;n", t->token);
  198. }
  199. if ( t->action != NULL ) dumpAction( t->action, dlgFile, 2,-1,0,1 );
  200. if ( GenCC ) {
  201. if ( TokenString(t->token) != NULL )
  202. fprintf(dlgFile, "ttreturn %s;n", TokenString(t->token));
  203. else
  204. fprintf(dlgFile, "ttreturn (ANTLRTokenType)%d;n", t->token);
  205. }
  206. fprintf(dlgFile, "t>>nn");
  207. }
  208. }
  209. }
  211. /* Strip the leading path (if any) from a filename */
  212. char *
  213. #ifdef __USE_PROTOS
  214. StripPath( char *fileName )
  215. #else
  216. StripPath( fileName )
  217. char *fileName;
  218. #endif
  219. {
  220. char *p;
  221. static char dirSym[2] = DirectorySymbol;
  223. if(NULL != (p = strrchr(fileName, dirSym[0])))
  224. p++;
  225. else
  226. p = fileName;
  228. return(p);
  229. }
  231. /* Generate a list of #defines && list of struct definitions for
  232.  * aggregate retv's */
  233. void
  234. #ifdef __USE_PROTOS
  235. genDefFile( void )
  236. #else
  237. genDefFile( )
  238. #endif
  239. {
  240. int i;
  242. /* If C++ mode and #tokdef used, then don't need anything in here since
  243.  * C++ puts all definitions in the class file name.
  244.  */
  245. if ( GenCC && UserTokenDefsFile ) return;
  246.     if ( MR_Inhibit_Tokens_h_Gen) return;
  248. DefFile = fopen(OutMetaName(DefFileName), "w");
  249. require(DefFile!=NULL, eMsg1("genDefFile: cannot open %s", OutMetaName(DefFileName)) );
  250. #if SPECIAL_FOPEN
  251. special_fopen_actions(OutMetaName(DefFileName));              /* MR1 */
  252. #endif
  253. fprintf(DefFile, "#ifndef %sn", StripPath(gate_symbol(DefFileName)));
  254. fprintf(DefFile, "#define %sn", StripPath(gate_symbol(DefFileName)));
  256. fprintf(DefFile, "/* %s -- List of labelled tokens and stuffn", DefFileName);
  257. fprintf(DefFile, " *n");
  258. fprintf(DefFile, " * Generated from:");
  259. for (i=0; i<NumFiles; i++) fprintf(DefFile, " %s", FileStr[i]);
  260. fprintf(DefFile, "n");
  261. fprintf(DefFile, " *n");
  262. fprintf(DefFile, " * Terence Parr, Will Cohen, and Hank Dietz: 1989-1998n");
  263. fprintf(DefFile, " * Purdue University Electrical Engineeringn");
  264. fprintf(DefFile, " * ANTLR Version %sn", Version);
  265. fprintf(DefFile, " */n");
  267. if ( !GenCC && LexGen ) {
  268. fprintf(DefFile,"#define zzEOF_TOKEN %dn",
  269. TokenInd!=NULL?TokenInd[EofToken]:EofToken);
  270. }
  272. if ( !UserDefdTokens )
  273. {
  274. int first=1;
  276. if ( GenCC ) fprintf(DefFile, "enum ANTLRTokenType {n");
  277. for (i=1; i<TokenNum; i++)
  278. {
  279. /* Don't do EpToken or expr w/o labels */
  280. if ( TokenString(i)!=NULL && i != EpToken )
  281. {
  282. TermEntry *p;
  284. if ( WarningLevel>1 )
  285. {
  286. int j;
  287. /* look in all lexclasses for the reg expr */
  289. /* MR10  Derek Pappas                                                */
  290. /* MR10     A #tokclass doesn't have associated regular expressiones */
  291. /* MR10        so don't warn user about it's omission                */
  293.                     p = (TermEntry *) hash_get(Tname, TokenString(i));
  295.                     if (p != NULL && ! p->classname) {
  296.      for (j=0; j<NumLexClasses; j++)
  297.      {
  298.      lexmode(j);
  299.      if ( ExprString(i)!=NULL ) break;
  300.      }
  301.      if ( j>=NumLexClasses )
  302.      {
  303.      warnNoFL(eMsg1("token label has no associated rexpr: %s",TokenString(i)));
  304.      }
  305.                     };
  306. }
  307. require((p=(TermEntry *)hash_get(Tname, TokenString(i))) != NULL,
  308. "token not in sym tab when it should be");
  309. if ( !p->classname )
  310. {
  311. if ( GenCC ) {
  312. if ( !first ) fprintf(DefFile, ",n");
  313. first = 0;
  314. fprintf(DefFile, "t%s=%d", TokenString(i), i);
  315. }
  316. else
  317. fprintf(DefFile, "#define %s %dn", TokenString(i), i);
  318. }
  319. }
  320. }
  321. /* MR1                                     */
  322. /* MR1  10-Apr-97 133MR1 Prevent use of varying sizes of integer     */
  323. /* MR1 for the enum ANTLRTokenType                             */
  324. /* MR1            */
  325. if ( GenCC ) {                                  /* MR1 */
  326.      if ( !first ) fprintf(DefFile, ",n");                  /* MR14 */
  327.      fprintf(DefFile, "tDLGminToken=0");                    /* MR1 */
  328.      fprintf(DefFile, ",ntDLGmaxToken=9999};n");          /* MR1 */
  329.                 };                              /* MR1 */
  330. }
  332. if ( !GenCC ) GenRulePrototypes(DefFile, SynDiag);
  334. fprintf(DefFile, "n#endifn");
  335. }
  337. void
  338. #ifdef __USE_PROTOS
  339. GenRemapFile( void )
  340. #else
  341. GenRemapFile( )
  342. #endif
  343. {
  344. if ( strcmp(ParserName, DefaultParserName)!=0 )
  345. {
  346. FILE *f;
  347. int i;
  349. f = fopen(OutMetaName(RemapFileName), "w");
  350. require(f!=NULL, eMsg1("GenRemapFile: cannot open %s", OutMetaName(RemapFileName)) );
  351. #ifdef SPECIAL_FOPEN
  352. special_fopen_actions(OutMetaName(RemapFileName));           /* MR1 */
  353. #endif
  354. fprintf(f, "/* %s -- List of symbols to remapn", RemapFileName);
  355. fprintf(f, " *n");
  356. fprintf(f, " * Generated from:");
  357. for (i=0; i<NumFiles; i++) fprintf(f, " %s", FileStr[i]);
  358. fprintf(f, "n");
  359. fprintf(f, " *n");
  360. fprintf(f, " * Terence Parr, Will Cohen, and Hank Dietz: 1989-1998n");
  361. fprintf(f, " * Purdue University Electrical Engineeringn");
  362. fprintf(f, " * ANTLR Version %sn", Version);
  363. fprintf(f, " */n");
  365. GenRuleFuncRedefs(f, SynDiag);
  366. GenPredefinedSymbolRedefs(f);
  367. if ( GenAST ) GenASTSymbolRedefs(f);
  368. GenSetRedefs(f);
  370. fclose(f);
  371. }
  372. }
  374. /* Generate a bunch of #defines that rename all functions to be "ParserName_func" */
  375. void
  376. #ifdef __USE_PROTOS
  377. GenRuleFuncRedefs( FILE *f, Junction *p )
  378. #else
  379. GenRuleFuncRedefs( f, p )
  380. FILE *f;
  381. Junction *p;
  382. #endif
  383. {
  384. fprintf(f, "n/* rename rule functions to be 'ParserName_func' */n");
  385. while ( p!=NULL )
  386. {
  387. fprintf(f, "#define %s %s_%sn", p->rname, ParserName, p->rname);
  388. p = (Junction *)p->p2;
  389. }
  390. }
  392. /* Generate a bunch of #defines that rename all standard symbols to be
  393.  * "ParserName_symbol".  The list of standard symbols to change is in
  394.  * globals.c.
  395.  */
  396. void
  397. #ifdef __USE_PROTOS
  398. GenPredefinedSymbolRedefs( FILE *f )
  399. #else
  400. GenPredefinedSymbolRedefs( f )
  401. FILE *f;
  402. #endif
  403. {
  404. char **p;
  406. fprintf(f, "n/* rename PCCTS-supplied symbols to be 'ParserName_symbol' */n");
  407. for (p = &StandardSymbols[0]; *p!=NULL; p++)
  408. {
  409. fprintf(f, "#define %s %s_%sn", *p, ParserName, *p);
  410. }
  411. }
  413. /* Generate a bunch of #defines that rename all AST symbols to be
  414.  * "ParserName_symbol".  The list of AST symbols to change is in
  415.  * globals.c.
  416.  */
  417. void
  418. #ifdef __USE_PROTOS
  419. GenASTSymbolRedefs( FILE *f )
  420. #else
  421. GenASTSymbolRedefs( f )
  422. FILE *f;
  423. #endif
  424. {
  425. char **p;
  427. fprintf(f, "n/* rename PCCTS-supplied AST symbols to be 'ParserName_symbol' */n");
  428. for (p = &ASTSymbols[0]; *p!=NULL; p++)
  429. {
  430. fprintf(f, "#define %s %s_%sn", *p, ParserName, *p);
  431. }
  432. }
  434. /* redefine all sets generated by ANTLR; WARNING:  'zzerr', 'setwd' must match
  435.  * use in bits.c (DumpSetWd() etc...)
  436.  */
  437. void
  438. #ifdef __USE_PROTOS
  439. GenSetRedefs( FILE *f )
  440. #else
  441. GenSetRedefs( f )
  442. FILE *f;
  443. #endif
  444. {
  445. int i;
  447. for (i=1; i<=wordnum; i++)
  448. {
  449. fprintf(f, "#define setwd%d %s_setwd%dn", i, ParserName, i);
  450. }
  451. for (i=1; i<=esetnum; i++)
  452. {
  453. fprintf(f, "#define zzerr%d %s_err%dn", i, ParserName, i);
  454. }
  455. }
  457. /* Find all return types/parameters that require structs and def
  458.  * all rules with ret types.
  459.  */
  460. void
  461. #ifdef __USE_PROTOS
  462. GenRulePrototypes( FILE *f, Junction *p )
  463. #else
  464. GenRulePrototypes( f, p )
  465. FILE *f;
  466. Junction *p;
  467. #endif
  468. {
  469. int i;
  471. i = 1;
  472. while ( p!=NULL )
  473. {
  474. if ( p->ret != NULL )
  475. {
  476. if ( HasComma(p->ret) )
  477. {
  478. DumpRetValStruct(f, p->ret, i);
  479. }
  480. fprintf(f, "n#ifdef __USE_PROTOSn");
  481. if ( HasComma(p->ret) )
  482. {
  483. fprintf(f, "extern struct _rv%d", i);
  484. }
  485. else
  486. {
  487. fprintf(f, "extern ");
  488. DumpType(p->ret, f);
  489. }
  490. fprintf(f, " %s%s(", RulePrefix, p->rname);
  491. DumpANSIFunctionArgDef(f,p);
  492. fprintf(f, ";n");
  493. #ifdef OLD
  494. if ( p->pdecl != NULL || GenAST )
  495. {
  496. if ( GenAST ) {
  497. fprintf(f, "AST **%s",(p->pdecl!=NULL)?",":"");
  498. }
  499. if ( p->pdecl!=NULL ) fprintf(f, "%s", p->pdecl);
  500. }
  501. else fprintf(f, "void");
  502. fprintf(f, ");n");
  503. #endif
  504. fprintf(f, "#elsen");
  505. if ( HasComma(p->ret) )
  506. {
  507. fprintf(f, "extern struct _rv%d", i);
  508. }
  509. else
  510. {
  511. fprintf(f, "extern ");
  512. DumpType(p->ret, f);
  513. }
  514. fprintf(f, " %s%s();n", RulePrefix, p->rname);
  515. fprintf(f, "#endifn");
  516. }
  517. else
  518. {
  519. fprintf(f, "n#ifdef __USE_PROTOSn");
  520. fprintf(f, "void %s%s(", RulePrefix, p->rname);
  521. DumpANSIFunctionArgDef(f,p);
  522. fprintf(f, ";n");
  523. #ifdef OLD
  524. if ( p->pdecl != NULL || GenAST )
  525. {
  526. if ( GenAST ) {
  527. fprintf(f, "AST **%s",(p->pdecl!=NULL)?",":"");
  528. }
  529. if ( p->pdecl!=NULL ) fprintf(f, "%s", p->pdecl);
  530. }
  531. else fprintf(f, "void");
  532. fprintf(f, ");n");
  533. #endif
  534. fprintf(f, "#elsen");
  535. fprintf(f, "extern void %s%s();n", RulePrefix, p->rname);
  536. fprintf(f, "#endifn");
  537. }
  538. i++;
  539. p = (Junction *)p->p2;
  540. }
  541. }
  543. /* Define all rules in the class.h file; generate any required
  544.  * struct definitions first, however.
  545.  */
  546. void
  547. #ifdef __USE_PROTOS
  548. GenRuleMemberDeclarationsForCC( FILE *f, Junction *q )
  549. #else
  550. GenRuleMemberDeclarationsForCC( f, q )
  551. FILE *f;
  552. Junction *q;
  553. #endif
  554. {
  555. Junction *p = q;
  556. int i;
  558. fprintf(f, "private:n");
  560. /* Dump dflt handler declaration */
  561. fprintf(f, "tvoid zzdflthandlers( int _signal, int *_retsignal );nn");
  563. fprintf(f, "public:n");
  565. /* Dump return value structs */
  566. i = 1;
  567. while ( p!=NULL )
  568. {
  569. if ( p->ret != NULL )
  570. {
  571. if ( HasComma(p->ret) )
  572. {
  573. DumpRetValStruct(f, p->ret, i);
  574. }
  575. }
  576. i++;
  577. p = (Junction *)p->p2;
  578. }
  580. /* Dump member func defs && CONSTRUCTOR */
  581. fprintf(f, "t%s(ANTLRTokenBuffer *input);n", CurrentClassName);
  582. /*
  583. fprintf(f, "t%s(ANTLRTokenBuffer *input, ANTLRTokenType eof);n",
  584.    CurrentClassName);
  585. */
  587. i = 1;
  588. p = q;
  589. while ( p!=NULL )
  590. {
  591. if ( p->ret != NULL )
  592. {
  593. if ( HasComma(p->ret) )
  594. {
  595. fprintf(f, "tstruct _rv%d", i);
  596. }
  597. else
  598. {
  599. fprintf(f, "t");
  600. DumpType(p->ret, f);
  601. }
  602. fprintf(f, " %s%s(",RulePrefix,p->rname);
  603. DumpANSIFunctionArgDef(f,p);
  604. fprintf(f, ";n");
  605. #ifdef OLD
  606. if ( p->pdecl != NULL || GenAST )
  607. {
  608. if ( GenAST ) fprintf(f, "ASTBase **%s",(p->pdecl!=NULL)?",":"");
  609. if ( p->pdecl!=NULL ) fprintf(f, "%s", p->pdecl);
  610. }
  611. fprintf(f, ");n");
  612. #endif
  613. }
  614. else
  615. {
  616. fprintf(f, "tvoid %s%s(",RulePrefix,p->rname);
  617. DumpANSIFunctionArgDef(f,p);
  618. fprintf(f, ";n");
  619. #ifdef OLD
  620. if ( p->pdecl != NULL || GenAST )
  621. {
  622. if ( GenAST ) fprintf(f, "ASTBase **%s",(p->pdecl!=NULL)?",":"");
  623. if ( p->pdecl!=NULL ) fprintf(f, "%s", p->pdecl);
  624. }
  625. fprintf(f, ");n");
  626. #endif
  627. }
  628. i++;
  629. p = (Junction *)p->p2;
  630. }
  631. }
  633. /* Given a list of ANSI-style parameter declarations, print out a
  634.  * comma-separated list of the symbols (w/o types).
  635.  * Basically, we look for a comma, then work backwards until start of
  636.  * the symbol name.  Then print it out until 1st non-alnum char.  Now,
  637.  * move on to next parameter.
  638.  *
  639.  */
  641. /* MR5  Jan Mikkelsen 26-May-97 - added initalComma parameter              */
  642. void
  643. #ifdef __USE_PROTOS
  644. DumpListOfParmNames( char *pdecl, FILE *output, int initialComma )  /* MR5 */
  645. #else
  646. DumpListOfParmNames( pdecl, output, initialComma )     /* MR5 */
  647. char *pdecl;                        /* MR5 */
  648. FILE *output;                             /* MR5 */
  649. int initialComma;                                         /* MR5 */
  650. #endif
  651. {
  652. int firstTime = 1, done = 0;
  653. require(output!=NULL, "DumpListOfParmNames: NULL parm");
  655. if ( pdecl == NULL ) return;
  656. while ( !done )
  657. {
  658. if ( !firstTime || initialComma ) putc(',', output);        /* MR5 */
  659. done = DumpNextNameInDef(&pdecl, output);
  660. firstTime = 0;
  661. }
  662. }
  664. /* given a list of parameters or return values, dump the next
  665.  * name to output.  Return 1 if last one just printed, 0 if more to go.
  666.  */
  667. int
  668. #ifdef __USE_PROTOS
  669. DumpNextNameInDef( char **q, FILE *output )
  670. #else
  671. DumpNextNameInDef( q, output )
  672. char **q;
  673. FILE *output;
  674. #endif
  675. {
  676. char *p = *q; /* where did we leave off? */
  677. int done=0;
  679. while ( *p!='' && *p!=',' ) p++; /* find end of decl */
  680. if ( *p == '' ) done = 1;
  681. while ( !isalnum(*p) && *p!='_' ) --p; /* scan back until valid var character */
  682. while ( isalnum(*p) || *p=='_' ) --p; /* scan back until beginning of variable */
  683. p++; /* move to start of variable */
  684. while ( isalnum(*p) || *p=='_'  ) {putc(*p, output); p++;}
  685. while ( *p!='' && *p!=',' ) p++; /* find end of decl */
  686. p++; /* move past this parameter */
  688. *q = p; /* record where we left off */
  689. return done;
  690. }
  692. /* Given a list of ANSI-style parameter declarations, dump K&R-style
  693.  * declarations, one per line for each parameter.  Basically, convert
  694.  * comma to semi-colon, newline.
  695.  */
  696. void
  697. #ifdef __USE_PROTOS
  698. DumpOldStyleParms( char *pdecl, FILE *output )
  699. #else
  700. DumpOldStyleParms( pdecl, output )
  701. char *pdecl;
  702. FILE *output;
  703. #endif
  704. {
  705. require(output!=NULL, "DumpOldStyleParms: NULL parm");
  707. if ( pdecl == NULL ) return;
  708. while ( *pdecl != '' )
  709. {
  710. if ( *pdecl == ',' )
  711. {
  712. pdecl++;
  713. putc(';', output); putc('n', output);
  714. while ( *pdecl==' ' || *pdecl=='t' || *pdecl=='n' ) pdecl++;
  715. }
  716. else {putc(*pdecl, output); pdecl++;}
  717. }
  718. putc(';', output);
  719. putc('n', output);
  720. }
  722. /* Take in a type definition (type + symbol) and print out type only */
  723. void
  724. #ifdef __USE_PROTOS
  725. DumpType( char *s, FILE *f )
  726. #else
  727. DumpType( s, f )
  728. char *s;
  729. FILE *f;
  730. #endif
  731. {
  732. char *p, *end;
  733. require(s!=NULL, "DumpType: invalid type string");
  735. p = &s[strlen(s)-1]; /* start at end of string and work back */
  737. /* MR11 */
  739. /* scan back until valid variable character */
  740. while ( !isalnum(*p) && *p!='_' ) --p;
  741. /* scan back until beginning of variable */
  742. while ( isalnum(*p) || *p=='_' ) --p;
  743. if ( p<=s )
  744. {
  745. warnNoFL(eMsg1("invalid parameter/return value: '%s'",s));
  746. return;
  747. }
  748. end = p; /* here is where we stop printing alnum */
  749. p = s;
  750. while ( p!=end ) {putc(*p, f); p++;} /* dump until just before variable */
  751. while ( *p!='' )  /* dump rest w/o variable */
  752. {
  753. if ( !isalnum(*p) && *p!='_' ) putc(*p, f);
  754. p++;
  755. }
  756. }
  758. /* check to see if string e is a word in string s */
  759. int
  760. #ifdef __USE_PROTOS
  761. strmember( char *s, char *e )
  762. #else
  763. strmember( s, e )
  764. char *s;
  765. char *e;
  766. #endif
  767. {
  768.     register char *p;
  769.     require(s!=NULL&&e!=NULL, "strmember: NULL string");
  771.     if ( *e=='' ) return 1;   /* empty string is always member */
  772.     do {
  773. while ( *s!='' && !isalnum(*s) && *s!='_' )
  774. ++s;
  775. p = e;
  776. while ( *p!='' && *p==*s ) {p++; s++;}
  777. if ( *p=='' ) {
  778.     if ( *s=='' ) return 1;
  779.     if ( !isalnum (*s) && *s != '_' ) return 1;
  780. }
  781. while ( isalnum(*s) || *s == '_' )
  782. ++s;
  783.     } while ( *s!='' );
  784.     return 0;
  785. }
  787. int
  788. #ifdef __USE_PROTOS
  789. HasComma( char *s )
  790. #else
  791. HasComma( s )
  792. char *s;
  793. #endif
  794. {
  795. while (*s!='')
  796. if ( *s++ == ',' ) return 1;
  797. return 0;
  798. }
  800. void
  801. #ifdef __USE_PROTOS
  802. DumpRetValStruct( FILE *f, char *ret, int i )
  803. #else
  804. DumpRetValStruct( f, ret, i )
  805. FILE *f;
  806. char *ret;
  807. int i;
  808. #endif
  809. {
  810. fprintf(f, "nstruct _rv%d {n", i);
  811. while ( *ret != '' )
  812. {
  813.  while ( *ret==' ' || *ret=='t' ) ret++; /* ignore white */
  814.  putc('t', f);
  815.  while ( *ret!=',' && *ret!='' ) {putc(*ret,f); ret++;}
  816.  if ( *ret == ',' ) {putc(';', f); putc('n', f); ret++;}
  817. }
  818. fprintf(f, ";n};n");
  819. }
  821. /* given "s" yield s -- DESTRUCTIVE (we modify s if starts with " else return s) */
  822. char *
  823. #ifdef __USE_PROTOS
  824. StripQuotes( char *s )
  825. #else
  826. StripQuotes( s )
  827. char *s;
  828. #endif
  829. {
  830. if ( *s == '"' )
  831. {
  832. s[ strlen(s)-1 ] = '';    /* remove last quote */
  833. return( s+1 ); /* return address past initial quote */
  834. }
  835. return( s );
  836. }