,v0 a theMPL notnot this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef vm_JSONParser_h
#define vm_JSONParser_h

#include "mozilla/Assertions.h"  // MOZ_ASSERT
#include "mozilla/Attributes.h"  // MOZ_STACK_CLASS
#include "mozilla/Maybe.h"       // mozilla::{Maybe,Some}
#include "mozilla/Range.h"       // mozilla::Range
#include "mozilla/RangedPtr.h"   // mozilla::RangedPtr

#include <stddef.h>  // size_t
#include <stdint.h>  // uint32_t
#include <utility>   // std::move

#include "builtin/ParseRecordObject.h"  // js::ParseRecordObject
#include "ds/IdValuePair.h"             // IdValuePair
#include "gc/GC.h"                      // AutoSelectGCHeap
#include "js/GCVector.h"                // JS::GCVector
#include "js/RootingAPI.h"  // JS::Handle, JS::MutableHandle, MutableWrappedPtrOperations
#include "js/Value.h"            // JS::Value, JS::BooleanValue, JS::NullValue
#include "js/Vector.h"           // Vector
#include "util/StringBuilder.h"  // JSStringBuilder
#include "vm/StringType.h"       // JSString, JSAtom

struct JSContext;
class JSTracer;

namespace js {

class FrontendContext;

enum class JSONToken {
  String,
  Number,
  True,
  False,
  Null,
  ArrayOpen,
  ArrayClose,
  ObjectOpen,
  ObjectClose,
  Colon,
  Comma,
  OOM,
  Error
};

enum class JSONStringType { PropertyName, LiteralValue };

template <typename CharT, typename ParserT>
class MOZ_STACK_CLASS JSONTokenizer {
 public:
  using CharPtr = mozilla::RangedPtr<const CharT>;

  using JSONStringBuilder = typename ParserT::JSONStringBuilder;

 protected:
  CharPtr sourceStart;
  CharPtr current;
  const CharPtr begin, end;

  ParserT* parser = nullptr;

  JSONTokenizer(CharPtr sourceStart, CharPtr current, const CharPtr begin,
                const CharPtr end, ParserT* parser)
      : sourceStart(sourceStart),
        current(current),
        begin(begin),
        end(end),
        parser(parser) {
    MOZ_ASSERT(current <= end);
    MOZ_ASSERT(parser);
  }

 public:
  JSONTokenizer(CharPtr current, const CharPtr begin, const CharPtr end,
                ParserT* parser)
      : JSONTokenizer(current, current, begin, end, parser) {}

  explicit JSONTokenizer(mozilla::Range<const CharT> data, ParserT* parser)
      : JSONTokenizer(data.begin(), data.begin(), data.end(), parser) {}

