Extracted StringReader and StringWriter from JsonParser

Split `Internals/` folder into `Data/`, `Deserialization/`, `Serialization/`

include/ArduinoJson/Deserialization/Comments.hpp

@@ -0,0 +1,76 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#pragma once
+
+namespace ArduinoJson {
+namespace Internals {
+template <typename TInput>
+void skipSpacesAndComments(TInput& input) {
+  for (;;) {
+    switch (input.peek()) {
+      // spaces
+      case ' ':
+      case '\t':
+      case '\r':
+      case '\n':
+        input.skip();
+        continue;
+
+      // comments
+      case '/':
+        switch (input.peekNext()) {
+          // C-style block comment
+          case '*':
+            input.skip();  // skip '/'
+            input.skip();  // skip '*'
+            for (;;) {
+              switch (input.peek()) {
+                case '\0':
+                  return;
+                case '*':
+                  input.skip();  // skip '*'
+                  if (input.peek() == '/') {
+                    input.skip();  // skip '/'
+                    return;
+                  }
+                  break;
+                default:
+                  input.skip();
+              }
+            }
+            break;
+
+          // C++-style line comment
+          case '/':
+            input.skip();  // skip '/'
+            for (;;) {
+              switch (input.peek()) {
+                case '\0':
+                  return;
+                case '\n':
+                  input.skip();
+                  return;
+                default:
+                  input.skip();
+              }
+            }
+            return;
+
+          // not a comment, just a '/'
+          default:
+            return;
+        }
+        break;
+
+      default:
+        return;
+    }
+  }
+}
+}
+}

include/ArduinoJson/Deserialization/JsonParser.hpp

@@ -0,0 +1,71 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#pragma once
+
+#include "../JsonBuffer.hpp"
+#include "../JsonVariant.hpp"
+#include "StringReader.hpp"
+#include "StringWriter.hpp"
+
+namespace ArduinoJson {
+namespace Internals {
+
+// Parse JSON string to create JsonArrays and JsonObjects
+// This internal class is not indended to be used directly.
+// Instead, use JsonBuffer.parseArray() or .parseObject()
+class JsonParser {
+ public:
+  JsonParser(JsonBuffer *buffer, char *json, uint8_t nestingLimit)
+      : _buffer(buffer),
+        _reader(json),
+        _writer(json),
+        _nestingLimit(nestingLimit) {}
+
+  JsonArray &parseArray();
+  JsonObject &parseObject();
+
+  JsonVariant parseVariant() {
+    JsonVariant result;
+    parseAnythingTo(&result);
+    return result;
+  }
+
+ private:
+  static bool eat(StringReader &, char charToSkip);
+  FORCE_INLINE bool eat(char charToSkip) {
+    return eat(_reader, charToSkip);
+  }
+
+  const char *parseString();
+  bool parseAnythingTo(JsonVariant *destination);
+  FORCE_INLINE bool parseAnythingToUnsafe(JsonVariant *destination);
+
+  inline bool parseArrayTo(JsonVariant *destination);
+  inline bool parseObjectTo(JsonVariant *destination);
+  inline bool parseStringTo(JsonVariant *destination);
+
+  static inline bool isInRange(char c, char min, char max) {
+    return min <= c && c <= max;
+  }
+
+  static inline bool isLetterOrNumber(char c) {
+    return isInRange(c, '0', '9') || isInRange(c, 'a', 'z') ||
+           isInRange(c, 'A', 'Z') || c == '+' || c == '-' || c == '.';
+  }
+
+  static inline bool isQuote(char c) {
+    return c == '\'' || c == '\"';
+  }
+
+  JsonBuffer *_buffer;
+  StringReader _reader;
+  StringWriter _writer;
+  uint8_t _nestingLimit;
+};
+}
+}

include/ArduinoJson/Deserialization/JsonParserImpl.hpp

