public void fillInit(Context curContext)
        {
            if (curContext.Idents.Count > 0)
            {
                msil.Append("    .locals init (\n");
                int index = 0;
                foreach (var kv in curContext.Idents)
                {
                    if (kv.Value.IdentType != IdentType.Function)
                    {
                        msil.Append(string.Format("      [{0}] {1}", index, ReturnType(kv.Value.DataType.SimpleDataType))); //kv.Value.Index
                        kv.Value.Index = index;
                        if (kv.Value.DataType.ArrayCount == 1)
                        {
                            msil.Append(string.Format("[]"));
                        }
                        else
                            if (kv.Value.DataType.ArrayCount > 1)
                            {
                                MsilArray(kv.Value.DataType.ArrayCount);
                            }

                        msil.Append(string.Format(" {0}{1}\n", kv.Key, ++index < curContext.Idents.Count ? "," : ","));
                    }
                }
                msil.Remove(msil.Length - 2, 1);

                msil.Append("    )\n");
            }
        }
        public static string GenerateMSIL(ITree programNode, Context context1)
        {
            MSILGenerator g = new MSILGenerator(programNode);
            //g.NumVariables();
            context = context1;

            g.Generate();
            return g.msil.ToString();
        }
Esempio n. 3
0
 public static AstNode Check(string src, Context context)
 {
     ICharStream input = new ANTLRStringStream(src);
     MathExprLexer lexer = new MathExprLexer(input);
     CommonTokenStream tokens = new CommonTokenStream(lexer);
     MathExprParser parser = new MathExprParser(tokens);
     parser.TreeAdaptor = new AstNodeTreeAdapter();
     AstNode program = (AstNode) parser.execute().Tree;
     SemanticChecker.Check((AstNode)program, context);
     return program;
 }
