Exemple #1
0
 public override string GetNamespaceName(Namespace space) {
     using (TextWriter writer = new StringWriter()) {
         writer.Write("N:");
         WriteNamespace(space, writer);
         return (writer.ToString());
     }
 }
Exemple #2
0
 private void ParseNamespaceMemberDeclarations(Namespace/*!*/ parentNamespace, TokenSet followers){
   TokenSet attributeOrNamespaceOrTypeDeclarationStartOrLastIdentifier = Parser.AttributeOrNamespaceOrTypeDeclarationStart|Token.LastIdentifier;
   TokenSet followersOrAttributeOrNamespaceOrTypeDeclarationStartOrLastIdentifier = followers|attributeOrNamespaceOrTypeDeclarationStartOrLastIdentifier;
   while (attributeOrNamespaceOrTypeDeclarationStartOrLastIdentifier[this.currentToken] || this.currentToken == Token.Identifier)
     this.ParseNamespaceOrTypeDeclarations(parentNamespace, followersOrAttributeOrNamespaceOrTypeDeclarationStartOrLastIdentifier);
   //if (this.sink != null && this.currentToken == Token.EndOfFile){
   //  TypeAlias ta = new TypeAlias(new TypeExpression(new Identifier(" ", this.scanner.CurrentSourceContext)), Identifier.Empty);
   //  parentNamespace.Types.Add(ta);
   //}
   Debug.Assert(followers[this.currentToken]);
 }
Exemple #3
0
 public override Namespace VisitNamespace(Namespace nspace)
 {
     this.VisitTypeNodeList(nspace.Types);
     return nspace;
 }
Exemple #4
0
    CompilationUnit CreateCompilationUnit(Module module, TypeNode type) {
      
      CompilationUnit cu = new CompilationUnit();
      cu.Namespaces = new NamespaceList();      
      cu.TargetModule = module;
      this.cunit = cu;
      this.module = module;

      Namespace ns = new Namespace(Identifier.Empty, Identifier.Empty, new AliasDefinitionList(), new UsedNamespaceList(), new NamespaceList(), new TypeNodeList());
      cu.Namespaces.Add(ns);      

      ns.UsedNamespaces.Add(new UsedNamespace(Identifier.For("System")));
      ns.UsedNamespaces.Add(new UsedNamespace(Identifier.For("System.Xml")));
      ns.UsedNamespaces.Add(new UsedNamespace(Identifier.For("Microsoft.Comega"))); // XmlSerializationWriter

      CreateSerializerFor(type);
      return cu;
    }
Exemple #5
0
        /// <summary>
        /// Store the type in the catalog indexed by namespace
        /// </summary>
        /// <param name="type">The type to store in the catalog</param>
        private void StoreType(TypeNode type)
        {
            string spaceName = GetNamespaceName(type);
            Namespace space;

            if(!catalog.TryGetValue(spaceName, out space))
            {
                space = new Namespace(new Identifier(spaceName));
                catalog.Add(spaceName, space);
            }

            if(space.Types == null)
                throw new InvalidOperationException("Null type list encountered");

            space.Types.Add(type);

            // Store nested types as well
            foreach(var member in type.Members)
            {
                TypeNode nestedType = member as TypeNode;

                if(nestedType != null)
                    this.StoreType(nestedType);
            }
        }
Exemple #6
0
 public override bool IsExposedNamespace(Namespace space) {
     return (true);
 }
        // Members

        private void WriteNamespaceElements(Namespace space) {
            TypeNodeList types = space.Types;
            if (types.Count == 0) return;
            writer.WriteStartElement("elements");
            for (int i = 0; i < types.Count; i++) {
                TypeNode type = types[i];
                //skip hidden types, but if a type is not exposed and has exposed members we must add it
                if (!ApiFilter.IsExposedType(type) && !ApiFilter.HasExposedMembers(type)) continue;
                writer.WriteStartElement("element");
                writer.WriteAttributeString("api", namer.GetTypeName(type));
                writer.WriteEndElement();
            }
            writer.WriteEndElement();
        }
 protected override void VisitNamespace(Namespace space) {
     parsedNamespaces.Add(space);
     WriteNamespace(space);
     base.VisitNamespace(space);
 }
