Esempio n. 1
0
 private IFunctionNode find_constructor(ICommonTypeNode tn)
 {
     foreach (ICommonMethodNode cmn in tn.methods)
     {
         if (cmn.is_constructor)
         {
             return(cmn);
         }
     }
     return(null);
 }
Esempio n. 2
0
 private IFunctionNode find_constructor_with_params(ICommonTypeNode tn)
 {
     foreach (ICommonMethodNode cmn in tn.methods)
     {
         if (cmn.is_constructor && cmn.parameters.Length == 2)
         {
             return(cmn);
         }
     }
     return(null);
 }
Esempio n. 3
0
 private IFunctionNode find_method(ICommonTypeNode tn, string name)
 {
     foreach (ICommonMethodNode cmn in tn.methods)
     {
         if (string.Compare(cmn.name, name, true) == 0)
         {
             return(cmn);
         }
     }
     return(null);
 }
Esempio n. 4
0
        public List <ICommonMethodNode> GetOverloadedConstructors(ICommonTypeNode t)
        {
            List <ICommonMethodNode> lst = new List <ICommonMethodNode>();

            foreach (ICommonMethodNode m in t.methods)
            {
                if (m.is_constructor)
                {
                    lst.Add(m);
                }
            }
            return(lst);
        }
Esempio n. 5
0
        public ICommonClassFieldNode[] GetDefinedFields(ICommonTypeNode ctn)
        {
            List <ICommonClassFieldNode> lst = new List <ICommonClassFieldNode>();

            foreach (ICommonClassFieldNode fld in ctn.fields)
            {
                if (!fld.name.Contains("$"))
                {
                    lst.Add(fld);
                }
            }
            return(lst.ToArray());
        }
Esempio n. 6
0
        public ITypeNode[] GetChildClasses(ICommonTypeNode ctn)
        {
            List <ITypeNode> lst = new List <ITypeNode>();

            foreach (ITypeNode t in main_ns.types)
            {
                if (t.base_type == ctn)
                {
                    lst.Add(t);
                }
            }
            return(lst.ToArray());
        }
Esempio n. 7
0
        public IClassConstantDefinitionNode[] GetConstants(ICommonTypeNode ctn, string name)
        {
            List <IClassConstantDefinitionNode> lst = new List <IClassConstantDefinitionNode>();

            foreach (IClassConstantDefinitionNode p in ctn.constants)
            {
                if (string.Compare(p.name, name, true) == 0)
                {
                    lst.Add(p);
                }
            }
            return(lst.ToArray());
        }
Esempio n. 8
0
        public ICommonMethodNode[] GetMethods(ICommonTypeNode t, string name)
        {
            List <ICommonMethodNode> lst = new List <ICommonMethodNode>();

            foreach (ICommonMethodNode m in t.methods)
            {
                if (string.Compare(m.name, name, true) == 0)
                {
                    lst.Add(m);
                }
            }
            return(lst.ToArray());
        }
Esempio n. 9
0
        public ICommonMethodNode[] GetConstructors(ICommonTypeNode ctn)
        {
            List <ICommonMethodNode> lst = new List <ICommonMethodNode>();

            foreach (ICommonMethodNode m in ctn.methods)
            {
                if (m.is_constructor && m.field_access_level != field_access_level.fal_private && m.polymorphic_state != polymorphic_state.ps_static &&
                    HelpUtils.can_write(m))
                {
                    lst.Add(m);
                }
            }
            return(lst.ToArray());
        }
Esempio n. 10
0
        public ICommonPropertyNode[] GetProperties(ICommonTypeNode ctn)
        {
            List <ICommonPropertyNode> lst = new List <ICommonPropertyNode>();

            while (ctn != null)
            {
                foreach (ICommonPropertyNode p in ctn.properties)
                {
                    lst.Add(p);
                }
                ctn = ctn.base_type as ICommonTypeNode;
            }
            lst.Sort(new PropertyComparer());
            return(lst.ToArray());
        }
Esempio n. 11
0
        public bool is_overload(ICommonMethodNode meth, ICommonTypeNode ctn)
        {
            int count = 1;

            while (ctn != null)
            {
                foreach (ICommonMethodNode m in ctn.methods)
                {
                    if (string.Compare(meth.name, m.name, true) == 0 && meth != m && meth.overrided_method != m)
                    {
                        count++;
                    }
                }
                ctn = ctn.base_type as ICommonTypeNode;
            }
            return(count > 1);
        }
Esempio n. 12
0
        public List <ICommonMethodNode> GetOverloadsList(ICommonTypeNode t, ICommonMethodNode meth)
        {
            List <ICommonMethodNode> lst = new List <ICommonMethodNode>();

            while (t != null)
            {
                foreach (ICommonMethodNode m in t.methods)
                {
                    if (string.Compare(m.name, meth.name, true) == 0 && meth.overrided_method != m)
                    {
                        lst.Add(m);
                    }
                }
                t = t.base_type as ICommonTypeNode;
            }
            return(lst);
        }
Esempio n. 13
0
        public ICommonPropertyNode[] GetNonPrivateProperties(ICommonTypeNode ctn)
        {
            List <ICommonPropertyNode> lst = new List <ICommonPropertyNode>();

            while (ctn != null)
            {
                foreach (ICommonPropertyNode p in ctn.properties)
                {
                    if (p.field_access_level != field_access_level.fal_private && HelpUtils.can_write(p))
                    {
                        lst.Add(p);
                    }
                }
                ctn = ctn.base_type as ICommonTypeNode;
            }
            lst.Sort(new PropertyComparer());
            return(lst.ToArray());
        }
Esempio n. 14
0
        public IClassConstantDefinitionNode[] GetNonPrivateClassConstants(ICommonTypeNode ctn)
        {
            List <IClassConstantDefinitionNode> lst = new List <IClassConstantDefinitionNode>();

            while (ctn != null)
            {
                foreach (IClassConstantDefinitionNode p in ctn.constants)
                {
                    if (p.field_access_level != field_access_level.fal_private && HelpUtils.can_write(p))
                    {
                        lst.Add(p);
                    }
                }
                ctn = ctn.base_type as ICommonTypeNode;
            }
            lst.Sort(new ConstantComparer());
            return(lst.ToArray());
        }
Esempio n. 15
0
        public ICommonClassFieldNode[] GetFields(ICommonTypeNode ctn, field_access_level fal)
        {
            List <ICommonClassFieldNode> lst = new List <ICommonClassFieldNode>();

            while (ctn != null)
            {
                foreach (ICommonClassFieldNode p in ctn.fields)
                {
                    if (p.field_access_level == fal && HelpUtils.can_write(p))
                    {
                        lst.Add(p);
                    }
                }
                ctn = ctn.base_type as ICommonTypeNode;
            }
            lst.Sort(new FieldComparer());
            return(lst.ToArray());
        }
