public override void VisitNamespaceDecl(NamespaceDecl x) { using (new ScopeHelper(this, x)) { base.VisitNamespaceDecl(x); } }
public override void VisitNamespaceDecl(NamespaceDecl x) { _naming = x.Naming; _current = Connect(_current, NewBlock()); // create new block with new naming base.VisitNamespaceDecl(x); }
private void InitializeFields() { strBufStack.Clear(); //docCommentStack = null; condLevel = 0; Debug.Assert(sourceUnit != null); if (sourceUnit.CurrentNamespace.HasValue && sourceUnit.CurrentNamespace.Value.Namespaces.Length > 0) { // J: inject current namespace from sourceUnit: this.currentNamespace = new AST.NamespaceDecl(Position.Initial, sourceUnit.CurrentNamespace.Value.ToStringList(), true); // add aliases into the namespace: if (sourceUnit.Aliases.Count > 0) { foreach (var alias in sourceUnit.Aliases) { this.currentNamespace.Aliases.Add(alias.Key, alias.Value); } } } else { this.currentNamespace = null; } }
public void Typecheck() { foreach (InstrNode node in ast.Instructions) { NamespaceDecl nmsp = ((NamespaceDecl)node.Value); topLevelEnvironment.AddEntry(nmsp.Name.Seq, new Namespace(), node.Position); new NamespaceChecker(nmsp.Block, topLevelEnvironment).Typecheck(); } }
public override void VisitNamespaceDecl(NamespaceDecl x) { VisitSpecificElementProlog(); SerializeToken(nameof(x.QualifiedName), x.QualifiedName.ToString(), x.QualifiedName.Span); SerializeToken(nameof(x.IsAnonymous), x.IsAnonymous.ToString(), null); base.VisitNamespaceDecl(x); }
/// <summary> /// Visit namespace statements. /// </summary> /// <param name="x"></param> override public void VisitNamespaceDecl(NamespaceDecl x) { _serializer.StartSerialize(typeof(NamespaceDecl).Name, SerializeSpan(x.Span), new NodeObj("Name", x.QualifiedName.QualifiedName.NamespacePhpName), new NodeObj("SimpleSyntax", x.IsSimpleSyntax.ToString()), SerializeNamingContext(x.Naming)); SerializePHPDoc(x.PHPDoc); SerializeOptionalProperty("Body", x.Body); _serializer.EndSerialize(); }
/// <summary> /// Visit declaration of namespace. /// </summary> /// <param name="x">NamespaceDecl</param> public override void VisitNamespaceDecl(NamespaceDecl x) { if (x.Statements != null) { foreach (Statement s in x.Statements) { s.VisitMe(this); } } }
// Looks up a namespace in the list of current namespaces in scope string LookupNamespace(string prefix, NamespaceDecl namespacesInScope) { while (namespacesInScope != null) { if (prefix == namespacesInScope.prefix) { return(namespacesInScope.namespaceUri); } namespacesInScope = namespacesInScope.previousDecl; } return(null); }
// // Constructor // public XmlBookmarkReader(XmlReader reader) { this.reader = reader; // initialize namespaces XmlNameTable nt = reader.NameTable; currentNamespacesInScope = new NamespaceDecl(nt.Add("xml"), nt.Add("http://www.w3.org/XML/1998/namespace"), null); currentNamespacesInScope = new NamespaceDecl(nt.Add("xmlns"), nt.Add("http://www.w3.org/2000/xmlns/"), currentNamespacesInScope); currentNamespacesInScope = new NamespaceDecl(nt.Add(string.Empty), nt.Add(string.Empty), currentNamespacesInScope); currentNamespacesInScope.scopeCount++; nextNamespacesInScope = currentNamespacesInScope; bookmarks = new Hashtable(); }
internal CachedXmlNode(XmlNodeType nodeType, string name, string localName, string prefix, string namespaceUri, string value, int depth, NamespaceDecl namespacesInScope, CachedXmlNode next) { this.nodeType = nodeType; this.name = name; this.localName = localName; this.prefix = prefix; this.namespaceUri = namespaceUri; this.value = value; this.depth = depth; this.namespacesInScope = namespacesInScope; this.next = next; isDefaultOrEmpty = false; this.attributes = null; }
// On element start tag it walks though the attributes of an element to find all namespace declaration and adds them to the namespace tree. // On End tag it adjusts the reference to the next namespace scope which will be applies on the next Read void ProcessNamespaces() { NamespaceDecl originalNamespaces = currentNamespacesInScope; XmlNodeType nodeType = reader.NodeType; switch (nodeType) { case XmlNodeType.Element: if (reader.MoveToFirstAttribute()) { do { if (reader.NamespaceURI == "http://www.w3.org/2000/xmlns/") { // add namespace string prefix = (reader.Prefix.Length == 0) ? string.Empty : reader.LocalName; currentNamespacesInScope = new NamespaceDecl(prefix, reader.NameTable.Add(reader.Value), currentNamespacesInScope); } } while (reader.MoveToNextAttribute()); reader.MoveToElement(); } if (reader.IsEmptyElement) { nextNamespacesInScope = originalNamespaces; } else { nextNamespacesInScope = currentNamespacesInScope; // push scope currentNamespacesInScope.scopeCount++; } break; case XmlNodeType.EndElement: // pop scope NamespaceDecl decl = currentNamespacesInScope; decl.scopeCount--; while (decl.scopeCount == 0) { decl = decl.previousDecl; } nextNamespacesInScope = decl; break; } }
public override bool Read() { // have current node -> we are replaying if (curNode != null) { // recover from iterating over attributes if (curAttrParent != null) { curNode = curAttrParent; if (attributeTextValue != null) { attributeTextValue.next = null; } } // move to next node in the list if (curNode.next != null) { SetCurrentNode(curNode.next); return(true); } // end of cached nodes else { curNode = null; } } // pop namespace scope if previous node was an end element or an empty element currentNamespacesInScope = nextNamespacesInScope; // read next node from the reader if (!reader.Read()) { return(false); } // save namespaces ProcessNamespaces(); // have some bookmark need to cache the node if (bookmarks.Count > 0) { CacheCurrentNode(); } return(true); }
private static void ListPrepend <T>(object /*!*/ list, object /*!*/ item) { Debug.Assert(list != null); Debug.Assert(item != null); Debug.Assert(item is T); var tlist = (List <T>)list; // little hack when prepending simple syntaxed namespace before some statements: // namespace A; // == {item} // stmt1; stmt2; // <-- add these stamenents into namespace A // namespace B; NamespaceDecl nsitem = item as NamespaceDecl; if (nsitem != null && nsitem.IsSimpleSyntax) { Debug.Assert(list is List <Statement>); var slist = (List <Statement>)list; // move statements into nsitem namespace: int i = 0; // find how many Statements from tlist move to nsitem.Statements while (i < slist.Count && !(slist[i] is NamespaceDecl)) { ++i; } if (i > 0) { nsitem.Statements.AddRange(slist.Take(i)); //nsitem.UpdatePosition(Position.CombinePositions(nsitem.Position, slist[i - 1].Position)); tlist.RemoveRange(0, i); } } // prepend the item: tlist.Insert(0, (T)item); }
public override void VisitNamespaceDecl(NamespaceDecl x) { ConsumeToken(Tokens.T_NAMESPACE, "namespace", x.Span.Start); if (x.QualifiedName.HasValue) { VisitQualifiedName(x.QualifiedName.QualifiedName.WithFullyQualified(false)); } if (x.IsSimpleSyntax) { // namespace QNAME; BODY ConsumeToken(Tokens.T_SEMI, ";"); VisitList(x.Body.Statements); } else { // namespace QNAME { BODY } } VisitElement(x.Body); }
/// <summary> /// Combines name and its namespace. /// </summary> /// <param name="name">Name.</param> /// <param name="ns">Can be <c>null</c>.</param> /// <returns></returns> public static QualifiedName MakeQualifiedName(Name name, NamespaceDecl ns) { return (ns != null && ns.QualifiedName.HasValue) ? new QualifiedName(name, ns.QualifiedName.QualifiedName.Namespaces) : new QualifiedName(name); }
public override void VisitNamespaceDecl(NamespaceDecl x) { _statementContext = VariableKind.GlobalVariable; base.VisitNamespaceDecl(x); }
public void NamespaceDeclReduced(Parser parser, NamespaceDecl decl) { }
void PopNamespaces(NamespaceDecl firstInScopeChain) { NamespaceDecl decl = firstInScopeChain; while (null != decl) { if (null == decl.prevLink) this.namespaces.Remove(decl.prefix); else this.namespaces[decl.prefix] = decl.prevLink; NamespaceDecl next = decl.scopeLink; // unlink chains for better gc behaviour decl.prevLink = null; decl.scopeLink = null; decl = next; } }
static SymbolDecl[] ParseSymbolInternal(string[] tokens, ref int index) { if (CppParser.Token(tokens, ref index, "public") || CppParser.Token(tokens, ref index, "protected") || CppParser.Token(tokens, ref index, "private")) { index--; return(null); } TemplateDecl templateDecl = null; if (CppParser.Token(tokens, ref index, "template")) { templateDecl = new TemplateDecl { TypeParameters = new List <TypeParameterDecl>(), Specialization = new List <TypeDecl>(), }; CppParser.EnsureToken(tokens, ref index, "<"); if (!CppParser.Token(tokens, ref index, ">")) { while (true) { string token = null; CppParser.SkipUntilInTemplate(tokens, ref index, out token, ",", ">", "="); index -= 2; templateDecl.TypeParameters.Add(new TypeParameterDecl { Name = CppParser.EnsureId(tokens, ref index), }); index++; if (token == "=") { CppParser.SkipUntilInTemplate(tokens, ref index, out token, ",", ">"); } if (token == ">") { break; } } } } if (CppParser.Token(tokens, ref index, "friend")) { int oldIndex = index - 1; string token = null; CppParser.SkipUntil(tokens, ref index, out token, ";", "{"); if (token == ";") { return(null); } else { index = oldIndex; tokens[index] = "static"; } } if (CppParser.Token(tokens, ref index, "namespace")) { if (templateDecl != null) { throw new ArgumentException("Failed to parse."); } var decl = new NamespaceDecl(); decl.Name = CppParser.EnsureId(tokens, ref index); CppParser.EnsureToken(tokens, ref index, "{"); ParseSymbols(tokens, ref index, decl); CppParser.EnsureToken(tokens, ref index, "}"); return(new SymbolDecl[] { decl }); } else if (CppParser.Token(tokens, ref index, "using")) { if (CppParser.Token(tokens, ref index, "namespace")) { if (templateDecl != null) { throw new ArgumentException("Failed to parse."); } var decl = new UsingNamespaceDecl(); decl.Path = new List <string>(); decl.Path.Add(CppParser.EnsureId(tokens, ref index)); while (!CppParser.Token(tokens, ref index, ";")) { CppParser.EnsureToken(tokens, ref index, ":"); CppParser.EnsureToken(tokens, ref index, ":"); decl.Path.Add(CppParser.EnsureId(tokens, ref index)); } return(new SymbolDecl[] { decl }); } else { string name = null; if (CppParser.Id(tokens, ref index, out name)) { if (templateDecl != null) { if (CppParser.Token(tokens, ref index, "<")) { while (true) { templateDecl.Specialization.Add(CppTypeParser.EnsureTypeWithoutName(tokens, ref index)); if (CppParser.Token(tokens, ref index, ">")) { break; } CppParser.EnsureToken(tokens, ref index, ","); } } } if (CppParser.Token(tokens, ref index, "=")) { SymbolDecl decl = new TypedefDecl { Name = name, Type = CppTypeParser.EnsureTypeWithoutName(tokens, ref index), }; CppParser.EnsureToken(tokens, ref index, ";"); if (templateDecl != null) { templateDecl.Element = decl; decl = templateDecl; } return(new SymbolDecl[] { decl }); } } if (templateDecl != null) { throw new ArgumentException("Failed to parse."); } CppParser.SkipUntil(tokens, ref index, ";"); } } else if (CppParser.Token(tokens, ref index, "typedef")) { if (templateDecl != null) { throw new ArgumentException("Failed to parse."); } string name = null; var type = CppTypeParser.EnsureTypeWithName(tokens, ref index, out name); CppParser.EnsureToken(tokens, ref index, ";"); var decl = new TypedefDecl(); decl.Name = name; decl.Type = type; return(new SymbolDecl[] { decl }); } else if (CppParser.Token(tokens, ref index, "enum")) { if (templateDecl != null) { throw new ArgumentException("Failed to parse."); } bool enumClass = CppParser.Token(tokens, ref index, "class"); string name = CppParser.EnsureId(tokens, ref index); if (CppParser.Token(tokens, ref index, ":")) { CppTypeParser.EnsureTypeWithoutName(tokens, ref index); } if (!CppParser.Token(tokens, ref index, ";")) { CppParser.EnsureToken(tokens, ref index, "{"); var decl = new EnumDecl { Name = name, EnumClass = enumClass, Children = new List <SymbolDecl>(), }; while (true) { if (CppParser.Token(tokens, ref index, "}")) { break; } while (index < tokens.Length && tokens[index].Length >= 3 && tokens[index].StartsWith("///")) { index++; } decl.Children.Add(new EnumItemDecl { Name = CppParser.EnsureId(tokens, ref index), }); string token = null; CppParser.SkipUntil(tokens, ref index, out token, ",", "}"); if (token == "}") { break; } } if (CppParser.Id(tokens, ref index, out name)) { var varDecl = new VarDecl { Static = false, Name = name, Type = new RefTypeDecl { Name = decl.Name, }, }; CppParser.EnsureToken(tokens, ref index, ";"); return(new SymbolDecl[] { decl, varDecl }); } else { CppParser.EnsureToken(tokens, ref index, ";"); return(new SymbolDecl[] { decl }); } } } else if (CppParser.Token(tokens, ref index, "struct") || CppParser.Token(tokens, ref index, "class") || CppParser.Token(tokens, ref index, "union")) { if (CppParser.Token(tokens, ref index, "{")) { if (tokens[index - 2] == "class") { throw new ArgumentException("Failed to parse."); } var decl = new GroupedFieldDecl { Grouping = tokens[index - 2] == "struct" ? Grouping.Struct : Grouping.Union, }; ParseSymbols(tokens, ref index, decl); CppParser.EnsureToken(tokens, ref index, "}"); CppParser.EnsureToken(tokens, ref index, ";"); return(new SymbolDecl[] { decl }); } else { string name = CppParser.EnsureId(tokens, ref index); if (!CppParser.Token(tokens, ref index, ";")) { var classDecl = new ClassDecl { ClassType = tokens[index - 2] == "struct" ? ClassType.Struct : tokens[index - 2] == "class" ? ClassType.Class : ClassType.Union, BaseTypes = new List <BaseTypeDecl>(), Name = name, }; if (templateDecl != null) { if (CppParser.Token(tokens, ref index, "<")) { if (!CppParser.Token(tokens, ref index, ">")) { while (true) { int oldIndex = index; try { templateDecl.Specialization.Add(CppTypeParser.EnsureTypeWithoutName(tokens, ref index)); } catch (ArgumentException) { index = oldIndex; CppParser.SkipUntilInTemplate(tokens, ref index, ",", ">"); index--; templateDecl.Specialization.Add(new ConstantTypeDecl { Value = tokens .Skip(oldIndex) .Take(index - oldIndex) .Aggregate((a, b) => a + " " + b), }); } if (CppParser.Token(tokens, ref index, ">")) { break; } CppParser.EnsureToken(tokens, ref index, ","); } } } } CppParser.Token(tokens, ref index, "abstract"); if (CppParser.Token(tokens, ref index, ":")) { while (true) { Access access = classDecl.ClassType == ClassType.Class ? Access.Private : Access.Public; CppParser.Token(tokens, ref index, "virtual"); if (CppParser.Token(tokens, ref index, "private")) { access = Access.Private; } else if (CppParser.Token(tokens, ref index, "protected")) { access = Access.Protected; } else if (CppParser.Token(tokens, ref index, "public")) { access = Access.Public; } CppParser.Token(tokens, ref index, "virtual"); classDecl.BaseTypes.Add(new BaseTypeDecl { Access = access, Type = CppTypeParser.EnsureTypeWithoutName(tokens, ref index), }); if (!CppParser.Token(tokens, ref index, ",")) { break; } } } CppParser.EnsureToken(tokens, ref index, "{"); while (true) { if (CppParser.Token(tokens, ref index, "}")) { break; } Access access = classDecl.ClassType == ClassType.Class ? Access.Private : Access.Public; if (CppParser.Token(tokens, ref index, "private")) { access = Access.Private; CppParser.EnsureToken(tokens, ref index, ":"); } else if (CppParser.Token(tokens, ref index, "protected")) { access = Access.Protected; CppParser.EnsureToken(tokens, ref index, ":"); } else if (CppParser.Token(tokens, ref index, "public")) { access = Access.Public; CppParser.EnsureToken(tokens, ref index, ":"); } ParseSymbols(tokens, ref index, classDecl, access); } SymbolDecl decl = classDecl; if (templateDecl != null) { templateDecl.Element = decl; decl = templateDecl; } if (CppParser.Id(tokens, ref index, out name)) { var varDecl = new VarDecl { Static = false, Name = name, Type = new RefTypeDecl { Name = classDecl.Name, }, }; CppParser.EnsureToken(tokens, ref index, ";"); return(new SymbolDecl[] { decl, varDecl }); } else { CppParser.EnsureToken(tokens, ref index, ";"); return(new SymbolDecl[] { decl }); } } } } else if (!CppParser.Token(tokens, ref index, ";")) { Function function = Function.Function; { int oldIndex = index; string name = null; if (CppParser.Id(tokens, ref index, out name)) { if (CppParser.Token(tokens, ref index, "(")) { CppParser.SkipUntil(tokens, ref index, ")"); if (CppParser.Token(tokens, ref index, ";") || CppParser.Token(tokens, ref index, "=") || CppParser.Token(tokens, ref index, ":") || CppParser.Token(tokens, ref index, "{")) { function = Function.Constructor; } } index = oldIndex; } else if (CppParser.Token(tokens, ref index, "~")) { function = Function.Destructor; } } if (function == Function.Function) { Virtual virtualFunction = Virtual.Normal; CppParser.Token(tokens, ref index, "extern"); CppParser.Token(tokens, ref index, "mutable"); if (CppParser.Token(tokens, ref index, "virtual")) { virtualFunction = Virtual.Virtual; } else if (CppParser.Token(tokens, ref index, "static")) { virtualFunction = Virtual.Static; } CppParser.Token(tokens, ref index, "inline"); CppParser.Token(tokens, ref index, "__forceinline"); if (CppParser.Token(tokens, ref index, "operator")) { TypeDecl returnType = null; { int oldIndex = index; CppParser.SkipUntilInTemplate(tokens, ref index, "("); int modify = --index; tokens[modify] = "$"; index = oldIndex; returnType = CppTypeParser.EnsureTypeWithoutName(tokens, ref index); if (index != modify) { throw new ArgumentException("Failed to parse."); } tokens[modify] = "("; } var decl = new FuncDecl { Virtual = Virtual.Normal, Name = "operator", Function = function, }; TypeDecl functionType = null; Action <TypeDecl> continuation = null; CallingConvention callingConvention = CallingConvention.Default; CppTypeParser.ParseTypeContinueAfterName(tokens, ref index, ref callingConvention, out functionType, out continuation); continuation(returnType); decl.Type = functionType; if (!CppParser.Token(tokens, ref index, ";")) { CppParser.EnsureToken(tokens, ref index, "{"); CppParser.SkipUntil(tokens, ref index, "}"); } if (templateDecl != null) { templateDecl.Element = decl; return(new SymbolDecl[] { templateDecl }); } else { return(new SymbolDecl[] { decl }); } } else { string name = null; TypeDecl type = null; if (CppTypeParser.ParseType(tokens, ref index, out type, out name)) { if (name == null) { throw new ArgumentException("Failed to parse."); } if (type is FunctionTypeDecl) { if (CppParser.Token(tokens, ref index, "=")) { if (CppParser.Token(tokens, ref index, "0")) { virtualFunction = Virtual.Abstract; } else { CppParser.EnsureToken(tokens, ref index, "default", "delete"); } } var decl = new FuncDecl { Virtual = virtualFunction, Name = name, Type = type, Function = Function.Function, }; if (!CppParser.Token(tokens, ref index, ";")) { CppParser.EnsureToken(tokens, ref index, "{"); CppParser.SkipUntil(tokens, ref index, "}"); } if (templateDecl != null) { templateDecl.Element = decl; return(new SymbolDecl[] { templateDecl }); } else { return(new SymbolDecl[] { decl }); } } else { if (virtualFunction != Virtual.Normal && virtualFunction != Virtual.Static) { throw new ArgumentException("Failed to parse."); } if (CppParser.Token(tokens, ref index, "=")) { CppParser.SkipUntil(tokens, ref index, ";"); } else { CppParser.EnsureToken(tokens, ref index, ";"); } if (!(type is ClassMemberTypeDecl)) { var decl = new VarDecl { Static = virtualFunction == Virtual.Static, Name = name, Type = type, }; return(new SymbolDecl[] { decl }); } } } } } else { var decl = new FuncDecl { Virtual = Virtual.Normal, Name = (function == Function.Constructor ? "" : "~") + CppParser.EnsureId(tokens, ref index), Function = function, }; TypeDecl functionType = null; Action <TypeDecl> continuation = null; CallingConvention callingConvention = CallingConvention.Default; CppTypeParser.ParseTypeContinueAfterName(tokens, ref index, ref callingConvention, out functionType, out continuation); continuation(new RefTypeDecl { Name = "void" }); decl.Type = functionType; if (CppParser.Token(tokens, ref index, "=")) { CppParser.EnsureToken(tokens, ref index, "default", "delete"); } if (!CppParser.Token(tokens, ref index, ";")) { if (CppParser.Token(tokens, ref index, ":")) { CppParser.SkipUntil(tokens, ref index, "{"); } else { CppParser.EnsureToken(tokens, ref index, "{"); } CppParser.SkipUntil(tokens, ref index, "}"); } if (templateDecl != null) { templateDecl.Element = decl; return(new SymbolDecl[] { templateDecl }); } else { return(new SymbolDecl[] { decl }); } } } return(null); }
public NamespaceDecl(string prefix, string nsuri, NamespaceDecl nextInScope, NamespaceDecl prevDecl, int scope, bool implied) { this.prefix = prefix; this.uri = nsuri; this.scopeLink = nextInScope; this.prevLink = prevDecl; this.scope = scope; this.implied = implied; }
void PushNamespace(string prefix, string ns, bool implied) { if (prefix == "xml") return; int elemDepth = this.elemDepth; NamespaceDecl curDecl; this.namespaces.TryGetValue(prefix, out curDecl); if (null != curDecl) { if (curDecl.uri == ns) { // if we see the nsdecl after we saw the first reference in this scope // fix up 'implied' flag if (!implied && curDecl.implied && (curDecl.scope == elemDepth)) { curDecl.implied = false; } return; } // check that this doesn't conflict this.qnameElement.CheckPrefixNS(prefix, ns); if (prefix.Length != 0) { for (int i = 0; i < this.attrCount; i++) { if (this.attributes[i].name.prefix.Length != 0) this.attributes[i].name.CheckPrefixNS(prefix, ns); } } } // actually add ns decl NamespaceDecl decl = new NamespaceDecl(prefix, ns, this.elementStack[elemDepth].nsdecls, curDecl, elemDepth, implied); this.elementStack[elemDepth].nsdecls = decl; this.namespaces[prefix] = decl; }
public SourceNamespaceSymbol(SourceModuleSymbol module, NamespaceDecl ns) { _sourceModule = module; _name = ns.QualifiedName.QualifiedName.ClrName(); }
internal NamespaceDecl(string prefix, string namespaceUri, NamespaceDecl previousDecl) { this.prefix = prefix; this.namespaceUri = namespaceUri; this.previousDecl = previousDecl; }
/// <summary> /// Combines name and its namespace. /// </summary> /// <param name="name">Name.</param> /// <param name="ns">Can be <c>null</c>.</param> /// <returns></returns> public static QualifiedName MakeQualifiedName(Name name, NamespaceDecl ns) { return((ns != null && ns.QualifiedName.HasValue) ? new QualifiedName(name, ns.QualifiedName.QualifiedName.Namespaces) : new QualifiedName(name)); }
void SymbolDecl.IVisitor.Visit(NamespaceDecl decl) { throw new ArgumentOutOfRangeException(); }
private void PushNamespace(string prefix, string ns, bool implied) { if (prefix != "xml") { NamespaceDecl decl; int elemDepth = this.elemDepth; this.namespaces.TryGetValue(prefix, out decl); if (decl != null) { if (decl.uri == ns) { if ((!implied && decl.implied) && (decl.scope == elemDepth)) { decl.implied = false; } return; } this.qnameElement.CheckPrefixNS(prefix, ns); if (prefix.Length != 0) { for (int i = 0; i < this.attrCount; i++) { if (this.attributes[i].name.prefix.Length != 0) { this.attributes[i].name.CheckPrefixNS(prefix, ns); } } } } NamespaceDecl decl2 = new NamespaceDecl(prefix, ns, this.elementStack[elemDepth].nsdecls, decl, elemDepth, implied); this.elementStack[elemDepth].nsdecls = decl2; this.namespaces[prefix] = decl2; } }
private void PopNamespaces(NamespaceDecl firstInScopeChain) { NamespaceDecl scopeLink; for (NamespaceDecl decl = firstInScopeChain; decl != null; decl = scopeLink) { if (decl.prevLink == null) { this.namespaces.Remove(decl.prefix); } else { this.namespaces[decl.prefix] = decl.prevLink; } scopeLink = decl.scopeLink; decl.prevLink = null; decl.scopeLink = null; } }
/// <summary> /// Create naming context. /// </summary> /// <param name="ns">Current namespace declaration. In case it is <c>null</c>, context for global code is created.</param> /// <param name="unit">Global code used when <paramref name="ns"/> is <c>null</c>.</param> /// <returns>Naming context. Cannot be <c>null</c>.</returns> public static NamingContext GetNamingContext(NamespaceDecl ns, SourceUnit unit) { return (ns != null) ? ns.Naming : unit.Naming; }
/// <summary> /// Create naming context. /// </summary> /// <param name="ns">Current namespace declaration. In case it is <c>null</c>, context for global code is created.</param> /// <param name="unit">Global code used when <paramref name="ns"/> is <c>null</c>.</param> /// <returns>Naming context. Cannot be <c>null</c>.</returns> public static NamingContext GetNamingContext(NamespaceDecl ns, SourceUnit unit) { return((ns != null) ? ns.Naming : unit.Naming); }
/// <summary> /// Combines name and its namespace. /// </summary> /// <param name="name">Name.</param> /// <param name="ns">Can be <c>null</c>.</param> /// <returns></returns> public static QualifiedName MakeQualifiedName(Name name, NamespaceDecl ns) { return((ns == null || ns.QualifiedName.Namespaces.Length == 0) ? new QualifiedName(name) : new QualifiedName(name, ns.QualifiedName.Namespaces)); }
/// <summary> /// Visit namespace statements. /// </summary> /// <param name="x"></param> virtual public void VisitNamespaceDecl(NamespaceDecl x) { VisitElement(x.Body); }
/// <summary> /// Visit a namespace declaration /// </summary> private void VisitNamespaceDecl(NamespaceDecl namespaceDecl, TraversalData traversalData) { traversalData.AddNamespace(namespaceDecl.ToString()); Visit(namespaceDecl.Decls, traversalData); traversalData.RemoveNamespace(); }
void AddInitNamespace(string prefix, string uri) { NamespaceDecl nsdecl = new NamespaceDecl(prefix, uri, this.elementStack[0].nsdecls, null, -1, true); this.elementStack[0].nsdecls = nsdecl; this.namespaces.Add(prefix, nsdecl); }
internal CachedXmlNode(XmlReader reader, NamespaceDecl namespacesInScope, CachedXmlNode next) : this(reader.NodeType, reader.Name, reader.LocalName, reader.Prefix, reader.NamespaceURI, reader.Value, reader.Depth, namespacesInScope, next) { }
/// <summary> /// Create naming context. /// </summary> /// <param name="ns">Current namespace declaration. In case it is <c>null</c>, context for global code is created.</param> /// <param name="ast">Global code used when <paramref name="ns"/> is <c>null</c>.</param> /// <returns>Naming context. Cannot be <c>null</c>.</returns> public static NamingContext GetNamingContext(NamespaceDecl ns, GlobalCode ast) { return((ns != null) ? ns.Naming : ast.SourceUnit.Naming); }
public NamespaceDecl Clear() { NamespaceDecl nsdecls = this.nsdecls; this.nsdecls = null; return nsdecls; }