# line 3 "grammar.y"
#include "datatypes.h"
#include "fmax.h"

static Value result, tmpval1, tmpval2, tmpval3;

extern Tree *MakeTreeNode();
extern Tree *MakeBinaryOp();
extern Tree *MakeTernaryOp();
extern Tree *MakeCommaOp();
extern Tree *MakeUnaryOp();
extern Tree *MakeIntegerNode();
extern Tree *MakeRealNode();
extern Tree *MakeComplexNode();
extern Tree *MakeArrayNode();
extern Tree *MakeVariableNode();
extern Tree *MakeFunctionNode();
extern void ChangeToLValue();
extern TreeList *EmptyTreeList();
extern TreeList *AddToTreeList();
extern void DefineFunction();


# line 28 "grammar.y"
typedef union  { Tree *tree;
	 int i;
	 double d;
	 char *id;
	 TreeList *list; } YYSTYPE;
# define INTEGER 257
# define DISPLAY 258
# define ON 259
# define OFF 260
# define REAL 261
# define IDENT 262
# define STRING 263
# define LPAREN 264
# define RPAREN 265
# define LBRACKET 266
# define RBRACKET 267
# define LCURLY 268
# define RCURLY 269
# define COMMA 270
# define SEMICOLON 271
# define EOL 272
# define DEFINE 273
# define CLEAR 274
# define REPLOT 275
# define QUIT 276
# define PLOT 277
# define SET 278
# define NUMSAMPLES 279
# define TITLE 280
# define XLABEL 281
# define YLABEL 282
# define Y2LABEL 283
# define ASSIGN 284
# define PLUSEQ 285
# define MINUSEQ 286
# define TIMESEQ 287
# define DIVIDEEQ 288
# define MODEQ 289
# define POWEREQ 290
# define LSHIFTEQ 291
# define RSHIFTEQ 292
# define LOREQ 293
# define BOREQ 294
# define XOREQ 295
# define LANDEQ 296
# define BANDEQ 297
# define QUESTION 298
# define COLON 299
# define LOR 300
# define LAND 301
# define BOR 302
# define XOR 303
# define BAND 304
# define EQ 305
# define NE 306
# define LT 307
# define GT 308
# define LE 309
# define GE 310
# define LSHIFT 311
# define RSHIFT 312
# define PLUS 313
# define MINUS 314
# define TIMES 315
# define DIVIDE 316
# define MODULO 317
# define POWER 318
# define CONCAT 319
# define UNARY 320
# define LNOT 321
# define BNOT 322
# define PLUSPLUS 323
# define MINUSMINUS 324
# define PLUSOVER 325
# define MINUSOVER 326
# define MULTOVER 327
# define DIVOVER 328
# define MODOVER 329
# define POWEROVER 330
# define LOROVER 331
# define BOROVER 332
# define XOROVER 333
# define LANDOVER 334
# define BANDOVER 335
# define SIZEOF 336
#define yyclearin yychar = -1
#define yyerrok yyerrflag = 0
extern int yychar;
extern short yyerrflag;
#ifndef YYMAXDEPTH
#define YYMAXDEPTH 150
#endif
YYSTYPE yylval, yyval;
# define YYERRCODE 256

# line 298 "grammar.y"

    
#include "lex.yy.c"

double valueof(v)
Value *v;
{
    if (v->type == integer) return v->i.i;
    else if (v->type == real) return v->r.r;
    else internalerr("valueof: integer or real expected.");
}
    
Tree *MakeTreeNode(n)
int n;
{
    register Tree *t;

    t = (Tree *) malloc(sizeof(Tree) + (n-1)*sizeof(Tree *));
    if (t == NULL) internalerr("Out of memory in MakeTreeNode()");
    return t;
}
    
Tree *MakeBinaryOp(op,t1,t2)
operator op;
Tree *t1,*t2;
{
    register Tree *t;

    t = MakeTreeNode(2);
    t->op = op;
    t->args[0] = t1;
    t->args[1] = t2;
    return t;
}
    
Tree *MakeTernaryOp(t1,t2,t3)
Tree *t1, *t2, *t3;
{
    register Tree *t;

    t = MakeTreeNode(3);
    t->args[0] = t1;
    t->args[1] = t2;
    t->args[2] = t3;
    return t;
}

Tree *MakeCommaOp(first,rest)
Tree *first;
TreeList *rest;
{
    register Tree *t;
    register int i;

    t = MakeTreeNode(rest->n + 1);
    t->op = Comma;
    t->v.i.i = rest->n + 1;
    t->args[0] = first;
    for(i=0; i < rest->n; i++) {
	t->args[i+1] = rest->subtrees[i];
    }
    return t;
}