Esempio n. 16
0
        public ICommonMethodNode[] GetMethods(ICommonTypeNode ctn, field_access_level fal)
        {
            List <ICommonMethodNode> lst = new List <ICommonMethodNode>();

            ICommonPropertyNode[] props = GetProperties(ctn);
            while (ctn != null)
            {
                foreach (ICommonMethodNode m in ctn.methods)
                {
                    if (!m.is_constructor && m.field_access_level == fal && m.Location != null && !is_getter_or_setter(m, props) &&
                        !is_event_special_method(m) && HelpUtils.can_write(m))
                    {
                        lst.Add(m);
                    }
                }
                ctn = ctn.base_type as ICommonTypeNode;
            }
            lst.Sort(new MethodComparer());
            return(lst.ToArray());
        }
Esempio n. 17
0
        private string getFieldValueFromSemanticNodeAccessModifierType(object _node)
        {
            // структуру в абстр. класс для хранения соотв. значений в Сишарпе (и других языках)
            string fieldValue = "";

            if (_node is ICommonTypeNode)
            {
                ICommonTypeNode node = _node as ICommonTypeNode;

                if ((node).type_access_level == type_access_level.tal_internal)
                {
                    return("internal" + Indents.BetweenWords);
                }

                if ((node).type_access_level == type_access_level.tal_public)
                {
                    return("public" + Indents.BetweenWords);
                }
            }
            return("");
        }
Esempio n. 18
0
        public int GetMethodIndex(ICommonMethodNode cmn, ICommonTypeNode ctn)
        {
            int i = 1;

            while (ctn != null)
            {
                ICommonMethodNode[] meths = ctn.methods;
                foreach (ICommonMethodNode m in meths)
                {
                    if (m == cmn)
                    {
                        return(i);
                    }
                    else if (string.Compare(m.name, cmn.name, true) == 0 && cmn.overrided_method != m)
                    {
                        i++;
                    }
                }
                ctn = ctn.base_type as ICommonTypeNode;
            }
            return(1);
        }
Esempio n. 19
0
 private IFunctionNode find_constructor_with_one_param(ICommonTypeNode tn)
 {
 	foreach (ICommonMethodNode cmn in tn.methods)
 	{
 		if (cmn.is_constructor && cmn.parameters.Length == 1) return cmn;
 	}
 	return null;
 }
Esempio n. 20
0
 private IFunctionNode find_method(ICommonTypeNode tn, string name)
 {
 	foreach (ICommonMethodNode cmn in tn.methods)
 	{
 		if (string.Compare(cmn.name,name,true) == 0) return cmn;
 	}
     return null;
 }
Esempio n. 21
0
 //(ssyy) Инициализации полей типа параметр дженерика
 private void CreateRuntimeInitCodeWithCheck(ILGenerator il, FieldBuilder fb, ICommonTypeNode type)
 {
     if (type.runtime_initialization_marker == null) return;
     Type tinfo = helper.GetTypeReference(type).tp;
     FieldInfo finfo = helper.GetField(type.runtime_initialization_marker).fi;
     Label lab = il.DefineLabel();
     il.Emit(OpCodes.Ldsfld, finfo);
     il.Emit(OpCodes.Brfalse, lab);
     if (!fb.IsStatic)
     {
         il.Emit(OpCodes.Ldarg_0);
     }
     il.Emit(OpCodes.Ldsfld, finfo);
     if (fb.IsStatic)
     {
         il.Emit(OpCodes.Ldsfld, fb);
     }
     else
     {
         il.Emit(OpCodes.Ldarg_0);
         il.Emit(OpCodes.Ldfld, fb);
     }
     il.Emit(OpCodes.Box, tinfo);
     MethodInfo rif = null;
     if (SystemLibrary.SystemLibInitializer.RuntimeInitializeFunction.sym_info is ICompiledMethodNode)
         rif = (SystemLibrary.SystemLibInitializer.RuntimeInitializeFunction.sym_info as ICompiledMethodNode).method_info;
     else
         rif = helper.GetMethod(SystemLibrary.SystemLibInitializer.RuntimeInitializeFunction.sym_info as IFunctionNode).mi;
     il.EmitCall(OpCodes.Call, rif, null);
     il.Emit(OpCodes.Unbox_Any, tinfo);
     if (fb.IsStatic)
     {
         il.Emit(OpCodes.Stsfld, fb);
     }
     else
     {
         il.Emit(OpCodes.Stfld, fb);
     }
     il.MarkLabel(lab);
 }
Esempio n. 22
0
        //Перевод заголовка типа
        private void ConvertTypeHeader(ICommonTypeNode value)
        {
            //(ssyy) Обрабатываем инстанции generic-типов
            //FillGetterMethodsTable(value);
            IGenericTypeInstance igtn = value as IGenericTypeInstance;
            if (igtn != null)
            {
                //Формируем список типов-параметров 
                List<Type> iparams = new List<Type>();
                foreach (ITypeNode itn in igtn.generic_parameters)
                {
                    TypeInfo tinfo = helper.GetTypeReference(itn);
                    if (tinfo == null)
                    {
                        AddTypeInstanceToFunction(GetGenericFunctionContainer(value), igtn);
                        return;
                    }
                    iparams.Add(tinfo.tp);
                }
                //Запрашиваем инстанцию
                //ICompiledTypeNode icompiled_type = igtn.original_generic as ICompiledTypeNode;
                Type orig_type = helper.GetTypeReference(igtn.original_generic).tp;
                Type rez = orig_type.MakeGenericType(iparams.ToArray());
                //Добавляем в хэш
                TypeInfo inst_ti = helper.AddExistingType(igtn, rez);
                TypeInfo generic_def_ti = helper.GetTypeReference(igtn.original_generic);
                if (generic_def_ti.init_meth != null)
                    inst_ti.init_meth = TypeBuilder.GetMethod(rez, generic_def_ti.init_meth);
                if (generic_def_ti.clone_meth != null)
                    inst_ti.clone_meth = TypeBuilder.GetMethod(rez, generic_def_ti.clone_meth);
                if (generic_def_ti.assign_meth != null)
                    inst_ti.assign_meth = TypeBuilder.GetMethod(rez, generic_def_ti.assign_meth);
                return;
            }
            if (comp_opt.target == TargetType.Dll)
                AddPropertyAccessors(value);
            Type[] interfaces = new Type[value.ImplementingInterfaces.Count];
            for (int i = 0; i < interfaces.Length; i++)
            {
                TypeInfo ii_ti = helper.GetTypeReference(value.ImplementingInterfaces[i]);
                interfaces[i] = ii_ti.tp;
            }

            //определяем тип
            TypeInfo ti = helper.GetTypeReference(value);
            bool not_exist = ti == null;
            TypeBuilder tb = null;
            GenericTypeParameterBuilder gtpb = null;
            if (!not_exist)
            {
                tb = ti.tp as TypeBuilder;
                gtpb = ti.tp as GenericTypeParameterBuilder;
            }

            TypeAttributes ta = (not_exist) ? ConvertAttributes(value) : TypeAttributes.NotPublic;

            if (value.base_type is ICompiledTypeNode && (value.base_type as ICompiledTypeNode).compiled_type == TypeFactory.EnumType)
            {
                ta = TypeAttributes.Public;
                if (value.type_access_level == type_access_level.tal_internal)
                    ta = TypeAttributes.NotPublic;
                EnumBuilder emb = mb.DefineEnum(cur_unit + "." + value.name, ta, TypeFactory.Int32Type);
                //int num = 0;
                foreach (IClassConstantDefinitionNode ccfn in value.constants)
                {
                    emb.DefineLiteral(ccfn.name, (ccfn.constant_value as IEnumConstNode).constant_value);
                }
                AddEnumToCloseList(emb);
                helper.AddEnum(value, emb);
                return;
            }
            else
            {
                if (not_exist)
                {
                    tb = mb.DefineType(cur_unit + "." + value.name, ta, null, interfaces);
                }
                else
                {
                    if (gtpb == null)
                    {
                        foreach (Type interf in interfaces)
                        {
                            tb.AddInterfaceImplementation(interf);
                        }
                    }
                    else
                    {
                        gtpb.SetInterfaceConstraints(interfaces);
                        GenericParameterAttributes gpa = GenericParameterAttributes.None;
                        if (value.is_value_type)
                            gpa |= GenericParameterAttributes.NotNullableValueTypeConstraint;
                        if (value.is_class)
                            gpa |= GenericParameterAttributes.ReferenceTypeConstraint;
                        if (value.methods.Length > 0)
                            gpa |= GenericParameterAttributes.DefaultConstructorConstraint;
                        gtpb.SetGenericParameterAttributes(gpa);
                    }
                }
            }
            //добавлям его во внутр. структуры
            if (not_exist)
            {
                ti = helper.AddType(value, tb);
            }
            //if (value.fields.Length == 1 && value.fields[0].type is ISimpleArrayNode)
            if (value.type_special_kind == type_special_kind.array_wrapper)
            {
                ti.is_arr = true;
            }
            if (value.base_type != null && !value.IsInterface)
            {
                Type base_type = helper.GetTypeReference(value.base_type).tp;
                if (gtpb == null)
                {
                    tb.SetParent(base_type);
                }
                else
                {
                    if (base_type != TypeFactory.ObjectType)
                        gtpb.SetBaseTypeConstraint(base_type);
                }
            }
            if (!value.is_generic_parameter)
            {
                AddTypeToCloseList(tb);//добавляем его в список закрытия
                if (!value.IsInterface && value.type_special_kind != type_special_kind.array_wrapper)
                    AddInitMembers(ti, tb, value);
            }
            //если это обертка над массивом, сразу переводим реализацию
            //if (value.fields.Length == 1 && value.fields[0].type is ISimpleArrayNode) ConvertArrayWrapperType(value);
        }
