/*below is Yacc Grammer source for ANSI C*/ 

/*YACC--LALR(1) PARSER*/ 

%token IDENTIFIER CONSTANT STRING_LITERAL SIZEOF
%token PTR_OP INC_OP DEC_OP LEFT_OP RIGHT_OP LE_OP GE_OP EQ_OP NE_OP
%token AND_OP OR_OP MUL_ASSIGN DIV_ASSIGN MOD_ASSIGN ADD_ASSIGN
%token SUB_ASSIGN LEFT_ASSIGN RIGHT_ASSIGN AND_ASSIGN
%token XOR_ASSIGN OR_ASSIGN TYPE_NAME 

%token TYPEDEF EXTERN STATIC AUTO REGISTER
%token CHAR SHORT INT LONG SIGNED UNSIGNED FLOAT DOUBLE CONST VOLATILE VOID
%token STRUCT UNION ENUM ELIPSIS RANGE 

%token CASE DEFAULT IF ELSE SWITCH WHILE DO FOR GOTO CONTINUE BREAK RETURN 

%start file
%% 

primary_expr
 : identifier
 | CONSTANT
 | STRING_LITERAL
 | '(' expr ')'
 ; 

postfix_expr
 : primary_expr
 | postfix_expr '[' expr ']'
 | postfix_expr '(' ')'
 | postfix_expr '(' argument_expr_list ')'
 | postfix_expr '.' identifier
 | postfix_expr PTR_OP identifier
 | postfix_expr INC_OP
 | postfix_expr DEC_OP
 ; 

argument_expr_list
 : assignment_expr
 | argument_expr_list ',' assignment_expr
 ; 

unary_expr
 : postfix_expr
 | INC_OP unary_expr
 | DEC_OP unary_expr
 | unary_operator cast_expr
 | SIZEOF unary_expr
 | SIZEOF '(' type_name ')'
 ; 

unary_operator
 : '&'
 | '*'
 | '+'
 | '-'
 | '~'
 | '!'
 ; 

cast_expr
 : unary_expr
 | '(' type_name ')' cast_expr
 ; 

multiplicative_expr
 : cast_expr
 | multiplicative_expr '*' cast_expr
 | multiplicative_expr '/' cast_expr
 | multiplicative_expr '%' cast_expr
 ; 

additive_expr
 : multiplicative_expr
 | additive_expr '+' multiplicative_expr
 | additive_expr '-' multiplicative_expr
 ; 

shift_expr
 : additive_expr
 | shift_expr LEFT_OP additive_expr
 | shift_expr RIGHT_OP additive_expr
 ; 

relational_expr
 : shift_expr
 | relational_expr '<' shift_expr
 | relational_expr '>' shift_expr
 | relational_expr LE_OP shift_expr
 | relational_expr GE_OP shift_expr
 ; 

equality_expr
 : relational_expr
 | equality_expr EQ_OP relational_expr
 | equality_expr NE_OP relational_expr
 ; 

and_expr
 : equality_expr
 | and_expr '&' equality_expr
 ; 

exclusive_or_expr
 : and_expr
 | exclusive_or_expr '^' and_expr
 ; 

inclusive_or_expr
 : exclusive_or_expr
 | inclusive_or_expr '|' exclusive_or_expr
 ; 

logical_and_expr
 : inclusive_or_expr
 | logical_and_expr AND_OP inclusive_or_expr
 ; 

logical_or_expr
 : logical_and_expr
 | logical_or_expr OR_OP logical_and_expr
 ; 

conditional_expr
 : logical_or_expr
 | logical_or_expr '?' logical_or_expr ':' conditional_expr
 ; 

assignment_expr
 : conditional_expr
 | unary_expr assignment_operator assignment_expr
 ; 

assignment_operator
 : '='
 | MUL_ASSIGN
 | DIV_ASSIGN
 | MOD_ASSIGN
 | ADD_ASSIGN
 | SUB_ASSIGN
 | LEFT_ASSIGN
 | RIGHT_ASSIGN
 | AND_ASSIGN
 | XOR_ASSIGN
 | OR_ASSIGN
 ; 

expr
 : assignment_expr
 | expr ',' assignment_expr
 ; 

constant_expr
 : conditional_expr
 ; 

declaration
 : declaration_specifiers ';'
 | declaration_specifiers init_declarator_list ';'
 ; 

declaration_specifiers
 : storage_class_specifier
 | storage_class_specifier declaration_specifiers
 | type_specifier
 | type_specifier declaration_specifiers
 ; 

