ZYM/BH-Python-Interpreter-2023
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

init

Browse Source
This commit is contained in:
Wankupi
2023-10-30 19:34:40 +08:00
commit 2e29af68b3
107 changed files with 7880 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
generated/CMakeLists.txt Normal file
View File

@ -0,0 +1,7 @@
cmake_minimum_required(VERSION 3.15)
include_directories(/usr/include/antlr4-runtime/)
file(GLOB PyAntlrSrc *.cpp)
add_library(PyAntlr STATIC ${PyAntlrSrc})

632
generated/Python3Lexer.cpp Normal file
View File

@ -0,0 +1,632 @@
#include <list>
#include <regex>
// Generated from Python3Lexer.g4 by ANTLR 4.13.1
#include "Python3Lexer.h"
using namespace antlr4;
using namespace antlr4;
namespace {
struct Python3LexerStaticData final {
Python3LexerStaticData(std::vector<std::string> ruleNames,
std::vector<std::string> channelNames,
std::vector<std::string> modeNames,
std::vector<std::string> literalNames,
std::vector<std::string> 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) {}
Python3LexerStaticData(const Python3LexerStaticData&) = delete;
Python3LexerStaticData(Python3LexerStaticData&&) = delete;
Python3LexerStaticData& operator=(const Python3LexerStaticData&) = delete;
Python3LexerStaticData& operator=(Python3LexerStaticData&&) = delete;
std::vector<antlr4::dfa::DFA> decisionToDFA;
antlr4::atn::PredictionContextCache sharedContextCache;
const std::vector<std::string> ruleNames;
const std::vector<std::string> channelNames;
const std::vector<std::string> modeNames;
const std::vector<std::string> literalNames;
const std::vector<std::string> symbolicNames;
const antlr4::dfa::Vocabulary vocabulary;
antlr4::atn::SerializedATNView serializedATN;
std::unique_ptr<antlr4::atn::ATN> atn;
};
::antlr4::internal::OnceFlag python3lexerLexerOnceFlag;
#if ANTLR4_USE_THREAD_LOCAL_CACHE
static thread_local
#endif
Python3LexerStaticData *python3lexerLexerStaticData = nullptr;
void python3lexerLexerInitialize() {
#if ANTLR4_USE_THREAD_LOCAL_CACHE
if (python3lexerLexerStaticData != nullptr) {
return;
}
#else
assert(python3lexerLexerStaticData == nullptr);
#endif
auto staticData = std::make_unique<Python3LexerStaticData>(
std::vector<std::string>{
"STRING", "NUMBER", "INTEGER", "DEF", "RETURN", "IF", "ELIF", "ELSE",
"WHILE", "FOR", "IN", "OR", "AND", "NOT", "NONE", "TRUE", "FALSE",
"CONTINUE", "BREAK", "NEWLINE", "NAME", "STRING_LITERAL", "BYTES_LITERAL",
"DECIMAL_INTEGER", "OCT_INTEGER", "HEX_INTEGER", "BIN_INTEGER", "FLOAT_NUMBER",
"IMAG_NUMBER", "DOT", "ELLIPSIS", "STAR", "OPEN_PAREN", "CLOSE_PAREN",
"COMMA", "COLON", "SEMI_COLON", "POWER", "ASSIGN", "OPEN_BRACK", "CLOSE_BRACK",
"OR_OP", "XOR", "AND_OP", "LEFT_SHIFT", "RIGHT_SHIFT", "ADD", "MINUS",
"DIV", "MOD", "IDIV", "NOT_OP", "OPEN_BRACE", "CLOSE_BRACE", "LESS_THAN",
"GREATER_THAN", "EQUALS", "GT_EQ", "LT_EQ", "NOT_EQ_1", "NOT_EQ_2",
"AT", "ARROW", "ADD_ASSIGN", "SUB_ASSIGN", "MULT_ASSIGN", "AT_ASSIGN",
"DIV_ASSIGN", "MOD_ASSIGN", "AND_ASSIGN", "OR_ASSIGN", "XOR_ASSIGN",
"LEFT_SHIFT_ASSIGN", "RIGHT_SHIFT_ASSIGN", "POWER_ASSIGN", "IDIV_ASSIGN",
"SKIP_", "UNKNOWN_CHAR", "SHORT_STRING", "LONG_STRING", "LONG_STRING_ITEM",
"LONG_STRING_CHAR", "STRING_ESCAPE_SEQ", "NON_ZERO_DIGIT", "DIGIT",
"OCT_DIGIT", "HEX_DIGIT", "BIN_DIGIT", "POINT_FLOAT", "EXPONENT_FLOAT",
"INT_PART", "FRACTION", "EXPONENT", "SHORT_BYTES", "LONG_BYTES", "LONG_BYTES_ITEM",
"SHORT_BYTES_CHAR_NO_SINGLE_QUOTE", "SHORT_BYTES_CHAR_NO_DOUBLE_QUOTE",
"LONG_BYTES_CHAR", "BYTES_ESCAPE_SEQ", "SPACES", "COMMENT", "LINE_JOINING",
"ID_START", "ID_CONTINUE"
},
std::vector<std::string>{
"DEFAULT_TOKEN_CHANNEL", "HIDDEN"
},
std::vector<std::string>{
"DEFAULT_MODE"
},
std::vector<std::string>{
"", "", "", "", "", "", "'def'", "'return'", "'if'", "'elif'", "'else'",
"'while'", "'for'", "'in'", "'or'", "'and'", "'not'", "'None'", "'True'",
"'False'", "'continue'", "'break'", "", "", "", "", "", "", "", "",
"", "", "'.'", "'...'", "'*'", "'('", "')'", "','", "':'", "';'",
"'**'", "'='", "'['", "']'", "'|'", "'^'", "'&'", "'<<'", "'>>'",
"'+'", "'-'", "'/'", "'%'", "'//'", "'~'", "'{'", "'}'", "'<'", "'>'",
"'=='", "'>='", "'<='", "'<>'", "'!='", "'@'", "'->'", "'+='", "'-='",
"'*='", "'@='", "'/='", "'%='", "'&='", "'|='", "'^='", "'<<='", "'>>='",
"'**='", "'//='"
},
std::vector<std::string>{
"", "INDENT", "DEDENT", "STRING", "NUMBER", "INTEGER", "DEF", "RETURN",
"IF", "ELIF", "ELSE", "WHILE", "FOR", "IN", "OR", "AND", "NOT", "NONE",
"TRUE", "FALSE", "CONTINUE", "BREAK", "NEWLINE", "NAME", "STRING_LITERAL",
"BYTES_LITERAL", "DECIMAL_INTEGER", "OCT_INTEGER", "HEX_INTEGER",
"BIN_INTEGER", "FLOAT_NUMBER", "IMAG_NUMBER", "DOT", "ELLIPSIS", "STAR",
"OPEN_PAREN", "CLOSE_PAREN", "COMMA", "COLON", "SEMI_COLON", "POWER",
"ASSIGN", "OPEN_BRACK", "CLOSE_BRACK", "OR_OP", "XOR", "AND_OP", "LEFT_SHIFT",
"RIGHT_SHIFT", "ADD", "MINUS", "DIV", "MOD", "IDIV", "NOT_OP", "OPEN_BRACE",
"CLOSE_BRACE", "LESS_THAN", "GREATER_THAN", "EQUALS", "GT_EQ", "LT_EQ",
"NOT_EQ_1", "NOT_EQ_2", "AT", "ARROW", "ADD_ASSIGN", "SUB_ASSIGN",
"MULT_ASSIGN", "AT_ASSIGN", "DIV_ASSIGN", "MOD_ASSIGN", "AND_ASSIGN",
"OR_ASSIGN", "XOR_ASSIGN", "LEFT_SHIFT_ASSIGN", "RIGHT_SHIFT_ASSIGN",
"POWER_ASSIGN", "IDIV_ASSIGN", "SKIP_", "UNKNOWN_CHAR"
}
);
static const int32_t serializedATNSegment[] = {
4,0,80,732,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,1,0,1,0,3,0,214,8,0,1,1,1,1,1,1,3,1,219,8,1,1,2,1,2,1,2,1,2,3,2,
225,8,2,1,3,1,3,1,3,1,3,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,5,1,5,1,5,1,6,1,
6,1,6,1,6,1,6,1,7,1,7,1,7,1,7,1,7,1,8,1,8,1,8,1,8,1,8,1,8,1,9,1,9,1,9,
1,9,1,10,1,10,1,10,1,11,1,11,1,11,1,12,1,12,1,12,1,12,1,13,1,13,1,13,
1,13,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,17,1,17,1,17,1,17,1,18,1,18,
1,18,1,18,1,18,1,18,1,19,1,19,1,19,3,19,309,8,19,1,19,1,19,3,19,313,8,
19,1,19,3,19,316,8,19,3,19,318,8,19,1,19,1,19,1,20,1,20,5,20,324,8,20,
10,20,12,20,327,9,20,1,21,1,21,1,21,1,21,1,21,3,21,334,8,21,1,21,1,21,
3,21,338,8,21,1,22,1,22,1,22,1,22,1,22,3,22,345,8,22,1,22,1,22,3,22,349,
8,22,1,23,1,23,5,23,353,8,23,10,23,12,23,356,9,23,1,23,4,23,359,8,23,
11,23,12,23,360,3,23,363,8,23,1,24,1,24,1,24,4,24,368,8,24,11,24,12,24,
369,1,25,1,25,1,25,4,25,375,8,25,11,25,12,25,376,1,26,1,26,1,26,4,26,
382,8,26,11,26,12,26,383,1,27,1,27,3,27,388,8,27,1,28,1,28,3,28,392,8,
28,1,28,1,28,1,29,1,29,1,30,1,30,1,30,1,30,1,31,1,31,1,32,1,32,1,32,1,
33,1,33,1,33,1,34,1,34,1,35,1,35,1,36,1,36,1,37,1,37,1,37,1,38,1,38,1,
39,1,39,1,39,1,40,1,40,1,40,1,41,1,41,1,42,1,42,1,43,1,43,1,44,1,44,1,
44,1,45,1,45,1,45,1,46,1,46,1,47,1,47,1,48,1,48,1,49,1,49,1,50,1,50,1,
50,1,51,1,51,1,52,1,52,1,52,1,53,1,53,1,53,1,54,1,54,1,55,1,55,1,56,1,
56,1,56,1,57,1,57,1,57,1,58,1,58,1,58,1,59,1,59,1,59,1,60,1,60,1,60,1,
61,1,61,1,62,1,62,1,62,1,63,1,63,1,63,1,64,1,64,1,64,1,65,1,65,1,65,1,
66,1,66,1,66,1,67,1,67,1,67,1,68,1,68,1,68,1,69,1,69,1,69,1,70,1,70,1,
70,1,71,1,71,1,71,1,72,1,72,1,72,1,72,1,73,1,73,1,73,1,73,1,74,1,74,1,
74,1,74,1,75,1,75,1,75,1,75,1,76,1,76,1,76,3,76,528,8,76,1,76,1,76,1,
77,1,77,1,78,1,78,1,78,5,78,537,8,78,10,78,12,78,540,9,78,1,78,1,78,1,
78,1,78,5,78,546,8,78,10,78,12,78,549,9,78,1,78,3,78,552,8,78,1,79,1,
79,1,79,1,79,1,79,5,79,559,8,79,10,79,12,79,562,9,79,1,79,1,79,1,79,1,
79,1,79,1,79,1,79,1,79,5,79,572,8,79,10,79,12,79,575,9,79,1,79,1,79,1,
79,3,79,580,8,79,1,80,1,80,3,80,584,8,80,1,81,1,81,1,82,1,82,1,82,1,82,
3,82,592,8,82,1,83,1,83,1,84,1,84,1,85,1,85,1,86,1,86,1,87,1,87,1,88,
3,88,605,8,88,1,88,1,88,1,88,1,88,3,88,611,8,88,1,89,1,89,3,89,615,8,
89,1,89,1,89,1,90,4,90,620,8,90,11,90,12,90,621,1,91,1,91,4,91,626,8,
91,11,91,12,91,627,1,92,1,92,3,92,632,8,92,1,92,4,92,635,8,92,11,92,12,
92,636,1,93,1,93,1,93,5,93,642,8,93,10,93,12,93,645,9,93,1,93,1,93,1,
93,1,93,5,93,651,8,93,10,93,12,93,654,9,93,1,93,3,93,657,8,93,1,94,1,
94,1,94,1,94,1,94,5,94,664,8,94,10,94,12,94,667,9,94,1,94,1,94,1,94,1,
94,1,94,1,94,1,94,1,94,5,94,677,8,94,10,94,12,94,680,9,94,1,94,1,94,1,
94,3,94,685,8,94,1,95,1,95,3,95,689,8,95,1,96,3,96,692,8,96,1,97,3,97,
695,8,97,1,98,3,98,698,8,98,1,99,1,99,1,99,1,100,4,100,704,8,100,11,100,
12,100,705,1,101,1,101,5,101,710,8,101,10,101,12,101,713,9,101,1,102,
1,102,3,102,717,8,102,1,102,3,102,720,8,102,1,102,1,102,3,102,724,8,102,
1,103,3,103,727,8,103,1,104,1,104,3,104,731,8,104,4,560,573,665,678,0,
105,1,3,3,4,5,5,7,6,9,7,11,8,13,9,15,10,17,11,19,12,21,13,23,14,25,15,
27,16,29,17,31,18,33,19,35,20,37,21,39,22,41,23,43,24,45,25,47,26,49,
27,51,28,53,29,55,30,57,31,59,32,61,33,63,34,65,35,67,36,69,37,71,38,
73,39,75,40,77,41,79,42,81,43,83,44,85,45,87,46,89,47,91,48,93,49,95,
50,97,51,99,52,101,53,103,54,105,55,107,56,109,57,111,58,113,59,115,60,
117,61,119,62,121,63,123,64,125,65,127,66,129,67,131,68,133,69,135,70,
137,71,139,72,141,73,143,74,145,75,147,76,149,77,151,78,153,79,155,80,
157,0,159,0,161,0,163,0,165,0,167,0,169,0,171,0,173,0,175,0,177,0,179,
0,181,0,183,0,185,0,187,0,189,0,191,0,193,0,195,0,197,0,199,0,201,0,203,
0,205,0,207,0,209,0,1,0,25,6,0,70,70,82,82,85,85,102,102,114,114,117,
117,2,0,70,70,102,102,2,0,82,82,114,114,2,0,66,66,98,98,2,0,79,79,111,
111,2,0,88,88,120,120,2,0,74,74,106,106,4,0,10,10,12,13,39,39,92,92,4,
0,10,10,12,13,34,34,92,92,1,0,92,92,1,0,49,57,1,0,48,57,1,0,48,55,3,0,
48,57,65,70,97,102,1,0,48,49,2,0,69,69,101,101,2,0,43,43,45,45,5,0,0,
9,11,12,14,38,40,91,93,127,5,0,0,9,11,12,14,33,35,91,93,127,2,0,0,91,
93,127,1,0,0,127,2,0,9,9,32,32,2,0,10,10,12,13,295,0,65,90,95,95,97,122,
170,170,181,181,186,186,192,214,216,246,248,577,592,705,710,721,736,740,
750,750,890,890,902,902,904,906,908,908,910,929,931,974,976,1013,1015,
1153,1162,1230,1232,1273,1280,1295,1329,1366,1369,1369,1377,1415,1488,
1514,1520,1522,1569,1594,1600,1610,1646,1647,1649,1747,1749,1749,1765,
1766,1774,1775,1786,1788,1791,1791,1808,1808,1810,1839,1869,1901,1920,
1957,1969,1969,2308,2361,2365,2365,2384,2384,2392,2401,2429,2429,2437,
2444,2447,2448,2451,2472,2474,2480,2482,2482,2486,2489,2493,2493,2510,
2510,2524,2525,2527,2529,2544,2545,2565,2570,2575,2576,2579,2600,2602,
2608,2610,2611,2613,2614,2616,2617,2649,2652,2654,2654,2674,2676,2693,
2701,2703,2705,2707,2728,2730,2736,2738,2739,2741,2745,2749,2749,2768,
2768,2784,2785,2821,2828,2831,2832,2835,2856,2858,2864,2866,2867,2869,
2873,2877,2877,2908,2909,2911,2913,2929,2929,2947,2947,2949,2954,2958,
2960,2962,2965,2969,2970,2972,2972,2974,2975,2979,2980,2984,2986,2990,
3001,3077,3084,3086,3088,3090,3112,3114,3123,3125,3129,3168,3169,3205,
3212,3214,3216,3218,3240,3242,3251,3253,3257,3261,3261,3294,3294,3296,
3297,3333,3340,3342,3344,3346,3368,3370,3385,3424,3425,3461,3478,3482,
3505,3507,3515,3517,3517,3520,3526,3585,3632,3634,3635,3648,3654,3713,
3714,3716,3716,3719,3720,3722,3722,3725,3725,3732,3735,3737,3743,3745,
3747,3749,3749,3751,3751,3754,3755,3757,3760,3762,3763,3773,3773,3776,
3780,3782,3782,3804,3805,3840,3840,3904,3911,3913,3946,3976,3979,4096,
4129,4131,4135,4137,4138,4176,4181,4256,4293,4304,4346,4348,4348,4352,
4441,4447,4514,4520,4601,4608,4680,4682,4685,4688,4694,4696,4696,4698,
4701,4704,4744,4746,4749,4752,4784,4786,4789,4792,4798,4800,4800,4802,
4805,4808,4822,4824,4880,4882,4885,4888,4954,4992,5007,5024,5108,5121,
5740,5743,5750,5761,5786,5792,5866,5870,5872,5888,5900,5902,5905,5920,
5937,5952,5969,5984,5996,5998,6000,6016,6067,6103,6103,6108,6108,6176,
6263,6272,6312,6400,6428,6480,6509,6512,6516,6528,6569,6593,6599,6656,
6678,7424,7615,7680,7835,7840,7929,7936,7957,7960,7965,7968,8005,8008,
8013,8016,8023,8025,8025,8027,8027,8029,8029,8031,8061,8064,8116,8118,
8124,8126,8126,8130,8132,8134,8140,8144,8147,8150,8155,8160,8172,8178,
8180,8182,8188,8305,8305,8319,8319,8336,8340,8450,8450,8455,8455,8458,
8467,8469,8469,8472,8477,8484,8484,8486,8486,8488,8488,8490,8497,8499,
8505,8508,8511,8517,8521,8544,8579,11264,11310,11312,11358,11392,11492,
11520,11557,11568,11621,11631,11631,11648,11670,11680,11686,11688,11694,
11696,11702,11704,11710,11712,11718,11720,11726,11728,11734,11736,11742,
12293,12295,12321,12329,12337,12341,12344,12348,12353,12438,12443,12447,
12449,12538,12540,12543,12549,12588,12593,12686,12704,12727,12784,12799,
13312,19893,19968,40891,40960,42124,43008,43009,43011,43013,43015,43018,
43020,43042,44032,55203,63744,64045,64048,64106,64112,64217,64256,64262,
64275,64279,64285,64285,64287,64296,64298,64310,64312,64316,64318,64318,
64320,64321,64323,64324,64326,64433,64467,64829,64848,64911,64914,64967,
65008,65019,65136,65140,65142,65276,65313,65338,65345,65370,65382,65470,
65474,65479,65482,65487,65490,65495,65498,65500,148,0,48,57,768,879,1155,
1158,1425,1465,1467,1469,1471,1471,1473,1474,1476,1477,1479,1479,1552,
1557,1611,1630,1632,1641,1648,1648,1750,1756,1759,1764,1767,1768,1770,
1773,1776,1785,1809,1809,1840,1866,1958,1968,2305,2307,2364,2364,2366,
2381,2385,2388,2402,2403,2406,2415,2433,2435,2492,2492,2494,2500,2503,
2504,2507,2509,2519,2519,2530,2531,2534,2543,2561,2563,2620,2620,2622,
2626,2631,2632,2635,2637,2662,2673,2689,2691,2748,2748,2750,2757,2759,
2761,2763,2765,2786,2787,2790,2799,2817,2819,2876,2876,2878,2883,2887,
2888,2891,2893,2902,2903,2918,2927,2946,2946,3006,3010,3014,3016,3018,
3021,3031,3031,3046,3055,3073,3075,3134,3140,3142,3144,3146,3149,3157,
3158,3174,3183,3202,3203,3260,3260,3262,3268,3270,3272,3274,3277,3285,
3286,3302,3311,3330,3331,3390,3395,3398,3400,3402,3405,3415,3415,3430,
3439,3458,3459,3530,3530,3535,3540,3542,3542,3544,3551,3570,3571,3633,
3633,3636,3642,3655,3662,3664,3673,3761,3761,3764,3769,3771,3772,3784,
3789,3792,3801,3864,3865,3872,3881,3893,3893,3895,3895,3897,3897,3902,
3903,3953,3972,3974,3975,3984,3991,3993,4028,4038,4038,4140,4146,4150,
4153,4160,4169,4182,4185,4959,4959,4969,4977,5906,5908,5938,5940,5970,
5971,6002,6003,6070,6099,6109,6109,6112,6121,6155,6157,6160,6169,6313,
6313,6432,6443,6448,6459,6470,6479,6576,6592,6600,6601,6608,6617,6679,
6683,7616,7619,8255,8256,8276,8276,8400,8412,8417,8417,8421,8427,12330,
12335,12441,12442,43010,43010,43014,43014,43019,43019,43043,43047,64286,
64286,65024,65039,65056,65059,65075,65076,65101,65103,65296,65305,65343,
65343,764,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,1,213,1,0,0,0,3,218,1,0,0,0,5,224,1,0,0,0,7,226,1,0,0,0,9,230,1,0,0,
0,11,237,1,0,0,0,13,240,1,0,0,0,15,245,1,0,0,0,17,250,1,0,0,0,19,256,
1,0,0,0,21,260,1,0,0,0,23,263,1,0,0,0,25,266,1,0,0,0,27,270,1,0,0,0,29,
274,1,0,0,0,31,279,1,0,0,0,33,284,1,0,0,0,35,290,1,0,0,0,37,299,1,0,0,
0,39,317,1,0,0,0,41,321,1,0,0,0,43,333,1,0,0,0,45,344,1,0,0,0,47,362,
1,0,0,0,49,364,1,0,0,0,51,371,1,0,0,0,53,378,1,0,0,0,55,387,1,0,0,0,57,
391,1,0,0,0,59,395,1,0,0,0,61,397,1,0,0,0,63,401,1,0,0,0,65,403,1,0,0,
0,67,406,1,0,0,0,69,409,1,0,0,0,71,411,1,0,0,0,73,413,1,0,0,0,75,415,
1,0,0,0,77,418,1,0,0,0,79,420,1,0,0,0,81,423,1,0,0,0,83,426,1,0,0,0,85,
428,1,0,0,0,87,430,1,0,0,0,89,432,1,0,0,0,91,435,1,0,0,0,93,438,1,0,0,
0,95,440,1,0,0,0,97,442,1,0,0,0,99,444,1,0,0,0,101,446,1,0,0,0,103,449,
1,0,0,0,105,451,1,0,0,0,107,454,1,0,0,0,109,457,1,0,0,0,111,459,1,0,0,
0,113,461,1,0,0,0,115,464,1,0,0,0,117,467,1,0,0,0,119,470,1,0,0,0,121,
473,1,0,0,0,123,476,1,0,0,0,125,478,1,0,0,0,127,481,1,0,0,0,129,484,1,
0,0,0,131,487,1,0,0,0,133,490,1,0,0,0,135,493,1,0,0,0,137,496,1,0,0,0,
139,499,1,0,0,0,141,502,1,0,0,0,143,505,1,0,0,0,145,508,1,0,0,0,147,512,
1,0,0,0,149,516,1,0,0,0,151,520,1,0,0,0,153,527,1,0,0,0,155,531,1,0,0,
0,157,551,1,0,0,0,159,579,1,0,0,0,161,583,1,0,0,0,163,585,1,0,0,0,165,
591,1,0,0,0,167,593,1,0,0,0,169,595,1,0,0,0,171,597,1,0,0,0,173,599,1,
0,0,0,175,601,1,0,0,0,177,610,1,0,0,0,179,614,1,0,0,0,181,619,1,0,0,0,
183,623,1,0,0,0,185,629,1,0,0,0,187,656,1,0,0,0,189,684,1,0,0,0,191,688,
1,0,0,0,193,691,1,0,0,0,195,694,1,0,0,0,197,697,1,0,0,0,199,699,1,0,0,
0,201,703,1,0,0,0,203,707,1,0,0,0,205,714,1,0,0,0,207,726,1,0,0,0,209,
730,1,0,0,0,211,214,3,43,21,0,212,214,3,45,22,0,213,211,1,0,0,0,213,212,
1,0,0,0,214,2,1,0,0,0,215,219,3,5,2,0,216,219,3,55,27,0,217,219,3,57,
28,0,218,215,1,0,0,0,218,216,1,0,0,0,218,217,1,0,0,0,219,4,1,0,0,0,220,
225,3,47,23,0,221,225,3,49,24,0,222,225,3,51,25,0,223,225,3,53,26,0,224,
220,1,0,0,0,224,221,1,0,0,0,224,222,1,0,0,0,224,223,1,0,0,0,225,6,1,0,
0,0,226,227,5,100,0,0,227,228,5,101,0,0,228,229,5,102,0,0,229,8,1,0,0,
0,230,231,5,114,0,0,231,232,5,101,0,0,232,233,5,116,0,0,233,234,5,117,
0,0,234,235,5,114,0,0,235,236,5,110,0,0,236,10,1,0,0,0,237,238,5,105,
0,0,238,239,5,102,0,0,239,12,1,0,0,0,240,241,5,101,0,0,241,242,5,108,
0,0,242,243,5,105,0,0,243,244,5,102,0,0,244,14,1,0,0,0,245,246,5,101,
0,0,246,247,5,108,0,0,247,248,5,115,0,0,248,249,5,101,0,0,249,16,1,0,
0,0,250,251,5,119,0,0,251,252,5,104,0,0,252,253,5,105,0,0,253,254,5,108,
0,0,254,255,5,101,0,0,255,18,1,0,0,0,256,257,5,102,0,0,257,258,5,111,
0,0,258,259,5,114,0,0,259,20,1,0,0,0,260,261,5,105,0,0,261,262,5,110,
0,0,262,22,1,0,0,0,263,264,5,111,0,0,264,265,5,114,0,0,265,24,1,0,0,0,
266,267,5,97,0,0,267,268,5,110,0,0,268,269,5,100,0,0,269,26,1,0,0,0,270,
271,5,110,0,0,271,272,5,111,0,0,272,273,5,116,0,0,273,28,1,0,0,0,274,
275,5,78,0,0,275,276,5,111,0,0,276,277,5,110,0,0,277,278,5,101,0,0,278,
30,1,0,0,0,279,280,5,84,0,0,280,281,5,114,0,0,281,282,5,117,0,0,282,283,
5,101,0,0,283,32,1,0,0,0,284,285,5,70,0,0,285,286,5,97,0,0,286,287,5,
108,0,0,287,288,5,115,0,0,288,289,5,101,0,0,289,34,1,0,0,0,290,291,5,
99,0,0,291,292,5,111,0,0,292,293,5,110,0,0,293,294,5,116,0,0,294,295,
5,105,0,0,295,296,5,110,0,0,296,297,5,117,0,0,297,298,5,101,0,0,298,36,
1,0,0,0,299,300,5,98,0,0,300,301,5,114,0,0,301,302,5,101,0,0,302,303,
5,97,0,0,303,304,5,107,0,0,304,38,1,0,0,0,305,306,4,19,0,0,306,318,3,
201,100,0,307,309,5,13,0,0,308,307,1,0,0,0,308,309,1,0,0,0,309,310,1,
0,0,0,310,313,5,10,0,0,311,313,2,12,13,0,312,308,1,0,0,0,312,311,1,0,
0,0,313,315,1,0,0,0,314,316,3,201,100,0,315,314,1,0,0,0,315,316,1,0,0,
0,316,318,1,0,0,0,317,305,1,0,0,0,317,312,1,0,0,0,318,319,1,0,0,0,319,
320,6,19,0,0,320,40,1,0,0,0,321,325,3,207,103,0,322,324,3,209,104,0,323,
322,1,0,0,0,324,327,1,0,0,0,325,323,1,0,0,0,325,326,1,0,0,0,326,42,1,
0,0,0,327,325,1,0,0,0,328,334,7,0,0,0,329,330,7,1,0,0,330,334,7,2,0,0,
331,332,7,2,0,0,332,334,7,1,0,0,333,328,1,0,0,0,333,329,1,0,0,0,333,331,
1,0,0,0,333,334,1,0,0,0,334,337,1,0,0,0,335,338,3,157,78,0,336,338,3,
159,79,0,337,335,1,0,0,0,337,336,1,0,0,0,338,44,1,0,0,0,339,345,7,3,0,
0,340,341,7,3,0,0,341,345,7,2,0,0,342,343,7,2,0,0,343,345,7,3,0,0,344,
339,1,0,0,0,344,340,1,0,0,0,344,342,1,0,0,0,345,348,1,0,0,0,346,349,3,
187,93,0,347,349,3,189,94,0,348,346,1,0,0,0,348,347,1,0,0,0,349,46,1,
0,0,0,350,354,3,167,83,0,351,353,3,169,84,0,352,351,1,0,0,0,353,356,1,
0,0,0,354,352,1,0,0,0,354,355,1,0,0,0,355,363,1,0,0,0,356,354,1,0,0,0,
357,359,5,48,0,0,358,357,1,0,0,0,359,360,1,0,0,0,360,358,1,0,0,0,360,
361,1,0,0,0,361,363,1,0,0,0,362,350,1,0,0,0,362,358,1,0,0,0,363,48,1,
0,0,0,364,365,5,48,0,0,365,367,7,4,0,0,366,368,3,171,85,0,367,366,1,0,
0,0,368,369,1,0,0,0,369,367,1,0,0,0,369,370,1,0,0,0,370,50,1,0,0,0,371,
372,5,48,0,0,372,374,7,5,0,0,373,375,3,173,86,0,374,373,1,0,0,0,375,376,
1,0,0,0,376,374,1,0,0,0,376,377,1,0,0,0,377,52,1,0,0,0,378,379,5,48,0,
0,379,381,7,3,0,0,380,382,3,175,87,0,381,380,1,0,0,0,382,383,1,0,0,0,
383,381,1,0,0,0,383,384,1,0,0,0,384,54,1,0,0,0,385,388,3,177,88,0,386,
388,3,179,89,0,387,385,1,0,0,0,387,386,1,0,0,0,388,56,1,0,0,0,389,392,
3,55,27,0,390,392,3,181,90,0,391,389,1,0,0,0,391,390,1,0,0,0,392,393,
1,0,0,0,393,394,7,6,0,0,394,58,1,0,0,0,395,396,5,46,0,0,396,60,1,0,0,
0,397,398,5,46,0,0,398,399,5,46,0,0,399,400,5,46,0,0,400,62,1,0,0,0,401,
402,5,42,0,0,402,64,1,0,0,0,403,404,5,40,0,0,404,405,6,32,1,0,405,66,
1,0,0,0,406,407,5,41,0,0,407,408,6,33,2,0,408,68,1,0,0,0,409,410,5,44,
0,0,410,70,1,0,0,0,411,412,5,58,0,0,412,72,1,0,0,0,413,414,5,59,0,0,414,
74,1,0,0,0,415,416,5,42,0,0,416,417,5,42,0,0,417,76,1,0,0,0,418,419,5,
61,0,0,419,78,1,0,0,0,420,421,5,91,0,0,421,422,6,39,3,0,422,80,1,0,0,
0,423,424,5,93,0,0,424,425,6,40,4,0,425,82,1,0,0,0,426,427,5,124,0,0,
427,84,1,0,0,0,428,429,5,94,0,0,429,86,1,0,0,0,430,431,5,38,0,0,431,88,
1,0,0,0,432,433,5,60,0,0,433,434,5,60,0,0,434,90,1,0,0,0,435,436,5,62,
0,0,436,437,5,62,0,0,437,92,1,0,0,0,438,439,5,43,0,0,439,94,1,0,0,0,440,
441,5,45,0,0,441,96,1,0,0,0,442,443,5,47,0,0,443,98,1,0,0,0,444,445,5,
37,0,0,445,100,1,0,0,0,446,447,5,47,0,0,447,448,5,47,0,0,448,102,1,0,
0,0,449,450,5,126,0,0,450,104,1,0,0,0,451,452,5,123,0,0,452,453,6,52,
5,0,453,106,1,0,0,0,454,455,5,125,0,0,455,456,6,53,6,0,456,108,1,0,0,
0,457,458,5,60,0,0,458,110,1,0,0,0,459,460,5,62,0,0,460,112,1,0,0,0,461,
462,5,61,0,0,462,463,5,61,0,0,463,114,1,0,0,0,464,465,5,62,0,0,465,466,
5,61,0,0,466,116,1,0,0,0,467,468,5,60,0,0,468,469,5,61,0,0,469,118,1,
0,0,0,470,471,5,60,0,0,471,472,5,62,0,0,472,120,1,0,0,0,473,474,5,33,
0,0,474,475,5,61,0,0,475,122,1,0,0,0,476,477,5,64,0,0,477,124,1,0,0,0,
478,479,5,45,0,0,479,480,5,62,0,0,480,126,1,0,0,0,481,482,5,43,0,0,482,
483,5,61,0,0,483,128,1,0,0,0,484,485,5,45,0,0,485,486,5,61,0,0,486,130,
1,0,0,0,487,488,5,42,0,0,488,489,5,61,0,0,489,132,1,0,0,0,490,491,5,64,
0,0,491,492,5,61,0,0,492,134,1,0,0,0,493,494,5,47,0,0,494,495,5,61,0,
0,495,136,1,0,0,0,496,497,5,37,0,0,497,498,5,61,0,0,498,138,1,0,0,0,499,
500,5,38,0,0,500,501,5,61,0,0,501,140,1,0,0,0,502,503,5,124,0,0,503,504,
5,61,0,0,504,142,1,0,0,0,505,506,5,94,0,0,506,507,5,61,0,0,507,144,1,
0,0,0,508,509,5,60,0,0,509,510,5,60,0,0,510,511,5,61,0,0,511,146,1,0,
0,0,512,513,5,62,0,0,513,514,5,62,0,0,514,515,5,61,0,0,515,148,1,0,0,
0,516,517,5,42,0,0,517,518,5,42,0,0,518,519,5,61,0,0,519,150,1,0,0,0,
520,521,5,47,0,0,521,522,5,47,0,0,522,523,5,61,0,0,523,152,1,0,0,0,524,
528,3,201,100,0,525,528,3,203,101,0,526,528,3,205,102,0,527,524,1,0,0,
0,527,525,1,0,0,0,527,526,1,0,0,0,528,529,1,0,0,0,529,530,6,76,7,0,530,
154,1,0,0,0,531,532,9,0,0,0,532,156,1,0,0,0,533,538,5,39,0,0,534,537,
3,165,82,0,535,537,8,7,0,0,536,534,1,0,0,0,536,535,1,0,0,0,537,540,1,
0,0,0,538,536,1,0,0,0,538,539,1,0,0,0,539,541,1,0,0,0,540,538,1,0,0,0,
541,552,5,39,0,0,542,547,5,34,0,0,543,546,3,165,82,0,544,546,8,8,0,0,
545,543,1,0,0,0,545,544,1,0,0,0,546,549,1,0,0,0,547,545,1,0,0,0,547,548,
1,0,0,0,548,550,1,0,0,0,549,547,1,0,0,0,550,552,5,34,0,0,551,533,1,0,
0,0,551,542,1,0,0,0,552,158,1,0,0,0,553,554,5,39,0,0,554,555,5,39,0,0,
555,556,5,39,0,0,556,560,1,0,0,0,557,559,3,161,80,0,558,557,1,0,0,0,559,
562,1,0,0,0,560,561,1,0,0,0,560,558,1,0,0,0,561,563,1,0,0,0,562,560,1,
0,0,0,563,564,5,39,0,0,564,565,5,39,0,0,565,580,5,39,0,0,566,567,5,34,
0,0,567,568,5,34,0,0,568,569,5,34,0,0,569,573,1,0,0,0,570,572,3,161,80,
0,571,570,1,0,0,0,572,575,1,0,0,0,573,574,1,0,0,0,573,571,1,0,0,0,574,
576,1,0,0,0,575,573,1,0,0,0,576,577,5,34,0,0,577,578,5,34,0,0,578,580,
5,34,0,0,579,553,1,0,0,0,579,566,1,0,0,0,580,160,1,0,0,0,581,584,3,163,
81,0,582,584,3,165,82,0,583,581,1,0,0,0,583,582,1,0,0,0,584,162,1,0,0,
0,585,586,8,9,0,0,586,164,1,0,0,0,587,588,5,92,0,0,588,592,9,0,0,0,589,
590,5,92,0,0,590,592,3,39,19,0,591,587,1,0,0,0,591,589,1,0,0,0,592,166,
1,0,0,0,593,594,7,10,0,0,594,168,1,0,0,0,595,596,7,11,0,0,596,170,1,0,
0,0,597,598,7,12,0,0,598,172,1,0,0,0,599,600,7,13,0,0,600,174,1,0,0,0,
601,602,7,14,0,0,602,176,1,0,0,0,603,605,3,181,90,0,604,603,1,0,0,0,604,
605,1,0,0,0,605,606,1,0,0,0,606,611,3,183,91,0,607,608,3,181,90,0,608,
609,5,46,0,0,609,611,1,0,0,0,610,604,1,0,0,0,610,607,1,0,0,0,611,178,
1,0,0,0,612,615,3,181,90,0,613,615,3,177,88,0,614,612,1,0,0,0,614,613,
1,0,0,0,615,616,1,0,0,0,616,617,3,185,92,0,617,180,1,0,0,0,618,620,3,
169,84,0,619,618,1,0,0,0,620,621,1,0,0,0,621,619,1,0,0,0,621,622,1,0,
0,0,622,182,1,0,0,0,623,625,5,46,0,0,624,626,3,169,84,0,625,624,1,0,0,
0,626,627,1,0,0,0,627,625,1,0,0,0,627,628,1,0,0,0,628,184,1,0,0,0,629,
631,7,15,0,0,630,632,7,16,0,0,631,630,1,0,0,0,631,632,1,0,0,0,632,634,
1,0,0,0,633,635,3,169,84,0,634,633,1,0,0,0,635,636,1,0,0,0,636,634,1,
0,0,0,636,637,1,0,0,0,637,186,1,0,0,0,638,643,5,39,0,0,639,642,3,193,
96,0,640,642,3,199,99,0,641,639,1,0,0,0,641,640,1,0,0,0,642,645,1,0,0,
0,643,641,1,0,0,0,643,644,1,0,0,0,644,646,1,0,0,0,645,643,1,0,0,0,646,
657,5,39,0,0,647,652,5,34,0,0,648,651,3,195,97,0,649,651,3,199,99,0,650,
648,1,0,0,0,650,649,1,0,0,0,651,654,1,0,0,0,652,650,1,0,0,0,652,653,1,
0,0,0,653,655,1,0,0,0,654,652,1,0,0,0,655,657,5,34,0,0,656,638,1,0,0,
0,656,647,1,0,0,0,657,188,1,0,0,0,658,659,5,39,0,0,659,660,5,39,0,0,660,
661,5,39,0,0,661,665,1,0,0,0,662,664,3,191,95,0,663,662,1,0,0,0,664,667,
1,0,0,0,665,666,1,0,0,0,665,663,1,0,0,0,666,668,1,0,0,0,667,665,1,0,0,
0,668,669,5,39,0,0,669,670,5,39,0,0,670,685,5,39,0,0,671,672,5,34,0,0,
672,673,5,34,0,0,673,674,5,34,0,0,674,678,1,0,0,0,675,677,3,191,95,0,
676,675,1,0,0,0,677,680,1,0,0,0,678,679,1,0,0,0,678,676,1,0,0,0,679,681,
1,0,0,0,680,678,1,0,0,0,681,682,5,34,0,0,682,683,5,34,0,0,683,685,5,34,
0,0,684,658,1,0,0,0,684,671,1,0,0,0,685,190,1,0,0,0,686,689,3,197,98,
0,687,689,3,199,99,0,688,686,1,0,0,0,688,687,1,0,0,0,689,192,1,0,0,0,
690,692,7,17,0,0,691,690,1,0,0,0,692,194,1,0,0,0,693,695,7,18,0,0,694,
693,1,0,0,0,695,196,1,0,0,0,696,698,7,19,0,0,697,696,1,0,0,0,698,198,
1,0,0,0,699,700,5,92,0,0,700,701,7,20,0,0,701,200,1,0,0,0,702,704,7,21,
0,0,703,702,1,0,0,0,704,705,1,0,0,0,705,703,1,0,0,0,705,706,1,0,0,0,706,
202,1,0,0,0,707,711,5,35,0,0,708,710,8,22,0,0,709,708,1,0,0,0,710,713,
1,0,0,0,711,709,1,0,0,0,711,712,1,0,0,0,712,204,1,0,0,0,713,711,1,0,0,
0,714,716,5,92,0,0,715,717,3,201,100,0,716,715,1,0,0,0,716,717,1,0,0,
0,717,723,1,0,0,0,718,720,5,13,0,0,719,718,1,0,0,0,719,720,1,0,0,0,720,
721,1,0,0,0,721,724,5,10,0,0,722,724,2,12,13,0,723,719,1,0,0,0,723,722,
1,0,0,0,724,206,1,0,0,0,725,727,7,23,0,0,726,725,1,0,0,0,727,208,1,0,
0,0,728,731,3,207,103,0,729,731,7,24,0,0,730,728,1,0,0,0,730,729,1,0,
0,0,731,210,1,0,0,0,58,0,213,218,224,308,312,315,317,325,333,337,344,
348,354,360,362,369,376,383,387,391,527,536,538,545,547,551,560,573,579,
583,591,604,610,614,621,627,631,636,641,643,650,652,656,665,678,684,688,
691,694,697,705,711,716,719,723,726,730,8,1,19,0,1,32,1,1,33,2,1,39,3,
1,40,4,1,52,5,1,53,6,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);
}
python3lexerLexerStaticData = staticData.release();
}
}
Python3Lexer::Python3Lexer(CharStream *input) : Lexer(input) {
Python3Lexer::initialize();
_interpreter = new atn::LexerATNSimulator(this, *python3lexerLexerStaticData->atn, python3lexerLexerStaticData->decisionToDFA, python3lexerLexerStaticData->sharedContextCache);
}
Python3Lexer::~Python3Lexer() {
delete _interpreter;
}
std::string Python3Lexer::getGrammarFileName() const {
return "Python3Lexer.g4";
}
const std::vector<std::string>& Python3Lexer::getRuleNames() const {
return python3lexerLexerStaticData->ruleNames;
}
const std::vector<std::string>& Python3Lexer::getChannelNames() const {
return python3lexerLexerStaticData->channelNames;
}
const std::vector<std::string>& Python3Lexer::getModeNames() const {
return python3lexerLexerStaticData->modeNames;
}
const dfa::Vocabulary& Python3Lexer::getVocabulary() const {
return python3lexerLexerStaticData->vocabulary;
}
antlr4::atn::SerializedATNView Python3Lexer::getSerializedATN() const {
return python3lexerLexerStaticData->serializedATN;
}
const atn::ATN& Python3Lexer::getATN() const {
return *python3lexerLexerStaticData->atn;
}
void Python3Lexer::action(RuleContext *context, size_t ruleIndex, size_t actionIndex) {
switch (ruleIndex) {
case 19: NEWLINEAction(antlrcpp::downCast<antlr4::RuleContext *>(context), actionIndex); break;
case 32: OPEN_PARENAction(antlrcpp::downCast<antlr4::RuleContext *>(context), actionIndex); break;
case 33: CLOSE_PARENAction(antlrcpp::downCast<antlr4::RuleContext *>(context), actionIndex); break;
case 39: OPEN_BRACKAction(antlrcpp::downCast<antlr4::RuleContext *>(context), actionIndex); break;
case 40: CLOSE_BRACKAction(antlrcpp::downCast<antlr4::RuleContext *>(context), actionIndex); break;
case 52: OPEN_BRACEAction(antlrcpp::downCast<antlr4::RuleContext *>(context), actionIndex); break;
case 53: CLOSE_BRACEAction(antlrcpp::downCast<antlr4::RuleContext *>(context), actionIndex); break;
default:
break;
}
}
bool Python3Lexer::sempred(RuleContext *context, size_t ruleIndex, size_t predicateIndex) {
switch (ruleIndex) {
case 19: return NEWLINESempred(antlrcpp::downCast<antlr4::RuleContext *>(context), predicateIndex);
default:
break;
}
return true;
}
void Python3Lexer::NEWLINEAction(antlr4::RuleContext *context, size_t actionIndex) {
switch (actionIndex) {
case 0:
{
std::string pattern1="[^\r\n\f]+";
std::string pattern2="[\r\n\f]+";
std::regex re1(pattern1);
std::regex re2(pattern2);
std::string fmt="";
std::string newLine=regex_replace(getText(),re1,fmt);
std::string spaces = regex_replace(getText(),re2,fmt);
int next = _input->LA(1);
if (opened > 0 || next == '\r' || next == '\n' || next == '\f' || next == '#') {
// If we're inside a list or on a blank line, ignore all indents,
// dedents and line breaks.
skip();
}
else {
emit(commonToken(NEWLINE, newLine));
int indent = getIndentationCount(spaces);
int previous = indents.empty() ? 0 : indents.top();
if (indent == previous) {
// skip indents of the same size as the present indent-size
skip();
}
else if (indent > previous) {
indents.push(indent);
emit(commonToken(Python3Lexer::INDENT, spaces));
}
else {
// Possibly emit more than 1 DEDENT token.
while(!indents.empty() && indents.top() > indent) {
this->emit(createDedent());
indents.pop();
}
}
}
}
break;
default:
break;
}
}
void Python3Lexer::OPEN_PARENAction(antlr4::RuleContext *context, size_t actionIndex) {
switch (actionIndex) {
case 1: opened++; break;
default:
break;
}
}
void Python3Lexer::CLOSE_PARENAction(antlr4::RuleContext *context, size_t actionIndex) {
switch (actionIndex) {
case 2: opened--; break;
default:
break;
}
}
void Python3Lexer::OPEN_BRACKAction(antlr4::RuleContext *context, size_t actionIndex) {
switch (actionIndex) {
case 3: opened++; break;
default:
break;
}
}
void Python3Lexer::CLOSE_BRACKAction(antlr4::RuleContext *context, size_t actionIndex) {
switch (actionIndex) {
case 4: opened--; break;
default:
break;
}
}
void Python3Lexer::OPEN_BRACEAction(antlr4::RuleContext *context, size_t actionIndex) {
switch (actionIndex) {
case 5: opened++; break;
default:
break;
}
}
void Python3Lexer::CLOSE_BRACEAction(antlr4::RuleContext *context, size_t actionIndex) {
switch (actionIndex) {
case 6: opened--; break;
default:
break;
}
}
bool Python3Lexer::NEWLINESempred(antlr4::RuleContext *_localctx, size_t predicateIndex) {
switch (predicateIndex) {
case 0: return atStartOfInput();
default:
break;
}
return true;
}
void Python3Lexer::initialize() {
#if ANTLR4_USE_THREAD_LOCAL_CACHE
python3lexerLexerInitialize();
#else
::antlr4::internal::call_once(python3lexerLexerOnceFlag, python3lexerLexerInitialize);
#endif
}

