BaseTools: Various typo

[mirror_edk2.git] / BaseTools / Source / C / VfrCompile / Pccts / antlr / lex.c

/*\r
 * lex.c	--	Generate all of the lexical type files: parser.dlg tokens.h\r
 *\r
 * SOFTWARE RIGHTS\r
 *\r
 * We reserve no LEGAL rights to the Purdue Compiler Construction Tool\r
 * Set (PCCTS) -- PCCTS is in the public domain.  An individual or\r
 * company may do whatever they wish with source code distributed with\r
 * PCCTS or the code generated by PCCTS, including the incorporation of\r
 * PCCTS, or its output, into commerical software.\r
 *\r
 * We encourage users to develop software with PCCTS.  However, we do ask\r
 * that credit is given to us for developing PCCTS.  By "credit",\r
 * we mean that if you incorporate our source code into one of your\r
 * programs (commercial product, research project, or otherwise) that you\r
 * acknowledge this fact somewhere in the documentation, research report,\r
 * etc...  If you like PCCTS and have developed a nice tool with the\r
 * output, please mention that you developed it using PCCTS.  In\r
 * addition, we ask that this header remain intact in our source code.\r
 * As long as these guidelines are kept, we expect to continue enhancing\r
 * this system and expect to make other tools available as they are\r
 * completed.\r
 *\r
 * ANTLR 1.33\r
 * Terence Parr\r
 * Parr Research Corporation\r
 * with Purdue University and AHPCRC, University of Minnesota\r
 * 1989-2001\r
 */\r
