示例#1
0
        static TypeTable()
        {
            obj_type = get_compiled_type(new SymInfo(PascalABCCompiler.TreeConverter.compiler_string_consts.object_type_name, SymbolKind.Type, PascalABCCompiler.TreeConverter.compiler_string_consts.object_type_name), typeof(object));

            int_type = get_compiled_type(new SymInfo(PascalABCCompiler.TreeConverter.compiler_string_consts.integer_type_name, SymbolKind.Type, PascalABCCompiler.TreeConverter.compiler_string_consts.integer_type_name), typeof(int));


            real_type = get_compiled_type(new SymInfo(PascalABCCompiler.TreeConverter.compiler_string_consts.real_type_name, SymbolKind.Type, PascalABCCompiler.TreeConverter.compiler_string_consts.real_type_name), typeof(double));

            string_type = get_compiled_type(new SymInfo(PascalABCCompiler.TreeConverter.compiler_string_consts.string_type_name, SymbolKind.Class, PascalABCCompiler.TreeConverter.compiler_string_consts.string_type_name), typeof(string));

            char_type = get_compiled_type(new SymInfo(PascalABCCompiler.TreeConverter.compiler_string_consts.char_type_name, SymbolKind.Type, PascalABCCompiler.TreeConverter.compiler_string_consts.char_type_name), typeof(char));

            bool_type = get_compiled_type(new SymInfo(PascalABCCompiler.TreeConverter.compiler_string_consts.bool_type_name, SymbolKind.Type, PascalABCCompiler.TreeConverter.compiler_string_consts.bool_type_name), typeof(bool));

            byte_type = get_compiled_type(new SymInfo(PascalABCCompiler.TreeConverter.compiler_string_consts.byte_type_name, SymbolKind.Type, PascalABCCompiler.TreeConverter.compiler_string_consts.byte_type_name), typeof(byte));

            int16_type = get_compiled_type(new SymInfo(PascalABCCompiler.TreeConverter.compiler_string_consts.short_type_name, SymbolKind.Type, PascalABCCompiler.TreeConverter.compiler_string_consts.short_type_name), typeof(short));

            sbyte_type = get_compiled_type(new SymInfo(PascalABCCompiler.TreeConverter.compiler_string_consts.sbyte_type_name, SymbolKind.Type, PascalABCCompiler.TreeConverter.compiler_string_consts.sbyte_type_name), typeof(sbyte));

            uint16_type = get_compiled_type(new SymInfo(PascalABCCompiler.TreeConverter.compiler_string_consts.ushort_type_name, SymbolKind.Type, PascalABCCompiler.TreeConverter.compiler_string_consts.ushort_type_name), typeof(ushort));

            uint32_type = get_compiled_type(new SymInfo(PascalABCCompiler.TreeConverter.compiler_string_consts.uint_type_name, SymbolKind.Type, PascalABCCompiler.TreeConverter.compiler_string_consts.uint_type_name), typeof(uint));

            int64_type = get_compiled_type(new SymInfo(PascalABCCompiler.TreeConverter.compiler_string_consts.long_type_name, SymbolKind.Type, PascalABCCompiler.TreeConverter.compiler_string_consts.long_type_name), typeof(long));

            uint64_type = get_compiled_type(new SymInfo(PascalABCCompiler.TreeConverter.compiler_string_consts.ulong_type_name, SymbolKind.Type, PascalABCCompiler.TreeConverter.compiler_string_consts.ulong_type_name), typeof(ulong));

            float_type = get_compiled_type(new SymInfo(PascalABCCompiler.TreeConverter.compiler_string_consts.float_type_name, SymbolKind.Type, PascalABCCompiler.TreeConverter.compiler_string_consts.float_type_name), typeof(float));

            ptr_type = get_compiled_type(new SymInfo(PascalABCCompiler.TreeConverter.compiler_string_consts.pointer_type_name, SymbolKind.Type, PascalABCCompiler.TreeConverter.compiler_string_consts.pointer_type_name), Type.GetType("System.Void*"));

            void_type = get_compiled_type(new SymInfo("void", SymbolKind.Type, "void"), typeof(void));

            ProcScope ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.plus_name, int_type);
            int_plus = ps;
            ElementScope left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int_type, int_type);
            ElementScope right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int_type, int_type);
            ps.return_type = int_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            int_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.plus_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.minus_name, int_type);
            int_minus = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int_type, int_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int_type, int_type);
            ps.return_type = int_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            int_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.minus_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.mul_name, int_type);
            int_mul = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int_type, int_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int_type, int_type);
            ps.return_type = int_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            int_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.mul_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.idiv_name, int_type);
            int_div = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int_type, int_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int_type, int_type);
            ps.return_type = int_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            int_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.idiv_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.mod_name, int_type);
            int_mod = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int_type, int_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int_type, int_type);
            ps.return_type = int_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            int_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.mod_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.shl_name, int_type);
            int_shl = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int_type, int_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int_type, int_type);
            ps.return_type = int_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            int_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.shl_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.shr_name, int_type);
            int_shr = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int_type, int_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int_type, int_type);
            ps.return_type = int_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            int_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.shr_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.and_name, int_type);
            int_and = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int_type, int_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int_type, int_type);
            ps.return_type = int_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            int_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.and_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.or_name, int_type);
            int_or = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int_type, int_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int_type, int_type);
            ps.return_type = int_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            int_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.or_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.xor_name, int_type);
            int_xor = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int_type, int_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int_type, int_type);
            ps.return_type = int_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            int_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.xor_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.eq_name, int_type);
            int_eq = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int_type, int_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int_type, int_type);
            ps.return_type = bool_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            int_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.eq_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.noteq_name, int_type);
            int_noteq = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int_type, int_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int_type, int_type);
            ps.return_type = bool_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            int_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.noteq_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.sm_name, int_type);
            int_sm = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int_type, int_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int_type, int_type);
            ps.return_type = bool_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            int_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.sm_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.smeq_name, int_type);
            int_smeq = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int_type, int_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int_type, int_type);
            ps.return_type = bool_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            int_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.smeq_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.gr_name, int_type);
            int_gr = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int_type, int_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int_type, int_type);
            ps.return_type = bool_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            int_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.gr_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.greq_name, int_type);
            int_greq = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int_type, int_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int_type, int_type);
            ps.return_type = bool_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            int_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.greq_name, ps);

            //byte type
            byte_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.plus_name, int_plus);
            byte_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.minus_name, int_minus);
            byte_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.mul_name, int_mul);
            byte_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.idiv_name, int_div);
            byte_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.mod_name, int_mod);
            byte_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.shl_name, int_shl);
            byte_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.shr_name, int_shr);
            byte_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.eq_name, int_eq);
            byte_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.noteq_name, int_noteq);
            byte_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.sm_name, int_sm);
            byte_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.smeq_name, int_smeq);
            byte_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.gr_name, int_gr);
            byte_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.greq_name, int_greq);
            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.and_name, byte_type);
            byte_and = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), byte_type, byte_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), byte_type, byte_type);
            ps.return_type = byte_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            byte_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.and_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.or_name, byte_type);
            byte_or = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), byte_type, byte_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), byte_type, byte_type);
            ps.return_type = byte_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            byte_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.or_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.xor_name, byte_type);
            byte_xor = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), byte_type, byte_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), byte_type, byte_type);
            ps.return_type = byte_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            byte_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.xor_name, ps);

            //sbyte
            sbyte_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.plus_name, int_plus);
            sbyte_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.minus_name, int_minus);
            sbyte_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.mul_name, int_mul);
            sbyte_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.idiv_name, int_div);
            sbyte_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.mod_name, int_mod);
            sbyte_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.shl_name, int_shl);
            sbyte_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.shr_name, int_shr);
            sbyte_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.eq_name, int_eq);
            sbyte_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.noteq_name, int_noteq);
            sbyte_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.sm_name, int_sm);
            sbyte_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.smeq_name, int_smeq);
            sbyte_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.gr_name, int_gr);
            sbyte_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.greq_name, int_greq);
            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.and_name, sbyte_type);
            sbyte_and = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), sbyte_type, sbyte_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), sbyte_type, sbyte_type);
            ps.return_type = sbyte_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            sbyte_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.and_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.or_name, sbyte_type);
            sbyte_or = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), sbyte_type, sbyte_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), sbyte_type, sbyte_type);
            ps.return_type = sbyte_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            sbyte_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.or_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.xor_name, sbyte_type);
            sbyte_xor = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), sbyte_type, sbyte_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), sbyte_type, sbyte_type);
            ps.return_type = sbyte_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            sbyte_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.xor_name, ps);

            //ushort
            uint16_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.plus_name, int_plus);
            uint16_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.minus_name, int_minus);
            uint16_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.mul_name, int_mul);
            uint16_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.idiv_name, int_div);
            uint16_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.mod_name, int_mod);
            uint16_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.shl_name, int_shl);
            uint16_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.shr_name, int_shr);
            uint16_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.eq_name, int_eq);
            uint16_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.noteq_name, int_noteq);
            uint16_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.sm_name, int_sm);
            uint16_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.smeq_name, int_smeq);
            uint16_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.gr_name, int_gr);
            uint16_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.greq_name, int_greq);
            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.and_name, uint16_type);
            uint16_and = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), uint16_type, uint16_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), uint16_type, uint16_type);
            ps.return_type = uint16_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            uint16_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.and_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.or_name, uint16_type);
            uint16_or = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), uint16_type, uint16_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), uint16_type, uint16_type);
            ps.return_type = uint16_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            uint16_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.or_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.xor_name, uint16_type);
            uint16_xor = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), uint16_type, uint16_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), uint16_type, uint16_type);
            ps.return_type = uint16_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            uint16_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.xor_name, ps);

            //int16
            int16_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.plus_name, int_plus);
            int16_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.minus_name, int_minus);
            int16_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.mul_name, int_mul);
            int16_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.idiv_name, int_div);
            int16_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.mod_name, int_mod);
            int16_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.shl_name, int_shl);
            int16_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.shr_name, int_shr);
            int16_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.eq_name, int_eq);
            int16_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.noteq_name, int_noteq);
            int16_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.sm_name, int_sm);
            int16_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.smeq_name, int_smeq);
            int16_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.gr_name, int_gr);
            int16_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.greq_name, int_greq);
            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.and_name, uint16_type);
            int16_and = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int16_type, int16_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int16_type, int16_type);
            ps.return_type = int16_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            int16_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.and_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.or_name, int16_type);
            int16_or = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int16_type, int16_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int16_type, int16_type);
            ps.return_type = int16_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            int16_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.or_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.xor_name, int16_type);
            int16_xor = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int16_type, int16_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int16_type, int16_type);
            ps.return_type = int16_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            int16_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.xor_name, ps);

            //int64
            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.plus_name, int64_type);
            int64_plus = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int64_type, int64_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int64_type, int64_type);
            ps.return_type = int64_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            int64_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.plus_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.minus_name, int64_type);
            int64_minus = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int64_type, int64_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int64_type, int64_type);
            ps.return_type = int64_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            int64_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.minus_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.mul_name, int64_type);
            int64_mul = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int64_type, int64_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int64_type, int64_type);
            ps.return_type = int64_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            int64_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.mul_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.idiv_name, int64_type);
            int64_div = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int64_type, int64_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int64_type, int64_type);
            ps.return_type = int64_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            int64_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.idiv_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.mod_name, int64_type);
            int64_mod = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int64_type, int64_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int64_type, int64_type);
            ps.return_type = int64_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            int64_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.mod_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.shl_name, int64_type);
            int64_shl = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int64_type, int64_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int64_type, int64_type);
            ps.return_type = int64_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            int64_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.shl_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.shr_name, int64_type);
            int64_shr = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int64_type, int64_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int64_type, int64_type);
            ps.return_type = int64_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            int64_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.shr_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.and_name, int64_type);
            int64_and = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int64_type, int64_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int64_type, int64_type);
            ps.return_type = int64_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            int64_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.and_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.or_name, int64_type);
            int64_or = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int64_type, int64_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int64_type, int64_type);
            ps.return_type = int64_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            int64_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.or_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.xor_name, int64_type);
            int64_xor = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int64_type, int64_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int64_type, int64_type);
            ps.return_type = int64_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            int64_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.xor_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.eq_name, int64_type);
            int64_eq = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int64_type, int64_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int64_type, int64_type);
            ps.return_type = bool_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            int64_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.eq_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.noteq_name, int64_type);
            int64_noteq = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int64_type, int64_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int64_type, int64_type);
            ps.return_type = bool_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            int64_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.noteq_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.sm_name, int64_type);
            int64_sm = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int64_type, int64_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int64_type, int64_type);
            ps.return_type = bool_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            int64_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.sm_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.smeq_name, int64_type);
            int64_smeq = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int64_type, int64_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int64_type, int64_type);
            ps.return_type = bool_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            int64_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.smeq_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.gr_name, int64_type);
            int64_gr = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int64_type, int64_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int64_type, int64_type);
            ps.return_type = bool_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            int64_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.gr_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.greq_name, int64_type);
            int64_greq = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int64_type, int64_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int64_type, int64_type);
            ps.return_type = bool_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            int64_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.greq_name, ps);

            //uint
            //int16
            uint32_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.plus_name, int64_plus);
            uint32_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.minus_name, int64_minus);
            uint32_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.mul_name, int64_mul);
            uint32_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.idiv_name, int64_div);
            uint32_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.mod_name, int64_mod);
            uint32_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.shl_name, int64_shl);
            uint32_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.shr_name, int64_shr);
            uint32_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.eq_name, int64_eq);
            uint32_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.noteq_name, int64_noteq);
            uint32_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.sm_name, int64_sm);
            uint32_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.smeq_name, int64_smeq);
            uint32_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.gr_name, int64_gr);
            uint32_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.greq_name, int64_greq);
            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.and_name, uint32_type);
            uint32_and = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), uint32_type, uint32_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), uint32_type, uint32_type);
            ps.return_type = uint32_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            uint32_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.and_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.or_name, uint32_type);
            uint32_or = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), uint32_type, uint32_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), uint32_type, uint32_type);
            ps.return_type = uint32_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            uint32_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.or_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.xor_name, uint32_type);
            uint32_xor = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), uint32_type, uint32_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), uint32_type, uint32_type);
            ps.return_type = uint32_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            uint32_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.xor_name, ps);

            //uint64 type
            uint64_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.plus_name, int64_plus);
            uint64_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.minus_name, int64_minus);
            uint64_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.mul_name, int64_mul);
            uint64_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.idiv_name, int64_div);
            uint64_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.mod_name, int64_mod);
            uint64_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.shl_name, int64_shl);
            uint64_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.shr_name, int64_shr);
            uint64_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.eq_name, int64_eq);
            uint64_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.noteq_name, int64_noteq);
            uint64_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.sm_name, int64_sm);
            uint64_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.smeq_name, int64_smeq);
            uint64_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.gr_name, int64_gr);
            uint64_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.greq_name, int64_greq);
            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.and_name, uint64_type);
            uint64_and = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), uint64_type, uint64_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), uint64_type, uint64_type);
            ps.return_type = uint64_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            uint64_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.and_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.or_name, uint64_type);
            uint64_or = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), uint64_type, uint64_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), uint64_type, uint64_type);
            ps.return_type = uint64_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            uint64_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.or_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.xor_name, uint64_type);
            uint64_xor = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), uint64_type, uint64_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), uint64_type, uint64_type);
            ps.return_type = uint64_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            uint64_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.xor_name, ps);

            //real_type
            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.plus_name, real_type);
            real_plus = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), real_type, real_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), real_type, real_type);
            ps.return_type = real_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            real_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.plus_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.minus_name, real_type);
            real_minus = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), real_type, real_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), real_type, real_type);
            ps.return_type = real_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            real_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.minus_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.mul_name, real_type);
            real_mul = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), real_type, real_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), real_type, real_type);
            ps.return_type = real_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            real_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.mul_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.div_name, real_type);
            real_div = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), real_type, real_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), real_type, real_type);
            ps.return_type = real_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            real_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.div_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.eq_name, real_type);
            real_eq = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), real_type, real_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), real_type, real_type);
            ps.return_type = real_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            real_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.eq_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.noteq_name, real_type);
            real_noteq = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), real_type, real_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), real_type, real_type);
            ps.return_type = bool_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            real_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.noteq_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.sm_name, real_type);
            real_sm = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), real_type, real_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), real_type, real_type);
            ps.return_type = bool_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            real_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.sm_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.smeq_name, real_type);
            real_smeq = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), real_type, real_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), real_type, real_type);
            ps.return_type = bool_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            real_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.smeq_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.gr_name, real_type);
            real_gr = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), real_type, real_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), real_type, real_type);
            ps.return_type = bool_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            real_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.gr_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.greq_name, int64_type);
            real_greq = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int64_type, int64_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), int64_type, int64_type);
            ps.return_type = bool_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            real_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.greq_name, ps);

            int_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.plus_name, int64_plus);
            int_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.minus_name, int64_minus);
            int_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.mul_name, int64_mul);
            int_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.div_name, int64_div);
            int_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.mod_name, int64_mod);
            int_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.shl_name, int64_shl);
            int_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.shr_name, int64_shr);
            int_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.eq_name, int64_eq);
            int_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.noteq_name, int64_noteq);
            int_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.sm_name, int64_sm);
            int_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.smeq_name, int64_smeq);
            int_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.gr_name, int64_gr);
            int_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.greq_name, int64_greq);

            int_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.plus_name, real_plus);
            int_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.minus_name, real_minus);
            int_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.mul_name, real_mul);
            int_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.div_name, real_div);
            int_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.eq_name, real_eq);
            int_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.noteq_name, real_noteq);
            int_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.sm_name, real_sm);
            int_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.smeq_name, real_smeq);
            int_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.gr_name, real_gr);
            int_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.greq_name, real_greq);

            int64_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.plus_name, real_plus);
            int64_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.minus_name, real_minus);
            int64_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.mul_name, real_mul);
            int64_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.div_name, real_div);
            int64_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.eq_name, real_eq);
            int64_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.noteq_name, real_noteq);
            int64_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.sm_name, real_sm);
            int64_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.smeq_name, real_smeq);
            int64_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.gr_name, real_gr);
            int64_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.greq_name, real_greq);

            //boolean type
            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.and_name, bool_type);
            bool_and = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), bool_type, bool_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), bool_type, bool_type);
            ps.return_type = bool_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            bool_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.and_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.or_name, bool_type);
            bool_or = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), bool_type, bool_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), bool_type, bool_type);
            ps.return_type = bool_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            bool_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.or_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.xor_name, bool_type);
            bool_xor = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), bool_type, bool_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), bool_type, bool_type);
            ps.return_type = bool_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            bool_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.xor_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.eq_name, bool_type);
            bool_eq = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), bool_type, bool_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), bool_type, bool_type);
            ps.return_type = bool_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            bool_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.eq_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.noteq_name, bool_type);
            bool_noteq = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), bool_type, bool_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), bool_type, bool_type);
            ps.return_type = bool_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            bool_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.noteq_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.sm_name, bool_type);
            bool_sm = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), bool_type, bool_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), bool_type, bool_type);
            ps.return_type = bool_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            bool_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.sm_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.smeq_name, bool_type);
            bool_smeq = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), bool_type, bool_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), bool_type, bool_type);
            ps.return_type = bool_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            bool_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.smeq_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.gr_name, bool_type);
            bool_gr = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), bool_type, bool_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), bool_type, bool_type);
            ps.return_type = bool_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            bool_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.gr_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.greq_name, bool_type);
            bool_greq = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), bool_type, bool_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), bool_type, bool_type);
            ps.return_type = bool_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            bool_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.greq_name, ps);

            //char type
            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.eq_name, char_type);
            char_eq = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), char_type, char_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), char_type, char_type);
            ps.return_type = bool_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            char_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.eq_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.noteq_name, char_type);
            char_noteq = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), char_type, char_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), char_type, char_type);
            ps.return_type = bool_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            char_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.noteq_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.sm_name, char_type);
            char_sm = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), char_type, char_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), char_type, char_type);
            ps.return_type = bool_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            char_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.sm_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.smeq_name, char_type);
            char_smeq = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), char_type, char_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), char_type, char_type);
            ps.return_type = bool_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            char_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.smeq_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.greq_name, char_type);
            char_greq = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), char_type, char_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), char_type, char_type);
            ps.return_type = bool_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            char_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.greq_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.gr_name, char_type);
            char_gr = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), char_type, char_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), char_type, char_type);
            ps.return_type = bool_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            char_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.gr_name, ps);

            //string type
            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.plus_name, string_type);
            string_plus = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), string_type, string_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), string_type, string_type);
            ps.return_type = string_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            string_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.plus_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.eq_name, string_type);
            string_eq = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), string_type, string_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), string_type, string_type);
            ps.return_type = bool_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            string_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.eq_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.noteq_name, string_type);
            string_noteq = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), string_type, string_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), string_type, string_type);
            ps.return_type = bool_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            string_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.noteq_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.sm_name, string_type);
            string_sm = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), string_type, string_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), string_type, string_type);
            ps.return_type = bool_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            string_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.sm_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.smeq_name, string_type);
            string_smeq = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), string_type, string_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), string_type, string_type);
            ps.return_type = bool_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            string_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.smeq_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.gr_name, string_type);
            string_gr = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), string_type, string_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), string_type, string_type);
            ps.return_type = bool_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            string_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.gr_name, ps);

            ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.greq_name, string_type);
            string_greq = ps;
            left = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), string_type, string_type);
            right = new ElementScope(new SymInfo("", SymbolKind.Parameter, ""), string_type, string_type);
            ps.return_type = bool_type;
            ps.AddParameter(left);
            ps.AddParameter(right);
            string_type.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.greq_name, ps);
        }
