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); }