\r
#include <stdio.h>\r
#include <ctype.h>\r
/* MR1						                                                */\r
/* MR1  10-Apr-97  MR1	Replace use of __STDC__ with __USE_PROTOS	    */\r
/* MR1				                                                        */\r
#include "pcctscfg.h"\r
#include "set.h"\r
#include "syn.h"\r
#include "hash.h"\r
#include "generic.h"\r
\r
#define DLGErrorString "invalid token"\r
\r
/* Generate a complete lexical description of the lexemes found in the grammar */\r
void\r
#ifdef __USE_PROTOS\r
genLexDescr( void )\r
#else\r
genLexDescr( )\r
#endif\r
{\r
	ListNode *p;\r
	FILE *dlgFile = fopen(OutMetaName(DlgFileName), "w");\r
	require(dlgFile!=NULL, eMsg1("genLexFile: cannot open %s", OutMetaName(DlgFileName)) );\r
#ifdef SPECIAL_FOPEN\r
	special_fopen_actions(OutMetaName(DlgFileName));	             /* MR1 */\r
#endif\r
	fprintf(dlgFile, "<<\n");\r
	fprintf(dlgFile, "/* %s -- DLG Description of scanner\n", DlgFileName);\r
	fprintf(dlgFile, " *\n");\r
	fprintf(dlgFile, " * Generated from:");\r
	{int i; for (i=0; i<NumFiles; i++) fprintf(dlgFile, " %s", FileStr[i]);}\r
	fprintf(dlgFile, "\n");\r
	fprintf(dlgFile, " *\n");\r
	fprintf(dlgFile, " * Terence Parr, Will Cohen, and Hank Dietz: 1989-2001\n");\r
	fprintf(dlgFile, " * Purdue University Electrical Engineering\n");\r
	fprintf(dlgFile, " * With AHPCRC, University of Minnesota\n");\r
	fprintf(dlgFile, " * ANTLR Version %s\n", Version);\r
	fprintf(dlgFile, " */\n\n");\r
    if (FirstAction != NULL ) dumpAction( FirstAction, dlgFile, 0, -1, 0, 1 );  /* MR11 MR15b */\r
    fprintf(dlgFile, "#define ANTLR_VERSION	%s\n", VersionDef);\r
	if ( GenCC )\r
	{\r
		if ( !UserDefdTokens ) fprintf(dlgFile, "#include \"%s\"\n", DefFileName);\r
		else fprintf(dlgFile, "#include %s\n", UserTokenDefsFile);\r
		fprintf(dlgFile, "#include \"%s\"\n", ATOKEN_H);\r
		if ( GenAST ) fprintf(dlgFile, "#include \"%s\"\n", ASTBASE_H);\r
		if ( HdrAction != NULL ) dumpAction( HdrAction, dlgFile, 0, -1, 0, 1 );\r
	}\r
	else\r
	{\r
		fprintf(dlgFile, "#include \"pcctscfg.h\"\n");\r
		fprintf(dlgFile, "#include \"pccts_stdio.h\"\n");\r
		if ( strcmp(ParserName, DefaultParserName)!=0 )\r
			fprintf(dlgFile, "#define %s %s\n", DefaultParserName, ParserName);\r
		if ( strcmp(ParserName, DefaultParserName)!=0 )\r
			fprintf(dlgFile, "#include \"%s\"\n", RemapFileName);\r
		if ( HdrAction != NULL ) dumpAction( HdrAction, dlgFile, 0, -1, 0, 1 );\r
		if ( FoundGuessBlk )\r
		{\r
			fprintf(dlgFile, "#define ZZCAN_GUESS\n");\r
			fprintf(dlgFile, "#include \"pccts_setjmp.h\"\n");\r
		}\r
		if ( OutputLL_k > 1 ) fprintf(dlgFile, "#define LL_K %d\n", OutputLL_k);\r
		if ( DemandLookahead ) fprintf(dlgFile, "#define DEMAND_LOOK\n");\r
        if (TraceGen) {\r
          fprintf(dlgFile,"#ifndef zzTRACE_RULES\n");  /* MR20 */\r
          fprintf(dlgFile,"#define zzTRACE_RULES\n");  /* MR20 */\r
          fprintf(dlgFile,"#endif\n");  /* MR22 */\r
        };\r
		fprintf(dlgFile, "#include \"antlr.h\"\n");\r
		if ( GenAST ) {\r
			fprintf(dlgFile, "#include \"ast.h\"\n");\r
		}\r
		if ( UserDefdTokens )\r
			fprintf(dlgFile, "#include %s\n", UserTokenDefsFile);\r
		/* still need this one as it has the func prototypes */\r
		fprintf(dlgFile, "#include \"%s\"\n", DefFileName);\r
		fprintf(dlgFile, "#include \"dlgdef.h\"\n");\r
		fprintf(dlgFile, "LOOKAHEAD\n");\r
		fprintf(dlgFile, "\n");\r
		fprintf(dlgFile, "void\n");\r
		fprintf(dlgFile, "#ifdef __USE_PROTOS\n");\r
		fprintf(dlgFile, "zzerraction(void)\n");\r
		fprintf(dlgFile, "#else\n");\r
		fprintf(dlgFile, "zzerraction()\n");\r
		fprintf(dlgFile, "#endif\n");\r
		fprintf(dlgFile, "{\n");\r
		fprintf(dlgFile, "\t(*zzerr)(\"%s\");\n", DLGErrorString);\r
		fprintf(dlgFile, "\tzzadvance();\n");\r
		fprintf(dlgFile, "\tzzskip();\n");\r
		fprintf(dlgFile, "}\n");\r
	}\r
	fprintf(dlgFile, ">>\n\n");\r
\r
	/* dump all actions */\r
\r
/* MR1									                                    */\r
/* MR1  11-Apr-97	Provide mechanism for inserting code into DLG class     */\r
/* MR1	 	   	  via <<%%lexmember ....>> & <<%%lexprefix ...>>            */\r
/* MR1				                					    */\r
          if (LexActions != NULL) {\r
            for (p = LexActions->next; p!=NULL; p=p->next)\r
		{\r
/* MR1 */	fprintf(dlgFile, "<<%%%%lexaction\n");\r
			dumpAction( (char *)p->elem, dlgFile, 0, -1, 0, 1 );\r
			fprintf(dlgFile, ">>\n\n");\r
		}\r
	  };\r
\r
/* MR1 */ if (GenCC) {\r
/* MR1 */   fprintf(dlgFile,"<<%%%%parserclass %s>>\n\n",CurrentClassName);\r
/* MR1 */ };\r
\r
/* MR1 */ if (LexPrefixActions != NULL) {\r
/* MR1 */   for (p = LexPrefixActions->next; p!=NULL; p=p->next)\r
/* MR1 */       {\r
/* MR1 */               fprintf(dlgFile, "<<%%%%lexprefix\n");\r
/* MR1 */               dumpAction( (char *)p->elem, dlgFile, 0, -1, 0, 1 );\r
/* MR1 */               fprintf(dlgFile, ">>\n\n");\r
/* MR1 */       }\r
/* MR1 */ };\r
\r
/* MR1 */ if (LexMemberActions != NULL) {\r
/* MR1 */   for (p = LexMemberActions->next; p!=NULL; p=p->next)\r
/* MR1 */       {\r
/* MR1 */               fprintf(dlgFile, "<<%%%%lexmember\n");\r
/* MR1 */               dumpAction( (char *)p->elem, dlgFile, 0, -1, 0, 1 );\r
/* MR1 */               fprintf(dlgFile, ">>\n\n");\r
/* MR1 */       }\r
/* MR1 */ };\r
\r
	/* dump all regular expression rules/actions (skip sentinel node) */\r
	if ( ExprOrder == NULL ) {\r
		warnNoFL("no regular expressions found in grammar");\r
	}\r
	else dumpLexClasses(dlgFile);\r
	fprintf(dlgFile, "%%%%\n");\r
	fclose( dlgFile );\r
}\r
\r
/* For each lexical class, scan ExprOrder looking for expressions\r
 * in that lexical class.  Print out only those that match.\r
 * Each element of the ExprOrder list has both an expr and an lclass\r
 * field.\r
 */\r
