// Code generated from antlr/FqlParser.g4 by ANTLR 4.9.2. DO NOT EDIT. package fql // FqlParser import ( "fmt" "reflect" "strconv" "github.com/antlr/antlr4/runtime/Go/antlr" ) // Suppress unused import errors var _ = fmt.Printf var _ = reflect.Copy var _ = strconv.Itoa var parserATN = []uint16{ 3, 24715, 42794, 33075, 47597, 16764, 15335, 30598, 22884, 3, 71, 656, 4, 2, 9, 2, 4, 3, 9, 3, 4, 4, 9, 4, 4, 5, 9, 5, 4, 6, 9, 6, 4, 7, 9, 7, 4, 8, 9, 8, 4, 9, 9, 9, 4, 10, 9, 10, 4, 11, 9, 11, 4, 12, 9, 12, 4, 13, 9, 13, 4, 14, 9, 14, 4, 15, 9, 15, 4, 16, 9, 16, 4, 17, 9, 17, 4, 18, 9, 18, 4, 19, 9, 19, 4, 20, 9, 20, 4, 21, 9, 21, 4, 22, 9, 22, 4, 23, 9, 23, 4, 24, 9, 24, 4, 25, 9, 25, 4, 26, 9, 26, 4, 27, 9, 27, 4, 28, 9, 28, 4, 29, 9, 29, 4, 30, 9, 30, 4, 31, 9, 31, 4, 32, 9, 32, 4, 33, 9, 33, 4, 34, 9, 34, 4, 35, 9, 35, 4, 36, 9, 36, 4, 37, 9, 37, 4, 38, 9, 38, 4, 39, 9, 39, 4, 40, 9, 40, 4, 41, 9, 41, 4, 42, 9, 42, 4, 43, 9, 43, 4, 44, 9, 44, 4, 45, 9, 45, 4, 46, 9, 46, 4, 47, 9, 47, 4, 48, 9, 48, 4, 49, 9, 49, 4, 50, 9, 50, 4, 51, 9, 51, 4, 52, 9, 52, 4, 53, 9, 53, 4, 54, 9, 54, 4, 55, 9, 55, 4, 56, 9, 56, 4, 57, 9, 57, 4, 58, 9, 58, 4, 59, 9, 59, 4, 60, 9, 60, 4, 61, 9, 61, 4, 62, 9, 62, 4, 63, 9, 63, 4, 64, 9, 64, 4, 65, 9, 65, 4, 66, 9, 66, 4, 67, 9, 67, 3, 2, 7, 2, 136, 10, 2, 12, 2, 14, 2, 139, 11, 2, 3, 2, 3, 2, 3, 2, 3, 3, 3, 3, 3, 4, 3, 4, 3, 5, 3, 5, 3, 5, 3, 6, 3, 6, 3, 6, 3, 7, 7, 7, 155, 10, 7, 12, 7, 14, 7, 158, 11, 7, 3, 7, 3, 7, 3, 8, 3, 8, 3, 8, 5, 8, 165, 10, 8, 3, 9, 3, 9, 5, 9, 169, 10, 9, 3, 10, 3, 10, 3, 10, 3, 10, 3, 10, 3, 10, 5, 10, 177, 10, 10, 3, 10, 3, 10, 3, 10, 3, 10, 3, 10, 3, 10, 5, 10, 185, 10, 10, 3, 11, 3, 11, 5, 11, 189, 10, 11, 3, 11, 3, 11, 3, 11, 5, 11, 194, 10, 11, 3, 11, 3, 11, 3, 11, 3, 11, 5, 11, 200, 10, 11, 3, 11, 5, 11, 203, 10, 11, 3, 12, 3, 12, 3, 12, 3, 12, 5, 12, 209, 10, 12, 3, 12, 3, 12, 3, 12, 7, 12, 214, 10, 12, 12, 12, 14, 12, 217, 11, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 5, 12, 224, 10, 12, 3, 12, 3, 12, 3, 12, 7, 12, 229, 10, 12, 12, 12, 14, 12, 232, 11, 12, 3, 12, 3, 12, 5, 12, 236, 10, 12, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 5, 13, 245, 10, 13, 3, 14, 3, 14, 3, 14, 3, 14, 5, 14, 251, 10, 14, 3, 15, 3, 15, 5, 15, 255, 10, 15, 3, 16, 3, 16, 5, 16, 259, 10, 16, 3, 17, 3, 17, 5, 17, 263, 10, 17, 3, 18, 3, 18, 3, 18, 3, 19, 3, 19, 3, 19, 3, 19, 5, 19, 272, 10, 19, 3, 20, 3, 20, 5, 20, 276, 10, 20, 3, 21, 3, 21, 3, 21, 3, 21, 7, 21, 282, 10, 21, 12, 21, 14, 21, 285, 11, 21, 3, 22, 3, 22, 5, 22, 289, 10, 22, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 5, 23, 309, 10, 23, 3, 24, 3, 24, 3, 24, 3, 24, 3, 25, 3, 25, 3, 25, 7, 25, 318, 10, 25, 12, 25, 14, 25, 321, 11, 25, 3, 26, 3, 26, 3, 26, 3, 26, 7, 26, 327, 10, 26, 12, 26, 14, 26, 330, 11, 26, 3, 27, 3, 27, 3, 27, 3, 27, 3, 28, 3, 28, 3, 28, 3, 28, 3, 28, 3, 28, 5, 28, 342, 10, 28, 5, 28, 344, 10, 28, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 30, 3, 30, 3, 30, 3, 30, 5, 30, 355, 10, 30, 3, 31, 3, 31, 3, 31, 3, 31, 3, 31, 3, 31, 5, 31, 363, 10, 31, 3, 31, 5, 31, 366, 10, 31, 3, 32, 3, 32, 3, 32, 5, 32, 371, 10, 32, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 5, 33, 378, 10, 33, 3, 34, 3, 34, 3, 34, 5, 34, 383, 10, 34, 3, 35, 3, 35, 3, 35, 5, 35, 388, 10, 35, 3, 35, 3, 35, 3, 35, 3, 35, 5, 35, 394, 10, 35, 3, 36, 3, 36, 3, 36, 3, 36, 7, 36, 400, 10, 36, 12, 36, 14, 36, 403, 11, 36, 3, 36, 5, 36, 406, 10, 36, 5, 36, 408, 10, 36, 3, 36, 3, 36, 3, 37, 3, 37, 3, 37, 3, 37, 7, 37, 416, 10, 37, 12, 37, 14, 37, 419, 11, 37, 3, 37, 5, 37, 422, 10, 37, 5, 37, 424, 10, 37, 3, 37, 3, 37, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 5, 38, 437, 10, 38, 3, 39, 3, 39, 3, 39, 3, 39, 3, 40, 3, 40, 3, 40, 5, 40, 446, 10, 40, 3, 41, 3, 41, 3, 42, 3, 42, 3, 43, 3, 43, 3, 44, 3, 44, 3, 45, 3, 45, 3, 46, 3, 46, 3, 46, 3, 46, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 5, 47, 479, 10, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 5, 47, 493, 10, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 5, 47, 526, 10, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 5, 47, 535, 10, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 5, 47, 544, 10, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 5, 47, 551, 10, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 5, 47, 562, 10, 47, 3, 47, 3, 47, 7, 47, 566, 10, 47, 12, 47, 14, 47, 569, 11, 47, 3, 48, 3, 48, 6, 48, 573, 10, 48, 13, 48, 14, 48, 574, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 5, 49, 582, 10, 49, 3, 50, 3, 50, 3, 50, 3, 50, 3, 51, 3, 51, 5, 51, 590, 10, 51, 3, 52, 5, 52, 593, 10, 52, 3, 52, 3, 52, 3, 52, 3, 52, 5, 52, 599, 10, 52, 3, 52, 5, 52, 602, 10, 52, 3, 53, 3, 53, 3, 54, 7, 54, 607, 10, 54, 12, 54, 14, 54, 610, 11, 54, 3, 55, 3, 55, 3, 55, 3, 55, 7, 55, 616, 10, 55, 12, 55, 14, 55, 619, 11, 55, 5, 55, 621, 10, 55, 3, 55, 3, 55, 3, 56, 3, 56, 3, 57, 3, 57, 3, 57, 5, 57, 630, 10, 57, 3, 58, 3, 58, 3, 58, 5, 58, 635, 10, 58, 3, 59, 3, 59, 3, 60, 3, 60, 3, 61, 3, 61, 3, 62, 3, 62, 3, 63, 3, 63, 3, 64, 3, 64, 3, 65, 3, 65, 3, 66, 3, 66, 3, 66, 3, 67, 3, 67, 3, 67, 2, 3, 92, 68, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130, 132, 2, 10, 3, 2, 48, 49, 6, 2, 30, 31, 37, 39, 41, 62, 66, 66, 4, 2, 48, 48, 56, 57, 3, 2, 17, 22, 3, 2, 35, 36, 3, 2, 23, 25, 3, 2, 26, 27, 4, 2, 26, 27, 61, 61, 2, 701, 2, 137, 3, 2, 2, 2, 4, 143, 3, 2, 2, 2, 6, 145, 3, 2, 2, 2, 8, 147, 3, 2, 2, 2, 10, 150, 3, 2, 2, 2, 12, 156, 3, 2, 2, 2, 14, 164, 3, 2, 2, 2, 16, 168, 3, 2, 2, 2, 18, 184, 3, 2, 2, 2, 20, 202, 3, 2, 2, 2, 22, 235, 3, 2, 2, 2, 24, 244, 3, 2, 2, 2, 26, 250, 3, 2, 2, 2, 28, 254, 3, 2, 2, 2, 30, 258, 3, 2, 2, 2, 32, 262, 3, 2, 2, 2, 34, 264, 3, 2, 2, 2, 36, 267, 3, 2, 2, 2, 38, 275, 3, 2, 2, 2, 40, 277, 3, 2, 2, 2, 42, 286, 3, 2, 2, 2, 44, 308, 3, 2, 2, 2, 46, 310, 3, 2, 2, 2, 48, 314, 3, 2, 2, 2, 50, 322, 3, 2, 2, 2, 52, 331, 3, 2, 2, 2, 54, 343, 3, 2, 2, 2, 56, 345, 3, 2, 2, 2, 58, 354, 3, 2, 2, 2, 60, 356, 3, 2, 2, 2, 62, 370, 3, 2, 2, 2, 64, 377, 3, 2, 2, 2, 66, 382, 3, 2, 2, 2, 68, 387, 3, 2, 2, 2, 70, 395, 3, 2, 2, 2, 72, 411, 3, 2, 2, 2, 74, 436, 3, 2, 2, 2, 76, 438, 3, 2, 2, 2, 78, 445, 3, 2, 2, 2, 80, 447, 3, 2, 2, 2, 82, 449, 3, 2, 2, 2, 84, 451, 3, 2, 2, 2, 86, 453, 3, 2, 2, 2, 88, 455, 3, 2, 2, 2, 90, 457, 3, 2, 2, 2, 92, 478, 3, 2, 2, 2, 94, 570, 3, 2, 2, 2, 96, 581, 3, 2, 2, 2, 98, 583, 3, 2, 2, 2, 100, 587, 3, 2, 2, 2, 102, 601, 3, 2, 2, 2, 104, 603, 3, 2, 2, 2, 106, 608, 3, 2, 2, 2, 108, 611, 3, 2, 2, 2, 110, 624, 3, 2, 2, 2, 112, 629, 3, 2, 2, 2, 114, 634, 3, 2, 2, 2, 116, 636, 3, 2, 2, 2, 118, 638, 3, 2, 2, 2, 120, 640, 3, 2, 2, 2, 122, 642, 3, 2, 2, 2, 124, 644, 3, 2, 2, 2, 126, 646, 3, 2, 2, 2, 128, 648, 3, 2, 2, 2, 130, 650, 3, 2, 2, 2, 132, 653, 3, 2, 2, 2, 134, 136, 5, 4, 3, 2, 135, 134, 3, 2, 2, 2, 136, 139, 3, 2, 2, 2, 137, 135, 3, 2, 2, 2, 137, 138, 3, 2, 2, 2, 138, 140, 3, 2, 2, 2, 139, 137, 3, 2, 2, 2, 140, 141, 5, 12, 7, 2, 141, 142, 7, 2, 2, 3, 142, 3, 3, 2, 2, 2, 143, 144, 5, 6, 4, 2, 144, 5, 3, 2, 2, 2, 145, 146, 5, 8, 5, 2, 146, 7, 3, 2, 2, 2, 147, 148, 7, 51, 2, 2, 148, 149, 5, 10, 6, 2, 149, 9, 3, 2, 2, 2, 150, 151, 5, 106, 54, 2, 151, 152, 7, 66, 2, 2, 152, 11, 3, 2, 2, 2, 153, 155, 5, 14, 8, 2, 154, 153, 3, 2, 2, 2, 155, 158, 3, 2, 2, 2, 156, 154, 3, 2, 2, 2, 156, 157, 3, 2, 2, 2, 157, 159, 3, 2, 2, 2, 158, 156, 3, 2, 2, 2, 159, 160, 5, 16, 9, 2, 160, 13, 3, 2, 2, 2, 161, 165, 5, 18, 10, 2, 162, 165, 5, 100, 51, 2, 163, 165, 5, 60, 31, 2, 164, 161, 3, 2, 2, 2, 164, 162, 3, 2, 2, 2, 164, 163, 3, 2, 2, 2, 165, 15, 3, 2, 2, 2, 166, 169, 5, 20, 11, 2, 167, 169, 5, 22, 12, 2, 168, 166, 3, 2, 2, 2, 168, 167, 3, 2, 2, 2, 169, 17, 3, 2, 2, 2, 170, 171, 7, 45, 2, 2, 171, 172, 7, 66, 2, 2, 172, 173, 7, 33, 2, 2, 173, 176, 7, 13, 2, 2, 174, 177, 5, 22, 12, 2, 175, 177, 5, 60, 31, 2, 176, 174, 3, 2, 2, 2, 176, 175, 3, 2, 2, 2, 177, 178, 3, 2, 2, 2, 178, 179, 7, 14, 2, 2, 179, 185, 3, 2, 2, 2, 180, 181, 7, 45, 2, 2, 181, 182, 7, 66, 2, 2, 182, 183, 7, 33, 2, 2, 183, 185, 5, 92, 47, 2, 184, 170, 3, 2, 2, 2, 184, 180, 3, 2, 2, 2, 185, 19, 3, 2, 2, 2, 186, 188, 7, 38, 2, 2, 187, 189, 7, 41, 2, 2, 188, 187, 3, 2, 2, 2, 188, 189, 3, 2, 2, 2, 189, 190, 3, 2, 2, 2, 190, 193, 7, 13, 2, 2, 191, 194, 5, 22, 12, 2, 192, 194, 5, 60, 31, 2, 193, 191, 3, 2, 2, 2, 193, 192, 3, 2, 2, 2, 194, 195, 3, 2, 2, 2, 195, 196, 7, 14, 2, 2, 196, 203, 3, 2, 2, 2, 197, 199, 7, 38, 2, 2, 198, 200, 7, 41, 2, 2, 199, 198, 3, 2, 2, 2, 199, 200, 3, 2, 2, 2, 200, 201, 3, 2, 2, 2, 201, 203, 5, 92, 47, 2, 202, 186, 3, 2, 2, 2, 202, 197, 3, 2, 2, 2, 203, 21, 3, 2, 2, 2, 204, 205, 7, 37, 2, 2, 205, 208, 7, 66, 2, 2, 206, 207, 7, 10, 2, 2, 207, 209, 7, 66, 2, 2, 208, 206, 3, 2, 2, 2, 208, 209, 3, 2, 2, 2, 209, 210, 3, 2, 2, 2, 210, 211, 7, 62, 2, 2, 211, 215, 5, 24, 13, 2, 212, 214, 5, 30, 16, 2, 213, 212, 3, 2, 2, 2, 214, 217, 3, 2, 2, 2, 215, 213, 3, 2, 2, 2, 215, 216, 3, 2, 2, 2, 216, 218, 3, 2, 2, 2, 217, 215, 3, 2, 2, 2, 218, 219, 5, 32, 17, 2, 219, 236, 3, 2, 2, 2, 220, 221, 7, 37, 2, 2, 221, 223, 7, 66, 2, 2, 222, 224, 7, 63, 2, 2, 223, 222, 3, 2, 2, 2, 223, 224, 3, 2, 2, 2, 224, 225, 3, 2, 2, 2, 225, 226, 7, 64, 2, 2, 226, 230, 5, 92, 47, 2, 227, 229, 5, 30, 16, 2, 228, 227, 3, 2, 2, 2, 229, 232, 3, 2, 2, 2, 230, 228, 3, 2, 2, 2, 230, 231, 3, 2, 2, 2, 231, 233, 3, 2, 2, 2, 232, 230, 3, 2, 2, 2, 233, 234, 5, 32, 17, 2, 234, 236, 3, 2, 2, 2, 235, 204, 3, 2, 2, 2, 235, 220, 3, 2, 2, 2, 236, 23, 3, 2, 2, 2, 237, 245, 5, 100, 51, 2, 238, 245, 5, 70, 36, 2, 239, 245, 5, 72, 37, 2, 240, 245, 5, 132, 67, 2, 241, 245, 5, 94, 48, 2, 242, 245, 5, 68, 35, 2, 243, 245, 5, 130, 66, 2, 244, 237, 3, 2, 2, 2, 244, 238, 3, 2, 2, 2, 244, 239, 3, 2, 2, 2, 244, 240, 3, 2, 2, 2, 244, 241, 3, 2, 2, 2, 244, 242, 3, 2, 2, 2, 244, 243, 3, 2, 2, 2, 245, 25, 3, 2, 2, 2, 246, 251, 5, 36, 19, 2, 247, 251, 5, 40, 21, 2, 248, 251, 5, 34, 18, 2, 249, 251, 5, 44, 23, 2, 250, 246, 3, 2, 2, 2, 250, 247, 3, 2, 2, 2, 250, 248, 3, 2, 2, 2, 250, 249, 3, 2, 2, 2, 251, 27, 3, 2, 2, 2, 252, 255, 5, 18, 10, 2, 253, 255, 5, 100, 51, 2, 254, 252, 3, 2, 2, 2, 254, 253, 3, 2, 2, 2, 255, 29, 3, 2, 2, 2, 256, 259, 5, 28, 15, 2, 257, 259, 5, 26, 14, 2, 258, 256, 3, 2, 2, 2, 258, 257, 3, 2, 2, 2, 259, 31, 3, 2, 2, 2, 260, 263, 5, 20, 11, 2, 261, 263, 5, 22, 12, 2, 262, 260, 3, 2, 2, 2, 262, 261, 3, 2, 2, 2, 263, 33, 3, 2, 2, 2, 264, 265, 7, 42, 2, 2, 265, 266, 5, 92, 47, 2, 266, 35, 3, 2, 2, 2, 267, 268, 7, 44, 2, 2, 268, 271, 5, 38, 20, 2, 269, 270, 7, 10, 2, 2, 270, 272, 5, 38, 20, 2, 271, 269, 3, 2, 2, 2, 271, 272, 3, 2, 2, 2, 272, 37, 3, 2, 2, 2, 273, 276, 7, 68, 2, 2, 274, 276, 5, 130, 66, 2, 275, 273, 3, 2, 2, 2, 275, 274, 3, 2, 2, 2, 276, 39, 3, 2, 2, 2, 277, 278, 7, 43, 2, 2, 278, 283, 5, 42, 22, 2, 279, 280, 7, 10, 2, 2, 280, 282, 5, 42, 22, 2, 281, 279, 3, 2, 2, 2, 282, 285, 3, 2, 2, 2, 283, 281, 3, 2, 2, 2, 283, 284, 3, 2, 2, 2, 284, 41, 3, 2, 2, 2, 285, 283, 3, 2, 2, 2, 286, 288, 5, 92, 47, 2, 287, 289, 7, 47, 2, 2, 288, 287, 3, 2, 2, 2, 288, 289, 3, 2, 2, 2, 289, 43, 3, 2, 2, 2, 290, 291, 7, 46, 2, 2, 291, 309, 5, 56, 29, 2, 292, 293, 7, 46, 2, 2, 293, 309, 5, 50, 26, 2, 294, 295, 7, 46, 2, 2, 295, 296, 5, 48, 25, 2, 296, 297, 5, 50, 26, 2, 297, 309, 3, 2, 2, 2, 298, 299, 7, 46, 2, 2, 299, 300, 5, 48, 25, 2, 300, 301, 5, 54, 28, 2, 301, 309, 3, 2, 2, 2, 302, 303, 7, 46, 2, 2, 303, 304, 5, 48, 25, 2, 304, 305, 5, 56, 29, 2, 305, 309, 3, 2, 2, 2, 306, 307, 7, 46, 2, 2, 307, 309, 5, 48, 25, 2, 308, 290, 3, 2, 2, 2, 308, 292, 3, 2, 2, 2, 308, 294, 3, 2, 2, 2, 308, 298, 3, 2, 2, 2, 308, 302, 3, 2, 2, 2, 308, 306, 3, 2, 2, 2, 309, 45, 3, 2, 2, 2, 310, 311, 7, 66, 2, 2, 311, 312, 7, 33, 2, 2, 312, 313, 5, 92, 47, 2, 313, 47, 3, 2, 2, 2, 314, 319, 5, 46, 24, 2, 315, 316, 7, 10, 2, 2, 316, 318, 5, 46, 24, 2, 317, 315, 3, 2, 2, 2, 318, 321, 3, 2, 2, 2, 319, 317, 3, 2, 2, 2, 319, 320, 3, 2, 2, 2, 320, 49, 3, 2, 2, 2, 321, 319, 3, 2, 2, 2, 322, 323, 7, 58, 2, 2, 323, 328, 5, 52, 27, 2, 324, 325, 7, 10, 2, 2, 325, 327, 5, 52, 27, 2, 326, 324, 3, 2, 2, 2, 327, 330, 3, 2, 2, 2, 328, 326, 3, 2, 2, 2, 328, 329, 3, 2, 2, 2, 329, 51, 3, 2, 2, 2, 330, 328, 3, 2, 2, 2, 331, 332, 7, 66, 2, 2, 332, 333, 7, 33, 2, 2, 333, 334, 5, 100, 51, 2, 334, 53, 3, 2, 2, 2, 335, 336, 7, 52, 2, 2, 336, 344, 5, 46, 24, 2, 337, 338, 7, 52, 2, 2, 338, 341, 7, 66, 2, 2, 339, 340, 7, 53, 2, 2, 340, 342, 7, 66, 2, 2, 341, 339, 3, 2, 2, 2, 341, 342, 3, 2, 2, 2, 342, 344, 3, 2, 2, 2, 343, 335, 3, 2, 2, 2, 343, 337, 3, 2, 2, 2, 344, 55, 3, 2, 2, 2, 345, 346, 7, 54, 2, 2, 346, 347, 7, 55, 2, 2, 347, 348, 7, 52, 2, 2, 348, 349, 7, 66, 2, 2, 349, 57, 3, 2, 2, 2, 350, 351, 7, 40, 2, 2, 351, 355, 5, 72, 37, 2, 352, 353, 7, 40, 2, 2, 353, 355, 5, 132, 67, 2, 354, 350, 3, 2, 2, 2, 354, 352, 3, 2, 2, 2, 355, 59, 3, 2, 2, 2, 356, 357, 7, 39, 2, 2, 357, 358, 7, 59, 2, 2, 358, 359, 5, 64, 33, 2, 359, 360, 7, 62, 2, 2, 360, 362, 5, 66, 34, 2, 361, 363, 5, 58, 30, 2, 362, 361, 3, 2, 2, 2, 362, 363, 3, 2, 2, 2, 363, 365, 3, 2, 2, 2, 364, 366, 5, 62, 32, 2, 365, 364, 3, 2, 2, 2, 365, 366, 3, 2, 2, 2, 366, 61, 3, 2, 2, 2, 367, 371, 5, 86, 44, 2, 368, 371, 5, 132, 67, 2, 369, 371, 5, 130, 66, 2, 370, 367, 3, 2, 2, 2, 370, 368, 3, 2, 2, 2, 370, 369, 3, 2, 2, 2, 371, 63, 3, 2, 2, 2, 372, 378, 5, 82, 42, 2, 373, 378, 5, 132, 67, 2, 374, 378, 5, 130, 66, 2, 375, 378, 5, 100, 51, 2, 376, 378, 5, 94, 48, 2, 377, 372, 3, 2, 2, 2, 377, 373, 3, 2, 2, 2, 377, 374, 3, 2, 2, 2, 377, 375, 3, 2, 2, 2, 377, 376, 3, 2, 2, 2, 378, 65, 3, 2, 2, 2, 379, 383, 5, 100, 51, 2, 380, 383, 5, 132, 67, 2, 381, 383, 5, 94, 48, 2, 382, 379, 3, 2, 2, 2, 382, 380, 3, 2, 2, 2, 382, 381, 3, 2, 2, 2, 383, 67, 3, 2, 2, 2, 384, 388, 5, 86, 44, 2, 385, 388, 5, 132, 67, 2, 386, 388, 5, 130, 66, 2, 387, 384, 3, 2, 2, 2, 387, 385, 3, 2, 2, 2, 387, 386, 3, 2, 2, 2, 388, 389, 3, 2, 2, 2, 389, 393, 7, 32, 2, 2, 390, 394, 5, 86, 44, 2, 391, 394, 5, 132, 67, 2, 392, 394, 5, 130, 66, 2, 393, 390, 3, 2, 2, 2, 393, 391, 3, 2, 2, 2, 393, 392, 3, 2, 2, 2, 394, 69, 3, 2, 2, 2, 395, 407, 7, 11, 2, 2, 396, 401, 5, 92, 47, 2, 397, 398, 7, 10, 2, 2, 398, 400, 5, 92, 47, 2, 399, 397, 3, 2, 2, 2, 400, 403, 3, 2, 2, 2, 401, 399, 3, 2, 2, 2, 401, 402, 3, 2, 2, 2, 402, 405, 3, 2, 2, 2, 403, 401, 3, 2, 2, 2, 404, 406, 7, 10, 2, 2, 405, 404, 3, 2, 2, 2, 405, 406, 3, 2, 2, 2, 406, 408, 3, 2, 2, 2, 407, 396, 3, 2, 2, 2, 407, 408, 3, 2, 2, 2, 408, 409, 3, 2, 2, 2, 409, 410, 7, 12, 2, 2, 410, 71, 3, 2, 2, 2, 411, 423, 7, 15, 2, 2, 412, 417, 5, 74, 38, 2, 413, 414, 7, 10, 2, 2, 414, 416, 5, 74, 38, 2, 415, 413, 3, 2, 2, 2, 416, 419, 3, 2, 2, 2, 417, 415, 3, 2, 2, 2, 417, 418, 3, 2, 2, 2, 418, 421, 3, 2, 2, 2, 419, 417, 3, 2, 2, 2, 420, 422, 7, 10, 2, 2, 421, 420, 3, 2, 2, 2, 421, 422, 3, 2, 2, 2, 422, 424, 3, 2, 2, 2, 423, 412, 3, 2, 2, 2, 423, 424, 3, 2, 2, 2, 424, 425, 3, 2, 2, 2, 425, 426, 7, 16, 2, 2, 426, 73, 3, 2, 2, 2, 427, 428, 5, 78, 40, 2, 428, 429, 7, 7, 2, 2, 429, 430, 5, 92, 47, 2, 430, 437, 3, 2, 2, 2, 431, 432, 5, 76, 39, 2, 432, 433, 7, 7, 2, 2, 433, 434, 5, 92, 47, 2, 434, 437, 3, 2, 2, 2, 435, 437, 5, 132, 67, 2, 436, 427, 3, 2, 2, 2, 436, 431, 3, 2, 2, 2, 436, 435, 3, 2, 2, 2, 437, 75, 3, 2, 2, 2, 438, 439, 7, 11, 2, 2, 439, 440, 5, 92, 47, 2, 440, 441, 7, 12, 2, 2, 441, 77, 3, 2, 2, 2, 442, 446, 7, 66, 2, 2, 443, 446, 5, 82, 42, 2, 444, 446, 5, 130, 66, 2, 445, 442, 3, 2, 2, 2, 445, 443, 3, 2, 2, 2, 445, 444, 3, 2, 2, 2, 446, 79, 3, 2, 2, 2, 447, 448, 7, 50, 2, 2, 448, 81, 3, 2, 2, 2, 449, 450, 7, 67, 2, 2, 450, 83, 3, 2, 2, 2, 451, 452, 7, 69, 2, 2, 452, 85, 3, 2, 2, 2, 453, 454, 7, 68, 2, 2, 454, 87, 3, 2, 2, 2, 455, 456, 9, 2, 2, 2, 456, 89, 3, 2, 2, 2, 457, 458, 7, 13, 2, 2, 458, 459, 5, 92, 47, 2, 459, 460, 7, 14, 2, 2, 460, 91, 3, 2, 2, 2, 461, 462, 8, 47, 1, 2, 462, 463, 5, 128, 65, 2, 463, 464, 5, 92, 47, 29, 464, 479, 3, 2, 2, 2, 465, 479, 5, 68, 35, 2, 466, 479, 5, 82, 42, 2, 467, 479, 5, 84, 43, 2, 468, 479, 5, 86, 44, 2, 469, 479, 5, 80, 41, 2, 470, 479, 5, 70, 36, 2, 471, 479, 5, 72, 37, 2, 472, 479, 5, 94, 48, 2, 473, 479, 5, 100, 51, 2, 474, 479, 5, 130, 66, 2, 475, 479, 5, 132, 67, 2, 476, 479, 5, 88, 45, 2, 477, 479, 5, 90, 46, 2, 478, 461, 3, 2, 2, 2, 478, 465, 3, 2, 2, 2, 478, 466, 3, 2, 2, 2, 478, 467, 3, 2, 2, 2, 478, 468, 3, 2, 2, 2, 478, 469, 3, 2, 2, 2, 478, 470, 3, 2, 2, 2, 478, 471, 3, 2, 2, 2, 478, 472, 3, 2, 2, 2, 478, 473, 3, 2, 2, 2, 478, 474, 3, 2, 2, 2, 478, 475, 3, 2, 2, 2, 478, 476, 3, 2, 2, 2, 478, 477, 3, 2, 2, 2, 479, 567, 3, 2, 2, 2, 480, 481, 12, 28, 2, 2, 481, 482, 5, 124, 63, 2, 482, 483, 5, 92, 47, 29, 483, 566, 3, 2, 2, 2, 484, 485, 12, 27, 2, 2, 485, 486, 5, 126, 64, 2, 486, 487, 5, 92, 47, 28, 487, 566, 3, 2, 2, 2, 488, 489, 12, 26, 2, 2, 489, 492, 5, 110, 56, 2, 490, 493, 5, 112, 57, 2, 491, 493, 5, 116, 59, 2, 492, 490, 3, 2, 2, 2, 492, 491, 3, 2, 2, 2, 493, 494, 3, 2, 2, 2, 494, 495, 5, 92, 47, 27, 495, 566, 3, 2, 2, 2, 496, 497, 12, 25, 2, 2, 497, 498, 5, 112, 57, 2, 498, 499, 5, 92, 47, 26, 499, 566, 3, 2, 2, 2, 500, 501, 12, 24, 2, 2, 501, 502, 5, 114, 58, 2, 502, 503, 5, 92, 47, 25, 503, 566, 3, 2, 2, 2, 504, 505, 12, 23, 2, 2, 505, 506, 5, 116, 59, 2, 506, 507, 5, 92, 47, 24, 507, 566, 3, 2, 2, 2, 508, 509, 12, 22, 2, 2, 509, 510, 5, 118, 60, 2, 510, 511, 5, 92, 47, 23, 511, 566, 3, 2, 2, 2, 512, 513, 12, 21, 2, 2, 513, 514, 5, 120, 61, 2, 514, 515, 5, 92, 47, 22, 515, 566, 3, 2, 2, 2, 516, 517, 12, 20, 2, 2, 517, 518, 5, 122, 62, 2, 518, 519, 5, 92, 47, 21, 519, 566, 3, 2, 2, 2, 520, 521, 12, 17, 2, 2, 521, 522, 7, 34, 2, 2, 522, 525, 7, 13, 2, 2, 523, 526, 5, 22, 12, 2, 524, 526, 5, 60, 31, 2, 525, 523, 3, 2, 2, 2, 525, 524, 3, 2, 2, 2, 526, 527, 3, 2, 2, 2, 527, 528, 7, 14, 2, 2, 528, 529, 7, 7, 2, 2, 529, 530, 5, 92, 47, 18, 530, 566, 3, 2, 2, 2, 531, 532, 12, 16, 2, 2, 532, 534, 7, 34, 2, 2, 533, 535, 5, 92, 47, 2, 534, 533, 3, 2, 2, 2, 534, 535, 3, 2, 2, 2, 535, 536, 3, 2, 2, 2, 536, 537, 7, 7, 2, 2, 537, 566, 5, 92, 47, 17, 538, 539, 12, 19, 2, 2, 539, 540, 7, 34, 2, 2, 540, 543, 7, 13, 2, 2, 541, 544, 5, 22, 12, 2, 542, 544, 5, 60, 31, 2, 543, 541, 3, 2, 2, 2, 543, 542, 3, 2, 2, 2, 544, 545, 3, 2, 2, 2, 545, 546, 7, 14, 2, 2, 546, 547, 7, 7, 2, 2, 547, 550, 7, 13, 2, 2, 548, 551, 5, 22, 12, 2, 549, 551, 5, 60, 31, 2, 550, 548, 3, 2, 2, 2, 550, 549, 3, 2, 2, 2, 551, 552, 3, 2, 2, 2, 552, 553, 7, 14, 2, 2, 553, 566, 3, 2, 2, 2, 554, 555, 12, 18, 2, 2, 555, 556, 7, 34, 2, 2, 556, 557, 5, 92, 47, 2, 557, 558, 7, 7, 2, 2, 558, 561, 7, 13, 2, 2, 559, 562, 5, 22, 12, 2, 560, 562, 5, 60, 31, 2, 561, 559, 3, 2, 2, 2, 561, 560, 3, 2, 2, 2, 562, 563, 3, 2, 2, 2, 563, 564, 7, 14, 2, 2, 564, 566, 3, 2, 2, 2, 565, 480, 3, 2, 2, 2, 565, 484, 3, 2, 2, 2, 565, 488, 3, 2, 2, 2, 565, 496, 3, 2, 2, 2, 565, 500, 3, 2, 2, 2, 565, 504, 3, 2, 2, 2, 565, 508, 3, 2, 2, 2, 565, 512, 3, 2, 2, 2, 565, 516, 3, 2, 2, 2, 565, 520, 3, 2, 2, 2, 565, 531, 3, 2, 2, 2, 565, 538, 3, 2, 2, 2, 565, 554, 3, 2, 2, 2, 566, 569, 3, 2, 2, 2, 567, 565, 3, 2, 2, 2, 567, 568, 3, 2, 2, 2, 568, 93, 3, 2, 2, 2, 569, 567, 3, 2, 2, 2, 570, 572, 5, 96, 49, 2, 571, 573, 5, 102, 52, 2, 572, 571, 3, 2, 2, 2, 573, 574, 3, 2, 2, 2, 574, 572, 3, 2, 2, 2, 574, 575, 3, 2, 2, 2, 575, 95, 3, 2, 2, 2, 576, 582, 5, 132, 67, 2, 577, 582, 5, 130, 66, 2, 578, 582, 5, 70, 36, 2, 579, 582, 5, 72, 37, 2, 580, 582, 5, 98, 50, 2, 581, 576, 3, 2, 2, 2, 581, 577, 3, 2, 2, 2, 581, 578, 3, 2, 2, 2, 581, 579, 3, 2, 2, 2, 581, 580, 3, 2, 2, 2, 582, 97, 3, 2, 2, 2, 583, 584, 5, 106, 54, 2, 584, 585, 5, 104, 53, 2, 585, 586, 5, 108, 55, 2, 586, 99, 3, 2, 2, 2, 587, 589, 5, 98, 50, 2, 588, 590, 7, 34, 2, 2, 589, 588, 3, 2, 2, 2, 589, 590, 3, 2, 2, 2, 590, 101, 3, 2, 2, 2, 591, 593, 7, 34, 2, 2, 592, 591, 3, 2, 2, 2, 592, 593, 3, 2, 2, 2, 593, 594, 3, 2, 2, 2, 594, 595, 7, 9, 2, 2, 595, 602, 5, 78, 40, 2, 596, 597, 7, 34, 2, 2, 597, 599, 7, 9, 2, 2, 598, 596, 3, 2, 2, 2, 598, 599, 3, 2, 2, 2, 599, 600, 3, 2, 2, 2, 600, 602, 5, 76, 39, 2, 601, 592, 3, 2, 2, 2, 601, 598, 3, 2, 2, 2, 602, 103, 3, 2, 2, 2, 603, 604, 9, 3, 2, 2, 604, 105, 3, 2, 2, 2, 605, 607, 7, 70, 2, 2, 606, 605, 3, 2, 2, 2, 607, 610, 3, 2, 2, 2, 608, 606, 3, 2, 2, 2, 608, 609, 3, 2, 2, 2, 609, 107, 3, 2, 2, 2, 610, 608, 3, 2, 2, 2, 611, 620, 7, 13, 2, 2, 612, 617, 5, 92, 47, 2, 613, 614, 7, 10, 2, 2, 614, 616, 5, 92, 47, 2, 615, 613, 3, 2, 2, 2, 616, 619, 3, 2, 2, 2, 617, 615, 3, 2, 2, 2, 617, 618, 3, 2, 2, 2, 618, 621, 3, 2, 2, 2, 619, 617, 3, 2, 2, 2, 620, 612, 3, 2, 2, 2, 620, 621, 3, 2, 2, 2, 621, 622, 3, 2, 2, 2, 622, 623, 7, 14, 2, 2, 623, 109, 3, 2, 2, 2, 624, 625, 9, 4, 2, 2, 625, 111, 3, 2, 2, 2, 626, 630, 7, 62, 2, 2, 627, 628, 7, 61, 2, 2, 628, 630, 7, 62, 2, 2, 629, 626, 3, 2, 2, 2, 629, 627, 3, 2, 2, 2, 630, 113, 3, 2, 2, 2, 631, 635, 7, 60, 2, 2, 632, 633, 7, 61, 2, 2, 633, 635, 7, 60, 2, 2, 634, 631, 3, 2, 2, 2, 634, 632, 3, 2, 2, 2, 635, 115, 3, 2, 2, 2, 636, 637, 9, 5, 2, 2, 637, 117, 3, 2, 2, 2, 638, 639, 9, 6, 2, 2, 639, 119, 3, 2, 2, 2, 640, 641, 7, 30, 2, 2, 641, 121, 3, 2, 2, 2, 642, 643, 7, 31, 2, 2, 643, 123, 3, 2, 2, 2, 644, 645, 9, 7, 2, 2, 645, 125, 3, 2, 2, 2, 646, 647, 9, 8, 2, 2, 647, 127, 3, 2, 2, 2, 648, 649, 9, 9, 2, 2, 649, 129, 3, 2, 2, 2, 650, 651, 7, 65, 2, 2, 651, 652, 7, 66, 2, 2, 652, 131, 3, 2, 2, 2, 653, 654, 7, 66, 2, 2, 654, 133, 3, 2, 2, 2, 67, 137, 156, 164, 168, 176, 184, 188, 193, 199, 202, 208, 215, 223, 230, 235, 244, 250, 254, 258, 262, 271, 275, 283, 288, 308, 319, 328, 341, 343, 354, 362, 365, 370, 377, 382, 387, 393, 401, 405, 407, 417, 421, 423, 436, 445, 478, 492, 525, 534, 543, 550, 561, 565, 567, 574, 581, 589, 592, 598, 601, 608, 617, 620, 629, 634, } var literalNames = []string{ "", "", "", "", "", "':'", "';'", "'.'", "','", "'['", "']'", "'('", "')'", "'{'", "'}'", "'>'", "'<'", "'=='", "'>='", "'<='", "'!='", "'*'", "'/'", "'%'", "'+'", "'-'", "'--'", "'++'", "", "", "", "'='", "'?'", "'!~'", "'=~'", "'FOR'", "'RETURN'", "'WAITFOR'", "'OPTIONS'", "'DISTINCT'", "'FILTER'", "'SORT'", "'LIMIT'", "'LET'", "'COLLECT'", "", "'NONE'", "'NULL'", "", "'USE'", "'INTO'", "'KEEP'", "'WITH'", "'COUNT'", "'ALL'", "'ANY'", "'AGGREGATE'", "'EVENT'", "'LIKE'", "", "'IN'", "'DO'", "'WHILE'", "'@'", } var symbolicNames = []string{ "", "MultiLineComment", "SingleLineComment", "WhiteSpaces", "LineTerminator", "Colon", "SemiColon", "Dot", "Comma", "OpenBracket", "CloseBracket", "OpenParen", "CloseParen", "OpenBrace", "CloseBrace", "Gt", "Lt", "Eq", "Gte", "Lte", "Neq", "Multi", "Div", "Mod", "Plus", "Minus", "MinusMinus", "PlusPlus", "And", "Or", "Range", "Assign", "QuestionMark", "RegexNotMatch", "RegexMatch", "For", "Return", "Waitfor", "Options", "Distinct", "Filter", "Sort", "Limit", "Let", "Collect", "SortDirection", "None", "Null", "BooleanLiteral", "Use", "Into", "Keep", "With", "Count", "All", "Any", "Aggregate", "Event", "Like", "Not", "In", "Do", "While", "Param", "Identifier", "StringLiteral", "IntegerLiteral", "FloatLiteral", "NamespaceSegment", "UnknownIdentifier", } var ruleNames = []string{ "program", "head", "useExpression", "use", "namespaceIdentifier", "body", "bodyStatement", "bodyExpression", "variableDeclaration", "returnExpression", "forExpression", "forExpressionSource", "forExpressionClause", "forExpressionStatement", "forExpressionBody", "forExpressionReturn", "filterClause", "limitClause", "limitClauseValue", "sortClause", "sortClauseExpression", "collectClause", "collectSelector", "collectGrouping", "collectAggregator", "collectAggregateSelector", "collectGroupVariable", "collectCounter", "optionsClause", "waitForExpression", "waitForTimeout", "waitForEventName", "waitForEventSource", "rangeOperator", "arrayLiteral", "objectLiteral", "propertyAssignment", "computedPropertyName", "propertyName", "booleanLiteral", "stringLiteral", "floatLiteral", "integerLiteral", "noneLiteral", "expressionGroup", "expression", "memberExpression", "memberExpressionSource", "functionCall", "functionCallExpression", "memberExpressionPath", "functionIdentifier", "namespace", "arguments", "arrayOperator", "inOperator", "likeOperator", "equalityOperator", "regexpOperator", "logicalAndOperator", "logicalOrOperator", "multiplicativeOperator", "additiveOperator", "unaryOperator", "param", "variable", } type FqlParser struct { *antlr.BaseParser } // NewFqlParser produces a new parser instance for the optional input antlr.TokenStream. // // The *FqlParser instance produced may be reused by calling the SetInputStream method. // The initial parser configuration is expensive to construct, and the object is not thread-safe; // however, if used within a Golang sync.Pool, the construction cost amortizes well and the // objects can be used in a thread-safe manner. func NewFqlParser(input antlr.TokenStream) *FqlParser { this := new(FqlParser) deserializer := antlr.NewATNDeserializer(nil) deserializedATN := deserializer.DeserializeFromUInt16(parserATN) decisionToDFA := make([]*antlr.DFA, len(deserializedATN.DecisionToState)) for index, ds := range deserializedATN.DecisionToState { decisionToDFA[index] = antlr.NewDFA(ds, index) } this.BaseParser = antlr.NewBaseParser(input) this.Interpreter = antlr.NewParserATNSimulator(this, deserializedATN, decisionToDFA, antlr.NewPredictionContextCache()) this.RuleNames = ruleNames this.LiteralNames = literalNames this.SymbolicNames = symbolicNames this.GrammarFileName = "FqlParser.g4" return this } // FqlParser tokens. const ( FqlParserEOF = antlr.TokenEOF FqlParserMultiLineComment = 1 FqlParserSingleLineComment = 2 FqlParserWhiteSpaces = 3 FqlParserLineTerminator = 4 FqlParserColon = 5 FqlParserSemiColon = 6 FqlParserDot = 7 FqlParserComma = 8 FqlParserOpenBracket = 9 FqlParserCloseBracket = 10 FqlParserOpenParen = 11 FqlParserCloseParen = 12 FqlParserOpenBrace = 13 FqlParserCloseBrace = 14 FqlParserGt = 15 FqlParserLt = 16 FqlParserEq = 17 FqlParserGte = 18 FqlParserLte = 19 FqlParserNeq = 20 FqlParserMulti = 21 FqlParserDiv = 22 FqlParserMod = 23 FqlParserPlus = 24 FqlParserMinus = 25 FqlParserMinusMinus = 26 FqlParserPlusPlus = 27 FqlParserAnd = 28 FqlParserOr = 29 FqlParserRange = 30 FqlParserAssign = 31 FqlParserQuestionMark = 32 FqlParserRegexNotMatch = 33 FqlParserRegexMatch = 34 FqlParserFor = 35 FqlParserReturn = 36 FqlParserWaitfor = 37 FqlParserOptions = 38 FqlParserDistinct = 39 FqlParserFilter = 40 FqlParserSort = 41 FqlParserLimit = 42 FqlParserLet = 43 FqlParserCollect = 44 FqlParserSortDirection = 45 FqlParserNone = 46 FqlParserNull = 47 FqlParserBooleanLiteral = 48 FqlParserUse = 49 FqlParserInto = 50 FqlParserKeep = 51 FqlParserWith = 52 FqlParserCount = 53 FqlParserAll = 54 FqlParserAny = 55 FqlParserAggregate = 56 FqlParserEvent = 57 FqlParserLike = 58 FqlParserNot = 59 FqlParserIn = 60 FqlParserDo = 61 FqlParserWhile = 62 FqlParserParam = 63 FqlParserIdentifier = 64 FqlParserStringLiteral = 65 FqlParserIntegerLiteral = 66 FqlParserFloatLiteral = 67 FqlParserNamespaceSegment = 68 FqlParserUnknownIdentifier = 69 ) // FqlParser rules. const ( FqlParserRULE_program = 0 FqlParserRULE_head = 1 FqlParserRULE_useExpression = 2 FqlParserRULE_use = 3 FqlParserRULE_namespaceIdentifier = 4 FqlParserRULE_body = 5 FqlParserRULE_bodyStatement = 6 FqlParserRULE_bodyExpression = 7 FqlParserRULE_variableDeclaration = 8 FqlParserRULE_returnExpression = 9 FqlParserRULE_forExpression = 10 FqlParserRULE_forExpressionSource = 11 FqlParserRULE_forExpressionClause = 12 FqlParserRULE_forExpressionStatement = 13 FqlParserRULE_forExpressionBody = 14 FqlParserRULE_forExpressionReturn = 15 FqlParserRULE_filterClause = 16 FqlParserRULE_limitClause = 17 FqlParserRULE_limitClauseValue = 18 FqlParserRULE_sortClause = 19 FqlParserRULE_sortClauseExpression = 20 FqlParserRULE_collectClause = 21 FqlParserRULE_collectSelector = 22 FqlParserRULE_collectGrouping = 23 FqlParserRULE_collectAggregator = 24 FqlParserRULE_collectAggregateSelector = 25 FqlParserRULE_collectGroupVariable = 26 FqlParserRULE_collectCounter = 27 FqlParserRULE_optionsClause = 28 FqlParserRULE_waitForExpression = 29 FqlParserRULE_waitForTimeout = 30 FqlParserRULE_waitForEventName = 31 FqlParserRULE_waitForEventSource = 32 FqlParserRULE_rangeOperator = 33 FqlParserRULE_arrayLiteral = 34 FqlParserRULE_objectLiteral = 35 FqlParserRULE_propertyAssignment = 36 FqlParserRULE_computedPropertyName = 37 FqlParserRULE_propertyName = 38 FqlParserRULE_booleanLiteral = 39 FqlParserRULE_stringLiteral = 40 FqlParserRULE_floatLiteral = 41 FqlParserRULE_integerLiteral = 42 FqlParserRULE_noneLiteral = 43 FqlParserRULE_expressionGroup = 44 FqlParserRULE_expression = 45 FqlParserRULE_memberExpression = 46 FqlParserRULE_memberExpressionSource = 47 FqlParserRULE_functionCall = 48 FqlParserRULE_functionCallExpression = 49 FqlParserRULE_memberExpressionPath = 50 FqlParserRULE_functionIdentifier = 51 FqlParserRULE_namespace = 52 FqlParserRULE_arguments = 53 FqlParserRULE_arrayOperator = 54 FqlParserRULE_inOperator = 55 FqlParserRULE_likeOperator = 56 FqlParserRULE_equalityOperator = 57 FqlParserRULE_regexpOperator = 58 FqlParserRULE_logicalAndOperator = 59 FqlParserRULE_logicalOrOperator = 60 FqlParserRULE_multiplicativeOperator = 61 FqlParserRULE_additiveOperator = 62 FqlParserRULE_unaryOperator = 63 FqlParserRULE_param = 64 FqlParserRULE_variable = 65 ) // IProgramContext is an interface to support dynamic dispatch. type IProgramContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // IsProgramContext differentiates from other interfaces. IsProgramContext() } type ProgramContext struct { *antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyProgramContext() *ProgramContext { var p = new(ProgramContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) p.RuleIndex = FqlParserRULE_program return p } func (*ProgramContext) IsProgramContext() {} func NewProgramContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ProgramContext { var p = new(ProgramContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) p.parser = parser p.RuleIndex = FqlParserRULE_program return p } func (s *ProgramContext) GetParser() antlr.Parser { return s.parser } func (s *ProgramContext) Body() IBodyContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IBodyContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(IBodyContext) } func (s *ProgramContext) EOF() antlr.TerminalNode { return s.GetToken(FqlParserEOF, 0) } func (s *ProgramContext) AllHead() []IHeadContext { var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IHeadContext)(nil)).Elem()) var tst = make([]IHeadContext, len(ts)) for i, t := range ts { if t != nil { tst[i] = t.(IHeadContext) } } return tst } func (s *ProgramContext) Head(i int) IHeadContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IHeadContext)(nil)).Elem(), i) if t == nil { return nil } return t.(IHeadContext) } func (s *ProgramContext) GetRuleContext() antlr.RuleContext { return s } func (s *ProgramContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *ProgramContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.EnterProgram(s) } } func (s *ProgramContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.ExitProgram(s) } } func (s *ProgramContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case FqlParserVisitor: return t.VisitProgram(s) default: return t.VisitChildren(s) } } func (p *FqlParser) Program() (localctx IProgramContext) { localctx = NewProgramContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 0, FqlParserRULE_program) defer func() { p.ExitRule() }() defer func() { if err := recover(); err != nil { if v, ok := err.(antlr.RecognitionException); ok { localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) } else { panic(err) } } }() var _alt int p.EnterOuterAlt(localctx, 1) p.SetState(135) p.GetErrorHandler().Sync(p) _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 0, p.GetParserRuleContext()) for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { if _alt == 1 { { p.SetState(132) p.Head() } } p.SetState(137) p.GetErrorHandler().Sync(p) _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 0, p.GetParserRuleContext()) } { p.SetState(138) p.Body() } { p.SetState(139) p.Match(FqlParserEOF) } return localctx } // IHeadContext is an interface to support dynamic dispatch. type IHeadContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // IsHeadContext differentiates from other interfaces. IsHeadContext() } type HeadContext struct { *antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyHeadContext() *HeadContext { var p = new(HeadContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) p.RuleIndex = FqlParserRULE_head return p } func (*HeadContext) IsHeadContext() {} func NewHeadContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *HeadContext { var p = new(HeadContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) p.parser = parser p.RuleIndex = FqlParserRULE_head return p } func (s *HeadContext) GetParser() antlr.Parser { return s.parser } func (s *HeadContext) UseExpression() IUseExpressionContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IUseExpressionContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(IUseExpressionContext) } func (s *HeadContext) GetRuleContext() antlr.RuleContext { return s } func (s *HeadContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *HeadContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.EnterHead(s) } } func (s *HeadContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.ExitHead(s) } } func (s *HeadContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case FqlParserVisitor: return t.VisitHead(s) default: return t.VisitChildren(s) } } func (p *FqlParser) Head() (localctx IHeadContext) { localctx = NewHeadContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 2, FqlParserRULE_head) defer func() { p.ExitRule() }() defer func() { if err := recover(); err != nil { if v, ok := err.(antlr.RecognitionException); ok { localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) } else { panic(err) } } }() p.EnterOuterAlt(localctx, 1) { p.SetState(141) p.UseExpression() } return localctx } // IUseExpressionContext is an interface to support dynamic dispatch. type IUseExpressionContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // IsUseExpressionContext differentiates from other interfaces. IsUseExpressionContext() } type UseExpressionContext struct { *antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyUseExpressionContext() *UseExpressionContext { var p = new(UseExpressionContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) p.RuleIndex = FqlParserRULE_useExpression return p } func (*UseExpressionContext) IsUseExpressionContext() {} func NewUseExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UseExpressionContext { var p = new(UseExpressionContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) p.parser = parser p.RuleIndex = FqlParserRULE_useExpression return p } func (s *UseExpressionContext) GetParser() antlr.Parser { return s.parser } func (s *UseExpressionContext) Use() IUseContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IUseContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(IUseContext) } func (s *UseExpressionContext) GetRuleContext() antlr.RuleContext { return s } func (s *UseExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *UseExpressionContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.EnterUseExpression(s) } } func (s *UseExpressionContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.ExitUseExpression(s) } } func (s *UseExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case FqlParserVisitor: return t.VisitUseExpression(s) default: return t.VisitChildren(s) } } func (p *FqlParser) UseExpression() (localctx IUseExpressionContext) { localctx = NewUseExpressionContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 4, FqlParserRULE_useExpression) defer func() { p.ExitRule() }() defer func() { if err := recover(); err != nil { if v, ok := err.(antlr.RecognitionException); ok { localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) } else { panic(err) } } }() p.EnterOuterAlt(localctx, 1) { p.SetState(143) p.Use() } return localctx } // IUseContext is an interface to support dynamic dispatch. type IUseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // IsUseContext differentiates from other interfaces. IsUseContext() } type UseContext struct { *antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyUseContext() *UseContext { var p = new(UseContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) p.RuleIndex = FqlParserRULE_use return p } func (*UseContext) IsUseContext() {} func NewUseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UseContext { var p = new(UseContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) p.parser = parser p.RuleIndex = FqlParserRULE_use return p } func (s *UseContext) GetParser() antlr.Parser { return s.parser } func (s *UseContext) Use() antlr.TerminalNode { return s.GetToken(FqlParserUse, 0) } func (s *UseContext) NamespaceIdentifier() INamespaceIdentifierContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*INamespaceIdentifierContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(INamespaceIdentifierContext) } func (s *UseContext) GetRuleContext() antlr.RuleContext { return s } func (s *UseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *UseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.EnterUse(s) } } func (s *UseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.ExitUse(s) } } func (s *UseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case FqlParserVisitor: return t.VisitUse(s) default: return t.VisitChildren(s) } } func (p *FqlParser) Use() (localctx IUseContext) { localctx = NewUseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 6, FqlParserRULE_use) defer func() { p.ExitRule() }() defer func() { if err := recover(); err != nil { if v, ok := err.(antlr.RecognitionException); ok { localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) } else { panic(err) } } }() p.EnterOuterAlt(localctx, 1) { p.SetState(145) p.Match(FqlParserUse) } { p.SetState(146) p.NamespaceIdentifier() } return localctx } // INamespaceIdentifierContext is an interface to support dynamic dispatch. type INamespaceIdentifierContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // IsNamespaceIdentifierContext differentiates from other interfaces. IsNamespaceIdentifierContext() } type NamespaceIdentifierContext struct { *antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyNamespaceIdentifierContext() *NamespaceIdentifierContext { var p = new(NamespaceIdentifierContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) p.RuleIndex = FqlParserRULE_namespaceIdentifier return p } func (*NamespaceIdentifierContext) IsNamespaceIdentifierContext() {} func NewNamespaceIdentifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NamespaceIdentifierContext { var p = new(NamespaceIdentifierContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) p.parser = parser p.RuleIndex = FqlParserRULE_namespaceIdentifier return p } func (s *NamespaceIdentifierContext) GetParser() antlr.Parser { return s.parser } func (s *NamespaceIdentifierContext) Namespace() INamespaceContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*INamespaceContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(INamespaceContext) } func (s *NamespaceIdentifierContext) Identifier() antlr.TerminalNode { return s.GetToken(FqlParserIdentifier, 0) } func (s *NamespaceIdentifierContext) GetRuleContext() antlr.RuleContext { return s } func (s *NamespaceIdentifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *NamespaceIdentifierContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.EnterNamespaceIdentifier(s) } } func (s *NamespaceIdentifierContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.ExitNamespaceIdentifier(s) } } func (s *NamespaceIdentifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case FqlParserVisitor: return t.VisitNamespaceIdentifier(s) default: return t.VisitChildren(s) } } func (p *FqlParser) NamespaceIdentifier() (localctx INamespaceIdentifierContext) { localctx = NewNamespaceIdentifierContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 8, FqlParserRULE_namespaceIdentifier) defer func() { p.ExitRule() }() defer func() { if err := recover(); err != nil { if v, ok := err.(antlr.RecognitionException); ok { localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) } else { panic(err) } } }() p.EnterOuterAlt(localctx, 1) { p.SetState(148) p.Namespace() } { p.SetState(149) p.Match(FqlParserIdentifier) } return localctx } // IBodyContext is an interface to support dynamic dispatch. type IBodyContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // IsBodyContext differentiates from other interfaces. IsBodyContext() } type BodyContext struct { *antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyBodyContext() *BodyContext { var p = new(BodyContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) p.RuleIndex = FqlParserRULE_body return p } func (*BodyContext) IsBodyContext() {} func NewBodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BodyContext { var p = new(BodyContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) p.parser = parser p.RuleIndex = FqlParserRULE_body return p } func (s *BodyContext) GetParser() antlr.Parser { return s.parser } func (s *BodyContext) BodyExpression() IBodyExpressionContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IBodyExpressionContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(IBodyExpressionContext) } func (s *BodyContext) AllBodyStatement() []IBodyStatementContext { var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IBodyStatementContext)(nil)).Elem()) var tst = make([]IBodyStatementContext, len(ts)) for i, t := range ts { if t != nil { tst[i] = t.(IBodyStatementContext) } } return tst } func (s *BodyContext) BodyStatement(i int) IBodyStatementContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IBodyStatementContext)(nil)).Elem(), i) if t == nil { return nil } return t.(IBodyStatementContext) } func (s *BodyContext) GetRuleContext() antlr.RuleContext { return s } func (s *BodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *BodyContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.EnterBody(s) } } func (s *BodyContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.ExitBody(s) } } func (s *BodyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case FqlParserVisitor: return t.VisitBody(s) default: return t.VisitChildren(s) } } func (p *FqlParser) Body() (localctx IBodyContext) { localctx = NewBodyContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 10, FqlParserRULE_body) defer func() { p.ExitRule() }() defer func() { if err := recover(); err != nil { if v, ok := err.(antlr.RecognitionException); ok { localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) } else { panic(err) } } }() var _alt int p.EnterOuterAlt(localctx, 1) p.SetState(154) p.GetErrorHandler().Sync(p) _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 1, p.GetParserRuleContext()) for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { if _alt == 1 { { p.SetState(151) p.BodyStatement() } } p.SetState(156) p.GetErrorHandler().Sync(p) _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 1, p.GetParserRuleContext()) } { p.SetState(157) p.BodyExpression() } return localctx } // IBodyStatementContext is an interface to support dynamic dispatch. type IBodyStatementContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // IsBodyStatementContext differentiates from other interfaces. IsBodyStatementContext() } type BodyStatementContext struct { *antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyBodyStatementContext() *BodyStatementContext { var p = new(BodyStatementContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) p.RuleIndex = FqlParserRULE_bodyStatement return p } func (*BodyStatementContext) IsBodyStatementContext() {} func NewBodyStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BodyStatementContext { var p = new(BodyStatementContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) p.parser = parser p.RuleIndex = FqlParserRULE_bodyStatement return p } func (s *BodyStatementContext) GetParser() antlr.Parser { return s.parser } func (s *BodyStatementContext) VariableDeclaration() IVariableDeclarationContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IVariableDeclarationContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(IVariableDeclarationContext) } func (s *BodyStatementContext) FunctionCallExpression() IFunctionCallExpressionContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IFunctionCallExpressionContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(IFunctionCallExpressionContext) } func (s *BodyStatementContext) WaitForExpression() IWaitForExpressionContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IWaitForExpressionContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(IWaitForExpressionContext) } func (s *BodyStatementContext) GetRuleContext() antlr.RuleContext { return s } func (s *BodyStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *BodyStatementContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.EnterBodyStatement(s) } } func (s *BodyStatementContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.ExitBodyStatement(s) } } func (s *BodyStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case FqlParserVisitor: return t.VisitBodyStatement(s) default: return t.VisitChildren(s) } } func (p *FqlParser) BodyStatement() (localctx IBodyStatementContext) { localctx = NewBodyStatementContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 12, FqlParserRULE_bodyStatement) defer func() { p.ExitRule() }() defer func() { if err := recover(); err != nil { if v, ok := err.(antlr.RecognitionException); ok { localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) } else { panic(err) } } }() p.SetState(162) p.GetErrorHandler().Sync(p) switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 2, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(159) p.VariableDeclaration() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(160) p.FunctionCallExpression() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(161) p.WaitForExpression() } } return localctx } // IBodyExpressionContext is an interface to support dynamic dispatch. type IBodyExpressionContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // IsBodyExpressionContext differentiates from other interfaces. IsBodyExpressionContext() } type BodyExpressionContext struct { *antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyBodyExpressionContext() *BodyExpressionContext { var p = new(BodyExpressionContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) p.RuleIndex = FqlParserRULE_bodyExpression return p } func (*BodyExpressionContext) IsBodyExpressionContext() {} func NewBodyExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BodyExpressionContext { var p = new(BodyExpressionContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) p.parser = parser p.RuleIndex = FqlParserRULE_bodyExpression return p } func (s *BodyExpressionContext) GetParser() antlr.Parser { return s.parser } func (s *BodyExpressionContext) ReturnExpression() IReturnExpressionContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IReturnExpressionContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(IReturnExpressionContext) } func (s *BodyExpressionContext) ForExpression() IForExpressionContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IForExpressionContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(IForExpressionContext) } func (s *BodyExpressionContext) GetRuleContext() antlr.RuleContext { return s } func (s *BodyExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *BodyExpressionContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.EnterBodyExpression(s) } } func (s *BodyExpressionContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.ExitBodyExpression(s) } } func (s *BodyExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case FqlParserVisitor: return t.VisitBodyExpression(s) default: return t.VisitChildren(s) } } func (p *FqlParser) BodyExpression() (localctx IBodyExpressionContext) { localctx = NewBodyExpressionContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 14, FqlParserRULE_bodyExpression) defer func() { p.ExitRule() }() defer func() { if err := recover(); err != nil { if v, ok := err.(antlr.RecognitionException); ok { localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) } else { panic(err) } } }() p.SetState(166) p.GetErrorHandler().Sync(p) switch p.GetTokenStream().LA(1) { case FqlParserReturn: p.EnterOuterAlt(localctx, 1) { p.SetState(164) p.ReturnExpression() } case FqlParserFor: p.EnterOuterAlt(localctx, 2) { p.SetState(165) p.ForExpression() } default: panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) } return localctx } // IVariableDeclarationContext is an interface to support dynamic dispatch. type IVariableDeclarationContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // IsVariableDeclarationContext differentiates from other interfaces. IsVariableDeclarationContext() } type VariableDeclarationContext struct { *antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyVariableDeclarationContext() *VariableDeclarationContext { var p = new(VariableDeclarationContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) p.RuleIndex = FqlParserRULE_variableDeclaration return p } func (*VariableDeclarationContext) IsVariableDeclarationContext() {} func NewVariableDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VariableDeclarationContext { var p = new(VariableDeclarationContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) p.parser = parser p.RuleIndex = FqlParserRULE_variableDeclaration return p } func (s *VariableDeclarationContext) GetParser() antlr.Parser { return s.parser } func (s *VariableDeclarationContext) Let() antlr.TerminalNode { return s.GetToken(FqlParserLet, 0) } func (s *VariableDeclarationContext) Identifier() antlr.TerminalNode { return s.GetToken(FqlParserIdentifier, 0) } func (s *VariableDeclarationContext) Assign() antlr.TerminalNode { return s.GetToken(FqlParserAssign, 0) } func (s *VariableDeclarationContext) OpenParen() antlr.TerminalNode { return s.GetToken(FqlParserOpenParen, 0) } func (s *VariableDeclarationContext) CloseParen() antlr.TerminalNode { return s.GetToken(FqlParserCloseParen, 0) } func (s *VariableDeclarationContext) ForExpression() IForExpressionContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IForExpressionContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(IForExpressionContext) } func (s *VariableDeclarationContext) WaitForExpression() IWaitForExpressionContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IWaitForExpressionContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(IWaitForExpressionContext) } func (s *VariableDeclarationContext) Expression() IExpressionContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(IExpressionContext) } func (s *VariableDeclarationContext) GetRuleContext() antlr.RuleContext { return s } func (s *VariableDeclarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *VariableDeclarationContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.EnterVariableDeclaration(s) } } func (s *VariableDeclarationContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.ExitVariableDeclaration(s) } } func (s *VariableDeclarationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case FqlParserVisitor: return t.VisitVariableDeclaration(s) default: return t.VisitChildren(s) } } func (p *FqlParser) VariableDeclaration() (localctx IVariableDeclarationContext) { localctx = NewVariableDeclarationContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 16, FqlParserRULE_variableDeclaration) defer func() { p.ExitRule() }() defer func() { if err := recover(); err != nil { if v, ok := err.(antlr.RecognitionException); ok { localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) } else { panic(err) } } }() p.SetState(182) p.GetErrorHandler().Sync(p) switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 5, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(168) p.Match(FqlParserLet) } { p.SetState(169) p.Match(FqlParserIdentifier) } { p.SetState(170) p.Match(FqlParserAssign) } { p.SetState(171) p.Match(FqlParserOpenParen) } p.SetState(174) p.GetErrorHandler().Sync(p) switch p.GetTokenStream().LA(1) { case FqlParserFor: { p.SetState(172) p.ForExpression() } case FqlParserWaitfor: { p.SetState(173) p.WaitForExpression() } default: panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) } { p.SetState(176) p.Match(FqlParserCloseParen) } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(178) p.Match(FqlParserLet) } { p.SetState(179) p.Match(FqlParserIdentifier) } { p.SetState(180) p.Match(FqlParserAssign) } { p.SetState(181) p.expression(0) } } return localctx } // IReturnExpressionContext is an interface to support dynamic dispatch. type IReturnExpressionContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // IsReturnExpressionContext differentiates from other interfaces. IsReturnExpressionContext() } type ReturnExpressionContext struct { *antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyReturnExpressionContext() *ReturnExpressionContext { var p = new(ReturnExpressionContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) p.RuleIndex = FqlParserRULE_returnExpression return p } func (*ReturnExpressionContext) IsReturnExpressionContext() {} func NewReturnExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReturnExpressionContext { var p = new(ReturnExpressionContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) p.parser = parser p.RuleIndex = FqlParserRULE_returnExpression return p } func (s *ReturnExpressionContext) GetParser() antlr.Parser { return s.parser } func (s *ReturnExpressionContext) Return() antlr.TerminalNode { return s.GetToken(FqlParserReturn, 0) } func (s *ReturnExpressionContext) OpenParen() antlr.TerminalNode { return s.GetToken(FqlParserOpenParen, 0) } func (s *ReturnExpressionContext) CloseParen() antlr.TerminalNode { return s.GetToken(FqlParserCloseParen, 0) } func (s *ReturnExpressionContext) ForExpression() IForExpressionContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IForExpressionContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(IForExpressionContext) } func (s *ReturnExpressionContext) WaitForExpression() IWaitForExpressionContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IWaitForExpressionContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(IWaitForExpressionContext) } func (s *ReturnExpressionContext) Distinct() antlr.TerminalNode { return s.GetToken(FqlParserDistinct, 0) } func (s *ReturnExpressionContext) Expression() IExpressionContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(IExpressionContext) } func (s *ReturnExpressionContext) GetRuleContext() antlr.RuleContext { return s } func (s *ReturnExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *ReturnExpressionContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.EnterReturnExpression(s) } } func (s *ReturnExpressionContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.ExitReturnExpression(s) } } func (s *ReturnExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case FqlParserVisitor: return t.VisitReturnExpression(s) default: return t.VisitChildren(s) } } func (p *FqlParser) ReturnExpression() (localctx IReturnExpressionContext) { localctx = NewReturnExpressionContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 18, FqlParserRULE_returnExpression) var _la int defer func() { p.ExitRule() }() defer func() { if err := recover(); err != nil { if v, ok := err.(antlr.RecognitionException); ok { localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) } else { panic(err) } } }() p.SetState(200) p.GetErrorHandler().Sync(p) switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 9, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(184) p.Match(FqlParserReturn) } p.SetState(186) p.GetErrorHandler().Sync(p) _la = p.GetTokenStream().LA(1) if _la == FqlParserDistinct { { p.SetState(185) p.Match(FqlParserDistinct) } } { p.SetState(188) p.Match(FqlParserOpenParen) } p.SetState(191) p.GetErrorHandler().Sync(p) switch p.GetTokenStream().LA(1) { case FqlParserFor: { p.SetState(189) p.ForExpression() } case FqlParserWaitfor: { p.SetState(190) p.WaitForExpression() } default: panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) } { p.SetState(193) p.Match(FqlParserCloseParen) } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(195) p.Match(FqlParserReturn) } p.SetState(197) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 8, p.GetParserRuleContext()) == 1 { { p.SetState(196) p.Match(FqlParserDistinct) } } { p.SetState(199) p.expression(0) } } return localctx } // IForExpressionContext is an interface to support dynamic dispatch. type IForExpressionContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // IsForExpressionContext differentiates from other interfaces. IsForExpressionContext() } type ForExpressionContext struct { *antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyForExpressionContext() *ForExpressionContext { var p = new(ForExpressionContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) p.RuleIndex = FqlParserRULE_forExpression return p } func (*ForExpressionContext) IsForExpressionContext() {} func NewForExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForExpressionContext { var p = new(ForExpressionContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) p.parser = parser p.RuleIndex = FqlParserRULE_forExpression return p } func (s *ForExpressionContext) GetParser() antlr.Parser { return s.parser } func (s *ForExpressionContext) For() antlr.TerminalNode { return s.GetToken(FqlParserFor, 0) } func (s *ForExpressionContext) AllIdentifier() []antlr.TerminalNode { return s.GetTokens(FqlParserIdentifier) } func (s *ForExpressionContext) Identifier(i int) antlr.TerminalNode { return s.GetToken(FqlParserIdentifier, i) } func (s *ForExpressionContext) In() antlr.TerminalNode { return s.GetToken(FqlParserIn, 0) } func (s *ForExpressionContext) ForExpressionSource() IForExpressionSourceContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IForExpressionSourceContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(IForExpressionSourceContext) } func (s *ForExpressionContext) ForExpressionReturn() IForExpressionReturnContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IForExpressionReturnContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(IForExpressionReturnContext) } func (s *ForExpressionContext) Comma() antlr.TerminalNode { return s.GetToken(FqlParserComma, 0) } func (s *ForExpressionContext) AllForExpressionBody() []IForExpressionBodyContext { var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IForExpressionBodyContext)(nil)).Elem()) var tst = make([]IForExpressionBodyContext, len(ts)) for i, t := range ts { if t != nil { tst[i] = t.(IForExpressionBodyContext) } } return tst } func (s *ForExpressionContext) ForExpressionBody(i int) IForExpressionBodyContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IForExpressionBodyContext)(nil)).Elem(), i) if t == nil { return nil } return t.(IForExpressionBodyContext) } func (s *ForExpressionContext) While() antlr.TerminalNode { return s.GetToken(FqlParserWhile, 0) } func (s *ForExpressionContext) Expression() IExpressionContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(IExpressionContext) } func (s *ForExpressionContext) Do() antlr.TerminalNode { return s.GetToken(FqlParserDo, 0) } func (s *ForExpressionContext) GetRuleContext() antlr.RuleContext { return s } func (s *ForExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *ForExpressionContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.EnterForExpression(s) } } func (s *ForExpressionContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.ExitForExpression(s) } } func (s *ForExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case FqlParserVisitor: return t.VisitForExpression(s) default: return t.VisitChildren(s) } } func (p *FqlParser) ForExpression() (localctx IForExpressionContext) { localctx = NewForExpressionContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 20, FqlParserRULE_forExpression) var _la int defer func() { p.ExitRule() }() defer func() { if err := recover(); err != nil { if v, ok := err.(antlr.RecognitionException); ok { localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) } else { panic(err) } } }() var _alt int p.SetState(233) p.GetErrorHandler().Sync(p) switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 14, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(202) p.Match(FqlParserFor) } { p.SetState(203) p.Match(FqlParserIdentifier) } p.SetState(206) p.GetErrorHandler().Sync(p) _la = p.GetTokenStream().LA(1) if _la == FqlParserComma { { p.SetState(204) p.Match(FqlParserComma) } { p.SetState(205) p.Match(FqlParserIdentifier) } } { p.SetState(208) p.Match(FqlParserIn) } { p.SetState(209) p.ForExpressionSource() } p.SetState(213) p.GetErrorHandler().Sync(p) _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 11, p.GetParserRuleContext()) for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { if _alt == 1 { { p.SetState(210) p.ForExpressionBody() } } p.SetState(215) p.GetErrorHandler().Sync(p) _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 11, p.GetParserRuleContext()) } { p.SetState(216) p.ForExpressionReturn() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(218) p.Match(FqlParserFor) } { p.SetState(219) p.Match(FqlParserIdentifier) } p.SetState(221) p.GetErrorHandler().Sync(p) _la = p.GetTokenStream().LA(1) if _la == FqlParserDo { { p.SetState(220) p.Match(FqlParserDo) } } { p.SetState(223) p.Match(FqlParserWhile) } { p.SetState(224) p.expression(0) } p.SetState(228) p.GetErrorHandler().Sync(p) _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 13, p.GetParserRuleContext()) for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { if _alt == 1 { { p.SetState(225) p.ForExpressionBody() } } p.SetState(230) p.GetErrorHandler().Sync(p) _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 13, p.GetParserRuleContext()) } { p.SetState(231) p.ForExpressionReturn() } } return localctx } // IForExpressionSourceContext is an interface to support dynamic dispatch. type IForExpressionSourceContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // IsForExpressionSourceContext differentiates from other interfaces. IsForExpressionSourceContext() } type ForExpressionSourceContext struct { *antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyForExpressionSourceContext() *ForExpressionSourceContext { var p = new(ForExpressionSourceContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) p.RuleIndex = FqlParserRULE_forExpressionSource return p } func (*ForExpressionSourceContext) IsForExpressionSourceContext() {} func NewForExpressionSourceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForExpressionSourceContext { var p = new(ForExpressionSourceContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) p.parser = parser p.RuleIndex = FqlParserRULE_forExpressionSource return p } func (s *ForExpressionSourceContext) GetParser() antlr.Parser { return s.parser } func (s *ForExpressionSourceContext) FunctionCallExpression() IFunctionCallExpressionContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IFunctionCallExpressionContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(IFunctionCallExpressionContext) } func (s *ForExpressionSourceContext) ArrayLiteral() IArrayLiteralContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IArrayLiteralContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(IArrayLiteralContext) } func (s *ForExpressionSourceContext) ObjectLiteral() IObjectLiteralContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IObjectLiteralContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(IObjectLiteralContext) } func (s *ForExpressionSourceContext) Variable() IVariableContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IVariableContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(IVariableContext) } func (s *ForExpressionSourceContext) MemberExpression() IMemberExpressionContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IMemberExpressionContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(IMemberExpressionContext) } func (s *ForExpressionSourceContext) RangeOperator() IRangeOperatorContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IRangeOperatorContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(IRangeOperatorContext) } func (s *ForExpressionSourceContext) Param() IParamContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IParamContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(IParamContext) } func (s *ForExpressionSourceContext) GetRuleContext() antlr.RuleContext { return s } func (s *ForExpressionSourceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *ForExpressionSourceContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.EnterForExpressionSource(s) } } func (s *ForExpressionSourceContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.ExitForExpressionSource(s) } } func (s *ForExpressionSourceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case FqlParserVisitor: return t.VisitForExpressionSource(s) default: return t.VisitChildren(s) } } func (p *FqlParser) ForExpressionSource() (localctx IForExpressionSourceContext) { localctx = NewForExpressionSourceContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 22, FqlParserRULE_forExpressionSource) defer func() { p.ExitRule() }() defer func() { if err := recover(); err != nil { if v, ok := err.(antlr.RecognitionException); ok { localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) } else { panic(err) } } }() p.SetState(242) p.GetErrorHandler().Sync(p) switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 15, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(235) p.FunctionCallExpression() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(236) p.ArrayLiteral() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(237) p.ObjectLiteral() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(238) p.Variable() } case 5: p.EnterOuterAlt(localctx, 5) { p.SetState(239) p.MemberExpression() } case 6: p.EnterOuterAlt(localctx, 6) { p.SetState(240) p.RangeOperator() } case 7: p.EnterOuterAlt(localctx, 7) { p.SetState(241) p.Param() } } return localctx } // IForExpressionClauseContext is an interface to support dynamic dispatch. type IForExpressionClauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // IsForExpressionClauseContext differentiates from other interfaces. IsForExpressionClauseContext() } type ForExpressionClauseContext struct { *antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyForExpressionClauseContext() *ForExpressionClauseContext { var p = new(ForExpressionClauseContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) p.RuleIndex = FqlParserRULE_forExpressionClause return p } func (*ForExpressionClauseContext) IsForExpressionClauseContext() {} func NewForExpressionClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForExpressionClauseContext { var p = new(ForExpressionClauseContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) p.parser = parser p.RuleIndex = FqlParserRULE_forExpressionClause return p } func (s *ForExpressionClauseContext) GetParser() antlr.Parser { return s.parser } func (s *ForExpressionClauseContext) LimitClause() ILimitClauseContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*ILimitClauseContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(ILimitClauseContext) } func (s *ForExpressionClauseContext) SortClause() ISortClauseContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*ISortClauseContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(ISortClauseContext) } func (s *ForExpressionClauseContext) FilterClause() IFilterClauseContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IFilterClauseContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(IFilterClauseContext) } func (s *ForExpressionClauseContext) CollectClause() ICollectClauseContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*ICollectClauseContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(ICollectClauseContext) } func (s *ForExpressionClauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *ForExpressionClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *ForExpressionClauseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.EnterForExpressionClause(s) } } func (s *ForExpressionClauseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.ExitForExpressionClause(s) } } func (s *ForExpressionClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case FqlParserVisitor: return t.VisitForExpressionClause(s) default: return t.VisitChildren(s) } } func (p *FqlParser) ForExpressionClause() (localctx IForExpressionClauseContext) { localctx = NewForExpressionClauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 24, FqlParserRULE_forExpressionClause) defer func() { p.ExitRule() }() defer func() { if err := recover(); err != nil { if v, ok := err.(antlr.RecognitionException); ok { localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) } else { panic(err) } } }() p.SetState(248) p.GetErrorHandler().Sync(p) switch p.GetTokenStream().LA(1) { case FqlParserLimit: p.EnterOuterAlt(localctx, 1) { p.SetState(244) p.LimitClause() } case FqlParserSort: p.EnterOuterAlt(localctx, 2) { p.SetState(245) p.SortClause() } case FqlParserFilter: p.EnterOuterAlt(localctx, 3) { p.SetState(246) p.FilterClause() } case FqlParserCollect: p.EnterOuterAlt(localctx, 4) { p.SetState(247) p.CollectClause() } default: panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) } return localctx } // IForExpressionStatementContext is an interface to support dynamic dispatch. type IForExpressionStatementContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // IsForExpressionStatementContext differentiates from other interfaces. IsForExpressionStatementContext() } type ForExpressionStatementContext struct { *antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyForExpressionStatementContext() *ForExpressionStatementContext { var p = new(ForExpressionStatementContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) p.RuleIndex = FqlParserRULE_forExpressionStatement return p } func (*ForExpressionStatementContext) IsForExpressionStatementContext() {} func NewForExpressionStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForExpressionStatementContext { var p = new(ForExpressionStatementContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) p.parser = parser p.RuleIndex = FqlParserRULE_forExpressionStatement return p } func (s *ForExpressionStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ForExpressionStatementContext) VariableDeclaration() IVariableDeclarationContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IVariableDeclarationContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(IVariableDeclarationContext) } func (s *ForExpressionStatementContext) FunctionCallExpression() IFunctionCallExpressionContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IFunctionCallExpressionContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(IFunctionCallExpressionContext) } func (s *ForExpressionStatementContext) GetRuleContext() antlr.RuleContext { return s } func (s *ForExpressionStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *ForExpressionStatementContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.EnterForExpressionStatement(s) } } func (s *ForExpressionStatementContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.ExitForExpressionStatement(s) } } func (s *ForExpressionStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case FqlParserVisitor: return t.VisitForExpressionStatement(s) default: return t.VisitChildren(s) } } func (p *FqlParser) ForExpressionStatement() (localctx IForExpressionStatementContext) { localctx = NewForExpressionStatementContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 26, FqlParserRULE_forExpressionStatement) defer func() { p.ExitRule() }() defer func() { if err := recover(); err != nil { if v, ok := err.(antlr.RecognitionException); ok { localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) } else { panic(err) } } }() p.SetState(252) p.GetErrorHandler().Sync(p) switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 17, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(250) p.VariableDeclaration() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(251) p.FunctionCallExpression() } } return localctx } // IForExpressionBodyContext is an interface to support dynamic dispatch. type IForExpressionBodyContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // IsForExpressionBodyContext differentiates from other interfaces. IsForExpressionBodyContext() } type ForExpressionBodyContext struct { *antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyForExpressionBodyContext() *ForExpressionBodyContext { var p = new(ForExpressionBodyContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) p.RuleIndex = FqlParserRULE_forExpressionBody return p } func (*ForExpressionBodyContext) IsForExpressionBodyContext() {} func NewForExpressionBodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForExpressionBodyContext { var p = new(ForExpressionBodyContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) p.parser = parser p.RuleIndex = FqlParserRULE_forExpressionBody return p } func (s *ForExpressionBodyContext) GetParser() antlr.Parser { return s.parser } func (s *ForExpressionBodyContext) ForExpressionStatement() IForExpressionStatementContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IForExpressionStatementContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(IForExpressionStatementContext) } func (s *ForExpressionBodyContext) ForExpressionClause() IForExpressionClauseContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IForExpressionClauseContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(IForExpressionClauseContext) } func (s *ForExpressionBodyContext) GetRuleContext() antlr.RuleContext { return s } func (s *ForExpressionBodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *ForExpressionBodyContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.EnterForExpressionBody(s) } } func (s *ForExpressionBodyContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.ExitForExpressionBody(s) } } func (s *ForExpressionBodyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case FqlParserVisitor: return t.VisitForExpressionBody(s) default: return t.VisitChildren(s) } } func (p *FqlParser) ForExpressionBody() (localctx IForExpressionBodyContext) { localctx = NewForExpressionBodyContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 28, FqlParserRULE_forExpressionBody) defer func() { p.ExitRule() }() defer func() { if err := recover(); err != nil { if v, ok := err.(antlr.RecognitionException); ok { localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) } else { panic(err) } } }() p.SetState(256) p.GetErrorHandler().Sync(p) switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 18, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(254) p.ForExpressionStatement() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(255) p.ForExpressionClause() } } return localctx } // IForExpressionReturnContext is an interface to support dynamic dispatch. type IForExpressionReturnContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // IsForExpressionReturnContext differentiates from other interfaces. IsForExpressionReturnContext() } type ForExpressionReturnContext struct { *antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyForExpressionReturnContext() *ForExpressionReturnContext { var p = new(ForExpressionReturnContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) p.RuleIndex = FqlParserRULE_forExpressionReturn return p } func (*ForExpressionReturnContext) IsForExpressionReturnContext() {} func NewForExpressionReturnContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForExpressionReturnContext { var p = new(ForExpressionReturnContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) p.parser = parser p.RuleIndex = FqlParserRULE_forExpressionReturn return p } func (s *ForExpressionReturnContext) GetParser() antlr.Parser { return s.parser } func (s *ForExpressionReturnContext) ReturnExpression() IReturnExpressionContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IReturnExpressionContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(IReturnExpressionContext) } func (s *ForExpressionReturnContext) ForExpression() IForExpressionContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IForExpressionContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(IForExpressionContext) } func (s *ForExpressionReturnContext) GetRuleContext() antlr.RuleContext { return s } func (s *ForExpressionReturnContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *ForExpressionReturnContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.EnterForExpressionReturn(s) } } func (s *ForExpressionReturnContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.ExitForExpressionReturn(s) } } func (s *ForExpressionReturnContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case FqlParserVisitor: return t.VisitForExpressionReturn(s) default: return t.VisitChildren(s) } } func (p *FqlParser) ForExpressionReturn() (localctx IForExpressionReturnContext) { localctx = NewForExpressionReturnContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 30, FqlParserRULE_forExpressionReturn) defer func() { p.ExitRule() }() defer func() { if err := recover(); err != nil { if v, ok := err.(antlr.RecognitionException); ok { localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) } else { panic(err) } } }() p.SetState(260) p.GetErrorHandler().Sync(p) switch p.GetTokenStream().LA(1) { case FqlParserReturn: p.EnterOuterAlt(localctx, 1) { p.SetState(258) p.ReturnExpression() } case FqlParserFor: p.EnterOuterAlt(localctx, 2) { p.SetState(259) p.ForExpression() } default: panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) } return localctx } // IFilterClauseContext is an interface to support dynamic dispatch. type IFilterClauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // IsFilterClauseContext differentiates from other interfaces. IsFilterClauseContext() } type FilterClauseContext struct { *antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyFilterClauseContext() *FilterClauseContext { var p = new(FilterClauseContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) p.RuleIndex = FqlParserRULE_filterClause return p } func (*FilterClauseContext) IsFilterClauseContext() {} func NewFilterClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FilterClauseContext { var p = new(FilterClauseContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) p.parser = parser p.RuleIndex = FqlParserRULE_filterClause return p } func (s *FilterClauseContext) GetParser() antlr.Parser { return s.parser } func (s *FilterClauseContext) Filter() antlr.TerminalNode { return s.GetToken(FqlParserFilter, 0) } func (s *FilterClauseContext) Expression() IExpressionContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(IExpressionContext) } func (s *FilterClauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *FilterClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *FilterClauseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.EnterFilterClause(s) } } func (s *FilterClauseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.ExitFilterClause(s) } } func (s *FilterClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case FqlParserVisitor: return t.VisitFilterClause(s) default: return t.VisitChildren(s) } } func (p *FqlParser) FilterClause() (localctx IFilterClauseContext) { localctx = NewFilterClauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 32, FqlParserRULE_filterClause) defer func() { p.ExitRule() }() defer func() { if err := recover(); err != nil { if v, ok := err.(antlr.RecognitionException); ok { localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) } else { panic(err) } } }() p.EnterOuterAlt(localctx, 1) { p.SetState(262) p.Match(FqlParserFilter) } { p.SetState(263) p.expression(0) } return localctx } // ILimitClauseContext is an interface to support dynamic dispatch. type ILimitClauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // IsLimitClauseContext differentiates from other interfaces. IsLimitClauseContext() } type LimitClauseContext struct { *antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyLimitClauseContext() *LimitClauseContext { var p = new(LimitClauseContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) p.RuleIndex = FqlParserRULE_limitClause return p } func (*LimitClauseContext) IsLimitClauseContext() {} func NewLimitClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LimitClauseContext { var p = new(LimitClauseContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) p.parser = parser p.RuleIndex = FqlParserRULE_limitClause return p } func (s *LimitClauseContext) GetParser() antlr.Parser { return s.parser } func (s *LimitClauseContext) Limit() antlr.TerminalNode { return s.GetToken(FqlParserLimit, 0) } func (s *LimitClauseContext) AllLimitClauseValue() []ILimitClauseValueContext { var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ILimitClauseValueContext)(nil)).Elem()) var tst = make([]ILimitClauseValueContext, len(ts)) for i, t := range ts { if t != nil { tst[i] = t.(ILimitClauseValueContext) } } return tst } func (s *LimitClauseContext) LimitClauseValue(i int) ILimitClauseValueContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*ILimitClauseValueContext)(nil)).Elem(), i) if t == nil { return nil } return t.(ILimitClauseValueContext) } func (s *LimitClauseContext) Comma() antlr.TerminalNode { return s.GetToken(FqlParserComma, 0) } func (s *LimitClauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *LimitClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *LimitClauseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.EnterLimitClause(s) } } func (s *LimitClauseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.ExitLimitClause(s) } } func (s *LimitClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case FqlParserVisitor: return t.VisitLimitClause(s) default: return t.VisitChildren(s) } } func (p *FqlParser) LimitClause() (localctx ILimitClauseContext) { localctx = NewLimitClauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 34, FqlParserRULE_limitClause) var _la int defer func() { p.ExitRule() }() defer func() { if err := recover(); err != nil { if v, ok := err.(antlr.RecognitionException); ok { localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) } else { panic(err) } } }() p.EnterOuterAlt(localctx, 1) { p.SetState(265) p.Match(FqlParserLimit) } { p.SetState(266) p.LimitClauseValue() } p.SetState(269) p.GetErrorHandler().Sync(p) _la = p.GetTokenStream().LA(1) if _la == FqlParserComma { { p.SetState(267) p.Match(FqlParserComma) } { p.SetState(268) p.LimitClauseValue() } } return localctx } // ILimitClauseValueContext is an interface to support dynamic dispatch. type ILimitClauseValueContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // IsLimitClauseValueContext differentiates from other interfaces. IsLimitClauseValueContext() } type LimitClauseValueContext struct { *antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyLimitClauseValueContext() *LimitClauseValueContext { var p = new(LimitClauseValueContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) p.RuleIndex = FqlParserRULE_limitClauseValue return p } func (*LimitClauseValueContext) IsLimitClauseValueContext() {} func NewLimitClauseValueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LimitClauseValueContext { var p = new(LimitClauseValueContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) p.parser = parser p.RuleIndex = FqlParserRULE_limitClauseValue return p } func (s *LimitClauseValueContext) GetParser() antlr.Parser { return s.parser } func (s *LimitClauseValueContext) IntegerLiteral() antlr.TerminalNode { return s.GetToken(FqlParserIntegerLiteral, 0) } func (s *LimitClauseValueContext) Param() IParamContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IParamContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(IParamContext) } func (s *LimitClauseValueContext) GetRuleContext() antlr.RuleContext { return s } func (s *LimitClauseValueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *LimitClauseValueContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.EnterLimitClauseValue(s) } } func (s *LimitClauseValueContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.ExitLimitClauseValue(s) } } func (s *LimitClauseValueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case FqlParserVisitor: return t.VisitLimitClauseValue(s) default: return t.VisitChildren(s) } } func (p *FqlParser) LimitClauseValue() (localctx ILimitClauseValueContext) { localctx = NewLimitClauseValueContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 36, FqlParserRULE_limitClauseValue) defer func() { p.ExitRule() }() defer func() { if err := recover(); err != nil { if v, ok := err.(antlr.RecognitionException); ok { localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) } else { panic(err) } } }() p.SetState(273) p.GetErrorHandler().Sync(p) switch p.GetTokenStream().LA(1) { case FqlParserIntegerLiteral: p.EnterOuterAlt(localctx, 1) { p.SetState(271) p.Match(FqlParserIntegerLiteral) } case FqlParserParam: p.EnterOuterAlt(localctx, 2) { p.SetState(272) p.Param() } default: panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) } return localctx } // ISortClauseContext is an interface to support dynamic dispatch. type ISortClauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // IsSortClauseContext differentiates from other interfaces. IsSortClauseContext() } type SortClauseContext struct { *antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptySortClauseContext() *SortClauseContext { var p = new(SortClauseContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) p.RuleIndex = FqlParserRULE_sortClause return p } func (*SortClauseContext) IsSortClauseContext() {} func NewSortClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SortClauseContext { var p = new(SortClauseContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) p.parser = parser p.RuleIndex = FqlParserRULE_sortClause return p } func (s *SortClauseContext) GetParser() antlr.Parser { return s.parser } func (s *SortClauseContext) Sort() antlr.TerminalNode { return s.GetToken(FqlParserSort, 0) } func (s *SortClauseContext) AllSortClauseExpression() []ISortClauseExpressionContext { var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISortClauseExpressionContext)(nil)).Elem()) var tst = make([]ISortClauseExpressionContext, len(ts)) for i, t := range ts { if t != nil { tst[i] = t.(ISortClauseExpressionContext) } } return tst } func (s *SortClauseContext) SortClauseExpression(i int) ISortClauseExpressionContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*ISortClauseExpressionContext)(nil)).Elem(), i) if t == nil { return nil } return t.(ISortClauseExpressionContext) } func (s *SortClauseContext) AllComma() []antlr.TerminalNode { return s.GetTokens(FqlParserComma) } func (s *SortClauseContext) Comma(i int) antlr.TerminalNode { return s.GetToken(FqlParserComma, i) } func (s *SortClauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *SortClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *SortClauseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.EnterSortClause(s) } } func (s *SortClauseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.ExitSortClause(s) } } func (s *SortClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case FqlParserVisitor: return t.VisitSortClause(s) default: return t.VisitChildren(s) } } func (p *FqlParser) SortClause() (localctx ISortClauseContext) { localctx = NewSortClauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 38, FqlParserRULE_sortClause) var _la int defer func() { p.ExitRule() }() defer func() { if err := recover(); err != nil { if v, ok := err.(antlr.RecognitionException); ok { localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) } else { panic(err) } } }() p.EnterOuterAlt(localctx, 1) { p.SetState(275) p.Match(FqlParserSort) } { p.SetState(276) p.SortClauseExpression() } p.SetState(281) p.GetErrorHandler().Sync(p) _la = p.GetTokenStream().LA(1) for _la == FqlParserComma { { p.SetState(277) p.Match(FqlParserComma) } { p.SetState(278) p.SortClauseExpression() } p.SetState(283) p.GetErrorHandler().Sync(p) _la = p.GetTokenStream().LA(1) } return localctx } // ISortClauseExpressionContext is an interface to support dynamic dispatch. type ISortClauseExpressionContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // IsSortClauseExpressionContext differentiates from other interfaces. IsSortClauseExpressionContext() } type SortClauseExpressionContext struct { *antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptySortClauseExpressionContext() *SortClauseExpressionContext { var p = new(SortClauseExpressionContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) p.RuleIndex = FqlParserRULE_sortClauseExpression return p } func (*SortClauseExpressionContext) IsSortClauseExpressionContext() {} func NewSortClauseExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SortClauseExpressionContext { var p = new(SortClauseExpressionContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) p.parser = parser p.RuleIndex = FqlParserRULE_sortClauseExpression return p } func (s *SortClauseExpressionContext) GetParser() antlr.Parser { return s.parser } func (s *SortClauseExpressionContext) Expression() IExpressionContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(IExpressionContext) } func (s *SortClauseExpressionContext) SortDirection() antlr.TerminalNode { return s.GetToken(FqlParserSortDirection, 0) } func (s *SortClauseExpressionContext) GetRuleContext() antlr.RuleContext { return s } func (s *SortClauseExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *SortClauseExpressionContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.EnterSortClauseExpression(s) } } func (s *SortClauseExpressionContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.ExitSortClauseExpression(s) } } func (s *SortClauseExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case FqlParserVisitor: return t.VisitSortClauseExpression(s) default: return t.VisitChildren(s) } } func (p *FqlParser) SortClauseExpression() (localctx ISortClauseExpressionContext) { localctx = NewSortClauseExpressionContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 40, FqlParserRULE_sortClauseExpression) defer func() { p.ExitRule() }() defer func() { if err := recover(); err != nil { if v, ok := err.(antlr.RecognitionException); ok { localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) } else { panic(err) } } }() p.EnterOuterAlt(localctx, 1) { p.SetState(284) p.expression(0) } p.SetState(286) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 23, p.GetParserRuleContext()) == 1 { { p.SetState(285) p.Match(FqlParserSortDirection) } } return localctx } // ICollectClauseContext is an interface to support dynamic dispatch. type ICollectClauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // IsCollectClauseContext differentiates from other interfaces. IsCollectClauseContext() } type CollectClauseContext struct { *antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCollectClauseContext() *CollectClauseContext { var p = new(CollectClauseContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) p.RuleIndex = FqlParserRULE_collectClause return p } func (*CollectClauseContext) IsCollectClauseContext() {} func NewCollectClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CollectClauseContext { var p = new(CollectClauseContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) p.parser = parser p.RuleIndex = FqlParserRULE_collectClause return p } func (s *CollectClauseContext) GetParser() antlr.Parser { return s.parser } func (s *CollectClauseContext) Collect() antlr.TerminalNode { return s.GetToken(FqlParserCollect, 0) } func (s *CollectClauseContext) CollectCounter() ICollectCounterContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*ICollectCounterContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(ICollectCounterContext) } func (s *CollectClauseContext) CollectAggregator() ICollectAggregatorContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*ICollectAggregatorContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(ICollectAggregatorContext) } func (s *CollectClauseContext) CollectGrouping() ICollectGroupingContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*ICollectGroupingContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(ICollectGroupingContext) } func (s *CollectClauseContext) CollectGroupVariable() ICollectGroupVariableContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*ICollectGroupVariableContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(ICollectGroupVariableContext) } func (s *CollectClauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *CollectClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *CollectClauseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.EnterCollectClause(s) } } func (s *CollectClauseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.ExitCollectClause(s) } } func (s *CollectClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case FqlParserVisitor: return t.VisitCollectClause(s) default: return t.VisitChildren(s) } } func (p *FqlParser) CollectClause() (localctx ICollectClauseContext) { localctx = NewCollectClauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 42, FqlParserRULE_collectClause) defer func() { p.ExitRule() }() defer func() { if err := recover(); err != nil { if v, ok := err.(antlr.RecognitionException); ok { localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) } else { panic(err) } } }() p.SetState(306) p.GetErrorHandler().Sync(p) switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 24, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(288) p.Match(FqlParserCollect) } { p.SetState(289) p.CollectCounter() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(290) p.Match(FqlParserCollect) } { p.SetState(291) p.CollectAggregator() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(292) p.Match(FqlParserCollect) } { p.SetState(293) p.CollectGrouping() } { p.SetState(294) p.CollectAggregator() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(296) p.Match(FqlParserCollect) } { p.SetState(297) p.CollectGrouping() } { p.SetState(298) p.CollectGroupVariable() } case 5: p.EnterOuterAlt(localctx, 5) { p.SetState(300) p.Match(FqlParserCollect) } { p.SetState(301) p.CollectGrouping() } { p.SetState(302) p.CollectCounter() } case 6: p.EnterOuterAlt(localctx, 6) { p.SetState(304) p.Match(FqlParserCollect) } { p.SetState(305) p.CollectGrouping() } } return localctx } // ICollectSelectorContext is an interface to support dynamic dispatch. type ICollectSelectorContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // IsCollectSelectorContext differentiates from other interfaces. IsCollectSelectorContext() } type CollectSelectorContext struct { *antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCollectSelectorContext() *CollectSelectorContext { var p = new(CollectSelectorContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) p.RuleIndex = FqlParserRULE_collectSelector return p } func (*CollectSelectorContext) IsCollectSelectorContext() {} func NewCollectSelectorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CollectSelectorContext { var p = new(CollectSelectorContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) p.parser = parser p.RuleIndex = FqlParserRULE_collectSelector return p } func (s *CollectSelectorContext) GetParser() antlr.Parser { return s.parser } func (s *CollectSelectorContext) Identifier() antlr.TerminalNode { return s.GetToken(FqlParserIdentifier, 0) } func (s *CollectSelectorContext) Assign() antlr.TerminalNode { return s.GetToken(FqlParserAssign, 0) } func (s *CollectSelectorContext) Expression() IExpressionContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(IExpressionContext) } func (s *CollectSelectorContext) GetRuleContext() antlr.RuleContext { return s } func (s *CollectSelectorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *CollectSelectorContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.EnterCollectSelector(s) } } func (s *CollectSelectorContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.ExitCollectSelector(s) } } func (s *CollectSelectorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case FqlParserVisitor: return t.VisitCollectSelector(s) default: return t.VisitChildren(s) } } func (p *FqlParser) CollectSelector() (localctx ICollectSelectorContext) { localctx = NewCollectSelectorContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 44, FqlParserRULE_collectSelector) defer func() { p.ExitRule() }() defer func() { if err := recover(); err != nil { if v, ok := err.(antlr.RecognitionException); ok { localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) } else { panic(err) } } }() p.EnterOuterAlt(localctx, 1) { p.SetState(308) p.Match(FqlParserIdentifier) } { p.SetState(309) p.Match(FqlParserAssign) } { p.SetState(310) p.expression(0) } return localctx } // ICollectGroupingContext is an interface to support dynamic dispatch. type ICollectGroupingContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // IsCollectGroupingContext differentiates from other interfaces. IsCollectGroupingContext() } type CollectGroupingContext struct { *antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCollectGroupingContext() *CollectGroupingContext { var p = new(CollectGroupingContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) p.RuleIndex = FqlParserRULE_collectGrouping return p } func (*CollectGroupingContext) IsCollectGroupingContext() {} func NewCollectGroupingContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CollectGroupingContext { var p = new(CollectGroupingContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) p.parser = parser p.RuleIndex = FqlParserRULE_collectGrouping return p } func (s *CollectGroupingContext) GetParser() antlr.Parser { return s.parser } func (s *CollectGroupingContext) AllCollectSelector() []ICollectSelectorContext { var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ICollectSelectorContext)(nil)).Elem()) var tst = make([]ICollectSelectorContext, len(ts)) for i, t := range ts { if t != nil { tst[i] = t.(ICollectSelectorContext) } } return tst } func (s *CollectGroupingContext) CollectSelector(i int) ICollectSelectorContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*ICollectSelectorContext)(nil)).Elem(), i) if t == nil { return nil } return t.(ICollectSelectorContext) } func (s *CollectGroupingContext) AllComma() []antlr.TerminalNode { return s.GetTokens(FqlParserComma) } func (s *CollectGroupingContext) Comma(i int) antlr.TerminalNode { return s.GetToken(FqlParserComma, i) } func (s *CollectGroupingContext) GetRuleContext() antlr.RuleContext { return s } func (s *CollectGroupingContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *CollectGroupingContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.EnterCollectGrouping(s) } } func (s *CollectGroupingContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.ExitCollectGrouping(s) } } func (s *CollectGroupingContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case FqlParserVisitor: return t.VisitCollectGrouping(s) default: return t.VisitChildren(s) } } func (p *FqlParser) CollectGrouping() (localctx ICollectGroupingContext) { localctx = NewCollectGroupingContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 46, FqlParserRULE_collectGrouping) var _la int defer func() { p.ExitRule() }() defer func() { if err := recover(); err != nil { if v, ok := err.(antlr.RecognitionException); ok { localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) } else { panic(err) } } }() p.EnterOuterAlt(localctx, 1) { p.SetState(312) p.CollectSelector() } p.SetState(317) p.GetErrorHandler().Sync(p) _la = p.GetTokenStream().LA(1) for _la == FqlParserComma { { p.SetState(313) p.Match(FqlParserComma) } { p.SetState(314) p.CollectSelector() } p.SetState(319) p.GetErrorHandler().Sync(p) _la = p.GetTokenStream().LA(1) } return localctx } // ICollectAggregatorContext is an interface to support dynamic dispatch. type ICollectAggregatorContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // IsCollectAggregatorContext differentiates from other interfaces. IsCollectAggregatorContext() } type CollectAggregatorContext struct { *antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCollectAggregatorContext() *CollectAggregatorContext { var p = new(CollectAggregatorContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) p.RuleIndex = FqlParserRULE_collectAggregator return p } func (*CollectAggregatorContext) IsCollectAggregatorContext() {} func NewCollectAggregatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CollectAggregatorContext { var p = new(CollectAggregatorContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) p.parser = parser p.RuleIndex = FqlParserRULE_collectAggregator return p } func (s *CollectAggregatorContext) GetParser() antlr.Parser { return s.parser } func (s *CollectAggregatorContext) Aggregate() antlr.TerminalNode { return s.GetToken(FqlParserAggregate, 0) } func (s *CollectAggregatorContext) AllCollectAggregateSelector() []ICollectAggregateSelectorContext { var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ICollectAggregateSelectorContext)(nil)).Elem()) var tst = make([]ICollectAggregateSelectorContext, len(ts)) for i, t := range ts { if t != nil { tst[i] = t.(ICollectAggregateSelectorContext) } } return tst } func (s *CollectAggregatorContext) CollectAggregateSelector(i int) ICollectAggregateSelectorContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*ICollectAggregateSelectorContext)(nil)).Elem(), i) if t == nil { return nil } return t.(ICollectAggregateSelectorContext) } func (s *CollectAggregatorContext) AllComma() []antlr.TerminalNode { return s.GetTokens(FqlParserComma) } func (s *CollectAggregatorContext) Comma(i int) antlr.TerminalNode { return s.GetToken(FqlParserComma, i) } func (s *CollectAggregatorContext) GetRuleContext() antlr.RuleContext { return s } func (s *CollectAggregatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *CollectAggregatorContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.EnterCollectAggregator(s) } } func (s *CollectAggregatorContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.ExitCollectAggregator(s) } } func (s *CollectAggregatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case FqlParserVisitor: return t.VisitCollectAggregator(s) default: return t.VisitChildren(s) } } func (p *FqlParser) CollectAggregator() (localctx ICollectAggregatorContext) { localctx = NewCollectAggregatorContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 48, FqlParserRULE_collectAggregator) var _la int defer func() { p.ExitRule() }() defer func() { if err := recover(); err != nil { if v, ok := err.(antlr.RecognitionException); ok { localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) } else { panic(err) } } }() p.EnterOuterAlt(localctx, 1) { p.SetState(320) p.Match(FqlParserAggregate) } { p.SetState(321) p.CollectAggregateSelector() } p.SetState(326) p.GetErrorHandler().Sync(p) _la = p.GetTokenStream().LA(1) for _la == FqlParserComma { { p.SetState(322) p.Match(FqlParserComma) } { p.SetState(323) p.CollectAggregateSelector() } p.SetState(328) p.GetErrorHandler().Sync(p) _la = p.GetTokenStream().LA(1) } return localctx } // ICollectAggregateSelectorContext is an interface to support dynamic dispatch. type ICollectAggregateSelectorContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // IsCollectAggregateSelectorContext differentiates from other interfaces. IsCollectAggregateSelectorContext() } type CollectAggregateSelectorContext struct { *antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCollectAggregateSelectorContext() *CollectAggregateSelectorContext { var p = new(CollectAggregateSelectorContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) p.RuleIndex = FqlParserRULE_collectAggregateSelector return p } func (*CollectAggregateSelectorContext) IsCollectAggregateSelectorContext() {} func NewCollectAggregateSelectorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CollectAggregateSelectorContext { var p = new(CollectAggregateSelectorContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) p.parser = parser p.RuleIndex = FqlParserRULE_collectAggregateSelector return p } func (s *CollectAggregateSelectorContext) GetParser() antlr.Parser { return s.parser } func (s *CollectAggregateSelectorContext) Identifier() antlr.TerminalNode { return s.GetToken(FqlParserIdentifier, 0) } func (s *CollectAggregateSelectorContext) Assign() antlr.TerminalNode { return s.GetToken(FqlParserAssign, 0) } func (s *CollectAggregateSelectorContext) FunctionCallExpression() IFunctionCallExpressionContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IFunctionCallExpressionContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(IFunctionCallExpressionContext) } func (s *CollectAggregateSelectorContext) GetRuleContext() antlr.RuleContext { return s } func (s *CollectAggregateSelectorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *CollectAggregateSelectorContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.EnterCollectAggregateSelector(s) } } func (s *CollectAggregateSelectorContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.ExitCollectAggregateSelector(s) } } func (s *CollectAggregateSelectorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case FqlParserVisitor: return t.VisitCollectAggregateSelector(s) default: return t.VisitChildren(s) } } func (p *FqlParser) CollectAggregateSelector() (localctx ICollectAggregateSelectorContext) { localctx = NewCollectAggregateSelectorContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 50, FqlParserRULE_collectAggregateSelector) defer func() { p.ExitRule() }() defer func() { if err := recover(); err != nil { if v, ok := err.(antlr.RecognitionException); ok { localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) } else { panic(err) } } }() p.EnterOuterAlt(localctx, 1) { p.SetState(329) p.Match(FqlParserIdentifier) } { p.SetState(330) p.Match(FqlParserAssign) } { p.SetState(331) p.FunctionCallExpression() } return localctx } // ICollectGroupVariableContext is an interface to support dynamic dispatch. type ICollectGroupVariableContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // IsCollectGroupVariableContext differentiates from other interfaces. IsCollectGroupVariableContext() } type CollectGroupVariableContext struct { *antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCollectGroupVariableContext() *CollectGroupVariableContext { var p = new(CollectGroupVariableContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) p.RuleIndex = FqlParserRULE_collectGroupVariable return p } func (*CollectGroupVariableContext) IsCollectGroupVariableContext() {} func NewCollectGroupVariableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CollectGroupVariableContext { var p = new(CollectGroupVariableContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) p.parser = parser p.RuleIndex = FqlParserRULE_collectGroupVariable return p } func (s *CollectGroupVariableContext) GetParser() antlr.Parser { return s.parser } func (s *CollectGroupVariableContext) Into() antlr.TerminalNode { return s.GetToken(FqlParserInto, 0) } func (s *CollectGroupVariableContext) CollectSelector() ICollectSelectorContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*ICollectSelectorContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(ICollectSelectorContext) } func (s *CollectGroupVariableContext) AllIdentifier() []antlr.TerminalNode { return s.GetTokens(FqlParserIdentifier) } func (s *CollectGroupVariableContext) Identifier(i int) antlr.TerminalNode { return s.GetToken(FqlParserIdentifier, i) } func (s *CollectGroupVariableContext) Keep() antlr.TerminalNode { return s.GetToken(FqlParserKeep, 0) } func (s *CollectGroupVariableContext) GetRuleContext() antlr.RuleContext { return s } func (s *CollectGroupVariableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *CollectGroupVariableContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.EnterCollectGroupVariable(s) } } func (s *CollectGroupVariableContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.ExitCollectGroupVariable(s) } } func (s *CollectGroupVariableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case FqlParserVisitor: return t.VisitCollectGroupVariable(s) default: return t.VisitChildren(s) } } func (p *FqlParser) CollectGroupVariable() (localctx ICollectGroupVariableContext) { localctx = NewCollectGroupVariableContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 52, FqlParserRULE_collectGroupVariable) defer func() { p.ExitRule() }() defer func() { if err := recover(); err != nil { if v, ok := err.(antlr.RecognitionException); ok { localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) } else { panic(err) } } }() p.SetState(341) p.GetErrorHandler().Sync(p) switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 28, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(333) p.Match(FqlParserInto) } { p.SetState(334) p.CollectSelector() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(335) p.Match(FqlParserInto) } { p.SetState(336) p.Match(FqlParserIdentifier) } p.SetState(339) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 27, p.GetParserRuleContext()) == 1 { { p.SetState(337) p.Match(FqlParserKeep) } { p.SetState(338) p.Match(FqlParserIdentifier) } } } return localctx } // ICollectCounterContext is an interface to support dynamic dispatch. type ICollectCounterContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // IsCollectCounterContext differentiates from other interfaces. IsCollectCounterContext() } type CollectCounterContext struct { *antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCollectCounterContext() *CollectCounterContext { var p = new(CollectCounterContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) p.RuleIndex = FqlParserRULE_collectCounter return p } func (*CollectCounterContext) IsCollectCounterContext() {} func NewCollectCounterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CollectCounterContext { var p = new(CollectCounterContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) p.parser = parser p.RuleIndex = FqlParserRULE_collectCounter return p } func (s *CollectCounterContext) GetParser() antlr.Parser { return s.parser } func (s *CollectCounterContext) With() antlr.TerminalNode { return s.GetToken(FqlParserWith, 0) } func (s *CollectCounterContext) Count() antlr.TerminalNode { return s.GetToken(FqlParserCount, 0) } func (s *CollectCounterContext) Into() antlr.TerminalNode { return s.GetToken(FqlParserInto, 0) } func (s *CollectCounterContext) Identifier() antlr.TerminalNode { return s.GetToken(FqlParserIdentifier, 0) } func (s *CollectCounterContext) GetRuleContext() antlr.RuleContext { return s } func (s *CollectCounterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *CollectCounterContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.EnterCollectCounter(s) } } func (s *CollectCounterContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.ExitCollectCounter(s) } } func (s *CollectCounterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case FqlParserVisitor: return t.VisitCollectCounter(s) default: return t.VisitChildren(s) } } func (p *FqlParser) CollectCounter() (localctx ICollectCounterContext) { localctx = NewCollectCounterContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 54, FqlParserRULE_collectCounter) defer func() { p.ExitRule() }() defer func() { if err := recover(); err != nil { if v, ok := err.(antlr.RecognitionException); ok { localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) } else { panic(err) } } }() p.EnterOuterAlt(localctx, 1) { p.SetState(343) p.Match(FqlParserWith) } { p.SetState(344) p.Match(FqlParserCount) } { p.SetState(345) p.Match(FqlParserInto) } { p.SetState(346) p.Match(FqlParserIdentifier) } return localctx } // IOptionsClauseContext is an interface to support dynamic dispatch. type IOptionsClauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // IsOptionsClauseContext differentiates from other interfaces. IsOptionsClauseContext() } type OptionsClauseContext struct { *antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOptionsClauseContext() *OptionsClauseContext { var p = new(OptionsClauseContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) p.RuleIndex = FqlParserRULE_optionsClause return p } func (*OptionsClauseContext) IsOptionsClauseContext() {} func NewOptionsClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptionsClauseContext { var p = new(OptionsClauseContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) p.parser = parser p.RuleIndex = FqlParserRULE_optionsClause return p } func (s *OptionsClauseContext) GetParser() antlr.Parser { return s.parser } func (s *OptionsClauseContext) Options() antlr.TerminalNode { return s.GetToken(FqlParserOptions, 0) } func (s *OptionsClauseContext) ObjectLiteral() IObjectLiteralContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IObjectLiteralContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(IObjectLiteralContext) } func (s *OptionsClauseContext) Variable() IVariableContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IVariableContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(IVariableContext) } func (s *OptionsClauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *OptionsClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *OptionsClauseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.EnterOptionsClause(s) } } func (s *OptionsClauseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.ExitOptionsClause(s) } } func (s *OptionsClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case FqlParserVisitor: return t.VisitOptionsClause(s) default: return t.VisitChildren(s) } } func (p *FqlParser) OptionsClause() (localctx IOptionsClauseContext) { localctx = NewOptionsClauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 56, FqlParserRULE_optionsClause) defer func() { p.ExitRule() }() defer func() { if err := recover(); err != nil { if v, ok := err.(antlr.RecognitionException); ok { localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) } else { panic(err) } } }() p.SetState(352) p.GetErrorHandler().Sync(p) switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 29, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(348) p.Match(FqlParserOptions) } { p.SetState(349) p.ObjectLiteral() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(350) p.Match(FqlParserOptions) } { p.SetState(351) p.Variable() } } return localctx } // IWaitForExpressionContext is an interface to support dynamic dispatch. type IWaitForExpressionContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // IsWaitForExpressionContext differentiates from other interfaces. IsWaitForExpressionContext() } type WaitForExpressionContext struct { *antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyWaitForExpressionContext() *WaitForExpressionContext { var p = new(WaitForExpressionContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) p.RuleIndex = FqlParserRULE_waitForExpression return p } func (*WaitForExpressionContext) IsWaitForExpressionContext() {} func NewWaitForExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WaitForExpressionContext { var p = new(WaitForExpressionContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) p.parser = parser p.RuleIndex = FqlParserRULE_waitForExpression return p } func (s *WaitForExpressionContext) GetParser() antlr.Parser { return s.parser } func (s *WaitForExpressionContext) Waitfor() antlr.TerminalNode { return s.GetToken(FqlParserWaitfor, 0) } func (s *WaitForExpressionContext) Event() antlr.TerminalNode { return s.GetToken(FqlParserEvent, 0) } func (s *WaitForExpressionContext) WaitForEventName() IWaitForEventNameContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IWaitForEventNameContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(IWaitForEventNameContext) } func (s *WaitForExpressionContext) In() antlr.TerminalNode { return s.GetToken(FqlParserIn, 0) } func (s *WaitForExpressionContext) WaitForEventSource() IWaitForEventSourceContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IWaitForEventSourceContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(IWaitForEventSourceContext) } func (s *WaitForExpressionContext) OptionsClause() IOptionsClauseContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IOptionsClauseContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(IOptionsClauseContext) } func (s *WaitForExpressionContext) WaitForTimeout() IWaitForTimeoutContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IWaitForTimeoutContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(IWaitForTimeoutContext) } func (s *WaitForExpressionContext) GetRuleContext() antlr.RuleContext { return s } func (s *WaitForExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *WaitForExpressionContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.EnterWaitForExpression(s) } } func (s *WaitForExpressionContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.ExitWaitForExpression(s) } } func (s *WaitForExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case FqlParserVisitor: return t.VisitWaitForExpression(s) default: return t.VisitChildren(s) } } func (p *FqlParser) WaitForExpression() (localctx IWaitForExpressionContext) { localctx = NewWaitForExpressionContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 58, FqlParserRULE_waitForExpression) var _la int defer func() { p.ExitRule() }() defer func() { if err := recover(); err != nil { if v, ok := err.(antlr.RecognitionException); ok { localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) } else { panic(err) } } }() p.EnterOuterAlt(localctx, 1) { p.SetState(354) p.Match(FqlParserWaitfor) } { p.SetState(355) p.Match(FqlParserEvent) } { p.SetState(356) p.WaitForEventName() } { p.SetState(357) p.Match(FqlParserIn) } { p.SetState(358) p.WaitForEventSource() } p.SetState(360) p.GetErrorHandler().Sync(p) _la = p.GetTokenStream().LA(1) if _la == FqlParserOptions { { p.SetState(359) p.OptionsClause() } } p.SetState(363) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 31, p.GetParserRuleContext()) == 1 { { p.SetState(362) p.WaitForTimeout() } } return localctx } // IWaitForTimeoutContext is an interface to support dynamic dispatch. type IWaitForTimeoutContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // IsWaitForTimeoutContext differentiates from other interfaces. IsWaitForTimeoutContext() } type WaitForTimeoutContext struct { *antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyWaitForTimeoutContext() *WaitForTimeoutContext { var p = new(WaitForTimeoutContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) p.RuleIndex = FqlParserRULE_waitForTimeout return p } func (*WaitForTimeoutContext) IsWaitForTimeoutContext() {} func NewWaitForTimeoutContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WaitForTimeoutContext { var p = new(WaitForTimeoutContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) p.parser = parser p.RuleIndex = FqlParserRULE_waitForTimeout return p } func (s *WaitForTimeoutContext) GetParser() antlr.Parser { return s.parser } func (s *WaitForTimeoutContext) IntegerLiteral() IIntegerLiteralContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IIntegerLiteralContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(IIntegerLiteralContext) } func (s *WaitForTimeoutContext) Variable() IVariableContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IVariableContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(IVariableContext) } func (s *WaitForTimeoutContext) Param() IParamContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IParamContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(IParamContext) } func (s *WaitForTimeoutContext) GetRuleContext() antlr.RuleContext { return s } func (s *WaitForTimeoutContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *WaitForTimeoutContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.EnterWaitForTimeout(s) } } func (s *WaitForTimeoutContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.ExitWaitForTimeout(s) } } func (s *WaitForTimeoutContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case FqlParserVisitor: return t.VisitWaitForTimeout(s) default: return t.VisitChildren(s) } } func (p *FqlParser) WaitForTimeout() (localctx IWaitForTimeoutContext) { localctx = NewWaitForTimeoutContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 60, FqlParserRULE_waitForTimeout) defer func() { p.ExitRule() }() defer func() { if err := recover(); err != nil { if v, ok := err.(antlr.RecognitionException); ok { localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) } else { panic(err) } } }() p.SetState(368) p.GetErrorHandler().Sync(p) switch p.GetTokenStream().LA(1) { case FqlParserIntegerLiteral: p.EnterOuterAlt(localctx, 1) { p.SetState(365) p.IntegerLiteral() } case FqlParserIdentifier: p.EnterOuterAlt(localctx, 2) { p.SetState(366) p.Variable() } case FqlParserParam: p.EnterOuterAlt(localctx, 3) { p.SetState(367) p.Param() } default: panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) } return localctx } // IWaitForEventNameContext is an interface to support dynamic dispatch. type IWaitForEventNameContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // IsWaitForEventNameContext differentiates from other interfaces. IsWaitForEventNameContext() } type WaitForEventNameContext struct { *antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyWaitForEventNameContext() *WaitForEventNameContext { var p = new(WaitForEventNameContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) p.RuleIndex = FqlParserRULE_waitForEventName return p } func (*WaitForEventNameContext) IsWaitForEventNameContext() {} func NewWaitForEventNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WaitForEventNameContext { var p = new(WaitForEventNameContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) p.parser = parser p.RuleIndex = FqlParserRULE_waitForEventName return p } func (s *WaitForEventNameContext) GetParser() antlr.Parser { return s.parser } func (s *WaitForEventNameContext) StringLiteral() IStringLiteralContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IStringLiteralContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(IStringLiteralContext) } func (s *WaitForEventNameContext) Variable() IVariableContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IVariableContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(IVariableContext) } func (s *WaitForEventNameContext) Param() IParamContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IParamContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(IParamContext) } func (s *WaitForEventNameContext) FunctionCallExpression() IFunctionCallExpressionContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IFunctionCallExpressionContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(IFunctionCallExpressionContext) } func (s *WaitForEventNameContext) MemberExpression() IMemberExpressionContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IMemberExpressionContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(IMemberExpressionContext) } func (s *WaitForEventNameContext) GetRuleContext() antlr.RuleContext { return s } func (s *WaitForEventNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *WaitForEventNameContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.EnterWaitForEventName(s) } } func (s *WaitForEventNameContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.ExitWaitForEventName(s) } } func (s *WaitForEventNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case FqlParserVisitor: return t.VisitWaitForEventName(s) default: return t.VisitChildren(s) } } func (p *FqlParser) WaitForEventName() (localctx IWaitForEventNameContext) { localctx = NewWaitForEventNameContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 62, FqlParserRULE_waitForEventName) defer func() { p.ExitRule() }() defer func() { if err := recover(); err != nil { if v, ok := err.(antlr.RecognitionException); ok { localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) } else { panic(err) } } }() p.SetState(375) p.GetErrorHandler().Sync(p) switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 33, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(370) p.StringLiteral() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(371) p.Variable() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(372) p.Param() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(373) p.FunctionCallExpression() } case 5: p.EnterOuterAlt(localctx, 5) { p.SetState(374) p.MemberExpression() } } return localctx } // IWaitForEventSourceContext is an interface to support dynamic dispatch. type IWaitForEventSourceContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // IsWaitForEventSourceContext differentiates from other interfaces. IsWaitForEventSourceContext() } type WaitForEventSourceContext struct { *antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyWaitForEventSourceContext() *WaitForEventSourceContext { var p = new(WaitForEventSourceContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) p.RuleIndex = FqlParserRULE_waitForEventSource return p } func (*WaitForEventSourceContext) IsWaitForEventSourceContext() {} func NewWaitForEventSourceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WaitForEventSourceContext { var p = new(WaitForEventSourceContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) p.parser = parser p.RuleIndex = FqlParserRULE_waitForEventSource return p } func (s *WaitForEventSourceContext) GetParser() antlr.Parser { return s.parser } func (s *WaitForEventSourceContext) FunctionCallExpression() IFunctionCallExpressionContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IFunctionCallExpressionContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(IFunctionCallExpressionContext) } func (s *WaitForEventSourceContext) Variable() IVariableContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IVariableContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(IVariableContext) } func (s *WaitForEventSourceContext) MemberExpression() IMemberExpressionContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IMemberExpressionContext)(nil)).Elem(), 0) if t == nil { return nil } return t.(IMemberExpressionContext) } func (s *WaitForEventSourceContext) GetRuleContext() antlr.RuleContext { return s } func (s *WaitForEventSourceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *WaitForEventSourceContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.EnterWaitForEventSource(s) } } func (s *WaitForEventSourceContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.ExitWaitForEventSource(s) } } func (s *WaitForEventSourceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case FqlParserVisitor: return t.VisitWaitForEventSource(s) default: return t.VisitChildren(s) } } func (p *FqlParser) WaitForEventSource() (localctx IWaitForEventSourceContext) { localctx = NewWaitForEventSourceContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 64, FqlParserRULE_waitForEventSource) defer func() { p.ExitRule() }() defer func() { if err := recover(); err != nil { if v, ok := err.(antlr.RecognitionException); ok { localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) } else { panic(err) } } }() p.SetState(380) p.GetErrorHandler().Sync(p) switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 34, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(377) p.FunctionCallExpression() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(378) p.Variable() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(379) p.MemberExpression() } } return localctx } // IRangeOperatorContext is an interface to support dynamic dispatch. type IRangeOperatorContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // IsRangeOperatorContext differentiates from other interfaces. IsRangeOperatorContext() } type RangeOperatorContext struct { *antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyRangeOperatorContext() *RangeOperatorContext { var p = new(RangeOperatorContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) p.RuleIndex = FqlParserRULE_rangeOperator return p } func (*RangeOperatorContext) IsRangeOperatorContext() {} func NewRangeOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RangeOperatorContext { var p = new(RangeOperatorContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) p.parser = parser p.RuleIndex = FqlParserRULE_rangeOperator return p } func (s *RangeOperatorContext) GetParser() antlr.Parser { return s.parser } func (s *RangeOperatorContext) Range() antlr.TerminalNode { return s.GetToken(FqlParserRange, 0) } func (s *RangeOperatorContext) AllIntegerLiteral() []IIntegerLiteralContext { var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IIntegerLiteralContext)(nil)).Elem()) var tst = make([]IIntegerLiteralContext, len(ts)) for i, t := range ts { if t != nil { tst[i] = t.(IIntegerLiteralContext) } } return tst } func (s *RangeOperatorContext) IntegerLiteral(i int) IIntegerLiteralContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IIntegerLiteralContext)(nil)).Elem(), i) if t == nil { return nil } return t.(IIntegerLiteralContext) } func (s *RangeOperatorContext) AllVariable() []IVariableContext { var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IVariableContext)(nil)).Elem()) var tst = make([]IVariableContext, len(ts)) for i, t := range ts { if t != nil { tst[i] = t.(IVariableContext) } } return tst } func (s *RangeOperatorContext) Variable(i int) IVariableContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IVariableContext)(nil)).Elem(), i) if t == nil { return nil } return t.(IVariableContext) } func (s *RangeOperatorContext) AllParam() []IParamContext { var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IParamContext)(nil)).Elem()) var tst = make([]IParamContext, len(ts)) for i, t := range ts { if t != nil { tst[i] = t.(IParamContext) } } return tst } func (s *RangeOperatorContext) Param(i int) IParamContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IParamContext)(nil)).Elem(), i) if t == nil { return nil } return t.(IParamContext) } func (s *RangeOperatorContext) GetRuleContext() antlr.RuleContext { return s } func (s *RangeOperatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *RangeOperatorContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.EnterRangeOperator(s) } } func (s *RangeOperatorContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.ExitRangeOperator(s) } } func (s *RangeOperatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case FqlParserVisitor: return t.VisitRangeOperator(s) default: return t.VisitChildren(s) } } func (p *FqlParser) RangeOperator() (localctx IRangeOperatorContext) { localctx = NewRangeOperatorContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 66, FqlParserRULE_rangeOperator) defer func() { p.ExitRule() }() defer func() { if err := recover(); err != nil { if v, ok := err.(antlr.RecognitionException); ok { localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) } else { panic(err) } } }() p.EnterOuterAlt(localctx, 1) p.SetState(385) p.GetErrorHandler().Sync(p) switch p.GetTokenStream().LA(1) { case FqlParserIntegerLiteral: { p.SetState(382) p.IntegerLiteral() } case FqlParserIdentifier: { p.SetState(383) p.Variable() } case FqlParserParam: { p.SetState(384) p.Param() } default: panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) } { p.SetState(387) p.Match(FqlParserRange) } p.SetState(391) p.GetErrorHandler().Sync(p) switch p.GetTokenStream().LA(1) { case FqlParserIntegerLiteral: { p.SetState(388) p.IntegerLiteral() } case FqlParserIdentifier: { p.SetState(389) p.Variable() } case FqlParserParam: { p.SetState(390) p.Param() } default: panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) } return localctx } // IArrayLiteralContext is an interface to support dynamic dispatch. type IArrayLiteralContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // IsArrayLiteralContext differentiates from other interfaces. IsArrayLiteralContext() } type ArrayLiteralContext struct { *antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyArrayLiteralContext() *ArrayLiteralContext { var p = new(ArrayLiteralContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) p.RuleIndex = FqlParserRULE_arrayLiteral return p } func (*ArrayLiteralContext) IsArrayLiteralContext() {} func NewArrayLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArrayLiteralContext { var p = new(ArrayLiteralContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) p.parser = parser p.RuleIndex = FqlParserRULE_arrayLiteral return p } func (s *ArrayLiteralContext) GetParser() antlr.Parser { return s.parser } func (s *ArrayLiteralContext) OpenBracket() antlr.TerminalNode { return s.GetToken(FqlParserOpenBracket, 0) } func (s *ArrayLiteralContext) CloseBracket() antlr.TerminalNode { return s.GetToken(FqlParserCloseBracket, 0) } func (s *ArrayLiteralContext) AllExpression() []IExpressionContext { var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IExpressionContext)(nil)).Elem()) var tst = make([]IExpressionContext, len(ts)) for i, t := range ts { if t != nil { tst[i] = t.(IExpressionContext) } } return tst } func (s *ArrayLiteralContext) Expression(i int) IExpressionContext { var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), i) if t == nil { return nil } return t.(IExpressionContext) } func (s *ArrayLiteralContext) AllComma() []antlr.TerminalNode { return s.GetTokens(FqlParserComma) } func (s *ArrayLiteralContext) Comma(i int) antlr.TerminalNode { return s.GetToken(FqlParserComma, i) } func (s *ArrayLiteralContext) GetRuleContext() antlr.RuleContext { return s } func (s *ArrayLiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *ArrayLiteralContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.EnterArrayLiteral(s) } } func (s *ArrayLiteralContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(FqlParserListener); ok { listenerT.ExitArrayLiteral(s) } } func (s *ArrayLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case FqlParserVisitor: return t.VisitArrayLiteral(s) default: return t.VisitChildren(s) } } func (p *FqlParser) ArrayLiteral() (localctx IArrayLiteralContext) { localctx = NewArrayLiteralContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 68, FqlParserRULE_arrayLiteral) var _la int defer func() { p.ExitRule() }() defer func() { if err := recover(); err != nil { if v, ok := err.(antlr.RecognitionException); ok { localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) } else { panic(err) } } }() var _alt int p.EnterOuterAlt(localctx, 1) { p.SetState(393) p.Match(FqlParserOpenBracket) } p.SetState(405) p.GetErrorHandler().Sync(p) _la = p.GetTokenStream().LA(1) if (((_la-9)&-(0x1f+1)) == 0 && ((1<