expressir 0.2.4-x64-mingw32

data/ext/express-parser/antlr4-upstream/runtime/Cpp/runtime/src/support/guid.h

@@ -0,0 +1,112 @@
+/*
+ The MIT License (MIT)
+
+ Copyright (c) 2014 Graeme Hill (http://graemehill.ca)
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+ */
+#pragma once
+
+#include <iostream>
+#include <vector>
+#include <sstream>
+#include <string>
+#include <iomanip>
+#include <stdint.h>
+
+#ifdef GUID_ANDROID
+#include <jni.h>
+#endif
+
+// Class to represent a GUID/UUID. Each instance acts as a wrapper around a
+// 16 byte value that can be passed around by value. It also supports
+// conversion to string (via the stream operator <<) and conversion from a
+// string via constructor.
+class Guid
+{
+public:
+
+  // create a guid from vector of bytes
+  Guid(const std::vector<unsigned char> &bytes);
+
+  // create a guid from array of bytes
+  Guid(const unsigned char *bytes);
+
+  // Create a guid from array of words.
+  Guid(const uint16_t *bytes, bool reverse);
+
+  // create a guid from string
+  Guid(const std::string &fromString);
+
+  // create empty guid
+  Guid();
+
+  // copy constructor
+  Guid(const Guid &other);
+
+  // overload assignment operator
+  Guid &operator=(const Guid &other);
+
+  // overload equality and inequality operator
+  bool operator==(const Guid &other) const;
+  bool operator!=(const Guid &other) const;
+
+  const std::string toString() const;
+  std::vector<unsigned char>::const_iterator begin() { return _bytes.begin(); }
+  std::vector<unsigned char>::const_iterator end() { return _bytes.end(); }
+  std::vector<unsigned char>::const_reverse_iterator rbegin() { return _bytes.rbegin(); }
+  std::vector<unsigned char>::const_reverse_iterator rend() { return _bytes.rend(); }
+
+
+private:
+
+  // actual data
+  std::vector<unsigned char> _bytes;
+
+  // make the << operator a friend so it can access _bytes
+  friend std::ostream &operator<<(std::ostream &s, const Guid &guid);
+};
+
+// Class that can create new guids. The only reason this exists instead of
+// just a global "newGuid" function is because some platforms will require
+// that there is some attached context. In the case of android, we need to
+// know what JNIEnv is being used to call back to Java, but the newGuid()
+// function would no longer be cross-platform if we parameterized the android
+// version. Instead, construction of the GuidGenerator may be different on
+// each platform, but the use of newGuid is uniform.
+class GuidGenerator
+{
+public:
+#ifdef GUID_ANDROID
+  GuidGenerator(JNIEnv *env);
+#else
+  GuidGenerator() { }
+#endif
+
+  Guid newGuid();
+
+#ifdef GUID_ANDROID
+private:
+  JNIEnv *_env;
+  jclass _uuidClass;
+  jmethodID _newGuidMethod;
+  jmethodID _mostSignificantBitsMethod;
+  jmethodID _leastSignificantBitsMethod;
+#endif
+};

data/ext/express-parser/antlr4-upstream/runtime/Cpp/runtime/src/tree/AbstractParseTreeVisitor.h

