Web alhem.net

rowo.cpp

Go to the documentation of this file.

#ifndef lint
static char yysccsid[] = "@(#)yaccpar   1.9 (Berkeley) 02/21/93";
#endif
#define YYBYACC 1
#define YYMAJOR 1
#define YYMINOR 9
#define yyclearin (yychar=(-1))
#define yyerrok (yyerrflag=0)
#define YYRECOVERING (yyerrflag!=0)
#define YYPREFIX "yy"
#line 2 "rowo.y"
#include <string>
#include <stdio.h>
#include <stdlib.h>
#include <vector>
#include <map>
#include "robotworld.h"

#define C the_str[the_ptr]
#define C1 the_str[the_ptr+1]

/* local*/
static  char the_str[1000];
static  int the_ptr;
static  int line;
static  FILE *fil;
static  int uniq;
static  std::vector<VARIABLE *> variables;
static  std::string codestr; /* total bytecode string*/
static  std::map<std::string, int> codemap; /* method to address map*/
static  bool failed;
static  int x_ptr;

const std::string& GetCodestr() { return codestr; }
std::map<std::string, int>& GetCodemap() { return codemap; }
std::vector<VARIABLE *>& GetVariables() { return variables; }
bool GetFailed() { return failed; }

/* forward declarations*/
int yyparse();
short reg_variable(const std::string& ,int type = 0);
void check_property(const std::string& , const std::string& );
void check_method(const std::string& , const std::string& );
void add_bytecode(char *, int opcode);
void add_bytecode(char *, int opcode, short val);
void add_bytecode(char *, int opcode, long val);
void add_bytecode(char *, int opcode, const std::string& object, const std::string& property_or_method);
#line 40 "rowo.y"
typedef union {
        long l;
        char str[1000];
        struct codestruct {
                char code[10000];
                char bytecode[10000];
        } code;
} YYSTYPE;
#line 58 "y.tab.c"
#define INT 257
#define IDENTIFIER 258
#define COMMENT 259
#define Object 260
#define EnumObjectType 261
#define Cos 262
#define Sin 263
#define If 264
#define Loop 265
#define EQ 266
#define NEQ 267
#define AND 268
#define OR 269
#define YYERRCODE 256
short yylhs[] = {                                        -1,
    0,   10,   10,   11,   12,   12,    4,    4,    5,    5,
    5,    5,    5,    6,    7,    7,    8,    8,    9,    2,
    2,    2,    3,    1,    1,    1,    1,    1,    1,    1,
    1,    1,    1,    1,    1,    1,    1,    1,    1,
};
short yylen[] = {                                         2,
    1,    1,    2,    2,    2,    3,    1,    2,    1,    1,
    1,    1,    1,    5,    3,    5,    7,    7,    6,    0,
    1,    3,    1,    1,    1,    3,    1,    3,    3,    3,
    3,    3,    3,    5,    3,    2,    3,    3,    3,
};
short yydefred[] = {                                      0,
    0,    0,    0,    2,    0,    4,    3,    0,   13,    0,
    0,    5,    0,    7,    9,   10,   11,   12,    0,    0,
    0,    6,    8,   24,    0,    0,   25,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,   36,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,   28,   26,    0,    0,   35,    0,    0,    0,    0,
    0,    0,    0,   31,   32,    0,    0,   21,    0,   14,
    0,    0,    0,   19,    0,   18,   17,    0,   22,
};
short yydgoto[] = {                                       2,
   66,   67,   68,   13,   14,   15,   16,   17,   18,    3,
    4,    6,
};
short yysindex[] = {                                   -257,
 -121,    0, -257,    0, -106,    0,    0,  -53,    0,  -26,
  -19,    0, -103,    0,    0,    0,    0,    0,  -33, -233,
   75,    0,    0,    0,  -14,  -11,    0, -249,   75,   75,
   86,  -34,   58, -227, -222,   -9,   -8,    0,   71,   75,
   75,   75,   75,   75,   75,   75,   75,   75,   75,   75,
 -121,    0,    0, -219, -213,    0,    4,    4,   97,   97,
   80,  -32,  -32,    0,    0,   86,  -37,    0,   86,    0,
 -121, -121,   75,    0,   75,    0,    0,   86,    0,
};
short yyrindex[] = {                                      0,
    0,    0,   50,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,  -29,    0,    0,    0,    0,    0,
  -92,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,  -36,    0,
    0,    0,    0,    0,    0,    0,   12,   25,   39,   46,
    0,  -15,   -1,    0,    0,  -24,    0,    0,  -84,    0,
    0,    0,    0,    0,    0,    0,    0,   53,    0,
};
short yygindex[] = {                                      0,
  163,    0,  -23,    0,   41,    0,    0,    0,    0,    0,
   52,  -48,
};
#define YYTABLESIZE 364
short yytable[] = {                                      29,
    1,    5,   70,   74,   20,   49,   30,   19,   36,   47,
   37,   27,   27,   27,   48,   27,   23,   27,   12,   20,
   21,   22,   76,   77,   32,   30,   50,   30,   27,   30,
   52,   34,   15,   27,   35,   53,   54,   55,   71,   29,
   16,   29,   30,   29,   72,   47,   46,   30,   45,    1,
   48,   79,   33,   23,    7,    0,   29,    0,    0,    0,
    0,   29,    0,    0,    0,   37,   44,    0,    0,   33,
    0,    0,    0,    0,    0,    0,    0,    0,    0,   38,
    0,    0,   37,    0,    0,    0,   39,    0,    0,    0,
    0,    0,    0,   34,    0,   27,   38,    0,   51,   47,
   46,    0,   45,   39,   48,    0,    0,   29,    0,   30,
   34,   56,   47,   46,   30,   45,    0,   48,    0,    0,
   44,   47,   46,   29,   45,    0,   48,   47,   46,    0,
   45,    0,   48,   44,    0,    0,   33,   73,   47,   46,
    0,   45,   44,   48,    0,    0,    0,    0,   44,   37,
    0,    8,    9,   10,    8,    9,   10,   11,    0,   44,
   11,    0,    0,   38,    0,   15,   15,   15,    0,    0,
   39,   15,    0,   16,   16,   16,    0,   34,    0,   16,
    0,   31,    0,   33,    0,    0,    0,    0,    0,    0,
    0,   38,   39,    0,    0,    0,    0,    0,    0,    0,
    0,    0,   57,   58,   59,   60,   61,   62,   63,   64,
   65,    0,   69,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,   24,   25,    0,   26,   27,   27,   27,
   27,   28,   75,   20,   27,   78,   27,   27,   27,   27,
   27,    0,   30,   30,   30,   23,    0,    0,   30,    0,
   30,   30,   30,   30,   30,    0,   29,   29,   29,    0,
    0,    0,   29,    0,   29,   29,   29,   29,   29,   33,
   33,   33,    0,    0,    0,   33,    0,   33,   33,   33,
   33,   33,   37,   37,   37,    0,    0,    0,   37,    0,
   37,   37,   37,   37,   37,    0,   38,   38,   38,    0,
    0,    0,   38,   39,   39,   39,   38,   38,   38,   39,
   34,   34,   34,   39,   39,   39,   34,    0,    0,    0,
    0,    0,   34,   40,   41,   42,   43,    0,    0,    0,
    0,   24,   25,    0,   26,   27,   40,   41,   42,   43,
    0,    0,    0,    0,    0,   40,   41,   42,   43,    0,
    0,   40,   41,   42,   43,    0,    0,    0,    0,    0,
    0,    0,   40,   41,
};
short yycheck[] = {                                      33,
  258,  123,   51,   41,   41,   40,   40,   61,  258,   42,
  260,   41,   42,   43,   47,   45,   41,   47,  125,   46,
   40,  125,   71,   72,  258,   41,   61,   43,   58,   45,
  258,   46,  125,   63,   46,  258,   46,   46,  258,   41,
  125,   43,   58,   45,  258,   42,   43,   63,   45,    0,
   47,   75,   41,   13,    3,   -1,   58,   -1,   -1,   -1,
   -1,   63,   -1,   -1,   -1,   41,   63,   -1,   -1,   58,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   41,
   -1,   -1,   58,   -1,   -1,   -1,   41,   -1,   -1,   -1,
   -1,   -1,   -1,   41,   -1,  125,   58,   -1,   41,   42,
   43,   -1,   45,   58,   47,   -1,   -1,   33,   -1,  125,
   58,   41,   42,   43,   40,   45,   -1,   47,   -1,   -1,
   63,   42,   43,  125,   45,   -1,   47,   42,   43,   -1,
   45,   -1,   47,   63,   -1,   -1,  125,   58,   42,   43,
   -1,   45,   63,   47,   -1,   -1,   -1,   -1,   63,  125,
   -1,  258,  259,  260,  258,  259,  260,  264,   -1,   63,
  264,   -1,   -1,  125,   -1,  258,  259,  260,   -1,   -1,
  125,  264,   -1,  258,  259,  260,   -1,  125,   -1,  264,
   -1,   19,   -1,   21,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   29,   30,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   40,   41,   42,   43,   44,   45,   46,   47,
   48,   -1,   50,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,  257,  258,   -1,  260,  261,  258,  259,
  260,  265,  270,  270,  264,   73,  266,  267,  268,  269,
  270,   -1,  258,  259,  260,  270,   -1,   -1,  264,   -1,
  266,  267,  268,  269,  270,   -1,  258,  259,  260,   -1,
   -1,   -1,  264,   -1,  266,  267,  268,  269,  270,  258,
  259,  260,   -1,   -1,   -1,  264,   -1,  266,  267,  268,
  269,  270,  258,  259,  260,   -1,   -1,   -1,  264,   -1,
  266,  267,  268,  269,  270,   -1,  258,  259,  260,   -1,
   -1,   -1,  264,  258,  259,  260,  268,  269,  270,  264,
  258,  259,  260,  268,  269,  270,  264,   -1,   -1,   -1,
   -1,   -1,  270,  266,  267,  268,  269,   -1,   -1,   -1,
   -1,  257,  258,   -1,  260,  261,  266,  267,  268,  269,
   -1,   -1,   -1,   -1,   -1,  266,  267,  268,  269,   -1,
   -1,  266,  267,  268,  269,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,  266,  267,
};
#define YYFINAL 2
#ifndef YYDEBUG
#define YYDEBUG 0
#endif
#define YYMAXTOKEN 270
#if YYDEBUG
char *yyname[] = {
"end-of-file",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
"'!'",0,0,0,0,0,0,"'('","')'","'*'","'+'",0,"'-'","'.'","'/'",0,0,0,0,0,0,0,0,0,
0,"':'",0,0,"'='",0,"'?'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'{'",0,"'}'",0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,"INT","IDENTIFIER","COMMENT","Object","EnumObjectType",
"Cos","Sin","If","Loop","EQ","NEQ","AND","OR","\", \"",
};
char *yyrule[] = {
"$accept : program",
"program : methods",
"methods : method",
"methods : methods method",
"method : IDENTIFIER scope",
"scope : '{' '}'",
"scope : '{' statements '}'",
"statements : statement",
"statements : statements statement",
"statement : if_statement",
"statement : assign_statement",
"statement : loop_statement",
"statement : object_statement",
"statement : COMMENT",
"if_statement : If '(' expr ')' scope",
"assign_statement : IDENTIFIER '=' expr",
"assign_statement : Object '.' IDENTIFIER '=' expr",
"loop_statement : IDENTIFIER '=' Loop Object '.' IDENTIFIER scope",
"loop_statement : IDENTIFIER '=' Loop IDENTIFIER '.' IDENTIFIER scope",
"object_statement : Object '.' IDENTIFIER '(' parameters ')'",
"parameters :",
"parameters : parameter",
"parameters : parameters \", \" parameter",
"parameter : expr",
"expr : INT",
"expr : EnumObjectType",
"expr : Object '.' IDENTIFIER",
"expr : IDENTIFIER",
"expr : IDENTIFIER '.' IDENTIFIER",
"expr : expr '+' expr",
"expr : expr '-' expr",
"expr : expr '*' expr",
"expr : expr '/' expr",
"expr : expr EQ expr",
"expr : expr '?' expr ':' expr",
"expr : '(' expr ')'",
"expr : '!' expr",
"expr : expr NEQ expr",
"expr : expr AND expr",
"expr : expr OR expr",
};
#endif
#ifdef YYSTACKSIZE
#undef YYMAXDEPTH
#define YYMAXDEPTH YYSTACKSIZE
#else
#ifdef YYMAXDEPTH
#define YYSTACKSIZE YYMAXDEPTH
#else
#define YYSTACKSIZE 500
#define YYMAXDEPTH 500
#endif
#endif
int yydebug;
int yynerrs;
int yyerrflag;
int yychar;
short *yyssp;
YYSTYPE *yyvsp;
YYSTYPE yyval;
YYSTYPE yylval;
short yyss[YYSTACKSIZE];
YYSTYPE yyvs[YYSTACKSIZE];
#define yystacksize YYSTACKSIZE
#line 420 "rowo.y"