Exemple #9
0
 public virtual void FindTypesToBeDuplicated(Namespace nspace)
 {
     if (nspace == null) return;
     this.FindTypesToBeDuplicated(nspace.Types);
     this.FindTypesToBeDuplicated(nspace.NestedNamespaces);
 }
Exemple #10
0
 private void ParseTypeDeclaration(Namespace ns, TypeNode parentType, AttributeList attributes, TokenList modifierTokens,
   SourceContextList modifierContexts, TypeFlags flags, bool isPartial, SourceContext sctx, TokenSet followers){
   if (parentType is Interface){
     this.HandleError(Error.InterfacesCannotContainTypes);
     modifierTokens = null;
   }
   TypeNode t = null;
   InvariantCt = 0;
   switch(this.currentToken){
     case Token.Class:
       Class c = new Class();
       t = c;
       if (parentType == null)
         t.DeclaringNamespace = ns;
       else
         t.DeclaringType = parentType;
       if (modifierTokens != null)
         t.Flags |= this.NestedTypeFlags(modifierTokens, modifierContexts, t, isPartial)|TypeFlags.BeforeFieldInit;
       else{
         t.IsUnsafe = this.inUnsafeCode;
         t.Flags |= flags|TypeFlags.BeforeFieldInit;
       }
       if (t.IsAbstract && t.IsSealed && t.IsSpecialName){
         c.IsAbstractSealedContainerForStatics = true;
         c.Flags &= ~TypeFlags.SpecialName;
       }
       break;
     case Token.Interface:
       t = new Interface();
       if (parentType == null)
         t.DeclaringNamespace = ns;
       else
         t.DeclaringType = parentType;
       if (modifierTokens != null)
         t.Flags |= this.NestedTypeFlags(modifierTokens, modifierContexts, t, isPartial);
       else{
         if ((flags & TypeFlags.Abstract) != 0){
           if ((flags & TypeFlags.Sealed) != 0 && (flags & TypeFlags.SpecialName) != 0){
             this.HandleError(Error.InvalidModifier, "static");
             flags &= ~(TypeFlags.Abstract|TypeFlags.Sealed|TypeFlags.SpecialName);
           }else{
             this.HandleError(Error.InvalidModifier, "abstract");
             flags &= ~TypeFlags.Abstract;
           }
         }else if ((flags & TypeFlags.Sealed) != 0){
           this.HandleError(Error.InvalidModifier, "sealed");
           flags &= ~TypeFlags.Sealed;
         }
         t.IsUnsafe = this.inUnsafeCode;
         t.Flags |= flags|TypeFlags.BeforeFieldInit;
       }
       break;
     case Token.Struct:
       t = new Struct();
       if (parentType == null)
         t.DeclaringNamespace = ns;
       else
         t.DeclaringType = parentType;
       if (modifierTokens != null)
         t.Flags |= this.NestedTypeFlags(modifierTokens, modifierContexts, t, isPartial)|TypeFlags.BeforeFieldInit;
       else{
         if ((flags & TypeFlags.Abstract) != 0){
           if ((flags & TypeFlags.Sealed) != 0 && (flags & TypeFlags.SpecialName) != 0){
             this.HandleError(Error.InvalidModifier, "static");
             flags &= ~(TypeFlags.Abstract|TypeFlags.Sealed|TypeFlags.SpecialName);
           }else{
             this.HandleError(Error.InvalidModifier, "abstract");
             flags &= ~TypeFlags.Abstract;
           }
         }else if ((flags & TypeFlags.Sealed) != 0){
           this.HandleError(Error.InvalidModifier, "sealed");
         }
         t.IsUnsafe = this.inUnsafeCode;
         t.Flags |= flags|TypeFlags.BeforeFieldInit;
       }
       break;
     default:
       Debug.Assert(false);
       break;
   }
   t.Attributes = attributes;
   t.SourceContext = sctx;
   t.DeclaringModule = this.module;
   t.Documentation = this.LastDocComment;
   this.GetNextToken();
   t.Name = this.scanner.GetIdentifier();
   if (Parser.IdentifierOrNonReservedKeyword[this.currentToken])
     this.GetNextToken();
   else{
     this.SkipIdentifierOrNonReservedKeyword();
     if (Parser.IdentifierOrNonReservedKeyword[this.currentToken]){
       t.Name = this.scanner.GetIdentifier();
       this.GetNextToken();
     }
   }
   if (this.currentToken == Token.LessThan)
     this.ParseTypeParameters(t, followers|Token.Colon|Token.LeftBrace|Token.Where);
   if (parentType != null){
     t.Namespace = Identifier.Empty;
     if (parentType.IsGeneric) t.IsGeneric = true;
   }else
     t.Namespace = ns.FullNameId;
   Identifier mangledName = t.Name;
   if (Cci.TargetPlatform.GenericTypeNamesMangleChar != 0) {
     int numPars = t.TemplateParameters == null ? 0 : t.TemplateParameters.Count;
     if (numPars > 0){
       mangledName = new Identifier(t.Name.ToString() + Cci.TargetPlatform.GenericTypeNamesMangleChar + numPars.ToString(), t.Name.SourceContext);
       t.IsGeneric = this.useGenerics;
     }
   }
   t.PartiallyDefines = this.GetCompleteType(t, mangledName, isPartial);
   if (isPartial){
     isPartial = t.PartiallyDefines != null;
     if (!isPartial)
       t.Name = new Identifier(t.Name+" "+t.UniqueKey, t.Name.SourceContext);
   }else
     isPartial = t.PartiallyDefines != null;
   if (parentType != null){
     if (!isPartial || parentType.PartiallyDefines != null)
       parentType.Members.Add(t);
   }else{
     ns.Types.Add(t);
     if (!isPartial) this.AddTypeToModule(t);
   }
   if (this.currentToken == Token.Colon){
     this.GetNextToken();
     t.Interfaces = this.ParseInterfaceList(followers|Token.LeftBrace|Token.Where, true); //The first of these might be the base class, but that is a semantic issue
   }else
     t.Interfaces = new InterfaceList(); //TODO: omit this?
   t.InterfaceExpressions = t.Interfaces;
   while (this.currentToken == Token.Where)
     this.ParseTypeParameterConstraint(t, followers|Token.LeftBrace|Token.Where);
   t.SourceContext.EndPos = this.scanner.endPos;
   SourceContext typeBodyCtx = this.scanner.CurrentSourceContext;
   this.Skip(Token.LeftBrace);
 tryAgain:
   this.ParseTypeMembers(t, followers|Token.RightBrace);
   if (this.currentToken == Token.Namespace){
     this.HandleError(Error.InvalidMemberDecl, this.scanner.CurrentSourceContext.SourceText);
     this.currentToken = Token.Class;
     goto tryAgain;
   }
   int endCol = this.scanner.endPos;
   this.ParseBracket(t.SourceContext, Token.RightBrace, followers|Token.Semicolon, Error.ExpectedRightBrace);
   t.SourceContext.EndPos = endCol;
   t.Name = mangledName;
   if (this.currentToken == Token.Semicolon)
     this.GetNextToken();
   if (this.sink != null){
     typeBodyCtx.EndPos = endCol;
     this.sink.AddCollapsibleRegion(typeBodyCtx, false);
   }
   this.SkipTo(followers|Parser.TypeMemberStart);
   if (!followers[this.currentToken])
     this.SkipTo(followers, Error.NamespaceUnexpected);
   if (isPartial) this.MergeWithCompleteType(t);
 }
