niko
782 lines
16 KiB
C#
782 lines
16 KiB
C#
using System;
|
||
using System.Collections;
|
||
using System.Globalization;
|
||
using System.IO;
|
||
using System.Text;
|
||
|
||
namespace Mono.Xml
|
||
{
|
||
// Token: 0x020000EF RID: 239
|
||
internal class SmallXmlParser
|
||
{
|
||
// Token: 0x06000BE4 RID: 3044 RVA: 0x00035B24 File Offset: 0x00033D24
|
||
private Exception Error(string msg)
|
||
{
|
||
return new SmallXmlParserException(msg, this.line, this.column);
|
||
}
|
||
|
||
// Token: 0x06000BE5 RID: 3045 RVA: 0x00035B38 File Offset: 0x00033D38
|
||
private Exception UnexpectedEndError()
|
||
{
|
||
string[] array = new string[this.elementNames.Count];
|
||
this.elementNames.CopyTo(array, 0);
|
||
return this.Error(string.Format("Unexpected end of stream. Element stack content is {0}", string.Join(",", array)));
|
||
}
|
||
|
||
// Token: 0x06000BE6 RID: 3046 RVA: 0x00035B80 File Offset: 0x00033D80
|
||
private bool IsNameChar(char c, bool start)
|
||
{
|
||
if (c == '-' || c == '.')
|
||
{
|
||
return !start;
|
||
}
|
||
if (c == ':' || c == '_')
|
||
{
|
||
return true;
|
||
}
|
||
if (c > 'Ā')
|
||
{
|
||
if (c == 'ۥ' || c == 'ۦ' || c == 'ՙ')
|
||
{
|
||
return true;
|
||
}
|
||
if ('ʻ' <= c && c <= 'ˁ')
|
||
{
|
||
return true;
|
||
}
|
||
}
|
||
switch (char.GetUnicodeCategory(c))
|
||
{
|
||
case UnicodeCategory.UppercaseLetter:
|
||
case UnicodeCategory.LowercaseLetter:
|
||
case UnicodeCategory.TitlecaseLetter:
|
||
case UnicodeCategory.OtherLetter:
|
||
case UnicodeCategory.LetterNumber:
|
||
return true;
|
||
case UnicodeCategory.ModifierLetter:
|
||
case UnicodeCategory.NonSpacingMark:
|
||
case UnicodeCategory.SpacingCombiningMark:
|
||
case UnicodeCategory.EnclosingMark:
|
||
case UnicodeCategory.DecimalDigitNumber:
|
||
return !start;
|
||
default:
|
||
return false;
|
||
}
|
||
}
|
||
|
||
// Token: 0x06000BE7 RID: 3047 RVA: 0x00035C4C File Offset: 0x00033E4C
|
||
private bool IsWhitespace(int c)
|
||
{
|
||
switch (c)
|
||
{
|
||
case 9:
|
||
case 10:
|
||
case 13:
|
||
break;
|
||
default:
|
||
if (c != 32)
|
||
{
|
||
return false;
|
||
}
|
||
break;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
// Token: 0x06000BE8 RID: 3048 RVA: 0x00035C88 File Offset: 0x00033E88
|
||
public void SkipWhitespaces()
|
||
{
|
||
this.SkipWhitespaces(false);
|
||
}
|
||
|
||
// Token: 0x06000BE9 RID: 3049 RVA: 0x00035C94 File Offset: 0x00033E94
|
||
private void HandleWhitespaces()
|
||
{
|
||
while (this.IsWhitespace(this.Peek()))
|
||
{
|
||
this.buffer.Append((char)this.Read());
|
||
}
|
||
if (this.Peek() != 60 && this.Peek() >= 0)
|
||
{
|
||
this.isWhitespace = false;
|
||
}
|
||
}
|
||
|
||
// Token: 0x06000BEA RID: 3050 RVA: 0x00035CEC File Offset: 0x00033EEC
|
||
public void SkipWhitespaces(bool expected)
|
||
{
|
||
for (;;)
|
||
{
|
||
int num = this.Peek();
|
||
switch (num)
|
||
{
|
||
case 9:
|
||
case 10:
|
||
case 13:
|
||
break;
|
||
default:
|
||
if (num != 32)
|
||
{
|
||
goto Block_0;
|
||
}
|
||
break;
|
||
}
|
||
this.Read();
|
||
if (expected)
|
||
{
|
||
expected = false;
|
||
}
|
||
}
|
||
Block_0:
|
||
if (expected)
|
||
{
|
||
throw this.Error("Whitespace is expected.");
|
||
}
|
||
}
|
||
|
||
// Token: 0x06000BEB RID: 3051 RVA: 0x00035D58 File Offset: 0x00033F58
|
||
private int Peek()
|
||
{
|
||
return this.reader.Peek();
|
||
}
|
||
|
||
// Token: 0x06000BEC RID: 3052 RVA: 0x00035D68 File Offset: 0x00033F68
|
||
private int Read()
|
||
{
|
||
int num = this.reader.Read();
|
||
if (num == 10)
|
||
{
|
||
this.resetColumn = true;
|
||
}
|
||
if (this.resetColumn)
|
||
{
|
||
this.line++;
|
||
this.resetColumn = false;
|
||
this.column = 1;
|
||
}
|
||
else
|
||
{
|
||
this.column++;
|
||
}
|
||
return num;
|
||
}
|
||
|
||
// Token: 0x06000BED RID: 3053 RVA: 0x00035DCC File Offset: 0x00033FCC
|
||
public void Expect(int c)
|
||
{
|
||
int num = this.Read();
|
||
if (num < 0)
|
||
{
|
||
throw this.UnexpectedEndError();
|
||
}
|
||
if (num != c)
|
||
{
|
||
throw this.Error(string.Format("Expected '{0}' but got {1}", (char)c, (char)num));
|
||
}
|
||
}
|
||
|
||
// Token: 0x06000BEE RID: 3054 RVA: 0x00035E14 File Offset: 0x00034014
|
||
private string ReadUntil(char until, bool handleReferences)
|
||
{
|
||
while (this.Peek() >= 0)
|
||
{
|
||
char c = (char)this.Read();
|
||
if (c == until)
|
||
{
|
||
string text = this.buffer.ToString();
|
||
this.buffer.Length = 0;
|
||
return text;
|
||
}
|
||
if (handleReferences && c == '&')
|
||
{
|
||
this.ReadReference();
|
||
}
|
||
else
|
||
{
|
||
this.buffer.Append(c);
|
||
}
|
||
}
|
||
throw this.UnexpectedEndError();
|
||
}
|
||
|
||
// Token: 0x06000BEF RID: 3055 RVA: 0x00035E8C File Offset: 0x0003408C
|
||
public string ReadName()
|
||
{
|
||
int num = 0;
|
||
if (this.Peek() < 0 || !this.IsNameChar((char)this.Peek(), true))
|
||
{
|
||
throw this.Error("XML name start character is expected.");
|
||
}
|
||
for (int i = this.Peek(); i >= 0; i = this.Peek())
|
||
{
|
||
char c = (char)i;
|
||
if (!this.IsNameChar(c, false))
|
||
{
|
||
break;
|
||
}
|
||
if (num == this.nameBuffer.Length)
|
||
{
|
||
char[] array = new char[num * 2];
|
||
Array.Copy(this.nameBuffer, array, num);
|
||
this.nameBuffer = array;
|
||
}
|
||
this.nameBuffer[num++] = c;
|
||
this.Read();
|
||
}
|
||
if (num == 0)
|
||
{
|
||
throw this.Error("Valid XML name is expected.");
|
||
}
|
||
return new string(this.nameBuffer, 0, num);
|
||
}
|
||
|
||
// Token: 0x06000BF0 RID: 3056 RVA: 0x00035F54 File Offset: 0x00034154
|
||
public void Parse(TextReader input, SmallXmlParser.IContentHandler handler)
|
||
{
|
||
this.reader = input;
|
||
this.handler = handler;
|
||
handler.OnStartParsing(this);
|
||
while (this.Peek() >= 0)
|
||
{
|
||
this.ReadContent();
|
||
}
|
||
this.HandleBufferedContent();
|
||
if (this.elementNames.Count > 0)
|
||
{
|
||
throw this.Error(string.Format("Insufficient close tag: {0}", this.elementNames.Peek()));
|
||
}
|
||
handler.OnEndParsing(this);
|
||
this.Cleanup();
|
||
}
|
||
|
||
// Token: 0x06000BF1 RID: 3057 RVA: 0x00035FD0 File Offset: 0x000341D0
|
||
private void Cleanup()
|
||
{
|
||
this.line = 1;
|
||
this.column = 0;
|
||
this.handler = null;
|
||
this.reader = null;
|
||
this.elementNames.Clear();
|
||
this.xmlSpaces.Clear();
|
||
this.attributes.Clear();
|
||
this.buffer.Length = 0;
|
||
this.xmlSpace = null;
|
||
this.isWhitespace = false;
|
||
}
|
||
|
||
// Token: 0x06000BF2 RID: 3058 RVA: 0x00036034 File Offset: 0x00034234
|
||
public void ReadContent()
|
||
{
|
||
if (this.IsWhitespace(this.Peek()))
|
||
{
|
||
if (this.buffer.Length == 0)
|
||
{
|
||
this.isWhitespace = true;
|
||
}
|
||
this.HandleWhitespaces();
|
||
}
|
||
if (this.Peek() != 60)
|
||
{
|
||
this.ReadCharacters();
|
||
return;
|
||
}
|
||
this.Read();
|
||
int num = this.Peek();
|
||
if (num != 33)
|
||
{
|
||
if (num != 47)
|
||
{
|
||
string text;
|
||
if (num != 63)
|
||
{
|
||
this.HandleBufferedContent();
|
||
text = this.ReadName();
|
||
while (this.Peek() != 62 && this.Peek() != 47)
|
||
{
|
||
this.ReadAttribute(this.attributes);
|
||
}
|
||
this.handler.OnStartElement(text, this.attributes);
|
||
this.attributes.Clear();
|
||
this.SkipWhitespaces();
|
||
if (this.Peek() == 47)
|
||
{
|
||
this.Read();
|
||
this.handler.OnEndElement(text);
|
||
}
|
||
else
|
||
{
|
||
this.elementNames.Push(text);
|
||
this.xmlSpaces.Push(this.xmlSpace);
|
||
}
|
||
this.Expect(62);
|
||
return;
|
||
}
|
||
this.HandleBufferedContent();
|
||
this.Read();
|
||
text = this.ReadName();
|
||
this.SkipWhitespaces();
|
||
string text2 = string.Empty;
|
||
if (this.Peek() != 63)
|
||
{
|
||
for (;;)
|
||
{
|
||
text2 += this.ReadUntil('?', false);
|
||
if (this.Peek() == 62)
|
||
{
|
||
break;
|
||
}
|
||
text2 += "?";
|
||
}
|
||
}
|
||
this.handler.OnProcessingInstruction(text, text2);
|
||
this.Expect(62);
|
||
return;
|
||
}
|
||
else
|
||
{
|
||
this.HandleBufferedContent();
|
||
if (this.elementNames.Count == 0)
|
||
{
|
||
throw this.UnexpectedEndError();
|
||
}
|
||
this.Read();
|
||
string text = this.ReadName();
|
||
this.SkipWhitespaces();
|
||
string text3 = (string)this.elementNames.Pop();
|
||
this.xmlSpaces.Pop();
|
||
if (this.xmlSpaces.Count > 0)
|
||
{
|
||
this.xmlSpace = (string)this.xmlSpaces.Peek();
|
||
}
|
||
else
|
||
{
|
||
this.xmlSpace = null;
|
||
}
|
||
if (text != text3)
|
||
{
|
||
throw this.Error(string.Format("End tag mismatch: expected {0} but found {1}", text3, text));
|
||
}
|
||
this.handler.OnEndElement(text);
|
||
this.Expect(62);
|
||
return;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
this.Read();
|
||
if (this.Peek() == 91)
|
||
{
|
||
this.Read();
|
||
if (this.ReadName() != "CDATA")
|
||
{
|
||
throw this.Error("Invalid declaration markup");
|
||
}
|
||
this.Expect(91);
|
||
this.ReadCDATASection();
|
||
return;
|
||
}
|
||
else
|
||
{
|
||
if (this.Peek() == 45)
|
||
{
|
||
this.ReadComment();
|
||
return;
|
||
}
|
||
if (this.ReadName() != "DOCTYPE")
|
||
{
|
||
throw this.Error("Invalid declaration markup.");
|
||
}
|
||
throw this.Error("This parser does not support document type.");
|
||
}
|
||
}
|
||
}
|
||
|
||
// Token: 0x06000BF3 RID: 3059 RVA: 0x0003630C File Offset: 0x0003450C
|
||
private void HandleBufferedContent()
|
||
{
|
||
if (this.buffer.Length == 0)
|
||
{
|
||
return;
|
||
}
|
||
if (this.isWhitespace)
|
||
{
|
||
this.handler.OnIgnorableWhitespace(this.buffer.ToString());
|
||
}
|
||
else
|
||
{
|
||
this.handler.OnChars(this.buffer.ToString());
|
||
}
|
||
this.buffer.Length = 0;
|
||
this.isWhitespace = false;
|
||
}
|
||
|
||
// Token: 0x06000BF4 RID: 3060 RVA: 0x0003637C File Offset: 0x0003457C
|
||
private void ReadCharacters()
|
||
{
|
||
this.isWhitespace = false;
|
||
for (;;)
|
||
{
|
||
int num = this.Peek();
|
||
int num2 = num;
|
||
if (num2 == -1)
|
||
{
|
||
break;
|
||
}
|
||
if (num2 != 38)
|
||
{
|
||
if (num2 == 60)
|
||
{
|
||
return;
|
||
}
|
||
this.buffer.Append((char)this.Read());
|
||
}
|
||
else
|
||
{
|
||
this.Read();
|
||
this.ReadReference();
|
||
}
|
||
}
|
||
}
|
||
|
||
// Token: 0x06000BF5 RID: 3061 RVA: 0x000363E8 File Offset: 0x000345E8
|
||
private void ReadReference()
|
||
{
|
||
if (this.Peek() != 35)
|
||
{
|
||
string text = this.ReadName();
|
||
this.Expect(59);
|
||
string text2 = text;
|
||
switch (text2)
|
||
{
|
||
case "amp":
|
||
this.buffer.Append('&');
|
||
return;
|
||
case "quot":
|
||
this.buffer.Append('"');
|
||
return;
|
||
case "apos":
|
||
this.buffer.Append('\'');
|
||
return;
|
||
case "lt":
|
||
this.buffer.Append('<');
|
||
return;
|
||
case "gt":
|
||
this.buffer.Append('>');
|
||
return;
|
||
}
|
||
throw this.Error("General non-predefined entity reference is not supported in this parser.");
|
||
}
|
||
this.Read();
|
||
this.ReadCharacterReference();
|
||
}
|
||
|
||
// Token: 0x06000BF6 RID: 3062 RVA: 0x0003651C File Offset: 0x0003471C
|
||
private int ReadCharacterReference()
|
||
{
|
||
int num = 0;
|
||
if (this.Peek() == 120)
|
||
{
|
||
this.Read();
|
||
for (int i = this.Peek(); i >= 0; i = this.Peek())
|
||
{
|
||
if (48 <= i && i <= 57)
|
||
{
|
||
num <<= 4 + i - 48;
|
||
}
|
||
else if (65 <= i && i <= 70)
|
||
{
|
||
num <<= 4 + i - 65 + 10;
|
||
}
|
||
else
|
||
{
|
||
if (97 > i || i > 102)
|
||
{
|
||
break;
|
||
}
|
||
num <<= 4 + i - 97 + 10;
|
||
}
|
||
this.Read();
|
||
}
|
||
}
|
||
else
|
||
{
|
||
for (int j = this.Peek(); j >= 0; j = this.Peek())
|
||
{
|
||
if (48 > j || j > 57)
|
||
{
|
||
break;
|
||
}
|
||
num <<= 4 + j - 48;
|
||
this.Read();
|
||
}
|
||
}
|
||
return num;
|
||
}
|
||
|
||
// Token: 0x06000BF7 RID: 3063 RVA: 0x0003661C File Offset: 0x0003481C
|
||
private void ReadAttribute(SmallXmlParser.AttrListImpl a)
|
||
{
|
||
this.SkipWhitespaces(true);
|
||
if (this.Peek() == 47 || this.Peek() == 62)
|
||
{
|
||
return;
|
||
}
|
||
string text = this.ReadName();
|
||
this.SkipWhitespaces();
|
||
this.Expect(61);
|
||
this.SkipWhitespaces();
|
||
int num = this.Read();
|
||
string text2;
|
||
if (num != 34)
|
||
{
|
||
if (num != 39)
|
||
{
|
||
throw this.Error("Invalid attribute value markup.");
|
||
}
|
||
text2 = this.ReadUntil('\'', true);
|
||
}
|
||
else
|
||
{
|
||
text2 = this.ReadUntil('"', true);
|
||
}
|
||
if (text == "xml:space")
|
||
{
|
||
this.xmlSpace = text2;
|
||
}
|
||
a.Add(text, text2);
|
||
}
|
||
|
||
// Token: 0x06000BF8 RID: 3064 RVA: 0x000366CC File Offset: 0x000348CC
|
||
private void ReadCDATASection()
|
||
{
|
||
int num = 0;
|
||
while (this.Peek() >= 0)
|
||
{
|
||
char c = (char)this.Read();
|
||
if (c == ']')
|
||
{
|
||
num++;
|
||
}
|
||
else
|
||
{
|
||
if (c == '>' && num > 1)
|
||
{
|
||
for (int i = num; i > 2; i--)
|
||
{
|
||
this.buffer.Append(']');
|
||
}
|
||
return;
|
||
}
|
||
for (int j = 0; j < num; j++)
|
||
{
|
||
this.buffer.Append(']');
|
||
}
|
||
num = 0;
|
||
this.buffer.Append(c);
|
||
}
|
||
}
|
||
throw this.UnexpectedEndError();
|
||
}
|
||
|
||
// Token: 0x06000BF9 RID: 3065 RVA: 0x00036770 File Offset: 0x00034970
|
||
private void ReadComment()
|
||
{
|
||
this.Expect(45);
|
||
this.Expect(45);
|
||
for (;;)
|
||
{
|
||
if (this.Read() == 45)
|
||
{
|
||
if (this.Read() == 45)
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if (this.Read() != 62)
|
||
{
|
||
throw this.Error("'--' is not allowed inside comment markup.");
|
||
}
|
||
}
|
||
|
||
// Token: 0x04000342 RID: 834
|
||
private SmallXmlParser.IContentHandler handler;
|
||
|
||
// Token: 0x04000343 RID: 835
|
||
private TextReader reader;
|
||
|
||
// Token: 0x04000344 RID: 836
|
||
private Stack elementNames = new Stack();
|
||
|
||
// Token: 0x04000345 RID: 837
|
||
private Stack xmlSpaces = new Stack();
|
||
|
||
// Token: 0x04000346 RID: 838
|
||
private string xmlSpace;
|
||
|
||
// Token: 0x04000347 RID: 839
|
||
private StringBuilder buffer = new StringBuilder(200);
|
||
|
||
// Token: 0x04000348 RID: 840
|
||
private char[] nameBuffer = new char[30];
|
||
|
||
// Token: 0x04000349 RID: 841
|
||
private bool isWhitespace;
|
||
|
||
// Token: 0x0400034A RID: 842
|
||
private SmallXmlParser.AttrListImpl attributes = new SmallXmlParser.AttrListImpl();
|
||
|
||
// Token: 0x0400034B RID: 843
|
||
private int line = 1;
|
||
|
||
// Token: 0x0400034C RID: 844
|
||
private int column;
|
||
|
||
// Token: 0x0400034D RID: 845
|
||
private bool resetColumn;
|
||
|
||
// Token: 0x020000F0 RID: 240
|
||
public interface IContentHandler
|
||
{
|
||
// Token: 0x06000BFA RID: 3066
|
||
void OnStartParsing(SmallXmlParser parser);
|
||
|
||
// Token: 0x06000BFB RID: 3067
|
||
void OnEndParsing(SmallXmlParser parser);
|
||
|
||
// Token: 0x06000BFC RID: 3068
|
||
void OnStartElement(string name, SmallXmlParser.IAttrList attrs);
|
||
|
||
// Token: 0x06000BFD RID: 3069
|
||
void OnEndElement(string name);
|
||
|
||
// Token: 0x06000BFE RID: 3070
|
||
void OnProcessingInstruction(string name, string text);
|
||
|
||
// Token: 0x06000BFF RID: 3071
|
||
void OnChars(string text);
|
||
|
||
// Token: 0x06000C00 RID: 3072
|
||
void OnIgnorableWhitespace(string text);
|
||
}
|
||
|
||
// Token: 0x020000F1 RID: 241
|
||
public interface IAttrList
|
||
{
|
||
// Token: 0x170001B8 RID: 440
|
||
// (get) Token: 0x06000C01 RID: 3073
|
||
int Length { get; }
|
||
|
||
// Token: 0x170001B9 RID: 441
|
||
// (get) Token: 0x06000C02 RID: 3074
|
||
bool IsEmpty { get; }
|
||
|
||
// Token: 0x06000C03 RID: 3075
|
||
string GetName(int i);
|
||
|
||
// Token: 0x06000C04 RID: 3076
|
||
string GetValue(int i);
|
||
|
||
// Token: 0x06000C05 RID: 3077
|
||
string GetValue(string name);
|
||
|
||
// Token: 0x170001BA RID: 442
|
||
// (get) Token: 0x06000C06 RID: 3078
|
||
string[] Names { get; }
|
||
|
||
// Token: 0x170001BB RID: 443
|
||
// (get) Token: 0x06000C07 RID: 3079
|
||
string[] Values { get; }
|
||
}
|
||
|
||
// Token: 0x020000F2 RID: 242
|
||
private class AttrListImpl : SmallXmlParser.IAttrList
|
||
{
|
||
// Token: 0x170001BC RID: 444
|
||
// (get) Token: 0x06000C09 RID: 3081 RVA: 0x000367F4 File Offset: 0x000349F4
|
||
public int Length
|
||
{
|
||
get
|
||
{
|
||
return this.attrNames.Count;
|
||
}
|
||
}
|
||
|
||
// Token: 0x170001BD RID: 445
|
||
// (get) Token: 0x06000C0A RID: 3082 RVA: 0x00036804 File Offset: 0x00034A04
|
||
public bool IsEmpty
|
||
{
|
||
get
|
||
{
|
||
return this.attrNames.Count == 0;
|
||
}
|
||
}
|
||
|
||
// Token: 0x06000C0B RID: 3083 RVA: 0x00036814 File Offset: 0x00034A14
|
||
public string GetName(int i)
|
||
{
|
||
return (string)this.attrNames[i];
|
||
}
|
||
|
||
// Token: 0x06000C0C RID: 3084 RVA: 0x00036828 File Offset: 0x00034A28
|
||
public string GetValue(int i)
|
||
{
|
||
return (string)this.attrValues[i];
|
||
}
|
||
|
||
// Token: 0x06000C0D RID: 3085 RVA: 0x0003683C File Offset: 0x00034A3C
|
||
public string GetValue(string name)
|
||
{
|
||
for (int i = 0; i < this.attrNames.Count; i++)
|
||
{
|
||
if ((string)this.attrNames[i] == name)
|
||
{
|
||
return (string)this.attrValues[i];
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
|
||
// Token: 0x170001BE RID: 446
|
||
// (get) Token: 0x06000C0E RID: 3086 RVA: 0x00036894 File Offset: 0x00034A94
|
||
public string[] Names
|
||
{
|
||
get
|
||
{
|
||
return (string[])this.attrNames.ToArray(typeof(string));
|
||
}
|
||
}
|
||
|
||
// Token: 0x170001BF RID: 447
|
||
// (get) Token: 0x06000C0F RID: 3087 RVA: 0x000368B0 File Offset: 0x00034AB0
|
||
public string[] Values
|
||
{
|
||
get
|
||
{
|
||
return (string[])this.attrValues.ToArray(typeof(string));
|
||
}
|
||
}
|
||
|
||
// Token: 0x06000C10 RID: 3088 RVA: 0x000368CC File Offset: 0x00034ACC
|
||
internal void Clear()
|
||
{
|
||
this.attrNames.Clear();
|
||
this.attrValues.Clear();
|
||
}
|
||
|
||
// Token: 0x06000C11 RID: 3089 RVA: 0x000368E4 File Offset: 0x00034AE4
|
||
internal void Add(string name, string value)
|
||
{
|
||
this.attrNames.Add(name);
|
||
this.attrValues.Add(value);
|
||
}
|
||
|
||
// Token: 0x0400034F RID: 847
|
||
private ArrayList attrNames = new ArrayList();
|
||
|
||
// Token: 0x04000350 RID: 848
|
||
private ArrayList attrValues = new ArrayList();
|
||
}
|
||
}
|
||
}
|