1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
|
//------------------------------------------------------------------------------
// <copyright file="OutputScopeManager.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
// <owner current="true" primary="true">Microsoft</owner>
//------------------------------------------------------------------------------
namespace System.Xml.Xsl.XsltOld {
using Res = System.Xml.Utils.Res;
using System;
using System.Globalization;
using System.Diagnostics;
using System.Xml;
internal class OutputScopeManager {
private const int STACK_INCREMENT = 10;
private HWStack elementScopesStack;
private string defaultNS;
private OutKeywords atoms;
private XmlNameTable nameTable;
private int prefixIndex;
internal string DefaultNamespace {
get { return this.defaultNS; }
}
internal OutputScope CurrentElementScope {
get {
Debug.Assert(this.elementScopesStack.Peek() != null); // We adding rootElementScope to garantee this
return (OutputScope) this.elementScopesStack.Peek();
}
}
internal XmlSpace XmlSpace {
get { return CurrentElementScope.Space; }
}
internal string XmlLang {
get { return CurrentElementScope.Lang; }
}
internal OutputScopeManager(XmlNameTable nameTable, OutKeywords atoms) {
Debug.Assert(nameTable != null);
Debug.Assert(atoms != null);
this.elementScopesStack = new HWStack(STACK_INCREMENT);
this.nameTable = nameTable;
this.atoms = atoms;
this.defaultNS = this.atoms.Empty;
// We always adding rootElementScope to garantee that CurrentElementScope != null
// This context is active between PI and first element for example
OutputScope rootElementScope = (OutputScope) this.elementScopesStack.Push();
if(rootElementScope == null) {
rootElementScope = new OutputScope();
this.elementScopesStack.AddToTop(rootElementScope);
}
rootElementScope.Init(string.Empty, string.Empty, string.Empty, /*space:*/XmlSpace.None, /*lang:*/string.Empty, /*mixed:*/false);
}
internal void PushNamespace(string prefix, string nspace) {
Debug.Assert(prefix != null);
Debug.Assert(nspace != null);
CurrentElementScope.AddNamespace(prefix, nspace, this.defaultNS);
if (prefix == null || prefix.Length == 0) {
this.defaultNS = nspace;
}
}
internal void PushScope(string name, string nspace, string prefix) {
Debug.Assert(name != null);
Debug.Assert(nspace != null);
Debug.Assert(prefix != null);
OutputScope parentScope = CurrentElementScope;
OutputScope elementScope = (OutputScope) this.elementScopesStack.Push();
if (elementScope == null) {
elementScope = new OutputScope();
this.elementScopesStack.AddToTop(elementScope);
}
Debug.Assert(elementScope != null);
elementScope.Init(name, nspace, prefix, parentScope.Space, parentScope.Lang, parentScope.Mixed);
}
internal void PopScope() {
OutputScope elementScope = (OutputScope) this.elementScopesStack.Pop();
Debug.Assert(elementScope != null); // We adding rootElementScope to garantee this
for (NamespaceDecl scope = elementScope.Scopes; scope != null; scope = scope.Next) {
this.defaultNS = scope.PrevDefaultNsUri;
}
}
internal string ResolveNamespace(string prefix) {
bool thisScope;
return ResolveNamespace(prefix, out thisScope);
}
internal string ResolveNamespace(string prefix, out bool thisScope) {
Debug.Assert(prefix != null);
thisScope = true;
if (prefix == null || prefix.Length == 0) {
return this.defaultNS;
}
else {
if (Ref.Equal(prefix, this.atoms.Xml)) {
return this.atoms.XmlNamespace;
}
else if (Ref.Equal(prefix, this.atoms.Xmlns)) {
return this.atoms.XmlnsNamespace;
}
for (int i = this.elementScopesStack.Length - 1; i >= 0; i --) {
Debug.Assert(this.elementScopesStack[i] is OutputScope);
OutputScope elementScope = (OutputScope) this.elementScopesStack[i];
string nspace = elementScope.ResolveAtom(prefix);
if (nspace != null) {
thisScope = (i == this.elementScopesStack.Length - 1);
return nspace;
}
}
}
return null;
}
internal bool FindPrefix(string nspace, out string prefix) {
Debug.Assert(nspace != null);
for (int i = this.elementScopesStack.Length - 1; 0 <= i; i--) {
Debug.Assert(this.elementScopesStack[i] is OutputScope);
OutputScope elementScope = (OutputScope) this.elementScopesStack[i];
string pfx = null;
if (elementScope.FindPrefix(nspace, out pfx)) {
string testNspace = ResolveNamespace(pfx);
if(testNspace != null && Ref.Equal(testNspace, nspace)) {
prefix = pfx;
return true;
}
else {
break;
}
}
}
prefix = null;
return false;
}
internal string GeneratePrefix(string format) {
string prefix;
do {
prefix = String.Format(CultureInfo.InvariantCulture, format, this.prefixIndex ++);
}while(this.nameTable.Get(prefix) != null);
return this.nameTable.Add(prefix);
}
}
}
|
