niko
695 lines
20 KiB
C#
695 lines
20 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Text;
|
|
|
|
namespace Google.Protobuf
|
|
{
|
|
// Token: 0x02000012 RID: 18
|
|
internal abstract class JsonTokenizer
|
|
{
|
|
// Token: 0x06000121 RID: 289 RVA: 0x0000751F File Offset: 0x0000571F
|
|
internal static JsonTokenizer FromTextReader(TextReader reader)
|
|
{
|
|
return new JsonTokenizer.JsonTextTokenizer(reader);
|
|
}
|
|
|
|
// Token: 0x06000122 RID: 290 RVA: 0x00007527 File Offset: 0x00005727
|
|
internal static JsonTokenizer FromReplayedTokens(IList<JsonToken> tokens, JsonTokenizer continuation)
|
|
{
|
|
return new JsonTokenizer.JsonReplayTokenizer(tokens, continuation);
|
|
}
|
|
|
|
// Token: 0x17000023 RID: 35
|
|
// (get) Token: 0x06000123 RID: 291 RVA: 0x00007530 File Offset: 0x00005730
|
|
// (set) Token: 0x06000124 RID: 292 RVA: 0x00007538 File Offset: 0x00005738
|
|
internal int ObjectDepth { get; private set; }
|
|
|
|
// Token: 0x06000125 RID: 293 RVA: 0x00007544 File Offset: 0x00005744
|
|
internal void PushBack(JsonToken token)
|
|
{
|
|
if (this.bufferedToken != null)
|
|
{
|
|
throw new InvalidOperationException("Can't push back twice");
|
|
}
|
|
this.bufferedToken = token;
|
|
if (token.Type == JsonToken.TokenType.StartObject)
|
|
{
|
|
int num = this.ObjectDepth;
|
|
this.ObjectDepth = num - 1;
|
|
return;
|
|
}
|
|
if (token.Type == JsonToken.TokenType.EndObject)
|
|
{
|
|
int num = this.ObjectDepth;
|
|
this.ObjectDepth = num + 1;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000126 RID: 294 RVA: 0x000075A0 File Offset: 0x000057A0
|
|
internal JsonToken Next()
|
|
{
|
|
JsonToken jsonToken;
|
|
if (this.bufferedToken != null)
|
|
{
|
|
jsonToken = this.bufferedToken;
|
|
this.bufferedToken = null;
|
|
}
|
|
else
|
|
{
|
|
jsonToken = this.NextImpl();
|
|
}
|
|
if (jsonToken.Type == JsonToken.TokenType.StartObject)
|
|
{
|
|
int num = this.ObjectDepth;
|
|
this.ObjectDepth = num + 1;
|
|
}
|
|
else if (jsonToken.Type == JsonToken.TokenType.EndObject)
|
|
{
|
|
int num = this.ObjectDepth;
|
|
this.ObjectDepth = num - 1;
|
|
}
|
|
return jsonToken;
|
|
}
|
|
|
|
// Token: 0x06000127 RID: 295
|
|
protected abstract JsonToken NextImpl();
|
|
|
|
// Token: 0x04000046 RID: 70
|
|
private JsonToken bufferedToken;
|
|
|
|
// Token: 0x02000082 RID: 130
|
|
private class JsonReplayTokenizer : JsonTokenizer
|
|
{
|
|
// Token: 0x060006C3 RID: 1731 RVA: 0x00016852 File Offset: 0x00014A52
|
|
internal JsonReplayTokenizer(IList<JsonToken> tokens, JsonTokenizer nextTokenizer)
|
|
{
|
|
this.tokens = tokens;
|
|
this.nextTokenizer = nextTokenizer;
|
|
}
|
|
|
|
// Token: 0x060006C4 RID: 1732 RVA: 0x00016868 File Offset: 0x00014A68
|
|
protected override JsonToken NextImpl()
|
|
{
|
|
if (this.nextTokenIndex >= this.tokens.Count)
|
|
{
|
|
return this.nextTokenizer.Next();
|
|
}
|
|
IList<JsonToken> list = this.tokens;
|
|
int num = this.nextTokenIndex;
|
|
this.nextTokenIndex = num + 1;
|
|
return list[num];
|
|
}
|
|
|
|
// Token: 0x040002AB RID: 683
|
|
private readonly IList<JsonToken> tokens;
|
|
|
|
// Token: 0x040002AC RID: 684
|
|
private readonly JsonTokenizer nextTokenizer;
|
|
|
|
// Token: 0x040002AD RID: 685
|
|
private int nextTokenIndex;
|
|
}
|
|
|
|
// Token: 0x02000083 RID: 131
|
|
private sealed class JsonTextTokenizer : JsonTokenizer
|
|
{
|
|
// Token: 0x060006C5 RID: 1733 RVA: 0x000168B0 File Offset: 0x00014AB0
|
|
internal JsonTextTokenizer(TextReader reader)
|
|
{
|
|
this.reader = new JsonTokenizer.JsonTextTokenizer.PushBackReader(reader);
|
|
this.state = JsonTokenizer.JsonTextTokenizer.State.StartOfDocument;
|
|
this.containerStack.Push(JsonTokenizer.JsonTextTokenizer.ContainerType.Document);
|
|
}
|
|
|
|
// Token: 0x060006C6 RID: 1734 RVA: 0x000168E4 File Offset: 0x00014AE4
|
|
protected override JsonToken NextImpl()
|
|
{
|
|
if (this.state == JsonTokenizer.JsonTextTokenizer.State.ReaderExhausted)
|
|
{
|
|
throw new InvalidOperationException("Next() called after end of document");
|
|
}
|
|
char? c;
|
|
char value;
|
|
for (;;)
|
|
{
|
|
c = this.reader.Read();
|
|
if (c == null)
|
|
{
|
|
break;
|
|
}
|
|
value = c.Value;
|
|
if (value > ']')
|
|
{
|
|
goto IL_106;
|
|
}
|
|
if (value > ':')
|
|
{
|
|
goto IL_F1;
|
|
}
|
|
switch (value)
|
|
{
|
|
case '\t':
|
|
case '\n':
|
|
case '\r':
|
|
break;
|
|
case '\v':
|
|
case '\f':
|
|
goto IL_2BB;
|
|
default:
|
|
switch (value)
|
|
{
|
|
case ' ':
|
|
continue;
|
|
case '"':
|
|
goto IL_188;
|
|
case ',':
|
|
this.ValidateState(JsonTokenizer.JsonTextTokenizer.State.ObjectAfterProperty | JsonTokenizer.JsonTextTokenizer.State.ArrayAfterValue, "Invalid state to read a colon: ");
|
|
this.state = ((this.state == JsonTokenizer.JsonTextTokenizer.State.ObjectAfterProperty) ? JsonTokenizer.JsonTextTokenizer.State.ObjectAfterComma : JsonTokenizer.JsonTextTokenizer.State.ArrayAfterComma);
|
|
continue;
|
|
case '-':
|
|
case '0':
|
|
case '1':
|
|
case '2':
|
|
case '3':
|
|
case '4':
|
|
case '5':
|
|
case '6':
|
|
case '7':
|
|
case '8':
|
|
case '9':
|
|
goto IL_29D;
|
|
case ':':
|
|
this.ValidateState(JsonTokenizer.JsonTextTokenizer.State.ObjectBeforeColon, "Invalid state to read a colon: ");
|
|
this.state = JsonTokenizer.JsonTextTokenizer.State.ObjectAfterColon;
|
|
continue;
|
|
}
|
|
goto Block_6;
|
|
}
|
|
}
|
|
this.ValidateState(JsonTokenizer.JsonTextTokenizer.State.ExpectedEndOfDocument, "Unexpected end of document in state: ");
|
|
this.state = JsonTokenizer.JsonTextTokenizer.State.ReaderExhausted;
|
|
return JsonToken.EndDocument;
|
|
Block_6:
|
|
goto IL_2BB;
|
|
IL_F1:
|
|
if (value == '[')
|
|
{
|
|
this.ValidateState(JsonTokenizer.JsonTextTokenizer.ValueStates, "Invalid state to read an open square bracket: ");
|
|
this.state = JsonTokenizer.JsonTextTokenizer.State.ArrayStart;
|
|
this.containerStack.Push(JsonTokenizer.JsonTextTokenizer.ContainerType.Array);
|
|
return JsonToken.StartArray;
|
|
}
|
|
if (value != ']')
|
|
{
|
|
goto IL_2BB;
|
|
}
|
|
this.ValidateState(JsonTokenizer.JsonTextTokenizer.State.ArrayStart | JsonTokenizer.JsonTextTokenizer.State.ArrayAfterValue, "Invalid state to read a close square bracket: ");
|
|
this.PopContainer();
|
|
return JsonToken.EndArray;
|
|
IL_106:
|
|
if (value <= 'n')
|
|
{
|
|
if (value == 'f')
|
|
{
|
|
this.ConsumeLiteral("false");
|
|
this.ValidateAndModifyStateForValue("Invalid state to read a false literal: ");
|
|
return JsonToken.False;
|
|
}
|
|
if (value != 'n')
|
|
{
|
|
goto IL_2BB;
|
|
}
|
|
this.ConsumeLiteral("null");
|
|
this.ValidateAndModifyStateForValue("Invalid state to read a null literal: ");
|
|
return JsonToken.Null;
|
|
}
|
|
else
|
|
{
|
|
if (value == 't')
|
|
{
|
|
this.ConsumeLiteral("true");
|
|
this.ValidateAndModifyStateForValue("Invalid state to read a true literal: ");
|
|
return JsonToken.True;
|
|
}
|
|
if (value == '{')
|
|
{
|
|
this.ValidateState(JsonTokenizer.JsonTextTokenizer.ValueStates, "Invalid state to read an open brace: ");
|
|
this.state = JsonTokenizer.JsonTextTokenizer.State.ObjectStart;
|
|
this.containerStack.Push(JsonTokenizer.JsonTextTokenizer.ContainerType.Object);
|
|
return JsonToken.StartObject;
|
|
}
|
|
if (value != '}')
|
|
{
|
|
goto IL_2BB;
|
|
}
|
|
this.ValidateState(JsonTokenizer.JsonTextTokenizer.State.ObjectStart | JsonTokenizer.JsonTextTokenizer.State.ObjectAfterProperty, "Invalid state to read a close brace: ");
|
|
this.PopContainer();
|
|
return JsonToken.EndObject;
|
|
}
|
|
IL_188:
|
|
string text = this.ReadString();
|
|
if ((this.state & (JsonTokenizer.JsonTextTokenizer.State.ObjectStart | JsonTokenizer.JsonTextTokenizer.State.ObjectAfterComma)) != (JsonTokenizer.JsonTextTokenizer.State)0)
|
|
{
|
|
this.state = JsonTokenizer.JsonTextTokenizer.State.ObjectBeforeColon;
|
|
return JsonToken.Name(text);
|
|
}
|
|
this.ValidateAndModifyStateForValue("Invalid state to read a double quote: ");
|
|
return JsonToken.Value(text);
|
|
IL_29D:
|
|
double num = this.ReadNumber(c.Value);
|
|
this.ValidateAndModifyStateForValue("Invalid state to read a number token: ");
|
|
return JsonToken.Value(num);
|
|
IL_2BB:
|
|
throw new InvalidJsonException("Invalid first character of token: " + c.Value.ToString());
|
|
}
|
|
|
|
// Token: 0x060006C7 RID: 1735 RVA: 0x00016BCA File Offset: 0x00014DCA
|
|
private void ValidateState(JsonTokenizer.JsonTextTokenizer.State validStates, string errorPrefix)
|
|
{
|
|
if ((validStates & this.state) == (JsonTokenizer.JsonTextTokenizer.State)0)
|
|
{
|
|
throw this.reader.CreateException(errorPrefix + this.state);
|
|
}
|
|
}
|
|
|
|
// Token: 0x060006C8 RID: 1736 RVA: 0x00016BF4 File Offset: 0x00014DF4
|
|
private string ReadString()
|
|
{
|
|
StringBuilder stringBuilder = new StringBuilder();
|
|
bool flag = false;
|
|
char c;
|
|
for (;;)
|
|
{
|
|
c = this.reader.ReadOrFail("Unexpected end of text while reading string");
|
|
if (c < ' ')
|
|
{
|
|
break;
|
|
}
|
|
if (c == '"')
|
|
{
|
|
goto Block_2;
|
|
}
|
|
if (c == '\\')
|
|
{
|
|
c = this.ReadEscapedCharacter();
|
|
}
|
|
if (flag != char.IsLowSurrogate(c))
|
|
{
|
|
goto Block_5;
|
|
}
|
|
flag = char.IsHighSurrogate(c);
|
|
stringBuilder.Append(c);
|
|
}
|
|
throw this.reader.CreateException(string.Format(CultureInfo.InvariantCulture, "Invalid character in string literal: U+{0:x4}", new object[] { (int)c }));
|
|
Block_2:
|
|
if (flag)
|
|
{
|
|
throw this.reader.CreateException("Invalid use of surrogate pair code units");
|
|
}
|
|
return stringBuilder.ToString();
|
|
Block_5:
|
|
throw this.reader.CreateException("Invalid use of surrogate pair code units");
|
|
}
|
|
|
|
// Token: 0x060006C9 RID: 1737 RVA: 0x00016CA4 File Offset: 0x00014EA4
|
|
private char ReadEscapedCharacter()
|
|
{
|
|
char c = this.reader.ReadOrFail("Unexpected end of text while reading character escape sequence");
|
|
if (c <= '\\')
|
|
{
|
|
if (c == '"')
|
|
{
|
|
return '"';
|
|
}
|
|
if (c == '/')
|
|
{
|
|
return '/';
|
|
}
|
|
if (c == '\\')
|
|
{
|
|
return '\\';
|
|
}
|
|
}
|
|
else if (c <= 'f')
|
|
{
|
|
if (c == 'b')
|
|
{
|
|
return '\b';
|
|
}
|
|
if (c == 'f')
|
|
{
|
|
return '\f';
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (c == 'n')
|
|
{
|
|
return '\n';
|
|
}
|
|
switch (c)
|
|
{
|
|
case 'r':
|
|
return '\r';
|
|
case 't':
|
|
return '\t';
|
|
case 'u':
|
|
return this.ReadUnicodeEscape();
|
|
}
|
|
}
|
|
throw this.reader.CreateException(string.Format(CultureInfo.InvariantCulture, "Invalid character in character escape sequence: U+{0:x4}", new object[] { (int)c }));
|
|
}
|
|
|
|
// Token: 0x060006CA RID: 1738 RVA: 0x00016D50 File Offset: 0x00014F50
|
|
private char ReadUnicodeEscape()
|
|
{
|
|
int num = 0;
|
|
for (int i = 0; i < 4; i++)
|
|
{
|
|
char c = this.reader.ReadOrFail("Unexpected end of text while reading Unicode escape sequence");
|
|
int num2;
|
|
if (c >= '0' && c <= '9')
|
|
{
|
|
num2 = (int)(c - '0');
|
|
}
|
|
else if (c >= 'a' && c <= 'f')
|
|
{
|
|
num2 = (int)(c - 'a' + '\n');
|
|
}
|
|
else
|
|
{
|
|
if (c < 'A' || c > 'F')
|
|
{
|
|
throw this.reader.CreateException(string.Format(CultureInfo.InvariantCulture, "Invalid character in character escape sequence: U+{0:x4}", new object[] { (int)c }));
|
|
}
|
|
num2 = (int)(c - 'A' + '\n');
|
|
}
|
|
num = (num << 4) + num2;
|
|
}
|
|
return (char)num;
|
|
}
|
|
|
|
// Token: 0x060006CB RID: 1739 RVA: 0x00016DEC File Offset: 0x00014FEC
|
|
private void ConsumeLiteral(string text)
|
|
{
|
|
for (int i = 1; i < text.Length; i++)
|
|
{
|
|
char? c = this.reader.Read();
|
|
if (c == null)
|
|
{
|
|
throw this.reader.CreateException("Unexpected end of text while reading literal token " + text);
|
|
}
|
|
if (c.Value != text[i])
|
|
{
|
|
throw this.reader.CreateException("Unexpected character while reading literal token " + text);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x060006CC RID: 1740 RVA: 0x00016E60 File Offset: 0x00015060
|
|
private double ReadNumber(char initialCharacter)
|
|
{
|
|
StringBuilder stringBuilder = new StringBuilder();
|
|
if (initialCharacter == '-')
|
|
{
|
|
stringBuilder.Append("-");
|
|
}
|
|
else
|
|
{
|
|
this.reader.PushBack(initialCharacter);
|
|
}
|
|
char? c = this.ReadInt(stringBuilder);
|
|
char? c2 = c;
|
|
if (((c2 != null) ? new int?((int)c2.GetValueOrDefault()) : null) == 46)
|
|
{
|
|
c = this.ReadFrac(stringBuilder);
|
|
}
|
|
c2 = c;
|
|
if (!(((c2 != null) ? new int?((int)c2.GetValueOrDefault()) : null) == 101))
|
|
{
|
|
c2 = c;
|
|
if (!(((c2 != null) ? new int?((int)c2.GetValueOrDefault()) : null) == 69))
|
|
{
|
|
goto IL_F7;
|
|
}
|
|
}
|
|
c = this.ReadExp(stringBuilder);
|
|
IL_F7:
|
|
if (c != null)
|
|
{
|
|
this.reader.PushBack(c.Value);
|
|
}
|
|
double num;
|
|
try
|
|
{
|
|
num = double.Parse(stringBuilder.ToString(), NumberStyles.AllowLeadingSign | NumberStyles.AllowDecimalPoint | NumberStyles.AllowExponent, CultureInfo.InvariantCulture);
|
|
}
|
|
catch (OverflowException)
|
|
{
|
|
throw this.reader.CreateException("Numeric value out of range: " + stringBuilder);
|
|
}
|
|
return num;
|
|
}
|
|
|
|
// Token: 0x060006CD RID: 1741 RVA: 0x00016FC4 File Offset: 0x000151C4
|
|
private char? ReadInt(StringBuilder builder)
|
|
{
|
|
char c = this.reader.ReadOrFail("Invalid numeric literal");
|
|
if (c < '0' || c > '9')
|
|
{
|
|
throw this.reader.CreateException("Invalid numeric literal");
|
|
}
|
|
builder.Append(c);
|
|
int num;
|
|
char? c2 = this.ConsumeDigits(builder, out num);
|
|
if (c == '0' && num != 0)
|
|
{
|
|
throw this.reader.CreateException("Invalid numeric literal: leading 0 for non-zero value.");
|
|
}
|
|
return c2;
|
|
}
|
|
|
|
// Token: 0x060006CE RID: 1742 RVA: 0x00017028 File Offset: 0x00015228
|
|
private char? ReadFrac(StringBuilder builder)
|
|
{
|
|
builder.Append('.');
|
|
int num;
|
|
char? c = this.ConsumeDigits(builder, out num);
|
|
if (num == 0)
|
|
{
|
|
throw this.reader.CreateException("Invalid numeric literal: fraction with no trailing digits");
|
|
}
|
|
return c;
|
|
}
|
|
|
|
// Token: 0x060006CF RID: 1743 RVA: 0x0001705C File Offset: 0x0001525C
|
|
private char? ReadExp(StringBuilder builder)
|
|
{
|
|
builder.Append('E');
|
|
char? c = this.reader.Read();
|
|
if (c == null)
|
|
{
|
|
throw this.reader.CreateException("Invalid numeric literal: exponent with no trailing digits");
|
|
}
|
|
char? c2 = c;
|
|
if (!(((c2 != null) ? new int?((int)c2.GetValueOrDefault()) : null) == 45))
|
|
{
|
|
c2 = c;
|
|
if (!(((c2 != null) ? new int?((int)c2.GetValueOrDefault()) : null) == 43))
|
|
{
|
|
this.reader.PushBack(c.Value);
|
|
goto IL_CD;
|
|
}
|
|
}
|
|
builder.Append(c.Value);
|
|
IL_CD:
|
|
int num;
|
|
c = this.ConsumeDigits(builder, out num);
|
|
if (num == 0)
|
|
{
|
|
throw this.reader.CreateException("Invalid numeric literal: exponent without value");
|
|
}
|
|
return c;
|
|
}
|
|
|
|
// Token: 0x060006D0 RID: 1744 RVA: 0x00017158 File Offset: 0x00015358
|
|
private char? ConsumeDigits(StringBuilder builder, out int count)
|
|
{
|
|
count = 0;
|
|
char? c;
|
|
for (;;)
|
|
{
|
|
c = this.reader.Read();
|
|
if (c == null || c.Value < '0' || c.Value > '9')
|
|
{
|
|
break;
|
|
}
|
|
count++;
|
|
builder.Append(c.Value);
|
|
}
|
|
return c;
|
|
}
|
|
|
|
// Token: 0x060006D1 RID: 1745 RVA: 0x000171AC File Offset: 0x000153AC
|
|
private void ValidateAndModifyStateForValue(string errorPrefix)
|
|
{
|
|
this.ValidateState(JsonTokenizer.JsonTextTokenizer.ValueStates, errorPrefix);
|
|
JsonTokenizer.JsonTextTokenizer.State state = this.state;
|
|
if (state <= JsonTokenizer.JsonTextTokenizer.State.ObjectAfterColon)
|
|
{
|
|
if (state == JsonTokenizer.JsonTextTokenizer.State.StartOfDocument)
|
|
{
|
|
this.state = JsonTokenizer.JsonTextTokenizer.State.ExpectedEndOfDocument;
|
|
return;
|
|
}
|
|
if (state == JsonTokenizer.JsonTextTokenizer.State.ObjectAfterColon)
|
|
{
|
|
this.state = JsonTokenizer.JsonTextTokenizer.State.ObjectAfterProperty;
|
|
return;
|
|
}
|
|
}
|
|
else if (state == JsonTokenizer.JsonTextTokenizer.State.ArrayStart || state == JsonTokenizer.JsonTextTokenizer.State.ArrayAfterComma)
|
|
{
|
|
this.state = JsonTokenizer.JsonTextTokenizer.State.ArrayAfterValue;
|
|
return;
|
|
}
|
|
throw new InvalidOperationException("ValidateAndModifyStateForValue does not handle all value states (and should)");
|
|
}
|
|
|
|
// Token: 0x060006D2 RID: 1746 RVA: 0x00017218 File Offset: 0x00015418
|
|
private void PopContainer()
|
|
{
|
|
this.containerStack.Pop();
|
|
JsonTokenizer.JsonTextTokenizer.ContainerType containerType = this.containerStack.Peek();
|
|
switch (containerType)
|
|
{
|
|
case JsonTokenizer.JsonTextTokenizer.ContainerType.Document:
|
|
this.state = JsonTokenizer.JsonTextTokenizer.State.ExpectedEndOfDocument;
|
|
return;
|
|
case JsonTokenizer.JsonTextTokenizer.ContainerType.Object:
|
|
this.state = JsonTokenizer.JsonTextTokenizer.State.ObjectAfterProperty;
|
|
return;
|
|
case JsonTokenizer.JsonTextTokenizer.ContainerType.Array:
|
|
this.state = JsonTokenizer.JsonTextTokenizer.State.ArrayAfterValue;
|
|
return;
|
|
default:
|
|
throw new InvalidOperationException("Unexpected container type: " + containerType);
|
|
}
|
|
}
|
|
|
|
// Token: 0x040002AE RID: 686
|
|
private static readonly JsonTokenizer.JsonTextTokenizer.State ValueStates = JsonTokenizer.JsonTextTokenizer.State.StartOfDocument | JsonTokenizer.JsonTextTokenizer.State.ObjectAfterColon | JsonTokenizer.JsonTextTokenizer.State.ArrayStart | JsonTokenizer.JsonTextTokenizer.State.ArrayAfterComma;
|
|
|
|
// Token: 0x040002AF RID: 687
|
|
private readonly Stack<JsonTokenizer.JsonTextTokenizer.ContainerType> containerStack = new Stack<JsonTokenizer.JsonTextTokenizer.ContainerType>();
|
|
|
|
// Token: 0x040002B0 RID: 688
|
|
private readonly JsonTokenizer.JsonTextTokenizer.PushBackReader reader;
|
|
|
|
// Token: 0x040002B1 RID: 689
|
|
private JsonTokenizer.JsonTextTokenizer.State state;
|
|
|
|
// Token: 0x020000D0 RID: 208
|
|
private enum ContainerType
|
|
{
|
|
// Token: 0x0400031A RID: 794
|
|
Document,
|
|
// Token: 0x0400031B RID: 795
|
|
Object,
|
|
// Token: 0x0400031C RID: 796
|
|
Array
|
|
}
|
|
|
|
// Token: 0x020000D1 RID: 209
|
|
[Flags]
|
|
private enum State
|
|
{
|
|
// Token: 0x0400031E RID: 798
|
|
StartOfDocument = 1,
|
|
// Token: 0x0400031F RID: 799
|
|
ExpectedEndOfDocument = 2,
|
|
// Token: 0x04000320 RID: 800
|
|
ReaderExhausted = 4,
|
|
// Token: 0x04000321 RID: 801
|
|
ObjectStart = 8,
|
|
// Token: 0x04000322 RID: 802
|
|
ObjectBeforeColon = 16,
|
|
// Token: 0x04000323 RID: 803
|
|
ObjectAfterColon = 32,
|
|
// Token: 0x04000324 RID: 804
|
|
ObjectAfterProperty = 64,
|
|
// Token: 0x04000325 RID: 805
|
|
ObjectAfterComma = 128,
|
|
// Token: 0x04000326 RID: 806
|
|
ArrayStart = 256,
|
|
// Token: 0x04000327 RID: 807
|
|
ArrayAfterValue = 512,
|
|
// Token: 0x04000328 RID: 808
|
|
ArrayAfterComma = 1024
|
|
}
|
|
|
|
// Token: 0x020000D2 RID: 210
|
|
private class PushBackReader
|
|
{
|
|
// Token: 0x060007AE RID: 1966 RVA: 0x00017CA7 File Offset: 0x00015EA7
|
|
internal PushBackReader(TextReader reader)
|
|
{
|
|
this.reader = reader;
|
|
}
|
|
|
|
// Token: 0x060007AF RID: 1967 RVA: 0x00017CB8 File Offset: 0x00015EB8
|
|
internal char? Read()
|
|
{
|
|
if (this.nextChar != null)
|
|
{
|
|
char? c = this.nextChar;
|
|
this.nextChar = null;
|
|
return c;
|
|
}
|
|
int num = this.reader.Read();
|
|
if (num != -1)
|
|
{
|
|
return new char?((char)num);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x060007B0 RID: 1968 RVA: 0x00017D08 File Offset: 0x00015F08
|
|
internal char ReadOrFail(string messageOnFailure)
|
|
{
|
|
char? c = this.Read();
|
|
if (c == null)
|
|
{
|
|
throw this.CreateException(messageOnFailure);
|
|
}
|
|
return c.Value;
|
|
}
|
|
|
|
// Token: 0x060007B1 RID: 1969 RVA: 0x00017D34 File Offset: 0x00015F34
|
|
internal void PushBack(char c)
|
|
{
|
|
if (this.nextChar != null)
|
|
{
|
|
throw new InvalidOperationException("Cannot push back when already buffering a character");
|
|
}
|
|
this.nextChar = new char?(c);
|
|
}
|
|
|
|
// Token: 0x060007B2 RID: 1970 RVA: 0x00017D5A File Offset: 0x00015F5A
|
|
internal InvalidJsonException CreateException(string message)
|
|
{
|
|
return new InvalidJsonException(message);
|
|
}
|
|
|
|
// Token: 0x04000329 RID: 809
|
|
private readonly TextReader reader;
|
|
|
|
// Token: 0x0400032A RID: 810
|
|
private char? nextChar;
|
|
}
|
|
}
|
|
}
|
|
}
|