void\r
#ifdef __USE_PROTOS\r
dumpLexClasses( FILE *dlgFile )\r
#else\r
dumpLexClasses( dlgFile )\r
FILE *dlgFile;\r
#endif\r
{\r
	int i;\r
	TermEntry *t;\r
	ListNode *p;\r
	Expr *q;\r
\r
	for (i=0; i<NumLexClasses; i++)\r
	{\r
		fprintf(dlgFile, "\n%%%%%s\n\n", lclass[i].classnum);\r
		for (p=ExprOrder->next; p!=NULL; p=p->next)\r
		{\r
			q = (Expr *) p->elem;\r
			if ( q->lclass != i ) continue;\r
			lexmode(i);\r
			t = (TermEntry *) hash_get(Texpr, q->expr);\r
			require(t!=NULL, eMsg1("genLexDescr: rexpr %s not in hash table",q->expr) );\r
			if ( t->token == EpToken ) continue;\r
			fprintf(dlgFile, "%s\n\t<<\n", StripQuotes(q->expr));\r
			/* replace " killed by StripQuotes() */\r
			q->expr[ strlen(q->expr) ] = '"';\r
			if ( !GenCC ) {\r
				if ( TokenString(t->token) != NULL )\r
					fprintf(dlgFile, "\t\tNLA = %s;\n", TokenString(t->token));\r
				else\r
					fprintf(dlgFile, "\t\tNLA = %d;\n", t->token);\r
			}\r
			if ( t->action != NULL ) dumpAction( t->action, dlgFile, 2,-1,0,1 );\r
			if ( GenCC ) {\r
				if ( TokenString(t->token) != NULL )\r
					fprintf(dlgFile, "\t\treturn %s;\n", TokenString(t->token));\r
				else\r
					fprintf(dlgFile, "\t\treturn (ANTLRTokenType)%d;\n", t->token);\r
			}\r
			fprintf(dlgFile, "\t>>\n\n");\r
		}\r
	}\r
}\r
\r
/* Strip the leading path (if any) from a filename */\r
char *\r
#ifdef __USE_PROTOS\r
StripPath( char *fileName )\r
#else\r
StripPath( fileName )\r
char *fileName;\r
#endif\r
{\r
	char *p;\r
	static char dirSym[2] = DirectorySymbol;\r
\r
	if(NULL != (p = strrchr(fileName, dirSym[0])))\r
		p++;\r
	else\r
		p = fileName;\r
\r
	return(p);\r
}\r
\r
/* Generate a list of #defines && list of struct definitions for\r
 * aggregate retv's */\r
