// ---------------------------------------------------------------------
//
// internal Properties
//
// ---------------------------------------------------------------------
#region internal Properties
#endregion internal Properties
// ---------------------------------------------------------------------
//
// Private Methods
//
// ---------------------------------------------------------------------
#region Private Methods
// Helper for Parse method.
private XamlToRtfError ParseXTokStartElement(XamlToken xamlToken, ref string name)
{
XamlToRtfError xamlToRtfError = _xamlAttributes.Init(xamlToken.Text);
if (xamlToRtfError == XamlToRtfError.None)
{
xamlToRtfError = _xamlAttributes.GetTag(ref name);
if (xamlToRtfError == XamlToRtfError.None)
{
xamlToRtfError = _xamlContent.StartElement(string.Empty, name, name, _xamlAttributes);
if (xamlToRtfError == XamlToRtfError.None)
{
if (_xamlAttributes.IsEmpty)
{
xamlToRtfError = _xamlContent.EndElement(string.Empty, name, name);
}
else
{
xamlToRtfError = (XamlToRtfError)_xamlTagStack.Push(name);
}
}
}
}
return(xamlToRtfError);
}
// Token: 0x0600862F RID: 34351 RVA: 0x0024C1FC File Offset: 0x0024A3FC
XamlToRtfError IXamlAttributes.GetLength(ref int length)
{
XamlToRtfError result = XamlToRtfError.None;
if (this._xamlParsePoints.IsValid)
{
length = (this._xamlParsePoints.Count - 1) / 2;
return(result);
}
return(XamlToRtfError.Unknown);
}
// Token: 0x0600862E RID: 34350 RVA: 0x0024C1C8 File Offset: 0x0024A3C8
internal XamlToRtfError GetTag(ref string xamlTag)
{
XamlToRtfError result = XamlToRtfError.None;
if (!this._xamlParsePoints.IsValid)
{
return(XamlToRtfError.Unknown);
}
xamlTag = (string)this._xamlParsePoints[0];
return(result);
}
// Token: 0x06008638 RID: 34360 RVA: 0x0024C2F8 File Offset: 0x0024A4F8
XamlToRtfError IXamlAttributes.GetValue(int index, ref string valueName)
{
XamlToRtfError result = XamlToRtfError.None;
int num = (this._xamlParsePoints.Count - 1) / 2;
if (index < 0 || index > num - 1)
{
return(XamlToRtfError.OutOfRange);
}
valueName = (string)this._xamlParsePoints[index * 2 + 2];
return(result);
}
internal XamlToRtfError GetTag(ref string xamlTag)
{
XamlToRtfError rtfToXamlError = XamlToRtfError.None;
if (!_xamlParsePoints.IsValid)
{
return(XamlToRtfError.Unknown);
}
xamlTag = (string)_xamlParsePoints[0];
return(rtfToXamlError);
}
// Token: 0x06008633 RID: 34355 RVA: 0x0024C25C File Offset: 0x0024A45C
XamlToRtfError IXamlAttributes.GetName(int index, ref string uri, ref string localName, ref string qName)
{
XamlToRtfError result = XamlToRtfError.None;
int num = (this._xamlParsePoints.Count - 1) / 2;
if (index < 0 || index > num - 1)
{
return(XamlToRtfError.Unknown);
}
localName = (string)this._xamlParsePoints[index * 2 + 1];
qName = (string)this._xamlParsePoints[index * 2 + 2];
return(result);
}
XamlToRtfError IXamlAttributes.GetLength(ref int length)
{
XamlToRtfError rtfToXamlError = XamlToRtfError.None;
if (_xamlParsePoints.IsValid)
{
length = (_xamlParsePoints.Count - 1) / 2;
return(rtfToXamlError);
}
else
{
return(XamlToRtfError.Unknown);
}
}
// Token: 0x06003F40 RID: 16192 RVA: 0x001212F8 File Offset: 0x0011F4F8
private XamlToRtfError ParseXTokEndElement(XamlToRtfParser.XamlToken xamlToken, ref string name)
{
XamlToRtfError xamlToRtfError = this._xamlAttributes.Init(xamlToken.Text);
if (xamlToRtfError == XamlToRtfError.None)
{
xamlToRtfError = this._xamlAttributes.GetTag(ref name);
if (xamlToRtfError == XamlToRtfError.None && this._xamlTagStack.IsMatchTop(name))
{
this._xamlTagStack.Pop();
xamlToRtfError = this._xamlContent.EndElement(string.Empty, name, name);
}
}
return(xamlToRtfError);
}
XamlToRtfError IXamlAttributes.GetValue(int index, ref string valueName)
{
XamlToRtfError rtfToXamlError = XamlToRtfError.None;
int nLength = (_xamlParsePoints.Count - 1) / 2;
if (index < 0 || index > nLength - 1)
{
return(XamlToRtfError.OutOfRange);
}
valueName = (string)_xamlParsePoints[index * 2 + 2];
return(rtfToXamlError);
}
XamlToRtfError IXamlAttributes.GetName(int index, ref string uri, ref string localName, ref string qName)
{
XamlToRtfError rtfToXamlError = XamlToRtfError.None;
int nLength = (_xamlParsePoints.Count - 1) / 2;
if (index < 0 || index > nLength - 1)
{
return(XamlToRtfError.Unknown);
}
localName = (string)_xamlParsePoints[index * 2 + 1];
qName = (string)_xamlParsePoints[index * 2 + 2];
return(rtfToXamlError);
}
void IXamlErrorHandler.IgnorableWarning(string message, XamlToRtfError xamlToRtfError)
{
}
void IXamlErrorHandler.FatalError(string message, XamlToRtfError xamlToRtfError)
{
}
// ---------------------------------------------------------------------
//
// internal Methods
//
// ---------------------------------------------------------------------
#region internal Methods
internal XamlToRtfError Init(string xaml)
{
XamlToRtfError xamlToRtfError = XamlToRtfError.None;
// Initialize
_empty = false;
_valid = false;
Clear();
char quoteChar;
int xamlIndex = 0;
// Need to have at least "<...>". Note that verification at this point that the string ends with angle
// bracket allows me below to safely loop looking for specific character sets that don't match angle bracket
// without also explicitly having to test for looping past the end of the string.
if (xaml.Length < 2 || xaml[0] != '<' || xaml[xaml.Length - 1] != '>')
{
return(XamlToRtfError.Unknown);
}
xamlIndex++;
if (IsSpace(xaml[xamlIndex]))
{
return(XamlToRtfError.Unknown);
}
// An end tag?
if (xaml[xamlIndex] == '/')
{
return(HandleEndTag(xaml, xamlIndex));
}
// Add the start and end of the tag pointers
//AddParseData(xaml.Substring(xamlIndex));
int startIndex = xamlIndex;
// Note that check above that the string ends in angle simplifies loop check
for (xamlIndex++; IsNameChar(xaml[xamlIndex]); xamlIndex++)
{
continue;
}
AddParseData(xaml.Substring(startIndex, xamlIndex - startIndex));
// Start parsing name/value pairs
while (xamlIndex < xaml.Length)
{
// Move past spaces
for (; IsSpace(xaml[xamlIndex]); xamlIndex++)
{
continue;
}
// Done?
if (xamlIndex == xaml.Length - 1)
{
break;
}
// Empty tag?
if (xaml[xamlIndex] == '/')
{
if (xamlIndex == xaml.Length - 2)
{
_empty = true;
break;
}
else
{
return(XamlToRtfError.Unknown);
}
}
// OK, have another attribute
//AddParseData(xaml.Substring(xamlIndex));
startIndex = xamlIndex;
for (xamlIndex++; IsNameChar(xaml[xamlIndex]); xamlIndex++)
{
continue;
}
AddParseData(xaml.Substring(startIndex, xamlIndex - startIndex));
// Move past optional trailing spaces
if (xamlIndex < xaml.Length)
{
for (; IsSpace(xaml[xamlIndex]); xamlIndex++)
{
continue;
}
}
// Attribute with no '='?
if (xamlIndex == xaml.Length || xaml[xamlIndex] != '=')
{
return(XamlToRtfError.Unknown);
}
// Move past '=' and optional trailing spaces
xamlIndex++;
for (; IsSpace(xaml[xamlIndex]); xamlIndex++)
{
continue;
}
// Value needs to be quoted
if (xaml[xamlIndex] != '\'' && xaml[xamlIndex] != '"')
{
return(XamlToRtfError.Unknown);
}
quoteChar = xaml[xamlIndex++];
//AddParseData(xaml.Substring(xamlIndex));
startIndex = xamlIndex;
for (; xamlIndex < xaml.Length && xaml[xamlIndex] != quoteChar; xamlIndex++)
{
continue;
}
if (xamlIndex == xaml.Length)
{
return(XamlToRtfError.Unknown);
}
AddParseData(xaml.Substring(startIndex, xamlIndex - startIndex));
xamlIndex++;
}
_valid = true;
return(xamlToRtfError);
}
XamlToRtfError IXamlAttributes.GetTypeFromQName(string qName, ref string typeName)
{
XamlToRtfError rtfToXamlError = XamlToRtfError.None;
return(rtfToXamlError);
}
XamlToRtfError IXamlAttributes.GetValueFromName(string uri, string localName, ref string valueName)
{
XamlToRtfError rtfToXamlError = XamlToRtfError.None;
return(rtfToXamlError);
}
XamlToRtfError IXamlAttributes.GetType(int index, ref string typeName)
{
XamlToRtfError rtfToXamlError = XamlToRtfError.None;
return(rtfToXamlError);
}
XamlToRtfError IXamlAttributes.GetIndexFromQName(string qName, ref int index)
{
XamlToRtfError rtfToXamlError = XamlToRtfError.None;
return(rtfToXamlError);
}
XamlToRtfError IXamlAttributes.GetLocalName(int index, ref string localName)
{
XamlToRtfError rtfToXamlError = XamlToRtfError.None;
return(rtfToXamlError);
}
XamlToRtfError IXamlAttributes.GetUri(int index, ref string uri)
{
XamlToRtfError rtfToXamlError = XamlToRtfError.None;
return(rtfToXamlError);
}
// Token: 0x06008624 RID: 34340 RVA: 0x0024BCCC File Offset: 0x00249ECC
internal XamlToRtfError Next(XamlToRtfParser.XamlToken token)
{
XamlToRtfError result = XamlToRtfError.None;
int xamlIndex = this._xamlIndex;
if (this._xamlIndex < this._xaml.Length)
{
char c = this._xaml[this._xamlIndex];
if (c <= ' ')
{
switch (c)
{
case '\t':
case '\n':
case '\r':
break;
case '\v':
case '\f':
goto IL_124;
default:
if (c != ' ')
{
goto IL_124;
}
break;
}
token.TokenType = XamlTokenType.XTokWS;
this._xamlIndex++;
while (this.IsCharsAvailable(1))
{
if (!this.IsSpace(this._xaml[this._xamlIndex]))
{
break;
}
this._xamlIndex++;
}
goto IL_17C;
}
if (c == '&')
{
token.TokenType = XamlTokenType.XTokInvalid;
this._xamlIndex++;
while (this.IsCharsAvailable(1))
{
if (this._xaml[this._xamlIndex] == ';')
{
this._xamlIndex++;
token.TokenType = XamlTokenType.XTokEntity;
break;
}
this._xamlIndex++;
}
goto IL_17C;
}
if (c == '<')
{
this.NextLessThanToken(token);
goto IL_17C;
}
IL_124:
token.TokenType = XamlTokenType.XTokCharacters;
this._xamlIndex++;
while (this.IsCharsAvailable(1) && this._xaml[this._xamlIndex] != '&' && this._xaml[this._xamlIndex] != '<')
{
this._xamlIndex++;
}
}
IL_17C:
token.Text = this._xaml.Substring(xamlIndex, this._xamlIndex - xamlIndex);
if (token.Text.Length == 0)
{
token.TokenType = XamlTokenType.XTokEOF;
}
return(result);
}
// Token: 0x0600863E RID: 34366 RVA: 0x0024C37C File Offset: 0x0024A57C
internal XamlToRtfError Init(string xaml)
{
XamlToRtfError result = XamlToRtfError.None;
this._empty = false;
this._valid = false;
this.Clear();
int i = 0;
if (xaml.Length < 2 || xaml[0] != '<' || xaml[xaml.Length - 1] != '>')
{
return(XamlToRtfError.Unknown);
}
i++;
if (this.IsSpace(xaml[i]))
{
return(XamlToRtfError.Unknown);
}
if (xaml[i] == '/')
{
return(this.HandleEndTag(xaml, i));
}
int num = i;
i++;
while (this.IsNameChar(xaml[i]))
{
i++;
}
this.AddParseData(xaml.Substring(num, i - num));
while (i < xaml.Length)
{
while (this.IsSpace(xaml[i]))
{
i++;
}
if (i == xaml.Length - 1)
{
break;
}
if (xaml[i] == '/')
{
if (i == xaml.Length - 2)
{
this._empty = true;
break;
}
return(XamlToRtfError.Unknown);
}
else
{
num = i;
i++;
while (this.IsNameChar(xaml[i]))
{
i++;
}
this.AddParseData(xaml.Substring(num, i - num));
if (i < xaml.Length)
{
while (this.IsSpace(xaml[i]))
{
i++;
}
}
if (i == xaml.Length || xaml[i] != '=')
{
return(XamlToRtfError.Unknown);
}
i++;
while (this.IsSpace(xaml[i]))
{
i++;
}
if (xaml[i] != '\'' && xaml[i] != '"')
{
return(XamlToRtfError.Unknown);
}
char c = xaml[i++];
num = i;
while (i < xaml.Length && xaml[i] != c)
{
i++;
}
if (i == xaml.Length)
{
return(XamlToRtfError.Unknown);
}
this.AddParseData(xaml.Substring(num, i - num));
i++;
}
}
this._valid = true;
return(result);
}
// ---------------------------------------------------------------------
//
// internal Methods
//
// ---------------------------------------------------------------------
#region internal Methods
internal XamlToRtfError Parse()
{
// Need callbacks
if (_xamlContent == null || _xamlError == null)
{
return(XamlToRtfError.Unknown);
}
// We are simply looking for well-formedness: that is, that the XML is lexically valid and tags are balanced.
XamlToRtfError xamlToRtfError = XamlToRtfError.None;
XamlToken xamlToken = new XamlToken();
string name = string.Empty;
// Fire things off
xamlToRtfError = _xamlContent.StartDocument();
while (xamlToRtfError == XamlToRtfError.None)
{
xamlToRtfError = _xamlLexer.Next(xamlToken);
if (xamlToRtfError != XamlToRtfError.None || xamlToken.TokenType == XamlTokenType.XTokEOF)
{
break;
}
switch (xamlToken.TokenType)
{
case XamlTokenType.XTokInvalid:
xamlToRtfError = XamlToRtfError.Unknown;
break;
case XamlTokenType.XTokCharacters:
xamlToRtfError = _xamlContent.Characters(xamlToken.Text);
break;
case XamlTokenType.XTokEntity:
xamlToRtfError = _xamlContent.SkippedEntity(xamlToken.Text);
break;
case XamlTokenType.XTokStartElement:
xamlToRtfError = ParseXTokStartElement(xamlToken, ref name);
break;
case XamlTokenType.XTokEndElement:
xamlToRtfError = ParseXTokEndElement(xamlToken, ref name);
break;
case XamlTokenType.XTokCData:
// Ignore
break;
case XamlTokenType.XTokPI:
// Ignore
break;
case XamlTokenType.XTokComment:
// Ignore
break;
case XamlTokenType.XTokWS:
xamlToRtfError = _xamlContent.IgnorableWhitespace(xamlToken.Text);
break;
default:
xamlToRtfError = XamlToRtfError.Unknown;
break;
}
}
// All tags need to have been popped.
if (xamlToRtfError == XamlToRtfError.None && _xamlTagStack.Count != 0)
{
xamlToRtfError = XamlToRtfError.Unknown;
}
// Wrap things up
if (xamlToRtfError == XamlToRtfError.None)
{
xamlToRtfError = _xamlContent.EndDocument();
}
return(xamlToRtfError);
}
// ---------------------------------------------------------------------
//
// internal Methods
//
// ---------------------------------------------------------------------
#region internal Methods
internal XamlToRtfError Next(XamlToken token)
{
XamlToRtfError xamlToRtfError = XamlToRtfError.None;
int startIndex = _xamlIndex;
if (_xamlIndex < _xaml.Length)
{
char tokenChar = _xaml[_xamlIndex];
switch (tokenChar)
{
case ' ':
case '\t':
case '\r':
case '\n':
token.TokenType = XamlTokenType.XTokWS;
for (_xamlIndex++; IsCharsAvailable(1) && IsSpace(_xaml[_xamlIndex]); _xamlIndex++)
{
continue;
}
break;
case '<':
NextLessThanToken(token);
break;
case '&':
// Entity
token.TokenType = XamlTokenType.XTokInvalid;
for (_xamlIndex++; IsCharsAvailable(1); _xamlIndex++)
{
if (_xaml[_xamlIndex] == ';')
{
_xamlIndex++;
token.TokenType = XamlTokenType.XTokEntity;
break;
}
}
break;
default:
// Plain text
token.TokenType = XamlTokenType.XTokCharacters;
for (_xamlIndex++; IsCharsAvailable(1); _xamlIndex++)
{
if (_xaml[_xamlIndex] == '&' || _xaml[_xamlIndex] == '<')
{
break;
}
}
break;
}
}
token.Text = _xaml.Substring(startIndex, _xamlIndex - startIndex);
if (token.Text.Length == 0)
{
token.TokenType = XamlTokenType.XTokEOF;
}
return(xamlToRtfError);
}