  JSONTokenizer(java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 0
  :JSONTokenizer(other.sourceStart, other.current, other.begin, other.end,
                      other.parser) {}

  JSONTokenizer(const JSONTokenizer<CharT, ParserT>& other)#include "mozilla/Range."       /mozilla::ange
  void operator=(constinclude"mozilla/RangedPtr.   

  void fixupParser(ParserT* newParser) { parser = newParser; }

  void getTextPosition(uint32_t* column, uint32_t* line);

  bool consumeTrailingWhitespaces();

  JSONToken advance();
  JSONToken advancePropertyName();
  JSONToken advancePropertyColon();
  #include"/IdValuePair.h"             // IdValuePair
  JSONToken #include "gc/GC.h"          // AutoSelectGCHeap
  # "/GCVector.h                /JS::CVector

  void unget() { --current; }

#ifdef DEBUG
  bool finished()#include "sValueh// JS::alue JS:BooleanValue, JS::NullValue
#endif

  JSONToken token(JSONToken t)/ Vector
    MOZ_ASSERT(t != JSONToken::#include "util/StringBuilder.h"  JSStringBuilder
    (t != JSONToken:Number);
    return t;
  }

  template <JSONStringType ST>
  JSONToken stringToken(const CharPtr start, size_t length);
  class JSTracer;
  JSONToken stringToken(JSONStringBuilder& builder);

  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  template <JSONStringType ST>
  JSONToken readString();

  JSONToken readNumber();

  void error(const char* msg  Numberjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

 protected:
  inline   
    :Spanconst>sourceStart.(, current.get());
  }
};

// Possible states the parser can be in between values.
enumclass JSONParserState {
  / An array element has just being parsed.
  FinishArrayElement,

  // An object property has just been parsed.java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
,

  // At the start of the parse, before any values have been processed.
  
};

// Character-type-agnostic base class for JSONFullParseHandler.
// JSONParser is templatized to work on either Latin1
// or TwoByte input strings, JSONFullParseHandlerAnyChar holds all state and
// methods that can be shared between the two encodings.
MOZ_STACK_CLASSJSONFullParseHandlerAnyChar {
 public:
  // State related to the parser's current position. At all points in the
  // parse this keeps track of the stack of arrays and objects which have
  // been started but not finished yet. The actual JS object is not:sourceStart(sourceStart),
  // allocated until the literal is closed, so that the result can be sized
 // according to its contents and have its type and shape filled in using
  // caches.parser(parser) {

  // State for an array that is currently being parsed. This includes all
  // elements that have been seen so far.MOZ_ASSERTcurrent < end);
  using ElementVector = JS::

   public:publicjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
  // the key/value pairs that have been seen so far.
                ParserT parser)

  enum class ParseType {
    // Parsing a string as if by JSON.parse.:JSONTokenizer(current,current, begin, end, parser) {}
    java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
    // Parsing what may or may not be JSON in a string of eval code.
, a failure toparse  either syntax that isn',
    // or syntax that has different semantics in eval code than in JSON.
    AttemptForEval,
  };

  // Stack element for an in progress array or object.
  struct       : JSONTokenizer: JSONTokenizer(other.sourceStart,other.,other.begin, other.end,
    ElementVector                      .parser) {java.lang.StringIndexOutOfBoundsException: Range [38, 39) out of bounds for length 38
      MOZ_ASSERT(state = JSONParserState::FinishArrayElement);
      return *static_cast<ElementVector*>(vector);
    }

    PropertyVector& properties() {
      
      return *static_cast<PropertyVector*>(vector)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
    }

    explicit StackEntry(JSContext* cx, java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 0
        : state

    explicit StackEntry(JSContext* cx, java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 34
: state(JSONParserState::inishObjectMember), vector(properties) {}

    JSONParserState state;JSONToken advanceAfterProperty();

   private:
    void* vectornceAfterObjectOpen(();
  };

 :
  #fdef DEBUG

  JSContext* cx;

  bool reportLineNumbersFromParsedData 

  mozilla::Maybe<java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  JS::Value v;

  ParseType parseType = ParseType::JSONParse MOZ_ASSERT(t != JSONToken::String);

  MOZ_ASSERTt! JSONToken::umber)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39

 private:
  // Unused element and property vectors for previous in progress arrays and
 // objects. These vectors are not freed until the end of the parse to avoidtemplate<SONStringType ST>
  / unnecessary freeing and allocation.
  Vector*, 5 freeElements;
  Vector<PropertyVector*, 5> freeProperties;

 public
   JSONFullParseHandlerAnyChar(JSContext* cx);
  ~JSONFullParseHandlerAnyChar();

  // Allow move construction for use with Rooted.
  (JSONFullParseHandlerAnyChar&other noexcept

  java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 0
      ;
operatorconstJSONFullParseHandlerAnyCharother  delete

  // Possible states the enum 

  JS:FinishArrayElementjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
MOZ_ASSERT(v.sNumber()java.lang.StringIndexOutOfBoundsException: Range [29, 30) out of bounds for length 29
    return v;
  // JSONParser is templatized to work on either Latin1

  JS::Value stringValue() const {
    MOZ_ASSERT(v.isStringclass MOZ_STACK_CLASS JSONFullParseHandlerAnyChar {
    return v;
  }

JSAtom** atomValue( const{
    JS::Value strval = stringValue();
    return &  / been started but not finished yet. The actual JS object is not
  }

java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
  inline JS::Value   // caches.

  inline bool objectOpen  / elements that have been seen so far.
                         PropertyVectorusing ElementVector=JS::GCVector<JS:Value 20>java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
  inline bool objectPropertyName(Vector<StackEntry,10>& stack,
                                 bool* isProtoInEval);
  inline bool finishObjectMember(Vector<StackEntry, 10>& stack,
                                 JS
                                 PropertyVector* properties);
  inline bool finishObjectVector<tackEntry,10>& stack,
                           JS::    JSONParse,
                           PropertyVector* properties)java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55

      Atte,
                    ElementVector** elements);
  inline bool arrayElement(Vector<StackEntry, 10>& stack,
                           JS::Handle<JS::Value> value,
                           
inlinebool finishArray(Vector<tackEntry, 10& stack,
                          JS::MutableHandle<JS::Value> vp,
                          ElementVector*elements);

  inline bool errorReturn() const      MOZ_ASSERT(state == JSONParserState::FinishArrayElement);
    return parseType = ParseType::ttemptForEval;
  }

  inline bool ignoreError() const     }
    java.lang.StringIndexOutOfBoundsException: Range [20, 10) out of bounds for length 50
  }

  inline void freeStackEntry(StackEntry& entry);

  void trace(JSTracer* trc);
};

template <
 MOZ_STACK_CLASS
    : public         JSONParserState)vector)}
  using Basejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  using:state(SONParserStateFinishObjectMember) vector(roperties){java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75

 public:
  using ContextT = JSContext;

   JSONStringBuilder {
   public:
    JSStringBuilder buffer;

  explicitJSONStringBuilder(JSContext* cx) : buffer(cx) {}

    boolpublic:
t CharT* begin, const CharT* end);
  };

