/// <summary>
/// This constructor is internal so that external users cannot construct it (and therefore we do not have to test it separately).
/// Initialize output state to accept Rtf content (top-level sequences are therefore prohibited).
/// </summary>
internal XmlQueryOutput(XmlQueryRuntime runtime, XmlEventCache xwrt) {
this.runtime = runtime;
this.xwrt = xwrt;
this.xstate = XmlState.WithinContent;
this.depth = 1;
this.rootType = XPathNodeType.Root;
}
/// <summary>
/// This constructor is internal so that external users cannot construct it (and therefore we do not have to test it separately).
/// Initialize output state to accept Rtf content (top-level sequences are therefore prohibited).
/// </summary>
internal XmlQueryOutput(XmlQueryRuntime runtime, XmlEventCache xwrt)
{
_runtime = runtime;
_xwrt = xwrt;
_xstate = XmlState.WithinContent;
_depth = 1;
_rootType = XPathNodeType.Root;
}
public override void AcceptName(RCToken token)
{
if (_state == XmlState.OpenTag)
{
_tags.Push(token.Text);
_state = XmlState.Attributes;
}
else if (_state == XmlState.Attributes)
{
_attribute = token.Text;
}
}
private void RunForFile(string byteFilename, string xmlFilename)
{
XmlState xmlSpec = XmlStatePersistor.LoadState(xmlFilename);
Assert.NotNull(xmlSpec);
bool failed = false;
using (StreamReader byteFile = new StreamReader(byteFilename))
{
while (!byteFile.EndOfStream)
{
string[] parts = byteFile.ReadLine().Split(": ");
Assert.Equal(2, parts.Length);
int index = int.Parse(parts[0]);
int count = int.Parse(parts[1]);
Macro macroXml = xmlSpec.MacroPool.FirstOrDefault(m => m.Index == index);
Assert.NotNull(macroXml);
List <byte[]> data = Enumerable.Range(0, count).Select(x => byteFile.ReadLine().HexToByteArray()).ToList();
Assert.Equal(macroXml.Operations.Count, data.Count);
for (var i = 0; i < count; i++)
{
try
{
MacroOpBase converted = MacroOpManager.CreateFromData(data[i], false);
MacroOpBase op = macroXml.Operations[i].ToMacroOp();
if (!Equals(converted, op))
{
output.WriteLine("Line {2}\nGot:\n {0}Expected:\n {1}", ToString(converted), ToString(op), i);
failed = true;
}
}
catch (Exception e)
{
output.WriteLine(e.Message + "\n");
failed = true;
}
}
}
}
Assert.False(failed);
}
private void RunForFile(string filename)
{
string tmpFile = Path.GetTempFileName();
string fullPath = Path.Combine(AppContext.BaseDirectory, filename);
XmlState profile = XmlStatePersistor.LoadState(fullPath);
Assert.NotNull(profile);
Assert.True(XmlStatePersistor.SaveState(tmpFile, profile));
List <string> changes = CompileXmlChanges(CalculateFileVersion(profile.MajorVersion, profile.MinorVersion), fullPath, tmpFile);
File.Delete(tmpFile);
string res = String.Join(Environment.NewLine, changes);
output.WriteLine(res);
Assert.Equal("", res);
}
public override void AcceptXmlBracket(RCToken token)
{
if (token.Text.Equals("<"))
{
_contents.Push(RCBlock.Empty);
_attributes.Push(RCBlock.Empty);
_state = XmlState.OpenTag;
}
else if (token.Text.Equals(">"))
{
if (_state == XmlState.Attributes)
{
_state = XmlState.Content;
}
}
else if (token.Text.Equals("</") || token.Text.Equals("/>"))
{
// The current child is already at the top of the stack see "<"
RCBlock child = _contents.Pop();
RCBlock attributes = _attributes.Pop();
// null to be replaced with block of attributes
if (child.Count == 0)
{
child = new RCBlock(attributes, "", ":", _text);
}
else
{
child = new RCBlock(attributes, "", ":", child);
}
RCBlock next = new RCBlock(_contents.Pop(), _tags.Pop(), ":", child);
_contents.Push(next);
_text = _default;
_state = XmlState.CloseTag;
}
else if (token.Text.Equals("="))
{
}
}
/// <summary>
/// XmlRawWriter.WriteStartAttribute() with prefix, local-name, ns, and schema type.
/// </summary>
public void WriteStartAttributeUnchecked(string prefix, string localName, string ns) {
Debug.Assert(this.xstate == XmlState.EnumAttrs, "WriteStartAttribute cannot be called in the " + this.xstate + " state.");
Writer.WriteStartAttribute(prefix, localName, ns);
this.xstate = XmlState.WithinAttr;
this.depth++;
}
/// <summary>
/// Call XmlRawWriter.WriteEndElement() with prefix, local-name, and ns.
/// </summary>
public void WriteEndElementUnchecked(string prefix, string localName, string ns) {
Debug.Assert(this.xstate == XmlState.EnumAttrs || this.xstate == XmlState.WithinContent, "WriteEndElement cannot be called in the " + this.xstate + " state.");
Writer.WriteEndElement(prefix, localName, ns);
this.xstate = XmlState.WithinContent;
this.depth--;
if (this.nsmgr != null) this.nsmgr.PopScope();
}
/// <summary>
/// Call XmlRawWriter.StartElementContent().
/// </summary>
public void StartElementContentUnchecked() {
Debug.Assert(this.xstate == XmlState.EnumAttrs, "StartElementContent cannot be called in the " + this.xstate + " state.");
// Output any cached namespaces
if (this.cntNmsp != 0)
WriteCachedNamespaces();
Writer.StartElementContent();
this.xstate = XmlState.WithinContent;
}
//-----------------------------------------------
// XmlQueryOutput methods (XmlRawWriter)
//-----------------------------------------------
/// <summary>
/// Call XmlRawWriter.WriteStartElement() with prefix, local-name, ns, and schema type.
/// </summary>
public void WriteStartElementUnchecked(string prefix, string localName, string ns) {
Debug.Assert(this.xstate == XmlState.WithinContent, "WriteStartElement cannot be called in the " + this.xstate + " state.");
if (this.nsmgr != null) this.nsmgr.PushScope();
Writer.WriteStartElement(prefix, localName, ns);
this.xstate = XmlState.EnumAttrs;
this.depth++;
this.useDefNmsp = ns.Length == 0;
}
protected override void When()
{
_state = new XmlState();
}
/// <summary>
/// Before writing a comment, perform various checks to ensure well-formedness.
/// </summary>
public void WriteStartComment() {
// Xml state transitions
ConstructWithinContent(XPathNodeType.Comment);
this.nodeText.Clear();
this.xstate = XmlState.WithinComment;
this.depth++;
}
/// <summary>
/// Before writing a namespace, perform various checks to ensure well-formedness.
/// </summary>
public void WriteStartNamespace(string prefix) {
Debug.Assert(prefix != null, "Invalid argument");
// Handle namespace attributes that are not sent directly to WriteNamespaceDeclaration
ConstructInEnumAttrs(XPathNodeType.Namespace);
this.piTarget/*nmspPrefix*/ = prefix;
this.nodeText.Clear();
this.xstate = XmlState.WithinNmsp;
this.depth++;
}
/// <summary>
/// Ensure that state transitions to EnumAttrs.
/// </summary>
private void ConstructInEnumAttrs(XPathNodeType rootType) {
Debug.Assert(rootType == XPathNodeType.Attribute || rootType == XPathNodeType.Namespace);
switch (this.xstate) {
case XmlState.WithinSequence:
StartTree(rootType);
this.xstate = XmlState.EnumAttrs;
break;
case XmlState.EnumAttrs:
// Already in EnumAttrs state
break;
default:
// Construction is not allowed in this state
ThrowInvalidStateError(rootType);
break;
}
}
/// <summary>
/// Ensure that state transitions to WithinContent.
/// </summary>
private void ConstructWithinContent(XPathNodeType rootType) {
Debug.Assert(rootType == XPathNodeType.Element || rootType == XPathNodeType.Comment || rootType == XPathNodeType.ProcessingInstruction);
switch (this.xstate) {
case XmlState.WithinSequence:
// If state is WithinSequence, call XmlSequenceWriter.StartTree
StartTree(rootType);
this.xstate = XmlState.WithinContent;
break;
case XmlState.WithinContent:
// Already within element content
break;
case XmlState.EnumAttrs:
// Start element content
StartElementContentUnchecked();
break;
default:
// Construction is not allowed in this state
ThrowInvalidStateError(rootType);
break;
}
}
private void Process()
{
var state = XmlState.Other;
var line = 1;
var ch = ReadText();
_i = 0;
while (ch > 0)
{
switch (ch)
{
case '\r':
ReadText('\n');
line++;
_lineOffsets.Add(_i + 1);
if (state == XmlState.Tag)
{
state = XmlState.Attribute;
}
break;
case '\n':
line++;
_lineOffsets.Add(_i + 1);
if (state == XmlState.Tag)
{
state = XmlState.Attribute;
}
break;
default:
switch (state)
{
case XmlState.Attribute:
if (ch == '=')
{
if (ReadText('"') || ReadText('\''))
{
state = XmlState.AttributeValue;
}
}
else if (ch == '>')
{
state = XmlState.Other;
}
break;
case XmlState.AttributeValue:
if (ch == '"' || ch == '\'')
{
state = XmlState.Tag;
}
break;
case XmlState.CData:
if (ch == ']' && ReadText("]>"))
{
state = XmlState.Other;
}
break;
case XmlState.Comment:
if (ch == '-' && ReadText("->"))
{
state = XmlState.Other;
}
break;
case XmlState.Tag:
if (char.IsWhiteSpace((char)ch))
{
state = XmlState.Attribute;
}
else if (ch == '>')
{
state = XmlState.Other;
}
break;
case XmlState.Other:
if (ch == '<')
{
if (_reader.Peek() == '!')
{
ReadText();
if (ReadText("--"))
{
state = XmlState.Comment;
}
else if (ReadText("[CDATA["))
{
state = XmlState.CData;
}
}
else
{
state = XmlState.Tag;
}
}
break;
}
break;
}
ch = ReadText();
}
switch (state)
{
case XmlState.Attribute:
if (char.IsWhiteSpace(_builder[_builder.Length - 1]))
{
state = XmlState.AttributeStart;
_builder.Append(">");
}
else
{
_builder.Append("=\"\">");
}
break;
case XmlState.AttributeValue:
if (_builder[_builder.Length - 1] == '=')
{
_builder.Append('"');
}
else
{
if (_builder[LastIndexOf('=') + 1] == '\'')
{
_builder.Append("'>");
}
else
{
_builder.Append("\">");
}
}
break;
case XmlState.CData:
_builder.Append("]]>");
break;
case XmlState.Comment:
_builder.Append("-->");
break;
case XmlState.Tag:
if (_builder[_builder.Length - 1] == '<')
{
_builder.Append(__noName);
}
_builder.Append(">");
break;
}
_builder.Append("<!--").Append(__eof).Append("-->");
_reader = null;
var settings = new XmlReaderSettings()
{
ConformanceLevel = ConformanceLevel.Fragment
};
var textReader = new System.IO.StringReader(_builder.ToString());
_builder.Length = 0;
_xml = XmlReader.Create(textReader, settings);
_endState = state;
}
private void Process()
{
var state = XmlState.Other;
var line = 1;
var ch = ReadText();
_i = 0;
while (ch > 0)
{
switch (ch)
{
case '\r':
ReadText('\n');
line++;
_lineOffsets.Add(_i + 1);
if (state == XmlState.Tag) state = XmlState.Attribute;
break;
case '\n':
line++;
_lineOffsets.Add(_i + 1);
if (state == XmlState.Tag) state = XmlState.Attribute;
break;
default:
switch (state)
{
case XmlState.Attribute:
if (ch == '=')
{
if (ReadText('"') || ReadText('\''))
{
state = XmlState.AttributeValue;
}
}
else if (ch == '>')
{
state = XmlState.Other;
}
break;
case XmlState.AttributeValue:
if (ch == '"' || ch == '\'')
{
state = XmlState.Tag;
}
break;
case XmlState.CData:
if (ch == ']' && ReadText("]>"))
{
state = XmlState.Other;
}
break;
case XmlState.Comment:
if (ch == '-' && ReadText("->"))
{
state = XmlState.Other;
}
break;
case XmlState.Tag:
if (char.IsWhiteSpace((char)ch))
{
state = XmlState.Attribute;
}
else if (ch == '>')
{
state = XmlState.Other;
}
break;
case XmlState.Other:
if (ch == '<')
{
if (_reader.Peek() == '!')
{
ReadText();
if (ReadText("--"))
{
state = XmlState.Comment;
}
else if (ReadText("[CDATA["))
{
state = XmlState.CData;
}
}
else
{
state = XmlState.Tag;
}
}
break;
}
break;
}
ch = ReadText();
}
switch (state)
{
case XmlState.Attribute:
if (char.IsWhiteSpace(_builder[_builder.Length - 1]))
{
state = XmlState.AttributeStart;
_builder.Append(">");
}
else
{
_builder.Append("=\"\">");
}
break;
case XmlState.AttributeValue:
if (_builder[_builder.Length - 1] == '=')
{
_builder.Append('"');
}
else
{
if (_builder[LastIndexOf('=') + 1] == '\'')
{
_builder.Append("'>");
}
else
{
_builder.Append("\">");
}
}
break;
case XmlState.CData:
_builder.Append("]]>");
break;
case XmlState.Comment:
_builder.Append("-->");
break;
case XmlState.Tag:
if (_builder[_builder.Length - 1] == '<') _builder.Append(__noName);
_builder.Append(">");
break;
}
_builder.Append("<!--").Append(__eof).Append("-->");
_reader = null;
var settings = new XmlReaderSettings() { ConformanceLevel = ConformanceLevel.Fragment };
var textReader = new System.IO.StringReader(_builder.ToString());
_builder.Length = 0;
_xml = XmlReader.Create(textReader, settings);
_endState = state;
}
/// <summary>
/// Before writing a namespace, perform various checks to ensure well-formedness.
/// </summary>
public void WriteEndNamespace() {
Debug.Assert(this.xstate == XmlState.WithinNmsp, "WriteEndNamespace cannot be called in the " + this.xstate + " state.");
this.xstate = XmlState.EnumAttrs;
this.depth--;
// Write cached namespace attribute
WriteNamespaceDeclaration(this.nmspPrefix, this.nmspText);
this.nmspPrefix = null;
if (this.depth == 0)
EndTree();
}
/// <summary>
/// XmlRawWriter.WriteEndAttribute().
/// </summary>
public void WriteEndAttributeUnchecked() {
Debug.Assert(this.xstate == XmlState.WithinAttr, "WriteEndAttribute cannot be called in the " + this.xstate + " state.");
Writer.WriteEndAttribute();
this.xstate = XmlState.EnumAttrs;
this.depth--;
}
/// <summary>
/// Before writing a comment, perform various checks to ensure well-formedness.
/// </summary>
public void WriteEndComment() {
Debug.Assert(this.xstate == XmlState.WithinComment, "WriteEndComment cannot be called in the " + this.xstate + " state.");
Writer.WriteComment(this.nodeText.GetResult());
this.xstate = XmlState.WithinContent;
this.depth--;
if (this.depth == 0)
EndTree();
}
private Dictionary<string, string> usedPrefixes = new Dictionary<string, string>(); //The prefies that used in the current scope
/// <summary>
/// This constructor is internal so that external users cannot construct it (and therefore we do not have to test it separately).
/// Initialize output state to accept top-level sequences.
/// </summary>
internal XmlQueryOutput(XmlQueryRuntime runtime, XmlSequenceWriter seqwrt) {
this.runtime = runtime;
this.seqwrt = seqwrt;
this.xstate = XmlState.WithinSequence;
}
/// <summary>
/// Before writing a processing instruction, perform various checks to ensure well-formedness.
/// </summary>
public void WriteEndProcessingInstruction() {
Debug.Assert(this.xstate == XmlState.WithinPI, "WriteEndProcessingInstruction cannot be called in the " + this.xstate + " state.");
Writer.WriteProcessingInstruction(this.piTarget, this.nodeText.GetResult());
this.xstate = XmlState.WithinContent;
this.depth--;
// Xml state transitions
if (this.depth == 0)
EndTree();
}
/// <summary>
/// Before writing a namespace, perform various checks to ensure well-formedness.
/// </summary>
public void WriteEndNamespace() {
Debug.Assert(this.xstate == XmlState.WithinNmsp, "WriteEndNamespace cannot be called in the " + this.xstate + " state.");
this.xstate = XmlState.EnumAttrs;
this.depth--;
// Write cached namespace attribute
WriteNamespaceDeclaration(this.piTarget/*nmspPrefix*/, this.nodeText.GetResult());
if (this.depth == 0)
EndTree();
}
protected override void GivenThat()
{
base.GivenThat();
_state = new XmlState(_testXmlDocument);
}
/// <summary>
/// Return the type of node that is under construction given the specified XmlState.
/// </summary>
private XPathNodeType XmlStateToNodeType(XmlState xstate) {
switch (xstate) {
case XmlState.EnumAttrs: return XPathNodeType.Element;
case XmlState.WithinContent: return XPathNodeType.Element;
case XmlState.WithinAttr: return XPathNodeType.Attribute;
case XmlState.WithinComment: return XPathNodeType.Comment;
case XmlState.WithinPI: return XPathNodeType.ProcessingInstruction;
}
Debug.Assert(false, xstate.ToString() + " is not a valid XmlState.");
return XPathNodeType.Element;
}
/// <summary>
/// Before writing a comment, perform various checks to ensure well-formedness.
/// </summary>
public void WriteStartComment() {
// Xml state transitions
ConstructWithinContent(XPathNodeType.Comment);
this.commentText = string.Empty;
this.xstate = XmlState.WithinComment;
this.depth++;
}
/// <summary>
/// Before writing a processing instruction, perform various checks to ensure well-formedness.
/// </summary>
public void WriteStartProcessingInstruction(string target) {
// Xml state transitions
ConstructWithinContent(XPathNodeType.ProcessingInstruction);
// Verify PI name
ValidateNames.ValidateNameThrow("", target, "", XPathNodeType.ProcessingInstruction, ValidateNames.Flags.AllExceptPrefixMapping);
this.piTarget = target;
this.nodeText.Clear();
this.xstate = XmlState.WithinPI;
this.depth++;
}
//-----------------------------------------------
// XmlQueryOutput methods (XmlSequenceWriter)
//-----------------------------------------------
/// <summary>
/// Call XmlSequenceWriter.StartTree() in order to start construction of a new tree.
/// </summary>
public void StartTree(XPathNodeType rootType) {
Debug.Assert(this.xstate == XmlState.WithinSequence, "StartTree cannot be called in the " + this.xstate + " state.");
Writer = this.seqwrt.StartTree(rootType, this.nsmgr, this.runtime.NameTable);
this.rootType = rootType;
this.xstate = (rootType == XPathNodeType.Attribute || rootType == XPathNodeType.Namespace) ? XmlState.EnumAttrs : XmlState.WithinContent;
}
protected override void When()
{
_state = new XmlState(_testXmlDocument);
}
/// <summary>
/// Call XmlSequenceWriter.EndTree().
/// </summary>
public void EndTree() {
Debug.Assert(this.xstate == XmlState.EnumAttrs || this.xstate == XmlState.WithinContent, "EndTree cannot be called in the " + this.xstate + " state.");
this.seqwrt.EndTree();
this.xstate = XmlState.WithinSequence;
Writer = null;
}
//-----------------------------------------------
// XmlQueryOutput methods (XmlRawWriter)
//-----------------------------------------------
/// <summary>
/// Call XmlRawWriter.WriteStartElement() with prefix, local-name, ns, and schema type.
/// </summary>
public void WriteStartElementUnchecked(string prefix, string localName, string ns) {
Debug.Assert(this.xstate == XmlState.WithinContent, "WriteStartElement cannot be called in the " + this.xstate + " state.");
if (this.nsmgr != null) this.nsmgr.PushScope();
Writer.WriteStartElement(prefix, localName, ns);
//reset when enter element
usedPrefixes.Clear();
usedPrefixes[prefix] = ns;
this.xstate = XmlState.EnumAttrs;
this.depth++;
}
private Dictionary<string, string> _usedPrefixes = new Dictionary<string, string>(); //The prefies that used in the current scope
/// <summary>
/// This constructor is internal so that external users cannot construct it (and therefore we do not have to test it separately).
/// Initialize output state to accept top-level sequences.
/// </summary>
internal XmlQueryOutput(XmlQueryRuntime runtime, XmlSequenceWriter seqwrt)
{
_runtime = runtime;
_seqwrt = seqwrt;
_xstate = XmlState.WithinSequence;
}
