Розробка системних програмних модулів та компонент систем програмування

                            code += "mov eax,temp\n";

                            code += "fistp temp\n";

                            code += "cmp eax,temp\n";

                            code += "jne lbl" + Convert.ToString(LblCount) + "\n";

                            code += "mov edx,1\n";

                            code += "lbl" + Convert.ToString(LblCount++) + ":\n";

                            code += "mov temp,edx\n";

                            code += "fild temp\n";

                            code += ";---------------------\n";

                            break;

                        case "NotEqual":

                            code += ";---st(0) != st(1)---";

                            code += "mov edx,0\n";

                            code += "fistp temp\n";

                            code += "mov eax,temp\n";

                            code += "fistp temp\n";

                            code += "cmp eax,temp\n";

                            code += "je lbl" + Convert.ToString(LblCount) + "\n";

                            code += "mov edx,1\n";

                            code += "lbl" + Convert.ToString(LblCount++) + ":\n";

                            code += "mov temp,edx\n";

                            code += "fild temp\n";

                            code += ";---------------------\n";

                            break;

                        case "LesserOrEqual":

                            code += ";---st(0) <= st(1)---";

                            code += "mov edx,0\n";

                            code += "fistp temp\n";

                            code += "mov eax,temp\n";

                            code += "fistp temp\n";

                            code += "cmp eax,temp\n";

                            code += "jg lbl" + Convert.ToString(LblCount) + "\n";

                            code += "mov edx,1\n";

                            code += "lbl" + Convert.ToString(LblCount++) + ":\n";

                            code += "mov temp,edx\n";

                            code += "fild temp\n";

                            code += ";---------------------\n";

                            break;

                        case "GreaterOrEqual":

                            code += ";---st(0) >= st(1)---";

                            code += "mov edx,0\n";

                            code += "fistp temp\n";

                            code += "mov eax,temp\n";

                            code += "fistp temp\n";

                            code += "cmp eax,temp\n";

                            code += "jl lbl" + Convert.ToString(LblCount) + "\n";

                            code += "mov edx,1\n";

                            code += "lbl" + Convert.ToString(LblCount++) + ":\n";

                            code += "mov temp,edx\n";

                            code += "fild temp\n";

                            code += "---------------------\n";

                            break;

                        case "Not":

                            code += "f_not\n";

                            break;

                        case "Or":

                            code += "f_or\n";

                            break;

                        case "And":

                            code += "f_and\n";

                            break;

                    }

                }

            }

            catch (InvalidOperationException)

            {

                AddError("Incorect form of expression", line);

            }

            TreeNode Code = new TreeNode(code);

            Output.Push(Code);

            return Output;

        }

        private TreeNode Coagulation(Stack<TreeNode> inp)

        {

            TreeNode Node = new TreeNode("Block");

            Node.Text = "Block";

            Node.Name = "";

            Node.ImageKey = "Block";

            Node.SelectedImageIndex = inp.First().SelectedImageIndex;

            for (; inp.Count > 0; )

            {

                if ((inp.First().ImageKey == "Block") | (inp.First().ImageKey == "Cycle") | (inp.First().ImageKey == "IOStream"))

                    Node.Name += inp.First().Name;

                Node.Nodes.Add(inp.Pop());

            }

            return Node;

        }

        //Additional fumctions, they help to reduce volume of text

        bool CheckIdentForDefine(int i)

        {

            for (; i < LexTable.Count - 1; i++)

            {

                if (LexTable[i].Type == LexemType.Ident)

                {

                    bool IsDeclared = false;

                    bool IsInitialized = false;

                    for (int j = 0; j < IdentTable.Count; j++)

                    {

                        if (LexTable[i].Text == IdentTable[j].Name)

                        {

                            IsDeclared = true;

                            if (LexTable[i + 1].Type == LexemType.Equator)

                            {

                                IsInitialized = true;

                                IdentTable[j].IsDeclared = true;

                            }

                            else

                            {

                                IsInitialized = IdentTable[j].IsDeclared;

                            }

                        }

                    }

                    if (!IsDeclared)

                    {

                        AddError("Undeclared identifier [" + LexTable[i].Text + "] used!", LexTable[i].Line);

                        return false;

                    }

                    else

                    {

                        if (!IsInitialized)

                        {

                            AddError("Uninitialized identifier [" + LexTable[i].Text + "] used!", LexTable[i].Line);

                            return false;

                        }

                    }

                }

            }

            return true;

        }

        private bool LogicalExpressionPart(string LexType)

        {

            if ((LexType == "Ident") | (LexType == "Const") | (LexType == "Addition") | (LexType == "Substraction") |

                (LexType == "OpenBracket") | (LexType == "CloseBracket") | (LexType == "Multiplication") | (LexType == "Divide") |

                (LexType == "Module") | (LexType == "And") | (LexType == "Or") | (LexType == "Not") |

                (LexType == "Equal") | (LexType == "NotEqual") | (LexType == "LesserOrEqual") | (LexType == "GreaterOrEqual") | (LexType == "Equator"))

            {

                return true;

            }

            else

            {

                return false;

            }

        }

        private Stack<TreeNode> Reverse(Stack<TreeNode> in_)

        {

            Stack<TreeNode> ret = new Stack<TreeNode>();

            while(in_.Count > 0)

            {

                ret.Push(in_.Pop());

            }

            return ret;

        }

        private void AddError(string error_text, int line)

        {

            Error Err = new Error();

            Err.Line = line;

            Err.Text = error_text;

            SyntaxErrors.Add(Err);

        }

        private TreeNode LexToNode(Lexema Lex)

        {

            TreeNode tmp = new TreeNode();

            tmp.Text = Lex.Text + "[" + Convert.ToString(Lex.Type) + "]";

            tmp.Name = Lex.Text;

            tmp.ImageIndex = Lex.Value;

            tmp.SelectedImageIndex = Lex.Line;

            tmp.ImageKey = Convert.ToString(Lex.Type);

            return tmp;

        }

        //class objects

        int StrCount;

        int LblCount;

        int ExitCicleCount;

        int StartCicleCount;

        private TreeNode GramTree;

        public List<Strings> StringTable;

        public List<Identificator> IdentTable;

        public List<Identificator> ConstTable;

        private List<Lexema> LexTable;

        public Errors SyntaxErrors;

        public int[,] PriorityTable;

    }

}