Tree *MakeUnaryOp(op,t1)
operator op;
Tree *t1;
{
    register Tree *t;

    t = MakeTreeNode(1);
    t->op = op;
    t->args[0] = t1;
    return t;
}

Tree *MakeIntegerNode(i)
int i;
{
    register Tree *t;

    t = MakeTreeNode(0);
    t->op = Pushc;
    t->v.type = integer;
    t->v.i.i = i;
    return t;
}

Tree *MakeRealNode(r)
double r;
{
    register Tree *t;

    t = MakeTreeNode(0);
    t->op = Pushc;
    t->v.type = real;
    t->v.r.r = r;
    return t;
}
    
Tree *MakeComplexNode(a,b)
Value *a,*b;
{
    register Tree *t;

    t = MakeTreeNode(0);
    t->op = Pushc;
    t->v.type = complex;
    if (a->type == integer)
	t->v.c.c.r = (double) a->i.i;
    else if (a->type == real)
	t->v.c.c.r = a->r.r;
    else
	runerr("components of complex number must be integer or real.");
    if (b->type == integer)
	t->v.c.c.i = (double) b->i.i;
    else if (b->type == real)
	t->v.c.c.i = b->r.r;
    else
	runerr("components of complex number must be integer or real.");

    return t;
}

Tree *MakeArrayNode(tl)
TreeList *tl;
{
    register Tree *t;
    register int i;

    t = MakeTreeNode(0);
    t->op = Pushc;
    t->v.type = array;
    t->v.a.maxsize = t->v.a.N = tl->n;
    t->v.a.vals = (Value *) malloc(tl->n * sizeof(Value));
    for(i=0; i < tl->n; i++) {
	t->v.a.vals[i] = *EvalTree(tl->subtrees[i],&tmpval1,NULL);
    }
    return t;
}

Tree *MakeVariableNode(id)
char *id;
{
/* Look up the ident in the symbol table.  If it is not a local var.,
 * then code a Push operation with that symbol as the argument.  If
 * it is a local variable, then do a Pushl operation with the localvar
 * as the argument.
 */

    register Tree *t;
    register Symbol *s;

    s = LookupIdent(id);
    if (s == NULL) s = NewUndefSymbol(id);
    t = MakeTreeNode(0);

    if (s->value.type != localvar) {
	t->op = Push;
	t->v.type = variable;
	t->v.v.s = s;
    }
    else {
	t->op = Pushl;
	t->v = s->value;
    }

    free(id);   /* fix the symbol handing */
    return t;
}

Tree *MakeFunctionNode(func,args)
Tree *func;
TreeList *args;
{
    register Tree *t;
    register int i;

    t = MakeTreeNode(args->n + 1);
    t->op = Call;
    t->v.i.i = args->n;
    t->args[0] = func;
    for(i=0; i<args->n; i++)
	t->args[i+1] = args->subtrees[i];
    return t;
}

void ChangeToLValue(t)
Tree *t;
{
    if (t->op == Push) {
	t->op = Pushlval;
    }
    else if (t->op == Index) {
	t->op = Indexlval;
	ChangeToLValue(t->args[0]);
    }
    else
	yyerror("Bad left-hand side of assignment.");
}

TreeList *EmptyTreeList()
{
    register TreeList *tl;

    tl = (TreeList *)malloc(sizeof(TreeList) + 7*sizeof(Tree *));
    tl->n = 0;
    tl->maxn = 8;
    return tl;
}

TreeList *AddToTreeList(tl,t)
TreeList *tl;
Tree *t;
{
    if (tl->n == tl->maxn) {
	realloc(tl,sizeof(TreeList) + (tl->maxn+tl->maxn-1)*sizeof(Tree *));
	tl->maxn *= 2;
    }

    tl->subtrees[tl->n++] = t;
    return tl;
}

void DefineFunction(name,numprms,body)
char *name;
int numprms;
Tree *body;
{
    Symbol *s;

    s = LookupIdent(name);
    if (s == NULL) s = NewUndefSymbol(name);

    s->value.type = deffunc;
    s->value.df.numprms = numprms;
    s->value.df.body = body;
    free(name);  /* fix up the symbol handling so I don't have to do this */
}

