private void Initialize(XmlResolver?resolver)
{
_nameTable = null;
_xmlResolver = resolver;
// limit the entity resolving to 10 million character. the caller can still
// override it to any other value or set it to zero for unlimiting it
_maxCharactersFromEntities = (long)1e7;
_lineNumberOffset = 0;
_linePositionOffset = 0;
_checkCharacters = true;
_conformanceLevel = ConformanceLevel.Document;
_ignoreWhitespace = false;
_ignorePIs = false;
_ignoreComments = false;
_dtdProcessing = DtdProcessing.Prohibit;
_closeInput = false;
_maxCharactersInDocument = 0;
_schemas = null;
_validationType = ValidationType.None;
_validationFlags = XmlSchemaValidationFlags.ProcessIdentityConstraints;
_validationFlags |= XmlSchemaValidationFlags.AllowXmlAttributes;
_useAsync = false;
_isReadOnly = false;
IsXmlResolverSet = false;
}
public XmlParserContext(XmlNameTable?nt, XmlNamespaceManager?nsMgr, string?docTypeName,
string?pubId, string?sysId, string?internalSubset, string?baseURI,
string?xmlLang, XmlSpace xmlSpace, Encoding?enc)
{
if (nsMgr != null)
{
if (nt == null)
{
_nt = nsMgr.NameTable;
}
else
{
if ((object)nt != (object?)nsMgr.NameTable)
{
throw new XmlException(SR.Xml_NotSameNametable, string.Empty);
}
_nt = nt;
}
}
else
{
_nt = nt;
}
_nsMgr = nsMgr;
_docTypeName = (null == docTypeName ? string.Empty : docTypeName);
_pubId = (null == pubId ? string.Empty : pubId);
_sysId = (null == sysId ? string.Empty : sysId);
_internalSubset = (null == internalSubset ? string.Empty : internalSubset);
_baseURI = (null == baseURI ? string.Empty : baseURI);
_xmlLang = (null == xmlLang ? string.Empty : xmlLang);
_xmlSpace = xmlSpace;
_encoding = enc;
}
public XmlParserContext(XmlNameTable?nt, XmlNamespaceManager?nsMgr, string?docTypeName,
string?pubId, string?sysId, string?internalSubset, string?baseURI,
string?xmlLang, XmlSpace xmlSpace)
: this(nt, nsMgr, docTypeName, pubId, sysId, internalSubset, baseURI, xmlLang, xmlSpace, null)
{
// Intentionally Empty
}
internal XNodeReader(XNode node, XmlNameTable?nameTable, ReaderOptions options)
{
_source = node;
_root = node;
_nameTable = nameTable ?? CreateNameTable();
_omitDuplicateNamespaces = (options & ReaderOptions.OmitDuplicateNamespaces) != 0 ? true : false;
}
internal RecordBuilder(IRecordOutput output, XmlNameTable?nameTable)
{
Debug.Assert(output != null);
_output = output;
_nameTable = nameTable != null ? nameTable : new NameTable();
_atoms = new OutKeywords(_nameTable);
_scopeManager = new OutputScopeManager(_nameTable, _atoms);
}
private ExtensibleNavigator(
INode current,
string?baseUri,
XmlNameTable?nameTable,
IDictionary <string, string>?namespacePrefixes)
{
BaseURI = baseUri ?? "";
_current = current;
NameTable = nameTable ?? new ExtensibleNameTable();
_namespacePrefixes = namespacePrefixes ?? new Dictionary <string, string>();
}
public QueryReaderSettings(XmlReader reader)
{
#pragma warning disable 618
XmlValidatingReader?valReader = reader as XmlValidatingReader;
#pragma warning restore 618
if (valReader != null)
{
// Unwrap validation reader
_validatingReader = true;
reader = valReader.Impl.Reader;
}
_xmlReaderSettings = reader.Settings;
if (_xmlReaderSettings != null)
{
_xmlReaderSettings = _xmlReaderSettings.Clone();
_xmlReaderSettings.NameTable = reader.NameTable;
_xmlReaderSettings.CloseInput = true;
_xmlReaderSettings.LineNumberOffset = 0;
_xmlReaderSettings.LinePositionOffset = 0;
XmlTextReaderImpl?impl = reader as XmlTextReaderImpl;
if (impl != null)
{
_xmlReaderSettings.XmlResolver = impl.GetResolver();
}
}
else
{
_xmlNameTable = reader.NameTable;
XmlTextReader?xmlTextReader = reader as XmlTextReader;
if (xmlTextReader != null)
{
XmlTextReaderImpl impl = xmlTextReader.Impl;
_entityHandling = impl.EntityHandling;
_namespaces = impl.Namespaces;
_normalization = impl.Normalization;
_prohibitDtd = (impl.DtdProcessing == DtdProcessing.Prohibit);
_whitespaceHandling = impl.WhitespaceHandling;
_xmlResolver = impl.GetResolver();
}
else
{
_entityHandling = EntityHandling.ExpandEntities;
_namespaces = true;
_normalization = true;
_prohibitDtd = true;
_whitespaceHandling = WhitespaceHandling.All;
_xmlResolver = null;
}
}
}
public XmlNamespaceManager(XmlNameTable nameTable)
{
_nameTable = nameTable;
_xml = nameTable.Add("xml");
_xmlNs = nameTable.Add("xmlns");
_nsdecls = new NamespaceDeclaration[8];
string emptyStr = nameTable.Add(string.Empty);
_nsdecls[0].Set(emptyStr, emptyStr, -1, -1);
_nsdecls[1].Set(_xmlNs, nameTable.Add(XmlReservedNs.NsXmlNs), -1, -1);
_nsdecls[2].Set(_xml, nameTable.Add(XmlReservedNs.NsXml), 0, -1);
_lastDecl = 2;
_scopeId = 1;
}
/// <summary>
/// Atomize all names contained within the whitespace rules with respect to "nameTable".
/// </summary>
public void Atomize(XmlNameTable nameTable)
{
// If names are already atomized with respect to "nameTable", no need to do it again
if (nameTable != _nameTable)
{
_nameTable = nameTable;
foreach (InternalWhitespaceRule rule in _qnames.Values)
{
rule.Atomize(nameTable);
}
foreach (InternalWhitespaceRule rule in _wildcards)
{
rule.Atomize(nameTable);
}
}
}
/// <summary>
/// Creates an <see cref="XPathNavigator"/> for a given <see cref="XNode"/>
/// </summary>
/// <param name="node">Extension point <see cref="XNode"/></param>
/// <param name="nameTable">The <see cref="XmlNameTable"/> to be used by
/// the <see cref="XPathNavigator"/></param>
/// <returns>An <see cref="XPathNavigator"/></returns>
public static XPathNavigator CreateNavigator(this XNode node, XmlNameTable?nameTable)
{
ArgumentNullException.ThrowIfNull(node);
if (node is XDocumentType)
{
throw new ArgumentException(SR.Format(SR.Argument_CreateNavigator, XmlNodeType.DocumentType));
}
XText?text = node as XText;
if (text != null)
{
if (text.GetParent() is XDocument)
{
throw new ArgumentException(SR.Format(SR.Argument_CreateNavigator, XmlNodeType.Whitespace));
}
node = CalibrateText(text);
}
return(new XNodeNavigator(node, nameTable));
}
//-----------------------------------------------
// Constructors
//-----------------------------------------------
/// <summary>
/// This constructor is internal so that external users cannot construct it (and therefore we do not have to test it separately).
/// </summary>
internal XmlQueryRuntime(XmlQueryStaticData data, object defaultDataSource, XmlResolver dataSources, XsltArgumentList?argList, XmlSequenceWriter seqWrt)
{
Debug.Assert(data != null);
string[]? names = data.Names;
Int32Pair[]? filters = data.Filters;
WhitespaceRuleLookup?wsRules;
int i;
// Early-Bound Library Objects
wsRules = (data.WhitespaceRules != null && data.WhitespaceRules.Count != 0) ? new WhitespaceRuleLookup(data.WhitespaceRules) : null;
_ctxt = new XmlQueryContext(this, defaultDataSource, dataSources, argList, wsRules);
_xsltLib = null;
_earlyInfo = data.EarlyBound;
_earlyObjects = (_earlyInfo != null) ? new object[_earlyInfo.Length] : null;
// Global variables and parameters
_globalNames = data.GlobalNames;
_globalValues = (_globalNames != null) ? new object[_globalNames.Length] : null;
// Names
_nameTableQuery = _ctxt.QueryNameTable;
_atomizedNames = null;
if (names != null)
{
// Atomize all names in "nameTableQuery". Use names from the default data source's
// name table when possible.
XmlNameTable?nameTableDefault = _ctxt.DefaultNameTable;
_atomizedNames = new string[names.Length];
if (nameTableDefault != _nameTableQuery && nameTableDefault != null)
{
// Ensure that atomized names from the default data source are added to the
// name table used in this query
for (i = 0; i < names.Length; i++)
{
string?name = nameTableDefault.Get(names[i]);
_atomizedNames[i] = _nameTableQuery.Add(name ?? names[i]);
}
}
else
{
// Enter names into nametable used in this query
for (i = 0; i < names.Length; i++)
{
_atomizedNames[i] = _nameTableQuery.Add(names[i]);
}
}
}
// Name filters
_filters = null;
if (filters != null)
{
// Construct name filters. Each pair of integers in the filters[] array specifies the
// (localName, namespaceUri) of the NameFilter to be created.
_filters = new XmlNavigatorFilter[filters.Length];
for (i = 0; i < filters.Length; i++)
{
_filters[i] = XmlNavNameFilter.Create(_atomizedNames ![filters[i].Left], _atomizedNames[filters[i].Right]);
public XNodeNavigator(XNode node, XmlNameTable?nameTable)
{
_source = node;
_nameTable = nameTable != null ? nameTable : CreateNameTable();
}
public XmlParserContext(XmlNameTable?nt, XmlNamespaceManager?nsMgr, string?xmlLang, XmlSpace xmlSpace, Encoding?enc)
: this(nt, nsMgr, null, null, null, null, string.Empty, xmlLang, xmlSpace, enc)
{
// Intentionally Empty
}
public abstract object ParseValue(string s, XmlNameTable?nameTable, IXmlNamespaceResolver?nsmgr);
internal abstract Exception?TryParseValue(object value, XmlNameTable?nameTable, IXmlNamespaceResolver?namespaceResolver, out object?typedValue);
internal abstract object ParseValue(string s, XmlNameTable?nameTable, IXmlNamespaceResolver?nsmgr, bool createAtomicValue);
internal XNodeReader(XNode node, XmlNameTable?nameTable)
: this(node, nameTable,
(node.GetSaveOptionsFromAnnotations() & SaveOptions.OmitDuplicateNamespaces) != 0 ?
ReaderOptions.OmitDuplicateNamespaces : ReaderOptions.None)
{
}
