#ifndef lint
static char const 
yyrcsid[] = "$FreeBSD: src/usr.bin/yacc/skeleton.c,v 1.28 2000/01/17 02:04:06 bde Exp $";
#endif
#include <stdlib.h>
#define YYBYACC 1
#define YYMAJOR 1
#define YYMINOR 9
#define YYLEX yylex()
#define YYEMPTY -1
#define yyclearin (yychar=(YYEMPTY))
#define yyerrok (yyerrflag=0)
#define YYRECOVERING() (yyerrflag!=0)
static int yygrowstack();
#define YYPREFIX "yy"
#line 30 "ejsc_parser.y"
#define MAXVARS 16
#define MAXARGLISTS 8
#define MAXSYMS 300
  /* Keep up with linenumbers */
  int yylineno=1;

  /* Index constructions to generate evalIds */
  int evalIndex=0;

  /* Error "handling" */
  int yyerror(char *s) {
    fprintf(stderr, "%s\n", s);
    fflush(stderr);
    return 0;
  }
  
  /* Get first non-null index in tVariable array */
  int first_null_index(tVariable *vp) {
    int i;
    for (i=0 ; i<MAXVARS; i++) {
      /* Variable arrays are initially filled with null-variables, so
	 first free index is first index having null-variable */
      if ( vp[i].type == tNull ) {
	return i;
      }
    }
    return MAXVARS;
  }
  /* The same as abow, but for array of arrays */
  int first_null_index_(tVariable **vpp) {
    int i;
    /* Array of variable arrays is initially filled with
       null-pointers. */
    for (i=0 ; i<MAXVARS; i++) {
      if ( vpp[i] == NULL ) {
	return i;
      }
    }
    return MAXVARS;
  }

  /* Get the index of symbol named name, -1 if name doesn't exist in
     symbol table of given symbol sym */
  int get_sym_index(tSymbol *sym, tIdentifier name) {
    int i;
    if ((*sym).symTable == NULL ||
	(*sym).symTSize < 1) {
      /* No symbol table */
      return -1;
    }
    /* Browse symbol table */
    for (i=0; (*sym).symTable[i]!=NULL; i++) {
      /* Compare symbol name and given identifier */
      if ( strcmp((*(*sym).symTable[i]).symName, name) == 0 ) {
	return i;
      }
    }
    /* Symbol not found */
    return -1;
  }

  /* Assure free space in symTable of given symbol, return first free
     index */
  int check_symtable(tSymbol *sym) {
    int i, newsize;
    if ( ((*sym).symTable == NULL) ||
	 ((*sym).symTSize < 1) ) {
      /* Initialize symbol table */
#ifdef EJSCCDEBUG
      if ( ejsccdebug ) {
	printf("ejsccdebug: Init symtable of '%s' (%d).\n", (*sym).symName, (int)sym);
	fflush(stdout);
      }
#endif
      newsize = MAXSYMS;
      (*sym).symTable = (tSymbol **)malloc(newsize * sizeof(tSymbol *));
      /* Fill with NULL */
      for (i=0; i<newsize; (*sym).symTable[i++] = NULL );
      (*sym).symTSize = newsize;
    } else {
      /* Check free space */
      if ( (*sym).symTable[(*sym).symTSize-1] != NULL ) {
	/* Full, must realloc */
	/* Reallocation can't be allowed due direct references to symbols */
	fprintf(outfile, "Fatal error: Too many symbols in '%s'.\n", (*sym).symName);
	exit(1);
	/*
#ifdef EJSCCDEBUG
	if ( ejsccdebug ) {
	  printf("ejsccdebug: Realloc symtable of '%s'.\n", (*sym).symName);
	  fflush(stdout);
	}
#endif
	newsize = ((*sym).symTSize+10) * sizeof(tSymbol);
	(*sym).symTable = realloc((*sym).symTable, newsize);
	for (i=(*sym).symTSize; i<(*sym).symTSize+10; 
	     (*sym).symTable[i++] = nullSym);
	(*sym).symTSize += 10;
	*/
      } 
    }
    /* Find first free (NULL or nullSym) index */
    for (i=0; i<(*sym).symTSize; i++) {
      if ( ((*sym).symTable[i] == NULL) ||
	   ((*((*sym).symTable[i])).symName == nullSym.symName) ) {
	return i;
      }
    }
    /* symTable full.  Shouldn't ever happen */
    yyerror("symTable still full after assuring free space.  Fatal error."); 
    exit(1);
  }


  int append_symbol_to_symtable(tIdentifier name, tVariable *val, tSymbol *sym) {
    /* Check if symbol already exists. */
    int i = get_sym_index(sym, name);
    if ( i<0 ) {
      /* New symbol */
      i = check_symtable(sym);
      if ( i<0 ) return -1;
      if ( (*sym).symTable[i] == NULL ) {
	(*sym).symTable[i] = (tSymbol *)malloc(sizeof(tSymbol));
	(*(*sym).symTable[i]) = nullSym;
#ifdef EJSCCDEBUG
	if ( ejsccdebug ) {
	  printf("ejsccdebug: Created new symbol '%s'. (%d)\n", 
		 name, (int)(*sym).symTable[i]);
	  fflush(stdout);
	}
#endif
      }
      (*(*sym).symTable[i]).symName = name;
      (*(*sym).symTable[i]).symIndex = 0;
      /* No need to reset previously set defaults*/
      /* (*(*sym).symTable[i]).symTSize = 0;*/
      /* (*(*sym).symTable[i]).symTable = NULL;*/
      (*(*sym).symTable[i]).parentSym = sym;
      (*(*sym).symTable[i]).beingCompiled = false;
    }
    /* Set value of symbol */
    (*(*sym).symTable[i]).symValue = val;
#ifdef EJSCCDEBUG
    if ( ejsccdebug ) {
      printf("ejsccdebug: Set val of sym '%s' in symTable[%d] of '%s'. (%d, %d)\n", 
	     name, i, (*sym).symName, (int)(*sym).symTable[i], (int)sym);
      fflush(stdout);
    }
#endif
    return i;
  }

  /* Append simple (object, constant, etc.) symbol to symbol table of
     current symbol */
  int append_symbol_to_current(tIdentifier name, tVariable *val) {
    return append_symbol_to_symtable(name, val, currentSym);
  }

  /* Generate human readable 'name' of given variable */
  char *get_name(tVariable *var) {
    char *tmp;
    switch ( (*var).type ) {
    case tOb:
      tmp = (char*)malloc((16 + strlen((*var).value.o.objName))*sizeof(char));
      sprintf(tmp, "construction '%s'", (*var).value.o.objName);
      return tmp;
    case tSt:
      return "string";
    case tIn:
      return "integer";
    case tFl:
      return "float";
    case tId:
      return "identifier";
    case tNull:
      return "null";
    default:
      return "#UNKNOWN#";
    }
  }

  void set_scope(tSymbol *sym) {
    tVariable *val;
    int i, j;
    val = (*sym).symValue;
    /* Set scope of construction objects given as argument */
    if ( (*val).value.o.arguments != NULL ) {
      i=0;
      while ( (*val).value.o.arguments[i] != NULL ) {
	j=0;
	while ((*val).value.o.arguments[i][j].type != tNull) {
	  (*val).scope = sym;
	  j++;
	}
	i++;
      }
    }
  }