@@ -0,0 +1,184 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#pragma once
+
+#include "Comments.hpp"
+#include "JsonParser.hpp"
+
+inline bool ArduinoJson::Internals::JsonParser::eat(StringReader &reader,
+                                                    char charToSkip) {
+  skipSpacesAndComments(reader);
+  if (reader.peek() != charToSkip) return false;
+  reader.skip();
+  skipSpacesAndComments(reader);
+  return true;
+}
+
+inline bool ArduinoJson::Internals::JsonParser::parseAnythingTo(
+    JsonVariant *destination) {
+  if (_nestingLimit == 0) return false;
+  _nestingLimit--;
+  bool success = parseAnythingToUnsafe(destination);
+  _nestingLimit++;
+  return success;
+}
+
+inline bool ArduinoJson::Internals::JsonParser::parseAnythingToUnsafe(
+    JsonVariant *destination) {
+  skipSpacesAndComments(_reader);
+
+  switch (_reader.peek()) {
+    case '[':
+      return parseArrayTo(destination);
+
+    case '{':
+      return parseObjectTo(destination);
+
+    default:
+      return parseStringTo(destination);
+  }
+}
+
+inline ArduinoJson::JsonArray &
+ArduinoJson::Internals::JsonParser::parseArray() {
+  // Create an empty array
+  JsonArray &array = _buffer->createArray();
+
+  // Check opening braket
+  if (!eat('[')) goto ERROR_MISSING_BRACKET;
+  if (eat(']')) goto SUCCESS_EMPTY_ARRAY;
+
+  // Read each value
+  for (;;) {
+    // 1 - Parse value
+    JsonVariant value;
+    if (!parseAnythingTo(&value)) goto ERROR_INVALID_VALUE;
+    if (!array.add(value)) goto ERROR_NO_MEMORY;
+
+    // 2 - More values?
+    if (eat(']')) goto SUCCES_NON_EMPTY_ARRAY;
+    if (!eat(',')) goto ERROR_MISSING_COMMA;
+  }
+
+SUCCESS_EMPTY_ARRAY:
+SUCCES_NON_EMPTY_ARRAY:
+  return array;
+
+ERROR_INVALID_VALUE:
+ERROR_MISSING_BRACKET:
+ERROR_MISSING_COMMA:
+ERROR_NO_MEMORY:
+  return JsonArray::invalid();
+}
+
+inline bool ArduinoJson::Internals::JsonParser::parseArrayTo(
+    JsonVariant *destination) {
+  JsonArray &array = parseArray();
+  if (!array.success()) return false;
+
+  *destination = array;
+  return true;
+}
+
+inline ArduinoJson::JsonObject &
+ArduinoJson::Internals::JsonParser::parseObject() {
+  // Create an empty object
+  JsonObject &object = _buffer->createObject();
+
+  // Check opening brace
+  if (!eat('{')) goto ERROR_MISSING_BRACE;
+  if (eat('}')) goto SUCCESS_EMPTY_OBJECT;
+
+  // Read each key value pair
+  for (;;) {
+    // 1 - Parse key
+    const char *key = parseString();
+    if (!key) goto ERROR_INVALID_KEY;
+    if (!eat(':')) goto ERROR_MISSING_COLON;
+
+    // 2 - Parse value
+    JsonVariant value;
+    if (!parseAnythingTo(&value)) goto ERROR_INVALID_VALUE;
+    if (!object.set(key, value)) goto ERROR_NO_MEMORY;
+
+    // 3 - More keys/values?
+    if (eat('}')) goto SUCCESS_NON_EMPTY_OBJECT;
+    if (!eat(',')) goto ERROR_MISSING_COMMA;
+  }
+
+SUCCESS_EMPTY_OBJECT:
+SUCCESS_NON_EMPTY_OBJECT:
+  return object;
+
+ERROR_INVALID_KEY:
+ERROR_INVALID_VALUE:
+ERROR_MISSING_BRACE:
+ERROR_MISSING_COLON:
+ERROR_MISSING_COMMA:
+ERROR_NO_MEMORY:
+  return JsonObject::invalid();
+}
+
+inline bool ArduinoJson::Internals::JsonParser::parseObjectTo(
+    JsonVariant *destination) {
+  JsonObject &object = parseObject();
+  if (!object.success()) return false;
+
+  *destination = object;
+  return true;
+}
+
+inline const char *ArduinoJson::Internals::JsonParser::parseString() {
+  const char *str = _writer.startString();
+
+  char c = _reader.peek();
+
+  if (isQuote(c)) {  // quotes
+    _reader.skip();
+    char stopChar = c;
+    for (;;) {
+      c = _reader.peek();
+      if (c == '\0') break;
+      _reader.skip();
+
+      if (c == stopChar) break;
+
+      if (c == '\\') {
+        // replace char
+        c = Encoding::unescapeChar(_reader.peek());
+        if (c == '\0') break;
+        _reader.skip();
+      }
+
+      _writer.append(c);
+    }
+  } else {  // no quotes
+    for (;;) {
+      if (!isLetterOrNumber(c)) break;
+      _reader.skip();
+      _writer.append(c);
+      c = _reader.peek();
+    }
+  }
+
+  _writer.stopString();
+  return str;
+}
+
+inline bool ArduinoJson::Internals::JsonParser::parseStringTo(
+    JsonVariant *destination) {
+  bool hasQuotes = isQuote(_reader.peek());
+  const char *value = parseString();
+  if (value == NULL) return false;
+  if (hasQuotes) {
+    *destination = value;
+  } else {
+    *destination = RawJson(value);
+  }
+  return true;
+}

include/ArduinoJson/Deserialization/StringReader.hpp

@@ -0,0 +1,36 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#pragma once
+
+namespace ArduinoJson {
+namespace Internals {
+
+// Parse JSON string to create JsonArrays and JsonObjects
+// This internal class is not indended to be used directly.
+// Instead, use JsonBuffer.parseArray() or .parseObject()
+class StringReader {
+ public:
+  StringReader(const char *input) : _ptr(input ? input : "") {}
+
+  void skip() {
+    _ptr++;
+  }
+
+  char peek() const {
+    return _ptr[0];
+  }
+
+  char peekNext() const {
+    return _ptr[1];
+  }
+
+ private:
+  const char *_ptr;
+};
+}
+}

include/ArduinoJson/Deserialization/StringWriter.hpp

@@ -0,0 +1,36 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#pragma once
+
+namespace ArduinoJson {
+namespace Internals {
+
+// Parse JSON string to create JsonArrays and JsonObjects
+// This internal class is not indended to be used directly.
+// Instead, use JsonBuffer.parseArray() or .parseObject()
+class StringWriter {
+ public:
+  StringWriter(char *buffer) : _ptr(buffer) {}
+
+  const char *startString() {
+    return _ptr;
+  }
+
+  void stopString() {
+    *_ptr++ = 0;
+  }
+
+  void append(char c) {
+    *_ptr++ = c;
+  }
+
+ private:
+  char *_ptr;
+};
+}
+}