Tree *MakePartition(v1,v2,v3)
Value *v1, *v2, *v3;
{
    double start, step, stop;
    Tree *t;
    int i;

    if (!(isarray(v1) || isarray(v2) || isarray(v3))) {
	if (!(isintorreal(v1) && isintorreal(v2) && isintorreal(v3)))
         runerr("Integers, reals, or arrays expected for partition operator.");

	start = valueof(v1);
	step = valueof(v2);
	stop = valueof(v3);
	if (step == 0.0) runerr("Cannot partition with a step of zero.");
	
	t = MakeTreeNode(0);
	t->op = Pushc;
	t->v.type = array;
	t->v.a.N =  (stop > start)?(int)floor((stop-start)/step + 1):0;
	t->v.a.maxsize = t->v.a.N;
	t->v.a.vals = (Value *)malloc(sizeof(Value) * t->v.a.N);
	
	/* Work around a vax  bug to ensure that it */
	/* goes through the loop the last time (when start = stop */
	for (i=0; start < stop+step; start += step, i++) {
	    t->v.a.vals[i].type =  real;
	    t->v.a.vals[i].r.r = start;
       }

	return t;
    }
    else {
	internalerr("arrays not supported yet.");
    }
}
       
short yyexca[] ={
-1, 1,
	0, -1,
	-2, 0,
	};
# define YYNPROD 92
# define YYLAST 844
short yyact[]={

  39,  81, 169,  82,  40,  38, 144,  42,  57,  43,
 166,  41,  64,  78,   6,   7,   8,   9, 146,  10,
  11,  16, 165,  12,  13,  14,  15,  39, 152,  55,
  50,  40,  38,  48,  42, 109,  43, 143,  41,  75,
  76,  67,  68,  69,  70,  71,  72,  65,  66,  59,
  60,  61,  62,  63,  64,  78,  21,  20,  85,  54,
  83,  84,   6,   7,  25,  24,  22,  23,  26,  27,
  28,  29,  30,  31,  32,  33,  34,  35,  36,  37,
  53,  52,  51,  21,  20, 112, 170, 159,  47,  49,
 164,  25,  24,  22,  23,  26,  27,  28,  29,  30,
  31,  32,  33,  34,  35,  36,  37,  80,  69,  70,
  71,  72,  65,  66,  59,  60,  61,  62,  63,  64,
  78,  79, 163,  74,  73,  77,  75,  76,  67,  68,
  69,  70,  71,  72,  65,  66,  59,  60,  61,  62,
  63,  64,  78, 148, 114, 115, 149,  65,  66,  59,
  60,  61,  62,  63,  64,  78, 108,   2, 147,  44,
  80,  59,  60,  61,  62,  63,  64,  78,  61,  62,
  63,  64,  78,   5,  79, 158,  74,  73,  77,  75,
  76,  67,  68,  69,  70,  71,  72,  65,  66,  59,
  60,  61,  62,  63,  64,  78, 171,  76,  67,  68,
  69,  70,  71,  72,  65,  66,  59,  60,  61,  62,
  63,  64,  78,  80,   3, 116, 105, 157, 139,  45,
  46, 106,   4,  56, 113,  19,   1,  79,   0,  74,
  73,  77,  75,  76,  67,  68,  69,  70,  71,  72,
  65,  66,  59,  60,  61,  62,  63,  64,  78, 167,
  67,  68,  69,  70,  71,  72,  65,  66,  59,  60,
  61,  62,  63,  64,  78,   0,  80,   0,   0,   0,
   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  79,   0,  74,  73,  77,  75,  76,  67,  68,  69,
  70,  71,  72,  65,  66,  59,  60,  61,  62,  63,
  64,  78, 162, 140,   0,   0,   0,   0,   0,   0,
   0,   0,   0,   0,   0,   0,   0,  80,   0,   0,
   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
   0,  79,   0,  74,  73,  77,  75,  76,  67,  68,
  69,  70,  71,  72,  65,  66,  59,  60,  61,  62,
  63,  64,  78, 153,   0,   0,   0,   0,   0,   0,
   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  80,   0,   0,   0,   0,   0,   0,   0,   0,   0,
   0,   0,   0,   0,  79,   0,  74,  73,  77,  75,
  76,  67,  68,  69,  70,  71,  72,  65,  66,  59,
  60,  61,  62,  63,  64,  78,  80,   0,   0,   0,
   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  79, 150,  74,  73,  77,  75,  76,  67,  68,  69,
  70,  71,  72,  65,  66,  59,  60,  61,  62,  63,
  64,  78,  80,   0,   0,   0,   0,   0,   0,   0,
   0,   0,   0,   0,   0,   0,  79, 145,  74,  73,
  77,  75,  76,  67,  68,  69,  70,  71,  72,  65,
  66,  59,  60,  61,  62,  63,  64,  78, 142,   0,
   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
   0,   0,  80,   0,   0,   0,   0,   0,   0,   0,
   0,   0,   0,   0,   0,   0,  79,   0,  74,  73,
  77,  75,  76,  67,  68,  69,  70,  71,  72,  65,
  66,  59,  60,  61,  62,  63,  64,  78,  58,   0,
   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
   0,   0,  80,   0,   0,   0,   0,   0,   0,   0,
   0,   0,   0,   0,   0,   0,  79,   0,  74,  73,
  77,  75,  76,  67,  68,  69,  70,  71,  72,  65,
  66,  59,  60,  61,  62,  63,  64,  78,  80,   0,
   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
   0,   0,  79,   0,  74,  73,  77,  75,  76,  67,
  68,  69,  70,  71,  72,  65,  66,  59,  60,  61,
  62,  63,  64,  78,  79,   0,  74,  73,  77,  75,
  76,  67,  68,  69,  70,  71,  72,  65,  66,  59,
  60,  61,  62,  63,  64,  78,  73,  77,  75,  76,
  67,  68,  69,  70,  71,  72,  65,  66,  59,  60,
  61,  62,  63,  64,  78,  77,  75,  76,  67,  68,
  69,  70,  71,  72,  65,  66,  59,  60,  61,  62,
  63,  64,  78,  17,  18,   0,   0,   0,   0,   0,
   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
   0,   0,   0,   0,   0,  86,  87,  88,  89,  90,
  91,  92,  93,  94,  95,  96,  97,  98,  99, 100,
 101, 102, 103,   0,   0, 104,   0, 107,   0,   0,
   0,   0, 110, 111,   0,   0,   0,   0,   0,   0,
   0,   0, 117, 118, 119, 120, 121, 122, 123, 124,
 125, 126, 127, 128, 129, 130, 131, 132, 133, 134,
 135, 136, 137, 138,   0, 117, 141,   0,   0,   0,
   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
   0,   0,   0, 151,   0,   0, 154,   0,   0, 155,
 156,   0,   0, 160, 161,   0,   0,   0,   0,   0,
   0,   0,   0,   0,   0,   0,   0, 168,   0,   0,
   0,   0,   0, 172 };