#line 231 "ejsc_parser.y"
typedef union {
  tBoolean b;
  tSymbol s;
  tVariable v;
  tVariable *vp;
  tVariable **vpp;
} YYSTYPE;
#line 225 "ejsc_parser.c"
#define YYERRCODE 256
#define NAME 257
#define STRING 258
#define COMMENT 259
#define INT 260
#define FLOAT 261
#define BEGIN_BLOCK 262
#define END_BLOCK 263
#define CONS_ 264
#define COBJ_ATTR 265
#define COBJ_CONS 266
const short yylhs[] = {                                        -1,
    0,    0,    0,    0,    2,    2,    1,    4,    4,    7,
    7,    7,    3,    3,    8,    8,    8,    5,    5,   10,
   10,   11,   11,   12,    6,    6,    9,    9,
};
const short yylen[] = {                                         2,
    2,    3,    4,    1,    1,    0,    4,    4,    3,    3,
    1,    0,    3,    3,    1,    1,    1,    3,    0,    3,
    1,    3,    3,    4,    4,    0,    1,    1,
};
const short yydefred[] = {                                      0,
    0,    4,    0,    0,    0,    0,    0,    1,    5,    0,
    0,    0,   11,    0,    0,    0,    0,    2,    0,   16,
   27,   28,    0,    0,   15,    3,    9,    0,    0,    0,
    0,   21,    0,    7,   14,   13,   10,    8,    0,    0,
    0,    0,   18,    0,    0,   22,   23,   20,    0,    0,
   25,   24,
};
const short yydgoto[] = {                                       8,
    4,   11,   13,    7,   17,   34,   14,   24,   25,   31,
   32,   41,
};
const short yysindex[] = {                                   -230,
  -24,    0, -230, -242, -242, -242,  -33,    0,    0,  -37,
 -215,  -28,    0,  -18, -242, -242, -227,    0,   -4,    0,
    0,    0, -242, -242,    0,    0,    0, -242,   12, -195,
  -36,    0,  -19,    0,    0,    0,    0,    0,    1, -242,
 -242, -242,    0, -230, -242,    0,    0,    0, -229,   28,
    0,    0,
};
const short yyrindex[] = {                                      0,
    0,    0,    0,  -12, -190,  -35,  -41,    0,    0,    0,
    0,    0,    0,    0,  -35, -190,  -40,    0,  -39,    0,
    0,    0,  -20,  -20,    0,    0,    0, -190,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,  -32,  -34,
  -34, -190,    0,    0,  -35,    0,    0,    0,    0,    0,
    0,    0,
};
const short yygindex[] = {                                     11,
   37,    9,   10,    0,    0,    0,   -1,   22,    0,    0,
   18,    0,
};
#define YYTABLESIZE 227
const short yytable[] = {                                      19,
   26,   17,   19,   26,   17,   12,   15,   42,   12,    6,
    3,   17,   10,   29,   12,    6,    9,   19,   26,   17,
    6,   18,   27,    6,   30,   28,    1,    1,    2,    2,
   26,   35,   36,   51,   33,    6,    5,   37,    6,   44,
   45,   19,   20,   50,   21,   22,    6,   23,   46,   47,
   30,   40,   38,    0,   49,   28,   43,   16,    6,   48,
   17,   39,   20,    0,   21,   22,    6,    6,   52,    6,
    6,   28,    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,    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,    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,   19,   26,   17,
   19,    6,    6,    0,    6,    6,   17,
};
const short yycheck[] = {                                      41,
   41,   41,   44,   44,   44,   41,   40,   44,   44,   44,
    0,   44,    4,   15,    5,   40,  259,   59,   59,   59,
   41,   59,   41,   44,   16,   44,  257,  257,  259,  259,
   59,   23,   24,  263,  262,   40,   61,   28,   59,   59,
   40,  257,  258,   45,  260,  261,   59,   11,   40,   41,
   42,   30,   41,   -1,   44,   44,   93,   91,   93,   42,
   93,  257,  258,   -1,  260,  261,  257,  258,   41,  260,
  261,   44,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,  259,  259,  259,
  262,  257,  258,   -1,  260,  261,  259,
};
#define YYFINAL 3
#ifndef YYDEBUG
#define YYDEBUG 0
#endif
#define YYMAXTOKEN 266
#if YYDEBUG
const char * const yyname[] = {
"end-of-file",0,0,0,0,0,0,0,0,0,"'\\n'",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,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,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,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,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,"NAME","STRING","COMMENT","INT","FLOAT","BEGIN_BLOCK","END_BLOCK","CONS_",
"COBJ_ATTR","COBJ_CONS",
};
const char * const yyrule[] = {
"$accept : construction",
"construction : construction construction",
"construction : construction_object maybecomment ';'",
"construction : NAME '=' attribute ';'",
"construction : COMMENT",
"maybecomment : COMMENT",
"maybecomment :",
"construction_object : NAME attributes formats codeblock",
"attributes : attributes '(' attributelist ')'",
"attributes : '(' attributelist ')'",
"attributelist : attributelist ',' attribute",
"attributelist : attribute",
"attributelist :",
"attribute : maybecomment simple_attribute maybecomment",
"attribute : maybecomment construction_object maybecomment",
"simple_attribute : number",
"simple_attribute : STRING",
"simple_attribute : NAME",
"formats : '[' formatlist ']'",
"formats :",
"formatlist : formatlist ',' format",
"formatlist : format",
"format : maybecomment simple_attribute maybecomment",
"format : maybecomment format_call maybecomment",
"format_call : NAME '(' attributelist ')'",
"codeblock : BEGIN_BLOCK ';' construction END_BLOCK",
"codeblock :",
"number : INT",
"number : FLOAT",
};
#endif
#if YYDEBUG
#include <stdio.h>
#endif
#ifdef YYSTACKSIZE
#undef YYMAXDEPTH
#define YYMAXDEPTH YYSTACKSIZE
#else
#ifdef YYMAXDEPTH
#define YYSTACKSIZE YYMAXDEPTH
#else
#define YYSTACKSIZE 10000
#define YYMAXDEPTH 10000
#endif
#endif
#define YYINITSTACKSIZE 200
int yydebug;
int yynerrs;
int yyerrflag;
int yychar;
short *yyssp;
YYSTYPE *yyvsp;
YYSTYPE yyval;
YYSTYPE yylval;
short *yyss;
short *yysslim;
YYSTYPE *yyvs;
int yystacksize;
#line 512 "ejsc_parser.y"