void\r
#ifdef __USE_PROTOS\r
genDefFile( void )\r
#else\r
genDefFile( )\r
#endif\r
{\r
	int i;\r
\r
	/* If C++ mode and #tokdef used, then don't need anything in here since\r
	 * C++ puts all definitions in the class file name.\r
	 */\r
	if ( GenCC && UserTokenDefsFile ) return;\r
    if ( MR_Inhibit_Tokens_h_Gen) return;\r
\r
	DefFile = fopen(OutMetaName(DefFileName), "w");\r
	require(DefFile!=NULL, eMsg1("genDefFile: cannot open %s", OutMetaName(DefFileName)) );\r
#ifdef SPECIAL_FOPEN\r
	special_fopen_actions(OutMetaName(DefFileName));	             /* MR1 */\r
#endif\r
	fprintf(DefFile, "#ifndef %s\n", StripPath(gate_symbol(DefFileName)));\r
	fprintf(DefFile, "#define %s\n", StripPath(gate_symbol(DefFileName)));\r
\r
	fprintf(DefFile, "/* %s -- List of labelled tokens and stuff\n", DefFileName);\r
	fprintf(DefFile, " *\n");\r
	fprintf(DefFile, " * Generated from:");\r
	for (i=0; i<NumFiles; i++) fprintf(DefFile, " %s", FileStr[i]);\r
	fprintf(DefFile, "\n");\r
	fprintf(DefFile, " *\n");\r
	fprintf(DefFile, " * Terence Parr, Will Cohen, and Hank Dietz: 1989-2001\n");\r
	fprintf(DefFile, " * Purdue University Electrical Engineering\n");\r
	fprintf(DefFile, " * ANTLR Version %s\n", Version);\r
	fprintf(DefFile, " */\n");\r
\r
	if ( !GenCC && LexGen ) {\r
		fprintf(DefFile,"#define zzEOF_TOKEN %d\n",\r
				TokenInd!=NULL?TokenInd[EofToken]:EofToken);\r
	}\r
\r
	if ( !UserDefdTokens )\r
	{\r
		int first=1;\r
\r
		if ( GenCC ) fprintf(DefFile, "enum ANTLRTokenType {\n");\r
		for (i=1; i<TokenNum; i++)\r
		{\r
			/* Don't do EpToken or expr w/o labels */\r
			if ( TokenString(i)!=NULL && i != EpToken )\r
			{\r
				TermEntry *p;\r
				\r
				if ( WarningLevel>1 )\r
				{\r
					int j;\r
					/* look in all lexclasses for the reg expr */\r
\r
/* MR10  Derek Pappas                                                */\r
/* MR10     A #tokclass doesn't have associated regular expressiones */\r
/* MR10        so don't warn user about it's omission                */\r
\r
                    p = (TermEntry *) hash_get(Tname, TokenString(i));\r
\r
                    if (p != NULL && ! p->classname) {\r
    					for (j=0; j<NumLexClasses; j++)\r
    					{\r
    						lexmode(j);\r
    						if ( ExprString(i)!=NULL ) break;\r
    					}\r
    					if ( j>=NumLexClasses )\r
    					{\r
    						warnNoFL(eMsg1("token label has no associated rexpr: %s",TokenString(i)));\r
    					}\r
                    };\r
				}\r
				require((p=(TermEntry *)hash_get(Tname, TokenString(i))) != NULL,\r
						"token not in sym tab when it should be");\r
				if ( !p->classname )\r
				{\r
					if ( GenCC ) {\r
						if ( !first ) fprintf(DefFile, ",\n");\r
						first = 0;\r
						fprintf(DefFile, "\t%s=%d", TokenString(i), i);\r
					}\r
					else\r
						fprintf(DefFile, "#define %s %d\n", TokenString(i), i);\r
				}\r
			}\r
		}\r
/* MR1									                                    */\r
/* MR1  10-Apr-97 133MR1	Prevent use of varying sizes of integer	    */\r
/* MR1				for the enum ANTLRTokenType                             */\r
/* MR1								           */\r
		if ( GenCC ) {				                                 /* MR1 */\r
 		 	 if ( !first ) fprintf(DefFile, ",\n");                  /* MR14 */\r
		     fprintf(DefFile, "\tDLGminToken=0");                 /* MR1 */\r
		     fprintf(DefFile, ",\n\tDLGmaxToken=9999};\n");          /* MR1 */\r
                };						                             /* MR1 */\r
	}\r
\r
	if ( !GenCC ) GenRulePrototypes(DefFile, SynDiag);\r
\r
	fprintf(DefFile, "\n#endif\n");\r
}\r
\r
void\r
#ifdef __USE_PROTOS\r
GenRemapFile( void )\r
#else\r
GenRemapFile( )\r
#endif\r
{\r
	if ( strcmp(ParserName, DefaultParserName)!=0 )\r
	{\r
		FILE *f;\r
		int i;\r
\r
		f = fopen(OutMetaName(RemapFileName), "w");\r
		require(f!=NULL, eMsg1("GenRemapFile: cannot open %s", OutMetaName(RemapFileName)) );\r
#ifdef SPECIAL_FOPEN\r
		special_fopen_actions(OutMetaName(RemapFileName));           /* MR1 */\r
#endif\r
		fprintf(f, "/* %s -- List of symbols to remap\n", RemapFileName);\r
		fprintf(f, " *\n");\r
		fprintf(f, " * Generated from:");\r
		for (i=0; i<NumFiles; i++) fprintf(f, " %s", FileStr[i]);\r
		fprintf(f, "\n");\r
		fprintf(f, " *\n");\r
		fprintf(f, " * Terence Parr, Will Cohen, and Hank Dietz: 1989-2001\n");\r
		fprintf(f, " * Purdue University Electrical Engineering\n");\r
		fprintf(f, " * ANTLR Version %s\n", Version);\r
		fprintf(f, " */\n");\r
\r
		GenRuleFuncRedefs(f, SynDiag);\r
		GenPredefinedSymbolRedefs(f);\r
		if ( GenAST ) GenASTSymbolRedefs(f);\r
		GenSetRedefs(f);\r
\r
		fclose(f);\r
	}\r
}\r
\r
/* Generate a bunch of #defines that rename all functions to be "ParserName_func" */\r
void\r
#ifdef __USE_PROTOS\r
GenRuleFuncRedefs( FILE *f, Junction *p )\r
#else\r
GenRuleFuncRedefs( f, p )\r
FILE *f;\r
Junction *p;\r
#endif\r
{\r
	fprintf(f, "\n/* rename rule functions to be 'ParserName_func' */\n");\r
	while ( p!=NULL )\r
	{\r
		fprintf(f, "#define %s %s_%s\n", p->rname, ParserName, p->rname);\r
		p = (Junction *)p->p2;\r
	}\r
}\r
\r
/* Generate a bunch of #defines that rename all standard symbols to be\r
 * "ParserName_symbol".  The list of standard symbols to change is in\r
 * globals.c.\r
 */\r