init_declarator_list
 : init_declarator
 | init_declarator_list ',' init_declarator
 ; 

init_declarator
 : declarator
 | declarator '=' initializer
 ; 

storage_class_specifier
 : TYPEDEF
 | EXTERN
 | STATIC
 | AUTO
 | REGISTER
 ; 

type_specifier
 : CHAR
 | SHORT
 | INT
 | LONG
 | SIGNED
 | UNSIGNED
 | FLOAT
 | DOUBLE
 | CONST
 | VOLATILE
 | VOID
 | struct_or_union_specifier
 | enum_specifier
 | TYPE_NAME
 ; 

struct_or_union_specifier
 : struct_or_union identifier '{' struct_declaration_list '}'
 | struct_or_union '{' struct_declaration_list '}'
 | struct_or_union identifier
 ; 

struct_or_union
 : STRUCT
 | UNION
 ; 

struct_declaration_list
 : struct_declaration
 | struct_declaration_list struct_declaration
 ; 

struct_declaration
 : type_specifier_list struct_declarator_list ';'
 ; 

struct_declarator_list
 : struct_declarator
 | struct_declarator_list ',' struct_declarator
 ; 

struct_declarator
 : declarator
 | ':' constant_expr
 | declarator ':' constant_expr
 ; 

enum_specifier
 : ENUM '{' enumerator_list '}'
 | ENUM identifier '{' enumerator_list '}'
 | ENUM identifier
 ; 

enumerator_list
 : enumerator
 | enumerator_list ',' enumerator
 ; 

enumerator
 : identifier
 | identifier '=' constant_expr
 ; 

declarator
 : declarator2
 | pointer declarator2
 ; 

declarator2
 : identifier
 | '(' declarator ')'
 | declarator2 '[' ']'
 | declarator2 '[' constant_expr ']'
 | declarator2 '(' ')'
 | declarator2 '(' parameter_type_list ')'
 | declarator2 '(' parameter_identifier_list ')'
 ; 

pointer
 : '*'
 | '*' type_specifier_list
 | '*' pointer
 | '*' type_specifier_list pointer
 ; 

type_specifier_list
 : type_specifier
 | type_specifier_list type_specifier
 ; 

parameter_identifier_list
 : identifier_list
 | identifier_list ',' ELIPSIS
 ; 

identifier_list
 : identifier
 | identifier_list ',' identifier
 ; 

parameter_type_list
 : parameter_list
 | parameter_list ',' ELIPSIS
 ; 

parameter_list
 : parameter_declaration
 | parameter_list ',' parameter_declaration
 ; 

parameter_declaration
 : type_specifier_list declarator
 | type_name
 ; 

type_name
 : type_specifier_list
 | type_specifier_list abstract_declarator
 ; 

abstract_declarator
 : pointer
 | abstract_declarator2
 | pointer abstract_declarator2
 ; 

abstract_declarator2
 : '(' abstract_declarator ')'
 | '[' ']'
 | '[' constant_expr ']'
 | abstract_declarator2 '[' ']'
 | abstract_declarator2 '[' constant_expr ']'
 | '(' ')'
 | '(' parameter_type_list ')'
 | abstract_declarator2 '(' ')'
 | abstract_declarator2 '(' parameter_type_list ')'
 ; 

initializer
 : assignment_expr
 | '{' initializer_list '}'
 | '{' initializer_list ',' '}'
 ; 

initializer_list
 : initializer
 | initializer_list ',' initializer
 ; 

statement
 : labeled_statement
 | compound_statement
 | expression_statement
 | selection_statement
 | iteration_statement
 | jump_statement
 ; 

labeled_statement
 : identifier ':' statement
 | CASE constant_expr ':' statement
 | DEFAULT ':' statement
 ; 

compound_statement
 : '{' '}'
 | '{' statement_list '}'
 | '{' declaration_list '}'
 | '{' declaration_list statement_list '}'
 ; 

declaration_list
 : declaration
 | declaration_list declaration
 ; 

statement_list
 : statement
 | statement_list statement
 ; 

expression_statement
 : ';'
 | expr ';'
 ; 

selection_statement
 : IF '(' expr ')' statement
 | IF '(' expr ')' statement ELSE statement
 | SWITCH '(' expr ')' statement
 ; 