#include "ejsc_lexer.c"
#line 409 "ejsc_parser.c"
/* allocate initial stack or double stack size, up to YYMAXDEPTH */
static int yygrowstack()
{
    int newsize, i;
    short *newss;
    YYSTYPE *newvs;

    if ((newsize = yystacksize) == 0)
        newsize = YYINITSTACKSIZE;
    else if (newsize >= YYMAXDEPTH)
        return -1;
    else if ((newsize *= 2) > YYMAXDEPTH)
        newsize = YYMAXDEPTH;
    i = yyssp - yyss;
    newss = yyss ? (short *)realloc(yyss, newsize * sizeof *newss) :
      (short *)malloc(newsize * sizeof *newss);
    if (newss == NULL)
        return -1;
    yyss = newss;
    yyssp = newss + i;
    newvs = yyvs ? (YYSTYPE *)realloc(yyvs, newsize * sizeof *newvs) :
      (YYSTYPE *)malloc(newsize * sizeof *newvs);
    if (newvs == NULL)
        return -1;
    yyvs = newvs;
    yyvsp = newvs + i;
    yystacksize = newsize;
    yysslim = yyss + newsize - 1;
    return 0;
}

#define YYABORT goto yyabort
#define YYREJECT goto yyabort
#define YYACCEPT goto yyaccept
#define YYERROR goto yyerrlab