  explicit JSONFullParseHandler(JSContext* cx) : Base

  JSONFullParseHandler(JSONFullParseHandler&& other) noexcept
      :      : :Maybe::ConstUTF8CharsZ>filename;

  JSONFullParseHandler(const JSONFullParseHandler& other) = delete;
voidoperator=constJSONFullParseHandler& other) = delete;

  java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
  inline privatejava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
                             mozilla::Span<  // objects. These vectors are not freed until  of theparse to avoid
template <JSONStringType ST>
  inline bool setStringValue(JSONStringBuilder& builder
                             mozilla  explicitJSONFullParseHandlerAnyChar(JSContext*cx)
  inline java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  inline bool  JSONFullParseHandlerAnyChar(JSONFullParseHandlerAnyChar&& other) noexcept;
  inline bool setNullValuejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  void reportError(const char* msg, uint32_t line, uint32_t column      delete;
};

JSContext context(){return cx;}
java.lang.StringIndexOutOfBoundsException: Range [0, 5) out of bounds for length 0
  using  =mozilla::RangedPtr<onst >;
  using BaseMOZ_ASSERTvisNumber(;

 public:;
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0

  tringBuilder typename :;
   }
  using PropertyVector = typename Base::PropertyVector;
using ElementVector= typenameBase::lementVector;

 public:   returnstrval.toString)-()java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