short yypact[]={

-257,-257,-1000,-1000,-209,-209,-1000,-1000,-174,-1000,
-1000,-233,-181,-182,-183,-204,-250, 258,-1000,-263,
-230,-230,-230,-230,-230,-230,-230,-230,-230,-230,
-230,-230,-230,-230,-230,-230,-230,-230,-1000,-1000,
-1000,-230,-230,-230,-1000,-1000,-1000,-229,-230,-230,
-1000,-1000,-1000,-1000,-1000,-172,-115,-1000,-230,-230,
-230,-230,-230,-230,-230,-230,-230,-230,-230,-230,
-230,-230,-230,-230,-230,-230,-230,-230,-230,-230,
-1000,-230,-230,-1000,-1000,-1000,-1000,-1000,-1000,-1000,
-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,
-1000,-1000,-1000,-1000, 208,-228,-261, 158,-252,-1000,
-124, 294,-1000,-1000,-1000,-1000,-252, 294,-147,-147,
-306,-306,-306,-306,-152,-152,-199,-199,-164,-164,
-164,-164, 353, 335,-107, -55,-264,-1000, 122,-230,
-237,  86,-230,-1000,-1000,-230,-230,-175,-1000,-230,
-230, 294,-1000,-1000,  33,-177, 294,-243,-260,-1000,
 -18, 316,-1000,-230,-1000,-282,-176,-1000, -71,-230,
-1000,-1000, 294 };
short yypgo[]={

   0, 226, 173, 673, 674, 225, 221, 156, 224, 223,
 157, 214, 222, 218, 217, 175, 158,  89 };
short yyr1[]={

   0,   1,   1,  10,  10,  10,  11,  11,   2,   2,
   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,
   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,
   3,   3,  13,   3,   4,   4,   4,   4,   4,   4,
   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,
   4,   4,   4,   5,   5,   5,   5,   5,   5,   5,
   5,   5,   5,   5,   5,   5,   6,   6,   7,   7,
  14,  14,  15,  15,  16,  12,  12,  12,  12,  12,
  17,  12,  12,  12,  12,  12,  12,  12,  12,   9,
   8,   8 };
short yyr2[]={

   0,   1,   2,   1,   2,   2,   1,   1,   1,   3,
   1,   3,   3,   3,   3,   3,   3,   3,   3,   3,
   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,
   3,   5,   0,   4,   1,   2,   2,   2,   2,   2,
   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,
   2,   2,   2,   1,   1,   1,   5,   3,   3,   7,
   5,   4,   4,   2,   2,   2,   0,   1,   1,   3,
   0,   1,   1,   3,   0,   8,   1,   1,   4,   6,
   0,   3,   2,   2,   2,   2,   2,   3,   3,   1,
   1,   1 };