#ifndef YYPARSE_PARAM
#if defined(__cplusplus) || __STDC__
#define YYPARSE_PARAM_ARG void
#define YYPARSE_PARAM_DECL
#else	/* ! ANSI-C/C++ */
#define YYPARSE_PARAM_ARG
#define YYPARSE_PARAM_DECL
#endif	/* ANSI-C/C++ */
#else	/* YYPARSE_PARAM */
#ifndef YYPARSE_PARAM_TYPE
#define YYPARSE_PARAM_TYPE void *
#endif
#if defined(__cplusplus) || __STDC__
#define YYPARSE_PARAM_ARG YYPARSE_PARAM_TYPE YYPARSE_PARAM
#define YYPARSE_PARAM_DECL
#else	/* ! ANSI-C/C++ */
#define YYPARSE_PARAM_ARG YYPARSE_PARAM
#define YYPARSE_PARAM_DECL YYPARSE_PARAM_TYPE YYPARSE_PARAM;
#endif	/* ANSI-C/C++ */
#endif	/* ! YYPARSE_PARAM */

int
yyparse (YYPARSE_PARAM_ARG)
    YYPARSE_PARAM_DECL
{
    register int yym, yyn, yystate;
#if YYDEBUG
    register const char *yys;

    if ((yys = getenv("YYDEBUG")))
    {
        yyn = *yys;
        if (yyn >= '0' && yyn <= '9')
            yydebug = yyn - '0';
    }
#endif

    yynerrs = 0;
    yyerrflag = 0;
    yychar = (-1);

    if (yyss == NULL && yygrowstack()) goto yyoverflow;
    yyssp = yyss;
    yyvsp = yyvs;
    *yyssp = yystate = 0;

yyloop:
    if ((yyn = yydefred[yystate])) goto yyreduce;
    if (yychar < 0)
    {
        if ((yychar = yylex()) < 0) yychar = 0;
#if YYDEBUG
        if (yydebug)
        {
            yys = 0;
            if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
            if (!yys) yys = "illegal-symbol";
            printf("%sdebug: state %d, reading %d (%s)\n",
                    YYPREFIX, yystate, yychar, yys);
        }
#endif
    }
    if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
    {
#if YYDEBUG
        if (yydebug)
            printf("%sdebug: state %d, shifting to state %d\n",
                    YYPREFIX, yystate, yytable[yyn]);
#endif
        if (yyssp >= yysslim && yygrowstack())
        {
            goto yyoverflow;
        }
        *++yyssp = yystate = yytable[yyn];
        *++yyvsp = yylval;
        yychar = (-1);
        if (yyerrflag > 0)  --yyerrflag;
        goto yyloop;
    }
    if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
    {
        yyn = yytable[yyn];
        goto yyreduce;
    }
    if (yyerrflag) goto yyinrecovery;
#if defined(lint) || defined(__GNUC__)
    goto yynewerror;
#endif
yynewerror:
    yyerror("syntax error");
#if defined(lint) || defined(__GNUC__)
    goto yyerrlab;
#endif
yyerrlab:
    ++yynerrs;
yyinrecovery:
    if (yyerrflag < 3)
    {
        yyerrflag = 3;
        for (;;)
        {
            if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE) >= 0 &&
                    yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
            {
#if YYDEBUG
                if (yydebug)
                    printf("%sdebug: state %d, error recovery shifting\
 to state %d\n", YYPREFIX, *yyssp, yytable[yyn]);
#endif
                if (yyssp >= yysslim && yygrowstack())
                {
                    goto yyoverflow;
                }
                *++yyssp = yystate = yytable[yyn];
                *++yyvsp = yylval;
                goto yyloop;
            }
            else
            {
#if YYDEBUG
                if (yydebug)
                    printf("%sdebug: error recovery discarding state %d\n",
                            YYPREFIX, *yyssp);
#endif
                if (yyssp <= yyss) goto yyabort;
                --yyssp;
                --yyvsp;
            }
        }
    }
    else
    {
        if (yychar == 0) goto yyabort;
#if YYDEBUG
        if (yydebug)
        {
            yys = 0;
            if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
            if (!yys) yys = "illegal-symbol";
            printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
                    YYPREFIX, yystate, yychar, yys);
        }