@@ -0,0 +1,128 @@
+/* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
+ * Use of this file is governed by the BSD 3-clause license that
+ * can be found in the LICENSE.txt file in the project root.
+ */
+
+#pragma once
+
+#include "tree/ParseTreeVisitor.h"
+
+namespace antlr4 {
+namespace tree {
+
+  class ANTLR4CPP_PUBLIC AbstractParseTreeVisitor : public ParseTreeVisitor {
+  public:
+    /// The default implementation calls <seealso cref="ParseTree#accept"/> on the
+    /// specified tree.
+    virtual antlrcpp::Any visit(ParseTree *tree) override {
+      return tree->accept(this);
+    }
+
+    /**
+     * <p>The default implementation initializes the aggregate result to
+     * {@link #defaultResult defaultResult()}. Before visiting each child, it
+     * calls {@link #shouldVisitNextChild shouldVisitNextChild}; if the result
+     * is {@code false} no more children are visited and the current aggregate
+     * result is returned. After visiting a child, the aggregate result is
+     * updated by calling {@link #aggregateResult aggregateResult} with the
+     * previous aggregate result and the result of visiting the child.</p>
+     *
+     * <p>The default implementation is not safe for use in visitors that modify
+     * the tree structure. Visitors that modify the tree should override this
+     * method to behave properly in respect to the specific algorithm in use.</p>
+     */
+    virtual antlrcpp::Any visitChildren(ParseTree *node) override {
+      antlrcpp::Any result = defaultResult();
+      size_t n = node->children.size();
+      for (size_t i = 0; i < n; i++) {
+        if (!shouldVisitNextChild(node, result)) {
+          break;
+        }
+
+        antlrcpp::Any childResult = node->children[i]->accept(this);
+        result = aggregateResult(result, childResult);
+      }
+
+      return result;
+    }
+
+    /// The default implementation returns the result of
+    /// <seealso cref="#defaultResult defaultResult"/>.
+    virtual antlrcpp::Any visitTerminal(TerminalNode * /*node*/) override {
+      return defaultResult();
+    }
+
+    /// The default implementation returns the result of
+    /// <seealso cref="#defaultResult defaultResult"/>.
+    virtual antlrcpp::Any visitErrorNode(ErrorNode * /*node*/) override {
+      return defaultResult();
+    }
+
+  protected:
+    /// <summary>
+    /// Gets the default value returned by visitor methods. This value is
+    /// returned by the default implementations of
+    /// <seealso cref="#visitTerminal visitTerminal"/>, <seealso cref="#visitErrorNode visitErrorNode"/>.
+    /// The default implementation of <seealso cref="#visitChildren visitChildren"/>
+    /// initializes its aggregate result to this value.
+    /// <p/>
+    /// The base implementation returns {@code null}.
+    /// </summary>
+    /// <returns> The default value returned by visitor methods. </returns>
+    virtual antlrcpp::Any defaultResult() {
+      return nullptr; // support isNotNull
+    }
+
+    /// <summary>
+    /// Aggregates the results of visiting multiple children of a node. After
+    /// either all children are visited or <seealso cref="#shouldVisitNextChild"/> returns
+    /// {@code false}, the aggregate value is returned as the result of
+    /// <seealso cref="#visitChildren"/>.
+    /// <p/>
+    /// The default implementation returns {@code nextResult}, meaning
+    /// <seealso cref="#visitChildren"/> will return the result of the last child visited
+    /// (or return the initial value if the node has no children).
+    /// </summary>
+    /// <param name="aggregate"> The previous aggregate value. In the default
+    /// implementation, the aggregate value is initialized to
+    /// <seealso cref="#defaultResult"/>, which is passed as the {@code aggregate} argument
+    /// to this method after the first child node is visited. </param>
+    /// <param name="nextResult"> The result of the immediately preceeding call to visit
+    /// a child node.
+    /// </param>
+    /// <returns> The updated aggregate result. </returns>
+    virtual antlrcpp::Any aggregateResult(antlrcpp::Any /*aggregate*/, const antlrcpp::Any &nextResult) {
+      return nextResult;
+    }
+
+    /// <summary>
+    /// This method is called after visiting each child in
+    /// <seealso cref="#visitChildren"/>. This method is first called before the first
+    /// child is visited; at that point {@code currentResult} will be the initial
+    /// value (in the default implementation, the initial value is returned by a
+    /// call to <seealso cref="#defaultResult"/>. This method is not called after the last
+    /// child is visited.
+    /// <p/>
+    /// The default implementation always returns {@code true}, indicating that
+    /// {@code visitChildren} should only return after all children are visited.
+    /// One reason to override this method is to provide a "short circuit"
+    /// evaluation option for situations where the result of visiting a single
+    /// child has the potential to determine the result of the visit operation as
+    /// a whole.
+    /// </summary>
+    /// <param name="node"> The <seealso cref="ParseTree"/> whose children are currently being
+    /// visited. </param>
+    /// <param name="currentResult"> The current aggregate result of the children visited
+    /// to the current point.
+    /// </param>
+    /// <returns> {@code true} to continue visiting children. Otherwise return
+    /// {@code false} to stop visiting children and immediately return the
+    /// current aggregate result from <seealso cref="#visitChildren"/>. </returns>
+    virtual bool shouldVisitNextChild(ParseTree * /*node*/, const antlrcpp::Any &/*currentResult*/) {
+      return true;
+    }
+
+  };
+
+} // namespace tree
+} // namespace antlr4