Exemple #11
0
 private void ParseTypeDeclaration(Namespace ns, TypeNode parentType, AttributeList attributes, TokenList modifierTokens,
   SourceContextList modifierContexts, bool isPartial, SourceContext sctx, TokenSet followers){
   this.ParseTypeDeclaration(ns, parentType, attributes, modifierTokens, modifierContexts, TypeFlags.None, isPartial, sctx, followers);
 }
Exemple #12
0
 private void ParseTypeDeclaration(Namespace ns, TypeNode parentType, AttributeList attributes, TypeFlags flags, bool isPartial, SourceContext sctx, TokenSet followers){
   this.ParseTypeDeclaration(ns, parentType, attributes, null, null, flags, isPartial, sctx, followers);
 }
Exemple #13
0
 private AttributeList ParseAttributes(Namespace ns, TokenSet followers){
   if (this.currentToken != Token.LeftBracket) return null;
   AttributeList attributes = new AttributeList();
   bool allowGlobalAttributes = ns != null && ns.Name == Identifier.Empty &&
     (ns.NestedNamespaces == null || ns.NestedNamespaces.Count == 0) && (ns.Types == null || ns.Types.Count == 0);
   while(this.currentToken == Token.LeftBracket){
     SourceContext sctx = this.scanner.CurrentSourceContext;
     this.GetNextToken();
     AttributeTargets flags = (AttributeTargets)0;
     Identifier id = this.scanner.GetIdentifier();
     SourceContext attrCtx = this.scanner.CurrentSourceContext;
     switch(this.currentToken){
       case Token.Event:
       case Token.Identifier:
       case Token.Return:
         this.GetNextToken();
         if (this.currentToken == Token.Colon){
           this.GetNextToken();
           int key = id.UniqueIdKey;
           if (key == Parser.assemblyId.UniqueIdKey)
             flags = AttributeTargets.Assembly;
           else if (key == Parser.eventId.UniqueIdKey)
             flags = AttributeTargets.Event;
           else if (key == Parser.fieldId.UniqueIdKey)
             flags = AttributeTargets.Field;
           else if (key == Parser.methodId.UniqueIdKey)
             flags = AttributeTargets.Method|AttributeTargets.Constructor;
           else if (key == Parser.moduleId.UniqueIdKey)
             flags = AttributeTargets.Module;
           else if (key == Parser.paramId.UniqueIdKey)
             flags = AttributeTargets.Parameter;
           else if (key == Parser.propertyId.UniqueIdKey)
             flags = AttributeTargets.Property;
           else if (key == Parser.returnId.UniqueIdKey)
             flags = AttributeTargets.ReturnValue;
           else if (key == Parser.typeId.UniqueIdKey)
             flags = AttributeTargets.Class|AttributeTargets.Delegate|AttributeTargets.Enum|AttributeTargets.Interface|AttributeTargets.Struct;
           else{
             flags = (AttributeTargets)int.MaxValue;
             this.HandleError(Error.InvalidAttributeLocation, id.ToString());
           }
           id = this.scanner.GetIdentifier();
           this.SkipIdentifierOrNonReservedKeyword();
         }
         break;
       default:
         this.SkipIdentifierOrNonReservedKeyword();
         break;
     }
     for(;;){
       AttributeNode attr = new AttributeNode();
       attr.SourceContext = attrCtx;
       attr.Target = flags;
       if (this.currentToken == Token.DoubleColon){
         Identifier prefix = id;
         this.GetNextToken();
         id = this.scanner.GetIdentifier();
         id.Prefix = prefix;
         id.SourceContext.StartPos = prefix.SourceContext.StartPos;
         this.SkipIdentifierOrNonReservedKeyword();
       }
       if (this.sink != null) this.sink.StartName(id);
       if (this.currentToken == Token.Dot)
         attr.Constructor = this.ParseQualifiedIdentifier(id, followers|Token.Comma|Token.LeftParenthesis|Token.RightBracket);
       else
         attr.Constructor = id;
       this.ParseAttributeArguments(attr, followers|Token.Comma|Token.RightBracket);
       if (flags != (AttributeTargets)int.MaxValue){
         if (allowGlobalAttributes && (flags == AttributeTargets.Assembly || flags == AttributeTargets.Module)){
           if (ns.Attributes == null) ns.Attributes = new AttributeList();
           ns.Attributes.Add(attr);
         }else
           attributes.Add(attr);
       }
       if (this.currentToken != Token.Comma) break;
       this.GetNextToken();
       if (this.currentToken == Token.RightBracket) break;
       id = this.scanner.GetIdentifier();
       this.SkipIdentifierOrNonReservedKeyword();
     }
     this.ParseBracket(sctx, Token.RightBracket, followers, Error.ExpectedRightBracket);
   }
   this.SkipTo(followers);
   return attributes;
 }