Esempio n. 23
0
        //Переводит аттрибуты типа в аттрибуты .NET
        private TypeAttributes ConvertAttributes(ICommonTypeNode value)
        {
            TypeAttributes ta = TypeAttributes.Public;
            if (value.type_access_level == type_access_level.tal_internal)
                ta = TypeAttributes.NotPublic;
            //(ssyy) 27.10.2007 Прекратить бардак!  Я в третий раз устанавливаю здесь аттрибут Sealed!
            //Это надо, чтобы нельзя было наследовать от записей.
            //В следующий раз разработчику, снявшему аттрибут Sealed, указать причину, по которой это было сделано!
            if (value.is_value_type)
                ta |= TypeAttributes.SequentialLayout | TypeAttributes.BeforeFieldInit | TypeAttributes.Sealed;
            //TypeAttributes.Sealed нужно!

            if (value.IsSealed)
                ta |= TypeAttributes.Sealed;

            ICompiledTypeNode ictn = value.base_type as ICompiledTypeNode;
            if (ictn != null)
            {
                if (ictn.compiled_type == TypeFactory.MulticastDelegateType)
                {
                    ta |= TypeAttributes.Public | TypeAttributes.AutoClass | TypeAttributes.AnsiClass | TypeAttributes.Sealed;
                }
            }
            if (value.IsInterface)
            {
                ta |= TypeAttributes.Interface | TypeAttributes.Abstract | TypeAttributes.AnsiClass;
                //if (has_com_import_attr(value))
                //	ta |= TypeAttributes.Import;
            }
            if (value.IsAbstract)
            {
                ta |= TypeAttributes.Abstract;
            }
            return ta;
        }
Esempio n. 24
0
        private void AddInitMembers(TypeInfo ti, TypeBuilder tb, ICommonTypeNode ctn)
        {
            MethodBuilder init_mb = tb.DefineMethod("$Init$", MethodAttributes.Public, TypeFactory.VoidType, Type.EmptyTypes);
            ti.init_meth = init_mb;
            //определяем метод $Init$ для выделения памяти, если метод еще не определен (в структурах он опред-ся раньше)
            //MethodBuilder init_mb = ti.init_meth;
            //if (init_mb == null) init_mb = tb.DefineMethod("$Init$", MethodAttributes.Public, typeof(void), Type.EmptyTypes);
            ti.init_meth = init_mb;
            //определяем метод Clone и Assign
            if (tb.IsValueType)
            {
                MethodBuilder clone_mb = null;
                MethodBuilder ass_mb = null;
                if (NeedAddCloneMethods(ctn))
                {
                    clone_mb = tb.DefineMethod("$Clone$", MethodAttributes.Public, tb, Type.EmptyTypes);
                    LocalBuilder lb = clone_mb.GetILGenerator().DeclareLocal(tb);
                    MarkSequencePoint(clone_mb.GetILGenerator(), 0xFFFFFF, 0, 0xFFFFFF, 0);
                    clone_mb.GetILGenerator().Emit(OpCodes.Ldloca, lb);
                    clone_mb.GetILGenerator().Emit(OpCodes.Call, init_mb);
                    ti.clone_meth = clone_mb;

                    ass_mb = tb.DefineMethod("$Assign$", MethodAttributes.Public, TypeFactory.VoidType, new Type[1] { tb });
                    ass_mb.DefineParameter(1, ParameterAttributes.None, "$obj$");
                    ti.assign_meth = ass_mb;
                }
                MethodBuilder fix_mb = tb.DefineMethod("$Fix$", MethodAttributes.Public, TypeFactory.VoidType, Type.EmptyTypes);
                ti.fix_meth = fix_mb;
            }
        }
