summaryrefslogtreecommitdiffstats
path: root/js/src/vm/JSONParser.h
diff options
context:
space:
mode:
Diffstat (limited to 'js/src/vm/JSONParser.h')
-rw-r--r--js/src/vm/JSONParser.h268
1 files changed, 268 insertions, 0 deletions
diff --git a/js/src/vm/JSONParser.h b/js/src/vm/JSONParser.h
new file mode 100644
index 000000000..797aaca5f
--- /dev/null
+++ b/js/src/vm/JSONParser.h
@@ -0,0 +1,268 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ * vim: set ts=8 sts=4 et sw=4 tw=99:
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef vm_JSONParser_h
+#define vm_JSONParser_h
+
+#include "mozilla/Attributes.h"
+#include "mozilla/Range.h"
+
+#include "jspubtd.h"
+
+#include "ds/IdValuePair.h"
+#include "vm/String.h"
+
+namespace js {
+
+// JSONParser base class. JSONParser is templatized to work on either Latin1
+// or TwoByte input strings, JSONParserBase holds all state and methods that
+// can be shared between the two encodings.
+class MOZ_STACK_CLASS JSONParserBase
+{
+ public:
+ enum ErrorHandling { RaiseError, NoError };
+
+ private:
+ /* Data members */
+ Value v;
+
+ protected:
+ JSContext * const cx;
+
+ const ErrorHandling errorHandling;
+
+ enum Token { String, Number, True, False, Null,
+ ArrayOpen, ArrayClose,
+ ObjectOpen, ObjectClose,
+ Colon, Comma,
+ OOM, Error };
+
+ // 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
+ // 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.
+
+ // State for an array that is currently being parsed. This includes all
+ // elements that have been seen so far.
+ typedef Vector<Value, 20> ElementVector;
+
+ // State for an object that is currently being parsed. This includes all
+ // the key/value pairs that have been seen so far.
+ typedef Vector<IdValuePair, 10> PropertyVector;
+
+ // Possible states the parser can be in between values.
+ enum ParserState {
+ // An array element has just being parsed.
+ FinishArrayElement,
+
+ // An object property has just been parsed.
+ FinishObjectMember,
+
+ // At the start of the parse, before any values have been processed.
+ JSONValue
+ };
+
+ // Stack element for an in progress array or object.
+ struct StackEntry {
+ ElementVector& elements() {
+ MOZ_ASSERT(state == FinishArrayElement);
+ return * static_cast<ElementVector*>(vector);
+ }
+
+ PropertyVector& properties() {
+ MOZ_ASSERT(state == FinishObjectMember);
+ return * static_cast<PropertyVector*>(vector);
+ }
+
+ explicit StackEntry(ElementVector* elements)
+ : state(FinishArrayElement), vector(elements)
+ {}
+
+ explicit StackEntry(PropertyVector* properties)
+ : state(FinishObjectMember), vector(properties)
+ {}
+
+ ParserState state;
+
+ private:
+ void* vector;
+ };
+
+ // All in progress arrays and objects being parsed, in order from outermost
+ // to innermost.
+ Vector<StackEntry, 10> stack;
+
+ // Unused element and property vectors for previous in progress arrays and
+ // objects. These vectors are not freed until the end of the parse to avoid
+ // unnecessary freeing and allocation.
+ Vector<ElementVector*, 5> freeElements;
+ Vector<PropertyVector*, 5> freeProperties;
+
+#ifdef DEBUG
+ Token lastToken;
+#endif
+
+ JSONParserBase(JSContext* cx, ErrorHandling errorHandling)
+ : cx(cx),
+ errorHandling(errorHandling),
+ stack(cx),
+ freeElements(cx),
+ freeProperties(cx)
+#ifdef DEBUG
+ , lastToken(Error)
+#endif
+ {}
+ ~JSONParserBase();
+
+ // Allow move construction for use with Rooted.
+ JSONParserBase(JSONParserBase&& other)
+ : v(other.v),
+ cx(other.cx),
+ errorHandling(other.errorHandling),
+ stack(mozilla::Move(other.stack)),
+ freeElements(mozilla::Move(other.freeElements)),
+ freeProperties(mozilla::Move(other.freeProperties))
+#ifdef DEBUG
+ , lastToken(mozilla::Move(other.lastToken))
+#endif
+ {}
+
+
+ Value numberValue() const {
+ MOZ_ASSERT(lastToken == Number);
+ MOZ_ASSERT(v.isNumber());
+ return v;
+ }
+
+ Value stringValue() const {
+ MOZ_ASSERT(lastToken == String);
+ MOZ_ASSERT(v.isString());
+ return v;
+ }
+
+ JSAtom* atomValue() const {
+ Value strval = stringValue();
+ return &strval.toString()->asAtom();
+ }
+
+ Token token(Token t) {
+ MOZ_ASSERT(t != String);
+ MOZ_ASSERT(t != Number);
+#ifdef DEBUG
+ lastToken = t;
+#endif
+ return t;
+ }
+
+ Token stringToken(JSString* str) {
+ this->v = StringValue(str);
+#ifdef DEBUG
+ lastToken = String;
+#endif
+ return String;
+ }
+
+ Token numberToken(double d) {
+ this->v = NumberValue(d);
+#ifdef DEBUG
+ lastToken = Number;
+#endif
+ return Number;
+ }
+
+ enum StringType { PropertyName, LiteralValue };
+
+ bool errorReturn();
+
+ bool finishObject(MutableHandleValue vp, PropertyVector& properties);
+ bool finishArray(MutableHandleValue vp, ElementVector& elements);
+
+ void trace(JSTracer* trc);
+
+ private:
+ JSONParserBase(const JSONParserBase& other) = delete;
+ void operator=(const JSONParserBase& other) = delete;
+};
+
+template <typename CharT>
+class MOZ_STACK_CLASS JSONParser : public JSONParserBase
+{
+ private:
+ typedef mozilla::RangedPtr<const CharT> CharPtr;
+
+ CharPtr current;
+ const CharPtr begin, end;
+
+ public:
+ /* Public API */
+
+ /* Create a parser for the provided JSON data. */
+ JSONParser(JSContext* cx, mozilla::Range<const CharT> data,
+ ErrorHandling errorHandling = RaiseError)
+ : JSONParserBase(cx, errorHandling),
+ current(data.begin()),
+ begin(current),
+ end(data.end())
+ {
+ MOZ_ASSERT(current <= end);
+ }
+
+ /* Allow move construction for use with Rooted. */
+ JSONParser(JSONParser&& other)
+ : JSONParserBase(mozilla::Move(other)),
+ current(other.current),
+ begin(other.begin),
+ end(other.end)
+ {}
+
+ /*
+ * 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. OOM) occurs during parsing, return false.
+ * Otherwise, 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,
+ * otherwise return true and set *vp to |undefined|. (JSON syntax can't
+ * represent |undefined|, so the JSON data couldn't have specified it.)
+ */
+ bool parse(MutableHandleValue vp);
+
+ static void trace(JSONParser<CharT>* parser, JSTracer* trc) { parser->trace(trc); }
+ void trace(JSTracer* trc) { JSONParserBase::trace(trc); }
+
+ private:
+ template<StringType ST> Token readString();
+
+ Token readNumber();
+
+ Token advance();
+ Token advancePropertyName();
+ Token advancePropertyColon();
+ Token advanceAfterProperty();
+ Token advanceAfterObjectOpen();
+ Token advanceAfterArrayElement();
+
+ void error(const char* msg);
+
+ void getTextPosition(uint32_t* column, uint32_t* line);
+
+ private:
+ JSONParser(const JSONParser& other) = delete;
+ void operator=(const JSONParser& other) = delete;
+};
+
+template <typename CharT>
+struct RootedBase<JSONParser<CharT>> {
+ bool parse(MutableHandleValue vp) {
+ return static_cast<Rooted<JSONParser<CharT>>*>(this)->get().parse(vp);
+ }
+};
+
+} /* namespace js */
+
+#endif /* vm_JSONParser_h */