diff --git a/cpp/CMakeLists.txt b/cpp/CMakeLists.txt old mode 100644 new mode 100755 index 1ba393255..f69bee3d6 --- a/cpp/CMakeLists.txt +++ b/cpp/CMakeLists.txt @@ -21,7 +21,6 @@ project(TsFile_CPP) cmake_policy(SET CMP0079 NEW) set(TsFile_CPP_VERSION 1.2.0.dev) - set(CMAKE_CXX_FLAGS "$ENV{CXXFLAGS} -Wall -Werror") message("cmake using: USE_CPP11=${USE_CPP11}") @@ -76,6 +75,8 @@ set(PROJECT_INCLUDE_DIR ${PROJECT_INCLUDE_DIR} set(EXECUTABLE_OUTPUT_PATH ${PROJECT_BINARY_DIR}/bin) include_directories(${PROJECT_INCLUDE_DIR}) +include_directories(${PROJECT_SOURCE_DIR}/third_party/antlr4-cpp-runtime-4/runtime/src) + add_subdirectory(third_party) add_subdirectory(src) diff --git a/cpp/README.md b/cpp/README.md index 2d7be530b..afe3a0caf 100644 --- a/cpp/README.md +++ b/cpp/README.md @@ -74,6 +74,13 @@ To build tsfile, you can run: `bash build.sh`. If you have Maven tools, you can Before you submit your code to GitHub, please ensure that the `mvn` compilation is correct. +If you compile using MinGW on windows and encounter an error, you can try replacing MinGW with the following version that we have tried without problems: + +* GCC 14.2.0 (with **POSIX** threads) + LLVM/Clang/LLD/LLDB 18.1.8 + MinGW-w64 12.0.0 UCRT - release 1 +* GCC 12.2.0 + LLVM/Clang/LLD/LLDB 16.0.0 + MinGW-w64 10.0.0 (UCRT) - release 5 +* GCC 12.2.0 + LLVM/Clang/LLD/LLDB 16.0.0 + MinGW-w64 10.0.0 (MSVCRT) - release 5 +* GCC 11.2.0 + MinGW-w64 10.0.0 (MSVCRT) - release 1 + ## Use TsFile You can find examples on how to read and write data in `demo_read.cpp` and `demo_write.cpp` located under `./examples/cpp_examples`. There are also examples under `./examples/c_examples`on how to use a C-style API to read and write data in a C environment. You can run `bash build.sh` under `./examples` to generate an executable output under `./examples/build`. \ No newline at end of file diff --git a/cpp/examples/cpp_examples/demo_read.cpp b/cpp/examples/cpp_examples/demo_read.cpp index 5b36af3c8..8fab33f99 100644 --- a/cpp/examples/cpp_examples/demo_read.cpp +++ b/cpp/examples/cpp_examples/demo_read.cpp @@ -70,16 +70,16 @@ int demo_read() { std::cout << "begin to query expr" << std::endl; ASSERT(ret == 0); - storage::QueryDataSet *qds = nullptr; + storage::ResultSet *qds = nullptr; ret = reader.query(query_expr, qds); storage::RowRecord *record; std::cout << "begin to dump data from tsfile ---" << std::endl; int row_cout = 0; do { - record = qds->get_next(); - if (record) { + if (qds->next()) { std::cout << "dump QDS : " << record->get_timestamp() << ","; + record = qds->get_row_record(); if (record) { int size = record->get_fields()->size(); for (int i = 0; i < size; ++i) { diff --git a/cpp/examples/cpp_examples/demo_write.cpp b/cpp/examples/cpp_examples/demo_write.cpp index 2fafb4655..17c5cb6ba 100644 --- a/cpp/examples/cpp_examples/demo_write.cpp +++ b/cpp/examples/cpp_examples/demo_write.cpp @@ -66,16 +66,14 @@ int demo_write() { std::vector schema_vec[50]; for (int i = 0; i < device_num; i++) { std::string device_name = "test_device" + std::to_string(i); + schema_vec[i].reserve(measurement_num); for (int j = 0; j < measurement_num; j++) { std::string measure_name = "measurement" + std::to_string(j); - schema_vec[i].push_back( + schema_vec[i].emplace_back( MeasurementSchema(measure_name, common::TSDataType::INT32, common::TSEncoding::PLAIN, common::CompressionType::UNCOMPRESSED)); - tsfile_writer_->register_timeseries( - device_name, measure_name, common::TSDataType::INT32, - common::TSEncoding::PLAIN, - common::CompressionType::UNCOMPRESSED); + tsfile_writer_->register_timeseries(device_name, schema_vec[i][j]); } } diff --git a/cpp/pom.xml b/cpp/pom.xml index c36997356..a0060c245 100644 --- a/cpp/pom.xml +++ b/cpp/pom.xml @@ -147,6 +147,40 @@ + + linux-install-uuid-dev + + + unix + Linux + + + + + + org.codehaus.mojo + exec-maven-plugin + 1.1.1 + + + install-uuid-dev + validate + + exec + + + + + bash + + -c + sudo apt-get update && sudo apt-get install -y uuid-dev + + + + + + with-code-coverage diff --git a/cpp/src/CMakeLists.txt b/cpp/src/CMakeLists.txt index 643e70a1d..847f41d8b 100644 --- a/cpp/src/CMakeLists.txt +++ b/cpp/src/CMakeLists.txt @@ -20,6 +20,9 @@ message("Running in src diectory") if (${COV_ENABLED}) add_compile_options(-fprofile-arcs -ftest-coverage) endif () +add_definitions(-DANTLR4CPP_STATIC) +set(ANTLR4_WITH_STATIC_CRT OFF) +add_subdirectory(parser) add_subdirectory(common) add_subdirectory(compress) add_subdirectory(cwrapper) @@ -29,13 +32,22 @@ add_subdirectory(reader) add_subdirectory(utils) add_subdirectory(writer) +set(SNAPPY_LIB_NAME "snappy") +set(LZ4_LIB_NAME "LZ4") +set(LZO_LIB_NAME "lzokay") +target_link_libraries(parser_obj antlr4_static) +target_link_libraries(compress_obj ${SNAPPY_LIB_NAME} ${LZ4_LIB_NAME} ${LZO_LIB_NAME} zlibstatic ) +target_link_libraries(common_obj ${SNAPPY_LIB_NAME} ${LZ4_LIB_NAME} ${LZO_LIB_NAME} zlibstatic ) +target_link_libraries(read_obj ${SNAPPY_LIB_NAME} ${LZ4_LIB_NAME} ${LZO_LIB_NAME} zlibstatic ) +target_link_libraries(write_obj ${SNAPPY_LIB_NAME} ${LZ4_LIB_NAME} ${LZO_LIB_NAME} zlibstatic ) + add_library(tsfile SHARED) if (${COV_ENABLED}) message("Enable code cov...") - target_link_libraries(tsfile common_obj compress_obj cwrapper_obj file_obj read_obj write_obj -lgcov) + target_link_libraries(tsfile common_obj compress_obj cwrapper_obj file_obj read_obj write_obj parser_obj -lgcov) else() message("Disable code cov...") - target_link_libraries(tsfile common_obj compress_obj cwrapper_obj file_obj read_obj write_obj) + target_link_libraries(tsfile common_obj compress_obj cwrapper_obj file_obj read_obj write_obj parser_obj) endif() set(LIBTSFILE_PROJECT_VERSION ${TsFile_CPP_VERSION}) @@ -46,15 +58,6 @@ set_target_properties(tsfile PROPERTIES SOVERSION ${LIBTSFILE_SO_VERSION}) set(LIBTSFILE_SDK_DIR ${LIBRARY_OUTPUT_PATH}) install(TARGETS tsfile LIBRARY DESTINATION ${LIBTSFILE_SDK_DIR}) -set(SNAPPY_LIB_NAME "snappy") -set(LZ4_LIB_NAME "LZ4") -set(LZO_LIB_NAME "lzokay") -set(ZLIB_LIB_NAME "z") - -target_link_libraries(compress_obj ${SNAPPY_LIB_NAME} ${LZ4_LIB_NAME} ${LZO_LIB_NAME} ${ZLIB_LIB_NAME}) -target_link_libraries(common_obj ${SNAPPY_LIB_NAME} ${LZ4_LIB_NAME} ${LZO_LIB_NAME} ${ZLIB_LIB_NAME}) -target_link_libraries(read_obj ${SNAPPY_LIB_NAME} ${LZ4_LIB_NAME} ${LZO_LIB_NAME} ${ZLIB_LIB_NAME}) -target_link_libraries(write_obj ${SNAPPY_LIB_NAME} ${LZ4_LIB_NAME} ${LZO_LIB_NAME} ${ZLIB_LIB_NAME}) # set(CMAKE_PREFIX_PATH ../../third-party/lz4-dev/lib) # set(LZ4_LIB_DIR ../../third-party/lz4-dev/lib) # find_library(my_lz4_lib NAMES lz4 PATHS ${LZ4_LIB_DIR} NO_DEFAULT_PATH REQUIRED) diff --git a/cpp/src/common/allocator/my_string.h b/cpp/src/common/allocator/my_string.h index 72bbce3f9..e543d6b0a 100644 --- a/cpp/src/common/allocator/my_string.h +++ b/cpp/src/common/allocator/my_string.h @@ -147,6 +147,7 @@ struct String { return this->len_ < other.len_; } + std::string to_std_string() { return std::string(buf_, len_); } #ifndef NDEBUG friend std::ostream &operator<<(std::ostream &os, const String &s) { diff --git a/cpp/src/common/constant/CMakeLists.txt b/cpp/src/common/constant/CMakeLists.txt new file mode 100644 index 000000000..5860be1f2 --- /dev/null +++ b/cpp/src/common/constant/CMakeLists.txt @@ -0,0 +1,18 @@ +#[[ +Licensed to the Apache Software Foundation (ASF) under one +or more contributor license agreements. See the NOTICE file +distributed with this work for additional information +regarding copyright ownership. The ASF licenses this file +to you under the Apache License, Version 2.0 (the +"License"); you may not use this file except in compliance +with the License. You may obtain a copy of the License at + + https://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, +software distributed under the License is distributed on an +"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +KIND, either express or implied. See the License for the +specific language governing permissions and limitations +under the License. +]] \ No newline at end of file diff --git a/cpp/src/common/constant/tsfile_constant.h b/cpp/src/common/constant/tsfile_constant.h new file mode 100644 index 000000000..982f03784 --- /dev/null +++ b/cpp/src/common/constant/tsfile_constant.h @@ -0,0 +1,44 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * License); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +#include +#include + +namespace storage +{ + static const std::string TSFILE_SUFFIX = ".tsfile"; + static const std::string TSFILE_HOME = "TSFILE_HOME"; + static const std::string TSFILE_CONF = "TSFILE_CONF"; + static const std::string PATH_ROOT = "root"; + static const std::string TMP_SUFFIX = "tmp"; + static const std::string PATH_SEPARATOR = "."; + static const char PATH_SEPARATOR_CHAR = '.'; + static const std::string PATH_SEPARATER_NO_REGEX = "\\."; + static const char DOUBLE_QUOTE = '"'; + static const char BACK_QUOTE = '`'; + static const std::string BACK_QUOTE_STRING = "`"; + static const std::string DOUBLE_BACK_QUOTE_STRING = "``"; + + static const unsigned char TIME_COLUMN_MASK = 0x80; + static const unsigned char VALUE_COLUMN_MASK = 0x40; + + static const std::string TIME_COLUMN_ID = ""; + + static const std::regex IDENTIFIER_PATTERN("([a-zA-Z0-9_\\u2E80-\\u9FFF]+)"); + static const std::regex NODE_NAME_PATTERN("(\\*{0,2}[a-zA-Z0-9_\\u2E80-\\u9FFF]+\\*{0,2})"); +} // namespace storage diff --git a/cpp/src/common/mutex/mutex.h b/cpp/src/common/mutex/mutex.h index 18bb736e6..264d71dff 100644 --- a/cpp/src/common/mutex/mutex.h +++ b/cpp/src/common/mutex/mutex.h @@ -43,6 +43,7 @@ class Mutex { void unlock() { int ret = pthread_mutex_unlock(&mutex_); ASSERT(ret == 0); + (void) ret; } bool try_lock() { diff --git a/cpp/src/common/path.h b/cpp/src/common/path.h index 7a3b55b0c..c0ed63dd2 100644 --- a/cpp/src/common/path.h +++ b/cpp/src/common/path.h @@ -19,6 +19,10 @@ #ifndef COMMON_READ_COMMON_PATH_H #define COMMON_READ_COMMON_PATH_H +#include "utils/errno_define.h" +#include "parser/generated/PathParser.h" +#include "parser/path_nodes_generator.h" + #include namespace storage { @@ -35,6 +39,28 @@ struct Path { full_path_ = device + "." + measurement; } + Path(const std::string& path_sc, bool if_split = true) { + if (!path_sc.empty()) { + if (!if_split) { + full_path_ = path_sc; + device_ = path_sc; + } else { + std::vector nodes = PathNodesGenerator::invokeParser(path_sc); + if (nodes.size() > 0) { + for (uint64_t i = 0; i + 1 < nodes.size(); i++) { + device_ += nodes[i] + (i + 2 < nodes.size() ? "." : ""); + } + measurement_ = nodes[nodes.size() - 1]; + full_path_ = device_ + "." + measurement_; + } else { + full_path_ = path_sc; + device_ = ""; + measurement_ = path_sc; + } + } + } + } + bool operator==(const Path &path) { if (measurement_.compare(path.measurement_) == 0 && device_.compare(path.device_) == 0) { diff --git a/cpp/src/common/record.h b/cpp/src/common/record.h index 1fc275d46..1e1374634 100644 --- a/cpp/src/common/record.h +++ b/cpp/src/common/record.h @@ -24,7 +24,7 @@ #include #include "common/db_common.h" - +#include "utils/errno_define.h" namespace storage { // TODO: use std::move @@ -120,22 +120,24 @@ struct DataPoint { struct TsRecord { int64_t timestamp_; - std::string device_name_; + std::string device_id_; std::vector points_; - TsRecord(const std::string &device_name) : device_name_(device_name) {} + TsRecord(const std::string &device_name) : device_id_(device_name) {} TsRecord(int64_t timestamp, const std::string &device_name, int32_t point_count_in_row = 0) - : timestamp_(timestamp), device_name_(device_name), points_() { + : timestamp_(timestamp), device_id_(device_name), points_() { if (point_count_in_row > 0) { points_.reserve(point_count_in_row); } } - void append_data_point(const DataPoint &point) { - // points_.emplace_back(point); C++11 - points_.push_back(point); + template + int add_point(const std::string &measurement_name, T val) { + int ret = common::E_OK; + points_.emplace_back(DataPoint(measurement_name, val)); + return ret; } }; diff --git a/cpp/src/common/row_record.h b/cpp/src/common/row_record.h index 6901b08d7..83a4ff149 100644 --- a/cpp/src/common/row_record.h +++ b/cpp/src/common/row_record.h @@ -86,9 +86,31 @@ struct Field { } } + template + FORCE_INLINE T get_value() { + switch (type_) { + case common::TSDataType::BOOLEAN: + return value_.bval_; + case common::TSDataType::INT32: + return value_.ival_; + case common::TSDataType::INT64: + return value_.lval_; + case common::TSDataType::FLOAT: + return value_.fval_; + case common::TSDataType::DOUBLE: + return value_.dval_; + // case common::TSDataType::TEXT : + // return value_.sval_; + default: + std::cout << "unknown data type" << std::endl; + break; + } + return -1; // when data type is unknown + } + public: common::TSDataType type_; - + std::string column_name; union { bool bval_; int64_t lval_; @@ -182,6 +204,8 @@ class RowRecord { FORCE_INLINE std::vector *get_fields() { return fields_; } + FORCE_INLINE uint32_t get_col_num() { return col_num_; } + private: int64_t time_; // time value uint32_t col_num_; // measurement num diff --git a/cpp/src/common/schema.h b/cpp/src/common/schema.h index 087439dd0..f4710698f 100644 --- a/cpp/src/common/schema.h +++ b/cpp/src/common/schema.h @@ -50,6 +50,15 @@ struct MeasurementSchema { chunk_writer_(nullptr), value_chunk_writer_(nullptr) {} + MeasurementSchema(const std::string &measurement_name, + common::TSDataType data_type) + : measurement_name_(measurement_name), + data_type_(data_type), + encoding_(get_default_encoding_for_type(data_type)), + compression_type_(common::LZ4), + chunk_writer_(nullptr), + value_chunk_writer_(nullptr) {} + MeasurementSchema(const std::string &measurement_name, common::TSDataType data_type, common::TSEncoding encoding, common::CompressionType compression_type) diff --git a/cpp/src/common/tablet.cc b/cpp/src/common/tablet.cc index 1ed92cf4c..fa5c29947 100644 --- a/cpp/src/common/tablet.cc +++ b/cpp/src/common/tablet.cc @@ -29,7 +29,7 @@ namespace storage { int Tablet::init() { ASSERT(timestamps_ == NULL); - timestamps_ = (int64_t *)malloc(sizeof(int64_t) * max_rows_); + timestamps_ = (int64_t *)malloc(sizeof(int64_t) * max_row_num_); size_t schema_count = schema_vec_->size(); std::pair::iterator, bool> ins_res; @@ -48,12 +48,12 @@ int Tablet::init() { for (size_t c = 0; c < schema_count; c++) { const MeasurementSchema &schema = schema_vec_->at(c); value_matrix_[c] = - malloc(get_data_type_size(schema.data_type_) * max_rows_); + malloc(get_data_type_size(schema.data_type_) * max_row_num_); } bitmaps_ = new BitMap[schema_count]; for (size_t c = 0; c < schema_count; c++) { - bitmaps_[c].init(max_rows_, /*init_as_zero=*/true); + bitmaps_[c].init(max_row_num_, /*init_as_zero=*/true); } return E_OK; } @@ -75,9 +75,9 @@ void Tablet::destroy() { } } -int Tablet::set_timestamp(int row_index, int64_t timestamp) { +int Tablet::add_timestamp(uint32_t row_index, int64_t timestamp) { ASSERT(timestamps_ != NULL); - if (UNLIKELY(row_index >= max_rows_)) { + if (UNLIKELY(row_index >= static_cast(max_row_num_))) { ASSERT(false); return E_OUT_OF_RANGE; } @@ -85,80 +85,60 @@ int Tablet::set_timestamp(int row_index, int64_t timestamp) { return E_OK; } -#define DO_SET_VALUE_BY_COL_NAME(row_index, measurement_name, val) \ - do { \ - SchemaMapIterator find_iter = schema_map_.find(measurement_name); \ - if (LIKELY(find_iter == schema_map_.end())) { \ - ASSERT(false); \ - return E_INVALID_ARG; \ - } \ - return set_value(row_index, find_iter->second, val); \ - } while (false) - -#define DO_SET_VALUE_BY_COL_INDEX(row_index, schema_index, CppType, val) \ - do { \ - if (LIKELY(schema_index >= schema_vec_->size())) { \ - ASSERT(false); \ - return E_OUT_OF_RANGE; \ - } \ - const MeasurementSchema &schema = schema_vec_->at(schema_index); \ - if (LIKELY(GetDataTypeFromTemplateType() != \ - schema.data_type_)) { \ - return E_TYPE_NOT_MATCH; \ - } \ - CppType *column_values = (CppType *)value_matrix_[schema_index]; \ - column_values[row_index] = val; \ - bitmaps_[schema_index].set(row_index); /* mark as non-null*/ \ - } while (false) - -int Tablet::set_value(int row_index, const std::string &measurement_name, - bool val) { - DO_SET_VALUE_BY_COL_NAME(row_index, measurement_name, val); -} - -int Tablet::set_value(int row_index, const std::string &measurement_name, - int32_t val) { - DO_SET_VALUE_BY_COL_NAME(row_index, measurement_name, val); -} - -int Tablet::set_value(int row_index, const std::string &measurement_name, - int64_t val) { - DO_SET_VALUE_BY_COL_NAME(row_index, measurement_name, val); -} - -int Tablet::set_value(int row_index, const std::string &measurement_name, - float val) { - DO_SET_VALUE_BY_COL_NAME(row_index, measurement_name, val); -} - -int Tablet::set_value(int row_index, const std::string &measurement_name, - double val) { - DO_SET_VALUE_BY_COL_NAME(row_index, measurement_name, val); -} - -int Tablet::set_value(int row_index, uint32_t schema_index, bool val) { - DO_SET_VALUE_BY_COL_INDEX(row_index, schema_index, bool, val); - return E_OK; -} - -int Tablet::set_value(int row_index, uint32_t schema_index, int32_t val) { - DO_SET_VALUE_BY_COL_INDEX(row_index, schema_index, int32_t, val); - return E_OK; -} - -int Tablet::set_value(int row_index, uint32_t schema_index, int64_t val) { - DO_SET_VALUE_BY_COL_INDEX(row_index, schema_index, int64_t, val); - return E_OK; -} - -int Tablet::set_value(int row_index, uint32_t schema_index, float val) { - DO_SET_VALUE_BY_COL_INDEX(row_index, schema_index, float, val); - return E_OK; +template +int Tablet::add_value(uint32_t row_index, uint32_t schema_index, T val) { + int ret = common::E_OK; + if (LIKELY(schema_index >= schema_vec_->size())) { + ASSERT(false); + ret = common::E_OUT_OF_RANGE; + } else { + const MeasurementSchema &schema = schema_vec_->at(schema_index); + if (LIKELY(GetDataTypeFromTemplateType() != schema.data_type_)) { + ret = common::E_TYPE_NOT_MATCH; + } else { + T *column_values = (T *)value_matrix_[schema_index]; + column_values[row_index] = val; + bitmaps_[schema_index].set(row_index); /* mark as non-null*/ + } + } + return ret; } -int Tablet::set_value(int row_index, uint32_t schema_index, double val) { - DO_SET_VALUE_BY_COL_INDEX(row_index, schema_index, double, val); - return E_OK; +template +int Tablet::add_value(uint32_t row_index, const std::string &measurement_name, + T val) { + int ret = common::E_OK; + SchemaMapIterator find_iter = schema_map_.find(measurement_name); + if (LIKELY(find_iter == schema_map_.end())) { + ASSERT(false); + ret = E_INVALID_ARG; + } else { + ret = add_value(row_index, find_iter->second, val); + } + return ret; } +template int Tablet::add_value(uint32_t row_index, uint32_t schema_index, + bool val); +template int Tablet::add_value(uint32_t row_index, uint32_t schema_index, + int32_t val); +template int Tablet::add_value(uint32_t row_index, uint32_t schema_index, + int64_t val); +template int Tablet::add_value(uint32_t row_index, uint32_t schema_index, + float val); +template int Tablet::add_value(uint32_t row_index, uint32_t schema_index, + double val); + +template int Tablet::add_value(uint32_t row_index, + const std::string &measurement_name, bool val); +template int Tablet::add_value(uint32_t row_index, + const std::string &measurement_name, + int32_t val); +template int Tablet::add_value(uint32_t row_index, + const std::string &measurement_name, + int64_t val); +template int Tablet::add_value(uint32_t row_index, + const std::string &measurement_name, float val); +template int Tablet::add_value(uint32_t row_index, + const std::string &measurement_name, double val); } // end namespace storage \ No newline at end of file diff --git a/cpp/src/common/tablet.h b/cpp/src/common/tablet.h index 163f2ee87..55a686d62 100644 --- a/cpp/src/common/tablet.h +++ b/cpp/src/common/tablet.h @@ -20,6 +20,8 @@ #ifndef COMMON_TABLET_H #define COMMON_TABLET_H +#include +#include #include #include "common/container/bit_map.h" @@ -27,57 +29,76 @@ namespace storage { +template + class TabletRowIterator; class TabletColIterator; class Tablet { public: - static const int DEFAULT_MAX_ROWS = 1024; + static const uint32_t DEFAULT_MAX_ROWS = 1024; public: - Tablet(const std::string &device_name, - const std::vector *schema_vec, + Tablet(const std::string &device_id, + std::shared_ptr> schema_vec, int max_rows = DEFAULT_MAX_ROWS) - : max_rows_(max_rows), - device_name_(device_name), + : max_row_num_(max_rows), + device_id_(device_id), schema_vec_(schema_vec), timestamps_(NULL), value_matrix_(NULL), bitmaps_(NULL) { - ASSERT(device_name.size() >= 1); + ASSERT(device_id.size() >= 1); ASSERT(schema_vec != NULL); ASSERT(max_rows > 0 && max_rows < (1 << 30)); if (max_rows < 0) { ASSERT(false); - max_rows_ = DEFAULT_MAX_ROWS; + max_row_num_ = DEFAULT_MAX_ROWS; } } + + Tablet(const std::string &device_id, + const std::vector *measurement_list, + const std::vector *data_type_list, + int max_row_num = DEFAULT_MAX_ROWS) + : max_row_num_(max_row_num), + device_id_(device_id), + timestamps_(NULL), + value_matrix_(NULL), + bitmaps_(NULL) { + ASSERT(device_id.size() >= 1); + ASSERT(measurement_list != NULL); + ASSERT(data_type_list != NULL); + ASSERT(max_row_num > 0 && max_row_num < (1 << 30)); + if (max_row_num < 0) { + ASSERT(false); + max_row_num_ = DEFAULT_MAX_ROWS; + } + + ASSERT(measurement_list->size() == data_type_list->size()); + std::vector measurement_vec; + measurement_vec.reserve(measurement_list->size()); + std::transform(measurement_list->begin(), measurement_list->end(), + data_type_list->begin(), + std::back_inserter(measurement_vec), + [](const std::string &name, common::TSDataType type) { + return MeasurementSchema(name, type); + }); + } ~Tablet() { destroy(); } int init(); void destroy(); size_t get_column_count() const { return schema_vec_->size(); } - int set_timestamp(int row_index, int64_t timestamp); - - int set_value(int row_index, uint32_t schema_index, bool val); - int set_value(int row_index, uint32_t schema_index, int32_t val); - int set_value(int row_index, uint32_t schema_index, int64_t val); - int set_value(int row_index, uint32_t schema_index, float val); - int set_value(int row_index, uint32_t schema_index, double val); - // int set_value(int row_index, int schema_index, double val); - - int set_value(int row_index, const std::string &measurement_name, bool val); - int set_value(int row_index, const std::string &measurement_name, - int32_t val); - int set_value(int row_index, const std::string &measurement_name, - int64_t val); - int set_value(int row_index, const std::string &measurement_name, - float val); - int set_value(int row_index, const std::string &measurement_name, - double val); - // int set_value(int row_index, const std::string &measurement_name, double - // val); + int add_timestamp(uint32_t row_index, int64_t timestamp); + + template + int add_value(uint32_t row_index, uint32_t schema_index, T val); + + template + int add_value(uint32_t row_index, const std::string &measurement_name, + T val); friend class TabletColIterator; friend class TsFileWriter; @@ -87,9 +108,9 @@ class Tablet { typedef std::map::iterator SchemaMapIterator; private: - int max_rows_; - std::string device_name_; - const std::vector *schema_vec_; + int max_row_num_; + std::string device_id_; + std::shared_ptr> schema_vec_; std::map schema_map_; int64_t *timestamps_; void **value_matrix_; diff --git a/cpp/src/common/tsfile_common.h b/cpp/src/common/tsfile_common.h index 0a3d37028..5c42fffa5 100644 --- a/cpp/src/common/tsfile_common.h +++ b/cpp/src/common/tsfile_common.h @@ -699,10 +699,11 @@ enum MetaIndexNodeType { LEAF_MEASUREMENT = 3, INVALID_META_NODE_TYPE = 4, }; - +#ifndef NDEBUG static const char *meta_index_node_type_names[5] = { "INTERNAL_DEVICE", "LEAF_DEVICE", "INTERNAL_MEASUREMENT", "LEAF_MEASUREMENT", "INVALID_META_NODE_TYPE"}; +#endif struct MetaIndexNode { // TODO use vector to support binary search diff --git a/cpp/src/cwrapper/TsFile-cwrapper.cc b/cpp/src/cwrapper/TsFile-cwrapper.cc index d19c47694..347608304 100644 --- a/cpp/src/cwrapper/TsFile-cwrapper.cc +++ b/cpp/src/cwrapper/TsFile-cwrapper.cc @@ -27,7 +27,7 @@ #include "reader/filter/filter.h" #include "reader/filter/time_filter.h" #include "reader/filter/time_operator.h" -#include "reader/query_data_set.h" +#include "reader/result_set.h" #include "reader/tsfile_reader.h" #include "utils/errno_define.h" #include "writer/tsfile_writer.h" @@ -206,10 +206,12 @@ ErrorCode tsfile_register_table_column(CTsFileWriter writer, const char* table_name, ColumnSchema* schema) { TsFileWriter* w = (TsFileWriter*)writer; - int ret = w->register_timeseries(table_name, schema->name, - get_datatype(schema->column_def), - get_data_encoding(schema->column_def), - get_data_compression(schema->column_def)); + + int ret = w->register_timeseries( + table_name, storage::MeasurementSchema( + schema->name, get_datatype(schema->column_def), + get_data_encoding(schema->column_def), + get_data_compression(schema->column_def))); return ret; } @@ -218,11 +220,12 @@ ErrorCode tsfile_register_table(CTsFileWriter writer, TsFileWriter* w = (TsFileWriter*)writer; for (int column_id = 0; column_id < table_schema->column_num; column_id++) { ColumnSchema* schema = table_schema->column_schema[column_id]; - ErrorCode ret = - w->register_timeseries(table_schema->table_name, schema->name, - get_datatype(schema->column_def), - get_data_encoding(schema->column_def), - get_data_compression(schema->column_def)); + ErrorCode ret = w->register_timeseries( + table_schema->table_name, + storage::MeasurementSchema( + schema->name, get_datatype(schema->column_def), + get_data_encoding(schema->column_def), + get_data_compression(schema->column_def))); if (ret != E_OK) { return ret; } @@ -593,7 +596,7 @@ QueryDataRet ts_reader_query(CTsFileReader reader, const char* table_name, selected_paths.push_back(storage::Path(table_name_str, column_name)); } - storage::QueryDataSet* qds = nullptr; + storage::ResultSet* qds = nullptr; storage::QueryExpression* query_expression = storage::QueryExpression::create(selected_paths, (storage::Expression*)expression); @@ -605,7 +608,6 @@ QueryDataRet ts_reader_query(CTsFileReader reader, const char* table_name, for (int i = 0; i < column_num; i++) { ret->column_names[i] = strdup(columns_name[i]); } - storage::QueryExpression::destory(query_expression); return ret; } @@ -620,7 +622,7 @@ QueryDataRet ts_reader_begin_end(CTsFileReader reader, const char* table_name, selected_paths.push_back(storage::Path(table_name_str, column_name)); } - storage::QueryDataSet* qds = nullptr; + storage::ResultSet* qds = nullptr; storage::Filter* filter_low = nullptr; storage::Filter* filter_high = nullptr; storage::Expression* exp = nullptr; @@ -633,7 +635,8 @@ QueryDataRet ts_reader_begin_end(CTsFileReader reader, const char* table_name, } if (filter_low != nullptr && filter_high != nullptr) { and_filter = new storage::AndFilter(filter_low, filter_high); - exp = new storage::Expression(storage::GLOBALTIME_EXPR, and_filter); + exp = new storage::Expression(storage::GLOBALTIME_EXPR, + and_filter); // exp never be deleted } else if (filter_low != nullptr && filter_high == nullptr) { exp = new storage::Expression(storage::GLOBALTIME_EXPR, filter_low); } else if (filter_high != nullptr && filter_low == nullptr) { @@ -649,7 +652,6 @@ QueryDataRet ts_reader_begin_end(CTsFileReader reader, const char* table_name, for (int i = 0; i < column_num; i++) { ret->column_names[i] = strdup(columns_name[i]); } - storage::QueryExpression::destory(query_expr); return ret; } @@ -662,7 +664,7 @@ QueryDataRet ts_reader_read(CTsFileReader reader, const char* table_name, std::string column_name(columns_name[i]); selected_paths.push_back(storage::Path(table_name_str, column_name)); } - storage::QueryDataSet* qds = nullptr; + storage::ResultSet* qds = nullptr; storage::QueryExpression* query_expr = storage::QueryExpression::create(selected_paths, nullptr); r->query(query_expr, qds); @@ -673,12 +675,11 @@ QueryDataRet ts_reader_read(CTsFileReader reader, const char* table_name, for (int i = 0; i < column_num; i++) { ret->column_names[i] = strdup(columns_name[i]); } - storage::QueryExpression::destory(query_expr); return ret; } ErrorCode destory_query_dataret(QueryDataRet data) { - storage::QueryDataSet* qds = (storage::QueryDataSet*)data->data; + storage::ResultSet* qds = (storage::ResultSet*)data->data; delete qds; for (int i = 0; i < data->column_num; i++) { free(data->column_names[i]); @@ -689,17 +690,15 @@ ErrorCode destory_query_dataret(QueryDataRet data) { } DataResult* ts_next(QueryDataRet data, int expect_line_count) { - storage::QueryDataSet* qds = (storage::QueryDataSet*)data->data; + storage::ResultSet* qds = (storage::ResultSet*)data->data; DataResult* result = create_tablet("result", expect_line_count); storage::RowRecord* record; bool init_tablet = false; for (int i = 0; i < expect_line_count; i++) { - record = qds->get_next(); - if (record == nullptr) { + if (!qds->next()) { break; - std::cout << "record null now" - << "i = " << i << std::endl; } + record = qds->get_row_record(); int column_num = record->get_fields()->size(); if (!init_tablet) { for (int col = 0; col < column_num; col++) { diff --git a/cpp/src/encoding/encoder_factory.h b/cpp/src/encoding/encoder_factory.h index e9e02e4b2..0e582ae3b 100644 --- a/cpp/src/encoding/encoder_factory.h +++ b/cpp/src/encoding/encoder_factory.h @@ -55,6 +55,18 @@ class EncoderFactory { } } + static Encoder *alloc_time_encoder(common::TSEncoding encoding) { + if (encoding == common::PLAIN) { + ALLOC_AND_RETURN_ENCODER(PlainEncoder); + } else if (encoding == common::TS_2DIFF) { + ALLOC_AND_RETURN_ENCODER(LongTS2DIFFEncoder); + } else { + // not support now + ASSERT(false); + return nullptr; + } + } + static Encoder *alloc_value_encoder(common::TSEncoding encoding, common::TSDataType data_type) { if (encoding == common::PLAIN) { diff --git a/cpp/src/file/CMakeLists.txt b/cpp/src/file/CMakeLists.txt index 3b4b171f3..e0d863112 100644 --- a/cpp/src/file/CMakeLists.txt +++ b/cpp/src/file/CMakeLists.txt @@ -16,7 +16,7 @@ KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ]] -message("running in src/fuke diectory") +message("running in src/file diectory") message("CMAKE_CURRENT_SOURCE_DIR: ${CMAKE_CURRENT_SOURCE_DIR}") set(CMAKE_POSITION_INDEPENDENT_CODE ON) diff --git a/cpp/src/file/open_file.cc b/cpp/src/file/open_file.cc index 2543f1bf7..1d9002466 100644 --- a/cpp/src/file/open_file.cc +++ b/cpp/src/file/open_file.cc @@ -25,6 +25,7 @@ namespace storage { int OpenFile::init() { void *buf = mem_alloc(sizeof(TsTimeRangeMap), MOD_OPEN_FILE_OBJ); + fd_ = -1; if (IS_NULL(buf)) { return E_OOM; } diff --git a/cpp/src/file/tsfile_io_reader.cc b/cpp/src/file/tsfile_io_reader.cc index cba47f533..c39f3cef9 100644 --- a/cpp/src/file/tsfile_io_reader.cc +++ b/cpp/src/file/tsfile_io_reader.cc @@ -88,6 +88,25 @@ void TsFileIOReader::revert_ssi(TsFileSeriesScanIterator *ssi) { } } +int TsFileIOReader::get_device_timeseries_meta_without_chunk_meta( + std::string device_id, std::vector ×eries_indexs, + PageArena &pa) { + int ret = E_OK; + load_tsfile_meta_if_necessary(); + MetaIndexEntry meta_index_entry; + int64_t end_offset; + std::vector> meta_index_entry_list; + if (RET_FAIL( + load_device_index_entry(device_id, meta_index_entry, end_offset))) { + } else if (RET_FAIL(load_all_measurement_index_entry( + meta_index_entry.offset_, end_offset, pa, + meta_index_entry_list))) { + } else if (RET_FAIL(do_load_all_timeseries_index(meta_index_entry_list, pa, + timeseries_indexs))) { + } + return ret; +} + bool TsFileIOReader::filter_stasify(ITimeseriesIndex *ts_index, Filter *time_filter) { ASSERT(ts_index->get_statistic() != nullptr); @@ -304,6 +323,47 @@ int TsFileIOReader::load_measurement_index_entry( return ret; } +int TsFileIOReader::load_all_measurement_index_entry( + int64_t start_offset, int64_t end_offset, common::PageArena &pa, + std::vector> + &ret_measurement_index_entry) { +#if DEBUG_SE + std::cout << "load_measurement_index_entry: measurement_name_str=" + << measurement_name_str << ", start_offset=" << start_offset + << ", end_offset=" << end_offset << std::endl; +#endif + ASSERT(start_offset < end_offset); + int ret = E_OK; + // 1. load top measuremnt_index_node + const int32_t read_size = (int32_t)(end_offset - start_offset); + int32_t ret_read_len = 0; + char *data_buf = (char *)pa.alloc(read_size); + void *m_idx_node_buf = pa.alloc(sizeof(MetaIndexNode)); + if (IS_NULL(data_buf) || IS_NULL(m_idx_node_buf)) { + return E_OOM; + } + MetaIndexNode *top_node = new (m_idx_node_buf) MetaIndexNode(&pa); + if (RET_FAIL(read_file_->read(start_offset, data_buf, read_size, + ret_read_len))) { + } else if (RET_FAIL(top_node->deserialize_from(data_buf, read_size))) { + } +#if DEBUG_SE + std::cout + << "load_measurement_index_entry deserialize MetaIndexNode, top_node=" + << *top_node << " at file pos " << start_offset << " to " << end_offset + << std::endl; +#endif + // 2. search from top_node in top-down way + if (IS_SUCC(ret)) { + get_all_leaf(top_node, ret_measurement_index_entry); + } + if (ret == E_NOT_EXIST) { + ret = E_MEASUREMENT_NOT_EXIST; + } + top_node->children_.~vector(); + return ret; +} + /* * @target_name device_name or measurement_name * @index_node leaf device node or leaf measurement node @@ -457,6 +517,80 @@ int TsFileIOReader::do_load_timeseries_index( return ret; } +int TsFileIOReader::do_load_all_timeseries_index( + std::vector> &index_node_entry_list, + common::PageArena &in_timeseries_index_pa, + std::vector &ts_indexs) { + int ret = E_OK; + for (const auto &index_node_entry : index_node_entry_list) { + int64_t start_offset = index_node_entry.first->offset_, + end_offset = index_node_entry.second; + const std::string target_measurement_name( + index_node_entry.first->name_.to_std_string()); + ITimeseriesIndex *ts_idx; + ret = do_load_timeseries_index(target_measurement_name, start_offset, + end_offset, in_timeseries_index_pa, + ts_idx); + if (IS_SUCC(ret)) { + ts_indexs.push_back(ts_idx); + } + } + return ret; +} + +int TsFileIOReader::get_all_leaf( + MetaIndexNode *index_node, + std::vector> &index_node_entry_list) { + int ret = E_OK; + if (index_node->node_type_ == LEAF_MEASUREMENT || + index_node->node_type_ == LEAF_DEVICE) { + for (size_t i = 0; i < index_node->children_.size(); i++) { + if (i + 1 < index_node->children_.size()) { + index_node_entry_list.push_back( + std::make_pair(index_node->children_[i], + index_node->children_[i + 1]->offset_)); + } else { + index_node_entry_list.push_back(std::make_pair( + index_node->children_[i], index_node->end_offset_)); + } + } + } else { + // read next level index node + for (size_t i = 0; i < index_node->children_.size(); i++) { + int64_t end_offset = index_node->end_offset_; + if (i + 1 < index_node->children_.size()) { + end_offset = index_node->children_[i + 1]->offset_; + } + const int read_size = + end_offset - index_node->children_[i]->offset_; +#if DEBUG_SE + std::cout << "search_from_internal_node, end_offset=" << end_offset + << ", index_entry.offset_=" << index_entry.offset_ + << std::endl; +#endif + ASSERT(read_size > 0 && read_size < (1 << 30)); + PageArena cur_level_index_node_pa; + void *buf = cur_level_index_node_pa.alloc(sizeof(MetaIndexNode)); + char *data_buf = (char *)cur_level_index_node_pa.alloc(read_size); + if (IS_NULL(buf) || IS_NULL(data_buf)) { + return E_OOM; + } + MetaIndexNode *cur_level_index_node = + new (buf) MetaIndexNode(&cur_level_index_node_pa); + int32_t ret_read_len = 0; + if (RET_FAIL(read_file_->read(index_node->children_[i]->offset_, + data_buf, read_size, ret_read_len))) { + } else if (read_size != ret_read_len) { + ret = E_TSFILE_CORRUPTED; + } else if (RET_FAIL(cur_level_index_node->deserialize_from( + data_buf, read_size))) { + } else { + ret = get_all_leaf(cur_level_index_node, index_node_entry_list); + } + } + } + return ret; +} #if 0 int TsFileIOReader::get_next(const std::string &device_path, const std::string &measurement_name, diff --git a/cpp/src/file/tsfile_io_reader.h b/cpp/src/file/tsfile_io_reader.h index 8c26e547b..a8d8419bd 100644 --- a/cpp/src/file/tsfile_io_reader.h +++ b/cpp/src/file/tsfile_io_reader.h @@ -59,6 +59,15 @@ class TsFileIOReader { Filter *time_filter = nullptr); void revert_ssi(TsFileSeriesScanIterator *ssi); std::string get_file_path() const { return read_file_->file_path(); } + TsFileMeta *get_tsfile_meta() { + load_tsfile_meta_if_necessary(); + return &tsfile_meta_; + } + + int get_device_timeseries_meta_without_chunk_meta( + std::string device_id, + std::vector ×eries_indexs, + common::PageArena &pa); private: FORCE_INLINE int32_t file_size() const { return read_file_->file_size(); } @@ -71,10 +80,19 @@ class TsFileIOReader { const std::string &measurement_name, int64_t start_offset, int64_t end_offset, MetaIndexEntry &ret_measurement_index_entry, int64_t &ret_end_offset); + int load_all_measurement_index_entry( + int64_t start_offset, int64_t end_offset, common::PageArena &pa, + std::vector> + &ret_measurement_index_entry); int do_load_timeseries_index(const std::string &measurement_name_str, int64_t start_offset, int64_t end_offset, common::PageArena &pa, ITimeseriesIndex *&ts_index); + int do_load_all_timeseries_index( + std::vector> + &index_node_entry_list, + common::PageArena &in_timeseries_index_pa, + std::vector &ts_indexs); int load_timeseries_index_for_ssi(const std::string &device_path, const std::string &measurement_name, TsFileSeriesScanIterator *&ssi); @@ -88,6 +106,10 @@ class TsFileIOReader { int64_t &ret_end_offset); bool filter_stasify(ITimeseriesIndex *ts_index, Filter *time_filter); + int get_all_leaf(MetaIndexNode *index_node, + std::vector> + &index_node_entry_list); + private: ReadFile *read_file_; common::PageArena tsfile_meta_page_arena_; diff --git a/cpp/src/file/tsfile_io_writer.cc b/cpp/src/file/tsfile_io_writer.cc index 99c6ec64f..be153754b 100644 --- a/cpp/src/file/tsfile_io_writer.cc +++ b/cpp/src/file/tsfile_io_writer.cc @@ -648,7 +648,6 @@ int TsFileIOWriter::generate_root(SimpleList *node_queue, if (RET_FAIL( alloc_and_init_meta_index_node(wmm, cur_index_node, node_type))) { } - uint32_t from_size = from->size(); while (IS_SUCC(ret)) { to->clear(); SimpleList::Iterator from_iter; @@ -700,7 +699,7 @@ int TsFileIOWriter::generate_root(SimpleList *node_queue, } } if (IS_SUCC(ret)) { - ASSERT(from_size > to->size()); + ASSERT(from->size() > to->size()); if (to->size() == 1) { root_node = to->front(); break; diff --git a/cpp/src/parser/CMakeLists.txt b/cpp/src/parser/CMakeLists.txt new file mode 100644 index 000000000..92694434e --- /dev/null +++ b/cpp/src/parser/CMakeLists.txt @@ -0,0 +1,22 @@ +#[[ +Licensed to the Apache Software Foundation (ASF) under one +or more contributor license agreements. See the NOTICE file +distributed with this work for additional information +regarding copyright ownership. The ASF licenses this file +to you under the Apache License, Version 2.0 (the +"License"); you may not use this file except in compliance +with the License. You may obtain a copy of the License at + + https://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, +software distributed under the License is distributed on an +"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +KIND, either express or implied. See the License for the +specific language governing permissions and limitations +under the License. +]] +message("Running in src/parser directory") +set(CMAKE_POSITION_INDEPENDENT_CODE ON) +file(GLOB_RECURSE PARSER_SRC_LIST "*.cpp") +add_library(parser_obj OBJECT ${PARSER_SRC_LIST}) diff --git a/cpp/src/parser/PathLexer.g4 b/cpp/src/parser/PathLexer.g4 new file mode 100644 index 000000000..0f682f4ea --- /dev/null +++ b/cpp/src/parser/PathLexer.g4 @@ -0,0 +1,212 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +lexer grammar PathLexer; + +ROOT + : R O O T + ; + +/** + * 1. Whitespace + */ + +// Instead of discarding whitespace completely, send them to a channel invisable to the parser, so +// that the lexer could still produce WS tokens for the CLI's highlighter. +WS + : + [ \u000B\t\r\n]+ -> channel(HIDDEN) + ; + +/** + * 2. Keywords, new keywords should be added into IdentifierParser.g4 + */ + +// Common Keywords + +TIME + : T I M E + ; + +TIMESTAMP + : T I M E S T A M P + ; + +/** + * 3. Operators + */ + +// Operators. Arithmetics + +MINUS : '-'; +PLUS : '+'; +DIV : '/'; +MOD : '%'; + + +// Operators. Comparation + +OPERATOR_DEQ : '=='; +OPERATOR_SEQ : '='; +OPERATOR_GT : '>'; +OPERATOR_GTE : '>='; +OPERATOR_LT : '<'; +OPERATOR_LTE : '<='; +OPERATOR_NEQ : '!=' | '<>'; + +OPERATOR_BITWISE_AND : '&'; + +OPERATOR_LOGICAL_AND : '&&'; + +OPERATOR_BITWISE_OR : '|'; + +OPERATOR_LOGICAL_OR : '||'; + +OPERATOR_NOT : '!'; + +/** + * 4. Constructors Symbols + */ + +DOT : '.'; +COMMA : ','; +SEMI: ';'; +STAR: '*'; +DOUBLE_STAR: '**'; +LR_BRACKET : '('; +RR_BRACKET : ')'; +LS_BRACKET : '['; +RS_BRACKET : ']'; +DOUBLE_COLON: '::'; + +/** + * 5. Literals + */ + +// String Literal + +STRING_LITERAL + : DQUOTA_STRING + | SQUOTA_STRING + ; + + +// Date & Time Literal + +DURATION_LITERAL + : (INTEGER_LITERAL+ (Y|M O|W|D|H|M|S|M S|U S|N S))+ + ; + +DATETIME_LITERAL + : DATE_LITERAL ((T | WS) TIME_LITERAL (('+' | '-') INTEGER_LITERAL ':' INTEGER_LITERAL)?)? + ; + +fragment DATE_LITERAL + : INTEGER_LITERAL '-' INTEGER_LITERAL '-' INTEGER_LITERAL + | INTEGER_LITERAL '/' INTEGER_LITERAL '/' INTEGER_LITERAL + | INTEGER_LITERAL '.' INTEGER_LITERAL '.' INTEGER_LITERAL + ; + +fragment TIME_LITERAL + : INTEGER_LITERAL ':' INTEGER_LITERAL ':' INTEGER_LITERAL (DOT INTEGER_LITERAL)? + ; + +// Number Literal + +INTEGER_LITERAL + : DEC_DIGIT+ + ; + +EXPONENT_NUM_PART + : DEC_DIGIT+ ('e'|'E') ('+'|'-')? DEC_DIGIT+ + ; + +fragment DEC_DIGIT + : [0-9] + ; + + +ID + : NAME_CHAR+ + ; + +QUOTED_ID + : BQUOTA_STRING + ; + + + +fragment NAME_CHAR + : 'A'..'Z' + | 'a'..'z' + | '0'..'9' + | '_' + | ':' + | '@' + | '#' + | '$' + | '{' + | '}' + | CN_CHAR + ; + +fragment CN_CHAR + : '\u2E80'..'\u9FFF' + ; + +fragment DQUOTA_STRING + : '"' ( '""' | ~('"') )* '"' + ; + +fragment SQUOTA_STRING + : '\'' ( '\'\'' | ~('\'') )* '\'' + ; + +fragment BQUOTA_STRING + : '`' ( '``' | ~('`') )* '`' + ; + +// Characters and write it this way for case sensitivity + +fragment A: [aA]; +fragment B: [bB]; +fragment C: [cC]; +fragment D: [dD]; +fragment E: [eE]; +fragment F: [fF]; +fragment G: [gG]; +fragment H: [hH]; +fragment I: [iI]; +fragment J: [jJ]; +fragment K: [kK]; +fragment L: [lL]; +fragment M: [mM]; +fragment N: [nN]; +fragment O: [oO]; +fragment P: [pP]; +fragment Q: [qQ]; +fragment R: [rR]; +fragment S: [sS]; +fragment T: [tT]; +fragment U: [uU]; +fragment V: [vV]; +fragment W: [wW]; +fragment X: [xX]; +fragment Y: [yY]; +fragment Z: [zZ]; \ No newline at end of file diff --git a/cpp/src/parser/PathParser.g4 b/cpp/src/parser/PathParser.g4 new file mode 100644 index 000000000..91acbed70 --- /dev/null +++ b/cpp/src/parser/PathParser.g4 @@ -0,0 +1,67 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +parser grammar PathParser; + +options { tokenVocab=PathLexer; } + + +/** + * PartialPath and Path used by Session API and TsFile API should be parsed by Antlr4. + */ + +path + : prefixPath EOF + | suffixPath EOF + ; + +prefixPath + : ROOT (DOT nodeName)* + ; + +suffixPath + : nodeName (DOT nodeName)* + ; + +nodeName + : wildcard + | wildcard nodeNameSlice wildcard? + | nodeNameSlice wildcard + | nodeNameWithoutWildcard + ; + +nodeNameWithoutWildcard + : identifier + ; + +nodeNameSlice + : identifier + | INTEGER_LITERAL + ; + +identifier + : DURATION_LITERAL + | ID + | QUOTED_ID + ; + +wildcard + : STAR + | DOUBLE_STAR + ; diff --git a/cpp/src/parser/generated/PathLexer.cpp b/cpp/src/parser/generated/PathLexer.cpp new file mode 100644 index 000000000..bb4dcd217 --- /dev/null +++ b/cpp/src/parser/generated/PathLexer.cpp @@ -0,0 +1,470 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * License); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +// Generated from PathLexer.g4 by ANTLR 4.9.3 + + +#include "PathLexer.h" + + +using namespace antlr4; + + +PathLexer::PathLexer(CharStream *input) : Lexer(input) { + _interpreter = new atn::LexerATNSimulator(this, _atn, _decisionToDFA, _sharedContextCache); +} + +PathLexer::~PathLexer() { + delete _interpreter; +} + +std::string PathLexer::getGrammarFileName() const { + return "PathLexer.g4"; +} + +const std::vector& PathLexer::getRuleNames() const { + return _ruleNames; +} + +const std::vector& PathLexer::getChannelNames() const { + return _channelNames; +} + +const std::vector& PathLexer::getModeNames() const { + return _modeNames; +} + +const std::vector& PathLexer::getTokenNames() const { + return _tokenNames; +} + +dfa::Vocabulary& PathLexer::getVocabulary() const { + return _vocabulary; +} + +const std::vector PathLexer::getSerializedATN() const { + return _serializedATN; +} + +const atn::ATN& PathLexer::getATN() const { + return _atn; +} + + + + +// Static vars and initialization. +std::vector PathLexer::_decisionToDFA; +atn::PredictionContextCache PathLexer::_sharedContextCache; + +// We own the ATN which in turn owns the ATN states. +atn::ATN PathLexer::_atn; +std::vector PathLexer::_serializedATN; + +std::vector PathLexer::_ruleNames = { + "ROOT", "WS", "TIME", "TIMESTAMP", "MINUS", "PLUS", "DIV", "MOD", "OPERATOR_DEQ", + "OPERATOR_SEQ", "OPERATOR_GT", "OPERATOR_GTE", "OPERATOR_LT", "OPERATOR_LTE", + "OPERATOR_NEQ", "OPERATOR_BITWISE_AND", "OPERATOR_LOGICAL_AND", "OPERATOR_BITWISE_OR", + "OPERATOR_LOGICAL_OR", "OPERATOR_NOT", "DOT", "COMMA", "SEMI", "STAR", + "DOUBLE_STAR", "LR_BRACKET", "RR_BRACKET", "LS_BRACKET", "RS_BRACKET", + "DOUBLE_COLON", "STRING_LITERAL", "DURATION_LITERAL", "DATETIME_LITERAL", + "DATE_LITERAL", "TIME_LITERAL", "INTEGER_LITERAL", "EXPONENT_NUM_PART", + "DEC_DIGIT", "ID", "QUOTED_ID", "NAME_CHAR", "CN_CHAR", "DQUOTA_STRING", + "SQUOTA_STRING", "BQUOTA_STRING", "A", "B", "C", "D", "E", "F", "G", "H", + "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", + "W", "X", "Y", "Z" +}; + +std::vector PathLexer::_channelNames = { + "DEFAULT_TOKEN_CHANNEL", "HIDDEN" +}; + +std::vector PathLexer::_modeNames = { + "DEFAULT_MODE" +}; + +std::vector PathLexer::_literalNames = { + "", "", "", "", "", "'-'", "'+'", "'/'", "'%'", "'=='", "'='", "'>'", + "'>='", "'<'", "'<='", "", "'&'", "'&&'", "'|'", "'||'", "'!'", "'.'", + "','", "';'", "'*'", "'**'", "'('", "')'", "'['", "']'", "'::'" +}; + +std::vector PathLexer::_symbolicNames = { + "", "ROOT", "WS", "TIME", "TIMESTAMP", "MINUS", "PLUS", "DIV", "MOD", + "OPERATOR_DEQ", "OPERATOR_SEQ", "OPERATOR_GT", "OPERATOR_GTE", "OPERATOR_LT", + "OPERATOR_LTE", "OPERATOR_NEQ", "OPERATOR_BITWISE_AND", "OPERATOR_LOGICAL_AND", + "OPERATOR_BITWISE_OR", "OPERATOR_LOGICAL_OR", "OPERATOR_NOT", "DOT", "COMMA", + "SEMI", "STAR", "DOUBLE_STAR", "LR_BRACKET", "RR_BRACKET", "LS_BRACKET", + "RS_BRACKET", "DOUBLE_COLON", "STRING_LITERAL", "DURATION_LITERAL", "DATETIME_LITERAL", + "INTEGER_LITERAL", "EXPONENT_NUM_PART", "ID", "QUOTED_ID" +}; + +dfa::Vocabulary PathLexer::_vocabulary(_literalNames, _symbolicNames); + +std::vector PathLexer::_tokenNames; + +PathLexer::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, 0x27, 0x1b0, 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, 0x4, 0x22, 0x9, 0x22, + 0x4, 0x23, 0x9, 0x23, 0x4, 0x24, 0x9, 0x24, 0x4, 0x25, 0x9, 0x25, + 0x4, 0x26, 0x9, 0x26, 0x4, 0x27, 0x9, 0x27, 0x4, 0x28, 0x9, 0x28, + 0x4, 0x29, 0x9, 0x29, 0x4, 0x2a, 0x9, 0x2a, 0x4, 0x2b, 0x9, 0x2b, + 0x4, 0x2c, 0x9, 0x2c, 0x4, 0x2d, 0x9, 0x2d, 0x4, 0x2e, 0x9, 0x2e, + 0x4, 0x2f, 0x9, 0x2f, 0x4, 0x30, 0x9, 0x30, 0x4, 0x31, 0x9, 0x31, + 0x4, 0x32, 0x9, 0x32, 0x4, 0x33, 0x9, 0x33, 0x4, 0x34, 0x9, 0x34, + 0x4, 0x35, 0x9, 0x35, 0x4, 0x36, 0x9, 0x36, 0x4, 0x37, 0x9, 0x37, + 0x4, 0x38, 0x9, 0x38, 0x4, 0x39, 0x9, 0x39, 0x4, 0x3a, 0x9, 0x3a, + 0x4, 0x3b, 0x9, 0x3b, 0x4, 0x3c, 0x9, 0x3c, 0x4, 0x3d, 0x9, 0x3d, + 0x4, 0x3e, 0x9, 0x3e, 0x4, 0x3f, 0x9, 0x3f, 0x4, 0x40, 0x9, 0x40, + 0x4, 0x41, 0x9, 0x41, 0x4, 0x42, 0x9, 0x42, 0x4, 0x43, 0x9, 0x43, + 0x4, 0x44, 0x9, 0x44, 0x4, 0x45, 0x9, 0x45, 0x4, 0x46, 0x9, 0x46, + 0x4, 0x47, 0x9, 0x47, 0x4, 0x48, 0x9, 0x48, 0x3, 0x2, 0x3, 0x2, 0x3, + 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x3, 0x6, 0x3, 0x98, 0xa, 0x3, 0xd, + 0x3, 0xe, 0x3, 0x99, 0x3, 0x3, 0x3, 0x3, 0x3, 0x4, 0x3, 0x4, 0x3, + 0x4, 0x3, 0x4, 0x3, 0x4, 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, + 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x3, + 0x6, 0x3, 0x6, 0x3, 0x7, 0x3, 0x7, 0x3, 0x8, 0x3, 0x8, 0x3, 0x9, + 0x3, 0x9, 0x3, 0xa, 0x3, 0xa, 0x3, 0xa, 0x3, 0xb, 0x3, 0xb, 0x3, + 0xc, 0x3, 0xc, 0x3, 0xd, 0x3, 0xd, 0x3, 0xd, 0x3, 0xe, 0x3, 0xe, + 0x3, 0xf, 0x3, 0xf, 0x3, 0xf, 0x3, 0x10, 0x3, 0x10, 0x3, 0x10, 0x3, + 0x10, 0x5, 0x10, 0xc8, 0xa, 0x10, 0x3, 0x11, 0x3, 0x11, 0x3, 0x12, + 0x3, 0x12, 0x3, 0x12, 0x3, 0x13, 0x3, 0x13, 0x3, 0x14, 0x3, 0x14, + 0x3, 0x14, 0x3, 0x15, 0x3, 0x15, 0x3, 0x16, 0x3, 0x16, 0x3, 0x17, + 0x3, 0x17, 0x3, 0x18, 0x3, 0x18, 0x3, 0x19, 0x3, 0x19, 0x3, 0x1a, + 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1b, 0x3, 0x1b, 0x3, 0x1c, 0x3, 0x1c, + 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1e, 0x3, 0x1e, 0x3, 0x1f, 0x3, 0x1f, + 0x3, 0x1f, 0x3, 0x20, 0x3, 0x20, 0x5, 0x20, 0xee, 0xa, 0x20, 0x3, + 0x21, 0x6, 0x21, 0xf1, 0xa, 0x21, 0xd, 0x21, 0xe, 0x21, 0xf2, 0x3, + 0x21, 0x3, 0x21, 0x3, 0x21, 0x3, 0x21, 0x3, 0x21, 0x3, 0x21, 0x3, + 0x21, 0x3, 0x21, 0x3, 0x21, 0x3, 0x21, 0x3, 0x21, 0x3, 0x21, 0x3, + 0x21, 0x3, 0x21, 0x3, 0x21, 0x3, 0x21, 0x3, 0x21, 0x3, 0x21, 0x5, + 0x21, 0x107, 0xa, 0x21, 0x6, 0x21, 0x109, 0xa, 0x21, 0xd, 0x21, 0xe, + 0x21, 0x10a, 0x3, 0x22, 0x3, 0x22, 0x3, 0x22, 0x5, 0x22, 0x110, 0xa, + 0x22, 0x3, 0x22, 0x3, 0x22, 0x3, 0x22, 0x3, 0x22, 0x3, 0x22, 0x3, + 0x22, 0x5, 0x22, 0x118, 0xa, 0x22, 0x5, 0x22, 0x11a, 0xa, 0x22, 0x3, + 0x23, 0x3, 0x23, 0x3, 0x23, 0x3, 0x23, 0x3, 0x23, 0x3, 0x23, 0x3, + 0x23, 0x3, 0x23, 0x3, 0x23, 0x3, 0x23, 0x3, 0x23, 0x3, 0x23, 0x3, + 0x23, 0x3, 0x23, 0x3, 0x23, 0x3, 0x23, 0x3, 0x23, 0x3, 0x23, 0x5, + 0x23, 0x12e, 0xa, 0x23, 0x3, 0x24, 0x3, 0x24, 0x3, 0x24, 0x3, 0x24, + 0x3, 0x24, 0x3, 0x24, 0x3, 0x24, 0x3, 0x24, 0x5, 0x24, 0x138, 0xa, + 0x24, 0x3, 0x25, 0x6, 0x25, 0x13b, 0xa, 0x25, 0xd, 0x25, 0xe, 0x25, + 0x13c, 0x3, 0x26, 0x6, 0x26, 0x140, 0xa, 0x26, 0xd, 0x26, 0xe, 0x26, + 0x141, 0x3, 0x26, 0x3, 0x26, 0x5, 0x26, 0x146, 0xa, 0x26, 0x3, 0x26, + 0x6, 0x26, 0x149, 0xa, 0x26, 0xd, 0x26, 0xe, 0x26, 0x14a, 0x3, 0x27, + 0x3, 0x27, 0x3, 0x28, 0x6, 0x28, 0x150, 0xa, 0x28, 0xd, 0x28, 0xe, + 0x28, 0x151, 0x3, 0x29, 0x3, 0x29, 0x3, 0x2a, 0x3, 0x2a, 0x5, 0x2a, + 0x158, 0xa, 0x2a, 0x3, 0x2b, 0x3, 0x2b, 0x3, 0x2c, 0x3, 0x2c, 0x3, + 0x2c, 0x3, 0x2c, 0x7, 0x2c, 0x160, 0xa, 0x2c, 0xc, 0x2c, 0xe, 0x2c, + 0x163, 0xb, 0x2c, 0x3, 0x2c, 0x3, 0x2c, 0x3, 0x2d, 0x3, 0x2d, 0x3, + 0x2d, 0x3, 0x2d, 0x7, 0x2d, 0x16b, 0xa, 0x2d, 0xc, 0x2d, 0xe, 0x2d, + 0x16e, 0xb, 0x2d, 0x3, 0x2d, 0x3, 0x2d, 0x3, 0x2e, 0x3, 0x2e, 0x3, + 0x2e, 0x3, 0x2e, 0x7, 0x2e, 0x176, 0xa, 0x2e, 0xc, 0x2e, 0xe, 0x2e, + 0x179, 0xb, 0x2e, 0x3, 0x2e, 0x3, 0x2e, 0x3, 0x2f, 0x3, 0x2f, 0x3, + 0x30, 0x3, 0x30, 0x3, 0x31, 0x3, 0x31, 0x3, 0x32, 0x3, 0x32, 0x3, + 0x33, 0x3, 0x33, 0x3, 0x34, 0x3, 0x34, 0x3, 0x35, 0x3, 0x35, 0x3, + 0x36, 0x3, 0x36, 0x3, 0x37, 0x3, 0x37, 0x3, 0x38, 0x3, 0x38, 0x3, + 0x39, 0x3, 0x39, 0x3, 0x3a, 0x3, 0x3a, 0x3, 0x3b, 0x3, 0x3b, 0x3, + 0x3c, 0x3, 0x3c, 0x3, 0x3d, 0x3, 0x3d, 0x3, 0x3e, 0x3, 0x3e, 0x3, + 0x3f, 0x3, 0x3f, 0x3, 0x40, 0x3, 0x40, 0x3, 0x41, 0x3, 0x41, 0x3, + 0x42, 0x3, 0x42, 0x3, 0x43, 0x3, 0x43, 0x3, 0x44, 0x3, 0x44, 0x3, + 0x45, 0x3, 0x45, 0x3, 0x46, 0x3, 0x46, 0x3, 0x47, 0x3, 0x47, 0x3, + 0x48, 0x3, 0x48, 0x2, 0x2, 0x49, 0x3, 0x3, 0x5, 0x4, 0x7, 0x5, 0x9, + 0x6, 0xb, 0x7, 0xd, 0x8, 0xf, 0x9, 0x11, 0xa, 0x13, 0xb, 0x15, 0xc, + 0x17, 0xd, 0x19, 0xe, 0x1b, 0xf, 0x1d, 0x10, 0x1f, 0x11, 0x21, 0x12, + 0x23, 0x13, 0x25, 0x14, 0x27, 0x15, 0x29, 0x16, 0x2b, 0x17, 0x2d, + 0x18, 0x2f, 0x19, 0x31, 0x1a, 0x33, 0x1b, 0x35, 0x1c, 0x37, 0x1d, + 0x39, 0x1e, 0x3b, 0x1f, 0x3d, 0x20, 0x3f, 0x21, 0x41, 0x22, 0x43, + 0x23, 0x45, 0x2, 0x47, 0x2, 0x49, 0x24, 0x4b, 0x25, 0x4d, 0x2, 0x4f, + 0x26, 0x51, 0x27, 0x53, 0x2, 0x55, 0x2, 0x57, 0x2, 0x59, 0x2, 0x5b, + 0x2, 0x5d, 0x2, 0x5f, 0x2, 0x61, 0x2, 0x63, 0x2, 0x65, 0x2, 0x67, + 0x2, 0x69, 0x2, 0x6b, 0x2, 0x6d, 0x2, 0x6f, 0x2, 0x71, 0x2, 0x73, + 0x2, 0x75, 0x2, 0x77, 0x2, 0x79, 0x2, 0x7b, 0x2, 0x7d, 0x2, 0x7f, + 0x2, 0x81, 0x2, 0x83, 0x2, 0x85, 0x2, 0x87, 0x2, 0x89, 0x2, 0x8b, + 0x2, 0x8d, 0x2, 0x8f, 0x2, 0x3, 0x2, 0x23, 0x5, 0x2, 0xb, 0xd, 0xf, + 0xf, 0x22, 0x22, 0x4, 0x2, 0x2d, 0x2d, 0x2f, 0x2f, 0x4, 0x2, 0x47, + 0x47, 0x67, 0x67, 0x3, 0x2, 0x32, 0x3b, 0x8, 0x2, 0x25, 0x26, 0x32, + 0x3c, 0x42, 0x5c, 0x61, 0x61, 0x63, 0x7d, 0x7f, 0x7f, 0x3, 0x2, 0x24, + 0x24, 0x3, 0x2, 0x29, 0x29, 0x3, 0x2, 0x62, 0x62, 0x4, 0x2, 0x43, + 0x43, 0x63, 0x63, 0x4, 0x2, 0x44, 0x44, 0x64, 0x64, 0x4, 0x2, 0x45, + 0x45, 0x65, 0x65, 0x4, 0x2, 0x46, 0x46, 0x66, 0x66, 0x4, 0x2, 0x48, + 0x48, 0x68, 0x68, 0x4, 0x2, 0x49, 0x49, 0x69, 0x69, 0x4, 0x2, 0x4a, + 0x4a, 0x6a, 0x6a, 0x4, 0x2, 0x4b, 0x4b, 0x6b, 0x6b, 0x4, 0x2, 0x4c, + 0x4c, 0x6c, 0x6c, 0x4, 0x2, 0x4d, 0x4d, 0x6d, 0x6d, 0x4, 0x2, 0x4e, + 0x4e, 0x6e, 0x6e, 0x4, 0x2, 0x4f, 0x4f, 0x6f, 0x6f, 0x4, 0x2, 0x50, + 0x50, 0x70, 0x70, 0x4, 0x2, 0x51, 0x51, 0x71, 0x71, 0x4, 0x2, 0x52, + 0x52, 0x72, 0x72, 0x4, 0x2, 0x53, 0x53, 0x73, 0x73, 0x4, 0x2, 0x54, + 0x54, 0x74, 0x74, 0x4, 0x2, 0x55, 0x55, 0x75, 0x75, 0x4, 0x2, 0x56, + 0x56, 0x76, 0x76, 0x4, 0x2, 0x57, 0x57, 0x77, 0x77, 0x4, 0x2, 0x58, + 0x58, 0x78, 0x78, 0x4, 0x2, 0x59, 0x59, 0x79, 0x79, 0x4, 0x2, 0x5a, + 0x5a, 0x7a, 0x7a, 0x4, 0x2, 0x5b, 0x5b, 0x7b, 0x7b, 0x4, 0x2, 0x5c, + 0x5c, 0x7c, 0x7c, 0x2, 0x1ad, 0x2, 0x3, 0x3, 0x2, 0x2, 0x2, 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, 0xf, 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, 0x2, 0x3f, 0x3, 0x2, 0x2, 0x2, 0x2, 0x41, 0x3, + 0x2, 0x2, 0x2, 0x2, 0x43, 0x3, 0x2, 0x2, 0x2, 0x2, 0x49, 0x3, 0x2, + 0x2, 0x2, 0x2, 0x4b, 0x3, 0x2, 0x2, 0x2, 0x2, 0x4f, 0x3, 0x2, 0x2, + 0x2, 0x2, 0x51, 0x3, 0x2, 0x2, 0x2, 0x3, 0x91, 0x3, 0x2, 0x2, 0x2, + 0x5, 0x97, 0x3, 0x2, 0x2, 0x2, 0x7, 0x9d, 0x3, 0x2, 0x2, 0x2, 0x9, + 0xa2, 0x3, 0x2, 0x2, 0x2, 0xb, 0xac, 0x3, 0x2, 0x2, 0x2, 0xd, 0xae, + 0x3, 0x2, 0x2, 0x2, 0xf, 0xb0, 0x3, 0x2, 0x2, 0x2, 0x11, 0xb2, 0x3, + 0x2, 0x2, 0x2, 0x13, 0xb4, 0x3, 0x2, 0x2, 0x2, 0x15, 0xb7, 0x3, 0x2, + 0x2, 0x2, 0x17, 0xb9, 0x3, 0x2, 0x2, 0x2, 0x19, 0xbb, 0x3, 0x2, 0x2, + 0x2, 0x1b, 0xbe, 0x3, 0x2, 0x2, 0x2, 0x1d, 0xc0, 0x3, 0x2, 0x2, 0x2, + 0x1f, 0xc7, 0x3, 0x2, 0x2, 0x2, 0x21, 0xc9, 0x3, 0x2, 0x2, 0x2, 0x23, + 0xcb, 0x3, 0x2, 0x2, 0x2, 0x25, 0xce, 0x3, 0x2, 0x2, 0x2, 0x27, 0xd0, + 0x3, 0x2, 0x2, 0x2, 0x29, 0xd3, 0x3, 0x2, 0x2, 0x2, 0x2b, 0xd5, 0x3, + 0x2, 0x2, 0x2, 0x2d, 0xd7, 0x3, 0x2, 0x2, 0x2, 0x2f, 0xd9, 0x3, 0x2, + 0x2, 0x2, 0x31, 0xdb, 0x3, 0x2, 0x2, 0x2, 0x33, 0xdd, 0x3, 0x2, 0x2, + 0x2, 0x35, 0xe0, 0x3, 0x2, 0x2, 0x2, 0x37, 0xe2, 0x3, 0x2, 0x2, 0x2, + 0x39, 0xe4, 0x3, 0x2, 0x2, 0x2, 0x3b, 0xe6, 0x3, 0x2, 0x2, 0x2, 0x3d, + 0xe8, 0x3, 0x2, 0x2, 0x2, 0x3f, 0xed, 0x3, 0x2, 0x2, 0x2, 0x41, 0x108, + 0x3, 0x2, 0x2, 0x2, 0x43, 0x10c, 0x3, 0x2, 0x2, 0x2, 0x45, 0x12d, + 0x3, 0x2, 0x2, 0x2, 0x47, 0x12f, 0x3, 0x2, 0x2, 0x2, 0x49, 0x13a, + 0x3, 0x2, 0x2, 0x2, 0x4b, 0x13f, 0x3, 0x2, 0x2, 0x2, 0x4d, 0x14c, + 0x3, 0x2, 0x2, 0x2, 0x4f, 0x14f, 0x3, 0x2, 0x2, 0x2, 0x51, 0x153, + 0x3, 0x2, 0x2, 0x2, 0x53, 0x157, 0x3, 0x2, 0x2, 0x2, 0x55, 0x159, + 0x3, 0x2, 0x2, 0x2, 0x57, 0x15b, 0x3, 0x2, 0x2, 0x2, 0x59, 0x166, + 0x3, 0x2, 0x2, 0x2, 0x5b, 0x171, 0x3, 0x2, 0x2, 0x2, 0x5d, 0x17c, + 0x3, 0x2, 0x2, 0x2, 0x5f, 0x17e, 0x3, 0x2, 0x2, 0x2, 0x61, 0x180, + 0x3, 0x2, 0x2, 0x2, 0x63, 0x182, 0x3, 0x2, 0x2, 0x2, 0x65, 0x184, + 0x3, 0x2, 0x2, 0x2, 0x67, 0x186, 0x3, 0x2, 0x2, 0x2, 0x69, 0x188, + 0x3, 0x2, 0x2, 0x2, 0x6b, 0x18a, 0x3, 0x2, 0x2, 0x2, 0x6d, 0x18c, + 0x3, 0x2, 0x2, 0x2, 0x6f, 0x18e, 0x3, 0x2, 0x2, 0x2, 0x71, 0x190, + 0x3, 0x2, 0x2, 0x2, 0x73, 0x192, 0x3, 0x2, 0x2, 0x2, 0x75, 0x194, + 0x3, 0x2, 0x2, 0x2, 0x77, 0x196, 0x3, 0x2, 0x2, 0x2, 0x79, 0x198, + 0x3, 0x2, 0x2, 0x2, 0x7b, 0x19a, 0x3, 0x2, 0x2, 0x2, 0x7d, 0x19c, + 0x3, 0x2, 0x2, 0x2, 0x7f, 0x19e, 0x3, 0x2, 0x2, 0x2, 0x81, 0x1a0, + 0x3, 0x2, 0x2, 0x2, 0x83, 0x1a2, 0x3, 0x2, 0x2, 0x2, 0x85, 0x1a4, + 0x3, 0x2, 0x2, 0x2, 0x87, 0x1a6, 0x3, 0x2, 0x2, 0x2, 0x89, 0x1a8, + 0x3, 0x2, 0x2, 0x2, 0x8b, 0x1aa, 0x3, 0x2, 0x2, 0x2, 0x8d, 0x1ac, + 0x3, 0x2, 0x2, 0x2, 0x8f, 0x1ae, 0x3, 0x2, 0x2, 0x2, 0x91, 0x92, + 0x5, 0x7f, 0x40, 0x2, 0x92, 0x93, 0x5, 0x79, 0x3d, 0x2, 0x93, 0x94, + 0x5, 0x79, 0x3d, 0x2, 0x94, 0x95, 0x5, 0x83, 0x42, 0x2, 0x95, 0x4, + 0x3, 0x2, 0x2, 0x2, 0x96, 0x98, 0x9, 0x2, 0x2, 0x2, 0x97, 0x96, 0x3, + 0x2, 0x2, 0x2, 0x98, 0x99, 0x3, 0x2, 0x2, 0x2, 0x99, 0x97, 0x3, 0x2, + 0x2, 0x2, 0x99, 0x9a, 0x3, 0x2, 0x2, 0x2, 0x9a, 0x9b, 0x3, 0x2, 0x2, + 0x2, 0x9b, 0x9c, 0x8, 0x3, 0x2, 0x2, 0x9c, 0x6, 0x3, 0x2, 0x2, 0x2, + 0x9d, 0x9e, 0x5, 0x83, 0x42, 0x2, 0x9e, 0x9f, 0x5, 0x6d, 0x37, 0x2, + 0x9f, 0xa0, 0x5, 0x75, 0x3b, 0x2, 0xa0, 0xa1, 0x5, 0x65, 0x33, 0x2, + 0xa1, 0x8, 0x3, 0x2, 0x2, 0x2, 0xa2, 0xa3, 0x5, 0x83, 0x42, 0x2, + 0xa3, 0xa4, 0x5, 0x6d, 0x37, 0x2, 0xa4, 0xa5, 0x5, 0x75, 0x3b, 0x2, + 0xa5, 0xa6, 0x5, 0x65, 0x33, 0x2, 0xa6, 0xa7, 0x5, 0x81, 0x41, 0x2, + 0xa7, 0xa8, 0x5, 0x83, 0x42, 0x2, 0xa8, 0xa9, 0x5, 0x5d, 0x2f, 0x2, + 0xa9, 0xaa, 0x5, 0x75, 0x3b, 0x2, 0xaa, 0xab, 0x5, 0x7b, 0x3e, 0x2, + 0xab, 0xa, 0x3, 0x2, 0x2, 0x2, 0xac, 0xad, 0x7, 0x2f, 0x2, 0x2, 0xad, + 0xc, 0x3, 0x2, 0x2, 0x2, 0xae, 0xaf, 0x7, 0x2d, 0x2, 0x2, 0xaf, 0xe, + 0x3, 0x2, 0x2, 0x2, 0xb0, 0xb1, 0x7, 0x31, 0x2, 0x2, 0xb1, 0x10, + 0x3, 0x2, 0x2, 0x2, 0xb2, 0xb3, 0x7, 0x27, 0x2, 0x2, 0xb3, 0x12, + 0x3, 0x2, 0x2, 0x2, 0xb4, 0xb5, 0x7, 0x3f, 0x2, 0x2, 0xb5, 0xb6, + 0x7, 0x3f, 0x2, 0x2, 0xb6, 0x14, 0x3, 0x2, 0x2, 0x2, 0xb7, 0xb8, + 0x7, 0x3f, 0x2, 0x2, 0xb8, 0x16, 0x3, 0x2, 0x2, 0x2, 0xb9, 0xba, + 0x7, 0x40, 0x2, 0x2, 0xba, 0x18, 0x3, 0x2, 0x2, 0x2, 0xbb, 0xbc, + 0x7, 0x40, 0x2, 0x2, 0xbc, 0xbd, 0x7, 0x3f, 0x2, 0x2, 0xbd, 0x1a, + 0x3, 0x2, 0x2, 0x2, 0xbe, 0xbf, 0x7, 0x3e, 0x2, 0x2, 0xbf, 0x1c, + 0x3, 0x2, 0x2, 0x2, 0xc0, 0xc1, 0x7, 0x3e, 0x2, 0x2, 0xc1, 0xc2, + 0x7, 0x3f, 0x2, 0x2, 0xc2, 0x1e, 0x3, 0x2, 0x2, 0x2, 0xc3, 0xc4, + 0x7, 0x23, 0x2, 0x2, 0xc4, 0xc8, 0x7, 0x3f, 0x2, 0x2, 0xc5, 0xc6, + 0x7, 0x3e, 0x2, 0x2, 0xc6, 0xc8, 0x7, 0x40, 0x2, 0x2, 0xc7, 0xc3, + 0x3, 0x2, 0x2, 0x2, 0xc7, 0xc5, 0x3, 0x2, 0x2, 0x2, 0xc8, 0x20, 0x3, + 0x2, 0x2, 0x2, 0xc9, 0xca, 0x7, 0x28, 0x2, 0x2, 0xca, 0x22, 0x3, + 0x2, 0x2, 0x2, 0xcb, 0xcc, 0x7, 0x28, 0x2, 0x2, 0xcc, 0xcd, 0x7, + 0x28, 0x2, 0x2, 0xcd, 0x24, 0x3, 0x2, 0x2, 0x2, 0xce, 0xcf, 0x7, + 0x7e, 0x2, 0x2, 0xcf, 0x26, 0x3, 0x2, 0x2, 0x2, 0xd0, 0xd1, 0x7, + 0x7e, 0x2, 0x2, 0xd1, 0xd2, 0x7, 0x7e, 0x2, 0x2, 0xd2, 0x28, 0x3, + 0x2, 0x2, 0x2, 0xd3, 0xd4, 0x7, 0x23, 0x2, 0x2, 0xd4, 0x2a, 0x3, + 0x2, 0x2, 0x2, 0xd5, 0xd6, 0x7, 0x30, 0x2, 0x2, 0xd6, 0x2c, 0x3, + 0x2, 0x2, 0x2, 0xd7, 0xd8, 0x7, 0x2e, 0x2, 0x2, 0xd8, 0x2e, 0x3, + 0x2, 0x2, 0x2, 0xd9, 0xda, 0x7, 0x3d, 0x2, 0x2, 0xda, 0x30, 0x3, + 0x2, 0x2, 0x2, 0xdb, 0xdc, 0x7, 0x2c, 0x2, 0x2, 0xdc, 0x32, 0x3, + 0x2, 0x2, 0x2, 0xdd, 0xde, 0x7, 0x2c, 0x2, 0x2, 0xde, 0xdf, 0x7, + 0x2c, 0x2, 0x2, 0xdf, 0x34, 0x3, 0x2, 0x2, 0x2, 0xe0, 0xe1, 0x7, + 0x2a, 0x2, 0x2, 0xe1, 0x36, 0x3, 0x2, 0x2, 0x2, 0xe2, 0xe3, 0x7, + 0x2b, 0x2, 0x2, 0xe3, 0x38, 0x3, 0x2, 0x2, 0x2, 0xe4, 0xe5, 0x7, + 0x5d, 0x2, 0x2, 0xe5, 0x3a, 0x3, 0x2, 0x2, 0x2, 0xe6, 0xe7, 0x7, + 0x5f, 0x2, 0x2, 0xe7, 0x3c, 0x3, 0x2, 0x2, 0x2, 0xe8, 0xe9, 0x7, + 0x3c, 0x2, 0x2, 0xe9, 0xea, 0x7, 0x3c, 0x2, 0x2, 0xea, 0x3e, 0x3, + 0x2, 0x2, 0x2, 0xeb, 0xee, 0x5, 0x57, 0x2c, 0x2, 0xec, 0xee, 0x5, + 0x59, 0x2d, 0x2, 0xed, 0xeb, 0x3, 0x2, 0x2, 0x2, 0xed, 0xec, 0x3, + 0x2, 0x2, 0x2, 0xee, 0x40, 0x3, 0x2, 0x2, 0x2, 0xef, 0xf1, 0x5, 0x49, + 0x25, 0x2, 0xf0, 0xef, 0x3, 0x2, 0x2, 0x2, 0xf1, 0xf2, 0x3, 0x2, + 0x2, 0x2, 0xf2, 0xf0, 0x3, 0x2, 0x2, 0x2, 0xf2, 0xf3, 0x3, 0x2, 0x2, + 0x2, 0xf3, 0x106, 0x3, 0x2, 0x2, 0x2, 0xf4, 0x107, 0x5, 0x8d, 0x47, + 0x2, 0xf5, 0xf6, 0x5, 0x75, 0x3b, 0x2, 0xf6, 0xf7, 0x5, 0x79, 0x3d, + 0x2, 0xf7, 0x107, 0x3, 0x2, 0x2, 0x2, 0xf8, 0x107, 0x5, 0x89, 0x45, + 0x2, 0xf9, 0x107, 0x5, 0x63, 0x32, 0x2, 0xfa, 0x107, 0x5, 0x6b, 0x36, + 0x2, 0xfb, 0x107, 0x5, 0x75, 0x3b, 0x2, 0xfc, 0x107, 0x5, 0x81, 0x41, + 0x2, 0xfd, 0xfe, 0x5, 0x75, 0x3b, 0x2, 0xfe, 0xff, 0x5, 0x81, 0x41, + 0x2, 0xff, 0x107, 0x3, 0x2, 0x2, 0x2, 0x100, 0x101, 0x5, 0x85, 0x43, + 0x2, 0x101, 0x102, 0x5, 0x81, 0x41, 0x2, 0x102, 0x107, 0x3, 0x2, + 0x2, 0x2, 0x103, 0x104, 0x5, 0x77, 0x3c, 0x2, 0x104, 0x105, 0x5, + 0x81, 0x41, 0x2, 0x105, 0x107, 0x3, 0x2, 0x2, 0x2, 0x106, 0xf4, 0x3, + 0x2, 0x2, 0x2, 0x106, 0xf5, 0x3, 0x2, 0x2, 0x2, 0x106, 0xf8, 0x3, + 0x2, 0x2, 0x2, 0x106, 0xf9, 0x3, 0x2, 0x2, 0x2, 0x106, 0xfa, 0x3, + 0x2, 0x2, 0x2, 0x106, 0xfb, 0x3, 0x2, 0x2, 0x2, 0x106, 0xfc, 0x3, + 0x2, 0x2, 0x2, 0x106, 0xfd, 0x3, 0x2, 0x2, 0x2, 0x106, 0x100, 0x3, + 0x2, 0x2, 0x2, 0x106, 0x103, 0x3, 0x2, 0x2, 0x2, 0x107, 0x109, 0x3, + 0x2, 0x2, 0x2, 0x108, 0xf0, 0x3, 0x2, 0x2, 0x2, 0x109, 0x10a, 0x3, + 0x2, 0x2, 0x2, 0x10a, 0x108, 0x3, 0x2, 0x2, 0x2, 0x10a, 0x10b, 0x3, + 0x2, 0x2, 0x2, 0x10b, 0x42, 0x3, 0x2, 0x2, 0x2, 0x10c, 0x119, 0x5, + 0x45, 0x23, 0x2, 0x10d, 0x110, 0x5, 0x83, 0x42, 0x2, 0x10e, 0x110, + 0x5, 0x5, 0x3, 0x2, 0x10f, 0x10d, 0x3, 0x2, 0x2, 0x2, 0x10f, 0x10e, + 0x3, 0x2, 0x2, 0x2, 0x110, 0x111, 0x3, 0x2, 0x2, 0x2, 0x111, 0x117, + 0x5, 0x47, 0x24, 0x2, 0x112, 0x113, 0x9, 0x3, 0x2, 0x2, 0x113, 0x114, + 0x5, 0x49, 0x25, 0x2, 0x114, 0x115, 0x7, 0x3c, 0x2, 0x2, 0x115, 0x116, + 0x5, 0x49, 0x25, 0x2, 0x116, 0x118, 0x3, 0x2, 0x2, 0x2, 0x117, 0x112, + 0x3, 0x2, 0x2, 0x2, 0x117, 0x118, 0x3, 0x2, 0x2, 0x2, 0x118, 0x11a, + 0x3, 0x2, 0x2, 0x2, 0x119, 0x10f, 0x3, 0x2, 0x2, 0x2, 0x119, 0x11a, + 0x3, 0x2, 0x2, 0x2, 0x11a, 0x44, 0x3, 0x2, 0x2, 0x2, 0x11b, 0x11c, + 0x5, 0x49, 0x25, 0x2, 0x11c, 0x11d, 0x7, 0x2f, 0x2, 0x2, 0x11d, 0x11e, + 0x5, 0x49, 0x25, 0x2, 0x11e, 0x11f, 0x7, 0x2f, 0x2, 0x2, 0x11f, 0x120, + 0x5, 0x49, 0x25, 0x2, 0x120, 0x12e, 0x3, 0x2, 0x2, 0x2, 0x121, 0x122, + 0x5, 0x49, 0x25, 0x2, 0x122, 0x123, 0x7, 0x31, 0x2, 0x2, 0x123, 0x124, + 0x5, 0x49, 0x25, 0x2, 0x124, 0x125, 0x7, 0x31, 0x2, 0x2, 0x125, 0x126, + 0x5, 0x49, 0x25, 0x2, 0x126, 0x12e, 0x3, 0x2, 0x2, 0x2, 0x127, 0x128, + 0x5, 0x49, 0x25, 0x2, 0x128, 0x129, 0x7, 0x30, 0x2, 0x2, 0x129, 0x12a, + 0x5, 0x49, 0x25, 0x2, 0x12a, 0x12b, 0x7, 0x30, 0x2, 0x2, 0x12b, 0x12c, + 0x5, 0x49, 0x25, 0x2, 0x12c, 0x12e, 0x3, 0x2, 0x2, 0x2, 0x12d, 0x11b, + 0x3, 0x2, 0x2, 0x2, 0x12d, 0x121, 0x3, 0x2, 0x2, 0x2, 0x12d, 0x127, + 0x3, 0x2, 0x2, 0x2, 0x12e, 0x46, 0x3, 0x2, 0x2, 0x2, 0x12f, 0x130, + 0x5, 0x49, 0x25, 0x2, 0x130, 0x131, 0x7, 0x3c, 0x2, 0x2, 0x131, 0x132, + 0x5, 0x49, 0x25, 0x2, 0x132, 0x133, 0x7, 0x3c, 0x2, 0x2, 0x133, 0x137, + 0x5, 0x49, 0x25, 0x2, 0x134, 0x135, 0x5, 0x2b, 0x16, 0x2, 0x135, + 0x136, 0x5, 0x49, 0x25, 0x2, 0x136, 0x138, 0x3, 0x2, 0x2, 0x2, 0x137, + 0x134, 0x3, 0x2, 0x2, 0x2, 0x137, 0x138, 0x3, 0x2, 0x2, 0x2, 0x138, + 0x48, 0x3, 0x2, 0x2, 0x2, 0x139, 0x13b, 0x5, 0x4d, 0x27, 0x2, 0x13a, + 0x139, 0x3, 0x2, 0x2, 0x2, 0x13b, 0x13c, 0x3, 0x2, 0x2, 0x2, 0x13c, + 0x13a, 0x3, 0x2, 0x2, 0x2, 0x13c, 0x13d, 0x3, 0x2, 0x2, 0x2, 0x13d, + 0x4a, 0x3, 0x2, 0x2, 0x2, 0x13e, 0x140, 0x5, 0x4d, 0x27, 0x2, 0x13f, + 0x13e, 0x3, 0x2, 0x2, 0x2, 0x140, 0x141, 0x3, 0x2, 0x2, 0x2, 0x141, + 0x13f, 0x3, 0x2, 0x2, 0x2, 0x141, 0x142, 0x3, 0x2, 0x2, 0x2, 0x142, + 0x143, 0x3, 0x2, 0x2, 0x2, 0x143, 0x145, 0x9, 0x4, 0x2, 0x2, 0x144, + 0x146, 0x9, 0x3, 0x2, 0x2, 0x145, 0x144, 0x3, 0x2, 0x2, 0x2, 0x145, + 0x146, 0x3, 0x2, 0x2, 0x2, 0x146, 0x148, 0x3, 0x2, 0x2, 0x2, 0x147, + 0x149, 0x5, 0x4d, 0x27, 0x2, 0x148, 0x147, 0x3, 0x2, 0x2, 0x2, 0x149, + 0x14a, 0x3, 0x2, 0x2, 0x2, 0x14a, 0x148, 0x3, 0x2, 0x2, 0x2, 0x14a, + 0x14b, 0x3, 0x2, 0x2, 0x2, 0x14b, 0x4c, 0x3, 0x2, 0x2, 0x2, 0x14c, + 0x14d, 0x9, 0x5, 0x2, 0x2, 0x14d, 0x4e, 0x3, 0x2, 0x2, 0x2, 0x14e, + 0x150, 0x5, 0x53, 0x2a, 0x2, 0x14f, 0x14e, 0x3, 0x2, 0x2, 0x2, 0x150, + 0x151, 0x3, 0x2, 0x2, 0x2, 0x151, 0x14f, 0x3, 0x2, 0x2, 0x2, 0x151, + 0x152, 0x3, 0x2, 0x2, 0x2, 0x152, 0x50, 0x3, 0x2, 0x2, 0x2, 0x153, + 0x154, 0x5, 0x5b, 0x2e, 0x2, 0x154, 0x52, 0x3, 0x2, 0x2, 0x2, 0x155, + 0x158, 0x9, 0x6, 0x2, 0x2, 0x156, 0x158, 0x5, 0x55, 0x2b, 0x2, 0x157, + 0x155, 0x3, 0x2, 0x2, 0x2, 0x157, 0x156, 0x3, 0x2, 0x2, 0x2, 0x158, + 0x54, 0x3, 0x2, 0x2, 0x2, 0x159, 0x15a, 0x4, 0x2e82, 0xa001, 0x2, + 0x15a, 0x56, 0x3, 0x2, 0x2, 0x2, 0x15b, 0x161, 0x7, 0x24, 0x2, 0x2, + 0x15c, 0x15d, 0x7, 0x24, 0x2, 0x2, 0x15d, 0x160, 0x7, 0x24, 0x2, + 0x2, 0x15e, 0x160, 0xa, 0x7, 0x2, 0x2, 0x15f, 0x15c, 0x3, 0x2, 0x2, + 0x2, 0x15f, 0x15e, 0x3, 0x2, 0x2, 0x2, 0x160, 0x163, 0x3, 0x2, 0x2, + 0x2, 0x161, 0x15f, 0x3, 0x2, 0x2, 0x2, 0x161, 0x162, 0x3, 0x2, 0x2, + 0x2, 0x162, 0x164, 0x3, 0x2, 0x2, 0x2, 0x163, 0x161, 0x3, 0x2, 0x2, + 0x2, 0x164, 0x165, 0x7, 0x24, 0x2, 0x2, 0x165, 0x58, 0x3, 0x2, 0x2, + 0x2, 0x166, 0x16c, 0x7, 0x29, 0x2, 0x2, 0x167, 0x168, 0x7, 0x29, + 0x2, 0x2, 0x168, 0x16b, 0x7, 0x29, 0x2, 0x2, 0x169, 0x16b, 0xa, 0x8, + 0x2, 0x2, 0x16a, 0x167, 0x3, 0x2, 0x2, 0x2, 0x16a, 0x169, 0x3, 0x2, + 0x2, 0x2, 0x16b, 0x16e, 0x3, 0x2, 0x2, 0x2, 0x16c, 0x16a, 0x3, 0x2, + 0x2, 0x2, 0x16c, 0x16d, 0x3, 0x2, 0x2, 0x2, 0x16d, 0x16f, 0x3, 0x2, + 0x2, 0x2, 0x16e, 0x16c, 0x3, 0x2, 0x2, 0x2, 0x16f, 0x170, 0x7, 0x29, + 0x2, 0x2, 0x170, 0x5a, 0x3, 0x2, 0x2, 0x2, 0x171, 0x177, 0x7, 0x62, + 0x2, 0x2, 0x172, 0x173, 0x7, 0x62, 0x2, 0x2, 0x173, 0x176, 0x7, 0x62, + 0x2, 0x2, 0x174, 0x176, 0xa, 0x9, 0x2, 0x2, 0x175, 0x172, 0x3, 0x2, + 0x2, 0x2, 0x175, 0x174, 0x3, 0x2, 0x2, 0x2, 0x176, 0x179, 0x3, 0x2, + 0x2, 0x2, 0x177, 0x175, 0x3, 0x2, 0x2, 0x2, 0x177, 0x178, 0x3, 0x2, + 0x2, 0x2, 0x178, 0x17a, 0x3, 0x2, 0x2, 0x2, 0x179, 0x177, 0x3, 0x2, + 0x2, 0x2, 0x17a, 0x17b, 0x7, 0x62, 0x2, 0x2, 0x17b, 0x5c, 0x3, 0x2, + 0x2, 0x2, 0x17c, 0x17d, 0x9, 0xa, 0x2, 0x2, 0x17d, 0x5e, 0x3, 0x2, + 0x2, 0x2, 0x17e, 0x17f, 0x9, 0xb, 0x2, 0x2, 0x17f, 0x60, 0x3, 0x2, + 0x2, 0x2, 0x180, 0x181, 0x9, 0xc, 0x2, 0x2, 0x181, 0x62, 0x3, 0x2, + 0x2, 0x2, 0x182, 0x183, 0x9, 0xd, 0x2, 0x2, 0x183, 0x64, 0x3, 0x2, + 0x2, 0x2, 0x184, 0x185, 0x9, 0x4, 0x2, 0x2, 0x185, 0x66, 0x3, 0x2, + 0x2, 0x2, 0x186, 0x187, 0x9, 0xe, 0x2, 0x2, 0x187, 0x68, 0x3, 0x2, + 0x2, 0x2, 0x188, 0x189, 0x9, 0xf, 0x2, 0x2, 0x189, 0x6a, 0x3, 0x2, + 0x2, 0x2, 0x18a, 0x18b, 0x9, 0x10, 0x2, 0x2, 0x18b, 0x6c, 0x3, 0x2, + 0x2, 0x2, 0x18c, 0x18d, 0x9, 0x11, 0x2, 0x2, 0x18d, 0x6e, 0x3, 0x2, + 0x2, 0x2, 0x18e, 0x18f, 0x9, 0x12, 0x2, 0x2, 0x18f, 0x70, 0x3, 0x2, + 0x2, 0x2, 0x190, 0x191, 0x9, 0x13, 0x2, 0x2, 0x191, 0x72, 0x3, 0x2, + 0x2, 0x2, 0x192, 0x193, 0x9, 0x14, 0x2, 0x2, 0x193, 0x74, 0x3, 0x2, + 0x2, 0x2, 0x194, 0x195, 0x9, 0x15, 0x2, 0x2, 0x195, 0x76, 0x3, 0x2, + 0x2, 0x2, 0x196, 0x197, 0x9, 0x16, 0x2, 0x2, 0x197, 0x78, 0x3, 0x2, + 0x2, 0x2, 0x198, 0x199, 0x9, 0x17, 0x2, 0x2, 0x199, 0x7a, 0x3, 0x2, + 0x2, 0x2, 0x19a, 0x19b, 0x9, 0x18, 0x2, 0x2, 0x19b, 0x7c, 0x3, 0x2, + 0x2, 0x2, 0x19c, 0x19d, 0x9, 0x19, 0x2, 0x2, 0x19d, 0x7e, 0x3, 0x2, + 0x2, 0x2, 0x19e, 0x19f, 0x9, 0x1a, 0x2, 0x2, 0x19f, 0x80, 0x3, 0x2, + 0x2, 0x2, 0x1a0, 0x1a1, 0x9, 0x1b, 0x2, 0x2, 0x1a1, 0x82, 0x3, 0x2, + 0x2, 0x2, 0x1a2, 0x1a3, 0x9, 0x1c, 0x2, 0x2, 0x1a3, 0x84, 0x3, 0x2, + 0x2, 0x2, 0x1a4, 0x1a5, 0x9, 0x1d, 0x2, 0x2, 0x1a5, 0x86, 0x3, 0x2, + 0x2, 0x2, 0x1a6, 0x1a7, 0x9, 0x1e, 0x2, 0x2, 0x1a7, 0x88, 0x3, 0x2, + 0x2, 0x2, 0x1a8, 0x1a9, 0x9, 0x1f, 0x2, 0x2, 0x1a9, 0x8a, 0x3, 0x2, + 0x2, 0x2, 0x1aa, 0x1ab, 0x9, 0x20, 0x2, 0x2, 0x1ab, 0x8c, 0x3, 0x2, + 0x2, 0x2, 0x1ac, 0x1ad, 0x9, 0x21, 0x2, 0x2, 0x1ad, 0x8e, 0x3, 0x2, + 0x2, 0x2, 0x1ae, 0x1af, 0x9, 0x22, 0x2, 0x2, 0x1af, 0x90, 0x3, 0x2, + 0x2, 0x2, 0x1a, 0x2, 0x99, 0xc7, 0xed, 0xf2, 0x106, 0x10a, 0x10f, + 0x117, 0x119, 0x12d, 0x137, 0x13c, 0x141, 0x145, 0x14a, 0x151, 0x157, + 0x15f, 0x161, 0x16a, 0x16c, 0x175, 0x177, 0x3, 0x2, 0x3, 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); + } +} + +PathLexer::Initializer PathLexer::_init; diff --git a/cpp/src/parser/generated/PathLexer.h b/cpp/src/parser/generated/PathLexer.h new file mode 100644 index 000000000..058ac66f3 --- /dev/null +++ b/cpp/src/parser/generated/PathLexer.h @@ -0,0 +1,80 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * License); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +// Generated from PathLexer.g4 by ANTLR 4.9.3 + +#pragma once + + +#include "antlr4-runtime.h" + + + + +class PathLexer : public antlr4::Lexer { +public: + enum { + ROOT = 1, WS = 2, TIME = 3, TIMESTAMP = 4, MINUS = 5, PLUS = 6, DIV = 7, + MOD = 8, OPERATOR_DEQ = 9, OPERATOR_SEQ = 10, OPERATOR_GT = 11, OPERATOR_GTE = 12, + OPERATOR_LT = 13, OPERATOR_LTE = 14, OPERATOR_NEQ = 15, OPERATOR_BITWISE_AND = 16, + OPERATOR_LOGICAL_AND = 17, OPERATOR_BITWISE_OR = 18, OPERATOR_LOGICAL_OR = 19, + OPERATOR_NOT = 20, DOT = 21, COMMA = 22, SEMI = 23, STAR = 24, DOUBLE_STAR = 25, + LR_BRACKET = 26, RR_BRACKET = 27, LS_BRACKET = 28, RS_BRACKET = 29, + DOUBLE_COLON = 30, STRING_LITERAL = 31, DURATION_LITERAL = 32, DATETIME_LITERAL = 33, + INTEGER_LITERAL = 34, EXPONENT_NUM_PART = 35, ID = 36, QUOTED_ID = 37 + }; + + explicit PathLexer(antlr4::CharStream *input); + ~PathLexer(); + + 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; + +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; + + + // Individual action functions triggered by action() above. + + // Individual semantic predicate functions triggered by sempred() above. + + struct Initializer { + Initializer(); + }; + static Initializer _init; +}; + diff --git a/cpp/src/parser/generated/PathParser.cpp b/cpp/src/parser/generated/PathParser.cpp new file mode 100644 index 000000000..8b6ea1114 --- /dev/null +++ b/cpp/src/parser/generated/PathParser.cpp @@ -0,0 +1,850 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * License); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +// Generated from PathParser.g4 by ANTLR 4.9.3 + + +#include "PathParserListener.h" +#include "PathParserVisitor.h" + +#include "PathParser.h" + + +using namespace antlrcpp; +using namespace antlr4; + +PathParser::PathParser(TokenStream *input) : Parser(input) { + _interpreter = new atn::ParserATNSimulator(this, _atn, _decisionToDFA, _sharedContextCache); +} + +PathParser::~PathParser() { + delete _interpreter; +} + +std::string PathParser::getGrammarFileName() const { + return "PathParser.g4"; +} + +const std::vector& PathParser::getRuleNames() const { + return _ruleNames; +} + +dfa::Vocabulary& PathParser::getVocabulary() const { + return _vocabulary; +} + + +//----------------- PathContext ------------------------------------------------------------------ + +PathParser::PathContext::PathContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +PathParser::PrefixPathContext* PathParser::PathContext::prefixPath() { + return getRuleContext(0); +} + +tree::TerminalNode* PathParser::PathContext::EOF() { + return getToken(PathParser::EOF, 0); +} + +PathParser::SuffixPathContext* PathParser::PathContext::suffixPath() { + return getRuleContext(0); +} + + +size_t PathParser::PathContext::getRuleIndex() const { + return PathParser::RulePath; +} + +void PathParser::PathContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterPath(this); +} + +void PathParser::PathContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitPath(this); +} + + +antlrcpp::Any PathParser::PathContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitPath(this); + else + return visitor->visitChildren(this); +} + +PathParser::PathContext* PathParser::path() { + PathContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 0, PathParser::RulePath); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(22); + _errHandler->sync(this); + switch (_input->LA(1)) { + case PathParser::ROOT: { + enterOuterAlt(_localctx, 1); + setState(16); + prefixPath(); + setState(17); + match(PathParser::EOF); + break; + } + + case PathParser::STAR: + case PathParser::DOUBLE_STAR: + case PathParser::DURATION_LITERAL: + case PathParser::INTEGER_LITERAL: + case PathParser::ID: + case PathParser::QUOTED_ID: { + enterOuterAlt(_localctx, 2); + setState(19); + suffixPath(); + setState(20); + match(PathParser::EOF); + break; + } + + default: + throw NoViableAltException(this); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- PrefixPathContext ------------------------------------------------------------------ + +PathParser::PrefixPathContext::PrefixPathContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* PathParser::PrefixPathContext::ROOT() { + return getToken(PathParser::ROOT, 0); +} + +std::vector PathParser::PrefixPathContext::DOT() { + return getTokens(PathParser::DOT); +} + +tree::TerminalNode* PathParser::PrefixPathContext::DOT(size_t i) { + return getToken(PathParser::DOT, i); +} + +std::vector PathParser::PrefixPathContext::nodeName() { + return getRuleContexts(); +} + +PathParser::NodeNameContext* PathParser::PrefixPathContext::nodeName(size_t i) { + return getRuleContext(i); +} + + +size_t PathParser::PrefixPathContext::getRuleIndex() const { + return PathParser::RulePrefixPath; +} + +void PathParser::PrefixPathContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterPrefixPath(this); +} + +void PathParser::PrefixPathContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitPrefixPath(this); +} + + +antlrcpp::Any PathParser::PrefixPathContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitPrefixPath(this); + else + return visitor->visitChildren(this); +} + +PathParser::PrefixPathContext* PathParser::prefixPath() { + PrefixPathContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 2, PathParser::RulePrefixPath); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(24); + match(PathParser::ROOT); + setState(29); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == PathParser::DOT) { + setState(25); + match(PathParser::DOT); + setState(26); + nodeName(); + setState(31); + _errHandler->sync(this); + _la = _input->LA(1); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- SuffixPathContext ------------------------------------------------------------------ + +PathParser::SuffixPathContext::SuffixPathContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector PathParser::SuffixPathContext::nodeName() { + return getRuleContexts(); +} + +PathParser::NodeNameContext* PathParser::SuffixPathContext::nodeName(size_t i) { + return getRuleContext(i); +} + +std::vector PathParser::SuffixPathContext::DOT() { + return getTokens(PathParser::DOT); +} + +tree::TerminalNode* PathParser::SuffixPathContext::DOT(size_t i) { + return getToken(PathParser::DOT, i); +} + + +size_t PathParser::SuffixPathContext::getRuleIndex() const { + return PathParser::RuleSuffixPath; +} + +void PathParser::SuffixPathContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterSuffixPath(this); +} + +void PathParser::SuffixPathContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitSuffixPath(this); +} + + +antlrcpp::Any PathParser::SuffixPathContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitSuffixPath(this); + else + return visitor->visitChildren(this); +} + +PathParser::SuffixPathContext* PathParser::suffixPath() { + SuffixPathContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 4, PathParser::RuleSuffixPath); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(32); + nodeName(); + setState(37); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == PathParser::DOT) { + setState(33); + match(PathParser::DOT); + setState(34); + nodeName(); + setState(39); + _errHandler->sync(this); + _la = _input->LA(1); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- NodeNameContext ------------------------------------------------------------------ + +PathParser::NodeNameContext::NodeNameContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector PathParser::NodeNameContext::wildcard() { + return getRuleContexts(); +} + +PathParser::WildcardContext* PathParser::NodeNameContext::wildcard(size_t i) { + return getRuleContext(i); +} + +PathParser::NodeNameSliceContext* PathParser::NodeNameContext::nodeNameSlice() { + return getRuleContext(0); +} + +PathParser::NodeNameWithoutWildcardContext* PathParser::NodeNameContext::nodeNameWithoutWildcard() { + return getRuleContext(0); +} + + +size_t PathParser::NodeNameContext::getRuleIndex() const { + return PathParser::RuleNodeName; +} + +void PathParser::NodeNameContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterNodeName(this); +} + +void PathParser::NodeNameContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitNodeName(this); +} + + +antlrcpp::Any PathParser::NodeNameContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitNodeName(this); + else + return visitor->visitChildren(this); +} + +PathParser::NodeNameContext* PathParser::nodeName() { + NodeNameContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 6, PathParser::RuleNodeName); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(50); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 4, _ctx)) { + case 1: { + enterOuterAlt(_localctx, 1); + setState(40); + wildcard(); + break; + } + + case 2: { + enterOuterAlt(_localctx, 2); + setState(41); + wildcard(); + setState(42); + nodeNameSlice(); + setState(44); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == PathParser::STAR + + || _la == PathParser::DOUBLE_STAR) { + setState(43); + wildcard(); + } + break; + } + + case 3: { + enterOuterAlt(_localctx, 3); + setState(46); + nodeNameSlice(); + setState(47); + wildcard(); + break; + } + + case 4: { + enterOuterAlt(_localctx, 4); + setState(49); + nodeNameWithoutWildcard(); + break; + } + + default: + break; + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- NodeNameWithoutWildcardContext ------------------------------------------------------------------ + +PathParser::NodeNameWithoutWildcardContext::NodeNameWithoutWildcardContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +PathParser::IdentifierContext* PathParser::NodeNameWithoutWildcardContext::identifier() { + return getRuleContext(0); +} + + +size_t PathParser::NodeNameWithoutWildcardContext::getRuleIndex() const { + return PathParser::RuleNodeNameWithoutWildcard; +} + +void PathParser::NodeNameWithoutWildcardContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterNodeNameWithoutWildcard(this); +} + +void PathParser::NodeNameWithoutWildcardContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitNodeNameWithoutWildcard(this); +} + + +antlrcpp::Any PathParser::NodeNameWithoutWildcardContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitNodeNameWithoutWildcard(this); + else + return visitor->visitChildren(this); +} + +PathParser::NodeNameWithoutWildcardContext* PathParser::nodeNameWithoutWildcard() { + NodeNameWithoutWildcardContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 8, PathParser::RuleNodeNameWithoutWildcard); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(52); + identifier(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- NodeNameSliceContext ------------------------------------------------------------------ + +PathParser::NodeNameSliceContext::NodeNameSliceContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +PathParser::IdentifierContext* PathParser::NodeNameSliceContext::identifier() { + return getRuleContext(0); +} + +tree::TerminalNode* PathParser::NodeNameSliceContext::INTEGER_LITERAL() { + return getToken(PathParser::INTEGER_LITERAL, 0); +} + + +size_t PathParser::NodeNameSliceContext::getRuleIndex() const { + return PathParser::RuleNodeNameSlice; +} + +void PathParser::NodeNameSliceContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterNodeNameSlice(this); +} + +void PathParser::NodeNameSliceContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitNodeNameSlice(this); +} + + +antlrcpp::Any PathParser::NodeNameSliceContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitNodeNameSlice(this); + else + return visitor->visitChildren(this); +} + +PathParser::NodeNameSliceContext* PathParser::nodeNameSlice() { + NodeNameSliceContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 10, PathParser::RuleNodeNameSlice); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(56); + _errHandler->sync(this); + switch (_input->LA(1)) { + case PathParser::DURATION_LITERAL: + case PathParser::ID: + case PathParser::QUOTED_ID: { + enterOuterAlt(_localctx, 1); + setState(54); + identifier(); + break; + } + + case PathParser::INTEGER_LITERAL: { + enterOuterAlt(_localctx, 2); + setState(55); + match(PathParser::INTEGER_LITERAL); + break; + } + + default: + throw NoViableAltException(this); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- IdentifierContext ------------------------------------------------------------------ + +PathParser::IdentifierContext::IdentifierContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* PathParser::IdentifierContext::DURATION_LITERAL() { + return getToken(PathParser::DURATION_LITERAL, 0); +} + +tree::TerminalNode* PathParser::IdentifierContext::ID() { + return getToken(PathParser::ID, 0); +} + +tree::TerminalNode* PathParser::IdentifierContext::QUOTED_ID() { + return getToken(PathParser::QUOTED_ID, 0); +} + + +size_t PathParser::IdentifierContext::getRuleIndex() const { + return PathParser::RuleIdentifier; +} + +void PathParser::IdentifierContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterIdentifier(this); +} + +void PathParser::IdentifierContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitIdentifier(this); +} + + +antlrcpp::Any PathParser::IdentifierContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitIdentifier(this); + else + return visitor->visitChildren(this); +} + +PathParser::IdentifierContext* PathParser::identifier() { + IdentifierContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 12, PathParser::RuleIdentifier); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(58); + _la = _input->LA(1); + if (!((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & ((1ULL << PathParser::DURATION_LITERAL) + | (1ULL << PathParser::ID) + | (1ULL << PathParser::QUOTED_ID))) != 0))) { + _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; +} + +//----------------- WildcardContext ------------------------------------------------------------------ + +PathParser::WildcardContext::WildcardContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* PathParser::WildcardContext::STAR() { + return getToken(PathParser::STAR, 0); +} + +tree::TerminalNode* PathParser::WildcardContext::DOUBLE_STAR() { + return getToken(PathParser::DOUBLE_STAR, 0); +} + + +size_t PathParser::WildcardContext::getRuleIndex() const { + return PathParser::RuleWildcard; +} + +void PathParser::WildcardContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterWildcard(this); +} + +void PathParser::WildcardContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitWildcard(this); +} + + +antlrcpp::Any PathParser::WildcardContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitWildcard(this); + else + return visitor->visitChildren(this); +} + +PathParser::WildcardContext* PathParser::wildcard() { + WildcardContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 14, PathParser::RuleWildcard); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(60); + _la = _input->LA(1); + if (!(_la == PathParser::STAR + + || _la == PathParser::DOUBLE_STAR)) { + _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; +} + +// Static vars and initialization. +std::vector PathParser::_decisionToDFA; +atn::PredictionContextCache PathParser::_sharedContextCache; + +// We own the ATN which in turn owns the ATN states. +atn::ATN PathParser::_atn; +std::vector PathParser::_serializedATN; + +std::vector PathParser::_ruleNames = { + "path", "prefixPath", "suffixPath", "nodeName", "nodeNameWithoutWildcard", + "nodeNameSlice", "identifier", "wildcard" +}; + +std::vector PathParser::_literalNames = { + "", "", "", "", "", "'-'", "'+'", "'/'", "'%'", "'=='", "'='", "'>'", + "'>='", "'<'", "'<='", "", "'&'", "'&&'", "'|'", "'||'", "'!'", "'.'", + "','", "';'", "'*'", "'**'", "'('", "')'", "'['", "']'", "'::'" +}; + +std::vector PathParser::_symbolicNames = { + "", "ROOT", "WS", "TIME", "TIMESTAMP", "MINUS", "PLUS", "DIV", "MOD", + "OPERATOR_DEQ", "OPERATOR_SEQ", "OPERATOR_GT", "OPERATOR_GTE", "OPERATOR_LT", + "OPERATOR_LTE", "OPERATOR_NEQ", "OPERATOR_BITWISE_AND", "OPERATOR_LOGICAL_AND", + "OPERATOR_BITWISE_OR", "OPERATOR_LOGICAL_OR", "OPERATOR_NOT", "DOT", "COMMA", + "SEMI", "STAR", "DOUBLE_STAR", "LR_BRACKET", "RR_BRACKET", "LS_BRACKET", + "RS_BRACKET", "DOUBLE_COLON", "STRING_LITERAL", "DURATION_LITERAL", "DATETIME_LITERAL", + "INTEGER_LITERAL", "EXPONENT_NUM_PART", "ID", "QUOTED_ID" +}; + +dfa::Vocabulary PathParser::_vocabulary(_literalNames, _symbolicNames); + +std::vector PathParser::_tokenNames; + +PathParser::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, 0x27, 0x41, 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, 0x3, 0x2, 0x3, 0x2, + 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x5, 0x2, 0x19, 0xa, 0x2, + 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x7, 0x3, 0x1e, 0xa, 0x3, 0xc, 0x3, + 0xe, 0x3, 0x21, 0xb, 0x3, 0x3, 0x4, 0x3, 0x4, 0x3, 0x4, 0x7, 0x4, + 0x26, 0xa, 0x4, 0xc, 0x4, 0xe, 0x4, 0x29, 0xb, 0x4, 0x3, 0x5, 0x3, + 0x5, 0x3, 0x5, 0x3, 0x5, 0x5, 0x5, 0x2f, 0xa, 0x5, 0x3, 0x5, 0x3, + 0x5, 0x3, 0x5, 0x3, 0x5, 0x5, 0x5, 0x35, 0xa, 0x5, 0x3, 0x6, 0x3, + 0x6, 0x3, 0x7, 0x3, 0x7, 0x5, 0x7, 0x3b, 0xa, 0x7, 0x3, 0x8, 0x3, + 0x8, 0x3, 0x9, 0x3, 0x9, 0x3, 0x9, 0x2, 0x2, 0xa, 0x2, 0x4, 0x6, + 0x8, 0xa, 0xc, 0xe, 0x10, 0x2, 0x4, 0x4, 0x2, 0x22, 0x22, 0x26, 0x27, + 0x3, 0x2, 0x1a, 0x1b, 0x2, 0x40, 0x2, 0x18, 0x3, 0x2, 0x2, 0x2, 0x4, + 0x1a, 0x3, 0x2, 0x2, 0x2, 0x6, 0x22, 0x3, 0x2, 0x2, 0x2, 0x8, 0x34, + 0x3, 0x2, 0x2, 0x2, 0xa, 0x36, 0x3, 0x2, 0x2, 0x2, 0xc, 0x3a, 0x3, + 0x2, 0x2, 0x2, 0xe, 0x3c, 0x3, 0x2, 0x2, 0x2, 0x10, 0x3e, 0x3, 0x2, + 0x2, 0x2, 0x12, 0x13, 0x5, 0x4, 0x3, 0x2, 0x13, 0x14, 0x7, 0x2, 0x2, + 0x3, 0x14, 0x19, 0x3, 0x2, 0x2, 0x2, 0x15, 0x16, 0x5, 0x6, 0x4, 0x2, + 0x16, 0x17, 0x7, 0x2, 0x2, 0x3, 0x17, 0x19, 0x3, 0x2, 0x2, 0x2, 0x18, + 0x12, 0x3, 0x2, 0x2, 0x2, 0x18, 0x15, 0x3, 0x2, 0x2, 0x2, 0x19, 0x3, + 0x3, 0x2, 0x2, 0x2, 0x1a, 0x1f, 0x7, 0x3, 0x2, 0x2, 0x1b, 0x1c, 0x7, + 0x17, 0x2, 0x2, 0x1c, 0x1e, 0x5, 0x8, 0x5, 0x2, 0x1d, 0x1b, 0x3, + 0x2, 0x2, 0x2, 0x1e, 0x21, 0x3, 0x2, 0x2, 0x2, 0x1f, 0x1d, 0x3, 0x2, + 0x2, 0x2, 0x1f, 0x20, 0x3, 0x2, 0x2, 0x2, 0x20, 0x5, 0x3, 0x2, 0x2, + 0x2, 0x21, 0x1f, 0x3, 0x2, 0x2, 0x2, 0x22, 0x27, 0x5, 0x8, 0x5, 0x2, + 0x23, 0x24, 0x7, 0x17, 0x2, 0x2, 0x24, 0x26, 0x5, 0x8, 0x5, 0x2, + 0x25, 0x23, 0x3, 0x2, 0x2, 0x2, 0x26, 0x29, 0x3, 0x2, 0x2, 0x2, 0x27, + 0x25, 0x3, 0x2, 0x2, 0x2, 0x27, 0x28, 0x3, 0x2, 0x2, 0x2, 0x28, 0x7, + 0x3, 0x2, 0x2, 0x2, 0x29, 0x27, 0x3, 0x2, 0x2, 0x2, 0x2a, 0x35, 0x5, + 0x10, 0x9, 0x2, 0x2b, 0x2c, 0x5, 0x10, 0x9, 0x2, 0x2c, 0x2e, 0x5, + 0xc, 0x7, 0x2, 0x2d, 0x2f, 0x5, 0x10, 0x9, 0x2, 0x2e, 0x2d, 0x3, + 0x2, 0x2, 0x2, 0x2e, 0x2f, 0x3, 0x2, 0x2, 0x2, 0x2f, 0x35, 0x3, 0x2, + 0x2, 0x2, 0x30, 0x31, 0x5, 0xc, 0x7, 0x2, 0x31, 0x32, 0x5, 0x10, + 0x9, 0x2, 0x32, 0x35, 0x3, 0x2, 0x2, 0x2, 0x33, 0x35, 0x5, 0xa, 0x6, + 0x2, 0x34, 0x2a, 0x3, 0x2, 0x2, 0x2, 0x34, 0x2b, 0x3, 0x2, 0x2, 0x2, + 0x34, 0x30, 0x3, 0x2, 0x2, 0x2, 0x34, 0x33, 0x3, 0x2, 0x2, 0x2, 0x35, + 0x9, 0x3, 0x2, 0x2, 0x2, 0x36, 0x37, 0x5, 0xe, 0x8, 0x2, 0x37, 0xb, + 0x3, 0x2, 0x2, 0x2, 0x38, 0x3b, 0x5, 0xe, 0x8, 0x2, 0x39, 0x3b, 0x7, + 0x24, 0x2, 0x2, 0x3a, 0x38, 0x3, 0x2, 0x2, 0x2, 0x3a, 0x39, 0x3, + 0x2, 0x2, 0x2, 0x3b, 0xd, 0x3, 0x2, 0x2, 0x2, 0x3c, 0x3d, 0x9, 0x2, + 0x2, 0x2, 0x3d, 0xf, 0x3, 0x2, 0x2, 0x2, 0x3e, 0x3f, 0x9, 0x3, 0x2, + 0x2, 0x3f, 0x11, 0x3, 0x2, 0x2, 0x2, 0x8, 0x18, 0x1f, 0x27, 0x2e, + 0x34, 0x3a, + }; + + _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); + } +} + +PathParser::Initializer PathParser::_init; diff --git a/cpp/src/parser/generated/PathParser.h b/cpp/src/parser/generated/PathParser.h new file mode 100644 index 000000000..5d7afeb2c --- /dev/null +++ b/cpp/src/parser/generated/PathParser.h @@ -0,0 +1,222 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * License); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +// Generated from PathParser.g4 by ANTLR 4.9.3 + +#pragma once + + +#include "antlr4-runtime.h" + + + + +class PathParser : public antlr4::Parser { +public: + enum { + ROOT = 1, WS = 2, TIME = 3, TIMESTAMP = 4, MINUS = 5, PLUS = 6, DIV = 7, + MOD = 8, OPERATOR_DEQ = 9, OPERATOR_SEQ = 10, OPERATOR_GT = 11, OPERATOR_GTE = 12, + OPERATOR_LT = 13, OPERATOR_LTE = 14, OPERATOR_NEQ = 15, OPERATOR_BITWISE_AND = 16, + OPERATOR_LOGICAL_AND = 17, OPERATOR_BITWISE_OR = 18, OPERATOR_LOGICAL_OR = 19, + OPERATOR_NOT = 20, DOT = 21, COMMA = 22, SEMI = 23, STAR = 24, DOUBLE_STAR = 25, + LR_BRACKET = 26, RR_BRACKET = 27, LS_BRACKET = 28, RS_BRACKET = 29, + DOUBLE_COLON = 30, STRING_LITERAL = 31, DURATION_LITERAL = 32, DATETIME_LITERAL = 33, + INTEGER_LITERAL = 34, EXPONENT_NUM_PART = 35, ID = 36, QUOTED_ID = 37 + }; + + enum { + RulePath = 0, RulePrefixPath = 1, RuleSuffixPath = 2, RuleNodeName = 3, + RuleNodeNameWithoutWildcard = 4, RuleNodeNameSlice = 5, RuleIdentifier = 6, + RuleWildcard = 7 + }; + + explicit PathParser(antlr4::TokenStream *input); + ~PathParser(); + + 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; + + + class PathContext; + class PrefixPathContext; + class SuffixPathContext; + class NodeNameContext; + class NodeNameWithoutWildcardContext; + class NodeNameSliceContext; + class IdentifierContext; + class WildcardContext; + + class PathContext : public antlr4::ParserRuleContext { + public: + PathContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + PrefixPathContext *prefixPath(); + antlr4::tree::TerminalNode *EOF(); + SuffixPathContext *suffixPath(); + + 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; + + }; + + PathContext* path(); + + class PrefixPathContext : public antlr4::ParserRuleContext { + public: + PrefixPathContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *ROOT(); + std::vector DOT(); + antlr4::tree::TerminalNode* DOT(size_t i); + std::vector nodeName(); + NodeNameContext* nodeName(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; + + }; + + PrefixPathContext* prefixPath(); + + class SuffixPathContext : public antlr4::ParserRuleContext { + public: + SuffixPathContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector nodeName(); + NodeNameContext* nodeName(size_t i); + std::vector DOT(); + antlr4::tree::TerminalNode* DOT(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; + + }; + + SuffixPathContext* suffixPath(); + + class NodeNameContext : public antlr4::ParserRuleContext { + public: + NodeNameContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector wildcard(); + WildcardContext* wildcard(size_t i); + NodeNameSliceContext *nodeNameSlice(); + NodeNameWithoutWildcardContext *nodeNameWithoutWildcard(); + + 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; + + }; + + NodeNameContext* nodeName(); + + class NodeNameWithoutWildcardContext : public antlr4::ParserRuleContext { + public: + NodeNameWithoutWildcardContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + IdentifierContext *identifier(); + + 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; + + }; + + NodeNameWithoutWildcardContext* nodeNameWithoutWildcard(); + + class NodeNameSliceContext : public antlr4::ParserRuleContext { + public: + NodeNameSliceContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + IdentifierContext *identifier(); + antlr4::tree::TerminalNode *INTEGER_LITERAL(); + + 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; + + }; + + NodeNameSliceContext* nodeNameSlice(); + + class IdentifierContext : public antlr4::ParserRuleContext { + public: + IdentifierContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *DURATION_LITERAL(); + antlr4::tree::TerminalNode *ID(); + antlr4::tree::TerminalNode *QUOTED_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; + + }; + + IdentifierContext* identifier(); + + class WildcardContext : public antlr4::ParserRuleContext { + public: + WildcardContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *STAR(); + antlr4::tree::TerminalNode *DOUBLE_STAR(); + + 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; + + }; + + WildcardContext* wildcard(); + + +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; + + + struct Initializer { + Initializer(); + }; + static Initializer _init; +}; + diff --git a/cpp/src/parser/generated/PathParserBaseListener.cpp b/cpp/src/parser/generated/PathParserBaseListener.cpp new file mode 100644 index 000000000..fbf094631 --- /dev/null +++ b/cpp/src/parser/generated/PathParserBaseListener.cpp @@ -0,0 +1,24 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * License); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +// Generated from PathParser.g4 by ANTLR 4.9.3 + + +#include "PathParserBaseListener.h" + + diff --git a/cpp/src/parser/generated/PathParserBaseListener.h b/cpp/src/parser/generated/PathParserBaseListener.h new file mode 100644 index 000000000..9d6c0cc6e --- /dev/null +++ b/cpp/src/parser/generated/PathParserBaseListener.h @@ -0,0 +1,67 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * License); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +// Generated from PathParser.g4 by ANTLR 4.9.3 + +#pragma once + + +#include "antlr4-runtime.h" +#include "PathParserListener.h" + + +/** + * This class provides an empty implementation of PathParserListener, + * which can be extended to create a listener which only needs to handle a subset + * of the available methods. + */ +class PathParserBaseListener : public PathParserListener { +public: + + virtual void enterPath(PathParser::PathContext * /*ctx*/) override { } + virtual void exitPath(PathParser::PathContext * /*ctx*/) override { } + + virtual void enterPrefixPath(PathParser::PrefixPathContext * /*ctx*/) override { } + virtual void exitPrefixPath(PathParser::PrefixPathContext * /*ctx*/) override { } + + virtual void enterSuffixPath(PathParser::SuffixPathContext * /*ctx*/) override { } + virtual void exitSuffixPath(PathParser::SuffixPathContext * /*ctx*/) override { } + + virtual void enterNodeName(PathParser::NodeNameContext * /*ctx*/) override { } + virtual void exitNodeName(PathParser::NodeNameContext * /*ctx*/) override { } + + virtual void enterNodeNameWithoutWildcard(PathParser::NodeNameWithoutWildcardContext * /*ctx*/) override { } + virtual void exitNodeNameWithoutWildcard(PathParser::NodeNameWithoutWildcardContext * /*ctx*/) override { } + + virtual void enterNodeNameSlice(PathParser::NodeNameSliceContext * /*ctx*/) override { } + virtual void exitNodeNameSlice(PathParser::NodeNameSliceContext * /*ctx*/) override { } + + virtual void enterIdentifier(PathParser::IdentifierContext * /*ctx*/) override { } + virtual void exitIdentifier(PathParser::IdentifierContext * /*ctx*/) override { } + + virtual void enterWildcard(PathParser::WildcardContext * /*ctx*/) override { } + virtual void exitWildcard(PathParser::WildcardContext * /*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 { } + +}; + diff --git a/cpp/src/parser/generated/PathParserBaseVisitor.cpp b/cpp/src/parser/generated/PathParserBaseVisitor.cpp new file mode 100644 index 000000000..9c6ac11dd --- /dev/null +++ b/cpp/src/parser/generated/PathParserBaseVisitor.cpp @@ -0,0 +1,24 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * License); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +// Generated from PathParser.g4 by ANTLR 4.9.3 + + +#include "PathParserBaseVisitor.h" + + diff --git a/cpp/src/parser/generated/PathParserBaseVisitor.h b/cpp/src/parser/generated/PathParserBaseVisitor.h new file mode 100644 index 000000000..1dfc62644 --- /dev/null +++ b/cpp/src/parser/generated/PathParserBaseVisitor.h @@ -0,0 +1,69 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * License); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +// Generated from PathParser.g4 by ANTLR 4.9.3 + +#pragma once + + +#include "antlr4-runtime.h" +#include "PathParserVisitor.h" + + +/** + * This class provides an empty implementation of PathParserVisitor, which can be + * extended to create a visitor which only needs to handle a subset of the available methods. + */ +class PathParserBaseVisitor : public PathParserVisitor { +public: + + virtual antlrcpp::Any visitPath(PathParser::PathContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitPrefixPath(PathParser::PrefixPathContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitSuffixPath(PathParser::SuffixPathContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitNodeName(PathParser::NodeNameContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitNodeNameWithoutWildcard(PathParser::NodeNameWithoutWildcardContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitNodeNameSlice(PathParser::NodeNameSliceContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitIdentifier(PathParser::IdentifierContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitWildcard(PathParser::WildcardContext *ctx) override { + return visitChildren(ctx); + } + + +}; + diff --git a/cpp/src/parser/generated/PathParserListener.cpp b/cpp/src/parser/generated/PathParserListener.cpp new file mode 100644 index 000000000..d41f8bc38 --- /dev/null +++ b/cpp/src/parser/generated/PathParserListener.cpp @@ -0,0 +1,24 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * License); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +// Generated from PathParser.g4 by ANTLR 4.9.3 + + +#include "PathParserListener.h" + + diff --git a/cpp/src/parser/generated/PathParserListener.h b/cpp/src/parser/generated/PathParserListener.h new file mode 100644 index 000000000..f069a14c9 --- /dev/null +++ b/cpp/src/parser/generated/PathParserListener.h @@ -0,0 +1,60 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * License); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +// Generated from PathParser.g4 by ANTLR 4.9.3 + +#pragma once + + +#include "antlr4-runtime.h" +#include "PathParser.h" + + +/** + * This interface defines an abstract listener for a parse tree produced by PathParser. + */ +class PathParserListener : public antlr4::tree::ParseTreeListener { +public: + + virtual void enterPath(PathParser::PathContext *ctx) = 0; + virtual void exitPath(PathParser::PathContext *ctx) = 0; + + virtual void enterPrefixPath(PathParser::PrefixPathContext *ctx) = 0; + virtual void exitPrefixPath(PathParser::PrefixPathContext *ctx) = 0; + + virtual void enterSuffixPath(PathParser::SuffixPathContext *ctx) = 0; + virtual void exitSuffixPath(PathParser::SuffixPathContext *ctx) = 0; + + virtual void enterNodeName(PathParser::NodeNameContext *ctx) = 0; + virtual void exitNodeName(PathParser::NodeNameContext *ctx) = 0; + + virtual void enterNodeNameWithoutWildcard(PathParser::NodeNameWithoutWildcardContext *ctx) = 0; + virtual void exitNodeNameWithoutWildcard(PathParser::NodeNameWithoutWildcardContext *ctx) = 0; + + virtual void enterNodeNameSlice(PathParser::NodeNameSliceContext *ctx) = 0; + virtual void exitNodeNameSlice(PathParser::NodeNameSliceContext *ctx) = 0; + + virtual void enterIdentifier(PathParser::IdentifierContext *ctx) = 0; + virtual void exitIdentifier(PathParser::IdentifierContext *ctx) = 0; + + virtual void enterWildcard(PathParser::WildcardContext *ctx) = 0; + virtual void exitWildcard(PathParser::WildcardContext *ctx) = 0; + + +}; + diff --git a/cpp/src/parser/generated/PathParserVisitor.cpp b/cpp/src/parser/generated/PathParserVisitor.cpp new file mode 100644 index 000000000..bea4c7436 --- /dev/null +++ b/cpp/src/parser/generated/PathParserVisitor.cpp @@ -0,0 +1,24 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * License); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +// Generated from PathParser.g4 by ANTLR 4.9.3 + + +#include "PathParserVisitor.h" + + diff --git a/cpp/src/parser/generated/PathParserVisitor.h b/cpp/src/parser/generated/PathParserVisitor.h new file mode 100644 index 000000000..5090d0354 --- /dev/null +++ b/cpp/src/parser/generated/PathParserVisitor.h @@ -0,0 +1,57 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * License); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +// Generated from PathParser.g4 by ANTLR 4.9.3 + +#pragma once + + +#include "antlr4-runtime.h" +#include "PathParser.h" + + + +/** + * This class defines an abstract visitor for a parse tree + * produced by PathParser. + */ +class PathParserVisitor : public antlr4::tree::AbstractParseTreeVisitor { +public: + + /** + * Visit parse trees produced by PathParser. + */ + virtual antlrcpp::Any visitPath(PathParser::PathContext *context) = 0; + + virtual antlrcpp::Any visitPrefixPath(PathParser::PrefixPathContext *context) = 0; + + virtual antlrcpp::Any visitSuffixPath(PathParser::SuffixPathContext *context) = 0; + + virtual antlrcpp::Any visitNodeName(PathParser::NodeNameContext *context) = 0; + + virtual antlrcpp::Any visitNodeNameWithoutWildcard(PathParser::NodeNameWithoutWildcardContext *context) = 0; + + virtual antlrcpp::Any visitNodeNameSlice(PathParser::NodeNameSliceContext *context) = 0; + + virtual antlrcpp::Any visitIdentifier(PathParser::IdentifierContext *context) = 0; + + virtual antlrcpp::Any visitWildcard(PathParser::WildcardContext *context) = 0; + + +}; + diff --git a/cpp/src/parser/path_nodes_generator.cpp b/cpp/src/parser/path_nodes_generator.cpp new file mode 100644 index 000000000..a22d3905c --- /dev/null +++ b/cpp/src/parser/path_nodes_generator.cpp @@ -0,0 +1,47 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * License); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +#include +#include + +#include "path_nodes_generator.h" +#include "utils/errno_define.h" +#include "generated/PathLexer.h" +#include "generated/PathParser.h" +#include "path_parser_error.h" +#include "path_visitor.h" + +namespace storage { + std::vector PathNodesGenerator::invokeParser(const std::string& path) { + antlr4::ANTLRInputStream inputStream(path); + PathLexer lexer(&inputStream); + lexer.removeErrorListeners(); + lexer.addErrorListener(&PathParseError::getInstance()); + antlr4::CommonTokenStream tokens(&lexer); + PathParser parser(&tokens); + parser.removeErrorListeners(); + parser.addErrorListener(&PathParseError::getInstance()); + parser.getInterpreter()->setPredictionMode(antlr4::atn::PredictionMode::LL); + /* if use SLL Mode to parse path, it will throw exception + but c++ tsfile forbid throw exception, so we use LL Mode + to parse path. + */ + PathVisitor path_visitor; + return path_visitor.visit(parser.path()).as>(); + } +} diff --git a/cpp/src/reader/query_data_set.h b/cpp/src/parser/path_nodes_generator.h similarity index 74% rename from cpp/src/reader/query_data_set.h rename to cpp/src/parser/path_nodes_generator.h index 858427660..51a78b665 100644 --- a/cpp/src/reader/query_data_set.h +++ b/cpp/src/parser/path_nodes_generator.h @@ -16,21 +16,17 @@ * specific language governing permissions and limitations * under the License. */ +#ifndef PATH_NODES_GENERATOR_H +#define PATH_NODES_GENERATOR_H -#ifndef READER_QUERY_DATA_SET_H -#define READER_QUERY_DATA_SET_H - -#include "common/row_record.h" +#include +#include namespace storage { - -class QueryDataSet { - public: - QueryDataSet() {} - virtual ~QueryDataSet() {} - virtual RowRecord *get_next() = 0; +class PathNodesGenerator { + public: + static std::vector invokeParser(const std::string& path); }; +} -} // namespace storage - -#endif // READER_QUERY_DATA_SET_H +#endif \ No newline at end of file diff --git a/cpp/src/parser/path_parser_error.h b/cpp/src/parser/path_parser_error.h new file mode 100644 index 000000000..f4cdfb4d0 --- /dev/null +++ b/cpp/src/parser/path_parser_error.h @@ -0,0 +1,77 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * License); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +#include "antlr4-runtime.h" +#include +#include +#include +#include + +class PathParseError : public antlr4::BaseErrorListener { +public: + static PathParseError& getInstance() { + static PathParseError instance; + return instance; + } + + void syntaxError(antlr4::Recognizer* recognizer, + antlr4::Token* offending_symbol, + size_t line, + size_t char_position_inLine, + const std::string& msg, + std::exception_ptr e) override { + std::string modified_msg = msg; + + auto* parser = dynamic_cast(recognizer); + if (parser != nullptr) { + auto expectedTokens = parser->getExpectedTokens(); + auto vocabulary = parser->getVocabulary(); + + std::set expectedTokenNames; + for (auto token : expectedTokens.toSet()) { + expectedTokenNames.insert(vocabulary.getDisplayName(token)); + } + + if (expectedTokenNames.count("ID") && expectedTokenNames.count("QUOTED_ID")) { + std::ostringstream expectedStr; + expectedStr << "{ID, QUOTED_ID"; + + if (expectedTokenNames.count("*") && expectedTokenNames.count("**")) { + expectedStr << ", *, **"; + } + + expectedStr << "}"; + modified_msg = replace_substring(msg, expectedTokens.toString(vocabulary), expectedStr.str()); + } + } + + throw std::runtime_error("line " + std::to_string(line) + ":" + + std::to_string(char_position_inLine) + " " + modified_msg); + } + +private: + static std::string replace_substring(const std::string& source, + const std::string& from, + const std::string& to) { + size_t start_pos = source.find(from); + if (start_pos == std::string::npos) { + return source; + } + return source.substr(0, start_pos) + to + source.substr(start_pos + from.length()); + } +}; \ No newline at end of file diff --git a/cpp/src/parser/path_visitor.cpp b/cpp/src/parser/path_visitor.cpp new file mode 100644 index 000000000..ebbf5d39d --- /dev/null +++ b/cpp/src/parser/path_visitor.cpp @@ -0,0 +1,111 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * License); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +#include "path_visitor.h" + +namespace storage +{ + antlrcpp::Any PathVisitor::visitPath(PathParser::PathContext *ctx) { + if (ctx->prefixPath() != nullptr) { + return visitPrefixPath(ctx->prefixPath()); + } else { + return visitSuffixPath(ctx->suffixPath()); + } + } + + antlrcpp::Any PathVisitor::visitPrefixPath(PathParser::PrefixPathContext *ctx) { + std::vector node_names = ctx->nodeName(); + std::vector path; + path.reserve(node_names.size() + 1); + path.push_back(ctx->ROOT()->getText()); + for (uint64_t i = 0; i < node_names.size(); i++) { + path.push_back(parse_node_name(node_names[i])); + } + return path; + } + + antlrcpp::Any PathVisitor::visitSuffixPath(PathParser::SuffixPathContext *ctx) { + std::vector node_names = ctx->nodeName(); + std::vector path; + path.reserve(node_names.size()); + for (uint64_t i = 0; i < node_names.size(); i++) { + path.emplace_back(parse_node_name(node_names[i])); + } + return path; + } + std::string PathVisitor::parse_node_name(PathParser::NodeNameContext *ctx) { + std::string node_name = ctx->getText(); + if (starts_with(node_name, BACK_QUOTE_STRING) && ends_with(node_name, BACK_QUOTE_STRING)) { + std::string unWrapped = node_name.substr(1, node_name.length() - 2); + if (is_real_number(unWrapped) || !std::regex_match(unWrapped, IDENTIFIER_PATTERN)) { + return node_name; + } + + return unWrapped; + } + + return node_name; + } + bool PathVisitor::is_real_number(const std::string& str) { + std::string s = str; + if (starts_with(s, "+") || starts_with(s, "-")) { + std::string removeSign = s.substr(1); + if (starts_with(removeSign, "+") || starts_with(removeSign, "-")) { + return false; + } else { + s = removeSign; + } + } + size_t index = 0; + auto it = std::find_if(s.begin(), s.end(), [](const char& c) { return c != '0'; }); + if (it != s.end()) { + index = it - s.begin(); + } + + if (index > 0 && (s[index] == 'e' || s[index] == 'E')) { + return is_creatable(s.substr(index - 1)); + } else { + return is_creatable(s.substr(index)); + } + } + bool PathVisitor::starts_with(const std::string& str, const std::string& prefix) { + if (prefix.size() > str.size()) { + return false; + } + return str.substr(0, prefix.size()) == prefix; + } + + bool PathVisitor::ends_with(const std::string& str, const std::string& suffix) { + if (suffix.size() > str.size()) { + return false; + } + return str.substr(str.size() - suffix.size()) == suffix; + } + + bool PathVisitor::is_creatable(const std::string& str) { + try { + std::stod(str); + return true; + } catch (const std::invalid_argument& e) { + return false; + } catch (const std::out_of_range& e) { + return false; + } + } +} // namespace storage diff --git a/cpp/src/parser/path_visitor.h b/cpp/src/parser/path_visitor.h new file mode 100644 index 000000000..23c6abaa1 --- /dev/null +++ b/cpp/src/parser/path_visitor.h @@ -0,0 +1,49 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * License); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +#ifndef PATH_VISITOR_H +#define PATH_VISITOR_H + +#include "generated/PathParserBaseVisitor.h" +#include "generated/PathParser.h" +#include "common/constant/tsfile_constant.h" + +namespace storage +{ + class PathVisitor : public PathParserBaseVisitor + { + public: + antlrcpp::Any visitPath(PathParser::PathContext *ctx) override; + + antlrcpp::Any visitPrefixPath(PathParser::PrefixPathContext *ctx) override; + + antlrcpp::Any visitSuffixPath(PathParser::SuffixPathContext *ctx) override; + + static bool is_real_number(const std::string& str); + private: + std::string parse_node_name(PathParser::NodeNameContext *ctx); + + static bool starts_with(const std::string& src, const std::string& prefix); + static bool ends_with(const std::string& src, const std::string& suffix); + static bool is_creatable(const std::string& str); + }; + +} // namespace storage + +#endif diff --git a/cpp/src/reader/expression.cc b/cpp/src/reader/expression.cc index e6002d829..123132e2b 100644 --- a/cpp/src/reader/expression.cc +++ b/cpp/src/reader/expression.cc @@ -196,12 +196,19 @@ Expression *QueryExpression::optimize(Expression *expression, void QueryExpression::destory() { for (size_t i = 0; i < my_exprs_.size(); i++) { delete my_exprs_[i]; + my_exprs_[i] = nullptr; } my_exprs_.clear(); for (size_t i = 0; i < my_filters_.size(); i++) { delete my_filters_[i]; + my_filters_[i] = nullptr; + } + if (expression_ != nullptr) { + delete expression_; + expression_ = nullptr; } my_filters_.clear(); + } } // namespace storage diff --git a/cpp/src/reader/expression.h b/cpp/src/reader/expression.h index b5e1af084..512705039 100644 --- a/cpp/src/reader/expression.h +++ b/cpp/src/reader/expression.h @@ -24,6 +24,7 @@ #include "common/db_common.h" #include "common/path.h" +#include "filter/filter.h" namespace storage { @@ -64,6 +65,21 @@ struct Expression { right_(nullptr), filter_(f), series_path_(path) {} + void destroy() { + if (filter_ != nullptr) { + delete filter_; + filter_ = nullptr; + } + if (left_ != nullptr) { + delete left_; + left_ = nullptr; + } + if (right_ != nullptr) { + delete right_; + right_ = nullptr; + } + } + ~Expression() { destroy(); } }; class QueryExpression { diff --git a/cpp/src/reader/filter/and_filter.h b/cpp/src/reader/filter/and_filter.h index b902d59cb..839826342 100644 --- a/cpp/src/reader/filter/and_filter.h +++ b/cpp/src/reader/filter/and_filter.h @@ -34,16 +34,16 @@ class AndFilter : public BinaryFilter { return left_->satisfy(statistic) && right_->satisfy(statistic); } - FORCE_INLINE bool satisfy(long time, int64_t value) { + FORCE_INLINE bool satisfy(int64_t time, int64_t value) { return left_->satisfy(time, value) && right_->satisfy(time, value); } - FORCE_INLINE bool satisfy_start_end_time(long start_time, long end_time) { + FORCE_INLINE bool satisfy_start_end_time(int64_t start_time, int64_t end_time) { return left_->satisfy_start_end_time(start_time, end_time) && right_->satisfy_start_end_time(start_time, end_time); } - FORCE_INLINE bool contain_start_end_time(long start_time, long end_time) { + FORCE_INLINE bool contain_start_end_time(int64_t start_time, int64_t end_time) { return left_->contain_start_end_time(start_time, end_time) && right_->contain_start_end_time(start_time, end_time); } diff --git a/cpp/src/reader/filter/filter.h b/cpp/src/reader/filter/filter.h index f4d15f0b7..2179201f0 100644 --- a/cpp/src/reader/filter/filter.h +++ b/cpp/src/reader/filter/filter.h @@ -37,15 +37,15 @@ class Filter { ASSERT(false); return false; } - virtual bool satisfy(long time, int64_t value) { + virtual bool satisfy(int64_t time, int64_t value) { ASSERT(false); return false; } - virtual bool satisfy_start_end_time(long start_time, long end_time) { + virtual bool satisfy_start_end_time(int64_t start_time, int64_t end_time) { ASSERT(false); return false; } - virtual bool contain_start_end_time(long start_time, long end_time) { + virtual bool contain_start_end_time(int64_t start_time, int64_t end_time) { ASSERT(false); return false; } diff --git a/cpp/src/reader/filter/or_filter.h b/cpp/src/reader/filter/or_filter.h index f0ca1aed1..f68d9d02f 100644 --- a/cpp/src/reader/filter/or_filter.h +++ b/cpp/src/reader/filter/or_filter.h @@ -34,16 +34,16 @@ class OrFilter : public BinaryFilter { return left_->satisfy(statistic) || right_->satisfy(statistic); } - FORCE_INLINE bool satisfy(long time, int64_t value) { + FORCE_INLINE bool satisfy(int64_t time, int64_t value) { return left_->satisfy(time, value) || right_->satisfy(time, value); } - FORCE_INLINE bool satisfy_start_end_time(long start_time, long end_time) { + FORCE_INLINE bool satisfy_start_end_time(int64_t start_time, int64_t end_time) { return left_->satisfy_start_end_time(start_time, end_time) || right_->satisfy_start_end_time(start_time, end_time); } - FORCE_INLINE bool contain_start_end_time(long start_time, long end_time) { + FORCE_INLINE bool contain_start_end_time(int64_t start_time, int64_t end_time) { return left_->contain_start_end_time(start_time, end_time) || right_->contain_start_end_time(start_time, end_time); } diff --git a/cpp/src/reader/filter/time_operator.cc b/cpp/src/reader/filter/time_operator.cc index c43376a69..d4b0ed6f3 100644 --- a/cpp/src/reader/filter/time_operator.cc +++ b/cpp/src/reader/filter/time_operator.cc @@ -38,11 +38,11 @@ bool TimeBetween::satisfy(Statistic *statistic) { } } -bool TimeBetween::satisfy(long time, int64_t value) { +bool TimeBetween::satisfy(int64_t time, int64_t value) { return (value1_ <= time) && (time <= value2_) ^ not_; } -bool TimeBetween::satisfy_start_end_time(long start_time, long end_time) { +bool TimeBetween::satisfy_start_end_time(int64_t start_time, int64_t end_time) { if (not_) { return start_time < value1_ || end_time > value2_; } else { @@ -50,7 +50,7 @@ bool TimeBetween::satisfy_start_end_time(long start_time, long end_time) { } } -bool TimeBetween::contain_start_end_time(long start_time, long end_time) { +bool TimeBetween::contain_start_end_time(int64_t start_time, int64_t end_time) { if (not_) { return end_time < value1_ || start_time > value2_; } else { @@ -83,18 +83,18 @@ TimeIn::~TimeIn() {} bool TimeIn::satisfy(Statistic *statistic) { return true; } -bool TimeIn::satisfy(long time, int64_t value) { +bool TimeIn::satisfy(int64_t time, int64_t value) { std::vector::iterator it = find(values_.begin(), values_.end(), time); bool result = (it != values_.end() ? true : false); return result != not_; } -bool TimeIn::satisfy_start_end_time(long start_time, long end_time) { +bool TimeIn::satisfy_start_end_time(int64_t start_time, int64_t end_time) { return true; } -bool TimeIn::contain_start_end_time(long start_time, long end_time) { +bool TimeIn::contain_start_end_time(int64_t start_time, int64_t end_time) { return true; } @@ -115,13 +115,13 @@ bool TimeEq::satisfy(Statistic *statistic) { return value_ >= statistic->start_time_ && value_ <= statistic->end_time_; } -bool TimeEq::satisfy(long time, int64_t value) { return value_ == time; } +bool TimeEq::satisfy(int64_t time, int64_t value) { return value_ == time; } -bool TimeEq::satisfy_start_end_time(long start_time, long end_time) { +bool TimeEq::satisfy_start_end_time(int64_t start_time, int64_t end_time) { return value_ <= end_time && value_ >= start_time; } -bool TimeEq::contain_start_end_time(long start_time, long end_time) { +bool TimeEq::contain_start_end_time(int64_t start_time, int64_t end_time) { return value_ == start_time && value_ == end_time; } @@ -140,13 +140,13 @@ bool TimeNotEq::satisfy(Statistic *statistic) { value_ == statistic->end_time_); } -bool TimeNotEq::satisfy(long time, int64_t value) { return !(value_ == time); } +bool TimeNotEq::satisfy(int64_t time, int64_t value) { return !(value_ == time); } -bool TimeNotEq::satisfy_start_end_time(long start_time, long end_time) { +bool TimeNotEq::satisfy_start_end_time(int64_t start_time, int64_t end_time) { return value_ != end_time && value_ != start_time; } -bool TimeNotEq::contain_start_end_time(long start_time, long end_time) { +bool TimeNotEq::contain_start_end_time(int64_t start_time, int64_t end_time) { return value_ < start_time || value_ > end_time; } @@ -175,13 +175,13 @@ bool TimeGt::satisfy(Statistic *statistic) { return value_ < statistic->end_time_; } -bool TimeGt::satisfy(long time, int64_t value) { return value_ < time; } +bool TimeGt::satisfy(int64_t time, int64_t value) { return value_ < time; } -bool TimeGt::satisfy_start_end_time(long start_time, long end_time) { +bool TimeGt::satisfy_start_end_time(int64_t start_time, int64_t end_time) { return value_ < end_time; } -bool TimeGt::contain_start_end_time(long start_time, long end_time) { +bool TimeGt::contain_start_end_time(int64_t start_time, int64_t end_time) { return value_ < start_time; } @@ -202,13 +202,13 @@ bool TimeGtEq::satisfy(Statistic *statistic) { return value_ <= statistic->end_time_; } -bool TimeGtEq::satisfy(long time, int64_t value) { return value_ <= time; } +bool TimeGtEq::satisfy(int64_t time, int64_t value) { return value_ <= time; } -bool TimeGtEq::satisfy_start_end_time(long start_time, long end_time) { +bool TimeGtEq::satisfy_start_end_time(int64_t start_time, int64_t end_time) { return value_ <= end_time; } -bool TimeGtEq::contain_start_end_time(long start_time, long end_time) { +bool TimeGtEq::contain_start_end_time(int64_t start_time, int64_t end_time) { return value_ <= start_time; } @@ -227,13 +227,13 @@ bool TimeLt::satisfy(Statistic *statistic) { return value_ > statistic->start_time_; } -bool TimeLt::satisfy(long time, int64_t value) { return value_ > time; } +bool TimeLt::satisfy(int64_t time, int64_t value) { return value_ > time; } -bool TimeLt::satisfy_start_end_time(long start_time, long end_time) { +bool TimeLt::satisfy_start_end_time(int64_t start_time, int64_t end_time) { return value_ > start_time; } -bool TimeLt::contain_start_end_time(long start_time, long end_time) { +bool TimeLt::contain_start_end_time(int64_t start_time, int64_t end_time) { return value_ > end_time; } @@ -254,13 +254,13 @@ bool TimeLtEq::satisfy(Statistic *statistic) { return value_ >= statistic->start_time_; } -bool TimeLtEq::satisfy(long time, int64_t value) { return value_ >= time; } +bool TimeLtEq::satisfy(int64_t time, int64_t value) { return value_ >= time; } -bool TimeLtEq::satisfy_start_end_time(long start_time, long end_time) { +bool TimeLtEq::satisfy_start_end_time(int64_t start_time, int64_t end_time) { return value_ >= start_time; } -bool TimeLtEq::contain_start_end_time(long start_time, long end_time) { +bool TimeLtEq::contain_start_end_time(int64_t start_time, int64_t end_time) { return value_ >= end_time; } diff --git a/cpp/src/reader/filter/time_operator.h b/cpp/src/reader/filter/time_operator.h index 8480aec33..58ee50146 100644 --- a/cpp/src/reader/filter/time_operator.h +++ b/cpp/src/reader/filter/time_operator.h @@ -38,11 +38,11 @@ class TimeBetween : public Filter { bool satisfy(Statistic *statistic); - bool satisfy(long time, int64_t value); + bool satisfy(int64_t time, int64_t value); - bool satisfy_start_end_time(long start_time, long end_time); + bool satisfy_start_end_time(int64_t start_time, int64_t end_time); - bool contain_start_end_time(long start_time, long end_time); + bool contain_start_end_time(int64_t start_time, int64_t end_time); std::vector *get_time_ranges(); FilterType get_filter_type() { return type_; } @@ -62,11 +62,11 @@ class TimeIn : public Filter { bool satisfy(Statistic *statistic); - bool satisfy(long time, int64_t value); + bool satisfy(int64_t time, int64_t value); - bool satisfy_start_end_time(long start_time, long end_time); + bool satisfy_start_end_time(int64_t start_time, int64_t end_time); - bool contain_start_end_time(long start_time, long end_time); + bool contain_start_end_time(int64_t start_time, int64_t end_time); std::vector *get_time_ranges(); @@ -85,11 +85,11 @@ class TimeEq : public Filter { bool satisfy(Statistic *statistic); - bool satisfy(long time, int64_t value); + bool satisfy(int64_t time, int64_t value); - bool satisfy_start_end_time(long start_time, long end_time); + bool satisfy_start_end_time(int64_t start_time, int64_t end_time); - bool contain_start_end_time(long start_time, long end_time); + bool contain_start_end_time(int64_t start_time, int64_t end_time); std::vector *get_time_ranges(); @@ -107,11 +107,11 @@ class TimeNotEq : public Filter { bool satisfy(Statistic *statistic); - bool satisfy(long time, int64_t value); + bool satisfy(int64_t time, int64_t value); - bool satisfy_start_end_time(long start_time, long end_time); + bool satisfy_start_end_time(int64_t start_time, int64_t end_time); - bool contain_start_end_time(long start_time, long end_time); + bool contain_start_end_time(int64_t start_time, int64_t end_time); std::vector *get_time_ranges(); FilterType get_filter_type() { return type_; } @@ -128,11 +128,11 @@ class TimeGt : public Filter { bool satisfy(Statistic *statistic); - bool satisfy(long time, int64_t value); + bool satisfy(int64_t time, int64_t value); - bool satisfy_start_end_time(long start_time, long end_time); + bool satisfy_start_end_time(int64_t start_time, int64_t end_time); - bool contain_start_end_time(long start_time, long end_time); + bool contain_start_end_time(int64_t start_time, int64_t end_time); std::vector *get_time_ranges(); @@ -150,11 +150,11 @@ class TimeGtEq : public Filter { bool satisfy(Statistic *statistic); - bool satisfy(long time, int64_t value); + bool satisfy(int64_t time, int64_t value); - bool satisfy_start_end_time(long start_time, long end_time); + bool satisfy_start_end_time(int64_t start_time, int64_t end_time); - bool contain_start_end_time(long start_time, long end_time); + bool contain_start_end_time(int64_t start_time, int64_t end_time); std::vector *get_time_ranges(); void reset_value(int64_t val) { value_ = val; } @@ -172,11 +172,11 @@ class TimeLt : public Filter { bool satisfy(Statistic *statistic); - bool satisfy(long time, int64_t value); + bool satisfy(int64_t time, int64_t value); - bool satisfy_start_end_time(long start_time, long end_time); + bool satisfy_start_end_time(int64_t start_time, int64_t end_time); - bool contain_start_end_time(long start_time, long end_time); + bool contain_start_end_time(int64_t start_time, int64_t end_time); std::vector *get_time_ranges(); @@ -194,11 +194,11 @@ class TimeLtEq : public Filter { bool satisfy(Statistic *statistic); - bool satisfy(long time, int64_t value); + bool satisfy(int64_t time, int64_t value); - bool satisfy_start_end_time(long start_time, long end_time); + bool satisfy_start_end_time(int64_t start_time, int64_t end_time); - bool contain_start_end_time(long start_time, long end_time); + bool contain_start_end_time(int64_t start_time, int64_t end_time); std::vector *get_time_ranges(); FilterType get_filter_type() { return type_; } diff --git a/cpp/src/reader/qds_with_timegenerator.cc b/cpp/src/reader/qds_with_timegenerator.cc index df42a329d..fd39ad300 100644 --- a/cpp/src/reader/qds_with_timegenerator.cc +++ b/cpp/src/reader/qds_with_timegenerator.cc @@ -287,17 +287,25 @@ int QDSWithTimeGenerator::init(TsFileIOReader *io_reader, QueryExpression *qe) { io_reader_ = io_reader; qe_ = qe; std::vector paths = qe_->selected_series_; - + std::vector column_names; + std::vector data_types; + column_names.reserve(paths.size()); + data_types.reserve(paths.size()); + for (const auto &path : paths) { + column_names.push_back(path.full_path_); + } for (size_t i = 0; i < paths.size(); i++) { ValueAt va; + index_lookup_.insert({paths[i].measurement_, i}); if (RET_FAIL(io_reader_->alloc_ssi(paths[i].device_, paths[i].measurement_, va.ssi_))) { } else { va.io_reader_ = io_reader_; + data_types.push_back(va.value_col_iter_->get_data_type()); value_at_vec_.push_back(va); } } - + result_set_metadata_ = new ResultSetMetadata(column_names, data_types); row_record_ = new RowRecord(value_at_vec_.size()); tree_ = construct_node_tree(qe->expression_); return E_OK; @@ -313,11 +321,15 @@ void destroy_node(Node *node) { delete node; } -void QDSWithTimeGenerator::destroy() { +void QDSWithTimeGenerator::close() { if (row_record_ != nullptr) { delete row_record_; row_record_ = nullptr; } + if (result_set_metadata_ != nullptr) { + delete result_set_metadata_; + result_set_metadata_ = nullptr; + } if (tree_ != nullptr) { destroy_node(tree_); tree_ = nullptr; @@ -325,16 +337,20 @@ void QDSWithTimeGenerator::destroy() { for (size_t i = 0; i < value_at_vec_.size(); i++) { value_at_vec_[i].destroy(); } + if (qe_ != nullptr) { + delete qe_; + qe_ = nullptr; + } value_at_vec_.clear(); } -RowRecord *QDSWithTimeGenerator::get_next() { +bool QDSWithTimeGenerator::next() { if (tree_ == nullptr) { - return nullptr; + return false; } int64_t timestamp = tree_->get_cur_timestamp(); if (timestamp == INVALID_NEXT_TIMESTAMP) { - return nullptr; + return false; } row_record_->set_timestamp(timestamp); #if DEBUG_SE @@ -352,9 +368,27 @@ RowRecord *QDSWithTimeGenerator::get_next() { #if DEBUG_SE std::cout << "\n\n" << std::endl; #endif - return row_record_; + return true; } +bool QDSWithTimeGenerator::is_null(const std::string &column_name) { + auto iter = index_lookup_.find(column_name); + if (iter == index_lookup_.end()) { + return true; + } else { + return is_null(iter->second); + } +} + +bool QDSWithTimeGenerator::is_null(uint32_t column_index) { + return row_record_->get_field(column_index) == nullptr; +} + +RowRecord *QDSWithTimeGenerator::get_row_record() { return row_record_; } + +ResultSetMetadata *QDSWithTimeGenerator::get_metadata() { + return result_set_metadata_; +} Node *QDSWithTimeGenerator::construct_node_tree(Expression *expr) { if (expr->type_ == AND_EXPR || expr->type_ == OR_EXPR) { Node *root = nullptr; diff --git a/cpp/src/reader/qds_with_timegenerator.h b/cpp/src/reader/qds_with_timegenerator.h index 3afafcf2f..43c367424 100644 --- a/cpp/src/reader/qds_with_timegenerator.h +++ b/cpp/src/reader/qds_with_timegenerator.h @@ -21,8 +21,8 @@ #include "common/db_common.h" #include "expression.h" -#include "query_data_set.h" #include "reader/tsfile_series_scan_iterator.h" +#include "result_set.h" namespace storage { @@ -106,25 +106,31 @@ struct Node { void next_timestamp(int64_t beyond_this_time); }; -class QDSWithTimeGenerator : public QueryDataSet { +class QDSWithTimeGenerator : public ResultSet { public: QDSWithTimeGenerator() : row_record_(nullptr), + result_set_metadata_(nullptr), io_reader_(nullptr), qe_(nullptr), tree_(nullptr), value_at_vec_() {} - ~QDSWithTimeGenerator() { destroy(); } + ~QDSWithTimeGenerator() { close(); } int init(TsFileIOReader *io_reader, QueryExpression *qe); - void destroy(); - RowRecord *get_next(); + void close(); + bool next(); + bool is_null(const std::string &column_name); + bool is_null(uint32_t column_index); + RowRecord *get_row_record(); + ResultSetMetadata *get_metadata(); private: Node *construct_node_tree(Expression *expr); private: RowRecord *row_record_; + ResultSetMetadata *result_set_metadata_; TsFileIOReader *io_reader_; QueryExpression *qe_; Node *tree_; diff --git a/cpp/src/reader/qds_without_timegenerator.cc b/cpp/src/reader/qds_without_timegenerator.cc index af7f24293..1fac9990a 100644 --- a/cpp/src/reader/qds_without_timegenerator.cc +++ b/cpp/src/reader/qds_without_timegenerator.cc @@ -34,6 +34,10 @@ int QDSWithoutTimeGenerator::init(TsFileIOReader *io_reader, std::vector paths = qe_->selected_series_; size_t origin_path_count = paths.size(); std::vector valid_paths; + std::vector column_names; + std::vector data_types; + column_names.reserve(origin_path_count); + data_types.reserve(origin_path_count); Expression *global_time_expression = qe->expression_; Filter *global_time_filter = nullptr; if (global_time_expression != nullptr) { @@ -46,8 +50,10 @@ int QDSWithoutTimeGenerator::init(TsFileIOReader *io_reader, if (ret != 0) { return ret; } else { + index_lookup_.insert({paths[i].measurement_, i}); ssi_vec_.push_back(ssi); valid_paths.push_back(paths[i]); + column_names.push_back(paths[i].full_path_); } } @@ -59,15 +65,21 @@ int QDSWithoutTimeGenerator::init(TsFileIOReader *io_reader, for (size_t i = 0; i < path_count; i++) { get_next_tsblock(i, true); + data_types.push_back(value_iters_[i]->get_data_type()); } + result_set_metadata_ = new ResultSetMetadata(column_names, data_types); return E_OK; // ignore invalid timeseries } -void QDSWithoutTimeGenerator::destroy() { +void QDSWithoutTimeGenerator::close() { if (row_record_ != nullptr) { delete row_record_; row_record_ = nullptr; } + if (result_set_metadata_ != nullptr) { + delete result_set_metadata_; + result_set_metadata_ = nullptr; + } for (size_t i = 0; i < time_iters_.size(); i++) { delete time_iters_[i]; time_iters_[i] = nullptr; @@ -89,12 +101,16 @@ void QDSWithoutTimeGenerator::destroy() { io_reader_->revert_ssi(ssi); } ssi_vec_.clear(); + if (qe_ != nullptr) { + delete qe_; + qe_ = nullptr; + } } -RowRecord *QDSWithoutTimeGenerator::get_next() { +bool QDSWithoutTimeGenerator::next() { row_record_->reset(); if (heap_time_.size() == 0) { - return nullptr; + return false; } int64_t time = heap_time_.begin()->first; row_record_->set_timestamp(time); @@ -118,7 +134,26 @@ RowRecord *QDSWithoutTimeGenerator::get_next() { iter++; // cppcheck-suppress postfixOperator heap_time_.erase(cur); } - return row_record_; + return true; +} + +bool QDSWithoutTimeGenerator::is_null(const std::string &column_name) { + auto iter = index_lookup_.find(column_name); + if (iter == index_lookup_.end()) { + return true; + } else { + return is_null(iter->second); + } +} + +bool QDSWithoutTimeGenerator::is_null(uint32_t column_index) { + return row_record_->get_field(column_index) == nullptr; +} + +RowRecord *QDSWithoutTimeGenerator::get_row_record() { return row_record_; } + +ResultSetMetadata *QDSWithoutTimeGenerator::get_metadata() { + return result_set_metadata_; } int QDSWithoutTimeGenerator::get_next_tsblock(uint32_t index, bool alloc_mem) { diff --git a/cpp/src/reader/qds_without_timegenerator.h b/cpp/src/reader/qds_without_timegenerator.h index 8b18caa06..b41655269 100644 --- a/cpp/src/reader/qds_without_timegenerator.h +++ b/cpp/src/reader/qds_without_timegenerator.h @@ -25,14 +25,15 @@ #include "expression.h" #include "file/tsfile_io_reader.h" -#include "query_data_set.h" +#include "result_set.h" namespace storage { -class QDSWithoutTimeGenerator : public QueryDataSet { +class QDSWithoutTimeGenerator : public ResultSet { public: QDSWithoutTimeGenerator() : row_record_(nullptr), + result_set_metadata_(nullptr), io_reader_(nullptr), qe_(nullptr), ssi_vec_(), @@ -40,16 +41,21 @@ class QDSWithoutTimeGenerator : public QueryDataSet { time_iters_(), value_iters_(), heap_time_() {} - ~QDSWithoutTimeGenerator() { destroy(); } + ~QDSWithoutTimeGenerator() { close(); } int init(TsFileIOReader *io_reader, QueryExpression *qe); - void destroy(); - RowRecord *get_next(); + void close(); + bool next(); + bool is_null(const std::string &column_name); + bool is_null(uint32_t column_index); + RowRecord *get_row_record(); + ResultSetMetadata *get_metadata(); private: int get_next_tsblock(uint32_t index, bool alloc_mem); private: RowRecord *row_record_; + ResultSetMetadata *result_set_metadata_; TsFileIOReader *io_reader_; QueryExpression *qe_; std::vector ssi_vec_; diff --git a/cpp/src/reader/result_set.h b/cpp/src/reader/result_set.h new file mode 100644 index 000000000..767c95860 --- /dev/null +++ b/cpp/src/reader/result_set.h @@ -0,0 +1,80 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * License); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +#ifndef READER_QUERY_DATA_SET_H +#define READER_QUERY_DATA_SET_H + +#include + +#include "common/row_record.h" + +namespace storage { + +class ResultSetMetadata { + public: + ResultSetMetadata(const std::vector& column_names, + const std::vector& column_types) + : column_names_(column_names), column_types_(column_types) {} + common::TSDataType get_column_type(uint32_t column_index) { + ASSERT(column_index >= 0 && column_index < column_types_.size()); + return column_types_[column_index]; + } + std::string get_column_name(uint32_t column_index) { + ASSERT(column_index >= 0 && column_index < column_names_.size()); + return column_names_[column_index]; + } + + private: + std::vector column_names_; + std::vector column_types_; +}; + +class ResultSet { + public: + ResultSet() {} + virtual ~ResultSet() {} + virtual bool next() = 0; + virtual bool is_null(const std::string& column_name) = 0; + virtual bool is_null(uint32_t column_index) = 0; + + template + T get_value(const std::string& column_name) { + RowRecord* row_record = get_row_record(); + ASSERT(index_lookup_.count(column_name)); + uint32_t index = index_lookup_[column_name]; + ASSERT(index >= 0 && index < row_record->get_col_num()); + return row_record->get_field(index)->get_value(); + } + template + T get_value(uint32_t column_index) { + RowRecord* row_record = get_row_record(); + ASSERT(column_index >= 0 && column_index < row_record->get_col_num()); + return row_record->get_field(column_index)->get_value(); + } + virtual RowRecord* get_row_record() = 0; + virtual ResultSetMetadata* get_metadata() = 0; + virtual void close() = 0; + + protected: + std::unordered_map index_lookup_; +}; + +} // namespace storage + +#endif // READER_QUERY_DATA_SET_H diff --git a/cpp/src/reader/tsfile_executor.cc b/cpp/src/reader/tsfile_executor.cc index 757a8e235..71c03f0ee 100644 --- a/cpp/src/reader/tsfile_executor.cc +++ b/cpp/src/reader/tsfile_executor.cc @@ -58,11 +58,10 @@ int TsFileExecutor::init(const std::string &file_path) { return ret; } -int TsFileExecutor::execute(QueryExpression *query_expr, - QueryDataSet *&ret_qds) { +int TsFileExecutor::execute(QueryExpression *query_expr, ResultSet *&ret_qds) { ASSERT(is_inited_); query_exprs_ = query_expr; - std::vector paths = query_expr->selected_series_; + std::vector paths = query_exprs_->selected_series_; Expression *origin_expr = query_exprs_->expression_; Expression *regular_expr = nullptr; if (query_exprs_->has_filter_) { @@ -88,7 +87,7 @@ int TsFileExecutor::execute(QueryExpression *query_expr, } int TsFileExecutor::execute_may_with_global_timefilter(QueryExpression *qe, - QueryDataSet *&ret_qds) { + ResultSet *&ret_qds) { int ret = E_OK; QDSWithoutTimeGenerator *qds = new QDSWithoutTimeGenerator; ret = qds->init(&io_reader_, qe); @@ -101,7 +100,7 @@ int TsFileExecutor::execute_may_with_global_timefilter(QueryExpression *qe, } int TsFileExecutor::execute_with_timegenerator(QueryExpression *qe, - QueryDataSet *&ret_qds) { + ResultSet *&ret_qds) { int ret = E_OK; QDSWithTimeGenerator *qds = new QDSWithTimeGenerator; ret = qds->init(&io_reader_, qe); @@ -113,6 +112,6 @@ int TsFileExecutor::execute_with_timegenerator(QueryExpression *qe, return ret; } -void TsFileExecutor::destroy_query_data_set(QueryDataSet *qds) { delete qds; } +void TsFileExecutor::destroy_query_data_set(ResultSet *qds) { delete qds; } } // namespace storage diff --git a/cpp/src/reader/tsfile_executor.h b/cpp/src/reader/tsfile_executor.h index f768c4b4a..a87dba2b4 100644 --- a/cpp/src/reader/tsfile_executor.h +++ b/cpp/src/reader/tsfile_executor.h @@ -22,8 +22,8 @@ #include #include "file/read_file.h" -#include "query_data_set.h" #include "query_executor.h" +#include "result_set.h" namespace storage { @@ -34,13 +34,15 @@ class TsFileExecutor // : public QueryExecutor ~TsFileExecutor(); int init(ReadFile *read_file); int init(const std::string &file_path); - int execute(QueryExpression *query_expr, QueryDataSet *&ret_qds); - void destroy_query_data_set(QueryDataSet *qds); + int execute(QueryExpression *query_expr, ResultSet *&ret_qds); + void destroy_query_data_set(ResultSet *qds); + TsFileMeta *get_tsfile_meta() { return io_reader_.get_tsfile_meta(); } + TsFileIOReader *get_tsfile_io_reader() { return &io_reader_; } private: int execute_may_with_global_timefilter(QueryExpression *qe, - QueryDataSet *&ret_qds); - int execute_with_timegenerator(QueryExpression *qe, QueryDataSet *&ret_qds); + ResultSet *&ret_qds); + int execute_with_timegenerator(QueryExpression *qe, ResultSet *&ret_qds); private: TsFileIOReader io_reader_; diff --git a/cpp/src/reader/tsfile_reader.cc b/cpp/src/reader/tsfile_reader.cc index 3b73b4f3f..f613d735e 100644 --- a/cpp/src/reader/tsfile_reader.cc +++ b/cpp/src/reader/tsfile_reader.cc @@ -18,6 +18,8 @@ */ #include "tsfile_reader.h" +#include "common/schema.h" +#include "filter/time_operator.h" #include "tsfile_executor.h" using namespace common; @@ -27,7 +29,22 @@ namespace storage { TsFileReader::TsFileReader() : read_file_(nullptr), tsfile_executor_(nullptr) {} -TsFileReader::~TsFileReader() { +TsFileReader::~TsFileReader() { close(); } + +int TsFileReader::open(const std::string &file_path) { + int ret = E_OK; + read_file_ = new storage::ReadFile; + tsfile_executor_ = new storage::TsFileExecutor(); + if (RET_FAIL(read_file_->open(file_path))) { + std::cout << "filed to open file " << ret << std::endl; + } else if (RET_FAIL(tsfile_executor_->init(read_file_))) { + std::cout << "filed to init " << ret << std::endl; + } + return ret; +} + +int TsFileReader::close() { + int ret = E_OK; if (tsfile_executor_ != nullptr) { delete tsfile_executor_; tsfile_executor_ = nullptr; @@ -37,29 +54,102 @@ TsFileReader::~TsFileReader() { delete read_file_; read_file_ = nullptr; } + return ret; } -int TsFileReader::open(const std::string &file_path) { +int TsFileReader::query(QueryExpression *qe, ResultSet *&ret_qds) { + return tsfile_executor_->execute(qe, ret_qds); +} + +int TsFileReader::query(std::vector &path_list, int64_t start_time, + int64_t end_time, ResultSet *&result_set) { int ret = E_OK; - read_file_ = new storage::ReadFile; - tsfile_executor_ = new storage::TsFileExecutor(); - if (RET_FAIL(read_file_->open(file_path))) { - std::cout << "filed to open file " << ret << std::endl; - } else if (RET_FAIL(tsfile_executor_->init(read_file_))) { - std::cout << "filed to init " << ret << std::endl; + Filter *time_filter = new TimeBetween(start_time, end_time, false); + Expression *exp = + new storage::Expression(storage::GLOBALTIME_EXPR, time_filter); + std::vector path_list_vec; + for (const auto &path : path_list) { + path_list_vec.emplace_back(Path(path, true)); } + QueryExpression *query_expression = + QueryExpression::create(path_list_vec, exp); + ret = tsfile_executor_->execute(query_expression, result_set); return ret; } -int TsFileReader::query(QueryExpression *qe, QueryDataSet *&ret_qds) { - return tsfile_executor_->execute(qe, ret_qds); +void TsFileReader::destroy_query_data_set(storage::ResultSet *qds) { + tsfile_executor_->destroy_query_data_set(qds); } -void TsFileReader::destroy_query_data_set(storage::QueryDataSet *qds) { - tsfile_executor_->destroy_query_data_set(qds); +std::vector TsFileReader::get_all_devices() { + TsFileMeta *tsfile_meta = tsfile_executor_->get_tsfile_meta(); + std::vector device_ids; + if (tsfile_meta != nullptr) { + PageArena pa; + pa.init(512, MOD_TSFILE_READER); + get_all_devices(device_ids, tsfile_meta->index_node_, pa); + } + return device_ids; +} + +int TsFileReader::get_all_devices(std::vector &device_ids, MetaIndexNode *index_node, PageArena &pa) { + int ret = E_OK; + if (index_node != nullptr) { + if (index_node->node_type_ == LEAF_DEVICE) { + for (const auto &meta_index_entry : index_node->children_) { + device_ids.push_back(meta_index_entry->name_.to_std_string()); + } + } else { + for (size_t idx = 0; idx < index_node->children_.size(); idx++) { + MetaIndexEntry* meta_index_entry = index_node->children_[idx]; + int start_offset = meta_index_entry->offset_; + int end_offset = index_node->end_offset_; + if (idx + 1 < index_node->children_.size()) { + end_offset = index_node->children_[idx + 1]->offset_; + } + ASSERT(end_offset - start_offset > 0); + const int32_t read_size = (int32_t)end_offset - start_offset; + int32_t ret_read_len = 0; + char *data_buf = (char *)pa.alloc(read_size); + void *m_idx_node_buf = pa.alloc(sizeof(MetaIndexNode)); + if (IS_NULL(data_buf) || IS_NULL(m_idx_node_buf)) { + return E_OOM; + } + MetaIndexNode *top_node = new (m_idx_node_buf) MetaIndexNode(&pa); + if (RET_FAIL(read_file_->read(start_offset, data_buf, read_size, + ret_read_len))) { + } else if (RET_FAIL(top_node->deserialize_from(data_buf, read_size))) { + } else { + ret = get_all_devices(device_ids, top_node, pa); + } + top_node->destroy(); + } + } + } + return ret; +} + +int TsFileReader::get_timeseries_schema( + const std::string &device_id, std::vector &result) { + int ret = E_OK; + std::vector timeseries_indexs; + PageArena pa; + pa.init(512, MOD_TSFILE_READER); + if (RET_FAIL(tsfile_executor_->get_tsfile_io_reader() + ->get_device_timeseries_meta_without_chunk_meta( + device_id, timeseries_indexs, pa))) { + } else { + for (auto timeseries_index : timeseries_indexs) { + MeasurementSchema ms( + timeseries_index->get_measurement_name().to_std_string(), + timeseries_index->get_data_type()); + result.push_back(ms); + } + } + return E_OK; } -QueryDataSet *TsFileReader::read_timeseries( +ResultSet *TsFileReader::read_timeseries( const std::string &device_name, std::vector measurement_name) { return nullptr; } diff --git a/cpp/src/reader/tsfile_reader.h b/cpp/src/reader/tsfile_reader.h index 3d90ffc46..0746cb585 100644 --- a/cpp/src/reader/tsfile_reader.h +++ b/cpp/src/reader/tsfile_reader.h @@ -23,11 +23,12 @@ #include "common/row_record.h" #include "expression.h" #include "file/read_file.h" - +#include "common/tsfile_common.h" namespace storage { class TsFileExecutor; class ReadFile; -class QueryDataSet; +class ResultSet; +struct MeasurementSchema; } // namespace storage namespace storage { @@ -40,12 +41,19 @@ class TsFileReader { TsFileReader(); ~TsFileReader(); int open(const std::string &file_path); - int query(storage::QueryExpression *qe, QueryDataSet *&ret_qds); - void destroy_query_data_set(QueryDataSet *qds); - QueryDataSet *read_timeseries(const std::string &device_name, - std::vector measurement_name); + int close(); + int query(storage::QueryExpression *qe, ResultSet *&ret_qds); + int query(std::vector &path_list, int64_t start_time, + int64_t end_time, ResultSet *&result_set); + void destroy_query_data_set(ResultSet *qds); + ResultSet *read_timeseries(const std::string &device_name, + std::vector measurement_name); + std::vector get_all_devices(); + int get_timeseries_schema(const std::string &device_id, + std::vector &result); private: + int get_all_devices(std::vector &device_ids, MetaIndexNode *index_node, common::PageArena &pa); storage::ReadFile *read_file_; storage::TsFileExecutor *tsfile_executor_; }; diff --git a/cpp/src/writer/time_page_writer.cc b/cpp/src/writer/time_page_writer.cc index 215b0b766..8093a76fa 100644 --- a/cpp/src/writer/time_page_writer.cc +++ b/cpp/src/writer/time_page_writer.cc @@ -70,7 +70,8 @@ int TimePageData::init(ByteStream &time_bs, Compressor *compressor) { int TimePageWriter::init(TSEncoding encoding, CompressionType compression) { int ret = E_OK; - if (nullptr == (time_encoder_ = EncoderFactory::alloc_time_encoder())) { + if (nullptr == + (time_encoder_ = EncoderFactory::alloc_time_encoder(encoding))) { ret = E_OOM; } else if (nullptr == (statistic_ = StatisticFactory::alloc_statistic( common::VECTOR))) { diff --git a/cpp/src/writer/tsfile_writer.cc b/cpp/src/writer/tsfile_writer.cc index 8cc0b6d4d..61b0510bb 100644 --- a/cpp/src/writer/tsfile_writer.cc +++ b/cpp/src/writer/tsfile_writer.cc @@ -130,23 +130,24 @@ int TsFileWriter::open(const std::string &file_path, int flags, mode_t mode) { return ret; } +int TsFileWriter::open(const std::string &file_path) { + return open(file_path, O_RDWR | O_CREAT | O_TRUNC, 0666); +} + int TsFileWriter::register_aligned_timeseries( - const std::string &device_path, const std::string &measurement_name, - common::TSDataType data_type, common::TSEncoding encoding, - common::CompressionType compression_type) { - MeasurementSchema *ms = new MeasurementSchema(measurement_name, data_type, - encoding, compression_type); - return register_timeseries(device_path, ms, true); + const std::string &device_id, const MeasurementSchema &measurement_schema) { + MeasurementSchema *ms = new MeasurementSchema( + measurement_schema.measurement_name_, measurement_schema.data_type_, + measurement_schema.encoding_, measurement_schema.compression_type_); + return register_timeseries(device_id, ms, true); } int TsFileWriter::register_aligned_timeseries( - const std::string &device_path, - const std::vector &measurement_schema_vec) { + const std::string &device_id, + const std::vector &measurement_schemas) { int ret = E_OK; - std::vector::const_iterator it = - measurement_schema_vec.begin(); - for (; it != measurement_schema_vec.end(); it++) { - ret = register_timeseries(device_path, *it, true); + for (auto it : measurement_schemas) { + ret = register_timeseries(device_id, it, true); if (ret != E_OK) { return ret; } @@ -155,18 +156,17 @@ int TsFileWriter::register_aligned_timeseries( } int TsFileWriter::register_timeseries( - const std::string &device_path, const std::string &measurement_name, - common::TSDataType data_type, common::TSEncoding encoding, - common::CompressionType compression_type) { - MeasurementSchema *ms = new MeasurementSchema(measurement_name, data_type, - encoding, compression_type); - return register_timeseries(device_path, ms); + const std::string &device_id, const MeasurementSchema &measurement_schema) { + MeasurementSchema *ms = new MeasurementSchema( + measurement_schema.measurement_name_, measurement_schema.data_type_, + measurement_schema.encoding_, measurement_schema.compression_type_); + return register_timeseries(device_id, ms, false); } -int TsFileWriter::register_timeseries(const std::string &device_path, +int TsFileWriter::register_timeseries(const std::string &device_id, MeasurementSchema *measurement_schema, bool is_aligned) { - DeviceSchemaIter device_iter = schemas_.find(device_path); + DeviceSchemaIter device_iter = schemas_.find(device_id); if (device_iter != schemas_.end()) { MeasurementSchemaMap &msm = device_iter->second->measurement_schema_map_; @@ -180,20 +180,20 @@ int TsFileWriter::register_timeseries(const std::string &device_path, ms_group->is_aligned_ = is_aligned; ms_group->measurement_schema_map_.insert(std::make_pair( measurement_schema->measurement_name_, measurement_schema)); - schemas_.insert(std::make_pair(device_path, ms_group)); + schemas_.insert(std::make_pair(device_id, ms_group)); } return E_OK; } int TsFileWriter::register_timeseries( - const std::string &device_path, + const std::string &device_id, const std::vector &measurement_schema_vec) { int ret = E_OK; std::vector::const_iterator it = measurement_schema_vec.begin(); for (; it != measurement_schema_vec.end(); it++) { // cppcheck-suppress postfixOperator - ret = register_timeseries(device_path, *it); + ret = register_timeseries(device_id, *it); if (ret != E_OK) { return ret; } @@ -410,8 +410,8 @@ int TsFileWriter::write_record(const TsRecord &record) { // std::vector chunk_writers; SimpleVector chunk_writers; MeasurementNamesFromRecord mnames_getter(record); - if (RET_FAIL(do_check_schema(record.device_name_, mnames_getter, - chunk_writers))) { + if (RET_FAIL( + do_check_schema(record.device_id_, mnames_getter, chunk_writers))) { return ret; } @@ -435,7 +435,7 @@ int TsFileWriter::write_record_aligned(const TsRecord &record) { SimpleVector value_chunk_writers; TimeChunkWriter *time_chunk_writer; MeasurementNamesFromRecord mnames_getter(record); - if (RET_FAIL(do_check_schema_aligned(record.device_name_, mnames_getter, + if (RET_FAIL(do_check_schema_aligned(record.device_id_, mnames_getter, time_chunk_writer, value_chunk_writers))) { return ret; @@ -509,7 +509,7 @@ int TsFileWriter::write_tablet_aligned(const Tablet &tablet) { SimpleVector value_chunk_writers; TimeChunkWriter *time_chunk_writer = nullptr; MeasurementNamesFromTablet mnames_getter(tablet); - if (RET_FAIL(do_check_schema_aligned(tablet.device_name_, mnames_getter, + if (RET_FAIL(do_check_schema_aligned(tablet.device_id_, mnames_getter, time_chunk_writer, value_chunk_writers))) { return ret; @@ -529,8 +529,8 @@ int TsFileWriter::write_tablet(const Tablet &tablet) { int ret = E_OK; SimpleVector chunk_writers; MeasurementNamesFromTablet mnames_getter(tablet); - if (RET_FAIL(do_check_schema(tablet.device_name_, mnames_getter, - chunk_writers))) { + if (RET_FAIL( + do_check_schema(tablet.device_id_, mnames_getter, chunk_writers))) { return ret; } ASSERT(chunk_writers.size() == tablet.get_column_count()); @@ -543,7 +543,7 @@ int TsFileWriter::write_tablet(const Tablet &tablet) { write_column(chunk_writer, tablet, c); } - record_count_since_last_flush_ += tablet.max_rows_; + record_count_since_last_flush_ += tablet.max_row_num_; ret = check_memory_size_and_may_flush_chunks(); return ret; } @@ -556,7 +556,7 @@ int TsFileWriter::write_column(ChunkWriter *chunk_writer, const Tablet &tablet, int64_t *timestamps = tablet.timestamps_; void *col_values = tablet.value_matrix_[col_idx]; BitMap &col_notnull_bitmap = tablet.bitmaps_[col_idx]; - int32_t row_count = tablet.max_rows_; + int32_t row_count = tablet.max_row_num_; if (data_type == common::BOOLEAN) { ret = write_typed_column(chunk_writer, timestamps, (bool *)col_values, @@ -589,7 +589,7 @@ int TsFileWriter::value_write_column(ValueChunkWriter *value_chunk_writer, int64_t *timestamps = tablet.timestamps_; void *col_values = tablet.value_matrix_[col_idx]; BitMap &col_notnull_bitmap = tablet.bitmaps_[col_idx]; - int32_t row_count = tablet.max_rows_; + int32_t row_count = tablet.max_row_num_; if (data_type == common::BOOLEAN) { ret = write_typed_column(value_chunk_writer, timestamps, diff --git a/cpp/src/writer/tsfile_writer.h b/cpp/src/writer/tsfile_writer.h index 7b43b850f..d1b3b96b8 100644 --- a/cpp/src/writer/tsfile_writer.h +++ b/cpp/src/writer/tsfile_writer.h @@ -50,21 +50,17 @@ class TsFileWriter { void destroy(); int open(const std::string &file_path, int flags, mode_t mode); + int open(const std::string &file_path); int init(storage::WriteFile *write_file); - int register_timeseries(const std::string &device_path, - const std::string &measurement_name, - common::TSDataType data_type, - common::TSEncoding encoding, - common::CompressionType compression_type); - int register_aligned_timeseries(const std::string &device_path, - const std::string &measurement_name, - common::TSDataType data_type, - common::TSEncoding encoding, - common::CompressionType compression_type); + int register_timeseries(const std::string &device_id, + const MeasurementSchema &measurement_schema); int register_aligned_timeseries( - const std::string &device_path, - const std::vector &measurement_schema_vec); + const std::string &device_id, + const MeasurementSchema &measurement_schema); + int register_aligned_timeseries( + const std::string &device_id, + const std::vector &measurement_schemas); int write_record(const TsRecord &record); int write_tablet(const Tablet &tablet); int write_record_aligned(const TsRecord &record); @@ -130,11 +126,11 @@ class TsFileWriter { // std::vector &chunk_writers); int write_column(storage::ChunkWriter *chunk_writer, const Tablet &tablet, int col_idx); - int register_timeseries(const std::string &device_path, + int register_timeseries(const std::string &device_id, MeasurementSchema *measurement_schema, bool is_aligned = false); int register_timeseries( - const std::string &device_path, + const std::string &device_id, const std::vector &measurement_schema_vec); private: diff --git a/cpp/test/CMakeLists.txt b/cpp/test/CMakeLists.txt index f5c42572d..77e31d6c0 100644 --- a/cpp/test/CMakeLists.txt +++ b/cpp/test/CMakeLists.txt @@ -71,7 +71,9 @@ file(GLOB_RECURSE TEST_SRCS "encoding/*_test.cc" "utils/*_test.cc" "file/*_test.cc" + "parser/*_test.cc" "compress/*_test.cc" + "reader/*_test.cc" "writer/*_test.cc" ) if (${COV_ENABLED}) @@ -80,7 +82,7 @@ if (${COV_ENABLED}) endif () if(NOT WIN32) -# enable address sanitizer default +#enable address sanitizer default set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address -g") endif() diff --git a/cpp/test/common/allocator/byte_stream_test.cc b/cpp/test/common/allocator/byte_stream_test.cc index 573804c93..b7177d16a 100644 --- a/cpp/test/common/allocator/byte_stream_test.cc +++ b/cpp/test/common/allocator/byte_stream_test.cc @@ -208,7 +208,7 @@ class SerializationUtilTest : public ::testing::Test { TEST_F(SerializationUtilTest, WriteReadUI8) { uint8_t value_to_write = 0x12; - uint8_t value_read; + uint8_t value_read = 0; EXPECT_EQ(SerializationUtil::write_ui8(value_to_write, *byte_stream_), common::E_OK); @@ -219,7 +219,7 @@ TEST_F(SerializationUtilTest, WriteReadUI8) { TEST_F(SerializationUtilTest, WriteReadUI16) { uint16_t value_to_write = 0x1234; - uint16_t value_read; + uint16_t value_read = 0; EXPECT_EQ(SerializationUtil::write_ui16(value_to_write, *byte_stream_), common::E_OK); @@ -230,7 +230,7 @@ TEST_F(SerializationUtilTest, WriteReadUI16) { TEST_F(SerializationUtilTest, WriteReadUI32) { uint32_t value_to_write = 0x12345678; - uint32_t value_read; + uint32_t value_read = 0; EXPECT_EQ(SerializationUtil::write_ui32(value_to_write, *byte_stream_), common::E_OK); @@ -241,7 +241,7 @@ TEST_F(SerializationUtilTest, WriteReadUI32) { TEST_F(SerializationUtilTest, WriteReadUI64) { uint64_t value_to_write = 0x123456789ABCDEF0; - uint64_t value_read; + uint64_t value_read = 0; EXPECT_EQ(SerializationUtil::write_ui64(value_to_write, *byte_stream_), common::E_OK); @@ -252,7 +252,7 @@ TEST_F(SerializationUtilTest, WriteReadUI64) { TEST_F(SerializationUtilTest, WriteReadFloat) { float value_to_write = 3.14f; - float value_read; + float value_read = 0.0; EXPECT_EQ(SerializationUtil::write_float(value_to_write, *byte_stream_), common::E_OK); @@ -263,7 +263,7 @@ TEST_F(SerializationUtilTest, WriteReadFloat) { TEST_F(SerializationUtilTest, WriteReadDouble) { double value_to_write = 3.141592653589793; - double value_read; + double value_read = 0.0; EXPECT_EQ(SerializationUtil::write_double(value_to_write, *byte_stream_), common::E_OK); @@ -274,7 +274,7 @@ TEST_F(SerializationUtilTest, WriteReadDouble) { TEST_F(SerializationUtilTest, WriteReadString) { std::string value_to_write = "Hello, World!"; - std::string value_read; + std::string value_read = ""; EXPECT_EQ(SerializationUtil::write_str(value_to_write, *byte_stream_), common::E_OK); diff --git a/cpp/test/common/record_test.cc b/cpp/test/common/record_test.cc index 211b2235d..3a5c67bb6 100644 --- a/cpp/test/common/record_test.cc +++ b/cpp/test/common/record_test.cc @@ -90,21 +90,20 @@ TEST(DataPointTest, SetDouble) { TEST(TsRecordTest, ConstructorWithDeviceName) { TsRecord ts_record("device1"); - EXPECT_EQ(ts_record.device_name_, "device1"); + EXPECT_EQ(ts_record.device_id_, "device1"); EXPECT_EQ(ts_record.points_.size(), 0); } TEST(TsRecordTest, ConstructorWithTimestamp) { TsRecord ts_record(1625140800, "device1", 5); EXPECT_EQ(ts_record.timestamp_, 1625140800); - EXPECT_EQ(ts_record.device_name_, "device1"); + EXPECT_EQ(ts_record.device_id_, "device1"); EXPECT_EQ(ts_record.points_.capacity(), 5); } -TEST(TsRecordTest, AppendDataPoint) { +TEST(TsRecordTest, AddPoint) { TsRecord ts_record("device1"); - DataPoint dp("temperature", 36.6); - ts_record.append_data_point(dp); + ts_record.add_point("temperature", 36.6); ASSERT_EQ(ts_record.points_.size(), 1); EXPECT_EQ(ts_record.points_[0].measurement_name_, "temperature"); EXPECT_EQ(ts_record.points_[0].data_type_, common::DOUBLE); @@ -114,8 +113,7 @@ TEST(TsRecordTest, AppendDataPoint) { TEST(TsRecordTest, LargeQuantities) { TsRecord ts_record("device1"); for (int i = 0; i < 10000; i++) { - DataPoint dp(std::to_string(i), 36.6); - ts_record.append_data_point(dp); + ts_record.add_point(std::to_string(i), 36.6); } ASSERT_EQ(ts_record.points_.size(), 10000); diff --git a/cpp/test/common/tablet_test.cc b/cpp/test/common/tablet_test.cc index 0ebf4619e..bd795bcfe 100644 --- a/cpp/test/common/tablet_test.cc +++ b/cpp/test/common/tablet_test.cc @@ -34,17 +34,18 @@ TEST(TabletTest, BasicFunctionality) { schema_vec.push_back(MeasurementSchema( "measurement2", common::TSDataType::BOOLEAN, common::TSEncoding::RLE, common::CompressionType::SNAPPY)); - Tablet tablet(device_name, &schema_vec); + Tablet tablet(device_name, + std::make_shared>(schema_vec)); EXPECT_EQ(tablet.get_column_count(), schema_vec.size()); EXPECT_EQ(tablet.init(), common::E_OK); - EXPECT_EQ(tablet.set_value(0, "measurement1", true), common::E_OK); - EXPECT_EQ(tablet.set_value(0, "measurement2", false), common::E_OK); + EXPECT_EQ(tablet.add_value(0, "measurement1", true), common::E_OK); + EXPECT_EQ(tablet.add_value(0, "measurement2", false), common::E_OK); - EXPECT_EQ(tablet.set_value(1, 0, false), common::E_OK); - EXPECT_EQ(tablet.set_value(1, 1, true), common::E_OK); + EXPECT_EQ(tablet.add_value(1, 0, false), common::E_OK); + EXPECT_EQ(tablet.add_value(1, 1, true), common::E_OK); } TEST(TabletTest, LargeQuantities) { @@ -56,7 +57,8 @@ TEST(TabletTest, LargeQuantities) { "measurement" + std::to_string(i), common::TSDataType::BOOLEAN, common::TSEncoding::RLE, common::CompressionType::SNAPPY)); } - Tablet tablet(device_name, &schema_vec); + Tablet tablet(device_name, + std::make_shared>(schema_vec)); EXPECT_EQ(tablet.get_column_count(), schema_vec.size()); } diff --git a/cpp/test/common/tsblock/vector/variable_length_vector_test.cc b/cpp/test/common/tsblock/vector/variable_length_vector_test.cc index c61321667..bea3fd6f7 100644 --- a/cpp/test/common/tsblock/vector/variable_length_vector_test.cc +++ b/cpp/test/common/tsblock/vector/variable_length_vector_test.cc @@ -50,8 +50,8 @@ TEST(VariableLengthVectorTest, AppendAndRead) { const char* value = "test"; vlv.append(value, type_size); - uint32_t len; - bool null; + uint32_t len = 0; + bool null = false; char* result = vlv.read(&len, &null, 0); EXPECT_EQ(len, type_size); EXPECT_FALSE(null); @@ -66,7 +66,7 @@ TEST(VariableLengthVectorTest, ReadWithLen) { const char* value = "test"; vlv.append(value, type_size); - uint32_t len; + uint32_t len = 0; char* result = vlv.read(&len); EXPECT_EQ(len, type_size); EXPECT_EQ(memcmp(result, value, type_size), 0); diff --git a/cpp/test/file/write_file_test.cc b/cpp/test/file/write_file_test.cc index 7a6c90476..e7ee54e0c 100644 --- a/cpp/test/file/write_file_test.cc +++ b/cpp/test/file/write_file_test.cc @@ -44,6 +44,10 @@ TEST_F(WriteFileTest, CreateFile) { remove(file_name.c_str()); } +#if defined(__GNUC__) && !defined(__clang__) + #pragma GCC push_options + #pragma GCC optimize ("O0") +#endif TEST_F(WriteFileTest, WriteToFile) { WriteFile write_file; std::string file_name = "test_file_write.dat"; @@ -68,6 +72,9 @@ TEST_F(WriteFileTest, WriteToFile) { remove(file_name.c_str()); } +#if defined(__GNUC__) && !defined(__clang__) + #pragma GCC pop_options +#endif TEST_F(WriteFileTest, SyncFile) { WriteFile write_file; diff --git a/cpp/test/parser/path_name_test.cc b/cpp/test/parser/path_name_test.cc new file mode 100644 index 000000000..933352202 --- /dev/null +++ b/cpp/test/parser/path_name_test.cc @@ -0,0 +1,175 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * License); you may not use this file except in compliance + * with the License. You may obtain a copy of the License a + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +#include + +#include "common/path.h" + +namespace storage { + +class PathNameTest : public ::testing::Test {}; + +TEST_F(PathNameTest, TestLegalPath) { + // empty path + Path a("", true); + EXPECT_EQ("", a.device_); + EXPECT_EQ("", a.measurement_); + + // empty device + Path b("s1", true); + EXPECT_EQ("s1", b.measurement_); + EXPECT_EQ("", b.device_); + + // normal node + Path c("root.sg.a", true); + EXPECT_EQ("root.sg", c.device_); + EXPECT_EQ("a", c.measurement_); + + // quoted node + Path d("root.sg.`a.b`", true); + EXPECT_EQ("root.sg", d.device_); + EXPECT_EQ("`a.b`", d.measurement_); + + Path e("root.sg.`a.``b`", true); + EXPECT_EQ("root.sg", e.device_); + EXPECT_EQ("`a.``b`", e.measurement_); + + Path f("root.`sg\"`.`a.``b`", true); + EXPECT_EQ("root.`sg\"`", f.device_); + EXPECT_EQ("`a.``b`", f.measurement_); + + Path g("root.sg.`a.b\\\\`", true); + EXPECT_EQ("root.sg", g.device_); + EXPECT_EQ("`a.b\\\\`", g.measurement_); + + // quoted node of digits + Path h("root.sg.`111`", true); + EXPECT_EQ("root.sg", h.device_); + EXPECT_EQ("`111`", h.measurement_); + + // quoted node of key word + Path i("root.sg.`select`", true); + EXPECT_EQ("root.sg", i.device_); + EXPECT_EQ("select", i.measurement_); + + // wildcard + Path j("root.sg.`a*b`", true); + EXPECT_EQ("root.sg", j.device_); + EXPECT_EQ("`a*b`", j.measurement_); + + Path k("root.sg.*", true); + EXPECT_EQ("root.sg", k.device_); + EXPECT_EQ("*", k.measurement_); + + Path l("root.sg.**", true); + EXPECT_EQ("root.sg", l.device_); + EXPECT_EQ("**", l.measurement_); + + // raw key word + Path m("root.sg.select", true); + EXPECT_EQ("root.sg", m.device_); + EXPECT_EQ("select", m.measurement_); + + Path n("root.sg.device", true); + EXPECT_EQ("root.sg", n.device_); + EXPECT_EQ("device", n.measurement_); + + Path o("root.sg.drop_trigger", true); + EXPECT_EQ("root.sg", o.device_); + EXPECT_EQ("drop_trigger", o.measurement_); + + Path p("root.sg.and", true); + EXPECT_EQ("root.sg", p.device_); + EXPECT_EQ("and", p.measurement_); + + p = Path("root.sg.or", true); + EXPECT_EQ("root.sg", p.device_); + EXPECT_EQ("or", p.measurement_); + + p = Path("root.sg.not", true); + EXPECT_EQ("root.sg", p.device_); + EXPECT_EQ("not", p.measurement_); + + p = Path("root.sg.null", true); + EXPECT_EQ("root.sg", p.device_); + EXPECT_EQ("null", p.measurement_); + + p = Path("root.sg.contains", true); + EXPECT_EQ("root.sg", p.device_); + EXPECT_EQ("contains", p.measurement_); + + p = Path("root.sg.`0000`", true); + EXPECT_EQ("root.sg", p.device_); + EXPECT_EQ("`0000`", p.measurement_); + + p = Path("root.sg.`0e38`", true); + EXPECT_EQ("root.sg", p.device_); + EXPECT_EQ("`0e38`", p.measurement_); + + p = Path("root.sg.`00.12`", true); + EXPECT_EQ("root.sg", p.device_); + EXPECT_EQ("`00.12`", p.measurement_); +} + +TEST_F(PathNameTest, TestIllegalPathName) { + EXPECT_THROW ({ + Path("root.sg`", true); + } , std::runtime_error); + + EXPECT_THROW ({ + Path("root.sg\na", true); + }, std::runtime_error); + + EXPECT_THROW ({ + Path("root.select`", true); + } , std::runtime_error); + + EXPECT_THROW ({ + // pure digits + Path("root.111", true); + } , std::runtime_error); + + EXPECT_THROW ({ + // single ` in quoted node + Path("root.`a``", true); + } , std::runtime_error); + + EXPECT_THROW ({ + // single ` in quoted node + Path("root.``a`", true); + } , std::runtime_error); + + EXPECT_THROW ({ + Path("root.a*%", true); + } , std::runtime_error); + + EXPECT_THROW ({ + Path("root.a*b", true); + } , std::runtime_error); + + EXPECT_THROW ({ + Path("root.0e38", true); + } , std::runtime_error); + + EXPECT_THROW ({ + Path("root.0000", true); + }, std::runtime_error); +} + + +} // namespace storage diff --git a/cpp/test/reader/tsfile_reader_test.cc b/cpp/test/reader/tsfile_reader_test.cc new file mode 100644 index 000000000..13ebe6947 --- /dev/null +++ b/cpp/test/reader/tsfile_reader_test.cc @@ -0,0 +1,228 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * License); you may not use this file except in compliance + * with the License. You may obtain a copy of the License a + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +#include "reader/tsfile_reader.h" + +#include + +#include +#include + +#include "common/path.h" +#include "common/record.h" +#include "common/schema.h" +#include "common/tablet.h" +#include "file/tsfile_io_writer.h" +#include "file/write_file.h" +#include "reader/qds_without_timegenerator.h" +#include "writer/tsfile_writer.h" + +using namespace storage; +using namespace common; + +class TsFileReaderTest : public ::testing::Test { + protected: + void SetUp() override { + tsfile_writer_ = new TsFileWriter(); + libtsfile_init(); + file_name_ = std::string("tsfile_writer_test_") + + generate_random_string(10) + std::string(".tsfile"); + remove(file_name_.c_str()); + int flags = O_WRONLY | O_CREAT | O_TRUNC; +#ifdef _WIN32 + flags |= O_BINARY; +#endif + mode_t mode = 0666; + EXPECT_EQ(tsfile_writer_->open(file_name_, flags, mode), common::E_OK); + } + void TearDown() override { + delete tsfile_writer_; + remove(file_name_.c_str()); + } + + std::string file_name_; + TsFileWriter *tsfile_writer_ = nullptr; + + public: + static std::string generate_random_string(int length) { + std::random_device rd; + std::mt19937 gen(rd()); + std::uniform_int_distribution<> dis(0, 61); + + const std::string chars = + "0123456789" + "abcdefghijklmnopqrstuvwxyz" + "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; + + std::string random_string; + + for (int i = 0; i < length; ++i) { + random_string += chars[dis(gen)]; + } + + return random_string; + } + + static std::string field_to_string(storage::Field *value) { + if (value->type_ == common::TEXT) { + return std::string(value->value_.sval_); + } else { + std::stringstream ss; + switch (value->type_) { + case common::BOOLEAN: + ss << (value->value_.bval_ ? "true" : "false"); + break; + case common::INT32: + ss << value->value_.ival_; + break; + case common::INT64: + ss << value->value_.lval_; + break; + case common::FLOAT: + ss << value->value_.fval_; + break; + case common::DOUBLE: + ss << value->value_.dval_; + break; + case common::NULL_TYPE: + ss << "NULL"; + break; + default: + ASSERT(false); + break; + } + return ss.str(); + } + } +}; + +TEST_F(TsFileReaderTest, ResultSetMetadata) { + std::string device_path = "device1"; + std::string measurement_name = "temperature"; + common::TSDataType data_type = common::TSDataType::INT32; + common::TSEncoding encoding = common::TSEncoding::PLAIN; + common::CompressionType compression_type = + common::CompressionType::UNCOMPRESSED; + tsfile_writer_->register_timeseries( + device_path, storage::MeasurementSchema(measurement_name, data_type, + encoding, compression_type)); + + for (int i = 0; i < 50000; ++i) { + TsRecord record(1622505600000 + i * 1000, device_path); + record.add_point(measurement_name, (int32_t)i); + ASSERT_EQ(tsfile_writer_->write_record(record), E_OK); + ASSERT_EQ(tsfile_writer_->flush(), E_OK); + } + ASSERT_EQ(tsfile_writer_->close(), E_OK); + + std::vector select_list = {"device1.temperature"}; + + storage::TsFileReader reader; + int ret = reader.open(file_name_); + ASSERT_EQ(ret, common::E_OK); + storage::ResultSet *tmp_qds = nullptr; + + ret = reader.query(select_list, 1622505600000, 1622505600000 + 50000 * 1000, + tmp_qds); + auto *qds = (QDSWithoutTimeGenerator *)tmp_qds; + + ResultSetMetadata *result_set_metadaa = qds->get_metadata(); + ASSERT_EQ(result_set_metadaa->get_column_type(0), data_type); + ASSERT_EQ(result_set_metadaa->get_column_name(0), + device_path + "." + measurement_name); + reader.destroy_query_data_set(qds); + reader.close(); +} + +TEST_F(TsFileReaderTest, GetAllDevice) { + std::string measurement_name = "temperature"; + common::TSDataType data_type = common::TSDataType::INT32; + common::TSEncoding encoding = common::TSEncoding::PLAIN; + common::CompressionType compression_type = + common::CompressionType::UNCOMPRESSED; + + for (size_t i = 0; i < 1024; i++) { + tsfile_writer_->register_timeseries( + "device.ln" + to_string(i), + storage::MeasurementSchema(measurement_name, data_type, encoding, + compression_type)); + } + + for (size_t i = 0; i < 1024; i++) { + TsRecord record(1622505600000, "device.ln" + to_string(i)); + record.add_point(measurement_name, (int32_t)0); + ASSERT_EQ(tsfile_writer_->write_record(record), E_OK); + } + ASSERT_EQ(tsfile_writer_->flush(), E_OK); + ASSERT_EQ(tsfile_writer_->close(), E_OK); + + storage::TsFileReader reader; + int ret = reader.open(file_name_); + ASSERT_EQ(ret, common::E_OK); + std::vector devices = reader.get_all_devices(); + ASSERT_EQ(devices.size(), 1024); + std::vector devices_name_expected; + for (size_t i = 0; i < 1024; i++) { + devices_name_expected.push_back("device.ln" + std::to_string(i)); + } + std::sort(devices_name_expected.begin(), devices_name_expected.end(), [](const std::string& left_str, const std::string& right_str) { + return left_str < right_str; + }); + + for (size_t i = 0; i < devices.size(); i++) { + ASSERT_EQ(devices[i], devices_name_expected[i]); + } +} + +TEST_F(TsFileReaderTest, GetTimeseriesSchema) { + std::vector device_path = {"device", "device.ln"}; + std::vector measurement_name = {"temperature", "humidity"}; + common::TSDataType data_type = common::TSDataType::INT32; + common::TSEncoding encoding = common::TSEncoding::PLAIN; + common::CompressionType compression_type = + common::CompressionType::UNCOMPRESSED; + tsfile_writer_->register_timeseries( + device_path[0], + storage::MeasurementSchema(measurement_name[0], data_type, encoding, + compression_type)); + tsfile_writer_->register_timeseries( + device_path[1], + storage::MeasurementSchema(measurement_name[1], data_type, encoding, + compression_type)); + TsRecord record_0(1622505600000, device_path[0]); + record_0.add_point(measurement_name[0], (int32_t)0); + TsRecord record_1(1622505600000, device_path[1]); + record_1.add_point(measurement_name[1], (int32_t)1); + ASSERT_EQ(tsfile_writer_->write_record(record_0), E_OK); + ASSERT_EQ(tsfile_writer_->write_record(record_1), E_OK); + ASSERT_EQ(tsfile_writer_->flush(), E_OK); + ASSERT_EQ(tsfile_writer_->close(), E_OK); + + storage::TsFileReader reader; + int ret = reader.open(file_name_); + ASSERT_EQ(ret, common::E_OK); + std::vector measurement_schemas; + reader.get_timeseries_schema(device_path[0], measurement_schemas); + ASSERT_EQ(measurement_schemas[0].measurement_name_, measurement_name[0]); + ASSERT_EQ(measurement_schemas[0].data_type_, TSDataType::INT32); + + reader.get_timeseries_schema(device_path[1], measurement_schemas); + ASSERT_EQ(measurement_schemas[1].measurement_name_, measurement_name[1]); + ASSERT_EQ(measurement_schemas[1].data_type_, TSDataType::INT32); + reader.close(); +} \ No newline at end of file diff --git a/cpp/test/writer/tsfile_writer_test.cc b/cpp/test/writer/tsfile_writer_test.cc index 6b6011265..9d51078f5 100644 --- a/cpp/test/writer/tsfile_writer_test.cc +++ b/cpp/test/writer/tsfile_writer_test.cc @@ -127,9 +127,10 @@ TEST_F(TsFileWriterTest, WriteDiffDataType) { for (uint32_t i = 0; i < measurement_names.size(); i++) { std::string measurement_name = measurement_names[i]; common::TSDataType data_type = data_types[i]; - tsfile_writer_->register_timeseries(device_name, measurement_name, - data_type, encoding, - compression_type); + tsfile_writer_->register_timeseries( + device_name, + storage::MeasurementSchema(measurement_name, data_type, encoding, + compression_type)); } int row_num = 1000; @@ -140,19 +141,16 @@ TEST_F(TsFileWriterTest, WriteDiffDataType) { common::TSDataType data_type = data_types[j]; switch (data_type) { case BOOLEAN: - record.append_data_point(DataPoint(measurement_name, true)); + record.add_point(measurement_name, true); break; case INT64: - record.append_data_point( - DataPoint(measurement_name, (int64_t)415412)); + record.add_point(measurement_name, (int64_t)415412); break; case FLOAT: - record.append_data_point( - DataPoint(measurement_name, (float)1.0)); + record.add_point(measurement_name, (float)1.0); break; case DOUBLE: - record.append_data_point( - DataPoint(measurement_name, (double)2.0)); + record.add_point(measurement_name, (double)2.0); break; default: break; @@ -163,35 +161,43 @@ TEST_F(TsFileWriterTest, WriteDiffDataType) { ASSERT_EQ(tsfile_writer_->flush(), E_OK); ASSERT_EQ(tsfile_writer_->close(), E_OK); - std::vector select_list; + std::vector select_list; + select_list.reserve(measurement_names.size()); for (uint32_t i = 0; i < measurement_names.size(); ++i) { std::string measurement_name = measurement_names[i]; - storage::Path path(device_name, measurement_name); - select_list.push_back(path); + std::string path_name = device_name + "." + measurement_name; + select_list.emplace_back(path_name); } - storage::QueryExpression *query_expr = - storage::QueryExpression::create(select_list, nullptr); storage::TsFileReader reader; int ret = reader.open(file_name_); ASSERT_EQ(ret, common::E_OK); - storage::QueryDataSet *tmp_qds = nullptr; + storage::ResultSet *tmp_qds = nullptr; - ret = reader.query(query_expr, tmp_qds); + ret = reader.query(select_list, 1622505600000, + 1622505600000 + row_num * 100, tmp_qds); auto *qds = (QDSWithoutTimeGenerator *)tmp_qds; - storage::RowRecord *record; int64_t cur_record_num = 0; do { - record = qds->get_next(); - if (!record) { + if (!qds->next()) { break; } cur_record_num++; + ASSERT_EQ(qds->get_value(0), (float)1.0); + ASSERT_EQ(qds->get_value(1), (int64_t)415412); + ASSERT_EQ(qds->get_value(2), true); + ASSERT_EQ(qds->get_value(3), (double)2.0); + + ASSERT_EQ(qds->get_value(measurement_names[0]), (float)1.0); + ASSERT_EQ(qds->get_value(measurement_names[1]), + (int64_t)415412); + ASSERT_EQ(qds->get_value(measurement_names[2]), true); + ASSERT_EQ(qds->get_value(measurement_names[3]), (double)2.0); } while (true); EXPECT_EQ(cur_record_num, row_num); - storage::QueryExpression::destory(query_expr); reader.destroy_query_data_set(qds); + reader.close(); } TEST_F(TsFileWriterTest, RegisterTimeSeries) { @@ -202,9 +208,10 @@ TEST_F(TsFileWriterTest, RegisterTimeSeries) { common::CompressionType compression_type = common::CompressionType::UNCOMPRESSED; - ASSERT_EQ(tsfile_writer_->register_timeseries(device_path, measurement_name, - data_type, encoding, - compression_type), + ASSERT_EQ(tsfile_writer_->register_timeseries( + device_path, + storage::MeasurementSchema(measurement_name, data_type, + encoding, compression_type)), E_OK); } @@ -215,13 +222,13 @@ TEST_F(TsFileWriterTest, WriteMultipleRecords) { common::TSEncoding encoding = common::TSEncoding::PLAIN; common::CompressionType compression_type = common::CompressionType::UNCOMPRESSED; - tsfile_writer_->register_timeseries(device_path, measurement_name, - data_type, encoding, compression_type); + tsfile_writer_->register_timeseries( + device_path, storage::MeasurementSchema(measurement_name, data_type, + encoding, compression_type)); for (int i = 0; i < 50000; ++i) { TsRecord record(1622505600000 + i * 1000, device_path); - DataPoint point(measurement_name, (int32_t)i); - record.append_data_point(point); + record.add_point(measurement_name, (int32_t)i); ASSERT_EQ(tsfile_writer_->write_record(record), E_OK); ASSERT_EQ(tsfile_writer_->flush(), E_OK); } @@ -243,20 +250,24 @@ TEST_F(TsFileWriterTest, WriteMultipleTabletsMultiFlush) { common::TSEncoding::PLAIN, common::CompressionType::UNCOMPRESSED); tsfile_writer_->register_timeseries( - device_name, measure_name, common::TSDataType::INT32, - common::TSEncoding::PLAIN, - common::CompressionType::UNCOMPRESSED); + device_name, storage::MeasurementSchema( + measure_name, common::TSDataType::INT32, + common::TSEncoding::PLAIN, + common::CompressionType::UNCOMPRESSED)); } } for (int tablet_num = 0; tablet_num < max_tablet_num; tablet_num++) { for (int i = 0; i < device_num; i++) { std::string device_name = "test_device" + std::to_string(i); - Tablet tablet(device_name, &schema_vecs[i], 1); + Tablet tablet(device_name, + std::make_shared>( + schema_vecs[i]), + 1); tablet.init(); for (int j = 0; j < measurement_num; j++) { - tablet.set_timestamp(0, 16225600000 + tablet_num * 100); - tablet.set_value(0, j, static_cast(tablet_num)); + tablet.add_timestamp(0, 16225600000 + tablet_num * 100); + tablet.add_value(0, j, static_cast(tablet_num)); } ASSERT_EQ(tsfile_writer_->write_tablet(tablet), E_OK); } @@ -279,7 +290,7 @@ TEST_F(TsFileWriterTest, WriteMultipleTabletsMultiFlush) { storage::TsFileReader reader; int ret = reader.open(file_name_); ASSERT_EQ(ret, common::E_OK); - storage::QueryDataSet *tmp_qds = nullptr; + storage::ResultSet *tmp_qds = nullptr; ret = reader.query(query_expr, tmp_qds); auto *qds = (QDSWithoutTimeGenerator *)tmp_qds; @@ -287,17 +298,16 @@ TEST_F(TsFileWriterTest, WriteMultipleTabletsMultiFlush) { storage::RowRecord *record; int max_rows = max_tablet_num * 1; for (int cur_row = 0; cur_row < max_rows; cur_row++) { - record = qds->get_next(); - if (!record) { + if (!qds->next()) { break; } + record = qds->get_row_record(); int size = record->get_fields()->size(); for (int i = 0; i < size; ++i) { EXPECT_EQ(std::to_string(cur_row), field_to_string(record->get_field(i))); } } - storage::QueryExpression::destory(query_expr); reader.destroy_query_data_set(qds); } @@ -315,23 +325,27 @@ TEST_F(TsFileWriterTest, WriteMultipleTabletsInt64) { common::TSEncoding::PLAIN, common::CompressionType::UNCOMPRESSED)); tsfile_writer_->register_timeseries( - device_name, measure_name, common::TSDataType::INT64, - common::TSEncoding::PLAIN, - common::CompressionType::UNCOMPRESSED); + device_name, storage::MeasurementSchema( + measure_name, common::TSDataType::INT64, + common::TSEncoding::PLAIN, + common::CompressionType::UNCOMPRESSED)); } } for (int i = 0; i < device_num; i++) { std::string device_name = "test_device" + std::to_string(i); int max_rows = 100; - Tablet tablet(device_name, &schema_vec[i], max_rows); + Tablet tablet( + device_name, + std::make_shared>(schema_vec[i]), + max_rows); tablet.init(); for (int j = 0; j < measurement_num; j++) { for (int row = 0; row < max_rows; row++) { - tablet.set_timestamp(row, 16225600 + row); + tablet.add_timestamp(row, 16225600 + row); } for (int row = 0; row < max_rows; row++) { - tablet.set_value(row, j, static_cast(row)); + tablet.add_value(row, j, static_cast(row)); } } ASSERT_EQ(tsfile_writer_->write_tablet(tablet), E_OK); @@ -355,23 +369,27 @@ TEST_F(TsFileWriterTest, WriteMultipleTabletsDouble) { common::TSEncoding::PLAIN, common::CompressionType::UNCOMPRESSED)); tsfile_writer_->register_timeseries( - device_name, measure_name, common::TSDataType::DOUBLE, - common::TSEncoding::PLAIN, - common::CompressionType::UNCOMPRESSED); + device_name, storage::MeasurementSchema( + measure_name, common::TSDataType::DOUBLE, + common::TSEncoding::PLAIN, + common::CompressionType::UNCOMPRESSED)); } } for (int i = 0; i < device_num; i++) { std::string device_name = "test_device" + std::to_string(i); int max_rows = 200; - Tablet tablet(device_name, &schema_vec[i], max_rows); + Tablet tablet( + device_name, + std::make_shared>(schema_vec[i]), + max_rows); tablet.init(); for (int j = 0; j < measurement_num; j++) { for (int row = 0; row < max_rows; row++) { - tablet.set_timestamp(row, 16225600 + row); + tablet.add_timestamp(row, 16225600 + row); } for (int row = 0; row < max_rows; row++) { - tablet.set_value(row, j, static_cast(row) + 1.0); + tablet.add_value(row, j, static_cast(row) + 1.0); } } ASSERT_EQ(tsfile_writer_->write_tablet(tablet), E_OK); @@ -397,22 +415,22 @@ TEST_F(TsFileWriterTest, FlushMultipleDevice) { common::TSEncoding::PLAIN, common::CompressionType::UNCOMPRESSED)); tsfile_writer_->register_timeseries( - device_name, measure_name, common::TSDataType::INT64, + device_name, MeasurementSchema(measure_name, common::TSDataType::INT64, common::TSEncoding::PLAIN, - common::CompressionType::UNCOMPRESSED); + common::CompressionType::UNCOMPRESSED)); } } for (int i = 0; i < device_num; i++) { std::string device_name = "test_device" + std::to_string(i); - Tablet tablet(device_name, &schema_vec[i], max_rows); + Tablet tablet(device_name, std::make_shared>(schema_vec[i]), max_rows); tablet.init(); for (int j = 0; j < measurement_num; j++) { for (int row = 0; row < max_rows; row++) { - tablet.set_timestamp(row, 16225600 + row); + tablet.add_timestamp(row, 16225600 + row); } for (int row = 0; row < max_rows; row++) { - tablet.set_value(row, j, static_cast(row)); + tablet.add_value(row, j, static_cast(row)); } } ASSERT_EQ(tsfile_writer_->write_tablet(tablet), E_OK); @@ -436,7 +454,7 @@ TEST_F(TsFileWriterTest, FlushMultipleDevice) { storage::TsFileReader reader; int ret = reader.open(file_name_); ASSERT_EQ(ret, common::E_OK); - storage::QueryDataSet *tmp_qds = nullptr; + storage::ResultSet *tmp_qds = nullptr; ret = reader.query(query_expr, tmp_qds); auto *qds = (QDSWithoutTimeGenerator *)tmp_qds; @@ -444,7 +462,10 @@ TEST_F(TsFileWriterTest, FlushMultipleDevice) { storage::RowRecord *record; int64_t cur_record_num = 0; do { - record = qds->get_next(); + if (!qds->next()) { + break; + } + record = qds->get_row_record(); // if empty chunk is writen, the timestamp should be NULL if (!record) { break; @@ -453,7 +474,6 @@ TEST_F(TsFileWriterTest, FlushMultipleDevice) { cur_record_num++; } while (true); EXPECT_EQ(cur_record_num, max_rows); - storage::QueryExpression::destory(query_expr); reader.destroy_query_data_set(qds); } @@ -472,22 +492,22 @@ TEST_F(TsFileWriterTest, AnalyzeTsfileForload) { common::TSEncoding::PLAIN, common::CompressionType::UNCOMPRESSED)); tsfile_writer_->register_timeseries( - device_name, measure_name, common::TSDataType::INT64, + device_name, MeasurementSchema(measure_name, common::TSDataType::INT64, common::TSEncoding::PLAIN, - common::CompressionType::UNCOMPRESSED); + common::CompressionType::UNCOMPRESSED)); } } for (int i = 0; i < device_num; i++) { std::string device_name = "test_device" + std::to_string(i); - Tablet tablet(device_name, &schema_vec[i], max_rows); + Tablet tablet(device_name, std::make_shared>(schema_vec[i]), max_rows); tablet.init(); for (int j = 0; j < measurement_num; j++) { for (int row = 0; row < max_rows; row++) { - tablet.set_timestamp(row, 16225600 + row); + tablet.add_timestamp(row, 16225600 + row); } for (int row = 0; row < max_rows; row++) { - tablet.set_value(row, j, static_cast(row)); + tablet.add_value(row, j, static_cast(row)); } } ASSERT_EQ(tsfile_writer_->write_tablet(tablet), E_OK); @@ -511,9 +531,10 @@ TEST_F(TsFileWriterTest, FlushWithoutWriteAfterRegisterTS) { common::CompressionType compression_type = common::CompressionType::UNCOMPRESSED; - ASSERT_EQ(tsfile_writer_->register_timeseries(device_path, measurement_name, - data_type, encoding, - compression_type), + ASSERT_EQ(tsfile_writer_->register_timeseries( + device_path, + storage::MeasurementSchema(measurement_name, data_type, + encoding, compression_type)), E_OK); ASSERT_EQ(tsfile_writer_->flush(), E_OK); ASSERT_EQ(tsfile_writer_->close(), E_OK); @@ -543,8 +564,7 @@ TEST_F(TsFileWriterTest, WriteAlignedTimeseries) { for (int i = 0; i < row_num; ++i) { TsRecord record(1622505600000 + i * 1000, device_name); for (const auto &measurement_name : measurement_names) { - DataPoint point(measurement_name, (int32_t)i); - record.append_data_point(point); + record.add_point(measurement_name, (int32_t)i); } ASSERT_EQ(tsfile_writer_->write_record_aligned(record), E_OK); } @@ -564,24 +584,23 @@ TEST_F(TsFileWriterTest, WriteAlignedTimeseries) { storage::TsFileReader reader; int ret = reader.open(file_name_); ASSERT_EQ(ret, common::E_OK); - storage::QueryDataSet *tmp_qds = nullptr; + storage::ResultSet *tmp_qds = nullptr; ret = reader.query(query_expr, tmp_qds); auto *qds = (QDSWithoutTimeGenerator *)tmp_qds; storage::RowRecord *record; for (int cur_row = 0; cur_row < row_num; cur_row++) { - record = qds->get_next(); - if (!record) { + if (!qds->next()) { break; } + record = qds->get_row_record(); int size = record->get_fields()->size(); for (int i = 0; i < size; ++i) { EXPECT_EQ(std::to_string(cur_row), field_to_string(record->get_field(i))); } } - storage::QueryExpression::destory(query_expr); reader.destroy_query_data_set(qds); } @@ -609,8 +628,7 @@ TEST_F(TsFileWriterTest, WriteAlignedMultiFlush) { for (int i = 0; i < row_num; ++i) { TsRecord record(1622505600000 + i * 1000, device_name); for (const auto &measurement_name : measurement_names) { - DataPoint point(measurement_name, (int32_t)i); - record.append_data_point(point); + record.add_point(measurement_name, (int32_t)i); } ASSERT_EQ(tsfile_writer_->write_record_aligned(record), E_OK); ASSERT_EQ(tsfile_writer_->flush(), E_OK); @@ -630,24 +648,23 @@ TEST_F(TsFileWriterTest, WriteAlignedMultiFlush) { storage::TsFileReader reader; int ret = reader.open(file_name_); ASSERT_EQ(ret, common::E_OK); - storage::QueryDataSet *tmp_qds = nullptr; + storage::ResultSet *tmp_qds = nullptr; ret = reader.query(query_expr, tmp_qds); auto *qds = (QDSWithoutTimeGenerator *)tmp_qds; storage::RowRecord *record; for (int cur_row = 0; cur_row < row_num; cur_row++) { - record = qds->get_next(); - if (!record) { + if (!qds->next()) { break; } + record = qds->get_row_record(); int size = record->get_fields()->size(); for (int i = 0; i < size; ++i) { EXPECT_EQ(std::to_string(cur_row), field_to_string(record->get_field(i))); } } - storage::QueryExpression::destory(query_expr); reader.destroy_query_data_set(qds); } @@ -675,11 +692,7 @@ TEST_F(TsFileWriterTest, WriteAlignedPartialData) { for (int i = 0; i < row_num; ++i) { TsRecord record(1622505600000 + i * 1000, device_name); for (const auto &measurement_name : measurement_names) { - DataPoint point(measurement_name, (int32_t)i); - if (i % 2 == 0) { - point.isnull = true; - } - record.append_data_point(point); + record.add_point(measurement_name, (int32_t)i); } ASSERT_EQ(tsfile_writer_->write_record_aligned(record), E_OK); } @@ -698,25 +711,24 @@ TEST_F(TsFileWriterTest, WriteAlignedPartialData) { storage::TsFileReader reader; int ret = reader.open(file_name_); ASSERT_EQ(ret, common::E_OK); - storage::QueryDataSet *tmp_qds = nullptr; + storage::ResultSet *tmp_qds = nullptr; ret = reader.query(query_expr, tmp_qds); auto *qds = (QDSWithoutTimeGenerator *)tmp_qds; storage::RowRecord *record; - int64_t cur_row = 1; + int64_t cur_row = 0; do { - record = qds->get_next(); - if (!record) { + if (!qds->next()) { break; } + record = qds->get_row_record(); int size = record->get_fields()->size(); for (int i = 0; i < size; ++i) { EXPECT_EQ(std::to_string(cur_row), field_to_string(record->get_field(i))); } - cur_row += 2; + cur_row++; } while (true); - storage::QueryExpression::destory(query_expr); reader.destroy_query_data_set(qds); } \ No newline at end of file diff --git a/cpp/third_party/CMakeLists.txt b/cpp/third_party/CMakeLists.txt index 1f4356861..e6c5ae489 100755 --- a/cpp/third_party/CMakeLists.txt +++ b/cpp/third_party/CMakeLists.txt @@ -16,6 +16,7 @@ KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ]] +add_subdirectory(antlr4-cpp-runtime-4) add_subdirectory(google_snappy) add_subdirectory(lz4) add_subdirectory(lzokay) diff --git a/cpp/third_party/antlr4-cpp-runtime-4/CMakeLists.txt b/cpp/third_party/antlr4-cpp-runtime-4/CMakeLists.txt new file mode 100644 index 000000000..9e293de75 --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/CMakeLists.txt @@ -0,0 +1,218 @@ +# -*- mode:cmake -*- +cmake_minimum_required (VERSION 3.10) +# 2.8 needed because of ExternalProject +# Detect build type, fallback to release and throw a warning if use didn't specify any +set(CMAKE_POSITION_INDEPENDENT_CODE ON) +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) + +# 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) +set(THIRD_PARTY_READY TRUE CACHE INTERNAL "Third-party libraries ready") diff --git a/cpp/third_party/antlr4-cpp-runtime-4/LICENSE.txt b/cpp/third_party/antlr4-cpp-runtime-4/LICENSE.txt new file mode 100644 index 000000000..2042d1bda --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/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/cpp/third_party/antlr4-cpp-runtime-4/README.md b/cpp/third_party/antlr4-cpp-runtime-4/README.md new file mode 100644 index 000000000..4caf612a1 --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/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/cpp/third_party/antlr4-cpp-runtime-4/VERSION b/cpp/third_party/antlr4-cpp-runtime-4/VERSION new file mode 100644 index 000000000..e69de29bb diff --git a/cpp/third_party/antlr4-cpp-runtime-4/cmake/Antlr4Package.md b/cpp/third_party/antlr4-cpp-runtime-4/cmake/Antlr4Package.md new file mode 100644 index 000000000..10e775285 --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/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/cpp/third_party/antlr4-cpp-runtime-4/cmake/ExternalAntlr4Cpp.cmake b/cpp/third_party/antlr4-cpp-runtime-4/cmake/ExternalAntlr4Cpp.cmake new file mode 100644 index 000000000..2acc610ef --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/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/cpp/third_party/antlr4-cpp-runtime-4/cmake/FindANTLR.cmake b/cpp/third_party/antlr4-cpp-runtime-4/cmake/FindANTLR.cmake new file mode 100644 index 000000000..2d204d7e9 --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/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/cpp/third_party/antlr4-cpp-runtime-4/cmake/README.md b/cpp/third_party/antlr4-cpp-runtime-4/cmake/README.md new file mode 100644 index 000000000..0ebe1dd51 --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/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/cpp/third_party/antlr4-cpp-runtime-4/cmake/antlr4-generator.cmake.in b/cpp/third_party/antlr4-cpp-runtime-4/cmake/antlr4-generator.cmake.in new file mode 100644 index 000000000..63996514b --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/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/cpp/third_party/antlr4-cpp-runtime-4/cmake/antlr4-runtime.cmake.in b/cpp/third_party/antlr4-cpp-runtime-4/cmake/antlr4-runtime.cmake.in new file mode 100644 index 000000000..860aeb601 --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/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/cpp/third_party/antlr4-cpp-runtime-4/demo/CMakeLists.txt b/cpp/third_party/antlr4-cpp-runtime-4/demo/CMakeLists.txt new file mode 100644 index 000000000..23b4c4060 --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/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/cpp/third_party/antlr4-cpp-runtime-4/demo/Linux/main.cpp b/cpp/third_party/antlr4-cpp-runtime-4/demo/Linux/main.cpp new file mode 100644 index 000000000..672ce2a3b --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/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/cpp/third_party/antlr4-cpp-runtime-4/demo/Mac/antlr4-cpp-demo/main.cpp b/cpp/third_party/antlr4-cpp-runtime-4/demo/Mac/antlr4-cpp-demo/main.cpp new file mode 100644 index 000000000..8420ae17c --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/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/cpp/third_party/antlr4-cpp-runtime-4/demo/Mac/antlrcpp Tests/Info.plist b/cpp/third_party/antlr4-cpp-runtime-4/demo/Mac/antlrcpp Tests/Info.plist new file mode 100644 index 000000000..ba72822e8 --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/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/cpp/third_party/antlr4-cpp-runtime-4/demo/Mac/antlrcpp Tests/InputHandlingTests.mm b/cpp/third_party/antlr4-cpp-runtime-4/demo/Mac/antlrcpp Tests/InputHandlingTests.mm new file mode 100644 index 000000000..647f73fed --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/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/cpp/third_party/antlr4-cpp-runtime-4/demo/Mac/antlrcpp Tests/MiscClassTests.mm b/cpp/third_party/antlr4-cpp-runtime-4/demo/Mac/antlrcpp Tests/MiscClassTests.mm new file mode 100644 index 000000000..58cac4be4 --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/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/cpp/third_party/antlr4-cpp-runtime-4/demo/Mac/antlrcpp Tests/antlrcpp_Tests.mm b/cpp/third_party/antlr4-cpp-runtime-4/demo/Mac/antlrcpp Tests/antlrcpp_Tests.mm new file mode 100644 index 000000000..b4c52406e --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/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/cpp/third_party/antlr4-cpp-runtime-4/demo/Mac/antlrcpp-demo.xcodeproj/project.pbxproj b/cpp/third_party/antlr4-cpp-runtime-4/demo/Mac/antlrcpp-demo.xcodeproj/project.pbxproj new file mode 100644 index 000000000..5f136b03e --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/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/cpp/third_party/antlr4-cpp-runtime-4/demo/Mac/antlrcpp-demo.xcodeproj/project.xcworkspace/contents.xcworkspacedata b/cpp/third_party/antlr4-cpp-runtime-4/demo/Mac/antlrcpp-demo.xcodeproj/project.xcworkspace/contents.xcworkspacedata new file mode 100644 index 000000000..919434a62 --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/demo/Mac/antlrcpp-demo.xcodeproj/project.xcworkspace/contents.xcworkspacedata @@ -0,0 +1,7 @@ + + + + + diff --git a/cpp/third_party/antlr4-cpp-runtime-4/demo/Mac/antlrcpp-demo.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist b/cpp/third_party/antlr4-cpp-runtime-4/demo/Mac/antlrcpp-demo.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist new file mode 100644 index 000000000..18d981003 --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/demo/Mac/antlrcpp-demo.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist @@ -0,0 +1,8 @@ + + + + + IDEDidComputeMac32BitWarning + + + diff --git a/cpp/third_party/antlr4-cpp-runtime-4/demo/Mac/antlrcpp-demo.xcodeproj/xcshareddata/xcschemes/antlr4-cpp-demo.xcscheme b/cpp/third_party/antlr4-cpp-runtime-4/demo/Mac/antlrcpp-demo.xcodeproj/xcshareddata/xcschemes/antlr4-cpp-demo.xcscheme new file mode 100644 index 000000000..8e3cfa5d8 --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/demo/Mac/antlrcpp-demo.xcodeproj/xcshareddata/xcschemes/antlr4-cpp-demo.xcscheme @@ -0,0 +1,102 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/cpp/third_party/antlr4-cpp-runtime-4/demo/Mac/antlrcpp-demo.xcodeproj/xcshareddata/xcschemes/antlrcpp Tests.xcscheme b/cpp/third_party/antlr4-cpp-runtime-4/demo/Mac/antlrcpp-demo.xcodeproj/xcshareddata/xcschemes/antlrcpp Tests.xcscheme new file mode 100644 index 000000000..8edff6632 --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/demo/Mac/antlrcpp-demo.xcodeproj/xcshareddata/xcschemes/antlrcpp Tests.xcscheme @@ -0,0 +1,56 @@ + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/cpp/third_party/antlr4-cpp-runtime-4/demo/Mac/build.sh b/cpp/third_party/antlr4-cpp-runtime-4/demo/Mac/build.sh new file mode 100755 index 000000000..ff991f45c --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/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/cpp/third_party/antlr4-cpp-runtime-4/demo/README.md b/cpp/third_party/antlr4-cpp-runtime-4/demo/README.md new file mode 100644 index 000000000..73f03a4a9 --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/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/cpp/third_party/antlr4-cpp-runtime-4/demo/TLexer.g4 b/cpp/third_party/antlr4-cpp-runtime-4/demo/TLexer.g4 new file mode 100644 index 000000000..ac2128c8d --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/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/cpp/third_party/antlr4-cpp-runtime-4/demo/TParser.g4 b/cpp/third_party/antlr4-cpp-runtime-4/demo/TParser.g4 new file mode 100644 index 000000000..9f25be93d --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/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/cpp/third_party/antlr4-cpp-runtime-4/demo/Windows/antlr4-cpp-demo/antlr4-cpp-demo-vs2015.vcxproj b/cpp/third_party/antlr4-cpp-runtime-4/demo/Windows/antlr4-cpp-demo/antlr4-cpp-demo-vs2015.vcxproj new file mode 100644 index 000000000..f004fb06c --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/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/cpp/third_party/antlr4-cpp-runtime-4/demo/Windows/antlr4-cpp-demo/antlr4-cpp-demo-vs2015.vcxproj.filters b/cpp/third_party/antlr4-cpp-runtime-4/demo/Windows/antlr4-cpp-demo/antlr4-cpp-demo-vs2015.vcxproj.filters new file mode 100644 index 000000000..ed5618412 --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/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/cpp/third_party/antlr4-cpp-runtime-4/demo/Windows/antlr4-cpp-demo/antlr4-cpp-demo.vcxproj b/cpp/third_party/antlr4-cpp-runtime-4/demo/Windows/antlr4-cpp-demo/antlr4-cpp-demo.vcxproj new file mode 100644 index 000000000..ec6240de0 --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/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/cpp/third_party/antlr4-cpp-runtime-4/demo/Windows/antlr4-cpp-demo/antlr4-cpp-demo.vcxproj.filters b/cpp/third_party/antlr4-cpp-runtime-4/demo/Windows/antlr4-cpp-demo/antlr4-cpp-demo.vcxproj.filters new file mode 100644 index 000000000..ed5618412 --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/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/cpp/third_party/antlr4-cpp-runtime-4/demo/Windows/antlr4-cpp-demo/main.cpp b/cpp/third_party/antlr4-cpp-runtime-4/demo/Windows/antlr4-cpp-demo/main.cpp new file mode 100644 index 000000000..fa470e5ed --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/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/cpp/third_party/antlr4-cpp-runtime-4/demo/Windows/antlr4cpp-vs2013.sln b/cpp/third_party/antlr4-cpp-runtime-4/demo/Windows/antlr4cpp-vs2013.sln new file mode 100644 index 000000000..931aeb3eb --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/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/cpp/third_party/antlr4-cpp-runtime-4/demo/Windows/antlr4cpp-vs2015.sln b/cpp/third_party/antlr4-cpp-runtime-4/demo/Windows/antlr4cpp-vs2015.sln new file mode 100644 index 000000000..6bf253d08 --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/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/cpp/third_party/antlr4-cpp-runtime-4/demo/generate.cmd b/cpp/third_party/antlr4-cpp-runtime-4/demo/generate.cmd new file mode 100644 index 000000000..5d74466a9 --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/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/cpp/third_party/antlr4-cpp-runtime-4/demo/generate.sh b/cpp/third_party/antlr4-cpp-runtime-4/demo/generate.sh new file mode 100755 index 000000000..2fb8b1317 --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/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/cpp/third_party/antlr4-cpp-runtime-4/deploy-macos.sh b/cpp/third_party/antlr4-cpp-runtime-4/deploy-macos.sh new file mode 100755 index 000000000..cf977652d --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/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/cpp/third_party/antlr4-cpp-runtime-4/deploy-source.sh b/cpp/third_party/antlr4-cpp-runtime-4/deploy-source.sh new file mode 100755 index 000000000..d079821aa --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/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/cpp/third_party/antlr4-cpp-runtime-4/deploy-windows.cmd b/cpp/third_party/antlr4-cpp-runtime-4/deploy-windows.cmd new file mode 100644 index 000000000..8fc22ab5b --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/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/cpp/third_party/antlr4-cpp-runtime-4/runtime/CMakeLists.txt b/cpp/third_party/antlr4-cpp-runtime-4/runtime/CMakeLists.txt new file mode 100644 index 000000000..a143befb0 --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/runtime/CMakeLists.txt @@ -0,0 +1,165 @@ +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_definitions(-DANTLR4CPP_STATIC) +set(ANTLR4_WITH_STATIC_CRT OFF) +add_library(antlr4_shared SHARED ${libantlrcpp_SRC}) +add_library(antlr4_static STATIC ${libantlrcpp_SRC}) +set(LIB_OUTPUT_DIR ${CMAKE_BINARY_DIR}/lib) # 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() \ No newline at end of file diff --git a/cpp/third_party/antlr4-cpp-runtime-4/runtime/antlr4cpp-vs2013.vcxproj b/cpp/third_party/antlr4-cpp-runtime-4/runtime/antlr4cpp-vs2013.vcxproj new file mode 100644 index 000000000..47377c18a --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/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/cpp/third_party/antlr4-cpp-runtime-4/runtime/antlr4cpp-vs2013.vcxproj.filters b/cpp/third_party/antlr4-cpp-runtime-4/runtime/antlr4cpp-vs2013.vcxproj.filters new file mode 100644 index 000000000..499a82ed4 --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/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/cpp/third_party/antlr4-cpp-runtime-4/runtime/antlr4cpp-vs2015.vcxproj b/cpp/third_party/antlr4-cpp-runtime-4/runtime/antlr4cpp-vs2015.vcxproj new file mode 100644 index 000000000..9085761e8 --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/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/cpp/third_party/antlr4-cpp-runtime-4/runtime/antlr4cpp-vs2015.vcxproj.filters b/cpp/third_party/antlr4-cpp-runtime-4/runtime/antlr4cpp-vs2015.vcxproj.filters new file mode 100644 index 000000000..cc1986923 --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/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/cpp/third_party/antlr4-cpp-runtime-4/runtime/antlr4cpp-vs2017.vcxproj b/cpp/third_party/antlr4-cpp-runtime-4/runtime/antlr4cpp-vs2017.vcxproj new file mode 100644 index 000000000..2c3611c86 --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/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/cpp/third_party/antlr4-cpp-runtime-4/runtime/antlr4cpp-vs2017.vcxproj.filters b/cpp/third_party/antlr4-cpp-runtime-4/runtime/antlr4cpp-vs2017.vcxproj.filters new file mode 100644 index 000000000..cc1986923 --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/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/cpp/third_party/antlr4-cpp-runtime-4/runtime/antlr4cpp-vs2019.vcxproj b/cpp/third_party/antlr4-cpp-runtime-4/runtime/antlr4cpp-vs2019.vcxproj new file mode 100644 index 000000000..54f0aeb14 --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/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/cpp/third_party/antlr4-cpp-runtime-4/runtime/antlr4cpp-vs2019.vcxproj.filters b/cpp/third_party/antlr4-cpp-runtime-4/runtime/antlr4cpp-vs2019.vcxproj.filters new file mode 100644 index 000000000..cc1986923 --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/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/cpp/third_party/antlr4-cpp-runtime-4/runtime/antlrcpp-ios/Info.plist b/cpp/third_party/antlr4-cpp-runtime-4/runtime/antlrcpp-ios/Info.plist new file mode 100644 index 000000000..d3de8eefb --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/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/cpp/third_party/antlr4-cpp-runtime-4/runtime/antlrcpp-ios/antlrcpp_ios.h b/cpp/third_party/antlr4-cpp-runtime-4/runtime/antlrcpp-ios/antlrcpp_ios.h new file mode 100644 index 000000000..bd6b3d424 --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/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/cpp/third_party/antlr4-cpp-runtime-4/runtime/antlrcpp.xcodeproj/project.pbxproj b/cpp/third_party/antlr4-cpp-runtime-4/runtime/antlrcpp.xcodeproj/project.pbxproj new file mode 100644 index 000000000..17ab19848 --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/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/cpp/third_party/antlr4-cpp-runtime-4/runtime/antlrcpp.xcodeproj/project.xcworkspace/contents.xcworkspacedata b/cpp/third_party/antlr4-cpp-runtime-4/runtime/antlrcpp.xcodeproj/project.xcworkspace/contents.xcworkspacedata new file mode 100644 index 000000000..919434a62 --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/runtime/antlrcpp.xcodeproj/project.xcworkspace/contents.xcworkspacedata @@ -0,0 +1,7 @@ + + + + + diff --git a/cpp/third_party/antlr4-cpp-runtime-4/runtime/antlrcpp.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist b/cpp/third_party/antlr4-cpp-runtime-4/runtime/antlrcpp.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist new file mode 100644 index 000000000..18d981003 --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/runtime/antlrcpp.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist @@ -0,0 +1,8 @@ + + + + + IDEDidComputeMac32BitWarning + + + diff --git a/cpp/third_party/antlr4-cpp-runtime-4/runtime/antlrcpp.xcodeproj/xcshareddata/xcschemes/antlr4.xcscheme b/cpp/third_party/antlr4-cpp-runtime-4/runtime/antlrcpp.xcodeproj/xcshareddata/xcschemes/antlr4.xcscheme new file mode 100644 index 000000000..701bbf383 --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/runtime/antlrcpp.xcodeproj/xcshareddata/xcschemes/antlr4.xcscheme @@ -0,0 +1,76 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/cpp/third_party/antlr4-cpp-runtime-4/runtime/antlrcpp.xcodeproj/xcshareddata/xcschemes/antlr4_ios.xcscheme b/cpp/third_party/antlr4-cpp-runtime-4/runtime/antlrcpp.xcodeproj/xcshareddata/xcschemes/antlr4_ios.xcscheme new file mode 100644 index 000000000..b62a43946 --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/runtime/antlrcpp.xcodeproj/xcshareddata/xcschemes/antlr4_ios.xcscheme @@ -0,0 +1,76 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/cpp/third_party/antlr4-cpp-runtime-4/runtime/antlrcpp.xcodeproj/xcshareddata/xcschemes/antlr4_static.xcscheme b/cpp/third_party/antlr4-cpp-runtime-4/runtime/antlrcpp.xcodeproj/xcshareddata/xcschemes/antlr4_static.xcscheme new file mode 100644 index 000000000..c3f426417 --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/runtime/antlrcpp.xcodeproj/xcshareddata/xcschemes/antlr4_static.xcscheme @@ -0,0 +1,76 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/cpp/third_party/antlr4-cpp-runtime-4/runtime/src/ANTLRErrorListener.cpp b/cpp/third_party/antlr4-cpp-runtime-4/runtime/src/ANTLRErrorListener.cpp new file mode 100644 index 000000000..6ceadb87f --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/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/cpp/third_party/antlr4-cpp-runtime-4/runtime/src/ANTLRErrorListener.h b/cpp/third_party/antlr4-cpp-runtime-4/runtime/src/ANTLRErrorListener.h new file mode 100755 index 000000000..d6efad1d9 --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/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/cpp/third_party/antlr4-cpp-runtime-4/runtime/src/ANTLRErrorStrategy.cpp b/cpp/third_party/antlr4-cpp-runtime-4/runtime/src/ANTLRErrorStrategy.cpp new file mode 100644 index 000000000..1655a5731 --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/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/cpp/third_party/antlr4-cpp-runtime-4/runtime/src/ANTLRErrorStrategy.h b/cpp/third_party/antlr4-cpp-runtime-4/runtime/src/ANTLRErrorStrategy.h new file mode 100755 index 000000000..a3eecd14c --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/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/cpp/third_party/antlr4-cpp-runtime-4/runtime/src/ANTLRFileStream.cpp b/cpp/third_party/antlr4-cpp-runtime-4/runtime/src/ANTLRFileStream.cpp new file mode 100755 index 000000000..62061bb83 --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/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/cpp/third_party/antlr4-cpp-runtime-4/runtime/src/ANTLRFileStream.h b/cpp/third_party/antlr4-cpp-runtime-4/runtime/src/ANTLRFileStream.h new file mode 100755 index 000000000..6c7d619a0 --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/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/cpp/third_party/antlr4-cpp-runtime-4/runtime/src/ANTLRInputStream.cpp b/cpp/third_party/antlr4-cpp-runtime-4/runtime/src/ANTLRInputStream.cpp new file mode 100755 index 000000000..2dded4091 --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/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/cpp/third_party/antlr4-cpp-runtime-4/runtime/src/ANTLRInputStream.h b/cpp/third_party/antlr4-cpp-runtime-4/runtime/src/ANTLRInputStream.h new file mode 100755 index 000000000..fdf857e3e --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/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/cpp/third_party/antlr4-cpp-runtime-4/runtime/src/BailErrorStrategy.cpp b/cpp/third_party/antlr4-cpp-runtime-4/runtime/src/BailErrorStrategy.cpp new file mode 100755 index 000000000..5fbc01161 --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/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/cpp/third_party/antlr4-cpp-runtime-4/runtime/src/BailErrorStrategy.h b/cpp/third_party/antlr4-cpp-runtime-4/runtime/src/BailErrorStrategy.h new file mode 100755 index 000000000..2a8c36f9e --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/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/cpp/third_party/antlr4-cpp-runtime-4/runtime/src/BaseErrorListener.cpp b/cpp/third_party/antlr4-cpp-runtime-4/runtime/src/BaseErrorListener.cpp new file mode 100755 index 000000000..c035f09f0 --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/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/cpp/third_party/antlr4-cpp-runtime-4/runtime/src/BaseErrorListener.h b/cpp/third_party/antlr4-cpp-runtime-4/runtime/src/BaseErrorListener.h new file mode 100755 index 000000000..aad2e5d75 --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/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/cpp/third_party/antlr4-cpp-runtime-4/runtime/src/BufferedTokenStream.cpp b/cpp/third_party/antlr4-cpp-runtime-4/runtime/src/BufferedTokenStream.cpp new file mode 100755 index 000000000..241dfe5c4 --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/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/cpp/third_party/antlr4-cpp-runtime-4/runtime/src/BufferedTokenStream.h b/cpp/third_party/antlr4-cpp-runtime-4/runtime/src/BufferedTokenStream.h new file mode 100755 index 000000000..fab74d24c --- /dev/null +++ b/cpp/third_party/antlr4-cpp-runtime-4/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: + * + *