示例#2
0
 public virtual TypeScope GetInstance(List<TypeScope> gen_args)
 {
     TypeScope ts = new TypeScope(this.kind, this.topScope, this.baseScope);
     ts.original_type = this;
     ts.loc = this.loc;
     for (int i = 0; i < gen_args.Count; i++)
     {
         ts.AddGenericParameter(gen_args[i].si.name);
         ts.AddGenericInstanciation(gen_args[i]);
     }
     ts.si.name = this.si.name;
     ts.documentation = this.documentation;
     ts.si.description = ts.GetDescription();
     if (this.elementType != null)
     {
         ts.elementType = internalInstance(this.elementType, gen_args);
     }
     if (this.indexers != null && this.indexers.Count > 0)
     {
         ts.indexers = new List<TypeScope>();
         for (int j = 0; j < this.indexers.Count; j++)
             ts.indexers.Add(internalInstance(this.indexers[j], gen_args));
     }
     Hashtable procs = new Hashtable();
     for (int i = 0; i < members.Count; i++)
     {
         SymScope ss = members[i];
         ts.members.Add(ss);
         if (ss is ElementScope)
         {
             ElementScope es = ss as ElementScope;
             ElementScope new_es = new ElementScope(new SymInfo(es.si.name, es.si.kind, es.si.name), es.sc, ts);
             ts.members[i] = new_es;
             new_es.loc = es.loc;
             new_es.documentation = es.documentation;
             new_es.si.acc_mod = es.si.acc_mod;
             new_es.si.has_doc = es.si.has_doc;
             if (es.indexers != null && es.indexers.Count > 0)
             {
                 new_es.indexers = new List<TypeScope>();
                 for (int j = 0; j < es.indexers.Count; j++)
                     new_es.indexers.Add(internalInstance(es.indexers[j], gen_args));
             }
             if (es.elementType != null)
             {
                 new_es.elementType = internalInstance(es.elementType, gen_args);
             }
             new_es.sc = internalInstance(es.sc as TypeScope, gen_args);
             new_es.MakeDescription();
         }
         else if (ss is ProcScope)
         {
             ProcScope ps = ss as ProcScope;
             ProcScope new_proc = new ProcScope(ps.si.name, ts, ps.is_constructor);
             procs[ps] = new_proc;
             new_proc.loc = ps.loc;
             new_proc.documentation = ps.documentation;
             new_proc.si.acc_mod = ps.si.acc_mod;
             new_proc.is_static = ps.is_static;
             new_proc.is_virtual = ps.is_virtual;
             new_proc.is_abstract = ps.is_abstract;
             new_proc.is_override = ps.is_override;
             new_proc.is_reintroduce = ps.is_reintroduce;
             ts.members[i] = new_proc;
             if (ps.parameters != null)
                 for (int j = 0; j < ps.parameters.Count; j++)
                 {
                     ElementScope es = ps.parameters[j];
                     ElementScope es2 = new ElementScope(new SymInfo(es.si.name, es.si.kind, es.si.name), es.sc, new_proc);
                     es2.loc = es.loc;
                     es2.cnst_val = es.cnst_val;
                     es2.si.acc_mod = es.si.acc_mod;
                     es2.param_kind = es.param_kind;
                     es2.sc = internalInstance(es.sc as TypeScope, gen_args);
                     es2.MakeDescription();
                     new_proc.AddParameter(es2);
                 }
             new_proc.return_type = internalInstance(ps.return_type, gen_args);
             new_proc.Complete();
         }
     }
     foreach (ProcScope ps in procs.Keys)
     {
         ProcScope new_ps = procs[ps] as ProcScope;
         if (ps.nextProc != null && procs[ps.nextProc] != null)
         {
             new_ps.nextProc = procs[ps.nextProc] as ProcScope;
         }
     }
     return ts;
 }
  private void add_standart_types(SymScope cur_scope)
  {
  	string type_name = null;
  	//obj_type = new CompiledScope(new SymInfo(PascalABCCompiler.TreeConverter.compiler_string_consts.object_type_name, SymbolKind.Type,PascalABCCompiler.TreeConverter.compiler_string_consts.object_type_name),typeof(object));
  	cur_scope.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.object_type_name,TypeTable.obj_type);
  	//int_type = new CompiledScope(new SymInfo(PascalABCCompiler.TreeConverter.compiler_string_consts.integer_type_name, SymbolKind.Type,PascalABCCompiler.TreeConverter.compiler_string_consts.integer_type_name),typeof(int));
  	//cur_scope.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.integer_type_name, int_type);
  	type_name = this.converter.controller.Parser.LanguageInformation.GetStandardTypeByKeyword(PascalABCCompiler.Parsers.KeywordKind.IntType);
  	if (type_name != null) cur_scope.AddName(type_name, TypeTable.int_type);
  	//real_type = new CompiledScope(new SymInfo(PascalABCCompiler.TreeConverter.compiler_string_consts.real_type_name, SymbolKind.Type,PascalABCCompiler.TreeConverter.compiler_string_consts.real_type_name),typeof(double));
  	//cur_scope.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.real_type_name,real_type);
      type_name = this.converter.controller.Parser.LanguageInformation.GetStandardTypeByKeyword(PascalABCCompiler.Parsers.KeywordKind.DoubleType);
      if (type_name != null) cur_scope.AddName(type_name, TypeTable.real_type);
  	//string_type = new CompiledScope(new SymInfo(PascalABCCompiler.TreeConverter.compiler_string_consts.string_type_name, SymbolKind.Class,PascalABCCompiler.TreeConverter.compiler_string_consts.string_type_name),typeof(string));
  	cur_scope.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.string_type_name,TypeTable.string_type);
  	//cur_scope.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.string_type_name,
  	//new CompiledScope(new SymInfo(PascalABCCompiler.TreeConverter.compiler_string_consts.string_type_name, SymbolKind.Type,PascalABCCompiler.TreeConverter.compiler_string_consts.ShortStringTypeName),typeof(string)));
  	//char_type = new CompiledScope(new SymInfo(PascalABCCompiler.TreeConverter.compiler_string_consts.char_type_name, SymbolKind.Type,PascalABCCompiler.TreeConverter.compiler_string_consts.char_type_name),typeof(char));
  	type_name = this.converter.controller.Parser.LanguageInformation.GetStandardTypeByKeyword(PascalABCCompiler.Parsers.KeywordKind.CharType);
      if (type_name != null) cur_scope.AddName(type_name, TypeTable.char_type);
  	//cur_scope.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.char_type_name,char_type);
  	//bool_type = new CompiledScope(new SymInfo(PascalABCCompiler.TreeConverter.compiler_string_consts.bool_type_name, SymbolKind.Type,PascalABCCompiler.TreeConverter.compiler_string_consts.bool_type_name),typeof(bool));
  	type_name = this.converter.controller.Parser.LanguageInformation.GetStandardTypeByKeyword(PascalABCCompiler.Parsers.KeywordKind.BoolType);
      if (type_name != null) cur_scope.AddName(type_name, TypeTable.bool_type);
  	//cur_scope.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.bool_type_name,bool_type);
  	//byte_type = new CompiledScope(new SymInfo(PascalABCCompiler.TreeConverter.compiler_string_consts.byte_type_name, SymbolKind.Type,PascalABCCompiler.TreeConverter.compiler_string_consts.byte_type_name),typeof(byte));
  	type_name = this.converter.controller.Parser.LanguageInformation.GetStandardTypeByKeyword(PascalABCCompiler.Parsers.KeywordKind.ByteType);
      if (type_name != null) cur_scope.AddName(type_name, TypeTable.byte_type);
  	//cur_scope.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.byte_type_name,byte_type);
  	//int16_type = new CompiledScope(new SymInfo(PascalABCCompiler.TreeConverter.compiler_string_consts.short_type_name, SymbolKind.Type,PascalABCCompiler.TreeConverter.compiler_string_consts.short_type_name),typeof(short));
  	type_name = this.converter.controller.Parser.LanguageInformation.GetStandardTypeByKeyword(PascalABCCompiler.Parsers.KeywordKind.ShortType);
      if (type_name != null) cur_scope.AddName(type_name, TypeTable.int16_type);
  	//cur_scope.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.short_type_name,int16_type);
  	//sbyte_type = new CompiledScope(new SymInfo(PascalABCCompiler.TreeConverter.compiler_string_consts.sbyte_type_name, SymbolKind.Type,PascalABCCompiler.TreeConverter.compiler_string_consts.sbyte_type_name),typeof(sbyte));
  	type_name = this.converter.controller.Parser.LanguageInformation.GetStandardTypeByKeyword(PascalABCCompiler.Parsers.KeywordKind.SByteType);
      if (type_name != null) cur_scope.AddName(type_name, TypeTable.sbyte_type);
  	//cur_scope.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.sbyte_type_name,sbyte_type);
  	//uint16_type = new CompiledScope(new SymInfo(PascalABCCompiler.TreeConverter.compiler_string_consts.ushort_type_name, SymbolKind.Type,PascalABCCompiler.TreeConverter.compiler_string_consts.ushort_type_name),typeof(ushort));
  	type_name = this.converter.controller.Parser.LanguageInformation.GetStandardTypeByKeyword(PascalABCCompiler.Parsers.KeywordKind.UShortType);
      if (type_name != null) cur_scope.AddName(type_name, TypeTable.uint16_type);
  	//cur_scope.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.ushort_type_name,uint16_type);
  	//uint32_type = new CompiledScope(new SymInfo(PascalABCCompiler.TreeConverter.compiler_string_consts.uint_type_name, SymbolKind.Type,PascalABCCompiler.TreeConverter.compiler_string_consts.uint_type_name),typeof(uint));
  	type_name = this.converter.controller.Parser.LanguageInformation.GetStandardTypeByKeyword(PascalABCCompiler.Parsers.KeywordKind.UIntType);
      if (type_name != null) cur_scope.AddName(type_name, TypeTable.uint32_type);
  	//cur_scope.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.uint_type_name,uint32_type);
  	//int64_type = new CompiledScope(new SymInfo(PascalABCCompiler.TreeConverter.compiler_string_consts.long_type_name, SymbolKind.Type,PascalABCCompiler.TreeConverter.compiler_string_consts.long_type_name),typeof(long));
  	type_name = this.converter.controller.Parser.LanguageInformation.GetStandardTypeByKeyword(PascalABCCompiler.Parsers.KeywordKind.Int64Type);
      if (type_name != null) cur_scope.AddName(type_name, TypeTable.int64_type);
  	//cur_scope.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.long_type_name,int64_type);
  	//uint64_type = new CompiledScope(new SymInfo(PascalABCCompiler.TreeConverter.compiler_string_consts.ulong_type_name, SymbolKind.Type,PascalABCCompiler.TreeConverter.compiler_string_consts.ulong_type_name),typeof(ulong));
  	type_name = this.converter.controller.Parser.LanguageInformation.GetStandardTypeByKeyword(PascalABCCompiler.Parsers.KeywordKind.UInt64Type);
      if (type_name != null) cur_scope.AddName(type_name, TypeTable.uint64_type);
  	//cur_scope.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.ulong_type_name,uint64_type);
  	//float_type = new CompiledScope(new SymInfo(PascalABCCompiler.TreeConverter.compiler_string_consts.float_type_name, SymbolKind.Type,PascalABCCompiler.TreeConverter.compiler_string_consts.float_type_name),typeof(float));
  	type_name = this.converter.controller.Parser.LanguageInformation.GetStandardTypeByKeyword(PascalABCCompiler.Parsers.KeywordKind.FloatType);
      if (type_name != null) cur_scope.AddName(type_name, TypeTable.float_type);
  	//cur_scope.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.float_type_name,float_type);
  	//ptr_type = new CompiledScope(new SymInfo(PascalABCCompiler.TreeConverter.compiler_string_consts.pointer_type_name, SymbolKind.Type,PascalABCCompiler.TreeConverter.compiler_string_consts.pointer_type_name),Type.GetType("System.Void*"));
  	type_name = this.converter.controller.Parser.LanguageInformation.GetStandardTypeByKeyword(PascalABCCompiler.Parsers.KeywordKind.PointerType);
      if (type_name != null) cur_scope.AddName(type_name, TypeTable.ptr_type);
  	//cur_scope.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.pointer_type_name,ptr_type);
  	ProcScope ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.set_length_procedure_name,null);
  	ps.AddParameter(new ElementScope(new SymInfo("arr", SymbolKind.Parameter,"arr"),new ArrayScope(),null,ps));
  	ps.parameters[0].param_kind = parametr_kind.var_parametr;
  	ps.AddParameter(new ElementScope(new SymInfo("length", SymbolKind.Parameter,"length"),TypeTable.int_type,null,ps));
  	ps.Complete();
  	cur_scope.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.set_length_procedure_name,ps);
  	cur_scope.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.true_const_name,new ElementScope(new SymInfo(PascalABCCompiler.TreeConverter.compiler_string_consts.true_const_name, SymbolKind.Constant,PascalABCCompiler.TreeConverter.compiler_string_consts.true_const_name),TypeTable.bool_type,true,null));
  	cur_scope.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.false_const_name,new ElementScope(new SymInfo(PascalABCCompiler.TreeConverter.compiler_string_consts.false_const_name, SymbolKind.Constant,PascalABCCompiler.TreeConverter.compiler_string_consts.false_const_name),TypeTable.bool_type,false,null));
 		ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.new_procedure_name,null);
 		ElementScope prm = new ElementScope(new SymInfo("p", SymbolKind.Parameter,"p"),TypeTable.ptr_type,null,ps);
 		prm.param_kind = parametr_kind.var_parametr;
 		ps.AddParameter(prm);
 		ps.Complete();
 		cur_scope.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.new_procedure_name,ps);
 		ps = new ProcScope(PascalABCCompiler.TreeConverter.compiler_string_consts.dispose_procedure_name,null);
 		prm = new ElementScope(new SymInfo("p", SymbolKind.Parameter,"p"),TypeTable.ptr_type,null,ps);
 		prm.param_kind = parametr_kind.var_parametr;
 		ps.AddParameter(prm);
 		ps.Complete();
 		cur_scope.AddName(PascalABCCompiler.TreeConverter.compiler_string_consts.dispose_procedure_name,ps);
 }
 public override void visit(function_lambda_definition _function_lambda_definition)
 {
     ProcScope ps = new ProcScope(_function_lambda_definition.lambda_name, this.cur_scope);
     ps.loc = get_location(_function_lambda_definition);
     cur_scope.AddName(_function_lambda_definition.lambda_name, ps);
     if (_function_lambda_definition.ident_list != null)
         foreach (ident id in _function_lambda_definition.ident_list.idents)
         {
             ElementScope es = new ElementScope(new SymInfo(id.name, SymbolKind.Parameter, ""), new UnknownScope(new SymInfo("T", SymbolKind.Type, "T")), ps);
             ps.AddName(id.name, es);
             ps.AddParameter(es);
             es.loc = get_location(id);
         }
     _function_lambda_definition.proc_body.visit(this);
     ps.return_type = returned_scope as TypeScope;
     returned_scope = new ProcType(ps);
 }
 public override void visit(function_lambda_definition _function_lambda_definition)
 {
     ProcScope ps = new ProcScope(_function_lambda_definition.lambda_name, null);
     if (_function_lambda_definition.ident_list != null)
         foreach (ident id in _function_lambda_definition.ident_list.idents)
             ps.AddParameter(new ElementScope(new SymInfo(id.name, SymbolKind.Parameter, ""), new UnknownScope(new SymInfo("", SymbolKind.Type, "")), ps));
     _function_lambda_definition.proc_body.visit(this);
     if (returned_scope is ElementScope)
         returned_scope = (returned_scope as ElementScope).sc;
     ps.return_type = returned_scope as TypeScope;
     returned_scope = new ProcType(ps);
 }