From: Manuel Klimek Date: Tue, 17 Apr 2012 17:21:17 +0000 (+0000) Subject: Goodbye, JSONParser... X-Git-Url: http://demsky.eecs.uci.edu/git/?a=commitdiff_plain;h=61c3d3001515619ce112ae6e26b7d127a4db1b1c;p=oota-llvm.git Goodbye, JSONParser... git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@154930 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/CMakeLists.txt b/CMakeLists.txt index 8336bc975e3..a98dd500596 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -396,7 +396,6 @@ add_subdirectory(utils/FileUpdate) add_subdirectory(utils/count) add_subdirectory(utils/not) add_subdirectory(utils/llvm-lit) -add_subdirectory(utils/json-bench) add_subdirectory(utils/yaml-bench) add_subdirectory(projects) diff --git a/include/llvm/Support/JSONParser.h b/include/llvm/Support/JSONParser.h deleted file mode 100644 index 11149f1e47b..00000000000 --- a/include/llvm/Support/JSONParser.h +++ /dev/null @@ -1,448 +0,0 @@ -//===--- JSONParser.h - Simple JSON parser ----------------------*- C++ -*-===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// -// -// This file implements a JSON parser. -// -// See http://www.json.org/ for an overview. -// See http://www.ietf.org/rfc/rfc4627.txt for the full standard. -// -// FIXME: Currently this supports a subset of JSON. Specifically, support -// for numbers, booleans and null for values is missing. -// -//===----------------------------------------------------------------------===// - -#ifndef LLVM_SUPPORT_JSON_PARSER_H -#define LLVM_SUPPORT_JSON_PARSER_H - -#include "llvm/ADT/StringRef.h" -#include "llvm/Support/Allocator.h" -#include "llvm/Support/Casting.h" -#include "llvm/Support/ErrorHandling.h" -#include "llvm/Support/SourceMgr.h" - -namespace llvm { - -class JSONContainer; -class JSONString; -class JSONValue; -class JSONKeyValuePair; - -/// \brief Base class for a parsable JSON atom. -/// -/// This class has no semantics other than being a unit of JSON data which can -/// be parsed out of a JSON document. -class JSONAtom { -public: - /// \brief Possible types of JSON objects. - enum Kind { JK_KeyValuePair, JK_Array, JK_Object, JK_String }; - - /// \brief Returns the type of this value. - Kind getKind() const { return MyKind; } - - static bool classof(const JSONAtom *Atom) { return true; } - -protected: - JSONAtom(Kind MyKind) : MyKind(MyKind) {} - -private: - Kind MyKind; -}; - -/// \brief A parser for JSON text. -/// -/// Use an object of JSONParser to iterate over the values of a JSON text. -/// All objects are parsed during the iteration, so you can only iterate once -/// over the JSON text, but the cost of partial iteration is minimized. -/// Create a new JSONParser if you want to iterate multiple times. -class JSONParser { -public: - /// \brief Create a JSONParser for the given input. - /// - /// Parsing is started via parseRoot(). Access to the object returned from - /// parseRoot() will parse the input lazily. - JSONParser(StringRef Input, SourceMgr *SM); - - /// \brief Returns the outermost JSON value (either an array or an object). - /// - /// Can return NULL if the input does not start with an array or an object. - /// The object is not parsed yet - the caller must iterate over the - /// returned object to trigger parsing. - /// - /// A JSONValue can be either a JSONString, JSONObject or JSONArray. - JSONValue *parseRoot(); - - /// \brief Parses the JSON text and returns whether it is valid JSON. - /// - /// In case validate() return false, failed() will return true and - /// getErrorMessage() will return the parsing error. - bool validate(); - - /// \brief Returns true if an error occurs during parsing. - /// - /// If there was an error while parsing an object that was created by - /// iterating over the result of 'parseRoot', 'failed' will return true. - bool failed() const; - -private: - /// \brief These methods manage the implementation details of parsing new JSON - /// atoms. - /// @{ - JSONString *parseString(); - JSONValue *parseValue(); - JSONKeyValuePair *parseKeyValuePair(); - /// @} - - /// \brief Helpers to parse the elements out of both forms of containers. - /// @{ - const JSONAtom *parseElement(JSONAtom::Kind ContainerKind); - StringRef::iterator parseFirstElement(JSONAtom::Kind ContainerKind, - char StartChar, char EndChar, - const JSONAtom *&Element); - StringRef::iterator parseNextElement(JSONAtom::Kind ContainerKind, - char EndChar, - const JSONAtom *&Element); - /// @} - - /// \brief Whitespace parsing. - /// @{ - void nextNonWhitespace(); - bool isWhitespace(); - /// @} - - /// \brief These methods are used for error handling. - /// { - void setExpectedError(StringRef Expected, StringRef Found); - void setExpectedError(StringRef Expected, char Found); - bool errorIfAtEndOfFile(StringRef Message); - bool errorIfNotAt(char C, StringRef Message); - /// } - - /// \brief Skips all elements in the given container. - bool skipContainer(const JSONContainer &Container); - - /// \brief Skips to the next position behind the given JSON atom. - bool skip(const JSONAtom &Atom); - - /// All nodes are allocated by the parser and will be deallocated when the - /// parser is destroyed. - BumpPtrAllocator ValueAllocator; - - /// \brief The original input to the parser. - MemoryBuffer *InputBuffer; - - /// \brief The source manager used for diagnostics and buffer management. - SourceMgr *SM; - - /// \brief The current position in the parse stream. - StringRef::iterator Position; - - /// \brief The end position for fast EOF checks without introducing - /// unnecessary dereferences. - StringRef::iterator End; - - /// \brief If true, an error has occurred. - bool Failed; - - friend class JSONContainer; -}; - - -/// \brief Base class for JSON value objects. -/// -/// This object represents an abstract JSON value. It is the root node behind -/// the group of JSON entities that can represent top-level values in a JSON -/// document. It has no API, and is just a placeholder in the type hierarchy of -/// nodes. -class JSONValue : public JSONAtom { -protected: - JSONValue(Kind MyKind) : JSONAtom(MyKind) {} - -public: - /// \brief dyn_cast helpers - ///@{ - static bool classof(const JSONAtom *Atom) { - switch (Atom->getKind()) { - case JK_Array: - case JK_Object: - case JK_String: - return true; - case JK_KeyValuePair: - return false; - } - llvm_unreachable("Invalid JSONAtom kind"); - } - static bool classof(const JSONValue *Value) { return true; } - ///@} -}; - -/// \brief Gives access to the text of a JSON string. -/// -/// FIXME: Implement a method to return the unescaped text. -class JSONString : public JSONValue { -public: - /// \brief Returns the underlying parsed text of the string. - /// - /// This is the unescaped content of the JSON text. - /// See http://www.ietf.org/rfc/rfc4627.txt for details. - StringRef getRawText() const { return RawText; } - -private: - JSONString(StringRef RawText) : JSONValue(JK_String), RawText(RawText) {} - - StringRef RawText; - - friend class JSONParser; - -public: - /// \brief dyn_cast helpers - ///@{ - static bool classof(const JSONAtom *Atom) { - return Atom->getKind() == JK_String; - } - static bool classof(const JSONString *String) { return true; } - ///@} -}; - -/// \brief A (key, value) tuple of type (JSONString *, JSONValue *). -/// -/// Note that JSONKeyValuePair is not a JSONValue, it is a bare JSONAtom. -/// JSONKeyValuePairs can be elements of a JSONObject, but not of a JSONArray. -/// They are not viable as top-level values either. -class JSONKeyValuePair : public JSONAtom { -public: - const JSONString * const Key; - const JSONValue * const Value; - -private: - JSONKeyValuePair(const JSONString *Key, const JSONValue *Value) - : JSONAtom(JK_KeyValuePair), Key(Key), Value(Value) {} - - friend class JSONParser; - -public: - /// \brief dyn_cast helpers - ///@{ - static bool classof(const JSONAtom *Atom) { - return Atom->getKind() == JK_KeyValuePair; - } - static bool classof(const JSONKeyValuePair *KeyValuePair) { return true; } - ///@} -}; - -/// \brief Implementation of JSON containers (arrays and objects). -/// -/// JSONContainers drive the lazy parsing of JSON arrays and objects via -/// forward iterators. -class JSONContainer : public JSONValue { -private: - /// \brief An iterator that parses the underlying container during iteration. - /// - /// Iterators on the same collection use shared state, so when multiple copies - /// of an iterator exist, only one is allowed to be used for iteration; - /// iterating multiple copies of an iterator of the same collection will lead - /// to undefined behavior. - class AtomIterator { - public: - AtomIterator(const AtomIterator &I) : Container(I.Container) {} - - /// \brief Iterator interface. - ///@{ - bool operator==(const AtomIterator &I) const { - if (isEnd() || I.isEnd()) - return isEnd() == I.isEnd(); - return Container->Position == I.Container->Position; - } - bool operator!=(const AtomIterator &I) const { - return !(*this == I); - } - AtomIterator &operator++() { - Container->parseNextElement(); - return *this; - } - const JSONAtom *operator*() { - return Container->Current; - } - ///@} - - private: - /// \brief Create an iterator for which 'isEnd' returns true. - AtomIterator() : Container(0) {} - - /// \brief Create an iterator for the given container. - AtomIterator(const JSONContainer *Container) : Container(Container) {} - - bool isEnd() const { - return Container == 0 || Container->Position == StringRef::iterator(); - } - - const JSONContainer * const Container; - - friend class JSONContainer; - }; - -protected: - /// \brief An iterator for the specified AtomT. - /// - /// Used for the implementation of iterators for JSONArray and JSONObject. - template - class IteratorTemplate : public std::iterator { - public: - explicit IteratorTemplate(const AtomIterator& AtomI) - : AtomI(AtomI) {} - - bool operator==(const IteratorTemplate &I) const { - return AtomI == I.AtomI; - } - bool operator!=(const IteratorTemplate &I) const { return !(*this == I); } - - IteratorTemplate &operator++() { - ++AtomI; - return *this; - } - - const AtomT *operator*() { return dyn_cast(*AtomI); } - - private: - AtomIterator AtomI; - }; - - JSONContainer(JSONParser *Parser, char StartChar, char EndChar, - JSONAtom::Kind ContainerKind) - : JSONValue(ContainerKind), Parser(Parser), - Position(), Current(0), Started(false), - StartChar(StartChar), EndChar(EndChar) {} - - /// \brief Returns a lazy parsing iterator over the container. - /// - /// As the iterator drives the parse stream, begin() must only be called - /// once per container. - AtomIterator atom_begin() const { - if (Started) - report_fatal_error("Cannot parse container twice."); - Started = true; - // Set up the position and current element when we begin iterating over the - // container. - Position = Parser->parseFirstElement(getKind(), StartChar, EndChar, Current); - return AtomIterator(this); - } - AtomIterator atom_end() const { - return AtomIterator(); - } - -private: - AtomIterator atom_current() const { - if (!Started) - return atom_begin(); - - return AtomIterator(this); - } - - /// \brief Parse the next element in the container into the Current element. - /// - /// This routine is called as an iterator into this container walks through - /// its elements. It mutates the container's internal current node to point to - /// the next atom of the container. - void parseNextElement() const { - Parser->skip(*Current); - Position = Parser->parseNextElement(getKind(), EndChar, Current); - } - - // For parsing, JSONContainers call back into the JSONParser. - JSONParser * const Parser; - - // 'Position', 'Current' and 'Started' store the state of the parse stream - // for iterators on the container, they don't change the container's elements - // and are thus marked as mutable. - mutable StringRef::iterator Position; - mutable const JSONAtom *Current; - mutable bool Started; - - const char StartChar; - const char EndChar; - - friend class JSONParser; - -public: - /// \brief dyn_cast helpers - ///@{ - static bool classof(const JSONAtom *Atom) { - switch (Atom->getKind()) { - case JK_Array: - case JK_Object: - return true; - case JK_KeyValuePair: - case JK_String: - return false; - } - llvm_unreachable("Invalid JSONAtom kind"); - } - static bool classof(const JSONContainer *Container) { return true; } - ///@} -}; - -/// \brief A simple JSON array. -class JSONArray : public JSONContainer { -public: - typedef IteratorTemplate const_iterator; - - /// \brief Returns a lazy parsing iterator over the container. - /// - /// As the iterator drives the parse stream, begin() must only be called - /// once per container. - const_iterator begin() const { return const_iterator(atom_begin()); } - const_iterator end() const { return const_iterator(atom_end()); } - -private: - JSONArray(JSONParser *Parser) - : JSONContainer(Parser, '[', ']', JSONAtom::JK_Array) {} - -public: - /// \brief dyn_cast helpers - ///@{ - static bool classof(const JSONAtom *Atom) { - return Atom->getKind() == JSONAtom::JK_Array; - } - static bool classof(const JSONArray *Array) { return true; } - ///@} - - friend class JSONParser; -}; - -/// \brief A JSON object: an iterable list of JSON key-value pairs. -class JSONObject : public JSONContainer { -public: - typedef IteratorTemplate const_iterator; - - /// \brief Returns a lazy parsing iterator over the container. - /// - /// As the iterator drives the parse stream, begin() must only be called - /// once per container. - const_iterator begin() const { return const_iterator(atom_begin()); } - const_iterator end() const { return const_iterator(atom_end()); } - -private: - JSONObject(JSONParser *Parser) - : JSONContainer(Parser, '{', '}', JSONAtom::JK_Object) {} - -public: - /// \brief dyn_cast helpers - ///@{ - static bool classof(const JSONAtom *Atom) { - return Atom->getKind() == JSONAtom::JK_Object; - } - static bool classof(const JSONObject *Object) { return true; } - ///@} - - friend class JSONParser; -}; - -} // end namespace llvm - -#endif // LLVM_SUPPORT_JSON_PARSER_H diff --git a/lib/Support/CMakeLists.txt b/lib/Support/CMakeLists.txt index 9b3b6c801dd..fbbcf78397e 100644 --- a/lib/Support/CMakeLists.txt +++ b/lib/Support/CMakeLists.txt @@ -32,7 +32,6 @@ add_llvm_library(LLVMSupport IntrusiveRefCntPtr.cpp IsInf.cpp IsNAN.cpp - JSONParser.cpp LockFileManager.cpp ManagedStatic.cpp MemoryBuffer.cpp diff --git a/lib/Support/JSONParser.cpp b/lib/Support/JSONParser.cpp deleted file mode 100644 index 5dfcf297a7e..00000000000 --- a/lib/Support/JSONParser.cpp +++ /dev/null @@ -1,302 +0,0 @@ -//===--- JSONParser.cpp - Simple JSON parser ------------------------------===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// -// -// This file implements a JSON parser. -// -//===----------------------------------------------------------------------===// - -#include "llvm/Support/JSONParser.h" - -#include "llvm/ADT/Twine.h" -#include "llvm/Support/Casting.h" -#include "llvm/Support/MemoryBuffer.h" - -using namespace llvm; - -JSONParser::JSONParser(StringRef Input, SourceMgr *SM) - : SM(SM), Failed(false) { - InputBuffer = MemoryBuffer::getMemBuffer(Input, "JSON"); - SM->AddNewSourceBuffer(InputBuffer, SMLoc()); - End = InputBuffer->getBuffer().end(); - Position = InputBuffer->getBuffer().begin(); -} - -JSONValue *JSONParser::parseRoot() { - if (Position != InputBuffer->getBuffer().begin()) - report_fatal_error("Cannot reuse JSONParser."); - if (isWhitespace()) - nextNonWhitespace(); - if (errorIfAtEndOfFile("'[' or '{' at start of JSON text")) - return 0; - switch (*Position) { - case '[': - return new (ValueAllocator.Allocate(1)) JSONArray(this); - case '{': - return new (ValueAllocator.Allocate(1)) JSONObject(this); - default: - setExpectedError("'[' or '{' at start of JSON text", *Position); - return 0; - } -} - -bool JSONParser::validate() { - JSONValue *Root = parseRoot(); - if (Root == NULL) { - return false; - } - return skip(*Root); -} - -bool JSONParser::skip(const JSONAtom &Atom) { - switch(Atom.getKind()) { - case JSONAtom::JK_Array: - case JSONAtom::JK_Object: - return skipContainer(*cast(&Atom)); - case JSONAtom::JK_String: - return true; - case JSONAtom::JK_KeyValuePair: - return skip(*cast(&Atom)->Value); - } - llvm_unreachable("Impossible enum value."); -} - -// Sets the current error to: -// "expected , but found ". -void JSONParser::setExpectedError(StringRef Expected, StringRef Found) { - SM->PrintMessage(SMLoc::getFromPointer(Position), SourceMgr::DK_Error, - "expected " + Expected + ", but found " + Found + ".", ArrayRef()); - Failed = true; -} - -// Sets the current error to: -// "expected , but found ". -void JSONParser::setExpectedError(StringRef Expected, char Found) { - setExpectedError(Expected, ("'" + StringRef(&Found, 1) + "'").str()); -} - -// If there is no character available, returns true and sets the current error -// to: "expected , but found EOF.". -bool JSONParser::errorIfAtEndOfFile(StringRef Expected) { - if (Position == End) { - setExpectedError(Expected, "EOF"); - return true; - } - return false; -} - -// Sets the current error if the current character is not C to: -// "expected 'C', but got ". -bool JSONParser::errorIfNotAt(char C, StringRef Message) { - if (*Position != C) { - std::string Expected = - ("'" + StringRef(&C, 1) + "' " + Message).str(); - if (Position == End) - setExpectedError(Expected, "EOF"); - else - setExpectedError(Expected, *Position); - return true; - } - return false; -} - -// Forbidding inlining improves performance by roughly 20%. -// FIXME: Remove once llvm optimizes this to the faster version without hints. -LLVM_ATTRIBUTE_NOINLINE static bool -wasEscaped(StringRef::iterator First, StringRef::iterator Position); - -// Returns whether a character at 'Position' was escaped with a leading '\'. -// 'First' specifies the position of the first character in the string. -static bool wasEscaped(StringRef::iterator First, - StringRef::iterator Position) { - assert(Position - 1 >= First); - StringRef::iterator I = Position - 1; - // We calulate the number of consecutive '\'s before the current position - // by iterating backwards through our string. - while (I >= First && *I == '\\') --I; - // (Position - 1 - I) now contains the number of '\'s before the current - // position. If it is odd, the character at 'Positon' was escaped. - return (Position - 1 - I) % 2 == 1; -} - -// Parses a JSONString, assuming that the current position is on a quote. -JSONString *JSONParser::parseString() { - assert(Position != End); - assert(!isWhitespace()); - if (errorIfNotAt('"', "at start of string")) - return 0; - StringRef::iterator First = Position + 1; - - // Benchmarking shows that this loop is the hot path of the application with - // about 2/3rd of the runtime cycles. Since escaped quotes are not the common - // case, and multiple escaped backslashes before escaped quotes are very rare, - // we pessimize this case to achieve a smaller inner loop in the common case. - // We're doing that by having a quick inner loop that just scans for the next - // quote. Once we find the quote we check the last character to see whether - // the quote might have been escaped. If the last character is not a '\', we - // know the quote was not escaped and have thus found the end of the string. - // If the immediately preceding character was a '\', we have to scan backwards - // to see whether the previous character was actually an escaped backslash, or - // an escape character for the quote. If we find that the current quote was - // escaped, we continue parsing for the next quote and repeat. - // This optimization brings around 30% performance improvements. - do { - // Step over the current quote. - ++Position; - // Find the next quote. - while (Position != End && *Position != '"') - ++Position; - if (errorIfAtEndOfFile("'\"' at end of string")) - return 0; - // Repeat until the previous character was not a '\' or was an escaped - // backslash. - } while (*(Position - 1) == '\\' && wasEscaped(First, Position)); - - return new (ValueAllocator.Allocate()) - JSONString(StringRef(First, Position - First)); -} - - -// Advances the position to the next non-whitespace position. -void JSONParser::nextNonWhitespace() { - do { - ++Position; - } while (isWhitespace()); -} - -// Checks if there is a whitespace character at the current position. -bool JSONParser::isWhitespace() { - return *Position == ' ' || *Position == '\t' || - *Position == '\n' || *Position == '\r'; -} - -bool JSONParser::failed() const { - return Failed; -} - -// Parses a JSONValue, assuming that the current position is at the first -// character of the value. -JSONValue *JSONParser::parseValue() { - assert(Position != End); - assert(!isWhitespace()); - switch (*Position) { - case '[': - return new (ValueAllocator.Allocate(1)) JSONArray(this); - case '{': - return new (ValueAllocator.Allocate(1)) JSONObject(this); - case '"': - return parseString(); - default: - setExpectedError("'[', '{' or '\"' at start of value", *Position); - return 0; - } -} - -// Parses a JSONKeyValuePair, assuming that the current position is at the first -// character of the key, value pair. -JSONKeyValuePair *JSONParser::parseKeyValuePair() { - assert(Position != End); - assert(!isWhitespace()); - - JSONString *Key = parseString(); - if (Key == 0) - return 0; - - nextNonWhitespace(); - if (errorIfNotAt(':', "between key and value")) - return 0; - - nextNonWhitespace(); - const JSONValue *Value = parseValue(); - if (Value == 0) - return 0; - - return new (ValueAllocator.Allocate(1)) - JSONKeyValuePair(Key, Value); -} - -/// \brief Parses the first element of a JSON array or object, or closes the -/// array. -/// -/// The method assumes that the current position is before the first character -/// of the element, with possible white space in between. When successful, it -/// returns the new position after parsing the element. Otherwise, if there is -/// no next value, it returns a default constructed StringRef::iterator. -StringRef::iterator JSONParser::parseFirstElement(JSONAtom::Kind ContainerKind, - char StartChar, char EndChar, - const JSONAtom *&Element) { - assert(*Position == StartChar); - Element = 0; - nextNonWhitespace(); - if (errorIfAtEndOfFile("value or end of container at start of container")) - return StringRef::iterator(); - - if (*Position == EndChar) - return StringRef::iterator(); - - Element = parseElement(ContainerKind); - if (Element == 0) - return StringRef::iterator(); - - return Position; -} - -/// \brief Parses the next element of a JSON array or object, or closes the -/// array. -/// -/// The method assumes that the current position is before the ',' which -/// separates the next element from the current element. When successful, it -/// returns the new position after parsing the element. Otherwise, if there is -/// no next value, it returns a default constructed StringRef::iterator. -StringRef::iterator JSONParser::parseNextElement(JSONAtom::Kind ContainerKind, - char EndChar, - const JSONAtom *&Element) { - Element = 0; - nextNonWhitespace(); - if (errorIfAtEndOfFile("',' or end of container for next element")) - return 0; - - if (*Position == ',') { - nextNonWhitespace(); - if (errorIfAtEndOfFile("element in container")) - return StringRef::iterator(); - - Element = parseElement(ContainerKind); - if (Element == 0) - return StringRef::iterator(); - - return Position; - } else if (*Position == EndChar) { - return StringRef::iterator(); - } else { - setExpectedError("',' or end of container for next element", *Position); - return StringRef::iterator(); - } -} - -const JSONAtom *JSONParser::parseElement(JSONAtom::Kind ContainerKind) { - switch (ContainerKind) { - case JSONAtom::JK_Array: - return parseValue(); - case JSONAtom::JK_Object: - return parseKeyValuePair(); - default: - llvm_unreachable("Impossible code path"); - } -} - -bool JSONParser::skipContainer(const JSONContainer &Container) { - for (JSONContainer::AtomIterator I = Container.atom_current(), - E = Container.atom_end(); - I != E; ++I) { - assert(*I != 0); - if (!skip(**I)) - return false; - } - return !failed(); -} diff --git a/unittests/CMakeLists.txt b/unittests/CMakeLists.txt index 5d691728d80..78009a86df5 100644 --- a/unittests/CMakeLists.txt +++ b/unittests/CMakeLists.txt @@ -165,7 +165,6 @@ add_llvm_unittest(Support Support/CommandLineTest.cpp Support/ConstantRangeTest.cpp Support/EndianTest.cpp - Support/JSONParserTest.cpp Support/LeakDetectorTest.cpp Support/MathExtrasTest.cpp Support/Path.cpp diff --git a/unittests/Support/JSONParserTest.cpp b/unittests/Support/JSONParserTest.cpp deleted file mode 100644 index e9efb817c29..00000000000 --- a/unittests/Support/JSONParserTest.cpp +++ /dev/null @@ -1,191 +0,0 @@ -//===- unittest/Tooling/JSONParserTest ------------------------------------===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - -#include "llvm/Support/Casting.h" -#include "llvm/Support/JSONParser.h" -#include "llvm/ADT/Twine.h" -#include "gtest/gtest.h" - -namespace llvm { - -// Checks that the given input gives a parse error. Makes sure that an error -// text is available and the parse fails. -static void ExpectParseError(StringRef Message, StringRef Input) { - SourceMgr SM; - JSONParser Parser(Input, &SM); - EXPECT_FALSE(Parser.validate()) << Message << ": " << Input; - EXPECT_TRUE(Parser.failed()) << Message << ": " << Input; -} - -// Checks that the given input can be parsed without error. -static void ExpectParseSuccess(StringRef Message, StringRef Input) { - SourceMgr SM; - JSONParser Parser(Input, &SM); - EXPECT_TRUE(Parser.validate()) << Message << ": " << Input; -} - -TEST(JSONParser, FailsOnEmptyString) { - ExpectParseError("Empty JSON text", ""); -} - -TEST(JSONParser, FailsIfStartsWithString) { - ExpectParseError("Top-level string", "\"x\""); -} - -TEST(JSONParser, ParsesEmptyArray) { - ExpectParseSuccess("Empty array", "[]"); -} - -TEST(JSONParser, FailsIfNotClosingArray) { - ExpectParseError("Not closing array", "["); - ExpectParseError("Not closing array", " [ "); - ExpectParseError("Not closing array", " [x"); -} - -TEST(JSONParser, ParsesEmptyArrayWithWhitespace) { - ExpectParseSuccess("Array with spaces", " [ ] "); - ExpectParseSuccess("All whitespaces", "\t\r\n[\t\n \t\r ]\t\r \n\n"); -} - -TEST(JSONParser, ParsesEmptyObject) { - ExpectParseSuccess("Empty object", "[{}]"); -} - -TEST(JSONParser, ParsesObject) { - ExpectParseSuccess("Object with an entry", "[{\"a\":\"/b\"}]"); -} - -TEST(JSONParser, ParsesMultipleKeyValuePairsInObject) { - ExpectParseSuccess("Multiple key, value pairs", - "[{\"a\":\"/b\",\"c\":\"d\",\"e\":\"f\"}]"); -} - -TEST(JSONParser, FailsIfNotClosingObject) { - ExpectParseError("Missing close on empty", "[{]"); - ExpectParseError("Missing close after pair", "[{\"a\":\"b\"]"); -} - -TEST(JSONParser, FailsIfMissingColon) { - ExpectParseError("Missing colon between key and value", "[{\"a\"\"/b\"}]"); - ExpectParseError("Missing colon between key and value", "[{\"a\" \"b\"}]"); -} - -TEST(JSONParser, FailsOnMissingQuote) { - ExpectParseError("Missing open quote", "[{a\":\"b\"}]"); - ExpectParseError("Missing closing quote", "[{\"a\":\"b}]"); -} - -TEST(JSONParser, ParsesEscapedQuotes) { - ExpectParseSuccess("Parses escaped string in key and value", - "[{\"a\":\"\\\"b\\\" \\\" \\\"\"}]"); -} - -TEST(JSONParser, ParsesEmptyString) { - ExpectParseSuccess("Parses empty string in value", "[{\"a\":\"\"}]"); -} - -TEST(JSONParser, FailsOnMissingString) { - ExpectParseError("Missing value", "[{\"a\":}]"); - ExpectParseError("Missing key", "[{:\"b\"}]"); -} - -TEST(JSONParser, ParsesMultipleObjects) { - ExpectParseSuccess( - "Multiple objects in array", - "[" - " { \"a\" : \"b\" }," - " { \"a\" : \"b\" }," - " { \"a\" : \"b\" }" - "]"); -} - -TEST(JSONParser, FailsOnMissingComma) { - ExpectParseError( - "Missing comma", - "[" - " { \"a\" : \"b\" }" - " { \"a\" : \"b\" }" - "]"); -} - -TEST(JSONParser, FailsOnSuperfluousComma) { - ExpectParseError("Superfluous comma in array", "[ { \"a\" : \"b\" }, ]"); - ExpectParseError("Superfluous comma in object", "{ \"a\" : \"b\", }"); -} - -TEST(JSONParser, ParsesSpacesInBetweenTokens) { - ExpectParseSuccess( - "Various whitespace between tokens", - " \t \n\n \r [ \t \n\n \r" - " \t \n\n \r { \t \n\n \r\"a\"\t \n\n \r :" - " \t \n\n \r \"b\"\t \n\n \r } \t \n\n \r,\t \n\n \r" - " \t \n\n \r { \t \n\n \r\"a\"\t \n\n \r :" - " \t \n\n \r \"b\"\t \n\n \r } \t \n\n \r]\t \n\n \r"); -} - -TEST(JSONParser, ParsesArrayOfArrays) { - ExpectParseSuccess("Array of arrays", "[[]]"); -} - -TEST(JSONParser, HandlesEndOfFileGracefully) { - ExpectParseError("In string starting with EOF", "[\""); - ExpectParseError("In string hitting EOF", "[\" "); - ExpectParseError("In string escaping EOF", "[\" \\"); - ExpectParseError("In array starting with EOF", "["); - ExpectParseError("In array element starting with EOF", "[[], "); - ExpectParseError("In array hitting EOF", "[[] "); - ExpectParseError("In array hitting EOF", "[[]"); - ExpectParseError("In object hitting EOF", "{\"\""); -} - -// Checks that the given string can be parsed into an identical string inside -// of an array. -static void ExpectCanParseString(StringRef String) { - std::string StringInArray = (llvm::Twine("[\"") + String + "\"]").str(); - SourceMgr SM; - JSONParser Parser(StringInArray, &SM); - const JSONArray *ParsedArray = dyn_cast(Parser.parseRoot()); - StringRef ParsedString = - dyn_cast(*ParsedArray->begin())->getRawText(); - EXPECT_EQ(String, ParsedString.str()); -} - -// Checks that parsing the given string inside an array fails. -static void ExpectCannotParseString(StringRef String) { - std::string StringInArray = (llvm::Twine("[\"") + String + "\"]").str(); - ExpectParseError((Twine("When parsing string \"") + String + "\"").str(), - StringInArray); -} - -TEST(JSONParser, ParsesStrings) { - ExpectCanParseString(""); - ExpectCannotParseString("\\"); - ExpectCannotParseString("\""); - ExpectCanParseString(" "); - ExpectCanParseString("\\ "); - ExpectCanParseString("\\\""); - ExpectCannotParseString("\"\\"); - ExpectCannotParseString(" \\"); - ExpectCanParseString("\\\\"); - ExpectCannotParseString("\\\\\\"); - ExpectCanParseString("\\\\\\\\"); - ExpectCanParseString("\\\" "); - ExpectCannotParseString("\\\\\" "); - ExpectCanParseString("\\\\\\\" "); - ExpectCanParseString(" \\\\ \\\" \\\\\\\" "); -} - -TEST(JSONParser, WorksWithIteratorAlgorithms) { - SourceMgr SM; - JSONParser Parser("[\"1\", \"2\", \"3\", \"4\", \"5\", \"6\"]", &SM); - const JSONArray *Array = dyn_cast(Parser.parseRoot()); - EXPECT_EQ(6, std::distance(Array->begin(), Array->end())); -} - -} // end namespace llvm diff --git a/utils/Makefile b/utils/Makefile index b98376006ed..ecb30bed7c6 100644 --- a/utils/Makefile +++ b/utils/Makefile @@ -9,7 +9,7 @@ LEVEL = .. PARALLEL_DIRS := FileCheck FileUpdate TableGen PerfectShuffle \ - count fpcmp llvm-lit not unittest json-bench + count fpcmp llvm-lit not unittest EXTRA_DIST := check-each-file codegen-diff countloc.sh \ DSAclean.py DSAextract.py emacs findsym.pl GenLibDeps.pl \ diff --git a/utils/json-bench/CMakeLists.txt b/utils/json-bench/CMakeLists.txt deleted file mode 100644 index 03ac51ce64a..00000000000 --- a/utils/json-bench/CMakeLists.txt +++ /dev/null @@ -1,5 +0,0 @@ -add_llvm_utility(json-bench - JSONBench.cpp - ) - -target_link_libraries(json-bench LLVMSupport) diff --git a/utils/json-bench/JSONBench.cpp b/utils/json-bench/JSONBench.cpp deleted file mode 100644 index ca8a36a03ab..00000000000 --- a/utils/json-bench/JSONBench.cpp +++ /dev/null @@ -1,85 +0,0 @@ -//===- JSONBench - Benchmark the JSONParser implementation ----------------===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// -// -// This program executes the JSONParser on differntly sized JSON texts and -// outputs the run time. -// -//===----------------------------------------------------------------------===// - -#include "llvm/ADT/Twine.h" -#include "llvm/Support/CommandLine.h" -#include "llvm/Support/JSONParser.h" -#include "llvm/Support/Timer.h" -#include "llvm/Support/raw_ostream.h" - -static llvm::cl::opt -Verify("verify", llvm::cl::desc( - "Run a quick verification useful for regression testing"), - llvm::cl::init(false)); - -static llvm::cl::opt -MemoryLimitMB("memory-limit", llvm::cl::desc( - "Do not use more megabytes of memory"), - llvm::cl::init(1000)); - -void benchmark(llvm::TimerGroup &Group, llvm::StringRef Name, - llvm::StringRef JSONText) { - llvm::Timer BaseLine((Name + ": Loop").str(), Group); - BaseLine.startTimer(); - char C = 0; - for (llvm::StringRef::iterator I = JSONText.begin(), - E = JSONText.end(); - I != E; ++I) { C += *I; } - BaseLine.stopTimer(); - volatile char DontOptimizeOut = C; (void)DontOptimizeOut; - - llvm::Timer Parsing((Name + ": Parsing").str(), Group); - Parsing.startTimer(); - llvm::SourceMgr SM; - llvm::JSONParser Parser(JSONText, &SM); - if (!Parser.validate()) { - llvm::errs() << "Parsing error in JSON parser benchmark.\n"; - exit(1); - } - Parsing.stopTimer(); -} - -std::string createJSONText(size_t MemoryMB, unsigned ValueSize) { - std::string JSONText; - llvm::raw_string_ostream Stream(JSONText); - Stream << "[\n"; - size_t MemoryBytes = MemoryMB * 1024 * 1024; - while (JSONText.size() < MemoryBytes) { - Stream << " {\n" - << " \"key1\": \"" << std::string(ValueSize, '*') << "\",\n" - << " \"key2\": \"" << std::string(ValueSize, '*') << "\",\n" - << " \"key3\": \"" << std::string(ValueSize, '*') << "\"\n" - << " }"; - Stream.flush(); - if (JSONText.size() < MemoryBytes) Stream << ","; - Stream << "\n"; - } - Stream << "]\n"; - Stream.flush(); - return JSONText; -} - -int main(int argc, char **argv) { - llvm::cl::ParseCommandLineOptions(argc, argv); - llvm::TimerGroup Group("JSON parser benchmark"); - if (Verify) { - benchmark(Group, "Fast", createJSONText(10, 500)); - } else { - benchmark(Group, "Small Values", createJSONText(MemoryLimitMB, 5)); - benchmark(Group, "Medium Values", createJSONText(MemoryLimitMB, 500)); - benchmark(Group, "Large Values", createJSONText(MemoryLimitMB, 50000)); - } - return 0; -} - diff --git a/utils/json-bench/Makefile b/utils/json-bench/Makefile deleted file mode 100644 index 6651626f683..00000000000 --- a/utils/json-bench/Makefile +++ /dev/null @@ -1,21 +0,0 @@ -##===- utils/FileCheck/Makefile ----------------------------*- Makefile -*-===## -# -# The LLVM Compiler Infrastructure -# -# This file is distributed under the University of Illinois Open Source -# License. See LICENSE.TXT for details. -# -##===----------------------------------------------------------------------===## - -LEVEL = ../.. -TOOLNAME = json-bench -USEDLIBS = LLVMSupport.a - -# This tool has no plugins, optimize startup time. -TOOL_NO_EXPORTS = 1 - -# Don't install this utility -NO_INSTALL = 1 - -include $(LEVEL)/Makefile.common -