[llvm-commits] [llvm] r154930 - in /llvm/trunk: CMakeLists.txt include/llvm/Support/JSONParser.h lib/Support/CMakeLists.txt lib/Support/JSONParser.cpp unittests/CMakeLists.txt unittests/Support/JSONParserTest.cpp utils/Makefile utils/json-bench/
Manuel Klimek
klimek at google.com
Fri Apr 20 06:47:15 PDT 2012
Done.
On Fri, Apr 20, 2012 at 3:34 PM, Timur Iskhodzhanov <timurrrr at google.com> wrote:
> Hi Manuel,
>
> I still see json-bench in test/CMakeLists.txt:80
> 74 add_dependencies(check.deps
> 75 UnitTests
> 76 BugpointPasses LLVMHello
> 77 llc lli llvm-ar llvm-as llvm-dis llvm-extract llvm-dwarfdump
> 78 llvm-link llvm-mc llvm-nm llvm-objdump llvm-readobj
> 79 macho-dump opt
> 80 FileCheck count not json-bench)
>
>
> Timur Iskhodzhanov,
> Google Russia
>
>
>
>
> On Tue, Apr 17, 2012 at 9:21 PM, Manuel Klimek <klimek at google.com> wrote:
>> Author: klimek
>> Date: Tue Apr 17 12:21:17 2012
>> New Revision: 154930
>>
>> URL: http://llvm.org/viewvc/llvm-project?rev=154930&view=rev
>> Log:
>> Goodbye, JSONParser...
>>
>> Removed:
>> llvm/trunk/include/llvm/Support/JSONParser.h
>> llvm/trunk/lib/Support/JSONParser.cpp
>> llvm/trunk/unittests/Support/JSONParserTest.cpp
>> llvm/trunk/utils/json-bench/
>> Modified:
>> llvm/trunk/CMakeLists.txt
>> llvm/trunk/lib/Support/CMakeLists.txt
>> llvm/trunk/unittests/CMakeLists.txt
>> llvm/trunk/utils/Makefile
>>
>> Modified: llvm/trunk/CMakeLists.txt
>> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/CMakeLists.txt?rev=154930&r1=154929&r2=154930&view=diff
>> ==============================================================================
>> --- llvm/trunk/CMakeLists.txt (original)
>> +++ llvm/trunk/CMakeLists.txt Tue Apr 17 12:21:17 2012
>> @@ -396,7 +396,6 @@
>> 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)
>>
>> Removed: llvm/trunk/include/llvm/Support/JSONParser.h
>> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Support/JSONParser.h?rev=154929&view=auto
>> ==============================================================================
>> --- llvm/trunk/include/llvm/Support/JSONParser.h (original)
>> +++ llvm/trunk/include/llvm/Support/JSONParser.h (removed)
>> @@ -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 <typename AtomT>
>> - class IteratorTemplate : public std::iterator<std::forward_iterator_tag,
>> - const AtomT*> {
>> - 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<AtomT>(*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<JSONValue> 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<JSONKeyValuePair> 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
>>
>> Modified: llvm/trunk/lib/Support/CMakeLists.txt
>> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Support/CMakeLists.txt?rev=154930&r1=154929&r2=154930&view=diff
>> ==============================================================================
>> --- llvm/trunk/lib/Support/CMakeLists.txt (original)
>> +++ llvm/trunk/lib/Support/CMakeLists.txt Tue Apr 17 12:21:17 2012
>> @@ -32,7 +32,6 @@
>> IntrusiveRefCntPtr.cpp
>> IsInf.cpp
>> IsNAN.cpp
>> - JSONParser.cpp
>> LockFileManager.cpp
>> ManagedStatic.cpp
>> MemoryBuffer.cpp
>>
>> Removed: llvm/trunk/lib/Support/JSONParser.cpp
>> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Support/JSONParser.cpp?rev=154929&view=auto
>> ==============================================================================
>> --- llvm/trunk/lib/Support/JSONParser.cpp (original)
>> +++ llvm/trunk/lib/Support/JSONParser.cpp (removed)
>> @@ -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<JSONArray>(1)) JSONArray(this);
>> - case '{':
>> - return new (ValueAllocator.Allocate<JSONObject>(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<JSONContainer>(&Atom));
>> - case JSONAtom::JK_String:
>> - return true;
>> - case JSONAtom::JK_KeyValuePair:
>> - return skip(*cast<JSONKeyValuePair>(&Atom)->Value);
>> - }
>> - llvm_unreachable("Impossible enum value.");
>> -}
>> -
>> -// Sets the current error to:
>> -// "expected <Expected>, but found <Found>".
>> -void JSONParser::setExpectedError(StringRef Expected, StringRef Found) {
>> - SM->PrintMessage(SMLoc::getFromPointer(Position), SourceMgr::DK_Error,
>> - "expected " + Expected + ", but found " + Found + ".", ArrayRef<SMRange>());
>> - Failed = true;
>> -}
>> -
>> -// Sets the current error to:
>> -// "expected <Expected>, but found <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 <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 <current character>".
>> -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>())
>> - 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<JSONArray>(1)) JSONArray(this);
>> - case '{':
>> - return new (ValueAllocator.Allocate<JSONObject>(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<JSONKeyValuePair>(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();
>> -}
>>
>> Modified: llvm/trunk/unittests/CMakeLists.txt
>> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/unittests/CMakeLists.txt?rev=154930&r1=154929&r2=154930&view=diff
>> ==============================================================================
>> --- llvm/trunk/unittests/CMakeLists.txt (original)
>> +++ llvm/trunk/unittests/CMakeLists.txt Tue Apr 17 12:21:17 2012
>> @@ -165,7 +165,6 @@
>> Support/CommandLineTest.cpp
>> Support/ConstantRangeTest.cpp
>> Support/EndianTest.cpp
>> - Support/JSONParserTest.cpp
>> Support/LeakDetectorTest.cpp
>> Support/MathExtrasTest.cpp
>> Support/Path.cpp
>>
>> Removed: llvm/trunk/unittests/Support/JSONParserTest.cpp
>> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/unittests/Support/JSONParserTest.cpp?rev=154929&view=auto
>> ==============================================================================
>> --- llvm/trunk/unittests/Support/JSONParserTest.cpp (original)
>> +++ llvm/trunk/unittests/Support/JSONParserTest.cpp (removed)
>> @@ -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<JSONArray>(Parser.parseRoot());
>> - StringRef ParsedString =
>> - dyn_cast<JSONString>(*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<JSONArray>(Parser.parseRoot());
>> - EXPECT_EQ(6, std::distance(Array->begin(), Array->end()));
>> -}
>> -
>> -} // end namespace llvm
>>
>> Modified: llvm/trunk/utils/Makefile
>> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/utils/Makefile?rev=154930&r1=154929&r2=154930&view=diff
>> ==============================================================================
>> --- llvm/trunk/utils/Makefile (original)
>> +++ llvm/trunk/utils/Makefile Tue Apr 17 12:21:17 2012
>> @@ -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 \
>>
>>
>> _______________________________________________
>> llvm-commits mailing list
>> llvm-commits at cs.uiuc.edu
>> http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
More information about the llvm-commits
mailing list