186
generated/Python3Lexer.h Normal file
View File

@ -0,0 +1,186 @@
#include <list>
#include <regex>
// Generated from Python3Lexer.g4 by ANTLR 4.13.1
#pragma once
#include "antlr4-runtime.h"
class Python3Lexer : public antlr4::Lexer {
public:
enum {
INDENT = 1, DEDENT = 2, STRING = 3, NUMBER = 4, INTEGER = 5, DEF = 6,
RETURN = 7, IF = 8, ELIF = 9, ELSE = 10, WHILE = 11, FOR = 12, IN = 13,
OR = 14, AND = 15, NOT = 16, NONE = 17, TRUE = 18, FALSE = 19, CONTINUE = 20,
BREAK = 21, NEWLINE = 22, NAME = 23, STRING_LITERAL = 24, BYTES_LITERAL = 25,
DECIMAL_INTEGER = 26, OCT_INTEGER = 27, HEX_INTEGER = 28, BIN_INTEGER = 29,
FLOAT_NUMBER = 30, IMAG_NUMBER = 31, DOT = 32, ELLIPSIS = 33, STAR = 34,
OPEN_PAREN = 35, CLOSE_PAREN = 36, COMMA = 37, COLON = 38, SEMI_COLON = 39,
POWER = 40, ASSIGN = 41, OPEN_BRACK = 42, CLOSE_BRACK = 43, OR_OP = 44,
XOR = 45, AND_OP = 46, LEFT_SHIFT = 47, RIGHT_SHIFT = 48, ADD = 49,
MINUS = 50, DIV = 51, MOD = 52, IDIV = 53, NOT_OP = 54, OPEN_BRACE = 55,
CLOSE_BRACE = 56, LESS_THAN = 57, GREATER_THAN = 58, EQUALS = 59, GT_EQ = 60,
LT_EQ = 61, NOT_EQ_1 = 62, NOT_EQ_2 = 63, AT = 64, ARROW = 65, ADD_ASSIGN = 66,
SUB_ASSIGN = 67, MULT_ASSIGN = 68, AT_ASSIGN = 69, DIV_ASSIGN = 70,
MOD_ASSIGN = 71, AND_ASSIGN = 72, OR_ASSIGN = 73, XOR_ASSIGN = 74, LEFT_SHIFT_ASSIGN = 75,
RIGHT_SHIFT_ASSIGN = 76, POWER_ASSIGN = 77, IDIV_ASSIGN = 78, SKIP_ = 79,
UNKNOWN_CHAR = 80
};
explicit Python3Lexer(antlr4::CharStream *input);
~Python3Lexer() override;
// A queue where extra tokens are pushed on (see the NEWLINE lexer rule).
private: std::list<antlr4::Token*> tokens ;
// The stack that keeps track of the indentation level.
private: std::stack<int> indents ;
// The amount of opened braces, brackets and parenthesis.
private: int opened = 0;
// The most recently produced token.
private: antlr4::Token* lastToken = nullptr;
public: void emit(std::unique_ptr<antlr4::Token> t) override {
token.release();
token=std::move(t);
tokens.push_back(token.get());
// std::cout<<t->toString()<<std::endl;
}
public: std::unique_ptr<antlr4::Token> nextToken() override {
// Check if the end-of-file is ahead and there are still some DEDENTS expected.
if (_input->LA(1) == EOF && !this->indents.empty()) {
// Remove any trailing EOF tokens from our buffer.
for(auto i=tokens.rbegin();i!=tokens.rend();){
auto tmp=i;
i++;
if((*tmp)->getType()==EOF){
tokens.erase(tmp.base());
}
}
// First emit an extra line break that serves as the end of the statement.
std::unique_ptr<antlr4::Token> tmp=commonToken(Python3Lexer::NEWLINE, "\n");
this->emit(std::move(tmp));
// Now emit as much DEDENT tokens as needed.
while (!indents.empty()) {
auto tmp=createDedent();
this->emit(std::move(tmp));
indents.pop();
}
// Put the EOF back on the token stream.
this->emit(commonToken(static_cast<int>(Python3Lexer::EOF), "<EOF>"));
}
std::unique_ptr<antlr4::Token> next = Lexer::nextToken();
if (next->getChannel() == antlr4::Token::DEFAULT_CHANNEL) {
// Keep track of the last token on the default channel.
this->lastToken = next.get();
}
if (tokens.empty()) {
return std::move(next);
} else{
next.release();
auto tmp=tokens.front();
tokens.pop_front();
return std::unique_ptr<antlr4::Token>(tmp);
}
}
private: std::unique_ptr<antlr4::Token> createDedent() {
auto dedent = commonToken(Python3Lexer::DEDENT, "");
dedent->setLine(this->lastToken->getLine());
return std::move(dedent);
}
private: std::unique_ptr<antlr4::CommonToken> commonToken(int type,std::string text) {
int stop = this->getCharIndex() - 1;
int start = text.empty() ? stop : stop - text.length() + 1;
return std::move(std::unique_ptr<antlr4::CommonToken>(new antlr4::CommonToken({ this, _input },
type,
DEFAULT_TOKEN_CHANNEL, start, stop)));
}
// Calculates the indentation of the provided spaces, taking the
// following rules into account:
//
// "Tabs are replaced (from left to right) by one to eight spaces
// such that the total number of characters up to and including
// the replacement is a multiple of eight [...]"
//
// -- https://docs.python.org/3.1/reference/lexical_analysis.html#indentation
static int getIndentationCount(std::string spaces) {
int count = 0;
for (char ch : spaces) {
switch (ch) {
case '\t':
count += 8 - (count % 8);
break;
default:
// A normal space char.
count++;
}
}
return count;
}
bool atStartOfInput() {
return Lexer::getCharPositionInLine() == 0 && Lexer::getLine() == 1;
}
std::string getGrammarFileName() const override;
const std::vector<std::string>& getRuleNames() const override;
const std::vector<std::string>& getChannelNames() const override;
const std::vector<std::string>& getModeNames() const override;
const antlr4::dfa::Vocabulary& getVocabulary() const override;
antlr4::atn::SerializedATNView getSerializedATN() const override;
const antlr4::atn::ATN& getATN() const override;
void action(antlr4::RuleContext *context, size_t ruleIndex, size_t actionIndex) override;
bool sempred(antlr4::RuleContext *_localctx, size_t ruleIndex, size_t predicateIndex) 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.
void NEWLINEAction(antlr4::RuleContext *context, size_t actionIndex);
void OPEN_PARENAction(antlr4::RuleContext *context, size_t actionIndex);
void CLOSE_PARENAction(antlr4::RuleContext *context, size_t actionIndex);
void OPEN_BRACKAction(antlr4::RuleContext *context, size_t actionIndex);
void CLOSE_BRACKAction(antlr4::RuleContext *context, size_t actionIndex);
void OPEN_BRACEAction(antlr4::RuleContext *context, size_t actionIndex);
void CLOSE_BRACEAction(antlr4::RuleContext *context, size_t actionIndex);
// Individual semantic predicate functions triggered by sempred() above.
bool NEWLINESempred(antlr4::RuleContext *_localctx, size_t predicateIndex);
};

