示例#1
0
 static void yy_reduce_proc(YY_PARSER pParser, int yyrule, YY_MINOR_TYPE yypgotominor, YY_STACK_ENTRY [] yystack)
 {
     if (reduceprocs[yyrule] != null)
     {
         reduceprocs[yyrule].reduce_proc(pParser, yypgotominor, yystack);
     }
 }
示例#2
0
    /* syntax error */
    static void yy_syntax_error(YY_PARSER pParser, int yymajor, YY_MINOR_TYPE yypminor)
    {
/* #line 13 "gram.y" */

        Console.WriteLine("Syntax Error! \n By Shift " + yymajor + " value(" + yypminor.yy_11 + ")");

/* #line 463 "yy_table.cs" */
    }
示例#3
0
        /* reduce function */
        public void reduce_proc(YY_PARSER pParser, YY_MINOR_TYPE yypgotominor, YY_STACK_ENTRY [] yystack)
        {
/* #line 34 "gram.y" */

            yypgotominor.yy_11 = yystack[pParser.yystack_top + (-2)].yyminor.yy_11 * yystack[pParser.yystack_top + (0)].yyminor.yy_11;

/* #line 212 "yy_table.cs" */
        }
示例#4
0
        /* reduce function */
        public void reduce_proc(YY_PARSER pParser, YY_MINOR_TYPE yypgotominor, YY_STACK_ENTRY [] yystack)
        {
/* #line 22 "gram.y" */

            Console.WriteLine("Result = " + yystack[pParser.yystack_top + (0)].yyminor.yy_11);

/* #line 179 "yy_table.cs" */
        }
示例#5
0
    public static void ParseFree(Object p)
    {
        YY_PARSER pParser = (YY_PARSER)p;

        if (pParser == null)
        {
            return;
        }
        while (pParser.yystack_top >= 0)
        {
            yy_pop_stack(pParser);
        }
        pParser = null;
    }
示例#6
0
    /* accept process */
    static void yy_accept(YY_PARSER pParser)
    {
        if (DEBUG != 0)
        {
            if (yytraceWriter != null)
            {
                yy_traceFile(yytraceWriter, yytracePrompt + "Accept!\r\n");
            }
        } /* DEBUG */

        while (pParser.yystack_top >= 0)
        {
            yy_pop_stack(pParser);
        }
    }
示例#7
0
        /* reduce function */
        public void reduce_proc(YY_PARSER pParser, YY_MINOR_TYPE yypgotominor, YY_STACK_ENTRY [] yystack)
        {
/* #line 38 "gram.y" */

            if (yystack[pParser.yystack_top + (0)].yyminor.yy_11 != 0)
            {
                yypgotominor.yy_11 = yystack[pParser.yystack_top + (-2)].yyminor.yy_11 / yystack[pParser.yystack_top + (0)].yyminor.yy_11;
            }
            else
            {
                Console.WriteLine("Divide by zero!");
            }

/* #line 226 "yy_table.cs" */
        }
示例#8
0
    /* parse failed */
    static void yy_parse_failed(YY_PARSER pParser)
    {
        if (DEBUG != 0)
        {
            if (yytraceWriter != null)
            {
                yy_traceFile(yytraceWriter, yytracePrompt + "Parse Failed!\r\n");
            }
        } /* DEBUG */

/* #line 17 "gram.y" */

        Console.WriteLine("Parse Failed!");
        Environment.Exit(0);
/* #line 480 "yy_table.cs" */
    }
示例#9
0
    static void yy_reduce(YY_PARSER pParser, int yyrule)
    {
        int yygoto;
        int yyaction;
        int yysize;

        YY_MINOR_TYPE yygotominor = new YY_MINOR_TYPE();

        if (DEBUG != 0)
        {
            if (yytraceWriter != null && yyrule >= 0 && yyrule < yy_ruleName.Length) /* missing realloc process or realloc stack failure */
            {
                yy_traceFile(yytraceWriter, yytracePrompt + "Reduce [" + yy_ruleName[yyrule] + "]\r\n");
            }
        } /* DEBUG */

        yy_reduce_proc(pParser, yyrule, yygotominor, pParser.yystack); /* invoke reduce code */

        yygoto = yyruleInfo[yyrule].lhs;
        yysize = yyruleInfo[yyrule].nrhs;

        yyaction             = yy_find_reduce_action(pParser.yystack[pParser.yystack_top - yysize].yystate, yygoto);
        pParser.yystack_top -= yysize;

        if (yyaction < YY_NSTATE)/* nonterminal shift so yyaction need less state number */

        {
            if (DEBUG != 0)
            {
                /* if not debugging direct shift action improve performance */
                pParser.yystack_top++;
                pParser.yystack[pParser.yystack_top].yystate = yyaction;
                pParser.yystack[pParser.yystack_top].yymajor = yygoto;
                pParser.yystack[pParser.yystack_top].yyminor = yygotominor;
            } /* DEBUG */
            else
            {
                yy_shift(pParser, yyaction, yygoto, yygotominor);
            }
        }
        else if (yyaction == YY_ACCEPT_ACTION)
        {
            yy_accept(pParser);
        }
    }