iteration_statement
 : WHILE '(' expr ')' statement
 | DO statement WHILE '(' expr ')' ';'
 | FOR '(' ';' ';' ')' statement
 | FOR '(' ';' ';' expr ')' statement
 | FOR '(' ';' expr ';' ')' statement
 | FOR '(' ';' expr ';' expr ')' statement
 | FOR '(' expr ';' ';' ')' statement
 | FOR '(' expr ';' ';' expr ')' statement
 | FOR '(' expr ';' expr ';' ')' statement
 | FOR '(' expr ';' expr ';' expr ')' statement
 ; 

jump_statement
 : GOTO identifier ';'
 | CONTINUE ';'
 | BREAK ';'
 | RETURN ';'
 | RETURN expr ';'
 ; 

file
 : external_definition
 | file external_definition
 ; 

external_definition
 : function_definition
 | declaration
 ; 

function_definition
 : declarator function_body
 | declaration_specifiers declarator function_body
 ; 

function_body
 : compound_statement
 | declaration_list compound_statement
 ; 

identifier
 : IDENTIFIER
 ;
%% 

#include <stdio.h> 

extern char yytext[];
extern int column; 

yyerror(s)
char *s;
{
 fflush(stdout);
 printf("\n%*s\n%*s\n", column, "^", column, s);
} 

main()
{
 int yyparse(); 

 return(yyparse());
}
\Rogue\Monster\
else
  echo "will not over write ./main.c"
fi
if `test ! -s ./scan.l`
then
echo "writting ./scan.l"
cat > ./scan.l << '\Rogue\Monster\'
D   [0-9]
L   [a-zA-Z_]
H   [a-fA-F0-9]
E   [Ee][+-]?{D}+
FS   (f|F|l|L)
IS   (u|U|l|L)* 

%{
#include <stdio.h>
#include "y.tab.h" 

void count();
%} 

%%
"/*"   { comment(); } 

"auto"   { count(); return(AUTO); }
"break"   { count(); return(BREAK); }
"case"   { count(); return(CASE); }
"char"   { count(); return(CHAR); }
"const"   { count(); return(CONST); }
"continue"  { count(); return(CONTINUE); }
"default"  { count(); return(DEFAULT); }
"do"   { count(); return(DO); }
"double"  { count(); return(DOUBLE); }
"else"   { count(); return(ELSE); }
"enum"   { count(); return(ENUM); }
"extern"  { count(); return(EXTERN); }
"float"   { count(); return(FLOAT); }
"for"   { count(); return(FOR); }
"goto"   { count(); return(GOTO); }
"if"   { count(); return(IF); }
"int"   { count(); return(INT); }
"long"   { count(); return(LONG); }
"register"  { count(); return(REGISTER); }
"return"  { count(); return(RETURN); }
"short"   { count(); return(SHORT); }
"signed"  { count(); return(SIGNED); }
"sizeof"  { count(); return(SIZEOF); }
"static"  { count(); return(STATIC); }
"struct"  { count(); return(STRUCT); }
"switch"  { count(); return(SWITCH); }
"typedef"  { count(); return(TYPEDEF); }
"union"   { count(); return(UNION); }
"unsigned"  { count(); return(UNSIGNED); }
"void"   { count(); return(VOID); }
"volatile"  { count(); return(VOLATILE); }
"while"   { count(); return(WHILE); } 

{L}({L}|{D})*  { count(); return(check_type()); } 

0[xX]{H}+{IS}?  { count(); return(CONSTANT); }
0[xX]{H}+{IS}?  { count(); return(CONSTANT); }
0{D}+{IS}?  { count(); return(CONSTANT); }
0{D}+{IS}?  { count(); return(CONSTANT); }
{D}+{IS}?  { count(); return(CONSTANT); }
{D}+{IS}?  { count(); return(CONSTANT); }
'(\\.|[^\\'])+'  { count(); return(CONSTANT); } 

{D}+{E}{FS}?  { count(); return(CONSTANT); }
{D}*"."{D}+({E})?{FS}? { count(); return(CONSTANT); }
{D}+"."{D}*({E})?{FS}? { count(); return(CONSTANT); } 

\"(\\.|[^\\"])*\" { count(); return(STRING_LITERAL); } 