short yychk[]={

-1000,  -1, -10, -11, -12,  -2, 271, 272, 273, 274,
 276, 277, 280, 281, 282, 283, 278,  -3,  -4,  -5,
 314, 313, 323, 324, 322, 321, 325, 326, 327, 328,
 329, 330, 331, 332, 333, 334, 335, 336, 262, 257,
 261, 268, 264, 266, -10, -11, -11, 262, 266, -17,
 263, 263, 263, 263, 263, 279,  -9, 258, 270, 313,
 314, 315, 316, 317, 318, 311, 312, 305, 306, 307,
 308, 309, 310, 301, 300, 303, 304, 302, 319, 298,
 284, 264, 266, 323, 324, 321,  -4,  -4,  -4,  -4,
  -4,  -4,  -4,  -4,  -4,  -4,  -4,  -4,  -4,  -4,
  -4,  -4,  -4,  -4,  -3,  -2,  -6,  -3,  -7, 264,
  -3,  -3, 257,  -8, 259, 260,  -7,  -3,  -3,  -3,
  -3,  -3,  -3,  -3,  -3,  -3,  -3,  -3,  -3,  -3,
  -3,  -3,  -3,  -3,  -3,  -3,  -3,  -3,  -3, -13,
  -6,  -3, 270, 265, 267, 299, 270, -16, 267, 270,
 299,  -3, 265, 267,  -3,  -3,  -3, -14, -15, 262,
  -3,  -3, 269, 299, 267, 265, 270, 267,  -3, 284,
 262, 267,  -3 };
short yydef[]={

   0,  -2,   1,   3,   0,   0,   6,   7,   0,  76,
  77,  80,   0,   0,   0,   0,   0,   8,  10,  34,
   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
   0,   0,   0,   0,   0,   0,   0,   0,  53,  54,
  55,   0,   0,  66,   2,   4,   5,   0,   0,   0,
  82,  83,  84,  85,  86,   0,   0,  89,   0,   0,
   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  32,  66,   0,  63,  64,  65,  35,  36,  37,  38,
  39,  40,  41,  42,  43,  44,  45,  46,  47,  48,
  49,  50,  51,  52,   0,   0,   0,  68,  67,  74,
   0,  81,  87,  88,  90,  91,   9,  68,  11,  12,
  13,  14,  15,  16,  17,  18,  19,  20,  21,  22,
  23,  24,  25,  26,  27,  28,  29,  30,   0,   0,
   0,   0,   0,  57,  58,   0,   0,  70,  78,   0,
   0,  33,  61,  62,   0,   0,  69,   0,  71,  72,
   0,  31,  56,   0,  60,   0,   0,  79,   0,   0,
  73,  59,  75 };
#ifndef lint
static char yaccpar_sccsid[] = "@(#)yaccpar	4.1	(Berkeley)	2/11/83";
#endif

#
# define YYFLAG -1000
# define YYERROR goto yyerrlab
# define YYACCEPT return(0)
# define YYABORT return(1)

/*	parser for yacc output	*/

#ifdef YYDEBUG
int yydebug = 0; /* 1 for debugging */
#endif
YYSTYPE yyv[YYMAXDEPTH]; /* where the values are stored */
int yychar = -1; /* current input token number */
int yynerrs = 0;  /* number of errors */
short yyerrflag = 0;  /* error recovery flag */