Esempio n. 25
0
        //определяем заголовки членов класса
        private void ConvertTypeMemberHeader(ICommonTypeNode value)
        {
            //если это оболочка над массивом переводим ее особым образом

            if (value.type_special_kind == type_special_kind.diap_type || value.type_special_kind == type_special_kind.array_kind) return;
            if (value.fields.Length == 1 && value.fields[0].type is ISimpleArrayNode)
            {
                ConvertArrayWrapperType(value);
                return;
            }
            if (value is ISimpleArrayNode) return;
            //этот тип уже был переведен, поэтому находим его
            TypeInfo ti = helper.GetTypeReference(value);

            //ivan
            if (ti.tp.IsEnum || !(ti.tp is TypeBuilder)) return;
            TypeBuilder tb = (TypeBuilder)ti.tp;
            if (tb.IsValueType) BuildCloseTypeOrder(value, tb);
            //сохраняем контекст
            TypeInfo tmp_ti = cur_ti;
            cur_ti = ti;
            TypeBuilder tmp = cur_type;
            cur_type = tb;

            //(ssyy) Если это интерфейс, то пропускаем следующую хрень
            if (!value.IsInterface)
            {
                //определяем метод $Init$ для выделения памяти, если метод еще не определен (в структурах он опред-ся раньше)
                MethodBuilder clone_mb = null;
                MethodBuilder ass_mb = null;
                if (ti.init_meth != null && tb.IsValueType)
                {
                    clone_mb = ti.clone_meth as MethodBuilder;
                    ass_mb = ti.assign_meth as MethodBuilder;
                }
                foreach (ICommonClassFieldNode fld in value.fields)
                    fld.visit(this);

                foreach (ICommonMethodNode meth in value.methods)
                    ConvertMethodHeader(meth);
                foreach (ICommonPropertyNode prop in value.properties)
                    prop.visit(this);

                foreach (IClassConstantDefinitionNode constant in value.constants)
                    constant.visit(this);

                foreach (ICommonEventNode evnt in value.events)
                    evnt.visit(this);

                //(ssyy) 21.05.2008
                foreach (ICommonMethodNode meth in value.methods)
                {
                    if (meth.is_generic_function)
                    {
                        ConvertTypeInstancesMembersInFunction(meth);
                    }
                }
                //добавляем ритерны в специальные методы
                //ti.init_meth.GetILGenerator().Emit(OpCodes.Ret);
                //if (hndl_mb != null) hndl_mb.GetILGenerator().Emit(OpCodes.Ret);
                if (clone_mb != null)
                {
                    clone_mb.GetILGenerator().Emit(OpCodes.Ldloc_0);
                    clone_mb.GetILGenerator().Emit(OpCodes.Ret);
                }
                if (ass_mb != null)
                {
                    ass_mb.GetILGenerator().Emit(OpCodes.Ret);
                }
                if (ti.fix_meth != null)
                {
                    ti.fix_meth.GetILGenerator().Emit(OpCodes.Ret);
                }
            }
            else
            {
                //(ssyy) сейчас переводим интерфейс

                foreach (ICommonMethodNode meth in value.methods)
                    ConvertMethodHeader(meth);
                foreach (ICommonPropertyNode prop in value.properties)
                    prop.visit(this);
                foreach (ICommonEventNode evnt in value.events)
                    evnt.visit(this);
                //(ssyy) 21.05.2008
                foreach (ICommonMethodNode meth in value.methods)
                {
                    if (meth.is_generic_function)
                    {
                        ConvertTypeInstancesMembersInFunction(meth);
                    }
                }

            }

            if (value.default_property != null)
            {
                using (BinaryWriter bw = new BinaryWriter(new MemoryStream()))
                {
                    bw.Write(value.default_property.name);
                    bw.Seek(0, SeekOrigin.Begin);
                    byte[] bytes = new byte[2 + value.default_property.name.Length + 1 + 2];
                    bytes[0] = 1;
                    bytes[1] = 0;
                    bw.BaseStream.Read(bytes, 2, value.default_property.name.Length + 1);
                    tb.SetCustomAttribute(TypeFactory.DefaultMemberAttributeType.GetConstructor(new Type[1] { TypeFactory.StringType }), bytes);
                }
            }
            //восстанавливаем контекст
            cur_type = tmp;
            cur_ti = tmp_ti;
        }
Esempio n. 26
0
 public void SetAsProcessing(ICommonTypeNode type)
 {
     processing_types[type] = true;
 }
Esempio n. 27
0
		public static bool can_write(ICommonTypeNode t)
		{
			return !(string.IsNullOrEmpty(t.Documentation) && !builder.options.ShowNoCommentedElements || t.name.Contains("$")
			         || is_pascal_type(t) || user_doc_disabled(t.Documentation));
		}
Esempio n. 28
0
		private static string get_delegate(ICommonTypeNode t, bool use_tags)
		{
			ICommonMethodNode f = builder.parser.GetMethods(t,"Invoke")[0];
			StringBuilder sb = new StringBuilder();
			if (f.return_value_type == null)
				sb.Append(use_tags?get_span_for_keyword("procedure"):"procedure");
			else
				sb.Append(use_tags?get_span_for_keyword("function"):"function");
            if (f.parameters.Length > 0)
            {
                sb.Append('(');
                for (int i = 0; i < f.parameters.Length; i++)
                {
                    IParameterNode prm = f.parameters[i];
                    if (prm.parameter_type == parameter_type.var)
                        sb.Append((use_tags ? get_span_for_keyword("var") : "var") + " ");
                    else if (prm.is_params)
                        sb.Append((use_tags ? get_span_for_keyword("params") : "params") + " ");
                    if (use_tags)
                        sb.Append(get_span_for_param(prm.name));
                    else
                        sb.Append(prm.name);
                    sb.Append(" : ");
                    if (use_tags)
                        sb.Append(get_type_html_text(prm.type));
                    else
                        sb.Append(get_type_text(prm.type));
                    if (i < f.parameters.Length - 1)
                        sb.Append("; ");
                }
                sb.Append(')');
            }
			
			if (f.return_value_type != null && !f.is_constructor)
				sb.Append(": "+(use_tags?get_type_html_text(f.return_value_type):get_type_text(f.return_value_type)));
			return sb.ToString();
		}
Esempio n. 29
0
		public static string get_type_header(ICommonTypeNode t)
		{
			StringBuilder sb = new StringBuilder();
			string hdr = HelpUtils.extract_user_defined_header(t.Documentation);
			if (!string.IsNullOrEmpty(hdr))
			{
				sb.Append("<div>"+hdr+"</div>");
				return sb.ToString();
			}
			sb.Append("<div>");
			sb.Append(get_span_for_keyword("type")+" "+get_span_for_identifier(HelpUtils.build_name_with_possible_generic(t,true))+" = ");
			if (t.type_special_kind == type_special_kind.set_type)
				sb.Append(get_set_type(t,true));
			else
			if (t.type_special_kind == type_special_kind.typed_file)
				sb.Append(get_typed_file(t,true));
			else
			if (t.type_special_kind == type_special_kind.binary_file)
				sb.Append(get_span_for_keyword("file"));
			else
			if (t.type_special_kind == type_special_kind.diap_type)
				sb.Append(get_diap_type(t,true));
			else if (t.type_special_kind == type_special_kind.array_wrapper)
				sb.Append(get_static_array_type(t,true));
			else
			if (t.IsInterface)
				sb.Append(get_span_for_keyword("interface"));
			else if (t.is_class)
			{
				sb.Append(get_span_for_keyword("class"));
				sb.Append(get_inherited_and_implement(t));
			}
			else if (t.IsEnum)
				sb.Append(get_enum(t,true));
			else if (t.IsDelegate)
				sb.Append(get_delegate(t,true));
			else if (t.is_value_type)
				sb.Append(get_span_for_keyword("record"));
			sb.Append("</div>");
			return sb.ToString();
		}
