示例#1
0
        /// <summary>
        /// Реализует выполнение ПОЛИЗа
        /// </summary>
        public void execute()
        {
            Lexem       lex, lex1, lex2;
            bool        b;
            string      val, hlp_str;
            int         i, j, size = prog.get_free(), num;
            Type_of_lex t;

            if (wb.exit_run > 0)
            {
                wb.exit_run--;
                cur_step_poliz++;
            }
            while (cur_step_poliz < size)
            {
                curLex = prog.arr[cur_step_poliz];
                switch (curLex.get_type())
                {
                case Type_of_lex._int:
                case Type_of_lex._double:
                case Type_of_lex._string:
                case Type_of_lex._bool:
                case Type_of_lex.POLIZ_ADDR:
                case Type_of_lex.POLIZ_LABEL:
                    args.Push(curLex);
                    break;

                case Type_of_lex.LEX_id:
                    //Проверили, не вызов ли функции
                    if (!id_is_func(curLex))
                    {
                        lex = new Lexem(tableId.get_type_of_lex(curLex.getName()), tableId.get_value_of_lex(curLex.getName()));
                        args.Push(lex);
                    }
                    else
                    {
                        if (tableId.getNumOfFunc(curLex.getName()) < tableId.get_inet_func_num())
                        {
                            bool need_exit_in_wait_loop = run_inet_func(curLex.getName());

                            if (need_exit_in_wait_loop)
                            {
                                system_print(">>>exit in main wait loop<<<");
                                wb.exit_run--;
                                cur_step_poliz++;
                                return;
                            }
                        }
                        else
                        {
                            run_func(curLex.getName());
                        }
                    }
                    break;

                case Type_of_lex.LEX_ElCcnt:
                    lex = args.Pop();
                    args.Push(new Lexem(Type_of_lex._int, tableId.get_htmlElemCollect_of_lex(lex.getName()).Count.ToString()));
                    break;

                case Type_of_lex.LEX_ElCbyNum:
                    lex  = args.Pop();   //iterator
                    lex1 = args.Pop();   //elem_collection
                    lex2 = args.Pop();   //elem

                    HtmlElement hc = tableId.get_htmlElemCollect_of_lex(lex1.getName())[Convert.ToInt32(lex.getName())];
                    tableId.putHtmlElemValueOfLex(tableId.getNumOfLex(lex2), hc);
                    break;

                case Type_of_lex.LEX_WRITE:
                    //System.Console.WriteLine(args.Pop().getName());
                    system_print(args.Pop().getName());
                    break;

                case Type_of_lex.LEX_READ:
                    lex = args.Pop();
                    //val = System.Console.ReadLine();
                    val = system_read();
                    tableId.putValueOfLex(Convert.ToInt32(lex.getName()), val);
                    break;

                case Type_of_lex.LEX_not:
                    lex = args.Pop();
                    args.Push(new Lexem(lex.get_type(), getValueFromBool(!getBoolFromValue(lex))));
                    break;

                case Type_of_lex.LEX_or:
                    lex1 = args.Pop();
                    lex2 = args.Pop();
                    b    = getBoolFromValue(lex1) || getBoolFromValue(lex2);
                    args.Push(new Lexem(Type_of_lex._bool, getValueFromBool(b)));
                    break;

                case Type_of_lex.LEX_and:
                    lex1 = args.Pop();
                    lex2 = args.Pop();
                    b    = getBoolFromValue(lex1) && getBoolFromValue(lex2);
                    args.Push(new Lexem(Type_of_lex._bool, getValueFromBool(b)));
                    break;

                case Type_of_lex.POLIZ_GO:
                    cur_step_poliz = Convert.ToInt32(args.Pop().getName()) - 1;
                    break;

                case Type_of_lex.POLIZ_FGO:
                    lex1 = args.Pop();
                    lex2 = args.Pop();
                    if (!getBoolFromValue(lex2))
                    {
                        cur_step_poliz = Convert.ToInt32(lex1.getName()) - 1;
                    }
                    break;

                case Type_of_lex.LEX_UPLUS:
                    break;

                case Type_of_lex.LEX_UMINUS:
                    lex1 = args.Pop();
                    val  = "-" + lex1.getName();
                    args.Push(new Lexem(lex1.get_type(), val));
                    break;

                case Type_of_lex.LEX_minusMinus:
                case Type_of_lex.LEX_MINUSMINUSright:
                    lex1    = args.Pop();
                    num     = Convert.ToInt32(lex1.getName());
                    t       = tableId.getTypeofLex(num);
                    hlp_str = tableId.get_value_of_lex(num);
                    switch (t)
                    {
                    case Type_of_lex._string:
                        val = hlp_str.Remove(hlp_str.Length - 1);
                        break;

                    case Type_of_lex._bool:
                        bool a1 = getBoolFromValue(new Lexem(Type_of_lex._bool, hlp_str));
                        b   = !a1;
                        val = getValueFromBool(b);
                        break;

                    case Type_of_lex._double:
                        val = (Convert.ToDouble(hlp_str) - 1).ToString();
                        break;

                    case Type_of_lex._int:
                        val = (Convert.ToInt32(hlp_str) - 1).ToString();
                        break;

                    default:
                        val = hlp_str.Remove(hlp_str.Length - 1);
                        break;
                    }
                    tableId.putValueOfLex(Convert.ToInt32(lex1.getName()), val);
                    if (curLex.get_type() == Type_of_lex.LEX_minusMinus)
                    {
                        args.Push(new Lexem(t, val));
                    }
                    else
                    {
                        args.Push(new Lexem(t, hlp_str));
                    }
                    break;

                case Type_of_lex.LEX_plusPlus:
                case Type_of_lex.LEX_PLUSPLUSright:
                    lex1    = args.Pop();
                    num     = Convert.ToInt32(lex1.getName());
                    t       = tableId.getTypeofLex(num);
                    hlp_str = tableId.get_value_of_lex(num);
                    switch (t)
                    {
                    case Type_of_lex._string:
                        val = hlp_str + " ";
                        break;

                    case Type_of_lex._bool:
                        bool a1 = getBoolFromValue(new Lexem(Type_of_lex._bool, hlp_str));
                        b   = !a1;
                        val = getValueFromBool(b);
                        break;

                    case Type_of_lex._double:
                        val = (Convert.ToDouble(hlp_str) + 1).ToString();
                        break;

                    case Type_of_lex._int:
                        val = (Convert.ToInt32(hlp_str) + 1).ToString();
                        break;

                    default:
                        val = hlp_str + " ";
                        break;
                    }
                    tableId.putValueOfLex(Convert.ToInt32(lex1.getName()), val);
                    if (curLex.get_type() == Type_of_lex.LEX_plusPlus)
                    {
                        args.Push(new Lexem(t, val));
                    }
                    else
                    {
                        args.Push(new Lexem(t, hlp_str));
                    }
                    break;

                case Type_of_lex.LEX_plus:
                    lex1 = args.Pop();
                    lex2 = args.Pop();
                    t    = get_real_type(lex1, lex2);
                    switch (t)
                    {
                    case Type_of_lex._string:
                        val = lex1.getName() + lex2.getName();
                        break;

                    case Type_of_lex._bool:
                        bool a1 = getBoolFromValue(lex1), a2 = getBoolFromValue(lex2);
                        b   = !a1 && a2 || a1 && !a2;
                        val = getValueFromBool(b);
                        break;

                    case Type_of_lex._double:
                        val = (Convert.ToDouble(lex1.getName()) + Convert.ToDouble(lex2.getName())).ToString();
                        break;

                    case Type_of_lex._int:
                        val = (Convert.ToInt32(lex1.getName()) + Convert.ToInt32(lex2.getName())).ToString();
                        break;

                    default:
                        val = lex1.getName() + lex2.getName();
                        break;
                    }
                    args.Push(new Lexem(t, val));
                    break;

                case Type_of_lex.LEX_mul:
                    lex1 = args.Pop();
                    lex2 = args.Pop();
                    t    = get_real_type(lex1, lex2);
                    switch (t)
                    {
                    case Type_of_lex._string:
                        val = lex1.getName() + lex2.getName();
                        break;

                    case Type_of_lex._bool:
                        bool a1 = getBoolFromValue(lex1), a2 = getBoolFromValue(lex2);
                        b   = a1 && a2;
                        val = getValueFromBool(b);
                        break;

                    case Type_of_lex._double:
                        val = (Convert.ToDouble(lex1.getName()) * Convert.ToDouble(lex2.getName())).ToString();
                        break;

                    case Type_of_lex._int:
                        val = (Convert.ToInt32(lex1.getName()) * Convert.ToInt32(lex2.getName())).ToString();
                        break;

                    default:
                        val = lex1.getName() + lex2.getName();
                        break;
                    }
                    args.Push(new Lexem(t, val));
                    break;

                case Type_of_lex.LEX_minus:
                    lex1 = args.Pop();
                    lex2 = args.Pop();
                    t    = get_real_type(lex1, lex2);
                    switch (t)
                    {
                    case Type_of_lex._string:
                        val = "";
                        break;

                    case Type_of_lex._bool:
                        bool a1 = getBoolFromValue(lex1), a2 = getBoolFromValue(lex2);
                        b   = !a1 && a2 || a1 && !a2;
                        val = getValueFromBool(b);
                        break;

                    case Type_of_lex._double:
                        val = (Convert.ToDouble(lex2.getName()) - Convert.ToDouble(lex1.getName())).ToString();
                        break;

                    case Type_of_lex._int:
                        val = (Convert.ToInt32(lex2.getName()) - Convert.ToInt32(lex1.getName())).ToString();
                        break;

                    default:
                        val = "";
                        break;
                    }
                    args.Push(new Lexem(t, val));
                    break;

                case Type_of_lex.LEX_slash:
                    lex1 = args.Pop();
                    lex2 = args.Pop();
                    t    = get_real_type(lex1, lex2);
                    switch (t)
                    {
                    case Type_of_lex._string:
                        val = "";
                        break;

                    case Type_of_lex._bool:
                        val = getValueFromBool(false);
                        break;

                    case Type_of_lex._double:
                        val = (Convert.ToDouble(lex2.getName()) / Convert.ToDouble(lex1.getName())).ToString();
                        break;

                    case Type_of_lex._int:
                        val = (Convert.ToInt32(lex2.getName()) / Convert.ToInt32(lex1.getName())).ToString();
                        break;

                    default:
                        val = "";
                        break;
                    }
                    args.Push(new Lexem(t, val));
                    break;

                case Type_of_lex.LEX_less:
                    lex1 = args.Pop();
                    lex2 = args.Pop();
                    t    = get_real_type(lex1, lex2);
                    switch (t)
                    {
                    case Type_of_lex._bool:
                        val = "";
                        break;

                    case Type_of_lex._double:
                        val = (Convert.ToDouble(lex2.getName()) < Convert.ToDouble(lex1.getName())).ToString();
                        break;

                    case Type_of_lex._int:
                        val = (Convert.ToInt32(lex2.getName()) < Convert.ToInt32(lex1.getName())).ToString();
                        break;

                    case Type_of_lex._string:
                    default:
                        i = String.Compare(lex2.getName(), lex1.getName());
                        if (i < 0)
                        {
                            val = "true";
                        }
                        else
                        {
                            val = "false";
                        }
                        break;
                    }
                    args.Push(new Lexem(Type_of_lex._bool, val));
                    break;

                case Type_of_lex.LEX_bigger:
                    lex1 = args.Pop();
                    lex2 = args.Pop();
                    t    = get_real_type(lex1, lex2);
                    switch (t)
                    {
                    case Type_of_lex._bool:
                        val = "";
                        break;

                    case Type_of_lex._double:
                        val = (Convert.ToDouble(lex2.getName()) > Convert.ToDouble(lex1.getName())).ToString();
                        break;

                    case Type_of_lex._int:
                        val = (Convert.ToInt32(lex2.getName()) > Convert.ToInt32(lex1.getName())).ToString();
                        break;

                    case Type_of_lex._string:
                    default:
                        i = String.Compare(lex2.getName(), lex1.getName());
                        if (i > 0)
                        {
                            val = "true";
                        }
                        else
                        {
                            val = "false";
                        }
                        break;
                    }
                    args.Push(new Lexem(Type_of_lex._bool, val));
                    break;

                case Type_of_lex.LEX_lessEq:
                    lex1 = args.Pop();
                    lex2 = args.Pop();
                    t    = get_real_type(lex1, lex2);
                    switch (t)
                    {
                    case Type_of_lex._bool:
                        val = "";
                        break;

                    case Type_of_lex._double:
                        val = (Convert.ToDouble(lex2.getName()) <= Convert.ToDouble(lex1.getName())).ToString();
                        break;

                    case Type_of_lex._int:
                        val = (Convert.ToInt32(lex2.getName()) <= Convert.ToInt32(lex1.getName())).ToString();
                        break;

                    case Type_of_lex._string:
                    default:
                        i = String.Compare(lex2.getName(), lex1.getName());
                        if (i <= 0)
                        {
                            val = "true";
                        }
                        else
                        {
                            val = "false";
                        }
                        break;
                    }
                    args.Push(new Lexem(Type_of_lex._bool, val));
                    break;

                case Type_of_lex.LEX_biggerEq:
                    lex1 = args.Pop();
                    lex2 = args.Pop();
                    t    = get_real_type(lex1, lex2);
                    switch (t)
                    {
                    case Type_of_lex._bool:
                        val = "";
                        break;

                    case Type_of_lex._double:
                        val = (Convert.ToDouble(lex2.getName()) >= Convert.ToDouble(lex1.getName())).ToString();
                        break;

                    case Type_of_lex._int:
                        val = (Convert.ToInt32(lex2.getName()) >= Convert.ToInt32(lex1.getName())).ToString();
                        break;

                    case Type_of_lex._string:
                    default:
                        i = String.Compare(lex2.getName(), lex1.getName());
                        if (i >= 0)
                        {
                            val = "true";
                        }
                        else
                        {
                            val = "false";
                        }
                        break;
                    }
                    args.Push(new Lexem(Type_of_lex._bool, val));
                    break;

                case Type_of_lex.LEX_neq:
                    val = (args.Pop().getName() != args.Pop().getName()).ToString();
                    args.Push(new Lexem(Type_of_lex._bool, val));
                    break;

                case Type_of_lex.LEX_eq:
                    val = (args.Pop().getName() == args.Pop().getName()).ToString();
                    args.Push(new Lexem(Type_of_lex._bool, val));
                    break;

                case Type_of_lex.LEX_assign:
                    lex1 = args.Pop();    //что присваиваем
                    lex2 = args.Pop();    //куда присваиваем
                    val  = lex1.getName();
                    if (lex1.get_type() != Type_of_lex._htmlelement && lex1.get_type() != Type_of_lex._htmlelementcollect)
                    {
                        tableId.putValueOfLex(Convert.ToInt32(lex2.getName()), val);
                    }
                    //в вычислителе лежало имя, а реальное значение надо взять из таблицы идентификаторов
                    else
                    {
                        tableId.putValueOfLex(Convert.ToInt32(lex2.getName()), val, true);
                    }
                    break;
                }
                cur_step_poliz++;
            }//end of while
            if (cur_step_poliz >= size)
            {
                if (wb.isConsoleVersion)
                {
                    Application.Exit();
                }
            }
        }