y.tab.c

編譯器的虛擬yacc工具

# line 2 "./ny.temp.y"

typedef enum {ny_empty,ny_terminal,ny_nonTerminal} ny_TokenType;


/***********************************************************************
 
 What This Is:      Newyacc specification for building a source-to-
			source translator which takes a yacc
			specification and produces a second yacc
			specification which has all the same behavior
			as the original plus the added behavior of
			drawing the parse tree and stack to the screen
			specifications
 Author:            Modified by Laura Deddens from start code provided
                    by Dr. Elizabeth White.
 Email:             [e-mail] (Laura)
 Last Modified:     5 September 1996
 
***********************************************************************/
#include <stdio.h>
#include <string.h>
#include "nytags.h"

typedef struct TokenNodeStruct *TokenNodeHdl;
typedef struct TokenNodeStruct {
   char *tokenName;
   char *newNonTerminalName;
   int typed;
   TokenNodeHdl next;
   int precedence;
   char *newPseudoTokenName;
   int thisPrecedence;
}TokenNodeStruct;

typedef struct NonTerminalNodeStruct *NonTerminalNodeHdl;
typedef struct NonTerminalNodeStruct {
   char *nonTerminalName;
   int typed;
   NonTerminalNodeHdl next;
}NonTerminalNodeStruct;

int gTokenCount = 0;
TokenNodeHdl gTokenList = NULL;
NonTerminalNodeHdl gNonTerminalList = NULL;
int gNumValues;
char *gNonTerminalName;
int gCountRHSElements;
int gCurlyCount;
int gTokenTyped;
int gNonTerminalTyped;
char *gStructName;
TokenNodeHdl gCurPrec;

char *AddTokenSymbol();
char *AddNonTerminalSymbol();
char *PrintIncludes();
char *SetNumValues();
char *PrintTypeNewNonTerminals();
char *InitNonTerminalName();
char *InitRHSElementsCount();
char *IncrRHSElementsCount();
char *LookupTokenSymbol();
char *PrintNonAction();
char *PrintEndAction();
char *PrintNewProductions();
char *PrintSecondDivider();
char *InitCurlyCount();
char *IncrCurlyCount();
char *DecrCurlyCount();
char *PrintCurlyIndent();
char *SetStructName();
char *InitTokenTypedToTrue();
char *InitTokenTypedToFalse();
char *InitNonTerminalTypedToTrue();
char *InitNonTerminalTypedToFalse();
char *PrintType();
char *PrintTypeUntypedTokens();
char *PrintTypeUntypedNonTerminals();
char *PrintNewPseudoTokens();
char *MarkWithThisPrec();
char *MarkWithPrec();
char *InitCurPrec();
char *PrintNonPrecedence();
char *myprint(char *s);
# define TOKEN_T 257
# define LEFT_T 258
# define RIGHT_T 259
# define TYPE_T 260
# define NONASSOC_T 261
# define PREC_T 262
# define NAME 263
# define CHAR 264
# define DIVIDER 265
# define ENDDIVIDER 266
# define ENDCHAR 267
# define LCURL 268
# define CCHAR 269
# define RCURL 270
# define UNION_T 271
# define STRUCT_U 272
# define INT_U 273
# define INT 274
# define NAME_U 275
# define UCHAR 276
# define ALCURLY 277
# define ASPACE 278
# define ARETURN 279
# define ACHAR 280
# define ARCURLY 281
# define SQUOAT 282
# define SCHAR 283
# define BEGINLIT 284
# define LQUOAT 285
# define LCHAR 286
# define ENDLIT 287
# define JUNK 288

#ifdef __STDC__
#include <stdlib.h>
#include <string.h>
#else
#include <malloc.h>
#include <memory.h>
#endif

#include <values.h>

#ifdef __cplusplus

#ifndef yyerror
	void yyerror(const char *);
#endif

#ifndef yylex
#ifdef __EXTERN_C__
	extern "C" { int yylex(void); }
#else
	int yylex(void);
#endif
#endif
	int yyparse(void);

#endif
#define yyclearin yychar = -1
#define yyerrok yyerrflag = 0
extern int yychar;
extern int yylineno; extern int yyerrflag;
#ifndef YYSTYPE
#define YYSTYPE int
#endif
YYSTYPE yylval;
YYSTYPE yyval;
typedef int yytabelem;
#ifndef YYMAXDEPTH
#define YYMAXDEPTH 150
#endif
#if YYMAXDEPTH > 0
int yy_yys[YYMAXDEPTH], *yys = yy_yys;
YYSTYPE yy_yyv[YYMAXDEPTH], *yyv = yy_yyv;
#else	/* user does initial allocation */
int *yys;
YYSTYPE *yyv;
#endif
static int yymaxdepth = YYMAXDEPTH;
# define YYERRCODE 256

# line 327 "./ny.temp.y"


char *AddTokenSymbol(argc, argv)
     int argc;
     char **argv;
   {
   TokenNodeHdl cur = gTokenList;
   int found = 0;
   char *newNonTerminalName;
   char *num;
   TokenNodeHdl node;
   char *newPseudoTokenName;
 
   while((cur != NULL) && (!found))
      {
      if(strcmp(cur->tokenName, argv[0]) == 0)
         {
         if (cur->typed == 0)
            {
            cur->typed = gTokenTyped;
            }
         found = 1;
         }
      cur = cur->next;
      }
   if (!found)
      {
      num = (char *)calloc(30, sizeof(char));
      node = (TokenNodeHdl)malloc(sizeof(TokenNodeStruct));
      gTokenCount++;
      node->next = gTokenList;
      gTokenList = node;
      node->tokenName = strdup(argv[0]);
      newNonTerminalName = strdup("token");
      sprintf(num, "%d", gTokenCount);
      strcat(newNonTerminalName, num);
      node->newNonTerminalName = newNonTerminalName;
      node->typed = gTokenTyped;
      newPseudoTokenName = strdup("TOKEN");
      strcat(newPseudoTokenName, num);
      node->newPseudoTokenName = newPseudoTokenName;
      node->precedence = 0;
      node->thisPrecedence = 0;
      }
   return NULL;
   }