Exemple #14
0
    private void ParseTypeDeclarations(Namespace ns, TokenSet followers){
      for(;;){
        SourceContext sctx = this.scanner.CurrentSourceContext;
        AttributeList attributes = this.ParseAttributes(ns, followers|Parser.AttributeOrTypeDeclarationStart);
        Token tok = this.currentToken;
        this.inUnsafeCode = false;
        TypeFlags flags = this.ParseTypeModifiers();
        switch (this.currentToken){
          case Token.Class:
          case Token.Interface:
          case Token.Struct: this.ParseTypeDeclaration(ns, null, attributes, flags, false, sctx, followers); break;
          case Token.Delegate: this.ParseDelegateDeclaration(ns, null, attributes, flags, sctx, followers); break;
          case Token.Enum: this.ParseEnumDeclaration(ns, null, attributes, flags, sctx, followers); break;
          case Token.Namespace:
            if (tok != this.currentToken || (attributes != null && attributes.Count > 0))
              this.HandleError(Error.BadTokenInType);
            return;
          case Token.LeftBracket:
            this.HandleError(Error.BadTokenInType);
            this.GetNextToken();
            return;
          case Token.MultiLineDocCommentStart:
          case Token.SingleLineDocCommentStart:
            this.ParseDocComment(followers);
            break;
          case Token.Partial:
            SourceContext pctx = this.scanner.CurrentSourceContext;
            this.GetNextToken();
            switch (this.currentToken){
              case Token.Class:
              case Token.Struct:
              case Token.Interface:
                this.ParseTypeDeclaration(ns, null, attributes, flags, true, sctx, followers); break;
              case Token.Enum:
                this.HandleError(Error.PartialMisplaced);
                this.ParseEnumDeclaration(ns, null, attributes, flags, sctx, followers); break;
              default:
                if (this.currentToken == Token.Namespace)
                  this.HandleError(Error.BadModifiersOnNamespace);
                else
                  this.HandleError(Error.PartialMisplaced);
                this.SkipTo(followers, Error.None);
                return;
            }
            break;
          default:
            if (!followers[this.currentToken])
              this.SkipTo(followers, Error.BadTokenInType);
            else if (this.currentToken == Token.EndOfFile && attributes != null){
              Class dummy = new Class(this.module, null, attributes, TypeFlags.Public, ns.Name, Identifier.Empty, null, null, new MemberList(0));
              ns.Types.Add(dummy);
              //this.sink = null;
            }
            return;
        }

        this.inUnsafeCode = false;
      }
    }
