Code Coverage Statistics for Source File

Newtonsoft.Json\JsonTextReader.cs

Symbol Coverage: 90.29% (344 of 381)

Branch Coverage: 92.62% (251 of 271)

Cyclomatic Complexity Avg: 6.21 Max:31

Code Lines: 381

Symbol Coverage Trend

View:


#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Xml;
using System.Globalization;
using Newtonsoft.Json.Utilities;

namespace Newtonsoft.Json
{
  /// <summary>
  /// Represents a reader that provides fast, non-cached, forward-only access to serialized Json data.
  /// </summary>
  public class JsonTextReader : JsonReader, IJsonLineInfo
  {
    private readonly TextReader _reader;
    private readonly StringBuffer _buffer;
    private char? _lastChar;
    private int _currentLinePosition;
    private int _currentLineNumber;
    private bool _end;

    /// <summary>
    /// Initializes a new instance of the <see cref="JsonReader"/> class with the specified <see cref="TextReader"/>.
    /// </summary>
    /// <param name="reader">The <c>TextReader</c> containing the XML data to read.</param>
    public JsonTextReader(TextReader reader)
    {
      if (reader == null)
        throw new ArgumentNullException("reader");

      _reader = reader;
      _buffer = new StringBuffer(4096);
      _currentLineNumber = 1;
    }

    private void ParseString(char quote)
    {
      ReadStringIntoBuffer(quote);

      string text = _buffer.ToString();
      _buffer.Position = 0;

      if (text.StartsWith("/Date(", StringComparison.Ordinal) && text.EndsWith(")/", StringComparison.Ordinal))
      {
        ParseDate(text);
      }
      else
      {
        SetToken(JsonToken.String, text);
        QuoteChar = quote;
      }
    }

