diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..62e7228 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,33 @@ +cmake_minimum_required (VERSION 3.19) + +cmake_policy(SET CMP0135 OLD) + +set(CMAKE_DISABLE_IN_SOURCE_BUILD ON) +set(CMAKE_EXPORT_COMPILE_COMMANDS ON) + +project(sysy + VERSION 0.0.0.1 + DESCRIPTION "The SysY language compiler" + LANGUAGES CXX +) + +set(CMAKE_CXX_STANDARD 17 CACHE STRING "C++ standard to conform to") +set(CMAKE_CXX_STANDARD_REQUIRED YES) +set(CMAKE_CXX_EXTENSIONS OFF) + +if(NOT CMAKE_BUILD_TYPE) + message(STATUS "Build type not set, falling back to Debug mode.") + set(CMAKE_BUILD_TYPE "Release" CACHE STRING + "Choose the type of build, options are: Debug Release." FORCE) +endif(NOT CMAKE_BUILD_TYPE) + +# ANTLR +set(ANTLR_EXECUTABLE "${PROJECT_SOURCE_DIR}/antlr/antlr-4.9.3-complete.jar") +set(ANTLR_RUNTIME "${PROJECT_SOURCE_DIR}/antlr/antlr4-runtime") + +set(ANTLR4_INSTALL ON) +set(ANTLR_BUILD_CPP_TESTS OFF) +add_subdirectory(${ANTLR_RUNTIME}) + +# Project source files +add_subdirectory(src) \ No newline at end of file diff --git a/antlr/antlr-4.9.3-complete.jar b/antlr/antlr-4.9.3-complete.jar new file mode 100644 index 0000000..749296f Binary files /dev/null and b/antlr/antlr-4.9.3-complete.jar differ diff --git a/antlr/antlr4-runtime/CMakeLists.txt b/antlr/antlr4-runtime/CMakeLists.txt new file mode 100644 index 0000000..e549f11 --- /dev/null +++ b/antlr/antlr4-runtime/CMakeLists.txt @@ -0,0 +1,220 @@ +# -*- mode:cmake -*- +cmake_minimum_required (VERSION 2.8) +# 2.8 needed because of ExternalProject + +# Detect build type, fallback to release and throw a warning if use didn't specify any +if(NOT CMAKE_BUILD_TYPE) + message(WARNING "Build type not set, falling back to Release mode. + To specify build type use: + -DCMAKE_BUILD_TYPE= where is Debug or Release.") + set(CMAKE_BUILD_TYPE "Release" CACHE STRING + "Choose the type of build, options are: Debug Release." + FORCE) +endif(NOT CMAKE_BUILD_TYPE) + +if(NOT WITH_DEMO) + message(STATUS "Building without demo. To enable demo build use: -DWITH_DEMO=True") + set(WITH_DEMO False CACHE STRING + "Chose to build with or without demo executable" + FORCE) +endif(NOT WITH_DEMO) + +option(WITH_LIBCXX "Building with clang++ and libc++(in Linux). To enable with: -DWITH_LIBCXX=On" Off) +option(WITH_STATIC_CRT "(Visual C++) Enable to statically link CRT, which avoids requiring users to install the redistribution package. + To disable with: -DWITH_STATIC_CRT=Off" On) + +project(LIBANTLR4) + +if(CMAKE_VERSION VERSION_EQUAL "3.0.0" OR + CMAKE_VERSION VERSION_GREATER "3.0.0") + CMAKE_POLICY(SET CMP0026 NEW) + CMAKE_POLICY(SET CMP0054 OLD) + CMAKE_POLICY(SET CMP0045 OLD) + CMAKE_POLICY(SET CMP0042 OLD) +endif() + +if(CMAKE_VERSION VERSION_EQUAL "3.3.0" OR + CMAKE_VERSION VERSION_GREATER "3.3.0") + CMAKE_POLICY(SET CMP0059 OLD) + CMAKE_POLICY(SET CMP0054 OLD) +endif() + +if(CMAKE_SYSTEM_NAME MATCHES "Linux") + find_package(PkgConfig REQUIRED) + pkg_check_modules(UUID REQUIRED uuid) +endif() +if(APPLE) + find_library(COREFOUNDATION_LIBRARY CoreFoundation) +endif() + +file(STRINGS "VERSION" ANTLR_VERSION) + +if(WITH_DEMO) + # Java is not necessary if building without demos. + find_package(Java COMPONENTS Runtime REQUIRED) + + if(NOT ANTLR_JAR_LOCATION) + message(FATAL_ERROR "Missing antlr4.jar location. You can specify it's path using: -DANTLR_JAR_LOCATION=") + else() + get_filename_component(ANTLR_NAME ${ANTLR_JAR_LOCATION} NAME_WE) + if(NOT EXISTS "${ANTLR_JAR_LOCATION}") + message(FATAL_ERROR "Unable to find ${ANTLR_NAME} in ${ANTLR_JAR_LOCATION}") + else() + message(STATUS "Found ${ANTLR_NAME}: ${ANTLR_JAR_LOCATION}") + endif() + endif() +endif(WITH_DEMO) + +if(MSVC_VERSION) + set(MY_CXX_WARNING_FLAGS " /W4") +else() + set(MY_CXX_WARNING_FLAGS " -Wall -pedantic -W") +endif() + +# Define USE_UTF8_INSTEAD_OF_CODECVT macro. +# set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DUSE_UTF8_INSTEAD_OF_CODECVT") + +# Initialize CXXFLAGS. +if("${CMAKE_VERSION}" VERSION_GREATER 3.1.0) + if(NOT DEFINED CMAKE_CXX_STANDARD) + # only set CMAKE_CXX_STANDARD if not already set + # this allows the standard to be set by the caller, for example with -DCMAKE_CXX_STANDARD:STRING=17 + set(CMAKE_CXX_STANDARD 11) + endif() + set(CMAKE_CXX_STANDARD_REQUIRED ON) + set(CMAKE_CXX_EXTENSIONS OFF) +else() + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11") + set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -std=c++11") + set(CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL} -std=c++11") + set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -std=c++11") + set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -std=c++11") +endif() + +set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${MY_CXX_WARNING_FLAGS}") +if(MSVC_VERSION) + set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /Od /Zi /MP ${MY_CXX_WARNING_FLAGS}") + set(CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL} /O1 /Oi /Ob2 /Gy /MP /DNDEBUG ${MY_CXX_WARNING_FLAGS}") + set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /O2 /Oi /Ob2 /Gy /MP /DNDEBUG ${MY_CXX_WARNING_FLGAS}") + set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} /O2 /Oi /Ob2 /Gy /MP /Zi ${MY_CXX_WARNING_FLAGS}") +else() + set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -O0 -g ${MY_CXX_WARNING_FLAGS}") + set(CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL} -Os -DNDEBUG ${MY_CXX_WARNING_FLAGS}") + set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3 -DNDEBUG ${MY_CXX_WARNING_FLGAS}") + set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -O2 -g ${MY_CXX_WARNING_FLAGS}") +endif() + +# Compiler-specific C++11 activation. +if("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU" OR "${CMAKE_CXX_COMPILER_ID}" MATCHES "Intel") + execute_process( + COMMAND ${CMAKE_CXX_COMPILER} -dumpversion OUTPUT_VARIABLE GCC_VERSION) + # Just g++-5.0 and greater contain header. (test in ubuntu) + if(NOT (GCC_VERSION VERSION_GREATER 5.0 OR GCC_VERSION VERSION_EQUAL 5.0)) + message(FATAL_ERROR "${PROJECT_NAME} requires g++ 5.0 or greater.") + endif () +elseif ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" AND ANDROID) + # Need -Os cflag and cxxflags here to work with exception handling on armeabi. + # see https://github.com/android-ndk/ndk/issues/573 + # and without -stdlib=libc++ cxxflags +elseif ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" AND APPLE) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -stdlib=libc++") +elseif ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" AND ( CMAKE_SYSTEM_NAME MATCHES "Linux" OR CMAKE_SYSTEM_NAME MATCHES "FreeBSD") ) + execute_process( + COMMAND ${CMAKE_CXX_COMPILER} -dumpversion OUTPUT_VARIABLE CLANG_VERSION) + if(NOT (CLANG_VERSION VERSION_GREATER 4.2.1 OR CLANG_VERSION VERSION_EQUAL 4.2.1)) + message(FATAL_ERROR "${PROJECT_NAME} requires clang 4.2.1 or greater.") + endif() + # You can use libc++ to compile this project when g++ is NOT greater than or equal to 5.0. + if(WITH_LIBCXX) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++") + endif() +elseif(MSVC_VERSION GREATER 1800 OR MSVC_VERSION EQUAL 1800) + # Visual Studio 2012+ supports c++11 features +elseif(CMAKE_SYSTEM_NAME MATCHES "Emscripten") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -stdlib=libc++") +else() + message(FATAL_ERROR "Your C++ compiler does not support C++11.") +endif() + + +add_subdirectory(runtime) +if(WITH_DEMO) + add_subdirectory(demo) +endif(WITH_DEMO) + +# Generate CMake Package Files only if install is active +if (ANTLR4_INSTALL) + + include(GNUInstallDirs) + include(CMakePackageConfigHelpers) + + if(NOT ANTLR4_CMAKE_DIR) + set(ANTLR4_CMAKE_DIR ${CMAKE_INSTALL_LIBDIR}/cmake CACHE STRING + "Installation directory for cmake files." FORCE ) + endif(NOT ANTLR4_CMAKE_DIR) + + set(version_runtime_config ${PROJECT_BINARY_DIR}/antlr4-runtime-config-version.cmake) + set(version_generator_config ${PROJECT_BINARY_DIR}/antlr4-generator-config-version.cmake) + set(project_runtime_config ${PROJECT_BINARY_DIR}/antlr4-runtime-config.cmake) + set(project_generator_config ${PROJECT_BINARY_DIR}/antlr4-generator-config.cmake) + set(targets_export_name antlr4-targets) + + set(ANTLR4_LIB_DIR ${CMAKE_INSTALL_LIBDIR} CACHE STRING + "Installation directory for libraries, relative to ${CMAKE_INSTALL_PREFIX}.") + + set(ANTLR4_INCLUDE_DIR ${CMAKE_INSTALL_INCLUDEDIR}/antlr4-runtime CACHE STRING + "Installation directory for include files, relative to ${CMAKE_INSTALL_PREFIX}.") + + configure_package_config_file( + cmake/antlr4-runtime.cmake.in + ${project_runtime_config} + INSTALL_DESTINATION ${ANTLR4_CMAKE_DIR}/antlr4-runtime + PATH_VARS + ANTLR4_INCLUDE_DIR + ANTLR4_LIB_DIR ) + + configure_package_config_file( + cmake/antlr4-generator.cmake.in + ${project_generator_config} + INSTALL_DESTINATION ${ANTLR4_CMAKE_DIR}/antlr4-generator + PATH_VARS + ANTLR4_INCLUDE_DIR + ANTLR4_LIB_DIR ) + + write_basic_package_version_file( + ${version_runtime_config} + VERSION ${ANTLR_VERSION} + COMPATIBILITY SameMajorVersion ) + + write_basic_package_version_file( + ${version_generator_config} + VERSION ${ANTLR_VERSION} + COMPATIBILITY SameMajorVersion ) + + install(EXPORT ${targets_export_name} + DESTINATION ${ANTLR4_CMAKE_DIR}/antlr4-runtime ) + + install(FILES ${project_runtime_config} + ${version_runtime_config} + DESTINATION ${ANTLR4_CMAKE_DIR}/antlr4-runtime ) + + install(FILES ${project_generator_config} + ${version_generator_config} + DESTINATION ${ANTLR4_CMAKE_DIR}/antlr4-generator ) + +endif(ANTLR4_INSTALL) + +if(EXISTS LICENSE.txt) +install(FILES LICENSE.txt + DESTINATION "share/doc/libantlr4") +elseif(EXISTS ../../LICENSE.txt) +install(FILES ../../LICENSE.txt + DESTINATION "share/doc/libantlr4") +endif() + +install(FILES README.md VERSION + DESTINATION "share/doc/libantlr4") + +set(CPACK_PACKAGE_CONTACT "antlr-discussion@googlegroups.com") +set(CPACK_PACKAGE_VERSION ${ANTLR_VERSION}) +include(CPack) diff --git a/antlr/antlr4-runtime/LICENSE.txt b/antlr/antlr4-runtime/LICENSE.txt new file mode 100644 index 0000000..2042d1b --- /dev/null +++ b/antlr/antlr4-runtime/LICENSE.txt @@ -0,0 +1,52 @@ +[The "BSD 3-clause license"] +Copyright (c) 2012-2017 The ANTLR Project. 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. Neither the name of the copyright holder nor the names of its contributors + may 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. + +===== + +MIT License for codepointat.js from https://git.io/codepointat +MIT License for fromcodepoint.js from https://git.io/vDW1m + +Copyright Mathias Bynens + +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. diff --git a/antlr/antlr4-runtime/README.md b/antlr/antlr4-runtime/README.md new file mode 100644 index 0000000..4caf612 --- /dev/null +++ b/antlr/antlr4-runtime/README.md @@ -0,0 +1,72 @@ +# C++ target for ANTLR 4 + +This folder contains the C++ runtime support for ANTLR. See [the canonical antlr4 repository](https://github.com/antlr/antlr4) for in depth detail about how to use ANTLR 4. + +## Authors and major contributors + +ANTLR 4 is the result of substantial effort of the following people: + +* [Terence Parr](http://www.cs.usfca.edu/~parrt/), parrt@cs.usfca.edu + ANTLR project lead and supreme dictator for life + [University of San Francisco](http://www.usfca.edu/) +* [Sam Harwell](http://tunnelvisionlabs.com/) + Tool co-author, Java and C# target) + +The C++ target has been the work of the following people: + +* Dan McLaughlin, dan.mclaughlin@gmail.com (initial port, got code to compile) +* David Sisson, dsisson@google.com (initial port, made the runtime C++ tests runnable) +* [Mike Lischke](www.soft-gems.net), mike@lischke-online.de (brought the initial port to a working library, made most runtime tests passing) + +## Other contributors + +* Marcin Szalowicz, mszalowicz@mailplus.pl (cmake build setup) +* Tim O'Callaghan, timo@linux.com (additional superbuild cmake pattern script) + +## Project Status + +* Building on macOS, Windows, Android and Linux +* No errors and warnings +* Library linking +* Some unit tests in the macOS project, for important base classes with almost 100% code coverage. +* All memory allocations checked +* Simple command line demo application working on all supported platforms. +* All runtime tests pass. + +### Build + Usage Notes + +The minimum C++ version to compile the ANTLR C++ runtime with is C++11. The supplied projects can built the runtime either as static or dynamic library, as both 32bit and 64bit arch. The macOS project contains a target for iOS and can also be built using cmake (instead of XCode). + +Include the antlr4-runtime.h umbrella header in your target application to get everything needed to use the library. + +If you are compiling with cmake, the minimum version required is cmake 2.8. +By default, the libraries produced by the CMake build target C++11. If you want to target a different C++ standard, you can explicitly pass the standard - e.g. `-DCMAKE_CXX_STANDARD=17`. + +#### Compiling on Windows with Visual Studio using he Visual Studio projects +Simply open the VS project from the runtime folder (VS 2013+) and build it. + +#### Compiling on Windows using cmake with Visual Studio VS2017 and later +Use the "Open Folder" Feature from the File->Open->Folder menu to open the runtime/Cpp directory. +It will automatically use the CMake description to open up a Visual Studio Solution. + +#### Compiling on macOS +Either open the included XCode project and build that or use the cmake compilation as described for linux. + +#### Compiling on Android +Try run cmake -DCMAKE_ANDROID_NDK=/folder/of/android_ndkr17_and_above -DCMAKE_SYSTEM_NAME=Android -DCMAKE_ANDROID_API=14 -DCMAKE_ANDROID_ARCH_ABI=x86 -DCMAKE_ANDROID_STL_TYPE=c++_shared -DCMAKE_ANDROID_NDK_TOOLCHAIN_VERSION=clang -DCMAKE_BUILD_TYPE=Release /folder/antlr4_src_dir -G Ninja. + +#### Compiling on Linux +- cd \/runtime/Cpp (this is where this readme is located) +- mkdir build && mkdir run && cd build +- cmake .. -DANTLR_JAR_LOCATION=full/path/to/antlr4-4.5.4-SNAPSHOT.jar -DWITH_DEMO=True +- make +- DESTDIR=\/runtime/Cpp/run make install + +If you don't want to build the demo then simply run cmake without parameters. +There is another cmake script available in the subfolder cmake/ for those who prefer the superbuild cmake pattern. + +#### CMake Package support +If the CMake variable 'ANTLR4_INSTALL' is set, CMake Packages will be build and installed during the install step. +They expose two packages: antlr4_runtime and antlr4_generator which can be referenced to ease up the use of the +ANTLR Generator and runtime. +Use and Sample can be found [here](cmake/Antlr4Package.md) diff --git a/antlr/antlr4-runtime/VERSION b/antlr/antlr4-runtime/VERSION new file mode 100644 index 0000000..c01c413 --- /dev/null +++ b/antlr/antlr4-runtime/VERSION @@ -0,0 +1 @@ +4.9.3 diff --git a/antlr/antlr4-runtime/cmake/Antlr4Package.md b/antlr/antlr4-runtime/cmake/Antlr4Package.md new file mode 100644 index 0000000..10e7752 --- /dev/null +++ b/antlr/antlr4-runtime/cmake/Antlr4Package.md @@ -0,0 +1,136 @@ +# CMake Antlr4 Package Usage + +## The `antlr4-generator` Package + +To use the Package you must insert a +```cmake +find_package(antlr4-generator REQUIRED) +``` +line in your `CMakeList.txt` file. + +The package exposes a function `antlr4_generate` that generates the required setup to call ANTLR for a +given input file during build. + +The following table lists the parameters that can be used with the function: + +Argument# | Required | Default | Use +----------|-----------|---------|--- +0 | Yes | n/a | Unique target name. It is used to generate CMake Variables to reference the various outputs of the generation +1 | Yes | n/a | Input file containing the lexer/parser definition +2 | Yes | n/a | Type of Rules contained in the input: LEXER, PARSER or BOTH +4 | No | FALSE | Boolean to indicate if a listener interface should be generated +5 | No | FALSE | Boolean to indicate if a visitor interface should be generated +6 | No | none | C++ namespace in which the generated classes should be placed +7 | No | none | Additional files on which the input depends +8 | No | none | Library path to use during generation + +The `ANTLR4_JAR_LOCATION` CMake variable must be set to the location where the `antlr-4*-complete.jar` generator is located. You can download the file from [here](http://www.antlr.org/download.html). + +Additional options to the ANTLR4 generator can be passed in the `ANTLR4_GENERATED_OPTIONS` variable. Add the installation prefix of `antlr4-runtime` to `CMAKE_PREFIX_PATH` or set + `antlr4-runtime_DIR` to a directory containing the files. + +The following CMake variables are available following a call to `antlr4_generate` + +Output variable | Meaning +---|--- +`ANTLR4_INCLUDE_DIR_` | Directory containing the generated header files +`ANTLR4_SRC_FILES_` | List of generated source files +`ANTLR4_TOKEN_FILES_` | List of generated token files +`ANTLR4_TOKEN_DIRECTORY_` | Directory containing the generated token files + +#### Sample: +```cmake + # generate parser with visitor classes. + # put the classes in C++ namespace 'antlrcpptest::' + antlr4_generate( + antlrcpptest_parser + ${CMAKE_CURRENT_SOURCE_DIR}/TLexer.g4 + LEXER + FALSE + TRUE + "antlrcpptest" + ) +``` + +**Remember that the ANTLR generator requires a working Java installation on your machine!** + +## The `antlr4-runtime` Package + +To use the Package you must insert a +```cmake +find_package(antlr4-runtime REQUIRED) +``` +line in your `CMakeList.txt` file. + +The package exposes two different targets: + +Target|Use +--|-- +antlr4_shared|Shared library version of the runtime +antlr4_static|Static library version of the runtime + +Both set the following CMake variables: + +Output variable | Meaning +---|--- +`ANTLR4_INCLUDE_DIR` | Include directory containing the runtime header files +`ANTLR4_LIB_DIR` | Library directory containing the runtime library files + +#### Sample: +```cmake +# add runtime include directories on this project. +include_directories( ${ANTLR4_INCLUDE_DIR} ) + +# add runtime to project dependencies +add_dependencies( Parsertest antlr4_shared ) + +# add runtime to project link libraries +target_link_libraries( Parsertest PRIVATE + antlr4_shared) +``` + +### Full Example: +```cmake + # Bring in the required packages + find_package(antlr4-runtime REQUIRED) + find_package(antlr4-generator REQUIRED) + + # Set path to generator + set(ANTLR4_JAR_LOCATION ${PROJECT_SOURCE_DIR}/thirdparty/antlr/antlr-4.9.3-complete.jar) + + # generate lexer + antlr4_generate( + antlrcpptest_lexer + ${CMAKE_CURRENT_SOURCE_DIR}/TLexer.g4 + LEXER + FALSE + FALSE + "antlrcpptest" + ) + + # generate parser + antlr4_generate( + antlrcpptest_parser + ${CMAKE_CURRENT_SOURCE_DIR}/TParser.g4 + PARSER + FALSE + TRUE + "antlrcpptest" + "${ANTLR4_TOKEN_FILES_antlrcpptest_lexer}" + "${ANTLR4_TOKEN_DIRECTORY_antlrcpptest_lexer}" + ) + + # add directories for generated include files + include_directories( ${PROJECT_BINARY_DIR} ${ANTLR4_INCLUDE_DIR} ${ANTLR4_INCLUDE_DIR_antlrcpptest_lexer} ${ANTLR4_INCLUDE_DIR_antlrcpptest_parser} ) + + # add generated source files + add_executable( Parsertest main.cpp ${ANTLR4_SRC_FILES_antlrcpptest_lexer} ${ANTLR4_SRC_FILES_antlrcpptest_parser} ) + + # add required runtime library + add_dependencies( Parsertest antlr4_shared ) + + target_link_libraries( Parsertest PRIVATE + antlr4_shared) + +``` + diff --git a/antlr/antlr4-runtime/cmake/ExternalAntlr4Cpp.cmake b/antlr/antlr4-runtime/cmake/ExternalAntlr4Cpp.cmake new file mode 100644 index 0000000..2acc610 --- /dev/null +++ b/antlr/antlr4-runtime/cmake/ExternalAntlr4Cpp.cmake @@ -0,0 +1,158 @@ +cmake_minimum_required(VERSION 3.7) + +include(ExternalProject) + +set(ANTLR4_ROOT ${CMAKE_CURRENT_BINARY_DIR}/antlr4_runtime/src/antlr4_runtime) +set(ANTLR4_INCLUDE_DIRS ${ANTLR4_ROOT}/runtime/Cpp/runtime/src) +set(ANTLR4_GIT_REPOSITORY https://github.com/antlr/antlr4.git) +if(NOT DEFINED ANTLR4_TAG) + # Set to branch name to keep library updated at the cost of needing to rebuild after 'clean' + # Set to commit hash to keep the build stable and does not need to rebuild after 'clean' + set(ANTLR4_TAG master) +endif() + +if(${CMAKE_GENERATOR} MATCHES "Visual Studio.*") + set(ANTLR4_OUTPUT_DIR ${ANTLR4_ROOT}/runtime/Cpp/dist/$(Configuration)) +elseif(${CMAKE_GENERATOR} MATCHES "Xcode.*") + set(ANTLR4_OUTPUT_DIR ${ANTLR4_ROOT}/runtime/Cpp/dist/$(CONFIGURATION)) +else() + set(ANTLR4_OUTPUT_DIR ${ANTLR4_ROOT}/runtime/Cpp/dist) +endif() + +if(MSVC) + set(ANTLR4_STATIC_LIBRARIES + ${ANTLR4_OUTPUT_DIR}/antlr4-runtime-static.lib) + set(ANTLR4_SHARED_LIBRARIES + ${ANTLR4_OUTPUT_DIR}/antlr4-runtime.lib) + set(ANTLR4_RUNTIME_LIBRARIES + ${ANTLR4_OUTPUT_DIR}/antlr4-runtime.dll) +else() + set(ANTLR4_STATIC_LIBRARIES + ${ANTLR4_OUTPUT_DIR}/libantlr4-runtime.a) + if(MINGW) + set(ANTLR4_SHARED_LIBRARIES + ${ANTLR4_OUTPUT_DIR}/libantlr4-runtime.dll.a) + set(ANTLR4_RUNTIME_LIBRARIES + ${ANTLR4_OUTPUT_DIR}/libantlr4-runtime.dll) + elseif(CYGWIN) + set(ANTLR4_SHARED_LIBRARIES + ${ANTLR4_OUTPUT_DIR}/libantlr4-runtime.dll.a) + set(ANTLR4_RUNTIME_LIBRARIES + ${ANTLR4_OUTPUT_DIR}/cygantlr4-runtime-4.9.3.dll) + elseif(APPLE) + set(ANTLR4_RUNTIME_LIBRARIES + ${ANTLR4_OUTPUT_DIR}/libantlr4-runtime.dylib) + else() + set(ANTLR4_RUNTIME_LIBRARIES + ${ANTLR4_OUTPUT_DIR}/libantlr4-runtime.so) + endif() +endif() + +if(${CMAKE_GENERATOR} MATCHES ".* Makefiles") + # This avoids + # 'warning: jobserver unavailable: using -j1. Add '+' to parent make rule.' + set(ANTLR4_BUILD_COMMAND $(MAKE)) +elseif(${CMAKE_GENERATOR} MATCHES "Visual Studio.*") + set(ANTLR4_BUILD_COMMAND + ${CMAKE_COMMAND} + --build . + --config $(Configuration) + --target) +elseif(${CMAKE_GENERATOR} MATCHES "Xcode.*") + set(ANTLR4_BUILD_COMMAND + ${CMAKE_COMMAND} + --build . + --config $(CONFIGURATION) + --target) +else() + set(ANTLR4_BUILD_COMMAND + ${CMAKE_COMMAND} + --build . + --target) +endif() + +if(NOT DEFINED ANTLR4_WITH_STATIC_CRT) + set(ANTLR4_WITH_STATIC_CRT ON) +endif() + +if(ANTLR4_ZIP_REPOSITORY) + ExternalProject_Add( + antlr4_runtime + PREFIX antlr4_runtime + URL ${ANTLR4_ZIP_REPOSITORY} + DOWNLOAD_DIR ${CMAKE_CURRENT_BINARY_DIR} + BUILD_COMMAND "" + BUILD_IN_SOURCE 1 + SOURCE_DIR ${ANTLR4_ROOT} + SOURCE_SUBDIR runtime/Cpp + CMAKE_CACHE_ARGS + -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE} + -DWITH_STATIC_CRT:BOOL=${ANTLR4_WITH_STATIC_CRT} + # -DCMAKE_CXX_STANDARD:STRING=17 # if desired, compile the runtime with a different C++ standard + # -DCMAKE_CXX_STANDARD:STRING=${CMAKE_CXX_STANDARD} # alternatively, compile the runtime with the same C++ standard as the outer project + INSTALL_COMMAND "" + EXCLUDE_FROM_ALL 1) +else() + ExternalProject_Add( + antlr4_runtime + PREFIX antlr4_runtime + GIT_REPOSITORY ${ANTLR4_GIT_REPOSITORY} + GIT_TAG ${ANTLR4_TAG} + DOWNLOAD_DIR ${CMAKE_CURRENT_BINARY_DIR} + BUILD_COMMAND "" + BUILD_IN_SOURCE 1 + SOURCE_DIR ${ANTLR4_ROOT} + SOURCE_SUBDIR runtime/Cpp + CMAKE_CACHE_ARGS + -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE} + -DWITH_STATIC_CRT:BOOL=${ANTLR4_WITH_STATIC_CRT} + # -DCMAKE_CXX_STANDARD:STRING=17 # if desired, compile the runtime with a different C++ standard + # -DCMAKE_CXX_STANDARD:STRING=${CMAKE_CXX_STANDARD} # alternatively, compile the runtime with the same C++ standard as the outer project + INSTALL_COMMAND "" + EXCLUDE_FROM_ALL 1) +endif() + +# Separate build step as rarely people want both +set(ANTLR4_BUILD_DIR ${ANTLR4_ROOT}) +if(${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.14.0") + # CMake 3.14 builds in above's SOURCE_SUBDIR when BUILD_IN_SOURCE is true + set(ANTLR4_BUILD_DIR ${ANTLR4_ROOT}/runtime/Cpp) +endif() + +ExternalProject_Add_Step( + antlr4_runtime + build_static + COMMAND ${ANTLR4_BUILD_COMMAND} antlr4_static + # Depend on target instead of step (a custom command) + # to avoid running dependent steps concurrently + DEPENDS antlr4_runtime + BYPRODUCTS ${ANTLR4_STATIC_LIBRARIES} + EXCLUDE_FROM_MAIN 1 + WORKING_DIRECTORY ${ANTLR4_BUILD_DIR}) +ExternalProject_Add_StepTargets(antlr4_runtime build_static) + +add_library(antlr4_static STATIC IMPORTED) +add_dependencies(antlr4_static antlr4_runtime-build_static) +set_target_properties(antlr4_static PROPERTIES + IMPORTED_LOCATION ${ANTLR4_STATIC_LIBRARIES}) + +ExternalProject_Add_Step( + antlr4_runtime + build_shared + COMMAND ${ANTLR4_BUILD_COMMAND} antlr4_shared + # Depend on target instead of step (a custom command) + # to avoid running dependent steps concurrently + DEPENDS antlr4_runtime + BYPRODUCTS ${ANTLR4_SHARED_LIBRARIES} ${ANTLR4_RUNTIME_LIBRARIES} + EXCLUDE_FROM_MAIN 1 + WORKING_DIRECTORY ${ANTLR4_BUILD_DIR}) +ExternalProject_Add_StepTargets(antlr4_runtime build_shared) + +add_library(antlr4_shared SHARED IMPORTED) +add_dependencies(antlr4_shared antlr4_runtime-build_shared) +set_target_properties(antlr4_shared PROPERTIES + IMPORTED_LOCATION ${ANTLR4_RUNTIME_LIBRARIES}) +if(ANTLR4_SHARED_LIBRARIES) + set_target_properties(antlr4_shared PROPERTIES + IMPORTED_IMPLIB ${ANTLR4_SHARED_LIBRARIES}) +endif() diff --git a/antlr/antlr4-runtime/cmake/FindANTLR.cmake b/antlr/antlr4-runtime/cmake/FindANTLR.cmake new file mode 100644 index 0000000..2d204d7 --- /dev/null +++ b/antlr/antlr4-runtime/cmake/FindANTLR.cmake @@ -0,0 +1,124 @@ +find_package(Java QUIET COMPONENTS Runtime) + +if(NOT ANTLR_EXECUTABLE) + find_program(ANTLR_EXECUTABLE + NAMES antlr.jar antlr4.jar antlr-4.jar antlr-4.9.3-complete.jar) +endif() + +if(ANTLR_EXECUTABLE AND Java_JAVA_EXECUTABLE) + execute_process( + COMMAND ${Java_JAVA_EXECUTABLE} -jar ${ANTLR_EXECUTABLE} + OUTPUT_VARIABLE ANTLR_COMMAND_OUTPUT + ERROR_VARIABLE ANTLR_COMMAND_ERROR + RESULT_VARIABLE ANTLR_COMMAND_RESULT + OUTPUT_STRIP_TRAILING_WHITESPACE) + + if(ANTLR_COMMAND_RESULT EQUAL 0) + string(REGEX MATCH "Version [0-9]+(\\.[0-9])*" ANTLR_VERSION ${ANTLR_COMMAND_OUTPUT}) + string(REPLACE "Version " "" ANTLR_VERSION ${ANTLR_VERSION}) + else() + message( + SEND_ERROR + "Command '${Java_JAVA_EXECUTABLE} -jar ${ANTLR_EXECUTABLE}' " + "failed with the output '${ANTLR_COMMAND_ERROR}'") + endif() + + macro(ANTLR_TARGET Name InputFile) + set(ANTLR_OPTIONS LEXER PARSER LISTENER VISITOR) + set(ANTLR_ONE_VALUE_ARGS PACKAGE OUTPUT_DIRECTORY DEPENDS_ANTLR) + set(ANTLR_MULTI_VALUE_ARGS COMPILE_FLAGS DEPENDS) + cmake_parse_arguments(ANTLR_TARGET + "${ANTLR_OPTIONS}" + "${ANTLR_ONE_VALUE_ARGS}" + "${ANTLR_MULTI_VALUE_ARGS}" + ${ARGN}) + + set(ANTLR_${Name}_INPUT ${InputFile}) + + get_filename_component(ANTLR_INPUT ${InputFile} NAME_WE) + + if(ANTLR_TARGET_OUTPUT_DIRECTORY) + set(ANTLR_${Name}_OUTPUT_DIR ${ANTLR_TARGET_OUTPUT_DIRECTORY}) + else() + set(ANTLR_${Name}_OUTPUT_DIR + ${CMAKE_CURRENT_BINARY_DIR}/antlr4cpp_generated_src/${ANTLR_INPUT}) + endif() + + unset(ANTLR_${Name}_CXX_OUTPUTS) + + if((ANTLR_TARGET_LEXER AND NOT ANTLR_TARGET_PARSER) OR + (ANTLR_TARGET_PARSER AND NOT ANTLR_TARGET_LEXER)) + list(APPEND ANTLR_${Name}_CXX_OUTPUTS + ${ANTLR_${Name}_OUTPUT_DIR}/${ANTLR_INPUT}.h + ${ANTLR_${Name}_OUTPUT_DIR}/${ANTLR_INPUT}.cpp) + set(ANTLR_${Name}_OUTPUTS + ${ANTLR_${Name}_OUTPUT_DIR}/${ANTLR_INPUT}.interp + ${ANTLR_${Name}_OUTPUT_DIR}/${ANTLR_INPUT}.tokens) + else() + list(APPEND ANTLR_${Name}_CXX_OUTPUTS + ${ANTLR_${Name}_OUTPUT_DIR}/${ANTLR_INPUT}Lexer.h + ${ANTLR_${Name}_OUTPUT_DIR}/${ANTLR_INPUT}Lexer.cpp + ${ANTLR_${Name}_OUTPUT_DIR}/${ANTLR_INPUT}Parser.h + ${ANTLR_${Name}_OUTPUT_DIR}/${ANTLR_INPUT}Parser.cpp) + list(APPEND ANTLR_${Name}_OUTPUTS + ${ANTLR_${Name}_OUTPUT_DIR}/${ANTLR_INPUT}Lexer.interp + ${ANTLR_${Name}_OUTPUT_DIR}/${ANTLR_INPUT}Lexer.tokens) + endif() + + if(ANTLR_TARGET_LISTENER) + list(APPEND ANTLR_${Name}_CXX_OUTPUTS + ${ANTLR_${Name}_OUTPUT_DIR}/${ANTLR_INPUT}BaseListener.h + ${ANTLR_${Name}_OUTPUT_DIR}/${ANTLR_INPUT}BaseListener.cpp + ${ANTLR_${Name}_OUTPUT_DIR}/${ANTLR_INPUT}Listener.h + ${ANTLR_${Name}_OUTPUT_DIR}/${ANTLR_INPUT}Listener.cpp) + list(APPEND ANTLR_TARGET_COMPILE_FLAGS -listener) + endif() + + if(ANTLR_TARGET_VISITOR) + list(APPEND ANTLR_${Name}_CXX_OUTPUTS + ${ANTLR_${Name}_OUTPUT_DIR}/${ANTLR_INPUT}BaseVisitor.h + ${ANTLR_${Name}_OUTPUT_DIR}/${ANTLR_INPUT}BaseVisitor.cpp + ${ANTLR_${Name}_OUTPUT_DIR}/${ANTLR_INPUT}Visitor.h + ${ANTLR_${Name}_OUTPUT_DIR}/${ANTLR_INPUT}Visitor.cpp) + list(APPEND ANTLR_TARGET_COMPILE_FLAGS -visitor) + endif() + + if(ANTLR_TARGET_PACKAGE) + list(APPEND ANTLR_TARGET_COMPILE_FLAGS -package ${ANTLR_TARGET_PACKAGE}) + endif() + + list(APPEND ANTLR_${Name}_OUTPUTS ${ANTLR_${Name}_CXX_OUTPUTS}) + + if(ANTLR_TARGET_DEPENDS_ANTLR) + if(ANTLR_${ANTLR_TARGET_DEPENDS_ANTLR}_INPUT) + list(APPEND ANTLR_TARGET_DEPENDS + ${ANTLR_${ANTLR_TARGET_DEPENDS_ANTLR}_INPUT}) + list(APPEND ANTLR_TARGET_DEPENDS + ${ANTLR_${ANTLR_TARGET_DEPENDS_ANTLR}_OUTPUTS}) + else() + message(SEND_ERROR + "ANTLR target '${ANTLR_TARGET_DEPENDS_ANTLR}' not found") + endif() + endif() + + add_custom_command( + OUTPUT ${ANTLR_${Name}_OUTPUTS} + COMMAND ${Java_JAVA_EXECUTABLE} -jar ${ANTLR_EXECUTABLE} + ${InputFile} + -o ${ANTLR_${Name}_OUTPUT_DIR} + -no-listener + -Dlanguage=Cpp + ${ANTLR_TARGET_COMPILE_FLAGS} + DEPENDS ${InputFile} + ${ANTLR_TARGET_DEPENDS} + WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} + COMMENT "Building ${Name} with ANTLR ${ANTLR_VERSION}") + endmacro(ANTLR_TARGET) + +endif(ANTLR_EXECUTABLE AND Java_JAVA_EXECUTABLE) + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args( + ANTLR + REQUIRED_VARS ANTLR_EXECUTABLE Java_JAVA_EXECUTABLE + VERSION_VAR ANTLR_VERSION) diff --git a/antlr/antlr4-runtime/cmake/README.md b/antlr/antlr4-runtime/cmake/README.md new file mode 100644 index 0000000..0ebe1dd --- /dev/null +++ b/antlr/antlr4-runtime/cmake/README.md @@ -0,0 +1,157 @@ +## Getting started with Antlr4Cpp + +Here is how you can use this external project to create the antlr4cpp demo to start your project off. + +1. Create your project source folder somewhere. e.g. ~/srcfolder/ + 1. Make a subfolder cmake + 2. Copy the files in this folder to srcfolder/cmake + 3. Cut below and use it to create srcfolder/CMakeLists.txt + 4. Copy main.cpp, TLexer.g4 and TParser.g4 to ./srcfolder/ from [here](https://github.com/antlr/antlr4/tree/master/runtime/Cpp/demo) +2. Make a build folder e.g. ~/buildfolder/ +3. From the buildfolder, run `cmake ~/srcfolder; make` + +```cmake +# minimum required CMAKE version +CMAKE_MINIMUM_REQUIRED(VERSION 3.7 FATAL_ERROR) + +list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake) + +# compiler must be 11 or 14 +set(CMAKE_CXX_STANDARD 11) + +# required if linking to static library +add_definitions(-DANTLR4CPP_STATIC) + +# using /MD flag for antlr4_runtime (for Visual C++ compilers only) +set(ANTLR4_WITH_STATIC_CRT OFF) +# add external build for antlrcpp +include(ExternalAntlr4Cpp) +# add antrl4cpp artifacts to project environment +include_directories(${ANTLR4_INCLUDE_DIRS}) + +# set variable pointing to the antlr tool that supports C++ +# this is not required if the jar file can be found under PATH environment +set(ANTLR_EXECUTABLE /home/user/antlr-4.9.3-complete.jar) +# add macros to generate ANTLR Cpp code from grammar +find_package(ANTLR REQUIRED) + +# Call macro to add lexer and grammar to your build dependencies. +antlr_target(SampleGrammarLexer TLexer.g4 LEXER + PACKAGE antlrcpptest) +antlr_target(SampleGrammarParser TParser.g4 PARSER + PACKAGE antlrcpptest + DEPENDS_ANTLR SampleGrammarLexer + COMPILE_FLAGS -lib ${ANTLR_SampleGrammarLexer_OUTPUT_DIR}) + +# include generated files in project environment +include_directories(${ANTLR_SampleGrammarLexer_OUTPUT_DIR}) +include_directories(${ANTLR_SampleGrammarParser_OUTPUT_DIR}) + +# add generated grammar to demo binary target +add_executable(demo main.cpp + ${ANTLR_SampleGrammarLexer_CXX_OUTPUTS} + ${ANTLR_SampleGrammarParser_CXX_OUTPUTS}) +target_link_libraries(demo antlr4_static) +``` + +## Documentation for FindANTLR + +The module defines the following variables: + +``` +ANTLR_FOUND - true is ANTLR jar executable is found +ANTLR_EXECUTABLE - the path to the ANTLR jar executable +ANTLR_VERSION - the version of ANTLR +``` + +If ANTLR is found, the module will provide the macros: + +``` +ANTLR_TARGET( + [PACKAGE namespace] + [OUTPUT_DIRECTORY dir] + [DEPENDS_ANTLR ] + [COMPILE_FLAGS [args...]] + [DEPENDS [depends...]] + [LEXER] + [PARSER] + [LISTENER] + [VISITOR]) +``` + +which creates a custom command to generate C++ files from ``. Running the macro defines the following variables: + +``` +ANTLR_${name}_INPUT - the ANTLR input used for the macro +ANTLR_${name}_OUTPUTS - the outputs generated by ANTLR +ANTLR_${name}_CXX_OUTPUTS - the C++ outputs generated by ANTLR +ANTLR_${name}_OUTPUT_DIR - the output directory for ANTLR +``` + +The options are: + +* `PACKAGE` - defines a namespace for the generated C++ files +* `OUTPUT_DIRECTORY` - the output directory for the generated files. By default it uses `${CMAKE_CURRENT_BINARY_DIR}` +* `DEPENDS_ANTLR` - the dependent target generated from antlr_target for the current call +* `COMPILE_FLAGS` - additional compile flags for ANTLR tool +* `DEPENDS` - specify the files on which the command depends. It works the same way `DEPENDS` in [`add_custom_command()`](https://cmake.org/cmake/help/v3.11/command/add_custom_command.html) +* `LEXER` - specify that the input file is a lexer grammar +* `PARSER` - specify that the input file is a parser grammar +* `LISTENER` - tell ANTLR tool to generate a parse tree listener +* `VISITOR` - tell ANTLR tool to generate a parse tree visitor + +### Examples + +To generate C++ files from an ANTLR input file T.g4, which defines both lexer and parser grammar one may call: + +```cmake +find_package(ANTLR REQUIRED) +antlr_target(Sample T.g4) +``` + +Note that this command will do nothing unless the outputs of `Sample`, i.e. `ANTLR_Sample_CXX_OUTPUTS` gets used by some target. + +## Documentation for ExternalAntlr4Cpp + +Including ExternalAntlr4Cpp will add `antlr4_static` and `antlr4_shared` as an optional target. It will also define the following variables: + +``` +ANTLR4_INCLUDE_DIRS - the include directory that should be included when compiling C++ source file +ANTLR4_STATIC_LIBRARIES - path to antlr4 static library +ANTLR4_SHARED_LIBRARIES - path to antlr4 shared library +ANTLR4_RUNTIME_LIBRARIES - path to antlr4 shared runtime library (such as DLL, DYLIB and SO file) +ANTLR4_TAG - branch/tag used for building antlr4 library +``` + +`ANTLR4_TAG` is set to master branch by default to keep antlr4 updated. However, it will be required to rebuild after every `clean` is called. Set `ANTLR4_TAG` to a desired commit hash value to avoid rebuilding after every `clean` and keep the build stable, at the cost of not automatically update to latest commit. + +The ANTLR C++ runtime source is downloaded from GitHub by default. However, users may specify `ANTLR4_ZIP_REPOSITORY` to list the zip file from [ANTLR downloads](http://www.antlr.org/download.html) (under *C++ Target*). This variable can list a zip file included in the project directory; this is useful for maintaining a canonical source for each new build. + +Visual C++ compiler users may want to additionally define `ANTLR4_WITH_STATIC_CRT` before including the file. Set `ANTLR4_WITH_STATIC_CRT` to true if ANTLR4 C++ runtime library should be compiled with `/MT` flag, otherwise will be compiled with `/MD` flag. This variable has a default value of `OFF`. Changing `ANTLR4_WITH_STATIC_CRT` after building the library may require reinitialization of CMake or `clean` for the library to get rebuilt. + +You may need to modify your local copy of ExternalAntlr4Cpp.cpp to modify some build settings. For example, to specify the C++ standard to use when building the runtime, add `-DCMAKE_CXX_STANDARD:STRING=17` to `CMAKE_CACHE_ARGS`. + +### Examples + +To build and link ANTLR4 static library to a target one may call: + +```cmake +include(ExternalAntlr4Cpp) +include_directories(${ANTLR4_INCLUDE_DIRS}) +add_executable(output main.cpp) +target_link_libraries(output antlr4_static) +``` + +It may also be a good idea to copy the runtime libraries (DLL, DYLIB or SO file) to the executable for it to run properly after build. i.e. To build and link antlr4 shared library to a target one may call: + +```cmake +include(ExternalAntlr4Cpp) +include_directories(${ANTLR4_INCLUDE_DIRS}) +add_executable(output main.cpp) +target_link_libraries(output antlr4_shared) +add_custom_command(TARGET output + POST_BUILD + COMMAND ${CMAKE_COMMAND} + -E copy ${ANTLR4_RUNTIME_LIBRARIES} . + WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}) +``` diff --git a/antlr/antlr4-runtime/cmake/antlr4-generator.cmake.in b/antlr/antlr4-runtime/cmake/antlr4-generator.cmake.in new file mode 100644 index 0000000..6399651 --- /dev/null +++ b/antlr/antlr4-runtime/cmake/antlr4-generator.cmake.in @@ -0,0 +1,181 @@ +set(ANTLR_VERSION @ANTLR_VERSION@) + +@PACKAGE_INIT@ + +if (NOT ANTLR4_CPP_GENERATED_SRC_DIR) + set(ANTLR4_GENERATED_SRC_DIR ${CMAKE_BINARY_DIR}/antlr4_generated_src) +endif() + +FIND_PACKAGE(Java COMPONENTS Runtime REQUIRED) + +# +# The ANTLR generator will output the following files given the input file f.g4 +# +# Input -> f.g4 +# Output -> f.h +# -> f.cpp +# +# the following files will only be produced if there is a parser contained +# Flag -visitor active +# Output -> BaseVisitor.h +# -> BaseVisitor.cpp +# -> Visitor.h +# -> Visitor.cpp +# +# Flag -listener active +# Output -> BaseListener.h +# -> BaseListener.cpp +# -> Listener.h +# -> Listener.cpp +# +# See documentation in markup +# +function(antlr4_generate + Antlr4_ProjectTarget + Antlr4_InputFile + Antlr4_GeneratorType + ) + + set( Antlr4_GeneratedSrcDir ${ANTLR4_GENERATED_SRC_DIR}/${Antlr4_ProjectTarget} ) + + get_filename_component(Antlr4_InputFileBaseName ${Antlr4_InputFile} NAME_WE ) + + list( APPEND Antlr4_GeneratorStatusMessage "Common Include-, Source- and Tokenfiles" ) + + if ( ${Antlr4_GeneratorType} STREQUAL "LEXER") + set(Antlr4_LexerBaseName "${Antlr4_InputFileBaseName}") + set(Antlr4_ParserBaseName "") + else() + if ( ${Antlr4_GeneratorType} STREQUAL "PARSER") + set(Antlr4_LexerBaseName "") + set(Antlr4_ParserBaseName "${Antlr4_InputFileBaseName}") + else() + if ( ${Antlr4_GeneratorType} STREQUAL "BOTH") + set(Antlr4_LexerBaseName "${Antlr4_InputFileBaseName}Lexer") + set(Antlr4_ParserBaseName "${Antlr4_InputFileBaseName}Parser") + else() + message(FATAL_ERROR "The third parameter must be LEXER, PARSER or BOTH") + endif () + endif () + endif () + + # Prepare list of generated targets + list( APPEND Antlr4_GeneratedTargets "${Antlr4_GeneratedSrcDir}/${Antlr4_InputFileBaseName}.tokens" ) + list( APPEND Antlr4_GeneratedTargets "${Antlr4_GeneratedSrcDir}/${Antlr4_InputFileBaseName}.interp" ) + list( APPEND DependentTargets "${Antlr4_GeneratedSrcDir}/${Antlr4_InputFileBaseName}.tokens" ) + + if ( NOT ${Antlr4_LexerBaseName} STREQUAL "" ) + list( APPEND Antlr4_GeneratedTargets "${Antlr4_GeneratedSrcDir}/${Antlr4_LexerBaseName}.h" ) + list( APPEND Antlr4_GeneratedTargets "${Antlr4_GeneratedSrcDir}/${Antlr4_LexerBaseName}.cpp" ) + endif () + + if ( NOT ${Antlr4_ParserBaseName} STREQUAL "" ) + list( APPEND Antlr4_GeneratedTargets "${Antlr4_GeneratedSrcDir}/${Antlr4_ParserBaseName}.h" ) + list( APPEND Antlr4_GeneratedTargets "${Antlr4_GeneratedSrcDir}/${Antlr4_ParserBaseName}.cpp" ) + endif () + + # process optional arguments ... + + if ( ( ARGC GREATER_EQUAL 4 ) AND ARGV3 ) + set(Antlr4_BuildListenerOption "-listener") + + list( APPEND Antlr4_GeneratedTargets "${Antlr4_GeneratedSrcDir}/${Antlr4_InputFileBaseName}BaseListener.h" ) + list( APPEND Antlr4_GeneratedTargets "${Antlr4_GeneratedSrcDir}/${Antlr4_InputFileBaseName}BaseListener.cpp" ) + list( APPEND Antlr4_GeneratedTargets "${Antlr4_GeneratedSrcDir}/${Antlr4_InputFileBaseName}Listener.h" ) + list( APPEND Antlr4_GeneratedTargets "${Antlr4_GeneratedSrcDir}/${Antlr4_InputFileBaseName}Listener.cpp" ) + + list( APPEND Antlr4_GeneratorStatusMessage ", Listener Include- and Sourcefiles" ) + else() + set(Antlr4_BuildListenerOption "-no-listener") + endif () + + if ( ( ARGC GREATER_EQUAL 5 ) AND ARGV4 ) + set(Antlr4_BuildVisitorOption "-visitor") + + list( APPEND Antlr4_GeneratedTargets "${Antlr4_GeneratedSrcDir}/${Antlr4_InputFileBaseName}BaseVisitor.h" ) + list( APPEND Antlr4_GeneratedTargets "${Antlr4_GeneratedSrcDir}/${Antlr4_InputFileBaseName}BaseVisitor.cpp" ) + list( APPEND Antlr4_GeneratedTargets "${Antlr4_GeneratedSrcDir}/${Antlr4_InputFileBaseName}Visitor.h" ) + list( APPEND Antlr4_GeneratedTargets "${Antlr4_GeneratedSrcDir}/${Antlr4_InputFileBaseName}Visitor.cpp" ) + + list( APPEND Antlr4_GeneratorStatusMessage ", Visitor Include- and Sourcefiles" ) + else() + set(Antlr4_BuildVisitorOption "-no-visitor") + endif () + + if ( (ARGC GREATER_EQUAL 6 ) AND (NOT ${ARGV5} STREQUAL "") ) + set(Antlr4_NamespaceOption "-package;${ARGV5}") + + list( APPEND Antlr4_GeneratorStatusMessage " in Namespace ${ARGV5}" ) + else() + set(Antlr4_NamespaceOption "") + endif () + + if ( (ARGC GREATER_EQUAL 7 ) AND (NOT ${ARGV6} STREQUAL "") ) + set(Antlr4_AdditionalDependencies ${ARGV6}) + else() + set(Antlr4_AdditionalDependencies "") + endif () + + if ( (ARGC GREATER_EQUAL 8 ) AND (NOT ${ARGV7} STREQUAL "") ) + set(Antlr4_LibOption "-lib;${ARGV7}") + + list( APPEND Antlr4_GeneratorStatusMessage " using Library ${ARGV7}" ) + else() + set(Antlr4_LibOption "") + endif () + + if(NOT Java_FOUND) + message(FATAL_ERROR "Java is required to process grammar or lexer files! - Use 'FIND_PACKAGE(Java COMPONENTS Runtime REQUIRED)'") + endif() + + if(NOT EXISTS "${ANTLR4_JAR_LOCATION}") + message(FATAL_ERROR "Unable to find antlr tool. ANTLR4_JAR_LOCATION:${ANTLR4_JAR_LOCATION}") + endif() + + # The call to generate the files + add_custom_command( + OUTPUT ${Antlr4_GeneratedTargets} + # Remove target directory + COMMAND + ${CMAKE_COMMAND} -E remove_directory ${Antlr4_GeneratedSrcDir} + # Create target directory + COMMAND + ${CMAKE_COMMAND} -E make_directory ${Antlr4_GeneratedSrcDir} + COMMAND + # Generate files + "${Java_JAVA_EXECUTABLE}" -jar "${ANTLR4_JAR_LOCATION}" -Werror -Dlanguage=Cpp ${Antlr4_BuildListenerOption} ${Antlr4_BuildVisitorOption} ${Antlr4_LibOption} ${ANTLR4_GENERATED_OPTIONS} -o "${Antlr4_GeneratedSrcDir}" ${Antlr4_NamespaceOption} "${Antlr4_InputFile}" + WORKING_DIRECTORY "${CMAKE_BINARY_DIR}" + MAIN_DEPENDENCY "${Antlr4_InputFile}" + DEPENDS ${Antlr4_AdditionalDependencies} + ) + + # set output variables in parent scope + set( ANTLR4_INCLUDE_DIR_${Antlr4_ProjectTarget} ${Antlr4_GeneratedSrcDir} PARENT_SCOPE) + set( ANTLR4_SRC_FILES_${Antlr4_ProjectTarget} ${Antlr4_GeneratedTargets} PARENT_SCOPE) + set( ANTLR4_TOKEN_FILES_${Antlr4_ProjectTarget} ${DependentTargets} PARENT_SCOPE) + set( ANTLR4_TOKEN_DIRECTORY_${Antlr4_ProjectTarget} ${Antlr4_GeneratedSrcDir} PARENT_SCOPE) + + # export generated cpp files into list + foreach(generated_file ${Antlr4_GeneratedTargets}) + + if (NOT CMAKE_CXX_COMPILER_ID MATCHES "MSVC") + set_source_files_properties( + ${generated_file} + PROPERTIES + COMPILE_FLAGS -Wno-overloaded-virtual + ) + endif () + + if (CMAKE_CXX_COMPILER_ID MATCHES "MSVC") + set_source_files_properties( + ${generated_file} + PROPERTIES + COMPILE_FLAGS -wd4251 + ) + endif () + + endforeach(generated_file) + +message(STATUS "Antlr4 ${Antlr4_ProjectTarget} - Building " ${Antlr4_GeneratorStatusMessage} ) + +endfunction() diff --git a/antlr/antlr4-runtime/cmake/antlr4-runtime.cmake.in b/antlr/antlr4-runtime/cmake/antlr4-runtime.cmake.in new file mode 100644 index 0000000..860aeb6 --- /dev/null +++ b/antlr/antlr4-runtime/cmake/antlr4-runtime.cmake.in @@ -0,0 +1,10 @@ +set(ANTLR_VERSION @ANTLR_VERSION@) + +@PACKAGE_INIT@ + +set_and_check(ANTLR4_INCLUDE_DIR "@PACKAGE_ANTLR4_INCLUDE_DIR@") +set_and_check(ANTLR4_LIB_DIR "@PACKAGE_ANTLR4_LIB_DIR@") + +include(${CMAKE_CURRENT_LIST_DIR}/@targets_export_name@.cmake) + +check_required_components(antlr) diff --git a/antlr/antlr4-runtime/demo/CMakeLists.txt b/antlr/antlr4-runtime/demo/CMakeLists.txt new file mode 100644 index 0000000..23b4c40 --- /dev/null +++ b/antlr/antlr4-runtime/demo/CMakeLists.txt @@ -0,0 +1,80 @@ +# -*- mode:cmake -*- +if(NOT UNIX) + message(WARNING "Unsupported operating system") +endif() + +set(antlr4-demo-GENERATED_SRC + ${PROJECT_SOURCE_DIR}/demo/generated/TLexer.cpp + ${PROJECT_SOURCE_DIR}/demo/generated/TParser.cpp + ${PROJECT_SOURCE_DIR}/demo/generated/TParserBaseListener.cpp + ${PROJECT_SOURCE_DIR}/demo/generated/TParserBaseVisitor.cpp + ${PROJECT_SOURCE_DIR}/demo/generated/TParserListener.cpp + ${PROJECT_SOURCE_DIR}/demo/generated/TParserVisitor.cpp + ) + +foreach(src_file ${antlr4-demo-GENERATED_SRC}) + set_source_files_properties( + ${src_file} + PROPERTIES + GENERATED TRUE + ) +endforeach(src_file ${antlr4-demo-GENERATED_SRC}) + +add_custom_target(GenerateParser DEPENDS ${antlr4-demo-GENERATED_SRC}) +add_custom_command(OUTPUT ${antlr4-demo-GENERATED_SRC} + COMMAND + ${CMAKE_COMMAND} -E make_directory ${PROJECT_SOURCE_DIR}/demo/generated/ + COMMAND + "${Java_JAVA_EXECUTABLE}" -jar ${ANTLR_JAR_LOCATION} -Werror -Dlanguage=Cpp -listener -visitor -o ${PROJECT_SOURCE_DIR}/demo/generated/ -package antlrcpptest ${PROJECT_SOURCE_DIR}/demo/TLexer.g4 ${PROJECT_SOURCE_DIR}/demo/TParser.g4 + WORKING_DIRECTORY "${CMAKE_BINARY_DIR}" + DEPENDS ${PROJECT_SOURCE_DIR}/demo/TLexer.g4 ${PROJECT_SOURCE_DIR}/demo/TParser.g4 + ) + +include_directories( + ${PROJECT_SOURCE_DIR}/runtime/src + ${PROJECT_SOURCE_DIR}/runtime/src/misc + ${PROJECT_SOURCE_DIR}/runtime/src/atn + ${PROJECT_SOURCE_DIR}/runtime/src/dfa + ${PROJECT_SOURCE_DIR}/runtime/src/tree + ${PROJECT_SOURCE_DIR}/runtime/src/support + ${PROJECT_SOURCE_DIR}/demo/generated + ) + +#file(GLOB antlr4-demo_SRC "${PROJECT_SOURCE_DIR}/demo/generated/*") +set(antlr4-demo_SRC + ${PROJECT_SOURCE_DIR}/demo/Linux/main.cpp + ${antlr4-demo-GENERATED_SRC} + ) + +if(NOT CMAKE_CXX_COMPILER_ID MATCHES "MSVC") + set (flags_1 "-Wno-overloaded-virtual") +else() + set (flags_1 "-MP /wd4251") +endif() + +foreach(src_file ${antlr4-demo_SRC}) + set_source_files_properties( + ${src_file} + PROPERTIES + COMPILE_FLAGS "${COMPILE_FLAGS} ${flags_1}" + ) +endforeach(src_file ${antlr4-demo_SRC}) + +add_executable(antlr4-demo + ${antlr4-demo_SRC} + ) +#add_precompiled_header(antlr4-demo ${PROJECT_SOURCE_DIR}/runtime/src/antlrcpp-Prefix.h) + +if(CMAKE_CXX_COMPILER_ID MATCHES "MSVC") + target_compile_options(antlr4-demo PRIVATE "/MT$<$:d>") +endif() + +add_dependencies(antlr4-demo GenerateParser) + +target_link_libraries(antlr4-demo antlr4_static) + +install(TARGETS antlr4-demo + DESTINATION "share" + COMPONENT dev + ) + diff --git a/antlr/antlr4-runtime/demo/Linux/main.cpp b/antlr/antlr4-runtime/demo/Linux/main.cpp new file mode 100644 index 0000000..672ce2a --- /dev/null +++ b/antlr/antlr4-runtime/demo/Linux/main.cpp @@ -0,0 +1,38 @@ +/* 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. + */ + +// +// main.cpp +// antlr4-cpp-demo +// +// Created by Mike Lischke on 13.03.16. +// + +#include + +#include "antlr4-runtime.h" +#include "TLexer.h" +#include "TParser.h" + +using namespace antlrcpptest; +using namespace antlr4; + +int main(int , const char **) { + ANTLRInputStream input(u8"๐Ÿด = ๐Ÿ + \"๐Ÿ˜Ž\";(((x * ฯ€))) * ยต + โˆฐ; a + (x * (y ? 0 : 1) + z);"); + TLexer lexer(&input); + CommonTokenStream tokens(&lexer); + + tokens.fill(); + for (auto token : tokens.getTokens()) { + std::cout << token->toString() << std::endl; + } + + TParser parser(&tokens); + tree::ParseTree* tree = parser.main(); + + std::cout << tree->toStringTree(&parser) << std::endl << std::endl; + + return 0; +} diff --git a/antlr/antlr4-runtime/demo/Mac/antlr4-cpp-demo/main.cpp b/antlr/antlr4-runtime/demo/Mac/antlr4-cpp-demo/main.cpp new file mode 100644 index 0000000..8420ae1 --- /dev/null +++ b/antlr/antlr4-runtime/demo/Mac/antlr4-cpp-demo/main.cpp @@ -0,0 +1,38 @@ +/* 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. + */ + +// +// main.cpp +// antlr4-cpp-demo +// +// Created by Mike Lischke on 13.03.16. +// + +#include + +#include "antlr4-runtime.h" +#include "TLexer.h" +#include "TParser.h" + +using namespace antlrcpptest; +using namespace antlr4; + +int main(int , const char **) { + ANTLRInputStream input(u8"๐Ÿด = ๐Ÿ + \"๐Ÿ˜Ž\";(((x * ฯ€))) * ยต + โˆฐ; a + (x * (y ? 0 : 1) + z);"); + TLexer lexer(&input); + CommonTokenStream tokens(&lexer); + + tokens.fill(); + for (auto token : tokens.getTokens()) { + std::cout << token->toString() << std::endl; + } + + TParser parser(&tokens); + tree::ParseTree *tree = parser.main(); + + std::cout << tree->toStringTree(&parser) << std::endl; + + return 0; +} diff --git a/antlr/antlr4-runtime/demo/Mac/antlrcpp Tests/Info.plist b/antlr/antlr4-runtime/demo/Mac/antlrcpp Tests/Info.plist new file mode 100644 index 0000000..ba72822 --- /dev/null +++ b/antlr/antlr4-runtime/demo/Mac/antlrcpp Tests/Info.plist @@ -0,0 +1,24 @@ + + + + + CFBundleDevelopmentRegion + en + CFBundleExecutable + $(EXECUTABLE_NAME) + CFBundleIdentifier + $(PRODUCT_BUNDLE_IDENTIFIER) + CFBundleInfoDictionaryVersion + 6.0 + CFBundleName + $(PRODUCT_NAME) + CFBundlePackageType + BNDL + CFBundleShortVersionString + 1.0 + CFBundleSignature + ???? + CFBundleVersion + 1 + + diff --git a/antlr/antlr4-runtime/demo/Mac/antlrcpp Tests/InputHandlingTests.mm b/antlr/antlr4-runtime/demo/Mac/antlrcpp Tests/InputHandlingTests.mm new file mode 100644 index 0000000..647f73f --- /dev/null +++ b/antlr/antlr4-runtime/demo/Mac/antlrcpp Tests/InputHandlingTests.mm @@ -0,0 +1,172 @@ +/* + * [The "BSD license"] + * Copyright (c) 2016 Mike Lischke + * 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. + */ + +#import + +#include "ANTLRInputStream.h" +#include "Exceptions.h" +#include "Interval.h" +#include "UnbufferedTokenStream.h" +#include "StringUtils.h" + +using namespace antlrcpp; +using namespace antlr4; +using namespace antlr4::misc; + +@interface InputHandlingTests : XCTestCase + +@end + +@implementation InputHandlingTests + +- (void)setUp { + [super setUp]; + // Put setup code here. This method is called before the invocation of each test method in the class. +} + +- (void)tearDown { + // Put teardown code here. This method is called after the invocation of each test method in the class. + [super tearDown]; +} + +- (void)testANTLRInputStreamCreation { + ANTLRInputStream stream1; + XCTAssert(stream1.toString().empty()); + XCTAssertEqual(stream1.index(), 0U); + + ANTLRInputStream stream2("To be or not to be"); + XCTAssert(stream2.toString() == "To be or not to be"); + XCTAssertEqual(stream2.index(), 0U); + XCTAssertEqual(stream2.size(), 18U); + + char data[] = "Lorem ipsum dolor sit amet"; + ANTLRInputStream stream3(data, sizeof(data) / sizeof(data[0])); + XCTAssert(stream3.toString() == std::string("Lorem ipsum dolor sit amet\0", 27)); + XCTAssertEqual(stream3.index(), 0U); + XCTAssertEqual(stream3.size(), 27U); + + std::stringstream input("Lorem ipsum dolor sit amet"); + ANTLRInputStream stream4(input); + std::string content = stream4.toString(); + XCTAssertEqual(content, "Lorem ipsum dolor sit amet"); // Now as utf-8 string. + XCTAssertEqual(stream4.index(), 0U); + XCTAssertEqual(stream4.size(), 26U); + + std::string longString(33333, 'a'); + input.str(longString); + stream4.load(input); + XCTAssertEqual(stream4.index(), 0U); + XCTAssertEqual(stream4.size(), 33333U); + + input.clear(); + stream4.load(input); + XCTAssertEqual(stream4.size(), 0U); +} + +- (void)testANTLRInputStreamUse { + std::string text(u8"๐ŸšงLorem ipsum dolor sit amet๐Ÿ•ถ"); + std::u32string wtext = utf8_to_utf32(text.c_str(), text.c_str() + text.size()); // Convert to UTF-32. + ANTLRInputStream stream(text); + XCTAssertEqual(stream.index(), 0U); + XCTAssertEqual(stream.size(), wtext.size()); + + for (size_t i = 0; i < stream.size(); ++i) { + stream.consume(); + XCTAssertEqual(stream.index(), i + 1); + } + + try { + stream.consume(); + XCTFail(); + } catch (IllegalStateException &e) { + // Expected. + std::string message = e.what(); + XCTAssertEqual(message, "cannot consume EOF"); + } + + XCTAssertEqual(stream.index(), wtext.size()); + stream.reset(); + XCTAssertEqual(stream.index(), 0U); + + XCTAssertEqual(stream.LA(0), 0ULL); + for (size_t i = 1; i < wtext.size(); ++i) { + XCTAssertEqual(stream.LA(static_cast(i)), wtext[i - 1]); // LA(1) means: current char. + XCTAssertEqual(stream.LT(static_cast(i)), wtext[i - 1]); // LT is mapped to LA. + XCTAssertEqual(stream.index(), 0U); // No consumption when looking ahead. + } + + stream.seek(wtext.size() - 1); + XCTAssertEqual(stream.index(), wtext.size() - 1); + + stream.seek(wtext.size() / 2); + XCTAssertEqual(stream.index(), wtext.size() / 2); + + stream.seek(wtext.size() - 1); + for (ssize_t i = 1; i < static_cast(wtext.size()) - 1; ++i) { + XCTAssertEqual(stream.LA(-i), wtext[wtext.size() - i - 1]); // LA(-1) means: previous char. + XCTAssertEqual(stream.LT(-i), wtext[wtext.size() - i - 1]); // LT is mapped to LA. + XCTAssertEqual(stream.index(), wtext.size() - 1); // No consumption when looking ahead. + } + + XCTAssertEqual(stream.LA(-10000), IntStream::EOF); + + // Mark and release do nothing. + stream.reset(); + XCTAssertEqual(stream.index(), 0U); + ssize_t marker = stream.mark(); + XCTAssertEqual(marker, -1); + stream.seek(10); + XCTAssertEqual(stream.index(), 10U); + XCTAssertEqual(stream.mark(), -1); + + stream.release(marker); + XCTAssertEqual(stream.index(), 10U); + + misc::Interval interval1(2, 10UL); // From - to, inclusive. + std::string output = stream.getText(interval1); + std::string sub = utf32_to_utf8(wtext.substr(2, 9)); + XCTAssertEqual(output, sub); + + misc::Interval interval2(200, 10UL); // Start beyond bounds. + output = stream.getText(interval2); + XCTAssert(output.empty()); + + misc::Interval interval3(0, 200UL); // End beyond bounds. + output = stream.getText(interval3); + XCTAssertEqual(output, text); + + stream.name = "unit tests"; // Quite useless test, as "name" is a public field. + XCTAssertEqual(stream.getSourceName(), "unit tests"); +} + +- (void)testUnbufferedTokenSteam { + //UnbufferedTokenStream stream; +} + +@end diff --git a/antlr/antlr4-runtime/demo/Mac/antlrcpp Tests/MiscClassTests.mm b/antlr/antlr4-runtime/demo/Mac/antlrcpp Tests/MiscClassTests.mm new file mode 100644 index 0000000..58cac4b --- /dev/null +++ b/antlr/antlr4-runtime/demo/Mac/antlrcpp Tests/MiscClassTests.mm @@ -0,0 +1,388 @@ +/* + * [The "BSD license"] + * Copyright (c) 2016 Mike Lischke + * 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. + */ + +#import + +#include "antlr4-runtime.h" + +using namespace antlr4; +using namespace antlr4::misc; +using namespace antlrcpp; + +@interface MiscClassTests : XCTestCase + +@end + +@implementation MiscClassTests + +- (void)setUp { + [super setUp]; + // Put setup code here. This method is called before the invocation of each test method in the class. +} + +- (void)tearDown { + // Put teardown code here. This method is called after the invocation of each test method in the class. + [super tearDown]; +} + +- (void)testCPPUtils { + + class A { public: virtual ~A() {}; }; + class B : public A { public: virtual ~B() {}; }; + class C : public A { public: virtual ~C() {}; }; + class D : public C { public: virtual ~D() {}; }; + + { + A *a = new A(); B *b = new B(); C *c = new C(); D *d = new D(); + XCTAssert(is(b)); + XCTAssertFalse(is(a)); + XCTAssert(is(c)); + XCTAssertFalse(is(c)); + XCTAssert(is(d)); + XCTAssert(is(d)); + XCTAssertFalse(is(d)); + delete a; delete b; delete c; delete d; + } + { + Ref a(new A()); + Ref b(new B()); + Ref c(new C()); + Ref d(new D()); + XCTAssert(is(b)); + XCTAssertFalse(is(a)); + XCTAssert(is(c)); + XCTAssertFalse(is(c)); + XCTAssert(is(d)); + XCTAssert(is(d)); + XCTAssertFalse(is(d)); + } +} + +- (void)testMurmurHash { + XCTAssertEqual(MurmurHash::initialize(), 0U); + XCTAssertEqual(MurmurHash::initialize(31), 31U); + + // In absence of real test vectors (64bit) for murmurhash I instead check if I can find duplicate hash values + // in a deterministic and a random sequence of 100K values each. + std::set hashs; + for (size_t i = 0; i < 100000; ++i) { + std::vector data = { i, static_cast(i * M_PI), arc4random() }; + size_t hash = 0; + for (auto value : data) + hash = MurmurHash::update(hash, value); + hash = MurmurHash::finish(hash, data.size()); + hashs.insert(hash); + } + XCTAssertEqual(hashs.size(), 100000U, @"At least one duplicate hash found."); + + hashs.clear(); + for (size_t i = 0; i < 100000; ++i) { + std::vector data = { i, static_cast(i * M_PI) }; + size_t hash = 0; + for (auto value : data) + hash = MurmurHash::update(hash, value); + hash = MurmurHash::finish(hash, data.size()); + hashs.insert(hash); + } + XCTAssertEqual(hashs.size(), 100000U, @"At least one duplicate hash found."); + + // Another test with fixed input but varying seeds. + // Note: the higher the seed the less LSDs are in the result (for small input data). + hashs.clear(); + std::vector data = { L'ยต', 'a', '@', '1' }; + for (size_t i = 0; i < 100000; ++i) { + size_t hash = i; + for (auto value : data) + hash = MurmurHash::update(hash, value); + hash = MurmurHash::finish(hash, data.size()); + hashs.insert(hash); + } + XCTAssertEqual(hashs.size(), 100000U, @"At least one duplicate hash found."); +} + +- (void)testInterval { + // The Interval class contains no error handling (checks for invalid intervals), hence some of the results + // look strange as we test of course such intervals as well. + XCTAssertEqual(Interval().length(), 0UL); + XCTAssertEqual(Interval(0, 0UL).length(), 1UL); // Remember: it's an inclusive interval. + XCTAssertEqual(Interval(100, 100UL).length(), 1UL); + XCTAssertEqual(Interval(-1L, -1).length(), 1UL); // Unwanted behavior: negative ranges. + XCTAssertEqual(Interval(-1L, -2).length(), 0UL); + XCTAssertEqual(Interval(100, 50UL).length(), 0UL); + + XCTAssert(Interval() == Interval(-1L, -2)); + XCTAssert(Interval(0, 0UL) == Interval(0, 0UL)); + XCTAssertFalse(Interval(0, 1UL) == Interval(1, 2UL)); + + XCTAssertEqual(Interval().hashCode(), 22070U); + XCTAssertEqual(Interval(0, 0UL).hashCode(), 22103U); + XCTAssertEqual(Interval(10, 2000UL).hashCode(), 24413U); + + // Results for the interval test functions in this order: + // startsBeforeDisjoint + // startsBeforeNonDisjoint + // startsAfter + // startsAfterDisjoint + // startsAfterNonDisjoint + // disjoint + // adjacent + // properlyContains + + typedef std::vector TestResults; + struct TestEntry { size_t runningNumber; Interval interval1, interval2; TestResults results; }; + std::vector testData = { + // Extreme cases + invalid intervals. + { 0, Interval(), Interval(10, 20UL), { true, false, false, false, false, true, false, false } }, + { 1, Interval(1, 1UL), Interval(1, 1UL), { false, true, false, false, false, false, false, true } }, + { 2, Interval(10000, 10000UL), Interval(10000, 10000UL), { false, true, false, false, false, false, false, true } }, + { 3, Interval(100, 10UL), Interval(100, 10UL), { false, false, false, true, false, true, false, true } }, + { 4, Interval(100, 10UL), Interval(10, 100UL), { false, false, true, false, true, false, false, false } }, + { 5, Interval(10, 100UL), Interval(100, 10UL), { false, true, false, false, false, false, false, true } }, + + // First starts before second. End varies. + { 20, Interval(10, 12UL), Interval(12, 100UL), { false, true, false, false, false, false, false, false } }, + { 21, Interval(10, 12UL), Interval(13, 100UL), { true, false, false, false, false, true, true, false } }, + { 22, Interval(10, 12UL), Interval(14, 100UL), { true, false, false, false, false, true, false, false } }, + { 23, Interval(10, 13UL), Interval(12, 100UL), { false, true, false, false, false, false, false, false } }, + { 24, Interval(10, 14UL), Interval(12, 100UL), { false, true, false, false, false, false, false, false } }, + { 25, Interval(10, 99UL), Interval(12, 100UL), { false, true, false, false, false, false, false, false } }, + { 26, Interval(10, 100UL), Interval(12, 100UL), { false, true, false, false, false, false, false, true } }, + { 27, Interval(10, 101UL), Interval(12, 100UL), { false, true, false, false, false, false, false, true } }, + { 28, Interval(10, 1000UL), Interval(12, 100UL), { false, true, false, false, false, false, false, true } }, + + // First and second start equal. End varies. + { 30, Interval(12, 12UL), Interval(12, 100UL), { false, true, false, false, false, false, false, false } }, + { 31, Interval(12, 12UL), Interval(13, 100UL), { true, false, false, false, false, true, true, false } }, + { 32, Interval(12, 12UL), Interval(14, 100UL), { true, false, false, false, false, true, false, false } }, + { 33, Interval(12, 13UL), Interval(12, 100UL), { false, true, false, false, false, false, false, false } }, + { 34, Interval(12, 14UL), Interval(12, 100UL), { false, true, false, false, false, false, false, false } }, + { 35, Interval(12, 99UL), Interval(12, 100UL), { false, true, false, false, false, false, false, false } }, + { 36, Interval(12, 100UL), Interval(12, 100UL), { false, true, false, false, false, false, false, true } }, + { 37, Interval(12, 101UL), Interval(12, 100UL), { false, true, false, false, false, false, false, true } }, + { 38, Interval(12, 1000UL), Interval(12, 100UL), { false, true, false, false, false, false, false, true } }, + + // First starts after second. End varies. + { 40, Interval(15, 12UL), Interval(12, 100UL), { false, false, true, false, true, false, false, false } }, + { 41, Interval(15, 12UL), Interval(13, 100UL), { false, false, true, false, true, false, true, false } }, + { 42, Interval(15, 12UL), Interval(14, 100UL), { false, false, true, false, true, false, false, false } }, + { 43, Interval(15, 13UL), Interval(12, 100UL), { false, false, true, false, true, false, false, false } }, + { 44, Interval(15, 14UL), Interval(12, 100UL), { false, false, true, false, true, false, false, false } }, + { 45, Interval(15, 99UL), Interval(12, 100UL), { false, false, true, false, true, false, false, false } }, + { 46, Interval(15, 100UL), Interval(12, 100UL), { false, false, true, false, true, false, false, false } }, + { 47, Interval(15, 101UL), Interval(12, 100UL), { false, false, true, false, true, false, false, false } }, + { 48, Interval(15, 1000UL), Interval(12, 100UL), { false, false, true, false, true, false, false, false } }, + + // First ends before second. Start varies. + { 50, Interval(10, 90UL), Interval(20, 100UL), { false, true, false, false, false, false, false, false } }, + { 51, Interval(19, 90UL), Interval(20, 100UL), { false, true, false, false, false, false, false, false } }, + { 52, Interval(20, 90UL), Interval(20, 100UL), { false, true, false, false, false, false, false, false } }, + { 53, Interval(21, 90UL), Interval(20, 100UL), { false, false, true, false, true, false, false, false } }, + { 54, Interval(98, 90UL), Interval(20, 100UL), { false, false, true, false, true, false, false, false } }, + { 55, Interval(99, 90UL), Interval(20, 100UL), { false, false, true, false, true, false, false, false } }, + { 56, Interval(100, 90UL), Interval(20, 100UL), { false, false, true, false, true, false, false, false } }, + { 57, Interval(101, 90UL), Interval(20, 100UL), { false, false, true, true, false, true, true, false } }, + { 58, Interval(1000, 90UL), Interval(20, 100UL), { false, false, true, true, false, true, false, false } }, + + // First and second end equal. Start varies. + { 60, Interval(10, 100UL), Interval(20, 100UL), { false, true, false, false, false, false, false, true } }, + { 61, Interval(19, 100UL), Interval(20, 100UL), { false, true, false, false, false, false, false, true } }, + { 62, Interval(20, 100UL), Interval(20, 100UL), { false, true, false, false, false, false, false, true } }, + { 63, Interval(21, 100UL), Interval(20, 100UL), { false, false, true, false, true, false, false, false } }, + { 64, Interval(98, 100UL), Interval(20, 100UL), { false, false, true, false, true, false, false, false } }, + { 65, Interval(99, 100UL), Interval(20, 100UL), { false, false, true, false, true, false, false, false } }, + { 66, Interval(100, 100UL), Interval(20, 100UL), { false, false, true, false, true, false, false, false } }, + { 67, Interval(101, 100UL), Interval(20, 100UL), { false, false, true, true, false, true, true, false } }, + { 68, Interval(1000, 100UL), Interval(20, 100UL), { false, false, true, true, false, true, false, false } }, + + // First ends after second. Start varies. + { 70, Interval(10, 1000UL), Interval(20, 100UL), { false, true, false, false, false, false, false, true } }, + { 71, Interval(19, 1000UL), Interval(20, 100UL), { false, true, false, false, false, false, false, true } }, + { 72, Interval(20, 1000UL), Interval(20, 100UL), { false, true, false, false, false, false, false, true } }, + { 73, Interval(21, 1000UL), Interval(20, 100UL), { false, false, true, false, true, false, false, false } }, + { 74, Interval(98, 1000UL), Interval(20, 100UL), { false, false, true, false, true, false, false, false } }, + { 75, Interval(99, 1000UL), Interval(20, 100UL), { false, false, true, false, true, false, false, false } }, + { 76, Interval(100, 1000UL), Interval(20, 100UL), { false, false, true, false, true, false, false, false } }, + { 77, Interval(101, 1000UL), Interval(20, 100UL), { false, false, true, true, false, true, true, false } }, + { 78, Interval(1000, 1000UL), Interval(20, 100UL), { false, false, true, true, false, true, false, false } }, + + // It's possible to add more tests with borders that touch each other (e.g. first starts before/on/after second + // and first ends directly before/after second. However, such cases are not handled differently in the Interval + // class + // (only adjacent intervals, where first ends directly before second starts and vice versa. So I ommitted them here. + }; + + for (auto &entry : testData) { + XCTAssert(entry.interval1.startsBeforeDisjoint(entry.interval2) == entry.results[0], @"entry: %zu", + entry.runningNumber); + XCTAssert(entry.interval1.startsBeforeNonDisjoint(entry.interval2) == entry.results[1], @"entry: %zu", + entry.runningNumber); + XCTAssert(entry.interval1.startsAfter(entry.interval2) == entry.results[2], @"entry: %zu", entry.runningNumber); + XCTAssert(entry.interval1.startsAfterDisjoint(entry.interval2) == entry.results[3], @"entry: %zu", + entry.runningNumber); + XCTAssert(entry.interval1.startsAfterNonDisjoint(entry.interval2) == entry.results[4], @"entry: %zu", + entry.runningNumber); + XCTAssert(entry.interval1.disjoint(entry.interval2) == entry.results[5], @"entry: %zu", entry.runningNumber); + XCTAssert(entry.interval1.adjacent(entry.interval2) == entry.results[6], @"entry: %zu", entry.runningNumber); + XCTAssert(entry.interval1.properlyContains(entry.interval2) == entry.results[7], @"entry: %zu", + entry.runningNumber); + } + + XCTAssert(Interval().Union(Interval(10, 100UL)) == Interval(-1L, 100)); + XCTAssert(Interval(10, 10UL).Union(Interval(10, 100UL)) == Interval(10, 100UL)); + XCTAssert(Interval(10, 11UL).Union(Interval(10, 100UL)) == Interval(10, 100UL)); + XCTAssert(Interval(10, 1000UL).Union(Interval(10, 100UL)) == Interval(10, 1000UL)); + XCTAssert(Interval(1000, 30UL).Union(Interval(10, 100UL)) == Interval(10, 100UL)); + XCTAssert(Interval(1000, 2000UL).Union(Interval(10, 100UL)) == Interval(10, 2000UL)); + XCTAssert(Interval(500, 2000UL).Union(Interval(10, 1000UL)) == Interval(10, 2000UL)); + + XCTAssert(Interval().intersection(Interval(10, 100UL)) == Interval(10, -2L)); + XCTAssert(Interval(10, 10UL).intersection(Interval(10, 100UL)) == Interval(10, 10UL)); + XCTAssert(Interval(10, 11UL).intersection(Interval(10, 100UL)) == Interval(10, 11UL)); + XCTAssert(Interval(10, 1000UL).intersection(Interval(10, 100UL)) == Interval(10, 100UL)); + XCTAssert(Interval(1000, 30UL).intersection(Interval(10, 100UL)) == Interval(1000, 30UL)); + XCTAssert(Interval(1000, 2000UL).intersection(Interval(10, 100UL)) == Interval(1000, 100UL)); + XCTAssert(Interval(500, 2000UL).intersection(Interval(10, 1000UL)) == Interval(500, 1000UL)); + + XCTAssert(Interval().toString() == "-1..-2"); + XCTAssert(Interval(10, 10UL).toString() == "10..10"); + XCTAssert(Interval(1000, 2000UL).toString() == "1000..2000"); + XCTAssert(Interval(500UL, INT_MAX).toString() == "500.." + std::to_string(INT_MAX)); +} + +- (void)testIntervalSet { + XCTAssertFalse(IntervalSet().isReadOnly()); + XCTAssert(IntervalSet().isEmpty()); + + IntervalSet set1; + set1.setReadOnly(true); + XCTAssert(set1.isReadOnly()); + + XCTAssert(IntervalSet() == IntervalSet::EMPTY_SET); + + std::vector intervals = { Interval(), Interval(10, 20UL), Interval(20, 100UL), Interval(1000, 2000UL) }; + IntervalSet set2(intervals); + XCTAssertFalse(set2.isEmpty()); + XCTAssertFalse(set2.contains(9UL)); + XCTAssert(set2.contains(10UL)); + XCTAssert(set2.contains(20UL)); + XCTAssertTrue(set2.contains(22UL)); + XCTAssert(set2.contains(1111UL)); + XCTAssertFalse(set2.contains(10000UL)); + XCTAssertEqual(set2.getSingleElement(), Token::INVALID_TYPE); + XCTAssertEqual(set2.getMinElement(), -1); + XCTAssertEqual(set2.getMaxElement(), 2000); + + IntervalSet set3(set2); + XCTAssertFalse(set3.isEmpty()); + XCTAssertFalse(set3.contains(9UL)); + XCTAssert(set3.contains(10UL)); + XCTAssert(set3.contains(20UL)); + XCTAssertTrue(set3.contains(22UL)); + XCTAssert(set3.contains(1111UL)); + XCTAssertFalse(set3.contains(10000UL)); + XCTAssertEqual(set3.getSingleElement(), Token::INVALID_TYPE); + XCTAssertEqual(set3.getMinElement(), 10); + XCTAssertEqual(set3.getMaxElement(), 2000); + + set3.add(Interval(100, 1000UL)); + XCTAssertEqual(set3.getMinElement(), 10); + set3.add(Interval(9, 1000UL)); + XCTAssertEqual(set3.getMinElement(), 9); + set3.add(Interval(1, 1UL)); + XCTAssertEqual(set3.getMinElement(), 1); + + IntervalSet set4; + set4.add(10); + XCTAssertEqual(set4.getSingleElement(), 10); + XCTAssertEqual(set4.getMinElement(), 10); + XCTAssertEqual(set4.getMaxElement(), 10); + + set4.clear(); + XCTAssert(set4.isEmpty()); + set4.add(Interval(10, 10UL)); + XCTAssertEqual(set4.getSingleElement(), 10); + XCTAssertEqual(set4.getMinElement(), 10); + XCTAssertEqual(set4.getMaxElement(), 10); + set4.setReadOnly(true); + try { + set4.clear(); + XCTFail(@"Expected exception"); + } catch (IllegalStateException &e) { + } + + try { + set4.setReadOnly(false); + XCTFail(@"Expected exception"); + } catch (IllegalStateException &e) { + } + + try { + set4 = IntervalSet::of(12345); + XCTFail(@"Expected exception"); + } catch (IllegalStateException &e) { + } + + IntervalSet set5 = IntervalSet::of(12345); + XCTAssertEqual(set5.getSingleElement(), 12345); + XCTAssertEqual(set5.getMinElement(), 12345); + XCTAssertEqual(set5.getMaxElement(), 12345); + + IntervalSet set6(10, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50); + XCTAssertEqual(set6.getMinElement(), 5); + XCTAssertEqual(set6.getMaxElement(), 50); + XCTAssertEqual(set6.size(), 10U); + set6.add(12, 18); + XCTAssertEqual(set6.size(), 16U); // (15, 15) replaced by (12, 18) + set6.add(9, 33); + XCTAssertEqual(set6.size(), 30U); // (10, 10), (12, 18), (20, 20), (25, 25) and (30, 30) replaced by (9, 33) + + XCTAssert(IntervalSet(3, 1, 2, 10).Or(IntervalSet(3, 1, 2, 5)) == IntervalSet(4, 1, 2, 5, 10)); + XCTAssert(IntervalSet({ Interval(2, 10UL) }).Or(IntervalSet({ Interval(5, 8UL) })) == IntervalSet({ Interval(2, 10UL) })); + + XCTAssert(IntervalSet::of(1, 10).complement(IntervalSet::of(7, 55)) == IntervalSet::of(11, 55)); + XCTAssert(IntervalSet::of(1, 10).complement(IntervalSet::of(20, 55)) == IntervalSet::of(20, 55)); + XCTAssert(IntervalSet::of(1, 10).complement(IntervalSet::of(5, 6)) == IntervalSet::EMPTY_SET); + XCTAssert(IntervalSet::of(15, 20).complement(IntervalSet::of(7, 55)) == + IntervalSet({ Interval(7, 14UL), Interval(21, 55UL) })); + XCTAssert(IntervalSet({ Interval(1, 10UL), Interval(30, 35UL) }).complement(IntervalSet::of(7, 55)) == + IntervalSet({ Interval(11, 29UL), Interval(36, 55UL) })); + + XCTAssert(IntervalSet::of(1, 10).And(IntervalSet::of(7, 55)) == IntervalSet::of(7, 10)); + XCTAssert(IntervalSet::of(1, 10).And(IntervalSet::of(20, 55)) == IntervalSet::EMPTY_SET); + XCTAssert(IntervalSet::of(1, 10).And(IntervalSet::of(5, 6)) == IntervalSet::of(5, 6)); + XCTAssert(IntervalSet::of(15, 20).And(IntervalSet::of(7, 55)) == IntervalSet::of(15, 20)); + + XCTAssert(IntervalSet::of(1, 10).subtract(IntervalSet::of(7, 55)) == IntervalSet::of(1, 6)); + XCTAssert(IntervalSet::of(1, 10).subtract(IntervalSet::of(20, 55)) == IntervalSet::of(1, 10)); + XCTAssert(IntervalSet::of(1, 10).subtract(IntervalSet::of(5, 6)) == + IntervalSet({ Interval(1, 4UL), Interval(7, 10UL) })); + XCTAssert(IntervalSet::of(15, 20).subtract(IntervalSet::of(7, 55)) == IntervalSet::EMPTY_SET); +} + +@end diff --git a/antlr/antlr4-runtime/demo/Mac/antlrcpp Tests/antlrcpp_Tests.mm b/antlr/antlr4-runtime/demo/Mac/antlrcpp Tests/antlrcpp_Tests.mm new file mode 100644 index 0000000..b4c5240 --- /dev/null +++ b/antlr/antlr4-runtime/demo/Mac/antlrcpp Tests/antlrcpp_Tests.mm @@ -0,0 +1,57 @@ +/* + * [The "BSD license"] + * Copyright (c) 2015 Dan McLaughlin + * 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. + */ + +#import +#import + +#include "ParserATNSimulator.h" +#include "DFA.h" +#include "ATN.h" + +#include + +using namespace antlr4; + +@interface antlrcpp_Tests : XCTestCase + +@end + +@implementation antlrcpp_Tests + +- (void)setUp { + [super setUp]; + // Put setup code here. This method is called before the invocation of each test method in the class. +} + +- (void)tearDown { + // Put teardown code here. This method is called after the invocation of each test method in the class. + [super tearDown]; +} + +@end diff --git a/antlr/antlr4-runtime/demo/Mac/antlrcpp-demo.xcodeproj/project.pbxproj b/antlr/antlr4-runtime/demo/Mac/antlrcpp-demo.xcodeproj/project.pbxproj new file mode 100644 index 0000000..5f136b0 --- /dev/null +++ b/antlr/antlr4-runtime/demo/Mac/antlrcpp-demo.xcodeproj/project.pbxproj @@ -0,0 +1,609 @@ +// !$*UTF8*$! +{ + archiveVersion = 1; + classes = { + }; + objectVersion = 46; + objects = { + +/* Begin PBXBuildFile section */ + 270925AC1CDB427200522D32 /* libantlr4-runtime.dylib in Frameworks */ = {isa = PBXBuildFile; fileRef = 270925A71CDB409400522D32 /* libantlr4-runtime.dylib */; }; + 270925AF1CDB428A00522D32 /* libantlr4-runtime.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 270925A91CDB409400522D32 /* libantlr4-runtime.a */; }; + 270925B11CDB455B00522D32 /* TLexer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 27A23EA11CC2A8D60036D8A3 /* TLexer.cpp */; }; + 2747A7131CA6C46C0030247B /* InputHandlingTests.mm in Sources */ = {isa = PBXBuildFile; fileRef = 2747A7121CA6C46C0030247B /* InputHandlingTests.mm */; }; + 274FC6D91CA96B6C008D4374 /* MiscClassTests.mm in Sources */ = {isa = PBXBuildFile; fileRef = 274FC6D81CA96B6C008D4374 /* MiscClassTests.mm */; }; + 27C66A6A1C9591280021E494 /* main.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 27C66A691C9591280021E494 /* main.cpp */; }; + 27C6E1801C972FFC0079AF06 /* TParser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 27C6E1741C972FFC0079AF06 /* TParser.cpp */; }; + 27C6E1811C972FFC0079AF06 /* TParserBaseListener.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 27C6E1771C972FFC0079AF06 /* TParserBaseListener.cpp */; }; + 27C6E1821C972FFC0079AF06 /* TParserBaseVisitor.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 27C6E1791C972FFC0079AF06 /* TParserBaseVisitor.cpp */; }; + 27C6E1831C972FFC0079AF06 /* TParserListener.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 27C6E17B1C972FFC0079AF06 /* TParserListener.cpp */; }; + 27C6E1841C972FFC0079AF06 /* TParserVisitor.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 27C6E17D1C972FFC0079AF06 /* TParserVisitor.cpp */; }; + 37F1356D1B4AC02800E0CACF /* antlrcpp_Tests.mm in Sources */ = {isa = PBXBuildFile; fileRef = 37F1356C1B4AC02800E0CACF /* antlrcpp_Tests.mm */; }; +/* End PBXBuildFile section */ + +/* Begin PBXContainerItemProxy section */ + 270925A61CDB409400522D32 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 270925A11CDB409400522D32 /* antlrcpp.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = 37D727AA1867AF1E007B6D10; + remoteInfo = antlrcpp; + }; + 270925A81CDB409400522D32 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 270925A11CDB409400522D32 /* antlrcpp.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = 37C147171B4D5A04008EDDDB; + remoteInfo = antlrcpp_static; + }; + 270925AA1CDB426900522D32 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 270925A11CDB409400522D32 /* antlrcpp.xcodeproj */; + proxyType = 1; + remoteGlobalIDString = 37D727A91867AF1E007B6D10; + remoteInfo = antlrcpp; + }; + 270925AD1CDB428400522D32 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 270925A11CDB409400522D32 /* antlrcpp.xcodeproj */; + proxyType = 1; + remoteGlobalIDString = 37C147161B4D5A04008EDDDB; + remoteInfo = antlrcpp_static; + }; + 273DC2BC1CDB619900DB7B2B /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 270925A11CDB409400522D32 /* antlrcpp.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = 270C67F01CDB4F1E00116E17; + remoteInfo = antlrcpp_ios; + }; +/* End PBXContainerItemProxy section */ + +/* Begin PBXCopyFilesBuildPhase section */ + 27C66A651C9591280021E494 /* CopyFiles */ = { + isa = PBXCopyFilesBuildPhase; + buildActionMask = 2147483647; + dstPath = /usr/share/man/man1/; + dstSubfolderSpec = 0; + files = ( + ); + runOnlyForDeploymentPostprocessing = 1; + }; +/* End PBXCopyFilesBuildPhase section */ + +/* Begin PBXFileReference section */ + 270925A11CDB409400522D32 /* antlrcpp.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = antlrcpp.xcodeproj; path = ../../runtime/antlrcpp.xcodeproj; sourceTree = ""; }; + 2747A7121CA6C46C0030247B /* InputHandlingTests.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = InputHandlingTests.mm; sourceTree = ""; wrapsLines = 0; }; + 274FC6D81CA96B6C008D4374 /* MiscClassTests.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = MiscClassTests.mm; sourceTree = ""; wrapsLines = 0; }; + 27874F1D1CCB7A0700AF1C53 /* CoreFoundation.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreFoundation.framework; path = System/Library/Frameworks/CoreFoundation.framework; sourceTree = SDKROOT; }; + 27A23EA11CC2A8D60036D8A3 /* TLexer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = TLexer.cpp; path = ../generated/TLexer.cpp; sourceTree = ""; wrapsLines = 0; }; + 27A23EA21CC2A8D60036D8A3 /* TLexer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = TLexer.h; path = ../generated/TLexer.h; sourceTree = ""; }; + 27C66A671C9591280021E494 /* antlr4-cpp-demo */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = "antlr4-cpp-demo"; sourceTree = BUILT_PRODUCTS_DIR; }; + 27C66A691C9591280021E494 /* main.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = main.cpp; sourceTree = ""; wrapsLines = 0; }; + 27C66A731C9592400021E494 /* TLexer.g4 */ = {isa = PBXFileReference; lastKnownFileType = text; name = TLexer.g4; path = ../../TLexer.g4; sourceTree = ""; }; + 27C66A741C9592400021E494 /* TParser.g4 */ = {isa = PBXFileReference; lastKnownFileType = text; name = TParser.g4; path = ../../TParser.g4; sourceTree = ""; }; + 27C6E1741C972FFC0079AF06 /* TParser.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = TParser.cpp; path = ../generated/TParser.cpp; sourceTree = ""; wrapsLines = 0; }; + 27C6E1751C972FFC0079AF06 /* TParser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = TParser.h; path = ../generated/TParser.h; sourceTree = ""; wrapsLines = 0; }; + 27C6E1771C972FFC0079AF06 /* TParserBaseListener.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = TParserBaseListener.cpp; path = ../generated/TParserBaseListener.cpp; sourceTree = ""; }; + 27C6E1781C972FFC0079AF06 /* TParserBaseListener.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = TParserBaseListener.h; path = ../generated/TParserBaseListener.h; sourceTree = ""; }; + 27C6E1791C972FFC0079AF06 /* TParserBaseVisitor.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = TParserBaseVisitor.cpp; path = ../generated/TParserBaseVisitor.cpp; sourceTree = ""; }; + 27C6E17B1C972FFC0079AF06 /* TParserListener.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = TParserListener.cpp; path = ../generated/TParserListener.cpp; sourceTree = ""; }; + 27C6E17C1C972FFC0079AF06 /* TParserListener.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = TParserListener.h; path = ../generated/TParserListener.h; sourceTree = ""; }; + 27C6E17D1C972FFC0079AF06 /* TParserVisitor.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = TParserVisitor.cpp; path = ../generated/TParserVisitor.cpp; sourceTree = ""; }; + 27C6E1851C97322F0079AF06 /* TParserBaseVisitor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = TParserBaseVisitor.h; path = ../generated/TParserBaseVisitor.h; sourceTree = ""; wrapsLines = 0; }; + 27C6E1861C97322F0079AF06 /* TParserVisitor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = TParserVisitor.h; path = ../generated/TParserVisitor.h; sourceTree = ""; }; + 37F135681B4AC02800E0CACF /* antlrcpp Tests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = "antlrcpp Tests.xctest"; sourceTree = BUILT_PRODUCTS_DIR; }; + 37F1356B1B4AC02800E0CACF /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = ""; }; + 37F1356C1B4AC02800E0CACF /* antlrcpp_Tests.mm */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.objcpp; path = antlrcpp_Tests.mm; sourceTree = ""; }; +/* End PBXFileReference section */ + +/* Begin PBXFrameworksBuildPhase section */ + 27C66A641C9591280021E494 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + 270925AC1CDB427200522D32 /* libantlr4-runtime.dylib in Frameworks */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 37F135651B4AC02800E0CACF /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + 270925AF1CDB428A00522D32 /* libantlr4-runtime.a in Frameworks */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXFrameworksBuildPhase section */ + +/* Begin PBXGroup section */ + 270925A21CDB409400522D32 /* Products */ = { + isa = PBXGroup; + children = ( + 270925A71CDB409400522D32 /* libantlr4-runtime.dylib */, + 270925A91CDB409400522D32 /* libantlr4-runtime.a */, + 273DC2BD1CDB619900DB7B2B /* antlr4_ios.framework */, + ); + name = Products; + sourceTree = ""; + }; + 27874F221CCBB34200AF1C53 /* Linked Frameworks */ = { + isa = PBXGroup; + children = ( + 27874F1D1CCB7A0700AF1C53 /* CoreFoundation.framework */, + ); + name = "Linked Frameworks"; + sourceTree = ""; + }; + 27C66A5C1C958EB50021E494 /* generated */ = { + isa = PBXGroup; + children = ( + 27A23EA11CC2A8D60036D8A3 /* TLexer.cpp */, + 27A23EA21CC2A8D60036D8A3 /* TLexer.h */, + 27C6E1741C972FFC0079AF06 /* TParser.cpp */, + 27C6E1751C972FFC0079AF06 /* TParser.h */, + 27C6E1771C972FFC0079AF06 /* TParserBaseListener.cpp */, + 27C6E1781C972FFC0079AF06 /* TParserBaseListener.h */, + 27C6E1791C972FFC0079AF06 /* TParserBaseVisitor.cpp */, + 27C6E1851C97322F0079AF06 /* TParserBaseVisitor.h */, + 27C6E17B1C972FFC0079AF06 /* TParserListener.cpp */, + 27C6E17C1C972FFC0079AF06 /* TParserListener.h */, + 27C6E17D1C972FFC0079AF06 /* TParserVisitor.cpp */, + 27C6E1861C97322F0079AF06 /* TParserVisitor.h */, + ); + name = generated; + sourceTree = ""; + }; + 27C66A681C9591280021E494 /* antlr4-cpp-demo */ = { + isa = PBXGroup; + children = ( + 27C66A691C9591280021E494 /* main.cpp */, + 27C66A731C9592400021E494 /* TLexer.g4 */, + 27C66A741C9592400021E494 /* TParser.g4 */, + ); + path = "antlr4-cpp-demo"; + sourceTree = ""; + }; + 37D727A11867AF1E007B6D10 = { + isa = PBXGroup; + children = ( + 270925A11CDB409400522D32 /* antlrcpp.xcodeproj */, + 27C66A681C9591280021E494 /* antlr4-cpp-demo */, + 37F135691B4AC02800E0CACF /* antlrcpp Tests */, + 27C66A5C1C958EB50021E494 /* generated */, + 27874F221CCBB34200AF1C53 /* Linked Frameworks */, + 37D727AB1867AF1E007B6D10 /* Products */, + ); + sourceTree = ""; + }; + 37D727AB1867AF1E007B6D10 /* Products */ = { + isa = PBXGroup; + children = ( + 37F135681B4AC02800E0CACF /* antlrcpp Tests.xctest */, + 27C66A671C9591280021E494 /* antlr4-cpp-demo */, + ); + name = Products; + sourceTree = ""; + }; + 37F135691B4AC02800E0CACF /* antlrcpp Tests */ = { + isa = PBXGroup; + children = ( + 37F1356A1B4AC02800E0CACF /* Supporting Files */, + 37F1356C1B4AC02800E0CACF /* antlrcpp_Tests.mm */, + 2747A7121CA6C46C0030247B /* InputHandlingTests.mm */, + 274FC6D81CA96B6C008D4374 /* MiscClassTests.mm */, + ); + path = "antlrcpp Tests"; + sourceTree = ""; + }; + 37F1356A1B4AC02800E0CACF /* Supporting Files */ = { + isa = PBXGroup; + children = ( + 37F1356B1B4AC02800E0CACF /* Info.plist */, + ); + name = "Supporting Files"; + sourceTree = ""; + }; +/* End PBXGroup section */ + +/* Begin PBXNativeTarget section */ + 27C66A661C9591280021E494 /* antlr4-cpp-demo */ = { + isa = PBXNativeTarget; + buildConfigurationList = 27C66A6B1C9591280021E494 /* Build configuration list for PBXNativeTarget "antlr4-cpp-demo" */; + buildPhases = ( + 27C66A721C9591EF0021E494 /* Generate Parser */, + 27C66A631C9591280021E494 /* Sources */, + 27C66A641C9591280021E494 /* Frameworks */, + 27C66A651C9591280021E494 /* CopyFiles */, + ); + buildRules = ( + ); + dependencies = ( + 270925AB1CDB426900522D32 /* PBXTargetDependency */, + ); + name = "antlr4-cpp-demo"; + productName = "antlr4-cpp-demo"; + productReference = 27C66A671C9591280021E494 /* antlr4-cpp-demo */; + productType = "com.apple.product-type.tool"; + }; + 37F135671B4AC02800E0CACF /* antlrcpp Tests */ = { + isa = PBXNativeTarget; + buildConfigurationList = 37F135731B4AC02800E0CACF /* Build configuration list for PBXNativeTarget "antlrcpp Tests" */; + buildPhases = ( + 37F135641B4AC02800E0CACF /* Sources */, + 37F135651B4AC02800E0CACF /* Frameworks */, + 37F135661B4AC02800E0CACF /* Resources */, + ); + buildRules = ( + ); + dependencies = ( + 270925AE1CDB428400522D32 /* PBXTargetDependency */, + ); + name = "antlrcpp Tests"; + productName = "antlrcpp Tests"; + productReference = 37F135681B4AC02800E0CACF /* antlrcpp Tests.xctest */; + productType = "com.apple.product-type.bundle.unit-test"; + }; +/* End PBXNativeTarget section */ + +/* Begin PBXProject section */ + 37D727A21867AF1E007B6D10 /* Project object */ = { + isa = PBXProject; + attributes = { + LastUpgradeCheck = 1010; + ORGANIZATIONNAME = "ANTLR4 Project"; + TargetAttributes = { + 27C66A661C9591280021E494 = { + CreatedOnToolsVersion = 7.2.1; + }; + 37F135671B4AC02800E0CACF = { + CreatedOnToolsVersion = 6.3.2; + }; + }; + }; + buildConfigurationList = 37D727A51867AF1E007B6D10 /* Build configuration list for PBXProject "antlrcpp-demo" */; + compatibilityVersion = "Xcode 3.2"; + developmentRegion = English; + hasScannedForEncodings = 0; + knownRegions = ( + en, + ); + mainGroup = 37D727A11867AF1E007B6D10; + productRefGroup = 37D727AB1867AF1E007B6D10 /* Products */; + projectDirPath = ""; + projectReferences = ( + { + ProductGroup = 270925A21CDB409400522D32 /* Products */; + ProjectRef = 270925A11CDB409400522D32 /* antlrcpp.xcodeproj */; + }, + ); + projectRoot = ""; + targets = ( + 37F135671B4AC02800E0CACF /* antlrcpp Tests */, + 27C66A661C9591280021E494 /* antlr4-cpp-demo */, + ); + }; +/* End PBXProject section */ + +/* Begin PBXReferenceProxy section */ + 270925A71CDB409400522D32 /* libantlr4-runtime.dylib */ = { + isa = PBXReferenceProxy; + fileType = "compiled.mach-o.dylib"; + path = "libantlr4-runtime.dylib"; + remoteRef = 270925A61CDB409400522D32 /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 270925A91CDB409400522D32 /* libantlr4-runtime.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = "libantlr4-runtime.a"; + remoteRef = 270925A81CDB409400522D32 /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 273DC2BD1CDB619900DB7B2B /* antlr4_ios.framework */ = { + isa = PBXReferenceProxy; + fileType = wrapper.framework; + path = antlr4_ios.framework; + remoteRef = 273DC2BC1CDB619900DB7B2B /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; +/* End PBXReferenceProxy section */ + +/* Begin PBXResourcesBuildPhase section */ + 37F135661B4AC02800E0CACF /* Resources */ = { + isa = PBXResourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXResourcesBuildPhase section */ + +/* Begin PBXShellScriptBuildPhase section */ + 27C66A721C9591EF0021E494 /* Generate Parser */ = { + isa = PBXShellScriptBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + inputPaths = ( + ); + name = "Generate Parser"; + outputPaths = ( + ); + runOnlyForDeploymentPostprocessing = 0; + shellPath = /bin/sh; + shellScript = "pushd ..\nif [ TParser.g4 -nt generated/TParser.cpp -o TLexer.g4 -nt generated/TLexer.cpp ]; then\n./generate.sh;\nfi\npopd\n"; + showEnvVarsInLog = 0; + }; +/* End PBXShellScriptBuildPhase section */ + +/* Begin PBXSourcesBuildPhase section */ + 27C66A631C9591280021E494 /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 27C66A6A1C9591280021E494 /* main.cpp in Sources */, + 27C6E1821C972FFC0079AF06 /* TParserBaseVisitor.cpp in Sources */, + 270925B11CDB455B00522D32 /* TLexer.cpp in Sources */, + 27C6E1831C972FFC0079AF06 /* TParserListener.cpp in Sources */, + 27C6E1811C972FFC0079AF06 /* TParserBaseListener.cpp in Sources */, + 27C6E1841C972FFC0079AF06 /* TParserVisitor.cpp in Sources */, + 27C6E1801C972FFC0079AF06 /* TParser.cpp in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 37F135641B4AC02800E0CACF /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 37F1356D1B4AC02800E0CACF /* antlrcpp_Tests.mm in Sources */, + 2747A7131CA6C46C0030247B /* InputHandlingTests.mm in Sources */, + 274FC6D91CA96B6C008D4374 /* MiscClassTests.mm in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXSourcesBuildPhase section */ + +/* Begin PBXTargetDependency section */ + 270925AB1CDB426900522D32 /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + name = antlrcpp; + targetProxy = 270925AA1CDB426900522D32 /* PBXContainerItemProxy */; + }; + 270925AE1CDB428400522D32 /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + name = antlrcpp_static; + targetProxy = 270925AD1CDB428400522D32 /* PBXContainerItemProxy */; + }; +/* End PBXTargetDependency section */ + +/* Begin XCBuildConfiguration section */ + 27C66A6C1C9591280021E494 /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + CLANG_ENABLE_MODULES = YES; + CLANG_WARN_UNREACHABLE_CODE = YES; + CODE_SIGN_IDENTITY = "-"; + DEBUG_INFORMATION_FORMAT = dwarf; + ENABLE_STRICT_OBJC_MSGSEND = YES; + GCC_NO_COMMON_BLOCKS = YES; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + MTL_ENABLE_DEBUG_INFO = YES; + PRODUCT_NAME = "$(TARGET_NAME)"; + }; + name = Debug; + }; + 27C66A6D1C9591280021E494 /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + CLANG_ENABLE_MODULES = YES; + CLANG_WARN_UNREACHABLE_CODE = YES; + CODE_SIGN_IDENTITY = "-"; + COPY_PHASE_STRIP = NO; + ENABLE_STRICT_OBJC_MSGSEND = YES; + GCC_NO_COMMON_BLOCKS = YES; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + MTL_ENABLE_DEBUG_INFO = NO; + PRODUCT_NAME = "$(TARGET_NAME)"; + }; + name = Release; + }; + 37D727B51867AF1E007B6D10 /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; + CLANG_CXX_LIBRARY = "libc++"; + CLANG_ENABLE_OBJC_ARC = YES; + CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_COMMA = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INFINITE_RECURSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES; + CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES; + CLANG_WARN_OBJC_LITERAL_CONVERSION = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN_RANGE_LOOP_ANALYSIS = YES; + CLANG_WARN_STRICT_PROTOTYPES = YES; + CLANG_WARN_SUSPICIOUS_MOVE = YES; + CLANG_WARN_UNREACHABLE_CODE = YES; + CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; + COPY_PHASE_STRIP = NO; + ENABLE_STRICT_OBJC_MSGSEND = YES; + ENABLE_TESTABILITY = YES; + GCC_C_LANGUAGE_STANDARD = gnu99; + GCC_DYNAMIC_NO_PIC = NO; + GCC_ENABLE_OBJC_EXCEPTIONS = YES; + GCC_NO_COMMON_BLOCKS = YES; + GCC_OPTIMIZATION_LEVEL = 0; + GCC_PREPROCESSOR_DEFINITIONS = ( + "DEBUG=1", + "$(inherited)", + ); + GCC_SYMBOLS_PRIVATE_EXTERN = NO; + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_SIGN_COMPARE = YES; + GCC_WARN_UNDECLARED_SELECTOR = YES; + GCC_WARN_UNINITIALIZED_AUTOS = YES; + GCC_WARN_UNUSED_FUNCTION = YES; + GCC_WARN_UNUSED_PARAMETER = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + HEADER_SEARCH_PATHS = ( + ../../runtime/src/tree/pattern, + ../../runtime/src/tree, + ../../runtime/src/support, + ../../runtime/src/misc, + ../../runtime/src/dfa, + ../../runtime/src/atn, + ../../runtime/src, + ); + MACOSX_DEPLOYMENT_TARGET = 10.9; + ONLY_ACTIVE_ARCH = YES; + SDKROOT = macosx; + }; + name = Debug; + }; + 37D727B61867AF1E007B6D10 /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; + CLANG_CXX_LIBRARY = "libc++"; + CLANG_ENABLE_OBJC_ARC = YES; + CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_COMMA = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INFINITE_RECURSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES; + CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES; + CLANG_WARN_OBJC_LITERAL_CONVERSION = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN_RANGE_LOOP_ANALYSIS = YES; + CLANG_WARN_STRICT_PROTOTYPES = YES; + CLANG_WARN_SUSPICIOUS_MOVE = YES; + CLANG_WARN_UNREACHABLE_CODE = YES; + CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; + COPY_PHASE_STRIP = YES; + DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; + ENABLE_NS_ASSERTIONS = NO; + ENABLE_STRICT_OBJC_MSGSEND = YES; + GCC_C_LANGUAGE_STANDARD = gnu99; + GCC_ENABLE_OBJC_EXCEPTIONS = YES; + GCC_NO_COMMON_BLOCKS = YES; + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_SIGN_COMPARE = YES; + GCC_WARN_UNDECLARED_SELECTOR = YES; + GCC_WARN_UNINITIALIZED_AUTOS = YES; + GCC_WARN_UNUSED_FUNCTION = YES; + GCC_WARN_UNUSED_PARAMETER = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + HEADER_SEARCH_PATHS = ( + ../../runtime/src/tree/pattern, + ../../runtime/src/tree, + ../../runtime/src/support, + ../../runtime/src/misc, + ../../runtime/src/dfa, + ../../runtime/src/atn, + ../../runtime/src, + ); + MACOSX_DEPLOYMENT_TARGET = 10.9; + SDKROOT = macosx; + }; + name = Release; + }; + 37F135711B4AC02800E0CACF /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + CLANG_ENABLE_MODULES = YES; + CLANG_WARN_UNREACHABLE_CODE = YES; + COMBINE_HIDPI_IMAGES = YES; + DEBUG_INFORMATION_FORMAT = dwarf; + ENABLE_STRICT_OBJC_MSGSEND = YES; + FRAMEWORK_SEARCH_PATHS = ( + "$(DEVELOPER_FRAMEWORKS_DIR)", + "$(inherited)", + ); + GCC_NO_COMMON_BLOCKS = YES; + GCC_PREPROCESSOR_DEFINITIONS = ( + "DEBUG=1", + "$(inherited)", + ); + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + INFOPLIST_FILE = "antlrcpp Tests/Info.plist"; + LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/../Frameworks @loader_path/../Frameworks"; + MTL_ENABLE_DEBUG_INFO = YES; + PRODUCT_BUNDLE_IDENTIFIER = "com.antlr.$(PRODUCT_NAME:rfc1034identifier)"; + PRODUCT_NAME = "$(TARGET_NAME)"; + }; + name = Debug; + }; + 37F135721B4AC02800E0CACF /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + CLANG_ENABLE_MODULES = YES; + CLANG_WARN_UNREACHABLE_CODE = YES; + COMBINE_HIDPI_IMAGES = YES; + COPY_PHASE_STRIP = NO; + ENABLE_STRICT_OBJC_MSGSEND = YES; + FRAMEWORK_SEARCH_PATHS = ( + "$(DEVELOPER_FRAMEWORKS_DIR)", + "$(inherited)", + ); + GCC_NO_COMMON_BLOCKS = YES; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + INFOPLIST_FILE = "antlrcpp Tests/Info.plist"; + LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/../Frameworks @loader_path/../Frameworks"; + MTL_ENABLE_DEBUG_INFO = NO; + PRODUCT_BUNDLE_IDENTIFIER = "com.antlr.$(PRODUCT_NAME:rfc1034identifier)"; + PRODUCT_NAME = "$(TARGET_NAME)"; + }; + name = Release; + }; +/* End XCBuildConfiguration section */ + +/* Begin XCConfigurationList section */ + 27C66A6B1C9591280021E494 /* Build configuration list for PBXNativeTarget "antlr4-cpp-demo" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 27C66A6C1C9591280021E494 /* Debug */, + 27C66A6D1C9591280021E494 /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 37D727A51867AF1E007B6D10 /* Build configuration list for PBXProject "antlrcpp-demo" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 37D727B51867AF1E007B6D10 /* Debug */, + 37D727B61867AF1E007B6D10 /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 37F135731B4AC02800E0CACF /* Build configuration list for PBXNativeTarget "antlrcpp Tests" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 37F135711B4AC02800E0CACF /* Debug */, + 37F135721B4AC02800E0CACF /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; +/* End XCConfigurationList section */ + }; + rootObject = 37D727A21867AF1E007B6D10 /* Project object */; +} diff --git a/antlr/antlr4-runtime/demo/Mac/antlrcpp-demo.xcodeproj/project.xcworkspace/contents.xcworkspacedata b/antlr/antlr4-runtime/demo/Mac/antlrcpp-demo.xcodeproj/project.xcworkspace/contents.xcworkspacedata new file mode 100644 index 0000000..919434a --- /dev/null +++ b/antlr/antlr4-runtime/demo/Mac/antlrcpp-demo.xcodeproj/project.xcworkspace/contents.xcworkspacedata @@ -0,0 +1,7 @@ + + + + + diff --git a/antlr/antlr4-runtime/demo/Mac/antlrcpp-demo.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist b/antlr/antlr4-runtime/demo/Mac/antlrcpp-demo.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist new file mode 100644 index 0000000..18d9810 --- /dev/null +++ b/antlr/antlr4-runtime/demo/Mac/antlrcpp-demo.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist @@ -0,0 +1,8 @@ + + + + + IDEDidComputeMac32BitWarning + + + diff --git a/antlr/antlr4-runtime/demo/Mac/antlrcpp-demo.xcodeproj/xcshareddata/xcschemes/antlr4-cpp-demo.xcscheme b/antlr/antlr4-runtime/demo/Mac/antlrcpp-demo.xcodeproj/xcshareddata/xcschemes/antlr4-cpp-demo.xcscheme new file mode 100644 index 0000000..8e3cfa5 --- /dev/null +++ b/antlr/antlr4-runtime/demo/Mac/antlrcpp-demo.xcodeproj/xcshareddata/xcschemes/antlr4-cpp-demo.xcscheme @@ -0,0 +1,102 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/antlr/antlr4-runtime/demo/Mac/antlrcpp-demo.xcodeproj/xcshareddata/xcschemes/antlrcpp Tests.xcscheme b/antlr/antlr4-runtime/demo/Mac/antlrcpp-demo.xcodeproj/xcshareddata/xcschemes/antlrcpp Tests.xcscheme new file mode 100644 index 0000000..8edff66 --- /dev/null +++ b/antlr/antlr4-runtime/demo/Mac/antlrcpp-demo.xcodeproj/xcshareddata/xcschemes/antlrcpp Tests.xcscheme @@ -0,0 +1,56 @@ + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/antlr/antlr4-runtime/demo/Mac/build.sh b/antlr/antlr4-runtime/demo/Mac/build.sh new file mode 100755 index 0000000..ff991f4 --- /dev/null +++ b/antlr/antlr4-runtime/demo/Mac/build.sh @@ -0,0 +1,43 @@ +#!/bin/sh +# [The "BSD license"] +# Copyright (c) 2013 Terence Parr +# Copyright (c) 2013 Dan McLaughlin +# 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. + + +CURRENT_DIR=$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd ) +ANTLRCPP_XCODEPROJ="${CURRENT_DIR}/antlrcpp.xcodeproj" + +# OS X +xcrun xcodebuild -project ${ANTLRCPP_XCODEPROJ} -target antlrcpp -configuration Release $@ +xcrun xcodebuild -project ${ANTLRCPP_XCODEPROJ} -target antlrcpp -configuration Debug $@ + +# iOS +#xcrun xcodebuild -project ${ANTLRCPP_XCODEPROJ} -target antlrcpp_iphone -configuration Release -sdk iphoneos $@ +#xcrun xcodebuild -project ${ANTLRCPP_XCODEPROJ} -target antlrcpp_iphone -configuration Debug -sdk iphoneos $@ +#xcrun xcodebuild -project ${ANTLRCPP_XCODEPROJ} -target antlrcpp_iphone_sim -configuration Release -sdk iphonesimulator $@ +#xcrun xcodebuild -project ${ANTLRCPP_XCODEPROJ} -target antlrcpp_iphone_sim -configuration Debug -sdk iphonesimulator $@ + diff --git a/antlr/antlr4-runtime/demo/README.md b/antlr/antlr4-runtime/demo/README.md new file mode 100644 index 0000000..73f03a4 --- /dev/null +++ b/antlr/antlr4-runtime/demo/README.md @@ -0,0 +1,13 @@ +## Demo application for the ANTLR 4 C++ target + +This demo app shows how to build the ANTLR runtime both as dynamic and static library and how to use a parser generated from a simple demo grammar. + +A few steps are necessary to get this to work: + +- Download the current ANTLR jar and place it in this folder. +- Open the generation script for your platform (generate.cmd for Windows, generate.sh for *nix/OSX) and update the LOCATION var to the actual name of the jar you downloaded. +- Run the generation script. This will generate a test parser + lexer, along with listener + visitor classes in a subfolder named "generated". This is where the demo application looks for these files. +- Open the project in the folder that matches your system. +- Compile and run. + +Compilation is done as described in the [runtime/cpp/readme.md](../README.md) file. diff --git a/antlr/antlr4-runtime/demo/TLexer.g4 b/antlr/antlr4-runtime/demo/TLexer.g4 new file mode 100644 index 0000000..ac2128c --- /dev/null +++ b/antlr/antlr4-runtime/demo/TLexer.g4 @@ -0,0 +1,86 @@ +lexer grammar TLexer; + +// These are all supported lexer sections: + +// Lexer file header. Appears at the top of h + cpp files. Use e.g. for copyrights. +@lexer::header {/* lexer header section */} + +// Appears before any #include in h + cpp files. +@lexer::preinclude {/* lexer precinclude section */} + +// Follows directly after the standard #includes in h + cpp files. +@lexer::postinclude { +/* lexer postinclude section */ +#ifndef _WIN32 +#pragma GCC diagnostic ignored "-Wunused-parameter" +#endif +} + +// Directly preceds the lexer class declaration in the h file (e.g. for additional types etc.). +@lexer::context {/* lexer context section */} + +// Appears in the public part of the lexer in the h file. +@lexer::members {/* public lexer declarations section */ +bool canTestFoo() { return true; } +bool isItFoo() { return true; } +bool isItBar() { return true; } + +void myFooLexerAction() { /* do something*/ }; +void myBarLexerAction() { /* do something*/ }; +} + +// Appears in the private part of the lexer in the h file. +@lexer::declarations {/* private lexer declarations/members section */} + +// Appears in line with the other class member definitions in the cpp file. +@lexer::definitions {/* lexer definitions section */} + +channels { CommentsChannel, DirectiveChannel } + +tokens { + DUMMY +} + +Return: 'return'; +Continue: 'continue'; + +INT: Digit+; +Digit: [0-9]; + +ID: LETTER (LETTER | '0'..'9')*; +fragment LETTER : [a-zA-Z\u0080-\u{10FFFF}]; + +LessThan: '<'; +GreaterThan: '>'; +Equal: '='; +And: 'and'; + +Colon: ':'; +Semicolon: ';'; +Plus: '+'; +Minus: '-'; +Star: '*'; +OpenPar: '('; +ClosePar: ')'; +OpenCurly: '{' -> pushMode(Mode1); +CloseCurly: '}' -> popMode; +QuestionMark: '?'; +Comma: ',' -> skip; +Dollar: '$' -> more, mode(Mode1); +Ampersand: '&' -> type(DUMMY); + +String: '"' .*? '"'; +Foo: {canTestFoo()}? 'foo' {isItFoo()}? { myFooLexerAction(); }; +Bar: 'bar' {isItBar()}? { myBarLexerAction(); }; +Any: Foo Dot Bar? DotDot Baz; + +Comment : '#' ~[\r\n]* '\r'? '\n' -> channel(CommentsChannel); +WS: [ \t\r\n]+ -> channel(99); + +fragment Baz: 'Baz'; + +mode Mode1; +Dot: '.'; + +mode Mode2; +DotDot: '..'; diff --git a/antlr/antlr4-runtime/demo/TParser.g4 b/antlr/antlr4-runtime/demo/TParser.g4 new file mode 100644 index 0000000..9f25be9 --- /dev/null +++ b/antlr/antlr4-runtime/demo/TParser.g4 @@ -0,0 +1,119 @@ +parser grammar TParser; + +options { + tokenVocab = TLexer; +} + +// These are all supported parser sections: + +// Parser file header. Appears at the top in all parser related files. Use e.g. for copyrights. +@parser::header {/* parser/listener/visitor header section */} + +// Appears before any #include in h + cpp files. +@parser::preinclude {/* parser precinclude section */} + +// Follows directly after the standard #includes in h + cpp files. +@parser::postinclude { +/* parser postinclude section */ +#ifndef _WIN32 +#pragma GCC diagnostic ignored "-Wunused-parameter" +#endif +} + +// Directly preceeds the parser class declaration in the h file (e.g. for additional types etc.). +@parser::context {/* parser context section */} + +// Appears in the private part of the parser in the h file. +// The function bodies could also appear in the definitions section, but I want to maximize +// Java compatibility, so we can also create a Java parser from this grammar. +// Still, some tweaking is necessary after the Java file generation (e.g. bool -> boolean). +@parser::members { +/* public parser declarations/members section */ +bool myAction() { return true; } +bool doesItBlend() { return true; } +void cleanUp() {} +void doInit() {} +void doAfter() {} +} + +// Appears in the public part of the parser in the h file. +@parser::declarations {/* private parser declarations section */} + +// Appears in line with the other class member definitions in the cpp file. +@parser::definitions {/* parser definitions section */} + +// Additionally there are similar sections for (base)listener and (base)visitor files. +@parser::listenerpreinclude {/* listener preinclude section */} +@parser::listenerpostinclude {/* listener postinclude section */} +@parser::listenerdeclarations {/* listener public declarations/members section */} +@parser::listenermembers {/* listener private declarations/members section */} +@parser::listenerdefinitions {/* listener definitions section */} + +@parser::baselistenerpreinclude {/* base listener preinclude section */} +@parser::baselistenerpostinclude {/* base listener postinclude section */} +@parser::baselistenerdeclarations {/* base listener public declarations/members section */} +@parser::baselistenermembers {/* base listener private declarations/members section */} +@parser::baselistenerdefinitions {/* base listener definitions section */} + +@parser::visitorpreinclude {/* visitor preinclude section */} +@parser::visitorpostinclude {/* visitor postinclude section */} +@parser::visitordeclarations {/* visitor public declarations/members section */} +@parser::visitormembers {/* visitor private declarations/members section */} +@parser::visitordefinitions {/* visitor definitions section */} + +@parser::basevisitorpreinclude {/* base visitor preinclude section */} +@parser::basevisitorpostinclude {/* base visitor postinclude section */} +@parser::basevisitordeclarations {/* base visitor public declarations/members section */} +@parser::basevisitormembers {/* base visitor private declarations/members section */} +@parser::basevisitordefinitions {/* base visitor definitions section */} + +// Actual grammar start. +main: stat+ EOF; +divide : ID (and_ GreaterThan)? {doesItBlend()}?; +and_ @init{ doInit(); } @after { doAfter(); } : And ; + +conquer: + divide+ + | {doesItBlend()}? and_ { myAction(); } + | ID (LessThan* divide)?? { $ID.text; } +; + +// Unused rule to demonstrate some of the special features. +unused[double input = 111] returns [double calculated] locals [int _a, double _b, int _c] @init{ doInit(); } @after { doAfter(); } : + stat +; +catch [...] { + // Replaces the standard exception handling. +} +finally { + cleanUp(); +} + +unused2: + (unused[1] .)+ (Colon | Semicolon | Plus)? ~Semicolon +; + +stat: expr Equal expr Semicolon + | expr Semicolon +; + +expr: expr Star expr + | expr Plus expr + | OpenPar expr ClosePar + | expr QuestionMark expr Colon expr + | expr Equal expr + | identifier = id + | flowControl + | INT + | String +; + +flowControl: + Return expr # Return + | Continue # Continue +; + +id: ID; +array : OpenCurly el += INT (Comma el += INT)* CloseCurly; +idarray : OpenCurly element += id (Comma element += id)* CloseCurly; +any: t = .; diff --git a/antlr/antlr4-runtime/demo/Windows/antlr4-cpp-demo/antlr4-cpp-demo-vs2015.vcxproj b/antlr/antlr4-runtime/demo/Windows/antlr4-cpp-demo/antlr4-cpp-demo-vs2015.vcxproj new file mode 100644 index 0000000..f004fb0 --- /dev/null +++ b/antlr/antlr4-runtime/demo/Windows/antlr4-cpp-demo/antlr4-cpp-demo-vs2015.vcxproj @@ -0,0 +1,362 @@ +๏ปฟ + + + + Debug DLL + Win32 + + + Debug DLL + x64 + + + Debug Static + Win32 + + + Debug Static + x64 + + + Release DLL + Win32 + + + Release DLL + x64 + + + Release Static + Win32 + + + Release Static + x64 + + + + {24EC5104-7402-4C76-B66B-27ADBE062D68} + Win32Proj + antlr4cppdemo + antlr4cpp-demo + 8.1 + + + + Application + true + v140 + Unicode + + + Application + true + v140 + Unicode + + + Application + true + v140 + Unicode + + + Application + true + v140 + Unicode + + + Application + false + v140 + true + Unicode + + + Application + false + v140 + true + Unicode + + + Application + false + v140 + true + Unicode + + + Application + false + v140 + true + Unicode + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + true + $(SolutionDir)bin\vs-2015\$(PlatformTarget)\$(Configuration)\ + $(SolutionDir)obj\$(PlatformTarget)\$(Configuration)\$(ProjectName)\ + + + true + $(SolutionDir)bin\vs-2015\$(PlatformTarget)\$(Configuration)\ + $(SolutionDir)obj\$(PlatformTarget)\$(Configuration)\$(ProjectName)\ + + + true + $(SolutionDir)bin\vs-2015\$(PlatformTarget)\$(Configuration)\ + $(SolutionDir)obj\$(PlatformTarget)\$(Configuration)\$(ProjectName)\ + + + true + $(SolutionDir)bin\vs-2015\$(PlatformTarget)\$(Configuration)\ + $(SolutionDir)obj\$(PlatformTarget)\$(Configuration)\$(ProjectName)\ + + + false + $(SolutionDir)bin\vs-2015\$(PlatformTarget)\$(Configuration)\ + $(SolutionDir)obj\$(PlatformTarget)\$(Configuration)\$(ProjectName)\ + + + false + $(SolutionDir)bin\vs-2015\$(PlatformTarget)\$(Configuration)\ + $(SolutionDir)obj\$(PlatformTarget)\$(Configuration)\$(ProjectName)\ + + + false + $(SolutionDir)bin\vs-2015\$(PlatformTarget)\$(Configuration)\ + $(SolutionDir)obj\$(PlatformTarget)\$(Configuration)\$(ProjectName)\ + + + false + $(SolutionDir)bin\vs-2015\$(PlatformTarget)\$(Configuration)\ + $(SolutionDir)obj\$(PlatformTarget)\$(Configuration)\$(ProjectName)\ + + + + + + Level3 + Disabled + ANTLR4CPP_STATIC;%(PreprocessorDefinitions) + true + $(SolutionDir)..\generated;$(SolutionDir)..\..\runtime\src;$(SolutionDir)..\..\runtime\src\atn;$(SolutionDir)..\..\runtime\src\dfa;$(SolutionDir)..\..\runtime\src\misc;$(SolutionDir)..\..\runtime\src\support;$(SolutionDir)..\..\runtime\src\tree;$(SolutionDir)..\..\runtime\src\tree\xpath;$(SolutionDir)..\..\runtime\src\tree\pattern;%(AdditionalIncludeDirectories) + + + 4251 + true + false + + + Console + true + + + + + + + Level3 + Disabled + %(PreprocessorDefinitions) + true + $(SolutionDir)..\generated;$(SolutionDir)..\..\runtime\src;$(SolutionDir)..\..\runtime\src\atn;$(SolutionDir)..\..\runtime\src\dfa;$(SolutionDir)..\..\runtime\src\misc;$(SolutionDir)..\..\runtime\src\support;$(SolutionDir)..\..\runtime\src\tree;$(SolutionDir)..\..\runtime\src\tree\xpath;$(SolutionDir)..\..\runtime\src\tree\pattern;%(AdditionalIncludeDirectories) + + + 4251 + true + false + + + Console + true + + + + + + + Level3 + Disabled + ANTLR4CPP_STATIC;%(PreprocessorDefinitions) + true + $(SolutionDir)..\generated;$(SolutionDir)..\..\runtime\src;$(SolutionDir)..\..\runtime\src\atn;$(SolutionDir)..\..\runtime\src\dfa;$(SolutionDir)..\..\runtime\src\misc;$(SolutionDir)..\..\runtime\src\support;$(SolutionDir)..\..\runtime\src\tree;$(SolutionDir)..\..\runtime\src\tree\xpath;$(SolutionDir)..\..\runtime\src\tree\pattern;%(AdditionalIncludeDirectories) + + + 4251 + true + false + + + Console + true + + + + + + + Level3 + Disabled + %(PreprocessorDefinitions) + true + $(SolutionDir)..\generated;$(SolutionDir)..\..\runtime\src;$(SolutionDir)..\..\runtime\src\atn;$(SolutionDir)..\..\runtime\src\dfa;$(SolutionDir)..\..\runtime\src\misc;$(SolutionDir)..\..\runtime\src\support;$(SolutionDir)..\..\runtime\src\tree;$(SolutionDir)..\..\runtime\src\tree\xpath;$(SolutionDir)..\..\runtime\src\tree\pattern;%(AdditionalIncludeDirectories) + + + 4251 + true + false + + + Console + true + + + + + Level3 + + + MaxSpeed + true + true + ANTLR4CPP_STATIC;%(PreprocessorDefinitions) + true + $(SolutionDir)..\generated;$(SolutionDir)..\..\runtime\src;$(SolutionDir)..\..\runtime\src\atn;$(SolutionDir)..\..\runtime\src\dfa;$(SolutionDir)..\..\runtime\src\misc;$(SolutionDir)..\..\runtime\src\support;$(SolutionDir)..\..\runtime\src\tree;$(SolutionDir)..\..\runtime\src\tree\xpath;$(SolutionDir)..\..\runtime\src\tree\pattern;%(AdditionalIncludeDirectories) + + + 4251 + true + + + Console + true + true + true + + + + + Level3 + + + MaxSpeed + true + true + %(PreprocessorDefinitions) + true + $(SolutionDir)..\generated;$(SolutionDir)..\..\runtime\src;$(SolutionDir)..\..\runtime\src\atn;$(SolutionDir)..\..\runtime\src\dfa;$(SolutionDir)..\..\runtime\src\misc;$(SolutionDir)..\..\runtime\src\support;$(SolutionDir)..\..\runtime\src\tree;$(SolutionDir)..\..\runtime\src\tree\xpath;$(SolutionDir)..\..\runtime\src\tree\pattern;%(AdditionalIncludeDirectories) + + + 4251 + true + + + Console + true + true + true + + + + + Level3 + + + MaxSpeed + true + true + ANTLR4CPP_STATIC;%(PreprocessorDefinitions) + true + $(SolutionDir)..\generated;$(SolutionDir)..\..\runtime\src;$(SolutionDir)..\..\runtime\src\atn;$(SolutionDir)..\..\runtime\src\dfa;$(SolutionDir)..\..\runtime\src\misc;$(SolutionDir)..\..\runtime\src\support;$(SolutionDir)..\..\runtime\src\tree;$(SolutionDir)..\..\runtime\src\tree\xpath;$(SolutionDir)..\..\runtime\src\tree\pattern;%(AdditionalIncludeDirectories) + + + 4251 + true + + + Console + true + true + true + + + + + Level3 + + + MaxSpeed + true + true + %(PreprocessorDefinitions) + true + $(SolutionDir)..\generated;$(SolutionDir)..\..\runtime\src;$(SolutionDir)..\..\runtime\src\atn;$(SolutionDir)..\..\runtime\src\dfa;$(SolutionDir)..\..\runtime\src\misc;$(SolutionDir)..\..\runtime\src\support;$(SolutionDir)..\..\runtime\src\tree;$(SolutionDir)..\..\runtime\src\tree\xpath;$(SolutionDir)..\..\runtime\src\tree\pattern;%(AdditionalIncludeDirectories) + + + 4251 + true + + + Console + true + true + true + + + + + + + + + + + + + + + + + + + + + + {a9762991-1b57-4dce-90c0-ee42b96947be} + + + + + + \ No newline at end of file diff --git a/antlr/antlr4-runtime/demo/Windows/antlr4-cpp-demo/antlr4-cpp-demo-vs2015.vcxproj.filters b/antlr/antlr4-runtime/demo/Windows/antlr4-cpp-demo/antlr4-cpp-demo-vs2015.vcxproj.filters new file mode 100644 index 0000000..ed56184 --- /dev/null +++ b/antlr/antlr4-runtime/demo/Windows/antlr4-cpp-demo/antlr4-cpp-demo-vs2015.vcxproj.filters @@ -0,0 +1,63 @@ +๏ปฟ + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hh;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + {ef397b7b-1192-4d44-93ed-fadaec7622e8} + + + + + Source Files + + + generated + + + generated + + + generated + + + generated + + + generated + + + generated + + + + + generated + + + generated + + + generated + + + generated + + + generated + + + generated + + + \ No newline at end of file diff --git a/antlr/antlr4-runtime/demo/Windows/antlr4-cpp-demo/antlr4-cpp-demo.vcxproj b/antlr/antlr4-runtime/demo/Windows/antlr4-cpp-demo/antlr4-cpp-demo.vcxproj new file mode 100644 index 0000000..ec6240d --- /dev/null +++ b/antlr/antlr4-runtime/demo/Windows/antlr4-cpp-demo/antlr4-cpp-demo.vcxproj @@ -0,0 +1,349 @@ +๏ปฟ + + + + Debug DLL + Win32 + + + Debug DLL + x64 + + + Debug Static + Win32 + + + Debug Static + x64 + + + Release DLL + Win32 + + + Release DLL + x64 + + + Release Static + Win32 + + + Release Static + x64 + + + + {24EC5104-7402-4C76-B66B-27ADBE062D68} + Win32Proj + antlr4cppdemo + antlr4cpp-demo + + + + Application + true + v120 + Unicode + + + Application + true + v120 + Unicode + + + Application + true + v120 + Unicode + + + Application + true + v120 + Unicode + + + Application + false + v120 + true + Unicode + + + Application + false + v120 + true + Unicode + + + Application + false + v120 + true + Unicode + + + Application + false + v120 + true + Unicode + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + true + $(SolutionDir)bin\vs-2013\$(PlatformTarget)\$(Configuration)\ + $(SolutionDir)obj\$(PlatformTarget)\$(Configuration)\$(ProjectName)\ + + + true + $(SolutionDir)bin\vs-2013\$(PlatformTarget)\$(Configuration)\ + $(SolutionDir)obj\$(PlatformTarget)\$(Configuration)\$(ProjectName)\ + + + true + $(SolutionDir)bin\vs-2013\$(PlatformTarget)\$(Configuration)\ + $(SolutionDir)obj\$(PlatformTarget)\$(Configuration)\$(ProjectName)\ + + + true + $(SolutionDir)bin\vs-2013\$(PlatformTarget)\$(Configuration)\ + $(SolutionDir)obj\$(PlatformTarget)\$(Configuration)\$(ProjectName)\ + + + false + $(SolutionDir)bin\vs-2013\$(PlatformTarget)\$(Configuration)\ + $(SolutionDir)obj\$(PlatformTarget)\$(Configuration)\$(ProjectName)\ + + + false + $(SolutionDir)bin\vs-2013\$(PlatformTarget)\$(Configuration)\ + $(SolutionDir)obj\$(PlatformTarget)\$(Configuration)\$(ProjectName)\ + + + false + $(SolutionDir)bin\vs-2013\$(PlatformTarget)\$(Configuration)\ + $(SolutionDir)obj\$(PlatformTarget)\$(Configuration)\$(ProjectName)\ + + + false + $(SolutionDir)bin\vs-2013\$(PlatformTarget)\$(Configuration)\ + $(SolutionDir)obj\$(PlatformTarget)\$(Configuration)\$(ProjectName)\ + + + + + + Level3 + Disabled + WIN32;_DEBUG;_CONSOLE;_LIB;%(PreprocessorDefinitions) + true + $(SolutionDir)..\generated;$(SolutionDir)..\..\runtime\src;$(SolutionDir)..\..\runtime\src\atn;$(SolutionDir)..\..\runtime\src\dfa;$(SolutionDir)..\..\runtime\src\misc;$(SolutionDir)..\..\runtime\src\support;$(SolutionDir)..\..\runtime\src\tree;$(SolutionDir)..\..\runtime\src\tree\xpath;$(SolutionDir)..\..\runtime\src\tree\pattern;%(AdditionalIncludeDirectories) + + + 4251 + + + Console + true + + + + + + + Level3 + Disabled + WIN32;_DEBUG;_CONSOLE;_LIB;%(PreprocessorDefinitions) + true + $(SolutionDir)..\generated;$(SolutionDir)..\..\runtime\src;$(SolutionDir)..\..\runtime\src\atn;$(SolutionDir)..\..\runtime\src\dfa;$(SolutionDir)..\..\runtime\src\misc;$(SolutionDir)..\..\runtime\src\support;$(SolutionDir)..\..\runtime\src\tree;$(SolutionDir)..\..\runtime\src\tree\xpath;$(SolutionDir)..\..\runtime\src\tree\pattern;%(AdditionalIncludeDirectories) + + + 4251 + + + Console + true + + + + + + + Level3 + Disabled + WIN32;_DEBUG;_CONSOLE;_LIB;%(PreprocessorDefinitions) + true + $(SolutionDir)..\generated;$(SolutionDir)..\..\runtime\src;$(SolutionDir)..\..\runtime\src\atn;$(SolutionDir)..\..\runtime\src\dfa;$(SolutionDir)..\..\runtime\src\misc;$(SolutionDir)..\..\runtime\src\support;$(SolutionDir)..\..\runtime\src\tree;$(SolutionDir)..\..\runtime\src\tree\xpath;$(SolutionDir)..\..\runtime\src\tree\pattern;%(AdditionalIncludeDirectories) + + + 4251 + + + Console + true + + + + + + + Level3 + Disabled + WIN32;_DEBUG;_CONSOLE;_LIB;%(PreprocessorDefinitions) + true + $(SolutionDir)..\generated;$(SolutionDir)..\..\runtime\src;$(SolutionDir)..\..\runtime\src\atn;$(SolutionDir)..\..\runtime\src\dfa;$(SolutionDir)..\..\runtime\src\misc;$(SolutionDir)..\..\runtime\src\support;$(SolutionDir)..\..\runtime\src\tree;$(SolutionDir)..\..\runtime\src\tree\xpath;$(SolutionDir)..\..\runtime\src\tree\pattern;%(AdditionalIncludeDirectories) + + + 4251 + + + Console + true + + + + + Level3 + + + MaxSpeed + true + true + WIN32;NDEBUG;_CONSOLE;_LIB;%(PreprocessorDefinitions) + true + $(SolutionDir)..\generated;$(SolutionDir)..\..\runtime\src;$(SolutionDir)..\..\runtime\src\atn;$(SolutionDir)..\..\runtime\src\dfa;$(SolutionDir)..\..\runtime\src\misc;$(SolutionDir)..\..\runtime\src\support;$(SolutionDir)..\..\runtime\src\tree;$(SolutionDir)..\..\runtime\src\tree\xpath;$(SolutionDir)..\..\runtime\src\tree\pattern;%(AdditionalIncludeDirectories) + + + 4251 + + + Console + true + true + true + + + + + Level3 + + + MaxSpeed + true + true + WIN32;NDEBUG;_CONSOLE;_LIB;%(PreprocessorDefinitions) + true + $(SolutionDir)..\generated;$(SolutionDir)..\..\runtime\src;$(SolutionDir)..\..\runtime\src\atn;$(SolutionDir)..\..\runtime\src\dfa;$(SolutionDir)..\..\runtime\src\misc;$(SolutionDir)..\..\runtime\src\support;$(SolutionDir)..\..\runtime\src\tree;$(SolutionDir)..\..\runtime\src\tree\xpath;$(SolutionDir)..\..\runtime\src\tree\pattern;%(AdditionalIncludeDirectories) + + + 4251 + + + Console + true + true + true + + + + + Level3 + + + MaxSpeed + true + true + WIN32;NDEBUG;_CONSOLE;_LIB;%(PreprocessorDefinitions) + true + $(SolutionDir)..\generated;$(SolutionDir)..\..\runtime\src;$(SolutionDir)..\..\runtime\src\atn;$(SolutionDir)..\..\runtime\src\dfa;$(SolutionDir)..\..\runtime\src\misc;$(SolutionDir)..\..\runtime\src\support;$(SolutionDir)..\..\runtime\src\tree;$(SolutionDir)..\..\runtime\src\tree\xpath;$(SolutionDir)..\..\runtime\src\tree\pattern;%(AdditionalIncludeDirectories) + + + 4251 + + + Console + true + true + true + + + + + Level3 + + + MaxSpeed + true + true + WIN32;NDEBUG;_CONSOLE;_LIB;%(PreprocessorDefinitions) + true + $(SolutionDir)..\generated;$(SolutionDir)..\..\runtime\src;$(SolutionDir)..\..\runtime\src\atn;$(SolutionDir)..\..\runtime\src\dfa;$(SolutionDir)..\..\runtime\src\misc;$(SolutionDir)..\..\runtime\src\support;$(SolutionDir)..\..\runtime\src\tree;$(SolutionDir)..\..\runtime\src\tree\xpath;$(SolutionDir)..\..\runtime\src\tree\pattern;%(AdditionalIncludeDirectories) + + + 4251 + + + Console + true + true + true + + + + + + + + + + + + + + + + + + + + + + {a9762991-1b57-4dce-90c0-ee42b96947be} + + + + + + \ No newline at end of file diff --git a/antlr/antlr4-runtime/demo/Windows/antlr4-cpp-demo/antlr4-cpp-demo.vcxproj.filters b/antlr/antlr4-runtime/demo/Windows/antlr4-cpp-demo/antlr4-cpp-demo.vcxproj.filters new file mode 100644 index 0000000..ed56184 --- /dev/null +++ b/antlr/antlr4-runtime/demo/Windows/antlr4-cpp-demo/antlr4-cpp-demo.vcxproj.filters @@ -0,0 +1,63 @@ +๏ปฟ + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hh;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + {ef397b7b-1192-4d44-93ed-fadaec7622e8} + + + + + Source Files + + + generated + + + generated + + + generated + + + generated + + + generated + + + generated + + + + + generated + + + generated + + + generated + + + generated + + + generated + + + generated + + + \ No newline at end of file diff --git a/antlr/antlr4-runtime/demo/Windows/antlr4-cpp-demo/main.cpp b/antlr/antlr4-runtime/demo/Windows/antlr4-cpp-demo/main.cpp new file mode 100644 index 0000000..fa470e5 --- /dev/null +++ b/antlr/antlr4-runtime/demo/Windows/antlr4-cpp-demo/main.cpp @@ -0,0 +1,41 @@ +๏ปฟ/* 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. + */ + +// +// main.cpp +// antlr4-cpp-demo +// +// Created by Mike Lischke on 13.03.16. +// + +#include + +#include "antlr4-runtime.h" +#include "TLexer.h" +#include "TParser.h" + +#include + +#pragma execution_character_set("utf-8") + +using namespace antlrcpptest; +using namespace antlr4; + +int main(int argc, const char * argv[]) { + + ANTLRInputStream input("๐Ÿด = ๐Ÿ + \"๐Ÿ˜Ž\";(((x * ฯ€))) * ยต + โˆฐ; a + (x * (y ? 0 : 1) + z);"); + TLexer lexer(&input); + CommonTokenStream tokens(&lexer); + + TParser parser(&tokens); + tree::ParseTree *tree = parser.main(); + + std::wstring s = antlrcpp::s2ws(tree->toStringTree(&parser)) + L"\n"; + + OutputDebugString(s.data()); // Only works properly since VS 2015. + //std::wcout << "Parse Tree: " << s << std::endl; Unicode output in the console is very limited. + + return 0; +} diff --git a/antlr/antlr4-runtime/demo/Windows/antlr4cpp-vs2013.sln b/antlr/antlr4-runtime/demo/Windows/antlr4cpp-vs2013.sln new file mode 100644 index 0000000..931aeb3 --- /dev/null +++ b/antlr/antlr4-runtime/demo/Windows/antlr4cpp-vs2013.sln @@ -0,0 +1,58 @@ +๏ปฟ +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio 2013 +VisualStudioVersion = 12.0.40629.0 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "antlr4cpp-demo", "antlr4-cpp-demo\antlr4-cpp-demo.vcxproj", "{24EC5104-7402-4C76-B66B-27ADBE062D68}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "antlr4cpp-vs2013", "..\..\runtime\antlr4cpp-vs2013.vcxproj", "{A9762991-1B57-4DCE-90C0-EE42B96947BE}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug DLL|Win32 = Debug DLL|Win32 + Debug DLL|x64 = Debug DLL|x64 + Debug Static|Win32 = Debug Static|Win32 + Debug Static|x64 = Debug Static|x64 + Release DLL|Win32 = Release DLL|Win32 + Release DLL|x64 = Release DLL|x64 + Release Static|Win32 = Release Static|Win32 + Release Static|x64 = Release Static|x64 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {24EC5104-7402-4C76-B66B-27ADBE062D68}.Debug DLL|Win32.ActiveCfg = Debug DLL|Win32 + {24EC5104-7402-4C76-B66B-27ADBE062D68}.Debug DLL|Win32.Build.0 = Debug DLL|Win32 + {24EC5104-7402-4C76-B66B-27ADBE062D68}.Debug DLL|x64.ActiveCfg = Debug DLL|x64 + {24EC5104-7402-4C76-B66B-27ADBE062D68}.Debug DLL|x64.Build.0 = Debug DLL|x64 + {24EC5104-7402-4C76-B66B-27ADBE062D68}.Debug Static|Win32.ActiveCfg = Debug Static|Win32 + {24EC5104-7402-4C76-B66B-27ADBE062D68}.Debug Static|Win32.Build.0 = Debug Static|Win32 + {24EC5104-7402-4C76-B66B-27ADBE062D68}.Debug Static|x64.ActiveCfg = Debug Static|x64 + {24EC5104-7402-4C76-B66B-27ADBE062D68}.Debug Static|x64.Build.0 = Debug Static|x64 + {24EC5104-7402-4C76-B66B-27ADBE062D68}.Release DLL|Win32.ActiveCfg = Release DLL|Win32 + {24EC5104-7402-4C76-B66B-27ADBE062D68}.Release DLL|Win32.Build.0 = Release DLL|Win32 + {24EC5104-7402-4C76-B66B-27ADBE062D68}.Release DLL|x64.ActiveCfg = Release DLL|x64 + {24EC5104-7402-4C76-B66B-27ADBE062D68}.Release DLL|x64.Build.0 = Release DLL|x64 + {24EC5104-7402-4C76-B66B-27ADBE062D68}.Release Static|Win32.ActiveCfg = Release Static|Win32 + {24EC5104-7402-4C76-B66B-27ADBE062D68}.Release Static|Win32.Build.0 = Release Static|Win32 + {24EC5104-7402-4C76-B66B-27ADBE062D68}.Release Static|x64.ActiveCfg = Release Static|x64 + {24EC5104-7402-4C76-B66B-27ADBE062D68}.Release Static|x64.Build.0 = Release Static|x64 + {A9762991-1B57-4DCE-90C0-EE42B96947BE}.Debug DLL|Win32.ActiveCfg = Debug DLL|Win32 + {A9762991-1B57-4DCE-90C0-EE42B96947BE}.Debug DLL|Win32.Build.0 = Debug DLL|Win32 + {A9762991-1B57-4DCE-90C0-EE42B96947BE}.Debug DLL|x64.ActiveCfg = Debug DLL|x64 + {A9762991-1B57-4DCE-90C0-EE42B96947BE}.Debug DLL|x64.Build.0 = Debug DLL|x64 + {A9762991-1B57-4DCE-90C0-EE42B96947BE}.Debug Static|Win32.ActiveCfg = Debug Static|Win32 + {A9762991-1B57-4DCE-90C0-EE42B96947BE}.Debug Static|Win32.Build.0 = Debug Static|Win32 + {A9762991-1B57-4DCE-90C0-EE42B96947BE}.Debug Static|x64.ActiveCfg = Debug Static|x64 + {A9762991-1B57-4DCE-90C0-EE42B96947BE}.Debug Static|x64.Build.0 = Debug Static|x64 + {A9762991-1B57-4DCE-90C0-EE42B96947BE}.Release DLL|Win32.ActiveCfg = Release DLL|Win32 + {A9762991-1B57-4DCE-90C0-EE42B96947BE}.Release DLL|Win32.Build.0 = Release DLL|Win32 + {A9762991-1B57-4DCE-90C0-EE42B96947BE}.Release DLL|x64.ActiveCfg = Release DLL|x64 + {A9762991-1B57-4DCE-90C0-EE42B96947BE}.Release DLL|x64.Build.0 = Release DLL|x64 + {A9762991-1B57-4DCE-90C0-EE42B96947BE}.Release Static|Win32.ActiveCfg = Release Static|Win32 + {A9762991-1B57-4DCE-90C0-EE42B96947BE}.Release Static|Win32.Build.0 = Release Static|Win32 + {A9762991-1B57-4DCE-90C0-EE42B96947BE}.Release Static|x64.ActiveCfg = Release Static|x64 + {A9762991-1B57-4DCE-90C0-EE42B96947BE}.Release Static|x64.Build.0 = Release Static|x64 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/antlr/antlr4-runtime/demo/Windows/antlr4cpp-vs2015.sln b/antlr/antlr4-runtime/demo/Windows/antlr4cpp-vs2015.sln new file mode 100644 index 0000000..6bf253d --- /dev/null +++ b/antlr/antlr4-runtime/demo/Windows/antlr4cpp-vs2015.sln @@ -0,0 +1,58 @@ +๏ปฟ +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio 14 +VisualStudioVersion = 14.0.25420.1 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "antlr4cpp-vs2015", "..\..\runtime\antlr4cpp-vs2015.vcxproj", "{A9762991-1B57-4DCE-90C0-EE42B96947BE}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "antlr4cpp-demo", "antlr4-cpp-demo\antlr4-cpp-demo-vs2015.vcxproj", "{24EC5104-7402-4C76-B66B-27ADBE062D68}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug DLL|x64 = Debug DLL|x64 + Debug DLL|x86 = Debug DLL|x86 + Debug Static|x64 = Debug Static|x64 + Debug Static|x86 = Debug Static|x86 + Release DLL|x64 = Release DLL|x64 + Release DLL|x86 = Release DLL|x86 + Release Static|x64 = Release Static|x64 + Release Static|x86 = Release Static|x86 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {A9762991-1B57-4DCE-90C0-EE42B96947BE}.Debug DLL|x64.ActiveCfg = Debug DLL|x64 + {A9762991-1B57-4DCE-90C0-EE42B96947BE}.Debug DLL|x64.Build.0 = Debug DLL|x64 + {A9762991-1B57-4DCE-90C0-EE42B96947BE}.Debug DLL|x86.ActiveCfg = Debug DLL|Win32 + {A9762991-1B57-4DCE-90C0-EE42B96947BE}.Debug DLL|x86.Build.0 = Debug DLL|Win32 + {A9762991-1B57-4DCE-90C0-EE42B96947BE}.Debug Static|x64.ActiveCfg = Debug Static|x64 + {A9762991-1B57-4DCE-90C0-EE42B96947BE}.Debug Static|x64.Build.0 = Debug Static|x64 + {A9762991-1B57-4DCE-90C0-EE42B96947BE}.Debug Static|x86.ActiveCfg = Debug Static|Win32 + {A9762991-1B57-4DCE-90C0-EE42B96947BE}.Debug Static|x86.Build.0 = Debug Static|Win32 + {A9762991-1B57-4DCE-90C0-EE42B96947BE}.Release DLL|x64.ActiveCfg = Release DLL|x64 + {A9762991-1B57-4DCE-90C0-EE42B96947BE}.Release DLL|x64.Build.0 = Release DLL|x64 + {A9762991-1B57-4DCE-90C0-EE42B96947BE}.Release DLL|x86.ActiveCfg = Release DLL|Win32 + {A9762991-1B57-4DCE-90C0-EE42B96947BE}.Release DLL|x86.Build.0 = Release DLL|Win32 + {A9762991-1B57-4DCE-90C0-EE42B96947BE}.Release Static|x64.ActiveCfg = Release Static|x64 + {A9762991-1B57-4DCE-90C0-EE42B96947BE}.Release Static|x64.Build.0 = Release Static|x64 + {A9762991-1B57-4DCE-90C0-EE42B96947BE}.Release Static|x86.ActiveCfg = Release Static|Win32 + {A9762991-1B57-4DCE-90C0-EE42B96947BE}.Release Static|x86.Build.0 = Release Static|Win32 + {24EC5104-7402-4C76-B66B-27ADBE062D68}.Debug DLL|x64.ActiveCfg = Debug DLL|x64 + {24EC5104-7402-4C76-B66B-27ADBE062D68}.Debug DLL|x64.Build.0 = Debug DLL|x64 + {24EC5104-7402-4C76-B66B-27ADBE062D68}.Debug DLL|x86.ActiveCfg = Debug DLL|Win32 + {24EC5104-7402-4C76-B66B-27ADBE062D68}.Debug DLL|x86.Build.0 = Debug DLL|Win32 + {24EC5104-7402-4C76-B66B-27ADBE062D68}.Debug Static|x64.ActiveCfg = Debug Static|x64 + {24EC5104-7402-4C76-B66B-27ADBE062D68}.Debug Static|x64.Build.0 = Debug Static|x64 + {24EC5104-7402-4C76-B66B-27ADBE062D68}.Debug Static|x86.ActiveCfg = Debug Static|Win32 + {24EC5104-7402-4C76-B66B-27ADBE062D68}.Debug Static|x86.Build.0 = Debug Static|Win32 + {24EC5104-7402-4C76-B66B-27ADBE062D68}.Release DLL|x64.ActiveCfg = Release DLL|x64 + {24EC5104-7402-4C76-B66B-27ADBE062D68}.Release DLL|x64.Build.0 = Release DLL|x64 + {24EC5104-7402-4C76-B66B-27ADBE062D68}.Release DLL|x86.ActiveCfg = Release DLL|Win32 + {24EC5104-7402-4C76-B66B-27ADBE062D68}.Release DLL|x86.Build.0 = Release DLL|Win32 + {24EC5104-7402-4C76-B66B-27ADBE062D68}.Release Static|x64.ActiveCfg = Release Static|x64 + {24EC5104-7402-4C76-B66B-27ADBE062D68}.Release Static|x64.Build.0 = Release Static|x64 + {24EC5104-7402-4C76-B66B-27ADBE062D68}.Release Static|x86.ActiveCfg = Release Static|Win32 + {24EC5104-7402-4C76-B66B-27ADBE062D68}.Release Static|x86.Build.0 = Release Static|Win32 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/antlr/antlr4-runtime/demo/generate.cmd b/antlr/antlr4-runtime/demo/generate.cmd new file mode 100644 index 0000000..5d74466 --- /dev/null +++ b/antlr/antlr4-runtime/demo/generate.cmd @@ -0,0 +1,13 @@ +@echo off +:: Created 2016, Mike Lischke (public domain) + +:: This script is used to generate source files from the test grammars in the same folder. The generated files are placed +:: into a subfolder "generated" which the demo project uses to compile a demo binary. + +:: Download the ANLTR jar and place it in the same folder as this script (or adjust the LOCATION var accordingly). + +set LOCATION=antlr-4.9.3-complete.jar +java -jar %LOCATION% -Dlanguage=Cpp -listener -visitor -o generated/ -package antlrcpptest TLexer.g4 TParser.g4 +::java -jar %LOCATION% -Dlanguage=Cpp -listener -visitor -o generated/ -package antlrcpptest -XdbgST TLexer.g4 TParser.g4 +::java -jar %LOCATION% -Dlanguage=Java -listener -visitor -o generated/ -package antlrcpptest TLexer.g4 TParser.g4 + diff --git a/antlr/antlr4-runtime/demo/generate.sh b/antlr/antlr4-runtime/demo/generate.sh new file mode 100755 index 0000000..2fb8b13 --- /dev/null +++ b/antlr/antlr4-runtime/demo/generate.sh @@ -0,0 +1,28 @@ +#!/bin/bash +set -o errexit + +# Created 2016, Mike Lischke (public domain) + +# This script is used to generate source files from the test grammars in the same folder. The generated files are placed +# into a subfolder "generated" which the demo project uses to compile a demo binary. + +# There are 2 ways of running the ANTLR generator here. + +# 1) Running from jar. Use the given jar (or replace it by another one you built or downloaded) for generation. +#LOCATION=antlr4-4.5.4-SNAPSHOT.jar +#java -jar $LOCATION -Dlanguage=Cpp -listener -visitor -o generated/ -package antlrcpptest TLexer.g4 TParser.g4 +#java -jar $LOCATION -Dlanguage=Cpp -listener -visitor -o generated/ -package antlrcpptest -XdbgST TLexer.g4 TParser.g4 +#java -jar $LOCATION -Dlanguage=Java -listener -visitor -o generated/ -package antlrcpptest TLexer.g4 TParser.g4 + +# 2) Running from class path. This requires that you have both antlr3 and antlr4 compiled. In this scenario no installation +# is needed. You just compile the java class files (using "mvn compile" in both the antlr4 and the antlr3 root folders). +# The script then runs the generation using these class files, by specifying them on the classpath. +# Also the string template jar is needed. Adjust CLASSPATH if you have stored the jar in a different folder as this script assumes. +# Furthermore is assumed that the antlr3 folder is located side-by-side with the antlr4 folder. Adjust CLASSPATH if not. +# This approach is especially useful if you are working on a target stg file, as it doesn't require to regenerate the +# antlr jar over and over again. +CLASSPATH=../../../tool/resources/:ST-4.0.8.jar:../../../tool/target/classes:../../../runtime/Java/target/classes:../../../../antlr3/runtime/Java/target/classes + +java -cp $CLASSPATH org.antlr.v4.Tool -Dlanguage=Cpp -listener -visitor -o generated/ -package antlrcpptest TLexer.g4 TParser.g4 +#java -cp $CLASSPATH org.antlr.v4.Tool -Dlanguage=Cpp -listener -visitor -o generated/ -package antlrcpptest -XdbgST TLexer.g4 TParser.g4 +#java -cp $CLASSPATH org.antlr.v4.Tool -Dlanguage=Java -listener -visitor -o generated/ TLexer.g4 TParser.g4 diff --git a/antlr/antlr4-runtime/demo/generated/TLexer.cpp b/antlr/antlr4-runtime/demo/generated/TLexer.cpp new file mode 100644 index 0000000..20f65cd --- /dev/null +++ b/antlr/antlr4-runtime/demo/generated/TLexer.cpp @@ -0,0 +1,347 @@ +/* lexer header section */ + +// Generated from /home/xsu/workspace/sysy/sysy/antlr/antlr4-runtime/demo/TLexer.g4 by ANTLR 4.9.3 + +/* lexer precinclude section */ + +#include "TLexer.h" + + +/* lexer postinclude section */ +#ifndef _WIN32 +#pragma GCC diagnostic ignored "-Wunused-parameter" +#endif + + +using namespace antlr4; + +using namespace antlrcpptest; + +TLexer::TLexer(CharStream *input) : Lexer(input) { + _interpreter = new atn::LexerATNSimulator(this, _atn, _decisionToDFA, _sharedContextCache); +} + +TLexer::~TLexer() { + delete _interpreter; +} + +std::string TLexer::getGrammarFileName() const { + return "TLexer.g4"; +} + +const std::vector& TLexer::getRuleNames() const { + return _ruleNames; +} + +const std::vector& TLexer::getChannelNames() const { + return _channelNames; +} + +const std::vector& TLexer::getModeNames() const { + return _modeNames; +} + +const std::vector& TLexer::getTokenNames() const { + return _tokenNames; +} + +dfa::Vocabulary& TLexer::getVocabulary() const { + return _vocabulary; +} + +const std::vector TLexer::getSerializedATN() const { + return _serializedATN; +} + +const atn::ATN& TLexer::getATN() const { + return _atn; +} + +/* lexer definitions section */ + +void TLexer::action(RuleContext *context, size_t ruleIndex, size_t actionIndex) { + switch (ruleIndex) { + case 24: FooAction(antlrcpp::downCast(context), actionIndex); break; + case 25: BarAction(antlrcpp::downCast(context), actionIndex); break; + + default: + break; + } +} + +bool TLexer::sempred(RuleContext *context, size_t ruleIndex, size_t predicateIndex) { + switch (ruleIndex) { + case 24: return FooSempred(antlrcpp::downCast(context), predicateIndex); + case 25: return BarSempred(antlrcpp::downCast(context), predicateIndex); + + default: + break; + } + return true; +} + +void TLexer::FooAction(antlr4::RuleContext *context, size_t actionIndex) { + switch (actionIndex) { + case 0: myFooLexerAction(); break; + + default: + break; + } +} + +void TLexer::BarAction(antlr4::RuleContext *context, size_t actionIndex) { + switch (actionIndex) { + case 1: myBarLexerAction(); break; + + default: + break; + } +} + + +bool TLexer::FooSempred(antlr4::RuleContext *_localctx, size_t predicateIndex) { + switch (predicateIndex) { + case 0: return canTestFoo(); + case 1: return isItFoo(); + + default: + break; + } + return true; +} + +bool TLexer::BarSempred(antlr4::RuleContext *_localctx, size_t predicateIndex) { + switch (predicateIndex) { + case 2: return isItBar(); + + default: + break; + } + return true; +} + + +// Static vars and initialization. +std::vector TLexer::_decisionToDFA; +atn::PredictionContextCache TLexer::_sharedContextCache; + +// We own the ATN which in turn owns the ATN states. +atn::ATN TLexer::_atn; +std::vector TLexer::_serializedATN; + +std::vector TLexer::_ruleNames = { + "Return", "Continue", "INT", "Digit", "ID", "LETTER", "LessThan", "GreaterThan", + "Equal", "And", "Colon", "Semicolon", "Plus", "Minus", "Star", "OpenPar", + "ClosePar", "OpenCurly", "CloseCurly", "QuestionMark", "Comma", "Dollar", + "Ampersand", "String", "Foo", "Bar", "Any", "Comment", "WS", "Baz", "Dot", + "DotDot" +}; + +std::vector TLexer::_channelNames = { + "DEFAULT_TOKEN_CHANNEL", "HIDDEN", "CommentsChannel", "DirectiveChannel" +}; + +std::vector TLexer::_modeNames = { + "DEFAULT_MODE", "Mode1", "Mode2" +}; + +std::vector TLexer::_literalNames = { + "", "", "'return'", "'continue'", "", "", "", "'<'", "'>'", "'='", "'and'", + "':'", "';'", "'+'", "'-'", "'*'", "'('", "')'", "'{'", "'}'", "'\u003F'", + "','", "", "", "", "", "", "", "'.'", "'..'", "'$'", "'&'" +}; + +std::vector TLexer::_symbolicNames = { + "", "DUMMY", "Return", "Continue", "INT", "Digit", "ID", "LessThan", "GreaterThan", + "Equal", "And", "Colon", "Semicolon", "Plus", "Minus", "Star", "OpenPar", + "ClosePar", "OpenCurly", "CloseCurly", "QuestionMark", "Comma", "String", + "Foo", "Bar", "Any", "Comment", "WS", "Dot", "DotDot", "Dollar", "Ampersand" +}; + +dfa::Vocabulary TLexer::_vocabulary(_literalNames, _symbolicNames); + +std::vector TLexer::_tokenNames; + +TLexer::Initializer::Initializer() { + // This code could be in a static initializer lambda, but VS doesn't allow access to private class members from there. + for (size_t i = 0; i < _symbolicNames.size(); ++i) { + std::string name = _vocabulary.getLiteralName(i); + if (name.empty()) { + name = _vocabulary.getSymbolicName(i); + } + + if (name.empty()) { + _tokenNames.push_back(""); + } else { + _tokenNames.push_back(name); + } + } + + static const uint16_t serializedATNSegment0[] = { + 0x3, 0x608b, 0xa72a, 0x8133, 0xb9ed, 0x417c, 0x3be7, 0x7786, 0x5964, + 0x2, 0x21, 0xd3, 0x8, 0x1, 0x8, 0x1, 0x8, 0x1, 0x4, 0x2, 0x9, 0x2, + 0x4, 0x3, 0x9, 0x3, 0x4, 0x4, 0x9, 0x4, 0x4, 0x5, 0x9, 0x5, 0x4, + 0x6, 0x9, 0x6, 0x4, 0x7, 0x9, 0x7, 0x4, 0x8, 0x9, 0x8, 0x4, 0x9, + 0x9, 0x9, 0x4, 0xa, 0x9, 0xa, 0x4, 0xb, 0x9, 0xb, 0x4, 0xc, 0x9, + 0xc, 0x4, 0xd, 0x9, 0xd, 0x4, 0xe, 0x9, 0xe, 0x4, 0xf, 0x9, 0xf, + 0x4, 0x10, 0x9, 0x10, 0x4, 0x11, 0x9, 0x11, 0x4, 0x12, 0x9, 0x12, + 0x4, 0x13, 0x9, 0x13, 0x4, 0x14, 0x9, 0x14, 0x4, 0x15, 0x9, 0x15, + 0x4, 0x16, 0x9, 0x16, 0x4, 0x17, 0x9, 0x17, 0x4, 0x18, 0x9, 0x18, + 0x4, 0x19, 0x9, 0x19, 0x4, 0x1a, 0x9, 0x1a, 0x4, 0x1b, 0x9, 0x1b, + 0x4, 0x1c, 0x9, 0x1c, 0x4, 0x1d, 0x9, 0x1d, 0x4, 0x1e, 0x9, 0x1e, + 0x4, 0x1f, 0x9, 0x1f, 0x4, 0x20, 0x9, 0x20, 0x4, 0x21, 0x9, 0x21, + 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, + 0x2, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, + 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x4, 0x6, 0x4, 0x57, 0xa, 0x4, + 0xd, 0x4, 0xe, 0x4, 0x58, 0x3, 0x5, 0x3, 0x5, 0x3, 0x6, 0x3, 0x6, + 0x3, 0x6, 0x7, 0x6, 0x60, 0xa, 0x6, 0xc, 0x6, 0xe, 0x6, 0x63, 0xb, + 0x6, 0x3, 0x7, 0x3, 0x7, 0x3, 0x8, 0x3, 0x8, 0x3, 0x9, 0x3, 0x9, + 0x3, 0xa, 0x3, 0xa, 0x3, 0xb, 0x3, 0xb, 0x3, 0xb, 0x3, 0xb, 0x3, + 0xc, 0x3, 0xc, 0x3, 0xd, 0x3, 0xd, 0x3, 0xe, 0x3, 0xe, 0x3, 0xf, + 0x3, 0xf, 0x3, 0x10, 0x3, 0x10, 0x3, 0x11, 0x3, 0x11, 0x3, 0x12, + 0x3, 0x12, 0x3, 0x13, 0x3, 0x13, 0x3, 0x13, 0x3, 0x13, 0x3, 0x14, + 0x3, 0x14, 0x3, 0x14, 0x3, 0x14, 0x3, 0x15, 0x3, 0x15, 0x3, 0x16, + 0x3, 0x16, 0x3, 0x16, 0x3, 0x16, 0x3, 0x17, 0x3, 0x17, 0x3, 0x17, + 0x3, 0x17, 0x3, 0x17, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, + 0x3, 0x19, 0x3, 0x19, 0x7, 0x19, 0x98, 0xa, 0x19, 0xc, 0x19, 0xe, + 0x19, 0x9b, 0xb, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x1a, 0x3, 0x1a, + 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1a, + 0x3, 0x1b, 0x3, 0x1b, 0x3, 0x1b, 0x3, 0x1b, 0x3, 0x1b, 0x3, 0x1b, + 0x3, 0x1b, 0x3, 0x1c, 0x3, 0x1c, 0x3, 0x1c, 0x5, 0x1c, 0xb1, 0xa, + 0x1c, 0x3, 0x1c, 0x3, 0x1c, 0x3, 0x1c, 0x3, 0x1d, 0x3, 0x1d, 0x7, + 0x1d, 0xb8, 0xa, 0x1d, 0xc, 0x1d, 0xe, 0x1d, 0xbb, 0xb, 0x1d, 0x3, + 0x1d, 0x5, 0x1d, 0xbe, 0xa, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, + 0x3, 0x1d, 0x3, 0x1e, 0x6, 0x1e, 0xc5, 0xa, 0x1e, 0xd, 0x1e, 0xe, + 0x1e, 0xc6, 0x3, 0x1e, 0x3, 0x1e, 0x3, 0x1f, 0x3, 0x1f, 0x3, 0x1f, + 0x3, 0x1f, 0x3, 0x20, 0x3, 0x20, 0x3, 0x21, 0x3, 0x21, 0x3, 0x21, + 0x3, 0x99, 0x2, 0x22, 0x5, 0x4, 0x7, 0x5, 0x9, 0x6, 0xb, 0x7, 0xd, + 0x8, 0xf, 0x2, 0x11, 0x9, 0x13, 0xa, 0x15, 0xb, 0x17, 0xc, 0x19, + 0xd, 0x1b, 0xe, 0x1d, 0xf, 0x1f, 0x10, 0x21, 0x11, 0x23, 0x12, 0x25, + 0x13, 0x27, 0x14, 0x29, 0x15, 0x2b, 0x16, 0x2d, 0x17, 0x2f, 0x20, + 0x31, 0x21, 0x33, 0x18, 0x35, 0x19, 0x37, 0x1a, 0x39, 0x1b, 0x3b, + 0x1c, 0x3d, 0x1d, 0x3f, 0x2, 0x41, 0x1e, 0x43, 0x1f, 0x5, 0x2, 0x3, + 0x4, 0x5, 0x3, 0x2, 0x32, 0x3b, 0x4, 0x2, 0xc, 0xc, 0xf, 0xf, 0x5, + 0x2, 0xb, 0xc, 0xf, 0xf, 0x22, 0x22, 0x3, 0x5, 0x2, 0x43, 0x2, 0x5c, + 0x2, 0x63, 0x2, 0x7c, 0x2, 0x82, 0x2, 0x1, 0x12, 0xd6, 0x2, 0x5, + 0x3, 0x2, 0x2, 0x2, 0x2, 0x7, 0x3, 0x2, 0x2, 0x2, 0x2, 0x9, 0x3, + 0x2, 0x2, 0x2, 0x2, 0xb, 0x3, 0x2, 0x2, 0x2, 0x2, 0xd, 0x3, 0x2, + 0x2, 0x2, 0x2, 0x11, 0x3, 0x2, 0x2, 0x2, 0x2, 0x13, 0x3, 0x2, 0x2, + 0x2, 0x2, 0x15, 0x3, 0x2, 0x2, 0x2, 0x2, 0x17, 0x3, 0x2, 0x2, 0x2, + 0x2, 0x19, 0x3, 0x2, 0x2, 0x2, 0x2, 0x1b, 0x3, 0x2, 0x2, 0x2, 0x2, + 0x1d, 0x3, 0x2, 0x2, 0x2, 0x2, 0x1f, 0x3, 0x2, 0x2, 0x2, 0x2, 0x21, + 0x3, 0x2, 0x2, 0x2, 0x2, 0x23, 0x3, 0x2, 0x2, 0x2, 0x2, 0x25, 0x3, + 0x2, 0x2, 0x2, 0x2, 0x27, 0x3, 0x2, 0x2, 0x2, 0x2, 0x29, 0x3, 0x2, + 0x2, 0x2, 0x2, 0x2b, 0x3, 0x2, 0x2, 0x2, 0x2, 0x2d, 0x3, 0x2, 0x2, + 0x2, 0x2, 0x2f, 0x3, 0x2, 0x2, 0x2, 0x2, 0x31, 0x3, 0x2, 0x2, 0x2, + 0x2, 0x33, 0x3, 0x2, 0x2, 0x2, 0x2, 0x35, 0x3, 0x2, 0x2, 0x2, 0x2, + 0x37, 0x3, 0x2, 0x2, 0x2, 0x2, 0x39, 0x3, 0x2, 0x2, 0x2, 0x2, 0x3b, + 0x3, 0x2, 0x2, 0x2, 0x2, 0x3d, 0x3, 0x2, 0x2, 0x2, 0x3, 0x41, 0x3, + 0x2, 0x2, 0x2, 0x4, 0x43, 0x3, 0x2, 0x2, 0x2, 0x5, 0x45, 0x3, 0x2, + 0x2, 0x2, 0x7, 0x4c, 0x3, 0x2, 0x2, 0x2, 0x9, 0x56, 0x3, 0x2, 0x2, + 0x2, 0xb, 0x5a, 0x3, 0x2, 0x2, 0x2, 0xd, 0x5c, 0x3, 0x2, 0x2, 0x2, + 0xf, 0x64, 0x3, 0x2, 0x2, 0x2, 0x11, 0x66, 0x3, 0x2, 0x2, 0x2, 0x13, + 0x68, 0x3, 0x2, 0x2, 0x2, 0x15, 0x6a, 0x3, 0x2, 0x2, 0x2, 0x17, 0x6c, + 0x3, 0x2, 0x2, 0x2, 0x19, 0x70, 0x3, 0x2, 0x2, 0x2, 0x1b, 0x72, 0x3, + 0x2, 0x2, 0x2, 0x1d, 0x74, 0x3, 0x2, 0x2, 0x2, 0x1f, 0x76, 0x3, 0x2, + 0x2, 0x2, 0x21, 0x78, 0x3, 0x2, 0x2, 0x2, 0x23, 0x7a, 0x3, 0x2, 0x2, + 0x2, 0x25, 0x7c, 0x3, 0x2, 0x2, 0x2, 0x27, 0x7e, 0x3, 0x2, 0x2, 0x2, + 0x29, 0x82, 0x3, 0x2, 0x2, 0x2, 0x2b, 0x86, 0x3, 0x2, 0x2, 0x2, 0x2d, + 0x88, 0x3, 0x2, 0x2, 0x2, 0x2f, 0x8c, 0x3, 0x2, 0x2, 0x2, 0x31, 0x91, + 0x3, 0x2, 0x2, 0x2, 0x33, 0x95, 0x3, 0x2, 0x2, 0x2, 0x35, 0x9e, 0x3, + 0x2, 0x2, 0x2, 0x37, 0xa6, 0x3, 0x2, 0x2, 0x2, 0x39, 0xad, 0x3, 0x2, + 0x2, 0x2, 0x3b, 0xb5, 0x3, 0x2, 0x2, 0x2, 0x3d, 0xc4, 0x3, 0x2, 0x2, + 0x2, 0x3f, 0xca, 0x3, 0x2, 0x2, 0x2, 0x41, 0xce, 0x3, 0x2, 0x2, 0x2, + 0x43, 0xd0, 0x3, 0x2, 0x2, 0x2, 0x45, 0x46, 0x7, 0x74, 0x2, 0x2, + 0x46, 0x47, 0x7, 0x67, 0x2, 0x2, 0x47, 0x48, 0x7, 0x76, 0x2, 0x2, + 0x48, 0x49, 0x7, 0x77, 0x2, 0x2, 0x49, 0x4a, 0x7, 0x74, 0x2, 0x2, + 0x4a, 0x4b, 0x7, 0x70, 0x2, 0x2, 0x4b, 0x6, 0x3, 0x2, 0x2, 0x2, 0x4c, + 0x4d, 0x7, 0x65, 0x2, 0x2, 0x4d, 0x4e, 0x7, 0x71, 0x2, 0x2, 0x4e, + 0x4f, 0x7, 0x70, 0x2, 0x2, 0x4f, 0x50, 0x7, 0x76, 0x2, 0x2, 0x50, + 0x51, 0x7, 0x6b, 0x2, 0x2, 0x51, 0x52, 0x7, 0x70, 0x2, 0x2, 0x52, + 0x53, 0x7, 0x77, 0x2, 0x2, 0x53, 0x54, 0x7, 0x67, 0x2, 0x2, 0x54, + 0x8, 0x3, 0x2, 0x2, 0x2, 0x55, 0x57, 0x5, 0xb, 0x5, 0x2, 0x56, 0x55, + 0x3, 0x2, 0x2, 0x2, 0x57, 0x58, 0x3, 0x2, 0x2, 0x2, 0x58, 0x56, 0x3, + 0x2, 0x2, 0x2, 0x58, 0x59, 0x3, 0x2, 0x2, 0x2, 0x59, 0xa, 0x3, 0x2, + 0x2, 0x2, 0x5a, 0x5b, 0x9, 0x2, 0x2, 0x2, 0x5b, 0xc, 0x3, 0x2, 0x2, + 0x2, 0x5c, 0x61, 0x5, 0xf, 0x7, 0x2, 0x5d, 0x60, 0x5, 0xf, 0x7, 0x2, + 0x5e, 0x60, 0x4, 0x32, 0x3b, 0x2, 0x5f, 0x5d, 0x3, 0x2, 0x2, 0x2, + 0x5f, 0x5e, 0x3, 0x2, 0x2, 0x2, 0x60, 0x63, 0x3, 0x2, 0x2, 0x2, 0x61, + 0x5f, 0x3, 0x2, 0x2, 0x2, 0x61, 0x62, 0x3, 0x2, 0x2, 0x2, 0x62, 0xe, + 0x3, 0x2, 0x2, 0x2, 0x63, 0x61, 0x3, 0x2, 0x2, 0x2, 0x64, 0x65, 0x9, + 0x5, 0x2, 0x2, 0x65, 0x10, 0x3, 0x2, 0x2, 0x2, 0x66, 0x67, 0x7, 0x3e, + 0x2, 0x2, 0x67, 0x12, 0x3, 0x2, 0x2, 0x2, 0x68, 0x69, 0x7, 0x40, + 0x2, 0x2, 0x69, 0x14, 0x3, 0x2, 0x2, 0x2, 0x6a, 0x6b, 0x7, 0x3f, + 0x2, 0x2, 0x6b, 0x16, 0x3, 0x2, 0x2, 0x2, 0x6c, 0x6d, 0x7, 0x63, + 0x2, 0x2, 0x6d, 0x6e, 0x7, 0x70, 0x2, 0x2, 0x6e, 0x6f, 0x7, 0x66, + 0x2, 0x2, 0x6f, 0x18, 0x3, 0x2, 0x2, 0x2, 0x70, 0x71, 0x7, 0x3c, + 0x2, 0x2, 0x71, 0x1a, 0x3, 0x2, 0x2, 0x2, 0x72, 0x73, 0x7, 0x3d, + 0x2, 0x2, 0x73, 0x1c, 0x3, 0x2, 0x2, 0x2, 0x74, 0x75, 0x7, 0x2d, + 0x2, 0x2, 0x75, 0x1e, 0x3, 0x2, 0x2, 0x2, 0x76, 0x77, 0x7, 0x2f, + 0x2, 0x2, 0x77, 0x20, 0x3, 0x2, 0x2, 0x2, 0x78, 0x79, 0x7, 0x2c, + 0x2, 0x2, 0x79, 0x22, 0x3, 0x2, 0x2, 0x2, 0x7a, 0x7b, 0x7, 0x2a, + 0x2, 0x2, 0x7b, 0x24, 0x3, 0x2, 0x2, 0x2, 0x7c, 0x7d, 0x7, 0x2b, + 0x2, 0x2, 0x7d, 0x26, 0x3, 0x2, 0x2, 0x2, 0x7e, 0x7f, 0x7, 0x7d, + 0x2, 0x2, 0x7f, 0x80, 0x3, 0x2, 0x2, 0x2, 0x80, 0x81, 0x8, 0x13, + 0x2, 0x2, 0x81, 0x28, 0x3, 0x2, 0x2, 0x2, 0x82, 0x83, 0x7, 0x7f, + 0x2, 0x2, 0x83, 0x84, 0x3, 0x2, 0x2, 0x2, 0x84, 0x85, 0x8, 0x14, + 0x3, 0x2, 0x85, 0x2a, 0x3, 0x2, 0x2, 0x2, 0x86, 0x87, 0x7, 0x41, + 0x2, 0x2, 0x87, 0x2c, 0x3, 0x2, 0x2, 0x2, 0x88, 0x89, 0x7, 0x2e, + 0x2, 0x2, 0x89, 0x8a, 0x3, 0x2, 0x2, 0x2, 0x8a, 0x8b, 0x8, 0x16, + 0x4, 0x2, 0x8b, 0x2e, 0x3, 0x2, 0x2, 0x2, 0x8c, 0x8d, 0x7, 0x26, + 0x2, 0x2, 0x8d, 0x8e, 0x3, 0x2, 0x2, 0x2, 0x8e, 0x8f, 0x8, 0x17, + 0x5, 0x2, 0x8f, 0x90, 0x8, 0x17, 0x6, 0x2, 0x90, 0x30, 0x3, 0x2, + 0x2, 0x2, 0x91, 0x92, 0x7, 0x28, 0x2, 0x2, 0x92, 0x93, 0x3, 0x2, + 0x2, 0x2, 0x93, 0x94, 0x8, 0x18, 0x7, 0x2, 0x94, 0x32, 0x3, 0x2, + 0x2, 0x2, 0x95, 0x99, 0x7, 0x24, 0x2, 0x2, 0x96, 0x98, 0xb, 0x2, + 0x2, 0x2, 0x97, 0x96, 0x3, 0x2, 0x2, 0x2, 0x98, 0x9b, 0x3, 0x2, 0x2, + 0x2, 0x99, 0x9a, 0x3, 0x2, 0x2, 0x2, 0x99, 0x97, 0x3, 0x2, 0x2, 0x2, + 0x9a, 0x9c, 0x3, 0x2, 0x2, 0x2, 0x9b, 0x99, 0x3, 0x2, 0x2, 0x2, 0x9c, + 0x9d, 0x7, 0x24, 0x2, 0x2, 0x9d, 0x34, 0x3, 0x2, 0x2, 0x2, 0x9e, + 0x9f, 0x6, 0x1a, 0x2, 0x2, 0x9f, 0xa0, 0x7, 0x68, 0x2, 0x2, 0xa0, + 0xa1, 0x7, 0x71, 0x2, 0x2, 0xa1, 0xa2, 0x7, 0x71, 0x2, 0x2, 0xa2, + 0xa3, 0x3, 0x2, 0x2, 0x2, 0xa3, 0xa4, 0x6, 0x1a, 0x3, 0x2, 0xa4, + 0xa5, 0x8, 0x1a, 0x8, 0x2, 0xa5, 0x36, 0x3, 0x2, 0x2, 0x2, 0xa6, + 0xa7, 0x7, 0x64, 0x2, 0x2, 0xa7, 0xa8, 0x7, 0x63, 0x2, 0x2, 0xa8, + 0xa9, 0x7, 0x74, 0x2, 0x2, 0xa9, 0xaa, 0x3, 0x2, 0x2, 0x2, 0xaa, + 0xab, 0x6, 0x1b, 0x4, 0x2, 0xab, 0xac, 0x8, 0x1b, 0x9, 0x2, 0xac, + 0x38, 0x3, 0x2, 0x2, 0x2, 0xad, 0xae, 0x5, 0x35, 0x1a, 0x2, 0xae, + 0xb0, 0x5, 0x41, 0x20, 0x2, 0xaf, 0xb1, 0x5, 0x37, 0x1b, 0x2, 0xb0, + 0xaf, 0x3, 0x2, 0x2, 0x2, 0xb0, 0xb1, 0x3, 0x2, 0x2, 0x2, 0xb1, 0xb2, + 0x3, 0x2, 0x2, 0x2, 0xb2, 0xb3, 0x5, 0x43, 0x21, 0x2, 0xb3, 0xb4, + 0x5, 0x3f, 0x1f, 0x2, 0xb4, 0x3a, 0x3, 0x2, 0x2, 0x2, 0xb5, 0xb9, + 0x7, 0x25, 0x2, 0x2, 0xb6, 0xb8, 0xa, 0x3, 0x2, 0x2, 0xb7, 0xb6, + 0x3, 0x2, 0x2, 0x2, 0xb8, 0xbb, 0x3, 0x2, 0x2, 0x2, 0xb9, 0xb7, 0x3, + 0x2, 0x2, 0x2, 0xb9, 0xba, 0x3, 0x2, 0x2, 0x2, 0xba, 0xbd, 0x3, 0x2, + 0x2, 0x2, 0xbb, 0xb9, 0x3, 0x2, 0x2, 0x2, 0xbc, 0xbe, 0x7, 0xf, 0x2, + 0x2, 0xbd, 0xbc, 0x3, 0x2, 0x2, 0x2, 0xbd, 0xbe, 0x3, 0x2, 0x2, 0x2, + 0xbe, 0xbf, 0x3, 0x2, 0x2, 0x2, 0xbf, 0xc0, 0x7, 0xc, 0x2, 0x2, 0xc0, + 0xc1, 0x3, 0x2, 0x2, 0x2, 0xc1, 0xc2, 0x8, 0x1d, 0xa, 0x2, 0xc2, + 0x3c, 0x3, 0x2, 0x2, 0x2, 0xc3, 0xc5, 0x9, 0x4, 0x2, 0x2, 0xc4, 0xc3, + 0x3, 0x2, 0x2, 0x2, 0xc5, 0xc6, 0x3, 0x2, 0x2, 0x2, 0xc6, 0xc4, 0x3, + 0x2, 0x2, 0x2, 0xc6, 0xc7, 0x3, 0x2, 0x2, 0x2, 0xc7, 0xc8, 0x3, 0x2, + 0x2, 0x2, 0xc8, 0xc9, 0x8, 0x1e, 0xb, 0x2, 0xc9, 0x3e, 0x3, 0x2, + 0x2, 0x2, 0xca, 0xcb, 0x7, 0x44, 0x2, 0x2, 0xcb, 0xcc, 0x7, 0x63, + 0x2, 0x2, 0xcc, 0xcd, 0x7, 0x7c, 0x2, 0x2, 0xcd, 0x40, 0x3, 0x2, + 0x2, 0x2, 0xce, 0xcf, 0x7, 0x30, 0x2, 0x2, 0xcf, 0x42, 0x3, 0x2, + 0x2, 0x2, 0xd0, 0xd1, 0x7, 0x30, 0x2, 0x2, 0xd1, 0xd2, 0x7, 0x30, + 0x2, 0x2, 0xd2, 0x44, 0x3, 0x2, 0x2, 0x2, 0xd, 0x2, 0x3, 0x4, 0x58, + 0x5f, 0x61, 0x99, 0xb0, 0xb9, 0xbd, 0xc6, 0xc, 0x7, 0x3, 0x2, 0x6, + 0x2, 0x2, 0x8, 0x2, 0x2, 0x5, 0x2, 0x2, 0x4, 0x3, 0x2, 0x9, 0x3, + 0x2, 0x3, 0x1a, 0x2, 0x3, 0x1b, 0x3, 0x2, 0x4, 0x2, 0x2, 0x65, 0x2, + }; + + _serializedATN.insert(_serializedATN.end(), serializedATNSegment0, + serializedATNSegment0 + sizeof(serializedATNSegment0) / sizeof(serializedATNSegment0[0])); + + + atn::ATNDeserializer deserializer; + _atn = deserializer.deserialize(_serializedATN); + + size_t count = _atn.getNumberOfDecisions(); + _decisionToDFA.reserve(count); + for (size_t i = 0; i < count; i++) { + _decisionToDFA.emplace_back(_atn.getDecisionState(i), i); + } +} + +TLexer::Initializer TLexer::_init; diff --git a/antlr/antlr4-runtime/demo/generated/TLexer.h b/antlr/antlr4-runtime/demo/generated/TLexer.h new file mode 100644 index 0000000..fb067ca --- /dev/null +++ b/antlr/antlr4-runtime/demo/generated/TLexer.h @@ -0,0 +1,96 @@ +/* lexer header section */ + +// Generated from /home/xsu/workspace/sysy/sysy/antlr/antlr4-runtime/demo/TLexer.g4 by ANTLR 4.9.3 + +#pragma once + +/* lexer precinclude section */ + +#include "antlr4-runtime.h" + + +/* lexer postinclude section */ +#ifndef _WIN32 +#pragma GCC diagnostic ignored "-Wunused-parameter" +#endif + + +namespace antlrcpptest { + +/* lexer context section */ + +class TLexer : public antlr4::Lexer { +public: + enum { + DUMMY = 1, Return = 2, Continue = 3, INT = 4, Digit = 5, ID = 6, LessThan = 7, + GreaterThan = 8, Equal = 9, And = 10, Colon = 11, Semicolon = 12, Plus = 13, + Minus = 14, Star = 15, OpenPar = 16, ClosePar = 17, OpenCurly = 18, + CloseCurly = 19, QuestionMark = 20, Comma = 21, String = 22, Foo = 23, + Bar = 24, Any = 25, Comment = 26, WS = 27, Dot = 28, DotDot = 29, Dollar = 30, + Ampersand = 31 + }; + + enum { + CommentsChannel = 2, DirectiveChannel = 3 + }; + + enum { + Mode1 = 1, Mode2 = 2 + }; + + explicit TLexer(antlr4::CharStream *input); + ~TLexer(); + + /* public lexer declarations section */ + bool canTestFoo() { return true; } + bool isItFoo() { return true; } + bool isItBar() { return true; } + + void myFooLexerAction() { /* do something*/ }; + void myBarLexerAction() { /* do something*/ }; + + virtual std::string getGrammarFileName() const override; + virtual const std::vector& getRuleNames() const override; + + virtual const std::vector& getChannelNames() const override; + virtual const std::vector& getModeNames() const override; + virtual const std::vector& getTokenNames() const override; // deprecated, use vocabulary instead + virtual antlr4::dfa::Vocabulary& getVocabulary() const override; + + virtual const std::vector getSerializedATN() const override; + virtual const antlr4::atn::ATN& getATN() const override; + + virtual void action(antlr4::RuleContext *context, size_t ruleIndex, size_t actionIndex) override; + virtual bool sempred(antlr4::RuleContext *_localctx, size_t ruleIndex, size_t predicateIndex) override; + +private: + static std::vector _decisionToDFA; + static antlr4::atn::PredictionContextCache _sharedContextCache; + static std::vector _ruleNames; + static std::vector _tokenNames; + static std::vector _channelNames; + static std::vector _modeNames; + + static std::vector _literalNames; + static std::vector _symbolicNames; + static antlr4::dfa::Vocabulary _vocabulary; + static antlr4::atn::ATN _atn; + static std::vector _serializedATN; + + /* private lexer declarations/members section */ + + // Individual action functions triggered by action() above. + void FooAction(antlr4::RuleContext *context, size_t actionIndex); + void BarAction(antlr4::RuleContext *context, size_t actionIndex); + + // Individual semantic predicate functions triggered by sempred() above. + bool FooSempred(antlr4::RuleContext *_localctx, size_t predicateIndex); + bool BarSempred(antlr4::RuleContext *_localctx, size_t predicateIndex); + + struct Initializer { + Initializer(); + }; + static Initializer _init; +}; + +} // namespace antlrcpptest diff --git a/antlr/antlr4-runtime/demo/generated/TLexer.interp b/antlr/antlr4-runtime/demo/generated/TLexer.interp new file mode 100644 index 0000000..87a8c09 --- /dev/null +++ b/antlr/antlr4-runtime/demo/generated/TLexer.interp @@ -0,0 +1,117 @@ +token literal names: +null +null +'return' +'continue' +null +null +null +'<' +'>' +'=' +'and' +':' +';' +'+' +'-' +'*' +'(' +')' +'{' +'}' +'?' +',' +null +null +null +null +null +null +'.' +'..' +'$' +'&' + +token symbolic names: +null +DUMMY +Return +Continue +INT +Digit +ID +LessThan +GreaterThan +Equal +And +Colon +Semicolon +Plus +Minus +Star +OpenPar +ClosePar +OpenCurly +CloseCurly +QuestionMark +Comma +String +Foo +Bar +Any +Comment +WS +Dot +DotDot +Dollar +Ampersand + +rule names: +Return +Continue +INT +Digit +ID +LETTER +LessThan +GreaterThan +Equal +And +Colon +Semicolon +Plus +Minus +Star +OpenPar +ClosePar +OpenCurly +CloseCurly +QuestionMark +Comma +Dollar +Ampersand +String +Foo +Bar +Any +Comment +WS +Baz +Dot +DotDot + +channel names: +DEFAULT_TOKEN_CHANNEL +HIDDEN +null +null +CommentsChannel +DirectiveChannel + +mode names: +DEFAULT_MODE +Mode1 +Mode2 + +atn: +[3, 24715, 42794, 33075, 47597, 16764, 15335, 30598, 22884, 2, 33, 211, 8, 1, 8, 1, 8, 1, 4, 2, 9, 2, 4, 3, 9, 3, 4, 4, 9, 4, 4, 5, 9, 5, 4, 6, 9, 6, 4, 7, 9, 7, 4, 8, 9, 8, 4, 9, 9, 9, 4, 10, 9, 10, 4, 11, 9, 11, 4, 12, 9, 12, 4, 13, 9, 13, 4, 14, 9, 14, 4, 15, 9, 15, 4, 16, 9, 16, 4, 17, 9, 17, 4, 18, 9, 18, 4, 19, 9, 19, 4, 20, 9, 20, 4, 21, 9, 21, 4, 22, 9, 22, 4, 23, 9, 23, 4, 24, 9, 24, 4, 25, 9, 25, 4, 26, 9, 26, 4, 27, 9, 27, 4, 28, 9, 28, 4, 29, 9, 29, 4, 30, 9, 30, 4, 31, 9, 31, 4, 32, 9, 32, 4, 33, 9, 33, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 6, 4, 87, 10, 4, 13, 4, 14, 4, 88, 3, 5, 3, 5, 3, 6, 3, 6, 3, 6, 7, 6, 96, 10, 6, 12, 6, 14, 6, 99, 11, 6, 3, 7, 3, 7, 3, 8, 3, 8, 3, 9, 3, 9, 3, 10, 3, 10, 3, 11, 3, 11, 3, 11, 3, 11, 3, 12, 3, 12, 3, 13, 3, 13, 3, 14, 3, 14, 3, 15, 3, 15, 3, 16, 3, 16, 3, 17, 3, 17, 3, 18, 3, 18, 3, 19, 3, 19, 3, 19, 3, 19, 3, 20, 3, 20, 3, 20, 3, 20, 3, 21, 3, 21, 3, 22, 3, 22, 3, 22, 3, 22, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 24, 3, 24, 3, 24, 3, 24, 3, 25, 3, 25, 7, 25, 152, 10, 25, 12, 25, 14, 25, 155, 11, 25, 3, 25, 3, 25, 3, 26, 3, 26, 3, 26, 3, 26, 3, 26, 3, 26, 3, 26, 3, 26, 3, 27, 3, 27, 3, 27, 3, 27, 3, 27, 3, 27, 3, 27, 3, 28, 3, 28, 3, 28, 5, 28, 177, 10, 28, 3, 28, 3, 28, 3, 28, 3, 29, 3, 29, 7, 29, 184, 10, 29, 12, 29, 14, 29, 187, 11, 29, 3, 29, 5, 29, 190, 10, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 30, 6, 30, 197, 10, 30, 13, 30, 14, 30, 198, 3, 30, 3, 30, 3, 31, 3, 31, 3, 31, 3, 31, 3, 32, 3, 32, 3, 33, 3, 33, 3, 33, 3, 153, 2, 34, 5, 4, 7, 5, 9, 6, 11, 7, 13, 8, 15, 2, 17, 9, 19, 10, 21, 11, 23, 12, 25, 13, 27, 14, 29, 15, 31, 16, 33, 17, 35, 18, 37, 19, 39, 20, 41, 21, 43, 22, 45, 23, 47, 32, 49, 33, 51, 24, 53, 25, 55, 26, 57, 27, 59, 28, 61, 29, 63, 2, 65, 30, 67, 31, 5, 2, 3, 4, 5, 3, 2, 50, 59, 4, 2, 12, 12, 15, 15, 5, 2, 11, 12, 15, 15, 34, 34, 3, 5, 2, 67, 2, 92, 2, 99, 2, 124, 2, 130, 2, 1, 18, 214, 2, 5, 3, 2, 2, 2, 2, 7, 3, 2, 2, 2, 2, 9, 3, 2, 2, 2, 2, 11, 3, 2, 2, 2, 2, 13, 3, 2, 2, 2, 2, 17, 3, 2, 2, 2, 2, 19, 3, 2, 2, 2, 2, 21, 3, 2, 2, 2, 2, 23, 3, 2, 2, 2, 2, 25, 3, 2, 2, 2, 2, 27, 3, 2, 2, 2, 2, 29, 3, 2, 2, 2, 2, 31, 3, 2, 2, 2, 2, 33, 3, 2, 2, 2, 2, 35, 3, 2, 2, 2, 2, 37, 3, 2, 2, 2, 2, 39, 3, 2, 2, 2, 2, 41, 3, 2, 2, 2, 2, 43, 3, 2, 2, 2, 2, 45, 3, 2, 2, 2, 2, 47, 3, 2, 2, 2, 2, 49, 3, 2, 2, 2, 2, 51, 3, 2, 2, 2, 2, 53, 3, 2, 2, 2, 2, 55, 3, 2, 2, 2, 2, 57, 3, 2, 2, 2, 2, 59, 3, 2, 2, 2, 2, 61, 3, 2, 2, 2, 3, 65, 3, 2, 2, 2, 4, 67, 3, 2, 2, 2, 5, 69, 3, 2, 2, 2, 7, 76, 3, 2, 2, 2, 9, 86, 3, 2, 2, 2, 11, 90, 3, 2, 2, 2, 13, 92, 3, 2, 2, 2, 15, 100, 3, 2, 2, 2, 17, 102, 3, 2, 2, 2, 19, 104, 3, 2, 2, 2, 21, 106, 3, 2, 2, 2, 23, 108, 3, 2, 2, 2, 25, 112, 3, 2, 2, 2, 27, 114, 3, 2, 2, 2, 29, 116, 3, 2, 2, 2, 31, 118, 3, 2, 2, 2, 33, 120, 3, 2, 2, 2, 35, 122, 3, 2, 2, 2, 37, 124, 3, 2, 2, 2, 39, 126, 3, 2, 2, 2, 41, 130, 3, 2, 2, 2, 43, 134, 3, 2, 2, 2, 45, 136, 3, 2, 2, 2, 47, 140, 3, 2, 2, 2, 49, 145, 3, 2, 2, 2, 51, 149, 3, 2, 2, 2, 53, 158, 3, 2, 2, 2, 55, 166, 3, 2, 2, 2, 57, 173, 3, 2, 2, 2, 59, 181, 3, 2, 2, 2, 61, 196, 3, 2, 2, 2, 63, 202, 3, 2, 2, 2, 65, 206, 3, 2, 2, 2, 67, 208, 3, 2, 2, 2, 69, 70, 7, 116, 2, 2, 70, 71, 7, 103, 2, 2, 71, 72, 7, 118, 2, 2, 72, 73, 7, 119, 2, 2, 73, 74, 7, 116, 2, 2, 74, 75, 7, 112, 2, 2, 75, 6, 3, 2, 2, 2, 76, 77, 7, 101, 2, 2, 77, 78, 7, 113, 2, 2, 78, 79, 7, 112, 2, 2, 79, 80, 7, 118, 2, 2, 80, 81, 7, 107, 2, 2, 81, 82, 7, 112, 2, 2, 82, 83, 7, 119, 2, 2, 83, 84, 7, 103, 2, 2, 84, 8, 3, 2, 2, 2, 85, 87, 5, 11, 5, 2, 86, 85, 3, 2, 2, 2, 87, 88, 3, 2, 2, 2, 88, 86, 3, 2, 2, 2, 88, 89, 3, 2, 2, 2, 89, 10, 3, 2, 2, 2, 90, 91, 9, 2, 2, 2, 91, 12, 3, 2, 2, 2, 92, 97, 5, 15, 7, 2, 93, 96, 5, 15, 7, 2, 94, 96, 4, 50, 59, 2, 95, 93, 3, 2, 2, 2, 95, 94, 3, 2, 2, 2, 96, 99, 3, 2, 2, 2, 97, 95, 3, 2, 2, 2, 97, 98, 3, 2, 2, 2, 98, 14, 3, 2, 2, 2, 99, 97, 3, 2, 2, 2, 100, 101, 9, 5, 2, 2, 101, 16, 3, 2, 2, 2, 102, 103, 7, 62, 2, 2, 103, 18, 3, 2, 2, 2, 104, 105, 7, 64, 2, 2, 105, 20, 3, 2, 2, 2, 106, 107, 7, 63, 2, 2, 107, 22, 3, 2, 2, 2, 108, 109, 7, 99, 2, 2, 109, 110, 7, 112, 2, 2, 110, 111, 7, 102, 2, 2, 111, 24, 3, 2, 2, 2, 112, 113, 7, 60, 2, 2, 113, 26, 3, 2, 2, 2, 114, 115, 7, 61, 2, 2, 115, 28, 3, 2, 2, 2, 116, 117, 7, 45, 2, 2, 117, 30, 3, 2, 2, 2, 118, 119, 7, 47, 2, 2, 119, 32, 3, 2, 2, 2, 120, 121, 7, 44, 2, 2, 121, 34, 3, 2, 2, 2, 122, 123, 7, 42, 2, 2, 123, 36, 3, 2, 2, 2, 124, 125, 7, 43, 2, 2, 125, 38, 3, 2, 2, 2, 126, 127, 7, 125, 2, 2, 127, 128, 3, 2, 2, 2, 128, 129, 8, 19, 2, 2, 129, 40, 3, 2, 2, 2, 130, 131, 7, 127, 2, 2, 131, 132, 3, 2, 2, 2, 132, 133, 8, 20, 3, 2, 133, 42, 3, 2, 2, 2, 134, 135, 7, 65, 2, 2, 135, 44, 3, 2, 2, 2, 136, 137, 7, 46, 2, 2, 137, 138, 3, 2, 2, 2, 138, 139, 8, 22, 4, 2, 139, 46, 3, 2, 2, 2, 140, 141, 7, 38, 2, 2, 141, 142, 3, 2, 2, 2, 142, 143, 8, 23, 5, 2, 143, 144, 8, 23, 6, 2, 144, 48, 3, 2, 2, 2, 145, 146, 7, 40, 2, 2, 146, 147, 3, 2, 2, 2, 147, 148, 8, 24, 7, 2, 148, 50, 3, 2, 2, 2, 149, 153, 7, 36, 2, 2, 150, 152, 11, 2, 2, 2, 151, 150, 3, 2, 2, 2, 152, 155, 3, 2, 2, 2, 153, 154, 3, 2, 2, 2, 153, 151, 3, 2, 2, 2, 154, 156, 3, 2, 2, 2, 155, 153, 3, 2, 2, 2, 156, 157, 7, 36, 2, 2, 157, 52, 3, 2, 2, 2, 158, 159, 6, 26, 2, 2, 159, 160, 7, 104, 2, 2, 160, 161, 7, 113, 2, 2, 161, 162, 7, 113, 2, 2, 162, 163, 3, 2, 2, 2, 163, 164, 6, 26, 3, 2, 164, 165, 8, 26, 8, 2, 165, 54, 3, 2, 2, 2, 166, 167, 7, 100, 2, 2, 167, 168, 7, 99, 2, 2, 168, 169, 7, 116, 2, 2, 169, 170, 3, 2, 2, 2, 170, 171, 6, 27, 4, 2, 171, 172, 8, 27, 9, 2, 172, 56, 3, 2, 2, 2, 173, 174, 5, 53, 26, 2, 174, 176, 5, 65, 32, 2, 175, 177, 5, 55, 27, 2, 176, 175, 3, 2, 2, 2, 176, 177, 3, 2, 2, 2, 177, 178, 3, 2, 2, 2, 178, 179, 5, 67, 33, 2, 179, 180, 5, 63, 31, 2, 180, 58, 3, 2, 2, 2, 181, 185, 7, 37, 2, 2, 182, 184, 10, 3, 2, 2, 183, 182, 3, 2, 2, 2, 184, 187, 3, 2, 2, 2, 185, 183, 3, 2, 2, 2, 185, 186, 3, 2, 2, 2, 186, 189, 3, 2, 2, 2, 187, 185, 3, 2, 2, 2, 188, 190, 7, 15, 2, 2, 189, 188, 3, 2, 2, 2, 189, 190, 3, 2, 2, 2, 190, 191, 3, 2, 2, 2, 191, 192, 7, 12, 2, 2, 192, 193, 3, 2, 2, 2, 193, 194, 8, 29, 10, 2, 194, 60, 3, 2, 2, 2, 195, 197, 9, 4, 2, 2, 196, 195, 3, 2, 2, 2, 197, 198, 3, 2, 2, 2, 198, 196, 3, 2, 2, 2, 198, 199, 3, 2, 2, 2, 199, 200, 3, 2, 2, 2, 200, 201, 8, 30, 11, 2, 201, 62, 3, 2, 2, 2, 202, 203, 7, 68, 2, 2, 203, 204, 7, 99, 2, 2, 204, 205, 7, 124, 2, 2, 205, 64, 3, 2, 2, 2, 206, 207, 7, 48, 2, 2, 207, 66, 3, 2, 2, 2, 208, 209, 7, 48, 2, 2, 209, 210, 7, 48, 2, 2, 210, 68, 3, 2, 2, 2, 13, 2, 3, 4, 88, 95, 97, 153, 176, 185, 189, 198, 12, 7, 3, 2, 6, 2, 2, 8, 2, 2, 5, 2, 2, 4, 3, 2, 9, 3, 2, 3, 26, 2, 3, 27, 3, 2, 4, 2, 2, 101, 2] \ No newline at end of file diff --git a/antlr/antlr4-runtime/demo/generated/TLexer.tokens b/antlr/antlr4-runtime/demo/generated/TLexer.tokens new file mode 100644 index 0000000..aac0d44 --- /dev/null +++ b/antlr/antlr4-runtime/demo/generated/TLexer.tokens @@ -0,0 +1,52 @@ +DUMMY=1 +Return=2 +Continue=3 +INT=4 +Digit=5 +ID=6 +LessThan=7 +GreaterThan=8 +Equal=9 +And=10 +Colon=11 +Semicolon=12 +Plus=13 +Minus=14 +Star=15 +OpenPar=16 +ClosePar=17 +OpenCurly=18 +CloseCurly=19 +QuestionMark=20 +Comma=21 +String=22 +Foo=23 +Bar=24 +Any=25 +Comment=26 +WS=27 +Dot=28 +DotDot=29 +Dollar=30 +Ampersand=31 +'return'=2 +'continue'=3 +'<'=7 +'>'=8 +'='=9 +'and'=10 +':'=11 +';'=12 +'+'=13 +'-'=14 +'*'=15 +'('=16 +')'=17 +'{'=18 +'}'=19 +'?'=20 +','=21 +'$'=30 +'&'=31 +'.'=28 +'..'=29 diff --git a/antlr/antlr4-runtime/demo/generated/TParser.cpp b/antlr/antlr4-runtime/demo/generated/TParser.cpp new file mode 100644 index 0000000..70dea93 --- /dev/null +++ b/antlr/antlr4-runtime/demo/generated/TParser.cpp @@ -0,0 +1,1604 @@ +/* parser/listener/visitor header section */ + +// Generated from /home/xsu/workspace/sysy/sysy/antlr/antlr4-runtime/demo/TParser.g4 by ANTLR 4.9.3 + +/* parser precinclude section */ + +#include "TParserListener.h" +#include "TParserVisitor.h" + +#include "TParser.h" + + +/* parser postinclude section */ +#ifndef _WIN32 +#pragma GCC diagnostic ignored "-Wunused-parameter" +#endif + + +using namespace antlrcpp; +using namespace antlrcpptest; +using namespace antlr4; + +TParser::TParser(TokenStream *input) : Parser(input) { + _interpreter = new atn::ParserATNSimulator(this, _atn, _decisionToDFA, _sharedContextCache); +} + +TParser::~TParser() { + delete _interpreter; +} + +std::string TParser::getGrammarFileName() const { + return "TParser.g4"; +} + +const std::vector& TParser::getRuleNames() const { + return _ruleNames; +} + +dfa::Vocabulary& TParser::getVocabulary() const { + return _vocabulary; +} + +/* parser definitions section */ + +//----------------- MainContext ------------------------------------------------------------------ + +TParser::MainContext::MainContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* TParser::MainContext::EOF() { + return getToken(TParser::EOF, 0); +} + +std::vector TParser::MainContext::stat() { + return getRuleContexts(); +} + +TParser::StatContext* TParser::MainContext::stat(size_t i) { + return getRuleContext(i); +} + + +size_t TParser::MainContext::getRuleIndex() const { + return TParser::RuleMain; +} + +void TParser::MainContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterMain(this); +} + +void TParser::MainContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitMain(this); +} + + +antlrcpp::Any TParser::MainContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitMain(this); + else + return visitor->visitChildren(this); +} + +TParser::MainContext* TParser::main() { + MainContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 0, TParser::RuleMain); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(27); + _errHandler->sync(this); + _la = _input->LA(1); + do { + setState(26); + stat(); + setState(29); + _errHandler->sync(this); + _la = _input->LA(1); + } while ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & ((1ULL << TParser::Return) + | (1ULL << TParser::Continue) + | (1ULL << TParser::INT) + | (1ULL << TParser::ID) + | (1ULL << TParser::OpenPar) + | (1ULL << TParser::String))) != 0)); + setState(31); + match(TParser::EOF); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- DivideContext ------------------------------------------------------------------ + +TParser::DivideContext::DivideContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* TParser::DivideContext::ID() { + return getToken(TParser::ID, 0); +} + +TParser::And_Context* TParser::DivideContext::and_() { + return getRuleContext(0); +} + +tree::TerminalNode* TParser::DivideContext::GreaterThan() { + return getToken(TParser::GreaterThan, 0); +} + + +size_t TParser::DivideContext::getRuleIndex() const { + return TParser::RuleDivide; +} + +void TParser::DivideContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterDivide(this); +} + +void TParser::DivideContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitDivide(this); +} + + +antlrcpp::Any TParser::DivideContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitDivide(this); + else + return visitor->visitChildren(this); +} + +TParser::DivideContext* TParser::divide() { + DivideContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 2, TParser::RuleDivide); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(33); + match(TParser::ID); + setState(37); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 1, _ctx)) { + case 1: { + setState(34); + and_(); + setState(35); + match(TParser::GreaterThan); + break; + } + + default: + break; + } + setState(39); + + if (!(doesItBlend())) throw FailedPredicateException(this, "doesItBlend()"); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- And_Context ------------------------------------------------------------------ + +TParser::And_Context::And_Context(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* TParser::And_Context::And() { + return getToken(TParser::And, 0); +} + + +size_t TParser::And_Context::getRuleIndex() const { + return TParser::RuleAnd_; +} + +void TParser::And_Context::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterAnd_(this); +} + +void TParser::And_Context::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitAnd_(this); +} + + +antlrcpp::Any TParser::And_Context::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitAnd_(this); + else + return visitor->visitChildren(this); +} + +TParser::And_Context* TParser::and_() { + And_Context *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 4, TParser::RuleAnd_); + doInit(); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(41); + match(TParser::And); + _ctx->stop = _input->LT(-1); + doAfter(); + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ConquerContext ------------------------------------------------------------------ + +TParser::ConquerContext::ConquerContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector TParser::ConquerContext::divide() { + return getRuleContexts(); +} + +TParser::DivideContext* TParser::ConquerContext::divide(size_t i) { + return getRuleContext(i); +} + +TParser::And_Context* TParser::ConquerContext::and_() { + return getRuleContext(0); +} + +tree::TerminalNode* TParser::ConquerContext::ID() { + return getToken(TParser::ID, 0); +} + +std::vector TParser::ConquerContext::LessThan() { + return getTokens(TParser::LessThan); +} + +tree::TerminalNode* TParser::ConquerContext::LessThan(size_t i) { + return getToken(TParser::LessThan, i); +} + + +size_t TParser::ConquerContext::getRuleIndex() const { + return TParser::RuleConquer; +} + +void TParser::ConquerContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterConquer(this); +} + +void TParser::ConquerContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitConquer(this); +} + + +antlrcpp::Any TParser::ConquerContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitConquer(this); + else + return visitor->visitChildren(this); +} + +TParser::ConquerContext* TParser::conquer() { + ConquerContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 6, TParser::RuleConquer); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(63); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 5, _ctx)) { + case 1: { + enterOuterAlt(_localctx, 1); + setState(44); + _errHandler->sync(this); + _la = _input->LA(1); + do { + setState(43); + divide(); + setState(46); + _errHandler->sync(this); + _la = _input->LA(1); + } while (_la == TParser::ID); + break; + } + + case 2: { + enterOuterAlt(_localctx, 2); + setState(48); + + if (!(doesItBlend())) throw FailedPredicateException(this, "doesItBlend()"); + setState(49); + and_(); + myAction(); + break; + } + + case 3: { + enterOuterAlt(_localctx, 3); + setState(52); + antlrcpp::downCast(_localctx)->idToken = match(TParser::ID); + setState(60); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 4, _ctx)) { + case 1 + 1: { + setState(56); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == TParser::LessThan) { + setState(53); + match(TParser::LessThan); + setState(58); + _errHandler->sync(this); + _la = _input->LA(1); + } + setState(59); + divide(); + break; + } + + default: + break; + } + (antlrcpp::downCast(_localctx)->idToken != nullptr ? antlrcpp::downCast(_localctx)->idToken->getText() : ""); + break; + } + + default: + break; + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- UnusedContext ------------------------------------------------------------------ + +TParser::UnusedContext::UnusedContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +TParser::UnusedContext::UnusedContext(ParserRuleContext *parent, size_t invokingState, double input) + : ParserRuleContext(parent, invokingState) { + this->input = input; +} + +TParser::StatContext* TParser::UnusedContext::stat() { + return getRuleContext(0); +} + + +size_t TParser::UnusedContext::getRuleIndex() const { + return TParser::RuleUnused; +} + +void TParser::UnusedContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterUnused(this); +} + +void TParser::UnusedContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitUnused(this); +} + + +antlrcpp::Any TParser::UnusedContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitUnused(this); + else + return visitor->visitChildren(this); +} + +TParser::UnusedContext* TParser::unused(double input) { + UnusedContext *_localctx = _tracker.createInstance(_ctx, getState(), input); + enterRule(_localctx, 8, TParser::RuleUnused); + doInit(); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + + cleanUp(); + + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(65); + stat(); + _ctx->stop = _input->LT(-1); + doAfter(); + } + catch (...) { + + // Replaces the standard exception handling. + + } + return _localctx; +} + +//----------------- Unused2Context ------------------------------------------------------------------ + +TParser::Unused2Context::Unused2Context(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector TParser::Unused2Context::Semicolon() { + return getTokens(TParser::Semicolon); +} + +tree::TerminalNode* TParser::Unused2Context::Semicolon(size_t i) { + return getToken(TParser::Semicolon, i); +} + +std::vector TParser::Unused2Context::unused() { + return getRuleContexts(); +} + +TParser::UnusedContext* TParser::Unused2Context::unused(size_t i) { + return getRuleContext(i); +} + +tree::TerminalNode* TParser::Unused2Context::Colon() { + return getToken(TParser::Colon, 0); +} + +tree::TerminalNode* TParser::Unused2Context::Plus() { + return getToken(TParser::Plus, 0); +} + + +size_t TParser::Unused2Context::getRuleIndex() const { + return TParser::RuleUnused2; +} + +void TParser::Unused2Context::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterUnused2(this); +} + +void TParser::Unused2Context::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitUnused2(this); +} + + +antlrcpp::Any TParser::Unused2Context::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitUnused2(this); + else + return visitor->visitChildren(this); +} + +TParser::Unused2Context* TParser::unused2() { + Unused2Context *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 10, TParser::RuleUnused2); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + size_t alt; + enterOuterAlt(_localctx, 1); + setState(70); + _errHandler->sync(this); + alt = 1; + do { + switch (alt) { + case 1: { + setState(67); + unused(1); + setState(68); + matchWildcard(); + break; + } + + default: + throw NoViableAltException(this); + } + setState(72); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 6, _ctx); + } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER); + setState(75); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 7, _ctx)) { + case 1: { + setState(74); + _la = _input->LA(1); + if (!((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & ((1ULL << TParser::Colon) + | (1ULL << TParser::Semicolon) + | (1ULL << TParser::Plus))) != 0))) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + break; + } + + default: + break; + } + setState(77); + _la = _input->LA(1); + if (_la == 0 || _la == Token::EOF || (_la == TParser::Semicolon)) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- StatContext ------------------------------------------------------------------ + +TParser::StatContext::StatContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector TParser::StatContext::expr() { + return getRuleContexts(); +} + +TParser::ExprContext* TParser::StatContext::expr(size_t i) { + return getRuleContext(i); +} + +tree::TerminalNode* TParser::StatContext::Equal() { + return getToken(TParser::Equal, 0); +} + +tree::TerminalNode* TParser::StatContext::Semicolon() { + return getToken(TParser::Semicolon, 0); +} + + +size_t TParser::StatContext::getRuleIndex() const { + return TParser::RuleStat; +} + +void TParser::StatContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterStat(this); +} + +void TParser::StatContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitStat(this); +} + + +antlrcpp::Any TParser::StatContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitStat(this); + else + return visitor->visitChildren(this); +} + +TParser::StatContext* TParser::stat() { + StatContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 12, TParser::RuleStat); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(87); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 8, _ctx)) { + case 1: { + enterOuterAlt(_localctx, 1); + setState(79); + expr(0); + setState(80); + match(TParser::Equal); + setState(81); + expr(0); + setState(82); + match(TParser::Semicolon); + break; + } + + case 2: { + enterOuterAlt(_localctx, 2); + setState(84); + expr(0); + setState(85); + match(TParser::Semicolon); + break; + } + + default: + break; + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ExprContext ------------------------------------------------------------------ + +TParser::ExprContext::ExprContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* TParser::ExprContext::OpenPar() { + return getToken(TParser::OpenPar, 0); +} + +std::vector TParser::ExprContext::expr() { + return getRuleContexts(); +} + +TParser::ExprContext* TParser::ExprContext::expr(size_t i) { + return getRuleContext(i); +} + +tree::TerminalNode* TParser::ExprContext::ClosePar() { + return getToken(TParser::ClosePar, 0); +} + +TParser::IdContext* TParser::ExprContext::id() { + return getRuleContext(0); +} + +TParser::FlowControlContext* TParser::ExprContext::flowControl() { + return getRuleContext(0); +} + +tree::TerminalNode* TParser::ExprContext::INT() { + return getToken(TParser::INT, 0); +} + +tree::TerminalNode* TParser::ExprContext::String() { + return getToken(TParser::String, 0); +} + +tree::TerminalNode* TParser::ExprContext::Star() { + return getToken(TParser::Star, 0); +} + +tree::TerminalNode* TParser::ExprContext::Plus() { + return getToken(TParser::Plus, 0); +} + +tree::TerminalNode* TParser::ExprContext::QuestionMark() { + return getToken(TParser::QuestionMark, 0); +} + +tree::TerminalNode* TParser::ExprContext::Colon() { + return getToken(TParser::Colon, 0); +} + +tree::TerminalNode* TParser::ExprContext::Equal() { + return getToken(TParser::Equal, 0); +} + + +size_t TParser::ExprContext::getRuleIndex() const { + return TParser::RuleExpr; +} + +void TParser::ExprContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterExpr(this); +} + +void TParser::ExprContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitExpr(this); +} + + +antlrcpp::Any TParser::ExprContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitExpr(this); + else + return visitor->visitChildren(this); +} + + +TParser::ExprContext* TParser::expr() { + return expr(0); +} + +TParser::ExprContext* TParser::expr(int precedence) { + ParserRuleContext *parentContext = _ctx; + size_t parentState = getState(); + TParser::ExprContext *_localctx = _tracker.createInstance(_ctx, parentState); + TParser::ExprContext *previousContext = _localctx; + (void)previousContext; // Silence compiler, in case the context is not used by generated code. + size_t startState = 14; + enterRecursionRule(_localctx, 14, TParser::RuleExpr, precedence); + + + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + unrollRecursionContexts(parentContext); + }); + try { + size_t alt; + enterOuterAlt(_localctx, 1); + setState(98); + _errHandler->sync(this); + switch (_input->LA(1)) { + case TParser::OpenPar: { + setState(90); + match(TParser::OpenPar); + setState(91); + expr(0); + setState(92); + match(TParser::ClosePar); + break; + } + + case TParser::ID: { + setState(94); + antlrcpp::downCast(_localctx)->identifier = id(); + break; + } + + case TParser::Return: + case TParser::Continue: { + setState(95); + flowControl(); + break; + } + + case TParser::INT: { + setState(96); + match(TParser::INT); + break; + } + + case TParser::String: { + setState(97); + match(TParser::String); + break; + } + + default: + throw NoViableAltException(this); + } + _ctx->stop = _input->LT(-1); + setState(117); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 11, _ctx); + while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { + if (alt == 1) { + if (!_parseListeners.empty()) + triggerExitRuleEvent(); + previousContext = _localctx; + setState(115); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 10, _ctx)) { + case 1: { + _localctx = _tracker.createInstance(parentContext, parentState); + pushNewRecursionContext(_localctx, startState, RuleExpr); + setState(100); + + if (!(precpred(_ctx, 9))) throw FailedPredicateException(this, "precpred(_ctx, 9)"); + setState(101); + match(TParser::Star); + setState(102); + expr(10); + break; + } + + case 2: { + _localctx = _tracker.createInstance(parentContext, parentState); + pushNewRecursionContext(_localctx, startState, RuleExpr); + setState(103); + + if (!(precpred(_ctx, 8))) throw FailedPredicateException(this, "precpred(_ctx, 8)"); + setState(104); + match(TParser::Plus); + setState(105); + expr(9); + break; + } + + case 3: { + _localctx = _tracker.createInstance(parentContext, parentState); + pushNewRecursionContext(_localctx, startState, RuleExpr); + setState(106); + + if (!(precpred(_ctx, 6))) throw FailedPredicateException(this, "precpred(_ctx, 6)"); + setState(107); + match(TParser::QuestionMark); + setState(108); + expr(0); + setState(109); + match(TParser::Colon); + setState(110); + expr(6); + break; + } + + case 4: { + _localctx = _tracker.createInstance(parentContext, parentState); + pushNewRecursionContext(_localctx, startState, RuleExpr); + setState(112); + + if (!(precpred(_ctx, 5))) throw FailedPredicateException(this, "precpred(_ctx, 5)"); + setState(113); + match(TParser::Equal); + setState(114); + expr(5); + break; + } + + default: + break; + } + } + setState(119); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 11, _ctx); + } + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + return _localctx; +} + +//----------------- FlowControlContext ------------------------------------------------------------------ + +TParser::FlowControlContext::FlowControlContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + + +size_t TParser::FlowControlContext::getRuleIndex() const { + return TParser::RuleFlowControl; +} + +void TParser::FlowControlContext::copyFrom(FlowControlContext *ctx) { + ParserRuleContext::copyFrom(ctx); +} + +//----------------- ReturnContext ------------------------------------------------------------------ + +tree::TerminalNode* TParser::ReturnContext::Return() { + return getToken(TParser::Return, 0); +} + +TParser::ExprContext* TParser::ReturnContext::expr() { + return getRuleContext(0); +} + +TParser::ReturnContext::ReturnContext(FlowControlContext *ctx) { copyFrom(ctx); } + +void TParser::ReturnContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterReturn(this); +} +void TParser::ReturnContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitReturn(this); +} + +antlrcpp::Any TParser::ReturnContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitReturn(this); + else + return visitor->visitChildren(this); +} +//----------------- ContinueContext ------------------------------------------------------------------ + +tree::TerminalNode* TParser::ContinueContext::Continue() { + return getToken(TParser::Continue, 0); +} + +TParser::ContinueContext::ContinueContext(FlowControlContext *ctx) { copyFrom(ctx); } + +void TParser::ContinueContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterContinue(this); +} +void TParser::ContinueContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitContinue(this); +} + +antlrcpp::Any TParser::ContinueContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitContinue(this); + else + return visitor->visitChildren(this); +} +TParser::FlowControlContext* TParser::flowControl() { + FlowControlContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 16, TParser::RuleFlowControl); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(123); + _errHandler->sync(this); + switch (_input->LA(1)) { + case TParser::Return: { + _localctx = _tracker.createInstance(_localctx); + enterOuterAlt(_localctx, 1); + setState(120); + match(TParser::Return); + setState(121); + expr(0); + break; + } + + case TParser::Continue: { + _localctx = _tracker.createInstance(_localctx); + enterOuterAlt(_localctx, 2); + setState(122); + match(TParser::Continue); + break; + } + + default: + throw NoViableAltException(this); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- IdContext ------------------------------------------------------------------ + +TParser::IdContext::IdContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* TParser::IdContext::ID() { + return getToken(TParser::ID, 0); +} + + +size_t TParser::IdContext::getRuleIndex() const { + return TParser::RuleId; +} + +void TParser::IdContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterId(this); +} + +void TParser::IdContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitId(this); +} + + +antlrcpp::Any TParser::IdContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitId(this); + else + return visitor->visitChildren(this); +} + +TParser::IdContext* TParser::id() { + IdContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 18, TParser::RuleId); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(125); + match(TParser::ID); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ArrayContext ------------------------------------------------------------------ + +TParser::ArrayContext::ArrayContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* TParser::ArrayContext::OpenCurly() { + return getToken(TParser::OpenCurly, 0); +} + +tree::TerminalNode* TParser::ArrayContext::CloseCurly() { + return getToken(TParser::CloseCurly, 0); +} + +std::vector TParser::ArrayContext::INT() { + return getTokens(TParser::INT); +} + +tree::TerminalNode* TParser::ArrayContext::INT(size_t i) { + return getToken(TParser::INT, i); +} + +std::vector TParser::ArrayContext::Comma() { + return getTokens(TParser::Comma); +} + +tree::TerminalNode* TParser::ArrayContext::Comma(size_t i) { + return getToken(TParser::Comma, i); +} + + +size_t TParser::ArrayContext::getRuleIndex() const { + return TParser::RuleArray; +} + +void TParser::ArrayContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterArray(this); +} + +void TParser::ArrayContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitArray(this); +} + + +antlrcpp::Any TParser::ArrayContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitArray(this); + else + return visitor->visitChildren(this); +} + +TParser::ArrayContext* TParser::array() { + ArrayContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 20, TParser::RuleArray); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(127); + match(TParser::OpenCurly); + setState(128); + antlrcpp::downCast(_localctx)->intToken = match(TParser::INT); + antlrcpp::downCast(_localctx)->el.push_back(antlrcpp::downCast(_localctx)->intToken); + setState(133); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == TParser::Comma) { + setState(129); + match(TParser::Comma); + setState(130); + antlrcpp::downCast(_localctx)->intToken = match(TParser::INT); + antlrcpp::downCast(_localctx)->el.push_back(antlrcpp::downCast(_localctx)->intToken); + setState(135); + _errHandler->sync(this); + _la = _input->LA(1); + } + setState(136); + match(TParser::CloseCurly); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- IdarrayContext ------------------------------------------------------------------ + +TParser::IdarrayContext::IdarrayContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* TParser::IdarrayContext::OpenCurly() { + return getToken(TParser::OpenCurly, 0); +} + +tree::TerminalNode* TParser::IdarrayContext::CloseCurly() { + return getToken(TParser::CloseCurly, 0); +} + +std::vector TParser::IdarrayContext::id() { + return getRuleContexts(); +} + +TParser::IdContext* TParser::IdarrayContext::id(size_t i) { + return getRuleContext(i); +} + +std::vector TParser::IdarrayContext::Comma() { + return getTokens(TParser::Comma); +} + +tree::TerminalNode* TParser::IdarrayContext::Comma(size_t i) { + return getToken(TParser::Comma, i); +} + + +size_t TParser::IdarrayContext::getRuleIndex() const { + return TParser::RuleIdarray; +} + +void TParser::IdarrayContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterIdarray(this); +} + +void TParser::IdarrayContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitIdarray(this); +} + + +antlrcpp::Any TParser::IdarrayContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitIdarray(this); + else + return visitor->visitChildren(this); +} + +TParser::IdarrayContext* TParser::idarray() { + IdarrayContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 22, TParser::RuleIdarray); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(138); + match(TParser::OpenCurly); + setState(139); + antlrcpp::downCast(_localctx)->idContext = id(); + antlrcpp::downCast(_localctx)->element.push_back(antlrcpp::downCast(_localctx)->idContext); + setState(144); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == TParser::Comma) { + setState(140); + match(TParser::Comma); + setState(141); + antlrcpp::downCast(_localctx)->idContext = id(); + antlrcpp::downCast(_localctx)->element.push_back(antlrcpp::downCast(_localctx)->idContext); + setState(146); + _errHandler->sync(this); + _la = _input->LA(1); + } + setState(147); + match(TParser::CloseCurly); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- AnyContext ------------------------------------------------------------------ + +TParser::AnyContext::AnyContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + + +size_t TParser::AnyContext::getRuleIndex() const { + return TParser::RuleAny; +} + +void TParser::AnyContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterAny(this); +} + +void TParser::AnyContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitAny(this); +} + + +antlrcpp::Any TParser::AnyContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitAny(this); + else + return visitor->visitChildren(this); +} + +TParser::AnyContext* TParser::any() { + AnyContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 24, TParser::RuleAny); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(149); + antlrcpp::downCast(_localctx)->t = matchWildcard(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +bool TParser::sempred(RuleContext *context, size_t ruleIndex, size_t predicateIndex) { + switch (ruleIndex) { + case 1: return divideSempred(antlrcpp::downCast(context), predicateIndex); + case 3: return conquerSempred(antlrcpp::downCast(context), predicateIndex); + case 7: return exprSempred(antlrcpp::downCast(context), predicateIndex); + + default: + break; + } + return true; +} + +bool TParser::divideSempred(DivideContext *_localctx, size_t predicateIndex) { + switch (predicateIndex) { + case 0: return doesItBlend(); + + default: + break; + } + return true; +} + +bool TParser::conquerSempred(ConquerContext *_localctx, size_t predicateIndex) { + switch (predicateIndex) { + case 1: return doesItBlend(); + + default: + break; + } + return true; +} + +bool TParser::exprSempred(ExprContext *_localctx, size_t predicateIndex) { + switch (predicateIndex) { + case 2: return precpred(_ctx, 9); + case 3: return precpred(_ctx, 8); + case 4: return precpred(_ctx, 6); + case 5: return precpred(_ctx, 5); + + default: + break; + } + return true; +} + +// Static vars and initialization. +std::vector TParser::_decisionToDFA; +atn::PredictionContextCache TParser::_sharedContextCache; + +// We own the ATN which in turn owns the ATN states. +atn::ATN TParser::_atn; +std::vector TParser::_serializedATN; + +std::vector TParser::_ruleNames = { + "main", "divide", "and_", "conquer", "unused", "unused2", "stat", "expr", + "flowControl", "id", "array", "idarray", "any" +}; + +std::vector TParser::_literalNames = { + "", "", "'return'", "'continue'", "", "", "", "'<'", "'>'", "'='", "'and'", + "':'", "';'", "'+'", "'-'", "'*'", "'('", "')'", "'{'", "'}'", "'\u003F'", + "','", "", "", "", "", "", "", "'.'", "'..'", "'$'", "'&'" +}; + +std::vector TParser::_symbolicNames = { + "", "DUMMY", "Return", "Continue", "INT", "Digit", "ID", "LessThan", "GreaterThan", + "Equal", "And", "Colon", "Semicolon", "Plus", "Minus", "Star", "OpenPar", + "ClosePar", "OpenCurly", "CloseCurly", "QuestionMark", "Comma", "String", + "Foo", "Bar", "Any", "Comment", "WS", "Dot", "DotDot", "Dollar", "Ampersand" +}; + +dfa::Vocabulary TParser::_vocabulary(_literalNames, _symbolicNames); + +std::vector TParser::_tokenNames; + +TParser::Initializer::Initializer() { + for (size_t i = 0; i < _symbolicNames.size(); ++i) { + std::string name = _vocabulary.getLiteralName(i); + if (name.empty()) { + name = _vocabulary.getSymbolicName(i); + } + + if (name.empty()) { + _tokenNames.push_back(""); + } else { + _tokenNames.push_back(name); + } + } + + static const uint16_t serializedATNSegment0[] = { + 0x3, 0x608b, 0xa72a, 0x8133, 0xb9ed, 0x417c, 0x3be7, 0x7786, 0x5964, + 0x3, 0x21, 0x9a, 0x4, 0x2, 0x9, 0x2, 0x4, 0x3, 0x9, 0x3, 0x4, 0x4, + 0x9, 0x4, 0x4, 0x5, 0x9, 0x5, 0x4, 0x6, 0x9, 0x6, 0x4, 0x7, 0x9, + 0x7, 0x4, 0x8, 0x9, 0x8, 0x4, 0x9, 0x9, 0x9, 0x4, 0xa, 0x9, 0xa, + 0x4, 0xb, 0x9, 0xb, 0x4, 0xc, 0x9, 0xc, 0x4, 0xd, 0x9, 0xd, 0x4, + 0xe, 0x9, 0xe, 0x3, 0x2, 0x6, 0x2, 0x1e, 0xa, 0x2, 0xd, 0x2, 0xe, + 0x2, 0x1f, 0x3, 0x2, 0x3, 0x2, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, + 0x3, 0x5, 0x3, 0x28, 0xa, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x4, 0x3, + 0x4, 0x3, 0x5, 0x6, 0x5, 0x2f, 0xa, 0x5, 0xd, 0x5, 0xe, 0x5, 0x30, + 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x7, + 0x5, 0x39, 0xa, 0x5, 0xc, 0x5, 0xe, 0x5, 0x3c, 0xb, 0x5, 0x3, 0x5, + 0x5, 0x5, 0x3f, 0xa, 0x5, 0x3, 0x5, 0x5, 0x5, 0x42, 0xa, 0x5, 0x3, + 0x6, 0x3, 0x6, 0x3, 0x7, 0x3, 0x7, 0x3, 0x7, 0x6, 0x7, 0x49, 0xa, + 0x7, 0xd, 0x7, 0xe, 0x7, 0x4a, 0x3, 0x7, 0x5, 0x7, 0x4e, 0xa, 0x7, + 0x3, 0x7, 0x3, 0x7, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, 0x3, + 0x8, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, 0x5, 0x8, 0x5a, 0xa, 0x8, 0x3, + 0x9, 0x3, 0x9, 0x3, 0x9, 0x3, 0x9, 0x3, 0x9, 0x3, 0x9, 0x3, 0x9, + 0x3, 0x9, 0x3, 0x9, 0x5, 0x9, 0x65, 0xa, 0x9, 0x3, 0x9, 0x3, 0x9, + 0x3, 0x9, 0x3, 0x9, 0x3, 0x9, 0x3, 0x9, 0x3, 0x9, 0x3, 0x9, 0x3, + 0x9, 0x3, 0x9, 0x3, 0x9, 0x3, 0x9, 0x3, 0x9, 0x3, 0x9, 0x3, 0x9, + 0x7, 0x9, 0x76, 0xa, 0x9, 0xc, 0x9, 0xe, 0x9, 0x79, 0xb, 0x9, 0x3, + 0xa, 0x3, 0xa, 0x3, 0xa, 0x5, 0xa, 0x7e, 0xa, 0xa, 0x3, 0xb, 0x3, + 0xb, 0x3, 0xc, 0x3, 0xc, 0x3, 0xc, 0x3, 0xc, 0x7, 0xc, 0x86, 0xa, + 0xc, 0xc, 0xc, 0xe, 0xc, 0x89, 0xb, 0xc, 0x3, 0xc, 0x3, 0xc, 0x3, + 0xd, 0x3, 0xd, 0x3, 0xd, 0x3, 0xd, 0x7, 0xd, 0x91, 0xa, 0xd, 0xc, + 0xd, 0xe, 0xd, 0x94, 0xb, 0xd, 0x3, 0xd, 0x3, 0xd, 0x3, 0xe, 0x3, + 0xe, 0x3, 0xe, 0x3, 0x3e, 0x3, 0x10, 0xf, 0x2, 0x4, 0x6, 0x8, 0xa, + 0xc, 0xe, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1a, 0x2, 0x4, 0x3, 0x2, + 0xd, 0xf, 0x3, 0x2, 0xe, 0xe, 0x2, 0xa1, 0x2, 0x1d, 0x3, 0x2, 0x2, + 0x2, 0x4, 0x23, 0x3, 0x2, 0x2, 0x2, 0x6, 0x2b, 0x3, 0x2, 0x2, 0x2, + 0x8, 0x41, 0x3, 0x2, 0x2, 0x2, 0xa, 0x43, 0x3, 0x2, 0x2, 0x2, 0xc, + 0x48, 0x3, 0x2, 0x2, 0x2, 0xe, 0x59, 0x3, 0x2, 0x2, 0x2, 0x10, 0x64, + 0x3, 0x2, 0x2, 0x2, 0x12, 0x7d, 0x3, 0x2, 0x2, 0x2, 0x14, 0x7f, 0x3, + 0x2, 0x2, 0x2, 0x16, 0x81, 0x3, 0x2, 0x2, 0x2, 0x18, 0x8c, 0x3, 0x2, + 0x2, 0x2, 0x1a, 0x97, 0x3, 0x2, 0x2, 0x2, 0x1c, 0x1e, 0x5, 0xe, 0x8, + 0x2, 0x1d, 0x1c, 0x3, 0x2, 0x2, 0x2, 0x1e, 0x1f, 0x3, 0x2, 0x2, 0x2, + 0x1f, 0x1d, 0x3, 0x2, 0x2, 0x2, 0x1f, 0x20, 0x3, 0x2, 0x2, 0x2, 0x20, + 0x21, 0x3, 0x2, 0x2, 0x2, 0x21, 0x22, 0x7, 0x2, 0x2, 0x3, 0x22, 0x3, + 0x3, 0x2, 0x2, 0x2, 0x23, 0x27, 0x7, 0x8, 0x2, 0x2, 0x24, 0x25, 0x5, + 0x6, 0x4, 0x2, 0x25, 0x26, 0x7, 0xa, 0x2, 0x2, 0x26, 0x28, 0x3, 0x2, + 0x2, 0x2, 0x27, 0x24, 0x3, 0x2, 0x2, 0x2, 0x27, 0x28, 0x3, 0x2, 0x2, + 0x2, 0x28, 0x29, 0x3, 0x2, 0x2, 0x2, 0x29, 0x2a, 0x6, 0x3, 0x2, 0x2, + 0x2a, 0x5, 0x3, 0x2, 0x2, 0x2, 0x2b, 0x2c, 0x7, 0xc, 0x2, 0x2, 0x2c, + 0x7, 0x3, 0x2, 0x2, 0x2, 0x2d, 0x2f, 0x5, 0x4, 0x3, 0x2, 0x2e, 0x2d, + 0x3, 0x2, 0x2, 0x2, 0x2f, 0x30, 0x3, 0x2, 0x2, 0x2, 0x30, 0x2e, 0x3, + 0x2, 0x2, 0x2, 0x30, 0x31, 0x3, 0x2, 0x2, 0x2, 0x31, 0x42, 0x3, 0x2, + 0x2, 0x2, 0x32, 0x33, 0x6, 0x5, 0x3, 0x2, 0x33, 0x34, 0x5, 0x6, 0x4, + 0x2, 0x34, 0x35, 0x8, 0x5, 0x1, 0x2, 0x35, 0x42, 0x3, 0x2, 0x2, 0x2, + 0x36, 0x3e, 0x7, 0x8, 0x2, 0x2, 0x37, 0x39, 0x7, 0x9, 0x2, 0x2, 0x38, + 0x37, 0x3, 0x2, 0x2, 0x2, 0x39, 0x3c, 0x3, 0x2, 0x2, 0x2, 0x3a, 0x38, + 0x3, 0x2, 0x2, 0x2, 0x3a, 0x3b, 0x3, 0x2, 0x2, 0x2, 0x3b, 0x3d, 0x3, + 0x2, 0x2, 0x2, 0x3c, 0x3a, 0x3, 0x2, 0x2, 0x2, 0x3d, 0x3f, 0x5, 0x4, + 0x3, 0x2, 0x3e, 0x3f, 0x3, 0x2, 0x2, 0x2, 0x3e, 0x3a, 0x3, 0x2, 0x2, + 0x2, 0x3f, 0x40, 0x3, 0x2, 0x2, 0x2, 0x40, 0x42, 0x8, 0x5, 0x1, 0x2, + 0x41, 0x2e, 0x3, 0x2, 0x2, 0x2, 0x41, 0x32, 0x3, 0x2, 0x2, 0x2, 0x41, + 0x36, 0x3, 0x2, 0x2, 0x2, 0x42, 0x9, 0x3, 0x2, 0x2, 0x2, 0x43, 0x44, + 0x5, 0xe, 0x8, 0x2, 0x44, 0xb, 0x3, 0x2, 0x2, 0x2, 0x45, 0x46, 0x5, + 0xa, 0x6, 0x2, 0x46, 0x47, 0xb, 0x2, 0x2, 0x2, 0x47, 0x49, 0x3, 0x2, + 0x2, 0x2, 0x48, 0x45, 0x3, 0x2, 0x2, 0x2, 0x49, 0x4a, 0x3, 0x2, 0x2, + 0x2, 0x4a, 0x48, 0x3, 0x2, 0x2, 0x2, 0x4a, 0x4b, 0x3, 0x2, 0x2, 0x2, + 0x4b, 0x4d, 0x3, 0x2, 0x2, 0x2, 0x4c, 0x4e, 0x9, 0x2, 0x2, 0x2, 0x4d, + 0x4c, 0x3, 0x2, 0x2, 0x2, 0x4d, 0x4e, 0x3, 0x2, 0x2, 0x2, 0x4e, 0x4f, + 0x3, 0x2, 0x2, 0x2, 0x4f, 0x50, 0xa, 0x3, 0x2, 0x2, 0x50, 0xd, 0x3, + 0x2, 0x2, 0x2, 0x51, 0x52, 0x5, 0x10, 0x9, 0x2, 0x52, 0x53, 0x7, + 0xb, 0x2, 0x2, 0x53, 0x54, 0x5, 0x10, 0x9, 0x2, 0x54, 0x55, 0x7, + 0xe, 0x2, 0x2, 0x55, 0x5a, 0x3, 0x2, 0x2, 0x2, 0x56, 0x57, 0x5, 0x10, + 0x9, 0x2, 0x57, 0x58, 0x7, 0xe, 0x2, 0x2, 0x58, 0x5a, 0x3, 0x2, 0x2, + 0x2, 0x59, 0x51, 0x3, 0x2, 0x2, 0x2, 0x59, 0x56, 0x3, 0x2, 0x2, 0x2, + 0x5a, 0xf, 0x3, 0x2, 0x2, 0x2, 0x5b, 0x5c, 0x8, 0x9, 0x1, 0x2, 0x5c, + 0x5d, 0x7, 0x12, 0x2, 0x2, 0x5d, 0x5e, 0x5, 0x10, 0x9, 0x2, 0x5e, + 0x5f, 0x7, 0x13, 0x2, 0x2, 0x5f, 0x65, 0x3, 0x2, 0x2, 0x2, 0x60, + 0x65, 0x5, 0x14, 0xb, 0x2, 0x61, 0x65, 0x5, 0x12, 0xa, 0x2, 0x62, + 0x65, 0x7, 0x6, 0x2, 0x2, 0x63, 0x65, 0x7, 0x18, 0x2, 0x2, 0x64, + 0x5b, 0x3, 0x2, 0x2, 0x2, 0x64, 0x60, 0x3, 0x2, 0x2, 0x2, 0x64, 0x61, + 0x3, 0x2, 0x2, 0x2, 0x64, 0x62, 0x3, 0x2, 0x2, 0x2, 0x64, 0x63, 0x3, + 0x2, 0x2, 0x2, 0x65, 0x77, 0x3, 0x2, 0x2, 0x2, 0x66, 0x67, 0xc, 0xb, + 0x2, 0x2, 0x67, 0x68, 0x7, 0x11, 0x2, 0x2, 0x68, 0x76, 0x5, 0x10, + 0x9, 0xc, 0x69, 0x6a, 0xc, 0xa, 0x2, 0x2, 0x6a, 0x6b, 0x7, 0xf, 0x2, + 0x2, 0x6b, 0x76, 0x5, 0x10, 0x9, 0xb, 0x6c, 0x6d, 0xc, 0x8, 0x2, + 0x2, 0x6d, 0x6e, 0x7, 0x16, 0x2, 0x2, 0x6e, 0x6f, 0x5, 0x10, 0x9, + 0x2, 0x6f, 0x70, 0x7, 0xd, 0x2, 0x2, 0x70, 0x71, 0x5, 0x10, 0x9, + 0x8, 0x71, 0x76, 0x3, 0x2, 0x2, 0x2, 0x72, 0x73, 0xc, 0x7, 0x2, 0x2, + 0x73, 0x74, 0x7, 0xb, 0x2, 0x2, 0x74, 0x76, 0x5, 0x10, 0x9, 0x7, + 0x75, 0x66, 0x3, 0x2, 0x2, 0x2, 0x75, 0x69, 0x3, 0x2, 0x2, 0x2, 0x75, + 0x6c, 0x3, 0x2, 0x2, 0x2, 0x75, 0x72, 0x3, 0x2, 0x2, 0x2, 0x76, 0x79, + 0x3, 0x2, 0x2, 0x2, 0x77, 0x75, 0x3, 0x2, 0x2, 0x2, 0x77, 0x78, 0x3, + 0x2, 0x2, 0x2, 0x78, 0x11, 0x3, 0x2, 0x2, 0x2, 0x79, 0x77, 0x3, 0x2, + 0x2, 0x2, 0x7a, 0x7b, 0x7, 0x4, 0x2, 0x2, 0x7b, 0x7e, 0x5, 0x10, + 0x9, 0x2, 0x7c, 0x7e, 0x7, 0x5, 0x2, 0x2, 0x7d, 0x7a, 0x3, 0x2, 0x2, + 0x2, 0x7d, 0x7c, 0x3, 0x2, 0x2, 0x2, 0x7e, 0x13, 0x3, 0x2, 0x2, 0x2, + 0x7f, 0x80, 0x7, 0x8, 0x2, 0x2, 0x80, 0x15, 0x3, 0x2, 0x2, 0x2, 0x81, + 0x82, 0x7, 0x14, 0x2, 0x2, 0x82, 0x87, 0x7, 0x6, 0x2, 0x2, 0x83, + 0x84, 0x7, 0x17, 0x2, 0x2, 0x84, 0x86, 0x7, 0x6, 0x2, 0x2, 0x85, + 0x83, 0x3, 0x2, 0x2, 0x2, 0x86, 0x89, 0x3, 0x2, 0x2, 0x2, 0x87, 0x85, + 0x3, 0x2, 0x2, 0x2, 0x87, 0x88, 0x3, 0x2, 0x2, 0x2, 0x88, 0x8a, 0x3, + 0x2, 0x2, 0x2, 0x89, 0x87, 0x3, 0x2, 0x2, 0x2, 0x8a, 0x8b, 0x7, 0x15, + 0x2, 0x2, 0x8b, 0x17, 0x3, 0x2, 0x2, 0x2, 0x8c, 0x8d, 0x7, 0x14, + 0x2, 0x2, 0x8d, 0x92, 0x5, 0x14, 0xb, 0x2, 0x8e, 0x8f, 0x7, 0x17, + 0x2, 0x2, 0x8f, 0x91, 0x5, 0x14, 0xb, 0x2, 0x90, 0x8e, 0x3, 0x2, + 0x2, 0x2, 0x91, 0x94, 0x3, 0x2, 0x2, 0x2, 0x92, 0x90, 0x3, 0x2, 0x2, + 0x2, 0x92, 0x93, 0x3, 0x2, 0x2, 0x2, 0x93, 0x95, 0x3, 0x2, 0x2, 0x2, + 0x94, 0x92, 0x3, 0x2, 0x2, 0x2, 0x95, 0x96, 0x7, 0x15, 0x2, 0x2, + 0x96, 0x19, 0x3, 0x2, 0x2, 0x2, 0x97, 0x98, 0xb, 0x2, 0x2, 0x2, 0x98, + 0x1b, 0x3, 0x2, 0x2, 0x2, 0x11, 0x1f, 0x27, 0x30, 0x3a, 0x3e, 0x41, + 0x4a, 0x4d, 0x59, 0x64, 0x75, 0x77, 0x7d, 0x87, 0x92, + }; + + _serializedATN.insert(_serializedATN.end(), serializedATNSegment0, + serializedATNSegment0 + sizeof(serializedATNSegment0) / sizeof(serializedATNSegment0[0])); + + + atn::ATNDeserializer deserializer; + _atn = deserializer.deserialize(_serializedATN); + + size_t count = _atn.getNumberOfDecisions(); + _decisionToDFA.reserve(count); + for (size_t i = 0; i < count; i++) { + _decisionToDFA.emplace_back(_atn.getDecisionState(i), i); + } +} + +TParser::Initializer TParser::_init; diff --git a/antlr/antlr4-runtime/demo/generated/TParser.h b/antlr/antlr4-runtime/demo/generated/TParser.h new file mode 100644 index 0000000..5f04c5c --- /dev/null +++ b/antlr/antlr4-runtime/demo/generated/TParser.h @@ -0,0 +1,366 @@ +/* parser/listener/visitor header section */ + +// Generated from /home/xsu/workspace/sysy/sysy/antlr/antlr4-runtime/demo/TParser.g4 by ANTLR 4.9.3 + +#pragma once + +/* parser precinclude section */ + +#include "antlr4-runtime.h" + + +/* parser postinclude section */ +#ifndef _WIN32 +#pragma GCC diagnostic ignored "-Wunused-parameter" +#endif + + +namespace antlrcpptest { + +/* parser context section */ + +class TParser : public antlr4::Parser { +public: + enum { + DUMMY = 1, Return = 2, Continue = 3, INT = 4, Digit = 5, ID = 6, LessThan = 7, + GreaterThan = 8, Equal = 9, And = 10, Colon = 11, Semicolon = 12, Plus = 13, + Minus = 14, Star = 15, OpenPar = 16, ClosePar = 17, OpenCurly = 18, + CloseCurly = 19, QuestionMark = 20, Comma = 21, String = 22, Foo = 23, + Bar = 24, Any = 25, Comment = 26, WS = 27, Dot = 28, DotDot = 29, Dollar = 30, + Ampersand = 31 + }; + + enum { + RuleMain = 0, RuleDivide = 1, RuleAnd_ = 2, RuleConquer = 3, RuleUnused = 4, + RuleUnused2 = 5, RuleStat = 6, RuleExpr = 7, RuleFlowControl = 8, RuleId = 9, + RuleArray = 10, RuleIdarray = 11, RuleAny = 12 + }; + + explicit TParser(antlr4::TokenStream *input); + ~TParser(); + + virtual std::string getGrammarFileName() const override; + virtual const antlr4::atn::ATN& getATN() const override { return _atn; }; + virtual const std::vector& getTokenNames() const override { return _tokenNames; }; // deprecated: use vocabulary instead. + virtual const std::vector& getRuleNames() const override; + virtual antlr4::dfa::Vocabulary& getVocabulary() const override; + + + /* public parser declarations/members section */ + bool myAction() { return true; } + bool doesItBlend() { return true; } + void cleanUp() {} + void doInit() {} + void doAfter() {} + + + class MainContext; + class DivideContext; + class And_Context; + class ConquerContext; + class UnusedContext; + class Unused2Context; + class StatContext; + class ExprContext; + class FlowControlContext; + class IdContext; + class ArrayContext; + class IdarrayContext; + class AnyContext; + + class MainContext : public antlr4::ParserRuleContext { + public: + MainContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *EOF(); + std::vector stat(); + StatContext* stat(size_t i); + + virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; + virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + MainContext* main(); + + class DivideContext : public antlr4::ParserRuleContext { + public: + DivideContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *ID(); + And_Context *and_(); + antlr4::tree::TerminalNode *GreaterThan(); + + virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; + virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + DivideContext* divide(); + + class And_Context : public antlr4::ParserRuleContext { + public: + And_Context(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *And(); + + virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; + virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + And_Context* and_(); + + class ConquerContext : public antlr4::ParserRuleContext { + public: + antlr4::Token *idToken = nullptr; + ConquerContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector divide(); + DivideContext* divide(size_t i); + And_Context *and_(); + antlr4::tree::TerminalNode *ID(); + std::vector LessThan(); + antlr4::tree::TerminalNode* LessThan(size_t i); + + virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; + virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + ConquerContext* conquer(); + + class UnusedContext : public antlr4::ParserRuleContext { + public: + double input = 111; + double calculated; + int _a; + double _b; + int _c; + UnusedContext(antlr4::ParserRuleContext *parent, size_t invokingState); + UnusedContext(antlr4::ParserRuleContext *parent, size_t invokingState, double input = 111); + virtual size_t getRuleIndex() const override; + StatContext *stat(); + + virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; + virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + UnusedContext* unused(double input = 111); + + class Unused2Context : public antlr4::ParserRuleContext { + public: + Unused2Context(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector Semicolon(); + antlr4::tree::TerminalNode* Semicolon(size_t i); + std::vector unused(); + UnusedContext* unused(size_t i); + antlr4::tree::TerminalNode *Colon(); + antlr4::tree::TerminalNode *Plus(); + + virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; + virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + Unused2Context* unused2(); + + class StatContext : public antlr4::ParserRuleContext { + public: + StatContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector expr(); + ExprContext* expr(size_t i); + antlr4::tree::TerminalNode *Equal(); + antlr4::tree::TerminalNode *Semicolon(); + + virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; + virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + StatContext* stat(); + + class ExprContext : public antlr4::ParserRuleContext { + public: + TParser::IdContext *identifier = nullptr; + ExprContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *OpenPar(); + std::vector expr(); + ExprContext* expr(size_t i); + antlr4::tree::TerminalNode *ClosePar(); + IdContext *id(); + FlowControlContext *flowControl(); + antlr4::tree::TerminalNode *INT(); + antlr4::tree::TerminalNode *String(); + antlr4::tree::TerminalNode *Star(); + antlr4::tree::TerminalNode *Plus(); + antlr4::tree::TerminalNode *QuestionMark(); + antlr4::tree::TerminalNode *Colon(); + antlr4::tree::TerminalNode *Equal(); + + virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; + virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + ExprContext* expr(); + ExprContext* expr(int precedence); + class FlowControlContext : public antlr4::ParserRuleContext { + public: + FlowControlContext(antlr4::ParserRuleContext *parent, size_t invokingState); + + FlowControlContext() = default; + void copyFrom(FlowControlContext *context); + using antlr4::ParserRuleContext::copyFrom; + + virtual size_t getRuleIndex() const override; + + + }; + + class ReturnContext : public FlowControlContext { + public: + ReturnContext(FlowControlContext *ctx); + + antlr4::tree::TerminalNode *Return(); + ExprContext *expr(); + virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; + virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + }; + + class ContinueContext : public FlowControlContext { + public: + ContinueContext(FlowControlContext *ctx); + + antlr4::tree::TerminalNode *Continue(); + virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; + virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + }; + + FlowControlContext* flowControl(); + + class IdContext : public antlr4::ParserRuleContext { + public: + IdContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *ID(); + + virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; + virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + IdContext* id(); + + class ArrayContext : public antlr4::ParserRuleContext { + public: + antlr4::Token *intToken = nullptr; + std::vector el; + ArrayContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *OpenCurly(); + antlr4::tree::TerminalNode *CloseCurly(); + std::vector INT(); + antlr4::tree::TerminalNode* INT(size_t i); + std::vector Comma(); + antlr4::tree::TerminalNode* Comma(size_t i); + + virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; + virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + ArrayContext* array(); + + class IdarrayContext : public antlr4::ParserRuleContext { + public: + TParser::IdContext *idContext = nullptr; + std::vector element; + IdarrayContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *OpenCurly(); + antlr4::tree::TerminalNode *CloseCurly(); + std::vector id(); + IdContext* id(size_t i); + std::vector Comma(); + antlr4::tree::TerminalNode* Comma(size_t i); + + virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; + virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + IdarrayContext* idarray(); + + class AnyContext : public antlr4::ParserRuleContext { + public: + antlr4::Token *t = nullptr; + AnyContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + + virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override; + virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override; + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + AnyContext* any(); + + + virtual bool sempred(antlr4::RuleContext *_localctx, size_t ruleIndex, size_t predicateIndex) override; + bool divideSempred(DivideContext *_localctx, size_t predicateIndex); + bool conquerSempred(ConquerContext *_localctx, size_t predicateIndex); + bool exprSempred(ExprContext *_localctx, size_t predicateIndex); + +private: + static std::vector _decisionToDFA; + static antlr4::atn::PredictionContextCache _sharedContextCache; + static std::vector _ruleNames; + static std::vector _tokenNames; + + static std::vector _literalNames; + static std::vector _symbolicNames; + static antlr4::dfa::Vocabulary _vocabulary; + static antlr4::atn::ATN _atn; + static std::vector _serializedATN; + + /* private parser declarations section */ + + struct Initializer { + Initializer(); + }; + static Initializer _init; +}; + +} // namespace antlrcpptest diff --git a/antlr/antlr4-runtime/demo/generated/TParser.interp b/antlr/antlr4-runtime/demo/generated/TParser.interp new file mode 100644 index 0000000..efda57d --- /dev/null +++ b/antlr/antlr4-runtime/demo/generated/TParser.interp @@ -0,0 +1,86 @@ +token literal names: +null +null +'return' +'continue' +null +null +null +'<' +'>' +'=' +'and' +':' +';' +'+' +'-' +'*' +'(' +')' +'{' +'}' +'?' +',' +null +null +null +null +null +null +'.' +'..' +'$' +'&' + +token symbolic names: +null +DUMMY +Return +Continue +INT +Digit +ID +LessThan +GreaterThan +Equal +And +Colon +Semicolon +Plus +Minus +Star +OpenPar +ClosePar +OpenCurly +CloseCurly +QuestionMark +Comma +String +Foo +Bar +Any +Comment +WS +Dot +DotDot +Dollar +Ampersand + +rule names: +main +divide +and_ +conquer +unused +unused2 +stat +expr +flowControl +id +array +idarray +any + + +atn: +[3, 24715, 42794, 33075, 47597, 16764, 15335, 30598, 22884, 3, 33, 154, 4, 2, 9, 2, 4, 3, 9, 3, 4, 4, 9, 4, 4, 5, 9, 5, 4, 6, 9, 6, 4, 7, 9, 7, 4, 8, 9, 8, 4, 9, 9, 9, 4, 10, 9, 10, 4, 11, 9, 11, 4, 12, 9, 12, 4, 13, 9, 13, 4, 14, 9, 14, 3, 2, 6, 2, 30, 10, 2, 13, 2, 14, 2, 31, 3, 2, 3, 2, 3, 3, 3, 3, 3, 3, 3, 3, 5, 3, 40, 10, 3, 3, 3, 3, 3, 3, 4, 3, 4, 3, 5, 6, 5, 47, 10, 5, 13, 5, 14, 5, 48, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 7, 5, 57, 10, 5, 12, 5, 14, 5, 60, 11, 5, 3, 5, 5, 5, 63, 10, 5, 3, 5, 5, 5, 66, 10, 5, 3, 6, 3, 6, 3, 7, 3, 7, 3, 7, 6, 7, 73, 10, 7, 13, 7, 14, 7, 74, 3, 7, 5, 7, 78, 10, 7, 3, 7, 3, 7, 3, 8, 3, 8, 3, 8, 3, 8, 3, 8, 3, 8, 3, 8, 3, 8, 5, 8, 90, 10, 8, 3, 9, 3, 9, 3, 9, 3, 9, 3, 9, 3, 9, 3, 9, 3, 9, 3, 9, 5, 9, 101, 10, 9, 3, 9, 3, 9, 3, 9, 3, 9, 3, 9, 3, 9, 3, 9, 3, 9, 3, 9, 3, 9, 3, 9, 3, 9, 3, 9, 3, 9, 3, 9, 7, 9, 118, 10, 9, 12, 9, 14, 9, 121, 11, 9, 3, 10, 3, 10, 3, 10, 5, 10, 126, 10, 10, 3, 11, 3, 11, 3, 12, 3, 12, 3, 12, 3, 12, 7, 12, 134, 10, 12, 12, 12, 14, 12, 137, 11, 12, 3, 12, 3, 12, 3, 13, 3, 13, 3, 13, 3, 13, 7, 13, 145, 10, 13, 12, 13, 14, 13, 148, 11, 13, 3, 13, 3, 13, 3, 14, 3, 14, 3, 14, 3, 62, 3, 16, 15, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 2, 4, 3, 2, 13, 15, 3, 2, 14, 14, 2, 161, 2, 29, 3, 2, 2, 2, 4, 35, 3, 2, 2, 2, 6, 43, 3, 2, 2, 2, 8, 65, 3, 2, 2, 2, 10, 67, 3, 2, 2, 2, 12, 72, 3, 2, 2, 2, 14, 89, 3, 2, 2, 2, 16, 100, 3, 2, 2, 2, 18, 125, 3, 2, 2, 2, 20, 127, 3, 2, 2, 2, 22, 129, 3, 2, 2, 2, 24, 140, 3, 2, 2, 2, 26, 151, 3, 2, 2, 2, 28, 30, 5, 14, 8, 2, 29, 28, 3, 2, 2, 2, 30, 31, 3, 2, 2, 2, 31, 29, 3, 2, 2, 2, 31, 32, 3, 2, 2, 2, 32, 33, 3, 2, 2, 2, 33, 34, 7, 2, 2, 3, 34, 3, 3, 2, 2, 2, 35, 39, 7, 8, 2, 2, 36, 37, 5, 6, 4, 2, 37, 38, 7, 10, 2, 2, 38, 40, 3, 2, 2, 2, 39, 36, 3, 2, 2, 2, 39, 40, 3, 2, 2, 2, 40, 41, 3, 2, 2, 2, 41, 42, 6, 3, 2, 2, 42, 5, 3, 2, 2, 2, 43, 44, 7, 12, 2, 2, 44, 7, 3, 2, 2, 2, 45, 47, 5, 4, 3, 2, 46, 45, 3, 2, 2, 2, 47, 48, 3, 2, 2, 2, 48, 46, 3, 2, 2, 2, 48, 49, 3, 2, 2, 2, 49, 66, 3, 2, 2, 2, 50, 51, 6, 5, 3, 2, 51, 52, 5, 6, 4, 2, 52, 53, 8, 5, 1, 2, 53, 66, 3, 2, 2, 2, 54, 62, 7, 8, 2, 2, 55, 57, 7, 9, 2, 2, 56, 55, 3, 2, 2, 2, 57, 60, 3, 2, 2, 2, 58, 56, 3, 2, 2, 2, 58, 59, 3, 2, 2, 2, 59, 61, 3, 2, 2, 2, 60, 58, 3, 2, 2, 2, 61, 63, 5, 4, 3, 2, 62, 63, 3, 2, 2, 2, 62, 58, 3, 2, 2, 2, 63, 64, 3, 2, 2, 2, 64, 66, 8, 5, 1, 2, 65, 46, 3, 2, 2, 2, 65, 50, 3, 2, 2, 2, 65, 54, 3, 2, 2, 2, 66, 9, 3, 2, 2, 2, 67, 68, 5, 14, 8, 2, 68, 11, 3, 2, 2, 2, 69, 70, 5, 10, 6, 2, 70, 71, 11, 2, 2, 2, 71, 73, 3, 2, 2, 2, 72, 69, 3, 2, 2, 2, 73, 74, 3, 2, 2, 2, 74, 72, 3, 2, 2, 2, 74, 75, 3, 2, 2, 2, 75, 77, 3, 2, 2, 2, 76, 78, 9, 2, 2, 2, 77, 76, 3, 2, 2, 2, 77, 78, 3, 2, 2, 2, 78, 79, 3, 2, 2, 2, 79, 80, 10, 3, 2, 2, 80, 13, 3, 2, 2, 2, 81, 82, 5, 16, 9, 2, 82, 83, 7, 11, 2, 2, 83, 84, 5, 16, 9, 2, 84, 85, 7, 14, 2, 2, 85, 90, 3, 2, 2, 2, 86, 87, 5, 16, 9, 2, 87, 88, 7, 14, 2, 2, 88, 90, 3, 2, 2, 2, 89, 81, 3, 2, 2, 2, 89, 86, 3, 2, 2, 2, 90, 15, 3, 2, 2, 2, 91, 92, 8, 9, 1, 2, 92, 93, 7, 18, 2, 2, 93, 94, 5, 16, 9, 2, 94, 95, 7, 19, 2, 2, 95, 101, 3, 2, 2, 2, 96, 101, 5, 20, 11, 2, 97, 101, 5, 18, 10, 2, 98, 101, 7, 6, 2, 2, 99, 101, 7, 24, 2, 2, 100, 91, 3, 2, 2, 2, 100, 96, 3, 2, 2, 2, 100, 97, 3, 2, 2, 2, 100, 98, 3, 2, 2, 2, 100, 99, 3, 2, 2, 2, 101, 119, 3, 2, 2, 2, 102, 103, 12, 11, 2, 2, 103, 104, 7, 17, 2, 2, 104, 118, 5, 16, 9, 12, 105, 106, 12, 10, 2, 2, 106, 107, 7, 15, 2, 2, 107, 118, 5, 16, 9, 11, 108, 109, 12, 8, 2, 2, 109, 110, 7, 22, 2, 2, 110, 111, 5, 16, 9, 2, 111, 112, 7, 13, 2, 2, 112, 113, 5, 16, 9, 8, 113, 118, 3, 2, 2, 2, 114, 115, 12, 7, 2, 2, 115, 116, 7, 11, 2, 2, 116, 118, 5, 16, 9, 7, 117, 102, 3, 2, 2, 2, 117, 105, 3, 2, 2, 2, 117, 108, 3, 2, 2, 2, 117, 114, 3, 2, 2, 2, 118, 121, 3, 2, 2, 2, 119, 117, 3, 2, 2, 2, 119, 120, 3, 2, 2, 2, 120, 17, 3, 2, 2, 2, 121, 119, 3, 2, 2, 2, 122, 123, 7, 4, 2, 2, 123, 126, 5, 16, 9, 2, 124, 126, 7, 5, 2, 2, 125, 122, 3, 2, 2, 2, 125, 124, 3, 2, 2, 2, 126, 19, 3, 2, 2, 2, 127, 128, 7, 8, 2, 2, 128, 21, 3, 2, 2, 2, 129, 130, 7, 20, 2, 2, 130, 135, 7, 6, 2, 2, 131, 132, 7, 23, 2, 2, 132, 134, 7, 6, 2, 2, 133, 131, 3, 2, 2, 2, 134, 137, 3, 2, 2, 2, 135, 133, 3, 2, 2, 2, 135, 136, 3, 2, 2, 2, 136, 138, 3, 2, 2, 2, 137, 135, 3, 2, 2, 2, 138, 139, 7, 21, 2, 2, 139, 23, 3, 2, 2, 2, 140, 141, 7, 20, 2, 2, 141, 146, 5, 20, 11, 2, 142, 143, 7, 23, 2, 2, 143, 145, 5, 20, 11, 2, 144, 142, 3, 2, 2, 2, 145, 148, 3, 2, 2, 2, 146, 144, 3, 2, 2, 2, 146, 147, 3, 2, 2, 2, 147, 149, 3, 2, 2, 2, 148, 146, 3, 2, 2, 2, 149, 150, 7, 21, 2, 2, 150, 25, 3, 2, 2, 2, 151, 152, 11, 2, 2, 2, 152, 27, 3, 2, 2, 2, 17, 31, 39, 48, 58, 62, 65, 74, 77, 89, 100, 117, 119, 125, 135, 146] \ No newline at end of file diff --git a/antlr/antlr4-runtime/demo/generated/TParser.tokens b/antlr/antlr4-runtime/demo/generated/TParser.tokens new file mode 100644 index 0000000..aac0d44 --- /dev/null +++ b/antlr/antlr4-runtime/demo/generated/TParser.tokens @@ -0,0 +1,52 @@ +DUMMY=1 +Return=2 +Continue=3 +INT=4 +Digit=5 +ID=6 +LessThan=7 +GreaterThan=8 +Equal=9 +And=10 +Colon=11 +Semicolon=12 +Plus=13 +Minus=14 +Star=15 +OpenPar=16 +ClosePar=17 +OpenCurly=18 +CloseCurly=19 +QuestionMark=20 +Comma=21 +String=22 +Foo=23 +Bar=24 +Any=25 +Comment=26 +WS=27 +Dot=28 +DotDot=29 +Dollar=30 +Ampersand=31 +'return'=2 +'continue'=3 +'<'=7 +'>'=8 +'='=9 +'and'=10 +':'=11 +';'=12 +'+'=13 +'-'=14 +'*'=15 +'('=16 +')'=17 +'{'=18 +'}'=19 +'?'=20 +','=21 +'$'=30 +'&'=31 +'.'=28 +'..'=29 diff --git a/antlr/antlr4-runtime/demo/generated/TParserBaseListener.cpp b/antlr/antlr4-runtime/demo/generated/TParserBaseListener.cpp new file mode 100644 index 0000000..25e20a6 --- /dev/null +++ b/antlr/antlr4-runtime/demo/generated/TParserBaseListener.cpp @@ -0,0 +1,13 @@ +/* parser/listener/visitor header section */ + +// Generated from /home/xsu/workspace/sysy/sysy/antlr/antlr4-runtime/demo/TParser.g4 by ANTLR 4.9.3 + +/* base listener preinclude section */ + +#include "TParserBaseListener.h" + +/* base listener postinclude section */ + +using namespace antlrcpptest; + +/* base listener definitions section */ \ No newline at end of file diff --git a/antlr/antlr4-runtime/demo/generated/TParserBaseListener.h b/antlr/antlr4-runtime/demo/generated/TParserBaseListener.h new file mode 100644 index 0000000..084ffc6 --- /dev/null +++ b/antlr/antlr4-runtime/demo/generated/TParserBaseListener.h @@ -0,0 +1,77 @@ +/* parser/listener/visitor header section */ + +// Generated from /home/xsu/workspace/sysy/sysy/antlr/antlr4-runtime/demo/TParser.g4 by ANTLR 4.9.3 + +#pragma once + +/* base listener preinclude section */ + +#include "antlr4-runtime.h" +#include "TParserListener.h" + +/* base listener postinclude section */ + +namespace antlrcpptest { + +/** + * This class provides an empty implementation of TParserListener, + * which can be extended to create a listener which only needs to handle a subset + * of the available methods. + */ +class TParserBaseListener : public TParserListener { +public: +/* base listener public declarations/members section */ + + virtual void enterMain(TParser::MainContext * /*ctx*/) override { } + virtual void exitMain(TParser::MainContext * /*ctx*/) override { } + + virtual void enterDivide(TParser::DivideContext * /*ctx*/) override { } + virtual void exitDivide(TParser::DivideContext * /*ctx*/) override { } + + virtual void enterAnd_(TParser::And_Context * /*ctx*/) override { } + virtual void exitAnd_(TParser::And_Context * /*ctx*/) override { } + + virtual void enterConquer(TParser::ConquerContext * /*ctx*/) override { } + virtual void exitConquer(TParser::ConquerContext * /*ctx*/) override { } + + virtual void enterUnused(TParser::UnusedContext * /*ctx*/) override { } + virtual void exitUnused(TParser::UnusedContext * /*ctx*/) override { } + + virtual void enterUnused2(TParser::Unused2Context * /*ctx*/) override { } + virtual void exitUnused2(TParser::Unused2Context * /*ctx*/) override { } + + virtual void enterStat(TParser::StatContext * /*ctx*/) override { } + virtual void exitStat(TParser::StatContext * /*ctx*/) override { } + + virtual void enterExpr(TParser::ExprContext * /*ctx*/) override { } + virtual void exitExpr(TParser::ExprContext * /*ctx*/) override { } + + virtual void enterReturn(TParser::ReturnContext * /*ctx*/) override { } + virtual void exitReturn(TParser::ReturnContext * /*ctx*/) override { } + + virtual void enterContinue(TParser::ContinueContext * /*ctx*/) override { } + virtual void exitContinue(TParser::ContinueContext * /*ctx*/) override { } + + virtual void enterId(TParser::IdContext * /*ctx*/) override { } + virtual void exitId(TParser::IdContext * /*ctx*/) override { } + + virtual void enterArray(TParser::ArrayContext * /*ctx*/) override { } + virtual void exitArray(TParser::ArrayContext * /*ctx*/) override { } + + virtual void enterIdarray(TParser::IdarrayContext * /*ctx*/) override { } + virtual void exitIdarray(TParser::IdarrayContext * /*ctx*/) override { } + + virtual void enterAny(TParser::AnyContext * /*ctx*/) override { } + virtual void exitAny(TParser::AnyContext * /*ctx*/) override { } + + + virtual void enterEveryRule(antlr4::ParserRuleContext * /*ctx*/) override { } + virtual void exitEveryRule(antlr4::ParserRuleContext * /*ctx*/) override { } + virtual void visitTerminal(antlr4::tree::TerminalNode * /*node*/) override { } + virtual void visitErrorNode(antlr4::tree::ErrorNode * /*node*/) override { } + +private: +/* base listener private declarations/members section */ +}; + +} // namespace antlrcpptest diff --git a/antlr/antlr4-runtime/demo/generated/TParserBaseVisitor.cpp b/antlr/antlr4-runtime/demo/generated/TParserBaseVisitor.cpp new file mode 100644 index 0000000..0050588 --- /dev/null +++ b/antlr/antlr4-runtime/demo/generated/TParserBaseVisitor.cpp @@ -0,0 +1,13 @@ +/* parser/listener/visitor header section */ + +// Generated from /home/xsu/workspace/sysy/sysy/antlr/antlr4-runtime/demo/TParser.g4 by ANTLR 4.9.3 + +/* base visitor preinclude section */ + +#include "TParserBaseVisitor.h" + +/* base visitor postinclude section */ + +using namespace antlrcpptest; + +/* base visitor definitions section */ diff --git a/antlr/antlr4-runtime/demo/generated/TParserBaseVisitor.h b/antlr/antlr4-runtime/demo/generated/TParserBaseVisitor.h new file mode 100644 index 0000000..611b8f0 --- /dev/null +++ b/antlr/antlr4-runtime/demo/generated/TParserBaseVisitor.h @@ -0,0 +1,85 @@ +/* parser/listener/visitor header section */ + +// Generated from /home/xsu/workspace/sysy/sysy/antlr/antlr4-runtime/demo/TParser.g4 by ANTLR 4.9.3 + +#pragma once + +/* base visitor preinclude section */ + +#include "antlr4-runtime.h" +#include "TParserVisitor.h" + +/* base visitor postinclude section */ + +namespace antlrcpptest { + +/** + * This class provides an empty implementation of TParserVisitor, which can be + * extended to create a visitor which only needs to handle a subset of the available methods. + */ +class TParserBaseVisitor : public TParserVisitor { +public: +/* base visitor public declarations/members section */ + + virtual antlrcpp::Any visitMain(TParser::MainContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitDivide(TParser::DivideContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitAnd_(TParser::And_Context *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitConquer(TParser::ConquerContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitUnused(TParser::UnusedContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitUnused2(TParser::Unused2Context *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitStat(TParser::StatContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitExpr(TParser::ExprContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitReturn(TParser::ReturnContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitContinue(TParser::ContinueContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitId(TParser::IdContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitArray(TParser::ArrayContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitIdarray(TParser::IdarrayContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitAny(TParser::AnyContext *ctx) override { + return visitChildren(ctx); + } + + +private: +/* base visitor private declarations/members section */ +}; + +} // namespace antlrcpptest diff --git a/antlr/antlr4-runtime/demo/generated/TParserListener.cpp b/antlr/antlr4-runtime/demo/generated/TParserListener.cpp new file mode 100644 index 0000000..285e5c5 --- /dev/null +++ b/antlr/antlr4-runtime/demo/generated/TParserListener.cpp @@ -0,0 +1,13 @@ +/* parser/listener/visitor header section */ + +// Generated from /home/xsu/workspace/sysy/sysy/antlr/antlr4-runtime/demo/TParser.g4 by ANTLR 4.9.3 + +/* listener preinclude section */ + +#include "TParserListener.h" + +/* listener postinclude section */ + +using namespace antlrcpptest; + +/* listener definitions section */ \ No newline at end of file diff --git a/antlr/antlr4-runtime/demo/generated/TParserListener.h b/antlr/antlr4-runtime/demo/generated/TParserListener.h new file mode 100644 index 0000000..83cb8f7 --- /dev/null +++ b/antlr/antlr4-runtime/demo/generated/TParserListener.h @@ -0,0 +1,70 @@ +/* parser/listener/visitor header section */ + +// Generated from /home/xsu/workspace/sysy/sysy/antlr/antlr4-runtime/demo/TParser.g4 by ANTLR 4.9.3 + +#pragma once + +/* listener preinclude section */ + +#include "antlr4-runtime.h" +#include "TParser.h" + +/* listener postinclude section */ + +namespace antlrcpptest { + +/** + * This interface defines an abstract listener for a parse tree produced by TParser. + */ +class TParserListener : public antlr4::tree::ParseTreeListener { +public: +/* listener public declarations/members section */ + + virtual void enterMain(TParser::MainContext *ctx) = 0; + virtual void exitMain(TParser::MainContext *ctx) = 0; + + virtual void enterDivide(TParser::DivideContext *ctx) = 0; + virtual void exitDivide(TParser::DivideContext *ctx) = 0; + + virtual void enterAnd_(TParser::And_Context *ctx) = 0; + virtual void exitAnd_(TParser::And_Context *ctx) = 0; + + virtual void enterConquer(TParser::ConquerContext *ctx) = 0; + virtual void exitConquer(TParser::ConquerContext *ctx) = 0; + + virtual void enterUnused(TParser::UnusedContext *ctx) = 0; + virtual void exitUnused(TParser::UnusedContext *ctx) = 0; + + virtual void enterUnused2(TParser::Unused2Context *ctx) = 0; + virtual void exitUnused2(TParser::Unused2Context *ctx) = 0; + + virtual void enterStat(TParser::StatContext *ctx) = 0; + virtual void exitStat(TParser::StatContext *ctx) = 0; + + virtual void enterExpr(TParser::ExprContext *ctx) = 0; + virtual void exitExpr(TParser::ExprContext *ctx) = 0; + + virtual void enterReturn(TParser::ReturnContext *ctx) = 0; + virtual void exitReturn(TParser::ReturnContext *ctx) = 0; + + virtual void enterContinue(TParser::ContinueContext *ctx) = 0; + virtual void exitContinue(TParser::ContinueContext *ctx) = 0; + + virtual void enterId(TParser::IdContext *ctx) = 0; + virtual void exitId(TParser::IdContext *ctx) = 0; + + virtual void enterArray(TParser::ArrayContext *ctx) = 0; + virtual void exitArray(TParser::ArrayContext *ctx) = 0; + + virtual void enterIdarray(TParser::IdarrayContext *ctx) = 0; + virtual void exitIdarray(TParser::IdarrayContext *ctx) = 0; + + virtual void enterAny(TParser::AnyContext *ctx) = 0; + virtual void exitAny(TParser::AnyContext *ctx) = 0; + + +private: +/* listener private declarations/members section */ +}; + +} // namespace antlrcpptest diff --git a/antlr/antlr4-runtime/demo/generated/TParserVisitor.cpp b/antlr/antlr4-runtime/demo/generated/TParserVisitor.cpp new file mode 100644 index 0000000..90907ab --- /dev/null +++ b/antlr/antlr4-runtime/demo/generated/TParserVisitor.cpp @@ -0,0 +1,13 @@ +/* parser/listener/visitor header section */ + +// Generated from /home/xsu/workspace/sysy/sysy/antlr/antlr4-runtime/demo/TParser.g4 by ANTLR 4.9.3 + +/* visitor preinclude section */ + +#include "TParserVisitor.h" + +/* visitor postinclude section */ + +using namespace antlrcpptest; + +/* visitor definitions section */ diff --git a/antlr/antlr4-runtime/demo/generated/TParserVisitor.h b/antlr/antlr4-runtime/demo/generated/TParserVisitor.h new file mode 100644 index 0000000..1c96e19 --- /dev/null +++ b/antlr/antlr4-runtime/demo/generated/TParserVisitor.h @@ -0,0 +1,60 @@ +/* parser/listener/visitor header section */ + +// Generated from /home/xsu/workspace/sysy/sysy/antlr/antlr4-runtime/demo/TParser.g4 by ANTLR 4.9.3 + +#pragma once + +/* visitor preinclude section */ + +#include "antlr4-runtime.h" +#include "TParser.h" + +/* visitor postinclude section */ + +namespace antlrcpptest { + +/** + * This class defines an abstract visitor for a parse tree + * produced by TParser. + */ +class TParserVisitor : public antlr4::tree::AbstractParseTreeVisitor { +public: + /* visitor public declarations/members section */ + + /** + * Visit parse trees produced by TParser. + */ + virtual antlrcpp::Any visitMain(TParser::MainContext *context) = 0; + + virtual antlrcpp::Any visitDivide(TParser::DivideContext *context) = 0; + + virtual antlrcpp::Any visitAnd_(TParser::And_Context *context) = 0; + + virtual antlrcpp::Any visitConquer(TParser::ConquerContext *context) = 0; + + virtual antlrcpp::Any visitUnused(TParser::UnusedContext *context) = 0; + + virtual antlrcpp::Any visitUnused2(TParser::Unused2Context *context) = 0; + + virtual antlrcpp::Any visitStat(TParser::StatContext *context) = 0; + + virtual antlrcpp::Any visitExpr(TParser::ExprContext *context) = 0; + + virtual antlrcpp::Any visitReturn(TParser::ReturnContext *context) = 0; + + virtual antlrcpp::Any visitContinue(TParser::ContinueContext *context) = 0; + + virtual antlrcpp::Any visitId(TParser::IdContext *context) = 0; + + virtual antlrcpp::Any visitArray(TParser::ArrayContext *context) = 0; + + virtual antlrcpp::Any visitIdarray(TParser::IdarrayContext *context) = 0; + + virtual antlrcpp::Any visitAny(TParser::AnyContext *context) = 0; + + +private: +/* visitor private declarations/members section */ +}; + +} // namespace antlrcpptest diff --git a/antlr/antlr4-runtime/deploy-macos.sh b/antlr/antlr4-runtime/deploy-macos.sh new file mode 100755 index 0000000..cf97765 --- /dev/null +++ b/antlr/antlr4-runtime/deploy-macos.sh @@ -0,0 +1,48 @@ +#!/bin/bash + +# Clean left overs from previous builds if there are any +rm -f -R antlr4-runtime build lib 2> /dev/null +rm antlr4-cpp-runtime-macos.zip 2> /dev/null + +# Get utf8 dependency. +mkdir -p runtime/thirdparty 2> /dev/null +pushd runtime/thirdparty +if [ ! -d utfcpp ] +then + git clone https://github.com/nemtrif/utfcpp.git utfcpp + pushd utfcpp + git checkout tags/v3.1.1 + popd +fi +popd + +# Binaries +xcodebuild -project runtime/antlrcpp.xcodeproj \ + -target antlr4 \ + # GCC_PREPROCESSOR_DEFINITIONS='$GCC_PREPROCESSOR_DEFINITIONS USE_UTF8_INSTEAD_OF_CODECVT' \ + -configuration Release +xcodebuild -project runtime/antlrcpp.xcodeproj \ + -target antlr4_static \ + # GCC_PREPROCESSOR_DEFINITIONS='$GCC_PREPROCESSOR_DEFINITIONS USE_UTF8_INSTEAD_OF_CODECVT' \ + -configuration Release +rm -f -R lib +mkdir lib +mv runtime/build/Release/libantlr4-runtime.a lib/ +mv runtime/build/Release/libantlr4-runtime.dylib lib/ + +# Headers +rm -f -R antlr4-runtime +pushd runtime/src +find . -name '*.h' | cpio -pdm ../../antlr4-runtime +popd +pushd runtime/thirdparty/utfcpp/source +find . -name '*.h' | cpio -pdm ../../../../antlr4-runtime +popd + +# Zip up and clean up +zip -r antlr4-cpp-runtime-macos.zip antlr4-runtime lib + +rm -f -R antlr4-runtime build lib + +# Deploy +#cp antlr4-cpp-runtime-macos.zip ~/antlr/sites/website-antlr4/download diff --git a/antlr/antlr4-runtime/deploy-source.sh b/antlr/antlr4-runtime/deploy-source.sh new file mode 100755 index 0000000..d079821 --- /dev/null +++ b/antlr/antlr4-runtime/deploy-source.sh @@ -0,0 +1,14 @@ +#!/bin/bash + +# Zip it +rm -f antlr4-cpp-runtime-source.zip +zip -r antlr4-cpp-runtime-source.zip "README.md" "cmake" "demo" "runtime" "CMakeLists.txt" "deploy-macos.sh" "deploy-source.sh" "deploy-windows.cmd" "VERSION" \ + -X -x "*.DS_Store*" "antlrcpp.xcodeproj/xcuserdata/*" "*Build*" "*DerivedData*" "*.jar" "demo/generated/*" "*.vscode*" "runtime/build/*" + +# Add the license file from the ANTLR root as well. +pushd ../../ +zip runtime/cpp/antlr4-cpp-runtime-source.zip LICENSE.txt +popd + +# Deploy +#cp antlr4-cpp-runtime-source.zip ~/antlr/sites/website-antlr4/download diff --git a/antlr/antlr4-runtime/deploy-windows.cmd b/antlr/antlr4-runtime/deploy-windows.cmd new file mode 100644 index 0000000..8fc22ab --- /dev/null +++ b/antlr/antlr4-runtime/deploy-windows.cmd @@ -0,0 +1,81 @@ +@echo off +setlocal + +if [%1] == [] goto Usage + +rem Clean left overs from previous builds if there are any +if exist bin rmdir /S /Q runtime\bin +if exist obj rmdir /S /Q runtime\obj +if exist lib rmdir /S /Q lib +if exist antlr4-runtime rmdir /S /Q antlr4-runtime +if exist antlr4-cpp-runtime-vs2017.zip erase antlr4-cpp-runtime-vs2017.zip +if exist antlr4-cpp-runtime-vs2019.zip erase antlr4-cpp-runtime-vs2019.zip + +rem Headers +echo Copying header files ... +xcopy runtime\src\*.h antlr4-runtime\ /s /q + +rem Binaries +rem VS 2017 disabled by default. Change the X to a C to enable it. +if exist "X:\Program Files (x86)\Microsoft Visual Studio\2017\%1\Common7\Tools\VsDevCmd.bat" ( + echo. + + call "C:\Program Files (x86)\Microsoft Visual Studio\2017\%1\Common7\Tools\VsDevCmd.bat" + + pushd runtime + msbuild antlr4cpp-vs2017.vcxproj /p:configuration="Release DLL" /p:platform=Win32 + msbuild antlr4cpp-vs2017.vcxproj /p:configuration="Release DLL" /p:platform=x64 + popd + + 7z a antlr4-cpp-runtime-vs2017.zip antlr4-runtime + xcopy runtime\bin\*.dll lib\ /s + xcopy runtime\bin\*.lib lib\ /s + 7z a antlr4-cpp-runtime-vs2017.zip lib + + rmdir /S /Q lib + rmdir /S /Q runtime\bin + rmdir /S /Q runtime\obj + + rem if exist antlr4-cpp-runtime-vs2017.zip copy antlr4-cpp-runtime-vs2017.zip ~/antlr/sites/website-antlr4/download +) + +set VCTargetsPath=C:\Program Files (x86)\Microsoft Visual Studio\2019\%1\MSBuild\Microsoft\VC\v160\ +if exist "C:\Program Files (x86)\Microsoft Visual Studio\2019\%1\Common7\Tools\VsDevCmd.bat" ( + echo. + + call "C:\Program Files (x86)\Microsoft Visual Studio\2019\%1\Common7\Tools\VsDevCmd.bat" + + pushd runtime + msbuild antlr4cpp-vs2019.vcxproj /p:configuration="Release DLL" /p:platform=Win32 + msbuild antlr4cpp-vs2019.vcxproj /p:configuration="Release DLL" /p:platform=x64 + popd + + 7z a antlr4-cpp-runtime-vs2019.zip antlr4-runtime + xcopy runtime\bin\*.dll lib\ /s + xcopy runtime\bin\*.lib lib\ /s + 7z a antlr4-cpp-runtime-vs2019.zip lib + + rmdir /S /Q lib + rmdir /S /Q runtime\bin + rmdir /S /Q runtime\obj + + rem if exist antlr4-cpp-runtime-vs2019.zip copy antlr4-cpp-runtime-vs2019.zip ~/antlr/sites/website-antlr4/download +) + +rmdir /S /Q antlr4-runtime +echo. +echo === Build done === + +goto end + +:Usage + +echo This script builds Visual Studio 2017 and/or 2019 libraries of the ANTLR4 runtime. +echo You have to specify the type of your VS installation (Community, Professional etc.) to construct +echo the correct build tools path. +echo. +echo Example: +echo %0 Professional +echo. + +:end diff --git a/antlr/antlr4-runtime/dist/libantlr4-runtime.so.4.9.3 b/antlr/antlr4-runtime/dist/libantlr4-runtime.so.4.9.3 new file mode 100755 index 0000000..a225a67 Binary files /dev/null and b/antlr/antlr4-runtime/dist/libantlr4-runtime.so.4.9.3 differ diff --git a/antlr/antlr4-runtime/runtime/CMakeLists.txt b/antlr/antlr4-runtime/runtime/CMakeLists.txt new file mode 100644 index 0000000..c8b16c6 --- /dev/null +++ b/antlr/antlr4-runtime/runtime/CMakeLists.txt @@ -0,0 +1,167 @@ +include_directories( + ${PROJECT_SOURCE_DIR}/runtime/src + ${PROJECT_SOURCE_DIR}/runtime/src/atn + ${PROJECT_SOURCE_DIR}/runtime/src/dfa + ${PROJECT_SOURCE_DIR}/runtime/src/misc + ${PROJECT_SOURCE_DIR}/runtime/src/support + ${PROJECT_SOURCE_DIR}/runtime/src/tree + ${PROJECT_SOURCE_DIR}/runtime/src/tree/pattern + ${PROJECT_SOURCE_DIR}/runtime/src/tree/xpath +) + + +file(GLOB libantlrcpp_SRC + "${PROJECT_SOURCE_DIR}/runtime/src/*.cpp" + "${PROJECT_SOURCE_DIR}/runtime/src/atn/*.cpp" + "${PROJECT_SOURCE_DIR}/runtime/src/dfa/*.cpp" + "${PROJECT_SOURCE_DIR}/runtime/src/misc/*.cpp" + "${PROJECT_SOURCE_DIR}/runtime/src/support/*.cpp" + "${PROJECT_SOURCE_DIR}/runtime/src/tree/*.cpp" + "${PROJECT_SOURCE_DIR}/runtime/src/tree/pattern/*.cpp" + "${PROJECT_SOURCE_DIR}/runtime/src/tree/xpath/*.cpp" +) + +add_library(antlr4_shared SHARED ${libantlrcpp_SRC}) +add_library(antlr4_static STATIC ${libantlrcpp_SRC}) + +set(LIB_OUTPUT_DIR "${CMAKE_HOME_DIRECTORY}/dist") # put generated libraries here. +message(STATUS "Output libraries to ${LIB_OUTPUT_DIR}") + +# make sure 'make' works fine even if ${LIB_OUTPUT_DIR} is deleted. +add_custom_target(make_lib_output_dir ALL + COMMAND ${CMAKE_COMMAND} -E make_directory ${LIB_OUTPUT_DIR} + ) + +add_dependencies(antlr4_shared make_lib_output_dir) +add_dependencies(antlr4_static make_lib_output_dir) + +find_package(utf8cpp QUIET) + +set(INSTALL_utf8cpp FALSE) + +if (utf8cpp_FOUND) + target_link_libraries(antlr4_shared utf8cpp) + target_link_libraries(antlr4_static utf8cpp) +else() + + # older utf8cpp doesn't define the package above + find_path(utf8cpp_HEADER utf8.h + PATH_SUFFIXES utf8cpp + ) + + if (utf8cpp_HEADER) + include_directories(${utf8cpp_HEADER}) + else() + include(${CMAKE_ROOT}/Modules/ExternalProject.cmake) + set(THIRDPARTY_DIR ${CMAKE_BINARY_DIR}/runtime/thirdparty) + set(UTFCPP_DIR ${THIRDPARTY_DIR}/utfcpp) + ExternalProject_Add( + utf8cpp + GIT_REPOSITORY "https://github.com/nemtrif/utfcpp" + GIT_TAG "v3.1.1" + SOURCE_DIR ${UTFCPP_DIR} + UPDATE_DISCONNECTED 1 + CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=${UTFCPP_DIR}/install -DUTF8_TESTS=off -DUTF8_SAMPLES=off + STEP_TARGETS build) + + include_directories( + ${UTFCPP_DIR}/install/include/utf8cpp + ${UTFCPP_DIR}/install/include/utf8cpp/utf8 + ) + + add_dependencies(antlr4_shared utf8cpp) + add_dependencies(antlr4_static utf8cpp) + set(INSTALL_utf8cpp TRUE) + endif() +endif() + +if(CMAKE_SYSTEM_NAME MATCHES "Linux") + target_link_libraries(antlr4_shared ${UUID_LIBRARIES}) + target_link_libraries(antlr4_static ${UUID_LIBRARIES}) +elseif(APPLE) + target_link_libraries(antlr4_shared ${COREFOUNDATION_LIBRARY}) + target_link_libraries(antlr4_static ${COREFOUNDATION_LIBRARY}) +endif() + +if(CMAKE_CXX_COMPILER_ID MATCHES "MSVC") + set(disabled_compile_warnings "/wd4251") +else() + set(disabled_compile_warnings "-Wno-overloaded-virtual") +endif() + + +if("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang") + set(disabled_compile_warnings "${disabled_compile_warnings} -Wno-dollar-in-identifier-extension -Wno-four-char-constants") +elseif("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU" OR "${CMAKE_CXX_COMPILER_ID}" MATCHES "Intel") + set(disabled_compile_warnings "${disabled_compile_warnings} -Wno-multichar") +endif() + +set(extra_share_compile_flags "") +set(extra_static_compile_flags "") +if(WIN32) + set(extra_share_compile_flags "-DANTLR4CPP_EXPORTS") + set(extra_static_compile_flags "-DANTLR4CPP_STATIC") +endif(WIN32) +if(CMAKE_CXX_COMPILER_ID MATCHES "MSVC") + if(WITH_STATIC_CRT) + target_compile_options(antlr4_shared PRIVATE "/MT$<$:d>") + target_compile_options(antlr4_static PRIVATE "/MT$<$:d>") + else() + target_compile_options(antlr4_shared PRIVATE "/MD$<$:d>") + target_compile_options(antlr4_static PRIVATE "/MD$<$:d>") + endif() +endif() + +set(static_lib_suffix "") +if(CMAKE_CXX_COMPILER_ID MATCHES "MSVC") + set(static_lib_suffix "-static") +endif() + +if(CMAKE_CXX_COMPILER_ID MATCHES "MSVC") + set(extra_share_compile_flags "-DANTLR4CPP_EXPORTS -MP /wd4251") + set(extra_static_compile_flags "-DANTLR4CPP_STATIC -MP") +endif() + +set_target_properties(antlr4_shared + PROPERTIES VERSION ${ANTLR_VERSION} + SOVERSION ${ANTLR_VERSION} + OUTPUT_NAME antlr4-runtime + LIBRARY_OUTPUT_DIRECTORY ${LIB_OUTPUT_DIR} + # TODO: test in windows. DLL is treated as runtime. + # see https://cmake.org/cmake/help/v3.0/prop_tgt/LIBRARY_OUTPUT_DIRECTORY.html + RUNTIME_OUTPUT_DIRECTORY ${LIB_OUTPUT_DIR} + ARCHIVE_OUTPUT_DIRECTORY ${LIB_OUTPUT_DIR} + COMPILE_FLAGS "${disabled_compile_warnings} ${extra_share_compile_flags}") + +set_target_properties(antlr4_static + PROPERTIES VERSION ${ANTLR_VERSION} + SOVERSION ${ANTLR_VERSION} + OUTPUT_NAME "antlr4-runtime${static_lib_suffix}" + ARCHIVE_OUTPUT_DIRECTORY ${LIB_OUTPUT_DIR} + COMPILE_FLAGS "${disabled_compile_warnings} ${extra_static_compile_flags}") + +install(TARGETS antlr4_shared + DESTINATION lib + EXPORT antlr4-targets) +install(TARGETS antlr4_static + DESTINATION lib + EXPORT antlr4-targets) + +install(DIRECTORY "${PROJECT_SOURCE_DIR}/runtime/src/" + DESTINATION "include/antlr4-runtime" + COMPONENT dev + FILES_MATCHING PATTERN "*.h" + ) + +if (INSTALL_utf8cpp) + install(FILES "${UTFCPP_DIR}/source/utf8.h" + DESTINATION "include/antlr4-runtime") + install(DIRECTORY "${UTFCPP_DIR}/source/utf8" + DESTINATION "include/antlr4-runtime" + COMPONENT dev + FILES_MATCHING PATTERN "*.h" + ) +endif() + + + diff --git a/antlr/antlr4-runtime/runtime/antlr4cpp-vs2013.vcxproj b/antlr/antlr4-runtime/runtime/antlr4cpp-vs2013.vcxproj new file mode 100644 index 0000000..47377c1 --- /dev/null +++ b/antlr/antlr4-runtime/runtime/antlr4cpp-vs2013.vcxproj @@ -0,0 +1,637 @@ +๏ปฟ + + + + Debug Static + Win32 + + + Debug Static + x64 + + + Debug DLL + Win32 + + + Debug DLL + x64 + + + Release Static + Win32 + + + Release Static + x64 + + + Release DLL + Win32 + + + Release DLL + x64 + + + + {229A61DC-1207-4E4E-88B0-F4CB7205672D} + Win32Proj + antlr4cpp + + + + DynamicLibrary + true + Unicode + v120 + + + StaticLibrary + true + Unicode + v120 + + + DynamicLibrary + true + Unicode + v120 + + + StaticLibrary + true + Unicode + v120 + + + DynamicLibrary + false + true + Unicode + v120 + + + StaticLibrary + false + true + Unicode + v120 + + + DynamicLibrary + false + true + Unicode + v120 + + + StaticLibrary + false + true + Unicode + v120 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + true + $(SolutionDir)bin\vs-2013\$(PlatformTarget)\$(Configuration)\ + $(SolutionDir)obj\$(PlatformTarget)\$(Configuration)\$(ProjectName)\ + antlr4-runtime + + + true + $(SolutionDir)bin\vs-2013\$(PlatformTarget)\$(Configuration)\ + $(SolutionDir)obj\$(PlatformTarget)\$(Configuration)\$(ProjectName)\ + antlr4-runtime + + + true + $(SolutionDir)bin\vs-2013\$(PlatformTarget)\$(Configuration)\ + $(SolutionDir)obj\$(PlatformTarget)\$(Configuration)\$(ProjectName)\ + antlr4-runtime + + + true + $(SolutionDir)bin\vs-2013\$(PlatformTarget)\$(Configuration)\ + $(SolutionDir)obj\$(PlatformTarget)\$(Configuration)\$(ProjectName)\ + antlr4-runtime + + + false + $(SolutionDir)bin\vs-2013\$(PlatformTarget)\$(Configuration)\ + $(SolutionDir)obj\$(PlatformTarget)\$(Configuration)\$(ProjectName)\ + antlr4-runtime + + + false + $(SolutionDir)bin\vs-2013\$(PlatformTarget)\$(Configuration)\ + $(SolutionDir)obj\$(PlatformTarget)\$(Configuration)\$(ProjectName)\ + antlr4-runtime + + + false + $(SolutionDir)bin\vs-2013\$(PlatformTarget)\$(Configuration)\ + $(SolutionDir)obj\$(PlatformTarget)\$(Configuration)\$(ProjectName)\ + antlr4-runtime + + + false + $(SolutionDir)bin\vs-2013\$(PlatformTarget)\$(Configuration)\ + $(SolutionDir)obj\$(PlatformTarget)\$(Configuration)\$(ProjectName)\ + antlr4-runtime + + + + Level4 + Disabled + ANTLR4CPP_DLL;ANTLR4CPP_EXPORTS;%(PreprocessorDefinitions) + src/tree;src;%(AdditionalIncludeDirectories) + + + + + 4251 + + + Windows + true + + + + + Level4 + Disabled + ANTLR4CPP_EXPORTS;%(PreprocessorDefinitions) + src/tree;src;%(AdditionalIncludeDirectories) + + + + + 4251 + + + Windows + true + + + + + Level4 + Disabled + ANTLR4CPP_DLL;ANTLR4CPP_EXPORTS;%(PreprocessorDefinitions) + src/tree;src;%(AdditionalIncludeDirectories) + + + + + 4251 + + + Windows + true + + + + + Level4 + Disabled + ANTLR4CPP_STATIC;%(PreprocessorDefinitions) + src/tree;src;%(AdditionalIncludeDirectories) + + + + + 4251 + + + Windows + true + + + + + Level4 + MaxSpeed + true + true + ANTLR4CPP_DLL;ANTLR4CPP_EXPORTS;%(PreprocessorDefinitions) + src/tree;src;%(AdditionalIncludeDirectories) + + + + + 4251 + + + Windows + true + true + true + + + + + Level4 + MaxSpeed + true + true + ANTLR4CPP_EXPORTS;%(PreprocessorDefinitions) + src/tree;src;%(AdditionalIncludeDirectories) + + + + + 4251 + + + Windows + true + true + true + + + + + Level4 + MaxSpeed + true + true + ANTLR4CPP_DLL;ANTLR4CPP_EXPORTS;%(PreprocessorDefinitions) + src/tree;src;%(AdditionalIncludeDirectories) + + + + + 4251 + + + Windows + true + true + true + + + + + Level4 + MaxSpeed + true + true + ANTLR4CPP_STATIC;%(PreprocessorDefinitions) + src/tree;src;%(AdditionalIncludeDirectories) + + + + + 4251 + + + Windows + true + true + true + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/antlr/antlr4-runtime/runtime/antlr4cpp-vs2013.vcxproj.filters b/antlr/antlr4-runtime/runtime/antlr4cpp-vs2013.vcxproj.filters new file mode 100644 index 0000000..499a82e --- /dev/null +++ b/antlr/antlr4-runtime/runtime/antlr4cpp-vs2013.vcxproj.filters @@ -0,0 +1,984 @@ +๏ปฟ + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + {587a2726-4856-4d21-937a-fbaebaa90232} + + + {2662156f-1508-4dad-b991-a8298a6db9bf} + + + {5b1e59b1-7fa5-46a5-8d92-965bd709cca0} + + + {9de9fe74-5d67-441d-a972-3cebe6dfbfcc} + + + {89fd3896-0ab1-476d-8d64-a57f10a5e73b} + + + {23939d7b-8e11-421e-80eb-b2cfdfdd64e9} + + + {05f2bacb-b5b2-4ca3-abe1-ca9a7239ecaa} + + + {d3b2ae2d-836b-4c73-8180-aca4ebb7d658} + + + {6674a0f0-c65d-4a00-a9e5-1f243b89d0a2} + + + {1893fffe-7a2b-4708-8ce5-003aa9b749f7} + + + {053a0632-27bc-4043-b5e8-760951b3b5b9} + + + {048c180d-44cf-49ca-a7aa-d0053fea07f5} + + + {3181cae5-cc15-4050-8c45-22af44a823de} + + + {290632d2-c56e-4005-a417-eb83b9531e1a} + + + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\dfa + + + Header Files\dfa + + + Header Files\dfa + + + Header Files\dfa + + + Header Files\misc + + + Header Files\misc + + + Header Files\misc + + + Header Files\misc + + + Header Files\support + + + Header Files\support + + + Header Files\support + + + Header Files\support + + + Header Files\support + + + Header Files\tree + + + Header Files\tree + + + Header Files\tree + + + Header Files\tree + + + Header Files\tree + + + Header Files\tree + + + Header Files\tree + + + Header Files\tree + + + Header Files\tree + + + Header Files\tree + + + Header Files\tree + + + Header Files\tree + + + Header Files\tree + + + Header Files\tree + + + Header Files\tree\pattern + + + Header Files\tree\pattern + + + Header Files\tree\pattern + + + Header Files\tree\pattern + + + Header Files\tree\pattern + + + Header Files\tree\pattern + + + Header Files\tree\pattern + + + Header Files\tree\pattern + + + Header Files\tree\xpath + + + Header Files + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\misc + + + Header Files + + + Header Files + + + Header Files\support + + + Header Files\tree\xpath + + + Header Files\tree\xpath + + + Header Files\tree\xpath + + + Header Files\tree\xpath + + + Header Files\tree\xpath + + + Header Files\tree\xpath + + + Header Files\tree\xpath + + + Header Files\tree\xpath + + + Header Files\tree\xpath + + + Header Files + + + Header Files + + + Header Files\tree + + + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\dfa + + + Source Files\dfa + + + Source Files\dfa + + + Source Files\dfa + + + Source Files\misc + + + Source Files\misc + + + Source Files\misc + + + Source Files\support + + + Source Files\support + + + Source Files\support + + + Source Files\tree + + + Source Files\tree + + + Source Files\tree + + + Source Files\tree + + + Source Files\tree\pattern + + + Source Files\tree\pattern + + + Source Files\tree\pattern + + + Source Files\tree\pattern + + + Source Files\tree\pattern + + + Source Files\tree\pattern + + + Source Files\tree\pattern + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files + + + Source Files + + + Source Files\support + + + Source Files\tree\xpath + + + Source Files\tree\xpath + + + Source Files\tree\xpath + + + Source Files\tree\xpath + + + Source Files\tree\xpath + + + Source Files\tree\xpath + + + Source Files\tree\xpath + + + Source Files\tree\xpath + + + Source Files\tree\xpath + + + Source Files\tree\xpath + + + Source Files + + + Source Files\tree + + + Source Files\tree + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files\tree + + + Source Files\tree + + + Source Files\tree + + + Source Files\tree + + + Source Files\support + + + Source Files\atn + + + Source Files\atn + + + Source Files\tree\pattern + + + Source Files\misc + + + \ No newline at end of file diff --git a/antlr/antlr4-runtime/runtime/antlr4cpp-vs2015.vcxproj b/antlr/antlr4-runtime/runtime/antlr4cpp-vs2015.vcxproj new file mode 100644 index 0000000..9085761 --- /dev/null +++ b/antlr/antlr4-runtime/runtime/antlr4cpp-vs2015.vcxproj @@ -0,0 +1,652 @@ +๏ปฟ + + + + Debug Static + Win32 + + + Debug Static + x64 + + + Debug DLL + Win32 + + + Debug DLL + x64 + + + Release Static + Win32 + + + Release Static + x64 + + + Release DLL + Win32 + + + Release DLL + x64 + + + + {A9762991-1B57-4DCE-90C0-EE42B96947BE} + Win32Proj + antlr4cpp + 8.1 + + + + DynamicLibrary + true + Unicode + v140 + + + StaticLibrary + true + Unicode + v140 + + + DynamicLibrary + true + Unicode + v140 + + + StaticLibrary + true + Unicode + v140 + + + DynamicLibrary + false + true + Unicode + v140 + + + StaticLibrary + false + true + Unicode + v140 + + + DynamicLibrary + false + true + Unicode + v140 + + + StaticLibrary + false + true + Unicode + v140 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + true + $(SolutionDir)bin\vs-2015\$(PlatformTarget)\$(Configuration)\ + $(SolutionDir)obj\$(PlatformTarget)\$(Configuration)\$(ProjectName)\ + antlr4-runtime + + + true + $(SolutionDir)bin\vs-2015\$(PlatformTarget)\$(Configuration)\ + $(SolutionDir)obj\$(PlatformTarget)\$(Configuration)\$(ProjectName)\ + antlr4-runtime + + + true + $(SolutionDir)bin\vs-2015\$(PlatformTarget)\$(Configuration)\ + $(SolutionDir)obj\$(PlatformTarget)\$(Configuration)\$(ProjectName)\ + antlr4-runtime + + + true + $(SolutionDir)bin\vs-2015\$(PlatformTarget)\$(Configuration)\ + $(SolutionDir)obj\$(PlatformTarget)\$(Configuration)\$(ProjectName)\ + antlr4-runtime + + + false + $(SolutionDir)bin\vs-2015\$(PlatformTarget)\$(Configuration)\ + $(SolutionDir)obj\$(PlatformTarget)\$(Configuration)\$(ProjectName)\ + antlr4-runtime + + + false + $(SolutionDir)bin\vs-2015\$(PlatformTarget)\$(Configuration)\ + $(SolutionDir)obj\$(PlatformTarget)\$(Configuration)\$(ProjectName)\ + antlr4-runtime + + + false + $(SolutionDir)bin\vs-2015\$(PlatformTarget)\$(Configuration)\ + $(SolutionDir)obj\$(PlatformTarget)\$(Configuration)\$(ProjectName)\ + antlr4-runtime + + + false + $(SolutionDir)bin\vs-2015\$(PlatformTarget)\$(Configuration)\ + $(SolutionDir)obj\$(PlatformTarget)\$(Configuration)\$(ProjectName)\ + antlr4-runtime + + + + Level4 + Disabled + ANTLR4CPP_EXPORTS;%(PreprocessorDefinitions) + src;%(AdditionalIncludeDirectories) + + + + + 4251 + true + false + + + Windows + true + + + + + Level4 + Disabled + ANTLR4CPP_EXPORTS;%(PreprocessorDefinitions) + src;%(AdditionalIncludeDirectories) + + + + + 4251 + true + false + + + Windows + true + + + + + Level4 + Disabled + ANTLR4CPP_EXPORTS;%(PreprocessorDefinitions) + src;%(AdditionalIncludeDirectories) + + + + + 4251 + true + false + + + Windows + true + + + + + Level4 + Disabled + ANTLR4CPP_STATIC;%(PreprocessorDefinitions) + src;%(AdditionalIncludeDirectories) + + + + + 4251 + true + false + + + Windows + true + + + + + Level4 + MaxSpeed + true + true + ANTLR4CPP_DLL;ANTLR4CPP_EXPORTS;%(PreprocessorDefinitions) + src;%(AdditionalIncludeDirectories) + + + + + 4251 + true + + + Windows + true + true + true + + + + + Level4 + MaxSpeed + true + true + ANTLR4CPP_EXPORTS;%(PreprocessorDefinitions) + src;%(AdditionalIncludeDirectories) + + + + + 4251 + true + + + Windows + true + true + true + + + + + Level4 + MaxSpeed + true + true + ANTLR4CPP_DLL;ANTLR4CPP_EXPORTS;%(PreprocessorDefinitions) + src;%(AdditionalIncludeDirectories) + + + + + 4251 + true + + + Windows + true + true + true + + + + + Level4 + MaxSpeed + true + true + ANTLR4CPP_STATIC;%(PreprocessorDefinitions) + src;%(AdditionalIncludeDirectories) + + + + + 4251 + true + + + Windows + true + true + true + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/antlr/antlr4-runtime/runtime/antlr4cpp-vs2015.vcxproj.filters b/antlr/antlr4-runtime/runtime/antlr4cpp-vs2015.vcxproj.filters new file mode 100644 index 0000000..cc19869 --- /dev/null +++ b/antlr/antlr4-runtime/runtime/antlr4cpp-vs2015.vcxproj.filters @@ -0,0 +1,990 @@ +๏ปฟ + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + {587a2726-4856-4d21-937a-fbaebaa90232} + + + {2662156f-1508-4dad-b991-a8298a6db9bf} + + + {5b1e59b1-7fa5-46a5-8d92-965bd709cca0} + + + {9de9fe74-5d67-441d-a972-3cebe6dfbfcc} + + + {89fd3896-0ab1-476d-8d64-a57f10a5e73b} + + + {23939d7b-8e11-421e-80eb-b2cfdfdd64e9} + + + {05f2bacb-b5b2-4ca3-abe1-ca9a7239ecaa} + + + {d3b2ae2d-836b-4c73-8180-aca4ebb7d658} + + + {6674a0f0-c65d-4a00-a9e5-1f243b89d0a2} + + + {1893fffe-7a2b-4708-8ce5-003aa9b749f7} + + + {053a0632-27bc-4043-b5e8-760951b3b5b9} + + + {048c180d-44cf-49ca-a7aa-d0053fea07f5} + + + {3181cae5-cc15-4050-8c45-22af44a823de} + + + {290632d2-c56e-4005-a417-eb83b9531e1a} + + + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\dfa + + + Header Files\dfa + + + Header Files\dfa + + + Header Files\dfa + + + Header Files\misc + + + Header Files\misc + + + Header Files\misc + + + Header Files\misc + + + Header Files\support + + + Header Files\support + + + Header Files\support + + + Header Files\support + + + Header Files\support + + + Header Files\tree + + + Header Files\tree + + + Header Files\tree + + + Header Files\tree + + + Header Files\tree + + + Header Files\tree + + + Header Files\tree + + + Header Files\tree + + + Header Files\tree + + + Header Files\tree + + + Header Files\tree + + + Header Files\tree + + + Header Files\tree + + + Header Files\tree\pattern + + + Header Files\tree\pattern + + + Header Files\tree\pattern + + + Header Files\tree\pattern + + + Header Files\tree\pattern + + + Header Files\tree\pattern + + + Header Files\tree\pattern + + + Header Files\tree\pattern + + + Header Files\tree\xpath + + + Header Files + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\misc + + + Header Files + + + Header Files + + + Header Files\support + + + Header Files\tree\xpath + + + Header Files\tree\xpath + + + Header Files\tree\xpath + + + Header Files\tree\xpath + + + Header Files\tree\xpath + + + Header Files\tree\xpath + + + Header Files\tree\xpath + + + Header Files\tree\xpath + + + Header Files\tree\xpath + + + Header Files + + + Header Files + + + Source Files\support + + + Header Files\tree + + + Header Files + + + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\dfa + + + Source Files\dfa + + + Source Files\dfa + + + Source Files\dfa + + + Source Files\misc + + + Source Files\misc + + + Source Files\misc + + + Source Files\support + + + Source Files\support + + + Source Files\support + + + Source Files\tree + + + Source Files\tree + + + Source Files\tree + + + Source Files\tree + + + Source Files\tree\pattern + + + Source Files\tree\pattern + + + Source Files\tree\pattern + + + Source Files\tree\pattern + + + Source Files\tree\pattern + + + Source Files\tree\pattern + + + Source Files\tree\pattern + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files + + + Source Files + + + Source Files\support + + + Source Files\tree\xpath + + + Source Files\tree\xpath + + + Source Files\tree\xpath + + + Source Files\tree\xpath + + + Source Files\tree\xpath + + + Source Files\tree\xpath + + + Source Files\tree\xpath + + + Source Files\tree\xpath + + + Source Files\tree\xpath + + + Source Files\tree\xpath + + + Source Files + + + Source Files\tree + + + Source Files\tree + + + Source Files + + + Source Files + + + Source Files + + + Source Files\atn + + + Source Files\atn + + + Source Files\misc + + + Source Files + + + Source Files + + + Source Files + + + Source Files\support + + + Source Files\tree + + + Source Files\tree + + + Source Files\tree + + + Source Files\tree + + + Source Files\tree\pattern + + + \ No newline at end of file diff --git a/antlr/antlr4-runtime/runtime/antlr4cpp-vs2017.vcxproj b/antlr/antlr4-runtime/runtime/antlr4cpp-vs2017.vcxproj new file mode 100644 index 0000000..2c3611c --- /dev/null +++ b/antlr/antlr4-runtime/runtime/antlr4cpp-vs2017.vcxproj @@ -0,0 +1,652 @@ +๏ปฟ + + + + Debug Static + Win32 + + + Debug Static + x64 + + + Debug DLL + Win32 + + + Debug DLL + x64 + + + Release Static + Win32 + + + Release Static + x64 + + + Release DLL + Win32 + + + Release DLL + x64 + + + + {83BE66CD-9C4F-4F84-B72A-DD1855C8FC8A} + Win32Proj + antlr4cpp + 10.0.16299.0 + + + + DynamicLibrary + true + Unicode + v141 + + + StaticLibrary + true + Unicode + v141 + + + DynamicLibrary + true + Unicode + v141 + + + StaticLibrary + true + Unicode + v141 + + + DynamicLibrary + false + true + Unicode + v141 + + + StaticLibrary + false + true + Unicode + v141 + + + DynamicLibrary + false + true + Unicode + v141 + + + StaticLibrary + false + true + Unicode + v141 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + true + $(SolutionDir)bin\vs-2017\$(PlatformTarget)\$(Configuration)\ + $(SolutionDir)obj\$(PlatformTarget)\$(Configuration)\$(ProjectName)\ + antlr4-runtime + + + true + $(SolutionDir)bin\vs-2017\$(PlatformTarget)\$(Configuration)\ + $(SolutionDir)obj\$(PlatformTarget)\$(Configuration)\$(ProjectName)\ + antlr4-runtime + + + true + $(SolutionDir)bin\vs-2017\$(PlatformTarget)\$(Configuration)\ + $(SolutionDir)obj\$(PlatformTarget)\$(Configuration)\$(ProjectName)\ + antlr4-runtime + + + true + $(SolutionDir)bin\vs-2017\$(PlatformTarget)\$(Configuration)\ + $(SolutionDir)obj\$(PlatformTarget)\$(Configuration)\$(ProjectName)\ + antlr4-runtime + + + false + $(SolutionDir)bin\vs-2017\$(PlatformTarget)\$(Configuration)\ + $(SolutionDir)obj\$(PlatformTarget)\$(Configuration)\$(ProjectName)\ + antlr4-runtime + + + false + $(SolutionDir)bin\vs-2017\$(PlatformTarget)\$(Configuration)\ + $(SolutionDir)obj\$(PlatformTarget)\$(Configuration)\$(ProjectName)\ + antlr4-runtime + + + false + $(SolutionDir)bin\vs-2017\$(PlatformTarget)\$(Configuration)\ + $(SolutionDir)obj\$(PlatformTarget)\$(Configuration)\$(ProjectName)\ + antlr4-runtime + + + false + $(SolutionDir)bin\vs-2017\$(PlatformTarget)\$(Configuration)\ + $(SolutionDir)obj\$(PlatformTarget)\$(Configuration)\$(ProjectName)\ + antlr4-runtime + + + + Level4 + Disabled + ANTLR4CPP_EXPORTS;%(PreprocessorDefinitions) + src;%(AdditionalIncludeDirectories) + + + + + 4251 + true + false + + + Windows + true + + + + + Level4 + Disabled + ANTLR4CPP_EXPORTS;%(PreprocessorDefinitions) + src;%(AdditionalIncludeDirectories) + + + + + 4251 + true + false + + + Windows + true + + + + + Level4 + Disabled + ANTLR4CPP_EXPORTS;%(PreprocessorDefinitions) + src;%(AdditionalIncludeDirectories) + + + + + 4251 + true + false + + + Windows + true + + + + + Level4 + Disabled + ANTLR4CPP_STATIC;%(PreprocessorDefinitions) + src;%(AdditionalIncludeDirectories) + + + + + 4251 + true + false + + + Windows + true + + + + + Level4 + MaxSpeed + true + true + ANTLR4CPP_DLL;ANTLR4CPP_EXPORTS;%(PreprocessorDefinitions) + src;%(AdditionalIncludeDirectories) + + + + + 4251 + true + + + Windows + true + true + true + + + + + Level4 + MaxSpeed + true + true + ANTLR4CPP_EXPORTS;%(PreprocessorDefinitions) + src;%(AdditionalIncludeDirectories) + + + + + 4251 + true + + + Windows + true + true + true + + + + + Level4 + MaxSpeed + true + true + ANTLR4CPP_DLL;ANTLR4CPP_EXPORTS;%(PreprocessorDefinitions) + src;%(AdditionalIncludeDirectories) + + + + + 4251 + true + + + Windows + true + true + true + + + + + Level4 + MaxSpeed + true + true + ANTLR4CPP_STATIC;%(PreprocessorDefinitions) + src;%(AdditionalIncludeDirectories) + + + + + 4251 + true + + + Windows + true + true + true + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/antlr/antlr4-runtime/runtime/antlr4cpp-vs2017.vcxproj.filters b/antlr/antlr4-runtime/runtime/antlr4cpp-vs2017.vcxproj.filters new file mode 100644 index 0000000..cc19869 --- /dev/null +++ b/antlr/antlr4-runtime/runtime/antlr4cpp-vs2017.vcxproj.filters @@ -0,0 +1,990 @@ +๏ปฟ + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + {587a2726-4856-4d21-937a-fbaebaa90232} + + + {2662156f-1508-4dad-b991-a8298a6db9bf} + + + {5b1e59b1-7fa5-46a5-8d92-965bd709cca0} + + + {9de9fe74-5d67-441d-a972-3cebe6dfbfcc} + + + {89fd3896-0ab1-476d-8d64-a57f10a5e73b} + + + {23939d7b-8e11-421e-80eb-b2cfdfdd64e9} + + + {05f2bacb-b5b2-4ca3-abe1-ca9a7239ecaa} + + + {d3b2ae2d-836b-4c73-8180-aca4ebb7d658} + + + {6674a0f0-c65d-4a00-a9e5-1f243b89d0a2} + + + {1893fffe-7a2b-4708-8ce5-003aa9b749f7} + + + {053a0632-27bc-4043-b5e8-760951b3b5b9} + + + {048c180d-44cf-49ca-a7aa-d0053fea07f5} + + + {3181cae5-cc15-4050-8c45-22af44a823de} + + + {290632d2-c56e-4005-a417-eb83b9531e1a} + + + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\dfa + + + Header Files\dfa + + + Header Files\dfa + + + Header Files\dfa + + + Header Files\misc + + + Header Files\misc + + + Header Files\misc + + + Header Files\misc + + + Header Files\support + + + Header Files\support + + + Header Files\support + + + Header Files\support + + + Header Files\support + + + Header Files\tree + + + Header Files\tree + + + Header Files\tree + + + Header Files\tree + + + Header Files\tree + + + Header Files\tree + + + Header Files\tree + + + Header Files\tree + + + Header Files\tree + + + Header Files\tree + + + Header Files\tree + + + Header Files\tree + + + Header Files\tree + + + Header Files\tree\pattern + + + Header Files\tree\pattern + + + Header Files\tree\pattern + + + Header Files\tree\pattern + + + Header Files\tree\pattern + + + Header Files\tree\pattern + + + Header Files\tree\pattern + + + Header Files\tree\pattern + + + Header Files\tree\xpath + + + Header Files + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\misc + + + Header Files + + + Header Files + + + Header Files\support + + + Header Files\tree\xpath + + + Header Files\tree\xpath + + + Header Files\tree\xpath + + + Header Files\tree\xpath + + + Header Files\tree\xpath + + + Header Files\tree\xpath + + + Header Files\tree\xpath + + + Header Files\tree\xpath + + + Header Files\tree\xpath + + + Header Files + + + Header Files + + + Source Files\support + + + Header Files\tree + + + Header Files + + + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\dfa + + + Source Files\dfa + + + Source Files\dfa + + + Source Files\dfa + + + Source Files\misc + + + Source Files\misc + + + Source Files\misc + + + Source Files\support + + + Source Files\support + + + Source Files\support + + + Source Files\tree + + + Source Files\tree + + + Source Files\tree + + + Source Files\tree + + + Source Files\tree\pattern + + + Source Files\tree\pattern + + + Source Files\tree\pattern + + + Source Files\tree\pattern + + + Source Files\tree\pattern + + + Source Files\tree\pattern + + + Source Files\tree\pattern + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files + + + Source Files + + + Source Files\support + + + Source Files\tree\xpath + + + Source Files\tree\xpath + + + Source Files\tree\xpath + + + Source Files\tree\xpath + + + Source Files\tree\xpath + + + Source Files\tree\xpath + + + Source Files\tree\xpath + + + Source Files\tree\xpath + + + Source Files\tree\xpath + + + Source Files\tree\xpath + + + Source Files + + + Source Files\tree + + + Source Files\tree + + + Source Files + + + Source Files + + + Source Files + + + Source Files\atn + + + Source Files\atn + + + Source Files\misc + + + Source Files + + + Source Files + + + Source Files + + + Source Files\support + + + Source Files\tree + + + Source Files\tree + + + Source Files\tree + + + Source Files\tree + + + Source Files\tree\pattern + + + \ No newline at end of file diff --git a/antlr/antlr4-runtime/runtime/antlr4cpp-vs2019.vcxproj b/antlr/antlr4-runtime/runtime/antlr4cpp-vs2019.vcxproj new file mode 100644 index 0000000..54f0aeb --- /dev/null +++ b/antlr/antlr4-runtime/runtime/antlr4cpp-vs2019.vcxproj @@ -0,0 +1,660 @@ +๏ปฟ + + + + Debug Static + Win32 + + + Debug Static + x64 + + + Debug DLL + Win32 + + + Debug DLL + x64 + + + Release Static + Win32 + + + Release Static + x64 + + + Release DLL + Win32 + + + Release DLL + x64 + + + + {83BE66CD-9C4F-4F84-B72A-DD1855C8FC8A} + Win32Proj + antlr4cpp + 10.0 + + + + DynamicLibrary + true + Unicode + v142 + + + StaticLibrary + true + Unicode + v142 + + + DynamicLibrary + true + Unicode + v142 + + + StaticLibrary + true + Unicode + v142 + + + DynamicLibrary + false + true + Unicode + v142 + + + StaticLibrary + false + true + Unicode + v142 + + + DynamicLibrary + false + true + Unicode + v142 + + + StaticLibrary + false + true + Unicode + v142 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + true + $(SolutionDir)bin\vs-2019\$(PlatformTarget)\$(Configuration)\ + $(SolutionDir)obj\$(PlatformTarget)\$(Configuration)\$(ProjectName)\ + antlr4-runtime + + + true + $(SolutionDir)bin\vs-2019\$(PlatformTarget)\$(Configuration)\ + $(SolutionDir)obj\$(PlatformTarget)\$(Configuration)\$(ProjectName)\ + antlr4-runtime + + + true + $(SolutionDir)bin\vs-2019\$(PlatformTarget)\$(Configuration)\ + $(SolutionDir)obj\$(PlatformTarget)\$(Configuration)\$(ProjectName)\ + antlr4-runtime + + + true + $(SolutionDir)bin\vs-2019\$(PlatformTarget)\$(Configuration)\ + $(SolutionDir)obj\$(PlatformTarget)\$(Configuration)\$(ProjectName)\ + antlr4-runtime + + + false + $(SolutionDir)bin\vs-2019\$(PlatformTarget)\$(Configuration)\ + $(SolutionDir)obj\$(PlatformTarget)\$(Configuration)\$(ProjectName)\ + antlr4-runtime + + + false + $(SolutionDir)bin\vs-2019\$(PlatformTarget)\$(Configuration)\ + $(SolutionDir)obj\$(PlatformTarget)\$(Configuration)\$(ProjectName)\ + antlr4-runtime + + + false + $(SolutionDir)bin\vs-2019\$(PlatformTarget)\$(Configuration)\ + $(SolutionDir)obj\$(PlatformTarget)\$(Configuration)\$(ProjectName)\ + antlr4-runtime + + + false + $(SolutionDir)bin\vs-2019\$(PlatformTarget)\$(Configuration)\ + $(SolutionDir)obj\$(PlatformTarget)\$(Configuration)\$(ProjectName)\ + antlr4-runtime + + + + Level4 + Disabled + ANTLR4CPP_EXPORTS;%(PreprocessorDefinitions) + src;%(AdditionalIncludeDirectories) + + + + + 4251 + true + false + /Zc:__cplusplus %(AdditionalOptions) + + + Windows + true + + + + + Level4 + Disabled + ANTLR4CPP_EXPORTS;%(PreprocessorDefinitions) + src;%(AdditionalIncludeDirectories) + + + + + 4251 + true + false + /Zc:__cplusplus %(AdditionalOptions) + + + Windows + true + + + + + Level4 + Disabled + ANTLR4CPP_EXPORTS;%(PreprocessorDefinitions) + src;%(AdditionalIncludeDirectories) + + + + + 4251 + true + false + /Zc:__cplusplus %(AdditionalOptions) + + + Windows + true + + + + + Level4 + Disabled + ANTLR4CPP_STATIC;%(PreprocessorDefinitions) + src;%(AdditionalIncludeDirectories) + + + + + 4251 + true + false + /Zc:__cplusplus %(AdditionalOptions) + + + Windows + true + + + + + Level4 + MaxSpeed + true + true + ANTLR4CPP_DLL;ANTLR4CPP_EXPORTS;%(PreprocessorDefinitions) + src;%(AdditionalIncludeDirectories) + + + + + 4251 + true + /Zc:__cplusplus %(AdditionalOptions) + + + Windows + true + true + true + + + + + Level4 + MaxSpeed + true + true + ANTLR4CPP_EXPORTS;%(PreprocessorDefinitions) + src;%(AdditionalIncludeDirectories) + + + + + 4251 + true + /Zc:__cplusplus %(AdditionalOptions) + + + Windows + true + true + true + + + + + Level4 + MaxSpeed + true + true + ANTLR4CPP_DLL;ANTLR4CPP_EXPORTS;%(PreprocessorDefinitions) + src;%(AdditionalIncludeDirectories) + + + + + 4251 + true + /Zc:__cplusplus %(AdditionalOptions) + + + Windows + true + true + true + + + + + Level4 + MaxSpeed + true + true + ANTLR4CPP_STATIC;%(PreprocessorDefinitions) + src;%(AdditionalIncludeDirectories) + + + + + 4251 + true + /Zc:__cplusplus %(AdditionalOptions) + + + Windows + true + true + true + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/antlr/antlr4-runtime/runtime/antlr4cpp-vs2019.vcxproj.filters b/antlr/antlr4-runtime/runtime/antlr4cpp-vs2019.vcxproj.filters new file mode 100644 index 0000000..cc19869 --- /dev/null +++ b/antlr/antlr4-runtime/runtime/antlr4cpp-vs2019.vcxproj.filters @@ -0,0 +1,990 @@ +๏ปฟ + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + {587a2726-4856-4d21-937a-fbaebaa90232} + + + {2662156f-1508-4dad-b991-a8298a6db9bf} + + + {5b1e59b1-7fa5-46a5-8d92-965bd709cca0} + + + {9de9fe74-5d67-441d-a972-3cebe6dfbfcc} + + + {89fd3896-0ab1-476d-8d64-a57f10a5e73b} + + + {23939d7b-8e11-421e-80eb-b2cfdfdd64e9} + + + {05f2bacb-b5b2-4ca3-abe1-ca9a7239ecaa} + + + {d3b2ae2d-836b-4c73-8180-aca4ebb7d658} + + + {6674a0f0-c65d-4a00-a9e5-1f243b89d0a2} + + + {1893fffe-7a2b-4708-8ce5-003aa9b749f7} + + + {053a0632-27bc-4043-b5e8-760951b3b5b9} + + + {048c180d-44cf-49ca-a7aa-d0053fea07f5} + + + {3181cae5-cc15-4050-8c45-22af44a823de} + + + {290632d2-c56e-4005-a417-eb83b9531e1a} + + + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\dfa + + + Header Files\dfa + + + Header Files\dfa + + + Header Files\dfa + + + Header Files\misc + + + Header Files\misc + + + Header Files\misc + + + Header Files\misc + + + Header Files\support + + + Header Files\support + + + Header Files\support + + + Header Files\support + + + Header Files\support + + + Header Files\tree + + + Header Files\tree + + + Header Files\tree + + + Header Files\tree + + + Header Files\tree + + + Header Files\tree + + + Header Files\tree + + + Header Files\tree + + + Header Files\tree + + + Header Files\tree + + + Header Files\tree + + + Header Files\tree + + + Header Files\tree + + + Header Files\tree\pattern + + + Header Files\tree\pattern + + + Header Files\tree\pattern + + + Header Files\tree\pattern + + + Header Files\tree\pattern + + + Header Files\tree\pattern + + + Header Files\tree\pattern + + + Header Files\tree\pattern + + + Header Files\tree\xpath + + + Header Files + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\atn + + + Header Files\misc + + + Header Files + + + Header Files + + + Header Files\support + + + Header Files\tree\xpath + + + Header Files\tree\xpath + + + Header Files\tree\xpath + + + Header Files\tree\xpath + + + Header Files\tree\xpath + + + Header Files\tree\xpath + + + Header Files\tree\xpath + + + Header Files\tree\xpath + + + Header Files\tree\xpath + + + Header Files + + + Header Files + + + Source Files\support + + + Header Files\tree + + + Header Files + + + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\dfa + + + Source Files\dfa + + + Source Files\dfa + + + Source Files\dfa + + + Source Files\misc + + + Source Files\misc + + + Source Files\misc + + + Source Files\support + + + Source Files\support + + + Source Files\support + + + Source Files\tree + + + Source Files\tree + + + Source Files\tree + + + Source Files\tree + + + Source Files\tree\pattern + + + Source Files\tree\pattern + + + Source Files\tree\pattern + + + Source Files\tree\pattern + + + Source Files\tree\pattern + + + Source Files\tree\pattern + + + Source Files\tree\pattern + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files\atn + + + Source Files + + + Source Files + + + Source Files\support + + + Source Files\tree\xpath + + + Source Files\tree\xpath + + + Source Files\tree\xpath + + + Source Files\tree\xpath + + + Source Files\tree\xpath + + + Source Files\tree\xpath + + + Source Files\tree\xpath + + + Source Files\tree\xpath + + + Source Files\tree\xpath + + + Source Files\tree\xpath + + + Source Files + + + Source Files\tree + + + Source Files\tree + + + Source Files + + + Source Files + + + Source Files + + + Source Files\atn + + + Source Files\atn + + + Source Files\misc + + + Source Files + + + Source Files + + + Source Files + + + Source Files\support + + + Source Files\tree + + + Source Files\tree + + + Source Files\tree + + + Source Files\tree + + + Source Files\tree\pattern + + + \ No newline at end of file diff --git a/antlr/antlr4-runtime/runtime/antlrcpp-ios/Info.plist b/antlr/antlr4-runtime/runtime/antlrcpp-ios/Info.plist new file mode 100644 index 0000000..d3de8ee --- /dev/null +++ b/antlr/antlr4-runtime/runtime/antlrcpp-ios/Info.plist @@ -0,0 +1,26 @@ + + + + + CFBundleDevelopmentRegion + en + CFBundleExecutable + $(EXECUTABLE_NAME) + CFBundleIdentifier + $(PRODUCT_BUNDLE_IDENTIFIER) + CFBundleInfoDictionaryVersion + 6.0 + CFBundleName + $(PRODUCT_NAME) + CFBundlePackageType + FMWK + CFBundleShortVersionString + 1.0 + CFBundleSignature + ???? + CFBundleVersion + $(CURRENT_PROJECT_VERSION) + NSPrincipalClass + + + diff --git a/antlr/antlr4-runtime/runtime/antlrcpp-ios/antlrcpp_ios.h b/antlr/antlr4-runtime/runtime/antlrcpp-ios/antlrcpp_ios.h new file mode 100644 index 0000000..bd6b3d4 --- /dev/null +++ b/antlr/antlr4-runtime/runtime/antlrcpp-ios/antlrcpp_ios.h @@ -0,0 +1,17 @@ +// +// antlrcpp-ios.h +// antlrcpp-ios +// +// Created by Mike Lischke on 05.05.16. +// Copyright ยฉ 2016 Mike Lischke. All rights reserved. +// + +#import + +//! Project version number for antlrcpp-ios. +FOUNDATION_EXPORT double antlrcpp_iosVersionNumber; + +//! Project version string for antlrcpp-ios. +FOUNDATION_EXPORT const unsigned char antlrcpp_iosVersionString[]; + +#include "antlr4-runtime.h" diff --git a/antlr/antlr4-runtime/runtime/antlrcpp.xcodeproj/project.pbxproj b/antlr/antlr4-runtime/runtime/antlrcpp.xcodeproj/project.pbxproj new file mode 100644 index 0000000..17ab198 --- /dev/null +++ b/antlr/antlr4-runtime/runtime/antlrcpp.xcodeproj/project.pbxproj @@ -0,0 +1,3040 @@ +// !$*UTF8*$! +{ + archiveVersion = 1; + classes = { + }; + objectVersion = 54; + objects = { + +/* Begin PBXBuildFile section */ + 270C67F31CDB4F1E00116E17 /* antlrcpp_ios.h in Headers */ = {isa = PBXBuildFile; fileRef = 270C67F21CDB4F1E00116E17 /* antlrcpp_ios.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 270C69E01CDB536A00116E17 /* CoreFoundation.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 270C69DF1CDB536A00116E17 /* CoreFoundation.framework */; }; + 276566E01DA93BFB000869BE /* ParseTree.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276566DF1DA93BFB000869BE /* ParseTree.cpp */; }; + 276566E11DA93BFB000869BE /* ParseTree.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276566DF1DA93BFB000869BE /* ParseTree.cpp */; }; + 276566E21DA93BFB000869BE /* ParseTree.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276566DF1DA93BFB000869BE /* ParseTree.cpp */; }; + 276E5D2E1CDB57AA003FF4B4 /* ANTLRErrorListener.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C0C1CDB57AA003FF4B4 /* ANTLRErrorListener.h */; }; + 276E5D2F1CDB57AA003FF4B4 /* ANTLRErrorListener.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C0C1CDB57AA003FF4B4 /* ANTLRErrorListener.h */; }; + 276E5D301CDB57AA003FF4B4 /* ANTLRErrorListener.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C0C1CDB57AA003FF4B4 /* ANTLRErrorListener.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5D311CDB57AA003FF4B4 /* ANTLRErrorStrategy.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C0D1CDB57AA003FF4B4 /* ANTLRErrorStrategy.h */; }; + 276E5D321CDB57AA003FF4B4 /* ANTLRErrorStrategy.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C0D1CDB57AA003FF4B4 /* ANTLRErrorStrategy.h */; }; + 276E5D331CDB57AA003FF4B4 /* ANTLRErrorStrategy.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C0D1CDB57AA003FF4B4 /* ANTLRErrorStrategy.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5D341CDB57AA003FF4B4 /* ANTLRFileStream.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C0E1CDB57AA003FF4B4 /* ANTLRFileStream.cpp */; }; + 276E5D351CDB57AA003FF4B4 /* ANTLRFileStream.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C0E1CDB57AA003FF4B4 /* ANTLRFileStream.cpp */; }; + 276E5D361CDB57AA003FF4B4 /* ANTLRFileStream.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C0E1CDB57AA003FF4B4 /* ANTLRFileStream.cpp */; }; + 276E5D371CDB57AA003FF4B4 /* ANTLRFileStream.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C0F1CDB57AA003FF4B4 /* ANTLRFileStream.h */; }; + 276E5D381CDB57AA003FF4B4 /* ANTLRFileStream.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C0F1CDB57AA003FF4B4 /* ANTLRFileStream.h */; }; + 276E5D391CDB57AA003FF4B4 /* ANTLRFileStream.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C0F1CDB57AA003FF4B4 /* ANTLRFileStream.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5D3A1CDB57AA003FF4B4 /* ANTLRInputStream.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C101CDB57AA003FF4B4 /* ANTLRInputStream.cpp */; }; + 276E5D3B1CDB57AA003FF4B4 /* ANTLRInputStream.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C101CDB57AA003FF4B4 /* ANTLRInputStream.cpp */; }; + 276E5D3C1CDB57AA003FF4B4 /* ANTLRInputStream.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C101CDB57AA003FF4B4 /* ANTLRInputStream.cpp */; }; + 276E5D3D1CDB57AA003FF4B4 /* ANTLRInputStream.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C111CDB57AA003FF4B4 /* ANTLRInputStream.h */; }; + 276E5D3E1CDB57AA003FF4B4 /* ANTLRInputStream.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C111CDB57AA003FF4B4 /* ANTLRInputStream.h */; }; + 276E5D3F1CDB57AA003FF4B4 /* ANTLRInputStream.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C111CDB57AA003FF4B4 /* ANTLRInputStream.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5D401CDB57AA003FF4B4 /* AbstractPredicateTransition.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C131CDB57AA003FF4B4 /* AbstractPredicateTransition.cpp */; }; + 276E5D411CDB57AA003FF4B4 /* AbstractPredicateTransition.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C131CDB57AA003FF4B4 /* AbstractPredicateTransition.cpp */; }; + 276E5D421CDB57AA003FF4B4 /* AbstractPredicateTransition.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C131CDB57AA003FF4B4 /* AbstractPredicateTransition.cpp */; }; + 276E5D431CDB57AA003FF4B4 /* AbstractPredicateTransition.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C141CDB57AA003FF4B4 /* AbstractPredicateTransition.h */; }; + 276E5D441CDB57AA003FF4B4 /* AbstractPredicateTransition.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C141CDB57AA003FF4B4 /* AbstractPredicateTransition.h */; }; + 276E5D451CDB57AA003FF4B4 /* AbstractPredicateTransition.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C141CDB57AA003FF4B4 /* AbstractPredicateTransition.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5D461CDB57AA003FF4B4 /* ActionTransition.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C151CDB57AA003FF4B4 /* ActionTransition.cpp */; }; + 276E5D471CDB57AA003FF4B4 /* ActionTransition.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C151CDB57AA003FF4B4 /* ActionTransition.cpp */; }; + 276E5D481CDB57AA003FF4B4 /* ActionTransition.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C151CDB57AA003FF4B4 /* ActionTransition.cpp */; }; + 276E5D491CDB57AA003FF4B4 /* ActionTransition.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C161CDB57AA003FF4B4 /* ActionTransition.h */; }; + 276E5D4A1CDB57AA003FF4B4 /* ActionTransition.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C161CDB57AA003FF4B4 /* ActionTransition.h */; }; + 276E5D4B1CDB57AA003FF4B4 /* ActionTransition.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C161CDB57AA003FF4B4 /* ActionTransition.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5D4C1CDB57AA003FF4B4 /* AmbiguityInfo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C171CDB57AA003FF4B4 /* AmbiguityInfo.cpp */; }; + 276E5D4D1CDB57AA003FF4B4 /* AmbiguityInfo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C171CDB57AA003FF4B4 /* AmbiguityInfo.cpp */; }; + 276E5D4E1CDB57AA003FF4B4 /* AmbiguityInfo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C171CDB57AA003FF4B4 /* AmbiguityInfo.cpp */; }; + 276E5D4F1CDB57AA003FF4B4 /* AmbiguityInfo.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C181CDB57AA003FF4B4 /* AmbiguityInfo.h */; }; + 276E5D501CDB57AA003FF4B4 /* AmbiguityInfo.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C181CDB57AA003FF4B4 /* AmbiguityInfo.h */; }; + 276E5D511CDB57AA003FF4B4 /* AmbiguityInfo.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C181CDB57AA003FF4B4 /* AmbiguityInfo.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5D521CDB57AA003FF4B4 /* ArrayPredictionContext.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C191CDB57AA003FF4B4 /* ArrayPredictionContext.cpp */; }; + 276E5D531CDB57AA003FF4B4 /* ArrayPredictionContext.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C191CDB57AA003FF4B4 /* ArrayPredictionContext.cpp */; }; + 276E5D541CDB57AA003FF4B4 /* ArrayPredictionContext.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C191CDB57AA003FF4B4 /* ArrayPredictionContext.cpp */; }; + 276E5D551CDB57AA003FF4B4 /* ArrayPredictionContext.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C1A1CDB57AA003FF4B4 /* ArrayPredictionContext.h */; }; + 276E5D561CDB57AA003FF4B4 /* ArrayPredictionContext.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C1A1CDB57AA003FF4B4 /* ArrayPredictionContext.h */; }; + 276E5D571CDB57AA003FF4B4 /* ArrayPredictionContext.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C1A1CDB57AA003FF4B4 /* ArrayPredictionContext.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5D581CDB57AA003FF4B4 /* ATN.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C1B1CDB57AA003FF4B4 /* ATN.cpp */; }; + 276E5D591CDB57AA003FF4B4 /* ATN.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C1B1CDB57AA003FF4B4 /* ATN.cpp */; }; + 276E5D5A1CDB57AA003FF4B4 /* ATN.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C1B1CDB57AA003FF4B4 /* ATN.cpp */; }; + 276E5D5B1CDB57AA003FF4B4 /* ATN.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C1C1CDB57AA003FF4B4 /* ATN.h */; }; + 276E5D5C1CDB57AA003FF4B4 /* ATN.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C1C1CDB57AA003FF4B4 /* ATN.h */; }; + 276E5D5D1CDB57AA003FF4B4 /* ATN.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C1C1CDB57AA003FF4B4 /* ATN.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5D5E1CDB57AA003FF4B4 /* ATNConfig.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C1D1CDB57AA003FF4B4 /* ATNConfig.cpp */; }; + 276E5D5F1CDB57AA003FF4B4 /* ATNConfig.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C1D1CDB57AA003FF4B4 /* ATNConfig.cpp */; }; + 276E5D601CDB57AA003FF4B4 /* ATNConfig.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C1D1CDB57AA003FF4B4 /* ATNConfig.cpp */; }; + 276E5D611CDB57AA003FF4B4 /* ATNConfig.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C1E1CDB57AA003FF4B4 /* ATNConfig.h */; }; + 276E5D621CDB57AA003FF4B4 /* ATNConfig.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C1E1CDB57AA003FF4B4 /* ATNConfig.h */; }; + 276E5D631CDB57AA003FF4B4 /* ATNConfig.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C1E1CDB57AA003FF4B4 /* ATNConfig.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5D641CDB57AA003FF4B4 /* ATNConfigSet.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C1F1CDB57AA003FF4B4 /* ATNConfigSet.cpp */; }; + 276E5D651CDB57AA003FF4B4 /* ATNConfigSet.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C1F1CDB57AA003FF4B4 /* ATNConfigSet.cpp */; }; + 276E5D661CDB57AA003FF4B4 /* ATNConfigSet.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C1F1CDB57AA003FF4B4 /* ATNConfigSet.cpp */; }; + 276E5D671CDB57AA003FF4B4 /* ATNConfigSet.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C201CDB57AA003FF4B4 /* ATNConfigSet.h */; }; + 276E5D681CDB57AA003FF4B4 /* ATNConfigSet.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C201CDB57AA003FF4B4 /* ATNConfigSet.h */; }; + 276E5D691CDB57AA003FF4B4 /* ATNConfigSet.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C201CDB57AA003FF4B4 /* ATNConfigSet.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5D6A1CDB57AA003FF4B4 /* ATNDeserializationOptions.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C211CDB57AA003FF4B4 /* ATNDeserializationOptions.cpp */; }; + 276E5D6B1CDB57AA003FF4B4 /* ATNDeserializationOptions.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C211CDB57AA003FF4B4 /* ATNDeserializationOptions.cpp */; }; + 276E5D6C1CDB57AA003FF4B4 /* ATNDeserializationOptions.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C211CDB57AA003FF4B4 /* ATNDeserializationOptions.cpp */; }; + 276E5D6D1CDB57AA003FF4B4 /* ATNDeserializationOptions.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C221CDB57AA003FF4B4 /* ATNDeserializationOptions.h */; }; + 276E5D6E1CDB57AA003FF4B4 /* ATNDeserializationOptions.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C221CDB57AA003FF4B4 /* ATNDeserializationOptions.h */; }; + 276E5D6F1CDB57AA003FF4B4 /* ATNDeserializationOptions.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C221CDB57AA003FF4B4 /* ATNDeserializationOptions.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5D701CDB57AA003FF4B4 /* ATNDeserializer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C231CDB57AA003FF4B4 /* ATNDeserializer.cpp */; }; + 276E5D711CDB57AA003FF4B4 /* ATNDeserializer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C231CDB57AA003FF4B4 /* ATNDeserializer.cpp */; }; + 276E5D721CDB57AA003FF4B4 /* ATNDeserializer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C231CDB57AA003FF4B4 /* ATNDeserializer.cpp */; }; + 276E5D731CDB57AA003FF4B4 /* ATNDeserializer.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C241CDB57AA003FF4B4 /* ATNDeserializer.h */; }; + 276E5D741CDB57AA003FF4B4 /* ATNDeserializer.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C241CDB57AA003FF4B4 /* ATNDeserializer.h */; }; + 276E5D751CDB57AA003FF4B4 /* ATNDeserializer.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C241CDB57AA003FF4B4 /* ATNDeserializer.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5D761CDB57AA003FF4B4 /* ATNSerializer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C251CDB57AA003FF4B4 /* ATNSerializer.cpp */; }; + 276E5D771CDB57AA003FF4B4 /* ATNSerializer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C251CDB57AA003FF4B4 /* ATNSerializer.cpp */; }; + 276E5D781CDB57AA003FF4B4 /* ATNSerializer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C251CDB57AA003FF4B4 /* ATNSerializer.cpp */; }; + 276E5D791CDB57AA003FF4B4 /* ATNSerializer.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C261CDB57AA003FF4B4 /* ATNSerializer.h */; }; + 276E5D7A1CDB57AA003FF4B4 /* ATNSerializer.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C261CDB57AA003FF4B4 /* ATNSerializer.h */; }; + 276E5D7B1CDB57AA003FF4B4 /* ATNSerializer.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C261CDB57AA003FF4B4 /* ATNSerializer.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5D7C1CDB57AA003FF4B4 /* ATNSimulator.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C271CDB57AA003FF4B4 /* ATNSimulator.cpp */; }; + 276E5D7D1CDB57AA003FF4B4 /* ATNSimulator.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C271CDB57AA003FF4B4 /* ATNSimulator.cpp */; }; + 276E5D7E1CDB57AA003FF4B4 /* ATNSimulator.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C271CDB57AA003FF4B4 /* ATNSimulator.cpp */; }; + 276E5D7F1CDB57AA003FF4B4 /* ATNSimulator.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C281CDB57AA003FF4B4 /* ATNSimulator.h */; }; + 276E5D801CDB57AA003FF4B4 /* ATNSimulator.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C281CDB57AA003FF4B4 /* ATNSimulator.h */; }; + 276E5D811CDB57AA003FF4B4 /* ATNSimulator.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C281CDB57AA003FF4B4 /* ATNSimulator.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5D821CDB57AA003FF4B4 /* ATNState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C291CDB57AA003FF4B4 /* ATNState.cpp */; }; + 276E5D831CDB57AA003FF4B4 /* ATNState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C291CDB57AA003FF4B4 /* ATNState.cpp */; }; + 276E5D841CDB57AA003FF4B4 /* ATNState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C291CDB57AA003FF4B4 /* ATNState.cpp */; }; + 276E5D851CDB57AA003FF4B4 /* ATNState.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C2A1CDB57AA003FF4B4 /* ATNState.h */; }; + 276E5D861CDB57AA003FF4B4 /* ATNState.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C2A1CDB57AA003FF4B4 /* ATNState.h */; }; + 276E5D871CDB57AA003FF4B4 /* ATNState.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C2A1CDB57AA003FF4B4 /* ATNState.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5D8B1CDB57AA003FF4B4 /* ATNType.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C2C1CDB57AA003FF4B4 /* ATNType.h */; }; + 276E5D8C1CDB57AA003FF4B4 /* ATNType.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C2C1CDB57AA003FF4B4 /* ATNType.h */; }; + 276E5D8D1CDB57AA003FF4B4 /* ATNType.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C2C1CDB57AA003FF4B4 /* ATNType.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5D8E1CDB57AA003FF4B4 /* AtomTransition.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C2D1CDB57AA003FF4B4 /* AtomTransition.cpp */; }; + 276E5D8F1CDB57AA003FF4B4 /* AtomTransition.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C2D1CDB57AA003FF4B4 /* AtomTransition.cpp */; }; + 276E5D901CDB57AA003FF4B4 /* AtomTransition.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C2D1CDB57AA003FF4B4 /* AtomTransition.cpp */; }; + 276E5D911CDB57AA003FF4B4 /* AtomTransition.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C2E1CDB57AA003FF4B4 /* AtomTransition.h */; }; + 276E5D921CDB57AA003FF4B4 /* AtomTransition.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C2E1CDB57AA003FF4B4 /* AtomTransition.h */; }; + 276E5D931CDB57AA003FF4B4 /* AtomTransition.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C2E1CDB57AA003FF4B4 /* AtomTransition.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5D941CDB57AA003FF4B4 /* BasicBlockStartState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C2F1CDB57AA003FF4B4 /* BasicBlockStartState.cpp */; }; + 276E5D951CDB57AA003FF4B4 /* BasicBlockStartState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C2F1CDB57AA003FF4B4 /* BasicBlockStartState.cpp */; }; + 276E5D961CDB57AA003FF4B4 /* BasicBlockStartState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C2F1CDB57AA003FF4B4 /* BasicBlockStartState.cpp */; }; + 276E5D971CDB57AA003FF4B4 /* BasicBlockStartState.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C301CDB57AA003FF4B4 /* BasicBlockStartState.h */; }; + 276E5D981CDB57AA003FF4B4 /* BasicBlockStartState.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C301CDB57AA003FF4B4 /* BasicBlockStartState.h */; }; + 276E5D991CDB57AA003FF4B4 /* BasicBlockStartState.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C301CDB57AA003FF4B4 /* BasicBlockStartState.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5D9A1CDB57AA003FF4B4 /* BasicState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C311CDB57AA003FF4B4 /* BasicState.cpp */; }; + 276E5D9B1CDB57AA003FF4B4 /* BasicState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C311CDB57AA003FF4B4 /* BasicState.cpp */; }; + 276E5D9C1CDB57AA003FF4B4 /* BasicState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C311CDB57AA003FF4B4 /* BasicState.cpp */; }; + 276E5D9D1CDB57AA003FF4B4 /* BasicState.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C321CDB57AA003FF4B4 /* BasicState.h */; }; + 276E5D9E1CDB57AA003FF4B4 /* BasicState.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C321CDB57AA003FF4B4 /* BasicState.h */; }; + 276E5D9F1CDB57AA003FF4B4 /* BasicState.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C321CDB57AA003FF4B4 /* BasicState.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5DA01CDB57AA003FF4B4 /* BlockEndState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C331CDB57AA003FF4B4 /* BlockEndState.cpp */; }; + 276E5DA11CDB57AA003FF4B4 /* BlockEndState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C331CDB57AA003FF4B4 /* BlockEndState.cpp */; }; + 276E5DA21CDB57AA003FF4B4 /* BlockEndState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C331CDB57AA003FF4B4 /* BlockEndState.cpp */; }; + 276E5DA31CDB57AA003FF4B4 /* BlockEndState.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C341CDB57AA003FF4B4 /* BlockEndState.h */; }; + 276E5DA41CDB57AA003FF4B4 /* BlockEndState.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C341CDB57AA003FF4B4 /* BlockEndState.h */; }; + 276E5DA51CDB57AA003FF4B4 /* BlockEndState.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C341CDB57AA003FF4B4 /* BlockEndState.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5DA61CDB57AA003FF4B4 /* BlockStartState.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C351CDB57AA003FF4B4 /* BlockStartState.h */; }; + 276E5DA71CDB57AA003FF4B4 /* BlockStartState.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C351CDB57AA003FF4B4 /* BlockStartState.h */; }; + 276E5DA81CDB57AA003FF4B4 /* BlockStartState.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C351CDB57AA003FF4B4 /* BlockStartState.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5DAC1CDB57AA003FF4B4 /* ContextSensitivityInfo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C371CDB57AA003FF4B4 /* ContextSensitivityInfo.cpp */; }; + 276E5DAD1CDB57AA003FF4B4 /* ContextSensitivityInfo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C371CDB57AA003FF4B4 /* ContextSensitivityInfo.cpp */; }; + 276E5DAE1CDB57AA003FF4B4 /* ContextSensitivityInfo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C371CDB57AA003FF4B4 /* ContextSensitivityInfo.cpp */; }; + 276E5DAF1CDB57AA003FF4B4 /* ContextSensitivityInfo.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C381CDB57AA003FF4B4 /* ContextSensitivityInfo.h */; }; + 276E5DB01CDB57AA003FF4B4 /* ContextSensitivityInfo.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C381CDB57AA003FF4B4 /* ContextSensitivityInfo.h */; }; + 276E5DB11CDB57AA003FF4B4 /* ContextSensitivityInfo.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C381CDB57AA003FF4B4 /* ContextSensitivityInfo.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5DB21CDB57AA003FF4B4 /* DecisionEventInfo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C391CDB57AA003FF4B4 /* DecisionEventInfo.cpp */; }; + 276E5DB31CDB57AA003FF4B4 /* DecisionEventInfo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C391CDB57AA003FF4B4 /* DecisionEventInfo.cpp */; }; + 276E5DB41CDB57AA003FF4B4 /* DecisionEventInfo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C391CDB57AA003FF4B4 /* DecisionEventInfo.cpp */; }; + 276E5DB51CDB57AA003FF4B4 /* DecisionEventInfo.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C3A1CDB57AA003FF4B4 /* DecisionEventInfo.h */; }; + 276E5DB61CDB57AA003FF4B4 /* DecisionEventInfo.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C3A1CDB57AA003FF4B4 /* DecisionEventInfo.h */; }; + 276E5DB71CDB57AA003FF4B4 /* DecisionEventInfo.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C3A1CDB57AA003FF4B4 /* DecisionEventInfo.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5DB81CDB57AA003FF4B4 /* DecisionInfo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C3B1CDB57AA003FF4B4 /* DecisionInfo.cpp */; }; + 276E5DB91CDB57AA003FF4B4 /* DecisionInfo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C3B1CDB57AA003FF4B4 /* DecisionInfo.cpp */; }; + 276E5DBA1CDB57AA003FF4B4 /* DecisionInfo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C3B1CDB57AA003FF4B4 /* DecisionInfo.cpp */; }; + 276E5DBB1CDB57AA003FF4B4 /* DecisionInfo.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C3C1CDB57AA003FF4B4 /* DecisionInfo.h */; }; + 276E5DBC1CDB57AA003FF4B4 /* DecisionInfo.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C3C1CDB57AA003FF4B4 /* DecisionInfo.h */; }; + 276E5DBD1CDB57AA003FF4B4 /* DecisionInfo.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C3C1CDB57AA003FF4B4 /* DecisionInfo.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5DBE1CDB57AA003FF4B4 /* DecisionState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C3D1CDB57AA003FF4B4 /* DecisionState.cpp */; }; + 276E5DBF1CDB57AA003FF4B4 /* DecisionState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C3D1CDB57AA003FF4B4 /* DecisionState.cpp */; }; + 276E5DC01CDB57AA003FF4B4 /* DecisionState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C3D1CDB57AA003FF4B4 /* DecisionState.cpp */; }; + 276E5DC11CDB57AA003FF4B4 /* DecisionState.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C3E1CDB57AA003FF4B4 /* DecisionState.h */; }; + 276E5DC21CDB57AA003FF4B4 /* DecisionState.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C3E1CDB57AA003FF4B4 /* DecisionState.h */; }; + 276E5DC31CDB57AA003FF4B4 /* DecisionState.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C3E1CDB57AA003FF4B4 /* DecisionState.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5DC41CDB57AA003FF4B4 /* EmptyPredictionContext.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C3F1CDB57AA003FF4B4 /* EmptyPredictionContext.cpp */; }; + 276E5DC51CDB57AA003FF4B4 /* EmptyPredictionContext.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C3F1CDB57AA003FF4B4 /* EmptyPredictionContext.cpp */; }; + 276E5DC61CDB57AA003FF4B4 /* EmptyPredictionContext.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C3F1CDB57AA003FF4B4 /* EmptyPredictionContext.cpp */; }; + 276E5DC71CDB57AA003FF4B4 /* EmptyPredictionContext.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C401CDB57AA003FF4B4 /* EmptyPredictionContext.h */; }; + 276E5DC81CDB57AA003FF4B4 /* EmptyPredictionContext.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C401CDB57AA003FF4B4 /* EmptyPredictionContext.h */; }; + 276E5DC91CDB57AA003FF4B4 /* EmptyPredictionContext.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C401CDB57AA003FF4B4 /* EmptyPredictionContext.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5DCA1CDB57AA003FF4B4 /* EpsilonTransition.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C411CDB57AA003FF4B4 /* EpsilonTransition.cpp */; }; + 276E5DCB1CDB57AA003FF4B4 /* EpsilonTransition.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C411CDB57AA003FF4B4 /* EpsilonTransition.cpp */; }; + 276E5DCC1CDB57AA003FF4B4 /* EpsilonTransition.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C411CDB57AA003FF4B4 /* EpsilonTransition.cpp */; }; + 276E5DCD1CDB57AA003FF4B4 /* EpsilonTransition.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C421CDB57AA003FF4B4 /* EpsilonTransition.h */; }; + 276E5DCE1CDB57AA003FF4B4 /* EpsilonTransition.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C421CDB57AA003FF4B4 /* EpsilonTransition.h */; }; + 276E5DCF1CDB57AA003FF4B4 /* EpsilonTransition.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C421CDB57AA003FF4B4 /* EpsilonTransition.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5DD01CDB57AA003FF4B4 /* ErrorInfo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C431CDB57AA003FF4B4 /* ErrorInfo.cpp */; }; + 276E5DD11CDB57AA003FF4B4 /* ErrorInfo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C431CDB57AA003FF4B4 /* ErrorInfo.cpp */; }; + 276E5DD21CDB57AA003FF4B4 /* ErrorInfo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C431CDB57AA003FF4B4 /* ErrorInfo.cpp */; }; + 276E5DD31CDB57AA003FF4B4 /* ErrorInfo.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C441CDB57AA003FF4B4 /* ErrorInfo.h */; }; + 276E5DD41CDB57AA003FF4B4 /* ErrorInfo.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C441CDB57AA003FF4B4 /* ErrorInfo.h */; }; + 276E5DD51CDB57AA003FF4B4 /* ErrorInfo.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C441CDB57AA003FF4B4 /* ErrorInfo.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5DD61CDB57AA003FF4B4 /* LexerAction.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C451CDB57AA003FF4B4 /* LexerAction.h */; }; + 276E5DD71CDB57AA003FF4B4 /* LexerAction.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C451CDB57AA003FF4B4 /* LexerAction.h */; }; + 276E5DD81CDB57AA003FF4B4 /* LexerAction.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C451CDB57AA003FF4B4 /* LexerAction.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5DD91CDB57AA003FF4B4 /* LexerActionExecutor.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C461CDB57AA003FF4B4 /* LexerActionExecutor.cpp */; }; + 276E5DDA1CDB57AA003FF4B4 /* LexerActionExecutor.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C461CDB57AA003FF4B4 /* LexerActionExecutor.cpp */; }; + 276E5DDB1CDB57AA003FF4B4 /* LexerActionExecutor.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C461CDB57AA003FF4B4 /* LexerActionExecutor.cpp */; }; + 276E5DDC1CDB57AA003FF4B4 /* LexerActionExecutor.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C471CDB57AA003FF4B4 /* LexerActionExecutor.h */; }; + 276E5DDD1CDB57AA003FF4B4 /* LexerActionExecutor.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C471CDB57AA003FF4B4 /* LexerActionExecutor.h */; }; + 276E5DDE1CDB57AA003FF4B4 /* LexerActionExecutor.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C471CDB57AA003FF4B4 /* LexerActionExecutor.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5DE21CDB57AA003FF4B4 /* LexerActionType.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C491CDB57AA003FF4B4 /* LexerActionType.h */; }; + 276E5DE31CDB57AA003FF4B4 /* LexerActionType.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C491CDB57AA003FF4B4 /* LexerActionType.h */; }; + 276E5DE41CDB57AA003FF4B4 /* LexerActionType.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C491CDB57AA003FF4B4 /* LexerActionType.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5DE51CDB57AA003FF4B4 /* LexerATNConfig.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C4A1CDB57AA003FF4B4 /* LexerATNConfig.cpp */; }; + 276E5DE61CDB57AA003FF4B4 /* LexerATNConfig.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C4A1CDB57AA003FF4B4 /* LexerATNConfig.cpp */; }; + 276E5DE71CDB57AA003FF4B4 /* LexerATNConfig.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C4A1CDB57AA003FF4B4 /* LexerATNConfig.cpp */; }; + 276E5DE81CDB57AA003FF4B4 /* LexerATNConfig.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C4B1CDB57AA003FF4B4 /* LexerATNConfig.h */; }; + 276E5DE91CDB57AA003FF4B4 /* LexerATNConfig.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C4B1CDB57AA003FF4B4 /* LexerATNConfig.h */; }; + 276E5DEA1CDB57AA003FF4B4 /* LexerATNConfig.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C4B1CDB57AA003FF4B4 /* LexerATNConfig.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5DEB1CDB57AA003FF4B4 /* LexerATNSimulator.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C4C1CDB57AA003FF4B4 /* LexerATNSimulator.cpp */; }; + 276E5DEC1CDB57AA003FF4B4 /* LexerATNSimulator.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C4C1CDB57AA003FF4B4 /* LexerATNSimulator.cpp */; }; + 276E5DED1CDB57AA003FF4B4 /* LexerATNSimulator.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C4C1CDB57AA003FF4B4 /* LexerATNSimulator.cpp */; }; + 276E5DEE1CDB57AA003FF4B4 /* LexerATNSimulator.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C4D1CDB57AA003FF4B4 /* LexerATNSimulator.h */; }; + 276E5DEF1CDB57AA003FF4B4 /* LexerATNSimulator.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C4D1CDB57AA003FF4B4 /* LexerATNSimulator.h */; }; + 276E5DF01CDB57AA003FF4B4 /* LexerATNSimulator.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C4D1CDB57AA003FF4B4 /* LexerATNSimulator.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5DF11CDB57AA003FF4B4 /* LexerChannelAction.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C4E1CDB57AA003FF4B4 /* LexerChannelAction.cpp */; }; + 276E5DF21CDB57AA003FF4B4 /* LexerChannelAction.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C4E1CDB57AA003FF4B4 /* LexerChannelAction.cpp */; }; + 276E5DF31CDB57AA003FF4B4 /* LexerChannelAction.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C4E1CDB57AA003FF4B4 /* LexerChannelAction.cpp */; }; + 276E5DF41CDB57AA003FF4B4 /* LexerChannelAction.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C4F1CDB57AA003FF4B4 /* LexerChannelAction.h */; }; + 276E5DF51CDB57AA003FF4B4 /* LexerChannelAction.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C4F1CDB57AA003FF4B4 /* LexerChannelAction.h */; }; + 276E5DF61CDB57AA003FF4B4 /* LexerChannelAction.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C4F1CDB57AA003FF4B4 /* LexerChannelAction.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5DF71CDB57AA003FF4B4 /* LexerCustomAction.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C501CDB57AA003FF4B4 /* LexerCustomAction.cpp */; }; + 276E5DF81CDB57AA003FF4B4 /* LexerCustomAction.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C501CDB57AA003FF4B4 /* LexerCustomAction.cpp */; }; + 276E5DF91CDB57AA003FF4B4 /* LexerCustomAction.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C501CDB57AA003FF4B4 /* LexerCustomAction.cpp */; }; + 276E5DFA1CDB57AA003FF4B4 /* LexerCustomAction.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C511CDB57AA003FF4B4 /* LexerCustomAction.h */; }; + 276E5DFB1CDB57AA003FF4B4 /* LexerCustomAction.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C511CDB57AA003FF4B4 /* LexerCustomAction.h */; }; + 276E5DFC1CDB57AA003FF4B4 /* LexerCustomAction.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C511CDB57AA003FF4B4 /* LexerCustomAction.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5DFD1CDB57AA003FF4B4 /* LexerIndexedCustomAction.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C521CDB57AA003FF4B4 /* LexerIndexedCustomAction.cpp */; }; + 276E5DFE1CDB57AA003FF4B4 /* LexerIndexedCustomAction.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C521CDB57AA003FF4B4 /* LexerIndexedCustomAction.cpp */; }; + 276E5DFF1CDB57AA003FF4B4 /* LexerIndexedCustomAction.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C521CDB57AA003FF4B4 /* LexerIndexedCustomAction.cpp */; }; + 276E5E001CDB57AA003FF4B4 /* LexerIndexedCustomAction.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C531CDB57AA003FF4B4 /* LexerIndexedCustomAction.h */; }; + 276E5E011CDB57AA003FF4B4 /* LexerIndexedCustomAction.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C531CDB57AA003FF4B4 /* LexerIndexedCustomAction.h */; }; + 276E5E021CDB57AA003FF4B4 /* LexerIndexedCustomAction.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C531CDB57AA003FF4B4 /* LexerIndexedCustomAction.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5E031CDB57AA003FF4B4 /* LexerModeAction.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C541CDB57AA003FF4B4 /* LexerModeAction.cpp */; }; + 276E5E041CDB57AA003FF4B4 /* LexerModeAction.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C541CDB57AA003FF4B4 /* LexerModeAction.cpp */; }; + 276E5E051CDB57AA003FF4B4 /* LexerModeAction.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C541CDB57AA003FF4B4 /* LexerModeAction.cpp */; }; + 276E5E061CDB57AA003FF4B4 /* LexerModeAction.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C551CDB57AA003FF4B4 /* LexerModeAction.h */; }; + 276E5E071CDB57AA003FF4B4 /* LexerModeAction.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C551CDB57AA003FF4B4 /* LexerModeAction.h */; }; + 276E5E081CDB57AA003FF4B4 /* LexerModeAction.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C551CDB57AA003FF4B4 /* LexerModeAction.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5E091CDB57AA003FF4B4 /* LexerMoreAction.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C561CDB57AA003FF4B4 /* LexerMoreAction.cpp */; }; + 276E5E0A1CDB57AA003FF4B4 /* LexerMoreAction.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C561CDB57AA003FF4B4 /* LexerMoreAction.cpp */; }; + 276E5E0B1CDB57AA003FF4B4 /* LexerMoreAction.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C561CDB57AA003FF4B4 /* LexerMoreAction.cpp */; }; + 276E5E0C1CDB57AA003FF4B4 /* LexerMoreAction.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C571CDB57AA003FF4B4 /* LexerMoreAction.h */; }; + 276E5E0D1CDB57AA003FF4B4 /* LexerMoreAction.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C571CDB57AA003FF4B4 /* LexerMoreAction.h */; }; + 276E5E0E1CDB57AA003FF4B4 /* LexerMoreAction.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C571CDB57AA003FF4B4 /* LexerMoreAction.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5E0F1CDB57AA003FF4B4 /* LexerPopModeAction.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C581CDB57AA003FF4B4 /* LexerPopModeAction.cpp */; }; + 276E5E101CDB57AA003FF4B4 /* LexerPopModeAction.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C581CDB57AA003FF4B4 /* LexerPopModeAction.cpp */; }; + 276E5E111CDB57AA003FF4B4 /* LexerPopModeAction.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C581CDB57AA003FF4B4 /* LexerPopModeAction.cpp */; }; + 276E5E121CDB57AA003FF4B4 /* LexerPopModeAction.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C591CDB57AA003FF4B4 /* LexerPopModeAction.h */; }; + 276E5E131CDB57AA003FF4B4 /* LexerPopModeAction.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C591CDB57AA003FF4B4 /* LexerPopModeAction.h */; }; + 276E5E141CDB57AA003FF4B4 /* LexerPopModeAction.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C591CDB57AA003FF4B4 /* LexerPopModeAction.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5E151CDB57AA003FF4B4 /* LexerPushModeAction.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C5A1CDB57AA003FF4B4 /* LexerPushModeAction.cpp */; }; + 276E5E161CDB57AA003FF4B4 /* LexerPushModeAction.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C5A1CDB57AA003FF4B4 /* LexerPushModeAction.cpp */; }; + 276E5E171CDB57AA003FF4B4 /* LexerPushModeAction.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C5A1CDB57AA003FF4B4 /* LexerPushModeAction.cpp */; }; + 276E5E181CDB57AA003FF4B4 /* LexerPushModeAction.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C5B1CDB57AA003FF4B4 /* LexerPushModeAction.h */; }; + 276E5E191CDB57AA003FF4B4 /* LexerPushModeAction.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C5B1CDB57AA003FF4B4 /* LexerPushModeAction.h */; }; + 276E5E1A1CDB57AA003FF4B4 /* LexerPushModeAction.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C5B1CDB57AA003FF4B4 /* LexerPushModeAction.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5E1B1CDB57AA003FF4B4 /* LexerSkipAction.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C5C1CDB57AA003FF4B4 /* LexerSkipAction.cpp */; }; + 276E5E1C1CDB57AA003FF4B4 /* LexerSkipAction.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C5C1CDB57AA003FF4B4 /* LexerSkipAction.cpp */; }; + 276E5E1D1CDB57AA003FF4B4 /* LexerSkipAction.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C5C1CDB57AA003FF4B4 /* LexerSkipAction.cpp */; }; + 276E5E1E1CDB57AA003FF4B4 /* LexerSkipAction.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C5D1CDB57AA003FF4B4 /* LexerSkipAction.h */; }; + 276E5E1F1CDB57AA003FF4B4 /* LexerSkipAction.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C5D1CDB57AA003FF4B4 /* LexerSkipAction.h */; }; + 276E5E201CDB57AA003FF4B4 /* LexerSkipAction.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C5D1CDB57AA003FF4B4 /* LexerSkipAction.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5E211CDB57AA003FF4B4 /* LexerTypeAction.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C5E1CDB57AA003FF4B4 /* LexerTypeAction.cpp */; }; + 276E5E221CDB57AA003FF4B4 /* LexerTypeAction.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C5E1CDB57AA003FF4B4 /* LexerTypeAction.cpp */; }; + 276E5E231CDB57AA003FF4B4 /* LexerTypeAction.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C5E1CDB57AA003FF4B4 /* LexerTypeAction.cpp */; }; + 276E5E241CDB57AA003FF4B4 /* LexerTypeAction.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C5F1CDB57AA003FF4B4 /* LexerTypeAction.h */; }; + 276E5E251CDB57AA003FF4B4 /* LexerTypeAction.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C5F1CDB57AA003FF4B4 /* LexerTypeAction.h */; }; + 276E5E261CDB57AA003FF4B4 /* LexerTypeAction.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C5F1CDB57AA003FF4B4 /* LexerTypeAction.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5E271CDB57AA003FF4B4 /* LL1Analyzer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C601CDB57AA003FF4B4 /* LL1Analyzer.cpp */; }; + 276E5E281CDB57AA003FF4B4 /* LL1Analyzer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C601CDB57AA003FF4B4 /* LL1Analyzer.cpp */; }; + 276E5E291CDB57AA003FF4B4 /* LL1Analyzer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C601CDB57AA003FF4B4 /* LL1Analyzer.cpp */; }; + 276E5E2A1CDB57AA003FF4B4 /* LL1Analyzer.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C611CDB57AA003FF4B4 /* LL1Analyzer.h */; }; + 276E5E2B1CDB57AA003FF4B4 /* LL1Analyzer.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C611CDB57AA003FF4B4 /* LL1Analyzer.h */; }; + 276E5E2C1CDB57AA003FF4B4 /* LL1Analyzer.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C611CDB57AA003FF4B4 /* LL1Analyzer.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5E2D1CDB57AA003FF4B4 /* LookaheadEventInfo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C621CDB57AA003FF4B4 /* LookaheadEventInfo.cpp */; }; + 276E5E2E1CDB57AA003FF4B4 /* LookaheadEventInfo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C621CDB57AA003FF4B4 /* LookaheadEventInfo.cpp */; }; + 276E5E2F1CDB57AA003FF4B4 /* LookaheadEventInfo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C621CDB57AA003FF4B4 /* LookaheadEventInfo.cpp */; }; + 276E5E301CDB57AA003FF4B4 /* LookaheadEventInfo.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C631CDB57AA003FF4B4 /* LookaheadEventInfo.h */; }; + 276E5E311CDB57AA003FF4B4 /* LookaheadEventInfo.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C631CDB57AA003FF4B4 /* LookaheadEventInfo.h */; }; + 276E5E321CDB57AA003FF4B4 /* LookaheadEventInfo.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C631CDB57AA003FF4B4 /* LookaheadEventInfo.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5E331CDB57AA003FF4B4 /* LoopEndState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C641CDB57AA003FF4B4 /* LoopEndState.cpp */; }; + 276E5E341CDB57AA003FF4B4 /* LoopEndState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C641CDB57AA003FF4B4 /* LoopEndState.cpp */; }; + 276E5E351CDB57AA003FF4B4 /* LoopEndState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C641CDB57AA003FF4B4 /* LoopEndState.cpp */; }; + 276E5E361CDB57AA003FF4B4 /* LoopEndState.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C651CDB57AA003FF4B4 /* LoopEndState.h */; }; + 276E5E371CDB57AA003FF4B4 /* LoopEndState.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C651CDB57AA003FF4B4 /* LoopEndState.h */; }; + 276E5E381CDB57AA003FF4B4 /* LoopEndState.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C651CDB57AA003FF4B4 /* LoopEndState.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5E3C1CDB57AA003FF4B4 /* NotSetTransition.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C671CDB57AA003FF4B4 /* NotSetTransition.cpp */; }; + 276E5E3D1CDB57AA003FF4B4 /* NotSetTransition.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C671CDB57AA003FF4B4 /* NotSetTransition.cpp */; }; + 276E5E3E1CDB57AA003FF4B4 /* NotSetTransition.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C671CDB57AA003FF4B4 /* NotSetTransition.cpp */; }; + 276E5E3F1CDB57AA003FF4B4 /* NotSetTransition.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C681CDB57AA003FF4B4 /* NotSetTransition.h */; }; + 276E5E401CDB57AA003FF4B4 /* NotSetTransition.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C681CDB57AA003FF4B4 /* NotSetTransition.h */; }; + 276E5E411CDB57AA003FF4B4 /* NotSetTransition.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C681CDB57AA003FF4B4 /* NotSetTransition.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5E421CDB57AA003FF4B4 /* OrderedATNConfigSet.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C691CDB57AA003FF4B4 /* OrderedATNConfigSet.cpp */; }; + 276E5E431CDB57AA003FF4B4 /* OrderedATNConfigSet.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C691CDB57AA003FF4B4 /* OrderedATNConfigSet.cpp */; }; + 276E5E441CDB57AA003FF4B4 /* OrderedATNConfigSet.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C691CDB57AA003FF4B4 /* OrderedATNConfigSet.cpp */; }; + 276E5E451CDB57AA003FF4B4 /* OrderedATNConfigSet.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C6A1CDB57AA003FF4B4 /* OrderedATNConfigSet.h */; }; + 276E5E461CDB57AA003FF4B4 /* OrderedATNConfigSet.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C6A1CDB57AA003FF4B4 /* OrderedATNConfigSet.h */; }; + 276E5E471CDB57AA003FF4B4 /* OrderedATNConfigSet.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C6A1CDB57AA003FF4B4 /* OrderedATNConfigSet.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5E481CDB57AA003FF4B4 /* ParseInfo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C6B1CDB57AA003FF4B4 /* ParseInfo.cpp */; }; + 276E5E491CDB57AA003FF4B4 /* ParseInfo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C6B1CDB57AA003FF4B4 /* ParseInfo.cpp */; }; + 276E5E4A1CDB57AA003FF4B4 /* ParseInfo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C6B1CDB57AA003FF4B4 /* ParseInfo.cpp */; }; + 276E5E4B1CDB57AA003FF4B4 /* ParseInfo.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C6C1CDB57AA003FF4B4 /* ParseInfo.h */; }; + 276E5E4C1CDB57AA003FF4B4 /* ParseInfo.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C6C1CDB57AA003FF4B4 /* ParseInfo.h */; }; + 276E5E4D1CDB57AA003FF4B4 /* ParseInfo.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C6C1CDB57AA003FF4B4 /* ParseInfo.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5E4E1CDB57AA003FF4B4 /* ParserATNSimulator.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C6D1CDB57AA003FF4B4 /* ParserATNSimulator.cpp */; }; + 276E5E4F1CDB57AA003FF4B4 /* ParserATNSimulator.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C6D1CDB57AA003FF4B4 /* ParserATNSimulator.cpp */; }; + 276E5E501CDB57AA003FF4B4 /* ParserATNSimulator.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C6D1CDB57AA003FF4B4 /* ParserATNSimulator.cpp */; }; + 276E5E511CDB57AA003FF4B4 /* ParserATNSimulator.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C6E1CDB57AA003FF4B4 /* ParserATNSimulator.h */; }; + 276E5E521CDB57AA003FF4B4 /* ParserATNSimulator.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C6E1CDB57AA003FF4B4 /* ParserATNSimulator.h */; }; + 276E5E531CDB57AA003FF4B4 /* ParserATNSimulator.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C6E1CDB57AA003FF4B4 /* ParserATNSimulator.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5E541CDB57AA003FF4B4 /* PlusBlockStartState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C6F1CDB57AA003FF4B4 /* PlusBlockStartState.cpp */; }; + 276E5E551CDB57AA003FF4B4 /* PlusBlockStartState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C6F1CDB57AA003FF4B4 /* PlusBlockStartState.cpp */; }; + 276E5E561CDB57AA003FF4B4 /* PlusBlockStartState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C6F1CDB57AA003FF4B4 /* PlusBlockStartState.cpp */; }; + 276E5E571CDB57AA003FF4B4 /* PlusBlockStartState.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C701CDB57AA003FF4B4 /* PlusBlockStartState.h */; }; + 276E5E581CDB57AA003FF4B4 /* PlusBlockStartState.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C701CDB57AA003FF4B4 /* PlusBlockStartState.h */; }; + 276E5E591CDB57AA003FF4B4 /* PlusBlockStartState.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C701CDB57AA003FF4B4 /* PlusBlockStartState.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5E5A1CDB57AA003FF4B4 /* PlusLoopbackState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C711CDB57AA003FF4B4 /* PlusLoopbackState.cpp */; }; + 276E5E5B1CDB57AA003FF4B4 /* PlusLoopbackState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C711CDB57AA003FF4B4 /* PlusLoopbackState.cpp */; }; + 276E5E5C1CDB57AA003FF4B4 /* PlusLoopbackState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C711CDB57AA003FF4B4 /* PlusLoopbackState.cpp */; }; + 276E5E5D1CDB57AA003FF4B4 /* PlusLoopbackState.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C721CDB57AA003FF4B4 /* PlusLoopbackState.h */; }; + 276E5E5E1CDB57AA003FF4B4 /* PlusLoopbackState.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C721CDB57AA003FF4B4 /* PlusLoopbackState.h */; }; + 276E5E5F1CDB57AA003FF4B4 /* PlusLoopbackState.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C721CDB57AA003FF4B4 /* PlusLoopbackState.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5E601CDB57AA003FF4B4 /* PrecedencePredicateTransition.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C731CDB57AA003FF4B4 /* PrecedencePredicateTransition.cpp */; }; + 276E5E611CDB57AA003FF4B4 /* PrecedencePredicateTransition.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C731CDB57AA003FF4B4 /* PrecedencePredicateTransition.cpp */; }; + 276E5E621CDB57AA003FF4B4 /* PrecedencePredicateTransition.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C731CDB57AA003FF4B4 /* PrecedencePredicateTransition.cpp */; }; + 276E5E631CDB57AA003FF4B4 /* PrecedencePredicateTransition.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C741CDB57AA003FF4B4 /* PrecedencePredicateTransition.h */; }; + 276E5E641CDB57AA003FF4B4 /* PrecedencePredicateTransition.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C741CDB57AA003FF4B4 /* PrecedencePredicateTransition.h */; }; + 276E5E651CDB57AA003FF4B4 /* PrecedencePredicateTransition.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C741CDB57AA003FF4B4 /* PrecedencePredicateTransition.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5E661CDB57AA003FF4B4 /* PredicateEvalInfo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C751CDB57AA003FF4B4 /* PredicateEvalInfo.cpp */; }; + 276E5E671CDB57AA003FF4B4 /* PredicateEvalInfo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C751CDB57AA003FF4B4 /* PredicateEvalInfo.cpp */; }; + 276E5E681CDB57AA003FF4B4 /* PredicateEvalInfo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C751CDB57AA003FF4B4 /* PredicateEvalInfo.cpp */; }; + 276E5E691CDB57AA003FF4B4 /* PredicateEvalInfo.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C761CDB57AA003FF4B4 /* PredicateEvalInfo.h */; }; + 276E5E6A1CDB57AA003FF4B4 /* PredicateEvalInfo.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C761CDB57AA003FF4B4 /* PredicateEvalInfo.h */; }; + 276E5E6B1CDB57AA003FF4B4 /* PredicateEvalInfo.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C761CDB57AA003FF4B4 /* PredicateEvalInfo.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5E6C1CDB57AA003FF4B4 /* PredicateTransition.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C771CDB57AA003FF4B4 /* PredicateTransition.cpp */; }; + 276E5E6D1CDB57AA003FF4B4 /* PredicateTransition.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C771CDB57AA003FF4B4 /* PredicateTransition.cpp */; }; + 276E5E6E1CDB57AA003FF4B4 /* PredicateTransition.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C771CDB57AA003FF4B4 /* PredicateTransition.cpp */; }; + 276E5E6F1CDB57AA003FF4B4 /* PredicateTransition.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C781CDB57AA003FF4B4 /* PredicateTransition.h */; }; + 276E5E701CDB57AA003FF4B4 /* PredicateTransition.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C781CDB57AA003FF4B4 /* PredicateTransition.h */; }; + 276E5E711CDB57AA003FF4B4 /* PredicateTransition.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C781CDB57AA003FF4B4 /* PredicateTransition.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5E721CDB57AA003FF4B4 /* PredictionContext.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C791CDB57AA003FF4B4 /* PredictionContext.cpp */; }; + 276E5E731CDB57AA003FF4B4 /* PredictionContext.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C791CDB57AA003FF4B4 /* PredictionContext.cpp */; }; + 276E5E741CDB57AA003FF4B4 /* PredictionContext.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C791CDB57AA003FF4B4 /* PredictionContext.cpp */; }; + 276E5E751CDB57AA003FF4B4 /* PredictionContext.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C7A1CDB57AA003FF4B4 /* PredictionContext.h */; }; + 276E5E761CDB57AA003FF4B4 /* PredictionContext.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C7A1CDB57AA003FF4B4 /* PredictionContext.h */; }; + 276E5E771CDB57AA003FF4B4 /* PredictionContext.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C7A1CDB57AA003FF4B4 /* PredictionContext.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5E781CDB57AA003FF4B4 /* PredictionMode.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C7B1CDB57AA003FF4B4 /* PredictionMode.cpp */; }; + 276E5E791CDB57AA003FF4B4 /* PredictionMode.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C7B1CDB57AA003FF4B4 /* PredictionMode.cpp */; }; + 276E5E7A1CDB57AA003FF4B4 /* PredictionMode.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C7B1CDB57AA003FF4B4 /* PredictionMode.cpp */; }; + 276E5E7B1CDB57AA003FF4B4 /* PredictionMode.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C7C1CDB57AA003FF4B4 /* PredictionMode.h */; }; + 276E5E7C1CDB57AA003FF4B4 /* PredictionMode.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C7C1CDB57AA003FF4B4 /* PredictionMode.h */; }; + 276E5E7D1CDB57AA003FF4B4 /* PredictionMode.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C7C1CDB57AA003FF4B4 /* PredictionMode.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5E7E1CDB57AA003FF4B4 /* ProfilingATNSimulator.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C7D1CDB57AA003FF4B4 /* ProfilingATNSimulator.cpp */; }; + 276E5E7F1CDB57AA003FF4B4 /* ProfilingATNSimulator.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C7D1CDB57AA003FF4B4 /* ProfilingATNSimulator.cpp */; }; + 276E5E801CDB57AA003FF4B4 /* ProfilingATNSimulator.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C7D1CDB57AA003FF4B4 /* ProfilingATNSimulator.cpp */; }; + 276E5E811CDB57AA003FF4B4 /* ProfilingATNSimulator.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C7E1CDB57AA003FF4B4 /* ProfilingATNSimulator.h */; }; + 276E5E821CDB57AA003FF4B4 /* ProfilingATNSimulator.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C7E1CDB57AA003FF4B4 /* ProfilingATNSimulator.h */; }; + 276E5E831CDB57AA003FF4B4 /* ProfilingATNSimulator.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C7E1CDB57AA003FF4B4 /* ProfilingATNSimulator.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5E841CDB57AA003FF4B4 /* RangeTransition.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C7F1CDB57AA003FF4B4 /* RangeTransition.cpp */; }; + 276E5E851CDB57AA003FF4B4 /* RangeTransition.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C7F1CDB57AA003FF4B4 /* RangeTransition.cpp */; }; + 276E5E861CDB57AA003FF4B4 /* RangeTransition.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C7F1CDB57AA003FF4B4 /* RangeTransition.cpp */; }; + 276E5E871CDB57AA003FF4B4 /* RangeTransition.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C801CDB57AA003FF4B4 /* RangeTransition.h */; }; + 276E5E881CDB57AA003FF4B4 /* RangeTransition.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C801CDB57AA003FF4B4 /* RangeTransition.h */; }; + 276E5E891CDB57AA003FF4B4 /* RangeTransition.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C801CDB57AA003FF4B4 /* RangeTransition.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5E8A1CDB57AA003FF4B4 /* RuleStartState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C811CDB57AA003FF4B4 /* RuleStartState.cpp */; }; + 276E5E8B1CDB57AA003FF4B4 /* RuleStartState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C811CDB57AA003FF4B4 /* RuleStartState.cpp */; }; + 276E5E8C1CDB57AA003FF4B4 /* RuleStartState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C811CDB57AA003FF4B4 /* RuleStartState.cpp */; }; + 276E5E8D1CDB57AA003FF4B4 /* RuleStartState.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C821CDB57AA003FF4B4 /* RuleStartState.h */; }; + 276E5E8E1CDB57AA003FF4B4 /* RuleStartState.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C821CDB57AA003FF4B4 /* RuleStartState.h */; }; + 276E5E8F1CDB57AA003FF4B4 /* RuleStartState.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C821CDB57AA003FF4B4 /* RuleStartState.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5E901CDB57AA003FF4B4 /* RuleStopState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C831CDB57AA003FF4B4 /* RuleStopState.cpp */; }; + 276E5E911CDB57AA003FF4B4 /* RuleStopState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C831CDB57AA003FF4B4 /* RuleStopState.cpp */; }; + 276E5E921CDB57AA003FF4B4 /* RuleStopState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C831CDB57AA003FF4B4 /* RuleStopState.cpp */; }; + 276E5E931CDB57AA003FF4B4 /* RuleStopState.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C841CDB57AA003FF4B4 /* RuleStopState.h */; }; + 276E5E941CDB57AA003FF4B4 /* RuleStopState.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C841CDB57AA003FF4B4 /* RuleStopState.h */; }; + 276E5E951CDB57AA003FF4B4 /* RuleStopState.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C841CDB57AA003FF4B4 /* RuleStopState.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5E961CDB57AA003FF4B4 /* RuleTransition.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C851CDB57AA003FF4B4 /* RuleTransition.cpp */; }; + 276E5E971CDB57AA003FF4B4 /* RuleTransition.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C851CDB57AA003FF4B4 /* RuleTransition.cpp */; }; + 276E5E981CDB57AA003FF4B4 /* RuleTransition.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C851CDB57AA003FF4B4 /* RuleTransition.cpp */; }; + 276E5E991CDB57AA003FF4B4 /* RuleTransition.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C861CDB57AA003FF4B4 /* RuleTransition.h */; }; + 276E5E9A1CDB57AA003FF4B4 /* RuleTransition.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C861CDB57AA003FF4B4 /* RuleTransition.h */; }; + 276E5E9B1CDB57AA003FF4B4 /* RuleTransition.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C861CDB57AA003FF4B4 /* RuleTransition.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5E9C1CDB57AA003FF4B4 /* SemanticContext.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C871CDB57AA003FF4B4 /* SemanticContext.cpp */; }; + 276E5E9D1CDB57AA003FF4B4 /* SemanticContext.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C871CDB57AA003FF4B4 /* SemanticContext.cpp */; }; + 276E5E9E1CDB57AA003FF4B4 /* SemanticContext.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C871CDB57AA003FF4B4 /* SemanticContext.cpp */; }; + 276E5E9F1CDB57AA003FF4B4 /* SemanticContext.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C881CDB57AA003FF4B4 /* SemanticContext.h */; }; + 276E5EA01CDB57AA003FF4B4 /* SemanticContext.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C881CDB57AA003FF4B4 /* SemanticContext.h */; }; + 276E5EA11CDB57AA003FF4B4 /* SemanticContext.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C881CDB57AA003FF4B4 /* SemanticContext.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5EA21CDB57AA003FF4B4 /* SetTransition.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C891CDB57AA003FF4B4 /* SetTransition.cpp */; }; + 276E5EA31CDB57AA003FF4B4 /* SetTransition.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C891CDB57AA003FF4B4 /* SetTransition.cpp */; }; + 276E5EA41CDB57AA003FF4B4 /* SetTransition.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C891CDB57AA003FF4B4 /* SetTransition.cpp */; }; + 276E5EA51CDB57AA003FF4B4 /* SetTransition.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C8A1CDB57AA003FF4B4 /* SetTransition.h */; }; + 276E5EA61CDB57AA003FF4B4 /* SetTransition.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C8A1CDB57AA003FF4B4 /* SetTransition.h */; }; + 276E5EA71CDB57AA003FF4B4 /* SetTransition.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C8A1CDB57AA003FF4B4 /* SetTransition.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5EA81CDB57AA003FF4B4 /* SingletonPredictionContext.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C8B1CDB57AA003FF4B4 /* SingletonPredictionContext.cpp */; }; + 276E5EA91CDB57AA003FF4B4 /* SingletonPredictionContext.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C8B1CDB57AA003FF4B4 /* SingletonPredictionContext.cpp */; }; + 276E5EAA1CDB57AA003FF4B4 /* SingletonPredictionContext.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C8B1CDB57AA003FF4B4 /* SingletonPredictionContext.cpp */; }; + 276E5EAB1CDB57AA003FF4B4 /* SingletonPredictionContext.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C8C1CDB57AA003FF4B4 /* SingletonPredictionContext.h */; }; + 276E5EAC1CDB57AA003FF4B4 /* SingletonPredictionContext.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C8C1CDB57AA003FF4B4 /* SingletonPredictionContext.h */; }; + 276E5EAD1CDB57AA003FF4B4 /* SingletonPredictionContext.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C8C1CDB57AA003FF4B4 /* SingletonPredictionContext.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5EAE1CDB57AA003FF4B4 /* StarBlockStartState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C8D1CDB57AA003FF4B4 /* StarBlockStartState.cpp */; }; + 276E5EAF1CDB57AA003FF4B4 /* StarBlockStartState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C8D1CDB57AA003FF4B4 /* StarBlockStartState.cpp */; }; + 276E5EB01CDB57AA003FF4B4 /* StarBlockStartState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C8D1CDB57AA003FF4B4 /* StarBlockStartState.cpp */; }; + 276E5EB11CDB57AA003FF4B4 /* StarBlockStartState.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C8E1CDB57AA003FF4B4 /* StarBlockStartState.h */; }; + 276E5EB21CDB57AA003FF4B4 /* StarBlockStartState.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C8E1CDB57AA003FF4B4 /* StarBlockStartState.h */; }; + 276E5EB31CDB57AA003FF4B4 /* StarBlockStartState.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C8E1CDB57AA003FF4B4 /* StarBlockStartState.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5EB41CDB57AA003FF4B4 /* StarLoopbackState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C8F1CDB57AA003FF4B4 /* StarLoopbackState.cpp */; }; + 276E5EB51CDB57AA003FF4B4 /* StarLoopbackState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C8F1CDB57AA003FF4B4 /* StarLoopbackState.cpp */; }; + 276E5EB61CDB57AA003FF4B4 /* StarLoopbackState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C8F1CDB57AA003FF4B4 /* StarLoopbackState.cpp */; }; + 276E5EB71CDB57AA003FF4B4 /* StarLoopbackState.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C901CDB57AA003FF4B4 /* StarLoopbackState.h */; }; + 276E5EB81CDB57AA003FF4B4 /* StarLoopbackState.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C901CDB57AA003FF4B4 /* StarLoopbackState.h */; }; + 276E5EB91CDB57AA003FF4B4 /* StarLoopbackState.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C901CDB57AA003FF4B4 /* StarLoopbackState.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5EBA1CDB57AA003FF4B4 /* StarLoopEntryState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C911CDB57AA003FF4B4 /* StarLoopEntryState.cpp */; }; + 276E5EBB1CDB57AA003FF4B4 /* StarLoopEntryState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C911CDB57AA003FF4B4 /* StarLoopEntryState.cpp */; }; + 276E5EBC1CDB57AA003FF4B4 /* StarLoopEntryState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C911CDB57AA003FF4B4 /* StarLoopEntryState.cpp */; }; + 276E5EBD1CDB57AA003FF4B4 /* StarLoopEntryState.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C921CDB57AA003FF4B4 /* StarLoopEntryState.h */; }; + 276E5EBE1CDB57AA003FF4B4 /* StarLoopEntryState.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C921CDB57AA003FF4B4 /* StarLoopEntryState.h */; }; + 276E5EBF1CDB57AA003FF4B4 /* StarLoopEntryState.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C921CDB57AA003FF4B4 /* StarLoopEntryState.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5EC01CDB57AA003FF4B4 /* TokensStartState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C931CDB57AA003FF4B4 /* TokensStartState.cpp */; }; + 276E5EC11CDB57AA003FF4B4 /* TokensStartState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C931CDB57AA003FF4B4 /* TokensStartState.cpp */; }; + 276E5EC21CDB57AA003FF4B4 /* TokensStartState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C931CDB57AA003FF4B4 /* TokensStartState.cpp */; }; + 276E5EC31CDB57AA003FF4B4 /* TokensStartState.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C941CDB57AA003FF4B4 /* TokensStartState.h */; }; + 276E5EC41CDB57AA003FF4B4 /* TokensStartState.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C941CDB57AA003FF4B4 /* TokensStartState.h */; }; + 276E5EC51CDB57AA003FF4B4 /* TokensStartState.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C941CDB57AA003FF4B4 /* TokensStartState.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5EC61CDB57AA003FF4B4 /* Transition.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C951CDB57AA003FF4B4 /* Transition.cpp */; }; + 276E5EC71CDB57AA003FF4B4 /* Transition.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C951CDB57AA003FF4B4 /* Transition.cpp */; }; + 276E5EC81CDB57AA003FF4B4 /* Transition.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C951CDB57AA003FF4B4 /* Transition.cpp */; }; + 276E5EC91CDB57AA003FF4B4 /* Transition.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C961CDB57AA003FF4B4 /* Transition.h */; }; + 276E5ECA1CDB57AA003FF4B4 /* Transition.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C961CDB57AA003FF4B4 /* Transition.h */; }; + 276E5ECB1CDB57AA003FF4B4 /* Transition.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C961CDB57AA003FF4B4 /* Transition.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5ECC1CDB57AA003FF4B4 /* WildcardTransition.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C971CDB57AA003FF4B4 /* WildcardTransition.cpp */; }; + 276E5ECD1CDB57AA003FF4B4 /* WildcardTransition.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C971CDB57AA003FF4B4 /* WildcardTransition.cpp */; }; + 276E5ECE1CDB57AA003FF4B4 /* WildcardTransition.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C971CDB57AA003FF4B4 /* WildcardTransition.cpp */; }; + 276E5ECF1CDB57AA003FF4B4 /* WildcardTransition.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C981CDB57AA003FF4B4 /* WildcardTransition.h */; }; + 276E5ED01CDB57AA003FF4B4 /* WildcardTransition.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C981CDB57AA003FF4B4 /* WildcardTransition.h */; }; + 276E5ED11CDB57AA003FF4B4 /* WildcardTransition.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C981CDB57AA003FF4B4 /* WildcardTransition.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5ED21CDB57AA003FF4B4 /* BailErrorStrategy.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C991CDB57AA003FF4B4 /* BailErrorStrategy.cpp */; }; + 276E5ED31CDB57AA003FF4B4 /* BailErrorStrategy.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C991CDB57AA003FF4B4 /* BailErrorStrategy.cpp */; }; + 276E5ED41CDB57AA003FF4B4 /* BailErrorStrategy.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C991CDB57AA003FF4B4 /* BailErrorStrategy.cpp */; }; + 276E5ED51CDB57AA003FF4B4 /* BailErrorStrategy.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C9A1CDB57AA003FF4B4 /* BailErrorStrategy.h */; }; + 276E5ED61CDB57AA003FF4B4 /* BailErrorStrategy.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C9A1CDB57AA003FF4B4 /* BailErrorStrategy.h */; }; + 276E5ED71CDB57AA003FF4B4 /* BailErrorStrategy.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C9A1CDB57AA003FF4B4 /* BailErrorStrategy.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5ED81CDB57AA003FF4B4 /* BaseErrorListener.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C9B1CDB57AA003FF4B4 /* BaseErrorListener.cpp */; }; + 276E5ED91CDB57AA003FF4B4 /* BaseErrorListener.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C9B1CDB57AA003FF4B4 /* BaseErrorListener.cpp */; }; + 276E5EDA1CDB57AA003FF4B4 /* BaseErrorListener.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C9B1CDB57AA003FF4B4 /* BaseErrorListener.cpp */; }; + 276E5EDB1CDB57AA003FF4B4 /* BaseErrorListener.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C9C1CDB57AA003FF4B4 /* BaseErrorListener.h */; }; + 276E5EDC1CDB57AA003FF4B4 /* BaseErrorListener.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C9C1CDB57AA003FF4B4 /* BaseErrorListener.h */; }; + 276E5EDD1CDB57AA003FF4B4 /* BaseErrorListener.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C9C1CDB57AA003FF4B4 /* BaseErrorListener.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5EDE1CDB57AA003FF4B4 /* BufferedTokenStream.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C9D1CDB57AA003FF4B4 /* BufferedTokenStream.cpp */; }; + 276E5EDF1CDB57AA003FF4B4 /* BufferedTokenStream.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C9D1CDB57AA003FF4B4 /* BufferedTokenStream.cpp */; }; + 276E5EE01CDB57AA003FF4B4 /* BufferedTokenStream.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C9D1CDB57AA003FF4B4 /* BufferedTokenStream.cpp */; }; + 276E5EE11CDB57AA003FF4B4 /* BufferedTokenStream.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C9E1CDB57AA003FF4B4 /* BufferedTokenStream.h */; }; + 276E5EE21CDB57AA003FF4B4 /* BufferedTokenStream.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C9E1CDB57AA003FF4B4 /* BufferedTokenStream.h */; }; + 276E5EE31CDB57AA003FF4B4 /* BufferedTokenStream.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5C9E1CDB57AA003FF4B4 /* BufferedTokenStream.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5EE41CDB57AA003FF4B4 /* CharStream.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C9F1CDB57AA003FF4B4 /* CharStream.cpp */; }; + 276E5EE51CDB57AA003FF4B4 /* CharStream.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C9F1CDB57AA003FF4B4 /* CharStream.cpp */; }; + 276E5EE61CDB57AA003FF4B4 /* CharStream.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5C9F1CDB57AA003FF4B4 /* CharStream.cpp */; }; + 276E5EE71CDB57AA003FF4B4 /* CharStream.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CA01CDB57AA003FF4B4 /* CharStream.h */; }; + 276E5EE81CDB57AA003FF4B4 /* CharStream.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CA01CDB57AA003FF4B4 /* CharStream.h */; }; + 276E5EE91CDB57AA003FF4B4 /* CharStream.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CA01CDB57AA003FF4B4 /* CharStream.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5EEA1CDB57AA003FF4B4 /* CommonToken.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CA11CDB57AA003FF4B4 /* CommonToken.cpp */; }; + 276E5EEB1CDB57AA003FF4B4 /* CommonToken.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CA11CDB57AA003FF4B4 /* CommonToken.cpp */; }; + 276E5EEC1CDB57AA003FF4B4 /* CommonToken.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CA11CDB57AA003FF4B4 /* CommonToken.cpp */; }; + 276E5EED1CDB57AA003FF4B4 /* CommonToken.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CA21CDB57AA003FF4B4 /* CommonToken.h */; }; + 276E5EEE1CDB57AA003FF4B4 /* CommonToken.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CA21CDB57AA003FF4B4 /* CommonToken.h */; }; + 276E5EEF1CDB57AA003FF4B4 /* CommonToken.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CA21CDB57AA003FF4B4 /* CommonToken.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5EF01CDB57AA003FF4B4 /* CommonTokenFactory.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CA31CDB57AA003FF4B4 /* CommonTokenFactory.cpp */; }; + 276E5EF11CDB57AA003FF4B4 /* CommonTokenFactory.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CA31CDB57AA003FF4B4 /* CommonTokenFactory.cpp */; }; + 276E5EF21CDB57AA003FF4B4 /* CommonTokenFactory.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CA31CDB57AA003FF4B4 /* CommonTokenFactory.cpp */; }; + 276E5EF31CDB57AA003FF4B4 /* CommonTokenFactory.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CA41CDB57AA003FF4B4 /* CommonTokenFactory.h */; }; + 276E5EF41CDB57AA003FF4B4 /* CommonTokenFactory.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CA41CDB57AA003FF4B4 /* CommonTokenFactory.h */; }; + 276E5EF51CDB57AA003FF4B4 /* CommonTokenFactory.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CA41CDB57AA003FF4B4 /* CommonTokenFactory.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5EF61CDB57AA003FF4B4 /* CommonTokenStream.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CA51CDB57AA003FF4B4 /* CommonTokenStream.cpp */; }; + 276E5EF71CDB57AA003FF4B4 /* CommonTokenStream.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CA51CDB57AA003FF4B4 /* CommonTokenStream.cpp */; }; + 276E5EF81CDB57AA003FF4B4 /* CommonTokenStream.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CA51CDB57AA003FF4B4 /* CommonTokenStream.cpp */; }; + 276E5EF91CDB57AA003FF4B4 /* CommonTokenStream.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CA61CDB57AA003FF4B4 /* CommonTokenStream.h */; }; + 276E5EFA1CDB57AA003FF4B4 /* CommonTokenStream.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CA61CDB57AA003FF4B4 /* CommonTokenStream.h */; }; + 276E5EFB1CDB57AA003FF4B4 /* CommonTokenStream.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CA61CDB57AA003FF4B4 /* CommonTokenStream.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5EFC1CDB57AA003FF4B4 /* ConsoleErrorListener.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CA71CDB57AA003FF4B4 /* ConsoleErrorListener.cpp */; }; + 276E5EFD1CDB57AA003FF4B4 /* ConsoleErrorListener.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CA71CDB57AA003FF4B4 /* ConsoleErrorListener.cpp */; }; + 276E5EFE1CDB57AA003FF4B4 /* ConsoleErrorListener.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CA71CDB57AA003FF4B4 /* ConsoleErrorListener.cpp */; }; + 276E5EFF1CDB57AA003FF4B4 /* ConsoleErrorListener.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CA81CDB57AA003FF4B4 /* ConsoleErrorListener.h */; }; + 276E5F001CDB57AA003FF4B4 /* ConsoleErrorListener.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CA81CDB57AA003FF4B4 /* ConsoleErrorListener.h */; }; + 276E5F011CDB57AA003FF4B4 /* ConsoleErrorListener.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CA81CDB57AA003FF4B4 /* ConsoleErrorListener.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5F021CDB57AA003FF4B4 /* DefaultErrorStrategy.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CA91CDB57AA003FF4B4 /* DefaultErrorStrategy.cpp */; }; + 276E5F031CDB57AA003FF4B4 /* DefaultErrorStrategy.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CA91CDB57AA003FF4B4 /* DefaultErrorStrategy.cpp */; }; + 276E5F041CDB57AA003FF4B4 /* DefaultErrorStrategy.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CA91CDB57AA003FF4B4 /* DefaultErrorStrategy.cpp */; }; + 276E5F051CDB57AA003FF4B4 /* DefaultErrorStrategy.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CAA1CDB57AA003FF4B4 /* DefaultErrorStrategy.h */; }; + 276E5F061CDB57AA003FF4B4 /* DefaultErrorStrategy.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CAA1CDB57AA003FF4B4 /* DefaultErrorStrategy.h */; }; + 276E5F071CDB57AA003FF4B4 /* DefaultErrorStrategy.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CAA1CDB57AA003FF4B4 /* DefaultErrorStrategy.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5F081CDB57AA003FF4B4 /* DFA.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CAC1CDB57AA003FF4B4 /* DFA.cpp */; }; + 276E5F091CDB57AA003FF4B4 /* DFA.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CAC1CDB57AA003FF4B4 /* DFA.cpp */; }; + 276E5F0A1CDB57AA003FF4B4 /* DFA.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CAC1CDB57AA003FF4B4 /* DFA.cpp */; }; + 276E5F0B1CDB57AA003FF4B4 /* DFA.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CAD1CDB57AA003FF4B4 /* DFA.h */; }; + 276E5F0C1CDB57AA003FF4B4 /* DFA.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CAD1CDB57AA003FF4B4 /* DFA.h */; }; + 276E5F0D1CDB57AA003FF4B4 /* DFA.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CAD1CDB57AA003FF4B4 /* DFA.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5F0E1CDB57AA003FF4B4 /* DFASerializer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CAE1CDB57AA003FF4B4 /* DFASerializer.cpp */; }; + 276E5F0F1CDB57AA003FF4B4 /* DFASerializer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CAE1CDB57AA003FF4B4 /* DFASerializer.cpp */; }; + 276E5F101CDB57AA003FF4B4 /* DFASerializer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CAE1CDB57AA003FF4B4 /* DFASerializer.cpp */; }; + 276E5F111CDB57AA003FF4B4 /* DFASerializer.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CAF1CDB57AA003FF4B4 /* DFASerializer.h */; }; + 276E5F121CDB57AA003FF4B4 /* DFASerializer.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CAF1CDB57AA003FF4B4 /* DFASerializer.h */; }; + 276E5F131CDB57AA003FF4B4 /* DFASerializer.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CAF1CDB57AA003FF4B4 /* DFASerializer.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5F141CDB57AA003FF4B4 /* DFAState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CB01CDB57AA003FF4B4 /* DFAState.cpp */; }; + 276E5F151CDB57AA003FF4B4 /* DFAState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CB01CDB57AA003FF4B4 /* DFAState.cpp */; }; + 276E5F161CDB57AA003FF4B4 /* DFAState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CB01CDB57AA003FF4B4 /* DFAState.cpp */; }; + 276E5F171CDB57AA003FF4B4 /* DFAState.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CB11CDB57AA003FF4B4 /* DFAState.h */; }; + 276E5F181CDB57AA003FF4B4 /* DFAState.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CB11CDB57AA003FF4B4 /* DFAState.h */; }; + 276E5F191CDB57AA003FF4B4 /* DFAState.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CB11CDB57AA003FF4B4 /* DFAState.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5F1A1CDB57AA003FF4B4 /* LexerDFASerializer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CB21CDB57AA003FF4B4 /* LexerDFASerializer.cpp */; }; + 276E5F1B1CDB57AA003FF4B4 /* LexerDFASerializer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CB21CDB57AA003FF4B4 /* LexerDFASerializer.cpp */; }; + 276E5F1C1CDB57AA003FF4B4 /* LexerDFASerializer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CB21CDB57AA003FF4B4 /* LexerDFASerializer.cpp */; }; + 276E5F1D1CDB57AA003FF4B4 /* LexerDFASerializer.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CB31CDB57AA003FF4B4 /* LexerDFASerializer.h */; }; + 276E5F1E1CDB57AA003FF4B4 /* LexerDFASerializer.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CB31CDB57AA003FF4B4 /* LexerDFASerializer.h */; }; + 276E5F1F1CDB57AA003FF4B4 /* LexerDFASerializer.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CB31CDB57AA003FF4B4 /* LexerDFASerializer.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5F201CDB57AA003FF4B4 /* DiagnosticErrorListener.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CB41CDB57AA003FF4B4 /* DiagnosticErrorListener.cpp */; }; + 276E5F211CDB57AA003FF4B4 /* DiagnosticErrorListener.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CB41CDB57AA003FF4B4 /* DiagnosticErrorListener.cpp */; }; + 276E5F221CDB57AA003FF4B4 /* DiagnosticErrorListener.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CB41CDB57AA003FF4B4 /* DiagnosticErrorListener.cpp */; }; + 276E5F231CDB57AA003FF4B4 /* DiagnosticErrorListener.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CB51CDB57AA003FF4B4 /* DiagnosticErrorListener.h */; }; + 276E5F241CDB57AA003FF4B4 /* DiagnosticErrorListener.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CB51CDB57AA003FF4B4 /* DiagnosticErrorListener.h */; }; + 276E5F251CDB57AA003FF4B4 /* DiagnosticErrorListener.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CB51CDB57AA003FF4B4 /* DiagnosticErrorListener.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5F261CDB57AA003FF4B4 /* Exceptions.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CB61CDB57AA003FF4B4 /* Exceptions.cpp */; }; + 276E5F271CDB57AA003FF4B4 /* Exceptions.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CB61CDB57AA003FF4B4 /* Exceptions.cpp */; }; + 276E5F281CDB57AA003FF4B4 /* Exceptions.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CB61CDB57AA003FF4B4 /* Exceptions.cpp */; }; + 276E5F291CDB57AA003FF4B4 /* Exceptions.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CB71CDB57AA003FF4B4 /* Exceptions.h */; }; + 276E5F2A1CDB57AA003FF4B4 /* Exceptions.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CB71CDB57AA003FF4B4 /* Exceptions.h */; }; + 276E5F2B1CDB57AA003FF4B4 /* Exceptions.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CB71CDB57AA003FF4B4 /* Exceptions.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5F2C1CDB57AA003FF4B4 /* FailedPredicateException.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CB81CDB57AA003FF4B4 /* FailedPredicateException.cpp */; }; + 276E5F2D1CDB57AA003FF4B4 /* FailedPredicateException.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CB81CDB57AA003FF4B4 /* FailedPredicateException.cpp */; }; + 276E5F2E1CDB57AA003FF4B4 /* FailedPredicateException.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CB81CDB57AA003FF4B4 /* FailedPredicateException.cpp */; }; + 276E5F2F1CDB57AA003FF4B4 /* FailedPredicateException.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CB91CDB57AA003FF4B4 /* FailedPredicateException.h */; }; + 276E5F301CDB57AA003FF4B4 /* FailedPredicateException.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CB91CDB57AA003FF4B4 /* FailedPredicateException.h */; }; + 276E5F311CDB57AA003FF4B4 /* FailedPredicateException.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CB91CDB57AA003FF4B4 /* FailedPredicateException.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5F321CDB57AA003FF4B4 /* InputMismatchException.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CBA1CDB57AA003FF4B4 /* InputMismatchException.cpp */; }; + 276E5F331CDB57AA003FF4B4 /* InputMismatchException.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CBA1CDB57AA003FF4B4 /* InputMismatchException.cpp */; }; + 276E5F341CDB57AA003FF4B4 /* InputMismatchException.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CBA1CDB57AA003FF4B4 /* InputMismatchException.cpp */; }; + 276E5F351CDB57AA003FF4B4 /* InputMismatchException.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CBB1CDB57AA003FF4B4 /* InputMismatchException.h */; }; + 276E5F361CDB57AA003FF4B4 /* InputMismatchException.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CBB1CDB57AA003FF4B4 /* InputMismatchException.h */; }; + 276E5F371CDB57AA003FF4B4 /* InputMismatchException.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CBB1CDB57AA003FF4B4 /* InputMismatchException.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5F381CDB57AA003FF4B4 /* InterpreterRuleContext.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CBC1CDB57AA003FF4B4 /* InterpreterRuleContext.cpp */; }; + 276E5F391CDB57AA003FF4B4 /* InterpreterRuleContext.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CBC1CDB57AA003FF4B4 /* InterpreterRuleContext.cpp */; }; + 276E5F3A1CDB57AA003FF4B4 /* InterpreterRuleContext.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CBC1CDB57AA003FF4B4 /* InterpreterRuleContext.cpp */; }; + 276E5F3B1CDB57AA003FF4B4 /* InterpreterRuleContext.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CBD1CDB57AA003FF4B4 /* InterpreterRuleContext.h */; }; + 276E5F3C1CDB57AA003FF4B4 /* InterpreterRuleContext.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CBD1CDB57AA003FF4B4 /* InterpreterRuleContext.h */; }; + 276E5F3D1CDB57AA003FF4B4 /* InterpreterRuleContext.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CBD1CDB57AA003FF4B4 /* InterpreterRuleContext.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5F3E1CDB57AA003FF4B4 /* IntStream.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CBE1CDB57AA003FF4B4 /* IntStream.cpp */; }; + 276E5F3F1CDB57AA003FF4B4 /* IntStream.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CBE1CDB57AA003FF4B4 /* IntStream.cpp */; }; + 276E5F401CDB57AA003FF4B4 /* IntStream.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CBE1CDB57AA003FF4B4 /* IntStream.cpp */; }; + 276E5F411CDB57AA003FF4B4 /* IntStream.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CBF1CDB57AA003FF4B4 /* IntStream.h */; }; + 276E5F421CDB57AA003FF4B4 /* IntStream.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CBF1CDB57AA003FF4B4 /* IntStream.h */; }; + 276E5F431CDB57AA003FF4B4 /* IntStream.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CBF1CDB57AA003FF4B4 /* IntStream.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5F471CDB57AA003FF4B4 /* Lexer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CC11CDB57AA003FF4B4 /* Lexer.cpp */; }; + 276E5F481CDB57AA003FF4B4 /* Lexer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CC11CDB57AA003FF4B4 /* Lexer.cpp */; }; + 276E5F491CDB57AA003FF4B4 /* Lexer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CC11CDB57AA003FF4B4 /* Lexer.cpp */; }; + 276E5F4A1CDB57AA003FF4B4 /* Lexer.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CC21CDB57AA003FF4B4 /* Lexer.h */; }; + 276E5F4B1CDB57AA003FF4B4 /* Lexer.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CC21CDB57AA003FF4B4 /* Lexer.h */; }; + 276E5F4C1CDB57AA003FF4B4 /* Lexer.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CC21CDB57AA003FF4B4 /* Lexer.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5F4D1CDB57AA003FF4B4 /* LexerInterpreter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CC31CDB57AA003FF4B4 /* LexerInterpreter.cpp */; }; + 276E5F4E1CDB57AA003FF4B4 /* LexerInterpreter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CC31CDB57AA003FF4B4 /* LexerInterpreter.cpp */; }; + 276E5F4F1CDB57AA003FF4B4 /* LexerInterpreter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CC31CDB57AA003FF4B4 /* LexerInterpreter.cpp */; }; + 276E5F501CDB57AA003FF4B4 /* LexerInterpreter.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CC41CDB57AA003FF4B4 /* LexerInterpreter.h */; }; + 276E5F511CDB57AA003FF4B4 /* LexerInterpreter.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CC41CDB57AA003FF4B4 /* LexerInterpreter.h */; }; + 276E5F521CDB57AA003FF4B4 /* LexerInterpreter.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CC41CDB57AA003FF4B4 /* LexerInterpreter.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5F531CDB57AA003FF4B4 /* LexerNoViableAltException.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CC51CDB57AA003FF4B4 /* LexerNoViableAltException.cpp */; }; + 276E5F541CDB57AA003FF4B4 /* LexerNoViableAltException.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CC51CDB57AA003FF4B4 /* LexerNoViableAltException.cpp */; }; + 276E5F551CDB57AA003FF4B4 /* LexerNoViableAltException.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CC51CDB57AA003FF4B4 /* LexerNoViableAltException.cpp */; }; + 276E5F561CDB57AA003FF4B4 /* LexerNoViableAltException.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CC61CDB57AA003FF4B4 /* LexerNoViableAltException.h */; }; + 276E5F571CDB57AA003FF4B4 /* LexerNoViableAltException.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CC61CDB57AA003FF4B4 /* LexerNoViableAltException.h */; }; + 276E5F581CDB57AA003FF4B4 /* LexerNoViableAltException.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CC61CDB57AA003FF4B4 /* LexerNoViableAltException.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5F591CDB57AA003FF4B4 /* ListTokenSource.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CC71CDB57AA003FF4B4 /* ListTokenSource.cpp */; }; + 276E5F5A1CDB57AA003FF4B4 /* ListTokenSource.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CC71CDB57AA003FF4B4 /* ListTokenSource.cpp */; }; + 276E5F5B1CDB57AA003FF4B4 /* ListTokenSource.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CC71CDB57AA003FF4B4 /* ListTokenSource.cpp */; }; + 276E5F5C1CDB57AA003FF4B4 /* ListTokenSource.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CC81CDB57AA003FF4B4 /* ListTokenSource.h */; }; + 276E5F5D1CDB57AA003FF4B4 /* ListTokenSource.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CC81CDB57AA003FF4B4 /* ListTokenSource.h */; }; + 276E5F5E1CDB57AA003FF4B4 /* ListTokenSource.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CC81CDB57AA003FF4B4 /* ListTokenSource.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5F5F1CDB57AA003FF4B4 /* Interval.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CCA1CDB57AA003FF4B4 /* Interval.cpp */; }; + 276E5F601CDB57AA003FF4B4 /* Interval.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CCA1CDB57AA003FF4B4 /* Interval.cpp */; }; + 276E5F611CDB57AA003FF4B4 /* Interval.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CCA1CDB57AA003FF4B4 /* Interval.cpp */; }; + 276E5F621CDB57AA003FF4B4 /* Interval.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CCB1CDB57AA003FF4B4 /* Interval.h */; }; + 276E5F631CDB57AA003FF4B4 /* Interval.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CCB1CDB57AA003FF4B4 /* Interval.h */; }; + 276E5F641CDB57AA003FF4B4 /* Interval.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CCB1CDB57AA003FF4B4 /* Interval.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5F651CDB57AA003FF4B4 /* IntervalSet.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CCC1CDB57AA003FF4B4 /* IntervalSet.cpp */; }; + 276E5F661CDB57AA003FF4B4 /* IntervalSet.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CCC1CDB57AA003FF4B4 /* IntervalSet.cpp */; }; + 276E5F671CDB57AA003FF4B4 /* IntervalSet.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CCC1CDB57AA003FF4B4 /* IntervalSet.cpp */; }; + 276E5F681CDB57AA003FF4B4 /* IntervalSet.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CCD1CDB57AA003FF4B4 /* IntervalSet.h */; }; + 276E5F691CDB57AA003FF4B4 /* IntervalSet.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CCD1CDB57AA003FF4B4 /* IntervalSet.h */; }; + 276E5F6A1CDB57AA003FF4B4 /* IntervalSet.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CCD1CDB57AA003FF4B4 /* IntervalSet.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5F6B1CDB57AA003FF4B4 /* MurmurHash.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CCE1CDB57AA003FF4B4 /* MurmurHash.cpp */; }; + 276E5F6C1CDB57AA003FF4B4 /* MurmurHash.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CCE1CDB57AA003FF4B4 /* MurmurHash.cpp */; }; + 276E5F6D1CDB57AA003FF4B4 /* MurmurHash.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CCE1CDB57AA003FF4B4 /* MurmurHash.cpp */; }; + 276E5F6E1CDB57AA003FF4B4 /* MurmurHash.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CCF1CDB57AA003FF4B4 /* MurmurHash.h */; }; + 276E5F6F1CDB57AA003FF4B4 /* MurmurHash.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CCF1CDB57AA003FF4B4 /* MurmurHash.h */; }; + 276E5F701CDB57AA003FF4B4 /* MurmurHash.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CCF1CDB57AA003FF4B4 /* MurmurHash.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5F741CDB57AA003FF4B4 /* Predicate.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CD11CDB57AA003FF4B4 /* Predicate.h */; }; + 276E5F751CDB57AA003FF4B4 /* Predicate.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CD11CDB57AA003FF4B4 /* Predicate.h */; }; + 276E5F761CDB57AA003FF4B4 /* Predicate.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CD11CDB57AA003FF4B4 /* Predicate.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5F7D1CDB57AA003FF4B4 /* NoViableAltException.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CD41CDB57AA003FF4B4 /* NoViableAltException.cpp */; }; + 276E5F7E1CDB57AA003FF4B4 /* NoViableAltException.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CD41CDB57AA003FF4B4 /* NoViableAltException.cpp */; }; + 276E5F7F1CDB57AA003FF4B4 /* NoViableAltException.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CD41CDB57AA003FF4B4 /* NoViableAltException.cpp */; }; + 276E5F801CDB57AA003FF4B4 /* NoViableAltException.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CD51CDB57AA003FF4B4 /* NoViableAltException.h */; }; + 276E5F811CDB57AA003FF4B4 /* NoViableAltException.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CD51CDB57AA003FF4B4 /* NoViableAltException.h */; }; + 276E5F821CDB57AA003FF4B4 /* NoViableAltException.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CD51CDB57AA003FF4B4 /* NoViableAltException.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5F831CDB57AA003FF4B4 /* Parser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CD61CDB57AA003FF4B4 /* Parser.cpp */; }; + 276E5F841CDB57AA003FF4B4 /* Parser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CD61CDB57AA003FF4B4 /* Parser.cpp */; }; + 276E5F851CDB57AA003FF4B4 /* Parser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CD61CDB57AA003FF4B4 /* Parser.cpp */; }; + 276E5F861CDB57AA003FF4B4 /* Parser.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CD71CDB57AA003FF4B4 /* Parser.h */; }; + 276E5F871CDB57AA003FF4B4 /* Parser.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CD71CDB57AA003FF4B4 /* Parser.h */; }; + 276E5F881CDB57AA003FF4B4 /* Parser.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CD71CDB57AA003FF4B4 /* Parser.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5F891CDB57AA003FF4B4 /* ParserInterpreter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CD81CDB57AA003FF4B4 /* ParserInterpreter.cpp */; }; + 276E5F8A1CDB57AA003FF4B4 /* ParserInterpreter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CD81CDB57AA003FF4B4 /* ParserInterpreter.cpp */; }; + 276E5F8B1CDB57AA003FF4B4 /* ParserInterpreter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CD81CDB57AA003FF4B4 /* ParserInterpreter.cpp */; }; + 276E5F8C1CDB57AA003FF4B4 /* ParserInterpreter.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CD91CDB57AA003FF4B4 /* ParserInterpreter.h */; }; + 276E5F8D1CDB57AA003FF4B4 /* ParserInterpreter.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CD91CDB57AA003FF4B4 /* ParserInterpreter.h */; }; + 276E5F8E1CDB57AA003FF4B4 /* ParserInterpreter.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CD91CDB57AA003FF4B4 /* ParserInterpreter.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5F8F1CDB57AA003FF4B4 /* ParserRuleContext.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CDA1CDB57AA003FF4B4 /* ParserRuleContext.cpp */; }; + 276E5F901CDB57AA003FF4B4 /* ParserRuleContext.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CDA1CDB57AA003FF4B4 /* ParserRuleContext.cpp */; }; + 276E5F911CDB57AA003FF4B4 /* ParserRuleContext.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CDA1CDB57AA003FF4B4 /* ParserRuleContext.cpp */; }; + 276E5F921CDB57AA003FF4B4 /* ParserRuleContext.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CDB1CDB57AA003FF4B4 /* ParserRuleContext.h */; }; + 276E5F931CDB57AA003FF4B4 /* ParserRuleContext.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CDB1CDB57AA003FF4B4 /* ParserRuleContext.h */; }; + 276E5F941CDB57AA003FF4B4 /* ParserRuleContext.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CDB1CDB57AA003FF4B4 /* ParserRuleContext.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5F951CDB57AA003FF4B4 /* ProxyErrorListener.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CDC1CDB57AA003FF4B4 /* ProxyErrorListener.cpp */; }; + 276E5F961CDB57AA003FF4B4 /* ProxyErrorListener.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CDC1CDB57AA003FF4B4 /* ProxyErrorListener.cpp */; }; + 276E5F971CDB57AA003FF4B4 /* ProxyErrorListener.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CDC1CDB57AA003FF4B4 /* ProxyErrorListener.cpp */; }; + 276E5F981CDB57AA003FF4B4 /* ProxyErrorListener.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CDD1CDB57AA003FF4B4 /* ProxyErrorListener.h */; }; + 276E5F991CDB57AA003FF4B4 /* ProxyErrorListener.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CDD1CDB57AA003FF4B4 /* ProxyErrorListener.h */; }; + 276E5F9A1CDB57AA003FF4B4 /* ProxyErrorListener.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CDD1CDB57AA003FF4B4 /* ProxyErrorListener.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5F9B1CDB57AA003FF4B4 /* RecognitionException.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CDE1CDB57AA003FF4B4 /* RecognitionException.cpp */; }; + 276E5F9C1CDB57AA003FF4B4 /* RecognitionException.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CDE1CDB57AA003FF4B4 /* RecognitionException.cpp */; }; + 276E5F9D1CDB57AA003FF4B4 /* RecognitionException.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CDE1CDB57AA003FF4B4 /* RecognitionException.cpp */; }; + 276E5F9E1CDB57AA003FF4B4 /* RecognitionException.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CDF1CDB57AA003FF4B4 /* RecognitionException.h */; }; + 276E5F9F1CDB57AA003FF4B4 /* RecognitionException.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CDF1CDB57AA003FF4B4 /* RecognitionException.h */; }; + 276E5FA01CDB57AA003FF4B4 /* RecognitionException.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CDF1CDB57AA003FF4B4 /* RecognitionException.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5FA11CDB57AA003FF4B4 /* Recognizer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CE01CDB57AA003FF4B4 /* Recognizer.cpp */; }; + 276E5FA21CDB57AA003FF4B4 /* Recognizer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CE01CDB57AA003FF4B4 /* Recognizer.cpp */; }; + 276E5FA31CDB57AA003FF4B4 /* Recognizer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CE01CDB57AA003FF4B4 /* Recognizer.cpp */; }; + 276E5FA41CDB57AA003FF4B4 /* Recognizer.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CE11CDB57AA003FF4B4 /* Recognizer.h */; }; + 276E5FA51CDB57AA003FF4B4 /* Recognizer.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CE11CDB57AA003FF4B4 /* Recognizer.h */; }; + 276E5FA61CDB57AA003FF4B4 /* Recognizer.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CE11CDB57AA003FF4B4 /* Recognizer.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5FA71CDB57AA003FF4B4 /* RuleContext.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CE21CDB57AA003FF4B4 /* RuleContext.cpp */; }; + 276E5FA81CDB57AA003FF4B4 /* RuleContext.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CE21CDB57AA003FF4B4 /* RuleContext.cpp */; }; + 276E5FA91CDB57AA003FF4B4 /* RuleContext.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CE21CDB57AA003FF4B4 /* RuleContext.cpp */; }; + 276E5FAA1CDB57AA003FF4B4 /* RuleContext.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CE31CDB57AA003FF4B4 /* RuleContext.h */; }; + 276E5FAB1CDB57AA003FF4B4 /* RuleContext.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CE31CDB57AA003FF4B4 /* RuleContext.h */; }; + 276E5FAC1CDB57AA003FF4B4 /* RuleContext.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CE31CDB57AA003FF4B4 /* RuleContext.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5FAD1CDB57AA003FF4B4 /* Arrays.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CE51CDB57AA003FF4B4 /* Arrays.cpp */; }; + 276E5FAE1CDB57AA003FF4B4 /* Arrays.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CE51CDB57AA003FF4B4 /* Arrays.cpp */; }; + 276E5FAF1CDB57AA003FF4B4 /* Arrays.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CE51CDB57AA003FF4B4 /* Arrays.cpp */; }; + 276E5FB01CDB57AA003FF4B4 /* Arrays.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CE61CDB57AA003FF4B4 /* Arrays.h */; }; + 276E5FB11CDB57AA003FF4B4 /* Arrays.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CE61CDB57AA003FF4B4 /* Arrays.h */; }; + 276E5FB21CDB57AA003FF4B4 /* Arrays.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CE61CDB57AA003FF4B4 /* Arrays.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5FB31CDB57AA003FF4B4 /* BitSet.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CE71CDB57AA003FF4B4 /* BitSet.h */; }; + 276E5FB41CDB57AA003FF4B4 /* BitSet.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CE71CDB57AA003FF4B4 /* BitSet.h */; }; + 276E5FB51CDB57AA003FF4B4 /* BitSet.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CE71CDB57AA003FF4B4 /* BitSet.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5FB61CDB57AA003FF4B4 /* CPPUtils.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CE81CDB57AA003FF4B4 /* CPPUtils.cpp */; }; + 276E5FB71CDB57AA003FF4B4 /* CPPUtils.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CE81CDB57AA003FF4B4 /* CPPUtils.cpp */; }; + 276E5FB81CDB57AA003FF4B4 /* CPPUtils.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CE81CDB57AA003FF4B4 /* CPPUtils.cpp */; }; + 276E5FB91CDB57AA003FF4B4 /* CPPUtils.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CE91CDB57AA003FF4B4 /* CPPUtils.h */; }; + 276E5FBA1CDB57AA003FF4B4 /* CPPUtils.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CE91CDB57AA003FF4B4 /* CPPUtils.h */; }; + 276E5FBB1CDB57AA003FF4B4 /* CPPUtils.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CE91CDB57AA003FF4B4 /* CPPUtils.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5FBC1CDB57AA003FF4B4 /* Declarations.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CEA1CDB57AA003FF4B4 /* Declarations.h */; }; + 276E5FBD1CDB57AA003FF4B4 /* Declarations.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CEA1CDB57AA003FF4B4 /* Declarations.h */; }; + 276E5FBE1CDB57AA003FF4B4 /* Declarations.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CEA1CDB57AA003FF4B4 /* Declarations.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5FBF1CDB57AA003FF4B4 /* guid.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CEB1CDB57AA003FF4B4 /* guid.cpp */; }; + 276E5FC01CDB57AA003FF4B4 /* guid.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CEB1CDB57AA003FF4B4 /* guid.cpp */; }; + 276E5FC11CDB57AA003FF4B4 /* guid.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CEB1CDB57AA003FF4B4 /* guid.cpp */; }; + 276E5FC21CDB57AA003FF4B4 /* guid.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CEC1CDB57AA003FF4B4 /* guid.h */; }; + 276E5FC31CDB57AA003FF4B4 /* guid.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CEC1CDB57AA003FF4B4 /* guid.h */; }; + 276E5FC41CDB57AA003FF4B4 /* guid.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CEC1CDB57AA003FF4B4 /* guid.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5FC51CDB57AA003FF4B4 /* StringUtils.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CED1CDB57AA003FF4B4 /* StringUtils.cpp */; }; + 276E5FC61CDB57AA003FF4B4 /* StringUtils.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CED1CDB57AA003FF4B4 /* StringUtils.cpp */; }; + 276E5FC71CDB57AA003FF4B4 /* StringUtils.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CED1CDB57AA003FF4B4 /* StringUtils.cpp */; }; + 276E5FC81CDB57AA003FF4B4 /* StringUtils.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CEE1CDB57AA003FF4B4 /* StringUtils.h */; }; + 276E5FC91CDB57AA003FF4B4 /* StringUtils.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CEE1CDB57AA003FF4B4 /* StringUtils.h */; }; + 276E5FCA1CDB57AA003FF4B4 /* StringUtils.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CEE1CDB57AA003FF4B4 /* StringUtils.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5FCE1CDB57AA003FF4B4 /* Token.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CF01CDB57AA003FF4B4 /* Token.h */; }; + 276E5FCF1CDB57AA003FF4B4 /* Token.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CF01CDB57AA003FF4B4 /* Token.h */; }; + 276E5FD01CDB57AA003FF4B4 /* Token.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CF01CDB57AA003FF4B4 /* Token.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5FD41CDB57AA003FF4B4 /* TokenFactory.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CF21CDB57AA003FF4B4 /* TokenFactory.h */; }; + 276E5FD51CDB57AA003FF4B4 /* TokenFactory.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CF21CDB57AA003FF4B4 /* TokenFactory.h */; }; + 276E5FD61CDB57AA003FF4B4 /* TokenFactory.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CF21CDB57AA003FF4B4 /* TokenFactory.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5FDA1CDB57AA003FF4B4 /* TokenSource.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CF41CDB57AA003FF4B4 /* TokenSource.h */; }; + 276E5FDB1CDB57AA003FF4B4 /* TokenSource.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CF41CDB57AA003FF4B4 /* TokenSource.h */; }; + 276E5FDC1CDB57AA003FF4B4 /* TokenSource.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CF41CDB57AA003FF4B4 /* TokenSource.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5FDD1CDB57AA003FF4B4 /* TokenStream.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CF51CDB57AA003FF4B4 /* TokenStream.cpp */; }; + 276E5FDE1CDB57AA003FF4B4 /* TokenStream.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CF51CDB57AA003FF4B4 /* TokenStream.cpp */; }; + 276E5FDF1CDB57AA003FF4B4 /* TokenStream.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CF51CDB57AA003FF4B4 /* TokenStream.cpp */; }; + 276E5FE01CDB57AA003FF4B4 /* TokenStream.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CF61CDB57AA003FF4B4 /* TokenStream.h */; }; + 276E5FE11CDB57AA003FF4B4 /* TokenStream.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CF61CDB57AA003FF4B4 /* TokenStream.h */; }; + 276E5FE21CDB57AA003FF4B4 /* TokenStream.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CF61CDB57AA003FF4B4 /* TokenStream.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5FE31CDB57AA003FF4B4 /* TokenStreamRewriter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CF71CDB57AA003FF4B4 /* TokenStreamRewriter.cpp */; }; + 276E5FE41CDB57AA003FF4B4 /* TokenStreamRewriter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CF71CDB57AA003FF4B4 /* TokenStreamRewriter.cpp */; }; + 276E5FE51CDB57AA003FF4B4 /* TokenStreamRewriter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CF71CDB57AA003FF4B4 /* TokenStreamRewriter.cpp */; }; + 276E5FE61CDB57AA003FF4B4 /* TokenStreamRewriter.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CF81CDB57AA003FF4B4 /* TokenStreamRewriter.h */; }; + 276E5FE71CDB57AA003FF4B4 /* TokenStreamRewriter.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CF81CDB57AA003FF4B4 /* TokenStreamRewriter.h */; }; + 276E5FE81CDB57AA003FF4B4 /* TokenStreamRewriter.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CF81CDB57AA003FF4B4 /* TokenStreamRewriter.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5FE91CDB57AA003FF4B4 /* AbstractParseTreeVisitor.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CFA1CDB57AA003FF4B4 /* AbstractParseTreeVisitor.h */; }; + 276E5FEA1CDB57AA003FF4B4 /* AbstractParseTreeVisitor.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CFA1CDB57AA003FF4B4 /* AbstractParseTreeVisitor.h */; }; + 276E5FEB1CDB57AA003FF4B4 /* AbstractParseTreeVisitor.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CFA1CDB57AA003FF4B4 /* AbstractParseTreeVisitor.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5FEC1CDB57AA003FF4B4 /* ErrorNode.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CFB1CDB57AA003FF4B4 /* ErrorNode.h */; }; + 276E5FED1CDB57AA003FF4B4 /* ErrorNode.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CFB1CDB57AA003FF4B4 /* ErrorNode.h */; }; + 276E5FEE1CDB57AA003FF4B4 /* ErrorNode.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CFB1CDB57AA003FF4B4 /* ErrorNode.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5FEF1CDB57AA003FF4B4 /* ErrorNodeImpl.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CFC1CDB57AA003FF4B4 /* ErrorNodeImpl.cpp */; }; + 276E5FF01CDB57AA003FF4B4 /* ErrorNodeImpl.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CFC1CDB57AA003FF4B4 /* ErrorNodeImpl.cpp */; }; + 276E5FF11CDB57AA003FF4B4 /* ErrorNodeImpl.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5CFC1CDB57AA003FF4B4 /* ErrorNodeImpl.cpp */; }; + 276E5FF21CDB57AA003FF4B4 /* ErrorNodeImpl.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CFD1CDB57AA003FF4B4 /* ErrorNodeImpl.h */; }; + 276E5FF31CDB57AA003FF4B4 /* ErrorNodeImpl.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CFD1CDB57AA003FF4B4 /* ErrorNodeImpl.h */; }; + 276E5FF41CDB57AA003FF4B4 /* ErrorNodeImpl.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CFD1CDB57AA003FF4B4 /* ErrorNodeImpl.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5FF51CDB57AA003FF4B4 /* ParseTree.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CFE1CDB57AA003FF4B4 /* ParseTree.h */; }; + 276E5FF61CDB57AA003FF4B4 /* ParseTree.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CFE1CDB57AA003FF4B4 /* ParseTree.h */; }; + 276E5FF71CDB57AA003FF4B4 /* ParseTree.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5CFE1CDB57AA003FF4B4 /* ParseTree.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E5FFB1CDB57AA003FF4B4 /* ParseTreeListener.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5D001CDB57AA003FF4B4 /* ParseTreeListener.h */; }; + 276E5FFC1CDB57AA003FF4B4 /* ParseTreeListener.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5D001CDB57AA003FF4B4 /* ParseTreeListener.h */; }; + 276E5FFD1CDB57AA003FF4B4 /* ParseTreeListener.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5D001CDB57AA003FF4B4 /* ParseTreeListener.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E60011CDB57AA003FF4B4 /* ParseTreeProperty.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5D021CDB57AA003FF4B4 /* ParseTreeProperty.h */; }; + 276E60021CDB57AA003FF4B4 /* ParseTreeProperty.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5D021CDB57AA003FF4B4 /* ParseTreeProperty.h */; }; + 276E60031CDB57AA003FF4B4 /* ParseTreeProperty.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5D021CDB57AA003FF4B4 /* ParseTreeProperty.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E60041CDB57AA003FF4B4 /* ParseTreeVisitor.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5D031CDB57AA003FF4B4 /* ParseTreeVisitor.h */; }; + 276E60051CDB57AA003FF4B4 /* ParseTreeVisitor.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5D031CDB57AA003FF4B4 /* ParseTreeVisitor.h */; }; + 276E60061CDB57AA003FF4B4 /* ParseTreeVisitor.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5D031CDB57AA003FF4B4 /* ParseTreeVisitor.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E60071CDB57AA003FF4B4 /* ParseTreeWalker.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5D041CDB57AA003FF4B4 /* ParseTreeWalker.cpp */; }; + 276E60081CDB57AA003FF4B4 /* ParseTreeWalker.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5D041CDB57AA003FF4B4 /* ParseTreeWalker.cpp */; }; + 276E60091CDB57AA003FF4B4 /* ParseTreeWalker.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5D041CDB57AA003FF4B4 /* ParseTreeWalker.cpp */; }; + 276E600A1CDB57AA003FF4B4 /* ParseTreeWalker.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5D051CDB57AA003FF4B4 /* ParseTreeWalker.h */; }; + 276E600B1CDB57AA003FF4B4 /* ParseTreeWalker.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5D051CDB57AA003FF4B4 /* ParseTreeWalker.h */; }; + 276E600C1CDB57AA003FF4B4 /* ParseTreeWalker.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5D051CDB57AA003FF4B4 /* ParseTreeWalker.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E600D1CDB57AA003FF4B4 /* Chunk.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5D071CDB57AA003FF4B4 /* Chunk.h */; }; + 276E600E1CDB57AA003FF4B4 /* Chunk.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5D071CDB57AA003FF4B4 /* Chunk.h */; }; + 276E600F1CDB57AA003FF4B4 /* Chunk.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5D071CDB57AA003FF4B4 /* Chunk.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E60101CDB57AA003FF4B4 /* ParseTreeMatch.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5D081CDB57AA003FF4B4 /* ParseTreeMatch.cpp */; }; + 276E60111CDB57AA003FF4B4 /* ParseTreeMatch.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5D081CDB57AA003FF4B4 /* ParseTreeMatch.cpp */; }; + 276E60121CDB57AA003FF4B4 /* ParseTreeMatch.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5D081CDB57AA003FF4B4 /* ParseTreeMatch.cpp */; }; + 276E60131CDB57AA003FF4B4 /* ParseTreeMatch.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5D091CDB57AA003FF4B4 /* ParseTreeMatch.h */; }; + 276E60141CDB57AA003FF4B4 /* ParseTreeMatch.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5D091CDB57AA003FF4B4 /* ParseTreeMatch.h */; }; + 276E60151CDB57AA003FF4B4 /* ParseTreeMatch.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5D091CDB57AA003FF4B4 /* ParseTreeMatch.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E60161CDB57AA003FF4B4 /* ParseTreePattern.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5D0A1CDB57AA003FF4B4 /* ParseTreePattern.cpp */; }; + 276E60171CDB57AA003FF4B4 /* ParseTreePattern.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5D0A1CDB57AA003FF4B4 /* ParseTreePattern.cpp */; }; + 276E60181CDB57AA003FF4B4 /* ParseTreePattern.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5D0A1CDB57AA003FF4B4 /* ParseTreePattern.cpp */; }; + 276E60191CDB57AA003FF4B4 /* ParseTreePattern.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5D0B1CDB57AA003FF4B4 /* ParseTreePattern.h */; }; + 276E601A1CDB57AA003FF4B4 /* ParseTreePattern.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5D0B1CDB57AA003FF4B4 /* ParseTreePattern.h */; }; + 276E601B1CDB57AA003FF4B4 /* ParseTreePattern.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5D0B1CDB57AA003FF4B4 /* ParseTreePattern.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E601C1CDB57AA003FF4B4 /* ParseTreePatternMatcher.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5D0C1CDB57AA003FF4B4 /* ParseTreePatternMatcher.cpp */; }; + 276E601D1CDB57AA003FF4B4 /* ParseTreePatternMatcher.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5D0C1CDB57AA003FF4B4 /* ParseTreePatternMatcher.cpp */; }; + 276E601E1CDB57AA003FF4B4 /* ParseTreePatternMatcher.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5D0C1CDB57AA003FF4B4 /* ParseTreePatternMatcher.cpp */; }; + 276E601F1CDB57AA003FF4B4 /* ParseTreePatternMatcher.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5D0D1CDB57AA003FF4B4 /* ParseTreePatternMatcher.h */; }; + 276E60201CDB57AA003FF4B4 /* ParseTreePatternMatcher.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5D0D1CDB57AA003FF4B4 /* ParseTreePatternMatcher.h */; }; + 276E60211CDB57AA003FF4B4 /* ParseTreePatternMatcher.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5D0D1CDB57AA003FF4B4 /* ParseTreePatternMatcher.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E60221CDB57AA003FF4B4 /* RuleTagToken.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5D0E1CDB57AA003FF4B4 /* RuleTagToken.cpp */; }; + 276E60231CDB57AA003FF4B4 /* RuleTagToken.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5D0E1CDB57AA003FF4B4 /* RuleTagToken.cpp */; }; + 276E60241CDB57AA003FF4B4 /* RuleTagToken.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5D0E1CDB57AA003FF4B4 /* RuleTagToken.cpp */; }; + 276E60251CDB57AA003FF4B4 /* RuleTagToken.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5D0F1CDB57AA003FF4B4 /* RuleTagToken.h */; }; + 276E60261CDB57AA003FF4B4 /* RuleTagToken.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5D0F1CDB57AA003FF4B4 /* RuleTagToken.h */; }; + 276E60271CDB57AA003FF4B4 /* RuleTagToken.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5D0F1CDB57AA003FF4B4 /* RuleTagToken.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E60281CDB57AA003FF4B4 /* TagChunk.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5D101CDB57AA003FF4B4 /* TagChunk.cpp */; }; + 276E60291CDB57AA003FF4B4 /* TagChunk.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5D101CDB57AA003FF4B4 /* TagChunk.cpp */; }; + 276E602A1CDB57AA003FF4B4 /* TagChunk.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5D101CDB57AA003FF4B4 /* TagChunk.cpp */; }; + 276E602B1CDB57AA003FF4B4 /* TagChunk.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5D111CDB57AA003FF4B4 /* TagChunk.h */; }; + 276E602C1CDB57AA003FF4B4 /* TagChunk.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5D111CDB57AA003FF4B4 /* TagChunk.h */; }; + 276E602D1CDB57AA003FF4B4 /* TagChunk.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5D111CDB57AA003FF4B4 /* TagChunk.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E602E1CDB57AA003FF4B4 /* TextChunk.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5D121CDB57AA003FF4B4 /* TextChunk.cpp */; }; + 276E602F1CDB57AA003FF4B4 /* TextChunk.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5D121CDB57AA003FF4B4 /* TextChunk.cpp */; }; + 276E60301CDB57AA003FF4B4 /* TextChunk.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5D121CDB57AA003FF4B4 /* TextChunk.cpp */; }; + 276E60311CDB57AA003FF4B4 /* TextChunk.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5D131CDB57AA003FF4B4 /* TextChunk.h */; }; + 276E60321CDB57AA003FF4B4 /* TextChunk.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5D131CDB57AA003FF4B4 /* TextChunk.h */; }; + 276E60331CDB57AA003FF4B4 /* TextChunk.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5D131CDB57AA003FF4B4 /* TextChunk.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E60341CDB57AA003FF4B4 /* TokenTagToken.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5D141CDB57AA003FF4B4 /* TokenTagToken.cpp */; }; + 276E60351CDB57AA003FF4B4 /* TokenTagToken.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5D141CDB57AA003FF4B4 /* TokenTagToken.cpp */; }; + 276E60361CDB57AA003FF4B4 /* TokenTagToken.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5D141CDB57AA003FF4B4 /* TokenTagToken.cpp */; }; + 276E60371CDB57AA003FF4B4 /* TokenTagToken.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5D151CDB57AA003FF4B4 /* TokenTagToken.h */; }; + 276E60381CDB57AA003FF4B4 /* TokenTagToken.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5D151CDB57AA003FF4B4 /* TokenTagToken.h */; }; + 276E60391CDB57AA003FF4B4 /* TokenTagToken.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5D151CDB57AA003FF4B4 /* TokenTagToken.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E60401CDB57AA003FF4B4 /* TerminalNode.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5D181CDB57AA003FF4B4 /* TerminalNode.h */; }; + 276E60411CDB57AA003FF4B4 /* TerminalNode.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5D181CDB57AA003FF4B4 /* TerminalNode.h */; }; + 276E60421CDB57AA003FF4B4 /* TerminalNode.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5D181CDB57AA003FF4B4 /* TerminalNode.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E60431CDB57AA003FF4B4 /* TerminalNodeImpl.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5D191CDB57AA003FF4B4 /* TerminalNodeImpl.cpp */; }; + 276E60441CDB57AA003FF4B4 /* TerminalNodeImpl.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5D191CDB57AA003FF4B4 /* TerminalNodeImpl.cpp */; }; + 276E60451CDB57AA003FF4B4 /* TerminalNodeImpl.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5D191CDB57AA003FF4B4 /* TerminalNodeImpl.cpp */; }; + 276E60461CDB57AA003FF4B4 /* TerminalNodeImpl.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5D1A1CDB57AA003FF4B4 /* TerminalNodeImpl.h */; }; + 276E60471CDB57AA003FF4B4 /* TerminalNodeImpl.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5D1A1CDB57AA003FF4B4 /* TerminalNodeImpl.h */; }; + 276E60481CDB57AA003FF4B4 /* TerminalNodeImpl.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5D1A1CDB57AA003FF4B4 /* TerminalNodeImpl.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E604F1CDB57AA003FF4B4 /* Trees.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5D1D1CDB57AA003FF4B4 /* Trees.cpp */; }; + 276E60501CDB57AA003FF4B4 /* Trees.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5D1D1CDB57AA003FF4B4 /* Trees.cpp */; }; + 276E60511CDB57AA003FF4B4 /* Trees.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5D1D1CDB57AA003FF4B4 /* Trees.cpp */; }; + 276E60521CDB57AA003FF4B4 /* Trees.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5D1E1CDB57AA003FF4B4 /* Trees.h */; }; + 276E60531CDB57AA003FF4B4 /* Trees.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5D1E1CDB57AA003FF4B4 /* Trees.h */; }; + 276E60541CDB57AA003FF4B4 /* Trees.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5D1E1CDB57AA003FF4B4 /* Trees.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E605B1CDB57AA003FF4B4 /* UnbufferedCharStream.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5D221CDB57AA003FF4B4 /* UnbufferedCharStream.cpp */; }; + 276E605C1CDB57AA003FF4B4 /* UnbufferedCharStream.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5D221CDB57AA003FF4B4 /* UnbufferedCharStream.cpp */; }; + 276E605D1CDB57AA003FF4B4 /* UnbufferedCharStream.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5D221CDB57AA003FF4B4 /* UnbufferedCharStream.cpp */; }; + 276E605E1CDB57AA003FF4B4 /* UnbufferedCharStream.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5D231CDB57AA003FF4B4 /* UnbufferedCharStream.h */; }; + 276E605F1CDB57AA003FF4B4 /* UnbufferedCharStream.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5D231CDB57AA003FF4B4 /* UnbufferedCharStream.h */; }; + 276E60601CDB57AA003FF4B4 /* UnbufferedCharStream.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5D231CDB57AA003FF4B4 /* UnbufferedCharStream.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E60611CDB57AA003FF4B4 /* UnbufferedTokenStream.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5D241CDB57AA003FF4B4 /* UnbufferedTokenStream.cpp */; }; + 276E60621CDB57AA003FF4B4 /* UnbufferedTokenStream.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5D241CDB57AA003FF4B4 /* UnbufferedTokenStream.cpp */; }; + 276E60631CDB57AA003FF4B4 /* UnbufferedTokenStream.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5D241CDB57AA003FF4B4 /* UnbufferedTokenStream.cpp */; }; + 276E60641CDB57AA003FF4B4 /* UnbufferedTokenStream.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5D251CDB57AA003FF4B4 /* UnbufferedTokenStream.h */; }; + 276E60651CDB57AA003FF4B4 /* UnbufferedTokenStream.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5D251CDB57AA003FF4B4 /* UnbufferedTokenStream.h */; }; + 276E60661CDB57AA003FF4B4 /* UnbufferedTokenStream.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5D251CDB57AA003FF4B4 /* UnbufferedTokenStream.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E606A1CDB57AA003FF4B4 /* Vocabulary.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5D271CDB57AA003FF4B4 /* Vocabulary.cpp */; }; + 276E606B1CDB57AA003FF4B4 /* Vocabulary.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5D271CDB57AA003FF4B4 /* Vocabulary.cpp */; }; + 276E606C1CDB57AA003FF4B4 /* Vocabulary.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 276E5D271CDB57AA003FF4B4 /* Vocabulary.cpp */; }; + 276E606D1CDB57AA003FF4B4 /* Vocabulary.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5D281CDB57AA003FF4B4 /* Vocabulary.h */; }; + 276E606E1CDB57AA003FF4B4 /* Vocabulary.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5D281CDB57AA003FF4B4 /* Vocabulary.h */; }; + 276E606F1CDB57AA003FF4B4 /* Vocabulary.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5D281CDB57AA003FF4B4 /* Vocabulary.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 276E60731CDB57AA003FF4B4 /* WritableToken.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5D2A1CDB57AA003FF4B4 /* WritableToken.h */; }; + 276E60741CDB57AA003FF4B4 /* WritableToken.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5D2A1CDB57AA003FF4B4 /* WritableToken.h */; }; + 276E60751CDB57AA003FF4B4 /* WritableToken.h in Headers */ = {isa = PBXBuildFile; fileRef = 276E5D2A1CDB57AA003FF4B4 /* WritableToken.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 27745F031CE49C000067C6A3 /* RuntimeMetaData.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 27745EFB1CE49C000067C6A3 /* RuntimeMetaData.cpp */; }; + 27745F041CE49C000067C6A3 /* RuntimeMetaData.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 27745EFB1CE49C000067C6A3 /* RuntimeMetaData.cpp */; }; + 27745F051CE49C000067C6A3 /* RuntimeMetaData.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 27745EFB1CE49C000067C6A3 /* RuntimeMetaData.cpp */; }; + 27745F061CE49C000067C6A3 /* RuntimeMetaData.h in Headers */ = {isa = PBXBuildFile; fileRef = 27745EFC1CE49C000067C6A3 /* RuntimeMetaData.h */; }; + 27745F071CE49C000067C6A3 /* RuntimeMetaData.h in Headers */ = {isa = PBXBuildFile; fileRef = 27745EFC1CE49C000067C6A3 /* RuntimeMetaData.h */; }; + 27745F081CE49C000067C6A3 /* RuntimeMetaData.h in Headers */ = {isa = PBXBuildFile; fileRef = 27745EFC1CE49C000067C6A3 /* RuntimeMetaData.h */; }; + 27874F1E1CCB7A0700AF1C53 /* CoreFoundation.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 27874F1D1CCB7A0700AF1C53 /* CoreFoundation.framework */; }; + 27874F211CCB7B1700AF1C53 /* CoreFoundation.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 27874F1D1CCB7A0700AF1C53 /* CoreFoundation.framework */; }; + 2793DC851F08083F00A84290 /* TokenSource.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2793DC841F08083F00A84290 /* TokenSource.cpp */; }; + 2793DC861F08083F00A84290 /* TokenSource.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2793DC841F08083F00A84290 /* TokenSource.cpp */; }; + 2793DC871F08083F00A84290 /* TokenSource.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2793DC841F08083F00A84290 /* TokenSource.cpp */; }; + 2793DC891F08087500A84290 /* Chunk.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2793DC881F08087500A84290 /* Chunk.cpp */; }; + 2793DC8A1F08087500A84290 /* Chunk.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2793DC881F08087500A84290 /* Chunk.cpp */; }; + 2793DC8B1F08087500A84290 /* Chunk.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2793DC881F08087500A84290 /* Chunk.cpp */; }; + 2793DC8D1F08088F00A84290 /* ParseTreeListener.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2793DC8C1F08088F00A84290 /* ParseTreeListener.cpp */; }; + 2793DC8E1F08088F00A84290 /* ParseTreeListener.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2793DC8C1F08088F00A84290 /* ParseTreeListener.cpp */; }; + 2793DC8F1F08088F00A84290 /* ParseTreeListener.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2793DC8C1F08088F00A84290 /* ParseTreeListener.cpp */; }; + 2793DC911F0808A200A84290 /* TerminalNode.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2793DC901F0808A200A84290 /* TerminalNode.cpp */; }; + 2793DC921F0808A200A84290 /* TerminalNode.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2793DC901F0808A200A84290 /* TerminalNode.cpp */; }; + 2793DC931F0808A200A84290 /* TerminalNode.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2793DC901F0808A200A84290 /* TerminalNode.cpp */; }; + 2793DC961F0808E100A84290 /* ErrorNode.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2793DC941F0808E100A84290 /* ErrorNode.cpp */; }; + 2793DC971F0808E100A84290 /* ErrorNode.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2793DC941F0808E100A84290 /* ErrorNode.cpp */; }; + 2793DC981F0808E100A84290 /* ErrorNode.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2793DC941F0808E100A84290 /* ErrorNode.cpp */; }; + 2793DC991F0808E100A84290 /* ParseTreeVisitor.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2793DC951F0808E100A84290 /* ParseTreeVisitor.cpp */; }; + 2793DC9A1F0808E100A84290 /* ParseTreeVisitor.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2793DC951F0808E100A84290 /* ParseTreeVisitor.cpp */; }; + 2793DC9B1F0808E100A84290 /* ParseTreeVisitor.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2793DC951F0808E100A84290 /* ParseTreeVisitor.cpp */; }; + 2793DC9D1F08090D00A84290 /* Any.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2793DC9C1F08090D00A84290 /* Any.cpp */; }; + 2793DC9E1F08090D00A84290 /* Any.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2793DC9C1F08090D00A84290 /* Any.cpp */; }; + 2793DC9F1F08090D00A84290 /* Any.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2793DC9C1F08090D00A84290 /* Any.cpp */; }; + 2793DCA41F08095F00A84290 /* ANTLRErrorListener.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2793DCA01F08095F00A84290 /* ANTLRErrorListener.cpp */; }; + 2793DCA51F08095F00A84290 /* ANTLRErrorListener.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2793DCA01F08095F00A84290 /* ANTLRErrorListener.cpp */; }; + 2793DCA61F08095F00A84290 /* ANTLRErrorListener.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2793DCA01F08095F00A84290 /* ANTLRErrorListener.cpp */; }; + 2793DCA71F08095F00A84290 /* ANTLRErrorStrategy.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2793DCA11F08095F00A84290 /* ANTLRErrorStrategy.cpp */; }; + 2793DCA81F08095F00A84290 /* ANTLRErrorStrategy.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2793DCA11F08095F00A84290 /* ANTLRErrorStrategy.cpp */; }; + 2793DCA91F08095F00A84290 /* ANTLRErrorStrategy.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2793DCA11F08095F00A84290 /* ANTLRErrorStrategy.cpp */; }; + 2793DCAA1F08095F00A84290 /* Token.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2793DCA21F08095F00A84290 /* Token.cpp */; }; + 2793DCAB1F08095F00A84290 /* Token.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2793DCA21F08095F00A84290 /* Token.cpp */; }; + 2793DCAC1F08095F00A84290 /* Token.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2793DCA21F08095F00A84290 /* Token.cpp */; }; + 2793DCAD1F08095F00A84290 /* WritableToken.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2793DCA31F08095F00A84290 /* WritableToken.cpp */; }; + 2793DCAE1F08095F00A84290 /* WritableToken.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2793DCA31F08095F00A84290 /* WritableToken.cpp */; }; + 2793DCAF1F08095F00A84290 /* WritableToken.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2793DCA31F08095F00A84290 /* WritableToken.cpp */; }; + 2793DCB31F08099C00A84290 /* BlockStartState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2793DCB01F08099C00A84290 /* BlockStartState.cpp */; }; + 2793DCB41F08099C00A84290 /* BlockStartState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2793DCB01F08099C00A84290 /* BlockStartState.cpp */; }; + 2793DCB51F08099C00A84290 /* BlockStartState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2793DCB01F08099C00A84290 /* BlockStartState.cpp */; }; + 2793DCB61F08099C00A84290 /* LexerAction.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2793DCB11F08099C00A84290 /* LexerAction.cpp */; }; + 2793DCB71F08099C00A84290 /* LexerAction.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2793DCB11F08099C00A84290 /* LexerAction.cpp */; }; + 2793DCB81F08099C00A84290 /* LexerAction.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2793DCB11F08099C00A84290 /* LexerAction.cpp */; }; + 2794D8561CE7821B00FADD0F /* antlr4-common.h in Headers */ = {isa = PBXBuildFile; fileRef = 2794D8551CE7821B00FADD0F /* antlr4-common.h */; }; + 2794D8571CE7821B00FADD0F /* antlr4-common.h in Headers */ = {isa = PBXBuildFile; fileRef = 2794D8551CE7821B00FADD0F /* antlr4-common.h */; }; + 2794D8581CE7821B00FADD0F /* antlr4-common.h in Headers */ = {isa = PBXBuildFile; fileRef = 2794D8551CE7821B00FADD0F /* antlr4-common.h */; }; + 27AC52D01CE773A80093AAAB /* antlr4-runtime.h in Headers */ = {isa = PBXBuildFile; fileRef = 27AC52CF1CE773A80093AAAB /* antlr4-runtime.h */; }; + 27AC52D11CE773A80093AAAB /* antlr4-runtime.h in Headers */ = {isa = PBXBuildFile; fileRef = 27AC52CF1CE773A80093AAAB /* antlr4-runtime.h */; }; + 27AC52D21CE773A80093AAAB /* antlr4-runtime.h in Headers */ = {isa = PBXBuildFile; fileRef = 27AC52CF1CE773A80093AAAB /* antlr4-runtime.h */; }; + 27B36AC61DACE7AF0069C868 /* RuleContextWithAltNum.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 27B36AC41DACE7AF0069C868 /* RuleContextWithAltNum.cpp */; }; + 27B36AC71DACE7AF0069C868 /* RuleContextWithAltNum.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 27B36AC41DACE7AF0069C868 /* RuleContextWithAltNum.cpp */; }; + 27B36AC81DACE7AF0069C868 /* RuleContextWithAltNum.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 27B36AC41DACE7AF0069C868 /* RuleContextWithAltNum.cpp */; }; + 27B36AC91DACE7AF0069C868 /* RuleContextWithAltNum.h in Headers */ = {isa = PBXBuildFile; fileRef = 27B36AC51DACE7AF0069C868 /* RuleContextWithAltNum.h */; }; + 27B36ACA1DACE7AF0069C868 /* RuleContextWithAltNum.h in Headers */ = {isa = PBXBuildFile; fileRef = 27B36AC51DACE7AF0069C868 /* RuleContextWithAltNum.h */; }; + 27B36ACB1DACE7AF0069C868 /* RuleContextWithAltNum.h in Headers */ = {isa = PBXBuildFile; fileRef = 27B36AC51DACE7AF0069C868 /* RuleContextWithAltNum.h */; }; + 27C375841EA1059C00B5883C /* InterpreterDataReader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 27C375821EA1059C00B5883C /* InterpreterDataReader.cpp */; }; + 27C375851EA1059C00B5883C /* InterpreterDataReader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 27C375821EA1059C00B5883C /* InterpreterDataReader.cpp */; }; + 27C375861EA1059C00B5883C /* InterpreterDataReader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 27C375821EA1059C00B5883C /* InterpreterDataReader.cpp */; }; + 27C375871EA1059C00B5883C /* InterpreterDataReader.h in Headers */ = {isa = PBXBuildFile; fileRef = 27C375831EA1059C00B5883C /* InterpreterDataReader.h */; }; + 27C375881EA1059C00B5883C /* InterpreterDataReader.h in Headers */ = {isa = PBXBuildFile; fileRef = 27C375831EA1059C00B5883C /* InterpreterDataReader.h */; }; + 27C375891EA1059C00B5883C /* InterpreterDataReader.h in Headers */ = {isa = PBXBuildFile; fileRef = 27C375831EA1059C00B5883C /* InterpreterDataReader.h */; }; + 27D414521DEB0D3D00D0F3F9 /* IterativeParseTreeWalker.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 27D414501DEB0D3D00D0F3F9 /* IterativeParseTreeWalker.cpp */; }; + 27D414531DEB0D3D00D0F3F9 /* IterativeParseTreeWalker.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 27D414501DEB0D3D00D0F3F9 /* IterativeParseTreeWalker.cpp */; }; + 27D414541DEB0D3D00D0F3F9 /* IterativeParseTreeWalker.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 27D414501DEB0D3D00D0F3F9 /* IterativeParseTreeWalker.cpp */; }; + 27D414551DEB0D3D00D0F3F9 /* IterativeParseTreeWalker.h in Headers */ = {isa = PBXBuildFile; fileRef = 27D414511DEB0D3D00D0F3F9 /* IterativeParseTreeWalker.h */; }; + 27D414561DEB0D3D00D0F3F9 /* IterativeParseTreeWalker.h in Headers */ = {isa = PBXBuildFile; fileRef = 27D414511DEB0D3D00D0F3F9 /* IterativeParseTreeWalker.h */; }; + 27D414571DEB0D3D00D0F3F9 /* IterativeParseTreeWalker.h in Headers */ = {isa = PBXBuildFile; fileRef = 27D414511DEB0D3D00D0F3F9 /* IterativeParseTreeWalker.h */; }; + 27DB449D1D045537007E790B /* XPath.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 27DB448B1D045537007E790B /* XPath.cpp */; }; + 27DB449E1D045537007E790B /* XPath.h in Headers */ = {isa = PBXBuildFile; fileRef = 27DB448C1D045537007E790B /* XPath.h */; }; + 27DB449F1D045537007E790B /* XPathElement.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 27DB448D1D045537007E790B /* XPathElement.cpp */; }; + 27DB44A01D045537007E790B /* XPathElement.h in Headers */ = {isa = PBXBuildFile; fileRef = 27DB448E1D045537007E790B /* XPathElement.h */; }; + 27DB44A11D045537007E790B /* XPathLexerErrorListener.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 27DB448F1D045537007E790B /* XPathLexerErrorListener.cpp */; }; + 27DB44A21D045537007E790B /* XPathLexerErrorListener.h in Headers */ = {isa = PBXBuildFile; fileRef = 27DB44901D045537007E790B /* XPathLexerErrorListener.h */; }; + 27DB44A31D045537007E790B /* XPathRuleAnywhereElement.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 27DB44911D045537007E790B /* XPathRuleAnywhereElement.cpp */; }; + 27DB44A41D045537007E790B /* XPathRuleAnywhereElement.h in Headers */ = {isa = PBXBuildFile; fileRef = 27DB44921D045537007E790B /* XPathRuleAnywhereElement.h */; }; + 27DB44A51D045537007E790B /* XPathRuleElement.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 27DB44931D045537007E790B /* XPathRuleElement.cpp */; }; + 27DB44A61D045537007E790B /* XPathRuleElement.h in Headers */ = {isa = PBXBuildFile; fileRef = 27DB44941D045537007E790B /* XPathRuleElement.h */; }; + 27DB44A71D045537007E790B /* XPathTokenAnywhereElement.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 27DB44951D045537007E790B /* XPathTokenAnywhereElement.cpp */; }; + 27DB44A81D045537007E790B /* XPathTokenAnywhereElement.h in Headers */ = {isa = PBXBuildFile; fileRef = 27DB44961D045537007E790B /* XPathTokenAnywhereElement.h */; }; + 27DB44A91D045537007E790B /* XPathTokenElement.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 27DB44971D045537007E790B /* XPathTokenElement.cpp */; }; + 27DB44AA1D045537007E790B /* XPathTokenElement.h in Headers */ = {isa = PBXBuildFile; fileRef = 27DB44981D045537007E790B /* XPathTokenElement.h */; }; + 27DB44AB1D045537007E790B /* XPathWildcardAnywhereElement.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 27DB44991D045537007E790B /* XPathWildcardAnywhereElement.cpp */; }; + 27DB44AC1D045537007E790B /* XPathWildcardAnywhereElement.h in Headers */ = {isa = PBXBuildFile; fileRef = 27DB449A1D045537007E790B /* XPathWildcardAnywhereElement.h */; }; + 27DB44AD1D045537007E790B /* XPathWildcardElement.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 27DB449B1D045537007E790B /* XPathWildcardElement.cpp */; }; + 27DB44AE1D045537007E790B /* XPathWildcardElement.h in Headers */ = {isa = PBXBuildFile; fileRef = 27DB449C1D045537007E790B /* XPathWildcardElement.h */; }; + 27DB44B11D0463CC007E790B /* XPathLexer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 27DB44AF1D0463CC007E790B /* XPathLexer.cpp */; }; + 27DB44B21D0463CC007E790B /* XPathLexer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 27DB44AF1D0463CC007E790B /* XPathLexer.cpp */; }; + 27DB44B31D0463CC007E790B /* XPathLexer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 27DB44AF1D0463CC007E790B /* XPathLexer.cpp */; }; + 27DB44B41D0463CC007E790B /* XPathLexer.h in Headers */ = {isa = PBXBuildFile; fileRef = 27DB44B01D0463CC007E790B /* XPathLexer.h */; }; + 27DB44B51D0463CC007E790B /* XPathLexer.h in Headers */ = {isa = PBXBuildFile; fileRef = 27DB44B01D0463CC007E790B /* XPathLexer.h */; }; + 27DB44B61D0463CC007E790B /* XPathLexer.h in Headers */ = {isa = PBXBuildFile; fileRef = 27DB44B01D0463CC007E790B /* XPathLexer.h */; }; + 27DB44B71D0463DA007E790B /* XPath.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 27DB448B1D045537007E790B /* XPath.cpp */; }; + 27DB44B81D0463DA007E790B /* XPath.h in Headers */ = {isa = PBXBuildFile; fileRef = 27DB448C1D045537007E790B /* XPath.h */; }; + 27DB44B91D0463DA007E790B /* XPathElement.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 27DB448D1D045537007E790B /* XPathElement.cpp */; }; + 27DB44BA1D0463DA007E790B /* XPathElement.h in Headers */ = {isa = PBXBuildFile; fileRef = 27DB448E1D045537007E790B /* XPathElement.h */; }; + 27DB44BB1D0463DA007E790B /* XPathLexerErrorListener.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 27DB448F1D045537007E790B /* XPathLexerErrorListener.cpp */; }; + 27DB44BC1D0463DA007E790B /* XPathLexerErrorListener.h in Headers */ = {isa = PBXBuildFile; fileRef = 27DB44901D045537007E790B /* XPathLexerErrorListener.h */; }; + 27DB44BD1D0463DA007E790B /* XPathRuleAnywhereElement.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 27DB44911D045537007E790B /* XPathRuleAnywhereElement.cpp */; }; + 27DB44BE1D0463DA007E790B /* XPathRuleAnywhereElement.h in Headers */ = {isa = PBXBuildFile; fileRef = 27DB44921D045537007E790B /* XPathRuleAnywhereElement.h */; }; + 27DB44BF1D0463DA007E790B /* XPathRuleElement.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 27DB44931D045537007E790B /* XPathRuleElement.cpp */; }; + 27DB44C01D0463DA007E790B /* XPathRuleElement.h in Headers */ = {isa = PBXBuildFile; fileRef = 27DB44941D045537007E790B /* XPathRuleElement.h */; }; + 27DB44C11D0463DA007E790B /* XPathTokenAnywhereElement.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 27DB44951D045537007E790B /* XPathTokenAnywhereElement.cpp */; }; + 27DB44C21D0463DA007E790B /* XPathTokenAnywhereElement.h in Headers */ = {isa = PBXBuildFile; fileRef = 27DB44961D045537007E790B /* XPathTokenAnywhereElement.h */; }; + 27DB44C31D0463DA007E790B /* XPathTokenElement.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 27DB44971D045537007E790B /* XPathTokenElement.cpp */; }; + 27DB44C41D0463DA007E790B /* XPathTokenElement.h in Headers */ = {isa = PBXBuildFile; fileRef = 27DB44981D045537007E790B /* XPathTokenElement.h */; }; + 27DB44C51D0463DA007E790B /* XPathWildcardAnywhereElement.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 27DB44991D045537007E790B /* XPathWildcardAnywhereElement.cpp */; }; + 27DB44C61D0463DA007E790B /* XPathWildcardAnywhereElement.h in Headers */ = {isa = PBXBuildFile; fileRef = 27DB449A1D045537007E790B /* XPathWildcardAnywhereElement.h */; }; + 27DB44C71D0463DA007E790B /* XPathWildcardElement.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 27DB449B1D045537007E790B /* XPathWildcardElement.cpp */; }; + 27DB44C81D0463DA007E790B /* XPathWildcardElement.h in Headers */ = {isa = PBXBuildFile; fileRef = 27DB449C1D045537007E790B /* XPathWildcardElement.h */; }; + 27DB44C91D0463DB007E790B /* XPath.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 27DB448B1D045537007E790B /* XPath.cpp */; }; + 27DB44CA1D0463DB007E790B /* XPath.h in Headers */ = {isa = PBXBuildFile; fileRef = 27DB448C1D045537007E790B /* XPath.h */; }; + 27DB44CB1D0463DB007E790B /* XPathElement.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 27DB448D1D045537007E790B /* XPathElement.cpp */; }; + 27DB44CC1D0463DB007E790B /* XPathElement.h in Headers */ = {isa = PBXBuildFile; fileRef = 27DB448E1D045537007E790B /* XPathElement.h */; }; + 27DB44CD1D0463DB007E790B /* XPathLexerErrorListener.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 27DB448F1D045537007E790B /* XPathLexerErrorListener.cpp */; }; + 27DB44CE1D0463DB007E790B /* XPathLexerErrorListener.h in Headers */ = {isa = PBXBuildFile; fileRef = 27DB44901D045537007E790B /* XPathLexerErrorListener.h */; }; + 27DB44CF1D0463DB007E790B /* XPathRuleAnywhereElement.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 27DB44911D045537007E790B /* XPathRuleAnywhereElement.cpp */; }; + 27DB44D01D0463DB007E790B /* XPathRuleAnywhereElement.h in Headers */ = {isa = PBXBuildFile; fileRef = 27DB44921D045537007E790B /* XPathRuleAnywhereElement.h */; }; + 27DB44D11D0463DB007E790B /* XPathRuleElement.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 27DB44931D045537007E790B /* XPathRuleElement.cpp */; }; + 27DB44D21D0463DB007E790B /* XPathRuleElement.h in Headers */ = {isa = PBXBuildFile; fileRef = 27DB44941D045537007E790B /* XPathRuleElement.h */; }; + 27DB44D31D0463DB007E790B /* XPathTokenAnywhereElement.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 27DB44951D045537007E790B /* XPathTokenAnywhereElement.cpp */; }; + 27DB44D41D0463DB007E790B /* XPathTokenAnywhereElement.h in Headers */ = {isa = PBXBuildFile; fileRef = 27DB44961D045537007E790B /* XPathTokenAnywhereElement.h */; }; + 27DB44D51D0463DB007E790B /* XPathTokenElement.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 27DB44971D045537007E790B /* XPathTokenElement.cpp */; }; + 27DB44D61D0463DB007E790B /* XPathTokenElement.h in Headers */ = {isa = PBXBuildFile; fileRef = 27DB44981D045537007E790B /* XPathTokenElement.h */; }; + 27DB44D71D0463DB007E790B /* XPathWildcardAnywhereElement.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 27DB44991D045537007E790B /* XPathWildcardAnywhereElement.cpp */; }; + 27DB44D81D0463DB007E790B /* XPathWildcardAnywhereElement.h in Headers */ = {isa = PBXBuildFile; fileRef = 27DB449A1D045537007E790B /* XPathWildcardAnywhereElement.h */; }; + 27DB44D91D0463DB007E790B /* XPathWildcardElement.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 27DB449B1D045537007E790B /* XPathWildcardElement.cpp */; }; + 27DB44DA1D0463DB007E790B /* XPathWildcardElement.h in Headers */ = {isa = PBXBuildFile; fileRef = 27DB449C1D045537007E790B /* XPathWildcardElement.h */; }; + 27F4A8561D4CEB2A00E067EE /* Any.h in Headers */ = {isa = PBXBuildFile; fileRef = 27F4A8551D4CEB2A00E067EE /* Any.h */; }; +/* End PBXBuildFile section */ + +/* Begin PBXFileReference section */ + 270C67F01CDB4F1E00116E17 /* antlr4_ios.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = antlr4_ios.framework; sourceTree = BUILT_PRODUCTS_DIR; }; + 270C67F21CDB4F1E00116E17 /* antlrcpp_ios.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = antlrcpp_ios.h; sourceTree = ""; wrapsLines = 0; }; + 270C67F41CDB4F1E00116E17 /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = ""; }; + 270C69DF1CDB536A00116E17 /* CoreFoundation.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreFoundation.framework; path = Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS9.3.sdk/System/Library/Frameworks/CoreFoundation.framework; sourceTree = DEVELOPER_DIR; }; + 276566DF1DA93BFB000869BE /* ParseTree.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ParseTree.cpp; sourceTree = ""; }; + 276E5C0C1CDB57AA003FF4B4 /* ANTLRErrorListener.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ANTLRErrorListener.h; sourceTree = ""; wrapsLines = 0; }; + 276E5C0D1CDB57AA003FF4B4 /* ANTLRErrorStrategy.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ANTLRErrorStrategy.h; sourceTree = ""; }; + 276E5C0E1CDB57AA003FF4B4 /* ANTLRFileStream.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ANTLRFileStream.cpp; sourceTree = ""; }; + 276E5C0F1CDB57AA003FF4B4 /* ANTLRFileStream.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ANTLRFileStream.h; sourceTree = ""; wrapsLines = 0; }; + 276E5C101CDB57AA003FF4B4 /* ANTLRInputStream.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ANTLRInputStream.cpp; sourceTree = ""; }; + 276E5C111CDB57AA003FF4B4 /* ANTLRInputStream.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ANTLRInputStream.h; sourceTree = ""; }; + 276E5C131CDB57AA003FF4B4 /* AbstractPredicateTransition.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = AbstractPredicateTransition.cpp; sourceTree = ""; wrapsLines = 0; }; + 276E5C141CDB57AA003FF4B4 /* AbstractPredicateTransition.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = AbstractPredicateTransition.h; sourceTree = ""; }; + 276E5C151CDB57AA003FF4B4 /* ActionTransition.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ActionTransition.cpp; sourceTree = ""; }; + 276E5C161CDB57AA003FF4B4 /* ActionTransition.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ActionTransition.h; sourceTree = ""; }; + 276E5C171CDB57AA003FF4B4 /* AmbiguityInfo.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = AmbiguityInfo.cpp; sourceTree = ""; }; + 276E5C181CDB57AA003FF4B4 /* AmbiguityInfo.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = AmbiguityInfo.h; sourceTree = ""; }; + 276E5C191CDB57AA003FF4B4 /* ArrayPredictionContext.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; lineEnding = 0; path = ArrayPredictionContext.cpp; sourceTree = ""; wrapsLines = 0; xcLanguageSpecificationIdentifier = xcode.lang.cpp; }; + 276E5C1A1CDB57AA003FF4B4 /* ArrayPredictionContext.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; lineEnding = 0; path = ArrayPredictionContext.h; sourceTree = ""; wrapsLines = 0; xcLanguageSpecificationIdentifier = xcode.lang.objcpp; }; + 276E5C1B1CDB57AA003FF4B4 /* ATN.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ATN.cpp; sourceTree = ""; }; + 276E5C1C1CDB57AA003FF4B4 /* ATN.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ATN.h; sourceTree = ""; }; + 276E5C1D1CDB57AA003FF4B4 /* ATNConfig.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; lineEnding = 0; path = ATNConfig.cpp; sourceTree = ""; wrapsLines = 0; xcLanguageSpecificationIdentifier = xcode.lang.cpp; }; + 276E5C1E1CDB57AA003FF4B4 /* ATNConfig.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; lineEnding = 0; path = ATNConfig.h; sourceTree = ""; wrapsLines = 0; xcLanguageSpecificationIdentifier = xcode.lang.objcpp; }; + 276E5C1F1CDB57AA003FF4B4 /* ATNConfigSet.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ATNConfigSet.cpp; sourceTree = ""; wrapsLines = 0; }; + 276E5C201CDB57AA003FF4B4 /* ATNConfigSet.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ATNConfigSet.h; sourceTree = ""; wrapsLines = 0; }; + 276E5C211CDB57AA003FF4B4 /* ATNDeserializationOptions.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ATNDeserializationOptions.cpp; sourceTree = ""; }; + 276E5C221CDB57AA003FF4B4 /* ATNDeserializationOptions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ATNDeserializationOptions.h; sourceTree = ""; }; + 276E5C231CDB57AA003FF4B4 /* ATNDeserializer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ATNDeserializer.cpp; sourceTree = ""; wrapsLines = 0; }; + 276E5C241CDB57AA003FF4B4 /* ATNDeserializer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ATNDeserializer.h; sourceTree = ""; wrapsLines = 0; }; + 276E5C251CDB57AA003FF4B4 /* ATNSerializer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; lineEnding = 0; path = ATNSerializer.cpp; sourceTree = ""; xcLanguageSpecificationIdentifier = xcode.lang.cpp; }; + 276E5C261CDB57AA003FF4B4 /* ATNSerializer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ATNSerializer.h; sourceTree = ""; }; + 276E5C271CDB57AA003FF4B4 /* ATNSimulator.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; lineEnding = 0; path = ATNSimulator.cpp; sourceTree = ""; xcLanguageSpecificationIdentifier = xcode.lang.cpp; }; + 276E5C281CDB57AA003FF4B4 /* ATNSimulator.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; lineEnding = 0; path = ATNSimulator.h; sourceTree = ""; wrapsLines = 0; xcLanguageSpecificationIdentifier = xcode.lang.objcpp; }; + 276E5C291CDB57AA003FF4B4 /* ATNState.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ATNState.cpp; sourceTree = ""; }; + 276E5C2A1CDB57AA003FF4B4 /* ATNState.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ATNState.h; sourceTree = ""; }; + 276E5C2C1CDB57AA003FF4B4 /* ATNType.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ATNType.h; sourceTree = ""; }; + 276E5C2D1CDB57AA003FF4B4 /* AtomTransition.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = AtomTransition.cpp; sourceTree = ""; }; + 276E5C2E1CDB57AA003FF4B4 /* AtomTransition.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = AtomTransition.h; sourceTree = ""; }; + 276E5C2F1CDB57AA003FF4B4 /* BasicBlockStartState.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = BasicBlockStartState.cpp; sourceTree = ""; }; + 276E5C301CDB57AA003FF4B4 /* BasicBlockStartState.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = BasicBlockStartState.h; sourceTree = ""; }; + 276E5C311CDB57AA003FF4B4 /* BasicState.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = BasicState.cpp; sourceTree = ""; }; + 276E5C321CDB57AA003FF4B4 /* BasicState.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = BasicState.h; sourceTree = ""; }; + 276E5C331CDB57AA003FF4B4 /* BlockEndState.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = BlockEndState.cpp; sourceTree = ""; }; + 276E5C341CDB57AA003FF4B4 /* BlockEndState.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = BlockEndState.h; sourceTree = ""; }; + 276E5C351CDB57AA003FF4B4 /* BlockStartState.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = BlockStartState.h; sourceTree = ""; }; + 276E5C371CDB57AA003FF4B4 /* ContextSensitivityInfo.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ContextSensitivityInfo.cpp; sourceTree = ""; }; + 276E5C381CDB57AA003FF4B4 /* ContextSensitivityInfo.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ContextSensitivityInfo.h; sourceTree = ""; wrapsLines = 0; }; + 276E5C391CDB57AA003FF4B4 /* DecisionEventInfo.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = DecisionEventInfo.cpp; sourceTree = ""; wrapsLines = 0; }; + 276E5C3A1CDB57AA003FF4B4 /* DecisionEventInfo.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DecisionEventInfo.h; sourceTree = ""; wrapsLines = 0; }; + 276E5C3B1CDB57AA003FF4B4 /* DecisionInfo.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = DecisionInfo.cpp; sourceTree = ""; }; + 276E5C3C1CDB57AA003FF4B4 /* DecisionInfo.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DecisionInfo.h; sourceTree = ""; }; + 276E5C3D1CDB57AA003FF4B4 /* DecisionState.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = DecisionState.cpp; sourceTree = ""; }; + 276E5C3E1CDB57AA003FF4B4 /* DecisionState.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DecisionState.h; sourceTree = ""; }; + 276E5C3F1CDB57AA003FF4B4 /* EmptyPredictionContext.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = EmptyPredictionContext.cpp; sourceTree = ""; wrapsLines = 0; }; + 276E5C401CDB57AA003FF4B4 /* EmptyPredictionContext.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = EmptyPredictionContext.h; sourceTree = ""; }; + 276E5C411CDB57AA003FF4B4 /* EpsilonTransition.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = EpsilonTransition.cpp; sourceTree = ""; }; + 276E5C421CDB57AA003FF4B4 /* EpsilonTransition.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = EpsilonTransition.h; sourceTree = ""; }; + 276E5C431CDB57AA003FF4B4 /* ErrorInfo.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ErrorInfo.cpp; sourceTree = ""; wrapsLines = 0; }; + 276E5C441CDB57AA003FF4B4 /* ErrorInfo.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ErrorInfo.h; sourceTree = ""; wrapsLines = 0; }; + 276E5C451CDB57AA003FF4B4 /* LexerAction.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LexerAction.h; sourceTree = ""; }; + 276E5C461CDB57AA003FF4B4 /* LexerActionExecutor.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LexerActionExecutor.cpp; sourceTree = ""; wrapsLines = 0; }; + 276E5C471CDB57AA003FF4B4 /* LexerActionExecutor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LexerActionExecutor.h; sourceTree = ""; wrapsLines = 0; }; + 276E5C491CDB57AA003FF4B4 /* LexerActionType.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LexerActionType.h; sourceTree = ""; }; + 276E5C4A1CDB57AA003FF4B4 /* LexerATNConfig.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LexerATNConfig.cpp; sourceTree = ""; wrapsLines = 0; }; + 276E5C4B1CDB57AA003FF4B4 /* LexerATNConfig.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LexerATNConfig.h; sourceTree = ""; wrapsLines = 0; }; + 276E5C4C1CDB57AA003FF4B4 /* LexerATNSimulator.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LexerATNSimulator.cpp; sourceTree = ""; wrapsLines = 0; }; + 276E5C4D1CDB57AA003FF4B4 /* LexerATNSimulator.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LexerATNSimulator.h; sourceTree = ""; wrapsLines = 0; }; + 276E5C4E1CDB57AA003FF4B4 /* LexerChannelAction.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LexerChannelAction.cpp; sourceTree = ""; }; + 276E5C4F1CDB57AA003FF4B4 /* LexerChannelAction.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LexerChannelAction.h; sourceTree = ""; }; + 276E5C501CDB57AA003FF4B4 /* LexerCustomAction.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LexerCustomAction.cpp; sourceTree = ""; }; + 276E5C511CDB57AA003FF4B4 /* LexerCustomAction.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LexerCustomAction.h; sourceTree = ""; }; + 276E5C521CDB57AA003FF4B4 /* LexerIndexedCustomAction.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LexerIndexedCustomAction.cpp; sourceTree = ""; wrapsLines = 0; }; + 276E5C531CDB57AA003FF4B4 /* LexerIndexedCustomAction.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LexerIndexedCustomAction.h; sourceTree = ""; }; + 276E5C541CDB57AA003FF4B4 /* LexerModeAction.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LexerModeAction.cpp; sourceTree = ""; }; + 276E5C551CDB57AA003FF4B4 /* LexerModeAction.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LexerModeAction.h; sourceTree = ""; }; + 276E5C561CDB57AA003FF4B4 /* LexerMoreAction.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LexerMoreAction.cpp; sourceTree = ""; }; + 276E5C571CDB57AA003FF4B4 /* LexerMoreAction.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LexerMoreAction.h; sourceTree = ""; }; + 276E5C581CDB57AA003FF4B4 /* LexerPopModeAction.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LexerPopModeAction.cpp; sourceTree = ""; }; + 276E5C591CDB57AA003FF4B4 /* LexerPopModeAction.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LexerPopModeAction.h; sourceTree = ""; }; + 276E5C5A1CDB57AA003FF4B4 /* LexerPushModeAction.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LexerPushModeAction.cpp; sourceTree = ""; }; + 276E5C5B1CDB57AA003FF4B4 /* LexerPushModeAction.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LexerPushModeAction.h; sourceTree = ""; }; + 276E5C5C1CDB57AA003FF4B4 /* LexerSkipAction.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LexerSkipAction.cpp; sourceTree = ""; }; + 276E5C5D1CDB57AA003FF4B4 /* LexerSkipAction.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LexerSkipAction.h; sourceTree = ""; }; + 276E5C5E1CDB57AA003FF4B4 /* LexerTypeAction.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LexerTypeAction.cpp; sourceTree = ""; }; + 276E5C5F1CDB57AA003FF4B4 /* LexerTypeAction.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LexerTypeAction.h; sourceTree = ""; }; + 276E5C601CDB57AA003FF4B4 /* LL1Analyzer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LL1Analyzer.cpp; sourceTree = ""; wrapsLines = 0; }; + 276E5C611CDB57AA003FF4B4 /* LL1Analyzer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LL1Analyzer.h; sourceTree = ""; wrapsLines = 0; }; + 276E5C621CDB57AA003FF4B4 /* LookaheadEventInfo.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LookaheadEventInfo.cpp; sourceTree = ""; wrapsLines = 0; }; + 276E5C631CDB57AA003FF4B4 /* LookaheadEventInfo.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LookaheadEventInfo.h; sourceTree = ""; wrapsLines = 0; }; + 276E5C641CDB57AA003FF4B4 /* LoopEndState.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LoopEndState.cpp; sourceTree = ""; }; + 276E5C651CDB57AA003FF4B4 /* LoopEndState.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LoopEndState.h; sourceTree = ""; }; + 276E5C671CDB57AA003FF4B4 /* NotSetTransition.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = NotSetTransition.cpp; sourceTree = ""; wrapsLines = 0; }; + 276E5C681CDB57AA003FF4B4 /* NotSetTransition.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = NotSetTransition.h; sourceTree = ""; }; + 276E5C691CDB57AA003FF4B4 /* OrderedATNConfigSet.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = OrderedATNConfigSet.cpp; sourceTree = ""; wrapsLines = 0; }; + 276E5C6A1CDB57AA003FF4B4 /* OrderedATNConfigSet.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = OrderedATNConfigSet.h; sourceTree = ""; }; + 276E5C6B1CDB57AA003FF4B4 /* ParseInfo.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ParseInfo.cpp; sourceTree = ""; }; + 276E5C6C1CDB57AA003FF4B4 /* ParseInfo.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ParseInfo.h; sourceTree = ""; }; + 276E5C6D1CDB57AA003FF4B4 /* ParserATNSimulator.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ParserATNSimulator.cpp; sourceTree = ""; wrapsLines = 0; }; + 276E5C6E1CDB57AA003FF4B4 /* ParserATNSimulator.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ParserATNSimulator.h; sourceTree = ""; wrapsLines = 0; }; + 276E5C6F1CDB57AA003FF4B4 /* PlusBlockStartState.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = PlusBlockStartState.cpp; sourceTree = ""; }; + 276E5C701CDB57AA003FF4B4 /* PlusBlockStartState.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = PlusBlockStartState.h; sourceTree = ""; }; + 276E5C711CDB57AA003FF4B4 /* PlusLoopbackState.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = PlusLoopbackState.cpp; sourceTree = ""; }; + 276E5C721CDB57AA003FF4B4 /* PlusLoopbackState.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = PlusLoopbackState.h; sourceTree = ""; }; + 276E5C731CDB57AA003FF4B4 /* PrecedencePredicateTransition.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = PrecedencePredicateTransition.cpp; sourceTree = ""; wrapsLines = 0; }; + 276E5C741CDB57AA003FF4B4 /* PrecedencePredicateTransition.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = PrecedencePredicateTransition.h; sourceTree = ""; }; + 276E5C751CDB57AA003FF4B4 /* PredicateEvalInfo.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = PredicateEvalInfo.cpp; sourceTree = ""; wrapsLines = 0; }; + 276E5C761CDB57AA003FF4B4 /* PredicateEvalInfo.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = PredicateEvalInfo.h; sourceTree = ""; wrapsLines = 0; }; + 276E5C771CDB57AA003FF4B4 /* PredicateTransition.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = PredicateTransition.cpp; sourceTree = ""; wrapsLines = 0; }; + 276E5C781CDB57AA003FF4B4 /* PredicateTransition.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = PredicateTransition.h; sourceTree = ""; wrapsLines = 0; }; + 276E5C791CDB57AA003FF4B4 /* PredictionContext.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = PredictionContext.cpp; sourceTree = ""; wrapsLines = 0; }; + 276E5C7A1CDB57AA003FF4B4 /* PredictionContext.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = PredictionContext.h; sourceTree = ""; wrapsLines = 0; }; + 276E5C7B1CDB57AA003FF4B4 /* PredictionMode.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = PredictionMode.cpp; sourceTree = ""; wrapsLines = 0; }; + 276E5C7C1CDB57AA003FF4B4 /* PredictionMode.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = PredictionMode.h; sourceTree = ""; wrapsLines = 0; }; + 276E5C7D1CDB57AA003FF4B4 /* ProfilingATNSimulator.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ProfilingATNSimulator.cpp; sourceTree = ""; wrapsLines = 0; }; + 276E5C7E1CDB57AA003FF4B4 /* ProfilingATNSimulator.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ProfilingATNSimulator.h; sourceTree = ""; wrapsLines = 0; }; + 276E5C7F1CDB57AA003FF4B4 /* RangeTransition.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = RangeTransition.cpp; sourceTree = ""; wrapsLines = 0; }; + 276E5C801CDB57AA003FF4B4 /* RangeTransition.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RangeTransition.h; sourceTree = ""; }; + 276E5C811CDB57AA003FF4B4 /* RuleStartState.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = RuleStartState.cpp; sourceTree = ""; }; + 276E5C821CDB57AA003FF4B4 /* RuleStartState.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RuleStartState.h; sourceTree = ""; }; + 276E5C831CDB57AA003FF4B4 /* RuleStopState.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = RuleStopState.cpp; sourceTree = ""; }; + 276E5C841CDB57AA003FF4B4 /* RuleStopState.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RuleStopState.h; sourceTree = ""; }; + 276E5C851CDB57AA003FF4B4 /* RuleTransition.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = RuleTransition.cpp; sourceTree = ""; }; + 276E5C861CDB57AA003FF4B4 /* RuleTransition.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RuleTransition.h; sourceTree = ""; }; + 276E5C871CDB57AA003FF4B4 /* SemanticContext.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = SemanticContext.cpp; sourceTree = ""; wrapsLines = 0; }; + 276E5C881CDB57AA003FF4B4 /* SemanticContext.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SemanticContext.h; sourceTree = ""; wrapsLines = 0; }; + 276E5C891CDB57AA003FF4B4 /* SetTransition.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = SetTransition.cpp; sourceTree = ""; }; + 276E5C8A1CDB57AA003FF4B4 /* SetTransition.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SetTransition.h; sourceTree = ""; }; + 276E5C8B1CDB57AA003FF4B4 /* SingletonPredictionContext.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = SingletonPredictionContext.cpp; sourceTree = ""; wrapsLines = 0; }; + 276E5C8C1CDB57AA003FF4B4 /* SingletonPredictionContext.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SingletonPredictionContext.h; sourceTree = ""; wrapsLines = 0; }; + 276E5C8D1CDB57AA003FF4B4 /* StarBlockStartState.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = StarBlockStartState.cpp; sourceTree = ""; }; + 276E5C8E1CDB57AA003FF4B4 /* StarBlockStartState.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = StarBlockStartState.h; sourceTree = ""; }; + 276E5C8F1CDB57AA003FF4B4 /* StarLoopbackState.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = StarLoopbackState.cpp; sourceTree = ""; }; + 276E5C901CDB57AA003FF4B4 /* StarLoopbackState.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = StarLoopbackState.h; sourceTree = ""; }; + 276E5C911CDB57AA003FF4B4 /* StarLoopEntryState.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = StarLoopEntryState.cpp; sourceTree = ""; }; + 276E5C921CDB57AA003FF4B4 /* StarLoopEntryState.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = StarLoopEntryState.h; sourceTree = ""; }; + 276E5C931CDB57AA003FF4B4 /* TokensStartState.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = TokensStartState.cpp; sourceTree = ""; }; + 276E5C941CDB57AA003FF4B4 /* TokensStartState.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TokensStartState.h; sourceTree = ""; }; + 276E5C951CDB57AA003FF4B4 /* Transition.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Transition.cpp; sourceTree = ""; }; + 276E5C961CDB57AA003FF4B4 /* Transition.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Transition.h; sourceTree = ""; }; + 276E5C971CDB57AA003FF4B4 /* WildcardTransition.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WildcardTransition.cpp; sourceTree = ""; }; + 276E5C981CDB57AA003FF4B4 /* WildcardTransition.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WildcardTransition.h; sourceTree = ""; }; + 276E5C991CDB57AA003FF4B4 /* BailErrorStrategy.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = BailErrorStrategy.cpp; sourceTree = ""; }; + 276E5C9A1CDB57AA003FF4B4 /* BailErrorStrategy.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = BailErrorStrategy.h; sourceTree = ""; }; + 276E5C9B1CDB57AA003FF4B4 /* BaseErrorListener.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = BaseErrorListener.cpp; sourceTree = ""; wrapsLines = 0; }; + 276E5C9C1CDB57AA003FF4B4 /* BaseErrorListener.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = BaseErrorListener.h; sourceTree = ""; wrapsLines = 0; }; + 276E5C9D1CDB57AA003FF4B4 /* BufferedTokenStream.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; lineEnding = 0; path = BufferedTokenStream.cpp; sourceTree = ""; xcLanguageSpecificationIdentifier = xcode.lang.cpp; }; + 276E5C9E1CDB57AA003FF4B4 /* BufferedTokenStream.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; lineEnding = 0; path = BufferedTokenStream.h; sourceTree = ""; xcLanguageSpecificationIdentifier = xcode.lang.objcpp; }; + 276E5C9F1CDB57AA003FF4B4 /* CharStream.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = CharStream.cpp; sourceTree = ""; }; + 276E5CA01CDB57AA003FF4B4 /* CharStream.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CharStream.h; sourceTree = ""; }; + 276E5CA11CDB57AA003FF4B4 /* CommonToken.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = CommonToken.cpp; sourceTree = ""; wrapsLines = 0; }; + 276E5CA21CDB57AA003FF4B4 /* CommonToken.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CommonToken.h; sourceTree = ""; }; + 276E5CA31CDB57AA003FF4B4 /* CommonTokenFactory.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = CommonTokenFactory.cpp; sourceTree = ""; }; + 276E5CA41CDB57AA003FF4B4 /* CommonTokenFactory.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CommonTokenFactory.h; sourceTree = ""; }; + 276E5CA51CDB57AA003FF4B4 /* CommonTokenStream.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = CommonTokenStream.cpp; sourceTree = ""; }; + 276E5CA61CDB57AA003FF4B4 /* CommonTokenStream.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CommonTokenStream.h; sourceTree = ""; }; + 276E5CA71CDB57AA003FF4B4 /* ConsoleErrorListener.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ConsoleErrorListener.cpp; sourceTree = ""; wrapsLines = 0; }; + 276E5CA81CDB57AA003FF4B4 /* ConsoleErrorListener.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ConsoleErrorListener.h; sourceTree = ""; wrapsLines = 0; }; + 276E5CA91CDB57AA003FF4B4 /* DefaultErrorStrategy.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = DefaultErrorStrategy.cpp; sourceTree = ""; wrapsLines = 0; }; + 276E5CAA1CDB57AA003FF4B4 /* DefaultErrorStrategy.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DefaultErrorStrategy.h; sourceTree = ""; }; + 276E5CAC1CDB57AA003FF4B4 /* DFA.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = DFA.cpp; sourceTree = ""; wrapsLines = 0; }; + 276E5CAD1CDB57AA003FF4B4 /* DFA.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DFA.h; sourceTree = ""; wrapsLines = 0; }; + 276E5CAE1CDB57AA003FF4B4 /* DFASerializer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = DFASerializer.cpp; sourceTree = ""; wrapsLines = 0; }; + 276E5CAF1CDB57AA003FF4B4 /* DFASerializer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DFASerializer.h; sourceTree = ""; }; + 276E5CB01CDB57AA003FF4B4 /* DFAState.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = DFAState.cpp; sourceTree = ""; }; + 276E5CB11CDB57AA003FF4B4 /* DFAState.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DFAState.h; sourceTree = ""; }; + 276E5CB21CDB57AA003FF4B4 /* LexerDFASerializer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LexerDFASerializer.cpp; sourceTree = ""; }; + 276E5CB31CDB57AA003FF4B4 /* LexerDFASerializer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LexerDFASerializer.h; sourceTree = ""; }; + 276E5CB41CDB57AA003FF4B4 /* DiagnosticErrorListener.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = DiagnosticErrorListener.cpp; sourceTree = ""; wrapsLines = 0; }; + 276E5CB51CDB57AA003FF4B4 /* DiagnosticErrorListener.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DiagnosticErrorListener.h; sourceTree = ""; wrapsLines = 0; }; + 276E5CB61CDB57AA003FF4B4 /* Exceptions.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Exceptions.cpp; sourceTree = ""; wrapsLines = 0; }; + 276E5CB71CDB57AA003FF4B4 /* Exceptions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Exceptions.h; sourceTree = ""; }; + 276E5CB81CDB57AA003FF4B4 /* FailedPredicateException.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = FailedPredicateException.cpp; sourceTree = ""; wrapsLines = 0; }; + 276E5CB91CDB57AA003FF4B4 /* FailedPredicateException.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FailedPredicateException.h; sourceTree = ""; }; + 276E5CBA1CDB57AA003FF4B4 /* InputMismatchException.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = InputMismatchException.cpp; sourceTree = ""; }; + 276E5CBB1CDB57AA003FF4B4 /* InputMismatchException.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = InputMismatchException.h; sourceTree = ""; }; + 276E5CBC1CDB57AA003FF4B4 /* InterpreterRuleContext.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = InterpreterRuleContext.cpp; sourceTree = ""; wrapsLines = 0; }; + 276E5CBD1CDB57AA003FF4B4 /* InterpreterRuleContext.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = InterpreterRuleContext.h; sourceTree = ""; wrapsLines = 0; }; + 276E5CBE1CDB57AA003FF4B4 /* IntStream.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = IntStream.cpp; sourceTree = ""; }; + 276E5CBF1CDB57AA003FF4B4 /* IntStream.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = IntStream.h; sourceTree = ""; }; + 276E5CC11CDB57AA003FF4B4 /* Lexer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Lexer.cpp; sourceTree = ""; wrapsLines = 0; }; + 276E5CC21CDB57AA003FF4B4 /* Lexer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Lexer.h; sourceTree = ""; }; + 276E5CC31CDB57AA003FF4B4 /* LexerInterpreter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LexerInterpreter.cpp; sourceTree = ""; wrapsLines = 0; }; + 276E5CC41CDB57AA003FF4B4 /* LexerInterpreter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LexerInterpreter.h; sourceTree = ""; }; + 276E5CC51CDB57AA003FF4B4 /* LexerNoViableAltException.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LexerNoViableAltException.cpp; sourceTree = ""; }; + 276E5CC61CDB57AA003FF4B4 /* LexerNoViableAltException.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LexerNoViableAltException.h; sourceTree = ""; }; + 276E5CC71CDB57AA003FF4B4 /* ListTokenSource.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ListTokenSource.cpp; sourceTree = ""; wrapsLines = 0; }; + 276E5CC81CDB57AA003FF4B4 /* ListTokenSource.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ListTokenSource.h; sourceTree = ""; wrapsLines = 0; }; + 276E5CCA1CDB57AA003FF4B4 /* Interval.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Interval.cpp; sourceTree = ""; }; + 276E5CCB1CDB57AA003FF4B4 /* Interval.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Interval.h; sourceTree = ""; }; + 276E5CCC1CDB57AA003FF4B4 /* IntervalSet.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = IntervalSet.cpp; sourceTree = ""; wrapsLines = 0; }; + 276E5CCD1CDB57AA003FF4B4 /* IntervalSet.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = IntervalSet.h; sourceTree = ""; }; + 276E5CCE1CDB57AA003FF4B4 /* MurmurHash.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = MurmurHash.cpp; sourceTree = ""; }; + 276E5CCF1CDB57AA003FF4B4 /* MurmurHash.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MurmurHash.h; sourceTree = ""; }; + 276E5CD11CDB57AA003FF4B4 /* Predicate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Predicate.h; sourceTree = ""; }; + 276E5CD41CDB57AA003FF4B4 /* NoViableAltException.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = NoViableAltException.cpp; sourceTree = ""; wrapsLines = 0; }; + 276E5CD51CDB57AA003FF4B4 /* NoViableAltException.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = NoViableAltException.h; sourceTree = ""; wrapsLines = 0; }; + 276E5CD61CDB57AA003FF4B4 /* Parser.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Parser.cpp; sourceTree = ""; wrapsLines = 0; }; + 276E5CD71CDB57AA003FF4B4 /* Parser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Parser.h; sourceTree = ""; }; + 276E5CD81CDB57AA003FF4B4 /* ParserInterpreter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ParserInterpreter.cpp; sourceTree = ""; wrapsLines = 0; }; + 276E5CD91CDB57AA003FF4B4 /* ParserInterpreter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ParserInterpreter.h; sourceTree = ""; wrapsLines = 0; }; + 276E5CDA1CDB57AA003FF4B4 /* ParserRuleContext.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ParserRuleContext.cpp; sourceTree = ""; wrapsLines = 0; }; + 276E5CDB1CDB57AA003FF4B4 /* ParserRuleContext.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ParserRuleContext.h; sourceTree = ""; wrapsLines = 0; }; + 276E5CDC1CDB57AA003FF4B4 /* ProxyErrorListener.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ProxyErrorListener.cpp; sourceTree = ""; wrapsLines = 0; }; + 276E5CDD1CDB57AA003FF4B4 /* ProxyErrorListener.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ProxyErrorListener.h; sourceTree = ""; wrapsLines = 0; }; + 276E5CDE1CDB57AA003FF4B4 /* RecognitionException.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = RecognitionException.cpp; sourceTree = ""; wrapsLines = 0; }; + 276E5CDF1CDB57AA003FF4B4 /* RecognitionException.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RecognitionException.h; sourceTree = ""; wrapsLines = 0; }; + 276E5CE01CDB57AA003FF4B4 /* Recognizer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Recognizer.cpp; sourceTree = ""; }; + 276E5CE11CDB57AA003FF4B4 /* Recognizer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Recognizer.h; sourceTree = ""; }; + 276E5CE21CDB57AA003FF4B4 /* RuleContext.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = RuleContext.cpp; sourceTree = ""; wrapsLines = 0; }; + 276E5CE31CDB57AA003FF4B4 /* RuleContext.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RuleContext.h; sourceTree = ""; }; + 276E5CE51CDB57AA003FF4B4 /* Arrays.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Arrays.cpp; sourceTree = ""; }; + 276E5CE61CDB57AA003FF4B4 /* Arrays.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Arrays.h; sourceTree = ""; }; + 276E5CE71CDB57AA003FF4B4 /* BitSet.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = BitSet.h; sourceTree = ""; }; + 276E5CE81CDB57AA003FF4B4 /* CPPUtils.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = CPPUtils.cpp; sourceTree = ""; wrapsLines = 0; }; + 276E5CE91CDB57AA003FF4B4 /* CPPUtils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; lineEnding = 0; path = CPPUtils.h; sourceTree = ""; xcLanguageSpecificationIdentifier = xcode.lang.objcpp; }; + 276E5CEA1CDB57AA003FF4B4 /* Declarations.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Declarations.h; sourceTree = ""; }; + 276E5CEB1CDB57AA003FF4B4 /* guid.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = guid.cpp; sourceTree = ""; }; + 276E5CEC1CDB57AA003FF4B4 /* guid.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = guid.h; sourceTree = ""; }; + 276E5CED1CDB57AA003FF4B4 /* StringUtils.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = StringUtils.cpp; sourceTree = ""; }; + 276E5CEE1CDB57AA003FF4B4 /* StringUtils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = StringUtils.h; sourceTree = ""; }; + 276E5CF01CDB57AA003FF4B4 /* Token.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Token.h; sourceTree = ""; }; + 276E5CF21CDB57AA003FF4B4 /* TokenFactory.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TokenFactory.h; sourceTree = ""; }; + 276E5CF41CDB57AA003FF4B4 /* TokenSource.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TokenSource.h; sourceTree = ""; }; + 276E5CF51CDB57AA003FF4B4 /* TokenStream.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = TokenStream.cpp; sourceTree = ""; }; + 276E5CF61CDB57AA003FF4B4 /* TokenStream.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TokenStream.h; sourceTree = ""; }; + 276E5CF71CDB57AA003FF4B4 /* TokenStreamRewriter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = TokenStreamRewriter.cpp; sourceTree = ""; wrapsLines = 0; }; + 276E5CF81CDB57AA003FF4B4 /* TokenStreamRewriter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TokenStreamRewriter.h; sourceTree = ""; wrapsLines = 0; }; + 276E5CFA1CDB57AA003FF4B4 /* AbstractParseTreeVisitor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = AbstractParseTreeVisitor.h; sourceTree = ""; }; + 276E5CFB1CDB57AA003FF4B4 /* ErrorNode.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ErrorNode.h; sourceTree = ""; }; + 276E5CFC1CDB57AA003FF4B4 /* ErrorNodeImpl.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ErrorNodeImpl.cpp; sourceTree = ""; }; + 276E5CFD1CDB57AA003FF4B4 /* ErrorNodeImpl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ErrorNodeImpl.h; sourceTree = ""; }; + 276E5CFE1CDB57AA003FF4B4 /* ParseTree.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ParseTree.h; sourceTree = ""; wrapsLines = 0; }; + 276E5D001CDB57AA003FF4B4 /* ParseTreeListener.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ParseTreeListener.h; sourceTree = ""; }; + 276E5D021CDB57AA003FF4B4 /* ParseTreeProperty.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ParseTreeProperty.h; sourceTree = ""; }; + 276E5D031CDB57AA003FF4B4 /* ParseTreeVisitor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ParseTreeVisitor.h; sourceTree = ""; wrapsLines = 0; }; + 276E5D041CDB57AA003FF4B4 /* ParseTreeWalker.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ParseTreeWalker.cpp; sourceTree = ""; }; + 276E5D051CDB57AA003FF4B4 /* ParseTreeWalker.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ParseTreeWalker.h; sourceTree = ""; }; + 276E5D071CDB57AA003FF4B4 /* Chunk.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Chunk.h; sourceTree = ""; }; + 276E5D081CDB57AA003FF4B4 /* ParseTreeMatch.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ParseTreeMatch.cpp; sourceTree = ""; }; + 276E5D091CDB57AA003FF4B4 /* ParseTreeMatch.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ParseTreeMatch.h; sourceTree = ""; wrapsLines = 0; }; + 276E5D0A1CDB57AA003FF4B4 /* ParseTreePattern.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ParseTreePattern.cpp; sourceTree = ""; wrapsLines = 0; }; + 276E5D0B1CDB57AA003FF4B4 /* ParseTreePattern.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ParseTreePattern.h; sourceTree = ""; wrapsLines = 0; }; + 276E5D0C1CDB57AA003FF4B4 /* ParseTreePatternMatcher.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ParseTreePatternMatcher.cpp; sourceTree = ""; wrapsLines = 0; }; + 276E5D0D1CDB57AA003FF4B4 /* ParseTreePatternMatcher.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ParseTreePatternMatcher.h; sourceTree = ""; wrapsLines = 0; }; + 276E5D0E1CDB57AA003FF4B4 /* RuleTagToken.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = RuleTagToken.cpp; sourceTree = ""; wrapsLines = 0; }; + 276E5D0F1CDB57AA003FF4B4 /* RuleTagToken.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RuleTagToken.h; sourceTree = ""; }; + 276E5D101CDB57AA003FF4B4 /* TagChunk.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = TagChunk.cpp; sourceTree = ""; }; + 276E5D111CDB57AA003FF4B4 /* TagChunk.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TagChunk.h; sourceTree = ""; }; + 276E5D121CDB57AA003FF4B4 /* TextChunk.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = TextChunk.cpp; sourceTree = ""; }; + 276E5D131CDB57AA003FF4B4 /* TextChunk.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TextChunk.h; sourceTree = ""; }; + 276E5D141CDB57AA003FF4B4 /* TokenTagToken.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = TokenTagToken.cpp; sourceTree = ""; wrapsLines = 0; }; + 276E5D151CDB57AA003FF4B4 /* TokenTagToken.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TokenTagToken.h; sourceTree = ""; }; + 276E5D181CDB57AA003FF4B4 /* TerminalNode.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TerminalNode.h; sourceTree = ""; }; + 276E5D191CDB57AA003FF4B4 /* TerminalNodeImpl.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = TerminalNodeImpl.cpp; sourceTree = ""; }; + 276E5D1A1CDB57AA003FF4B4 /* TerminalNodeImpl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TerminalNodeImpl.h; sourceTree = ""; }; + 276E5D1D1CDB57AA003FF4B4 /* Trees.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Trees.cpp; sourceTree = ""; wrapsLines = 0; }; + 276E5D1E1CDB57AA003FF4B4 /* Trees.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Trees.h; sourceTree = ""; wrapsLines = 0; }; + 276E5D221CDB57AA003FF4B4 /* UnbufferedCharStream.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = UnbufferedCharStream.cpp; sourceTree = ""; wrapsLines = 0; }; + 276E5D231CDB57AA003FF4B4 /* UnbufferedCharStream.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = UnbufferedCharStream.h; sourceTree = ""; }; + 276E5D241CDB57AA003FF4B4 /* UnbufferedTokenStream.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = UnbufferedTokenStream.cpp; sourceTree = ""; wrapsLines = 0; }; + 276E5D251CDB57AA003FF4B4 /* UnbufferedTokenStream.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = UnbufferedTokenStream.h; sourceTree = ""; }; + 276E5D271CDB57AA003FF4B4 /* Vocabulary.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Vocabulary.cpp; sourceTree = ""; wrapsLines = 0; }; + 276E5D281CDB57AA003FF4B4 /* Vocabulary.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Vocabulary.h; sourceTree = ""; }; + 276E5D2A1CDB57AA003FF4B4 /* WritableToken.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WritableToken.h; sourceTree = ""; }; + 27745EFB1CE49C000067C6A3 /* RuntimeMetaData.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = RuntimeMetaData.cpp; sourceTree = ""; wrapsLines = 0; }; + 27745EFC1CE49C000067C6A3 /* RuntimeMetaData.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RuntimeMetaData.h; sourceTree = ""; }; + 27874F1D1CCB7A0700AF1C53 /* CoreFoundation.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreFoundation.framework; path = System/Library/Frameworks/CoreFoundation.framework; sourceTree = SDKROOT; }; + 2793DC841F08083F00A84290 /* TokenSource.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = TokenSource.cpp; sourceTree = ""; }; + 2793DC881F08087500A84290 /* Chunk.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Chunk.cpp; sourceTree = ""; }; + 2793DC8C1F08088F00A84290 /* ParseTreeListener.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ParseTreeListener.cpp; sourceTree = ""; }; + 2793DC901F0808A200A84290 /* TerminalNode.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = TerminalNode.cpp; sourceTree = ""; }; + 2793DC941F0808E100A84290 /* ErrorNode.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ErrorNode.cpp; sourceTree = ""; }; + 2793DC951F0808E100A84290 /* ParseTreeVisitor.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ParseTreeVisitor.cpp; sourceTree = ""; }; + 2793DC9C1F08090D00A84290 /* Any.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Any.cpp; sourceTree = ""; }; + 2793DCA01F08095F00A84290 /* ANTLRErrorListener.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ANTLRErrorListener.cpp; sourceTree = ""; }; + 2793DCA11F08095F00A84290 /* ANTLRErrorStrategy.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ANTLRErrorStrategy.cpp; sourceTree = ""; }; + 2793DCA21F08095F00A84290 /* Token.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Token.cpp; sourceTree = ""; }; + 2793DCA31F08095F00A84290 /* WritableToken.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WritableToken.cpp; sourceTree = ""; }; + 2793DCB01F08099C00A84290 /* BlockStartState.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = BlockStartState.cpp; sourceTree = ""; }; + 2793DCB11F08099C00A84290 /* LexerAction.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LexerAction.cpp; sourceTree = ""; }; + 2794D8551CE7821B00FADD0F /* antlr4-common.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "antlr4-common.h"; sourceTree = ""; }; + 27AC52CF1CE773A80093AAAB /* antlr4-runtime.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "antlr4-runtime.h"; sourceTree = ""; }; + 27B36AC41DACE7AF0069C868 /* RuleContextWithAltNum.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = RuleContextWithAltNum.cpp; sourceTree = ""; }; + 27B36AC51DACE7AF0069C868 /* RuleContextWithAltNum.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RuleContextWithAltNum.h; sourceTree = ""; }; + 27C375821EA1059C00B5883C /* InterpreterDataReader.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = InterpreterDataReader.cpp; sourceTree = ""; }; + 27C375831EA1059C00B5883C /* InterpreterDataReader.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = InterpreterDataReader.h; sourceTree = ""; }; + 27D414501DEB0D3D00D0F3F9 /* IterativeParseTreeWalker.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = IterativeParseTreeWalker.cpp; sourceTree = ""; }; + 27D414511DEB0D3D00D0F3F9 /* IterativeParseTreeWalker.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = IterativeParseTreeWalker.h; sourceTree = ""; }; + 27DB448B1D045537007E790B /* XPath.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = XPath.cpp; sourceTree = ""; wrapsLines = 0; }; + 27DB448C1D045537007E790B /* XPath.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XPath.h; sourceTree = ""; wrapsLines = 0; }; + 27DB448D1D045537007E790B /* XPathElement.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = XPathElement.cpp; sourceTree = ""; wrapsLines = 0; }; + 27DB448E1D045537007E790B /* XPathElement.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XPathElement.h; sourceTree = ""; wrapsLines = 0; }; + 27DB448F1D045537007E790B /* XPathLexerErrorListener.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = XPathLexerErrorListener.cpp; sourceTree = ""; wrapsLines = 0; }; + 27DB44901D045537007E790B /* XPathLexerErrorListener.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XPathLexerErrorListener.h; sourceTree = ""; wrapsLines = 0; }; + 27DB44911D045537007E790B /* XPathRuleAnywhereElement.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = XPathRuleAnywhereElement.cpp; sourceTree = ""; wrapsLines = 0; }; + 27DB44921D045537007E790B /* XPathRuleAnywhereElement.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XPathRuleAnywhereElement.h; sourceTree = ""; wrapsLines = 0; }; + 27DB44931D045537007E790B /* XPathRuleElement.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = XPathRuleElement.cpp; sourceTree = ""; wrapsLines = 0; }; + 27DB44941D045537007E790B /* XPathRuleElement.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XPathRuleElement.h; sourceTree = ""; wrapsLines = 0; }; + 27DB44951D045537007E790B /* XPathTokenAnywhereElement.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = XPathTokenAnywhereElement.cpp; sourceTree = ""; wrapsLines = 0; }; + 27DB44961D045537007E790B /* XPathTokenAnywhereElement.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XPathTokenAnywhereElement.h; sourceTree = ""; wrapsLines = 0; }; + 27DB44971D045537007E790B /* XPathTokenElement.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = XPathTokenElement.cpp; sourceTree = ""; wrapsLines = 0; }; + 27DB44981D045537007E790B /* XPathTokenElement.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XPathTokenElement.h; sourceTree = ""; wrapsLines = 0; }; + 27DB44991D045537007E790B /* XPathWildcardAnywhereElement.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = XPathWildcardAnywhereElement.cpp; sourceTree = ""; wrapsLines = 0; }; + 27DB449A1D045537007E790B /* XPathWildcardAnywhereElement.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XPathWildcardAnywhereElement.h; sourceTree = ""; wrapsLines = 0; }; + 27DB449B1D045537007E790B /* XPathWildcardElement.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = XPathWildcardElement.cpp; sourceTree = ""; wrapsLines = 0; }; + 27DB449C1D045537007E790B /* XPathWildcardElement.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XPathWildcardElement.h; sourceTree = ""; wrapsLines = 0; }; + 27DB44AF1D0463CC007E790B /* XPathLexer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = XPathLexer.cpp; sourceTree = ""; }; + 27DB44B01D0463CC007E790B /* XPathLexer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XPathLexer.h; sourceTree = ""; wrapsLines = 0; }; + 27F4A8551D4CEB2A00E067EE /* Any.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Any.h; sourceTree = ""; }; + 37C147171B4D5A04008EDDDB /* libantlr4-runtime.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = "libantlr4-runtime.a"; sourceTree = BUILT_PRODUCTS_DIR; }; + 37D727AA1867AF1E007B6D10 /* libantlr4-runtime.dylib */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.dylib"; includeInIndex = 0; path = "libantlr4-runtime.dylib"; sourceTree = BUILT_PRODUCTS_DIR; }; +/* End PBXFileReference section */ + +/* Begin PBXFrameworksBuildPhase section */ + 270C67EC1CDB4F1E00116E17 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + 270C69E01CDB536A00116E17 /* CoreFoundation.framework in Frameworks */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 37C147141B4D5A04008EDDDB /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + 27874F1E1CCB7A0700AF1C53 /* CoreFoundation.framework in Frameworks */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 37D727A71867AF1E007B6D10 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + 27874F211CCB7B1700AF1C53 /* CoreFoundation.framework in Frameworks */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXFrameworksBuildPhase section */ + +/* Begin PBXGroup section */ + 270C67F11CDB4F1E00116E17 /* antlrcpp-ios */ = { + isa = PBXGroup; + children = ( + 270C67F21CDB4F1E00116E17 /* antlrcpp_ios.h */, + 270C67F41CDB4F1E00116E17 /* Info.plist */, + ); + path = "antlrcpp-ios"; + sourceTree = ""; + }; + 276E5C0A1CDB57AA003FF4B4 /* runtime */ = { + isa = PBXGroup; + children = ( + 276E5C121CDB57AA003FF4B4 /* atn */, + 276E5CAB1CDB57AA003FF4B4 /* dfa */, + 276E5CC91CDB57AA003FF4B4 /* misc */, + 276E5CE41CDB57AA003FF4B4 /* support */, + 276E5CF91CDB57AA003FF4B4 /* tree */, + 2794D8551CE7821B00FADD0F /* antlr4-common.h */, + 27AC52CF1CE773A80093AAAB /* antlr4-runtime.h */, + 2793DCA01F08095F00A84290 /* ANTLRErrorListener.cpp */, + 276E5C0C1CDB57AA003FF4B4 /* ANTLRErrorListener.h */, + 2793DCA11F08095F00A84290 /* ANTLRErrorStrategy.cpp */, + 276E5C0D1CDB57AA003FF4B4 /* ANTLRErrorStrategy.h */, + 276E5C0E1CDB57AA003FF4B4 /* ANTLRFileStream.cpp */, + 276E5C0F1CDB57AA003FF4B4 /* ANTLRFileStream.h */, + 276E5C101CDB57AA003FF4B4 /* ANTLRInputStream.cpp */, + 276E5C111CDB57AA003FF4B4 /* ANTLRInputStream.h */, + 276E5C991CDB57AA003FF4B4 /* BailErrorStrategy.cpp */, + 276E5C9A1CDB57AA003FF4B4 /* BailErrorStrategy.h */, + 276E5C9B1CDB57AA003FF4B4 /* BaseErrorListener.cpp */, + 276E5C9C1CDB57AA003FF4B4 /* BaseErrorListener.h */, + 276E5C9D1CDB57AA003FF4B4 /* BufferedTokenStream.cpp */, + 276E5C9E1CDB57AA003FF4B4 /* BufferedTokenStream.h */, + 276E5C9F1CDB57AA003FF4B4 /* CharStream.cpp */, + 276E5CA01CDB57AA003FF4B4 /* CharStream.h */, + 276E5CA11CDB57AA003FF4B4 /* CommonToken.cpp */, + 276E5CA21CDB57AA003FF4B4 /* CommonToken.h */, + 276E5CA31CDB57AA003FF4B4 /* CommonTokenFactory.cpp */, + 276E5CA41CDB57AA003FF4B4 /* CommonTokenFactory.h */, + 276E5CA51CDB57AA003FF4B4 /* CommonTokenStream.cpp */, + 276E5CA61CDB57AA003FF4B4 /* CommonTokenStream.h */, + 276E5CA71CDB57AA003FF4B4 /* ConsoleErrorListener.cpp */, + 276E5CA81CDB57AA003FF4B4 /* ConsoleErrorListener.h */, + 276E5CA91CDB57AA003FF4B4 /* DefaultErrorStrategy.cpp */, + 276E5CAA1CDB57AA003FF4B4 /* DefaultErrorStrategy.h */, + 276E5CB41CDB57AA003FF4B4 /* DiagnosticErrorListener.cpp */, + 276E5CB51CDB57AA003FF4B4 /* DiagnosticErrorListener.h */, + 276E5CB61CDB57AA003FF4B4 /* Exceptions.cpp */, + 276E5CB71CDB57AA003FF4B4 /* Exceptions.h */, + 276E5CB81CDB57AA003FF4B4 /* FailedPredicateException.cpp */, + 276E5CB91CDB57AA003FF4B4 /* FailedPredicateException.h */, + 276E5CBA1CDB57AA003FF4B4 /* InputMismatchException.cpp */, + 276E5CBB1CDB57AA003FF4B4 /* InputMismatchException.h */, + 276E5CBC1CDB57AA003FF4B4 /* InterpreterRuleContext.cpp */, + 276E5CBD1CDB57AA003FF4B4 /* InterpreterRuleContext.h */, + 276E5CBE1CDB57AA003FF4B4 /* IntStream.cpp */, + 276E5CBF1CDB57AA003FF4B4 /* IntStream.h */, + 276E5CC11CDB57AA003FF4B4 /* Lexer.cpp */, + 276E5CC21CDB57AA003FF4B4 /* Lexer.h */, + 276E5CC31CDB57AA003FF4B4 /* LexerInterpreter.cpp */, + 276E5CC41CDB57AA003FF4B4 /* LexerInterpreter.h */, + 276E5CC51CDB57AA003FF4B4 /* LexerNoViableAltException.cpp */, + 276E5CC61CDB57AA003FF4B4 /* LexerNoViableAltException.h */, + 276E5CC71CDB57AA003FF4B4 /* ListTokenSource.cpp */, + 276E5CC81CDB57AA003FF4B4 /* ListTokenSource.h */, + 276E5CD41CDB57AA003FF4B4 /* NoViableAltException.cpp */, + 276E5CD51CDB57AA003FF4B4 /* NoViableAltException.h */, + 276E5CD61CDB57AA003FF4B4 /* Parser.cpp */, + 276E5CD71CDB57AA003FF4B4 /* Parser.h */, + 276E5CD81CDB57AA003FF4B4 /* ParserInterpreter.cpp */, + 276E5CD91CDB57AA003FF4B4 /* ParserInterpreter.h */, + 276E5CDA1CDB57AA003FF4B4 /* ParserRuleContext.cpp */, + 276E5CDB1CDB57AA003FF4B4 /* ParserRuleContext.h */, + 276E5CDC1CDB57AA003FF4B4 /* ProxyErrorListener.cpp */, + 276E5CDD1CDB57AA003FF4B4 /* ProxyErrorListener.h */, + 276E5CDE1CDB57AA003FF4B4 /* RecognitionException.cpp */, + 276E5CDF1CDB57AA003FF4B4 /* RecognitionException.h */, + 276E5CE01CDB57AA003FF4B4 /* Recognizer.cpp */, + 276E5CE11CDB57AA003FF4B4 /* Recognizer.h */, + 276E5CE21CDB57AA003FF4B4 /* RuleContext.cpp */, + 276E5CE31CDB57AA003FF4B4 /* RuleContext.h */, + 27B36AC41DACE7AF0069C868 /* RuleContextWithAltNum.cpp */, + 27B36AC51DACE7AF0069C868 /* RuleContextWithAltNum.h */, + 27745EFB1CE49C000067C6A3 /* RuntimeMetaData.cpp */, + 27745EFC1CE49C000067C6A3 /* RuntimeMetaData.h */, + 2793DCA21F08095F00A84290 /* Token.cpp */, + 276E5CF01CDB57AA003FF4B4 /* Token.h */, + 276E5CF21CDB57AA003FF4B4 /* TokenFactory.h */, + 2793DC841F08083F00A84290 /* TokenSource.cpp */, + 276E5CF41CDB57AA003FF4B4 /* TokenSource.h */, + 276E5CF51CDB57AA003FF4B4 /* TokenStream.cpp */, + 276E5CF61CDB57AA003FF4B4 /* TokenStream.h */, + 276E5CF71CDB57AA003FF4B4 /* TokenStreamRewriter.cpp */, + 276E5CF81CDB57AA003FF4B4 /* TokenStreamRewriter.h */, + 276E5D221CDB57AA003FF4B4 /* UnbufferedCharStream.cpp */, + 276E5D231CDB57AA003FF4B4 /* UnbufferedCharStream.h */, + 276E5D241CDB57AA003FF4B4 /* UnbufferedTokenStream.cpp */, + 276E5D251CDB57AA003FF4B4 /* UnbufferedTokenStream.h */, + 276E5D271CDB57AA003FF4B4 /* Vocabulary.cpp */, + 276E5D281CDB57AA003FF4B4 /* Vocabulary.h */, + 2793DCA31F08095F00A84290 /* WritableToken.cpp */, + 276E5D2A1CDB57AA003FF4B4 /* WritableToken.h */, + ); + name = runtime; + path = src; + sourceTree = ""; + }; + 276E5C121CDB57AA003FF4B4 /* atn */ = { + isa = PBXGroup; + children = ( + 276E5C131CDB57AA003FF4B4 /* AbstractPredicateTransition.cpp */, + 276E5C141CDB57AA003FF4B4 /* AbstractPredicateTransition.h */, + 276E5C151CDB57AA003FF4B4 /* ActionTransition.cpp */, + 276E5C161CDB57AA003FF4B4 /* ActionTransition.h */, + 276E5C171CDB57AA003FF4B4 /* AmbiguityInfo.cpp */, + 276E5C181CDB57AA003FF4B4 /* AmbiguityInfo.h */, + 276E5C191CDB57AA003FF4B4 /* ArrayPredictionContext.cpp */, + 276E5C1A1CDB57AA003FF4B4 /* ArrayPredictionContext.h */, + 276E5C1B1CDB57AA003FF4B4 /* ATN.cpp */, + 276E5C1C1CDB57AA003FF4B4 /* ATN.h */, + 276E5C1D1CDB57AA003FF4B4 /* ATNConfig.cpp */, + 276E5C1E1CDB57AA003FF4B4 /* ATNConfig.h */, + 276E5C1F1CDB57AA003FF4B4 /* ATNConfigSet.cpp */, + 276E5C201CDB57AA003FF4B4 /* ATNConfigSet.h */, + 276E5C211CDB57AA003FF4B4 /* ATNDeserializationOptions.cpp */, + 276E5C221CDB57AA003FF4B4 /* ATNDeserializationOptions.h */, + 276E5C231CDB57AA003FF4B4 /* ATNDeserializer.cpp */, + 276E5C241CDB57AA003FF4B4 /* ATNDeserializer.h */, + 276E5C251CDB57AA003FF4B4 /* ATNSerializer.cpp */, + 276E5C261CDB57AA003FF4B4 /* ATNSerializer.h */, + 276E5C271CDB57AA003FF4B4 /* ATNSimulator.cpp */, + 276E5C281CDB57AA003FF4B4 /* ATNSimulator.h */, + 276E5C291CDB57AA003FF4B4 /* ATNState.cpp */, + 276E5C2A1CDB57AA003FF4B4 /* ATNState.h */, + 276E5C2C1CDB57AA003FF4B4 /* ATNType.h */, + 276E5C2D1CDB57AA003FF4B4 /* AtomTransition.cpp */, + 276E5C2E1CDB57AA003FF4B4 /* AtomTransition.h */, + 276E5C2F1CDB57AA003FF4B4 /* BasicBlockStartState.cpp */, + 276E5C301CDB57AA003FF4B4 /* BasicBlockStartState.h */, + 276E5C311CDB57AA003FF4B4 /* BasicState.cpp */, + 276E5C321CDB57AA003FF4B4 /* BasicState.h */, + 276E5C331CDB57AA003FF4B4 /* BlockEndState.cpp */, + 276E5C341CDB57AA003FF4B4 /* BlockEndState.h */, + 2793DCB01F08099C00A84290 /* BlockStartState.cpp */, + 276E5C351CDB57AA003FF4B4 /* BlockStartState.h */, + 276E5C371CDB57AA003FF4B4 /* ContextSensitivityInfo.cpp */, + 276E5C381CDB57AA003FF4B4 /* ContextSensitivityInfo.h */, + 276E5C391CDB57AA003FF4B4 /* DecisionEventInfo.cpp */, + 276E5C3A1CDB57AA003FF4B4 /* DecisionEventInfo.h */, + 276E5C3B1CDB57AA003FF4B4 /* DecisionInfo.cpp */, + 276E5C3C1CDB57AA003FF4B4 /* DecisionInfo.h */, + 276E5C3D1CDB57AA003FF4B4 /* DecisionState.cpp */, + 276E5C3E1CDB57AA003FF4B4 /* DecisionState.h */, + 276E5C3F1CDB57AA003FF4B4 /* EmptyPredictionContext.cpp */, + 276E5C401CDB57AA003FF4B4 /* EmptyPredictionContext.h */, + 276E5C411CDB57AA003FF4B4 /* EpsilonTransition.cpp */, + 276E5C421CDB57AA003FF4B4 /* EpsilonTransition.h */, + 276E5C431CDB57AA003FF4B4 /* ErrorInfo.cpp */, + 276E5C441CDB57AA003FF4B4 /* ErrorInfo.h */, + 2793DCB11F08099C00A84290 /* LexerAction.cpp */, + 276E5C451CDB57AA003FF4B4 /* LexerAction.h */, + 276E5C461CDB57AA003FF4B4 /* LexerActionExecutor.cpp */, + 276E5C471CDB57AA003FF4B4 /* LexerActionExecutor.h */, + 276E5C491CDB57AA003FF4B4 /* LexerActionType.h */, + 276E5C4A1CDB57AA003FF4B4 /* LexerATNConfig.cpp */, + 276E5C4B1CDB57AA003FF4B4 /* LexerATNConfig.h */, + 276E5C4C1CDB57AA003FF4B4 /* LexerATNSimulator.cpp */, + 276E5C4D1CDB57AA003FF4B4 /* LexerATNSimulator.h */, + 276E5C4E1CDB57AA003FF4B4 /* LexerChannelAction.cpp */, + 276E5C4F1CDB57AA003FF4B4 /* LexerChannelAction.h */, + 276E5C501CDB57AA003FF4B4 /* LexerCustomAction.cpp */, + 276E5C511CDB57AA003FF4B4 /* LexerCustomAction.h */, + 276E5C521CDB57AA003FF4B4 /* LexerIndexedCustomAction.cpp */, + 276E5C531CDB57AA003FF4B4 /* LexerIndexedCustomAction.h */, + 276E5C541CDB57AA003FF4B4 /* LexerModeAction.cpp */, + 276E5C551CDB57AA003FF4B4 /* LexerModeAction.h */, + 276E5C561CDB57AA003FF4B4 /* LexerMoreAction.cpp */, + 276E5C571CDB57AA003FF4B4 /* LexerMoreAction.h */, + 276E5C581CDB57AA003FF4B4 /* LexerPopModeAction.cpp */, + 276E5C591CDB57AA003FF4B4 /* LexerPopModeAction.h */, + 276E5C5A1CDB57AA003FF4B4 /* LexerPushModeAction.cpp */, + 276E5C5B1CDB57AA003FF4B4 /* LexerPushModeAction.h */, + 276E5C5C1CDB57AA003FF4B4 /* LexerSkipAction.cpp */, + 276E5C5D1CDB57AA003FF4B4 /* LexerSkipAction.h */, + 276E5C5E1CDB57AA003FF4B4 /* LexerTypeAction.cpp */, + 276E5C5F1CDB57AA003FF4B4 /* LexerTypeAction.h */, + 276E5C601CDB57AA003FF4B4 /* LL1Analyzer.cpp */, + 276E5C611CDB57AA003FF4B4 /* LL1Analyzer.h */, + 276E5C621CDB57AA003FF4B4 /* LookaheadEventInfo.cpp */, + 276E5C631CDB57AA003FF4B4 /* LookaheadEventInfo.h */, + 276E5C641CDB57AA003FF4B4 /* LoopEndState.cpp */, + 276E5C651CDB57AA003FF4B4 /* LoopEndState.h */, + 276E5C671CDB57AA003FF4B4 /* NotSetTransition.cpp */, + 276E5C681CDB57AA003FF4B4 /* NotSetTransition.h */, + 276E5C691CDB57AA003FF4B4 /* OrderedATNConfigSet.cpp */, + 276E5C6A1CDB57AA003FF4B4 /* OrderedATNConfigSet.h */, + 276E5C6B1CDB57AA003FF4B4 /* ParseInfo.cpp */, + 276E5C6C1CDB57AA003FF4B4 /* ParseInfo.h */, + 276E5C6D1CDB57AA003FF4B4 /* ParserATNSimulator.cpp */, + 276E5C6E1CDB57AA003FF4B4 /* ParserATNSimulator.h */, + 276E5C6F1CDB57AA003FF4B4 /* PlusBlockStartState.cpp */, + 276E5C701CDB57AA003FF4B4 /* PlusBlockStartState.h */, + 276E5C711CDB57AA003FF4B4 /* PlusLoopbackState.cpp */, + 276E5C721CDB57AA003FF4B4 /* PlusLoopbackState.h */, + 276E5C731CDB57AA003FF4B4 /* PrecedencePredicateTransition.cpp */, + 276E5C741CDB57AA003FF4B4 /* PrecedencePredicateTransition.h */, + 276E5C751CDB57AA003FF4B4 /* PredicateEvalInfo.cpp */, + 276E5C761CDB57AA003FF4B4 /* PredicateEvalInfo.h */, + 276E5C771CDB57AA003FF4B4 /* PredicateTransition.cpp */, + 276E5C781CDB57AA003FF4B4 /* PredicateTransition.h */, + 276E5C791CDB57AA003FF4B4 /* PredictionContext.cpp */, + 276E5C7A1CDB57AA003FF4B4 /* PredictionContext.h */, + 276E5C7B1CDB57AA003FF4B4 /* PredictionMode.cpp */, + 276E5C7C1CDB57AA003FF4B4 /* PredictionMode.h */, + 276E5C7D1CDB57AA003FF4B4 /* ProfilingATNSimulator.cpp */, + 276E5C7E1CDB57AA003FF4B4 /* ProfilingATNSimulator.h */, + 276E5C7F1CDB57AA003FF4B4 /* RangeTransition.cpp */, + 276E5C801CDB57AA003FF4B4 /* RangeTransition.h */, + 276E5C811CDB57AA003FF4B4 /* RuleStartState.cpp */, + 276E5C821CDB57AA003FF4B4 /* RuleStartState.h */, + 276E5C831CDB57AA003FF4B4 /* RuleStopState.cpp */, + 276E5C841CDB57AA003FF4B4 /* RuleStopState.h */, + 276E5C851CDB57AA003FF4B4 /* RuleTransition.cpp */, + 276E5C861CDB57AA003FF4B4 /* RuleTransition.h */, + 276E5C871CDB57AA003FF4B4 /* SemanticContext.cpp */, + 276E5C881CDB57AA003FF4B4 /* SemanticContext.h */, + 276E5C891CDB57AA003FF4B4 /* SetTransition.cpp */, + 276E5C8A1CDB57AA003FF4B4 /* SetTransition.h */, + 276E5C8B1CDB57AA003FF4B4 /* SingletonPredictionContext.cpp */, + 276E5C8C1CDB57AA003FF4B4 /* SingletonPredictionContext.h */, + 276E5C8D1CDB57AA003FF4B4 /* StarBlockStartState.cpp */, + 276E5C8E1CDB57AA003FF4B4 /* StarBlockStartState.h */, + 276E5C8F1CDB57AA003FF4B4 /* StarLoopbackState.cpp */, + 276E5C901CDB57AA003FF4B4 /* StarLoopbackState.h */, + 276E5C911CDB57AA003FF4B4 /* StarLoopEntryState.cpp */, + 276E5C921CDB57AA003FF4B4 /* StarLoopEntryState.h */, + 276E5C931CDB57AA003FF4B4 /* TokensStartState.cpp */, + 276E5C941CDB57AA003FF4B4 /* TokensStartState.h */, + 276E5C951CDB57AA003FF4B4 /* Transition.cpp */, + 276E5C961CDB57AA003FF4B4 /* Transition.h */, + 276E5C971CDB57AA003FF4B4 /* WildcardTransition.cpp */, + 276E5C981CDB57AA003FF4B4 /* WildcardTransition.h */, + ); + path = atn; + sourceTree = ""; + }; + 276E5CAB1CDB57AA003FF4B4 /* dfa */ = { + isa = PBXGroup; + children = ( + 276E5CAC1CDB57AA003FF4B4 /* DFA.cpp */, + 276E5CAD1CDB57AA003FF4B4 /* DFA.h */, + 276E5CAE1CDB57AA003FF4B4 /* DFASerializer.cpp */, + 276E5CAF1CDB57AA003FF4B4 /* DFASerializer.h */, + 276E5CB01CDB57AA003FF4B4 /* DFAState.cpp */, + 276E5CB11CDB57AA003FF4B4 /* DFAState.h */, + 276E5CB21CDB57AA003FF4B4 /* LexerDFASerializer.cpp */, + 276E5CB31CDB57AA003FF4B4 /* LexerDFASerializer.h */, + ); + path = dfa; + sourceTree = ""; + }; + 276E5CC91CDB57AA003FF4B4 /* misc */ = { + isa = PBXGroup; + children = ( + 27C375821EA1059C00B5883C /* InterpreterDataReader.cpp */, + 27C375831EA1059C00B5883C /* InterpreterDataReader.h */, + 276E5CCA1CDB57AA003FF4B4 /* Interval.cpp */, + 276E5CCB1CDB57AA003FF4B4 /* Interval.h */, + 276E5CCC1CDB57AA003FF4B4 /* IntervalSet.cpp */, + 276E5CCD1CDB57AA003FF4B4 /* IntervalSet.h */, + 276E5CCE1CDB57AA003FF4B4 /* MurmurHash.cpp */, + 276E5CCF1CDB57AA003FF4B4 /* MurmurHash.h */, + 276E5CD11CDB57AA003FF4B4 /* Predicate.h */, + ); + path = misc; + sourceTree = ""; + }; + 276E5CE41CDB57AA003FF4B4 /* support */ = { + isa = PBXGroup; + children = ( + 2793DC9C1F08090D00A84290 /* Any.cpp */, + 27F4A8551D4CEB2A00E067EE /* Any.h */, + 276E5CE51CDB57AA003FF4B4 /* Arrays.cpp */, + 276E5CE61CDB57AA003FF4B4 /* Arrays.h */, + 276E5CE71CDB57AA003FF4B4 /* BitSet.h */, + 276E5CE81CDB57AA003FF4B4 /* CPPUtils.cpp */, + 276E5CE91CDB57AA003FF4B4 /* CPPUtils.h */, + 276E5CEA1CDB57AA003FF4B4 /* Declarations.h */, + 276E5CEB1CDB57AA003FF4B4 /* guid.cpp */, + 276E5CEC1CDB57AA003FF4B4 /* guid.h */, + 276E5CED1CDB57AA003FF4B4 /* StringUtils.cpp */, + 276E5CEE1CDB57AA003FF4B4 /* StringUtils.h */, + ); + path = support; + sourceTree = ""; + }; + 276E5CF91CDB57AA003FF4B4 /* tree */ = { + isa = PBXGroup; + children = ( + 276E5D061CDB57AA003FF4B4 /* pattern */, + 27DB448A1D045537007E790B /* xpath */, + 276E5CFA1CDB57AA003FF4B4 /* AbstractParseTreeVisitor.h */, + 2793DC941F0808E100A84290 /* ErrorNode.cpp */, + 276E5CFB1CDB57AA003FF4B4 /* ErrorNode.h */, + 276E5CFC1CDB57AA003FF4B4 /* ErrorNodeImpl.cpp */, + 276E5CFD1CDB57AA003FF4B4 /* ErrorNodeImpl.h */, + 27D414501DEB0D3D00D0F3F9 /* IterativeParseTreeWalker.cpp */, + 27D414511DEB0D3D00D0F3F9 /* IterativeParseTreeWalker.h */, + 276566DF1DA93BFB000869BE /* ParseTree.cpp */, + 276E5CFE1CDB57AA003FF4B4 /* ParseTree.h */, + 2793DC8C1F08088F00A84290 /* ParseTreeListener.cpp */, + 276E5D001CDB57AA003FF4B4 /* ParseTreeListener.h */, + 276E5D021CDB57AA003FF4B4 /* ParseTreeProperty.h */, + 2793DC951F0808E100A84290 /* ParseTreeVisitor.cpp */, + 276E5D031CDB57AA003FF4B4 /* ParseTreeVisitor.h */, + 276E5D041CDB57AA003FF4B4 /* ParseTreeWalker.cpp */, + 276E5D051CDB57AA003FF4B4 /* ParseTreeWalker.h */, + 2793DC901F0808A200A84290 /* TerminalNode.cpp */, + 276E5D181CDB57AA003FF4B4 /* TerminalNode.h */, + 276E5D191CDB57AA003FF4B4 /* TerminalNodeImpl.cpp */, + 276E5D1A1CDB57AA003FF4B4 /* TerminalNodeImpl.h */, + 276E5D1D1CDB57AA003FF4B4 /* Trees.cpp */, + 276E5D1E1CDB57AA003FF4B4 /* Trees.h */, + ); + path = tree; + sourceTree = ""; + }; + 276E5D061CDB57AA003FF4B4 /* pattern */ = { + isa = PBXGroup; + children = ( + 276E5D071CDB57AA003FF4B4 /* Chunk.h */, + 2793DC881F08087500A84290 /* Chunk.cpp */, + 276E5D081CDB57AA003FF4B4 /* ParseTreeMatch.cpp */, + 276E5D091CDB57AA003FF4B4 /* ParseTreeMatch.h */, + 276E5D0A1CDB57AA003FF4B4 /* ParseTreePattern.cpp */, + 276E5D0B1CDB57AA003FF4B4 /* ParseTreePattern.h */, + 276E5D0C1CDB57AA003FF4B4 /* ParseTreePatternMatcher.cpp */, + 276E5D0D1CDB57AA003FF4B4 /* ParseTreePatternMatcher.h */, + 276E5D0E1CDB57AA003FF4B4 /* RuleTagToken.cpp */, + 276E5D0F1CDB57AA003FF4B4 /* RuleTagToken.h */, + 276E5D101CDB57AA003FF4B4 /* TagChunk.cpp */, + 276E5D111CDB57AA003FF4B4 /* TagChunk.h */, + 276E5D121CDB57AA003FF4B4 /* TextChunk.cpp */, + 276E5D131CDB57AA003FF4B4 /* TextChunk.h */, + 276E5D141CDB57AA003FF4B4 /* TokenTagToken.cpp */, + 276E5D151CDB57AA003FF4B4 /* TokenTagToken.h */, + ); + path = pattern; + sourceTree = ""; + }; + 27874F221CCBB34200AF1C53 /* Linked Frameworks */ = { + isa = PBXGroup; + children = ( + 270C69DF1CDB536A00116E17 /* CoreFoundation.framework */, + 27874F1D1CCB7A0700AF1C53 /* CoreFoundation.framework */, + ); + name = "Linked Frameworks"; + sourceTree = ""; + }; + 27DB448A1D045537007E790B /* xpath */ = { + isa = PBXGroup; + children = ( + 27DB448B1D045537007E790B /* XPath.cpp */, + 27DB448C1D045537007E790B /* XPath.h */, + 27DB448D1D045537007E790B /* XPathElement.cpp */, + 27DB448E1D045537007E790B /* XPathElement.h */, + 27DB44AF1D0463CC007E790B /* XPathLexer.cpp */, + 27DB44B01D0463CC007E790B /* XPathLexer.h */, + 27DB448F1D045537007E790B /* XPathLexerErrorListener.cpp */, + 27DB44901D045537007E790B /* XPathLexerErrorListener.h */, + 27DB44911D045537007E790B /* XPathRuleAnywhereElement.cpp */, + 27DB44921D045537007E790B /* XPathRuleAnywhereElement.h */, + 27DB44931D045537007E790B /* XPathRuleElement.cpp */, + 27DB44941D045537007E790B /* XPathRuleElement.h */, + 27DB44951D045537007E790B /* XPathTokenAnywhereElement.cpp */, + 27DB44961D045537007E790B /* XPathTokenAnywhereElement.h */, + 27DB44971D045537007E790B /* XPathTokenElement.cpp */, + 27DB44981D045537007E790B /* XPathTokenElement.h */, + 27DB44991D045537007E790B /* XPathWildcardAnywhereElement.cpp */, + 27DB449A1D045537007E790B /* XPathWildcardAnywhereElement.h */, + 27DB449B1D045537007E790B /* XPathWildcardElement.cpp */, + 27DB449C1D045537007E790B /* XPathWildcardElement.h */, + ); + path = xpath; + sourceTree = ""; + }; + 37D727A11867AF1E007B6D10 = { + isa = PBXGroup; + children = ( + 270C67F11CDB4F1E00116E17 /* antlrcpp-ios */, + 27874F221CCBB34200AF1C53 /* Linked Frameworks */, + 37D727AB1867AF1E007B6D10 /* Products */, + 276E5C0A1CDB57AA003FF4B4 /* runtime */, + ); + sourceTree = ""; + }; + 37D727AB1867AF1E007B6D10 /* Products */ = { + isa = PBXGroup; + children = ( + 37D727AA1867AF1E007B6D10 /* libantlr4-runtime.dylib */, + 37C147171B4D5A04008EDDDB /* libantlr4-runtime.a */, + 270C67F01CDB4F1E00116E17 /* antlr4_ios.framework */, + ); + name = Products; + sourceTree = ""; + }; +/* End PBXGroup section */ + +/* Begin PBXHeadersBuildPhase section */ + 270C67ED1CDB4F1E00116E17 /* Headers */ = { + isa = PBXHeadersBuildPhase; + buildActionMask = 2147483647; + files = ( + 276E5FEB1CDB57AA003FF4B4 /* AbstractParseTreeVisitor.h in Headers */, + 276E60331CDB57AA003FF4B4 /* TextChunk.h in Headers */, + 276E5F431CDB57AA003FF4B4 /* IntStream.h in Headers */, + 276E5D5D1CDB57AA003FF4B4 /* ATN.h in Headers */, + 276E60601CDB57AA003FF4B4 /* UnbufferedCharStream.h in Headers */, + 276E5DD81CDB57AA003FF4B4 /* LexerAction.h in Headers */, + 276E5FF71CDB57AA003FF4B4 /* ParseTree.h in Headers */, + 276E5DA81CDB57AA003FF4B4 /* BlockStartState.h in Headers */, + 276E5FE21CDB57AA003FF4B4 /* TokenStream.h in Headers */, + 276E5D6F1CDB57AA003FF4B4 /* ATNDeserializationOptions.h in Headers */, + 27DB44CA1D0463DB007E790B /* XPath.h in Headers */, + 276E5EDD1CDB57AA003FF4B4 /* BaseErrorListener.h in Headers */, + 276E5DB71CDB57AA003FF4B4 /* DecisionEventInfo.h in Headers */, + 27DB44D01D0463DB007E790B /* XPathRuleAnywhereElement.h in Headers */, + 27AC52D21CE773A80093AAAB /* antlr4-runtime.h in Headers */, + 276E5E2C1CDB57AA003FF4B4 /* LL1Analyzer.h in Headers */, + 276E5D7B1CDB57AA003FF4B4 /* ATNSerializer.h in Headers */, + 276E5EAD1CDB57AA003FF4B4 /* SingletonPredictionContext.h in Headers */, + 276E5E1A1CDB57AA003FF4B4 /* LexerPushModeAction.h in Headers */, + 276E5ECB1CDB57AA003FF4B4 /* Transition.h in Headers */, + 276E5EA11CDB57AA003FF4B4 /* SemanticContext.h in Headers */, + 27DB44DA1D0463DB007E790B /* XPathWildcardElement.h in Headers */, + 276E5F5E1CDB57AA003FF4B4 /* ListTokenSource.h in Headers */, + 276E5F8E1CDB57AA003FF4B4 /* ParserInterpreter.h in Headers */, + 276E5DDE1CDB57AA003FF4B4 /* LexerActionExecutor.h in Headers */, + 276E5F4C1CDB57AA003FF4B4 /* Lexer.h in Headers */, + 276E5F641CDB57AA003FF4B4 /* Interval.h in Headers */, + 276E5DA51CDB57AA003FF4B4 /* BlockEndState.h in Headers */, + 276E5E831CDB57AA003FF4B4 /* ProfilingATNSimulator.h in Headers */, + 276E5D991CDB57AA003FF4B4 /* BasicBlockStartState.h in Headers */, + 27C375891EA1059C00B5883C /* InterpreterDataReader.h in Headers */, + 276E5E9B1CDB57AA003FF4B4 /* RuleTransition.h in Headers */, + 276E60031CDB57AA003FF4B4 /* ParseTreeProperty.h in Headers */, + 276E5D8D1CDB57AA003FF4B4 /* ATNType.h in Headers */, + 276E5FFD1CDB57AA003FF4B4 /* ParseTreeListener.h in Headers */, + 276E5D9F1CDB57AA003FF4B4 /* BasicState.h in Headers */, + 276E5FAC1CDB57AA003FF4B4 /* RuleContext.h in Headers */, + 276E60271CDB57AA003FF4B4 /* RuleTagToken.h in Headers */, + 276E5F011CDB57AA003FF4B4 /* ConsoleErrorListener.h in Headers */, + 276E5D331CDB57AA003FF4B4 /* ANTLRErrorStrategy.h in Headers */, + 276E5E0E1CDB57AA003FF4B4 /* LexerMoreAction.h in Headers */, + 276E5D4B1CDB57AA003FF4B4 /* ActionTransition.h in Headers */, + 276E5E8F1CDB57AA003FF4B4 /* RuleStartState.h in Headers */, + 276E5E201CDB57AA003FF4B4 /* LexerSkipAction.h in Headers */, + 276E5E381CDB57AA003FF4B4 /* LoopEndState.h in Headers */, + 276E5D691CDB57AA003FF4B4 /* ATNConfigSet.h in Headers */, + 276E5D391CDB57AA003FF4B4 /* ANTLRFileStream.h in Headers */, + 276E5D301CDB57AA003FF4B4 /* ANTLRErrorListener.h in Headers */, + 27B36ACB1DACE7AF0069C868 /* RuleContextWithAltNum.h in Headers */, + 276E5FCA1CDB57AA003FF4B4 /* StringUtils.h in Headers */, + 276E5EF51CDB57AA003FF4B4 /* CommonTokenFactory.h in Headers */, + 276E5F191CDB57AA003FF4B4 /* DFAState.h in Headers */, + 276E5FA61CDB57AA003FF4B4 /* Recognizer.h in Headers */, + 276E60751CDB57AA003FF4B4 /* WritableToken.h in Headers */, + 276E5D3F1CDB57AA003FF4B4 /* ANTLRInputStream.h in Headers */, + 276E5FD01CDB57AA003FF4B4 /* Token.h in Headers */, + 276E60421CDB57AA003FF4B4 /* TerminalNode.h in Headers */, + 276E5D751CDB57AA003FF4B4 /* ATNDeserializer.h in Headers */, + 276E5D871CDB57AA003FF4B4 /* ATNState.h in Headers */, + 276E5E7D1CDB57AA003FF4B4 /* PredictionMode.h in Headers */, + 276E5EBF1CDB57AA003FF4B4 /* StarLoopEntryState.h in Headers */, + 276E5FA01CDB57AA003FF4B4 /* RecognitionException.h in Headers */, + 276E5EA71CDB57AA003FF4B4 /* SetTransition.h in Headers */, + 276E5F1F1CDB57AA003FF4B4 /* LexerDFASerializer.h in Headers */, + 276E5E471CDB57AA003FF4B4 /* OrderedATNConfigSet.h in Headers */, + 276E5DF61CDB57AA003FF4B4 /* LexerChannelAction.h in Headers */, + 276E5FB21CDB57AA003FF4B4 /* Arrays.h in Headers */, + 276E5F821CDB57AA003FF4B4 /* NoViableAltException.h in Headers */, + 276E5DEA1CDB57AA003FF4B4 /* LexerATNConfig.h in Headers */, + 276E60481CDB57AA003FF4B4 /* TerminalNodeImpl.h in Headers */, + 27745F081CE49C000067C6A3 /* RuntimeMetaData.h in Headers */, + 276E5FF41CDB57AA003FF4B4 /* ErrorNodeImpl.h in Headers */, + 276E5EC51CDB57AA003FF4B4 /* TokensStartState.h in Headers */, + 276E5DC91CDB57AA003FF4B4 /* EmptyPredictionContext.h in Headers */, + 276E5D451CDB57AA003FF4B4 /* AbstractPredicateTransition.h in Headers */, + 276E5F2B1CDB57AA003FF4B4 /* Exceptions.h in Headers */, + 276E5F251CDB57AA003FF4B4 /* DiagnosticErrorListener.h in Headers */, + 276E5E141CDB57AA003FF4B4 /* LexerPopModeAction.h in Headers */, + 276E5ED71CDB57AA003FF4B4 /* BailErrorStrategy.h in Headers */, + 27DB44CE1D0463DB007E790B /* XPathLexerErrorListener.h in Headers */, + 276E5DCF1CDB57AA003FF4B4 /* EpsilonTransition.h in Headers */, + 276E5FBE1CDB57AA003FF4B4 /* Declarations.h in Headers */, + 276E600C1CDB57AA003FF4B4 /* ParseTreeWalker.h in Headers */, + 276E5E771CDB57AA003FF4B4 /* PredictionContext.h in Headers */, + 276E60151CDB57AA003FF4B4 /* ParseTreeMatch.h in Headers */, + 27DB44CC1D0463DB007E790B /* XPathElement.h in Headers */, + 276E5F581CDB57AA003FF4B4 /* LexerNoViableAltException.h in Headers */, + 276E5D811CDB57AA003FF4B4 /* ATNSimulator.h in Headers */, + 27DB44B61D0463CC007E790B /* XPathLexer.h in Headers */, + 276E5FC41CDB57AA003FF4B4 /* guid.h in Headers */, + 276E602D1CDB57AA003FF4B4 /* TagChunk.h in Headers */, + 276E5E951CDB57AA003FF4B4 /* RuleStopState.h in Headers */, + 276E5F761CDB57AA003FF4B4 /* Predicate.h in Headers */, + 276E5F941CDB57AA003FF4B4 /* ParserRuleContext.h in Headers */, + 276E5FEE1CDB57AA003FF4B4 /* ErrorNode.h in Headers */, + 276E5EB91CDB57AA003FF4B4 /* StarLoopbackState.h in Headers */, + 276E5E5F1CDB57AA003FF4B4 /* PlusLoopbackState.h in Headers */, + 276E5E081CDB57AA003FF4B4 /* LexerModeAction.h in Headers */, + 276E5E591CDB57AA003FF4B4 /* PlusBlockStartState.h in Headers */, + 276E5D931CDB57AA003FF4B4 /* AtomTransition.h in Headers */, + 276E5F521CDB57AA003FF4B4 /* LexerInterpreter.h in Headers */, + 276E5F311CDB57AA003FF4B4 /* FailedPredicateException.h in Headers */, + 276E5E321CDB57AA003FF4B4 /* LookaheadEventInfo.h in Headers */, + 276E5F0D1CDB57AA003FF4B4 /* DFA.h in Headers */, + 276E606F1CDB57AA003FF4B4 /* Vocabulary.h in Headers */, + 276E60541CDB57AA003FF4B4 /* Trees.h in Headers */, + 276E5FB51CDB57AA003FF4B4 /* BitSet.h in Headers */, + 276E5F9A1CDB57AA003FF4B4 /* ProxyErrorListener.h in Headers */, + 276E5E411CDB57AA003FF4B4 /* NotSetTransition.h in Headers */, + 276E5E891CDB57AA003FF4B4 /* RangeTransition.h in Headers */, + 27DB44D21D0463DB007E790B /* XPathRuleElement.h in Headers */, + 27D414571DEB0D3D00D0F3F9 /* IterativeParseTreeWalker.h in Headers */, + 276E601B1CDB57AA003FF4B4 /* ParseTreePattern.h in Headers */, + 276E5DFC1CDB57AA003FF4B4 /* LexerCustomAction.h in Headers */, + 276E5FE81CDB57AA003FF4B4 /* TokenStreamRewriter.h in Headers */, + 276E5DF01CDB57AA003FF4B4 /* LexerATNSimulator.h in Headers */, + 276E5DD51CDB57AA003FF4B4 /* ErrorInfo.h in Headers */, + 276E5E261CDB57AA003FF4B4 /* LexerTypeAction.h in Headers */, + 27DB44D61D0463DB007E790B /* XPathTokenElement.h in Headers */, + 276E5DE41CDB57AA003FF4B4 /* LexerActionType.h in Headers */, + 276E5D511CDB57AA003FF4B4 /* AmbiguityInfo.h in Headers */, + 276E5E711CDB57AA003FF4B4 /* PredicateTransition.h in Headers */, + 276E5EE91CDB57AA003FF4B4 /* CharStream.h in Headers */, + 276E60061CDB57AA003FF4B4 /* ParseTreeVisitor.h in Headers */, + 276E5D571CDB57AA003FF4B4 /* ArrayPredictionContext.h in Headers */, + 276E5E531CDB57AA003FF4B4 /* ParserATNSimulator.h in Headers */, + 276E60661CDB57AA003FF4B4 /* UnbufferedTokenStream.h in Headers */, + 276E5F6A1CDB57AA003FF4B4 /* IntervalSet.h in Headers */, + 276E5E651CDB57AA003FF4B4 /* PrecedencePredicateTransition.h in Headers */, + 276E5F071CDB57AA003FF4B4 /* DefaultErrorStrategy.h in Headers */, + 276E5F3D1CDB57AA003FF4B4 /* InterpreterRuleContext.h in Headers */, + 276E5F131CDB57AA003FF4B4 /* DFASerializer.h in Headers */, + 2794D8581CE7821B00FADD0F /* antlr4-common.h in Headers */, + 276E5F371CDB57AA003FF4B4 /* InputMismatchException.h in Headers */, + 276E5FDC1CDB57AA003FF4B4 /* TokenSource.h in Headers */, + 276E5ED11CDB57AA003FF4B4 /* WildcardTransition.h in Headers */, + 276E600F1CDB57AA003FF4B4 /* Chunk.h in Headers */, + 276E5FBB1CDB57AA003FF4B4 /* CPPUtils.h in Headers */, + 276E5EE31CDB57AA003FF4B4 /* BufferedTokenStream.h in Headers */, + 276E5DB11CDB57AA003FF4B4 /* ContextSensitivityInfo.h in Headers */, + 276E5E021CDB57AA003FF4B4 /* LexerIndexedCustomAction.h in Headers */, + 276E5FD61CDB57AA003FF4B4 /* TokenFactory.h in Headers */, + 276E5EFB1CDB57AA003FF4B4 /* CommonTokenStream.h in Headers */, + 276E5EB31CDB57AA003FF4B4 /* StarBlockStartState.h in Headers */, + 276E5F701CDB57AA003FF4B4 /* MurmurHash.h in Headers */, + 276E60211CDB57AA003FF4B4 /* ParseTreePatternMatcher.h in Headers */, + 276E5D631CDB57AA003FF4B4 /* ATNConfig.h in Headers */, + 27DB44D41D0463DB007E790B /* XPathTokenAnywhereElement.h in Headers */, + 27DB44D81D0463DB007E790B /* XPathWildcardAnywhereElement.h in Headers */, + 276E5E4D1CDB57AA003FF4B4 /* ParseInfo.h in Headers */, + 276E5F881CDB57AA003FF4B4 /* Parser.h in Headers */, + 276E5DBD1CDB57AA003FF4B4 /* DecisionInfo.h in Headers */, + 276E5DC31CDB57AA003FF4B4 /* DecisionState.h in Headers */, + 276E5E6B1CDB57AA003FF4B4 /* PredicateEvalInfo.h in Headers */, + 276E5EEF1CDB57AA003FF4B4 /* CommonToken.h in Headers */, + 270C67F31CDB4F1E00116E17 /* antlrcpp_ios.h in Headers */, + 276E60391CDB57AA003FF4B4 /* TokenTagToken.h in Headers */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 37C147151B4D5A04008EDDDB /* Headers */ = { + isa = PBXHeadersBuildPhase; + buildActionMask = 2147483647; + files = ( + 276E5FEA1CDB57AA003FF4B4 /* AbstractParseTreeVisitor.h in Headers */, + 276E60321CDB57AA003FF4B4 /* TextChunk.h in Headers */, + 276E5F421CDB57AA003FF4B4 /* IntStream.h in Headers */, + 276E5D5C1CDB57AA003FF4B4 /* ATN.h in Headers */, + 276E605F1CDB57AA003FF4B4 /* UnbufferedCharStream.h in Headers */, + 276E5DD71CDB57AA003FF4B4 /* LexerAction.h in Headers */, + 276E5FF61CDB57AA003FF4B4 /* ParseTree.h in Headers */, + 27AC52D11CE773A80093AAAB /* antlr4-runtime.h in Headers */, + 276E5DA71CDB57AA003FF4B4 /* BlockStartState.h in Headers */, + 276E5FE11CDB57AA003FF4B4 /* TokenStream.h in Headers */, + 276E5D6E1CDB57AA003FF4B4 /* ATNDeserializationOptions.h in Headers */, + 276E5EDC1CDB57AA003FF4B4 /* BaseErrorListener.h in Headers */, + 276E5DB61CDB57AA003FF4B4 /* DecisionEventInfo.h in Headers */, + 276E5E2B1CDB57AA003FF4B4 /* LL1Analyzer.h in Headers */, + 27DB44BA1D0463DA007E790B /* XPathElement.h in Headers */, + 276E5D7A1CDB57AA003FF4B4 /* ATNSerializer.h in Headers */, + 27C375881EA1059C00B5883C /* InterpreterDataReader.h in Headers */, + 276E5EAC1CDB57AA003FF4B4 /* SingletonPredictionContext.h in Headers */, + 276E5E191CDB57AA003FF4B4 /* LexerPushModeAction.h in Headers */, + 276E5ECA1CDB57AA003FF4B4 /* Transition.h in Headers */, + 276E5EA01CDB57AA003FF4B4 /* SemanticContext.h in Headers */, + 276E5F5D1CDB57AA003FF4B4 /* ListTokenSource.h in Headers */, + 276E5F8D1CDB57AA003FF4B4 /* ParserInterpreter.h in Headers */, + 27D414561DEB0D3D00D0F3F9 /* IterativeParseTreeWalker.h in Headers */, + 276E5DDD1CDB57AA003FF4B4 /* LexerActionExecutor.h in Headers */, + 276E5F4B1CDB57AA003FF4B4 /* Lexer.h in Headers */, + 276E5F631CDB57AA003FF4B4 /* Interval.h in Headers */, + 276E5DA41CDB57AA003FF4B4 /* BlockEndState.h in Headers */, + 27DB44C21D0463DA007E790B /* XPathTokenAnywhereElement.h in Headers */, + 276E5E821CDB57AA003FF4B4 /* ProfilingATNSimulator.h in Headers */, + 27DB44C41D0463DA007E790B /* XPathTokenElement.h in Headers */, + 276E5D981CDB57AA003FF4B4 /* BasicBlockStartState.h in Headers */, + 276E5E9A1CDB57AA003FF4B4 /* RuleTransition.h in Headers */, + 27DB44B81D0463DA007E790B /* XPath.h in Headers */, + 276E60021CDB57AA003FF4B4 /* ParseTreeProperty.h in Headers */, + 276E5D8C1CDB57AA003FF4B4 /* ATNType.h in Headers */, + 276E5FFC1CDB57AA003FF4B4 /* ParseTreeListener.h in Headers */, + 276E5D9E1CDB57AA003FF4B4 /* BasicState.h in Headers */, + 276E5FAB1CDB57AA003FF4B4 /* RuleContext.h in Headers */, + 276E60261CDB57AA003FF4B4 /* RuleTagToken.h in Headers */, + 276E5F001CDB57AA003FF4B4 /* ConsoleErrorListener.h in Headers */, + 27B36ACA1DACE7AF0069C868 /* RuleContextWithAltNum.h in Headers */, + 276E5D321CDB57AA003FF4B4 /* ANTLRErrorStrategy.h in Headers */, + 276E5E0D1CDB57AA003FF4B4 /* LexerMoreAction.h in Headers */, + 276E5D4A1CDB57AA003FF4B4 /* ActionTransition.h in Headers */, + 276E5E8E1CDB57AA003FF4B4 /* RuleStartState.h in Headers */, + 276E5E1F1CDB57AA003FF4B4 /* LexerSkipAction.h in Headers */, + 276E5E371CDB57AA003FF4B4 /* LoopEndState.h in Headers */, + 276E5D681CDB57AA003FF4B4 /* ATNConfigSet.h in Headers */, + 276E5D381CDB57AA003FF4B4 /* ANTLRFileStream.h in Headers */, + 27DB44C01D0463DA007E790B /* XPathRuleElement.h in Headers */, + 276E5D2F1CDB57AA003FF4B4 /* ANTLRErrorListener.h in Headers */, + 276E5FC91CDB57AA003FF4B4 /* StringUtils.h in Headers */, + 276E5EF41CDB57AA003FF4B4 /* CommonTokenFactory.h in Headers */, + 276E5F181CDB57AA003FF4B4 /* DFAState.h in Headers */, + 276E5FA51CDB57AA003FF4B4 /* Recognizer.h in Headers */, + 276E60741CDB57AA003FF4B4 /* WritableToken.h in Headers */, + 276E5D3E1CDB57AA003FF4B4 /* ANTLRInputStream.h in Headers */, + 276E5FCF1CDB57AA003FF4B4 /* Token.h in Headers */, + 276E60411CDB57AA003FF4B4 /* TerminalNode.h in Headers */, + 276E5D741CDB57AA003FF4B4 /* ATNDeserializer.h in Headers */, + 27DB44B51D0463CC007E790B /* XPathLexer.h in Headers */, + 276E5D861CDB57AA003FF4B4 /* ATNState.h in Headers */, + 276E5E7C1CDB57AA003FF4B4 /* PredictionMode.h in Headers */, + 276E5EBE1CDB57AA003FF4B4 /* StarLoopEntryState.h in Headers */, + 276E5F9F1CDB57AA003FF4B4 /* RecognitionException.h in Headers */, + 27DB44BE1D0463DA007E790B /* XPathRuleAnywhereElement.h in Headers */, + 27745F071CE49C000067C6A3 /* RuntimeMetaData.h in Headers */, + 276E5EA61CDB57AA003FF4B4 /* SetTransition.h in Headers */, + 276E5F1E1CDB57AA003FF4B4 /* LexerDFASerializer.h in Headers */, + 276E5E461CDB57AA003FF4B4 /* OrderedATNConfigSet.h in Headers */, + 276E5DF51CDB57AA003FF4B4 /* LexerChannelAction.h in Headers */, + 276E5FB11CDB57AA003FF4B4 /* Arrays.h in Headers */, + 276E5F811CDB57AA003FF4B4 /* NoViableAltException.h in Headers */, + 276E5DE91CDB57AA003FF4B4 /* LexerATNConfig.h in Headers */, + 276E60471CDB57AA003FF4B4 /* TerminalNodeImpl.h in Headers */, + 276E5FF31CDB57AA003FF4B4 /* ErrorNodeImpl.h in Headers */, + 276E5EC41CDB57AA003FF4B4 /* TokensStartState.h in Headers */, + 276E5DC81CDB57AA003FF4B4 /* EmptyPredictionContext.h in Headers */, + 276E5D441CDB57AA003FF4B4 /* AbstractPredicateTransition.h in Headers */, + 276E5F2A1CDB57AA003FF4B4 /* Exceptions.h in Headers */, + 27DB44C61D0463DA007E790B /* XPathWildcardAnywhereElement.h in Headers */, + 276E5F241CDB57AA003FF4B4 /* DiagnosticErrorListener.h in Headers */, + 276E5E131CDB57AA003FF4B4 /* LexerPopModeAction.h in Headers */, + 276E5ED61CDB57AA003FF4B4 /* BailErrorStrategy.h in Headers */, + 276E5DCE1CDB57AA003FF4B4 /* EpsilonTransition.h in Headers */, + 276E5FBD1CDB57AA003FF4B4 /* Declarations.h in Headers */, + 276E600B1CDB57AA003FF4B4 /* ParseTreeWalker.h in Headers */, + 276E5E761CDB57AA003FF4B4 /* PredictionContext.h in Headers */, + 276E60141CDB57AA003FF4B4 /* ParseTreeMatch.h in Headers */, + 276E5F571CDB57AA003FF4B4 /* LexerNoViableAltException.h in Headers */, + 276E5D801CDB57AA003FF4B4 /* ATNSimulator.h in Headers */, + 276E5FC31CDB57AA003FF4B4 /* guid.h in Headers */, + 276E602C1CDB57AA003FF4B4 /* TagChunk.h in Headers */, + 276E5E941CDB57AA003FF4B4 /* RuleStopState.h in Headers */, + 276E5F751CDB57AA003FF4B4 /* Predicate.h in Headers */, + 276E5F931CDB57AA003FF4B4 /* ParserRuleContext.h in Headers */, + 276E5FED1CDB57AA003FF4B4 /* ErrorNode.h in Headers */, + 276E5EB81CDB57AA003FF4B4 /* StarLoopbackState.h in Headers */, + 276E5E5E1CDB57AA003FF4B4 /* PlusLoopbackState.h in Headers */, + 276E5E071CDB57AA003FF4B4 /* LexerModeAction.h in Headers */, + 276E5E581CDB57AA003FF4B4 /* PlusBlockStartState.h in Headers */, + 276E5D921CDB57AA003FF4B4 /* AtomTransition.h in Headers */, + 276E5F511CDB57AA003FF4B4 /* LexerInterpreter.h in Headers */, + 276E5F301CDB57AA003FF4B4 /* FailedPredicateException.h in Headers */, + 276E5E311CDB57AA003FF4B4 /* LookaheadEventInfo.h in Headers */, + 276E5F0C1CDB57AA003FF4B4 /* DFA.h in Headers */, + 276E606E1CDB57AA003FF4B4 /* Vocabulary.h in Headers */, + 276E60531CDB57AA003FF4B4 /* Trees.h in Headers */, + 276E5FB41CDB57AA003FF4B4 /* BitSet.h in Headers */, + 276E5F991CDB57AA003FF4B4 /* ProxyErrorListener.h in Headers */, + 276E5E401CDB57AA003FF4B4 /* NotSetTransition.h in Headers */, + 276E5E881CDB57AA003FF4B4 /* RangeTransition.h in Headers */, + 276E601A1CDB57AA003FF4B4 /* ParseTreePattern.h in Headers */, + 276E5DFB1CDB57AA003FF4B4 /* LexerCustomAction.h in Headers */, + 276E5FE71CDB57AA003FF4B4 /* TokenStreamRewriter.h in Headers */, + 276E5DEF1CDB57AA003FF4B4 /* LexerATNSimulator.h in Headers */, + 276E5DD41CDB57AA003FF4B4 /* ErrorInfo.h in Headers */, + 276E5E251CDB57AA003FF4B4 /* LexerTypeAction.h in Headers */, + 276E5DE31CDB57AA003FF4B4 /* LexerActionType.h in Headers */, + 276E5D501CDB57AA003FF4B4 /* AmbiguityInfo.h in Headers */, + 276E5E701CDB57AA003FF4B4 /* PredicateTransition.h in Headers */, + 276E5EE81CDB57AA003FF4B4 /* CharStream.h in Headers */, + 276E60051CDB57AA003FF4B4 /* ParseTreeVisitor.h in Headers */, + 276E5D561CDB57AA003FF4B4 /* ArrayPredictionContext.h in Headers */, + 276E5E521CDB57AA003FF4B4 /* ParserATNSimulator.h in Headers */, + 2794D8571CE7821B00FADD0F /* antlr4-common.h in Headers */, + 276E60651CDB57AA003FF4B4 /* UnbufferedTokenStream.h in Headers */, + 276E5F691CDB57AA003FF4B4 /* IntervalSet.h in Headers */, + 276E5E641CDB57AA003FF4B4 /* PrecedencePredicateTransition.h in Headers */, + 276E5F061CDB57AA003FF4B4 /* DefaultErrorStrategy.h in Headers */, + 276E5F3C1CDB57AA003FF4B4 /* InterpreterRuleContext.h in Headers */, + 27DB44BC1D0463DA007E790B /* XPathLexerErrorListener.h in Headers */, + 276E5F121CDB57AA003FF4B4 /* DFASerializer.h in Headers */, + 276E5F361CDB57AA003FF4B4 /* InputMismatchException.h in Headers */, + 276E5FDB1CDB57AA003FF4B4 /* TokenSource.h in Headers */, + 276E5ED01CDB57AA003FF4B4 /* WildcardTransition.h in Headers */, + 276E600E1CDB57AA003FF4B4 /* Chunk.h in Headers */, + 276E5FBA1CDB57AA003FF4B4 /* CPPUtils.h in Headers */, + 276E5EE21CDB57AA003FF4B4 /* BufferedTokenStream.h in Headers */, + 276E5DB01CDB57AA003FF4B4 /* ContextSensitivityInfo.h in Headers */, + 276E5E011CDB57AA003FF4B4 /* LexerIndexedCustomAction.h in Headers */, + 276E5FD51CDB57AA003FF4B4 /* TokenFactory.h in Headers */, + 276E5EFA1CDB57AA003FF4B4 /* CommonTokenStream.h in Headers */, + 276E5EB21CDB57AA003FF4B4 /* StarBlockStartState.h in Headers */, + 276E5F6F1CDB57AA003FF4B4 /* MurmurHash.h in Headers */, + 27DB44C81D0463DA007E790B /* XPathWildcardElement.h in Headers */, + 276E60201CDB57AA003FF4B4 /* ParseTreePatternMatcher.h in Headers */, + 276E5D621CDB57AA003FF4B4 /* ATNConfig.h in Headers */, + 276E5E4C1CDB57AA003FF4B4 /* ParseInfo.h in Headers */, + 276E5F871CDB57AA003FF4B4 /* Parser.h in Headers */, + 276E5DBC1CDB57AA003FF4B4 /* DecisionInfo.h in Headers */, + 276E5DC21CDB57AA003FF4B4 /* DecisionState.h in Headers */, + 276E5E6A1CDB57AA003FF4B4 /* PredicateEvalInfo.h in Headers */, + 276E5EEE1CDB57AA003FF4B4 /* CommonToken.h in Headers */, + 276E60381CDB57AA003FF4B4 /* TokenTagToken.h in Headers */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 37D727A81867AF1E007B6D10 /* Headers */ = { + isa = PBXHeadersBuildPhase; + buildActionMask = 2147483647; + files = ( + 276E5FE91CDB57AA003FF4B4 /* AbstractParseTreeVisitor.h in Headers */, + 27DB44AC1D045537007E790B /* XPathWildcardAnywhereElement.h in Headers */, + 276E60311CDB57AA003FF4B4 /* TextChunk.h in Headers */, + 276E5F411CDB57AA003FF4B4 /* IntStream.h in Headers */, + 276E5D5B1CDB57AA003FF4B4 /* ATN.h in Headers */, + 276E605E1CDB57AA003FF4B4 /* UnbufferedCharStream.h in Headers */, + 276E5DD61CDB57AA003FF4B4 /* LexerAction.h in Headers */, + 27DB44A41D045537007E790B /* XPathRuleAnywhereElement.h in Headers */, + 276E5FF51CDB57AA003FF4B4 /* ParseTree.h in Headers */, + 27AC52D01CE773A80093AAAB /* antlr4-runtime.h in Headers */, + 276E5DA61CDB57AA003FF4B4 /* BlockStartState.h in Headers */, + 276E5FE01CDB57AA003FF4B4 /* TokenStream.h in Headers */, + 276E5D6D1CDB57AA003FF4B4 /* ATNDeserializationOptions.h in Headers */, + 276E5EDB1CDB57AA003FF4B4 /* BaseErrorListener.h in Headers */, + 276E5DB51CDB57AA003FF4B4 /* DecisionEventInfo.h in Headers */, + 276E5E2A1CDB57AA003FF4B4 /* LL1Analyzer.h in Headers */, + 276E5D791CDB57AA003FF4B4 /* ATNSerializer.h in Headers */, + 276E5EAB1CDB57AA003FF4B4 /* SingletonPredictionContext.h in Headers */, + 276E5E181CDB57AA003FF4B4 /* LexerPushModeAction.h in Headers */, + 276E5EC91CDB57AA003FF4B4 /* Transition.h in Headers */, + 276E5E9F1CDB57AA003FF4B4 /* SemanticContext.h in Headers */, + 276E5F5C1CDB57AA003FF4B4 /* ListTokenSource.h in Headers */, + 276E5F8C1CDB57AA003FF4B4 /* ParserInterpreter.h in Headers */, + 276E5DDC1CDB57AA003FF4B4 /* LexerActionExecutor.h in Headers */, + 276E5F4A1CDB57AA003FF4B4 /* Lexer.h in Headers */, + 276E5F621CDB57AA003FF4B4 /* Interval.h in Headers */, + 276E5DA31CDB57AA003FF4B4 /* BlockEndState.h in Headers */, + 276E5E811CDB57AA003FF4B4 /* ProfilingATNSimulator.h in Headers */, + 276E5D971CDB57AA003FF4B4 /* BasicBlockStartState.h in Headers */, + 276E5E991CDB57AA003FF4B4 /* RuleTransition.h in Headers */, + 27C375871EA1059C00B5883C /* InterpreterDataReader.h in Headers */, + 276E60011CDB57AA003FF4B4 /* ParseTreeProperty.h in Headers */, + 276E5D8B1CDB57AA003FF4B4 /* ATNType.h in Headers */, + 276E5FFB1CDB57AA003FF4B4 /* ParseTreeListener.h in Headers */, + 276E5D9D1CDB57AA003FF4B4 /* BasicState.h in Headers */, + 276E5FAA1CDB57AA003FF4B4 /* RuleContext.h in Headers */, + 276E60251CDB57AA003FF4B4 /* RuleTagToken.h in Headers */, + 276E5EFF1CDB57AA003FF4B4 /* ConsoleErrorListener.h in Headers */, + 276E5D311CDB57AA003FF4B4 /* ANTLRErrorStrategy.h in Headers */, + 276E5E0C1CDB57AA003FF4B4 /* LexerMoreAction.h in Headers */, + 276E5D491CDB57AA003FF4B4 /* ActionTransition.h in Headers */, + 276E5E8D1CDB57AA003FF4B4 /* RuleStartState.h in Headers */, + 276E5E1E1CDB57AA003FF4B4 /* LexerSkipAction.h in Headers */, + 276E5E361CDB57AA003FF4B4 /* LoopEndState.h in Headers */, + 276E5D671CDB57AA003FF4B4 /* ATNConfigSet.h in Headers */, + 276E5D371CDB57AA003FF4B4 /* ANTLRFileStream.h in Headers */, + 27DB44B41D0463CC007E790B /* XPathLexer.h in Headers */, + 276E5D2E1CDB57AA003FF4B4 /* ANTLRErrorListener.h in Headers */, + 27B36AC91DACE7AF0069C868 /* RuleContextWithAltNum.h in Headers */, + 276E5FC81CDB57AA003FF4B4 /* StringUtils.h in Headers */, + 276E5EF31CDB57AA003FF4B4 /* CommonTokenFactory.h in Headers */, + 276E5F171CDB57AA003FF4B4 /* DFAState.h in Headers */, + 276E5FA41CDB57AA003FF4B4 /* Recognizer.h in Headers */, + 276E60731CDB57AA003FF4B4 /* WritableToken.h in Headers */, + 276E5D3D1CDB57AA003FF4B4 /* ANTLRInputStream.h in Headers */, + 276E5FCE1CDB57AA003FF4B4 /* Token.h in Headers */, + 276E60401CDB57AA003FF4B4 /* TerminalNode.h in Headers */, + 276E5D731CDB57AA003FF4B4 /* ATNDeserializer.h in Headers */, + 276E5D851CDB57AA003FF4B4 /* ATNState.h in Headers */, + 276E5E7B1CDB57AA003FF4B4 /* PredictionMode.h in Headers */, + 276E5EBD1CDB57AA003FF4B4 /* StarLoopEntryState.h in Headers */, + 276E5F9E1CDB57AA003FF4B4 /* RecognitionException.h in Headers */, + 27745F061CE49C000067C6A3 /* RuntimeMetaData.h in Headers */, + 276E5EA51CDB57AA003FF4B4 /* SetTransition.h in Headers */, + 276E5F1D1CDB57AA003FF4B4 /* LexerDFASerializer.h in Headers */, + 276E5E451CDB57AA003FF4B4 /* OrderedATNConfigSet.h in Headers */, + 276E5DF41CDB57AA003FF4B4 /* LexerChannelAction.h in Headers */, + 276E5FB01CDB57AA003FF4B4 /* Arrays.h in Headers */, + 276E5F801CDB57AA003FF4B4 /* NoViableAltException.h in Headers */, + 276E5DE81CDB57AA003FF4B4 /* LexerATNConfig.h in Headers */, + 276E60461CDB57AA003FF4B4 /* TerminalNodeImpl.h in Headers */, + 276E5FF21CDB57AA003FF4B4 /* ErrorNodeImpl.h in Headers */, + 276E5EC31CDB57AA003FF4B4 /* TokensStartState.h in Headers */, + 276E5DC71CDB57AA003FF4B4 /* EmptyPredictionContext.h in Headers */, + 276E5D431CDB57AA003FF4B4 /* AbstractPredicateTransition.h in Headers */, + 276E5F291CDB57AA003FF4B4 /* Exceptions.h in Headers */, + 276E5F231CDB57AA003FF4B4 /* DiagnosticErrorListener.h in Headers */, + 27DB449E1D045537007E790B /* XPath.h in Headers */, + 276E5E121CDB57AA003FF4B4 /* LexerPopModeAction.h in Headers */, + 276E5ED51CDB57AA003FF4B4 /* BailErrorStrategy.h in Headers */, + 276E5DCD1CDB57AA003FF4B4 /* EpsilonTransition.h in Headers */, + 276E5FBC1CDB57AA003FF4B4 /* Declarations.h in Headers */, + 276E600A1CDB57AA003FF4B4 /* ParseTreeWalker.h in Headers */, + 276E5E751CDB57AA003FF4B4 /* PredictionContext.h in Headers */, + 276E60131CDB57AA003FF4B4 /* ParseTreeMatch.h in Headers */, + 276E5F561CDB57AA003FF4B4 /* LexerNoViableAltException.h in Headers */, + 276E5D7F1CDB57AA003FF4B4 /* ATNSimulator.h in Headers */, + 276E5FC21CDB57AA003FF4B4 /* guid.h in Headers */, + 276E602B1CDB57AA003FF4B4 /* TagChunk.h in Headers */, + 276E5E931CDB57AA003FF4B4 /* RuleStopState.h in Headers */, + 276E5F741CDB57AA003FF4B4 /* Predicate.h in Headers */, + 276E5F921CDB57AA003FF4B4 /* ParserRuleContext.h in Headers */, + 276E5FEC1CDB57AA003FF4B4 /* ErrorNode.h in Headers */, + 276E5EB71CDB57AA003FF4B4 /* StarLoopbackState.h in Headers */, + 276E5E5D1CDB57AA003FF4B4 /* PlusLoopbackState.h in Headers */, + 276E5E061CDB57AA003FF4B4 /* LexerModeAction.h in Headers */, + 276E5E571CDB57AA003FF4B4 /* PlusBlockStartState.h in Headers */, + 276E5D911CDB57AA003FF4B4 /* AtomTransition.h in Headers */, + 276E5F501CDB57AA003FF4B4 /* LexerInterpreter.h in Headers */, + 27DB44AE1D045537007E790B /* XPathWildcardElement.h in Headers */, + 276E5F2F1CDB57AA003FF4B4 /* FailedPredicateException.h in Headers */, + 276E5E301CDB57AA003FF4B4 /* LookaheadEventInfo.h in Headers */, + 276E5F0B1CDB57AA003FF4B4 /* DFA.h in Headers */, + 276E606D1CDB57AA003FF4B4 /* Vocabulary.h in Headers */, + 276E60521CDB57AA003FF4B4 /* Trees.h in Headers */, + 276E5FB31CDB57AA003FF4B4 /* BitSet.h in Headers */, + 27DB44AA1D045537007E790B /* XPathTokenElement.h in Headers */, + 276E5F981CDB57AA003FF4B4 /* ProxyErrorListener.h in Headers */, + 276E5E3F1CDB57AA003FF4B4 /* NotSetTransition.h in Headers */, + 276E5E871CDB57AA003FF4B4 /* RangeTransition.h in Headers */, + 276E60191CDB57AA003FF4B4 /* ParseTreePattern.h in Headers */, + 27D414551DEB0D3D00D0F3F9 /* IterativeParseTreeWalker.h in Headers */, + 276E5DFA1CDB57AA003FF4B4 /* LexerCustomAction.h in Headers */, + 276E5FE61CDB57AA003FF4B4 /* TokenStreamRewriter.h in Headers */, + 276E5DEE1CDB57AA003FF4B4 /* LexerATNSimulator.h in Headers */, + 27DB44A61D045537007E790B /* XPathRuleElement.h in Headers */, + 276E5DD31CDB57AA003FF4B4 /* ErrorInfo.h in Headers */, + 276E5E241CDB57AA003FF4B4 /* LexerTypeAction.h in Headers */, + 276E5DE21CDB57AA003FF4B4 /* LexerActionType.h in Headers */, + 276E5D4F1CDB57AA003FF4B4 /* AmbiguityInfo.h in Headers */, + 276E5E6F1CDB57AA003FF4B4 /* PredicateTransition.h in Headers */, + 276E5EE71CDB57AA003FF4B4 /* CharStream.h in Headers */, + 276E60041CDB57AA003FF4B4 /* ParseTreeVisitor.h in Headers */, + 276E5D551CDB57AA003FF4B4 /* ArrayPredictionContext.h in Headers */, + 276E5E511CDB57AA003FF4B4 /* ParserATNSimulator.h in Headers */, + 2794D8561CE7821B00FADD0F /* antlr4-common.h in Headers */, + 276E60641CDB57AA003FF4B4 /* UnbufferedTokenStream.h in Headers */, + 276E5F681CDB57AA003FF4B4 /* IntervalSet.h in Headers */, + 276E5E631CDB57AA003FF4B4 /* PrecedencePredicateTransition.h in Headers */, + 276E5F051CDB57AA003FF4B4 /* DefaultErrorStrategy.h in Headers */, + 276E5F3B1CDB57AA003FF4B4 /* InterpreterRuleContext.h in Headers */, + 276E5F111CDB57AA003FF4B4 /* DFASerializer.h in Headers */, + 276E5F351CDB57AA003FF4B4 /* InputMismatchException.h in Headers */, + 276E5FDA1CDB57AA003FF4B4 /* TokenSource.h in Headers */, + 276E5ECF1CDB57AA003FF4B4 /* WildcardTransition.h in Headers */, + 276E600D1CDB57AA003FF4B4 /* Chunk.h in Headers */, + 276E5FB91CDB57AA003FF4B4 /* CPPUtils.h in Headers */, + 276E5EE11CDB57AA003FF4B4 /* BufferedTokenStream.h in Headers */, + 276E5DAF1CDB57AA003FF4B4 /* ContextSensitivityInfo.h in Headers */, + 276E5E001CDB57AA003FF4B4 /* LexerIndexedCustomAction.h in Headers */, + 27DB44A81D045537007E790B /* XPathTokenAnywhereElement.h in Headers */, + 276E5FD41CDB57AA003FF4B4 /* TokenFactory.h in Headers */, + 276E5EF91CDB57AA003FF4B4 /* CommonTokenStream.h in Headers */, + 27F4A8561D4CEB2A00E067EE /* Any.h in Headers */, + 276E5EB11CDB57AA003FF4B4 /* StarBlockStartState.h in Headers */, + 276E5F6E1CDB57AA003FF4B4 /* MurmurHash.h in Headers */, + 276E601F1CDB57AA003FF4B4 /* ParseTreePatternMatcher.h in Headers */, + 276E5D611CDB57AA003FF4B4 /* ATNConfig.h in Headers */, + 27DB44A21D045537007E790B /* XPathLexerErrorListener.h in Headers */, + 276E5E4B1CDB57AA003FF4B4 /* ParseInfo.h in Headers */, + 276E5F861CDB57AA003FF4B4 /* Parser.h in Headers */, + 27DB44A01D045537007E790B /* XPathElement.h in Headers */, + 276E5DBB1CDB57AA003FF4B4 /* DecisionInfo.h in Headers */, + 276E5DC11CDB57AA003FF4B4 /* DecisionState.h in Headers */, + 276E5E691CDB57AA003FF4B4 /* PredicateEvalInfo.h in Headers */, + 276E5EED1CDB57AA003FF4B4 /* CommonToken.h in Headers */, + 276E60371CDB57AA003FF4B4 /* TokenTagToken.h in Headers */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXHeadersBuildPhase section */ + +/* Begin PBXNativeTarget section */ + 270C67EF1CDB4F1E00116E17 /* antlr4_ios */ = { + isa = PBXNativeTarget; + buildConfigurationList = 270C67F71CDB4F1E00116E17 /* Build configuration list for PBXNativeTarget "antlr4_ios" */; + buildPhases = ( + 270C67EB1CDB4F1E00116E17 /* Sources */, + 270C67EC1CDB4F1E00116E17 /* Frameworks */, + 270C67ED1CDB4F1E00116E17 /* Headers */, + 270C67EE1CDB4F1E00116E17 /* Resources */, + ); + buildRules = ( + ); + dependencies = ( + ); + name = antlr4_ios; + productName = "antlrcpp-ios"; + productReference = 270C67F01CDB4F1E00116E17 /* antlr4_ios.framework */; + productType = "com.apple.product-type.framework"; + }; + 37C147161B4D5A04008EDDDB /* antlr4_static */ = { + isa = PBXNativeTarget; + buildConfigurationList = 37C147211B4D5A04008EDDDB /* Build configuration list for PBXNativeTarget "antlr4_static" */; + buildPhases = ( + 37C147131B4D5A04008EDDDB /* Sources */, + 37C147141B4D5A04008EDDDB /* Frameworks */, + 37C147151B4D5A04008EDDDB /* Headers */, + ); + buildRules = ( + ); + dependencies = ( + ); + name = antlr4_static; + productName = antlrcpp_static; + productReference = 37C147171B4D5A04008EDDDB /* libantlr4-runtime.a */; + productType = "com.apple.product-type.library.static"; + }; + 37D727A91867AF1E007B6D10 /* antlr4 */ = { + isa = PBXNativeTarget; + buildConfigurationList = 37D727B71867AF1E007B6D10 /* Build configuration list for PBXNativeTarget "antlr4" */; + buildPhases = ( + 37D727A61867AF1E007B6D10 /* Sources */, + 37D727A71867AF1E007B6D10 /* Frameworks */, + 37D727A81867AF1E007B6D10 /* Headers */, + ); + buildRules = ( + ); + dependencies = ( + ); + name = antlr4; + productName = antlrcpp; + productReference = 37D727AA1867AF1E007B6D10 /* libantlr4-runtime.dylib */; + productType = "com.apple.product-type.library.dynamic"; + }; +/* End PBXNativeTarget section */ + +/* Begin PBXProject section */ + 37D727A21867AF1E007B6D10 /* Project object */ = { + isa = PBXProject; + attributes = { + LastUpgradeCheck = 1240; + ORGANIZATIONNAME = ANTLR; + TargetAttributes = { + 270C67EF1CDB4F1E00116E17 = { + CreatedOnToolsVersion = 7.3.1; + }; + 37C147161B4D5A04008EDDDB = { + CreatedOnToolsVersion = 6.3.2; + }; + }; + }; + buildConfigurationList = 37D727A51867AF1E007B6D10 /* Build configuration list for PBXProject "antlrcpp" */; + compatibilityVersion = "Xcode 12.0"; + developmentRegion = en; + hasScannedForEncodings = 0; + knownRegions = ( + en, + Base, + ); + mainGroup = 37D727A11867AF1E007B6D10; + productRefGroup = 37D727AB1867AF1E007B6D10 /* Products */; + projectDirPath = ""; + projectRoot = ""; + targets = ( + 37D727A91867AF1E007B6D10 /* antlr4 */, + 37C147161B4D5A04008EDDDB /* antlr4_static */, + 270C67EF1CDB4F1E00116E17 /* antlr4_ios */, + ); + }; +/* End PBXProject section */ + +/* Begin PBXResourcesBuildPhase section */ + 270C67EE1CDB4F1E00116E17 /* Resources */ = { + isa = PBXResourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXResourcesBuildPhase section */ + +/* Begin PBXSourcesBuildPhase section */ + 270C67EB1CDB4F1E00116E17 /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 276E5F671CDB57AA003FF4B4 /* IntervalSet.cpp in Sources */, + 276E5D3C1CDB57AA003FF4B4 /* ANTLRInputStream.cpp in Sources */, + 276E5FC71CDB57AA003FF4B4 /* StringUtils.cpp in Sources */, + 276E5D361CDB57AA003FF4B4 /* ANTLRFileStream.cpp in Sources */, + 276E5D541CDB57AA003FF4B4 /* ArrayPredictionContext.cpp in Sources */, + 276E5F0A1CDB57AA003FF4B4 /* DFA.cpp in Sources */, + 276E5E231CDB57AA003FF4B4 /* LexerTypeAction.cpp in Sources */, + 276E5EC21CDB57AA003FF4B4 /* TokensStartState.cpp in Sources */, + 276E5DB41CDB57AA003FF4B4 /* DecisionEventInfo.cpp in Sources */, + 276E60451CDB57AA003FF4B4 /* TerminalNodeImpl.cpp in Sources */, + 276E5DD21CDB57AA003FF4B4 /* ErrorInfo.cpp in Sources */, + 276E5F551CDB57AA003FF4B4 /* LexerNoViableAltException.cpp in Sources */, + 2793DCB81F08099C00A84290 /* LexerAction.cpp in Sources */, + 276E5E561CDB57AA003FF4B4 /* PlusBlockStartState.cpp in Sources */, + 27C375861EA1059C00B5883C /* InterpreterDataReader.cpp in Sources */, + 276E5E1D1CDB57AA003FF4B4 /* LexerSkipAction.cpp in Sources */, + 276E5EBC1CDB57AA003FF4B4 /* StarLoopEntryState.cpp in Sources */, + 276E5D721CDB57AA003FF4B4 /* ATNDeserializer.cpp in Sources */, + 2793DC8B1F08087500A84290 /* Chunk.cpp in Sources */, + 276E5E2F1CDB57AA003FF4B4 /* LookaheadEventInfo.cpp in Sources */, + 276E5DFF1CDB57AA003FF4B4 /* LexerIndexedCustomAction.cpp in Sources */, + 276E60511CDB57AA003FF4B4 /* Trees.cpp in Sources */, + 276E5EB61CDB57AA003FF4B4 /* StarLoopbackState.cpp in Sources */, + 276E5E621CDB57AA003FF4B4 /* PrecedencePredicateTransition.cpp in Sources */, + 276E5E051CDB57AA003FF4B4 /* LexerModeAction.cpp in Sources */, + 276E5F491CDB57AA003FF4B4 /* Lexer.cpp in Sources */, + 276E5EDA1CDB57AA003FF4B4 /* BaseErrorListener.cpp in Sources */, + 27DB44C91D0463DB007E790B /* XPath.cpp in Sources */, + 276E5DBA1CDB57AA003FF4B4 /* DecisionInfo.cpp in Sources */, + 276E5F611CDB57AA003FF4B4 /* Interval.cpp in Sources */, + 276E5F911CDB57AA003FF4B4 /* ParserRuleContext.cpp in Sources */, + 276E5E111CDB57AA003FF4B4 /* LexerPopModeAction.cpp in Sources */, + 276E5E6E1CDB57AA003FF4B4 /* PredicateTransition.cpp in Sources */, + 276E5E7A1CDB57AA003FF4B4 /* PredictionMode.cpp in Sources */, + 276E605D1CDB57AA003FF4B4 /* UnbufferedCharStream.cpp in Sources */, + 276E5F341CDB57AA003FF4B4 /* InputMismatchException.cpp in Sources */, + 27DB44D91D0463DB007E790B /* XPathWildcardElement.cpp in Sources */, + 276E5E741CDB57AA003FF4B4 /* PredictionContext.cpp in Sources */, + 27DB44CB1D0463DB007E790B /* XPathElement.cpp in Sources */, + 276E5E171CDB57AA003FF4B4 /* LexerPushModeAction.cpp in Sources */, + 276E5DA21CDB57AA003FF4B4 /* BlockEndState.cpp in Sources */, + 276E5EF21CDB57AA003FF4B4 /* CommonTokenFactory.cpp in Sources */, + 276E5DF31CDB57AA003FF4B4 /* LexerChannelAction.cpp in Sources */, + 276E5E921CDB57AA003FF4B4 /* RuleStopState.cpp in Sources */, + 276E60631CDB57AA003FF4B4 /* UnbufferedTokenStream.cpp in Sources */, + 276E5DDB1CDB57AA003FF4B4 /* LexerActionExecutor.cpp in Sources */, + 2793DC981F0808E100A84290 /* ErrorNode.cpp in Sources */, + 2793DCAF1F08095F00A84290 /* WritableToken.cpp in Sources */, + 276E5E9E1CDB57AA003FF4B4 /* SemanticContext.cpp in Sources */, + 276E5EC81CDB57AA003FF4B4 /* Transition.cpp in Sources */, + 276E601E1CDB57AA003FF4B4 /* ParseTreePatternMatcher.cpp in Sources */, + 276E5F221CDB57AA003FF4B4 /* DiagnosticErrorListener.cpp in Sources */, + 276E5D481CDB57AA003FF4B4 /* ActionTransition.cpp in Sources */, + 276E5DC61CDB57AA003FF4B4 /* EmptyPredictionContext.cpp in Sources */, + 276E5ED41CDB57AA003FF4B4 /* BailErrorStrategy.cpp in Sources */, + 2793DC9B1F0808E100A84290 /* ParseTreeVisitor.cpp in Sources */, + 2793DCAC1F08095F00A84290 /* Token.cpp in Sources */, + 276E5FA31CDB57AA003FF4B4 /* Recognizer.cpp in Sources */, + 276E5D6C1CDB57AA003FF4B4 /* ATNDeserializationOptions.cpp in Sources */, + 276E60361CDB57AA003FF4B4 /* TokenTagToken.cpp in Sources */, + 27DB44D51D0463DB007E790B /* XPathTokenElement.cpp in Sources */, + 27DB44D11D0463DB007E790B /* XPathRuleElement.cpp in Sources */, + 276E5DED1CDB57AA003FF4B4 /* LexerATNSimulator.cpp in Sources */, + 2793DCB51F08099C00A84290 /* BlockStartState.cpp in Sources */, + 276E606C1CDB57AA003FF4B4 /* Vocabulary.cpp in Sources */, + 276E5F1C1CDB57AA003FF4B4 /* LexerDFASerializer.cpp in Sources */, + 276E60181CDB57AA003FF4B4 /* ParseTreePattern.cpp in Sources */, + 276E5DE71CDB57AA003FF4B4 /* LexerATNConfig.cpp in Sources */, + 27B36AC81DACE7AF0069C868 /* RuleContextWithAltNum.cpp in Sources */, + 276E5F101CDB57AA003FF4B4 /* DFASerializer.cpp in Sources */, + 276E5F2E1CDB57AA003FF4B4 /* FailedPredicateException.cpp in Sources */, + 27D414541DEB0D3D00D0F3F9 /* IterativeParseTreeWalker.cpp in Sources */, + 276E5F8B1CDB57AA003FF4B4 /* ParserInterpreter.cpp in Sources */, + 276E5D4E1CDB57AA003FF4B4 /* AmbiguityInfo.cpp in Sources */, + 276E5F161CDB57AA003FF4B4 /* DFAState.cpp in Sources */, + 276E60091CDB57AA003FF4B4 /* ParseTreeWalker.cpp in Sources */, + 27DB44CD1D0463DB007E790B /* XPathLexerErrorListener.cpp in Sources */, + 276E5F9D1CDB57AA003FF4B4 /* RecognitionException.cpp in Sources */, + 276E5E8C1CDB57AA003FF4B4 /* RuleStartState.cpp in Sources */, + 276E5EA41CDB57AA003FF4B4 /* SetTransition.cpp in Sources */, + 276E5D841CDB57AA003FF4B4 /* ATNState.cpp in Sources */, + 276E60241CDB57AA003FF4B4 /* RuleTagToken.cpp in Sources */, + 276E5E501CDB57AA003FF4B4 /* ParserATNSimulator.cpp in Sources */, + 276E602A1CDB57AA003FF4B4 /* TagChunk.cpp in Sources */, + 276E5F7F1CDB57AA003FF4B4 /* NoViableAltException.cpp in Sources */, + 276E5D781CDB57AA003FF4B4 /* ATNSerializer.cpp in Sources */, + 27745F051CE49C000067C6A3 /* RuntimeMetaData.cpp in Sources */, + 276E5DAE1CDB57AA003FF4B4 /* ContextSensitivityInfo.cpp in Sources */, + 2793DCA61F08095F00A84290 /* ANTLRErrorListener.cpp in Sources */, + 276E5D661CDB57AA003FF4B4 /* ATNConfigSet.cpp in Sources */, + 2793DC9F1F08090D00A84290 /* Any.cpp in Sources */, + 276E5FAF1CDB57AA003FF4B4 /* Arrays.cpp in Sources */, + 276E5ECE1CDB57AA003FF4B4 /* WildcardTransition.cpp in Sources */, + 276E5E861CDB57AA003FF4B4 /* RangeTransition.cpp in Sources */, + 276E5D7E1CDB57AA003FF4B4 /* ATNSimulator.cpp in Sources */, + 276E5D9C1CDB57AA003FF4B4 /* BasicState.cpp in Sources */, + 276E5FC11CDB57AA003FF4B4 /* guid.cpp in Sources */, + 276E5E801CDB57AA003FF4B4 /* ProfilingATNSimulator.cpp in Sources */, + 2793DCA91F08095F00A84290 /* ANTLRErrorStrategy.cpp in Sources */, + 276E5F401CDB57AA003FF4B4 /* IntStream.cpp in Sources */, + 276E5F5B1CDB57AA003FF4B4 /* ListTokenSource.cpp in Sources */, + 276E5F6D1CDB57AA003FF4B4 /* MurmurHash.cpp in Sources */, + 276E5FDF1CDB57AA003FF4B4 /* TokenStream.cpp in Sources */, + 276E5FF11CDB57AA003FF4B4 /* ErrorNodeImpl.cpp in Sources */, + 27DB44D71D0463DB007E790B /* XPathWildcardAnywhereElement.cpp in Sources */, + 276E5D961CDB57AA003FF4B4 /* BasicBlockStartState.cpp in Sources */, + 276E5E4A1CDB57AA003FF4B4 /* ParseInfo.cpp in Sources */, + 276E5E3E1CDB57AA003FF4B4 /* NotSetTransition.cpp in Sources */, + 27DB44B31D0463CC007E790B /* XPathLexer.cpp in Sources */, + 276E60301CDB57AA003FF4B4 /* TextChunk.cpp in Sources */, + 27DB44CF1D0463DB007E790B /* XPathRuleAnywhereElement.cpp in Sources */, + 276E5E441CDB57AA003FF4B4 /* OrderedATNConfigSet.cpp in Sources */, + 276E5DCC1CDB57AA003FF4B4 /* EpsilonTransition.cpp in Sources */, + 2793DC8F1F08088F00A84290 /* ParseTreeListener.cpp in Sources */, + 276E5D5A1CDB57AA003FF4B4 /* ATN.cpp in Sources */, + 276E5EE61CDB57AA003FF4B4 /* CharStream.cpp in Sources */, + 276E5EE01CDB57AA003FF4B4 /* BufferedTokenStream.cpp in Sources */, + 276E5F041CDB57AA003FF4B4 /* DefaultErrorStrategy.cpp in Sources */, + 276E5D421CDB57AA003FF4B4 /* AbstractPredicateTransition.cpp in Sources */, + 276E5E5C1CDB57AA003FF4B4 /* PlusLoopbackState.cpp in Sources */, + 276E5E351CDB57AA003FF4B4 /* LoopEndState.cpp in Sources */, + 276E5FE51CDB57AA003FF4B4 /* TokenStreamRewriter.cpp in Sources */, + 276E5FA91CDB57AA003FF4B4 /* RuleContext.cpp in Sources */, + 276E5D601CDB57AA003FF4B4 /* ATNConfig.cpp in Sources */, + 276E5EFE1CDB57AA003FF4B4 /* ConsoleErrorListener.cpp in Sources */, + 276E5EAA1CDB57AA003FF4B4 /* SingletonPredictionContext.cpp in Sources */, + 276E5E681CDB57AA003FF4B4 /* PredicateEvalInfo.cpp in Sources */, + 276E5F281CDB57AA003FF4B4 /* Exceptions.cpp in Sources */, + 276E5F851CDB57AA003FF4B4 /* Parser.cpp in Sources */, + 276E5DC01CDB57AA003FF4B4 /* DecisionState.cpp in Sources */, + 276E5E981CDB57AA003FF4B4 /* RuleTransition.cpp in Sources */, + 276E5EF81CDB57AA003FF4B4 /* CommonTokenStream.cpp in Sources */, + 2793DC871F08083F00A84290 /* TokenSource.cpp in Sources */, + 2793DC931F0808A200A84290 /* TerminalNode.cpp in Sources */, + 276E60121CDB57AA003FF4B4 /* ParseTreeMatch.cpp in Sources */, + 276566E21DA93BFB000869BE /* ParseTree.cpp in Sources */, + 276E5EEC1CDB57AA003FF4B4 /* CommonToken.cpp in Sources */, + 276E5D901CDB57AA003FF4B4 /* AtomTransition.cpp in Sources */, + 276E5E0B1CDB57AA003FF4B4 /* LexerMoreAction.cpp in Sources */, + 276E5F3A1CDB57AA003FF4B4 /* InterpreterRuleContext.cpp in Sources */, + 276E5F971CDB57AA003FF4B4 /* ProxyErrorListener.cpp in Sources */, + 276E5DF91CDB57AA003FF4B4 /* LexerCustomAction.cpp in Sources */, + 276E5F4F1CDB57AA003FF4B4 /* LexerInterpreter.cpp in Sources */, + 276E5E291CDB57AA003FF4B4 /* LL1Analyzer.cpp in Sources */, + 276E5EB01CDB57AA003FF4B4 /* StarBlockStartState.cpp in Sources */, + 27DB44D31D0463DB007E790B /* XPathTokenAnywhereElement.cpp in Sources */, + 276E5FB81CDB57AA003FF4B4 /* CPPUtils.cpp in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 37C147131B4D5A04008EDDDB /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 276E5F661CDB57AA003FF4B4 /* IntervalSet.cpp in Sources */, + 276E5D3B1CDB57AA003FF4B4 /* ANTLRInputStream.cpp in Sources */, + 276E5FC61CDB57AA003FF4B4 /* StringUtils.cpp in Sources */, + 276E5D351CDB57AA003FF4B4 /* ANTLRFileStream.cpp in Sources */, + 276E5D531CDB57AA003FF4B4 /* ArrayPredictionContext.cpp in Sources */, + 276E5F091CDB57AA003FF4B4 /* DFA.cpp in Sources */, + 276E5E221CDB57AA003FF4B4 /* LexerTypeAction.cpp in Sources */, + 276E5EC11CDB57AA003FF4B4 /* TokensStartState.cpp in Sources */, + 276E5DB31CDB57AA003FF4B4 /* DecisionEventInfo.cpp in Sources */, + 276E60441CDB57AA003FF4B4 /* TerminalNodeImpl.cpp in Sources */, + 276E5DD11CDB57AA003FF4B4 /* ErrorInfo.cpp in Sources */, + 276E5F541CDB57AA003FF4B4 /* LexerNoViableAltException.cpp in Sources */, + 2793DCB71F08099C00A84290 /* LexerAction.cpp in Sources */, + 276E5E551CDB57AA003FF4B4 /* PlusBlockStartState.cpp in Sources */, + 27C375851EA1059C00B5883C /* InterpreterDataReader.cpp in Sources */, + 276E5E1C1CDB57AA003FF4B4 /* LexerSkipAction.cpp in Sources */, + 276E5EBB1CDB57AA003FF4B4 /* StarLoopEntryState.cpp in Sources */, + 276E5D711CDB57AA003FF4B4 /* ATNDeserializer.cpp in Sources */, + 2793DC8A1F08087500A84290 /* Chunk.cpp in Sources */, + 276E5E2E1CDB57AA003FF4B4 /* LookaheadEventInfo.cpp in Sources */, + 276E5DFE1CDB57AA003FF4B4 /* LexerIndexedCustomAction.cpp in Sources */, + 276E60501CDB57AA003FF4B4 /* Trees.cpp in Sources */, + 276E5EB51CDB57AA003FF4B4 /* StarLoopbackState.cpp in Sources */, + 276E5E611CDB57AA003FF4B4 /* PrecedencePredicateTransition.cpp in Sources */, + 276E5E041CDB57AA003FF4B4 /* LexerModeAction.cpp in Sources */, + 276E5F481CDB57AA003FF4B4 /* Lexer.cpp in Sources */, + 276E5ED91CDB57AA003FF4B4 /* BaseErrorListener.cpp in Sources */, + 27DB44B71D0463DA007E790B /* XPath.cpp in Sources */, + 276E5DB91CDB57AA003FF4B4 /* DecisionInfo.cpp in Sources */, + 276E5F601CDB57AA003FF4B4 /* Interval.cpp in Sources */, + 276E5F901CDB57AA003FF4B4 /* ParserRuleContext.cpp in Sources */, + 276E5E101CDB57AA003FF4B4 /* LexerPopModeAction.cpp in Sources */, + 276E5E6D1CDB57AA003FF4B4 /* PredicateTransition.cpp in Sources */, + 276E5E791CDB57AA003FF4B4 /* PredictionMode.cpp in Sources */, + 276E605C1CDB57AA003FF4B4 /* UnbufferedCharStream.cpp in Sources */, + 276E5F331CDB57AA003FF4B4 /* InputMismatchException.cpp in Sources */, + 27DB44C71D0463DA007E790B /* XPathWildcardElement.cpp in Sources */, + 276E5E731CDB57AA003FF4B4 /* PredictionContext.cpp in Sources */, + 27DB44B91D0463DA007E790B /* XPathElement.cpp in Sources */, + 276E5E161CDB57AA003FF4B4 /* LexerPushModeAction.cpp in Sources */, + 276E5DA11CDB57AA003FF4B4 /* BlockEndState.cpp in Sources */, + 276E5EF11CDB57AA003FF4B4 /* CommonTokenFactory.cpp in Sources */, + 276E5DF21CDB57AA003FF4B4 /* LexerChannelAction.cpp in Sources */, + 276E5E911CDB57AA003FF4B4 /* RuleStopState.cpp in Sources */, + 276E60621CDB57AA003FF4B4 /* UnbufferedTokenStream.cpp in Sources */, + 276E5DDA1CDB57AA003FF4B4 /* LexerActionExecutor.cpp in Sources */, + 2793DC971F0808E100A84290 /* ErrorNode.cpp in Sources */, + 2793DCAE1F08095F00A84290 /* WritableToken.cpp in Sources */, + 276E5E9D1CDB57AA003FF4B4 /* SemanticContext.cpp in Sources */, + 276E5EC71CDB57AA003FF4B4 /* Transition.cpp in Sources */, + 276E601D1CDB57AA003FF4B4 /* ParseTreePatternMatcher.cpp in Sources */, + 276E5F211CDB57AA003FF4B4 /* DiagnosticErrorListener.cpp in Sources */, + 276E5D471CDB57AA003FF4B4 /* ActionTransition.cpp in Sources */, + 276E5DC51CDB57AA003FF4B4 /* EmptyPredictionContext.cpp in Sources */, + 276E5ED31CDB57AA003FF4B4 /* BailErrorStrategy.cpp in Sources */, + 2793DC9A1F0808E100A84290 /* ParseTreeVisitor.cpp in Sources */, + 2793DCAB1F08095F00A84290 /* Token.cpp in Sources */, + 276E5FA21CDB57AA003FF4B4 /* Recognizer.cpp in Sources */, + 276E5D6B1CDB57AA003FF4B4 /* ATNDeserializationOptions.cpp in Sources */, + 276E60351CDB57AA003FF4B4 /* TokenTagToken.cpp in Sources */, + 27DB44C31D0463DA007E790B /* XPathTokenElement.cpp in Sources */, + 27DB44BF1D0463DA007E790B /* XPathRuleElement.cpp in Sources */, + 276E5DEC1CDB57AA003FF4B4 /* LexerATNSimulator.cpp in Sources */, + 2793DCB41F08099C00A84290 /* BlockStartState.cpp in Sources */, + 276E606B1CDB57AA003FF4B4 /* Vocabulary.cpp in Sources */, + 276E5F1B1CDB57AA003FF4B4 /* LexerDFASerializer.cpp in Sources */, + 276E60171CDB57AA003FF4B4 /* ParseTreePattern.cpp in Sources */, + 276E5DE61CDB57AA003FF4B4 /* LexerATNConfig.cpp in Sources */, + 27B36AC71DACE7AF0069C868 /* RuleContextWithAltNum.cpp in Sources */, + 276E5F0F1CDB57AA003FF4B4 /* DFASerializer.cpp in Sources */, + 276E5F2D1CDB57AA003FF4B4 /* FailedPredicateException.cpp in Sources */, + 27D414531DEB0D3D00D0F3F9 /* IterativeParseTreeWalker.cpp in Sources */, + 276E5F8A1CDB57AA003FF4B4 /* ParserInterpreter.cpp in Sources */, + 276E5D4D1CDB57AA003FF4B4 /* AmbiguityInfo.cpp in Sources */, + 276E5F151CDB57AA003FF4B4 /* DFAState.cpp in Sources */, + 276E60081CDB57AA003FF4B4 /* ParseTreeWalker.cpp in Sources */, + 27DB44BB1D0463DA007E790B /* XPathLexerErrorListener.cpp in Sources */, + 276E5F9C1CDB57AA003FF4B4 /* RecognitionException.cpp in Sources */, + 276E5E8B1CDB57AA003FF4B4 /* RuleStartState.cpp in Sources */, + 276E5EA31CDB57AA003FF4B4 /* SetTransition.cpp in Sources */, + 276E5D831CDB57AA003FF4B4 /* ATNState.cpp in Sources */, + 276E60231CDB57AA003FF4B4 /* RuleTagToken.cpp in Sources */, + 276E5E4F1CDB57AA003FF4B4 /* ParserATNSimulator.cpp in Sources */, + 276E60291CDB57AA003FF4B4 /* TagChunk.cpp in Sources */, + 276E5F7E1CDB57AA003FF4B4 /* NoViableAltException.cpp in Sources */, + 276E5D771CDB57AA003FF4B4 /* ATNSerializer.cpp in Sources */, + 27745F041CE49C000067C6A3 /* RuntimeMetaData.cpp in Sources */, + 276E5DAD1CDB57AA003FF4B4 /* ContextSensitivityInfo.cpp in Sources */, + 2793DCA51F08095F00A84290 /* ANTLRErrorListener.cpp in Sources */, + 276E5D651CDB57AA003FF4B4 /* ATNConfigSet.cpp in Sources */, + 2793DC9E1F08090D00A84290 /* Any.cpp in Sources */, + 276E5FAE1CDB57AA003FF4B4 /* Arrays.cpp in Sources */, + 276E5ECD1CDB57AA003FF4B4 /* WildcardTransition.cpp in Sources */, + 276E5E851CDB57AA003FF4B4 /* RangeTransition.cpp in Sources */, + 276E5D7D1CDB57AA003FF4B4 /* ATNSimulator.cpp in Sources */, + 276E5D9B1CDB57AA003FF4B4 /* BasicState.cpp in Sources */, + 276E5FC01CDB57AA003FF4B4 /* guid.cpp in Sources */, + 276E5E7F1CDB57AA003FF4B4 /* ProfilingATNSimulator.cpp in Sources */, + 2793DCA81F08095F00A84290 /* ANTLRErrorStrategy.cpp in Sources */, + 276E5F3F1CDB57AA003FF4B4 /* IntStream.cpp in Sources */, + 276E5F5A1CDB57AA003FF4B4 /* ListTokenSource.cpp in Sources */, + 276E5F6C1CDB57AA003FF4B4 /* MurmurHash.cpp in Sources */, + 276E5FDE1CDB57AA003FF4B4 /* TokenStream.cpp in Sources */, + 276E5FF01CDB57AA003FF4B4 /* ErrorNodeImpl.cpp in Sources */, + 27DB44C51D0463DA007E790B /* XPathWildcardAnywhereElement.cpp in Sources */, + 276E5D951CDB57AA003FF4B4 /* BasicBlockStartState.cpp in Sources */, + 276E5E491CDB57AA003FF4B4 /* ParseInfo.cpp in Sources */, + 276E5E3D1CDB57AA003FF4B4 /* NotSetTransition.cpp in Sources */, + 27DB44B21D0463CC007E790B /* XPathLexer.cpp in Sources */, + 276E602F1CDB57AA003FF4B4 /* TextChunk.cpp in Sources */, + 27DB44BD1D0463DA007E790B /* XPathRuleAnywhereElement.cpp in Sources */, + 276E5E431CDB57AA003FF4B4 /* OrderedATNConfigSet.cpp in Sources */, + 276E5DCB1CDB57AA003FF4B4 /* EpsilonTransition.cpp in Sources */, + 2793DC8E1F08088F00A84290 /* ParseTreeListener.cpp in Sources */, + 276E5D591CDB57AA003FF4B4 /* ATN.cpp in Sources */, + 276E5EE51CDB57AA003FF4B4 /* CharStream.cpp in Sources */, + 276E5EDF1CDB57AA003FF4B4 /* BufferedTokenStream.cpp in Sources */, + 276E5F031CDB57AA003FF4B4 /* DefaultErrorStrategy.cpp in Sources */, + 276E5D411CDB57AA003FF4B4 /* AbstractPredicateTransition.cpp in Sources */, + 276E5E5B1CDB57AA003FF4B4 /* PlusLoopbackState.cpp in Sources */, + 276E5E341CDB57AA003FF4B4 /* LoopEndState.cpp in Sources */, + 276E5FE41CDB57AA003FF4B4 /* TokenStreamRewriter.cpp in Sources */, + 276E5FA81CDB57AA003FF4B4 /* RuleContext.cpp in Sources */, + 276E5D5F1CDB57AA003FF4B4 /* ATNConfig.cpp in Sources */, + 276E5EFD1CDB57AA003FF4B4 /* ConsoleErrorListener.cpp in Sources */, + 276E5EA91CDB57AA003FF4B4 /* SingletonPredictionContext.cpp in Sources */, + 276E5E671CDB57AA003FF4B4 /* PredicateEvalInfo.cpp in Sources */, + 276E5F271CDB57AA003FF4B4 /* Exceptions.cpp in Sources */, + 276E5F841CDB57AA003FF4B4 /* Parser.cpp in Sources */, + 276E5DBF1CDB57AA003FF4B4 /* DecisionState.cpp in Sources */, + 276E5E971CDB57AA003FF4B4 /* RuleTransition.cpp in Sources */, + 276E5EF71CDB57AA003FF4B4 /* CommonTokenStream.cpp in Sources */, + 2793DC861F08083F00A84290 /* TokenSource.cpp in Sources */, + 2793DC921F0808A200A84290 /* TerminalNode.cpp in Sources */, + 276E60111CDB57AA003FF4B4 /* ParseTreeMatch.cpp in Sources */, + 276566E11DA93BFB000869BE /* ParseTree.cpp in Sources */, + 276E5EEB1CDB57AA003FF4B4 /* CommonToken.cpp in Sources */, + 276E5D8F1CDB57AA003FF4B4 /* AtomTransition.cpp in Sources */, + 276E5E0A1CDB57AA003FF4B4 /* LexerMoreAction.cpp in Sources */, + 276E5F391CDB57AA003FF4B4 /* InterpreterRuleContext.cpp in Sources */, + 276E5F961CDB57AA003FF4B4 /* ProxyErrorListener.cpp in Sources */, + 276E5DF81CDB57AA003FF4B4 /* LexerCustomAction.cpp in Sources */, + 276E5F4E1CDB57AA003FF4B4 /* LexerInterpreter.cpp in Sources */, + 276E5E281CDB57AA003FF4B4 /* LL1Analyzer.cpp in Sources */, + 276E5EAF1CDB57AA003FF4B4 /* StarBlockStartState.cpp in Sources */, + 27DB44C11D0463DA007E790B /* XPathTokenAnywhereElement.cpp in Sources */, + 276E5FB71CDB57AA003FF4B4 /* CPPUtils.cpp in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 37D727A61867AF1E007B6D10 /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 276E5F651CDB57AA003FF4B4 /* IntervalSet.cpp in Sources */, + 276E5D3A1CDB57AA003FF4B4 /* ANTLRInputStream.cpp in Sources */, + 276E5FC51CDB57AA003FF4B4 /* StringUtils.cpp in Sources */, + 276E5D341CDB57AA003FF4B4 /* ANTLRFileStream.cpp in Sources */, + 276E5D521CDB57AA003FF4B4 /* ArrayPredictionContext.cpp in Sources */, + 276E5F081CDB57AA003FF4B4 /* DFA.cpp in Sources */, + 276E5E211CDB57AA003FF4B4 /* LexerTypeAction.cpp in Sources */, + 27DB449F1D045537007E790B /* XPathElement.cpp in Sources */, + 276E5EC01CDB57AA003FF4B4 /* TokensStartState.cpp in Sources */, + 276E5DB21CDB57AA003FF4B4 /* DecisionEventInfo.cpp in Sources */, + 276E60431CDB57AA003FF4B4 /* TerminalNodeImpl.cpp in Sources */, + 276E5DD01CDB57AA003FF4B4 /* ErrorInfo.cpp in Sources */, + 2793DCB61F08099C00A84290 /* LexerAction.cpp in Sources */, + 276E5F531CDB57AA003FF4B4 /* LexerNoViableAltException.cpp in Sources */, + 27C375841EA1059C00B5883C /* InterpreterDataReader.cpp in Sources */, + 276E5E541CDB57AA003FF4B4 /* PlusBlockStartState.cpp in Sources */, + 276E5E1B1CDB57AA003FF4B4 /* LexerSkipAction.cpp in Sources */, + 276E5EBA1CDB57AA003FF4B4 /* StarLoopEntryState.cpp in Sources */, + 2793DC891F08087500A84290 /* Chunk.cpp in Sources */, + 276E5D701CDB57AA003FF4B4 /* ATNDeserializer.cpp in Sources */, + 276E5E2D1CDB57AA003FF4B4 /* LookaheadEventInfo.cpp in Sources */, + 276E5DFD1CDB57AA003FF4B4 /* LexerIndexedCustomAction.cpp in Sources */, + 276E604F1CDB57AA003FF4B4 /* Trees.cpp in Sources */, + 276E5EB41CDB57AA003FF4B4 /* StarLoopbackState.cpp in Sources */, + 276E5E601CDB57AA003FF4B4 /* PrecedencePredicateTransition.cpp in Sources */, + 27DB44A31D045537007E790B /* XPathRuleAnywhereElement.cpp in Sources */, + 276E5E031CDB57AA003FF4B4 /* LexerModeAction.cpp in Sources */, + 276E5F471CDB57AA003FF4B4 /* Lexer.cpp in Sources */, + 276E5ED81CDB57AA003FF4B4 /* BaseErrorListener.cpp in Sources */, + 276E5DB81CDB57AA003FF4B4 /* DecisionInfo.cpp in Sources */, + 276E5F5F1CDB57AA003FF4B4 /* Interval.cpp in Sources */, + 276E5F8F1CDB57AA003FF4B4 /* ParserRuleContext.cpp in Sources */, + 276E5E0F1CDB57AA003FF4B4 /* LexerPopModeAction.cpp in Sources */, + 276E5E6C1CDB57AA003FF4B4 /* PredicateTransition.cpp in Sources */, + 276E5E781CDB57AA003FF4B4 /* PredictionMode.cpp in Sources */, + 276E605B1CDB57AA003FF4B4 /* UnbufferedCharStream.cpp in Sources */, + 276E5F321CDB57AA003FF4B4 /* InputMismatchException.cpp in Sources */, + 276E5E721CDB57AA003FF4B4 /* PredictionContext.cpp in Sources */, + 276E5E151CDB57AA003FF4B4 /* LexerPushModeAction.cpp in Sources */, + 276E5DA01CDB57AA003FF4B4 /* BlockEndState.cpp in Sources */, + 276E5EF01CDB57AA003FF4B4 /* CommonTokenFactory.cpp in Sources */, + 276E5DF11CDB57AA003FF4B4 /* LexerChannelAction.cpp in Sources */, + 276E5E901CDB57AA003FF4B4 /* RuleStopState.cpp in Sources */, + 276E60611CDB57AA003FF4B4 /* UnbufferedTokenStream.cpp in Sources */, + 276E5DD91CDB57AA003FF4B4 /* LexerActionExecutor.cpp in Sources */, + 27DB449D1D045537007E790B /* XPath.cpp in Sources */, + 2793DC961F0808E100A84290 /* ErrorNode.cpp in Sources */, + 2793DCAD1F08095F00A84290 /* WritableToken.cpp in Sources */, + 276E5E9C1CDB57AA003FF4B4 /* SemanticContext.cpp in Sources */, + 27DB44AD1D045537007E790B /* XPathWildcardElement.cpp in Sources */, + 276E5EC61CDB57AA003FF4B4 /* Transition.cpp in Sources */, + 276E601C1CDB57AA003FF4B4 /* ParseTreePatternMatcher.cpp in Sources */, + 27DB44A51D045537007E790B /* XPathRuleElement.cpp in Sources */, + 276E5F201CDB57AA003FF4B4 /* DiagnosticErrorListener.cpp in Sources */, + 276E5D461CDB57AA003FF4B4 /* ActionTransition.cpp in Sources */, + 2793DC991F0808E100A84290 /* ParseTreeVisitor.cpp in Sources */, + 2793DCAA1F08095F00A84290 /* Token.cpp in Sources */, + 276E5DC41CDB57AA003FF4B4 /* EmptyPredictionContext.cpp in Sources */, + 276E5ED21CDB57AA003FF4B4 /* BailErrorStrategy.cpp in Sources */, + 276E5FA11CDB57AA003FF4B4 /* Recognizer.cpp in Sources */, + 276E5D6A1CDB57AA003FF4B4 /* ATNDeserializationOptions.cpp in Sources */, + 276E60341CDB57AA003FF4B4 /* TokenTagToken.cpp in Sources */, + 276E5DEB1CDB57AA003FF4B4 /* LexerATNSimulator.cpp in Sources */, + 2793DCB31F08099C00A84290 /* BlockStartState.cpp in Sources */, + 276E606A1CDB57AA003FF4B4 /* Vocabulary.cpp in Sources */, + 276E5F1A1CDB57AA003FF4B4 /* LexerDFASerializer.cpp in Sources */, + 276E60161CDB57AA003FF4B4 /* ParseTreePattern.cpp in Sources */, + 276E5DE51CDB57AA003FF4B4 /* LexerATNConfig.cpp in Sources */, + 27B36AC61DACE7AF0069C868 /* RuleContextWithAltNum.cpp in Sources */, + 276E5F0E1CDB57AA003FF4B4 /* DFASerializer.cpp in Sources */, + 276E5F2C1CDB57AA003FF4B4 /* FailedPredicateException.cpp in Sources */, + 27D414521DEB0D3D00D0F3F9 /* IterativeParseTreeWalker.cpp in Sources */, + 27DB44A71D045537007E790B /* XPathTokenAnywhereElement.cpp in Sources */, + 276E5F891CDB57AA003FF4B4 /* ParserInterpreter.cpp in Sources */, + 276E5D4C1CDB57AA003FF4B4 /* AmbiguityInfo.cpp in Sources */, + 276E5F141CDB57AA003FF4B4 /* DFAState.cpp in Sources */, + 276E60071CDB57AA003FF4B4 /* ParseTreeWalker.cpp in Sources */, + 276E5F9B1CDB57AA003FF4B4 /* RecognitionException.cpp in Sources */, + 276E5E8A1CDB57AA003FF4B4 /* RuleStartState.cpp in Sources */, + 276E5EA21CDB57AA003FF4B4 /* SetTransition.cpp in Sources */, + 276E5D821CDB57AA003FF4B4 /* ATNState.cpp in Sources */, + 276E60221CDB57AA003FF4B4 /* RuleTagToken.cpp in Sources */, + 276E5E4E1CDB57AA003FF4B4 /* ParserATNSimulator.cpp in Sources */, + 276E60281CDB57AA003FF4B4 /* TagChunk.cpp in Sources */, + 276E5F7D1CDB57AA003FF4B4 /* NoViableAltException.cpp in Sources */, + 276E5D761CDB57AA003FF4B4 /* ATNSerializer.cpp in Sources */, + 27745F031CE49C000067C6A3 /* RuntimeMetaData.cpp in Sources */, + 276E5DAC1CDB57AA003FF4B4 /* ContextSensitivityInfo.cpp in Sources */, + 2793DCA41F08095F00A84290 /* ANTLRErrorListener.cpp in Sources */, + 276E5D641CDB57AA003FF4B4 /* ATNConfigSet.cpp in Sources */, + 2793DC9D1F08090D00A84290 /* Any.cpp in Sources */, + 276E5FAD1CDB57AA003FF4B4 /* Arrays.cpp in Sources */, + 276E5ECC1CDB57AA003FF4B4 /* WildcardTransition.cpp in Sources */, + 276E5E841CDB57AA003FF4B4 /* RangeTransition.cpp in Sources */, + 276E5D7C1CDB57AA003FF4B4 /* ATNSimulator.cpp in Sources */, + 276E5D9A1CDB57AA003FF4B4 /* BasicState.cpp in Sources */, + 276E5FBF1CDB57AA003FF4B4 /* guid.cpp in Sources */, + 276E5E7E1CDB57AA003FF4B4 /* ProfilingATNSimulator.cpp in Sources */, + 2793DCA71F08095F00A84290 /* ANTLRErrorStrategy.cpp in Sources */, + 276E5F3E1CDB57AA003FF4B4 /* IntStream.cpp in Sources */, + 276E5F591CDB57AA003FF4B4 /* ListTokenSource.cpp in Sources */, + 276E5F6B1CDB57AA003FF4B4 /* MurmurHash.cpp in Sources */, + 276E5FDD1CDB57AA003FF4B4 /* TokenStream.cpp in Sources */, + 276E5FEF1CDB57AA003FF4B4 /* ErrorNodeImpl.cpp in Sources */, + 276E5D941CDB57AA003FF4B4 /* BasicBlockStartState.cpp in Sources */, + 276E5E481CDB57AA003FF4B4 /* ParseInfo.cpp in Sources */, + 276E5E3C1CDB57AA003FF4B4 /* NotSetTransition.cpp in Sources */, + 276E602E1CDB57AA003FF4B4 /* TextChunk.cpp in Sources */, + 276E5E421CDB57AA003FF4B4 /* OrderedATNConfigSet.cpp in Sources */, + 276E5DCA1CDB57AA003FF4B4 /* EpsilonTransition.cpp in Sources */, + 276E5D581CDB57AA003FF4B4 /* ATN.cpp in Sources */, + 276E5EE41CDB57AA003FF4B4 /* CharStream.cpp in Sources */, + 27DB44AB1D045537007E790B /* XPathWildcardAnywhereElement.cpp in Sources */, + 2793DC8D1F08088F00A84290 /* ParseTreeListener.cpp in Sources */, + 276E5EDE1CDB57AA003FF4B4 /* BufferedTokenStream.cpp in Sources */, + 276E5F021CDB57AA003FF4B4 /* DefaultErrorStrategy.cpp in Sources */, + 276E5D401CDB57AA003FF4B4 /* AbstractPredicateTransition.cpp in Sources */, + 276E5E5A1CDB57AA003FF4B4 /* PlusLoopbackState.cpp in Sources */, + 276E5E331CDB57AA003FF4B4 /* LoopEndState.cpp in Sources */, + 276E5FE31CDB57AA003FF4B4 /* TokenStreamRewriter.cpp in Sources */, + 27DB44A11D045537007E790B /* XPathLexerErrorListener.cpp in Sources */, + 276E5FA71CDB57AA003FF4B4 /* RuleContext.cpp in Sources */, + 27DB44B11D0463CC007E790B /* XPathLexer.cpp in Sources */, + 276E5D5E1CDB57AA003FF4B4 /* ATNConfig.cpp in Sources */, + 276E5EFC1CDB57AA003FF4B4 /* ConsoleErrorListener.cpp in Sources */, + 276E5EA81CDB57AA003FF4B4 /* SingletonPredictionContext.cpp in Sources */, + 276E5E661CDB57AA003FF4B4 /* PredicateEvalInfo.cpp in Sources */, + 276E5F261CDB57AA003FF4B4 /* Exceptions.cpp in Sources */, + 276E5F831CDB57AA003FF4B4 /* Parser.cpp in Sources */, + 276E5DBE1CDB57AA003FF4B4 /* DecisionState.cpp in Sources */, + 276E5E961CDB57AA003FF4B4 /* RuleTransition.cpp in Sources */, + 276E5EF61CDB57AA003FF4B4 /* CommonTokenStream.cpp in Sources */, + 2793DC851F08083F00A84290 /* TokenSource.cpp in Sources */, + 2793DC911F0808A200A84290 /* TerminalNode.cpp in Sources */, + 276E60101CDB57AA003FF4B4 /* ParseTreeMatch.cpp in Sources */, + 276566E01DA93BFB000869BE /* ParseTree.cpp in Sources */, + 276E5EEA1CDB57AA003FF4B4 /* CommonToken.cpp in Sources */, + 276E5D8E1CDB57AA003FF4B4 /* AtomTransition.cpp in Sources */, + 276E5E091CDB57AA003FF4B4 /* LexerMoreAction.cpp in Sources */, + 276E5F381CDB57AA003FF4B4 /* InterpreterRuleContext.cpp in Sources */, + 276E5F951CDB57AA003FF4B4 /* ProxyErrorListener.cpp in Sources */, + 276E5DF71CDB57AA003FF4B4 /* LexerCustomAction.cpp in Sources */, + 276E5F4D1CDB57AA003FF4B4 /* LexerInterpreter.cpp in Sources */, + 276E5E271CDB57AA003FF4B4 /* LL1Analyzer.cpp in Sources */, + 276E5EAE1CDB57AA003FF4B4 /* StarBlockStartState.cpp in Sources */, + 27DB44A91D045537007E790B /* XPathTokenElement.cpp in Sources */, + 276E5FB61CDB57AA003FF4B4 /* CPPUtils.cpp in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXSourcesBuildPhase section */ + +/* Begin XCBuildConfiguration section */ + 270C67F51CDB4F1E00116E17 /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + CLANG_ANALYZER_NONNULL = YES; + CLANG_ENABLE_MODULES = YES; + CLANG_WARN_UNREACHABLE_CODE = YES; + "CODE_SIGN_IDENTITY[sdk=iphoneos*]" = ""; + CURRENT_PROJECT_VERSION = 1; + DEBUG_INFORMATION_FORMAT = dwarf; + DEFINES_MODULE = YES; + DYLIB_COMPATIBILITY_VERSION = 1; + DYLIB_CURRENT_VERSION = 1; + DYLIB_INSTALL_NAME_BASE = "@rpath"; + ENABLE_STRICT_OBJC_MSGSEND = YES; + GCC_NO_COMMON_BLOCKS = YES; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + INFOPLIST_FILE = "antlrcpp-ios/Info.plist"; + INSTALL_PATH = "$(LOCAL_LIBRARY_DIR)/Frameworks"; + IPHONEOS_DEPLOYMENT_TARGET = 12.0; + LD_RUNPATH_SEARCH_PATHS = ( + "$(inherited)", + "@executable_path/Frameworks", + "@loader_path/Frameworks", + ); + MTL_ENABLE_DEBUG_INFO = YES; + PRODUCT_BUNDLE_IDENTIFIER = "org.antlr.v4.runtime.antlrcpp-ios"; + PRODUCT_NAME = "$(TARGET_NAME)"; + SDKROOT = iphoneos; + SKIP_INSTALL = YES; + TARGETED_DEVICE_FAMILY = "1,2"; + VERSIONING_SYSTEM = "apple-generic"; + VERSION_INFO_PREFIX = ""; + }; + name = Debug; + }; + 270C67F61CDB4F1E00116E17 /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + CLANG_ANALYZER_NONNULL = YES; + CLANG_ENABLE_MODULES = YES; + CLANG_WARN_UNREACHABLE_CODE = YES; + "CODE_SIGN_IDENTITY[sdk=iphoneos*]" = ""; + COPY_PHASE_STRIP = NO; + CURRENT_PROJECT_VERSION = 1; + DEFINES_MODULE = YES; + DYLIB_COMPATIBILITY_VERSION = 1; + DYLIB_CURRENT_VERSION = 1; + DYLIB_INSTALL_NAME_BASE = "@rpath"; + ENABLE_STRICT_OBJC_MSGSEND = YES; + GCC_NO_COMMON_BLOCKS = YES; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + INFOPLIST_FILE = "antlrcpp-ios/Info.plist"; + INSTALL_PATH = "$(LOCAL_LIBRARY_DIR)/Frameworks"; + IPHONEOS_DEPLOYMENT_TARGET = 12.0; + LD_RUNPATH_SEARCH_PATHS = ( + "$(inherited)", + "@executable_path/Frameworks", + "@loader_path/Frameworks", + ); + MTL_ENABLE_DEBUG_INFO = NO; + PRODUCT_BUNDLE_IDENTIFIER = "org.antlr.v4.runtime.antlrcpp-ios"; + PRODUCT_NAME = "$(TARGET_NAME)"; + SDKROOT = iphoneos; + SKIP_INSTALL = YES; + TARGETED_DEVICE_FAMILY = "1,2"; + VALIDATE_PRODUCT = YES; + VERSIONING_SYSTEM = "apple-generic"; + VERSION_INFO_PREFIX = ""; + }; + name = Release; + }; + 37C1471F1B4D5A04008EDDDB /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + CLANG_ENABLE_MODULES = YES; + CLANG_WARN_UNREACHABLE_CODE = YES; + COMBINE_HIDPI_IMAGES = YES; + DEBUG_INFORMATION_FORMAT = dwarf; + ENABLE_STRICT_OBJC_MSGSEND = YES; + EXECUTABLE_PREFIX = lib; + GCC_ENABLE_CPP_EXCEPTIONS = YES; + GCC_ENABLE_CPP_RTTI = YES; + GCC_NO_COMMON_BLOCKS = YES; + GCC_PREPROCESSOR_DEFINITIONS = ( + "DEBUG=1", + "$(inherited)", + ); + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + MTL_ENABLE_DEBUG_INFO = YES; + PRODUCT_NAME = "antlr4-runtime"; + }; + name = Debug; + }; + 37C147201B4D5A04008EDDDB /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + CLANG_ENABLE_MODULES = YES; + CLANG_WARN_UNREACHABLE_CODE = YES; + COMBINE_HIDPI_IMAGES = YES; + COPY_PHASE_STRIP = NO; + ENABLE_STRICT_OBJC_MSGSEND = YES; + EXECUTABLE_PREFIX = lib; + GCC_ENABLE_CPP_EXCEPTIONS = YES; + GCC_ENABLE_CPP_RTTI = YES; + GCC_NO_COMMON_BLOCKS = YES; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + MTL_ENABLE_DEBUG_INFO = NO; + PRODUCT_NAME = "antlr4-runtime"; + }; + name = Release; + }; + 37D727B51867AF1E007B6D10 /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + CLANG_ANALYZER_LOCALIZABILITY_NONLOCALIZED = YES; + CLANG_CXX_LANGUAGE_STANDARD = "c++17"; + CLANG_ENABLE_OBJC_ARC = YES; + CLANG_WARN_ASSIGN_ENUM = YES; + CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_COMMA = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INFINITE_RECURSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN_QUOTED_INCLUDE_IN_FRAMEWORK_HEADER = YES; + CLANG_WARN_RANGE_LOOP_ANALYSIS = YES; + CLANG_WARN_STRICT_PROTOTYPES = YES; + CLANG_WARN_SUSPICIOUS_IMPLICIT_CONVERSION = YES; + CLANG_WARN_SUSPICIOUS_MOVE = YES; + CLANG_WARN_UNREACHABLE_CODE = YES; + CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; + COPY_PHASE_STRIP = NO; + ENABLE_STRICT_OBJC_MSGSEND = YES; + ENABLE_TESTABILITY = YES; + GCC_C_LANGUAGE_STANDARD = gnu99; + GCC_DYNAMIC_NO_PIC = NO; + GCC_ENABLE_OBJC_EXCEPTIONS = YES; + GCC_INLINES_ARE_PRIVATE_EXTERN = YES; + GCC_NO_COMMON_BLOCKS = YES; + GCC_OPTIMIZATION_LEVEL = 0; + GCC_PREPROCESSOR_DEFINITIONS = ( + "DEBUG=1", + "$(inherited)", + ); + GCC_SYMBOLS_PRIVATE_EXTERN = YES; + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_MISSING_NEWLINE = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_INITIALIZER_NOT_FULLY_BRACKETED = YES; + GCC_WARN_NON_VIRTUAL_DESTRUCTOR = YES; + GCC_WARN_SIGN_COMPARE = YES; + GCC_WARN_UNDECLARED_SELECTOR = YES; + GCC_WARN_UNINITIALIZED_AUTOS = YES; + GCC_WARN_UNUSED_FUNCTION = YES; + GCC_WARN_UNUSED_LABEL = YES; + GCC_WARN_UNUSED_PARAMETER = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + HEADER_SEARCH_PATHS = ( + src/, + thirdparty/utfcpp/source/, + thirdparty/utfcpp/source/utf8/, + ); + MACOSX_DEPLOYMENT_TARGET = 11.1; + ONLY_ACTIVE_ARCH = YES; + SDKROOT = macosx; + }; + name = Debug; + }; + 37D727B61867AF1E007B6D10 /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + CLANG_ANALYZER_LOCALIZABILITY_NONLOCALIZED = YES; + CLANG_CXX_LANGUAGE_STANDARD = "c++17"; + CLANG_ENABLE_OBJC_ARC = YES; + CLANG_WARN_ASSIGN_ENUM = YES; + CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_COMMA = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INFINITE_RECURSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN_QUOTED_INCLUDE_IN_FRAMEWORK_HEADER = YES; + CLANG_WARN_RANGE_LOOP_ANALYSIS = YES; + CLANG_WARN_STRICT_PROTOTYPES = YES; + CLANG_WARN_SUSPICIOUS_IMPLICIT_CONVERSION = YES; + CLANG_WARN_SUSPICIOUS_MOVE = YES; + CLANG_WARN_UNREACHABLE_CODE = YES; + CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; + COPY_PHASE_STRIP = YES; + DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; + ENABLE_NS_ASSERTIONS = NO; + ENABLE_STRICT_OBJC_MSGSEND = YES; + GCC_C_LANGUAGE_STANDARD = gnu99; + GCC_ENABLE_OBJC_EXCEPTIONS = YES; + GCC_INLINES_ARE_PRIVATE_EXTERN = YES; + GCC_NO_COMMON_BLOCKS = YES; + GCC_PREPROCESSOR_DEFINITIONS = "$(inherited)"; + GCC_SYMBOLS_PRIVATE_EXTERN = YES; + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_MISSING_NEWLINE = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_INITIALIZER_NOT_FULLY_BRACKETED = YES; + GCC_WARN_NON_VIRTUAL_DESTRUCTOR = YES; + GCC_WARN_SIGN_COMPARE = YES; + GCC_WARN_UNDECLARED_SELECTOR = YES; + GCC_WARN_UNINITIALIZED_AUTOS = YES; + GCC_WARN_UNUSED_FUNCTION = YES; + GCC_WARN_UNUSED_LABEL = YES; + GCC_WARN_UNUSED_PARAMETER = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + HEADER_SEARCH_PATHS = ( + src/, + thirdparty/utfcpp/source/, + thirdparty/utfcpp/source/utf8/, + ); + MACOSX_DEPLOYMENT_TARGET = 11.1; + SDKROOT = macosx; + }; + name = Release; + }; + 37D727B81867AF1E007B6D10 /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + COMBINE_HIDPI_IMAGES = YES; + EXECUTABLE_PREFIX = lib; + LD_DYLIB_INSTALL_NAME = "$(EXECUTABLE_PATH)"; + OTHER_CPLUSPLUSFLAGS = ( + "$(OTHER_CFLAGS)", + "-fvisibility=hidden", + ); + PRODUCT_NAME = "$(TARGET_NAME)-runtime"; + }; + name = Debug; + }; + 37D727B91867AF1E007B6D10 /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + COMBINE_HIDPI_IMAGES = YES; + EXECUTABLE_PREFIX = lib; + LD_DYLIB_INSTALL_NAME = "$(EXECUTABLE_PATH)"; + OTHER_CPLUSPLUSFLAGS = ( + "$(OTHER_CFLAGS)", + "-fvisibility=hidden", + ); + PRODUCT_NAME = "$(TARGET_NAME)-runtime"; + }; + name = Release; + }; +/* End XCBuildConfiguration section */ + +/* Begin XCConfigurationList section */ + 270C67F71CDB4F1E00116E17 /* Build configuration list for PBXNativeTarget "antlr4_ios" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 270C67F51CDB4F1E00116E17 /* Debug */, + 270C67F61CDB4F1E00116E17 /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 37C147211B4D5A04008EDDDB /* Build configuration list for PBXNativeTarget "antlr4_static" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 37C1471F1B4D5A04008EDDDB /* Debug */, + 37C147201B4D5A04008EDDDB /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 37D727A51867AF1E007B6D10 /* Build configuration list for PBXProject "antlrcpp" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 37D727B51867AF1E007B6D10 /* Debug */, + 37D727B61867AF1E007B6D10 /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 37D727B71867AF1E007B6D10 /* Build configuration list for PBXNativeTarget "antlr4" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 37D727B81867AF1E007B6D10 /* Debug */, + 37D727B91867AF1E007B6D10 /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; +/* End XCConfigurationList section */ + }; + rootObject = 37D727A21867AF1E007B6D10 /* Project object */; +} diff --git a/antlr/antlr4-runtime/runtime/antlrcpp.xcodeproj/project.xcworkspace/contents.xcworkspacedata b/antlr/antlr4-runtime/runtime/antlrcpp.xcodeproj/project.xcworkspace/contents.xcworkspacedata new file mode 100644 index 0000000..919434a --- /dev/null +++ b/antlr/antlr4-runtime/runtime/antlrcpp.xcodeproj/project.xcworkspace/contents.xcworkspacedata @@ -0,0 +1,7 @@ + + + + + diff --git a/antlr/antlr4-runtime/runtime/antlrcpp.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist b/antlr/antlr4-runtime/runtime/antlrcpp.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist new file mode 100644 index 0000000..18d9810 --- /dev/null +++ b/antlr/antlr4-runtime/runtime/antlrcpp.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist @@ -0,0 +1,8 @@ + + + + + IDEDidComputeMac32BitWarning + + + diff --git a/antlr/antlr4-runtime/runtime/antlrcpp.xcodeproj/xcshareddata/xcschemes/antlr4.xcscheme b/antlr/antlr4-runtime/runtime/antlrcpp.xcodeproj/xcshareddata/xcschemes/antlr4.xcscheme new file mode 100644 index 0000000..701bbf3 --- /dev/null +++ b/antlr/antlr4-runtime/runtime/antlrcpp.xcodeproj/xcshareddata/xcschemes/antlr4.xcscheme @@ -0,0 +1,76 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/antlr/antlr4-runtime/runtime/antlrcpp.xcodeproj/xcshareddata/xcschemes/antlr4_ios.xcscheme b/antlr/antlr4-runtime/runtime/antlrcpp.xcodeproj/xcshareddata/xcschemes/antlr4_ios.xcscheme new file mode 100644 index 0000000..b62a439 --- /dev/null +++ b/antlr/antlr4-runtime/runtime/antlrcpp.xcodeproj/xcshareddata/xcschemes/antlr4_ios.xcscheme @@ -0,0 +1,76 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/antlr/antlr4-runtime/runtime/antlrcpp.xcodeproj/xcshareddata/xcschemes/antlr4_static.xcscheme b/antlr/antlr4-runtime/runtime/antlrcpp.xcodeproj/xcshareddata/xcschemes/antlr4_static.xcscheme new file mode 100644 index 0000000..c3f4264 --- /dev/null +++ b/antlr/antlr4-runtime/runtime/antlrcpp.xcodeproj/xcshareddata/xcschemes/antlr4_static.xcscheme @@ -0,0 +1,76 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/antlr/antlr4-runtime/runtime/src/ANTLRErrorListener.cpp b/antlr/antlr4-runtime/runtime/src/ANTLRErrorListener.cpp new file mode 100644 index 0000000..6ceadb8 --- /dev/null +++ b/antlr/antlr4-runtime/runtime/src/ANTLRErrorListener.cpp @@ -0,0 +1,10 @@ +/* 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 "ANTLRErrorListener.h" + +antlr4::ANTLRErrorListener::~ANTLRErrorListener() +{ +} diff --git a/antlr/antlr4-runtime/runtime/src/ANTLRErrorListener.h b/antlr/antlr4-runtime/runtime/src/ANTLRErrorListener.h new file mode 100755 index 0000000..d6efad1 --- /dev/null +++ b/antlr/antlr4-runtime/runtime/src/ANTLRErrorListener.h @@ -0,0 +1,167 @@ +๏ปฟ/* 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 "RecognitionException.h" + +namespace antlrcpp { + class BitSet; +} + +namespace antlr4 { + + /// How to emit recognition errors (an interface in Java). + class ANTLR4CPP_PUBLIC ANTLRErrorListener { + public: + virtual ~ANTLRErrorListener(); + + /// + /// Upon syntax error, notify any interested parties. This is not how to + /// recover from errors or compute error messages. + /// specifies how to recover from syntax errors and how to compute error + /// messages. This listener's job is simply to emit a computed message, + /// though it has enough information to create its own message in many cases. + ///

+ /// The is non-null for all syntax errors except + /// when we discover mismatched token errors that we can recover from + /// in-line, without returning from the surrounding rule (via the single + /// token insertion and deletion mechanism). + ///

+ /// + /// What parser got the error. From this + /// object, you can access the context as well + /// as the input stream. + /// + /// The offending token in the input token + /// stream, unless recognizer is a lexer (then it's null). If + /// no viable alternative error, {@code e} has token at which we + /// started production for the decision. + /// + /// The line number in the input where the error occurred. + /// + /// The character position within that line where the error occurred. + /// + /// The message to emit. + /// + /// The exception generated by the parser that led to + /// the reporting of an error. It is null in the case where + /// the parser was able to recover in line without exiting the + /// surrounding rule. + virtual void syntaxError(Recognizer *recognizer, Token *offendingSymbol, size_t line, + size_t charPositionInLine, const std::string &msg, std::exception_ptr e) = 0; + + /** + * This method is called by the parser when a full-context prediction + * results in an ambiguity. + * + *

Each full-context prediction which does not result in a syntax error + * will call either {@link #reportContextSensitivity} or + * {@link #reportAmbiguity}.

+ * + *

When {@code ambigAlts} is not null, it contains the set of potentially + * viable alternatives identified by the prediction algorithm. When + * {@code ambigAlts} is null, use {@link ATNConfigSet#getAlts} to obtain the + * represented alternatives from the {@code configs} argument.

+ * + *

When {@code exact} is {@code true}, all of the potentially + * viable alternatives are truly viable, i.e. this is reporting an exact + * ambiguity. When {@code exact} is {@code false}, at least two of + * the potentially viable alternatives are viable for the current input, but + * the prediction algorithm terminated as soon as it determined that at + * least the minimum potentially viable alternative is truly + * viable.

+ * + *

When the {@link PredictionMode#LL_EXACT_AMBIG_DETECTION} prediction + * mode is used, the parser is required to identify exact ambiguities so + * {@code exact} will always be {@code true}.

+ * + *

This method is not used by lexers.

+ * + * @param recognizer the parser instance + * @param dfa the DFA for the current decision + * @param startIndex the input index where the decision started + * @param stopIndex the input input where the ambiguity was identified + * @param exact {@code true} if the ambiguity is exactly known, otherwise + * {@code false}. This is always {@code true} when + * {@link PredictionMode#LL_EXACT_AMBIG_DETECTION} is used. + * @param ambigAlts the potentially ambiguous alternatives, or {@code null} + * to indicate that the potentially ambiguous alternatives are the complete + * set of represented alternatives in {@code configs} + * @param configs the ATN configuration set where the ambiguity was + * identified + */ + virtual void reportAmbiguity(Parser *recognizer, const dfa::DFA &dfa, size_t startIndex, size_t stopIndex, bool exact, + const antlrcpp::BitSet &ambigAlts, atn::ATNConfigSet *configs) = 0; + + /** + * This method is called when an SLL conflict occurs and the parser is about + * to use the full context information to make an LL decision. + * + *

If one or more configurations in {@code configs} contains a semantic + * predicate, the predicates are evaluated before this method is called. The + * subset of alternatives which are still viable after predicates are + * evaluated is reported in {@code conflictingAlts}.

+ * + *

This method is not used by lexers.

+ * + * @param recognizer the parser instance + * @param dfa the DFA for the current decision + * @param startIndex the input index where the decision started + * @param stopIndex the input index where the SLL conflict occurred + * @param conflictingAlts The specific conflicting alternatives. If this is + * {@code null}, the conflicting alternatives are all alternatives + * represented in {@code configs}. At the moment, conflictingAlts is non-null + * (for the reference implementation, but Sam's optimized version can see this + * as null). + * @param configs the ATN configuration set where the SLL conflict was + * detected + */ + virtual void reportAttemptingFullContext(Parser *recognizer, const dfa::DFA &dfa, size_t startIndex, size_t stopIndex, + const antlrcpp::BitSet &conflictingAlts, atn::ATNConfigSet *configs) = 0; + + /** + * This method is called by the parser when a full-context prediction has a + * unique result. + * + *

Each full-context prediction which does not result in a syntax error + * will call either {@link #reportContextSensitivity} or + * {@link #reportAmbiguity}.

+ * + *

For prediction implementations that only evaluate full-context + * predictions when an SLL conflict is found (including the default + * {@link ParserATNSimulator} implementation), this method reports cases + * where SLL conflicts were resolved to unique full-context predictions, + * i.e. the decision was context-sensitive. This report does not necessarily + * indicate a problem, and it may appear even in completely unambiguous + * grammars.

+ * + *

{@code configs} may have more than one represented alternative if the + * full-context prediction algorithm does not evaluate predicates before + * beginning the full-context prediction. In all cases, the final prediction + * is passed as the {@code prediction} argument.

+ * + *

Note that the definition of "context sensitivity" in this method + * differs from the concept in {@link DecisionInfo#contextSensitivities}. + * This method reports all instances where an SLL conflict occurred but LL + * parsing produced a unique result, whether or not that unique result + * matches the minimum alternative in the SLL conflicting set.

+ * + *

This method is not used by lexers.

+ * + * @param recognizer the parser instance + * @param dfa the DFA for the current decision + * @param startIndex the input index where the decision started + * @param stopIndex the input index where the context sensitivity was + * finally determined + * @param prediction the unambiguous result of the full-context prediction + * @param configs the ATN configuration set where the unambiguous prediction + * was determined + */ + virtual void reportContextSensitivity(Parser *recognizer, const dfa::DFA &dfa, size_t startIndex, size_t stopIndex, + size_t prediction, atn::ATNConfigSet *configs) = 0; + }; + +} // namespace antlr4 diff --git a/antlr/antlr4-runtime/runtime/src/ANTLRErrorStrategy.cpp b/antlr/antlr4-runtime/runtime/src/ANTLRErrorStrategy.cpp new file mode 100644 index 0000000..1655a57 --- /dev/null +++ b/antlr/antlr4-runtime/runtime/src/ANTLRErrorStrategy.cpp @@ -0,0 +1,10 @@ +/* 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 "ANTLRErrorStrategy.h" + +antlr4::ANTLRErrorStrategy::~ANTLRErrorStrategy() +{ +} diff --git a/antlr/antlr4-runtime/runtime/src/ANTLRErrorStrategy.h b/antlr/antlr4-runtime/runtime/src/ANTLRErrorStrategy.h new file mode 100755 index 0000000..a3eecd1 --- /dev/null +++ b/antlr/antlr4-runtime/runtime/src/ANTLRErrorStrategy.h @@ -0,0 +1,121 @@ +/* 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 "Token.h" + +namespace antlr4 { + + /// + /// The interface for defining strategies to deal with syntax errors encountered + /// during a parse by ANTLR-generated parsers. We distinguish between three + /// different kinds of errors: + /// + ///
    + ///
  • The parser could not figure out which path to take in the ATN (none of + /// the available alternatives could possibly match)
    • + ///
  • The current input does not match what we were looking for
    • + ///
  • A predicate evaluated to false
    • + ///
+ /// + /// Implementations of this interface report syntax errors by calling + /// . + ///

+ /// TODO: what to do about lexers + ///

+ class ANTLR4CPP_PUBLIC ANTLRErrorStrategy { + public: + + /// + /// Reset the error handler state for the specified {@code recognizer}. + /// the parser instance + virtual ~ANTLRErrorStrategy(); + + virtual void reset(Parser *recognizer) = 0; + + /** + * This method is called when an unexpected symbol is encountered during an + * inline match operation, such as {@link Parser#match}. If the error + * strategy successfully recovers from the match failure, this method + * returns the {@link Token} instance which should be treated as the + * successful result of the match. + * + *

This method handles the consumption of any tokens - the caller should + * not call {@link Parser#consume} after a successful recovery.

+ * + *

Note that the calling code will not report an error if this method + * returns successfully. The error strategy implementation is responsible + * for calling {@link Parser#notifyErrorListeners} as appropriate.

+ * + * @param recognizer the parser instance + * @throws RecognitionException if the error strategy was not able to + * recover from the unexpected input symbol + */ + virtual Token* recoverInline(Parser *recognizer) = 0; + + /// + /// This method is called to recover from exception {@code e}. This method is + /// called after by the default exception handler + /// generated for a rule method. + /// + /// + /// the parser instance + /// the recognition exception to recover from + /// if the error strategy could not recover from + /// the recognition exception + virtual void recover(Parser *recognizer, std::exception_ptr e) = 0; + + /// + /// This method provides the error handler with an opportunity to handle + /// syntactic or semantic errors in the input stream before they result in a + /// . + ///

+ /// The generated code currently contains calls to after + /// entering the decision state of a closure block ({@code (...)*} or + /// {@code (...)+}). + ///

+ /// For an implementation based on Jim Idle's "magic sync" mechanism, see + /// . + ///

+ /// + /// the parser instance + /// if an error is detected by the error + /// strategy but cannot be automatically recovered at the current state in + /// the parsing process + virtual void sync(Parser *recognizer) = 0; + + /// + /// Tests whether or not {@code recognizer} is in the process of recovering + /// from an error. In error recovery mode, adds + /// symbols to the parse tree by calling + /// {@link Parser#createErrorNode(ParserRuleContext, Token)} then + /// {@link ParserRuleContext#addErrorNode(ErrorNode)} instead of + /// {@link Parser#createTerminalNode(ParserRuleContext, Token)}. + /// + /// the parser instance + /// {@code true} if the parser is currently recovering from a parse + /// error, otherwise {@code false} + virtual bool inErrorRecoveryMode(Parser *recognizer) = 0; + + /// + /// This method is called by when the parser successfully matches an input + /// symbol. + /// + /// the parser instance + virtual void reportMatch(Parser *recognizer) = 0; + + /// + /// Report any kind of . This method is called by + /// the default exception handler generated for a rule method. + /// + /// the parser instance + /// the recognition exception to report + virtual void reportError(Parser *recognizer, const RecognitionException &e) = 0; + }; + +} // namespace antlr4 diff --git a/antlr/antlr4-runtime/runtime/src/ANTLRFileStream.cpp b/antlr/antlr4-runtime/runtime/src/ANTLRFileStream.cpp new file mode 100755 index 0000000..62061bb --- /dev/null +++ b/antlr/antlr4-runtime/runtime/src/ANTLRFileStream.cpp @@ -0,0 +1,29 @@ +/* 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/StringUtils.h" + +#include "ANTLRFileStream.h" + +using namespace antlr4; + +void ANTLRFileStream::loadFromFile(const std::string &fileName) { + _fileName = fileName; + if (_fileName.empty()) { + return; + } + +#ifdef _MSC_VER + std::ifstream stream(antlrcpp::s2ws(fileName), std::ios::binary); +#else + std::ifstream stream(fileName, std::ios::binary); +#endif + + ANTLRInputStream::load(stream); +} + +std::string ANTLRFileStream::getSourceName() const { + return _fileName; +} diff --git a/antlr/antlr4-runtime/runtime/src/ANTLRFileStream.h b/antlr/antlr4-runtime/runtime/src/ANTLRFileStream.h new file mode 100755 index 0000000..6c7d619 --- /dev/null +++ b/antlr/antlr4-runtime/runtime/src/ANTLRFileStream.h @@ -0,0 +1,30 @@ +/* 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 "ANTLRInputStream.h" + +namespace antlr4 { + + /// This is an ANTLRInputStream that is loaded from a file all at once + /// when you construct the object (or call load()). + // TODO: this class needs testing. + class ANTLR4CPP_PUBLIC ANTLRFileStream : public ANTLRInputStream { + public: + ANTLRFileStream() = default; + ANTLRFileStream(const std::string &) = delete; + ANTLRFileStream(const char *data, size_t length) = delete; + ANTLRFileStream(std::istream &stream) = delete; + + // Assumes a file name encoded in UTF-8 and file content in the same encoding (with or w/o BOM). + virtual void loadFromFile(const std::string &fileName); + virtual std::string getSourceName() const override; + + private: + std::string _fileName; // UTF-8 encoded file name. + }; + +} // namespace antlr4 diff --git a/antlr/antlr4-runtime/runtime/src/ANTLRInputStream.cpp b/antlr/antlr4-runtime/runtime/src/ANTLRInputStream.cpp new file mode 100755 index 0000000..2dded40 --- /dev/null +++ b/antlr/antlr4-runtime/runtime/src/ANTLRInputStream.cpp @@ -0,0 +1,169 @@ +/* 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 + +#include "Exceptions.h" +#include "misc/Interval.h" +#include "IntStream.h" + +#include "support/StringUtils.h" +#include "support/CPPUtils.h" + +#include "ANTLRInputStream.h" + +using namespace antlr4; +using namespace antlrcpp; + +using misc::Interval; + +ANTLRInputStream::ANTLRInputStream() { + InitializeInstanceFields(); +} + +#if __cplusplus >= 201703L +ANTLRInputStream::ANTLRInputStream(const std::string_view &input): ANTLRInputStream() { + load(input.data(), input.length()); +} +#endif + +ANTLRInputStream::ANTLRInputStream(const std::string &input): ANTLRInputStream() { + load(input.data(), input.size()); +} + +ANTLRInputStream::ANTLRInputStream(const char *data, size_t length) { + load(data, length); +} + +ANTLRInputStream::ANTLRInputStream(std::istream &stream): ANTLRInputStream() { + load(stream); +} + +void ANTLRInputStream::load(const std::string &input) { + load(input.data(), input.size()); +} + +void ANTLRInputStream::load(const char *data, size_t length) { + // Remove the UTF-8 BOM if present. + const char *bom = "\xef\xbb\xbf"; + if (length >= 3 && strncmp(data, bom, 3) == 0) + _data = antlrcpp::utf8_to_utf32(data + 3, data + length); + else + _data = antlrcpp::utf8_to_utf32(data, data + length); + p = 0; +} + +void ANTLRInputStream::load(std::istream &stream) { + if (!stream.good() || stream.eof()) // No fail, bad or EOF. + return; + + _data.clear(); + + std::string s((std::istreambuf_iterator(stream)), std::istreambuf_iterator()); + load(s.data(), s.length()); +} + +void ANTLRInputStream::reset() { + p = 0; +} + +void ANTLRInputStream::consume() { + if (p >= _data.size()) { + assert(LA(1) == IntStream::EOF); + throw IllegalStateException("cannot consume EOF"); + } + + if (p < _data.size()) { + p++; + } +} + +size_t ANTLRInputStream::LA(ssize_t i) { + if (i == 0) { + return 0; // undefined + } + + ssize_t position = static_cast(p); + if (i < 0) { + i++; // e.g., translate LA(-1) to use offset i=0; then _data[p+0-1] + if ((position + i - 1) < 0) { + return IntStream::EOF; // invalid; no char before first char + } + } + + if ((position + i - 1) >= static_cast(_data.size())) { + return IntStream::EOF; + } + + return _data[static_cast((position + i - 1))]; +} + +size_t ANTLRInputStream::LT(ssize_t i) { + return LA(i); +} + +size_t ANTLRInputStream::index() { + return p; +} + +size_t ANTLRInputStream::size() { + return _data.size(); +} + +// Mark/release do nothing. We have entire buffer. +ssize_t ANTLRInputStream::mark() { + return -1; +} + +void ANTLRInputStream::release(ssize_t /* marker */) { +} + +void ANTLRInputStream::seek(size_t index) { + if (index <= p) { + p = index; // just jump; don't update stream state (line, ...) + return; + } + // seek forward, consume until p hits index or n (whichever comes first) + index = std::min(index, _data.size()); + while (p < index) { + consume(); + } +} + +std::string ANTLRInputStream::getText(const Interval &interval) { + if (interval.a < 0 || interval.b < 0) { + return ""; + } + + size_t start = static_cast(interval.a); + size_t stop = static_cast(interval.b); + + + if (stop >= _data.size()) { + stop = _data.size() - 1; + } + + size_t count = stop - start + 1; + if (start >= _data.size()) { + return ""; + } + + return antlrcpp::utf32_to_utf8(_data.substr(start, count)); +} + +std::string ANTLRInputStream::getSourceName() const { + if (name.empty()) { + return IntStream::UNKNOWN_SOURCE_NAME; + } + return name; +} + +std::string ANTLRInputStream::toString() const { + return antlrcpp::utf32_to_utf8(_data); +} + +void ANTLRInputStream::InitializeInstanceFields() { + p = 0; +} diff --git a/antlr/antlr4-runtime/runtime/src/ANTLRInputStream.h b/antlr/antlr4-runtime/runtime/src/ANTLRInputStream.h new file mode 100755 index 0000000..fdf857e --- /dev/null +++ b/antlr/antlr4-runtime/runtime/src/ANTLRInputStream.h @@ -0,0 +1,76 @@ +/* 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 "CharStream.h" + +namespace antlr4 { + + // Vacuum all input from a stream and then treat it + // like a string. Can also pass in a string or char[] to use. + // Input is expected to be encoded in UTF-8 and converted to UTF-32 internally. + class ANTLR4CPP_PUBLIC ANTLRInputStream : public CharStream { + protected: + /// The data being scanned. + // UTF-32 + UTF32String _data; + + /// 0..n-1 index into string of next char + size_t p; + + public: + /// What is name or source of this char stream? + std::string name; + + ANTLRInputStream(); + +#if __cplusplus >= 201703L + ANTLRInputStream(const std::string_view &input); +#endif + + ANTLRInputStream(const std::string &input); + ANTLRInputStream(const char *data, size_t length); + ANTLRInputStream(std::istream &stream); + + virtual void load(const std::string &input); + virtual void load(const char *data, size_t length); + virtual void load(std::istream &stream); + + /// Reset the stream so that it's in the same state it was + /// when the object was created *except* the data array is not + /// touched. + virtual void reset(); + virtual void consume() override; + virtual size_t LA(ssize_t i) override; + virtual size_t LT(ssize_t i); + + /// + /// Return the current input symbol index 0..n where n indicates the + /// last symbol has been read. The index is the index of char to + /// be returned from LA(1). + /// + virtual size_t index() override; + virtual size_t size() override; + + /// + /// mark/release do nothing; we have entire buffer + virtual ssize_t mark() override; + virtual void release(ssize_t marker) override; + + /// + /// consume() ahead until p==index; can't just set p=index as we must + /// update line and charPositionInLine. If we seek backwards, just set p + /// + virtual void seek(size_t index) override; + virtual std::string getText(const misc::Interval &interval) override; + virtual std::string getSourceName() const override; + virtual std::string toString() const override; + + private: + void InitializeInstanceFields(); + }; + +} // namespace antlr4 diff --git a/antlr/antlr4-runtime/runtime/src/BailErrorStrategy.cpp b/antlr/antlr4-runtime/runtime/src/BailErrorStrategy.cpp new file mode 100755 index 0000000..5fbc011 --- /dev/null +++ b/antlr/antlr4-runtime/runtime/src/BailErrorStrategy.cpp @@ -0,0 +1,61 @@ +๏ปฟ/* 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 "ParserRuleContext.h" +#include "InputMismatchException.h" +#include "Parser.h" + +#include "BailErrorStrategy.h" + +using namespace antlr4; + +void BailErrorStrategy::recover(Parser *recognizer, std::exception_ptr e) { + ParserRuleContext *context = recognizer->getContext(); + do { + context->exception = e; + if (context->parent == nullptr) + break; + context = static_cast(context->parent); + } while (true); + + try { + std::rethrow_exception(e); // Throw the exception to be able to catch and rethrow nested. +#if defined(_MSC_FULL_VER) && _MSC_FULL_VER < 190023026 + } catch (RecognitionException &inner) { + throw ParseCancellationException(inner.what()); +#else + } catch (RecognitionException & /*inner*/) { + std::throw_with_nested(ParseCancellationException()); +#endif + } +} + +Token* BailErrorStrategy::recoverInline(Parser *recognizer) { + InputMismatchException e(recognizer); + std::exception_ptr exception = std::make_exception_ptr(e); + + ParserRuleContext *context = recognizer->getContext(); + do { + context->exception = exception; + if (context->parent == nullptr) + break; + context = static_cast(context->parent); + } while (true); + + try { + throw e; +#if defined(_MSC_FULL_VER) && _MSC_FULL_VER < 190023026 + } catch (InputMismatchException &inner) { + throw ParseCancellationException(inner.what()); +#else + } catch (InputMismatchException & /*inner*/) { + std::throw_with_nested(ParseCancellationException()); +#endif + } +} + +void BailErrorStrategy::sync(Parser * /*recognizer*/) { +} diff --git a/antlr/antlr4-runtime/runtime/src/BailErrorStrategy.h b/antlr/antlr4-runtime/runtime/src/BailErrorStrategy.h new file mode 100755 index 0000000..2a8c36f --- /dev/null +++ b/antlr/antlr4-runtime/runtime/src/BailErrorStrategy.h @@ -0,0 +1,59 @@ +๏ปฟ/* 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 "DefaultErrorStrategy.h" + +namespace antlr4 { + + /** + * This implementation of {@link ANTLRErrorStrategy} responds to syntax errors + * by immediately canceling the parse operation with a + * {@link ParseCancellationException}. The implementation ensures that the + * {@link ParserRuleContext#exception} field is set for all parse tree nodes + * that were not completed prior to encountering the error. + * + *

+ * This error strategy is useful in the following scenarios.

+ * + *
    + *
  • Two-stage parsing: This error strategy allows the first + * stage of two-stage parsing to immediately terminate if an error is + * encountered, and immediately fall back to the second stage. In addition to + * avoiding wasted work by attempting to recover from errors here, the empty + * implementation of {@link BailErrorStrategy#sync} improves the performance of + * the first stage.
    • + *
  • Silent validation: When syntax errors are not being + * reported or logged, and the parse result is simply ignored if errors occur, + * the {@link BailErrorStrategy} avoids wasting work on recovering from errors + * when the result will be ignored either way.
    • + *
+ * + *

+ * {@code myparser.setErrorHandler(new BailErrorStrategy());}

+ * + * @see Parser#setErrorHandler(ANTLRErrorStrategy) + */ + class ANTLR4CPP_PUBLIC BailErrorStrategy : public DefaultErrorStrategy { + /// + /// Instead of recovering from exception {@code e}, re-throw it wrapped + /// in a so it is not caught by the + /// rule function catches. Use to get the + /// original . + /// + public: + virtual void recover(Parser *recognizer, std::exception_ptr e) override; + + /// Make sure we don't attempt to recover inline; if the parser + /// successfully recovers, it won't throw an exception. + virtual Token* recoverInline(Parser *recognizer) override; + + /// + /// Make sure we don't attempt to recover from problems in subrules. + virtual void sync(Parser *recognizer) override; + }; + +} // namespace antlr4 diff --git a/antlr/antlr4-runtime/runtime/src/BaseErrorListener.cpp b/antlr/antlr4-runtime/runtime/src/BaseErrorListener.cpp new file mode 100755 index 0000000..c035f09 --- /dev/null +++ b/antlr/antlr4-runtime/runtime/src/BaseErrorListener.cpp @@ -0,0 +1,25 @@ +๏ปฟ/* 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 "BaseErrorListener.h" +#include "RecognitionException.h" + +using namespace antlr4; + +void BaseErrorListener::syntaxError(Recognizer * /*recognizer*/, Token * /*offendingSymbol*/, size_t /*line*/, + size_t /*charPositionInLine*/, const std::string &/*msg*/, std::exception_ptr /*e*/) { +} + +void BaseErrorListener::reportAmbiguity(Parser * /*recognizer*/, const dfa::DFA &/*dfa*/, size_t /*startIndex*/, + size_t /*stopIndex*/, bool /*exact*/, const antlrcpp::BitSet &/*ambigAlts*/, atn::ATNConfigSet * /*configs*/) { +} + +void BaseErrorListener::reportAttemptingFullContext(Parser * /*recognizer*/, const dfa::DFA &/*dfa*/, size_t /*startIndex*/, + size_t /*stopIndex*/, const antlrcpp::BitSet &/*conflictingAlts*/, atn::ATNConfigSet * /*configs*/) { +} + +void BaseErrorListener::reportContextSensitivity(Parser * /*recognizer*/, const dfa::DFA &/*dfa*/, size_t /*startIndex*/, + size_t /*stopIndex*/, size_t /*prediction*/, atn::ATNConfigSet * /*configs*/) { +} diff --git a/antlr/antlr4-runtime/runtime/src/BaseErrorListener.h b/antlr/antlr4-runtime/runtime/src/BaseErrorListener.h new file mode 100755 index 0000000..aad2e5d --- /dev/null +++ b/antlr/antlr4-runtime/runtime/src/BaseErrorListener.h @@ -0,0 +1,36 @@ +๏ปฟ/* 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 "ANTLRErrorListener.h" + +namespace antlrcpp { + class BitSet; +} + +namespace antlr4 { + + /** + * Provides an empty default implementation of {@link ANTLRErrorListener}. The + * default implementation of each method does nothing, but can be overridden as + * necessary. + */ + class ANTLR4CPP_PUBLIC BaseErrorListener : public ANTLRErrorListener { + + virtual void syntaxError(Recognizer *recognizer, Token * offendingSymbol, size_t line, size_t charPositionInLine, + const std::string &msg, std::exception_ptr e) override; + + virtual void reportAmbiguity(Parser *recognizer, const dfa::DFA &dfa, size_t startIndex, size_t stopIndex, bool exact, + const antlrcpp::BitSet &ambigAlts, atn::ATNConfigSet *configs) override; + + virtual void reportAttemptingFullContext(Parser *recognizer, const dfa::DFA &dfa, size_t startIndex, size_t stopIndex, + const antlrcpp::BitSet &conflictingAlts, atn::ATNConfigSet *configs) override; + + virtual void reportContextSensitivity(Parser *recognizer, const dfa::DFA &dfa, size_t startIndex, size_t stopIndex, + size_t prediction, atn::ATNConfigSet *configs) override; + }; + +} // namespace antlr4 diff --git a/antlr/antlr4-runtime/runtime/src/BufferedTokenStream.cpp b/antlr/antlr4-runtime/runtime/src/BufferedTokenStream.cpp new file mode 100755 index 0000000..241dfe5 --- /dev/null +++ b/antlr/antlr4-runtime/runtime/src/BufferedTokenStream.cpp @@ -0,0 +1,414 @@ +๏ปฟ/* 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 "WritableToken.h" +#include "Lexer.h" +#include "RuleContext.h" +#include "misc/Interval.h" +#include "Exceptions.h" +#include "support/CPPUtils.h" + +#include "BufferedTokenStream.h" + +using namespace antlr4; +using namespace antlrcpp; + +BufferedTokenStream::BufferedTokenStream(TokenSource *tokenSource) : _tokenSource(tokenSource){ + InitializeInstanceFields(); +} + +TokenSource* BufferedTokenStream::getTokenSource() const { + return _tokenSource; +} + +size_t BufferedTokenStream::index() { + return _p; +} + +ssize_t BufferedTokenStream::mark() { + return 0; +} + +void BufferedTokenStream::release(ssize_t /*marker*/) { + // no resources to release +} + +void BufferedTokenStream::reset() { + seek(0); +} + +void BufferedTokenStream::seek(size_t index) { + lazyInit(); + _p = adjustSeekIndex(index); +} + +size_t BufferedTokenStream::size() { + return _tokens.size(); +} + +void BufferedTokenStream::consume() { + bool skipEofCheck = false; + if (!_needSetup) { + if (_fetchedEOF) { + // the last token in tokens is EOF. skip check if p indexes any + // fetched token except the last. + skipEofCheck = _p < _tokens.size() - 1; + } else { + // no EOF token in tokens. skip check if p indexes a fetched token. + skipEofCheck = _p < _tokens.size(); + } + } else { + // not yet initialized + skipEofCheck = false; + } + + if (!skipEofCheck && LA(1) == Token::EOF) { + throw IllegalStateException("cannot consume EOF"); + } + + if (sync(_p + 1)) { + _p = adjustSeekIndex(_p + 1); + } +} + +bool BufferedTokenStream::sync(size_t i) { + if (i + 1 < _tokens.size()) + return true; + size_t n = i - _tokens.size() + 1; // how many more elements we need? + + if (n > 0) { + size_t fetched = fetch(n); + return fetched >= n; + } + + return true; +} + +size_t BufferedTokenStream::fetch(size_t n) { + if (_fetchedEOF) { + return 0; + } + + size_t i = 0; + while (i < n) { + std::unique_ptr t(_tokenSource->nextToken()); + + if (is(t.get())) { + (static_cast(t.get()))->setTokenIndex(_tokens.size()); + } + + _tokens.push_back(std::move(t)); + ++i; + + if (_tokens.back()->getType() == Token::EOF) { + _fetchedEOF = true; + break; + } + } + + return i; +} + +Token* BufferedTokenStream::get(size_t i) const { + if (i >= _tokens.size()) { + throw IndexOutOfBoundsException(std::string("token index ") + + std::to_string(i) + + std::string(" out of range 0..") + + std::to_string(_tokens.size() - 1)); + } + return _tokens[i].get(); +} + +std::vector BufferedTokenStream::get(size_t start, size_t stop) { + std::vector subset; + + lazyInit(); + + if (_tokens.empty()) { + return subset; + } + + if (stop >= _tokens.size()) { + stop = _tokens.size() - 1; + } + for (size_t i = start; i <= stop; i++) { + Token *t = _tokens[i].get(); + if (t->getType() == Token::EOF) { + break; + } + subset.push_back(t); + } + return subset; +} + +size_t BufferedTokenStream::LA(ssize_t i) { + return LT(i)->getType(); +} + +Token* BufferedTokenStream::LB(size_t k) { + if (k > _p) { + return nullptr; + } + return _tokens[_p - k].get(); +} + +Token* BufferedTokenStream::LT(ssize_t k) { + lazyInit(); + if (k == 0) { + return nullptr; + } + if (k < 0) { + return LB(-k); + } + + size_t i = _p + k - 1; + sync(i); + if (i >= _tokens.size()) { // return EOF token + // EOF must be last token + return _tokens.back().get(); + } + + return _tokens[i].get(); +} + +ssize_t BufferedTokenStream::adjustSeekIndex(size_t i) { + return i; +} + +void BufferedTokenStream::lazyInit() { + if (_needSetup) { + setup(); + } +} + +void BufferedTokenStream::setup() { + _needSetup = false; + sync(0); + _p = adjustSeekIndex(0); +} + +void BufferedTokenStream::setTokenSource(TokenSource *tokenSource) { + _tokenSource = tokenSource; + _tokens.clear(); + _fetchedEOF = false; + _needSetup = true; +} + +std::vector BufferedTokenStream::getTokens() { + std::vector result; + for (auto &t : _tokens) + result.push_back(t.get()); + return result; +} + +std::vector BufferedTokenStream::getTokens(size_t start, size_t stop) { + return getTokens(start, stop, std::vector()); +} + +std::vector BufferedTokenStream::getTokens(size_t start, size_t stop, const std::vector &types) { + lazyInit(); + if (stop >= _tokens.size() || start >= _tokens.size()) { + throw IndexOutOfBoundsException(std::string("start ") + + std::to_string(start) + + std::string(" or stop ") + + std::to_string(stop) + + std::string(" not in 0..") + + std::to_string(_tokens.size() - 1)); + } + + std::vector filteredTokens; + + if (start > stop) { + return filteredTokens; + } + + for (size_t i = start; i <= stop; i++) { + Token *tok = _tokens[i].get(); + + if (types.empty() || std::find(types.begin(), types.end(), tok->getType()) != types.end()) { + filteredTokens.push_back(tok); + } + } + return filteredTokens; +} + +std::vector BufferedTokenStream::getTokens(size_t start, size_t stop, size_t ttype) { + std::vector s; + s.push_back(ttype); + return getTokens(start, stop, s); +} + +ssize_t BufferedTokenStream::nextTokenOnChannel(size_t i, size_t channel) { + sync(i); + if (i >= size()) { + return size() - 1; + } + + Token *token = _tokens[i].get(); + while (token->getChannel() != channel) { + if (token->getType() == Token::EOF) { + return i; + } + i++; + sync(i); + token = _tokens[i].get(); + } + return i; +} + +ssize_t BufferedTokenStream::previousTokenOnChannel(size_t i, size_t channel) { + sync(i); + if (i >= size()) { + // the EOF token is on every channel + return size() - 1; + } + + while (true) { + Token *token = _tokens[i].get(); + if (token->getType() == Token::EOF || token->getChannel() == channel) { + return i; + } + + if (i == 0) + return -1; + i--; + } + return i; +} + +std::vector BufferedTokenStream::getHiddenTokensToRight(size_t tokenIndex, ssize_t channel) { + lazyInit(); + if (tokenIndex >= _tokens.size()) { + throw IndexOutOfBoundsException(std::to_string(tokenIndex) + " not in 0.." + std::to_string(_tokens.size() - 1)); + } + + ssize_t nextOnChannel = nextTokenOnChannel(tokenIndex + 1, Lexer::DEFAULT_TOKEN_CHANNEL); + size_t to; + size_t from = tokenIndex + 1; + // if none onchannel to right, nextOnChannel=-1 so set to = last token + if (nextOnChannel == -1) { + to = static_cast(size() - 1); + } else { + to = nextOnChannel; + } + + return filterForChannel(from, to, channel); +} + +std::vector BufferedTokenStream::getHiddenTokensToRight(size_t tokenIndex) { + return getHiddenTokensToRight(tokenIndex, -1); +} + +std::vector BufferedTokenStream::getHiddenTokensToLeft(size_t tokenIndex, ssize_t channel) { + lazyInit(); + if (tokenIndex >= _tokens.size()) { + throw IndexOutOfBoundsException(std::to_string(tokenIndex) + " not in 0.." + std::to_string(_tokens.size() - 1)); + } + + if (tokenIndex == 0) { + // Obviously no tokens can appear before the first token. + return { }; + } + + ssize_t prevOnChannel = previousTokenOnChannel(tokenIndex - 1, Lexer::DEFAULT_TOKEN_CHANNEL); + if (prevOnChannel == static_cast(tokenIndex - 1)) { + return { }; + } + // if none onchannel to left, prevOnChannel=-1 then from=0 + size_t from = static_cast(prevOnChannel + 1); + size_t to = tokenIndex - 1; + + return filterForChannel(from, to, channel); +} + +std::vector BufferedTokenStream::getHiddenTokensToLeft(size_t tokenIndex) { + return getHiddenTokensToLeft(tokenIndex, -1); +} + +std::vector BufferedTokenStream::filterForChannel(size_t from, size_t to, ssize_t channel) { + std::vector hidden; + for (size_t i = from; i <= to; i++) { + Token *t = _tokens[i].get(); + if (channel == -1) { + if (t->getChannel() != Lexer::DEFAULT_TOKEN_CHANNEL) { + hidden.push_back(t); + } + } else { + if (t->getChannel() == static_cast(channel)) { + hidden.push_back(t); + } + } + } + + return hidden; +} + +bool BufferedTokenStream::isInitialized() const { + return !_needSetup; +} + +/** + * Get the text of all tokens in this buffer. + */ +std::string BufferedTokenStream::getSourceName() const +{ + return _tokenSource->getSourceName(); +} + +std::string BufferedTokenStream::getText() { + fill(); + return getText(misc::Interval(0U, size() - 1)); +} + +std::string BufferedTokenStream::getText(const misc::Interval &interval) { + lazyInit(); + size_t start = interval.a; + size_t stop = interval.b; + if (start == INVALID_INDEX || stop == INVALID_INDEX) { + return ""; + } + sync(stop); + if (stop >= _tokens.size()) { + stop = _tokens.size() - 1; + } + + std::stringstream ss; + for (size_t i = start; i <= stop; i++) { + Token *t = _tokens[i].get(); + if (t->getType() == Token::EOF) { + break; + } + ss << t->getText(); + } + return ss.str(); +} + +std::string BufferedTokenStream::getText(RuleContext *ctx) { + return getText(ctx->getSourceInterval()); +} + +std::string BufferedTokenStream::getText(Token *start, Token *stop) { + if (start != nullptr && stop != nullptr) { + return getText(misc::Interval(start->getTokenIndex(), stop->getTokenIndex())); + } + + return ""; +} + +void BufferedTokenStream::fill() { + lazyInit(); + const size_t blockSize = 1000; + while (true) { + size_t fetched = fetch(blockSize); + if (fetched < blockSize) { + return; + } + } +} + +void BufferedTokenStream::InitializeInstanceFields() { + _needSetup = true; + _fetchedEOF = false; +} diff --git a/antlr/antlr4-runtime/runtime/src/BufferedTokenStream.h b/antlr/antlr4-runtime/runtime/src/BufferedTokenStream.h new file mode 100755 index 0000000..fab74d2 --- /dev/null +++ b/antlr/antlr4-runtime/runtime/src/BufferedTokenStream.h @@ -0,0 +1,200 @@ +๏ปฟ/* 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 "TokenStream.h" + +namespace antlr4 { + + /** + * This implementation of {@link TokenStream} loads tokens from a + * {@link TokenSource} on-demand, and places the tokens in a buffer to provide + * access to any previous token by index. + * + *

+ * This token stream ignores the value of {@link Token#getChannel}. If your + * parser requires the token stream filter tokens to only those on a particular + * channel, such as {@link Token#DEFAULT_CHANNEL} or + * {@link Token#HIDDEN_CHANNEL}, use a filtering token stream such a + * {@link CommonTokenStream}.

+ */ + class ANTLR4CPP_PUBLIC BufferedTokenStream : public TokenStream { + public: + BufferedTokenStream(TokenSource *tokenSource); + BufferedTokenStream(const BufferedTokenStream& other) = delete; + + BufferedTokenStream& operator = (const BufferedTokenStream& other) = delete; + + virtual TokenSource* getTokenSource() const override; + virtual size_t index() override; + virtual ssize_t mark() override; + + virtual void release(ssize_t marker) override; + virtual void reset(); + virtual void seek(size_t index) override; + + virtual size_t size() override; + virtual void consume() override; + + virtual Token* get(size_t i) const override; + + /// Get all tokens from start..stop inclusively. + virtual std::vector get(size_t start, size_t stop); + + virtual size_t LA(ssize_t i) override; + virtual Token* LT(ssize_t k) override; + + /// Reset this token stream by setting its token source. + virtual void setTokenSource(TokenSource *tokenSource); + virtual std::vector getTokens(); + virtual std::vector getTokens(size_t start, size_t stop); + + /// + /// Given a start and stop index, return a List of all tokens in + /// the token type BitSet. Return null if no tokens were found. This + /// method looks at both on and off channel tokens. + /// + virtual std::vector getTokens(size_t start, size_t stop, const std::vector &types); + virtual std::vector getTokens(size_t start, size_t stop, size_t ttype); + + /// Collect all tokens on specified channel to the right of + /// the current token up until we see a token on DEFAULT_TOKEN_CHANNEL or + /// EOF. If channel is -1, find any non default channel token. + virtual std::vector getHiddenTokensToRight(size_t tokenIndex, ssize_t channel); + + /// + /// Collect all hidden tokens (any off-default channel) to the right of + /// the current token up until we see a token on DEFAULT_TOKEN_CHANNEL + /// or EOF. + /// + virtual std::vector getHiddenTokensToRight(size_t tokenIndex); + + /// + /// Collect all tokens on specified channel to the left of + /// the current token up until we see a token on DEFAULT_TOKEN_CHANNEL. + /// If channel is -1, find any non default channel token. + /// + virtual std::vector getHiddenTokensToLeft(size_t tokenIndex, ssize_t channel); + + /// + /// Collect all hidden tokens (any off-default channel) to the left of + /// the current token up until we see a token on DEFAULT_TOKEN_CHANNEL. + /// + virtual std::vector getHiddenTokensToLeft(size_t tokenIndex); + + virtual std::string getSourceName() const override; + virtual std::string getText() override; + virtual std::string getText(const misc::Interval &interval) override; + virtual std::string getText(RuleContext *ctx) override; + virtual std::string getText(Token *start, Token *stop) override; + + /// Get all tokens from lexer until EOF. + virtual void fill(); + + protected: + /** + * The {@link TokenSource} from which tokens for this stream are fetched. + */ + TokenSource *_tokenSource; + + /** + * A collection of all tokens fetched from the token source. The list is + * considered a complete view of the input once {@link #fetchedEOF} is set + * to {@code true}. + */ + std::vector> _tokens; + + /** + * The index into {@link #tokens} of the current token (next token to + * {@link #consume}). {@link #tokens}{@code [}{@link #p}{@code ]} should be + * {@link #LT LT(1)}. + * + *

This field is set to -1 when the stream is first constructed or when + * {@link #setTokenSource} is called, indicating that the first token has + * not yet been fetched from the token source. For additional information, + * see the documentation of {@link IntStream} for a description of + * Initializing Methods.

+ */ + // ml: since -1 requires to make this member signed for just this single aspect we use a member _needSetup instead. + // Use bool isInitialized() to find out if this stream has started reading. + size_t _p; + + /** + * Indicates whether the {@link Token#EOF} token has been fetched from + * {@link #tokenSource} and added to {@link #tokens}. This field improves + * performance for the following cases: + * + *