using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Text;
namespace Google.ProtocolBuffers.Serialization
{
/// <summary>
/// JSon Tokenizer used by JsonFormatReader
/// </summary>
abstract class JsonCursor
{
public enum JsType { String, Number, Object, Array, True, False, Null }
#region Buffering implementations
class JsonStreamCursor : JsonCursor
{
private readonly byte[] _buffer;
private int _bufferPos;
private readonly Stream _input;
public JsonStreamCursor(Stream input)
{
_input = input;
_next = _input.ReadByte();
}
public JsonStreamCursor(byte[] input)
{
_input = null;
_buffer = input;
_next = _buffer[_bufferPos];
}
protected override int Peek()
{
if (_input != null)
return _next;
else if (_bufferPos < _buffer.Length)
return _buffer[_bufferPos];
else
return -1;
}
protected override int Read()
{
if (_input != null)
{
int result = _next;
_next = _input.ReadByte();
return result;
}
else if (_bufferPos < _buffer.Length)
return _buffer[_bufferPos++];
else
return -1;
}
}
class JsonTextCursor : JsonCursor
{
private readonly char[] _buffer;
private int _bufferPos;
private readonly TextReader _input;
public JsonTextCursor(char[] input)
{
_input = null;
_buffer = input;
_bufferPos = 0;
_next = Peek();
}
public JsonTextCursor(TextReader input)
{
_input = input;
_next = Peek();
}
protected override int Peek()
{
if (_input != null)
return _input.Peek();
else if (_bufferPos < _buffer.Length)
return _buffer[_bufferPos];
else
return -1;
}
protected override int Read()
{
if (_input != null)
return _input.Read();
else if (_bufferPos < _buffer.Length)
return _buffer[_bufferPos++];
else
return -1;
}
}
#endregion
protected int _next;
private int _lineNo, _linePos;
public static JsonCursor CreateInstance(byte[] input) { return new JsonStreamCursor(input); }
public static JsonCursor CreateInstance(Stream input) { return new JsonStreamCursor(input); }
public static JsonCursor CreateInstance(string input) { return new JsonTextCursor(input.ToCharArray()); }
public static JsonCursor CreateInstance(TextReader input) { return new JsonTextCursor(input); }
protected JsonCursor()
{
_lineNo = 1;
_linePos = 0;
}
/// <summary>Returns the next character without actually 'reading' it</summary>
protected abstract int Peek();
/// <summary>Reads the next character in the input</summary>
protected abstract int Read();
public Char NextChar { get { SkipWhitespace(); return (char)_next; } }
#region Assert(...)
[System.Diagnostics.DebuggerNonUserCode]
private string CharDisplay(int ch)
{
return ch == -1 ? "EOF" :
(ch > 32 && ch < 127) ? String.Format("'{0}'", (char)ch) :
String.Format("'\\u{0:x4}'", ch);
}
[System.Diagnostics.DebuggerNonUserCode]
private void Assert(bool cond, char expected)
{
if (!cond)
{
throw new FormatException(
String.Format(CultureInfo.InvariantCulture,
"({0}:{1}) error: Unexpected token {2}, expected: {3}.",
_lineNo, _linePos,
CharDisplay(_next),
CharDisplay(expected)
));
}
}
[System.Diagnostics.DebuggerNonUserCode]
public void Assert(bool cond, string message)
{
if (!cond)
{
throw new FormatException(
String.Format(CultureInfo.InvariantCulture,
"({0},{1}) error: {2}", _lineNo, _linePos, message));
}
}
[System.Diagnostics.DebuggerNonUserCode]
public void Assert(bool cond, string format, params object[] args)
{
if (!cond)
{
if (args != null && args.Length > 0)
format = String.Format(format, args);
throw new FormatException(
String.Format(CultureInfo.InvariantCulture,
"({0},{1}) error: {2}", _lineNo, _linePos, format));
}
}
#endregion
private char ReadChar()
{
int ch = Read();
Assert(ch != -1, "Unexpected end of file.");
if (ch == '\n')
{
_lineNo++;
_linePos = 0;
}
else if (ch != '\r')
{
_linePos++;
}
_next = Peek();
return (char)ch;
}
public void Consume(char ch) { Assert(TryConsume(ch), ch); }
public bool TryConsume(char ch)
{
SkipWhitespace();
if (_next == ch)
{
ReadChar();
return true;
}
return false;
}
public void Consume(string sequence)
{
SkipWhitespace();
foreach (char ch in sequence)
Assert(ch == ReadChar(), "Expected token '{0}'.", sequence);
}
public void SkipWhitespace()
{
int chnext = _next;
while (chnext != -1)
{
if (!Char.IsWhiteSpace((char)chnext))
break;
ReadChar();
chnext = _next;
}
}
public string ReadString()
{
SkipWhitespace();
Consume('"');
List<Char> sb = new List<char>(100);
while (_next != '"')
{
if (_next == '\\')
{
Consume('\\');//skip the escape
char ch = ReadChar();
switch (ch)
{
case 'b': sb.Add('\b'); break;
case 'f': sb.Add('\f'); break;
case 'n': sb.Add('\n'); break;
case 'r': sb.Add('\r'); break;
case 't': sb.Add('\t'); break;
case 'u':
{
string hex = new string(new char[] { ReadChar(), ReadChar(), ReadChar(), ReadChar() });
int result;
Assert(int.TryParse(hex, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out result),
"Expected a 4-character hex specifier.");
sb.Add((char)result);
break;
}
default:
sb.Add(ch); break;
}
}
else
{
Assert(_next != '\n' && _next != '\r' && _next != '\f' && _next != -1, '"');
sb.Add(ReadChar());
}
}
Consume('"');
return new String(sb.ToArray());
}
public string ReadNumber()
{
SkipWhitespace();
List<Char> sb = new List<char>(24);
if (_next == '-')
sb.Add(ReadChar());
Assert(_next >= '0' && _next <= '9', "Expected a numeric type.");
while ((_next >= '0' && _next <= '9') || _next == '.')
sb.Add(ReadChar());
if (_next == 'e' || _next == 'E')
{
sb.Add(ReadChar());
if (_next == '-' || _next == '+')
sb.Add(ReadChar());
Assert(_next >= '0' && _next <= '9', "Expected a numeric type.");
while (_next >= '0' && _next <= '9')
sb.Add(ReadChar());
}
return new String(sb.ToArray());
}
public JsType ReadVariant(out object value)
{
SkipWhitespace();
switch (_next)
{
case 'n': Consume("null"); value = null; return JsType.Null;
case 't': Consume("true"); value = true; return JsType.True;
case 'f': Consume("false"); value = false; return JsType.False;
case '"': value = ReadString(); return JsType.String;
case '{':
{
Consume('{');
while (NextChar != '}')
{
ReadString();
Consume(':');
object tmp;
ReadVariant(out tmp);
if (!TryConsume(','))
break;
}
Consume('}');
value = null;
return JsType.Object;
}
case '[':
{
Consume('[');
List<object> values = new List<object>();
while (NextChar != ']')
{
object tmp;
ReadVariant(out tmp);
values.Add(tmp);
if (!TryConsume(','))
break;
}
Consume(']');
value = values.ToArray();
return JsType.Array;
}
default:
if ((_next >= '0' && _next <= '9') || _next == '-')
{
value = ReadNumber();
return JsType.Number;
}
Assert(false, "Expected a value.");
throw new FormatException();
}
}
}
}