int yyerror(char *s)
{
        int i;

        printf("%d>%s\n", line, the_str);
        printf("%d ", line);
        for (i = 1; i < x_ptr; i++)
                printf(" ");
        printf("^ yyerror '%s'\n", s);
        failed = true;
        return 0;
}


int yylex()
{
        size_t x;

        while (C == ' ' || C == 9)
        {
                the_ptr++;
        }
        while (!C && !feof(fil))
        {
                fgets(the_str, 1000, fil);
                the_str[strlen(the_str) - 1] = 0;
                for (size_t i = 0; i < strlen(the_str); i++)
                        if (the_str[i] == 9)
                                the_str[i] = ' ';
                the_ptr = 0;
                line++;
                while (C == ' ' || C == 9)
                {
                        the_ptr++;
                }
        }
        if (feof(fil))
        {
                return 0;
        }
        x_ptr = the_ptr;
        if (C == '=' && C1 == '=')
        {
                the_ptr += 2;
                return EQ;
        }
        if (C == '!' && C1 == '=')
        {
                the_ptr += 2;
                return NEQ;
        }
        if (C == '&' && C1 == '&')
        {
                the_ptr += 2;
                return AND;
        }
        if (C == '|' && C1 == '|')
        {
                the_ptr += 2;
                return OR;
        }
        if (C == '/' && C1 == '/')
        {
                strcpy(yylval.str, the_str + the_ptr);
                C = 0;
                return COMMENT;
        }
        if (isalpha(C))
        {
                x = the_ptr++;
                while (isalnum(C) || C == '_')
                {
                        the_ptr++;
                }
                std::string ord = static_cast<std::string>(the_str).substr(x, the_ptr - x);
                strcpy(yylval.str, ord.c_str());
                if (ord == "if")
                        return If;
                if (ord == "radar" || ord == "turret" || ord == "gun" || ord == "robot" || ord == "shields" )
                {
                        return Object;
                }
                if (ord == "Robot") // Robot, Portal, Powerup, Base, Nothing, Item
                {
                        yylval.l = MAPOBJECT_ROBOT;
                        return EnumObjectType;
                }
                if (ord == "Portal")
                {
                        yylval.l = MAPOBJECT_PORTAL;
                        return EnumObjectType;
                }
                if (ord == "Powerup")
                {
                        yylval.l = MAPOBJECT_POWERUP_UNKNOWN;
                        return EnumObjectType;
                }
                if (ord == "Base")
                {
                        yylval.l = MAPOBJECT_BASE;
                        return EnumObjectType;
                }
                if (ord == "Item")
                {
                        yylval.l = MAPOBJECT_ITEM;
                        return EnumObjectType;
                }
                if (ord == "Nothing")
                {
                        yylval.l = MAPOBJECT_NOTHING;
                        return EnumObjectType;
                }
                if (ord == "loop")
                        return Loop;
                return IDENTIFIER;
        }
        if (isdigit(C))
        {
                bool f = false;
                x = the_ptr;
                while (isdigit(C)) // || C == '.' || C == 'e' || C == 'E')
                {
                        if (!isdigit(C))
                        f = true;
                        the_ptr++;
                }
                std::string ord = static_cast<std::string>(the_str).substr(x, the_ptr - x);
/*
                if (f)
                {
                        yylval.d = atof(ord.c_str());
                        return FLOAT;
                }
*/
                yylval.l = atol(ord.c_str());
                return INT;
        }
        return the_str[the_ptr++];
}