char *AddNonTerminalSymbol(argc, argv)
      int argc;
      char **argv;
   {
   NonTerminalNodeHdl cur = gNonTerminalList;
   int found = 0;
   NonTerminalNodeHdl node;
 
   while((cur != NULL) && (!found))
      {
      if(strcmp(cur->nonTerminalName, argv[0]) == 0)
         {
         found = 1;
         }
      cur = cur->next;
      }
   if (!found)
      {
      node = (NonTerminalNodeHdl)malloc(sizeof(NonTerminalNodeStruct));
      node->next = gNonTerminalList;
      gNonTerminalList = node;
      node->nonTerminalName = strdup(argv[0]);
      node->typed = gNonTerminalTyped;
      }
   return NULL;
   }

char *PrintIncludes()
   {
   printf("\n#include <parseTree.h>\n#include <parseTreeList.h>\n#include <stepPar.h>\n#include <graphicParse.h>\n");
   return NULL;
   }

char *SetNumValues(argc, argv)
      int argc;
      char **argv;
   {
   gNumValues = atoi(argv[0]);
   return NULL;
   }

char *PrintTypeNewNonTerminals()
   {
   int i;
 
   if (gTokenCount > 0)
      {
      printf("\n%%type <%s>", gStructName);
      for (i = 1; i<=gTokenCount; i++)
         {
         printf(" token%d", i);
         }
      }
   return NULL;
   }

char *InitNonTerminalName(argc, argv)
      int argc;
      char **argv;
   {
   gNonTerminalName = strdup(argv[0]);
 
   return NULL;
   }

char *InitRHSElementsCount()
   {
   gCountRHSElements = 0;
   return NULL;
   }

char  *IncrRHSElementsCount()
   {
   gCountRHSElements++;
   return NULL;
   }

char *LookupTokenSymbol(argc, argv)
      int argc;
      char **argv;
   {
   TokenNodeHdl cur = gTokenList;
   int found = 0;
   char *ans = argv[0];
 
   while((cur != NULL) && (!found))
      {
      if (strcmp(cur->tokenName, argv[0]) == 0)
         {
         found = 1;
         ans = cur->newNonTerminalName;
         if(cur->precedence)
            {
            gCurPrec = cur;
            }
         }
      cur = cur->next;
      }
   return ans;
   }

char *PrintNonAction()
   {
   printf("{\n\t\t\t");
   PrintEndAction();
   printf("\n\t\t\t}");
 
   return NULL;
   }

char *PrintEndAction()
   {
   int i;

   printf("   {\n\t\t\t   ParseTreeListHdl list = NULL;\n");
   if (gCountRHSElements > 0)
      {
      printf("\n\t\t\t   $$.tree = NULL;\n\t\t\t   CreateNonLeafParseTree((ParseTreeHdl *)&($$.tree), \"%s\", strlen(\"%s\"));", gNonTerminalName, gNonTerminalName);
      }
   else
      {
      printf("\n\t\t\t   $$.tree = NULL;\n\t\t\t   CreateLeafParseTree((ParseTreeHdl *)&($$.tree), \"%s\", strlen(\"%s\"));", gNonTerminalName, gNonTerminalName);
      }
   for (i = 0; i < gNumValues; i++)
      {
      printf("\n\t\t\t   SetParseTreeOrgValue($$.tree, $$.x[%d], %d);", i, i);
      }
   printf("\n\t\t\t   CreateParseTreeList(&list);\n\t\t\t   AddFirst(list, $$.tree);");
   for (i = 1; i <= gCountRHSElements; i++)
      {
      printf("\n\t\t\t   AddLast(list, $%d.tree);", i);
      }
   printf("\n\t\t\t   HandleReduction(&list);\n\t\t\t   }");

   return NULL;
   }

char *PrintNewProductions()
   {
   int i;
   TokenNodeHdl cur = gTokenList;
 
   printf("\n");
   while (cur != NULL)
      {
      printf("%s\t:\t%s\n\t\t\t{\n\t\t\t$$.tree = NULL;\n\t\t\tCreateLeafParseTree((ParseTreeHdl *)&($$.tree), \"%s\", strlen(\"%s\"));\n\t\t\t", cur->newNonTerminalName, cur->tokenName, cur->tokenName, cur->tokenName );
      for (i = 0; i < gNumValues; i++)
         {
         printf("SetParseTreeOrgValue($$.tree, $1.x[%d], %d);\n\t\t\t", i, i);
         }
      printf("HandleToken($$.tree);\n\t\t\t}\n\t\t;\n\n");
      cur = cur->next;
      }
   return NULL;
   }
 
char *PrintSecondDivider()
   {
   printf("%%%%\n\nint main(int argc, char *argv[])\n   {\n   gNumValues = %d;\n   MyMain(argc, argv);\n   return 0;\n   }\n\n\n\n", gNumValues);
   return NULL;
   }

char *InitCurlyCount()
   {
   gCurlyCount = 0;
   return NULL;
   }

char *IncrCurlyCount()
   {
   gCurlyCount++;
   return NULL;
   }

char *DecrCurlyCount()
   {
   gCurlyCount--;
   return NULL;
   }

char *PrintCurlyIndent()
   {
   int i;

   for (i = 1; i <= gCurlyCount; i++)
      {
      printf("   ");
      }

   return NULL;
   }