Esempio n. 30
0
 public void visit(ICommonTypeNode value)
 {             
     ISemanticNodeConverter.SourceTextBuilder.AddNodeInToStack(ISemanticNodeConverter.ConvertPABCNETNodeType("type", value));
 }
Esempio n. 31
0
		public virtual void visit(ICommonTypeNode value)
		{
		}
Esempio n. 32
0
        public void visit(ICommonTypeNode value)
        {
            string s = value.GetType().ToString() + ".";
            prepare_string_node(value.name, s + "name");           
            prepare_up_link_node(value.comprehensive_namespace.namespace_name.ToString(), s + "comprehensive_namespace", value.comprehensive_namespace);
            //table_for_up_links.Add(treeView.SelectedNode.Nodes[1] as myTreeNode, treeView.SelectedNode.Parent.Parent as myTreeNode);
            
            myTreeNode from = treeView.SelectedNode.Nodes[treeView.SelectedNode.Nodes.Count - 1] as myTreeNode;
            myTreeNode to = table_subnodes[value.comprehensive_namespace] as myTreeNode;
            table_for_up_links.Add(from, to);

            prepare_node(value.base_type, s + "base_type");
            prepare_base_node_collection(value.constants, s + "constants", "constants", value.constants.Length);
            prepare_node(value.default_property, s + "default_property");
            prepare_node(value.element_type, s + "element_type");
            prepare_base_node_collection(value.fields, s + "fields", "fields", value.fields.Length);
            //prepare_node(value.generic_container, s + "generic_container");
            //value.generic_params;
            prepare_string_node(value.has_static_constructor.ToString(), s + "has_static_constructor");
            prepare_base_node_collection_up_links(value.ImplementingInterfaces, s + "ImplementingInterfaces", "ImplementingInterfaces", value.ImplementingInterfaces.Count);            
            prepare_string_node(value.is_class.ToString(), s + "is_class");
            prepare_string_node(value.is_generic_parameter.ToString(), s + "is_generic_parameter");
            prepare_string_node(value.is_generic_type_definition.ToString(), s + "is_generic_type_definition");
            prepare_string_node(value.is_value_type.ToString(), s + "is_value_type");
            prepare_string_node(value.IsInterface.ToString(), s + "IsInterface");
            prepare_string_node(value.IsSealed.ToString(), s + "IsSealed");
            prepare_node(value.lower_value, s + "lower_value");
            prepare_base_node_collection(value.methods, s + "methods", "methods", value.methods.Length);
            prepare_string_node(value.node_kind.ToString(), s + "node_kind");
            prepare_base_node_collection(value.properties, s + "properties", "properties", value.properties.Length);
            //prepare_node(value.runtime_initialization_marker, s + "runtime_initialization_marker");
            prepare_string_node(value.type_access_level.ToString(), s + "type_access_level");
            prepare_string_node(value.type_special_kind.ToString(), s + "type_special_kind");
            prepare_node(value.upper_value, s + "upper_value");
        }
Esempio n. 33
0
        private void MakeAttribute(ICommonTypeNode ctn)
        {
            Type t = helper.GetTypeReference(ctn).tp;
            IAttributeNode[] attrs = ctn.Attributes;
            for (int i = 0; i < attrs.Length; i++)
            {
                //if (attrs[i].AttributeType == SystemLibrary.SystemLibrary.comimport_type)
                //	continue;

                CustomAttributeBuilder cab = new CustomAttributeBuilder
                    ((attrs[i].AttributeConstructor is ICompiledConstructorNode) ? (attrs[i].AttributeConstructor as ICompiledConstructorNode).constructor_info : helper.GetConstructor(attrs[i].AttributeConstructor).cnstr, get_constants(attrs[i].Arguments),
                    get_named_properties(attrs[i].PropertyNames), get_constants(attrs[i].PropertyInitializers),
                    get_named_fields(attrs[i].FieldNames), get_constants(attrs[i].FieldInitializers));
                if (t is TypeBuilder)
                    (t as TypeBuilder).SetCustomAttribute(cab);
                else if (t is EnumBuilder)
                    (t as EnumBuilder).SetCustomAttribute(cab);
            }
        }
Esempio n. 34
0
		public static bool can_show_members(ICommonTypeNode t)
		{
			switch (t.type_special_kind)
			{
				case type_special_kind.array_wrapper:
				case type_special_kind.set_type:
				case type_special_kind.typed_file:
				case type_special_kind.text_file:
				case type_special_kind.binary_file:
				case type_special_kind.diap_type:
				return false;
			}
			if (t.IsDelegate /*|| t.IsEnum*/)
				return false;
			return true;
		}
Esempio n. 35
0
 private bool NeedAddCloneMethods(ICommonTypeNode ctn)
 {
     foreach (ICommonClassFieldNode cfn in ctn.fields)
     {
         if (cfn.polymorphic_state != polymorphic_state.ps_static &&
             (cfn.type.type_special_kind == type_special_kind.array_wrapper ||
             cfn.type.type_special_kind == type_special_kind.base_set_type ||
             cfn.type.type_special_kind == type_special_kind.short_string ||
             cfn.type.type_special_kind == type_special_kind.text_file ||
             cfn.type.type_special_kind == type_special_kind.typed_file ||
             cfn.type.type_special_kind == type_special_kind.binary_file ||
             cfn.type.type_special_kind == type_special_kind.set_type))
             return true;
         if (cfn.type.type_special_kind == type_special_kind.record && cfn.type is ICommonTypeNode)
             if (NeedAddCloneMethods(cfn.type as ICommonTypeNode))
                 return true;
     }
     return false;
 }
Esempio n. 36
0
 private Type CreateTypedSetType(ICommonTypeNode t)
 {
     Type tt = helper.GetPascalTypeReference(t);
     if (tt != null) return tt;
     TypeBuilder tb = mb.DefineType(cur_unit + ".%" + t.name, TypeAttributes.Public, TypeFactory.ObjectType);
     types.Add(tb);
     helper.AddPascalTypeReference(t, tb);
     add_possible_type_attribute(tb, t);
     return tb;
 }
Esempio n. 37
0
 private bool has_com_import_attr(ICommonTypeNode value)
 {
     IAttributeNode[] attrs = value.Attributes;
     foreach (IAttributeNode attr in attrs)
         if (attr.AttributeType == SystemLibrary.SystemLibrary.comimport_type)
             return true;
     return false;
 }
