/** handles the declaration for the interface definition / fwd declaration * @return the TypeBuilder for this interface */ private TypeBuilder CreateOrGetInterfaceDcl(Symbol forSymbol, System.Type[] interfaces, bool isAbstract, bool isLocal, bool isForward) { TypeBuilder interfaceToBuild = null; if (!m_typeManager.IsFwdDeclared(forSymbol)) { Trace.WriteLine("generating code for interface: " + forSymbol.getSymbolName()); interfaceToBuild = m_typeManager.StartTypeDefinition(forSymbol, TypeAttributes.Interface | TypeAttributes.Public | TypeAttributes.Abstract, null, interfaces, isForward); // add InterfaceTypeAttribute IdlTypeInterface ifType = IdlTypeInterface.ConcreteInterface; if (isAbstract) { ifType = IdlTypeInterface.AbstractInterface; } if (isLocal) { ifType = IdlTypeInterface.LocalInterface; } if ((isLocal) && (isAbstract)) { throw new InternalCompilerException("internal error: iftype precondition"); } // add interface type CustomAttributeBuilder interfaceTypeAttrBuilder = new InterfaceTypeAttribute(ifType).CreateAttributeBuilder(); interfaceToBuild.SetCustomAttribute(interfaceTypeAttrBuilder); interfaceToBuild.AddInterfaceImplementation(typeof(IIdlEntity)); } else { // get incomplete type Trace.WriteLine("complete interface: " + forSymbol.getSymbolName()); interfaceToBuild = m_typeManager.GetIncompleteForwardDeclaration(forSymbol); // add inheritance relationship: for (int i = 0; i < interfaces.Length; i++) { interfaceToBuild.AddInterfaceImplementation(interfaces[i]); } } return interfaceToBuild; }
/// <summary> /// get the full defined Type or the fwd decl /// </summary> public TypeContainer GetKnownType(Symbol forSymbol) { // search in all complete types from this run, also typesdefs, ... TypeContainer result = (TypeContainer)m_completeTypeTable[forSymbol]; if (result == null) { result = (TypeContainer)m_typesInCreation[forSymbol]; } if (result == null) { // search in build-module to get also types from a run over a previous root idl-file (one specified on the command line) Type fromBuildMod = GetTypeFromBuildModule(forSymbol); if (fromBuildMod != null) { result = new CompileTimeTypeContainer(this, fromBuildMod); } } if (result == null) { // check in types, which are defined in referenced assemblies Type fromAsm = GetTypeFromRefAssemblies(forSymbol); if (fromAsm != null) { // remark: all types in ref assemblies are fully completed -> no need for compileTimeTypeContainer result = new TypeContainer(fromAsm); } } if ((result == null) && (m_sequenceRecursionAllowedType != null) && m_sequenceRecursionAllowedType.SymbolPart.Equals(forSymbol)) { result = m_sequenceRecursionAllowedType.TypePart; } return result; }
/// <summary> /// allows sequence recursion for unions/struct. Don't forget to call /// UnpublishTypeForSequenceRecursion after sequence elem type is identified /// </summary> public void PublishTypeForSequenceRecursion(Symbol typeSym, TypeBuilder type) { if (!IsTypeDeclarded(typeSym)) { TypeContainer container = new CompileTimeTypeContainer(this, type); m_sequenceRecursionAllowedType = new TypeSymbolPair(typeSym, container); } }
/// <summary> /// checks, if a type is already declared in a referenced assembly /// </summary> public bool IsTypeDeclaredInRefAssemblies(Symbol forSymbol) { return GetTypeFromRefAssemblies(forSymbol) != null; }
/// <summary>checks if a type generation can be skipped, /// because type is already defined in a previous run over a parse tree /// or in a reference assembly /// </summary> /// <remarks>this method is used to support runs over more than one parse tree /// </remarks> public bool CheckSkip(Symbol forSymbol) { if (IsTypeDeclaredInRefAssemblies(forSymbol)) { // skip, because already defined in a referenced assembly // -> this overrides the def from idl return true; } // check here directly on module, to find out about runs of the compiler for // previous files (for every run over a new file on the IDL To CLS argument line, // a new TypeManager is used) Type inBuildModule = GetTypeFromBuildModule(forSymbol); if (inBuildModule != null && !IsIncompleteDeclarationPresent(forSymbol)) { // safe to skip, because type is already fully declared in this run return true; } // do not skip return false; }
public bool IsFwdDeclared(Symbol forSymbol) { return GetIncompleteForwardDeclartionUnchecked(forSymbol) != null; }
private void AddRepositoryIdAttribute(TypeBuilder typeBuild, Symbol typeSymbol) { string repositoryId = FindRepositoryId(typeSymbol); if (repositoryId == null) { // no repository id specified, create one from the idl, because of special name mappings // creating a rep-id in Channel code can lead to the wrong one ... repositoryId = typeSymbol.ConstructRepositoryId(); } AddRepositoryIdAttribute(typeBuild, repositoryId); }
/// <summary> /// start a type definition for a type with System.Object as parent /// </summary> /// <param name="isForwardDeclaration">specifies, if this type is created from an idl forward declaration</param> public TypeBuilder StartTypeDefinition(Symbol typeSymbol, TypeAttributes typeAttributes, Type[] interfaces, bool isForwardDeclaration) { return StartTypeDefinition(typeSymbol, typeAttributes, typeof(System.Object), interfaces, isForwardDeclaration); }
/// <summary> /// Start a type definition for a boxed value type /// Adds also repository id and IIdlEntity inheritance. /// </summary> public TypeBuilder StartBoxedValueTypeDefinition(Symbol typeSymbol, Type boxedType, CustomAttributeBuilder[] boxedTypeAttributes) { if (IsTypeDeclarded(typeSymbol)) { // was not skipped, tried to redeclare -> internal error throw new InternalCompilerException("A type with the name " + GetKnownType(typeSymbol).GetCompactClsType().FullName + " is already declared for symbol: " + typeSymbol); } Scope enclosingScope = typeSymbol.getDeclaredIn(); String fullyQualName = enclosingScope.GetFullyQualifiedNameForSymbol(typeSymbol.getSymbolName()); Trace.WriteLine("generating code for boxed value type: " + fullyQualName); TypeBuilder result = m_boxedValueTypeGenerator.CreateBoxedType(boxedType, m_modBuilder, fullyQualName, boxedTypeAttributes); // book-keeping TypeContainer container = new CompileTimeTypeContainer(this, result); m_typesInCreation[typeSymbol] = container; // repository and iidlentiry inheritance result.AddInterfaceImplementation(typeof(IIdlEntity)); AddRepositoryIdAttribute(result, typeSymbol); return result; }
/// <summary> /// start a type definition for a type /// </summary> /// <param name="isForwardDeclaration">specifies, if this type is created from an idl forward declaration</param> private TypeBuilder StartTypeDefinition(Symbol typeSymbol, string fullyQualName, TypeAttributes typeAttributes, Type parent, Type[] interfaces, bool isForwardDeclaration) { if (IsTypeDeclarded(typeSymbol)) { // was not skipped, tried to redeclare -> internal error throw new InternalCompilerException("A type with the name " + GetKnownType(typeSymbol).GetCompactClsType().FullName + " is already declared for symbol: " + typeSymbol); } TypeBuilder result = m_modBuilder.DefineType(fullyQualName, typeAttributes, parent, interfaces); AddRepositoryIdAttribute(result, typeSymbol); // every constructed type should have a rep-id. // book-keeping TypeContainer container = new CompileTimeTypeContainer(this, result); m_typesInCreation[typeSymbol] = container; if (isForwardDeclaration) { // store type-fwd declaration in a special place, to allow searching only those when trying to complete a fwd declaration. m_fwdDeclaredTypes[typeSymbol] = container; } return result; }
/// <summary> /// start a type definition for a type /// </summary> /// <param name="isForwardDeclaration">specifies, if this type is created from an idl forward declaration</param> public TypeBuilder StartTypeDefinition(Symbol typeSymbol, TypeAttributes typeAttributes, Type parent, Type[] interfaces, bool isForwardDeclaration) { Scope enclosingScope = typeSymbol.getDeclaredIn(); String fullyQualName = enclosingScope.GetFullyQualifiedNameForSymbol(typeSymbol.getSymbolName()); return StartTypeDefinition(typeSymbol, fullyQualName, typeAttributes, parent, interfaces, isForwardDeclaration); }
/// <summary>finds the repository id attribute for the symbol starting the search in startInScope</summary> private string FindRepositoryId(Symbol forSymbol) { Scope startInScope = forSymbol.getDeclaredIn(); string forName = forSymbol.getSymbolName(); string result = startInScope.getRepositoryIdFor(forName); if (result == null) { // try inside scope to find it Scope innerScope = startInScope.getChildScope(forName); if (innerScope != null) { result = innerScope.getRepositoryIdFor(forName); } } return result; }
public BuildInfo(Scope buildScope, TypeBuilder containerType, Symbol containerSymbol) { m_buildScope = buildScope; m_containerType = containerType; m_containerSymbol = containerSymbol; }
/** handles the declaration for the value definition / fwd declaration * @return the TypeBuilder for this interface */ private TypeBuilder CreateOrGetValueDcl(Symbol forSymbol, System.Type parent, System.Type[] interfaces, bool isAbstract, bool isForwardDecl) { TypeBuilder valueToBuild; if (!m_typeManager.IsFwdDeclared(forSymbol)) { Trace.WriteLine("generating code for value type: " + forSymbol.getSymbolName()); TypeAttributes attrs = TypeAttributes.Public | TypeAttributes.Abstract; if (isAbstract) { attrs |= TypeAttributes.Interface; if (parent != null) { // classes are considered as concrete value types throw new InvalidIdlException("not possible for an abstract value type " + forSymbol.getDeclaredIn().GetFullyQualifiedNameForSymbol(forSymbol.getSymbolName()) + " to inherit from a concrete one " + parent.FullName); } } else { attrs |= TypeAttributes.Class; } valueToBuild = m_typeManager.StartTypeDefinition(forSymbol, attrs, parent, interfaces, isForwardDecl); if (isAbstract) { // add InterfaceTypeAttribute IdlTypeInterface ifType = IdlTypeInterface.AbstractValueType; CustomAttributeBuilder interfaceTypeAttrBuilder = new InterfaceTypeAttribute(ifType).CreateAttributeBuilder(); valueToBuild.SetCustomAttribute(interfaceTypeAttrBuilder); } valueToBuild.AddInterfaceImplementation(typeof(IIdlEntity)); // implement IDLEntity } else { // get incomplete type Trace.WriteLine("complete valuetype: " + forSymbol.getSymbolName()); valueToBuild = m_typeManager.GetIncompleteForwardDeclaration(forSymbol); // add inheritance relationship: for (int i = 0; i < interfaces.Length; i++) { valueToBuild.AddInterfaceImplementation(interfaces[i]); } if (parent != null) { valueToBuild.SetParent(parent); } } // add abstract methods for all interface methods, a class inherit from (only if valueToBuild is a class an not an interface) // add property to abstract class for all properties defined in an interface (only if valueToBuild is a class an not an interface) AddInheritedMembersAbstractDeclToClassForIf(valueToBuild, interfaces); return valueToBuild; }
private bool IsIncompleteDeclarationPresent(Symbol typeSymbol) { return m_typesInCreation[typeSymbol] != null; }
public UnionGenerationHelper StartUnionTypeDefinition(Symbol typeSymbol, string fullyQualName) { if (IsTypeDeclarded(typeSymbol)) { // was not skipped, tried to redeclare -> internal error throw new InternalCompilerException("A type with the name " + GetKnownType(typeSymbol).GetCompactClsType().FullName + " is already declared for symbol: " + typeSymbol); } UnionGenerationHelper genHelper = new UnionGenerationHelper(m_modBuilder, fullyQualName, TypeAttributes.Public); AddRepositoryIdAttribute(genHelper.Builder, typeSymbol); // book-keeping TypeContainer container = new CompileTimeTypeContainer(this, genHelper.Builder); m_typesInCreation[typeSymbol] = container; return genHelper; }
/// <summary> /// is at least a forward declaration for the type represented by the symbol present /// </summary> public bool IsTypeDeclarded(Symbol forSymbol) { TypeContainer type = GetKnownType(forSymbol); return (type != null); }
public Type EndUnionTypeDefinition(Symbol typeSymbol, UnionGenerationHelper helper) { Type resultType = helper.FinalizeType(); // book-keeping m_typesInCreation.Remove(typeSymbol); AddCompleteTypeDefinition(typeSymbol, new CompileTimeTypeContainer(this, resultType)); return resultType; }
private void AddRepositoryIdAttribute(Symbol typeSymbol) { TypeBuilder inCreation = GetTypeFromTypesInCreation(typeSymbol); AddRepositoryIdAttribute(inCreation, typeSymbol); }
/// <summary> /// completed the type definiton by creation toComplete.CreateType and /// updates internal state used to tell about status of types /// </summary> /// <param name="toComplete"></param> /// <returns></returns> public Type EndTypeDefinition(Symbol typeSymbol) { TypeBuilder toComplete = GetTypeFromTypesInCreation(typeSymbol); Type resultType = toComplete.CreateType(); // update the book-keeping m_typesInCreation.Remove(typeSymbol); m_fwdDeclaredTypes.Remove(typeSymbol); AddCompleteTypeDefinition(typeSymbol,new CompileTimeTypeContainer(this, resultType)); return resultType; }
private string GetFullTypeNameForSymbol(Symbol forSymbol) { Scope declIn = forSymbol.getDeclaredIn(); return declIn.GetFullyQualifiedNameForSymbol(forSymbol.getSymbolName()); }
public TypeBuilder GetIncompleteForwardDeclaration(Symbol typeSymbol) { TypeBuilder result = GetIncompleteForwardDeclartionUnchecked(typeSymbol); if (result != null) { return result; } else { // must be found, otherwise an implementation error ... throw new InternalCompilerException("forward decl not retrieved again for " + typeSymbol); } }
private Type GetTypeFromRefAssemblies(Symbol forSymbol) { string fullName = GetFullTypeNameForSymbol(forSymbol); String repId = forSymbol.getDeclaredIn().getRepositoryIdFor(forSymbol.getSymbolName()); return m_refAsmTypes.GetTypeFromRefAssemblies(fullName, repId); }
/// <summary> /// the same as GetIncompleteForwardDeclaration, but throws no exception if not found /// </summary> private TypeBuilder GetIncompleteForwardDeclartionUnchecked(Symbol typeSymbol) { TypeContainer container = (TypeContainer)m_fwdDeclaredTypes[typeSymbol]; TypeBuilder result = (container != null ? container.GetCompactClsType() as TypeBuilder : null); return result; }
/// <summary> /// checks if a type is known by ModuleBuilder and if yes, returns it; otherwise; returns null /// </summary> private Type GetTypeFromBuildModule(Symbol forSymbol) { string fullName = GetFullTypeNameForSymbol(forSymbol); Type result = GetTypeFromBuildModule(fullName); return result; }
/// <summary> /// returns the typebuilder if found among types in creation, otherwise throws exception /// </summary> private TypeBuilder GetTypeFromTypesInCreation(Symbol typeSymbol) { TypeContainer container = (TypeContainer)m_typesInCreation[typeSymbol]; TypeBuilder toComplete = (container != null ? container.GetCompactClsType() as TypeBuilder : null); if (toComplete != null) { return toComplete; } else { throw new InternalCompilerException("type in creation not found: " + typeSymbol); } }
/// <summary> /// register a resolved typedef /// </summary> public void RegisterTypeDef(TypeContainer fullDecl, Symbol forSymbol) { AddCompleteTypeDefinition(forSymbol, fullDecl); }
/// <summary>add a fully defined type to the known types</summary> private void AddCompleteTypeDefinition(Symbol typeSymbol, TypeContainer fullDecl) { if (m_typesInCreation.ContainsKey(typeSymbol)) { throw new InternalCompilerException("type can't be registered, an incomplete declaration exists; symbol: " + typeSymbol); // should not occur, check by sym table } if (m_completeTypeTable.ContainsKey(typeSymbol)) { throw new InternalCompilerException("type already defined; symbol: " + typeSymbol); // should not occur, checked by sym table } m_completeTypeTable[typeSymbol] = fullDecl; }
public TypeSymbolPair(Symbol symbolPart, TypeContainer typePart) { SymbolPart = symbolPart; TypePart = typePart; }
public ConcreteValTypeBuildInfo(Scope buildScope, TypeBuilder containerType, Symbol containerSymbol, ConstructorBuilder defConstr) : base(buildScope, containerType, containerSymbol) { m_defaultConstr = defConstr; }