# Generated from zaplangParser.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,78,551,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,7, 6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13,7,13, 2,14,7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,19,2,20, 7,20,2,21,7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2,26,7,26, 2,27,7,27,2,28,7,28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7,32,2,33, 7,33,2,34,7,34,2,35,7,35,2,36,7,36,2,37,7,37,2,38,7,38,2,39,7,39, 2,40,7,40,2,41,7,41,2,42,7,42,2,43,7,43,2,44,7,44,2,45,7,45,2,46, 7,46,2,47,7,47,2,48,7,48,1,0,5,0,100,8,0,10,0,12,0,103,9,0,1,1,1, 1,1,1,1,1,3,1,109,8,1,1,2,1,2,1,2,1,2,3,2,115,8,2,1,2,1,2,1,2,1, 3,1,3,3,3,122,8,3,1,4,1,4,1,5,1,5,1,5,5,5,129,8,5,10,5,12,5,132, 9,5,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,3,6,143,8,6,1,7,1,7,1,7, 3,7,148,8,7,1,7,5,7,151,8,7,10,7,12,7,154,9,7,1,7,1,7,1,7,3,7,159, 8,7,1,7,5,7,162,8,7,10,7,12,7,165,9,7,3,7,167,8,7,1,8,1,8,1,8,1, 8,1,8,1,8,1,8,3,8,176,8,8,1,9,1,9,1,9,1,9,1,9,1,9,3,9,184,8,9,1, 10,1,10,1,10,1,10,3,10,190,8,10,1,11,1,11,1,11,1,11,5,11,196,8,11, 10,11,12,11,199,9,11,1,11,1,11,1,11,1,12,1,12,1,12,1,12,1,12,1,12, 1,12,1,12,1,12,1,12,1,12,3,12,215,8,12,1,13,1,13,1,13,1,13,1,13, 1,13,1,13,1,14,1,14,1,14,5,14,227,8,14,10,14,12,14,230,9,14,1,15, 1,15,1,15,1,15,3,15,236,8,15,1,16,1,16,1,16,1,16,5,16,242,8,16,10, 16,12,16,245,9,16,1,16,1,16,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1, 17,1,17,1,17,1,17,1,17,1,17,1,17,3,17,263,8,17,1,18,1,18,1,19,1, 19,3,19,269,8,19,1,19,1,19,1,20,1,20,1,20,5,20,276,8,20,10,20,12, 20,279,9,20,1,21,1,21,1,21,1,21,1,21,1,21,3,21,287,8,21,1,22,1,22, 5,22,291,8,22,10,22,12,22,294,9,22,1,22,1,22,1,23,1,23,1,24,1,24, 1,24,1,24,3,24,304,8,24,1,25,1,25,1,25,1,25,1,25,1,25,1,25,1,25, 1,25,1,25,1,25,1,25,1,25,1,25,1,25,1,25,1,25,1,25,5,25,324,8,25, 10,25,12,25,327,9,25,1,25,3,25,330,8,25,1,25,3,25,333,8,25,1,26, 1,26,1,26,1,26,5,26,339,8,26,10,26,12,26,342,9,26,1,27,1,27,1,27, 5,27,347,8,27,10,27,12,27,350,9,27,1,28,1,28,1,28,1,28,1,28,1,28, 1,28,1,28,1,28,3,28,361,8,28,1,28,1,28,3,28,365,8,28,1,28,1,28,3, 28,369,8,28,1,28,1,28,3,28,373,8,28,1,29,1,29,3,29,377,8,29,1,29, 1,29,1,29,1,29,1,29,3,29,384,8,29,1,30,1,30,5,30,388,8,30,10,30, 12,30,391,9,30,1,30,5,30,394,8,30,10,30,12,30,397,9,30,1,30,1,30, 3,30,401,8,30,1,31,1,31,1,31,1,31,1,31,1,31,5,31,409,8,31,10,31, 12,31,412,9,31,1,32,1,32,1,32,1,32,1,32,3,32,419,8,32,1,33,1,33, 1,34,1,34,1,34,1,34,1,34,1,34,1,34,3,34,430,8,34,1,35,1,35,1,35, 5,35,435,8,35,10,35,12,35,438,9,35,1,36,1,36,1,36,5,36,443,8,36, 10,36,12,36,446,9,36,1,37,1,37,1,37,5,37,451,8,37,10,37,12,37,454, 9,37,1,38,1,38,1,38,5,38,459,8,38,10,38,12,38,462,9,38,1,39,1,39, 1,39,5,39,467,8,39,10,39,12,39,470,9,39,1,40,1,40,1,40,5,40,475, 8,40,10,40,12,40,478,9,40,1,41,1,41,1,41,5,41,483,8,41,10,41,12, 41,486,9,41,1,42,1,42,1,42,1,42,3,42,492,8,42,1,43,1,43,1,44,1,44, 1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,3,44,507,8,44,1,44, 1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,5,44,520,8,44, 10,44,12,44,523,9,44,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45, 1,45,1,45,1,45,3,45,537,8,45,1,46,1,46,1,47,1,47,1,47,5,47,544,8, 47,10,47,12,47,547,9,47,1,48,1,48,1,48,0,2,62,88,49,0,2,4,6,8,10, 12,14,16,18,20,22,24,26,28,30,32,34,36,38,40,42,44,46,48,50,52,54, 56,58,60,62,64,66,68,70,72,74,76,78,80,82,84,86,88,90,92,94,96,0, 8,1,0,54,64,1,0,65,66,1,0,30,33,1,0,43,44,2,0,34,34,36,36,1,0,38, 40,4,0,34,38,41,41,46,46,49,49,3,0,11,11,20,20,70,72,579,0,101,1, 0,0,0,2,108,1,0,0,0,4,110,1,0,0,0,6,121,1,0,0,0,8,123,1,0,0,0,10, 125,1,0,0,0,12,142,1,0,0,0,14,166,1,0,0,0,16,175,1,0,0,0,18,183, 1,0,0,0,20,189,1,0,0,0,22,191,1,0,0,0,24,214,1,0,0,0,26,216,1,0, 0,0,28,223,1,0,0,0,30,235,1,0,0,0,32,237,1,0,0,0,34,262,1,0,0,0, 36,264,1,0,0,0,38,266,1,0,0,0,40,272,1,0,0,0,42,286,1,0,0,0,44,288, 1,0,0,0,46,297,1,0,0,0,48,303,1,0,0,0,50,332,1,0,0,0,52,334,1,0, 0,0,54,343,1,0,0,0,56,372,1,0,0,0,58,383,1,0,0,0,60,400,1,0,0,0, 62,402,1,0,0,0,64,418,1,0,0,0,66,420,1,0,0,0,68,429,1,0,0,0,70,431, 1,0,0,0,72,439,1,0,0,0,74,447,1,0,0,0,76,455,1,0,0,0,78,463,1,0, 0,0,80,471,1,0,0,0,82,479,1,0,0,0,84,491,1,0,0,0,86,493,1,0,0,0, 88,495,1,0,0,0,90,536,1,0,0,0,92,538,1,0,0,0,94,540,1,0,0,0,96,548, 1,0,0,0,98,100,3,2,1,0,99,98,1,0,0,0,100,103,1,0,0,0,101,99,1,0, 0,0,101,102,1,0,0,0,102,1,1,0,0,0,103,101,1,0,0,0,104,109,3,4,2, 0,105,109,3,32,16,0,106,109,3,22,11,0,107,109,3,26,13,0,108,104, 1,0,0,0,108,105,1,0,0,0,108,106,1,0,0,0,108,107,1,0,0,0,109,3,1, 0,0,0,110,111,3,6,3,0,111,112,3,8,4,0,112,114,5,24,0,0,113,115,3, 10,5,0,114,113,1,0,0,0,114,115,1,0,0,0,115,116,1,0,0,0,116,117,5, 25,0,0,117,118,3,60,30,0,118,5,1,0,0,0,119,122,3,14,7,0,120,122, 5,22,0,0,121,119,1,0,0,0,121,120,1,0,0,0,122,7,1,0,0,0,123,124,5, 69,0,0,124,9,1,0,0,0,125,130,3,12,6,0,126,127,5,53,0,0,127,129,3, 12,6,0,128,126,1,0,0,0,129,132,1,0,0,0,130,128,1,0,0,0,130,131,1, 0,0,0,131,11,1,0,0,0,132,130,1,0,0,0,133,134,3,14,7,0,134,135,5, 69,0,0,135,143,1,0,0,0,136,137,3,14,7,0,137,138,5,69,0,0,138,139, 5,26,0,0,139,140,5,70,0,0,140,141,5,27,0,0,141,143,1,0,0,0,142,133, 1,0,0,0,142,136,1,0,0,0,143,13,1,0,0,0,144,152,3,16,8,0,145,147, 5,26,0,0,146,148,5,70,0,0,147,146,1,0,0,0,147,148,1,0,0,0,148,149, 1,0,0,0,149,151,5,27,0,0,150,145,1,0,0,0,151,154,1,0,0,0,152,150, 1,0,0,0,152,153,1,0,0,0,153,167,1,0,0,0,154,152,1,0,0,0,155,163, 3,20,10,0,156,158,5,26,0,0,157,159,5,70,0,0,158,157,1,0,0,0,158, 159,1,0,0,0,159,160,1,0,0,0,160,162,5,27,0,0,161,156,1,0,0,0,162, 165,1,0,0,0,163,161,1,0,0,0,163,164,1,0,0,0,164,167,1,0,0,0,165, 163,1,0,0,0,166,144,1,0,0,0,166,155,1,0,0,0,167,15,1,0,0,0,168,176, 5,15,0,0,169,176,5,8,0,0,170,176,5,12,0,0,171,176,5,5,0,0,172,176, 5,17,0,0,173,176,5,21,0,0,174,176,3,18,9,0,175,168,1,0,0,0,175,169, 1,0,0,0,175,170,1,0,0,0,175,171,1,0,0,0,175,172,1,0,0,0,175,173, 1,0,0,0,175,174,1,0,0,0,176,17,1,0,0,0,177,184,5,38,0,0,178,179, 5,38,0,0,179,184,5,38,0,0,180,181,5,38,0,0,181,182,5,38,0,0,182, 184,5,38,0,0,183,177,1,0,0,0,183,178,1,0,0,0,183,180,1,0,0,0,184, 19,1,0,0,0,185,186,5,18,0,0,186,190,5,69,0,0,187,188,5,10,0,0,188, 190,5,69,0,0,189,185,1,0,0,0,189,187,1,0,0,0,190,21,1,0,0,0,191, 192,5,18,0,0,192,193,5,69,0,0,193,197,5,28,0,0,194,196,3,24,12,0, 195,194,1,0,0,0,196,199,1,0,0,0,197,195,1,0,0,0,197,198,1,0,0,0, 198,200,1,0,0,0,199,197,1,0,0,0,200,201,5,29,0,0,201,202,5,52,0, 0,202,23,1,0,0,0,203,204,3,14,7,0,204,205,5,69,0,0,205,206,5,52, 0,0,206,215,1,0,0,0,207,208,3,14,7,0,208,209,5,69,0,0,209,210,5, 26,0,0,210,211,5,70,0,0,211,212,5,27,0,0,212,213,5,52,0,0,213,215, 1,0,0,0,214,203,1,0,0,0,214,207,1,0,0,0,215,25,1,0,0,0,216,217,5, 10,0,0,217,218,5,69,0,0,218,219,5,28,0,0,219,220,3,28,14,0,220,221, 5,29,0,0,221,222,5,52,0,0,222,27,1,0,0,0,223,228,3,30,15,0,224,225, 5,53,0,0,225,227,3,30,15,0,226,224,1,0,0,0,227,230,1,0,0,0,228,226, 1,0,0,0,228,229,1,0,0,0,229,29,1,0,0,0,230,228,1,0,0,0,231,236,5, 69,0,0,232,233,5,69,0,0,233,234,5,54,0,0,234,236,5,70,0,0,235,231, 1,0,0,0,235,232,1,0,0,0,236,31,1,0,0,0,237,238,3,14,7,0,238,243, 3,34,17,0,239,240,5,53,0,0,240,242,3,34,17,0,241,239,1,0,0,0,242, 245,1,0,0,0,243,241,1,0,0,0,243,244,1,0,0,0,244,246,1,0,0,0,245, 243,1,0,0,0,246,247,5,52,0,0,247,33,1,0,0,0,248,263,5,69,0,0,249, 250,5,69,0,0,250,251,5,54,0,0,251,263,3,36,18,0,252,253,5,69,0,0, 253,254,5,26,0,0,254,255,5,70,0,0,255,263,5,27,0,0,256,257,5,69, 0,0,257,258,5,26,0,0,258,259,5,70,0,0,259,260,5,27,0,0,260,261,5, 54,0,0,261,263,3,38,19,0,262,248,1,0,0,0,262,249,1,0,0,0,262,252, 1,0,0,0,262,256,1,0,0,0,263,35,1,0,0,0,264,265,3,64,32,0,265,37, 1,0,0,0,266,268,5,28,0,0,267,269,3,40,20,0,268,267,1,0,0,0,268,269, 1,0,0,0,269,270,1,0,0,0,270,271,5,29,0,0,271,39,1,0,0,0,272,277, 3,64,32,0,273,274,5,53,0,0,274,276,3,64,32,0,275,273,1,0,0,0,276, 279,1,0,0,0,277,275,1,0,0,0,277,278,1,0,0,0,278,41,1,0,0,0,279,277, 1,0,0,0,280,287,3,44,22,0,281,287,3,46,23,0,282,287,3,48,24,0,283, 287,3,50,25,0,284,287,3,56,28,0,285,287,3,58,29,0,286,280,1,0,0, 0,286,281,1,0,0,0,286,282,1,0,0,0,286,283,1,0,0,0,286,284,1,0,0, 0,286,285,1,0,0,0,287,43,1,0,0,0,288,292,5,28,0,0,289,291,3,42,21, 0,290,289,1,0,0,0,291,294,1,0,0,0,292,290,1,0,0,0,292,293,1,0,0, 0,293,295,1,0,0,0,294,292,1,0,0,0,295,296,5,29,0,0,296,45,1,0,0, 0,297,298,3,32,16,0,298,47,1,0,0,0,299,300,3,62,31,0,300,301,5,52, 0,0,301,304,1,0,0,0,302,304,5,52,0,0,303,299,1,0,0,0,303,302,1,0, 0,0,304,49,1,0,0,0,305,306,5,14,0,0,306,307,5,24,0,0,307,308,3,62, 31,0,308,309,5,25,0,0,309,310,3,42,21,0,310,333,1,0,0,0,311,312, 5,14,0,0,312,313,5,24,0,0,313,314,3,62,31,0,314,315,5,25,0,0,315, 316,3,42,21,0,316,317,5,9,0,0,317,318,3,42,21,0,318,333,1,0,0,0, 319,320,5,4,0,0,320,321,5,1,0,0,321,325,5,28,0,0,322,324,3,52,26, 0,323,322,1,0,0,0,324,327,1,0,0,0,325,323,1,0,0,0,325,326,1,0,0, 0,326,329,1,0,0,0,327,325,1,0,0,0,328,330,3,54,27,0,329,328,1,0, 0,0,329,330,1,0,0,0,330,331,1,0,0,0,331,333,5,29,0,0,332,305,1,0, 0,0,332,311,1,0,0,0,332,319,1,0,0,0,333,51,1,0,0,0,334,335,5,4,0, 0,335,336,3,92,46,0,336,340,5,51,0,0,337,339,3,42,21,0,338,337,1, 0,0,0,339,342,1,0,0,0,340,338,1,0,0,0,340,341,1,0,0,0,341,53,1,0, 0,0,342,340,1,0,0,0,343,344,5,6,0,0,344,348,5,51,0,0,345,347,3,42, 21,0,346,345,1,0,0,0,347,350,1,0,0,0,348,346,1,0,0,0,348,349,1,0, 0,0,349,55,1,0,0,0,350,348,1,0,0,0,351,352,5,23,0,0,352,353,5,24, 0,0,353,354,3,62,31,0,354,355,5,25,0,0,355,356,3,42,21,0,356,373, 1,0,0,0,357,358,5,13,0,0,358,360,5,24,0,0,359,361,3,48,24,0,360, 359,1,0,0,0,360,361,1,0,0,0,361,362,1,0,0,0,362,364,5,52,0,0,363, 365,3,62,31,0,364,363,1,0,0,0,364,365,1,0,0,0,365,366,1,0,0,0,366, 368,5,52,0,0,367,369,3,62,31,0,368,367,1,0,0,0,368,369,1,0,0,0,369, 370,1,0,0,0,370,371,5,25,0,0,371,373,3,42,21,0,372,351,1,0,0,0,372, 357,1,0,0,0,373,57,1,0,0,0,374,376,5,16,0,0,375,377,3,62,31,0,376, 375,1,0,0,0,376,377,1,0,0,0,377,378,1,0,0,0,378,384,5,52,0,0,379, 380,5,3,0,0,380,384,5,52,0,0,381,382,5,19,0,0,382,384,5,52,0,0,383, 374,1,0,0,0,383,379,1,0,0,0,383,381,1,0,0,0,384,59,1,0,0,0,385,389, 5,28,0,0,386,388,3,32,16,0,387,386,1,0,0,0,388,391,1,0,0,0,389,387, 1,0,0,0,389,390,1,0,0,0,390,395,1,0,0,0,391,389,1,0,0,0,392,394, 3,42,21,0,393,392,1,0,0,0,394,397,1,0,0,0,395,393,1,0,0,0,395,396, 1,0,0,0,396,398,1,0,0,0,397,395,1,0,0,0,398,401,5,29,0,0,399,401, 3,42,21,0,400,385,1,0,0,0,400,399,1,0,0,0,401,61,1,0,0,0,402,403, 6,31,-1,0,403,404,3,64,32,0,404,410,1,0,0,0,405,406,10,1,0,0,406, 407,5,53,0,0,407,409,3,64,32,0,408,405,1,0,0,0,409,412,1,0,0,0,410, 408,1,0,0,0,410,411,1,0,0,0,411,63,1,0,0,0,412,410,1,0,0,0,413,419, 3,68,34,0,414,415,3,84,42,0,415,416,3,66,33,0,416,417,3,64,32,0, 417,419,1,0,0,0,418,413,1,0,0,0,418,414,1,0,0,0,419,65,1,0,0,0,420, 421,7,0,0,0,421,67,1,0,0,0,422,430,3,70,35,0,423,424,3,70,35,0,424, 425,5,50,0,0,425,426,3,62,31,0,426,427,5,51,0,0,427,428,3,68,34, 0,428,430,1,0,0,0,429,422,1,0,0,0,429,423,1,0,0,0,430,69,1,0,0,0, 431,436,3,72,36,0,432,433,5,48,0,0,433,435,3,72,36,0,434,432,1,0, 0,0,435,438,1,0,0,0,436,434,1,0,0,0,436,437,1,0,0,0,437,71,1,0,0, 0,438,436,1,0,0,0,439,444,3,74,37,0,440,441,5,47,0,0,441,443,3,74, 37,0,442,440,1,0,0,0,443,446,1,0,0,0,444,442,1,0,0,0,444,445,1,0, 0,0,445,73,1,0,0,0,446,444,1,0,0,0,447,452,3,76,38,0,448,449,7,1, 0,0,449,451,3,76,38,0,450,448,1,0,0,0,451,454,1,0,0,0,452,450,1, 0,0,0,452,453,1,0,0,0,453,75,1,0,0,0,454,452,1,0,0,0,455,460,3,78, 39,0,456,457,7,2,0,0,457,459,3,78,39,0,458,456,1,0,0,0,459,462,1, 0,0,0,460,458,1,0,0,0,460,461,1,0,0,0,461,77,1,0,0,0,462,460,1,0, 0,0,463,468,3,80,40,0,464,465,7,3,0,0,465,467,3,80,40,0,466,464, 1,0,0,0,467,470,1,0,0,0,468,466,1,0,0,0,468,469,1,0,0,0,469,79,1, 0,0,0,470,468,1,0,0,0,471,476,3,82,41,0,472,473,7,4,0,0,473,475, 3,82,41,0,474,472,1,0,0,0,475,478,1,0,0,0,476,474,1,0,0,0,476,477, 1,0,0,0,477,81,1,0,0,0,478,476,1,0,0,0,479,484,3,84,42,0,480,481, 7,5,0,0,481,483,3,84,42,0,482,480,1,0,0,0,483,486,1,0,0,0,484,482, 1,0,0,0,484,485,1,0,0,0,485,83,1,0,0,0,486,484,1,0,0,0,487,488,3, 86,43,0,488,489,3,84,42,0,489,492,1,0,0,0,490,492,3,88,44,0,491, 487,1,0,0,0,491,490,1,0,0,0,492,85,1,0,0,0,493,494,7,6,0,0,494,87, 1,0,0,0,495,496,6,44,-1,0,496,497,3,90,45,0,497,521,1,0,0,0,498, 499,10,6,0,0,499,500,5,26,0,0,500,501,3,62,31,0,501,502,5,27,0,0, 502,520,1,0,0,0,503,504,10,5,0,0,504,506,5,24,0,0,505,507,3,94,47, 0,506,505,1,0,0,0,506,507,1,0,0,0,507,508,1,0,0,0,508,520,5,25,0, 0,509,510,10,4,0,0,510,511,5,68,0,0,511,520,5,69,0,0,512,513,10, 3,0,0,513,514,5,67,0,0,514,520,5,69,0,0,515,516,10,2,0,0,516,520, 5,35,0,0,517,518,10,1,0,0,518,520,5,37,0,0,519,498,1,0,0,0,519,503, 1,0,0,0,519,509,1,0,0,0,519,512,1,0,0,0,519,515,1,0,0,0,519,517, 1,0,0,0,520,523,1,0,0,0,521,519,1,0,0,0,521,522,1,0,0,0,522,89,1, 0,0,0,523,521,1,0,0,0,524,537,5,69,0,0,525,537,3,92,46,0,526,537, 5,73,0,0,527,528,5,24,0,0,528,529,3,62,31,0,529,530,5,25,0,0,530, 537,1,0,0,0,531,532,5,24,0,0,532,533,3,14,7,0,533,534,5,25,0,0,534, 535,3,84,42,0,535,537,1,0,0,0,536,524,1,0,0,0,536,525,1,0,0,0,536, 526,1,0,0,0,536,527,1,0,0,0,536,531,1,0,0,0,537,91,1,0,0,0,538,539, 7,7,0,0,539,93,1,0,0,0,540,545,3,64,32,0,541,542,5,53,0,0,542,544, 3,64,32,0,543,541,1,0,0,0,544,547,1,0,0,0,545,543,1,0,0,0,545,546, 1,0,0,0,546,95,1,0,0,0,547,545,1,0,0,0,548,549,5,1,0,0,549,97,1, 0,0,0,55,101,108,114,121,130,142,147,152,158,163,166,175,183,189, 197,214,228,235,243,262,268,277,286,292,303,325,329,332,340,348, 360,364,368,372,376,383,389,395,400,410,418,429,436,444,452,460, 468,476,484,491,506,519,521,536,545 ] class zaplangParser ( Parser ): grammarFileName = "zaplangParser.g4" atn = ATNDeserializer().deserialize(serializedATN()) decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ] sharedContextCache = PredictionContextCache() literalNames = [ "", "'bul'", "'func'", "'fin'", "'caso'", "'carac'", "'pordef'", "'hacer'", "'doble'", "'sino'", "'enum'", "'falso'", "'flot'", "'por'", "'si'", "'Ent'", "'retornar'", "'cf'", "'estruct'", "'interrup'", "'verdadero'", "'sf'", "'vacio'", "'mientras'", "'('", "')'", "'['", "']'", "'{'", "'}'", "'<'", "'<='", "'>'", "'>='", "'+'", "'++'", "'-'", "'--'", "'*'", "'/'", "'%'", "'&'", "'|'", "'<<'", "'>>'", "'^'", "'~'", "'&&'", "'||'", "'!'", "'?'", "':'", "';'", "','", "'='", "'*='", "'/='", "'%='", "'+='", "'-='", "'&='", "'|='", "'<<='", "'>>='", "'^='", "'=='", "'!='", "'->'", "'.'" ] symbolicNames = [ "", "Bul", "Func", "Fin", "Caso", "Carac", "Pordef", "Hacer", "Doble", "Sino", "Enum", "Falso", "Flot", "Por", "Si", "Ent", "Retornar", "ConFirma", "Estruct", "Interrup", "Verdadero", "SinFirma", "Vacio", "Mientras", "ParenIzq", "ParenDer", "CorcheteIzq", "CorcheteDer", "LlaveIzq", "LlaveDer", "MenorQue", "MenorOIgualQue", "MayorQue", "MayorOIgualQue", "Mas", "MasMas", "Menos", "MenosMenos", "Estrella", "Div", "Mod", "Y", "O", "DesplazIzq", "DesplazDer", "Xor", "Complemento", "YY", "OO", "Not", "Pregunta", "DosPuntos", "PuntoYComa", "Coma", "Asignar", "EstrellaAsignacion", "DivAsignacion", "ModAsignacion", "MasAsignacion", "MenosAsignacion", "YAsignacion", "OAsignacion", "DesplazIzqAsignacion", "DesplazDerAsignacion", "XorAsignacion", "Igual", "Diferente", "Flecha", "Punto", "Identificador", "ConstanteEntera", "ConstanteFlotante", "ConstanteCaracteres", "CadenaLiteral", "Whitespace", "Newline", "BlockComment", "LineComment", "LineCommentHash" ] RULE_unidadTraduccion = 0 RULE_declaracionExterna = 1 RULE_declaracionFuncion = 2 RULE_tipoRetorno = 3 RULE_identificadorFuncion = 4 RULE_listaParametros = 5 RULE_declaracionParametro = 6 RULE_especificadorTipo = 7 RULE_tipoBasico = 8 RULE_puntero = 9 RULE_tipoEstructurado = 10 RULE_declaracionEstruct = 11 RULE_miembroEstruct = 12 RULE_declaracionEnum = 13 RULE_listaEnumeradores = 14 RULE_enumerador = 15 RULE_declaracionVariable = 16 RULE_inicializadorVariable = 17 RULE_inicializador = 18 RULE_inicializadorArreglo = 19 RULE_listaInitializers = 20 RULE_sentencia = 21 RULE_sentenciaCompuesta = 22 RULE_sentenciaDeclaracion = 23 RULE_sentenciaExpresion = 24 RULE_sentenciaSeleccion = 25 RULE_casoEtiqueta = 26 RULE_etiquetaPorDef = 27 RULE_sentenciaIteracion = 28 RULE_sentenciaSalto = 29 RULE_bloque = 30 RULE_expresion = 31 RULE_asignacionExpresion = 32 RULE_operadorAsignacion = 33 RULE_expresionCondicional = 34 RULE_expresionLogicaO = 35 RULE_expresionLogicaY = 36 RULE_expresionIgualacion = 37 RULE_expresionRelacional = 38 RULE_expresionDesplazamiento = 39 RULE_expresionAditiva = 40 RULE_expresionMultiplicativa = 41 RULE_expresionUnaria = 42 RULE_operadorUnario = 43 RULE_expresionPostfija = 44 RULE_expresionPrimaria = 45 RULE_constanteExpresion = 46 RULE_listaArgumentos = 47 RULE_marcaPunto = 48 ruleNames = [ "unidadTraduccion", "declaracionExterna", "declaracionFuncion", "tipoRetorno", "identificadorFuncion", "listaParametros", "declaracionParametro", "especificadorTipo", "tipoBasico", "puntero", "tipoEstructurado", "declaracionEstruct", "miembroEstruct", "declaracionEnum", "listaEnumeradores", "enumerador", "declaracionVariable", "inicializadorVariable", "inicializador", "inicializadorArreglo", "listaInitializers", "sentencia", "sentenciaCompuesta", "sentenciaDeclaracion", "sentenciaExpresion", "sentenciaSeleccion", "casoEtiqueta", "etiquetaPorDef", "sentenciaIteracion", "sentenciaSalto", "bloque", "expresion", "asignacionExpresion", "operadorAsignacion", "expresionCondicional", "expresionLogicaO", "expresionLogicaY", "expresionIgualacion", "expresionRelacional", "expresionDesplazamiento", "expresionAditiva", "expresionMultiplicativa", "expresionUnaria", "operadorUnario", "expresionPostfija", "expresionPrimaria", "constanteExpresion", "listaArgumentos", "marcaPunto" ] EOF = Token.EOF Bul=1 Func=2 Fin=3 Caso=4 Carac=5 Pordef=6 Hacer=7 Doble=8 Sino=9 Enum=10 Falso=11 Flot=12 Por=13 Si=14 Ent=15 Retornar=16 ConFirma=17 Estruct=18 Interrup=19 Verdadero=20 SinFirma=21 Vacio=22 Mientras=23 ParenIzq=24 ParenDer=25 CorcheteIzq=26 CorcheteDer=27 LlaveIzq=28 LlaveDer=29 MenorQue=30 MenorOIgualQue=31 MayorQue=32 MayorOIgualQue=33 Mas=34 MasMas=35 Menos=36 MenosMenos=37 Estrella=38 Div=39 Mod=40 Y=41 O=42 DesplazIzq=43 DesplazDer=44 Xor=45 Complemento=46 YY=47 OO=48 Not=49 Pregunta=50 DosPuntos=51 PuntoYComa=52 Coma=53 Asignar=54 EstrellaAsignacion=55 DivAsignacion=56 ModAsignacion=57 MasAsignacion=58 MenosAsignacion=59 YAsignacion=60 OAsignacion=61 DesplazIzqAsignacion=62 DesplazDerAsignacion=63 XorAsignacion=64 Igual=65 Diferente=66 Flecha=67 Punto=68 Identificador=69 ConstanteEntera=70 ConstanteFlotante=71 ConstanteCaracteres=72 CadenaLiteral=73 Whitespace=74 Newline=75 BlockComment=76 LineComment=77 LineCommentHash=78 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 UnidadTraduccionContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def declaracionExterna(self, i:int=None): if i is None: return self.getTypedRuleContexts(zaplangParser.DeclaracionExternaContext) else: return self.getTypedRuleContext(zaplangParser.DeclaracionExternaContext,i) def getRuleIndex(self): return zaplangParser.RULE_unidadTraduccion def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterUnidadTraduccion" ): listener.enterUnidadTraduccion(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitUnidadTraduccion" ): listener.exitUnidadTraduccion(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitUnidadTraduccion" ): return visitor.visitUnidadTraduccion(self) else: return visitor.visitChildren(self) def unidadTraduccion(self): localctx = zaplangParser.UnidadTraduccionContext(self, self._ctx, self.state) self.enterRule(localctx, 0, self.RULE_unidadTraduccion) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 101 self._errHandler.sync(self) _la = self._input.LA(1) while (((_la) & ~0x3f) == 0 and ((1 << _la) & 274884629792) != 0): self.state = 98 self.declaracionExterna() self.state = 103 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 DeclaracionExternaContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def declaracionFuncion(self): return self.getTypedRuleContext(zaplangParser.DeclaracionFuncionContext,0) def declaracionVariable(self): return self.getTypedRuleContext(zaplangParser.DeclaracionVariableContext,0) def declaracionEstruct(self): return self.getTypedRuleContext(zaplangParser.DeclaracionEstructContext,0) def declaracionEnum(self): return self.getTypedRuleContext(zaplangParser.DeclaracionEnumContext,0) def getRuleIndex(self): return zaplangParser.RULE_declaracionExterna def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterDeclaracionExterna" ): listener.enterDeclaracionExterna(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitDeclaracionExterna" ): listener.exitDeclaracionExterna(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitDeclaracionExterna" ): return visitor.visitDeclaracionExterna(self) else: return visitor.visitChildren(self) def declaracionExterna(self): localctx = zaplangParser.DeclaracionExternaContext(self, self._ctx, self.state) self.enterRule(localctx, 2, self.RULE_declaracionExterna) try: self.state = 108 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input,1,self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) self.state = 104 self.declaracionFuncion() pass elif la_ == 2: self.enterOuterAlt(localctx, 2) self.state = 105 self.declaracionVariable() pass elif la_ == 3: self.enterOuterAlt(localctx, 3) self.state = 106 self.declaracionEstruct() pass elif la_ == 4: self.enterOuterAlt(localctx, 4) self.state = 107 self.declaracionEnum() pass except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class DeclaracionFuncionContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def tipoRetorno(self): return self.getTypedRuleContext(zaplangParser.TipoRetornoContext,0) def identificadorFuncion(self): return self.getTypedRuleContext(zaplangParser.IdentificadorFuncionContext,0) def ParenIzq(self): return self.getToken(zaplangParser.ParenIzq, 0) def ParenDer(self): return self.getToken(zaplangParser.ParenDer, 0) def bloque(self): return self.getTypedRuleContext(zaplangParser.BloqueContext,0) def listaParametros(self): return self.getTypedRuleContext(zaplangParser.ListaParametrosContext,0) def getRuleIndex(self): return zaplangParser.RULE_declaracionFuncion def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterDeclaracionFuncion" ): listener.enterDeclaracionFuncion(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitDeclaracionFuncion" ): listener.exitDeclaracionFuncion(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitDeclaracionFuncion" ): return visitor.visitDeclaracionFuncion(self) else: return visitor.visitChildren(self) def declaracionFuncion(self): localctx = zaplangParser.DeclaracionFuncionContext(self, self._ctx, self.state) self.enterRule(localctx, 4, self.RULE_declaracionFuncion) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 110 self.tipoRetorno() self.state = 111 self.identificadorFuncion() self.state = 112 self.match(zaplangParser.ParenIzq) self.state = 114 self._errHandler.sync(self) _la = self._input.LA(1) if (((_la) & ~0x3f) == 0 and ((1 << _la) & 274880435488) != 0): self.state = 113 self.listaParametros() self.state = 116 self.match(zaplangParser.ParenDer) self.state = 117 self.bloque() except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class TipoRetornoContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def especificadorTipo(self): return self.getTypedRuleContext(zaplangParser.EspecificadorTipoContext,0) def Vacio(self): return self.getToken(zaplangParser.Vacio, 0) def getRuleIndex(self): return zaplangParser.RULE_tipoRetorno def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterTipoRetorno" ): listener.enterTipoRetorno(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitTipoRetorno" ): listener.exitTipoRetorno(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitTipoRetorno" ): return visitor.visitTipoRetorno(self) else: return visitor.visitChildren(self) def tipoRetorno(self): localctx = zaplangParser.TipoRetornoContext(self, self._ctx, self.state) self.enterRule(localctx, 6, self.RULE_tipoRetorno) try: self.state = 121 self._errHandler.sync(self) token = self._input.LA(1) if token in [5, 8, 10, 12, 15, 17, 18, 21, 38]: self.enterOuterAlt(localctx, 1) self.state = 119 self.especificadorTipo() pass elif token in [22]: self.enterOuterAlt(localctx, 2) self.state = 120 self.match(zaplangParser.Vacio) 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 IdentificadorFuncionContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def Identificador(self): return self.getToken(zaplangParser.Identificador, 0) def getRuleIndex(self): return zaplangParser.RULE_identificadorFuncion def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterIdentificadorFuncion" ): listener.enterIdentificadorFuncion(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitIdentificadorFuncion" ): listener.exitIdentificadorFuncion(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitIdentificadorFuncion" ): return visitor.visitIdentificadorFuncion(self) else: return visitor.visitChildren(self) def identificadorFuncion(self): localctx = zaplangParser.IdentificadorFuncionContext(self, self._ctx, self.state) self.enterRule(localctx, 8, self.RULE_identificadorFuncion) try: self.enterOuterAlt(localctx, 1) self.state = 123 self.match(zaplangParser.Identificador) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class ListaParametrosContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def declaracionParametro(self, i:int=None): if i is None: return self.getTypedRuleContexts(zaplangParser.DeclaracionParametroContext) else: return self.getTypedRuleContext(zaplangParser.DeclaracionParametroContext,i) def Coma(self, i:int=None): if i is None: return self.getTokens(zaplangParser.Coma) else: return self.getToken(zaplangParser.Coma, i) def getRuleIndex(self): return zaplangParser.RULE_listaParametros def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterListaParametros" ): listener.enterListaParametros(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitListaParametros" ): listener.exitListaParametros(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitListaParametros" ): return visitor.visitListaParametros(self) else: return visitor.visitChildren(self) def listaParametros(self): localctx = zaplangParser.ListaParametrosContext(self, self._ctx, self.state) self.enterRule(localctx, 10, self.RULE_listaParametros) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 125 self.declaracionParametro() self.state = 130 self._errHandler.sync(self) _la = self._input.LA(1) while _la==53: self.state = 126 self.match(zaplangParser.Coma) self.state = 127 self.declaracionParametro() self.state = 132 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 DeclaracionParametroContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def especificadorTipo(self): return self.getTypedRuleContext(zaplangParser.EspecificadorTipoContext,0) def Identificador(self): return self.getToken(zaplangParser.Identificador, 0) def CorcheteIzq(self): return self.getToken(zaplangParser.CorcheteIzq, 0) def ConstanteEntera(self): return self.getToken(zaplangParser.ConstanteEntera, 0) def CorcheteDer(self): return self.getToken(zaplangParser.CorcheteDer, 0) def getRuleIndex(self): return zaplangParser.RULE_declaracionParametro def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterDeclaracionParametro" ): listener.enterDeclaracionParametro(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitDeclaracionParametro" ): listener.exitDeclaracionParametro(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitDeclaracionParametro" ): return visitor.visitDeclaracionParametro(self) else: return visitor.visitChildren(self) def declaracionParametro(self): localctx = zaplangParser.DeclaracionParametroContext(self, self._ctx, self.state) self.enterRule(localctx, 12, self.RULE_declaracionParametro) try: self.state = 142 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input,5,self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) self.state = 133 self.especificadorTipo() self.state = 134 self.match(zaplangParser.Identificador) pass elif la_ == 2: self.enterOuterAlt(localctx, 2) self.state = 136 self.especificadorTipo() self.state = 137 self.match(zaplangParser.Identificador) self.state = 138 self.match(zaplangParser.CorcheteIzq) self.state = 139 self.match(zaplangParser.ConstanteEntera) self.state = 140 self.match(zaplangParser.CorcheteDer) pass except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class EspecificadorTipoContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def tipoBasico(self): return self.getTypedRuleContext(zaplangParser.TipoBasicoContext,0) def CorcheteIzq(self, i:int=None): if i is None: return self.getTokens(zaplangParser.CorcheteIzq) else: return self.getToken(zaplangParser.CorcheteIzq, i) def CorcheteDer(self, i:int=None): if i is None: return self.getTokens(zaplangParser.CorcheteDer) else: return self.getToken(zaplangParser.CorcheteDer, i) def ConstanteEntera(self, i:int=None): if i is None: return self.getTokens(zaplangParser.ConstanteEntera) else: return self.getToken(zaplangParser.ConstanteEntera, i) def tipoEstructurado(self): return self.getTypedRuleContext(zaplangParser.TipoEstructuradoContext,0) def getRuleIndex(self): return zaplangParser.RULE_especificadorTipo def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterEspecificadorTipo" ): listener.enterEspecificadorTipo(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitEspecificadorTipo" ): listener.exitEspecificadorTipo(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitEspecificadorTipo" ): return visitor.visitEspecificadorTipo(self) else: return visitor.visitChildren(self) def especificadorTipo(self): localctx = zaplangParser.EspecificadorTipoContext(self, self._ctx, self.state) self.enterRule(localctx, 14, self.RULE_especificadorTipo) self._la = 0 # Token type try: self.state = 166 self._errHandler.sync(self) token = self._input.LA(1) if token in [5, 8, 12, 15, 17, 21, 38]: self.enterOuterAlt(localctx, 1) self.state = 144 self.tipoBasico() self.state = 152 self._errHandler.sync(self) _la = self._input.LA(1) while _la==26: self.state = 145 self.match(zaplangParser.CorcheteIzq) self.state = 147 self._errHandler.sync(self) _la = self._input.LA(1) if _la==70: self.state = 146 self.match(zaplangParser.ConstanteEntera) self.state = 149 self.match(zaplangParser.CorcheteDer) self.state = 154 self._errHandler.sync(self) _la = self._input.LA(1) pass elif token in [10, 18]: self.enterOuterAlt(localctx, 2) self.state = 155 self.tipoEstructurado() self.state = 163 self._errHandler.sync(self) _la = self._input.LA(1) while _la==26: self.state = 156 self.match(zaplangParser.CorcheteIzq) self.state = 158 self._errHandler.sync(self) _la = self._input.LA(1) if _la==70: self.state = 157 self.match(zaplangParser.ConstanteEntera) self.state = 160 self.match(zaplangParser.CorcheteDer) self.state = 165 self._errHandler.sync(self) _la = self._input.LA(1) 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 TipoBasicoContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def Ent(self): return self.getToken(zaplangParser.Ent, 0) def Doble(self): return self.getToken(zaplangParser.Doble, 0) def Flot(self): return self.getToken(zaplangParser.Flot, 0) def Carac(self): return self.getToken(zaplangParser.Carac, 0) def ConFirma(self): return self.getToken(zaplangParser.ConFirma, 0) def SinFirma(self): return self.getToken(zaplangParser.SinFirma, 0) def puntero(self): return self.getTypedRuleContext(zaplangParser.PunteroContext,0) def getRuleIndex(self): return zaplangParser.RULE_tipoBasico def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterTipoBasico" ): listener.enterTipoBasico(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitTipoBasico" ): listener.exitTipoBasico(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitTipoBasico" ): return visitor.visitTipoBasico(self) else: return visitor.visitChildren(self) def tipoBasico(self): localctx = zaplangParser.TipoBasicoContext(self, self._ctx, self.state) self.enterRule(localctx, 16, self.RULE_tipoBasico) try: self.state = 175 self._errHandler.sync(self) token = self._input.LA(1) if token in [15]: self.enterOuterAlt(localctx, 1) self.state = 168 self.match(zaplangParser.Ent) pass elif token in [8]: self.enterOuterAlt(localctx, 2) self.state = 169 self.match(zaplangParser.Doble) pass elif token in [12]: self.enterOuterAlt(localctx, 3) self.state = 170 self.match(zaplangParser.Flot) pass elif token in [5]: self.enterOuterAlt(localctx, 4) self.state = 171 self.match(zaplangParser.Carac) pass elif token in [17]: self.enterOuterAlt(localctx, 5) self.state = 172 self.match(zaplangParser.ConFirma) pass elif token in [21]: self.enterOuterAlt(localctx, 6) self.state = 173 self.match(zaplangParser.SinFirma) pass elif token in [38]: self.enterOuterAlt(localctx, 7) self.state = 174 self.puntero() 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 PunteroContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def Estrella(self, i:int=None): if i is None: return self.getTokens(zaplangParser.Estrella) else: return self.getToken(zaplangParser.Estrella, i) def getRuleIndex(self): return zaplangParser.RULE_puntero def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterPuntero" ): listener.enterPuntero(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitPuntero" ): listener.exitPuntero(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitPuntero" ): return visitor.visitPuntero(self) else: return visitor.visitChildren(self) def puntero(self): localctx = zaplangParser.PunteroContext(self, self._ctx, self.state) self.enterRule(localctx, 18, self.RULE_puntero) try: self.state = 183 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input,12,self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) self.state = 177 self.match(zaplangParser.Estrella) pass elif la_ == 2: self.enterOuterAlt(localctx, 2) self.state = 178 self.match(zaplangParser.Estrella) self.state = 179 self.match(zaplangParser.Estrella) pass elif la_ == 3: self.enterOuterAlt(localctx, 3) self.state = 180 self.match(zaplangParser.Estrella) self.state = 181 self.match(zaplangParser.Estrella) self.state = 182 self.match(zaplangParser.Estrella) pass except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class TipoEstructuradoContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def Estruct(self): return self.getToken(zaplangParser.Estruct, 0) def Identificador(self): return self.getToken(zaplangParser.Identificador, 0) def Enum(self): return self.getToken(zaplangParser.Enum, 0) def getRuleIndex(self): return zaplangParser.RULE_tipoEstructurado def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterTipoEstructurado" ): listener.enterTipoEstructurado(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitTipoEstructurado" ): listener.exitTipoEstructurado(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitTipoEstructurado" ): return visitor.visitTipoEstructurado(self) else: return visitor.visitChildren(self) def tipoEstructurado(self): localctx = zaplangParser.TipoEstructuradoContext(self, self._ctx, self.state) self.enterRule(localctx, 20, self.RULE_tipoEstructurado) try: self.state = 189 self._errHandler.sync(self) token = self._input.LA(1) if token in [18]: self.enterOuterAlt(localctx, 1) self.state = 185 self.match(zaplangParser.Estruct) self.state = 186 self.match(zaplangParser.Identificador) pass elif token in [10]: self.enterOuterAlt(localctx, 2) self.state = 187 self.match(zaplangParser.Enum) self.state = 188 self.match(zaplangParser.Identificador) 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 DeclaracionEstructContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def Estruct(self): return self.getToken(zaplangParser.Estruct, 0) def Identificador(self): return self.getToken(zaplangParser.Identificador, 0) def LlaveIzq(self): return self.getToken(zaplangParser.LlaveIzq, 0) def LlaveDer(self): return self.getToken(zaplangParser.LlaveDer, 0) def PuntoYComa(self): return self.getToken(zaplangParser.PuntoYComa, 0) def miembroEstruct(self, i:int=None): if i is None: return self.getTypedRuleContexts(zaplangParser.MiembroEstructContext) else: return self.getTypedRuleContext(zaplangParser.MiembroEstructContext,i) def getRuleIndex(self): return zaplangParser.RULE_declaracionEstruct def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterDeclaracionEstruct" ): listener.enterDeclaracionEstruct(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitDeclaracionEstruct" ): listener.exitDeclaracionEstruct(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitDeclaracionEstruct" ): return visitor.visitDeclaracionEstruct(self) else: return visitor.visitChildren(self) def declaracionEstruct(self): localctx = zaplangParser.DeclaracionEstructContext(self, self._ctx, self.state) self.enterRule(localctx, 22, self.RULE_declaracionEstruct) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 191 self.match(zaplangParser.Estruct) self.state = 192 self.match(zaplangParser.Identificador) self.state = 193 self.match(zaplangParser.LlaveIzq) self.state = 197 self._errHandler.sync(self) _la = self._input.LA(1) while (((_la) & ~0x3f) == 0 and ((1 << _la) & 274880435488) != 0): self.state = 194 self.miembroEstruct() self.state = 199 self._errHandler.sync(self) _la = self._input.LA(1) self.state = 200 self.match(zaplangParser.LlaveDer) self.state = 201 self.match(zaplangParser.PuntoYComa) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class MiembroEstructContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def especificadorTipo(self): return self.getTypedRuleContext(zaplangParser.EspecificadorTipoContext,0) def Identificador(self): return self.getToken(zaplangParser.Identificador, 0) def PuntoYComa(self): return self.getToken(zaplangParser.PuntoYComa, 0) def CorcheteIzq(self): return self.getToken(zaplangParser.CorcheteIzq, 0) def ConstanteEntera(self): return self.getToken(zaplangParser.ConstanteEntera, 0) def CorcheteDer(self): return self.getToken(zaplangParser.CorcheteDer, 0) def getRuleIndex(self): return zaplangParser.RULE_miembroEstruct def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterMiembroEstruct" ): listener.enterMiembroEstruct(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitMiembroEstruct" ): listener.exitMiembroEstruct(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitMiembroEstruct" ): return visitor.visitMiembroEstruct(self) else: return visitor.visitChildren(self) def miembroEstruct(self): localctx = zaplangParser.MiembroEstructContext(self, self._ctx, self.state) self.enterRule(localctx, 24, self.RULE_miembroEstruct) try: self.state = 214 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input,15,self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) self.state = 203 self.especificadorTipo() self.state = 204 self.match(zaplangParser.Identificador) self.state = 205 self.match(zaplangParser.PuntoYComa) pass elif la_ == 2: self.enterOuterAlt(localctx, 2) self.state = 207 self.especificadorTipo() self.state = 208 self.match(zaplangParser.Identificador) self.state = 209 self.match(zaplangParser.CorcheteIzq) self.state = 210 self.match(zaplangParser.ConstanteEntera) self.state = 211 self.match(zaplangParser.CorcheteDer) self.state = 212 self.match(zaplangParser.PuntoYComa) pass except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class DeclaracionEnumContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def Enum(self): return self.getToken(zaplangParser.Enum, 0) def Identificador(self): return self.getToken(zaplangParser.Identificador, 0) def LlaveIzq(self): return self.getToken(zaplangParser.LlaveIzq, 0) def listaEnumeradores(self): return self.getTypedRuleContext(zaplangParser.ListaEnumeradoresContext,0) def LlaveDer(self): return self.getToken(zaplangParser.LlaveDer, 0) def PuntoYComa(self): return self.getToken(zaplangParser.PuntoYComa, 0) def getRuleIndex(self): return zaplangParser.RULE_declaracionEnum def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterDeclaracionEnum" ): listener.enterDeclaracionEnum(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitDeclaracionEnum" ): listener.exitDeclaracionEnum(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitDeclaracionEnum" ): return visitor.visitDeclaracionEnum(self) else: return visitor.visitChildren(self) def declaracionEnum(self): localctx = zaplangParser.DeclaracionEnumContext(self, self._ctx, self.state) self.enterRule(localctx, 26, self.RULE_declaracionEnum) try: self.enterOuterAlt(localctx, 1) self.state = 216 self.match(zaplangParser.Enum) self.state = 217 self.match(zaplangParser.Identificador) self.state = 218 self.match(zaplangParser.LlaveIzq) self.state = 219 self.listaEnumeradores() self.state = 220 self.match(zaplangParser.LlaveDer) self.state = 221 self.match(zaplangParser.PuntoYComa) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class ListaEnumeradoresContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def enumerador(self, i:int=None): if i is None: return self.getTypedRuleContexts(zaplangParser.EnumeradorContext) else: return self.getTypedRuleContext(zaplangParser.EnumeradorContext,i) def Coma(self, i:int=None): if i is None: return self.getTokens(zaplangParser.Coma) else: return self.getToken(zaplangParser.Coma, i) def getRuleIndex(self): return zaplangParser.RULE_listaEnumeradores def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterListaEnumeradores" ): listener.enterListaEnumeradores(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitListaEnumeradores" ): listener.exitListaEnumeradores(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitListaEnumeradores" ): return visitor.visitListaEnumeradores(self) else: return visitor.visitChildren(self) def listaEnumeradores(self): localctx = zaplangParser.ListaEnumeradoresContext(self, self._ctx, self.state) self.enterRule(localctx, 28, self.RULE_listaEnumeradores) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 223 self.enumerador() self.state = 228 self._errHandler.sync(self) _la = self._input.LA(1) while _la==53: self.state = 224 self.match(zaplangParser.Coma) self.state = 225 self.enumerador() self.state = 230 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 EnumeradorContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def Identificador(self): return self.getToken(zaplangParser.Identificador, 0) def Asignar(self): return self.getToken(zaplangParser.Asignar, 0) def ConstanteEntera(self): return self.getToken(zaplangParser.ConstanteEntera, 0) def getRuleIndex(self): return zaplangParser.RULE_enumerador def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterEnumerador" ): listener.enterEnumerador(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitEnumerador" ): listener.exitEnumerador(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitEnumerador" ): return visitor.visitEnumerador(self) else: return visitor.visitChildren(self) def enumerador(self): localctx = zaplangParser.EnumeradorContext(self, self._ctx, self.state) self.enterRule(localctx, 30, self.RULE_enumerador) try: self.state = 235 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input,17,self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) self.state = 231 self.match(zaplangParser.Identificador) pass elif la_ == 2: self.enterOuterAlt(localctx, 2) self.state = 232 self.match(zaplangParser.Identificador) self.state = 233 self.match(zaplangParser.Asignar) self.state = 234 self.match(zaplangParser.ConstanteEntera) pass except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class DeclaracionVariableContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def especificadorTipo(self): return self.getTypedRuleContext(zaplangParser.EspecificadorTipoContext,0) def inicializadorVariable(self, i:int=None): if i is None: return self.getTypedRuleContexts(zaplangParser.InicializadorVariableContext) else: return self.getTypedRuleContext(zaplangParser.InicializadorVariableContext,i) def PuntoYComa(self): return self.getToken(zaplangParser.PuntoYComa, 0) def Coma(self, i:int=None): if i is None: return self.getTokens(zaplangParser.Coma) else: return self.getToken(zaplangParser.Coma, i) def getRuleIndex(self): return zaplangParser.RULE_declaracionVariable def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterDeclaracionVariable" ): listener.enterDeclaracionVariable(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitDeclaracionVariable" ): listener.exitDeclaracionVariable(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitDeclaracionVariable" ): return visitor.visitDeclaracionVariable(self) else: return visitor.visitChildren(self) def declaracionVariable(self): localctx = zaplangParser.DeclaracionVariableContext(self, self._ctx, self.state) self.enterRule(localctx, 32, self.RULE_declaracionVariable) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 237 self.especificadorTipo() self.state = 238 self.inicializadorVariable() self.state = 243 self._errHandler.sync(self) _la = self._input.LA(1) while _la==53: self.state = 239 self.match(zaplangParser.Coma) self.state = 240 self.inicializadorVariable() self.state = 245 self._errHandler.sync(self) _la = self._input.LA(1) self.state = 246 self.match(zaplangParser.PuntoYComa) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class InicializadorVariableContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def Identificador(self): return self.getToken(zaplangParser.Identificador, 0) def Asignar(self): return self.getToken(zaplangParser.Asignar, 0) def inicializador(self): return self.getTypedRuleContext(zaplangParser.InicializadorContext,0) def CorcheteIzq(self): return self.getToken(zaplangParser.CorcheteIzq, 0) def ConstanteEntera(self): return self.getToken(zaplangParser.ConstanteEntera, 0) def CorcheteDer(self): return self.getToken(zaplangParser.CorcheteDer, 0) def inicializadorArreglo(self): return self.getTypedRuleContext(zaplangParser.InicializadorArregloContext,0) def getRuleIndex(self): return zaplangParser.RULE_inicializadorVariable def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterInicializadorVariable" ): listener.enterInicializadorVariable(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitInicializadorVariable" ): listener.exitInicializadorVariable(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitInicializadorVariable" ): return visitor.visitInicializadorVariable(self) else: return visitor.visitChildren(self) def inicializadorVariable(self): localctx = zaplangParser.InicializadorVariableContext(self, self._ctx, self.state) self.enterRule(localctx, 34, self.RULE_inicializadorVariable) try: self.state = 262 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input,19,self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) self.state = 248 self.match(zaplangParser.Identificador) pass elif la_ == 2: self.enterOuterAlt(localctx, 2) self.state = 249 self.match(zaplangParser.Identificador) self.state = 250 self.match(zaplangParser.Asignar) self.state = 251 self.inicializador() pass elif la_ == 3: self.enterOuterAlt(localctx, 3) self.state = 252 self.match(zaplangParser.Identificador) self.state = 253 self.match(zaplangParser.CorcheteIzq) self.state = 254 self.match(zaplangParser.ConstanteEntera) self.state = 255 self.match(zaplangParser.CorcheteDer) pass elif la_ == 4: self.enterOuterAlt(localctx, 4) self.state = 256 self.match(zaplangParser.Identificador) self.state = 257 self.match(zaplangParser.CorcheteIzq) self.state = 258 self.match(zaplangParser.ConstanteEntera) self.state = 259 self.match(zaplangParser.CorcheteDer) self.state = 260 self.match(zaplangParser.Asignar) self.state = 261 self.inicializadorArreglo() pass except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class InicializadorContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def asignacionExpresion(self): return self.getTypedRuleContext(zaplangParser.AsignacionExpresionContext,0) def getRuleIndex(self): return zaplangParser.RULE_inicializador def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterInicializador" ): listener.enterInicializador(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitInicializador" ): listener.exitInicializador(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitInicializador" ): return visitor.visitInicializador(self) else: return visitor.visitChildren(self) def inicializador(self): localctx = zaplangParser.InicializadorContext(self, self._ctx, self.state) self.enterRule(localctx, 36, self.RULE_inicializador) try: self.enterOuterAlt(localctx, 1) self.state = 264 self.asignacionExpresion() except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class InicializadorArregloContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def LlaveIzq(self): return self.getToken(zaplangParser.LlaveIzq, 0) def LlaveDer(self): return self.getToken(zaplangParser.LlaveDer, 0) def listaInitializers(self): return self.getTypedRuleContext(zaplangParser.ListaInitializersContext,0) def getRuleIndex(self): return zaplangParser.RULE_inicializadorArreglo def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterInicializadorArreglo" ): listener.enterInicializadorArreglo(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitInicializadorArreglo" ): listener.exitInicializadorArreglo(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitInicializadorArreglo" ): return visitor.visitInicializadorArreglo(self) else: return visitor.visitChildren(self) def inicializadorArreglo(self): localctx = zaplangParser.InicializadorArregloContext(self, self._ctx, self.state) self.enterRule(localctx, 38, self.RULE_inicializadorArreglo) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 266 self.match(zaplangParser.LlaveIzq) self.state = 268 self._errHandler.sync(self) _la = self._input.LA(1) if ((((_la - 11)) & ~0x3f) == 0 and ((1 << (_la - 11)) & 8935141971274506753) != 0): self.state = 267 self.listaInitializers() self.state = 270 self.match(zaplangParser.LlaveDer) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class ListaInitializersContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def asignacionExpresion(self, i:int=None): if i is None: return self.getTypedRuleContexts(zaplangParser.AsignacionExpresionContext) else: return self.getTypedRuleContext(zaplangParser.AsignacionExpresionContext,i) def Coma(self, i:int=None): if i is None: return self.getTokens(zaplangParser.Coma) else: return self.getToken(zaplangParser.Coma, i) def getRuleIndex(self): return zaplangParser.RULE_listaInitializers def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterListaInitializers" ): listener.enterListaInitializers(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitListaInitializers" ): listener.exitListaInitializers(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitListaInitializers" ): return visitor.visitListaInitializers(self) else: return visitor.visitChildren(self) def listaInitializers(self): localctx = zaplangParser.ListaInitializersContext(self, self._ctx, self.state) self.enterRule(localctx, 40, self.RULE_listaInitializers) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 272 self.asignacionExpresion() self.state = 277 self._errHandler.sync(self) _la = self._input.LA(1) while _la==53: self.state = 273 self.match(zaplangParser.Coma) self.state = 274 self.asignacionExpresion() self.state = 279 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 SentenciaContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def sentenciaCompuesta(self): return self.getTypedRuleContext(zaplangParser.SentenciaCompuestaContext,0) def sentenciaDeclaracion(self): return self.getTypedRuleContext(zaplangParser.SentenciaDeclaracionContext,0) def sentenciaExpresion(self): return self.getTypedRuleContext(zaplangParser.SentenciaExpresionContext,0) def sentenciaSeleccion(self): return self.getTypedRuleContext(zaplangParser.SentenciaSeleccionContext,0) def sentenciaIteracion(self): return self.getTypedRuleContext(zaplangParser.SentenciaIteracionContext,0) def sentenciaSalto(self): return self.getTypedRuleContext(zaplangParser.SentenciaSaltoContext,0) def getRuleIndex(self): return zaplangParser.RULE_sentencia def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterSentencia" ): listener.enterSentencia(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitSentencia" ): listener.exitSentencia(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitSentencia" ): return visitor.visitSentencia(self) else: return visitor.visitChildren(self) def sentencia(self): localctx = zaplangParser.SentenciaContext(self, self._ctx, self.state) self.enterRule(localctx, 42, self.RULE_sentencia) try: self.state = 286 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input,22,self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) self.state = 280 self.sentenciaCompuesta() pass elif la_ == 2: self.enterOuterAlt(localctx, 2) self.state = 281 self.sentenciaDeclaracion() pass elif la_ == 3: self.enterOuterAlt(localctx, 3) self.state = 282 self.sentenciaExpresion() pass elif la_ == 4: self.enterOuterAlt(localctx, 4) self.state = 283 self.sentenciaSeleccion() pass elif la_ == 5: self.enterOuterAlt(localctx, 5) self.state = 284 self.sentenciaIteracion() pass elif la_ == 6: self.enterOuterAlt(localctx, 6) self.state = 285 self.sentenciaSalto() pass except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class SentenciaCompuestaContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def LlaveIzq(self): return self.getToken(zaplangParser.LlaveIzq, 0) def LlaveDer(self): return self.getToken(zaplangParser.LlaveDer, 0) def sentencia(self, i:int=None): if i is None: return self.getTypedRuleContexts(zaplangParser.SentenciaContext) else: return self.getTypedRuleContext(zaplangParser.SentenciaContext,i) def getRuleIndex(self): return zaplangParser.RULE_sentenciaCompuesta def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterSentenciaCompuesta" ): listener.enterSentenciaCompuesta(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitSentenciaCompuesta" ): listener.exitSentenciaCompuesta(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitSentenciaCompuesta" ): return visitor.visitSentenciaCompuesta(self) else: return visitor.visitChildren(self) def sentenciaCompuesta(self): localctx = zaplangParser.SentenciaCompuestaContext(self, self._ctx, self.state) self.enterRule(localctx, 44, self.RULE_sentenciaCompuesta) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 288 self.match(zaplangParser.LlaveIzq) self.state = 292 self._errHandler.sync(self) _la = self._input.LA(1) while (((_la) & ~0x3f) == 0 and ((1 << _la) & 5139650221964600) != 0) or ((((_la - 69)) & ~0x3f) == 0 and ((1 << (_la - 69)) & 31) != 0): self.state = 289 self.sentencia() self.state = 294 self._errHandler.sync(self) _la = self._input.LA(1) self.state = 295 self.match(zaplangParser.LlaveDer) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class SentenciaDeclaracionContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def declaracionVariable(self): return self.getTypedRuleContext(zaplangParser.DeclaracionVariableContext,0) def getRuleIndex(self): return zaplangParser.RULE_sentenciaDeclaracion def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterSentenciaDeclaracion" ): listener.enterSentenciaDeclaracion(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitSentenciaDeclaracion" ): listener.exitSentenciaDeclaracion(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitSentenciaDeclaracion" ): return visitor.visitSentenciaDeclaracion(self) else: return visitor.visitChildren(self) def sentenciaDeclaracion(self): localctx = zaplangParser.SentenciaDeclaracionContext(self, self._ctx, self.state) self.enterRule(localctx, 46, self.RULE_sentenciaDeclaracion) try: self.enterOuterAlt(localctx, 1) self.state = 297 self.declaracionVariable() except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class SentenciaExpresionContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def expresion(self): return self.getTypedRuleContext(zaplangParser.ExpresionContext,0) def PuntoYComa(self): return self.getToken(zaplangParser.PuntoYComa, 0) def getRuleIndex(self): return zaplangParser.RULE_sentenciaExpresion def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterSentenciaExpresion" ): listener.enterSentenciaExpresion(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitSentenciaExpresion" ): listener.exitSentenciaExpresion(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitSentenciaExpresion" ): return visitor.visitSentenciaExpresion(self) else: return visitor.visitChildren(self) def sentenciaExpresion(self): localctx = zaplangParser.SentenciaExpresionContext(self, self._ctx, self.state) self.enterRule(localctx, 48, self.RULE_sentenciaExpresion) try: self.state = 303 self._errHandler.sync(self) token = self._input.LA(1) if token in [11, 20, 24, 34, 35, 36, 37, 38, 41, 46, 49, 69, 70, 71, 72, 73]: self.enterOuterAlt(localctx, 1) self.state = 299 self.expresion(0) self.state = 300 self.match(zaplangParser.PuntoYComa) pass elif token in [52]: self.enterOuterAlt(localctx, 2) self.state = 302 self.match(zaplangParser.PuntoYComa) 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 SentenciaSeleccionContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def Si(self): return self.getToken(zaplangParser.Si, 0) def ParenIzq(self): return self.getToken(zaplangParser.ParenIzq, 0) def expresion(self): return self.getTypedRuleContext(zaplangParser.ExpresionContext,0) def ParenDer(self): return self.getToken(zaplangParser.ParenDer, 0) def sentencia(self, i:int=None): if i is None: return self.getTypedRuleContexts(zaplangParser.SentenciaContext) else: return self.getTypedRuleContext(zaplangParser.SentenciaContext,i) def Sino(self): return self.getToken(zaplangParser.Sino, 0) def Caso(self): return self.getToken(zaplangParser.Caso, 0) def Bul(self): return self.getToken(zaplangParser.Bul, 0) def LlaveIzq(self): return self.getToken(zaplangParser.LlaveIzq, 0) def LlaveDer(self): return self.getToken(zaplangParser.LlaveDer, 0) def casoEtiqueta(self, i:int=None): if i is None: return self.getTypedRuleContexts(zaplangParser.CasoEtiquetaContext) else: return self.getTypedRuleContext(zaplangParser.CasoEtiquetaContext,i) def etiquetaPorDef(self): return self.getTypedRuleContext(zaplangParser.EtiquetaPorDefContext,0) def getRuleIndex(self): return zaplangParser.RULE_sentenciaSeleccion def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterSentenciaSeleccion" ): listener.enterSentenciaSeleccion(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitSentenciaSeleccion" ): listener.exitSentenciaSeleccion(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitSentenciaSeleccion" ): return visitor.visitSentenciaSeleccion(self) else: return visitor.visitChildren(self) def sentenciaSeleccion(self): localctx = zaplangParser.SentenciaSeleccionContext(self, self._ctx, self.state) self.enterRule(localctx, 50, self.RULE_sentenciaSeleccion) self._la = 0 # Token type try: self.state = 332 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input,27,self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) self.state = 305 self.match(zaplangParser.Si) self.state = 306 self.match(zaplangParser.ParenIzq) self.state = 307 self.expresion(0) self.state = 308 self.match(zaplangParser.ParenDer) self.state = 309 self.sentencia() pass elif la_ == 2: self.enterOuterAlt(localctx, 2) self.state = 311 self.match(zaplangParser.Si) self.state = 312 self.match(zaplangParser.ParenIzq) self.state = 313 self.expresion(0) self.state = 314 self.match(zaplangParser.ParenDer) self.state = 315 self.sentencia() self.state = 316 self.match(zaplangParser.Sino) self.state = 317 self.sentencia() pass elif la_ == 3: self.enterOuterAlt(localctx, 3) self.state = 319 self.match(zaplangParser.Caso) self.state = 320 self.match(zaplangParser.Bul) self.state = 321 self.match(zaplangParser.LlaveIzq) self.state = 325 self._errHandler.sync(self) _la = self._input.LA(1) while _la==4: self.state = 322 self.casoEtiqueta() self.state = 327 self._errHandler.sync(self) _la = self._input.LA(1) self.state = 329 self._errHandler.sync(self) _la = self._input.LA(1) if _la==6: self.state = 328 self.etiquetaPorDef() self.state = 331 self.match(zaplangParser.LlaveDer) pass except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class CasoEtiquetaContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def Caso(self): return self.getToken(zaplangParser.Caso, 0) def constanteExpresion(self): return self.getTypedRuleContext(zaplangParser.ConstanteExpresionContext,0) def DosPuntos(self): return self.getToken(zaplangParser.DosPuntos, 0) def sentencia(self, i:int=None): if i is None: return self.getTypedRuleContexts(zaplangParser.SentenciaContext) else: return self.getTypedRuleContext(zaplangParser.SentenciaContext,i) def getRuleIndex(self): return zaplangParser.RULE_casoEtiqueta def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterCasoEtiqueta" ): listener.enterCasoEtiqueta(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitCasoEtiqueta" ): listener.exitCasoEtiqueta(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitCasoEtiqueta" ): return visitor.visitCasoEtiqueta(self) else: return visitor.visitChildren(self) def casoEtiqueta(self): localctx = zaplangParser.CasoEtiquetaContext(self, self._ctx, self.state) self.enterRule(localctx, 52, self.RULE_casoEtiqueta) try: self.enterOuterAlt(localctx, 1) self.state = 334 self.match(zaplangParser.Caso) self.state = 335 self.constanteExpresion() self.state = 336 self.match(zaplangParser.DosPuntos) self.state = 340 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,28,self._ctx) while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: if _alt==1: self.state = 337 self.sentencia() self.state = 342 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,28,self._ctx) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class EtiquetaPorDefContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def Pordef(self): return self.getToken(zaplangParser.Pordef, 0) def DosPuntos(self): return self.getToken(zaplangParser.DosPuntos, 0) def sentencia(self, i:int=None): if i is None: return self.getTypedRuleContexts(zaplangParser.SentenciaContext) else: return self.getTypedRuleContext(zaplangParser.SentenciaContext,i) def getRuleIndex(self): return zaplangParser.RULE_etiquetaPorDef def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterEtiquetaPorDef" ): listener.enterEtiquetaPorDef(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitEtiquetaPorDef" ): listener.exitEtiquetaPorDef(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitEtiquetaPorDef" ): return visitor.visitEtiquetaPorDef(self) else: return visitor.visitChildren(self) def etiquetaPorDef(self): localctx = zaplangParser.EtiquetaPorDefContext(self, self._ctx, self.state) self.enterRule(localctx, 54, self.RULE_etiquetaPorDef) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 343 self.match(zaplangParser.Pordef) self.state = 344 self.match(zaplangParser.DosPuntos) self.state = 348 self._errHandler.sync(self) _la = self._input.LA(1) while (((_la) & ~0x3f) == 0 and ((1 << _la) & 5139650221964600) != 0) or ((((_la - 69)) & ~0x3f) == 0 and ((1 << (_la - 69)) & 31) != 0): self.state = 345 self.sentencia() self.state = 350 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 SentenciaIteracionContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def Mientras(self): return self.getToken(zaplangParser.Mientras, 0) def ParenIzq(self): return self.getToken(zaplangParser.ParenIzq, 0) def expresion(self, i:int=None): if i is None: return self.getTypedRuleContexts(zaplangParser.ExpresionContext) else: return self.getTypedRuleContext(zaplangParser.ExpresionContext,i) def ParenDer(self): return self.getToken(zaplangParser.ParenDer, 0) def sentencia(self): return self.getTypedRuleContext(zaplangParser.SentenciaContext,0) def Por(self): return self.getToken(zaplangParser.Por, 0) def PuntoYComa(self, i:int=None): if i is None: return self.getTokens(zaplangParser.PuntoYComa) else: return self.getToken(zaplangParser.PuntoYComa, i) def sentenciaExpresion(self): return self.getTypedRuleContext(zaplangParser.SentenciaExpresionContext,0) def getRuleIndex(self): return zaplangParser.RULE_sentenciaIteracion def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterSentenciaIteracion" ): listener.enterSentenciaIteracion(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitSentenciaIteracion" ): listener.exitSentenciaIteracion(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitSentenciaIteracion" ): return visitor.visitSentenciaIteracion(self) else: return visitor.visitChildren(self) def sentenciaIteracion(self): localctx = zaplangParser.SentenciaIteracionContext(self, self._ctx, self.state) self.enterRule(localctx, 56, self.RULE_sentenciaIteracion) self._la = 0 # Token type try: self.state = 372 self._errHandler.sync(self) token = self._input.LA(1) if token in [23]: self.enterOuterAlt(localctx, 1) self.state = 351 self.match(zaplangParser.Mientras) self.state = 352 self.match(zaplangParser.ParenIzq) self.state = 353 self.expresion(0) self.state = 354 self.match(zaplangParser.ParenDer) self.state = 355 self.sentencia() pass elif token in [13]: self.enterOuterAlt(localctx, 2) self.state = 357 self.match(zaplangParser.Por) self.state = 358 self.match(zaplangParser.ParenIzq) self.state = 360 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input,30,self._ctx) if la_ == 1: self.state = 359 self.sentenciaExpresion() self.state = 362 self.match(zaplangParser.PuntoYComa) self.state = 364 self._errHandler.sync(self) _la = self._input.LA(1) if ((((_la - 11)) & ~0x3f) == 0 and ((1 << (_la - 11)) & 8935141971274506753) != 0): self.state = 363 self.expresion(0) self.state = 366 self.match(zaplangParser.PuntoYComa) self.state = 368 self._errHandler.sync(self) _la = self._input.LA(1) if ((((_la - 11)) & ~0x3f) == 0 and ((1 << (_la - 11)) & 8935141971274506753) != 0): self.state = 367 self.expresion(0) self.state = 370 self.match(zaplangParser.ParenDer) self.state = 371 self.sentencia() 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 SentenciaSaltoContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def Retornar(self): return self.getToken(zaplangParser.Retornar, 0) def PuntoYComa(self): return self.getToken(zaplangParser.PuntoYComa, 0) def expresion(self): return self.getTypedRuleContext(zaplangParser.ExpresionContext,0) def Fin(self): return self.getToken(zaplangParser.Fin, 0) def Interrup(self): return self.getToken(zaplangParser.Interrup, 0) def getRuleIndex(self): return zaplangParser.RULE_sentenciaSalto def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterSentenciaSalto" ): listener.enterSentenciaSalto(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitSentenciaSalto" ): listener.exitSentenciaSalto(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitSentenciaSalto" ): return visitor.visitSentenciaSalto(self) else: return visitor.visitChildren(self) def sentenciaSalto(self): localctx = zaplangParser.SentenciaSaltoContext(self, self._ctx, self.state) self.enterRule(localctx, 58, self.RULE_sentenciaSalto) self._la = 0 # Token type try: self.state = 383 self._errHandler.sync(self) token = self._input.LA(1) if token in [16]: self.enterOuterAlt(localctx, 1) self.state = 374 self.match(zaplangParser.Retornar) self.state = 376 self._errHandler.sync(self) _la = self._input.LA(1) if ((((_la - 11)) & ~0x3f) == 0 and ((1 << (_la - 11)) & 8935141971274506753) != 0): self.state = 375 self.expresion(0) self.state = 378 self.match(zaplangParser.PuntoYComa) pass elif token in [3]: self.enterOuterAlt(localctx, 2) self.state = 379 self.match(zaplangParser.Fin) self.state = 380 self.match(zaplangParser.PuntoYComa) pass elif token in [19]: self.enterOuterAlt(localctx, 3) self.state = 381 self.match(zaplangParser.Interrup) self.state = 382 self.match(zaplangParser.PuntoYComa) 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 BloqueContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def LlaveIzq(self): return self.getToken(zaplangParser.LlaveIzq, 0) def LlaveDer(self): return self.getToken(zaplangParser.LlaveDer, 0) def declaracionVariable(self, i:int=None): if i is None: return self.getTypedRuleContexts(zaplangParser.DeclaracionVariableContext) else: return self.getTypedRuleContext(zaplangParser.DeclaracionVariableContext,i) def sentencia(self, i:int=None): if i is None: return self.getTypedRuleContexts(zaplangParser.SentenciaContext) else: return self.getTypedRuleContext(zaplangParser.SentenciaContext,i) def getRuleIndex(self): return zaplangParser.RULE_bloque def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterBloque" ): listener.enterBloque(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitBloque" ): listener.exitBloque(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitBloque" ): return visitor.visitBloque(self) else: return visitor.visitChildren(self) def bloque(self): localctx = zaplangParser.BloqueContext(self, self._ctx, self.state) self.enterRule(localctx, 60, self.RULE_bloque) self._la = 0 # Token type try: self.state = 400 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input,38,self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) self.state = 385 self.match(zaplangParser.LlaveIzq) self.state = 389 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,36,self._ctx) while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: if _alt==1: self.state = 386 self.declaracionVariable() self.state = 391 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,36,self._ctx) self.state = 395 self._errHandler.sync(self) _la = self._input.LA(1) while (((_la) & ~0x3f) == 0 and ((1 << _la) & 5139650221964600) != 0) or ((((_la - 69)) & ~0x3f) == 0 and ((1 << (_la - 69)) & 31) != 0): self.state = 392 self.sentencia() self.state = 397 self._errHandler.sync(self) _la = self._input.LA(1) self.state = 398 self.match(zaplangParser.LlaveDer) pass elif la_ == 2: self.enterOuterAlt(localctx, 2) self.state = 399 self.sentencia() pass except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class ExpresionContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def asignacionExpresion(self): return self.getTypedRuleContext(zaplangParser.AsignacionExpresionContext,0) def expresion(self): return self.getTypedRuleContext(zaplangParser.ExpresionContext,0) def Coma(self): return self.getToken(zaplangParser.Coma, 0) def getRuleIndex(self): return zaplangParser.RULE_expresion def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterExpresion" ): listener.enterExpresion(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitExpresion" ): listener.exitExpresion(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitExpresion" ): return visitor.visitExpresion(self) else: return visitor.visitChildren(self) def expresion(self, _p:int=0): _parentctx = self._ctx _parentState = self.state localctx = zaplangParser.ExpresionContext(self, self._ctx, _parentState) _prevctx = localctx _startState = 62 self.enterRecursionRule(localctx, 62, self.RULE_expresion, _p) try: self.enterOuterAlt(localctx, 1) self.state = 403 self.asignacionExpresion() self._ctx.stop = self._input.LT(-1) self.state = 410 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,39,self._ctx) while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: if _alt==1: if self._parseListeners is not None: self.triggerExitRuleEvent() _prevctx = localctx localctx = zaplangParser.ExpresionContext(self, _parentctx, _parentState) self.pushNewRecursionContext(localctx, _startState, self.RULE_expresion) self.state = 405 if not self.precpred(self._ctx, 1): from antlr4.error.Errors import FailedPredicateException raise FailedPredicateException(self, "self.precpred(self._ctx, 1)") self.state = 406 self.match(zaplangParser.Coma) self.state = 407 self.asignacionExpresion() self.state = 412 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,39,self._ctx) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.unrollRecursionContexts(_parentctx) return localctx class AsignacionExpresionContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def expresionCondicional(self): return self.getTypedRuleContext(zaplangParser.ExpresionCondicionalContext,0) def expresionUnaria(self): return self.getTypedRuleContext(zaplangParser.ExpresionUnariaContext,0) def operadorAsignacion(self): return self.getTypedRuleContext(zaplangParser.OperadorAsignacionContext,0) def asignacionExpresion(self): return self.getTypedRuleContext(zaplangParser.AsignacionExpresionContext,0) def getRuleIndex(self): return zaplangParser.RULE_asignacionExpresion def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterAsignacionExpresion" ): listener.enterAsignacionExpresion(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitAsignacionExpresion" ): listener.exitAsignacionExpresion(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitAsignacionExpresion" ): return visitor.visitAsignacionExpresion(self) else: return visitor.visitChildren(self) def asignacionExpresion(self): localctx = zaplangParser.AsignacionExpresionContext(self, self._ctx, self.state) self.enterRule(localctx, 64, self.RULE_asignacionExpresion) try: self.state = 418 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input,40,self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) self.state = 413 self.expresionCondicional() pass elif la_ == 2: self.enterOuterAlt(localctx, 2) self.state = 414 self.expresionUnaria() self.state = 415 self.operadorAsignacion() self.state = 416 self.asignacionExpresion() pass except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class OperadorAsignacionContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def Asignar(self): return self.getToken(zaplangParser.Asignar, 0) def MasAsignacion(self): return self.getToken(zaplangParser.MasAsignacion, 0) def MenosAsignacion(self): return self.getToken(zaplangParser.MenosAsignacion, 0) def EstrellaAsignacion(self): return self.getToken(zaplangParser.EstrellaAsignacion, 0) def DivAsignacion(self): return self.getToken(zaplangParser.DivAsignacion, 0) def ModAsignacion(self): return self.getToken(zaplangParser.ModAsignacion, 0) def DesplazIzqAsignacion(self): return self.getToken(zaplangParser.DesplazIzqAsignacion, 0) def DesplazDerAsignacion(self): return self.getToken(zaplangParser.DesplazDerAsignacion, 0) def YAsignacion(self): return self.getToken(zaplangParser.YAsignacion, 0) def XorAsignacion(self): return self.getToken(zaplangParser.XorAsignacion, 0) def OAsignacion(self): return self.getToken(zaplangParser.OAsignacion, 0) def getRuleIndex(self): return zaplangParser.RULE_operadorAsignacion def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterOperadorAsignacion" ): listener.enterOperadorAsignacion(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitOperadorAsignacion" ): listener.exitOperadorAsignacion(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitOperadorAsignacion" ): return visitor.visitOperadorAsignacion(self) else: return visitor.visitChildren(self) def operadorAsignacion(self): localctx = zaplangParser.OperadorAsignacionContext(self, self._ctx, self.state) self.enterRule(localctx, 66, self.RULE_operadorAsignacion) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 420 _la = self._input.LA(1) if not(((((_la - 54)) & ~0x3f) == 0 and ((1 << (_la - 54)) & 2047) != 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 ExpresionCondicionalContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def expresionLogicaO(self): return self.getTypedRuleContext(zaplangParser.ExpresionLogicaOContext,0) def Pregunta(self): return self.getToken(zaplangParser.Pregunta, 0) def expresion(self): return self.getTypedRuleContext(zaplangParser.ExpresionContext,0) def DosPuntos(self): return self.getToken(zaplangParser.DosPuntos, 0) def expresionCondicional(self): return self.getTypedRuleContext(zaplangParser.ExpresionCondicionalContext,0) def getRuleIndex(self): return zaplangParser.RULE_expresionCondicional def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterExpresionCondicional" ): listener.enterExpresionCondicional(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitExpresionCondicional" ): listener.exitExpresionCondicional(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitExpresionCondicional" ): return visitor.visitExpresionCondicional(self) else: return visitor.visitChildren(self) def expresionCondicional(self): localctx = zaplangParser.ExpresionCondicionalContext(self, self._ctx, self.state) self.enterRule(localctx, 68, self.RULE_expresionCondicional) try: self.state = 429 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input,41,self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) self.state = 422 self.expresionLogicaO() pass elif la_ == 2: self.enterOuterAlt(localctx, 2) self.state = 423 self.expresionLogicaO() self.state = 424 self.match(zaplangParser.Pregunta) self.state = 425 self.expresion(0) self.state = 426 self.match(zaplangParser.DosPuntos) self.state = 427 self.expresionCondicional() pass except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class ExpresionLogicaOContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def expresionLogicaY(self, i:int=None): if i is None: return self.getTypedRuleContexts(zaplangParser.ExpresionLogicaYContext) else: return self.getTypedRuleContext(zaplangParser.ExpresionLogicaYContext,i) def OO(self, i:int=None): if i is None: return self.getTokens(zaplangParser.OO) else: return self.getToken(zaplangParser.OO, i) def getRuleIndex(self): return zaplangParser.RULE_expresionLogicaO def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterExpresionLogicaO" ): listener.enterExpresionLogicaO(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitExpresionLogicaO" ): listener.exitExpresionLogicaO(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitExpresionLogicaO" ): return visitor.visitExpresionLogicaO(self) else: return visitor.visitChildren(self) def expresionLogicaO(self): localctx = zaplangParser.ExpresionLogicaOContext(self, self._ctx, self.state) self.enterRule(localctx, 70, self.RULE_expresionLogicaO) try: self.enterOuterAlt(localctx, 1) self.state = 431 self.expresionLogicaY() self.state = 436 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 = 432 self.match(zaplangParser.OO) self.state = 433 self.expresionLogicaY() self.state = 438 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,42,self._ctx) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class ExpresionLogicaYContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def expresionIgualacion(self, i:int=None): if i is None: return self.getTypedRuleContexts(zaplangParser.ExpresionIgualacionContext) else: return self.getTypedRuleContext(zaplangParser.ExpresionIgualacionContext,i) def YY(self, i:int=None): if i is None: return self.getTokens(zaplangParser.YY) else: return self.getToken(zaplangParser.YY, i) def getRuleIndex(self): return zaplangParser.RULE_expresionLogicaY def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterExpresionLogicaY" ): listener.enterExpresionLogicaY(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitExpresionLogicaY" ): listener.exitExpresionLogicaY(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitExpresionLogicaY" ): return visitor.visitExpresionLogicaY(self) else: return visitor.visitChildren(self) def expresionLogicaY(self): localctx = zaplangParser.ExpresionLogicaYContext(self, self._ctx, self.state) self.enterRule(localctx, 72, self.RULE_expresionLogicaY) try: self.enterOuterAlt(localctx, 1) self.state = 439 self.expresionIgualacion() self.state = 444 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,43,self._ctx) while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: if _alt==1: self.state = 440 self.match(zaplangParser.YY) self.state = 441 self.expresionIgualacion() self.state = 446 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,43,self._ctx) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class ExpresionIgualacionContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def expresionRelacional(self, i:int=None): if i is None: return self.getTypedRuleContexts(zaplangParser.ExpresionRelacionalContext) else: return self.getTypedRuleContext(zaplangParser.ExpresionRelacionalContext,i) def Igual(self, i:int=None): if i is None: return self.getTokens(zaplangParser.Igual) else: return self.getToken(zaplangParser.Igual, i) def Diferente(self, i:int=None): if i is None: return self.getTokens(zaplangParser.Diferente) else: return self.getToken(zaplangParser.Diferente, i) def getRuleIndex(self): return zaplangParser.RULE_expresionIgualacion def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterExpresionIgualacion" ): listener.enterExpresionIgualacion(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitExpresionIgualacion" ): listener.exitExpresionIgualacion(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitExpresionIgualacion" ): return visitor.visitExpresionIgualacion(self) else: return visitor.visitChildren(self) def expresionIgualacion(self): localctx = zaplangParser.ExpresionIgualacionContext(self, self._ctx, self.state) self.enterRule(localctx, 74, self.RULE_expresionIgualacion) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 447 self.expresionRelacional() self.state = 452 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,44,self._ctx) while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: if _alt==1: self.state = 448 _la = self._input.LA(1) if not(_la==65 or _la==66): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() self.state = 449 self.expresionRelacional() self.state = 454 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,44,self._ctx) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class ExpresionRelacionalContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def expresionDesplazamiento(self, i:int=None): if i is None: return self.getTypedRuleContexts(zaplangParser.ExpresionDesplazamientoContext) else: return self.getTypedRuleContext(zaplangParser.ExpresionDesplazamientoContext,i) def MenorQue(self, i:int=None): if i is None: return self.getTokens(zaplangParser.MenorQue) else: return self.getToken(zaplangParser.MenorQue, i) def MayorQue(self, i:int=None): if i is None: return self.getTokens(zaplangParser.MayorQue) else: return self.getToken(zaplangParser.MayorQue, i) def MenorOIgualQue(self, i:int=None): if i is None: return self.getTokens(zaplangParser.MenorOIgualQue) else: return self.getToken(zaplangParser.MenorOIgualQue, i) def MayorOIgualQue(self, i:int=None): if i is None: return self.getTokens(zaplangParser.MayorOIgualQue) else: return self.getToken(zaplangParser.MayorOIgualQue, i) def getRuleIndex(self): return zaplangParser.RULE_expresionRelacional def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterExpresionRelacional" ): listener.enterExpresionRelacional(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitExpresionRelacional" ): listener.exitExpresionRelacional(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitExpresionRelacional" ): return visitor.visitExpresionRelacional(self) else: return visitor.visitChildren(self) def expresionRelacional(self): localctx = zaplangParser.ExpresionRelacionalContext(self, self._ctx, self.state) self.enterRule(localctx, 76, self.RULE_expresionRelacional) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 455 self.expresionDesplazamiento() self.state = 460 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,45,self._ctx) while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: if _alt==1: self.state = 456 _la = self._input.LA(1) if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 16106127360) != 0)): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() self.state = 457 self.expresionDesplazamiento() self.state = 462 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,45,self._ctx) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class ExpresionDesplazamientoContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def expresionAditiva(self, i:int=None): if i is None: return self.getTypedRuleContexts(zaplangParser.ExpresionAditivaContext) else: return self.getTypedRuleContext(zaplangParser.ExpresionAditivaContext,i) def DesplazIzq(self, i:int=None): if i is None: return self.getTokens(zaplangParser.DesplazIzq) else: return self.getToken(zaplangParser.DesplazIzq, i) def DesplazDer(self, i:int=None): if i is None: return self.getTokens(zaplangParser.DesplazDer) else: return self.getToken(zaplangParser.DesplazDer, i) def getRuleIndex(self): return zaplangParser.RULE_expresionDesplazamiento def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterExpresionDesplazamiento" ): listener.enterExpresionDesplazamiento(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitExpresionDesplazamiento" ): listener.exitExpresionDesplazamiento(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitExpresionDesplazamiento" ): return visitor.visitExpresionDesplazamiento(self) else: return visitor.visitChildren(self) def expresionDesplazamiento(self): localctx = zaplangParser.ExpresionDesplazamientoContext(self, self._ctx, self.state) self.enterRule(localctx, 78, self.RULE_expresionDesplazamiento) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 463 self.expresionAditiva() self.state = 468 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,46,self._ctx) while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: if _alt==1: self.state = 464 _la = self._input.LA(1) if not(_la==43 or _la==44): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() self.state = 465 self.expresionAditiva() self.state = 470 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,46,self._ctx) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class ExpresionAditivaContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def expresionMultiplicativa(self, i:int=None): if i is None: return self.getTypedRuleContexts(zaplangParser.ExpresionMultiplicativaContext) else: return self.getTypedRuleContext(zaplangParser.ExpresionMultiplicativaContext,i) def Mas(self, i:int=None): if i is None: return self.getTokens(zaplangParser.Mas) else: return self.getToken(zaplangParser.Mas, i) def Menos(self, i:int=None): if i is None: return self.getTokens(zaplangParser.Menos) else: return self.getToken(zaplangParser.Menos, i) def getRuleIndex(self): return zaplangParser.RULE_expresionAditiva def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterExpresionAditiva" ): listener.enterExpresionAditiva(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitExpresionAditiva" ): listener.exitExpresionAditiva(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitExpresionAditiva" ): return visitor.visitExpresionAditiva(self) else: return visitor.visitChildren(self) def expresionAditiva(self): localctx = zaplangParser.ExpresionAditivaContext(self, self._ctx, self.state) self.enterRule(localctx, 80, self.RULE_expresionAditiva) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 471 self.expresionMultiplicativa() self.state = 476 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 = 472 _la = self._input.LA(1) if not(_la==34 or _la==36): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() self.state = 473 self.expresionMultiplicativa() self.state = 478 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,47,self._ctx) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class ExpresionMultiplicativaContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def expresionUnaria(self, i:int=None): if i is None: return self.getTypedRuleContexts(zaplangParser.ExpresionUnariaContext) else: return self.getTypedRuleContext(zaplangParser.ExpresionUnariaContext,i) def Estrella(self, i:int=None): if i is None: return self.getTokens(zaplangParser.Estrella) else: return self.getToken(zaplangParser.Estrella, i) def Div(self, i:int=None): if i is None: return self.getTokens(zaplangParser.Div) else: return self.getToken(zaplangParser.Div, i) def Mod(self, i:int=None): if i is None: return self.getTokens(zaplangParser.Mod) else: return self.getToken(zaplangParser.Mod, i) def getRuleIndex(self): return zaplangParser.RULE_expresionMultiplicativa def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterExpresionMultiplicativa" ): listener.enterExpresionMultiplicativa(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitExpresionMultiplicativa" ): listener.exitExpresionMultiplicativa(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitExpresionMultiplicativa" ): return visitor.visitExpresionMultiplicativa(self) else: return visitor.visitChildren(self) def expresionMultiplicativa(self): localctx = zaplangParser.ExpresionMultiplicativaContext(self, self._ctx, self.state) self.enterRule(localctx, 82, self.RULE_expresionMultiplicativa) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 479 self.expresionUnaria() self.state = 484 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,48,self._ctx) while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: if _alt==1: self.state = 480 _la = self._input.LA(1) if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 1924145348608) != 0)): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() self.state = 481 self.expresionUnaria() self.state = 486 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,48,self._ctx) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class ExpresionUnariaContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def operadorUnario(self): return self.getTypedRuleContext(zaplangParser.OperadorUnarioContext,0) def expresionUnaria(self): return self.getTypedRuleContext(zaplangParser.ExpresionUnariaContext,0) def expresionPostfija(self): return self.getTypedRuleContext(zaplangParser.ExpresionPostfijaContext,0) def getRuleIndex(self): return zaplangParser.RULE_expresionUnaria def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterExpresionUnaria" ): listener.enterExpresionUnaria(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitExpresionUnaria" ): listener.exitExpresionUnaria(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitExpresionUnaria" ): return visitor.visitExpresionUnaria(self) else: return visitor.visitChildren(self) def expresionUnaria(self): localctx = zaplangParser.ExpresionUnariaContext(self, self._ctx, self.state) self.enterRule(localctx, 84, self.RULE_expresionUnaria) try: self.state = 491 self._errHandler.sync(self) token = self._input.LA(1) if token in [34, 35, 36, 37, 38, 41, 46, 49]: self.enterOuterAlt(localctx, 1) self.state = 487 self.operadorUnario() self.state = 488 self.expresionUnaria() pass elif token in [11, 20, 24, 69, 70, 71, 72, 73]: self.enterOuterAlt(localctx, 2) self.state = 490 self.expresionPostfija(0) 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 OperadorUnarioContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def Y(self): return self.getToken(zaplangParser.Y, 0) def Estrella(self): return self.getToken(zaplangParser.Estrella, 0) def Mas(self): return self.getToken(zaplangParser.Mas, 0) def Menos(self): return self.getToken(zaplangParser.Menos, 0) def Complemento(self): return self.getToken(zaplangParser.Complemento, 0) def Not(self): return self.getToken(zaplangParser.Not, 0) def MasMas(self): return self.getToken(zaplangParser.MasMas, 0) def MenosMenos(self): return self.getToken(zaplangParser.MenosMenos, 0) def getRuleIndex(self): return zaplangParser.RULE_operadorUnario def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterOperadorUnario" ): listener.enterOperadorUnario(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitOperadorUnario" ): listener.exitOperadorUnario(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitOperadorUnario" ): return visitor.visitOperadorUnario(self) else: return visitor.visitChildren(self) def operadorUnario(self): localctx = zaplangParser.OperadorUnarioContext(self, self._ctx, self.state) self.enterRule(localctx, 86, self.RULE_operadorUnario) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 493 _la = self._input.LA(1) if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 636050296799232) != 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 ExpresionPostfijaContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def expresionPrimaria(self): return self.getTypedRuleContext(zaplangParser.ExpresionPrimariaContext,0) def expresionPostfija(self): return self.getTypedRuleContext(zaplangParser.ExpresionPostfijaContext,0) def CorcheteIzq(self): return self.getToken(zaplangParser.CorcheteIzq, 0) def expresion(self): return self.getTypedRuleContext(zaplangParser.ExpresionContext,0) def CorcheteDer(self): return self.getToken(zaplangParser.CorcheteDer, 0) def ParenIzq(self): return self.getToken(zaplangParser.ParenIzq, 0) def ParenDer(self): return self.getToken(zaplangParser.ParenDer, 0) def listaArgumentos(self): return self.getTypedRuleContext(zaplangParser.ListaArgumentosContext,0) def Punto(self): return self.getToken(zaplangParser.Punto, 0) def Identificador(self): return self.getToken(zaplangParser.Identificador, 0) def Flecha(self): return self.getToken(zaplangParser.Flecha, 0) def MasMas(self): return self.getToken(zaplangParser.MasMas, 0) def MenosMenos(self): return self.getToken(zaplangParser.MenosMenos, 0) def getRuleIndex(self): return zaplangParser.RULE_expresionPostfija def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterExpresionPostfija" ): listener.enterExpresionPostfija(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitExpresionPostfija" ): listener.exitExpresionPostfija(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitExpresionPostfija" ): return visitor.visitExpresionPostfija(self) else: return visitor.visitChildren(self) def expresionPostfija(self, _p:int=0): _parentctx = self._ctx _parentState = self.state localctx = zaplangParser.ExpresionPostfijaContext(self, self._ctx, _parentState) _prevctx = localctx _startState = 88 self.enterRecursionRule(localctx, 88, self.RULE_expresionPostfija, _p) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 496 self.expresionPrimaria() self._ctx.stop = self._input.LT(-1) self.state = 521 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,52,self._ctx) while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: if _alt==1: if self._parseListeners is not None: self.triggerExitRuleEvent() _prevctx = localctx self.state = 519 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input,51,self._ctx) if la_ == 1: localctx = zaplangParser.ExpresionPostfijaContext(self, _parentctx, _parentState) self.pushNewRecursionContext(localctx, _startState, self.RULE_expresionPostfija) self.state = 498 if not self.precpred(self._ctx, 6): from antlr4.error.Errors import FailedPredicateException raise FailedPredicateException(self, "self.precpred(self._ctx, 6)") self.state = 499 self.match(zaplangParser.CorcheteIzq) self.state = 500 self.expresion(0) self.state = 501 self.match(zaplangParser.CorcheteDer) pass elif la_ == 2: localctx = zaplangParser.ExpresionPostfijaContext(self, _parentctx, _parentState) self.pushNewRecursionContext(localctx, _startState, self.RULE_expresionPostfija) self.state = 503 if not self.precpred(self._ctx, 5): from antlr4.error.Errors import FailedPredicateException raise FailedPredicateException(self, "self.precpred(self._ctx, 5)") self.state = 504 self.match(zaplangParser.ParenIzq) self.state = 506 self._errHandler.sync(self) _la = self._input.LA(1) if ((((_la - 11)) & ~0x3f) == 0 and ((1 << (_la - 11)) & 8935141971274506753) != 0): self.state = 505 self.listaArgumentos() self.state = 508 self.match(zaplangParser.ParenDer) pass elif la_ == 3: localctx = zaplangParser.ExpresionPostfijaContext(self, _parentctx, _parentState) self.pushNewRecursionContext(localctx, _startState, self.RULE_expresionPostfija) self.state = 509 if not self.precpred(self._ctx, 4): from antlr4.error.Errors import FailedPredicateException raise FailedPredicateException(self, "self.precpred(self._ctx, 4)") self.state = 510 self.match(zaplangParser.Punto) self.state = 511 self.match(zaplangParser.Identificador) pass elif la_ == 4: localctx = zaplangParser.ExpresionPostfijaContext(self, _parentctx, _parentState) self.pushNewRecursionContext(localctx, _startState, self.RULE_expresionPostfija) self.state = 512 if not self.precpred(self._ctx, 3): from antlr4.error.Errors import FailedPredicateException raise FailedPredicateException(self, "self.precpred(self._ctx, 3)") self.state = 513 self.match(zaplangParser.Flecha) self.state = 514 self.match(zaplangParser.Identificador) pass elif la_ == 5: localctx = zaplangParser.ExpresionPostfijaContext(self, _parentctx, _parentState) self.pushNewRecursionContext(localctx, _startState, self.RULE_expresionPostfija) self.state = 515 if not self.precpred(self._ctx, 2): from antlr4.error.Errors import FailedPredicateException raise FailedPredicateException(self, "self.precpred(self._ctx, 2)") self.state = 516 self.match(zaplangParser.MasMas) pass elif la_ == 6: localctx = zaplangParser.ExpresionPostfijaContext(self, _parentctx, _parentState) self.pushNewRecursionContext(localctx, _startState, self.RULE_expresionPostfija) self.state = 517 if not self.precpred(self._ctx, 1): from antlr4.error.Errors import FailedPredicateException raise FailedPredicateException(self, "self.precpred(self._ctx, 1)") self.state = 518 self.match(zaplangParser.MenosMenos) pass self.state = 523 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,52,self._ctx) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.unrollRecursionContexts(_parentctx) return localctx class ExpresionPrimariaContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def Identificador(self): return self.getToken(zaplangParser.Identificador, 0) def constanteExpresion(self): return self.getTypedRuleContext(zaplangParser.ConstanteExpresionContext,0) def CadenaLiteral(self): return self.getToken(zaplangParser.CadenaLiteral, 0) def ParenIzq(self): return self.getToken(zaplangParser.ParenIzq, 0) def expresion(self): return self.getTypedRuleContext(zaplangParser.ExpresionContext,0) def ParenDer(self): return self.getToken(zaplangParser.ParenDer, 0) def especificadorTipo(self): return self.getTypedRuleContext(zaplangParser.EspecificadorTipoContext,0) def expresionUnaria(self): return self.getTypedRuleContext(zaplangParser.ExpresionUnariaContext,0) def getRuleIndex(self): return zaplangParser.RULE_expresionPrimaria def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterExpresionPrimaria" ): listener.enterExpresionPrimaria(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitExpresionPrimaria" ): listener.exitExpresionPrimaria(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitExpresionPrimaria" ): return visitor.visitExpresionPrimaria(self) else: return visitor.visitChildren(self) def expresionPrimaria(self): localctx = zaplangParser.ExpresionPrimariaContext(self, self._ctx, self.state) self.enterRule(localctx, 90, self.RULE_expresionPrimaria) try: self.state = 536 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input,53,self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) self.state = 524 self.match(zaplangParser.Identificador) pass elif la_ == 2: self.enterOuterAlt(localctx, 2) self.state = 525 self.constanteExpresion() pass elif la_ == 3: self.enterOuterAlt(localctx, 3) self.state = 526 self.match(zaplangParser.CadenaLiteral) pass elif la_ == 4: self.enterOuterAlt(localctx, 4) self.state = 527 self.match(zaplangParser.ParenIzq) self.state = 528 self.expresion(0) self.state = 529 self.match(zaplangParser.ParenDer) pass elif la_ == 5: self.enterOuterAlt(localctx, 5) self.state = 531 self.match(zaplangParser.ParenIzq) self.state = 532 self.especificadorTipo() self.state = 533 self.match(zaplangParser.ParenDer) self.state = 534 self.expresionUnaria() pass except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class ConstanteExpresionContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def ConstanteEntera(self): return self.getToken(zaplangParser.ConstanteEntera, 0) def ConstanteFlotante(self): return self.getToken(zaplangParser.ConstanteFlotante, 0) def ConstanteCaracteres(self): return self.getToken(zaplangParser.ConstanteCaracteres, 0) def Verdadero(self): return self.getToken(zaplangParser.Verdadero, 0) def Falso(self): return self.getToken(zaplangParser.Falso, 0) def getRuleIndex(self): return zaplangParser.RULE_constanteExpresion def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterConstanteExpresion" ): listener.enterConstanteExpresion(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitConstanteExpresion" ): listener.exitConstanteExpresion(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitConstanteExpresion" ): return visitor.visitConstanteExpresion(self) else: return visitor.visitChildren(self) def constanteExpresion(self): localctx = zaplangParser.ConstanteExpresionContext(self, self._ctx, self.state) self.enterRule(localctx, 92, self.RULE_constanteExpresion) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 538 _la = self._input.LA(1) if not(((((_la - 11)) & ~0x3f) == 0 and ((1 << (_la - 11)) & 4035225266123964929) != 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 ListaArgumentosContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def asignacionExpresion(self, i:int=None): if i is None: return self.getTypedRuleContexts(zaplangParser.AsignacionExpresionContext) else: return self.getTypedRuleContext(zaplangParser.AsignacionExpresionContext,i) def Coma(self, i:int=None): if i is None: return self.getTokens(zaplangParser.Coma) else: return self.getToken(zaplangParser.Coma, i) def getRuleIndex(self): return zaplangParser.RULE_listaArgumentos def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterListaArgumentos" ): listener.enterListaArgumentos(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitListaArgumentos" ): listener.exitListaArgumentos(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitListaArgumentos" ): return visitor.visitListaArgumentos(self) else: return visitor.visitChildren(self) def listaArgumentos(self): localctx = zaplangParser.ListaArgumentosContext(self, self._ctx, self.state) self.enterRule(localctx, 94, self.RULE_listaArgumentos) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 540 self.asignacionExpresion() self.state = 545 self._errHandler.sync(self) _la = self._input.LA(1) while _la==53: self.state = 541 self.match(zaplangParser.Coma) self.state = 542 self.asignacionExpresion() self.state = 547 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 MarcaPuntoContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def Bul(self): return self.getToken(zaplangParser.Bul, 0) def getRuleIndex(self): return zaplangParser.RULE_marcaPunto def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterMarcaPunto" ): listener.enterMarcaPunto(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitMarcaPunto" ): listener.exitMarcaPunto(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitMarcaPunto" ): return visitor.visitMarcaPunto(self) else: return visitor.visitChildren(self) def marcaPunto(self): localctx = zaplangParser.MarcaPuntoContext(self, self._ctx, self.state) self.enterRule(localctx, 96, self.RULE_marcaPunto) try: self.enterOuterAlt(localctx, 1) self.state = 548 self.match(zaplangParser.Bul) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int): if self._predicates == None: self._predicates = dict() self._predicates[31] = self.expresion_sempred self._predicates[44] = self.expresionPostfija_sempred pred = self._predicates.get(ruleIndex, None) if pred is None: raise Exception("No predicate with index:" + str(ruleIndex)) else: return pred(localctx, predIndex) def expresion_sempred(self, localctx:ExpresionContext, predIndex:int): if predIndex == 0: return self.precpred(self._ctx, 1) def expresionPostfija_sempred(self, localctx:ExpresionPostfijaContext, predIndex:int): if predIndex == 1: return self.precpred(self._ctx, 6) if predIndex == 2: return self.precpred(self._ctx, 5) if predIndex == 3: return self.precpred(self._ctx, 4) if predIndex == 4: return self.precpred(self._ctx, 3) if predIndex == 5: return self.precpred(self._ctx, 2) if predIndex == 6: return self.precpred(self._ctx, 1)