">>="   { count(); return(RIGHT_ASSIGN); }
"<<="   { count(); return(LEFT_ASSIGN); }
"+="   { count(); return(ADD_ASSIGN); }
"-="   { count(); return(SUB_ASSIGN); }
"*="   { count(); return(MUL_ASSIGN); }
"/="   { count(); return(DIV_ASSIGN); }
"%="   { count(); return(MOD_ASSIGN); }
"&="   { count(); return(AND_ASSIGN); }
"^="   { count(); return(XOR_ASSIGN); }
"|="   { count(); return(OR_ASSIGN); }
">>"   { count(); return(RIGHT_OP); }
"<<"   { count(); return(LEFT_OP); }
"++"   { count(); return(INC_OP); }
"--"   { count(); return(DEC_OP); }
"->"   { count(); return(PTR_OP); }
"&&"   { count(); return(AND_OP); }
"||"   { count(); return(OR_OP); }
"<="   { count(); return(LE_OP); }
">="   { count(); return(GE_OP); }
"=="   { count(); return(EQ_OP); }
"!="   { count(); return(NE_OP); }
";"   { count(); return(';'); }
"{"   { count(); return('{'); }
"}"   { count(); return('}'); }
","   { count(); return(','); }
":"   { count(); return(':'); }
"="   { count(); return('='); }
"("   { count(); return('('); }
")"   { count(); return(')'); }
"["   { count(); return('['); }
"]"   { count(); return(']'); }
"."   { count(); return('.'); }
"&"   { count(); return('&'); }
"!"   { count(); return('!'); }
"~"   { count(); return('~'); }
"-"   { count(); return('-'); }
"+"   { count(); return('+'); }
"*"   { count(); return('*'); }
"/"   { count(); return('/'); }
"%"   { count(); return('%'); }
"<"   { count(); return('<'); }
">"   { count(); return('>'); }
"^"   { count(); return('^'); }
"|"   { count(); return('|'); }
"?"   { count(); return('?'); } 

[ \t\v\n\f]  { count(); }
.   { /* ignore bad characters */ } 

%% 

yywrap()
{
 return(1);
} 

comment()
{
 char c, c1; 

loop:
 while ((c = input()) != '*' && c != 0)
  putchar(c); 

 if ((c1 = input()) != '/' && c != 0)
 {
  unput(c1);
  goto loop;
 } 

 if (c != 0)
  putchar(c1);
} 

int column = 0; 

void count()
{
 int i; 

 for (i = 0; yytext[i] != '\0'; i++)
  if (yytext[i] == '\n')
   column = 0;
  else if (yytext[i] == '\t')
   column += 8 - (column % 8);
  else
   column++; 

 ECHO;
} 

int check_type()
{
/*
* pseudo code --- this is what it should check
*
* if (yytext == type_name)
*  return(TYPE_NAME);
*
* return(IDENTIFIER);
*/ 

/*
* it actually will only return IDENTIFIER
*/ 

 return(IDENTIFIER);
}
\Rogue\Monster\
else
  echo "will not over write ./scan.l"
fi
if `test ! -s ./y.tab.h`
then
echo "writting ./y.tab.h"
cat > ./y.tab.h << '\Rogue\Monster\'
# define IDENTIFIER 257
# define CONSTANT 258
# define STRING_LITERAL 259
# define SIZEOF 260
# define PTR_OP 261
# define INC_OP 262
# define DEC_OP 263
# define LEFT_OP 264
# define RIGHT_OP 265
# define LE_OP 266
# define GE_OP 267
# define EQ_OP 268
# define NE_OP 269
# define AND_OP 270
# define OR_OP 271
# define MUL_ASSIGN 272
# define DIV_ASSIGN 273
# define MOD_ASSIGN 274
# define ADD_ASSIGN 275
# define SUB_ASSIGN 276
# define LEFT_ASSIGN 277
# define RIGHT_ASSIGN 278
# define AND_ASSIGN 279
# define XOR_ASSIGN 280
# define OR_ASSIGN 281
# define TYPE_NAME 282
# define TYPEDEF 283
# define EXTERN 284
# define STATIC 285
# define AUTO 286
# define REGISTER 287
# define CHAR 288
# define SHORT 289
# define INT 290
# define LONG 291
# define SIGNED 292
# define UNSIGNED 293
# define FLOAT 294
# define DOUBLE 295
# define CONST 296
# define VOLATILE 297
# define VOID 298
# define STRUCT 299
# define UNION 300
# define ENUM 301
# define ELIPSIS 302
# define RANGE 303
# define CASE 304
# define DEFAULT 305
# define IF 306
# define ELSE 307
# define SWITCH 308
# define WHILE 309
# define DO 310
# define FOR 311
# define GOTO 312
# define CONTINUE 313
# define BREAK 314
# define RETURN 315
\Rogue\Monster\
else
  echo "will not over write ./y.tab.h"
fi
echo "Finished archive 1 of 1"
exit