# Generated from Pseudocode.g4 by ANTLR 4.13.2 # encoding: utf-8 from antlr4 import * from io import StringIO import sys if sys.version_info[1] > 5: from typing import TextIO else: from typing.io import TextIO def serializedATN(): return [ 4,1,46,514,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,1,0,5,0,66,8,0, 10,0,12,0,69,9,0,1,0,1,0,4,0,73,8,0,11,0,12,0,74,1,0,5,0,78,8,0, 10,0,12,0,81,9,0,1,0,5,0,84,8,0,10,0,12,0,87,9,0,1,0,1,0,1,1,3,1, 92,8,1,1,1,1,1,3,1,96,8,1,1,1,1,1,3,1,100,8,1,1,1,1,1,3,1,104,8, 1,1,1,1,1,1,1,3,1,109,8,1,1,1,1,1,3,1,113,8,1,1,1,1,1,3,1,117,8, 1,1,1,1,1,3,1,121,8,1,1,1,3,1,124,8,1,1,1,1,1,3,1,128,8,1,1,1,3, 1,131,8,1,1,1,1,1,3,1,135,8,1,3,1,137,8,1,1,2,1,2,1,2,1,2,1,2,1, 2,3,2,145,8,2,1,3,1,3,1,3,1,3,3,3,151,8,3,1,4,1,4,1,4,1,4,1,4,1, 4,1,4,1,4,1,4,1,4,1,4,1,4,3,4,165,8,4,1,4,1,4,1,4,1,4,1,4,1,4,1, 4,5,4,174,8,4,10,4,12,4,177,9,4,1,4,1,4,3,4,181,8,4,1,5,1,5,1,5, 1,5,1,6,1,6,1,6,1,6,3,6,191,8,6,1,6,1,6,1,6,4,6,196,8,6,11,6,12, 6,197,1,6,1,6,4,6,202,8,6,11,6,12,6,203,1,6,5,6,207,8,6,10,6,12, 6,210,9,6,3,6,212,8,6,1,6,5,6,215,8,6,10,6,12,6,218,9,6,1,6,1,6, 1,6,1,7,1,7,1,7,3,7,226,8,7,1,7,1,7,1,8,1,8,1,8,5,8,233,8,8,10,8, 12,8,236,9,8,1,9,3,9,239,8,9,1,9,1,9,1,10,1,10,1,10,1,10,1,10,1, 10,1,11,1,11,1,11,5,11,252,8,11,10,11,12,11,255,9,11,1,12,1,12,1, 13,1,13,3,13,261,8,13,1,13,1,13,1,13,1,13,1,13,4,13,268,8,13,11, 13,12,13,269,1,13,1,13,4,13,274,8,13,11,13,12,13,275,1,13,5,13,279, 8,13,10,13,12,13,282,9,13,3,13,284,8,13,1,13,5,13,287,8,13,10,13, 12,13,290,9,13,1,13,1,13,1,13,1,14,1,14,3,14,297,8,14,1,14,1,14, 1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,4,14,310,8,14,11,14, 12,14,311,1,14,1,14,1,14,1,14,1,15,1,15,1,15,1,15,1,16,1,16,1,16, 1,16,1,16,1,16,4,16,328,8,16,11,16,12,16,329,1,16,1,16,1,16,1,16, 1,16,1,16,1,16,1,16,4,16,340,8,16,11,16,12,16,341,1,16,1,16,5,16, 346,8,16,10,16,12,16,349,9,16,1,16,1,16,1,16,4,16,354,8,16,11,16, 12,16,355,1,16,3,16,359,8,16,1,16,1,16,1,16,1,17,1,17,1,17,1,17, 1,17,1,17,4,17,370,8,17,11,17,12,17,371,1,17,1,17,4,17,376,8,17, 11,17,12,17,377,1,17,5,17,381,8,17,10,17,12,17,384,9,17,3,17,386, 8,17,1,17,5,17,389,8,17,10,17,12,17,392,9,17,1,17,1,17,1,17,1,18, 1,18,1,18,1,19,1,19,1,20,1,20,4,20,404,8,20,11,20,12,20,405,1,20, 5,20,409,8,20,10,20,12,20,412,9,20,3,20,414,8,20,1,20,5,20,417,8, 20,10,20,12,20,420,9,20,1,21,1,21,1,22,1,22,1,22,4,22,427,8,22,11, 22,12,22,428,1,22,3,22,432,8,22,1,23,1,23,1,23,4,23,437,8,23,11, 23,12,23,438,1,23,3,23,442,8,23,1,24,1,24,1,24,1,24,1,24,3,24,449, 8,24,1,25,1,25,1,25,4,25,454,8,25,11,25,12,25,455,1,25,3,25,459, 8,25,1,26,1,26,1,26,4,26,464,8,26,11,26,12,26,465,1,26,3,26,469, 8,26,1,27,1,27,1,27,4,27,474,8,27,11,27,12,27,475,1,27,3,27,479, 8,27,1,28,1,28,1,28,3,28,484,8,28,1,29,1,29,1,29,1,29,1,29,1,29, 1,29,3,29,493,8,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,3,29,502,8, 29,1,30,1,30,1,30,5,30,507,8,30,10,30,12,30,510,9,30,1,31,1,31,1, 31,0,0,32,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,0,7,4,0,29,29,31,31,33,33,35, 35,2,0,17,17,19,20,1,0,42,43,2,0,22,22,24,27,2,0,32,32,34,34,2,0, 30,30,36,36,2,0,12,13,16,20,561,0,67,1,0,0,0,2,136,1,0,0,0,4,144, 1,0,0,0,6,146,1,0,0,0,8,180,1,0,0,0,10,182,1,0,0,0,12,186,1,0,0, 0,14,222,1,0,0,0,16,229,1,0,0,0,18,238,1,0,0,0,20,242,1,0,0,0,22, 248,1,0,0,0,24,256,1,0,0,0,26,258,1,0,0,0,28,294,1,0,0,0,30,317, 1,0,0,0,32,321,1,0,0,0,34,363,1,0,0,0,36,396,1,0,0,0,38,399,1,0, 0,0,40,413,1,0,0,0,42,421,1,0,0,0,44,431,1,0,0,0,46,441,1,0,0,0, 48,448,1,0,0,0,50,458,1,0,0,0,52,468,1,0,0,0,54,478,1,0,0,0,56,483, 1,0,0,0,58,501,1,0,0,0,60,503,1,0,0,0,62,511,1,0,0,0,64,66,5,45, 0,0,65,64,1,0,0,0,66,69,1,0,0,0,67,65,1,0,0,0,67,68,1,0,0,0,68,70, 1,0,0,0,69,67,1,0,0,0,70,79,3,2,1,0,71,73,5,45,0,0,72,71,1,0,0,0, 73,74,1,0,0,0,74,72,1,0,0,0,74,75,1,0,0,0,75,76,1,0,0,0,76,78,3, 2,1,0,77,72,1,0,0,0,78,81,1,0,0,0,79,77,1,0,0,0,79,80,1,0,0,0,80, 85,1,0,0,0,81,79,1,0,0,0,82,84,5,45,0,0,83,82,1,0,0,0,84,87,1,0, 0,0,85,83,1,0,0,0,85,86,1,0,0,0,86,88,1,0,0,0,87,85,1,0,0,0,88,89, 5,0,0,1,89,1,1,0,0,0,90,92,3,20,10,0,91,90,1,0,0,0,91,92,1,0,0,0, 92,93,1,0,0,0,93,95,3,6,3,0,94,96,5,43,0,0,95,94,1,0,0,0,95,96,1, 0,0,0,96,137,1,0,0,0,97,137,3,12,6,0,98,100,3,20,10,0,99,98,1,0, 0,0,99,100,1,0,0,0,100,101,1,0,0,0,101,103,3,14,7,0,102,104,5,43, 0,0,103,102,1,0,0,0,103,104,1,0,0,0,104,137,1,0,0,0,105,137,3,26, 13,0,106,137,3,28,14,0,107,109,3,20,10,0,108,107,1,0,0,0,108,109, 1,0,0,0,109,110,1,0,0,0,110,137,3,32,16,0,111,113,3,20,10,0,112, 111,1,0,0,0,112,113,1,0,0,0,113,114,1,0,0,0,114,137,3,34,17,0,115, 117,3,20,10,0,116,115,1,0,0,0,116,117,1,0,0,0,117,118,1,0,0,0,118, 120,3,36,18,0,119,121,5,43,0,0,120,119,1,0,0,0,120,121,1,0,0,0,121, 137,1,0,0,0,122,124,3,20,10,0,123,122,1,0,0,0,123,124,1,0,0,0,124, 125,1,0,0,0,125,127,3,38,19,0,126,128,5,43,0,0,127,126,1,0,0,0,127, 128,1,0,0,0,128,137,1,0,0,0,129,131,3,20,10,0,130,129,1,0,0,0,130, 131,1,0,0,0,131,132,1,0,0,0,132,134,3,10,5,0,133,135,5,43,0,0,134, 133,1,0,0,0,134,135,1,0,0,0,135,137,1,0,0,0,136,91,1,0,0,0,136,97, 1,0,0,0,136,99,1,0,0,0,136,105,1,0,0,0,136,106,1,0,0,0,136,108,1, 0,0,0,136,112,1,0,0,0,136,116,1,0,0,0,136,123,1,0,0,0,136,130,1, 0,0,0,137,3,1,0,0,0,138,139,5,17,0,0,139,140,5,37,0,0,140,141,3, 42,21,0,141,142,5,38,0,0,142,145,1,0,0,0,143,145,5,17,0,0,144,138, 1,0,0,0,144,143,1,0,0,0,145,5,1,0,0,0,146,147,3,4,2,0,147,150,5, 23,0,0,148,151,3,42,21,0,149,151,3,8,4,0,150,148,1,0,0,0,150,149, 1,0,0,0,151,7,1,0,0,0,152,153,5,1,0,0,153,154,5,37,0,0,154,155,3, 42,21,0,155,156,5,2,0,0,156,157,3,42,21,0,157,158,5,38,0,0,158,181, 1,0,0,0,159,160,5,1,0,0,160,161,5,39,0,0,161,164,3,42,21,0,162,163, 5,42,0,0,163,165,3,42,21,0,164,162,1,0,0,0,164,165,1,0,0,0,165,166, 1,0,0,0,166,167,5,40,0,0,167,181,1,0,0,0,168,169,5,1,0,0,169,170, 5,37,0,0,170,175,3,42,21,0,171,172,5,42,0,0,172,174,3,42,21,0,173, 171,1,0,0,0,174,177,1,0,0,0,175,173,1,0,0,0,175,176,1,0,0,0,176, 178,1,0,0,0,177,175,1,0,0,0,178,179,5,38,0,0,179,181,1,0,0,0,180, 152,1,0,0,0,180,159,1,0,0,0,180,168,1,0,0,0,181,9,1,0,0,0,182,183, 3,4,2,0,183,184,7,0,0,0,184,185,3,42,21,0,185,11,1,0,0,0,186,187, 5,3,0,0,187,188,5,17,0,0,188,190,5,39,0,0,189,191,3,16,8,0,190,189, 1,0,0,0,190,191,1,0,0,0,191,192,1,0,0,0,192,193,5,40,0,0,193,195, 5,41,0,0,194,196,5,45,0,0,195,194,1,0,0,0,196,197,1,0,0,0,197,195, 1,0,0,0,197,198,1,0,0,0,198,211,1,0,0,0,199,208,3,2,1,0,200,202, 5,45,0,0,201,200,1,0,0,0,202,203,1,0,0,0,203,201,1,0,0,0,203,204, 1,0,0,0,204,205,1,0,0,0,205,207,3,2,1,0,206,201,1,0,0,0,207,210, 1,0,0,0,208,206,1,0,0,0,208,209,1,0,0,0,209,212,1,0,0,0,210,208, 1,0,0,0,211,199,1,0,0,0,211,212,1,0,0,0,212,216,1,0,0,0,213,215, 5,45,0,0,214,213,1,0,0,0,215,218,1,0,0,0,216,214,1,0,0,0,216,217, 1,0,0,0,217,219,1,0,0,0,218,216,1,0,0,0,219,220,5,9,0,0,220,221, 5,3,0,0,221,13,1,0,0,0,222,223,5,17,0,0,223,225,5,39,0,0,224,226, 3,60,30,0,225,224,1,0,0,0,225,226,1,0,0,0,226,227,1,0,0,0,227,228, 5,40,0,0,228,15,1,0,0,0,229,234,3,18,9,0,230,231,5,42,0,0,231,233, 3,18,9,0,232,230,1,0,0,0,233,236,1,0,0,0,234,232,1,0,0,0,234,235, 1,0,0,0,235,17,1,0,0,0,236,234,1,0,0,0,237,239,3,20,10,0,238,237, 1,0,0,0,238,239,1,0,0,0,239,240,1,0,0,0,240,241,5,17,0,0,241,19, 1,0,0,0,242,243,5,44,0,0,243,244,5,17,0,0,244,245,5,25,0,0,245,246, 3,22,11,0,246,247,5,27,0,0,247,21,1,0,0,0,248,253,3,24,12,0,249, 250,5,42,0,0,250,252,3,24,12,0,251,249,1,0,0,0,252,255,1,0,0,0,253, 251,1,0,0,0,253,254,1,0,0,0,254,23,1,0,0,0,255,253,1,0,0,0,256,257, 7,1,0,0,257,25,1,0,0,0,258,260,5,4,0,0,259,261,3,20,10,0,260,259, 1,0,0,0,260,261,1,0,0,0,261,262,1,0,0,0,262,263,5,17,0,0,263,264, 5,5,0,0,264,265,5,17,0,0,265,267,5,41,0,0,266,268,5,45,0,0,267,266, 1,0,0,0,268,269,1,0,0,0,269,267,1,0,0,0,269,270,1,0,0,0,270,283, 1,0,0,0,271,280,3,2,1,0,272,274,5,45,0,0,273,272,1,0,0,0,274,275, 1,0,0,0,275,273,1,0,0,0,275,276,1,0,0,0,276,277,1,0,0,0,277,279, 3,2,1,0,278,273,1,0,0,0,279,282,1,0,0,0,280,278,1,0,0,0,280,281, 1,0,0,0,281,284,1,0,0,0,282,280,1,0,0,0,283,271,1,0,0,0,283,284, 1,0,0,0,284,288,1,0,0,0,285,287,5,45,0,0,286,285,1,0,0,0,287,290, 1,0,0,0,288,286,1,0,0,0,288,289,1,0,0,0,289,291,1,0,0,0,290,288, 1,0,0,0,291,292,5,9,0,0,292,293,5,4,0,0,293,27,1,0,0,0,294,296,5, 4,0,0,295,297,3,20,10,0,296,295,1,0,0,0,296,297,1,0,0,0,297,298, 1,0,0,0,298,299,5,39,0,0,299,300,5,17,0,0,300,301,5,23,0,0,301,302, 3,42,21,0,302,303,7,2,0,0,303,304,3,42,21,0,304,305,7,2,0,0,305, 306,3,30,15,0,306,307,5,40,0,0,307,309,5,41,0,0,308,310,5,45,0,0, 309,308,1,0,0,0,310,311,1,0,0,0,311,309,1,0,0,0,311,312,1,0,0,0, 312,313,1,0,0,0,313,314,3,40,20,0,314,315,5,9,0,0,315,316,5,4,0, 0,316,29,1,0,0,0,317,318,5,17,0,0,318,319,7,0,0,0,319,320,3,42,21, 0,320,31,1,0,0,0,321,322,5,6,0,0,322,323,5,39,0,0,323,324,3,42,21, 0,324,325,5,40,0,0,325,327,5,41,0,0,326,328,5,45,0,0,327,326,1,0, 0,0,328,329,1,0,0,0,329,327,1,0,0,0,329,330,1,0,0,0,330,331,1,0, 0,0,331,347,3,40,20,0,332,333,5,7,0,0,333,334,5,6,0,0,334,335,5, 39,0,0,335,336,3,42,21,0,336,337,5,40,0,0,337,339,5,41,0,0,338,340, 5,45,0,0,339,338,1,0,0,0,340,341,1,0,0,0,341,339,1,0,0,0,341,342, 1,0,0,0,342,343,1,0,0,0,343,344,3,40,20,0,344,346,1,0,0,0,345,332, 1,0,0,0,346,349,1,0,0,0,347,345,1,0,0,0,347,348,1,0,0,0,348,358, 1,0,0,0,349,347,1,0,0,0,350,351,5,7,0,0,351,353,5,41,0,0,352,354, 5,45,0,0,353,352,1,0,0,0,354,355,1,0,0,0,355,353,1,0,0,0,355,356, 1,0,0,0,356,357,1,0,0,0,357,359,3,40,20,0,358,350,1,0,0,0,358,359, 1,0,0,0,359,360,1,0,0,0,360,361,5,9,0,0,361,362,5,6,0,0,362,33,1, 0,0,0,363,364,5,10,0,0,364,365,5,39,0,0,365,366,3,42,21,0,366,367, 5,40,0,0,367,369,5,41,0,0,368,370,5,45,0,0,369,368,1,0,0,0,370,371, 1,0,0,0,371,369,1,0,0,0,371,372,1,0,0,0,372,385,1,0,0,0,373,382, 3,2,1,0,374,376,5,45,0,0,375,374,1,0,0,0,376,377,1,0,0,0,377,375, 1,0,0,0,377,378,1,0,0,0,378,379,1,0,0,0,379,381,3,2,1,0,380,375, 1,0,0,0,381,384,1,0,0,0,382,380,1,0,0,0,382,383,1,0,0,0,383,386, 1,0,0,0,384,382,1,0,0,0,385,373,1,0,0,0,385,386,1,0,0,0,386,390, 1,0,0,0,387,389,5,45,0,0,388,387,1,0,0,0,389,392,1,0,0,0,390,388, 1,0,0,0,390,391,1,0,0,0,391,393,1,0,0,0,392,390,1,0,0,0,393,394, 5,9,0,0,394,395,5,10,0,0,395,35,1,0,0,0,396,397,5,8,0,0,397,398, 3,42,21,0,398,37,1,0,0,0,399,400,5,11,0,0,400,39,1,0,0,0,401,410, 3,2,1,0,402,404,5,45,0,0,403,402,1,0,0,0,404,405,1,0,0,0,405,403, 1,0,0,0,405,406,1,0,0,0,406,407,1,0,0,0,407,409,3,2,1,0,408,403, 1,0,0,0,409,412,1,0,0,0,410,408,1,0,0,0,410,411,1,0,0,0,411,414, 1,0,0,0,412,410,1,0,0,0,413,401,1,0,0,0,413,414,1,0,0,0,414,418, 1,0,0,0,415,417,5,45,0,0,416,415,1,0,0,0,417,420,1,0,0,0,418,416, 1,0,0,0,418,419,1,0,0,0,419,41,1,0,0,0,420,418,1,0,0,0,421,422,3, 44,22,0,422,43,1,0,0,0,423,426,3,46,23,0,424,425,5,15,0,0,425,427, 3,46,23,0,426,424,1,0,0,0,427,428,1,0,0,0,428,426,1,0,0,0,428,429, 1,0,0,0,429,432,1,0,0,0,430,432,3,46,23,0,431,423,1,0,0,0,431,430, 1,0,0,0,432,45,1,0,0,0,433,436,3,48,24,0,434,435,5,14,0,0,435,437, 3,48,24,0,436,434,1,0,0,0,437,438,1,0,0,0,438,436,1,0,0,0,438,439, 1,0,0,0,439,442,1,0,0,0,440,442,3,48,24,0,441,433,1,0,0,0,441,440, 1,0,0,0,442,47,1,0,0,0,443,444,3,50,25,0,444,445,7,3,0,0,445,446, 3,50,25,0,446,449,1,0,0,0,447,449,3,50,25,0,448,443,1,0,0,0,448, 447,1,0,0,0,449,49,1,0,0,0,450,453,3,52,26,0,451,452,7,4,0,0,452, 454,3,52,26,0,453,451,1,0,0,0,454,455,1,0,0,0,455,453,1,0,0,0,455, 456,1,0,0,0,456,459,1,0,0,0,457,459,3,52,26,0,458,450,1,0,0,0,458, 457,1,0,0,0,459,51,1,0,0,0,460,463,3,54,27,0,461,462,7,5,0,0,462, 464,3,54,27,0,463,461,1,0,0,0,464,465,1,0,0,0,465,463,1,0,0,0,465, 466,1,0,0,0,466,469,1,0,0,0,467,469,3,54,27,0,468,460,1,0,0,0,468, 467,1,0,0,0,469,53,1,0,0,0,470,473,3,56,28,0,471,472,5,28,0,0,472, 474,3,56,28,0,473,471,1,0,0,0,474,475,1,0,0,0,475,473,1,0,0,0,475, 476,1,0,0,0,476,479,1,0,0,0,477,479,3,56,28,0,478,470,1,0,0,0,478, 477,1,0,0,0,479,55,1,0,0,0,480,481,5,34,0,0,481,484,3,56,28,0,482, 484,3,58,29,0,483,480,1,0,0,0,483,482,1,0,0,0,484,57,1,0,0,0,485, 486,5,39,0,0,486,487,3,42,21,0,487,488,5,40,0,0,488,502,1,0,0,0, 489,490,5,17,0,0,490,492,5,39,0,0,491,493,3,60,30,0,492,491,1,0, 0,0,492,493,1,0,0,0,493,494,1,0,0,0,494,502,5,40,0,0,495,496,5,17, 0,0,496,497,5,37,0,0,497,498,3,42,21,0,498,499,5,38,0,0,499,502, 1,0,0,0,500,502,3,62,31,0,501,485,1,0,0,0,501,489,1,0,0,0,501,495, 1,0,0,0,501,500,1,0,0,0,502,59,1,0,0,0,503,508,3,42,21,0,504,505, 5,42,0,0,505,507,3,42,21,0,506,504,1,0,0,0,507,510,1,0,0,0,508,506, 1,0,0,0,508,509,1,0,0,0,509,61,1,0,0,0,510,508,1,0,0,0,511,512,7, 6,0,0,512,63,1,0,0,0,69,67,74,79,85,91,95,99,103,108,112,116,120, 123,127,130,134,136,144,150,164,175,180,190,197,203,208,211,216, 225,234,238,253,260,269,275,280,283,288,296,311,329,341,347,355, 358,371,377,382,385,390,405,410,413,418,428,431,438,441,448,455, 458,465,468,475,478,483,492,501,508 ] class PseudocodeParser ( Parser ): grammarFileName = "Pseudocode.g4" atn = ATNDeserializer().deserialize(serializedATN()) decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ] sharedContextCache = PredictionContextCache() literalNames = [ "", "'arr'", "'to'", "'fun'", "'for'", "'in'", "'if'", "'else'", "'return'", "'end'", "'while'", "'break'", "", "'False'", "'and'", "'or'", "'Null'", "", "", "", "", "", "'=='", "'='", "'<='", "'<'", "'>='", "'>'", "'**'", "'*='", "'*'", "'+='", "'+'", "'-='", "'-'", "'/='", "'/'", "'['", "']'", "'('", "')'", "':'", "','", "';'", "'@'" ] symbolicNames = [ "", "ARR", "TO", "FUN", "FOR", "IN", "IF", "ELSE", "RETURN", "END", "WHILE", "BREAK", "TRUE", "FALSE", "AND", "OR", "NULL", "ID", "FLOAT", "INT", "STRING", "COMMENT", "EQEQ", "EQ", "LESS_EQ", "LOW_THAN", "GREATER_EQ", "GREATER_THAN", "POW", "STAR_EQ", "STAR", "PLUS_EQ", "PLUS", "MINUS_EQ", "MINUS", "SLASH_EQ", "SLASH", "LBRACK", "RBRACK", "LPAREN", "RPAREN", "COLON", "COMMA", "SEMICOLON", "AT", "NL", "WS" ] RULE_program = 0 RULE_statement = 1 RULE_lvalue = 2 RULE_assignment = 3 RULE_arrayInitialization = 4 RULE_compoundAssignment = 5 RULE_functionDecl = 6 RULE_functionCallStatement = 7 RULE_paramList = 8 RULE_annotatedParam = 9 RULE_annotation = 10 RULE_annotationArgList = 11 RULE_annotationArg = 12 RULE_forEachLoop = 13 RULE_regularForLoop = 14 RULE_forUpdate = 15 RULE_ifStatement = 16 RULE_whileLoop = 17 RULE_returnStatement = 18 RULE_breakStatement = 19 RULE_block = 20 RULE_expression = 21 RULE_logicalOrExpression = 22 RULE_logicalAndExpression = 23 RULE_comparisonExpression = 24 RULE_additiveExpression = 25 RULE_multiplicativeExpression = 26 RULE_powerExpression = 27 RULE_unaryExpression = 28 RULE_primaryExpression = 29 RULE_expressionList = 30 RULE_atom = 31 ruleNames = [ "program", "statement", "lvalue", "assignment", "arrayInitialization", "compoundAssignment", "functionDecl", "functionCallStatement", "paramList", "annotatedParam", "annotation", "annotationArgList", "annotationArg", "forEachLoop", "regularForLoop", "forUpdate", "ifStatement", "whileLoop", "returnStatement", "breakStatement", "block", "expression", "logicalOrExpression", "logicalAndExpression", "comparisonExpression", "additiveExpression", "multiplicativeExpression", "powerExpression", "unaryExpression", "primaryExpression", "expressionList", "atom" ] EOF = Token.EOF ARR=1 TO=2 FUN=3 FOR=4 IN=5 IF=6 ELSE=7 RETURN=8 END=9 WHILE=10 BREAK=11 TRUE=12 FALSE=13 AND=14 OR=15 NULL=16 ID=17 FLOAT=18 INT=19 STRING=20 COMMENT=21 EQEQ=22 EQ=23 LESS_EQ=24 LOW_THAN=25 GREATER_EQ=26 GREATER_THAN=27 POW=28 STAR_EQ=29 STAR=30 PLUS_EQ=31 PLUS=32 MINUS_EQ=33 MINUS=34 SLASH_EQ=35 SLASH=36 LBRACK=37 RBRACK=38 LPAREN=39 RPAREN=40 COLON=41 COMMA=42 SEMICOLON=43 AT=44 NL=45 WS=46 def __init__(self, input:TokenStream, output:TextIO = sys.stdout): super().__init__(input, output) self.checkVersion("4.13.2") self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache) self._predicates = None class ProgramContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def statement(self, i:int=None): if i is None: return self.getTypedRuleContexts(PseudocodeParser.StatementContext) else: return self.getTypedRuleContext(PseudocodeParser.StatementContext,i) def EOF(self): return self.getToken(PseudocodeParser.EOF, 0) def NL(self, i:int=None): if i is None: return self.getTokens(PseudocodeParser.NL) else: return self.getToken(PseudocodeParser.NL, i) def getRuleIndex(self): return PseudocodeParser.RULE_program def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterProgram" ): listener.enterProgram(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitProgram" ): listener.exitProgram(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitProgram" ): return visitor.visitProgram(self) else: return visitor.visitChildren(self) def program(self): localctx = PseudocodeParser.ProgramContext(self, self._ctx, self.state) self.enterRule(localctx, 0, self.RULE_program) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 67 self._errHandler.sync(self) _la = self._input.LA(1) while _la==45: self.state = 64 self.match(PseudocodeParser.NL) self.state = 69 self._errHandler.sync(self) _la = self._input.LA(1) self.state = 70 self.statement() self.state = 79 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,2,self._ctx) while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: if _alt==1: self.state = 72 self._errHandler.sync(self) _la = self._input.LA(1) while True: self.state = 71 self.match(PseudocodeParser.NL) self.state = 74 self._errHandler.sync(self) _la = self._input.LA(1) if not (_la==45): break self.state = 76 self.statement() self.state = 81 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,2,self._ctx) self.state = 85 self._errHandler.sync(self) _la = self._input.LA(1) while _la==45: self.state = 82 self.match(PseudocodeParser.NL) self.state = 87 self._errHandler.sync(self) _la = self._input.LA(1) self.state = 88 self.match(PseudocodeParser.EOF) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class StatementContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def assignment(self): return self.getTypedRuleContext(PseudocodeParser.AssignmentContext,0) def annotation(self): return self.getTypedRuleContext(PseudocodeParser.AnnotationContext,0) def SEMICOLON(self): return self.getToken(PseudocodeParser.SEMICOLON, 0) def functionDecl(self): return self.getTypedRuleContext(PseudocodeParser.FunctionDeclContext,0) def functionCallStatement(self): return self.getTypedRuleContext(PseudocodeParser.FunctionCallStatementContext,0) def forEachLoop(self): return self.getTypedRuleContext(PseudocodeParser.ForEachLoopContext,0) def regularForLoop(self): return self.getTypedRuleContext(PseudocodeParser.RegularForLoopContext,0) def ifStatement(self): return self.getTypedRuleContext(PseudocodeParser.IfStatementContext,0) def whileLoop(self): return self.getTypedRuleContext(PseudocodeParser.WhileLoopContext,0) def returnStatement(self): return self.getTypedRuleContext(PseudocodeParser.ReturnStatementContext,0) def breakStatement(self): return self.getTypedRuleContext(PseudocodeParser.BreakStatementContext,0) def compoundAssignment(self): return self.getTypedRuleContext(PseudocodeParser.CompoundAssignmentContext,0) def getRuleIndex(self): return PseudocodeParser.RULE_statement def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterStatement" ): listener.enterStatement(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitStatement" ): listener.exitStatement(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitStatement" ): return visitor.visitStatement(self) else: return visitor.visitChildren(self) def statement(self): localctx = PseudocodeParser.StatementContext(self, self._ctx, self.state) self.enterRule(localctx, 2, self.RULE_statement) self._la = 0 # Token type try: self.state = 136 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input,16,self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) self.state = 91 self._errHandler.sync(self) _la = self._input.LA(1) if _la==44: self.state = 90 self.annotation() self.state = 93 self.assignment() self.state = 95 self._errHandler.sync(self) _la = self._input.LA(1) if _la==43: self.state = 94 self.match(PseudocodeParser.SEMICOLON) pass elif la_ == 2: self.enterOuterAlt(localctx, 2) self.state = 97 self.functionDecl() pass elif la_ == 3: self.enterOuterAlt(localctx, 3) self.state = 99 self._errHandler.sync(self) _la = self._input.LA(1) if _la==44: self.state = 98 self.annotation() self.state = 101 self.functionCallStatement() self.state = 103 self._errHandler.sync(self) _la = self._input.LA(1) if _la==43: self.state = 102 self.match(PseudocodeParser.SEMICOLON) pass elif la_ == 4: self.enterOuterAlt(localctx, 4) self.state = 105 self.forEachLoop() pass elif la_ == 5: self.enterOuterAlt(localctx, 5) self.state = 106 self.regularForLoop() pass elif la_ == 6: self.enterOuterAlt(localctx, 6) self.state = 108 self._errHandler.sync(self) _la = self._input.LA(1) if _la==44: self.state = 107 self.annotation() self.state = 110 self.ifStatement() pass elif la_ == 7: self.enterOuterAlt(localctx, 7) self.state = 112 self._errHandler.sync(self) _la = self._input.LA(1) if _la==44: self.state = 111 self.annotation() self.state = 114 self.whileLoop() pass elif la_ == 8: self.enterOuterAlt(localctx, 8) self.state = 116 self._errHandler.sync(self) _la = self._input.LA(1) if _la==44: self.state = 115 self.annotation() self.state = 118 self.returnStatement() self.state = 120 self._errHandler.sync(self) _la = self._input.LA(1) if _la==43: self.state = 119 self.match(PseudocodeParser.SEMICOLON) pass elif la_ == 9: self.enterOuterAlt(localctx, 9) self.state = 123 self._errHandler.sync(self) _la = self._input.LA(1) if _la==44: self.state = 122 self.annotation() self.state = 125 self.breakStatement() self.state = 127 self._errHandler.sync(self) _la = self._input.LA(1) if _la==43: self.state = 126 self.match(PseudocodeParser.SEMICOLON) pass elif la_ == 10: self.enterOuterAlt(localctx, 10) self.state = 130 self._errHandler.sync(self) _la = self._input.LA(1) if _la==44: self.state = 129 self.annotation() self.state = 132 self.compoundAssignment() self.state = 134 self._errHandler.sync(self) _la = self._input.LA(1) if _la==43: self.state = 133 self.match(PseudocodeParser.SEMICOLON) pass except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class LvalueContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def getRuleIndex(self): return PseudocodeParser.RULE_lvalue def copyFrom(self, ctx:ParserRuleContext): super().copyFrom(ctx) class SimpleLvalueContext(LvalueContext): def __init__(self, parser, ctx:ParserRuleContext): # actually a PseudocodeParser.LvalueContext super().__init__(parser) self.copyFrom(ctx) def ID(self): return self.getToken(PseudocodeParser.ID, 0) def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterSimpleLvalue" ): listener.enterSimpleLvalue(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitSimpleLvalue" ): listener.exitSimpleLvalue(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitSimpleLvalue" ): return visitor.visitSimpleLvalue(self) else: return visitor.visitChildren(self) class ArrayLvalueContext(LvalueContext): def __init__(self, parser, ctx:ParserRuleContext): # actually a PseudocodeParser.LvalueContext super().__init__(parser) self.copyFrom(ctx) def ID(self): return self.getToken(PseudocodeParser.ID, 0) def LBRACK(self): return self.getToken(PseudocodeParser.LBRACK, 0) def expression(self): return self.getTypedRuleContext(PseudocodeParser.ExpressionContext,0) def RBRACK(self): return self.getToken(PseudocodeParser.RBRACK, 0) def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterArrayLvalue" ): listener.enterArrayLvalue(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitArrayLvalue" ): listener.exitArrayLvalue(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitArrayLvalue" ): return visitor.visitArrayLvalue(self) else: return visitor.visitChildren(self) def lvalue(self): localctx = PseudocodeParser.LvalueContext(self, self._ctx, self.state) self.enterRule(localctx, 4, self.RULE_lvalue) try: self.state = 144 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input,17,self._ctx) if la_ == 1: localctx = PseudocodeParser.ArrayLvalueContext(self, localctx) self.enterOuterAlt(localctx, 1) self.state = 138 self.match(PseudocodeParser.ID) self.state = 139 self.match(PseudocodeParser.LBRACK) self.state = 140 self.expression() self.state = 141 self.match(PseudocodeParser.RBRACK) pass elif la_ == 2: localctx = PseudocodeParser.SimpleLvalueContext(self, localctx) self.enterOuterAlt(localctx, 2) self.state = 143 self.match(PseudocodeParser.ID) pass except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class AssignmentContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def lvalue(self): return self.getTypedRuleContext(PseudocodeParser.LvalueContext,0) def EQ(self): return self.getToken(PseudocodeParser.EQ, 0) def expression(self): return self.getTypedRuleContext(PseudocodeParser.ExpressionContext,0) def arrayInitialization(self): return self.getTypedRuleContext(PseudocodeParser.ArrayInitializationContext,0) def getRuleIndex(self): return PseudocodeParser.RULE_assignment def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterAssignment" ): listener.enterAssignment(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitAssignment" ): listener.exitAssignment(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitAssignment" ): return visitor.visitAssignment(self) else: return visitor.visitChildren(self) def assignment(self): localctx = PseudocodeParser.AssignmentContext(self, self._ctx, self.state) self.enterRule(localctx, 6, self.RULE_assignment) try: self.enterOuterAlt(localctx, 1) self.state = 146 self.lvalue() self.state = 147 self.match(PseudocodeParser.EQ) self.state = 150 self._errHandler.sync(self) token = self._input.LA(1) if token in [12, 13, 16, 17, 18, 19, 20, 34, 39]: self.state = 148 self.expression() pass elif token in [1]: self.state = 149 self.arrayInitialization() pass else: raise NoViableAltException(self) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class ArrayInitializationContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def getRuleIndex(self): return PseudocodeParser.RULE_arrayInitialization def copyFrom(self, ctx:ParserRuleContext): super().copyFrom(ctx) class RangeArrayContext(ArrayInitializationContext): def __init__(self, parser, ctx:ParserRuleContext): # actually a PseudocodeParser.ArrayInitializationContext super().__init__(parser) self.start = None # ExpressionContext self.stop = None # ExpressionContext self.copyFrom(ctx) def ARR(self): return self.getToken(PseudocodeParser.ARR, 0) def LBRACK(self): return self.getToken(PseudocodeParser.LBRACK, 0) def TO(self): return self.getToken(PseudocodeParser.TO, 0) def RBRACK(self): return self.getToken(PseudocodeParser.RBRACK, 0) def expression(self, i:int=None): if i is None: return self.getTypedRuleContexts(PseudocodeParser.ExpressionContext) else: return self.getTypedRuleContext(PseudocodeParser.ExpressionContext,i) def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterRangeArray" ): listener.enterRangeArray(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitRangeArray" ): listener.exitRangeArray(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitRangeArray" ): return visitor.visitRangeArray(self) else: return visitor.visitChildren(self) class ValueArrayContext(ArrayInitializationContext): def __init__(self, parser, ctx:ParserRuleContext): # actually a PseudocodeParser.ArrayInitializationContext super().__init__(parser) self.copyFrom(ctx) def ARR(self): return self.getToken(PseudocodeParser.ARR, 0) def LBRACK(self): return self.getToken(PseudocodeParser.LBRACK, 0) def expression(self, i:int=None): if i is None: return self.getTypedRuleContexts(PseudocodeParser.ExpressionContext) else: return self.getTypedRuleContext(PseudocodeParser.ExpressionContext,i) def RBRACK(self): return self.getToken(PseudocodeParser.RBRACK, 0) def COMMA(self, i:int=None): if i is None: return self.getTokens(PseudocodeParser.COMMA) else: return self.getToken(PseudocodeParser.COMMA, i) def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterValueArray" ): listener.enterValueArray(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitValueArray" ): listener.exitValueArray(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitValueArray" ): return visitor.visitValueArray(self) else: return visitor.visitChildren(self) class SizeArrayContext(ArrayInitializationContext): def __init__(self, parser, ctx:ParserRuleContext): # actually a PseudocodeParser.ArrayInitializationContext super().__init__(parser) self.size = None # ExpressionContext self.fill = None # ExpressionContext self.copyFrom(ctx) def ARR(self): return self.getToken(PseudocodeParser.ARR, 0) def LPAREN(self): return self.getToken(PseudocodeParser.LPAREN, 0) def RPAREN(self): return self.getToken(PseudocodeParser.RPAREN, 0) def expression(self, i:int=None): if i is None: return self.getTypedRuleContexts(PseudocodeParser.ExpressionContext) else: return self.getTypedRuleContext(PseudocodeParser.ExpressionContext,i) def COMMA(self): return self.getToken(PseudocodeParser.COMMA, 0) def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterSizeArray" ): listener.enterSizeArray(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitSizeArray" ): listener.exitSizeArray(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitSizeArray" ): return visitor.visitSizeArray(self) else: return visitor.visitChildren(self) def arrayInitialization(self): localctx = PseudocodeParser.ArrayInitializationContext(self, self._ctx, self.state) self.enterRule(localctx, 8, self.RULE_arrayInitialization) self._la = 0 # Token type try: self.state = 180 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input,21,self._ctx) if la_ == 1: localctx = PseudocodeParser.RangeArrayContext(self, localctx) self.enterOuterAlt(localctx, 1) self.state = 152 self.match(PseudocodeParser.ARR) self.state = 153 self.match(PseudocodeParser.LBRACK) self.state = 154 localctx.start = self.expression() self.state = 155 self.match(PseudocodeParser.TO) self.state = 156 localctx.stop = self.expression() self.state = 157 self.match(PseudocodeParser.RBRACK) pass elif la_ == 2: localctx = PseudocodeParser.SizeArrayContext(self, localctx) self.enterOuterAlt(localctx, 2) self.state = 159 self.match(PseudocodeParser.ARR) self.state = 160 self.match(PseudocodeParser.LPAREN) self.state = 161 localctx.size = self.expression() self.state = 164 self._errHandler.sync(self) _la = self._input.LA(1) if _la==42: self.state = 162 self.match(PseudocodeParser.COMMA) self.state = 163 localctx.fill = self.expression() self.state = 166 self.match(PseudocodeParser.RPAREN) pass elif la_ == 3: localctx = PseudocodeParser.ValueArrayContext(self, localctx) self.enterOuterAlt(localctx, 3) self.state = 168 self.match(PseudocodeParser.ARR) self.state = 169 self.match(PseudocodeParser.LBRACK) self.state = 170 self.expression() self.state = 175 self._errHandler.sync(self) _la = self._input.LA(1) while _la==42: self.state = 171 self.match(PseudocodeParser.COMMA) self.state = 172 self.expression() self.state = 177 self._errHandler.sync(self) _la = self._input.LA(1) self.state = 178 self.match(PseudocodeParser.RBRACK) pass except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class CompoundAssignmentContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def lvalue(self): return self.getTypedRuleContext(PseudocodeParser.LvalueContext,0) def expression(self): return self.getTypedRuleContext(PseudocodeParser.ExpressionContext,0) def PLUS_EQ(self): return self.getToken(PseudocodeParser.PLUS_EQ, 0) def MINUS_EQ(self): return self.getToken(PseudocodeParser.MINUS_EQ, 0) def STAR_EQ(self): return self.getToken(PseudocodeParser.STAR_EQ, 0) def SLASH_EQ(self): return self.getToken(PseudocodeParser.SLASH_EQ, 0) def getRuleIndex(self): return PseudocodeParser.RULE_compoundAssignment def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterCompoundAssignment" ): listener.enterCompoundAssignment(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitCompoundAssignment" ): listener.exitCompoundAssignment(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitCompoundAssignment" ): return visitor.visitCompoundAssignment(self) else: return visitor.visitChildren(self) def compoundAssignment(self): localctx = PseudocodeParser.CompoundAssignmentContext(self, self._ctx, self.state) self.enterRule(localctx, 10, self.RULE_compoundAssignment) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 182 self.lvalue() self.state = 183 _la = self._input.LA(1) if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 45634027520) != 0)): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() self.state = 184 self.expression() except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class FunctionDeclContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def FUN(self, i:int=None): if i is None: return self.getTokens(PseudocodeParser.FUN) else: return self.getToken(PseudocodeParser.FUN, i) def ID(self): return self.getToken(PseudocodeParser.ID, 0) def LPAREN(self): return self.getToken(PseudocodeParser.LPAREN, 0) def RPAREN(self): return self.getToken(PseudocodeParser.RPAREN, 0) def COLON(self): return self.getToken(PseudocodeParser.COLON, 0) def END(self): return self.getToken(PseudocodeParser.END, 0) def paramList(self): return self.getTypedRuleContext(PseudocodeParser.ParamListContext,0) def NL(self, i:int=None): if i is None: return self.getTokens(PseudocodeParser.NL) else: return self.getToken(PseudocodeParser.NL, i) def statement(self, i:int=None): if i is None: return self.getTypedRuleContexts(PseudocodeParser.StatementContext) else: return self.getTypedRuleContext(PseudocodeParser.StatementContext,i) def getRuleIndex(self): return PseudocodeParser.RULE_functionDecl def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterFunctionDecl" ): listener.enterFunctionDecl(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitFunctionDecl" ): listener.exitFunctionDecl(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitFunctionDecl" ): return visitor.visitFunctionDecl(self) else: return visitor.visitChildren(self) def functionDecl(self): localctx = PseudocodeParser.FunctionDeclContext(self, self._ctx, self.state) self.enterRule(localctx, 12, self.RULE_functionDecl) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 186 self.match(PseudocodeParser.FUN) self.state = 187 self.match(PseudocodeParser.ID) self.state = 188 self.match(PseudocodeParser.LPAREN) self.state = 190 self._errHandler.sync(self) _la = self._input.LA(1) if _la==17 or _la==44: self.state = 189 self.paramList() self.state = 192 self.match(PseudocodeParser.RPAREN) self.state = 193 self.match(PseudocodeParser.COLON) self.state = 195 self._errHandler.sync(self) _alt = 1 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: if _alt == 1: self.state = 194 self.match(PseudocodeParser.NL) else: raise NoViableAltException(self) self.state = 197 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,23,self._ctx) self.state = 211 self._errHandler.sync(self) _la = self._input.LA(1) if (((_la) & ~0x3f) == 0 and ((1 << _la) & 17592186178904) != 0): self.state = 199 self.statement() self.state = 208 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,25,self._ctx) while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: if _alt==1: self.state = 201 self._errHandler.sync(self) _la = self._input.LA(1) while True: self.state = 200 self.match(PseudocodeParser.NL) self.state = 203 self._errHandler.sync(self) _la = self._input.LA(1) if not (_la==45): break self.state = 205 self.statement() self.state = 210 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,25,self._ctx) self.state = 216 self._errHandler.sync(self) _la = self._input.LA(1) while _la==45: self.state = 213 self.match(PseudocodeParser.NL) self.state = 218 self._errHandler.sync(self) _la = self._input.LA(1) self.state = 219 self.match(PseudocodeParser.END) self.state = 220 self.match(PseudocodeParser.FUN) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class FunctionCallStatementContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def ID(self): return self.getToken(PseudocodeParser.ID, 0) def LPAREN(self): return self.getToken(PseudocodeParser.LPAREN, 0) def RPAREN(self): return self.getToken(PseudocodeParser.RPAREN, 0) def expressionList(self): return self.getTypedRuleContext(PseudocodeParser.ExpressionListContext,0) def getRuleIndex(self): return PseudocodeParser.RULE_functionCallStatement def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterFunctionCallStatement" ): listener.enterFunctionCallStatement(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitFunctionCallStatement" ): listener.exitFunctionCallStatement(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitFunctionCallStatement" ): return visitor.visitFunctionCallStatement(self) else: return visitor.visitChildren(self) def functionCallStatement(self): localctx = PseudocodeParser.FunctionCallStatementContext(self, self._ctx, self.state) self.enterRule(localctx, 14, self.RULE_functionCallStatement) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 222 self.match(PseudocodeParser.ID) self.state = 223 self.match(PseudocodeParser.LPAREN) self.state = 225 self._errHandler.sync(self) _la = self._input.LA(1) if (((_la) & ~0x3f) == 0 and ((1 << _la) & 566937726976) != 0): self.state = 224 self.expressionList() self.state = 227 self.match(PseudocodeParser.RPAREN) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class ParamListContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def annotatedParam(self, i:int=None): if i is None: return self.getTypedRuleContexts(PseudocodeParser.AnnotatedParamContext) else: return self.getTypedRuleContext(PseudocodeParser.AnnotatedParamContext,i) def COMMA(self, i:int=None): if i is None: return self.getTokens(PseudocodeParser.COMMA) else: return self.getToken(PseudocodeParser.COMMA, i) def getRuleIndex(self): return PseudocodeParser.RULE_paramList def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterParamList" ): listener.enterParamList(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitParamList" ): listener.exitParamList(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitParamList" ): return visitor.visitParamList(self) else: return visitor.visitChildren(self) def paramList(self): localctx = PseudocodeParser.ParamListContext(self, self._ctx, self.state) self.enterRule(localctx, 16, self.RULE_paramList) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 229 self.annotatedParam() self.state = 234 self._errHandler.sync(self) _la = self._input.LA(1) while _la==42: self.state = 230 self.match(PseudocodeParser.COMMA) self.state = 231 self.annotatedParam() self.state = 236 self._errHandler.sync(self) _la = self._input.LA(1) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class AnnotatedParamContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def ID(self): return self.getToken(PseudocodeParser.ID, 0) def annotation(self): return self.getTypedRuleContext(PseudocodeParser.AnnotationContext,0) def getRuleIndex(self): return PseudocodeParser.RULE_annotatedParam def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterAnnotatedParam" ): listener.enterAnnotatedParam(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitAnnotatedParam" ): listener.exitAnnotatedParam(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitAnnotatedParam" ): return visitor.visitAnnotatedParam(self) else: return visitor.visitChildren(self) def annotatedParam(self): localctx = PseudocodeParser.AnnotatedParamContext(self, self._ctx, self.state) self.enterRule(localctx, 18, self.RULE_annotatedParam) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 238 self._errHandler.sync(self) _la = self._input.LA(1) if _la==44: self.state = 237 self.annotation() self.state = 240 self.match(PseudocodeParser.ID) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class AnnotationContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def AT(self): return self.getToken(PseudocodeParser.AT, 0) def ID(self): return self.getToken(PseudocodeParser.ID, 0) def LOW_THAN(self): return self.getToken(PseudocodeParser.LOW_THAN, 0) def annotationArgList(self): return self.getTypedRuleContext(PseudocodeParser.AnnotationArgListContext,0) def GREATER_THAN(self): return self.getToken(PseudocodeParser.GREATER_THAN, 0) def getRuleIndex(self): return PseudocodeParser.RULE_annotation def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterAnnotation" ): listener.enterAnnotation(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitAnnotation" ): listener.exitAnnotation(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitAnnotation" ): return visitor.visitAnnotation(self) else: return visitor.visitChildren(self) def annotation(self): localctx = PseudocodeParser.AnnotationContext(self, self._ctx, self.state) self.enterRule(localctx, 20, self.RULE_annotation) try: self.enterOuterAlt(localctx, 1) self.state = 242 self.match(PseudocodeParser.AT) self.state = 243 self.match(PseudocodeParser.ID) self.state = 244 self.match(PseudocodeParser.LOW_THAN) self.state = 245 self.annotationArgList() self.state = 246 self.match(PseudocodeParser.GREATER_THAN) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class AnnotationArgListContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def annotationArg(self, i:int=None): if i is None: return self.getTypedRuleContexts(PseudocodeParser.AnnotationArgContext) else: return self.getTypedRuleContext(PseudocodeParser.AnnotationArgContext,i) def COMMA(self, i:int=None): if i is None: return self.getTokens(PseudocodeParser.COMMA) else: return self.getToken(PseudocodeParser.COMMA, i) def getRuleIndex(self): return PseudocodeParser.RULE_annotationArgList def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterAnnotationArgList" ): listener.enterAnnotationArgList(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitAnnotationArgList" ): listener.exitAnnotationArgList(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitAnnotationArgList" ): return visitor.visitAnnotationArgList(self) else: return visitor.visitChildren(self) def annotationArgList(self): localctx = PseudocodeParser.AnnotationArgListContext(self, self._ctx, self.state) self.enterRule(localctx, 22, self.RULE_annotationArgList) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 248 self.annotationArg() self.state = 253 self._errHandler.sync(self) _la = self._input.LA(1) while _la==42: self.state = 249 self.match(PseudocodeParser.COMMA) self.state = 250 self.annotationArg() self.state = 255 self._errHandler.sync(self) _la = self._input.LA(1) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class AnnotationArgContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def ID(self): return self.getToken(PseudocodeParser.ID, 0) def STRING(self): return self.getToken(PseudocodeParser.STRING, 0) def INT(self): return self.getToken(PseudocodeParser.INT, 0) def getRuleIndex(self): return PseudocodeParser.RULE_annotationArg def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterAnnotationArg" ): listener.enterAnnotationArg(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitAnnotationArg" ): listener.exitAnnotationArg(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitAnnotationArg" ): return visitor.visitAnnotationArg(self) else: return visitor.visitChildren(self) def annotationArg(self): localctx = PseudocodeParser.AnnotationArgContext(self, self._ctx, self.state) self.enterRule(localctx, 24, self.RULE_annotationArg) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 256 _la = self._input.LA(1) if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 1703936) != 0)): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class ForEachLoopContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def FOR(self, i:int=None): if i is None: return self.getTokens(PseudocodeParser.FOR) else: return self.getToken(PseudocodeParser.FOR, i) def ID(self, i:int=None): if i is None: return self.getTokens(PseudocodeParser.ID) else: return self.getToken(PseudocodeParser.ID, i) def IN(self): return self.getToken(PseudocodeParser.IN, 0) def COLON(self): return self.getToken(PseudocodeParser.COLON, 0) def END(self): return self.getToken(PseudocodeParser.END, 0) def annotation(self): return self.getTypedRuleContext(PseudocodeParser.AnnotationContext,0) def NL(self, i:int=None): if i is None: return self.getTokens(PseudocodeParser.NL) else: return self.getToken(PseudocodeParser.NL, i) def statement(self, i:int=None): if i is None: return self.getTypedRuleContexts(PseudocodeParser.StatementContext) else: return self.getTypedRuleContext(PseudocodeParser.StatementContext,i) def getRuleIndex(self): return PseudocodeParser.RULE_forEachLoop def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterForEachLoop" ): listener.enterForEachLoop(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitForEachLoop" ): listener.exitForEachLoop(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitForEachLoop" ): return visitor.visitForEachLoop(self) else: return visitor.visitChildren(self) def forEachLoop(self): localctx = PseudocodeParser.ForEachLoopContext(self, self._ctx, self.state) self.enterRule(localctx, 26, self.RULE_forEachLoop) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 258 self.match(PseudocodeParser.FOR) self.state = 260 self._errHandler.sync(self) _la = self._input.LA(1) if _la==44: self.state = 259 self.annotation() self.state = 262 self.match(PseudocodeParser.ID) self.state = 263 self.match(PseudocodeParser.IN) self.state = 264 self.match(PseudocodeParser.ID) self.state = 265 self.match(PseudocodeParser.COLON) self.state = 267 self._errHandler.sync(self) _alt = 1 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: if _alt == 1: self.state = 266 self.match(PseudocodeParser.NL) else: raise NoViableAltException(self) self.state = 269 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,33,self._ctx) self.state = 283 self._errHandler.sync(self) _la = self._input.LA(1) if (((_la) & ~0x3f) == 0 and ((1 << _la) & 17592186178904) != 0): self.state = 271 self.statement() self.state = 280 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,35,self._ctx) while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: if _alt==1: self.state = 273 self._errHandler.sync(self) _la = self._input.LA(1) while True: self.state = 272 self.match(PseudocodeParser.NL) self.state = 275 self._errHandler.sync(self) _la = self._input.LA(1) if not (_la==45): break self.state = 277 self.statement() self.state = 282 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,35,self._ctx) self.state = 288 self._errHandler.sync(self) _la = self._input.LA(1) while _la==45: self.state = 285 self.match(PseudocodeParser.NL) self.state = 290 self._errHandler.sync(self) _la = self._input.LA(1) self.state = 291 self.match(PseudocodeParser.END) self.state = 292 self.match(PseudocodeParser.FOR) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class RegularForLoopContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def FOR(self, i:int=None): if i is None: return self.getTokens(PseudocodeParser.FOR) else: return self.getToken(PseudocodeParser.FOR, i) def LPAREN(self): return self.getToken(PseudocodeParser.LPAREN, 0) def ID(self): return self.getToken(PseudocodeParser.ID, 0) def EQ(self): return self.getToken(PseudocodeParser.EQ, 0) def expression(self, i:int=None): if i is None: return self.getTypedRuleContexts(PseudocodeParser.ExpressionContext) else: return self.getTypedRuleContext(PseudocodeParser.ExpressionContext,i) def forUpdate(self): return self.getTypedRuleContext(PseudocodeParser.ForUpdateContext,0) def RPAREN(self): return self.getToken(PseudocodeParser.RPAREN, 0) def COLON(self): return self.getToken(PseudocodeParser.COLON, 0) def block(self): return self.getTypedRuleContext(PseudocodeParser.BlockContext,0) def END(self): return self.getToken(PseudocodeParser.END, 0) def COMMA(self, i:int=None): if i is None: return self.getTokens(PseudocodeParser.COMMA) else: return self.getToken(PseudocodeParser.COMMA, i) def SEMICOLON(self, i:int=None): if i is None: return self.getTokens(PseudocodeParser.SEMICOLON) else: return self.getToken(PseudocodeParser.SEMICOLON, i) def annotation(self): return self.getTypedRuleContext(PseudocodeParser.AnnotationContext,0) def NL(self, i:int=None): if i is None: return self.getTokens(PseudocodeParser.NL) else: return self.getToken(PseudocodeParser.NL, i) def getRuleIndex(self): return PseudocodeParser.RULE_regularForLoop def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterRegularForLoop" ): listener.enterRegularForLoop(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitRegularForLoop" ): listener.exitRegularForLoop(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitRegularForLoop" ): return visitor.visitRegularForLoop(self) else: return visitor.visitChildren(self) def regularForLoop(self): localctx = PseudocodeParser.RegularForLoopContext(self, self._ctx, self.state) self.enterRule(localctx, 28, self.RULE_regularForLoop) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 294 self.match(PseudocodeParser.FOR) self.state = 296 self._errHandler.sync(self) _la = self._input.LA(1) if _la==44: self.state = 295 self.annotation() self.state = 298 self.match(PseudocodeParser.LPAREN) self.state = 299 self.match(PseudocodeParser.ID) self.state = 300 self.match(PseudocodeParser.EQ) self.state = 301 self.expression() self.state = 302 _la = self._input.LA(1) if not(_la==42 or _la==43): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() self.state = 303 self.expression() self.state = 304 _la = self._input.LA(1) if not(_la==42 or _la==43): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() self.state = 305 self.forUpdate() self.state = 306 self.match(PseudocodeParser.RPAREN) self.state = 307 self.match(PseudocodeParser.COLON) self.state = 309 self._errHandler.sync(self) _alt = 1 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: if _alt == 1: self.state = 308 self.match(PseudocodeParser.NL) else: raise NoViableAltException(self) self.state = 311 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,39,self._ctx) self.state = 313 self.block() self.state = 314 self.match(PseudocodeParser.END) self.state = 315 self.match(PseudocodeParser.FOR) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class ForUpdateContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def ID(self): return self.getToken(PseudocodeParser.ID, 0) def expression(self): return self.getTypedRuleContext(PseudocodeParser.ExpressionContext,0) def PLUS_EQ(self): return self.getToken(PseudocodeParser.PLUS_EQ, 0) def MINUS_EQ(self): return self.getToken(PseudocodeParser.MINUS_EQ, 0) def STAR_EQ(self): return self.getToken(PseudocodeParser.STAR_EQ, 0) def SLASH_EQ(self): return self.getToken(PseudocodeParser.SLASH_EQ, 0) def getRuleIndex(self): return PseudocodeParser.RULE_forUpdate def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterForUpdate" ): listener.enterForUpdate(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitForUpdate" ): listener.exitForUpdate(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitForUpdate" ): return visitor.visitForUpdate(self) else: return visitor.visitChildren(self) def forUpdate(self): localctx = PseudocodeParser.ForUpdateContext(self, self._ctx, self.state) self.enterRule(localctx, 30, self.RULE_forUpdate) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 317 self.match(PseudocodeParser.ID) self.state = 318 _la = self._input.LA(1) if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 45634027520) != 0)): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() self.state = 319 self.expression() except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class IfStatementContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def IF(self, i:int=None): if i is None: return self.getTokens(PseudocodeParser.IF) else: return self.getToken(PseudocodeParser.IF, i) def LPAREN(self, i:int=None): if i is None: return self.getTokens(PseudocodeParser.LPAREN) else: return self.getToken(PseudocodeParser.LPAREN, i) def expression(self, i:int=None): if i is None: return self.getTypedRuleContexts(PseudocodeParser.ExpressionContext) else: return self.getTypedRuleContext(PseudocodeParser.ExpressionContext,i) def RPAREN(self, i:int=None): if i is None: return self.getTokens(PseudocodeParser.RPAREN) else: return self.getToken(PseudocodeParser.RPAREN, i) def COLON(self, i:int=None): if i is None: return self.getTokens(PseudocodeParser.COLON) else: return self.getToken(PseudocodeParser.COLON, i) def block(self, i:int=None): if i is None: return self.getTypedRuleContexts(PseudocodeParser.BlockContext) else: return self.getTypedRuleContext(PseudocodeParser.BlockContext,i) def END(self): return self.getToken(PseudocodeParser.END, 0) def NL(self, i:int=None): if i is None: return self.getTokens(PseudocodeParser.NL) else: return self.getToken(PseudocodeParser.NL, i) def ELSE(self, i:int=None): if i is None: return self.getTokens(PseudocodeParser.ELSE) else: return self.getToken(PseudocodeParser.ELSE, i) def getRuleIndex(self): return PseudocodeParser.RULE_ifStatement def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterIfStatement" ): listener.enterIfStatement(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitIfStatement" ): listener.exitIfStatement(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitIfStatement" ): return visitor.visitIfStatement(self) else: return visitor.visitChildren(self) def ifStatement(self): localctx = PseudocodeParser.IfStatementContext(self, self._ctx, self.state) self.enterRule(localctx, 32, self.RULE_ifStatement) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 321 self.match(PseudocodeParser.IF) self.state = 322 self.match(PseudocodeParser.LPAREN) self.state = 323 self.expression() self.state = 324 self.match(PseudocodeParser.RPAREN) self.state = 325 self.match(PseudocodeParser.COLON) self.state = 327 self._errHandler.sync(self) _alt = 1 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: if _alt == 1: self.state = 326 self.match(PseudocodeParser.NL) else: raise NoViableAltException(self) self.state = 329 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,40,self._ctx) self.state = 331 self.block() self.state = 347 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,42,self._ctx) while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: if _alt==1: self.state = 332 self.match(PseudocodeParser.ELSE) self.state = 333 self.match(PseudocodeParser.IF) self.state = 334 self.match(PseudocodeParser.LPAREN) self.state = 335 self.expression() self.state = 336 self.match(PseudocodeParser.RPAREN) self.state = 337 self.match(PseudocodeParser.COLON) self.state = 339 self._errHandler.sync(self) _alt = 1 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: if _alt == 1: self.state = 338 self.match(PseudocodeParser.NL) else: raise NoViableAltException(self) self.state = 341 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,41,self._ctx) self.state = 343 self.block() self.state = 349 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,42,self._ctx) self.state = 358 self._errHandler.sync(self) _la = self._input.LA(1) if _la==7: self.state = 350 self.match(PseudocodeParser.ELSE) self.state = 351 self.match(PseudocodeParser.COLON) self.state = 353 self._errHandler.sync(self) _alt = 1 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: if _alt == 1: self.state = 352 self.match(PseudocodeParser.NL) else: raise NoViableAltException(self) self.state = 355 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,43,self._ctx) self.state = 357 self.block() self.state = 360 self.match(PseudocodeParser.END) self.state = 361 self.match(PseudocodeParser.IF) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class WhileLoopContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def WHILE(self, i:int=None): if i is None: return self.getTokens(PseudocodeParser.WHILE) else: return self.getToken(PseudocodeParser.WHILE, i) def LPAREN(self): return self.getToken(PseudocodeParser.LPAREN, 0) def expression(self): return self.getTypedRuleContext(PseudocodeParser.ExpressionContext,0) def RPAREN(self): return self.getToken(PseudocodeParser.RPAREN, 0) def COLON(self): return self.getToken(PseudocodeParser.COLON, 0) def END(self): return self.getToken(PseudocodeParser.END, 0) def NL(self, i:int=None): if i is None: return self.getTokens(PseudocodeParser.NL) else: return self.getToken(PseudocodeParser.NL, i) def statement(self, i:int=None): if i is None: return self.getTypedRuleContexts(PseudocodeParser.StatementContext) else: return self.getTypedRuleContext(PseudocodeParser.StatementContext,i) def getRuleIndex(self): return PseudocodeParser.RULE_whileLoop def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterWhileLoop" ): listener.enterWhileLoop(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitWhileLoop" ): listener.exitWhileLoop(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitWhileLoop" ): return visitor.visitWhileLoop(self) else: return visitor.visitChildren(self) def whileLoop(self): localctx = PseudocodeParser.WhileLoopContext(self, self._ctx, self.state) self.enterRule(localctx, 34, self.RULE_whileLoop) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 363 self.match(PseudocodeParser.WHILE) self.state = 364 self.match(PseudocodeParser.LPAREN) self.state = 365 self.expression() self.state = 366 self.match(PseudocodeParser.RPAREN) self.state = 367 self.match(PseudocodeParser.COLON) self.state = 369 self._errHandler.sync(self) _alt = 1 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: if _alt == 1: self.state = 368 self.match(PseudocodeParser.NL) else: raise NoViableAltException(self) self.state = 371 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,45,self._ctx) self.state = 385 self._errHandler.sync(self) _la = self._input.LA(1) if (((_la) & ~0x3f) == 0 and ((1 << _la) & 17592186178904) != 0): self.state = 373 self.statement() self.state = 382 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,47,self._ctx) while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: if _alt==1: self.state = 375 self._errHandler.sync(self) _la = self._input.LA(1) while True: self.state = 374 self.match(PseudocodeParser.NL) self.state = 377 self._errHandler.sync(self) _la = self._input.LA(1) if not (_la==45): break self.state = 379 self.statement() self.state = 384 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,47,self._ctx) self.state = 390 self._errHandler.sync(self) _la = self._input.LA(1) while _la==45: self.state = 387 self.match(PseudocodeParser.NL) self.state = 392 self._errHandler.sync(self) _la = self._input.LA(1) self.state = 393 self.match(PseudocodeParser.END) self.state = 394 self.match(PseudocodeParser.WHILE) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class ReturnStatementContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def RETURN(self): return self.getToken(PseudocodeParser.RETURN, 0) def expression(self): return self.getTypedRuleContext(PseudocodeParser.ExpressionContext,0) def getRuleIndex(self): return PseudocodeParser.RULE_returnStatement def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterReturnStatement" ): listener.enterReturnStatement(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitReturnStatement" ): listener.exitReturnStatement(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitReturnStatement" ): return visitor.visitReturnStatement(self) else: return visitor.visitChildren(self) def returnStatement(self): localctx = PseudocodeParser.ReturnStatementContext(self, self._ctx, self.state) self.enterRule(localctx, 36, self.RULE_returnStatement) try: self.enterOuterAlt(localctx, 1) self.state = 396 self.match(PseudocodeParser.RETURN) self.state = 397 self.expression() except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class BreakStatementContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def BREAK(self): return self.getToken(PseudocodeParser.BREAK, 0) def getRuleIndex(self): return PseudocodeParser.RULE_breakStatement def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterBreakStatement" ): listener.enterBreakStatement(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitBreakStatement" ): listener.exitBreakStatement(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitBreakStatement" ): return visitor.visitBreakStatement(self) else: return visitor.visitChildren(self) def breakStatement(self): localctx = PseudocodeParser.BreakStatementContext(self, self._ctx, self.state) self.enterRule(localctx, 38, self.RULE_breakStatement) try: self.enterOuterAlt(localctx, 1) self.state = 399 self.match(PseudocodeParser.BREAK) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class BlockContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def statement(self, i:int=None): if i is None: return self.getTypedRuleContexts(PseudocodeParser.StatementContext) else: return self.getTypedRuleContext(PseudocodeParser.StatementContext,i) def NL(self, i:int=None): if i is None: return self.getTokens(PseudocodeParser.NL) else: return self.getToken(PseudocodeParser.NL, i) def getRuleIndex(self): return PseudocodeParser.RULE_block def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterBlock" ): listener.enterBlock(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitBlock" ): listener.exitBlock(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitBlock" ): return visitor.visitBlock(self) else: return visitor.visitChildren(self) def block(self): localctx = PseudocodeParser.BlockContext(self, self._ctx, self.state) self.enterRule(localctx, 40, self.RULE_block) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 413 self._errHandler.sync(self) _la = self._input.LA(1) if (((_la) & ~0x3f) == 0 and ((1 << _la) & 17592186178904) != 0): self.state = 401 self.statement() self.state = 410 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,51,self._ctx) while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: if _alt==1: self.state = 403 self._errHandler.sync(self) _la = self._input.LA(1) while True: self.state = 402 self.match(PseudocodeParser.NL) self.state = 405 self._errHandler.sync(self) _la = self._input.LA(1) if not (_la==45): break self.state = 407 self.statement() self.state = 412 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,51,self._ctx) self.state = 418 self._errHandler.sync(self) _la = self._input.LA(1) while _la==45: self.state = 415 self.match(PseudocodeParser.NL) self.state = 420 self._errHandler.sync(self) _la = self._input.LA(1) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class ExpressionContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def logicalOrExpression(self): return self.getTypedRuleContext(PseudocodeParser.LogicalOrExpressionContext,0) def getRuleIndex(self): return PseudocodeParser.RULE_expression def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterExpression" ): listener.enterExpression(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitExpression" ): listener.exitExpression(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitExpression" ): return visitor.visitExpression(self) else: return visitor.visitChildren(self) def expression(self): localctx = PseudocodeParser.ExpressionContext(self, self._ctx, self.state) self.enterRule(localctx, 42, self.RULE_expression) try: self.enterOuterAlt(localctx, 1) self.state = 421 self.logicalOrExpression() except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class LogicalOrExpressionContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def getRuleIndex(self): return PseudocodeParser.RULE_logicalOrExpression def copyFrom(self, ctx:ParserRuleContext): super().copyFrom(ctx) class OrExprContext(LogicalOrExpressionContext): def __init__(self, parser, ctx:ParserRuleContext): # actually a PseudocodeParser.LogicalOrExpressionContext super().__init__(parser) self.left = None # LogicalAndExpressionContext self.right = None # LogicalAndExpressionContext self.copyFrom(ctx) def logicalAndExpression(self, i:int=None): if i is None: return self.getTypedRuleContexts(PseudocodeParser.LogicalAndExpressionContext) else: return self.getTypedRuleContext(PseudocodeParser.LogicalAndExpressionContext,i) def OR(self, i:int=None): if i is None: return self.getTokens(PseudocodeParser.OR) else: return self.getToken(PseudocodeParser.OR, i) def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterOrExpr" ): listener.enterOrExpr(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitOrExpr" ): listener.exitOrExpr(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitOrExpr" ): return visitor.visitOrExpr(self) else: return visitor.visitChildren(self) class OrPassContext(LogicalOrExpressionContext): def __init__(self, parser, ctx:ParserRuleContext): # actually a PseudocodeParser.LogicalOrExpressionContext super().__init__(parser) self.copyFrom(ctx) def logicalAndExpression(self): return self.getTypedRuleContext(PseudocodeParser.LogicalAndExpressionContext,0) def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterOrPass" ): listener.enterOrPass(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitOrPass" ): listener.exitOrPass(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitOrPass" ): return visitor.visitOrPass(self) else: return visitor.visitChildren(self) def logicalOrExpression(self): localctx = PseudocodeParser.LogicalOrExpressionContext(self, self._ctx, self.state) self.enterRule(localctx, 44, self.RULE_logicalOrExpression) self._la = 0 # Token type try: self.state = 431 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input,55,self._ctx) if la_ == 1: localctx = PseudocodeParser.OrExprContext(self, localctx) self.enterOuterAlt(localctx, 1) self.state = 423 localctx.left = self.logicalAndExpression() self.state = 426 self._errHandler.sync(self) _la = self._input.LA(1) while True: self.state = 424 self.match(PseudocodeParser.OR) self.state = 425 localctx.right = self.logicalAndExpression() self.state = 428 self._errHandler.sync(self) _la = self._input.LA(1) if not (_la==15): break pass elif la_ == 2: localctx = PseudocodeParser.OrPassContext(self, localctx) self.enterOuterAlt(localctx, 2) self.state = 430 self.logicalAndExpression() pass except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class LogicalAndExpressionContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def getRuleIndex(self): return PseudocodeParser.RULE_logicalAndExpression def copyFrom(self, ctx:ParserRuleContext): super().copyFrom(ctx) class AndExprContext(LogicalAndExpressionContext): def __init__(self, parser, ctx:ParserRuleContext): # actually a PseudocodeParser.LogicalAndExpressionContext super().__init__(parser) self.left = None # ComparisonExpressionContext self.right = None # ComparisonExpressionContext self.copyFrom(ctx) def comparisonExpression(self, i:int=None): if i is None: return self.getTypedRuleContexts(PseudocodeParser.ComparisonExpressionContext) else: return self.getTypedRuleContext(PseudocodeParser.ComparisonExpressionContext,i) def AND(self, i:int=None): if i is None: return self.getTokens(PseudocodeParser.AND) else: return self.getToken(PseudocodeParser.AND, i) def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterAndExpr" ): listener.enterAndExpr(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitAndExpr" ): listener.exitAndExpr(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitAndExpr" ): return visitor.visitAndExpr(self) else: return visitor.visitChildren(self) class AndPassContext(LogicalAndExpressionContext): def __init__(self, parser, ctx:ParserRuleContext): # actually a PseudocodeParser.LogicalAndExpressionContext super().__init__(parser) self.copyFrom(ctx) def comparisonExpression(self): return self.getTypedRuleContext(PseudocodeParser.ComparisonExpressionContext,0) def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterAndPass" ): listener.enterAndPass(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitAndPass" ): listener.exitAndPass(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitAndPass" ): return visitor.visitAndPass(self) else: return visitor.visitChildren(self) def logicalAndExpression(self): localctx = PseudocodeParser.LogicalAndExpressionContext(self, self._ctx, self.state) self.enterRule(localctx, 46, self.RULE_logicalAndExpression) self._la = 0 # Token type try: self.state = 441 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input,57,self._ctx) if la_ == 1: localctx = PseudocodeParser.AndExprContext(self, localctx) self.enterOuterAlt(localctx, 1) self.state = 433 localctx.left = self.comparisonExpression() self.state = 436 self._errHandler.sync(self) _la = self._input.LA(1) while True: self.state = 434 self.match(PseudocodeParser.AND) self.state = 435 localctx.right = self.comparisonExpression() self.state = 438 self._errHandler.sync(self) _la = self._input.LA(1) if not (_la==14): break pass elif la_ == 2: localctx = PseudocodeParser.AndPassContext(self, localctx) self.enterOuterAlt(localctx, 2) self.state = 440 self.comparisonExpression() pass except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class ComparisonExpressionContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def getRuleIndex(self): return PseudocodeParser.RULE_comparisonExpression def copyFrom(self, ctx:ParserRuleContext): super().copyFrom(ctx) class CompareExprContext(ComparisonExpressionContext): def __init__(self, parser, ctx:ParserRuleContext): # actually a PseudocodeParser.ComparisonExpressionContext super().__init__(parser) self.left = None # AdditiveExpressionContext self.op = None # Token self.right = None # AdditiveExpressionContext self.copyFrom(ctx) def additiveExpression(self, i:int=None): if i is None: return self.getTypedRuleContexts(PseudocodeParser.AdditiveExpressionContext) else: return self.getTypedRuleContext(PseudocodeParser.AdditiveExpressionContext,i) def EQEQ(self): return self.getToken(PseudocodeParser.EQEQ, 0) def LOW_THAN(self): return self.getToken(PseudocodeParser.LOW_THAN, 0) def GREATER_THAN(self): return self.getToken(PseudocodeParser.GREATER_THAN, 0) def LESS_EQ(self): return self.getToken(PseudocodeParser.LESS_EQ, 0) def GREATER_EQ(self): return self.getToken(PseudocodeParser.GREATER_EQ, 0) def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterCompareExpr" ): listener.enterCompareExpr(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitCompareExpr" ): listener.exitCompareExpr(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitCompareExpr" ): return visitor.visitCompareExpr(self) else: return visitor.visitChildren(self) class ComparisonPassContext(ComparisonExpressionContext): def __init__(self, parser, ctx:ParserRuleContext): # actually a PseudocodeParser.ComparisonExpressionContext super().__init__(parser) self.copyFrom(ctx) def additiveExpression(self): return self.getTypedRuleContext(PseudocodeParser.AdditiveExpressionContext,0) def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterComparisonPass" ): listener.enterComparisonPass(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitComparisonPass" ): listener.exitComparisonPass(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitComparisonPass" ): return visitor.visitComparisonPass(self) else: return visitor.visitChildren(self) def comparisonExpression(self): localctx = PseudocodeParser.ComparisonExpressionContext(self, self._ctx, self.state) self.enterRule(localctx, 48, self.RULE_comparisonExpression) self._la = 0 # Token type try: self.state = 448 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input,58,self._ctx) if la_ == 1: localctx = PseudocodeParser.CompareExprContext(self, localctx) self.enterOuterAlt(localctx, 1) self.state = 443 localctx.left = self.additiveExpression() self.state = 444 localctx.op = self._input.LT(1) _la = self._input.LA(1) if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 255852544) != 0)): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() self.state = 445 localctx.right = self.additiveExpression() pass elif la_ == 2: localctx = PseudocodeParser.ComparisonPassContext(self, localctx) self.enterOuterAlt(localctx, 2) self.state = 447 self.additiveExpression() pass except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class AdditiveExpressionContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def getRuleIndex(self): return PseudocodeParser.RULE_additiveExpression def copyFrom(self, ctx:ParserRuleContext): super().copyFrom(ctx) class AdditivePassContext(AdditiveExpressionContext): def __init__(self, parser, ctx:ParserRuleContext): # actually a PseudocodeParser.AdditiveExpressionContext super().__init__(parser) self.copyFrom(ctx) def multiplicativeExpression(self): return self.getTypedRuleContext(PseudocodeParser.MultiplicativeExpressionContext,0) def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterAdditivePass" ): listener.enterAdditivePass(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitAdditivePass" ): listener.exitAdditivePass(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitAdditivePass" ): return visitor.visitAdditivePass(self) else: return visitor.visitChildren(self) class AddExprContext(AdditiveExpressionContext): def __init__(self, parser, ctx:ParserRuleContext): # actually a PseudocodeParser.AdditiveExpressionContext super().__init__(parser) self.left = None # MultiplicativeExpressionContext self.op = None # Token self.right = None # MultiplicativeExpressionContext self.copyFrom(ctx) def multiplicativeExpression(self, i:int=None): if i is None: return self.getTypedRuleContexts(PseudocodeParser.MultiplicativeExpressionContext) else: return self.getTypedRuleContext(PseudocodeParser.MultiplicativeExpressionContext,i) def PLUS(self, i:int=None): if i is None: return self.getTokens(PseudocodeParser.PLUS) else: return self.getToken(PseudocodeParser.PLUS, i) def MINUS(self, i:int=None): if i is None: return self.getTokens(PseudocodeParser.MINUS) else: return self.getToken(PseudocodeParser.MINUS, i) def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterAddExpr" ): listener.enterAddExpr(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitAddExpr" ): listener.exitAddExpr(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitAddExpr" ): return visitor.visitAddExpr(self) else: return visitor.visitChildren(self) def additiveExpression(self): localctx = PseudocodeParser.AdditiveExpressionContext(self, self._ctx, self.state) self.enterRule(localctx, 50, self.RULE_additiveExpression) self._la = 0 # Token type try: self.state = 458 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input,60,self._ctx) if la_ == 1: localctx = PseudocodeParser.AddExprContext(self, localctx) self.enterOuterAlt(localctx, 1) self.state = 450 localctx.left = self.multiplicativeExpression() self.state = 453 self._errHandler.sync(self) _la = self._input.LA(1) while True: self.state = 451 localctx.op = self._input.LT(1) _la = self._input.LA(1) if not(_la==32 or _la==34): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() self.state = 452 localctx.right = self.multiplicativeExpression() self.state = 455 self._errHandler.sync(self) _la = self._input.LA(1) if not (_la==32 or _la==34): break pass elif la_ == 2: localctx = PseudocodeParser.AdditivePassContext(self, localctx) self.enterOuterAlt(localctx, 2) self.state = 457 self.multiplicativeExpression() pass except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class MultiplicativeExpressionContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def getRuleIndex(self): return PseudocodeParser.RULE_multiplicativeExpression def copyFrom(self, ctx:ParserRuleContext): super().copyFrom(ctx) class MulExprContext(MultiplicativeExpressionContext): def __init__(self, parser, ctx:ParserRuleContext): # actually a PseudocodeParser.MultiplicativeExpressionContext super().__init__(parser) self.left = None # PowerExpressionContext self.op = None # Token self.right = None # PowerExpressionContext self.copyFrom(ctx) def powerExpression(self, i:int=None): if i is None: return self.getTypedRuleContexts(PseudocodeParser.PowerExpressionContext) else: return self.getTypedRuleContext(PseudocodeParser.PowerExpressionContext,i) def STAR(self, i:int=None): if i is None: return self.getTokens(PseudocodeParser.STAR) else: return self.getToken(PseudocodeParser.STAR, i) def SLASH(self, i:int=None): if i is None: return self.getTokens(PseudocodeParser.SLASH) else: return self.getToken(PseudocodeParser.SLASH, i) def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterMulExpr" ): listener.enterMulExpr(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitMulExpr" ): listener.exitMulExpr(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitMulExpr" ): return visitor.visitMulExpr(self) else: return visitor.visitChildren(self) class MultiplicativePassContext(MultiplicativeExpressionContext): def __init__(self, parser, ctx:ParserRuleContext): # actually a PseudocodeParser.MultiplicativeExpressionContext super().__init__(parser) self.copyFrom(ctx) def powerExpression(self): return self.getTypedRuleContext(PseudocodeParser.PowerExpressionContext,0) def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterMultiplicativePass" ): listener.enterMultiplicativePass(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitMultiplicativePass" ): listener.exitMultiplicativePass(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitMultiplicativePass" ): return visitor.visitMultiplicativePass(self) else: return visitor.visitChildren(self) def multiplicativeExpression(self): localctx = PseudocodeParser.MultiplicativeExpressionContext(self, self._ctx, self.state) self.enterRule(localctx, 52, self.RULE_multiplicativeExpression) self._la = 0 # Token type try: self.state = 468 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input,62,self._ctx) if la_ == 1: localctx = PseudocodeParser.MulExprContext(self, localctx) self.enterOuterAlt(localctx, 1) self.state = 460 localctx.left = self.powerExpression() self.state = 463 self._errHandler.sync(self) _la = self._input.LA(1) while True: self.state = 461 localctx.op = self._input.LT(1) _la = self._input.LA(1) if not(_la==30 or _la==36): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() self.state = 462 localctx.right = self.powerExpression() self.state = 465 self._errHandler.sync(self) _la = self._input.LA(1) if not (_la==30 or _la==36): break pass elif la_ == 2: localctx = PseudocodeParser.MultiplicativePassContext(self, localctx) self.enterOuterAlt(localctx, 2) self.state = 467 self.powerExpression() pass except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class PowerExpressionContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def getRuleIndex(self): return PseudocodeParser.RULE_powerExpression def copyFrom(self, ctx:ParserRuleContext): super().copyFrom(ctx) class PowerPassContext(PowerExpressionContext): def __init__(self, parser, ctx:ParserRuleContext): # actually a PseudocodeParser.PowerExpressionContext super().__init__(parser) self.copyFrom(ctx) def unaryExpression(self): return self.getTypedRuleContext(PseudocodeParser.UnaryExpressionContext,0) def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterPowerPass" ): listener.enterPowerPass(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitPowerPass" ): listener.exitPowerPass(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitPowerPass" ): return visitor.visitPowerPass(self) else: return visitor.visitChildren(self) class PowExprContext(PowerExpressionContext): def __init__(self, parser, ctx:ParserRuleContext): # actually a PseudocodeParser.PowerExpressionContext super().__init__(parser) self.left = None # UnaryExpressionContext self.right = None # UnaryExpressionContext self.copyFrom(ctx) def unaryExpression(self, i:int=None): if i is None: return self.getTypedRuleContexts(PseudocodeParser.UnaryExpressionContext) else: return self.getTypedRuleContext(PseudocodeParser.UnaryExpressionContext,i) def POW(self, i:int=None): if i is None: return self.getTokens(PseudocodeParser.POW) else: return self.getToken(PseudocodeParser.POW, i) def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterPowExpr" ): listener.enterPowExpr(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitPowExpr" ): listener.exitPowExpr(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitPowExpr" ): return visitor.visitPowExpr(self) else: return visitor.visitChildren(self) def powerExpression(self): localctx = PseudocodeParser.PowerExpressionContext(self, self._ctx, self.state) self.enterRule(localctx, 54, self.RULE_powerExpression) self._la = 0 # Token type try: self.state = 478 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input,64,self._ctx) if la_ == 1: localctx = PseudocodeParser.PowExprContext(self, localctx) self.enterOuterAlt(localctx, 1) self.state = 470 localctx.left = self.unaryExpression() self.state = 473 self._errHandler.sync(self) _la = self._input.LA(1) while True: self.state = 471 self.match(PseudocodeParser.POW) self.state = 472 localctx.right = self.unaryExpression() self.state = 475 self._errHandler.sync(self) _la = self._input.LA(1) if not (_la==28): break pass elif la_ == 2: localctx = PseudocodeParser.PowerPassContext(self, localctx) self.enterOuterAlt(localctx, 2) self.state = 477 self.unaryExpression() pass except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class UnaryExpressionContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def getRuleIndex(self): return PseudocodeParser.RULE_unaryExpression def copyFrom(self, ctx:ParserRuleContext): super().copyFrom(ctx) class UnaryPassContext(UnaryExpressionContext): def __init__(self, parser, ctx:ParserRuleContext): # actually a PseudocodeParser.UnaryExpressionContext super().__init__(parser) self.copyFrom(ctx) def primaryExpression(self): return self.getTypedRuleContext(PseudocodeParser.PrimaryExpressionContext,0) def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterUnaryPass" ): listener.enterUnaryPass(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitUnaryPass" ): listener.exitUnaryPass(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitUnaryPass" ): return visitor.visitUnaryPass(self) else: return visitor.visitChildren(self) class UnaryMinusExprContext(UnaryExpressionContext): def __init__(self, parser, ctx:ParserRuleContext): # actually a PseudocodeParser.UnaryExpressionContext super().__init__(parser) self.copyFrom(ctx) def MINUS(self): return self.getToken(PseudocodeParser.MINUS, 0) def unaryExpression(self): return self.getTypedRuleContext(PseudocodeParser.UnaryExpressionContext,0) def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterUnaryMinusExpr" ): listener.enterUnaryMinusExpr(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitUnaryMinusExpr" ): listener.exitUnaryMinusExpr(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitUnaryMinusExpr" ): return visitor.visitUnaryMinusExpr(self) else: return visitor.visitChildren(self) def unaryExpression(self): localctx = PseudocodeParser.UnaryExpressionContext(self, self._ctx, self.state) self.enterRule(localctx, 56, self.RULE_unaryExpression) try: self.state = 483 self._errHandler.sync(self) token = self._input.LA(1) if token in [34]: localctx = PseudocodeParser.UnaryMinusExprContext(self, localctx) self.enterOuterAlt(localctx, 1) self.state = 480 self.match(PseudocodeParser.MINUS) self.state = 481 self.unaryExpression() pass elif token in [12, 13, 16, 17, 18, 19, 20, 39]: localctx = PseudocodeParser.UnaryPassContext(self, localctx) self.enterOuterAlt(localctx, 2) self.state = 482 self.primaryExpression() pass else: raise NoViableAltException(self) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class PrimaryExpressionContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def getRuleIndex(self): return PseudocodeParser.RULE_primaryExpression def copyFrom(self, ctx:ParserRuleContext): super().copyFrom(ctx) class ParenExpressionContext(PrimaryExpressionContext): def __init__(self, parser, ctx:ParserRuleContext): # actually a PseudocodeParser.PrimaryExpressionContext super().__init__(parser) self.copyFrom(ctx) def LPAREN(self): return self.getToken(PseudocodeParser.LPAREN, 0) def expression(self): return self.getTypedRuleContext(PseudocodeParser.ExpressionContext,0) def RPAREN(self): return self.getToken(PseudocodeParser.RPAREN, 0) def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterParenExpression" ): listener.enterParenExpression(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitParenExpression" ): listener.exitParenExpression(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitParenExpression" ): return visitor.visitParenExpression(self) else: return visitor.visitChildren(self) class AtomExpressionContext(PrimaryExpressionContext): def __init__(self, parser, ctx:ParserRuleContext): # actually a PseudocodeParser.PrimaryExpressionContext super().__init__(parser) self.copyFrom(ctx) def atom(self): return self.getTypedRuleContext(PseudocodeParser.AtomContext,0) def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterAtomExpression" ): listener.enterAtomExpression(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitAtomExpression" ): listener.exitAtomExpression(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitAtomExpression" ): return visitor.visitAtomExpression(self) else: return visitor.visitChildren(self) class ArrayAccessExpressionContext(PrimaryExpressionContext): def __init__(self, parser, ctx:ParserRuleContext): # actually a PseudocodeParser.PrimaryExpressionContext super().__init__(parser) self.copyFrom(ctx) def ID(self): return self.getToken(PseudocodeParser.ID, 0) def LBRACK(self): return self.getToken(PseudocodeParser.LBRACK, 0) def expression(self): return self.getTypedRuleContext(PseudocodeParser.ExpressionContext,0) def RBRACK(self): return self.getToken(PseudocodeParser.RBRACK, 0) def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterArrayAccessExpression" ): listener.enterArrayAccessExpression(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitArrayAccessExpression" ): listener.exitArrayAccessExpression(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitArrayAccessExpression" ): return visitor.visitArrayAccessExpression(self) else: return visitor.visitChildren(self) class FunctionCallExpressionContext(PrimaryExpressionContext): def __init__(self, parser, ctx:ParserRuleContext): # actually a PseudocodeParser.PrimaryExpressionContext super().__init__(parser) self.copyFrom(ctx) def ID(self): return self.getToken(PseudocodeParser.ID, 0) def LPAREN(self): return self.getToken(PseudocodeParser.LPAREN, 0) def RPAREN(self): return self.getToken(PseudocodeParser.RPAREN, 0) def expressionList(self): return self.getTypedRuleContext(PseudocodeParser.ExpressionListContext,0) def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterFunctionCallExpression" ): listener.enterFunctionCallExpression(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitFunctionCallExpression" ): listener.exitFunctionCallExpression(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitFunctionCallExpression" ): return visitor.visitFunctionCallExpression(self) else: return visitor.visitChildren(self) def primaryExpression(self): localctx = PseudocodeParser.PrimaryExpressionContext(self, self._ctx, self.state) self.enterRule(localctx, 58, self.RULE_primaryExpression) self._la = 0 # Token type try: self.state = 501 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input,67,self._ctx) if la_ == 1: localctx = PseudocodeParser.ParenExpressionContext(self, localctx) self.enterOuterAlt(localctx, 1) self.state = 485 self.match(PseudocodeParser.LPAREN) self.state = 486 self.expression() self.state = 487 self.match(PseudocodeParser.RPAREN) pass elif la_ == 2: localctx = PseudocodeParser.FunctionCallExpressionContext(self, localctx) self.enterOuterAlt(localctx, 2) self.state = 489 self.match(PseudocodeParser.ID) self.state = 490 self.match(PseudocodeParser.LPAREN) self.state = 492 self._errHandler.sync(self) _la = self._input.LA(1) if (((_la) & ~0x3f) == 0 and ((1 << _la) & 566937726976) != 0): self.state = 491 self.expressionList() self.state = 494 self.match(PseudocodeParser.RPAREN) pass elif la_ == 3: localctx = PseudocodeParser.ArrayAccessExpressionContext(self, localctx) self.enterOuterAlt(localctx, 3) self.state = 495 self.match(PseudocodeParser.ID) self.state = 496 self.match(PseudocodeParser.LBRACK) self.state = 497 self.expression() self.state = 498 self.match(PseudocodeParser.RBRACK) pass elif la_ == 4: localctx = PseudocodeParser.AtomExpressionContext(self, localctx) self.enterOuterAlt(localctx, 4) self.state = 500 self.atom() pass except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class ExpressionListContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def expression(self, i:int=None): if i is None: return self.getTypedRuleContexts(PseudocodeParser.ExpressionContext) else: return self.getTypedRuleContext(PseudocodeParser.ExpressionContext,i) def COMMA(self, i:int=None): if i is None: return self.getTokens(PseudocodeParser.COMMA) else: return self.getToken(PseudocodeParser.COMMA, i) def getRuleIndex(self): return PseudocodeParser.RULE_expressionList def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterExpressionList" ): listener.enterExpressionList(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitExpressionList" ): listener.exitExpressionList(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitExpressionList" ): return visitor.visitExpressionList(self) else: return visitor.visitChildren(self) def expressionList(self): localctx = PseudocodeParser.ExpressionListContext(self, self._ctx, self.state) self.enterRule(localctx, 60, self.RULE_expressionList) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 503 self.expression() self.state = 508 self._errHandler.sync(self) _la = self._input.LA(1) while _la==42: self.state = 504 self.match(PseudocodeParser.COMMA) self.state = 505 self.expression() self.state = 510 self._errHandler.sync(self) _la = self._input.LA(1) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class AtomContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def ID(self): return self.getToken(PseudocodeParser.ID, 0) def INT(self): return self.getToken(PseudocodeParser.INT, 0) def FLOAT(self): return self.getToken(PseudocodeParser.FLOAT, 0) def TRUE(self): return self.getToken(PseudocodeParser.TRUE, 0) def FALSE(self): return self.getToken(PseudocodeParser.FALSE, 0) def NULL(self): return self.getToken(PseudocodeParser.NULL, 0) def STRING(self): return self.getToken(PseudocodeParser.STRING, 0) def getRuleIndex(self): return PseudocodeParser.RULE_atom def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterAtom" ): listener.enterAtom(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitAtom" ): listener.exitAtom(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitAtom" ): return visitor.visitAtom(self) else: return visitor.visitChildren(self) def atom(self): localctx = PseudocodeParser.AtomContext(self, self._ctx, self.state) self.enterRule(localctx, 62, self.RULE_atom) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 511 _la = self._input.LA(1) if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 2043904) != 0)): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx