Personal tools
You are here: Home Projects C++ Cfront releases Release 1.0 Source cfront src y.tab.c
Document Actions

y.tab.c

by Paul McJones last modified 2007-02-02 09:35

Click here to get the file

Size 66.4 kB - File type text/x-csrc

File contents

# line 43 "gram.y"
#include "size.h"
#include "cfront.h"

#define YYMAXDEPTH 300
extern int yyparse();

Pbase defa_type;
Pbase moe_type;
Pexpr dummy;
Pexpr zero;

Pclass ccl;
int cdi = 0;
static Pname cd = 0, cd_vec[BLMAX];
static char stmt_seen = 0, stmt_vec[BLMAX];
Plist modified_tn = 0;
static Plist tn_vec[BLMAX];

Pname sta_name = (Pname)&sta_name;

extern TOK back;
TOK back;
#define lex_unget(x) back = x

#define Ndata(a,b)	Pname(b)->normalize((Pbase)a,0,0)
#define Ncast(a,b)	Pname(b)->normalize((Pbase)a,0,1)
#define Nfct(a,b,c)	Pname(b)->normalize((Pbase)a,(Pblock)c,0)
#define Ntype(p)	Pname(p)->tp
#define Nstclass(p)	Pname(p)->n_stclass
#define Nlist(p)	Pname(p)->n_list
#define Ncopy(n)	(Pname(n)->base==TNAME)?new name(Pname(n)->string):Pname(n)
#define Nhide(n)	Pname(n)->hide()

#define fieldN(e)	new basetype(FIELD,(Pname)e)
#define enumdefN(m)	new enumdef(m)
#define Fargtype(p)	Pfct(p)->argtype
#define Finit(p)	Pfct(p)->f_init
#define Finline(p)	Pfct(p)->f_inline = 1
#define Fargdcl(p,q,r)	Pfct(p)->argdcl(q,r)
#define Freturns(p)	Pfct(p)->returns
#define fctN(t,a,k)	new fct(t,a,k)
#define vecN(e)		new vec(0,e)
#define Vtype(v)	Pvec(v)->typ
#define Ptyp(p)		Pptr(p)->typ

#define conN(t,v)	new expr(t,(Pexpr)v,0)

#define nlistN(n)	(PP)new nlist((Pname)n)
#define Nadd(l,n)	((class nlist *)l)->add((Pname)n)
#define Nadd_list(l,n)  ((class nlist *)l)->add_list((Pname)n)
#define Nunlist(l)	name_unlist((nlist*)l)
#define slistN(s)	(PP)new slist((Pstmt)s)
#define Sadd(l,s)	((slist*)l)->add((Pstmt)s)
#define Sunlist(l)	stmt_unlist((slist*)l)
#define Eadd(l,e)	((elist*)l)->add((Pexpr)e)
#define Eunlist(l)	expr_unlist((elist*)l)

		/* avoid redefinitions */
#undef EOFTOK
#undef ASM
#undef BREAK
#undef CASE
#undef CONTINUE
#undef DEFAULT
#undef DELETE
#undef DO
#undef ELSE
#undef ENUM
#undef FOR
#undef FORTRAN
#undef GOTO
#undef IF
#undef NEW
#undef OPERATOR
#undef PUBLIC
#undef RETURN
#undef SIZEOF
#undef SWITCH
#undef THIS
#undef WHILE
#undef LP
#undef RP
#undef LB
#undef RB
#undef REF
#undef DOT	
#undef NOT	
#undef COMPL	
#undef MUL	
#undef AND	
#undef PLUS	
#undef MINUS	
#undef ER	
#undef OR	
#undef ANDAND
#undef OROR
#undef QUEST
#undef COLON
#undef ASSIGN
#undef CM
#undef SM	
#undef LC	
#undef RC
#undef ID
#undef STRING
#undef ICON
#undef FCON	
#undef CCON	
#undef ZERO
#undef ASOP
#undef RELOP
#undef EQUOP
#undef DIVOP
#undef SHIFTOP
#undef ICOP
#undef TYPE
#undef TNAME
#undef EMPTY
#undef NO_ID
#undef NO_EXPR
#undef ELLIPSIS
#undef AGGR
#undef MEM
#undef CAST
#undef ENDCAST

Pname syn()
{
	return (Pname) yyparse();
}


# line 176 "gram.y"
typedef union  {
	char*	s;
	TOK	t;
	int	i;
	loc	l;
	Pname	pn;
	Ptype	pt;
	Pexpr	pe;
	Pstmt	ps;
	Pbase	pb;
	PP	p;	/* fudge: pointer to all class node objects
				neccessary only because unions of class
				pointers are not implemented by cpre
			*/
} YYSTYPE;

# line 192 "gram.y"
extern YYSTYPE yylval;
# define EOFTOK 0
# define ASM 1
# define BREAK 3
# define CASE 4
# define CONTINUE 7
# define DEFAULT 8
# define DELETE 9
# define DO 10
# define ELSE 12
# define ENUM 13
# define FOR 16
# define FORTRAN 17
# define GOTO 19
# define IF 20
# define NEW 23
# define OPERATOR 24
# define PUBLIC 25
# define RETURN 28
# define SIZEOF 30
# define SWITCH 33
# define THIS 34
# define WHILE 39
# define LP 40
# define RP 41
# define LB 42
# define RB 43
# define REF 44
# define DOT 45
# define NOT 46
# define COMPL 47
# define MUL 50
# define AND 52
# define PLUS 54
# define MINUS 55
# define ER 64
# define OR 65
# define ANDAND 66
# define OROR 67
# define QUEST 68
# define COLON 69
# define ASSIGN 70
# define CM 71
# define SM 72
# define LC 73
# define RC 74
# define CAST 113
# define ENDCAST 122
# define ID 80
# define STRING 81
# define ICON 82
# define FCON 83
# define CCON 84
# define ZERO 86
# define ASOP 90
# define RELOP 91
# define EQUOP 92
# define DIVOP 93
# define SHIFTOP 94
# define ICOP 95
# define TYPE 97
# define TNAME 123
# define EMPTY 124
# define NO_ID 125
# define NO_EXPR 126
# define ELLIPSIS 155
# define AGGR 156
# define MEM 160
#define yyclearin yychar = -1
#define yyerrok yyerrflag = 0
extern int yychar;
extern int yyerrflag;
#ifndef YYMAXDEPTH
#define YYMAXDEPTH 150
#endif
YYSTYPE yylval, yyval;
typedef int yytabelem;
# define YYERRCODE 256

# line 1256 "gram.y"


yytabelem yyexca[] ={
-1, 1,
	0, -1,
	-2, 0,
-1, 30,
	71, 20,
	72, 20,
	-2, 19,
-1, 43,
	155, 231,
	-2, 178,
-1, 49,
	155, 231,
	-2, 178,
-1, 221,
	1, 126,
	3, 126,
	4, 126,
	7, 126,
	8, 126,
	9, 126,
	10, 126,
	13, 126,
	16, 126,
	19, 126,
	20, 126,
	23, 126,
	24, 126,
	28, 126,
	30, 126,
	33, 126,
	34, 126,
	39, 126,
	40, 126,
	46, 126,
	47, 126,
	50, 126,
	52, 126,
	54, 126,
	55, 126,
	64, 126,
	65, 126,
	66, 126,
	67, 126,
	68, 126,
	70, 126,
	71, 126,
	72, 126,
	73, 126,
	113, 126,
	80, 126,
	81, 126,
	82, 126,
	83, 126,
	84, 126,
	86, 126,
	90, 126,
	91, 126,
	92, 126,
	93, 126,
	94, 126,
	95, 126,
	97, 126,
	123, 126,
	156, 126,
	160, 126,
	-2, 0,
-1, 249,
	72, 51,
	-2, 100,
-1, 250,
	72, 50,
	-2, 64,
	};