void\r
#ifdef __USE_PROTOS\r
GenPredefinedSymbolRedefs( FILE *f )\r
#else\r
GenPredefinedSymbolRedefs( f )\r
FILE *f;\r
#endif\r
{\r
	char **p;\r
\r
	fprintf(f, "\n/* rename PCCTS-supplied symbols to be 'ParserName_symbol' */\n");\r
	for (p = &StandardSymbols[0]; *p!=NULL; p++)\r
	{\r
		fprintf(f, "#define %s %s_%s\n", *p, ParserName, *p);\r
	}\r
}\r
\r
/* Generate a bunch of #defines that rename all AST symbols to be\r
 * "ParserName_symbol".  The list of AST symbols to change is in\r
 * globals.c.\r
 */\r
void\r
#ifdef __USE_PROTOS\r
GenASTSymbolRedefs( FILE *f )\r
#else\r
GenASTSymbolRedefs( f )\r
FILE *f;\r
#endif\r
{\r
	char **p;\r
\r
	fprintf(f, "\n/* rename PCCTS-supplied AST symbols to be 'ParserName_symbol' */\n");\r
	for (p = &ASTSymbols[0]; *p!=NULL; p++)\r
	{\r
		fprintf(f, "#define %s %s_%s\n", *p, ParserName, *p);\r
	}\r
}\r
\r
/* redefine all sets generated by ANTLR; WARNING:  'zzerr', 'setwd' must match\r
 * use in bits.c (DumpSetWd() etc...)\r
 */\r
void\r
#ifdef __USE_PROTOS\r
GenSetRedefs( FILE *f )\r
#else\r
GenSetRedefs( f )\r
FILE *f;\r
#endif\r
{\r
	int i;\r
\r
	for (i=1; i<=wordnum; i++)\r
	{\r
		fprintf(f, "#define setwd%d %s_setwd%d\n", i, ParserName, i);\r
	}\r
	for (i=1; i<=esetnum; i++)\r
	{\r
		fprintf(f, "#define zzerr%d %s_err%d\n", i, ParserName, i);\r
	}\r
}\r
\r
/* Find all return types/parameters that require structs and def\r
 * all rules with ret types.\r
 *\r
 * This is for the declaration, not the definition.\r
 */\r
void\r
#ifdef __USE_PROTOS\r
GenRulePrototypes( FILE *f, Junction *p )\r
#else\r
GenRulePrototypes( f, p )\r
FILE *f;\r
Junction *p;\r
#endif\r
{\r
	int i;\r
\r
	i = 1;\r
	while ( p!=NULL )\r
	{\r
		if ( p->ret != NULL )\r
		{\r
/* MR23 */	if ( hasMultipleOperands(p->ret) )\r
			{\r
				DumpRetValStruct(f, p->ret, i);\r
			}\r
			fprintf(f, "\n#ifdef __USE_PROTOS\n");\r
/* MR23 */	if ( hasMultipleOperands(p->ret) ) \r
			{\r
				fprintf(f, "extern struct _rv%d", i);\r
			}\r
			else\r
			{\r
				fprintf(f, "extern ");\r
				DumpType(p->ret, f);\r
			}\r
			fprintf(f, " %s%s(", RulePrefix, p->rname);\r
			DumpANSIFunctionArgDef(f,p,1 /* emit initializers ? */);\r
			fprintf(f, ";\n");\r
			fprintf(f, "#else\n");\r
/* MR23 */	if ( hasMultipleOperands(p->ret) )\r
			{\r
				fprintf(f, "extern struct _rv%d", i);\r
			}\r
			else\r
			{\r
				fprintf(f, "extern ");\r
				DumpType(p->ret, f);\r
			}\r
			fprintf(f, " %s%s();\n", RulePrefix, p->rname);\r
			fprintf(f, "#endif\n");\r
		}\r
		else\r
		{\r
			fprintf(f, "\n#ifdef __USE_PROTOS\n");\r
			fprintf(f, "void %s%s(", RulePrefix, p->rname);\r
			DumpANSIFunctionArgDef(f,p, 1 /* emit initializers ? */ );\r
			fprintf(f, ";\n");\r
#ifdef OLD\r
			if ( p->pdecl != NULL || GenAST )\r
			{\r
				if ( GenAST ) {\r
					fprintf(f, "AST **%s",(p->pdecl!=NULL)?",":"");\r
				}\r
				if ( p->pdecl!=NULL ) fprintf(f, "%s", p->pdecl);\r
			}\r
			else fprintf(f, "void");\r
			fprintf(f, ");\n");\r
#endif\r
			fprintf(f, "#else\n");\r
			fprintf(f, "extern void %s%s();\n", RulePrefix, p->rname);\r
			fprintf(f, "#endif\n");\r
		}\r
		i++;\r
		p = (Junction *)p->p2;\r
	}\r
}\r
\r
/* Define all rules in the class.h file; generate any required\r
 * struct definitions first, however.\r
 */\r
void\r
#ifdef __USE_PROTOS\r
GenRuleMemberDeclarationsForCC( FILE *f, Junction *q )\r
#else\r
GenRuleMemberDeclarationsForCC( f, q )\r
FILE *f;\r
Junction *q;\r
#endif\r
{\r
	Junction *p = q;\r
	int i;\r
\r
	fprintf(f, "private:\n");\r
\r
	/* Dump dflt handler declaration */\r
	fprintf(f, "\tvoid zzdflthandlers( int _signal, int *_retsignal );\n\n");\r
\r
	fprintf(f, "public:\n");\r
\r
	/* Dump return value structs */\r
	i = 1;\r
	while ( p!=NULL )\r
	{\r
		if ( p->ret != NULL )\r
		{\r
/* MR23 */	if ( hasMultipleOperands(p->ret) )\r
			{\r
				DumpRetValStruct(f, p->ret, i);\r
			}\r
		}\r
		i++;\r
		p = (Junction *)p->p2;\r
	}\r
\r
	/* Dump member func defs && CONSTRUCTOR */\r
	fprintf(f, "\t%s(ANTLRTokenBuffer *input);\n", CurrentClassName);\r
/*\r
	fprintf(f, "\t%s(ANTLRTokenBuffer *input, ANTLRTokenType eof);\n",\r
			   CurrentClassName);\r
*/\r
\r
	i = 1;\r
	p = q;\r
	while ( p!=NULL )\r
	{\r
		if ( p->ret != NULL )\r
		{\r
/* MR23 */	if ( hasMultipleOperands(p->ret) )\r
			{\r
				fprintf(f, "\tstruct _rv%d", i);\r
			}\r
			else\r
			{\r
				fprintf(f, "\t");\r
				DumpType(p->ret, f);\r
			}\r
			fprintf(f, " %s%s(",RulePrefix,p->rname);\r
			DumpANSIFunctionArgDef(f,p, 1 /* emit initializers ? */ );\r
			fprintf(f, ";\n");\r
#ifdef OLD\r
			if ( p->pdecl != NULL || GenAST )\r
			{\r
				if ( GenAST ) fprintf(f, "ASTBase **%s",(p->pdecl!=NULL)?",":"");\r
				if ( p->pdecl!=NULL ) fprintf(f, "%s", p->pdecl);\r
			}\r
			fprintf(f, ");\n");\r
#endif\r
		}\r
		else\r
		{\r
			fprintf(f, "\tvoid %s%s(",RulePrefix,p->rname);\r
			DumpANSIFunctionArgDef(f,p, 1 /* emit initializers ? */);\r
			fprintf(f, ";\n");\r
#ifdef OLD\r
			if ( p->pdecl != NULL || GenAST )\r
			{\r
				if ( GenAST ) fprintf(f, "ASTBase **%s",(p->pdecl!=NULL)?",":"");\r
				if ( p->pdecl!=NULL ) fprintf(f, "%s", p->pdecl);\r
			}\r
			fprintf(f, ");\n");\r
#endif\r
		}\r
		i++;\r
		p = (Junction *)p->p2;\r
	}\r
}\r
\r
/* Given a list of ANSI-style parameter declarations, print out a\r
 * comma-separated list of the symbols (w/o types).\r
 * Basically, we look for a comma, then work backwards until start of\r
 * the symbol name.  Then print it out until 1st non-alnum char.  Now,\r
 * move on to next parameter.\r
 *\r
 */\r
