public static object DynCreatePi([Implict] Executive executive, object name, object value)
{
if (name == Undefined.Value)
throw new XQueryException(Properties.Resources.XPTY0004, "()", "xs:string | xs:untypedAtomic");
string ncname = (string)name;
if (String.Compare(ncname, "xml", true) == 0)
throw new XQueryException(Properties.Resources.XQDY0064);
string text = value == Undefined.Value ? "" : NormalizeStringValue(value.ToString(), false, true).Trim();
if (text.Contains("?>"))
throw new XQueryException(Properties.Resources.XQDY0026);
XQueryContext context = (XQueryContext)executive.Owner;
XQueryDocument doc = context.CreateDocument();
XQueryDocumentBuilder builder = new XQueryDocumentBuilder(doc);
try
{
builder.WriteProcessingInstruction(XmlConvert.VerifyNCName(ncname), text);
}
catch (XmlException)
{
throw new XQueryException(Properties.Resources.FORG0001, name, "xs:NCName");
}
XPathFactory.XQueryDynNodeNavigator nav = new XPathFactory.XQueryDynNodeNavigator(doc);
nav.MoveTo(doc.CreateNavigator());
return nav;
}
public static object CreateBuilder([Implict] Executive executive)
{
XQueryContext context = (XQueryContext)executive.Owner;
XQueryDocument doc = context.CreateDocument();
XQueryDocumentBuilder builder = new XQueryDocumentBuilder(doc);
builder.NamespaceInheritanceMode = context.NamespaceInheritanceMode;
return builder;
}
public static object DynCreateText([Implict] Executive executive, object value)
{
if (value == Undefined.Value)
return Undefined.Value;
XQueryContext context = (XQueryContext)executive.Owner;
XQueryDocument doc = context.CreateDocument();
XQueryDocumentBuilder builder = new XQueryDocumentBuilder(doc);
builder.WriteString((string)value);
XPathFactory.XQueryDynNodeNavigator nav = new XPathFactory.XQueryDynNodeNavigator(doc);
nav.MoveTo(doc.CreateNavigator());
return nav;
}
public static object DynCreateComment([Implict] Executive executive, object value)
{
XQueryContext context = (XQueryContext)executive.Owner;
XQueryDocument doc = context.CreateDocument();
XQueryDocumentBuilder builder = new XQueryDocumentBuilder(doc);
string text = value == Undefined.Value ? "" : NormalizeStringValue((string)value, false, true);
if (text.EndsWith("-") || text.Contains("--"))
throw new XQueryException(Properties.Resources.XQDY0072);
builder.WriteComment(text);
XPathFactory.XQueryDynNodeNavigator nav = new XPathFactory.XQueryDynNodeNavigator(doc);
nav.MoveTo(doc.CreateNavigator());
return nav;
}
public static object DynCreateElement([Implict] Executive executive, object name, XmlNamespaceManager nsmgr, object body)
{
XQueryContext context = (XQueryContext)executive.Owner;
XQueryDocument doc = context.CreateDocument();
XQueryDocumentBuilder builder = new XQueryDocumentBuilder(doc);
QNameValue qname = GetQualifiedName(name, nsmgr, nsmgr.DefaultNamespace);
builder.WriteStartElement(qname.Prefix, qname.LocalName, qname.NamespaceUri);
if (body != null)
WriteNode(executive, builder, body);
builder.WriteEndElement();
return doc.CreateNavigator();
}
public static object DynCreateAttribute([Implict] Executive executive, object name, XmlNamespaceManager nsmgr, object value)
{
XQueryContext context = (XQueryContext)executive.Owner;
XQueryDocument doc = context.CreateDocument();
XQueryDocumentBuilder builder = new XQueryDocumentBuilder(doc);
QNameValue qname = GetQualifiedName(name, nsmgr, "");
if (qname.Prefix == "xmlns" || (qname.Prefix == "" && qname.LocalName == "xmlns"))
throw new XQueryException(Properties.Resources.XQDY0044);
builder.WriteStartElement("dummy");
builder.WriteStartAttribute(qname.Prefix, qname.LocalName, qname.NamespaceUri);
string text = value == Undefined.Value ? "" : (string)value;
builder.WriteString(text);
builder.WriteEndAttribute();
builder.WriteEndElement();
XPathNavigator nav = doc.CreateNavigator();
return new NodeIterator(XPathFactory.DynAttributeIterator(nav));
}
public static object DynCreateDocument([Implict] Executive executive, object body)
{
XQueryContext context = (XQueryContext)executive.Owner;
XQueryDocument doc = context.CreateDocument();
XQueryDocumentBuilder builder = new XQueryDocumentBuilder(doc);
builder.WriteStartDocument();
if (body != null)
WriteNode(executive, builder, body);
return doc.CreateNavigator();
}
public XQueryDocument(XmlReader reader, XmlSpace space)
: this()
{
this.input = reader;
nameTable = input.NameTable;
builder = new XQueryDocumentBuilder(this);
builder.SchemaInfo = input.SchemaInfo;
baseUri = reader.BaseURI;
preserveSpace = (space == XmlSpace.Preserve);
}
public XQueryDocument(Stream stream, XmlReaderSettings settings)
: this()
{
input = XmlReader.Create(stream, settings);
builder = new XQueryDocumentBuilder(this);
}
public XQueryDocument(TextReader textReader)
: this()
{
input = XmlReader.Create(textReader);
builder = new XQueryDocumentBuilder(this);
}
public XQueryDocument(Stream stream)
: this()
{
input = XmlReader.Create(stream);
builder = new XQueryDocumentBuilder(this);
}
private void Read()
{
token.ThrowIfCancellationRequested();
if (lookahead || input.Read())
{
if (documentRoot == null)
{
builder.WriteStartDocument();
documentRoot = builder.DocumentRoot;
}
lookahead = false;
switch (input.NodeType)
{
case XmlNodeType.XmlDeclaration:
break;
case XmlNodeType.DocumentType:
try
{
object documentType;
string value = input.Value;
if (value == "")
documentType = DTDParser.ParseExternal(input.GetAttribute("PUBLIC"),
input.GetAttribute("SYSTEM"), baseUri);
else
documentType = DTDParser.ParseInline(value, baseUri);
CreateIdTable(documentType);
}
catch (XQueryException)
{
}
break;
case XmlNodeType.Element:
builder.IsEmptyElement = input.IsEmptyElement;
builder.WriteStartElement(input.Prefix, input.LocalName, input.NamespaceURI);
string elemName = input.Name;
while (input.MoveToNextAttribute())
{
builder.WriteStartAttribute(input.Prefix, input.LocalName, input.NamespaceURI);
builder.WriteString(input.Value);
builder.WriteEndAttribute();
if (elemIdTable != null)
{
string name;
if (elemIdTable.TryGetValue(elemName, out name) &&
name == input.Name)
{
if (IdTable == null)
IdTable = new Dictionary<string, int>();
if (!IdTable.ContainsKey(input.Value))
IdTable.Add(input.Value, builder.Position);
}
}
if (pagefile.HasSchemaInfo)
{
IXmlSchemaInfo schemaInfo = input.SchemaInfo;
if (schemaInfo != null && schemaInfo.SchemaType != null)
{
XmlTypeCode typeCode = schemaInfo.SchemaType.TypeCode;
if (typeCode == XmlTypeCode.Id)
{
if (IdTable == null)
IdTable = new Dictionary<string, int>();
if (!IdTable.ContainsKey(input.Value))
IdTable.Add(input.Value, builder.Position);
}
}
}
}
if (builder.IsEmptyElement)
builder.WriteEndElement();
else
{
while (input.Read())
{
if (input.NodeType == XmlNodeType.Text)
builder.WriteString(input.Value);
else if (input.NodeType == XmlNodeType.Whitespace)
{
if (preserveSpace)
builder.WriteString(input.Value);
}
else if (input.NodeType == XmlNodeType.EndElement)
{
builder.WriteEndElement();
break;
}
else
{
builder.CompleteElement();
lookahead = true;
break;
}
}
}
break;
case XmlNodeType.EndElement:
builder.WriteEndElement();
break;
case XmlNodeType.Text:
case XmlNodeType.CDATA:
builder.WriteString(input.Value);
break;
case XmlNodeType.EntityReference:
input.ResolveEntity();
break;
case XmlNodeType.ProcessingInstruction:
builder.WriteProcessingInstruction(input.LocalName, input.Value);
break;
case XmlNodeType.Comment:
builder.WriteComment(input.Value);
break;
case XmlNodeType.Whitespace:
case XmlNodeType.SignificantWhitespace:
if (preserveSpace)
builder.WriteString(input.Value);
break;
}
}
else
{
builder.WriteEndDocument();
input.Close();
input = null;
builder = null;
}
}
public void Open(Uri uri, XmlReaderSettings settings, XmlSpace space, CancellationToken token)
{
bool large = false;
if (uri.Scheme == "file")
{
FileInfo fi = new FileInfo(uri.LocalPath);
if (fi.Exists && fi.Length > XQueryLimits.LargeFileLength)
large = true;
}
pagefile = new PageFile(large);
input = XmlReader.Create(uri.AbsoluteUri, settings);
nameTable = input.NameTable;
builder = new XQueryDocumentBuilder(this);
builder.SchemaInfo = input.SchemaInfo;
pagefile.HasSchemaInfo = (input.SchemaInfo != null);
baseUri = input.BaseURI;
preserveSpace = (space == XmlSpace.Preserve);
this.token = token;
}
private IEnumerable<XPathItem> DocumentIterator(XQueryContext context, XQueryNodeIterator iter)
{
foreach (XPathItem item in iter)
{
XPathNavigator nav = item as XPathNavigator;
if (nav != null && nav.NodeType != XPathNodeType.Root)
{
XQueryDocument doc = context.CreateDocument();
XQueryDocumentBuilder builder = new XQueryDocumentBuilder(doc);
builder.WriteStartDocument();
Core.WriteNode(context.Engine, builder, nav);
yield return doc.CreateNavigator();
}
else
yield return item;
}
}
public static object DynCreateElement([Implict] Executive executive, QNameValue name, object body)
{
XQueryContext context = (XQueryContext)executive.Owner;
XQueryDocument doc = context.CreateDocument();
XQueryDocumentBuilder builder = new XQueryDocumentBuilder(doc);
builder.WriteStartElement(name.Prefix, name.LocalName, name.NamespaceUri);
if (body != null)
WriteNode(executive, builder, body);
builder.WriteEndElement();
return doc.CreateNavigator();
}
private bool CompareFragment(XQueryContext context, string sourceFile, XQueryNodeIterator iter, XmlSpace space)
{
StringBuilder sb = new StringBuilder();
sb.AppendLine("<?xml version='1.0'?>");
sb.Append("<root>");
TextReader textReader = new StreamReader(sourceFile, true);
sb.Append(textReader.ReadToEnd());
textReader.Close();
sb.Append("</root>");
XmlReaderSettings settings = context.GetSettings();
XmlReader reader = XmlReader.Create(new StringReader(sb.ToString()), settings);
XQueryDocument doc1 = new XQueryDocument(reader, space);
doc1.Fill();
context.AddDocument(doc1);
XQueryDocument doc2 = context.CreateDocument();
XQueryDocumentBuilder builder = new XQueryDocumentBuilder(doc2);
builder.WriteStartDocument();
builder.WriteStartElement("root", "");
Core.WriteNode(context.Engine, builder, iter.Clone());
builder.WriteEndElement();
XQueryNodeIterator iter1 = new NodeIterator(new XPathItem[] { doc1.CreateNavigator() });
XQueryNodeIterator iter2 = new NodeIterator(new XPathItem[] { doc2.CreateNavigator() });
TreeComparer comparer = new TreeComparer();
comparer.IgnoreWhitespace = true;
bool res = comparer.DeepEqual(iter1, iter2);
return res;
}
public XQueryDocument(string uri, XmlSpace space)
: this()
{
XmlReaderSettings settings = new XmlReaderSettings();
settings.IgnoreWhitespace = space != XmlSpace.Preserve;
settings.DtdProcessing = DtdProcessing.Parse;
settings.XmlResolver = null;
settings.NameTable = nameTable;
input = XmlReader.Create(uri, settings);
builder = new XQueryDocumentBuilder(this);
builder.SchemaInfo = input.SchemaInfo;
baseUri = input.BaseURI;
preserveSpace = (space == XmlSpace.Preserve);
}
