[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/

Timur Iskhodzhanov timurrrr at google.com
Fri Apr 20 06:34:11 PDT 2012


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