void parse_file(const std::string& filename)
{
        *the_str = 0;
        the_ptr = 0;
        line = 0;
        uniq = 1;
        codestr = "";
        failed = false;
        while (codemap.size())
        {
                codemap.erase(codemap.begin());
        }
        while (variables.size())
        {
                variables.erase(variables.begin());
        }
        if ((fil = fopen(filename.c_str(), "rt")) != NULL)
        {
                yyparse();
                fclose(fil);
        }
        else
        {
                fprintf(stderr, "Couldn't open '%s'...\n", filename.c_str());
                failed = true;
        }
}


short reg_variable(const std::string& name,int type)
{
        for (std::vector<VARIABLE *>::iterator it = variables.begin(); it != variables.end(); it++)
        {
                VARIABLE *p = *it;
                if (name == p -> name)
                {
                        if (type && !p -> type)
                                p -> type = type;
                        if (type && p -> type && type != p -> type)
                                fprintf(stderr,"Variable type mismatch: '%s'\n",name.c_str());
                        return p -> nr;
                }
        }
        VARIABLE *p = new VARIABLE(name, type, variables.size());
        variables.push_back(p);
        return p -> nr;
}


void check_property(const std::string& object, const std::string& property)
{
}


void check_method(const std::string& object, const std::string& method)
{
}


void add_bytecode(char *s, int opcode)
{
        sprintf(s + strlen(s), "%02x", opcode);
}


void add_bytecode(char *s, int opcode, short valx)
{
        unsigned short val;
        if (valx < 0)
        {
                val = -valx;
                val |= 0x8000;
        }
        else
        {
                val = valx;
        }
        sprintf(s + strlen(s), "%02x%04x", opcode, val);
}


void add_bytecode(char *s, int opcode, long val)
{
        sprintf(s + strlen(s), "%02x%08lx", opcode, val);
}


void add_bytecode(char *s, int opcode, const std::string& object, const std::string& property_or_method)
{
        int objectcode = 0;
        int val = 0;
        {
                // robot, radar, turret, gun, shields
                if (!strcmp(object.c_str(), "robot"))
                {
                        objectcode = ROBOTOBJECT_ROBOT;
                        if (property_or_method == "ok")
                                val = 1;
                        if (property_or_method == "damage")
                                val = 2;
                        if (property_or_method == "repair_rate")
                                val = 3;
                        if (property_or_method == "inventory")
                                val = 4;
                        if (property_or_method == "power")
                                val = 5;
                        if (property_or_method == "charging")
                                val = 6;
                }
                else
                if (!strcmp(object.c_str(), "radar"))
                {
                        objectcode = ROBOTOBJECT_RADAR;
                        if (property_or_method == "ok")
                                val = 1;
                        if (property_or_method == "damage")
                                val = 2;
                        if (property_or_method == "repair_rate")
                                val = 3;
                }
                else
                if (!strcmp(object.c_str(), "turret"))
                {
                        objectcode = ROBOTOBJECT_TURRET;
                        if (property_or_method == "ok")
                                val = 1;
                        if (property_or_method == "damage")
                                val = 2;
                        if (property_or_method == "repair_rate")
                                val = 3;
                }
                else
                if (!strcmp(object.c_str(), "gun"))
                {
                        objectcode = ROBOTOBJECT_GUN;
                        if (property_or_method == "ok")
                                val = 1;
                        if (property_or_method == "damage")
                                val = 2;
                        if (property_or_method == "repair_rate")
                                val = 3;
                }
                else
                if (!strcmp(object.c_str(), "shields"))
                {
                        objectcode = ROBOTOBJECT_SHIELDS;
                        if (property_or_method == "ok")
                                val = 1;
                        if (property_or_method == "damage")
                                val = 2;
                        if (property_or_method == "repair_rate")
                                val = 3;
                }
                else
                {
                        printf("Unknown object: %s\n", object.c_str() );
                        failed = true;
                }
        }
        sprintf(s + strlen(s), "%02x%02x%02x", opcode, objectcode, val);
}


#line 591 "y.tab.c"
#define YYABORT goto yyabort
#define YYREJECT goto yyabort
#define YYACCEPT goto yyaccept
#define YYERROR goto yyerrlab
int
yyparse()
{
    register int yym, yyn, yystate;
#if YYDEBUG
    register char *yys;
    extern char *getenv();

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

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

    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 >= yyss + yystacksize - 1)
        {
            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;
#ifdef lint
    goto yynewerror;
#endif
yynewerror:
    yyerror("syntax error");
#ifdef lint
    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 >= yyss + yystacksize - 1)
                {
                    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 4:
#line 80 "rowo.y"
{
                /* if (*scope) ...*/
                add_bytecode(yyvsp[0].code.bytecode, 0x84); /* ret*/
                /* create codestr / codemap*/
                codemap[yyvsp[-1].str] = codestr.size() / 2; /* entry point*/
                codestr += yyvsp[0].code.bytecode;
        }
break;
case 5:
#line 88 "rowo.y"
{
                *yyval.code.code = 0;
                *yyval.code.bytecode = 0;
        }
break;
case 6:
#line 92 "rowo.y"
{
                strcpy(yyval.code.code, yyvsp[-1].code.code);
                /* bytecode*/
                strcpy(yyval.code.bytecode, yyvsp[-1].code.bytecode);
        }
break;
case 7:
#line 98 "rowo.y"
{
                strcpy(yyval.code.code, yyvsp[0].code.code);
                /* bytecode*/
                strcpy(yyval.code.bytecode, yyvsp[0].code.bytecode);
        }
break;
case 8:
#line 103 "rowo.y"
{
                strcpy(yyval.code.code, yyvsp[-1].code.code);
                strcat(yyval.code.code, yyvsp[0].code.code);
                /* bytecode*/
                strcpy(yyval.code.bytecode, yyvsp[-1].code.bytecode);
                strcat(yyval.code.bytecode, yyvsp[0].code.bytecode);
        }
break;
case 9:
#line 111 "rowo.y"
{
                strcpy(yyval.code.code, yyvsp[0].code.code);
                /* bytecode*/
                strcpy(yyval.code.bytecode, yyvsp[0].code.bytecode);
        }
break;
case 10:
#line 116 "rowo.y"
{
                strcpy(yyval.code.code, yyvsp[0].code.code);
                /* bytecode*/
                strcpy(yyval.code.bytecode, yyvsp[0].code.bytecode);
        }
break;
case 11:
#line 121 "rowo.y"
{
                strcpy(yyval.code.code, yyvsp[0].code.code);
                /* bytecode*/
                strcpy(yyval.code.bytecode, yyvsp[0].code.bytecode);
        }
break;
case 12:
#line 126 "rowo.y"
{
                strcpy(yyval.code.code, yyvsp[0].code.code);
                /* bytecode*/
                strcpy(yyval.code.bytecode, yyvsp[0].code.bytecode);
        }
break;
case 13:
#line 131 "rowo.y"
{       *yyval.code.code = 0;
                *yyval.code.bytecode = 0;
        }
break;
case 14:
#line 135 "rowo.y"
{
                /* if (*scope) ...*/
                int x = uniq++;
                *yyval.code.code = 0;
                strcat(yyval.code.code, "       // if_statement\n");
                strcat(yyval.code.code, yyvsp[-2].code.code);
                sprintf(yyval.code.code + strlen(yyval.code.code), "    jz      label_%d\n", x);
                strcat(yyval.code.code, yyvsp[0].code.code);
                sprintf(yyval.code.code + strlen(yyval.code.code), "label_%d:\n", x);
                /* bytecode*/
                strcpy(yyval.code.bytecode, yyvsp[-2].code.bytecode); /* get expression*/
                short len = strlen(yyvsp[0].code.bytecode) / 2; /* length in bytes*/
                add_bytecode(yyval.code.bytecode, 0x0a, len); /* jz*/
                strcat(yyval.code.bytecode, yyvsp[0].code.bytecode); /* scope*/
        }
break;
case 15:
#line 151 "rowo.y"
{
                *yyval.code.code = 0;
                strcat(yyval.code.code, "       // assign_statement\n");
                strcat(yyval.code.code, yyvsp[0].code.code);
                sprintf(yyval.code.code + strlen(yyval.code.code), "    ld      $%s, a\n", yyvsp[-2].str);
                
                short var = reg_variable(yyvsp[-2].str, 1);
                /* bytecode*/
                strcpy(yyval.code.bytecode, yyvsp[0].code.bytecode); /* get expression*/
                add_bytecode(yyval.code.bytecode, 0x0d, var); /* variable[] = register1*/
        }
break;
case 16:
#line 162 "rowo.y"
{
                *yyval.code.code = 0;
                strcat(yyval.code.code, "       // assign_statement\n");
                strcat(yyval.code.code, yyvsp[0].code.code);
                sprintf(yyval.code.code + strlen(yyval.code.code), "    ld      $%s.%s, a\n", yyvsp[-4].str, yyvsp[-2].str);
                
                check_property(yyvsp[-4].str, yyvsp[-2].str);
                /* bytecode*/
                strcpy(yyval.code.bytecode, yyvsp[0].code.bytecode); /* get expression*/
                add_bytecode(yyval.code.bytecode, 0x0f, yyvsp[-4].str, yyvsp[-2].str); /* assign object.property*/
        }
break;
case 17:
#line 174 "rowo.y"
{
                short var = reg_variable(yyvsp[-6].str, 2);
                check_property(yyvsp[-3].str, yyvsp[-1].str);
                /* bytecode*/
                *yyval.code.bytecode = 0;
                add_bytecode(yyval.code.bytecode, 0x82, yyvsp[-3].str, yyvsp[-1].str);  /* loop init object.property*/
                strcat(yyval.code.bytecode, "0000");                    /* loop body length*/
                size_t x = strlen(yyval.code.bytecode);
                add_bytecode(yyval.code.bytecode, 0x83, var);           /* assign object variable: 3 bytes*/
                short len = strlen(yyvsp[0].code.bytecode) / 2 + 3;     /* length in bytes*/
                add_bytecode(yyval.code.bytecode, 0x0a, len);           /* jz end of loop: 3 bytes*/
                strcat(yyval.code.bytecode, yyvsp[0].code.bytecode);            /* scope*/
                len = strlen(yyvsp[0].code.bytecode) / 2 + 6;
                len = -len;
                add_bytecode(yyval.code.bytecode, 0x81, len);           /* jmp loop beginning*/
                
                size_t body = (strlen(yyval.code.bytecode) - x) / 2;
                char slask[100];
                sprintf(slask, "%04x", body);
                memcpy(yyval.code.bytecode + x - 4, slask, 4);
        }
break;
case 18:
#line 195 "rowo.y"
{
                short var1 = reg_variable(yyvsp[-6].str, 2);
                short var2 = reg_variable(yyvsp[-3].str);
                short len = strlen(yyvsp[-1].str);
                *yyval.code.bytecode = 0;
                add_bytecode(yyval.code.bytecode, 0x11, var2);          /* register1 = variable[zz zz].property*/
                sprintf(yyval.code.bytecode + strlen(yyval.code.bytecode), "%02x", len);
                for (int i = 0; i < len; i++)