LCOV - code coverage report
Current view: top level - src - json-parser.h (source / functions) Hit Total Coverage
Test: app.info Lines: 14 18 77.8 %
Date: 2017-04-26 Functions: 4 16 25.0 %

          Line data    Source code
       1             : // Copyright 2011 the V8 project authors. All rights reserved.
       2             : // Use of this source code is governed by a BSD-style license that can be
       3             : // found in the LICENSE file.
       4             : 
       5             : #ifndef V8_JSON_PARSER_H_
       6             : #define V8_JSON_PARSER_H_
       7             : 
       8             : #include "src/factory.h"
       9             : #include "src/objects.h"
      10             : 
      11             : namespace v8 {
      12             : namespace internal {
      13             : 
      14             : enum ParseElementResult { kElementFound, kElementNotFound, kNullHandle };
      15             : 
      16             : class JsonParseInternalizer BASE_EMBEDDED {
      17             :  public:
      18             :   static MaybeHandle<Object> Internalize(Isolate* isolate,
      19             :                                          Handle<Object> object,
      20             :                                          Handle<Object> reviver);
      21             : 
      22             :  private:
      23             :   JsonParseInternalizer(Isolate* isolate, Handle<JSReceiver> reviver)
      24         218 :       : isolate_(isolate), reviver_(reviver) {}
      25             : 
      26             :   MaybeHandle<Object> InternalizeJsonProperty(Handle<JSReceiver> holder,
      27             :                                               Handle<String> key);
      28             : 
      29             :   bool RecurseAndApply(Handle<JSReceiver> holder, Handle<String> name);
      30             : 
      31             :   Isolate* isolate_;
      32             :   Handle<JSReceiver> reviver_;
      33             : };
      34             : 
      35             : // A simple json parser.
      36             : template <bool seq_one_byte>
      37      692509 : class JsonParser BASE_EMBEDDED {
      38             :  public:
      39      692509 :   MUST_USE_RESULT static MaybeHandle<Object> Parse(Isolate* isolate,
      40             :                                                    Handle<String> source,
      41             :                                                    Handle<Object> reviver) {
      42             :     Handle<Object> result;
      43     2077527 :     ASSIGN_RETURN_ON_EXCEPTION(isolate, result,
      44             :                                JsonParser(isolate, source).ParseJson(), Object);
      45      691441 :     if (reviver->IsCallable()) {
      46         218 :       return JsonParseInternalizer::Internalize(isolate, result, reviver);
      47             :     }
      48             :     return result;
      49             :   }
      50             : 
      51             :   static const int kEndOfString = -1;
      52             : 
      53             :  private:
      54             :   JsonParser(Isolate* isolate, Handle<String> source);
      55             : 
      56             :   // Parse a string containing a single JSON value.
      57             :   MaybeHandle<Object> ParseJson();
      58             : 
      59             :   INLINE(void Advance());
      60             : 
      61             :   // The JSON lexical grammar is specified in the ECMAScript 5 standard,
      62             :   // section 15.12.1.1. The only allowed whitespace characters between tokens
      63             :   // are tab, carriage-return, newline and space.
      64             : 
      65             :   INLINE(void AdvanceSkipWhitespace());
      66             :   INLINE(void SkipWhitespace());
      67             :   INLINE(uc32 AdvanceGetChar());
      68             : 
      69             :   // Checks that current charater is c.
      70             :   // If so, then consume c and skip whitespace.
      71             :   INLINE(bool MatchSkipWhiteSpace(uc32 c));
      72             : 
      73             :   // A JSON string (production JSONString) is subset of valid JavaScript string
      74             :   // literals. The string must only be double-quoted (not single-quoted), and
      75             :   // the only allowed backslash-escapes are ", /, \, b, f, n, r, t and
      76             :   // four-digit hex escapes (uXXXX). Any other use of backslashes is invalid.
      77           0 :   Handle<String> ParseJsonString() {
      78    21424977 :     return ScanJsonString<false>();
      79             :   }
      80             : 
      81             :   bool ParseJsonString(Handle<String> expected);
      82             : 
      83    15201595 :   Handle<String> ParseJsonInternalizedString() {
      84    15201595 :     Handle<String> result = ScanJsonString<true>();
      85    15201595 :     if (result.is_null()) return result;
      86    15201490 :     return factory()->InternalizeString(result);
      87             :   }
      88             : 
      89             :   template <bool is_internalized>
      90             :   Handle<String> ScanJsonString();
      91             :   // Creates a new string and copies prefix[start..end] into the beginning
      92             :   // of it. Then scans the rest of the string, adding characters after the
      93             :   // prefix. Called by ScanJsonString when reaching a '\' or non-Latin1 char.
      94             :   template <typename StringType, typename SinkChar>
      95             :   Handle<String> SlowScanJsonString(Handle<String> prefix, int start, int end);
      96             : 
      97             :   // A JSON number (production JSONNumber) is a subset of the valid JavaScript
      98             :   // decimal number literals.
      99             :   // It includes an optional minus sign, must have at least one
     100             :   // digit before and after a decimal point, may not have prefixed zeros (unless
     101             :   // the integer part is zero), and may include an exponent part (e.g., "e-10").
     102             :   // Hexadecimal and octal numbers are not allowed.
     103             :   Handle<Object> ParseJsonNumber();
     104             : 
     105             :   // Parse a single JSON value from input (grammar production JSONValue).
     106             :   // A JSON value is either a (double-quoted) string literal, a number literal,
     107             :   // one of "true", "false", or "null", or an object or array literal.
     108             :   Handle<Object> ParseJsonValue();
     109             : 
     110             :   // Parse a JSON object literal (grammar production JSONObject).
     111             :   // An object literal is a squiggly-braced and comma separated sequence
     112             :   // (possibly empty) of key/value pairs, where the key is a JSON string
     113             :   // literal, the value is a JSON value, and the two are separated by a colon.
     114             :   // A JSON array doesn't allow numbers and identifiers as keys, like a
     115             :   // JavaScript array.
     116             :   Handle<Object> ParseJsonObject();
     117             : 
     118             :   // Helper for ParseJsonObject. Parses the form "123": obj, which is recorded
     119             :   // as an element, not a property.
     120             :   ParseElementResult ParseElement(Handle<JSObject> json_object);
     121             : 
     122             :   // Parses a JSON array literal (grammar production JSONArray). An array
     123             :   // literal is a square-bracketed and comma separated sequence (possibly empty)
     124             :   // of JSON values.
     125             :   // A JSON array doesn't allow leaving out values from the sequence, nor does
     126             :   // it allow a terminal comma, like a JavaScript array does.
     127             :   Handle<Object> ParseJsonArray();
     128             : 
     129             : 
     130             :   // Mark that a parsing error has happened at the current token, and
     131             :   // return a null handle. Primarily for readability.
     132           0 :   inline Handle<Object> ReportUnexpectedCharacter() {
     133           0 :     return Handle<Object>::null();
     134             :   }
     135             : 
     136    86810744 :   inline Isolate* isolate() { return isolate_; }
     137    67084541 :   inline Factory* factory() { return factory_; }
     138    10090379 :   inline Handle<JSFunction> object_constructor() { return object_constructor_; }
     139             : 
     140             :   static const int kInitialSpecialStringLength = 32;
     141             :   static const int kPretenureTreshold = 100 * 1024;
     142             : 
     143             :  private:
     144           0 :   Zone* zone() { return &zone_; }
     145             : 
     146             :   void CommitStateToJsonObject(Handle<JSObject> json_object, Handle<Map> map,
     147             :                                ZoneList<Handle<Object> >* properties);
     148             : 
     149             :   Handle<String> source_;
     150             :   int source_length_;
     151             :   Handle<SeqOneByteString> seq_source_;
     152             : 
     153             :   PretenureFlag pretenure_;
     154             :   Isolate* isolate_;
     155             :   Factory* factory_;
     156             :   Zone zone_;
     157             :   Handle<JSFunction> object_constructor_;
     158             :   uc32 c0_;
     159             :   int position_;
     160             : };
     161             : 
     162             : }  // namespace internal
     163             : }  // namespace v8
     164             : 
     165             : #endif  // V8_JSON_PARSER_H_

Generated by: LCOV version 1.10