282
generated/Python3Lexer.interp Normal file
View File

File diff suppressed because one or more lines are too long

143
generated/Python3Lexer.tokens Normal file
View File

@ -0,0 +1,143 @@
INDENT=1
DEDENT=2
STRING=3
NUMBER=4
INTEGER=5
DEF=6
RETURN=7
IF=8
ELIF=9
ELSE=10
WHILE=11
FOR=12
IN=13
OR=14
AND=15
NOT=16
NONE=17
TRUE=18
FALSE=19
CONTINUE=20
BREAK=21
NEWLINE=22
NAME=23
STRING_LITERAL=24
BYTES_LITERAL=25
DECIMAL_INTEGER=26
OCT_INTEGER=27
HEX_INTEGER=28
BIN_INTEGER=29
FLOAT_NUMBER=30
IMAG_NUMBER=31
DOT=32
ELLIPSIS=33
STAR=34
OPEN_PAREN=35
CLOSE_PAREN=36
COMMA=37
COLON=38
SEMI_COLON=39
POWER=40
ASSIGN=41
OPEN_BRACK=42
CLOSE_BRACK=43
OR_OP=44
XOR=45
AND_OP=46
LEFT_SHIFT=47
RIGHT_SHIFT=48
ADD=49
MINUS=50
DIV=51
MOD=52
IDIV=53
NOT_OP=54
OPEN_BRACE=55
CLOSE_BRACE=56
LESS_THAN=57
GREATER_THAN=58
EQUALS=59
GT_EQ=60
LT_EQ=61
NOT_EQ_1=62
NOT_EQ_2=63
AT=64
ARROW=65
ADD_ASSIGN=66
SUB_ASSIGN=67
MULT_ASSIGN=68
AT_ASSIGN=69
DIV_ASSIGN=70
MOD_ASSIGN=71
AND_ASSIGN=72
OR_ASSIGN=73
XOR_ASSIGN=74
LEFT_SHIFT_ASSIGN=75
RIGHT_SHIFT_ASSIGN=76
POWER_ASSIGN=77
IDIV_ASSIGN=78
SKIP_=79
UNKNOWN_CHAR=80
'def'=6
'return'=7
'if'=8
'elif'=9
'else'=10
'while'=11
'for'=12
'in'=13
'or'=14
'and'=15
'not'=16
'None'=17
'True'=18
'False'=19
'continue'=20
'break'=21
'.'=32
'...'=33
'*'=34
'('=35
')'=36
','=37
':'=38
';'=39
'**'=40
'='=41
'['=42
']'=43
'|'=44
'^'=45
'&'=46
'<<'=47
'>>'=48
'+'=49
'-'=50
'/'=51
'%'=52
'//'=53
'~'=54
'{'=55
'}'=56
'<'=57
'>'=58
'=='=59
'>='=60
'<='=61
'<>'=62
'!='=63
'@'=64
'->'=65
'+='=66
'-='=67
'*='=68
'@='=69
'/='=70
'%='=71
'&='=72
'|='=73
'^='=74
'<<='=75
'>>='=76
'**='=77
'//='=78

3012
generated/Python3Parser.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

661
generated/Python3Parser.h Normal file
View File

@ -0,0 +1,661 @@
// Generated from Python3Parser.g4 by ANTLR 4.13.1
#pragma once
#include "antlr4-runtime.h"
class Python3Parser : public antlr4::Parser {
public:
enum {
INDENT = 1, DEDENT = 2, STRING = 3, NUMBER = 4, INTEGER = 5, DEF = 6,
RETURN = 7, IF = 8, ELIF = 9, ELSE = 10, WHILE = 11, FOR = 12, IN = 13,
OR = 14, AND = 15, NOT = 16, NONE = 17, TRUE = 18, FALSE = 19, CONTINUE = 20,
BREAK = 21, NEWLINE = 22, NAME = 23, STRING_LITERAL = 24, BYTES_LITERAL = 25,
DECIMAL_INTEGER = 26, OCT_INTEGER = 27, HEX_INTEGER = 28, BIN_INTEGER = 29,
FLOAT_NUMBER = 30, IMAG_NUMBER = 31, DOT = 32, ELLIPSIS = 33, STAR = 34,
OPEN_PAREN = 35, CLOSE_PAREN = 36, COMMA = 37, COLON = 38, SEMI_COLON = 39,
POWER = 40, ASSIGN = 41, OPEN_BRACK = 42, CLOSE_BRACK = 43, OR_OP = 44,
XOR = 45, AND_OP = 46, LEFT_SHIFT = 47, RIGHT_SHIFT = 48, ADD = 49,
MINUS = 50, DIV = 51, MOD = 52, IDIV = 53, NOT_OP = 54, OPEN_BRACE = 55,
CLOSE_BRACE = 56, LESS_THAN = 57, GREATER_THAN = 58, EQUALS = 59, GT_EQ = 60,
LT_EQ = 61, NOT_EQ_1 = 62, NOT_EQ_2 = 63, AT = 64, ARROW = 65, ADD_ASSIGN = 66,
SUB_ASSIGN = 67, MULT_ASSIGN = 68, AT_ASSIGN = 69, DIV_ASSIGN = 70,
MOD_ASSIGN = 71, AND_ASSIGN = 72, OR_ASSIGN = 73, XOR_ASSIGN = 74, LEFT_SHIFT_ASSIGN = 75,
RIGHT_SHIFT_ASSIGN = 76, POWER_ASSIGN = 77, IDIV_ASSIGN = 78, SKIP_ = 79,
UNKNOWN_CHAR = 80
};
enum {
RuleFile_input = 0, RuleFuncdef = 1, RuleParameters = 2, RuleTypedargslist = 3,
RuleTfpdef = 4, RuleStmt = 5, RuleSimple_stmt = 6, RuleSmall_stmt = 7,
RuleExpr_stmt = 8, RuleAugassign = 9, RuleFlow_stmt = 10, RuleBreak_stmt = 11,
RuleContinue_stmt = 12, RuleReturn_stmt = 13, RuleCompound_stmt = 14,
RuleIf_stmt = 15, RuleWhile_stmt = 16, RuleSuite = 17, RuleTest = 18,
RuleOr_test = 19, RuleAnd_test = 20, RuleNot_test = 21, RuleComparison = 22,
RuleComp_op = 23, RuleArith_expr = 24, RuleAddorsub_op = 25, RuleTerm = 26,
RuleMuldivmod_op = 27, RuleFactor = 28, RuleAtom_expr = 29, RuleTrailer = 30,
RuleAtom = 31, RuleTestlist = 32, RuleArglist = 33, RuleArgument = 34
};
explicit Python3Parser(antlr4::TokenStream *input);
Python3Parser(antlr4::TokenStream *input, const antlr4::atn::ParserATNSimulatorOptions &options);
~Python3Parser() override;
std::string getGrammarFileName() const override;
const antlr4::atn::ATN& getATN() const override;
const std::vector<std::string>& getRuleNames() const override;
const antlr4::dfa::Vocabulary& getVocabulary() const override;
antlr4::atn::SerializedATNView getSerializedATN() const override;
class File_inputContext;
class FuncdefContext;
class ParametersContext;
class TypedargslistContext;
class TfpdefContext;
class StmtContext;
class Simple_stmtContext;
class Small_stmtContext;
class Expr_stmtContext;
class AugassignContext;
class Flow_stmtContext;
class Break_stmtContext;
class Continue_stmtContext;
class Return_stmtContext;
class Compound_stmtContext;
class If_stmtContext;
class While_stmtContext;
class SuiteContext;
class TestContext;
class Or_testContext;
class And_testContext;
class Not_testContext;
class ComparisonContext;
class Comp_opContext;
class Arith_exprContext;
class Addorsub_opContext;
class TermContext;
class Muldivmod_opContext;
class FactorContext;
class Atom_exprContext;
class TrailerContext;
class AtomContext;
class TestlistContext;
class ArglistContext;
class ArgumentContext;
class File_inputContext : public antlr4::ParserRuleContext {
public:
File_inputContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *EOF();
std::vector<antlr4::tree::TerminalNode *> NEWLINE();
antlr4::tree::TerminalNode* NEWLINE(size_t i);
std::vector<StmtContext *> stmt();
StmtContext* stmt(size_t i);
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
File_inputContext* file_input();
class FuncdefContext : public antlr4::ParserRuleContext {
public:
FuncdefContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *DEF();
antlr4::tree::TerminalNode *NAME();
ParametersContext *parameters();
antlr4::tree::TerminalNode *COLON();
SuiteContext *suite();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
FuncdefContext* funcdef();
class ParametersContext : public antlr4::ParserRuleContext {
public:
ParametersContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *OPEN_PAREN();
antlr4::tree::TerminalNode *CLOSE_PAREN();
TypedargslistContext *typedargslist();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
ParametersContext* parameters();
class TypedargslistContext : public antlr4::ParserRuleContext {
public:
TypedargslistContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
std::vector<TfpdefContext *> tfpdef();
TfpdefContext* tfpdef(size_t i);
std::vector<antlr4::tree::TerminalNode *> ASSIGN();
antlr4::tree::TerminalNode* ASSIGN(size_t i);
std::vector<TestContext *> test();
TestContext* test(size_t i);
std::vector<antlr4::tree::TerminalNode *> COMMA();
antlr4::tree::TerminalNode* COMMA(size_t i);
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
TypedargslistContext* typedargslist();
class TfpdefContext : public antlr4::ParserRuleContext {
public:
TfpdefContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *NAME();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
TfpdefContext* tfpdef();
class StmtContext : public antlr4::ParserRuleContext {
public:
StmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
Simple_stmtContext *simple_stmt();
Compound_stmtContext *compound_stmt();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
StmtContext* stmt();
class Simple_stmtContext : public antlr4::ParserRuleContext {
public:
Simple_stmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
Small_stmtContext *small_stmt();
antlr4::tree::TerminalNode *NEWLINE();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
Simple_stmtContext* simple_stmt();
class Small_stmtContext : public antlr4::ParserRuleContext {
public:
Small_stmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
Expr_stmtContext *expr_stmt();
Flow_stmtContext *flow_stmt();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
Small_stmtContext* small_stmt();
class Expr_stmtContext : public antlr4::ParserRuleContext {
public:
Expr_stmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
std::vector<TestlistContext *> testlist();
TestlistContext* testlist(size_t i);
AugassignContext *augassign();
std::vector<antlr4::tree::TerminalNode *> ASSIGN();
antlr4::tree::TerminalNode* ASSIGN(size_t i);
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
Expr_stmtContext* expr_stmt();
class AugassignContext : public antlr4::ParserRuleContext {
public:
AugassignContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *ADD_ASSIGN();
antlr4::tree::TerminalNode *SUB_ASSIGN();
antlr4::tree::TerminalNode *MULT_ASSIGN();
antlr4::tree::TerminalNode *DIV_ASSIGN();
antlr4::tree::TerminalNode *IDIV_ASSIGN();
antlr4::tree::TerminalNode *MOD_ASSIGN();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
AugassignContext* augassign();
class Flow_stmtContext : public antlr4::ParserRuleContext {
public:
Flow_stmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
Break_stmtContext *break_stmt();
Continue_stmtContext *continue_stmt();
Return_stmtContext *return_stmt();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
Flow_stmtContext* flow_stmt();
class Break_stmtContext : public antlr4::ParserRuleContext {
public:
Break_stmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *BREAK();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
Break_stmtContext* break_stmt();
class Continue_stmtContext : public antlr4::ParserRuleContext {
public:
Continue_stmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *CONTINUE();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
Continue_stmtContext* continue_stmt();
class Return_stmtContext : public antlr4::ParserRuleContext {
public:
Return_stmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *RETURN();
TestlistContext *testlist();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
Return_stmtContext* return_stmt();
class Compound_stmtContext : public antlr4::ParserRuleContext {
public:
Compound_stmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
If_stmtContext *if_stmt();
While_stmtContext *while_stmt();
FuncdefContext *funcdef();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
Compound_stmtContext* compound_stmt();
class If_stmtContext : public antlr4::ParserRuleContext {
public:
If_stmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *IF();
std::vector<TestContext *> test();
TestContext* test(size_t i);
std::vector<antlr4::tree::TerminalNode *> COLON();
antlr4::tree::TerminalNode* COLON(size_t i);
std::vector<SuiteContext *> suite();
SuiteContext* suite(size_t i);
std::vector<antlr4::tree::TerminalNode *> ELIF();
antlr4::tree::TerminalNode* ELIF(size_t i);
antlr4::tree::TerminalNode *ELSE();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
If_stmtContext* if_stmt();
class While_stmtContext : public antlr4::ParserRuleContext {
public:
While_stmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *WHILE();
TestContext *test();
antlr4::tree::TerminalNode *COLON();
SuiteContext *suite();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
While_stmtContext* while_stmt();
class SuiteContext : public antlr4::ParserRuleContext {
public:
SuiteContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
Simple_stmtContext *simple_stmt();
antlr4::tree::TerminalNode *NEWLINE();
antlr4::tree::TerminalNode *INDENT();
antlr4::tree::TerminalNode *DEDENT();
std::vector<StmtContext *> stmt();
StmtContext* stmt(size_t i);
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
SuiteContext* suite();
class TestContext : public antlr4::ParserRuleContext {
public:
TestContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
Or_testContext *or_test();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
TestContext* test();
class Or_testContext : public antlr4::ParserRuleContext {
public:
Or_testContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
std::vector<And_testContext *> and_test();
And_testContext* and_test(size_t i);
std::vector<antlr4::tree::TerminalNode *> OR();
antlr4::tree::TerminalNode* OR(size_t i);
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
Or_testContext* or_test();
class And_testContext : public antlr4::ParserRuleContext {
public:
And_testContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
std::vector<Not_testContext *> not_test();
Not_testContext* not_test(size_t i);
std::vector<antlr4::tree::TerminalNode *> AND();
antlr4::tree::TerminalNode* AND(size_t i);
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
And_testContext* and_test();
class Not_testContext : public antlr4::ParserRuleContext {
public:
Not_testContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *NOT();
Not_testContext *not_test();
ComparisonContext *comparison();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
Not_testContext* not_test();
class ComparisonContext : public antlr4::ParserRuleContext {
public:
ComparisonContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
std::vector<Arith_exprContext *> arith_expr();
Arith_exprContext* arith_expr(size_t i);
std::vector<Comp_opContext *> comp_op();
Comp_opContext* comp_op(size_t i);
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
ComparisonContext* comparison();
class Comp_opContext : public antlr4::ParserRuleContext {
public:
Comp_opContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *LESS_THAN();
antlr4::tree::TerminalNode *GREATER_THAN();
antlr4::tree::TerminalNode *EQUALS();
antlr4::tree::TerminalNode *GT_EQ();
antlr4::tree::TerminalNode *LT_EQ();
antlr4::tree::TerminalNode *NOT_EQ_2();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
Comp_opContext* comp_op();
class Arith_exprContext : public antlr4::ParserRuleContext {
public:
Arith_exprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
std::vector<TermContext *> term();
TermContext* term(size_t i);
std::vector<Addorsub_opContext *> addorsub_op();
Addorsub_opContext* addorsub_op(size_t i);
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
Arith_exprContext* arith_expr();
class Addorsub_opContext : public antlr4::ParserRuleContext {
public:
Addorsub_opContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *ADD();
antlr4::tree::TerminalNode *MINUS();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
Addorsub_opContext* addorsub_op();
class TermContext : public antlr4::ParserRuleContext {
public:
TermContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
std::vector<FactorContext *> factor();
FactorContext* factor(size_t i);
std::vector<Muldivmod_opContext *> muldivmod_op();
Muldivmod_opContext* muldivmod_op(size_t i);
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
TermContext* term();
class Muldivmod_opContext : public antlr4::ParserRuleContext {
public:
Muldivmod_opContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *STAR();
antlr4::tree::TerminalNode *DIV();
antlr4::tree::TerminalNode *IDIV();
antlr4::tree::TerminalNode *MOD();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
Muldivmod_opContext* muldivmod_op();
class FactorContext : public antlr4::ParserRuleContext {
public:
FactorContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
FactorContext *factor();
antlr4::tree::TerminalNode *ADD();
antlr4::tree::TerminalNode *MINUS();
Atom_exprContext *atom_expr();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
FactorContext* factor();
class Atom_exprContext : public antlr4::ParserRuleContext {
public:
Atom_exprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
AtomContext *atom();
TrailerContext *trailer();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
Atom_exprContext* atom_expr();
class TrailerContext : public antlr4::ParserRuleContext {
public:
TrailerContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *OPEN_PAREN();
antlr4::tree::TerminalNode *CLOSE_PAREN();
ArglistContext *arglist();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
TrailerContext* trailer();
class AtomContext : public antlr4::ParserRuleContext {
public:
AtomContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *NAME();
antlr4::tree::TerminalNode *NUMBER();
antlr4::tree::TerminalNode *NONE();
antlr4::tree::TerminalNode *TRUE();
antlr4::tree::TerminalNode *FALSE();
antlr4::tree::TerminalNode *OPEN_PAREN();
TestContext *test();
antlr4::tree::TerminalNode *CLOSE_PAREN();
std::vector<antlr4::tree::TerminalNode *> STRING();
antlr4::tree::TerminalNode* STRING(size_t i);
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
AtomContext* atom();
class TestlistContext : public antlr4::ParserRuleContext {
public:
TestlistContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
std::vector<TestContext *> test();
TestContext* test(size_t i);
std::vector<antlr4::tree::TerminalNode *> COMMA();
antlr4::tree::TerminalNode* COMMA(size_t i);
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
TestlistContext* testlist();
class ArglistContext : public antlr4::ParserRuleContext {
public:
ArglistContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
std::vector<ArgumentContext *> argument();
ArgumentContext* argument(size_t i);
std::vector<antlr4::tree::TerminalNode *> COMMA();
antlr4::tree::TerminalNode* COMMA(size_t i);
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
ArglistContext* arglist();
class ArgumentContext : public antlr4::ParserRuleContext {
public:
ArgumentContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
std::vector<TestContext *> test();
TestContext* test(size_t i);
antlr4::tree::TerminalNode *ASSIGN();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
ArgumentContext* argument();
// 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:
};

206
generated/Python3Parser.interp Normal file
View File

File diff suppressed because one or more lines are too long

143
generated/Python3Parser.tokens Normal file
View File

@ -0,0 +1,143 @@
INDENT=1
DEDENT=2
STRING=3
NUMBER=4
INTEGER=5
DEF=6
RETURN=7
IF=8
ELIF=9
ELSE=10
WHILE=11
FOR=12
IN=13
OR=14
AND=15
NOT=16
NONE=17
TRUE=18
FALSE=19
CONTINUE=20
BREAK=21
NEWLINE=22
NAME=23
STRING_LITERAL=24
BYTES_LITERAL=25
DECIMAL_INTEGER=26
OCT_INTEGER=27
HEX_INTEGER=28
BIN_INTEGER=29
FLOAT_NUMBER=30
IMAG_NUMBER=31
DOT=32
ELLIPSIS=33
STAR=34
OPEN_PAREN=35
CLOSE_PAREN=36
COMMA=37
COLON=38
SEMI_COLON=39
POWER=40
ASSIGN=41
OPEN_BRACK=42
CLOSE_BRACK=43
OR_OP=44
XOR=45
AND_OP=46
LEFT_SHIFT=47
RIGHT_SHIFT=48
ADD=49
MINUS=50
DIV=51
MOD=52
IDIV=53
NOT_OP=54
OPEN_BRACE=55
CLOSE_BRACE=56
LESS_THAN=57
GREATER_THAN=58
EQUALS=59
GT_EQ=60
LT_EQ=61
NOT_EQ_1=62
NOT_EQ_2=63
AT=64
ARROW=65
ADD_ASSIGN=66
SUB_ASSIGN=67
MULT_ASSIGN=68
AT_ASSIGN=69
DIV_ASSIGN=70
MOD_ASSIGN=71
AND_ASSIGN=72
OR_ASSIGN=73
XOR_ASSIGN=74
LEFT_SHIFT_ASSIGN=75
RIGHT_SHIFT_ASSIGN=76
POWER_ASSIGN=77
IDIV_ASSIGN=78
SKIP_=79
UNKNOWN_CHAR=80
'def'=6
'return'=7
'if'=8
'elif'=9
'else'=10
'while'=11
'for'=12
'in'=13
'or'=14
'and'=15
'not'=16
'None'=17
'True'=18
'False'=19
'continue'=20
'break'=21
'.'=32
'...'=33
'*'=34
'('=35
')'=36
','=37
':'=38
';'=39
'**'=40
'='=41
'['=42
']'=43
'|'=44
'^'=45
'&'=46
'<<'=47
'>>'=48
'+'=49
'-'=50
'/'=51
'%'=52
'//'=53
'~'=54
'{'=55
'}'=56
'<'=57
'>'=58
'=='=59
'>='=60
'<='=61
'<>'=62
'!='=63
'@'=64
'->'=65
'+='=66
'-='=67
'*='=68
'@='=69
'/='=70
'%='=71
'&='=72
'|='=73
'^='=74
'<<='=75
'>>='=76
'**='=77
'//='=78

7
generated/Python3ParserBaseVisitor.cpp Normal file
View File

@ -0,0 +1,7 @@
// Generated from Python3Parser.g4 by ANTLR 4.13.1
#include "Python3ParserBaseVisitor.h"

160
generated/Python3ParserBaseVisitor.h Normal file
View File

@ -0,0 +1,160 @@
// Generated from Python3Parser.g4 by ANTLR 4.13.1
#pragma once
#include "antlr4-runtime.h"
#include "Python3ParserVisitor.h"
/**
* This class provides an empty implementation of Python3ParserVisitor, which can be
* extended to create a visitor which only needs to handle a subset of the available methods.
*/
class Python3ParserBaseVisitor : public Python3ParserVisitor {
public:
virtual std::any visitFile_input(Python3Parser::File_inputContext *ctx) override {
return visitChildren(ctx);
}
virtual std::any visitFuncdef(Python3Parser::FuncdefContext *ctx) override {
return visitChildren(ctx);
}
virtual std::any visitParameters(Python3Parser::ParametersContext *ctx) override {
return visitChildren(ctx);
}
virtual std::any visitTypedargslist(Python3Parser::TypedargslistContext *ctx) override {
return visitChildren(ctx);
}
virtual std::any visitTfpdef(Python3Parser::TfpdefContext *ctx) override {
return visitChildren(ctx);
}
virtual std::any visitStmt(Python3Parser::StmtContext *ctx) override {
return visitChildren(ctx);
}
virtual std::any visitSimple_stmt(Python3Parser::Simple_stmtContext *ctx) override {
return visitChildren(ctx);
}
virtual std::any visitSmall_stmt(Python3Parser::Small_stmtContext *ctx) override {
return visitChildren(ctx);
}
virtual std::any visitExpr_stmt(Python3Parser::Expr_stmtContext *ctx) override {
return visitChildren(ctx);
}
virtual std::any visitAugassign(Python3Parser::AugassignContext *ctx) override {
return visitChildren(ctx);
}
virtual std::any visitFlow_stmt(Python3Parser::Flow_stmtContext *ctx) override {
return visitChildren(ctx);
}
virtual std::any visitBreak_stmt(Python3Parser::Break_stmtContext *ctx) override {
return visitChildren(ctx);
}
virtual std::any visitContinue_stmt(Python3Parser::Continue_stmtContext *ctx) override {
return visitChildren(ctx);
}
virtual std::any visitReturn_stmt(Python3Parser::Return_stmtContext *ctx) override {
return visitChildren(ctx);
}
virtual std::any visitCompound_stmt(Python3Parser::Compound_stmtContext *ctx) override {
return visitChildren(ctx);
}
virtual std::any visitIf_stmt(Python3Parser::If_stmtContext *ctx) override {
return visitChildren(ctx);
}
virtual std::any visitWhile_stmt(Python3Parser::While_stmtContext *ctx) override {
return visitChildren(ctx);
}
virtual std::any visitSuite(Python3Parser::SuiteContext *ctx) override {
return visitChildren(ctx);
}
virtual std::any visitTest(Python3Parser::TestContext *ctx) override {
return visitChildren(ctx);
}
virtual std::any visitOr_test(Python3Parser::Or_testContext *ctx) override {
return visitChildren(ctx);
}
virtual std::any visitAnd_test(Python3Parser::And_testContext *ctx) override {
return visitChildren(ctx);
}
virtual std::any visitNot_test(Python3Parser::Not_testContext *ctx) override {
return visitChildren(ctx);
}
virtual std::any visitComparison(Python3Parser::ComparisonContext *ctx) override {
return visitChildren(ctx);
}
virtual std::any visitComp_op(Python3Parser::Comp_opContext *ctx) override {
return visitChildren(ctx);
}
virtual std::any visitArith_expr(Python3Parser::Arith_exprContext *ctx) override {
return visitChildren(ctx);
}
virtual std::any visitAddorsub_op(Python3Parser::Addorsub_opContext *ctx) override {
return visitChildren(ctx);
}
virtual std::any visitTerm(Python3Parser::TermContext *ctx) override {
return visitChildren(ctx);
}
virtual std::any visitMuldivmod_op(Python3Parser::Muldivmod_opContext *ctx) override {
return visitChildren(ctx);
}
virtual std::any visitFactor(Python3Parser::FactorContext *ctx) override {
return visitChildren(ctx);
}
virtual std::any visitAtom_expr(Python3Parser::Atom_exprContext *ctx) override {
return visitChildren(ctx);
}
virtual std::any visitTrailer(Python3Parser::TrailerContext *ctx) override {
return visitChildren(ctx);
}
virtual std::any visitAtom(Python3Parser::AtomContext *ctx) override {
return visitChildren(ctx);
}
virtual std::any visitTestlist(Python3Parser::TestlistContext *ctx) override {
return visitChildren(ctx);
}
virtual std::any visitArglist(Python3Parser::ArglistContext *ctx) override {
return visitChildren(ctx);
}
virtual std::any visitArgument(Python3Parser::ArgumentContext *ctx) override {
return visitChildren(ctx);
}
};

7
generated/Python3ParserVisitor.cpp Normal file
View File

@ -0,0 +1,7 @@
// Generated from Python3Parser.g4 by ANTLR 4.13.1
#include "Python3ParserVisitor.h"

94
generated/Python3ParserVisitor.h Normal file
View File

@ -0,0 +1,94 @@
// Generated from Python3Parser.g4 by ANTLR 4.13.1
#pragma once
#include "antlr4-runtime.h"
#include "Python3Parser.h"
/**
* This class defines an abstract visitor for a parse tree
* produced by Python3Parser.
*/
class Python3ParserVisitor : public antlr4::tree::AbstractParseTreeVisitor {
public:
/**
* Visit parse trees produced by Python3Parser.
*/
virtual std::any visitFile_input(Python3Parser::File_inputContext *context) = 0;
virtual std::any visitFuncdef(Python3Parser::FuncdefContext *context) = 0;
virtual std::any visitParameters(Python3Parser::ParametersContext *context) = 0;
virtual std::any visitTypedargslist(Python3Parser::TypedargslistContext *context) = 0;
virtual std::any visitTfpdef(Python3Parser::TfpdefContext *context) = 0;
virtual std::any visitStmt(Python3Parser::StmtContext *context) = 0;
virtual std::any visitSimple_stmt(Python3Parser::Simple_stmtContext *context) = 0;
virtual std::any visitSmall_stmt(Python3Parser::Small_stmtContext *context) = 0;
virtual std::any visitExpr_stmt(Python3Parser::Expr_stmtContext *context) = 0;
virtual std::any visitAugassign(Python3Parser::AugassignContext *context) = 0;
virtual std::any visitFlow_stmt(Python3Parser::Flow_stmtContext *context) = 0;
virtual std::any visitBreak_stmt(Python3Parser::Break_stmtContext *context) = 0;
virtual std::any visitContinue_stmt(Python3Parser::Continue_stmtContext *context) = 0;
virtual std::any visitReturn_stmt(Python3Parser::Return_stmtContext *context) = 0;
virtual std::any visitCompound_stmt(Python3Parser::Compound_stmtContext *context) = 0;
virtual std::any visitIf_stmt(Python3Parser::If_stmtContext *context) = 0;
virtual std::any visitWhile_stmt(Python3Parser::While_stmtContext *context) = 0;
virtual std::any visitSuite(Python3Parser::SuiteContext *context) = 0;
virtual std::any visitTest(Python3Parser::TestContext *context) = 0;
virtual std::any visitOr_test(Python3Parser::Or_testContext *context) = 0;
virtual std::any visitAnd_test(Python3Parser::And_testContext *context) = 0;
virtual std::any visitNot_test(Python3Parser::Not_testContext *context) = 0;
virtual std::any visitComparison(Python3Parser::ComparisonContext *context) = 0;
virtual std::any visitComp_op(Python3Parser::Comp_opContext *context) = 0;
virtual std::any visitArith_expr(Python3Parser::Arith_exprContext *context) = 0;
virtual std::any visitAddorsub_op(Python3Parser::Addorsub_opContext *context) = 0;
virtual std::any visitTerm(Python3Parser::TermContext *context) = 0;
virtual std::any visitMuldivmod_op(Python3Parser::Muldivmod_opContext *context) = 0;
virtual std::any visitFactor(Python3Parser::FactorContext *context) = 0;
virtual std::any visitAtom_expr(Python3Parser::Atom_exprContext *context) = 0;
virtual std::any visitTrailer(Python3Parser::TrailerContext *context) = 0;
virtual std::any visitAtom(Python3Parser::AtomContext *context) = 0;
virtual std::any visitTestlist(Python3Parser::TestlistContext *context) = 0;
virtual std::any visitArglist(Python3Parser::ArglistContext *context) = 0;
virtual std::any visitArgument(Python3Parser::ArgumentContext *context) = 0;
};