\r
/* MR5 	Jan Mikkelsen 26-May-97 - added initialComma parameter              */\r
\r
void\r
#ifdef __USE_PROTOS\r
DumpListOfParmNames(char *pdecl, FILE *output, int initialComma)    /* MR5 */\r
#else\r
DumpListOfParmNames(pdecl, output, initialComma)		            /* MR5 */\r
char *pdecl;	             		 			  	                /* MR5 */\r
FILE *output;							                            /* MR5 */\r
int initialComma;			                                        /* MR5 */\r
#endif\r
{\r
	int firstTime = 1, done = 0;\r
	require(output!=NULL, "DumpListOfParmNames: NULL parm");\r
\r
	if ( pdecl == NULL ) return;\r
	while ( !done )\r
	{\r
		if ( !firstTime || initialComma ) putc(',', output);        /* MR5 */\r
		done = DumpNextNameInDef(&pdecl, output);\r
		firstTime = 0;\r
	}\r
}\r
\r
/* given a list of parameters or return values, dump the next\r
 * name to output.  Return 1 if last one just printed, 0 if more to go.\r
 */\r
\r
/* MR23 Total rewrite */\r
\r
int\r
#ifdef __USE_PROTOS\r
DumpNextNameInDef( char **q, FILE *output )\r
#else\r
DumpNextNameInDef( q, output )\r
char **q;\r
FILE *output;\r
#endif\r
{\r
	char *p;\r
	char *t;\r
	char *pDataType;\r
	char *pSymbol;\r
	char *pEqualSign;\r
	char *pValue;\r
	char *pSeparator;\r
	int nest = 0;\r
\r
	p = endFormal(*q,\r
			      &pDataType,\r
				  &pSymbol,\r
				  &pEqualSign,\r
				  &pValue,\r
				  &pSeparator,\r
				  &nest);\r
\r
    /* MR26 Handle rule arguments such as: IIR_Bool (IIR_Decl::*constraint)()\r
       For this we need to strip off anything which follows the symbol.\r
     */\r
\r
/* MR26 */  t = pSymbol;\r
/* MR26 */	if (t != NULL) {\r
/* MR26 */		for (t = pSymbol; *t != 0; t++) {\r
/* MR26 */			if (! (isalpha(*t) || isdigit(*t) || *t == '_' || *t == '$')) break;\r
/* MR26 */		}\r
/* MR26 */	}\r
/* MR26 */	fprintf(output, "%s", strBetween(pSymbol, t, pSeparator));\r
\r
    *q = p;\r
    return (*pSeparator  == 0);\r
}\r
\r
/* Given a list of ANSI-style parameter declarations, dump K&R-style\r
 * declarations, one per line for each parameter.  Basically, convert\r
 * comma to semi-colon, newline.\r
 */\r