data/ext/express-parser/antlr4-upstream/runtime/Cpp/runtime/src/tree/ErrorNode.cpp

@@ -0,0 +1,9 @@
+/* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
+ * Use of this file is governed by the BSD 3-clause license that
+ * can be found in the LICENSE.txt file in the project root.
+ */
+
+#include "tree/ErrorNode.h"
+
+antlr4::tree::ErrorNode::~ErrorNode() {
+}

data/ext/express-parser/antlr4-upstream/runtime/Cpp/runtime/src/tree/ErrorNode.h

@@ -0,0 +1,19 @@
+/* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
+ * Use of this file is governed by the BSD 3-clause license that
+ * can be found in the LICENSE.txt file in the project root.
+ */
+
+#pragma once
+
+#include "tree/TerminalNode.h"
+
+namespace antlr4 {
+namespace tree {
+
+  class ANTLR4CPP_PUBLIC ErrorNode : public virtual TerminalNode {
+  public:
+    ~ErrorNode() override;
+  };
+
+} // namespace tree
+} // namespace antlr4

data/ext/express-parser/antlr4-upstream/runtime/Cpp/runtime/src/tree/ErrorNodeImpl.cpp

@@ -0,0 +1,23 @@
+/* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
+ * Use of this file is governed by the BSD 3-clause license that
+ * can be found in the LICENSE.txt file in the project root.
+ */
+
+#include "Exceptions.h"
+#include "tree/ParseTreeVisitor.h"
+
+#include "tree/ErrorNodeImpl.h"
+
+using namespace antlr4;
+using namespace antlr4::misc;
+using namespace antlr4::tree;
+
+ErrorNodeImpl::ErrorNodeImpl(Token *token) : TerminalNodeImpl(token) {
+}
+
+ErrorNodeImpl::~ErrorNodeImpl() {
+}
+
+antlrcpp::Any ErrorNodeImpl::accept(ParseTreeVisitor *visitor) {
+  return visitor->visitErrorNode(this);
+}

data/ext/express-parser/antlr4-upstream/runtime/Cpp/runtime/src/tree/ErrorNodeImpl.h

@@ -0,0 +1,33 @@
+/* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
+ * Use of this file is governed by the BSD 3-clause license that
+ * can be found in the LICENSE.txt file in the project root.
+ */
+
+#pragma once
+
+#include "tree/ErrorNode.h"
+#include "tree/TerminalNodeImpl.h"
+#include "misc/Interval.h"
+
+#include "support/Any.h"
+
+namespace antlr4 {
+namespace tree {
+
+  /// <summary>
+  /// Represents a token that was consumed during resynchronization
+  ///  rather than during a valid match operation. For example,
+  ///  we will create this kind of a node during single token insertion
+  ///  and deletion as well as during "consume until error recovery set"
+  ///  upon no viable alternative exceptions.
+  /// </summary>
+  class ANTLR4CPP_PUBLIC ErrorNodeImpl : public virtual TerminalNodeImpl, public virtual ErrorNode {
+  public:
+    ErrorNodeImpl(Token *token);
+    ~ErrorNodeImpl() override;
+
+    virtual antlrcpp::Any accept(ParseTreeVisitor *visitor) override;
+  };
+
+} // namespace tree
+} // namespace antlr4