Esempio n. 38
0
        //переводим заголовки типов в порядке начиная с базовых классов (т. е. у которых наследники - откомпилированные типы)
        private void ConvertTypeHeaderInSpecialOrder(ICommonTypeNode t)
        {
            if (t.type_special_kind == type_special_kind.diap_type) return;
            if (t.type_special_kind == type_special_kind.array_kind) return;
            if (t.depended_from_indefinite) return;
            if (t.type_special_kind == type_special_kind.typed_file && comp_opt.target == TargetType.Dll)
            {
                if (!t.name.Contains(" "))
                {
                    CreateTypedFileType(t);
                    return;
                }
            }
            else
                if (t.type_special_kind == type_special_kind.set_type && comp_opt.target == TargetType.Dll)
                {
                    if (!t.name.Contains(" "))
                    {
                        CreateTypedSetType(t);
                        return;
                    }
                }

            if (helper.GetTypeReference(t) != null && !t.is_generic_parameter) return;

            if (t.is_generic_parameter)
            {
                //ConvertTypeHeaderInSpecialOrder(t.generic_container);
                AddTypeWithoutConvert(t);
                if (converting_generic_param != t)
                {
                    return;
                }
                converting_generic_param = null;
            }
            IGenericTypeInstance gti = t as IGenericTypeInstance;
            if (gti != null)
            {
                if (gti.original_generic is ICommonTypeNode)
                {
                    ConvertTypeHeaderInSpecialOrder((ICommonTypeNode)gti.original_generic);
                }
                foreach (ITypeNode itn in gti.generic_parameters)
                {
                    if (itn is ICommonTypeNode && !itn.is_generic_parameter)
                    {
                        ConvertTypeHeaderInSpecialOrder((ICommonTypeNode)itn);
                    }
                }
            }
            if (t.is_generic_type_definition)
            {
                AddTypeWithoutConvert(t);
                foreach (ICommonTypeNode par in t.generic_params)
                {
                    converting_generic_param = par;
                    ConvertTypeHeaderInSpecialOrder(par);
                }
            }
            else if ((t.type_special_kind == type_special_kind.none_kind ||
                t.type_special_kind == type_special_kind.record) && !t.IsEnum &&
                !t.is_generic_type_instance && !t.is_generic_parameter)
            {
                AddTypeWithoutConvert(t);
            }
            foreach (ITypeNode interf in t.ImplementingInterfaces)
                if (!(interf is ICompiledTypeNode))
                    ConvertTypeHeaderInSpecialOrder((ICommonTypeNode)interf);
            if (t.base_type != null && !(t.base_type is ICompiledTypeNode))
            {
                ConvertTypeHeaderInSpecialOrder((ICommonTypeNode)t.base_type);
            }
            ConvertTypeHeader(t);
        }
Esempio n. 39
0
 private void AddPropertyAccessors(ICommonTypeNode ctn)
 {
     ICommonPropertyNode[] props = ctn.properties;
     foreach (ICommonPropertyNode prop in props)
     {
         if (prop.get_function != null && !prop_accessors.ContainsKey(prop.get_function))
             prop_accessors.Add(prop.get_function, prop.get_function);
         if (prop.set_function != null && !prop_accessors.ContainsKey(prop.set_function))
             prop_accessors.Add(prop.set_function, prop.set_function);
     }
     ICommonMethodNode[] meths = ctn.methods;
     foreach (ICommonMethodNode meth in meths)
     {
         if (meth.overrided_method != null && !prop_accessors.ContainsKey(meth) && prop_accessors.ContainsKey(meth.overrided_method))
             prop_accessors.Add(meth, meth);
     }
 }
Esempio n. 40
0
 private void AddTypeWithoutConvert(ICommonTypeNode t)
 {
     if (helper.GetTypeReference(t) != null) return;
     TypeBuilder tb = mb.DefineType(cur_unit + "." + t.name, ConvertAttributes(t), null, new Type[0]);
     helper.AddType(t, tb);
     //(ssyy) обрабатываем generics
     if (t.is_generic_type_definition)
     {
         int count = t.generic_params.Count;
         string[] par_names = new string[count];
         //Создаём массив имён параметров
         for (int i = 0; i < count; i++)
         {
             par_names[i] = t.generic_params[i].name;
         }
         //Определяем параметры в строящемся типе
         GenericTypeParameterBuilder[] net_pars = tb.DefineGenericParameters(par_names);
         for (int i = 0; i < count; i++)
         {
             //добавляем параметр во внутр. структуры
             helper.AddExistingType(t.generic_params[i], net_pars[i]);
         }
     }
 }
