Order function definitions in base/ according to the header.

base/json/json_reader.cc

 // Copyright (c) 2010 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/scoped_ptr.h"
 #include "base/string_number_conversions.h"
@@ skipping 63 matching lines @@
     "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),
+      allow_trailing_comma_(false),
+      error_code_(JSON_NO_ERROR), error_line_(0), error_col_(0) {}
+
 /* static */
 Value* JSONReader::Read(const std::string& json,
                         bool allow_trailing_comma) {
   return ReadAndReturnError(json, allow_trailing_comma, NULL, NULL);
 }
 
 /* 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 */
-std::string JSONReader::FormatErrorMessage(int line, int column,
-                                           const std::string& description) {
-  if (line || column) {
-    return StringPrintf("Line: %i, column: %i, %s",
-                        line, column, description.c_str());
-  }
-  return description;
-}
-
-/* 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 11 matching lines @@
       NOTREACHED();
       return std::string();
   }
 }
 
 std::string JSONReader::GetErrorMessage() const {
   return FormatErrorMessage(error_line_, error_col_,
                             ErrorCodeToString(error_code_));
 }
 
-JSONReader::JSONReader()
-    : start_pos_(NULL), json_pos_(NULL), stack_depth_(0),
-      allow_trailing_comma_(false),
-      error_code_(JSON_NO_ERROR), error_line_(0), error_col_(0) {}
-
 Value* JSONReader::JsonToValue(const std::string& json, bool check_root,
                                bool allow_trailing_comma) {
   // The input must be in UTF-8.
   if (!IsStringUTF8(json.c_str())) {
     error_code_ = JSON_UNSUPPORTED_ENCODING;
     return NULL;
   }
 
   // The conversion from UTF8 to wstring removes null bytes for us
   // (a good thing).
@@ skipping 23 matching lines @@
     }
   }
 
   // Default to calling errors "syntax errors".
   if (error_code_ == 0)
     SetErrorCode(JSON_SYNTAX_ERROR, json_pos_);
 
   return NULL;
 }
 
+/* static */
+std::string JSONReader::FormatErrorMessage(int line, int column,
+                                           const std::string& description) {
+  if (line || column) {
+    return StringPrintf("Line: %i, column: %i, %s",
+                        line, column, description.c_str());
+  }
+  return description;
+}
+
 Value* JSONReader::BuildValue(bool is_root) {
   ++stack_depth_;
   if (stack_depth_ > kStackLimit) {
     SetErrorCode(JSON_TOO_MUCH_NESTING, json_pos_);
     return NULL;
   }
 
   Token token = ParseToken();
   // The root token must be an array or an object.
   if (is_root && token.type != Token::OBJECT_BEGIN &&
@@ skipping 365 matching lines @@
       token = ParseNumberToken();
       break;
 
     case '"':
       token = ParseStringToken();
       break;
   }
   return token;
 }
 
-bool JSONReader::NextStringMatch(const std::wstring& str) {
-  for (size_t i = 0; i < str.length(); ++i) {
-    if ('\0' == *json_pos_)
-      return false;
-    if (*(json_pos_ + i) != str[i])
-      return false;
-  }
-  return true;
-}
-
 void JSONReader::EatWhitespaceAndComments() {
   while ('\0' != *json_pos_) {
     switch (*json_pos_) {
       case ' ':
       case '\n':
       case '\r':
       case '\t':
         ++json_pos_;
         break;
       case '/':
@@ skipping 35 matching lines @@
         return true;
       }
       ++json_pos_;
     }
   } else {
     return false;
   }
   return true;
 }
 
+bool JSONReader::NextStringMatch(const std::wstring& str) {
+  for (size_t i = 0; i < str.length(); ++i) {
+    if ('\0' == *json_pos_)
+      return false;
+    if (*(json_pos_ + i) != str[i])
+      return false;
+  }
+  return true;
+}
+
 void JSONReader::SetErrorCode(JsonParseError error,
                               const wchar_t* error_pos) {
   int line_number = 1;
   int column_number = 1;
 
   // Figure out the line and column the error occured at.
   for (const wchar_t* pos = start_pos_; pos != error_pos; ++pos) {
     if (*pos == '\0') {
       NOTREACHED();
       return;
     }
 
     if (*pos == '\n') {
       ++line_number;
       column_number = 1;
     } else {
       ++column_number;
     }
   }
 
   error_line_ = line_number;
   error_col_ = column_number;
   error_code_ = error;
 }
 
 }  // namespace base