# define YYNPROD 237
# define YYLAST 1502
yytabelem yyact[]={

   351,    44,   372,   338,    42,   341,     5,   137,   342,     6,
    16,   104,   133,   223,   290,    50,   298,   164,    48,    60,
   287,   233,    61,   201,   204,   118,   136,   163,    49,   199,
    45,    10,   200,    46,   343,    89,    50,   217,    14,    48,
   102,    91,   377,    92,   139,    23,   144,   129,   318,    59,
   139,   153,   296,   227,   334,    54,   256,    23,    50,    94,
    50,    48,   145,    48,    38,    20,    92,   289,    22,    87,
    95,    21,    86,   131,   285,   141,    35,   388,   224,    96,
    22,   141,    36,   229,    90,   381,    93,   165,   357,   178,
   146,    92,   307,   176,   177,   158,   155,   364,   159,   139,
   162,   250,   174,   129,   379,   317,   171,   221,    92,    93,
   127,   300,   128,    53,   178,   191,   166,   406,   225,   127,
   216,   206,   207,   208,   209,   210,   211,   212,   213,   131,
    92,    27,   184,   217,    93,    27,   230,    27,   168,   203,
   205,   139,   167,   370,   249,    17,    23,   218,    47,   200,
   219,    93,   240,   231,   255,   239,    52,   184,   292,   215,
    99,   100,    18,   220,   172,   313,   126,   228,    24,    22,
    25,   257,    24,    93,    25,   126,   259,   260,   261,   262,
   263,   264,   265,   266,   267,   268,   269,   270,   271,   272,
   273,   274,   244,   275,   254,   276,   139,    35,   299,   139,
   139,    54,    15,    36,   248,   258,   242,    35,   277,   281,
   170,   282,   283,    36,    27,    33,   247,   246,   279,    19,
   236,    19,   278,   280,    45,   139,   286,    27,    23,   154,
    24,   139,    25,   252,   203,   308,   316,   301,   306,   293,
   252,   232,   284,   251,   253,    13,   205,   132,    51,    27,
   158,    22,   309,   159,   315,   162,   305,   310,   311,   295,
   234,   141,   245,    43,    24,    45,    25,   149,   152,    35,
   314,    35,   101,   141,    28,    36,   202,    36,    28,   304,
    28,   312,   148,    27,   147,    51,    45,   235,    24,   328,
    25,   241,   331,    45,    43,    40,    45,    43,    19,    45,
   154,   330,   398,   139,   383,   325,   332,   333,   326,   329,
   139,    33,   308,   308,   358,   360,   335,   362,   158,   336,
   365,   159,   361,   162,   132,   359,   292,    98,    43,   150,
    45,   328,   366,    19,   331,   331,    24,   232,    25,   130,
   195,   368,   194,   327,   196,   197,   330,   324,   374,   288,
   376,   291,   367,    45,   323,   380,   322,    28,   303,   132,
   363,    45,   238,   226,   169,   385,   151,    19,   384,   387,
    28,   373,   386,   375,   390,   371,   389,   302,   391,   395,
   393,   235,   235,   198,    29,   405,   397,    41,   399,   160,
     7,   396,    28,   132,   378,   193,   401,   394,   402,   392,
   404,   382,   408,   407,   161,     8,   178,   409,   410,   297,
   176,   177,   412,   340,   134,   352,   349,   414,    97,   353,
   350,   103,   356,   138,    83,    27,    28,   135,   346,   339,
   337,   355,   344,    31,   288,   107,   127,   291,   291,   157,
   354,    88,   116,    27,    26,   347,   125,   185,   183,   184,
   182,   345,   119,    12,    23,     1,   222,     2,   113,   114,
     0,     0,   109,     0,   110,     0,   112,   111,     0,     0,
    18,     0,     0,     0,     0,     0,     0,    22,     0,     0,
    24,     0,    25,     0,     0,   221,   369,     0,     0,     0,
     0,     0,   348,   123,   121,   122,   124,    11,   120,    39,
     0,     0,    32,     0,     0,     0,     0,   115,    30,   142,
    37,   340,     0,   352,   349,    55,    57,   353,   350,   103,
   356,     0,     0,    27,     0,   108,   346,    33,     0,   355,
   344,     0,   178,   107,   127,   143,   176,   177,   354,     0,
   116,   178,    27,   347,   125,   176,   177,     0,     0,   345,
   119,     0,     0,    34,    23,     0,   113,   114,     0,     0,
   109,     0,   110,     0,   112,   111,     0,     0,    28,   236,
    18,     0,   117,   185,     0,   184,   182,    22,     0,    24,
    24,    25,    25,   221,   184,   182,    28,     0,     0,     0,
   348,   123,   121,   122,   124,     0,   120,   173,     0,    39,
   103,     0,     0,     0,    27,   115,     0,   142,     0,   234,
    37,     0,     0,     0,   107,   127,     0,     0,     0,     0,
     0,   116,     0,   108,     0,   125,    33,     0,     0,   173,
     0,   119,     0,   143,    23,    23,     0,   113,   114,     0,
     0,   109,     0,   110,     0,   112,   111,     0,     0,     0,
    18,    18,   232,    58,     0,     0,     0,    22,    22,     0,
    24,    24,    25,    25,   140,     0,    28,     0,     0,     0,
   117,   126,   123,   121,   122,   124,     0,   120,     0,     0,
     0,   103,     0,     0,     0,    28,   115,     0,   142,     0,
    15,    15,     0,     0,     0,   107,   127,     0,     0,     0,
     0,     0,   116,     0,   108,     0,   125,     0,     0,     0,
     0,     0,   119,     0,   143,     0,     0,     0,   113,   114,
     0,     0,   109,     0,   110,     0,   112,   111,     0,     0,
     0,     0,     0,    58,    56,     0,     0,   178,     0,   179,
     0,   176,   177,     0,     0,   140,     0,    28,     0,     0,
     0,   117,   126,   123,   121,   122,   124,     0,   120,     0,
     0,     0,   103,     0,     0,     0,     0,   115,     0,   105,
     0,     0,     0,     4,     9,     0,   107,   127,   185,   183,
   184,   182,     0,   116,     0,   108,    27,   125,     0,     0,
     0,     0,     0,   119,     0,   106,     0,    23,     0,   113,
   114,     0,     0,   109,     0,   110,     0,   112,   111,     0,
     0,     0,     0,    18,     0,     0,     0,     0,     0,     0,
    22,     0,     0,    24,     0,    25,     0,     0,     0,     0,
     0,     0,   117,   126,   123,   121,   122,   124,     0,   120,
   107,   127,     0,     0,     0,     3,     0,   116,   115,     0,
   105,   125,     0,    15,     0,     0,     0,   119,     0,   192,
     0,     0,     0,   113,   114,     0,   108,   109,     0,   110,
    19,   112,   111,     0,     0,   178,   106,   179,     0,   176,
   177,   178,     0,   179,     0,   176,   177,     0,     0,   181,
   180,   186,   187,   190,     0,   181,    13,   126,   123,   121,
   122,   124,     0,   120,   107,   127,     0,     0,     0,     0,
     0,   116,   115,   117,   105,   125,   185,   183,   184,   182,
     0,   119,   185,   183,   184,   182,     0,   113,   114,    28,
   108,   109,     0,   110,     0,   112,   111,     0,     0,   178,
   106,   179,     0,   176,   177,     0,     0,     0,     0,   107,
   127,     0,     0,   181,   180,   186,   116,     0,     0,     0,
   125,   126,   123,   121,   122,   124,   119,   120,   107,   127,
     0,     0,   113,   114,     0,   116,   115,   117,   105,   125,
   185,   183,   184,   182,     0,   119,     0,     0,     0,     0,
     0,   113,   114,     0,   108,   109,     0,   110,     0,   112,
   111,     0,     0,     0,   106,     0,   126,   123,   121,   122,
   124,     0,   120,     0,     0,     0,     0,     0,     0,     0,
     0,   115,     0,   105,     0,   126,   123,   121,   122,   124,
     0,   120,    27,     0,     0,     0,     0,     0,     0,   108,
   115,   117,   105,    23,   156,     0,    82,     0,     0,   106,
     0,     0,     0,     0,     0,     0,     0,     0,   214,    18,
    81,     0,     0,     0,     0,     0,    22,     0,   106,    24,
     0,    25,     0,     0,     0,     0,     0,    74,     0,    75,
     0,     0,     0,    76,    77,     0,   117,    64,     0,    65,
     0,    62,    63,     0,     0,     0,     0,     0,     0,    15,
     0,    67,    66,    72,    73,   117,     0,    80,     0,     0,
     0,     0,     0,     0,     0,     0,    19,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,    79,    71,    69,
    70,    68,    78,     0,    84,     0,     0,     0,   413,     0,
     0,     0,    13,     0,     0,     0,     0,   178,     0,   179,
     0,   176,   177,     0,     0,     0,     0,     0,     0,     0,
    85,   181,   180,   186,   187,   190,     0,   175,   189,     0,
     0,     0,     0,     0,     0,    28,     0,     0,   178,     0,
   179,     0,   176,   177,     0,     0,     0,   188,   185,   183,
   184,   182,   181,   180,   186,   187,   190,     0,   175,   189,
   411,     0,     0,     0,     0,     0,     0,     0,     0,   178,
     0,   179,     0,   176,   177,     0,     0,     0,   188,   185,
   183,   184,   182,   181,   180,   186,   187,   190,   403,   175,
   189,   400,     0,     0,     0,     0,     0,     0,     0,     0,
   178,     0,   179,     0,   176,   177,     0,     0,     0,   188,
   185,   183,   184,   182,   181,   180,   186,   187,   190,     0,
   175,   189,     0,     0,   321,     0,     0,     0,     0,     0,
     0,   178,     0,   179,     0,   176,   177,     0,     0,     0,
   188,   185,   183,   184,   182,   181,   180,   186,   187,   190,
     0,   175,   189,     0,     0,   320,     0,     0,     0,     0,
     0,     0,   178,     0,   179,     0,   176,   177,     0,     0,
     0,   188,   185,   183,   184,   182,   181,   180,   186,   187,
   190,     0,   175,   189,     0,     0,     0,     0,     0,     0,
     0,     0,     0,   178,     0,   179,     0,   176,   177,     0,
     0,     0,   188,   185,   183,   184,   182,   181,   180,   186,
   187,   190,   319,   175,   189,   294,     0,     0,     0,     0,
     0,     0,     0,     0,   178,     0,   179,     0,   176,   177,
     0,     0,     0,   188,   185,   183,   184,   182,   181,   180,
   186,   187,   190,     0,   175,   189,     0,     0,   237,     0,
     0,     0,     0,     0,     0,   178,     0,   179,     0,   176,
   177,     0,     0,     0,   188,   185,   183,   184,   182,   181,
   180,   186,   187,   190,     0,   175,   189,     0,     0,     0,
     0,     0,     0,     0,     0,     0,   178,     0,   179,     0,
   176,   177,     0,     0,     0,   188,   185,   183,   184,   182,
   181,   180,   186,   187,   190,     0,   175,   189,     0,   178,
     0,   179,     0,   176,   177,     0,     0,   178,     0,   179,
     0,   176,   177,   181,   180,     0,   188,   185,   183,   184,
   182,   181,   180,   186,   187,   190,     0,   175,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
   185,   183,   184,   182,     0,     0,     0,   188,   185,   183,
   184,   182 };
yytabelem yypact[]={

   773, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,   344,
   430,   223, -1000,   -12, -1000,   240,    33,   611,   610, -1000,
 -1000, -1000,   -74,  1037,   -25,   -28, -1000,    11,   -14,    -2,
   257,    89, -1000, -1000,   -12, -1000, -1000,   203, -1000,   753,
 -1000,   270, -1000,   591, -1000,   753, -1000, -1000, -1000,   591,
 -1000,   204,   237,   222, -1000,   254,   -12,   288,   -12, -1000,
 -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
 -1000, -1000, -1000, -1000,   325,   225, -1000, -1000, -1000, -1000,
 -1000, -1000, -1000,   238, -1000, -1000, -1000, -1000,    22,  1019,
     7,    43, -1000, -1000, -1000,    69,   323,   270,   672,   530,
 -1000,   753,  1407,   817,   300,   343,   -11,   236,   201,   881,
   881,   881,   881,   881,   881,   881,   945,   -37, -1000,   753,
 -1000, -1000, -1000, -1000, -1000, -1000,  -123,  1037,    34, -1000,
    38,   430, -1000,   322,    12,    65, -1000, -1000, -1000,  1407,
   672,   529,   343,   -11,  1345,   321, -1000, -1000, -1000, -1000,
   251, -1000, -1000, -1000,   238, -1000,   193, -1000, -1000,   145,
   144, -1000,    21,   169, -1000,   174,     7, -1000,    31,    99,
    34, -1000, -1000,   257,  1407,   753,   753,   753,   753,   753,
   753,   753,   753,   753,   753,   753,   753,   753,   753,   753,
   753,   300,   753, -1000,   753,   672,    95,    86,   672,   672,
    50, -1000,   201,   214,   -55,   118,   300,   300,   300,   300,
   300,   300,   300,   300,   201, -1000,  1314,    28, -1000, -1000,
 -1000,   -58,    40, -1000,   672,   337, -1000, -1000,   317,   124,
   672,    18, -1000,   182, -1000,   180,   180, -1000, -1000, -1000,
 -1000,   201, -1000, -1000,   122, -1000, -1000, -1000,    93,   237,
   222, -1000,     7,   753,   162,    32,   -75, -1000, -1000,  1407,
    64,    64, -1000,   356,   831,   687,    39,   482, -1000,   491,
  1399,   889,  1407,  1407,  1283,  1252,  1221,   315, -1000,  -128,
 -1000,  -128,   313,   306, -1000,  1037,   302,   244,   238,   881,
   244,   286,   286,   -68, -1000, -1000,  1037,   510, -1000,    14,
    38,   284,   672, -1000,   281, -1000, -1000, -1000, -1000,   672,
   244,   319,   122, -1000, -1000,  1407, -1000, -1000,    24,   753,
   881, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,   244,
   300, -1000,   244,   311,   926, -1000, -1000,   412, -1000,    71,
   335, -1000, -1000, -1000,   331,   331,   333,   331,   -27, -1000,
    35,  1376, -1000, -1000,   753,     5, -1000, -1000, -1000, -1000,
   263, -1000, -1000,   251, -1000,   825,   300,   251, -1000, -1000,
 -1000,    -4,   510,   753,   510, -1000,   510, -1000,   753, -1000,
  1376, -1000,   510, -1000, -1000, -1000, -1000, -1000,   261,   376,
  1190, -1000,   510, -1000,   510,  1159,   510,   346,    45,   510,
 -1000,   753, -1000,   510, -1000,   331, -1000, -1000,  1128, -1000,
 -1000,   753,  1097,   510, -1000 };