Esempio n. 41
0
        //перевод заголовка функции
        private void ConvertFunctionHeader(ICommonFunctionNode func)
        {
            //if (is_in_unit && helper.IsUsed(func)==false) return;
            num_scope++; //увеличиваем глубину обл. видимости
            TypeBuilder tb = null, tmp_type = cur_type;
            Frame frm = null;
            bool nested = false;

            //func.functions_nodes.Length > 0 - имеет вложенные
            //funcs.Count > 0 - сама вложенная
            if (func.functions_nodes.Length > 0 || funcs.Count > 0)
            {
                nested = true;
                frm = MakeAuxType(func);//создаем запись активации
                tb = frm.tb;
                cur_type = tb;
            }
            else tb = cur_type;
            MethodAttributes attrs = MethodAttributes.Public | MethodAttributes.Static;
            //определяем саму процедуру/функцию
            MethodBuilder methb = null;
            methb = tb.DefineMethod(func.name, attrs);

            if (func.is_generic_function)
            {
                int count = func.generic_params.Count;
                string[] names = new string[count];
                for (int i = 0; i < count; i++)
                {
                    names[i] = func.generic_params[i].name;
                }
                methb.DefineGenericParameters(names);
                Type[] genargs = methb.GetGenericArguments();
                for (int i = 0; i < count; i++)
                {
                    helper.AddExistingType(func.generic_params[i], genargs[i]);
                }
                foreach (ICommonTypeNode par in func.generic_params)
                {
                    converting_generic_param = par;
                    ConvertTypeHeaderInSpecialOrder(par);
                }
                ConvertTypeInstancesInFunction(func);
            }

            Type ret_type = null;
            //получаем тип возвр. значения
            if (func.return_value_type == null)
                ret_type = TypeFactory.VoidType;
            else
                ret_type = helper.GetTypeReference(func.return_value_type).tp;
            //получаем типы параметров
            Type[] param_types = GetParamTypes(func);

            methb.SetParameters(param_types);
            methb.SetReturnType(ret_type);

            MethInfo mi = null;
            if (smi.Count != 0)
                //добавляем вложенную процедуру, привязывая ее к верхней процедуре
                mi = helper.AddMethod(func, methb, smi.Peek());
            else
                mi = helper.AddMethod(func, methb);
            mi.num_scope = num_scope;
            mi.disp = frm;//тип - запись активации
            smi.Push(mi);
            ParameterBuilder pb = null;
            int num = 0;
            ILGenerator tmp_il = il;
            il = methb.GetILGenerator();

            if (save_debug_info)
            {
                if (func.function_code is IStatementsListNode)
                    MarkSequencePoint(((IStatementsListNode)func.function_code).LeftLogicalBracketLocation);
                else
                    MarkSequencePoint(func.function_code.Location);
            }

            //if (ret_type != typeof(void)) mi.ret_val = il.DeclareLocal(ret_type);
            //если функция вложенная, то добавляем фиктивный параметр
            //ссылку на верхнюю запись активации
            if (funcs.Count > 0)
            {
                mi.nested = true;//это вложенная процедура
                methb.DefineParameter(1, ParameterAttributes.None, "$up$");
                num = 1;
            }
            //все нелокальные параметры будем хранить в нестатических полях
            //записи активации. В начале функции инициализируем эти поля
            //параметрами
            IParameterNode[] parameters = func.parameters;
            FieldBuilder[] fba = new FieldBuilder[parameters.Length];

            for (int i = 0; i < parameters.Length; i++)
            {
                object default_value = null;
                if (parameters[i].default_value != null)
                {
                    default_value = helper.GetConstantForExpression(parameters[i].default_value);
                }
                ParameterAttributes pa = ParameterAttributes.None;
                //if (func.parameters[i].parameter_type == parameter_type.var)
                //    pa = ParameterAttributes.Retval;
                if (default_value != null)
                    pa |= ParameterAttributes.Optional;
                pb = methb.DefineParameter(i + num + 1, pa, parameters[i].name);

                if (parameters[i].is_params)
                    pb.SetCustomAttribute(TypeFactory.ParamArrayAttributeConstructor, new byte[] { 0x1, 0x0, 0x0, 0x0 });
                if (default_value != null)
                    pb.SetConstant(default_value);
                if (func.functions_nodes.Length > 0)
                {
                    FieldBuilder fb = null;
                    //если параметр передается по значению, то все нормально
                    if (parameters[i].parameter_type == parameter_type.value)
                        fb = frm.tb.DefineField(parameters[i].name, param_types[i + num], FieldAttributes.Public);
                    else
                    {
                        //иначе параметр передается по ссылке
                        //тогда вместо типа параметра тип& используем тип*
                        //например System.Int32& - System.Int32* (unmanaged pointer)

                        //Type pt = param_types[i + num].Module.GetType(param_types[i + num].FullName.Substring(0, param_types[i + num].FullName.IndexOf('&')) + "*");
                        ////это означает, что тип определен в генерируемой сборке
                        //if (pt == null) mb.GetType(param_types[i + num].FullName.Substring(0, param_types[i + num].FullName.IndexOf('&')) + "*");
                        Type pt = param_types[i + num].GetElementType().MakePointerType();

                        //определяем поле для параметра
                        fb = frm.tb.DefineField(parameters[i].name, pt, FieldAttributes.Public);
                    }

                    //добавляем как глобальный параметр
                    helper.AddGlobalParameter(parameters[i], fb).meth = smi.Peek();
                    fba[i] = fb;
                }
                else
                {
                    //если проца не содержит вложенных, то все хорошо
                    helper.AddParameter(parameters[i], pb).meth = smi.Peek();
                }
            }

            if (func is ICommonNamespaceFunctionNode && (func as ICommonNamespaceFunctionNode).ConnectedToType != null)
            {
                if (!marked_with_extension_attribute.ContainsKey(cur_unit_type))
                {
                    cur_unit_type.SetCustomAttribute(TypeFactory.ExtensionAttributeType.GetConstructor(new Type[0]), new byte[0]);
                    marked_with_extension_attribute[cur_unit_type] = cur_unit_type;
                }
                methb.SetCustomAttribute(TypeFactory.ExtensionAttributeType.GetConstructor(new Type[0]), new byte[0]);
            }
            if (func.functions_nodes.Length > 0 || funcs.Count > 0)
            {
                //определяем переменную, хранящую ссылку на запись активации данной процедуры
                LocalBuilder frame = il.DeclareLocal(cur_type);
                mi.frame = frame;
                if (doc != null) frame.SetLocalSymInfo("$disp$");
                if (funcs.Count > 0)
                {
                    //если она вложенная, то конструктору зап. акт. передаем ссылку на верх. з. а.
                    il.Emit(OpCodes.Ldarg_0);
                    //создаем запись активации
                    il.Emit(OpCodes.Newobj, frm.cb);
                    il.Emit(OpCodes.Stloc, frame);
                }
                else
                {
                    //в противном случае просто создаем з. а.
                    il.Emit(OpCodes.Newobj, frm.cb);
                    il.Emit(OpCodes.Stloc_0, frame);
                }
                if (func.functions_nodes.Length > 0)
                    for (int j = 0; j < fba.Length; j++)
                    {
                        //сохраняем нелокальные параметры в полях
                        il.Emit(OpCodes.Ldloc_0);
                        parameters = func.parameters;
                        if (parameters[j].parameter_type == parameter_type.value)
                        {
                            if (funcs.Count > 0) il.Emit(OpCodes.Ldarg_S, (byte)(j + 1));
                            else il.Emit(OpCodes.Ldarg_S, (byte)j);
                        }
                        else
                        {
                            if (funcs.Count > 0) il.Emit(OpCodes.Ldarga_S, (byte)(j + 1));
                            else il.Emit(OpCodes.Ldarg_S, (byte)j);
                        }
                        il.Emit(OpCodes.Stfld, fba[j]);
                    }
            }
            funcs.Add(func); //здесь наверное дублирование
            MethodBuilder tmp = cur_meth;
            cur_meth = methb;
            ConvertCommonFunctionConstantDefinitions(func.constants);
            //если функция не содержит вложенных процедур, то
            //переводим переменные как локальные
            if (func.functions_nodes.Length > 0)
                ConvertNonLocalVariables(func.var_definition_nodes, frm.mb);
            /*if (func.functions_nodes.Length == 0)
                ConvertLocalVariables(func.var_definition_nodes);
            else
                //иначе как нелокальные
                ConvertNonLocalVariables(func.var_definition_nodes, frm.mb);*/
            //переводим заголовки вложенных функций
            ConvertNestedFunctionHeaders(func.functions_nodes);
            //переводим тела вложенных функций
            //foreach (ICommonNestedInFunctionFunctionNode f in func.functions_nodes)
            //	ConvertFunctionBody(f);
            if (frm != null)
                frm.mb.GetILGenerator().Emit(OpCodes.Ret);
            //восстанавливаем текущие значения
            cur_type = tmp_type;
            num_scope--;
            smi.Pop();
            funcs.RemoveAt(funcs.Count - 1);
        }
Esempio n. 42
0
 //перевод релизаций типов
 private void ConvertTypeImplementations(ICommonTypeNode[] types)
 {
     foreach (ICommonTypeNode t in types)
     //если это не особый тип переводим реализацию наверно здесь много лишнего нужно оставить ISimpleArrayNode
     {
         if (/*!(t.fields.Length == 1 && t.fields[0].type is ISimpleArrayNode) &&*/
             t.type_special_kind != type_special_kind.diap_type &&
             !t.depended_from_indefinite)
             t.visit(this);
     }
 }
