// Token: 0x06007854 RID: 30804 RVA: 0x002243FC File Offset: 0x002225FC
public static void UpdateAnnotation(XmlToken token, StickyNoteControl snc, SNCAnnotation sncAnnotation)
{
AnnotationService annotationService = null;
bool autoFlush = false;
try
{
annotationService = AnnotationService.GetService(((IAnnotationComponent)snc).AnnotatedElement);
if (annotationService != null && annotationService.Store != null)
{
autoFlush = annotationService.Store.AutoFlush;
annotationService.Store.AutoFlush = false;
}
if ((token & XmlToken.Ink) != (XmlToken)0 && snc.Content.Type == StickyNoteType.Ink)
{
sncAnnotation.UpdateContent(snc, true, XmlToken.Ink);
}
if ((token & XmlToken.Text) != (XmlToken)0 && snc.Content.Type == StickyNoteType.Text)
{
sncAnnotation.UpdateContent(snc, true, XmlToken.Text);
}
if ((token & (XmlToken.Left | XmlToken.Top | XmlToken.XOffset | XmlToken.YOffset | XmlToken.Width | XmlToken.Height | XmlToken.IsExpanded | XmlToken.Author | XmlToken.ZOrder)) != (XmlToken)0)
{
SNCAnnotation.UpdateMetaData(token, snc, sncAnnotation);
}
}
finally
{
if (annotationService != null && annotationService.Store != null)
{
annotationService.Store.AutoFlush = autoFlush;
}
}
}
// Token: 0x0600785B RID: 30811 RVA: 0x002248A0 File Offset: 0x00222AA0
private static void GetCargoAndRoot(SNCAnnotation annotation, XmlToken token, out AnnotationResource cargo, out XmlElement root, out bool newCargo, out bool newRoot)
{
Invariant.Assert(annotation != null, "Annotation is null.");
Invariant.Assert((token & (XmlToken.MetaData | XmlToken.Left | XmlToken.Top | XmlToken.XOffset | XmlToken.YOffset | XmlToken.Width | XmlToken.Height | XmlToken.IsExpanded | XmlToken.Author | XmlToken.Text | XmlToken.Ink | XmlToken.ZOrder)) > (XmlToken)0, "No token specified.");
string cargoName = SNCAnnotation.GetCargoName(token);
newRoot = false;
newCargo = false;
cargo = annotation.FindCargo(cargoName);
if (cargo != null)
{
root = SNCAnnotation.FindRootXmlElement(token, cargo);
if (root == null)
{
newRoot = true;
XmlDocument xmlDocument = new XmlDocument();
root = xmlDocument.CreateElement(SNCAnnotation.GetXmlName(token), "http://schemas.microsoft.com/windows/annotations/2003/11/base");
return;
}
}
else
{
newCargo = true;
cargo = new AnnotationResource(cargoName);
XmlDocument xmlDocument2 = new XmlDocument();
root = xmlDocument2.CreateElement(SNCAnnotation.GetXmlName(token), "http://schemas.microsoft.com/windows/annotations/2003/11/base");
cargo.Contents.Add(root);
}
}
public IXmlAttributeValue Parse(IXmlAttributeValue xmlAttributeValue)
{
ReferenceNameAttributeValue attributeValue = new ReferenceNameAttributeValue();
CompositeElement result = null;
string rawValue = xmlAttributeValue.UnquotedValue;
try
{
result = ParseTypeNameOrAttributeValue(rawValue);
}
catch (SyntaxError syntaxError)
{
result = (CompositeElement)syntaxError.ParsingResult;
result = handleError(result, syntaxError);
}
attributeValue.AddChild(new XmlToken(L4NTokenNodeType.QUOTE, new StringBuffer(new string('\"', 1)), 0, 1));
attributeValue.AddChild(result);
int resultLegth = result.GetText().Length;
if(resultLegth < rawValue.Length)
{
string suffix = rawValue.Substring(resultLegth);
StringBuffer sb = new StringBuffer(suffix);
XmlToken suffixToken = new XmlToken(L4NTokenNodeType.TEXT , sb, 0, suffix.Length);
attributeValue.AddChild(suffixToken);
}
attributeValue.AddChild(new XmlToken(L4NTokenNodeType.QUOTE, new StringBuffer(new string('\"', 1)), 0, 1));
return attributeValue;
}
/// <summary>
/// Before any doctype - still in the prolog. No declaration
/// allowed.
/// </summary>
/// <param name="token">The consumed token.</param>
private void BeforeDoctype(XmlToken token)
{
switch (token.Type)
{
case XmlTokenType.Doctype:
{
var doctypeToken = (XmlDoctypeToken)token;
var doctypeNode = new DocumentType(_document, doctypeToken.Name)
{
SystemIdentifier = doctypeToken.SystemIdentifier,
PublicIdentifier = doctypeToken.PublicIdentifier
};
_document.AppendChild(doctypeNode);
_currentMode = XmlTreeMode.Misc;
break;
}
default:
{
InMisc(token);
break;
}
}
}
/// <summary>
/// Consumes a token and processes it.
/// </summary>
/// <param name="token">The token to consume.</param>
private void Consume(XmlToken token)
{
switch (_currentMode)
{
case XmlTreeMode.Initial:
Initial(token);
break;
case XmlTreeMode.Prolog:
BeforeDoctype(token);
break;
case XmlTreeMode.Misc:
InMisc(token);
break;
case XmlTreeMode.Body:
InBody(token);
break;
case XmlTreeMode.After:
AfterBody(token);
break;
}
}
public override void Write(XmlNodeType nodeType, QName name, string value)
{
lock (this)
{
Debug.Assert(ReadEndPos <= WritePos && WritePos <= ReadStartPos + Buffer.Length);
if (WritePos == ReadStartPos + Buffer.Length)
{
if (WritePos == ReadEndPos)
{
ExpandBuffer();
}
else
{
Monitor.Wait(this);
}
}
Debug.Assert(WritePos < ReadStartPos + Buffer.Length);
XmlToken.Set(ref Buffer[WritePos & Mask], nodeType, name, value);
WritePos++;
if (ReadStartPos + Buffer.Length <= WritePos)
{
// This "if" is some heuristics, it may wrk or may not:
// To minimize task switching we wakeup reader ony if we wrote enouph tokens.
// So if reader already waits, let it sleep before we fill up the buffer.
Monitor.Pulse(this);
}
}
}
/// <summary>
/// After the body state - nothing except Comment PI S allowed.
/// </summary>
/// <param name="token">The consumed token.</param>
private void AfterBody(XmlToken token)
{
switch (token.Type)
{
case XmlTokenType.ProcessingInstruction:
case XmlTokenType.Comment:
{
InMisc(token);
break;
}
case XmlTokenType.EndOfFile:
{
break;
}
default:
{
if (!token.IsIgnorable && !_options.IsSuppressingErrors)
{
throw XmlParseError.XmlMissingRoot.At(token.Position);
}
break;
}
}
}
// Token: 0x0600785C RID: 30812 RVA: 0x0022494C File Offset: 0x00222B4C
private void UpdateAttribute(XmlElement root, XmlToken token, string value)
{
string xmlName = SNCAnnotation.GetXmlName(token);
XmlNode attributeNode = root.GetAttributeNode(xmlName, "http://schemas.microsoft.com/windows/annotations/2003/11/base");
if (attributeNode == null)
{
if (value == null)
{
return;
}
root.SetAttribute(xmlName, "http://schemas.microsoft.com/windows/annotations/2003/11/base", value);
return;
}
else
{
if (value == null)
{
root.RemoveAttribute(xmlName, "http://schemas.microsoft.com/windows/annotations/2003/11/base");
return;
}
if (attributeNode.Value != value)
{
root.SetAttribute(xmlName, "http://schemas.microsoft.com/windows/annotations/2003/11/base", value);
}
return;
}
}
// Token: 0x06007851 RID: 30801 RVA: 0x0022435C File Offset: 0x0022255C
static SNCAnnotation()
{
foreach (object obj in Enum.GetValues(typeof(XmlToken)))
{
XmlToken token = (XmlToken)obj;
SNCAnnotation.AddXmlTokenNames(token);
}
}
// Token: 0x06007863 RID: 30819 RVA: 0x00224D80 File Offset: 0x00222F80
private static void UpdateMetaData(XmlToken token, StickyNoteControl snc, SNCAnnotation sncAnnotation)
{
AnnotationResource annotationResource;
XmlElement xmlElement;
bool flag;
bool flag2;
SNCAnnotation.GetCargoAndRoot(sncAnnotation, XmlToken.MetaData, out annotationResource, out xmlElement, out flag, out flag2);
if ((token & XmlToken.IsExpanded) != (XmlToken)0)
{
bool isExpanded = snc.IsExpanded;
sncAnnotation.UpdateAttribute(xmlElement, XmlToken.IsExpanded, isExpanded.ToString(CultureInfo.InvariantCulture));
}
if ((token & XmlToken.Height) != (XmlToken)0)
{
double num = (double)snc.GetValue(FrameworkElement.HeightProperty);
sncAnnotation.UpdateAttribute(xmlElement, XmlToken.Height, num.ToString(CultureInfo.InvariantCulture));
}
if ((token & XmlToken.Width) != (XmlToken)0)
{
double num2 = (double)snc.GetValue(FrameworkElement.WidthProperty);
sncAnnotation.UpdateAttribute(xmlElement, XmlToken.Width, num2.ToString(CultureInfo.InvariantCulture));
}
if ((token & XmlToken.Left) != (XmlToken)0)
{
double num3 = snc.PositionTransform.X;
if (snc.FlipBothOrigins)
{
num3 = -(num3 + snc.Width);
}
sncAnnotation.UpdateAttribute(xmlElement, XmlToken.Left, num3.ToString(CultureInfo.InvariantCulture));
}
if ((token & XmlToken.Top) != (XmlToken)0)
{
sncAnnotation.UpdateAttribute(xmlElement, XmlToken.Top, snc.PositionTransform.Y.ToString(CultureInfo.InvariantCulture));
}
if ((token & XmlToken.XOffset) != (XmlToken)0)
{
sncAnnotation.UpdateAttribute(xmlElement, XmlToken.XOffset, snc.XOffset.ToString(CultureInfo.InvariantCulture));
}
if ((token & XmlToken.YOffset) != (XmlToken)0)
{
sncAnnotation.UpdateAttribute(xmlElement, XmlToken.YOffset, snc.YOffset.ToString(CultureInfo.InvariantCulture));
}
if ((token & XmlToken.ZOrder) != (XmlToken)0)
{
sncAnnotation.UpdateAttribute(xmlElement, XmlToken.ZOrder, ((IAnnotationComponent)snc).ZOrder.ToString(CultureInfo.InvariantCulture));
}
if (flag2)
{
annotationResource.Contents.Add(xmlElement);
}
if (flag)
{
sncAnnotation._annotation.Cargos.Add(annotationResource);
}
}
public override void GetToken(int attNum, out QName name, out string value)
{
Debug.Assert(0 <= attNum && attNum < ReadEndPos - ReadStartPos - 1);
XmlNodeType nodeType;
XmlToken.Get(ref Buffer[(ReadStartPos + attNum) & Mask], out nodeType, out name, out value);
Debug.Assert(nodeType == (attNum == 0 ? XmlNodeType.Element : XmlNodeType.Attribute),
"We use GetToken() only to access parts of start element tag.");
}
private TreeElement ParseIdentifier()
{
if (lexer.TokenType != CSharpTokenType.IDENTIFIER)
{
throw new UnexpectedToken("Expected identifier");
}
TreeElement result = new XmlToken(L4NTokenNodeType.IDENTIFIER, lexer.Buffer, lexer.TokenStart, lexer.TokenEnd);
lexer.Advance();
return result;
}
DtdToken Rework(XmlToken xmlToken)
{
if (xmlToken is XmlPIToken)
return new DtdPIToken((XmlPIToken)xmlToken);
else if (xmlToken is XmlCommentToken)
return new DtdCommentToken((XmlCommentToken)xmlToken);
else if (xmlToken is XmlEndOfFileToken)
return DtdToken.EOF;
throw new ArgumentException("The received token is not valid for a DTD.");
}
public virtual void Write(XmlNodeType nodeType, QName name, string value)
{
Debug.Assert(WritePos <= Buffer.Length);
if (WritePos == Buffer.Length)
{
var temp = new XmlToken[Buffer.Length * 2];
Buffer.CopyTo(temp, 0);
Buffer = temp;
}
Debug.Assert(WritePos < Buffer.Length);
XmlToken.Set(ref Buffer[WritePos], nodeType, name, value);
WritePos++;
}
// Token: 0x06007860 RID: 30816 RVA: 0x00224AE8 File Offset: 0x00222CE8
private static XmlElement FindRootXmlElement(XmlToken token, AnnotationResource cargo)
{
XmlElement result = null;
string value = string.Empty;
if (token <= XmlToken.YOffset)
{
if (token <= XmlToken.Left)
{
if (token != XmlToken.MetaData && token != XmlToken.Left)
{
goto IL_77;
}
}
else if (token != XmlToken.Top && token != XmlToken.XOffset && token != XmlToken.YOffset)
{
goto IL_77;
}
}
else if (token <= XmlToken.IsExpanded)
{
if (token != XmlToken.Width && token != XmlToken.Height && token != XmlToken.IsExpanded)
{
goto IL_77;
}
}
else
{
if (token == XmlToken.Text || token == XmlToken.Ink)
{
value = SNCAnnotation.GetXmlName(token);
goto IL_77;
}
if (token != XmlToken.ZOrder)
{
goto IL_77;
}
}
value = SNCAnnotation.GetXmlName(XmlToken.MetaData);
IL_77:
foreach (XmlElement xmlElement in cargo.Contents)
{
if (xmlElement.Name.Equals(value))
{
result = xmlElement;
break;
}
}
return(result);
}
protected override Action <ITextControl> ExecutePsiTransaction(ISolution solution, IProgressIndicator progress)
{
if (!Highlighting.IsValid())
{
return(null);
}
var node = Highlighting.Node;
var badWordTextRange = Highlighting.Range.TextRange;
var newText = StringUtil.ReplaceSection(
node.GetText(),
Suggestion,
badWordTextRange.StartOffset - node.GetDocumentRange().TextRange.StartOffset,
badWordTextRange.Length
);
if (node is XmlValueToken)
{
var newElm = new XmlValueToken(
(node as XmlValueToken).GetTokenType(),
new StringBuffer(newText),
new TreeOffset(0),
new TreeOffset(newText.Length)
);
ModificationUtil.ReplaceChild(node, newElm);
return(null);
}
if (node is XmlFloatingTextToken)
{
var newElm = new XmlFloatingTextToken(
(node as XmlFloatingTextToken).GetTokenType(),
newText
);
ModificationUtil.ReplaceChild(node, newElm);
return(null);
}
if (node is XmlToken)
{
var newElm = new XmlToken(
(node as XmlToken).GetTokenType(),
new StringBuffer(newText),
new TreeOffset(0),
new TreeOffset(newText.Length)
);
ModificationUtil.ReplaceChild(node, newElm);
return(null);
}
return(null);
}
static Color ColorForToken(XmlToken token, string tokenText)
{
Color color = Color.FromRgb(0, 0, 0);
switch (token.Kind)
{
case XmlTokenKind.Open:
case XmlTokenKind.OpenClose:
case XmlTokenKind.Close:
case XmlTokenKind.SelfClose:
case XmlTokenKind.CommentBegin:
case XmlTokenKind.CommentEnd:
case XmlTokenKind.CDataBegin:
case XmlTokenKind.CDataEnd:
case XmlTokenKind.Equals:
case XmlTokenKind.OpenProcessingInstruction:
case XmlTokenKind.CloseProcessingInstruction:
case XmlTokenKind.AttributeValue:
color = Color.FromRgb(0, 0, 255);
// color = "blue";
break;
case XmlTokenKind.ElementName:
color = Color.FromRgb(163, 21, 21);
// color = "brown";
break;
case XmlTokenKind.TextContent:
// color = "black";
break;
case XmlTokenKind.AttributeName:
case XmlTokenKind.Entity:
color = Color.FromRgb(255, 0, 0);
// color = "red";
break;
case XmlTokenKind.CommentText:
color = Color.FromRgb(0, 128, 0);
// color = "green";
break;
}
if (token.Kind == XmlTokenKind.ElementWhitespace ||
(token.Kind == XmlTokenKind.TextContent && tokenText.Trim() == ""))
{
// color = null;
}
return(color);
}
// Token: 0x0600785E RID: 30814 RVA: 0x002249BC File Offset: 0x00222BBC
private static void AddXmlTokenNames(XmlToken token)
{
string text = token.ToString();
if (token <= XmlToken.YOffset)
{
if (token <= XmlToken.Left)
{
if (token != XmlToken.MetaData)
{
if (token != XmlToken.Left)
{
goto IL_84;
}
goto IL_84;
}
}
else
{
if (token != XmlToken.Top && token != XmlToken.XOffset && token != XmlToken.YOffset)
{
goto IL_84;
}
goto IL_84;
}
}
else if (token <= XmlToken.IsExpanded)
{
if (token != XmlToken.Width && token != XmlToken.Height && token != XmlToken.IsExpanded)
{
goto IL_84;
}
goto IL_84;
}
else if (token != XmlToken.Text && token != XmlToken.Ink)
{
if (token != XmlToken.ZOrder)
{
goto IL_84;
}
goto IL_84;
}
SNCAnnotation.s_xmlTokeFullNames.Add(token, "anb:" + text);
return;
IL_84:
SNCAnnotation.s_xmlTokeFullNames.Add(token, text);
}
private void ExpandBuffer()
{
// Buffer is too smal for this amount of attributes.
Debug.Assert(WritePos == ReadStartPos + Buffer.Length, "no space to write next token");
Debug.Assert(WritePos == ReadEndPos, "all tokens ware read");
var newMask = (Mask << 1) | 1;
var newBuffer = new XmlToken[newMask + 1];
for (var i = ReadStartPos; i < WritePos; i++)
{
newBuffer[i & newMask] = Buffer[i & Mask];
}
Buffer = newBuffer;
Mask = newMask;
Debug.Assert(WritePos < ReadStartPos + Buffer.Length, "we should have now space to next write token");
}
// Token: 0x06007861 RID: 30817 RVA: 0x00224BB8 File Offset: 0x00222DB8
private static object FindContent(XmlToken token, AnnotationResource cargo)
{
object result = null;
XmlElement xmlElement = SNCAnnotation.FindRootXmlElement(token, cargo);
if (xmlElement != null)
{
if (token <= XmlToken.Width)
{
if (token <= XmlToken.Top)
{
if (token != XmlToken.Left && token != XmlToken.Top)
{
return(result);
}
}
else if (token != XmlToken.XOffset && token != XmlToken.YOffset && token != XmlToken.Width)
{
return(result);
}
}
else if (token <= XmlToken.IsExpanded)
{
if (token != XmlToken.Height && token != XmlToken.IsExpanded)
{
return(result);
}
}
else
{
if (token == XmlToken.Text || token == XmlToken.Ink)
{
return(xmlElement);
}
if (token != XmlToken.ZOrder)
{
return(result);
}
}
return(xmlElement.GetAttributeNode(SNCAnnotation.GetXmlName(token), "http://schemas.microsoft.com/windows/annotations/2003/11/base"));
}
return(result);
}
// Token: 0x0600785F RID: 30815 RVA: 0x00224A5C File Offset: 0x00222C5C
private static string GetCargoName(XmlToken token)
{
if (token <= XmlToken.YOffset)
{
if (token <= XmlToken.Left)
{
if (token != XmlToken.MetaData && token != XmlToken.Left)
{
goto IL_75;
}
}
else if (token != XmlToken.Top && token != XmlToken.XOffset && token != XmlToken.YOffset)
{
goto IL_75;
}
}
else if (token <= XmlToken.IsExpanded)
{
if (token != XmlToken.Width && token != XmlToken.Height && token != XmlToken.IsExpanded)
{
goto IL_75;
}
}
else
{
if (token == XmlToken.Text)
{
return("Text Data");
}
if (token == XmlToken.Ink)
{
return("Ink Data");
}
if (token != XmlToken.ZOrder)
{
goto IL_75;
}
}
return("Meta Data");
IL_75:
return(string.Empty);
}
// Token: 0x0600785A RID: 30810 RVA: 0x00224848 File Offset: 0x00222A48
private object FindData(XmlToken token)
{
object obj = null;
if (this._cachedXmlElements.ContainsKey(token))
{
obj = this._cachedXmlElements[token];
}
else
{
AnnotationResource annotationResource = this.FindCargo(SNCAnnotation.GetCargoName(token));
if (annotationResource != null)
{
obj = SNCAnnotation.FindContent(token, annotationResource);
if (obj != null)
{
this._cachedXmlElements.Add(token, obj);
}
}
}
return(obj);
}
/// <summary>
/// In the body state - no doctypes and declarations allowed.
/// </summary>
/// <param name="token">The consumed token.</param>
private void InMisc(XmlToken token)
{
switch (token.Type)
{
case XmlTokenType.Comment:
{
var commenToken = (XmlCommentToken)token;
var commentNode = _document.CreateComment(commenToken.Data);
CurrentNode.AppendChild(commentNode);
break;
}
case XmlTokenType.ProcessingInstruction:
{
var piToken = (XmlPIToken)token;
var piNode = _document.CreateProcessingInstruction(piToken.Target, piToken.Content);
CurrentNode.AppendChild(piNode);
break;
}
case XmlTokenType.StartTag:
{
_currentMode = XmlTreeMode.Body;
InBody(token);
break;
}
default:
{
if (!token.IsIgnorable && !_options.IsSuppressingErrors)
{
throw XmlParseError.XmlMissingRoot.At(token.Position);
}
break;
}
}
}
public override void Read(out XmlNodeType nodeType, out QName name, out string value)
{
lock (this)
{
Debug.Assert(ReadEndPos <= WritePos && WritePos <= ReadStartPos + Buffer.Length);
if (ReadEndPos == WritePos)
{
if (ReadEndPos == ReadStartPos + Buffer.Length)
{
ExpandBuffer();
Monitor.Pulse(this);
}
Monitor.Wait(this);
}
if (_exception != null)
{
throw new XsltException("Exception happened during transformation. See inner exception for details:\n", _exception);
}
}
Debug.Assert(ReadEndPos < WritePos);
XmlToken.Get(ref Buffer[ReadEndPos & Mask], out nodeType, out name, out value);
ReadEndPos++;
}
/// <summary>
/// The initial state. Expects an XML declaration.
/// </summary>
/// <param name="token">The consumed token.</param>
private void Initial(XmlToken token)
{
if (token.Type == XmlTokenType.Declaration)
{
var declarationToken = (XmlDeclarationToken)token;
_standalone = declarationToken.Standalone;
if (!declarationToken.IsEncodingMissing)
{
SetEncoding(declarationToken.Encoding);
}
if (!CheckVersion(declarationToken.Version) && !_options.IsSuppressingErrors)
{
throw XmlParseError.XmlDeclarationVersionUnsupported.At(token.Position);
}
}
else
{
_currentMode = XmlTreeMode.Prolog;
BeforeDoctype(token);
}
}
/// <summary>
/// After the body state - nothing except Comment PI S allowed.
/// </summary>
/// <param name="token">The consumed token.</param>
void AfterBody(XmlToken token)
{
switch (token.Type)
{
case XmlTokenType.ProcessingInstruction:
case XmlTokenType.Comment:
{
InMisc(token);
break;
}
case XmlTokenType.EndOfFile:
{
break;
}
default:
{
if (!token.IsIgnorable && !_options.IsSuppressingErrors)
{
throw XmlParseError.XmlMissingRoot.At(token.Position);
}
break;
}
}
}
/// <summary>
/// In the body state - no doctypes and declarations allowed.
/// </summary>
/// <param name="token">The consumed token.</param>
void InBody(XmlToken token)
{
switch (token.Type)
{
case XmlTokenType.StartTag:
{
var tagToken = (XmlTagToken)token;
var element = new XmlElement(_document, tagToken.Name);
CurrentNode.AppendChild(element);
if (!tagToken.IsSelfClosing)
{
_openElements.Add(element);
}
else if (_openElements.Count == 0)
{
_currentMode = XmlTreeMode.After;
}
for (var i = 0; i < tagToken.Attributes.Count; i++)
{
var name = tagToken.Attributes[i].Key;
var value = tagToken.Attributes[i].Value.Trim();
element.SetAttribute(name, value);
}
break;
}
case XmlTokenType.EndTag:
{
var tagToken = (XmlTagToken)token;
if (!CurrentNode.NodeName.Is(tagToken.Name))
{
if (_options.IsSuppressingErrors)
{
break;
}
throw XmlParseError.TagClosingMismatch.At(token.Position);
}
_openElements.RemoveAt(_openElements.Count - 1);
if (_openElements.Count == 0)
{
_currentMode = XmlTreeMode.After;
}
break;
}
case XmlTokenType.ProcessingInstruction:
case XmlTokenType.Comment:
{
InMisc(token);
break;
}
case XmlTokenType.CData:
{
var cdataToken = (XmlCDataToken)token;
CurrentNode.AppendText(cdataToken.Data);
break;
}
case XmlTokenType.Character:
{
var charToken = (XmlCharacterToken)token;
CurrentNode.AppendText(charToken.Data);
break;
}
case XmlTokenType.EndOfFile:
{
if (_options.IsSuppressingErrors)
{
break;
}
throw XmlParseError.EOF.At(token.Position);
}
case XmlTokenType.Doctype:
{
if (_options.IsSuppressingErrors)
{
break;
}
throw XmlParseError.XmlDoctypeAfterContent.At(token.Position);
}
case XmlTokenType.Declaration:
{
if (_options.IsSuppressingErrors)
{
break;
}
throw XmlParseError.XmlDeclarationMisplaced.At(token.Position);
}
}
}
/// <summary>
/// In the body state - no doctypes and declarations allowed.
/// </summary>
/// <param name="token">The consumed token.</param>
void InMisc(XmlToken token)
{
switch (token.Type)
{
case XmlTokenType.Comment:
{
var commenToken = (XmlCommentToken)token;
var commentNode = _document.CreateComment(commenToken.Data);
CurrentNode.AppendChild(commentNode);
break;
}
case XmlTokenType.ProcessingInstruction:
{
var piToken = (XmlPIToken)token;
var piNode = _document.CreateProcessingInstruction(piToken.Target, piToken.Content);
CurrentNode.AppendChild(piNode);
break;
}
case XmlTokenType.StartTag:
{
_currentMode = XmlTreeMode.Body;
InBody(token);
break;
}
default:
{
if (!token.IsIgnorable && !_options.IsSuppressingErrors)
{
throw XmlParseError.XmlMissingRoot.At(token.Position);
}
break;
}
}
}
/// <summary>
/// Before any doctype - still in the prolog. No declaration
/// allowed.
/// </summary>
/// <param name="token">The consumed token.</param>
void BeforeDoctype(XmlToken token)
{
switch (token.Type)
{
case XmlTokenType.Doctype:
{
var doctypeToken = (XmlDoctypeToken)token;
var doctypeNode = new DocumentType(_document, doctypeToken.Name)
{
SystemIdentifier = doctypeToken.SystemIdentifier,
PublicIdentifier = doctypeToken.PublicIdentifier
};
_document.AppendChild(doctypeNode);
_currentMode = XmlTreeMode.Misc;
break;
}
default:
{
InMisc(token);
break;
}
}
}
//------------------------
public bool Read()
{
Token = XmlToken.None;
Value = null;
int buffer_char = 0;
int buffer_peek = 0;
while (true)
{
buffer_char = text_read();
if (buffer_char < 0)
{
Token = XmlToken.End;
return true;
}
if (buffer_char == '<')
{
buffer_peek = text_peek();
if (buffer_peek == '/')
{
Token = XmlToken.TargetEnd;
ReadName();
return true;
}
else if (buffer_peek == '!')
{
text_read();
buffer_peek = text_peek();
if (buffer_peek == '-')//<!-- 注释
text_jump('>');
else //<![CDATA[
{
text_jump(6);
Token = XmlToken.CDATA;
ReadCDATA();
return true;
}
}
else if (buffer_peek == '?')
text_jump('>');
else
{
Token = XmlToken.TargetStart;
ReadName();
return true;
}
}
else
{
if (Token == XmlToken.None && buffer_char > 32)
{
Token = XmlToken.Value;
ReadValue();
return true;
}
}
}
}
/// <summary>
/// Iterate over characters one by one to tokenize the Xml string.
/// </summary>
/// <param name="str"></param>
/// <returns></returns>
private static List <XmlToken> LoopTokenize(string str)
{
// Temp variables to build up the current token
List <char> currentTokenText = new List <char>();
// Represents the list of tokens to be returned
List <XmlToken> tokens = new List <XmlToken>();
// Represents the index of the first character in the token
int tokenIndex = 0;
bool isStartTag = false;
bool isComment = false;
bool isQuote = false;
bool isAttribute = false;
for (int i = 0; i < str.Length; i++)
{
// Get the current character
char c = str[i];
// Skip the "ZERO WIDTH NO-BREAK SPACE" character resulting from encoding
if (c == 65279)
{
continue;
}
// Handle the escape sequence case
if (c == '&')
{
if (currentTokenText.Count > 0)
{
XmlToken token = new XmlToken();
token.Index = tokenIndex;
token.Text = new string(currentTokenText.ToArray());
tokens.Add(token);
currentTokenText.Clear();
// Determine token type
if (isQuote)
{
token.Type = XmlTokenType.Value;
}
else if (isComment)
{
token.Type = XmlTokenType.Comment;
}
else if (isStartTag)
{
if (isAttribute)
{
token.Type = XmlTokenType.Attribute;
}
else
{
token.Type = XmlTokenType.Element;
}
}
else
{
token.Type = XmlTokenType.None;
}
}
currentTokenText.Add('&');
XmlToken escapeToken = new XmlToken();
escapeToken.Type = XmlTokenType.Escape;
escapeToken.Index = i;
i++;
while (i < str.Length && char.IsLetterOrDigit(str[i]))
{
currentTokenText.Add(str[i]);
i++;
}
if (i < str.Length && c == ';')
{
currentTokenText.Add(';');
i++;
}
escapeToken.Text = new string(currentTokenText.ToArray());
currentTokenText.Clear();
tokens.Add(escapeToken);
continue;
}
// Only if the character is not between "" that is in a tag
if (!isQuote)
{
// Only if the character is not in a comment
if (!isComment)
{
// Only if we already have a start tag
if (isStartTag)
{
if (char.IsLetterOrDigit(c))
{
// We're starting to build up a token, so save its index
if (currentTokenText.Count == 0)
{
tokenIndex = i;
}
currentTokenText.Add(c);
}
else
{
// Add the previous token that could be an element or an attribute
if (currentTokenText.Count > 0)
{
XmlToken token = new XmlToken();
token.Text = new string(currentTokenText.ToArray());
currentTokenText.Clear();
token.Index = tokenIndex;
if (isAttribute)
{
token.Type = XmlTokenType.Attribute;
}
else
{
token.Type = XmlTokenType.Element;
}
tokens.Add(token);
}
// Check if we have something like <!-- to flag that we have a comment
if (c == '-')
{
if (i - 2 >= 0 && i + 1 < str.Length)
{
if (str[i - 2] == '<' && str[i - 1] == '!' && str[i + 1] == '-')
{
isStartTag = false;
isComment = true;
i += 1;
}
}
}
// Check if our start tag is now closed
else if (c == '>')
{
isStartTag = false;
isAttribute = false;
}
// We hit another start tag
else if (c == '<')
{
isAttribute = false;
}
// We're starting a quote
else if (c == '"')
{
isQuote = true;
}
// Check if we now have an attribute
if (char.IsWhiteSpace(c))
{
isAttribute = true;
}
else
{
tokens.Add(new XmlToken(c.ToString(), i, XmlTokenType.SpecialChar));
}
}
}
// If we didn't have a start tag, check if we now have one
else
{
if (c == '<')
{
if (currentTokenText.Count > 0)
{
XmlToken token = new XmlToken();
token.Index = tokenIndex;
token.Text = new string(currentTokenText.ToArray());
token.Type = XmlTokenType.None;
tokens.Add(token);
currentTokenText.Clear();
}
isStartTag = true;
tokens.Add(new XmlToken("<", i, XmlTokenType.SpecialChar));
}
else
{
if (currentTokenText.Count == 0)
{
tokenIndex = i;
}
currentTokenText.Add(c);
}
}
}
// In case we have a comment
else
{
// We're starting to build up a token, so save its index
if (currentTokenText.Count == 0)
{
tokenIndex = i;
}
currentTokenText.Add(c);
// Check if we have something like --> to see if we're closing a comment
// or if we're at the end
if (i + 2 < str.Length)
{
if (c == '-')
{
if (str[i + 1] == '-' && str[i + 2] == '>')
{
isComment = false;
i += 2;
}
}
}
else
{
isComment = false;
}
if (!isComment)
{
XmlToken token = new XmlToken();
token.Type = XmlTokenType.Comment;
token.Index = tokenIndex;
token.Text = new string(currentTokenText.ToArray());
tokens.Add(token);
currentTokenText.Clear();
}
}
}
// In case we have a quote
else
{
// We're starting to build up a token, so save its index
if (currentTokenText.Count == 0)
{
tokenIndex = i;
}
// Check if we no longer have a quote
if (c == '"')
{
isQuote = false;
XmlToken token = new XmlToken();
token.Type = XmlTokenType.Value;
token.Index = tokenIndex;
token.Text = new string(currentTokenText.ToArray());
tokens.Add(token);
currentTokenText.Clear();
}
else
{
currentTokenText.Add(c);
}
}
}
// Handle the last element
if (currentTokenText.Count > 0)
{
XmlToken token = new XmlToken();
token.Index = tokenIndex;
token.Text = new string(currentTokenText.ToArray());
tokens.Add(token);
currentTokenText.Clear();
// Determine token type
if (isQuote)
{
token.Type = XmlTokenType.Value;
}
else if (isComment)
{
token.Type = XmlTokenType.Comment;
}
else if (isStartTag)
{
if (isAttribute)
{
token.Type = XmlTokenType.Attribute;
}
else
{
token.Type = XmlTokenType.Element;
}
}
else
{
token.Type = XmlTokenType.None;
}
}
return(tokens);
}
private IXmlAttributeValue ParseAttributeValueAspect(IXmlAttributeValue xmlAttributeValue, CompositeElement newAttributeValue, StringParse stringParse)
{
if (xmlAttributeValue == null) throw new ArgumentNullException("xmlAttributeValue");
if (newAttributeValue == null) throw new ArgumentNullException("newAttributeValue");
if (stringParse == null) throw new ArgumentNullException("stringParse");
CompositeElement result = null;
string rawValue = xmlAttributeValue.UnquotedValue;
try
{
result = stringParse(rawValue);
}
catch (SyntaxError syntaxError)
{
result = (CompositeElement)syntaxError.ParsingResult;
result = handleError(result, syntaxError);
}
newAttributeValue.AddChild(new XmlToken(L4NTokenNodeType.QUOTE, new StringBuffer(new string('\"', 1)), 0, 1));
newAttributeValue.AddChild(result);
int resultLegth = result.GetText().Length;
if(resultLegth < rawValue.Length)
{
string suffix = rawValue.Substring(resultLegth);
StringBuffer sb = new StringBuffer(suffix);
XmlToken suffixToken = new XmlToken(L4NTokenNodeType.TEXT , sb, 0, suffix.Length);
newAttributeValue.AddChild(suffixToken);
}
newAttributeValue.AddChild(new XmlToken(L4NTokenNodeType.QUOTE, new StringBuffer(new string('\"', 1)), 0, 1));
return (IXmlAttributeValue)newAttributeValue;
}
// Token: 0x06007862 RID: 30818 RVA: 0x00224C48 File Offset: 0x00222E48
private void UpdateContent(StickyNoteControl snc, bool updateAnnotation, XmlToken token)
{
Invariant.Assert(snc != null, "Sticky Note Control is null.");
Invariant.Assert((token & (XmlToken.Text | XmlToken.Ink)) > (XmlToken)0, "No token specified.");
StickyNoteContentControl content = snc.Content;
if (content == null)
{
return;
}
if ((token == XmlToken.Ink && content.Type != StickyNoteType.Ink) || (token == XmlToken.Text && content.Type != StickyNoteType.Text))
{
return;
}
XmlElement xmlElement = null;
if (updateAnnotation)
{
AnnotationResource annotationResource = null;
bool flag = false;
bool flag2 = false;
if (!content.IsEmpty)
{
SNCAnnotation.GetCargoAndRoot(this, token, out annotationResource, out xmlElement, out flag2, out flag);
content.Save(xmlElement);
}
else
{
string cargoName = SNCAnnotation.GetCargoName(token);
annotationResource = this.FindCargo(cargoName);
if (annotationResource != null)
{
this._annotation.Cargos.Remove(annotationResource);
this._cachedXmlElements.Remove(token);
}
}
if (flag)
{
Invariant.Assert(xmlElement != null, "XmlElement should have been created.");
Invariant.Assert(annotationResource != null, "Cargo should have been retrieved.");
annotationResource.Contents.Add(xmlElement);
}
if (flag2)
{
Invariant.Assert(annotationResource != null, "Cargo should have been created.");
this._annotation.Cargos.Add(annotationResource);
return;
}
}
else
{
XmlElement xmlElement2 = (XmlElement)this.FindData(token);
if (xmlElement2 != null)
{
content.Load(xmlElement2);
return;
}
if (!content.IsEmpty)
{
content.Clear();
}
}
}
/// <summary>
/// Iterate over characters one by one to tokenize the Xml string.
/// </summary>
/// <param name="str"></param>
/// <returns></returns>
private static List<XmlToken> LoopTokenize(string str)
{
// Temp variables to build up the current token
List<char> currentTokenText = new List<char>();
// Represents the list of tokens to be returned
List<XmlToken> tokens = new List<XmlToken>();
// Represents the index of the first character in the token
int tokenIndex = 0;
bool isStartTag = false;
bool isComment = false;
bool isQuote = false;
bool isAttribute = false;
for (int i = 0; i < str.Length; i++)
{
// Get the current character
char c = str[i];
// Skip the "ZERO WIDTH NO-BREAK SPACE" character resulting from encoding
if (c == 65279)
{
continue;
}
// Handle the escape sequence case
if (c == '&')
{
if (currentTokenText.Count > 0)
{
XmlToken token = new XmlToken();
token.Index = tokenIndex;
token.Text = new string(currentTokenText.ToArray());
tokens.Add(token);
currentTokenText.Clear();
// Determine token type
if (isQuote)
{
token.Type = XmlTokenType.Value;
}
else if (isComment)
{
token.Type = XmlTokenType.Comment;
}
else if (isStartTag)
{
if (isAttribute)
{
token.Type = XmlTokenType.Attribute;
}
else
{
token.Type = XmlTokenType.Element;
}
}
else
{
token.Type = XmlTokenType.None;
}
}
currentTokenText.Add('&');
XmlToken escapeToken = new XmlToken();
escapeToken.Type = XmlTokenType.Escape;
escapeToken.Index = i;
i++;
while (i < str.Length && char.IsLetterOrDigit(str[i]))
{
currentTokenText.Add(str[i]);
i++;
}
if (i < str.Length && c == ';')
{
currentTokenText.Add(';');
i++;
}
escapeToken.Text = new string(currentTokenText.ToArray());
currentTokenText.Clear();
tokens.Add(escapeToken);
continue;
}
// Only if the character is not between "" that is in a tag
if(!isQuote)
{
// Only if the character is not in a comment
if(!isComment)
{
// Only if we already have a start tag
if(isStartTag)
{
if (char.IsLetterOrDigit(c))
{
// We're starting to build up a token, so save its index
if (currentTokenText.Count == 0)
{
tokenIndex = i;
}
currentTokenText.Add(c);
}
else
{
// Add the previous token that could be an element or an attribute
if (currentTokenText.Count > 0)
{
XmlToken token = new XmlToken();
token.Text = new string(currentTokenText.ToArray());
currentTokenText.Clear();
token.Index = tokenIndex;
if (isAttribute)
{
token.Type = XmlTokenType.Attribute;
}
else
{
token.Type = XmlTokenType.Element;
}
tokens.Add(token);
}
// Check if we have something like <!-- to flag that we have a comment
if (c == '-')
{
if (i - 2 >= 0 && i + 1 < str.Length)
{
if (str[i - 2] == '<' && str[i - 1] == '!' && str[i + 1] == '-')
{
isStartTag = false;
isComment = true;
i += 1;
}
}
}
// Check if our start tag is now closed
else if (c == '>')
{
isStartTag = false;
isAttribute = false;
}
// We hit another start tag
else if (c == '<')
{
isAttribute = false;
}
// We're starting a quote
else if (c == '"')
{
isQuote = true;
}
// Check if we now have an attribute
if (char.IsWhiteSpace(c))
{
isAttribute = true;
}
else
{
tokens.Add(new XmlToken(c.ToString(), i, XmlTokenType.SpecialChar));
}
}
}
// If we didn't have a start tag, check if we now have one
else
{
if (c == '<')
{
if (currentTokenText.Count > 0)
{
XmlToken token = new XmlToken();
token.Index = tokenIndex;
token.Text = new string(currentTokenText.ToArray());
token.Type = XmlTokenType.None;
tokens.Add(token);
currentTokenText.Clear();
}
isStartTag = true;
tokens.Add(new XmlToken("<", i, XmlTokenType.SpecialChar));
}
else
{
if (currentTokenText.Count == 0)
{
tokenIndex = i;
}
currentTokenText.Add(c);
}
}
}
// In case we have a comment
else
{
// We're starting to build up a token, so save its index
if (currentTokenText.Count == 0)
{
tokenIndex = i;
}
currentTokenText.Add(c);
// Check if we have something like --> to see if we're closing a comment
// or if we're at the end
if (i + 2 < str.Length)
{
if (c == '-')
{
if (str[i + 1] == '-' && str[i + 2] == '>')
{
isComment = false;
i += 2;
}
}
}
else
{
isComment = false;
}
if (!isComment)
{
XmlToken token = new XmlToken();
token.Type = XmlTokenType.Comment;
token.Index = tokenIndex;
token.Text = new string(currentTokenText.ToArray());
tokens.Add(token);
currentTokenText.Clear();
}
}
}
// In case we have a quote
else
{
// We're starting to build up a token, so save its index
if (currentTokenText.Count == 0)
{
tokenIndex = i;
}
// Check if we no longer have a quote
if (c == '"')
{
isQuote = false;
XmlToken token = new XmlToken();
token.Type = XmlTokenType.Value;
token.Index = tokenIndex;
token.Text = new string(currentTokenText.ToArray());
tokens.Add(token);
currentTokenText.Clear();
}
else
{
currentTokenText.Add(c);
}
}
}
// Handle the last element
if (currentTokenText.Count > 0)
{
XmlToken token = new XmlToken();
token.Index = tokenIndex;
token.Text = new string(currentTokenText.ToArray());
tokens.Add(token);
currentTokenText.Clear();
// Determine token type
if (isQuote)
{
token.Type = XmlTokenType.Value;
}
else if (isComment)
{
token.Type = XmlTokenType.Comment;
}
else if (isStartTag)
{
if (isAttribute)
{
token.Type = XmlTokenType.Attribute;
}
else
{
token.Type = XmlTokenType.Element;
}
}
else
{
token.Type = XmlTokenType.None;
}
}
return tokens;
}
private ReferenceTable CreateReferenceTable(XmlToken token)
{
ReferenceTable referenceTable = new ReferenceTable();
referenceTable.AppendNewChild(token);
return referenceTable;
}
/// <summary>
/// In the body state - no doctypes and declarations allowed.
/// </summary>
/// <param name="token">The consumed token.</param>
private void InBody(XmlToken token)
{
switch (token.Type)
{
case XmlTokenType.StartTag:
{
var tagToken = (XmlTagToken)token;
var element = CreateElement(tagToken.Name);
CurrentNode.AppendChild(element);
for (var i = 0; i < tagToken.Attributes.Count; i++)
{
var attr = tagToken.Attributes[i];
var item = CreateAttribute(attr.Key, attr.Value.Trim());
element.Attributes.FastAddItem(item);
}
if (!tagToken.IsSelfClosing)
{
_openElements.Add(element);
}
else if (_openElements.Count == 0)
{
_currentMode = XmlTreeMode.After;
}
if (_options.OnCreated != null)
{
_options.OnCreated.Invoke(element, tagToken.Position);
}
break;
}
case XmlTokenType.EndTag:
{
var tagToken = (XmlTagToken)token;
if (!CurrentNode.NodeName.Is(tagToken.Name))
{
if (_options.IsSuppressingErrors)
{
break;
}
throw XmlParseError.TagClosingMismatch.At(token.Position);
}
_openElements.RemoveAt(_openElements.Count - 1);
if (_openElements.Count == 0)
{
_currentMode = XmlTreeMode.After;
}
break;
}
case XmlTokenType.ProcessingInstruction:
case XmlTokenType.Comment:
{
InMisc(token);
break;
}
case XmlTokenType.CData:
{
var cdataToken = (XmlCDataToken)token;
CurrentNode.AppendText(cdataToken.Data);
break;
}
case XmlTokenType.Character:
{
var charToken = (XmlCharacterToken)token;
CurrentNode.AppendText(charToken.Data);
break;
}
case XmlTokenType.EndOfFile:
{
if (_options.IsSuppressingErrors)
{
break;
}
throw XmlParseError.EOF.At(token.Position);
}
case XmlTokenType.Doctype:
{
if (_options.IsSuppressingErrors)
{
break;
}
throw XmlParseError.XmlDoctypeAfterContent.At(token.Position);
}
case XmlTokenType.Declaration:
{
if (_options.IsSuppressingErrors)
{
break;
}
throw XmlParseError.XmlDeclarationMisplaced.At(token.Position);
}
}
}
// Token: 0x06007855 RID: 30805 RVA: 0x002244C0 File Offset: 0x002226C0
public static void UpdateStickyNoteControl(XmlToken token, StickyNoteControl snc, SNCAnnotation sncAnnotation)
{
Invariant.Assert((token & (XmlToken.Left | XmlToken.Top | XmlToken.XOffset | XmlToken.YOffset | XmlToken.Width | XmlToken.Height | XmlToken.IsExpanded | XmlToken.Author | XmlToken.Text | XmlToken.Ink | XmlToken.ZOrder)) > (XmlToken)0, "No token specified.");
Invariant.Assert(snc != null, "Sticky Note Control is null.");
Invariant.Assert(sncAnnotation != null, "Annotation is null.");
if ((token & XmlToken.Ink) != (XmlToken)0 && sncAnnotation.HasInkData)
{
sncAnnotation.UpdateContent(snc, false, XmlToken.Ink);
}
if ((token & XmlToken.Text) != (XmlToken)0 && sncAnnotation.HasTextData)
{
sncAnnotation.UpdateContent(snc, false, XmlToken.Text);
}
if ((token & XmlToken.Author) != (XmlToken)0)
{
int count = sncAnnotation._annotation.Authors.Count;
string listSeparator = snc.Language.GetSpecificCulture().TextInfo.ListSeparator;
string text = string.Empty;
for (int i = 0; i < count; i++)
{
if (i != 0)
{
text = text + listSeparator + sncAnnotation._annotation.Authors[i];
}
else
{
text += sncAnnotation._annotation.Authors[i];
}
}
snc.SetValue(StickyNoteControl.AuthorPropertyKey, text);
}
if ((token & XmlToken.Height) != (XmlToken)0)
{
XmlAttribute xmlAttribute = (XmlAttribute)sncAnnotation.FindData(XmlToken.Height);
if (xmlAttribute != null)
{
double num = Convert.ToDouble(xmlAttribute.Value, CultureInfo.InvariantCulture);
snc.SetValue(FrameworkElement.HeightProperty, num);
}
else
{
snc.ClearValue(FrameworkElement.HeightProperty);
}
}
if ((token & XmlToken.Width) != (XmlToken)0)
{
XmlAttribute xmlAttribute = (XmlAttribute)sncAnnotation.FindData(XmlToken.Width);
if (xmlAttribute != null)
{
double num2 = Convert.ToDouble(xmlAttribute.Value, CultureInfo.InvariantCulture);
snc.SetValue(FrameworkElement.WidthProperty, num2);
}
else
{
snc.ClearValue(FrameworkElement.WidthProperty);
}
}
if ((token & XmlToken.IsExpanded) != (XmlToken)0)
{
XmlAttribute xmlAttribute = (XmlAttribute)sncAnnotation.FindData(XmlToken.IsExpanded);
if (xmlAttribute != null)
{
bool isExpanded = Convert.ToBoolean(xmlAttribute.Value, CultureInfo.InvariantCulture);
snc.IsExpanded = isExpanded;
}
else
{
snc.ClearValue(StickyNoteControl.IsExpandedProperty);
}
}
if ((token & XmlToken.ZOrder) != (XmlToken)0)
{
XmlAttribute xmlAttribute = (XmlAttribute)sncAnnotation.FindData(XmlToken.ZOrder);
if (xmlAttribute != null)
{
((IAnnotationComponent)snc).ZOrder = Convert.ToInt32(xmlAttribute.Value, CultureInfo.InvariantCulture);
}
}
if ((token & (XmlToken.Left | XmlToken.Top | XmlToken.XOffset | XmlToken.YOffset)) != (XmlToken)0)
{
TranslateTransform translateTransform = new TranslateTransform();
if ((token & XmlToken.Left) != (XmlToken)0)
{
XmlAttribute xmlAttribute = (XmlAttribute)sncAnnotation.FindData(XmlToken.Left);
if (xmlAttribute != null)
{
double num3 = Convert.ToDouble(xmlAttribute.Value, CultureInfo.InvariantCulture);
if (snc.FlipBothOrigins)
{
num3 = -(num3 + snc.Width);
}
translateTransform.X = num3;
}
}
if ((token & XmlToken.Top) != (XmlToken)0)
{
XmlAttribute xmlAttribute = (XmlAttribute)sncAnnotation.FindData(XmlToken.Top);
if (xmlAttribute != null)
{
double y = Convert.ToDouble(xmlAttribute.Value, CultureInfo.InvariantCulture);
translateTransform.Y = y;
}
}
if ((token & XmlToken.XOffset) != (XmlToken)0)
{
XmlAttribute xmlAttribute = (XmlAttribute)sncAnnotation.FindData(XmlToken.XOffset);
if (xmlAttribute != null)
{
snc.XOffset = Convert.ToDouble(xmlAttribute.Value, CultureInfo.InvariantCulture);
}
}
if ((token & XmlToken.YOffset) != (XmlToken)0)
{
XmlAttribute xmlAttribute = (XmlAttribute)sncAnnotation.FindData(XmlToken.YOffset);
if (xmlAttribute != null)
{
snc.YOffset = Convert.ToDouble(xmlAttribute.Value, CultureInfo.InvariantCulture);
}
}
snc.PositionTransform = translateTransform;
}
}
public static void Set(ref XmlToken evnt, XmlNodeType nodeType, QName name, string value)
{
evnt._nodeType = nodeType;
evnt._name = name;
evnt._value = value;
}
protected virtual ReferenceModule CreateReferenceModule(XmlToken token)
{
ReferenceModule referenceModule = new ReferenceModule();
referenceModule.AppendNewChild(token);
return referenceModule;
}
///<summary>
///
/// Bind this reference to given Declared Element. May insert using directive.
///
///</summary>
///
///<returns>
///new "this"
///</returns>
///
public IReference BindTo(IDeclaredElement element)
{
using(WriteLockCookie cookie = WriteLockCookie.Create())
{
XmlToken token = NameToken;
Assert.CheckNotNull(token);
StringBuffer buffer = new StringBuffer(element.ShortName);
XmlToken newToken = new XmlToken(token.GetTokenType(), buffer, 0, buffer.Length);
LowLevelModificationUtil.ReplaceChildRange(token, token, new ITreeNode[] { newToken });
ResetReferences();
}
return this;
}
private XmlToken CreateModuleNameToken(int start, int end, bool unexpectedToken)
{
if(start == 0 && end == 0)
throw new UnexpectedToken("Unexpected token");
XmlToken ret = new XmlToken(L4NTokenNodeType.IDENTIFIER, lexer.Buffer, start, end);
if(unexpectedToken)
{
UnexpectedToken ex = new UnexpectedToken("Unexpected token");
ex.ParsingResult = ret;
throw ex;
}
return ret;
}
/// <summary>
/// Consumes a token and processes it.
/// </summary>
/// <param name="token">The token to consume.</param>
void Consume(XmlToken token)
{
switch (_currentMode)
{
case XmlTreeMode.Initial:
Initial(token);
break;
case XmlTreeMode.Prolog:
BeforeDoctype(token);
break;
case XmlTreeMode.Misc:
InMisc(token);
break;
case XmlTreeMode.Body:
InBody(token);
break;
case XmlTreeMode.After:
AfterBody(token);
break;
}
}
private TreeElement ParseReferenceNameInternal(TreeElement qualifier)
{
CompositeElement result = null;
TreeElement tempParsingResult = null;
try
{
result = CreateReferenceName();
tempParsingResult = qualifier;
result.AppendNewChild(tempParsingResult);
TokenNodeType tokenType = lexer.TokenType;
if (tokenType == CSharpTokenType.DOT)
{
tokenType = lexer.TokenType;
if (tokenType == CSharpTokenType.DOT)
{
tempParsingResult =
new XmlToken(L4NTokenNodeType.DOT, lexer.Buffer, lexer.TokenStart, lexer.TokenEnd);
lexer.Advance();
result.AppendNewChild(tempParsingResult);
}
else
{
if (result.firstChild == null)
{
result = null;
}
throw new UnexpectedToken("Unexpected token");
}
tempParsingResult = this.ParseIdentifier();
result.AppendNewChild(tempParsingResult);
}
}
catch (SyntaxError e)
{
if (((qualifier != null) && (qualifier.Parent == null)) && (qualifier != null))
{
result.AppendNewChild(qualifier);
}
if ((e.ParsingResult != null) && (result != null))
{
result.AppendNewChild(e.ParsingResult);
}
if (result != null)
{
e.ParsingResult = result;
}
throw;
}
return result;
}
/// <summary>
/// The initial state. Expects an XML declaration.
/// </summary>
/// <param name="token">The consumed token.</param>
void Initial(XmlToken token)
{
if (token.Type == XmlTokenType.Declaration)
{
var declarationToken = (XmlDeclarationToken)token;
_standalone = declarationToken.Standalone;
if (!declarationToken.IsEncodingMissing)
{
SetEncoding(declarationToken.Encoding);
}
if (!CheckVersion(declarationToken.Version) && !_options.IsSuppressingErrors)
{
throw XmlParseError.XmlDeclarationVersionUnsupported.At(token.Position);
}
}
else
{
_currentMode = XmlTreeMode.Prolog;
BeforeDoctype(token);
}
}
// Token: 0x0600785D RID: 30813 RVA: 0x002249AF File Offset: 0x00222BAF
private static string GetXmlName(XmlToken token)
{
return(SNCAnnotation.s_xmlTokeFullNames[token]);
}
//------------------------
public bool Read()
{
Token = XmlToken.None;
Value = null;
int buffer_char = 0;
int buffer_peek = 0;
while (true)
{
buffer_char = text_read();
if (buffer_char < 0)
{
Token = XmlToken.End;
return(true);
}
if (buffer_char == '<')
{
buffer_peek = text_peek();
if (buffer_peek == '/')
{
Token = XmlToken.TargetEnd;
ReadName();
return(true);
}
else if (buffer_peek == '!')
{
text_read();
buffer_peek = text_peek();
if (buffer_peek == '-')//<!-- 注释
{
text_jump('>');
}
else //<
