public override AstNode Visit(TypedefDefinition node) { // Prevent redefinition. ScopeMember old = currentContainer.FindMember(node.GetName()); if (old != null) { Error(node, "trying to redefine a typedef."); } // Create the type name. TypeNameMember typeName = new TypeNameMember(node.GetFlags(), node.GetName(), currentContainer); typeName.SetTypedefNode(node); node.SetTypeName(typeName); // Register the type name. if (currentContainer.IsNamespace()) { Namespace space = (Namespace)currentContainer; space.AddMember(typeName); } else if (currentContainer.IsStructure() || currentContainer.IsClass()) { Structure parent = (Structure)currentContainer; parent.AddTypeName(typeName); } else { Error(node, "unexpected place for a typedef."); } return(node); }
public static Namespace ParseNamespace(ParserContext context, TopLevelEntity parent, TokenStream tokens) { Token namespaceToken = tokens.PopExpected("namespace"); List <Token> nsNameParts = new List <Token>(); nsNameParts.Add(tokens.PopWord()); while (tokens.IsNext(".")) { tokens.PopExpected("."); nsNameParts.Add(tokens.PopWord()); } Namespace ns = new Namespace(namespaceToken, nsNameParts, parent); tokens.PopExpected("{"); while (!tokens.PopIfPresent("}")) { TopLevelEntity tle = Parse(context, tokens, ns); ns.AddMember(tle); } return(ns); }
// Caller must take lock on this internal void LoadTypesInNamespace( Namespace moduleNamespace ) //^ requires moduleNamespace.NamespaceNameOffset != 0xFFFFFFFF; { CoreTypes dummy = this.CoreTypes; //force core types to be initialized uint namespaceNameOffset = moduleNamespace.NamespaceNameOffset; Debug.Assert(namespaceNameOffset != 0xFFFFFFFF); uint numberOfTypeDefs = this.PEFileReader.TypeDefTable.NumberOfRows; var moduleTypeArray = this.ModuleTypeDefArray; for (uint i = 1; i <= numberOfTypeDefs; ++i) { TypeDefRow typeDefRow = this.PEFileReader.TypeDefTable[i]; // Check if its in the same namespace if (typeDefRow.Namespace != namespaceNameOffset || typeDefRow.IsNested) continue; // Check if its already created by someone else NamespaceType/*?*/ type = (NamespaceType)moduleTypeArray[i]; if (type == null) { type = this.CreateModuleNamespaceType(i, typeDefRow, moduleNamespace, MetadataReaderSignatureTypeCode.NotModulePrimitive); var redirectedType = this.ModuleReader.metadataReaderHost.Redirect(this.Module, type); if (redirectedType == type) moduleNamespace.AddMember(type); moduleTypeArray[i] = type; this.RedirectedTypeDefArray[i] = redirectedType; this.ModuleTypeDefLoadState[i] = LoadState.Loaded; } } uint numberOfExportedTypes = this.PEFileReader.ExportedTypeTable.NumberOfRows; ExportedTypeAliasBase/*?*/[] exportedTypeArray = this.ExportedTypeArray; for (uint i = 1; i <= numberOfExportedTypes; ++i) { ExportedTypeRow exportedTypeRow = this.PEFileReader.ExportedTypeTable[i]; // Check if its in the same namespace if (exportedTypeRow.TypeNamespace != namespaceNameOffset || exportedTypeRow.IsNested) continue; // Check if its already created by someone else ExportedTypeAliasBase/*?*/ type = exportedTypeArray[i]; if (type == null) { type = this.CreateExportedNamespaceType(i, exportedTypeRow, moduleNamespace); this.ExportedTypeArray[i] = type; this.ExportedTypeLoadState[i] = LoadState.Loaded; } } }
ExportedTypeNamespaceAlias CreateExportedNamespaceType( uint exportedTypeRowId, ExportedTypeRow exportedTypeRow, Namespace moduleNamespace ) { IName typeName = this.GetNameFromOffset(exportedTypeRow.TypeName); ExportedTypeNamespaceAlias exportedType = new ExportedTypeNamespaceAlias(this, typeName, exportedTypeRowId, exportedTypeRow.Flags, moduleNamespace); moduleNamespace.AddMember(exportedType); return exportedType; }
NamespaceType CreateModuleNamespaceType( uint typeDefRowId, TypeDefRow typeDefRow, Namespace moduleNamespace, ModuleSignatureTypeCode signatureTypeCode ) { IName typeName = this.GetNameFromOffset(typeDefRow.Name); uint genericParamRowIdStart; uint genericParamRowIdEnd; this.GetGenericParamInfoForType(typeDefRowId, out genericParamRowIdStart, out genericParamRowIdEnd); NamespaceType type; if (genericParamRowIdStart == 0) { if (signatureTypeCode == ModuleSignatureTypeCode.NotModulePrimitive) type = new NonGenericNamespaceTypeWithoutPrimitiveType(this, typeName, typeDefRowId, typeDefRow.Flags, moduleNamespace); else type = new NonGenericNamespaceTypeWithPrimitiveType(this, typeName, typeDefRowId, typeDefRow.Flags, moduleNamespace, signatureTypeCode); } else { IName unmangledTypeName = this.GetUnmangledNameFromOffset(typeDefRow.Name); type = new GenericNamespaceType(this, unmangledTypeName, typeDefRowId, typeDefRow.Flags, moduleNamespace, typeName, genericParamRowIdStart, genericParamRowIdEnd); } moduleNamespace.AddMember(type); return type; }
ExportedTypeNamespaceAlias CreateExportedNamespaceType(uint exportedTypeRowId, ExportedTypeRow exportedTypeRow, Namespace moduleNamespace) { ExportedTypeNamespaceAlias exportedType = new ExportedTypeNamespaceAlias(this, exportedTypeRowId, exportedTypeRow.Flags, moduleNamespace); moduleNamespace.AddMember(exportedType); return exportedType; }
public override AstNode Visit(NamespaceDefinition node) { // Handle nested names. string fullname = node.GetName(); StringBuilder nameBuilder = new StringBuilder(); int numscopes = 0; for (int i = 0; i < fullname.Length; i++) { char c = fullname[i]; if (c != '.') { nameBuilder.Append(c); if (i + 1 < fullname.Length) { continue; } } // Expect full name. if (c == '.' && i + 1 == fullname.Length) { Error(node, "expected complete namespace name."); } // Find an already declared namespace. string name = nameBuilder.ToString(); nameBuilder.Length = 0; ScopeMember old = currentContainer.FindMember(name); if (old != null) { if (!old.IsNamespace()) { Error(node, "defining namespace collides with another thing."); } // Store a reference in the node. node.SetNamespace((Namespace)old); } else { // Cast the current scope. Namespace space = (Namespace)currentContainer; // Create, name and add the new namespace. Namespace newNamespace = new Namespace(space); newNamespace.SetName(name); space.AddMember(newNamespace); // Store a reference in the node. node.SetNamespace(newNamespace); } // Update the scope. PushScope(node.GetNamespace()); // Increase the number of scopes. numscopes++; } // Visit the children. VisitList(node.GetChildren()); // Restore the scopes. for (int i = 0; i < numscopes; i++) { PopScope(); } return(node); }