    private void ReadStringIntoBuffer(char quote)
    {
      while (true)
      {
        char currentChar = MoveNext();

        switch (currentChar)
        {
          case '\0':
            if (_end)
              throw CreateJsonReaderException("Unterminated string. Expected delimiter: {0}. Line {1}, position {2}.", quote, _currentLineNumber, _currentLinePosition);

            _buffer.Append('\0');
            break;
          case '\\':
            if ((currentChar = MoveNext()) != '\0' || !_end)
            {
              switch (currentChar)
              {
                case 'b':
                  _buffer.Append('\b');
                  break;
                case 't':
                  _buffer.Append('\t');
                  break;
                case 'n':
                  _buffer.Append('\n');
                  break;
                case 'f':
                  _buffer.Append('\f');
                  break;
                case 'r':
                  _buffer.Append('\r');
                  break;
                case '\\':
                  _buffer.Append('\\');
                  break;
                case '"':
                case '\'':
                case '/':
                  _buffer.Append(currentChar);
                  break;
                case 'u':
                  char[] hexValues = new char[4];
                  for (int i = 0; i < hexValues.Length; i++)
                  {
                    if ((currentChar = MoveNext()) != '\0' || !_end)
                      hexValues[i] = currentChar;
                    else
                      throw CreateJsonReaderException("Unexpected end while parsing unicode character. Line {0}, position {1}.", _currentLineNumber, _currentLinePosition);
                  }

                  char hexChar = Convert.ToChar(int.Parse(new string(hexValues), NumberStyles.HexNumber, NumberFormatInfo.InvariantInfo));
                  _buffer.Append(hexChar);
                  break;
                default:
                  throw CreateJsonReaderException("Bad JSON escape sequence: {0}. Line {1}, position {2}.", @"\" + currentChar, _currentLineNumber, _currentLinePosition);
              }
            }
            else
            {
              throw CreateJsonReaderException("Unterminated string. Expected delimiter: {0}. Line {1}, position {2}.", quote, _currentLineNumber, _currentLinePosition);
            }
            break;
          case '"':
          case '\'':
            if (currentChar == quote)
            {
              return;
            }
            else
            {
              _buffer.Append(currentChar);
            }
            break;
          default:
            _buffer.Append(currentChar);
            break;
        }
      }
    }

    private JsonReaderException CreateJsonReaderException(string format, params object[] args)
    {
      string message = format.FormatWith(CultureInfo.InvariantCulture, args);
      return new JsonReaderException(message, null, _currentLineNumber, _currentLinePosition);
    }

    private void ParseDate(string text)
    {
      string value = text.Substring(6, text.Length - 8);
      DateTimeKind kind = DateTimeKind.Utc;

      int index = value.IndexOf('+', 1);

      if (index == -1)
        index = value.IndexOf('-', 1);

      if (index != -1)
      {
        kind = DateTimeKind.Local;
        value = value.Substring(0, index);
      }

      long javaScriptTicks = long.Parse(value, NumberStyles.Integer, CultureInfo.InvariantCulture);
      DateTime utcDateTime = JsonConvert.ConvertJavaScriptTicksToDateTime(javaScriptTicks);
      DateTime dateTime;

      switch (kind)
      {
        case DateTimeKind.Unspecified:
          dateTime = DateTime.SpecifyKind(utcDateTime.ToLocalTime(), DateTimeKind.Unspecified);
          break;
        case DateTimeKind.Local:
          dateTime = utcDateTime.ToLocalTime();
          break;
        default:
          dateTime = utcDateTime;
          break;
      }

      SetToken(JsonToken.Date, dateTime);
    }

    private const int LineFeedValue = StringUtils.LineFeed;
    private const int CarriageReturnValue = StringUtils.CarriageReturn;

    private char MoveNext()
    {
      int value = _reader.Read();

      switch (value)
      {
        case -1:
          _end = true;
          return '\0';
        case CarriageReturnValue:
          if (_reader.Peek() == LineFeedValue)
            _reader.Read();

          _currentLineNumber++;
          _currentLinePosition = 0;
          break;
        case LineFeedValue:
          _currentLineNumber++;
          _currentLinePosition = 0;
          break;
        default:
          _currentLinePosition++;
          break;
      }

      return (char)value;
    }

    private bool HasNext()
    {
      return (_reader.Peek() != -1);
    }

    private int PeekNext()
    {
      return _reader.Peek();
    }

    /// <summary>
    /// Reads the next JSON token from the stream.
    /// </summary>
    /// <returns>
    /// true if the next token was read successfully; false if there are no more tokens to read.
    /// </returns>
    public override bool Read()
    {
      while (true)
      {
        char currentChar;
        if (_lastChar != null)
        {
          currentChar = _lastChar.Value;
          _lastChar = null;
        }
        else
        {
          currentChar = MoveNext();
        }

        if (currentChar == '\0' && _end)
          return false;

        switch (CurrentState)
        {
          case State.Start:
          case State.Property:
          case State.Array:
          case State.ArrayStart:
          case State.Constructor:
          case State.ConstructorStart:
            return ParseValue(currentChar);
          case State.Complete:
            break;
          case State.Object:
          case State.ObjectStart:
            return ParseObject(currentChar);
          case State.PostValue:
            // returns true if it hits
            // end of object or array
            if (ParsePostValue(currentChar))
              return true;
            break;
          case State.Closed:
            break;
          case State.Error:
            break;
          default:
            throw CreateJsonReaderException("Unexpected state: {0}. Line {1}, position {2}.", CurrentState, _currentLineNumber, _currentLinePosition);
        }
      }
    }

    /// <summary>
    /// Reads the next JSON token from the stream as a <see cref="T:Byte[]"/>.
    /// </summary>
    /// <returns>
    /// A <see cref="T:Byte[]"/> or a null reference if the next JSON token is null.
    /// </returns>
    public override byte[] ReadAsBytes()
    {
      while (true)
      {
        char currentChar;
        if (_lastChar != null)
        {
          currentChar = _lastChar.Value;
          _lastChar = null;
        }
        else
        {
          currentChar = MoveNext();
        }

        if (currentChar == '\0' && _end)
          throw CreateJsonReaderException("Unexpected end when reading bytes: Line {0}, position {1}.", _currentLineNumber, _currentLinePosition);

        switch (CurrentState)
        {
          case State.PostValue:
          case State.Start:
          case State.Property:
          case State.Array:
          case State.ArrayStart:
          case State.Constructor:
          case State.ConstructorStart:
            do
            {
              switch (currentChar)
              {
                case '"':
                case '\'':
                  ReadStringIntoBuffer(currentChar);

                  byte[] data;
                  if (_buffer.Position == 0)
                  {
                    data = new byte[0];
                  }
                  else
                  {
                    data = Convert.FromBase64CharArray(_buffer.GetInternalBuffer(), 0, _buffer.Position);
                    _buffer.Position = 0;
                  }

                  SetToken(JsonToken.Bytes, data);

                  return data;
                case 'n':
                  ParseNull();
                  return null;
                case ' ':
                case StringUtils.Tab:
                case StringUtils.LineFeed:
                case StringUtils.CarriageReturn:
                  // eat
                  break;
                case ',':
                  SetStateBasedOnCurrent();
                  break;
                default:
                  if (char.IsWhiteSpace(currentChar))
                  {
                    // eat
                  }
                  else
                  {
                    throw CreateJsonReaderException("Unexpected character encountered while parsing value: {0}. Line {1}, position {2}.", currentChar, _currentLineNumber, _currentLinePosition);
                  }
                  break;
              }
            } while ((currentChar = MoveNext()) != '\0' || !_end);
            break;
          default:
            throw CreateJsonReaderException("Unexpected state: {0}. Line {1}, position {2}.", CurrentState, _currentLineNumber, _currentLinePosition);
        }
      }
    }

    private bool ParsePostValue(char currentChar)
    {
      do
      {
        switch (currentChar)
        {
          case '}':
            SetToken(JsonToken.EndObject);
            return true;
          case ']':
            SetToken(JsonToken.EndArray);
            return true;
          case ')':
            SetToken(JsonToken.EndConstructor);
            return true;
          case '/':
            ParseComment();
            return true;
          case ',':
            // finished parsing
            SetStateBasedOnCurrent();
            return false;
          case ' ':
          case StringUtils.Tab:
          case StringUtils.LineFeed:
          case StringUtils.CarriageReturn:
            // eat
            break;
          default:
            if (char.IsWhiteSpace(currentChar))
            {
              // eat
            }
            else
            {
              throw CreateJsonReaderException("After parsing a value an unexpected character was encountered: {0}. Line {1}, position {2}.", currentChar, _currentLineNumber, _currentLinePosition);
            }
            break;
        }
      } while ((currentChar = MoveNext()) != '\0' || !_end);

      return false;
    }

    private bool ParseObject(char currentChar)
    {
      do
      {
        switch (currentChar)
        {
          case '}':
            SetToken(JsonToken.EndObject);
            return true;
          case '/':
            ParseComment();
            return true;
          case ' ':
          case StringUtils.Tab:
          case StringUtils.LineFeed:
          case StringUtils.CarriageReturn:
            // eat
            break;
          default:
            if (char.IsWhiteSpace(currentChar))
            {
              // eat
            }
            else
            {
              return ParseProperty(currentChar);
            }
            break;
        }
      } while ((currentChar = MoveNext()) != '\0' || !_end);

      return false;
    }

    private bool ParseProperty(char firstChar)
    {
      char currentChar = firstChar;
      char quoteChar;

      if (ValidIdentifierChar(currentChar))
      {
        quoteChar = '\0';
        currentChar = ParseUnquotedProperty(currentChar);
      }
      else if (currentChar == '"' || currentChar == '\'')
      {
        quoteChar = currentChar;
        ReadStringIntoBuffer(quoteChar);
        currentChar = MoveNext();
      }
      else
      {
        throw CreateJsonReaderException("Invalid property identifier character: {0}. Line {1}, position {2}.", currentChar, _currentLineNumber, _currentLinePosition);
      }

      if (currentChar != ':')
      {
        currentChar = MoveNext();

        // finished property. skip any whitespace and move to colon
        EatWhitespace(currentChar, false, out currentChar);

        if (currentChar != ':')
          throw CreateJsonReaderException("Invalid character after parsing property name. Expected ':' but got: {0}. Line {1}, position {2}.", currentChar, _currentLineNumber, _currentLinePosition);
      }

      SetToken(JsonToken.PropertyName, _buffer.ToString());
      QuoteChar = quoteChar;
      _buffer.Position = 0;

      return true;
    }

    private bool ValidIdentifierChar(char value)
    {
      return (char.IsLetterOrDigit(value) || value == '_' || value == '$');
    }

    private char ParseUnquotedProperty(char firstChar)
    {
      // parse unquoted property name until whitespace or colon
      _buffer.Append(firstChar);

      char currentChar;

      while ((currentChar = MoveNext()) != '\0' || !_end)
      {
        if (char.IsWhiteSpace(currentChar) || currentChar == ':')
        {
          return currentChar;
        }
        else if (ValidIdentifierChar(currentChar))
        {
          _buffer.Append(currentChar);
        }
        else
        {
          throw CreateJsonReaderException("Invalid JavaScript property identifier character: {0}. Line {1}, position {2}.", currentChar, _currentLineNumber, _currentLinePosition);
        }
      }

      throw CreateJsonReaderException("Unexpected end when parsing unquoted property name. Line {0}, position {1}.", _currentLineNumber, _currentLinePosition);
    }

    private bool ParseValue(char currentChar)
    {
      do
      {
        switch (currentChar)
        {
          case '"':
          case '\'':
            ParseString(currentChar);
            return true;
          case 't':
            ParseTrue();
            return true;
          case 'f':
            ParseFalse();
            return true;
          case 'n':
            if (HasNext())
            {
              char next = (char)PeekNext();

              if (next == 'u')
                ParseNull();
              else if (next == 'e')
                ParseConstructor();
              else
                throw CreateJsonReaderException("Unexpected character encountered while parsing value: {0}. Line {1}, position {2}.", currentChar, _currentLineNumber, _currentLinePosition);
            }
            else
            {
              throw CreateJsonReaderException("Unexpected end. Line {0}, position {1}.", _currentLineNumber, _currentLinePosition);
            }
            return true;
          case 'N':
            ParseNumberNaN();
            return true;
          case 'I':
            ParseNumberPositiveInfinity();
            return true;
          case '-':
            if (PeekNext() == 'I')
              ParseNumberNegativeInfinity();
            else
              ParseNumber(currentChar);
            return true;
          case '/':
            ParseComment();
            return true;
          case 'u':
            ParseUndefined();
            return true;
          case '{':
            SetToken(JsonToken.StartObject);
            return true;
          case '[':
            SetToken(JsonToken.StartArray);
            return true;
          case '}':
            SetToken(JsonToken.EndObject);
            return true;
          case ']':
            SetToken(JsonToken.EndArray);
            return true;
          case ',':
            SetToken(JsonToken.Undefined);
            return true;
          case ')':
            SetToken(JsonToken.EndConstructor);
            return true;
          case ' ':
          case StringUtils.Tab:
          case StringUtils.LineFeed:
          case StringUtils.CarriageReturn:
            // eat
            break;
          default:
            if (char.IsWhiteSpace(currentChar))
            {
              // eat
            }
            else if (char.IsNumber(currentChar) || currentChar == '-' || currentChar == '.')
            {
              ParseNumber(currentChar);
              return true;
            }
            else
            {
              throw CreateJsonReaderException("Unexpected character encountered while parsing value: {0}. Line {1}, position {2}.", currentChar, _currentLineNumber, _currentLinePosition);
            }
            break;
        }
      } while ((currentChar = MoveNext()) != '\0' || !_end);

      return false;
    }

    private bool EatWhitespace(char initialChar, bool oneOrMore, out char finalChar)
    {
      bool whitespace = false;
      char currentChar = initialChar;
      while (currentChar == ' ' || char.IsWhiteSpace(currentChar))
      {
        whitespace = true;
        currentChar = MoveNext();
      }

      finalChar = currentChar;

      return (!oneOrMore || whitespace);
    }

    private void ParseConstructor()
    {
      if (MatchValue('n', "new", true))
      {
        char currentChar = MoveNext();

        if (EatWhitespace(currentChar, true, out currentChar))
        {
          while (char.IsLetter(currentChar))
          {
            _buffer.Append(currentChar);
            currentChar = MoveNext();
          }

          EatWhitespace(currentChar, false, out currentChar);

          if (currentChar != '(')
            throw CreateJsonReaderException("Unexpected character while parsing constructor: {0}. Line {1}, position {2}.", currentChar, _currentLineNumber, _currentLinePosition);

          string constructorName = _buffer.ToString();
          _buffer.Position = 0;

          SetToken(JsonToken.StartConstructor, constructorName);
        }
      }
    }

    private void ParseNumber(char firstChar)
    {
      char currentChar = firstChar;
      bool nonBase10 = (firstChar == '0');

      // parse until seperator character or end
      bool end = false;
      do
      {
        if (IsSeperator(currentChar))
        {
          end = true;
          _lastChar = currentChar;
        }
        else
        {
          _buffer.Append(currentChar);
        }

      } while (!end && ((currentChar = MoveNext()) != '\0' || !_end));

      string number = _buffer.ToString();
      object numberValue;
      JsonToken numberType;

      if (number.IndexOf(".", StringComparison.OrdinalIgnoreCase) != -1
        || number.IndexOf("e", StringComparison.OrdinalIgnoreCase) != -1)
      {
        numberValue = Convert.ToDouble(number, CultureInfo.InvariantCulture);
        numberType = JsonToken.Float;
      }
      else if (nonBase10)
      {
        numberValue = number.StartsWith("0x", StringComparison.OrdinalIgnoreCase)
          ? Convert.ToInt64(number, 16)
          : Convert.ToInt64(number, 8);
        numberType = JsonToken.Integer;
      }
      else
      {
        numberValue = Convert.ToInt64(number, CultureInfo.InvariantCulture);
        numberType = JsonToken.Integer;
      }

      _buffer.Position = 0;

      SetToken(numberType, numberValue);
    }

    private void ParseComment()
    {
      // should have already parsed / character before reaching this method

      char currentChar = MoveNext();

      if (currentChar == '*')
      {
        while ((currentChar = MoveNext()) != '\0' || !_end)
        {
          if (currentChar == '*')
          {
            if ((currentChar = MoveNext()) != '\0' || !_end)
            {
              if (currentChar == '/')
              {
                break;
              }
              else
              {
                _buffer.Append('*');
                _buffer.Append(currentChar);
              }
            }
          }
          else
          {
            _buffer.Append(currentChar);
          }
        }
      }
      else
      {
        throw CreateJsonReaderException("Error parsing comment. Expected: *. Line {0}, position {1}.", _currentLineNumber, _currentLinePosition);
      }

      SetToken(JsonToken.Comment, _buffer.ToString());

      _buffer.Position = 0;
    }

    private bool MatchValue(char firstChar, string value)
    {
      char currentChar = firstChar;

      int i = 0;
      do
      {
        if (currentChar != value[i])
        {
          break;
        }
        i++;
      }
      while (i < value.Length && ((currentChar = MoveNext()) != '\0' || !_end));

      return (i == value.Length);
    }

    private bool MatchValue(char firstChar, string value, bool noTrailingNonSeperatorCharacters)
    {
      // will match value and then move to the next character, checking that it is a seperator character
      bool match = MatchValue(firstChar, value);

      if (!noTrailingNonSeperatorCharacters)
      {
        return match;
      }
      else
      {
        int c = PeekNext();
        char next = (c != -1) ? (char) c : '\0';
        bool matchAndNoTrainingNonSeperatorCharacters = (match && (next == '\0' || IsSeperator(next)));

        return matchAndNoTrainingNonSeperatorCharacters;
      }
    }

    private bool IsSeperator(char c)
    {
      switch (c)
      {
        case '}':
        case ']':
        case ',':
          return true;
        case '/':
          // check next character to see if start of a comment
          return (HasNext() && PeekNext() == '*');
        case ')':
          if (CurrentState == State.Constructor || CurrentState == State.ConstructorStart)
            return true;
          break;
        case ' ':
        case StringUtils.Tab:
        case StringUtils.LineFeed:
        case StringUtils.CarriageReturn:
          return true;
        default:
          if (char.IsWhiteSpace(c))
            return true;
          break;
      }

      return false;
    }

    private void ParseTrue()
    {
      // check characters equal 'true'
      // and that it is followed by either a seperator character
      // or the text ends
      if (MatchValue('t', JsonConvert.True, true))
      {
        SetToken(JsonToken.Boolean, true);
      }
      else
      {
        throw CreateJsonReaderException("Error parsing boolean value. Line {0}, position {1}.", _currentLineNumber, _currentLinePosition);
      }
    }

    private void ParseNull()
    {
      if (MatchValue('n', JsonConvert.Null, true))
      {
        SetToken(JsonToken.Null);
      }
      else
      {
        throw CreateJsonReaderException("Error parsing null value. Line {0}, position {1}.", _currentLineNumber, _currentLinePosition);
      }
    }

    private void ParseUndefined()
    {
      if (MatchValue('u', JsonConvert.Undefined, true))
      {
        SetToken(JsonToken.Undefined);
      }
      else
      {
        throw CreateJsonReaderException("Error parsing undefined value. Line {0}, position {1}.", _currentLineNumber, _currentLinePosition);
      }
    }

    private void ParseFalse()
    {
      if (MatchValue('f', JsonConvert.False, true))
      {
        SetToken(JsonToken.Boolean, false);
      }
      else
      {
        throw CreateJsonReaderException("Error parsing boolean value. Line {0}, position {1}.", _currentLineNumber, _currentLinePosition);
      }
    }

    private void ParseNumberNegativeInfinity()
    {
      if (MatchValue('-', JsonConvert.NegativeInfinity, true))
      {
        SetToken(JsonToken.Float, double.NegativeInfinity);
      }
      else
      {
        throw CreateJsonReaderException("Error parsing negative infinity value. Line {0}, position {1}.", _currentLineNumber, _currentLinePosition);
      }
    }

    private void ParseNumberPositiveInfinity()
    {
      if (MatchValue('I', JsonConvert.PositiveInfinity, true))
      {
        SetToken(JsonToken.Float, double.PositiveInfinity);
      }
      else
      {
        throw CreateJsonReaderException("Error parsing positive infinity value. Line {0}, position {1}.", _currentLineNumber, _currentLinePosition);
      }
    }

    private void ParseNumberNaN()
    {
      if (MatchValue('N', JsonConvert.NaN, true))
      {
        SetToken(JsonToken.Float, double.NaN);
      }
      else
      {
        throw CreateJsonReaderException("Error parsing NaN value. Line {0}, position {1}.", _currentLineNumber, _currentLinePosition);
      }
    }

    /// <summary>
    /// Changes the state to closed. 
    /// </summary>
    public override void Close()
    {
      base.Close();

      if (_reader != null)
        _reader.Close();

      if (_buffer != null)
        _buffer.Clear();
    }

    /// <summary>
    /// Gets a value indicating whether the class can return line information.
    /// </summary>
    /// <returns>
    /// 	<c>true</c> if LineNumber and LinePosition can be provided; otherwise, <c>false</c>.
    /// </returns>
    public bool HasLineInfo()
    {
      return true;
    }

    /// <summary>
    /// Gets the current line number.
    /// </summary>
    /// <value>
    /// The current line number or 0 if no line information is available (for example, HasLineInfo returns false).
    /// </value>
    public int LineNumber
    {
      get
      {
        if (CurrentState == State.Start)
          return 0;

        return _currentLineNumber;
      }
    }

    /// <summary>
    /// Gets the current line position.
    /// </summary>
    /// <value>
    /// The current line position or 0 if no line information is available (for example, HasLineInfo returns false).
    /// </value>
    public int LinePosition
    {
      get { return _currentLinePosition; }
    }
  }
}

L	V	Source
1		#region License
2		// Copyright (c) 2007 James Newton-King
3		//
4		// Permission is hereby granted, free of charge, to any person
5		// obtaining a copy of this software and associated documentation
6		// files (the "Software"), to deal in the Software without
7		// restriction, including without limitation the rights to use,
8		// copy, modify, merge, publish, distribute, sublicense, and/or sell
9		// copies of the Software, and to permit persons to whom the
10		// Software is furnished to do so, subject to the following
11		// conditions:
12		//
13		// The above copyright notice and this permission notice shall be
14		// included in all copies or substantial portions of the Software.
15		//
16		// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
17		// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
18		// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
19		// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
20		// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
21		// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
22		// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
23		// OTHER DEALINGS IN THE SOFTWARE.
24		#endregion
25
26		using System;
27		using System.Collections.Generic;
28		using System.Text;
29		using System.IO;
30		using System.Xml;
31		using System.Globalization;
32		using Newtonsoft.Json.Utilities;
33
34		namespace Newtonsoft.Json
35		{
36		/// <summary>
37		/// Represents a reader that provides fast, non-cached, forward-only access to serialized Json data.
38		/// </summary>
39		public class JsonTextReader : JsonReader, IJsonLineInfo
40		{
41		private readonly TextReader _reader;
42		private readonly StringBuffer _buffer;
43		private char? _lastChar;
44		private int _currentLinePosition;
45		private int _currentLineNumber;
46		private bool _end;
47
48		/// <summary>
49		/// Initializes a new instance of the <see cref="JsonReader"/> class with the specified <see cref="TextReader"/>.
50		/// </summary>
51		/// <param name="reader">The <c>TextReader</c> containing the XML data to read.</param>
52	5439	public JsonTextReader(TextReader reader)
53		{
54	5439	if (reader == null)
55	1	throw new ArgumentNullException("reader");
56
57	5438	_reader = reader;
58	5438	_buffer = new StringBuffer(4096);
59	5438	_currentLineNumber = 1;
60	5438	}
61
62		private void ParseString(char quote)
63		{
64	61309	ReadStringIntoBuffer(quote);
65
66	61305	string text = _buffer.ToString();
67	61305	_buffer.Position = 0;
68
69	61305	if (text.StartsWith("/Date(", StringComparison.Ordinal) && text.EndsWith(")/", StringComparison.Ordinal))
70		{
71	20056	ParseDate(text);
72		}
73		else
74		{
75	41249	SetToken(JsonToken.String, text);
76	41249	QuoteChar = quote;
77		}
78	61305	}
79
80		private void ReadStringIntoBuffer(char quote)
81		{
82	1956661	while (true)
83		{
84	1956661	char currentChar = MoveNext();
85
86	1956661	switch (currentChar)
87		{
88		case '\0':
89	3	if (_end)
90	2	throw CreateJsonReaderException("Unterminated string. Expected delimiter: {0}. Line {1}, position {2}.", quote, _currentLineNumber, _currentLinePosition);
91
92	1	_buffer.Append('\0');
93	1	break;
94		case '\\':
95	45186	if ((currentChar = MoveNext()) != '\0' \|\| !_end)
96		{
97	45185	switch (currentChar)
98		{
99		case 'b':
100	6	_buffer.Append('\b');
101	6	break;
102		case 't':
103	8	_buffer.Append('\t');
104	8	break;
105		case 'n':
106	9	_buffer.Append('\n');
107	9	break;
108		case 'f':
109	6	_buffer.Append('\f');
110	6	break;
111		case 'r':
112	9	_buffer.Append('\r');
113	9	break;
114		case '\\':
115	17	_buffer.Append('\\');
116	17	break;
117		case '"':
118		case '\'':
119		case '/':
120	40121	_buffer.Append(currentChar);
121	40121	break;
122		case 'u':
123	5008	char[] hexValues = new char[4];
124	5008	for (int i = 0; i < hexValues.Length; i++)
125		{
126	20032	if ((currentChar = MoveNext()) != '\0' \|\| !_end)
127	20031	hexValues[i] = currentChar;
128		else
129	1	throw CreateJsonReaderException("Unexpected end while parsing unicode character. Line {0}, position {1}.", _currentLineNumber, _currentLinePosition);
130		}
131
132	5007	char hexChar = Convert.ToChar(int.Parse(new string(hexValues), NumberStyles.HexNumber, NumberFormatInfo.InvariantInfo));
133	5007	_buffer.Append(hexChar);
134	5007	break;
135		default:
136	1	throw CreateJsonReaderException("Bad JSON escape sequence: {0}. Line {1}, position {2}.", @"\" + currentChar, _currentLineNumber, _currentLinePosition);
137		}
138		}
139		else
140		{
141	1	throw CreateJsonReaderException("Unterminated string. Expected delimiter: {0}. Line {1}, position {2}.", quote, _currentLineNumber, _currentLinePosition);
142		}
143	45183	break;
144		case '"':
145		case '\'':
146	158121	if (currentChar == quote)
147		{
148	158105	return;
149		}
150		else
151		{
152	16	_buffer.Append(currentChar);
153		}
154	16	break;
155		default:
156	1753351	_buffer.Append(currentChar);
157	1753351	break;
158		}
159		}
160	158105	}
161
162		private JsonReaderException CreateJsonReaderException(string format, params object[] args)
163		{
164	11	string message = format.FormatWith(CultureInfo.InvariantCulture, args);
165	11	return new JsonReaderException(message, null, _currentLineNumber, _currentLinePosition);
166	11	}
167
168		private void ParseDate(string text)
169		{
170	20056	string value = text.Substring(6, text.Length - 8);
171	20056	DateTimeKind kind = DateTimeKind.Utc;
172
173	20056	int index = value.IndexOf('+', 1);
174
175	20056	if (index == -1)
176	47	index = value.IndexOf('-', 1);
177
178	20056	if (index != -1)
179		{
180	20015	kind = DateTimeKind.Local;
181	20015	value = value.Substring(0, index);
182		}
183
184	20056	long javaScriptTicks = long.Parse(value, NumberStyles.Integer, CultureInfo.InvariantCulture);
185	20056	DateTime utcDateTime = JsonConvert.ConvertJavaScriptTicksToDateTime(javaScriptTicks);
186		DateTime dateTime;
187
188	20056	switch (kind)
189		{
190		case DateTimeKind.Unspecified:
191	0	dateTime = DateTime.SpecifyKind(utcDateTime.ToLocalTime(), DateTimeKind.Unspecified);
192	0	break;
193		case DateTimeKind.Local:
194	20015	dateTime = utcDateTime.ToLocalTime();
195	20015	break;
196		default:
197	41	dateTime = utcDateTime;
198	41	break;
199		}
200
201	20056	SetToken(JsonToken.Date, dateTime);
202	20056	}
203
204		private const int LineFeedValue = StringUtils.LineFeed;
205		private const int CarriageReturnValue = StringUtils.CarriageReturn;
206
207		private char MoveNext()
208		{
209	2586278	int value = _reader.Read();
210
211	2586278	switch (value)
212		{
213		case -1:
214	217	_end = true;
215	217	return '\0';
216		case CarriageReturnValue:
217	2345	if (_reader.Peek() == LineFeedValue)
218	2345	_reader.Read();
219
220	2345	_currentLineNumber++;
221	2345	_currentLinePosition = 0;
222	2345	break;
223		case LineFeedValue:
224	1	_currentLineNumber++;
225	1	_currentLinePosition = 0;
226	1	break;
227		default:
228	2583715	_currentLinePosition++;
229	2583715	break;
230		}
231
232	2586061	return (char)value;
233	2586278	}
234
235		private bool HasNext()
236		{
237	10131	return (_reader.Peek() != -1);
238	10131	}
239
240		private int PeekNext()
241		{
242	20340	return _reader.Peek();
243	20340	}
244
245		/// <summary>
246		/// Reads the next JSON token from the stream.
247		/// </summary>
248		/// <returns>
249		/// true if the next token was read successfully; false if there are no more tokens to read.
250		/// </returns>
251		public override bool Read()
252		{
253	347775	while (true)
254		{
255		char currentChar;
256	347775	if (_lastChar != null)
257		{
258	20490	currentChar = _lastChar.Value;
259	20490	_lastChar = null;
260		}
261		else
262		{
263	327285	currentChar = MoveNext();
264		}
265
266	347775	if (currentChar == '\0' && _end)
267	194	return false;
268
269	347581	switch (CurrentState)
270		{
271		case State.Start:
272		case State.Property:
273		case State.Array:
274		case State.ArrayStart:
275		case State.Constructor:
276		case State.ConstructorStart:
277	128030	return ParseValue(currentChar);
278		case State.Complete:
279	0	break;
280		case State.Object:
281		case State.ObjectStart:
282	96964	return ParseObject(currentChar);
283		case State.PostValue:
284		// returns true if it hits
285		// end of object or array
286	122587	if (ParsePostValue(currentChar))
287	35967	return true;
288	86619	break;
289		case State.Closed:
290	0	break;
291		case State.Error:
292	0	break;
293		default:
294	0	throw CreateJsonReaderException("Unexpected state: {0}. Line {1}, position {2}.", CurrentState, _currentLineNumber, _currentLinePosition);
295		}
296		}
297	261148	}
298
299		/// <summary>
300		/// Reads the next JSON token from the stream as a <see cref="T:Byte[]"/>.
301		/// </summary>
302		/// <returns>
303		/// A <see cref="T:Byte[]"/> or a null reference if the next JSON token is null.
304		/// </returns>
305		public override byte[] ReadAsBytes()
306		{
307	11	while (true)
308		{
309		char currentChar;
310	11	if (_lastChar != null)
311		{
312	1	currentChar = _lastChar.Value;
313	1	_lastChar = null;
314		}
315		else
316		{
317	10	currentChar = MoveNext();
318		}
319
320	11	if (currentChar == '\0' && _end)
321	1	throw CreateJsonReaderException("Unexpected end when reading bytes: Line {0}, position {1}.", _currentLineNumber, _currentLinePosition);
322
323	10	switch (CurrentState)
324		{
325		case State.PostValue:
326		case State.Start:
327		case State.Property:
328		case State.Array:
329		case State.ArrayStart:
330		case State.Constructor:
331		case State.ConstructorStart:
332		do
333		{
334	14	switch (currentChar)
335		{
336		case '"':
337		case '\'':
338	7	ReadStringIntoBuffer(currentChar);
339
340		byte[] data;
341	6	if (_buffer.Position == 0)
342		{
343	2	data = new byte[0];
344		}
345		else
346		{
347	4	data = Convert.FromBase64CharArray(_buffer.GetInternalBuffer(), 0, _buffer.Position);
348	4	_buffer.Position = 0;
349		}
350
351	6	SetToken(JsonToken.Bytes, data);
352
353	6	return data;
354		case 'n':
355	1	ParseNull();
356	1	return null;
357		case ' ':
358		case StringUtils.Tab:
359		case StringUtils.LineFeed:
360		case StringUtils.CarriageReturn:
361		// eat
362	4	break;
363		case ',':
364	1	SetStateBasedOnCurrent();
365	1	break;
366		default:
367	1	if (char.IsWhiteSpace(currentChar))
368		{
369		// eat
370		}
371		else
372		{
373	1	throw CreateJsonReaderException("Unexpected character encountered while parsing value: {0}. Line {1}, position {2}.", currentChar, _currentLineNumber, _currentLinePosition);
374		}
375	0	break;
376		}
377	5	} while ((currentChar = MoveNext()) != '\0' \|\| !_end);
378	1	break;
379		default:
380	0	throw CreateJsonReaderException("Unexpected state: {0}. Line {1}, position {2}.", CurrentState, _currentLineNumber, _currentLinePosition);
381		}
382		}
383	7	}
384
385		private bool ParsePostValue(char currentChar)
386		{
387		do
388		{
389	125738	switch (currentChar)
390		{
391		case '}':
392	25709	SetToken(JsonToken.EndObject);
393	25709	return true;
394		case ']':
395	10238	SetToken(JsonToken.EndArray);
396	10238	return true;
397		case ')':
398	13	SetToken(JsonToken.EndConstructor);
399	13	return true;
400		case '/':
401	7	ParseComment();
402	7	return true;
403		case ',':
404		// finished parsing
405	86614	SetStateBasedOnCurrent();
406	86614	return false;
407		case ' ':
408		case StringUtils.Tab:
409		case StringUtils.LineFeed:
410		case StringUtils.CarriageReturn:
411		// eat
412	3156	break;
413		default:
414	1	if (char.IsWhiteSpace(currentChar))
415		{
416		// eat
417		}
418		else
419		{
420	1	throw CreateJsonReaderException("After parsing a value an unexpected character was encountered: {0}. Line {1}, position {2}.", currentChar, _currentLineNumber, _currentLinePosition);
421		}
422	0	break;
423		}
424	3156	} while ((currentChar = MoveNext()) != '\0' \|\| !_end);
425
426	5	return false;
427	122586	}
428
429		private bool ParseObject(char currentChar)
430		{
431		do
432		{
433	106918	switch (currentChar)
434		{
435		case '}':
436	28	SetToken(JsonToken.EndObject);
437	28	return true;
438		case '/':
439	2	ParseComment();
440	2	return true;
441		case ' ':
442		case StringUtils.Tab:
443		case StringUtils.LineFeed:
444		case StringUtils.CarriageReturn:
445		// eat
446	9954	break;
447		default:
448	96934	if (char.IsWhiteSpace(currentChar))
449		{
450		// eat
451		}
452		else
453		{
454	96934	return ParseProperty(currentChar);
455		}
456	0	break;
457		}
458	9954	} while ((currentChar = MoveNext()) != '\0' \|\| !_end);
459
460	0	return false;
461	96961	}
462
463		private bool ParseProperty(char firstChar)
464		{
465	96934	char currentChar = firstChar;
466		char quoteChar;
467
468	96934	if (ValidIdentifierChar(currentChar))
469		{
470	139	quoteChar = '\0';
471	139	currentChar = ParseUnquotedProperty(currentChar);
472		}
473	96795	else if (currentChar == '"' \|\| currentChar == '\'')
474		{
475	96794	quoteChar = currentChar;
476	96794	ReadStringIntoBuffer(quoteChar);
477	96794	currentChar = MoveNext();
478		}
479		else
480		{
481	1	throw CreateJsonReaderException("Invalid property identifier character: {0}. Line {1}, position {2}.", currentChar, _currentLineNumber, _currentLinePosition);
482		}
483
484	96932	if (currentChar != ':')
485		{
486	88	currentChar = MoveNext();
487
488		// finished property. skip any whitespace and move to colon
489	88	EatWhitespace(currentChar, false, out currentChar);
490
491	88	if (currentChar != ':')
492	1	throw CreateJsonReaderException("Invalid character after parsing property name. Expected ':' but got: {0}. Line {1}, position {2}.", currentChar, _currentLineNumber, _currentLinePosition);
493		}
494
495	96931	SetToken(JsonToken.PropertyName, _buffer.ToString());
496	96931	QuoteChar = quoteChar;
497	96931	_buffer.Position = 0;
498
499	96931	return true;
500	96931	}