Esempio n. 43
0
        //перевод заголовка метода
        private void ConvertMethodHeader(SemanticTree.ICommonMethodNode value)
        {
            if (value.is_constructor == true)
            {
                ConvertConstructorHeader(value);
                return;
            }

            if (helper.GetMethod(value) != null) return;

            MethodBuilder methb = null;
            bool is_prop_acc = IsPropertyAccessor(value);
            MethodAttributes attrs = GetMethodAttributes(value, is_prop_acc);

            IRuntimeManagedMethodBody irmmb = value.function_code as IRuntimeManagedMethodBody;
            if (irmmb != null)
            {
                if ((irmmb.runtime_statement_type == SemanticTree.runtime_statement_type.invoke_delegate) ||
                    (irmmb.runtime_statement_type == SemanticTree.runtime_statement_type.begin_invoke_delegate) ||
                    (irmmb.runtime_statement_type == SemanticTree.runtime_statement_type.end_invoke_delegate))
                {
                    attrs = MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.NewSlot |
                        MethodAttributes.Virtual;
                }
            }

            //определяем метод
            string method_name = OperatorsNameConvertor.convert_name(value.name);

            if (method_name != null)
            {
                attrs |= MethodAttributes.SpecialName;
            }
            else
            {
                bool get_set = false;
                method_name = GetPossibleAccessorName(value, out get_set);
                if (get_set)
                {
                    attrs |= MethodAttributes.SpecialName;
                }
                /*if (is_get_set)
                {
                    attrs |= MethodAttributes.SpecialName;
                    method_name = cur_prop_name;
                }*/
            }

            //ssyy
            if (value.comperehensive_type.IsInterface)
            {
                attrs |= MethodAttributes.Virtual | MethodAttributes.Abstract | MethodAttributes.NewSlot;
            }

            if (value.is_final)
            {
                attrs |= MethodAttributes.Virtual | MethodAttributes.Final;
            }

            if (value.newslot_awaited)
            {
                attrs |= MethodAttributes.NewSlot;
            }
            //\ssyy

            //methb = cur_type.DefineMethod(method_name, attrs, ret_type, param_types);
            methb = cur_type.DefineMethod(method_name, attrs);

            if (value.is_generic_function)
            {
                int count = value.generic_params.Count;
                string[] names = new string[count];
                for (int i = 0; i < count; i++)
                {
                    names[i] = value.generic_params[i].name;
                }
                methb.DefineGenericParameters(names);
                Type[] genargs = methb.GetGenericArguments();
                for (int i = 0; i < count; i++)
                {
                    helper.AddExistingType(value.generic_params[i], genargs[i]);
                }
                foreach (ICommonTypeNode par in value.generic_params)
                {
                    converting_generic_param = par;
                    ConvertTypeHeaderInSpecialOrder(par);
                }
                ConvertTypeInstancesInFunction(value);
            }

            Type ret_type = null;
            bool is_ptr_ret_type = false;
            if (value.return_value_type == null)
                ret_type = TypeFactory.VoidType;
            else
            {
                ret_type = helper.GetTypeReference(value.return_value_type).tp;
                if (IsNeedCorrectGetType(cur_ti, ret_type))
                {
                    ret_type = ret_type.MakePointerType();
                    is_ptr_ret_type = true;
                }
            }
            Type[] param_types = GetParamTypes(value);

            methb.SetParameters(param_types);
            methb.SetReturnType(ret_type);

            if (irmmb != null)
            {
                //if ((irmmb.runtime_statement_type == SemanticTree.runtime_statement_type.invoke_delegate) ||
                //    (irmmb.runtime_statement_type == SemanticTree.runtime_statement_type.begin_invoke_delegate) ||
                //    (irmmb.runtime_statement_type == SemanticTree.runtime_statement_type.end_invoke_delegate))
                //{
                methb.SetImplementationFlags(MethodImplAttributes.Runtime);
                //}
            }

            if (save_debug_info)
            {
                if (value.function_code is IStatementsListNode)
                    MarkSequencePoint(methb.GetILGenerator(), ((IStatementsListNode)value.function_code).LeftLogicalBracketLocation);
                //else
                // MarkSequencePoint(methb.GetILGenerator(),value.function_code.Location);
            }
            //TestForHandler(value, param_types, methb);
            MethInfo mi = null;
            mi = helper.AddMethod(value, methb);
            //binding CloneSet to set type
            if (value.comperehensive_type.type_special_kind == type_special_kind.base_set_type && value.name == "GetEnumerator")
            {
                helper.GetTypeReference(value.comperehensive_type).enumerator_meth = methb;
                //helper.GetTypeReference(value.comprehensive_type).assign_meth = methb;
            }
            mi.is_ptr_ret_type = is_ptr_ret_type;
            mi.num_scope = num_scope + 1;
            ConvertMethodParameters(value, methb);
        }
Esempio n. 44
0
 private void ConvertTypeMemberHeaderAndRemoveFromList(ICommonTypeNode type, List<ICommonTypeNode> types)
 {
     if (!type.depended_from_indefinite)
     {
         if (type.type_special_kind == type_special_kind.array_wrapper &&
             type.element_type.type_special_kind == type_special_kind.array_wrapper &&
             type.element_type is ICommonTypeNode &&
             types.IndexOf((ICommonTypeNode)(type.element_type)) > -1)
         {
             ConvertTypeMemberHeaderAndRemoveFromList((ICommonTypeNode)(type.element_type), types);
         }
         ConvertTypeMemberHeader(type);
     }
     types.Remove(type);
 }
Esempio n. 45
0
 private IFunctionNode find_constructor(ICommonTypeNode tn)
 {
 	foreach (ICommonMethodNode cmn in tn.methods)
 	{
 		if (cmn.is_constructor) return cmn;
 	}
 	return null;
 }
Esempio n. 46
0
 //перевод заголовков членов класса
 private void ConvertTypeMemberHeaders(ICommonTypeNode[] types)
 {
     //(ssyy) Переупорядочиваем, чтобы массивы создавались в правильном порядке
     List<ICommonTypeNode> ts = new List<ICommonTypeNode>(types);
     while (ts.Count > 0)
     {
         ConvertTypeMemberHeaderAndRemoveFromList(ts[0], ts);
     }
     //foreach (ICommonTypeNode t in types)
     //    ConvertTypeMemberHeader(t);
 }
 public virtual void visit(ICommonTypeNode value)
 {
 }
Esempio n. 48
0
 private void BuildCloseTypeOrder(ICommonTypeNode value, TypeBuilder tb)
 {
     foreach (ICommonClassFieldNode fld in value.fields)
     {
         ITypeNode ctn = fld.type;
         TypeInfo ti = helper.GetTypeReference(ctn);
         if (ctn is ICommonTypeNode && ti.tp.IsValueType && ti.tp is TypeBuilder)
         {
             BuildCloseTypeOrder((ICommonTypeNode)ctn, (TypeBuilder)ti.tp);
         }
     }
     if (!added_types.ContainsKey(tb))
     {
         value_types.Add(tb);
         added_types[tb] = tb;
     }
 }
Esempio n. 49
0
 public bool IsProcessing(ICommonTypeNode type)
 {
     return(processing_types[type] != null);
 }
Esempio n. 50
0
 //перевод заголовков типов
 private void ConvertTypeHeaders(ICommonTypeNode[] types)
 {
     foreach (ICommonTypeNode t in types)
     {
         ConvertTypeHeaderInSpecialOrder(t);
     }
 }