4524 lines
161 KiB
Python
4524 lines
161 KiB
Python
# 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 = [ "<INVALID>", "'bul'", "'func'", "'fin'", "'caso'",
|
|
"'carac'", "'pordef'", "'hacer'", "'doble'", "'sino'",
|
|
"'enum'", "'falso'", "'flot'", "'por'", "'si'", "'Ent'",
|
|
"'retornar'", "'cf'", "'estruct'", "'interrup'", "'verdadero'",
|
|
"'sf'", "'vacio'", "'mientras'", "'('", "')'", "'['",
|
|
"']'", "'{'", "'}'", "'<'", "'<='", "'>'", "'>='",
|
|
"'+'", "'++'", "'-'", "'--'", "'*'", "'/'", "'%'",
|
|
"'&'", "'|'", "'<<'", "'>>'", "'^'", "'~'", "'&&'",
|
|
"'||'", "'!'", "'?'", "':'", "';'", "','", "'='", "'*='",
|
|
"'/='", "'%='", "'+='", "'-='", "'&='", "'|='", "'<<='",
|
|
"'>>='", "'^='", "'=='", "'!='", "'->'", "'.'" ]
|
|
|
|
symbolicNames = [ "<INVALID>", "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)
|
|
|
|
|
|
|
|
|
|
|