data/ext/express-parser/antlr4-upstream/runtime/Cpp/runtime/src/tree/IterativeParseTreeWalker.cpp

@@ -0,0 +1,71 @@
+/* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
+ * Use of this file is governed by the BSD 3-clause license that
+ * can be found in the LICENSE.txt file in the project root.
+ */
+
+#include "support/CPPUtils.h"
+
+#include "tree/ParseTreeListener.h"
+#include "tree/ParseTree.h"
+#include "tree/ErrorNode.h"
+
+#include "IterativeParseTreeWalker.h"
+
+using namespace antlr4::tree;
+
+void IterativeParseTreeWalker::walk(ParseTreeListener *listener, ParseTree *t) const {
+
+  std::vector<ParseTree *> nodeStack;
+  std::vector<size_t> indexStack;
+
+  ParseTree *currentNode = t;
+  size_t currentIndex = 0;
+
+  while (currentNode != nullptr) {
+    // pre-order visit
+    if (antlrcpp::is<ErrorNode *>(currentNode)) {
+      listener->visitErrorNode(dynamic_cast<ErrorNode *>(currentNode));
+    } else if (antlrcpp::is<TerminalNode *>(currentNode)) {
+      listener->visitTerminal((TerminalNode *)currentNode);
+    } else {
+      enterRule(listener, currentNode);
+    }
+
+    // Move down to first child, if it exists.
+    if (!currentNode->children.empty()) {
+      nodeStack.push_back(currentNode);
+      indexStack.push_back(currentIndex);
+      currentIndex = 0;
+      currentNode = currentNode->children[0];
+      continue;
+    }
+
+    // No child nodes, so walk tree.
+    do {
+      // post-order visit
+      if (!antlrcpp::is<TerminalNode *>(currentNode)) {
+        exitRule(listener, currentNode);
+      }
+
+      // No parent, so no siblings.
+      if (nodeStack.empty()) {
+        currentNode = nullptr;
+        currentIndex = 0;
+        break;
+      }
+
+      // Move to next sibling if possible.
+      if (nodeStack.back()->children.size() > ++currentIndex) {
+        currentNode = nodeStack.back()->children[currentIndex];
+        break;
+      }
+
+      // No next sibling, so move up.
+      currentNode = nodeStack.back();
+      nodeStack.pop_back();
+      currentIndex = indexStack.back();
+      indexStack.pop_back();
+
+    } while (currentNode != nullptr);
+  }
+}

data/ext/express-parser/antlr4-upstream/runtime/Cpp/runtime/src/tree/IterativeParseTreeWalker.h

@@ -0,0 +1,53 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2012 Terence Parr
+ *  Copyright (c) 2012 Sam Harwell
+ *  All rights reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *  1. Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *  2. Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *  3. The name of the author may not be used to endorse or promote products
+ *     derived from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ *  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ *  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ *  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#include "antlr4-common.h"
+
+#include "tree/ParseTreeWalker.h"
+
+namespace antlr4 {
+namespace tree {
+
+  class ParseTreeListener;
+  
+  /**
+   * An iterative (read: non-recursive) pre-order and post-order tree walker that
+   * doesn't use the thread stack but heap-based stacks. Makes it possible to
+   * process deeply nested parse trees.
+   */
+  class ANTLR4CPP_PUBLIC IterativeParseTreeWalker : public ParseTreeWalker {
+  public:
+    virtual void walk(ParseTreeListener *listener, ParseTree *t) const override;
+  };
+
+} // namespace tree
+} // namespace antlr4