explicit JSONReviveHandler(JSContext*):Base(cx) parseRecordStack(cx) {}

  JSONReviveHandler(  inline JS::Value nullValue return JS:NullValue(;}
:Basestd:move(other)),
        parseRecordStack(std::move(other.parseRecordStack)) {}

  JSONReviveHandler(const JSONReviveHandler& other) =   inline bool objectPropertyName(Vector<StackEntry, 10>&
  java.lang.StringIndexOutOfBoundsException: Range [47, 6) out of bounds for length 58

  JSContext* inline finishObjectMemberVectorStackEntry10&stack,

  template <                   java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 62
  inline bool setStringValue(CharPtr start                           JS:MutableHandle<JS:Value vpjava.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
    if (!Base::                           *properties)java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
                                           :forward<SourceT&>(ource))){
      ;
    }
                               ::andle<JS:Value value,
    if constexpr (ST == JSONStringType::PropertyName) {
return true;
    }
    return finishPrimitiveParseRecord(this->vinlinebool finishArray(VectorStackEntry,10>&&nbsp;stack,
  }

template JSONStringType ST>
  inline bool                 ElementVector elements);
    if (!Base::template setStringValue<java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
                                            return parseType = ::AttemptForEval;
java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 19
    }
    // Property names don't need parse records.
     constexpr  ( = JSONStringType:PropertyName) {
      return true;
    }
    return java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 0


  java.lang.StringIndexOutOfBoundsException: Range [0, 8) out of bounds for length 0
    class MOZ_STACK_CLASSJSONFullParseHandler
      return false;
    }
    return finishPrimitiveParseRecord(this->v, source usingBase= JSONFullParseHandlerAnyChar;
  }

  inline bool setBooleanValue(bool value, SourceT&& source) {
    return finishPrimitiveParseRecord(JS::BooleanValue(value), source);
  }
  inline  (SourceT& source){
    return java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }

  inline bool objectOpen(Vector
                         PropertyVector**properties)java.lang.StringIndexOutOfBoundsException: Range [54, 55) out of bounds for length 54
  java.lang.StringIndexOutOfBoundsException: Range [32, 8) out of bounds for length 63

                                 PropertyVector** properties);
  inline  explicitJSONFullParseHandler(JSContext*cx :Base) {}
                       JS:MutableHandle<JS::Value> vp,
                           PropertyVector* properties);


ElementVector* elements);
  inline bool arrayElement(Vector< operator(JSONFullParseHandlerother=deletejava.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
                           :Handle<JS:Value valuejava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
                          ElementVector*elements);
  inline bool finishArraytemplate<JSONStringType STjava.lang.StringIndexOutOfBoundsException: Range [30, 31) out of bounds for length 30
                          ::MutableHandle<:Value>vp,
                          ElementVector* elements);

  void trace(                            mozilla:Span<onst CharT& source);

   inline setNumberValue(double d, mozilla::Span<const CharT>&& source);
    .back();
  };

 private:
  inline bool finishPrimitiveParseRecord(const Value& value,java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 0

  GCVector<ParseRecordObject*, 10> parseRecordStack;
};

template <template <typename>
class MOZ_STACK_CLASS JSONSyntaxParseHandler {
 private:
  using CharPtr = mozilla::RangedPtr<const CharT>;

 public:
  /* Types for templatized parser. */

  using ContextT = FrontendContext;

  class DummyValueusing JSONStringBuilder = ypenameBase::SONStringBuilder;

  struct ElementVector {};
  struct  {};

  class JSONStringBuilder {
   public:
    explicit*)}