yytabelem yypgo[]={

     0,   457,   404,   389,     8,   387,   112,   456,    13,     5,
   455,     1,   145,    31,   453,    71,    27,    17,    41,   444,
    65,   441,    35,   439,    64,   433,    38,   497,     7,   430,
    34,     3,   429,   427,    12,     0,    11,    25,    14,    24,
    51,    22,   424,    21,    26,   423,     4,   414,    20,    23,
     2,    10,    19,   409,   401,   399,   397,   394,   391 };
yytabelem yyr1[]={

     0,    10,    10,    10,     1,     1,     1,     1,     1,     2,
     4,     3,     6,     6,     7,     7,     8,     8,     5,     5,
    24,    24,    24,    24,    25,    25,     9,     9,    14,    14,
    14,    14,    13,    13,    13,    13,    13,    15,    15,    16,
    16,    17,    17,    17,    20,    20,    19,    19,    19,    19,
    18,    18,    21,    21,    21,    22,    22,    23,    23,    23,
    23,    23,    23,    23,    26,    26,    26,    26,    52,    52,
    52,    52,    52,    52,    52,    52,    52,    52,    52,    52,
    52,    52,    52,    52,    52,    52,    52,    52,    52,    51,
    51,    51,    51,    27,    27,    27,    27,    27,    27,    27,
    27,    27,    27,    27,    27,    27,    27,    43,    43,    43,
    43,    43,    43,    48,    48,    48,    38,    38,    38,    38,
    38,    40,    40,    29,    29,    50,    53,    30,    30,    30,
    32,    32,    32,    32,    32,    54,    32,    31,    31,    31,
    31,    31,    31,    31,    31,    55,    31,    31,    56,    31,
    57,    31,    58,    31,    34,    33,    33,    28,    28,    35,
    35,    35,    35,    35,    35,    35,    35,    35,    35,    35,
    35,    35,    35,    35,    35,    35,    35,    35,    35,    36,
    36,    36,    36,    36,    36,    36,    36,    36,    36,    36,
    36,    36,    36,    36,    36,    36,    36,    36,    36,    36,
    36,    36,    36,    36,    36,    36,    36,    36,    36,    37,
    37,    37,    37,    37,    37,    37,    37,    37,    39,    42,
    42,    41,    49,    45,    45,    46,    46,    46,    47,    47,
    44,    44,    12,    12,    12,    12,    11 };
yytabelem yyr2[]={

     0,     3,     3,     3,     3,     3,     3,     3,    11,     5,
    11,     9,     5,     1,     2,     7,     7,     9,     5,     1,
     2,     7,     5,     7,     3,     7,     7,     5,     3,     3,
     2,     2,     2,     5,     5,     5,     5,     9,    11,     3,
     7,     3,     7,     1,     7,     9,     5,     7,    11,    13,
     3,     2,     3,     7,     9,     5,     1,     2,     4,     2,
     4,     2,     2,     7,     3,     5,     5,     5,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     5,     5,     2,     2,     2,     2,     2,     3,     3,     4,
     4,     7,     7,     5,     5,     9,     9,     2,     7,     5,
     5,     5,     5,     5,     5,     9,     9,     3,     1,     5,
     5,     9,     9,     1,     5,     5,     1,     5,     5,     9,
     9,     1,     5,     5,     3,     7,     1,     9,     5,     7,
     3,     3,     3,     5,     5,     1,    11,     4,    11,     3,
     3,     2,     7,    11,     7,     1,    19,     7,     1,     9,
     1,    11,     1,     9,     3,     3,     7,     2,     7,     7,
     7,     7,     7,     7,     7,     7,     7,     7,     7,     7,
     7,     7,     7,     7,    11,     5,    11,     2,     1,     9,
     9,     5,     9,     5,     9,     5,     5,     5,     5,     5,
     5,     5,     5,     9,     9,     9,     7,     7,     7,     7,
     5,     2,     7,     3,     3,     3,     3,     3,     3,     3,
     7,     7,     5,     9,     9,     5,     9,     9,     5,     3,
     3,     5,     5,     5,     9,     7,     9,    11,     7,     3,
     2,     1,     3,     3,     5,     5,     7 };
yytabelem yychk[]={

 -1000,   -10,    -1,    72,     0,    -9,    -4,    -3,    -2,     1,
   -13,   -27,   -14,   123,   -26,    80,   -51,   -12,    40,    97,
   -20,   -15,    47,    24,    50,    52,   -19,    13,   156,    40,
   -27,   -25,    72,    97,   123,   -20,   -15,    80,   -24,    69,
    72,    -5,   -46,    40,   -11,    42,    45,   160,   -46,    40,
   -11,    45,   123,    80,   -26,   -27,   123,   -27,   123,   123,
   -52,   -41,    54,    55,    50,    52,    65,    64,    94,    92,
    93,    91,    66,    67,    40,    42,    46,    47,    95,    90,
    70,    23,     9,   -42,    97,   123,    97,    97,   -21,   -22,
    73,   -18,    80,   123,    73,   -18,    81,    -5,    70,    71,
    72,    69,   -35,     9,   -36,    97,   123,    23,   113,    50,
    52,    55,    54,    46,    47,    95,    30,   160,   -37,    40,
    86,    82,    83,    81,    84,    34,    80,    24,    -6,    -9,
    69,   -13,   123,   -34,   -47,   -33,   -44,   -28,   -45,   -35,
    73,   -13,    97,   123,   -35,   -34,   -26,    80,    45,    45,
    41,    41,    43,   -40,   -12,    74,    25,   -23,    -9,    -4,
    -3,    -2,   -51,   -16,   -17,    80,    73,    73,    69,    41,
    -6,   -28,   -24,   -27,   -35,    70,    54,    55,    50,    52,
    65,    64,    94,    92,    93,    91,    66,    67,    90,    71,
    68,   -36,    42,    95,    42,    40,    44,    45,    40,    40,
   160,   -49,    40,   -13,   -39,   -13,   -36,   -36,   -36,   -36,
   -36,   -36,   -36,   -36,   113,   -18,   -35,   160,   -52,   -41,
   -30,    73,    -7,    -8,    40,    80,    41,    41,   155,    71,
    71,   -34,   123,   -43,    80,   -12,    40,    43,    41,   -46,
   -11,    40,   -40,    97,   -22,    69,    72,    72,   -18,   123,
    80,    74,    71,    70,   -16,   123,    25,    72,   -30,   -35,
   -35,   -35,   -35,   -35,   -35,   -35,   -35,   -35,   -35,   -35,
   -35,   -35,   -35,   -35,   -35,   -35,   -35,   -34,   -37,   123,
   -37,   123,   -34,   -34,   -18,    24,   -49,   -48,   -12,   122,
   -38,   -12,    40,   -39,    41,   -18,    24,   -53,    74,   256,
    71,   -34,    40,    41,   155,   -44,   -28,    74,   -11,    70,
   -43,   -43,   -22,    72,   -17,   -35,    74,    73,   123,    69,
    43,    43,    41,    41,    41,   -52,   -41,    41,   -11,   -48,
   -36,   -11,   -38,   -38,   122,   -52,   -41,   -29,   -31,   -32,
     1,    -9,    -4,   -30,    20,    39,    16,    33,    80,     4,
     8,   -35,     3,     7,    28,    19,    10,    74,    -8,    41,
   -34,    41,   -28,    41,    73,   -35,   -36,    41,   -31,    74,
    72,    40,   -50,    40,   -50,    40,   -50,    69,   -57,    69,
   -35,    80,   -54,    41,   -46,   -11,   -46,   -11,    81,   -31,
   -35,   -31,   -55,   -31,   -56,   -35,   -58,   -31,    41,    12,
    41,   -31,   -31,    69,   -31,    39,    72,   -31,   -35,   -31,
   -50,    72,   -35,    41,   -31 };
yytabelem yydef[]={

     0,    -2,     1,     2,     3,     4,     5,     6,     7,     0,
     0,    19,    32,    29,    97,    64,     0,     0,     0,    28,
    30,    31,     0,     0,   232,   233,    56,     0,     0,     0,
    -2,     0,    27,    33,    34,    35,    36,    64,    24,   178,
     9,    13,    93,    -2,   104,   178,    89,    90,    94,    -2,
   103,     0,   100,    64,    99,   101,   102,     0,     0,    65,
    66,    67,    68,    69,    70,    71,    72,    73,    74,    75,
    76,    77,    78,    79,     0,     0,    82,    83,    84,    85,
    86,    87,    88,   121,   219,   220,   234,   235,     0,    52,
    43,     0,    50,    51,    46,     0,     0,    13,   178,     0,
    26,   178,    22,     0,   177,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,   201,   178,
   203,   204,   205,   206,   207,   208,   209,     0,     0,    18,
     0,     0,    29,     0,     0,   154,   229,   155,   230,   157,
   178,   108,    28,    29,     0,     0,    98,    64,    91,    92,
     0,    80,    81,   221,   121,    44,    56,    55,    57,    59,
    61,    62,     0,     0,    39,    41,    43,    47,     0,     0,
     0,    23,    25,    20,    21,   178,   178,   178,   178,   178,
   178,   178,   178,   178,   178,   178,   178,   178,   178,   178,
   178,   175,   178,   183,   178,   178,     0,     0,   178,   178,
     0,   181,     0,   113,     0,   116,   185,   186,   187,   188,
   189,   190,   191,   192,     0,   200,     0,     0,   212,   215,
    11,    -2,    12,    14,   178,     0,    95,   225,     0,   231,
   178,     0,    34,   223,   107,   108,   108,   236,    96,   105,
   106,   231,   122,    45,    53,    56,    58,    60,     0,    -2,
    -2,    37,    43,   178,     0,     0,     0,     8,    10,   159,
   160,   161,   162,   163,   164,   165,   166,   167,   168,   169,
   170,   171,   172,   173,     0,     0,     0,     0,   196,   197,
   198,   199,     0,     0,   210,     0,     0,   222,   113,     0,
   218,   116,   116,     0,   202,   211,     0,   178,   128,     0,
     0,     0,   178,   226,     0,   228,   156,   158,   110,   178,
   109,     0,    54,    63,    40,    42,    38,    48,     0,   178,
     0,   194,   195,   179,   180,   213,   216,   182,   115,   114,
   184,   118,   117,     0,   193,   214,   217,   178,   124,     0,
     0,   139,   140,   141,     0,     0,     0,     0,   209,   150,
     0,   130,   131,   132,   178,     0,   135,   129,    15,    16,
     0,   227,   224,     0,    49,   174,   176,     0,   123,   127,
   137,     0,   178,   178,   178,   145,   178,   148,   178,   152,
   133,   134,   178,    17,   111,   112,   119,   120,     0,   142,
     0,   144,   178,   147,   178,     0,   178,     0,     0,   178,
   125,   178,   149,   178,   153,     0,   138,   143,     0,   151,
   136,   178,     0,   178,   146 };
typedef struct { char *t_name; int t_val; } yytoktype;
#ifndef YYDEBUG
#	define YYDEBUG	0	/* don't allow debugging */
#endif

#if YYDEBUG