void\r
#ifdef __USE_PROTOS\r
DumpOldStyleParms( char *pdecl, FILE *output )\r
#else\r
DumpOldStyleParms( pdecl, output )\r
char *pdecl;\r
FILE *output;\r
#endif\r
{\r
	require(output!=NULL, "DumpOldStyleParms: NULL parm");\r
\r
	if ( pdecl == NULL ) return;\r
	while ( *pdecl != '\0' )\r
	{\r
		if ( *pdecl == ',' )\r
		{\r
			pdecl++;\r
			putc(';', output); putc('\n', output);\r
			while ( *pdecl==' ' || *pdecl=='\t' || *pdecl=='\n' ) pdecl++;\r
		}\r
		else {putc(*pdecl, output); pdecl++;}\r
	}\r
	putc(';', output);\r
	putc('\n', output);\r
}\r
\r
/* Take in a type definition (type + symbol) and print out type only */\r
/* MR23 Total rewrite */\r
\r
void\r
#ifdef __USE_PROTOS\r
DumpType( char *s, FILE *f )\r
#else\r
DumpType( s, f )\r
char *s;\r
FILE *f;\r
#endif\r
{\r
	char *p;\r
	char *pDataType;\r
	char *pSymbol;\r
	char *pEqualSign;\r
	char *pValue;\r
	char *pSeparator;\r
	int nest = 0;\r
\r
	require(s!=NULL, "DumpType: invalid type string"); \r
\r
	p = endFormal(s,\r
			      &pDataType,\r
				  &pSymbol,\r
				  &pEqualSign,\r
				  &pValue,\r
				  &pSeparator,\r
				  &nest);\r
	fprintf(f, "%s", strBetween(pDataType, pSymbol, pSeparator));\r
}\r
\r
/* check to see if string e is a word in string s */\r
int\r
#ifdef __USE_PROTOS\r
strmember( char *s, char *e )\r
#else\r
strmember( s, e )\r
char *s;\r
char *e;\r
#endif\r
{\r
    register char *p;\r
    require(s!=NULL&&e!=NULL, "strmember: NULL string");\r
\r
    if ( *e=='\0' ) return 1;   /* empty string is always member */\r
    do {\r
	while ( *s!='\0' && !isalnum(*s) && *s!='_' )\r
	++s;\r
	p = e;\r
	while ( *p!='\0' && *p==*s ) {p++; s++;}\r
	if ( *p=='\0' ) {\r
	    if ( *s=='\0' ) return 1;\r
	    if ( !isalnum (*s) && *s != '_' ) return 1;\r
	}\r
	while ( isalnum(*s) || *s == '_' )\r
	++s;\r
    } while ( *s!='\0' );\r
    return 0;\r
}\r
\r
#if 0\r
\r
/* MR23 Replaced by hasMultipleOperands() */\r
\r
int\r
#ifdef __USE_PROTOS\r
HasComma( char *s )\r
#else\r
HasComma( s )\r
char *s;\r
#endif\r
{\r
	while (*s!='\0')\r
		if ( *s++ == ',' ) return 1;\r
	return 0;\r
}\r
#endif\r
\r
\r
/* MR23 Total rewrite */\r
\r
void\r
#ifdef __USE_PROTOS\r
DumpRetValStruct( FILE *f, char *ret, int i )\r
#else\r
DumpRetValStruct( f, ret, i )\r
FILE *f;\r
char *ret;\r
int i;\r
#endif\r
{\r
	char *p = ret;\r
	char *pDataType;\r
	char *pSymbol;\r
	char *pEqualSign;\r
	char *pValue;\r
	char *pSeparator;\r
    int nest = 0;\r
\r
	fprintf(f, "\nstruct _rv%d {\n", i);\r
	while (*p != 0 && nest == 0) {\r
		p = endFormal(p,\r
			          &pDataType,\r
					  &pSymbol,\r
					  &pEqualSign,\r
					  &pValue,\r
					  &pSeparator,\r
					  &nest);\r
		fprintf(f,"\t");\r
		fprintf(f, "%s", strBetween(pDataType, pSymbol, pSeparator));\r
		fprintf(f," ");\r
		fprintf(f, "%s", strBetween(pSymbol, pEqualSign, pSeparator));\r
		fprintf(f,";\n");\r
    }\r
	fprintf(f,"};\n");\r
}\r
\r
/* given "s" yield s -- DESTRUCTIVE (we modify s if starts with " else return s) */\r
char *\r
#ifdef __USE_PROTOS\r
StripQuotes( char *s )\r
#else\r
StripQuotes( s )\r
char *s;\r
#endif\r
{\r
	if ( *s == '"' )\r
	{\r
		s[ strlen(s)-1 ] = '\0';    /* remove last quote */\r
		return( s+1 );				/* return address past initial quote */\r
	}\r
	return( s );\r
}\r