354 lines
15 KiB
C#
354 lines
15 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="CompilerScopeManager.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
// <owner current="true" primary="true">[....]</owner>
|
|
//------------------------------------------------------------------------------
|
|
|
|
using System.Diagnostics;
|
|
|
|
namespace System.Xml.Xsl.Xslt {
|
|
using QilName = System.Xml.Xsl.Qil.QilName;
|
|
|
|
// Compiler scope manager keeps track of
|
|
// Variable declarations
|
|
// Namespace declarations
|
|
// Extension and excluded namespaces
|
|
internal sealed class CompilerScopeManager<V> {
|
|
public enum ScopeFlags {
|
|
BackwardCompatibility = 0x1,
|
|
ForwardCompatibility = 0x2,
|
|
CanHaveApplyImports = 0x4,
|
|
NsDecl = 0x10, // NS declaration
|
|
NsExcl = 0x20, // NS Extencion (null for ExcludeAll)
|
|
Variable = 0x40,
|
|
|
|
CompatibilityFlags = BackwardCompatibility | ForwardCompatibility,
|
|
InheritedFlags = CompatibilityFlags | CanHaveApplyImports,
|
|
ExclusiveFlags = NsDecl | NsExcl | Variable
|
|
}
|
|
|
|
public struct ScopeRecord {
|
|
public int scopeCount;
|
|
public ScopeFlags flags;
|
|
public string ncName; // local-name for variable, prefix for namespace, null for extension or excluded namespace
|
|
public string nsUri; // namespace uri
|
|
public V value; // value for variable, null for namespace
|
|
|
|
// Exactly one of these three properties is true for every given record
|
|
public bool IsVariable { get { return (flags & ScopeFlags.Variable) != 0; } }
|
|
public bool IsNamespace { get { return (flags & ScopeFlags.NsDecl ) != 0; } }
|
|
// public bool IsExNamespace { get { return (flags & ScopeFlags.NsExcl ) != 0; } }
|
|
}
|
|
|
|
// Number of predefined records minus one
|
|
private const int LastPredefRecord = 0;
|
|
|
|
private ScopeRecord[] records = new ScopeRecord[32];
|
|
private int lastRecord = LastPredefRecord;
|
|
|
|
// This is cache of records[lastRecord].scopeCount field;
|
|
// most often we will have PushScope()/PopScope pare over the same record.
|
|
// It has sence to avoid adresing this field through array access.
|
|
private int lastScopes = 0;
|
|
|
|
public CompilerScopeManager() {
|
|
// The prefix 'xml' is by definition bound to the namespace name http://www.w3.org/XML/1998/namespace
|
|
records[0].flags = ScopeFlags.NsDecl;
|
|
records[0].ncName = "xml";
|
|
records[0].nsUri = XmlReservedNs.NsXml;
|
|
}
|
|
|
|
public CompilerScopeManager(KeywordsTable atoms) {
|
|
records[0].flags = ScopeFlags.NsDecl;
|
|
records[0].ncName = atoms.Xml;
|
|
records[0].nsUri = atoms.UriXml;
|
|
}
|
|
|
|
public void EnterScope() {
|
|
lastScopes++;
|
|
}
|
|
|
|
public void ExitScope() {
|
|
if (0 < lastScopes) {
|
|
lastScopes--;
|
|
} else {
|
|
while (records[--lastRecord].scopeCount == 0) {
|
|
}
|
|
lastScopes = records[lastRecord].scopeCount;
|
|
lastScopes--;
|
|
}
|
|
}
|
|
|
|
[Conditional("DEBUG")]
|
|
public void CheckEmpty() {
|
|
ExitScope();
|
|
Debug.Assert(lastRecord == 0 && lastScopes == 0, "PushScope() and PopScope() calls are unbalanced");
|
|
}
|
|
|
|
// returns true if ns decls was added to scope
|
|
public bool EnterScope(NsDecl nsDecl) {
|
|
lastScopes++;
|
|
|
|
bool hasNamespaces = false;
|
|
bool excludeAll = false;
|
|
for (; nsDecl != null; nsDecl = nsDecl.Prev) {
|
|
if (nsDecl.NsUri == null) {
|
|
Debug.Assert(nsDecl.Prefix == null, "NS may be null only when prefix is null where it is used for extension-element-prefixes='#all'");
|
|
excludeAll = true;
|
|
} else if (nsDecl.Prefix == null) {
|
|
AddExNamespace(nsDecl.NsUri);
|
|
} else {
|
|
hasNamespaces = true;
|
|
AddNsDeclaration(nsDecl.Prefix, nsDecl.NsUri);
|
|
}
|
|
}
|
|
if (excludeAll) {
|
|
// #all should be on the top of the stack, becase all NSs on this element should be excluded as well
|
|
AddExNamespace(null);
|
|
}
|
|
return hasNamespaces;
|
|
}
|
|
|
|
private void AddRecord() {
|
|
// Store cached fields:
|
|
records[lastRecord].scopeCount = lastScopes;
|
|
// Extend record buffer:
|
|
if (++lastRecord == records.Length) {
|
|
ScopeRecord[] newRecords = new ScopeRecord[lastRecord * 2];
|
|
Array.Copy(records, 0, newRecords, 0, lastRecord);
|
|
records = newRecords;
|
|
}
|
|
// reset scope count:
|
|
lastScopes = 0;
|
|
}
|
|
|
|
private void AddRecord(ScopeFlags flag, string ncName, string uri, V value) {
|
|
Debug.Assert(flag == (flag & ScopeFlags.ExclusiveFlags) && (flag & (flag - 1)) == 0 && flag != 0, "One exclusive flag");
|
|
Debug.Assert(uri != null || ncName == null, "null, null means exclude '#all'");
|
|
|
|
ScopeFlags flags = records[lastRecord].flags;
|
|
bool canReuseLastRecord = (lastScopes == 0) && (flags & ScopeFlags.ExclusiveFlags) == 0;
|
|
if (!canReuseLastRecord) {
|
|
AddRecord();
|
|
flags &= ScopeFlags.InheritedFlags;
|
|
}
|
|
|
|
records[lastRecord].flags = flags | flag;
|
|
records[lastRecord].ncName = ncName;
|
|
records[lastRecord].nsUri = uri;
|
|
records[lastRecord].value = value;
|
|
}
|
|
|
|
private void SetFlag(ScopeFlags flag, bool value) {
|
|
Debug.Assert(flag == (flag & ScopeFlags.InheritedFlags) && (flag & (flag - 1)) == 0 && flag != 0, "one inherited flag");
|
|
ScopeFlags flags = records[lastRecord].flags;
|
|
if (((flags & flag) != 0) != value) {
|
|
// lastScopes == records[lastRecord].scopeCount; // we know this because we are cashing it.
|
|
bool canReuseLastRecord = lastScopes == 0; // last record is from last scope
|
|
if (!canReuseLastRecord) {
|
|
AddRecord();
|
|
flags &= ScopeFlags.InheritedFlags;
|
|
}
|
|
if (flag == ScopeFlags.CanHaveApplyImports) {
|
|
flags ^= flag;
|
|
} else {
|
|
flags &= ~ScopeFlags.CompatibilityFlags;
|
|
if (value) {
|
|
flags |= flag;
|
|
}
|
|
}
|
|
records[lastRecord].flags = flags;
|
|
}
|
|
Debug.Assert((records[lastRecord].flags & ScopeFlags.CompatibilityFlags) != ScopeFlags.CompatibilityFlags,
|
|
"BackwardCompatibility and ForwardCompatibility flags are mutually exclusive"
|
|
);
|
|
}
|
|
|
|
// Add variable to the current scope. Returns false in case of duplicates.
|
|
public void AddVariable(QilName varName, V value) {
|
|
Debug.Assert(varName.LocalName != null && varName.NamespaceUri != null);
|
|
AddRecord(ScopeFlags.Variable, varName.LocalName, varName.NamespaceUri, value);
|
|
}
|
|
|
|
// Since the prefix might be redefined in an inner scope, we search in descending order in [to, from]
|
|
// If interval is empty (from < to), the function returns null.
|
|
private string LookupNamespace(string prefix, int from, int to) {
|
|
Debug.Assert(prefix != null);
|
|
for (int record = from; to <= record; --record) {
|
|
string recPrefix, recNsUri;
|
|
ScopeFlags flags = GetName(ref records[record], out recPrefix, out recNsUri);
|
|
if (
|
|
(flags & ScopeFlags.NsDecl) != 0 &&
|
|
recPrefix == prefix
|
|
) {
|
|
return recNsUri;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public string LookupNamespace(string prefix) {
|
|
return LookupNamespace(prefix, lastRecord, 0);
|
|
}
|
|
|
|
private static ScopeFlags GetName(ref ScopeRecord re, out string prefix, out string nsUri) {
|
|
prefix = re.ncName;
|
|
nsUri = re.nsUri;
|
|
return re.flags;
|
|
}
|
|
|
|
public void AddNsDeclaration(string prefix, string nsUri) {
|
|
AddRecord(ScopeFlags.NsDecl, prefix, nsUri, default(V));
|
|
}
|
|
|
|
public void AddExNamespace(string nsUri) {
|
|
AddRecord(ScopeFlags.NsExcl, null, nsUri, default(V));
|
|
}
|
|
|
|
public bool IsExNamespace(string nsUri) {
|
|
Debug.Assert(nsUri != null);
|
|
int exAll = 0;
|
|
for (int record = lastRecord; 0 <= record; record--) {
|
|
string recPrefix, recNsUri;
|
|
ScopeFlags flags = GetName(ref records[record], out recPrefix, out recNsUri);
|
|
if ((flags & ScopeFlags.NsExcl) != 0) {
|
|
Debug.Assert(recPrefix == null);
|
|
if (recNsUri == nsUri) {
|
|
return true; // This namespace is excluded
|
|
}
|
|
if (recNsUri == null) {
|
|
exAll = record; // #all namespaces below are excluded
|
|
}
|
|
} else if (
|
|
exAll != 0 &&
|
|
(flags & ScopeFlags.NsDecl) != 0 &&
|
|
recNsUri == nsUri
|
|
) {
|
|
// We need to check that this namespace wasn't undefined before last "#all"
|
|
bool undefined = false;
|
|
for (int prev = record + 1; prev < exAll; prev++) {
|
|
string prevPrefix, prevNsUri;
|
|
ScopeFlags prevFlags = GetName(ref records[prev], out prevPrefix, out prevNsUri);
|
|
if (
|
|
(flags & ScopeFlags.NsDecl) != 0 &&
|
|
prevPrefix == recPrefix
|
|
) {
|
|
// We don't care if records[prev].nsUri == records[record].nsUri.
|
|
// In this case the namespace was already undefined above.
|
|
undefined = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!undefined) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private int SearchVariable(string localName, string uri) {
|
|
Debug.Assert(localName != null);
|
|
for (int record = lastRecord; 0 <= record; --record) {
|
|
string recLocal, recNsUri;
|
|
ScopeFlags flags = GetName(ref records[record], out recLocal, out recNsUri);
|
|
if (
|
|
(flags & ScopeFlags.Variable) != 0 &&
|
|
recLocal == localName &&
|
|
recNsUri == uri
|
|
) {
|
|
return record;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
public V LookupVariable(string localName, string uri) {
|
|
int record = SearchVariable(localName, uri);
|
|
return (record < 0) ? default(V) : records[record].value;
|
|
}
|
|
|
|
public bool IsLocalVariable(string localName, string uri) {
|
|
int record = SearchVariable(localName, uri);
|
|
while (0 <= --record) {
|
|
if (records[record].scopeCount != 0) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public bool ForwardCompatibility {
|
|
get { return (records[lastRecord].flags & ScopeFlags.ForwardCompatibility) != 0; }
|
|
set { SetFlag(ScopeFlags.ForwardCompatibility, value); }
|
|
}
|
|
|
|
public bool BackwardCompatibility {
|
|
get { return (records[lastRecord].flags & ScopeFlags.BackwardCompatibility) != 0; }
|
|
set { SetFlag(ScopeFlags.BackwardCompatibility, value); }
|
|
}
|
|
|
|
public bool CanHaveApplyImports {
|
|
get { return (records[lastRecord].flags & ScopeFlags.CanHaveApplyImports) != 0; }
|
|
set { SetFlag(ScopeFlags.CanHaveApplyImports, value); }
|
|
}
|
|
|
|
internal System.Collections.Generic.IEnumerable<ScopeRecord> GetActiveRecords() {
|
|
int currentRecord = this.lastRecord + 1;
|
|
// This logic comes from NamespaceEnumerator.MoveNext but also returns variables
|
|
while (LastPredefRecord < --currentRecord) {
|
|
if (records[currentRecord].IsNamespace) {
|
|
// This is a namespace declaration
|
|
if (LookupNamespace(records[currentRecord].ncName, lastRecord, currentRecord + 1) != null) {
|
|
continue;
|
|
}
|
|
// Its prefix has not been redefined later in [currentRecord + 1, lastRecord]
|
|
}
|
|
yield return records[currentRecord];
|
|
}
|
|
}
|
|
|
|
public NamespaceEnumerator GetEnumerator() {
|
|
return new NamespaceEnumerator(this);
|
|
}
|
|
|
|
internal struct NamespaceEnumerator {
|
|
CompilerScopeManager<V> scope;
|
|
int lastRecord;
|
|
int currentRecord;
|
|
|
|
public NamespaceEnumerator(CompilerScopeManager<V> scope) {
|
|
this.scope = scope;
|
|
this.lastRecord = scope.lastRecord;
|
|
this.currentRecord = lastRecord + 1;
|
|
}
|
|
|
|
public void Reset() {
|
|
currentRecord = lastRecord + 1;
|
|
}
|
|
|
|
public bool MoveNext() {
|
|
while (LastPredefRecord < --currentRecord) {
|
|
if (scope.records[currentRecord].IsNamespace) {
|
|
// This is a namespace declaration
|
|
if (scope.LookupNamespace(scope.records[currentRecord].ncName, lastRecord, currentRecord + 1) == null) {
|
|
// Its prefix has not been redefined later in [currentRecord + 1, lastRecord]
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public ScopeRecord Current {
|
|
get {
|
|
Debug.Assert(LastPredefRecord <= currentRecord && currentRecord <= scope.lastRecord, "MoveNext() either was not called or returned false");
|
|
Debug.Assert(scope.records[currentRecord].IsNamespace);
|
|
return scope.records[currentRecord];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|