Exemple #15
0
 private void ParseNamespaceOrTypeDeclarations(Namespace parentNamespace, TokenSet followers){
   if (this.currentToken == Token.Identifier){
     TypeAlias ta = new TypeAlias(new TypeExpression(this.scanner.GetIdentifier()), Identifier.Empty);
     parentNamespace.Types.Add(ta);
     ta.SourceContext = this.scanner.CurrentSourceContext;
     this.GetNextToken();
     return;
   }
   if (this.currentToken == Token.Private || this.currentToken == Token.Protected){
     this.HandleError(Error.PrivateOrProtectedNamespaceElement);
     this.GetNextToken();
   }
   if (this.currentToken == Token.Namespace){
     SourceContext openContext = this.scanner.CurrentSourceContext;
     this.GetNextToken();
     TokenSet nsFollowers = followers|Token.RightBrace;
     Identifier nsId = this.ParseNamespaceName(Identifier.Empty, false, nsFollowers|Token.LeftBrace);
     Identifier nsFullId = parentNamespace.Name == Identifier.Empty ? nsId : Identifier.For(parentNamespace.FullName+"."+nsId);
     Namespace ns = new Namespace(nsId, nsFullId, new AliasDefinitionList(), new UsedNamespaceList(), new NamespaceList(), new TypeNodeList());
     ns.DeclaringNamespace = parentNamespace;
     ns.SourceContext = openContext;
     if (this.currentToken == Token.LeftBrace) openContext.EndPos = this.scanner.endPos;
     SourceContext nsBodyCtx = this.scanner.CurrentSourceContext;
     this.Skip(Token.LeftBrace);
     parentNamespace.NestedNamespaces.Add(ns);
     this.ParseExternalAliasDirectives(ns, nsFollowers|Parser.NamespaceOrTypeDeclarationStart|Token.Using|Token.LastIdentifier);
     this.ParseUsingDirectives(ns, nsFollowers|Token.LastIdentifier|Parser.NamespaceOrTypeDeclarationStart);
     this.ParseNamespaceMemberDeclarations(ns, nsFollowers);
     if (this.currentToken == Token.RightBrace && this.sink != null)
       this.sink.MatchPair(openContext, this.scanner.CurrentSourceContext);
     ns.SourceContext.EndPos = this.scanner.endPos;
     this.Skip(Token.RightBrace);
     if (this.currentToken == Token.Semicolon) this.GetNextToken();
     if (this.sink != null){
       nsBodyCtx.EndPos = this.scanner.endPos;
       this.sink.AddCollapsibleRegion(nsBodyCtx, false);
     }
   }else
     this.ParseTypeDeclarations(parentNamespace, followers);
   if (!followers[this.currentToken])
     this.SkipTo(followers, Error.EOFExpected);
 }