Esempio n. 4
0
        public static void Main(string[] args)
        {
            try {
            // в зависимости от наличия параметров командной строки разбираем
            // либо файл с именем, переданным первым параметром, либо стандартный ввод
            Context context = new Context(null);
            string src = @"
            void printInt(int a) { }
            void printDouble(double a) { }
            double sqrt(double a) { }
            double sqr(double a) { }
            int readInt() { }
            double readDouble() { }
            ";

            //Check(src, context);

            src = args.Length == 1 ? new StreamReader(args[0]).ReadToEnd()
                               : Console.In.ReadToEnd();
            ICharStream input = new ANTLRStringStream(src);
            MathExprLexer lexer = new MathExprLexer(input);
            CommonTokenStream tokens = new CommonTokenStream(lexer);
            MathExprParser parser = new MathExprParser(tokens);
            parser.TreeAdaptor = new AstNodeTreeAdapter();
            ITree program = (ITree)parser.execute().Tree;
            AstNodePrinter.Print(program);
            Console.WriteLine();
            SemanticChecker.Check((AstNode) program, context);
            AstNodePrinter.Print(program);
            //Console.ReadLine();

            AstNodePrinter.Print(program);
            Console.WriteLine();
            string msil = MSILGenerator.GenerateMSIL(program,context);
            Console.WriteLine(msil);
            Console.WriteLine();
            Console.ReadLine();

              }
              catch (Exception e) {
            Console.WriteLine("Error: {0}", e);
            Console.ReadLine();
              }
        }
 public Context(Context parentContext)
 {
     this.parentContext = parentContext;
 }
        public static DataType Check(AstNode node, Context context)
        {
            switch (node.Type)
            {
                case MathExprLexer.PROGRAM:
                {
                    if (context == null)
                        context = new Context(context);
                    CheckBlock(node, context);
                    return DataType.Void;
                }
                case MathExprLexer.BLOCK:
                {
                    context = new Context(context);
                    CheckBlock(node, context);
                    return DataType.Void;
                }

                case MathExprLexer.VAR: {
                    List<AstNode> nodes = new List<AstNode>();
                    DataType dataType = strToDataType(node.GetChild(0).Text);
                    for (int i = 0; i < node.GetChild(0).ChildCount; i++)
                    {
                        AstNode temp = (AstNode) node.GetChild(0).GetChild(i);
                        if (temp.Token.Type == MathExprLexer.ASSIGN)
                        {
                            Ident ident = context.InThisContext(temp.GetChild(0).Text);
                            if (ident != null)
                                throw new ApplicationException(string.Format("Identifier {0} already exists", temp.GetChild(0).Text));
                            AstNode var = new AstNode(new Antlr.Runtime.CommonToken(MathExprLexer.VAR, "VAR"));
                            var.AddChild(new AstNode(new Antlr.Runtime.CommonToken(MathExprLexer.IDENT, dataTypeToStr(dataType))));
                            var.GetChild(0).AddChild(new AstNode(new Antlr.Runtime.CommonToken(MathExprLexer.IDENT, temp.GetChild(0).Text)));
                            nodes.Add(var);
                            nodes.Add(temp);
                        }
                        else
                        {
                            Ident ident = context.InThisContext(temp.Text);
                            if (ident != null)
                                throw new ApplicationException(string.Format("Identifier {0} already exists", temp.Text));
                            AstNode var = new AstNode(new Antlr.Runtime.CommonToken(MathExprLexer.VAR, "VAR"));
                            var.AddChild(new AstNode(new Antlr.Runtime.CommonToken(MathExprLexer.IDENT, dataTypeToStr(dataType))));
                            var.GetChild(0).AddChild(temp);
                            nodes.Add(var);
                        }
                        string name = nodes[0].GetChild(0).GetChild(0).Text;
                        context[name] = new Ident(name, context.ParentContext == null ? IdentType.GlobalVar : IdentType.LocalVar, dataType, nodes[0]);

                        Antlr.Runtime.Tree.CommonTree tree = new Antlr.Runtime.Tree.CommonTree();
                        foreach (AstNode n in nodes)
                            tree.AddChild(n);
                        node.Parent.ReplaceChildren(node.ChildIndex, node.ChildIndex, tree);
                    }

                    return DataType.Void;
; 
                }

                case MathExprLexer.FUNCTION:
                {
                    DataType dataType = strToDataType(node.GetChild(0).Text);
                    string name = node.GetChild(1).Text;
                    Ident ident = context[name];
                    if (ident != null)
                        throw new ApplicationException(string.Format("Identifier {0} already exists", name));
                    Ident func = new Ident(name, IdentType.Function, dataType, node);
                    context[name] = func;
                    context = new Context(context);
                    AstNode _params = (AstNode) node.GetChild(2);
                    for (int i = 0; i < _params.ChildCount; i++)
                    {
                        DataType paramDataType = strToDataType(_params.GetChild(i).Text);
                        string paramName = _params.GetChild(i).GetChild(0).Text;
                        if (paramDataType == DataType.Void)
                            throw new ApplicationException(string.Format("In function {0} void param {1}", name, paramName));
                        context[paramName] = new Ident(paramName, IdentType.Param, paramDataType, (AstNode) _params.GetChild(i));
                    }
                    context.Function = func;
                    Check((AstNode) node.GetChild(3), context);
                    return DataType.Void;
                }

                case MathExprLexer.CALL:
                {
                    Ident ident = context[node.GetChild(0).Text];
                    if (ident == null)
                        throw new ApplicationException(string.Format("Unknown identifier {0}", node.GetChild(0).Text));
                    if (ident.IdentType != IdentType.Function)
                        throw new ApplicationException(string.Format("Identifier {0} is not function", node.GetChild(0).Text));
                    if (node.GetChild(1).ChildCount != ident.Node.GetChild(2).ChildCount)
                        throw new ApplicationException(string.Format("Not equals params count in function {0}", node.GetChild(0).Text));
                    for (int i = 0; i < ident.Node.GetChild(2).ChildCount; i++) {
                        DataType formalDataType = strToDataType(ident.Node.GetChild(2).GetChild(i).Text);
                        DataType factDataType = Check((AstNode)node.GetChild(1).GetChild(i), context);
                        if (formalDataType != factDataType)
                        {
                            if (formalDataType == DataType.Double && factDataType == DataType.Int)
                                convert((AstNode)node.GetChild(1).GetChild(i), DataType.Double);
                            else
                                throw new ApplicationException(string.Format("In function {0} param {1} incopotible types {2} {3}", node.GetChild(0).Text, i, dataTypeToStr(formalDataType), dataTypeToStr(factDataType)));
                        }
                    }
                    return strToDataType(ident.Node.GetChild(0).Text);
                }

                case MathExprLexer.IDENT:
                {
                    Ident ident = context[node.Text];
                    if (ident == null)
                        throw new ApplicationException(string.Format("Unknown identifier {0}", node.Text));
                    if (ident.IdentType == IdentType.Function)
                    {
                        if (ident.DataType == DataType.Void)
                            throw new ApplicationException(string.Format("Function {0} returns void", ident.Name));
                        if (ident.Node.GetChild(1).ChildCount > 0)
                            throw new ApplicationException(string.Format("No params for function {0} call", ident.Name));
                        AstNode call = new AstNode(new Antlr.Runtime.CommonToken(MathExprLexer.CALL));
                        call.AddChild(node);
                        call.AddChild(new AstNode(new Antlr.Runtime.CommonToken(MathExprLexer.PARAMS)));
                        node.Parent.SetChild(node.ChildIndex, call);

                        node.DataType = ident.DataType;
                        return node.DataType;
                    }
                    else
                    {
                        node.DataType = ident.DataType;
                        return node.DataType;
                    }
                }

                case MathExprLexer.NUMBER:
                {
                    node.DataType = node.Text.Contains(".") ? DataType.Double : DataType.Int;
                    return node.DataType;
                }

                case MathExprLexer.TRUE:
                case MathExprLexer.FALSE:
                {
                    node.DataType = DataType.Bool;
                    return node.DataType;
                }

                case MathExprLexer.ASSIGN:
                {
                    Ident ident = context[node.GetChild(0).Text];
                    if (ident == null)
                        throw new ApplicationException(string.Format("Unknown identifier {0}", node.GetChild(0).Text));
                    if (ident.IdentType == IdentType.Function)
                        throw new ApplicationException(string.Format("Assign to function {0}", node.GetChild(0).Text));
                    DataType rightDataType = Check((AstNode) node.GetChild(1), context);
                    if (ident.DataType != rightDataType)
                    {
                        if (ident.DataType == DataType.Double && rightDataType == DataType.Int)
                            convert((AstNode) node.GetChild(1), DataType.Double);
                        else
                            throw new ApplicationException(string.Format("Assign incopotible types {0} {1}", dataTypeToStr(ident.DataType), dataTypeToStr(rightDataType)));
                    }
                    return DataType.Void;
                }

                case MathExprLexer.RETURN:
                {
                    if (context.Function == null)
                        throw new ApplicationException(string.Format("Return not in function in line {0}", node.Line));

                    DataType returnDataType = Check((AstNode) node.GetChild(0), context);
                    if (context.Function.DataType != returnDataType)
                    {
                        if (context.Function.DataType == DataType.Double && returnDataType == DataType.Int)
                            convert((AstNode) node.GetChild(0), DataType.Double);
                        else
                            throw new ApplicationException(string.Format("Return incopotible types {0} {1}", dataTypeToStr(context.Function.DataType), dataTypeToStr(returnDataType)));
                    }
                    return DataType.Void;
                }

                case MathExprLexer.ADD:
                case MathExprLexer.SUB:
                case MathExprLexer.MUL:
                case MathExprLexer.DIV:
                case MathExprLexer.GE:
                case MathExprLexer.LE:
                case MathExprLexer.NEQUALS:
                case MathExprLexer.EQUALS:
                case MathExprLexer.GT:
                case MathExprLexer.LT:
                {
                    bool compareOperation = true;
                    switch (node.Type) {
                        case MathExprLexer.ADD:
                        case MathExprLexer.SUB:
                        case MathExprLexer.MUL:
                        case MathExprLexer.DIV:
                            compareOperation = false;
                            break;
                    }

                    DataType leftDataType = Check((AstNode) node.GetChild(0), context);
                    DataType rightDataType = Check((AstNode) node.GetChild(1), context);
                    if (leftDataType != DataType.Double && leftDataType != DataType.Int)
                        throw new ApplicationException(string.Format("Left operand invalid type for operation {0}, line = {1}, pos = {2}", node.Text, node.Line, node.TokenStartIndex));
                    if (rightDataType != DataType.Double && rightDataType != DataType.Int)
                        throw new ApplicationException(string.Format("Right operand invalid type for operation {0}, line = {1}, pos = {2}", node.Text, node.Line, node.TokenStartIndex));
                    if (leftDataType == DataType.Double)
                    {
                        if (rightDataType == DataType.Int)
                            convert((AstNode)node.GetChild(1), DataType.Double);
                        node.DataType = compareOperation ? DataType.Bool : DataType.Double;
                        return node.DataType;
                    }
                    if (rightDataType == DataType.Double)
                    {
                        if (leftDataType == DataType.Int)
                            convert((AstNode)node.GetChild(0), DataType.Double);
                        node.DataType = compareOperation ? DataType.Bool : DataType.Double;
                        return node.DataType;
                    }
                    node.DataType = compareOperation ? DataType.Bool : DataType.Int;
                    return node.DataType;
                }

                case MathExprLexer.NOT:
                {
                    DataType dataType = Check((AstNode) node.GetChild(0), context);
                    if (dataType != DataType.Bool)
                        throw new ApplicationException(string.Format("Not operator with type {0}", dataTypeToStr(dataType)));
                    node.DataType = DataType.Bool;
                    return node.DataType;
                }

                case MathExprLexer.AND:
                case MathExprLexer.OR:
                case MathExprLexer.XOR:
                {
                    DataType leftDataType = Check((AstNode) node.GetChild(0), context);
                    DataType rightDataType = Check((AstNode) node.GetChild(1), context);
                    if (leftDataType != DataType.Bool && rightDataType != DataType.Bool)
                        throw new ApplicationException(string.Format("{0} operator with type {1}, {2}", node.Text, dataTypeToStr(leftDataType), dataTypeToStr(rightDataType)));
                    node.DataType = DataType.Bool;
                    return node.DataType;
                }

                case MathExprLexer.WHILE:
                {
                    DataType condDataType = Check((AstNode)node.GetChild(0), context);
                    if (condDataType != DataType.Bool)
                        throw new ApplicationException(string.Format("In while condition type is {0}", dataTypeToStr(condDataType)));
                    // context = new Context(context);
                    Check((AstNode)node.GetChild(1), context);
                    return DataType.Void;
                }

                case MathExprLexer.IF:
                {
                    DataType condDataType = Check((AstNode)node.GetChild(0), context);
                    if (condDataType != DataType.Bool)
                        throw new ApplicationException(string.Format("In if condition type is {0}", dataTypeToStr(condDataType)));
                    // context = new Context(context);
                    Check((AstNode)node.GetChild(1), context);
                    if (node.ChildCount == 3)
                        Check((AstNode)node.GetChild(2), context);
                    return DataType.Void;
                }
                
                case MathExprLexer.FOR:
                {
                    context = new Context(context);
                    CheckBlock((AstNode) node.GetChild(0), context);
                    DataType condDataType = Check((AstNode)node.GetChild(1), context);
                    if (condDataType != DataType.Bool)
                        throw new ApplicationException(string.Format("In while condition type is {0}", dataTypeToStr(condDataType)));
                    CheckBlock((AstNode)node.GetChild(2), context);
                    Check((AstNode)node.GetChild(3), context);
                    return DataType.Void;
                }

                default:
                {
                    throw new ApplicationException("Unknown token type");
                }
                break;
            }
        }
 public static void CheckBlock(AstNode node, Context context)
 {
     for (int i = 0; i < node.ChildCount; i++)
         Check((AstNode)node.GetChild(i), context);
 }
        private void Generate(ITree node, Context context)
        {
            int tempLabIndex;

            switch (node.Type)
            {

                case AstNodeType.VARS:
                case AstNodeType.VAR:
                    int tmp = (node.GetChild(1) as AstNode).ODataType.ArrayCount;
                    if (tmp > 0)
                    {
                        for (int i = 0; i < tmp; i++)
                        {
                            msil.Append(string.Format("    ldc.i4.s {0}\n", (node.GetChild(1) as AstNode).ODataType.ALength));
                        }
                        if (tmp == 1)
                            msil.Append(string.Format("    newarr [mscorlib]System.{0}\n", ReturnConvertType(context.Idents[node.GetChild(0).Text].DataType.SimpleDataType)));
                        else
                        {
                            msil.Append(string.Format("    newobj instance void {0}", ReturnType(context.Idents[node.GetChild(0).Text].DataType.SimpleDataType)));
                            MsilArray(tmp);
                            msil.Append(string.Format("\n"));

                        }
                        msil.Append(string.Format("    stloc.s {0}\n", context.Idents[node.GetChild(0).Text].Index));
                    }
                    break;

                case AstNodeType.ARRAYPART:
                    Generate((AstNode)node.GetChild(0), context);
                    for (int i = 1; i < node.ChildCount; i++)
                    {
                        Generate((AstNode)node.GetChild(i), context);
                    }
                    if (node.ChildCount == 2)
                    {
                        msil.Append(string.Format("    ldelem.i4\n"));
                    }
                    else
                    {
                        string type = ReturnType(context.Idents[node.GetChild(0).Text].DataType.SimpleDataType);
                        msil.Append(string.Format("    call instance {0} {0} ", type));
                        MsilArray(node.ChildCount - 1);
                        msil.Append(string.Format("::Get({0} ", type));
                        for (int i = 0; i < node.ChildCount - 2; i++)
                        {
                            msil.Append(string.Format(",{0}", type));
                        }
                        msil.Append(string.Format(")\n", type));

                    }
                    break;

                case AstNodeType.ASSIGN:

                    if (node.GetChild(0).Type != AstNodeType.ARRAYPART)
                    {
                        Generate(node.GetChild(1), context);
                        msil.Append(string.Format("    stloc.s {0}\n", context.Idents[node.GetChild(0).Text].Index));
                    }
                    else
                    {
                        Generate(node.GetChild(0).GetChild(0), context);
                        for (int i = 1; i < node.ChildCount; i++)
                        {
                            Generate((AstNode)node.GetChild(0).GetChild(i), context);
                        }
                        if (node.ChildCount == 2)
                        {
                            Generate(node.GetChild(1), context);
                            msil.Append(string.Format("    stelem.i4\n"));
                        }
                        else
                        {
                            string type = ReturnType(context.Idents[node.GetChild(0).Text].DataType.SimpleDataType);
                            msil.Append(string.Format("    call instance void {0} ", type));
                            MsilArray(node.ChildCount - 1);
                            msil.Append(string.Format("::Set({0} ", type));
                            for (int i = 0; i < node.ChildCount - 2; i++)
                            {
                                msil.Append(string.Format(",{0}", type));
                            }
                            msil.Append(string.Format(")\n", type));

                        }
                    }
                    break;

                case AstNodeType.IDENT:
                    Ident ident = context.InThisContext(node.Text);//context.Idents[node.Text];
                    if (ident == null)
                    {
                        ident = context.ParentContext.InThisContext(node.Text);
                        if (ident != null && context.ParentContext.Function != null)
                            msil.Append(string.Format("    ldarg.s {0}\n", ident.Index));
                        break;
                    }
                        msil.Append(string.Format("    ldloc.s {0}\n", ident.Index));
                    break;

                case AstNodeType.NUMBER:
                    msil.Append(string.Format("    ldc.i4.s {0}\n", node.Text));
                    break;

                case AstNodeType.TRUE:
                    msil.Append(string.Format("    ldc.i4.s {0}\n", 1));
                    break;
                case AstNodeType.FALSE:
                    msil.Append(string.Format("    ldc.i4.s {0}\n", 0));
                    break;

                case AstNodeType.STRINGVAL:
                    msil.Append(string.Format("    ldstr {0}\n", node.Text));
                    break;

                case AstNodeType.FUNC_CALL:
                    for (int i = 0; i < node.GetChild(1).ChildCount; i++)
                    {
                        Generate(node.GetChild(1).GetChild(i), context);
                    }

                    msil.Append(string.Format("    call {0} Program::{1}(", ReturnType((node as AstNode).ODataType.SimpleDataType), node.GetChild(0).Text));
                    for (int i = 0; i < node.GetChild(1).ChildCount; i++)
                    {
                        msil.Append(string.Format("{0}, ", ReturnType((node.GetChild(1).GetChild(i) as AstNode).ODataType.SimpleDataType)));
                    }
                    msil.Remove(msil.Length - 2, 2);
                    msil.Append(string.Format(")\n"));
                    break;
                case AstNodeType.FUNC:
                    break;
                case AstNodeType.CONVERT:
                    Generate((AstNode)node.GetChild(0), context);
                    msil.Append(string.Format("    call string [mscorlib]System.Convert::To{0}({1})\n", ReturnConvertType((node as AstNode).ODataType.SimpleDataType),
                        ReturnType((node.GetChild(0) as AstNode).ODataType.SimpleDataType)));

                    break;

                case AstNodeType.ADD:
                case AstNodeType.SUB:
                case AstNodeType.MUL:
                case AstNodeType.DIV:
                    string oper = node.Type == AstNodeType.ADD ? "add" :
                                  node.Type == AstNodeType.SUB ? "sub" :
                                  node.Type == AstNodeType.MUL ? "mul" :
                                  node.Type == AstNodeType.DIV ? "div" :
                                  "unknown";

                    Generate(node.GetChild(0), context);
                    Generate(node.GetChild(1), context);
                    msil.Append(string.Format("    {0}\n", oper));
                    break;

                case AstNodeType.GT:
                case AstNodeType.EQ:
                case AstNodeType.LT:
                    oper = node.Type == AstNodeType.GT ? "cgt" :
                           node.Type == AstNodeType.LT ? "clt" :
                           node.Type == AstNodeType.EQ ? "ceq" :
                           "unknown";
                    Generate(node.GetChild(0), context);
                    Generate(node.GetChild(1), context);
                    msil.Append(string.Format("    {0}\n", oper));

                    break;

                case AstNodeType.GE:
                case AstNodeType.LE:
                case AstNodeType.NE:
                    oper = node.Type == AstNodeType.GE ? "clt" :
                           node.Type == AstNodeType.LE ? "cgt" :
                           node.Type == AstNodeType.NE ? "seq" :
                           "unknown";

                    Generate(node.GetChild(0), context);
                    Generate(node.GetChild(1), context);
                    msil.Append(string.Format("    {0}\n", oper));
                    msil.Append(string.Format("    ldc.i4.0 \n"));
                    msil.Append(string.Format("    seq\n"));
                    break;

                case MathExprLexer.SINCR:
                case MathExprLexer.EINCR:
                case MathExprLexer.SDECR:
                case MathExprLexer.EDECR:
                    oper = (node.Type == AstNodeType.SINCR || node.Type == AstNodeType.EINCR) ? "add" :
                           (node.Type == AstNodeType.SDECR || node.Type == AstNodeType.EDECR) ? "sub" :
                           "unknown";
                    msil.Append(string.Format("    ldloc.s {0}\n", context.Idents[node.GetChild(0).Text].Index));
                    msil.Append(string.Format("    ldc.i4.1 \n"));
                    msil.Append(string.Format("    {0}\n", oper));
                    msil.Append(string.Format("    stloc.s {0}\n", context.Idents[node.GetChild(0).Text].Index));
                    break;

                case AstNodeType.IF:
                    tempLabIndex = labIndex;
                    labIndex += 2;
                    Generate(node.GetChild(0), context);
                    msil.Append(string.Format("    brfalse.s L_{0:X4}\n", tempLabIndex + 1));
                    Generate(node.GetChild(1), context);
                    msil.Append(string.Format("    br.s L_{0:X4}\n", tempLabIndex + 2));
                    msil.Append(string.Format("  L_{0:X4}:\n", tempLabIndex + 1));
                    if (node.ChildCount > 2)
                        Generate(node.GetChild(2), context);
                    msil.Append(string.Format("  L_{0:X4}:\n", tempLabIndex + 2));
                    break;

                case AstNodeType.WHILE:
                    tempLabIndex = labIndex;
                    labIndex += 2;
                    msil.Append(string.Format("  L_{0:X4}:\n", tempLabIndex + 1));
                    Generate(node.GetChild(0), context);
                    msil.Append(string.Format("    brfalse.s L_{0:X4}\n", tempLabIndex + 2));
                    Generate(node.GetChild(1), context);
                    msil.Append(string.Format("    br.s L_{0:X4}\n", tempLabIndex + 1));
                    msil.Append(string.Format("  L_{0:X4}:\n", tempLabIndex + 2));
                    break;

                case AstNodeType.REPEATE:
                    tempLabIndex = labIndex;
                    labIndex += 1;
                    msil.Append(string.Format("  L_{0:X4}:\n", tempLabIndex + 1));
                    Generate(node.GetChild(0), context);
                    Generate(node.GetChild(1), context);
                    msil.Append(string.Format("    brtrue.s L_{0:X4}\n", tempLabIndex + 1));
                    break;

                case AstNodeType.FOR:
                    tempLabIndex = labIndex;
                    labIndex += 2;
                    Generate(node.GetChild(1), context);
                    msil.Append(string.Format("    stloc.s {0}\n", context.Idents[node.GetChild(0).GetChild(0).Text].Index));
                    msil.Append(string.Format("  L_{0:X4}:\n", tempLabIndex + 1));
                    msil.Append(string.Format("    ldloc.s {0}\n", context.Idents[node.GetChild(0).GetChild(0).Text].Index));
                    Generate(node.GetChild(2), context);
                    msil.Append(string.Format("    sub\n"));
                    msil.Append(string.Format("    ldc.i4.s {0}\n", 1));
                    msil.Append(string.Format("    sub\n"));
                    msil.Append(string.Format("    brfalse.s L_{0:X4}\n", tempLabIndex + 2));
                    Generate(node.GetChild(3), context);
                    msil.Append(string.Format("    ldloc.s {0}\n", context.Idents[node.GetChild(0).GetChild(0).Text].Index));
                    msil.Append(string.Format("    ldc.i4.s {0}\n", 1));
                    msil.Append(string.Format("    add\n"));
                    msil.Append(string.Format("    stloc.s {0}\n", context.Idents[node.GetChild(0).GetChild(0).Text].Index));
                    msil.Append(string.Format("    br.s L_{0:X4}\n", tempLabIndex + 1));
                    msil.Append(string.Format("  L_{0:X4}:\n", tempLabIndex + 2));
                    break;

                case AstNodeType.PRINT:
                    Generate(node.GetChild(0), context);
                    msil.Append(string.Format("    call void [mscorlib]System.Console::WriteLine(string)\n"));
                    msil.Append(string.Format("    nop\n"));
                    break;

                case AstNodeType.RETURN:
                    Generate((AstNode)node.GetChild(0), context);
                    msil.Append(string.Format("    ret\n"));
                    break;
                case AstNodeType.BLOCK:
                case AstNodeType.PROGRAM:
                    for (int i = 0; i < node.ChildCount; i++)
                        Generate(node.GetChild(i), context);
                    break;

                default:
                    throw new MSILGeneratorException("Not implemented!");
            }
        }
 public static void CheckBlock(AstNode node, Context context)
 {
     for (int crutch = 0; crutch < node.ChildCount; crutch++)
     {
         //AstNodePrinter.Print(node);
         Check((AstNode)node.GetChild(crutch), context);
         AstNodePrinter.Print(node);
     }
 }
        public static OrigDataType Check(AstNode node, Context context)
        {
            switch (node.Type)
            {
                case MathExprLexer.PROGRAM:
                    {
                        if (context == null)
                            context = new Context(context);
                        CheckBlock(node, context);
                        return new OrigDataType(DataType.Void);
                    }
                case MathExprLexer.BLOCK:
                    {
                        context = new Context(context);
                        contexts.Add(context);
                        CheckBlock(node, context);
                        return new OrigDataType(DataType.Void);
                    }
                case MathExprLexer.LET:
                case MathExprLexer.VAR:
                    {
                        List<AstNode> nodes = new List<AstNode>();
                        //String str = node.GetChild(1).GetChild(0).Text;
                        OrigDataType dataType;
                        //OrigDataType dataType = strToDataType(node.GetChild(1).GetChild(0).Text);

                        for (int i = 0; i < node.ChildCount; i++)
                        {
                            dataType = new OrigDataType(DataType.Void);
                            AstNode tempi = (AstNode)node.GetChild(i);
                            Ident ident = context.InThisContext(node.GetChild(i).Text);
                            if (ident != null)
                                throw new ApplicationException(string.Format("Identifier {0} already exists", tempi.Text));
                            String typeText = node.Type == MathExprLexer.VAR ? "VARS" : "LETS";
                            AstNode var = new AstNode(new Antlr.Runtime.CommonToken(MathExprLexer.VARS, typeText));
                            var.AddChild(new AstNode(new Antlr.Runtime.CommonToken(MathExprLexer.IDENT, tempi.Text)));
                            nodes.Add(var);

                            for (int j = 0; j < node.GetChild(i).ChildCount; j++)
                            {
                                AstNode tempj = (AstNode)node.GetChild(i).GetChild(j);
                                if (tempj.Token.Type == MathExprLexer.TYPE && tempj.ChildCount > 0)
                                {
                                    dataType.ReturnFromType(tempj);

                                    AstNode tempType = new AstNode(new Antlr.Runtime.CommonToken(MathExprLexer.TYPE, dataTypeToStr(dataType.SimpleDataType)));
                                    tempType.ODataType = dataType;

                                    var.AddChild(tempType);
                                }
                                if (tempj.Token.Type == MathExprLexer.ASSIGN)
                                {
                                    AstNode tempAssign = new AstNode(new Antlr.Runtime.CommonToken(MathExprLexer.ASSIGN, "="));
                                    tempAssign.AddChild(new AstNode(new Antlr.Runtime.CommonToken(MathExprLexer.IDENT, tempi.Text)));
                                    tempAssign.AddChild(tempj.GetChild(0));
                                    nodes.Add(tempAssign);
                                    if (dataType.SimpleDataType == DataType.Void)
                                    {
                                        dataType = Check((AstNode)tempAssign.GetChild(1), context);

                                        AstNode tempType = new AstNode(new Antlr.Runtime.CommonToken(MathExprLexer.TYPE, dataTypeToStr(dataType.SimpleDataType)));
                                        tempType.ODataType = dataType;
                                        AstNode tempCheckArrayPart = (AstNode)tempj.GetChild(0);
                                        //часть массива
                                        if (tempCheckArrayPart.Token.Type == MathExprLexer.ARRAY)
                                        {
                                            dataType.Check((AstNode)tempAssign.GetChild(1));
                                            AstNode tempTypeArr = (AstNode)tempj.GetChild(0);
                                            tempType.ODataType.ArrayCount = tempTypeArr.ODataType.ArrayCount;
                                        }
                                        //вызов функции
                                        if (tempCheckArrayPart.Token.Type == MathExprLexer.FUNC_CALL)
                                        {
                                            Check((AstNode)tempAssign.GetChild(1), context);
                                            tempType.ODataType = (tempAssign.GetChild(1) as AstNode).ODataType;
                                        }

                                        var.AddChild(tempType);
                                        crutch++;
                                    }
                                }
                            }

                            string name = nodes[i + i].GetChild(0).Text;
                            context[name] = new Ident(name, context.ParentContext == null ? IdentType.GlobalVar : IdentType.LocalVar, dataType, nodes[i + i], identIndex++);

                        }

                        Antlr.Runtime.Tree.CommonTree tree = new Antlr.Runtime.Tree.CommonTree();
                        foreach (AstNode n in nodes)
                            tree.AddChild(n);
                        node.Parent.ReplaceChildren(node.ChildIndex, node.ChildIndex, tree);

                        return new OrigDataType(DataType.Void);
                    }
                case MathExprLexer.VARS:
                case MathExprLexer.PARAMS: return new OrigDataType(DataType.Void);
                case MathExprLexer.FUNC:
                    {
                        OrigDataType dataType = new OrigDataType(strToDataType(node.GetChild(2).GetChild(0).Text));
                        string name = node.GetChild(0).Text;
                        Ident ident = context[name];
                        if (ident != null)
                            throw new ApplicationException(string.Format("Identifier {0} already exists", name));
                        Ident func = new Ident(name, IdentType.Function, dataType, node, identIndex++);
                        context[name] = func;
                        context = new Context(context);
                        contexts.Add(context);
                        AstNode _params = (AstNode)node.GetChild(1);
                        for (int i = 0; i < _params.ChildCount; i++)
                        {
                            OrigDataType paramDataType = new OrigDataType(strToDataType(_params.GetChild(i).GetChild(0).Text));
                            string paramName = _params.GetChild(i).Text;
                            if (paramDataType.SimpleDataType == DataType.Void)
                                throw new ApplicationException(string.Format("In function {0} void param {1}", name, paramName));
                            context[paramName] = new Ident(paramName, IdentType.Param, paramDataType, (AstNode)_params.GetChild(i), identIndex++);
                        }
                        context.Function = func;
                        if (dataType.SimpleDataType == DataType.Array)
                        {
                            dataType.ReturnFromType((AstNode)node.GetChild(2).GetChild(0));
                            dataType.ArrayCount++;
                            AstNode tempType = new AstNode(new Antlr.Runtime.CommonToken(MathExprLexer.TYPE, dataTypeToStr(dataType.SimpleDataType)));
                            tempType.ODataType = dataType;
                            node.GetChild(2).ReplaceChildren(0, 0, tempType);
                        }
                        Check((AstNode)node.GetChild(3), context);
                        return new OrigDataType(DataType.Void);
                    }
                case MathExprLexer.CONVERT:
                    {
                        OrigDataType dataType = new OrigDataType(strToDataType(node.GetChild(1).Text));
                        return dataType;
                    }
                case MathExprLexer.FUNC_CALL:
                    {

                        Ident ident = context[node.GetChild(0).Text];
                        node.ODataType = ident.DataType;
                        if (ident == null)
                            throw new ApplicationException(string.Format("Unknown identifier {0}", node.GetChild(0).Text));
                        if (ident.IdentType != IdentType.Function)
                            throw new ApplicationException(string.Format("Identifier {0} is not function", node.GetChild(0).Text));
                        if (node.ChildCount == 2 && node.GetChild(1).ChildCount != ident.Node.GetChild(1).ChildCount)
                            throw new ApplicationException(string.Format("Not equals params count in function {0}", node.GetChild(0).Text));
                        for (int i = 0; i < ident.Node.GetChild(1).ChildCount; i++)
                        {
                            OrigDataType formalDataType = new OrigDataType(strToDataType(ident.Node.GetChild(1).GetChild(i).GetChild(0).Text));
                            OrigDataType factDataType = Check((AstNode)node.GetChild(1).GetChild(i), context);
                            if (formalDataType.SimpleDataType != factDataType.SimpleDataType)
                            {
                                if (formalDataType.SimpleDataType == DataType.Double && factDataType.SimpleDataType == DataType.Int)
                                    convert((AstNode)node.GetChild(1).GetChild(i), new OrigDataType(DataType.Double));
                                else
                                    throw new ApplicationException(string.Format("In function {0} param {1} incopotible types {2} {3}", node.GetChild(0).Text, i, dataTypeToStr(formalDataType.SimpleDataType), dataTypeToStr(factDataType.SimpleDataType)));
                            }
                        }
                        return new OrigDataType(strToDataType(ident.Node.GetChild(2).GetChild(0).Text));
                    }

                case MathExprLexer.IDENT:
                    {
                        Ident ident = context[node.Text];
                        if (ident == null)
                            throw new ApplicationException(string.Format("Unknown identifier {0}", node.Text));
                        if (ident.IdentType == IdentType.Function)
                        {
                            if (ident.DataType.SimpleDataType == DataType.Void)
                                throw new ApplicationException(string.Format("Function {0} returns void", ident.Name));
                            if (ident.Node.GetChild(1).ChildCount > 0)
                                throw new ApplicationException(string.Format("No params for function {0} call", ident.Name));
                            AstNode call = new AstNode(new Antlr.Runtime.CommonToken(MathExprLexer.FUNC_CALL));
                            call.AddChild(node);
                            call.AddChild(new AstNode(new Antlr.Runtime.CommonToken(MathExprLexer.PARAMS)));
                            node.Parent.SetChild(node.ChildIndex, call);

                            node.ODataType = ident.DataType;
                            return node.ODataType;
                        }
                        else
                        {
                            node.ODataType = ident.DataType;
                            return node.ODataType;
                        }
                    }

                case MathExprLexer.NUMBER:
                    {
                        node.ODataType = node.Text.Contains(".") ? new OrigDataType(DataType.Double) : new OrigDataType(DataType.Int);
                        return node.ODataType;
                    }

                case MathExprLexer.STRINGVAL:
                    {
                        node.ODataType.SimpleDataType = DataType.String;
                        return node.ODataType;
                    }
                case MathExprLexer.TRUE:
                case MathExprLexer.FALSE:
                    {
                        node.ODataType.SimpleDataType = DataType.Bool;
                        return node.ODataType;
                    }
                case MathExprLexer.ARRAY:
                    {

                        OrigDataType dataType = new OrigDataType(DataType.Void);

                        dataType.ReturnFromValue(node);
                        node.ODataType = dataType;
                        int tmpArr = dataType.ArrayCount;
                        //int type = node.GetChild(0).Type;
                        for (int i = 0; i < node.ChildCount; i++)
                        {
                            dataType = Check((AstNode)node.GetChild(i), context);

                        }

                        return dataType;
                    }
                case MathExprLexer.ARRAYPART:
                    {
                        Ident ident = context[node.GetChild(0).Text];

                        OrigDataType dataType = new OrigDataType(ident.DataType.SimpleDataType);
                        dataType.ArrayCount = ident.DataType.ArrayCount - node.ChildCount + 1;
                        for (int i = 1; i < node.ChildCount; i++)
                        {
                            Check((AstNode)node.GetChild(i), context);
                        }
                        node.ODataType = dataType;
                        return dataType;
                    }
                case MathExprLexer.ASSIGN:
                    {

                        Ident ident = context[node.GetChild(0).Text];
                        if (node.GetChild(0).Type == MathExprLexer.ARRAYPART)
                        {
                            ident = context[node.GetChild(0).GetChild(0).Text];
                        }
                        if (ident == null)
                            throw new ApplicationException(string.Format("Unknown identifier {0}", node.GetChild(0).Text));
                        if (ident.IdentType == IdentType.Function)
                            throw new ApplicationException(string.Format("Assign to function {0}", node.GetChild(0).Text));

                        OrigDataType rightDataType = Check((AstNode)node.GetChild(1), context);
                        if (ident.DataType.SimpleDataType == DataType.Void)
                            return rightDataType;
                        //if(ident.OrigDataType == OrigDataType.Void)

                        if (ident.DataType.SimpleDataType != rightDataType.SimpleDataType)
                        {
                            if (ident.DataType.SimpleDataType == DataType.Double && rightDataType.SimpleDataType == DataType.Int)
                                convert((AstNode)node.GetChild(1), new OrigDataType(DataType.Double));
                            else
                                throw new ApplicationException(string.Format("Assign incopotible types {0} {1}", dataTypeToStr(ident.DataType.SimpleDataType), dataTypeToStr(rightDataType.SimpleDataType)));
                        }

                        return new OrigDataType(DataType.Void);
                    }

                case MathExprLexer.RETURN:
                    {
                        if (context.Function == null)
                            throw new ApplicationException(string.Format("Return not in function in line {0}", node.Line));

                        OrigDataType returnDataType = Check((AstNode)node.GetChild(0), context);
                        if (context.Function.DataType.SimpleDataType != returnDataType.SimpleDataType && context.Function.DataType.ArrayCount != returnDataType.ArrayCount)
                        {
                            if (context.Function.DataType.SimpleDataType == DataType.Double && returnDataType.SimpleDataType == DataType.Int)
                                convert((AstNode)node.GetChild(0), new OrigDataType(DataType.Double));
                            else
                                throw new ApplicationException(string.Format("Return incopotible types {0} {1}", dataTypeToStr(context.Function.DataType.SimpleDataType), dataTypeToStr(returnDataType.SimpleDataType)));
                        }
                        return new OrigDataType(DataType.Void);
                    }
                case MathExprLexer.SINCR:
                case MathExprLexer.EINCR:
                case MathExprLexer.SDECR:
                case MathExprLexer.EDECR:
                    {
                        OrigDataType idenDataType = Check((AstNode)node.GetChild(0), context);
                        if (idenDataType.SimpleDataType != DataType.Int && idenDataType.SimpleDataType != DataType.Double)
                            throw new ApplicationException(string.Format("In crement condition type is {0}", dataTypeToStr(idenDataType.SimpleDataType)));
                        return new OrigDataType(DataType.Void);
                    }
                case MathExprLexer.ADD:
                case MathExprLexer.SUB:
                case MathExprLexer.MUL:
                case MathExprLexer.DIV:
                case MathExprLexer.GE:
                case MathExprLexer.LE:
                case MathExprLexer.NE:
                case MathExprLexer.EQ:
                case MathExprLexer.GT:
                case MathExprLexer.LT:
                    {
                        bool compareOperation = true;
                        switch (node.Type)
                        {
                            case MathExprLexer.ADD:
                            case MathExprLexer.SUB:
                            case MathExprLexer.MUL:
                            case MathExprLexer.DIV:
                                compareOperation = false;
                                break;
                        }

                        OrigDataType leftDataType = Check((AstNode)node.GetChild(0), context);
                        OrigDataType rightDataType = Check((AstNode)node.GetChild(1), context);
                        if (leftDataType.SimpleDataType != DataType.Double && leftDataType.SimpleDataType != DataType.Int && leftDataType.SimpleDataType != DataType.Bool)
                            throw new ApplicationException(string.Format("Left operand invalid type for operation {0}, line = {1}, pos = {2}", node.Text, node.Line, node.TokenStartIndex));
                        if (rightDataType.SimpleDataType != DataType.Double && rightDataType.SimpleDataType != DataType.Int && leftDataType.SimpleDataType != DataType.Bool)
                            throw new ApplicationException(string.Format("Right operand invalid type for operation {0}, line = {1}, pos = {2}", node.Text, node.Line, node.TokenStartIndex));
                        if (leftDataType.SimpleDataType == DataType.Double)
                        {
                            if (rightDataType.SimpleDataType == DataType.Int)
                                convert((AstNode)node.GetChild(1), new OrigDataType(DataType.Double));
                            node.ODataType = compareOperation ? new OrigDataType(DataType.Bool) : new OrigDataType(DataType.Double);
                            return node.ODataType;
                        }
                        if (rightDataType.SimpleDataType == DataType.Double)
                        {
                            if (leftDataType.SimpleDataType == DataType.Int)
                                convert((AstNode)node.GetChild(0), new OrigDataType(DataType.Double));
                            node.ODataType = compareOperation ? new OrigDataType(DataType.Bool) : new OrigDataType(DataType.Double);
                            return node.ODataType;
                        }
                        node.ODataType = compareOperation ? new OrigDataType(DataType.Bool) : new OrigDataType(DataType.Int);
                        return node.ODataType;
                    }

                case MathExprLexer.NOT:
                    {
                        OrigDataType dataType = Check((AstNode)node.GetChild(0), context);
                        if (dataType.SimpleDataType != DataType.Bool)
                            throw new ApplicationException(string.Format("Not operator with type {0}", dataTypeToStr(dataType.SimpleDataType)));
                        node.ODataType.SimpleDataType = DataType.Bool;
                        return node.ODataType;
                    }

                case MathExprLexer.AND:
                case MathExprLexer.OR:
                    {
                        OrigDataType leftDataType = Check((AstNode)node.GetChild(0), context);
                        OrigDataType rightDataType = Check((AstNode)node.GetChild(1), context);
                        if (leftDataType.SimpleDataType != DataType.Bool && rightDataType.SimpleDataType != DataType.Bool)
                            throw new ApplicationException(string.Format("{0} operator with type {1}, {2}", node.Text, dataTypeToStr(leftDataType.SimpleDataType), dataTypeToStr(rightDataType.SimpleDataType)));
                        node.ODataType = new OrigDataType(DataType.Bool);
                        return node.ODataType;
                    }
                case MathExprLexer.REPEATE:
                case MathExprLexer.WHILE:
                    {
                        OrigDataType condDataType = Check((AstNode)node.GetChild(0), context);
                        if (condDataType.SimpleDataType != DataType.Bool)
                            throw new ApplicationException(string.Format("In while condition type is {0}", dataTypeToStr(condDataType.SimpleDataType)));
                        // context = new Context(context);
                        Check((AstNode)node.GetChild(1), context);
                        return new OrigDataType(DataType.Void);
                    }

                case MathExprLexer.IF:
                    {
                        OrigDataType condDataType = Check((AstNode)node.GetChild(0), context);
                        if (condDataType.SimpleDataType != DataType.Bool)
                            throw new ApplicationException(string.Format("In if condition type is {0}", dataTypeToStr(condDataType.SimpleDataType)));
                        //context = new Context(context);
                        Check((AstNode)node.GetChild(1), context);
                        if (node.ChildCount == 3)
                            Check((AstNode)node.GetChild(2), context);
                        return new OrigDataType(DataType.Void);
                    }
                case MathExprLexer.FOR:
                    {

                        for (int i = 0; i < node.ChildCount - 1; i++)
                        {
                            Check((AstNode)node.GetChild(i), context);
                        }
                        context = new Context(context);
                        CheckBlock((AstNode)node.GetChild(node.ChildCount - 1), context);

                        OrigDataType condDataType = Check((AstNode)node.GetChild(node.ChildCount - 3), context);
                        if (condDataType.SimpleDataType != DataType.Bool)
                            throw new ApplicationException(string.Format("In while condition type is {0}", dataTypeToStr(condDataType.SimpleDataType)));

                        return new OrigDataType(DataType.Void);
                    }
                case MathExprLexer.SWITCH:
                    {
                        OrigDataType identDataType = Check((AstNode)node.GetChild(0), context);
                        for (int i = 1; i < node.ChildCount; i++)
                        {
                            AstNode tempi = (AstNode)node.GetChild(i);
                            for (int j = 0; j < tempi.GetChild(0).ChildCount; j++)
                            {
                                if (identDataType.SimpleDataType != Check((AstNode)tempi.GetChild(0).GetChild(j), context).SimpleDataType)
                                    throw new ApplicationException(string.Format("In switch identDataType type is {0}", dataTypeToStr(identDataType.SimpleDataType)));
                            }
                            context = new Context(context);
                            CheckBlock((AstNode)tempi.GetChild(1), context);
                            //Check((AstNode)node.GetChild(i), context);
                        }
                        //context = new Context(context);

                        return new OrigDataType(DataType.Void);
                    }
                case MathExprLexer.PRINT:
                    {
                        if (node.ChildCount > 0)
                        {
                            Check((AstNode)node.GetChild(0), context);
                            if ((node.GetChild(0) as AstNode).ODataType.SimpleDataType != DataType.String)
                            {
                                convert((AstNode)node.GetChild(0), new OrigDataType(DataType.String));
                            }
                        }
                        return new OrigDataType(DataType.String);
                    }
                default:
                    {
                        throw new ApplicationException("Unknown token type");
                    }

            }
        }