diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index fb53bfb98b8acc6ea96465e6171f9e4892326bf6..7c7b798a9cd8c1e677a1e826fa84addaa990c2ad 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -33,15 +33,9 @@ jobs: cd build cmake .. make - # tests: - # runs-on: ubuntu-latest - # container: raiden454/cpp-app - # needs: [build] - # steps: - # - uses: actions/checkout@v3 - # - name: Run-Tests - # run: | - # find / -name "test_service" + - name: Run-Tests + run: | + ./build/server/internal/service/tests/test_service linters: runs-on: ubuntu-latest container: raiden454/cpp-app @@ -52,4 +46,4 @@ jobs: cppcheck server --std=c++17 --enable=all - name: Cpplint run: | - cpplint --extensions=cpp,hpp,h --recursive ./server/* + cpplint --extensions=cpp,hpp,h --recursive ./server/* \ No newline at end of file diff --git a/CMakeLists.txt b/CMakeLists.txt index 5054100d4d9df7e09087c90a11fdac68ac7ce761..1047f935afa08da31555f8f3ece3d0eb5096b82b 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,15 +1,40 @@ -set(CMAKE_CXX_STANDARD 17) +set(CMAKE_CXX_STANDARD 20) cmake_minimum_required(VERSION 3.16) -set(CMAKE_PREFIX_PATH build) -project(SourcedOut CXX) -# find_package(antlr4-runtime REQUIRED) -find_package(Boost 1.8.1 REQUIRED) -# find_package(libpqxx REQUIRED) -find_package(GTest REQUIRED) -set(THREADS_PREFER_PTHREAD_FLAG ON) -find_package(Threads REQUIRED) -message(STATUS ${Boost_LIBRARIES}) -set(CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS} "-lpthread -pthread") -add_executable(${PROJECT_NAME} src/main.cpp) -#add_executable(${PROJECT_NAME} text-basic-metrics/tbm_main.cpp text-basic-metrics/tbm_main.cpp) строка для запуска моей части в text-basic-metrics -target_link_libraries(${PROJECT_NAME} ${Boost_LIBRARIES} ${antlr4-runtime_LIBRARIES} ${libpqxx_LIBRARIES} ${GTest_LIBRARIES}) \ No newline at end of file + +set(PROJECT_NAME "SourcedOut") + +project(${PROJECT_NAME}) + + +set(BUILD_DEV TRUE CACHE BOOL "build dev version") +set(SANITIZE_BUILD TRUE CACHE BOOL "build with sanitizers") + +if(BUILD_DEV) + enable_testing() + message("Building dev version") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} --coverage -O0 -fprofile-arcs -ftest-coverage") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -Wall -Wextra -pedantic -Wformat=2 -Wfloat-equal -Wconversion \ + -Wlogical-op -Wshift-overflow=2 -Wduplicated-cond -Wcast-qual -Wcast-align -lpq -lpqxx") + set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -coverage -lgcov") + + if(SANITIZE_BUILD) + message("Sanitizers ON") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address,undefined -fno-sanitize-recover=all -fsanitize-undefined-trap-on-error") + endif(SANITIZE_BUILD) +endif(BUILD_DEV) + +set(BUILD_SERVER "BUILD_SERVER") +set(BUILD_CLIENT "BUILD_CLIENT") +set(BUILD_ALL "BUILD_ALL") + + +message("${BUILD_DEV} ${SANITIZE_BUILD} ${CMAKE_EXE_LINKER_FLAGS}") +set(BUILD_MODE ${BUILD_SERVER}) + +if((BUILD_MODE STREQUAL ${BUILD_CLIENT}) OR (BUILD_MODE STREQUAL ${BUILD_ALL})) + add_subdirectory(client) +endif() + +if((BUILD_MODE STREQUAL ${BUILD_SERVER}) OR (BUILD_MODE STREQUAL ${BUILD_ALL})) + add_subdirectory(server) +endif() \ No newline at end of file diff --git a/server/CMakeLists.txt b/server/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..a8604805565cc50758dd616d439d4e4afa99143f --- /dev/null +++ b/server/CMakeLists.txt @@ -0,0 +1,22 @@ +set(CMAKE_PREFIX_PATH build) +project(SourcedOut CXX) +# find_package(antlr4-runtime REQUIRED) +find_package(Boost 1.8.1 REQUIRED) +find_package(Threads REQUIRED) +find_library(PQXX_LIB pqxx) +find_package(GTest REQUIRED) +find_package(nlohmann_json REQUIRED) +message(STATUS ${nlohmann_json_LIBRARIES}) + +set(THREADS_PREFER_PTHREAD_FLAG ON) +find_package(Threads REQUIRED) + +add_subdirectory(pkg) +add_subdirectory(internal) + +message(STATUS ${Boost_LIBRARIES}) +set(CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS} "-lpthread -pthread") + +#add_subdirectory(cpp-dotenv) +#add_executable(${PROJECT_NAME} text-basic-metrics/tbm_main.cpp text-basic-metrics/tbm_main.cpp) строка для запуска моей части в text-basic-metrics +# target_link_libraries(${PROJECT_NAME} ${Boost_LIBRARIES} ${antlr4-runtime_LIBRARIES} ${libpqxx_LIBRARIES} ${GTest_LIBRARIES}) \ No newline at end of file diff --git a/server/cmd/.env b/server/cmd/.env new file mode 100644 index 0000000000000000000000000000000000000000..7cac90d91390a5f095999d7b06b7b0e61d0ffc0a --- /dev/null +++ b/server/cmd/.env @@ -0,0 +1,6 @@ +PGHOSTADDR=0.0.0.0 +PGPORT=5432 +PGDATABASE=mydb +PGUSER=postgres +PGPASSWORD=root +POOL_SIZE=10 \ No newline at end of file diff --git a/server/cmd/CMakeLists.txt b/server/cmd/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..446f2a8e6f3113d0433e9a8e9540cb15711dc13a --- /dev/null +++ b/server/cmd/CMakeLists.txt @@ -0,0 +1,10 @@ +set(PROJECT_NAME "Server") + +project(${PROJECT_NAME}) + +add_executable(Server main.cpp) +message(STATUS ${libusers}) +target_link_libraries(${PROJECT_NAME} ${Boost_LIBRARIES} ${antlr4-runtime_LIBRARIES} ${libpqxx_LIBRARIES} ${libEntities_LIB} ${libRepository_LIB}) +target_include_directories(Server PUBLIC ${libusers_INCLUDE_DIRS}) +message("Built server") + diff --git a/server/cmd/main.cpp b/server/cmd/main.cpp new file mode 100644 index 0000000000000000000000000000000000000000..177490d060451b7f2bde04bf5c85432e007f9058 --- /dev/null +++ b/server/cmd/main.cpp @@ -0,0 +1,10 @@ +//#include "dotenv.h" +#include "UserRepository.hpp" +#include "User.hpp" + +//using namespace dotenv; +int main(){ + User user{"qwerty200468@gmail.com", "123", "tolik"}; + UserRepository repo; + std::cout< +#include +#include + +class Solution { +public: + Solution() =default; + Solution(size_t id, std::string sendDate, size_t senderId, std::string source, + std::string tokens, std::string astTree, size_t taskId, std::string result); + + [[nodiscard]] size_t getId() const; + + + [[nodiscard]] const std::string &getSendDate() const; + + void setSendDate(const std::string &sendDate); + + [[nodiscard]] size_t getSenderId() const; + + void setSenderId(size_t senderId); + + [[nodiscard]] const std::string &getSource() const; + + void setSource(const std::string &source); + + [[nodiscard]] const std::string &getTokens() const; + + void setTokens(const std::string &tokens); + + [[nodiscard]] const std::string &getAstTree() const; + + void setAstTree(const std::string &astTree); + + [[nodiscard]] size_t getTaskId() const; + + void setTaskId(size_t taskId); + + [[nodiscard]] const std::string &getResult() const; + + void setResult(const std::string &result); + +private: + size_t id; + std::string send_date; + size_t sender_id; + std::string source; + std::string tokens; + std::string astTree; + size_t task_id; + std::string result; +public: + +}; + +#endif //SOURCEDOUT_SOLUTION_HPP diff --git a/server/internal/entities/include/Task.hpp b/server/internal/entities/include/Task.hpp new file mode 100644 index 0000000000000000000000000000000000000000..6ad362fc839c3dc314b302617a349e086274c726 --- /dev/null +++ b/server/internal/entities/include/Task.hpp @@ -0,0 +1,23 @@ +#ifndef SOURCEDOUT_TASK_HPP +#define SOURCEDOUT_TASK_HPP +#include +#include +class Task{ +private: + size_t id; + std::string description; + +public: + Task()=default; + ~Task() = default; + Task(size_t id, std::string description); + + explicit Task(std::string description); + + [[nodiscard]] size_t getId() const; + + [[nodiscard]] const std::string &getDescription() const; + + void setDescription(const std::string &description); +}; +#endif //SOURCEDOUT_TASK_HPP diff --git a/server/internal/entities/include/User.hpp b/server/internal/entities/include/User.hpp new file mode 100644 index 0000000000000000000000000000000000000000..a597e6926f09b3bf457b087aca388d907d76dc36 --- /dev/null +++ b/server/internal/entities/include/User.hpp @@ -0,0 +1,38 @@ +#ifndef SOURCEDOUT_USER_HPP + +#include +#include + +#define SOURCEDOUT_USER_HPP + +class User { +private: + size_t id; + std::string login; + std::string password; + std::string username; + +public: + User()=default; + User(size_t id_, std::string login_, std::string password_, std::string username_); + + User(std::string login_, std::string password_, std::string username_); + + [[nodiscard]] const std::string &getLogin() const; + + void setLogin(const std::string &login); + + [[nodiscard]] const std::string &getPassword() const; + + void setPassword(const std::string &password); + + [[nodiscard]] const std::string &getUsername() const; + + void setUsername(const std::string &username); + + [[nodiscard]] size_t getId() const; + + friend std::ostream &operator<<(std::ostream &os, const User &user); +}; + +#endif //SOURCEDOUT_USER_HPP diff --git a/server/internal/entities/src/Solution.cpp b/server/internal/entities/src/Solution.cpp new file mode 100644 index 0000000000000000000000000000000000000000..dd8a542a7bf1c09e5c7ff7b081dd1a50bb991f22 --- /dev/null +++ b/server/internal/entities/src/Solution.cpp @@ -0,0 +1,73 @@ + +#include +#include +#include "../include/Solution.hpp" + +Solution::Solution(unsigned long id, std::string sendDate, unsigned long senderId, + std::string source, std::string tokens, + std::string astTree, unsigned long taskId, + std::string result) : id(id), send_date(std::move(sendDate)), sender_id(senderId), + source(std::move(source)), tokens(std::move(tokens)), + astTree(std::move(astTree)), + task_id(taskId), result(std::move(result)) {} + +size_t Solution::getId() const { + return id; +} + + +const std::string &Solution::getSendDate() const { + return send_date; +} + +void Solution::setSendDate(const std::string &sendDate) { + send_date = sendDate; +} + +size_t Solution::getSenderId() const { + return sender_id; +} + +void Solution::setSenderId(size_t senderId) { + sender_id = senderId; +} + +const std::string &Solution::getSource() const { + return source; +} + +void Solution::setSource(const std::string &source_) { + Solution::source = source_; +} + +const std::string &Solution::getTokens() const { + return tokens; +} + +void Solution::setTokens(const std::string &tokens_) { + Solution::tokens = tokens_; +} + +const std::string &Solution::getAstTree() const { + return astTree; +} + +void Solution::setAstTree(const std::string &astTree_) { + Solution::astTree = astTree_; +} + +size_t Solution::getTaskId() const { + return task_id; +} + +void Solution::setTaskId(size_t taskId) { + task_id = taskId; +} + +const std::string &Solution::getResult() const { + return result; +} + +void Solution::setResult(const std::string &result_) { + Solution::result = result_; +} diff --git a/server/internal/entities/src/Task.cpp b/server/internal/entities/src/Task.cpp new file mode 100644 index 0000000000000000000000000000000000000000..99e0fe634f4a3d28f78cd11511352f6b90616680 --- /dev/null +++ b/server/internal/entities/src/Task.cpp @@ -0,0 +1,21 @@ +#pragma once + +#include "../include/Task.hpp" +#include +#include + +unsigned long Task::getId() const { + return id; +} + +Task::Task(size_t id, std::string description) : id(id), description(std::move(description)) {} + +Task::Task(std::string description) : id(0), description(std::move(description)) {} + +const std::string &Task::getDescription() const { + return description; +} + +void Task::setDescription(const std::string &description_) { + Task::description = description_; +} diff --git a/server/internal/entities/src/User.cpp b/server/internal/entities/src/User.cpp new file mode 100644 index 0000000000000000000000000000000000000000..c048f8f0b920614ef9e17cba52de56c2b614cafe --- /dev/null +++ b/server/internal/entities/src/User.cpp @@ -0,0 +1,43 @@ +#include +#include "../include/User.hpp" + +User::User(size_t id_, std::string login_, std::string password_, std::string username_) : + id(id_), login(std::move(login_)), password(std::move(password_)), username(std::move(username_)) { +} +User::User(std::string login_, std::string password_, std::string username_) : +id(0), login(std::move(login_)), password(std::move(password_)), username(std::move(username_)) { +} + +const std::string &User::getLogin() const { + return login; +} + +void User::setLogin(const std::string &login_) { + User::login = login_; +} + +const std::string &User::getPassword() const { + return password; +} + +void User::setPassword(const std::string &password_) { + User::password = password_; +} + +const std::string &User::getUsername() const { + return username; +} + +void User::setUsername(const std::string &username_) { + User::username = username_; +} + +size_t User::getId() const { + return id; +} + +std::ostream &operator<<(std::ostream &os, const User &user) { + os << "id: " << user.id << " login: " << user.login << " password: " << user.password << " username: " + << user.username; + return os; +} diff --git a/server/internal/repository/CMakeLists.txt b/server/internal/repository/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..bee149e70d973e2da173369a75bb490c61d2ece7 --- /dev/null +++ b/server/internal/repository/CMakeLists.txt @@ -0,0 +1,32 @@ +project("RepositoryLib") + +set(LIB_NAME libRepository) + +file(GLOB_RECURSE SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp) +file(GLOB_RECURSE HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/include/*.hpp ${CMAKE_CURRENT_SOURCE_DIR}/include/*.h ${CMAKE_CURRENT_SOURCE_DIR}/virtual/*.hpp) + +message("SOURCES = ${SOURCES}") +message("HEADERS = ${HEADERS}") + + +set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -Wall -Wextra -O2 -pedantic -Wformat=2 -Wfloat-equal -Wconversion \ +-Wlogical-op -Wshift-overflow=2 -Wduplicated-cond -Wcast-qual -Wcast-align") + +set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -lboost_filesystem") + + +add_library(${LIB_NAME} ${SOURCES} ${HEADERS}) +target_include_directories(${LIB_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include ${CMAKE_CURRENT_SOURCE_DIR}/virtual) +target_link_libraries(${LIB_NAME} ${Boost_LIBRARIES} ${libpqxx_LIBRARIES} ${libEntities_LIB} ${libDbManager_LIB}) + +set(libRepository_LIB ${LIB_NAME}) +set(libRepository_LIB ${libRepository_LIB} PARENT_SCOPE) + +set(libRepository_INCLUDE_DIRS ${LIB_NAME} ${CMAKE_CURRENT_SOURCE_DIR}/include ${CMAKE_CURRENT_SOURCE_DIR}/virtual) +set(libRepository_INCLUDE_DIRS ${libRepository_INCLUDE_DIRS} PARENT_SCOPE) + + +message(Entities_LIB = "${libEntities_LIB}") +message(dbManager = "${libDbManager_LIB}") +message("libRepository_LIB = ${libRepository_LIB}") +message("libRepository_INCLUDE_DIRS = ${libRepository_INCLUDE_DIRS}") diff --git a/server/internal/repository/virtual/ISolutionRepository.hpp b/server/internal/repository/virtual/ISolutionRepository.hpp new file mode 100644 index 0000000000000000000000000000000000000000..8a7b03532869bcbc96bad16cfd680a593ccbf884 --- /dev/null +++ b/server/internal/repository/virtual/ISolutionRepository.hpp @@ -0,0 +1,29 @@ +#ifndef SOURCEDOUT_ISOLUTIONREPOSITORY_HPP +#define SOURCEDOUT_ISOLUTIONREPOSITORY_HPP + +#include +#include +#include "../../entities/include/Solution.hpp" + +class ISolutionRepository { + public: + virtual ~ISolutionRepository() = default; + virtual Solution getSolutionById(size_t id) = 0; + + virtual std::vector getSolutionsBySenderId(size_t sender_id) = 0; + virtual std::vector getSolutions(size_t sender_id, size_t task_id) = 0; + + virtual std::vector getSolutionsByTaskId(size_t task_id) = 0; + + virtual size_t storeSolution(Solution solution) = 0; + + virtual void updateSolution(Solution solution) = 0; + + virtual void deleteSolutionById(size_t id) = 0; + + virtual void deleteSolution(Solution solution) = 0; + + +}; + +#endif //SOURCEDOUT_ISOLUTIONREPOSITORY_HPP diff --git a/server/internal/repository/virtual/ITaskRepository.hpp b/server/internal/repository/virtual/ITaskRepository.hpp new file mode 100644 index 0000000000000000000000000000000000000000..e367c21d528da5a084b1a2ac02410fea9a6ebc05 --- /dev/null +++ b/server/internal/repository/virtual/ITaskRepository.hpp @@ -0,0 +1,21 @@ +#ifndef SOURCEDOUT_ITASKREPOSITORY_HPP +#define SOURCEDOUT_ITASKREPOSITORY_HPP + +#include +#include "../../entities/include/Task.hpp" + +class ITaskRepository { + public: + virtual ~ITaskRepository() = default; + virtual Task getTaskById(size_t id) = 0; + + virtual void updateTask(Task task) = 0; + + virtual int storeTask(Task task) = 0; + + virtual void deleteTask(Task task) = 0; + + virtual void deleteTaskById(size_t task_id) = 0; +}; + +#endif //SOURCEDOUT_ITASKREPOSITORY_HPP diff --git a/server/internal/repository/virtual/IUserRepository.hpp b/server/internal/repository/virtual/IUserRepository.hpp new file mode 100644 index 0000000000000000000000000000000000000000..14d7a50ee86692f3768460ce520b78a50cf82f94 --- /dev/null +++ b/server/internal/repository/virtual/IUserRepository.hpp @@ -0,0 +1,23 @@ +#ifndef SOURCEDOUT_IUSERREPOSITORY_HPP +#define SOURCEDOUT_IUSERREPOSITORY_HPP + +#include +#include "../../entities/include/User.hpp" +class IUserRepository { +public: + virtual ~IUserRepository() = default; + virtual User getUserById(size_t id) = 0; + + virtual User getUserByLogin(std::string login) = 0; + + virtual size_t makeUser(User user) = 0; + + virtual void deleteUser(User user) = 0; + + virtual void deleteByUserId(size_t user_id) = 0; + + virtual std::vector getAllUsers() = 0; + +}; + +#endif //SOURCEDOUT_IUSERREPOSITORY_HPP diff --git a/server/internal/service/CMakeLists.txt b/server/internal/service/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..ed9f4152540ddff5b012edd200d207b7b536e530 --- /dev/null +++ b/server/internal/service/CMakeLists.txt @@ -0,0 +1,23 @@ +project("ServiceLib") + +file(GLOB SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp) +file(GLOB INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/include ${CMAKE_CURRENT_SOURCE_DIR}/virtual) + + +include_directories(${INCLUDE_DIRS}) +add_library(${PROJECT_NAME} ${SOURCES}) + +message("ANTLR4_LIB = ${ANTLR4_LIB}") +message("ANTLR4_LIB_INCLUDE_DIRS = ${ANTLR4_LIB_INCLUDE_DIRS}") + +target_include_directories(${PROJECT_NAME} PUBLIC ${INCLUDE_DIRS} ${libEntities_INCLUDE_DIRS} ${libRepository_INCLUDE_DIRS} ${ANTLR4_LIB_INCLUDE_DIRS}) +target_link_libraries(${PROJECT_NAME} ${libRepository_LIB} ${libEntities_LIB} ${ANTLR4_LIB}) + +set(SERVICE_lib_LIBRARY ${PROJECT_NAME}) +set(SERVICE_lib_LIBRARY ${SERVICE_lib_LIBRARY} PARENT_SCOPE) + +set(SERVICE_lib_INCLUDE_DIRS ${INCLUDE_DIRS}) +set(SERVICE_lib_INCLUDE_DIRS ${SERVICE_lib_INCLUDE_DIRS} PARENT_SCOPE) + +enable_testing() +add_subdirectory(tests) \ No newline at end of file diff --git a/server/internal/service/include/Exceptions.h b/server/internal/service/include/Exceptions.h new file mode 100644 index 0000000000000000000000000000000000000000..a032c21f5db1fa1cd4376dca67e295819a91d665 --- /dev/null +++ b/server/internal/service/include/Exceptions.h @@ -0,0 +1,9 @@ +#pragma once + +class ValidateException : public std::exception { + std::string _msg; + + public: + ValidateException(const std::string& msg) : _msg(msg) {} + virtual const char* what() const noexcept override { return _msg.c_str(); } +}; \ No newline at end of file diff --git a/server/internal/service/include/SolutionService.h b/server/internal/service/include/SolutionService.h new file mode 100644 index 0000000000000000000000000000000000000000..04ac2d8679eb40404e2e3eb99f060712e43db274 --- /dev/null +++ b/server/internal/service/include/SolutionService.h @@ -0,0 +1,25 @@ +#pragma once + +#include + +#include "ISolutionRepository.hpp" +#include "ISolutionService.h" +#include "IAntlrWrapper.h" +#include "IMockMetrics.h" + +class SolutionService : ISolutionService { + private: + std::unique_ptr solutionRepo; + std::unique_ptr antlr; + std::unique_ptr metrics; + public: + explicit SolutionService(std::unique_ptr solutionRepo); + void setAntlrWrapper(std::unique_ptr antlr_); + void setMetrics(std::unique_ptr metrics_); + Solution createSolution(size_t userId, size_t taskId, + std::string source) override; + std::vector getSolutionsByUserAndTaskId(size_t userId, + size_t taskId) override; + void deleteSolutionById(size_t solId) override; + std::pair getMetrics(size_t solId) override; +}; diff --git a/server/internal/service/include/TaskService.h b/server/internal/service/include/TaskService.h new file mode 100644 index 0000000000000000000000000000000000000000..bf04d3e472f736a8c24bd1d753cd5ed5a3577636 --- /dev/null +++ b/server/internal/service/include/TaskService.h @@ -0,0 +1,19 @@ +#pragma once + +#include + +#include "ITaskRepository.hpp" +#include "ITaskService.h" + +class TaskService : public ITaskService { + private: + std::unique_ptr taskRepo; + + public: + TaskService(std::unique_ptr taskRepo); + ~TaskService() override = default; + Task createTask(std::string desc) override; + Task getTask(size_t id) override; + std::vector getAllTasks() override; + void deleteTask(size_t id) override; +}; diff --git a/server/internal/service/include/UserService.h b/server/internal/service/include/UserService.h new file mode 100644 index 0000000000000000000000000000000000000000..719aa02fbcc1f38035bf4cf134085fdcc11af00f --- /dev/null +++ b/server/internal/service/include/UserService.h @@ -0,0 +1,19 @@ +#pragma once +#include + +#include "IUserRepository.hpp" +#include "IUserService.h" +#include "UserValidator.h" + +class UserService : IUserService { + private: + std::unique_ptr userRepo; + + public: + ~UserService() override = default; + explicit UserService(std::unique_ptr userRepo); + User createUser(std::string login, std::string username, + std::string password) override; + User getUserById(size_t id) override; + void deleteUser(size_t id) override; +}; diff --git a/server/internal/service/include/UserValidator.h b/server/internal/service/include/UserValidator.h new file mode 100644 index 0000000000000000000000000000000000000000..002f4503d5a1aaeaef870a5034b29879bfdd2b91 --- /dev/null +++ b/server/internal/service/include/UserValidator.h @@ -0,0 +1,16 @@ +#pragma once + +#include "User.hpp" + +class UserValidator { + private: + User user; + bool validateLogin(); + bool validatePassword(); + bool validateUsername(); + + public: + explicit UserValidator(User user); + bool validateUser(); + ~UserValidator() = default; +}; diff --git a/server/internal/service/src/SolutionService.cpp b/server/internal/service/src/SolutionService.cpp new file mode 100644 index 0000000000000000000000000000000000000000..485f86bacbd9df24d509bdc4e3e4022438b9bd7b --- /dev/null +++ b/server/internal/service/src/SolutionService.cpp @@ -0,0 +1,48 @@ +#include "SolutionService.h" + +SolutionService::SolutionService( + std::unique_ptr solutionRepo) + : solutionRepo(std::move(solutionRepo)) {} + +Solution SolutionService::createSolution(size_t userId, size_t taskId, + std::string source) { + size_t id = solutionRepo->storeSolution( + Solution(0, "", userId, source, "metrics1", "metrics2", taskId, "")); + return Solution(id, "", userId, source, "", "", taskId, ""); +} + +std::vector SolutionService::getSolutionsByUserAndTaskId( + size_t userId, size_t taskId) { + try { + return solutionRepo->getSolutions(userId, taskId); + } catch (std::exception& e) { + throw e; + } +} + +void SolutionService::deleteSolutionById(size_t solId) { + try { + solutionRepo->deleteSolutionById(solId); + } catch (std::exception& e) { + throw e; + } +} + +std::pair SolutionService::getMetrics(size_t solId) { + try { + Solution sol = solutionRepo->getSolutionById(solId); + std::string tokens = sol.getTokens(); + std::string astTree = sol.getAstTree(); + return std::make_pair(tokens, astTree); + } catch (std::exception& e) { + throw e; + } +} + +void SolutionService::setAntlrWrapper(std::unique_ptr antlr_) { + antlr = std::move(antlr_); +} + +void SolutionService::setMetrics(std::unique_ptr metrics_) { + metrics = std::move(metrics_); +} diff --git a/server/internal/service/src/TaskService.cpp b/server/internal/service/src/TaskService.cpp new file mode 100644 index 0000000000000000000000000000000000000000..a3ce5ef9b3baadb7902fbdf0f2cca6f9d0229a7a --- /dev/null +++ b/server/internal/service/src/TaskService.cpp @@ -0,0 +1,15 @@ +#include "TaskService.h" + +TaskService::TaskService(std::unique_ptr taskRepo) + : taskRepo(std::move(taskRepo)) {} + +Task TaskService::createTask(std::string desc) { + size_t id = taskRepo->storeTask(Task(desc)); + return Task(id, desc); +} + +std::vector TaskService::getAllTasks() { return std::vector(); } + +Task TaskService::getTask(size_t id) { return taskRepo->getTaskById(id); } + +void TaskService::deleteTask(size_t id) { taskRepo->deleteTaskById(id); } diff --git a/server/internal/service/src/UserService.cpp b/server/internal/service/src/UserService.cpp new file mode 100644 index 0000000000000000000000000000000000000000..b44ecf333aaab2c52a757505646371a8bfd83f48 --- /dev/null +++ b/server/internal/service/src/UserService.cpp @@ -0,0 +1,19 @@ +#include "UserService.h" + +#include "Exceptions.h" + +UserService::UserService(std::unique_ptr userRepo) + : userRepo(std::move(userRepo)) {} + +User UserService::createUser(std::string login, std::string username, + std::string password) { + if (login == "") { + throw ValidateException("invalid login"); + } + size_t id = userRepo->makeUser(User(login, password, username)); + return User(id, login, password, username); +} + +User UserService::getUserById(size_t id) { return userRepo->getUserById(id); } + +void UserService::deleteUser(size_t id) { userRepo->deleteByUserId(id); } diff --git a/server/internal/service/src/UserValidator.cpp b/server/internal/service/src/UserValidator.cpp new file mode 100644 index 0000000000000000000000000000000000000000..66666414ca86a6efd9e4e4e7ca113b9b38e9a5f4 --- /dev/null +++ b/server/internal/service/src/UserValidator.cpp @@ -0,0 +1,36 @@ +#include "UserValidator.h" + +#include + +UserValidator::UserValidator(User user) : user(user) {} + +bool UserValidator::validateUser() { + if (validateLogin() && validatePassword() && validateUsername()) { + return true; + } + return false; +} + +bool UserValidator::validateLogin() { + std::string login = user.getLogin(); + if (login.length() < 3 || login.length() > 30) { + return false; + } + return true; +} + +bool UserValidator::validatePassword() { + std::string password = user.getPassword(); + if (password.length() < 8 || password.length() > 30) { + return false; + } + return true; +} + +bool UserValidator::validateUsername() { + std::string username = user.getUsername(); + if (username.length() < 3 || username.length() > 20) { + return false; + } + return true; +} diff --git a/server/internal/service/tests/CMakeLists.txt b/server/internal/service/tests/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..5dc8740fa010b643d39406582be5b37b0e1a5c09 --- /dev/null +++ b/server/internal/service/tests/CMakeLists.txt @@ -0,0 +1,17 @@ +project(test_service) + +set(CMAKE_CXX_STANDARD 20) +add_compile_options(-coverage) + +file(GLOB SOURCES *.cpp) + +enable_testing() +find_package(GTest REQUIRED) + +add_executable(${PROJECT_NAME} ${SOURCES}) + +target_link_libraries(${PROJECT_NAME} ${SERVICE_lib_LIBRARY} GTest::GTest gmock) +target_include_directories(${PROJECT_NAME} PUBLIC ${SERVICE_lib_INCLUDE_DIRS}) + + +add_test(test_service test_service) \ No newline at end of file diff --git a/server/internal/service/tests/SolutionServiceTest.cpp b/server/internal/service/tests/SolutionServiceTest.cpp new file mode 100644 index 0000000000000000000000000000000000000000..2dcb91ffdb91f2fc6741c0f6bdca1fecd037c03f --- /dev/null +++ b/server/internal/service/tests/SolutionServiceTest.cpp @@ -0,0 +1,96 @@ +#include +#include + +#include "SolutionService.h" + +class Exception : public std::exception { + std::string _msg; + + public: + Exception(const std::string& msg) : _msg(msg) {} + virtual const char* what() const noexcept override { return _msg.c_str(); } +}; + +bool operator==(Solution s1, Solution s2) { return s1.getId() == s2.getId(); } + +class SolutionRepositoryMock : public ISolutionRepository { + public: + ~SolutionRepositoryMock() override = default; + MOCK_METHOD(Solution, getSolutionById, (size_t id), (override)); + MOCK_METHOD(std::vector, getSolutionsBySenderId, (size_t sender_id), + (override)); + MOCK_METHOD(std::vector, getSolutionsByTaskId, (size_t task_id), + (override)); + MOCK_METHOD(std::vector, getSolutions, + (size_t sender_id, size_t task_id), (override)); + MOCK_METHOD(size_t, storeSolution, (Solution solution), (override)); + MOCK_METHOD(void, updateSolution, (Solution solution), (override)); + MOCK_METHOD(void, deleteSolutionById, (size_t id), (override)); + MOCK_METHOD(void, deleteSolution, (Solution solution), (override)); +}; + +struct SolutionServiceTest : public testing::Test { + SolutionService* ss; + SolutionRepositoryMock* mock_ptr; + + void SetUp() { + auto mock = std::make_unique(); + mock_ptr = mock.get(); + ss = new SolutionService(std::move(mock)); + } + void TearDown() { delete ss; } +}; + +ACTION(NoSolutionException) { + throw Exception("no solution with this id in db"); +} + +TEST_F(SolutionServiceTest, getSolutionsByUserAndTaskId) { + std::vector solutions; + solutions.push_back(Solution(0, "", 1, "", "", "", 1, "")); + solutions.push_back(Solution(1, "", 1, "", "", "", 1, "")); + EXPECT_CALL(*mock_ptr, getSolutions(1, 1)) + .Times(1) + .WillOnce(::testing::Return(solutions)); + std::vector sols = ss->getSolutionsByUserAndTaskId(1, 1); + EXPECT_EQ(sols.size(), 2); +} + +TEST_F(SolutionServiceTest, deleteSolution) { + EXPECT_CALL(*mock_ptr, deleteSolutionById(1)).Times(1); + ss->deleteSolutionById(1); +} + +TEST_F(SolutionServiceTest, deleteSolutionException) { + EXPECT_CALL(*mock_ptr, deleteSolutionById(-1)) + .Times(1) + .WillRepeatedly(NoSolutionException()); + EXPECT_THROW(ss->deleteSolutionById(-1), std::exception); +} + +TEST_F(SolutionServiceTest, getMetrics) { + EXPECT_CALL(*mock_ptr, getSolutionById(1)) + .Times(1) + .WillOnce(::testing::Return( + Solution(1, "", 1, "", "tokens", "astTree", 1, ""))); + std::pair metrics = ss->getMetrics(1); + EXPECT_EQ(metrics.first, "tokens"); + EXPECT_EQ(metrics.second, "astTree"); +} + +TEST_F(SolutionServiceTest, getMetricsException) { + EXPECT_CALL(*mock_ptr, getSolutionById(-1)) + .Times(1) + .WillRepeatedly(NoSolutionException()); + EXPECT_THROW(ss->getMetrics(-1), std::exception); +} + +TEST_F(SolutionServiceTest, createSolution) { + EXPECT_CALL(*mock_ptr, + storeSolution(Solution(0, "", 2, "source", "", "", 1, ""))) + .Times(1) + .WillRepeatedly(::testing::Return(1)); + Solution sol = ss->createSolution(2, 1, "source"); + EXPECT_EQ(sol.getId(), 1); + EXPECT_EQ(sol.getSource(), "source"); +} \ No newline at end of file diff --git a/server/internal/service/tests/TaskServiceTest.cpp b/server/internal/service/tests/TaskServiceTest.cpp new file mode 100644 index 0000000000000000000000000000000000000000..5a450d201f578fa2c5f58817c42ebcd6165438ca --- /dev/null +++ b/server/internal/service/tests/TaskServiceTest.cpp @@ -0,0 +1,82 @@ +#include +#include + +#include "TaskService.h" + +bool operator==(Task t1, Task t2) { return t1.getId() == t2.getId(); } + +class Exception : public std::exception { + std::string _msg; + + public: + Exception(const std::string& msg) : _msg(msg) {} + virtual const char* what() const noexcept override { return _msg.c_str(); } +}; + +class TaskRepositoryMock : public ITaskRepository { + public: + ~TaskRepositoryMock() override = default; + MOCK_METHOD(Task, getTaskById, (size_t id), (override)); + MOCK_METHOD(void, updateTask, (Task task), (override)); + MOCK_METHOD(int, storeTask, (Task task), (override)); + MOCK_METHOD(void, deleteTask, (Task task), (override)); + MOCK_METHOD(void, deleteTaskById, (size_t id), (override)); +}; + +struct TaskServiceTest : public testing::Test { + TaskService* ts; + TaskRepositoryMock* mock_ptr; + + void SetUp() { + auto mock = std::make_unique(); + mock_ptr = mock.get(); + ts = new TaskService(std::move(mock)); + } + void TearDown() { delete ts; } +}; + +ACTION(NoTaskException) { throw Exception("no task with this id in db"); } + +TEST_F(TaskServiceTest, deleteTaskById) { + EXPECT_CALL(*mock_ptr, deleteTaskById(1)).Times(1); + ts->deleteTask(1); +} + +TEST_F(TaskServiceTest, deleteTasWithInvalidId) { + EXPECT_CALL(*mock_ptr, deleteTaskById(1)) + .Times(1) + .WillRepeatedly(NoTaskException()); + EXPECT_THROW(ts->deleteTask(1), Exception); +} + +TEST_F(TaskServiceTest, GetTaskByIdOK) { + EXPECT_CALL(*mock_ptr, getTaskById(1)) + .Times(1) + .WillOnce(::testing::Return(Task(1, "desription"))); + Task t = ts->getTask(1); + EXPECT_EQ(t.getId(), 1); + EXPECT_EQ(t.getDescription(), "desription"); +} + +TEST_F(TaskServiceTest, GetTaskByIdEXEPTION) { + EXPECT_CALL(*mock_ptr, getTaskById(-1)) + .Times(1) + .WillRepeatedly(NoTaskException()); + EXPECT_THROW(ts->getTask(-1), Exception); +} + +TEST_F(TaskServiceTest, CreateTask) { + EXPECT_CALL(*mock_ptr, storeTask(Task("desc"))) + .Times(1) + .WillOnce(::testing::Return(1)); + Task t = ts->createTask("desc"); + EXPECT_EQ(t.getId(), 1); + EXPECT_EQ(t.getDescription(), "desc"); + + EXPECT_CALL(*mock_ptr, storeTask(Task("desc2"))) + .Times(1) + .WillOnce(::testing::Return(2)); + t = ts->createTask("desc2"); + EXPECT_EQ(t.getId(), 2); + EXPECT_EQ(t.getDescription(), "desc2"); +} diff --git a/server/internal/service/tests/UserServiceTest.cpp b/server/internal/service/tests/UserServiceTest.cpp new file mode 100644 index 0000000000000000000000000000000000000000..a7423515f22b208ac3cbbf11a1947010b8d66fd2 --- /dev/null +++ b/server/internal/service/tests/UserServiceTest.cpp @@ -0,0 +1,85 @@ +#include +#include + +#include "Exceptions.h" +#include "UserService.h" + +bool operator==(User u1, User u2) { return u1.getId() == u2.getId(); } + +class Exception : public std::exception { + std::string _msg; + + public: + Exception(const std::string& msg) : _msg(msg) {} + virtual const char* what() const noexcept override { return _msg.c_str(); } +}; + +class UserRepositoryMock : public IUserRepository { + public: + ~UserRepositoryMock() override = default; + MOCK_METHOD(User, getUserById, (size_t id), (override)); + MOCK_METHOD(User, getUserByLogin, (std::string login), (override)); + MOCK_METHOD(size_t, makeUser, (User user), (override)); + MOCK_METHOD(void, deleteUser, (User user), (override)); + MOCK_METHOD(void, deleteByUserId, (size_t id), (override)); + MOCK_METHOD(std::vector, getAllUsers, (), (override)); +}; + +struct UserServiceTest : public testing::Test { + UserService* us; + UserRepositoryMock* mock_ptr; + + void SetUp() { + auto mock = std::make_unique(); + mock_ptr = mock.get(); + us = new UserService(std::move(mock)); + } + void TearDown() { delete us; } +}; + +ACTION(NoUserException) { throw Exception("no user with this id in db"); } + +TEST_F(UserServiceTest, deleteUser) { + EXPECT_CALL(*mock_ptr, deleteByUserId(1)).Times(1); + us->deleteUser(1); +} + +TEST_F(UserServiceTest, deleteUserWithInvalidId) { + EXPECT_CALL(*mock_ptr, deleteByUserId(1)) + .Times(1) + .WillRepeatedly(NoUserException()); + EXPECT_THROW(us->deleteUser(1), Exception); +} + +TEST_F(UserServiceTest, getUserOk) { + EXPECT_CALL(*mock_ptr, getUserById(1)) + .Times(1) + .WillOnce(::testing::Return(User(1, "login", "password", "username"))); + User u = us->getUserById(1); + EXPECT_EQ(u.getLogin(), "login"); + EXPECT_EQ(u.getId(), 1); + EXPECT_EQ(u.getPassword(), "password"); + EXPECT_EQ(u.getUsername(), "username"); +} + +TEST_F(UserServiceTest, getUserEXEPTION) { + EXPECT_CALL(*mock_ptr, getUserById(-1)).Times(1).WillOnce(NoUserException()); + EXPECT_THROW(us->getUserById(-1), Exception); +} + +TEST_F(UserServiceTest, makeUserOk) { + EXPECT_CALL(*mock_ptr, makeUser(User("login", "password", "username"))) + .Times(1) + .WillOnce(::testing::Return(1)); + User u = us->createUser("login", "username", "password"); + EXPECT_EQ(u.getLogin(), "login"); + EXPECT_EQ(u.getId(), 1); + EXPECT_EQ(u.getPassword(), "password"); + EXPECT_EQ(u.getUsername(), "username"); +} + +TEST_F(UserServiceTest, makeUserInvalidData) { + EXPECT_CALL(*mock_ptr, makeUser(User("login", "password", "username"))) + .Times(0); + EXPECT_THROW(us->createUser("", "", ""), ValidateException); +} \ No newline at end of file diff --git a/server/internal/service/tests/UserValidatorTest.cpp b/server/internal/service/tests/UserValidatorTest.cpp new file mode 100644 index 0000000000000000000000000000000000000000..802b2f03b5eb3368a223abbb1a4269a30c555a55 --- /dev/null +++ b/server/internal/service/tests/UserValidatorTest.cpp @@ -0,0 +1,29 @@ +#include +#include + +#include "UserValidator.h" + +TEST(UserValidatorTest, validateOK) { + UserValidator uv(User("login", "password", "username")); + EXPECT_TRUE(uv.validateUser()); +} + +TEST(UserValidatorTest, invalidLogin) { + UserValidator uv(User("", "password", "username")); + EXPECT_FALSE(uv.validateUser()); +} + +TEST(UserValidatorTest, invalidPassword) { + UserValidator uv(User("login", "", "username")); + EXPECT_FALSE(uv.validateUser()); +} + +TEST(UserValidatorTest, invalidUsername) { + UserValidator uv(User("login", "password", "")); + EXPECT_FALSE(uv.validateUser()); +} + +TEST(UserValidatorTest, invalidUserFields) { + UserValidator uv(User("", "", "")); + EXPECT_FALSE(uv.validateUser()); +} \ No newline at end of file diff --git a/server/internal/service/tests/main.cpp b/server/internal/service/tests/main.cpp new file mode 100644 index 0000000000000000000000000000000000000000..4ccb03731487f11418e7471cd8342ac0e4f81ae8 --- /dev/null +++ b/server/internal/service/tests/main.cpp @@ -0,0 +1,8 @@ +#include +#include + +int main(int argc, char** argv) { + ::testing::InitGoogleMock(&argc, argv); + + return RUN_ALL_TESTS(); +} \ No newline at end of file diff --git a/server/internal/service/virtual/IMockMetrics.h b/server/internal/service/virtual/IMockMetrics.h new file mode 100644 index 0000000000000000000000000000000000000000..d86a0f69e045523966ac4c50d01073853147b7fe --- /dev/null +++ b/server/internal/service/virtual/IMockMetrics.h @@ -0,0 +1,6 @@ +#pragma once + +class IMockMetrics { + public: + virtual void countMetric(); +}; diff --git a/server/internal/service/virtual/ISolutionService.h b/server/internal/service/virtual/ISolutionService.h new file mode 100644 index 0000000000000000000000000000000000000000..a9ec5483b64e2d9737b725ee17b6dc4afad3c078 --- /dev/null +++ b/server/internal/service/virtual/ISolutionService.h @@ -0,0 +1,18 @@ +#pragma once + +#include +#include + +#include "Solution.hpp" + +class ISolutionService { + public: + virtual ~ISolutionService() = default; + virtual Solution createSolution(size_t userId, size_t taskId, + std::string source) = 0; + virtual std::vector getSolutionsByUserAndTaskId(size_t userId, + size_t taskId) = 0; + virtual void deleteSolutionById(size_t solId) = 0; + + virtual std::pair getMetrics(size_t solId) = 0; +}; diff --git a/server/internal/service/virtual/ITaskService.h b/server/internal/service/virtual/ITaskService.h new file mode 100644 index 0000000000000000000000000000000000000000..731fb0f99bb7056d3d87ced20038cfb26cbd27f5 --- /dev/null +++ b/server/internal/service/virtual/ITaskService.h @@ -0,0 +1,13 @@ +#pragma once +#include + +#include "Task.hpp" + +class ITaskService { + public: + virtual ~ITaskService() = default; + virtual Task createTask(std::string desc) = 0; + virtual Task getTask(size_t id) = 0; + virtual std::vector getAllTasks() = 0; + virtual void deleteTask(size_t id) = 0; +}; diff --git a/server/internal/service/virtual/IUserService.h b/server/internal/service/virtual/IUserService.h new file mode 100644 index 0000000000000000000000000000000000000000..06d79720920e538ce1a8bfa24079953cc04b05e7 --- /dev/null +++ b/server/internal/service/virtual/IUserService.h @@ -0,0 +1,14 @@ +#pragma once + +#include + +#include "User.hpp" + +class IUserService { + public: + virtual ~IUserService() = default; + virtual User createUser(std::string login, std::string username, + std::string password) = 0; + virtual User getUserById(size_t id) = 0; + virtual void deleteUser(size_t id) = 0; +}; diff --git a/server/pkg/CMakeLists.txt b/server/pkg/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..f105ad52f9f205c401c2e5f15904b60fcc0bed87 --- /dev/null +++ b/server/pkg/CMakeLists.txt @@ -0,0 +1,4 @@ +add_subdirectory(antlr) + +set(ANTLR4_LIB ${ANTLR4_LIB} PARENT_SCOPE) +set(ANTLR4_LIB_INCLUDE_DIRS ${ANTLR4_LIB_INCLUDE_DIRS} PARENT_SCOPE) diff --git a/server/pkg/antlr/CMakeLists.txt b/server/pkg/antlr/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..c80b45532b951915d3e8643a900566053218b486 --- /dev/null +++ b/server/pkg/antlr/CMakeLists.txt @@ -0,0 +1,23 @@ +list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake) + +set(CMAKE_CXX_STANDARD 20) + + +# set(CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS} "-lpthread") +set(THREADS_PREFER_PTHREAD_FLAG ON) + + +include(ExternalAntlr4Cpp) +include_directories(${ANTLR4_INCLUDE_DIRS}) + +set(ANTLR_EXECUTABLE /usr/local/lib/antlr-4.12.0-complete.jar) +find_package(ANTLR REQUIRED) + +add_subdirectory(cpp14) +# add_subdirectory(python3) + +set(ANTLR4_LIB ${CPP_ANTLR_LIBRARY}) +set(ANTLR4_LIB ${ANTLR4_LIB} PARENT_SCOPE) +set(ANTLR4_LIB_INCLUDE_DIRS ${CPP_ANTLR_INCLUDE_DIRS}) +set(ANTLR4_LIB_INCLUDE_DIRS ${ANTLR4_LIB_INCLUDE_DIRS} PARENT_SCOPE) + diff --git a/server/pkg/antlr/cmake/ExternalAntlr4Cpp.cmake b/server/pkg/antlr/cmake/ExternalAntlr4Cpp.cmake new file mode 100644 index 0000000000000000000000000000000000000000..54f874b86be4fe787a640d9e9b560dac0fb0417a --- /dev/null +++ b/server/pkg/antlr/cmake/ExternalAntlr4Cpp.cmake @@ -0,0 +1,177 @@ +cmake_minimum_required(VERSION 3.7) + +if(POLICY CMP0114) + cmake_policy(SET CMP0114 NEW) +endif() + +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() + +# Ensure that the include dir already exists at configure time (to avoid cmake erroring +# on non-existent include dirs) +file(MAKE_DIRECTORY "${ANTLR4_INCLUDE_DIRS}") + +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.12.0.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} + -DDISABLE_WARNINGS:BOOL=ON + # -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} + -DDISABLE_WARNINGS:BOOL=ON + # -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}) +target_include_directories(antlr4_static + INTERFACE + ${ANTLR4_INCLUDE_DIRS} +) + +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}) +target_include_directories(antlr4_shared + INTERFACE + ${ANTLR4_INCLUDE_DIRS} +) + +if(ANTLR4_SHARED_LIBRARIES) + set_target_properties(antlr4_shared PROPERTIES + IMPORTED_IMPLIB ${ANTLR4_SHARED_LIBRARIES}) +endif() diff --git a/server/pkg/antlr/cmake/FindANTLR.cmake b/server/pkg/antlr/cmake/FindANTLR.cmake new file mode 100644 index 0000000000000000000000000000000000000000..0ac8f8c79f939621c3a9405e51e0fa0648109107 --- /dev/null +++ b/server/pkg/antlr/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.12.0-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/server/pkg/antlr/cmake/antlr4-generator.cmake.in b/server/pkg/antlr/cmake/antlr4-generator.cmake.in new file mode 100644 index 0000000000000000000000000000000000000000..63996514b0de9d619946f11b90585f8e0ecf7d95 --- /dev/null +++ b/server/pkg/antlr/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/server/pkg/antlr/cmake/antlr4-runtime.cmake.in b/server/pkg/antlr/cmake/antlr4-runtime.cmake.in new file mode 100644 index 0000000000000000000000000000000000000000..697b36c628172d5439476c4e28b67ea1fa64ca26 --- /dev/null +++ b/server/pkg/antlr/cmake/antlr4-runtime.cmake.in @@ -0,0 +1,13 @@ +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(CMakeFindDependencyMacro) +find_dependency(Threads) + +include(${CMAKE_CURRENT_LIST_DIR}/@targets_export_name@.cmake) + +check_required_components(antlr) diff --git a/server/pkg/antlr/cpp14/CMakeLists.txt b/server/pkg/antlr/cpp14/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..c8834799ef847c8dac739f2eb577f51ddb92c70e --- /dev/null +++ b/server/pkg/antlr/cpp14/CMakeLists.txt @@ -0,0 +1,20 @@ +cmake_minimum_required(VERSION 3.7) +project(cpp_antlr_lib) + +file(GLOB SOURCES ./src/*.cpp) +file(GLOB INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/include ${CMAKE_CURRENT_SOURCE_DIR}/../virtual) + + +include_directories(${INCLUDE_DIRS}) +add_library(${PROJECT_NAME} ${SOURCES}) + + +target_link_libraries(${PROJECT_NAME} antlr4_static Threads::Threads) + +set(CPP_ANTLR_LIBRARY ${PROJECT_NAME}) +set(CPP_ANTLR_LIBRARY ${CPP_ANTLR_LIBRARY} PARENT_SCOPE) + +set(CPP_ANTLR_INCLUDE_DIRS ${INCLUDE_DIRS}) +set(CPP_ANTLR_INCLUDE_DIRS ${CPP_ANTLR_INCLUDE_DIRS} PARENT_SCOPE) + +message("CPP_ANTLR = ${CPP_ANTLR_INCLUDE_DIRS} ") \ No newline at end of file diff --git a/server/pkg/antlr/cpp14/CPP14Lexer.g4 b/server/pkg/antlr/cpp14/CPP14Lexer.g4 new file mode 100644 index 0000000000000000000000000000000000000000..860e6d20c0c0d7774707bd9d10ad1cb8d53fa5b7 --- /dev/null +++ b/server/pkg/antlr/cpp14/CPP14Lexer.g4 @@ -0,0 +1,409 @@ +lexer grammar CPP14Lexer; + +IntegerLiteral: + DecimalLiteral Integersuffix? + | OctalLiteral Integersuffix? + | HexadecimalLiteral Integersuffix? + | BinaryLiteral Integersuffix?; + +CharacterLiteral: + ('u' | 'U' | 'L')? '\'' Cchar+ '\''; + +FloatingLiteral: + Fractionalconstant Exponentpart? Floatingsuffix? + | Digitsequence Exponentpart Floatingsuffix?; + +StringLiteral: + Encodingprefix? + (Rawstring + |'"' Schar* '"'); + +BooleanLiteral: False_ | True_; + +PointerLiteral: Nullptr; + +UserDefinedLiteral: + UserDefinedIntegerLiteral + | UserDefinedFloatingLiteral + | UserDefinedStringLiteral + | UserDefinedCharacterLiteral; + +MultiLineMacro: + '#' (~[\n]*? '\\' '\r'? '\n')+ ~ [\n]+ -> channel (HIDDEN); + +Directive: '#' ~ [\n]* -> channel (HIDDEN); +/*Keywords*/ + +Alignas: 'alignas'; + +Alignof: 'alignof'; + +Asm: 'asm'; + +Auto: 'auto'; + +Bool: 'bool'; + +Break: 'break'; + +Case: 'case'; + +Catch: 'catch'; + +Char: 'char'; + +Char16: 'char16_t'; + +Char32: 'char32_t'; + +Class: 'class'; + +Const: 'const'; + +Constexpr: 'constexpr'; + +Const_cast: 'const_cast'; + +Continue: 'continue'; + +Decltype: 'decltype'; + +Default: 'default'; + +Delete: 'delete'; + +Do: 'do'; + +Double: 'double'; + +Dynamic_cast: 'dynamic_cast'; + +Else: 'else'; + +Enum: 'enum'; + +Explicit: 'explicit'; + +Export: 'export'; + +Extern: 'extern'; + +//DO NOT RENAME - PYTHON NEEDS True and False +False_: 'false'; + +Final: 'final'; + +Float: 'float'; + +For: 'for'; + +Friend: 'friend'; + +Goto: 'goto'; + +If: 'if'; + +Inline: 'inline'; + +Int: 'int'; + +Long: 'long'; + +Mutable: 'mutable'; + +Namespace: 'namespace'; + +New: 'new'; + +Noexcept: 'noexcept'; + +Nullptr: 'nullptr'; + +Operator: 'operator'; + +Override: 'override'; + +Private: 'private'; + +Protected: 'protected'; + +Public: 'public'; + +Register: 'register'; + +Reinterpret_cast: 'reinterpret_cast'; + +Return: 'return'; + +Short: 'short'; + +Signed: 'signed'; + +Sizeof: 'sizeof'; + +Static: 'static'; + +Static_assert: 'static_assert'; + +Static_cast: 'static_cast'; + +Struct: 'struct'; + +Switch: 'switch'; + +Template: 'template'; + +This: 'this'; + +Thread_local: 'thread_local'; + +Throw: 'throw'; + +//DO NOT RENAME - PYTHON NEEDS True and False +True_: 'true'; + +Try: 'try'; + +Typedef: 'typedef'; + +Typeid_: 'typeid'; + +Typename_: 'typename'; + +Union: 'union'; + +Unsigned: 'unsigned'; + +Using: 'using'; + +Virtual: 'virtual'; + +Void: 'void'; + +Volatile: 'volatile'; + +Wchar: 'wchar_t'; + +While: 'while'; +/*Operators*/ + +LeftParen: '('; + +RightParen: ')'; + +LeftBracket: '['; + +RightBracket: ']'; + +LeftBrace: '{'; + +RightBrace: '}'; + +Plus: '+'; + +Minus: '-'; + +Star: '*'; + +Div: '/'; + +Mod: '%'; + +Caret: '^'; + +And: '&'; + +Or: '|'; + +Tilde: '~'; + +Not: '!' | 'not'; + +Assign: '='; + +Less: '<'; + +Greater: '>'; + +PlusAssign: '+='; + +MinusAssign: '-='; + +StarAssign: '*='; + +DivAssign: '/='; + +ModAssign: '%='; + +XorAssign: '^='; + +AndAssign: '&='; + +OrAssign: '|='; + +LeftShiftAssign: '<<='; + +RightShiftAssign: '>>='; + +Equal: '=='; + +NotEqual: '!='; + +LessEqual: '<='; + +GreaterEqual: '>='; + +AndAnd: '&&' | 'and'; + +OrOr: '||' | 'or'; + +PlusPlus: '++'; + +MinusMinus: '--'; + +Comma: ','; + +ArrowStar: '->*'; + +Arrow: '->'; + +Question: '?'; + +Colon: ':'; + +Doublecolon: '::'; + +Semi: ';'; + +Dot: '.'; + +DotStar: '.*'; + +Ellipsis: '...'; + +fragment Hexquad: + HEXADECIMALDIGIT HEXADECIMALDIGIT HEXADECIMALDIGIT HEXADECIMALDIGIT; + +fragment Universalcharactername: + '\\u' Hexquad + | '\\U' Hexquad Hexquad; + +Identifier: + /* + Identifiernondigit | Identifier Identifiernondigit | Identifier DIGIT + */ + Identifiernondigit (Identifiernondigit | DIGIT)*; + +fragment Identifiernondigit: NONDIGIT | Universalcharactername; + +fragment NONDIGIT: [a-zA-Z_]; + +fragment DIGIT: [0-9]; + +DecimalLiteral: NONZERODIGIT ('\''? DIGIT)*; + +OctalLiteral: '0' ('\''? OCTALDIGIT)*; + +HexadecimalLiteral: ('0x' | '0X') HEXADECIMALDIGIT ( + '\''? HEXADECIMALDIGIT + )*; + +BinaryLiteral: ('0b' | '0B') BINARYDIGIT ('\''? BINARYDIGIT)*; + +fragment NONZERODIGIT: [1-9]; + +fragment OCTALDIGIT: [0-7]; + +fragment HEXADECIMALDIGIT: [0-9a-fA-F]; + +fragment BINARYDIGIT: [01]; + +Integersuffix: + Unsignedsuffix Longsuffix? + | Unsignedsuffix Longlongsuffix? + | Longsuffix Unsignedsuffix? + | Longlongsuffix Unsignedsuffix?; + +fragment Unsignedsuffix: [uU]; + +fragment Longsuffix: [lL]; + +fragment Longlongsuffix: 'll' | 'LL'; + +fragment Cchar: + ~ ['\\\r\n] + | Escapesequence + | Universalcharactername; + +fragment Escapesequence: + Simpleescapesequence + | Octalescapesequence + | Hexadecimalescapesequence; + +fragment Simpleescapesequence: + '\\\'' + | '\\"' + | '\\?' + | '\\\\' + | '\\a' + | '\\b' + | '\\f' + | '\\n' + | '\\r' + | ('\\' ('\r' '\n'? | '\n')) + | '\\t' + | '\\v'; + +fragment Octalescapesequence: + '\\' OCTALDIGIT + | '\\' OCTALDIGIT OCTALDIGIT + | '\\' OCTALDIGIT OCTALDIGIT OCTALDIGIT; + +fragment Hexadecimalescapesequence: '\\x' HEXADECIMALDIGIT+; + +fragment Fractionalconstant: + Digitsequence? '.' Digitsequence + | Digitsequence '.'; + +fragment Exponentpart: + 'e' SIGN? Digitsequence + | 'E' SIGN? Digitsequence; + +fragment SIGN: [+-]; + +fragment Digitsequence: DIGIT ('\''? DIGIT)*; + +fragment Floatingsuffix: [flFL]; + +fragment Encodingprefix: 'u8' | 'u' | 'U' | 'L'; + +fragment Schar: + ~ ["\\\r\n] + | Escapesequence + | Universalcharactername; + +fragment Rawstring: 'R"' (( '\\' ["()] )|~[\r\n (])*? '(' ~[)]*? ')' (( '\\' ["()]) | ~[\r\n "])*? '"'; + +UserDefinedIntegerLiteral: + DecimalLiteral Udsuffix + | OctalLiteral Udsuffix + | HexadecimalLiteral Udsuffix + | BinaryLiteral Udsuffix; + +UserDefinedFloatingLiteral: + Fractionalconstant Exponentpart? Udsuffix + | Digitsequence Exponentpart Udsuffix; + +UserDefinedStringLiteral: StringLiteral Udsuffix; + +UserDefinedCharacterLiteral: CharacterLiteral Udsuffix; + +fragment Udsuffix: Identifier; + +Whitespace: [ \t]+ -> skip; + +Newline: ('\r' '\n'? | '\n') -> skip; + +BlockComment: '/*' .*? '*/' -> skip; + +LineComment: '//' ~ [\r\n]* -> skip; diff --git a/server/pkg/antlr/cpp14/CPP14Parser.g4 b/server/pkg/antlr/cpp14/CPP14Parser.g4 new file mode 100644 index 0000000000000000000000000000000000000000..6c4d84854407b31a5f2a8aebf556da49e3c134fc --- /dev/null +++ b/server/pkg/antlr/cpp14/CPP14Parser.g4 @@ -0,0 +1,823 @@ +/******************************************************************************* + * The MIT License (MIT) + * + * Copyright (c) 2015 Camilo Sanchez (Camiloasc1) 2020 Martin Mirchev (Marti2203) + * + * 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. + * **************************************************************************** + */ +parser grammar CPP14Parser; +options { + tokenVocab = CPP14Lexer; +} +/*Basic concepts*/ + +translationUnit: declarationseq? EOF; +/*Expressions*/ + +primaryExpression: + literal+ + | This + | LeftParen expression RightParen + | idExpression + | lambdaExpression; + +idExpression: unqualifiedId | qualifiedId; + +unqualifiedId: + Identifier + | operatorFunctionId + | conversionFunctionId + | literalOperatorId + | Tilde (className | decltypeSpecifier) + | templateId; + +qualifiedId: nestedNameSpecifier Template? unqualifiedId; + +nestedNameSpecifier: + (theTypeName | namespaceName | decltypeSpecifier)? Doublecolon + | nestedNameSpecifier ( + Identifier + | Template? simpleTemplateId + ) Doublecolon; +lambdaExpression: + lambdaIntroducer lambdaDeclarator? compoundStatement; + +lambdaIntroducer: LeftBracket lambdaCapture? RightBracket; + +lambdaCapture: + captureList + | captureDefault (Comma captureList)?; + +captureDefault: And | Assign; + +captureList: capture (Comma capture)* Ellipsis?; + +capture: simpleCapture | initcapture; + +simpleCapture: And? Identifier | This; + +initcapture: And? Identifier initializer; + +lambdaDeclarator: + LeftParen parameterDeclarationClause? RightParen Mutable? exceptionSpecification? + attributeSpecifierSeq? trailingReturnType?; + +postfixExpression: + primaryExpression + | postfixExpression LeftBracket (expression | bracedInitList) RightBracket + | postfixExpression LeftParen expressionList? RightParen + | (simpleTypeSpecifier | typeNameSpecifier) ( + LeftParen expressionList? RightParen + | bracedInitList + ) + | postfixExpression (Dot | Arrow) ( + Template? idExpression + | pseudoDestructorName + ) + | postfixExpression (PlusPlus | MinusMinus) + | ( + Dynamic_cast + | Static_cast + | Reinterpret_cast + | Const_cast + ) Less theTypeId Greater LeftParen expression RightParen + | typeIdOfTheTypeId LeftParen (expression | theTypeId) RightParen; +/* + add a middle layer to eliminate duplicated function declarations + */ + +typeIdOfTheTypeId: Typeid_; + +expressionList: initializerList; + +pseudoDestructorName: + nestedNameSpecifier? (theTypeName Doublecolon)? Tilde theTypeName + | nestedNameSpecifier Template simpleTemplateId Doublecolon Tilde theTypeName + | Tilde decltypeSpecifier; + +unaryExpression: + postfixExpression + | (PlusPlus | MinusMinus | unaryOperator | Sizeof) unaryExpression + | Sizeof ( + LeftParen theTypeId RightParen + | Ellipsis LeftParen Identifier RightParen + ) + | Alignof LeftParen theTypeId RightParen + | noExceptExpression + | newExpression + | deleteExpression; + +unaryOperator: Or | Star | And | Plus | Tilde | Minus | Not; + +newExpression: + Doublecolon? New newPlacement? ( + newTypeId + | (LeftParen theTypeId RightParen) + ) newInitializer?; + +newPlacement: LeftParen expressionList RightParen; + +newTypeId: typeSpecifierSeq newDeclarator?; + +newDeclarator: + pointerOperator newDeclarator? + | noPointerNewDeclarator; + +noPointerNewDeclarator: + LeftBracket expression RightBracket attributeSpecifierSeq? + | noPointerNewDeclarator LeftBracket constantExpression RightBracket attributeSpecifierSeq?; + +newInitializer: + LeftParen expressionList? RightParen + | bracedInitList; + +deleteExpression: + Doublecolon? Delete (LeftBracket RightBracket)? castExpression; + +noExceptExpression: Noexcept LeftParen expression RightParen; + +castExpression: + unaryExpression + | LeftParen theTypeId RightParen castExpression; + +pointerMemberExpression: + castExpression ((DotStar | ArrowStar) castExpression)*; + +multiplicativeExpression: + pointerMemberExpression ( + (Star | Div | Mod) pointerMemberExpression + )*; + +additiveExpression: + multiplicativeExpression ( + (Plus | Minus) multiplicativeExpression + )*; + +shiftExpression: + additiveExpression (shiftOperator additiveExpression)*; + +shiftOperator: Greater Greater | Less Less; + +relationalExpression: + shiftExpression ( + (Less | Greater | LessEqual | GreaterEqual) shiftExpression + )*; + +equalityExpression: + relationalExpression ( + (Equal | NotEqual) relationalExpression + )*; + +andExpression: equalityExpression (And equalityExpression)*; + +exclusiveOrExpression: andExpression (Caret andExpression)*; + +inclusiveOrExpression: + exclusiveOrExpression (Or exclusiveOrExpression)*; + +logicalAndExpression: + inclusiveOrExpression (AndAnd inclusiveOrExpression)*; + +logicalOrExpression: + logicalAndExpression (OrOr logicalAndExpression)*; + +conditionalExpression: + logicalOrExpression ( + Question expression Colon assignmentExpression + )?; + +assignmentExpression: + conditionalExpression + | logicalOrExpression assignmentOperator initializerClause + | throwExpression; + +assignmentOperator: + Assign + | StarAssign + | DivAssign + | ModAssign + | PlusAssign + | MinusAssign + | RightShiftAssign + | LeftShiftAssign + | AndAssign + | XorAssign + | OrAssign; + +expression: assignmentExpression (Comma assignmentExpression)*; + +constantExpression: conditionalExpression; +/*Statements*/ + +statement: + labeledStatement + | declarationStatement + | attributeSpecifierSeq? ( + expressionStatement + | compoundStatement + | selectionStatement + | iterationStatement + | jumpStatement + | tryBlock + ); + +labeledStatement: + attributeSpecifierSeq? ( + Identifier + | Case constantExpression + | Default + ) Colon statement; + +expressionStatement: expression? Semi; + +compoundStatement: LeftBrace statementSeq? RightBrace; + +statementSeq: statement+; + +selectionStatement: + If LeftParen condition RightParen statement (Else statement)? + | Switch LeftParen condition RightParen statement; + +condition: + expression + | attributeSpecifierSeq? declSpecifierSeq declarator ( + Assign initializerClause + | bracedInitList + ); + +iterationStatement: + While LeftParen condition RightParen statement + | Do statement While LeftParen expression RightParen Semi + | For LeftParen ( + forInitStatement condition? Semi expression? + | forRangeDeclaration Colon forRangeInitializer + ) RightParen statement; + +forInitStatement: expressionStatement | simpleDeclaration; + +forRangeDeclaration: + attributeSpecifierSeq? declSpecifierSeq declarator; + +forRangeInitializer: expression | bracedInitList; + +jumpStatement: + ( + Break + | Continue + | Return (expression | bracedInitList)? + | Goto Identifier + ) Semi; + +declarationStatement: blockDeclaration; +/*Declarations*/ + +declarationseq: declaration+; + +declaration: + blockDeclaration + | functionDefinition + | templateDeclaration + | explicitInstantiation + | explicitSpecialization + | linkageSpecification + | namespaceDefinition + | emptyDeclaration + | attributeDeclaration; + +blockDeclaration: + simpleDeclaration + | asmDefinition + | namespaceAliasDefinition + | usingDeclaration + | usingDirective + | staticAssertDeclaration + | aliasDeclaration + | opaqueEnumDeclaration; + +aliasDeclaration: + Using Identifier attributeSpecifierSeq? Assign theTypeId Semi; + +simpleDeclaration: + declSpecifierSeq? initDeclaratorList? Semi + | attributeSpecifierSeq declSpecifierSeq? initDeclaratorList Semi; + +staticAssertDeclaration: + Static_assert LeftParen constantExpression Comma StringLiteral RightParen Semi; + +emptyDeclaration: Semi; + +attributeDeclaration: attributeSpecifierSeq Semi; + +declSpecifier: + storageClassSpecifier + | typeSpecifier + | functionSpecifier + | Friend + | Typedef + | Constexpr; + +declSpecifierSeq: declSpecifier+? attributeSpecifierSeq?; + +storageClassSpecifier: + Register + | Static + | Thread_local + | Extern + | Mutable; + +functionSpecifier: Inline | Virtual | Explicit; + +typedefName: Identifier; + +typeSpecifier: + trailingTypeSpecifier + | classSpecifier + | enumSpecifier; + +trailingTypeSpecifier: + simpleTypeSpecifier + | elaboratedTypeSpecifier + | typeNameSpecifier + | cvQualifier; + +typeSpecifierSeq: typeSpecifier+ attributeSpecifierSeq?; + +trailingTypeSpecifierSeq: + trailingTypeSpecifier+ attributeSpecifierSeq?; + +simpleTypeLengthModifier: + Short + | Long; + +simpleTypeSignednessModifier: + Unsigned + | Signed; + +simpleTypeSpecifier: + nestedNameSpecifier? theTypeName + | nestedNameSpecifier Template simpleTemplateId + | simpleTypeSignednessModifier + | simpleTypeSignednessModifier? simpleTypeLengthModifier+ + | simpleTypeSignednessModifier? Char + | simpleTypeSignednessModifier? Char16 + | simpleTypeSignednessModifier? Char32 + | simpleTypeSignednessModifier? Wchar + | Bool + | simpleTypeSignednessModifier? simpleTypeLengthModifier* Int + | Float + | simpleTypeLengthModifier? Double + | Void + | Auto + | decltypeSpecifier; + +theTypeName: + className + | enumName + | typedefName + | simpleTemplateId; + +decltypeSpecifier: + Decltype LeftParen (expression | Auto) RightParen; + +elaboratedTypeSpecifier: + classKey ( + attributeSpecifierSeq? nestedNameSpecifier? Identifier + | simpleTemplateId + | nestedNameSpecifier Template? simpleTemplateId + ) + | Enum nestedNameSpecifier? Identifier; + +enumName: Identifier; + +enumSpecifier: + enumHead LeftBrace (enumeratorList Comma?)? RightBrace; + +enumHead: + enumkey attributeSpecifierSeq? ( + nestedNameSpecifier? Identifier + )? enumbase?; + +opaqueEnumDeclaration: + enumkey attributeSpecifierSeq? Identifier enumbase? Semi; + +enumkey: Enum (Class | Struct)?; + +enumbase: Colon typeSpecifierSeq; + +enumeratorList: + enumeratorDefinition (Comma enumeratorDefinition)*; + +enumeratorDefinition: enumerator (Assign constantExpression)?; + +enumerator: Identifier; + +namespaceName: originalNamespaceName | namespaceAlias; + +originalNamespaceName: Identifier; + +namespaceDefinition: + Inline? Namespace (Identifier | originalNamespaceName)? LeftBrace namespaceBody = declarationseq + ? RightBrace; + +namespaceAlias: Identifier; + +namespaceAliasDefinition: + Namespace Identifier Assign qualifiednamespacespecifier Semi; + +qualifiednamespacespecifier: nestedNameSpecifier? namespaceName; + +usingDeclaration: + Using ((Typename_? nestedNameSpecifier) | Doublecolon) unqualifiedId Semi; + +usingDirective: + attributeSpecifierSeq? Using Namespace nestedNameSpecifier? namespaceName Semi; + +asmDefinition: Asm LeftParen StringLiteral RightParen Semi; + +linkageSpecification: + Extern StringLiteral ( + LeftBrace declarationseq? RightBrace + | declaration + ); + +attributeSpecifierSeq: attributeSpecifier+; + +attributeSpecifier: + LeftBracket LeftBracket attributeList? RightBracket RightBracket + | alignmentspecifier; + +alignmentspecifier: + Alignas LeftParen (theTypeId | constantExpression) Ellipsis? RightParen; + +attributeList: attribute (Comma attribute)* Ellipsis?; + +attribute: (attributeNamespace Doublecolon)? Identifier attributeArgumentClause?; + +attributeNamespace: Identifier; + +attributeArgumentClause: LeftParen balancedTokenSeq? RightParen; + +balancedTokenSeq: balancedtoken+; + +balancedtoken: + LeftParen balancedTokenSeq RightParen + | LeftBracket balancedTokenSeq RightBracket + | LeftBrace balancedTokenSeq RightBrace + | ~( + LeftParen + | RightParen + | LeftBrace + | RightBrace + | LeftBracket + | RightBracket + )+; +/*Declarators*/ + +initDeclaratorList: initDeclarator (Comma initDeclarator)*; + +initDeclarator: declarator initializer?; + +declarator: + pointerDeclarator + | noPointerDeclarator parametersAndQualifiers trailingReturnType; + +pointerDeclarator: (pointerOperator Const?)* noPointerDeclarator; + +noPointerDeclarator: + declaratorid attributeSpecifierSeq? + | noPointerDeclarator ( + parametersAndQualifiers + | LeftBracket constantExpression? RightBracket attributeSpecifierSeq? + ) + | LeftParen pointerDeclarator RightParen; + +parametersAndQualifiers: + LeftParen parameterDeclarationClause? RightParen cvqualifierseq? refqualifier? + exceptionSpecification? attributeSpecifierSeq?; + +trailingReturnType: + Arrow trailingTypeSpecifierSeq abstractDeclarator?; + +pointerOperator: + (And | AndAnd) attributeSpecifierSeq? + | nestedNameSpecifier? Star attributeSpecifierSeq? cvqualifierseq?; + +cvqualifierseq: cvQualifier+; + +cvQualifier: Const | Volatile; + +refqualifier: And | AndAnd; + +declaratorid: Ellipsis? idExpression; + +theTypeId: typeSpecifierSeq abstractDeclarator?; + +abstractDeclarator: + pointerAbstractDeclarator + | noPointerAbstractDeclarator? parametersAndQualifiers trailingReturnType + | abstractPackDeclarator; + +pointerAbstractDeclarator: + noPointerAbstractDeclarator + | pointerOperator+ noPointerAbstractDeclarator?; + +noPointerAbstractDeclarator: + noPointerAbstractDeclarator ( + parametersAndQualifiers + | noPointerAbstractDeclarator LeftBracket constantExpression? RightBracket + attributeSpecifierSeq? + ) + | parametersAndQualifiers + | LeftBracket constantExpression? RightBracket attributeSpecifierSeq? + | LeftParen pointerAbstractDeclarator RightParen; + +abstractPackDeclarator: + pointerOperator* noPointerAbstractPackDeclarator; + +noPointerAbstractPackDeclarator: + noPointerAbstractPackDeclarator ( + parametersAndQualifiers + | LeftBracket constantExpression? RightBracket attributeSpecifierSeq? + ) + | Ellipsis; + +parameterDeclarationClause: + parameterDeclarationList (Comma? Ellipsis)?; + +parameterDeclarationList: + parameterDeclaration (Comma parameterDeclaration)*; + +parameterDeclaration: + attributeSpecifierSeq? declSpecifierSeq ( + (declarator | abstractDeclarator?) ( + Assign initializerClause + )? + ); + +functionDefinition: + attributeSpecifierSeq? declSpecifierSeq? declarator virtualSpecifierSeq? functionBody; + +functionBody: + constructorInitializer? compoundStatement + | functionTryBlock + | Assign (Default | Delete) Semi; + +initializer: + braceOrEqualInitializer + | LeftParen expressionList RightParen; + +braceOrEqualInitializer: + Assign initializerClause + | bracedInitList; + +initializerClause: assignmentExpression | bracedInitList; + +initializerList: + initializerClause Ellipsis? ( + Comma initializerClause Ellipsis? + )*; + +bracedInitList: LeftBrace (initializerList Comma?)? RightBrace; +/*Classes*/ + +className: Identifier | simpleTemplateId; + +classSpecifier: + classHead LeftBrace memberSpecification? RightBrace; + +classHead: + classKey attributeSpecifierSeq? ( + classHeadName classVirtSpecifier? + )? baseClause? + | Union attributeSpecifierSeq? ( + classHeadName classVirtSpecifier? + )?; + +classHeadName: nestedNameSpecifier? className; + +classVirtSpecifier: Final; + +classKey: Class | Struct; + +memberSpecification: + (memberdeclaration | accessSpecifier Colon)+; + +memberdeclaration: + attributeSpecifierSeq? declSpecifierSeq? memberDeclaratorList? Semi + | functionDefinition + | usingDeclaration + | staticAssertDeclaration + | templateDeclaration + | aliasDeclaration + | emptyDeclaration; + +memberDeclaratorList: + memberDeclarator (Comma memberDeclarator)*; + +memberDeclarator: + declarator ( + virtualSpecifierSeq? pureSpecifier? + | braceOrEqualInitializer? + ) + | Identifier? attributeSpecifierSeq? Colon constantExpression; + +virtualSpecifierSeq: virtualSpecifier+; + +virtualSpecifier: Override | Final; +/* + purespecifier: Assign '0'//Conflicts with the lexer ; + */ + +pureSpecifier: + Assign val = OctalLiteral {if($val.text.compareTo("0")!=0) throw new InputMismatchException(this); + }; +/*Derived classes*/ + +baseClause: Colon baseSpecifierList; + +baseSpecifierList: + baseSpecifier Ellipsis? (Comma baseSpecifier Ellipsis?)*; + +baseSpecifier: + attributeSpecifierSeq? ( + baseTypeSpecifier + | Virtual accessSpecifier? baseTypeSpecifier + | accessSpecifier Virtual? baseTypeSpecifier + ); + +classOrDeclType: + nestedNameSpecifier? className + | decltypeSpecifier; + +baseTypeSpecifier: classOrDeclType; + +accessSpecifier: Private | Protected | Public; +/*Special member functions*/ + +conversionFunctionId: Operator conversionTypeId; + +conversionTypeId: typeSpecifierSeq conversionDeclarator?; + +conversionDeclarator: pointerOperator conversionDeclarator?; + +constructorInitializer: Colon memInitializerList; + +memInitializerList: + memInitializer Ellipsis? (Comma memInitializer Ellipsis?)*; + +memInitializer: + meminitializerid ( + LeftParen expressionList? RightParen + | bracedInitList + ); + +meminitializerid: classOrDeclType | Identifier; +/*Overloading*/ + +operatorFunctionId: Operator theOperator; + +literalOperatorId: + Operator ( + StringLiteral Identifier + | UserDefinedStringLiteral + ); +/*Templates*/ + +templateDeclaration: + Template Less templateparameterList Greater declaration; + +templateparameterList: + templateParameter (Comma templateParameter)*; + +templateParameter: typeParameter | parameterDeclaration; + +typeParameter: + ( + (Template Less templateparameterList Greater)? Class + | Typename_ + ) ((Ellipsis? Identifier?) | (Identifier? Assign theTypeId)); + +simpleTemplateId: + templateName Less templateArgumentList? Greater; + +templateId: + simpleTemplateId + | (operatorFunctionId | literalOperatorId) Less templateArgumentList? Greater; + +templateName: Identifier; + +templateArgumentList: + templateArgument Ellipsis? (Comma templateArgument Ellipsis?)*; + +templateArgument: theTypeId | constantExpression | idExpression; + +typeNameSpecifier: + Typename_ nestedNameSpecifier ( + Identifier + | Template? simpleTemplateId + ); + +explicitInstantiation: Extern? Template declaration; + +explicitSpecialization: Template Less Greater declaration; +/*Exception handling*/ + +tryBlock: Try compoundStatement handlerSeq; + +functionTryBlock: + Try constructorInitializer? compoundStatement handlerSeq; + +handlerSeq: handler+; + +handler: + Catch LeftParen exceptionDeclaration RightParen compoundStatement; + +exceptionDeclaration: + attributeSpecifierSeq? typeSpecifierSeq ( + declarator + | abstractDeclarator + )? + | Ellipsis; + +throwExpression: Throw assignmentExpression?; + +exceptionSpecification: + dynamicExceptionSpecification + | noeExceptSpecification; + +dynamicExceptionSpecification: + Throw LeftParen typeIdList? RightParen; + +typeIdList: theTypeId Ellipsis? (Comma theTypeId Ellipsis?)*; + +noeExceptSpecification: + Noexcept LeftParen constantExpression RightParen + | Noexcept; +/*Preprocessing directives*/ + +/*Lexer*/ + +theOperator: + New (LeftBracket RightBracket)? + | Delete (LeftBracket RightBracket)? + | Plus + | Minus + | Star + | Div + | Mod + | Caret + | And + | Or + | Tilde + | Not + | Assign + | Greater + | Less + | GreaterEqual + | PlusAssign + | MinusAssign + | StarAssign + | ModAssign + | XorAssign + | AndAssign + | OrAssign + | Less Less + | Greater Greater + | RightShiftAssign + | LeftShiftAssign + | Equal + | NotEqual + | LessEqual + | AndAnd + | OrOr + | PlusPlus + | MinusMinus + | Comma + | ArrowStar + | Arrow + | LeftParen RightParen + | LeftBracket RightBracket; + +literal: + IntegerLiteral + | CharacterLiteral + | FloatingLiteral + | StringLiteral + | BooleanLiteral + | PointerLiteral + | UserDefinedLiteral; + diff --git a/server/pkg/antlr/cpp14/include/CPP14Lexer.h b/server/pkg/antlr/cpp14/include/CPP14Lexer.h new file mode 100644 index 0000000000000000000000000000000000000000..d8f3103ba98396708a075e58e54f8f11d4afc85a --- /dev/null +++ b/server/pkg/antlr/cpp14/include/CPP14Lexer.h @@ -0,0 +1,79 @@ + +// Generated from CPP14Lexer.g4 by ANTLR 4.12.0 + +#pragma once + + +#include "antlr4-runtime.h" + + +namespace antlrcpptest { + + +class CPP14Lexer : public antlr4::Lexer { +public: + enum { + IntegerLiteral = 1, CharacterLiteral = 2, FloatingLiteral = 3, StringLiteral = 4, + BooleanLiteral = 5, PointerLiteral = 6, UserDefinedLiteral = 7, MultiLineMacro = 8, + Directive = 9, Alignas = 10, Alignof = 11, Asm = 12, Auto = 13, Bool = 14, + Break = 15, Case = 16, Catch = 17, Char = 18, Char16 = 19, Char32 = 20, + Class = 21, Const = 22, Constexpr = 23, Const_cast = 24, Continue = 25, + Decltype = 26, Default = 27, Delete = 28, Do = 29, Double = 30, Dynamic_cast = 31, + Else = 32, Enum = 33, Explicit = 34, Export = 35, Extern = 36, False_ = 37, + Final = 38, Float = 39, For = 40, Friend = 41, Goto = 42, If = 43, Inline = 44, + Int = 45, Long = 46, Mutable = 47, Namespace = 48, New = 49, Noexcept = 50, + Nullptr = 51, Operator = 52, Override = 53, Private = 54, Protected = 55, + Public = 56, Register = 57, Reinterpret_cast = 58, Return = 59, Short = 60, + Signed = 61, Sizeof = 62, Static = 63, Static_assert = 64, Static_cast = 65, + Struct = 66, Switch = 67, Template = 68, This = 69, Thread_local = 70, + Throw = 71, True_ = 72, Try = 73, Typedef = 74, Typeid_ = 75, Typename_ = 76, + Union = 77, Unsigned = 78, Using = 79, Virtual = 80, Void = 81, Volatile = 82, + Wchar = 83, While = 84, LeftParen = 85, RightParen = 86, LeftBracket = 87, + RightBracket = 88, LeftBrace = 89, RightBrace = 90, Plus = 91, Minus = 92, + Star = 93, Div = 94, Mod = 95, Caret = 96, And = 97, Or = 98, Tilde = 99, + Not = 100, Assign = 101, Less = 102, Greater = 103, PlusAssign = 104, + MinusAssign = 105, StarAssign = 106, DivAssign = 107, ModAssign = 108, + XorAssign = 109, AndAssign = 110, OrAssign = 111, LeftShiftAssign = 112, + RightShiftAssign = 113, Equal = 114, NotEqual = 115, LessEqual = 116, + GreaterEqual = 117, AndAnd = 118, OrOr = 119, PlusPlus = 120, MinusMinus = 121, + Comma = 122, ArrowStar = 123, Arrow = 124, Question = 125, Colon = 126, + Doublecolon = 127, Semi = 128, Dot = 129, DotStar = 130, Ellipsis = 131, + Identifier = 132, DecimalLiteral = 133, OctalLiteral = 134, HexadecimalLiteral = 135, + BinaryLiteral = 136, Integersuffix = 137, UserDefinedIntegerLiteral = 138, + UserDefinedFloatingLiteral = 139, UserDefinedStringLiteral = 140, UserDefinedCharacterLiteral = 141, + Whitespace = 142, Newline = 143, BlockComment = 144, LineComment = 145 + }; + + explicit CPP14Lexer(antlr4::CharStream *input); + + ~CPP14Lexer() override; + + + std::string getGrammarFileName() const override; + + const std::vector& getRuleNames() const override; + + const std::vector& getChannelNames() const override; + + const std::vector& getModeNames() const override; + + const antlr4::dfa::Vocabulary& getVocabulary() const override; + + antlr4::atn::SerializedATNView getSerializedATN() const override; + + const antlr4::atn::ATN& getATN() const override; + + // By default the static state used to implement the lexer is lazily initialized during the first + // call to the constructor. You can call this function if you wish to initialize the static state + // ahead of time. + static void initialize(); + +private: + + // Individual action functions triggered by action() above. + + // Individual semantic predicate functions triggered by sempred() above. + +}; + +} // namespace antlrcpptest diff --git a/server/pkg/antlr/cpp14/include/CPP14Parser.h b/server/pkg/antlr/cpp14/include/CPP14Parser.h new file mode 100644 index 0000000000000000000000000000000000000000..6b00d6b12169d605d9930740d31ec958471819c0 --- /dev/null +++ b/server/pkg/antlr/cpp14/include/CPP14Parser.h @@ -0,0 +1,3149 @@ + +// Generated from CPP14Parser.g4 by ANTLR 4.12.0 + +#pragma once + + +#include "antlr4-runtime.h" + + +namespace antlrcpptest { + + +class CPP14Parser : public antlr4::Parser { +public: + enum { + IntegerLiteral = 1, CharacterLiteral = 2, FloatingLiteral = 3, StringLiteral = 4, + BooleanLiteral = 5, PointerLiteral = 6, UserDefinedLiteral = 7, MultiLineMacro = 8, + Directive = 9, Alignas = 10, Alignof = 11, Asm = 12, Auto = 13, Bool = 14, + Break = 15, Case = 16, Catch = 17, Char = 18, Char16 = 19, Char32 = 20, + Class = 21, Const = 22, Constexpr = 23, Const_cast = 24, Continue = 25, + Decltype = 26, Default = 27, Delete = 28, Do = 29, Double = 30, Dynamic_cast = 31, + Else = 32, Enum = 33, Explicit = 34, Export = 35, Extern = 36, False_ = 37, + Final = 38, Float = 39, For = 40, Friend = 41, Goto = 42, If = 43, Inline = 44, + Int = 45, Long = 46, Mutable = 47, Namespace = 48, New = 49, Noexcept = 50, + Nullptr = 51, Operator = 52, Override = 53, Private = 54, Protected = 55, + Public = 56, Register = 57, Reinterpret_cast = 58, Return = 59, Short = 60, + Signed = 61, Sizeof = 62, Static = 63, Static_assert = 64, Static_cast = 65, + Struct = 66, Switch = 67, Template = 68, This = 69, Thread_local = 70, + Throw = 71, True_ = 72, Try = 73, Typedef = 74, Typeid_ = 75, Typename_ = 76, + Union = 77, Unsigned = 78, Using = 79, Virtual = 80, Void = 81, Volatile = 82, + Wchar = 83, While = 84, LeftParen = 85, RightParen = 86, LeftBracket = 87, + RightBracket = 88, LeftBrace = 89, RightBrace = 90, Plus = 91, Minus = 92, + Star = 93, Div = 94, Mod = 95, Caret = 96, And = 97, Or = 98, Tilde = 99, + Not = 100, Assign = 101, Less = 102, Greater = 103, PlusAssign = 104, + MinusAssign = 105, StarAssign = 106, DivAssign = 107, ModAssign = 108, + XorAssign = 109, AndAssign = 110, OrAssign = 111, LeftShiftAssign = 112, + RightShiftAssign = 113, Equal = 114, NotEqual = 115, LessEqual = 116, + GreaterEqual = 117, AndAnd = 118, OrOr = 119, PlusPlus = 120, MinusMinus = 121, + Comma = 122, ArrowStar = 123, Arrow = 124, Question = 125, Colon = 126, + Doublecolon = 127, Semi = 128, Dot = 129, DotStar = 130, Ellipsis = 131, + Identifier = 132, DecimalLiteral = 133, OctalLiteral = 134, HexadecimalLiteral = 135, + BinaryLiteral = 136, Integersuffix = 137, UserDefinedIntegerLiteral = 138, + UserDefinedFloatingLiteral = 139, UserDefinedStringLiteral = 140, UserDefinedCharacterLiteral = 141, + Whitespace = 142, Newline = 143, BlockComment = 144, LineComment = 145 + }; + + enum { + RuleTranslationUnit = 0, RulePrimaryExpression = 1, RuleIdExpression = 2, + RuleUnqualifiedId = 3, RuleQualifiedId = 4, RuleNestedNameSpecifier = 5, + RuleLambdaExpression = 6, RuleLambdaIntroducer = 7, RuleLambdaCapture = 8, + RuleCaptureDefault = 9, RuleCaptureList = 10, RuleCapture = 11, RuleSimpleCapture = 12, + RuleInitcapture = 13, RuleLambdaDeclarator = 14, RulePostfixExpression = 15, + RuleTypeIdOfTheTypeId = 16, RuleExpressionList = 17, RulePseudoDestructorName = 18, + RuleUnaryExpression = 19, RuleUnaryOperator = 20, RuleNewExpression = 21, + RuleNewPlacement = 22, RuleNewTypeId = 23, RuleNewDeclarator = 24, RuleNoPointerNewDeclarator = 25, + RuleNewInitializer = 26, RuleDeleteExpression = 27, RuleNoExceptExpression = 28, + RuleCastExpression = 29, RulePointerMemberExpression = 30, RuleMultiplicativeExpression = 31, + RuleAdditiveExpression = 32, RuleShiftExpression = 33, RuleShiftOperator = 34, + RuleRelationalExpression = 35, RuleEqualityExpression = 36, RuleAndExpression = 37, + RuleExclusiveOrExpression = 38, RuleInclusiveOrExpression = 39, RuleLogicalAndExpression = 40, + RuleLogicalOrExpression = 41, RuleConditionalExpression = 42, RuleAssignmentExpression = 43, + RuleAssignmentOperator = 44, RuleExpression = 45, RuleConstantExpression = 46, + RuleStatement = 47, RuleLabeledStatement = 48, RuleExpressionStatement = 49, + RuleCompoundStatement = 50, RuleStatementSeq = 51, RuleSelectionStatement = 52, + RuleCondition = 53, RuleIterationStatement = 54, RuleForInitStatement = 55, + RuleForRangeDeclaration = 56, RuleForRangeInitializer = 57, RuleJumpStatement = 58, + RuleDeclarationStatement = 59, RuleDeclarationseq = 60, RuleDeclaration = 61, + RuleBlockDeclaration = 62, RuleAliasDeclaration = 63, RuleSimpleDeclaration = 64, + RuleStaticAssertDeclaration = 65, RuleEmptyDeclaration = 66, RuleAttributeDeclaration = 67, + RuleDeclSpecifier = 68, RuleDeclSpecifierSeq = 69, RuleStorageClassSpecifier = 70, + RuleFunctionSpecifier = 71, RuleTypedefName = 72, RuleTypeSpecifier = 73, + RuleTrailingTypeSpecifier = 74, RuleTypeSpecifierSeq = 75, RuleTrailingTypeSpecifierSeq = 76, + RuleSimpleTypeLengthModifier = 77, RuleSimpleTypeSignednessModifier = 78, + RuleSimpleTypeSpecifier = 79, RuleTheTypeName = 80, RuleDecltypeSpecifier = 81, + RuleElaboratedTypeSpecifier = 82, RuleEnumName = 83, RuleEnumSpecifier = 84, + RuleEnumHead = 85, RuleOpaqueEnumDeclaration = 86, RuleEnumkey = 87, + RuleEnumbase = 88, RuleEnumeratorList = 89, RuleEnumeratorDefinition = 90, + RuleEnumerator = 91, RuleNamespaceName = 92, RuleOriginalNamespaceName = 93, + RuleNamespaceDefinition = 94, RuleNamespaceAlias = 95, RuleNamespaceAliasDefinition = 96, + RuleQualifiednamespacespecifier = 97, RuleUsingDeclaration = 98, RuleUsingDirective = 99, + RuleAsmDefinition = 100, RuleLinkageSpecification = 101, RuleAttributeSpecifierSeq = 102, + RuleAttributeSpecifier = 103, RuleAlignmentspecifier = 104, RuleAttributeList = 105, + RuleAttribute = 106, RuleAttributeNamespace = 107, RuleAttributeArgumentClause = 108, + RuleBalancedTokenSeq = 109, RuleBalancedtoken = 110, RuleInitDeclaratorList = 111, + RuleInitDeclarator = 112, RuleDeclarator = 113, RulePointerDeclarator = 114, + RuleNoPointerDeclarator = 115, RuleParametersAndQualifiers = 116, RuleTrailingReturnType = 117, + RulePointerOperator = 118, RuleCvqualifierseq = 119, RuleCvQualifier = 120, + RuleRefqualifier = 121, RuleDeclaratorid = 122, RuleTheTypeId = 123, + RuleAbstractDeclarator = 124, RulePointerAbstractDeclarator = 125, RuleNoPointerAbstractDeclarator = 126, + RuleAbstractPackDeclarator = 127, RuleNoPointerAbstractPackDeclarator = 128, + RuleParameterDeclarationClause = 129, RuleParameterDeclarationList = 130, + RuleParameterDeclaration = 131, RuleFunctionDefinition = 132, RuleFunctionBody = 133, + RuleInitializer = 134, RuleBraceOrEqualInitializer = 135, RuleInitializerClause = 136, + RuleInitializerList = 137, RuleBracedInitList = 138, RuleClassName = 139, + RuleClassSpecifier = 140, RuleClassHead = 141, RuleClassHeadName = 142, + RuleClassVirtSpecifier = 143, RuleClassKey = 144, RuleMemberSpecification = 145, + RuleMemberdeclaration = 146, RuleMemberDeclaratorList = 147, RuleMemberDeclarator = 148, + RuleVirtualSpecifierSeq = 149, RuleVirtualSpecifier = 150, RulePureSpecifier = 151, + RuleBaseClause = 152, RuleBaseSpecifierList = 153, RuleBaseSpecifier = 154, + RuleClassOrDeclType = 155, RuleBaseTypeSpecifier = 156, RuleAccessSpecifier = 157, + RuleConversionFunctionId = 158, RuleConversionTypeId = 159, RuleConversionDeclarator = 160, + RuleConstructorInitializer = 161, RuleMemInitializerList = 162, RuleMemInitializer = 163, + RuleMeminitializerid = 164, RuleOperatorFunctionId = 165, RuleLiteralOperatorId = 166, + RuleTemplateDeclaration = 167, RuleTemplateparameterList = 168, RuleTemplateParameter = 169, + RuleTypeParameter = 170, RuleSimpleTemplateId = 171, RuleTemplateId = 172, + RuleTemplateName = 173, RuleTemplateArgumentList = 174, RuleTemplateArgument = 175, + RuleTypeNameSpecifier = 176, RuleExplicitInstantiation = 177, RuleExplicitSpecialization = 178, + RuleTryBlock = 179, RuleFunctionTryBlock = 180, RuleHandlerSeq = 181, + RuleHandler = 182, RuleExceptionDeclaration = 183, RuleThrowExpression = 184, + RuleExceptionSpecification = 185, RuleDynamicExceptionSpecification = 186, + RuleTypeIdList = 187, RuleNoeExceptSpecification = 188, RuleTheOperator = 189, + RuleLiteral = 190 + }; + + explicit CPP14Parser(antlr4::TokenStream *input); + + CPP14Parser(antlr4::TokenStream *input, const antlr4::atn::ParserATNSimulatorOptions &options); + + ~CPP14Parser() override; + + std::string getGrammarFileName() const override; + + const antlr4::atn::ATN& getATN() const override; + + const std::vector& getRuleNames() const override; + + const antlr4::dfa::Vocabulary& getVocabulary() const override; + + antlr4::atn::SerializedATNView getSerializedATN() const override; + + + class TranslationUnitContext; + class PrimaryExpressionContext; + class IdExpressionContext; + class UnqualifiedIdContext; + class QualifiedIdContext; + class NestedNameSpecifierContext; + class LambdaExpressionContext; + class LambdaIntroducerContext; + class LambdaCaptureContext; + class CaptureDefaultContext; + class CaptureListContext; + class CaptureContext; + class SimpleCaptureContext; + class InitcaptureContext; + class LambdaDeclaratorContext; + class PostfixExpressionContext; + class TypeIdOfTheTypeIdContext; + class ExpressionListContext; + class PseudoDestructorNameContext; + class UnaryExpressionContext; + class UnaryOperatorContext; + class NewExpressionContext; + class NewPlacementContext; + class NewTypeIdContext; + class NewDeclaratorContext; + class NoPointerNewDeclaratorContext; + class NewInitializerContext; + class DeleteExpressionContext; + class NoExceptExpressionContext; + class CastExpressionContext; + class PointerMemberExpressionContext; + class MultiplicativeExpressionContext; + class AdditiveExpressionContext; + class ShiftExpressionContext; + class ShiftOperatorContext; + class RelationalExpressionContext; + class EqualityExpressionContext; + class AndExpressionContext; + class ExclusiveOrExpressionContext; + class InclusiveOrExpressionContext; + class LogicalAndExpressionContext; + class LogicalOrExpressionContext; + class ConditionalExpressionContext; + class AssignmentExpressionContext; + class AssignmentOperatorContext; + class ExpressionContext; + class ConstantExpressionContext; + class StatementContext; + class LabeledStatementContext; + class ExpressionStatementContext; + class CompoundStatementContext; + class StatementSeqContext; + class SelectionStatementContext; + class ConditionContext; + class IterationStatementContext; + class ForInitStatementContext; + class ForRangeDeclarationContext; + class ForRangeInitializerContext; + class JumpStatementContext; + class DeclarationStatementContext; + class DeclarationseqContext; + class DeclarationContext; + class BlockDeclarationContext; + class AliasDeclarationContext; + class SimpleDeclarationContext; + class StaticAssertDeclarationContext; + class EmptyDeclarationContext; + class AttributeDeclarationContext; + class DeclSpecifierContext; + class DeclSpecifierSeqContext; + class StorageClassSpecifierContext; + class FunctionSpecifierContext; + class TypedefNameContext; + class TypeSpecifierContext; + class TrailingTypeSpecifierContext; + class TypeSpecifierSeqContext; + class TrailingTypeSpecifierSeqContext; + class SimpleTypeLengthModifierContext; + class SimpleTypeSignednessModifierContext; + class SimpleTypeSpecifierContext; + class TheTypeNameContext; + class DecltypeSpecifierContext; + class ElaboratedTypeSpecifierContext; + class EnumNameContext; + class EnumSpecifierContext; + class EnumHeadContext; + class OpaqueEnumDeclarationContext; + class EnumkeyContext; + class EnumbaseContext; + class EnumeratorListContext; + class EnumeratorDefinitionContext; + class EnumeratorContext; + class NamespaceNameContext; + class OriginalNamespaceNameContext; + class NamespaceDefinitionContext; + class NamespaceAliasContext; + class NamespaceAliasDefinitionContext; + class QualifiednamespacespecifierContext; + class UsingDeclarationContext; + class UsingDirectiveContext; + class AsmDefinitionContext; + class LinkageSpecificationContext; + class AttributeSpecifierSeqContext; + class AttributeSpecifierContext; + class AlignmentspecifierContext; + class AttributeListContext; + class AttributeContext; + class AttributeNamespaceContext; + class AttributeArgumentClauseContext; + class BalancedTokenSeqContext; + class BalancedtokenContext; + class InitDeclaratorListContext; + class InitDeclaratorContext; + class DeclaratorContext; + class PointerDeclaratorContext; + class NoPointerDeclaratorContext; + class ParametersAndQualifiersContext; + class TrailingReturnTypeContext; + class PointerOperatorContext; + class CvqualifierseqContext; + class CvQualifierContext; + class RefqualifierContext; + class DeclaratoridContext; + class TheTypeIdContext; + class AbstractDeclaratorContext; + class PointerAbstractDeclaratorContext; + class NoPointerAbstractDeclaratorContext; + class AbstractPackDeclaratorContext; + class NoPointerAbstractPackDeclaratorContext; + class ParameterDeclarationClauseContext; + class ParameterDeclarationListContext; + class ParameterDeclarationContext; + class FunctionDefinitionContext; + class FunctionBodyContext; + class InitializerContext; + class BraceOrEqualInitializerContext; + class InitializerClauseContext; + class InitializerListContext; + class BracedInitListContext; + class ClassNameContext; + class ClassSpecifierContext; + class ClassHeadContext; + class ClassHeadNameContext; + class ClassVirtSpecifierContext; + class ClassKeyContext; + class MemberSpecificationContext; + class MemberdeclarationContext; + class MemberDeclaratorListContext; + class MemberDeclaratorContext; + class VirtualSpecifierSeqContext; + class VirtualSpecifierContext; + class PureSpecifierContext; + class BaseClauseContext; + class BaseSpecifierListContext; + class BaseSpecifierContext; + class ClassOrDeclTypeContext; + class BaseTypeSpecifierContext; + class AccessSpecifierContext; + class ConversionFunctionIdContext; + class ConversionTypeIdContext; + class ConversionDeclaratorContext; + class ConstructorInitializerContext; + class MemInitializerListContext; + class MemInitializerContext; + class MeminitializeridContext; + class OperatorFunctionIdContext; + class LiteralOperatorIdContext; + class TemplateDeclarationContext; + class TemplateparameterListContext; + class TemplateParameterContext; + class TypeParameterContext; + class SimpleTemplateIdContext; + class TemplateIdContext; + class TemplateNameContext; + class TemplateArgumentListContext; + class TemplateArgumentContext; + class TypeNameSpecifierContext; + class ExplicitInstantiationContext; + class ExplicitSpecializationContext; + class TryBlockContext; + class FunctionTryBlockContext; + class HandlerSeqContext; + class HandlerContext; + class ExceptionDeclarationContext; + class ThrowExpressionContext; + class ExceptionSpecificationContext; + class DynamicExceptionSpecificationContext; + class TypeIdListContext; + class NoeExceptSpecificationContext; + class TheOperatorContext; + class LiteralContext; + + class TranslationUnitContext : public antlr4::ParserRuleContext { + public: + TranslationUnitContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *EOF(); + DeclarationseqContext *declarationseq(); + + + }; + + TranslationUnitContext* translationUnit(); + + class PrimaryExpressionContext : public antlr4::ParserRuleContext { + public: + PrimaryExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector literal(); + LiteralContext* literal(size_t i); + antlr4::tree::TerminalNode *This(); + antlr4::tree::TerminalNode *LeftParen(); + ExpressionContext *expression(); + antlr4::tree::TerminalNode *RightParen(); + IdExpressionContext *idExpression(); + LambdaExpressionContext *lambdaExpression(); + + + }; + + PrimaryExpressionContext* primaryExpression(); + + class IdExpressionContext : public antlr4::ParserRuleContext { + public: + IdExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + UnqualifiedIdContext *unqualifiedId(); + QualifiedIdContext *qualifiedId(); + + + }; + + IdExpressionContext* idExpression(); + + class UnqualifiedIdContext : public antlr4::ParserRuleContext { + public: + UnqualifiedIdContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Identifier(); + OperatorFunctionIdContext *operatorFunctionId(); + ConversionFunctionIdContext *conversionFunctionId(); + LiteralOperatorIdContext *literalOperatorId(); + antlr4::tree::TerminalNode *Tilde(); + ClassNameContext *className(); + DecltypeSpecifierContext *decltypeSpecifier(); + TemplateIdContext *templateId(); + + + }; + + UnqualifiedIdContext* unqualifiedId(); + + class QualifiedIdContext : public antlr4::ParserRuleContext { + public: + QualifiedIdContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + NestedNameSpecifierContext *nestedNameSpecifier(); + UnqualifiedIdContext *unqualifiedId(); + antlr4::tree::TerminalNode *Template(); + + + }; + + QualifiedIdContext* qualifiedId(); + + class NestedNameSpecifierContext : public antlr4::ParserRuleContext { + public: + NestedNameSpecifierContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Doublecolon(); + TheTypeNameContext *theTypeName(); + NamespaceNameContext *namespaceName(); + DecltypeSpecifierContext *decltypeSpecifier(); + NestedNameSpecifierContext *nestedNameSpecifier(); + antlr4::tree::TerminalNode *Identifier(); + SimpleTemplateIdContext *simpleTemplateId(); + antlr4::tree::TerminalNode *Template(); + + + }; + + NestedNameSpecifierContext* nestedNameSpecifier(); + NestedNameSpecifierContext* nestedNameSpecifier(int precedence); + class LambdaExpressionContext : public antlr4::ParserRuleContext { + public: + LambdaExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + LambdaIntroducerContext *lambdaIntroducer(); + CompoundStatementContext *compoundStatement(); + LambdaDeclaratorContext *lambdaDeclarator(); + + + }; + + LambdaExpressionContext* lambdaExpression(); + + class LambdaIntroducerContext : public antlr4::ParserRuleContext { + public: + LambdaIntroducerContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *LeftBracket(); + antlr4::tree::TerminalNode *RightBracket(); + LambdaCaptureContext *lambdaCapture(); + + + }; + + LambdaIntroducerContext* lambdaIntroducer(); + + class LambdaCaptureContext : public antlr4::ParserRuleContext { + public: + LambdaCaptureContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + CaptureListContext *captureList(); + CaptureDefaultContext *captureDefault(); + antlr4::tree::TerminalNode *Comma(); + + + }; + + LambdaCaptureContext* lambdaCapture(); + + class CaptureDefaultContext : public antlr4::ParserRuleContext { + public: + CaptureDefaultContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *And(); + antlr4::tree::TerminalNode *Assign(); + + + }; + + CaptureDefaultContext* captureDefault(); + + class CaptureListContext : public antlr4::ParserRuleContext { + public: + CaptureListContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector capture(); + CaptureContext* capture(size_t i); + std::vector Comma(); + antlr4::tree::TerminalNode* Comma(size_t i); + antlr4::tree::TerminalNode *Ellipsis(); + + + }; + + CaptureListContext* captureList(); + + class CaptureContext : public antlr4::ParserRuleContext { + public: + CaptureContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + SimpleCaptureContext *simpleCapture(); + InitcaptureContext *initcapture(); + + + }; + + CaptureContext* capture(); + + class SimpleCaptureContext : public antlr4::ParserRuleContext { + public: + SimpleCaptureContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Identifier(); + antlr4::tree::TerminalNode *And(); + antlr4::tree::TerminalNode *This(); + + + }; + + SimpleCaptureContext* simpleCapture(); + + class InitcaptureContext : public antlr4::ParserRuleContext { + public: + InitcaptureContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Identifier(); + InitializerContext *initializer(); + antlr4::tree::TerminalNode *And(); + + + }; + + InitcaptureContext* initcapture(); + + class LambdaDeclaratorContext : public antlr4::ParserRuleContext { + public: + LambdaDeclaratorContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *LeftParen(); + antlr4::tree::TerminalNode *RightParen(); + ParameterDeclarationClauseContext *parameterDeclarationClause(); + antlr4::tree::TerminalNode *Mutable(); + ExceptionSpecificationContext *exceptionSpecification(); + AttributeSpecifierSeqContext *attributeSpecifierSeq(); + TrailingReturnTypeContext *trailingReturnType(); + + + }; + + LambdaDeclaratorContext* lambdaDeclarator(); + + class PostfixExpressionContext : public antlr4::ParserRuleContext { + public: + PostfixExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + PrimaryExpressionContext *primaryExpression(); + SimpleTypeSpecifierContext *simpleTypeSpecifier(); + TypeNameSpecifierContext *typeNameSpecifier(); + antlr4::tree::TerminalNode *LeftParen(); + antlr4::tree::TerminalNode *RightParen(); + BracedInitListContext *bracedInitList(); + ExpressionListContext *expressionList(); + antlr4::tree::TerminalNode *Less(); + TheTypeIdContext *theTypeId(); + antlr4::tree::TerminalNode *Greater(); + ExpressionContext *expression(); + antlr4::tree::TerminalNode *Dynamic_cast(); + antlr4::tree::TerminalNode *Static_cast(); + antlr4::tree::TerminalNode *Reinterpret_cast(); + antlr4::tree::TerminalNode *Const_cast(); + TypeIdOfTheTypeIdContext *typeIdOfTheTypeId(); + PostfixExpressionContext *postfixExpression(); + antlr4::tree::TerminalNode *LeftBracket(); + antlr4::tree::TerminalNode *RightBracket(); + antlr4::tree::TerminalNode *Dot(); + antlr4::tree::TerminalNode *Arrow(); + IdExpressionContext *idExpression(); + PseudoDestructorNameContext *pseudoDestructorName(); + antlr4::tree::TerminalNode *Template(); + antlr4::tree::TerminalNode *PlusPlus(); + antlr4::tree::TerminalNode *MinusMinus(); + + + }; + + PostfixExpressionContext* postfixExpression(); + PostfixExpressionContext* postfixExpression(int precedence); + class TypeIdOfTheTypeIdContext : public antlr4::ParserRuleContext { + public: + TypeIdOfTheTypeIdContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Typeid_(); + + + }; + + TypeIdOfTheTypeIdContext* typeIdOfTheTypeId(); + + class ExpressionListContext : public antlr4::ParserRuleContext { + public: + ExpressionListContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + InitializerListContext *initializerList(); + + + }; + + ExpressionListContext* expressionList(); + + class PseudoDestructorNameContext : public antlr4::ParserRuleContext { + public: + PseudoDestructorNameContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Tilde(); + std::vector theTypeName(); + TheTypeNameContext* theTypeName(size_t i); + NestedNameSpecifierContext *nestedNameSpecifier(); + antlr4::tree::TerminalNode *Doublecolon(); + antlr4::tree::TerminalNode *Template(); + SimpleTemplateIdContext *simpleTemplateId(); + DecltypeSpecifierContext *decltypeSpecifier(); + + + }; + + PseudoDestructorNameContext* pseudoDestructorName(); + + class UnaryExpressionContext : public antlr4::ParserRuleContext { + public: + UnaryExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + PostfixExpressionContext *postfixExpression(); + UnaryExpressionContext *unaryExpression(); + antlr4::tree::TerminalNode *PlusPlus(); + antlr4::tree::TerminalNode *MinusMinus(); + UnaryOperatorContext *unaryOperator(); + antlr4::tree::TerminalNode *Sizeof(); + antlr4::tree::TerminalNode *LeftParen(); + TheTypeIdContext *theTypeId(); + antlr4::tree::TerminalNode *RightParen(); + antlr4::tree::TerminalNode *Ellipsis(); + antlr4::tree::TerminalNode *Identifier(); + antlr4::tree::TerminalNode *Alignof(); + NoExceptExpressionContext *noExceptExpression(); + NewExpressionContext *newExpression(); + DeleteExpressionContext *deleteExpression(); + + + }; + + UnaryExpressionContext* unaryExpression(); + + class UnaryOperatorContext : public antlr4::ParserRuleContext { + public: + UnaryOperatorContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Or(); + antlr4::tree::TerminalNode *Star(); + antlr4::tree::TerminalNode *And(); + antlr4::tree::TerminalNode *Plus(); + antlr4::tree::TerminalNode *Tilde(); + antlr4::tree::TerminalNode *Minus(); + antlr4::tree::TerminalNode *Not(); + + + }; + + UnaryOperatorContext* unaryOperator(); + + class NewExpressionContext : public antlr4::ParserRuleContext { + public: + NewExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *New(); + NewTypeIdContext *newTypeId(); + antlr4::tree::TerminalNode *Doublecolon(); + NewPlacementContext *newPlacement(); + NewInitializerContext *newInitializer(); + antlr4::tree::TerminalNode *LeftParen(); + TheTypeIdContext *theTypeId(); + antlr4::tree::TerminalNode *RightParen(); + + + }; + + NewExpressionContext* newExpression(); + + class NewPlacementContext : public antlr4::ParserRuleContext { + public: + NewPlacementContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *LeftParen(); + ExpressionListContext *expressionList(); + antlr4::tree::TerminalNode *RightParen(); + + + }; + + NewPlacementContext* newPlacement(); + + class NewTypeIdContext : public antlr4::ParserRuleContext { + public: + NewTypeIdContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + TypeSpecifierSeqContext *typeSpecifierSeq(); + NewDeclaratorContext *newDeclarator(); + + + }; + + NewTypeIdContext* newTypeId(); + + class NewDeclaratorContext : public antlr4::ParserRuleContext { + public: + NewDeclaratorContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + PointerOperatorContext *pointerOperator(); + NewDeclaratorContext *newDeclarator(); + NoPointerNewDeclaratorContext *noPointerNewDeclarator(); + + + }; + + NewDeclaratorContext* newDeclarator(); + + class NoPointerNewDeclaratorContext : public antlr4::ParserRuleContext { + public: + NoPointerNewDeclaratorContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *LeftBracket(); + ExpressionContext *expression(); + antlr4::tree::TerminalNode *RightBracket(); + AttributeSpecifierSeqContext *attributeSpecifierSeq(); + NoPointerNewDeclaratorContext *noPointerNewDeclarator(); + ConstantExpressionContext *constantExpression(); + + + }; + + NoPointerNewDeclaratorContext* noPointerNewDeclarator(); + NoPointerNewDeclaratorContext* noPointerNewDeclarator(int precedence); + class NewInitializerContext : public antlr4::ParserRuleContext { + public: + NewInitializerContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *LeftParen(); + antlr4::tree::TerminalNode *RightParen(); + ExpressionListContext *expressionList(); + BracedInitListContext *bracedInitList(); + + + }; + + NewInitializerContext* newInitializer(); + + class DeleteExpressionContext : public antlr4::ParserRuleContext { + public: + DeleteExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Delete(); + CastExpressionContext *castExpression(); + antlr4::tree::TerminalNode *Doublecolon(); + antlr4::tree::TerminalNode *LeftBracket(); + antlr4::tree::TerminalNode *RightBracket(); + + + }; + + DeleteExpressionContext* deleteExpression(); + + class NoExceptExpressionContext : public antlr4::ParserRuleContext { + public: + NoExceptExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Noexcept(); + antlr4::tree::TerminalNode *LeftParen(); + ExpressionContext *expression(); + antlr4::tree::TerminalNode *RightParen(); + + + }; + + NoExceptExpressionContext* noExceptExpression(); + + class CastExpressionContext : public antlr4::ParserRuleContext { + public: + CastExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + UnaryExpressionContext *unaryExpression(); + antlr4::tree::TerminalNode *LeftParen(); + TheTypeIdContext *theTypeId(); + antlr4::tree::TerminalNode *RightParen(); + CastExpressionContext *castExpression(); + + + }; + + CastExpressionContext* castExpression(); + + class PointerMemberExpressionContext : public antlr4::ParserRuleContext { + public: + PointerMemberExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector castExpression(); + CastExpressionContext* castExpression(size_t i); + std::vector DotStar(); + antlr4::tree::TerminalNode* DotStar(size_t i); + std::vector ArrowStar(); + antlr4::tree::TerminalNode* ArrowStar(size_t i); + + + }; + + PointerMemberExpressionContext* pointerMemberExpression(); + + class MultiplicativeExpressionContext : public antlr4::ParserRuleContext { + public: + MultiplicativeExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector pointerMemberExpression(); + PointerMemberExpressionContext* pointerMemberExpression(size_t i); + std::vector Star(); + antlr4::tree::TerminalNode* Star(size_t i); + std::vector Div(); + antlr4::tree::TerminalNode* Div(size_t i); + std::vector Mod(); + antlr4::tree::TerminalNode* Mod(size_t i); + + + }; + + MultiplicativeExpressionContext* multiplicativeExpression(); + + class AdditiveExpressionContext : public antlr4::ParserRuleContext { + public: + AdditiveExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector multiplicativeExpression(); + MultiplicativeExpressionContext* multiplicativeExpression(size_t i); + std::vector Plus(); + antlr4::tree::TerminalNode* Plus(size_t i); + std::vector Minus(); + antlr4::tree::TerminalNode* Minus(size_t i); + + + }; + + AdditiveExpressionContext* additiveExpression(); + + class ShiftExpressionContext : public antlr4::ParserRuleContext { + public: + ShiftExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector additiveExpression(); + AdditiveExpressionContext* additiveExpression(size_t i); + std::vector shiftOperator(); + ShiftOperatorContext* shiftOperator(size_t i); + + + }; + + ShiftExpressionContext* shiftExpression(); + + class ShiftOperatorContext : public antlr4::ParserRuleContext { + public: + ShiftOperatorContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector Greater(); + antlr4::tree::TerminalNode* Greater(size_t i); + std::vector Less(); + antlr4::tree::TerminalNode* Less(size_t i); + + + }; + + ShiftOperatorContext* shiftOperator(); + + class RelationalExpressionContext : public antlr4::ParserRuleContext { + public: + RelationalExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector shiftExpression(); + ShiftExpressionContext* shiftExpression(size_t i); + std::vector Less(); + antlr4::tree::TerminalNode* Less(size_t i); + std::vector Greater(); + antlr4::tree::TerminalNode* Greater(size_t i); + std::vector LessEqual(); + antlr4::tree::TerminalNode* LessEqual(size_t i); + std::vector GreaterEqual(); + antlr4::tree::TerminalNode* GreaterEqual(size_t i); + + + }; + + RelationalExpressionContext* relationalExpression(); + + class EqualityExpressionContext : public antlr4::ParserRuleContext { + public: + EqualityExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector relationalExpression(); + RelationalExpressionContext* relationalExpression(size_t i); + std::vector Equal(); + antlr4::tree::TerminalNode* Equal(size_t i); + std::vector NotEqual(); + antlr4::tree::TerminalNode* NotEqual(size_t i); + + + }; + + EqualityExpressionContext* equalityExpression(); + + class AndExpressionContext : public antlr4::ParserRuleContext { + public: + AndExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector equalityExpression(); + EqualityExpressionContext* equalityExpression(size_t i); + std::vector And(); + antlr4::tree::TerminalNode* And(size_t i); + + + }; + + AndExpressionContext* andExpression(); + + class ExclusiveOrExpressionContext : public antlr4::ParserRuleContext { + public: + ExclusiveOrExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector andExpression(); + AndExpressionContext* andExpression(size_t i); + std::vector Caret(); + antlr4::tree::TerminalNode* Caret(size_t i); + + + }; + + ExclusiveOrExpressionContext* exclusiveOrExpression(); + + class InclusiveOrExpressionContext : public antlr4::ParserRuleContext { + public: + InclusiveOrExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector exclusiveOrExpression(); + ExclusiveOrExpressionContext* exclusiveOrExpression(size_t i); + std::vector Or(); + antlr4::tree::TerminalNode* Or(size_t i); + + + }; + + InclusiveOrExpressionContext* inclusiveOrExpression(); + + class LogicalAndExpressionContext : public antlr4::ParserRuleContext { + public: + LogicalAndExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector inclusiveOrExpression(); + InclusiveOrExpressionContext* inclusiveOrExpression(size_t i); + std::vector AndAnd(); + antlr4::tree::TerminalNode* AndAnd(size_t i); + + + }; + + LogicalAndExpressionContext* logicalAndExpression(); + + class LogicalOrExpressionContext : public antlr4::ParserRuleContext { + public: + LogicalOrExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector logicalAndExpression(); + LogicalAndExpressionContext* logicalAndExpression(size_t i); + std::vector OrOr(); + antlr4::tree::TerminalNode* OrOr(size_t i); + + + }; + + LogicalOrExpressionContext* logicalOrExpression(); + + class ConditionalExpressionContext : public antlr4::ParserRuleContext { + public: + ConditionalExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + LogicalOrExpressionContext *logicalOrExpression(); + antlr4::tree::TerminalNode *Question(); + ExpressionContext *expression(); + antlr4::tree::TerminalNode *Colon(); + AssignmentExpressionContext *assignmentExpression(); + + + }; + + ConditionalExpressionContext* conditionalExpression(); + + class AssignmentExpressionContext : public antlr4::ParserRuleContext { + public: + AssignmentExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + ConditionalExpressionContext *conditionalExpression(); + LogicalOrExpressionContext *logicalOrExpression(); + AssignmentOperatorContext *assignmentOperator(); + InitializerClauseContext *initializerClause(); + ThrowExpressionContext *throwExpression(); + + + }; + + AssignmentExpressionContext* assignmentExpression(); + + class AssignmentOperatorContext : public antlr4::ParserRuleContext { + public: + AssignmentOperatorContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Assign(); + antlr4::tree::TerminalNode *StarAssign(); + antlr4::tree::TerminalNode *DivAssign(); + antlr4::tree::TerminalNode *ModAssign(); + antlr4::tree::TerminalNode *PlusAssign(); + antlr4::tree::TerminalNode *MinusAssign(); + antlr4::tree::TerminalNode *RightShiftAssign(); + antlr4::tree::TerminalNode *LeftShiftAssign(); + antlr4::tree::TerminalNode *AndAssign(); + antlr4::tree::TerminalNode *XorAssign(); + antlr4::tree::TerminalNode *OrAssign(); + + + }; + + AssignmentOperatorContext* assignmentOperator(); + + class ExpressionContext : public antlr4::ParserRuleContext { + public: + ExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector assignmentExpression(); + AssignmentExpressionContext* assignmentExpression(size_t i); + std::vector Comma(); + antlr4::tree::TerminalNode* Comma(size_t i); + + + }; + + ExpressionContext* expression(); + + class ConstantExpressionContext : public antlr4::ParserRuleContext { + public: + ConstantExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + ConditionalExpressionContext *conditionalExpression(); + + + }; + + ConstantExpressionContext* constantExpression(); + + class StatementContext : public antlr4::ParserRuleContext { + public: + StatementContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + LabeledStatementContext *labeledStatement(); + DeclarationStatementContext *declarationStatement(); + ExpressionStatementContext *expressionStatement(); + CompoundStatementContext *compoundStatement(); + SelectionStatementContext *selectionStatement(); + IterationStatementContext *iterationStatement(); + JumpStatementContext *jumpStatement(); + TryBlockContext *tryBlock(); + AttributeSpecifierSeqContext *attributeSpecifierSeq(); + + + }; + + StatementContext* statement(); + + class LabeledStatementContext : public antlr4::ParserRuleContext { + public: + LabeledStatementContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Colon(); + StatementContext *statement(); + antlr4::tree::TerminalNode *Identifier(); + antlr4::tree::TerminalNode *Case(); + ConstantExpressionContext *constantExpression(); + antlr4::tree::TerminalNode *Default(); + AttributeSpecifierSeqContext *attributeSpecifierSeq(); + + + }; + + LabeledStatementContext* labeledStatement(); + + class ExpressionStatementContext : public antlr4::ParserRuleContext { + public: + ExpressionStatementContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Semi(); + ExpressionContext *expression(); + + + }; + + ExpressionStatementContext* expressionStatement(); + + class CompoundStatementContext : public antlr4::ParserRuleContext { + public: + CompoundStatementContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *LeftBrace(); + antlr4::tree::TerminalNode *RightBrace(); + StatementSeqContext *statementSeq(); + + + }; + + CompoundStatementContext* compoundStatement(); + + class StatementSeqContext : public antlr4::ParserRuleContext { + public: + StatementSeqContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector statement(); + StatementContext* statement(size_t i); + + + }; + + StatementSeqContext* statementSeq(); + + class SelectionStatementContext : public antlr4::ParserRuleContext { + public: + SelectionStatementContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *If(); + antlr4::tree::TerminalNode *LeftParen(); + ConditionContext *condition(); + antlr4::tree::TerminalNode *RightParen(); + std::vector statement(); + StatementContext* statement(size_t i); + antlr4::tree::TerminalNode *Else(); + antlr4::tree::TerminalNode *Switch(); + + + }; + + SelectionStatementContext* selectionStatement(); + + class ConditionContext : public antlr4::ParserRuleContext { + public: + ConditionContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + ExpressionContext *expression(); + DeclSpecifierSeqContext *declSpecifierSeq(); + DeclaratorContext *declarator(); + antlr4::tree::TerminalNode *Assign(); + InitializerClauseContext *initializerClause(); + BracedInitListContext *bracedInitList(); + AttributeSpecifierSeqContext *attributeSpecifierSeq(); + + + }; + + ConditionContext* condition(); + + class IterationStatementContext : public antlr4::ParserRuleContext { + public: + IterationStatementContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *While(); + antlr4::tree::TerminalNode *LeftParen(); + ConditionContext *condition(); + antlr4::tree::TerminalNode *RightParen(); + StatementContext *statement(); + antlr4::tree::TerminalNode *Do(); + ExpressionContext *expression(); + antlr4::tree::TerminalNode *Semi(); + antlr4::tree::TerminalNode *For(); + ForInitStatementContext *forInitStatement(); + ForRangeDeclarationContext *forRangeDeclaration(); + antlr4::tree::TerminalNode *Colon(); + ForRangeInitializerContext *forRangeInitializer(); + + + }; + + IterationStatementContext* iterationStatement(); + + class ForInitStatementContext : public antlr4::ParserRuleContext { + public: + ForInitStatementContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + ExpressionStatementContext *expressionStatement(); + SimpleDeclarationContext *simpleDeclaration(); + + + }; + + ForInitStatementContext* forInitStatement(); + + class ForRangeDeclarationContext : public antlr4::ParserRuleContext { + public: + ForRangeDeclarationContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + DeclSpecifierSeqContext *declSpecifierSeq(); + DeclaratorContext *declarator(); + AttributeSpecifierSeqContext *attributeSpecifierSeq(); + + + }; + + ForRangeDeclarationContext* forRangeDeclaration(); + + class ForRangeInitializerContext : public antlr4::ParserRuleContext { + public: + ForRangeInitializerContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + ExpressionContext *expression(); + BracedInitListContext *bracedInitList(); + + + }; + + ForRangeInitializerContext* forRangeInitializer(); + + class JumpStatementContext : public antlr4::ParserRuleContext { + public: + JumpStatementContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Semi(); + antlr4::tree::TerminalNode *Break(); + antlr4::tree::TerminalNode *Continue(); + antlr4::tree::TerminalNode *Return(); + antlr4::tree::TerminalNode *Goto(); + antlr4::tree::TerminalNode *Identifier(); + ExpressionContext *expression(); + BracedInitListContext *bracedInitList(); + + + }; + + JumpStatementContext* jumpStatement(); + + class DeclarationStatementContext : public antlr4::ParserRuleContext { + public: + DeclarationStatementContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + BlockDeclarationContext *blockDeclaration(); + + + }; + + DeclarationStatementContext* declarationStatement(); + + class DeclarationseqContext : public antlr4::ParserRuleContext { + public: + DeclarationseqContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector declaration(); + DeclarationContext* declaration(size_t i); + + + }; + + DeclarationseqContext* declarationseq(); + + class DeclarationContext : public antlr4::ParserRuleContext { + public: + DeclarationContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + BlockDeclarationContext *blockDeclaration(); + FunctionDefinitionContext *functionDefinition(); + TemplateDeclarationContext *templateDeclaration(); + ExplicitInstantiationContext *explicitInstantiation(); + ExplicitSpecializationContext *explicitSpecialization(); + LinkageSpecificationContext *linkageSpecification(); + NamespaceDefinitionContext *namespaceDefinition(); + EmptyDeclarationContext *emptyDeclaration(); + AttributeDeclarationContext *attributeDeclaration(); + + + }; + + DeclarationContext* declaration(); + + class BlockDeclarationContext : public antlr4::ParserRuleContext { + public: + BlockDeclarationContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + SimpleDeclarationContext *simpleDeclaration(); + AsmDefinitionContext *asmDefinition(); + NamespaceAliasDefinitionContext *namespaceAliasDefinition(); + UsingDeclarationContext *usingDeclaration(); + UsingDirectiveContext *usingDirective(); + StaticAssertDeclarationContext *staticAssertDeclaration(); + AliasDeclarationContext *aliasDeclaration(); + OpaqueEnumDeclarationContext *opaqueEnumDeclaration(); + + + }; + + BlockDeclarationContext* blockDeclaration(); + + class AliasDeclarationContext : public antlr4::ParserRuleContext { + public: + AliasDeclarationContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Using(); + antlr4::tree::TerminalNode *Identifier(); + antlr4::tree::TerminalNode *Assign(); + TheTypeIdContext *theTypeId(); + antlr4::tree::TerminalNode *Semi(); + AttributeSpecifierSeqContext *attributeSpecifierSeq(); + + + }; + + AliasDeclarationContext* aliasDeclaration(); + + class SimpleDeclarationContext : public antlr4::ParserRuleContext { + public: + SimpleDeclarationContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Semi(); + DeclSpecifierSeqContext *declSpecifierSeq(); + InitDeclaratorListContext *initDeclaratorList(); + AttributeSpecifierSeqContext *attributeSpecifierSeq(); + + + }; + + SimpleDeclarationContext* simpleDeclaration(); + + class StaticAssertDeclarationContext : public antlr4::ParserRuleContext { + public: + StaticAssertDeclarationContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Static_assert(); + antlr4::tree::TerminalNode *LeftParen(); + ConstantExpressionContext *constantExpression(); + antlr4::tree::TerminalNode *Comma(); + antlr4::tree::TerminalNode *StringLiteral(); + antlr4::tree::TerminalNode *RightParen(); + antlr4::tree::TerminalNode *Semi(); + + + }; + + StaticAssertDeclarationContext* staticAssertDeclaration(); + + class EmptyDeclarationContext : public antlr4::ParserRuleContext { + public: + EmptyDeclarationContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Semi(); + + + }; + + EmptyDeclarationContext* emptyDeclaration(); + + class AttributeDeclarationContext : public antlr4::ParserRuleContext { + public: + AttributeDeclarationContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + AttributeSpecifierSeqContext *attributeSpecifierSeq(); + antlr4::tree::TerminalNode *Semi(); + + + }; + + AttributeDeclarationContext* attributeDeclaration(); + + class DeclSpecifierContext : public antlr4::ParserRuleContext { + public: + DeclSpecifierContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + StorageClassSpecifierContext *storageClassSpecifier(); + TypeSpecifierContext *typeSpecifier(); + FunctionSpecifierContext *functionSpecifier(); + antlr4::tree::TerminalNode *Friend(); + antlr4::tree::TerminalNode *Typedef(); + antlr4::tree::TerminalNode *Constexpr(); + + + }; + + DeclSpecifierContext* declSpecifier(); + + class DeclSpecifierSeqContext : public antlr4::ParserRuleContext { + public: + DeclSpecifierSeqContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector declSpecifier(); + DeclSpecifierContext* declSpecifier(size_t i); + AttributeSpecifierSeqContext *attributeSpecifierSeq(); + + + }; + + DeclSpecifierSeqContext* declSpecifierSeq(); + + class StorageClassSpecifierContext : public antlr4::ParserRuleContext { + public: + StorageClassSpecifierContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Register(); + antlr4::tree::TerminalNode *Static(); + antlr4::tree::TerminalNode *Thread_local(); + antlr4::tree::TerminalNode *Extern(); + antlr4::tree::TerminalNode *Mutable(); + + + }; + + StorageClassSpecifierContext* storageClassSpecifier(); + + class FunctionSpecifierContext : public antlr4::ParserRuleContext { + public: + FunctionSpecifierContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Inline(); + antlr4::tree::TerminalNode *Virtual(); + antlr4::tree::TerminalNode *Explicit(); + + + }; + + FunctionSpecifierContext* functionSpecifier(); + + class TypedefNameContext : public antlr4::ParserRuleContext { + public: + TypedefNameContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Identifier(); + + + }; + + TypedefNameContext* typedefName(); + + class TypeSpecifierContext : public antlr4::ParserRuleContext { + public: + TypeSpecifierContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + TrailingTypeSpecifierContext *trailingTypeSpecifier(); + ClassSpecifierContext *classSpecifier(); + EnumSpecifierContext *enumSpecifier(); + + + }; + + TypeSpecifierContext* typeSpecifier(); + + class TrailingTypeSpecifierContext : public antlr4::ParserRuleContext { + public: + TrailingTypeSpecifierContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + SimpleTypeSpecifierContext *simpleTypeSpecifier(); + ElaboratedTypeSpecifierContext *elaboratedTypeSpecifier(); + TypeNameSpecifierContext *typeNameSpecifier(); + CvQualifierContext *cvQualifier(); + + + }; + + TrailingTypeSpecifierContext* trailingTypeSpecifier(); + + class TypeSpecifierSeqContext : public antlr4::ParserRuleContext { + public: + TypeSpecifierSeqContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector typeSpecifier(); + TypeSpecifierContext* typeSpecifier(size_t i); + AttributeSpecifierSeqContext *attributeSpecifierSeq(); + + + }; + + TypeSpecifierSeqContext* typeSpecifierSeq(); + + class TrailingTypeSpecifierSeqContext : public antlr4::ParserRuleContext { + public: + TrailingTypeSpecifierSeqContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector trailingTypeSpecifier(); + TrailingTypeSpecifierContext* trailingTypeSpecifier(size_t i); + AttributeSpecifierSeqContext *attributeSpecifierSeq(); + + + }; + + TrailingTypeSpecifierSeqContext* trailingTypeSpecifierSeq(); + + class SimpleTypeLengthModifierContext : public antlr4::ParserRuleContext { + public: + SimpleTypeLengthModifierContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Short(); + antlr4::tree::TerminalNode *Long(); + + + }; + + SimpleTypeLengthModifierContext* simpleTypeLengthModifier(); + + class SimpleTypeSignednessModifierContext : public antlr4::ParserRuleContext { + public: + SimpleTypeSignednessModifierContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Unsigned(); + antlr4::tree::TerminalNode *Signed(); + + + }; + + SimpleTypeSignednessModifierContext* simpleTypeSignednessModifier(); + + class SimpleTypeSpecifierContext : public antlr4::ParserRuleContext { + public: + SimpleTypeSpecifierContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + TheTypeNameContext *theTypeName(); + NestedNameSpecifierContext *nestedNameSpecifier(); + antlr4::tree::TerminalNode *Template(); + SimpleTemplateIdContext *simpleTemplateId(); + SimpleTypeSignednessModifierContext *simpleTypeSignednessModifier(); + std::vector simpleTypeLengthModifier(); + SimpleTypeLengthModifierContext* simpleTypeLengthModifier(size_t i); + antlr4::tree::TerminalNode *Char(); + antlr4::tree::TerminalNode *Char16(); + antlr4::tree::TerminalNode *Char32(); + antlr4::tree::TerminalNode *Wchar(); + antlr4::tree::TerminalNode *Bool(); + antlr4::tree::TerminalNode *Int(); + antlr4::tree::TerminalNode *Float(); + antlr4::tree::TerminalNode *Double(); + antlr4::tree::TerminalNode *Void(); + antlr4::tree::TerminalNode *Auto(); + DecltypeSpecifierContext *decltypeSpecifier(); + + + }; + + SimpleTypeSpecifierContext* simpleTypeSpecifier(); + + class TheTypeNameContext : public antlr4::ParserRuleContext { + public: + TheTypeNameContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + ClassNameContext *className(); + EnumNameContext *enumName(); + TypedefNameContext *typedefName(); + SimpleTemplateIdContext *simpleTemplateId(); + + + }; + + TheTypeNameContext* theTypeName(); + + class DecltypeSpecifierContext : public antlr4::ParserRuleContext { + public: + DecltypeSpecifierContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Decltype(); + antlr4::tree::TerminalNode *LeftParen(); + antlr4::tree::TerminalNode *RightParen(); + ExpressionContext *expression(); + antlr4::tree::TerminalNode *Auto(); + + + }; + + DecltypeSpecifierContext* decltypeSpecifier(); + + class ElaboratedTypeSpecifierContext : public antlr4::ParserRuleContext { + public: + ElaboratedTypeSpecifierContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + ClassKeyContext *classKey(); + antlr4::tree::TerminalNode *Identifier(); + SimpleTemplateIdContext *simpleTemplateId(); + NestedNameSpecifierContext *nestedNameSpecifier(); + AttributeSpecifierSeqContext *attributeSpecifierSeq(); + antlr4::tree::TerminalNode *Template(); + antlr4::tree::TerminalNode *Enum(); + + + }; + + ElaboratedTypeSpecifierContext* elaboratedTypeSpecifier(); + + class EnumNameContext : public antlr4::ParserRuleContext { + public: + EnumNameContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Identifier(); + + + }; + + EnumNameContext* enumName(); + + class EnumSpecifierContext : public antlr4::ParserRuleContext { + public: + EnumSpecifierContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + EnumHeadContext *enumHead(); + antlr4::tree::TerminalNode *LeftBrace(); + antlr4::tree::TerminalNode *RightBrace(); + EnumeratorListContext *enumeratorList(); + antlr4::tree::TerminalNode *Comma(); + + + }; + + EnumSpecifierContext* enumSpecifier(); + + class EnumHeadContext : public antlr4::ParserRuleContext { + public: + EnumHeadContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + EnumkeyContext *enumkey(); + AttributeSpecifierSeqContext *attributeSpecifierSeq(); + antlr4::tree::TerminalNode *Identifier(); + EnumbaseContext *enumbase(); + NestedNameSpecifierContext *nestedNameSpecifier(); + + + }; + + EnumHeadContext* enumHead(); + + class OpaqueEnumDeclarationContext : public antlr4::ParserRuleContext { + public: + OpaqueEnumDeclarationContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + EnumkeyContext *enumkey(); + antlr4::tree::TerminalNode *Identifier(); + antlr4::tree::TerminalNode *Semi(); + AttributeSpecifierSeqContext *attributeSpecifierSeq(); + EnumbaseContext *enumbase(); + + + }; + + OpaqueEnumDeclarationContext* opaqueEnumDeclaration(); + + class EnumkeyContext : public antlr4::ParserRuleContext { + public: + EnumkeyContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Enum(); + antlr4::tree::TerminalNode *Class(); + antlr4::tree::TerminalNode *Struct(); + + + }; + + EnumkeyContext* enumkey(); + + class EnumbaseContext : public antlr4::ParserRuleContext { + public: + EnumbaseContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Colon(); + TypeSpecifierSeqContext *typeSpecifierSeq(); + + + }; + + EnumbaseContext* enumbase(); + + class EnumeratorListContext : public antlr4::ParserRuleContext { + public: + EnumeratorListContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector enumeratorDefinition(); + EnumeratorDefinitionContext* enumeratorDefinition(size_t i); + std::vector Comma(); + antlr4::tree::TerminalNode* Comma(size_t i); + + + }; + + EnumeratorListContext* enumeratorList(); + + class EnumeratorDefinitionContext : public antlr4::ParserRuleContext { + public: + EnumeratorDefinitionContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + EnumeratorContext *enumerator(); + antlr4::tree::TerminalNode *Assign(); + ConstantExpressionContext *constantExpression(); + + + }; + + EnumeratorDefinitionContext* enumeratorDefinition(); + + class EnumeratorContext : public antlr4::ParserRuleContext { + public: + EnumeratorContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Identifier(); + + + }; + + EnumeratorContext* enumerator(); + + class NamespaceNameContext : public antlr4::ParserRuleContext { + public: + NamespaceNameContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + OriginalNamespaceNameContext *originalNamespaceName(); + NamespaceAliasContext *namespaceAlias(); + + + }; + + NamespaceNameContext* namespaceName(); + + class OriginalNamespaceNameContext : public antlr4::ParserRuleContext { + public: + OriginalNamespaceNameContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Identifier(); + + + }; + + OriginalNamespaceNameContext* originalNamespaceName(); + + class NamespaceDefinitionContext : public antlr4::ParserRuleContext { + public: + CPP14Parser::DeclarationseqContext *namespaceBody = nullptr; + NamespaceDefinitionContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Namespace(); + antlr4::tree::TerminalNode *LeftBrace(); + antlr4::tree::TerminalNode *RightBrace(); + antlr4::tree::TerminalNode *Inline(); + antlr4::tree::TerminalNode *Identifier(); + OriginalNamespaceNameContext *originalNamespaceName(); + DeclarationseqContext *declarationseq(); + + + }; + + NamespaceDefinitionContext* namespaceDefinition(); + + class NamespaceAliasContext : public antlr4::ParserRuleContext { + public: + NamespaceAliasContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Identifier(); + + + }; + + NamespaceAliasContext* namespaceAlias(); + + class NamespaceAliasDefinitionContext : public antlr4::ParserRuleContext { + public: + NamespaceAliasDefinitionContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Namespace(); + antlr4::tree::TerminalNode *Identifier(); + antlr4::tree::TerminalNode *Assign(); + QualifiednamespacespecifierContext *qualifiednamespacespecifier(); + antlr4::tree::TerminalNode *Semi(); + + + }; + + NamespaceAliasDefinitionContext* namespaceAliasDefinition(); + + class QualifiednamespacespecifierContext : public antlr4::ParserRuleContext { + public: + QualifiednamespacespecifierContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + NamespaceNameContext *namespaceName(); + NestedNameSpecifierContext *nestedNameSpecifier(); + + + }; + + QualifiednamespacespecifierContext* qualifiednamespacespecifier(); + + class UsingDeclarationContext : public antlr4::ParserRuleContext { + public: + UsingDeclarationContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Using(); + UnqualifiedIdContext *unqualifiedId(); + antlr4::tree::TerminalNode *Semi(); + antlr4::tree::TerminalNode *Doublecolon(); + NestedNameSpecifierContext *nestedNameSpecifier(); + antlr4::tree::TerminalNode *Typename_(); + + + }; + + UsingDeclarationContext* usingDeclaration(); + + class UsingDirectiveContext : public antlr4::ParserRuleContext { + public: + UsingDirectiveContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Using(); + antlr4::tree::TerminalNode *Namespace(); + NamespaceNameContext *namespaceName(); + antlr4::tree::TerminalNode *Semi(); + AttributeSpecifierSeqContext *attributeSpecifierSeq(); + NestedNameSpecifierContext *nestedNameSpecifier(); + + + }; + + UsingDirectiveContext* usingDirective(); + + class AsmDefinitionContext : public antlr4::ParserRuleContext { + public: + AsmDefinitionContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Asm(); + antlr4::tree::TerminalNode *LeftParen(); + antlr4::tree::TerminalNode *StringLiteral(); + antlr4::tree::TerminalNode *RightParen(); + antlr4::tree::TerminalNode *Semi(); + + + }; + + AsmDefinitionContext* asmDefinition(); + + class LinkageSpecificationContext : public antlr4::ParserRuleContext { + public: + LinkageSpecificationContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Extern(); + antlr4::tree::TerminalNode *StringLiteral(); + antlr4::tree::TerminalNode *LeftBrace(); + antlr4::tree::TerminalNode *RightBrace(); + DeclarationContext *declaration(); + DeclarationseqContext *declarationseq(); + + + }; + + LinkageSpecificationContext* linkageSpecification(); + + class AttributeSpecifierSeqContext : public antlr4::ParserRuleContext { + public: + AttributeSpecifierSeqContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector attributeSpecifier(); + AttributeSpecifierContext* attributeSpecifier(size_t i); + + + }; + + AttributeSpecifierSeqContext* attributeSpecifierSeq(); + + class AttributeSpecifierContext : public antlr4::ParserRuleContext { + public: + AttributeSpecifierContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector LeftBracket(); + antlr4::tree::TerminalNode* LeftBracket(size_t i); + std::vector RightBracket(); + antlr4::tree::TerminalNode* RightBracket(size_t i); + AttributeListContext *attributeList(); + AlignmentspecifierContext *alignmentspecifier(); + + + }; + + AttributeSpecifierContext* attributeSpecifier(); + + class AlignmentspecifierContext : public antlr4::ParserRuleContext { + public: + AlignmentspecifierContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Alignas(); + antlr4::tree::TerminalNode *LeftParen(); + antlr4::tree::TerminalNode *RightParen(); + TheTypeIdContext *theTypeId(); + ConstantExpressionContext *constantExpression(); + antlr4::tree::TerminalNode *Ellipsis(); + + + }; + + AlignmentspecifierContext* alignmentspecifier(); + + class AttributeListContext : public antlr4::ParserRuleContext { + public: + AttributeListContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector attribute(); + AttributeContext* attribute(size_t i); + std::vector Comma(); + antlr4::tree::TerminalNode* Comma(size_t i); + antlr4::tree::TerminalNode *Ellipsis(); + + + }; + + AttributeListContext* attributeList(); + + class AttributeContext : public antlr4::ParserRuleContext { + public: + AttributeContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Identifier(); + AttributeNamespaceContext *attributeNamespace(); + antlr4::tree::TerminalNode *Doublecolon(); + AttributeArgumentClauseContext *attributeArgumentClause(); + + + }; + + AttributeContext* attribute(); + + class AttributeNamespaceContext : public antlr4::ParserRuleContext { + public: + AttributeNamespaceContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Identifier(); + + + }; + + AttributeNamespaceContext* attributeNamespace(); + + class AttributeArgumentClauseContext : public antlr4::ParserRuleContext { + public: + AttributeArgumentClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *LeftParen(); + antlr4::tree::TerminalNode *RightParen(); + BalancedTokenSeqContext *balancedTokenSeq(); + + + }; + + AttributeArgumentClauseContext* attributeArgumentClause(); + + class BalancedTokenSeqContext : public antlr4::ParserRuleContext { + public: + BalancedTokenSeqContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector balancedtoken(); + BalancedtokenContext* balancedtoken(size_t i); + + + }; + + BalancedTokenSeqContext* balancedTokenSeq(); + + class BalancedtokenContext : public antlr4::ParserRuleContext { + public: + BalancedtokenContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector LeftParen(); + antlr4::tree::TerminalNode* LeftParen(size_t i); + BalancedTokenSeqContext *balancedTokenSeq(); + std::vector RightParen(); + antlr4::tree::TerminalNode* RightParen(size_t i); + std::vector LeftBracket(); + antlr4::tree::TerminalNode* LeftBracket(size_t i); + std::vector RightBracket(); + antlr4::tree::TerminalNode* RightBracket(size_t i); + std::vector LeftBrace(); + antlr4::tree::TerminalNode* LeftBrace(size_t i); + std::vector RightBrace(); + antlr4::tree::TerminalNode* RightBrace(size_t i); + + + }; + + BalancedtokenContext* balancedtoken(); + + class InitDeclaratorListContext : public antlr4::ParserRuleContext { + public: + InitDeclaratorListContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector initDeclarator(); + InitDeclaratorContext* initDeclarator(size_t i); + std::vector Comma(); + antlr4::tree::TerminalNode* Comma(size_t i); + + + }; + + InitDeclaratorListContext* initDeclaratorList(); + + class InitDeclaratorContext : public antlr4::ParserRuleContext { + public: + InitDeclaratorContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + DeclaratorContext *declarator(); + InitializerContext *initializer(); + + + }; + + InitDeclaratorContext* initDeclarator(); + + class DeclaratorContext : public antlr4::ParserRuleContext { + public: + DeclaratorContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + PointerDeclaratorContext *pointerDeclarator(); + NoPointerDeclaratorContext *noPointerDeclarator(); + ParametersAndQualifiersContext *parametersAndQualifiers(); + TrailingReturnTypeContext *trailingReturnType(); + + + }; + + DeclaratorContext* declarator(); + + class PointerDeclaratorContext : public antlr4::ParserRuleContext { + public: + PointerDeclaratorContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + NoPointerDeclaratorContext *noPointerDeclarator(); + std::vector pointerOperator(); + PointerOperatorContext* pointerOperator(size_t i); + std::vector Const(); + antlr4::tree::TerminalNode* Const(size_t i); + + + }; + + PointerDeclaratorContext* pointerDeclarator(); + + class NoPointerDeclaratorContext : public antlr4::ParserRuleContext { + public: + NoPointerDeclaratorContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + DeclaratoridContext *declaratorid(); + AttributeSpecifierSeqContext *attributeSpecifierSeq(); + antlr4::tree::TerminalNode *LeftParen(); + PointerDeclaratorContext *pointerDeclarator(); + antlr4::tree::TerminalNode *RightParen(); + NoPointerDeclaratorContext *noPointerDeclarator(); + ParametersAndQualifiersContext *parametersAndQualifiers(); + antlr4::tree::TerminalNode *LeftBracket(); + antlr4::tree::TerminalNode *RightBracket(); + ConstantExpressionContext *constantExpression(); + + + }; + + NoPointerDeclaratorContext* noPointerDeclarator(); + NoPointerDeclaratorContext* noPointerDeclarator(int precedence); + class ParametersAndQualifiersContext : public antlr4::ParserRuleContext { + public: + ParametersAndQualifiersContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *LeftParen(); + antlr4::tree::TerminalNode *RightParen(); + ParameterDeclarationClauseContext *parameterDeclarationClause(); + CvqualifierseqContext *cvqualifierseq(); + RefqualifierContext *refqualifier(); + ExceptionSpecificationContext *exceptionSpecification(); + AttributeSpecifierSeqContext *attributeSpecifierSeq(); + + + }; + + ParametersAndQualifiersContext* parametersAndQualifiers(); + + class TrailingReturnTypeContext : public antlr4::ParserRuleContext { + public: + TrailingReturnTypeContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Arrow(); + TrailingTypeSpecifierSeqContext *trailingTypeSpecifierSeq(); + AbstractDeclaratorContext *abstractDeclarator(); + + + }; + + TrailingReturnTypeContext* trailingReturnType(); + + class PointerOperatorContext : public antlr4::ParserRuleContext { + public: + PointerOperatorContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *And(); + antlr4::tree::TerminalNode *AndAnd(); + AttributeSpecifierSeqContext *attributeSpecifierSeq(); + antlr4::tree::TerminalNode *Star(); + NestedNameSpecifierContext *nestedNameSpecifier(); + CvqualifierseqContext *cvqualifierseq(); + + + }; + + PointerOperatorContext* pointerOperator(); + + class CvqualifierseqContext : public antlr4::ParserRuleContext { + public: + CvqualifierseqContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector cvQualifier(); + CvQualifierContext* cvQualifier(size_t i); + + + }; + + CvqualifierseqContext* cvqualifierseq(); + + class CvQualifierContext : public antlr4::ParserRuleContext { + public: + CvQualifierContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Const(); + antlr4::tree::TerminalNode *Volatile(); + + + }; + + CvQualifierContext* cvQualifier(); + + class RefqualifierContext : public antlr4::ParserRuleContext { + public: + RefqualifierContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *And(); + antlr4::tree::TerminalNode *AndAnd(); + + + }; + + RefqualifierContext* refqualifier(); + + class DeclaratoridContext : public antlr4::ParserRuleContext { + public: + DeclaratoridContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + IdExpressionContext *idExpression(); + antlr4::tree::TerminalNode *Ellipsis(); + + + }; + + DeclaratoridContext* declaratorid(); + + class TheTypeIdContext : public antlr4::ParserRuleContext { + public: + TheTypeIdContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + TypeSpecifierSeqContext *typeSpecifierSeq(); + AbstractDeclaratorContext *abstractDeclarator(); + + + }; + + TheTypeIdContext* theTypeId(); + + class AbstractDeclaratorContext : public antlr4::ParserRuleContext { + public: + AbstractDeclaratorContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + PointerAbstractDeclaratorContext *pointerAbstractDeclarator(); + ParametersAndQualifiersContext *parametersAndQualifiers(); + TrailingReturnTypeContext *trailingReturnType(); + NoPointerAbstractDeclaratorContext *noPointerAbstractDeclarator(); + AbstractPackDeclaratorContext *abstractPackDeclarator(); + + + }; + + AbstractDeclaratorContext* abstractDeclarator(); + + class PointerAbstractDeclaratorContext : public antlr4::ParserRuleContext { + public: + PointerAbstractDeclaratorContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + NoPointerAbstractDeclaratorContext *noPointerAbstractDeclarator(); + std::vector pointerOperator(); + PointerOperatorContext* pointerOperator(size_t i); + + + }; + + PointerAbstractDeclaratorContext* pointerAbstractDeclarator(); + + class NoPointerAbstractDeclaratorContext : public antlr4::ParserRuleContext { + public: + NoPointerAbstractDeclaratorContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + ParametersAndQualifiersContext *parametersAndQualifiers(); + antlr4::tree::TerminalNode *LeftBracket(); + antlr4::tree::TerminalNode *RightBracket(); + ConstantExpressionContext *constantExpression(); + AttributeSpecifierSeqContext *attributeSpecifierSeq(); + antlr4::tree::TerminalNode *LeftParen(); + PointerAbstractDeclaratorContext *pointerAbstractDeclarator(); + antlr4::tree::TerminalNode *RightParen(); + std::vector noPointerAbstractDeclarator(); + NoPointerAbstractDeclaratorContext* noPointerAbstractDeclarator(size_t i); + + + }; + + NoPointerAbstractDeclaratorContext* noPointerAbstractDeclarator(); + NoPointerAbstractDeclaratorContext* noPointerAbstractDeclarator(int precedence); + class AbstractPackDeclaratorContext : public antlr4::ParserRuleContext { + public: + AbstractPackDeclaratorContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + NoPointerAbstractPackDeclaratorContext *noPointerAbstractPackDeclarator(); + std::vector pointerOperator(); + PointerOperatorContext* pointerOperator(size_t i); + + + }; + + AbstractPackDeclaratorContext* abstractPackDeclarator(); + + class NoPointerAbstractPackDeclaratorContext : public antlr4::ParserRuleContext { + public: + NoPointerAbstractPackDeclaratorContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Ellipsis(); + NoPointerAbstractPackDeclaratorContext *noPointerAbstractPackDeclarator(); + ParametersAndQualifiersContext *parametersAndQualifiers(); + antlr4::tree::TerminalNode *LeftBracket(); + antlr4::tree::TerminalNode *RightBracket(); + ConstantExpressionContext *constantExpression(); + AttributeSpecifierSeqContext *attributeSpecifierSeq(); + + + }; + + NoPointerAbstractPackDeclaratorContext* noPointerAbstractPackDeclarator(); + NoPointerAbstractPackDeclaratorContext* noPointerAbstractPackDeclarator(int precedence); + class ParameterDeclarationClauseContext : public antlr4::ParserRuleContext { + public: + ParameterDeclarationClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + ParameterDeclarationListContext *parameterDeclarationList(); + antlr4::tree::TerminalNode *Ellipsis(); + antlr4::tree::TerminalNode *Comma(); + + + }; + + ParameterDeclarationClauseContext* parameterDeclarationClause(); + + class ParameterDeclarationListContext : public antlr4::ParserRuleContext { + public: + ParameterDeclarationListContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector parameterDeclaration(); + ParameterDeclarationContext* parameterDeclaration(size_t i); + std::vector Comma(); + antlr4::tree::TerminalNode* Comma(size_t i); + + + }; + + ParameterDeclarationListContext* parameterDeclarationList(); + + class ParameterDeclarationContext : public antlr4::ParserRuleContext { + public: + ParameterDeclarationContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + DeclSpecifierSeqContext *declSpecifierSeq(); + AttributeSpecifierSeqContext *attributeSpecifierSeq(); + DeclaratorContext *declarator(); + antlr4::tree::TerminalNode *Assign(); + InitializerClauseContext *initializerClause(); + AbstractDeclaratorContext *abstractDeclarator(); + + + }; + + ParameterDeclarationContext* parameterDeclaration(); + + class FunctionDefinitionContext : public antlr4::ParserRuleContext { + public: + FunctionDefinitionContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + DeclaratorContext *declarator(); + FunctionBodyContext *functionBody(); + AttributeSpecifierSeqContext *attributeSpecifierSeq(); + DeclSpecifierSeqContext *declSpecifierSeq(); + VirtualSpecifierSeqContext *virtualSpecifierSeq(); + + + }; + + FunctionDefinitionContext* functionDefinition(); + + class FunctionBodyContext : public antlr4::ParserRuleContext { + public: + FunctionBodyContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + CompoundStatementContext *compoundStatement(); + ConstructorInitializerContext *constructorInitializer(); + FunctionTryBlockContext *functionTryBlock(); + antlr4::tree::TerminalNode *Assign(); + antlr4::tree::TerminalNode *Semi(); + antlr4::tree::TerminalNode *Default(); + antlr4::tree::TerminalNode *Delete(); + + + }; + + FunctionBodyContext* functionBody(); + + class InitializerContext : public antlr4::ParserRuleContext { + public: + InitializerContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + BraceOrEqualInitializerContext *braceOrEqualInitializer(); + antlr4::tree::TerminalNode *LeftParen(); + ExpressionListContext *expressionList(); + antlr4::tree::TerminalNode *RightParen(); + + + }; + + InitializerContext* initializer(); + + class BraceOrEqualInitializerContext : public antlr4::ParserRuleContext { + public: + BraceOrEqualInitializerContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Assign(); + InitializerClauseContext *initializerClause(); + BracedInitListContext *bracedInitList(); + + + }; + + BraceOrEqualInitializerContext* braceOrEqualInitializer(); + + class InitializerClauseContext : public antlr4::ParserRuleContext { + public: + InitializerClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + AssignmentExpressionContext *assignmentExpression(); + BracedInitListContext *bracedInitList(); + + + }; + + InitializerClauseContext* initializerClause(); + + class InitializerListContext : public antlr4::ParserRuleContext { + public: + InitializerListContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector initializerClause(); + InitializerClauseContext* initializerClause(size_t i); + std::vector Ellipsis(); + antlr4::tree::TerminalNode* Ellipsis(size_t i); + std::vector Comma(); + antlr4::tree::TerminalNode* Comma(size_t i); + + + }; + + InitializerListContext* initializerList(); + + class BracedInitListContext : public antlr4::ParserRuleContext { + public: + BracedInitListContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *LeftBrace(); + antlr4::tree::TerminalNode *RightBrace(); + InitializerListContext *initializerList(); + antlr4::tree::TerminalNode *Comma(); + + + }; + + BracedInitListContext* bracedInitList(); + + class ClassNameContext : public antlr4::ParserRuleContext { + public: + ClassNameContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Identifier(); + SimpleTemplateIdContext *simpleTemplateId(); + + + }; + + ClassNameContext* className(); + + class ClassSpecifierContext : public antlr4::ParserRuleContext { + public: + ClassSpecifierContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + ClassHeadContext *classHead(); + antlr4::tree::TerminalNode *LeftBrace(); + antlr4::tree::TerminalNode *RightBrace(); + MemberSpecificationContext *memberSpecification(); + + + }; + + ClassSpecifierContext* classSpecifier(); + + class ClassHeadContext : public antlr4::ParserRuleContext { + public: + ClassHeadContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + ClassKeyContext *classKey(); + AttributeSpecifierSeqContext *attributeSpecifierSeq(); + ClassHeadNameContext *classHeadName(); + BaseClauseContext *baseClause(); + ClassVirtSpecifierContext *classVirtSpecifier(); + antlr4::tree::TerminalNode *Union(); + + + }; + + ClassHeadContext* classHead(); + + class ClassHeadNameContext : public antlr4::ParserRuleContext { + public: + ClassHeadNameContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + ClassNameContext *className(); + NestedNameSpecifierContext *nestedNameSpecifier(); + + + }; + + ClassHeadNameContext* classHeadName(); + + class ClassVirtSpecifierContext : public antlr4::ParserRuleContext { + public: + ClassVirtSpecifierContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Final(); + + + }; + + ClassVirtSpecifierContext* classVirtSpecifier(); + + class ClassKeyContext : public antlr4::ParserRuleContext { + public: + ClassKeyContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Class(); + antlr4::tree::TerminalNode *Struct(); + + + }; + + ClassKeyContext* classKey(); + + class MemberSpecificationContext : public antlr4::ParserRuleContext { + public: + MemberSpecificationContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector memberdeclaration(); + MemberdeclarationContext* memberdeclaration(size_t i); + std::vector accessSpecifier(); + AccessSpecifierContext* accessSpecifier(size_t i); + std::vector Colon(); + antlr4::tree::TerminalNode* Colon(size_t i); + + + }; + + MemberSpecificationContext* memberSpecification(); + + class MemberdeclarationContext : public antlr4::ParserRuleContext { + public: + MemberdeclarationContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Semi(); + AttributeSpecifierSeqContext *attributeSpecifierSeq(); + DeclSpecifierSeqContext *declSpecifierSeq(); + MemberDeclaratorListContext *memberDeclaratorList(); + FunctionDefinitionContext *functionDefinition(); + UsingDeclarationContext *usingDeclaration(); + StaticAssertDeclarationContext *staticAssertDeclaration(); + TemplateDeclarationContext *templateDeclaration(); + AliasDeclarationContext *aliasDeclaration(); + EmptyDeclarationContext *emptyDeclaration(); + + + }; + + MemberdeclarationContext* memberdeclaration(); + + class MemberDeclaratorListContext : public antlr4::ParserRuleContext { + public: + MemberDeclaratorListContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector memberDeclarator(); + MemberDeclaratorContext* memberDeclarator(size_t i); + std::vector Comma(); + antlr4::tree::TerminalNode* Comma(size_t i); + + + }; + + MemberDeclaratorListContext* memberDeclaratorList(); + + class MemberDeclaratorContext : public antlr4::ParserRuleContext { + public: + MemberDeclaratorContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + DeclaratorContext *declarator(); + VirtualSpecifierSeqContext *virtualSpecifierSeq(); + PureSpecifierContext *pureSpecifier(); + BraceOrEqualInitializerContext *braceOrEqualInitializer(); + antlr4::tree::TerminalNode *Colon(); + ConstantExpressionContext *constantExpression(); + antlr4::tree::TerminalNode *Identifier(); + AttributeSpecifierSeqContext *attributeSpecifierSeq(); + + + }; + + MemberDeclaratorContext* memberDeclarator(); + + class VirtualSpecifierSeqContext : public antlr4::ParserRuleContext { + public: + VirtualSpecifierSeqContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector virtualSpecifier(); + VirtualSpecifierContext* virtualSpecifier(size_t i); + + + }; + + VirtualSpecifierSeqContext* virtualSpecifierSeq(); + + class VirtualSpecifierContext : public antlr4::ParserRuleContext { + public: + VirtualSpecifierContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Override(); + antlr4::tree::TerminalNode *Final(); + + + }; + + VirtualSpecifierContext* virtualSpecifier(); + + class PureSpecifierContext : public antlr4::ParserRuleContext { + public: + antlr4::Token *val = nullptr; + PureSpecifierContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Assign(); + antlr4::tree::TerminalNode *OctalLiteral(); + + + }; + + PureSpecifierContext* pureSpecifier(); + + class BaseClauseContext : public antlr4::ParserRuleContext { + public: + BaseClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Colon(); + BaseSpecifierListContext *baseSpecifierList(); + + + }; + + BaseClauseContext* baseClause(); + + class BaseSpecifierListContext : public antlr4::ParserRuleContext { + public: + BaseSpecifierListContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector baseSpecifier(); + BaseSpecifierContext* baseSpecifier(size_t i); + std::vector Ellipsis(); + antlr4::tree::TerminalNode* Ellipsis(size_t i); + std::vector Comma(); + antlr4::tree::TerminalNode* Comma(size_t i); + + + }; + + BaseSpecifierListContext* baseSpecifierList(); + + class BaseSpecifierContext : public antlr4::ParserRuleContext { + public: + BaseSpecifierContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + BaseTypeSpecifierContext *baseTypeSpecifier(); + antlr4::tree::TerminalNode *Virtual(); + AccessSpecifierContext *accessSpecifier(); + AttributeSpecifierSeqContext *attributeSpecifierSeq(); + + + }; + + BaseSpecifierContext* baseSpecifier(); + + class ClassOrDeclTypeContext : public antlr4::ParserRuleContext { + public: + ClassOrDeclTypeContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + ClassNameContext *className(); + NestedNameSpecifierContext *nestedNameSpecifier(); + DecltypeSpecifierContext *decltypeSpecifier(); + + + }; + + ClassOrDeclTypeContext* classOrDeclType(); + + class BaseTypeSpecifierContext : public antlr4::ParserRuleContext { + public: + BaseTypeSpecifierContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + ClassOrDeclTypeContext *classOrDeclType(); + + + }; + + BaseTypeSpecifierContext* baseTypeSpecifier(); + + class AccessSpecifierContext : public antlr4::ParserRuleContext { + public: + AccessSpecifierContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Private(); + antlr4::tree::TerminalNode *Protected(); + antlr4::tree::TerminalNode *Public(); + + + }; + + AccessSpecifierContext* accessSpecifier(); + + class ConversionFunctionIdContext : public antlr4::ParserRuleContext { + public: + ConversionFunctionIdContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Operator(); + ConversionTypeIdContext *conversionTypeId(); + + + }; + + ConversionFunctionIdContext* conversionFunctionId(); + + class ConversionTypeIdContext : public antlr4::ParserRuleContext { + public: + ConversionTypeIdContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + TypeSpecifierSeqContext *typeSpecifierSeq(); + ConversionDeclaratorContext *conversionDeclarator(); + + + }; + + ConversionTypeIdContext* conversionTypeId(); + + class ConversionDeclaratorContext : public antlr4::ParserRuleContext { + public: + ConversionDeclaratorContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + PointerOperatorContext *pointerOperator(); + ConversionDeclaratorContext *conversionDeclarator(); + + + }; + + ConversionDeclaratorContext* conversionDeclarator(); + + class ConstructorInitializerContext : public antlr4::ParserRuleContext { + public: + ConstructorInitializerContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Colon(); + MemInitializerListContext *memInitializerList(); + + + }; + + ConstructorInitializerContext* constructorInitializer(); + + class MemInitializerListContext : public antlr4::ParserRuleContext { + public: + MemInitializerListContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector memInitializer(); + MemInitializerContext* memInitializer(size_t i); + std::vector Ellipsis(); + antlr4::tree::TerminalNode* Ellipsis(size_t i); + std::vector Comma(); + antlr4::tree::TerminalNode* Comma(size_t i); + + + }; + + MemInitializerListContext* memInitializerList(); + + class MemInitializerContext : public antlr4::ParserRuleContext { + public: + MemInitializerContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + MeminitializeridContext *meminitializerid(); + antlr4::tree::TerminalNode *LeftParen(); + antlr4::tree::TerminalNode *RightParen(); + BracedInitListContext *bracedInitList(); + ExpressionListContext *expressionList(); + + + }; + + MemInitializerContext* memInitializer(); + + class MeminitializeridContext : public antlr4::ParserRuleContext { + public: + MeminitializeridContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + ClassOrDeclTypeContext *classOrDeclType(); + antlr4::tree::TerminalNode *Identifier(); + + + }; + + MeminitializeridContext* meminitializerid(); + + class OperatorFunctionIdContext : public antlr4::ParserRuleContext { + public: + OperatorFunctionIdContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Operator(); + TheOperatorContext *theOperator(); + + + }; + + OperatorFunctionIdContext* operatorFunctionId(); + + class LiteralOperatorIdContext : public antlr4::ParserRuleContext { + public: + LiteralOperatorIdContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Operator(); + antlr4::tree::TerminalNode *StringLiteral(); + antlr4::tree::TerminalNode *Identifier(); + antlr4::tree::TerminalNode *UserDefinedStringLiteral(); + + + }; + + LiteralOperatorIdContext* literalOperatorId(); + + class TemplateDeclarationContext : public antlr4::ParserRuleContext { + public: + TemplateDeclarationContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Template(); + antlr4::tree::TerminalNode *Less(); + TemplateparameterListContext *templateparameterList(); + antlr4::tree::TerminalNode *Greater(); + DeclarationContext *declaration(); + + + }; + + TemplateDeclarationContext* templateDeclaration(); + + class TemplateparameterListContext : public antlr4::ParserRuleContext { + public: + TemplateparameterListContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector templateParameter(); + TemplateParameterContext* templateParameter(size_t i); + std::vector Comma(); + antlr4::tree::TerminalNode* Comma(size_t i); + + + }; + + TemplateparameterListContext* templateparameterList(); + + class TemplateParameterContext : public antlr4::ParserRuleContext { + public: + TemplateParameterContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + TypeParameterContext *typeParameter(); + ParameterDeclarationContext *parameterDeclaration(); + + + }; + + TemplateParameterContext* templateParameter(); + + class TypeParameterContext : public antlr4::ParserRuleContext { + public: + TypeParameterContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Class(); + antlr4::tree::TerminalNode *Typename_(); + antlr4::tree::TerminalNode *Assign(); + TheTypeIdContext *theTypeId(); + antlr4::tree::TerminalNode *Template(); + antlr4::tree::TerminalNode *Less(); + TemplateparameterListContext *templateparameterList(); + antlr4::tree::TerminalNode *Greater(); + antlr4::tree::TerminalNode *Ellipsis(); + antlr4::tree::TerminalNode *Identifier(); + + + }; + + TypeParameterContext* typeParameter(); + + class SimpleTemplateIdContext : public antlr4::ParserRuleContext { + public: + SimpleTemplateIdContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + TemplateNameContext *templateName(); + antlr4::tree::TerminalNode *Less(); + antlr4::tree::TerminalNode *Greater(); + TemplateArgumentListContext *templateArgumentList(); + + + }; + + SimpleTemplateIdContext* simpleTemplateId(); + + class TemplateIdContext : public antlr4::ParserRuleContext { + public: + TemplateIdContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + SimpleTemplateIdContext *simpleTemplateId(); + antlr4::tree::TerminalNode *Less(); + antlr4::tree::TerminalNode *Greater(); + OperatorFunctionIdContext *operatorFunctionId(); + LiteralOperatorIdContext *literalOperatorId(); + TemplateArgumentListContext *templateArgumentList(); + + + }; + + TemplateIdContext* templateId(); + + class TemplateNameContext : public antlr4::ParserRuleContext { + public: + TemplateNameContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Identifier(); + + + }; + + TemplateNameContext* templateName(); + + class TemplateArgumentListContext : public antlr4::ParserRuleContext { + public: + TemplateArgumentListContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector templateArgument(); + TemplateArgumentContext* templateArgument(size_t i); + std::vector Ellipsis(); + antlr4::tree::TerminalNode* Ellipsis(size_t i); + std::vector Comma(); + antlr4::tree::TerminalNode* Comma(size_t i); + + + }; + + TemplateArgumentListContext* templateArgumentList(); + + class TemplateArgumentContext : public antlr4::ParserRuleContext { + public: + TemplateArgumentContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + TheTypeIdContext *theTypeId(); + ConstantExpressionContext *constantExpression(); + IdExpressionContext *idExpression(); + + + }; + + TemplateArgumentContext* templateArgument(); + + class TypeNameSpecifierContext : public antlr4::ParserRuleContext { + public: + TypeNameSpecifierContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Typename_(); + NestedNameSpecifierContext *nestedNameSpecifier(); + antlr4::tree::TerminalNode *Identifier(); + SimpleTemplateIdContext *simpleTemplateId(); + antlr4::tree::TerminalNode *Template(); + + + }; + + TypeNameSpecifierContext* typeNameSpecifier(); + + class ExplicitInstantiationContext : public antlr4::ParserRuleContext { + public: + ExplicitInstantiationContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Template(); + DeclarationContext *declaration(); + antlr4::tree::TerminalNode *Extern(); + + + }; + + ExplicitInstantiationContext* explicitInstantiation(); + + class ExplicitSpecializationContext : public antlr4::ParserRuleContext { + public: + ExplicitSpecializationContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Template(); + antlr4::tree::TerminalNode *Less(); + antlr4::tree::TerminalNode *Greater(); + DeclarationContext *declaration(); + + + }; + + ExplicitSpecializationContext* explicitSpecialization(); + + class TryBlockContext : public antlr4::ParserRuleContext { + public: + TryBlockContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Try(); + CompoundStatementContext *compoundStatement(); + HandlerSeqContext *handlerSeq(); + + + }; + + TryBlockContext* tryBlock(); + + class FunctionTryBlockContext : public antlr4::ParserRuleContext { + public: + FunctionTryBlockContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Try(); + CompoundStatementContext *compoundStatement(); + HandlerSeqContext *handlerSeq(); + ConstructorInitializerContext *constructorInitializer(); + + + }; + + FunctionTryBlockContext* functionTryBlock(); + + class HandlerSeqContext : public antlr4::ParserRuleContext { + public: + HandlerSeqContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector handler(); + HandlerContext* handler(size_t i); + + + }; + + HandlerSeqContext* handlerSeq(); + + class HandlerContext : public antlr4::ParserRuleContext { + public: + HandlerContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Catch(); + antlr4::tree::TerminalNode *LeftParen(); + ExceptionDeclarationContext *exceptionDeclaration(); + antlr4::tree::TerminalNode *RightParen(); + CompoundStatementContext *compoundStatement(); + + + }; + + HandlerContext* handler(); + + class ExceptionDeclarationContext : public antlr4::ParserRuleContext { + public: + ExceptionDeclarationContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + TypeSpecifierSeqContext *typeSpecifierSeq(); + AttributeSpecifierSeqContext *attributeSpecifierSeq(); + DeclaratorContext *declarator(); + AbstractDeclaratorContext *abstractDeclarator(); + antlr4::tree::TerminalNode *Ellipsis(); + + + }; + + ExceptionDeclarationContext* exceptionDeclaration(); + + class ThrowExpressionContext : public antlr4::ParserRuleContext { + public: + ThrowExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Throw(); + AssignmentExpressionContext *assignmentExpression(); + + + }; + + ThrowExpressionContext* throwExpression(); + + class ExceptionSpecificationContext : public antlr4::ParserRuleContext { + public: + ExceptionSpecificationContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + DynamicExceptionSpecificationContext *dynamicExceptionSpecification(); + NoeExceptSpecificationContext *noeExceptSpecification(); + + + }; + + ExceptionSpecificationContext* exceptionSpecification(); + + class DynamicExceptionSpecificationContext : public antlr4::ParserRuleContext { + public: + DynamicExceptionSpecificationContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Throw(); + antlr4::tree::TerminalNode *LeftParen(); + antlr4::tree::TerminalNode *RightParen(); + TypeIdListContext *typeIdList(); + + + }; + + DynamicExceptionSpecificationContext* dynamicExceptionSpecification(); + + class TypeIdListContext : public antlr4::ParserRuleContext { + public: + TypeIdListContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector theTypeId(); + TheTypeIdContext* theTypeId(size_t i); + std::vector Ellipsis(); + antlr4::tree::TerminalNode* Ellipsis(size_t i); + std::vector Comma(); + antlr4::tree::TerminalNode* Comma(size_t i); + + + }; + + TypeIdListContext* typeIdList(); + + class NoeExceptSpecificationContext : public antlr4::ParserRuleContext { + public: + NoeExceptSpecificationContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Noexcept(); + antlr4::tree::TerminalNode *LeftParen(); + ConstantExpressionContext *constantExpression(); + antlr4::tree::TerminalNode *RightParen(); + + + }; + + NoeExceptSpecificationContext* noeExceptSpecification(); + + class TheOperatorContext : public antlr4::ParserRuleContext { + public: + TheOperatorContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *New(); + antlr4::tree::TerminalNode *LeftBracket(); + antlr4::tree::TerminalNode *RightBracket(); + antlr4::tree::TerminalNode *Delete(); + antlr4::tree::TerminalNode *Plus(); + antlr4::tree::TerminalNode *Minus(); + antlr4::tree::TerminalNode *Star(); + antlr4::tree::TerminalNode *Div(); + antlr4::tree::TerminalNode *Mod(); + antlr4::tree::TerminalNode *Caret(); + antlr4::tree::TerminalNode *And(); + antlr4::tree::TerminalNode *Or(); + antlr4::tree::TerminalNode *Tilde(); + antlr4::tree::TerminalNode *Not(); + antlr4::tree::TerminalNode *Assign(); + std::vector Greater(); + antlr4::tree::TerminalNode* Greater(size_t i); + std::vector Less(); + antlr4::tree::TerminalNode* Less(size_t i); + antlr4::tree::TerminalNode *GreaterEqual(); + antlr4::tree::TerminalNode *PlusAssign(); + antlr4::tree::TerminalNode *MinusAssign(); + antlr4::tree::TerminalNode *StarAssign(); + antlr4::tree::TerminalNode *ModAssign(); + antlr4::tree::TerminalNode *XorAssign(); + antlr4::tree::TerminalNode *AndAssign(); + antlr4::tree::TerminalNode *OrAssign(); + antlr4::tree::TerminalNode *RightShiftAssign(); + antlr4::tree::TerminalNode *LeftShiftAssign(); + antlr4::tree::TerminalNode *Equal(); + antlr4::tree::TerminalNode *NotEqual(); + antlr4::tree::TerminalNode *LessEqual(); + antlr4::tree::TerminalNode *AndAnd(); + antlr4::tree::TerminalNode *OrOr(); + antlr4::tree::TerminalNode *PlusPlus(); + antlr4::tree::TerminalNode *MinusMinus(); + antlr4::tree::TerminalNode *Comma(); + antlr4::tree::TerminalNode *ArrowStar(); + antlr4::tree::TerminalNode *Arrow(); + antlr4::tree::TerminalNode *LeftParen(); + antlr4::tree::TerminalNode *RightParen(); + + + }; + + TheOperatorContext* theOperator(); + + class LiteralContext : public antlr4::ParserRuleContext { + public: + LiteralContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *IntegerLiteral(); + antlr4::tree::TerminalNode *CharacterLiteral(); + antlr4::tree::TerminalNode *FloatingLiteral(); + antlr4::tree::TerminalNode *StringLiteral(); + antlr4::tree::TerminalNode *BooleanLiteral(); + antlr4::tree::TerminalNode *PointerLiteral(); + antlr4::tree::TerminalNode *UserDefinedLiteral(); + + + }; + + LiteralContext* literal(); + + + bool sempred(antlr4::RuleContext *_localctx, size_t ruleIndex, size_t predicateIndex) override; + + bool nestedNameSpecifierSempred(NestedNameSpecifierContext *_localctx, size_t predicateIndex); + bool postfixExpressionSempred(PostfixExpressionContext *_localctx, size_t predicateIndex); + bool noPointerNewDeclaratorSempred(NoPointerNewDeclaratorContext *_localctx, size_t predicateIndex); + bool noPointerDeclaratorSempred(NoPointerDeclaratorContext *_localctx, size_t predicateIndex); + bool noPointerAbstractDeclaratorSempred(NoPointerAbstractDeclaratorContext *_localctx, size_t predicateIndex); + bool noPointerAbstractPackDeclaratorSempred(NoPointerAbstractPackDeclaratorContext *_localctx, size_t predicateIndex); + + // By default the static state used to implement the parser is lazily initialized during the first + // call to the constructor. You can call this function if you wish to initialize the static state + // ahead of time. + static void initialize(); + +private: +}; + +} // namespace antlrcpptest diff --git a/server/pkg/antlr/cpp14/include/MyCppAntlr.h b/server/pkg/antlr/cpp14/include/MyCppAntlr.h new file mode 100644 index 0000000000000000000000000000000000000000..561ba34a7c0ebb9c5b644cc430f3d593524103be --- /dev/null +++ b/server/pkg/antlr/cpp14/include/MyCppAntlr.h @@ -0,0 +1,31 @@ +#pragma once + +#include +#include +#include + +#include "CPP14Lexer.h" +#include "CPP14Parser.h" +#include "IAntlrWrapper.h" +#include "antlr4-runtime.h" + +class MyCppAntlr:IAntlrWrapper { + private: + std::unique_ptr lexer_ptr; + std::unique_ptr parser_ptr; + std::unique_ptr input_ptr; + std::unique_ptr tokenStream_ptr; + + public: + MyCppAntlr(std::unique_ptr input, + std::unique_ptr tokenStream, + std::unique_ptr lexer, + std::unique_ptr parser); + + static std::unique_ptr init(std::ifstream &in); + + std::vector getTokens() override; + + // antlr4::tree::ParseTree *getTree(); + std::string getTreeString() override; +}; diff --git a/server/pkg/antlr/cpp14/src/CPP14Lexer.cpp b/server/pkg/antlr/cpp14/src/CPP14Lexer.cpp new file mode 100644 index 0000000000000000000000000000000000000000..f2c86238722eedf1e32c01f8bafff787f61fdd95 --- /dev/null +++ b/server/pkg/antlr/cpp14/src/CPP14Lexer.cpp @@ -0,0 +1,718 @@ + +// Generated from CPP14Lexer.g4 by ANTLR 4.12.0 + + +#include "CPP14Lexer.h" + + +using namespace antlr4; + +using namespace antlrcpptest; + + +using namespace antlr4; + +namespace { + +struct CPP14LexerStaticData final { + CPP14LexerStaticData(std::vector ruleNames, + std::vector channelNames, + std::vector modeNames, + std::vector literalNames, + std::vector symbolicNames) + : ruleNames(std::move(ruleNames)), channelNames(std::move(channelNames)), + modeNames(std::move(modeNames)), literalNames(std::move(literalNames)), + symbolicNames(std::move(symbolicNames)), + vocabulary(this->literalNames, this->symbolicNames) {} + + CPP14LexerStaticData(const CPP14LexerStaticData&) = delete; + CPP14LexerStaticData(CPP14LexerStaticData&&) = delete; + CPP14LexerStaticData& operator=(const CPP14LexerStaticData&) = delete; + CPP14LexerStaticData& operator=(CPP14LexerStaticData&&) = delete; + + std::vector decisionToDFA; + antlr4::atn::PredictionContextCache sharedContextCache; + const std::vector ruleNames; + const std::vector channelNames; + const std::vector modeNames; + const std::vector literalNames; + const std::vector symbolicNames; + const antlr4::dfa::Vocabulary vocabulary; + antlr4::atn::SerializedATNView serializedATN; + std::unique_ptr atn; +}; + +::antlr4::internal::OnceFlag cpp14lexerLexerOnceFlag; +CPP14LexerStaticData *cpp14lexerLexerStaticData = nullptr; + +void cpp14lexerLexerInitialize() { + assert(cpp14lexerLexerStaticData == nullptr); + auto staticData = std::make_unique( + std::vector{ + "IntegerLiteral", "CharacterLiteral", "FloatingLiteral", "StringLiteral", + "BooleanLiteral", "PointerLiteral", "UserDefinedLiteral", "MultiLineMacro", + "Directive", "Alignas", "Alignof", "Asm", "Auto", "Bool", "Break", + "Case", "Catch", "Char", "Char16", "Char32", "Class", "Const", "Constexpr", + "Const_cast", "Continue", "Decltype", "Default", "Delete", "Do", "Double", + "Dynamic_cast", "Else", "Enum", "Explicit", "Export", "Extern", "False_", + "Final", "Float", "For", "Friend", "Goto", "If", "Inline", "Int", + "Long", "Mutable", "Namespace", "New", "Noexcept", "Nullptr", "Operator", + "Override", "Private", "Protected", "Public", "Register", "Reinterpret_cast", + "Return", "Short", "Signed", "Sizeof", "Static", "Static_assert", + "Static_cast", "Struct", "Switch", "Template", "This", "Thread_local", + "Throw", "True_", "Try", "Typedef", "Typeid_", "Typename_", "Union", + "Unsigned", "Using", "Virtual", "Void", "Volatile", "Wchar", "While", + "LeftParen", "RightParen", "LeftBracket", "RightBracket", "LeftBrace", + "RightBrace", "Plus", "Minus", "Star", "Div", "Mod", "Caret", "And", + "Or", "Tilde", "Not", "Assign", "Less", "Greater", "PlusAssign", "MinusAssign", + "StarAssign", "DivAssign", "ModAssign", "XorAssign", "AndAssign", + "OrAssign", "LeftShiftAssign", "RightShiftAssign", "Equal", "NotEqual", + "LessEqual", "GreaterEqual", "AndAnd", "OrOr", "PlusPlus", "MinusMinus", + "Comma", "ArrowStar", "Arrow", "Question", "Colon", "Doublecolon", + "Semi", "Dot", "DotStar", "Ellipsis", "Hexquad", "Universalcharactername", + "Identifier", "Identifiernondigit", "NONDIGIT", "DIGIT", "DecimalLiteral", + "OctalLiteral", "HexadecimalLiteral", "BinaryLiteral", "NONZERODIGIT", + "OCTALDIGIT", "HEXADECIMALDIGIT", "BINARYDIGIT", "Integersuffix", + "Unsignedsuffix", "Longsuffix", "Longlongsuffix", "Cchar", "Escapesequence", + "Simpleescapesequence", "Octalescapesequence", "Hexadecimalescapesequence", + "Fractionalconstant", "Exponentpart", "SIGN", "Digitsequence", "Floatingsuffix", + "Encodingprefix", "Schar", "Rawstring", "UserDefinedIntegerLiteral", + "UserDefinedFloatingLiteral", "UserDefinedStringLiteral", "UserDefinedCharacterLiteral", + "Udsuffix", "Whitespace", "Newline", "BlockComment", "LineComment" + }, + std::vector{ + "DEFAULT_TOKEN_CHANNEL", "HIDDEN" + }, + std::vector{ + "DEFAULT_MODE" + }, + std::vector{ + "", "", "", "", "", "", "", "", "", "", "'alignas'", "'alignof'", + "'asm'", "'auto'", "'bool'", "'break'", "'case'", "'catch'", "'char'", + "'char16_t'", "'char32_t'", "'class'", "'const'", "'constexpr'", "'const_cast'", + "'continue'", "'decltype'", "'default'", "'delete'", "'do'", "'double'", + "'dynamic_cast'", "'else'", "'enum'", "'explicit'", "'export'", "'extern'", + "'false'", "'final'", "'float'", "'for'", "'friend'", "'goto'", "'if'", + "'inline'", "'int'", "'long'", "'mutable'", "'namespace'", "'new'", + "'noexcept'", "'nullptr'", "'operator'", "'override'", "'private'", + "'protected'", "'public'", "'register'", "'reinterpret_cast'", "'return'", + "'short'", "'signed'", "'sizeof'", "'static'", "'static_assert'", + "'static_cast'", "'struct'", "'switch'", "'template'", "'this'", "'thread_local'", + "'throw'", "'true'", "'try'", "'typedef'", "'typeid'", "'typename'", + "'union'", "'unsigned'", "'using'", "'virtual'", "'void'", "'volatile'", + "'wchar_t'", "'while'", "'('", "')'", "'['", "']'", "'{'", "'}'", + "'+'", "'-'", "'*'", "'/'", "'%'", "'^'", "'&'", "'|'", "'~'", "", + "'='", "'<'", "'>'", "'+='", "'-='", "'*='", "'/='", "'%='", "'^='", + "'&='", "'|='", "'<<='", "'>>='", "'=='", "'!='", "'<='", "'>='", + "", "", "'++'", "'--'", "','", "'->*'", "'->'", "'\\u003F'", "':'", + "'::'", "';'", "'.'", "'.*'", "'...'" + }, + std::vector{ + "", "IntegerLiteral", "CharacterLiteral", "FloatingLiteral", "StringLiteral", + "BooleanLiteral", "PointerLiteral", "UserDefinedLiteral", "MultiLineMacro", + "Directive", "Alignas", "Alignof", "Asm", "Auto", "Bool", "Break", + "Case", "Catch", "Char", "Char16", "Char32", "Class", "Const", "Constexpr", + "Const_cast", "Continue", "Decltype", "Default", "Delete", "Do", "Double", + "Dynamic_cast", "Else", "Enum", "Explicit", "Export", "Extern", "False_", + "Final", "Float", "For", "Friend", "Goto", "If", "Inline", "Int", + "Long", "Mutable", "Namespace", "New", "Noexcept", "Nullptr", "Operator", + "Override", "Private", "Protected", "Public", "Register", "Reinterpret_cast", + "Return", "Short", "Signed", "Sizeof", "Static", "Static_assert", + "Static_cast", "Struct", "Switch", "Template", "This", "Thread_local", + "Throw", "True_", "Try", "Typedef", "Typeid_", "Typename_", "Union", + "Unsigned", "Using", "Virtual", "Void", "Volatile", "Wchar", "While", + "LeftParen", "RightParen", "LeftBracket", "RightBracket", "LeftBrace", + "RightBrace", "Plus", "Minus", "Star", "Div", "Mod", "Caret", "And", + "Or", "Tilde", "Not", "Assign", "Less", "Greater", "PlusAssign", "MinusAssign", + "StarAssign", "DivAssign", "ModAssign", "XorAssign", "AndAssign", + "OrAssign", "LeftShiftAssign", "RightShiftAssign", "Equal", "NotEqual", + "LessEqual", "GreaterEqual", "AndAnd", "OrOr", "PlusPlus", "MinusMinus", + "Comma", "ArrowStar", "Arrow", "Question", "Colon", "Doublecolon", + "Semi", "Dot", "DotStar", "Ellipsis", "Identifier", "DecimalLiteral", + "OctalLiteral", "HexadecimalLiteral", "BinaryLiteral", "Integersuffix", + "UserDefinedIntegerLiteral", "UserDefinedFloatingLiteral", "UserDefinedStringLiteral", + "UserDefinedCharacterLiteral", "Whitespace", "Newline", "BlockComment", + "LineComment" + } + ); + static const int32_t serializedATNSegment[] = { + 4,0,145,1460,6,-1,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6, + 7,6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13,7,13,2, + 14,7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,19,2,20,7,20,2, + 21,7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2,26,7,26,2,27,7,27,2, + 28,7,28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7,32,2,33,7,33,2,34,7,34,2, + 35,7,35,2,36,7,36,2,37,7,37,2,38,7,38,2,39,7,39,2,40,7,40,2,41,7,41,2, + 42,7,42,2,43,7,43,2,44,7,44,2,45,7,45,2,46,7,46,2,47,7,47,2,48,7,48,2, + 49,7,49,2,50,7,50,2,51,7,51,2,52,7,52,2,53,7,53,2,54,7,54,2,55,7,55,2, + 56,7,56,2,57,7,57,2,58,7,58,2,59,7,59,2,60,7,60,2,61,7,61,2,62,7,62,2, + 63,7,63,2,64,7,64,2,65,7,65,2,66,7,66,2,67,7,67,2,68,7,68,2,69,7,69,2, + 70,7,70,2,71,7,71,2,72,7,72,2,73,7,73,2,74,7,74,2,75,7,75,2,76,7,76,2, + 77,7,77,2,78,7,78,2,79,7,79,2,80,7,80,2,81,7,81,2,82,7,82,2,83,7,83,2, + 84,7,84,2,85,7,85,2,86,7,86,2,87,7,87,2,88,7,88,2,89,7,89,2,90,7,90,2, + 91,7,91,2,92,7,92,2,93,7,93,2,94,7,94,2,95,7,95,2,96,7,96,2,97,7,97,2, + 98,7,98,2,99,7,99,2,100,7,100,2,101,7,101,2,102,7,102,2,103,7,103,2,104, + 7,104,2,105,7,105,2,106,7,106,2,107,7,107,2,108,7,108,2,109,7,109,2,110, + 7,110,2,111,7,111,2,112,7,112,2,113,7,113,2,114,7,114,2,115,7,115,2,116, + 7,116,2,117,7,117,2,118,7,118,2,119,7,119,2,120,7,120,2,121,7,121,2,122, + 7,122,2,123,7,123,2,124,7,124,2,125,7,125,2,126,7,126,2,127,7,127,2,128, + 7,128,2,129,7,129,2,130,7,130,2,131,7,131,2,132,7,132,2,133,7,133,2,134, + 7,134,2,135,7,135,2,136,7,136,2,137,7,137,2,138,7,138,2,139,7,139,2,140, + 7,140,2,141,7,141,2,142,7,142,2,143,7,143,2,144,7,144,2,145,7,145,2,146, + 7,146,2,147,7,147,2,148,7,148,2,149,7,149,2,150,7,150,2,151,7,151,2,152, + 7,152,2,153,7,153,2,154,7,154,2,155,7,155,2,156,7,156,2,157,7,157,2,158, + 7,158,2,159,7,159,2,160,7,160,2,161,7,161,2,162,7,162,2,163,7,163,2,164, + 7,164,2,165,7,165,2,166,7,166,2,167,7,167,2,168,7,168,2,169,7,169,2,170, + 7,170,1,0,1,0,3,0,346,8,0,1,0,1,0,3,0,350,8,0,1,0,1,0,3,0,354,8,0,1,0, + 1,0,3,0,358,8,0,3,0,360,8,0,1,1,3,1,363,8,1,1,1,1,1,4,1,367,8,1,11,1, + 12,1,368,1,1,1,1,1,2,1,2,3,2,375,8,2,1,2,3,2,378,8,2,1,2,1,2,1,2,3,2, + 383,8,2,3,2,385,8,2,1,3,3,3,388,8,3,1,3,1,3,1,3,5,3,393,8,3,10,3,12,3, + 396,9,3,1,3,3,3,399,8,3,1,4,1,4,3,4,403,8,4,1,5,1,5,1,6,1,6,1,6,1,6,3, + 6,411,8,6,1,7,1,7,5,7,415,8,7,10,7,12,7,418,9,7,1,7,1,7,3,7,422,8,7,1, + 7,4,7,425,8,7,11,7,12,7,426,1,7,4,7,430,8,7,11,7,12,7,431,1,7,1,7,1,8, + 1,8,5,8,438,8,8,10,8,12,8,441,9,8,1,8,1,8,1,9,1,9,1,9,1,9,1,9,1,9,1,9, + 1,9,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,11,1,11,1,11,1,11,1,12, + 1,12,1,12,1,12,1,12,1,13,1,13,1,13,1,13,1,13,1,14,1,14,1,14,1,14,1,14, + 1,14,1,15,1,15,1,15,1,15,1,15,1,16,1,16,1,16,1,16,1,16,1,16,1,17,1,17, + 1,17,1,17,1,17,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,19,1,19, + 1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,20,1,20,1,20,1,20,1,20,1,20,1,21, + 1,21,1,21,1,21,1,21,1,21,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22, + 1,22,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,24,1,24, + 1,24,1,24,1,24,1,24,1,24,1,24,1,24,1,25,1,25,1,25,1,25,1,25,1,25,1,25, + 1,25,1,25,1,26,1,26,1,26,1,26,1,26,1,26,1,26,1,26,1,27,1,27,1,27,1,27, + 1,27,1,27,1,27,1,28,1,28,1,28,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,30, + 1,30,1,30,1,30,1,30,1,30,1,30,1,30,1,30,1,30,1,30,1,30,1,30,1,31,1,31, + 1,31,1,31,1,31,1,32,1,32,1,32,1,32,1,32,1,33,1,33,1,33,1,33,1,33,1,33, + 1,33,1,33,1,33,1,34,1,34,1,34,1,34,1,34,1,34,1,34,1,35,1,35,1,35,1,35, + 1,35,1,35,1,35,1,36,1,36,1,36,1,36,1,36,1,36,1,37,1,37,1,37,1,37,1,37, + 1,37,1,38,1,38,1,38,1,38,1,38,1,38,1,39,1,39,1,39,1,39,1,40,1,40,1,40, + 1,40,1,40,1,40,1,40,1,41,1,41,1,41,1,41,1,41,1,42,1,42,1,42,1,43,1,43, + 1,43,1,43,1,43,1,43,1,43,1,44,1,44,1,44,1,44,1,45,1,45,1,45,1,45,1,45, + 1,46,1,46,1,46,1,46,1,46,1,46,1,46,1,46,1,47,1,47,1,47,1,47,1,47,1,47, + 1,47,1,47,1,47,1,47,1,48,1,48,1,48,1,48,1,49,1,49,1,49,1,49,1,49,1,49, + 1,49,1,49,1,49,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,51,1,51,1,51, + 1,51,1,51,1,51,1,51,1,51,1,51,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52, + 1,52,1,53,1,53,1,53,1,53,1,53,1,53,1,53,1,53,1,54,1,54,1,54,1,54,1,54, + 1,54,1,54,1,54,1,54,1,54,1,55,1,55,1,55,1,55,1,55,1,55,1,55,1,56,1,56, + 1,56,1,56,1,56,1,56,1,56,1,56,1,56,1,57,1,57,1,57,1,57,1,57,1,57,1,57, + 1,57,1,57,1,57,1,57,1,57,1,57,1,57,1,57,1,57,1,57,1,58,1,58,1,58,1,58, + 1,58,1,58,1,58,1,59,1,59,1,59,1,59,1,59,1,59,1,60,1,60,1,60,1,60,1,60, + 1,60,1,60,1,61,1,61,1,61,1,61,1,61,1,61,1,61,1,62,1,62,1,62,1,62,1,62, + 1,62,1,62,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63, + 1,63,1,63,1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,64, + 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,66,1,66,1,66,1,66,1,66,1,66,1,66, + 1,67,1,67,1,67,1,67,1,67,1,67,1,67,1,67,1,67,1,68,1,68,1,68,1,68,1,68, + 1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,70, + 1,70,1,70,1,70,1,70,1,70,1,71,1,71,1,71,1,71,1,71,1,72,1,72,1,72,1,72, + 1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,74,1,74,1,74,1,74,1,74,1,74, + 1,74,1,75,1,75,1,75,1,75,1,75,1,75,1,75,1,75,1,75,1,76,1,76,1,76,1,76, + 1,76,1,76,1,77,1,77,1,77,1,77,1,77,1,77,1,77,1,77,1,77,1,78,1,78,1,78, + 1,78,1,78,1,78,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,80,1,80,1,80, + 1,80,1,80,1,81,1,81,1,81,1,81,1,81,1,81,1,81,1,81,1,81,1,82,1,82,1,82, + 1,82,1,82,1,82,1,82,1,82,1,83,1,83,1,83,1,83,1,83,1,83,1,84,1,84,1,85, + 1,85,1,86,1,86,1,87,1,87,1,88,1,88,1,89,1,89,1,90,1,90,1,91,1,91,1,92, + 1,92,1,93,1,93,1,94,1,94,1,95,1,95,1,96,1,96,1,97,1,97,1,98,1,98,1,99, + 1,99,1,99,1,99,3,99,1029,8,99,1,100,1,100,1,101,1,101,1,102,1,102,1,103, + 1,103,1,103,1,104,1,104,1,104,1,105,1,105,1,105,1,106,1,106,1,106,1,107, + 1,107,1,107,1,108,1,108,1,108,1,109,1,109,1,109,1,110,1,110,1,110,1,111, + 1,111,1,111,1,111,1,112,1,112,1,112,1,112,1,113,1,113,1,113,1,114,1,114, + 1,114,1,115,1,115,1,115,1,116,1,116,1,116,1,117,1,117,1,117,1,117,1,117, + 3,117,1086,8,117,1,118,1,118,1,118,1,118,3,118,1092,8,118,1,119,1,119, + 1,119,1,120,1,120,1,120,1,121,1,121,1,122,1,122,1,122,1,122,1,123,1,123, + 1,123,1,124,1,124,1,125,1,125,1,126,1,126,1,126,1,127,1,127,1,128,1,128, + 1,129,1,129,1,129,1,130,1,130,1,130,1,130,1,131,1,131,1,131,1,131,1,131, + 1,132,1,132,1,132,1,132,1,132,1,132,1,132,1,132,1,132,1,132,3,132,1142, + 8,132,1,133,1,133,1,133,5,133,1147,8,133,10,133,12,133,1150,9,133,1,134, + 1,134,3,134,1154,8,134,1,135,1,135,1,136,1,136,1,137,1,137,3,137,1162, + 8,137,1,137,5,137,1165,8,137,10,137,12,137,1168,9,137,1,138,1,138,3,138, + 1172,8,138,1,138,5,138,1175,8,138,10,138,12,138,1178,9,138,1,139,1,139, + 1,139,1,139,3,139,1184,8,139,1,139,1,139,3,139,1188,8,139,1,139,5,139, + 1191,8,139,10,139,12,139,1194,9,139,1,140,1,140,1,140,1,140,3,140,1200, + 8,140,1,140,1,140,3,140,1204,8,140,1,140,5,140,1207,8,140,10,140,12,140, + 1210,9,140,1,141,1,141,1,142,1,142,1,143,1,143,1,144,1,144,1,145,1,145, + 3,145,1222,8,145,1,145,1,145,3,145,1226,8,145,1,145,1,145,3,145,1230, + 8,145,1,145,1,145,3,145,1234,8,145,3,145,1236,8,145,1,146,1,146,1,147, + 1,147,1,148,1,148,1,148,1,148,3,148,1246,8,148,1,149,1,149,1,149,3,149, + 1251,8,149,1,150,1,150,1,150,3,150,1256,8,150,1,151,1,151,1,151,1,151, + 1,151,1,151,1,151,1,151,1,151,1,151,1,151,1,151,1,151,1,151,1,151,1,151, + 1,151,1,151,1,151,1,151,1,151,3,151,1279,8,151,1,151,3,151,1282,8,151, + 1,151,1,151,1,151,1,151,3,151,1288,8,151,1,152,1,152,1,152,1,152,1,152, + 1,152,1,152,1,152,1,152,1,152,1,152,3,152,1301,8,152,1,153,1,153,1,153, + 1,153,4,153,1307,8,153,11,153,12,153,1308,1,154,3,154,1312,8,154,1,154, + 1,154,1,154,1,154,1,154,3,154,1319,8,154,1,155,1,155,3,155,1323,8,155, + 1,155,1,155,1,155,3,155,1328,8,155,1,155,3,155,1331,8,155,1,156,1,156, + 1,157,1,157,3,157,1337,8,157,1,157,5,157,1340,8,157,10,157,12,157,1343, + 9,157,1,158,1,158,1,159,1,159,1,159,3,159,1350,8,159,1,160,1,160,1,160, + 3,160,1355,8,160,1,161,1,161,1,161,1,161,1,161,1,161,5,161,1363,8,161, + 10,161,12,161,1366,9,161,1,161,1,161,5,161,1370,8,161,10,161,12,161,1373, + 9,161,1,161,1,161,1,161,1,161,5,161,1379,8,161,10,161,12,161,1382,9,161, + 1,161,1,161,1,162,1,162,1,162,1,162,1,162,1,162,1,162,1,162,1,162,1,162, + 1,162,1,162,3,162,1398,8,162,1,163,1,163,3,163,1402,8,163,1,163,1,163, + 1,163,1,163,1,163,1,163,3,163,1410,8,163,1,164,1,164,1,164,1,165,1,165, + 1,165,1,166,1,166,1,167,4,167,1421,8,167,11,167,12,167,1422,1,167,1,167, + 1,168,1,168,3,168,1429,8,168,1,168,3,168,1432,8,168,1,168,1,168,1,169, + 1,169,1,169,1,169,5,169,1440,8,169,10,169,12,169,1443,9,169,1,169,1,169, + 1,169,1,169,1,169,1,170,1,170,1,170,1,170,5,170,1454,8,170,10,170,12, + 170,1457,9,170,1,170,1,170,5,416,1364,1371,1380,1441,0,171,1,1,3,2,5, + 3,7,4,9,5,11,6,13,7,15,8,17,9,19,10,21,11,23,12,25,13,27,14,29,15,31, + 16,33,17,35,18,37,19,39,20,41,21,43,22,45,23,47,24,49,25,51,26,53,27, + 55,28,57,29,59,30,61,31,63,32,65,33,67,34,69,35,71,36,73,37,75,38,77, + 39,79,40,81,41,83,42,85,43,87,44,89,45,91,46,93,47,95,48,97,49,99,50, + 101,51,103,52,105,53,107,54,109,55,111,56,113,57,115,58,117,59,119,60, + 121,61,123,62,125,63,127,64,129,65,131,66,133,67,135,68,137,69,139,70, + 141,71,143,72,145,73,147,74,149,75,151,76,153,77,155,78,157,79,159,80, + 161,81,163,82,165,83,167,84,169,85,171,86,173,87,175,88,177,89,179,90, + 181,91,183,92,185,93,187,94,189,95,191,96,193,97,195,98,197,99,199,100, + 201,101,203,102,205,103,207,104,209,105,211,106,213,107,215,108,217,109, + 219,110,221,111,223,112,225,113,227,114,229,115,231,116,233,117,235,118, + 237,119,239,120,241,121,243,122,245,123,247,124,249,125,251,126,253,127, + 255,128,257,129,259,130,261,131,263,0,265,0,267,132,269,0,271,0,273,0, + 275,133,277,134,279,135,281,136,283,0,285,0,287,0,289,0,291,137,293,0, + 295,0,297,0,299,0,301,0,303,0,305,0,307,0,309,0,311,0,313,0,315,0,317, + 0,319,0,321,0,323,0,325,138,327,139,329,140,331,141,333,0,335,142,337, + 143,339,144,341,145,1,0,20,3,0,76,76,85,85,117,117,1,0,10,10,3,0,65,90, + 95,95,97,122,1,0,48,57,1,0,49,57,1,0,48,55,3,0,48,57,65,70,97,102,1,0, + 48,49,2,0,85,85,117,117,2,0,76,76,108,108,4,0,10,10,13,13,39,39,92,92, + 2,0,43,43,45,45,4,0,70,70,76,76,102,102,108,108,4,0,10,10,13,13,34,34, + 92,92,2,0,34,34,40,41,4,0,10,10,13,13,32,32,40,40,1,0,41,41,4,0,10,10, + 13,13,32,32,34,34,2,0,9,9,32,32,2,0,10,10,13,13,1528,0,1,1,0,0,0,0,3, + 1,0,0,0,0,5,1,0,0,0,0,7,1,0,0,0,0,9,1,0,0,0,0,11,1,0,0,0,0,13,1,0,0,0, + 0,15,1,0,0,0,0,17,1,0,0,0,0,19,1,0,0,0,0,21,1,0,0,0,0,23,1,0,0,0,0,25, + 1,0,0,0,0,27,1,0,0,0,0,29,1,0,0,0,0,31,1,0,0,0,0,33,1,0,0,0,0,35,1,0, + 0,0,0,37,1,0,0,0,0,39,1,0,0,0,0,41,1,0,0,0,0,43,1,0,0,0,0,45,1,0,0,0, + 0,47,1,0,0,0,0,49,1,0,0,0,0,51,1,0,0,0,0,53,1,0,0,0,0,55,1,0,0,0,0,57, + 1,0,0,0,0,59,1,0,0,0,0,61,1,0,0,0,0,63,1,0,0,0,0,65,1,0,0,0,0,67,1,0, + 0,0,0,69,1,0,0,0,0,71,1,0,0,0,0,73,1,0,0,0,0,75,1,0,0,0,0,77,1,0,0,0, + 0,79,1,0,0,0,0,81,1,0,0,0,0,83,1,0,0,0,0,85,1,0,0,0,0,87,1,0,0,0,0,89, + 1,0,0,0,0,91,1,0,0,0,0,93,1,0,0,0,0,95,1,0,0,0,0,97,1,0,0,0,0,99,1,0, + 0,0,0,101,1,0,0,0,0,103,1,0,0,0,0,105,1,0,0,0,0,107,1,0,0,0,0,109,1,0, + 0,0,0,111,1,0,0,0,0,113,1,0,0,0,0,115,1,0,0,0,0,117,1,0,0,0,0,119,1,0, + 0,0,0,121,1,0,0,0,0,123,1,0,0,0,0,125,1,0,0,0,0,127,1,0,0,0,0,129,1,0, + 0,0,0,131,1,0,0,0,0,133,1,0,0,0,0,135,1,0,0,0,0,137,1,0,0,0,0,139,1,0, + 0,0,0,141,1,0,0,0,0,143,1,0,0,0,0,145,1,0,0,0,0,147,1,0,0,0,0,149,1,0, + 0,0,0,151,1,0,0,0,0,153,1,0,0,0,0,155,1,0,0,0,0,157,1,0,0,0,0,159,1,0, + 0,0,0,161,1,0,0,0,0,163,1,0,0,0,0,165,1,0,0,0,0,167,1,0,0,0,0,169,1,0, + 0,0,0,171,1,0,0,0,0,173,1,0,0,0,0,175,1,0,0,0,0,177,1,0,0,0,0,179,1,0, + 0,0,0,181,1,0,0,0,0,183,1,0,0,0,0,185,1,0,0,0,0,187,1,0,0,0,0,189,1,0, + 0,0,0,191,1,0,0,0,0,193,1,0,0,0,0,195,1,0,0,0,0,197,1,0,0,0,0,199,1,0, + 0,0,0,201,1,0,0,0,0,203,1,0,0,0,0,205,1,0,0,0,0,207,1,0,0,0,0,209,1,0, + 0,0,0,211,1,0,0,0,0,213,1,0,0,0,0,215,1,0,0,0,0,217,1,0,0,0,0,219,1,0, + 0,0,0,221,1,0,0,0,0,223,1,0,0,0,0,225,1,0,0,0,0,227,1,0,0,0,0,229,1,0, + 0,0,0,231,1,0,0,0,0,233,1,0,0,0,0,235,1,0,0,0,0,237,1,0,0,0,0,239,1,0, + 0,0,0,241,1,0,0,0,0,243,1,0,0,0,0,245,1,0,0,0,0,247,1,0,0,0,0,249,1,0, + 0,0,0,251,1,0,0,0,0,253,1,0,0,0,0,255,1,0,0,0,0,257,1,0,0,0,0,259,1,0, + 0,0,0,261,1,0,0,0,0,267,1,0,0,0,0,275,1,0,0,0,0,277,1,0,0,0,0,279,1,0, + 0,0,0,281,1,0,0,0,0,291,1,0,0,0,0,325,1,0,0,0,0,327,1,0,0,0,0,329,1,0, + 0,0,0,331,1,0,0,0,0,335,1,0,0,0,0,337,1,0,0,0,0,339,1,0,0,0,0,341,1,0, + 0,0,1,359,1,0,0,0,3,362,1,0,0,0,5,384,1,0,0,0,7,387,1,0,0,0,9,402,1,0, + 0,0,11,404,1,0,0,0,13,410,1,0,0,0,15,412,1,0,0,0,17,435,1,0,0,0,19,444, + 1,0,0,0,21,452,1,0,0,0,23,460,1,0,0,0,25,464,1,0,0,0,27,469,1,0,0,0,29, + 474,1,0,0,0,31,480,1,0,0,0,33,485,1,0,0,0,35,491,1,0,0,0,37,496,1,0,0, + 0,39,505,1,0,0,0,41,514,1,0,0,0,43,520,1,0,0,0,45,526,1,0,0,0,47,536, + 1,0,0,0,49,547,1,0,0,0,51,556,1,0,0,0,53,565,1,0,0,0,55,573,1,0,0,0,57, + 580,1,0,0,0,59,583,1,0,0,0,61,590,1,0,0,0,63,603,1,0,0,0,65,608,1,0,0, + 0,67,613,1,0,0,0,69,622,1,0,0,0,71,629,1,0,0,0,73,636,1,0,0,0,75,642, + 1,0,0,0,77,648,1,0,0,0,79,654,1,0,0,0,81,658,1,0,0,0,83,665,1,0,0,0,85, + 670,1,0,0,0,87,673,1,0,0,0,89,680,1,0,0,0,91,684,1,0,0,0,93,689,1,0,0, + 0,95,697,1,0,0,0,97,707,1,0,0,0,99,711,1,0,0,0,101,720,1,0,0,0,103,728, + 1,0,0,0,105,737,1,0,0,0,107,746,1,0,0,0,109,754,1,0,0,0,111,764,1,0,0, + 0,113,771,1,0,0,0,115,780,1,0,0,0,117,797,1,0,0,0,119,804,1,0,0,0,121, + 810,1,0,0,0,123,817,1,0,0,0,125,824,1,0,0,0,127,831,1,0,0,0,129,845,1, + 0,0,0,131,857,1,0,0,0,133,864,1,0,0,0,135,871,1,0,0,0,137,880,1,0,0,0, + 139,885,1,0,0,0,141,898,1,0,0,0,143,904,1,0,0,0,145,909,1,0,0,0,147,913, + 1,0,0,0,149,921,1,0,0,0,151,928,1,0,0,0,153,937,1,0,0,0,155,943,1,0,0, + 0,157,952,1,0,0,0,159,958,1,0,0,0,161,966,1,0,0,0,163,971,1,0,0,0,165, + 980,1,0,0,0,167,988,1,0,0,0,169,994,1,0,0,0,171,996,1,0,0,0,173,998,1, + 0,0,0,175,1000,1,0,0,0,177,1002,1,0,0,0,179,1004,1,0,0,0,181,1006,1,0, + 0,0,183,1008,1,0,0,0,185,1010,1,0,0,0,187,1012,1,0,0,0,189,1014,1,0,0, + 0,191,1016,1,0,0,0,193,1018,1,0,0,0,195,1020,1,0,0,0,197,1022,1,0,0,0, + 199,1028,1,0,0,0,201,1030,1,0,0,0,203,1032,1,0,0,0,205,1034,1,0,0,0,207, + 1036,1,0,0,0,209,1039,1,0,0,0,211,1042,1,0,0,0,213,1045,1,0,0,0,215,1048, + 1,0,0,0,217,1051,1,0,0,0,219,1054,1,0,0,0,221,1057,1,0,0,0,223,1060,1, + 0,0,0,225,1064,1,0,0,0,227,1068,1,0,0,0,229,1071,1,0,0,0,231,1074,1,0, + 0,0,233,1077,1,0,0,0,235,1085,1,0,0,0,237,1091,1,0,0,0,239,1093,1,0,0, + 0,241,1096,1,0,0,0,243,1099,1,0,0,0,245,1101,1,0,0,0,247,1105,1,0,0,0, + 249,1108,1,0,0,0,251,1110,1,0,0,0,253,1112,1,0,0,0,255,1115,1,0,0,0,257, + 1117,1,0,0,0,259,1119,1,0,0,0,261,1122,1,0,0,0,263,1126,1,0,0,0,265,1141, + 1,0,0,0,267,1143,1,0,0,0,269,1153,1,0,0,0,271,1155,1,0,0,0,273,1157,1, + 0,0,0,275,1159,1,0,0,0,277,1169,1,0,0,0,279,1183,1,0,0,0,281,1199,1,0, + 0,0,283,1211,1,0,0,0,285,1213,1,0,0,0,287,1215,1,0,0,0,289,1217,1,0,0, + 0,291,1235,1,0,0,0,293,1237,1,0,0,0,295,1239,1,0,0,0,297,1245,1,0,0,0, + 299,1250,1,0,0,0,301,1255,1,0,0,0,303,1287,1,0,0,0,305,1300,1,0,0,0,307, + 1302,1,0,0,0,309,1318,1,0,0,0,311,1330,1,0,0,0,313,1332,1,0,0,0,315,1334, + 1,0,0,0,317,1344,1,0,0,0,319,1349,1,0,0,0,321,1354,1,0,0,0,323,1356,1, + 0,0,0,325,1397,1,0,0,0,327,1409,1,0,0,0,329,1411,1,0,0,0,331,1414,1,0, + 0,0,333,1417,1,0,0,0,335,1420,1,0,0,0,337,1431,1,0,0,0,339,1435,1,0,0, + 0,341,1449,1,0,0,0,343,345,3,275,137,0,344,346,3,291,145,0,345,344,1, + 0,0,0,345,346,1,0,0,0,346,360,1,0,0,0,347,349,3,277,138,0,348,350,3,291, + 145,0,349,348,1,0,0,0,349,350,1,0,0,0,350,360,1,0,0,0,351,353,3,279,139, + 0,352,354,3,291,145,0,353,352,1,0,0,0,353,354,1,0,0,0,354,360,1,0,0,0, + 355,357,3,281,140,0,356,358,3,291,145,0,357,356,1,0,0,0,357,358,1,0,0, + 0,358,360,1,0,0,0,359,343,1,0,0,0,359,347,1,0,0,0,359,351,1,0,0,0,359, + 355,1,0,0,0,360,2,1,0,0,0,361,363,7,0,0,0,362,361,1,0,0,0,362,363,1,0, + 0,0,363,364,1,0,0,0,364,366,5,39,0,0,365,367,3,299,149,0,366,365,1,0, + 0,0,367,368,1,0,0,0,368,366,1,0,0,0,368,369,1,0,0,0,369,370,1,0,0,0,370, + 371,5,39,0,0,371,4,1,0,0,0,372,374,3,309,154,0,373,375,3,311,155,0,374, + 373,1,0,0,0,374,375,1,0,0,0,375,377,1,0,0,0,376,378,3,317,158,0,377,376, + 1,0,0,0,377,378,1,0,0,0,378,385,1,0,0,0,379,380,3,315,157,0,380,382,3, + 311,155,0,381,383,3,317,158,0,382,381,1,0,0,0,382,383,1,0,0,0,383,385, + 1,0,0,0,384,372,1,0,0,0,384,379,1,0,0,0,385,6,1,0,0,0,386,388,3,319,159, + 0,387,386,1,0,0,0,387,388,1,0,0,0,388,398,1,0,0,0,389,399,3,323,161,0, + 390,394,5,34,0,0,391,393,3,321,160,0,392,391,1,0,0,0,393,396,1,0,0,0, + 394,392,1,0,0,0,394,395,1,0,0,0,395,397,1,0,0,0,396,394,1,0,0,0,397,399, + 5,34,0,0,398,389,1,0,0,0,398,390,1,0,0,0,399,8,1,0,0,0,400,403,3,73,36, + 0,401,403,3,143,71,0,402,400,1,0,0,0,402,401,1,0,0,0,403,10,1,0,0,0,404, + 405,3,101,50,0,405,12,1,0,0,0,406,411,3,325,162,0,407,411,3,327,163,0, + 408,411,3,329,164,0,409,411,3,331,165,0,410,406,1,0,0,0,410,407,1,0,0, + 0,410,408,1,0,0,0,410,409,1,0,0,0,411,14,1,0,0,0,412,424,5,35,0,0,413, + 415,8,1,0,0,414,413,1,0,0,0,415,418,1,0,0,0,416,417,1,0,0,0,416,414,1, + 0,0,0,417,419,1,0,0,0,418,416,1,0,0,0,419,421,5,92,0,0,420,422,5,13,0, + 0,421,420,1,0,0,0,421,422,1,0,0,0,422,423,1,0,0,0,423,425,5,10,0,0,424, + 416,1,0,0,0,425,426,1,0,0,0,426,424,1,0,0,0,426,427,1,0,0,0,427,429,1, + 0,0,0,428,430,8,1,0,0,429,428,1,0,0,0,430,431,1,0,0,0,431,429,1,0,0,0, + 431,432,1,0,0,0,432,433,1,0,0,0,433,434,6,7,0,0,434,16,1,0,0,0,435,439, + 5,35,0,0,436,438,8,1,0,0,437,436,1,0,0,0,438,441,1,0,0,0,439,437,1,0, + 0,0,439,440,1,0,0,0,440,442,1,0,0,0,441,439,1,0,0,0,442,443,6,8,0,0,443, + 18,1,0,0,0,444,445,5,97,0,0,445,446,5,108,0,0,446,447,5,105,0,0,447,448, + 5,103,0,0,448,449,5,110,0,0,449,450,5,97,0,0,450,451,5,115,0,0,451,20, + 1,0,0,0,452,453,5,97,0,0,453,454,5,108,0,0,454,455,5,105,0,0,455,456, + 5,103,0,0,456,457,5,110,0,0,457,458,5,111,0,0,458,459,5,102,0,0,459,22, + 1,0,0,0,460,461,5,97,0,0,461,462,5,115,0,0,462,463,5,109,0,0,463,24,1, + 0,0,0,464,465,5,97,0,0,465,466,5,117,0,0,466,467,5,116,0,0,467,468,5, + 111,0,0,468,26,1,0,0,0,469,470,5,98,0,0,470,471,5,111,0,0,471,472,5,111, + 0,0,472,473,5,108,0,0,473,28,1,0,0,0,474,475,5,98,0,0,475,476,5,114,0, + 0,476,477,5,101,0,0,477,478,5,97,0,0,478,479,5,107,0,0,479,30,1,0,0,0, + 480,481,5,99,0,0,481,482,5,97,0,0,482,483,5,115,0,0,483,484,5,101,0,0, + 484,32,1,0,0,0,485,486,5,99,0,0,486,487,5,97,0,0,487,488,5,116,0,0,488, + 489,5,99,0,0,489,490,5,104,0,0,490,34,1,0,0,0,491,492,5,99,0,0,492,493, + 5,104,0,0,493,494,5,97,0,0,494,495,5,114,0,0,495,36,1,0,0,0,496,497,5, + 99,0,0,497,498,5,104,0,0,498,499,5,97,0,0,499,500,5,114,0,0,500,501,5, + 49,0,0,501,502,5,54,0,0,502,503,5,95,0,0,503,504,5,116,0,0,504,38,1,0, + 0,0,505,506,5,99,0,0,506,507,5,104,0,0,507,508,5,97,0,0,508,509,5,114, + 0,0,509,510,5,51,0,0,510,511,5,50,0,0,511,512,5,95,0,0,512,513,5,116, + 0,0,513,40,1,0,0,0,514,515,5,99,0,0,515,516,5,108,0,0,516,517,5,97,0, + 0,517,518,5,115,0,0,518,519,5,115,0,0,519,42,1,0,0,0,520,521,5,99,0,0, + 521,522,5,111,0,0,522,523,5,110,0,0,523,524,5,115,0,0,524,525,5,116,0, + 0,525,44,1,0,0,0,526,527,5,99,0,0,527,528,5,111,0,0,528,529,5,110,0,0, + 529,530,5,115,0,0,530,531,5,116,0,0,531,532,5,101,0,0,532,533,5,120,0, + 0,533,534,5,112,0,0,534,535,5,114,0,0,535,46,1,0,0,0,536,537,5,99,0,0, + 537,538,5,111,0,0,538,539,5,110,0,0,539,540,5,115,0,0,540,541,5,116,0, + 0,541,542,5,95,0,0,542,543,5,99,0,0,543,544,5,97,0,0,544,545,5,115,0, + 0,545,546,5,116,0,0,546,48,1,0,0,0,547,548,5,99,0,0,548,549,5,111,0,0, + 549,550,5,110,0,0,550,551,5,116,0,0,551,552,5,105,0,0,552,553,5,110,0, + 0,553,554,5,117,0,0,554,555,5,101,0,0,555,50,1,0,0,0,556,557,5,100,0, + 0,557,558,5,101,0,0,558,559,5,99,0,0,559,560,5,108,0,0,560,561,5,116, + 0,0,561,562,5,121,0,0,562,563,5,112,0,0,563,564,5,101,0,0,564,52,1,0, + 0,0,565,566,5,100,0,0,566,567,5,101,0,0,567,568,5,102,0,0,568,569,5,97, + 0,0,569,570,5,117,0,0,570,571,5,108,0,0,571,572,5,116,0,0,572,54,1,0, + 0,0,573,574,5,100,0,0,574,575,5,101,0,0,575,576,5,108,0,0,576,577,5,101, + 0,0,577,578,5,116,0,0,578,579,5,101,0,0,579,56,1,0,0,0,580,581,5,100, + 0,0,581,582,5,111,0,0,582,58,1,0,0,0,583,584,5,100,0,0,584,585,5,111, + 0,0,585,586,5,117,0,0,586,587,5,98,0,0,587,588,5,108,0,0,588,589,5,101, + 0,0,589,60,1,0,0,0,590,591,5,100,0,0,591,592,5,121,0,0,592,593,5,110, + 0,0,593,594,5,97,0,0,594,595,5,109,0,0,595,596,5,105,0,0,596,597,5,99, + 0,0,597,598,5,95,0,0,598,599,5,99,0,0,599,600,5,97,0,0,600,601,5,115, + 0,0,601,602,5,116,0,0,602,62,1,0,0,0,603,604,5,101,0,0,604,605,5,108, + 0,0,605,606,5,115,0,0,606,607,5,101,0,0,607,64,1,0,0,0,608,609,5,101, + 0,0,609,610,5,110,0,0,610,611,5,117,0,0,611,612,5,109,0,0,612,66,1,0, + 0,0,613,614,5,101,0,0,614,615,5,120,0,0,615,616,5,112,0,0,616,617,5,108, + 0,0,617,618,5,105,0,0,618,619,5,99,0,0,619,620,5,105,0,0,620,621,5,116, + 0,0,621,68,1,0,0,0,622,623,5,101,0,0,623,624,5,120,0,0,624,625,5,112, + 0,0,625,626,5,111,0,0,626,627,5,114,0,0,627,628,5,116,0,0,628,70,1,0, + 0,0,629,630,5,101,0,0,630,631,5,120,0,0,631,632,5,116,0,0,632,633,5,101, + 0,0,633,634,5,114,0,0,634,635,5,110,0,0,635,72,1,0,0,0,636,637,5,102, + 0,0,637,638,5,97,0,0,638,639,5,108,0,0,639,640,5,115,0,0,640,641,5,101, + 0,0,641,74,1,0,0,0,642,643,5,102,0,0,643,644,5,105,0,0,644,645,5,110, + 0,0,645,646,5,97,0,0,646,647,5,108,0,0,647,76,1,0,0,0,648,649,5,102,0, + 0,649,650,5,108,0,0,650,651,5,111,0,0,651,652,5,97,0,0,652,653,5,116, + 0,0,653,78,1,0,0,0,654,655,5,102,0,0,655,656,5,111,0,0,656,657,5,114, + 0,0,657,80,1,0,0,0,658,659,5,102,0,0,659,660,5,114,0,0,660,661,5,105, + 0,0,661,662,5,101,0,0,662,663,5,110,0,0,663,664,5,100,0,0,664,82,1,0, + 0,0,665,666,5,103,0,0,666,667,5,111,0,0,667,668,5,116,0,0,668,669,5,111, + 0,0,669,84,1,0,0,0,670,671,5,105,0,0,671,672,5,102,0,0,672,86,1,0,0,0, + 673,674,5,105,0,0,674,675,5,110,0,0,675,676,5,108,0,0,676,677,5,105,0, + 0,677,678,5,110,0,0,678,679,5,101,0,0,679,88,1,0,0,0,680,681,5,105,0, + 0,681,682,5,110,0,0,682,683,5,116,0,0,683,90,1,0,0,0,684,685,5,108,0, + 0,685,686,5,111,0,0,686,687,5,110,0,0,687,688,5,103,0,0,688,92,1,0,0, + 0,689,690,5,109,0,0,690,691,5,117,0,0,691,692,5,116,0,0,692,693,5,97, + 0,0,693,694,5,98,0,0,694,695,5,108,0,0,695,696,5,101,0,0,696,94,1,0,0, + 0,697,698,5,110,0,0,698,699,5,97,0,0,699,700,5,109,0,0,700,701,5,101, + 0,0,701,702,5,115,0,0,702,703,5,112,0,0,703,704,5,97,0,0,704,705,5,99, + 0,0,705,706,5,101,0,0,706,96,1,0,0,0,707,708,5,110,0,0,708,709,5,101, + 0,0,709,710,5,119,0,0,710,98,1,0,0,0,711,712,5,110,0,0,712,713,5,111, + 0,0,713,714,5,101,0,0,714,715,5,120,0,0,715,716,5,99,0,0,716,717,5,101, + 0,0,717,718,5,112,0,0,718,719,5,116,0,0,719,100,1,0,0,0,720,721,5,110, + 0,0,721,722,5,117,0,0,722,723,5,108,0,0,723,724,5,108,0,0,724,725,5,112, + 0,0,725,726,5,116,0,0,726,727,5,114,0,0,727,102,1,0,0,0,728,729,5,111, + 0,0,729,730,5,112,0,0,730,731,5,101,0,0,731,732,5,114,0,0,732,733,5,97, + 0,0,733,734,5,116,0,0,734,735,5,111,0,0,735,736,5,114,0,0,736,104,1,0, + 0,0,737,738,5,111,0,0,738,739,5,118,0,0,739,740,5,101,0,0,740,741,5,114, + 0,0,741,742,5,114,0,0,742,743,5,105,0,0,743,744,5,100,0,0,744,745,5,101, + 0,0,745,106,1,0,0,0,746,747,5,112,0,0,747,748,5,114,0,0,748,749,5,105, + 0,0,749,750,5,118,0,0,750,751,5,97,0,0,751,752,5,116,0,0,752,753,5,101, + 0,0,753,108,1,0,0,0,754,755,5,112,0,0,755,756,5,114,0,0,756,757,5,111, + 0,0,757,758,5,116,0,0,758,759,5,101,0,0,759,760,5,99,0,0,760,761,5,116, + 0,0,761,762,5,101,0,0,762,763,5,100,0,0,763,110,1,0,0,0,764,765,5,112, + 0,0,765,766,5,117,0,0,766,767,5,98,0,0,767,768,5,108,0,0,768,769,5,105, + 0,0,769,770,5,99,0,0,770,112,1,0,0,0,771,772,5,114,0,0,772,773,5,101, + 0,0,773,774,5,103,0,0,774,775,5,105,0,0,775,776,5,115,0,0,776,777,5,116, + 0,0,777,778,5,101,0,0,778,779,5,114,0,0,779,114,1,0,0,0,780,781,5,114, + 0,0,781,782,5,101,0,0,782,783,5,105,0,0,783,784,5,110,0,0,784,785,5,116, + 0,0,785,786,5,101,0,0,786,787,5,114,0,0,787,788,5,112,0,0,788,789,5,114, + 0,0,789,790,5,101,0,0,790,791,5,116,0,0,791,792,5,95,0,0,792,793,5,99, + 0,0,793,794,5,97,0,0,794,795,5,115,0,0,795,796,5,116,0,0,796,116,1,0, + 0,0,797,798,5,114,0,0,798,799,5,101,0,0,799,800,5,116,0,0,800,801,5,117, + 0,0,801,802,5,114,0,0,802,803,5,110,0,0,803,118,1,0,0,0,804,805,5,115, + 0,0,805,806,5,104,0,0,806,807,5,111,0,0,807,808,5,114,0,0,808,809,5,116, + 0,0,809,120,1,0,0,0,810,811,5,115,0,0,811,812,5,105,0,0,812,813,5,103, + 0,0,813,814,5,110,0,0,814,815,5,101,0,0,815,816,5,100,0,0,816,122,1,0, + 0,0,817,818,5,115,0,0,818,819,5,105,0,0,819,820,5,122,0,0,820,821,5,101, + 0,0,821,822,5,111,0,0,822,823,5,102,0,0,823,124,1,0,0,0,824,825,5,115, + 0,0,825,826,5,116,0,0,826,827,5,97,0,0,827,828,5,116,0,0,828,829,5,105, + 0,0,829,830,5,99,0,0,830,126,1,0,0,0,831,832,5,115,0,0,832,833,5,116, + 0,0,833,834,5,97,0,0,834,835,5,116,0,0,835,836,5,105,0,0,836,837,5,99, + 0,0,837,838,5,95,0,0,838,839,5,97,0,0,839,840,5,115,0,0,840,841,5,115, + 0,0,841,842,5,101,0,0,842,843,5,114,0,0,843,844,5,116,0,0,844,128,1,0, + 0,0,845,846,5,115,0,0,846,847,5,116,0,0,847,848,5,97,0,0,848,849,5,116, + 0,0,849,850,5,105,0,0,850,851,5,99,0,0,851,852,5,95,0,0,852,853,5,99, + 0,0,853,854,5,97,0,0,854,855,5,115,0,0,855,856,5,116,0,0,856,130,1,0, + 0,0,857,858,5,115,0,0,858,859,5,116,0,0,859,860,5,114,0,0,860,861,5,117, + 0,0,861,862,5,99,0,0,862,863,5,116,0,0,863,132,1,0,0,0,864,865,5,115, + 0,0,865,866,5,119,0,0,866,867,5,105,0,0,867,868,5,116,0,0,868,869,5,99, + 0,0,869,870,5,104,0,0,870,134,1,0,0,0,871,872,5,116,0,0,872,873,5,101, + 0,0,873,874,5,109,0,0,874,875,5,112,0,0,875,876,5,108,0,0,876,877,5,97, + 0,0,877,878,5,116,0,0,878,879,5,101,0,0,879,136,1,0,0,0,880,881,5,116, + 0,0,881,882,5,104,0,0,882,883,5,105,0,0,883,884,5,115,0,0,884,138,1,0, + 0,0,885,886,5,116,0,0,886,887,5,104,0,0,887,888,5,114,0,0,888,889,5,101, + 0,0,889,890,5,97,0,0,890,891,5,100,0,0,891,892,5,95,0,0,892,893,5,108, + 0,0,893,894,5,111,0,0,894,895,5,99,0,0,895,896,5,97,0,0,896,897,5,108, + 0,0,897,140,1,0,0,0,898,899,5,116,0,0,899,900,5,104,0,0,900,901,5,114, + 0,0,901,902,5,111,0,0,902,903,5,119,0,0,903,142,1,0,0,0,904,905,5,116, + 0,0,905,906,5,114,0,0,906,907,5,117,0,0,907,908,5,101,0,0,908,144,1,0, + 0,0,909,910,5,116,0,0,910,911,5,114,0,0,911,912,5,121,0,0,912,146,1,0, + 0,0,913,914,5,116,0,0,914,915,5,121,0,0,915,916,5,112,0,0,916,917,5,101, + 0,0,917,918,5,100,0,0,918,919,5,101,0,0,919,920,5,102,0,0,920,148,1,0, + 0,0,921,922,5,116,0,0,922,923,5,121,0,0,923,924,5,112,0,0,924,925,5,101, + 0,0,925,926,5,105,0,0,926,927,5,100,0,0,927,150,1,0,0,0,928,929,5,116, + 0,0,929,930,5,121,0,0,930,931,5,112,0,0,931,932,5,101,0,0,932,933,5,110, + 0,0,933,934,5,97,0,0,934,935,5,109,0,0,935,936,5,101,0,0,936,152,1,0, + 0,0,937,938,5,117,0,0,938,939,5,110,0,0,939,940,5,105,0,0,940,941,5,111, + 0,0,941,942,5,110,0,0,942,154,1,0,0,0,943,944,5,117,0,0,944,945,5,110, + 0,0,945,946,5,115,0,0,946,947,5,105,0,0,947,948,5,103,0,0,948,949,5,110, + 0,0,949,950,5,101,0,0,950,951,5,100,0,0,951,156,1,0,0,0,952,953,5,117, + 0,0,953,954,5,115,0,0,954,955,5,105,0,0,955,956,5,110,0,0,956,957,5,103, + 0,0,957,158,1,0,0,0,958,959,5,118,0,0,959,960,5,105,0,0,960,961,5,114, + 0,0,961,962,5,116,0,0,962,963,5,117,0,0,963,964,5,97,0,0,964,965,5,108, + 0,0,965,160,1,0,0,0,966,967,5,118,0,0,967,968,5,111,0,0,968,969,5,105, + 0,0,969,970,5,100,0,0,970,162,1,0,0,0,971,972,5,118,0,0,972,973,5,111, + 0,0,973,974,5,108,0,0,974,975,5,97,0,0,975,976,5,116,0,0,976,977,5,105, + 0,0,977,978,5,108,0,0,978,979,5,101,0,0,979,164,1,0,0,0,980,981,5,119, + 0,0,981,982,5,99,0,0,982,983,5,104,0,0,983,984,5,97,0,0,984,985,5,114, + 0,0,985,986,5,95,0,0,986,987,5,116,0,0,987,166,1,0,0,0,988,989,5,119, + 0,0,989,990,5,104,0,0,990,991,5,105,0,0,991,992,5,108,0,0,992,993,5,101, + 0,0,993,168,1,0,0,0,994,995,5,40,0,0,995,170,1,0,0,0,996,997,5,41,0,0, + 997,172,1,0,0,0,998,999,5,91,0,0,999,174,1,0,0,0,1000,1001,5,93,0,0,1001, + 176,1,0,0,0,1002,1003,5,123,0,0,1003,178,1,0,0,0,1004,1005,5,125,0,0, + 1005,180,1,0,0,0,1006,1007,5,43,0,0,1007,182,1,0,0,0,1008,1009,5,45,0, + 0,1009,184,1,0,0,0,1010,1011,5,42,0,0,1011,186,1,0,0,0,1012,1013,5,47, + 0,0,1013,188,1,0,0,0,1014,1015,5,37,0,0,1015,190,1,0,0,0,1016,1017,5, + 94,0,0,1017,192,1,0,0,0,1018,1019,5,38,0,0,1019,194,1,0,0,0,1020,1021, + 5,124,0,0,1021,196,1,0,0,0,1022,1023,5,126,0,0,1023,198,1,0,0,0,1024, + 1029,5,33,0,0,1025,1026,5,110,0,0,1026,1027,5,111,0,0,1027,1029,5,116, + 0,0,1028,1024,1,0,0,0,1028,1025,1,0,0,0,1029,200,1,0,0,0,1030,1031,5, + 61,0,0,1031,202,1,0,0,0,1032,1033,5,60,0,0,1033,204,1,0,0,0,1034,1035, + 5,62,0,0,1035,206,1,0,0,0,1036,1037,5,43,0,0,1037,1038,5,61,0,0,1038, + 208,1,0,0,0,1039,1040,5,45,0,0,1040,1041,5,61,0,0,1041,210,1,0,0,0,1042, + 1043,5,42,0,0,1043,1044,5,61,0,0,1044,212,1,0,0,0,1045,1046,5,47,0,0, + 1046,1047,5,61,0,0,1047,214,1,0,0,0,1048,1049,5,37,0,0,1049,1050,5,61, + 0,0,1050,216,1,0,0,0,1051,1052,5,94,0,0,1052,1053,5,61,0,0,1053,218,1, + 0,0,0,1054,1055,5,38,0,0,1055,1056,5,61,0,0,1056,220,1,0,0,0,1057,1058, + 5,124,0,0,1058,1059,5,61,0,0,1059,222,1,0,0,0,1060,1061,5,60,0,0,1061, + 1062,5,60,0,0,1062,1063,5,61,0,0,1063,224,1,0,0,0,1064,1065,5,62,0,0, + 1065,1066,5,62,0,0,1066,1067,5,61,0,0,1067,226,1,0,0,0,1068,1069,5,61, + 0,0,1069,1070,5,61,0,0,1070,228,1,0,0,0,1071,1072,5,33,0,0,1072,1073, + 5,61,0,0,1073,230,1,0,0,0,1074,1075,5,60,0,0,1075,1076,5,61,0,0,1076, + 232,1,0,0,0,1077,1078,5,62,0,0,1078,1079,5,61,0,0,1079,234,1,0,0,0,1080, + 1081,5,38,0,0,1081,1086,5,38,0,0,1082,1083,5,97,0,0,1083,1084,5,110,0, + 0,1084,1086,5,100,0,0,1085,1080,1,0,0,0,1085,1082,1,0,0,0,1086,236,1, + 0,0,0,1087,1088,5,124,0,0,1088,1092,5,124,0,0,1089,1090,5,111,0,0,1090, + 1092,5,114,0,0,1091,1087,1,0,0,0,1091,1089,1,0,0,0,1092,238,1,0,0,0,1093, + 1094,5,43,0,0,1094,1095,5,43,0,0,1095,240,1,0,0,0,1096,1097,5,45,0,0, + 1097,1098,5,45,0,0,1098,242,1,0,0,0,1099,1100,5,44,0,0,1100,244,1,0,0, + 0,1101,1102,5,45,0,0,1102,1103,5,62,0,0,1103,1104,5,42,0,0,1104,246,1, + 0,0,0,1105,1106,5,45,0,0,1106,1107,5,62,0,0,1107,248,1,0,0,0,1108,1109, + 5,63,0,0,1109,250,1,0,0,0,1110,1111,5,58,0,0,1111,252,1,0,0,0,1112,1113, + 5,58,0,0,1113,1114,5,58,0,0,1114,254,1,0,0,0,1115,1116,5,59,0,0,1116, + 256,1,0,0,0,1117,1118,5,46,0,0,1118,258,1,0,0,0,1119,1120,5,46,0,0,1120, + 1121,5,42,0,0,1121,260,1,0,0,0,1122,1123,5,46,0,0,1123,1124,5,46,0,0, + 1124,1125,5,46,0,0,1125,262,1,0,0,0,1126,1127,3,287,143,0,1127,1128,3, + 287,143,0,1128,1129,3,287,143,0,1129,1130,3,287,143,0,1130,264,1,0,0, + 0,1131,1132,5,92,0,0,1132,1133,5,117,0,0,1133,1134,1,0,0,0,1134,1142, + 3,263,131,0,1135,1136,5,92,0,0,1136,1137,5,85,0,0,1137,1138,1,0,0,0,1138, + 1139,3,263,131,0,1139,1140,3,263,131,0,1140,1142,1,0,0,0,1141,1131,1, + 0,0,0,1141,1135,1,0,0,0,1142,266,1,0,0,0,1143,1148,3,269,134,0,1144,1147, + 3,269,134,0,1145,1147,3,273,136,0,1146,1144,1,0,0,0,1146,1145,1,0,0,0, + 1147,1150,1,0,0,0,1148,1146,1,0,0,0,1148,1149,1,0,0,0,1149,268,1,0,0, + 0,1150,1148,1,0,0,0,1151,1154,3,271,135,0,1152,1154,3,265,132,0,1153, + 1151,1,0,0,0,1153,1152,1,0,0,0,1154,270,1,0,0,0,1155,1156,7,2,0,0,1156, + 272,1,0,0,0,1157,1158,7,3,0,0,1158,274,1,0,0,0,1159,1166,3,283,141,0, + 1160,1162,5,39,0,0,1161,1160,1,0,0,0,1161,1162,1,0,0,0,1162,1163,1,0, + 0,0,1163,1165,3,273,136,0,1164,1161,1,0,0,0,1165,1168,1,0,0,0,1166,1164, + 1,0,0,0,1166,1167,1,0,0,0,1167,276,1,0,0,0,1168,1166,1,0,0,0,1169,1176, + 5,48,0,0,1170,1172,5,39,0,0,1171,1170,1,0,0,0,1171,1172,1,0,0,0,1172, + 1173,1,0,0,0,1173,1175,3,285,142,0,1174,1171,1,0,0,0,1175,1178,1,0,0, + 0,1176,1174,1,0,0,0,1176,1177,1,0,0,0,1177,278,1,0,0,0,1178,1176,1,0, + 0,0,1179,1180,5,48,0,0,1180,1184,5,120,0,0,1181,1182,5,48,0,0,1182,1184, + 5,88,0,0,1183,1179,1,0,0,0,1183,1181,1,0,0,0,1184,1185,1,0,0,0,1185,1192, + 3,287,143,0,1186,1188,5,39,0,0,1187,1186,1,0,0,0,1187,1188,1,0,0,0,1188, + 1189,1,0,0,0,1189,1191,3,287,143,0,1190,1187,1,0,0,0,1191,1194,1,0,0, + 0,1192,1190,1,0,0,0,1192,1193,1,0,0,0,1193,280,1,0,0,0,1194,1192,1,0, + 0,0,1195,1196,5,48,0,0,1196,1200,5,98,0,0,1197,1198,5,48,0,0,1198,1200, + 5,66,0,0,1199,1195,1,0,0,0,1199,1197,1,0,0,0,1200,1201,1,0,0,0,1201,1208, + 3,289,144,0,1202,1204,5,39,0,0,1203,1202,1,0,0,0,1203,1204,1,0,0,0,1204, + 1205,1,0,0,0,1205,1207,3,289,144,0,1206,1203,1,0,0,0,1207,1210,1,0,0, + 0,1208,1206,1,0,0,0,1208,1209,1,0,0,0,1209,282,1,0,0,0,1210,1208,1,0, + 0,0,1211,1212,7,4,0,0,1212,284,1,0,0,0,1213,1214,7,5,0,0,1214,286,1,0, + 0,0,1215,1216,7,6,0,0,1216,288,1,0,0,0,1217,1218,7,7,0,0,1218,290,1,0, + 0,0,1219,1221,3,293,146,0,1220,1222,3,295,147,0,1221,1220,1,0,0,0,1221, + 1222,1,0,0,0,1222,1236,1,0,0,0,1223,1225,3,293,146,0,1224,1226,3,297, + 148,0,1225,1224,1,0,0,0,1225,1226,1,0,0,0,1226,1236,1,0,0,0,1227,1229, + 3,295,147,0,1228,1230,3,293,146,0,1229,1228,1,0,0,0,1229,1230,1,0,0,0, + 1230,1236,1,0,0,0,1231,1233,3,297,148,0,1232,1234,3,293,146,0,1233,1232, + 1,0,0,0,1233,1234,1,0,0,0,1234,1236,1,0,0,0,1235,1219,1,0,0,0,1235,1223, + 1,0,0,0,1235,1227,1,0,0,0,1235,1231,1,0,0,0,1236,292,1,0,0,0,1237,1238, + 7,8,0,0,1238,294,1,0,0,0,1239,1240,7,9,0,0,1240,296,1,0,0,0,1241,1242, + 5,108,0,0,1242,1246,5,108,0,0,1243,1244,5,76,0,0,1244,1246,5,76,0,0,1245, + 1241,1,0,0,0,1245,1243,1,0,0,0,1246,298,1,0,0,0,1247,1251,8,10,0,0,1248, + 1251,3,301,150,0,1249,1251,3,265,132,0,1250,1247,1,0,0,0,1250,1248,1, + 0,0,0,1250,1249,1,0,0,0,1251,300,1,0,0,0,1252,1256,3,303,151,0,1253,1256, + 3,305,152,0,1254,1256,3,307,153,0,1255,1252,1,0,0,0,1255,1253,1,0,0,0, + 1255,1254,1,0,0,0,1256,302,1,0,0,0,1257,1258,5,92,0,0,1258,1288,5,39, + 0,0,1259,1260,5,92,0,0,1260,1288,5,34,0,0,1261,1262,5,92,0,0,1262,1288, + 5,63,0,0,1263,1264,5,92,0,0,1264,1288,5,92,0,0,1265,1266,5,92,0,0,1266, + 1288,5,97,0,0,1267,1268,5,92,0,0,1268,1288,5,98,0,0,1269,1270,5,92,0, + 0,1270,1288,5,102,0,0,1271,1272,5,92,0,0,1272,1288,5,110,0,0,1273,1274, + 5,92,0,0,1274,1288,5,114,0,0,1275,1281,5,92,0,0,1276,1278,5,13,0,0,1277, + 1279,5,10,0,0,1278,1277,1,0,0,0,1278,1279,1,0,0,0,1279,1282,1,0,0,0,1280, + 1282,5,10,0,0,1281,1276,1,0,0,0,1281,1280,1,0,0,0,1282,1288,1,0,0,0,1283, + 1284,5,92,0,0,1284,1288,5,116,0,0,1285,1286,5,92,0,0,1286,1288,5,118, + 0,0,1287,1257,1,0,0,0,1287,1259,1,0,0,0,1287,1261,1,0,0,0,1287,1263,1, + 0,0,0,1287,1265,1,0,0,0,1287,1267,1,0,0,0,1287,1269,1,0,0,0,1287,1271, + 1,0,0,0,1287,1273,1,0,0,0,1287,1275,1,0,0,0,1287,1283,1,0,0,0,1287,1285, + 1,0,0,0,1288,304,1,0,0,0,1289,1290,5,92,0,0,1290,1301,3,285,142,0,1291, + 1292,5,92,0,0,1292,1293,3,285,142,0,1293,1294,3,285,142,0,1294,1301,1, + 0,0,0,1295,1296,5,92,0,0,1296,1297,3,285,142,0,1297,1298,3,285,142,0, + 1298,1299,3,285,142,0,1299,1301,1,0,0,0,1300,1289,1,0,0,0,1300,1291,1, + 0,0,0,1300,1295,1,0,0,0,1301,306,1,0,0,0,1302,1303,5,92,0,0,1303,1304, + 5,120,0,0,1304,1306,1,0,0,0,1305,1307,3,287,143,0,1306,1305,1,0,0,0,1307, + 1308,1,0,0,0,1308,1306,1,0,0,0,1308,1309,1,0,0,0,1309,308,1,0,0,0,1310, + 1312,3,315,157,0,1311,1310,1,0,0,0,1311,1312,1,0,0,0,1312,1313,1,0,0, + 0,1313,1314,5,46,0,0,1314,1319,3,315,157,0,1315,1316,3,315,157,0,1316, + 1317,5,46,0,0,1317,1319,1,0,0,0,1318,1311,1,0,0,0,1318,1315,1,0,0,0,1319, + 310,1,0,0,0,1320,1322,5,101,0,0,1321,1323,3,313,156,0,1322,1321,1,0,0, + 0,1322,1323,1,0,0,0,1323,1324,1,0,0,0,1324,1331,3,315,157,0,1325,1327, + 5,69,0,0,1326,1328,3,313,156,0,1327,1326,1,0,0,0,1327,1328,1,0,0,0,1328, + 1329,1,0,0,0,1329,1331,3,315,157,0,1330,1320,1,0,0,0,1330,1325,1,0,0, + 0,1331,312,1,0,0,0,1332,1333,7,11,0,0,1333,314,1,0,0,0,1334,1341,3,273, + 136,0,1335,1337,5,39,0,0,1336,1335,1,0,0,0,1336,1337,1,0,0,0,1337,1338, + 1,0,0,0,1338,1340,3,273,136,0,1339,1336,1,0,0,0,1340,1343,1,0,0,0,1341, + 1339,1,0,0,0,1341,1342,1,0,0,0,1342,316,1,0,0,0,1343,1341,1,0,0,0,1344, + 1345,7,12,0,0,1345,318,1,0,0,0,1346,1347,5,117,0,0,1347,1350,5,56,0,0, + 1348,1350,7,0,0,0,1349,1346,1,0,0,0,1349,1348,1,0,0,0,1350,320,1,0,0, + 0,1351,1355,8,13,0,0,1352,1355,3,301,150,0,1353,1355,3,265,132,0,1354, + 1351,1,0,0,0,1354,1352,1,0,0,0,1354,1353,1,0,0,0,1355,322,1,0,0,0,1356, + 1357,5,82,0,0,1357,1358,5,34,0,0,1358,1364,1,0,0,0,1359,1360,5,92,0,0, + 1360,1363,7,14,0,0,1361,1363,8,15,0,0,1362,1359,1,0,0,0,1362,1361,1,0, + 0,0,1363,1366,1,0,0,0,1364,1365,1,0,0,0,1364,1362,1,0,0,0,1365,1367,1, + 0,0,0,1366,1364,1,0,0,0,1367,1371,5,40,0,0,1368,1370,8,16,0,0,1369,1368, + 1,0,0,0,1370,1373,1,0,0,0,1371,1372,1,0,0,0,1371,1369,1,0,0,0,1372,1374, + 1,0,0,0,1373,1371,1,0,0,0,1374,1380,5,41,0,0,1375,1376,5,92,0,0,1376, + 1379,7,14,0,0,1377,1379,8,17,0,0,1378,1375,1,0,0,0,1378,1377,1,0,0,0, + 1379,1382,1,0,0,0,1380,1381,1,0,0,0,1380,1378,1,0,0,0,1381,1383,1,0,0, + 0,1382,1380,1,0,0,0,1383,1384,5,34,0,0,1384,324,1,0,0,0,1385,1386,3,275, + 137,0,1386,1387,3,333,166,0,1387,1398,1,0,0,0,1388,1389,3,277,138,0,1389, + 1390,3,333,166,0,1390,1398,1,0,0,0,1391,1392,3,279,139,0,1392,1393,3, + 333,166,0,1393,1398,1,0,0,0,1394,1395,3,281,140,0,1395,1396,3,333,166, + 0,1396,1398,1,0,0,0,1397,1385,1,0,0,0,1397,1388,1,0,0,0,1397,1391,1,0, + 0,0,1397,1394,1,0,0,0,1398,326,1,0,0,0,1399,1401,3,309,154,0,1400,1402, + 3,311,155,0,1401,1400,1,0,0,0,1401,1402,1,0,0,0,1402,1403,1,0,0,0,1403, + 1404,3,333,166,0,1404,1410,1,0,0,0,1405,1406,3,315,157,0,1406,1407,3, + 311,155,0,1407,1408,3,333,166,0,1408,1410,1,0,0,0,1409,1399,1,0,0,0,1409, + 1405,1,0,0,0,1410,328,1,0,0,0,1411,1412,3,7,3,0,1412,1413,3,333,166,0, + 1413,330,1,0,0,0,1414,1415,3,3,1,0,1415,1416,3,333,166,0,1416,332,1,0, + 0,0,1417,1418,3,267,133,0,1418,334,1,0,0,0,1419,1421,7,18,0,0,1420,1419, + 1,0,0,0,1421,1422,1,0,0,0,1422,1420,1,0,0,0,1422,1423,1,0,0,0,1423,1424, + 1,0,0,0,1424,1425,6,167,1,0,1425,336,1,0,0,0,1426,1428,5,13,0,0,1427, + 1429,5,10,0,0,1428,1427,1,0,0,0,1428,1429,1,0,0,0,1429,1432,1,0,0,0,1430, + 1432,5,10,0,0,1431,1426,1,0,0,0,1431,1430,1,0,0,0,1432,1433,1,0,0,0,1433, + 1434,6,168,1,0,1434,338,1,0,0,0,1435,1436,5,47,0,0,1436,1437,5,42,0,0, + 1437,1441,1,0,0,0,1438,1440,9,0,0,0,1439,1438,1,0,0,0,1440,1443,1,0,0, + 0,1441,1442,1,0,0,0,1441,1439,1,0,0,0,1442,1444,1,0,0,0,1443,1441,1,0, + 0,0,1444,1445,5,42,0,0,1445,1446,5,47,0,0,1446,1447,1,0,0,0,1447,1448, + 6,169,1,0,1448,340,1,0,0,0,1449,1450,5,47,0,0,1450,1451,5,47,0,0,1451, + 1455,1,0,0,0,1452,1454,8,19,0,0,1453,1452,1,0,0,0,1454,1457,1,0,0,0,1455, + 1453,1,0,0,0,1455,1456,1,0,0,0,1456,1458,1,0,0,0,1457,1455,1,0,0,0,1458, + 1459,6,170,1,0,1459,342,1,0,0,0,74,0,345,349,353,357,359,362,368,374, + 377,382,384,387,394,398,402,410,416,421,426,431,439,1028,1085,1091,1141, + 1146,1148,1153,1161,1166,1171,1176,1183,1187,1192,1199,1203,1208,1221, + 1225,1229,1233,1235,1245,1250,1255,1278,1281,1287,1300,1308,1311,1318, + 1322,1327,1330,1336,1341,1349,1354,1362,1364,1371,1378,1380,1397,1401, + 1409,1422,1428,1431,1441,1455,2,0,1,0,6,0,0 + }; + staticData->serializedATN = antlr4::atn::SerializedATNView(serializedATNSegment, sizeof(serializedATNSegment) / sizeof(serializedATNSegment[0])); + + antlr4::atn::ATNDeserializer deserializer; + staticData->atn = deserializer.deserialize(staticData->serializedATN); + + const size_t count = staticData->atn->getNumberOfDecisions(); + staticData->decisionToDFA.reserve(count); + for (size_t i = 0; i < count; i++) { + staticData->decisionToDFA.emplace_back(staticData->atn->getDecisionState(i), i); + } + cpp14lexerLexerStaticData = staticData.release(); +} + +} + +CPP14Lexer::CPP14Lexer(CharStream *input) : Lexer(input) { + CPP14Lexer::initialize(); + _interpreter = new atn::LexerATNSimulator(this, *cpp14lexerLexerStaticData->atn, cpp14lexerLexerStaticData->decisionToDFA, cpp14lexerLexerStaticData->sharedContextCache); +} + +CPP14Lexer::~CPP14Lexer() { + delete _interpreter; +} + +std::string CPP14Lexer::getGrammarFileName() const { + return "CPP14Lexer.g4"; +} + +const std::vector& CPP14Lexer::getRuleNames() const { + return cpp14lexerLexerStaticData->ruleNames; +} + +const std::vector& CPP14Lexer::getChannelNames() const { + return cpp14lexerLexerStaticData->channelNames; +} + +const std::vector& CPP14Lexer::getModeNames() const { + return cpp14lexerLexerStaticData->modeNames; +} + +const dfa::Vocabulary& CPP14Lexer::getVocabulary() const { + return cpp14lexerLexerStaticData->vocabulary; +} + +antlr4::atn::SerializedATNView CPP14Lexer::getSerializedATN() const { + return cpp14lexerLexerStaticData->serializedATN; +} + +const atn::ATN& CPP14Lexer::getATN() const { + return *cpp14lexerLexerStaticData->atn; +} + + + + +void CPP14Lexer::initialize() { + ::antlr4::internal::call_once(cpp14lexerLexerOnceFlag, cpp14lexerLexerInitialize); +} diff --git a/server/pkg/antlr/cpp14/src/CPP14Parser.cpp b/server/pkg/antlr/cpp14/src/CPP14Parser.cpp new file mode 100644 index 0000000000000000000000000000000000000000..87c20605a7aabd75bdac2c9c16dd4aaa8cfc0504 --- /dev/null +++ b/server/pkg/antlr/cpp14/src/CPP14Parser.cpp @@ -0,0 +1,18169 @@ + +// Generated from CPP14Parser.g4 by ANTLR 4.12.0 + + + +#include "CPP14Parser.h" + + +using namespace antlrcpp; +using namespace antlrcpptest; + +using namespace antlr4; + +namespace { + +struct CPP14ParserStaticData final { + CPP14ParserStaticData(std::vector ruleNames, + std::vector literalNames, + std::vector symbolicNames) + : ruleNames(std::move(ruleNames)), literalNames(std::move(literalNames)), + symbolicNames(std::move(symbolicNames)), + vocabulary(this->literalNames, this->symbolicNames) {} + + CPP14ParserStaticData(const CPP14ParserStaticData&) = delete; + CPP14ParserStaticData(CPP14ParserStaticData&&) = delete; + CPP14ParserStaticData& operator=(const CPP14ParserStaticData&) = delete; + CPP14ParserStaticData& operator=(CPP14ParserStaticData&&) = delete; + + std::vector decisionToDFA; + antlr4::atn::PredictionContextCache sharedContextCache; + const std::vector ruleNames; + const std::vector literalNames; + const std::vector symbolicNames; + const antlr4::dfa::Vocabulary vocabulary; + antlr4::atn::SerializedATNView serializedATN; + std::unique_ptr atn; +}; + +::antlr4::internal::OnceFlag cpp14parserParserOnceFlag; +CPP14ParserStaticData *cpp14parserParserStaticData = nullptr; + +void cpp14parserParserInitialize() { + assert(cpp14parserParserStaticData == nullptr); + auto staticData = std::make_unique( + std::vector{ + "translationUnit", "primaryExpression", "idExpression", "unqualifiedId", + "qualifiedId", "nestedNameSpecifier", "lambdaExpression", "lambdaIntroducer", + "lambdaCapture", "captureDefault", "captureList", "capture", "simpleCapture", + "initcapture", "lambdaDeclarator", "postfixExpression", "typeIdOfTheTypeId", + "expressionList", "pseudoDestructorName", "unaryExpression", "unaryOperator", + "newExpression", "newPlacement", "newTypeId", "newDeclarator", "noPointerNewDeclarator", + "newInitializer", "deleteExpression", "noExceptExpression", "castExpression", + "pointerMemberExpression", "multiplicativeExpression", "additiveExpression", + "shiftExpression", "shiftOperator", "relationalExpression", "equalityExpression", + "andExpression", "exclusiveOrExpression", "inclusiveOrExpression", + "logicalAndExpression", "logicalOrExpression", "conditionalExpression", + "assignmentExpression", "assignmentOperator", "expression", "constantExpression", + "statement", "labeledStatement", "expressionStatement", "compoundStatement", + "statementSeq", "selectionStatement", "condition", "iterationStatement", + "forInitStatement", "forRangeDeclaration", "forRangeInitializer", + "jumpStatement", "declarationStatement", "declarationseq", "declaration", + "blockDeclaration", "aliasDeclaration", "simpleDeclaration", "staticAssertDeclaration", + "emptyDeclaration", "attributeDeclaration", "declSpecifier", "declSpecifierSeq", + "storageClassSpecifier", "functionSpecifier", "typedefName", "typeSpecifier", + "trailingTypeSpecifier", "typeSpecifierSeq", "trailingTypeSpecifierSeq", + "simpleTypeLengthModifier", "simpleTypeSignednessModifier", "simpleTypeSpecifier", + "theTypeName", "decltypeSpecifier", "elaboratedTypeSpecifier", "enumName", + "enumSpecifier", "enumHead", "opaqueEnumDeclaration", "enumkey", "enumbase", + "enumeratorList", "enumeratorDefinition", "enumerator", "namespaceName", + "originalNamespaceName", "namespaceDefinition", "namespaceAlias", + "namespaceAliasDefinition", "qualifiednamespacespecifier", "usingDeclaration", + "usingDirective", "asmDefinition", "linkageSpecification", "attributeSpecifierSeq", + "attributeSpecifier", "alignmentspecifier", "attributeList", "attribute", + "attributeNamespace", "attributeArgumentClause", "balancedTokenSeq", + "balancedtoken", "initDeclaratorList", "initDeclarator", "declarator", + "pointerDeclarator", "noPointerDeclarator", "parametersAndQualifiers", + "trailingReturnType", "pointerOperator", "cvqualifierseq", "cvQualifier", + "refqualifier", "declaratorid", "theTypeId", "abstractDeclarator", + "pointerAbstractDeclarator", "noPointerAbstractDeclarator", "abstractPackDeclarator", + "noPointerAbstractPackDeclarator", "parameterDeclarationClause", "parameterDeclarationList", + "parameterDeclaration", "functionDefinition", "functionBody", "initializer", + "braceOrEqualInitializer", "initializerClause", "initializerList", + "bracedInitList", "className", "classSpecifier", "classHead", "classHeadName", + "classVirtSpecifier", "classKey", "memberSpecification", "memberdeclaration", + "memberDeclaratorList", "memberDeclarator", "virtualSpecifierSeq", + "virtualSpecifier", "pureSpecifier", "baseClause", "baseSpecifierList", + "baseSpecifier", "classOrDeclType", "baseTypeSpecifier", "accessSpecifier", + "conversionFunctionId", "conversionTypeId", "conversionDeclarator", + "constructorInitializer", "memInitializerList", "memInitializer", + "meminitializerid", "operatorFunctionId", "literalOperatorId", "templateDeclaration", + "templateparameterList", "templateParameter", "typeParameter", "simpleTemplateId", + "templateId", "templateName", "templateArgumentList", "templateArgument", + "typeNameSpecifier", "explicitInstantiation", "explicitSpecialization", + "tryBlock", "functionTryBlock", "handlerSeq", "handler", "exceptionDeclaration", + "throwExpression", "exceptionSpecification", "dynamicExceptionSpecification", + "typeIdList", "noeExceptSpecification", "theOperator", "literal" + }, + std::vector{ + "", "", "", "", "", "", "", "", "", "", "'alignas'", "'alignof'", + "'asm'", "'auto'", "'bool'", "'break'", "'case'", "'catch'", "'char'", + "'char16_t'", "'char32_t'", "'class'", "'const'", "'constexpr'", "'const_cast'", + "'continue'", "'decltype'", "'default'", "'delete'", "'do'", "'double'", + "'dynamic_cast'", "'else'", "'enum'", "'explicit'", "'export'", "'extern'", + "'false'", "'final'", "'float'", "'for'", "'friend'", "'goto'", "'if'", + "'inline'", "'int'", "'long'", "'mutable'", "'namespace'", "'new'", + "'noexcept'", "'nullptr'", "'operator'", "'override'", "'private'", + "'protected'", "'public'", "'register'", "'reinterpret_cast'", "'return'", + "'short'", "'signed'", "'sizeof'", "'static'", "'static_assert'", + "'static_cast'", "'struct'", "'switch'", "'template'", "'this'", "'thread_local'", + "'throw'", "'true'", "'try'", "'typedef'", "'typeid'", "'typename'", + "'union'", "'unsigned'", "'using'", "'virtual'", "'void'", "'volatile'", + "'wchar_t'", "'while'", "'('", "')'", "'['", "']'", "'{'", "'}'", + "'+'", "'-'", "'*'", "'/'", "'%'", "'^'", "'&'", "'|'", "'~'", "", + "'='", "'<'", "'>'", "'+='", "'-='", "'*='", "'/='", "'%='", "'^='", + "'&='", "'|='", "'<<='", "'>>='", "'=='", "'!='", "'<='", "'>='", + "", "", "'++'", "'--'", "','", "'->*'", "'->'", "'\\u003F'", "':'", + "'::'", "';'", "'.'", "'.*'", "'...'" + }, + std::vector{ + "", "IntegerLiteral", "CharacterLiteral", "FloatingLiteral", "StringLiteral", + "BooleanLiteral", "PointerLiteral", "UserDefinedLiteral", "MultiLineMacro", + "Directive", "Alignas", "Alignof", "Asm", "Auto", "Bool", "Break", + "Case", "Catch", "Char", "Char16", "Char32", "Class", "Const", "Constexpr", + "Const_cast", "Continue", "Decltype", "Default", "Delete", "Do", "Double", + "Dynamic_cast", "Else", "Enum", "Explicit", "Export", "Extern", "False_", + "Final", "Float", "For", "Friend", "Goto", "If", "Inline", "Int", + "Long", "Mutable", "Namespace", "New", "Noexcept", "Nullptr", "Operator", + "Override", "Private", "Protected", "Public", "Register", "Reinterpret_cast", + "Return", "Short", "Signed", "Sizeof", "Static", "Static_assert", + "Static_cast", "Struct", "Switch", "Template", "This", "Thread_local", + "Throw", "True_", "Try", "Typedef", "Typeid_", "Typename_", "Union", + "Unsigned", "Using", "Virtual", "Void", "Volatile", "Wchar", "While", + "LeftParen", "RightParen", "LeftBracket", "RightBracket", "LeftBrace", + "RightBrace", "Plus", "Minus", "Star", "Div", "Mod", "Caret", "And", + "Or", "Tilde", "Not", "Assign", "Less", "Greater", "PlusAssign", "MinusAssign", + "StarAssign", "DivAssign", "ModAssign", "XorAssign", "AndAssign", + "OrAssign", "LeftShiftAssign", "RightShiftAssign", "Equal", "NotEqual", + "LessEqual", "GreaterEqual", "AndAnd", "OrOr", "PlusPlus", "MinusMinus", + "Comma", "ArrowStar", "Arrow", "Question", "Colon", "Doublecolon", + "Semi", "Dot", "DotStar", "Ellipsis", "Identifier", "DecimalLiteral", + "OctalLiteral", "HexadecimalLiteral", "BinaryLiteral", "Integersuffix", + "UserDefinedIntegerLiteral", "UserDefinedFloatingLiteral", "UserDefinedStringLiteral", + "UserDefinedCharacterLiteral", "Whitespace", "Newline", "BlockComment", + "LineComment" + } + ); + static const int32_t serializedATNSegment[] = { + 4,1,145,2110,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,7,6, + 2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13,7,13,2,14, + 7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,19,2,20,7,20,2,21, + 7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2,26,7,26,2,27,7,27,2,28, + 7,28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7,32,2,33,7,33,2,34,7,34,2,35, + 7,35,2,36,7,36,2,37,7,37,2,38,7,38,2,39,7,39,2,40,7,40,2,41,7,41,2,42, + 7,42,2,43,7,43,2,44,7,44,2,45,7,45,2,46,7,46,2,47,7,47,2,48,7,48,2,49, + 7,49,2,50,7,50,2,51,7,51,2,52,7,52,2,53,7,53,2,54,7,54,2,55,7,55,2,56, + 7,56,2,57,7,57,2,58,7,58,2,59,7,59,2,60,7,60,2,61,7,61,2,62,7,62,2,63, + 7,63,2,64,7,64,2,65,7,65,2,66,7,66,2,67,7,67,2,68,7,68,2,69,7,69,2,70, + 7,70,2,71,7,71,2,72,7,72,2,73,7,73,2,74,7,74,2,75,7,75,2,76,7,76,2,77, + 7,77,2,78,7,78,2,79,7,79,2,80,7,80,2,81,7,81,2,82,7,82,2,83,7,83,2,84, + 7,84,2,85,7,85,2,86,7,86,2,87,7,87,2,88,7,88,2,89,7,89,2,90,7,90,2,91, + 7,91,2,92,7,92,2,93,7,93,2,94,7,94,2,95,7,95,2,96,7,96,2,97,7,97,2,98, + 7,98,2,99,7,99,2,100,7,100,2,101,7,101,2,102,7,102,2,103,7,103,2,104, + 7,104,2,105,7,105,2,106,7,106,2,107,7,107,2,108,7,108,2,109,7,109,2,110, + 7,110,2,111,7,111,2,112,7,112,2,113,7,113,2,114,7,114,2,115,7,115,2,116, + 7,116,2,117,7,117,2,118,7,118,2,119,7,119,2,120,7,120,2,121,7,121,2,122, + 7,122,2,123,7,123,2,124,7,124,2,125,7,125,2,126,7,126,2,127,7,127,2,128, + 7,128,2,129,7,129,2,130,7,130,2,131,7,131,2,132,7,132,2,133,7,133,2,134, + 7,134,2,135,7,135,2,136,7,136,2,137,7,137,2,138,7,138,2,139,7,139,2,140, + 7,140,2,141,7,141,2,142,7,142,2,143,7,143,2,144,7,144,2,145,7,145,2,146, + 7,146,2,147,7,147,2,148,7,148,2,149,7,149,2,150,7,150,2,151,7,151,2,152, + 7,152,2,153,7,153,2,154,7,154,2,155,7,155,2,156,7,156,2,157,7,157,2,158, + 7,158,2,159,7,159,2,160,7,160,2,161,7,161,2,162,7,162,2,163,7,163,2,164, + 7,164,2,165,7,165,2,166,7,166,2,167,7,167,2,168,7,168,2,169,7,169,2,170, + 7,170,2,171,7,171,2,172,7,172,2,173,7,173,2,174,7,174,2,175,7,175,2,176, + 7,176,2,177,7,177,2,178,7,178,2,179,7,179,2,180,7,180,2,181,7,181,2,182, + 7,182,2,183,7,183,2,184,7,184,2,185,7,185,2,186,7,186,2,187,7,187,2,188, + 7,188,2,189,7,189,2,190,7,190,1,0,3,0,384,8,0,1,0,1,0,1,1,4,1,389,8,1, + 11,1,12,1,390,1,1,1,1,1,1,1,1,1,1,1,1,1,1,3,1,400,8,1,1,2,1,2,3,2,404, + 8,2,1,3,1,3,1,3,1,3,1,3,1,3,1,3,3,3,413,8,3,1,3,3,3,416,8,3,1,4,1,4,3, + 4,420,8,4,1,4,1,4,1,5,1,5,1,5,1,5,3,5,428,8,5,1,5,1,5,1,5,1,5,1,5,3,5, + 435,8,5,1,5,3,5,438,8,5,1,5,5,5,441,8,5,10,5,12,5,444,9,5,1,6,1,6,3,6, + 448,8,6,1,6,1,6,1,7,1,7,3,7,454,8,7,1,7,1,7,1,8,1,8,1,8,1,8,3,8,462,8, + 8,3,8,464,8,8,1,9,1,9,1,10,1,10,1,10,5,10,471,8,10,10,10,12,10,474,9, + 10,1,10,3,10,477,8,10,1,11,1,11,3,11,481,8,11,1,12,3,12,484,8,12,1,12, + 1,12,3,12,488,8,12,1,13,3,13,491,8,13,1,13,1,13,1,13,1,14,1,14,3,14,498, + 8,14,1,14,1,14,3,14,502,8,14,1,14,3,14,505,8,14,1,14,3,14,508,8,14,1, + 14,3,14,511,8,14,1,15,1,15,1,15,1,15,3,15,517,8,15,1,15,1,15,3,15,521, + 8,15,1,15,1,15,3,15,525,8,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15, + 1,15,1,15,1,15,1,15,3,15,539,8,15,1,15,1,15,3,15,543,8,15,1,15,1,15,1, + 15,1,15,3,15,549,8,15,1,15,1,15,1,15,1,15,1,15,3,15,556,8,15,1,15,1,15, + 1,15,1,15,3,15,562,8,15,1,15,1,15,3,15,566,8,15,1,15,1,15,5,15,570,8, + 15,10,15,12,15,573,9,15,1,16,1,16,1,17,1,17,1,18,3,18,580,8,18,1,18,1, + 18,1,18,3,18,585,8,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1, + 18,1,18,3,18,598,8,18,1,19,1,19,1,19,1,19,1,19,3,19,605,8,19,1,19,1,19, + 1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,3,19,617,8,19,1,19,1,19,1,19, + 1,19,1,19,1,19,1,19,1,19,3,19,627,8,19,1,20,1,20,1,21,3,21,632,8,21,1, + 21,1,21,3,21,636,8,21,1,21,1,21,1,21,1,21,1,21,3,21,643,8,21,1,21,3,21, + 646,8,21,1,22,1,22,1,22,1,22,1,23,1,23,3,23,654,8,23,1,24,1,24,3,24,658, + 8,24,1,24,3,24,661,8,24,1,25,1,25,1,25,1,25,1,25,3,25,668,8,25,1,25,1, + 25,1,25,1,25,1,25,3,25,675,8,25,5,25,677,8,25,10,25,12,25,680,9,25,1, + 26,1,26,3,26,684,8,26,1,26,1,26,3,26,688,8,26,1,27,3,27,691,8,27,1,27, + 1,27,1,27,3,27,696,8,27,1,27,1,27,1,28,1,28,1,28,1,28,1,28,1,29,1,29, + 1,29,1,29,1,29,1,29,3,29,711,8,29,1,30,1,30,1,30,5,30,716,8,30,10,30, + 12,30,719,9,30,1,31,1,31,1,31,5,31,724,8,31,10,31,12,31,727,9,31,1,32, + 1,32,1,32,5,32,732,8,32,10,32,12,32,735,9,32,1,33,1,33,1,33,1,33,5,33, + 741,8,33,10,33,12,33,744,9,33,1,34,1,34,1,34,1,34,3,34,750,8,34,1,35, + 1,35,1,35,5,35,755,8,35,10,35,12,35,758,9,35,1,36,1,36,1,36,5,36,763, + 8,36,10,36,12,36,766,9,36,1,37,1,37,1,37,5,37,771,8,37,10,37,12,37,774, + 9,37,1,38,1,38,1,38,5,38,779,8,38,10,38,12,38,782,9,38,1,39,1,39,1,39, + 5,39,787,8,39,10,39,12,39,790,9,39,1,40,1,40,1,40,5,40,795,8,40,10,40, + 12,40,798,9,40,1,41,1,41,1,41,5,41,803,8,41,10,41,12,41,806,9,41,1,42, + 1,42,1,42,1,42,1,42,1,42,3,42,814,8,42,1,43,1,43,1,43,1,43,1,43,1,43, + 3,43,822,8,43,1,44,1,44,1,45,1,45,1,45,5,45,829,8,45,10,45,12,45,832, + 9,45,1,46,1,46,1,47,1,47,1,47,3,47,839,8,47,1,47,1,47,1,47,1,47,1,47, + 1,47,3,47,847,8,47,3,47,849,8,47,1,48,3,48,852,8,48,1,48,1,48,1,48,1, + 48,3,48,858,8,48,1,48,1,48,1,48,1,49,3,49,864,8,49,1,49,1,49,1,50,1,50, + 3,50,870,8,50,1,50,1,50,1,51,4,51,875,8,51,11,51,12,51,876,1,52,1,52, + 1,52,1,52,1,52,1,52,1,52,3,52,886,8,52,1,52,1,52,1,52,1,52,1,52,1,52, + 3,52,894,8,52,1,53,1,53,3,53,898,8,53,1,53,1,53,1,53,1,53,1,53,3,53,905, + 8,53,3,53,907,8,53,1,54,1,54,1,54,1,54,1,54,1,54,1,54,1,54,1,54,1,54, + 1,54,1,54,1,54,1,54,1,54,1,54,1,54,1,54,3,54,927,8,54,1,54,1,54,3,54, + 931,8,54,1,54,1,54,1,54,1,54,3,54,937,8,54,1,54,1,54,1,54,3,54,942,8, + 54,1,55,1,55,3,55,946,8,55,1,56,3,56,949,8,56,1,56,1,56,1,56,1,57,1,57, + 3,57,956,8,57,1,58,1,58,1,58,1,58,1,58,3,58,963,8,58,1,58,1,58,3,58,967, + 8,58,1,58,1,58,1,59,1,59,1,60,4,60,974,8,60,11,60,12,60,975,1,61,1,61, + 1,61,1,61,1,61,1,61,1,61,1,61,1,61,3,61,987,8,61,1,62,1,62,1,62,1,62, + 1,62,1,62,1,62,1,62,3,62,997,8,62,1,63,1,63,1,63,3,63,1002,8,63,1,63, + 1,63,1,63,1,63,1,64,3,64,1009,8,64,1,64,3,64,1012,8,64,1,64,1,64,1,64, + 3,64,1017,8,64,1,64,1,64,1,64,3,64,1022,8,64,1,65,1,65,1,65,1,65,1,65, + 1,65,1,65,1,65,1,66,1,66,1,67,1,67,1,67,1,68,1,68,1,68,1,68,1,68,1,68, + 3,68,1043,8,68,1,69,4,69,1046,8,69,11,69,12,69,1047,1,69,3,69,1051,8, + 69,1,70,1,70,1,71,1,71,1,72,1,72,1,73,1,73,1,73,3,73,1062,8,73,1,74,1, + 74,1,74,1,74,3,74,1068,8,74,1,75,4,75,1071,8,75,11,75,12,75,1072,1,75, + 3,75,1076,8,75,1,76,4,76,1079,8,76,11,76,12,76,1080,1,76,3,76,1084,8, + 76,1,77,1,77,1,78,1,78,1,79,3,79,1091,8,79,1,79,1,79,1,79,1,79,1,79,1, + 79,1,79,3,79,1100,8,79,1,79,4,79,1103,8,79,11,79,12,79,1104,1,79,3,79, + 1108,8,79,1,79,1,79,3,79,1112,8,79,1,79,1,79,3,79,1116,8,79,1,79,1,79, + 3,79,1120,8,79,1,79,1,79,1,79,3,79,1125,8,79,1,79,5,79,1128,8,79,10,79, + 12,79,1131,9,79,1,79,1,79,1,79,3,79,1136,8,79,1,79,1,79,1,79,1,79,3,79, + 1142,8,79,1,80,1,80,1,80,1,80,3,80,1148,8,80,1,81,1,81,1,81,1,81,3,81, + 1154,8,81,1,81,1,81,1,82,1,82,3,82,1160,8,82,1,82,3,82,1163,8,82,1,82, + 1,82,1,82,1,82,3,82,1169,8,82,1,82,1,82,3,82,1173,8,82,1,82,1,82,3,82, + 1177,8,82,1,82,3,82,1180,8,82,1,83,1,83,1,84,1,84,1,84,1,84,3,84,1188, + 8,84,3,84,1190,8,84,1,84,1,84,1,85,1,85,3,85,1196,8,85,1,85,3,85,1199, + 8,85,1,85,3,85,1202,8,85,1,85,3,85,1205,8,85,1,86,1,86,3,86,1209,8,86, + 1,86,1,86,3,86,1213,8,86,1,86,1,86,1,87,1,87,3,87,1219,8,87,1,88,1,88, + 1,88,1,89,1,89,1,89,5,89,1227,8,89,10,89,12,89,1230,9,89,1,90,1,90,1, + 90,3,90,1235,8,90,1,91,1,91,1,92,1,92,3,92,1241,8,92,1,93,1,93,1,94,3, + 94,1246,8,94,1,94,1,94,1,94,3,94,1251,8,94,1,94,1,94,3,94,1255,8,94,1, + 94,1,94,1,95,1,95,1,96,1,96,1,96,1,96,1,96,1,96,1,97,3,97,1268,8,97,1, + 97,1,97,1,98,1,98,3,98,1274,8,98,1,98,1,98,3,98,1278,8,98,1,98,1,98,1, + 98,1,99,3,99,1284,8,99,1,99,1,99,1,99,3,99,1289,8,99,1,99,1,99,1,99,1, + 100,1,100,1,100,1,100,1,100,1,100,1,101,1,101,1,101,1,101,3,101,1304, + 8,101,1,101,1,101,3,101,1308,8,101,1,102,4,102,1311,8,102,11,102,12,102, + 1312,1,103,1,103,1,103,3,103,1318,8,103,1,103,1,103,1,103,3,103,1323, + 8,103,1,104,1,104,1,104,1,104,3,104,1329,8,104,1,104,3,104,1332,8,104, + 1,104,1,104,1,105,1,105,1,105,5,105,1339,8,105,10,105,12,105,1342,9,105, + 1,105,3,105,1345,8,105,1,106,1,106,1,106,3,106,1350,8,106,1,106,1,106, + 3,106,1354,8,106,1,107,1,107,1,108,1,108,3,108,1360,8,108,1,108,1,108, + 1,109,4,109,1365,8,109,11,109,12,109,1366,1,110,1,110,1,110,1,110,1,110, + 1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,4,110,1382,8,110,11,110, + 12,110,1383,3,110,1386,8,110,1,111,1,111,1,111,5,111,1391,8,111,10,111, + 12,111,1394,9,111,1,112,1,112,3,112,1398,8,112,1,113,1,113,1,113,1,113, + 1,113,3,113,1405,8,113,1,114,1,114,3,114,1409,8,114,5,114,1411,8,114, + 10,114,12,114,1414,9,114,1,114,1,114,1,115,1,115,1,115,3,115,1421,8,115, + 1,115,1,115,1,115,1,115,3,115,1427,8,115,1,115,1,115,1,115,1,115,3,115, + 1433,8,115,1,115,1,115,3,115,1437,8,115,3,115,1439,8,115,5,115,1441,8, + 115,10,115,12,115,1444,9,115,1,116,1,116,3,116,1448,8,116,1,116,1,116, + 3,116,1452,8,116,1,116,3,116,1455,8,116,1,116,3,116,1458,8,116,1,116, + 3,116,1461,8,116,1,117,1,117,1,117,3,117,1466,8,117,1,118,1,118,3,118, + 1470,8,118,1,118,3,118,1473,8,118,1,118,1,118,3,118,1477,8,118,1,118, + 3,118,1480,8,118,3,118,1482,8,118,1,119,4,119,1485,8,119,11,119,12,119, + 1486,1,120,1,120,1,121,1,121,1,122,3,122,1494,8,122,1,122,1,122,1,123, + 1,123,3,123,1500,8,123,1,124,1,124,3,124,1504,8,124,1,124,1,124,1,124, + 1,124,3,124,1510,8,124,1,125,1,125,4,125,1514,8,125,11,125,12,125,1515, + 1,125,3,125,1519,8,125,3,125,1521,8,125,1,126,1,126,1,126,1,126,3,126, + 1527,8,126,1,126,1,126,3,126,1531,8,126,1,126,1,126,1,126,1,126,3,126, + 1537,8,126,1,126,1,126,1,126,1,126,1,126,3,126,1544,8,126,1,126,1,126, + 3,126,1548,8,126,3,126,1550,8,126,5,126,1552,8,126,10,126,12,126,1555, + 9,126,1,127,5,127,1558,8,127,10,127,12,127,1561,9,127,1,127,1,127,1,128, + 1,128,1,128,1,128,1,128,1,128,1,128,3,128,1572,8,128,1,128,1,128,3,128, + 1576,8,128,3,128,1578,8,128,5,128,1580,8,128,10,128,12,128,1583,9,128, + 1,129,1,129,3,129,1587,8,129,1,129,3,129,1590,8,129,1,130,1,130,1,130, + 5,130,1595,8,130,10,130,12,130,1598,9,130,1,131,3,131,1601,8,131,1,131, + 1,131,1,131,3,131,1606,8,131,3,131,1608,8,131,1,131,1,131,3,131,1612, + 8,131,1,132,3,132,1615,8,132,1,132,3,132,1618,8,132,1,132,1,132,3,132, + 1622,8,132,1,132,1,132,1,133,3,133,1627,8,133,1,133,1,133,1,133,1,133, + 1,133,3,133,1634,8,133,1,134,1,134,1,134,1,134,1,134,3,134,1641,8,134, + 1,135,1,135,1,135,3,135,1646,8,135,1,136,1,136,3,136,1650,8,136,1,137, + 1,137,3,137,1654,8,137,1,137,1,137,1,137,3,137,1659,8,137,5,137,1661, + 8,137,10,137,12,137,1664,9,137,1,138,1,138,1,138,3,138,1669,8,138,3,138, + 1671,8,138,1,138,1,138,1,139,1,139,3,139,1677,8,139,1,140,1,140,1,140, + 3,140,1682,8,140,1,140,1,140,1,141,1,141,3,141,1688,8,141,1,141,1,141, + 3,141,1692,8,141,3,141,1694,8,141,1,141,3,141,1697,8,141,1,141,1,141, + 3,141,1701,8,141,1,141,1,141,3,141,1705,8,141,3,141,1707,8,141,3,141, + 1709,8,141,1,142,3,142,1712,8,142,1,142,1,142,1,143,1,143,1,144,1,144, + 1,145,1,145,1,145,1,145,4,145,1724,8,145,11,145,12,145,1725,1,146,3,146, + 1729,8,146,1,146,3,146,1732,8,146,1,146,3,146,1735,8,146,1,146,1,146, + 1,146,1,146,1,146,1,146,1,146,3,146,1744,8,146,1,147,1,147,1,147,5,147, + 1749,8,147,10,147,12,147,1752,9,147,1,148,1,148,3,148,1756,8,148,1,148, + 3,148,1759,8,148,1,148,3,148,1762,8,148,3,148,1764,8,148,1,148,3,148, + 1767,8,148,1,148,3,148,1770,8,148,1,148,1,148,3,148,1774,8,148,1,149, + 4,149,1777,8,149,11,149,12,149,1778,1,150,1,150,1,151,1,151,1,151,1,151, + 1,152,1,152,1,152,1,153,1,153,3,153,1792,8,153,1,153,1,153,1,153,3,153, + 1797,8,153,5,153,1799,8,153,10,153,12,153,1802,9,153,1,154,3,154,1805, + 8,154,1,154,1,154,1,154,3,154,1810,8,154,1,154,1,154,1,154,3,154,1815, + 8,154,1,154,1,154,3,154,1819,8,154,1,155,3,155,1822,8,155,1,155,1,155, + 3,155,1826,8,155,1,156,1,156,1,157,1,157,1,158,1,158,1,158,1,159,1,159, + 3,159,1837,8,159,1,160,1,160,3,160,1841,8,160,1,161,1,161,1,161,1,162, + 1,162,3,162,1848,8,162,1,162,1,162,1,162,3,162,1853,8,162,5,162,1855, + 8,162,10,162,12,162,1858,9,162,1,163,1,163,1,163,3,163,1863,8,163,1,163, + 1,163,3,163,1867,8,163,1,164,1,164,3,164,1871,8,164,1,165,1,165,1,165, + 1,166,1,166,1,166,1,166,3,166,1880,8,166,1,167,1,167,1,167,1,167,1,167, + 1,167,1,168,1,168,1,168,5,168,1891,8,168,10,168,12,168,1894,9,168,1,169, + 1,169,3,169,1898,8,169,1,170,1,170,1,170,1,170,1,170,3,170,1905,8,170, + 1,170,1,170,3,170,1909,8,170,1,170,3,170,1912,8,170,1,170,3,170,1915, + 8,170,1,170,3,170,1918,8,170,1,170,1,170,3,170,1922,8,170,1,171,1,171, + 1,171,3,171,1927,8,171,1,171,1,171,1,172,1,172,1,172,3,172,1934,8,172, + 1,172,1,172,3,172,1938,8,172,1,172,1,172,3,172,1942,8,172,1,173,1,173, + 1,174,1,174,3,174,1948,8,174,1,174,1,174,1,174,3,174,1953,8,174,5,174, + 1955,8,174,10,174,12,174,1958,9,174,1,175,1,175,1,175,3,175,1963,8,175, + 1,176,1,176,1,176,1,176,3,176,1969,8,176,1,176,3,176,1972,8,176,1,177, + 3,177,1975,8,177,1,177,1,177,1,177,1,178,1,178,1,178,1,178,1,178,1,179, + 1,179,1,179,1,179,1,180,1,180,3,180,1991,8,180,1,180,1,180,1,180,1,181, + 4,181,1997,8,181,11,181,12,181,1998,1,182,1,182,1,182,1,182,1,182,1,182, + 1,183,3,183,2008,8,183,1,183,1,183,1,183,3,183,2013,8,183,1,183,3,183, + 2016,8,183,1,184,1,184,3,184,2020,8,184,1,185,1,185,3,185,2024,8,185, + 1,186,1,186,1,186,3,186,2029,8,186,1,186,1,186,1,187,1,187,3,187,2035, + 8,187,1,187,1,187,1,187,3,187,2040,8,187,5,187,2042,8,187,10,187,12,187, + 2045,9,187,1,188,1,188,1,188,1,188,1,188,1,188,3,188,2053,8,188,1,189, + 1,189,1,189,3,189,2058,8,189,1,189,1,189,1,189,3,189,2063,8,189,1,189, + 1,189,1,189,1,189,1,189,1,189,1,189,1,189,1,189,1,189,1,189,1,189,1,189, + 1,189,1,189,1,189,1,189,1,189,1,189,1,189,1,189,1,189,1,189,1,189,1,189, + 1,189,1,189,1,189,1,189,1,189,1,189,1,189,1,189,1,189,1,189,1,189,1,189, + 1,189,1,189,1,189,1,189,3,189,2106,8,189,1,190,1,190,1,190,1,1047,6,10, + 30,50,230,252,256,191,0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34, + 36,38,40,42,44,46,48,50,52,54,56,58,60,62,64,66,68,70,72,74,76,78,80, + 82,84,86,88,90,92,94,96,98,100,102,104,106,108,110,112,114,116,118,120, + 122,124,126,128,130,132,134,136,138,140,142,144,146,148,150,152,154,156, + 158,160,162,164,166,168,170,172,174,176,178,180,182,184,186,188,190,192, + 194,196,198,200,202,204,206,208,210,212,214,216,218,220,222,224,226,228, + 230,232,234,236,238,240,242,244,246,248,250,252,254,256,258,260,262,264, + 266,268,270,272,274,276,278,280,282,284,286,288,290,292,294,296,298,300, + 302,304,306,308,310,312,314,316,318,320,322,324,326,328,330,332,334,336, + 338,340,342,344,346,348,350,352,354,356,358,360,362,364,366,368,370,372, + 374,376,378,380,0,23,2,0,97,97,101,101,4,0,24,24,31,31,58,58,65,65,2, + 0,124,124,129,129,1,0,120,121,2,0,91,93,97,100,2,0,123,123,130,130,1, + 0,93,95,1,0,91,92,2,0,102,103,116,117,1,0,114,115,2,0,101,101,104,113, + 5,0,36,36,47,47,57,57,63,63,70,70,3,0,34,34,44,44,80,80,2,0,46,46,60, + 60,2,0,61,61,78,78,2,0,21,21,66,66,1,0,85,90,2,0,97,97,118,118,2,0,22, + 22,82,82,1,0,27,28,2,0,38,38,53,53,1,0,54,56,1,0,1,7,2343,0,383,1,0,0, + 0,2,399,1,0,0,0,4,403,1,0,0,0,6,415,1,0,0,0,8,417,1,0,0,0,10,423,1,0, + 0,0,12,445,1,0,0,0,14,451,1,0,0,0,16,463,1,0,0,0,18,465,1,0,0,0,20,467, + 1,0,0,0,22,480,1,0,0,0,24,487,1,0,0,0,26,490,1,0,0,0,28,495,1,0,0,0,30, + 542,1,0,0,0,32,574,1,0,0,0,34,576,1,0,0,0,36,597,1,0,0,0,38,626,1,0,0, + 0,40,628,1,0,0,0,42,631,1,0,0,0,44,647,1,0,0,0,46,651,1,0,0,0,48,660, + 1,0,0,0,50,662,1,0,0,0,52,687,1,0,0,0,54,690,1,0,0,0,56,699,1,0,0,0,58, + 710,1,0,0,0,60,712,1,0,0,0,62,720,1,0,0,0,64,728,1,0,0,0,66,736,1,0,0, + 0,68,749,1,0,0,0,70,751,1,0,0,0,72,759,1,0,0,0,74,767,1,0,0,0,76,775, + 1,0,0,0,78,783,1,0,0,0,80,791,1,0,0,0,82,799,1,0,0,0,84,807,1,0,0,0,86, + 821,1,0,0,0,88,823,1,0,0,0,90,825,1,0,0,0,92,833,1,0,0,0,94,848,1,0,0, + 0,96,851,1,0,0,0,98,863,1,0,0,0,100,867,1,0,0,0,102,874,1,0,0,0,104,893, + 1,0,0,0,106,906,1,0,0,0,108,941,1,0,0,0,110,945,1,0,0,0,112,948,1,0,0, + 0,114,955,1,0,0,0,116,966,1,0,0,0,118,970,1,0,0,0,120,973,1,0,0,0,122, + 986,1,0,0,0,124,996,1,0,0,0,126,998,1,0,0,0,128,1021,1,0,0,0,130,1023, + 1,0,0,0,132,1031,1,0,0,0,134,1033,1,0,0,0,136,1042,1,0,0,0,138,1045,1, + 0,0,0,140,1052,1,0,0,0,142,1054,1,0,0,0,144,1056,1,0,0,0,146,1061,1,0, + 0,0,148,1067,1,0,0,0,150,1070,1,0,0,0,152,1078,1,0,0,0,154,1085,1,0,0, + 0,156,1087,1,0,0,0,158,1141,1,0,0,0,160,1147,1,0,0,0,162,1149,1,0,0,0, + 164,1179,1,0,0,0,166,1181,1,0,0,0,168,1183,1,0,0,0,170,1193,1,0,0,0,172, + 1206,1,0,0,0,174,1216,1,0,0,0,176,1220,1,0,0,0,178,1223,1,0,0,0,180,1231, + 1,0,0,0,182,1236,1,0,0,0,184,1240,1,0,0,0,186,1242,1,0,0,0,188,1245,1, + 0,0,0,190,1258,1,0,0,0,192,1260,1,0,0,0,194,1267,1,0,0,0,196,1271,1,0, + 0,0,198,1283,1,0,0,0,200,1293,1,0,0,0,202,1299,1,0,0,0,204,1310,1,0,0, + 0,206,1322,1,0,0,0,208,1324,1,0,0,0,210,1335,1,0,0,0,212,1349,1,0,0,0, + 214,1355,1,0,0,0,216,1357,1,0,0,0,218,1364,1,0,0,0,220,1385,1,0,0,0,222, + 1387,1,0,0,0,224,1395,1,0,0,0,226,1404,1,0,0,0,228,1412,1,0,0,0,230,1426, + 1,0,0,0,232,1445,1,0,0,0,234,1462,1,0,0,0,236,1481,1,0,0,0,238,1484,1, + 0,0,0,240,1488,1,0,0,0,242,1490,1,0,0,0,244,1493,1,0,0,0,246,1497,1,0, + 0,0,248,1509,1,0,0,0,250,1520,1,0,0,0,252,1536,1,0,0,0,254,1559,1,0,0, + 0,256,1564,1,0,0,0,258,1584,1,0,0,0,260,1591,1,0,0,0,262,1600,1,0,0,0, + 264,1614,1,0,0,0,266,1633,1,0,0,0,268,1640,1,0,0,0,270,1645,1,0,0,0,272, + 1649,1,0,0,0,274,1651,1,0,0,0,276,1665,1,0,0,0,278,1676,1,0,0,0,280,1678, + 1,0,0,0,282,1708,1,0,0,0,284,1711,1,0,0,0,286,1715,1,0,0,0,288,1717,1, + 0,0,0,290,1723,1,0,0,0,292,1743,1,0,0,0,294,1745,1,0,0,0,296,1773,1,0, + 0,0,298,1776,1,0,0,0,300,1780,1,0,0,0,302,1782,1,0,0,0,304,1786,1,0,0, + 0,306,1789,1,0,0,0,308,1804,1,0,0,0,310,1825,1,0,0,0,312,1827,1,0,0,0, + 314,1829,1,0,0,0,316,1831,1,0,0,0,318,1834,1,0,0,0,320,1838,1,0,0,0,322, + 1842,1,0,0,0,324,1845,1,0,0,0,326,1859,1,0,0,0,328,1870,1,0,0,0,330,1872, + 1,0,0,0,332,1875,1,0,0,0,334,1881,1,0,0,0,336,1887,1,0,0,0,338,1897,1, + 0,0,0,340,1908,1,0,0,0,342,1923,1,0,0,0,344,1941,1,0,0,0,346,1943,1,0, + 0,0,348,1945,1,0,0,0,350,1962,1,0,0,0,352,1964,1,0,0,0,354,1974,1,0,0, + 0,356,1979,1,0,0,0,358,1984,1,0,0,0,360,1988,1,0,0,0,362,1996,1,0,0,0, + 364,2000,1,0,0,0,366,2015,1,0,0,0,368,2017,1,0,0,0,370,2023,1,0,0,0,372, + 2025,1,0,0,0,374,2032,1,0,0,0,376,2052,1,0,0,0,378,2105,1,0,0,0,380,2107, + 1,0,0,0,382,384,3,120,60,0,383,382,1,0,0,0,383,384,1,0,0,0,384,385,1, + 0,0,0,385,386,5,0,0,1,386,1,1,0,0,0,387,389,3,380,190,0,388,387,1,0,0, + 0,389,390,1,0,0,0,390,388,1,0,0,0,390,391,1,0,0,0,391,400,1,0,0,0,392, + 400,5,69,0,0,393,394,5,85,0,0,394,395,3,90,45,0,395,396,5,86,0,0,396, + 400,1,0,0,0,397,400,3,4,2,0,398,400,3,12,6,0,399,388,1,0,0,0,399,392, + 1,0,0,0,399,393,1,0,0,0,399,397,1,0,0,0,399,398,1,0,0,0,400,3,1,0,0,0, + 401,404,3,6,3,0,402,404,3,8,4,0,403,401,1,0,0,0,403,402,1,0,0,0,404,5, + 1,0,0,0,405,416,5,132,0,0,406,416,3,330,165,0,407,416,3,316,158,0,408, + 416,3,332,166,0,409,412,5,99,0,0,410,413,3,278,139,0,411,413,3,162,81, + 0,412,410,1,0,0,0,412,411,1,0,0,0,413,416,1,0,0,0,414,416,3,344,172,0, + 415,405,1,0,0,0,415,406,1,0,0,0,415,407,1,0,0,0,415,408,1,0,0,0,415,409, + 1,0,0,0,415,414,1,0,0,0,416,7,1,0,0,0,417,419,3,10,5,0,418,420,5,68,0, + 0,419,418,1,0,0,0,419,420,1,0,0,0,420,421,1,0,0,0,421,422,3,6,3,0,422, + 9,1,0,0,0,423,427,6,5,-1,0,424,428,3,160,80,0,425,428,3,184,92,0,426, + 428,3,162,81,0,427,424,1,0,0,0,427,425,1,0,0,0,427,426,1,0,0,0,427,428, + 1,0,0,0,428,429,1,0,0,0,429,430,5,127,0,0,430,442,1,0,0,0,431,437,10, + 1,0,0,432,438,5,132,0,0,433,435,5,68,0,0,434,433,1,0,0,0,434,435,1,0, + 0,0,435,436,1,0,0,0,436,438,3,342,171,0,437,432,1,0,0,0,437,434,1,0,0, + 0,438,439,1,0,0,0,439,441,5,127,0,0,440,431,1,0,0,0,441,444,1,0,0,0,442, + 440,1,0,0,0,442,443,1,0,0,0,443,11,1,0,0,0,444,442,1,0,0,0,445,447,3, + 14,7,0,446,448,3,28,14,0,447,446,1,0,0,0,447,448,1,0,0,0,448,449,1,0, + 0,0,449,450,3,100,50,0,450,13,1,0,0,0,451,453,5,87,0,0,452,454,3,16,8, + 0,453,452,1,0,0,0,453,454,1,0,0,0,454,455,1,0,0,0,455,456,5,88,0,0,456, + 15,1,0,0,0,457,464,3,20,10,0,458,461,3,18,9,0,459,460,5,122,0,0,460,462, + 3,20,10,0,461,459,1,0,0,0,461,462,1,0,0,0,462,464,1,0,0,0,463,457,1,0, + 0,0,463,458,1,0,0,0,464,17,1,0,0,0,465,466,7,0,0,0,466,19,1,0,0,0,467, + 472,3,22,11,0,468,469,5,122,0,0,469,471,3,22,11,0,470,468,1,0,0,0,471, + 474,1,0,0,0,472,470,1,0,0,0,472,473,1,0,0,0,473,476,1,0,0,0,474,472,1, + 0,0,0,475,477,5,131,0,0,476,475,1,0,0,0,476,477,1,0,0,0,477,21,1,0,0, + 0,478,481,3,24,12,0,479,481,3,26,13,0,480,478,1,0,0,0,480,479,1,0,0,0, + 481,23,1,0,0,0,482,484,5,97,0,0,483,482,1,0,0,0,483,484,1,0,0,0,484,485, + 1,0,0,0,485,488,5,132,0,0,486,488,5,69,0,0,487,483,1,0,0,0,487,486,1, + 0,0,0,488,25,1,0,0,0,489,491,5,97,0,0,490,489,1,0,0,0,490,491,1,0,0,0, + 491,492,1,0,0,0,492,493,5,132,0,0,493,494,3,268,134,0,494,27,1,0,0,0, + 495,497,5,85,0,0,496,498,3,258,129,0,497,496,1,0,0,0,497,498,1,0,0,0, + 498,499,1,0,0,0,499,501,5,86,0,0,500,502,5,47,0,0,501,500,1,0,0,0,501, + 502,1,0,0,0,502,504,1,0,0,0,503,505,3,370,185,0,504,503,1,0,0,0,504,505, + 1,0,0,0,505,507,1,0,0,0,506,508,3,204,102,0,507,506,1,0,0,0,507,508,1, + 0,0,0,508,510,1,0,0,0,509,511,3,234,117,0,510,509,1,0,0,0,510,511,1,0, + 0,0,511,29,1,0,0,0,512,513,6,15,-1,0,513,543,3,2,1,0,514,517,3,158,79, + 0,515,517,3,352,176,0,516,514,1,0,0,0,516,515,1,0,0,0,517,524,1,0,0,0, + 518,520,5,85,0,0,519,521,3,34,17,0,520,519,1,0,0,0,520,521,1,0,0,0,521, + 522,1,0,0,0,522,525,5,86,0,0,523,525,3,276,138,0,524,518,1,0,0,0,524, + 523,1,0,0,0,525,543,1,0,0,0,526,527,7,1,0,0,527,528,5,102,0,0,528,529, + 3,246,123,0,529,530,5,103,0,0,530,531,5,85,0,0,531,532,3,90,45,0,532, + 533,5,86,0,0,533,543,1,0,0,0,534,535,3,32,16,0,535,538,5,85,0,0,536,539, + 3,90,45,0,537,539,3,246,123,0,538,536,1,0,0,0,538,537,1,0,0,0,539,540, + 1,0,0,0,540,541,5,86,0,0,541,543,1,0,0,0,542,512,1,0,0,0,542,516,1,0, + 0,0,542,526,1,0,0,0,542,534,1,0,0,0,543,571,1,0,0,0,544,545,10,7,0,0, + 545,548,5,87,0,0,546,549,3,90,45,0,547,549,3,276,138,0,548,546,1,0,0, + 0,548,547,1,0,0,0,549,550,1,0,0,0,550,551,5,88,0,0,551,570,1,0,0,0,552, + 553,10,6,0,0,553,555,5,85,0,0,554,556,3,34,17,0,555,554,1,0,0,0,555,556, + 1,0,0,0,556,557,1,0,0,0,557,570,5,86,0,0,558,559,10,4,0,0,559,565,7,2, + 0,0,560,562,5,68,0,0,561,560,1,0,0,0,561,562,1,0,0,0,562,563,1,0,0,0, + 563,566,3,4,2,0,564,566,3,36,18,0,565,561,1,0,0,0,565,564,1,0,0,0,566, + 570,1,0,0,0,567,568,10,3,0,0,568,570,7,3,0,0,569,544,1,0,0,0,569,552, + 1,0,0,0,569,558,1,0,0,0,569,567,1,0,0,0,570,573,1,0,0,0,571,569,1,0,0, + 0,571,572,1,0,0,0,572,31,1,0,0,0,573,571,1,0,0,0,574,575,5,75,0,0,575, + 33,1,0,0,0,576,577,3,274,137,0,577,35,1,0,0,0,578,580,3,10,5,0,579,578, + 1,0,0,0,579,580,1,0,0,0,580,584,1,0,0,0,581,582,3,160,80,0,582,583,5, + 127,0,0,583,585,1,0,0,0,584,581,1,0,0,0,584,585,1,0,0,0,585,586,1,0,0, + 0,586,587,5,99,0,0,587,598,3,160,80,0,588,589,3,10,5,0,589,590,5,68,0, + 0,590,591,3,342,171,0,591,592,5,127,0,0,592,593,5,99,0,0,593,594,3,160, + 80,0,594,598,1,0,0,0,595,596,5,99,0,0,596,598,3,162,81,0,597,579,1,0, + 0,0,597,588,1,0,0,0,597,595,1,0,0,0,598,37,1,0,0,0,599,627,3,30,15,0, + 600,605,5,120,0,0,601,605,5,121,0,0,602,605,3,40,20,0,603,605,5,62,0, + 0,604,600,1,0,0,0,604,601,1,0,0,0,604,602,1,0,0,0,604,603,1,0,0,0,605, + 606,1,0,0,0,606,627,3,38,19,0,607,616,5,62,0,0,608,609,5,85,0,0,609,610, + 3,246,123,0,610,611,5,86,0,0,611,617,1,0,0,0,612,613,5,131,0,0,613,614, + 5,85,0,0,614,615,5,132,0,0,615,617,5,86,0,0,616,608,1,0,0,0,616,612,1, + 0,0,0,617,627,1,0,0,0,618,619,5,11,0,0,619,620,5,85,0,0,620,621,3,246, + 123,0,621,622,5,86,0,0,622,627,1,0,0,0,623,627,3,56,28,0,624,627,3,42, + 21,0,625,627,3,54,27,0,626,599,1,0,0,0,626,604,1,0,0,0,626,607,1,0,0, + 0,626,618,1,0,0,0,626,623,1,0,0,0,626,624,1,0,0,0,626,625,1,0,0,0,627, + 39,1,0,0,0,628,629,7,4,0,0,629,41,1,0,0,0,630,632,5,127,0,0,631,630,1, + 0,0,0,631,632,1,0,0,0,632,633,1,0,0,0,633,635,5,49,0,0,634,636,3,44,22, + 0,635,634,1,0,0,0,635,636,1,0,0,0,636,642,1,0,0,0,637,643,3,46,23,0,638, + 639,5,85,0,0,639,640,3,246,123,0,640,641,5,86,0,0,641,643,1,0,0,0,642, + 637,1,0,0,0,642,638,1,0,0,0,643,645,1,0,0,0,644,646,3,52,26,0,645,644, + 1,0,0,0,645,646,1,0,0,0,646,43,1,0,0,0,647,648,5,85,0,0,648,649,3,34, + 17,0,649,650,5,86,0,0,650,45,1,0,0,0,651,653,3,150,75,0,652,654,3,48, + 24,0,653,652,1,0,0,0,653,654,1,0,0,0,654,47,1,0,0,0,655,657,3,236,118, + 0,656,658,3,48,24,0,657,656,1,0,0,0,657,658,1,0,0,0,658,661,1,0,0,0,659, + 661,3,50,25,0,660,655,1,0,0,0,660,659,1,0,0,0,661,49,1,0,0,0,662,663, + 6,25,-1,0,663,664,5,87,0,0,664,665,3,90,45,0,665,667,5,88,0,0,666,668, + 3,204,102,0,667,666,1,0,0,0,667,668,1,0,0,0,668,678,1,0,0,0,669,670,10, + 1,0,0,670,671,5,87,0,0,671,672,3,92,46,0,672,674,5,88,0,0,673,675,3,204, + 102,0,674,673,1,0,0,0,674,675,1,0,0,0,675,677,1,0,0,0,676,669,1,0,0,0, + 677,680,1,0,0,0,678,676,1,0,0,0,678,679,1,0,0,0,679,51,1,0,0,0,680,678, + 1,0,0,0,681,683,5,85,0,0,682,684,3,34,17,0,683,682,1,0,0,0,683,684,1, + 0,0,0,684,685,1,0,0,0,685,688,5,86,0,0,686,688,3,276,138,0,687,681,1, + 0,0,0,687,686,1,0,0,0,688,53,1,0,0,0,689,691,5,127,0,0,690,689,1,0,0, + 0,690,691,1,0,0,0,691,692,1,0,0,0,692,695,5,28,0,0,693,694,5,87,0,0,694, + 696,5,88,0,0,695,693,1,0,0,0,695,696,1,0,0,0,696,697,1,0,0,0,697,698, + 3,58,29,0,698,55,1,0,0,0,699,700,5,50,0,0,700,701,5,85,0,0,701,702,3, + 90,45,0,702,703,5,86,0,0,703,57,1,0,0,0,704,711,3,38,19,0,705,706,5,85, + 0,0,706,707,3,246,123,0,707,708,5,86,0,0,708,709,3,58,29,0,709,711,1, + 0,0,0,710,704,1,0,0,0,710,705,1,0,0,0,711,59,1,0,0,0,712,717,3,58,29, + 0,713,714,7,5,0,0,714,716,3,58,29,0,715,713,1,0,0,0,716,719,1,0,0,0,717, + 715,1,0,0,0,717,718,1,0,0,0,718,61,1,0,0,0,719,717,1,0,0,0,720,725,3, + 60,30,0,721,722,7,6,0,0,722,724,3,60,30,0,723,721,1,0,0,0,724,727,1,0, + 0,0,725,723,1,0,0,0,725,726,1,0,0,0,726,63,1,0,0,0,727,725,1,0,0,0,728, + 733,3,62,31,0,729,730,7,7,0,0,730,732,3,62,31,0,731,729,1,0,0,0,732,735, + 1,0,0,0,733,731,1,0,0,0,733,734,1,0,0,0,734,65,1,0,0,0,735,733,1,0,0, + 0,736,742,3,64,32,0,737,738,3,68,34,0,738,739,3,64,32,0,739,741,1,0,0, + 0,740,737,1,0,0,0,741,744,1,0,0,0,742,740,1,0,0,0,742,743,1,0,0,0,743, + 67,1,0,0,0,744,742,1,0,0,0,745,746,5,103,0,0,746,750,5,103,0,0,747,748, + 5,102,0,0,748,750,5,102,0,0,749,745,1,0,0,0,749,747,1,0,0,0,750,69,1, + 0,0,0,751,756,3,66,33,0,752,753,7,8,0,0,753,755,3,66,33,0,754,752,1,0, + 0,0,755,758,1,0,0,0,756,754,1,0,0,0,756,757,1,0,0,0,757,71,1,0,0,0,758, + 756,1,0,0,0,759,764,3,70,35,0,760,761,7,9,0,0,761,763,3,70,35,0,762,760, + 1,0,0,0,763,766,1,0,0,0,764,762,1,0,0,0,764,765,1,0,0,0,765,73,1,0,0, + 0,766,764,1,0,0,0,767,772,3,72,36,0,768,769,5,97,0,0,769,771,3,72,36, + 0,770,768,1,0,0,0,771,774,1,0,0,0,772,770,1,0,0,0,772,773,1,0,0,0,773, + 75,1,0,0,0,774,772,1,0,0,0,775,780,3,74,37,0,776,777,5,96,0,0,777,779, + 3,74,37,0,778,776,1,0,0,0,779,782,1,0,0,0,780,778,1,0,0,0,780,781,1,0, + 0,0,781,77,1,0,0,0,782,780,1,0,0,0,783,788,3,76,38,0,784,785,5,98,0,0, + 785,787,3,76,38,0,786,784,1,0,0,0,787,790,1,0,0,0,788,786,1,0,0,0,788, + 789,1,0,0,0,789,79,1,0,0,0,790,788,1,0,0,0,791,796,3,78,39,0,792,793, + 5,118,0,0,793,795,3,78,39,0,794,792,1,0,0,0,795,798,1,0,0,0,796,794,1, + 0,0,0,796,797,1,0,0,0,797,81,1,0,0,0,798,796,1,0,0,0,799,804,3,80,40, + 0,800,801,5,119,0,0,801,803,3,80,40,0,802,800,1,0,0,0,803,806,1,0,0,0, + 804,802,1,0,0,0,804,805,1,0,0,0,805,83,1,0,0,0,806,804,1,0,0,0,807,813, + 3,82,41,0,808,809,5,125,0,0,809,810,3,90,45,0,810,811,5,126,0,0,811,812, + 3,86,43,0,812,814,1,0,0,0,813,808,1,0,0,0,813,814,1,0,0,0,814,85,1,0, + 0,0,815,822,3,84,42,0,816,817,3,82,41,0,817,818,3,88,44,0,818,819,3,272, + 136,0,819,822,1,0,0,0,820,822,3,368,184,0,821,815,1,0,0,0,821,816,1,0, + 0,0,821,820,1,0,0,0,822,87,1,0,0,0,823,824,7,10,0,0,824,89,1,0,0,0,825, + 830,3,86,43,0,826,827,5,122,0,0,827,829,3,86,43,0,828,826,1,0,0,0,829, + 832,1,0,0,0,830,828,1,0,0,0,830,831,1,0,0,0,831,91,1,0,0,0,832,830,1, + 0,0,0,833,834,3,84,42,0,834,93,1,0,0,0,835,849,3,96,48,0,836,849,3,118, + 59,0,837,839,3,204,102,0,838,837,1,0,0,0,838,839,1,0,0,0,839,846,1,0, + 0,0,840,847,3,98,49,0,841,847,3,100,50,0,842,847,3,104,52,0,843,847,3, + 108,54,0,844,847,3,116,58,0,845,847,3,358,179,0,846,840,1,0,0,0,846,841, + 1,0,0,0,846,842,1,0,0,0,846,843,1,0,0,0,846,844,1,0,0,0,846,845,1,0,0, + 0,847,849,1,0,0,0,848,835,1,0,0,0,848,836,1,0,0,0,848,838,1,0,0,0,849, + 95,1,0,0,0,850,852,3,204,102,0,851,850,1,0,0,0,851,852,1,0,0,0,852,857, + 1,0,0,0,853,858,5,132,0,0,854,855,5,16,0,0,855,858,3,92,46,0,856,858, + 5,27,0,0,857,853,1,0,0,0,857,854,1,0,0,0,857,856,1,0,0,0,858,859,1,0, + 0,0,859,860,5,126,0,0,860,861,3,94,47,0,861,97,1,0,0,0,862,864,3,90,45, + 0,863,862,1,0,0,0,863,864,1,0,0,0,864,865,1,0,0,0,865,866,5,128,0,0,866, + 99,1,0,0,0,867,869,5,89,0,0,868,870,3,102,51,0,869,868,1,0,0,0,869,870, + 1,0,0,0,870,871,1,0,0,0,871,872,5,90,0,0,872,101,1,0,0,0,873,875,3,94, + 47,0,874,873,1,0,0,0,875,876,1,0,0,0,876,874,1,0,0,0,876,877,1,0,0,0, + 877,103,1,0,0,0,878,879,5,43,0,0,879,880,5,85,0,0,880,881,3,106,53,0, + 881,882,5,86,0,0,882,885,3,94,47,0,883,884,5,32,0,0,884,886,3,94,47,0, + 885,883,1,0,0,0,885,886,1,0,0,0,886,894,1,0,0,0,887,888,5,67,0,0,888, + 889,5,85,0,0,889,890,3,106,53,0,890,891,5,86,0,0,891,892,3,94,47,0,892, + 894,1,0,0,0,893,878,1,0,0,0,893,887,1,0,0,0,894,105,1,0,0,0,895,907,3, + 90,45,0,896,898,3,204,102,0,897,896,1,0,0,0,897,898,1,0,0,0,898,899,1, + 0,0,0,899,900,3,138,69,0,900,904,3,226,113,0,901,902,5,101,0,0,902,905, + 3,272,136,0,903,905,3,276,138,0,904,901,1,0,0,0,904,903,1,0,0,0,905,907, + 1,0,0,0,906,895,1,0,0,0,906,897,1,0,0,0,907,107,1,0,0,0,908,909,5,84, + 0,0,909,910,5,85,0,0,910,911,3,106,53,0,911,912,5,86,0,0,912,913,3,94, + 47,0,913,942,1,0,0,0,914,915,5,29,0,0,915,916,3,94,47,0,916,917,5,84, + 0,0,917,918,5,85,0,0,918,919,3,90,45,0,919,920,5,86,0,0,920,921,5,128, + 0,0,921,942,1,0,0,0,922,923,5,40,0,0,923,936,5,85,0,0,924,926,3,110,55, + 0,925,927,3,106,53,0,926,925,1,0,0,0,926,927,1,0,0,0,927,928,1,0,0,0, + 928,930,5,128,0,0,929,931,3,90,45,0,930,929,1,0,0,0,930,931,1,0,0,0,931, + 937,1,0,0,0,932,933,3,112,56,0,933,934,5,126,0,0,934,935,3,114,57,0,935, + 937,1,0,0,0,936,924,1,0,0,0,936,932,1,0,0,0,937,938,1,0,0,0,938,939,5, + 86,0,0,939,940,3,94,47,0,940,942,1,0,0,0,941,908,1,0,0,0,941,914,1,0, + 0,0,941,922,1,0,0,0,942,109,1,0,0,0,943,946,3,98,49,0,944,946,3,128,64, + 0,945,943,1,0,0,0,945,944,1,0,0,0,946,111,1,0,0,0,947,949,3,204,102,0, + 948,947,1,0,0,0,948,949,1,0,0,0,949,950,1,0,0,0,950,951,3,138,69,0,951, + 952,3,226,113,0,952,113,1,0,0,0,953,956,3,90,45,0,954,956,3,276,138,0, + 955,953,1,0,0,0,955,954,1,0,0,0,956,115,1,0,0,0,957,967,5,15,0,0,958, + 967,5,25,0,0,959,962,5,59,0,0,960,963,3,90,45,0,961,963,3,276,138,0,962, + 960,1,0,0,0,962,961,1,0,0,0,962,963,1,0,0,0,963,967,1,0,0,0,964,965,5, + 42,0,0,965,967,5,132,0,0,966,957,1,0,0,0,966,958,1,0,0,0,966,959,1,0, + 0,0,966,964,1,0,0,0,967,968,1,0,0,0,968,969,5,128,0,0,969,117,1,0,0,0, + 970,971,3,124,62,0,971,119,1,0,0,0,972,974,3,122,61,0,973,972,1,0,0,0, + 974,975,1,0,0,0,975,973,1,0,0,0,975,976,1,0,0,0,976,121,1,0,0,0,977,987, + 3,124,62,0,978,987,3,264,132,0,979,987,3,334,167,0,980,987,3,354,177, + 0,981,987,3,356,178,0,982,987,3,202,101,0,983,987,3,188,94,0,984,987, + 3,132,66,0,985,987,3,134,67,0,986,977,1,0,0,0,986,978,1,0,0,0,986,979, + 1,0,0,0,986,980,1,0,0,0,986,981,1,0,0,0,986,982,1,0,0,0,986,983,1,0,0, + 0,986,984,1,0,0,0,986,985,1,0,0,0,987,123,1,0,0,0,988,997,3,128,64,0, + 989,997,3,200,100,0,990,997,3,192,96,0,991,997,3,196,98,0,992,997,3,198, + 99,0,993,997,3,130,65,0,994,997,3,126,63,0,995,997,3,172,86,0,996,988, + 1,0,0,0,996,989,1,0,0,0,996,990,1,0,0,0,996,991,1,0,0,0,996,992,1,0,0, + 0,996,993,1,0,0,0,996,994,1,0,0,0,996,995,1,0,0,0,997,125,1,0,0,0,998, + 999,5,79,0,0,999,1001,5,132,0,0,1000,1002,3,204,102,0,1001,1000,1,0,0, + 0,1001,1002,1,0,0,0,1002,1003,1,0,0,0,1003,1004,5,101,0,0,1004,1005,3, + 246,123,0,1005,1006,5,128,0,0,1006,127,1,0,0,0,1007,1009,3,138,69,0,1008, + 1007,1,0,0,0,1008,1009,1,0,0,0,1009,1011,1,0,0,0,1010,1012,3,222,111, + 0,1011,1010,1,0,0,0,1011,1012,1,0,0,0,1012,1013,1,0,0,0,1013,1022,5,128, + 0,0,1014,1016,3,204,102,0,1015,1017,3,138,69,0,1016,1015,1,0,0,0,1016, + 1017,1,0,0,0,1017,1018,1,0,0,0,1018,1019,3,222,111,0,1019,1020,5,128, + 0,0,1020,1022,1,0,0,0,1021,1008,1,0,0,0,1021,1014,1,0,0,0,1022,129,1, + 0,0,0,1023,1024,5,64,0,0,1024,1025,5,85,0,0,1025,1026,3,92,46,0,1026, + 1027,5,122,0,0,1027,1028,5,4,0,0,1028,1029,5,86,0,0,1029,1030,5,128,0, + 0,1030,131,1,0,0,0,1031,1032,5,128,0,0,1032,133,1,0,0,0,1033,1034,3,204, + 102,0,1034,1035,5,128,0,0,1035,135,1,0,0,0,1036,1043,3,140,70,0,1037, + 1043,3,146,73,0,1038,1043,3,142,71,0,1039,1043,5,41,0,0,1040,1043,5,74, + 0,0,1041,1043,5,23,0,0,1042,1036,1,0,0,0,1042,1037,1,0,0,0,1042,1038, + 1,0,0,0,1042,1039,1,0,0,0,1042,1040,1,0,0,0,1042,1041,1,0,0,0,1043,137, + 1,0,0,0,1044,1046,3,136,68,0,1045,1044,1,0,0,0,1046,1047,1,0,0,0,1047, + 1048,1,0,0,0,1047,1045,1,0,0,0,1048,1050,1,0,0,0,1049,1051,3,204,102, + 0,1050,1049,1,0,0,0,1050,1051,1,0,0,0,1051,139,1,0,0,0,1052,1053,7,11, + 0,0,1053,141,1,0,0,0,1054,1055,7,12,0,0,1055,143,1,0,0,0,1056,1057,5, + 132,0,0,1057,145,1,0,0,0,1058,1062,3,148,74,0,1059,1062,3,280,140,0,1060, + 1062,3,168,84,0,1061,1058,1,0,0,0,1061,1059,1,0,0,0,1061,1060,1,0,0,0, + 1062,147,1,0,0,0,1063,1068,3,158,79,0,1064,1068,3,164,82,0,1065,1068, + 3,352,176,0,1066,1068,3,240,120,0,1067,1063,1,0,0,0,1067,1064,1,0,0,0, + 1067,1065,1,0,0,0,1067,1066,1,0,0,0,1068,149,1,0,0,0,1069,1071,3,146, + 73,0,1070,1069,1,0,0,0,1071,1072,1,0,0,0,1072,1070,1,0,0,0,1072,1073, + 1,0,0,0,1073,1075,1,0,0,0,1074,1076,3,204,102,0,1075,1074,1,0,0,0,1075, + 1076,1,0,0,0,1076,151,1,0,0,0,1077,1079,3,148,74,0,1078,1077,1,0,0,0, + 1079,1080,1,0,0,0,1080,1078,1,0,0,0,1080,1081,1,0,0,0,1081,1083,1,0,0, + 0,1082,1084,3,204,102,0,1083,1082,1,0,0,0,1083,1084,1,0,0,0,1084,153, + 1,0,0,0,1085,1086,7,13,0,0,1086,155,1,0,0,0,1087,1088,7,14,0,0,1088,157, + 1,0,0,0,1089,1091,3,10,5,0,1090,1089,1,0,0,0,1090,1091,1,0,0,0,1091,1092, + 1,0,0,0,1092,1142,3,160,80,0,1093,1094,3,10,5,0,1094,1095,5,68,0,0,1095, + 1096,3,342,171,0,1096,1142,1,0,0,0,1097,1142,3,156,78,0,1098,1100,3,156, + 78,0,1099,1098,1,0,0,0,1099,1100,1,0,0,0,1100,1102,1,0,0,0,1101,1103, + 3,154,77,0,1102,1101,1,0,0,0,1103,1104,1,0,0,0,1104,1102,1,0,0,0,1104, + 1105,1,0,0,0,1105,1142,1,0,0,0,1106,1108,3,156,78,0,1107,1106,1,0,0,0, + 1107,1108,1,0,0,0,1108,1109,1,0,0,0,1109,1142,5,18,0,0,1110,1112,3,156, + 78,0,1111,1110,1,0,0,0,1111,1112,1,0,0,0,1112,1113,1,0,0,0,1113,1142, + 5,19,0,0,1114,1116,3,156,78,0,1115,1114,1,0,0,0,1115,1116,1,0,0,0,1116, + 1117,1,0,0,0,1117,1142,5,20,0,0,1118,1120,3,156,78,0,1119,1118,1,0,0, + 0,1119,1120,1,0,0,0,1120,1121,1,0,0,0,1121,1142,5,83,0,0,1122,1142,5, + 14,0,0,1123,1125,3,156,78,0,1124,1123,1,0,0,0,1124,1125,1,0,0,0,1125, + 1129,1,0,0,0,1126,1128,3,154,77,0,1127,1126,1,0,0,0,1128,1131,1,0,0,0, + 1129,1127,1,0,0,0,1129,1130,1,0,0,0,1130,1132,1,0,0,0,1131,1129,1,0,0, + 0,1132,1142,5,45,0,0,1133,1142,5,39,0,0,1134,1136,3,154,77,0,1135,1134, + 1,0,0,0,1135,1136,1,0,0,0,1136,1137,1,0,0,0,1137,1142,5,30,0,0,1138,1142, + 5,81,0,0,1139,1142,5,13,0,0,1140,1142,3,162,81,0,1141,1090,1,0,0,0,1141, + 1093,1,0,0,0,1141,1097,1,0,0,0,1141,1099,1,0,0,0,1141,1107,1,0,0,0,1141, + 1111,1,0,0,0,1141,1115,1,0,0,0,1141,1119,1,0,0,0,1141,1122,1,0,0,0,1141, + 1124,1,0,0,0,1141,1133,1,0,0,0,1141,1135,1,0,0,0,1141,1138,1,0,0,0,1141, + 1139,1,0,0,0,1141,1140,1,0,0,0,1142,159,1,0,0,0,1143,1148,3,278,139,0, + 1144,1148,3,166,83,0,1145,1148,3,144,72,0,1146,1148,3,342,171,0,1147, + 1143,1,0,0,0,1147,1144,1,0,0,0,1147,1145,1,0,0,0,1147,1146,1,0,0,0,1148, + 161,1,0,0,0,1149,1150,5,26,0,0,1150,1153,5,85,0,0,1151,1154,3,90,45,0, + 1152,1154,5,13,0,0,1153,1151,1,0,0,0,1153,1152,1,0,0,0,1154,1155,1,0, + 0,0,1155,1156,5,86,0,0,1156,163,1,0,0,0,1157,1172,3,288,144,0,1158,1160, + 3,204,102,0,1159,1158,1,0,0,0,1159,1160,1,0,0,0,1160,1162,1,0,0,0,1161, + 1163,3,10,5,0,1162,1161,1,0,0,0,1162,1163,1,0,0,0,1163,1164,1,0,0,0,1164, + 1173,5,132,0,0,1165,1173,3,342,171,0,1166,1168,3,10,5,0,1167,1169,5,68, + 0,0,1168,1167,1,0,0,0,1168,1169,1,0,0,0,1169,1170,1,0,0,0,1170,1171,3, + 342,171,0,1171,1173,1,0,0,0,1172,1159,1,0,0,0,1172,1165,1,0,0,0,1172, + 1166,1,0,0,0,1173,1180,1,0,0,0,1174,1176,5,33,0,0,1175,1177,3,10,5,0, + 1176,1175,1,0,0,0,1176,1177,1,0,0,0,1177,1178,1,0,0,0,1178,1180,5,132, + 0,0,1179,1157,1,0,0,0,1179,1174,1,0,0,0,1180,165,1,0,0,0,1181,1182,5, + 132,0,0,1182,167,1,0,0,0,1183,1184,3,170,85,0,1184,1189,5,89,0,0,1185, + 1187,3,178,89,0,1186,1188,5,122,0,0,1187,1186,1,0,0,0,1187,1188,1,0,0, + 0,1188,1190,1,0,0,0,1189,1185,1,0,0,0,1189,1190,1,0,0,0,1190,1191,1,0, + 0,0,1191,1192,5,90,0,0,1192,169,1,0,0,0,1193,1195,3,174,87,0,1194,1196, + 3,204,102,0,1195,1194,1,0,0,0,1195,1196,1,0,0,0,1196,1201,1,0,0,0,1197, + 1199,3,10,5,0,1198,1197,1,0,0,0,1198,1199,1,0,0,0,1199,1200,1,0,0,0,1200, + 1202,5,132,0,0,1201,1198,1,0,0,0,1201,1202,1,0,0,0,1202,1204,1,0,0,0, + 1203,1205,3,176,88,0,1204,1203,1,0,0,0,1204,1205,1,0,0,0,1205,171,1,0, + 0,0,1206,1208,3,174,87,0,1207,1209,3,204,102,0,1208,1207,1,0,0,0,1208, + 1209,1,0,0,0,1209,1210,1,0,0,0,1210,1212,5,132,0,0,1211,1213,3,176,88, + 0,1212,1211,1,0,0,0,1212,1213,1,0,0,0,1213,1214,1,0,0,0,1214,1215,5,128, + 0,0,1215,173,1,0,0,0,1216,1218,5,33,0,0,1217,1219,7,15,0,0,1218,1217, + 1,0,0,0,1218,1219,1,0,0,0,1219,175,1,0,0,0,1220,1221,5,126,0,0,1221,1222, + 3,150,75,0,1222,177,1,0,0,0,1223,1228,3,180,90,0,1224,1225,5,122,0,0, + 1225,1227,3,180,90,0,1226,1224,1,0,0,0,1227,1230,1,0,0,0,1228,1226,1, + 0,0,0,1228,1229,1,0,0,0,1229,179,1,0,0,0,1230,1228,1,0,0,0,1231,1234, + 3,182,91,0,1232,1233,5,101,0,0,1233,1235,3,92,46,0,1234,1232,1,0,0,0, + 1234,1235,1,0,0,0,1235,181,1,0,0,0,1236,1237,5,132,0,0,1237,183,1,0,0, + 0,1238,1241,3,186,93,0,1239,1241,3,190,95,0,1240,1238,1,0,0,0,1240,1239, + 1,0,0,0,1241,185,1,0,0,0,1242,1243,5,132,0,0,1243,187,1,0,0,0,1244,1246, + 5,44,0,0,1245,1244,1,0,0,0,1245,1246,1,0,0,0,1246,1247,1,0,0,0,1247,1250, + 5,48,0,0,1248,1251,5,132,0,0,1249,1251,3,186,93,0,1250,1248,1,0,0,0,1250, + 1249,1,0,0,0,1250,1251,1,0,0,0,1251,1252,1,0,0,0,1252,1254,5,89,0,0,1253, + 1255,3,120,60,0,1254,1253,1,0,0,0,1254,1255,1,0,0,0,1255,1256,1,0,0,0, + 1256,1257,5,90,0,0,1257,189,1,0,0,0,1258,1259,5,132,0,0,1259,191,1,0, + 0,0,1260,1261,5,48,0,0,1261,1262,5,132,0,0,1262,1263,5,101,0,0,1263,1264, + 3,194,97,0,1264,1265,5,128,0,0,1265,193,1,0,0,0,1266,1268,3,10,5,0,1267, + 1266,1,0,0,0,1267,1268,1,0,0,0,1268,1269,1,0,0,0,1269,1270,3,184,92,0, + 1270,195,1,0,0,0,1271,1277,5,79,0,0,1272,1274,5,76,0,0,1273,1272,1,0, + 0,0,1273,1274,1,0,0,0,1274,1275,1,0,0,0,1275,1278,3,10,5,0,1276,1278, + 5,127,0,0,1277,1273,1,0,0,0,1277,1276,1,0,0,0,1278,1279,1,0,0,0,1279, + 1280,3,6,3,0,1280,1281,5,128,0,0,1281,197,1,0,0,0,1282,1284,3,204,102, + 0,1283,1282,1,0,0,0,1283,1284,1,0,0,0,1284,1285,1,0,0,0,1285,1286,5,79, + 0,0,1286,1288,5,48,0,0,1287,1289,3,10,5,0,1288,1287,1,0,0,0,1288,1289, + 1,0,0,0,1289,1290,1,0,0,0,1290,1291,3,184,92,0,1291,1292,5,128,0,0,1292, + 199,1,0,0,0,1293,1294,5,12,0,0,1294,1295,5,85,0,0,1295,1296,5,4,0,0,1296, + 1297,5,86,0,0,1297,1298,5,128,0,0,1298,201,1,0,0,0,1299,1300,5,36,0,0, + 1300,1307,5,4,0,0,1301,1303,5,89,0,0,1302,1304,3,120,60,0,1303,1302,1, + 0,0,0,1303,1304,1,0,0,0,1304,1305,1,0,0,0,1305,1308,5,90,0,0,1306,1308, + 3,122,61,0,1307,1301,1,0,0,0,1307,1306,1,0,0,0,1308,203,1,0,0,0,1309, + 1311,3,206,103,0,1310,1309,1,0,0,0,1311,1312,1,0,0,0,1312,1310,1,0,0, + 0,1312,1313,1,0,0,0,1313,205,1,0,0,0,1314,1315,5,87,0,0,1315,1317,5,87, + 0,0,1316,1318,3,210,105,0,1317,1316,1,0,0,0,1317,1318,1,0,0,0,1318,1319, + 1,0,0,0,1319,1320,5,88,0,0,1320,1323,5,88,0,0,1321,1323,3,208,104,0,1322, + 1314,1,0,0,0,1322,1321,1,0,0,0,1323,207,1,0,0,0,1324,1325,5,10,0,0,1325, + 1328,5,85,0,0,1326,1329,3,246,123,0,1327,1329,3,92,46,0,1328,1326,1,0, + 0,0,1328,1327,1,0,0,0,1329,1331,1,0,0,0,1330,1332,5,131,0,0,1331,1330, + 1,0,0,0,1331,1332,1,0,0,0,1332,1333,1,0,0,0,1333,1334,5,86,0,0,1334,209, + 1,0,0,0,1335,1340,3,212,106,0,1336,1337,5,122,0,0,1337,1339,3,212,106, + 0,1338,1336,1,0,0,0,1339,1342,1,0,0,0,1340,1338,1,0,0,0,1340,1341,1,0, + 0,0,1341,1344,1,0,0,0,1342,1340,1,0,0,0,1343,1345,5,131,0,0,1344,1343, + 1,0,0,0,1344,1345,1,0,0,0,1345,211,1,0,0,0,1346,1347,3,214,107,0,1347, + 1348,5,127,0,0,1348,1350,1,0,0,0,1349,1346,1,0,0,0,1349,1350,1,0,0,0, + 1350,1351,1,0,0,0,1351,1353,5,132,0,0,1352,1354,3,216,108,0,1353,1352, + 1,0,0,0,1353,1354,1,0,0,0,1354,213,1,0,0,0,1355,1356,5,132,0,0,1356,215, + 1,0,0,0,1357,1359,5,85,0,0,1358,1360,3,218,109,0,1359,1358,1,0,0,0,1359, + 1360,1,0,0,0,1360,1361,1,0,0,0,1361,1362,5,86,0,0,1362,217,1,0,0,0,1363, + 1365,3,220,110,0,1364,1363,1,0,0,0,1365,1366,1,0,0,0,1366,1364,1,0,0, + 0,1366,1367,1,0,0,0,1367,219,1,0,0,0,1368,1369,5,85,0,0,1369,1370,3,218, + 109,0,1370,1371,5,86,0,0,1371,1386,1,0,0,0,1372,1373,5,87,0,0,1373,1374, + 3,218,109,0,1374,1375,5,88,0,0,1375,1386,1,0,0,0,1376,1377,5,89,0,0,1377, + 1378,3,218,109,0,1378,1379,5,90,0,0,1379,1386,1,0,0,0,1380,1382,8,16, + 0,0,1381,1380,1,0,0,0,1382,1383,1,0,0,0,1383,1381,1,0,0,0,1383,1384,1, + 0,0,0,1384,1386,1,0,0,0,1385,1368,1,0,0,0,1385,1372,1,0,0,0,1385,1376, + 1,0,0,0,1385,1381,1,0,0,0,1386,221,1,0,0,0,1387,1392,3,224,112,0,1388, + 1389,5,122,0,0,1389,1391,3,224,112,0,1390,1388,1,0,0,0,1391,1394,1,0, + 0,0,1392,1390,1,0,0,0,1392,1393,1,0,0,0,1393,223,1,0,0,0,1394,1392,1, + 0,0,0,1395,1397,3,226,113,0,1396,1398,3,268,134,0,1397,1396,1,0,0,0,1397, + 1398,1,0,0,0,1398,225,1,0,0,0,1399,1405,3,228,114,0,1400,1401,3,230,115, + 0,1401,1402,3,232,116,0,1402,1403,3,234,117,0,1403,1405,1,0,0,0,1404, + 1399,1,0,0,0,1404,1400,1,0,0,0,1405,227,1,0,0,0,1406,1408,3,236,118,0, + 1407,1409,5,22,0,0,1408,1407,1,0,0,0,1408,1409,1,0,0,0,1409,1411,1,0, + 0,0,1410,1406,1,0,0,0,1411,1414,1,0,0,0,1412,1410,1,0,0,0,1412,1413,1, + 0,0,0,1413,1415,1,0,0,0,1414,1412,1,0,0,0,1415,1416,3,230,115,0,1416, + 229,1,0,0,0,1417,1418,6,115,-1,0,1418,1420,3,244,122,0,1419,1421,3,204, + 102,0,1420,1419,1,0,0,0,1420,1421,1,0,0,0,1421,1427,1,0,0,0,1422,1423, + 5,85,0,0,1423,1424,3,228,114,0,1424,1425,5,86,0,0,1425,1427,1,0,0,0,1426, + 1417,1,0,0,0,1426,1422,1,0,0,0,1427,1442,1,0,0,0,1428,1438,10,2,0,0,1429, + 1439,3,232,116,0,1430,1432,5,87,0,0,1431,1433,3,92,46,0,1432,1431,1,0, + 0,0,1432,1433,1,0,0,0,1433,1434,1,0,0,0,1434,1436,5,88,0,0,1435,1437, + 3,204,102,0,1436,1435,1,0,0,0,1436,1437,1,0,0,0,1437,1439,1,0,0,0,1438, + 1429,1,0,0,0,1438,1430,1,0,0,0,1439,1441,1,0,0,0,1440,1428,1,0,0,0,1441, + 1444,1,0,0,0,1442,1440,1,0,0,0,1442,1443,1,0,0,0,1443,231,1,0,0,0,1444, + 1442,1,0,0,0,1445,1447,5,85,0,0,1446,1448,3,258,129,0,1447,1446,1,0,0, + 0,1447,1448,1,0,0,0,1448,1449,1,0,0,0,1449,1451,5,86,0,0,1450,1452,3, + 238,119,0,1451,1450,1,0,0,0,1451,1452,1,0,0,0,1452,1454,1,0,0,0,1453, + 1455,3,242,121,0,1454,1453,1,0,0,0,1454,1455,1,0,0,0,1455,1457,1,0,0, + 0,1456,1458,3,370,185,0,1457,1456,1,0,0,0,1457,1458,1,0,0,0,1458,1460, + 1,0,0,0,1459,1461,3,204,102,0,1460,1459,1,0,0,0,1460,1461,1,0,0,0,1461, + 233,1,0,0,0,1462,1463,5,124,0,0,1463,1465,3,152,76,0,1464,1466,3,248, + 124,0,1465,1464,1,0,0,0,1465,1466,1,0,0,0,1466,235,1,0,0,0,1467,1469, + 7,17,0,0,1468,1470,3,204,102,0,1469,1468,1,0,0,0,1469,1470,1,0,0,0,1470, + 1482,1,0,0,0,1471,1473,3,10,5,0,1472,1471,1,0,0,0,1472,1473,1,0,0,0,1473, + 1474,1,0,0,0,1474,1476,5,93,0,0,1475,1477,3,204,102,0,1476,1475,1,0,0, + 0,1476,1477,1,0,0,0,1477,1479,1,0,0,0,1478,1480,3,238,119,0,1479,1478, + 1,0,0,0,1479,1480,1,0,0,0,1480,1482,1,0,0,0,1481,1467,1,0,0,0,1481,1472, + 1,0,0,0,1482,237,1,0,0,0,1483,1485,3,240,120,0,1484,1483,1,0,0,0,1485, + 1486,1,0,0,0,1486,1484,1,0,0,0,1486,1487,1,0,0,0,1487,239,1,0,0,0,1488, + 1489,7,18,0,0,1489,241,1,0,0,0,1490,1491,7,17,0,0,1491,243,1,0,0,0,1492, + 1494,5,131,0,0,1493,1492,1,0,0,0,1493,1494,1,0,0,0,1494,1495,1,0,0,0, + 1495,1496,3,4,2,0,1496,245,1,0,0,0,1497,1499,3,150,75,0,1498,1500,3,248, + 124,0,1499,1498,1,0,0,0,1499,1500,1,0,0,0,1500,247,1,0,0,0,1501,1510, + 3,250,125,0,1502,1504,3,252,126,0,1503,1502,1,0,0,0,1503,1504,1,0,0,0, + 1504,1505,1,0,0,0,1505,1506,3,232,116,0,1506,1507,3,234,117,0,1507,1510, + 1,0,0,0,1508,1510,3,254,127,0,1509,1501,1,0,0,0,1509,1503,1,0,0,0,1509, + 1508,1,0,0,0,1510,249,1,0,0,0,1511,1521,3,252,126,0,1512,1514,3,236,118, + 0,1513,1512,1,0,0,0,1514,1515,1,0,0,0,1515,1513,1,0,0,0,1515,1516,1,0, + 0,0,1516,1518,1,0,0,0,1517,1519,3,252,126,0,1518,1517,1,0,0,0,1518,1519, + 1,0,0,0,1519,1521,1,0,0,0,1520,1511,1,0,0,0,1520,1513,1,0,0,0,1521,251, + 1,0,0,0,1522,1523,6,126,-1,0,1523,1537,3,232,116,0,1524,1526,5,87,0,0, + 1525,1527,3,92,46,0,1526,1525,1,0,0,0,1526,1527,1,0,0,0,1527,1528,1,0, + 0,0,1528,1530,5,88,0,0,1529,1531,3,204,102,0,1530,1529,1,0,0,0,1530,1531, + 1,0,0,0,1531,1537,1,0,0,0,1532,1533,5,85,0,0,1533,1534,3,250,125,0,1534, + 1535,5,86,0,0,1535,1537,1,0,0,0,1536,1522,1,0,0,0,1536,1524,1,0,0,0,1536, + 1532,1,0,0,0,1537,1553,1,0,0,0,1538,1549,10,4,0,0,1539,1550,3,232,116, + 0,1540,1541,3,252,126,0,1541,1543,5,87,0,0,1542,1544,3,92,46,0,1543,1542, + 1,0,0,0,1543,1544,1,0,0,0,1544,1545,1,0,0,0,1545,1547,5,88,0,0,1546,1548, + 3,204,102,0,1547,1546,1,0,0,0,1547,1548,1,0,0,0,1548,1550,1,0,0,0,1549, + 1539,1,0,0,0,1549,1540,1,0,0,0,1550,1552,1,0,0,0,1551,1538,1,0,0,0,1552, + 1555,1,0,0,0,1553,1551,1,0,0,0,1553,1554,1,0,0,0,1554,253,1,0,0,0,1555, + 1553,1,0,0,0,1556,1558,3,236,118,0,1557,1556,1,0,0,0,1558,1561,1,0,0, + 0,1559,1557,1,0,0,0,1559,1560,1,0,0,0,1560,1562,1,0,0,0,1561,1559,1,0, + 0,0,1562,1563,3,256,128,0,1563,255,1,0,0,0,1564,1565,6,128,-1,0,1565, + 1566,5,131,0,0,1566,1581,1,0,0,0,1567,1577,10,2,0,0,1568,1578,3,232,116, + 0,1569,1571,5,87,0,0,1570,1572,3,92,46,0,1571,1570,1,0,0,0,1571,1572, + 1,0,0,0,1572,1573,1,0,0,0,1573,1575,5,88,0,0,1574,1576,3,204,102,0,1575, + 1574,1,0,0,0,1575,1576,1,0,0,0,1576,1578,1,0,0,0,1577,1568,1,0,0,0,1577, + 1569,1,0,0,0,1578,1580,1,0,0,0,1579,1567,1,0,0,0,1580,1583,1,0,0,0,1581, + 1579,1,0,0,0,1581,1582,1,0,0,0,1582,257,1,0,0,0,1583,1581,1,0,0,0,1584, + 1589,3,260,130,0,1585,1587,5,122,0,0,1586,1585,1,0,0,0,1586,1587,1,0, + 0,0,1587,1588,1,0,0,0,1588,1590,5,131,0,0,1589,1586,1,0,0,0,1589,1590, + 1,0,0,0,1590,259,1,0,0,0,1591,1596,3,262,131,0,1592,1593,5,122,0,0,1593, + 1595,3,262,131,0,1594,1592,1,0,0,0,1595,1598,1,0,0,0,1596,1594,1,0,0, + 0,1596,1597,1,0,0,0,1597,261,1,0,0,0,1598,1596,1,0,0,0,1599,1601,3,204, + 102,0,1600,1599,1,0,0,0,1600,1601,1,0,0,0,1601,1602,1,0,0,0,1602,1607, + 3,138,69,0,1603,1608,3,226,113,0,1604,1606,3,248,124,0,1605,1604,1,0, + 0,0,1605,1606,1,0,0,0,1606,1608,1,0,0,0,1607,1603,1,0,0,0,1607,1605,1, + 0,0,0,1608,1611,1,0,0,0,1609,1610,5,101,0,0,1610,1612,3,272,136,0,1611, + 1609,1,0,0,0,1611,1612,1,0,0,0,1612,263,1,0,0,0,1613,1615,3,204,102,0, + 1614,1613,1,0,0,0,1614,1615,1,0,0,0,1615,1617,1,0,0,0,1616,1618,3,138, + 69,0,1617,1616,1,0,0,0,1617,1618,1,0,0,0,1618,1619,1,0,0,0,1619,1621, + 3,226,113,0,1620,1622,3,298,149,0,1621,1620,1,0,0,0,1621,1622,1,0,0,0, + 1622,1623,1,0,0,0,1623,1624,3,266,133,0,1624,265,1,0,0,0,1625,1627,3, + 322,161,0,1626,1625,1,0,0,0,1626,1627,1,0,0,0,1627,1628,1,0,0,0,1628, + 1634,3,100,50,0,1629,1634,3,360,180,0,1630,1631,5,101,0,0,1631,1632,7, + 19,0,0,1632,1634,5,128,0,0,1633,1626,1,0,0,0,1633,1629,1,0,0,0,1633,1630, + 1,0,0,0,1634,267,1,0,0,0,1635,1641,3,270,135,0,1636,1637,5,85,0,0,1637, + 1638,3,34,17,0,1638,1639,5,86,0,0,1639,1641,1,0,0,0,1640,1635,1,0,0,0, + 1640,1636,1,0,0,0,1641,269,1,0,0,0,1642,1643,5,101,0,0,1643,1646,3,272, + 136,0,1644,1646,3,276,138,0,1645,1642,1,0,0,0,1645,1644,1,0,0,0,1646, + 271,1,0,0,0,1647,1650,3,86,43,0,1648,1650,3,276,138,0,1649,1647,1,0,0, + 0,1649,1648,1,0,0,0,1650,273,1,0,0,0,1651,1653,3,272,136,0,1652,1654, + 5,131,0,0,1653,1652,1,0,0,0,1653,1654,1,0,0,0,1654,1662,1,0,0,0,1655, + 1656,5,122,0,0,1656,1658,3,272,136,0,1657,1659,5,131,0,0,1658,1657,1, + 0,0,0,1658,1659,1,0,0,0,1659,1661,1,0,0,0,1660,1655,1,0,0,0,1661,1664, + 1,0,0,0,1662,1660,1,0,0,0,1662,1663,1,0,0,0,1663,275,1,0,0,0,1664,1662, + 1,0,0,0,1665,1670,5,89,0,0,1666,1668,3,274,137,0,1667,1669,5,122,0,0, + 1668,1667,1,0,0,0,1668,1669,1,0,0,0,1669,1671,1,0,0,0,1670,1666,1,0,0, + 0,1670,1671,1,0,0,0,1671,1672,1,0,0,0,1672,1673,5,90,0,0,1673,277,1,0, + 0,0,1674,1677,5,132,0,0,1675,1677,3,342,171,0,1676,1674,1,0,0,0,1676, + 1675,1,0,0,0,1677,279,1,0,0,0,1678,1679,3,282,141,0,1679,1681,5,89,0, + 0,1680,1682,3,290,145,0,1681,1680,1,0,0,0,1681,1682,1,0,0,0,1682,1683, + 1,0,0,0,1683,1684,5,90,0,0,1684,281,1,0,0,0,1685,1687,3,288,144,0,1686, + 1688,3,204,102,0,1687,1686,1,0,0,0,1687,1688,1,0,0,0,1688,1693,1,0,0, + 0,1689,1691,3,284,142,0,1690,1692,3,286,143,0,1691,1690,1,0,0,0,1691, + 1692,1,0,0,0,1692,1694,1,0,0,0,1693,1689,1,0,0,0,1693,1694,1,0,0,0,1694, + 1696,1,0,0,0,1695,1697,3,304,152,0,1696,1695,1,0,0,0,1696,1697,1,0,0, + 0,1697,1709,1,0,0,0,1698,1700,5,77,0,0,1699,1701,3,204,102,0,1700,1699, + 1,0,0,0,1700,1701,1,0,0,0,1701,1706,1,0,0,0,1702,1704,3,284,142,0,1703, + 1705,3,286,143,0,1704,1703,1,0,0,0,1704,1705,1,0,0,0,1705,1707,1,0,0, + 0,1706,1702,1,0,0,0,1706,1707,1,0,0,0,1707,1709,1,0,0,0,1708,1685,1,0, + 0,0,1708,1698,1,0,0,0,1709,283,1,0,0,0,1710,1712,3,10,5,0,1711,1710,1, + 0,0,0,1711,1712,1,0,0,0,1712,1713,1,0,0,0,1713,1714,3,278,139,0,1714, + 285,1,0,0,0,1715,1716,5,38,0,0,1716,287,1,0,0,0,1717,1718,7,15,0,0,1718, + 289,1,0,0,0,1719,1724,3,292,146,0,1720,1721,3,314,157,0,1721,1722,5,126, + 0,0,1722,1724,1,0,0,0,1723,1719,1,0,0,0,1723,1720,1,0,0,0,1724,1725,1, + 0,0,0,1725,1723,1,0,0,0,1725,1726,1,0,0,0,1726,291,1,0,0,0,1727,1729, + 3,204,102,0,1728,1727,1,0,0,0,1728,1729,1,0,0,0,1729,1731,1,0,0,0,1730, + 1732,3,138,69,0,1731,1730,1,0,0,0,1731,1732,1,0,0,0,1732,1734,1,0,0,0, + 1733,1735,3,294,147,0,1734,1733,1,0,0,0,1734,1735,1,0,0,0,1735,1736,1, + 0,0,0,1736,1744,5,128,0,0,1737,1744,3,264,132,0,1738,1744,3,196,98,0, + 1739,1744,3,130,65,0,1740,1744,3,334,167,0,1741,1744,3,126,63,0,1742, + 1744,3,132,66,0,1743,1728,1,0,0,0,1743,1737,1,0,0,0,1743,1738,1,0,0,0, + 1743,1739,1,0,0,0,1743,1740,1,0,0,0,1743,1741,1,0,0,0,1743,1742,1,0,0, + 0,1744,293,1,0,0,0,1745,1750,3,296,148,0,1746,1747,5,122,0,0,1747,1749, + 3,296,148,0,1748,1746,1,0,0,0,1749,1752,1,0,0,0,1750,1748,1,0,0,0,1750, + 1751,1,0,0,0,1751,295,1,0,0,0,1752,1750,1,0,0,0,1753,1763,3,226,113,0, + 1754,1756,3,298,149,0,1755,1754,1,0,0,0,1755,1756,1,0,0,0,1756,1758,1, + 0,0,0,1757,1759,3,302,151,0,1758,1757,1,0,0,0,1758,1759,1,0,0,0,1759, + 1764,1,0,0,0,1760,1762,3,270,135,0,1761,1760,1,0,0,0,1761,1762,1,0,0, + 0,1762,1764,1,0,0,0,1763,1755,1,0,0,0,1763,1761,1,0,0,0,1764,1774,1,0, + 0,0,1765,1767,5,132,0,0,1766,1765,1,0,0,0,1766,1767,1,0,0,0,1767,1769, + 1,0,0,0,1768,1770,3,204,102,0,1769,1768,1,0,0,0,1769,1770,1,0,0,0,1770, + 1771,1,0,0,0,1771,1772,5,126,0,0,1772,1774,3,92,46,0,1773,1753,1,0,0, + 0,1773,1766,1,0,0,0,1774,297,1,0,0,0,1775,1777,3,300,150,0,1776,1775, + 1,0,0,0,1777,1778,1,0,0,0,1778,1776,1,0,0,0,1778,1779,1,0,0,0,1779,299, + 1,0,0,0,1780,1781,7,20,0,0,1781,301,1,0,0,0,1782,1783,5,101,0,0,1783, + 1784,5,134,0,0,1784,1785,6,151,-1,0,1785,303,1,0,0,0,1786,1787,5,126, + 0,0,1787,1788,3,306,153,0,1788,305,1,0,0,0,1789,1791,3,308,154,0,1790, + 1792,5,131,0,0,1791,1790,1,0,0,0,1791,1792,1,0,0,0,1792,1800,1,0,0,0, + 1793,1794,5,122,0,0,1794,1796,3,308,154,0,1795,1797,5,131,0,0,1796,1795, + 1,0,0,0,1796,1797,1,0,0,0,1797,1799,1,0,0,0,1798,1793,1,0,0,0,1799,1802, + 1,0,0,0,1800,1798,1,0,0,0,1800,1801,1,0,0,0,1801,307,1,0,0,0,1802,1800, + 1,0,0,0,1803,1805,3,204,102,0,1804,1803,1,0,0,0,1804,1805,1,0,0,0,1805, + 1818,1,0,0,0,1806,1819,3,312,156,0,1807,1809,5,80,0,0,1808,1810,3,314, + 157,0,1809,1808,1,0,0,0,1809,1810,1,0,0,0,1810,1811,1,0,0,0,1811,1819, + 3,312,156,0,1812,1814,3,314,157,0,1813,1815,5,80,0,0,1814,1813,1,0,0, + 0,1814,1815,1,0,0,0,1815,1816,1,0,0,0,1816,1817,3,312,156,0,1817,1819, + 1,0,0,0,1818,1806,1,0,0,0,1818,1807,1,0,0,0,1818,1812,1,0,0,0,1819,309, + 1,0,0,0,1820,1822,3,10,5,0,1821,1820,1,0,0,0,1821,1822,1,0,0,0,1822,1823, + 1,0,0,0,1823,1826,3,278,139,0,1824,1826,3,162,81,0,1825,1821,1,0,0,0, + 1825,1824,1,0,0,0,1826,311,1,0,0,0,1827,1828,3,310,155,0,1828,313,1,0, + 0,0,1829,1830,7,21,0,0,1830,315,1,0,0,0,1831,1832,5,52,0,0,1832,1833, + 3,318,159,0,1833,317,1,0,0,0,1834,1836,3,150,75,0,1835,1837,3,320,160, + 0,1836,1835,1,0,0,0,1836,1837,1,0,0,0,1837,319,1,0,0,0,1838,1840,3,236, + 118,0,1839,1841,3,320,160,0,1840,1839,1,0,0,0,1840,1841,1,0,0,0,1841, + 321,1,0,0,0,1842,1843,5,126,0,0,1843,1844,3,324,162,0,1844,323,1,0,0, + 0,1845,1847,3,326,163,0,1846,1848,5,131,0,0,1847,1846,1,0,0,0,1847,1848, + 1,0,0,0,1848,1856,1,0,0,0,1849,1850,5,122,0,0,1850,1852,3,326,163,0,1851, + 1853,5,131,0,0,1852,1851,1,0,0,0,1852,1853,1,0,0,0,1853,1855,1,0,0,0, + 1854,1849,1,0,0,0,1855,1858,1,0,0,0,1856,1854,1,0,0,0,1856,1857,1,0,0, + 0,1857,325,1,0,0,0,1858,1856,1,0,0,0,1859,1866,3,328,164,0,1860,1862, + 5,85,0,0,1861,1863,3,34,17,0,1862,1861,1,0,0,0,1862,1863,1,0,0,0,1863, + 1864,1,0,0,0,1864,1867,5,86,0,0,1865,1867,3,276,138,0,1866,1860,1,0,0, + 0,1866,1865,1,0,0,0,1867,327,1,0,0,0,1868,1871,3,310,155,0,1869,1871, + 5,132,0,0,1870,1868,1,0,0,0,1870,1869,1,0,0,0,1871,329,1,0,0,0,1872,1873, + 5,52,0,0,1873,1874,3,378,189,0,1874,331,1,0,0,0,1875,1879,5,52,0,0,1876, + 1877,5,4,0,0,1877,1880,5,132,0,0,1878,1880,5,140,0,0,1879,1876,1,0,0, + 0,1879,1878,1,0,0,0,1880,333,1,0,0,0,1881,1882,5,68,0,0,1882,1883,5,102, + 0,0,1883,1884,3,336,168,0,1884,1885,5,103,0,0,1885,1886,3,122,61,0,1886, + 335,1,0,0,0,1887,1892,3,338,169,0,1888,1889,5,122,0,0,1889,1891,3,338, + 169,0,1890,1888,1,0,0,0,1891,1894,1,0,0,0,1892,1890,1,0,0,0,1892,1893, + 1,0,0,0,1893,337,1,0,0,0,1894,1892,1,0,0,0,1895,1898,3,340,170,0,1896, + 1898,3,262,131,0,1897,1895,1,0,0,0,1897,1896,1,0,0,0,1898,339,1,0,0,0, + 1899,1900,5,68,0,0,1900,1901,5,102,0,0,1901,1902,3,336,168,0,1902,1903, + 5,103,0,0,1903,1905,1,0,0,0,1904,1899,1,0,0,0,1904,1905,1,0,0,0,1905, + 1906,1,0,0,0,1906,1909,5,21,0,0,1907,1909,5,76,0,0,1908,1904,1,0,0,0, + 1908,1907,1,0,0,0,1909,1921,1,0,0,0,1910,1912,5,131,0,0,1911,1910,1,0, + 0,0,1911,1912,1,0,0,0,1912,1914,1,0,0,0,1913,1915,5,132,0,0,1914,1913, + 1,0,0,0,1914,1915,1,0,0,0,1915,1922,1,0,0,0,1916,1918,5,132,0,0,1917, + 1916,1,0,0,0,1917,1918,1,0,0,0,1918,1919,1,0,0,0,1919,1920,5,101,0,0, + 1920,1922,3,246,123,0,1921,1911,1,0,0,0,1921,1917,1,0,0,0,1922,341,1, + 0,0,0,1923,1924,3,346,173,0,1924,1926,5,102,0,0,1925,1927,3,348,174,0, + 1926,1925,1,0,0,0,1926,1927,1,0,0,0,1927,1928,1,0,0,0,1928,1929,5,103, + 0,0,1929,343,1,0,0,0,1930,1942,3,342,171,0,1931,1934,3,330,165,0,1932, + 1934,3,332,166,0,1933,1931,1,0,0,0,1933,1932,1,0,0,0,1934,1935,1,0,0, + 0,1935,1937,5,102,0,0,1936,1938,3,348,174,0,1937,1936,1,0,0,0,1937,1938, + 1,0,0,0,1938,1939,1,0,0,0,1939,1940,5,103,0,0,1940,1942,1,0,0,0,1941, + 1930,1,0,0,0,1941,1933,1,0,0,0,1942,345,1,0,0,0,1943,1944,5,132,0,0,1944, + 347,1,0,0,0,1945,1947,3,350,175,0,1946,1948,5,131,0,0,1947,1946,1,0,0, + 0,1947,1948,1,0,0,0,1948,1956,1,0,0,0,1949,1950,5,122,0,0,1950,1952,3, + 350,175,0,1951,1953,5,131,0,0,1952,1951,1,0,0,0,1952,1953,1,0,0,0,1953, + 1955,1,0,0,0,1954,1949,1,0,0,0,1955,1958,1,0,0,0,1956,1954,1,0,0,0,1956, + 1957,1,0,0,0,1957,349,1,0,0,0,1958,1956,1,0,0,0,1959,1963,3,246,123,0, + 1960,1963,3,92,46,0,1961,1963,3,4,2,0,1962,1959,1,0,0,0,1962,1960,1,0, + 0,0,1962,1961,1,0,0,0,1963,351,1,0,0,0,1964,1965,5,76,0,0,1965,1971,3, + 10,5,0,1966,1972,5,132,0,0,1967,1969,5,68,0,0,1968,1967,1,0,0,0,1968, + 1969,1,0,0,0,1969,1970,1,0,0,0,1970,1972,3,342,171,0,1971,1966,1,0,0, + 0,1971,1968,1,0,0,0,1972,353,1,0,0,0,1973,1975,5,36,0,0,1974,1973,1,0, + 0,0,1974,1975,1,0,0,0,1975,1976,1,0,0,0,1976,1977,5,68,0,0,1977,1978, + 3,122,61,0,1978,355,1,0,0,0,1979,1980,5,68,0,0,1980,1981,5,102,0,0,1981, + 1982,5,103,0,0,1982,1983,3,122,61,0,1983,357,1,0,0,0,1984,1985,5,73,0, + 0,1985,1986,3,100,50,0,1986,1987,3,362,181,0,1987,359,1,0,0,0,1988,1990, + 5,73,0,0,1989,1991,3,322,161,0,1990,1989,1,0,0,0,1990,1991,1,0,0,0,1991, + 1992,1,0,0,0,1992,1993,3,100,50,0,1993,1994,3,362,181,0,1994,361,1,0, + 0,0,1995,1997,3,364,182,0,1996,1995,1,0,0,0,1997,1998,1,0,0,0,1998,1996, + 1,0,0,0,1998,1999,1,0,0,0,1999,363,1,0,0,0,2000,2001,5,17,0,0,2001,2002, + 5,85,0,0,2002,2003,3,366,183,0,2003,2004,5,86,0,0,2004,2005,3,100,50, + 0,2005,365,1,0,0,0,2006,2008,3,204,102,0,2007,2006,1,0,0,0,2007,2008, + 1,0,0,0,2008,2009,1,0,0,0,2009,2012,3,150,75,0,2010,2013,3,226,113,0, + 2011,2013,3,248,124,0,2012,2010,1,0,0,0,2012,2011,1,0,0,0,2012,2013,1, + 0,0,0,2013,2016,1,0,0,0,2014,2016,5,131,0,0,2015,2007,1,0,0,0,2015,2014, + 1,0,0,0,2016,367,1,0,0,0,2017,2019,5,71,0,0,2018,2020,3,86,43,0,2019, + 2018,1,0,0,0,2019,2020,1,0,0,0,2020,369,1,0,0,0,2021,2024,3,372,186,0, + 2022,2024,3,376,188,0,2023,2021,1,0,0,0,2023,2022,1,0,0,0,2024,371,1, + 0,0,0,2025,2026,5,71,0,0,2026,2028,5,85,0,0,2027,2029,3,374,187,0,2028, + 2027,1,0,0,0,2028,2029,1,0,0,0,2029,2030,1,0,0,0,2030,2031,5,86,0,0,2031, + 373,1,0,0,0,2032,2034,3,246,123,0,2033,2035,5,131,0,0,2034,2033,1,0,0, + 0,2034,2035,1,0,0,0,2035,2043,1,0,0,0,2036,2037,5,122,0,0,2037,2039,3, + 246,123,0,2038,2040,5,131,0,0,2039,2038,1,0,0,0,2039,2040,1,0,0,0,2040, + 2042,1,0,0,0,2041,2036,1,0,0,0,2042,2045,1,0,0,0,2043,2041,1,0,0,0,2043, + 2044,1,0,0,0,2044,375,1,0,0,0,2045,2043,1,0,0,0,2046,2047,5,50,0,0,2047, + 2048,5,85,0,0,2048,2049,3,92,46,0,2049,2050,5,86,0,0,2050,2053,1,0,0, + 0,2051,2053,5,50,0,0,2052,2046,1,0,0,0,2052,2051,1,0,0,0,2053,377,1,0, + 0,0,2054,2057,5,49,0,0,2055,2056,5,87,0,0,2056,2058,5,88,0,0,2057,2055, + 1,0,0,0,2057,2058,1,0,0,0,2058,2106,1,0,0,0,2059,2062,5,28,0,0,2060,2061, + 5,87,0,0,2061,2063,5,88,0,0,2062,2060,1,0,0,0,2062,2063,1,0,0,0,2063, + 2106,1,0,0,0,2064,2106,5,91,0,0,2065,2106,5,92,0,0,2066,2106,5,93,0,0, + 2067,2106,5,94,0,0,2068,2106,5,95,0,0,2069,2106,5,96,0,0,2070,2106,5, + 97,0,0,2071,2106,5,98,0,0,2072,2106,5,99,0,0,2073,2106,5,100,0,0,2074, + 2106,5,101,0,0,2075,2106,5,103,0,0,2076,2106,5,102,0,0,2077,2106,5,117, + 0,0,2078,2106,5,104,0,0,2079,2106,5,105,0,0,2080,2106,5,106,0,0,2081, + 2106,5,108,0,0,2082,2106,5,109,0,0,2083,2106,5,110,0,0,2084,2106,5,111, + 0,0,2085,2086,5,102,0,0,2086,2106,5,102,0,0,2087,2088,5,103,0,0,2088, + 2106,5,103,0,0,2089,2106,5,113,0,0,2090,2106,5,112,0,0,2091,2106,5,114, + 0,0,2092,2106,5,115,0,0,2093,2106,5,116,0,0,2094,2106,5,118,0,0,2095, + 2106,5,119,0,0,2096,2106,5,120,0,0,2097,2106,5,121,0,0,2098,2106,5,122, + 0,0,2099,2106,5,123,0,0,2100,2106,5,124,0,0,2101,2102,5,85,0,0,2102,2106, + 5,86,0,0,2103,2104,5,87,0,0,2104,2106,5,88,0,0,2105,2054,1,0,0,0,2105, + 2059,1,0,0,0,2105,2064,1,0,0,0,2105,2065,1,0,0,0,2105,2066,1,0,0,0,2105, + 2067,1,0,0,0,2105,2068,1,0,0,0,2105,2069,1,0,0,0,2105,2070,1,0,0,0,2105, + 2071,1,0,0,0,2105,2072,1,0,0,0,2105,2073,1,0,0,0,2105,2074,1,0,0,0,2105, + 2075,1,0,0,0,2105,2076,1,0,0,0,2105,2077,1,0,0,0,2105,2078,1,0,0,0,2105, + 2079,1,0,0,0,2105,2080,1,0,0,0,2105,2081,1,0,0,0,2105,2082,1,0,0,0,2105, + 2083,1,0,0,0,2105,2084,1,0,0,0,2105,2085,1,0,0,0,2105,2087,1,0,0,0,2105, + 2089,1,0,0,0,2105,2090,1,0,0,0,2105,2091,1,0,0,0,2105,2092,1,0,0,0,2105, + 2093,1,0,0,0,2105,2094,1,0,0,0,2105,2095,1,0,0,0,2105,2096,1,0,0,0,2105, + 2097,1,0,0,0,2105,2098,1,0,0,0,2105,2099,1,0,0,0,2105,2100,1,0,0,0,2105, + 2101,1,0,0,0,2105,2103,1,0,0,0,2106,379,1,0,0,0,2107,2108,7,22,0,0,2108, + 381,1,0,0,0,306,383,390,399,403,412,415,419,427,434,437,442,447,453,461, + 463,472,476,480,483,487,490,497,501,504,507,510,516,520,524,538,542,548, + 555,561,565,569,571,579,584,597,604,616,626,631,635,642,645,653,657,660, + 667,674,678,683,687,690,695,710,717,725,733,742,749,756,764,772,780,788, + 796,804,813,821,830,838,846,848,851,857,863,869,876,885,893,897,904,906, + 926,930,936,941,945,948,955,962,966,975,986,996,1001,1008,1011,1016,1021, + 1042,1047,1050,1061,1067,1072,1075,1080,1083,1090,1099,1104,1107,1111, + 1115,1119,1124,1129,1135,1141,1147,1153,1159,1162,1168,1172,1176,1179, + 1187,1189,1195,1198,1201,1204,1208,1212,1218,1228,1234,1240,1245,1250, + 1254,1267,1273,1277,1283,1288,1303,1307,1312,1317,1322,1328,1331,1340, + 1344,1349,1353,1359,1366,1383,1385,1392,1397,1404,1408,1412,1420,1426, + 1432,1436,1438,1442,1447,1451,1454,1457,1460,1465,1469,1472,1476,1479, + 1481,1486,1493,1499,1503,1509,1515,1518,1520,1526,1530,1536,1543,1547, + 1549,1553,1559,1571,1575,1577,1581,1586,1589,1596,1600,1605,1607,1611, + 1614,1617,1621,1626,1633,1640,1645,1649,1653,1658,1662,1668,1670,1676, + 1681,1687,1691,1693,1696,1700,1704,1706,1708,1711,1723,1725,1728,1731, + 1734,1743,1750,1755,1758,1761,1763,1766,1769,1773,1778,1791,1796,1800, + 1804,1809,1814,1818,1821,1825,1836,1840,1847,1852,1856,1862,1866,1870, + 1879,1892,1897,1904,1908,1911,1914,1917,1921,1926,1933,1937,1941,1947, + 1952,1956,1962,1968,1971,1974,1990,1998,2007,2012,2015,2019,2023,2028, + 2034,2039,2043,2052,2057,2062,2105 + }; + staticData->serializedATN = antlr4::atn::SerializedATNView(serializedATNSegment, sizeof(serializedATNSegment) / sizeof(serializedATNSegment[0])); + + antlr4::atn::ATNDeserializer deserializer; + staticData->atn = deserializer.deserialize(staticData->serializedATN); + + const size_t count = staticData->atn->getNumberOfDecisions(); + staticData->decisionToDFA.reserve(count); + for (size_t i = 0; i < count; i++) { + staticData->decisionToDFA.emplace_back(staticData->atn->getDecisionState(i), i); + } + cpp14parserParserStaticData = staticData.release(); +} + +} + +CPP14Parser::CPP14Parser(TokenStream *input) : CPP14Parser(input, antlr4::atn::ParserATNSimulatorOptions()) {} + +CPP14Parser::CPP14Parser(TokenStream *input, const antlr4::atn::ParserATNSimulatorOptions &options) : Parser(input) { + CPP14Parser::initialize(); + _interpreter = new atn::ParserATNSimulator(this, *cpp14parserParserStaticData->atn, cpp14parserParserStaticData->decisionToDFA, cpp14parserParserStaticData->sharedContextCache, options); +} + +CPP14Parser::~CPP14Parser() { + delete _interpreter; +} + +const atn::ATN& CPP14Parser::getATN() const { + return *cpp14parserParserStaticData->atn; +} + +std::string CPP14Parser::getGrammarFileName() const { + return "CPP14Parser.g4"; +} + +const std::vector& CPP14Parser::getRuleNames() const { + return cpp14parserParserStaticData->ruleNames; +} + +const dfa::Vocabulary& CPP14Parser::getVocabulary() const { + return cpp14parserParserStaticData->vocabulary; +} + +antlr4::atn::SerializedATNView CPP14Parser::getSerializedATN() const { + return cpp14parserParserStaticData->serializedATN; +} + + +//----------------- TranslationUnitContext ------------------------------------------------------------------ + +CPP14Parser::TranslationUnitContext::TranslationUnitContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::TranslationUnitContext::EOF() { + return getToken(CPP14Parser::EOF, 0); +} + +CPP14Parser::DeclarationseqContext* CPP14Parser::TranslationUnitContext::declarationseq() { + return getRuleContext(0); +} + + +size_t CPP14Parser::TranslationUnitContext::getRuleIndex() const { + return CPP14Parser::RuleTranslationUnit; +} + + +CPP14Parser::TranslationUnitContext* CPP14Parser::translationUnit() { + TranslationUnitContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 0, CPP14Parser::RuleTranslationUnit); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(383); + _errHandler->sync(this); + + _la = _input->LA(1); + if (((((_la - 10) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 10)) & 1543754443169808157) != 0) || ((((_la - 74) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 74)) & 459384754220313597) != 0)) { + setState(382); + declarationseq(); + } + setState(385); + match(CPP14Parser::EOF); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- PrimaryExpressionContext ------------------------------------------------------------------ + +CPP14Parser::PrimaryExpressionContext::PrimaryExpressionContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector CPP14Parser::PrimaryExpressionContext::literal() { + return getRuleContexts(); +} + +CPP14Parser::LiteralContext* CPP14Parser::PrimaryExpressionContext::literal(size_t i) { + return getRuleContext(i); +} + +tree::TerminalNode* CPP14Parser::PrimaryExpressionContext::This() { + return getToken(CPP14Parser::This, 0); +} + +tree::TerminalNode* CPP14Parser::PrimaryExpressionContext::LeftParen() { + return getToken(CPP14Parser::LeftParen, 0); +} + +CPP14Parser::ExpressionContext* CPP14Parser::PrimaryExpressionContext::expression() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::PrimaryExpressionContext::RightParen() { + return getToken(CPP14Parser::RightParen, 0); +} + +CPP14Parser::IdExpressionContext* CPP14Parser::PrimaryExpressionContext::idExpression() { + return getRuleContext(0); +} + +CPP14Parser::LambdaExpressionContext* CPP14Parser::PrimaryExpressionContext::lambdaExpression() { + return getRuleContext(0); +} + + +size_t CPP14Parser::PrimaryExpressionContext::getRuleIndex() const { + return CPP14Parser::RulePrimaryExpression; +} + + +CPP14Parser::PrimaryExpressionContext* CPP14Parser::primaryExpression() { + PrimaryExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 2, CPP14Parser::RulePrimaryExpression); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + size_t alt; + setState(399); + _errHandler->sync(this); + switch (_input->LA(1)) { + case CPP14Parser::IntegerLiteral: + case CPP14Parser::CharacterLiteral: + case CPP14Parser::FloatingLiteral: + case CPP14Parser::StringLiteral: + case CPP14Parser::BooleanLiteral: + case CPP14Parser::PointerLiteral: + case CPP14Parser::UserDefinedLiteral: { + enterOuterAlt(_localctx, 1); + setState(388); + _errHandler->sync(this); + alt = 1; + do { + switch (alt) { + case 1: { + setState(387); + literal(); + break; + } + + default: + throw NoViableAltException(this); + } + setState(390); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 1, _ctx); + } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER); + break; + } + + case CPP14Parser::This: { + enterOuterAlt(_localctx, 2); + setState(392); + match(CPP14Parser::This); + break; + } + + case CPP14Parser::LeftParen: { + enterOuterAlt(_localctx, 3); + setState(393); + match(CPP14Parser::LeftParen); + setState(394); + expression(); + setState(395); + match(CPP14Parser::RightParen); + break; + } + + case CPP14Parser::Decltype: + case CPP14Parser::Operator: + case CPP14Parser::Tilde: + case CPP14Parser::Doublecolon: + case CPP14Parser::Identifier: { + enterOuterAlt(_localctx, 4); + setState(397); + idExpression(); + break; + } + + case CPP14Parser::LeftBracket: { + enterOuterAlt(_localctx, 5); + setState(398); + lambdaExpression(); + break; + } + + default: + throw NoViableAltException(this); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- IdExpressionContext ------------------------------------------------------------------ + +CPP14Parser::IdExpressionContext::IdExpressionContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::UnqualifiedIdContext* CPP14Parser::IdExpressionContext::unqualifiedId() { + return getRuleContext(0); +} + +CPP14Parser::QualifiedIdContext* CPP14Parser::IdExpressionContext::qualifiedId() { + return getRuleContext(0); +} + + +size_t CPP14Parser::IdExpressionContext::getRuleIndex() const { + return CPP14Parser::RuleIdExpression; +} + + +CPP14Parser::IdExpressionContext* CPP14Parser::idExpression() { + IdExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 4, CPP14Parser::RuleIdExpression); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(403); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 3, _ctx)) { + case 1: { + enterOuterAlt(_localctx, 1); + setState(401); + unqualifiedId(); + break; + } + + case 2: { + enterOuterAlt(_localctx, 2); + setState(402); + qualifiedId(); + break; + } + + default: + break; + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- UnqualifiedIdContext ------------------------------------------------------------------ + +CPP14Parser::UnqualifiedIdContext::UnqualifiedIdContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::UnqualifiedIdContext::Identifier() { + return getToken(CPP14Parser::Identifier, 0); +} + +CPP14Parser::OperatorFunctionIdContext* CPP14Parser::UnqualifiedIdContext::operatorFunctionId() { + return getRuleContext(0); +} + +CPP14Parser::ConversionFunctionIdContext* CPP14Parser::UnqualifiedIdContext::conversionFunctionId() { + return getRuleContext(0); +} + +CPP14Parser::LiteralOperatorIdContext* CPP14Parser::UnqualifiedIdContext::literalOperatorId() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::UnqualifiedIdContext::Tilde() { + return getToken(CPP14Parser::Tilde, 0); +} + +CPP14Parser::ClassNameContext* CPP14Parser::UnqualifiedIdContext::className() { + return getRuleContext(0); +} + +CPP14Parser::DecltypeSpecifierContext* CPP14Parser::UnqualifiedIdContext::decltypeSpecifier() { + return getRuleContext(0); +} + +CPP14Parser::TemplateIdContext* CPP14Parser::UnqualifiedIdContext::templateId() { + return getRuleContext(0); +} + + +size_t CPP14Parser::UnqualifiedIdContext::getRuleIndex() const { + return CPP14Parser::RuleUnqualifiedId; +} + + +CPP14Parser::UnqualifiedIdContext* CPP14Parser::unqualifiedId() { + UnqualifiedIdContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 6, CPP14Parser::RuleUnqualifiedId); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(415); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 5, _ctx)) { + case 1: { + enterOuterAlt(_localctx, 1); + setState(405); + match(CPP14Parser::Identifier); + break; + } + + case 2: { + enterOuterAlt(_localctx, 2); + setState(406); + operatorFunctionId(); + break; + } + + case 3: { + enterOuterAlt(_localctx, 3); + setState(407); + conversionFunctionId(); + break; + } + + case 4: { + enterOuterAlt(_localctx, 4); + setState(408); + literalOperatorId(); + break; + } + + case 5: { + enterOuterAlt(_localctx, 5); + setState(409); + match(CPP14Parser::Tilde); + setState(412); + _errHandler->sync(this); + switch (_input->LA(1)) { + case CPP14Parser::Identifier: { + setState(410); + className(); + break; + } + + case CPP14Parser::Decltype: { + setState(411); + decltypeSpecifier(); + break; + } + + default: + throw NoViableAltException(this); + } + break; + } + + case 6: { + enterOuterAlt(_localctx, 6); + setState(414); + templateId(); + break; + } + + default: + break; + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- QualifiedIdContext ------------------------------------------------------------------ + +CPP14Parser::QualifiedIdContext::QualifiedIdContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::NestedNameSpecifierContext* CPP14Parser::QualifiedIdContext::nestedNameSpecifier() { + return getRuleContext(0); +} + +CPP14Parser::UnqualifiedIdContext* CPP14Parser::QualifiedIdContext::unqualifiedId() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::QualifiedIdContext::Template() { + return getToken(CPP14Parser::Template, 0); +} + + +size_t CPP14Parser::QualifiedIdContext::getRuleIndex() const { + return CPP14Parser::RuleQualifiedId; +} + + +CPP14Parser::QualifiedIdContext* CPP14Parser::qualifiedId() { + QualifiedIdContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 8, CPP14Parser::RuleQualifiedId); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(417); + nestedNameSpecifier(0); + setState(419); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Template) { + setState(418); + match(CPP14Parser::Template); + } + setState(421); + unqualifiedId(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- NestedNameSpecifierContext ------------------------------------------------------------------ + +CPP14Parser::NestedNameSpecifierContext::NestedNameSpecifierContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::NestedNameSpecifierContext::Doublecolon() { + return getToken(CPP14Parser::Doublecolon, 0); +} + +CPP14Parser::TheTypeNameContext* CPP14Parser::NestedNameSpecifierContext::theTypeName() { + return getRuleContext(0); +} + +CPP14Parser::NamespaceNameContext* CPP14Parser::NestedNameSpecifierContext::namespaceName() { + return getRuleContext(0); +} + +CPP14Parser::DecltypeSpecifierContext* CPP14Parser::NestedNameSpecifierContext::decltypeSpecifier() { + return getRuleContext(0); +} + +CPP14Parser::NestedNameSpecifierContext* CPP14Parser::NestedNameSpecifierContext::nestedNameSpecifier() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::NestedNameSpecifierContext::Identifier() { + return getToken(CPP14Parser::Identifier, 0); +} + +CPP14Parser::SimpleTemplateIdContext* CPP14Parser::NestedNameSpecifierContext::simpleTemplateId() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::NestedNameSpecifierContext::Template() { + return getToken(CPP14Parser::Template, 0); +} + + +size_t CPP14Parser::NestedNameSpecifierContext::getRuleIndex() const { + return CPP14Parser::RuleNestedNameSpecifier; +} + + + +CPP14Parser::NestedNameSpecifierContext* CPP14Parser::nestedNameSpecifier() { + return nestedNameSpecifier(0); +} + +CPP14Parser::NestedNameSpecifierContext* CPP14Parser::nestedNameSpecifier(int precedence) { + ParserRuleContext *parentContext = _ctx; + size_t parentState = getState(); + CPP14Parser::NestedNameSpecifierContext *_localctx = _tracker.createInstance(_ctx, parentState); + CPP14Parser::NestedNameSpecifierContext *previousContext = _localctx; + (void)previousContext; // Silence compiler, in case the context is not used by generated code. + size_t startState = 10; + enterRecursionRule(_localctx, 10, CPP14Parser::RuleNestedNameSpecifier, precedence); + + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + unrollRecursionContexts(parentContext); + }); + try { + size_t alt; + enterOuterAlt(_localctx, 1); + setState(427); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 7, _ctx)) { + case 1: { + setState(424); + theTypeName(); + break; + } + + case 2: { + setState(425); + namespaceName(); + break; + } + + case 3: { + setState(426); + decltypeSpecifier(); + break; + } + + default: + break; + } + setState(429); + match(CPP14Parser::Doublecolon); + _ctx->stop = _input->LT(-1); + setState(442); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 10, _ctx); + while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { + if (alt == 1) { + if (!_parseListeners.empty()) + triggerExitRuleEvent(); + previousContext = _localctx; + _localctx = _tracker.createInstance(parentContext, parentState); + pushNewRecursionContext(_localctx, startState, RuleNestedNameSpecifier); + setState(431); + + if (!(precpred(_ctx, 1))) throw FailedPredicateException(this, "precpred(_ctx, 1)"); + setState(437); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 9, _ctx)) { + case 1: { + setState(432); + match(CPP14Parser::Identifier); + break; + } + + case 2: { + setState(434); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Template) { + setState(433); + match(CPP14Parser::Template); + } + setState(436); + simpleTemplateId(); + break; + } + + default: + break; + } + setState(439); + match(CPP14Parser::Doublecolon); + } + setState(444); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 10, _ctx); + } + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + return _localctx; +} + +//----------------- LambdaExpressionContext ------------------------------------------------------------------ + +CPP14Parser::LambdaExpressionContext::LambdaExpressionContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::LambdaIntroducerContext* CPP14Parser::LambdaExpressionContext::lambdaIntroducer() { + return getRuleContext(0); +} + +CPP14Parser::CompoundStatementContext* CPP14Parser::LambdaExpressionContext::compoundStatement() { + return getRuleContext(0); +} + +CPP14Parser::LambdaDeclaratorContext* CPP14Parser::LambdaExpressionContext::lambdaDeclarator() { + return getRuleContext(0); +} + + +size_t CPP14Parser::LambdaExpressionContext::getRuleIndex() const { + return CPP14Parser::RuleLambdaExpression; +} + + +CPP14Parser::LambdaExpressionContext* CPP14Parser::lambdaExpression() { + LambdaExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 12, CPP14Parser::RuleLambdaExpression); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(445); + lambdaIntroducer(); + setState(447); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::LeftParen) { + setState(446); + lambdaDeclarator(); + } + setState(449); + compoundStatement(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- LambdaIntroducerContext ------------------------------------------------------------------ + +CPP14Parser::LambdaIntroducerContext::LambdaIntroducerContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::LambdaIntroducerContext::LeftBracket() { + return getToken(CPP14Parser::LeftBracket, 0); +} + +tree::TerminalNode* CPP14Parser::LambdaIntroducerContext::RightBracket() { + return getToken(CPP14Parser::RightBracket, 0); +} + +CPP14Parser::LambdaCaptureContext* CPP14Parser::LambdaIntroducerContext::lambdaCapture() { + return getRuleContext(0); +} + + +size_t CPP14Parser::LambdaIntroducerContext::getRuleIndex() const { + return CPP14Parser::RuleLambdaIntroducer; +} + + +CPP14Parser::LambdaIntroducerContext* CPP14Parser::lambdaIntroducer() { + LambdaIntroducerContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 14, CPP14Parser::RuleLambdaIntroducer); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(451); + match(CPP14Parser::LeftBracket); + setState(453); + _errHandler->sync(this); + + _la = _input->LA(1); + if (((((_la - 69) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 69)) & -9223372032291373055) != 0)) { + setState(452); + lambdaCapture(); + } + setState(455); + match(CPP14Parser::RightBracket); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- LambdaCaptureContext ------------------------------------------------------------------ + +CPP14Parser::LambdaCaptureContext::LambdaCaptureContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::CaptureListContext* CPP14Parser::LambdaCaptureContext::captureList() { + return getRuleContext(0); +} + +CPP14Parser::CaptureDefaultContext* CPP14Parser::LambdaCaptureContext::captureDefault() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::LambdaCaptureContext::Comma() { + return getToken(CPP14Parser::Comma, 0); +} + + +size_t CPP14Parser::LambdaCaptureContext::getRuleIndex() const { + return CPP14Parser::RuleLambdaCapture; +} + + +CPP14Parser::LambdaCaptureContext* CPP14Parser::lambdaCapture() { + LambdaCaptureContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 16, CPP14Parser::RuleLambdaCapture); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(463); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 14, _ctx)) { + case 1: { + enterOuterAlt(_localctx, 1); + setState(457); + captureList(); + break; + } + + case 2: { + enterOuterAlt(_localctx, 2); + setState(458); + captureDefault(); + setState(461); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Comma) { + setState(459); + match(CPP14Parser::Comma); + setState(460); + captureList(); + } + break; + } + + default: + break; + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- CaptureDefaultContext ------------------------------------------------------------------ + +CPP14Parser::CaptureDefaultContext::CaptureDefaultContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::CaptureDefaultContext::And() { + return getToken(CPP14Parser::And, 0); +} + +tree::TerminalNode* CPP14Parser::CaptureDefaultContext::Assign() { + return getToken(CPP14Parser::Assign, 0); +} + + +size_t CPP14Parser::CaptureDefaultContext::getRuleIndex() const { + return CPP14Parser::RuleCaptureDefault; +} + + +CPP14Parser::CaptureDefaultContext* CPP14Parser::captureDefault() { + CaptureDefaultContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 18, CPP14Parser::RuleCaptureDefault); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(465); + _la = _input->LA(1); + if (!(_la == CPP14Parser::And + + || _la == CPP14Parser::Assign)) { + _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; +} + +//----------------- CaptureListContext ------------------------------------------------------------------ + +CPP14Parser::CaptureListContext::CaptureListContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector CPP14Parser::CaptureListContext::capture() { + return getRuleContexts(); +} + +CPP14Parser::CaptureContext* CPP14Parser::CaptureListContext::capture(size_t i) { + return getRuleContext(i); +} + +std::vector CPP14Parser::CaptureListContext::Comma() { + return getTokens(CPP14Parser::Comma); +} + +tree::TerminalNode* CPP14Parser::CaptureListContext::Comma(size_t i) { + return getToken(CPP14Parser::Comma, i); +} + +tree::TerminalNode* CPP14Parser::CaptureListContext::Ellipsis() { + return getToken(CPP14Parser::Ellipsis, 0); +} + + +size_t CPP14Parser::CaptureListContext::getRuleIndex() const { + return CPP14Parser::RuleCaptureList; +} + + +CPP14Parser::CaptureListContext* CPP14Parser::captureList() { + CaptureListContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 20, CPP14Parser::RuleCaptureList); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(467); + capture(); + setState(472); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == CPP14Parser::Comma) { + setState(468); + match(CPP14Parser::Comma); + setState(469); + capture(); + setState(474); + _errHandler->sync(this); + _la = _input->LA(1); + } + setState(476); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Ellipsis) { + setState(475); + match(CPP14Parser::Ellipsis); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- CaptureContext ------------------------------------------------------------------ + +CPP14Parser::CaptureContext::CaptureContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::SimpleCaptureContext* CPP14Parser::CaptureContext::simpleCapture() { + return getRuleContext(0); +} + +CPP14Parser::InitcaptureContext* CPP14Parser::CaptureContext::initcapture() { + return getRuleContext(0); +} + + +size_t CPP14Parser::CaptureContext::getRuleIndex() const { + return CPP14Parser::RuleCapture; +} + + +CPP14Parser::CaptureContext* CPP14Parser::capture() { + CaptureContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 22, CPP14Parser::RuleCapture); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(480); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 17, _ctx)) { + case 1: { + enterOuterAlt(_localctx, 1); + setState(478); + simpleCapture(); + break; + } + + case 2: { + enterOuterAlt(_localctx, 2); + setState(479); + initcapture(); + break; + } + + default: + break; + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- SimpleCaptureContext ------------------------------------------------------------------ + +CPP14Parser::SimpleCaptureContext::SimpleCaptureContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::SimpleCaptureContext::Identifier() { + return getToken(CPP14Parser::Identifier, 0); +} + +tree::TerminalNode* CPP14Parser::SimpleCaptureContext::And() { + return getToken(CPP14Parser::And, 0); +} + +tree::TerminalNode* CPP14Parser::SimpleCaptureContext::This() { + return getToken(CPP14Parser::This, 0); +} + + +size_t CPP14Parser::SimpleCaptureContext::getRuleIndex() const { + return CPP14Parser::RuleSimpleCapture; +} + + +CPP14Parser::SimpleCaptureContext* CPP14Parser::simpleCapture() { + SimpleCaptureContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 24, CPP14Parser::RuleSimpleCapture); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(487); + _errHandler->sync(this); + switch (_input->LA(1)) { + case CPP14Parser::And: + case CPP14Parser::Identifier: { + enterOuterAlt(_localctx, 1); + setState(483); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::And) { + setState(482); + match(CPP14Parser::And); + } + setState(485); + match(CPP14Parser::Identifier); + break; + } + + case CPP14Parser::This: { + enterOuterAlt(_localctx, 2); + setState(486); + match(CPP14Parser::This); + break; + } + + default: + throw NoViableAltException(this); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- InitcaptureContext ------------------------------------------------------------------ + +CPP14Parser::InitcaptureContext::InitcaptureContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::InitcaptureContext::Identifier() { + return getToken(CPP14Parser::Identifier, 0); +} + +CPP14Parser::InitializerContext* CPP14Parser::InitcaptureContext::initializer() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::InitcaptureContext::And() { + return getToken(CPP14Parser::And, 0); +} + + +size_t CPP14Parser::InitcaptureContext::getRuleIndex() const { + return CPP14Parser::RuleInitcapture; +} + + +CPP14Parser::InitcaptureContext* CPP14Parser::initcapture() { + InitcaptureContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 26, CPP14Parser::RuleInitcapture); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(490); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::And) { + setState(489); + match(CPP14Parser::And); + } + setState(492); + match(CPP14Parser::Identifier); + setState(493); + initializer(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- LambdaDeclaratorContext ------------------------------------------------------------------ + +CPP14Parser::LambdaDeclaratorContext::LambdaDeclaratorContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::LambdaDeclaratorContext::LeftParen() { + return getToken(CPP14Parser::LeftParen, 0); +} + +tree::TerminalNode* CPP14Parser::LambdaDeclaratorContext::RightParen() { + return getToken(CPP14Parser::RightParen, 0); +} + +CPP14Parser::ParameterDeclarationClauseContext* CPP14Parser::LambdaDeclaratorContext::parameterDeclarationClause() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::LambdaDeclaratorContext::Mutable() { + return getToken(CPP14Parser::Mutable, 0); +} + +CPP14Parser::ExceptionSpecificationContext* CPP14Parser::LambdaDeclaratorContext::exceptionSpecification() { + return getRuleContext(0); +} + +CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::LambdaDeclaratorContext::attributeSpecifierSeq() { + return getRuleContext(0); +} + +CPP14Parser::TrailingReturnTypeContext* CPP14Parser::LambdaDeclaratorContext::trailingReturnType() { + return getRuleContext(0); +} + + +size_t CPP14Parser::LambdaDeclaratorContext::getRuleIndex() const { + return CPP14Parser::RuleLambdaDeclarator; +} + + +CPP14Parser::LambdaDeclaratorContext* CPP14Parser::lambdaDeclarator() { + LambdaDeclaratorContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 28, CPP14Parser::RuleLambdaDeclarator); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(495); + match(CPP14Parser::LeftParen); + setState(497); + _errHandler->sync(this); + + _la = _input->LA(1); + if (((((_la - 10) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 10)) & 1237504995584196377) != 0) || ((((_la - 74) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 74)) & 297237575406461917) != 0)) { + setState(496); + parameterDeclarationClause(); + } + setState(499); + match(CPP14Parser::RightParen); + setState(501); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Mutable) { + setState(500); + match(CPP14Parser::Mutable); + } + setState(504); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Noexcept + + || _la == CPP14Parser::Throw) { + setState(503); + exceptionSpecification(); + } + setState(507); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Alignas || _la == CPP14Parser::LeftBracket) { + setState(506); + attributeSpecifierSeq(); + } + setState(510); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Arrow) { + setState(509); + trailingReturnType(); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- PostfixExpressionContext ------------------------------------------------------------------ + +CPP14Parser::PostfixExpressionContext::PostfixExpressionContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::PrimaryExpressionContext* CPP14Parser::PostfixExpressionContext::primaryExpression() { + return getRuleContext(0); +} + +CPP14Parser::SimpleTypeSpecifierContext* CPP14Parser::PostfixExpressionContext::simpleTypeSpecifier() { + return getRuleContext(0); +} + +CPP14Parser::TypeNameSpecifierContext* CPP14Parser::PostfixExpressionContext::typeNameSpecifier() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::PostfixExpressionContext::LeftParen() { + return getToken(CPP14Parser::LeftParen, 0); +} + +tree::TerminalNode* CPP14Parser::PostfixExpressionContext::RightParen() { + return getToken(CPP14Parser::RightParen, 0); +} + +CPP14Parser::BracedInitListContext* CPP14Parser::PostfixExpressionContext::bracedInitList() { + return getRuleContext(0); +} + +CPP14Parser::ExpressionListContext* CPP14Parser::PostfixExpressionContext::expressionList() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::PostfixExpressionContext::Less() { + return getToken(CPP14Parser::Less, 0); +} + +CPP14Parser::TheTypeIdContext* CPP14Parser::PostfixExpressionContext::theTypeId() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::PostfixExpressionContext::Greater() { + return getToken(CPP14Parser::Greater, 0); +} + +CPP14Parser::ExpressionContext* CPP14Parser::PostfixExpressionContext::expression() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::PostfixExpressionContext::Dynamic_cast() { + return getToken(CPP14Parser::Dynamic_cast, 0); +} + +tree::TerminalNode* CPP14Parser::PostfixExpressionContext::Static_cast() { + return getToken(CPP14Parser::Static_cast, 0); +} + +tree::TerminalNode* CPP14Parser::PostfixExpressionContext::Reinterpret_cast() { + return getToken(CPP14Parser::Reinterpret_cast, 0); +} + +tree::TerminalNode* CPP14Parser::PostfixExpressionContext::Const_cast() { + return getToken(CPP14Parser::Const_cast, 0); +} + +CPP14Parser::TypeIdOfTheTypeIdContext* CPP14Parser::PostfixExpressionContext::typeIdOfTheTypeId() { + return getRuleContext(0); +} + +CPP14Parser::PostfixExpressionContext* CPP14Parser::PostfixExpressionContext::postfixExpression() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::PostfixExpressionContext::LeftBracket() { + return getToken(CPP14Parser::LeftBracket, 0); +} + +tree::TerminalNode* CPP14Parser::PostfixExpressionContext::RightBracket() { + return getToken(CPP14Parser::RightBracket, 0); +} + +tree::TerminalNode* CPP14Parser::PostfixExpressionContext::Dot() { + return getToken(CPP14Parser::Dot, 0); +} + +tree::TerminalNode* CPP14Parser::PostfixExpressionContext::Arrow() { + return getToken(CPP14Parser::Arrow, 0); +} + +CPP14Parser::IdExpressionContext* CPP14Parser::PostfixExpressionContext::idExpression() { + return getRuleContext(0); +} + +CPP14Parser::PseudoDestructorNameContext* CPP14Parser::PostfixExpressionContext::pseudoDestructorName() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::PostfixExpressionContext::Template() { + return getToken(CPP14Parser::Template, 0); +} + +tree::TerminalNode* CPP14Parser::PostfixExpressionContext::PlusPlus() { + return getToken(CPP14Parser::PlusPlus, 0); +} + +tree::TerminalNode* CPP14Parser::PostfixExpressionContext::MinusMinus() { + return getToken(CPP14Parser::MinusMinus, 0); +} + + +size_t CPP14Parser::PostfixExpressionContext::getRuleIndex() const { + return CPP14Parser::RulePostfixExpression; +} + + + +CPP14Parser::PostfixExpressionContext* CPP14Parser::postfixExpression() { + return postfixExpression(0); +} + +CPP14Parser::PostfixExpressionContext* CPP14Parser::postfixExpression(int precedence) { + ParserRuleContext *parentContext = _ctx; + size_t parentState = getState(); + CPP14Parser::PostfixExpressionContext *_localctx = _tracker.createInstance(_ctx, parentState); + CPP14Parser::PostfixExpressionContext *previousContext = _localctx; + (void)previousContext; // Silence compiler, in case the context is not used by generated code. + size_t startState = 30; + enterRecursionRule(_localctx, 30, CPP14Parser::RulePostfixExpression, precedence); + + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + unrollRecursionContexts(parentContext); + }); + try { + size_t alt; + enterOuterAlt(_localctx, 1); + setState(542); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 30, _ctx)) { + case 1: { + setState(513); + primaryExpression(); + break; + } + + case 2: { + setState(516); + _errHandler->sync(this); + switch (_input->LA(1)) { + case CPP14Parser::Auto: + case CPP14Parser::Bool: + case CPP14Parser::Char: + case CPP14Parser::Char16: + case CPP14Parser::Char32: + case CPP14Parser::Decltype: + case CPP14Parser::Double: + case CPP14Parser::Float: + case CPP14Parser::Int: + case CPP14Parser::Long: + case CPP14Parser::Short: + case CPP14Parser::Signed: + case CPP14Parser::Unsigned: + case CPP14Parser::Void: + case CPP14Parser::Wchar: + case CPP14Parser::Doublecolon: + case CPP14Parser::Identifier: { + setState(514); + simpleTypeSpecifier(); + break; + } + + case CPP14Parser::Typename_: { + setState(515); + typeNameSpecifier(); + break; + } + + default: + throw NoViableAltException(this); + } + setState(524); + _errHandler->sync(this); + switch (_input->LA(1)) { + case CPP14Parser::LeftParen: { + setState(518); + match(CPP14Parser::LeftParen); + setState(520); + _errHandler->sync(this); + + _la = _input->LA(1); + if ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 8364979464334764286) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 65)) & 4719772474400910417) != 0) || _la == CPP14Parser::Identifier) { + setState(519); + expressionList(); + } + setState(522); + match(CPP14Parser::RightParen); + break; + } + + case CPP14Parser::LeftBrace: { + setState(523); + bracedInitList(); + break; + } + + default: + throw NoViableAltException(this); + } + break; + } + + case 3: { + setState(526); + _la = _input->LA(1); + if (!(((((_la - 24) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 24)) & 2216203124865) != 0))) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + setState(527); + match(CPP14Parser::Less); + setState(528); + theTypeId(); + setState(529); + match(CPP14Parser::Greater); + setState(530); + match(CPP14Parser::LeftParen); + setState(531); + expression(); + setState(532); + match(CPP14Parser::RightParen); + break; + } + + case 4: { + setState(534); + typeIdOfTheTypeId(); + setState(535); + match(CPP14Parser::LeftParen); + setState(538); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 29, _ctx)) { + case 1: { + setState(536); + expression(); + break; + } + + case 2: { + setState(537); + theTypeId(); + break; + } + + default: + break; + } + setState(540); + match(CPP14Parser::RightParen); + break; + } + + default: + break; + } + _ctx->stop = _input->LT(-1); + setState(571); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 36, _ctx); + while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { + if (alt == 1) { + if (!_parseListeners.empty()) + triggerExitRuleEvent(); + previousContext = _localctx; + setState(569); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 35, _ctx)) { + case 1: { + _localctx = _tracker.createInstance(parentContext, parentState); + pushNewRecursionContext(_localctx, startState, RulePostfixExpression); + setState(544); + + if (!(precpred(_ctx, 7))) throw FailedPredicateException(this, "precpred(_ctx, 7)"); + setState(545); + match(CPP14Parser::LeftBracket); + setState(548); + _errHandler->sync(this); + switch (_input->LA(1)) { + case CPP14Parser::IntegerLiteral: + case CPP14Parser::CharacterLiteral: + case CPP14Parser::FloatingLiteral: + case CPP14Parser::StringLiteral: + case CPP14Parser::BooleanLiteral: + case CPP14Parser::PointerLiteral: + case CPP14Parser::UserDefinedLiteral: + case CPP14Parser::Alignof: + case CPP14Parser::Auto: + case CPP14Parser::Bool: + case CPP14Parser::Char: + case CPP14Parser::Char16: + case CPP14Parser::Char32: + case CPP14Parser::Const_cast: + case CPP14Parser::Decltype: + case CPP14Parser::Delete: + case CPP14Parser::Double: + case CPP14Parser::Dynamic_cast: + case CPP14Parser::Float: + case CPP14Parser::Int: + case CPP14Parser::Long: + case CPP14Parser::New: + case CPP14Parser::Noexcept: + case CPP14Parser::Operator: + case CPP14Parser::Reinterpret_cast: + case CPP14Parser::Short: + case CPP14Parser::Signed: + case CPP14Parser::Sizeof: + case CPP14Parser::Static_cast: + case CPP14Parser::This: + case CPP14Parser::Throw: + case CPP14Parser::Typeid_: + case CPP14Parser::Typename_: + case CPP14Parser::Unsigned: + case CPP14Parser::Void: + case CPP14Parser::Wchar: + case CPP14Parser::LeftParen: + case CPP14Parser::LeftBracket: + case CPP14Parser::Plus: + case CPP14Parser::Minus: + case CPP14Parser::Star: + case CPP14Parser::And: + case CPP14Parser::Or: + case CPP14Parser::Tilde: + case CPP14Parser::Not: + case CPP14Parser::PlusPlus: + case CPP14Parser::MinusMinus: + case CPP14Parser::Doublecolon: + case CPP14Parser::Identifier: { + setState(546); + expression(); + break; + } + + case CPP14Parser::LeftBrace: { + setState(547); + bracedInitList(); + break; + } + + default: + throw NoViableAltException(this); + } + setState(550); + match(CPP14Parser::RightBracket); + break; + } + + case 2: { + _localctx = _tracker.createInstance(parentContext, parentState); + pushNewRecursionContext(_localctx, startState, RulePostfixExpression); + setState(552); + + if (!(precpred(_ctx, 6))) throw FailedPredicateException(this, "precpred(_ctx, 6)"); + setState(553); + match(CPP14Parser::LeftParen); + setState(555); + _errHandler->sync(this); + + _la = _input->LA(1); + if ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 8364979464334764286) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 65)) & 4719772474400910417) != 0) || _la == CPP14Parser::Identifier) { + setState(554); + expressionList(); + } + setState(557); + match(CPP14Parser::RightParen); + break; + } + + case 3: { + _localctx = _tracker.createInstance(parentContext, parentState); + pushNewRecursionContext(_localctx, startState, RulePostfixExpression); + setState(558); + + if (!(precpred(_ctx, 4))) throw FailedPredicateException(this, "precpred(_ctx, 4)"); + setState(559); + _la = _input->LA(1); + if (!(_la == CPP14Parser::Arrow + + || _la == CPP14Parser::Dot)) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + setState(565); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 34, _ctx)) { + case 1: { + setState(561); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Template) { + setState(560); + match(CPP14Parser::Template); + } + setState(563); + idExpression(); + break; + } + + case 2: { + setState(564); + pseudoDestructorName(); + break; + } + + default: + break; + } + break; + } + + case 4: { + _localctx = _tracker.createInstance(parentContext, parentState); + pushNewRecursionContext(_localctx, startState, RulePostfixExpression); + setState(567); + + if (!(precpred(_ctx, 3))) throw FailedPredicateException(this, "precpred(_ctx, 3)"); + setState(568); + _la = _input->LA(1); + if (!(_la == CPP14Parser::PlusPlus + + || _la == CPP14Parser::MinusMinus)) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + break; + } + + default: + break; + } + } + setState(573); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 36, _ctx); + } + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + return _localctx; +} + +//----------------- TypeIdOfTheTypeIdContext ------------------------------------------------------------------ + +CPP14Parser::TypeIdOfTheTypeIdContext::TypeIdOfTheTypeIdContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::TypeIdOfTheTypeIdContext::Typeid_() { + return getToken(CPP14Parser::Typeid_, 0); +} + + +size_t CPP14Parser::TypeIdOfTheTypeIdContext::getRuleIndex() const { + return CPP14Parser::RuleTypeIdOfTheTypeId; +} + + +CPP14Parser::TypeIdOfTheTypeIdContext* CPP14Parser::typeIdOfTheTypeId() { + TypeIdOfTheTypeIdContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 32, CPP14Parser::RuleTypeIdOfTheTypeId); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(574); + match(CPP14Parser::Typeid_); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ExpressionListContext ------------------------------------------------------------------ + +CPP14Parser::ExpressionListContext::ExpressionListContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::InitializerListContext* CPP14Parser::ExpressionListContext::initializerList() { + return getRuleContext(0); +} + + +size_t CPP14Parser::ExpressionListContext::getRuleIndex() const { + return CPP14Parser::RuleExpressionList; +} + + +CPP14Parser::ExpressionListContext* CPP14Parser::expressionList() { + ExpressionListContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 34, CPP14Parser::RuleExpressionList); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(576); + initializerList(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- PseudoDestructorNameContext ------------------------------------------------------------------ + +CPP14Parser::PseudoDestructorNameContext::PseudoDestructorNameContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::PseudoDestructorNameContext::Tilde() { + return getToken(CPP14Parser::Tilde, 0); +} + +std::vector CPP14Parser::PseudoDestructorNameContext::theTypeName() { + return getRuleContexts(); +} + +CPP14Parser::TheTypeNameContext* CPP14Parser::PseudoDestructorNameContext::theTypeName(size_t i) { + return getRuleContext(i); +} + +CPP14Parser::NestedNameSpecifierContext* CPP14Parser::PseudoDestructorNameContext::nestedNameSpecifier() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::PseudoDestructorNameContext::Doublecolon() { + return getToken(CPP14Parser::Doublecolon, 0); +} + +tree::TerminalNode* CPP14Parser::PseudoDestructorNameContext::Template() { + return getToken(CPP14Parser::Template, 0); +} + +CPP14Parser::SimpleTemplateIdContext* CPP14Parser::PseudoDestructorNameContext::simpleTemplateId() { + return getRuleContext(0); +} + +CPP14Parser::DecltypeSpecifierContext* CPP14Parser::PseudoDestructorNameContext::decltypeSpecifier() { + return getRuleContext(0); +} + + +size_t CPP14Parser::PseudoDestructorNameContext::getRuleIndex() const { + return CPP14Parser::RulePseudoDestructorName; +} + + +CPP14Parser::PseudoDestructorNameContext* CPP14Parser::pseudoDestructorName() { + PseudoDestructorNameContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 36, CPP14Parser::RulePseudoDestructorName); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(597); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 39, _ctx)) { + case 1: { + enterOuterAlt(_localctx, 1); + setState(579); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 37, _ctx)) { + case 1: { + setState(578); + nestedNameSpecifier(0); + break; + } + + default: + break; + } + setState(584); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Identifier) { + setState(581); + theTypeName(); + setState(582); + match(CPP14Parser::Doublecolon); + } + setState(586); + match(CPP14Parser::Tilde); + setState(587); + theTypeName(); + break; + } + + case 2: { + enterOuterAlt(_localctx, 2); + setState(588); + nestedNameSpecifier(0); + setState(589); + match(CPP14Parser::Template); + setState(590); + simpleTemplateId(); + setState(591); + match(CPP14Parser::Doublecolon); + setState(592); + match(CPP14Parser::Tilde); + setState(593); + theTypeName(); + break; + } + + case 3: { + enterOuterAlt(_localctx, 3); + setState(595); + match(CPP14Parser::Tilde); + setState(596); + decltypeSpecifier(); + break; + } + + default: + break; + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- UnaryExpressionContext ------------------------------------------------------------------ + +CPP14Parser::UnaryExpressionContext::UnaryExpressionContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::PostfixExpressionContext* CPP14Parser::UnaryExpressionContext::postfixExpression() { + return getRuleContext(0); +} + +CPP14Parser::UnaryExpressionContext* CPP14Parser::UnaryExpressionContext::unaryExpression() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::UnaryExpressionContext::PlusPlus() { + return getToken(CPP14Parser::PlusPlus, 0); +} + +tree::TerminalNode* CPP14Parser::UnaryExpressionContext::MinusMinus() { + return getToken(CPP14Parser::MinusMinus, 0); +} + +CPP14Parser::UnaryOperatorContext* CPP14Parser::UnaryExpressionContext::unaryOperator() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::UnaryExpressionContext::Sizeof() { + return getToken(CPP14Parser::Sizeof, 0); +} + +tree::TerminalNode* CPP14Parser::UnaryExpressionContext::LeftParen() { + return getToken(CPP14Parser::LeftParen, 0); +} + +CPP14Parser::TheTypeIdContext* CPP14Parser::UnaryExpressionContext::theTypeId() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::UnaryExpressionContext::RightParen() { + return getToken(CPP14Parser::RightParen, 0); +} + +tree::TerminalNode* CPP14Parser::UnaryExpressionContext::Ellipsis() { + return getToken(CPP14Parser::Ellipsis, 0); +} + +tree::TerminalNode* CPP14Parser::UnaryExpressionContext::Identifier() { + return getToken(CPP14Parser::Identifier, 0); +} + +tree::TerminalNode* CPP14Parser::UnaryExpressionContext::Alignof() { + return getToken(CPP14Parser::Alignof, 0); +} + +CPP14Parser::NoExceptExpressionContext* CPP14Parser::UnaryExpressionContext::noExceptExpression() { + return getRuleContext(0); +} + +CPP14Parser::NewExpressionContext* CPP14Parser::UnaryExpressionContext::newExpression() { + return getRuleContext(0); +} + +CPP14Parser::DeleteExpressionContext* CPP14Parser::UnaryExpressionContext::deleteExpression() { + return getRuleContext(0); +} + + +size_t CPP14Parser::UnaryExpressionContext::getRuleIndex() const { + return CPP14Parser::RuleUnaryExpression; +} + + +CPP14Parser::UnaryExpressionContext* CPP14Parser::unaryExpression() { + UnaryExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 38, CPP14Parser::RuleUnaryExpression); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(626); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 42, _ctx)) { + case 1: { + enterOuterAlt(_localctx, 1); + setState(599); + postfixExpression(0); + break; + } + + case 2: { + enterOuterAlt(_localctx, 2); + setState(604); + _errHandler->sync(this); + switch (_input->LA(1)) { + case CPP14Parser::PlusPlus: { + setState(600); + match(CPP14Parser::PlusPlus); + break; + } + + case CPP14Parser::MinusMinus: { + setState(601); + match(CPP14Parser::MinusMinus); + break; + } + + case CPP14Parser::Plus: + case CPP14Parser::Minus: + case CPP14Parser::Star: + case CPP14Parser::And: + case CPP14Parser::Or: + case CPP14Parser::Tilde: + case CPP14Parser::Not: { + setState(602); + unaryOperator(); + break; + } + + case CPP14Parser::Sizeof: { + setState(603); + match(CPP14Parser::Sizeof); + break; + } + + default: + throw NoViableAltException(this); + } + setState(606); + unaryExpression(); + break; + } + + case 3: { + enterOuterAlt(_localctx, 3); + setState(607); + match(CPP14Parser::Sizeof); + setState(616); + _errHandler->sync(this); + switch (_input->LA(1)) { + case CPP14Parser::LeftParen: { + setState(608); + match(CPP14Parser::LeftParen); + setState(609); + theTypeId(); + setState(610); + match(CPP14Parser::RightParen); + break; + } + + case CPP14Parser::Ellipsis: { + setState(612); + match(CPP14Parser::Ellipsis); + setState(613); + match(CPP14Parser::LeftParen); + setState(614); + match(CPP14Parser::Identifier); + setState(615); + match(CPP14Parser::RightParen); + break; + } + + default: + throw NoViableAltException(this); + } + break; + } + + case 4: { + enterOuterAlt(_localctx, 4); + setState(618); + match(CPP14Parser::Alignof); + setState(619); + match(CPP14Parser::LeftParen); + setState(620); + theTypeId(); + setState(621); + match(CPP14Parser::RightParen); + break; + } + + case 5: { + enterOuterAlt(_localctx, 5); + setState(623); + noExceptExpression(); + break; + } + + case 6: { + enterOuterAlt(_localctx, 6); + setState(624); + newExpression(); + break; + } + + case 7: { + enterOuterAlt(_localctx, 7); + setState(625); + deleteExpression(); + break; + } + + default: + break; + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- UnaryOperatorContext ------------------------------------------------------------------ + +CPP14Parser::UnaryOperatorContext::UnaryOperatorContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::UnaryOperatorContext::Or() { + return getToken(CPP14Parser::Or, 0); +} + +tree::TerminalNode* CPP14Parser::UnaryOperatorContext::Star() { + return getToken(CPP14Parser::Star, 0); +} + +tree::TerminalNode* CPP14Parser::UnaryOperatorContext::And() { + return getToken(CPP14Parser::And, 0); +} + +tree::TerminalNode* CPP14Parser::UnaryOperatorContext::Plus() { + return getToken(CPP14Parser::Plus, 0); +} + +tree::TerminalNode* CPP14Parser::UnaryOperatorContext::Tilde() { + return getToken(CPP14Parser::Tilde, 0); +} + +tree::TerminalNode* CPP14Parser::UnaryOperatorContext::Minus() { + return getToken(CPP14Parser::Minus, 0); +} + +tree::TerminalNode* CPP14Parser::UnaryOperatorContext::Not() { + return getToken(CPP14Parser::Not, 0); +} + + +size_t CPP14Parser::UnaryOperatorContext::getRuleIndex() const { + return CPP14Parser::RuleUnaryOperator; +} + + +CPP14Parser::UnaryOperatorContext* CPP14Parser::unaryOperator() { + UnaryOperatorContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 40, CPP14Parser::RuleUnaryOperator); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(628); + _la = _input->LA(1); + if (!(((((_la - 91) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 91)) & 967) != 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; +} + +//----------------- NewExpressionContext ------------------------------------------------------------------ + +CPP14Parser::NewExpressionContext::NewExpressionContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::NewExpressionContext::New() { + return getToken(CPP14Parser::New, 0); +} + +CPP14Parser::NewTypeIdContext* CPP14Parser::NewExpressionContext::newTypeId() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::NewExpressionContext::Doublecolon() { + return getToken(CPP14Parser::Doublecolon, 0); +} + +CPP14Parser::NewPlacementContext* CPP14Parser::NewExpressionContext::newPlacement() { + return getRuleContext(0); +} + +CPP14Parser::NewInitializerContext* CPP14Parser::NewExpressionContext::newInitializer() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::NewExpressionContext::LeftParen() { + return getToken(CPP14Parser::LeftParen, 0); +} + +CPP14Parser::TheTypeIdContext* CPP14Parser::NewExpressionContext::theTypeId() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::NewExpressionContext::RightParen() { + return getToken(CPP14Parser::RightParen, 0); +} + + +size_t CPP14Parser::NewExpressionContext::getRuleIndex() const { + return CPP14Parser::RuleNewExpression; +} + + +CPP14Parser::NewExpressionContext* CPP14Parser::newExpression() { + NewExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 42, CPP14Parser::RuleNewExpression); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(631); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Doublecolon) { + setState(630); + match(CPP14Parser::Doublecolon); + } + setState(633); + match(CPP14Parser::New); + setState(635); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 44, _ctx)) { + case 1: { + setState(634); + newPlacement(); + break; + } + + default: + break; + } + setState(642); + _errHandler->sync(this); + switch (_input->LA(1)) { + case CPP14Parser::Auto: + case CPP14Parser::Bool: + case CPP14Parser::Char: + case CPP14Parser::Char16: + case CPP14Parser::Char32: + case CPP14Parser::Class: + case CPP14Parser::Const: + case CPP14Parser::Decltype: + case CPP14Parser::Double: + case CPP14Parser::Enum: + case CPP14Parser::Float: + case CPP14Parser::Int: + case CPP14Parser::Long: + case CPP14Parser::Short: + case CPP14Parser::Signed: + case CPP14Parser::Struct: + case CPP14Parser::Typename_: + case CPP14Parser::Union: + case CPP14Parser::Unsigned: + case CPP14Parser::Void: + case CPP14Parser::Volatile: + case CPP14Parser::Wchar: + case CPP14Parser::Doublecolon: + case CPP14Parser::Identifier: { + setState(637); + newTypeId(); + break; + } + + case CPP14Parser::LeftParen: { + setState(638); + match(CPP14Parser::LeftParen); + setState(639); + theTypeId(); + setState(640); + match(CPP14Parser::RightParen); + break; + } + + default: + throw NoViableAltException(this); + } + setState(645); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::LeftParen + + || _la == CPP14Parser::LeftBrace) { + setState(644); + newInitializer(); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- NewPlacementContext ------------------------------------------------------------------ + +CPP14Parser::NewPlacementContext::NewPlacementContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::NewPlacementContext::LeftParen() { + return getToken(CPP14Parser::LeftParen, 0); +} + +CPP14Parser::ExpressionListContext* CPP14Parser::NewPlacementContext::expressionList() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::NewPlacementContext::RightParen() { + return getToken(CPP14Parser::RightParen, 0); +} + + +size_t CPP14Parser::NewPlacementContext::getRuleIndex() const { + return CPP14Parser::RuleNewPlacement; +} + + +CPP14Parser::NewPlacementContext* CPP14Parser::newPlacement() { + NewPlacementContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 44, CPP14Parser::RuleNewPlacement); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(647); + match(CPP14Parser::LeftParen); + setState(648); + expressionList(); + setState(649); + match(CPP14Parser::RightParen); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- NewTypeIdContext ------------------------------------------------------------------ + +CPP14Parser::NewTypeIdContext::NewTypeIdContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::TypeSpecifierSeqContext* CPP14Parser::NewTypeIdContext::typeSpecifierSeq() { + return getRuleContext(0); +} + +CPP14Parser::NewDeclaratorContext* CPP14Parser::NewTypeIdContext::newDeclarator() { + return getRuleContext(0); +} + + +size_t CPP14Parser::NewTypeIdContext::getRuleIndex() const { + return CPP14Parser::RuleNewTypeId; +} + + +CPP14Parser::NewTypeIdContext* CPP14Parser::newTypeId() { + NewTypeIdContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 46, CPP14Parser::RuleNewTypeId); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(651); + typeSpecifierSeq(); + setState(653); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 47, _ctx)) { + case 1: { + setState(652); + newDeclarator(); + break; + } + + default: + break; + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- NewDeclaratorContext ------------------------------------------------------------------ + +CPP14Parser::NewDeclaratorContext::NewDeclaratorContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::PointerOperatorContext* CPP14Parser::NewDeclaratorContext::pointerOperator() { + return getRuleContext(0); +} + +CPP14Parser::NewDeclaratorContext* CPP14Parser::NewDeclaratorContext::newDeclarator() { + return getRuleContext(0); +} + +CPP14Parser::NoPointerNewDeclaratorContext* CPP14Parser::NewDeclaratorContext::noPointerNewDeclarator() { + return getRuleContext(0); +} + + +size_t CPP14Parser::NewDeclaratorContext::getRuleIndex() const { + return CPP14Parser::RuleNewDeclarator; +} + + +CPP14Parser::NewDeclaratorContext* CPP14Parser::newDeclarator() { + NewDeclaratorContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 48, CPP14Parser::RuleNewDeclarator); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(660); + _errHandler->sync(this); + switch (_input->LA(1)) { + case CPP14Parser::Decltype: + case CPP14Parser::Star: + case CPP14Parser::And: + case CPP14Parser::AndAnd: + case CPP14Parser::Doublecolon: + case CPP14Parser::Identifier: { + enterOuterAlt(_localctx, 1); + setState(655); + pointerOperator(); + setState(657); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 48, _ctx)) { + case 1: { + setState(656); + newDeclarator(); + break; + } + + default: + break; + } + break; + } + + case CPP14Parser::LeftBracket: { + enterOuterAlt(_localctx, 2); + setState(659); + noPointerNewDeclarator(0); + break; + } + + default: + throw NoViableAltException(this); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- NoPointerNewDeclaratorContext ------------------------------------------------------------------ + +CPP14Parser::NoPointerNewDeclaratorContext::NoPointerNewDeclaratorContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::NoPointerNewDeclaratorContext::LeftBracket() { + return getToken(CPP14Parser::LeftBracket, 0); +} + +CPP14Parser::ExpressionContext* CPP14Parser::NoPointerNewDeclaratorContext::expression() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::NoPointerNewDeclaratorContext::RightBracket() { + return getToken(CPP14Parser::RightBracket, 0); +} + +CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::NoPointerNewDeclaratorContext::attributeSpecifierSeq() { + return getRuleContext(0); +} + +CPP14Parser::NoPointerNewDeclaratorContext* CPP14Parser::NoPointerNewDeclaratorContext::noPointerNewDeclarator() { + return getRuleContext(0); +} + +CPP14Parser::ConstantExpressionContext* CPP14Parser::NoPointerNewDeclaratorContext::constantExpression() { + return getRuleContext(0); +} + + +size_t CPP14Parser::NoPointerNewDeclaratorContext::getRuleIndex() const { + return CPP14Parser::RuleNoPointerNewDeclarator; +} + + + +CPP14Parser::NoPointerNewDeclaratorContext* CPP14Parser::noPointerNewDeclarator() { + return noPointerNewDeclarator(0); +} + +CPP14Parser::NoPointerNewDeclaratorContext* CPP14Parser::noPointerNewDeclarator(int precedence) { + ParserRuleContext *parentContext = _ctx; + size_t parentState = getState(); + CPP14Parser::NoPointerNewDeclaratorContext *_localctx = _tracker.createInstance(_ctx, parentState); + CPP14Parser::NoPointerNewDeclaratorContext *previousContext = _localctx; + (void)previousContext; // Silence compiler, in case the context is not used by generated code. + size_t startState = 50; + enterRecursionRule(_localctx, 50, CPP14Parser::RuleNoPointerNewDeclarator, precedence); + + + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + unrollRecursionContexts(parentContext); + }); + try { + size_t alt; + enterOuterAlt(_localctx, 1); + setState(663); + match(CPP14Parser::LeftBracket); + setState(664); + expression(); + setState(665); + match(CPP14Parser::RightBracket); + setState(667); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 50, _ctx)) { + case 1: { + setState(666); + attributeSpecifierSeq(); + break; + } + + default: + break; + } + _ctx->stop = _input->LT(-1); + setState(678); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 52, _ctx); + while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { + if (alt == 1) { + if (!_parseListeners.empty()) + triggerExitRuleEvent(); + previousContext = _localctx; + _localctx = _tracker.createInstance(parentContext, parentState); + pushNewRecursionContext(_localctx, startState, RuleNoPointerNewDeclarator); + setState(669); + + if (!(precpred(_ctx, 1))) throw FailedPredicateException(this, "precpred(_ctx, 1)"); + setState(670); + match(CPP14Parser::LeftBracket); + setState(671); + constantExpression(); + setState(672); + match(CPP14Parser::RightBracket); + setState(674); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 51, _ctx)) { + case 1: { + setState(673); + attributeSpecifierSeq(); + break; + } + + default: + break; + } + } + setState(680); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 52, _ctx); + } + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + return _localctx; +} + +//----------------- NewInitializerContext ------------------------------------------------------------------ + +CPP14Parser::NewInitializerContext::NewInitializerContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::NewInitializerContext::LeftParen() { + return getToken(CPP14Parser::LeftParen, 0); +} + +tree::TerminalNode* CPP14Parser::NewInitializerContext::RightParen() { + return getToken(CPP14Parser::RightParen, 0); +} + +CPP14Parser::ExpressionListContext* CPP14Parser::NewInitializerContext::expressionList() { + return getRuleContext(0); +} + +CPP14Parser::BracedInitListContext* CPP14Parser::NewInitializerContext::bracedInitList() { + return getRuleContext(0); +} + + +size_t CPP14Parser::NewInitializerContext::getRuleIndex() const { + return CPP14Parser::RuleNewInitializer; +} + + +CPP14Parser::NewInitializerContext* CPP14Parser::newInitializer() { + NewInitializerContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 52, CPP14Parser::RuleNewInitializer); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(687); + _errHandler->sync(this); + switch (_input->LA(1)) { + case CPP14Parser::LeftParen: { + enterOuterAlt(_localctx, 1); + setState(681); + match(CPP14Parser::LeftParen); + setState(683); + _errHandler->sync(this); + + _la = _input->LA(1); + if ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 8364979464334764286) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 65)) & 4719772474400910417) != 0) || _la == CPP14Parser::Identifier) { + setState(682); + expressionList(); + } + setState(685); + match(CPP14Parser::RightParen); + break; + } + + case CPP14Parser::LeftBrace: { + enterOuterAlt(_localctx, 2); + setState(686); + bracedInitList(); + break; + } + + default: + throw NoViableAltException(this); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- DeleteExpressionContext ------------------------------------------------------------------ + +CPP14Parser::DeleteExpressionContext::DeleteExpressionContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::DeleteExpressionContext::Delete() { + return getToken(CPP14Parser::Delete, 0); +} + +CPP14Parser::CastExpressionContext* CPP14Parser::DeleteExpressionContext::castExpression() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::DeleteExpressionContext::Doublecolon() { + return getToken(CPP14Parser::Doublecolon, 0); +} + +tree::TerminalNode* CPP14Parser::DeleteExpressionContext::LeftBracket() { + return getToken(CPP14Parser::LeftBracket, 0); +} + +tree::TerminalNode* CPP14Parser::DeleteExpressionContext::RightBracket() { + return getToken(CPP14Parser::RightBracket, 0); +} + + +size_t CPP14Parser::DeleteExpressionContext::getRuleIndex() const { + return CPP14Parser::RuleDeleteExpression; +} + + +CPP14Parser::DeleteExpressionContext* CPP14Parser::deleteExpression() { + DeleteExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 54, CPP14Parser::RuleDeleteExpression); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(690); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Doublecolon) { + setState(689); + match(CPP14Parser::Doublecolon); + } + setState(692); + match(CPP14Parser::Delete); + setState(695); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 56, _ctx)) { + case 1: { + setState(693); + match(CPP14Parser::LeftBracket); + setState(694); + match(CPP14Parser::RightBracket); + break; + } + + default: + break; + } + setState(697); + castExpression(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- NoExceptExpressionContext ------------------------------------------------------------------ + +CPP14Parser::NoExceptExpressionContext::NoExceptExpressionContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::NoExceptExpressionContext::Noexcept() { + return getToken(CPP14Parser::Noexcept, 0); +} + +tree::TerminalNode* CPP14Parser::NoExceptExpressionContext::LeftParen() { + return getToken(CPP14Parser::LeftParen, 0); +} + +CPP14Parser::ExpressionContext* CPP14Parser::NoExceptExpressionContext::expression() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::NoExceptExpressionContext::RightParen() { + return getToken(CPP14Parser::RightParen, 0); +} + + +size_t CPP14Parser::NoExceptExpressionContext::getRuleIndex() const { + return CPP14Parser::RuleNoExceptExpression; +} + + +CPP14Parser::NoExceptExpressionContext* CPP14Parser::noExceptExpression() { + NoExceptExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 56, CPP14Parser::RuleNoExceptExpression); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(699); + match(CPP14Parser::Noexcept); + setState(700); + match(CPP14Parser::LeftParen); + setState(701); + expression(); + setState(702); + match(CPP14Parser::RightParen); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- CastExpressionContext ------------------------------------------------------------------ + +CPP14Parser::CastExpressionContext::CastExpressionContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::UnaryExpressionContext* CPP14Parser::CastExpressionContext::unaryExpression() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::CastExpressionContext::LeftParen() { + return getToken(CPP14Parser::LeftParen, 0); +} + +CPP14Parser::TheTypeIdContext* CPP14Parser::CastExpressionContext::theTypeId() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::CastExpressionContext::RightParen() { + return getToken(CPP14Parser::RightParen, 0); +} + +CPP14Parser::CastExpressionContext* CPP14Parser::CastExpressionContext::castExpression() { + return getRuleContext(0); +} + + +size_t CPP14Parser::CastExpressionContext::getRuleIndex() const { + return CPP14Parser::RuleCastExpression; +} + + +CPP14Parser::CastExpressionContext* CPP14Parser::castExpression() { + CastExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 58, CPP14Parser::RuleCastExpression); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(710); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 57, _ctx)) { + case 1: { + enterOuterAlt(_localctx, 1); + setState(704); + unaryExpression(); + break; + } + + case 2: { + enterOuterAlt(_localctx, 2); + setState(705); + match(CPP14Parser::LeftParen); + setState(706); + theTypeId(); + setState(707); + match(CPP14Parser::RightParen); + setState(708); + castExpression(); + break; + } + + default: + break; + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- PointerMemberExpressionContext ------------------------------------------------------------------ + +CPP14Parser::PointerMemberExpressionContext::PointerMemberExpressionContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector CPP14Parser::PointerMemberExpressionContext::castExpression() { + return getRuleContexts(); +} + +CPP14Parser::CastExpressionContext* CPP14Parser::PointerMemberExpressionContext::castExpression(size_t i) { + return getRuleContext(i); +} + +std::vector CPP14Parser::PointerMemberExpressionContext::DotStar() { + return getTokens(CPP14Parser::DotStar); +} + +tree::TerminalNode* CPP14Parser::PointerMemberExpressionContext::DotStar(size_t i) { + return getToken(CPP14Parser::DotStar, i); +} + +std::vector CPP14Parser::PointerMemberExpressionContext::ArrowStar() { + return getTokens(CPP14Parser::ArrowStar); +} + +tree::TerminalNode* CPP14Parser::PointerMemberExpressionContext::ArrowStar(size_t i) { + return getToken(CPP14Parser::ArrowStar, i); +} + + +size_t CPP14Parser::PointerMemberExpressionContext::getRuleIndex() const { + return CPP14Parser::RulePointerMemberExpression; +} + + +CPP14Parser::PointerMemberExpressionContext* CPP14Parser::pointerMemberExpression() { + PointerMemberExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 60, CPP14Parser::RulePointerMemberExpression); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(712); + castExpression(); + setState(717); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == CPP14Parser::ArrowStar + + || _la == CPP14Parser::DotStar) { + setState(713); + _la = _input->LA(1); + if (!(_la == CPP14Parser::ArrowStar + + || _la == CPP14Parser::DotStar)) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + setState(714); + castExpression(); + setState(719); + _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; +} + +//----------------- MultiplicativeExpressionContext ------------------------------------------------------------------ + +CPP14Parser::MultiplicativeExpressionContext::MultiplicativeExpressionContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector CPP14Parser::MultiplicativeExpressionContext::pointerMemberExpression() { + return getRuleContexts(); +} + +CPP14Parser::PointerMemberExpressionContext* CPP14Parser::MultiplicativeExpressionContext::pointerMemberExpression(size_t i) { + return getRuleContext(i); +} + +std::vector CPP14Parser::MultiplicativeExpressionContext::Star() { + return getTokens(CPP14Parser::Star); +} + +tree::TerminalNode* CPP14Parser::MultiplicativeExpressionContext::Star(size_t i) { + return getToken(CPP14Parser::Star, i); +} + +std::vector CPP14Parser::MultiplicativeExpressionContext::Div() { + return getTokens(CPP14Parser::Div); +} + +tree::TerminalNode* CPP14Parser::MultiplicativeExpressionContext::Div(size_t i) { + return getToken(CPP14Parser::Div, i); +} + +std::vector CPP14Parser::MultiplicativeExpressionContext::Mod() { + return getTokens(CPP14Parser::Mod); +} + +tree::TerminalNode* CPP14Parser::MultiplicativeExpressionContext::Mod(size_t i) { + return getToken(CPP14Parser::Mod, i); +} + + +size_t CPP14Parser::MultiplicativeExpressionContext::getRuleIndex() const { + return CPP14Parser::RuleMultiplicativeExpression; +} + + +CPP14Parser::MultiplicativeExpressionContext* CPP14Parser::multiplicativeExpression() { + MultiplicativeExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 62, CPP14Parser::RuleMultiplicativeExpression); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(720); + pointerMemberExpression(); + setState(725); + _errHandler->sync(this); + _la = _input->LA(1); + while (((((_la - 93) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 93)) & 7) != 0)) { + setState(721); + _la = _input->LA(1); + if (!(((((_la - 93) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 93)) & 7) != 0))) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + setState(722); + pointerMemberExpression(); + setState(727); + _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; +} + +//----------------- AdditiveExpressionContext ------------------------------------------------------------------ + +CPP14Parser::AdditiveExpressionContext::AdditiveExpressionContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector CPP14Parser::AdditiveExpressionContext::multiplicativeExpression() { + return getRuleContexts(); +} + +CPP14Parser::MultiplicativeExpressionContext* CPP14Parser::AdditiveExpressionContext::multiplicativeExpression(size_t i) { + return getRuleContext(i); +} + +std::vector CPP14Parser::AdditiveExpressionContext::Plus() { + return getTokens(CPP14Parser::Plus); +} + +tree::TerminalNode* CPP14Parser::AdditiveExpressionContext::Plus(size_t i) { + return getToken(CPP14Parser::Plus, i); +} + +std::vector CPP14Parser::AdditiveExpressionContext::Minus() { + return getTokens(CPP14Parser::Minus); +} + +tree::TerminalNode* CPP14Parser::AdditiveExpressionContext::Minus(size_t i) { + return getToken(CPP14Parser::Minus, i); +} + + +size_t CPP14Parser::AdditiveExpressionContext::getRuleIndex() const { + return CPP14Parser::RuleAdditiveExpression; +} + + +CPP14Parser::AdditiveExpressionContext* CPP14Parser::additiveExpression() { + AdditiveExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 64, CPP14Parser::RuleAdditiveExpression); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(728); + multiplicativeExpression(); + setState(733); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == CPP14Parser::Plus + + || _la == CPP14Parser::Minus) { + setState(729); + _la = _input->LA(1); + if (!(_la == CPP14Parser::Plus + + || _la == CPP14Parser::Minus)) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + setState(730); + multiplicativeExpression(); + setState(735); + _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; +} + +//----------------- ShiftExpressionContext ------------------------------------------------------------------ + +CPP14Parser::ShiftExpressionContext::ShiftExpressionContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector CPP14Parser::ShiftExpressionContext::additiveExpression() { + return getRuleContexts(); +} + +CPP14Parser::AdditiveExpressionContext* CPP14Parser::ShiftExpressionContext::additiveExpression(size_t i) { + return getRuleContext(i); +} + +std::vector CPP14Parser::ShiftExpressionContext::shiftOperator() { + return getRuleContexts(); +} + +CPP14Parser::ShiftOperatorContext* CPP14Parser::ShiftExpressionContext::shiftOperator(size_t i) { + return getRuleContext(i); +} + + +size_t CPP14Parser::ShiftExpressionContext::getRuleIndex() const { + return CPP14Parser::RuleShiftExpression; +} + + +CPP14Parser::ShiftExpressionContext* CPP14Parser::shiftExpression() { + ShiftExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 66, CPP14Parser::RuleShiftExpression); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + size_t alt; + enterOuterAlt(_localctx, 1); + setState(736); + additiveExpression(); + setState(742); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 61, _ctx); + while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { + if (alt == 1) { + setState(737); + shiftOperator(); + setState(738); + additiveExpression(); + } + setState(744); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 61, _ctx); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ShiftOperatorContext ------------------------------------------------------------------ + +CPP14Parser::ShiftOperatorContext::ShiftOperatorContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector CPP14Parser::ShiftOperatorContext::Greater() { + return getTokens(CPP14Parser::Greater); +} + +tree::TerminalNode* CPP14Parser::ShiftOperatorContext::Greater(size_t i) { + return getToken(CPP14Parser::Greater, i); +} + +std::vector CPP14Parser::ShiftOperatorContext::Less() { + return getTokens(CPP14Parser::Less); +} + +tree::TerminalNode* CPP14Parser::ShiftOperatorContext::Less(size_t i) { + return getToken(CPP14Parser::Less, i); +} + + +size_t CPP14Parser::ShiftOperatorContext::getRuleIndex() const { + return CPP14Parser::RuleShiftOperator; +} + + +CPP14Parser::ShiftOperatorContext* CPP14Parser::shiftOperator() { + ShiftOperatorContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 68, CPP14Parser::RuleShiftOperator); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(749); + _errHandler->sync(this); + switch (_input->LA(1)) { + case CPP14Parser::Greater: { + enterOuterAlt(_localctx, 1); + setState(745); + match(CPP14Parser::Greater); + setState(746); + match(CPP14Parser::Greater); + break; + } + + case CPP14Parser::Less: { + enterOuterAlt(_localctx, 2); + setState(747); + match(CPP14Parser::Less); + setState(748); + match(CPP14Parser::Less); + break; + } + + default: + throw NoViableAltException(this); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- RelationalExpressionContext ------------------------------------------------------------------ + +CPP14Parser::RelationalExpressionContext::RelationalExpressionContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector CPP14Parser::RelationalExpressionContext::shiftExpression() { + return getRuleContexts(); +} + +CPP14Parser::ShiftExpressionContext* CPP14Parser::RelationalExpressionContext::shiftExpression(size_t i) { + return getRuleContext(i); +} + +std::vector CPP14Parser::RelationalExpressionContext::Less() { + return getTokens(CPP14Parser::Less); +} + +tree::TerminalNode* CPP14Parser::RelationalExpressionContext::Less(size_t i) { + return getToken(CPP14Parser::Less, i); +} + +std::vector CPP14Parser::RelationalExpressionContext::Greater() { + return getTokens(CPP14Parser::Greater); +} + +tree::TerminalNode* CPP14Parser::RelationalExpressionContext::Greater(size_t i) { + return getToken(CPP14Parser::Greater, i); +} + +std::vector CPP14Parser::RelationalExpressionContext::LessEqual() { + return getTokens(CPP14Parser::LessEqual); +} + +tree::TerminalNode* CPP14Parser::RelationalExpressionContext::LessEqual(size_t i) { + return getToken(CPP14Parser::LessEqual, i); +} + +std::vector CPP14Parser::RelationalExpressionContext::GreaterEqual() { + return getTokens(CPP14Parser::GreaterEqual); +} + +tree::TerminalNode* CPP14Parser::RelationalExpressionContext::GreaterEqual(size_t i) { + return getToken(CPP14Parser::GreaterEqual, i); +} + + +size_t CPP14Parser::RelationalExpressionContext::getRuleIndex() const { + return CPP14Parser::RuleRelationalExpression; +} + + +CPP14Parser::RelationalExpressionContext* CPP14Parser::relationalExpression() { + RelationalExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 70, CPP14Parser::RuleRelationalExpression); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + size_t alt; + enterOuterAlt(_localctx, 1); + setState(751); + shiftExpression(); + setState(756); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 63, _ctx); + while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { + if (alt == 1) { + setState(752); + _la = _input->LA(1); + if (!(((((_la - 102) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 102)) & 49155) != 0))) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + setState(753); + shiftExpression(); + } + setState(758); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 63, _ctx); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- EqualityExpressionContext ------------------------------------------------------------------ + +CPP14Parser::EqualityExpressionContext::EqualityExpressionContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector CPP14Parser::EqualityExpressionContext::relationalExpression() { + return getRuleContexts(); +} + +CPP14Parser::RelationalExpressionContext* CPP14Parser::EqualityExpressionContext::relationalExpression(size_t i) { + return getRuleContext(i); +} + +std::vector CPP14Parser::EqualityExpressionContext::Equal() { + return getTokens(CPP14Parser::Equal); +} + +tree::TerminalNode* CPP14Parser::EqualityExpressionContext::Equal(size_t i) { + return getToken(CPP14Parser::Equal, i); +} + +std::vector CPP14Parser::EqualityExpressionContext::NotEqual() { + return getTokens(CPP14Parser::NotEqual); +} + +tree::TerminalNode* CPP14Parser::EqualityExpressionContext::NotEqual(size_t i) { + return getToken(CPP14Parser::NotEqual, i); +} + + +size_t CPP14Parser::EqualityExpressionContext::getRuleIndex() const { + return CPP14Parser::RuleEqualityExpression; +} + + +CPP14Parser::EqualityExpressionContext* CPP14Parser::equalityExpression() { + EqualityExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 72, CPP14Parser::RuleEqualityExpression); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(759); + relationalExpression(); + setState(764); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == CPP14Parser::Equal + + || _la == CPP14Parser::NotEqual) { + setState(760); + _la = _input->LA(1); + if (!(_la == CPP14Parser::Equal + + || _la == CPP14Parser::NotEqual)) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + setState(761); + relationalExpression(); + setState(766); + _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; +} + +//----------------- AndExpressionContext ------------------------------------------------------------------ + +CPP14Parser::AndExpressionContext::AndExpressionContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector CPP14Parser::AndExpressionContext::equalityExpression() { + return getRuleContexts(); +} + +CPP14Parser::EqualityExpressionContext* CPP14Parser::AndExpressionContext::equalityExpression(size_t i) { + return getRuleContext(i); +} + +std::vector CPP14Parser::AndExpressionContext::And() { + return getTokens(CPP14Parser::And); +} + +tree::TerminalNode* CPP14Parser::AndExpressionContext::And(size_t i) { + return getToken(CPP14Parser::And, i); +} + + +size_t CPP14Parser::AndExpressionContext::getRuleIndex() const { + return CPP14Parser::RuleAndExpression; +} + + +CPP14Parser::AndExpressionContext* CPP14Parser::andExpression() { + AndExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 74, CPP14Parser::RuleAndExpression); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(767); + equalityExpression(); + setState(772); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == CPP14Parser::And) { + setState(768); + match(CPP14Parser::And); + setState(769); + equalityExpression(); + setState(774); + _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; +} + +//----------------- ExclusiveOrExpressionContext ------------------------------------------------------------------ + +CPP14Parser::ExclusiveOrExpressionContext::ExclusiveOrExpressionContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector CPP14Parser::ExclusiveOrExpressionContext::andExpression() { + return getRuleContexts(); +} + +CPP14Parser::AndExpressionContext* CPP14Parser::ExclusiveOrExpressionContext::andExpression(size_t i) { + return getRuleContext(i); +} + +std::vector CPP14Parser::ExclusiveOrExpressionContext::Caret() { + return getTokens(CPP14Parser::Caret); +} + +tree::TerminalNode* CPP14Parser::ExclusiveOrExpressionContext::Caret(size_t i) { + return getToken(CPP14Parser::Caret, i); +} + + +size_t CPP14Parser::ExclusiveOrExpressionContext::getRuleIndex() const { + return CPP14Parser::RuleExclusiveOrExpression; +} + + +CPP14Parser::ExclusiveOrExpressionContext* CPP14Parser::exclusiveOrExpression() { + ExclusiveOrExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 76, CPP14Parser::RuleExclusiveOrExpression); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(775); + andExpression(); + setState(780); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == CPP14Parser::Caret) { + setState(776); + match(CPP14Parser::Caret); + setState(777); + andExpression(); + setState(782); + _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; +} + +//----------------- InclusiveOrExpressionContext ------------------------------------------------------------------ + +CPP14Parser::InclusiveOrExpressionContext::InclusiveOrExpressionContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector CPP14Parser::InclusiveOrExpressionContext::exclusiveOrExpression() { + return getRuleContexts(); +} + +CPP14Parser::ExclusiveOrExpressionContext* CPP14Parser::InclusiveOrExpressionContext::exclusiveOrExpression(size_t i) { + return getRuleContext(i); +} + +std::vector CPP14Parser::InclusiveOrExpressionContext::Or() { + return getTokens(CPP14Parser::Or); +} + +tree::TerminalNode* CPP14Parser::InclusiveOrExpressionContext::Or(size_t i) { + return getToken(CPP14Parser::Or, i); +} + + +size_t CPP14Parser::InclusiveOrExpressionContext::getRuleIndex() const { + return CPP14Parser::RuleInclusiveOrExpression; +} + + +CPP14Parser::InclusiveOrExpressionContext* CPP14Parser::inclusiveOrExpression() { + InclusiveOrExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 78, CPP14Parser::RuleInclusiveOrExpression); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(783); + exclusiveOrExpression(); + setState(788); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == CPP14Parser::Or) { + setState(784); + match(CPP14Parser::Or); + setState(785); + exclusiveOrExpression(); + setState(790); + _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; +} + +//----------------- LogicalAndExpressionContext ------------------------------------------------------------------ + +CPP14Parser::LogicalAndExpressionContext::LogicalAndExpressionContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector CPP14Parser::LogicalAndExpressionContext::inclusiveOrExpression() { + return getRuleContexts(); +} + +CPP14Parser::InclusiveOrExpressionContext* CPP14Parser::LogicalAndExpressionContext::inclusiveOrExpression(size_t i) { + return getRuleContext(i); +} + +std::vector CPP14Parser::LogicalAndExpressionContext::AndAnd() { + return getTokens(CPP14Parser::AndAnd); +} + +tree::TerminalNode* CPP14Parser::LogicalAndExpressionContext::AndAnd(size_t i) { + return getToken(CPP14Parser::AndAnd, i); +} + + +size_t CPP14Parser::LogicalAndExpressionContext::getRuleIndex() const { + return CPP14Parser::RuleLogicalAndExpression; +} + + +CPP14Parser::LogicalAndExpressionContext* CPP14Parser::logicalAndExpression() { + LogicalAndExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 80, CPP14Parser::RuleLogicalAndExpression); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(791); + inclusiveOrExpression(); + setState(796); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == CPP14Parser::AndAnd) { + setState(792); + match(CPP14Parser::AndAnd); + setState(793); + inclusiveOrExpression(); + setState(798); + _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; +} + +//----------------- LogicalOrExpressionContext ------------------------------------------------------------------ + +CPP14Parser::LogicalOrExpressionContext::LogicalOrExpressionContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector CPP14Parser::LogicalOrExpressionContext::logicalAndExpression() { + return getRuleContexts(); +} + +CPP14Parser::LogicalAndExpressionContext* CPP14Parser::LogicalOrExpressionContext::logicalAndExpression(size_t i) { + return getRuleContext(i); +} + +std::vector CPP14Parser::LogicalOrExpressionContext::OrOr() { + return getTokens(CPP14Parser::OrOr); +} + +tree::TerminalNode* CPP14Parser::LogicalOrExpressionContext::OrOr(size_t i) { + return getToken(CPP14Parser::OrOr, i); +} + + +size_t CPP14Parser::LogicalOrExpressionContext::getRuleIndex() const { + return CPP14Parser::RuleLogicalOrExpression; +} + + +CPP14Parser::LogicalOrExpressionContext* CPP14Parser::logicalOrExpression() { + LogicalOrExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 82, CPP14Parser::RuleLogicalOrExpression); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(799); + logicalAndExpression(); + setState(804); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == CPP14Parser::OrOr) { + setState(800); + match(CPP14Parser::OrOr); + setState(801); + logicalAndExpression(); + setState(806); + _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; +} + +//----------------- ConditionalExpressionContext ------------------------------------------------------------------ + +CPP14Parser::ConditionalExpressionContext::ConditionalExpressionContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::LogicalOrExpressionContext* CPP14Parser::ConditionalExpressionContext::logicalOrExpression() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::ConditionalExpressionContext::Question() { + return getToken(CPP14Parser::Question, 0); +} + +CPP14Parser::ExpressionContext* CPP14Parser::ConditionalExpressionContext::expression() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::ConditionalExpressionContext::Colon() { + return getToken(CPP14Parser::Colon, 0); +} + +CPP14Parser::AssignmentExpressionContext* CPP14Parser::ConditionalExpressionContext::assignmentExpression() { + return getRuleContext(0); +} + + +size_t CPP14Parser::ConditionalExpressionContext::getRuleIndex() const { + return CPP14Parser::RuleConditionalExpression; +} + + +CPP14Parser::ConditionalExpressionContext* CPP14Parser::conditionalExpression() { + ConditionalExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 84, CPP14Parser::RuleConditionalExpression); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(807); + logicalOrExpression(); + setState(813); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Question) { + setState(808); + match(CPP14Parser::Question); + setState(809); + expression(); + setState(810); + match(CPP14Parser::Colon); + setState(811); + assignmentExpression(); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- AssignmentExpressionContext ------------------------------------------------------------------ + +CPP14Parser::AssignmentExpressionContext::AssignmentExpressionContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::ConditionalExpressionContext* CPP14Parser::AssignmentExpressionContext::conditionalExpression() { + return getRuleContext(0); +} + +CPP14Parser::LogicalOrExpressionContext* CPP14Parser::AssignmentExpressionContext::logicalOrExpression() { + return getRuleContext(0); +} + +CPP14Parser::AssignmentOperatorContext* CPP14Parser::AssignmentExpressionContext::assignmentOperator() { + return getRuleContext(0); +} + +CPP14Parser::InitializerClauseContext* CPP14Parser::AssignmentExpressionContext::initializerClause() { + return getRuleContext(0); +} + +CPP14Parser::ThrowExpressionContext* CPP14Parser::AssignmentExpressionContext::throwExpression() { + return getRuleContext(0); +} + + +size_t CPP14Parser::AssignmentExpressionContext::getRuleIndex() const { + return CPP14Parser::RuleAssignmentExpression; +} + + +CPP14Parser::AssignmentExpressionContext* CPP14Parser::assignmentExpression() { + AssignmentExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 86, CPP14Parser::RuleAssignmentExpression); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(821); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 71, _ctx)) { + case 1: { + enterOuterAlt(_localctx, 1); + setState(815); + conditionalExpression(); + break; + } + + case 2: { + enterOuterAlt(_localctx, 2); + setState(816); + logicalOrExpression(); + setState(817); + assignmentOperator(); + setState(818); + initializerClause(); + break; + } + + case 3: { + enterOuterAlt(_localctx, 3); + setState(820); + throwExpression(); + break; + } + + default: + break; + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- AssignmentOperatorContext ------------------------------------------------------------------ + +CPP14Parser::AssignmentOperatorContext::AssignmentOperatorContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::AssignmentOperatorContext::Assign() { + return getToken(CPP14Parser::Assign, 0); +} + +tree::TerminalNode* CPP14Parser::AssignmentOperatorContext::StarAssign() { + return getToken(CPP14Parser::StarAssign, 0); +} + +tree::TerminalNode* CPP14Parser::AssignmentOperatorContext::DivAssign() { + return getToken(CPP14Parser::DivAssign, 0); +} + +tree::TerminalNode* CPP14Parser::AssignmentOperatorContext::ModAssign() { + return getToken(CPP14Parser::ModAssign, 0); +} + +tree::TerminalNode* CPP14Parser::AssignmentOperatorContext::PlusAssign() { + return getToken(CPP14Parser::PlusAssign, 0); +} + +tree::TerminalNode* CPP14Parser::AssignmentOperatorContext::MinusAssign() { + return getToken(CPP14Parser::MinusAssign, 0); +} + +tree::TerminalNode* CPP14Parser::AssignmentOperatorContext::RightShiftAssign() { + return getToken(CPP14Parser::RightShiftAssign, 0); +} + +tree::TerminalNode* CPP14Parser::AssignmentOperatorContext::LeftShiftAssign() { + return getToken(CPP14Parser::LeftShiftAssign, 0); +} + +tree::TerminalNode* CPP14Parser::AssignmentOperatorContext::AndAssign() { + return getToken(CPP14Parser::AndAssign, 0); +} + +tree::TerminalNode* CPP14Parser::AssignmentOperatorContext::XorAssign() { + return getToken(CPP14Parser::XorAssign, 0); +} + +tree::TerminalNode* CPP14Parser::AssignmentOperatorContext::OrAssign() { + return getToken(CPP14Parser::OrAssign, 0); +} + + +size_t CPP14Parser::AssignmentOperatorContext::getRuleIndex() const { + return CPP14Parser::RuleAssignmentOperator; +} + + +CPP14Parser::AssignmentOperatorContext* CPP14Parser::assignmentOperator() { + AssignmentOperatorContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 88, CPP14Parser::RuleAssignmentOperator); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(823); + _la = _input->LA(1); + if (!(((((_la - 101) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 101)) & 8185) != 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; +} + +//----------------- ExpressionContext ------------------------------------------------------------------ + +CPP14Parser::ExpressionContext::ExpressionContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector CPP14Parser::ExpressionContext::assignmentExpression() { + return getRuleContexts(); +} + +CPP14Parser::AssignmentExpressionContext* CPP14Parser::ExpressionContext::assignmentExpression(size_t i) { + return getRuleContext(i); +} + +std::vector CPP14Parser::ExpressionContext::Comma() { + return getTokens(CPP14Parser::Comma); +} + +tree::TerminalNode* CPP14Parser::ExpressionContext::Comma(size_t i) { + return getToken(CPP14Parser::Comma, i); +} + + +size_t CPP14Parser::ExpressionContext::getRuleIndex() const { + return CPP14Parser::RuleExpression; +} + + +CPP14Parser::ExpressionContext* CPP14Parser::expression() { + ExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 90, CPP14Parser::RuleExpression); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(825); + assignmentExpression(); + setState(830); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == CPP14Parser::Comma) { + setState(826); + match(CPP14Parser::Comma); + setState(827); + assignmentExpression(); + setState(832); + _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; +} + +//----------------- ConstantExpressionContext ------------------------------------------------------------------ + +CPP14Parser::ConstantExpressionContext::ConstantExpressionContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::ConditionalExpressionContext* CPP14Parser::ConstantExpressionContext::conditionalExpression() { + return getRuleContext(0); +} + + +size_t CPP14Parser::ConstantExpressionContext::getRuleIndex() const { + return CPP14Parser::RuleConstantExpression; +} + + +CPP14Parser::ConstantExpressionContext* CPP14Parser::constantExpression() { + ConstantExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 92, CPP14Parser::RuleConstantExpression); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(833); + conditionalExpression(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- StatementContext ------------------------------------------------------------------ + +CPP14Parser::StatementContext::StatementContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::LabeledStatementContext* CPP14Parser::StatementContext::labeledStatement() { + return getRuleContext(0); +} + +CPP14Parser::DeclarationStatementContext* CPP14Parser::StatementContext::declarationStatement() { + return getRuleContext(0); +} + +CPP14Parser::ExpressionStatementContext* CPP14Parser::StatementContext::expressionStatement() { + return getRuleContext(0); +} + +CPP14Parser::CompoundStatementContext* CPP14Parser::StatementContext::compoundStatement() { + return getRuleContext(0); +} + +CPP14Parser::SelectionStatementContext* CPP14Parser::StatementContext::selectionStatement() { + return getRuleContext(0); +} + +CPP14Parser::IterationStatementContext* CPP14Parser::StatementContext::iterationStatement() { + return getRuleContext(0); +} + +CPP14Parser::JumpStatementContext* CPP14Parser::StatementContext::jumpStatement() { + return getRuleContext(0); +} + +CPP14Parser::TryBlockContext* CPP14Parser::StatementContext::tryBlock() { + return getRuleContext(0); +} + +CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::StatementContext::attributeSpecifierSeq() { + return getRuleContext(0); +} + + +size_t CPP14Parser::StatementContext::getRuleIndex() const { + return CPP14Parser::RuleStatement; +} + + +CPP14Parser::StatementContext* CPP14Parser::statement() { + StatementContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 94, CPP14Parser::RuleStatement); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(848); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 75, _ctx)) { + case 1: { + enterOuterAlt(_localctx, 1); + setState(835); + labeledStatement(); + break; + } + + case 2: { + enterOuterAlt(_localctx, 2); + setState(836); + declarationStatement(); + break; + } + + case 3: { + enterOuterAlt(_localctx, 3); + setState(838); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 73, _ctx)) { + case 1: { + setState(837); + attributeSpecifierSeq(); + break; + } + + default: + break; + } + setState(846); + _errHandler->sync(this); + switch (_input->LA(1)) { + case CPP14Parser::IntegerLiteral: + case CPP14Parser::CharacterLiteral: + case CPP14Parser::FloatingLiteral: + case CPP14Parser::StringLiteral: + case CPP14Parser::BooleanLiteral: + case CPP14Parser::PointerLiteral: + case CPP14Parser::UserDefinedLiteral: + case CPP14Parser::Alignof: + case CPP14Parser::Auto: + case CPP14Parser::Bool: + case CPP14Parser::Char: + case CPP14Parser::Char16: + case CPP14Parser::Char32: + case CPP14Parser::Const_cast: + case CPP14Parser::Decltype: + case CPP14Parser::Delete: + case CPP14Parser::Double: + case CPP14Parser::Dynamic_cast: + case CPP14Parser::Float: + case CPP14Parser::Int: + case CPP14Parser::Long: + case CPP14Parser::New: + case CPP14Parser::Noexcept: + case CPP14Parser::Operator: + case CPP14Parser::Reinterpret_cast: + case CPP14Parser::Short: + case CPP14Parser::Signed: + case CPP14Parser::Sizeof: + case CPP14Parser::Static_cast: + case CPP14Parser::This: + case CPP14Parser::Throw: + case CPP14Parser::Typeid_: + case CPP14Parser::Typename_: + case CPP14Parser::Unsigned: + case CPP14Parser::Void: + case CPP14Parser::Wchar: + case CPP14Parser::LeftParen: + case CPP14Parser::LeftBracket: + case CPP14Parser::Plus: + case CPP14Parser::Minus: + case CPP14Parser::Star: + case CPP14Parser::And: + case CPP14Parser::Or: + case CPP14Parser::Tilde: + case CPP14Parser::Not: + case CPP14Parser::PlusPlus: + case CPP14Parser::MinusMinus: + case CPP14Parser::Doublecolon: + case CPP14Parser::Semi: + case CPP14Parser::Identifier: { + setState(840); + expressionStatement(); + break; + } + + case CPP14Parser::LeftBrace: { + setState(841); + compoundStatement(); + break; + } + + case CPP14Parser::If: + case CPP14Parser::Switch: { + setState(842); + selectionStatement(); + break; + } + + case CPP14Parser::Do: + case CPP14Parser::For: + case CPP14Parser::While: { + setState(843); + iterationStatement(); + break; + } + + case CPP14Parser::Break: + case CPP14Parser::Continue: + case CPP14Parser::Goto: + case CPP14Parser::Return: { + setState(844); + jumpStatement(); + break; + } + + case CPP14Parser::Try: { + setState(845); + tryBlock(); + break; + } + + default: + throw NoViableAltException(this); + } + break; + } + + default: + break; + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- LabeledStatementContext ------------------------------------------------------------------ + +CPP14Parser::LabeledStatementContext::LabeledStatementContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::LabeledStatementContext::Colon() { + return getToken(CPP14Parser::Colon, 0); +} + +CPP14Parser::StatementContext* CPP14Parser::LabeledStatementContext::statement() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::LabeledStatementContext::Identifier() { + return getToken(CPP14Parser::Identifier, 0); +} + +tree::TerminalNode* CPP14Parser::LabeledStatementContext::Case() { + return getToken(CPP14Parser::Case, 0); +} + +CPP14Parser::ConstantExpressionContext* CPP14Parser::LabeledStatementContext::constantExpression() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::LabeledStatementContext::Default() { + return getToken(CPP14Parser::Default, 0); +} + +CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::LabeledStatementContext::attributeSpecifierSeq() { + return getRuleContext(0); +} + + +size_t CPP14Parser::LabeledStatementContext::getRuleIndex() const { + return CPP14Parser::RuleLabeledStatement; +} + + +CPP14Parser::LabeledStatementContext* CPP14Parser::labeledStatement() { + LabeledStatementContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 96, CPP14Parser::RuleLabeledStatement); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(851); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Alignas || _la == CPP14Parser::LeftBracket) { + setState(850); + attributeSpecifierSeq(); + } + setState(857); + _errHandler->sync(this); + switch (_input->LA(1)) { + case CPP14Parser::Identifier: { + setState(853); + match(CPP14Parser::Identifier); + break; + } + + case CPP14Parser::Case: { + setState(854); + match(CPP14Parser::Case); + setState(855); + constantExpression(); + break; + } + + case CPP14Parser::Default: { + setState(856); + match(CPP14Parser::Default); + break; + } + + default: + throw NoViableAltException(this); + } + setState(859); + match(CPP14Parser::Colon); + setState(860); + statement(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ExpressionStatementContext ------------------------------------------------------------------ + +CPP14Parser::ExpressionStatementContext::ExpressionStatementContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::ExpressionStatementContext::Semi() { + return getToken(CPP14Parser::Semi, 0); +} + +CPP14Parser::ExpressionContext* CPP14Parser::ExpressionStatementContext::expression() { + return getRuleContext(0); +} + + +size_t CPP14Parser::ExpressionStatementContext::getRuleIndex() const { + return CPP14Parser::RuleExpressionStatement; +} + + +CPP14Parser::ExpressionStatementContext* CPP14Parser::expressionStatement() { + ExpressionStatementContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 98, CPP14Parser::RuleExpressionStatement); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(863); + _errHandler->sync(this); + + _la = _input->LA(1); + if ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 8364979464334764286) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 65)) & 4719772474384133201) != 0) || _la == CPP14Parser::Identifier) { + setState(862); + expression(); + } + setState(865); + match(CPP14Parser::Semi); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- CompoundStatementContext ------------------------------------------------------------------ + +CPP14Parser::CompoundStatementContext::CompoundStatementContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::CompoundStatementContext::LeftBrace() { + return getToken(CPP14Parser::LeftBrace, 0); +} + +tree::TerminalNode* CPP14Parser::CompoundStatementContext::RightBrace() { + return getToken(CPP14Parser::RightBrace, 0); +} + +CPP14Parser::StatementSeqContext* CPP14Parser::CompoundStatementContext::statementSeq() { + return getRuleContext(0); +} + + +size_t CPP14Parser::CompoundStatementContext::getRuleIndex() const { + return CPP14Parser::RuleCompoundStatement; +} + + +CPP14Parser::CompoundStatementContext* CPP14Parser::compoundStatement() { + CompoundStatementContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 100, CPP14Parser::RuleCompoundStatement); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(867); + match(CPP14Parser::LeftBrace); + setState(869); + _errHandler->sync(this); + + _la = _input->LA(1); + if ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & -137360239606498050) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 64)) & -8989184726396829969) != 0) || ((((_la - 128) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 128)) & 25) != 0)) { + setState(868); + statementSeq(); + } + setState(871); + match(CPP14Parser::RightBrace); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- StatementSeqContext ------------------------------------------------------------------ + +CPP14Parser::StatementSeqContext::StatementSeqContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector CPP14Parser::StatementSeqContext::statement() { + return getRuleContexts(); +} + +CPP14Parser::StatementContext* CPP14Parser::StatementSeqContext::statement(size_t i) { + return getRuleContext(i); +} + + +size_t CPP14Parser::StatementSeqContext::getRuleIndex() const { + return CPP14Parser::RuleStatementSeq; +} + + +CPP14Parser::StatementSeqContext* CPP14Parser::statementSeq() { + StatementSeqContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 102, CPP14Parser::RuleStatementSeq); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(874); + _errHandler->sync(this); + _la = _input->LA(1); + do { + setState(873); + statement(); + setState(876); + _errHandler->sync(this); + _la = _input->LA(1); + } while ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & -137360239606498050) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 64)) & -8989184726396829969) != 0) || ((((_la - 128) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 128)) & 25) != 0)); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- SelectionStatementContext ------------------------------------------------------------------ + +CPP14Parser::SelectionStatementContext::SelectionStatementContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::SelectionStatementContext::If() { + return getToken(CPP14Parser::If, 0); +} + +tree::TerminalNode* CPP14Parser::SelectionStatementContext::LeftParen() { + return getToken(CPP14Parser::LeftParen, 0); +} + +CPP14Parser::ConditionContext* CPP14Parser::SelectionStatementContext::condition() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::SelectionStatementContext::RightParen() { + return getToken(CPP14Parser::RightParen, 0); +} + +std::vector CPP14Parser::SelectionStatementContext::statement() { + return getRuleContexts(); +} + +CPP14Parser::StatementContext* CPP14Parser::SelectionStatementContext::statement(size_t i) { + return getRuleContext(i); +} + +tree::TerminalNode* CPP14Parser::SelectionStatementContext::Else() { + return getToken(CPP14Parser::Else, 0); +} + +tree::TerminalNode* CPP14Parser::SelectionStatementContext::Switch() { + return getToken(CPP14Parser::Switch, 0); +} + + +size_t CPP14Parser::SelectionStatementContext::getRuleIndex() const { + return CPP14Parser::RuleSelectionStatement; +} + + +CPP14Parser::SelectionStatementContext* CPP14Parser::selectionStatement() { + SelectionStatementContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 104, CPP14Parser::RuleSelectionStatement); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(893); + _errHandler->sync(this); + switch (_input->LA(1)) { + case CPP14Parser::If: { + enterOuterAlt(_localctx, 1); + setState(878); + match(CPP14Parser::If); + setState(879); + match(CPP14Parser::LeftParen); + setState(880); + condition(); + setState(881); + match(CPP14Parser::RightParen); + setState(882); + statement(); + setState(885); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 81, _ctx)) { + case 1: { + setState(883); + match(CPP14Parser::Else); + setState(884); + statement(); + break; + } + + default: + break; + } + break; + } + + case CPP14Parser::Switch: { + enterOuterAlt(_localctx, 2); + setState(887); + match(CPP14Parser::Switch); + setState(888); + match(CPP14Parser::LeftParen); + setState(889); + condition(); + setState(890); + match(CPP14Parser::RightParen); + setState(891); + statement(); + break; + } + + default: + throw NoViableAltException(this); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ConditionContext ------------------------------------------------------------------ + +CPP14Parser::ConditionContext::ConditionContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::ExpressionContext* CPP14Parser::ConditionContext::expression() { + return getRuleContext(0); +} + +CPP14Parser::DeclSpecifierSeqContext* CPP14Parser::ConditionContext::declSpecifierSeq() { + return getRuleContext(0); +} + +CPP14Parser::DeclaratorContext* CPP14Parser::ConditionContext::declarator() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::ConditionContext::Assign() { + return getToken(CPP14Parser::Assign, 0); +} + +CPP14Parser::InitializerClauseContext* CPP14Parser::ConditionContext::initializerClause() { + return getRuleContext(0); +} + +CPP14Parser::BracedInitListContext* CPP14Parser::ConditionContext::bracedInitList() { + return getRuleContext(0); +} + +CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::ConditionContext::attributeSpecifierSeq() { + return getRuleContext(0); +} + + +size_t CPP14Parser::ConditionContext::getRuleIndex() const { + return CPP14Parser::RuleCondition; +} + + +CPP14Parser::ConditionContext* CPP14Parser::condition() { + ConditionContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 106, CPP14Parser::RuleCondition); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(906); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 85, _ctx)) { + case 1: { + enterOuterAlt(_localctx, 1); + setState(895); + expression(); + break; + } + + case 2: { + enterOuterAlt(_localctx, 2); + setState(897); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Alignas || _la == CPP14Parser::LeftBracket) { + setState(896); + attributeSpecifierSeq(); + } + setState(899); + declSpecifierSeq(); + setState(900); + declarator(); + setState(904); + _errHandler->sync(this); + switch (_input->LA(1)) { + case CPP14Parser::Assign: { + setState(901); + match(CPP14Parser::Assign); + setState(902); + initializerClause(); + break; + } + + case CPP14Parser::LeftBrace: { + setState(903); + bracedInitList(); + break; + } + + default: + throw NoViableAltException(this); + } + break; + } + + default: + break; + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- IterationStatementContext ------------------------------------------------------------------ + +CPP14Parser::IterationStatementContext::IterationStatementContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::IterationStatementContext::While() { + return getToken(CPP14Parser::While, 0); +} + +tree::TerminalNode* CPP14Parser::IterationStatementContext::LeftParen() { + return getToken(CPP14Parser::LeftParen, 0); +} + +CPP14Parser::ConditionContext* CPP14Parser::IterationStatementContext::condition() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::IterationStatementContext::RightParen() { + return getToken(CPP14Parser::RightParen, 0); +} + +CPP14Parser::StatementContext* CPP14Parser::IterationStatementContext::statement() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::IterationStatementContext::Do() { + return getToken(CPP14Parser::Do, 0); +} + +CPP14Parser::ExpressionContext* CPP14Parser::IterationStatementContext::expression() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::IterationStatementContext::Semi() { + return getToken(CPP14Parser::Semi, 0); +} + +tree::TerminalNode* CPP14Parser::IterationStatementContext::For() { + return getToken(CPP14Parser::For, 0); +} + +CPP14Parser::ForInitStatementContext* CPP14Parser::IterationStatementContext::forInitStatement() { + return getRuleContext(0); +} + +CPP14Parser::ForRangeDeclarationContext* CPP14Parser::IterationStatementContext::forRangeDeclaration() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::IterationStatementContext::Colon() { + return getToken(CPP14Parser::Colon, 0); +} + +CPP14Parser::ForRangeInitializerContext* CPP14Parser::IterationStatementContext::forRangeInitializer() { + return getRuleContext(0); +} + + +size_t CPP14Parser::IterationStatementContext::getRuleIndex() const { + return CPP14Parser::RuleIterationStatement; +} + + +CPP14Parser::IterationStatementContext* CPP14Parser::iterationStatement() { + IterationStatementContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 108, CPP14Parser::RuleIterationStatement); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(941); + _errHandler->sync(this); + switch (_input->LA(1)) { + case CPP14Parser::While: { + enterOuterAlt(_localctx, 1); + setState(908); + match(CPP14Parser::While); + setState(909); + match(CPP14Parser::LeftParen); + setState(910); + condition(); + setState(911); + match(CPP14Parser::RightParen); + setState(912); + statement(); + break; + } + + case CPP14Parser::Do: { + enterOuterAlt(_localctx, 2); + setState(914); + match(CPP14Parser::Do); + setState(915); + statement(); + setState(916); + match(CPP14Parser::While); + setState(917); + match(CPP14Parser::LeftParen); + setState(918); + expression(); + setState(919); + match(CPP14Parser::RightParen); + setState(920); + match(CPP14Parser::Semi); + break; + } + + case CPP14Parser::For: { + enterOuterAlt(_localctx, 3); + setState(922); + match(CPP14Parser::For); + setState(923); + match(CPP14Parser::LeftParen); + setState(936); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 88, _ctx)) { + case 1: { + setState(924); + forInitStatement(); + setState(926); + _errHandler->sync(this); + + _la = _input->LA(1); + if ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & -714116761242538754) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 65)) & 4719772474384301683) != 0) || _la == CPP14Parser::Identifier) { + setState(925); + condition(); + } + setState(928); + match(CPP14Parser::Semi); + setState(930); + _errHandler->sync(this); + + _la = _input->LA(1); + if ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 8364979464334764286) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 65)) & 4719772474384133201) != 0) || _la == CPP14Parser::Identifier) { + setState(929); + expression(); + } + break; + } + + case 2: { + setState(932); + forRangeDeclaration(); + setState(933); + match(CPP14Parser::Colon); + setState(934); + forRangeInitializer(); + break; + } + + default: + break; + } + setState(938); + match(CPP14Parser::RightParen); + setState(939); + statement(); + break; + } + + default: + throw NoViableAltException(this); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ForInitStatementContext ------------------------------------------------------------------ + +CPP14Parser::ForInitStatementContext::ForInitStatementContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::ExpressionStatementContext* CPP14Parser::ForInitStatementContext::expressionStatement() { + return getRuleContext(0); +} + +CPP14Parser::SimpleDeclarationContext* CPP14Parser::ForInitStatementContext::simpleDeclaration() { + return getRuleContext(0); +} + + +size_t CPP14Parser::ForInitStatementContext::getRuleIndex() const { + return CPP14Parser::RuleForInitStatement; +} + + +CPP14Parser::ForInitStatementContext* CPP14Parser::forInitStatement() { + ForInitStatementContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 110, CPP14Parser::RuleForInitStatement); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(945); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 90, _ctx)) { + case 1: { + enterOuterAlt(_localctx, 1); + setState(943); + expressionStatement(); + break; + } + + case 2: { + enterOuterAlt(_localctx, 2); + setState(944); + simpleDeclaration(); + break; + } + + default: + break; + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ForRangeDeclarationContext ------------------------------------------------------------------ + +CPP14Parser::ForRangeDeclarationContext::ForRangeDeclarationContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::DeclSpecifierSeqContext* CPP14Parser::ForRangeDeclarationContext::declSpecifierSeq() { + return getRuleContext(0); +} + +CPP14Parser::DeclaratorContext* CPP14Parser::ForRangeDeclarationContext::declarator() { + return getRuleContext(0); +} + +CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::ForRangeDeclarationContext::attributeSpecifierSeq() { + return getRuleContext(0); +} + + +size_t CPP14Parser::ForRangeDeclarationContext::getRuleIndex() const { + return CPP14Parser::RuleForRangeDeclaration; +} + + +CPP14Parser::ForRangeDeclarationContext* CPP14Parser::forRangeDeclaration() { + ForRangeDeclarationContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 112, CPP14Parser::RuleForRangeDeclaration); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(948); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Alignas || _la == CPP14Parser::LeftBracket) { + setState(947); + attributeSpecifierSeq(); + } + setState(950); + declSpecifierSeq(); + setState(951); + declarator(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ForRangeInitializerContext ------------------------------------------------------------------ + +CPP14Parser::ForRangeInitializerContext::ForRangeInitializerContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::ExpressionContext* CPP14Parser::ForRangeInitializerContext::expression() { + return getRuleContext(0); +} + +CPP14Parser::BracedInitListContext* CPP14Parser::ForRangeInitializerContext::bracedInitList() { + return getRuleContext(0); +} + + +size_t CPP14Parser::ForRangeInitializerContext::getRuleIndex() const { + return CPP14Parser::RuleForRangeInitializer; +} + + +CPP14Parser::ForRangeInitializerContext* CPP14Parser::forRangeInitializer() { + ForRangeInitializerContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 114, CPP14Parser::RuleForRangeInitializer); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(955); + _errHandler->sync(this); + switch (_input->LA(1)) { + case CPP14Parser::IntegerLiteral: + case CPP14Parser::CharacterLiteral: + case CPP14Parser::FloatingLiteral: + case CPP14Parser::StringLiteral: + case CPP14Parser::BooleanLiteral: + case CPP14Parser::PointerLiteral: + case CPP14Parser::UserDefinedLiteral: + case CPP14Parser::Alignof: + case CPP14Parser::Auto: + case CPP14Parser::Bool: + case CPP14Parser::Char: + case CPP14Parser::Char16: + case CPP14Parser::Char32: + case CPP14Parser::Const_cast: + case CPP14Parser::Decltype: + case CPP14Parser::Delete: + case CPP14Parser::Double: + case CPP14Parser::Dynamic_cast: + case CPP14Parser::Float: + case CPP14Parser::Int: + case CPP14Parser::Long: + case CPP14Parser::New: + case CPP14Parser::Noexcept: + case CPP14Parser::Operator: + case CPP14Parser::Reinterpret_cast: + case CPP14Parser::Short: + case CPP14Parser::Signed: + case CPP14Parser::Sizeof: + case CPP14Parser::Static_cast: + case CPP14Parser::This: + case CPP14Parser::Throw: + case CPP14Parser::Typeid_: + case CPP14Parser::Typename_: + case CPP14Parser::Unsigned: + case CPP14Parser::Void: + case CPP14Parser::Wchar: + case CPP14Parser::LeftParen: + case CPP14Parser::LeftBracket: + case CPP14Parser::Plus: + case CPP14Parser::Minus: + case CPP14Parser::Star: + case CPP14Parser::And: + case CPP14Parser::Or: + case CPP14Parser::Tilde: + case CPP14Parser::Not: + case CPP14Parser::PlusPlus: + case CPP14Parser::MinusMinus: + case CPP14Parser::Doublecolon: + case CPP14Parser::Identifier: { + enterOuterAlt(_localctx, 1); + setState(953); + expression(); + break; + } + + case CPP14Parser::LeftBrace: { + enterOuterAlt(_localctx, 2); + setState(954); + bracedInitList(); + break; + } + + default: + throw NoViableAltException(this); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- JumpStatementContext ------------------------------------------------------------------ + +CPP14Parser::JumpStatementContext::JumpStatementContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::JumpStatementContext::Semi() { + return getToken(CPP14Parser::Semi, 0); +} + +tree::TerminalNode* CPP14Parser::JumpStatementContext::Break() { + return getToken(CPP14Parser::Break, 0); +} + +tree::TerminalNode* CPP14Parser::JumpStatementContext::Continue() { + return getToken(CPP14Parser::Continue, 0); +} + +tree::TerminalNode* CPP14Parser::JumpStatementContext::Return() { + return getToken(CPP14Parser::Return, 0); +} + +tree::TerminalNode* CPP14Parser::JumpStatementContext::Goto() { + return getToken(CPP14Parser::Goto, 0); +} + +tree::TerminalNode* CPP14Parser::JumpStatementContext::Identifier() { + return getToken(CPP14Parser::Identifier, 0); +} + +CPP14Parser::ExpressionContext* CPP14Parser::JumpStatementContext::expression() { + return getRuleContext(0); +} + +CPP14Parser::BracedInitListContext* CPP14Parser::JumpStatementContext::bracedInitList() { + return getRuleContext(0); +} + + +size_t CPP14Parser::JumpStatementContext::getRuleIndex() const { + return CPP14Parser::RuleJumpStatement; +} + + +CPP14Parser::JumpStatementContext* CPP14Parser::jumpStatement() { + JumpStatementContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 116, CPP14Parser::RuleJumpStatement); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(966); + _errHandler->sync(this); + switch (_input->LA(1)) { + case CPP14Parser::Break: { + setState(957); + match(CPP14Parser::Break); + break; + } + + case CPP14Parser::Continue: { + setState(958); + match(CPP14Parser::Continue); + break; + } + + case CPP14Parser::Return: { + setState(959); + match(CPP14Parser::Return); + setState(962); + _errHandler->sync(this); + switch (_input->LA(1)) { + case CPP14Parser::IntegerLiteral: + case CPP14Parser::CharacterLiteral: + case CPP14Parser::FloatingLiteral: + case CPP14Parser::StringLiteral: + case CPP14Parser::BooleanLiteral: + case CPP14Parser::PointerLiteral: + case CPP14Parser::UserDefinedLiteral: + case CPP14Parser::Alignof: + case CPP14Parser::Auto: + case CPP14Parser::Bool: + case CPP14Parser::Char: + case CPP14Parser::Char16: + case CPP14Parser::Char32: + case CPP14Parser::Const_cast: + case CPP14Parser::Decltype: + case CPP14Parser::Delete: + case CPP14Parser::Double: + case CPP14Parser::Dynamic_cast: + case CPP14Parser::Float: + case CPP14Parser::Int: + case CPP14Parser::Long: + case CPP14Parser::New: + case CPP14Parser::Noexcept: + case CPP14Parser::Operator: + case CPP14Parser::Reinterpret_cast: + case CPP14Parser::Short: + case CPP14Parser::Signed: + case CPP14Parser::Sizeof: + case CPP14Parser::Static_cast: + case CPP14Parser::This: + case CPP14Parser::Throw: + case CPP14Parser::Typeid_: + case CPP14Parser::Typename_: + case CPP14Parser::Unsigned: + case CPP14Parser::Void: + case CPP14Parser::Wchar: + case CPP14Parser::LeftParen: + case CPP14Parser::LeftBracket: + case CPP14Parser::Plus: + case CPP14Parser::Minus: + case CPP14Parser::Star: + case CPP14Parser::And: + case CPP14Parser::Or: + case CPP14Parser::Tilde: + case CPP14Parser::Not: + case CPP14Parser::PlusPlus: + case CPP14Parser::MinusMinus: + case CPP14Parser::Doublecolon: + case CPP14Parser::Identifier: { + setState(960); + expression(); + break; + } + + case CPP14Parser::LeftBrace: { + setState(961); + bracedInitList(); + break; + } + + case CPP14Parser::Semi: { + break; + } + + default: + break; + } + break; + } + + case CPP14Parser::Goto: { + setState(964); + match(CPP14Parser::Goto); + setState(965); + match(CPP14Parser::Identifier); + break; + } + + default: + throw NoViableAltException(this); + } + setState(968); + match(CPP14Parser::Semi); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- DeclarationStatementContext ------------------------------------------------------------------ + +CPP14Parser::DeclarationStatementContext::DeclarationStatementContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::BlockDeclarationContext* CPP14Parser::DeclarationStatementContext::blockDeclaration() { + return getRuleContext(0); +} + + +size_t CPP14Parser::DeclarationStatementContext::getRuleIndex() const { + return CPP14Parser::RuleDeclarationStatement; +} + + +CPP14Parser::DeclarationStatementContext* CPP14Parser::declarationStatement() { + DeclarationStatementContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 118, CPP14Parser::RuleDeclarationStatement); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(970); + blockDeclaration(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- DeclarationseqContext ------------------------------------------------------------------ + +CPP14Parser::DeclarationseqContext::DeclarationseqContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector CPP14Parser::DeclarationseqContext::declaration() { + return getRuleContexts(); +} + +CPP14Parser::DeclarationContext* CPP14Parser::DeclarationseqContext::declaration(size_t i) { + return getRuleContext(i); +} + + +size_t CPP14Parser::DeclarationseqContext::getRuleIndex() const { + return CPP14Parser::RuleDeclarationseq; +} + + +CPP14Parser::DeclarationseqContext* CPP14Parser::declarationseq() { + DeclarationseqContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 120, CPP14Parser::RuleDeclarationseq); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(973); + _errHandler->sync(this); + _la = _input->LA(1); + do { + setState(972); + declaration(); + setState(975); + _errHandler->sync(this); + _la = _input->LA(1); + } while (((((_la - 10) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 10)) & 1543754443169808157) != 0) || ((((_la - 74) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 74)) & 459384754220313597) != 0)); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- DeclarationContext ------------------------------------------------------------------ + +CPP14Parser::DeclarationContext::DeclarationContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::BlockDeclarationContext* CPP14Parser::DeclarationContext::blockDeclaration() { + return getRuleContext(0); +} + +CPP14Parser::FunctionDefinitionContext* CPP14Parser::DeclarationContext::functionDefinition() { + return getRuleContext(0); +} + +CPP14Parser::TemplateDeclarationContext* CPP14Parser::DeclarationContext::templateDeclaration() { + return getRuleContext(0); +} + +CPP14Parser::ExplicitInstantiationContext* CPP14Parser::DeclarationContext::explicitInstantiation() { + return getRuleContext(0); +} + +CPP14Parser::ExplicitSpecializationContext* CPP14Parser::DeclarationContext::explicitSpecialization() { + return getRuleContext(0); +} + +CPP14Parser::LinkageSpecificationContext* CPP14Parser::DeclarationContext::linkageSpecification() { + return getRuleContext(0); +} + +CPP14Parser::NamespaceDefinitionContext* CPP14Parser::DeclarationContext::namespaceDefinition() { + return getRuleContext(0); +} + +CPP14Parser::EmptyDeclarationContext* CPP14Parser::DeclarationContext::emptyDeclaration() { + return getRuleContext(0); +} + +CPP14Parser::AttributeDeclarationContext* CPP14Parser::DeclarationContext::attributeDeclaration() { + return getRuleContext(0); +} + + +size_t CPP14Parser::DeclarationContext::getRuleIndex() const { + return CPP14Parser::RuleDeclaration; +} + + +CPP14Parser::DeclarationContext* CPP14Parser::declaration() { + DeclarationContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 122, CPP14Parser::RuleDeclaration); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(986); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 96, _ctx)) { + case 1: { + enterOuterAlt(_localctx, 1); + setState(977); + blockDeclaration(); + break; + } + + case 2: { + enterOuterAlt(_localctx, 2); + setState(978); + functionDefinition(); + break; + } + + case 3: { + enterOuterAlt(_localctx, 3); + setState(979); + templateDeclaration(); + break; + } + + case 4: { + enterOuterAlt(_localctx, 4); + setState(980); + explicitInstantiation(); + break; + } + + case 5: { + enterOuterAlt(_localctx, 5); + setState(981); + explicitSpecialization(); + break; + } + + case 6: { + enterOuterAlt(_localctx, 6); + setState(982); + linkageSpecification(); + break; + } + + case 7: { + enterOuterAlt(_localctx, 7); + setState(983); + namespaceDefinition(); + break; + } + + case 8: { + enterOuterAlt(_localctx, 8); + setState(984); + emptyDeclaration(); + break; + } + + case 9: { + enterOuterAlt(_localctx, 9); + setState(985); + attributeDeclaration(); + break; + } + + default: + break; + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- BlockDeclarationContext ------------------------------------------------------------------ + +CPP14Parser::BlockDeclarationContext::BlockDeclarationContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::SimpleDeclarationContext* CPP14Parser::BlockDeclarationContext::simpleDeclaration() { + return getRuleContext(0); +} + +CPP14Parser::AsmDefinitionContext* CPP14Parser::BlockDeclarationContext::asmDefinition() { + return getRuleContext(0); +} + +CPP14Parser::NamespaceAliasDefinitionContext* CPP14Parser::BlockDeclarationContext::namespaceAliasDefinition() { + return getRuleContext(0); +} + +CPP14Parser::UsingDeclarationContext* CPP14Parser::BlockDeclarationContext::usingDeclaration() { + return getRuleContext(0); +} + +CPP14Parser::UsingDirectiveContext* CPP14Parser::BlockDeclarationContext::usingDirective() { + return getRuleContext(0); +} + +CPP14Parser::StaticAssertDeclarationContext* CPP14Parser::BlockDeclarationContext::staticAssertDeclaration() { + return getRuleContext(0); +} + +CPP14Parser::AliasDeclarationContext* CPP14Parser::BlockDeclarationContext::aliasDeclaration() { + return getRuleContext(0); +} + +CPP14Parser::OpaqueEnumDeclarationContext* CPP14Parser::BlockDeclarationContext::opaqueEnumDeclaration() { + return getRuleContext(0); +} + + +size_t CPP14Parser::BlockDeclarationContext::getRuleIndex() const { + return CPP14Parser::RuleBlockDeclaration; +} + + +CPP14Parser::BlockDeclarationContext* CPP14Parser::blockDeclaration() { + BlockDeclarationContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 124, CPP14Parser::RuleBlockDeclaration); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(996); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 97, _ctx)) { + case 1: { + enterOuterAlt(_localctx, 1); + setState(988); + simpleDeclaration(); + break; + } + + case 2: { + enterOuterAlt(_localctx, 2); + setState(989); + asmDefinition(); + break; + } + + case 3: { + enterOuterAlt(_localctx, 3); + setState(990); + namespaceAliasDefinition(); + break; + } + + case 4: { + enterOuterAlt(_localctx, 4); + setState(991); + usingDeclaration(); + break; + } + + case 5: { + enterOuterAlt(_localctx, 5); + setState(992); + usingDirective(); + break; + } + + case 6: { + enterOuterAlt(_localctx, 6); + setState(993); + staticAssertDeclaration(); + break; + } + + case 7: { + enterOuterAlt(_localctx, 7); + setState(994); + aliasDeclaration(); + break; + } + + case 8: { + enterOuterAlt(_localctx, 8); + setState(995); + opaqueEnumDeclaration(); + break; + } + + default: + break; + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- AliasDeclarationContext ------------------------------------------------------------------ + +CPP14Parser::AliasDeclarationContext::AliasDeclarationContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::AliasDeclarationContext::Using() { + return getToken(CPP14Parser::Using, 0); +} + +tree::TerminalNode* CPP14Parser::AliasDeclarationContext::Identifier() { + return getToken(CPP14Parser::Identifier, 0); +} + +tree::TerminalNode* CPP14Parser::AliasDeclarationContext::Assign() { + return getToken(CPP14Parser::Assign, 0); +} + +CPP14Parser::TheTypeIdContext* CPP14Parser::AliasDeclarationContext::theTypeId() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::AliasDeclarationContext::Semi() { + return getToken(CPP14Parser::Semi, 0); +} + +CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::AliasDeclarationContext::attributeSpecifierSeq() { + return getRuleContext(0); +} + + +size_t CPP14Parser::AliasDeclarationContext::getRuleIndex() const { + return CPP14Parser::RuleAliasDeclaration; +} + + +CPP14Parser::AliasDeclarationContext* CPP14Parser::aliasDeclaration() { + AliasDeclarationContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 126, CPP14Parser::RuleAliasDeclaration); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(998); + match(CPP14Parser::Using); + setState(999); + match(CPP14Parser::Identifier); + setState(1001); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Alignas || _la == CPP14Parser::LeftBracket) { + setState(1000); + attributeSpecifierSeq(); + } + setState(1003); + match(CPP14Parser::Assign); + setState(1004); + theTypeId(); + setState(1005); + match(CPP14Parser::Semi); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- SimpleDeclarationContext ------------------------------------------------------------------ + +CPP14Parser::SimpleDeclarationContext::SimpleDeclarationContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::SimpleDeclarationContext::Semi() { + return getToken(CPP14Parser::Semi, 0); +} + +CPP14Parser::DeclSpecifierSeqContext* CPP14Parser::SimpleDeclarationContext::declSpecifierSeq() { + return getRuleContext(0); +} + +CPP14Parser::InitDeclaratorListContext* CPP14Parser::SimpleDeclarationContext::initDeclaratorList() { + return getRuleContext(0); +} + +CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::SimpleDeclarationContext::attributeSpecifierSeq() { + return getRuleContext(0); +} + + +size_t CPP14Parser::SimpleDeclarationContext::getRuleIndex() const { + return CPP14Parser::RuleSimpleDeclaration; +} + + +CPP14Parser::SimpleDeclarationContext* CPP14Parser::simpleDeclaration() { + SimpleDeclarationContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 128, CPP14Parser::RuleSimpleDeclaration); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(1021); + _errHandler->sync(this); + switch (_input->LA(1)) { + case CPP14Parser::Auto: + case CPP14Parser::Bool: + case CPP14Parser::Char: + case CPP14Parser::Char16: + case CPP14Parser::Char32: + case CPP14Parser::Class: + case CPP14Parser::Const: + case CPP14Parser::Constexpr: + case CPP14Parser::Decltype: + case CPP14Parser::Double: + case CPP14Parser::Enum: + case CPP14Parser::Explicit: + case CPP14Parser::Extern: + case CPP14Parser::Float: + case CPP14Parser::Friend: + case CPP14Parser::Inline: + case CPP14Parser::Int: + case CPP14Parser::Long: + case CPP14Parser::Mutable: + case CPP14Parser::Operator: + case CPP14Parser::Register: + case CPP14Parser::Short: + case CPP14Parser::Signed: + case CPP14Parser::Static: + case CPP14Parser::Struct: + case CPP14Parser::Thread_local: + case CPP14Parser::Typedef: + case CPP14Parser::Typename_: + case CPP14Parser::Union: + case CPP14Parser::Unsigned: + case CPP14Parser::Virtual: + case CPP14Parser::Void: + case CPP14Parser::Volatile: + case CPP14Parser::Wchar: + case CPP14Parser::LeftParen: + case CPP14Parser::Star: + case CPP14Parser::And: + case CPP14Parser::Tilde: + case CPP14Parser::AndAnd: + case CPP14Parser::Doublecolon: + case CPP14Parser::Semi: + case CPP14Parser::Ellipsis: + case CPP14Parser::Identifier: { + enterOuterAlt(_localctx, 1); + setState(1008); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 99, _ctx)) { + case 1: { + setState(1007); + declSpecifierSeq(); + break; + } + + default: + break; + } + setState(1011); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Decltype + + || _la == CPP14Parser::Operator || ((((_la - 85) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 85)) & 215512868999425) != 0)) { + setState(1010); + initDeclaratorList(); + } + setState(1013); + match(CPP14Parser::Semi); + break; + } + + case CPP14Parser::Alignas: + case CPP14Parser::LeftBracket: { + enterOuterAlt(_localctx, 2); + setState(1014); + attributeSpecifierSeq(); + setState(1016); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 101, _ctx)) { + case 1: { + setState(1015); + declSpecifierSeq(); + break; + } + + default: + break; + } + setState(1018); + initDeclaratorList(); + setState(1019); + match(CPP14Parser::Semi); + break; + } + + default: + throw NoViableAltException(this); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- StaticAssertDeclarationContext ------------------------------------------------------------------ + +CPP14Parser::StaticAssertDeclarationContext::StaticAssertDeclarationContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::StaticAssertDeclarationContext::Static_assert() { + return getToken(CPP14Parser::Static_assert, 0); +} + +tree::TerminalNode* CPP14Parser::StaticAssertDeclarationContext::LeftParen() { + return getToken(CPP14Parser::LeftParen, 0); +} + +CPP14Parser::ConstantExpressionContext* CPP14Parser::StaticAssertDeclarationContext::constantExpression() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::StaticAssertDeclarationContext::Comma() { + return getToken(CPP14Parser::Comma, 0); +} + +tree::TerminalNode* CPP14Parser::StaticAssertDeclarationContext::StringLiteral() { + return getToken(CPP14Parser::StringLiteral, 0); +} + +tree::TerminalNode* CPP14Parser::StaticAssertDeclarationContext::RightParen() { + return getToken(CPP14Parser::RightParen, 0); +} + +tree::TerminalNode* CPP14Parser::StaticAssertDeclarationContext::Semi() { + return getToken(CPP14Parser::Semi, 0); +} + + +size_t CPP14Parser::StaticAssertDeclarationContext::getRuleIndex() const { + return CPP14Parser::RuleStaticAssertDeclaration; +} + + +CPP14Parser::StaticAssertDeclarationContext* CPP14Parser::staticAssertDeclaration() { + StaticAssertDeclarationContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 130, CPP14Parser::RuleStaticAssertDeclaration); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1023); + match(CPP14Parser::Static_assert); + setState(1024); + match(CPP14Parser::LeftParen); + setState(1025); + constantExpression(); + setState(1026); + match(CPP14Parser::Comma); + setState(1027); + match(CPP14Parser::StringLiteral); + setState(1028); + match(CPP14Parser::RightParen); + setState(1029); + match(CPP14Parser::Semi); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- EmptyDeclarationContext ------------------------------------------------------------------ + +CPP14Parser::EmptyDeclarationContext::EmptyDeclarationContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::EmptyDeclarationContext::Semi() { + return getToken(CPP14Parser::Semi, 0); +} + + +size_t CPP14Parser::EmptyDeclarationContext::getRuleIndex() const { + return CPP14Parser::RuleEmptyDeclaration; +} + + +CPP14Parser::EmptyDeclarationContext* CPP14Parser::emptyDeclaration() { + EmptyDeclarationContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 132, CPP14Parser::RuleEmptyDeclaration); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1031); + match(CPP14Parser::Semi); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- AttributeDeclarationContext ------------------------------------------------------------------ + +CPP14Parser::AttributeDeclarationContext::AttributeDeclarationContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::AttributeDeclarationContext::attributeSpecifierSeq() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::AttributeDeclarationContext::Semi() { + return getToken(CPP14Parser::Semi, 0); +} + + +size_t CPP14Parser::AttributeDeclarationContext::getRuleIndex() const { + return CPP14Parser::RuleAttributeDeclaration; +} + + +CPP14Parser::AttributeDeclarationContext* CPP14Parser::attributeDeclaration() { + AttributeDeclarationContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 134, CPP14Parser::RuleAttributeDeclaration); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1033); + attributeSpecifierSeq(); + setState(1034); + match(CPP14Parser::Semi); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- DeclSpecifierContext ------------------------------------------------------------------ + +CPP14Parser::DeclSpecifierContext::DeclSpecifierContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::StorageClassSpecifierContext* CPP14Parser::DeclSpecifierContext::storageClassSpecifier() { + return getRuleContext(0); +} + +CPP14Parser::TypeSpecifierContext* CPP14Parser::DeclSpecifierContext::typeSpecifier() { + return getRuleContext(0); +} + +CPP14Parser::FunctionSpecifierContext* CPP14Parser::DeclSpecifierContext::functionSpecifier() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::DeclSpecifierContext::Friend() { + return getToken(CPP14Parser::Friend, 0); +} + +tree::TerminalNode* CPP14Parser::DeclSpecifierContext::Typedef() { + return getToken(CPP14Parser::Typedef, 0); +} + +tree::TerminalNode* CPP14Parser::DeclSpecifierContext::Constexpr() { + return getToken(CPP14Parser::Constexpr, 0); +} + + +size_t CPP14Parser::DeclSpecifierContext::getRuleIndex() const { + return CPP14Parser::RuleDeclSpecifier; +} + + +CPP14Parser::DeclSpecifierContext* CPP14Parser::declSpecifier() { + DeclSpecifierContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 136, CPP14Parser::RuleDeclSpecifier); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(1042); + _errHandler->sync(this); + switch (_input->LA(1)) { + case CPP14Parser::Extern: + case CPP14Parser::Mutable: + case CPP14Parser::Register: + case CPP14Parser::Static: + case CPP14Parser::Thread_local: { + enterOuterAlt(_localctx, 1); + setState(1036); + storageClassSpecifier(); + break; + } + + case CPP14Parser::Auto: + case CPP14Parser::Bool: + case CPP14Parser::Char: + case CPP14Parser::Char16: + case CPP14Parser::Char32: + case CPP14Parser::Class: + case CPP14Parser::Const: + case CPP14Parser::Decltype: + case CPP14Parser::Double: + case CPP14Parser::Enum: + case CPP14Parser::Float: + case CPP14Parser::Int: + case CPP14Parser::Long: + case CPP14Parser::Short: + case CPP14Parser::Signed: + case CPP14Parser::Struct: + case CPP14Parser::Typename_: + case CPP14Parser::Union: + case CPP14Parser::Unsigned: + case CPP14Parser::Void: + case CPP14Parser::Volatile: + case CPP14Parser::Wchar: + case CPP14Parser::Doublecolon: + case CPP14Parser::Identifier: { + enterOuterAlt(_localctx, 2); + setState(1037); + typeSpecifier(); + break; + } + + case CPP14Parser::Explicit: + case CPP14Parser::Inline: + case CPP14Parser::Virtual: { + enterOuterAlt(_localctx, 3); + setState(1038); + functionSpecifier(); + break; + } + + case CPP14Parser::Friend: { + enterOuterAlt(_localctx, 4); + setState(1039); + match(CPP14Parser::Friend); + break; + } + + case CPP14Parser::Typedef: { + enterOuterAlt(_localctx, 5); + setState(1040); + match(CPP14Parser::Typedef); + break; + } + + case CPP14Parser::Constexpr: { + enterOuterAlt(_localctx, 6); + setState(1041); + match(CPP14Parser::Constexpr); + break; + } + + default: + throw NoViableAltException(this); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- DeclSpecifierSeqContext ------------------------------------------------------------------ + +CPP14Parser::DeclSpecifierSeqContext::DeclSpecifierSeqContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector CPP14Parser::DeclSpecifierSeqContext::declSpecifier() { + return getRuleContexts(); +} + +CPP14Parser::DeclSpecifierContext* CPP14Parser::DeclSpecifierSeqContext::declSpecifier(size_t i) { + return getRuleContext(i); +} + +CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::DeclSpecifierSeqContext::attributeSpecifierSeq() { + return getRuleContext(0); +} + + +size_t CPP14Parser::DeclSpecifierSeqContext::getRuleIndex() const { + return CPP14Parser::RuleDeclSpecifierSeq; +} + + +CPP14Parser::DeclSpecifierSeqContext* CPP14Parser::declSpecifierSeq() { + DeclSpecifierSeqContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 138, CPP14Parser::RuleDeclSpecifierSeq); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + size_t alt; + enterOuterAlt(_localctx, 1); + setState(1045); + _errHandler->sync(this); + alt = 1 + 1; + do { + switch (alt) { + case 1 + 1: { + setState(1044); + declSpecifier(); + break; + } + + default: + throw NoViableAltException(this); + } + setState(1047); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 104, _ctx); + } while (alt != 1 && alt != atn::ATN::INVALID_ALT_NUMBER); + setState(1050); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 105, _ctx)) { + case 1: { + setState(1049); + attributeSpecifierSeq(); + break; + } + + default: + break; + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- StorageClassSpecifierContext ------------------------------------------------------------------ + +CPP14Parser::StorageClassSpecifierContext::StorageClassSpecifierContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::StorageClassSpecifierContext::Register() { + return getToken(CPP14Parser::Register, 0); +} + +tree::TerminalNode* CPP14Parser::StorageClassSpecifierContext::Static() { + return getToken(CPP14Parser::Static, 0); +} + +tree::TerminalNode* CPP14Parser::StorageClassSpecifierContext::Thread_local() { + return getToken(CPP14Parser::Thread_local, 0); +} + +tree::TerminalNode* CPP14Parser::StorageClassSpecifierContext::Extern() { + return getToken(CPP14Parser::Extern, 0); +} + +tree::TerminalNode* CPP14Parser::StorageClassSpecifierContext::Mutable() { + return getToken(CPP14Parser::Mutable, 0); +} + + +size_t CPP14Parser::StorageClassSpecifierContext::getRuleIndex() const { + return CPP14Parser::RuleStorageClassSpecifier; +} + + +CPP14Parser::StorageClassSpecifierContext* CPP14Parser::storageClassSpecifier() { + StorageClassSpecifierContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 140, CPP14Parser::RuleStorageClassSpecifier); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1052); + _la = _input->LA(1); + if (!(((((_la - 36) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 36)) & 17316186113) != 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; +} + +//----------------- FunctionSpecifierContext ------------------------------------------------------------------ + +CPP14Parser::FunctionSpecifierContext::FunctionSpecifierContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::FunctionSpecifierContext::Inline() { + return getToken(CPP14Parser::Inline, 0); +} + +tree::TerminalNode* CPP14Parser::FunctionSpecifierContext::Virtual() { + return getToken(CPP14Parser::Virtual, 0); +} + +tree::TerminalNode* CPP14Parser::FunctionSpecifierContext::Explicit() { + return getToken(CPP14Parser::Explicit, 0); +} + + +size_t CPP14Parser::FunctionSpecifierContext::getRuleIndex() const { + return CPP14Parser::RuleFunctionSpecifier; +} + + +CPP14Parser::FunctionSpecifierContext* CPP14Parser::functionSpecifier() { + FunctionSpecifierContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 142, CPP14Parser::RuleFunctionSpecifier); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1054); + _la = _input->LA(1); + if (!(((((_la - 34) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 34)) & 70368744178689) != 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; +} + +//----------------- TypedefNameContext ------------------------------------------------------------------ + +CPP14Parser::TypedefNameContext::TypedefNameContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::TypedefNameContext::Identifier() { + return getToken(CPP14Parser::Identifier, 0); +} + + +size_t CPP14Parser::TypedefNameContext::getRuleIndex() const { + return CPP14Parser::RuleTypedefName; +} + + +CPP14Parser::TypedefNameContext* CPP14Parser::typedefName() { + TypedefNameContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 144, CPP14Parser::RuleTypedefName); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1056); + match(CPP14Parser::Identifier); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- TypeSpecifierContext ------------------------------------------------------------------ + +CPP14Parser::TypeSpecifierContext::TypeSpecifierContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::TrailingTypeSpecifierContext* CPP14Parser::TypeSpecifierContext::trailingTypeSpecifier() { + return getRuleContext(0); +} + +CPP14Parser::ClassSpecifierContext* CPP14Parser::TypeSpecifierContext::classSpecifier() { + return getRuleContext(0); +} + +CPP14Parser::EnumSpecifierContext* CPP14Parser::TypeSpecifierContext::enumSpecifier() { + return getRuleContext(0); +} + + +size_t CPP14Parser::TypeSpecifierContext::getRuleIndex() const { + return CPP14Parser::RuleTypeSpecifier; +} + + +CPP14Parser::TypeSpecifierContext* CPP14Parser::typeSpecifier() { + TypeSpecifierContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 146, CPP14Parser::RuleTypeSpecifier); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(1061); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 106, _ctx)) { + case 1: { + enterOuterAlt(_localctx, 1); + setState(1058); + trailingTypeSpecifier(); + break; + } + + case 2: { + enterOuterAlt(_localctx, 2); + setState(1059); + classSpecifier(); + break; + } + + case 3: { + enterOuterAlt(_localctx, 3); + setState(1060); + enumSpecifier(); + break; + } + + default: + break; + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- TrailingTypeSpecifierContext ------------------------------------------------------------------ + +CPP14Parser::TrailingTypeSpecifierContext::TrailingTypeSpecifierContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::SimpleTypeSpecifierContext* CPP14Parser::TrailingTypeSpecifierContext::simpleTypeSpecifier() { + return getRuleContext(0); +} + +CPP14Parser::ElaboratedTypeSpecifierContext* CPP14Parser::TrailingTypeSpecifierContext::elaboratedTypeSpecifier() { + return getRuleContext(0); +} + +CPP14Parser::TypeNameSpecifierContext* CPP14Parser::TrailingTypeSpecifierContext::typeNameSpecifier() { + return getRuleContext(0); +} + +CPP14Parser::CvQualifierContext* CPP14Parser::TrailingTypeSpecifierContext::cvQualifier() { + return getRuleContext(0); +} + + +size_t CPP14Parser::TrailingTypeSpecifierContext::getRuleIndex() const { + return CPP14Parser::RuleTrailingTypeSpecifier; +} + + +CPP14Parser::TrailingTypeSpecifierContext* CPP14Parser::trailingTypeSpecifier() { + TrailingTypeSpecifierContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 148, CPP14Parser::RuleTrailingTypeSpecifier); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(1067); + _errHandler->sync(this); + switch (_input->LA(1)) { + case CPP14Parser::Auto: + case CPP14Parser::Bool: + case CPP14Parser::Char: + case CPP14Parser::Char16: + case CPP14Parser::Char32: + case CPP14Parser::Decltype: + case CPP14Parser::Double: + case CPP14Parser::Float: + case CPP14Parser::Int: + case CPP14Parser::Long: + case CPP14Parser::Short: + case CPP14Parser::Signed: + case CPP14Parser::Unsigned: + case CPP14Parser::Void: + case CPP14Parser::Wchar: + case CPP14Parser::Doublecolon: + case CPP14Parser::Identifier: { + enterOuterAlt(_localctx, 1); + setState(1063); + simpleTypeSpecifier(); + break; + } + + case CPP14Parser::Class: + case CPP14Parser::Enum: + case CPP14Parser::Struct: { + enterOuterAlt(_localctx, 2); + setState(1064); + elaboratedTypeSpecifier(); + break; + } + + case CPP14Parser::Typename_: { + enterOuterAlt(_localctx, 3); + setState(1065); + typeNameSpecifier(); + break; + } + + case CPP14Parser::Const: + case CPP14Parser::Volatile: { + enterOuterAlt(_localctx, 4); + setState(1066); + cvQualifier(); + break; + } + + default: + throw NoViableAltException(this); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- TypeSpecifierSeqContext ------------------------------------------------------------------ + +CPP14Parser::TypeSpecifierSeqContext::TypeSpecifierSeqContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector CPP14Parser::TypeSpecifierSeqContext::typeSpecifier() { + return getRuleContexts(); +} + +CPP14Parser::TypeSpecifierContext* CPP14Parser::TypeSpecifierSeqContext::typeSpecifier(size_t i) { + return getRuleContext(i); +} + +CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::TypeSpecifierSeqContext::attributeSpecifierSeq() { + return getRuleContext(0); +} + + +size_t CPP14Parser::TypeSpecifierSeqContext::getRuleIndex() const { + return CPP14Parser::RuleTypeSpecifierSeq; +} + + +CPP14Parser::TypeSpecifierSeqContext* CPP14Parser::typeSpecifierSeq() { + TypeSpecifierSeqContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 150, CPP14Parser::RuleTypeSpecifierSeq); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + size_t alt; + enterOuterAlt(_localctx, 1); + setState(1070); + _errHandler->sync(this); + alt = 1; + do { + switch (alt) { + case 1: { + setState(1069); + typeSpecifier(); + break; + } + + default: + throw NoViableAltException(this); + } + setState(1072); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 108, _ctx); + } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER); + setState(1075); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 109, _ctx)) { + case 1: { + setState(1074); + attributeSpecifierSeq(); + break; + } + + default: + break; + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- TrailingTypeSpecifierSeqContext ------------------------------------------------------------------ + +CPP14Parser::TrailingTypeSpecifierSeqContext::TrailingTypeSpecifierSeqContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector CPP14Parser::TrailingTypeSpecifierSeqContext::trailingTypeSpecifier() { + return getRuleContexts(); +} + +CPP14Parser::TrailingTypeSpecifierContext* CPP14Parser::TrailingTypeSpecifierSeqContext::trailingTypeSpecifier(size_t i) { + return getRuleContext(i); +} + +CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::TrailingTypeSpecifierSeqContext::attributeSpecifierSeq() { + return getRuleContext(0); +} + + +size_t CPP14Parser::TrailingTypeSpecifierSeqContext::getRuleIndex() const { + return CPP14Parser::RuleTrailingTypeSpecifierSeq; +} + + +CPP14Parser::TrailingTypeSpecifierSeqContext* CPP14Parser::trailingTypeSpecifierSeq() { + TrailingTypeSpecifierSeqContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 152, CPP14Parser::RuleTrailingTypeSpecifierSeq); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + size_t alt; + enterOuterAlt(_localctx, 1); + setState(1078); + _errHandler->sync(this); + alt = 1; + do { + switch (alt) { + case 1: { + setState(1077); + trailingTypeSpecifier(); + break; + } + + default: + throw NoViableAltException(this); + } + setState(1080); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 110, _ctx); + } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER); + setState(1083); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 111, _ctx)) { + case 1: { + setState(1082); + attributeSpecifierSeq(); + break; + } + + default: + break; + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- SimpleTypeLengthModifierContext ------------------------------------------------------------------ + +CPP14Parser::SimpleTypeLengthModifierContext::SimpleTypeLengthModifierContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::SimpleTypeLengthModifierContext::Short() { + return getToken(CPP14Parser::Short, 0); +} + +tree::TerminalNode* CPP14Parser::SimpleTypeLengthModifierContext::Long() { + return getToken(CPP14Parser::Long, 0); +} + + +size_t CPP14Parser::SimpleTypeLengthModifierContext::getRuleIndex() const { + return CPP14Parser::RuleSimpleTypeLengthModifier; +} + + +CPP14Parser::SimpleTypeLengthModifierContext* CPP14Parser::simpleTypeLengthModifier() { + SimpleTypeLengthModifierContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 154, CPP14Parser::RuleSimpleTypeLengthModifier); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1085); + _la = _input->LA(1); + if (!(_la == CPP14Parser::Long + + || _la == CPP14Parser::Short)) { + _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; +} + +//----------------- SimpleTypeSignednessModifierContext ------------------------------------------------------------------ + +CPP14Parser::SimpleTypeSignednessModifierContext::SimpleTypeSignednessModifierContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::SimpleTypeSignednessModifierContext::Unsigned() { + return getToken(CPP14Parser::Unsigned, 0); +} + +tree::TerminalNode* CPP14Parser::SimpleTypeSignednessModifierContext::Signed() { + return getToken(CPP14Parser::Signed, 0); +} + + +size_t CPP14Parser::SimpleTypeSignednessModifierContext::getRuleIndex() const { + return CPP14Parser::RuleSimpleTypeSignednessModifier; +} + + +CPP14Parser::SimpleTypeSignednessModifierContext* CPP14Parser::simpleTypeSignednessModifier() { + SimpleTypeSignednessModifierContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 156, CPP14Parser::RuleSimpleTypeSignednessModifier); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1087); + _la = _input->LA(1); + if (!(_la == CPP14Parser::Signed + + || _la == CPP14Parser::Unsigned)) { + _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; +} + +//----------------- SimpleTypeSpecifierContext ------------------------------------------------------------------ + +CPP14Parser::SimpleTypeSpecifierContext::SimpleTypeSpecifierContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::TheTypeNameContext* CPP14Parser::SimpleTypeSpecifierContext::theTypeName() { + return getRuleContext(0); +} + +CPP14Parser::NestedNameSpecifierContext* CPP14Parser::SimpleTypeSpecifierContext::nestedNameSpecifier() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::SimpleTypeSpecifierContext::Template() { + return getToken(CPP14Parser::Template, 0); +} + +CPP14Parser::SimpleTemplateIdContext* CPP14Parser::SimpleTypeSpecifierContext::simpleTemplateId() { + return getRuleContext(0); +} + +CPP14Parser::SimpleTypeSignednessModifierContext* CPP14Parser::SimpleTypeSpecifierContext::simpleTypeSignednessModifier() { + return getRuleContext(0); +} + +std::vector CPP14Parser::SimpleTypeSpecifierContext::simpleTypeLengthModifier() { + return getRuleContexts(); +} + +CPP14Parser::SimpleTypeLengthModifierContext* CPP14Parser::SimpleTypeSpecifierContext::simpleTypeLengthModifier(size_t i) { + return getRuleContext(i); +} + +tree::TerminalNode* CPP14Parser::SimpleTypeSpecifierContext::Char() { + return getToken(CPP14Parser::Char, 0); +} + +tree::TerminalNode* CPP14Parser::SimpleTypeSpecifierContext::Char16() { + return getToken(CPP14Parser::Char16, 0); +} + +tree::TerminalNode* CPP14Parser::SimpleTypeSpecifierContext::Char32() { + return getToken(CPP14Parser::Char32, 0); +} + +tree::TerminalNode* CPP14Parser::SimpleTypeSpecifierContext::Wchar() { + return getToken(CPP14Parser::Wchar, 0); +} + +tree::TerminalNode* CPP14Parser::SimpleTypeSpecifierContext::Bool() { + return getToken(CPP14Parser::Bool, 0); +} + +tree::TerminalNode* CPP14Parser::SimpleTypeSpecifierContext::Int() { + return getToken(CPP14Parser::Int, 0); +} + +tree::TerminalNode* CPP14Parser::SimpleTypeSpecifierContext::Float() { + return getToken(CPP14Parser::Float, 0); +} + +tree::TerminalNode* CPP14Parser::SimpleTypeSpecifierContext::Double() { + return getToken(CPP14Parser::Double, 0); +} + +tree::TerminalNode* CPP14Parser::SimpleTypeSpecifierContext::Void() { + return getToken(CPP14Parser::Void, 0); +} + +tree::TerminalNode* CPP14Parser::SimpleTypeSpecifierContext::Auto() { + return getToken(CPP14Parser::Auto, 0); +} + +CPP14Parser::DecltypeSpecifierContext* CPP14Parser::SimpleTypeSpecifierContext::decltypeSpecifier() { + return getRuleContext(0); +} + + +size_t CPP14Parser::SimpleTypeSpecifierContext::getRuleIndex() const { + return CPP14Parser::RuleSimpleTypeSpecifier; +} + + +CPP14Parser::SimpleTypeSpecifierContext* CPP14Parser::simpleTypeSpecifier() { + SimpleTypeSpecifierContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 158, CPP14Parser::RuleSimpleTypeSpecifier); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + size_t alt; + setState(1141); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 122, _ctx)) { + case 1: { + enterOuterAlt(_localctx, 1); + setState(1090); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 112, _ctx)) { + case 1: { + setState(1089); + nestedNameSpecifier(0); + break; + } + + default: + break; + } + setState(1092); + theTypeName(); + break; + } + + case 2: { + enterOuterAlt(_localctx, 2); + setState(1093); + nestedNameSpecifier(0); + setState(1094); + match(CPP14Parser::Template); + setState(1095); + simpleTemplateId(); + break; + } + + case 3: { + enterOuterAlt(_localctx, 3); + setState(1097); + simpleTypeSignednessModifier(); + break; + } + + case 4: { + enterOuterAlt(_localctx, 4); + setState(1099); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Signed + + || _la == CPP14Parser::Unsigned) { + setState(1098); + simpleTypeSignednessModifier(); + } + setState(1102); + _errHandler->sync(this); + alt = 1; + do { + switch (alt) { + case 1: { + setState(1101); + simpleTypeLengthModifier(); + break; + } + + default: + throw NoViableAltException(this); + } + setState(1104); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 114, _ctx); + } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER); + break; + } + + case 5: { + enterOuterAlt(_localctx, 5); + setState(1107); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Signed + + || _la == CPP14Parser::Unsigned) { + setState(1106); + simpleTypeSignednessModifier(); + } + setState(1109); + match(CPP14Parser::Char); + break; + } + + case 6: { + enterOuterAlt(_localctx, 6); + setState(1111); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Signed + + || _la == CPP14Parser::Unsigned) { + setState(1110); + simpleTypeSignednessModifier(); + } + setState(1113); + match(CPP14Parser::Char16); + break; + } + + case 7: { + enterOuterAlt(_localctx, 7); + setState(1115); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Signed + + || _la == CPP14Parser::Unsigned) { + setState(1114); + simpleTypeSignednessModifier(); + } + setState(1117); + match(CPP14Parser::Char32); + break; + } + + case 8: { + enterOuterAlt(_localctx, 8); + setState(1119); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Signed + + || _la == CPP14Parser::Unsigned) { + setState(1118); + simpleTypeSignednessModifier(); + } + setState(1121); + match(CPP14Parser::Wchar); + break; + } + + case 9: { + enterOuterAlt(_localctx, 9); + setState(1122); + match(CPP14Parser::Bool); + break; + } + + case 10: { + enterOuterAlt(_localctx, 10); + setState(1124); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Signed + + || _la == CPP14Parser::Unsigned) { + setState(1123); + simpleTypeSignednessModifier(); + } + setState(1129); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == CPP14Parser::Long + + || _la == CPP14Parser::Short) { + setState(1126); + simpleTypeLengthModifier(); + setState(1131); + _errHandler->sync(this); + _la = _input->LA(1); + } + setState(1132); + match(CPP14Parser::Int); + break; + } + + case 11: { + enterOuterAlt(_localctx, 11); + setState(1133); + match(CPP14Parser::Float); + break; + } + + case 12: { + enterOuterAlt(_localctx, 12); + setState(1135); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Long + + || _la == CPP14Parser::Short) { + setState(1134); + simpleTypeLengthModifier(); + } + setState(1137); + match(CPP14Parser::Double); + break; + } + + case 13: { + enterOuterAlt(_localctx, 13); + setState(1138); + match(CPP14Parser::Void); + break; + } + + case 14: { + enterOuterAlt(_localctx, 14); + setState(1139); + match(CPP14Parser::Auto); + break; + } + + case 15: { + enterOuterAlt(_localctx, 15); + setState(1140); + decltypeSpecifier(); + break; + } + + default: + break; + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- TheTypeNameContext ------------------------------------------------------------------ + +CPP14Parser::TheTypeNameContext::TheTypeNameContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::ClassNameContext* CPP14Parser::TheTypeNameContext::className() { + return getRuleContext(0); +} + +CPP14Parser::EnumNameContext* CPP14Parser::TheTypeNameContext::enumName() { + return getRuleContext(0); +} + +CPP14Parser::TypedefNameContext* CPP14Parser::TheTypeNameContext::typedefName() { + return getRuleContext(0); +} + +CPP14Parser::SimpleTemplateIdContext* CPP14Parser::TheTypeNameContext::simpleTemplateId() { + return getRuleContext(0); +} + + +size_t CPP14Parser::TheTypeNameContext::getRuleIndex() const { + return CPP14Parser::RuleTheTypeName; +} + + +CPP14Parser::TheTypeNameContext* CPP14Parser::theTypeName() { + TheTypeNameContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 160, CPP14Parser::RuleTheTypeName); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(1147); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 123, _ctx)) { + case 1: { + enterOuterAlt(_localctx, 1); + setState(1143); + className(); + break; + } + + case 2: { + enterOuterAlt(_localctx, 2); + setState(1144); + enumName(); + break; + } + + case 3: { + enterOuterAlt(_localctx, 3); + setState(1145); + typedefName(); + break; + } + + case 4: { + enterOuterAlt(_localctx, 4); + setState(1146); + simpleTemplateId(); + break; + } + + default: + break; + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- DecltypeSpecifierContext ------------------------------------------------------------------ + +CPP14Parser::DecltypeSpecifierContext::DecltypeSpecifierContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::DecltypeSpecifierContext::Decltype() { + return getToken(CPP14Parser::Decltype, 0); +} + +tree::TerminalNode* CPP14Parser::DecltypeSpecifierContext::LeftParen() { + return getToken(CPP14Parser::LeftParen, 0); +} + +tree::TerminalNode* CPP14Parser::DecltypeSpecifierContext::RightParen() { + return getToken(CPP14Parser::RightParen, 0); +} + +CPP14Parser::ExpressionContext* CPP14Parser::DecltypeSpecifierContext::expression() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::DecltypeSpecifierContext::Auto() { + return getToken(CPP14Parser::Auto, 0); +} + + +size_t CPP14Parser::DecltypeSpecifierContext::getRuleIndex() const { + return CPP14Parser::RuleDecltypeSpecifier; +} + + +CPP14Parser::DecltypeSpecifierContext* CPP14Parser::decltypeSpecifier() { + DecltypeSpecifierContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 162, CPP14Parser::RuleDecltypeSpecifier); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1149); + match(CPP14Parser::Decltype); + setState(1150); + match(CPP14Parser::LeftParen); + setState(1153); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 124, _ctx)) { + case 1: { + setState(1151); + expression(); + break; + } + + case 2: { + setState(1152); + match(CPP14Parser::Auto); + break; + } + + default: + break; + } + setState(1155); + match(CPP14Parser::RightParen); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ElaboratedTypeSpecifierContext ------------------------------------------------------------------ + +CPP14Parser::ElaboratedTypeSpecifierContext::ElaboratedTypeSpecifierContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::ClassKeyContext* CPP14Parser::ElaboratedTypeSpecifierContext::classKey() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::ElaboratedTypeSpecifierContext::Identifier() { + return getToken(CPP14Parser::Identifier, 0); +} + +CPP14Parser::SimpleTemplateIdContext* CPP14Parser::ElaboratedTypeSpecifierContext::simpleTemplateId() { + return getRuleContext(0); +} + +CPP14Parser::NestedNameSpecifierContext* CPP14Parser::ElaboratedTypeSpecifierContext::nestedNameSpecifier() { + return getRuleContext(0); +} + +CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::ElaboratedTypeSpecifierContext::attributeSpecifierSeq() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::ElaboratedTypeSpecifierContext::Template() { + return getToken(CPP14Parser::Template, 0); +} + +tree::TerminalNode* CPP14Parser::ElaboratedTypeSpecifierContext::Enum() { + return getToken(CPP14Parser::Enum, 0); +} + + +size_t CPP14Parser::ElaboratedTypeSpecifierContext::getRuleIndex() const { + return CPP14Parser::RuleElaboratedTypeSpecifier; +} + + +CPP14Parser::ElaboratedTypeSpecifierContext* CPP14Parser::elaboratedTypeSpecifier() { + ElaboratedTypeSpecifierContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 164, CPP14Parser::RuleElaboratedTypeSpecifier); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(1179); + _errHandler->sync(this); + switch (_input->LA(1)) { + case CPP14Parser::Class: + case CPP14Parser::Struct: { + enterOuterAlt(_localctx, 1); + setState(1157); + classKey(); + setState(1172); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 128, _ctx)) { + case 1: { + setState(1159); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Alignas || _la == CPP14Parser::LeftBracket) { + setState(1158); + attributeSpecifierSeq(); + } + setState(1162); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 126, _ctx)) { + case 1: { + setState(1161); + nestedNameSpecifier(0); + break; + } + + default: + break; + } + setState(1164); + match(CPP14Parser::Identifier); + break; + } + + case 2: { + setState(1165); + simpleTemplateId(); + break; + } + + case 3: { + setState(1166); + nestedNameSpecifier(0); + setState(1168); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Template) { + setState(1167); + match(CPP14Parser::Template); + } + setState(1170); + simpleTemplateId(); + break; + } + + default: + break; + } + break; + } + + case CPP14Parser::Enum: { + enterOuterAlt(_localctx, 2); + setState(1174); + match(CPP14Parser::Enum); + setState(1176); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 129, _ctx)) { + case 1: { + setState(1175); + nestedNameSpecifier(0); + break; + } + + default: + break; + } + setState(1178); + match(CPP14Parser::Identifier); + break; + } + + default: + throw NoViableAltException(this); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- EnumNameContext ------------------------------------------------------------------ + +CPP14Parser::EnumNameContext::EnumNameContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::EnumNameContext::Identifier() { + return getToken(CPP14Parser::Identifier, 0); +} + + +size_t CPP14Parser::EnumNameContext::getRuleIndex() const { + return CPP14Parser::RuleEnumName; +} + + +CPP14Parser::EnumNameContext* CPP14Parser::enumName() { + EnumNameContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 166, CPP14Parser::RuleEnumName); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1181); + match(CPP14Parser::Identifier); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- EnumSpecifierContext ------------------------------------------------------------------ + +CPP14Parser::EnumSpecifierContext::EnumSpecifierContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::EnumHeadContext* CPP14Parser::EnumSpecifierContext::enumHead() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::EnumSpecifierContext::LeftBrace() { + return getToken(CPP14Parser::LeftBrace, 0); +} + +tree::TerminalNode* CPP14Parser::EnumSpecifierContext::RightBrace() { + return getToken(CPP14Parser::RightBrace, 0); +} + +CPP14Parser::EnumeratorListContext* CPP14Parser::EnumSpecifierContext::enumeratorList() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::EnumSpecifierContext::Comma() { + return getToken(CPP14Parser::Comma, 0); +} + + +size_t CPP14Parser::EnumSpecifierContext::getRuleIndex() const { + return CPP14Parser::RuleEnumSpecifier; +} + + +CPP14Parser::EnumSpecifierContext* CPP14Parser::enumSpecifier() { + EnumSpecifierContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 168, CPP14Parser::RuleEnumSpecifier); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1183); + enumHead(); + setState(1184); + match(CPP14Parser::LeftBrace); + setState(1189); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Identifier) { + setState(1185); + enumeratorList(); + setState(1187); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Comma) { + setState(1186); + match(CPP14Parser::Comma); + } + } + setState(1191); + match(CPP14Parser::RightBrace); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- EnumHeadContext ------------------------------------------------------------------ + +CPP14Parser::EnumHeadContext::EnumHeadContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::EnumkeyContext* CPP14Parser::EnumHeadContext::enumkey() { + return getRuleContext(0); +} + +CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::EnumHeadContext::attributeSpecifierSeq() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::EnumHeadContext::Identifier() { + return getToken(CPP14Parser::Identifier, 0); +} + +CPP14Parser::EnumbaseContext* CPP14Parser::EnumHeadContext::enumbase() { + return getRuleContext(0); +} + +CPP14Parser::NestedNameSpecifierContext* CPP14Parser::EnumHeadContext::nestedNameSpecifier() { + return getRuleContext(0); +} + + +size_t CPP14Parser::EnumHeadContext::getRuleIndex() const { + return CPP14Parser::RuleEnumHead; +} + + +CPP14Parser::EnumHeadContext* CPP14Parser::enumHead() { + EnumHeadContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 170, CPP14Parser::RuleEnumHead); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1193); + enumkey(); + setState(1195); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Alignas || _la == CPP14Parser::LeftBracket) { + setState(1194); + attributeSpecifierSeq(); + } + setState(1201); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Decltype || _la == CPP14Parser::Doublecolon + + || _la == CPP14Parser::Identifier) { + setState(1198); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 134, _ctx)) { + case 1: { + setState(1197); + nestedNameSpecifier(0); + break; + } + + default: + break; + } + setState(1200); + match(CPP14Parser::Identifier); + } + setState(1204); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Colon) { + setState(1203); + enumbase(); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- OpaqueEnumDeclarationContext ------------------------------------------------------------------ + +CPP14Parser::OpaqueEnumDeclarationContext::OpaqueEnumDeclarationContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::EnumkeyContext* CPP14Parser::OpaqueEnumDeclarationContext::enumkey() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::OpaqueEnumDeclarationContext::Identifier() { + return getToken(CPP14Parser::Identifier, 0); +} + +tree::TerminalNode* CPP14Parser::OpaqueEnumDeclarationContext::Semi() { + return getToken(CPP14Parser::Semi, 0); +} + +CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::OpaqueEnumDeclarationContext::attributeSpecifierSeq() { + return getRuleContext(0); +} + +CPP14Parser::EnumbaseContext* CPP14Parser::OpaqueEnumDeclarationContext::enumbase() { + return getRuleContext(0); +} + + +size_t CPP14Parser::OpaqueEnumDeclarationContext::getRuleIndex() const { + return CPP14Parser::RuleOpaqueEnumDeclaration; +} + + +CPP14Parser::OpaqueEnumDeclarationContext* CPP14Parser::opaqueEnumDeclaration() { + OpaqueEnumDeclarationContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 172, CPP14Parser::RuleOpaqueEnumDeclaration); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1206); + enumkey(); + setState(1208); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Alignas || _la == CPP14Parser::LeftBracket) { + setState(1207); + attributeSpecifierSeq(); + } + setState(1210); + match(CPP14Parser::Identifier); + setState(1212); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Colon) { + setState(1211); + enumbase(); + } + setState(1214); + match(CPP14Parser::Semi); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- EnumkeyContext ------------------------------------------------------------------ + +CPP14Parser::EnumkeyContext::EnumkeyContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::EnumkeyContext::Enum() { + return getToken(CPP14Parser::Enum, 0); +} + +tree::TerminalNode* CPP14Parser::EnumkeyContext::Class() { + return getToken(CPP14Parser::Class, 0); +} + +tree::TerminalNode* CPP14Parser::EnumkeyContext::Struct() { + return getToken(CPP14Parser::Struct, 0); +} + + +size_t CPP14Parser::EnumkeyContext::getRuleIndex() const { + return CPP14Parser::RuleEnumkey; +} + + +CPP14Parser::EnumkeyContext* CPP14Parser::enumkey() { + EnumkeyContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 174, CPP14Parser::RuleEnumkey); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1216); + match(CPP14Parser::Enum); + setState(1218); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Class + + || _la == CPP14Parser::Struct) { + setState(1217); + _la = _input->LA(1); + if (!(_la == CPP14Parser::Class + + || _la == CPP14Parser::Struct)) { + _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; +} + +//----------------- EnumbaseContext ------------------------------------------------------------------ + +CPP14Parser::EnumbaseContext::EnumbaseContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::EnumbaseContext::Colon() { + return getToken(CPP14Parser::Colon, 0); +} + +CPP14Parser::TypeSpecifierSeqContext* CPP14Parser::EnumbaseContext::typeSpecifierSeq() { + return getRuleContext(0); +} + + +size_t CPP14Parser::EnumbaseContext::getRuleIndex() const { + return CPP14Parser::RuleEnumbase; +} + + +CPP14Parser::EnumbaseContext* CPP14Parser::enumbase() { + EnumbaseContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 176, CPP14Parser::RuleEnumbase); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1220); + match(CPP14Parser::Colon); + setState(1221); + typeSpecifierSeq(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- EnumeratorListContext ------------------------------------------------------------------ + +CPP14Parser::EnumeratorListContext::EnumeratorListContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector CPP14Parser::EnumeratorListContext::enumeratorDefinition() { + return getRuleContexts(); +} + +CPP14Parser::EnumeratorDefinitionContext* CPP14Parser::EnumeratorListContext::enumeratorDefinition(size_t i) { + return getRuleContext(i); +} + +std::vector CPP14Parser::EnumeratorListContext::Comma() { + return getTokens(CPP14Parser::Comma); +} + +tree::TerminalNode* CPP14Parser::EnumeratorListContext::Comma(size_t i) { + return getToken(CPP14Parser::Comma, i); +} + + +size_t CPP14Parser::EnumeratorListContext::getRuleIndex() const { + return CPP14Parser::RuleEnumeratorList; +} + + +CPP14Parser::EnumeratorListContext* CPP14Parser::enumeratorList() { + EnumeratorListContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 178, CPP14Parser::RuleEnumeratorList); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + size_t alt; + enterOuterAlt(_localctx, 1); + setState(1223); + enumeratorDefinition(); + setState(1228); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 140, _ctx); + while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { + if (alt == 1) { + setState(1224); + match(CPP14Parser::Comma); + setState(1225); + enumeratorDefinition(); + } + setState(1230); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 140, _ctx); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- EnumeratorDefinitionContext ------------------------------------------------------------------ + +CPP14Parser::EnumeratorDefinitionContext::EnumeratorDefinitionContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::EnumeratorContext* CPP14Parser::EnumeratorDefinitionContext::enumerator() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::EnumeratorDefinitionContext::Assign() { + return getToken(CPP14Parser::Assign, 0); +} + +CPP14Parser::ConstantExpressionContext* CPP14Parser::EnumeratorDefinitionContext::constantExpression() { + return getRuleContext(0); +} + + +size_t CPP14Parser::EnumeratorDefinitionContext::getRuleIndex() const { + return CPP14Parser::RuleEnumeratorDefinition; +} + + +CPP14Parser::EnumeratorDefinitionContext* CPP14Parser::enumeratorDefinition() { + EnumeratorDefinitionContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 180, CPP14Parser::RuleEnumeratorDefinition); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1231); + enumerator(); + setState(1234); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Assign) { + setState(1232); + match(CPP14Parser::Assign); + setState(1233); + constantExpression(); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- EnumeratorContext ------------------------------------------------------------------ + +CPP14Parser::EnumeratorContext::EnumeratorContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::EnumeratorContext::Identifier() { + return getToken(CPP14Parser::Identifier, 0); +} + + +size_t CPP14Parser::EnumeratorContext::getRuleIndex() const { + return CPP14Parser::RuleEnumerator; +} + + +CPP14Parser::EnumeratorContext* CPP14Parser::enumerator() { + EnumeratorContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 182, CPP14Parser::RuleEnumerator); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1236); + match(CPP14Parser::Identifier); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- NamespaceNameContext ------------------------------------------------------------------ + +CPP14Parser::NamespaceNameContext::NamespaceNameContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::OriginalNamespaceNameContext* CPP14Parser::NamespaceNameContext::originalNamespaceName() { + return getRuleContext(0); +} + +CPP14Parser::NamespaceAliasContext* CPP14Parser::NamespaceNameContext::namespaceAlias() { + return getRuleContext(0); +} + + +size_t CPP14Parser::NamespaceNameContext::getRuleIndex() const { + return CPP14Parser::RuleNamespaceName; +} + + +CPP14Parser::NamespaceNameContext* CPP14Parser::namespaceName() { + NamespaceNameContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 184, CPP14Parser::RuleNamespaceName); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(1240); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 142, _ctx)) { + case 1: { + enterOuterAlt(_localctx, 1); + setState(1238); + originalNamespaceName(); + break; + } + + case 2: { + enterOuterAlt(_localctx, 2); + setState(1239); + namespaceAlias(); + break; + } + + default: + break; + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- OriginalNamespaceNameContext ------------------------------------------------------------------ + +CPP14Parser::OriginalNamespaceNameContext::OriginalNamespaceNameContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::OriginalNamespaceNameContext::Identifier() { + return getToken(CPP14Parser::Identifier, 0); +} + + +size_t CPP14Parser::OriginalNamespaceNameContext::getRuleIndex() const { + return CPP14Parser::RuleOriginalNamespaceName; +} + + +CPP14Parser::OriginalNamespaceNameContext* CPP14Parser::originalNamespaceName() { + OriginalNamespaceNameContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 186, CPP14Parser::RuleOriginalNamespaceName); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1242); + match(CPP14Parser::Identifier); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- NamespaceDefinitionContext ------------------------------------------------------------------ + +CPP14Parser::NamespaceDefinitionContext::NamespaceDefinitionContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::NamespaceDefinitionContext::Namespace() { + return getToken(CPP14Parser::Namespace, 0); +} + +tree::TerminalNode* CPP14Parser::NamespaceDefinitionContext::LeftBrace() { + return getToken(CPP14Parser::LeftBrace, 0); +} + +tree::TerminalNode* CPP14Parser::NamespaceDefinitionContext::RightBrace() { + return getToken(CPP14Parser::RightBrace, 0); +} + +tree::TerminalNode* CPP14Parser::NamespaceDefinitionContext::Inline() { + return getToken(CPP14Parser::Inline, 0); +} + +tree::TerminalNode* CPP14Parser::NamespaceDefinitionContext::Identifier() { + return getToken(CPP14Parser::Identifier, 0); +} + +CPP14Parser::OriginalNamespaceNameContext* CPP14Parser::NamespaceDefinitionContext::originalNamespaceName() { + return getRuleContext(0); +} + +CPP14Parser::DeclarationseqContext* CPP14Parser::NamespaceDefinitionContext::declarationseq() { + return getRuleContext(0); +} + + +size_t CPP14Parser::NamespaceDefinitionContext::getRuleIndex() const { + return CPP14Parser::RuleNamespaceDefinition; +} + + +CPP14Parser::NamespaceDefinitionContext* CPP14Parser::namespaceDefinition() { + NamespaceDefinitionContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 188, CPP14Parser::RuleNamespaceDefinition); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1245); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Inline) { + setState(1244); + match(CPP14Parser::Inline); + } + setState(1247); + match(CPP14Parser::Namespace); + setState(1250); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 144, _ctx)) { + case 1: { + setState(1248); + match(CPP14Parser::Identifier); + break; + } + + case 2: { + setState(1249); + originalNamespaceName(); + break; + } + + default: + break; + } + setState(1252); + match(CPP14Parser::LeftBrace); + setState(1254); + _errHandler->sync(this); + + _la = _input->LA(1); + if (((((_la - 10) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 10)) & 1543754443169808157) != 0) || ((((_la - 74) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 74)) & 459384754220313597) != 0)) { + setState(1253); + antlrcpp::downCast(_localctx)->namespaceBody = declarationseq(); + } + setState(1256); + match(CPP14Parser::RightBrace); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- NamespaceAliasContext ------------------------------------------------------------------ + +CPP14Parser::NamespaceAliasContext::NamespaceAliasContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::NamespaceAliasContext::Identifier() { + return getToken(CPP14Parser::Identifier, 0); +} + + +size_t CPP14Parser::NamespaceAliasContext::getRuleIndex() const { + return CPP14Parser::RuleNamespaceAlias; +} + + +CPP14Parser::NamespaceAliasContext* CPP14Parser::namespaceAlias() { + NamespaceAliasContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 190, CPP14Parser::RuleNamespaceAlias); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1258); + match(CPP14Parser::Identifier); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- NamespaceAliasDefinitionContext ------------------------------------------------------------------ + +CPP14Parser::NamespaceAliasDefinitionContext::NamespaceAliasDefinitionContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::NamespaceAliasDefinitionContext::Namespace() { + return getToken(CPP14Parser::Namespace, 0); +} + +tree::TerminalNode* CPP14Parser::NamespaceAliasDefinitionContext::Identifier() { + return getToken(CPP14Parser::Identifier, 0); +} + +tree::TerminalNode* CPP14Parser::NamespaceAliasDefinitionContext::Assign() { + return getToken(CPP14Parser::Assign, 0); +} + +CPP14Parser::QualifiednamespacespecifierContext* CPP14Parser::NamespaceAliasDefinitionContext::qualifiednamespacespecifier() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::NamespaceAliasDefinitionContext::Semi() { + return getToken(CPP14Parser::Semi, 0); +} + + +size_t CPP14Parser::NamespaceAliasDefinitionContext::getRuleIndex() const { + return CPP14Parser::RuleNamespaceAliasDefinition; +} + + +CPP14Parser::NamespaceAliasDefinitionContext* CPP14Parser::namespaceAliasDefinition() { + NamespaceAliasDefinitionContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 192, CPP14Parser::RuleNamespaceAliasDefinition); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1260); + match(CPP14Parser::Namespace); + setState(1261); + match(CPP14Parser::Identifier); + setState(1262); + match(CPP14Parser::Assign); + setState(1263); + qualifiednamespacespecifier(); + setState(1264); + match(CPP14Parser::Semi); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- QualifiednamespacespecifierContext ------------------------------------------------------------------ + +CPP14Parser::QualifiednamespacespecifierContext::QualifiednamespacespecifierContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::NamespaceNameContext* CPP14Parser::QualifiednamespacespecifierContext::namespaceName() { + return getRuleContext(0); +} + +CPP14Parser::NestedNameSpecifierContext* CPP14Parser::QualifiednamespacespecifierContext::nestedNameSpecifier() { + return getRuleContext(0); +} + + +size_t CPP14Parser::QualifiednamespacespecifierContext::getRuleIndex() const { + return CPP14Parser::RuleQualifiednamespacespecifier; +} + + +CPP14Parser::QualifiednamespacespecifierContext* CPP14Parser::qualifiednamespacespecifier() { + QualifiednamespacespecifierContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 194, CPP14Parser::RuleQualifiednamespacespecifier); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1267); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 146, _ctx)) { + case 1: { + setState(1266); + nestedNameSpecifier(0); + break; + } + + default: + break; + } + setState(1269); + namespaceName(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- UsingDeclarationContext ------------------------------------------------------------------ + +CPP14Parser::UsingDeclarationContext::UsingDeclarationContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::UsingDeclarationContext::Using() { + return getToken(CPP14Parser::Using, 0); +} + +CPP14Parser::UnqualifiedIdContext* CPP14Parser::UsingDeclarationContext::unqualifiedId() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::UsingDeclarationContext::Semi() { + return getToken(CPP14Parser::Semi, 0); +} + +tree::TerminalNode* CPP14Parser::UsingDeclarationContext::Doublecolon() { + return getToken(CPP14Parser::Doublecolon, 0); +} + +CPP14Parser::NestedNameSpecifierContext* CPP14Parser::UsingDeclarationContext::nestedNameSpecifier() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::UsingDeclarationContext::Typename_() { + return getToken(CPP14Parser::Typename_, 0); +} + + +size_t CPP14Parser::UsingDeclarationContext::getRuleIndex() const { + return CPP14Parser::RuleUsingDeclaration; +} + + +CPP14Parser::UsingDeclarationContext* CPP14Parser::usingDeclaration() { + UsingDeclarationContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 196, CPP14Parser::RuleUsingDeclaration); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1271); + match(CPP14Parser::Using); + setState(1277); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 148, _ctx)) { + case 1: { + setState(1273); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Typename_) { + setState(1272); + match(CPP14Parser::Typename_); + } + setState(1275); + nestedNameSpecifier(0); + break; + } + + case 2: { + setState(1276); + match(CPP14Parser::Doublecolon); + break; + } + + default: + break; + } + setState(1279); + unqualifiedId(); + setState(1280); + match(CPP14Parser::Semi); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- UsingDirectiveContext ------------------------------------------------------------------ + +CPP14Parser::UsingDirectiveContext::UsingDirectiveContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::UsingDirectiveContext::Using() { + return getToken(CPP14Parser::Using, 0); +} + +tree::TerminalNode* CPP14Parser::UsingDirectiveContext::Namespace() { + return getToken(CPP14Parser::Namespace, 0); +} + +CPP14Parser::NamespaceNameContext* CPP14Parser::UsingDirectiveContext::namespaceName() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::UsingDirectiveContext::Semi() { + return getToken(CPP14Parser::Semi, 0); +} + +CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::UsingDirectiveContext::attributeSpecifierSeq() { + return getRuleContext(0); +} + +CPP14Parser::NestedNameSpecifierContext* CPP14Parser::UsingDirectiveContext::nestedNameSpecifier() { + return getRuleContext(0); +} + + +size_t CPP14Parser::UsingDirectiveContext::getRuleIndex() const { + return CPP14Parser::RuleUsingDirective; +} + + +CPP14Parser::UsingDirectiveContext* CPP14Parser::usingDirective() { + UsingDirectiveContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 198, CPP14Parser::RuleUsingDirective); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1283); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Alignas || _la == CPP14Parser::LeftBracket) { + setState(1282); + attributeSpecifierSeq(); + } + setState(1285); + match(CPP14Parser::Using); + setState(1286); + match(CPP14Parser::Namespace); + setState(1288); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 150, _ctx)) { + case 1: { + setState(1287); + nestedNameSpecifier(0); + break; + } + + default: + break; + } + setState(1290); + namespaceName(); + setState(1291); + match(CPP14Parser::Semi); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- AsmDefinitionContext ------------------------------------------------------------------ + +CPP14Parser::AsmDefinitionContext::AsmDefinitionContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::AsmDefinitionContext::Asm() { + return getToken(CPP14Parser::Asm, 0); +} + +tree::TerminalNode* CPP14Parser::AsmDefinitionContext::LeftParen() { + return getToken(CPP14Parser::LeftParen, 0); +} + +tree::TerminalNode* CPP14Parser::AsmDefinitionContext::StringLiteral() { + return getToken(CPP14Parser::StringLiteral, 0); +} + +tree::TerminalNode* CPP14Parser::AsmDefinitionContext::RightParen() { + return getToken(CPP14Parser::RightParen, 0); +} + +tree::TerminalNode* CPP14Parser::AsmDefinitionContext::Semi() { + return getToken(CPP14Parser::Semi, 0); +} + + +size_t CPP14Parser::AsmDefinitionContext::getRuleIndex() const { + return CPP14Parser::RuleAsmDefinition; +} + + +CPP14Parser::AsmDefinitionContext* CPP14Parser::asmDefinition() { + AsmDefinitionContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 200, CPP14Parser::RuleAsmDefinition); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1293); + match(CPP14Parser::Asm); + setState(1294); + match(CPP14Parser::LeftParen); + setState(1295); + match(CPP14Parser::StringLiteral); + setState(1296); + match(CPP14Parser::RightParen); + setState(1297); + match(CPP14Parser::Semi); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- LinkageSpecificationContext ------------------------------------------------------------------ + +CPP14Parser::LinkageSpecificationContext::LinkageSpecificationContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::LinkageSpecificationContext::Extern() { + return getToken(CPP14Parser::Extern, 0); +} + +tree::TerminalNode* CPP14Parser::LinkageSpecificationContext::StringLiteral() { + return getToken(CPP14Parser::StringLiteral, 0); +} + +tree::TerminalNode* CPP14Parser::LinkageSpecificationContext::LeftBrace() { + return getToken(CPP14Parser::LeftBrace, 0); +} + +tree::TerminalNode* CPP14Parser::LinkageSpecificationContext::RightBrace() { + return getToken(CPP14Parser::RightBrace, 0); +} + +CPP14Parser::DeclarationContext* CPP14Parser::LinkageSpecificationContext::declaration() { + return getRuleContext(0); +} + +CPP14Parser::DeclarationseqContext* CPP14Parser::LinkageSpecificationContext::declarationseq() { + return getRuleContext(0); +} + + +size_t CPP14Parser::LinkageSpecificationContext::getRuleIndex() const { + return CPP14Parser::RuleLinkageSpecification; +} + + +CPP14Parser::LinkageSpecificationContext* CPP14Parser::linkageSpecification() { + LinkageSpecificationContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 202, CPP14Parser::RuleLinkageSpecification); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1299); + match(CPP14Parser::Extern); + setState(1300); + match(CPP14Parser::StringLiteral); + setState(1307); + _errHandler->sync(this); + switch (_input->LA(1)) { + case CPP14Parser::LeftBrace: { + setState(1301); + match(CPP14Parser::LeftBrace); + setState(1303); + _errHandler->sync(this); + + _la = _input->LA(1); + if (((((_la - 10) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 10)) & 1543754443169808157) != 0) || ((((_la - 74) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 74)) & 459384754220313597) != 0)) { + setState(1302); + declarationseq(); + } + setState(1305); + match(CPP14Parser::RightBrace); + break; + } + + case CPP14Parser::Alignas: + case CPP14Parser::Asm: + case CPP14Parser::Auto: + case CPP14Parser::Bool: + case CPP14Parser::Char: + case CPP14Parser::Char16: + case CPP14Parser::Char32: + case CPP14Parser::Class: + case CPP14Parser::Const: + case CPP14Parser::Constexpr: + case CPP14Parser::Decltype: + case CPP14Parser::Double: + case CPP14Parser::Enum: + case CPP14Parser::Explicit: + case CPP14Parser::Extern: + case CPP14Parser::Float: + case CPP14Parser::Friend: + case CPP14Parser::Inline: + case CPP14Parser::Int: + case CPP14Parser::Long: + case CPP14Parser::Mutable: + case CPP14Parser::Namespace: + case CPP14Parser::Operator: + case CPP14Parser::Register: + case CPP14Parser::Short: + case CPP14Parser::Signed: + case CPP14Parser::Static: + case CPP14Parser::Static_assert: + case CPP14Parser::Struct: + case CPP14Parser::Template: + case CPP14Parser::Thread_local: + case CPP14Parser::Typedef: + case CPP14Parser::Typename_: + case CPP14Parser::Union: + case CPP14Parser::Unsigned: + case CPP14Parser::Using: + case CPP14Parser::Virtual: + case CPP14Parser::Void: + case CPP14Parser::Volatile: + case CPP14Parser::Wchar: + case CPP14Parser::LeftParen: + case CPP14Parser::LeftBracket: + case CPP14Parser::Star: + case CPP14Parser::And: + case CPP14Parser::Tilde: + case CPP14Parser::AndAnd: + case CPP14Parser::Doublecolon: + case CPP14Parser::Semi: + case CPP14Parser::Ellipsis: + case CPP14Parser::Identifier: { + setState(1306); + declaration(); + break; + } + + default: + throw NoViableAltException(this); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- AttributeSpecifierSeqContext ------------------------------------------------------------------ + +CPP14Parser::AttributeSpecifierSeqContext::AttributeSpecifierSeqContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector CPP14Parser::AttributeSpecifierSeqContext::attributeSpecifier() { + return getRuleContexts(); +} + +CPP14Parser::AttributeSpecifierContext* CPP14Parser::AttributeSpecifierSeqContext::attributeSpecifier(size_t i) { + return getRuleContext(i); +} + + +size_t CPP14Parser::AttributeSpecifierSeqContext::getRuleIndex() const { + return CPP14Parser::RuleAttributeSpecifierSeq; +} + + +CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::attributeSpecifierSeq() { + AttributeSpecifierSeqContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 204, CPP14Parser::RuleAttributeSpecifierSeq); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + size_t alt; + enterOuterAlt(_localctx, 1); + setState(1310); + _errHandler->sync(this); + alt = 1; + do { + switch (alt) { + case 1: { + setState(1309); + attributeSpecifier(); + break; + } + + default: + throw NoViableAltException(this); + } + setState(1312); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 153, _ctx); + } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- AttributeSpecifierContext ------------------------------------------------------------------ + +CPP14Parser::AttributeSpecifierContext::AttributeSpecifierContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector CPP14Parser::AttributeSpecifierContext::LeftBracket() { + return getTokens(CPP14Parser::LeftBracket); +} + +tree::TerminalNode* CPP14Parser::AttributeSpecifierContext::LeftBracket(size_t i) { + return getToken(CPP14Parser::LeftBracket, i); +} + +std::vector CPP14Parser::AttributeSpecifierContext::RightBracket() { + return getTokens(CPP14Parser::RightBracket); +} + +tree::TerminalNode* CPP14Parser::AttributeSpecifierContext::RightBracket(size_t i) { + return getToken(CPP14Parser::RightBracket, i); +} + +CPP14Parser::AttributeListContext* CPP14Parser::AttributeSpecifierContext::attributeList() { + return getRuleContext(0); +} + +CPP14Parser::AlignmentspecifierContext* CPP14Parser::AttributeSpecifierContext::alignmentspecifier() { + return getRuleContext(0); +} + + +size_t CPP14Parser::AttributeSpecifierContext::getRuleIndex() const { + return CPP14Parser::RuleAttributeSpecifier; +} + + +CPP14Parser::AttributeSpecifierContext* CPP14Parser::attributeSpecifier() { + AttributeSpecifierContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 206, CPP14Parser::RuleAttributeSpecifier); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(1322); + _errHandler->sync(this); + switch (_input->LA(1)) { + case CPP14Parser::LeftBracket: { + enterOuterAlt(_localctx, 1); + setState(1314); + match(CPP14Parser::LeftBracket); + setState(1315); + match(CPP14Parser::LeftBracket); + setState(1317); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Identifier) { + setState(1316); + attributeList(); + } + setState(1319); + match(CPP14Parser::RightBracket); + setState(1320); + match(CPP14Parser::RightBracket); + break; + } + + case CPP14Parser::Alignas: { + enterOuterAlt(_localctx, 2); + setState(1321); + alignmentspecifier(); + break; + } + + default: + throw NoViableAltException(this); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- AlignmentspecifierContext ------------------------------------------------------------------ + +CPP14Parser::AlignmentspecifierContext::AlignmentspecifierContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::AlignmentspecifierContext::Alignas() { + return getToken(CPP14Parser::Alignas, 0); +} + +tree::TerminalNode* CPP14Parser::AlignmentspecifierContext::LeftParen() { + return getToken(CPP14Parser::LeftParen, 0); +} + +tree::TerminalNode* CPP14Parser::AlignmentspecifierContext::RightParen() { + return getToken(CPP14Parser::RightParen, 0); +} + +CPP14Parser::TheTypeIdContext* CPP14Parser::AlignmentspecifierContext::theTypeId() { + return getRuleContext(0); +} + +CPP14Parser::ConstantExpressionContext* CPP14Parser::AlignmentspecifierContext::constantExpression() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::AlignmentspecifierContext::Ellipsis() { + return getToken(CPP14Parser::Ellipsis, 0); +} + + +size_t CPP14Parser::AlignmentspecifierContext::getRuleIndex() const { + return CPP14Parser::RuleAlignmentspecifier; +} + + +CPP14Parser::AlignmentspecifierContext* CPP14Parser::alignmentspecifier() { + AlignmentspecifierContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 208, CPP14Parser::RuleAlignmentspecifier); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1324); + match(CPP14Parser::Alignas); + setState(1325); + match(CPP14Parser::LeftParen); + setState(1328); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 156, _ctx)) { + case 1: { + setState(1326); + theTypeId(); + break; + } + + case 2: { + setState(1327); + constantExpression(); + break; + } + + default: + break; + } + setState(1331); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Ellipsis) { + setState(1330); + match(CPP14Parser::Ellipsis); + } + setState(1333); + match(CPP14Parser::RightParen); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- AttributeListContext ------------------------------------------------------------------ + +CPP14Parser::AttributeListContext::AttributeListContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector CPP14Parser::AttributeListContext::attribute() { + return getRuleContexts(); +} + +CPP14Parser::AttributeContext* CPP14Parser::AttributeListContext::attribute(size_t i) { + return getRuleContext(i); +} + +std::vector CPP14Parser::AttributeListContext::Comma() { + return getTokens(CPP14Parser::Comma); +} + +tree::TerminalNode* CPP14Parser::AttributeListContext::Comma(size_t i) { + return getToken(CPP14Parser::Comma, i); +} + +tree::TerminalNode* CPP14Parser::AttributeListContext::Ellipsis() { + return getToken(CPP14Parser::Ellipsis, 0); +} + + +size_t CPP14Parser::AttributeListContext::getRuleIndex() const { + return CPP14Parser::RuleAttributeList; +} + + +CPP14Parser::AttributeListContext* CPP14Parser::attributeList() { + AttributeListContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 210, CPP14Parser::RuleAttributeList); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1335); + attribute(); + setState(1340); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == CPP14Parser::Comma) { + setState(1336); + match(CPP14Parser::Comma); + setState(1337); + attribute(); + setState(1342); + _errHandler->sync(this); + _la = _input->LA(1); + } + setState(1344); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Ellipsis) { + setState(1343); + match(CPP14Parser::Ellipsis); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- AttributeContext ------------------------------------------------------------------ + +CPP14Parser::AttributeContext::AttributeContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::AttributeContext::Identifier() { + return getToken(CPP14Parser::Identifier, 0); +} + +CPP14Parser::AttributeNamespaceContext* CPP14Parser::AttributeContext::attributeNamespace() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::AttributeContext::Doublecolon() { + return getToken(CPP14Parser::Doublecolon, 0); +} + +CPP14Parser::AttributeArgumentClauseContext* CPP14Parser::AttributeContext::attributeArgumentClause() { + return getRuleContext(0); +} + + +size_t CPP14Parser::AttributeContext::getRuleIndex() const { + return CPP14Parser::RuleAttribute; +} + + +CPP14Parser::AttributeContext* CPP14Parser::attribute() { + AttributeContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 212, CPP14Parser::RuleAttribute); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1349); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 160, _ctx)) { + case 1: { + setState(1346); + attributeNamespace(); + setState(1347); + match(CPP14Parser::Doublecolon); + break; + } + + default: + break; + } + setState(1351); + match(CPP14Parser::Identifier); + setState(1353); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::LeftParen) { + setState(1352); + attributeArgumentClause(); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- AttributeNamespaceContext ------------------------------------------------------------------ + +CPP14Parser::AttributeNamespaceContext::AttributeNamespaceContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::AttributeNamespaceContext::Identifier() { + return getToken(CPP14Parser::Identifier, 0); +} + + +size_t CPP14Parser::AttributeNamespaceContext::getRuleIndex() const { + return CPP14Parser::RuleAttributeNamespace; +} + + +CPP14Parser::AttributeNamespaceContext* CPP14Parser::attributeNamespace() { + AttributeNamespaceContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 214, CPP14Parser::RuleAttributeNamespace); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1355); + match(CPP14Parser::Identifier); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- AttributeArgumentClauseContext ------------------------------------------------------------------ + +CPP14Parser::AttributeArgumentClauseContext::AttributeArgumentClauseContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::AttributeArgumentClauseContext::LeftParen() { + return getToken(CPP14Parser::LeftParen, 0); +} + +tree::TerminalNode* CPP14Parser::AttributeArgumentClauseContext::RightParen() { + return getToken(CPP14Parser::RightParen, 0); +} + +CPP14Parser::BalancedTokenSeqContext* CPP14Parser::AttributeArgumentClauseContext::balancedTokenSeq() { + return getRuleContext(0); +} + + +size_t CPP14Parser::AttributeArgumentClauseContext::getRuleIndex() const { + return CPP14Parser::RuleAttributeArgumentClause; +} + + +CPP14Parser::AttributeArgumentClauseContext* CPP14Parser::attributeArgumentClause() { + AttributeArgumentClauseContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 216, CPP14Parser::RuleAttributeArgumentClause); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1357); + match(CPP14Parser::LeftParen); + setState(1359); + _errHandler->sync(this); + + _la = _input->LA(1); + if ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & -2) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 64)) & -88080385) != 0) || ((((_la - 128) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 128)) & 262143) != 0)) { + setState(1358); + balancedTokenSeq(); + } + setState(1361); + match(CPP14Parser::RightParen); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- BalancedTokenSeqContext ------------------------------------------------------------------ + +CPP14Parser::BalancedTokenSeqContext::BalancedTokenSeqContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector CPP14Parser::BalancedTokenSeqContext::balancedtoken() { + return getRuleContexts(); +} + +CPP14Parser::BalancedtokenContext* CPP14Parser::BalancedTokenSeqContext::balancedtoken(size_t i) { + return getRuleContext(i); +} + + +size_t CPP14Parser::BalancedTokenSeqContext::getRuleIndex() const { + return CPP14Parser::RuleBalancedTokenSeq; +} + + +CPP14Parser::BalancedTokenSeqContext* CPP14Parser::balancedTokenSeq() { + BalancedTokenSeqContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 218, CPP14Parser::RuleBalancedTokenSeq); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1364); + _errHandler->sync(this); + _la = _input->LA(1); + do { + setState(1363); + balancedtoken(); + setState(1366); + _errHandler->sync(this); + _la = _input->LA(1); + } while ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & -2) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 64)) & -88080385) != 0) || ((((_la - 128) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 128)) & 262143) != 0)); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- BalancedtokenContext ------------------------------------------------------------------ + +CPP14Parser::BalancedtokenContext::BalancedtokenContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector CPP14Parser::BalancedtokenContext::LeftParen() { + return getTokens(CPP14Parser::LeftParen); +} + +tree::TerminalNode* CPP14Parser::BalancedtokenContext::LeftParen(size_t i) { + return getToken(CPP14Parser::LeftParen, i); +} + +CPP14Parser::BalancedTokenSeqContext* CPP14Parser::BalancedtokenContext::balancedTokenSeq() { + return getRuleContext(0); +} + +std::vector CPP14Parser::BalancedtokenContext::RightParen() { + return getTokens(CPP14Parser::RightParen); +} + +tree::TerminalNode* CPP14Parser::BalancedtokenContext::RightParen(size_t i) { + return getToken(CPP14Parser::RightParen, i); +} + +std::vector CPP14Parser::BalancedtokenContext::LeftBracket() { + return getTokens(CPP14Parser::LeftBracket); +} + +tree::TerminalNode* CPP14Parser::BalancedtokenContext::LeftBracket(size_t i) { + return getToken(CPP14Parser::LeftBracket, i); +} + +std::vector CPP14Parser::BalancedtokenContext::RightBracket() { + return getTokens(CPP14Parser::RightBracket); +} + +tree::TerminalNode* CPP14Parser::BalancedtokenContext::RightBracket(size_t i) { + return getToken(CPP14Parser::RightBracket, i); +} + +std::vector CPP14Parser::BalancedtokenContext::LeftBrace() { + return getTokens(CPP14Parser::LeftBrace); +} + +tree::TerminalNode* CPP14Parser::BalancedtokenContext::LeftBrace(size_t i) { + return getToken(CPP14Parser::LeftBrace, i); +} + +std::vector CPP14Parser::BalancedtokenContext::RightBrace() { + return getTokens(CPP14Parser::RightBrace); +} + +tree::TerminalNode* CPP14Parser::BalancedtokenContext::RightBrace(size_t i) { + return getToken(CPP14Parser::RightBrace, i); +} + + +size_t CPP14Parser::BalancedtokenContext::getRuleIndex() const { + return CPP14Parser::RuleBalancedtoken; +} + + +CPP14Parser::BalancedtokenContext* CPP14Parser::balancedtoken() { + BalancedtokenContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 220, CPP14Parser::RuleBalancedtoken); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + size_t alt; + setState(1385); + _errHandler->sync(this); + switch (_input->LA(1)) { + case CPP14Parser::LeftParen: { + enterOuterAlt(_localctx, 1); + setState(1368); + match(CPP14Parser::LeftParen); + setState(1369); + balancedTokenSeq(); + setState(1370); + match(CPP14Parser::RightParen); + break; + } + + case CPP14Parser::LeftBracket: { + enterOuterAlt(_localctx, 2); + setState(1372); + match(CPP14Parser::LeftBracket); + setState(1373); + balancedTokenSeq(); + setState(1374); + match(CPP14Parser::RightBracket); + break; + } + + case CPP14Parser::LeftBrace: { + enterOuterAlt(_localctx, 3); + setState(1376); + match(CPP14Parser::LeftBrace); + setState(1377); + balancedTokenSeq(); + setState(1378); + match(CPP14Parser::RightBrace); + break; + } + + case CPP14Parser::IntegerLiteral: + case CPP14Parser::CharacterLiteral: + case CPP14Parser::FloatingLiteral: + case CPP14Parser::StringLiteral: + case CPP14Parser::BooleanLiteral: + case CPP14Parser::PointerLiteral: + case CPP14Parser::UserDefinedLiteral: + case CPP14Parser::MultiLineMacro: + case CPP14Parser::Directive: + case CPP14Parser::Alignas: + case CPP14Parser::Alignof: + case CPP14Parser::Asm: + case CPP14Parser::Auto: + case CPP14Parser::Bool: + case CPP14Parser::Break: + case CPP14Parser::Case: + case CPP14Parser::Catch: + case CPP14Parser::Char: + case CPP14Parser::Char16: + case CPP14Parser::Char32: + case CPP14Parser::Class: + case CPP14Parser::Const: + case CPP14Parser::Constexpr: + case CPP14Parser::Const_cast: + case CPP14Parser::Continue: + case CPP14Parser::Decltype: + case CPP14Parser::Default: + case CPP14Parser::Delete: + case CPP14Parser::Do: + case CPP14Parser::Double: + case CPP14Parser::Dynamic_cast: + case CPP14Parser::Else: + case CPP14Parser::Enum: + case CPP14Parser::Explicit: + case CPP14Parser::Export: + case CPP14Parser::Extern: + case CPP14Parser::False_: + case CPP14Parser::Final: + case CPP14Parser::Float: + case CPP14Parser::For: + case CPP14Parser::Friend: + case CPP14Parser::Goto: + case CPP14Parser::If: + case CPP14Parser::Inline: + case CPP14Parser::Int: + case CPP14Parser::Long: + case CPP14Parser::Mutable: + case CPP14Parser::Namespace: + case CPP14Parser::New: + case CPP14Parser::Noexcept: + case CPP14Parser::Nullptr: + case CPP14Parser::Operator: + case CPP14Parser::Override: + case CPP14Parser::Private: + case CPP14Parser::Protected: + case CPP14Parser::Public: + case CPP14Parser::Register: + case CPP14Parser::Reinterpret_cast: + case CPP14Parser::Return: + case CPP14Parser::Short: + case CPP14Parser::Signed: + case CPP14Parser::Sizeof: + case CPP14Parser::Static: + case CPP14Parser::Static_assert: + case CPP14Parser::Static_cast: + case CPP14Parser::Struct: + case CPP14Parser::Switch: + case CPP14Parser::Template: + case CPP14Parser::This: + case CPP14Parser::Thread_local: + case CPP14Parser::Throw: + case CPP14Parser::True_: + case CPP14Parser::Try: + case CPP14Parser::Typedef: + case CPP14Parser::Typeid_: + case CPP14Parser::Typename_: + case CPP14Parser::Union: + case CPP14Parser::Unsigned: + case CPP14Parser::Using: + case CPP14Parser::Virtual: + case CPP14Parser::Void: + case CPP14Parser::Volatile: + case CPP14Parser::Wchar: + case CPP14Parser::While: + case CPP14Parser::Plus: + case CPP14Parser::Minus: + case CPP14Parser::Star: + case CPP14Parser::Div: + case CPP14Parser::Mod: + case CPP14Parser::Caret: + case CPP14Parser::And: + case CPP14Parser::Or: + case CPP14Parser::Tilde: + case CPP14Parser::Not: + case CPP14Parser::Assign: + case CPP14Parser::Less: + case CPP14Parser::Greater: + case CPP14Parser::PlusAssign: + case CPP14Parser::MinusAssign: + case CPP14Parser::StarAssign: + case CPP14Parser::DivAssign: + case CPP14Parser::ModAssign: + case CPP14Parser::XorAssign: + case CPP14Parser::AndAssign: + case CPP14Parser::OrAssign: + case CPP14Parser::LeftShiftAssign: + case CPP14Parser::RightShiftAssign: + case CPP14Parser::Equal: + case CPP14Parser::NotEqual: + case CPP14Parser::LessEqual: + case CPP14Parser::GreaterEqual: + case CPP14Parser::AndAnd: + case CPP14Parser::OrOr: + case CPP14Parser::PlusPlus: + case CPP14Parser::MinusMinus: + case CPP14Parser::Comma: + case CPP14Parser::ArrowStar: + case CPP14Parser::Arrow: + case CPP14Parser::Question: + case CPP14Parser::Colon: + case CPP14Parser::Doublecolon: + case CPP14Parser::Semi: + case CPP14Parser::Dot: + case CPP14Parser::DotStar: + case CPP14Parser::Ellipsis: + case CPP14Parser::Identifier: + case CPP14Parser::DecimalLiteral: + case CPP14Parser::OctalLiteral: + case CPP14Parser::HexadecimalLiteral: + case CPP14Parser::BinaryLiteral: + case CPP14Parser::Integersuffix: + case CPP14Parser::UserDefinedIntegerLiteral: + case CPP14Parser::UserDefinedFloatingLiteral: + case CPP14Parser::UserDefinedStringLiteral: + case CPP14Parser::UserDefinedCharacterLiteral: + case CPP14Parser::Whitespace: + case CPP14Parser::Newline: + case CPP14Parser::BlockComment: + case CPP14Parser::LineComment: { + enterOuterAlt(_localctx, 4); + setState(1381); + _errHandler->sync(this); + alt = 1; + do { + switch (alt) { + case 1: { + setState(1380); + _la = _input->LA(1); + if (_la == 0 || _la == Token::EOF || (((((_la - 85) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 85)) & 63) != 0))) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + break; + } + + default: + throw NoViableAltException(this); + } + setState(1383); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 164, _ctx); + } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER); + break; + } + + default: + throw NoViableAltException(this); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- InitDeclaratorListContext ------------------------------------------------------------------ + +CPP14Parser::InitDeclaratorListContext::InitDeclaratorListContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector CPP14Parser::InitDeclaratorListContext::initDeclarator() { + return getRuleContexts(); +} + +CPP14Parser::InitDeclaratorContext* CPP14Parser::InitDeclaratorListContext::initDeclarator(size_t i) { + return getRuleContext(i); +} + +std::vector CPP14Parser::InitDeclaratorListContext::Comma() { + return getTokens(CPP14Parser::Comma); +} + +tree::TerminalNode* CPP14Parser::InitDeclaratorListContext::Comma(size_t i) { + return getToken(CPP14Parser::Comma, i); +} + + +size_t CPP14Parser::InitDeclaratorListContext::getRuleIndex() const { + return CPP14Parser::RuleInitDeclaratorList; +} + + +CPP14Parser::InitDeclaratorListContext* CPP14Parser::initDeclaratorList() { + InitDeclaratorListContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 222, CPP14Parser::RuleInitDeclaratorList); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1387); + initDeclarator(); + setState(1392); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == CPP14Parser::Comma) { + setState(1388); + match(CPP14Parser::Comma); + setState(1389); + initDeclarator(); + setState(1394); + _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; +} + +//----------------- InitDeclaratorContext ------------------------------------------------------------------ + +CPP14Parser::InitDeclaratorContext::InitDeclaratorContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::DeclaratorContext* CPP14Parser::InitDeclaratorContext::declarator() { + return getRuleContext(0); +} + +CPP14Parser::InitializerContext* CPP14Parser::InitDeclaratorContext::initializer() { + return getRuleContext(0); +} + + +size_t CPP14Parser::InitDeclaratorContext::getRuleIndex() const { + return CPP14Parser::RuleInitDeclarator; +} + + +CPP14Parser::InitDeclaratorContext* CPP14Parser::initDeclarator() { + InitDeclaratorContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 224, CPP14Parser::RuleInitDeclarator); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1395); + declarator(); + setState(1397); + _errHandler->sync(this); + + _la = _input->LA(1); + if (((((_la - 85) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 85)) & 65553) != 0)) { + setState(1396); + initializer(); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- DeclaratorContext ------------------------------------------------------------------ + +CPP14Parser::DeclaratorContext::DeclaratorContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::PointerDeclaratorContext* CPP14Parser::DeclaratorContext::pointerDeclarator() { + return getRuleContext(0); +} + +CPP14Parser::NoPointerDeclaratorContext* CPP14Parser::DeclaratorContext::noPointerDeclarator() { + return getRuleContext(0); +} + +CPP14Parser::ParametersAndQualifiersContext* CPP14Parser::DeclaratorContext::parametersAndQualifiers() { + return getRuleContext(0); +} + +CPP14Parser::TrailingReturnTypeContext* CPP14Parser::DeclaratorContext::trailingReturnType() { + return getRuleContext(0); +} + + +size_t CPP14Parser::DeclaratorContext::getRuleIndex() const { + return CPP14Parser::RuleDeclarator; +} + + +CPP14Parser::DeclaratorContext* CPP14Parser::declarator() { + DeclaratorContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 226, CPP14Parser::RuleDeclarator); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(1404); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 168, _ctx)) { + case 1: { + enterOuterAlt(_localctx, 1); + setState(1399); + pointerDeclarator(); + break; + } + + case 2: { + enterOuterAlt(_localctx, 2); + setState(1400); + noPointerDeclarator(0); + setState(1401); + parametersAndQualifiers(); + setState(1402); + trailingReturnType(); + break; + } + + default: + break; + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- PointerDeclaratorContext ------------------------------------------------------------------ + +CPP14Parser::PointerDeclaratorContext::PointerDeclaratorContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::NoPointerDeclaratorContext* CPP14Parser::PointerDeclaratorContext::noPointerDeclarator() { + return getRuleContext(0); +} + +std::vector CPP14Parser::PointerDeclaratorContext::pointerOperator() { + return getRuleContexts(); +} + +CPP14Parser::PointerOperatorContext* CPP14Parser::PointerDeclaratorContext::pointerOperator(size_t i) { + return getRuleContext(i); +} + +std::vector CPP14Parser::PointerDeclaratorContext::Const() { + return getTokens(CPP14Parser::Const); +} + +tree::TerminalNode* CPP14Parser::PointerDeclaratorContext::Const(size_t i) { + return getToken(CPP14Parser::Const, i); +} + + +size_t CPP14Parser::PointerDeclaratorContext::getRuleIndex() const { + return CPP14Parser::RulePointerDeclarator; +} + + +CPP14Parser::PointerDeclaratorContext* CPP14Parser::pointerDeclarator() { + PointerDeclaratorContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 228, CPP14Parser::RulePointerDeclarator); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + size_t alt; + enterOuterAlt(_localctx, 1); + setState(1412); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 170, _ctx); + while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { + if (alt == 1) { + setState(1406); + pointerOperator(); + setState(1408); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Const) { + setState(1407); + match(CPP14Parser::Const); + } + } + setState(1414); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 170, _ctx); + } + setState(1415); + noPointerDeclarator(0); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- NoPointerDeclaratorContext ------------------------------------------------------------------ + +CPP14Parser::NoPointerDeclaratorContext::NoPointerDeclaratorContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::DeclaratoridContext* CPP14Parser::NoPointerDeclaratorContext::declaratorid() { + return getRuleContext(0); +} + +CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::NoPointerDeclaratorContext::attributeSpecifierSeq() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::NoPointerDeclaratorContext::LeftParen() { + return getToken(CPP14Parser::LeftParen, 0); +} + +CPP14Parser::PointerDeclaratorContext* CPP14Parser::NoPointerDeclaratorContext::pointerDeclarator() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::NoPointerDeclaratorContext::RightParen() { + return getToken(CPP14Parser::RightParen, 0); +} + +CPP14Parser::NoPointerDeclaratorContext* CPP14Parser::NoPointerDeclaratorContext::noPointerDeclarator() { + return getRuleContext(0); +} + +CPP14Parser::ParametersAndQualifiersContext* CPP14Parser::NoPointerDeclaratorContext::parametersAndQualifiers() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::NoPointerDeclaratorContext::LeftBracket() { + return getToken(CPP14Parser::LeftBracket, 0); +} + +tree::TerminalNode* CPP14Parser::NoPointerDeclaratorContext::RightBracket() { + return getToken(CPP14Parser::RightBracket, 0); +} + +CPP14Parser::ConstantExpressionContext* CPP14Parser::NoPointerDeclaratorContext::constantExpression() { + return getRuleContext(0); +} + + +size_t CPP14Parser::NoPointerDeclaratorContext::getRuleIndex() const { + return CPP14Parser::RuleNoPointerDeclarator; +} + + + +CPP14Parser::NoPointerDeclaratorContext* CPP14Parser::noPointerDeclarator() { + return noPointerDeclarator(0); +} + +CPP14Parser::NoPointerDeclaratorContext* CPP14Parser::noPointerDeclarator(int precedence) { + ParserRuleContext *parentContext = _ctx; + size_t parentState = getState(); + CPP14Parser::NoPointerDeclaratorContext *_localctx = _tracker.createInstance(_ctx, parentState); + CPP14Parser::NoPointerDeclaratorContext *previousContext = _localctx; + (void)previousContext; // Silence compiler, in case the context is not used by generated code. + size_t startState = 230; + enterRecursionRule(_localctx, 230, CPP14Parser::RuleNoPointerDeclarator, precedence); + + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + unrollRecursionContexts(parentContext); + }); + try { + size_t alt; + enterOuterAlt(_localctx, 1); + setState(1426); + _errHandler->sync(this); + switch (_input->LA(1)) { + case CPP14Parser::Decltype: + case CPP14Parser::Operator: + case CPP14Parser::Tilde: + case CPP14Parser::Doublecolon: + case CPP14Parser::Ellipsis: + case CPP14Parser::Identifier: { + setState(1418); + declaratorid(); + setState(1420); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 171, _ctx)) { + case 1: { + setState(1419); + attributeSpecifierSeq(); + break; + } + + default: + break; + } + break; + } + + case CPP14Parser::LeftParen: { + setState(1422); + match(CPP14Parser::LeftParen); + setState(1423); + pointerDeclarator(); + setState(1424); + match(CPP14Parser::RightParen); + break; + } + + default: + throw NoViableAltException(this); + } + _ctx->stop = _input->LT(-1); + setState(1442); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 176, _ctx); + while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { + if (alt == 1) { + if (!_parseListeners.empty()) + triggerExitRuleEvent(); + previousContext = _localctx; + _localctx = _tracker.createInstance(parentContext, parentState); + pushNewRecursionContext(_localctx, startState, RuleNoPointerDeclarator); + setState(1428); + + if (!(precpred(_ctx, 2))) throw FailedPredicateException(this, "precpred(_ctx, 2)"); + setState(1438); + _errHandler->sync(this); + switch (_input->LA(1)) { + case CPP14Parser::LeftParen: { + setState(1429); + parametersAndQualifiers(); + break; + } + + case CPP14Parser::LeftBracket: { + setState(1430); + match(CPP14Parser::LeftBracket); + setState(1432); + _errHandler->sync(this); + + _la = _input->LA(1); + if ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 8364979464334764286) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 65)) & 4719772474384133137) != 0) || _la == CPP14Parser::Identifier) { + setState(1431); + constantExpression(); + } + setState(1434); + match(CPP14Parser::RightBracket); + setState(1436); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 174, _ctx)) { + case 1: { + setState(1435); + attributeSpecifierSeq(); + break; + } + + default: + break; + } + break; + } + + default: + throw NoViableAltException(this); + } + } + setState(1444); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 176, _ctx); + } + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + return _localctx; +} + +//----------------- ParametersAndQualifiersContext ------------------------------------------------------------------ + +CPP14Parser::ParametersAndQualifiersContext::ParametersAndQualifiersContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::ParametersAndQualifiersContext::LeftParen() { + return getToken(CPP14Parser::LeftParen, 0); +} + +tree::TerminalNode* CPP14Parser::ParametersAndQualifiersContext::RightParen() { + return getToken(CPP14Parser::RightParen, 0); +} + +CPP14Parser::ParameterDeclarationClauseContext* CPP14Parser::ParametersAndQualifiersContext::parameterDeclarationClause() { + return getRuleContext(0); +} + +CPP14Parser::CvqualifierseqContext* CPP14Parser::ParametersAndQualifiersContext::cvqualifierseq() { + return getRuleContext(0); +} + +CPP14Parser::RefqualifierContext* CPP14Parser::ParametersAndQualifiersContext::refqualifier() { + return getRuleContext(0); +} + +CPP14Parser::ExceptionSpecificationContext* CPP14Parser::ParametersAndQualifiersContext::exceptionSpecification() { + return getRuleContext(0); +} + +CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::ParametersAndQualifiersContext::attributeSpecifierSeq() { + return getRuleContext(0); +} + + +size_t CPP14Parser::ParametersAndQualifiersContext::getRuleIndex() const { + return CPP14Parser::RuleParametersAndQualifiers; +} + + +CPP14Parser::ParametersAndQualifiersContext* CPP14Parser::parametersAndQualifiers() { + ParametersAndQualifiersContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 232, CPP14Parser::RuleParametersAndQualifiers); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1445); + match(CPP14Parser::LeftParen); + setState(1447); + _errHandler->sync(this); + + _la = _input->LA(1); + if (((((_la - 10) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 10)) & 1237504995584196377) != 0) || ((((_la - 74) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 74)) & 297237575406461917) != 0)) { + setState(1446); + parameterDeclarationClause(); + } + setState(1449); + match(CPP14Parser::RightParen); + setState(1451); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 178, _ctx)) { + case 1: { + setState(1450); + cvqualifierseq(); + break; + } + + default: + break; + } + setState(1454); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 179, _ctx)) { + case 1: { + setState(1453); + refqualifier(); + break; + } + + default: + break; + } + setState(1457); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 180, _ctx)) { + case 1: { + setState(1456); + exceptionSpecification(); + break; + } + + default: + break; + } + setState(1460); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 181, _ctx)) { + case 1: { + setState(1459); + attributeSpecifierSeq(); + break; + } + + default: + break; + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- TrailingReturnTypeContext ------------------------------------------------------------------ + +CPP14Parser::TrailingReturnTypeContext::TrailingReturnTypeContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::TrailingReturnTypeContext::Arrow() { + return getToken(CPP14Parser::Arrow, 0); +} + +CPP14Parser::TrailingTypeSpecifierSeqContext* CPP14Parser::TrailingReturnTypeContext::trailingTypeSpecifierSeq() { + return getRuleContext(0); +} + +CPP14Parser::AbstractDeclaratorContext* CPP14Parser::TrailingReturnTypeContext::abstractDeclarator() { + return getRuleContext(0); +} + + +size_t CPP14Parser::TrailingReturnTypeContext::getRuleIndex() const { + return CPP14Parser::RuleTrailingReturnType; +} + + +CPP14Parser::TrailingReturnTypeContext* CPP14Parser::trailingReturnType() { + TrailingReturnTypeContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 234, CPP14Parser::RuleTrailingReturnType); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1462); + match(CPP14Parser::Arrow); + setState(1463); + trailingTypeSpecifierSeq(); + setState(1465); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 182, _ctx)) { + case 1: { + setState(1464); + abstractDeclarator(); + break; + } + + default: + break; + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- PointerOperatorContext ------------------------------------------------------------------ + +CPP14Parser::PointerOperatorContext::PointerOperatorContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::PointerOperatorContext::And() { + return getToken(CPP14Parser::And, 0); +} + +tree::TerminalNode* CPP14Parser::PointerOperatorContext::AndAnd() { + return getToken(CPP14Parser::AndAnd, 0); +} + +CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::PointerOperatorContext::attributeSpecifierSeq() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::PointerOperatorContext::Star() { + return getToken(CPP14Parser::Star, 0); +} + +CPP14Parser::NestedNameSpecifierContext* CPP14Parser::PointerOperatorContext::nestedNameSpecifier() { + return getRuleContext(0); +} + +CPP14Parser::CvqualifierseqContext* CPP14Parser::PointerOperatorContext::cvqualifierseq() { + return getRuleContext(0); +} + + +size_t CPP14Parser::PointerOperatorContext::getRuleIndex() const { + return CPP14Parser::RulePointerOperator; +} + + +CPP14Parser::PointerOperatorContext* CPP14Parser::pointerOperator() { + PointerOperatorContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 236, CPP14Parser::RulePointerOperator); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(1481); + _errHandler->sync(this); + switch (_input->LA(1)) { + case CPP14Parser::And: + case CPP14Parser::AndAnd: { + enterOuterAlt(_localctx, 1); + setState(1467); + _la = _input->LA(1); + if (!(_la == CPP14Parser::And + + || _la == CPP14Parser::AndAnd)) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + setState(1469); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 183, _ctx)) { + case 1: { + setState(1468); + attributeSpecifierSeq(); + break; + } + + default: + break; + } + break; + } + + case CPP14Parser::Decltype: + case CPP14Parser::Star: + case CPP14Parser::Doublecolon: + case CPP14Parser::Identifier: { + enterOuterAlt(_localctx, 2); + setState(1472); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Decltype || _la == CPP14Parser::Doublecolon + + || _la == CPP14Parser::Identifier) { + setState(1471); + nestedNameSpecifier(0); + } + setState(1474); + match(CPP14Parser::Star); + setState(1476); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 185, _ctx)) { + case 1: { + setState(1475); + attributeSpecifierSeq(); + break; + } + + default: + break; + } + setState(1479); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 186, _ctx)) { + case 1: { + setState(1478); + cvqualifierseq(); + break; + } + + default: + break; + } + break; + } + + default: + throw NoViableAltException(this); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- CvqualifierseqContext ------------------------------------------------------------------ + +CPP14Parser::CvqualifierseqContext::CvqualifierseqContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector CPP14Parser::CvqualifierseqContext::cvQualifier() { + return getRuleContexts(); +} + +CPP14Parser::CvQualifierContext* CPP14Parser::CvqualifierseqContext::cvQualifier(size_t i) { + return getRuleContext(i); +} + + +size_t CPP14Parser::CvqualifierseqContext::getRuleIndex() const { + return CPP14Parser::RuleCvqualifierseq; +} + + +CPP14Parser::CvqualifierseqContext* CPP14Parser::cvqualifierseq() { + CvqualifierseqContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 238, CPP14Parser::RuleCvqualifierseq); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + size_t alt; + enterOuterAlt(_localctx, 1); + setState(1484); + _errHandler->sync(this); + alt = 1; + do { + switch (alt) { + case 1: { + setState(1483); + cvQualifier(); + break; + } + + default: + throw NoViableAltException(this); + } + setState(1486); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 188, _ctx); + } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- CvQualifierContext ------------------------------------------------------------------ + +CPP14Parser::CvQualifierContext::CvQualifierContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::CvQualifierContext::Const() { + return getToken(CPP14Parser::Const, 0); +} + +tree::TerminalNode* CPP14Parser::CvQualifierContext::Volatile() { + return getToken(CPP14Parser::Volatile, 0); +} + + +size_t CPP14Parser::CvQualifierContext::getRuleIndex() const { + return CPP14Parser::RuleCvQualifier; +} + + +CPP14Parser::CvQualifierContext* CPP14Parser::cvQualifier() { + CvQualifierContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 240, CPP14Parser::RuleCvQualifier); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1488); + _la = _input->LA(1); + if (!(_la == CPP14Parser::Const + + || _la == CPP14Parser::Volatile)) { + _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; +} + +//----------------- RefqualifierContext ------------------------------------------------------------------ + +CPP14Parser::RefqualifierContext::RefqualifierContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::RefqualifierContext::And() { + return getToken(CPP14Parser::And, 0); +} + +tree::TerminalNode* CPP14Parser::RefqualifierContext::AndAnd() { + return getToken(CPP14Parser::AndAnd, 0); +} + + +size_t CPP14Parser::RefqualifierContext::getRuleIndex() const { + return CPP14Parser::RuleRefqualifier; +} + + +CPP14Parser::RefqualifierContext* CPP14Parser::refqualifier() { + RefqualifierContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 242, CPP14Parser::RuleRefqualifier); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1490); + _la = _input->LA(1); + if (!(_la == CPP14Parser::And + + || _la == CPP14Parser::AndAnd)) { + _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; +} + +//----------------- DeclaratoridContext ------------------------------------------------------------------ + +CPP14Parser::DeclaratoridContext::DeclaratoridContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::IdExpressionContext* CPP14Parser::DeclaratoridContext::idExpression() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::DeclaratoridContext::Ellipsis() { + return getToken(CPP14Parser::Ellipsis, 0); +} + + +size_t CPP14Parser::DeclaratoridContext::getRuleIndex() const { + return CPP14Parser::RuleDeclaratorid; +} + + +CPP14Parser::DeclaratoridContext* CPP14Parser::declaratorid() { + DeclaratoridContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 244, CPP14Parser::RuleDeclaratorid); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1493); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Ellipsis) { + setState(1492); + match(CPP14Parser::Ellipsis); + } + setState(1495); + idExpression(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- TheTypeIdContext ------------------------------------------------------------------ + +CPP14Parser::TheTypeIdContext::TheTypeIdContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::TypeSpecifierSeqContext* CPP14Parser::TheTypeIdContext::typeSpecifierSeq() { + return getRuleContext(0); +} + +CPP14Parser::AbstractDeclaratorContext* CPP14Parser::TheTypeIdContext::abstractDeclarator() { + return getRuleContext(0); +} + + +size_t CPP14Parser::TheTypeIdContext::getRuleIndex() const { + return CPP14Parser::RuleTheTypeId; +} + + +CPP14Parser::TheTypeIdContext* CPP14Parser::theTypeId() { + TheTypeIdContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 246, CPP14Parser::RuleTheTypeId); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1497); + typeSpecifierSeq(); + setState(1499); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 190, _ctx)) { + case 1: { + setState(1498); + abstractDeclarator(); + break; + } + + default: + break; + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- AbstractDeclaratorContext ------------------------------------------------------------------ + +CPP14Parser::AbstractDeclaratorContext::AbstractDeclaratorContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::PointerAbstractDeclaratorContext* CPP14Parser::AbstractDeclaratorContext::pointerAbstractDeclarator() { + return getRuleContext(0); +} + +CPP14Parser::ParametersAndQualifiersContext* CPP14Parser::AbstractDeclaratorContext::parametersAndQualifiers() { + return getRuleContext(0); +} + +CPP14Parser::TrailingReturnTypeContext* CPP14Parser::AbstractDeclaratorContext::trailingReturnType() { + return getRuleContext(0); +} + +CPP14Parser::NoPointerAbstractDeclaratorContext* CPP14Parser::AbstractDeclaratorContext::noPointerAbstractDeclarator() { + return getRuleContext(0); +} + +CPP14Parser::AbstractPackDeclaratorContext* CPP14Parser::AbstractDeclaratorContext::abstractPackDeclarator() { + return getRuleContext(0); +} + + +size_t CPP14Parser::AbstractDeclaratorContext::getRuleIndex() const { + return CPP14Parser::RuleAbstractDeclarator; +} + + +CPP14Parser::AbstractDeclaratorContext* CPP14Parser::abstractDeclarator() { + AbstractDeclaratorContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 248, CPP14Parser::RuleAbstractDeclarator); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(1509); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 192, _ctx)) { + case 1: { + enterOuterAlt(_localctx, 1); + setState(1501); + pointerAbstractDeclarator(); + break; + } + + case 2: { + enterOuterAlt(_localctx, 2); + setState(1503); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 191, _ctx)) { + case 1: { + setState(1502); + noPointerAbstractDeclarator(0); + break; + } + + default: + break; + } + setState(1505); + parametersAndQualifiers(); + setState(1506); + trailingReturnType(); + break; + } + + case 3: { + enterOuterAlt(_localctx, 3); + setState(1508); + abstractPackDeclarator(); + break; + } + + default: + break; + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- PointerAbstractDeclaratorContext ------------------------------------------------------------------ + +CPP14Parser::PointerAbstractDeclaratorContext::PointerAbstractDeclaratorContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::NoPointerAbstractDeclaratorContext* CPP14Parser::PointerAbstractDeclaratorContext::noPointerAbstractDeclarator() { + return getRuleContext(0); +} + +std::vector CPP14Parser::PointerAbstractDeclaratorContext::pointerOperator() { + return getRuleContexts(); +} + +CPP14Parser::PointerOperatorContext* CPP14Parser::PointerAbstractDeclaratorContext::pointerOperator(size_t i) { + return getRuleContext(i); +} + + +size_t CPP14Parser::PointerAbstractDeclaratorContext::getRuleIndex() const { + return CPP14Parser::RulePointerAbstractDeclarator; +} + + +CPP14Parser::PointerAbstractDeclaratorContext* CPP14Parser::pointerAbstractDeclarator() { + PointerAbstractDeclaratorContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 250, CPP14Parser::RulePointerAbstractDeclarator); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(1520); + _errHandler->sync(this); + switch (_input->LA(1)) { + case CPP14Parser::LeftParen: + case CPP14Parser::LeftBracket: { + enterOuterAlt(_localctx, 1); + setState(1511); + noPointerAbstractDeclarator(0); + break; + } + + case CPP14Parser::Decltype: + case CPP14Parser::Star: + case CPP14Parser::And: + case CPP14Parser::AndAnd: + case CPP14Parser::Doublecolon: + case CPP14Parser::Identifier: { + enterOuterAlt(_localctx, 2); + setState(1513); + _errHandler->sync(this); + _la = _input->LA(1); + do { + setState(1512); + pointerOperator(); + setState(1515); + _errHandler->sync(this); + _la = _input->LA(1); + } while (_la == CPP14Parser::Decltype || ((((_la - 93) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 93)) & 566969237521) != 0)); + setState(1518); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 194, _ctx)) { + case 1: { + setState(1517); + noPointerAbstractDeclarator(0); + break; + } + + default: + break; + } + break; + } + + default: + throw NoViableAltException(this); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- NoPointerAbstractDeclaratorContext ------------------------------------------------------------------ + +CPP14Parser::NoPointerAbstractDeclaratorContext::NoPointerAbstractDeclaratorContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::ParametersAndQualifiersContext* CPP14Parser::NoPointerAbstractDeclaratorContext::parametersAndQualifiers() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::NoPointerAbstractDeclaratorContext::LeftBracket() { + return getToken(CPP14Parser::LeftBracket, 0); +} + +tree::TerminalNode* CPP14Parser::NoPointerAbstractDeclaratorContext::RightBracket() { + return getToken(CPP14Parser::RightBracket, 0); +} + +CPP14Parser::ConstantExpressionContext* CPP14Parser::NoPointerAbstractDeclaratorContext::constantExpression() { + return getRuleContext(0); +} + +CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::NoPointerAbstractDeclaratorContext::attributeSpecifierSeq() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::NoPointerAbstractDeclaratorContext::LeftParen() { + return getToken(CPP14Parser::LeftParen, 0); +} + +CPP14Parser::PointerAbstractDeclaratorContext* CPP14Parser::NoPointerAbstractDeclaratorContext::pointerAbstractDeclarator() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::NoPointerAbstractDeclaratorContext::RightParen() { + return getToken(CPP14Parser::RightParen, 0); +} + +std::vector CPP14Parser::NoPointerAbstractDeclaratorContext::noPointerAbstractDeclarator() { + return getRuleContexts(); +} + +CPP14Parser::NoPointerAbstractDeclaratorContext* CPP14Parser::NoPointerAbstractDeclaratorContext::noPointerAbstractDeclarator(size_t i) { + return getRuleContext(i); +} + + +size_t CPP14Parser::NoPointerAbstractDeclaratorContext::getRuleIndex() const { + return CPP14Parser::RuleNoPointerAbstractDeclarator; +} + + + +CPP14Parser::NoPointerAbstractDeclaratorContext* CPP14Parser::noPointerAbstractDeclarator() { + return noPointerAbstractDeclarator(0); +} + +CPP14Parser::NoPointerAbstractDeclaratorContext* CPP14Parser::noPointerAbstractDeclarator(int precedence) { + ParserRuleContext *parentContext = _ctx; + size_t parentState = getState(); + CPP14Parser::NoPointerAbstractDeclaratorContext *_localctx = _tracker.createInstance(_ctx, parentState); + CPP14Parser::NoPointerAbstractDeclaratorContext *previousContext = _localctx; + (void)previousContext; // Silence compiler, in case the context is not used by generated code. + size_t startState = 252; + enterRecursionRule(_localctx, 252, CPP14Parser::RuleNoPointerAbstractDeclarator, precedence); + + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + unrollRecursionContexts(parentContext); + }); + try { + size_t alt; + enterOuterAlt(_localctx, 1); + setState(1536); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 198, _ctx)) { + case 1: { + setState(1523); + parametersAndQualifiers(); + break; + } + + case 2: { + setState(1524); + match(CPP14Parser::LeftBracket); + setState(1526); + _errHandler->sync(this); + + _la = _input->LA(1); + if ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 8364979464334764286) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 65)) & 4719772474384133137) != 0) || _la == CPP14Parser::Identifier) { + setState(1525); + constantExpression(); + } + setState(1528); + match(CPP14Parser::RightBracket); + setState(1530); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 197, _ctx)) { + case 1: { + setState(1529); + attributeSpecifierSeq(); + break; + } + + default: + break; + } + break; + } + + case 3: { + setState(1532); + match(CPP14Parser::LeftParen); + setState(1533); + pointerAbstractDeclarator(); + setState(1534); + match(CPP14Parser::RightParen); + break; + } + + default: + break; + } + _ctx->stop = _input->LT(-1); + setState(1553); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 202, _ctx); + while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { + if (alt == 1) { + if (!_parseListeners.empty()) + triggerExitRuleEvent(); + previousContext = _localctx; + _localctx = _tracker.createInstance(parentContext, parentState); + pushNewRecursionContext(_localctx, startState, RuleNoPointerAbstractDeclarator); + setState(1538); + + if (!(precpred(_ctx, 4))) throw FailedPredicateException(this, "precpred(_ctx, 4)"); + setState(1549); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 201, _ctx)) { + case 1: { + setState(1539); + parametersAndQualifiers(); + break; + } + + case 2: { + setState(1540); + noPointerAbstractDeclarator(0); + setState(1541); + match(CPP14Parser::LeftBracket); + setState(1543); + _errHandler->sync(this); + + _la = _input->LA(1); + if ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 8364979464334764286) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 65)) & 4719772474384133137) != 0) || _la == CPP14Parser::Identifier) { + setState(1542); + constantExpression(); + } + setState(1545); + match(CPP14Parser::RightBracket); + setState(1547); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 200, _ctx)) { + case 1: { + setState(1546); + attributeSpecifierSeq(); + break; + } + + default: + break; + } + break; + } + + default: + break; + } + } + setState(1555); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 202, _ctx); + } + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + return _localctx; +} + +//----------------- AbstractPackDeclaratorContext ------------------------------------------------------------------ + +CPP14Parser::AbstractPackDeclaratorContext::AbstractPackDeclaratorContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::NoPointerAbstractPackDeclaratorContext* CPP14Parser::AbstractPackDeclaratorContext::noPointerAbstractPackDeclarator() { + return getRuleContext(0); +} + +std::vector CPP14Parser::AbstractPackDeclaratorContext::pointerOperator() { + return getRuleContexts(); +} + +CPP14Parser::PointerOperatorContext* CPP14Parser::AbstractPackDeclaratorContext::pointerOperator(size_t i) { + return getRuleContext(i); +} + + +size_t CPP14Parser::AbstractPackDeclaratorContext::getRuleIndex() const { + return CPP14Parser::RuleAbstractPackDeclarator; +} + + +CPP14Parser::AbstractPackDeclaratorContext* CPP14Parser::abstractPackDeclarator() { + AbstractPackDeclaratorContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 254, CPP14Parser::RuleAbstractPackDeclarator); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1559); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == CPP14Parser::Decltype || ((((_la - 93) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 93)) & 566969237521) != 0)) { + setState(1556); + pointerOperator(); + setState(1561); + _errHandler->sync(this); + _la = _input->LA(1); + } + setState(1562); + noPointerAbstractPackDeclarator(0); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- NoPointerAbstractPackDeclaratorContext ------------------------------------------------------------------ + +CPP14Parser::NoPointerAbstractPackDeclaratorContext::NoPointerAbstractPackDeclaratorContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::NoPointerAbstractPackDeclaratorContext::Ellipsis() { + return getToken(CPP14Parser::Ellipsis, 0); +} + +CPP14Parser::NoPointerAbstractPackDeclaratorContext* CPP14Parser::NoPointerAbstractPackDeclaratorContext::noPointerAbstractPackDeclarator() { + return getRuleContext(0); +} + +CPP14Parser::ParametersAndQualifiersContext* CPP14Parser::NoPointerAbstractPackDeclaratorContext::parametersAndQualifiers() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::NoPointerAbstractPackDeclaratorContext::LeftBracket() { + return getToken(CPP14Parser::LeftBracket, 0); +} + +tree::TerminalNode* CPP14Parser::NoPointerAbstractPackDeclaratorContext::RightBracket() { + return getToken(CPP14Parser::RightBracket, 0); +} + +CPP14Parser::ConstantExpressionContext* CPP14Parser::NoPointerAbstractPackDeclaratorContext::constantExpression() { + return getRuleContext(0); +} + +CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::NoPointerAbstractPackDeclaratorContext::attributeSpecifierSeq() { + return getRuleContext(0); +} + + +size_t CPP14Parser::NoPointerAbstractPackDeclaratorContext::getRuleIndex() const { + return CPP14Parser::RuleNoPointerAbstractPackDeclarator; +} + + + +CPP14Parser::NoPointerAbstractPackDeclaratorContext* CPP14Parser::noPointerAbstractPackDeclarator() { + return noPointerAbstractPackDeclarator(0); +} + +CPP14Parser::NoPointerAbstractPackDeclaratorContext* CPP14Parser::noPointerAbstractPackDeclarator(int precedence) { + ParserRuleContext *parentContext = _ctx; + size_t parentState = getState(); + CPP14Parser::NoPointerAbstractPackDeclaratorContext *_localctx = _tracker.createInstance(_ctx, parentState); + CPP14Parser::NoPointerAbstractPackDeclaratorContext *previousContext = _localctx; + (void)previousContext; // Silence compiler, in case the context is not used by generated code. + size_t startState = 256; + enterRecursionRule(_localctx, 256, CPP14Parser::RuleNoPointerAbstractPackDeclarator, precedence); + + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + unrollRecursionContexts(parentContext); + }); + try { + size_t alt; + enterOuterAlt(_localctx, 1); + setState(1565); + match(CPP14Parser::Ellipsis); + _ctx->stop = _input->LT(-1); + setState(1581); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 207, _ctx); + while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { + if (alt == 1) { + if (!_parseListeners.empty()) + triggerExitRuleEvent(); + previousContext = _localctx; + _localctx = _tracker.createInstance(parentContext, parentState); + pushNewRecursionContext(_localctx, startState, RuleNoPointerAbstractPackDeclarator); + setState(1567); + + if (!(precpred(_ctx, 2))) throw FailedPredicateException(this, "precpred(_ctx, 2)"); + setState(1577); + _errHandler->sync(this); + switch (_input->LA(1)) { + case CPP14Parser::LeftParen: { + setState(1568); + parametersAndQualifiers(); + break; + } + + case CPP14Parser::LeftBracket: { + setState(1569); + match(CPP14Parser::LeftBracket); + setState(1571); + _errHandler->sync(this); + + _la = _input->LA(1); + if ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 8364979464334764286) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 65)) & 4719772474384133137) != 0) || _la == CPP14Parser::Identifier) { + setState(1570); + constantExpression(); + } + setState(1573); + match(CPP14Parser::RightBracket); + setState(1575); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 205, _ctx)) { + case 1: { + setState(1574); + attributeSpecifierSeq(); + break; + } + + default: + break; + } + break; + } + + default: + throw NoViableAltException(this); + } + } + setState(1583); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 207, _ctx); + } + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + return _localctx; +} + +//----------------- ParameterDeclarationClauseContext ------------------------------------------------------------------ + +CPP14Parser::ParameterDeclarationClauseContext::ParameterDeclarationClauseContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::ParameterDeclarationListContext* CPP14Parser::ParameterDeclarationClauseContext::parameterDeclarationList() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::ParameterDeclarationClauseContext::Ellipsis() { + return getToken(CPP14Parser::Ellipsis, 0); +} + +tree::TerminalNode* CPP14Parser::ParameterDeclarationClauseContext::Comma() { + return getToken(CPP14Parser::Comma, 0); +} + + +size_t CPP14Parser::ParameterDeclarationClauseContext::getRuleIndex() const { + return CPP14Parser::RuleParameterDeclarationClause; +} + + +CPP14Parser::ParameterDeclarationClauseContext* CPP14Parser::parameterDeclarationClause() { + ParameterDeclarationClauseContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 258, CPP14Parser::RuleParameterDeclarationClause); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1584); + parameterDeclarationList(); + setState(1589); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Comma + + || _la == CPP14Parser::Ellipsis) { + setState(1586); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Comma) { + setState(1585); + match(CPP14Parser::Comma); + } + setState(1588); + match(CPP14Parser::Ellipsis); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ParameterDeclarationListContext ------------------------------------------------------------------ + +CPP14Parser::ParameterDeclarationListContext::ParameterDeclarationListContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector CPP14Parser::ParameterDeclarationListContext::parameterDeclaration() { + return getRuleContexts(); +} + +CPP14Parser::ParameterDeclarationContext* CPP14Parser::ParameterDeclarationListContext::parameterDeclaration(size_t i) { + return getRuleContext(i); +} + +std::vector CPP14Parser::ParameterDeclarationListContext::Comma() { + return getTokens(CPP14Parser::Comma); +} + +tree::TerminalNode* CPP14Parser::ParameterDeclarationListContext::Comma(size_t i) { + return getToken(CPP14Parser::Comma, i); +} + + +size_t CPP14Parser::ParameterDeclarationListContext::getRuleIndex() const { + return CPP14Parser::RuleParameterDeclarationList; +} + + +CPP14Parser::ParameterDeclarationListContext* CPP14Parser::parameterDeclarationList() { + ParameterDeclarationListContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 260, CPP14Parser::RuleParameterDeclarationList); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + size_t alt; + enterOuterAlt(_localctx, 1); + setState(1591); + parameterDeclaration(); + setState(1596); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 210, _ctx); + while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { + if (alt == 1) { + setState(1592); + match(CPP14Parser::Comma); + setState(1593); + parameterDeclaration(); + } + setState(1598); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 210, _ctx); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ParameterDeclarationContext ------------------------------------------------------------------ + +CPP14Parser::ParameterDeclarationContext::ParameterDeclarationContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::DeclSpecifierSeqContext* CPP14Parser::ParameterDeclarationContext::declSpecifierSeq() { + return getRuleContext(0); +} + +CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::ParameterDeclarationContext::attributeSpecifierSeq() { + return getRuleContext(0); +} + +CPP14Parser::DeclaratorContext* CPP14Parser::ParameterDeclarationContext::declarator() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::ParameterDeclarationContext::Assign() { + return getToken(CPP14Parser::Assign, 0); +} + +CPP14Parser::InitializerClauseContext* CPP14Parser::ParameterDeclarationContext::initializerClause() { + return getRuleContext(0); +} + +CPP14Parser::AbstractDeclaratorContext* CPP14Parser::ParameterDeclarationContext::abstractDeclarator() { + return getRuleContext(0); +} + + +size_t CPP14Parser::ParameterDeclarationContext::getRuleIndex() const { + return CPP14Parser::RuleParameterDeclaration; +} + + +CPP14Parser::ParameterDeclarationContext* CPP14Parser::parameterDeclaration() { + ParameterDeclarationContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 262, CPP14Parser::RuleParameterDeclaration); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1600); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Alignas || _la == CPP14Parser::LeftBracket) { + setState(1599); + attributeSpecifierSeq(); + } + setState(1602); + declSpecifierSeq(); + + setState(1607); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 213, _ctx)) { + case 1: { + setState(1603); + declarator(); + break; + } + + case 2: { + setState(1605); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 212, _ctx)) { + case 1: { + setState(1604); + abstractDeclarator(); + break; + } + + default: + break; + } + break; + } + + default: + break; + } + setState(1611); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Assign) { + setState(1609); + match(CPP14Parser::Assign); + setState(1610); + initializerClause(); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- FunctionDefinitionContext ------------------------------------------------------------------ + +CPP14Parser::FunctionDefinitionContext::FunctionDefinitionContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::DeclaratorContext* CPP14Parser::FunctionDefinitionContext::declarator() { + return getRuleContext(0); +} + +CPP14Parser::FunctionBodyContext* CPP14Parser::FunctionDefinitionContext::functionBody() { + return getRuleContext(0); +} + +CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::FunctionDefinitionContext::attributeSpecifierSeq() { + return getRuleContext(0); +} + +CPP14Parser::DeclSpecifierSeqContext* CPP14Parser::FunctionDefinitionContext::declSpecifierSeq() { + return getRuleContext(0); +} + +CPP14Parser::VirtualSpecifierSeqContext* CPP14Parser::FunctionDefinitionContext::virtualSpecifierSeq() { + return getRuleContext(0); +} + + +size_t CPP14Parser::FunctionDefinitionContext::getRuleIndex() const { + return CPP14Parser::RuleFunctionDefinition; +} + + +CPP14Parser::FunctionDefinitionContext* CPP14Parser::functionDefinition() { + FunctionDefinitionContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 264, CPP14Parser::RuleFunctionDefinition); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1614); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Alignas || _la == CPP14Parser::LeftBracket) { + setState(1613); + attributeSpecifierSeq(); + } + setState(1617); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 216, _ctx)) { + case 1: { + setState(1616); + declSpecifierSeq(); + break; + } + + default: + break; + } + setState(1619); + declarator(); + setState(1621); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Final + + || _la == CPP14Parser::Override) { + setState(1620); + virtualSpecifierSeq(); + } + setState(1623); + functionBody(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- FunctionBodyContext ------------------------------------------------------------------ + +CPP14Parser::FunctionBodyContext::FunctionBodyContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::CompoundStatementContext* CPP14Parser::FunctionBodyContext::compoundStatement() { + return getRuleContext(0); +} + +CPP14Parser::ConstructorInitializerContext* CPP14Parser::FunctionBodyContext::constructorInitializer() { + return getRuleContext(0); +} + +CPP14Parser::FunctionTryBlockContext* CPP14Parser::FunctionBodyContext::functionTryBlock() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::FunctionBodyContext::Assign() { + return getToken(CPP14Parser::Assign, 0); +} + +tree::TerminalNode* CPP14Parser::FunctionBodyContext::Semi() { + return getToken(CPP14Parser::Semi, 0); +} + +tree::TerminalNode* CPP14Parser::FunctionBodyContext::Default() { + return getToken(CPP14Parser::Default, 0); +} + +tree::TerminalNode* CPP14Parser::FunctionBodyContext::Delete() { + return getToken(CPP14Parser::Delete, 0); +} + + +size_t CPP14Parser::FunctionBodyContext::getRuleIndex() const { + return CPP14Parser::RuleFunctionBody; +} + + +CPP14Parser::FunctionBodyContext* CPP14Parser::functionBody() { + FunctionBodyContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 266, CPP14Parser::RuleFunctionBody); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(1633); + _errHandler->sync(this); + switch (_input->LA(1)) { + case CPP14Parser::LeftBrace: + case CPP14Parser::Colon: { + enterOuterAlt(_localctx, 1); + setState(1626); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Colon) { + setState(1625); + constructorInitializer(); + } + setState(1628); + compoundStatement(); + break; + } + + case CPP14Parser::Try: { + enterOuterAlt(_localctx, 2); + setState(1629); + functionTryBlock(); + break; + } + + case CPP14Parser::Assign: { + enterOuterAlt(_localctx, 3); + setState(1630); + match(CPP14Parser::Assign); + setState(1631); + _la = _input->LA(1); + if (!(_la == CPP14Parser::Default + + || _la == CPP14Parser::Delete)) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + setState(1632); + match(CPP14Parser::Semi); + break; + } + + default: + throw NoViableAltException(this); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- InitializerContext ------------------------------------------------------------------ + +CPP14Parser::InitializerContext::InitializerContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::BraceOrEqualInitializerContext* CPP14Parser::InitializerContext::braceOrEqualInitializer() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::InitializerContext::LeftParen() { + return getToken(CPP14Parser::LeftParen, 0); +} + +CPP14Parser::ExpressionListContext* CPP14Parser::InitializerContext::expressionList() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::InitializerContext::RightParen() { + return getToken(CPP14Parser::RightParen, 0); +} + + +size_t CPP14Parser::InitializerContext::getRuleIndex() const { + return CPP14Parser::RuleInitializer; +} + + +CPP14Parser::InitializerContext* CPP14Parser::initializer() { + InitializerContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 268, CPP14Parser::RuleInitializer); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(1640); + _errHandler->sync(this); + switch (_input->LA(1)) { + case CPP14Parser::LeftBrace: + case CPP14Parser::Assign: { + enterOuterAlt(_localctx, 1); + setState(1635); + braceOrEqualInitializer(); + break; + } + + case CPP14Parser::LeftParen: { + enterOuterAlt(_localctx, 2); + setState(1636); + match(CPP14Parser::LeftParen); + setState(1637); + expressionList(); + setState(1638); + match(CPP14Parser::RightParen); + break; + } + + default: + throw NoViableAltException(this); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- BraceOrEqualInitializerContext ------------------------------------------------------------------ + +CPP14Parser::BraceOrEqualInitializerContext::BraceOrEqualInitializerContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::BraceOrEqualInitializerContext::Assign() { + return getToken(CPP14Parser::Assign, 0); +} + +CPP14Parser::InitializerClauseContext* CPP14Parser::BraceOrEqualInitializerContext::initializerClause() { + return getRuleContext(0); +} + +CPP14Parser::BracedInitListContext* CPP14Parser::BraceOrEqualInitializerContext::bracedInitList() { + return getRuleContext(0); +} + + +size_t CPP14Parser::BraceOrEqualInitializerContext::getRuleIndex() const { + return CPP14Parser::RuleBraceOrEqualInitializer; +} + + +CPP14Parser::BraceOrEqualInitializerContext* CPP14Parser::braceOrEqualInitializer() { + BraceOrEqualInitializerContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 270, CPP14Parser::RuleBraceOrEqualInitializer); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(1645); + _errHandler->sync(this); + switch (_input->LA(1)) { + case CPP14Parser::Assign: { + enterOuterAlt(_localctx, 1); + setState(1642); + match(CPP14Parser::Assign); + setState(1643); + initializerClause(); + break; + } + + case CPP14Parser::LeftBrace: { + enterOuterAlt(_localctx, 2); + setState(1644); + bracedInitList(); + break; + } + + default: + throw NoViableAltException(this); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- InitializerClauseContext ------------------------------------------------------------------ + +CPP14Parser::InitializerClauseContext::InitializerClauseContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::AssignmentExpressionContext* CPP14Parser::InitializerClauseContext::assignmentExpression() { + return getRuleContext(0); +} + +CPP14Parser::BracedInitListContext* CPP14Parser::InitializerClauseContext::bracedInitList() { + return getRuleContext(0); +} + + +size_t CPP14Parser::InitializerClauseContext::getRuleIndex() const { + return CPP14Parser::RuleInitializerClause; +} + + +CPP14Parser::InitializerClauseContext* CPP14Parser::initializerClause() { + InitializerClauseContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 272, CPP14Parser::RuleInitializerClause); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(1649); + _errHandler->sync(this); + switch (_input->LA(1)) { + case CPP14Parser::IntegerLiteral: + case CPP14Parser::CharacterLiteral: + case CPP14Parser::FloatingLiteral: + case CPP14Parser::StringLiteral: + case CPP14Parser::BooleanLiteral: + case CPP14Parser::PointerLiteral: + case CPP14Parser::UserDefinedLiteral: + case CPP14Parser::Alignof: + case CPP14Parser::Auto: + case CPP14Parser::Bool: + case CPP14Parser::Char: + case CPP14Parser::Char16: + case CPP14Parser::Char32: + case CPP14Parser::Const_cast: + case CPP14Parser::Decltype: + case CPP14Parser::Delete: + case CPP14Parser::Double: + case CPP14Parser::Dynamic_cast: + case CPP14Parser::Float: + case CPP14Parser::Int: + case CPP14Parser::Long: + case CPP14Parser::New: + case CPP14Parser::Noexcept: + case CPP14Parser::Operator: + case CPP14Parser::Reinterpret_cast: + case CPP14Parser::Short: + case CPP14Parser::Signed: + case CPP14Parser::Sizeof: + case CPP14Parser::Static_cast: + case CPP14Parser::This: + case CPP14Parser::Throw: + case CPP14Parser::Typeid_: + case CPP14Parser::Typename_: + case CPP14Parser::Unsigned: + case CPP14Parser::Void: + case CPP14Parser::Wchar: + case CPP14Parser::LeftParen: + case CPP14Parser::LeftBracket: + case CPP14Parser::Plus: + case CPP14Parser::Minus: + case CPP14Parser::Star: + case CPP14Parser::And: + case CPP14Parser::Or: + case CPP14Parser::Tilde: + case CPP14Parser::Not: + case CPP14Parser::PlusPlus: + case CPP14Parser::MinusMinus: + case CPP14Parser::Doublecolon: + case CPP14Parser::Identifier: { + enterOuterAlt(_localctx, 1); + setState(1647); + assignmentExpression(); + break; + } + + case CPP14Parser::LeftBrace: { + enterOuterAlt(_localctx, 2); + setState(1648); + bracedInitList(); + break; + } + + default: + throw NoViableAltException(this); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- InitializerListContext ------------------------------------------------------------------ + +CPP14Parser::InitializerListContext::InitializerListContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector CPP14Parser::InitializerListContext::initializerClause() { + return getRuleContexts(); +} + +CPP14Parser::InitializerClauseContext* CPP14Parser::InitializerListContext::initializerClause(size_t i) { + return getRuleContext(i); +} + +std::vector CPP14Parser::InitializerListContext::Ellipsis() { + return getTokens(CPP14Parser::Ellipsis); +} + +tree::TerminalNode* CPP14Parser::InitializerListContext::Ellipsis(size_t i) { + return getToken(CPP14Parser::Ellipsis, i); +} + +std::vector CPP14Parser::InitializerListContext::Comma() { + return getTokens(CPP14Parser::Comma); +} + +tree::TerminalNode* CPP14Parser::InitializerListContext::Comma(size_t i) { + return getToken(CPP14Parser::Comma, i); +} + + +size_t CPP14Parser::InitializerListContext::getRuleIndex() const { + return CPP14Parser::RuleInitializerList; +} + + +CPP14Parser::InitializerListContext* CPP14Parser::initializerList() { + InitializerListContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 274, CPP14Parser::RuleInitializerList); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + size_t alt; + enterOuterAlt(_localctx, 1); + setState(1651); + initializerClause(); + setState(1653); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Ellipsis) { + setState(1652); + match(CPP14Parser::Ellipsis); + } + setState(1662); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 225, _ctx); + while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { + if (alt == 1) { + setState(1655); + match(CPP14Parser::Comma); + setState(1656); + initializerClause(); + setState(1658); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Ellipsis) { + setState(1657); + match(CPP14Parser::Ellipsis); + } + } + setState(1664); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 225, _ctx); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- BracedInitListContext ------------------------------------------------------------------ + +CPP14Parser::BracedInitListContext::BracedInitListContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::BracedInitListContext::LeftBrace() { + return getToken(CPP14Parser::LeftBrace, 0); +} + +tree::TerminalNode* CPP14Parser::BracedInitListContext::RightBrace() { + return getToken(CPP14Parser::RightBrace, 0); +} + +CPP14Parser::InitializerListContext* CPP14Parser::BracedInitListContext::initializerList() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::BracedInitListContext::Comma() { + return getToken(CPP14Parser::Comma, 0); +} + + +size_t CPP14Parser::BracedInitListContext::getRuleIndex() const { + return CPP14Parser::RuleBracedInitList; +} + + +CPP14Parser::BracedInitListContext* CPP14Parser::bracedInitList() { + BracedInitListContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 276, CPP14Parser::RuleBracedInitList); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1665); + match(CPP14Parser::LeftBrace); + setState(1670); + _errHandler->sync(this); + + _la = _input->LA(1); + if ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 8364979464334764286) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 65)) & 4719772474400910417) != 0) || _la == CPP14Parser::Identifier) { + setState(1666); + initializerList(); + setState(1668); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Comma) { + setState(1667); + match(CPP14Parser::Comma); + } + } + setState(1672); + match(CPP14Parser::RightBrace); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ClassNameContext ------------------------------------------------------------------ + +CPP14Parser::ClassNameContext::ClassNameContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::ClassNameContext::Identifier() { + return getToken(CPP14Parser::Identifier, 0); +} + +CPP14Parser::SimpleTemplateIdContext* CPP14Parser::ClassNameContext::simpleTemplateId() { + return getRuleContext(0); +} + + +size_t CPP14Parser::ClassNameContext::getRuleIndex() const { + return CPP14Parser::RuleClassName; +} + + +CPP14Parser::ClassNameContext* CPP14Parser::className() { + ClassNameContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 278, CPP14Parser::RuleClassName); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(1676); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 228, _ctx)) { + case 1: { + enterOuterAlt(_localctx, 1); + setState(1674); + match(CPP14Parser::Identifier); + break; + } + + case 2: { + enterOuterAlt(_localctx, 2); + setState(1675); + simpleTemplateId(); + break; + } + + default: + break; + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ClassSpecifierContext ------------------------------------------------------------------ + +CPP14Parser::ClassSpecifierContext::ClassSpecifierContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::ClassHeadContext* CPP14Parser::ClassSpecifierContext::classHead() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::ClassSpecifierContext::LeftBrace() { + return getToken(CPP14Parser::LeftBrace, 0); +} + +tree::TerminalNode* CPP14Parser::ClassSpecifierContext::RightBrace() { + return getToken(CPP14Parser::RightBrace, 0); +} + +CPP14Parser::MemberSpecificationContext* CPP14Parser::ClassSpecifierContext::memberSpecification() { + return getRuleContext(0); +} + + +size_t CPP14Parser::ClassSpecifierContext::getRuleIndex() const { + return CPP14Parser::RuleClassSpecifier; +} + + +CPP14Parser::ClassSpecifierContext* CPP14Parser::classSpecifier() { + ClassSpecifierContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 280, CPP14Parser::RuleClassSpecifier); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1678); + classHead(); + setState(1679); + match(CPP14Parser::LeftBrace); + setState(1681); + _errHandler->sync(this); + + _la = _input->LA(1); + if (((((_la - 10) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 10)) & 1543877313594212121) != 0) || ((((_la - 74) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 74)) & 463888353847684093) != 0)) { + setState(1680); + memberSpecification(); + } + setState(1683); + match(CPP14Parser::RightBrace); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ClassHeadContext ------------------------------------------------------------------ + +CPP14Parser::ClassHeadContext::ClassHeadContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::ClassKeyContext* CPP14Parser::ClassHeadContext::classKey() { + return getRuleContext(0); +} + +CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::ClassHeadContext::attributeSpecifierSeq() { + return getRuleContext(0); +} + +CPP14Parser::ClassHeadNameContext* CPP14Parser::ClassHeadContext::classHeadName() { + return getRuleContext(0); +} + +CPP14Parser::BaseClauseContext* CPP14Parser::ClassHeadContext::baseClause() { + return getRuleContext(0); +} + +CPP14Parser::ClassVirtSpecifierContext* CPP14Parser::ClassHeadContext::classVirtSpecifier() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::ClassHeadContext::Union() { + return getToken(CPP14Parser::Union, 0); +} + + +size_t CPP14Parser::ClassHeadContext::getRuleIndex() const { + return CPP14Parser::RuleClassHead; +} + + +CPP14Parser::ClassHeadContext* CPP14Parser::classHead() { + ClassHeadContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 282, CPP14Parser::RuleClassHead); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(1708); + _errHandler->sync(this); + switch (_input->LA(1)) { + case CPP14Parser::Class: + case CPP14Parser::Struct: { + enterOuterAlt(_localctx, 1); + setState(1685); + classKey(); + setState(1687); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Alignas || _la == CPP14Parser::LeftBracket) { + setState(1686); + attributeSpecifierSeq(); + } + setState(1693); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Decltype || _la == CPP14Parser::Doublecolon + + || _la == CPP14Parser::Identifier) { + setState(1689); + classHeadName(); + setState(1691); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Final) { + setState(1690); + classVirtSpecifier(); + } + } + setState(1696); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Colon) { + setState(1695); + baseClause(); + } + break; + } + + case CPP14Parser::Union: { + enterOuterAlt(_localctx, 2); + setState(1698); + match(CPP14Parser::Union); + setState(1700); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Alignas || _la == CPP14Parser::LeftBracket) { + setState(1699); + attributeSpecifierSeq(); + } + setState(1706); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Decltype || _la == CPP14Parser::Doublecolon + + || _la == CPP14Parser::Identifier) { + setState(1702); + classHeadName(); + setState(1704); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Final) { + setState(1703); + classVirtSpecifier(); + } + } + break; + } + + default: + throw NoViableAltException(this); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ClassHeadNameContext ------------------------------------------------------------------ + +CPP14Parser::ClassHeadNameContext::ClassHeadNameContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::ClassNameContext* CPP14Parser::ClassHeadNameContext::className() { + return getRuleContext(0); +} + +CPP14Parser::NestedNameSpecifierContext* CPP14Parser::ClassHeadNameContext::nestedNameSpecifier() { + return getRuleContext(0); +} + + +size_t CPP14Parser::ClassHeadNameContext::getRuleIndex() const { + return CPP14Parser::RuleClassHeadName; +} + + +CPP14Parser::ClassHeadNameContext* CPP14Parser::classHeadName() { + ClassHeadNameContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 284, CPP14Parser::RuleClassHeadName); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1711); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 238, _ctx)) { + case 1: { + setState(1710); + nestedNameSpecifier(0); + break; + } + + default: + break; + } + setState(1713); + className(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ClassVirtSpecifierContext ------------------------------------------------------------------ + +CPP14Parser::ClassVirtSpecifierContext::ClassVirtSpecifierContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::ClassVirtSpecifierContext::Final() { + return getToken(CPP14Parser::Final, 0); +} + + +size_t CPP14Parser::ClassVirtSpecifierContext::getRuleIndex() const { + return CPP14Parser::RuleClassVirtSpecifier; +} + + +CPP14Parser::ClassVirtSpecifierContext* CPP14Parser::classVirtSpecifier() { + ClassVirtSpecifierContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 286, CPP14Parser::RuleClassVirtSpecifier); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1715); + match(CPP14Parser::Final); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ClassKeyContext ------------------------------------------------------------------ + +CPP14Parser::ClassKeyContext::ClassKeyContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::ClassKeyContext::Class() { + return getToken(CPP14Parser::Class, 0); +} + +tree::TerminalNode* CPP14Parser::ClassKeyContext::Struct() { + return getToken(CPP14Parser::Struct, 0); +} + + +size_t CPP14Parser::ClassKeyContext::getRuleIndex() const { + return CPP14Parser::RuleClassKey; +} + + +CPP14Parser::ClassKeyContext* CPP14Parser::classKey() { + ClassKeyContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 288, CPP14Parser::RuleClassKey); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1717); + _la = _input->LA(1); + if (!(_la == CPP14Parser::Class + + || _la == CPP14Parser::Struct)) { + _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; +} + +//----------------- MemberSpecificationContext ------------------------------------------------------------------ + +CPP14Parser::MemberSpecificationContext::MemberSpecificationContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector CPP14Parser::MemberSpecificationContext::memberdeclaration() { + return getRuleContexts(); +} + +CPP14Parser::MemberdeclarationContext* CPP14Parser::MemberSpecificationContext::memberdeclaration(size_t i) { + return getRuleContext(i); +} + +std::vector CPP14Parser::MemberSpecificationContext::accessSpecifier() { + return getRuleContexts(); +} + +CPP14Parser::AccessSpecifierContext* CPP14Parser::MemberSpecificationContext::accessSpecifier(size_t i) { + return getRuleContext(i); +} + +std::vector CPP14Parser::MemberSpecificationContext::Colon() { + return getTokens(CPP14Parser::Colon); +} + +tree::TerminalNode* CPP14Parser::MemberSpecificationContext::Colon(size_t i) { + return getToken(CPP14Parser::Colon, i); +} + + +size_t CPP14Parser::MemberSpecificationContext::getRuleIndex() const { + return CPP14Parser::RuleMemberSpecification; +} + + +CPP14Parser::MemberSpecificationContext* CPP14Parser::memberSpecification() { + MemberSpecificationContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 290, CPP14Parser::RuleMemberSpecification); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1723); + _errHandler->sync(this); + _la = _input->LA(1); + do { + setState(1723); + _errHandler->sync(this); + switch (_input->LA(1)) { + case CPP14Parser::Alignas: + case CPP14Parser::Auto: + case CPP14Parser::Bool: + case CPP14Parser::Char: + case CPP14Parser::Char16: + case CPP14Parser::Char32: + case CPP14Parser::Class: + case CPP14Parser::Const: + case CPP14Parser::Constexpr: + case CPP14Parser::Decltype: + case CPP14Parser::Double: + case CPP14Parser::Enum: + case CPP14Parser::Explicit: + case CPP14Parser::Extern: + case CPP14Parser::Float: + case CPP14Parser::Friend: + case CPP14Parser::Inline: + case CPP14Parser::Int: + case CPP14Parser::Long: + case CPP14Parser::Mutable: + case CPP14Parser::Operator: + case CPP14Parser::Register: + case CPP14Parser::Short: + case CPP14Parser::Signed: + case CPP14Parser::Static: + case CPP14Parser::Static_assert: + case CPP14Parser::Struct: + case CPP14Parser::Template: + case CPP14Parser::Thread_local: + case CPP14Parser::Typedef: + case CPP14Parser::Typename_: + case CPP14Parser::Union: + case CPP14Parser::Unsigned: + case CPP14Parser::Using: + case CPP14Parser::Virtual: + case CPP14Parser::Void: + case CPP14Parser::Volatile: + case CPP14Parser::Wchar: + case CPP14Parser::LeftParen: + case CPP14Parser::LeftBracket: + case CPP14Parser::Star: + case CPP14Parser::And: + case CPP14Parser::Tilde: + case CPP14Parser::AndAnd: + case CPP14Parser::Colon: + case CPP14Parser::Doublecolon: + case CPP14Parser::Semi: + case CPP14Parser::Ellipsis: + case CPP14Parser::Identifier: { + setState(1719); + memberdeclaration(); + break; + } + + case CPP14Parser::Private: + case CPP14Parser::Protected: + case CPP14Parser::Public: { + setState(1720); + accessSpecifier(); + setState(1721); + match(CPP14Parser::Colon); + break; + } + + default: + throw NoViableAltException(this); + } + setState(1725); + _errHandler->sync(this); + _la = _input->LA(1); + } while (((((_la - 10) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 10)) & 1543877313594212121) != 0) || ((((_la - 74) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 74)) & 463888353847684093) != 0)); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- MemberdeclarationContext ------------------------------------------------------------------ + +CPP14Parser::MemberdeclarationContext::MemberdeclarationContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::MemberdeclarationContext::Semi() { + return getToken(CPP14Parser::Semi, 0); +} + +CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::MemberdeclarationContext::attributeSpecifierSeq() { + return getRuleContext(0); +} + +CPP14Parser::DeclSpecifierSeqContext* CPP14Parser::MemberdeclarationContext::declSpecifierSeq() { + return getRuleContext(0); +} + +CPP14Parser::MemberDeclaratorListContext* CPP14Parser::MemberdeclarationContext::memberDeclaratorList() { + return getRuleContext(0); +} + +CPP14Parser::FunctionDefinitionContext* CPP14Parser::MemberdeclarationContext::functionDefinition() { + return getRuleContext(0); +} + +CPP14Parser::UsingDeclarationContext* CPP14Parser::MemberdeclarationContext::usingDeclaration() { + return getRuleContext(0); +} + +CPP14Parser::StaticAssertDeclarationContext* CPP14Parser::MemberdeclarationContext::staticAssertDeclaration() { + return getRuleContext(0); +} + +CPP14Parser::TemplateDeclarationContext* CPP14Parser::MemberdeclarationContext::templateDeclaration() { + return getRuleContext(0); +} + +CPP14Parser::AliasDeclarationContext* CPP14Parser::MemberdeclarationContext::aliasDeclaration() { + return getRuleContext(0); +} + +CPP14Parser::EmptyDeclarationContext* CPP14Parser::MemberdeclarationContext::emptyDeclaration() { + return getRuleContext(0); +} + + +size_t CPP14Parser::MemberdeclarationContext::getRuleIndex() const { + return CPP14Parser::RuleMemberdeclaration; +} + + +CPP14Parser::MemberdeclarationContext* CPP14Parser::memberdeclaration() { + MemberdeclarationContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 292, CPP14Parser::RuleMemberdeclaration); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(1743); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 244, _ctx)) { + case 1: { + enterOuterAlt(_localctx, 1); + setState(1728); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 241, _ctx)) { + case 1: { + setState(1727); + attributeSpecifierSeq(); + break; + } + + default: + break; + } + setState(1731); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 242, _ctx)) { + case 1: { + setState(1730); + declSpecifierSeq(); + break; + } + + default: + break; + } + setState(1734); + _errHandler->sync(this); + + _la = _input->LA(1); + if ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 4503599694480384) != 0) || ((((_la - 85) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 85)) & 217711892254981) != 0)) { + setState(1733); + memberDeclaratorList(); + } + setState(1736); + match(CPP14Parser::Semi); + break; + } + + case 2: { + enterOuterAlt(_localctx, 2); + setState(1737); + functionDefinition(); + break; + } + + case 3: { + enterOuterAlt(_localctx, 3); + setState(1738); + usingDeclaration(); + break; + } + + case 4: { + enterOuterAlt(_localctx, 4); + setState(1739); + staticAssertDeclaration(); + break; + } + + case 5: { + enterOuterAlt(_localctx, 5); + setState(1740); + templateDeclaration(); + break; + } + + case 6: { + enterOuterAlt(_localctx, 6); + setState(1741); + aliasDeclaration(); + break; + } + + case 7: { + enterOuterAlt(_localctx, 7); + setState(1742); + emptyDeclaration(); + break; + } + + default: + break; + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- MemberDeclaratorListContext ------------------------------------------------------------------ + +CPP14Parser::MemberDeclaratorListContext::MemberDeclaratorListContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector CPP14Parser::MemberDeclaratorListContext::memberDeclarator() { + return getRuleContexts(); +} + +CPP14Parser::MemberDeclaratorContext* CPP14Parser::MemberDeclaratorListContext::memberDeclarator(size_t i) { + return getRuleContext(i); +} + +std::vector CPP14Parser::MemberDeclaratorListContext::Comma() { + return getTokens(CPP14Parser::Comma); +} + +tree::TerminalNode* CPP14Parser::MemberDeclaratorListContext::Comma(size_t i) { + return getToken(CPP14Parser::Comma, i); +} + + +size_t CPP14Parser::MemberDeclaratorListContext::getRuleIndex() const { + return CPP14Parser::RuleMemberDeclaratorList; +} + + +CPP14Parser::MemberDeclaratorListContext* CPP14Parser::memberDeclaratorList() { + MemberDeclaratorListContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 294, CPP14Parser::RuleMemberDeclaratorList); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1745); + memberDeclarator(); + setState(1750); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == CPP14Parser::Comma) { + setState(1746); + match(CPP14Parser::Comma); + setState(1747); + memberDeclarator(); + setState(1752); + _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; +} + +//----------------- MemberDeclaratorContext ------------------------------------------------------------------ + +CPP14Parser::MemberDeclaratorContext::MemberDeclaratorContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::DeclaratorContext* CPP14Parser::MemberDeclaratorContext::declarator() { + return getRuleContext(0); +} + +CPP14Parser::VirtualSpecifierSeqContext* CPP14Parser::MemberDeclaratorContext::virtualSpecifierSeq() { + return getRuleContext(0); +} + +CPP14Parser::PureSpecifierContext* CPP14Parser::MemberDeclaratorContext::pureSpecifier() { + return getRuleContext(0); +} + +CPP14Parser::BraceOrEqualInitializerContext* CPP14Parser::MemberDeclaratorContext::braceOrEqualInitializer() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::MemberDeclaratorContext::Colon() { + return getToken(CPP14Parser::Colon, 0); +} + +CPP14Parser::ConstantExpressionContext* CPP14Parser::MemberDeclaratorContext::constantExpression() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::MemberDeclaratorContext::Identifier() { + return getToken(CPP14Parser::Identifier, 0); +} + +CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::MemberDeclaratorContext::attributeSpecifierSeq() { + return getRuleContext(0); +} + + +size_t CPP14Parser::MemberDeclaratorContext::getRuleIndex() const { + return CPP14Parser::RuleMemberDeclarator; +} + + +CPP14Parser::MemberDeclaratorContext* CPP14Parser::memberDeclarator() { + MemberDeclaratorContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 296, CPP14Parser::RuleMemberDeclarator); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(1773); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 252, _ctx)) { + case 1: { + enterOuterAlt(_localctx, 1); + setState(1753); + declarator(); + setState(1763); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 249, _ctx)) { + case 1: { + setState(1755); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Final + + || _la == CPP14Parser::Override) { + setState(1754); + virtualSpecifierSeq(); + } + setState(1758); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Assign) { + setState(1757); + pureSpecifier(); + } + break; + } + + case 2: { + setState(1761); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::LeftBrace + + || _la == CPP14Parser::Assign) { + setState(1760); + braceOrEqualInitializer(); + } + break; + } + + default: + break; + } + break; + } + + case 2: { + enterOuterAlt(_localctx, 2); + setState(1766); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Identifier) { + setState(1765); + match(CPP14Parser::Identifier); + } + setState(1769); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Alignas || _la == CPP14Parser::LeftBracket) { + setState(1768); + attributeSpecifierSeq(); + } + setState(1771); + match(CPP14Parser::Colon); + setState(1772); + constantExpression(); + break; + } + + default: + break; + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- VirtualSpecifierSeqContext ------------------------------------------------------------------ + +CPP14Parser::VirtualSpecifierSeqContext::VirtualSpecifierSeqContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector CPP14Parser::VirtualSpecifierSeqContext::virtualSpecifier() { + return getRuleContexts(); +} + +CPP14Parser::VirtualSpecifierContext* CPP14Parser::VirtualSpecifierSeqContext::virtualSpecifier(size_t i) { + return getRuleContext(i); +} + + +size_t CPP14Parser::VirtualSpecifierSeqContext::getRuleIndex() const { + return CPP14Parser::RuleVirtualSpecifierSeq; +} + + +CPP14Parser::VirtualSpecifierSeqContext* CPP14Parser::virtualSpecifierSeq() { + VirtualSpecifierSeqContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 298, CPP14Parser::RuleVirtualSpecifierSeq); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1776); + _errHandler->sync(this); + _la = _input->LA(1); + do { + setState(1775); + virtualSpecifier(); + setState(1778); + _errHandler->sync(this); + _la = _input->LA(1); + } while (_la == CPP14Parser::Final + + || _la == CPP14Parser::Override); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- VirtualSpecifierContext ------------------------------------------------------------------ + +CPP14Parser::VirtualSpecifierContext::VirtualSpecifierContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::VirtualSpecifierContext::Override() { + return getToken(CPP14Parser::Override, 0); +} + +tree::TerminalNode* CPP14Parser::VirtualSpecifierContext::Final() { + return getToken(CPP14Parser::Final, 0); +} + + +size_t CPP14Parser::VirtualSpecifierContext::getRuleIndex() const { + return CPP14Parser::RuleVirtualSpecifier; +} + + +CPP14Parser::VirtualSpecifierContext* CPP14Parser::virtualSpecifier() { + VirtualSpecifierContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 300, CPP14Parser::RuleVirtualSpecifier); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1780); + _la = _input->LA(1); + if (!(_la == CPP14Parser::Final + + || _la == CPP14Parser::Override)) { + _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; +} + +//----------------- PureSpecifierContext ------------------------------------------------------------------ + +CPP14Parser::PureSpecifierContext::PureSpecifierContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::PureSpecifierContext::Assign() { + return getToken(CPP14Parser::Assign, 0); +} + +tree::TerminalNode* CPP14Parser::PureSpecifierContext::OctalLiteral() { + return getToken(CPP14Parser::OctalLiteral, 0); +} + + +size_t CPP14Parser::PureSpecifierContext::getRuleIndex() const { + return CPP14Parser::RulePureSpecifier; +} + + +CPP14Parser::PureSpecifierContext* CPP14Parser::pureSpecifier() { + PureSpecifierContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 302, CPP14Parser::RulePureSpecifier); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1782); + match(CPP14Parser::Assign); + setState(1783); + antlrcpp::downCast(_localctx)->val = match(CPP14Parser::OctalLiteral); + if((antlrcpp::downCast(_localctx)->val != nullptr ? antlrcpp::downCast(_localctx)->val->getText() : "").compare("0")!=0) throw new InputMismatchException(this); + + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- BaseClauseContext ------------------------------------------------------------------ + +CPP14Parser::BaseClauseContext::BaseClauseContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::BaseClauseContext::Colon() { + return getToken(CPP14Parser::Colon, 0); +} + +CPP14Parser::BaseSpecifierListContext* CPP14Parser::BaseClauseContext::baseSpecifierList() { + return getRuleContext(0); +} + + +size_t CPP14Parser::BaseClauseContext::getRuleIndex() const { + return CPP14Parser::RuleBaseClause; +} + + +CPP14Parser::BaseClauseContext* CPP14Parser::baseClause() { + BaseClauseContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 304, CPP14Parser::RuleBaseClause); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1786); + match(CPP14Parser::Colon); + setState(1787); + baseSpecifierList(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- BaseSpecifierListContext ------------------------------------------------------------------ + +CPP14Parser::BaseSpecifierListContext::BaseSpecifierListContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector CPP14Parser::BaseSpecifierListContext::baseSpecifier() { + return getRuleContexts(); +} + +CPP14Parser::BaseSpecifierContext* CPP14Parser::BaseSpecifierListContext::baseSpecifier(size_t i) { + return getRuleContext(i); +} + +std::vector CPP14Parser::BaseSpecifierListContext::Ellipsis() { + return getTokens(CPP14Parser::Ellipsis); +} + +tree::TerminalNode* CPP14Parser::BaseSpecifierListContext::Ellipsis(size_t i) { + return getToken(CPP14Parser::Ellipsis, i); +} + +std::vector CPP14Parser::BaseSpecifierListContext::Comma() { + return getTokens(CPP14Parser::Comma); +} + +tree::TerminalNode* CPP14Parser::BaseSpecifierListContext::Comma(size_t i) { + return getToken(CPP14Parser::Comma, i); +} + + +size_t CPP14Parser::BaseSpecifierListContext::getRuleIndex() const { + return CPP14Parser::RuleBaseSpecifierList; +} + + +CPP14Parser::BaseSpecifierListContext* CPP14Parser::baseSpecifierList() { + BaseSpecifierListContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 306, CPP14Parser::RuleBaseSpecifierList); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1789); + baseSpecifier(); + setState(1791); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Ellipsis) { + setState(1790); + match(CPP14Parser::Ellipsis); + } + setState(1800); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == CPP14Parser::Comma) { + setState(1793); + match(CPP14Parser::Comma); + setState(1794); + baseSpecifier(); + setState(1796); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Ellipsis) { + setState(1795); + match(CPP14Parser::Ellipsis); + } + setState(1802); + _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; +} + +//----------------- BaseSpecifierContext ------------------------------------------------------------------ + +CPP14Parser::BaseSpecifierContext::BaseSpecifierContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::BaseTypeSpecifierContext* CPP14Parser::BaseSpecifierContext::baseTypeSpecifier() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::BaseSpecifierContext::Virtual() { + return getToken(CPP14Parser::Virtual, 0); +} + +CPP14Parser::AccessSpecifierContext* CPP14Parser::BaseSpecifierContext::accessSpecifier() { + return getRuleContext(0); +} + +CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::BaseSpecifierContext::attributeSpecifierSeq() { + return getRuleContext(0); +} + + +size_t CPP14Parser::BaseSpecifierContext::getRuleIndex() const { + return CPP14Parser::RuleBaseSpecifier; +} + + +CPP14Parser::BaseSpecifierContext* CPP14Parser::baseSpecifier() { + BaseSpecifierContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 308, CPP14Parser::RuleBaseSpecifier); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1804); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Alignas || _la == CPP14Parser::LeftBracket) { + setState(1803); + attributeSpecifierSeq(); + } + setState(1818); + _errHandler->sync(this); + switch (_input->LA(1)) { + case CPP14Parser::Decltype: + case CPP14Parser::Doublecolon: + case CPP14Parser::Identifier: { + setState(1806); + baseTypeSpecifier(); + break; + } + + case CPP14Parser::Virtual: { + setState(1807); + match(CPP14Parser::Virtual); + setState(1809); + _errHandler->sync(this); + + _la = _input->LA(1); + if ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 126100789566373888) != 0)) { + setState(1808); + accessSpecifier(); + } + setState(1811); + baseTypeSpecifier(); + break; + } + + case CPP14Parser::Private: + case CPP14Parser::Protected: + case CPP14Parser::Public: { + setState(1812); + accessSpecifier(); + setState(1814); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Virtual) { + setState(1813); + match(CPP14Parser::Virtual); + } + setState(1816); + baseTypeSpecifier(); + break; + } + + default: + throw NoViableAltException(this); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ClassOrDeclTypeContext ------------------------------------------------------------------ + +CPP14Parser::ClassOrDeclTypeContext::ClassOrDeclTypeContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::ClassNameContext* CPP14Parser::ClassOrDeclTypeContext::className() { + return getRuleContext(0); +} + +CPP14Parser::NestedNameSpecifierContext* CPP14Parser::ClassOrDeclTypeContext::nestedNameSpecifier() { + return getRuleContext(0); +} + +CPP14Parser::DecltypeSpecifierContext* CPP14Parser::ClassOrDeclTypeContext::decltypeSpecifier() { + return getRuleContext(0); +} + + +size_t CPP14Parser::ClassOrDeclTypeContext::getRuleIndex() const { + return CPP14Parser::RuleClassOrDeclType; +} + + +CPP14Parser::ClassOrDeclTypeContext* CPP14Parser::classOrDeclType() { + ClassOrDeclTypeContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 310, CPP14Parser::RuleClassOrDeclType); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(1825); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 262, _ctx)) { + case 1: { + enterOuterAlt(_localctx, 1); + setState(1821); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 261, _ctx)) { + case 1: { + setState(1820); + nestedNameSpecifier(0); + break; + } + + default: + break; + } + setState(1823); + className(); + break; + } + + case 2: { + enterOuterAlt(_localctx, 2); + setState(1824); + decltypeSpecifier(); + break; + } + + default: + break; + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- BaseTypeSpecifierContext ------------------------------------------------------------------ + +CPP14Parser::BaseTypeSpecifierContext::BaseTypeSpecifierContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::ClassOrDeclTypeContext* CPP14Parser::BaseTypeSpecifierContext::classOrDeclType() { + return getRuleContext(0); +} + + +size_t CPP14Parser::BaseTypeSpecifierContext::getRuleIndex() const { + return CPP14Parser::RuleBaseTypeSpecifier; +} + + +CPP14Parser::BaseTypeSpecifierContext* CPP14Parser::baseTypeSpecifier() { + BaseTypeSpecifierContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 312, CPP14Parser::RuleBaseTypeSpecifier); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1827); + classOrDeclType(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- AccessSpecifierContext ------------------------------------------------------------------ + +CPP14Parser::AccessSpecifierContext::AccessSpecifierContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::AccessSpecifierContext::Private() { + return getToken(CPP14Parser::Private, 0); +} + +tree::TerminalNode* CPP14Parser::AccessSpecifierContext::Protected() { + return getToken(CPP14Parser::Protected, 0); +} + +tree::TerminalNode* CPP14Parser::AccessSpecifierContext::Public() { + return getToken(CPP14Parser::Public, 0); +} + + +size_t CPP14Parser::AccessSpecifierContext::getRuleIndex() const { + return CPP14Parser::RuleAccessSpecifier; +} + + +CPP14Parser::AccessSpecifierContext* CPP14Parser::accessSpecifier() { + AccessSpecifierContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 314, CPP14Parser::RuleAccessSpecifier); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1829); + _la = _input->LA(1); + if (!((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 126100789566373888) != 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; +} + +//----------------- ConversionFunctionIdContext ------------------------------------------------------------------ + +CPP14Parser::ConversionFunctionIdContext::ConversionFunctionIdContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::ConversionFunctionIdContext::Operator() { + return getToken(CPP14Parser::Operator, 0); +} + +CPP14Parser::ConversionTypeIdContext* CPP14Parser::ConversionFunctionIdContext::conversionTypeId() { + return getRuleContext(0); +} + + +size_t CPP14Parser::ConversionFunctionIdContext::getRuleIndex() const { + return CPP14Parser::RuleConversionFunctionId; +} + + +CPP14Parser::ConversionFunctionIdContext* CPP14Parser::conversionFunctionId() { + ConversionFunctionIdContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 316, CPP14Parser::RuleConversionFunctionId); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1831); + match(CPP14Parser::Operator); + setState(1832); + conversionTypeId(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ConversionTypeIdContext ------------------------------------------------------------------ + +CPP14Parser::ConversionTypeIdContext::ConversionTypeIdContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::TypeSpecifierSeqContext* CPP14Parser::ConversionTypeIdContext::typeSpecifierSeq() { + return getRuleContext(0); +} + +CPP14Parser::ConversionDeclaratorContext* CPP14Parser::ConversionTypeIdContext::conversionDeclarator() { + return getRuleContext(0); +} + + +size_t CPP14Parser::ConversionTypeIdContext::getRuleIndex() const { + return CPP14Parser::RuleConversionTypeId; +} + + +CPP14Parser::ConversionTypeIdContext* CPP14Parser::conversionTypeId() { + ConversionTypeIdContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 318, CPP14Parser::RuleConversionTypeId); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1834); + typeSpecifierSeq(); + setState(1836); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 263, _ctx)) { + case 1: { + setState(1835); + conversionDeclarator(); + break; + } + + default: + break; + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ConversionDeclaratorContext ------------------------------------------------------------------ + +CPP14Parser::ConversionDeclaratorContext::ConversionDeclaratorContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::PointerOperatorContext* CPP14Parser::ConversionDeclaratorContext::pointerOperator() { + return getRuleContext(0); +} + +CPP14Parser::ConversionDeclaratorContext* CPP14Parser::ConversionDeclaratorContext::conversionDeclarator() { + return getRuleContext(0); +} + + +size_t CPP14Parser::ConversionDeclaratorContext::getRuleIndex() const { + return CPP14Parser::RuleConversionDeclarator; +} + + +CPP14Parser::ConversionDeclaratorContext* CPP14Parser::conversionDeclarator() { + ConversionDeclaratorContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 320, CPP14Parser::RuleConversionDeclarator); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1838); + pointerOperator(); + setState(1840); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 264, _ctx)) { + case 1: { + setState(1839); + conversionDeclarator(); + break; + } + + default: + break; + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ConstructorInitializerContext ------------------------------------------------------------------ + +CPP14Parser::ConstructorInitializerContext::ConstructorInitializerContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::ConstructorInitializerContext::Colon() { + return getToken(CPP14Parser::Colon, 0); +} + +CPP14Parser::MemInitializerListContext* CPP14Parser::ConstructorInitializerContext::memInitializerList() { + return getRuleContext(0); +} + + +size_t CPP14Parser::ConstructorInitializerContext::getRuleIndex() const { + return CPP14Parser::RuleConstructorInitializer; +} + + +CPP14Parser::ConstructorInitializerContext* CPP14Parser::constructorInitializer() { + ConstructorInitializerContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 322, CPP14Parser::RuleConstructorInitializer); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1842); + match(CPP14Parser::Colon); + setState(1843); + memInitializerList(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- MemInitializerListContext ------------------------------------------------------------------ + +CPP14Parser::MemInitializerListContext::MemInitializerListContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector CPP14Parser::MemInitializerListContext::memInitializer() { + return getRuleContexts(); +} + +CPP14Parser::MemInitializerContext* CPP14Parser::MemInitializerListContext::memInitializer(size_t i) { + return getRuleContext(i); +} + +std::vector CPP14Parser::MemInitializerListContext::Ellipsis() { + return getTokens(CPP14Parser::Ellipsis); +} + +tree::TerminalNode* CPP14Parser::MemInitializerListContext::Ellipsis(size_t i) { + return getToken(CPP14Parser::Ellipsis, i); +} + +std::vector CPP14Parser::MemInitializerListContext::Comma() { + return getTokens(CPP14Parser::Comma); +} + +tree::TerminalNode* CPP14Parser::MemInitializerListContext::Comma(size_t i) { + return getToken(CPP14Parser::Comma, i); +} + + +size_t CPP14Parser::MemInitializerListContext::getRuleIndex() const { + return CPP14Parser::RuleMemInitializerList; +} + + +CPP14Parser::MemInitializerListContext* CPP14Parser::memInitializerList() { + MemInitializerListContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 324, CPP14Parser::RuleMemInitializerList); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1845); + memInitializer(); + setState(1847); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Ellipsis) { + setState(1846); + match(CPP14Parser::Ellipsis); + } + setState(1856); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == CPP14Parser::Comma) { + setState(1849); + match(CPP14Parser::Comma); + setState(1850); + memInitializer(); + setState(1852); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Ellipsis) { + setState(1851); + match(CPP14Parser::Ellipsis); + } + setState(1858); + _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; +} + +//----------------- MemInitializerContext ------------------------------------------------------------------ + +CPP14Parser::MemInitializerContext::MemInitializerContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::MeminitializeridContext* CPP14Parser::MemInitializerContext::meminitializerid() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::MemInitializerContext::LeftParen() { + return getToken(CPP14Parser::LeftParen, 0); +} + +tree::TerminalNode* CPP14Parser::MemInitializerContext::RightParen() { + return getToken(CPP14Parser::RightParen, 0); +} + +CPP14Parser::BracedInitListContext* CPP14Parser::MemInitializerContext::bracedInitList() { + return getRuleContext(0); +} + +CPP14Parser::ExpressionListContext* CPP14Parser::MemInitializerContext::expressionList() { + return getRuleContext(0); +} + + +size_t CPP14Parser::MemInitializerContext::getRuleIndex() const { + return CPP14Parser::RuleMemInitializer; +} + + +CPP14Parser::MemInitializerContext* CPP14Parser::memInitializer() { + MemInitializerContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 326, CPP14Parser::RuleMemInitializer); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1859); + meminitializerid(); + setState(1866); + _errHandler->sync(this); + switch (_input->LA(1)) { + case CPP14Parser::LeftParen: { + setState(1860); + match(CPP14Parser::LeftParen); + setState(1862); + _errHandler->sync(this); + + _la = _input->LA(1); + if ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 8364979464334764286) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 65)) & 4719772474400910417) != 0) || _la == CPP14Parser::Identifier) { + setState(1861); + expressionList(); + } + setState(1864); + match(CPP14Parser::RightParen); + break; + } + + case CPP14Parser::LeftBrace: { + setState(1865); + bracedInitList(); + break; + } + + default: + throw NoViableAltException(this); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- MeminitializeridContext ------------------------------------------------------------------ + +CPP14Parser::MeminitializeridContext::MeminitializeridContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::ClassOrDeclTypeContext* CPP14Parser::MeminitializeridContext::classOrDeclType() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::MeminitializeridContext::Identifier() { + return getToken(CPP14Parser::Identifier, 0); +} + + +size_t CPP14Parser::MeminitializeridContext::getRuleIndex() const { + return CPP14Parser::RuleMeminitializerid; +} + + +CPP14Parser::MeminitializeridContext* CPP14Parser::meminitializerid() { + MeminitializeridContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 328, CPP14Parser::RuleMeminitializerid); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(1870); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 270, _ctx)) { + case 1: { + enterOuterAlt(_localctx, 1); + setState(1868); + classOrDeclType(); + break; + } + + case 2: { + enterOuterAlt(_localctx, 2); + setState(1869); + match(CPP14Parser::Identifier); + break; + } + + default: + break; + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- OperatorFunctionIdContext ------------------------------------------------------------------ + +CPP14Parser::OperatorFunctionIdContext::OperatorFunctionIdContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::OperatorFunctionIdContext::Operator() { + return getToken(CPP14Parser::Operator, 0); +} + +CPP14Parser::TheOperatorContext* CPP14Parser::OperatorFunctionIdContext::theOperator() { + return getRuleContext(0); +} + + +size_t CPP14Parser::OperatorFunctionIdContext::getRuleIndex() const { + return CPP14Parser::RuleOperatorFunctionId; +} + + +CPP14Parser::OperatorFunctionIdContext* CPP14Parser::operatorFunctionId() { + OperatorFunctionIdContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 330, CPP14Parser::RuleOperatorFunctionId); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1872); + match(CPP14Parser::Operator); + setState(1873); + theOperator(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- LiteralOperatorIdContext ------------------------------------------------------------------ + +CPP14Parser::LiteralOperatorIdContext::LiteralOperatorIdContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::LiteralOperatorIdContext::Operator() { + return getToken(CPP14Parser::Operator, 0); +} + +tree::TerminalNode* CPP14Parser::LiteralOperatorIdContext::StringLiteral() { + return getToken(CPP14Parser::StringLiteral, 0); +} + +tree::TerminalNode* CPP14Parser::LiteralOperatorIdContext::Identifier() { + return getToken(CPP14Parser::Identifier, 0); +} + +tree::TerminalNode* CPP14Parser::LiteralOperatorIdContext::UserDefinedStringLiteral() { + return getToken(CPP14Parser::UserDefinedStringLiteral, 0); +} + + +size_t CPP14Parser::LiteralOperatorIdContext::getRuleIndex() const { + return CPP14Parser::RuleLiteralOperatorId; +} + + +CPP14Parser::LiteralOperatorIdContext* CPP14Parser::literalOperatorId() { + LiteralOperatorIdContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 332, CPP14Parser::RuleLiteralOperatorId); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1875); + match(CPP14Parser::Operator); + setState(1879); + _errHandler->sync(this); + switch (_input->LA(1)) { + case CPP14Parser::StringLiteral: { + setState(1876); + match(CPP14Parser::StringLiteral); + setState(1877); + match(CPP14Parser::Identifier); + break; + } + + case CPP14Parser::UserDefinedStringLiteral: { + setState(1878); + match(CPP14Parser::UserDefinedStringLiteral); + break; + } + + default: + throw NoViableAltException(this); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- TemplateDeclarationContext ------------------------------------------------------------------ + +CPP14Parser::TemplateDeclarationContext::TemplateDeclarationContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::TemplateDeclarationContext::Template() { + return getToken(CPP14Parser::Template, 0); +} + +tree::TerminalNode* CPP14Parser::TemplateDeclarationContext::Less() { + return getToken(CPP14Parser::Less, 0); +} + +CPP14Parser::TemplateparameterListContext* CPP14Parser::TemplateDeclarationContext::templateparameterList() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::TemplateDeclarationContext::Greater() { + return getToken(CPP14Parser::Greater, 0); +} + +CPP14Parser::DeclarationContext* CPP14Parser::TemplateDeclarationContext::declaration() { + return getRuleContext(0); +} + + +size_t CPP14Parser::TemplateDeclarationContext::getRuleIndex() const { + return CPP14Parser::RuleTemplateDeclaration; +} + + +CPP14Parser::TemplateDeclarationContext* CPP14Parser::templateDeclaration() { + TemplateDeclarationContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 334, CPP14Parser::RuleTemplateDeclaration); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1881); + match(CPP14Parser::Template); + setState(1882); + match(CPP14Parser::Less); + setState(1883); + templateparameterList(); + setState(1884); + match(CPP14Parser::Greater); + setState(1885); + declaration(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- TemplateparameterListContext ------------------------------------------------------------------ + +CPP14Parser::TemplateparameterListContext::TemplateparameterListContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector CPP14Parser::TemplateparameterListContext::templateParameter() { + return getRuleContexts(); +} + +CPP14Parser::TemplateParameterContext* CPP14Parser::TemplateparameterListContext::templateParameter(size_t i) { + return getRuleContext(i); +} + +std::vector CPP14Parser::TemplateparameterListContext::Comma() { + return getTokens(CPP14Parser::Comma); +} + +tree::TerminalNode* CPP14Parser::TemplateparameterListContext::Comma(size_t i) { + return getToken(CPP14Parser::Comma, i); +} + + +size_t CPP14Parser::TemplateparameterListContext::getRuleIndex() const { + return CPP14Parser::RuleTemplateparameterList; +} + + +CPP14Parser::TemplateparameterListContext* CPP14Parser::templateparameterList() { + TemplateparameterListContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 336, CPP14Parser::RuleTemplateparameterList); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1887); + templateParameter(); + setState(1892); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == CPP14Parser::Comma) { + setState(1888); + match(CPP14Parser::Comma); + setState(1889); + templateParameter(); + setState(1894); + _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; +} + +//----------------- TemplateParameterContext ------------------------------------------------------------------ + +CPP14Parser::TemplateParameterContext::TemplateParameterContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::TypeParameterContext* CPP14Parser::TemplateParameterContext::typeParameter() { + return getRuleContext(0); +} + +CPP14Parser::ParameterDeclarationContext* CPP14Parser::TemplateParameterContext::parameterDeclaration() { + return getRuleContext(0); +} + + +size_t CPP14Parser::TemplateParameterContext::getRuleIndex() const { + return CPP14Parser::RuleTemplateParameter; +} + + +CPP14Parser::TemplateParameterContext* CPP14Parser::templateParameter() { + TemplateParameterContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 338, CPP14Parser::RuleTemplateParameter); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(1897); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 273, _ctx)) { + case 1: { + enterOuterAlt(_localctx, 1); + setState(1895); + typeParameter(); + break; + } + + case 2: { + enterOuterAlt(_localctx, 2); + setState(1896); + parameterDeclaration(); + break; + } + + default: + break; + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- TypeParameterContext ------------------------------------------------------------------ + +CPP14Parser::TypeParameterContext::TypeParameterContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::TypeParameterContext::Class() { + return getToken(CPP14Parser::Class, 0); +} + +tree::TerminalNode* CPP14Parser::TypeParameterContext::Typename_() { + return getToken(CPP14Parser::Typename_, 0); +} + +tree::TerminalNode* CPP14Parser::TypeParameterContext::Assign() { + return getToken(CPP14Parser::Assign, 0); +} + +CPP14Parser::TheTypeIdContext* CPP14Parser::TypeParameterContext::theTypeId() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::TypeParameterContext::Template() { + return getToken(CPP14Parser::Template, 0); +} + +tree::TerminalNode* CPP14Parser::TypeParameterContext::Less() { + return getToken(CPP14Parser::Less, 0); +} + +CPP14Parser::TemplateparameterListContext* CPP14Parser::TypeParameterContext::templateparameterList() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::TypeParameterContext::Greater() { + return getToken(CPP14Parser::Greater, 0); +} + +tree::TerminalNode* CPP14Parser::TypeParameterContext::Ellipsis() { + return getToken(CPP14Parser::Ellipsis, 0); +} + +tree::TerminalNode* CPP14Parser::TypeParameterContext::Identifier() { + return getToken(CPP14Parser::Identifier, 0); +} + + +size_t CPP14Parser::TypeParameterContext::getRuleIndex() const { + return CPP14Parser::RuleTypeParameter; +} + + +CPP14Parser::TypeParameterContext* CPP14Parser::typeParameter() { + TypeParameterContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 340, CPP14Parser::RuleTypeParameter); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1908); + _errHandler->sync(this); + switch (_input->LA(1)) { + case CPP14Parser::Class: + case CPP14Parser::Template: { + setState(1904); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Template) { + setState(1899); + match(CPP14Parser::Template); + setState(1900); + match(CPP14Parser::Less); + setState(1901); + templateparameterList(); + setState(1902); + match(CPP14Parser::Greater); + } + setState(1906); + match(CPP14Parser::Class); + break; + } + + case CPP14Parser::Typename_: { + setState(1907); + match(CPP14Parser::Typename_); + break; + } + + default: + throw NoViableAltException(this); + } + setState(1921); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 279, _ctx)) { + case 1: { + setState(1911); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Ellipsis) { + setState(1910); + match(CPP14Parser::Ellipsis); + } + setState(1914); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Identifier) { + setState(1913); + match(CPP14Parser::Identifier); + } + break; + } + + case 2: { + setState(1917); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Identifier) { + setState(1916); + match(CPP14Parser::Identifier); + } + setState(1919); + match(CPP14Parser::Assign); + setState(1920); + theTypeId(); + break; + } + + default: + break; + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- SimpleTemplateIdContext ------------------------------------------------------------------ + +CPP14Parser::SimpleTemplateIdContext::SimpleTemplateIdContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::TemplateNameContext* CPP14Parser::SimpleTemplateIdContext::templateName() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::SimpleTemplateIdContext::Less() { + return getToken(CPP14Parser::Less, 0); +} + +tree::TerminalNode* CPP14Parser::SimpleTemplateIdContext::Greater() { + return getToken(CPP14Parser::Greater, 0); +} + +CPP14Parser::TemplateArgumentListContext* CPP14Parser::SimpleTemplateIdContext::templateArgumentList() { + return getRuleContext(0); +} + + +size_t CPP14Parser::SimpleTemplateIdContext::getRuleIndex() const { + return CPP14Parser::RuleSimpleTemplateId; +} + + +CPP14Parser::SimpleTemplateIdContext* CPP14Parser::simpleTemplateId() { + SimpleTemplateIdContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 342, CPP14Parser::RuleSimpleTemplateId); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1923); + templateName(); + setState(1924); + match(CPP14Parser::Less); + setState(1926); + _errHandler->sync(this); + + _la = _input->LA(1); + if ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 8364979472930990334) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 65)) & 4719772474384268307) != 0) || _la == CPP14Parser::Identifier) { + setState(1925); + templateArgumentList(); + } + setState(1928); + match(CPP14Parser::Greater); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- TemplateIdContext ------------------------------------------------------------------ + +CPP14Parser::TemplateIdContext::TemplateIdContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::SimpleTemplateIdContext* CPP14Parser::TemplateIdContext::simpleTemplateId() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::TemplateIdContext::Less() { + return getToken(CPP14Parser::Less, 0); +} + +tree::TerminalNode* CPP14Parser::TemplateIdContext::Greater() { + return getToken(CPP14Parser::Greater, 0); +} + +CPP14Parser::OperatorFunctionIdContext* CPP14Parser::TemplateIdContext::operatorFunctionId() { + return getRuleContext(0); +} + +CPP14Parser::LiteralOperatorIdContext* CPP14Parser::TemplateIdContext::literalOperatorId() { + return getRuleContext(0); +} + +CPP14Parser::TemplateArgumentListContext* CPP14Parser::TemplateIdContext::templateArgumentList() { + return getRuleContext(0); +} + + +size_t CPP14Parser::TemplateIdContext::getRuleIndex() const { + return CPP14Parser::RuleTemplateId; +} + + +CPP14Parser::TemplateIdContext* CPP14Parser::templateId() { + TemplateIdContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 344, CPP14Parser::RuleTemplateId); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(1941); + _errHandler->sync(this); + switch (_input->LA(1)) { + case CPP14Parser::Identifier: { + enterOuterAlt(_localctx, 1); + setState(1930); + simpleTemplateId(); + break; + } + + case CPP14Parser::Operator: { + enterOuterAlt(_localctx, 2); + setState(1933); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 281, _ctx)) { + case 1: { + setState(1931); + operatorFunctionId(); + break; + } + + case 2: { + setState(1932); + literalOperatorId(); + break; + } + + default: + break; + } + setState(1935); + match(CPP14Parser::Less); + setState(1937); + _errHandler->sync(this); + + _la = _input->LA(1); + if ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 8364979472930990334) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 65)) & 4719772474384268307) != 0) || _la == CPP14Parser::Identifier) { + setState(1936); + templateArgumentList(); + } + setState(1939); + match(CPP14Parser::Greater); + break; + } + + default: + throw NoViableAltException(this); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- TemplateNameContext ------------------------------------------------------------------ + +CPP14Parser::TemplateNameContext::TemplateNameContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::TemplateNameContext::Identifier() { + return getToken(CPP14Parser::Identifier, 0); +} + + +size_t CPP14Parser::TemplateNameContext::getRuleIndex() const { + return CPP14Parser::RuleTemplateName; +} + + +CPP14Parser::TemplateNameContext* CPP14Parser::templateName() { + TemplateNameContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 346, CPP14Parser::RuleTemplateName); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1943); + match(CPP14Parser::Identifier); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- TemplateArgumentListContext ------------------------------------------------------------------ + +CPP14Parser::TemplateArgumentListContext::TemplateArgumentListContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector CPP14Parser::TemplateArgumentListContext::templateArgument() { + return getRuleContexts(); +} + +CPP14Parser::TemplateArgumentContext* CPP14Parser::TemplateArgumentListContext::templateArgument(size_t i) { + return getRuleContext(i); +} + +std::vector CPP14Parser::TemplateArgumentListContext::Ellipsis() { + return getTokens(CPP14Parser::Ellipsis); +} + +tree::TerminalNode* CPP14Parser::TemplateArgumentListContext::Ellipsis(size_t i) { + return getToken(CPP14Parser::Ellipsis, i); +} + +std::vector CPP14Parser::TemplateArgumentListContext::Comma() { + return getTokens(CPP14Parser::Comma); +} + +tree::TerminalNode* CPP14Parser::TemplateArgumentListContext::Comma(size_t i) { + return getToken(CPP14Parser::Comma, i); +} + + +size_t CPP14Parser::TemplateArgumentListContext::getRuleIndex() const { + return CPP14Parser::RuleTemplateArgumentList; +} + + +CPP14Parser::TemplateArgumentListContext* CPP14Parser::templateArgumentList() { + TemplateArgumentListContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 348, CPP14Parser::RuleTemplateArgumentList); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1945); + templateArgument(); + setState(1947); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Ellipsis) { + setState(1946); + match(CPP14Parser::Ellipsis); + } + setState(1956); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == CPP14Parser::Comma) { + setState(1949); + match(CPP14Parser::Comma); + setState(1950); + templateArgument(); + setState(1952); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Ellipsis) { + setState(1951); + match(CPP14Parser::Ellipsis); + } + setState(1958); + _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; +} + +//----------------- TemplateArgumentContext ------------------------------------------------------------------ + +CPP14Parser::TemplateArgumentContext::TemplateArgumentContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::TheTypeIdContext* CPP14Parser::TemplateArgumentContext::theTypeId() { + return getRuleContext(0); +} + +CPP14Parser::ConstantExpressionContext* CPP14Parser::TemplateArgumentContext::constantExpression() { + return getRuleContext(0); +} + +CPP14Parser::IdExpressionContext* CPP14Parser::TemplateArgumentContext::idExpression() { + return getRuleContext(0); +} + + +size_t CPP14Parser::TemplateArgumentContext::getRuleIndex() const { + return CPP14Parser::RuleTemplateArgument; +} + + +CPP14Parser::TemplateArgumentContext* CPP14Parser::templateArgument() { + TemplateArgumentContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 350, CPP14Parser::RuleTemplateArgument); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(1962); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 287, _ctx)) { + case 1: { + enterOuterAlt(_localctx, 1); + setState(1959); + theTypeId(); + break; + } + + case 2: { + enterOuterAlt(_localctx, 2); + setState(1960); + constantExpression(); + break; + } + + case 3: { + enterOuterAlt(_localctx, 3); + setState(1961); + idExpression(); + break; + } + + default: + break; + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- TypeNameSpecifierContext ------------------------------------------------------------------ + +CPP14Parser::TypeNameSpecifierContext::TypeNameSpecifierContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::TypeNameSpecifierContext::Typename_() { + return getToken(CPP14Parser::Typename_, 0); +} + +CPP14Parser::NestedNameSpecifierContext* CPP14Parser::TypeNameSpecifierContext::nestedNameSpecifier() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::TypeNameSpecifierContext::Identifier() { + return getToken(CPP14Parser::Identifier, 0); +} + +CPP14Parser::SimpleTemplateIdContext* CPP14Parser::TypeNameSpecifierContext::simpleTemplateId() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::TypeNameSpecifierContext::Template() { + return getToken(CPP14Parser::Template, 0); +} + + +size_t CPP14Parser::TypeNameSpecifierContext::getRuleIndex() const { + return CPP14Parser::RuleTypeNameSpecifier; +} + + +CPP14Parser::TypeNameSpecifierContext* CPP14Parser::typeNameSpecifier() { + TypeNameSpecifierContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 352, CPP14Parser::RuleTypeNameSpecifier); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1964); + match(CPP14Parser::Typename_); + setState(1965); + nestedNameSpecifier(0); + setState(1971); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 289, _ctx)) { + case 1: { + setState(1966); + match(CPP14Parser::Identifier); + break; + } + + case 2: { + setState(1968); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Template) { + setState(1967); + match(CPP14Parser::Template); + } + setState(1970); + simpleTemplateId(); + break; + } + + default: + break; + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ExplicitInstantiationContext ------------------------------------------------------------------ + +CPP14Parser::ExplicitInstantiationContext::ExplicitInstantiationContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::ExplicitInstantiationContext::Template() { + return getToken(CPP14Parser::Template, 0); +} + +CPP14Parser::DeclarationContext* CPP14Parser::ExplicitInstantiationContext::declaration() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::ExplicitInstantiationContext::Extern() { + return getToken(CPP14Parser::Extern, 0); +} + + +size_t CPP14Parser::ExplicitInstantiationContext::getRuleIndex() const { + return CPP14Parser::RuleExplicitInstantiation; +} + + +CPP14Parser::ExplicitInstantiationContext* CPP14Parser::explicitInstantiation() { + ExplicitInstantiationContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 354, CPP14Parser::RuleExplicitInstantiation); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1974); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Extern) { + setState(1973); + match(CPP14Parser::Extern); + } + setState(1976); + match(CPP14Parser::Template); + setState(1977); + declaration(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ExplicitSpecializationContext ------------------------------------------------------------------ + +CPP14Parser::ExplicitSpecializationContext::ExplicitSpecializationContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::ExplicitSpecializationContext::Template() { + return getToken(CPP14Parser::Template, 0); +} + +tree::TerminalNode* CPP14Parser::ExplicitSpecializationContext::Less() { + return getToken(CPP14Parser::Less, 0); +} + +tree::TerminalNode* CPP14Parser::ExplicitSpecializationContext::Greater() { + return getToken(CPP14Parser::Greater, 0); +} + +CPP14Parser::DeclarationContext* CPP14Parser::ExplicitSpecializationContext::declaration() { + return getRuleContext(0); +} + + +size_t CPP14Parser::ExplicitSpecializationContext::getRuleIndex() const { + return CPP14Parser::RuleExplicitSpecialization; +} + + +CPP14Parser::ExplicitSpecializationContext* CPP14Parser::explicitSpecialization() { + ExplicitSpecializationContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 356, CPP14Parser::RuleExplicitSpecialization); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1979); + match(CPP14Parser::Template); + setState(1980); + match(CPP14Parser::Less); + setState(1981); + match(CPP14Parser::Greater); + setState(1982); + declaration(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- TryBlockContext ------------------------------------------------------------------ + +CPP14Parser::TryBlockContext::TryBlockContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::TryBlockContext::Try() { + return getToken(CPP14Parser::Try, 0); +} + +CPP14Parser::CompoundStatementContext* CPP14Parser::TryBlockContext::compoundStatement() { + return getRuleContext(0); +} + +CPP14Parser::HandlerSeqContext* CPP14Parser::TryBlockContext::handlerSeq() { + return getRuleContext(0); +} + + +size_t CPP14Parser::TryBlockContext::getRuleIndex() const { + return CPP14Parser::RuleTryBlock; +} + + +CPP14Parser::TryBlockContext* CPP14Parser::tryBlock() { + TryBlockContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 358, CPP14Parser::RuleTryBlock); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1984); + match(CPP14Parser::Try); + setState(1985); + compoundStatement(); + setState(1986); + handlerSeq(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- FunctionTryBlockContext ------------------------------------------------------------------ + +CPP14Parser::FunctionTryBlockContext::FunctionTryBlockContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::FunctionTryBlockContext::Try() { + return getToken(CPP14Parser::Try, 0); +} + +CPP14Parser::CompoundStatementContext* CPP14Parser::FunctionTryBlockContext::compoundStatement() { + return getRuleContext(0); +} + +CPP14Parser::HandlerSeqContext* CPP14Parser::FunctionTryBlockContext::handlerSeq() { + return getRuleContext(0); +} + +CPP14Parser::ConstructorInitializerContext* CPP14Parser::FunctionTryBlockContext::constructorInitializer() { + return getRuleContext(0); +} + + +size_t CPP14Parser::FunctionTryBlockContext::getRuleIndex() const { + return CPP14Parser::RuleFunctionTryBlock; +} + + +CPP14Parser::FunctionTryBlockContext* CPP14Parser::functionTryBlock() { + FunctionTryBlockContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 360, CPP14Parser::RuleFunctionTryBlock); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1988); + match(CPP14Parser::Try); + setState(1990); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Colon) { + setState(1989); + constructorInitializer(); + } + setState(1992); + compoundStatement(); + setState(1993); + handlerSeq(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- HandlerSeqContext ------------------------------------------------------------------ + +CPP14Parser::HandlerSeqContext::HandlerSeqContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector CPP14Parser::HandlerSeqContext::handler() { + return getRuleContexts(); +} + +CPP14Parser::HandlerContext* CPP14Parser::HandlerSeqContext::handler(size_t i) { + return getRuleContext(i); +} + + +size_t CPP14Parser::HandlerSeqContext::getRuleIndex() const { + return CPP14Parser::RuleHandlerSeq; +} + + +CPP14Parser::HandlerSeqContext* CPP14Parser::handlerSeq() { + HandlerSeqContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 362, CPP14Parser::RuleHandlerSeq); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1996); + _errHandler->sync(this); + _la = _input->LA(1); + do { + setState(1995); + handler(); + setState(1998); + _errHandler->sync(this); + _la = _input->LA(1); + } while (_la == CPP14Parser::Catch); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- HandlerContext ------------------------------------------------------------------ + +CPP14Parser::HandlerContext::HandlerContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::HandlerContext::Catch() { + return getToken(CPP14Parser::Catch, 0); +} + +tree::TerminalNode* CPP14Parser::HandlerContext::LeftParen() { + return getToken(CPP14Parser::LeftParen, 0); +} + +CPP14Parser::ExceptionDeclarationContext* CPP14Parser::HandlerContext::exceptionDeclaration() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::HandlerContext::RightParen() { + return getToken(CPP14Parser::RightParen, 0); +} + +CPP14Parser::CompoundStatementContext* CPP14Parser::HandlerContext::compoundStatement() { + return getRuleContext(0); +} + + +size_t CPP14Parser::HandlerContext::getRuleIndex() const { + return CPP14Parser::RuleHandler; +} + + +CPP14Parser::HandlerContext* CPP14Parser::handler() { + HandlerContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 364, CPP14Parser::RuleHandler); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(2000); + match(CPP14Parser::Catch); + setState(2001); + match(CPP14Parser::LeftParen); + setState(2002); + exceptionDeclaration(); + setState(2003); + match(CPP14Parser::RightParen); + setState(2004); + compoundStatement(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ExceptionDeclarationContext ------------------------------------------------------------------ + +CPP14Parser::ExceptionDeclarationContext::ExceptionDeclarationContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::TypeSpecifierSeqContext* CPP14Parser::ExceptionDeclarationContext::typeSpecifierSeq() { + return getRuleContext(0); +} + +CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::ExceptionDeclarationContext::attributeSpecifierSeq() { + return getRuleContext(0); +} + +CPP14Parser::DeclaratorContext* CPP14Parser::ExceptionDeclarationContext::declarator() { + return getRuleContext(0); +} + +CPP14Parser::AbstractDeclaratorContext* CPP14Parser::ExceptionDeclarationContext::abstractDeclarator() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::ExceptionDeclarationContext::Ellipsis() { + return getToken(CPP14Parser::Ellipsis, 0); +} + + +size_t CPP14Parser::ExceptionDeclarationContext::getRuleIndex() const { + return CPP14Parser::RuleExceptionDeclaration; +} + + +CPP14Parser::ExceptionDeclarationContext* CPP14Parser::exceptionDeclaration() { + ExceptionDeclarationContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 366, CPP14Parser::RuleExceptionDeclaration); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(2015); + _errHandler->sync(this); + switch (_input->LA(1)) { + case CPP14Parser::Alignas: + case CPP14Parser::Auto: + case CPP14Parser::Bool: + case CPP14Parser::Char: + case CPP14Parser::Char16: + case CPP14Parser::Char32: + case CPP14Parser::Class: + case CPP14Parser::Const: + case CPP14Parser::Decltype: + case CPP14Parser::Double: + case CPP14Parser::Enum: + case CPP14Parser::Float: + case CPP14Parser::Int: + case CPP14Parser::Long: + case CPP14Parser::Short: + case CPP14Parser::Signed: + case CPP14Parser::Struct: + case CPP14Parser::Typename_: + case CPP14Parser::Union: + case CPP14Parser::Unsigned: + case CPP14Parser::Void: + case CPP14Parser::Volatile: + case CPP14Parser::Wchar: + case CPP14Parser::LeftBracket: + case CPP14Parser::Doublecolon: + case CPP14Parser::Identifier: { + enterOuterAlt(_localctx, 1); + setState(2007); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Alignas || _la == CPP14Parser::LeftBracket) { + setState(2006); + attributeSpecifierSeq(); + } + setState(2009); + typeSpecifierSeq(); + setState(2012); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 294, _ctx)) { + case 1: { + setState(2010); + declarator(); + break; + } + + case 2: { + setState(2011); + abstractDeclarator(); + break; + } + + default: + break; + } + break; + } + + case CPP14Parser::Ellipsis: { + enterOuterAlt(_localctx, 2); + setState(2014); + match(CPP14Parser::Ellipsis); + break; + } + + default: + throw NoViableAltException(this); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ThrowExpressionContext ------------------------------------------------------------------ + +CPP14Parser::ThrowExpressionContext::ThrowExpressionContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::ThrowExpressionContext::Throw() { + return getToken(CPP14Parser::Throw, 0); +} + +CPP14Parser::AssignmentExpressionContext* CPP14Parser::ThrowExpressionContext::assignmentExpression() { + return getRuleContext(0); +} + + +size_t CPP14Parser::ThrowExpressionContext::getRuleIndex() const { + return CPP14Parser::RuleThrowExpression; +} + + +CPP14Parser::ThrowExpressionContext* CPP14Parser::throwExpression() { + ThrowExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 368, CPP14Parser::RuleThrowExpression); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(2017); + match(CPP14Parser::Throw); + setState(2019); + _errHandler->sync(this); + + _la = _input->LA(1); + if ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 8364979464334764286) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 65)) & 4719772474384133201) != 0) || _la == CPP14Parser::Identifier) { + setState(2018); + assignmentExpression(); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ExceptionSpecificationContext ------------------------------------------------------------------ + +CPP14Parser::ExceptionSpecificationContext::ExceptionSpecificationContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CPP14Parser::DynamicExceptionSpecificationContext* CPP14Parser::ExceptionSpecificationContext::dynamicExceptionSpecification() { + return getRuleContext(0); +} + +CPP14Parser::NoeExceptSpecificationContext* CPP14Parser::ExceptionSpecificationContext::noeExceptSpecification() { + return getRuleContext(0); +} + + +size_t CPP14Parser::ExceptionSpecificationContext::getRuleIndex() const { + return CPP14Parser::RuleExceptionSpecification; +} + + +CPP14Parser::ExceptionSpecificationContext* CPP14Parser::exceptionSpecification() { + ExceptionSpecificationContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 370, CPP14Parser::RuleExceptionSpecification); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(2023); + _errHandler->sync(this); + switch (_input->LA(1)) { + case CPP14Parser::Throw: { + enterOuterAlt(_localctx, 1); + setState(2021); + dynamicExceptionSpecification(); + break; + } + + case CPP14Parser::Noexcept: { + enterOuterAlt(_localctx, 2); + setState(2022); + noeExceptSpecification(); + break; + } + + default: + throw NoViableAltException(this); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- DynamicExceptionSpecificationContext ------------------------------------------------------------------ + +CPP14Parser::DynamicExceptionSpecificationContext::DynamicExceptionSpecificationContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::DynamicExceptionSpecificationContext::Throw() { + return getToken(CPP14Parser::Throw, 0); +} + +tree::TerminalNode* CPP14Parser::DynamicExceptionSpecificationContext::LeftParen() { + return getToken(CPP14Parser::LeftParen, 0); +} + +tree::TerminalNode* CPP14Parser::DynamicExceptionSpecificationContext::RightParen() { + return getToken(CPP14Parser::RightParen, 0); +} + +CPP14Parser::TypeIdListContext* CPP14Parser::DynamicExceptionSpecificationContext::typeIdList() { + return getRuleContext(0); +} + + +size_t CPP14Parser::DynamicExceptionSpecificationContext::getRuleIndex() const { + return CPP14Parser::RuleDynamicExceptionSpecification; +} + + +CPP14Parser::DynamicExceptionSpecificationContext* CPP14Parser::dynamicExceptionSpecification() { + DynamicExceptionSpecificationContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 372, CPP14Parser::RuleDynamicExceptionSpecification); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(2025); + match(CPP14Parser::Throw); + setState(2026); + match(CPP14Parser::LeftParen); + setState(2028); + _errHandler->sync(this); + + _la = _input->LA(1); + if (((((_la - 13) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 13)) & -9213942612181769245) != 0) || ((((_la - 77) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 77)) & 37154696925806707) != 0)) { + setState(2027); + typeIdList(); + } + setState(2030); + match(CPP14Parser::RightParen); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- TypeIdListContext ------------------------------------------------------------------ + +CPP14Parser::TypeIdListContext::TypeIdListContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector CPP14Parser::TypeIdListContext::theTypeId() { + return getRuleContexts(); +} + +CPP14Parser::TheTypeIdContext* CPP14Parser::TypeIdListContext::theTypeId(size_t i) { + return getRuleContext(i); +} + +std::vector CPP14Parser::TypeIdListContext::Ellipsis() { + return getTokens(CPP14Parser::Ellipsis); +} + +tree::TerminalNode* CPP14Parser::TypeIdListContext::Ellipsis(size_t i) { + return getToken(CPP14Parser::Ellipsis, i); +} + +std::vector CPP14Parser::TypeIdListContext::Comma() { + return getTokens(CPP14Parser::Comma); +} + +tree::TerminalNode* CPP14Parser::TypeIdListContext::Comma(size_t i) { + return getToken(CPP14Parser::Comma, i); +} + + +size_t CPP14Parser::TypeIdListContext::getRuleIndex() const { + return CPP14Parser::RuleTypeIdList; +} + + +CPP14Parser::TypeIdListContext* CPP14Parser::typeIdList() { + TypeIdListContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 374, CPP14Parser::RuleTypeIdList); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(2032); + theTypeId(); + setState(2034); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Ellipsis) { + setState(2033); + match(CPP14Parser::Ellipsis); + } + setState(2043); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == CPP14Parser::Comma) { + setState(2036); + match(CPP14Parser::Comma); + setState(2037); + theTypeId(); + setState(2039); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CPP14Parser::Ellipsis) { + setState(2038); + match(CPP14Parser::Ellipsis); + } + setState(2045); + _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; +} + +//----------------- NoeExceptSpecificationContext ------------------------------------------------------------------ + +CPP14Parser::NoeExceptSpecificationContext::NoeExceptSpecificationContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::NoeExceptSpecificationContext::Noexcept() { + return getToken(CPP14Parser::Noexcept, 0); +} + +tree::TerminalNode* CPP14Parser::NoeExceptSpecificationContext::LeftParen() { + return getToken(CPP14Parser::LeftParen, 0); +} + +CPP14Parser::ConstantExpressionContext* CPP14Parser::NoeExceptSpecificationContext::constantExpression() { + return getRuleContext(0); +} + +tree::TerminalNode* CPP14Parser::NoeExceptSpecificationContext::RightParen() { + return getToken(CPP14Parser::RightParen, 0); +} + + +size_t CPP14Parser::NoeExceptSpecificationContext::getRuleIndex() const { + return CPP14Parser::RuleNoeExceptSpecification; +} + + +CPP14Parser::NoeExceptSpecificationContext* CPP14Parser::noeExceptSpecification() { + NoeExceptSpecificationContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 376, CPP14Parser::RuleNoeExceptSpecification); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(2052); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 302, _ctx)) { + case 1: { + enterOuterAlt(_localctx, 1); + setState(2046); + match(CPP14Parser::Noexcept); + setState(2047); + match(CPP14Parser::LeftParen); + setState(2048); + constantExpression(); + setState(2049); + match(CPP14Parser::RightParen); + break; + } + + case 2: { + enterOuterAlt(_localctx, 2); + setState(2051); + match(CPP14Parser::Noexcept); + break; + } + + default: + break; + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- TheOperatorContext ------------------------------------------------------------------ + +CPP14Parser::TheOperatorContext::TheOperatorContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::TheOperatorContext::New() { + return getToken(CPP14Parser::New, 0); +} + +tree::TerminalNode* CPP14Parser::TheOperatorContext::LeftBracket() { + return getToken(CPP14Parser::LeftBracket, 0); +} + +tree::TerminalNode* CPP14Parser::TheOperatorContext::RightBracket() { + return getToken(CPP14Parser::RightBracket, 0); +} + +tree::TerminalNode* CPP14Parser::TheOperatorContext::Delete() { + return getToken(CPP14Parser::Delete, 0); +} + +tree::TerminalNode* CPP14Parser::TheOperatorContext::Plus() { + return getToken(CPP14Parser::Plus, 0); +} + +tree::TerminalNode* CPP14Parser::TheOperatorContext::Minus() { + return getToken(CPP14Parser::Minus, 0); +} + +tree::TerminalNode* CPP14Parser::TheOperatorContext::Star() { + return getToken(CPP14Parser::Star, 0); +} + +tree::TerminalNode* CPP14Parser::TheOperatorContext::Div() { + return getToken(CPP14Parser::Div, 0); +} + +tree::TerminalNode* CPP14Parser::TheOperatorContext::Mod() { + return getToken(CPP14Parser::Mod, 0); +} + +tree::TerminalNode* CPP14Parser::TheOperatorContext::Caret() { + return getToken(CPP14Parser::Caret, 0); +} + +tree::TerminalNode* CPP14Parser::TheOperatorContext::And() { + return getToken(CPP14Parser::And, 0); +} + +tree::TerminalNode* CPP14Parser::TheOperatorContext::Or() { + return getToken(CPP14Parser::Or, 0); +} + +tree::TerminalNode* CPP14Parser::TheOperatorContext::Tilde() { + return getToken(CPP14Parser::Tilde, 0); +} + +tree::TerminalNode* CPP14Parser::TheOperatorContext::Not() { + return getToken(CPP14Parser::Not, 0); +} + +tree::TerminalNode* CPP14Parser::TheOperatorContext::Assign() { + return getToken(CPP14Parser::Assign, 0); +} + +std::vector CPP14Parser::TheOperatorContext::Greater() { + return getTokens(CPP14Parser::Greater); +} + +tree::TerminalNode* CPP14Parser::TheOperatorContext::Greater(size_t i) { + return getToken(CPP14Parser::Greater, i); +} + +std::vector CPP14Parser::TheOperatorContext::Less() { + return getTokens(CPP14Parser::Less); +} + +tree::TerminalNode* CPP14Parser::TheOperatorContext::Less(size_t i) { + return getToken(CPP14Parser::Less, i); +} + +tree::TerminalNode* CPP14Parser::TheOperatorContext::GreaterEqual() { + return getToken(CPP14Parser::GreaterEqual, 0); +} + +tree::TerminalNode* CPP14Parser::TheOperatorContext::PlusAssign() { + return getToken(CPP14Parser::PlusAssign, 0); +} + +tree::TerminalNode* CPP14Parser::TheOperatorContext::MinusAssign() { + return getToken(CPP14Parser::MinusAssign, 0); +} + +tree::TerminalNode* CPP14Parser::TheOperatorContext::StarAssign() { + return getToken(CPP14Parser::StarAssign, 0); +} + +tree::TerminalNode* CPP14Parser::TheOperatorContext::ModAssign() { + return getToken(CPP14Parser::ModAssign, 0); +} + +tree::TerminalNode* CPP14Parser::TheOperatorContext::XorAssign() { + return getToken(CPP14Parser::XorAssign, 0); +} + +tree::TerminalNode* CPP14Parser::TheOperatorContext::AndAssign() { + return getToken(CPP14Parser::AndAssign, 0); +} + +tree::TerminalNode* CPP14Parser::TheOperatorContext::OrAssign() { + return getToken(CPP14Parser::OrAssign, 0); +} + +tree::TerminalNode* CPP14Parser::TheOperatorContext::RightShiftAssign() { + return getToken(CPP14Parser::RightShiftAssign, 0); +} + +tree::TerminalNode* CPP14Parser::TheOperatorContext::LeftShiftAssign() { + return getToken(CPP14Parser::LeftShiftAssign, 0); +} + +tree::TerminalNode* CPP14Parser::TheOperatorContext::Equal() { + return getToken(CPP14Parser::Equal, 0); +} + +tree::TerminalNode* CPP14Parser::TheOperatorContext::NotEqual() { + return getToken(CPP14Parser::NotEqual, 0); +} + +tree::TerminalNode* CPP14Parser::TheOperatorContext::LessEqual() { + return getToken(CPP14Parser::LessEqual, 0); +} + +tree::TerminalNode* CPP14Parser::TheOperatorContext::AndAnd() { + return getToken(CPP14Parser::AndAnd, 0); +} + +tree::TerminalNode* CPP14Parser::TheOperatorContext::OrOr() { + return getToken(CPP14Parser::OrOr, 0); +} + +tree::TerminalNode* CPP14Parser::TheOperatorContext::PlusPlus() { + return getToken(CPP14Parser::PlusPlus, 0); +} + +tree::TerminalNode* CPP14Parser::TheOperatorContext::MinusMinus() { + return getToken(CPP14Parser::MinusMinus, 0); +} + +tree::TerminalNode* CPP14Parser::TheOperatorContext::Comma() { + return getToken(CPP14Parser::Comma, 0); +} + +tree::TerminalNode* CPP14Parser::TheOperatorContext::ArrowStar() { + return getToken(CPP14Parser::ArrowStar, 0); +} + +tree::TerminalNode* CPP14Parser::TheOperatorContext::Arrow() { + return getToken(CPP14Parser::Arrow, 0); +} + +tree::TerminalNode* CPP14Parser::TheOperatorContext::LeftParen() { + return getToken(CPP14Parser::LeftParen, 0); +} + +tree::TerminalNode* CPP14Parser::TheOperatorContext::RightParen() { + return getToken(CPP14Parser::RightParen, 0); +} + + +size_t CPP14Parser::TheOperatorContext::getRuleIndex() const { + return CPP14Parser::RuleTheOperator; +} + + +CPP14Parser::TheOperatorContext* CPP14Parser::theOperator() { + TheOperatorContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 378, CPP14Parser::RuleTheOperator); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(2105); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 305, _ctx)) { + case 1: { + enterOuterAlt(_localctx, 1); + setState(2054); + match(CPP14Parser::New); + setState(2057); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 303, _ctx)) { + case 1: { + setState(2055); + match(CPP14Parser::LeftBracket); + setState(2056); + match(CPP14Parser::RightBracket); + break; + } + + default: + break; + } + break; + } + + case 2: { + enterOuterAlt(_localctx, 2); + setState(2059); + match(CPP14Parser::Delete); + setState(2062); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 304, _ctx)) { + case 1: { + setState(2060); + match(CPP14Parser::LeftBracket); + setState(2061); + match(CPP14Parser::RightBracket); + break; + } + + default: + break; + } + break; + } + + case 3: { + enterOuterAlt(_localctx, 3); + setState(2064); + match(CPP14Parser::Plus); + break; + } + + case 4: { + enterOuterAlt(_localctx, 4); + setState(2065); + match(CPP14Parser::Minus); + break; + } + + case 5: { + enterOuterAlt(_localctx, 5); + setState(2066); + match(CPP14Parser::Star); + break; + } + + case 6: { + enterOuterAlt(_localctx, 6); + setState(2067); + match(CPP14Parser::Div); + break; + } + + case 7: { + enterOuterAlt(_localctx, 7); + setState(2068); + match(CPP14Parser::Mod); + break; + } + + case 8: { + enterOuterAlt(_localctx, 8); + setState(2069); + match(CPP14Parser::Caret); + break; + } + + case 9: { + enterOuterAlt(_localctx, 9); + setState(2070); + match(CPP14Parser::And); + break; + } + + case 10: { + enterOuterAlt(_localctx, 10); + setState(2071); + match(CPP14Parser::Or); + break; + } + + case 11: { + enterOuterAlt(_localctx, 11); + setState(2072); + match(CPP14Parser::Tilde); + break; + } + + case 12: { + enterOuterAlt(_localctx, 12); + setState(2073); + match(CPP14Parser::Not); + break; + } + + case 13: { + enterOuterAlt(_localctx, 13); + setState(2074); + match(CPP14Parser::Assign); + break; + } + + case 14: { + enterOuterAlt(_localctx, 14); + setState(2075); + match(CPP14Parser::Greater); + break; + } + + case 15: { + enterOuterAlt(_localctx, 15); + setState(2076); + match(CPP14Parser::Less); + break; + } + + case 16: { + enterOuterAlt(_localctx, 16); + setState(2077); + match(CPP14Parser::GreaterEqual); + break; + } + + case 17: { + enterOuterAlt(_localctx, 17); + setState(2078); + match(CPP14Parser::PlusAssign); + break; + } + + case 18: { + enterOuterAlt(_localctx, 18); + setState(2079); + match(CPP14Parser::MinusAssign); + break; + } + + case 19: { + enterOuterAlt(_localctx, 19); + setState(2080); + match(CPP14Parser::StarAssign); + break; + } + + case 20: { + enterOuterAlt(_localctx, 20); + setState(2081); + match(CPP14Parser::ModAssign); + break; + } + + case 21: { + enterOuterAlt(_localctx, 21); + setState(2082); + match(CPP14Parser::XorAssign); + break; + } + + case 22: { + enterOuterAlt(_localctx, 22); + setState(2083); + match(CPP14Parser::AndAssign); + break; + } + + case 23: { + enterOuterAlt(_localctx, 23); + setState(2084); + match(CPP14Parser::OrAssign); + break; + } + + case 24: { + enterOuterAlt(_localctx, 24); + setState(2085); + match(CPP14Parser::Less); + setState(2086); + match(CPP14Parser::Less); + break; + } + + case 25: { + enterOuterAlt(_localctx, 25); + setState(2087); + match(CPP14Parser::Greater); + setState(2088); + match(CPP14Parser::Greater); + break; + } + + case 26: { + enterOuterAlt(_localctx, 26); + setState(2089); + match(CPP14Parser::RightShiftAssign); + break; + } + + case 27: { + enterOuterAlt(_localctx, 27); + setState(2090); + match(CPP14Parser::LeftShiftAssign); + break; + } + + case 28: { + enterOuterAlt(_localctx, 28); + setState(2091); + match(CPP14Parser::Equal); + break; + } + + case 29: { + enterOuterAlt(_localctx, 29); + setState(2092); + match(CPP14Parser::NotEqual); + break; + } + + case 30: { + enterOuterAlt(_localctx, 30); + setState(2093); + match(CPP14Parser::LessEqual); + break; + } + + case 31: { + enterOuterAlt(_localctx, 31); + setState(2094); + match(CPP14Parser::AndAnd); + break; + } + + case 32: { + enterOuterAlt(_localctx, 32); + setState(2095); + match(CPP14Parser::OrOr); + break; + } + + case 33: { + enterOuterAlt(_localctx, 33); + setState(2096); + match(CPP14Parser::PlusPlus); + break; + } + + case 34: { + enterOuterAlt(_localctx, 34); + setState(2097); + match(CPP14Parser::MinusMinus); + break; + } + + case 35: { + enterOuterAlt(_localctx, 35); + setState(2098); + match(CPP14Parser::Comma); + break; + } + + case 36: { + enterOuterAlt(_localctx, 36); + setState(2099); + match(CPP14Parser::ArrowStar); + break; + } + + case 37: { + enterOuterAlt(_localctx, 37); + setState(2100); + match(CPP14Parser::Arrow); + break; + } + + case 38: { + enterOuterAlt(_localctx, 38); + setState(2101); + match(CPP14Parser::LeftParen); + setState(2102); + match(CPP14Parser::RightParen); + break; + } + + case 39: { + enterOuterAlt(_localctx, 39); + setState(2103); + match(CPP14Parser::LeftBracket); + setState(2104); + match(CPP14Parser::RightBracket); + break; + } + + default: + break; + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- LiteralContext ------------------------------------------------------------------ + +CPP14Parser::LiteralContext::LiteralContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CPP14Parser::LiteralContext::IntegerLiteral() { + return getToken(CPP14Parser::IntegerLiteral, 0); +} + +tree::TerminalNode* CPP14Parser::LiteralContext::CharacterLiteral() { + return getToken(CPP14Parser::CharacterLiteral, 0); +} + +tree::TerminalNode* CPP14Parser::LiteralContext::FloatingLiteral() { + return getToken(CPP14Parser::FloatingLiteral, 0); +} + +tree::TerminalNode* CPP14Parser::LiteralContext::StringLiteral() { + return getToken(CPP14Parser::StringLiteral, 0); +} + +tree::TerminalNode* CPP14Parser::LiteralContext::BooleanLiteral() { + return getToken(CPP14Parser::BooleanLiteral, 0); +} + +tree::TerminalNode* CPP14Parser::LiteralContext::PointerLiteral() { + return getToken(CPP14Parser::PointerLiteral, 0); +} + +tree::TerminalNode* CPP14Parser::LiteralContext::UserDefinedLiteral() { + return getToken(CPP14Parser::UserDefinedLiteral, 0); +} + + +size_t CPP14Parser::LiteralContext::getRuleIndex() const { + return CPP14Parser::RuleLiteral; +} + + +CPP14Parser::LiteralContext* CPP14Parser::literal() { + LiteralContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 380, CPP14Parser::RuleLiteral); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(2107); + _la = _input->LA(1); + if (!((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 254) != 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; +} + +bool CPP14Parser::sempred(RuleContext *context, size_t ruleIndex, size_t predicateIndex) { + switch (ruleIndex) { + case 5: return nestedNameSpecifierSempred(antlrcpp::downCast(context), predicateIndex); + case 15: return postfixExpressionSempred(antlrcpp::downCast(context), predicateIndex); + case 25: return noPointerNewDeclaratorSempred(antlrcpp::downCast(context), predicateIndex); + case 115: return noPointerDeclaratorSempred(antlrcpp::downCast(context), predicateIndex); + case 126: return noPointerAbstractDeclaratorSempred(antlrcpp::downCast(context), predicateIndex); + case 128: return noPointerAbstractPackDeclaratorSempred(antlrcpp::downCast(context), predicateIndex); + + default: + break; + } + return true; +} + +bool CPP14Parser::nestedNameSpecifierSempred(NestedNameSpecifierContext *_localctx, size_t predicateIndex) { + switch (predicateIndex) { + case 0: return precpred(_ctx, 1); + + default: + break; + } + return true; +} + +bool CPP14Parser::postfixExpressionSempred(PostfixExpressionContext *_localctx, size_t predicateIndex) { + switch (predicateIndex) { + case 1: return precpred(_ctx, 7); + case 2: return precpred(_ctx, 6); + case 3: return precpred(_ctx, 4); + case 4: return precpred(_ctx, 3); + + default: + break; + } + return true; +} + +bool CPP14Parser::noPointerNewDeclaratorSempred(NoPointerNewDeclaratorContext *_localctx, size_t predicateIndex) { + switch (predicateIndex) { + case 5: return precpred(_ctx, 1); + + default: + break; + } + return true; +} + +bool CPP14Parser::noPointerDeclaratorSempred(NoPointerDeclaratorContext *_localctx, size_t predicateIndex) { + switch (predicateIndex) { + case 6: return precpred(_ctx, 2); + + default: + break; + } + return true; +} + +bool CPP14Parser::noPointerAbstractDeclaratorSempred(NoPointerAbstractDeclaratorContext *_localctx, size_t predicateIndex) { + switch (predicateIndex) { + case 7: return precpred(_ctx, 4); + + default: + break; + } + return true; +} + +bool CPP14Parser::noPointerAbstractPackDeclaratorSempred(NoPointerAbstractPackDeclaratorContext *_localctx, size_t predicateIndex) { + switch (predicateIndex) { + case 8: return precpred(_ctx, 2); + + default: + break; + } + return true; +} + +void CPP14Parser::initialize() { + ::antlr4::internal::call_once(cpp14parserParserOnceFlag, cpp14parserParserInitialize); +} diff --git a/server/pkg/antlr/cpp14/src/MyCppAntlr.cpp b/server/pkg/antlr/cpp14/src/MyCppAntlr.cpp new file mode 100644 index 0000000000000000000000000000000000000000..bf777e3255adc3fb04138676affb9fd5873e309a --- /dev/null +++ b/server/pkg/antlr/cpp14/src/MyCppAntlr.cpp @@ -0,0 +1,41 @@ +#include "MyCppAntlr.h" + +#include + +MyCppAntlr::MyCppAntlr(std::unique_ptr input, + std::unique_ptr tokenStream, + std::unique_ptr lexer, + std::unique_ptr parser) + : input_ptr(std::move(input)), + tokenStream_ptr(std::move(tokenStream)), + lexer_ptr(std::move(lexer)), + parser_ptr(std::move(parser)) {} + +std::unique_ptr MyCppAntlr::init(std::ifstream& in) { + auto input = std::make_unique(in); + auto lex = std::make_unique(&(*input)); + auto tok = std::make_unique(&(*lex)); + auto parser = std::make_unique(&(*tok)); + auto a = std::make_unique( + MyCppAntlr(std::move(input),std::move(tok), std::move(lex), + std::move(parser))); + return std::move(a); +} + +std::vector MyCppAntlr::getTokens() { + tokenStream_ptr->fill(); + std::vector ans(tokenStream_ptr->size()); + + int i = 0; + for (antlr4::Token* token : tokenStream_ptr->getTokens()) { + ans[i] = token->toString(); + i++; + } + + return ans; +} + +std::string MyCppAntlr::getTreeString() { + auto tree = parser_ptr->translationUnit(); + return tree->toStringTree(&(*parser_ptr)); +} \ No newline at end of file diff --git a/server/pkg/antlr/python3/Python3.g4 b/server/pkg/antlr/python3/Python3.g4 new file mode 100644 index 0000000000000000000000000000000000000000..3f801e18042385ecd324faa3c156db9757796e73 --- /dev/null +++ b/server/pkg/antlr/python3/Python3.g4 @@ -0,0 +1,1182 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2014 by Bart Kiers + * + * 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. + * + * Project : python3-parser; an ANTLR4 grammar for Python 3 + * https://github.com/bkiers/python3-parser + * Developed by : Bart Kiers, bart@big-o.nl + */ +grammar Python3; + +// All comments that start with "///" are copy-pasted from +// The Python Language Reference + +tokens { INDENT, DEDENT } + +@lexer::header { + #include "Python3Parser.h" +} + + +@lexer::members { + private: + // A queue where extra tokens are pushed on (see the NEWLINE lexer rule). + std::vector> m_tokens; + // The stack that keeps track of the indentation level. + std::stack m_indents; + // The amount of opened braces, brackets and parenthesis. + int m_opened = 0; + // The most recently produced token. + std::unique_ptr m_pLastToken = nullptr; + + public: + virtual void emit(std::unique_ptr newToken) override { + m_tokens.push_back(cloneToken(newToken)); + setToken(std::move(newToken)); + } + + std::unique_ptr nextToken() override { + // Check if the end-of-file is ahead and there are still some DEDENTS expected. + if (_input->LA(1) == EOF && !m_indents.empty()) { + // Remove any trailing EOF tokens from our buffer. + for (int i = m_tokens.size() - 1; i >= 0; i--) { + if (m_tokens[i]->getType() == EOF) { + m_tokens.erase(m_tokens.begin() + i); + } + } + + // First emit an extra line break that serves as the end of the statement. + emit(commonToken(Python3Parser::NEWLINE, "\n")); + + // Now emit as much DEDENT tokens as needed. + while (!m_indents.empty()) { + emit(createDedent()); + m_indents.pop(); + } + + // Put the EOF back on the token stream. + emit(commonToken(EOF, "")); + } + + std::unique_ptr next = Lexer::nextToken(); + + if (next->getChannel() == antlr4::Token::DEFAULT_CHANNEL) { + // Keep track of the last token on the default channel. + m_pLastToken = cloneToken(next); + } + + if (!m_tokens.empty()) + { + next = std::move(*m_tokens.begin()); + m_tokens.erase(m_tokens.begin()); + } + + return next; + } + + private: + std::unique_ptr createDedent() { + std::unique_ptr dedent = commonToken(Python3Parser::DEDENT, ""); + return dedent; + } + + std::unique_ptr commonToken(size_t type, const std::string& text) { + int stop = getCharIndex() - 1; + int start = text.empty() ? stop : stop - text.size() + 1; + return _factory->create({ this, _input }, type, text, DEFAULT_TOKEN_CHANNEL, start, stop, m_pLastToken ? m_pLastToken->getLine() : 0, m_pLastToken ? m_pLastToken->getCharPositionInLine() : 0); + } + + std::unique_ptr cloneToken(const std::unique_ptr& source) { + return _factory->create({ this, _input }, source->getType(), source->getText(), source->getChannel(), source->getStartIndex(), source->getStopIndex(), source->getLine(), source->getCharPositionInLine()); + } + + + // Calculates the indentation of the provided spaces, taking the + // following rules into account: + // + // "Tabs are replaced (from left to right) by one to eight spaces + // such that the total number of characters up to and including + // the replacement is a multiple of eight [...]" + // + // -- https://docs.python.org/3.1/reference/lexical_analysis.html#indentation + static int getIndentationCount(const std::string& spaces) { + int count = 0; + for (char ch : spaces) { + switch (ch) { + case '\t': + count += 8 - (count % 8); + break; + default: + // A normal space char. + count++; + } + } + + return count; + } + + bool atStartOfInput() { + return getCharPositionInLine() == 0 && getLine() == 1; + } +} + +/* + * parser rules + */ + +single_input: NEWLINE | simple_stmt | compound_stmt NEWLINE; +file_input: (NEWLINE | stmt)* EOF; +eval_input: testlist NEWLINE* EOF; + +decorator: '@' dotted_name ( '(' (arglist)? ')' )? NEWLINE; +decorators: decorator+; +decorated: decorators (classdef | funcdef | async_funcdef); + +async_funcdef: ASYNC funcdef; +funcdef: 'def' NAME parameters ('->' test)? ':' suite; + +parameters: '(' (typedargslist)? ')'; +typedargslist: (tfpdef ('=' test)? (',' tfpdef ('=' test)?)* (',' ( + '*' (tfpdef)? (',' tfpdef ('=' test)?)* (',' ('**' tfpdef (',')?)?)? + | '**' tfpdef (',')?)?)? + | '*' (tfpdef)? (',' tfpdef ('=' test)?)* (',' ('**' tfpdef (',')?)?)? + | '**' tfpdef (',')?); +tfpdef: NAME (':' test)?; +varargslist: (vfpdef ('=' test)? (',' vfpdef ('=' test)?)* (',' ( + '*' (vfpdef)? (',' vfpdef ('=' test)?)* (',' ('**' vfpdef (',')?)?)? + | '**' vfpdef (',')?)?)? + | '*' (vfpdef)? (',' vfpdef ('=' test)?)* (',' ('**' vfpdef (',')?)?)? + | '**' vfpdef (',')? +); +vfpdef: NAME; + +stmt: simple_stmt | compound_stmt; +simple_stmt: small_stmt (';' small_stmt)* (';')? NEWLINE; +small_stmt: (expr_stmt | del_stmt | pass_stmt | flow_stmt | + import_stmt | global_stmt | nonlocal_stmt | assert_stmt); +expr_stmt: testlist_star_expr (annassign | augassign (yield_expr|testlist) | + ('=' (yield_expr|testlist_star_expr))*); +annassign: ':' test ('=' test)?; +testlist_star_expr: (test|star_expr) (',' (test|star_expr))* (',')?; +augassign: ('+=' | '-=' | '*=' | '@=' | '/=' | '%=' | '&=' | '|=' | '^=' | + '<<=' | '>>=' | '**=' | '//='); +// For normal and annotated assignments, additional restrictions enforced by the interpreter +del_stmt: 'del' exprlist; +pass_stmt: 'pass'; +flow_stmt: break_stmt | continue_stmt | return_stmt | raise_stmt | yield_stmt; +break_stmt: 'break'; +continue_stmt: 'continue'; +return_stmt: 'return' (testlist)?; +yield_stmt: yield_expr; +raise_stmt: 'raise' (test ('from' test)?)?; +import_stmt: import_name | import_from; +import_name: 'import' dotted_as_names; +// note below: the ('.' | '...') is necessary because '...' is tokenized as ELLIPSIS +import_from: ('from' (('.' | '...')* dotted_name | ('.' | '...')+) + 'import' ('*' | '(' import_as_names ')' | import_as_names)); +import_as_name: NAME ('as' NAME)?; +dotted_as_name: dotted_name ('as' NAME)?; +import_as_names: import_as_name (',' import_as_name)* (',')?; +dotted_as_names: dotted_as_name (',' dotted_as_name)*; +dotted_name: NAME ('.' NAME)*; +global_stmt: 'global' NAME (',' NAME)*; +nonlocal_stmt: 'nonlocal' NAME (',' NAME)*; +assert_stmt: 'assert' test (',' test)?; + +compound_stmt: if_stmt | while_stmt | for_stmt | try_stmt | with_stmt | funcdef | classdef | decorated | async_stmt; +async_stmt: ASYNC (funcdef | with_stmt | for_stmt); +if_stmt: 'if' test ':' suite ('elif' test ':' suite)* ('else' ':' suite)?; +while_stmt: 'while' test ':' suite ('else' ':' suite)?; +for_stmt: 'for' exprlist 'in' testlist ':' suite ('else' ':' suite)?; +try_stmt: ('try' ':' suite + ((except_clause ':' suite)+ + ('else' ':' suite)? + ('finally' ':' suite)? | + 'finally' ':' suite)); +with_stmt: 'with' with_item (',' with_item)* ':' suite; +with_item: test ('as' expr)?; +// NB compile.c makes sure that the default except clause is last +except_clause: 'except' (test ('as' NAME)?)?; +suite: simple_stmt | NEWLINE INDENT stmt+ DEDENT; + +test: or_test ('if' or_test 'else' test)? | lambdef; +test_nocond: or_test | lambdef_nocond; +lambdef: 'lambda' (varargslist)? ':' test; +lambdef_nocond: 'lambda' (varargslist)? ':' test_nocond; +or_test: and_test ('or' and_test)*; +and_test: not_test ('and' not_test)*; +not_test: 'not' not_test | comparison; +comparison: expr (comp_op expr)*; +// <> isn't actually a valid comparison operator in Python. It's here for the +// sake of a __future__ import described in PEP 401 (which really works :-) +comp_op: '<'|'>'|'=='|'>='|'<='|'<>'|'!='|'in'|'not' 'in'|'is'|'is' 'not'; +star_expr: '*' expr; +expr: xor_expr ('|' xor_expr)*; +xor_expr: and_expr ('^' and_expr)*; +and_expr: shift_expr ('&' shift_expr)*; +shift_expr: arith_expr (('<<'|'>>') arith_expr)*; +arith_expr: term (('+'|'-') term)*; +term: factor (('*'|'@'|'/'|'%'|'//') factor)*; +factor: ('+'|'-'|'~') factor | power; +power: atom_expr ('**' factor)?; +atom_expr: (AWAIT)? atom trailer*; +atom: ('(' (yield_expr|testlist_comp)? ')' | + '[' (testlist_comp)? ']' | + '{' (dictorsetmaker)? '}' | + NAME | NUMBER | STRING+ | '...' | 'None' | 'True' | 'False'); +testlist_comp: (test|star_expr) ( comp_for | (',' (test|star_expr))* (',')? ); +trailer: '(' (arglist)? ')' | '[' subscriptlist ']' | '.' NAME; +subscriptlist: subscript (',' subscript)* (',')?; +subscript: test | (test)? ':' (test)? (sliceop)?; +sliceop: ':' (test)?; +exprlist: (expr|star_expr) (',' (expr|star_expr))* (',')?; +testlist: test (',' test)* (',')?; +dictorsetmaker: ( ((test ':' test | '**' expr) + (comp_for | (',' (test ':' test | '**' expr))* (',')?)) | + ((test | star_expr) + (comp_for | (',' (test | star_expr))* (',')?)) ); + +classdef: 'class' NAME ('(' (arglist)? ')')? ':' suite; + +arglist: argument (',' argument)* (',')?; + +// The reason that keywords are test nodes instead of NAME is that using NAME +// results in an ambiguity. ast.c makes sure it's a NAME. +// "test '=' test" is really "keyword '=' test", but we have no such token. +// These need to be in a single rule to avoid grammar that is ambiguous +// to our LL(1) parser. Even though 'test' includes '*expr' in star_expr, +// we explicitly match '*' here, too, to give it proper precedence. +// Illegal combinations and orderings are blocked in ast.c: +// multiple (test comp_for) arguments are blocked; keyword unpackings +// that precede iterable unpackings are blocked; etc. +argument: ( test (comp_for)? | + test '=' test | + '**' test | + '*' test ); + +comp_iter: comp_for | comp_if; +comp_for: (ASYNC)? 'for' exprlist 'in' or_test (comp_iter)?; +comp_if: 'if' test_nocond (comp_iter)?; + +// not used in grammar, but may appear in "node" passed from Parser to Compiler +encoding_decl: NAME; + +yield_expr: 'yield' (yield_arg)?; +yield_arg: 'from' test | testlist; + +/* + * lexer rules + */ + +STRING + : STRING_LITERAL + | BYTES_LITERAL + ; + +NUMBER + : INTEGER + | FLOAT_NUMBER + | IMAG_NUMBER + ; + +INTEGER + : DECIMAL_INTEGER + | OCT_INTEGER + | HEX_INTEGER + | BIN_INTEGER + ; + +DEF : 'def'; +RETURN : 'return'; +RAISE : 'raise'; +FROM : 'from'; +IMPORT : 'import'; +AS : 'as'; +GLOBAL : 'global'; +NONLOCAL : 'nonlocal'; +ASSERT : 'assert'; +IF : 'if'; +ELIF : 'elif'; +ELSE : 'else'; +WHILE : 'while'; +FOR : 'for'; +IN : 'in'; +TRY : 'try'; +FINALLY : 'finally'; +WITH : 'with'; +EXCEPT : 'except'; +LAMBDA : 'lambda'; +OR : 'or'; +AND : 'and'; +NOT : 'not'; +IS : 'is'; +NONE : 'None'; +TRUE : 'True'; +FALSE : 'False'; +CLASS : 'class'; +YIELD : 'yield'; +DEL : 'del'; +PASS : 'pass'; +CONTINUE : 'continue'; +BREAK : 'break'; +ASYNC : 'async'; +AWAIT : 'await'; + +NEWLINE + : ( {atStartOfInput()}? SPACES + | ( '\r'? '\n' | '\r' | '\f' ) SPACES? + ) + { + { + std::string newLine, spaces; + std::string text = getText(); + for(char c : text) + { + if ((c == '\r') || (c == '\n') || (c == '\f')) + newLine.push_back(c); + else + spaces.push_back(c); + } + + + // Strip newlines inside open clauses except if we are near EOF. We keep NEWLINEs near EOF to + // satisfy the final newline needed by the single_put rule used by the REPL. + int next = _input->LA(1); + int nextnext = _input->LA(2); + if (m_opened > 0 || (nextnext != -1 && (next == '\r' || next == '\n' || next == '\f' || next == '#'))) { + // If we're inside a list or on a blank line, ignore all indents, + // dedents and line breaks. + skip(); + } + else { + emit(commonToken(NEWLINE, newLine)); + int indent = getIndentationCount(spaces); + int previous = m_indents.empty() ? 0 : m_indents.top(); + if (indent == previous) { + // skip indents of the same size as the present indent-size + skip(); + } + else if (indent > previous) { + m_indents.push(indent); + emit(commonToken(Python3Parser::INDENT, spaces)); + } + else { + // Possibly emit more than 1 DEDENT token. + while(!m_indents.empty() && m_indents.top() > indent) { + emit(createDedent()); + m_indents.pop(); + } + } + } + } + } + ; + +/// identifier ::= id_start id_continue* +NAME + : ID_START ID_CONTINUE* + ; + +/// stringliteral ::= [stringprefix](shortstring | longstring) +/// stringprefix ::= "r" | "u" | "R" | "U" | "f" | "F" +/// | "fr" | "Fr" | "fR" | "FR" | "rf" | "rF" | "Rf" | "RF" +STRING_LITERAL + : ( [rR] | [uU] | [fF] | ( [fF] [rR] ) | ( [rR] [fF] ) )? ( SHORT_STRING | LONG_STRING ) + ; + +/// bytesliteral ::= bytesprefix(shortbytes | longbytes) +/// bytesprefix ::= "b" | "B" | "br" | "Br" | "bR" | "BR" | "rb" | "rB" | "Rb" | "RB" +BYTES_LITERAL + : ( [bB] | ( [bB] [rR] ) | ( [rR] [bB] ) ) ( SHORT_BYTES | LONG_BYTES ) + ; + +/// decimalinteger ::= nonzerodigit digit* | "0"+ +DECIMAL_INTEGER + : NON_ZERO_DIGIT DIGIT* + | '0'+ + ; + +/// octinteger ::= "0" ("o" | "O") octdigit+ +OCT_INTEGER + : '0' [oO] OCT_DIGIT+ + ; + +/// hexinteger ::= "0" ("x" | "X") hexdigit+ +HEX_INTEGER + : '0' [xX] HEX_DIGIT+ + ; + +/// bininteger ::= "0" ("b" | "B") bindigit+ +BIN_INTEGER + : '0' [bB] BIN_DIGIT+ + ; + +/// floatnumber ::= pointfloat | exponentfloat +FLOAT_NUMBER + : POINT_FLOAT + | EXPONENT_FLOAT + ; + +/// imagnumber ::= (floatnumber | intpart) ("j" | "J") +IMAG_NUMBER + : ( FLOAT_NUMBER | INT_PART ) [jJ] + ; + +DOT : '.'; +ELLIPSIS : '...'; +STAR : '*'; +OPEN_PAREN : '(' {m_opened++;}; +CLOSE_PAREN : ')' {m_opened--;}; +COMMA : ','; +COLON : ':'; +SEMI_COLON : ';'; +POWER : '**'; +ASSIGN : '='; +OPEN_BRACK : '[' {m_opened++;}; +CLOSE_BRACK : ']' {m_opened--;}; +OR_OP : '|'; +XOR : '^'; +AND_OP : '&'; +LEFT_SHIFT : '<<'; +RIGHT_SHIFT : '>>'; +ADD : '+'; +MINUS : '-'; +DIV : '/'; +MOD : '%'; +IDIV : '//'; +NOT_OP : '~'; +OPEN_BRACE : '{' {m_opened++;}; +CLOSE_BRACE : '}' {m_opened--;}; +LESS_THAN : '<'; +GREATER_THAN : '>'; +EQUALS : '=='; +GT_EQ : '>='; +LT_EQ : '<='; +NOT_EQ_1 : '<>'; +NOT_EQ_2 : '!='; +AT : '@'; +ARROW : '->'; +ADD_ASSIGN : '+='; +SUB_ASSIGN : '-='; +MULT_ASSIGN : '*='; +AT_ASSIGN : '@='; +DIV_ASSIGN : '/='; +MOD_ASSIGN : '%='; +AND_ASSIGN : '&='; +OR_ASSIGN : '|='; +XOR_ASSIGN : '^='; +LEFT_SHIFT_ASSIGN : '<<='; +RIGHT_SHIFT_ASSIGN : '>>='; +POWER_ASSIGN : '**='; +IDIV_ASSIGN : '//='; + +SKIP_ + : ( SPACES | COMMENT | LINE_JOINING ) -> skip + ; + +UNKNOWN_CHAR + : . + ; + +/* + * fragments + */ + +/// shortstring ::= "'" shortstringitem* "'" | '"' shortstringitem* '"' +/// shortstringitem ::= shortstringchar | stringescapeseq +/// shortstringchar ::= +fragment SHORT_STRING + : '\'' ( STRING_ESCAPE_SEQ | ~[\\\r\n\f'] )* '\'' + | '"' ( STRING_ESCAPE_SEQ | ~[\\\r\n\f"] )* '"' + ; +/// longstring ::= "'''" longstringitem* "'''" | '"""' longstringitem* '"""' +fragment LONG_STRING + : '\'\'\'' LONG_STRING_ITEM*? '\'\'\'' + | '"""' LONG_STRING_ITEM*? '"""' + ; + +/// longstringitem ::= longstringchar | stringescapeseq +fragment LONG_STRING_ITEM + : LONG_STRING_CHAR + | STRING_ESCAPE_SEQ + ; + +/// longstringchar ::= +fragment LONG_STRING_CHAR + : ~'\\' + ; + +/// stringescapeseq ::= "\" +fragment STRING_ESCAPE_SEQ + : '\\' . + | '\\' NEWLINE + ; + +/// nonzerodigit ::= "1"..."9" +fragment NON_ZERO_DIGIT + : [1-9] + ; + +/// digit ::= "0"..."9" +fragment DIGIT + : [0-9] + ; + +/// octdigit ::= "0"..."7" +fragment OCT_DIGIT + : [0-7] + ; + +/// hexdigit ::= digit | "a"..."f" | "A"..."F" +fragment HEX_DIGIT + : [0-9a-fA-F] + ; + +/// bindigit ::= "0" | "1" +fragment BIN_DIGIT + : [01] + ; + +/// pointfloat ::= [intpart] fraction | intpart "." +fragment POINT_FLOAT + : INT_PART? FRACTION + | INT_PART '.' + ; + +/// exponentfloat ::= (intpart | pointfloat) exponent +fragment EXPONENT_FLOAT + : ( INT_PART | POINT_FLOAT ) EXPONENT + ; + +/// intpart ::= digit+ +fragment INT_PART + : DIGIT+ + ; + +/// fraction ::= "." digit+ +fragment FRACTION + : '.' DIGIT+ + ; + +/// exponent ::= ("e" | "E") ["+" | "-"] digit+ +fragment EXPONENT + : [eE] [+-]? DIGIT+ + ; + +/// shortbytes ::= "'" shortbytesitem* "'" | '"' shortbytesitem* '"' +/// shortbytesitem ::= shortbyteschar | bytesescapeseq +fragment SHORT_BYTES + : '\'' ( SHORT_BYTES_CHAR_NO_SINGLE_QUOTE | BYTES_ESCAPE_SEQ )* '\'' + | '"' ( SHORT_BYTES_CHAR_NO_DOUBLE_QUOTE | BYTES_ESCAPE_SEQ )* '"' + ; + +/// longbytes ::= "'''" longbytesitem* "'''" | '"""' longbytesitem* '"""' +fragment LONG_BYTES + : '\'\'\'' LONG_BYTES_ITEM*? '\'\'\'' + | '"""' LONG_BYTES_ITEM*? '"""' + ; + +/// longbytesitem ::= longbyteschar | bytesescapeseq +fragment LONG_BYTES_ITEM + : LONG_BYTES_CHAR + | BYTES_ESCAPE_SEQ + ; + +/// shortbyteschar ::= +fragment SHORT_BYTES_CHAR_NO_SINGLE_QUOTE + : [\u0000-\u0009] + | [\u000B-\u000C] + | [\u000E-\u0026] + | [\u0028-\u005B] + | [\u005D-\u007F] + ; + +fragment SHORT_BYTES_CHAR_NO_DOUBLE_QUOTE + : [\u0000-\u0009] + | [\u000B-\u000C] + | [\u000E-\u0021] + | [\u0023-\u005B] + | [\u005D-\u007F] + ; + +/// longbyteschar ::= +fragment LONG_BYTES_CHAR + : [\u0000-\u005B] + | [\u005D-\u007F] + ; + +/// bytesescapeseq ::= "\" +fragment BYTES_ESCAPE_SEQ + : '\\' [\u0000-\u007F] + ; + +fragment SPACES + : [ \t]+ + ; + +fragment COMMENT + : '#' ~[\r\n\f]* + ; + +fragment LINE_JOINING + : '\\' SPACES? ( '\r'? '\n' | '\r' | '\f') + ; + +/// id_start ::= +fragment ID_START + : '_' + | [A-Z] + | [a-z] + | '\u00AA' + | '\u00B5' + | '\u00BA' + | [\u00C0-\u00D6] + | [\u00D8-\u00F6] + | [\u00F8-\u01BA] + | '\u01BB' + | [\u01BC-\u01BF] + | [\u01C0-\u01C3] + | [\u01C4-\u0241] + | [\u0250-\u02AF] + | [\u02B0-\u02C1] + | [\u02C6-\u02D1] + | [\u02E0-\u02E4] + | '\u02EE' + | '\u037A' + | '\u0386' + | [\u0388-\u038A] + | '\u038C' + | [\u038E-\u03A1] + | [\u03A3-\u03CE] + | [\u03D0-\u03F5] + | [\u03F7-\u0481] + | [\u048A-\u04CE] + | [\u04D0-\u04F9] + | [\u0500-\u050F] + | [\u0531-\u0556] + | '\u0559' + | [\u0561-\u0587] + | [\u05D0-\u05EA] + | [\u05F0-\u05F2] + | [\u0621-\u063A] + | '\u0640' + | [\u0641-\u064A] + | [\u066E-\u066F] + | [\u0671-\u06D3] + | '\u06D5' + | [\u06E5-\u06E6] + | [\u06EE-\u06EF] + | [\u06FA-\u06FC] + | '\u06FF' + | '\u0710' + | [\u0712-\u072F] + | [\u074D-\u076D] + | [\u0780-\u07A5] + | '\u07B1' + | [\u0904-\u0939] + | '\u093D' + | '\u0950' + | [\u0958-\u0961] + | '\u097D' + | [\u0985-\u098C] + | [\u098F-\u0990] + | [\u0993-\u09A8] + | [\u09AA-\u09B0] + | '\u09B2' + | [\u09B6-\u09B9] + | '\u09BD' + | '\u09CE' + | [\u09DC-\u09DD] + | [\u09DF-\u09E1] + | [\u09F0-\u09F1] + | [\u0A05-\u0A0A] + | [\u0A0F-\u0A10] + | [\u0A13-\u0A28] + | [\u0A2A-\u0A30] + | [\u0A32-\u0A33] + | [\u0A35-\u0A36] + | [\u0A38-\u0A39] + | [\u0A59-\u0A5C] + | '\u0A5E' + | [\u0A72-\u0A74] + | [\u0A85-\u0A8D] + | [\u0A8F-\u0A91] + | [\u0A93-\u0AA8] + | [\u0AAA-\u0AB0] + | [\u0AB2-\u0AB3] + | [\u0AB5-\u0AB9] + | '\u0ABD' + | '\u0AD0' + | [\u0AE0-\u0AE1] + | [\u0B05-\u0B0C] + | [\u0B0F-\u0B10] + | [\u0B13-\u0B28] + | [\u0B2A-\u0B30] + | [\u0B32-\u0B33] + | [\u0B35-\u0B39] + | '\u0B3D' + | [\u0B5C-\u0B5D] + | [\u0B5F-\u0B61] + | '\u0B71' + | '\u0B83' + | [\u0B85-\u0B8A] + | [\u0B8E-\u0B90] + | [\u0B92-\u0B95] + | [\u0B99-\u0B9A] + | '\u0B9C' + | [\u0B9E-\u0B9F] + | [\u0BA3-\u0BA4] + | [\u0BA8-\u0BAA] + | [\u0BAE-\u0BB9] + | [\u0C05-\u0C0C] + | [\u0C0E-\u0C10] + | [\u0C12-\u0C28] + | [\u0C2A-\u0C33] + | [\u0C35-\u0C39] + | [\u0C60-\u0C61] + | [\u0C85-\u0C8C] + | [\u0C8E-\u0C90] + | [\u0C92-\u0CA8] + | [\u0CAA-\u0CB3] + | [\u0CB5-\u0CB9] + | '\u0CBD' + | '\u0CDE' + | [\u0CE0-\u0CE1] + | [\u0D05-\u0D0C] + | [\u0D0E-\u0D10] + | [\u0D12-\u0D28] + | [\u0D2A-\u0D39] + | [\u0D60-\u0D61] + | [\u0D85-\u0D96] + | [\u0D9A-\u0DB1] + | [\u0DB3-\u0DBB] + | '\u0DBD' + | [\u0DC0-\u0DC6] + | [\u0E01-\u0E30] + | [\u0E32-\u0E33] + | [\u0E40-\u0E45] + | '\u0E46' + | [\u0E81-\u0E82] + | '\u0E84' + | [\u0E87-\u0E88] + | '\u0E8A' + | '\u0E8D' + | [\u0E94-\u0E97] + | [\u0E99-\u0E9F] + | [\u0EA1-\u0EA3] + | '\u0EA5' + | '\u0EA7' + | [\u0EAA-\u0EAB] + | [\u0EAD-\u0EB0] + | [\u0EB2-\u0EB3] + | '\u0EBD' + | [\u0EC0-\u0EC4] + | '\u0EC6' + | [\u0EDC-\u0EDD] + | '\u0F00' + | [\u0F40-\u0F47] + | [\u0F49-\u0F6A] + | [\u0F88-\u0F8B] + | [\u1000-\u1021] + | [\u1023-\u1027] + | [\u1029-\u102A] + | [\u1050-\u1055] + | [\u10A0-\u10C5] + | [\u10D0-\u10FA] + | '\u10FC' + | [\u1100-\u1159] + | [\u115F-\u11A2] + | [\u11A8-\u11F9] + | [\u1200-\u1248] + | [\u124A-\u124D] + | [\u1250-\u1256] + | '\u1258' + | [\u125A-\u125D] + | [\u1260-\u1288] + | [\u128A-\u128D] + | [\u1290-\u12B0] + | [\u12B2-\u12B5] + | [\u12B8-\u12BE] + | '\u12C0' + | [\u12C2-\u12C5] + | [\u12C8-\u12D6] + | [\u12D8-\u1310] + | [\u1312-\u1315] + | [\u1318-\u135A] + | [\u1380-\u138F] + | [\u13A0-\u13F4] + | [\u1401-\u166C] + | [\u166F-\u1676] + | [\u1681-\u169A] + | [\u16A0-\u16EA] + | [\u16EE-\u16F0] + | [\u1700-\u170C] + | [\u170E-\u1711] + | [\u1720-\u1731] + | [\u1740-\u1751] + | [\u1760-\u176C] + | [\u176E-\u1770] + | [\u1780-\u17B3] + | '\u17D7' + | '\u17DC' + | [\u1820-\u1842] + | '\u1843' + | [\u1844-\u1877] + | [\u1880-\u18A8] + | [\u1900-\u191C] + | [\u1950-\u196D] + | [\u1970-\u1974] + | [\u1980-\u19A9] + | [\u19C1-\u19C7] + | [\u1A00-\u1A16] + | [\u1D00-\u1D2B] + | [\u1D2C-\u1D61] + | [\u1D62-\u1D77] + | '\u1D78' + | [\u1D79-\u1D9A] + | [\u1D9B-\u1DBF] + | [\u1E00-\u1E9B] + | [\u1EA0-\u1EF9] + | [\u1F00-\u1F15] + | [\u1F18-\u1F1D] + | [\u1F20-\u1F45] + | [\u1F48-\u1F4D] + | [\u1F50-\u1F57] + | '\u1F59' + | '\u1F5B' + | '\u1F5D' + | [\u1F5F-\u1F7D] + | [\u1F80-\u1FB4] + | [\u1FB6-\u1FBC] + | '\u1FBE' + | [\u1FC2-\u1FC4] + | [\u1FC6-\u1FCC] + | [\u1FD0-\u1FD3] + | [\u1FD6-\u1FDB] + | [\u1FE0-\u1FEC] + | [\u1FF2-\u1FF4] + | [\u1FF6-\u1FFC] + | '\u2071' + | '\u207F' + | [\u2090-\u2094] + | '\u2102' + | '\u2107' + | [\u210A-\u2113] + | '\u2115' + | '\u2118' + | [\u2119-\u211D] + | '\u2124' + | '\u2126' + | '\u2128' + | [\u212A-\u212D] + | '\u212E' + | [\u212F-\u2131] + | [\u2133-\u2134] + | [\u2135-\u2138] + | '\u2139' + | [\u213C-\u213F] + | [\u2145-\u2149] + | [\u2160-\u2183] + | [\u2C00-\u2C2E] + | [\u2C30-\u2C5E] + | [\u2C80-\u2CE4] + | [\u2D00-\u2D25] + | [\u2D30-\u2D65] + | '\u2D6F' + | [\u2D80-\u2D96] + | [\u2DA0-\u2DA6] + | [\u2DA8-\u2DAE] + | [\u2DB0-\u2DB6] + | [\u2DB8-\u2DBE] + | [\u2DC0-\u2DC6] + | [\u2DC8-\u2DCE] + | [\u2DD0-\u2DD6] + | [\u2DD8-\u2DDE] + | '\u3005' + | '\u3006' + | '\u3007' + | [\u3021-\u3029] + | [\u3031-\u3035] + | [\u3038-\u303A] + | '\u303B' + | '\u303C' + | [\u3041-\u3096] + | [\u309B-\u309C] + | [\u309D-\u309E] + | '\u309F' + | [\u30A1-\u30FA] + | [\u30FC-\u30FE] + | '\u30FF' + | [\u3105-\u312C] + | [\u3131-\u318E] + | [\u31A0-\u31B7] + | [\u31F0-\u31FF] + | [\u3400-\u4DB5] + | [\u4E00-\u9FBB] + | [\uA000-\uA014] + | '\uA015' + | [\uA016-\uA48C] + | [\uA800-\uA801] + | [\uA803-\uA805] + | [\uA807-\uA80A] + | [\uA80C-\uA822] + | [\uAC00-\uD7A3] + | [\uF900-\uFA2D] + | [\uFA30-\uFA6A] + | [\uFA70-\uFAD9] + | [\uFB00-\uFB06] + | [\uFB13-\uFB17] + | '\uFB1D' + | [\uFB1F-\uFB28] + | [\uFB2A-\uFB36] + | [\uFB38-\uFB3C] + | '\uFB3E' + | [\uFB40-\uFB41] + | [\uFB43-\uFB44] + | [\uFB46-\uFBB1] + | [\uFBD3-\uFD3D] + | [\uFD50-\uFD8F] + | [\uFD92-\uFDC7] + | [\uFDF0-\uFDFB] + | [\uFE70-\uFE74] + | [\uFE76-\uFEFC] + | [\uFF21-\uFF3A] + | [\uFF41-\uFF5A] + | [\uFF66-\uFF6F] + | '\uFF70' + | [\uFF71-\uFF9D] + | [\uFF9E-\uFF9F] + | [\uFFA0-\uFFBE] + | [\uFFC2-\uFFC7] + | [\uFFCA-\uFFCF] + | [\uFFD2-\uFFD7] + | [\uFFDA-\uFFDC] + ; + +/// id_continue ::= +fragment ID_CONTINUE + : ID_START + | [0-9] + | [\u0300-\u036F] + | [\u0483-\u0486] + | [\u0591-\u05B9] + | [\u05BB-\u05BD] + | '\u05BF' + | [\u05C1-\u05C2] + | [\u05C4-\u05C5] + | '\u05C7' + | [\u0610-\u0615] + | [\u064B-\u065E] + | [\u0660-\u0669] + | '\u0670' + | [\u06D6-\u06DC] + | [\u06DF-\u06E4] + | [\u06E7-\u06E8] + | [\u06EA-\u06ED] + | [\u06F0-\u06F9] + | '\u0711' + | [\u0730-\u074A] + | [\u07A6-\u07B0] + | [\u0901-\u0902] + | '\u0903' + | '\u093C' + | [\u093E-\u0940] + | [\u0941-\u0948] + | [\u0949-\u094C] + | '\u094D' + | [\u0951-\u0954] + | [\u0962-\u0963] + | [\u0966-\u096F] + | '\u0981' + | [\u0982-\u0983] + | '\u09BC' + | [\u09BE-\u09C0] + | [\u09C1-\u09C4] + | [\u09C7-\u09C8] + | [\u09CB-\u09CC] + | '\u09CD' + | '\u09D7' + | [\u09E2-\u09E3] + | [\u09E6-\u09EF] + | [\u0A01-\u0A02] + | '\u0A03' + | '\u0A3C' + | [\u0A3E-\u0A40] + | [\u0A41-\u0A42] + | [\u0A47-\u0A48] + | [\u0A4B-\u0A4D] + | [\u0A66-\u0A6F] + | [\u0A70-\u0A71] + | [\u0A81-\u0A82] + | '\u0A83' + | '\u0ABC' + | [\u0ABE-\u0AC0] + | [\u0AC1-\u0AC5] + | [\u0AC7-\u0AC8] + | '\u0AC9' + | [\u0ACB-\u0ACC] + | '\u0ACD' + | [\u0AE2-\u0AE3] + | [\u0AE6-\u0AEF] + | '\u0B01' + | [\u0B02-\u0B03] + | '\u0B3C' + | '\u0B3E' + | '\u0B3F' + | '\u0B40' + | [\u0B41-\u0B43] + | [\u0B47-\u0B48] + | [\u0B4B-\u0B4C] + | '\u0B4D' + | '\u0B56' + | '\u0B57' + | [\u0B66-\u0B6F] + | '\u0B82' + | [\u0BBE-\u0BBF] + | '\u0BC0' + | [\u0BC1-\u0BC2] + | [\u0BC6-\u0BC8] + | [\u0BCA-\u0BCC] + | '\u0BCD' + | '\u0BD7' + | [\u0BE6-\u0BEF] + | [\u0C01-\u0C03] + | [\u0C3E-\u0C40] + | [\u0C41-\u0C44] + | [\u0C46-\u0C48] + | [\u0C4A-\u0C4D] + | [\u0C55-\u0C56] + | [\u0C66-\u0C6F] + | [\u0C82-\u0C83] + | '\u0CBC' + | '\u0CBE' + | '\u0CBF' + | [\u0CC0-\u0CC4] + | '\u0CC6' + | [\u0CC7-\u0CC8] + | [\u0CCA-\u0CCB] + | [\u0CCC-\u0CCD] + | [\u0CD5-\u0CD6] + | [\u0CE6-\u0CEF] + | [\u0D02-\u0D03] + | [\u0D3E-\u0D40] + | [\u0D41-\u0D43] + | [\u0D46-\u0D48] + | [\u0D4A-\u0D4C] + | '\u0D4D' + | '\u0D57' + | [\u0D66-\u0D6F] + | [\u0D82-\u0D83] + | '\u0DCA' + | [\u0DCF-\u0DD1] + | [\u0DD2-\u0DD4] + | '\u0DD6' + | [\u0DD8-\u0DDF] + | [\u0DF2-\u0DF3] + | '\u0E31' + | [\u0E34-\u0E3A] + | [\u0E47-\u0E4E] + | [\u0E50-\u0E59] + | '\u0EB1' + | [\u0EB4-\u0EB9] + | [\u0EBB-\u0EBC] + | [\u0EC8-\u0ECD] + | [\u0ED0-\u0ED9] + | [\u0F18-\u0F19] + | [\u0F20-\u0F29] + | '\u0F35' + | '\u0F37' + | '\u0F39' + | [\u0F3E-\u0F3F] + | [\u0F71-\u0F7E] + | '\u0F7F' + | [\u0F80-\u0F84] + | [\u0F86-\u0F87] + | [\u0F90-\u0F97] + | [\u0F99-\u0FBC] + | '\u0FC6' + | '\u102C' + | [\u102D-\u1030] + | '\u1031' + | '\u1032' + | [\u1036-\u1037] + | '\u1038' + | '\u1039' + | [\u1040-\u1049] + | [\u1056-\u1057] + | [\u1058-\u1059] + | '\u135F' + | [\u1369-\u1371] + | [\u1712-\u1714] + | [\u1732-\u1734] + | [\u1752-\u1753] + | [\u1772-\u1773] + | '\u17B6' + | [\u17B7-\u17BD] + | [\u17BE-\u17C5] + | '\u17C6' + | [\u17C7-\u17C8] + | [\u17C9-\u17D3] + | '\u17DD' + | [\u17E0-\u17E9] + | [\u180B-\u180D] + | [\u1810-\u1819] + | '\u18A9' + | [\u1920-\u1922] + | [\u1923-\u1926] + | [\u1927-\u1928] + | [\u1929-\u192B] + | [\u1930-\u1931] + | '\u1932' + | [\u1933-\u1938] + | [\u1939-\u193B] + | [\u1946-\u194F] + | [\u19B0-\u19C0] + | [\u19C8-\u19C9] + | [\u19D0-\u19D9] + | [\u1A17-\u1A18] + | [\u1A19-\u1A1B] + | [\u1DC0-\u1DC3] + | [\u203F-\u2040] + | '\u2054' + | [\u20D0-\u20DC] + | '\u20E1' + | [\u20E5-\u20EB] + | [\u302A-\u302F] + | [\u3099-\u309A] + | '\uA802' + | '\uA806' + | '\uA80B' + | [\uA823-\uA824] + | [\uA825-\uA826] + | '\uA827' + | '\uFB1E' + | [\uFE00-\uFE0F] + | [\uFE20-\uFE23] + | [\uFE33-\uFE34] + | [\uFE4D-\uFE4F] + | [\uFF10-\uFF19] + | '\uFF3F' + ; diff --git a/server/pkg/antlr/testprogs/cpp/test.cpp b/server/pkg/antlr/testprogs/cpp/test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..d43253fba4408fa8e2fdb45d21baad10b6d8826f --- /dev/null +++ b/server/pkg/antlr/testprogs/cpp/test.cpp @@ -0,0 +1,12 @@ +#include + +using namespace std; + +int main() +{ + if (true && true) { + cout << "Hello World!"; + } + return 0; +} + diff --git a/server/pkg/antlr/testprogs/python/test.py b/server/pkg/antlr/testprogs/python/test.py new file mode 100644 index 0000000000000000000000000000000000000000..327d9004f717869738016e24306e6757c3ed0b1f --- /dev/null +++ b/server/pkg/antlr/testprogs/python/test.py @@ -0,0 +1,7 @@ +var_1 = 1567 +reverse = 0 +while var_1 > 0: + rest = var_1 % 10 + reverse = reverse * 10 + rest + var_1 = var_1 // 10 +print("Число в обратном порядке:", reverse) \ No newline at end of file diff --git a/server/pkg/antlr/virtual/IAntlrWrapper.h b/server/pkg/antlr/virtual/IAntlrWrapper.h new file mode 100644 index 0000000000000000000000000000000000000000..13b3a4db29448819310624a52ba98fb83fa3eaf4 --- /dev/null +++ b/server/pkg/antlr/virtual/IAntlrWrapper.h @@ -0,0 +1,9 @@ +#pragma once + +#include + +class IAntlrWrapper { + public: + virtual std::vector getTokens() = 0; + virtual std::string getTreeString() = 0; +};