#endif
        yychar = (-1);
        goto yyloop;
    }
yyreduce:
#if YYDEBUG
    if (yydebug)
        printf("%sdebug: state %d, reducing by rule %d (%s)\n",
                YYPREFIX, yystate, yyn, yyrule[yyn]);
#endif
    yym = yylen[yyn];
    yyval = yyvsp[1-yym];
    switch (yyn)
    {
case 2:
#line 248 "ejsc_parser.y"
{ 
    tIdentifier name;
    int i;
    static int cnum=1; /* Number of construction */
    static int lastlineno=0; /* Line number when last time visiting */
    /* Generate unique name */
    if ( yylineno != lastlineno ) {
      cnum = 1;
      lastlineno = yylineno;
    }
    name = (tIdentifier)malloc(32*sizeof(char));
    sprintf(name, "line_%d_construction_%d", yylineno, cnum++);
    i = append_symbol_to_current(name, yyvsp[-2].vp);
    (*(yyvsp[-2].vp)).scope = (*currentSym).symTable[i];
    /* In case of function definition, fix name */
    if ( ((*((*currentSym).symTable[i])).symTSize != 0) &&
	 ((*(*((*currentSym).symTable[i])).symValue).type == tOb) ) {
      /*      free((*currentSym).symTable[i].symName);*/
      (*((*currentSym).symTable[i])).symName = 
	(*(*((*currentSym).symTable[i])).symValue).value.o.objName;
    }
#ifdef EJSCCDEBUG
    if ( ejsccdebug ) {
      printf("ejsccdebug: Assigned to '%s'.\n", name);
      fflush(stdout);
    }
#endif
}
break;
case 3:
#line 276 "ejsc_parser.y"
{
    int i;
    i = append_symbol_to_current(yyvsp[-3].v.value.s, yyvsp[-1].vp);
    (*(yyvsp[-1].vp)).scope = (*currentSym).symTable[i];
#ifdef EJSCCDEBUG
    if ( ejsccdebug ) {
      printf("ejsccdebug: Assigned to '%s'.\n", yyvsp[-3].v.value.s);
      fflush(stdout);
    }
#endif
  }
break;
case 7:
#line 296 "ejsc_parser.y"
{ 
    tVariable *val;
    int ***tmp_eval;
    int i,j,k;
    /* Allocate memory */
    val = (tVariable *)malloc(sizeof(tVariable));
    /* Create construction object */
    (*val).type = tOb;
    (*val).evalId = evalIndex; evalIndex += EVALIDSTEP; /* Unique id*/
    (*val).value.o.objName = yyvsp[-3].v.value.s; /* Name*/
    /* Allocate memory for return values and reset them */
    (*val).value.o.returnValues = (char **)malloc(MAXSYMS * sizeof(char *));
    memset((*val).value.o.returnValues, (int)NULL, MAXSYMS * sizeof(char *));
    /* Decide type.  Existing codeblock means definition */
    if ( yyvsp[0].b == true ) {
      (*val).value.o.type = Definition;
    } else {
      (*val).value.o.type = Object;
    }
    /* Evaluation id's to keep track on the need of re-evaluation of arguments */
    (*val).value.o.arguments = yyvsp[-2].vpp; /* Argument list */
    tmp_eval = (*val).value.o.argumentEvalId = (int ***)malloc(MAXARGLISTS * sizeof(int **));
    for ( i=0 ; i<MAXARGLISTS ; i++ ) {
      tmp_eval[i] = (int **)malloc(MAXVARS * sizeof(int *));
      for ( j=0 ; j<MAXVARS ; j++ ) {
	tmp_eval[i][j] = (int *)malloc(MAXSYMS * sizeof(int));
	for ( k=0 ; k<MAXSYMS ; tmp_eval[i][j][k++] = -1 );
      }
    }
    /* Evaluation id's to keep track on the need of re-evaluation of formats */
    (*val).value.o.formats = yyvsp[-1].vp; /* Format list */
    (*tmp_eval) = (*val).value.o.formatEvalId = (int **)malloc(MAXARGLISTS * sizeof(int *));
    for ( i=0 ; i<MAXARGLISTS ; i++ ) {
      (*tmp_eval)[i] = (int *)malloc(MAXSYMS * sizeof(int));
      for ( j=0 ; j<MAXSYMS ; (*tmp_eval)[i][j++] = -1 );
    }
    (*val).scope = currentSym;
    yyval.vp = val;
#ifdef EJSCCDEBUG
    if ( ejsccdebug ) {
      printf("ejsccdebug: Found %s.\n", get_name(val));
      fflush(stdout);
    }
#endif
  }
break;
case 8:
#line 344 "ejsc_parser.y"
{
    int i = first_null_index_(yyvsp[-3].vpp);
#ifdef EJSCCDEBUG
    if ( ejsccdebug ) {
      printf("ejsccdebug: Yet another argument list found.\n");
      fflush(stdout);
    }
#endif
    if ( i > MAXARGLISTS-1 ) {
      /* FIXME: realloc */
      yyerror("Error. Too many attributelists.\n");
    } else {
      yyval.vpp = yyvsp[-3].vpp;
      yyval.vpp[i] = yyvsp[-1].vp;
    }
  }
break;
case 9:
#line 360 "ejsc_parser.y"
{
    int size = MAXARGLISTS;
    int i;
#ifdef EJSCCDEBUG
    if ( ejsccdebug ) {
      printf("ejsccdebug: Argument list found.\n");
      fflush(stdout);
    }
#endif
    yyval.vpp = (tVariable **)malloc(size * sizeof(tVariable *)); 
    for (i=0 ; i<size; yyval.vpp[i++]=NULL);
    yyval.vpp[0] = yyvsp[-1].vp;
  }
break;
case 10:
#line 376 "ejsc_parser.y"
{
    int i = first_null_index(yyvsp[-2].vp);
    if ( i > MAXVARS-1 ) { 
      /* FIXME: realloc */
      yyerror("Error. Too many attributes.\n"); 
    } else {
      yyval.vp = yyvsp[-2].vp;
      yyval.vp[i] = (*(yyvsp[0].vp));
    }
  }
break;
case 11:
#line 386 "ejsc_parser.y"
{ 
    int size = MAXVARS;
    int i;
    yyval.vp = (tVariable *)malloc(size * sizeof(tVariable)); 
    /* Set all variables to 'nullVar' */
    for (i=0 ; i<size; yyval.vp[i++]=nullVar);
    yyval.vp[0] = (*(yyvsp[0].vp));
  }
break;
case 12:
#line 394 "ejsc_parser.y"
{ yyval.vp = NULL; }
break;
case 13:
#line 398 "ejsc_parser.y"
{ yyval.vp = yyvsp[-1].vp; }
break;
case 14:
#line 399 "ejsc_parser.y"
{ 
    yyval.vp = yyvsp[-1].vp; 
}
break;
case 15:
#line 405 "ejsc_parser.y"
{ 
    yyval.vp = (tVariable*)malloc(sizeof(tVariable)); 
    (*(yyval.vp)) = yyvsp[0].v;
  }
break;
case 16:
#line 409 "ejsc_parser.y"
{ 
    yyval.vp = (tVariable*)malloc(sizeof(tVariable)); 
    (*(yyval.vp)) = yyvsp[0].v;
}
break;
case 17:
#line 413 "ejsc_parser.y"
{ 
    yyval.vp = (tVariable*)malloc(sizeof(tVariable)); 
    (*(yyval.vp)) = yyvsp[0].v;
}
break;
case 18:
#line 420 "ejsc_parser.y"
{ 
#ifdef EJSCCDEBUG
    if ( ejsccdebug ) {
      printf("ejsccdebug: Format list found.\n");
      fflush(stdout);
    }
#endif
    yyval.vp = yyvsp[-1].vp; 
}
break;
case 19:
#line 429 "ejsc_parser.y"
{ yyval.vp = NULL; }
break;
case 20:
#line 433 "ejsc_parser.y"
{
    int i = first_null_index(yyvsp[-2].vp);
    if ( i > MAXVARS-1 ) { 
      /* FIXME: realloc */
      fprintf(stderr, "Fatal error: Too many formats on line %d.\n", yylineno); 
      exit(1);
    } else {
      yyval.vp = yyvsp[-2].vp;
      yyval.vp[i] = (*(yyvsp[0].vp));
    }
  }
break;
case 21:
#line 444 "ejsc_parser.y"
{ 
    int size = MAXVARS;
    int i;
    yyval.vp = (tVariable *)malloc(size * sizeof(tVariable)); 
    /* Set all variables to 'nullVar' */
    for (i=0 ; i<size; yyval.vp[i++]=nullVar);
    yyval.vp[0] = (*(yyvsp[0].vp));
  }
break;
case 22:
#line 455 "ejsc_parser.y"
{ yyval.vp = yyvsp[-1].vp; }
break;
case 23:
#line 456 "ejsc_parser.y"
{
    /*
    $<vp>$ = (tVariable*)malloc(sizeof(tVariable)); 
    (*($<vp>$)) = $<v>2; 
    */
    yyval.vp = &yyvsp[-1].v;
  }
break;
case 24:
#line 466 "ejsc_parser.y"
{
    int ***tmp_eval;
    int i,j,k;
#ifdef EJSCCDEBUG
    if ( ejsccdebug ) {
      printf("ejsccdebug: Format call '%s' found.\n", yyvsp[-3].v.value.d);
      fflush(stdout);
    }
#endif
    yyval.v.type = tOb;
    yyval.v.value.o.objName = yyvsp[-3].v.value.d;
    yyval.v.value.o.type = Format;
    /* Allocate memory for argument lists */
    yyval.v.value.o.arguments = (tVariable**)malloc(2*sizeof(tVariable*));
    yyval.v.value.o.arguments[0] = yyvsp[-1].vp;
    yyval.v.value.o.arguments[1] = NULL;
    tmp_eval = yyval.v.value.o.argumentEvalId = 
      (int ***)malloc(2 * sizeof(int **));
    for ( i=0 ; i<2 ; i++ ) {
      tmp_eval[i] = (int **)malloc(MAXVARS * sizeof(int*));
      for ( j=0 ; j<MAXVARS ; j++ ) {
	tmp_eval[i][j] = (int *)malloc(MAXSYMS * sizeof(int));
	for ( k=0 ; k<MAXSYMS ; tmp_eval[i][j][k++] = -1 );
      }
    }
    /* Allocate memory for return values and reset them */
    yyval.v.value.o.returnValues = (char **)malloc(MAXSYMS * sizeof(char *));
    memset(yyval.v.value.o.returnValues, (int)NULL, MAXSYMS * sizeof(char *));
    /* Formats don't have formats... */
    yyval.v.value.o.formats = NULL;
    yyval.v.value.o.formatEvalId = NULL;
    yyval.v.scope = currentSym;
  }
break;
case 25:
#line 502 "ejsc_parser.y"
{ yyval.b = true; }
break;
case 26:
#line 503 "ejsc_parser.y"
{ yyval.b = false; }
break;
case 27:
#line 507 "ejsc_parser.y"
{ yyval.v = yyvsp[0].v; }
break;
case 28:
#line 508 "ejsc_parser.y"
{ yyval.v = yyvsp[0].v; }
break;
#line 898 "ejsc_parser.c"
    }
    yyssp -= yym;
    yystate = *yyssp;
    yyvsp -= yym;
    yym = yylhs[yyn];
    if (yystate == 0 && yym == 0)
    {
#if YYDEBUG
        if (yydebug)
            printf("%sdebug: after reduction, shifting from state 0 to\
 state %d\n", YYPREFIX, YYFINAL);
#endif
        yystate = YYFINAL;
        *++yyssp = YYFINAL;
        *++yyvsp = yyval;
        if (yychar < 0)
        {
            if ((yychar = yylex()) < 0) yychar = 0;
#if YYDEBUG
            if (yydebug)
            {
                yys = 0;
                if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
                if (!yys) yys = "illegal-symbol";
                printf("%sdebug: state %d, reading %d (%s)\n",
                        YYPREFIX, YYFINAL, yychar, yys);
            }
#endif
        }
        if (yychar == 0) goto yyaccept;
        goto yyloop;
    }
    if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
            yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
        yystate = yytable[yyn];
    else
        yystate = yydgoto[yym];
#if YYDEBUG
    if (yydebug)
        printf("%sdebug: after reduction, shifting from state %d \
to state %d\n", YYPREFIX, *yyssp, yystate);
#endif
    if (yyssp >= yysslim && yygrowstack())
    {
        goto yyoverflow;
    }
    *++yyssp = yystate;
    *++yyvsp = yyval;
    goto yyloop;
yyoverflow:
    yyerror("yacc stack overflow");
yyabort:
    return (1);
yyaccept:
    return (0);
}