yyparse() {

	short yys[YYMAXDEPTH];
	short yyj, yym;
	register YYSTYPE *yypvt;
	register short yystate, *yyps, yyn;
	register YYSTYPE *yypv;
	register short *yyxi;

	yystate = 0;
	yychar = -1;
	yynerrs = 0;
	yyerrflag = 0;
	yyps= &yys[-1];
	yypv= &yyv[-1];

 yystack:    /* put a state and value onto the stack */

#ifdef YYDEBUG
	if( yydebug  ) printf( "state %d, char 0%o\n", yystate, yychar );
#endif
		if( ++yyps> &yys[YYMAXDEPTH] ) { yyerror( "yacc stack overflow" ); return(1); }
		*yyps = yystate;
		++yypv;
		*yypv = yyval;

 yynewstate:

	yyn = yypact[yystate];

	if( yyn<= YYFLAG ) goto yydefault; /* simple state */

	if( yychar<0 ) if( (yychar=yylex())<0 ) yychar=0;
	if( (yyn += yychar)<0 || yyn >= YYLAST ) goto yydefault;

	if( yychk[ yyn=yyact[ yyn ] ] == yychar ){ /* valid shift */
		yychar = -1;
		yyval = yylval;
		yystate = yyn;
		if( yyerrflag > 0 ) --yyerrflag;
		goto yystack;
		}

 yydefault:
	/* default state action */

	if( (yyn=yydef[yystate]) == -2 ) {
		if( yychar<0 ) if( (yychar=yylex())<0 ) yychar = 0;
		/* look through exception table */

		for( yyxi=yyexca; (*yyxi!= (-1)) || (yyxi[1]!=yystate) ; yyxi += 2 ) ; /* VOID */

		while( *(yyxi+=2) >= 0 ){
			if( *yyxi == yychar ) break;
			}
		if( (yyn = yyxi[1]) < 0 ) return(0);   /* accept */
		}

	if( yyn == 0 ){ /* error */
		/* error ... attempt to resume parsing */

		switch( yyerrflag ){

		case 0:   /* brand new error */

			yyerror( "syntax error" );
		yyerrlab:
			++yynerrs;

		case 1:
		case 2: /* incompletely recovered error ... try again */

			yyerrflag = 3;

			/* find a state where "error" is a legal shift action */

			while ( yyps >= yys ) {
			   yyn = yypact[*yyps] + YYERRCODE;
			   if( yyn>= 0 && yyn < YYLAST && yychk[yyact[yyn]] == YYERRCODE ){
			      yystate = yyact[yyn];  /* simulate a shift of "error" */
			      goto yystack;
			      }
			   yyn = yypact[*yyps];

			   /* the current yyps has no shift onn "error", pop stack */

#ifdef YYDEBUG
			   if( yydebug ) printf( "error recovery pops state %d, uncovers %d\n", *yyps, yyps[-1] );
#endif
			   --yyps;
			   --yypv;
			   }

			/* there is no state on the stack with an error shift ... abort */

	yyabort:
			return(1);


		case 3:  /* no shift yet; clobber input char */

#ifdef YYDEBUG
			if( yydebug ) printf( "error recovery discards char %d\n", yychar );
#endif

			if( yychar == 0 ) goto yyabort; /* don't discard EOF, quit */
			yychar = -1;
			goto yynewstate;   /* try again in the same state */

			}

		}

	/* reduction by production yyn */

#ifdef YYDEBUG
		if( yydebug ) printf("reduce %d\n",yyn);
#endif
		yyps -= yyr2[yyn];
		yypvt = yypv;
		yypv -= yyr2[yyn];
		yyval = yypv[1];
		yym=yyn;
			/* consult goto table to find next state */
		yyn = yyr1[yyn];
		yyj = yypgo[yyn] + *yyps + 1;
		if( yyj>=YYLAST || yychk[ yystate = yyact[yyj] ] != -yyn ) yystate = yyact[yypgo[yyn]];
		switch(yym){
			
case 5:
# line 74 "grammar.y"
{ EvalTree(yypvt[-1].tree,&result,NULL);
                  fputs("==>\t", stdout); 
		  dispval(stdout,&result);
	          fputs("\n", stdout);
	          fflush(stdout);} break;
case 9:
# line 90 "grammar.y"
{ yyval.tree = MakeCommaOp(yypvt[-2].tree,yypvt[-0].list); } break;
case 11:
# line 97 "grammar.y"
{ yyval.tree = MakeBinaryOp(Plus,yypvt[-2].tree,yypvt[-0].tree); } break;
case 12:
# line 99 "grammar.y"
{ yyval.tree = MakeBinaryOp(Minus,yypvt[-2].tree,yypvt[-0].tree); } break;
case 13:
# line 101 "grammar.y"
{ yyval.tree = MakeBinaryOp(Mult,yypvt[-2].tree,yypvt[-0].tree); } break;
case 14:
# line 103 "grammar.y"
{ yyval.tree = MakeBinaryOp(Div,yypvt[-2].tree,yypvt[-0].tree); } break;
case 15:
# line 105 "grammar.y"
{ yyval.tree = MakeBinaryOp(Mod,yypvt[-2].tree,yypvt[-0].tree); } break;
case 16:
# line 107 "grammar.y"
{ yyval.tree = MakeBinaryOp(Power,yypvt[-2].tree,yypvt[-0].tree); } break;
case 17:
# line 109 "grammar.y"
{ yyval.tree = MakeBinaryOp(Lshift,yypvt[-2].tree,yypvt[-0].tree); } break;
case 18:
# line 111 "grammar.y"
{ yyval.tree = MakeBinaryOp(Rshift,yypvt[-2].tree,yypvt[-0].tree); } break;
case 19:
# line 113 "grammar.y"
{ yyval.tree = MakeBinaryOp(Eq,yypvt[-2].tree,yypvt[-0].tree); } break;
case 20:
# line 115 "grammar.y"
{ yyval.tree = MakeBinaryOp(Ne,yypvt[-2].tree,yypvt[-0].tree); } break;
case 21:
# line 117 "grammar.y"
{ yyval.tree = MakeBinaryOp(Lt,yypvt[-2].tree,yypvt[-0].tree); } break;
case 22:
# line 119 "grammar.y"
{ yyval.tree = MakeBinaryOp(Gt,yypvt[-2].tree,yypvt[-0].tree); } break;
case 23:
# line 121 "grammar.y"
{ yyval.tree = MakeBinaryOp(Le,yypvt[-2].tree,yypvt[-0].tree); } break;
case 24:
# line 123 "grammar.y"
{ yyval.tree = MakeBinaryOp(Ge,yypvt[-2].tree,yypvt[-0].tree); } break;
case 25:
# line 125 "grammar.y"
{ yyval.tree = MakeBinaryOp(Land,yypvt[-2].tree,yypvt[-0].tree); } break;
case 26:
# line 127 "grammar.y"
{ yyval.tree = MakeBinaryOp(Lor,yypvt[-2].tree,yypvt[-0].tree); } break;
case 27:
# line 129 "grammar.y"
{ yyval.tree = MakeBinaryOp(Xor,yypvt[-2].tree,yypvt[-0].tree); } break;
case 28:
# line 131 "grammar.y"
{ yyval.tree = MakeBinaryOp(Band,yypvt[-2].tree,yypvt[-0].tree); } break;
case 29:
# line 133 "grammar.y"
{ yyval.tree = MakeBinaryOp(Bor,yypvt[-2].tree,yypvt[-0].tree); } break;
case 30:
# line 135 "grammar.y"
{ yyval.tree = MakeBinaryOp(Concat,yypvt[-2].tree,yypvt[-0].tree); } break;
case 31:
# line 137 "grammar.y"
{ yyval.tree = MakeTernaryOp(yypvt[-4].tree,yypvt[-2].tree,yypvt[-0].tree); } break;
case 32:
# line 139 "grammar.y"
{ ChangeToLValue(yypvt[-1].tree); } break;
case 33:
# line 141 "grammar.y"
{ yyval.tree = MakeBinaryOp(Assign,yypvt[-3].tree,yypvt[-0].tree); } break;
case 35:
# line 148 "grammar.y"
{ yyval.tree = MakeUnaryOp(Uminus,yypvt[-0].tree); } break;
case 36:
# line 150 "grammar.y"
{ yyval.tree = MakeUnaryOp(Uplus,yypvt[-0].tree); } break;
case 37:
# line 152 "grammar.y"
{ yyval.tree = MakeUnaryOp(Preinc,yypvt[-0].tree); } break;
case 38:
# line 154 "grammar.y"
{ yyval.tree = MakeUnaryOp(Predec,yypvt[-0].tree); } break;
case 39:
# line 156 "grammar.y"
{ yyval.tree = MakeUnaryOp(Bnot,yypvt[-0].tree); } break;
case 40:
# line 158 "grammar.y"
{ yyval.tree = MakeUnaryOp(Lnot,yypvt[-0].tree); } break;
case 41:
# line 160 "grammar.y"
{ yyval.tree = MakeUnaryOp(Plusover,yypvt[-0].tree); } break;
case 42:
# line 162 "grammar.y"
{ yyval.tree = MakeUnaryOp(Minusover,yypvt[-0].tree); } break;
case 43:
# line 164 "grammar.y"
{ yyval.tree = MakeUnaryOp(Multover,yypvt[-0].tree); } break;
case 44:
# line 166 "grammar.y"
{ yyval.tree = MakeUnaryOp(Divover,yypvt[-0].tree); } break;
case 45:
# line 168 "grammar.y"
{ yyval.tree = MakeUnaryOp(Modover,yypvt[-0].tree); } break;
case 46:
# line 170 "grammar.y"
{ yyval.tree = MakeUnaryOp(Powerover,yypvt[-0].tree); } break;
case 47:
# line 172 "grammar.y"
{ yyval.tree = MakeUnaryOp(Lorover,yypvt[-0].tree); } break;
case 48:
# line 174 "grammar.y"
{ yyval.tree = MakeUnaryOp(Borover,yypvt[-0].tree); } break;
case 49:
# line 176 "grammar.y"
{ yyval.tree = MakeUnaryOp(Xorover,yypvt[-0].tree); } break;
case 50:
# line 178 "grammar.y"
{ yyval.tree = MakeUnaryOp(Landover,yypvt[-0].tree); } break;
case 51:
# line 180 "grammar.y"
{ yyval.tree = MakeUnaryOp(Bandover,yypvt[-0].tree); } break;
case 52:
# line 182 "grammar.y"
{ yyval.tree = MakeUnaryOp(Sizeof,yypvt[-0].tree); } break;
case 53:
# line 188 "grammar.y"
{ yyval.tree = MakeVariableNode(yypvt[-0].id); } break;
case 54:
# line 190 "grammar.y"
{ yyval.tree = MakeIntegerNode(yypvt[-0].i); } break;
case 55:
# line 192 "grammar.y"
{ yyval.tree = MakeRealNode(yypvt[-0].d); } break;
case 56:
# line 194 "grammar.y"
{ yyval.tree = MakeComplexNode(EvalTree(yypvt[-3].tree,&tmpval1,NULL),
				       EvalTree(yypvt[-1].tree,&tmpval2,NULL)); } break;
case 57:
# line 197 "grammar.y"
{ yyval.tree = yypvt[-1].tree; } break;
case 58:
# line 199 "grammar.y"
{ yyval.tree = MakeArrayNode(yypvt[-1].list); } break;
case 59:
# line 201 "grammar.y"
{ yyval.tree = MakePartition(EvalTree(yypvt[-5].tree,&tmpval1,NULL),
				     EvalTree(yypvt[-3].tree,&tmpval2,NULL),
				     EvalTree(yypvt[-1].tree,&tmpval3,NULL)); } break;
case 60:
# line 205 "grammar.y"
{ tmpval2.type = integer;
		  tmpval2.i.i = 1;
		  yyval.tree = MakePartition(EvalTree(yypvt[-3].tree,&tmpval1,NULL),
				     &tmpval2,
				     EvalTree(yypvt[-1].tree,&tmpval3,NULL)); } break;
case 61:
# line 211 "grammar.y"
{ yyval.tree = MakeFunctionNode(yypvt[-3].tree,yypvt[-1].list); } break;
case 62:
# line 213 "grammar.y"
{ yyval.tree = MakeBinaryOp(Index,yypvt[-3].tree,yypvt[-1].tree); } break;
case 63:
# line 215 "grammar.y"
{ yyval.tree = MakeUnaryOp(Postinc,yypvt[-1].tree); } break;
case 64:
# line 217 "grammar.y"
{ yyval.tree = MakeUnaryOp(Postdec,yypvt[-1].tree); } break;
case 65:
# line 219 "grammar.y"
{ yyval.tree = MakeUnaryOp(Factorial,yypvt[-1].tree); } break;
case 66:
# line 224 "grammar.y"
{ yyval.list = EmptyTreeList(); } break;
case 68:
# line 229 "grammar.y"
{ yyval.list = AddToTreeList(EmptyTreeList(),yypvt[-0].tree); } break;
case 69:
# line 231 "grammar.y"
{ yyval.list = AddToTreeList(yypvt[-2].list,yypvt[-0].tree); } break;
case 72:
# line 242 "grammar.y"
{ MakeLocalSym(yypvt[-0].id); } break;
case 73:
# line 244 "grammar.y"
{ MakeLocalSym(yypvt[-0].id); } break;
case 74:
# line 249 "grammar.y"
{ MarkLocalSyms(); } break;
case 75:
# line 251 "grammar.y"
{ ForgetLocalSyms();
		  DefineFunction(yypvt[-6].id,CountLocalSyms(),yypvt[-0].tree); 
	        } break;
case 76:
# line 254 "grammar.y"
{ ClearAllPlots(); } break;
case 77:
# line 256 "grammar.y"
{ exit(0); } break;
case 78:
# line 258 "grammar.y"
{ PlotArrays(NULL, EvalTree(yypvt[-1].tree, &tmpval1, NULL)); } break;
case 79:
# line 260 "grammar.y"
{ PlotArrays(EvalTree(yypvt[-3].tree, &tmpval1, NULL), 
                             EvalTree(yypvt[-1].tree, &tmpval2, NULL));} break;
case 80:
# line 263 "grammar.y"
{ MarkLocalSyms();
		  MakeLocalSym("x"); } break;
case 81:
# line 266 "grammar.y"
{ ForgetLocalSyms();
		  PlotExpression(yypvt[-0].tree); } break;
case 82:
# line 269 "grammar.y"
{ PlotFile(yypvt[-0].id); } break;
case 83:
# line 271 "grammar.y"
{ SetTitle(yypvt[-0].id); } break;
case 84:
# line 273 "grammar.y"
{ SetXLabel(yypvt[-0].id); } break;
case 85:
# line 275 "grammar.y"
{ SetYLabel(yypvt[-0].id); } break;
case 86:
# line 277 "grammar.y"
{ SetY2Label(yypvt[-0].id); } break;
case 87:
# line 279 "grammar.y"
{ SetSamples (yypvt[-0].i); } break;
case 88:
# line 281 "grammar.y"
{ SetOption (yypvt[-1].i, yypvt[-0].i);} break;
case 89:
# line 287 "grammar.y"
{ yyval.i = DISPLAYVAL; } break;
case 90:
# line 292 "grammar.y"
{ yyval.i = 1; } break;
case 91:
# line 294 "grammar.y"
{ yyval.i = 0; } break; 
		}
		goto yystack;  /* stack new state and value */

	}