yytoktype yytoks[] =
{
	"EOFTOK",	0,
	"ASM",	1,
	"BREAK",	3,
	"CASE",	4,
	"CONTINUE",	7,
	"DEFAULT",	8,
	"DELETE",	9,
	"DO",	10,
	"ELSE",	12,
	"ENUM",	13,
	"FOR",	16,
	"FORTRAN",	17,
	"GOTO",	19,
	"IF",	20,
	"NEW",	23,
	"OPERATOR",	24,
	"PUBLIC",	25,
	"RETURN",	28,
	"SIZEOF",	30,
	"SWITCH",	33,
	"THIS",	34,
	"WHILE",	39,
	"LP",	40,
	"RP",	41,
	"LB",	42,
	"RB",	43,
	"REF",	44,
	"DOT",	45,
	"NOT",	46,
	"COMPL",	47,
	"MUL",	50,
	"AND",	52,
	"PLUS",	54,
	"MINUS",	55,
	"ER",	64,
	"OR",	65,
	"ANDAND",	66,
	"OROR",	67,
	"QUEST",	68,
	"COLON",	69,
	"ASSIGN",	70,
	"CM",	71,
	"SM",	72,
	"LC",	73,
	"RC",	74,
	"CAST",	113,
	"ENDCAST",	122,
	"ID",	80,
	"STRING",	81,
	"ICON",	82,
	"FCON",	83,
	"CCON",	84,
	"ZERO",	86,
	"ASOP",	90,
	"RELOP",	91,
	"EQUOP",	92,
	"DIVOP",	93,
	"SHIFTOP",	94,
	"ICOP",	95,
	"TYPE",	97,
	"TNAME",	123,
	"EMPTY",	124,
	"NO_ID",	125,
	"NO_EXPR",	126,
	"ELLIPSIS",	155,
	"AGGR",	156,
	"MEM",	160,
	"-unknown-",	-1	/* ends search */
};

char * yyreds[] =
{
	"-no such reduction-",
	"ext_def : external_def",
	"ext_def : SM",
	"ext_def : EOFTOK",
	"external_def : data_dcl",
	"external_def : att_fct_def",
	"external_def : fct_def",
	"external_def : fct_dcl",
	"external_def : ASM LP STRING RP SM",
	"fct_dcl : decl SM",
	"att_fct_def : type decl arg_dcl_list base_init block",
	"fct_def : decl arg_dcl_list base_init block",
	"base_init : COLON init_list",
	"base_init : /* empty */",
	"init_list : binit",
	"init_list : init_list CM binit",
	"binit : LP elist RP",
	"binit : ID LP elist RP",
	"arg_dcl_list : arg_dcl_list data_dcl",
	"arg_dcl_list : /* empty */",
	"dl : decl",
	"dl : ID COLON e",
	"dl : COLON e",
	"dl : decl ASSIGN initializer",
	"decl_list : dl",
	"decl_list : decl_list CM dl",
	"data_dcl : type decl_list SM",
	"data_dcl : type SM",
	"tp : TYPE",
	"tp : TNAME",
	"tp : class_dcl",
	"tp : enum_dcl",
	"type : tp",
	"type : type TYPE",
	"type : type TNAME",
	"type : type class_dcl",
	"type : type enum_dcl",
	"enum_dcl : ENUM LC moe_list RC",
	"enum_dcl : ENUM tag LC moe_list RC",
	"moe_list : moe",
	"moe_list : moe_list CM moe",
	"moe : ID",
	"moe : ID ASSIGN e",
	"moe : /* empty */",
	"class_dcl : class_head mem_list RC",
	"class_dcl : class_head mem_list RC TYPE",
	"class_head : AGGR LC",
	"class_head : AGGR tag LC",
	"class_head : AGGR tag COLON TNAME LC",
	"class_head : AGGR tag COLON PUBLIC TNAME LC",
	"tag : ID",
	"tag : TNAME",
	"mem_list : cl_mem_list",
	"mem_list : cl_mem_list PUBLIC cl_mem_list",
	"mem_list : cl_mem_list PUBLIC COLON cl_mem_list",
	"cl_mem_list : cl_mem_list cl_mem",
	"cl_mem_list : /* empty */",
	"cl_mem : data_dcl",
	"cl_mem : att_fct_def SM",
	"cl_mem : att_fct_def",
	"cl_mem : fct_def SM",
	"cl_mem : fct_def",
	"cl_mem : fct_dcl",
	"cl_mem : tn_list tag SM",
	"fname : ID",
	"fname : COMPL TNAME",
	"fname : OPERATOR oper",
	"fname : OPERATOR c_type",
	"oper : PLUS",
	"oper : MINUS",
	"oper : MUL",
	"oper : AND",
	"oper : OR",
	"oper : ER",
	"oper : SHIFTOP",
	"oper : EQUOP",
	"oper : DIVOP",
	"oper : RELOP",
	"oper : ANDAND",
	"oper : OROR",
	"oper : LP RP",
	"oper : LB RB",
	"oper : NOT",
	"oper : COMPL",
	"oper : ICOP",
	"oper : ASOP",
	"oper : ASSIGN",
	"oper : NEW",
	"oper : DELETE",
	"tn_list : TNAME DOT",
	"tn_list : TNAME MEM",
	"tn_list : tn_list TNAME DOT",
	"tn_list : tn_list ID DOT",
	"decl : decl arg_list",
	"decl : TNAME arg_list",
	"decl : decl LP elist RP",
	"decl : TNAME LP elist RP",
	"decl : fname",
	"decl : ID DOT fname",
	"decl : tn_list fname",
	"decl : tn_list TNAME",
	"decl : ptr decl",
	"decl : ptr TNAME",
	"decl : TNAME vec",
	"decl : decl vec",
	"decl : LP decl RP arg_list",
	"decl : LP decl RP vec",
	"arg_decl : ID",
	"arg_decl : /* empty */",
	"arg_decl : ptr arg_decl",
	"arg_decl : arg_decl vec",
	"arg_decl : LP arg_decl RP arg_list",
	"arg_decl : LP arg_decl RP vec",
	"new_decl : /* empty */",
	"new_decl : ptr new_decl",
	"new_decl : new_decl vec",
	"cast_decl : /* empty */",
	"cast_decl : ptr cast_decl",
	"cast_decl : cast_decl vec",
	"cast_decl : LP cast_decl RP arg_list",
	"cast_decl : LP cast_decl RP vec",
	"c_decl : /* empty */",
	"c_decl : ptr c_decl",
	"stmt_list : stmt_list statement",
	"stmt_list : statement",
	"condition : LP e RP",
	"block : LC",
	"block : LC stmt_list RC",
	"block : LC RC",
	"block : LC error RC",
	"simple : e",
	"simple : BREAK",
	"simple : CONTINUE",
	"simple : RETURN e",
	"simple : GOTO ID",
	"simple : DO",
	"simple : DO statement WHILE condition",
	"statement : simple SM",
	"statement : ASM LP STRING RP SM",
	"statement : data_dcl",
	"statement : att_fct_def",
	"statement : block",
	"statement : IF condition statement",
	"statement : IF condition statement ELSE statement",
	"statement : WHILE condition statement",
	"statement : FOR LP",
	"statement : FOR LP statement e SM e RP statement",
	"statement : SWITCH condition statement",
	"statement : ID COLON",
	"statement : ID COLON statement",
	"statement : CASE",
	"statement : CASE e COLON statement",
	"statement : DEFAULT COLON",
	"statement : DEFAULT COLON statement",
	"elist : ex_list",
	"ex_list : initializer",
	"ex_list : ex_list CM initializer",
	"initializer : e",
	"initializer : LC elist RC",
	"e : e ASSIGN e",
	"e : e PLUS e",
	"e : e MINUS e",
	"e : e MUL e",
	"e : e AND e",
	"e : e OR e",
	"e : e ER e",
	"e : e SHIFTOP e",
	"e : e EQUOP e",
	"e : e DIVOP e",
	"e : e RELOP e",
	"e : e ANDAND e",
	"e : e OROR e",
	"e : e ASOP e",
	"e : e CM e",
	"e : e QUEST e COLON e",
	"e : DELETE term",
	"e : DELETE LB e RB term",
	"e : term",
	"e : /* empty */",
	"term : TYPE LP elist RP",
	"term : TNAME LP elist RP",
	"term : NEW new_type",
	"term : NEW LP new_type RP",
	"term : term ICOP",
	"term : CAST cast_type ENDCAST term",
	"term : MUL term",
	"term : AND term",
	"term : MINUS term",
	"term : PLUS term",
	"term : NOT term",
	"term : COMPL term",
	"term : ICOP term",
	"term : SIZEOF term",
	"term : SIZEOF CAST cast_type ENDCAST",
	"term : term LB e RB",
	"term : term LP elist RP",
	"term : term REF prim",
	"term : term REF TNAME",
	"term : term DOT prim",
	"term : term DOT TNAME",
	"term : MEM tag",
	"term : prim",
	"term : LP e RP",
	"term : ZERO",
	"term : ICON",
	"term : FCON",
	"term : STRING",
	"term : CCON",
	"term : THIS",
	"prim : ID",
	"prim : TNAME MEM tag",
	"prim : ID MEM tag",
	"prim : OPERATOR oper",
	"prim : TNAME MEM OPERATOR oper",
	"prim : ID MEM OPERATOR oper",
	"prim : OPERATOR c_type",
	"prim : TNAME MEM OPERATOR c_type",
	"prim : ID MEM OPERATOR c_type",
	"cast_type : type cast_decl",
	"c_tp : TYPE",
	"c_tp : TNAME",
	"c_type : c_tp c_decl",
	"new_type : type new_decl",
	"arg_type : type arg_decl",
	"arg_type : type arg_decl ASSIGN initializer",
	"arg_list : LP arg_type_list RP",
	"arg_list : LP arg_type_list ELLIPSIS RP",
	"arg_list : LP arg_type_list CM ELLIPSIS RP",
	"arg_type_list : arg_type_list CM at",
	"arg_type_list : at",
	"at : arg_type",
	"at : /* empty */",
	"ptr : MUL",
	"ptr : AND",
	"ptr : MUL TYPE",
	"ptr : AND TYPE",
	"vec : LB e RB",
};
#endif /* YYDEBUG */
/*	@(#)yaccpar	1.9	*/

/*
** Skeleton parser driver for yacc output
*/

/*
** yacc user known macros and defines
*/
#define YYERROR		goto yyerrlab
#define YYACCEPT	return(0)
#define YYABORT		return(1)
#define YYBACKUP( newtoken, newvalue )\
{\
	if ( yychar >= 0 || ( yyr2[ yytmp ] >> 1 ) != 1 )\
	{\
		yyerror( "syntax error - cannot backup" );\
		goto yyerrlab;\
	}\
	yychar = newtoken;\
	yystate = *yyps;\
	yylval = newvalue;\
	goto yynewstate;\
}
#define YYRECOVERING()	(!!yyerrflag)
#ifndef YYDEBUG
#	define YYDEBUG	1	/* make debugging available */
#endif

/*
** user known globals
*/
int yydebug;			/* set to 1 to get debugging */

/*
** driver internal defines
*/
#define YYFLAG		(-1000)

/*
** global variables used by the parser
*/
YYSTYPE yyv[ YYMAXDEPTH ];	/* value stack */
int yys[ YYMAXDEPTH ];		/* state stack */

YYSTYPE *yypv;			/* top of value stack */
int *yyps;			/* top of state stack */

int yystate;			/* current state */
int yytmp;			/* extra var (lasts between blocks) */

