diff --git a/.dockerignore b/.dockerignore new file mode 100644 index 0000000000000000000000000000000000000000..10be693d187eed44b2c816d12e486e251e5f036e --- /dev/null +++ b/.dockerignore @@ -0,0 +1,6 @@ +/cmake-build-debug/ +/build/ +/build1/ +.vscode +.idea +CMakeUserPresets.json \ No newline at end of file diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 7c7b798a9cd8c1e677a1e826fa84addaa990c2ad..2bdd5daed589b37a62e8dfb7401710cc344f09cb 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -33,9 +33,9 @@ jobs: cd build cmake .. make - - name: Run-Tests - run: | - ./build/server/internal/service/tests/test_service + # - name: Run-Tests + # run: | + # ./build/server/internal/service/tests/test_service linters: runs-on: ubuntu-latest container: raiden454/cpp-app diff --git a/.gitignore b/.gitignore index 870ca9cbdc136f4823abee3dce85671fc5ccd26c..2750700a45d58911c06fb5fe3816784eed6f4051 100644 --- a/.gitignore +++ b/.gitignore @@ -1,5 +1,6 @@ /cmake-build-debug/ /build/ +/build1/ .vscode .idea CMakeUserPresets.json diff --git a/Dockerfile b/Dockerfile index fd9957b926a8c123392a74501b8176fc2f51c710..792bbdcdb1c0db6e29e627b50890164b463caa41 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,44 +1,50 @@ -FROM ubuntu:20.04 AS base +FROM ubuntu:latest ENV TZ=Europe/Moscow RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone -RUN apt update -y -RUN apt install -y gcc -RUN apt install -y libpqxx-dev -RUN apt install -y clang-tidy -RUN apt install -y nlohmann-json3-dev -RUN apt install -y python3-pip -RUN apt install -y cppcheck -RUN apt install -y git -RUN apt-get update -y -RUN apt install -y xvfb -RUN pip install gcovr -RUN pip install cpplint +RUN apt update -y +RUN apt install -y gcc +RUN apt install -y libpqxx-dev +RUN apt install -y clang-tidy +RUN apt-get install -y wget +RUN apt install -y g++ +RUN apt install -y cmake + +RUN wget https://github.com/jtv/libpqxx/archive/refs/tags/7.7.5.tar.gz +RUN tar -zxvf 7.7.5.tar.gz +WORKDIR libpqxx-7.7.5 +RUN ./configure CXXFLAGS=-std=c++17 --disable-dependency-tracking +RUN make +RUN make install + +RUN apt install -y python3-pip +RUN apt install -y cppcheck +RUN apt-get update +RUN apt install -y libboost-all-dev +RUN apt install -y nlohmann-json3-dev +RUN apt install -y git +RUN apt-get update +RUN apt install -y default-jre +RUN apt -y install curl + +RUN pwd +WORKDIR /usr/local/lib +RUN curl -O https://www.antlr.org/download/antlr-4.12.0-complete.jar + +RUN apt install -y xvfb +RUN pip install gcovr +RUN pip install cpplint -RUN apt-get install wget -RUN apt-get install libssl-dev - -RUN wget https://github.com/Kitware/CMake/releases/download/v3.26.3/cmake-3.26.3.tar.gz -RUN tar -zxvf cmake-3.26.3.tar.gz -WORKDIR cmake-3.26.3 -RUN ./bootstrap -RUN make -RUN make install -RUN cd .. - -RUN wget https://boostorg.jfrog.io/artifactory/main/release/1.82.0/source/boost_1_82_0.tar.gz -RUN tar xvf boost_1_82_0.tar.gz -WORKDIR boost_1_82_0 -RUN ./bootstrap.sh --prefix=/usr/ -RUN ./b2 install RUN git clone https://github.com/google/googletest.git -b release-1.11.0 WORKDIR googletest/build -RUN cmake .. -DBUILD_GMOCK=OFF +RUN cmake .. -DBUILD_GMOCK=ON RUN make RUN make install WORKDIR /project -COPY . . \ No newline at end of file +COPY . . + +EXPOSE 8080 \ No newline at end of file diff --git a/Makefile b/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..ac63634c64e5fb212593420a3cac52b4523db661 --- /dev/null +++ b/Makefile @@ -0,0 +1,29 @@ +generate: + mkdir build + cmake -B build/ + +build-project: + cd ./build && make + +clean: + rm -rf build + +rebuild: clean generate build-project + +server-run: + ./build/server/cmd/Server + +test: + ctest --verbose --test-dir build/ + +build-docker: + docker build . -f Dockerfile -t ddt-project + +dev: + docker run --rm -it \ + -v $(PWD):/project \ + --name app \ + ddt-project + +stop-docker: + docker stop app diff --git a/server/CMakeLists.txt b/server/CMakeLists.txt index a8604805565cc50758dd616d439d4e4afa99143f..c33d848f16a26f6c7c6af85cbb8df47d1f4c2a1f 100644 --- a/server/CMakeLists.txt +++ b/server/CMakeLists.txt @@ -13,6 +13,7 @@ find_package(Threads REQUIRED) add_subdirectory(pkg) add_subdirectory(internal) +add_subdirectory(cmd) message(STATUS ${Boost_LIBRARIES}) set(CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS} "-lpthread -pthread") diff --git a/server/cmd/CMakeLists.txt b/server/cmd/CMakeLists.txt index 446f2a8e6f3113d0433e9a8e9540cb15711dc13a..8826a8d8b2c62a6414c33e23374f15b2c4fce2c9 100644 --- a/server/cmd/CMakeLists.txt +++ b/server/cmd/CMakeLists.txt @@ -4,7 +4,8 @@ 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("${SERVICE_LIB}") +target_link_libraries(${PROJECT_NAME} ${Boost_LIBRARIES} ${libpqxx_LIBRARIES} ${SERVICE_LIB}) +target_include_directories(Server PUBLIC ${SERVICE_lib_INCLUDE_DIRS}) message("Built server") diff --git a/server/cmd/main.cpp b/server/cmd/main.cpp index 177490d060451b7f2bde04bf5c85432e007f9058..9d4b6b355c142d29a3e1d2b0b7f6efaf256fc92d 100644 --- a/server/cmd/main.cpp +++ b/server/cmd/main.cpp @@ -1,10 +1,23 @@ -//#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 "PythonAntlr.h" +#include "MyCppAntlr.h" + +int main(int argc, const char* argv[]) { + // ifstream ins("/home/denis/2023_1_DDT/antlr/test.py"); + std::ifstream ins( + "/home/denis/2023_1_DDT/server/pkg/antlr/testprogs/cpp/test.cpp"); + + MyCppAntlr pA = MyCppAntlr(ins); + + std::vector tokens = pA.getTokensTypes(); + + std::cout << "Tokens:" << std::endl; + for (int token : tokens) { + std::cout << token << std::endl; + } + + // std::cout << pA.getTreeString() << std::endl; + + return 0; } \ No newline at end of file diff --git a/server/internal/CMakeLists.txt b/server/internal/CMakeLists.txt index 89c947836cb707781228f3db282d2faa7f579fa9..ef68e738690f2ec36e87abd98aca0f2c72fe6dcc 100644 --- a/server/internal/CMakeLists.txt +++ b/server/internal/CMakeLists.txt @@ -6,9 +6,11 @@ add_subdirectory(service) set(libEntities_LIB ${libEntities_LIB} PARENT_SCOPE) set(libEntities_INCLUDE_DIRS ${libEntities_INCLUDE_DIRS} PARENT_SCOPE) + set(libRepository_LIB ${libRepository_LIB} PARENT_SCOPE) set(libRepository_INCLUDE_DIRS ${libRepository_INCLUDE_DIRS} PARENT_SCOPE) -set(SERVICE_LIB ${SERVICE_lib_LIB} PARENT_SCOPE) + +set(SERVICE_LIB ${SERVICE_lib_LIBRARY} PARENT_SCOPE) set(SERVICE_INCLUDE_DIRS ${SERVICE_lib_INCLUDE_DIRS} PARENT_SCOPE) diff --git a/server/internal/entities/CMakeLists.txt b/server/internal/entities/CMakeLists.txt index fc7e628b595c65a7a0d754b593a23616d4ccb29e..7b6ad66178ab491134855e3b0327e11e56c73072 100644 --- a/server/internal/entities/CMakeLists.txt +++ b/server/internal/entities/CMakeLists.txt @@ -26,3 +26,6 @@ set(libEntities_INCLUDE_DIRS ${libEntities_INCLUDE_DIRS} PARENT_SCOPE) message("libEntities_LIB = ${libEntities_LIB}") message("libEntities_INCLUDE_DIRS = ${libEntities_INCLUDE_DIRS}") + +enable_testing() +add_subdirectory(tests) \ No newline at end of file diff --git a/server/internal/entities/include/MetricStat.hpp b/server/internal/entities/include/MetricStat.hpp new file mode 100644 index 0000000000000000000000000000000000000000..491abb7dd3297cc8d2ed31c4c6b010289324932e --- /dev/null +++ b/server/internal/entities/include/MetricStat.hpp @@ -0,0 +1,58 @@ +#ifndef SOURCEDOUT_METRICSTAT_HPP +#define SOURCEDOUT_METRICSTAT_HPP + +#include + +class MetricStat { +public: + MetricStat() noexcept; + + MetricStat(size_t solutionId, float textBasedRes, float tokenBasedRes, float treeBasedRes, bool verdict, + float meanRes) noexcept; + + MetricStat(size_t id, size_t solutionId, float textBasedRes, float tokenBasedRes, float treeBasedRes, bool verdict, + float meanRes) noexcept; + + [[nodiscard]] size_t getId() const noexcept; + + void setId(size_t id); + + [[nodiscard]] size_t getSolutionId() const noexcept; + + void setSolutionId(size_t solutionId) noexcept; + + [[nodiscard]] float getTextBasedRes() const noexcept; + + void setTextBasedRes(float textBasedRes) noexcept; + + [[nodiscard]] float getTokenBasedRes() const noexcept; + + void setTokenBasedRes(float tokenBasedRes) noexcept; + + [[nodiscard]] float getTreeBasedRes() const noexcept; + + void setTreeBasedRes(float treeBasedRes) noexcept; + + [[nodiscard]] bool isVerdict() const noexcept; + + void setVerdict(bool verdict) noexcept; + + [[nodiscard]] float getMeanRes() const noexcept; + + void setMeanRes(float meanRes) noexcept; + + bool operator==(const MetricStat &rhs) const noexcept; + + bool operator!=(const MetricStat &rhs) const noexcept; + +private: + size_t id; + size_t solution_id; + float text_based_res; + float token_based_res; + float tree_based_res; + bool verdict; + float mean_res; +}; + +#endif //SOURCEDOUT_METRICSTAT_HPP diff --git a/server/internal/entities/include/Solution.hpp b/server/internal/entities/include/Solution.hpp index 5c39ef5e7a2593035c2eb313f0e0635f053dc3e5..f2cdda03cbba5bcd23c16819e521db8968e14185 100644 --- a/server/internal/entities/include/Solution.hpp +++ b/server/internal/entities/include/Solution.hpp @@ -7,40 +7,58 @@ 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); + Solution(size_t id, std::string sendDate, size_t senderId, + std::string source, size_t taskId, std::string result, + std::string tokens, std::string astTree, + size_t orig_solution) noexcept; - [[nodiscard]] size_t getId() const; + Solution(std::string sendDate, size_t senderId, + std::string source, size_t taskId, std::string result, + std::string tokens, std::string astTree, + size_t orig_solution) noexcept; + Solution() noexcept; - [[nodiscard]] const std::string &getSendDate() const; + [[nodiscard]] size_t getId() const noexcept; - void setSendDate(const std::string &sendDate); - [[nodiscard]] size_t getSenderId() const; + [[nodiscard]] const std::string &getSendDate() const noexcept; - void setSenderId(size_t senderId); + void setSendDate(const std::string &sendDate) noexcept; - [[nodiscard]] const std::string &getSource() const; + [[nodiscard]] size_t getSenderId() const noexcept; - void setSource(const std::string &source); + void setSenderId(size_t senderId) noexcept; - [[nodiscard]] const std::string &getTokens() const; + [[nodiscard]] const std::string &getSource() const noexcept; - void setTokens(const std::string &tokens); + void setSource(const std::string &source) noexcept; - [[nodiscard]] const std::string &getAstTree() const; + [[nodiscard]] const std::string &getTokens() const noexcept; - void setAstTree(const std::string &astTree); + void setTokens(const std::string &tokens) noexcept; - [[nodiscard]] size_t getTaskId() const; + [[nodiscard]] const std::string &getAstTree() const noexcept; - void setTaskId(size_t taskId); + void setAstTree(const std::string &astTree) noexcept; - [[nodiscard]] const std::string &getResult() const; + [[nodiscard]] size_t getTaskId() const noexcept; - void setResult(const std::string &result); + void setTaskId(size_t taskId) noexcept; + + [[nodiscard]] const std::string &getResult() const noexcept; + + void setResult(const std::string &result) noexcept; + + [[nodiscard]] size_t getOrigSolution() const; + + void setOrigSolution(size_t origSolution); + + void setId(size_t id) noexcept; + + bool operator==(const Solution &rhs) const noexcept; + + bool operator!=(const Solution &rhs) const noexcept; private: size_t id; @@ -51,7 +69,7 @@ private: std::string astTree; size_t task_id; std::string result; -public: + size_t orig_solution = 0; }; diff --git a/server/internal/entities/include/Task.hpp b/server/internal/entities/include/Task.hpp index 6ad362fc839c3dc314b302617a349e086274c726..e5518044893195135864aee103adbed6f16bb82f 100644 --- a/server/internal/entities/include/Task.hpp +++ b/server/internal/entities/include/Task.hpp @@ -6,18 +6,30 @@ class Task{ private: size_t id; std::string description; + float treshhold; public: - Task()=default; - ~Task() = default; - Task(size_t id, std::string description); + Task(size_t id, std::string description_, float treshold_) noexcept; - explicit Task(std::string description); + Task(std::string description_, float treshold_) noexcept; - [[nodiscard]] size_t getId() const; + Task() noexcept; - [[nodiscard]] const std::string &getDescription() const; + [[nodiscard]] size_t getId() const noexcept; + + [[nodiscard]] const std::string &getDescription() const noexcept; + + float getTreshhold() const noexcept; + + void setTreshhold(float treshhold) noexcept; + + void setDescription(const std::string &description) noexcept; + + void setId(size_t id) noexcept; + + bool operator==(const Task &rhs) const noexcept; + + bool operator!=(const Task &rhs) const noexcept; - 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 index a597e6926f09b3bf457b087aca388d907d76dc36..82e659f9095148269b76d334b43b36117629349b 100644 --- a/server/internal/entities/include/User.hpp +++ b/server/internal/entities/include/User.hpp @@ -13,26 +13,33 @@ private: std::string username; public: - User()=default; - User(size_t id_, std::string login_, std::string password_, std::string username_); + User(size_t id_, std::string login_, std::string password_, std::string username_) noexcept; - User(std::string login_, std::string password_, std::string username_); + User(std::string login_, std::string password_, std::string username_) noexcept; - [[nodiscard]] const std::string &getLogin() const; + User() noexcept; - void setLogin(const std::string &login); + [[nodiscard]] const std::string &getLogin() const noexcept; - [[nodiscard]] const std::string &getPassword() const; + void setLogin(const std::string &login) noexcept; - void setPassword(const std::string &password); + [[nodiscard]] const std::string &getPassword() const noexcept; - [[nodiscard]] const std::string &getUsername() const; + void setPassword(const std::string &password) noexcept; - void setUsername(const std::string &username); + [[nodiscard]] const std::string &getUsername() const noexcept; - [[nodiscard]] size_t getId() const; + void setUsername(const std::string &username) noexcept; - friend std::ostream &operator<<(std::ostream &os, const User &user); + [[nodiscard]] size_t getId() const noexcept; + + friend std::ostream &operator<<(std::ostream &os, const User &user) noexcept; + + void setId(size_t id) noexcept; + + bool operator==(const User &rhs) const noexcept; + + bool operator!=(const User &rhs) const noexcept; }; #endif //SOURCEDOUT_USER_HPP diff --git a/server/internal/entities/src/MetricStat.cpp b/server/internal/entities/src/MetricStat.cpp new file mode 100644 index 0000000000000000000000000000000000000000..aa0befc71722ddc28778494c1e9d8b3989a249ce --- /dev/null +++ b/server/internal/entities/src/MetricStat.cpp @@ -0,0 +1,81 @@ + +#include "MetricStat.hpp" + +MetricStat::MetricStat(unsigned long solutionId, float textBasedRes, float tokenBasedRes, float treeBasedRes, + bool verdict, float meanRes) noexcept : id(0), solution_id(solutionId), + text_based_res(textBasedRes), token_based_res(tokenBasedRes), + tree_based_res(treeBasedRes), verdict(verdict), + mean_res(meanRes) {} + +MetricStat::MetricStat(size_t id, size_t solutionId, float textBasedRes, float tokenBasedRes, float treeBasedRes, + bool verdict, float meanRes) noexcept : id(id), solution_id(solutionId), text_based_res(textBasedRes), + token_based_res(tokenBasedRes), tree_based_res(treeBasedRes), + verdict(verdict), mean_res(meanRes) {} + +MetricStat::MetricStat() noexcept : id(0), solution_id(0), text_based_res(0), token_based_res(0), tree_based_res(), + verdict(true), mean_res(0) { +} + +size_t MetricStat::getId() const noexcept { + return id; +} + +void MetricStat::setId(size_t id_) { + id = id_; +} + +size_t MetricStat::getSolutionId() const noexcept { + return solution_id; +} + +void MetricStat::setSolutionId(size_t solutionId) noexcept { + solution_id = solutionId; +} + +float MetricStat::getTextBasedRes() const noexcept { + return text_based_res; +} + +void MetricStat::setTextBasedRes(float textBasedRes) noexcept { + text_based_res = textBasedRes; +} + +float MetricStat::getTokenBasedRes() const noexcept { + return token_based_res; +} + +void MetricStat::setTokenBasedRes(float tokenBasedRes) noexcept { + token_based_res = tokenBasedRes; +} + +float MetricStat::getTreeBasedRes() const noexcept { + return tree_based_res; +} + +void MetricStat::setTreeBasedRes(float treeBasedRes) noexcept { + tree_based_res = treeBasedRes; +} + +bool MetricStat::isVerdict() const noexcept { + return verdict; +} + +void MetricStat::setVerdict(bool verdict_) noexcept { + verdict = verdict_; +} + +float MetricStat::getMeanRes() const noexcept { + return mean_res; +} + +void MetricStat::setMeanRes(float meanRes) noexcept { + mean_res = meanRes; +} + +bool MetricStat::operator==(const MetricStat &rhs) const noexcept { + return id == rhs.id; +} + +bool MetricStat::operator!=(const MetricStat &rhs) const noexcept { + return !(rhs == *this); +} diff --git a/server/internal/entities/src/Solution.cpp b/server/internal/entities/src/Solution.cpp index dd8a542a7bf1c09e5c7ff7b081dd1a50bb991f22..ca5fa0dd17d71487aec0c17a846d6bd5a24a9001 100644 --- a/server/internal/entities/src/Solution.cpp +++ b/server/internal/entities/src/Solution.cpp @@ -1,73 +1,108 @@ #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 { +#include "Solution.hpp" + +Solution::Solution(size_t id, std::string sendDate, size_t senderId, + std::string source, size_t taskId, std::string result, + std::string tokens, std::string astTree, + size_t orig_solution) noexcept: + 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)), orig_solution(orig_solution) {} + +Solution::Solution(std::string sendDate, size_t senderId, + std::string source, size_t taskId, std::string result, + std::string tokens, std::string astTree, + size_t orig_solution) noexcept: + id(0), 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)), orig_solution(orig_solution) {} + + +size_t Solution::getId() const noexcept { return id; } +void Solution::setId(size_t id_) noexcept { + id = id_; +} -const std::string &Solution::getSendDate() const { +const std::string &Solution::getSendDate() const noexcept { return send_date; } -void Solution::setSendDate(const std::string &sendDate) { +void Solution::setSendDate(const std::string &sendDate) noexcept { send_date = sendDate; } -size_t Solution::getSenderId() const { +size_t Solution::getSenderId() const noexcept { return sender_id; } -void Solution::setSenderId(size_t senderId) { +void Solution::setSenderId(size_t senderId) noexcept { sender_id = senderId; } -const std::string &Solution::getSource() const { +const std::string &Solution::getSource() const noexcept { return source; } -void Solution::setSource(const std::string &source_) { +void Solution::setSource(const std::string &source_) noexcept { Solution::source = source_; } -const std::string &Solution::getTokens() const { +const std::string &Solution::getTokens() const noexcept { return tokens; } -void Solution::setTokens(const std::string &tokens_) { +void Solution::setTokens(const std::string &tokens_) noexcept { Solution::tokens = tokens_; } -const std::string &Solution::getAstTree() const { +const std::string &Solution::getAstTree() const noexcept { return astTree; } -void Solution::setAstTree(const std::string &astTree_) { +void Solution::setAstTree(const std::string &astTree_) noexcept { Solution::astTree = astTree_; } -size_t Solution::getTaskId() const { +size_t Solution::getTaskId() const noexcept { return task_id; } -void Solution::setTaskId(size_t taskId) { +void Solution::setTaskId(size_t taskId) noexcept { task_id = taskId; } -const std::string &Solution::getResult() const { +const std::string &Solution::getResult() const noexcept { return result; } -void Solution::setResult(const std::string &result_) { +void Solution::setResult(const std::string &result_) noexcept { Solution::result = result_; } + +bool Solution::operator==(const Solution &rhs) const noexcept { + return id == rhs.id; +} + +bool Solution::operator!=(const Solution &rhs) const noexcept { + return !(rhs == *this); +} + +size_t Solution::getOrigSolution() const { + return orig_solution; +} + +void Solution::setOrigSolution(size_t origSolution) { + orig_solution = origSolution; +} + +Solution::Solution()noexcept :id(0), sender_id(0), task_id(0){ + +} + diff --git a/server/internal/entities/src/Task.cpp b/server/internal/entities/src/Task.cpp index 99e0fe634f4a3d28f78cd11511352f6b90616680..e0fc10733fc4a2ab85888c8b2893c81bd51faded 100644 --- a/server/internal/entities/src/Task.cpp +++ b/server/internal/entities/src/Task.cpp @@ -1,21 +1,43 @@ -#pragma once - -#include "../include/Task.hpp" +#include "Task.hpp" #include -#include -unsigned long Task::getId() const { - return id; -} +Task::Task(std::string description_, float treshold_) noexcept : id(0), description(std::move(description_)), + treshhold(treshold_) {} -Task::Task(size_t id, std::string description) : id(id), description(std::move(description)) {} +Task::Task(size_t id, std::string description_, float treshold_) noexcept : id(id), description(std::move(description_)), + treshhold(treshold_) {} +Task::Task() noexcept:id(0), treshhold(0) { +} -Task::Task(std::string description) : id(0), description(std::move(description)) {} +unsigned long Task::getId() const noexcept { + return id; +} -const std::string &Task::getDescription() const { +const std::string &Task::getDescription() const noexcept { return description; } -void Task::setDescription(const std::string &description_) { +void Task::setId(size_t id_) noexcept { + id = id_; +} + +void Task::setDescription(const std::string &description_) noexcept { Task::description = description_; } + +bool Task::operator==(const Task &rhs) const noexcept { + return id == rhs.id; +} + +bool Task::operator!=(const Task &rhs) const noexcept { + return !(rhs == *this); +} + +float Task::getTreshhold() const noexcept { + return treshhold; +} + +void Task::setTreshhold(float treshhold_) noexcept { + Task::treshhold = treshhold_; +} + diff --git a/server/internal/entities/src/User.cpp b/server/internal/entities/src/User.cpp index c048f8f0b920614ef9e17cba52de56c2b614cafe..67f2620dc4a925944d4fd349532eee764af4f57b 100644 --- a/server/internal/entities/src/User.cpp +++ b/server/internal/entities/src/User.cpp @@ -1,43 +1,59 @@ #include #include "../include/User.hpp" -User::User(size_t id_, std::string login_, std::string password_, std::string username_) : +User::User(size_t id_, std::string login_, std::string password_, std::string username_) noexcept : 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_)) { + +User::User(std::string login_, std::string password_, std::string username_) noexcept : + id(0), login(std::move(login_)), password(std::move(password_)), username(std::move(username_)) { +} + +User::User() noexcept : id(0) { } -const std::string &User::getLogin() const { +const std::string &User::getLogin() const noexcept { return login; } -void User::setLogin(const std::string &login_) { +void User::setId(size_t id_) noexcept { + id = id_; +} + +void User::setLogin(const std::string &login_) noexcept { User::login = login_; } -const std::string &User::getPassword() const { +const std::string &User::getPassword() const noexcept { return password; } -void User::setPassword(const std::string &password_) { +void User::setPassword(const std::string &password_) noexcept { User::password = password_; } -const std::string &User::getUsername() const { +const std::string &User::getUsername() const noexcept { return username; } -void User::setUsername(const std::string &username_) { +void User::setUsername(const std::string &username_) noexcept { User::username = username_; } -size_t User::getId() const { +size_t User::getId() const noexcept { return id; } -std::ostream &operator<<(std::ostream &os, const User &user) { +std::ostream &operator<<(std::ostream &os, const User &user) noexcept { os << "id: " << user.id << " login: " << user.login << " password: " << user.password << " username: " << user.username; return os; } + +bool User::operator==(const User &rhs) const noexcept { + return id == rhs.id; +} + +bool User::operator!=(const User &rhs) const noexcept { + return !(rhs == *this); +} diff --git a/server/internal/entities/tests/CMakeLists.txt b/server/internal/entities/tests/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/server/internal/repository/virtual/IMetricRepository.hpp b/server/internal/repository/virtual/IMetricRepository.hpp new file mode 100644 index 0000000000000000000000000000000000000000..fcd92fe7e4acf5f413a3937bc09cdb2117c25485 --- /dev/null +++ b/server/internal/repository/virtual/IMetricRepository.hpp @@ -0,0 +1,22 @@ +#ifndef SOURCEDOUT_IMETRICREPOSITORY_HPP +#define SOURCEDOUT_IMETRICREPOSITORY_HPP + + +#include +#include +#include "MetricStat.hpp" + +class IMetricRepository { +public: + virtual std::optional getById(size_t id) = 0; + + virtual size_t storeMetric(MetricStat metric) = 0; + + virtual void updateMetric(MetricStat metric) = 0; + + virtual void deleteMetric(MetricStat metric) = 0; + + virtual void deleteMetricById(size_t id) = 0; +}; + +#endif //SOURCEDOUT_IMETRICREPOSITORY_HPP diff --git a/server/internal/repository/virtual/ISolutionRepository.hpp b/server/internal/repository/virtual/ISolutionRepository.hpp index 8a7b03532869bcbc96bad16cfd680a593ccbf884..383d04d655bab71f6785a99449c6e165483b607f 100644 --- a/server/internal/repository/virtual/ISolutionRepository.hpp +++ b/server/internal/repository/virtual/ISolutionRepository.hpp @@ -3,15 +3,16 @@ #include #include -#include "../../entities/include/Solution.hpp" +#include "Solution.hpp" +#include class ISolutionRepository { - public: +public: virtual ~ISolutionRepository() = default; - virtual Solution getSolutionById(size_t id) = 0; + + virtual std::optional 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; @@ -23,7 +24,7 @@ class ISolutionRepository { virtual void deleteSolution(Solution solution) = 0; - + virtual std::optional getOriginalSolution(size_t id) = 0; }; #endif //SOURCEDOUT_ISOLUTIONREPOSITORY_HPP diff --git a/server/internal/repository/virtual/ITaskRepository.hpp b/server/internal/repository/virtual/ITaskRepository.hpp index e367c21d528da5a084b1a2ac02410fea9a6ebc05..b26594683981f49d453845d1b355fc12b6ea2559 100644 --- a/server/internal/repository/virtual/ITaskRepository.hpp +++ b/server/internal/repository/virtual/ITaskRepository.hpp @@ -2,16 +2,22 @@ #define SOURCEDOUT_ITASKREPOSITORY_HPP #include -#include "../../entities/include/Task.hpp" +#include +#include "Task.hpp" +#include class ITaskRepository { - public: +public: virtual ~ITaskRepository() = default; - virtual Task getTaskById(size_t id) = 0; - virtual void updateTask(Task task) = 0; + virtual std::optional getTaskById(size_t id) = 0; - virtual int storeTask(Task task) = 0; + virtual std::vector getAllTasks() = 0; + + + virtual void updateTask(const Task& task) = 0; + + virtual size_t storeTask(Task task) = 0; virtual void deleteTask(Task task) = 0; diff --git a/server/internal/repository/virtual/IUserRepository.hpp b/server/internal/repository/virtual/IUserRepository.hpp index 14d7a50ee86692f3768460ce520b78a50cf82f94..feb232692c3731094c8117022b449add8e9e59f4 100644 --- a/server/internal/repository/virtual/IUserRepository.hpp +++ b/server/internal/repository/virtual/IUserRepository.hpp @@ -2,18 +2,23 @@ #define SOURCEDOUT_IUSERREPOSITORY_HPP #include -#include "../../entities/include/User.hpp" +#include "User.hpp" +#include + class IUserRepository { public: virtual ~IUserRepository() = default; - virtual User getUserById(size_t id) = 0; - virtual User getUserByLogin(std::string login) = 0; + virtual std::optional getUserById(size_t id) = 0; + + virtual std::optional getUserByLogin(std::string login) = 0; virtual size_t makeUser(User user) = 0; virtual void deleteUser(User user) = 0; + virtual void update(User user) = 0; + virtual void deleteByUserId(size_t user_id) = 0; virtual std::vector getAllUsers() = 0; diff --git a/server/internal/service/CMakeLists.txt b/server/internal/service/CMakeLists.txt index ed9f4152540ddff5b012edd200d207b7b536e530..8afbe0940477fc076f2c7399f08e601e386f5762 100644 --- a/server/internal/service/CMakeLists.txt +++ b/server/internal/service/CMakeLists.txt @@ -10,8 +10,11 @@ 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}) +message("METRICS_lib_INCLUDE_DIRS=${METRICS_lib_INCLUDE_DIRS}") +message("METRICS_LIBRARY=${METRICS_LIBRARY}") + +target_include_directories(${PROJECT_NAME} PUBLIC ${INCLUDE_DIRS} ${libEntities_INCLUDE_DIRS} ${libRepository_INCLUDE_DIRS} ${ANTLR4_LIB_INCLUDE_DIRS} ${METRICS_lib_INCLUDE_DIRS}) +target_link_libraries(${PROJECT_NAME} ${libRepository_LIB} ${libEntities_LIB} ${ANTLR4_LIB} ${METRICS_LIBRARY}) set(SERVICE_lib_LIBRARY ${PROJECT_NAME}) set(SERVICE_lib_LIBRARY ${SERVICE_lib_LIBRARY} PARENT_SCOPE) @@ -19,5 +22,5 @@ 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 +# 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 index a032c21f5db1fa1cd4376dca67e295819a91d665..b15d6328066e1b96e994abe41ee5c7f848127281 100644 --- a/server/internal/service/include/Exceptions.h +++ b/server/internal/service/include/Exceptions.h @@ -6,4 +6,21 @@ class ValidateException : public std::exception { public: ValidateException(const std::string& msg) : _msg(msg) {} virtual const char* what() const noexcept override { return _msg.c_str(); } +}; + + +class LoginException : public std::exception { + std::string _msg; + + public: + LoginException(const std::string& msg) : _msg(msg) {} + virtual const char* what() const noexcept override { return _msg.c_str(); } +}; + +class FileExtensionException : public std::exception { + std::string _msg; + + public: + FileExtensionException(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/FileMethods.h b/server/internal/service/include/FileMethods.h new file mode 100644 index 0000000000000000000000000000000000000000..0ff8df34002475ed77baf828ac437f90eaee5010 --- /dev/null +++ b/server/internal/service/include/FileMethods.h @@ -0,0 +1,14 @@ +#pragma once + +#include +#include + +inline const std::string CPP_EXTENSION = "cpp"; +inline const std::string PYTHON_EXTENSION = "py"; +inline const std::string UNKNOWN_EXTENSION = ""; + +class FileMethods { + public: + static std::pair checkFileExtension( + const std::string& filename); +}; \ No newline at end of file diff --git a/server/internal/service/include/SolutionService.h b/server/internal/service/include/SolutionService.h index 04ac2d8679eb40404e2e3eb99f060712e43db274..d59f2b2b79f10e818851e32144ed4abda11387cb 100644 --- a/server/internal/service/include/SolutionService.h +++ b/server/internal/service/include/SolutionService.h @@ -1,25 +1,42 @@ #pragma once #include +#include -#include "ISolutionRepository.hpp" -#include "ISolutionService.h" #include "IAntlrWrapper.h" #include "IMockMetrics.h" +#include "ISolutionRepository.hpp" +#include "ISolutionService.h" +#include "ITaskRepository.hpp" +#include "TextMetricsLib.h" +#include "TokenMetricLib.h" -class SolutionService : ISolutionService { +class SolutionService : public ISolutionService { private: std::unique_ptr solutionRepo; + std::unique_ptr taskRepo; std::unique_ptr antlr; - std::unique_ptr metrics; + std::unique_ptr textMetric; + std::unique_ptr tokenMetric; + void setAntlrWrapper(const std::string& fileExtension, + const std::string& filedata); + std::string setResultVerdict(float textBasedRes, float tokenBasedRes, + float treshold); + std::pair getMaxTextResMetric(std::vector& solutions, + const std::string& filedata, + float treshold); + + std::pair getMaxTokenResMetric( + std::vector& solutions, std::vector& tokens, + float treshold); + public: - explicit SolutionService(std::unique_ptr solutionRepo); - void setAntlrWrapper(std::unique_ptr antlr_); + explicit SolutionService(std::unique_ptr solutionRepo, + std::unique_ptr taskRepo); 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; + const std::string& filename, + const std::string& filedata) 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 index bf04d3e472f736a8c24bd1d753cd5ed5a3577636..d17e9d565ac88e3bbd5afe76e45d6b49f09d5d1f 100644 --- a/server/internal/service/include/TaskService.h +++ b/server/internal/service/include/TaskService.h @@ -11,8 +11,7 @@ class TaskService : public ITaskService { public: TaskService(std::unique_ptr taskRepo); - ~TaskService() override = default; - Task createTask(std::string desc) override; + Task createTask(const std::string& desc, float treshold = 0.5f) override; Task getTask(size_t id) override; std::vector getAllTasks() override; void deleteTask(size_t id) override; diff --git a/server/internal/service/include/TextMetricsLib.h b/server/internal/service/include/TextMetricsLib.h new file mode 100644 index 0000000000000000000000000000000000000000..4db863f2a574c304d8717383634e2d9629ce59c9 --- /dev/null +++ b/server/internal/service/include/TextMetricsLib.h @@ -0,0 +1,45 @@ +// +// Created by march on 02.05.2023. +// + +#ifndef SOURCEDOUT_DECLARATION_H +#define SOURCEDOUT_DECLARATION_H + +#include +#include +#include +#include +#include +#include + +class ITextMetric { + public: + virtual ~ITextMetric() = default; + virtual void setData(std::string text1, std::string text2) = 0; + virtual double getMetric() = 0; +}; + +class PrepareDataTextMetric : public ITextMetric { + public: + void setData(std::string text1, std::string text2) override; + + protected: + std::vector tokens1; + std::vector tokens2; + + private: + static std::string deleteComments(const std::string& text); + static std::vector tbmTokenizer(const std::string& text); +}; + +class LevDistTextMetric : public PrepareDataTextMetric { + public: + double getMetric() override; +}; + +class JaccardTextMetric : public PrepareDataTextMetric { + public: + double getMetric() override; +}; + +#endif // SOURCEDOUT_DECLARATION_H diff --git a/server/internal/service/include/TokenMetricLib.h b/server/internal/service/include/TokenMetricLib.h new file mode 100644 index 0000000000000000000000000000000000000000..c333fe2abbb5c5b06801d4a19d77f5757dbb21f9 --- /dev/null +++ b/server/internal/service/include/TokenMetricLib.h @@ -0,0 +1,42 @@ +// +// Created by march on 04.05.2023. +// + +#ifndef SOURCEDOUT_TOKENMETRICLIB_H +#define SOURCEDOUT_TOKENMETRICLIB_H + +#include +#include +#include +#include +#include + +#include + + +class ITokenMetric{ + public: + virtual ~ITokenMetric() = default; + virtual void setData(std::vector tokens1, std::vector tokens2) = 0; + virtual double getMetric() = 0; +}; + +class PrepareDataTokenMetric : public ITokenMetric{ +public: + void setData(std::vector _tokens1, std::vector _tokens2) override; +protected: + std::vector tokens1; + std::vector tokens2; +}; + +class LevDistTokenMetric : public PrepareDataTokenMetric{ +public: + double getMetric() override; +}; + +class WShinglingTokenMetric : public PrepareDataTokenMetric{ +public: + double getMetric() override; +}; + +#endif //SOURCEDOUT_TOKENMETRICLIB_H diff --git a/server/internal/service/include/UserService.h b/server/internal/service/include/UserService.h index 719aa02fbcc1f38035bf4cf134085fdcc11af00f..72e66fb1bffde3bd3643f151a450b8fc7305fcd5 100644 --- a/server/internal/service/include/UserService.h +++ b/server/internal/service/include/UserService.h @@ -5,15 +5,14 @@ #include "IUserService.h" #include "UserValidator.h" -class UserService : IUserService { +class UserService : public 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; + User createUser(const std::string& login, const std::string& username, + const std::string& password) override; + User login(const std::string& login, const std::string& password) override; void deleteUser(size_t id) override; }; diff --git a/server/internal/service/include/UserValidator.h b/server/internal/service/include/UserValidator.h index 002f4503d5a1aaeaef870a5034b29879bfdd2b91..34459b6e355ce0e6437fca36c283a22ce351c0f8 100644 --- a/server/internal/service/include/UserValidator.h +++ b/server/internal/service/include/UserValidator.h @@ -4,13 +4,10 @@ class UserValidator { private: - User user; - bool validateLogin(); - bool validatePassword(); - bool validateUsername(); + static bool validateLogin(const std::string& login); + static bool validatePassword(const std::string& password); + static bool validateUsername(const std::string& username); public: - explicit UserValidator(User user); - bool validateUser(); - ~UserValidator() = default; + static bool validate(const User& user); }; diff --git a/server/internal/service/include/Utils.h b/server/internal/service/include/Utils.h new file mode 100644 index 0000000000000000000000000000000000000000..20c67c83044f26f691c807f16634836ec8485756 --- /dev/null +++ b/server/internal/service/include/Utils.h @@ -0,0 +1,10 @@ +#pragma once + +#include +#include + +class Utils { + public: + static std::string convertIntArrayIntoString(std::vector& arr); + static std::vector convertStringIntoIntArray(const std::string& str); +}; diff --git a/server/internal/service/src/FileMethods.cpp b/server/internal/service/src/FileMethods.cpp new file mode 100644 index 0000000000000000000000000000000000000000..6304eea4c8d6cda398701cb6406626190c6f46c8 --- /dev/null +++ b/server/internal/service/src/FileMethods.cpp @@ -0,0 +1,15 @@ +#include "FileMethods.h" + +#include +#include + +std::pair FileMethods::checkFileExtension( + const std::string& filename) { + if (filename.substr(filename.find_last_of(".") + 1) == CPP_EXTENSION) { + return std::make_pair(CPP_EXTENSION, true); + } + if (filename.substr(filename.find_last_of(".") + 1) == PYTHON_EXTENSION) { + return std::make_pair(PYTHON_EXTENSION, true); + } + return std::make_pair(UNKNOWN_EXTENSION, false); +} \ No newline at end of file diff --git a/server/internal/service/src/SolutionService.cpp b/server/internal/service/src/SolutionService.cpp index 485f86bacbd9df24d509bdc4e3e4022438b9bd7b..2353fe6e6eec62241754e4b4040a7ac197671f5e 100644 --- a/server/internal/service/src/SolutionService.cpp +++ b/server/internal/service/src/SolutionService.cpp @@ -1,48 +1,162 @@ #include "SolutionService.h" +#include +#include +#include + +#include "FileMethods.h" +#include "MyCppAntlr.h" +#include "PythonAntlr.h" +#include "Utils.h" + +const std::string PLAGIAT_VERDICT = "Не, ну вы не палитесь. Плагиат."; +const std::string NOT_PLAGIAT_VERDICT = + "Красивое решение. А главное уникальное !"; + SolutionService::SolutionService( - std::unique_ptr solutionRepo) - : solutionRepo(std::move(solutionRepo)) {} + std::unique_ptr solutionRepo, + std::unique_ptr taskRepo) + : solutionRepo(std::move(solutionRepo)), taskRepo(std::move(taskRepo)) {} -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, ""); + +void SolutionService::setAntlrWrapper(const std::string& fileExtension, + const std::string& filedata) { + std::istringstream in(filedata); + if (fileExtension == CPP_EXTENSION) { + antlr = std::make_unique(in); + } else if (fileExtension == PYTHON_EXTENSION) { + antlr = std::make_unique(in); + } +} + +std::string SolutionService::setResultVerdict(float textBasedRes, + float tokenBasedRes, + float treshold = 0.5f) { + float meanRes = (tokenBasedRes + textBasedRes) / 2; + if (meanRes < treshold) { + return NOT_PLAGIAT_VERDICT; + } + return PLAGIAT_VERDICT; +} + +std::pair SolutionService::getMaxTextResMetric( + std::vector& solutions, const std::string& filedata, + float treshold) { + std::pair maxMatch = std::make_pair(0.0, 0); + for (auto sol : solutions) { + textMetric = std::make_unique(); + textMetric->setData(filedata, sol.getSource()); + float textBasedRes = float(textMetric->getMetric()); + + textMetric = std::make_unique(); + textMetric->setData(filedata, sol.getSource()); + textBasedRes = (textBasedRes + float(textMetric->getMetric())) / 2; + + if (maxMatch.first < textBasedRes) { + maxMatch.first = textBasedRes; + maxMatch.second = sol.getSenderId(); + } + + if (textBasedRes > treshold) { + break; + } + } + return maxMatch; +} + +std::pair SolutionService::getMaxTokenResMetric( + std::vector& solutions, std::vector& tokens, + float treshold) { + std::pair maxMatch = std::make_pair(0.0, 0ul); + for (auto sol : solutions) { + tokenMetric = std::make_unique(); + tokenMetric->setData(tokens, + Utils::convertStringIntoIntArray(sol.getTokens())); + float tokenBasedRes = float(tokenMetric->getMetric()); + + tokenMetric = std::make_unique(); + tokenMetric->setData(tokens, + Utils::convertStringIntoIntArray(sol.getTokens())); + tokenBasedRes = (tokenBasedRes + float(tokenMetric->getMetric())) / 2; + + if (maxMatch.first < tokenBasedRes) { + maxMatch.first = tokenBasedRes; + maxMatch.second = sol.getSenderId(); + } + + if (tokenBasedRes > treshold) { + break; + } + } + return maxMatch; } -std::vector SolutionService::getSolutionsByUserAndTaskId( - size_t userId, size_t taskId) { +Solution SolutionService::createSolution(size_t userId, size_t taskId, + const std::string& filename, + const std::string& filedata) { try { - return solutionRepo->getSolutions(userId, taskId); - } catch (std::exception& e) { - throw e; + std::pair fileExtension = + FileMethods::checkFileExtension(filename); + if (!fileExtension.second) { + throw FileExtensionException("unknown file extension"); + } + + setAntlrWrapper(fileExtension.first, filedata); + std::vector tokensTypes = antlr->getTokensTypes(); + std::string astTree = antlr->getTreeString(); + + std::time_t now = + std::chrono::system_clock::to_time_t(std::chrono::system_clock::now()); + + float treshold = taskRepo->getTaskById(taskId).value().getTreshhold(); + + std::vector solutions = + solutionRepo->getSolutionsByTaskId(taskId); + + std::pair textBasedRes = + getMaxTextResMetric(solutions, filedata, treshold); + std::pair tokenBasedRes = + getMaxTokenResMetric(solutions, tokensTypes, treshold); + + std::string result = + setResultVerdict(textBasedRes.first, tokenBasedRes.first, treshold); + + size_t plagiatUserId = -1; + if (result == PLAGIAT_VERDICT) { + if (textBasedRes.first > tokenBasedRes.first) { + plagiatUserId = textBasedRes.second; + } else { + plagiatUserId = tokenBasedRes.second; + } + } + + Solution sol = + Solution(std::ctime(&now), userId, filedata, taskId, + result, Utils::convertIntArrayIntoString(tokensTypes), astTree, + plagiatUserId); + size_t id = solutionRepo->storeSolution(sol); + sol.setId(id); + return sol; + } catch (...) { + throw; } } void SolutionService::deleteSolutionById(size_t solId) { try { solutionRepo->deleteSolutionById(solId); - } catch (std::exception& e) { - throw e; + } catch (...) { + throw; } } std::pair SolutionService::getMetrics(size_t solId) { try { - Solution sol = solutionRepo->getSolutionById(solId); + Solution sol = solutionRepo->getSolutionById(solId).value(); std::string tokens = sol.getTokens(); std::string astTree = sol.getAstTree(); return std::make_pair(tokens, astTree); - } catch (std::exception& e) { - throw e; + } catch (...) { + throw; } } - -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 index a3ce5ef9b3baadb7902fbdf0f2cca6f9d0229a7a..2a8b2da31fe667277ec20d3592ad0afdedb73235 100644 --- a/server/internal/service/src/TaskService.cpp +++ b/server/internal/service/src/TaskService.cpp @@ -3,13 +3,38 @@ 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); + +Task TaskService::createTask(const std::string& desc, float treshold) { + try { + Task task = Task(desc, treshold); + size_t id = taskRepo->storeTask(task); + task.setId(id); + return task; + } catch (...) { + throw; + } } -std::vector TaskService::getAllTasks() { return std::vector(); } +std::vector TaskService::getAllTasks() { + try { + return taskRepo->getAllTasks(); + } catch (...) { + throw; + } +} -Task TaskService::getTask(size_t id) { return taskRepo->getTaskById(id); } +Task TaskService::getTask(size_t id) { + try { + return taskRepo->getTaskById(id).value(); + } catch (...) { + throw; + } +} -void TaskService::deleteTask(size_t id) { taskRepo->deleteTaskById(id); } +void TaskService::deleteTask(size_t id) { + try { + taskRepo->deleteTaskById(id); + } catch (...) { + throw; + } +} diff --git a/server/internal/service/src/TextMetricImpl.cpp b/server/internal/service/src/TextMetricImpl.cpp new file mode 100644 index 0000000000000000000000000000000000000000..848c36bf6cfc1da24518fc279cb22275b9c89a26 --- /dev/null +++ b/server/internal/service/src/TextMetricImpl.cpp @@ -0,0 +1,117 @@ +// +// Created by march on 02.05.2023. +// + +#include "TextMetricsLib.h" + + +void PrepareDataTextMetric::setData(std::string text1, std::string text2) { + std::string non_comm_text1 = deleteComments(text1); + std::string non_comm_text2 = deleteComments(text2); + + tokens1 = tbmTokenizer(non_comm_text1); + tokens2 = tbmTokenizer(non_comm_text2); +} + +std::string PrepareDataTextMetric::deleteComments(const std::string& text) { + std::string modif; + std::string res; + + std::stringstream ss; + std::string line; + + ss << text; + + while(getline(ss, line)){ + line.push_back('\0'); + modif += line; + } + + bool s_comm = false; + bool m_comm = false; + + for (size_t i = 0; i < modif.size(); i++){ + if (s_comm && modif[i] == '\0') + s_comm = false; + else if (m_comm && modif[i] == '*' && modif[i + 1] == '/') + m_comm = false, i++; + else if (s_comm || m_comm) + continue; + else if (modif[i] == '/' && modif[i+1] == '/') + s_comm = true, i++; + else if (modif[i] == '/' && modif[i+1] == '*') + m_comm = true, i++; + + else if (modif[i] != '\0') + res += modif[i]; + else if (!res.empty() && res[res.size() - 1] != '\n') + res += '\n'; + } + return res; +} + +std::vector PrepareDataTextMetric::tbmTokenizer(const std::string &text) { + boost::char_separator sep(" {}();,\"\0\'"); + std::vector res; + boost::tokenizer < boost::char_separator > tokens(text, sep); + + for (const std::string &s: tokens) { + if (!s.empty() && s[0] != '\n' && s[0] != '\0'){ + res.push_back(s); + } + } + return res; +} + +double LevDistTextMetric::getMetric(){ + unsigned long n = tokens1.size(); + unsigned long m = tokens2.size(); + int x, y, z; + + std::vector > lev (n, std::vector (m, 0)); + + for (size_t i = 0; i < n; i++){ + for (size_t j = 0; j < m; j++){ + if (std::min(i, j) == 0){ + lev[i][j] = static_cast (std::max(i, j)); + } + else{ + x = lev[i-1][j]; + y = lev[i][j-1]; + z = lev[i-1][j-1]; + lev[i][j] = std::min(x, std::min(y, z)); + if (tokens1[i] != tokens2[j]){ + lev[i][j]++; + } + } + } + } + + if (n == 0 || m == 0) + return 0; + double res = 1.0 - static_cast (lev[n-1][m-1]) / static_cast (std::max(n ,m)); + return res; +} + + +double JaccardTextMetric::getMetric() { + std::set s1; + std::set s2; + + for (auto &i : tokens1) s1.insert(i); + for (auto &i : tokens2) s2.insert(i); + + + std::set intersect_sets; + set_intersection(s1.begin(), s1.end(), s2.begin(), s2.end(), + std::inserter(intersect_sets, intersect_sets.begin())); + + std::set union_sets; + set_union(s1.begin(), s1.end(), s2.begin(), s2.end(), + std::inserter(union_sets, union_sets.begin())); + + if (union_sets.empty()) + return 0; + else + return static_cast (intersect_sets.size()) / static_cast (union_sets.size()); +} diff --git a/server/internal/service/src/TokenMetricImpl.cpp b/server/internal/service/src/TokenMetricImpl.cpp new file mode 100644 index 0000000000000000000000000000000000000000..70cba714e4d75cdaad0dc1fb56bcad7e83e2ce7f --- /dev/null +++ b/server/internal/service/src/TokenMetricImpl.cpp @@ -0,0 +1,79 @@ +// +// Created by march on 04.05.2023. +// + +#include "TokenMetricLib.h" + +double LevDistTokenMetric::getMetric() { + unsigned long n = tokens1.size(); + unsigned long m = tokens2.size(); + int x, y, z; + + std::vector > lev (n, std::vector (m, 0)); + + for (size_t i = 0; i < n; i++){ + for (size_t j = 0; j < m; j++){ + if (std::min(i, j) == 0){ + lev[i][j] = static_cast (std::max(i, j)); + } + else{ + x = lev[i-1][j]; + y = lev[i][j-1]; + z = lev[i-1][j-1]; + lev[i][j] = std::min(x, std::min(y, z)); + if (tokens1[i] != tokens2[j]){ + lev[i][j]++; + } + } + } + } + + if (n == 0 || m == 0) + return 0; + double res = 1.0 - static_cast (lev[n-1][m-1]) / static_cast (std::max(n ,m)); + return res; +} + +double WShinglingTokenMetric::getMetric() { + unsigned long n = tokens1.size(); + unsigned long m = tokens2.size(); + + if (n == 0 || m == 0 || (n < 3 && m < 3)) + return 0; + + std::vector > sh1; + std::vector > sh2; + + for (size_t i = 0; i < n - 3; i++){ + sh1.emplace_back(tokens1[i], tokens1[i+1], tokens1[i+2]); + } + for (size_t i = 0; i < m - 3; i++){ + sh2.emplace_back(tokens2[i], tokens2[i+1], tokens2[i+2]); + } + + std::set > s1; + std::set > s2; + + for (auto &i : sh1) s1.insert(i); + for (auto &i : sh2) s2.insert(i); + + + std::set> intersect_sets; + set_intersection(s1.begin(), s1.end(), s2.begin(), s2.end(), + std::inserter(intersect_sets, intersect_sets.begin())); + + std::set> union_sets; + set_union(s1.begin(), s1.end(), s2.begin(), s2.end(), + std::inserter(union_sets, union_sets.begin())); + + if (union_sets.empty()) + return 0; + else + return static_cast (intersect_sets.size()) / static_cast (union_sets.size()); + +} + +void PrepareDataTokenMetric::setData(std::vector _tokens1, std::vector _tokens2) { + tokens1 = _tokens1; + tokens2 = _tokens2; +} diff --git a/server/internal/service/src/UserService.cpp b/server/internal/service/src/UserService.cpp index b44ecf333aaab2c52a757505646371a8bfd83f48..367e812908b51ac45514cb05a798f0095a333b97 100644 --- a/server/internal/service/src/UserService.cpp +++ b/server/internal/service/src/UserService.cpp @@ -1,19 +1,44 @@ #include "UserService.h" #include "Exceptions.h" +#include "UserValidator.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"); + +User UserService::createUser(const std::string& login, const std::string& username, + const std::string& password) { + User user = User(login, password, username); + if (!UserValidator::validate(user)) { + throw ValidateException("invalid user params"); + } + try { + size_t id = userRepo->makeUser(user); + user.setId(id); + return user; + } catch (...) { + throw; } - 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); } +User UserService::login(const std::string& login, const std::string& password) { + try { + User u = userRepo->getUserByLogin(login).value(); + if (u.getPassword() != password){ + throw LoginException("incorrect password"); + } + return u; + } catch (...) { + throw; + } +} -void UserService::deleteUser(size_t id) { userRepo->deleteByUserId(id); } + +void UserService::deleteUser(size_t id) { + try { + userRepo->deleteByUserId(id); + } catch (...) { + throw; + } +} diff --git a/server/internal/service/src/UserValidator.cpp b/server/internal/service/src/UserValidator.cpp index 66666414ca86a6efd9e4e4e7ca113b9b38e9a5f4..b653fc9af4a504efb2ffe17e7080adc8496a6f95 100644 --- a/server/internal/service/src/UserValidator.cpp +++ b/server/internal/service/src/UserValidator.cpp @@ -1,34 +1,32 @@ #include "UserValidator.h" #include +#include -UserValidator::UserValidator(User user) : user(user) {} - -bool UserValidator::validateUser() { - if (validateLogin() && validatePassword() && validateUsername()) { +bool UserValidator::validate(const User& user) { + if (validateLogin(user.getLogin()) && validatePassword(user.getPassword()) && + validateUsername(user.getUsername())) { return true; } return false; } -bool UserValidator::validateLogin() { - std::string login = user.getLogin(); +bool UserValidator::validateLogin(const std::string& login) { if (login.length() < 3 || login.length() > 30) { return false; } - return true; + const std::regex pattern("(\\w+)@(\\w+)(\\.(\\w+))+"); + return std::regex_match(login, pattern); } -bool UserValidator::validatePassword() { - std::string password = user.getPassword(); +bool UserValidator::validatePassword(const std::string& password) { if (password.length() < 8 || password.length() > 30) { return false; } return true; } -bool UserValidator::validateUsername() { - std::string username = user.getUsername(); +bool UserValidator::validateUsername(const std::string& username) { if (username.length() < 3 || username.length() > 20) { return false; } diff --git a/server/internal/service/src/Utils.cpp b/server/internal/service/src/Utils.cpp new file mode 100644 index 0000000000000000000000000000000000000000..005748f89f67e8ae423ac8019fe7d1d812415dc5 --- /dev/null +++ b/server/internal/service/src/Utils.cpp @@ -0,0 +1,23 @@ +#include "Utils.h" + +#include +#include +#include +#include +#include + +std::string Utils::convertIntArrayIntoString(std::vector& arr) { + std::string str; + for (size_t i = 0; i < arr.size(); i++) { + str += std::to_string(arr[i]) + " "; + } + return str; +} + +std::vector Utils::convertStringIntoIntArray(const std::string& str) { + std::stringstream ss(str); + std::vector v; + + std::copy(std::istream_iterator(ss), {}, back_inserter(v)); + return v; +} diff --git a/server/internal/service/tests/CMakeLists.txt b/server/internal/service/tests/CMakeLists.txt index 5dc8740fa010b643d39406582be5b37b0e1a5c09..e1cdd490497116ec9ddc9f2113f39c6eda4e012e 100644 --- a/server/internal/service/tests/CMakeLists.txt +++ b/server/internal/service/tests/CMakeLists.txt @@ -1,8 +1,5 @@ project(test_service) -set(CMAKE_CXX_STANDARD 20) -add_compile_options(-coverage) - file(GLOB SOURCES *.cpp) enable_testing() diff --git a/server/internal/service/tests/SolutionServiceTest.cpp b/server/internal/service/tests/SolutionServiceTest.cpp index 2dcb91ffdb91f2fc6741c0f6bdca1fecd037c03f..d4b347922f9ac53626e868ea3bfa8702d385fc7d 100644 --- a/server/internal/service/tests/SolutionServiceTest.cpp +++ b/server/internal/service/tests/SolutionServiceTest.cpp @@ -11,32 +11,45 @@ class Exception : public std::exception { 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::optional, 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)); + MOCK_METHOD(std::optional, getOriginalSolution, (size_t id), + (override)); +}; + +class TaskRepositoryMock : public ITaskRepository { + public: + ~TaskRepositoryMock() override = default; + MOCK_METHOD(std::optional, getTaskById, (size_t id), (override)); + MOCK_METHOD(void, updateTask, (const Task& task), (override)); + MOCK_METHOD(size_t, storeTask, (Task task), (override)); + MOCK_METHOD(void, deleteTask, (Task task), (override)); + MOCK_METHOD(void, deleteTaskById, (size_t id), (override)); + MOCK_METHOD(std::vector, getAllTasks, (), (override)); }; struct SolutionServiceTest : public testing::Test { SolutionService* ss; - SolutionRepositoryMock* mock_ptr; + SolutionRepositoryMock* solutionMockPtr; + TaskRepositoryMock* taskMockPtr; void SetUp() { - auto mock = std::make_unique(); - mock_ptr = mock.get(); - ss = new SolutionService(std::move(mock)); + auto sMock = std::make_unique(); + solutionMockPtr = sMock.get(); + auto tMock = std::make_unique(); + taskMockPtr = tMock.get(); + ss = new SolutionService(std::move(sMock), std::move(tMock)); } void TearDown() { delete ss; } }; @@ -45,52 +58,55 @@ 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); + EXPECT_CALL(*solutionMockPtr, deleteSolutionById(1)).Times(1); ss->deleteSolutionById(1); } TEST_F(SolutionServiceTest, deleteSolutionException) { - EXPECT_CALL(*mock_ptr, deleteSolutionById(-1)) + EXPECT_CALL(*solutionMockPtr, deleteSolutionById(-1)) .Times(1) .WillRepeatedly(NoSolutionException()); EXPECT_THROW(ss->deleteSolutionById(-1), std::exception); } TEST_F(SolutionServiceTest, getMetrics) { - EXPECT_CALL(*mock_ptr, getSolutionById(1)) + EXPECT_CALL(*solutionMockPtr, getSolutionById(1)) .Times(1) .WillOnce(::testing::Return( - Solution(1, "", 1, "", "tokens", "astTree", 1, ""))); + Solution(1, "", 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)) + EXPECT_CALL(*solutionMockPtr, 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, ""))) + EXPECT_CALL(*solutionMockPtr, + storeSolution(Solution(0, "", 2, "source", 1, "", "", "", 1))) .Times(1) .WillRepeatedly(::testing::Return(1)); - Solution sol = ss->createSolution(2, 1, "source"); + + std::vector solutions; + solutions.push_back(Solution(0, "", 1, "int main(){return 0;}", 1, "", + "45 132 85 86 89 59 1 128 90 -1", "", -1)); + EXPECT_CALL(*solutionMockPtr, getSolutionsByTaskId(1)) + .Times(1) + .WillOnce(::testing::Return(solutions)); + + EXPECT_CALL(*taskMockPtr, getTaskById(1)) + .Times(1) + .WillOnce(::testing::Return(Task(1, "desription", 0.5f))); + + Solution sol = ss->createSolution(2, 1, "main.cpp", "int main(){return 0;}"); EXPECT_EQ(sol.getId(), 1); - EXPECT_EQ(sol.getSource(), "source"); + EXPECT_EQ(sol.getSource(), "int main(){return 0;}"); + EXPECT_EQ(sol.getTokens(), "45 132 85 86 89 59 1 128 90 -1 "); + EXPECT_EQ(sol.getResult(), "Не, ну вы не палитесь. Плагиат."); } \ No newline at end of file diff --git a/server/internal/service/tests/TaskServiceTest.cpp b/server/internal/service/tests/TaskServiceTest.cpp index 5a450d201f578fa2c5f58817c42ebcd6165438ca..3e81339258d007a34a0b8a955e5402c77a5b696c 100644 --- a/server/internal/service/tests/TaskServiceTest.cpp +++ b/server/internal/service/tests/TaskServiceTest.cpp @@ -3,7 +3,6 @@ #include "TaskService.h" -bool operator==(Task t1, Task t2) { return t1.getId() == t2.getId(); } class Exception : public std::exception { std::string _msg; @@ -16,11 +15,12 @@ class Exception : public std::exception { 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(std::optional, getTaskById, (size_t id), (override)); + MOCK_METHOD(void, updateTask, (const Task& task), (override)); + MOCK_METHOD(size_t, storeTask, (Task task), (override)); MOCK_METHOD(void, deleteTask, (Task task), (override)); MOCK_METHOD(void, deleteTaskById, (size_t id), (override)); + MOCK_METHOD(std::vector, getAllTasks,(),(override)); }; struct TaskServiceTest : public testing::Test { @@ -46,13 +46,13 @@ TEST_F(TaskServiceTest, deleteTasWithInvalidId) { EXPECT_CALL(*mock_ptr, deleteTaskById(1)) .Times(1) .WillRepeatedly(NoTaskException()); - EXPECT_THROW(ts->deleteTask(1), Exception); + EXPECT_THROW(ts->deleteTask(1), std::exception); } TEST_F(TaskServiceTest, GetTaskByIdOK) { EXPECT_CALL(*mock_ptr, getTaskById(1)) .Times(1) - .WillOnce(::testing::Return(Task(1, "desription"))); + .WillOnce(::testing::Return(Task(1, "desription",0.7f))); Task t = ts->getTask(1); EXPECT_EQ(t.getId(), 1); EXPECT_EQ(t.getDescription(), "desription"); @@ -62,21 +62,21 @@ TEST_F(TaskServiceTest, GetTaskByIdEXEPTION) { EXPECT_CALL(*mock_ptr, getTaskById(-1)) .Times(1) .WillRepeatedly(NoTaskException()); - EXPECT_THROW(ts->getTask(-1), Exception); + EXPECT_THROW(ts->getTask(-1), std::exception); } TEST_F(TaskServiceTest, CreateTask) { - EXPECT_CALL(*mock_ptr, storeTask(Task("desc"))) + EXPECT_CALL(*mock_ptr, storeTask(Task("desc",0.5f))) .Times(1) .WillOnce(::testing::Return(1)); - Task t = ts->createTask("desc"); + Task t = ts->createTask("desc",0.5f); EXPECT_EQ(t.getId(), 1); EXPECT_EQ(t.getDescription(), "desc"); - EXPECT_CALL(*mock_ptr, storeTask(Task("desc2"))) + EXPECT_CALL(*mock_ptr, storeTask(Task("desc2",0.8f))) .Times(1) .WillOnce(::testing::Return(2)); - t = ts->createTask("desc2"); + t = ts->createTask("desc2",0.8f); 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 index a7423515f22b208ac3cbbf11a1947010b8d66fd2..86d76de42ca18c031b51539cf4f57912428d3950 100644 --- a/server/internal/service/tests/UserServiceTest.cpp +++ b/server/internal/service/tests/UserServiceTest.cpp @@ -4,7 +4,6 @@ #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; @@ -17,12 +16,13 @@ class Exception : public std::exception { 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(std::optional, getUserById, (size_t id), (override)); + MOCK_METHOD(std::optional, 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)); + MOCK_METHOD(void, update, (User user),(override)); }; struct UserServiceTest : public testing::Test { @@ -48,31 +48,38 @@ TEST_F(UserServiceTest, deleteUserWithInvalidId) { EXPECT_CALL(*mock_ptr, deleteByUserId(1)) .Times(1) .WillRepeatedly(NoUserException()); - EXPECT_THROW(us->deleteUser(1), Exception); + EXPECT_THROW(us->deleteUser(1), std::exception); } -TEST_F(UserServiceTest, getUserOk) { - EXPECT_CALL(*mock_ptr, getUserById(1)) +TEST_F(UserServiceTest, loginOk) { + EXPECT_CALL(*mock_ptr, getUserByLogin("login")) .Times(1) .WillOnce(::testing::Return(User(1, "login", "password", "username"))); - User u = us->getUserById(1); + User u = us->login("login","password"); 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, loginInvalidLogin) { + EXPECT_CALL(*mock_ptr, getUserByLogin("loginnn")).Times(1).WillOnce(NoUserException()); + EXPECT_THROW(us->login("loginnn","password"), std::exception); +} + +TEST_F(UserServiceTest, loginInvalidPass) { + EXPECT_CALL(*mock_ptr, getUserByLogin("login")) + .Times(1) + .WillOnce(::testing::Return(User(1, "login", "password", "username"))); + EXPECT_THROW(us->login("login","password1"), std::exception); } TEST_F(UserServiceTest, makeUserOk) { - EXPECT_CALL(*mock_ptr, makeUser(User("login", "password", "username"))) + EXPECT_CALL(*mock_ptr, makeUser(User("login@gmail.com", "password", "username"))) .Times(1) .WillOnce(::testing::Return(1)); - User u = us->createUser("login", "username", "password"); - EXPECT_EQ(u.getLogin(), "login"); + User u = us->createUser("login@gmail.com", "username", "password"); + EXPECT_EQ(u.getLogin(), "login@gmail.com"); EXPECT_EQ(u.getId(), 1); EXPECT_EQ(u.getPassword(), "password"); EXPECT_EQ(u.getUsername(), "username"); diff --git a/server/internal/service/tests/UserValidatorTest.cpp b/server/internal/service/tests/UserValidatorTest.cpp index 802b2f03b5eb3368a223abbb1a4269a30c555a55..0a77c9c14ced248b4d2c686b7f0559e7e3577b91 100644 --- a/server/internal/service/tests/UserValidatorTest.cpp +++ b/server/internal/service/tests/UserValidatorTest.cpp @@ -4,26 +4,21 @@ #include "UserValidator.h" TEST(UserValidatorTest, validateOK) { - UserValidator uv(User("login", "password", "username")); - EXPECT_TRUE(uv.validateUser()); + EXPECT_TRUE(UserValidator::validate(User("login@gmail.com", "password", "username"))); } TEST(UserValidatorTest, invalidLogin) { - UserValidator uv(User("", "password", "username")); - EXPECT_FALSE(uv.validateUser()); + EXPECT_FALSE(UserValidator::validate(User("", "password", "username"))); } TEST(UserValidatorTest, invalidPassword) { - UserValidator uv(User("login", "", "username")); - EXPECT_FALSE(uv.validateUser()); + EXPECT_FALSE(UserValidator::validate(User("login", "", "username"))); } TEST(UserValidatorTest, invalidUsername) { - UserValidator uv(User("login", "password", "")); - EXPECT_FALSE(uv.validateUser()); + EXPECT_FALSE(UserValidator::validate(User("login", "password", ""))); } TEST(UserValidatorTest, invalidUserFields) { - UserValidator uv(User("", "", "")); - EXPECT_FALSE(uv.validateUser()); + EXPECT_FALSE(UserValidator::validate(User("", "", ""))); } \ No newline at end of file diff --git a/server/internal/service/virtual/ISolutionService.h b/server/internal/service/virtual/ISolutionService.h index a9ec5483b64e2d9737b725ee17b6dc4afad3c078..4764c82cc9aa800efd903107ced0cf04c50692dc 100644 --- a/server/internal/service/virtual/ISolutionService.h +++ b/server/internal/service/virtual/ISolutionService.h @@ -9,9 +9,8 @@ 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; + const std::string& filename, + const std::string& filedata) = 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 index 731fb0f99bb7056d3d87ced20038cfb26cbd27f5..41501245fea6c102a6457e9377d591b065797957 100644 --- a/server/internal/service/virtual/ITaskService.h +++ b/server/internal/service/virtual/ITaskService.h @@ -6,7 +6,7 @@ class ITaskService { public: virtual ~ITaskService() = default; - virtual Task createTask(std::string desc) = 0; + virtual Task createTask(const std::string& desc,float treshold) = 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 index 06d79720920e538ce1a8bfa24079953cc04b05e7..b3a0ab5d6a34923b0527f16aacbbf822b23c4b7a 100644 --- a/server/internal/service/virtual/IUserService.h +++ b/server/internal/service/virtual/IUserService.h @@ -7,8 +7,8 @@ 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 User createUser(const std::string& login, const std::string& username, + const std::string& password) = 0; + virtual User login(const std::string& login, const std::string& password) = 0; virtual void deleteUser(size_t id) = 0; }; diff --git a/server/pkg/antlr/CMakeLists.txt b/server/pkg/antlr/CMakeLists.txt index c80b45532b951915d3e8643a900566053218b486..bcf317f298d02f11325809a319e4148d6e55d2a2 100644 --- a/server/pkg/antlr/CMakeLists.txt +++ b/server/pkg/antlr/CMakeLists.txt @@ -14,10 +14,13 @@ set(ANTLR_EXECUTABLE /usr/local/lib/antlr-4.12.0-complete.jar) find_package(ANTLR REQUIRED) add_subdirectory(cpp14) -# add_subdirectory(python3) +add_subdirectory(python3) -set(ANTLR4_LIB ${CPP_ANTLR_LIBRARY}) +message("CPP_ANTLR_LIBRARY=${CPP_ANTLR_LIBRARY}") +message("PYTHON3_ANTLR_LIBRARY=${PYTHON3_ANTLR_LIBRARY}") + +set(ANTLR4_LIB ${CPP_ANTLR_LIBRARY} ${PYTHON3_ANTLR_LIBRARY}) set(ANTLR4_LIB ${ANTLR4_LIB} PARENT_SCOPE) -set(ANTLR4_LIB_INCLUDE_DIRS ${CPP_ANTLR_INCLUDE_DIRS}) +set(ANTLR4_LIB_INCLUDE_DIRS ${CPP_ANTLR_INCLUDE_DIRS} ${PYTHON3_ANTLR_INCLUDE_DIRS}) set(ANTLR4_LIB_INCLUDE_DIRS ${ANTLR4_LIB_INCLUDE_DIRS} PARENT_SCOPE) diff --git a/server/pkg/antlr/cpp14/CMakeLists.txt b/server/pkg/antlr/cpp14/CMakeLists.txt index c8834799ef847c8dac739f2eb577f51ddb92c70e..5c3100fcaf43d34bc7ecb64894a5f0dc735585b5 100644 --- a/server/pkg/antlr/cpp14/CMakeLists.txt +++ b/server/pkg/antlr/cpp14/CMakeLists.txt @@ -5,8 +5,21 @@ file(GLOB SOURCES ./src/*.cpp) file(GLOB INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/include ${CMAKE_CURRENT_SOURCE_DIR}/../virtual) +antlr_target(CPP14GrammarLexer CPP14Lexer.g4 LEXER + PACKAGE antlrcpptest) +antlr_target(CPP14GrammarParser CPP14Parser.g4 PARSER + PACKAGE antlrcpptest + DEPENDS_ANTLR CPP14GrammarLexer + COMPILE_FLAGS -lib ${ANTLR_CPP14GrammarLexer_OUTPUT_DIR}) + +include_directories(${ANTLR_CPP14GrammarLexer_OUTPUT_DIR}) +include_directories(${ANTLR_CPP14GrammarParser_OUTPUT_DIR}) + + +message("ANTLR_CPP14GrammarParser_OUTPUT_DIR=${ANTLR_CPP14GrammarParser_OUTPUT_DIR}") + include_directories(${INCLUDE_DIRS}) -add_library(${PROJECT_NAME} ${SOURCES}) +add_library(${PROJECT_NAME} ${SOURCES} ${ANTLR_CPP14GrammarLexer_CXX_OUTPUTS} ${ANTLR_CPP14GrammarParser_CXX_OUTPUTS}) target_link_libraries(${PROJECT_NAME} antlr4_static Threads::Threads) @@ -14,7 +27,7 @@ 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 ${INCLUDE_DIRS} ${ANTLR_CPP14GrammarLexer_OUTPUT_DIR} ${ANTLR_CPP14GrammarParser_OUTPUT_DIR}) 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/CPP14Parser.g4 b/server/pkg/antlr/cpp14/CPP14Parser.g4 index 6c4d84854407b31a5f2a8aebf556da49e3c134fc..19c9aa5518ab77db29e555d76f7d910f4b87fc74 100644 --- a/server/pkg/antlr/cpp14/CPP14Parser.g4 +++ b/server/pkg/antlr/cpp14/CPP14Parser.g4 @@ -643,7 +643,7 @@ virtualSpecifier: Override | Final; */ pureSpecifier: - Assign val = OctalLiteral {if($val.text.compareTo("0")!=0) throw new InputMismatchException(this); + Assign val = OctalLiteral {if($val.text.compare("0")!=0) throw new InputMismatchException(this); }; /*Derived classes*/ diff --git a/server/pkg/antlr/cpp14/include/CPP14Lexer.h b/server/pkg/antlr/cpp14/include/CPP14Lexer.h deleted file mode 100644 index d8f3103ba98396708a075e58e54f8f11d4afc85a..0000000000000000000000000000000000000000 --- a/server/pkg/antlr/cpp14/include/CPP14Lexer.h +++ /dev/null @@ -1,79 +0,0 @@ - -// 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 deleted file mode 100644 index 6b00d6b12169d605d9930740d31ec958471819c0..0000000000000000000000000000000000000000 --- a/server/pkg/antlr/cpp14/include/CPP14Parser.h +++ /dev/null @@ -1,3149 +0,0 @@ - -// 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 index 561ba34a7c0ebb9c5b644cc430f3d593524103be..90c60969aa4e97a3087773182fa169866d5d4403 100644 --- a/server/pkg/antlr/cpp14/include/MyCppAntlr.h +++ b/server/pkg/antlr/cpp14/include/MyCppAntlr.h @@ -7,9 +7,8 @@ #include "CPP14Lexer.h" #include "CPP14Parser.h" #include "IAntlrWrapper.h" -#include "antlr4-runtime.h" -class MyCppAntlr:IAntlrWrapper { +class MyCppAntlr:public IAntlrWrapper { private: std::unique_ptr lexer_ptr; std::unique_ptr parser_ptr; @@ -17,15 +16,11 @@ class MyCppAntlr:IAntlrWrapper { 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(); + MyCppAntlr(std::istream &in); + ~MyCppAntlr() override = default; + std::vector getTokens() override; + std::vector getTokensTypes() override; + std::pair getTokensAndTree() override; + std::string getTokensString() override; std::string getTreeString() override; }; diff --git a/server/pkg/antlr/cpp14/src/CPP14Lexer.cpp b/server/pkg/antlr/cpp14/src/CPP14Lexer.cpp deleted file mode 100644 index f2c86238722eedf1e32c01f8bafff787f61fdd95..0000000000000000000000000000000000000000 --- a/server/pkg/antlr/cpp14/src/CPP14Lexer.cpp +++ /dev/null @@ -1,718 +0,0 @@ - -// 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 deleted file mode 100644 index 87c20605a7aabd75bdac2c9c16dd4aaa8cfc0504..0000000000000000000000000000000000000000 --- a/server/pkg/antlr/cpp14/src/CPP14Parser.cpp +++ /dev/null @@ -1,18169 +0,0 @@ - -// 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 index bf777e3255adc3fb04138676affb9fd5873e309a..a6dcf1c7a02e4daf7f290949b82000bbbcd5f2e3 100644 --- a/server/pkg/antlr/cpp14/src/MyCppAntlr.cpp +++ b/server/pkg/antlr/cpp14/src/MyCppAntlr.cpp @@ -2,40 +2,57 @@ #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); +MyCppAntlr::MyCppAntlr(std::istream& in) { + input_ptr = std::make_unique(in); + lexer_ptr = std::make_unique(&(*input_ptr)); + tokenStream_ptr = std::make_unique(&(*lexer_ptr)); + parser_ptr = std::make_unique(&(*tokenStream_ptr)); } -std::vector MyCppAntlr::getTokens() { +std::vector MyCppAntlr::getTokens() { tokenStream_ptr->fill(); - std::vector ans(tokenStream_ptr->size()); + std::vector ans(tokenStream_ptr->size()); int i = 0; for (antlr4::Token* token : tokenStream_ptr->getTokens()) { - ans[i] = token->toString(); + ans[i] = token; i++; } return ans; } +std::vector MyCppAntlr::getTokensTypes() { + tokenStream_ptr->fill(); + std::vector ans(tokenStream_ptr->size()); + + int i = 0; + for (antlr4::Token *token : tokenStream_ptr->getTokens()) { + ans[i] = token->getType(); + i++; + } + + return ans; +} + +std::string MyCppAntlr::getTokensString() { + tokenStream_ptr->fill(); + std::string res; + + for (antlr4::Token* token : tokenStream_ptr->getTokens()) { + res += token->toString() + " "; + } + + return res; +} + std::string MyCppAntlr::getTreeString() { auto tree = parser_ptr->translationUnit(); return tree->toStringTree(&(*parser_ptr)); +} + +std::pair MyCppAntlr::getTokensAndTree() { + std::string tokens = getTokensString(); + std::string astTree = getTreeString(); + return std::make_pair(tokens, astTree); } \ No newline at end of file diff --git a/server/pkg/antlr/python3/CMakeLists.txt b/server/pkg/antlr/python3/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..e60ee233e7e1ee5c03da8d013259029e9ce25528 --- /dev/null +++ b/server/pkg/antlr/python3/CMakeLists.txt @@ -0,0 +1,28 @@ +cmake_minimum_required(VERSION 3.7) +project(python_antlr_lib) + +file(GLOB SOURCES ./src/*.cpp) +file(GLOB INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/include ${CMAKE_CURRENT_SOURCE_DIR}/../virtual) + + +antlr_target(Python3Grammar Python3.g4 + PACKAGE antlrcpptest) + +include_directories(${ANTLR_Python3Grammar_OUTPUT_DIR}) + + +message("ANTLR_Python3Grammar_OUTPUT_DIR=${ANTLR_Python3Grammar_OUTPUT_DIR}") + +include_directories(${INCLUDE_DIRS}) +add_library(${PROJECT_NAME} ${SOURCES} ${ANTLR_Python3Grammar_CXX_OUTPUTS}) + + +target_link_libraries(${PROJECT_NAME} antlr4_static Threads::Threads) + +set(PYTHON3_ANTLR_LIBRARY ${PROJECT_NAME}) +set(PYTHON3_ANTLR_LIBRARY ${PYTHON3_ANTLR_LIBRARY} PARENT_SCOPE) + +set(PYTHON3_ANTLR_INCLUDE_DIRS ${INCLUDE_DIRS} ${ANTLR_Python3Grammar_OUTPUT_DIR}) +set(PYTHON3_ANTLR_INCLUDE_DIRS ${PYTHON3_ANTLR_INCLUDE_DIRS} PARENT_SCOPE) + +message("PYTHON3_ANTLR = ${PYTHON3_ANTLR_INCLUDE_DIRS} ") \ No newline at end of file diff --git a/server/pkg/antlr/python3/include/PythonAntlr.h b/server/pkg/antlr/python3/include/PythonAntlr.h new file mode 100644 index 0000000000000000000000000000000000000000..16fe1b4d7e6c53b6c0b4fc316413695536f08714 --- /dev/null +++ b/server/pkg/antlr/python3/include/PythonAntlr.h @@ -0,0 +1,27 @@ +#pragma once + +#include +#include +#include + +#include "Python3Lexer.h" +#include "Python3Parser.h" +#include "IAntlrWrapper.h" +#include "antlr4-runtime.h" + +class PythonAntlr:public IAntlrWrapper { + private: + std::unique_ptr lexer_ptr; + std::unique_ptr parser_ptr; + std::unique_ptr input_ptr; + std::unique_ptr tokenStream_ptr; + + public: + PythonAntlr(std::istream &in); + ~PythonAntlr() override = default; + std::vector getTokens() override; + std::vector getTokensTypes() override; + std::pair getTokensAndTree() override; + std::string getTokensString() override; + std::string getTreeString() override; +}; \ No newline at end of file diff --git a/server/pkg/antlr/python3/src/PythonAntlr.cpp b/server/pkg/antlr/python3/src/PythonAntlr.cpp new file mode 100644 index 0000000000000000000000000000000000000000..eae822d1afe99563a6550f3d0a410aba788363fe --- /dev/null +++ b/server/pkg/antlr/python3/src/PythonAntlr.cpp @@ -0,0 +1,58 @@ +#include "PythonAntlr.h" + +#include + +PythonAntlr::PythonAntlr(std::istream& in) { + input_ptr = std::make_unique(in); + lexer_ptr = std::make_unique(&(*input_ptr)); + tokenStream_ptr = std::make_unique(&(*lexer_ptr)); + parser_ptr = std::make_unique(&(*tokenStream_ptr)); +} + +std::vector PythonAntlr::getTokens() { + tokenStream_ptr->fill(); + std::vector ans(tokenStream_ptr->size()); + + int i = 0; + for (antlr4::Token *token : tokenStream_ptr->getTokens()) { + ans[i] = token; + i++; + } + + return ans; +} + +std::vector PythonAntlr::getTokensTypes() { + tokenStream_ptr->fill(); + std::vector ans(tokenStream_ptr->size()); + + int i = 0; + for (antlr4::Token *token : tokenStream_ptr->getTokens()) { + ans[i] = token->getType(); + i++; + } + + return ans; +} + +std::string PythonAntlr::getTokensString() { + tokenStream_ptr->fill(); + std::string res; + + for (antlr4::Token* token : tokenStream_ptr->getTokens()) { + res += token->toString()+" "; + } + + return res; +} + +std::string PythonAntlr::getTreeString() { + auto tree = parser_ptr->file_input(); + return tree->toStringTree(&(*parser_ptr)); +} + +std::pair PythonAntlr::getTokensAndTree() { + std::string tokens = getTokensString(); + std::string astTree = getTreeString(); + return std::make_pair(tokens, astTree); +} \ No newline at end of file diff --git a/server/pkg/antlr/testprogs/cpp/test.cpp b/server/pkg/antlr/testprogs/cpp/test.cpp index d43253fba4408fa8e2fdb45d21baad10b6d8826f..708f54faef6c2973eac82325711aac97dc313926 100644 --- a/server/pkg/antlr/testprogs/cpp/test.cpp +++ b/server/pkg/antlr/testprogs/cpp/test.cpp @@ -1,11 +1,12 @@ #include -using namespace std; int main() { + std::string res; + int a; if (true && true) { - cout << "Hello World!"; + std::cout << "Hello World!"; } return 0; } diff --git a/server/pkg/antlr/virtual/IAntlrWrapper.h b/server/pkg/antlr/virtual/IAntlrWrapper.h index 13b3a4db29448819310624a52ba98fb83fa3eaf4..c30efcfa9da28edbc706e208d2ffc5eaaf8a8f91 100644 --- a/server/pkg/antlr/virtual/IAntlrWrapper.h +++ b/server/pkg/antlr/virtual/IAntlrWrapper.h @@ -1,9 +1,16 @@ #pragma once +#include #include +#include "antlr4-runtime.h" + class IAntlrWrapper { public: - virtual std::vector getTokens() = 0; + virtual ~IAntlrWrapper() = default; + virtual std::vector getTokens() = 0; + virtual std::vector getTokensTypes() = 0; + virtual std::pair getTokensAndTree() = 0; + virtual std::string getTokensString() = 0; virtual std::string getTreeString() = 0; };