bool( ,constCharTend   java.lang.StringIndexOutOfBoundsException: Range [70, 67) out of bounds for length 70
}java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4

        parseRecordStackstd:move(ther.parseRecordStack)) {}
  JSONParserState state;
  };

 public:
  FrontendContext* fc;

  /* Public API */JSContext* context){return this-cx }

  /* Create a parser for the provided JSON data. */ bool setStringValueCharPtr start size_t length, SourceT&& source) {
explicit JSONSyntaxParseHandler(FrontendContext* fc):fc(fc) {

  JSONSyntaxParseHandler(JSONSyntaxParseHandler&& other) noexcept
      : fc(other.fc) {}

  ndlerconst JSONSyntaxParseHandler& other) = delete;
  void operator=(const java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 5

       truejava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18

  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  inline boolsetStringValueJSONStringBuilder&builder,SourceT& source) java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
                             mozilla:Spanjava.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
    returntruejava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
  }

  template <JSONStringType ST>
  inline bool setStringValue(JSONStringBuilder}
                             mozilla::Span<const/java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
    return true;
  }

  inline bool java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 18
    return true;
  }
  inline bool setBooleanValue(bool value, mozilla::Span<const}
    return true;
  }
 inline  setNullValue(mozilla::panconst >& source){return true; }

  inline     (!ase:setNumberValue(d, std::forward<SourceT&&>(source))) {

  inline DummyValue stringValue() const { return java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 5

  inline DummyValue booleanValue(bool
  inline DummyValue nullValue( {return DummyValue(); }

  inline bool objectOpen(VectorreturnfinishPrimitiveParseRecord(:BooleanValue(value), source);
                         PropertyVector** properties);
  inline bool java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 3
                                 *isProtoInEval) {
    *isProtoInEval = false;
    return    return finishPrimitiveParseRecord(:NullValue(), source);
  }
  inline bool java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
DummyValue value
                                 PropertyVector** properties) {
    return true;
  }
  inline bool finishObject(Vector<StackEntry, 10>& stack, DummyValue* java.lang.StringIndexOutOfBoundsException: Range [0, 72) out of bounds for length 63
                           PropertyVector* properties);

  inline bool arrayOpen(Vector<StackEntry, 10>& stack,
                        ElementVector** elements);
  inline bool arrayElement(Vector<StackEntry, 10>& stack, DummyValue& value,
                           ElementVector**  inline bool Vector<StackEntry, 10>& stack,
    return true;
  }
  inline bool finishArray(Vector<StackEntry, 10>& stack, DummyValue* vp,
                          ElementVector* elements);

  inline bool                           :MutableHandle<JS:Value ,

  inline bool ignoreError() const { java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0

   freeStackEntry(StackEntry& entry) {}

  void reportError(const char* msg, uint32_t linereturn parseRecordStack.back();
};

template <typename CharTprivate:
class MOZ_STACK_CLASS JSONPerHandlerParser {
  using ContextT =typename HandlerT:ContextT;

  using Tokenizer = JSONTokenizer<CharT, JSONPerHandlerParser<CharT, 

 public:
  using JSONStringBuilder = java.lang.StringIndexOutOfBoundsException: Range [0, 36) out of bounds for length 2

 publicclass MOZ_STACK_CLASS JSONSyntaxParseHandler {
  HandlerT handler;
  ertokenizer;

  // All in progress arrays and objects being parsed, in order from outermost
  // to innermost.
  Vector<typename HandlerT::StackEntry, 10> stack;

 public:
  /
      : java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 0

  sElementVector}java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
      : handler(std::move
        tokenizer:move(ther.tokenizer),
tackhandler..ontext() {
    tokenizer.fixupParser(this);
  }

  ~explicit JSONStringBui(rontendContext* fc){java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54

      bool append CharT*begin,const ){return true;}
      delete;
  void operator=(const}java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4

  template <    JSONParserState state;
  inline bool parseImpl(java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 4

  void outOfMemory()java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21

  void   /* Createa parser for provided JSONdata.*java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
};

template <typename CharT>
class
: JSONPerHandlerParser<CharT,JSONFullParseHandler<CharT>> {
  using Base = JSONPerHandlerParser<CharT,      :fcother.fc){java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23

 public:
  using ParseType = JSONFullParseHandlerAnyChar:void =(constJSONSyntaxParseHandler& ;other) = delete;

  /* Public API */

  /* Create a parser for the provided JSON data. */
JSONParser(JSContext cx,mozilla:Range<const CharT>data,
 ParseType parseType)
      : Base(cx, data) {
    this->handler.parseType = parseType;
  }

  /* Allow move construction for use with Rooted. */
  JSONParserreturn true;

  JSONParser(
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  /*
*Parse the JSON data specified at construction time.  If it parses
   successfully, store the prescribed value in *vp and return true.  If an
   * internal error (e.g.   return true;
* Otherwise, if invalid input was specifed but no internal error occurred,
  depends upon the error handling specified at construction: if
 then throw aSyntaxError and return false,
    otherwise returntrue and set vpto|ndefined|. (SON  can'java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
*undefined,so  JSON data couldn' have specified it.java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
   */
  bool parse(JS::MutableHandle<JS::Value> vp);

  void reportLineNumbersFromParsedData(bool b) {
    this->handler.  inline bool arrayOpen bool arrayOpen(VectorStackEntry,10&stack,
  }

  /**
   * Set a filename to be used in error messages.
   * This is optional and only used for error reporting.
   */
  java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 16
java.lang.StringIndexOutOfBoundsException: Range [69, 53) out of bounds for length 53
   bool(const{returnfalse;}

  void trace(JSTracer* trc);
};

template <typename CharT>
class MOZ_STACK_CLASS JSONReviveParser
    
 Base=JSONPerHandlerParser<CharT, JSONReviveHandler<CharT>>;

public:
  using ParseType = JSONFullParseHandlerAnyChar::ParseType;

  /* Public API */

class MOZ_STACK_CLASS JSONPerHandlerParser {
  JSONReviveParser(JSContext* cx  using ContextT =typename HandlerT::ContextT;
      : Base(cx, data

  /* Allow move construction for use with Rooted. */
  JSONReviveParser(JSONReviveParser&& 
     :Base::move(other) {}

JSONReviveParser(const JSONReviveParser& other) = delete;
  void

  /*
    dataspecified at construction time.  If it parses
  store the  value in *vp and return true.  If an
    internal error (eg OOM)occurs during parsing, return false.
   , if invalid input was specifed but no internal error occurred,
   behavior depends upon the error handling specified at construction: if
   * error handling is RaiseError then throw a SyntaxError and return false,
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   * template typename 
   java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
* it parses successfully, parse information for calling the reviver
   *function  stored in pro If this function returns false,*pro  be
   * set        c, ){
   */
  bool parse(JS::MutableHandle<JS::Value }
             JS::MutableHandle<ParseRecordObject

  void trace  JSONParser(JSONParser& other)noexcept :Base(std:ove(ther) {}
};

ame CharT typename Wrapper>
class java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0
    :public WrappedPtrOperations<JSONParser<CharT>, Wrapper> java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
 public:
  bool parse(JS::MutableHandle<JS::Value> vp) {
    return static_cast<Wrapper*>(this)->get().parse(vp);

  void setFilename(JS:*internalerror(. java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 67
    static_cast<Wrapper*>(this)->get().setFilename(filename);
  }
  void reportLineNumbersFromParsedData(bool b) {
static_castWrapper>-get)reportLineNumbersFromParsedData(b);
  }
};

template <typename CharT>
class MOZ_STACK_CLASS JSONSyntaxParser
    : JSONPerHandlerParser<CharT, JSONSyntaxParseHandler<CharT>> {
  using HandlerT = JSONSyntaxParseHandler<CharT>;
  using Base = JSONPerHandlerParser<CharT, HandlerT>;

 public:
  JSONSyntaxParser(FrontendContext* * behavior depends upon the error handling at construction:if
      : Base(fc, data) {}

axParserJSONSyntaxParser<CharT>&& other) noexcept
      : Base(std::move(other)) {}

  JSONSyntaxParser(const    * otherwise return true set*vp to |ndefined|. (SON can
  void operator=(const JSONSyntaxParser& other) = delete;

  bool parse();
};

} 

#    -handlerreportLineNumbersFromParsedData  java.lang.StringIndexOutOfBoundsException: Range [5, 53) out of bounds for length 5