int yynerrs;			/* number of errors */
int yyerrflag;			/* error recovery flag */
int yychar;			/* current input token number */



/*
** yyparse - return 0 if worked, 1 if syntax error not recovered from
*/
int
yyparse()
{
	register YYSTYPE *yypvt;	/* top of value stack for $vars */

	/*
	** Initialize externals - yyparse may be called more than once
	*/
	yypv = &yyv[-1];
	yyps = &yys[-1];
	yystate = 0;
	yytmp = 0;
	yynerrs = 0;
	yyerrflag = 0;
	yychar = -1;

	goto yystack;
	{
		register YYSTYPE *yy_pv;	/* top of value stack */
		register int *yy_ps;		/* top of state stack */
		register int yy_state;		/* current state */
		register int  yy_n;		/* internal state number info */

		/*
		** get globals into registers.
		** branch to here only if YYBACKUP was called.
		*/
	yynewstate:
		yy_pv = yypv;
		yy_ps = yyps;
		yy_state = yystate;
		goto yy_newstate;

		/*
		** get globals into registers.
		** either we just started, or we just finished a reduction
		*/
	yystack:
		yy_pv = yypv;
		yy_ps = yyps;
		yy_state = yystate;

		/*
		** top of for (;;) loop while no reductions done
		*/
	yy_stack:
		/*
		** put a state and value onto the stacks
		*/
#if YYDEBUG
		/*
		** if debugging, look up token value in list of value vs.
		** name pairs.  0 and negative (-1) are special values.
		** Note: linear search is used since time is not a real
		** consideration while debugging.
		*/
		if ( yydebug )
		{
			register int yy_i;

			printf( "State %d, token ", yy_state );
			if ( yychar == 0 )
				printf( "end-of-file\n" );
			else if ( yychar < 0 )
				printf( "-none-\n" );
			else
			{
				for ( yy_i = 0; yytoks[yy_i].t_val >= 0;
					yy_i++ )
				{
					if ( yytoks[yy_i].t_val == yychar )
						break;
				}
				printf( "%s\n", yytoks[yy_i].t_name );
			}
		}
#endif /* YYDEBUG */
		if ( ++yy_ps >= &yys[ YYMAXDEPTH ] )	/* room on stack? */
		{
			yyerror( "yacc stack overflow" );
			YYABORT;
		}
		*yy_ps = yy_state;
		*++yy_pv = yyval;

		/*
		** we have a new state - find out what to do
		*/
	yy_newstate:
		if ( ( yy_n = yypact[ yy_state ] ) <= YYFLAG )
			goto yydefault;		/* simple state */
#if YYDEBUG
		/*
		** if debugging, need to mark whether new token grabbed
		*/
		yytmp = yychar < 0;
#endif
		if ( ( yychar < 0 ) && ( ( yychar = yylex() ) < 0 ) )
			yychar = 0;		/* reached EOF */
#if YYDEBUG
		if ( yydebug && yytmp )
		{
			register int yy_i;

			printf( "Received token " );
			if ( yychar == 0 )
				printf( "end-of-file\n" );
			else if ( yychar < 0 )
				printf( "-none-\n" );
			else
			{
				for ( yy_i = 0; yytoks[yy_i].t_val >= 0;
					yy_i++ )
				{
					if ( yytoks[yy_i].t_val == yychar )
						break;
				}
				printf( "%s\n", yytoks[yy_i].t_name );
			}
		}
#endif /* YYDEBUG */
		if ( ( ( yy_n += yychar ) < 0 ) || ( yy_n >= YYLAST ) )
			goto yydefault;
		if ( yychk[ yy_n = yyact[ yy_n ] ] == yychar )	/*valid shift*/
		{
			yychar = -1;
			yyval = yylval;
			yy_state = yy_n;
			if ( yyerrflag > 0 )
				yyerrflag--;
			goto yy_stack;
		}

	yydefault:
		if ( ( yy_n = yydef[ yy_state ] ) == -2 )
		{
#if YYDEBUG
			yytmp = yychar < 0;
#endif
			if ( ( yychar < 0 ) && ( ( yychar = yylex() ) < 0 ) )
				yychar = 0;		/* reached EOF */
#if YYDEBUG
			if ( yydebug && yytmp )
			{
				register int yy_i;

				printf( "Received token " );
				if ( yychar == 0 )
					printf( "end-of-file\n" );
				else if ( yychar < 0 )
					printf( "-none-\n" );
				else
				{
					for ( yy_i = 0;
						yytoks[yy_i].t_val >= 0;
						yy_i++ )
					{
						if ( yytoks[yy_i].t_val
							== yychar )
						{
							break;
						}
					}
					printf( "%s\n", yytoks[yy_i].t_name );
				}
			}
#endif /* YYDEBUG */
			/*
			** look through exception table
			*/
			{
				register int *yyxi = yyexca;

				while ( ( *yyxi != -1 ) ||
					( yyxi[1] != yy_state ) )
				{
					yyxi += 2;
				}
				while ( ( *(yyxi += 2) >= 0 ) &&
					( *yyxi != yychar ) )
					;
				if ( ( yy_n = yyxi[1] ) < 0 )
					YYACCEPT;
			}
		}

		/*
		** check for syntax error
		*/
		if ( yy_n == 0 )	/* have an error */
		{
			/* no worry about speed here! */
			switch ( yyerrflag )
			{
			case 0:		/* new error */
				yyerror( "syntax error" );
				goto skip_init;
			yyerrlab:
				/*
				** get globals into registers.
				** we have a user generated syntax type error
				*/
				yy_pv = yypv;
				yy_ps = yyps;
				yy_state = yystate;
				yynerrs++;
			skip_init:
			case 1:
			case 2:		/* incompletely recovered error */
					/* try again... */
				yyerrflag = 3;
				/*
				** find state where "error" is a legal
				** shift action
				*/
				while ( yy_ps >= yys )
				{
					yy_n = yypact[ *yy_ps ] + YYERRCODE;
					if ( yy_n >= 0 && yy_n < YYLAST &&
						yychk[yyact[yy_n]] == YYERRCODE)					{
						/*
						** simulate shift of "error"
						*/
						yy_state = yyact[ yy_n ];
						goto yy_stack;
					}
					/*
					** current state has no shift on
					** "error", pop stack
					*/
#if YYDEBUG
#	define _POP_ "Error recovery pops state %d, uncovers state %d\n"
					if ( yydebug )
						printf( _POP_, *yy_ps,
							yy_ps[-1] );
#	undef _POP_
#endif
					yy_ps--;
					yy_pv--;
				}
				/*
				** there is no state on stack with "error" as
				** a valid shift.  give up.
				*/
				YYABORT;
			case 3:		/* no shift yet; eat a token */
#if YYDEBUG
				/*
				** if debugging, look up token in list of
				** pairs.  0 and negative shouldn't occur,
				** but since timing doesn't matter when
				** debugging, it doesn't hurt to leave the
				** tests here.
				*/
				if ( yydebug )
				{
					register int yy_i;

					printf( "Error recovery discards " );
					if ( yychar == 0 )
						printf( "token end-of-file\n" );
					else if ( yychar < 0 )
						printf( "token -none-\n" );
					else
					{
						for ( yy_i = 0;
							yytoks[yy_i].t_val >= 0;
							yy_i++ )
						{
							if ( yytoks[yy_i].t_val
								== yychar )
							{
								break;
							}
						}
						printf( "token %s\n",
							yytoks[yy_i].t_name );
					}
				}
#endif /* YYDEBUG */
				if ( yychar == 0 )	/* reached EOF. quit */
					YYABORT;
				yychar = -1;
				goto yy_newstate;
			}
		}/* end if ( yy_n == 0 ) */
		/*
		** reduction by production yy_n
		** put stack tops, etc. so things right after switch
		*/
#if YYDEBUG
		/*
		** if debugging, print the string that is the user's
		** specification of the reduction which is just about
		** to be done.
		*/
		if ( yydebug )
			printf( "Reduce by (%d) \"%s\"\n",
				yy_n, yyreds[ yy_n ] );
#endif
		yytmp = yy_n;			/* value to switch over */
		yypvt = yy_pv;			/* $vars top of value stack */
		/*
		** Look in goto table for next state
		** Sorry about using yy_state here as temporary
		** register variable, but why not, if it works...
		** If yyr2[ yy_n ] doesn't have the low order bit
		** set, then there is no action to be done for
		** this reduction.  So, no saving & unsaving of
		** registers done.  The only difference between the
		** code just after the if and the body of the if is
		** the goto yy_stack in the body.  This way the test
		** can be made before the choice of what to do is needed.
		*/
		{
			/* length of production doubled with extra bit */
			register int yy_len = yyr2[ yy_n ];

			if ( !( yy_len & 01 ) )
			{
				yy_len >>= 1;
				yyval = ( yy_pv -= yy_len )[1];	/* $$ = $1 */
				yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] +
					*( yy_ps -= yy_len ) + 1;
				if ( yy_state >= YYLAST ||
					yychk[ yy_state =
					yyact[ yy_state ] ] != -yy_n )
				{
					yy_state = yyact[ yypgo[ yy_n ] ];
				}
				goto yy_stack;
			}
			yy_len >>= 1;
			yyval = ( yy_pv -= yy_len )[1];	/* $$ = $1 */
			yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] +
				*( yy_ps -= yy_len ) + 1;
			if ( yy_state >= YYLAST ||
				yychk[ yy_state = yyact[ yy_state ] ] != -yy_n )
			{
				yy_state = yyact[ yypgo[ yy_n ] ];
			}
		}
					/* save until reenter driver code */
		yystate = yy_state;
		yyps = yy_ps;
		yypv = yy_pv;
	}
	/*
	** code supplied by user is placed in this switch
	*/
	switch( yytmp )
	{
		
case 1:
# line 343 "gram.y"
{	return yypvt[-0].i; } break;
case 2:
# line 345 "gram.y"
{	return 1; } break;
case 3:
# line 347 "gram.y"
{	return 0; } break;
case 4:
# line 351 "gram.y"
{	modified_tn = 0; if (yypvt[-0].pn==0) yyval.i = 1; } break;
case 5:
# line 353 "gram.y"
{	goto mod; } break;
case 6:
# line 355 "gram.y"
{	goto mod; } break;
case 7:
# line 357 "gram.y"
{ mod:	if (modified_tn) {
					restore();
					modified_tn = 0;
				}
			} break;
case 8:
# line 363 "gram.y"
{	Pname n = new name(make_name('A'));
				n->tp = new basetype(ASM,0);
				Pbase(n->tp)->b_name = Pname(yypvt[-2].s);
				yyval.p = n;
			} break;
case 9:
# line 371 "gram.y"
{	Pname n = yypvt[-1].pn;
				if (n==0 || n->tp==0) {
					error("TX for%n",n);
					yyval.p = Ndata(defa_type,yypvt[-1].p);
				}
				switch (n->tp->base) {
				case FCT:
					yyval.p = Nfct(defa_type,n,0);
					break;
				default:
					error("TX for%n",n);
					yyval.p = Ndata(defa_type,yypvt[-1].p);
				}
			} break;
case 10:
# line 389 "gram.y"
{	Pname n = Nfct(yypvt[-4].p,yypvt[-3].p,yypvt[-0].p);
				Fargdcl(n->tp,Nunlist(yypvt[-2].p),n);
				Finit(n->tp) = yypvt[-1].pn;
				yyval.p = n;
			} break;
case 11:
# line 397 "gram.y"
{	Pname n = Nfct(defa_type,yypvt[-3].p,yypvt[-0].p);
				Fargdcl(n->tp,Nunlist(yypvt[-2].p),n);
				Finit(n->tp) = yypvt[-1].pn;
				yyval.p = n;
			} break;
case 12:
# line 405 "gram.y"
{	yyval.p = yypvt[-0].p; } break;
case 13:
# line 407 "gram.y"
{	yyval.p = 0; } break;
case 15:
# line 412 "gram.y"
{	yyval.pn = yypvt[-0].pn;  yyval.pn->n_list = yypvt[-2].pn; } break;
case 16:
# line 416 "gram.y"
{	yyval.pn = new name;
				yyval.pn->n_initializer = yypvt[-1].pe;
			} break;
case 17:
# line 420 "gram.y"
{	yyval.pn = yypvt[-3].pn;
				yyval.pn->n_initializer = yypvt[-1].pe;
			} break;
case 18:
# line 431 "gram.y"
{	if (yypvt[-0].pn == 0)
					error("badAD");
				else if (yypvt[-0].pn->tp->base == FCT)
					error("FD inAL (%n)",yypvt[-0].pn);
				else if (yypvt[-1].p)
					Nadd_list(yypvt[-1].p,yypvt[-0].p);
				else
					yyval.p = nlistN(yypvt[-0].p);
			} break;
case 19:
# line 441 "gram.y"
{	yyval.p = 0; } break;
case 21:
# line 446 "gram.y"
{	yyval.p = yypvt[-2].pn;
				Ntype(yyval.p) = fieldN(yypvt[-0].pe);
		 	} break;
case 22:
# line 450 "gram.y"
{	yyval.p = new name;
				Ntype(yyval.p) = fieldN(yypvt[-0].pe);
			} break;
case 23:
# line 454 "gram.y"
{	yypvt[-2].pn->n_initializer = yypvt[-0].pe; } break;
case 24:
# line 458 "gram.y"
{	if (yypvt[-0].p) yyval.p = nlistN(yypvt[-0].p); } break;
case 25:
# line 460 "gram.y"
{	if (yypvt[-2].p)
					if (yypvt[-0].p)
						Nadd(yypvt[-2].p,yypvt[-0].p);
					else
						error("DL syntax");
				else {
					if (yypvt[-0].p) yyval.p = nlistN(yypvt[-0].p);
					error("DL syntax");
				}
			} break;
case 26:
# line 473 "gram.y"
{	yyval.p = Ndata(yypvt[-2].p,Nunlist(yypvt[-1].p)); } break;
case 27:
# line 475 "gram.y"
{	yyval.p = yypvt[-1].pb->aggr(); } break;
case 28:
# line 480 "gram.y"
{	yyval.p = new basetype(yypvt[-0].t,0); } break;
case 29:
# line 482 "gram.y"
{	yyval.p = new basetype(TYPE,yypvt[-0].pn); } break;
case 33:
# line 489 "gram.y"
{	yyval.p = yypvt[-1].pb->type_adj(yypvt[-0].t); } break;
case 34:
# line 491 "gram.y"
{	yyval.p = yypvt[-1].pb->name_adj(yypvt[-0].pn); } break;
case 35:
# line 493 "gram.y"
{	yyval.p = yypvt[-1].pb->base_adj(yypvt[-0].pb); } break;
case 36:
# line 495 "gram.y"
{	yyval.p = yypvt[-1].pb->base_adj(yypvt[-0].pb); } break;
case 37:
# line 505 "gram.y"
{	yyval.p = end_enum(0,yypvt[-1].pn); } break;
case 38:
# line 507 "gram.y"
{	yyval.p = end_enum(yypvt[-3].pn,yypvt[-1].pn); } break;
case 39:
# line 511 "gram.y"
{	if (yypvt[-0].p) yyval.p = nlistN(yypvt[-0].p); } break;
case 40:
# line 513 "gram.y"
{	if( yypvt[-0].p) if (yypvt[-2].p) Nadd(yypvt[-2].p,yypvt[-0].p); else yyval.p = nlistN(yypvt[-0].p); } break;
case 41:
# line 517 "gram.y"
{	yyval.p = yypvt[-0].pn; Ntype(yyval.p) = moe_type; } break;
case 42:
# line 519 "gram.y"
{	yyval.p = yypvt[-2].pn;
				Ntype(yyval.p) = moe_type;
				yyval.pn->n_initializer = yypvt[-0].pe;
			} break;
case 43:
# line 524 "gram.y"
{	yyval.p = 0; } break;
case 44:
# line 529 "gram.y"
{	end_cl(); } break;
case 45:
# line 531 "gram.y"
{	end_cl();
				error("`;' or declaratorX afterCD");
				lex_unget(yypvt[-0].t);
				/* lex_unget($4); but only one unget, sorry */
			 } break;
case 46:
# line 539 "gram.y"
{	yyval.p = start_cl(yypvt[-1].t,0,0); } break;
case 47:
# line 541 "gram.y"
{	yyval.p = start_cl(yypvt[-2].t,yypvt[-1].pn,0); } break;
case 48:
# line 543 "gram.y"
{	yyval.p = start_cl(yypvt[-4].t,yypvt[-3].pn,yypvt[-1].pn);
				if (yypvt[-4].t == STRUCT) ccl->pubbase = 1;
			} break;
case 49:
# line 547 "gram.y"
{	yyval.p = start_cl(yypvt[-5].t,yypvt[-4].pn,yypvt[-1].pn);
				ccl->pubbase = 1;
			} break;
case 50:
# line 553 "gram.y"
{ yyval.p = yypvt[-0].pn; } break;
case 52:
# line 558 "gram.y"
{	Pname n = Nunlist(yypvt[-0].p);
				if (ccl->is_simple())
					ccl->pubmem = n;
				else
					ccl->privmem = n;
				yyval.p = 0;
			} break;
case 53:
# line 566 "gram.y"
{	error("``:'' missing after ``public''");
				ccl->pubmem = Nunlist(yypvt[-0].p);
				TOK t = ccl->is_simple();
				if (t) error("public in%k",t);
				ccl->privmem = Nunlist(yypvt[-2].p);
				yyval.p = 0;
			} break;
case 54:
# line 574 "gram.y"
{	ccl->pubmem = Nunlist(yypvt[-0].p);
				TOK t = ccl->is_simple();
				if (t) error("public in%k",t);
				ccl->privmem = Nunlist(yypvt[-3].p);
				yyval.p = 0;
			 } break;
case 55:
# line 583 "gram.y"
{	if (yypvt[-0].p) if (yypvt[-1].p) Nadd_list(yypvt[-1].p,yypvt[-0].p); else yyval.p = nlistN(yypvt[-0].p); } break;
case 56:
# line 585 "gram.y"
{	yyval.p = 0; } break;
case 63:
# line 595 "gram.y"
{	Pname n = Ncopy(yypvt[-1].p);
				n->n_qualifier = (Pname)yypvt[-2].p;
				n->n_list = ccl->pubdef;
				ccl->pubdef = n;
				yyval.p = 0;
			} break;
case 64:
# line 619 "gram.y"
{	yyval.p = yypvt[-0].pn; } break;
case 65:
# line 621 "gram.y"
{	yyval.p = Ncopy(yypvt[-0].p); yyval.pn->n_oper = DTOR; } break;
case 66:
# line 623 "gram.y"
{	yyval.p = new name(oper_name(yypvt[-0].t));
				yyval.pn->n_oper = yypvt[-0].t;
			} break;
case 67:
# line 627 "gram.y"
{	Pname n = yypvt[-0].pn;
				n->string = "_type";
				n->n_oper = TYPE;
				n->n_initializer = (Pexpr)n->tp;
				n->tp = 0;
				yyval.p = n;
			} break;
case 80:
# line 648 "gram.y"
{	yyval.t = CALL; } break;
case 81:
# line 649 "gram.y"
{	yyval.t = DEREF; } break;
case 87:
# line 655 "gram.y"
{	yyval.t = NEW; } break;
case 88:
# line 656 "gram.y"
{	yyval.t = DELETE; } break;
case 91:
# line 662 "gram.y"
{	error("CNs do not nest"); } break;
case 92:
# line 664 "gram.y"
{	error("CNs do not nest"); } break;
case 93:
# line 668 "gram.y"
{	Freturns(yypvt[-0].p) = Ntype(yypvt[-1].p);
				Ntype(yypvt[-1].p) = (Ptype)yypvt[-0].p;
			} break;
case 94:
# line 672 "gram.y"
{	Pname n = (Pname)yypvt[-1].p;
				yyval.p = Ncopy(n);
				if (ccl && strcmp(n->string,ccl->string)) Nhide(n);
				yyval.pn->n_oper = TNAME;
				Freturns(yypvt[-0].p) = Ntype(yyval.p);
				Ntype(yyval.p) = (Ptype)yypvt[-0].p;
			} break;
case 95:
# line 684 "gram.y"
{	TOK k = 1;
				Pname l = yypvt[-1].pn;
				if (fct_void && l==0) k = 0;
				Ntype(yypvt[-3].p) = fctN(Ntype(yypvt[-3].p),l,k);
			} break;
case 96:
# line 690 "gram.y"
{	TOK k = 1;
				Pname l = yypvt[-1].pn;
				if (fct_void && l==0) k = 0;
				yyval.p = Ncopy(yypvt[-3].p);
				yyval.pn->n_oper = TNAME;
				Ntype(yyval.p) = fctN(0,l,k);
			} break;
case 98:
# line 699 "gram.y"
{	yyval.p = Ncopy(yypvt[-0].p);
				yyval.pn->n_qualifier = yypvt[-2].pn;
			} break;
case 99:
# line 703 "gram.y"
{	yyval.p = yypvt[-0].p;
				set_scope(yypvt[-1].pn);
				yyval.pn->n_qualifier = yypvt[-1].pn;
			} break;
case 100:
# line 708 "gram.y"
{	yyval.p = Ncopy(yypvt[-0].p);
				set_scope(yypvt[-1].pn);
				yyval.pn->n_oper = TNAME;
				yyval.pn->n_qualifier = yypvt[-1].pn;
			} break;
case 101:
# line 714 "gram.y"
{	Ptyp(yypvt[-1].p) = Ntype(yypvt[-0].p);
				Ntype(yypvt[-0].p) = (Ptype)yypvt[-1].p;
				yyval.p = yypvt[-0].p;
			} break;
case 102:
# line 719 "gram.y"
{	yyval.p = Ncopy(yypvt[-0].p);
				yyval.pn->n_oper = TNAME;
				Nhide(yypvt[-0].p);
				Ntype(yyval.p) = (Ptype)yypvt[-1].p;
			} break;
case 103:
# line 725 "gram.y"
{	yyval.p = Ncopy(yypvt[-1].p);
				yyval.pn->n_oper = TNAME;
				Nhide(yypvt[-1].p);
				Ntype(yyval.p) = (Ptype)yypvt[-0].p;
			} break;
case 104:
# line 731 "gram.y"
{	Vtype(yypvt[-0].p) = Ntype(yypvt[-1].p);
				Ntype(yypvt[-1].p) = (Ptype)yypvt[-0].p;
			} break;
case 105:
# line 735 "gram.y"
{	Freturns(yypvt[-0].p) = Ntype(yypvt[-2].p);
				Ntype(yypvt[-2].p) = (Ptype)yypvt[-0].p;
				yyval.p = yypvt[-2].p;
			} break;
case 106:
# line 740 "gram.y"
{	Vtype(yypvt[-0].p) = Ntype(yypvt[-2].p);
				Ntype(yypvt[-2].p) = (Ptype)yypvt[-0].p;
				yyval.p = yypvt[-2].p;
			} break;
case 107:
# line 747 "gram.y"
{	yyval.p = yypvt[-0].pn; } break;
case 108:
# line 749 "gram.y"
{	yyval.p = new name; } break;
case 109:
# line 751 "gram.y"
{	Ptyp(yypvt[-1].p) = Ntype(yypvt[-0].p);
				Ntype(yypvt[-0].p) = (Ptype)yypvt[-1].p;
				yyval.p = yypvt[-0].p;
			} break;
case 110:
# line 756 "gram.y"
{	Vtype(yypvt[-0].p) = Ntype(yypvt[-1].p);
				Ntype(yypvt[-1].p) = (Ptype)yypvt[-0].p;
			} break;
case 111:
# line 760 "gram.y"
{	Freturns(yypvt[-0].p) = Ntype(yypvt[-2].p);
				Ntype(yypvt[-2].p) = (Ptype)yypvt[-0].p;
				yyval.p = yypvt[-2].p;
			} break;
case 112:
# line 765 "gram.y"
{	Vtype(yypvt[-0].p) = Ntype(yypvt[-2].p);
				Ntype(yypvt[-2].p) = (Ptype)yypvt[-0].p;
				yyval.p = yypvt[-2].p;
			} break;
case 113:
# line 772 "gram.y"
{	yyval.p = new name; } break;
case 114:
# line 774 "gram.y"
{	Ptyp(yypvt[-1].p) = Ntype(yypvt[-0].p);
				Ntype(yypvt[-0].p) = (Ptype)yypvt[-1].p;
				yyval.p = yypvt[-0].p;
			} break;
case 115:
# line 779 "gram.y"
{	Vtype(yypvt[-0].p) = Ntype(yypvt[-1].p);
				Ntype(yypvt[-1].p) = (Ptype)yypvt[-0].p;
			} break;
case 116:
# line 785 "gram.y"
{	yyval.p = new name; } break;
case 117:
# line 787 "gram.y"
{	Ptyp(yypvt[-1].p) = Ntype(yypvt[-0].p);
				Ntype(yypvt[-0].p) = (Ptype)yypvt[-1].p;
				yyval.p = yypvt[-0].p;
			} break;
case 118:
# line 792 "gram.y"
{	Vtype(yypvt[-0].p) = Ntype(yypvt[-1].p);
				Ntype(yypvt[-1].p) = (Ptype)yypvt[-0].p;
			} break;
case 119:
# line 796 "gram.y"
{	Freturns(yypvt[-0].p) = Ntype(yypvt[-2].p);
				Ntype(yypvt[-2].p) = yypvt[-0].pt;
				yyval.p = yypvt[-2].p;
			} break;
case 120:
# line 801 "gram.y"
{	Vtype(yypvt[-0].p) = Ntype(yypvt[-2].p);
				Ntype(yypvt[-2].p) = yypvt[-0].pt;
				yyval.p = yypvt[-2].p;
			} break;
case 121:
# line 808 "gram.y"
{	yyval.p = new name; } break;
case 122:
# line 810 "gram.y"
{	Ptyp(yypvt[-1].p) = Ntype(yypvt[-0].p);
				Ntype(yypvt[-0].p) = (Ptype)yypvt[-1].p;
				yyval.p = yypvt[-0].p;
			} break;
case 123:
# line 821 "gram.y"
{	if (yypvt[-0].p)
					if (yypvt[-1].p)
						Sadd(yypvt[-1].p,yypvt[-0].p);
					else {
						yyval.p = slistN(yypvt[-0].p);
						stmt_seen = 1;
					}
			} break;
case 124:
# line 830 "gram.y"
{	if (yypvt[-0].p) {
					yyval.p = slistN(yypvt[-0].p);
					stmt_seen = 1;
				}
			} break;
case 125:
# line 838 "gram.y"
{	yyval.p = yypvt[-1].p;
				if (yyval.pe == dummy) error("empty condition");
				stmt_seen = 1;
			} break;
case 126:
# line 845 "gram.y"
{	cd_vec[cdi] = cd;
				stmt_vec[cdi] = stmt_seen;
				tn_vec[cdi++] = modified_tn;
				cd = 0;
				stmt_seen = 0;
				modified_tn = 0;
			} break;
case 127:
# line 853 "gram.y"
{	Pname n = Nunlist(cd);
				Pstmt ss = Sunlist(yypvt[-1].p);
				yyval.p = new block(yypvt[-3].l,n,ss);
				if (modified_tn) restore();
				cd = cd_vec[--cdi];
				stmt_seen = stmt_vec[cdi];
				modified_tn = tn_vec[cdi];
				if (cdi < 0) error('i',"block level(%d)",cdi);
			} break;
case 128:
# line 863 "gram.y"
{	yyval.p = new block(yypvt[-1].l,0,0); } break;
case 129:
# line 865 "gram.y"
{	yyval.p = new block(yypvt[-2].l,0,0); } break;
case 130:
# line 869 "gram.y"
{	yyval.p = new estmt(SM,curloc,yypvt[-0].pe,0);	} break;
case 131:
# line 871 "gram.y"
{	yyval.p = new stmt(BREAK,yypvt[-0].l,0); } break;
case 132:
# line 873 "gram.y"
{	yyval.p = new stmt(CONTINUE,yypvt[-0].l,0); } break;
case 133:
# line 875 "gram.y"
{	yyval.p = new estmt(RETURN,yypvt[-1].l,yypvt[-0].pe,0); } break;
case 134:
# line 877 "gram.y"
{	yyval.p = new lstmt(GOTO,yypvt[-1].l,yypvt[-0].pn,0); } break;
case 135:
# line 878 "gram.y"
{ stmt_seen=1; } break;
case 136:
# line 879 "gram.y"
{	yyval.p = new estmt(DO,yypvt[-4].l,yypvt[-0].pe,yypvt[-2].ps); } break;
case 138:
# line 884 "gram.y"
{	
				if (stmt_seen)
					yyval.p = new estmt(ASM,curloc,(Pexpr)yypvt[-2].s,0);
				else {
					Pname n = new name(make_name('A'));
					n->tp = new basetype(ASM,(Pname)yypvt[-2].s);
					if (cd) Nadd_list(cd,n); else cd=(Pname)nlistN(n);
					yyval.p = 0;
				}
			} break;
case 139:
# line 897 "gram.y"
{
				if (yypvt[-0].pn)
				if (stmt_seen) {
					Pname n = yypvt[-0].pn;
					yyval.p = new block(n->where,n,0);
					yyval.ps->base = DCL;
				}
				else {
					if (cd) Nadd_list(cd,yypvt[-0].p); else cd = (Pname)nlistN(yypvt[-0].p);
					yyval.p = 0;
				}
			} break;
case 140:
# line 910 "gram.y"
{	Pname n = Pname(yypvt[-0].p);
				lex_unget(RC);
				error(&n->where,"%n's definition is nested (did you forget a ``}''?)",n);
				if (cd) Nadd_list(cd,yypvt[-0].p); else cd = (Pname)nlistN(yypvt[-0].p);
				yyval.p = 0;
			} break;
case 142:
# line 918 "gram.y"
{	yyval.p = new ifstmt(yypvt[-2].l,yypvt[-1].pe,yypvt[-0].ps,0); } break;
case 143:
# line 920 "gram.y"
{	yyval.p = new ifstmt(yypvt[-4].l,yypvt[-3].pe,yypvt[-2].ps,yypvt[-0].ps); } break;
case 144:
# line 922 "gram.y"
{	yyval.p = new estmt(WHILE,yypvt[-2].l,yypvt[-1].pe,yypvt[-0].ps); } break;
case 145:
# line 923 "gram.y"
{ stmt_seen=1; } break;
case 146:
# line 924 "gram.y"
{	yyval.p = new forstmt(yypvt[-8].l,yypvt[-5].ps,yypvt[-4].pe,yypvt[-2].pe,yypvt[-0].ps); } break;
case 147:
# line 926 "gram.y"
{	yyval.p = new estmt(SWITCH,yypvt[-2].l,yypvt[-1].pe,yypvt[-0].ps); } break;
case 148:
# line 927 "gram.y"
{ yyval.p = yypvt[-1].pn; stmt_seen=1; } break;
case 149:
# line 928 "gram.y"
{	Pname n = yypvt[-1].pn;
				yyval.p = new lstmt(LABEL,n->where,n,yypvt[-0].ps);
			} break;
case 150:
# line 931 "gram.y"
{ stmt_seen=1; } break;
case 151:
# line 932 "gram.y"
{	if (yypvt[-2].pe == dummy) error("empty case label");
				yyval.p = new estmt(CASE,yypvt[-4].l,yypvt[-2].pe,yypvt[-0].ps);
			} break;
case 152:
# line 935 "gram.y"
{ stmt_seen=1; } break;
case 153:
# line 936 "gram.y"
{	yyval.p = new stmt(DEFAULT,yypvt[-3].l,yypvt[-0].ps); } break;
case 154:
# line 945 "gram.y"
{	Pexpr e = Eunlist(yypvt[-0].p);
				while (e && e->e1==dummy) {
					if (e->e2) error("EX inEL");
					delete e;
					e = e->e2;
				}
				yyval.p = e;
			} break;
case 155:
# line 955 "gram.y"
{	Pexpr e = new expr(ELIST,yypvt[-0].pe,0);
				yyval.p = (PP)new elist(e);

		} break;
case 156:
# line 959 "gram.y"
{	Pexpr e = new expr(ELIST,yypvt[-0].pe,0);
				Eadd(yypvt[-2].p,e);
			} break;
case 158:
# line 966 "gram.y"
{	Pexpr e;
				if (yypvt[-1].p)
					e = yypvt[-1].pe;
				else
					e = new expr(ELIST,dummy,0);
				yyval.p = new expr(ILIST,e,0);
			} break;
case 159:
# line 978 "gram.y"
{	binop:	yyval.p = new expr(yypvt[-1].t,yypvt[-2].pe,yypvt[-0].pe); } break;
case 160:
# line 979 "gram.y"
{	goto binop; } break;
case 161:
# line 980 "gram.y"
{	goto binop; } break;
case 162:
# line 981 "gram.y"
{	goto binop; } break;
case 163:
# line 982 "gram.y"
{	goto binop; } break;
case 164:
# line 983 "gram.y"
{	goto binop; } break;
case 165:
# line 984 "gram.y"
{	goto binop; } break;
case 166:
# line 985 "gram.y"
{ 	goto binop; } break;
case 167:
# line 986 "gram.y"
{	goto binop; } break;
case 168:
# line 987 "gram.y"
{	goto binop; } break;
case 169:
# line 988 "gram.y"
{	goto binop; } break;
case 170:
# line 989 "gram.y"
{	goto binop; } break;
case 171:
# line 990 "gram.y"
{	goto binop; } break;
case 172:
# line 991 "gram.y"
{	goto binop; } break;
case 173:
# line 992 "gram.y"
{	goto binop; } break;
case 174:
# line 994 "gram.y"
{	yyval.p = new qexpr(yypvt[-4].pe,yypvt[-2].pe,yypvt[-0].pe); } break;
case 175:
# line 996 "gram.y"
{	yyval.p = new expr(DELETE,yypvt[-0].pe,0); } break;
case 176:
# line 998 "gram.y"
{	yyval.p = new expr(DELETE,yypvt[-0].pe,yypvt[-2].pe); } break;
case 178:
# line 1001 "gram.y"
{	yyval.p = dummy; } break;
case 179:
# line 1005 "gram.y"
{	TOK b = yypvt[-3].t;
				Ptype t;
				switch (b) {
				case CHAR:	t = char_type; break;
				case SHORT:	t = short_type; break;
				case INT:	t = int_type; break;
				case LONG:	t = long_type; break;
				case UNSIGNED:	t = uint_type; break;
				case FLOAT:	t = float_type; break;
				case DOUBLE:	t = double_type; break;
				case VOID:	t = void_type; break;
				default:
					error("illegal constructor:%k",b);
					t = int_type;
				}
				yyval.p = new texpr(VALUE,t,yypvt[-1].pe);
			} break;
case 180:
# line 1023 "gram.y"
{	Ptype t = Ntype(yypvt[-3].p);
				yyval.p = new texpr(VALUE,t,yypvt[-1].pe);
			} break;
case 181:
# line 1027 "gram.y"
{	Ptype t = Ntype(yypvt[-0].p); yyval.p = new texpr(NEW,t,0); } break;
case 182:
# line 1029 "gram.y"
{	Ptype t = Ntype(yypvt[-1].p); yyval.p = new texpr(NEW,t,0); } break;
case 183:
# line 1031 "gram.y"
{	yyval.p = new expr(yypvt[-0].t,yypvt[-1].pe,0); } break;
case 184:
# line 1033 "gram.y"
{	yyval.p = new texpr(CAST,Ntype(yypvt[-2].p),yypvt[-0].pe); } break;
case 185:
# line 1035 "gram.y"
{	yyval.p = new expr(DEREF,yypvt[-0].pe,0); } break;
case 186:
# line 1037 "gram.y"
{	yyval.p = new expr(ADDROF,0,yypvt[-0].pe); } break;
case 187:
# line 1039 "gram.y"
{	yyval.p = new expr(UMINUS,0,yypvt[-0].pe); } break;
case 188:
# line 1041 "gram.y"
{	yyval.p = new expr(UPLUS,0,yypvt[-0].pe); } break;
case 189:
# line 1043 "gram.y"
{	yyval.p = new expr(NOT,0,yypvt[-0].pe); } break;
case 190:
# line 1045 "gram.y"
{	yyval.p = new expr(COMPL,0,yypvt[-0].pe); } break;
case 191:
# line 1047 "gram.y"
{	yyval.p = new expr(yypvt[-1].t,0,yypvt[-0].pe); } break;
case 192:
# line 1049 "gram.y"
{	yyval.p = new texpr(SIZEOF,0,yypvt[-0].pe); } break;
case 193:
# line 1051 "gram.y"
{	yyval.p = new texpr(SIZEOF,Ntype(yypvt[-1].p),0); } break;
case 194:
# line 1053 "gram.y"
{	yyval.p = new expr(DEREF,yypvt[-3].pe,yypvt[-1].pe); } break;
case 195:
# line 1055 "gram.y"
{	Pexpr ee = yypvt[-1].pe;
				Pexpr e = yypvt[-3].pe;
				if (e->base == NEW)
					e->e1 = ee;
				else
					yyval.p = new call(e,ee);
			} break;
case 196:
# line 1063 "gram.y"
{	yyval.p = new ref(REF,yypvt[-2].pe,yypvt[-0].pn); } break;
case 197:
# line 1065 "gram.y"
{	Pname n = Ncopy(yypvt[-0].p); yyval.p = new ref(REF,yypvt[-2].pe,n); } break;
case 198:
# line 1067 "gram.y"
{	yyval.p = new ref(DOT,yypvt[-2].pe,yypvt[-0].pn); } break;
case 199:
# line 1069 "gram.y"
{	Pname n = Ncopy(yypvt[-0].p); yyval.p = new ref(DOT,yypvt[-2].pe,n); } break;
case 200:
# line 1071 "gram.y"
{	yyval.p = Ncopy(yypvt[-0].p); yyval.pn->n_qualifier = sta_name; } break;
case 202:
# line 1074 "gram.y"
{	yyval.p = yypvt[-1].p; } break;
case 203:
# line 1076 "gram.y"
{	yyval.p = zero; } break;
case 204:
# line 1078 "gram.y"
{	yyval.p = conN(ICON,yypvt[-0].s); } break;
case 205:
# line 1080 "gram.y"
{	yyval.p = conN(FCON,yypvt[-0].s); } break;
case 206:
# line 1082 "gram.y"
{	yyval.p = conN(STRING,yypvt[-0].s); } break;
case 207:
# line 1084 "gram.y"
{	yyval.p = conN(CCON,yypvt[-0].s); } break;
case 208:
# line 1086 "gram.y"
{	yyval.p = conN(THIS,0); } break;
case 209:
# line 1094 "gram.y"
{	yyval.p = yypvt[-0].pn; } break;
case 210:
# line 1096 "gram.y"
{	yyval.p = Ncopy(yypvt[-0].p);
				yyval.pn->n_qualifier = yypvt[-2].pn;
			} break;
case 211:
# line 1100 "gram.y"
{	yyval.p = Ncopy(yypvt[-0].p);
				Pname nx = ktbl->look(yypvt[-2].pn->string,HIDDEN);
				if (nx == 0) error("non-typeN%n before ::",yyval.p);
				yyval.pn->n_qualifier = nx;
			} break;
case 212:
# line 1106 "gram.y"
{	yyval.p = new name(oper_name(yypvt[-0].t));
				yyval.pn->n_oper = yypvt[-0].t;
			} break;
case 213:
# line 1110 "gram.y"
{	yyval.p = new name(oper_name(yypvt[-0].t));
				yyval.pn->n_oper = yypvt[-0].t;
				yyval.pn->n_qualifier = yypvt[-3].pn;
			} break;
case 214:
# line 1115 "gram.y"
{	yyval.p = new name(oper_name(yypvt[-0].t));
				yyval.pn->n_oper = yypvt[-0].t;
				Pname nx = ktbl->look(yypvt[-3].pn->string,HIDDEN);
				if (nx == 0) error("non-typeN%n before ::",yyval.p);
				yyval.pn->n_qualifier = nx;
			} break;
case 215:
# line 1122 "gram.y"
{	Pname n = yypvt[-0].pn;
				static char buf[128];
				buf[0] = '_';
				buf[1] = 'O';
				n->tp->signature(buf+2);
				n->string = buf;
				n->tp = 0;
				yyval.p = n;
			} break;
case 216:
# line 1132 "gram.y"
{	Pname n = yypvt[-0].pn;
				static char buf[128];
				buf[0] = '_';
				buf[1] = 'O';
				n->tp->signature(buf+2);
				n->string = buf;
				n->tp = 0;
				n->n_qualifier = yypvt[-3].pn;
				yyval.p = n;
			} break;
case 217:
# line 1143 "gram.y"
{	Pname n = yypvt[-0].pn;
				static char buf[128];
				buf[0] = '_';
				buf[1] = 'O';
				n->tp->signature(buf+2);
				n->string = buf;
				n->tp = 0;
				Pname nx = ktbl->look(yypvt[-3].pn->string,HIDDEN);
				if (nx == 0) error("non-typeN%n before ::",yyval.p);
				n->n_qualifier = nx;
				yyval.p = n;
			} break;
case 218:
# line 1162 "gram.y"
{	yyval.p = Ncast(yypvt[-1].p,yypvt[-0].p); } break;
case 219:
# line 1166 "gram.y"
{	yyval.p = new basetype(yypvt[-0].t,0); } break;
case 220:
# line 1168 "gram.y"
{	yyval.p = new basetype(TYPE,yypvt[-0].pn); } break;
case 221:
# line 1172 "gram.y"
{	yyval.p = Ncast(yypvt[-1].p,yypvt[-0].p); } break;
case 222:
# line 1176 "gram.y"
{	yyval.p = Ncast(yypvt[-1].p,yypvt[-0].p); } break;
case 223:
# line 1180 "gram.y"
{	yyval.p = Ndata(yypvt[-1].p,yypvt[-0].p); } break;
case 224:
# line 1182 "gram.y"
{	yyval.p = Ndata(yypvt[-3].p,yypvt[-2].p);
				yyval.pn->n_initializer = yypvt[-0].pe;
			} break;
case 225:
# line 1188 "gram.y"
{	TOK k = 1;
				Pname l = yypvt[-1].pn;
			//	if (fct_void && l==0) k = 0;
				yyval.p = fctN(0,Nunlist(l),k);
			} break;
case 226:
# line 1194 "gram.y"
{	TOK k = ELLIPSIS;
				Pname l = yypvt[-2].pn;
			//	if (fct_void && l==0) k = 0;
				yyval.p = fctN(0,Nunlist(l),k);
			} break;
case 227:
# line 1200 "gram.y"
{	TOK k = ELLIPSIS;
				Pname l = yypvt[-3].pn;
			//	if (fct_void && l==0) k = 0;
				yyval.p = fctN(0,Nunlist(l),k);
			} break;
case 228:
# line 1208 "gram.y"
{	if (yypvt[-0].p)
					if (yypvt[-2].p)
						Nadd(yypvt[-2].p,yypvt[-0].p);
					else {
						error("AD syntax");
						yyval.p = nlistN(yypvt[-0].p); 
					}
				else
					error("AD syntax");
			} break;
case 229:
# line 1219 "gram.y"
{	if (yypvt[-0].p) yyval.p = nlistN(yypvt[-0].p); } break;
case 231:
# line 1224 "gram.y"
{	yyval.p = 0; } break;
case 232:
# line 1227 "gram.y"
{	yyval.p = new ptr(PTR,0); } break;
case 233:
# line 1229 "gram.y"
{	yyval.p = new ptr(RPTR,0); } break;
case 234:
# line 1231 "gram.y"
{	TOK c = yypvt[-0].t;
				if (c == CONST)
					yyval.p = new ptr(PTR,0,1);
				else {
					yyval.p = new ptr(PTR,0);
					error("syntax error: *%k",c);
				}
			} break;
case 235:
# line 1240 "gram.y"
{	TOK c = yypvt[-0].t;
				if (c == CONST)
					yyval.p = new ptr(RPTR,0,1);
				else {
					yyval.p = new ptr(RPTR,0);
					error("syntax error: &%k",c);
				}
			} break;
case 236:
# line 1251 "gram.y"
{	Pexpr d = yypvt[-1].pe;
				yyval.p = vecN( (d!=dummy)?d:0 );
			} break;
	}
	goto yystack;		/* reset registers in driver code */
}
« September 2014 »
Su Mo Tu We Th Fr Sa
1 2 3 4 5 6
7 8 9 10 11 12 13
14 15 16 17 18 19 20
21 22 23 24 25 26 27
28 29 30
 

Powered by Plone CMS, the Open Source Content Management System

This site conforms to the following standards: