SimpleYacc.y

%{
    public StListNode root;
    public Parser(AbstractScanner<ValueType, LexLocation> scanner) : base(scanner) { }
    private bool InDefSect = false;
%}

%output = SimpleYacc.cs

%union {
            public bool bVal;
            public int iVal;
            public string sVal;
            public Node nVal;
            public ExprNode eVal;
            public StatementNode stVal;
            public StListNode blVal;
       }

%using System.IO;
%using ProgramTree;

%namespace SimpleParser

%token BEGIN END ASSIGN SEMICOLON FOR COMMA COLON LPAR RPAR WHILE IF ELSE INPUT PRINT
VAR OR AND EQUAL NOTEQUAL LESS GREATER EQGREATER EQLESS GOTO PLUS MINUS MULT DIV NOT
%token <iVal> INUM
%token <bVal> BOOL
%token <sVal> ID

%type <eVal> expr ident A B C E T F exprlist
%type <stVal> assign statement for while if input print varlist var labelstatement goto block
%type <blVal> stlist progr

%%

progr   : stlist { root = $1; }
        ;

stlist	: statement { $$ = new StListNode($1); }
        | stlist statement
            {
                $1.Add($2);
                $$ = $1;
            }
        ;

statement: assign SEMICOLON { $$ = $1; }
        | for { $$ = $1; }
        | while { $$ = $1; }
        | if { $$ = $1; }
        | block { $$ = $1; }
        | input SEMICOLON { $$ = $1; }
        | print SEMICOLON { $$ = $1; }
        | var SEMICOLON { $$ = $1; }
        | goto SEMICOLON { $$ = $1; }
        | labelstatement { $$ = $1; }
        ;

ident 	: ID {
            if (!InDefSect)
                if (!SymbolTable.vars.ContainsKey($1))
                    throw new Exception("("+@1.StartLine+","+@1.StartColumn+"): Variable "+$1+" not described");
            $$ = new IdNode($1);
        }
        ;

assign 	: ident ASSIGN expr { $$ = new AssignNode($1 as IdNode, $3); }
        ;

block	: BEGIN stlist END { $$ = new BlockNode($2); }
        ;

for		: FOR ident ASSIGN expr COMMA expr statement
        { $$ = new ForNode($2 as IdNode, $4, $6, $7); }
        ;

while	: WHILE expr statement { $$ = new WhileNode($2, $3); }
        ;

if		: IF expr statement ELSE statement { $$ = new IfElseNode($2, $3, $5); }
        | IF expr statement { $$ = new IfElseNode($2, $3); }
        ;

expr	: expr OR A { $$ = new BinOpNode($1, $3, OpType.OR); }
        | A { $$ = $1; }
        ;

A		: A AND B { $$ = new BinOpNode($1, $3, OpType.AND); }
        | B { $$ = $1; }
        ;

B		: B EQUAL C { $$ = new BinOpNode($1, $3, OpType.EQUAL); }
        | B NOTEQUAL C { $$ = new BinOpNode($1, $3, OpType.NOTEQUAL); }
        | C { $$ = $1; }
        ;

C		: C GREATER E { $$ = new BinOpNode($1, $3, OpType.GREATER); }
        | C LESS E { $$ = new BinOpNode($1, $3, OpType.LESS); }
        | C EQGREATER E { $$ = new BinOpNode($1, $3, OpType.EQGREATER); }
        | C EQLESS E { $$ = new BinOpNode($1, $3, OpType.EQLESS); }
        | E { $$ = $1; }
        ;

E		: E PLUS T  { $$ = new BinOpNode($1, $3, OpType.PLUS); }
        | E MINUS T { $$ = new BinOpNode($1, $3, OpType.MINUS); }
        | T { $$ = $1; }
        ;

T		: T MULT F { $$ = new BinOpNode($1, $3, OpType.MULT); }
        | T DIV F { $$ = new BinOpNode($1, $3, OpType.DIV); }
        | F { $$ = $1; }
        ;

F		: ident { $$ = $1 as IdNode; }
        | INUM { $$ = new IntNumNode($1); }
        | LPAR expr RPAR { $$ = $2; }
        | BOOL { $$ = new BoolValNode($1); }
        | MINUS F { $$ = new UnOpNode($2, OpType.UNMINUS); }
        | NOT F { $$ = new UnOpNode($2, OpType.NOT);}
        ;

input	: INPUT LPAR ident RPAR { $$ = new InputNode($3 as IdNode); }
        ;

exprlist : expr { $$ = new ExprListNode($1); }
        | exprlist COMMA expr
        {
            ($1 as ExprListNode).Add($3);
            $$ = $1;
        }
        ;

print	: PRINT LPAR exprlist RPAR { $$ = new PrintNode($3 as ExprListNode); }
        ;

varlist	: ident { $$ = new VarListNode($1 as IdNode); }
        | varlist COMMA ident
        {
            ($1 as VarListNode).Add($3 as IdNode);
            $$ = $1;
        }
        ;

var		: VAR { InDefSect = true; } varlist
            {
                foreach (var v in ($3 as VarListNode).vars)
                    SymbolTable.NewVarDef(v.Name);
                InDefSect = false;
            }
        ;

goto	: GOTO INUM { $$ = new GotoNode($2); }
        ;

labelstatement	: INUM COLON statement { $$ = new LabelStatementNode($1, $3); }
        ;

%%