Exemple #16
0
 private static int CompareNamespaces(Namespace a, Namespace b) {
     return (String.Compare(a.Name.Name, b.Name.Name));
 }
Exemple #17
0
        private void StoreType(TypeNode type) {
            //Console.WriteLine("type: {0} ", type.Name);
            /*
            if (type.Name == null) {
                // CCI seems to occasionally construct corrupted, phantom types, which we should reject 
                // Console.WriteLine("unidentified type rejected");
                return;
            }
            */
            string spaceName = GetNamespaceName(type);
            //Console.WriteLine("in space: {0}", spaceName);
            Namespace space;
            if (!catalog.TryGetValue(spaceName, out space)) {
                space = new Namespace(new Identifier(spaceName));
                catalog.Add(spaceName, space);
            }
            if (space.Types == null) Console.WriteLine("null type list");
            space.Types.Add(type);

            //Console.WriteLine("getting members");
            MemberList members = type.Members;
            //Console.WriteLine("got {0} members", members.Count);
            for (int i = 0; i < members.Count; i++) {
                TypeNode nestedType = members[i] as TypeNode;
                if (nestedType != null) {
                    //Console.WriteLine("nested type {0}", type.FullName);
                    StoreType(nestedType);
                }
            }
            //Console.WriteLine("done storing type");
        }
Exemple #18
0
 public override Namespace VisitNamespace(Namespace nspace)
 {
     if (nspace == null) return null;
     return base.VisitNamespace((Namespace)nspace.Clone());
 }
        private void WriteNamespace(Namespace space) {
            writer.WriteStartElement("api");
            writer.WriteAttributeString("id", namer.GetNamespaceName(space));
            StartElementCallbacks("api", space);

            WriteApiData(space);
            WriteNamespaceElements(space);

            EndElementCallbacks("api", space);
            writer.WriteEndElement();
        }
Exemple #20
0
        /// <summary>
        /// This is used to see if a namespace is exposed
        /// </summary>
        /// <param name="space">The namespace to check</param>
        /// <returns>True if the namespace contains any exposed types or types with exposed members, false if not</returns>
        public virtual bool IsExposedNamespace(Namespace space)
        {
            if(space == null)
                throw new ArgumentNullException("space");

            // !EFW - Bug fix.  Some obfuscated assemblies have mangled names containing characters that
            // are not valid in XML.  Exclude those by default.
            if(space.FullName.HasInvalidXmlCharacters())
                return false;

            string name = space.Name.Name;

            // Look in cache to see if namespace exposure is already determined
            bool exposed;

            if(!namespaceCache.TryGetValue(name, out exposed))
            {
                // The namespace is exposed if any types in it are exposed              
                exposed = this.NamespaceContainsExposedTypes(space) ?? false;

                // the namespace is also exposed if it contains exposed members, even if all types are hidden
                if(!exposed)
                    exposed = this.NamespaceContainsExposedMembers(space);

                // Cache the result 
                namespaceCache.Add(name, exposed);
            }

            return exposed;
        }
 private void WriteNamespaceReference(Namespace space) {
     writer.WriteStartElement("namespace");
     writer.WriteAttributeString("api", namer.GetNamespaceName(space));
     writer.WriteEndElement();
 }