示例#10
0
    static void yy_shift(YY_PARSER pParser, int yynewState, int yymajor, YY_MINOR_TYPE yypminor)
    {
        pParser.yystack_top++;

        if (pParser.yystack_top >= pParser.yystack_depth)
        {
            if (DEBUG != 0)
            {
                if (yytraceWriter != null) /* trace stack overflow */
                {
                    yy_traceFile(yytraceWriter, yytracePrompt + "Stack Overflow ! Try realloc stack.\r\n");
                }
            } /* DEBUG */
            YY_STACK_ENTRY [] yystack = pParser.yystack;
            pParser.yystack = new YY_STACK_ENTRY[pParser.yystack_depth * 2];
            /* move to new stack */
            for (int i = 0; i < pParser.yystack_depth; i++)
            {
                pParser.yystack[i] = yystack[i];
            }
            pParser.yystack_depth *= 2;
        }
        /* entry stack */

        pParser.yystack[pParser.yystack_top]         = new YY_STACK_ENTRY();
        pParser.yystack[pParser.yystack_top].yystate = yynewState;
        pParser.yystack[pParser.yystack_top].yymajor = yymajor;
        pParser.yystack[pParser.yystack_top].yyminor = yypminor;

        if (DEBUG != 0)
        {
            if (yytraceWriter != null && pParser.yystack_top > 0)
            {
                int i;
                yy_traceFile(yytraceWriter, yytracePrompt + "Shift " + get_symbolName(yymajor) + " => State(" + yynewState + ")\r\n");
                yy_traceFile(yytraceWriter, yytracePrompt + "Stack:");
                for (i = 0; i <= pParser.yystack_top; i++)
                {
                    yy_traceFile(yytraceWriter, " " + get_symbolName(pParser.yystack[i].yymajor));
                }
                yy_traceFile(yytraceWriter, "\r\n");
            }
        } /* DEBUG */
    }
示例#11
0
    static int yy_find_shift_action(YY_PARSER pParser, int lookahead)
    {
        int i;
        int state = pParser.yystack[pParser.yystack_top].yystate;

        i = yy_shift_offset[state];

        /* default action */
        if (i == YY_SHIFT_DEFAULT_OFFSET)
        {
            return(yy_default[state]);
        }

        if (lookahead >= YY_NSYMBOL)
        {
            return(YY_ERROR_ACTION);
        }

        i += lookahead;

        if (i < 0 || i >= yy_state.Length || yy_state[i] != state)
        {
            /* try fallback */
            int fallback;
            if (lookahead > 0 && lookahead < yy_fallback.Length && (fallback = yy_fallback[0]) != 0)
            {
                if (DEBUG != 0)
                {
                    if (yytraceWriter != null) /* trace fallback */
                    {
                        yy_traceFile(yytraceWriter, yytracePrompt + "Fallback " + get_symbolName(lookahead) + " => " + get_symbolName(fallback) + "\r\n");
                    }
                } /* DEBUG */

                return(yy_find_shift_action(pParser, fallback));
            }
            return(yy_default[state]); /* used default action */
        }
        else
        {
            return(yy_action[i]);
        }
    }
示例#12
0
    public static Object ParseAlloc()
    {
        YY_PARSER pParser;
        int       yystack_depth = 100;

        init_procsArray();

        /* init process */
        yy_destructor_init();
        yy_reduce_init();

        pParser = new YY_PARSER();

        pParser.yystack_top   = -1;
        pParser.yystack       = new YY_STACK_ENTRY[yystack_depth];
        pParser.yystack_depth = yystack_depth;
        pParser.yyerr_count   = 0;

        return(pParser);
    }
示例#13
0
    static int yy_pop_stack(YY_PARSER pParser)
    {
        int            yymajor;
        YY_STACK_ENTRY yytop = pParser.yystack[pParser.yystack_top];

        if (pParser.yystack_top < 0)
        {
            return(0);
        }

        if (DEBUG != 0)
        {
            if (yytraceWriter != null) /* trace stack */
            {
                yy_traceFile(yytraceWriter, yytracePrompt + "Poping " + get_symbolName(yytop.yymajor) + "\r\n");
            }
        } /* DEBUG */

        yymajor = yytop.yymajor;
        yy_destructor(yymajor, yytop.yyminor); /* free stack top symbol */
        pParser.yystack_top--;
        return(yymajor);
    }