Basic support for reading and writing JSON objects.

runtime/vm/json.cc

+// Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+#include "vm/json.h"
+
+#include "platform/assert.h"
+#include "platform/utils.h"
+#include "vm/os.h"
+
+namespace dart {

[turnidge, 2012/04/09 22:26:42]

The classes in the header go "scanner, reader, writer" and the classes in this
file go "writer, reader, scanner."  This is a small thing , but if there isn't a
pressing reason for them to be different, it would be nice to have them
consistent.  It helps me when I'm bouncing between header and soure.  Your call.

[hausner, 2012/04/10 16:26:51]

I typically don't read source in a linear way, so I didn't notice the
discrepancy.
Order changed to match the header file.

On 2012/04/09 22:26:42, turnidge wrote:

+
+JSONWriter::JSONWriter(intptr_t buf_size) {
+  ASSERT(buf_size > 0);
+  buf_ = reinterpret_cast<char*>(malloc(buf_size));
+  buf_size_ = buf_size;
+  Clear();
+}
+
+
+JSONWriter::~JSONWriter() {
+  if (buf_ != NULL) {

[turnidge, 2012/04/09 22:26:42]

You don't need this if here.  It is safe to free/delete NULL.

[hausner, 2012/04/10 16:26:51]

Done.

+    delete buf_;

[turnidge, 2012/04/09 22:26:42]

Since you're using malloc above, should this be free()?  Either that or switch
the above to new[].

[hausner, 2012/04/10 16:26:51]

Nice catch, thank you.

On 2012/04/09 22:26:42, turnidge wrote:

+  }
+}
+
+
+void JSONWriter::Clear() {
+  msg_len_ = 0;
+  buf_[0] = '\0';
+}
+
+
+intptr_t JSONWriter::Printf(const char* format, ...) {
+  va_list args;
+  va_start(args, format);
+  intptr_t remaining = buf_size_ - msg_len_;
+  ASSERT(remaining >= 0);
+  intptr_t len = OS::VSNPrint(buf_ + msg_len_, remaining, format, args);
+  va_end(args);
+  if (len >= remaining) {
+    GrowBuffer(len + 64);  // Somewhat arbitrary slack.

[turnidge, 2012/04/09 22:26:42]

Make the slack amount a named constant.

[hausner, 2012/04/10 16:26:51]

Done.

+    remaining = buf_size_ - msg_len_;
+    ASSERT(remaining > len);
+    va_list args2;
+    va_start(args2, format);
+    intptr_t len2 = OS::VSNPrint(buf_ + msg_len_, remaining, format, args2);
+    va_end(args2);
+    ASSERT(len == len2);
+  }
+  msg_len_ += len;
+  buf_[msg_len_] = '\0';
+  return len;
+}
+
+
+void JSONWriter::GrowBuffer(intptr_t len) {
+  intptr_t new_size = buf_size_ + len;
+  char* new_buf = reinterpret_cast<char*>(malloc(new_size));

[turnidge, 2012/04/09 22:26:42]

Consider realloc?  It copies the bytes for you.

[hausner, 2012/04/10 16:26:51]

Good suggestion, thank you.

+  intptr_t msg_len = OS::SNPrint(new_buf, new_size, "%s", buf_);

[turnidge, 2012/04/09 22:26:42]

I don't think you should use SNPrint to go the buffer copy here.  I don't know
if % is a legal character in json strings, but perhaps it is.  If so, printf
will try to interpret the %'s in the text and things will go astray.

If you use realloc, this becomes a non-issue.

[hausner, 2012/04/10 16:26:51]

Very good point. Replaced with realloc().

On 2012/04/09 22:26:42, turnidge wrote:

+  ASSERT(msg_len < new_size);
+  buf_ = new_buf;
+  buf_size_ = new_size;
+}
+
+
+JSONReader::JSONReader(const char* json_object)
+: scanner_(json_object) {
+  Set(json_object);
+}
+
+void JSONReader::Set(const char* json_object) {
+  scanner_.Set(json_object);
+  json_object_ = json_object;
+  error_ = false;
+}
+
+
+bool JSONReader::Seek(const char* name) {
+  scanner_.Set(json_object_);

[turnidge, 2012/04/09 22:26:42]

Why the call to Set here?  Isn't this done already by the constructor?

[hausner, 2012/04/10 16:26:51]

Because a JSON object is by definition an unordered set of pairs. The Seek()
interface does not assume any particular ordering of fields and thus starts from
the beginning of the object each time you look for a particular name.

An alternative interface (which we can add if desired) could iterate over the
fields in textual order.

+  scanner_.Scan();
+  if (scanner_.CurrentToken() != JSONScanner::TokenLBrace) {
+    error_ = true;
+    return false;
+  }
+  scanner_.Scan();
+  while (scanner_.CurrentToken() == JSONScanner::TokenString) {
+    bool found = scanner_.IsStringLiteral(name);
+    scanner_.Scan();
+    if (scanner_.CurrentToken() != JSONScanner::TokenColon) {
+      error_ = true;
+      return false;
+    }
+    scanner_.Scan();
+    switch (scanner_.CurrentToken()) {
+      case JSONScanner::TokenString:
+      case JSONScanner::TokenInteger:
+      case JSONScanner::TokenLBrace:
+      case JSONScanner::TokenLBrack:
+      case JSONScanner::TokenTrue:
+      case JSONScanner::TokenFalse:
+      case JSONScanner::TokenNull:
+        // Found a legal value.
+        if (found) {
+          return true;
+        }
+        break;
+      default:
+        error_ = true;
+        return false;
+    }
+    // Skip the value.
+    if (scanner_.CurrentToken() == JSONScanner::TokenLBrace) {
+      scanner_.Skip(JSONScanner::TokenRBrace);
+      if (scanner_.CurrentToken() != JSONScanner::TokenRBrace) {
+        error_ = true;
+        return false;
+      }
+    } else if (scanner_.CurrentToken() == JSONScanner::TokenLBrack) {
+      scanner_.Skip(JSONScanner::TokenRBrack);
+      if (scanner_.CurrentToken() != JSONScanner::TokenRBrack) {
+        error_ = true;
+        return false;
+      }
+    }
+    scanner_.Scan();  // Value or closing brace or bracket.
+    if (scanner_.CurrentToken() == JSONScanner::TokenComma) {
+      scanner_.Scan();
+    } else {
+      // End of json object or malformed object. Value not found.
+      break;
+    }
+  }
+  return false;
+}
+
+
+JSONReader::JSONType JSONReader::Type() const {
+  if (error_) {
+    return kNone;
+  }
+  switch (scanner_.CurrentToken()) {
+    case JSONScanner::TokenString:
+      return kString;
+    case JSONScanner::TokenInteger:
+      return kInteger;
+    case JSONScanner::TokenLBrace:
+      return kObject;
+    case JSONScanner::TokenLBrack:
+      return kArray;
+    case JSONScanner::TokenTrue:
+    case JSONScanner::TokenFalse:
+    case JSONScanner::TokenNull:
+      return kLiteral;
+    default:
+      return kNone;
+  }
+}
+
+
+JSONScanner::JSONScanner(const char* msg) {
+  Set(msg);
+}
+
+
+void JSONScanner::Set(const char* txt) {
+  current_pos_ = txt;
+  token_start_ = txt;
+  token_length_ = 0;
+  token_ = TokenIllegal;
+}
+
+
+void JSONScanner::Recognize(Token t) {
+  ++current_pos_;
+  token_ = t;
+}
+
+
+bool JSONScanner::IsLetter(char ch) const {
+  return (('A' <= ch) && (ch <= 'Z')) || (('a' <= ch) && (ch <= 'z'));
+}
+
+
+bool JSONScanner::IsDigit(char ch) const {
+  return ('0' <= ch) && (ch <= '9');
+}
+
+
+bool JSONScanner::IsLiteral(const char* literal) {
+  int i = 0;
+  while ((literal[i] != '\0') && (current_pos_[i] == literal[i])) {
+    i++;
+  }
+  if ((literal[i] == '\0') && !IsLetter(current_pos_[i])) {
+    current_pos_ += i;
+    return true;
+  }
+  return false;
+}
+
+
+bool JSONScanner::IsStringLiteral(const char* literal) const {
+  if (token_ != TokenString) {
+    return false;
+  }
+  int i = 0;
+  while ((i < token_length_) && (token_start_[i] == literal[i])) {
+    i++;
+  }
+  return (i == token_length_) && (literal[i] == '\0');
+}
+
+
+void JSONScanner::Skip(Token matching_token) {
+  while (!EOM() && (token_ != TokenIllegal)) {
+    Scan();
+    if (token_ == TokenLBrace) {
+      Skip(TokenRBrace);
+    } else if (token_ == TokenLBrack) {
+      Skip(TokenRBrack);
+    } else if (token_ == matching_token) {
+      return;
+    } else if ((token_ == TokenRBrace) || (token_ == TokenRBrack)) {
+      // Mismatched brace or bracket.
+      token_ = TokenIllegal;
+    }
+  }
+}
+
+
+void JSONScanner::ScanString() {
+  ASSERT(*current_pos_ == '"');
+  ++current_pos_;
+  token_start_ = current_pos_;
+  while (*current_pos_ != '"') {
+    if (*current_pos_ == '\0') {
+      token_length_ = 0;
+      token_ = TokenIllegal;
+      return;
+    } else if (*current_pos_ == '\\') {
+      // TODO(hausner): Implement escape sequence.
+      UNIMPLEMENTED();
+    } else if (*current_pos_ < 0) {
+      // UTF-8 not supported.
+      token_length_ = 0;
+      token_ = TokenIllegal;
+      return;
+    } else {
+      ++current_pos_;
+    }
+  }
+  token_ = TokenString;
+  token_length_ = current_pos_ - token_start_;
+  ++current_pos_;
+}
+
+
+void JSONScanner::ScanNumber() {
+  if (*current_pos_ == '-') {
+    ++current_pos_;
+  }
+  if (!IsDigit(*current_pos_)) {
+    token_ = TokenIllegal;
+    token_length_ = 0;
+    return;
+  }
+  while (IsDigit(*current_pos_)) {
+    ++current_pos_;
+  }
+  if ((*current_pos_ == '.') ||
+      (*current_pos_ == 'e') ||
+      (*current_pos_ == 'E')) {
+    // Floating point numbers not supported.
+    token_ = TokenIllegal;
+    token_length_ = 0;
+    return;
+  }
+  token_ = TokenInteger;
+  token_length_ = current_pos_ - token_start_;
+}
+
+
+void JSONScanner::Scan() {
+  while ((*current_pos_ == ' ') ||
+         (*current_pos_ == '\t') ||
+         (*current_pos_ == '\n')) {
+    ++current_pos_;
+  }
+  token_start_ = current_pos_;
+  if (*current_pos_ == '\0') {
+    token_length_ = 0;
+    token_ = TokenEOM;
+    return;
+  }
+  switch (*current_pos_) {
+    case '{':
+      Recognize(TokenLBrace);
+      break;
+    case '}':
+      Recognize(TokenRBrace);
+      break;
+    case '[':
+      Recognize(TokenLBrack);
+      break;
+    case ']':
+      Recognize(TokenRBrack);
+      break;
+    case ':':
+      Recognize(TokenColon);
+      break;
+    case ',':
+      Recognize(TokenComma);
+      break;
+    case '"':
+      ScanString();
+      break;
+    case '0':
+    case '1':
+    case '2':
+    case '3':
+    case '4':
+    case '5':
+    case '6':
+    case '7':
+    case '8':
+    case '9':
+    case '-':
+      ScanNumber();
+      break;
+    default:
+      if (IsLiteral("true")) {
+        token_ = TokenTrue;
+      } else if (IsLiteral("false")) {
+        token_ = TokenFalse;
+      } else if (IsLiteral("null")) {
+        token_ = TokenNull;
+      } else {
+        token_length_ = 0;
+        token_ = TokenIllegal;
+      }
+  }
+}
+
+}  // namespace dart