administrator/pascalabcnet
1
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity

TypeFactory refactoring (#3347)

Browse source
This commit is contained in:
samuraiGH 2025-10-11 22:36:05 +03:00 committed by GitHub
parent 3aa75eb9d6
commit 48c7fe344b
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
3 changed files with 180 additions and 116 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
NETGenerator/Helpers.cs
View file

@ -995,7 +995,7 @@ namespace PascalABCCompiler.NETGenerator {
case type_special_kind.diap_type: case type_special_kind.diap_type:
return GetTypeReference(type.base_type); return GetTypeReference(type.base_type);
case type_special_kind.short_string: case type_special_kind.short_string:
return TypeFactory.string_type; return new TypeInfo(TypeFactory.StringType);
case type_special_kind.array_kind: case type_special_kind.array_kind:
TypeInfo tmp = GetTypeReference(type.element_type); TypeInfo tmp = GetTypeReference(type.element_type);
if (tmp == null) return null; if (tmp == null) return null;

141
NETGenerator/NETGenegratorTools.cs
View file

@ -2,29 +2,29 @@
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt) // This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Reflection.Emit;
using System.Reflection; using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
namespace PascalABCCompiler.NETGenerator namespace PascalABCCompiler.NETGenerator
{ {
public class TypeFactory public class TypeFactory
{ {
public static TypeInfo int_type; public static Type AttributeType = typeof(Attribute);
public static TypeInfo double_type; public static Type DefaultMemberAttributeType = typeof(DefaultMemberAttribute);
public static TypeInfo bool_type; public static Type ConditionalAttributeType = typeof(System.Diagnostics.ConditionalAttribute);
public static TypeInfo char_type;
public static TypeInfo string_type;
public static TypeInfo byte_type;
public static Type ExceptionType = typeof(Exception); public static Type ExceptionType = typeof(Exception);
public static Type VoidType = typeof(void); public static Type VoidType = typeof(void);
public static Type StringType = typeof(string); public static Type StringType = typeof(string);
public static Type ObjectType = typeof(object); public static Type ObjectType = typeof(object);
public static Type MonitorType = typeof(System.Threading.Monitor); public static Type MonitorType = typeof(System.Threading.Monitor);
public static Type IntPtr = typeof(System.IntPtr); public static Type IntPtrType = typeof(System.IntPtr);
public static Type UIntPtrType = typeof(UIntPtr);
public static Type ArrayType = typeof(System.Array); public static Type ArrayType = typeof(System.Array);
public static Type MulticastDelegateType = typeof(MulticastDelegate); public static Type MulticastDelegateType = typeof(MulticastDelegate);
public static Type DefaultMemberAttributeType = typeof(DefaultMemberAttribute);
public static Type EnumType = typeof(Enum); public static Type EnumType = typeof(Enum);
public static Type ExtensionAttributeType = typeof(System.Runtime.CompilerServices.ExtensionAttribute); public static Type ExtensionAttributeType = typeof(System.Runtime.CompilerServices.ExtensionAttribute);
public static Type ConvertType = typeof(Convert); public static Type ConvertType = typeof(Convert);
@ -54,37 +54,63 @@ namespace PascalABCCompiler.NETGenerator
private static HashSet<Type> types; private static HashSet<Type> types;
private static Dictionary<Type, int> sizes; private static Dictionary<Type, int> sizes;
public static MethodInfo ArrayCopyMethod; public static MethodInfo ArrayCopyMethod;
public static MethodInfo ArrayLengthGetMethod;
public static MethodInfo GetTypeFromHandleMethod; public static MethodInfo GetTypeFromHandleMethod;
public static MethodInfo ResizeMethod; public static MethodInfo ResizeMethod;
public static MethodInfo GCHandleFreeMethod; public static MethodInfo GCHandleFreeMethod;
public static MethodInfo StringNullOrEmptyMethod; public static MethodInfo StringNullOrEmptyMethod;
public static MethodInfo UnsizedArrayCreateMethodTemplate = null; public static MethodInfo StringCopyMethod;
public static MethodInfo GCHandleAlloc; public static MethodInfo GCHandleAlloc;
public static MethodInfo GCHandleAllocPinned; public static MethodInfo GCHandleAllocPinned;
public static MethodInfo OffsetToStringDataProperty; public static MethodInfo OffsetToStringDataProperty;
public static MethodInfo StringLengthMethod; public static MethodInfo StringLengthMethod;
public static MethodInfo CharToString; public static MethodInfo CharToString;
public static ConstructorInfo IndexOutOfRangeConstructor; public static MethodInfo MathMinMethod;
public static ConstructorInfo ParamArrayAttributeConstructor; public static MethodInfo MarshalAllocHGlobalMethod;
public static MethodInfo StringCopyMethod; public static MethodInfo MarshalFreeHGlobalMethod;
public static MethodInfo MarshalCopyMethod;
public static MethodInfo MarshalSizeOfMethod;
public static MethodInfo NullableHasValueGetMethod;
public static MethodInfo NullableGetValueOrDefaultMethod;
public static MethodInfo EnvironmentIs64BitProcessGetMethod;
public static MethodInfo ActivatorCreateInstanceMethod;
public static MethodInfo IEnumerableGenericGetEnumeratorMethod;
public static MethodInfo IEnumerableGetEnumeratorMethod;
public static MethodInfo IEnumeratorMoveNextMethod;
public static MethodInfo MonitorEnterMethod;
public static MethodInfo MonitorExitMethod;
public static MethodInfo ConvertToByteMethod;
public static MethodInfo ConvertToSByteMethod;
public static MethodInfo ConvertToInt16Method;
public static MethodInfo ConvertToUInt16Method;
public static MethodInfo ConvertToInt32Method;
public static MethodInfo ConvertToUInt32Method;
public static MethodInfo ConvertToInt64Method;
public static MethodInfo ConvertToUInt64Method;
public static MethodInfo ConvertToCharMethod;
public static MethodInfo ConvertToBooleanMethod;
public static MethodInfo ConvertToDoubleMethod;
public static MethodInfo ConvertToSingleMethod;
public static MethodInfo IDisposableDisposeMethod;
public static MethodInfo GetUnsizedArrayCreateMethod(TypeInfo ti) public static PropertyInfo SecurityRulesAttributeSkipVerificationInFullTrustProperty;
{
if (UnsizedArrayCreateMethodTemplate == null) public static ConstructorInfo IndexOutOfRangeCtor;
UnsizedArrayCreateMethodTemplate = ArrayType.GetMethod("Resize"); public static ConstructorInfo ParamArrayAttributeCtor;
return UnsizedArrayCreateMethodTemplate.MakeGenericMethod(ti.tp.GetElementType()); public static ConstructorInfo DebuggableAttributeCtor;
} public static ConstructorInfo AssemblyKeyFileAttributeCtor;
public static ConstructorInfo AssemblyDelaySignAttributeCtor;
public static ConstructorInfo TargetFrameworkAttributeCtor;
public static ConstructorInfo SecurityRulesAttributeCtor;
public static ConstructorInfo STAThreadAttributeCtor;
public static ConstructorInfo CompilationRelaxationsAttributeCtor;
public static ConstructorInfo AssemblyTitleAttributeCtor;
public static ConstructorInfo AssemblyDescriptionAttributeCtor;
static TypeFactory() static TypeFactory()
{ {
int_type = new TypeInfo(typeof(int));
double_type = new TypeInfo(typeof(double));
bool_type = new TypeInfo(typeof(bool));
char_type = new TypeInfo(typeof(char));
string_type = new TypeInfo(typeof(string));
byte_type = new TypeInfo(typeof(byte));
types = new HashSet<Type>() types = new HashSet<Type>()
{ {
BoolType, SByteType, ByteType, CharType, BoolType, SByteType, ByteType, CharType,
@ -111,18 +137,59 @@ namespace PascalABCCompiler.NETGenerator
//sizes[UIntPtr] = sizeof(UIntPtr); //sizes[UIntPtr] = sizeof(UIntPtr);
//types[TypeType] = TypeType; //types[TypeType] = TypeType;
ArrayCopyMethod = typeof(Array).GetMethod("Copy", new Type[3] { typeof(Array), typeof(Array), typeof(int) }); ArrayCopyMethod = ArrayType.GetMethod("Copy", new Type[3] { ArrayType, ArrayType, Int32Type });
StringNullOrEmptyMethod = typeof(string).GetMethod("IsNullOrEmpty"); ArrayLengthGetMethod = ArrayType.GetMethod("get_Length");
GCHandleAlloc = typeof(System.Runtime.InteropServices.GCHandle).GetMethod("Alloc",new Type[1]{TypeFactory.ObjectType}); StringNullOrEmptyMethod = StringType.GetMethod("IsNullOrEmpty");
GCHandleAllocPinned = typeof(System.Runtime.InteropServices.GCHandle).GetMethod("Alloc", new Type[2] { TypeFactory.ObjectType, typeof(GCHandleType) }); GCHandleAlloc = GCHandleType.GetMethod("Alloc",new Type[1]{ ObjectType });
GCHandleAllocPinned = GCHandleType.GetMethod("Alloc", new Type[2] { ObjectType, typeof(GCHandleType) });
OffsetToStringDataProperty = typeof(System.Runtime.CompilerServices.RuntimeHelpers).GetProperty("OffsetToStringData",BindingFlags.Public|BindingFlags.Static|BindingFlags.Instance).GetGetMethod(); OffsetToStringDataProperty = typeof(System.Runtime.CompilerServices.RuntimeHelpers).GetProperty("OffsetToStringData",BindingFlags.Public|BindingFlags.Static|BindingFlags.Instance).GetGetMethod();
StringLengthMethod = typeof(string).GetProperty("Length").GetGetMethod(); StringLengthMethod = StringType.GetProperty("Length").GetGetMethod();
IndexOutOfRangeConstructor = typeof(IndexOutOfRangeException).GetConstructor(Type.EmptyTypes);
ParamArrayAttributeConstructor = typeof(ParamArrayAttribute).GetConstructor(Type.EmptyTypes); GCHandleFreeMethod = GCHandleType.GetMethod("Free");
GCHandleFreeMethod = typeof(GCHandle).GetMethod("Free"); GetTypeFromHandleMethod = TypeType.GetMethod("GetTypeFromHandle");
GetTypeFromHandleMethod = typeof(Type).GetMethod("GetTypeFromHandle"); StringCopyMethod = StringType.GetMethod("Copy");
StringCopyMethod = typeof(string).GetMethod("Copy"); CharToString = CharType.GetMethod("ToString", BindingFlags.Static | BindingFlags.Public);
CharToString = typeof(char).GetMethod("ToString", BindingFlags.Static | BindingFlags.Public); MathMinMethod = typeof(Math).GetMethod("Min", new Type[] { Int32Type, Int32Type });
MarshalAllocHGlobalMethod = MarshalType.GetMethod("AllocHGlobal", new Type[1] { Int32Type });
MarshalFreeHGlobalMethod = MarshalType.GetMethod("FreeHGlobal", new Type[1] { typeof(IntPtr) });
MarshalCopyMethod = MarshalType.GetMethod("Copy", new Type[4] { typeof(byte[]), Int32Type, IntPtrType, Int32Type });
MarshalSizeOfMethod = MarshalType.GetMethod("SizeOf", new Type[] { TypeType });
NullableHasValueGetMethod = typeof(Nullable<>).GetProperty("HasValue").GetGetMethod();
NullableGetValueOrDefaultMethod = typeof(Nullable<>).GetMethod("GetValueOrDefault", Type.EmptyTypes);
EnvironmentIs64BitProcessGetMethod = typeof(Environment).GetProperty("Is64BitProcess", BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy).GetGetMethod();
ActivatorCreateInstanceMethod = typeof(Activator).GetMethod("CreateInstance", Type.EmptyTypes);
IEnumerableGenericGetEnumeratorMethod = IEnumerableGenericType.GetMethod("GetEnumerator");
IEnumerableGetEnumeratorMethod = IEnumerableType.GetMethod("GetEnumerator");
IEnumeratorMoveNextMethod = IEnumeratorType.GetMethod("MoveNext", BindingFlags.Instance | BindingFlags.Public);
MonitorEnterMethod = MonitorType.GetMethod("Enter", new Type[1] { ObjectType });
MonitorExitMethod = MonitorType.GetMethod("Exit", new Type[1] { ObjectType });
ConvertToByteMethod = ConvertType.GetMethod("ToByte", new Type[1] { ObjectType });
ConvertToSByteMethod = ConvertType.GetMethod("ToSByte", new Type[1] { ObjectType });
ConvertToInt16Method = ConvertType.GetMethod("ToInt16", new Type[1] { ObjectType });
ConvertToUInt16Method = ConvertType.GetMethod("ToUInt16", new Type[1] { ObjectType });
ConvertToInt32Method = ConvertType.GetMethod("ToInt32", new Type[1] { ObjectType });
ConvertToUInt32Method = ConvertType.GetMethod("ToUInt32", new Type[1] { ObjectType });
ConvertToInt64Method = ConvertType.GetMethod("ToInt64", new Type[1] { ObjectType });
ConvertToUInt64Method = ConvertType.GetMethod("ToUInt64", new Type[1] { ObjectType });
ConvertToCharMethod = ConvertType.GetMethod("ToChar", new Type[1] { ObjectType });
ConvertToBooleanMethod = ConvertType.GetMethod("ToBoolean", new Type[1] { ObjectType });
ConvertToDoubleMethod = ConvertType.GetMethod("ToDouble", new Type[1] { ObjectType });
ConvertToSingleMethod = ConvertType.GetMethod("ToSingle", new Type[1] { ObjectType });
IDisposableDisposeMethod = IDisposableType.GetMethod("Dispose", BindingFlags.Instance | BindingFlags.Public);
SecurityRulesAttributeSkipVerificationInFullTrustProperty = typeof(SecurityRulesAttribute).GetProperty("SkipVerificationInFullTrust");
IndexOutOfRangeCtor = typeof(IndexOutOfRangeException).GetConstructor(Type.EmptyTypes);
ParamArrayAttributeCtor = typeof(ParamArrayAttribute).GetConstructor(Type.EmptyTypes);
DebuggableAttributeCtor = typeof(System.Diagnostics.DebuggableAttribute).GetConstructor(new Type[] { BoolType, BoolType });
AssemblyKeyFileAttributeCtor = typeof(AssemblyKeyFileAttribute).GetConstructor(new Type[] { StringType });
AssemblyDelaySignAttributeCtor = typeof(AssemblyDelaySignAttribute).GetConstructor(new Type[] { BoolType });
TargetFrameworkAttributeCtor = typeof(TargetFrameworkAttribute).GetConstructor(new Type[] { StringType });
SecurityRulesAttributeCtor = typeof(SecurityRulesAttribute).GetConstructor(new Type[] { typeof(SecurityRuleSet) });
STAThreadAttributeCtor = typeof(STAThreadAttribute).GetConstructor(Type.EmptyTypes);
CompilationRelaxationsAttributeCtor = typeof(System.Runtime.CompilerServices.CompilationRelaxationsAttribute).GetConstructor(new Type[] { Int32Type });
AssemblyTitleAttributeCtor = typeof(AssemblyTitleAttribute).GetConstructor(new Type[] { StringType });
AssemblyDescriptionAttributeCtor = typeof(AssemblyDescriptionAttribute).GetConstructor(new Type[] { StringType });
} }
public static bool IsStandType(Type t) public static bool IsStandType(Type t)

153
NETGenerator/NETGenerator.cs
View file

@ -175,7 +175,6 @@ namespace PascalABCCompiler.NETGenerator
private Dictionary<ICommonFunctionNode, List<IGenericTypeInstance>> instances_in_functions = private Dictionary<ICommonFunctionNode, List<IGenericTypeInstance>> instances_in_functions =
new Dictionary<ICommonFunctionNode, List<IGenericTypeInstance>>(); new Dictionary<ICommonFunctionNode, List<IGenericTypeInstance>>();
private static MethodInfo ActivatorCreateInstance = typeof(Activator).GetMethod("CreateInstance", Type.EmptyTypes);
//\ssyy //\ssyy
private MethodInfo fix_pointer_meth = null; private MethodInfo fix_pointer_meth = null;
@ -306,7 +305,7 @@ namespace PascalABCCompiler.NETGenerator
get get
{ {
if (fileOfAttributeConstructor != null) return fileOfAttributeConstructor; if (fileOfAttributeConstructor != null) return fileOfAttributeConstructor;
TypeBuilder tb = mb.DefineType(StringConstants.file_of_attr_name, TypeAttributes.Public | TypeAttributes.BeforeFieldInit, typeof(Attribute)); TypeBuilder tb = mb.DefineType(StringConstants.file_of_attr_name, TypeAttributes.Public | TypeAttributes.BeforeFieldInit, TypeFactory.AttributeType);
types.Add(tb); types.Add(tb);
fileOfAttributeConstructor = tb.DefineConstructor(MethodAttributes.Public, CallingConventions.HasThis, new Type[1] { TypeFactory.ObjectType }); fileOfAttributeConstructor = tb.DefineConstructor(MethodAttributes.Public, CallingConventions.HasThis, new Type[1] { TypeFactory.ObjectType });
FieldBuilder fld = tb.DefineField("Type", TypeFactory.ObjectType, FieldAttributes.Public); FieldBuilder fld = tb.DefineField("Type", TypeFactory.ObjectType, FieldAttributes.Public);
@ -326,7 +325,7 @@ namespace PascalABCCompiler.NETGenerator
get get
{ {
if (setOfAttributeConstructor != null) return setOfAttributeConstructor; if (setOfAttributeConstructor != null) return setOfAttributeConstructor;
TypeBuilder tb = mb.DefineType(StringConstants.set_of_attr_name, TypeAttributes.Public | TypeAttributes.BeforeFieldInit, typeof(Attribute)); TypeBuilder tb = mb.DefineType(StringConstants.set_of_attr_name, TypeAttributes.Public | TypeAttributes.BeforeFieldInit, TypeFactory.AttributeType);
types.Add(tb); types.Add(tb);
setOfAttributeConstructor = tb.DefineConstructor(MethodAttributes.Public, CallingConventions.HasThis, new Type[1] { TypeFactory.ObjectType }); setOfAttributeConstructor = tb.DefineConstructor(MethodAttributes.Public, CallingConventions.HasThis, new Type[1] { TypeFactory.ObjectType });
FieldBuilder fld = tb.DefineField("Type", TypeFactory.ObjectType, FieldAttributes.Public); FieldBuilder fld = tb.DefineField("Type", TypeFactory.ObjectType, FieldAttributes.Public);
@ -347,7 +346,7 @@ namespace PascalABCCompiler.NETGenerator
get get
{ {
if (templateClassAttributeConstructor != null) return templateClassAttributeConstructor; if (templateClassAttributeConstructor != null) return templateClassAttributeConstructor;
TypeBuilder tb = mb.DefineType(StringConstants.template_class_attr_name, TypeAttributes.Public | TypeAttributes.BeforeFieldInit, typeof(Attribute)); TypeBuilder tb = mb.DefineType(StringConstants.template_class_attr_name, TypeAttributes.Public | TypeAttributes.BeforeFieldInit, TypeFactory.AttributeType);
types.Add(tb); types.Add(tb);
templateClassAttributeConstructor = tb.DefineConstructor(MethodAttributes.Public, CallingConventions.HasThis, new Type[1] { TypeFactory.ByteType.MakeArrayType() }); templateClassAttributeConstructor = tb.DefineConstructor(MethodAttributes.Public, CallingConventions.HasThis, new Type[1] { TypeFactory.ByteType.MakeArrayType() });
FieldBuilder fld = tb.DefineField("Tree", TypeFactory.ByteType.MakeArrayType(), FieldAttributes.Public); FieldBuilder fld = tb.DefineField("Tree", TypeFactory.ByteType.MakeArrayType(), FieldAttributes.Public);
@ -368,7 +367,7 @@ namespace PascalABCCompiler.NETGenerator
get get
{ {
if (typeSynonimAttributeConstructor != null) return typeSynonimAttributeConstructor; if (typeSynonimAttributeConstructor != null) return typeSynonimAttributeConstructor;
TypeBuilder tb = mb.DefineType(StringConstants.type_synonim_attr_name, TypeAttributes.Public | TypeAttributes.BeforeFieldInit, typeof(Attribute)); TypeBuilder tb = mb.DefineType(StringConstants.type_synonim_attr_name, TypeAttributes.Public | TypeAttributes.BeforeFieldInit, TypeFactory.AttributeType);
types.Add(tb); types.Add(tb);
typeSynonimAttributeConstructor = tb.DefineConstructor(MethodAttributes.Public, CallingConventions.HasThis, new Type[1] { TypeFactory.ObjectType }); typeSynonimAttributeConstructor = tb.DefineConstructor(MethodAttributes.Public, CallingConventions.HasThis, new Type[1] { TypeFactory.ObjectType });
FieldBuilder fld = tb.DefineField("Type", TypeFactory.ObjectType, FieldAttributes.Public); FieldBuilder fld = tb.DefineField("Type", TypeFactory.ObjectType, FieldAttributes.Public);
@ -389,7 +388,7 @@ namespace PascalABCCompiler.NETGenerator
get get
{ {
if (shortStringAttributeConstructor != null) return shortStringAttributeConstructor; if (shortStringAttributeConstructor != null) return shortStringAttributeConstructor;
TypeBuilder tb = mb.DefineType(StringConstants.short_string_attr_name, TypeAttributes.Public | TypeAttributes.BeforeFieldInit, typeof(Attribute)); TypeBuilder tb = mb.DefineType(StringConstants.short_string_attr_name, TypeAttributes.Public | TypeAttributes.BeforeFieldInit, TypeFactory.AttributeType);
types.Add(tb); types.Add(tb);
shortStringAttributeConstructor = tb.DefineConstructor(MethodAttributes.Public, CallingConventions.HasThis, new Type[1] { TypeFactory.Int32Type }); shortStringAttributeConstructor = tb.DefineConstructor(MethodAttributes.Public, CallingConventions.HasThis, new Type[1] { TypeFactory.Int32Type });
FieldBuilder fld = tb.DefineField("Length", TypeFactory.Int32Type, FieldAttributes.Public); FieldBuilder fld = tb.DefineField("Length", TypeFactory.Int32Type, FieldAttributes.Public);
@ -780,7 +779,7 @@ namespace PascalABCCompiler.NETGenerator
//bool emit_sym = true; //bool emit_sym = true;
if (save_debug_info) //если модуль отладочный, то устанавливаем атрибут, запрещающий inline методов if (save_debug_info) //если модуль отладочный, то устанавливаем атрибут, запрещающий inline методов
ab.SetCustomAttribute(typeof(System.Diagnostics.DebuggableAttribute).GetConstructor(new Type[] { typeof(bool), typeof(bool) }), new byte[] { 0x01, 0x00, 0x01, 0x01, 0x00, 0x00 }); ab.SetCustomAttribute(TypeFactory.DebuggableAttributeCtor, new byte[] { 0x01, 0x00, 0x01, 0x01, 0x00, 0x00 });
if (!IsDotnet5() && !IsDotnetNative() && (comp_opt.target == TargetType.Exe || comp_opt.target == TargetType.WinExe)) if (!IsDotnet5() && !IsDotnetNative() && (comp_opt.target == TargetType.Exe || comp_opt.target == TargetType.WinExe))
mb = ab.DefineDynamicModule(name + ".exe", an.Name + ".exe", save_debug_info); //определяем модуль (save_debug_info - флаг включать отладочную информацию) mb = ab.DefineDynamicModule(name + ".exe", an.Name + ".exe", save_debug_info); //определяем модуль (save_debug_info - флаг включать отладочную информацию)
@ -890,14 +889,14 @@ namespace PascalABCCompiler.NETGenerator
NamespacesTypes.Add(cnns[iii], cur_type); NamespacesTypes.Add(cnns[iii], cur_type);
if (cnns[iii].IsMain) if (cnns[iii].IsMain)
{ // SSM 05.02.20 here change { // SSM 05.02.20 here change
TypeBuilder attr_class = mb.DefineType(cnnsnamespace_name + "." + "$GlobAttr", TypeAttributes.Public | TypeAttributes.BeforeFieldInit, typeof(Attribute)); TypeBuilder attr_class = mb.DefineType(cnnsnamespace_name + "." + "$GlobAttr", TypeAttributes.Public | TypeAttributes.BeforeFieldInit, TypeFactory.AttributeType);
ConstructorInfo attr_ci = attr_class.DefineDefaultConstructor(MethodAttributes.Public); ConstructorInfo attr_ci = attr_class.DefineDefaultConstructor(MethodAttributes.Public);
cur_type.SetCustomAttribute(attr_ci, new byte[4] { 0x01, 0x00, 0x00, 0x00 }); cur_type.SetCustomAttribute(attr_ci, new byte[4] { 0x01, 0x00, 0x00, 0x00 });
attr_class.CreateType(); attr_class.CreateType();
} }
else if (!IsDotnetNative()) else if (!IsDotnetNative())
{ // SSM 05.02.20 here change { // SSM 05.02.20 here change
TypeBuilder attr_class = mb.DefineType(cnnsnamespace_name + "." + "$ClassUnitAttr", TypeAttributes.Public | TypeAttributes.BeforeFieldInit, typeof(Attribute)); TypeBuilder attr_class = mb.DefineType(cnnsnamespace_name + "." + "$ClassUnitAttr", TypeAttributes.Public | TypeAttributes.BeforeFieldInit, TypeFactory.AttributeType);
ConstructorInfo attr_ci = attr_class.DefineDefaultConstructor(MethodAttributes.Public); ConstructorInfo attr_ci = attr_class.DefineDefaultConstructor(MethodAttributes.Public);
cur_type.SetCustomAttribute(attr_ci, new byte[4] { 0x01, 0x00, 0x00, 0x00 }); cur_type.SetCustomAttribute(attr_ci, new byte[4] { 0x01, 0x00, 0x00, 0x00 });
attr_class.CreateType(); attr_class.CreateType();
@ -1154,7 +1153,7 @@ namespace PascalABCCompiler.NETGenerator
{ {
string[] namespaces = p.UsedNamespaces; string[] namespaces = p.UsedNamespaces;
TypeBuilder attr_class = mb.DefineType("$UsedNsAttr", TypeAttributes.Public | TypeAttributes.BeforeFieldInit, typeof(Attribute)); TypeBuilder attr_class = mb.DefineType("$UsedNsAttr", TypeAttributes.Public | TypeAttributes.BeforeFieldInit, TypeFactory.AttributeType);
FieldBuilder fld_ns = attr_class.DefineField("ns", TypeFactory.StringType, FieldAttributes.Public); FieldBuilder fld_ns = attr_class.DefineField("ns", TypeFactory.StringType, FieldAttributes.Public);
FieldBuilder fld_count = attr_class.DefineField("count", TypeFactory.Int32Type, FieldAttributes.Public); FieldBuilder fld_count = attr_class.DefineField("count", TypeFactory.Int32Type, FieldAttributes.Public);
ConstructorBuilder attr_ci = attr_class.DefineConstructor(MethodAttributes.Public, CallingConventions.HasThis, new Type[2] { TypeFactory.Int32Type, TypeFactory.StringType }); ConstructorBuilder attr_ci = attr_class.DefineConstructor(MethodAttributes.Public, CallingConventions.HasThis, new Type[2] { TypeFactory.Int32Type, TypeFactory.StringType });
@ -1211,20 +1210,20 @@ namespace PascalABCCompiler.NETGenerator
} }
if (an.Name == "PABCRtl") if (an.Name == "PABCRtl")
{ {
CustomAttributeBuilder cab = new CustomAttributeBuilder(typeof(AssemblyKeyFileAttribute).GetConstructor(new Type[] { typeof(string) }), new object[] { an.Name == "PABCRtl" ? "PublicKey.snk" : "PublicKey32.snk" }); CustomAttributeBuilder cab = new CustomAttributeBuilder(TypeFactory.AssemblyKeyFileAttributeCtor, new object[] { an.Name == "PABCRtl" ? "PublicKey.snk" : "PublicKey32.snk" });
ab.SetCustomAttribute(cab); ab.SetCustomAttribute(cab);
cab = new CustomAttributeBuilder(typeof(AssemblyDelaySignAttribute).GetConstructor(new Type[] { typeof(bool) }), new object[] { true }); cab = new CustomAttributeBuilder(TypeFactory.AssemblyDelaySignAttributeCtor, new object[] { true });
ab.SetCustomAttribute(cab); ab.SetCustomAttribute(cab);
cab = new CustomAttributeBuilder(typeof(TargetFrameworkAttribute).GetConstructor(new Type[] { typeof(string) }), new object[] { ".NETFramework,Version=v4.0" }); cab = new CustomAttributeBuilder(TypeFactory.TargetFrameworkAttributeCtor, new object[] { ".NETFramework,Version=v4.0" });
ab.SetCustomAttribute(cab); ab.SetCustomAttribute(cab);
} }
ab.SetCustomAttribute(new CustomAttributeBuilder(typeof(SecurityRulesAttribute).GetConstructor(new Type[] { typeof(SecurityRuleSet) }), new object[] { SecurityRuleSet.Level2 }, ab.SetCustomAttribute(new CustomAttributeBuilder(TypeFactory.SecurityRulesAttributeCtor, new object[] { SecurityRuleSet.Level2 },
new PropertyInfo[] { typeof(SecurityRulesAttribute).GetProperty("SkipVerificationInFullTrust") }, new PropertyInfo[] { TypeFactory.SecurityRulesAttributeSkipVerificationInFullTrustProperty },
new object[] { true })); new object[] { true }));
if (entry_meth != null && comp_opt.target == TargetType.WinExe) if (entry_meth != null && comp_opt.target == TargetType.WinExe)
{ {
entry_meth.SetCustomAttribute(typeof(STAThreadAttribute).GetConstructor(Type.EmptyTypes), new byte[] { 0x01, 0x00, 0x00, 0x00 }); entry_meth.SetCustomAttribute(TypeFactory.STAThreadAttributeCtor, new byte[] { 0x01, 0x00, 0x00, 0x00 });
} }
List<FileStream> ResStreams = new List<FileStream>(); List<FileStream> ResStreams = new List<FileStream>();
if (ResourceFiles != null) if (ResourceFiles != null)
@ -1234,17 +1233,17 @@ namespace PascalABCCompiler.NETGenerator
ResStreams.Add(stream); ResStreams.Add(stream);
mb.DefineManifestResource(Path.GetFileName(resname), stream, ResourceAttributes.Public); mb.DefineManifestResource(Path.GetFileName(resname), stream, ResourceAttributes.Public);
} }
ab.SetCustomAttribute(typeof(System.Runtime.CompilerServices.CompilationRelaxationsAttribute).GetConstructor(new Type[1] { TypeFactory.Int32Type }), ab.SetCustomAttribute(TypeFactory.CompilationRelaxationsAttributeCtor,
new byte[] { 0x01, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00 }); new byte[] { 0x01, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00 });
ab.SetCustomAttribute(new CustomAttributeBuilder(typeof(System.Reflection.AssemblyTitleAttribute).GetConstructor(new Type[] { typeof(string) }), new object[] { options.Title })); ab.SetCustomAttribute(new CustomAttributeBuilder(TypeFactory.AssemblyTitleAttributeCtor, new object[] { options.Title }));
ab.SetCustomAttribute(new CustomAttributeBuilder(typeof(System.Reflection.AssemblyDescriptionAttribute).GetConstructor(new Type[] { typeof(string) }), new object[] { options.Description })); ab.SetCustomAttribute(new CustomAttributeBuilder(TypeFactory.AssemblyDescriptionAttributeCtor, new object[] { options.Description }));
if (options.TargetFramework != "") if (options.TargetFramework != "")
{ {
string frameworkVersion = string.Join(".", options.TargetFramework.Substring(3).AsEnumerable()); string frameworkVersion = string.Join(".", options.TargetFramework.Substring(3).AsEnumerable());
ab.SetCustomAttribute(new CustomAttributeBuilder(typeof(TargetFrameworkAttribute).GetConstructor(new Type[] { typeof(string) }), new object[] { $".NETFramework,Version=v{frameworkVersion}" })); ab.SetCustomAttribute(new CustomAttributeBuilder(TypeFactory.TargetFrameworkAttributeCtor, new object[] { $".NETFramework,Version=v{frameworkVersion}" }));
} }
int tries = 0; int tries = 0;
@ -2938,7 +2937,7 @@ namespace PascalABCCompiler.NETGenerator
pb = methb.DefineParameter(i + num + 1, pa, parameters[i].name); pb = methb.DefineParameter(i + num + 1, pa, parameters[i].name);
if (parameters[i].is_params) if (parameters[i].is_params)
pb.SetCustomAttribute(TypeFactory.ParamArrayAttributeConstructor, new byte[] { 0x1, 0x0, 0x0, 0x0 }); pb.SetCustomAttribute(TypeFactory.ParamArrayAttributeCtor, new byte[] { 0x1, 0x0, 0x0, 0x0 });
if (default_value != null) if (default_value != null)
{ {
if ((Environment.OSVersion.Platform == PlatformID.Unix || Environment.OSVersion.Platform == PlatformID.MacOSX) && default_value.GetType() != param_types[i + num] && param_types[i + num].IsEnum) if ((Environment.OSVersion.Platform == PlatformID.Unix || Environment.OSVersion.Platform == PlatformID.MacOSX) && default_value.GetType() != param_types[i + num] && param_types[i + num].IsEnum)
@ -5584,7 +5583,7 @@ namespace PascalABCCompiler.NETGenerator
if (is_dot_expr == true) if (is_dot_expr == true)
{ {
LocalBuilder lb = null; LocalBuilder lb = null;
lb = il.DeclareLocal(typeof(long)); lb = il.DeclareLocal(TypeFactory.Int64Type);
il.Emit(OpCodes.Stloc, lb); il.Emit(OpCodes.Stloc, lb);
il.Emit(OpCodes.Ldloca, lb); il.Emit(OpCodes.Ldloca, lb);
} }
@ -5609,7 +5608,7 @@ namespace PascalABCCompiler.NETGenerator
if (is_dot_expr == true) if (is_dot_expr == true)
{ {
LocalBuilder lb = null; LocalBuilder lb = null;
lb = il.DeclareLocal(typeof(short)); lb = il.DeclareLocal(TypeFactory.Int16Type);
il.Emit(OpCodes.Stloc, lb); il.Emit(OpCodes.Stloc, lb);
il.Emit(OpCodes.Ldloca, lb); il.Emit(OpCodes.Ldloca, lb);
} }
@ -5621,7 +5620,7 @@ namespace PascalABCCompiler.NETGenerator
if (is_dot_expr == true) if (is_dot_expr == true)
{ {
LocalBuilder lb = null; LocalBuilder lb = null;
lb = il.DeclareLocal(typeof(ushort)); lb = il.DeclareLocal(TypeFactory.UInt16Type);
il.Emit(OpCodes.Stloc, lb); il.Emit(OpCodes.Stloc, lb);
il.Emit(OpCodes.Ldloca, lb); il.Emit(OpCodes.Ldloca, lb);
} }
@ -5633,7 +5632,7 @@ namespace PascalABCCompiler.NETGenerator
if (is_dot_expr == true) if (is_dot_expr == true)
{ {
LocalBuilder lb = null; LocalBuilder lb = null;
lb = il.DeclareLocal(typeof(uint)); lb = il.DeclareLocal(TypeFactory.UInt32Type);
il.Emit(OpCodes.Stloc, lb); il.Emit(OpCodes.Stloc, lb);
il.Emit(OpCodes.Ldloca, lb); il.Emit(OpCodes.Ldloca, lb);
} }
@ -5651,7 +5650,7 @@ namespace PascalABCCompiler.NETGenerator
if (is_dot_expr == true) if (is_dot_expr == true)
{ {
LocalBuilder lb = null; LocalBuilder lb = null;
lb = il.DeclareLocal(typeof(ulong)); lb = il.DeclareLocal(TypeFactory.UInt64Type);
il.Emit(OpCodes.Stloc, lb); il.Emit(OpCodes.Stloc, lb);
il.Emit(OpCodes.Ldloca, lb); il.Emit(OpCodes.Ldloca, lb);
} }
@ -5664,7 +5663,7 @@ namespace PascalABCCompiler.NETGenerator
if (is_dot_expr == true) if (is_dot_expr == true)
{ {
LocalBuilder lb = null; LocalBuilder lb = null;
lb = il.DeclareLocal(typeof(sbyte)); lb = il.DeclareLocal(TypeFactory.SByteType);
il.Emit(OpCodes.Stloc, lb); il.Emit(OpCodes.Stloc, lb);
il.Emit(OpCodes.Ldloca, lb); il.Emit(OpCodes.Ldloca, lb);
} }
@ -5680,7 +5679,7 @@ namespace PascalABCCompiler.NETGenerator
il.Emit(OpCodes.Ldc_I4_0); il.Emit(OpCodes.Ldc_I4_0);
if (is_dot_expr == true) if (is_dot_expr == true)
{ {
LocalBuilder lb = il.DeclareLocal(typeof(bool)); LocalBuilder lb = il.DeclareLocal(TypeFactory.BoolType);
il.Emit(OpCodes.Stloc, lb); il.Emit(OpCodes.Stloc, lb);
il.Emit(OpCodes.Ldloca, lb); il.Emit(OpCodes.Ldloca, lb);
} }
@ -6758,7 +6757,7 @@ namespace PascalABCCompiler.NETGenerator
{ {
pb = methb.DefineParameter(i + num + 1, ParameterAttributes.None, parameters[i].name); pb = methb.DefineParameter(i + num + 1, ParameterAttributes.None, parameters[i].name);
if (parameters[i].is_params) if (parameters[i].is_params)
pb.SetCustomAttribute(TypeFactory.ParamArrayAttributeConstructor, new byte[] { 0x1, 0x0, 0x0, 0x0 }); pb.SetCustomAttribute(TypeFactory.ParamArrayAttributeCtor, new byte[] { 0x1, 0x0, 0x0, 0x0 });
FieldBuilder fb = null; FieldBuilder fb = null;
if (parameters[i].parameter_type == parameter_type.value) if (parameters[i].parameter_type == parameter_type.value)
fb = frm.tb.DefineField(parameters[i].name, param_types[i + num], FieldAttributes.Public); fb = frm.tb.DefineField(parameters[i].name, param_types[i + num], FieldAttributes.Public);
@ -6971,7 +6970,7 @@ namespace PascalABCCompiler.NETGenerator
{ {
pb = methb.DefineParameter(i + num + 1, ParameterAttributes.None, parameters[i].name); pb = methb.DefineParameter(i + num + 1, ParameterAttributes.None, parameters[i].name);
if (parameters[i].is_params) if (parameters[i].is_params)
pb.SetCustomAttribute(TypeFactory.ParamArrayAttributeConstructor, new byte[] { 0x1, 0x0, 0x0, 0x0 }); pb.SetCustomAttribute(TypeFactory.ParamArrayAttributeCtor, new byte[] { 0x1, 0x0, 0x0, 0x0 });
if (func.functions_nodes.Length > 0) if (func.functions_nodes.Length > 0)
{ {
FieldBuilder fb = null; FieldBuilder fb = null;
@ -7125,7 +7124,7 @@ namespace PascalABCCompiler.NETGenerator
attrs = MethodAttributes.Public | MethodAttributes.HideBySig; attrs = MethodAttributes.Public | MethodAttributes.HideBySig;
param_types = new Type[2]; param_types = new Type[2];
param_types[0] = TypeFactory.ObjectType; param_types[0] = TypeFactory.ObjectType;
param_types[1] = TypeFactory.IntPtr; param_types[1] = TypeFactory.IntPtrType;
} }
} }
cnstr = cur_type.DefineConstructor(attrs, CallingConventions.HasThis, param_types); cnstr = cur_type.DefineConstructor(attrs, CallingConventions.HasThis, param_types);
@ -7358,7 +7357,7 @@ namespace PascalABCCompiler.NETGenerator
else pb.SetConstant(default_value); else pb.SetConstant(default_value);
helper.AddParameter(parameters[i], pb); helper.AddParameter(parameters[i], pb);
if (parameters[i].is_params) if (parameters[i].is_params)
pb.SetCustomAttribute(TypeFactory.ParamArrayAttributeConstructor, new byte[] { 0x1, 0x0, 0x0, 0x0 }); pb.SetCustomAttribute(TypeFactory.ParamArrayAttributeCtor, new byte[] { 0x1, 0x0, 0x0, 0x0 });
} }
} }
@ -7384,7 +7383,7 @@ namespace PascalABCCompiler.NETGenerator
else pb.SetConstant(default_value); else pb.SetConstant(default_value);
helper.AddParameter(parameters[i], pb); helper.AddParameter(parameters[i], pb);
if (parameters[i].is_params) if (parameters[i].is_params)
pb.SetCustomAttribute(TypeFactory.ParamArrayAttributeConstructor, new byte[] { 0x1, 0x0, 0x0, 0x0 }); pb.SetCustomAttribute(TypeFactory.ParamArrayAttributeCtor, new byte[] { 0x1, 0x0, 0x0, 0x0 });
} }
} }
@ -7421,9 +7420,9 @@ namespace PascalABCCompiler.NETGenerator
il.Emit(OpCodes.Stloc, tmp_lb); il.Emit(OpCodes.Stloc, tmp_lb);
il.Emit(OpCodes.Ldloc, tmp_lb); il.Emit(OpCodes.Ldloc, tmp_lb);
real_parameters[0].visit(this); real_parameters[0].visit(this);
il.Emit(OpCodes.Callvirt, TypeFactory.ArrayType.GetMethod("get_Length")); il.Emit(OpCodes.Callvirt, TypeFactory.ArrayLengthGetMethod);
real_parameters[1].visit(this); real_parameters[1].visit(this);
il.Emit(OpCodes.Call, typeof(Math).GetMethod("Min", new Type[] { TypeFactory.Int32Type, TypeFactory.Int32Type })); il.Emit(OpCodes.Call, TypeFactory.MathMinMethod);
il.Emit(OpCodes.Call, TypeFactory.ArrayCopyMethod); il.Emit(OpCodes.Call, TypeFactory.ArrayCopyMethod);
il.Emit(OpCodes.Ldloc, tmp_lb); il.Emit(OpCodes.Ldloc, tmp_lb);
il.Emit(OpCodes.Br, l2); il.Emit(OpCodes.Br, l2);
@ -7542,7 +7541,7 @@ namespace PascalABCCompiler.NETGenerator
private bool has_debug_conditional_attr(MethodInfo mi) private bool has_debug_conditional_attr(MethodInfo mi)
{ {
var attrs = mi.GetCustomAttributes(typeof(System.Diagnostics.ConditionalAttribute), true); var attrs = mi.GetCustomAttributes(TypeFactory.ConditionalAttributeType, true);
if (attrs != null && attrs.Length > 0 && (attrs[0] as System.Diagnostics.ConditionalAttribute).ConditionString == "DEBUG") if (attrs != null && attrs.Length > 0 && (attrs[0] as System.Diagnostics.ConditionalAttribute).ConditionString == "DEBUG")
return true; return true;
return false; return false;
@ -7552,7 +7551,7 @@ namespace PascalABCCompiler.NETGenerator
{ {
foreach (IAttributeNode attr in attrs) foreach (IAttributeNode attr in attrs)
{ {
if (attr.AttributeType is ICompiledTypeNode && (attr.AttributeType as ICompiledTypeNode).compiled_type == typeof(System.Diagnostics.ConditionalAttribute)) if (attr.AttributeType is ICompiledTypeNode && (attr.AttributeType as ICompiledTypeNode).compiled_type == TypeFactory.ConditionalAttributeType)
{ {
if ((string)attr.Arguments[0].value == "DEBUG") if ((string)attr.Arguments[0].value == "DEBUG")
return true; return true;
@ -7962,9 +7961,9 @@ namespace PascalABCCompiler.NETGenerator
il = methodb.GetILGenerator(); il = methodb.GetILGenerator();
il.Emit(OpCodes.Ldarg_0); il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_1); il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Call, typeof(Marshal).GetMethod("AllocHGlobal", new Type[1] { TypeFactory.Int32Type })); il.Emit(OpCodes.Call, TypeFactory.MarshalAllocHGlobalMethod);
il.Emit(OpCodes.Stind_I); il.Emit(OpCodes.Stind_I);
LocalBuilder lb = il.DeclareLocal(typeof(byte[])); LocalBuilder lb = il.DeclareLocal(TypeFactory.ByteType.MakeArrayType());
il.Emit(OpCodes.Ldarg_1); il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Newarr, TypeFactory.ByteType); il.Emit(OpCodes.Newarr, TypeFactory.ByteType);
il.Emit(OpCodes.Stloc, lb); il.Emit(OpCodes.Stloc, lb);
@ -7973,7 +7972,7 @@ namespace PascalABCCompiler.NETGenerator
il.Emit(OpCodes.Ldarg_0); il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldind_I); il.Emit(OpCodes.Ldind_I);
il.Emit(OpCodes.Ldarg_1); il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Call, typeof(Marshal).GetMethod("Copy", new Type[4] { typeof(byte[]), TypeFactory.Int32Type, TypeFactory.IntPtr, TypeFactory.Int32Type })); il.Emit(OpCodes.Call, TypeFactory.MarshalCopyMethod);
il.Emit(OpCodes.Ret); il.Emit(OpCodes.Ret);
mi = helper.AddMethod(func, methodb); mi = helper.AddMethod(func, methodb);
mi.stand = true; mi.stand = true;
@ -7985,7 +7984,7 @@ namespace PascalABCCompiler.NETGenerator
il = methodb.GetILGenerator(); il = methodb.GetILGenerator();
il.Emit(OpCodes.Ldarg_0); il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldind_I); il.Emit(OpCodes.Ldind_I);
il.Emit(OpCodes.Call, typeof(Marshal).GetMethod("FreeHGlobal", new Type[1] { typeof(IntPtr) })); il.Emit(OpCodes.Call, TypeFactory.MarshalFreeHGlobalMethod);
il.Emit(OpCodes.Ldarg_0); il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldc_I4_0); il.Emit(OpCodes.Ldc_I4_0);
il.Emit(OpCodes.Stind_I); il.Emit(OpCodes.Stind_I);
@ -9356,7 +9355,7 @@ namespace PascalABCCompiler.NETGenerator
MethodInfo mi = null; MethodInfo mi = null;
if (real_parameters[0].type is IGenericTypeInstance) if (real_parameters[0].type is IGenericTypeInstance)
mi = TypeBuilder.GetMethod(ti.tp, typeof(Nullable<>).GetMethod("get_HasValue")); mi = TypeBuilder.GetMethod(ti.tp, TypeFactory.NullableHasValueGetMethod);
else else
mi = ti.tp.GetMethod("get_HasValue"); mi = ti.tp.GetMethod("get_HasValue");
il.Emit(OpCodes.Call, mi); il.Emit(OpCodes.Call, mi);
@ -9386,7 +9385,7 @@ namespace PascalABCCompiler.NETGenerator
il.Emit(OpCodes.Ldloca, tmp_lb); il.Emit(OpCodes.Ldloca, tmp_lb);
MethodInfo mi = null; MethodInfo mi = null;
if (real_parameters[1].type is IGenericTypeInstance) if (real_parameters[1].type is IGenericTypeInstance)
mi = TypeBuilder.GetMethod(ti.tp, typeof(Nullable<>).GetMethod("get_HasValue")); mi = TypeBuilder.GetMethod(ti.tp, TypeFactory.NullableHasValueGetMethod);
else else
mi = ti.tp.GetMethod("get_HasValue"); mi = ti.tp.GetMethod("get_HasValue");
il.Emit(OpCodes.Call, mi); il.Emit(OpCodes.Call, mi);
@ -9419,7 +9418,7 @@ namespace PascalABCCompiler.NETGenerator
il.Emit(OpCodes.Stloc, lb_left); il.Emit(OpCodes.Stloc, lb_left);
il.Emit(OpCodes.Ldloca, lb_left); il.Emit(OpCodes.Ldloca, lb_left);
if (real_parameters[0].type is IGenericTypeInstance) if (real_parameters[0].type is IGenericTypeInstance)
mi_left = TypeBuilder.GetMethod(ti_left.tp, typeof(Nullable<>).GetMethod("get_HasValue", new Type[] { })); mi_left = TypeBuilder.GetMethod(ti_left.tp, TypeFactory.NullableHasValueGetMethod);
else else
mi_left = ti_left.tp.GetMethod("get_HasValue", new Type[] { }); mi_left = ti_left.tp.GetMethod("get_HasValue", new Type[] { });
il.Emit(OpCodes.Call, mi_left); il.Emit(OpCodes.Call, mi_left);
@ -9431,7 +9430,7 @@ namespace PascalABCCompiler.NETGenerator
il.Emit(OpCodes.Stloc, lb_right); il.Emit(OpCodes.Stloc, lb_right);
il.Emit(OpCodes.Ldloca, lb_right); il.Emit(OpCodes.Ldloca, lb_right);
if (real_parameters[1].type is IGenericTypeInstance) if (real_parameters[1].type is IGenericTypeInstance)
mi_right = TypeBuilder.GetMethod(ti_right.tp, typeof(Nullable<>).GetMethod("get_HasValue", new Type[] { })); mi_right = TypeBuilder.GetMethod(ti_right.tp, TypeFactory.NullableHasValueGetMethod);
else else
mi_right = ti_right.tp.GetMethod("get_HasValue", new Type[] { }); mi_right = ti_right.tp.GetMethod("get_HasValue", new Type[] { });
@ -9469,14 +9468,14 @@ namespace PascalABCCompiler.NETGenerator
if (real_parameters[1] is IDefaultOperatorNode) if (real_parameters[1] is IDefaultOperatorNode)
{ {
if (real_parameters[0].type is IGenericTypeInstance) if (real_parameters[0].type is IGenericTypeInstance)
mi_left = TypeBuilder.GetMethod(ti_left.tp, typeof(Nullable<>).GetMethod("get_HasValue", new Type[] { })); mi_left = TypeBuilder.GetMethod(ti_left.tp, TypeFactory.NullableHasValueGetMethod);
else else
mi_left = ti_left.tp.GetMethod("get_HasValue", new Type[] { }); mi_left = ti_left.tp.GetMethod("get_HasValue", new Type[] { });
} }
else else
{ {
if (real_parameters[0].type is IGenericTypeInstance) if (real_parameters[0].type is IGenericTypeInstance)
mi_left = TypeBuilder.GetMethod(ti_left.tp, typeof(Nullable<>).GetMethod("GetValueOrDefault", new Type[] { })); mi_left = TypeBuilder.GetMethod(ti_left.tp, TypeFactory.NullableGetValueOrDefaultMethod);
else else
mi_left = ti_left.tp.GetMethod("GetValueOrDefault", new Type[] { }); mi_left = ti_left.tp.GetMethod("GetValueOrDefault", new Type[] { });
} }
@ -9492,14 +9491,14 @@ namespace PascalABCCompiler.NETGenerator
if (real_parameters[0] is IDefaultOperatorNode) if (real_parameters[0] is IDefaultOperatorNode)
{ {
if (real_parameters[1].type is IGenericTypeInstance) if (real_parameters[1].type is IGenericTypeInstance)
mi_right = TypeBuilder.GetMethod(ti_right.tp, typeof(Nullable<>).GetMethod("get_HasValue", new Type[] { })); mi_right = TypeBuilder.GetMethod(ti_right.tp, TypeFactory.NullableHasValueGetMethod);
else else
mi_right = ti_right.tp.GetMethod("get_HasValue", new Type[] { }); mi_right = ti_right.tp.GetMethod("get_HasValue", new Type[] { });
} }
else else
{ {
if (real_parameters[1].type is IGenericTypeInstance) if (real_parameters[1].type is IGenericTypeInstance)
mi_right = TypeBuilder.GetMethod(ti_right.tp, typeof(Nullable<>).GetMethod("GetValueOrDefault", new Type[] { })); mi_right = TypeBuilder.GetMethod(ti_right.tp, TypeFactory.NullableGetValueOrDefaultMethod);
else else
mi_right = ti_right.tp.GetMethod("GetValueOrDefault", new Type[] { }); mi_right = ti_right.tp.GetMethod("GetValueOrDefault", new Type[] { });
} }
@ -10292,7 +10291,7 @@ namespace PascalABCCompiler.NETGenerator
il.Emit(OpCodes.Add); il.Emit(OpCodes.Add);
il.Emit(OpCodes.Br, ok_lbl); il.Emit(OpCodes.Br, ok_lbl);
il.MarkLabel(except_lbl); il.MarkLabel(except_lbl);
il.Emit(OpCodes.Newobj, TypeFactory.IndexOutOfRangeConstructor); il.Emit(OpCodes.Newobj, TypeFactory.IndexOutOfRangeCtor);
il.Emit(OpCodes.Throw); il.Emit(OpCodes.Throw);
il.MarkLabel(ok_lbl); il.MarkLabel(ok_lbl);
} }
@ -10494,7 +10493,7 @@ namespace PascalABCCompiler.NETGenerator
public void ConvertGenericParamCtorCall(ICommonConstructorCall value) public void ConvertGenericParamCtorCall(ICommonConstructorCall value)
{ {
Type gpar = helper.GetTypeReference(value.common_type).tp; Type gpar = helper.GetTypeReference(value.common_type).tp;
MethodInfo create_inst = ActivatorCreateInstance.MakeGenericMethod(gpar); MethodInfo create_inst = TypeFactory.ActivatorCreateInstanceMethod.MakeGenericMethod(gpar);
il.EmitCall(OpCodes.Call, create_inst, Type.EmptyTypes); il.EmitCall(OpCodes.Call, create_inst, Type.EmptyTypes);
} }
@ -11163,7 +11162,7 @@ namespace PascalABCCompiler.NETGenerator
MethodInfo mi = null; MethodInfo mi = null;
TypeInfo cond_ti = helper.GetTypeReference(value.condition.type); TypeInfo cond_ti = helper.GetTypeReference(value.condition.type);
if (value.condition.type is IGenericTypeInstance) if (value.condition.type is IGenericTypeInstance)
mi = TypeBuilder.GetMethod(cond_ti.tp, typeof(Nullable<>).GetMethod("get_HasValue")); mi = TypeBuilder.GetMethod(cond_ti.tp, TypeFactory.NullableHasValueGetMethod);
else else
mi = cond_ti.tp.GetMethod("get_HasValue"); mi = cond_ti.tp.GetMethod("get_HasValue");
il.Emit(OpCodes.Call, mi); il.Emit(OpCodes.Call, mi);
@ -11460,10 +11459,10 @@ namespace PascalABCCompiler.NETGenerator
private void PushRuntimeSize(Type t) private void PushRuntimeSize(Type t)
{ {
if (!t.IsValueType) if (!t.IsValueType)
t = TypeFactory.IntPtr; t = TypeFactory.IntPtrType;
if (t == TypeFactory.IntPtr) if (t == TypeFactory.IntPtrType)
{ {
il.Emit(OpCodes.Call, typeof(Environment).GetProperty("Is64BitProcess", BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy).GetGetMethod()); il.Emit(OpCodes.Call, TypeFactory.EnvironmentIs64BitProcessGetMethod);
Label brf = il.DefineLabel(); Label brf = il.DefineLabel();
Label bre = il.DefineLabel(); Label bre = il.DefineLabel();
il.Emit(OpCodes.Brfalse_S, brf); il.Emit(OpCodes.Brfalse_S, brf);
@ -11477,10 +11476,8 @@ namespace PascalABCCompiler.NETGenerator
{ {
//il.Emit(OpCodes.Ldtoken, t); //il.Emit(OpCodes.Ldtoken, t);
NETGeneratorTools.PushTypeOf(il, t); NETGeneratorTools.PushTypeOf(il, t);
Type typ = TypeFactory.MarshalType;
Type[] prms = new Type[1]; il.EmitCall(OpCodes.Call, TypeFactory.MarshalSizeOfMethod, null);
prms[0] = typeof(Type);
il.EmitCall(OpCodes.Call, typ.GetMethod("SizeOf", prms), null);
} }
return; return;
} }
@ -11494,7 +11491,7 @@ namespace PascalABCCompiler.NETGenerator
{ {
//void.System.Runtime.InteropServices.Marshal.SizeOf() //void.System.Runtime.InteropServices.Marshal.SizeOf()
Type tp = helper.GetTypeReference(value.oftype).tp; Type tp = helper.GetTypeReference(value.oftype).tp;
if (tp.IsPrimitive && tp != typeof(System.IntPtr) && tp != typeof(System.UIntPtr)) if (tp.IsPrimitive && tp != TypeFactory.IntPtrType && tp != TypeFactory.UIntPtrType)
{ {
PushIntConst(TypeFactory.GetPrimitiveTypeSize(tp)); PushIntConst(TypeFactory.GetPrimitiveTypeSize(tp));
return; return;
@ -11609,18 +11606,18 @@ namespace PascalABCCompiler.NETGenerator
{ {
switch (Type.GetTypeCode(t)) switch (Type.GetTypeCode(t))
{ {
case TypeCode.Byte: il.Emit(OpCodes.Call, TypeFactory.ConvertType.GetMethod("ToByte", new Type[1] { TypeFactory.ObjectType })); break; case TypeCode.Byte: il.Emit(OpCodes.Call, TypeFactory.ConvertToByteMethod); break;
case TypeCode.SByte: il.Emit(OpCodes.Call, TypeFactory.ConvertType.GetMethod("ToSByte", new Type[1] { TypeFactory.ObjectType })); break; case TypeCode.SByte: il.Emit(OpCodes.Call, TypeFactory.ConvertToSByteMethod); break;
case TypeCode.Int16: il.Emit(OpCodes.Call, TypeFactory.ConvertType.GetMethod("ToInt16", new Type[1] { TypeFactory.ObjectType })); break; case TypeCode.Int16: il.Emit(OpCodes.Call, TypeFactory.ConvertToInt16Method); break;
case TypeCode.UInt16: il.Emit(OpCodes.Call, TypeFactory.ConvertType.GetMethod("ToUInt16", new Type[1] { TypeFactory.ObjectType })); break; case TypeCode.UInt16: il.Emit(OpCodes.Call, TypeFactory.ConvertToUInt16Method); break;
case TypeCode.Int32: il.Emit(OpCodes.Call, TypeFactory.ConvertType.GetMethod("ToInt32", new Type[1] { TypeFactory.ObjectType })); break; case TypeCode.Int32: il.Emit(OpCodes.Call, TypeFactory.ConvertToInt32Method); break;
case TypeCode.UInt32: il.Emit(OpCodes.Call, TypeFactory.ConvertType.GetMethod("ToUInt32", new Type[1] { TypeFactory.ObjectType })); break; case TypeCode.UInt32: il.Emit(OpCodes.Call, TypeFactory.ConvertToUInt32Method); break;
case TypeCode.Int64: il.Emit(OpCodes.Call, TypeFactory.ConvertType.GetMethod("ToInt64", new Type[1] { TypeFactory.ObjectType })); break; case TypeCode.Int64: il.Emit(OpCodes.Call, TypeFactory.ConvertToInt64Method); break;
case TypeCode.UInt64: il.Emit(OpCodes.Call, TypeFactory.ConvertType.GetMethod("ToUInt64", new Type[1] { TypeFactory.ObjectType })); break; case TypeCode.UInt64: il.Emit(OpCodes.Call, TypeFactory.ConvertToUInt64Method); break;
case TypeCode.Char: il.Emit(OpCodes.Call, TypeFactory.ConvertType.GetMethod("ToChar", new Type[1] { TypeFactory.ObjectType })); break; case TypeCode.Char: il.Emit(OpCodes.Call, TypeFactory.ConvertToCharMethod); break;
case TypeCode.Boolean: il.Emit(OpCodes.Call, TypeFactory.ConvertType.GetMethod("ToBoolean", new Type[1] { TypeFactory.ObjectType })); break; case TypeCode.Boolean: il.Emit(OpCodes.Call, TypeFactory.ConvertToBooleanMethod); break;
case TypeCode.Double: il.Emit(OpCodes.Call, TypeFactory.ConvertType.GetMethod("ToDouble", new Type[1] { TypeFactory.ObjectType })); break; case TypeCode.Double: il.Emit(OpCodes.Call, TypeFactory.ConvertToDoubleMethod); break;
case TypeCode.Single: il.Emit(OpCodes.Call, TypeFactory.ConvertType.GetMethod("ToSingle", new Type[1] { TypeFactory.ObjectType })); break; case TypeCode.Single: il.Emit(OpCodes.Call, TypeFactory.ConvertToSingleMethod); break;
default: il.Emit(OpCodes.Unbox_Any, t); break; default: il.Emit(OpCodes.Unbox_Any, t); break;
} }
} }
@ -11646,7 +11643,7 @@ namespace PascalABCCompiler.NETGenerator
{ {
enumer_mi = TypeBuilder.GetMethod( enumer_mi = TypeBuilder.GetMethod(
TypeFactory.IEnumerableGenericType.MakeGenericType(elementType), TypeFactory.IEnumerableGenericType.MakeGenericType(elementType),
TypeFactory.IEnumerableGenericType.GetMethod("GetEnumerator") TypeFactory.IEnumerableGenericGetEnumeratorMethod
); );
// IEnumerator<elementType> // IEnumerator<elementType>
@ -11664,7 +11661,7 @@ namespace PascalABCCompiler.NETGenerator
} }
else else
{ {
enumer_mi = TypeFactory.IEnumerableType.GetMethod("GetEnumerator"); enumer_mi = TypeFactory.IEnumerableGetEnumeratorMethod;
return_type = enumer_mi.ReturnType; return_type = enumer_mi.ReturnType;
} }
@ -11754,7 +11751,7 @@ namespace PascalABCCompiler.NETGenerator
il.Emit(OpCodes.Ldloca, lb); il.Emit(OpCodes.Ldloca, lb);
else else
il.Emit(OpCodes.Ldloc, lb); il.Emit(OpCodes.Ldloc, lb);
il.Emit(OpCodes.Callvirt, TypeFactory.IEnumeratorType.GetMethod("MoveNext", BindingFlags.Instance | BindingFlags.Public)); il.Emit(OpCodes.Callvirt, TypeFactory.IEnumeratorMoveNextMethod);
il.Emit(OpCodes.Brtrue, l1); il.Emit(OpCodes.Brtrue, l1);
//il.Emit(OpCodes.Leave, leave_label); //il.Emit(OpCodes.Leave, leave_label);
il.BeginFinallyBlock(); il.BeginFinallyBlock();
@ -11773,7 +11770,7 @@ namespace PascalABCCompiler.NETGenerator
il.Emit(OpCodes.Ldloca, lb); il.Emit(OpCodes.Ldloca, lb);
else else
il.Emit(OpCodes.Ldloc, lb); il.Emit(OpCodes.Ldloc, lb);
il.Emit(OpCodes.Callvirt, TypeFactory.IDisposableType.GetMethod("Dispose", BindingFlags.Instance | BindingFlags.Public)); il.Emit(OpCodes.Callvirt, TypeFactory.IDisposableDisposeMethod);
} }
il.EndExceptionBlock(); il.EndExceptionBlock();
@ -11790,8 +11787,8 @@ namespace PascalABCCompiler.NETGenerator
{ {
if (_monitor_enter == null) if (_monitor_enter == null)
{ {
_monitor_enter = TypeFactory.MonitorType.GetMethod("Enter", new Type[1] { TypeFactory.ObjectType }); _monitor_enter = TypeFactory.MonitorEnterMethod;
_monitor_exit = TypeFactory.MonitorType.GetMethod("Exit", new Type[1] { TypeFactory.ObjectType }); _monitor_exit = TypeFactory.MonitorExitMethod;
} }
LocalBuilder lb = il.DeclareLocal(TypeFactory.ObjectType); LocalBuilder lb = il.DeclareLocal(TypeFactory.ObjectType);
value.LockObject.visit(this); value.LockObject.visit(this);