Exemple #22
0
        /// <summary>
        /// Check for any exposed types in a namespace
        /// </summary>
        /// <param name="space">The namespace to check</param>
        /// <returns>True if the namespace contains exposed types, false if it does not, or null if there are no
        /// exposed types but the API filter is empty.</returns>
        private bool? NamespaceContainsExposedTypes(Namespace space)
        {
            foreach(var type in space.Types)
                if(this.IsExposedType(type))
                    return true;

            return (apiFilter.NamespaceFilterCount == 0) ? (bool?)null : false;
        }
 public virtual Namespace VisitNamespace(Namespace nspace)
 {
     if (nspace == null) return null;
     nspace.AliasDefinitions = this.VisitAliasDefinitionList(nspace.AliasDefinitions);
     nspace.UsedNamespaces = this.VisitUsedNamespaceList(nspace.UsedNamespaces);
     nspace.Attributes = this.VisitAttributeList(nspace.Attributes);
     nspace.Types = this.VisitTypeNodeList(nspace.Types);
     nspace.NestedNamespaces = this.VisitNamespaceList(nspace.NestedNamespaces);
     return nspace;
 }
Exemple #24
0
        /// <summary>
        /// Check for any exposed members in any of the types
        /// </summary>
        /// <param name="space">The namespace to check</param>
        /// <returns>True if the type has an exposed member filter and it is matched are set to true.</returns>
        /// <remarks>This is used to determine if the namespace should be visited.  If the namespace and all
        /// types are set to false for exposed, we still want to visit them if any members are visible.</remarks>
        private bool NamespaceContainsExposedMembers(Namespace space)
        {
            foreach(var type in space.Types)
                if(this.HasExposedMembers(type))
                    return true;

            return false;
        }
Exemple #25
0
 /// <summary>
 /// This is used to visit a namespace
 /// </summary>
 /// <param name="space">The namespace to visit</param>
 protected virtual void VisitNamespace(Namespace space)
 {
     this.VisitEntity(space);
     this.VisitTypes(space.Types);
 }
Exemple #26
0
 /// <summary>
 /// Check to see if the namespace is exposed or not by this entry
 /// </summary>
 /// <param name="space">The namespace to check</param>
 /// <returns>Null if the namespace is not represented by this entry, true if it is and it is exposed or
 /// false if it is and it is not exposed.</returns>
 public bool? IsExposedNamespace(Namespace space)
 {
     return (space.Name.Name == name) ? exposed : (bool?)null;
 }
Exemple #27
0
        //=====================================================================

        /// <inheritdoc />
        public override string GetNamespaceName(Namespace space)
        {
            return "N:" + space.Name;
        }
Exemple #28
0
 protected virtual void VisitNamespace(Namespace space) {
     //Console.WriteLine("Visit Entity {0}",space.FullName);
     VisitEntity(space);
     TypeNodeList types = space.Types;
     VisitTypes(types);
 }
Exemple #29
0
 /// <summary>
 /// This method is used to get the namespace name
 /// </summary>
 /// <param name="space">The namespace for which to get the name</param>
 /// <returns>The namespace name</returns>
 public abstract string GetNamespaceName(Namespace space);
Exemple #30
0
 protected virtual void VisitNamespaces(NamespaceList spaces) {
     // sort namespaces by name
     Namespace[] sorted_spaces = new Namespace[spaces.Count];
     for (int i = 0; i < spaces.Count; i++) sorted_spaces[i] = spaces[i];
     Array.Sort < Namespace >(sorted_spaces, namespaceComparison);
     // visit them
     foreach (Namespace space in sorted_spaces) {
         if (filter.IsExposedNamespace(space)) VisitNamespace(space);
     }
 }