base/json: Get rid of static initializer in JSONReader.

base/json/json_reader.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/json/json_reader.h"
 
 #include "base/float_util.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stringprintf.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 
 namespace {
 
 const wchar_t kNullString[] = L"null";
 const wchar_t kTrueString[] = L"true";
 const wchar_t kFalseString[] = L"false";
 
 const int kStackLimit = 100;
 
-}  // namespace
-
-namespace base {
-
-static const JSONReader::Token kInvalidToken(JSONReader::Token::INVALID_TOKEN,
-                                             0, 0);
-namespace {
-
 // A helper method for ParseNumberToken.  It reads an int from the end of
 // token.  The method returns false if there is no valid integer at the end of
 // the token.
-bool ReadInt(JSONReader::Token& token, bool can_have_leading_zeros) {
+bool ReadInt(base::JSONReader::Token& token, bool can_have_leading_zeros) {
   wchar_t first = token.NextChar();
   int len = 0;
 
   // Read in more digits
   wchar_t c = first;
   while ('\0' != c && '0' <= c && c <= '9') {
     ++token.length;
     ++len;
     c = token.NextChar();
   }
   // We need at least 1 digit.
   if (len == 0)
     return false;
 
   if (!can_have_leading_zeros && len > 1 && '0' == first)
     return false;
 
   return true;
 }
 
 // A helper method for ParseStringToken.  It reads |digits| hex digits from the
 // token. If the sequence if digits is not valid (contains other characters),
 // the method returns false.
-bool ReadHexDigits(JSONReader::Token& token, int digits) {
+bool ReadHexDigits(base::JSONReader::Token& token, int digits) {
   for (int i = 1; i <= digits; ++i) {
     wchar_t c = *(token.begin + token.length + i);
     if ('\0' == c)
       return false;
     if (!(('0' <= c && c <= '9') || ('a' <= c && c <= 'f') ||
           ('A' <= c && c <= 'F'))) {
       return false;
     }
   }
 
   token.length += digits;
   return true;
 }
 
 }  // namespace
 
+namespace base {
+
 const char* JSONReader::kBadRootElementType =
     "Root value must be an array or object.";
 const char* JSONReader::kInvalidEscape =
     "Invalid escape sequence.";
 const char* JSONReader::kSyntaxError =
     "Syntax error.";
 const char* JSONReader::kTrailingComma =
     "Trailing comma not allowed.";
 const char* JSONReader::kTooMuchNesting =
     "Too much nesting.";
 const char* JSONReader::kUnexpectedDataAfterRoot =
     "Unexpected data after root element.";
 const char* JSONReader::kUnsupportedEncoding =
     "Unsupported encoding. JSON must be UTF-8.";
 const char* JSONReader::kUnquotedDictionaryKey =
     "Dictionary keys must be quoted.";
 
 JSONReader::JSONReader()
-    : start_pos_(NULL), json_pos_(NULL), stack_depth_(0),
+    : start_pos_(NULL),
+      json_pos_(NULL),
+      stack_depth_(0),
       allow_trailing_comma_(false),
-      error_code_(JSON_NO_ERROR), error_line_(0), error_col_(0) {}
+      error_code_(JSON_NO_ERROR),
+      error_line_(0),
+      error_col_(0) {}
 
-/* static */
+// static
 Value* JSONReader::Read(const std::string& json,
                         bool allow_trailing_comma) {
   return ReadAndReturnError(json, allow_trailing_comma, NULL, NULL);
 }
 
-/* static */
+// static
 Value* JSONReader::ReadAndReturnError(const std::string& json,
                                       bool allow_trailing_comma,
                                       int* error_code_out,
                                       std::string* error_msg_out) {
   JSONReader reader = JSONReader();
   Value* root = reader.JsonToValue(json, true, allow_trailing_comma);
   if (root)
     return root;
 
   if (error_code_out)
     *error_code_out = reader.error_code();
   if (error_msg_out)
     *error_msg_out = reader.GetErrorMessage();
 
   return NULL;
 }
 
-/* static */
+// static
 std::string JSONReader::ErrorCodeToString(JsonParseError error_code) {
   switch (error_code) {
     case JSON_NO_ERROR:
       return std::string();
     case JSON_BAD_ROOT_ELEMENT_TYPE:
       return kBadRootElementType;
     case JSON_INVALID_ESCAPE:
       return kInvalidEscape;
     case JSON_SYNTAX_ERROR:
       return kSyntaxError;
@@ skipping 54 matching lines @@
     }
   }
 
   // Default to calling errors "syntax errors".
   if (error_code_ == 0)
     SetErrorCode(JSON_SYNTAX_ERROR, json_pos_);
 
   return NULL;
 }
 
-/* static */
+// static
 std::string JSONReader::FormatErrorMessage(int line, int column,
                                            const std::string& description) {
   if (line || column) {
     return base::StringPrintf(
         "Line: %i, column: %i, %s", line, column, description.c_str());
   }
   return description;
 }
 
 Value* JSONReader::BuildValue(bool is_root) {
@@ skipping 154 matching lines @@
   // We just grab the number here.  We validate the size in DecodeNumber.
   // According   to RFC4627, a valid number is: [minus] int [frac] [exp]
   Token token(Token::NUMBER, json_pos_, 0);
   wchar_t c = *json_pos_;
   if ('-' == c) {
     ++token.length;
     c = token.NextChar();
   }
 
   if (!ReadInt(token, false))
-    return kInvalidToken;
+    return Token::CreateInvalidToken();
 
   // Optional fraction part
   c = token.NextChar();
   if ('.' == c) {
     ++token.length;
     if (!ReadInt(token, true))
-      return kInvalidToken;
+      return Token::CreateInvalidToken();
     c = token.NextChar();
   }
 
   // Optional exponent part
   if ('e' == c || 'E' == c) {
     ++token.length;
     c = token.NextChar();
     if ('-' == c || '+' == c) {
       ++token.length;
       c = token.NextChar();
     }
     if (!ReadInt(token, true))
-      return kInvalidToken;
+      return Token::CreateInvalidToken();
   }
 
   return token;
 }
 
 Value* JSONReader::DecodeNumber(const Token& token) {
   const std::wstring num_string(token.begin, token.length);
 
   int num_int;
   if (StringToInt(WideToUTF8(num_string), &num_int))
@@ skipping 12 matching lines @@
   wchar_t c = token.NextChar();
   while ('\0' != c) {
     if ('\\' == c) {
       ++token.length;
       c = token.NextChar();
       // Make sure the escaped char is valid.
       switch (c) {
         case 'x':
           if (!ReadHexDigits(token, 2)) {
             SetErrorCode(JSON_INVALID_ESCAPE, json_pos_ + token.length);
-            return kInvalidToken;
+            return Token::CreateInvalidToken();
           }
           break;
         case 'u':
           if (!ReadHexDigits(token, 4)) {
             SetErrorCode(JSON_INVALID_ESCAPE, json_pos_ + token.length);
-            return kInvalidToken;
+            return Token::CreateInvalidToken();
           }
           break;
         case '\\':
         case '/':
         case 'b':
         case 'f':
         case 'n':
         case 'r':
         case 't':
         case 'v':
         case '"':
           break;
         default:
           SetErrorCode(JSON_INVALID_ESCAPE, json_pos_ + token.length);
-          return kInvalidToken;
+          return Token::CreateInvalidToken();
       }
     } else if ('"' == c) {
       ++token.length;
       return token;
     }
     ++token.length;
     c = token.NextChar();
   }
-  return kInvalidToken;
+  return Token::CreateInvalidToken();
 }
 
 Value* JSONReader::DecodeString(const Token& token) {
   std::wstring decoded_str;
   decoded_str.reserve(token.length - 2);
 
   for (int i = 1; i < token.length - 1; ++i) {
     wchar_t c = *(token.begin + i);
     if ('\\' == c) {
       ++i;
@@ skipping 197 matching lines @@
       ++column_number;
     }
   }
 
   error_line_ = line_number;
   error_col_ = column_number;
   error_code_ = error;
 }
 
 }  // namespace base