MethodImpl CreateMethod()
{
var parameters = new List <Component_MemberParameter>();
foreach (var p in GetComponents <Component_MemberParameter>(false, false))
{
if (p.Enabled)
{
parameters.Add(p);
}
}
var parameters2 = new List <Metadata.Parameter>();
foreach (var p in parameters)
{
Metadata.Parameter p2 = p.CreateMetadataParameter();
if (p2 == null)
{
//!!!!
return(null);
}
parameters2.Add(p2);
}
//!!!!isConstructor
//!!!!isOperator
var method = new MethodImpl(Parent, Name, Static, parameters2.ToArray(), false, false, this);
method.Description = Description;
return(method);
}
public CCodeNewOperatorWithSizeDeclaration(INamedTypeSymbol type)
: base(new NewOperatorMethod(type))
{
var parameterSymbol = new ParameterImpl {
Name = "_customSize"
};
var parameter = new Parameter {
ParameterSymbol = parameterSymbol
};
var methodSymbol = new MethodImpl {
Name = "__new_set0", MethodKind = MethodKind.BuiltinOperator, Parameters = ImmutableArray.Create <IParameterSymbol>(parameterSymbol)
};
MethodBodyOpt = new MethodBody(Method)
{
Statements =
{
new ReturnStatement {
ExpressionOpt = new Call{
Method = methodSymbol, Arguments ={ parameter }
}
}
}
};
}
public void MethodImplEntry()
{
var text = @"
public class A
{
~A() { }
}
";
CompileAndVerify(text, assemblyValidator: (assembly, _) =>
{
var peFileReader = assembly.GetMetadataReader();
// Find the handle and row for A.
var pairA = peFileReader.TypeDefinitions.AsEnumerable().
Select(handle => new { handle = handle, row = peFileReader.GetTypeDefinition(handle) }).
Single(pair => peFileReader.GetString(pair.row.Name) == "A" &&
string.IsNullOrEmpty(peFileReader.GetString(pair.row.Namespace)));
TypeHandle handleA = pairA.handle;
TypeDefinition typeA = pairA.row;
// Find the handle for A's destructor.
MethodHandle handleDestructorA = typeA.GetMethods().AsEnumerable().
Single(handle => peFileReader.GetString(peFileReader.GetMethod(handle).Name) == WellKnownMemberNames.DestructorName);
// Find the handle for System.Object.
TypeReferenceHandle handleObject = peFileReader.TypeReferences.AsEnumerable().
Select(handle => new { handle = handle, row = peFileReader.GetTypeReference(handle) }).
Single(pair => peFileReader.GetString(pair.row.Name) == "Object" &&
peFileReader.GetString(pair.row.Namespace) == "System").handle;
// Find the handle for System.Object's destructor.
MemberReferenceHandle handleDestructorObject = peFileReader.MemberReferences.AsEnumerable().
Select(handle => new { handle = handle, row = peFileReader.GetMemberReference(handle) }).
Single(pair => pair.row.Parent == (Handle)handleObject &&
peFileReader.GetString(pair.row.Name) == WellKnownMemberNames.DestructorName).handle;
// Find the MethodImpl row for A.
MethodImpl methodImpl = typeA.GetMethodImplementations().AsEnumerable().
Select(handle => peFileReader.GetMethodImplementation(handle)).
Single();
// The Class column should point to A.
Assert.Equal(handleA, methodImpl.Type);
// The MethodDeclaration column should point to System.Object.Finalize.
Assert.Equal((Handle)handleDestructorObject, methodImpl.MethodDeclaration);
// The MethodDeclarationColumn should point to A's destructor.
Assert.Equal((Handle)handleDestructorA, methodImpl.MethodBody);
});
}
// Virtual function related functionality
public override MethodImplRecord[] FindMethodsImplWithMatchingDeclName(string declName)
{
MetadataReader metadataReader = _metadataUnit.MetadataReader;
ArrayBuilder <MethodImplRecord> foundRecords = new ArrayBuilder <MethodImplRecord>();
foreach (var methodImplHandle in _typeDefinition.MethodImpls)
{
MethodImpl methodImpl = metadataReader.GetMethodImpl(methodImplHandle);
Handle methodDeclCheckHandle = methodImpl.MethodDeclaration;
HandleType methodDeclHandleType = methodDeclCheckHandle.HandleType;
bool foundRecord = false;
switch (methodDeclHandleType)
{
case HandleType.QualifiedMethod:
QualifiedMethod qualifiedMethod = metadataReader.GetQualifiedMethod(methodDeclCheckHandle.ToQualifiedMethodHandle(metadataReader));
Method method = qualifiedMethod.Method.GetMethod(metadataReader);
if (method.Name.StringEquals(declName, metadataReader))
{
foundRecord = true;
}
break;
case HandleType.MemberReference:
{
MemberReference memberRef = metadataReader.GetMemberReference(methodDeclCheckHandle.ToMemberReferenceHandle(metadataReader));
if (memberRef.Name.StringEquals(declName, metadataReader))
{
foundRecord = true;
}
}
break;
}
if (foundRecord)
{
MethodDesc newRecordDecl = (MethodDesc)_metadataUnit.GetObject(methodImpl.MethodDeclaration, null);
MethodDesc newRecordBody = (MethodDesc)_metadataUnit.GetObject(methodImpl.MethodBody, null);
foundRecords.Add(new MethodImplRecord(newRecordDecl, newRecordBody));
}
}
if (foundRecords.Count != 0)
{
return(foundRecords.ToArray());
}
return(null);
}
/// <summary>
/// </summary>
/// <param name="static">
/// </param>
/// <returns>
/// </returns>
public IMethodSymbol GetNewMethod(bool @static = false, bool doNotMergeTemplateParameters = false)
{
var typeSymbol = (INamedTypeSymbol)Type;
var methodImpl = new MethodImpl
{
Name = string.Concat(typeSymbol.GetTypeName(), "_delegate_new", @static ? "_static" : string.Empty),
ReturnType = typeSymbol,
ReturnsVoid = false,
IsGenericMethod = typeSymbol.IsGenericType,
ContainingNamespace = typeSymbol.ContainingNamespace,
};
if (@static)
{
methodImpl.Parameters =
ImmutableArray.Create <IParameterSymbol>(
new ParameterImpl {
Name = "m", Type = new TypeImpl {
Name = "_Memptr", TypeKind = TypeKind.TypeParameter
}
});
}
else
{
methodImpl.Parameters =
ImmutableArray.Create <IParameterSymbol>(
new ParameterImpl {
Name = "t", Type = new TypeImpl {
Name = "_T", TypeKind = TypeKind.TypeParameter
}
},
new ParameterImpl {
Name = "m", Type = new TypeImpl {
Name = "_Memptr", TypeKind = TypeKind.TypeParameter
}
});
}
if (doNotMergeTemplateParameters)
{
methodImpl.TypeArguments = ImmutableArray.CreateRange(typeSymbol.GetTemplateArguments());
methodImpl.TypeParameters = ImmutableArray.CreateRange(typeSymbol.GetTemplateParameters());
}
else
{
methodImpl.IsGenericMethod = true;
methodImpl.TypeArguments = ImmutableArray.CreateRange(typeSymbol.GetTemplateArguments().Union(GetNewMethodTypeGeneric(@static)));
methodImpl.TypeParameters = ImmutableArray.CreateRange(typeSymbol.GetTemplateParameters().Union(GetNewMethodTypeParameterGeneric(@static)));
}
return(methodImpl);
}
void Clear()
{
compiledCode = "";
compiledScript = null;
compiledMembers.Clear();
compiledMemberBySignature.Clear();
//One method mode
compiledOneMethod = null;
properties.Clear();
propertyBySignature.Clear();
propertyMethodParameters = null;
propertyMethodReturnParameter = null;
// clear cached texture for flow graph
cachedFlowGraphNodeImage?.Dispose();
cachedFlowGraphNodeImage = null;
}
protected override MethodImplRecord[] ComputeVirtualMethodImplsForType()
{
ArrayBuilder <MethodImplRecord> records = new ArrayBuilder <MethodImplRecord>();
MetadataReader metadataReader = _metadataUnit.MetadataReader;
foreach (var methodImplHandle in _typeDefinition.MethodImpls)
{
MethodImpl methodImpl = metadataReader.GetMethodImpl(methodImplHandle);
Handle methodDeclCheckHandle = methodImpl.MethodDeclaration;
HandleType methodDeclHandleType = methodDeclCheckHandle.HandleType;
MetadataType owningType = null;
switch (methodDeclHandleType)
{
case HandleType.QualifiedMethod:
QualifiedMethod qualifiedMethod = metadataReader.GetQualifiedMethod(methodDeclCheckHandle.ToQualifiedMethodHandle(metadataReader));
owningType = (MetadataType)_metadataUnit.GetType(qualifiedMethod.EnclosingType);
break;
case HandleType.MemberReference:
Handle owningTypeHandle = metadataReader.GetMemberReference(methodDeclCheckHandle.ToMemberReferenceHandle(metadataReader)).Parent;
owningType = _metadataUnit.GetType(owningTypeHandle) as MetadataType;
break;
default:
Debug.Assert(false, "unexpected methodDeclHandleType");
break;
}
// We want to check that the type is not an interface match before actually getting the MethodDesc.
if (!owningType.IsInterface)
{
MethodDesc newRecordDecl = (MethodDesc)_metadataUnit.GetObject(methodImpl.MethodDeclaration, null);
MethodDesc newRecordBody = (MethodDesc)_metadataUnit.GetObject(methodImpl.MethodBody, null);
records.Add(new MethodImplRecord(newRecordDecl, newRecordBody));
}
}
return(records.ToArray());
}
internal void CalcElemSize()
{
elemSize[(int)MDTable.Assembly] = Assembly.Size(this);
elemSize[(int)MDTable.AssemblyOS] = 12;
elemSize[(int)MDTable.AssemblyProcessor] = 4;
elemSize[(int)MDTable.AssemblyRefOS] = 12 + TableIndexSize(MDTable.AssemblyRef);
elemSize[(int)MDTable.AssemblyRefProcessor] = 4 + TableIndexSize(MDTable.AssemblyRef);
elemSize[(int)MDTable.Module] = Module.Size(this);
elemSize[(int)MDTable.TypeRef] = ClassRef.Size(this);
elemSize[(int)MDTable.TypeDef] = ClassDef.Size(this);
elemSize[(int)MDTable.Field] = FieldDef.Size(this);
elemSize[(int)MDTable.Method] = MethodDef.Size(this);
elemSize[(int)MDTable.Param] = Param.Size(this);
elemSize[(int)MDTable.InterfaceImpl] = InterfaceImpl.Size(this);
elemSize[(int)MDTable.MemberRef] = FieldRef.Size(this);
elemSize[(int)MDTable.Constant] = ConstantElem.Size(this);
elemSize[(int)MDTable.CustomAttribute] = CustomAttribute.Size(this);
elemSize[(int)MDTable.FieldMarshal] = FieldMarshal.Size(this);
elemSize[(int)MDTable.DeclSecurity] = DeclSecurity.Size(this);
elemSize[(int)MDTable.ClassLayout] = ClassLayout.Size(this);
elemSize[(int)MDTable.FieldLayout] = FieldLayout.Size(this);
elemSize[(int)MDTable.StandAloneSig] = Signature.Size(this);
elemSize[(int)MDTable.EventMap] = MapElem.Size(this, MDTable.EventMap);
elemSize[(int)MDTable.Event] = Event.Size(this);
elemSize[(int)MDTable.PropertyMap] = MapElem.Size(this, MDTable.PropertyMap);
elemSize[(int)MDTable.Property] = Property.Size(this);
elemSize[(int)MDTable.MethodSemantics] = MethodSemantics.Size(this);
elemSize[(int)MDTable.MethodImpl] = MethodImpl.Size(this);
elemSize[(int)MDTable.ModuleRef] = ModuleRef.Size(this);
elemSize[(int)MDTable.TypeSpec] = TypeSpec.Size(this);
elemSize[(int)MDTable.ImplMap] = ImplMap.Size(this);
elemSize[(int)MDTable.FieldRVA] = FieldRVA.Size(this);
elemSize[(int)MDTable.Assembly] = Assembly.Size(this);
elemSize[(int)MDTable.AssemblyRef] = AssemblyRef.Size(this);
elemSize[(int)MDTable.File] = FileRef.Size(this);
elemSize[(int)MDTable.ExportedType] = ExternClass.Size(this);
elemSize[(int)MDTable.ManifestResource] = ManifestResource.Size(this);
elemSize[(int)MDTable.NestedClass] = MapElem.Size(this, MDTable.NestedClass);
elemSize[(int)MDTable.GenericParam] = GenericParam.Size(this);
elemSize[(int)MDTable.GenericParamConstraint] = GenericParamConstraint.Size(this);
elemSize[(int)MDTable.MethodSpec] = MethodSpec.Size(this);
}
void OneMethod_AddProperties(MethodImpl method)
{
//parameters
propertyMethodParameters = new List <MethodParameterPropertyImpl>();
foreach (var parameter in method.Parameters)
{
var prop = OneMethod_AddPropertyOfParameter(parameter);
properties.Add(prop);
propertyBySignature[prop.Signature] = prop;
//!!!!так? если несколько?
if (parameter.ReturnValue)
{
propertyMethodReturnParameter = prop;
}
else
{
propertyMethodParameters.Add(prop);
}
}
}
internal MTMessagesContainer this$0;
[MethodImpl(MethodImplOptions.NoInlining), LineNumberTable(0x1a)]
internal void AddMethodImpl(MethodImpl impl)
{
Contract.Requires(impl != null);
methodImpls.Add(impl);
}
public void RemoveMethodOverride(MethodImpl mImpl)
{
Contract.Requires(mImpl != null);
if (methodImpls != null)
methodImpls.Remove(mImpl);
}
public void AddMethodOverride(MethodImpl mImpl)
{
methodImpls.Add(mImpl);
mImpl.SetOwner(this);
}
internal TransportRate this$0;
[MethodImpl(MethodImplOptions.NoInlining), LineNumberTable(new byte[] { 0x1d, 0x6f, 0x67, 0x68 })]
internal void ReadMethodImpls(ClassDef theClass, uint classIx)
{
Contract.Requires(theClass != null);
SetElementPosition(MDTable.InterfaceImpl, 0);
for (int i = 0; (i < tableLengths[(int)MDTable.MethodImpl]); i++)
{
uint clIx = GetIndex(MDTable.TypeDef);
uint bodIx = GetCodedIndex(CIx.MethodDefOrRef);
uint declIx = GetCodedIndex(CIx.MethodDefOrRef);
if (clIx == classIx)
{
MethodImpl mImpl = new MethodImpl(this, theClass, bodIx, declIx);
theClass.AddMethodImpl(mImpl);
tables[(int)MDTable.MethodImpl][i] = mImpl;
}
}
}
internal static void Read(PEReader buff, TableRow[] impls)
{
Contract.Requires(buff != null);
Contract.Requires(impls != null);
for (int i = 0; i < impls.Length; i++)
impls[i] = new MethodImpl(buff);
}
private MethodDefTreatment ComputeMethodDefTreatment(MethodHandle methodDef)
{
MethodDefTreatment treatment = MethodDefTreatment.Implementation;
TypeDefinition parentType = peFileReader.GetTypeDefinition(peFileReader.FindMethodContainer(methodDef));
TypeAttributes parentFlags = parentType.Flags;
if (parentFlags.IsWindowsRuntime())
{
if (IsClrImplementationType(peFileReader.StringStream[parentType.Name], parentFlags))
{
treatment = MethodDefTreatment.Implementation;
}
else if (parentFlags.IsNested())
{
treatment = MethodDefTreatment.Implementation;
}
else if (parentFlags.IsInterface())
{
treatment = MethodDefTreatment.Interface;
}
else if (scenario == WinMDScenario.WinMDExp &&
!parentFlags.IsPublic())
{
treatment = MethodDefTreatment.Implementation;
}
else
{
treatment = MethodDefTreatment.Other;
var parentBaseType = parentType.BaseType;
if (HandleType.TypeReference == parentBaseType.HandleType)
{
switch (GetTypeRefTreatment((TypeReferenceHandle)parentBaseType))
{
case TypeRefTreatment.SystemAttribute:
treatment = MethodDefTreatment.Attribute;
break;
case TypeRefTreatment.SystemDelegate:
treatment = MethodDefTreatment.Delegate;
break;
}
}
}
}
if (treatment == MethodDefTreatment.Other)
{
// we want to hide the method if it implements
// only redirected interfaces
// We also want to check if the methodImpl is IClosable.Close,
// so we can change the name
bool seenRedirectedInterfaces = false;
bool seenNonRedirectedInterfaces = false;
bool isIClosableClose = false;
foreach (var methodImplHandle in parentType.GetMethodImplementations())
{
MethodImpl methodImpl = peFileReader.GetMethodImplementation(methodImplHandle);
if (methodImpl.MethodBody == methodDef)
{
MetadataToken declaration = methodImpl.MethodDeclaration;
// See if this MethodImpl implements a redirected interface
// In WinMD, MethodImpl will always use MemberRef and TypeRefs to refer to redirected interfaces,
// even if they are in the same module.
if (declaration.HandleType == HandleType.MemberReference &&
ImplementsRedirectedInterface((MemberReferenceHandle)declaration, out isIClosableClose))
{
seenRedirectedInterfaces = true;
if (isIClosableClose)
{
// This method implements IClosable.Close
// Let's rename to IDisposable later
// Once we know this implements IClosable.Close, we are done
// looking
break;
}
}
else
{
// Now we know this implements a non-redirected interface
// But we need to keep looking, just in case we got a methodimpl that
// implements the IClosable.Close method and needs to be renamed
seenNonRedirectedInterfaces = true;
}
}
}
if (isIClosableClose)
{
treatment = MethodDefTreatment.RenameToDisposeMethod;
}
else if (seenRedirectedInterfaces && !seenNonRedirectedInterfaces)
{
// Only hide if all the interfaces implemented are redirected
treatment = MethodDefTreatment.HiddenImpl;
}
}
// If treatment is other, then this is a non-managed WinRT runtime class definition
// Find out about various bits that we apply via attributes and name parsing
if (treatment == MethodDefTreatment.Other)
{
treatment |= GetMethodTreatmentFromCustomAttributes(methodDef);
Method method = peFileReader.GetMethod(methodDef);
if (method.Flags != MethodAttributes.SpecialName)
{
StringHandle methodName = method.Name;
if (peFileReader.StringStream.StartsWith(methodName, OperatorPrefixUtf8))
{
// TODO (tomat): consider avoiding name allocation by encoding the operator names in UTF8
string nameAfterOp = peFileReader.StringStream.GetSuffix(methodName, OperatorPrefixUtf8.Length);
if (Array.BinarySearch <string>(operatorNames, nameAfterOp) < 0)
{
treatment |= MethodDefTreatment.MarkSpecialName;
}
}
}
}
return(treatment);
}
public Tabels(PEFile p)
{
//Init
this.r = p.MetadataReader;
//Read all of the tabels
ModuleTabel = new List <Module>();
TypeRefTabel = new List <TypeRef>();
TypeDefTabel = new List <TypeDef>();
FieldTabel = new List <Field>();
MethodTabel = new List <Method>();
ParmTabel = new List <Param>();
InterfaceImplTable = new List <InterfaceImpl>();
MemberRefTabelRow = new List <MemberRef>();
ConstantTabel = new List <Constant>();
CustomAttributeTabel = new List <CustomAttribute>();
FieldMarshalTabel = new List <FieldMarshal>();
DeclSecurityTabel = new List <DeclSecurity>();
ClassLayoutTabel = new List <ClassLayout>();
FieldLayoutTabel = new List <FieldLayout>();
StandAloneSigTabel = new List <StandAloneSig>();
EventMapTabel = new List <EventMap>();
EventTabel = new List <Event>();
PropertyMapTabel = new List <PropertyMap>();
PropertyTabel = new List <PropertyTabel>();
MethodSemanticsTabel = new List <MethodSemantics>();
MethodImplTabel = new List <MethodImpl>();
ModuleRefTabel = new List <ModuleRef>();
TypeSpecTabel = new List <TypeSpec>();
ImplMapTabel = new List <ImplMap>();
FieldRVATabel = new List <FieldRVA>();
AssemblyTabel = new List <Assembly>();
AssemblyRefTabel = new List <AssemblyRef>();
FileTable = new List <File>();
ExportedTypeTable = new List <ExportedType>();
ManifestResourceTable = new List <ManifestResource>();
NestedClassTable = new List <NestedClass>();
GenericParamTable = new List <GenericParam>();
MethodSpecTable = new List <MethodSpec>();
int a = 0;
//Read module Tabel (if any)
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.Module) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new Module();
m.Read(r);
ModuleTabel.Add(m);
}
a++;
}
//Read TypeRef Tabel
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.TypeRef) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new TypeRef();
m.Read(r);
TypeRefTabel.Add(m);
}
a++;
}
//Read TypeDef Tabel
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.TypeDef) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new TypeDef();
m.Read(r);
TypeDefTabel.Add(m);
}
a++;
}
//Read Field Tabel
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.Field) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new Field();
m.Read(r);
FieldTabel.Add(m);
}
a++;
}
//Read Method tabel
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.Method) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new Method();
m.Read(r);
MethodTabel.Add(m);
}
a++;
}
//Read Parm Tabel
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.Param) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new Param();
m.Read(r);
ParmTabel.Add(m);
}
a++;
}
//Read interfaceimpl Tabel
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.InterfaceImpl) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new InterfaceImpl();
m.Read(r);
InterfaceImplTable.Add(m);
}
a++;
}
//Read MemberRef tabel
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.MemberRef) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new MemberRef();
m.Read(r);
MemberRefTabelRow.Add(m);
}
a++;
}
//Read Constant tabel
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.Constant) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new Constant();
m.Read(r);
ConstantTabel.Add(m);
}
a++;
}
//Read CustomAttribute tabel
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.CustomAttribute) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new CustomAttribute();
m.Read(r);
CustomAttributeTabel.Add(m);
}
a++;
}
//Read FieldMarshal tabel (Please test)
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.FieldMarshal) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new FieldMarshal();
m.Read(r);
FieldMarshalTabel.Add(m);
}
a++;
}
//Read DeclSecurity tabel
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.DeclSecurity) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new DeclSecurity();
m.Read(r);
DeclSecurityTabel.Add(m);
}
a++;
}
//Read ClassLayout tabel
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.ClassLayout) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new ClassLayout();
m.Read(r);
ClassLayoutTabel.Add(m);
}
a++;
}
//Read FieldLayout tabel
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.FieldLayout) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new FieldLayout();
m.Read(r);
FieldLayoutTabel.Add(m);
}
a++;
}
//Read StandAloneSig tabel
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.StandAloneSig) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new StandAloneSig();
m.Read(r);
StandAloneSigTabel.Add(m);
}
a++;
}
//Read EventMap tabel (please test)
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.EventMap) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new EventMap();
m.Read(r);
EventMapTabel.Add(m);
}
a++;
}
//Read event tabel
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.Event) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new Event();
m.Read(r);
EventTabel.Add(m);
}
a++;
}
//Read Property Map tabel
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.PropertyMap) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new PropertyMap();
m.Read(r);
PropertyMapTabel.Add(m);
}
a++;
}
//Read Property tabel
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.Property) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new PropertyTabel();
m.Read(r);
PropertyTabel.Add(m);
}
a++;
}
//Read MethodSemantics tabel
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.MethodSemantics) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new MethodSemantics();
m.Read(r);
MethodSemanticsTabel.Add(m);
}
a++;
}
//Read MethodImpl tabel (Please test)
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.MethodImpl) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new MethodImpl();
m.Read(r);
MethodImplTabel.Add(m);
}
a++;
}
//Read ModuleRef tabel (pls test)
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.ModuleRef) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new ModuleRef();
m.Read(r);
ModuleRefTabel.Add(m);
}
a++;
}
//Read TypeSpec tabel (pls test)
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.TypeSpec) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new TypeSpec();
m.Read(r);
TypeSpecTabel.Add(m);
}
a++;
}
//Read ImplMap tabel (pls test)
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.ImplMap) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new ImplMap();
m.Read(r);
ImplMapTabel.Add(m);
}
a++;
}
//Read FieldRVA tabel (pls test)
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.FieldRVA) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new FieldRVA();
m.Read(r);
FieldRVATabel.Add(m);
}
a++;
}
//Read Assembly tabel (pls test)
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.Assembly) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new Assembly();
m.Read(r);
AssemblyTabel.Add(m);
}
a++;
}
//Read ignored tabels (These never should be present!)
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.AssemblyProcessor) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var proc = r.ReadUInt32();
}
a++;
}
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.AssemblyOS) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
r.BaseStream.Position += 11; //Test please
}
a++;
}
//Read AssemblyRef Tabel
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.AssemblyRef) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new AssemblyRef();
m.Read(r);
AssemblyRefTabel.Add(m);
}
a++;
}
//Read AssemblyRefProcessor Tabel
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.AssemblyRefProcessor) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
r.BaseStream.Position += 8; //Test please
}
a++;
}
//Read AssemblyRefOS Tabel
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.AssemblyRefOS) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
r.BaseStream.Position += 16; //Test please
}
a++;
}
//Read File Tabel
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.File) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new File();
m.Read(r);
FileTable.Add(m);
}
a++;
}
//Read ExportedType Tabel
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.ExportedType) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new ExportedType();
m.Read(r);
ExportedTypeTable.Add(m);
}
a++;
}
//Read ManifestResource Tabel
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.ManifestResource) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new ManifestResource();
m.Read(r);
ManifestResourceTable.Add(m);
}
a++;
}
//Read NestedClass Tabel
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.NestedClass) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new NestedClass();
m.Read(r);
NestedClassTable.Add(m);
}
a++;
}
//Read GenericParam Tabel
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.GenericParam) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new GenericParam();
m.Read(r);
GenericParamTable.Add(m);
}
a++;
}
//Read MethodSpec Tabel
if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.MethodSpec) != 0)
{
for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
{
var m = new MethodSpec();
m.Read(r);
MethodSpecTable.Add(m);
}
a++;
}
}
internal TransportRate this$0;
[MethodImpl(MethodImplOptions.NoInlining), LineNumberTable(40)]
internal override void WriteTo(CCodeWriterBase c)
{
// Finish it properly
var localImpl = new LocalImpl {
Name = ConditionalReceiver.GetName(this.Id), Type = Type
};
var local = new Local {
LocalSymbol = localImpl
};
var block = new Block();
block.Statements.Add(
new ExpressionStatement
{
Expression =
new AssignmentOperator
{
ApplyAutoType = true,
TypeDeclaration = true,
Left = local,
Right = this.Receiver
}
});
var method = new MethodImpl {
Name = "__is_null"
};
method.Parameters = ImmutableArray.Create("Object".ToSystemType().ToParameter("p1"));
var call = new Call {
Method = method
};
call.Arguments.Add(local);
block.Statements.Add(
new ReturnStatement
{
ExpressionOpt =
new ConditionalOperator
{
Condition = call
/*
* new BinaryOperator
* {
* Left = (Type.TypeKind == TypeKind.TypeParameter) ? (Expression) new Cast
* {
* Constrained = true,
* Operand = local,
* Type = SpecialType.System_Object.ToType()
* } : local,
* Right = new Literal { Value = ConstantValue.Create(null) },
* OperatorKind = BinaryOperatorKind.NotEqual
* }*/,
Consequence = this.WhenNotNull,
Alternative = this.WhenNullOpt ?? new DefaultOperator {
Type = Type
}
}
});
new LambdaCall
{
Lambda = new LambdaExpression {
Statements = block, Type = Type
}
}.SetOwner(MethodOwner).WriteTo(c);
}
/// <summary>
/// </summary>
/// <param name="static">
/// </param>
/// <returns>
/// </returns>
public CCodeMethodDeclaration CreateInvokeMethod(bool @static = false)
{
var methodImpl = new MethodImpl
{
Name = this.invoke.Name,
IsVirtual = true,
IsOverride = true,
ReturnType = this.invoke.ReturnType,
ReturnsVoid = this.invoke.ReturnsVoid,
Parameters = this.invoke.Parameters,
ContainingType = this.GetDelegateType(@static),
ReceiverType = this.GetDelegateType(@static)
};
// invoke
var invokeMethod = new CCodeMethodDeclaration(methodImpl);
var operand = @static
? new PointerIndirectionOperator {
Operand = new FieldAccess {
Field = new FieldImpl {
Name = "_memptr"
}
}
}
: (Expression)
new Access
{
ReceiverOpt = new FieldAccess {
Field = new FieldImpl {
Name = "_t", Type = Type
}
},
Expression =
new PointerIndirectionOperator {
Operand = new FieldAccess {
Field = new FieldImpl {
Name = "_memptr"
}
}
}
};
var callExpr = new Call
{
ReceiverOpt = new Parenthesis {
Operand = operand, Type = new TypeImpl {
}
},
Method = new MethodImpl {
Name = string.Empty, Parameters = this.invoke.Parameters
}
};
foreach (var p in this.invoke.Parameters.Select(p => new Parameter {
ParameterSymbol = p
}))
{
callExpr.Arguments.Add(p);
}
// if for multiple delegate
var zero = new Literal {
Value = ConstantValue.Create(0)
};
var invocationCountLocal = new Local {
CustomName = "invocationCount", Type = new TypeImpl {
SpecialType = SpecialType.System_Int32
}
};
var invocationCount = new AssignmentOperator
{
TypeDeclaration = true,
ApplyAutoType = true,
Left = invocationCountLocal,
Right = new Call
{
Method = new MethodImpl {
Name = "ToInt32", Parameters = ImmutableArray <IParameterSymbol> .Empty
},
ReceiverOpt = new FieldAccess
{
ReceiverOpt = new ThisReference()
{
Type = new TypeImpl {
}
},
Field = new FieldImpl {
Name = "_invocationCount", Type = new TypeImpl {
}
},
Type = new TypeImpl {
}
}
}
};
var invocationCountStatement = new ExpressionStatement
{
Expression = invocationCount
};
var iLocal = new Local {
CustomName = "i", Type = new TypeImpl {
SpecialType = SpecialType.System_Int32
}
};
var invokeResult = new Local {
CustomName = "invokeResult", Type = this.invoke.ReturnType
};
// call for 'for'
var callExprInstance = new Call
{
ReceiverOpt = new Cast
{
Type = Type,
CCast = true,
Operand =
new ArrayAccess
{
Expression = new Cast
{
Operand =
new FieldAccess
{
ReceiverOpt = new ThisReference {
Type = new TypeImpl {
}
},
Field = new FieldImpl {
Name = "_invocationList", Type = new TypeImpl {
}
}
},
CCast = true,
Type = new ArrayTypeImpl {
ElementType = new NamedTypeImpl {
SpecialType = SpecialType.System_Delegate, IsReferenceType = true
}
}
},
Indices =
{
iLocal
},
Type = new TypeImpl {
}
}
},
Method = new MethodImpl {
Name = "Invoke", Parameters = this.invoke.Parameters
}
};
foreach (var p in this.invoke.Parameters.Select(p => new Parameter {
ParameterSymbol = p
}))
{
callExprInstance.Arguments.Add(p);
}
var block = new Block
{
Statements =
{
new ForStatement
{
InitializationOpt =
new AssignmentOperator
{
ApplyAutoType = true,
TypeDeclaration = true,
Left = iLocal,
Right = zero
},
ConditionOpt = new BinaryOperator
{
Left = iLocal,
Right = invocationCountLocal,
OperatorKind = BinaryOperatorKind.IntLessThan
},
IncrementingOpt =
new PrefixUnaryExpression {
Value = iLocal, OperatorKind = SyntaxKind.PlusPlusToken
},
Statements = new ExpressionStatement
{
Expression =
this.invoke.ReturnsVoid
? (Expression)callExprInstance
: (Expression) new AssignmentOperator {
Left = invokeResult, Right = callExprInstance
}
}
},
new ReturnStatement {
ExpressionOpt = !this.invoke.ReturnsVoid ? invokeResult : null
}
}
};
if (!this.invoke.ReturnsVoid)
{
block.Statements.Insert(0, new VariableDeclaration {
Local = invokeResult
});
}
var ifInvokeListCountGreaterThen0 = new IfStatement
{
Condition =
new BinaryOperator
{
Left = invocationCountLocal,
Right = zero,
OperatorKind = BinaryOperatorKind.IntGreaterThan
},
IfStatements = block
};
invokeMethod.MethodBodyOpt = new MethodBody(methodImpl)
{
Statements =
{
invocationCountStatement,
ifInvokeListCountGreaterThen0,
this.invoke.ReturnsVoid
? (Statement) new ExpressionStatement {
Expression = callExpr
}
: (Statement) new ReturnStatement {
ExpressionOpt = callExpr
}
}
};
return(invokeMethod);
}
private void InitializeTypeDef(Cts.MetadataType entity, TypeDefinition record)
{
Debug.Assert(entity.IsTypeDefinition);
Cts.MetadataType containingType = (Cts.MetadataType)entity.ContainingType;
if (containingType != null)
{
var enclosingType = (TypeDefinition)HandleType(containingType);
record.EnclosingType = enclosingType;
enclosingType.NestedTypes.Add(record);
var namespaceDefinition =
HandleNamespaceDefinition(containingType.Module, entity.ContainingType.Namespace);
record.NamespaceDefinition = namespaceDefinition;
}
else
{
var namespaceDefinition = HandleNamespaceDefinition(entity.Module, entity.Namespace);
record.NamespaceDefinition = namespaceDefinition;
namespaceDefinition.TypeDefinitions.Add(record);
}
record.Name = HandleString(entity.Name);
Cts.ClassLayoutMetadata layoutMetadata = entity.GetClassLayout();
record.Size = checked ((uint)layoutMetadata.Size);
record.PackingSize = checked ((ushort)layoutMetadata.PackingSize);
record.Flags = GetTypeAttributes(entity);
if (entity.HasBaseType)
{
record.BaseType = HandleType(entity.BaseType);
}
record.Interfaces.Capacity = entity.ExplicitlyImplementedInterfaces.Length;
foreach (var interfaceType in entity.ExplicitlyImplementedInterfaces)
{
if (IsBlocked(interfaceType))
{
continue;
}
record.Interfaces.Add(HandleType(interfaceType));
}
if (entity.HasInstantiation)
{
record.GenericParameters.Capacity = entity.Instantiation.Length;
foreach (var p in entity.Instantiation)
{
record.GenericParameters.Add(HandleGenericParameter((Cts.GenericParameterDesc)p));
}
}
foreach (var field in entity.GetFields())
{
if (_policy.GeneratesMetadata(field))
{
record.Fields.Add(HandleFieldDefinition(field));
}
}
foreach (var method in entity.GetMethods())
{
if (_policy.GeneratesMetadata(method))
{
record.Methods.Add(HandleMethodDefinition(method));
}
}
var ecmaEntity = entity as Cts.Ecma.EcmaType;
if (ecmaEntity != null)
{
Ecma.TypeDefinition ecmaRecord = ecmaEntity.MetadataReader.GetTypeDefinition(ecmaEntity.Handle);
foreach (var e in ecmaRecord.GetEvents())
{
Event evt = HandleEvent(ecmaEntity.EcmaModule, e);
if (evt != null)
{
record.Events.Add(evt);
}
}
foreach (var property in ecmaRecord.GetProperties())
{
Property prop = HandleProperty(ecmaEntity.EcmaModule, property);
if (prop != null)
{
record.Properties.Add(prop);
}
}
Ecma.CustomAttributeHandleCollection customAttributes = ecmaRecord.GetCustomAttributes();
if (customAttributes.Count > 0)
{
record.CustomAttributes = HandleCustomAttributes(ecmaEntity.EcmaModule, customAttributes);
}
foreach (var miHandle in ecmaRecord.GetMethodImplementations())
{
Ecma.MetadataReader reader = ecmaEntity.EcmaModule.MetadataReader;
Ecma.MethodImplementation miDef = reader.GetMethodImplementation(miHandle);
Cts.MethodDesc methodBody = (Cts.MethodDesc)ecmaEntity.EcmaModule.GetObject(miDef.MethodBody);
if (_policy.IsBlocked(methodBody))
{
continue;
}
Cts.MethodDesc methodDecl = (Cts.MethodDesc)ecmaEntity.EcmaModule.GetObject(miDef.MethodDeclaration);
if (_policy.IsBlocked(methodDecl.GetTypicalMethodDefinition()))
{
continue;
}
MethodImpl methodImplRecord = new MethodImpl
{
MethodBody = HandleQualifiedMethod(methodBody),
MethodDeclaration = HandleQualifiedMethod(methodDecl)
};
record.MethodImpls.Add(methodImplRecord);
}
}
}
public void Update()
{
if (DisableUpdate)
{
return;
}
//check disabled
if (!Enabled)
{
Clear();
return;
}
var newCode = Code.Value;
needUpdate = false;
if (newCode == compiledCode)
{
return;
}
////check for updates
//if( !needUpdate && newCode != compiledCode )
// needUpdate = true;
////nothing to update
//if( !needUpdate )
// return;
//do update
Clear();
compiledCode = newCode;
needUpdate = false;
if (!string.IsNullOrEmpty(newCode))
{
compiledScript = ScriptingCSharpEngine.GetOrCompileScript(compiledCode, out var error);
if (!string.IsNullOrEmpty(error))
{
Log.Warning($"Unable to compile script.\r\n\r\nComponent \"{GetPathFromRoot( true )}\".\r\n\r\n" + error);
return;
}
CreateScriptInstance();
//fields
foreach (var netField in compiledScript.Fields)
{
if (netField.IsPublic && netField.Name != "Owner")
{
var type = MetadataManager.GetTypeOfNetType(netField.FieldType);
var member = new PropertyImpl(this, netField.Name, netField.IsStatic, type, type, Array.Empty <Metadata.Parameter>(), false, compiledScript, netField);
compiledMembers.Add(member);
compiledMemberBySignature[member.Signature] = member;
}
}
//properties
foreach (var netProperty in compiledScript.Properties)
{
if (netProperty.GetMethod != null && netProperty.GetMethod.IsPublic)
{
var type = MetadataManager.GetTypeOfNetType(netProperty.PropertyType);
var unrefType = ReferenceUtility.GetUnreferencedType(type);
var netParameters = netProperty.GetIndexParameters();
var indexers = new List <Metadata.Parameter>();
for (int n = 0; n < netParameters.Length; n++)
{
var netParam = netParameters[n];
var netType = netParam.ParameterType;
bool isByReference = netType.IsByRef;
if (isByReference)
{
netType = netType.GetElementType();
}
var type2 = MetadataManager.GetTypeOfNetType(netType);
var p = new Metadata.Parameter(netParam.Name, type2, isByReference, netParam.IsIn, netParam.IsOut, netParam.IsRetval,
netParam.IsOptional, netParam.HasDefaultValue, netParam.DefaultValue);
indexers.Add(p);
}
var member = new PropertyImpl(this, netProperty.Name, ReflectionUtility.PropertyIsStatic(netProperty), type, unrefType, indexers.Count != 0 ? indexers.ToArray() : Array.Empty <Metadata.Parameter>(), !netProperty.CanWrite, compiledScript, netProperty);
compiledMembers.Add(member);
compiledMemberBySignature[member.Signature] = member;
}
}
//methods
foreach (var netMethod in compiledScript.Methods)
{
if (netMethod.IsSpecialName)
{
if (netMethod.Name.Length > 4 && (netMethod.Name.Substring(0, 4) == "get_" || netMethod.Name.Substring(0, 4) == "set_"))
{
continue;
}
if (netMethod.Name.Length > 4 && netMethod.Name.Substring(0, 4) == "add_")
{
continue;
}
if (netMethod.Name.Length > 7 && netMethod.Name.Substring(0, 7) == "remove_")
{
continue;
}
}
if (netMethod.GetBaseDefinition() != netMethod)
{
continue;
}
var netParams = netMethod.GetParameters();
var parameters = new List <Metadata.Parameter>();
for (int n = 0; n < netParams.Length; n++)
{
var netParam = netParams[n];
var netType = netParam.ParameterType;
bool isByReference = netType.IsByRef;
if (isByReference)
{
netType = netType.GetElementType();
}
var type = MetadataManager.GetTypeOfNetType(netType);
var p = new Metadata.Parameter(netParam.Name, type, isByReference, netParam.IsIn, netParam.IsOut, netParam.IsRetval,
netParam.IsOptional, netParam.HasDefaultValue, netParam.DefaultValue);
parameters.Add(p);
}
if (netMethod.ReturnType != null && netMethod.ReturnType != typeof(void))
{
var netType = netMethod.ReturnType;
bool isRef = netType.IsByRef;
if (isRef)
{
netType = netType.GetElementType();
}
var paramType = MetadataManager.GetTypeOfNetType(netType);
//"_return"
var p = new Metadata.Parameter("ReturnValue", paramType, isRef, false, true, true, false, false, null);
parameters.Add(p);
}
bool isOperator = netMethod.IsSpecialName && netMethod.Name.Length > 3 && netMethod.Name.Substring(0, 3) == "op_";
var member = new MethodImpl(this, netMethod.Name, netMethod.IsStatic, parameters.ToArray(), false, isOperator, compiledScript, netMethod);
compiledMembers.Add(member);
compiledMemberBySignature[member.Signature] = member;
}
//One method mode
if (compiledScript != null && compiledMembers.Count == 1)
{
compiledOneMethod = (MethodImpl)compiledMembers[0];
OneMethod_AddProperties(compiledOneMethod);
//var parameters = new List<Metadata.Parameter>();
//parameters.Add( new Metadata.Parameter( "a", MetadataManager.GetTypeOfNetType( typeof( int ) ), false, true, false, false, false, false, null ) );
//parameters.Add( new Metadata.Parameter( "ReturnValue", MetadataManager.GetTypeOfNetType( typeof( int ) ), false, true, false, true, false, false, null ) );
//xx xx;
//var method = new MethodImpl( this, "Method", true, parameters.ToArray(), false, false, compiledScript, compiledScript.PublicMethods[ 0 ] );
//compiledMembers.Add( method );
//compiledMemberBySignature[ method.Signature ] = method;
//compiledOneMethod = method;
////create properties
//if( method != null )
//{
// //parameters
// propertyMethodParameters = new List<PropertyImpl>();
// for( int nParameter = 0; nParameter < method.Parameters.Length; nParameter++ )
// {
// var parameter = method.Parameters[ nParameter ];
// ////!!!!имя еще как-то фиксить?
// //string name = null;
// //!!!!
// //if( parameter.ReturnValue )
// // name = "ReturnValue";
// //if( name == null )
// var name = parameter.Name.Substring( 0, 1 ).ToUpper() + parameter.Name.Substring( 1 );
// //!!!!поддержать ByReference. еще какие?
// bool readOnly = parameter.Output || parameter.ReturnValue;
// //!!!!
// //var parameterType = GetOverrideParameterType( parameter, out bool error );
// //if( error )
// //{
// // unableToInit = true;
// // goto unableToInitLabel;
// //}
// //var parameterType = parameter.Type;
// Metadata.TypeInfo type;
// bool referenceSupport = !readOnly;
// if( referenceSupport )
// {
// Type unrefNetType = parameter.Type.GetNetType();
// var refNetType = typeof( Reference<> ).MakeGenericType( unrefNetType );
// type = MetadataManager.GetTypeOfNetType( refNetType );
// }
// else
// type = parameter.Type;
// bool invoke = parameter.ReturnValue || parameter.ByReference || parameter.Output;
// string namePrefix = "__parameter_";
// string displayName = TypeUtils.DisplayNameAddSpaces( name );
// var p = new PropertyImpl( this, namePrefix + name, false, type, parameter.Type, new Metadata.Parameter[ 0 ], readOnly, "Method's Parameters", displayName, referenceSupport, parameter, invoke );
// p.Description = "";
// if( !readOnly )
// p.Serializable = true;
// properties.Add( p );
// propertyBySignature[ p.Signature ] = p;
// //!!!!так? если несколько?
// if( parameter.ReturnValue )
// propertyMethodReturnParameter = p;
// else
// propertyMethodParameters.Add( p );
// }
//}
}
//update child handlers
try
{
foreach (var handler in GetComponents <Component_EventHandler>())
{
handler.UpdateSubscription();
}
}
catch { }
}
}
public CCodeNewOperatorDeclaration(INamedTypeSymbol type, bool withFinalization = false, bool withExtraParams = false, bool debugVersion = false)
: base(new NewOperatorMethod(type))
{
this.withFinalization = withFinalization;
this.withExtraParams = withExtraParams;
this.debugVersion = debugVersion;
var parameterSymbols = new List <IParameterSymbol>();
var arguments = new List <Expression>();
var parameterSymbolSize = new ParameterImpl {
Name = "_size"
};
parameterSymbols.Add(parameterSymbolSize);
if (!withExtraParams)
{
var parameterSize = new Parameter {
ParameterSymbol = parameterSymbolSize
};
arguments.Add(parameterSize);
}
else
{
var parameterSymbolCustomSize = new ParameterImpl {
Name = "_customSize"
};
var parameterCustomSize = new Parameter {
ParameterSymbol = parameterSymbolCustomSize
};
parameterSymbols.Add(parameterSymbolCustomSize);
arguments.Add(parameterCustomSize);
}
if (type.IsAtomicType())
{
var parameterSymbolIsAtomicOrTypeDescr = new ParameterImpl {
Name = "_is_atomic_or_type_descr"
};
parameterSymbols.Add(parameterSymbolIsAtomicOrTypeDescr);
arguments.Add(
new FieldAccess
{
Field = new FieldImpl {
ContainingType = new NamedTypeImpl {
Name = "GCAtomic"
}, Name = "Default", IsStatic = true
}
});
}
else
{
// get or create type descriptor
var parameterSymbolIsAtomicOrTypeDescr = new ParameterImpl {
Name = "_is_atomic_or_type_descr"
};
parameterSymbols.Add(parameterSymbolIsAtomicOrTypeDescr);
var local = new Local {
CustomName = "__type_descriptor"
};
arguments.Add(
new ConditionalOperator
{
Condition = local,
Consequence = local,
Alternative =
new AssignmentOperator
{
Left = local,
Right =
new Call
{
Method = new CCodeGetTypeDescriptorDeclaration.GetTypeDescriptorMethod(type)
}
}
});
}
if (debugVersion)
{
var parameterSymbolFile = new ParameterImpl {
Name = "_file"
};
var parameterFile = new Parameter {
ParameterSymbol = parameterSymbolFile
};
var parameterSymbolLine = new ParameterImpl {
Name = "_line"
};
var parameterLine = new Parameter {
ParameterSymbol = parameterSymbolLine
};
parameterSymbols.Add(parameterSymbolFile);
parameterSymbols.Add(parameterSymbolLine);
arguments.Add(parameterFile);
arguments.Add(parameterLine);
}
var methodSymbol = new MethodImpl
{
Name = withFinalization ? "__new_set0_with_finalizer" : "__new_set0",
MethodKind = MethodKind.BuiltinOperator,
Parameters = ImmutableArray.Create(parameterSymbols.ToArray())
};
var methodCallExpr = new Call {
Method = methodSymbol
};
foreach (var argItem in arguments)
{
methodCallExpr.Arguments.Add(argItem);
}
MethodBodyOpt = new MethodBody(Method)
{
Statements = { new ReturnStatement {
ExpressionOpt = methodCallExpr
} }
};
}
/// <summary>
/// </summary>
/// <param name="static">
/// </param>
/// <returns>
/// </returns>
private CCodeMethodDeclaration CreateInvokeMethod(bool @static = false)
{
var methodImpl = new MethodImpl
{
Name = this.invoke.Name,
IsVirtual = true,
IsOverride = true,
ReturnType = this.invoke.ReturnType,
ReturnsVoid = this.invoke.ReturnsVoid,
Parameters = this.invoke.Parameters
};
var invokeMethod = new CCodeMethodDeclaration(methodImpl);
var operand = @static
? new PointerIndirectionOperator {
Operand = new FieldAccess {
Field = new FieldImpl {
Name = "_memptr"
}
}
}
: (Expression)
new Access
{
ReceiverOpt = new FieldAccess {
Field = new FieldImpl {
Name = "_t", Type = Type
}
},
Expression =
new PointerIndirectionOperator {
Operand = new FieldAccess {
Field = new FieldImpl {
Name = "_memptr"
}
}
}
};
var callExpr = new Call
{
ReceiverOpt = new Parenthesis {
Operand = operand, Type = new TypeImpl {
}
},
Method = new MethodImpl {
Name = string.Empty, Parameters = this.invoke.Parameters
}
};
foreach (var p in this.invoke.Parameters.Select(p => new Parameter {
ParameterSymbol = p
}))
{
callExpr.Arguments.Add(p);
}
var returnStatement = new ReturnStatement {
ExpressionOpt = callExpr
};
invokeMethod.MethodBodyOpt = new MethodBody(methodImpl)
{
Statements = { returnStatement }
};
return(invokeMethod);
}
