1# This file was generated from metar_parser.peg 2# See http://canopy.jcoglan.com/ for documentation. 3 4from collections import defaultdict 5import re 6 7 8class TreeNode(object): 9 def __init__(self, text, offset, elements): 10 self.text = text 11 self.offset = offset 12 self.elements = elements 13 14 def __iter__(self): 15 for el in self.elements: 16 yield el 17 18 19class TreeNode1(TreeNode): 20 def __init__(self, text, offset, elements): 21 super(TreeNode1, self).__init__(text, offset, elements) 22 self.metar = elements[0] 23 self.siteid = elements[1] 24 self.datetime = elements[2] 25 self.auto = elements[3] 26 self.wind = elements[4] 27 self.vis = elements[5] 28 self.run = elements[6] 29 self.curwx = elements[7] 30 self.skyc = elements[8] 31 self.temp_dewp = elements[9] 32 self.altim = elements[10] 33 self.remarks = elements[11] 34 self.end = elements[12] 35 36 37class TreeNode2(TreeNode): 38 def __init__(self, text, offset, elements): 39 super(TreeNode2, self).__init__(text, offset, elements) 40 self.sep = elements[0] 41 42 43class TreeNode3(TreeNode): 44 def __init__(self, text, offset, elements): 45 super(TreeNode3, self).__init__(text, offset, elements) 46 self.sep = elements[0] 47 48 49class TreeNode4(TreeNode): 50 def __init__(self, text, offset, elements): 51 super(TreeNode4, self).__init__(text, offset, elements) 52 self.wind_dir = elements[1] 53 self.wind_spd = elements[2] 54 55 56class TreeNode5(TreeNode): 57 def __init__(self, text, offset, elements): 58 super(TreeNode5, self).__init__(text, offset, elements) 59 self.sep = elements[0] 60 61 62class TreeNode6(TreeNode): 63 def __init__(self, text, offset, elements): 64 super(TreeNode6, self).__init__(text, offset, elements) 65 self.sep = elements[0] 66 67 68class TreeNode7(TreeNode): 69 def __init__(self, text, offset, elements): 70 super(TreeNode7, self).__init__(text, offset, elements) 71 self.sep = elements[0] 72 73 74class TreeNode8(TreeNode): 75 def __init__(self, text, offset, elements): 76 super(TreeNode8, self).__init__(text, offset, elements) 77 self.sep = elements[0] 78 79 80class TreeNode9(TreeNode): 81 def __init__(self, text, offset, elements): 82 super(TreeNode9, self).__init__(text, offset, elements) 83 self.sep = elements[0] 84 85 86class TreeNode10(TreeNode): 87 def __init__(self, text, offset, elements): 88 super(TreeNode10, self).__init__(text, offset, elements) 89 self.sep = elements[0] 90 91 92class TreeNode11(TreeNode): 93 def __init__(self, text, offset, elements): 94 super(TreeNode11, self).__init__(text, offset, elements) 95 self.sep = elements[0] 96 self.wx = elements[1] 97 98 99class TreeNode12(TreeNode): 100 def __init__(self, text, offset, elements): 101 super(TreeNode12, self).__init__(text, offset, elements) 102 self.sep = elements[0] 103 self.cover = elements[1] 104 105 106class TreeNode13(TreeNode): 107 def __init__(self, text, offset, elements): 108 super(TreeNode13, self).__init__(text, offset, elements) 109 self.sep = elements[0] 110 self.temp = elements[2] 111 self.dewp = elements[4] 112 113 114class ParseError(SyntaxError): 115 pass 116 117 118FAILURE = object() 119 120 121class Grammar(object): 122 REGEX_1 = re.compile('^[0-9A-Z]') 123 REGEX_2 = re.compile('^[0-9A-Z]') 124 REGEX_3 = re.compile('^[0-9A-Z]') 125 REGEX_4 = re.compile('^[0-9A-Z]') 126 REGEX_5 = re.compile('^[\\d]') 127 REGEX_6 = re.compile('^[\\d]') 128 REGEX_7 = re.compile('^[\\d]') 129 REGEX_8 = re.compile('^[\\d]') 130 REGEX_9 = re.compile('^[\\d]') 131 REGEX_10 = re.compile('^[\\d]') 132 REGEX_11 = re.compile('^[\\d]') 133 REGEX_12 = re.compile('^[\\d]') 134 REGEX_13 = re.compile('^[\\d]') 135 REGEX_14 = re.compile('^[\\d]') 136 REGEX_15 = re.compile('^[\\d]') 137 REGEX_16 = re.compile('^[\\d]') 138 REGEX_17 = re.compile('^[\\d]') 139 REGEX_18 = re.compile('^[\\d]') 140 REGEX_19 = re.compile('^[\\d]') 141 REGEX_20 = re.compile('^[\\d]') 142 REGEX_21 = re.compile('^[\\d]') 143 REGEX_22 = re.compile('^[\\d]') 144 REGEX_23 = re.compile('^[\\d]') 145 REGEX_24 = re.compile('^[\\d]') 146 REGEX_25 = re.compile('^[\\d]') 147 REGEX_26 = re.compile('^[\\d]') 148 REGEX_27 = re.compile('^[\\d]') 149 REGEX_28 = re.compile('^[\\d]') 150 REGEX_29 = re.compile('^[\\d]') 151 REGEX_30 = re.compile('^[\\d]') 152 REGEX_31 = re.compile('^[\\d]') 153 REGEX_32 = re.compile('^[\\d]') 154 REGEX_33 = re.compile('^[NSEW]') 155 REGEX_34 = re.compile('^[NSEW]') 156 REGEX_35 = re.compile('^[LRC]') 157 REGEX_36 = re.compile('^[\\d]') 158 REGEX_37 = re.compile('^[\\d]') 159 REGEX_38 = re.compile('^[LRC]') 160 REGEX_39 = re.compile('^[\\d]') 161 REGEX_40 = re.compile('^[\\d]') 162 REGEX_41 = re.compile('^[\\d]') 163 REGEX_42 = re.compile('^[\\d]') 164 REGEX_43 = re.compile('^["M" / "P"]') 165 REGEX_44 = re.compile('^[\\d]') 166 REGEX_45 = re.compile('^[\\d]') 167 REGEX_46 = re.compile('^[\\d]') 168 REGEX_47 = re.compile('^[\\d]') 169 REGEX_48 = re.compile('^[UDN]') 170 REGEX_49 = re.compile('^[-+]') 171 REGEX_50 = re.compile('^[\\d]') 172 REGEX_51 = re.compile('^[M]') 173 REGEX_52 = re.compile('^[\\d]') 174 REGEX_53 = re.compile('^[\\d]') 175 REGEX_54 = re.compile('^[M]') 176 REGEX_55 = re.compile('^[\\d]') 177 REGEX_56 = re.compile('^[\\d]') 178 REGEX_57 = re.compile('^["Q" / "A"]') 179 REGEX_58 = re.compile('^[\\d]') 180 REGEX_59 = re.compile('^[\\d]') 181 REGEX_60 = re.compile('^[\\d]') 182 REGEX_61 = re.compile('^[\\d]') 183 184 def _read_ob(self): 185 address0, index0 = FAILURE, self._offset 186 cached = self._cache['ob'].get(index0) 187 if cached: 188 self._offset = cached[1] 189 return cached[0] 190 index1, elements0 = self._offset, [] 191 address1 = FAILURE 192 address1 = self._read_metar() 193 if address1 is not FAILURE: 194 elements0.append(address1) 195 address2 = FAILURE 196 address2 = self._read_siteid() 197 if address2 is not FAILURE: 198 elements0.append(address2) 199 address3 = FAILURE 200 address3 = self._read_datetime() 201 if address3 is not FAILURE: 202 elements0.append(address3) 203 address4 = FAILURE 204 address4 = self._read_auto() 205 if address4 is not FAILURE: 206 elements0.append(address4) 207 address5 = FAILURE 208 address5 = self._read_wind() 209 if address5 is not FAILURE: 210 elements0.append(address5) 211 address6 = FAILURE 212 address6 = self._read_vis() 213 if address6 is not FAILURE: 214 elements0.append(address6) 215 address7 = FAILURE 216 address7 = self._read_run() 217 if address7 is not FAILURE: 218 elements0.append(address7) 219 address8 = FAILURE 220 address8 = self._read_curwx() 221 if address8 is not FAILURE: 222 elements0.append(address8) 223 address9 = FAILURE 224 address9 = self._read_skyc() 225 if address9 is not FAILURE: 226 elements0.append(address9) 227 address10 = FAILURE 228 address10 = self._read_temp_dewp() 229 if address10 is not FAILURE: 230 elements0.append(address10) 231 address11 = FAILURE 232 address11 = self._read_altim() 233 if address11 is not FAILURE: 234 elements0.append(address11) 235 address12 = FAILURE 236 address12 = self._read_remarks() 237 if address12 is not FAILURE: 238 elements0.append(address12) 239 address13 = FAILURE 240 address13 = self._read_end() 241 if address13 is not FAILURE: 242 elements0.append(address13) 243 else: 244 elements0 = None 245 self._offset = index1 246 else: 247 elements0 = None 248 self._offset = index1 249 else: 250 elements0 = None 251 self._offset = index1 252 else: 253 elements0 = None 254 self._offset = index1 255 else: 256 elements0 = None 257 self._offset = index1 258 else: 259 elements0 = None 260 self._offset = index1 261 else: 262 elements0 = None 263 self._offset = index1 264 else: 265 elements0 = None 266 self._offset = index1 267 else: 268 elements0 = None 269 self._offset = index1 270 else: 271 elements0 = None 272 self._offset = index1 273 else: 274 elements0 = None 275 self._offset = index1 276 else: 277 elements0 = None 278 self._offset = index1 279 else: 280 elements0 = None 281 self._offset = index1 282 if elements0 is None: 283 address0 = FAILURE 284 else: 285 address0 = TreeNode1(self._input[index1:self._offset], index1, elements0) 286 self._offset = self._offset 287 self._cache['ob'][index0] = (address0, self._offset) 288 return address0 289 290 def _read_metar(self): 291 address0, index0 = FAILURE, self._offset 292 cached = self._cache['metar'].get(index0) 293 if cached: 294 self._offset = cached[1] 295 return cached[0] 296 index1, elements0 = self._offset, [] 297 address1 = FAILURE 298 index2 = self._offset 299 chunk0, max0 = None, self._offset + 4 300 if max0 <= self._input_size: 301 chunk0 = self._input[self._offset:max0] 302 if chunk0 == 'COR ': 303 address1 = TreeNode(self._input[self._offset:self._offset + 4], self._offset, []) 304 self._offset = self._offset + 4 305 else: 306 address1 = FAILURE 307 if self._offset > self._failure: 308 self._failure = self._offset 309 self._expected = [] 310 if self._offset == self._failure: 311 self._expected.append('"COR "') 312 if address1 is FAILURE: 313 address1 = TreeNode(self._input[index2:index2], index2, []) 314 self._offset = index2 315 if address1 is not FAILURE: 316 elements0.append(address1) 317 address2 = FAILURE 318 index3 = self._offset 319 index4 = self._offset 320 chunk1, max1 = None, self._offset + 5 321 if max1 <= self._input_size: 322 chunk1 = self._input[self._offset:max1] 323 if chunk1 == 'METAR': 324 address2 = TreeNode(self._input[self._offset:self._offset + 5], self._offset, []) 325 self._offset = self._offset + 5 326 else: 327 address2 = FAILURE 328 if self._offset > self._failure: 329 self._failure = self._offset 330 self._expected = [] 331 if self._offset == self._failure: 332 self._expected.append('"METAR"') 333 if address2 is FAILURE: 334 self._offset = index4 335 chunk2, max2 = None, self._offset + 5 336 if max2 <= self._input_size: 337 chunk2 = self._input[self._offset:max2] 338 if chunk2 == 'SPECI': 339 address2 = TreeNode(self._input[self._offset:self._offset + 5], self._offset, []) 340 self._offset = self._offset + 5 341 else: 342 address2 = FAILURE 343 if self._offset > self._failure: 344 self._failure = self._offset 345 self._expected = [] 346 if self._offset == self._failure: 347 self._expected.append('"SPECI"') 348 if address2 is FAILURE: 349 self._offset = index4 350 if address2 is FAILURE: 351 address2 = TreeNode(self._input[index3:index3], index3, []) 352 self._offset = index3 353 if address2 is not FAILURE: 354 elements0.append(address2) 355 address3 = FAILURE 356 index5 = self._offset 357 address3 = self._read_auto() 358 if address3 is FAILURE: 359 address3 = TreeNode(self._input[index5:index5], index5, []) 360 self._offset = index5 361 if address3 is not FAILURE: 362 elements0.append(address3) 363 else: 364 elements0 = None 365 self._offset = index1 366 else: 367 elements0 = None 368 self._offset = index1 369 else: 370 elements0 = None 371 self._offset = index1 372 if elements0 is None: 373 address0 = FAILURE 374 else: 375 address0 = TreeNode(self._input[index1:self._offset], index1, elements0) 376 self._offset = self._offset 377 self._cache['metar'][index0] = (address0, self._offset) 378 return address0 379 380 def _read_sep(self): 381 address0, index0 = FAILURE, self._offset 382 cached = self._cache['sep'].get(index0) 383 if cached: 384 self._offset = cached[1] 385 return cached[0] 386 remaining0, index1, elements0, address1 = 1, self._offset, [], True 387 while address1 is not FAILURE: 388 chunk0, max0 = None, self._offset + 1 389 if max0 <= self._input_size: 390 chunk0 = self._input[self._offset:max0] 391 if chunk0 == ' ': 392 address1 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 393 self._offset = self._offset + 1 394 else: 395 address1 = FAILURE 396 if self._offset > self._failure: 397 self._failure = self._offset 398 self._expected = [] 399 if self._offset == self._failure: 400 self._expected.append('" "') 401 if address1 is not FAILURE: 402 elements0.append(address1) 403 remaining0 -= 1 404 if remaining0 <= 0: 405 address0 = TreeNode(self._input[index1:self._offset], index1, elements0) 406 self._offset = self._offset 407 else: 408 address0 = FAILURE 409 self._cache['sep'][index0] = (address0, self._offset) 410 return address0 411 412 def _read_siteid(self): 413 address0, index0 = FAILURE, self._offset 414 cached = self._cache['siteid'].get(index0) 415 if cached: 416 self._offset = cached[1] 417 return cached[0] 418 index1, elements0 = self._offset, [] 419 address1 = FAILURE 420 index2 = self._offset 421 address1 = self._read_sep() 422 if address1 is FAILURE: 423 address1 = TreeNode(self._input[index2:index2], index2, []) 424 self._offset = index2 425 if address1 is not FAILURE: 426 elements0.append(address1) 427 address2 = FAILURE 428 chunk0, max0 = None, self._offset + 1 429 if max0 <= self._input_size: 430 chunk0 = self._input[self._offset:max0] 431 if chunk0 is not None and Grammar.REGEX_1.search(chunk0): 432 address2 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 433 self._offset = self._offset + 1 434 else: 435 address2 = FAILURE 436 if self._offset > self._failure: 437 self._failure = self._offset 438 self._expected = [] 439 if self._offset == self._failure: 440 self._expected.append('[0-9A-Z]') 441 if address2 is not FAILURE: 442 elements0.append(address2) 443 address3 = FAILURE 444 chunk1, max1 = None, self._offset + 1 445 if max1 <= self._input_size: 446 chunk1 = self._input[self._offset:max1] 447 if chunk1 is not None and Grammar.REGEX_2.search(chunk1): 448 address3 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 449 self._offset = self._offset + 1 450 else: 451 address3 = FAILURE 452 if self._offset > self._failure: 453 self._failure = self._offset 454 self._expected = [] 455 if self._offset == self._failure: 456 self._expected.append('[0-9A-Z]') 457 if address3 is not FAILURE: 458 elements0.append(address3) 459 address4 = FAILURE 460 chunk2, max2 = None, self._offset + 1 461 if max2 <= self._input_size: 462 chunk2 = self._input[self._offset:max2] 463 if chunk2 is not None and Grammar.REGEX_3.search(chunk2): 464 address4 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 465 self._offset = self._offset + 1 466 else: 467 address4 = FAILURE 468 if self._offset > self._failure: 469 self._failure = self._offset 470 self._expected = [] 471 if self._offset == self._failure: 472 self._expected.append('[0-9A-Z]') 473 if address4 is not FAILURE: 474 elements0.append(address4) 475 address5 = FAILURE 476 chunk3, max3 = None, self._offset + 1 477 if max3 <= self._input_size: 478 chunk3 = self._input[self._offset:max3] 479 if chunk3 is not None and Grammar.REGEX_4.search(chunk3): 480 address5 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 481 self._offset = self._offset + 1 482 else: 483 address5 = FAILURE 484 if self._offset > self._failure: 485 self._failure = self._offset 486 self._expected = [] 487 if self._offset == self._failure: 488 self._expected.append('[0-9A-Z]') 489 if address5 is not FAILURE: 490 elements0.append(address5) 491 else: 492 elements0 = None 493 self._offset = index1 494 else: 495 elements0 = None 496 self._offset = index1 497 else: 498 elements0 = None 499 self._offset = index1 500 else: 501 elements0 = None 502 self._offset = index1 503 else: 504 elements0 = None 505 self._offset = index1 506 if elements0 is None: 507 address0 = FAILURE 508 else: 509 address0 = TreeNode(self._input[index1:self._offset], index1, elements0) 510 self._offset = self._offset 511 self._cache['siteid'][index0] = (address0, self._offset) 512 return address0 513 514 def _read_datetime(self): 515 address0, index0 = FAILURE, self._offset 516 cached = self._cache['datetime'].get(index0) 517 if cached: 518 self._offset = cached[1] 519 return cached[0] 520 index1, elements0 = self._offset, [] 521 address1 = FAILURE 522 address1 = self._read_sep() 523 if address1 is not FAILURE: 524 elements0.append(address1) 525 address2 = FAILURE 526 remaining0, index2, elements1, address3 = 1, self._offset, [], True 527 while address3 is not FAILURE: 528 chunk0, max0 = None, self._offset + 1 529 if max0 <= self._input_size: 530 chunk0 = self._input[self._offset:max0] 531 if chunk0 is not None and Grammar.REGEX_5.search(chunk0): 532 address3 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 533 self._offset = self._offset + 1 534 else: 535 address3 = FAILURE 536 if self._offset > self._failure: 537 self._failure = self._offset 538 self._expected = [] 539 if self._offset == self._failure: 540 self._expected.append('[\\d]') 541 if address3 is not FAILURE: 542 elements1.append(address3) 543 remaining0 -= 1 544 if remaining0 <= 0: 545 address2 = TreeNode(self._input[index2:self._offset], index2, elements1) 546 self._offset = self._offset 547 else: 548 address2 = FAILURE 549 if address2 is not FAILURE: 550 elements0.append(address2) 551 address4 = FAILURE 552 chunk1, max1 = None, self._offset + 1 553 if max1 <= self._input_size: 554 chunk1 = self._input[self._offset:max1] 555 if chunk1 == 'Z': 556 address4 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 557 self._offset = self._offset + 1 558 else: 559 address4 = FAILURE 560 if self._offset > self._failure: 561 self._failure = self._offset 562 self._expected = [] 563 if self._offset == self._failure: 564 self._expected.append('"Z"') 565 if address4 is not FAILURE: 566 elements0.append(address4) 567 else: 568 elements0 = None 569 self._offset = index1 570 else: 571 elements0 = None 572 self._offset = index1 573 else: 574 elements0 = None 575 self._offset = index1 576 if elements0 is None: 577 address0 = FAILURE 578 else: 579 address0 = TreeNode2(self._input[index1:self._offset], index1, elements0) 580 self._offset = self._offset 581 self._cache['datetime'][index0] = (address0, self._offset) 582 return address0 583 584 def _read_auto(self): 585 address0, index0 = FAILURE, self._offset 586 cached = self._cache['auto'].get(index0) 587 if cached: 588 self._offset = cached[1] 589 return cached[0] 590 index1 = self._offset 591 remaining0, index2, elements0, address1 = 1, self._offset, [], True 592 while address1 is not FAILURE: 593 index3, elements1 = self._offset, [] 594 address2 = FAILURE 595 address2 = self._read_sep() 596 if address2 is not FAILURE: 597 elements1.append(address2) 598 address3 = FAILURE 599 index4 = self._offset 600 chunk0, max0 = None, self._offset + 4 601 if max0 <= self._input_size: 602 chunk0 = self._input[self._offset:max0] 603 if chunk0 == 'AUTO': 604 address3 = TreeNode(self._input[self._offset:self._offset + 4], self._offset, []) 605 self._offset = self._offset + 4 606 else: 607 address3 = FAILURE 608 if self._offset > self._failure: 609 self._failure = self._offset 610 self._expected = [] 611 if self._offset == self._failure: 612 self._expected.append('"AUTO"') 613 if address3 is FAILURE: 614 self._offset = index4 615 chunk1, max1 = None, self._offset + 3 616 if max1 <= self._input_size: 617 chunk1 = self._input[self._offset:max1] 618 if chunk1 == 'COR': 619 address3 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, []) 620 self._offset = self._offset + 3 621 else: 622 address3 = FAILURE 623 if self._offset > self._failure: 624 self._failure = self._offset 625 self._expected = [] 626 if self._offset == self._failure: 627 self._expected.append('"COR"') 628 if address3 is FAILURE: 629 self._offset = index4 630 if address3 is not FAILURE: 631 elements1.append(address3) 632 else: 633 elements1 = None 634 self._offset = index3 635 else: 636 elements1 = None 637 self._offset = index3 638 if elements1 is None: 639 address1 = FAILURE 640 else: 641 address1 = TreeNode3(self._input[index3:self._offset], index3, elements1) 642 self._offset = self._offset 643 if address1 is not FAILURE: 644 elements0.append(address1) 645 remaining0 -= 1 646 if remaining0 <= 0: 647 address0 = TreeNode(self._input[index2:self._offset], index2, elements0) 648 self._offset = self._offset 649 else: 650 address0 = FAILURE 651 if address0 is FAILURE: 652 address0 = TreeNode(self._input[index1:index1], index1, []) 653 self._offset = index1 654 self._cache['auto'][index0] = (address0, self._offset) 655 return address0 656 657 def _read_wind(self): 658 address0, index0 = FAILURE, self._offset 659 cached = self._cache['wind'].get(index0) 660 if cached: 661 self._offset = cached[1] 662 return cached[0] 663 index1 = self._offset 664 index2, elements0 = self._offset, [] 665 address1 = FAILURE 666 index3 = self._offset 667 address1 = self._read_sep() 668 if address1 is FAILURE: 669 address1 = TreeNode(self._input[index3:index3], index3, []) 670 self._offset = index3 671 if address1 is not FAILURE: 672 elements0.append(address1) 673 address2 = FAILURE 674 address2 = self._read_wind_dir() 675 if address2 is not FAILURE: 676 elements0.append(address2) 677 address3 = FAILURE 678 address3 = self._read_wind_spd() 679 if address3 is not FAILURE: 680 elements0.append(address3) 681 address4 = FAILURE 682 index4 = self._offset 683 address4 = self._read_gust() 684 if address4 is FAILURE: 685 address4 = TreeNode(self._input[index4:index4], index4, []) 686 self._offset = index4 687 if address4 is not FAILURE: 688 elements0.append(address4) 689 address5 = FAILURE 690 index5 = self._offset 691 chunk0, max0 = None, self._offset + 2 692 if max0 <= self._input_size: 693 chunk0 = self._input[self._offset:max0] 694 if chunk0 == 'KT': 695 address5 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, []) 696 self._offset = self._offset + 2 697 else: 698 address5 = FAILURE 699 if self._offset > self._failure: 700 self._failure = self._offset 701 self._expected = [] 702 if self._offset == self._failure: 703 self._expected.append('"KT"') 704 if address5 is FAILURE: 705 self._offset = index5 706 chunk1, max1 = None, self._offset + 3 707 if max1 <= self._input_size: 708 chunk1 = self._input[self._offset:max1] 709 if chunk1 == 'MPS': 710 address5 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, []) 711 self._offset = self._offset + 3 712 else: 713 address5 = FAILURE 714 if self._offset > self._failure: 715 self._failure = self._offset 716 self._expected = [] 717 if self._offset == self._failure: 718 self._expected.append('"MPS"') 719 if address5 is FAILURE: 720 self._offset = index5 721 if address5 is not FAILURE: 722 elements0.append(address5) 723 address6 = FAILURE 724 index6 = self._offset 725 address6 = self._read_varwind() 726 if address6 is FAILURE: 727 address6 = TreeNode(self._input[index6:index6], index6, []) 728 self._offset = index6 729 if address6 is not FAILURE: 730 elements0.append(address6) 731 else: 732 elements0 = None 733 self._offset = index2 734 else: 735 elements0 = None 736 self._offset = index2 737 else: 738 elements0 = None 739 self._offset = index2 740 else: 741 elements0 = None 742 self._offset = index2 743 else: 744 elements0 = None 745 self._offset = index2 746 else: 747 elements0 = None 748 self._offset = index2 749 if elements0 is None: 750 address0 = FAILURE 751 else: 752 address0 = TreeNode4(self._input[index2:self._offset], index2, elements0) 753 self._offset = self._offset 754 if address0 is FAILURE: 755 address0 = TreeNode(self._input[index1:index1], index1, []) 756 self._offset = index1 757 self._cache['wind'][index0] = (address0, self._offset) 758 return address0 759 760 def _read_wind_dir(self): 761 address0, index0 = FAILURE, self._offset 762 cached = self._cache['wind_dir'].get(index0) 763 if cached: 764 self._offset = cached[1] 765 return cached[0] 766 index1 = self._offset 767 index2 = self._offset 768 index3, elements0 = self._offset, [] 769 address1 = FAILURE 770 chunk0, max0 = None, self._offset + 1 771 if max0 <= self._input_size: 772 chunk0 = self._input[self._offset:max0] 773 if chunk0 is not None and Grammar.REGEX_6.search(chunk0): 774 address1 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 775 self._offset = self._offset + 1 776 else: 777 address1 = FAILURE 778 if self._offset > self._failure: 779 self._failure = self._offset 780 self._expected = [] 781 if self._offset == self._failure: 782 self._expected.append('[\\d]') 783 if address1 is not FAILURE: 784 elements0.append(address1) 785 address2 = FAILURE 786 chunk1, max1 = None, self._offset + 1 787 if max1 <= self._input_size: 788 chunk1 = self._input[self._offset:max1] 789 if chunk1 is not None and Grammar.REGEX_7.search(chunk1): 790 address2 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 791 self._offset = self._offset + 1 792 else: 793 address2 = FAILURE 794 if self._offset > self._failure: 795 self._failure = self._offset 796 self._expected = [] 797 if self._offset == self._failure: 798 self._expected.append('[\\d]') 799 if address2 is not FAILURE: 800 elements0.append(address2) 801 address3 = FAILURE 802 chunk2, max2 = None, self._offset + 1 803 if max2 <= self._input_size: 804 chunk2 = self._input[self._offset:max2] 805 if chunk2 is not None and Grammar.REGEX_8.search(chunk2): 806 address3 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 807 self._offset = self._offset + 1 808 else: 809 address3 = FAILURE 810 if self._offset > self._failure: 811 self._failure = self._offset 812 self._expected = [] 813 if self._offset == self._failure: 814 self._expected.append('[\\d]') 815 if address3 is not FAILURE: 816 elements0.append(address3) 817 else: 818 elements0 = None 819 self._offset = index3 820 else: 821 elements0 = None 822 self._offset = index3 823 else: 824 elements0 = None 825 self._offset = index3 826 if elements0 is None: 827 address0 = FAILURE 828 else: 829 address0 = TreeNode(self._input[index3:self._offset], index3, elements0) 830 self._offset = self._offset 831 if address0 is FAILURE: 832 self._offset = index2 833 chunk3, max3 = None, self._offset + 3 834 if max3 <= self._input_size: 835 chunk3 = self._input[self._offset:max3] 836 if chunk3 == 'VAR': 837 address0 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, []) 838 self._offset = self._offset + 3 839 else: 840 address0 = FAILURE 841 if self._offset > self._failure: 842 self._failure = self._offset 843 self._expected = [] 844 if self._offset == self._failure: 845 self._expected.append('\'VAR\'') 846 if address0 is FAILURE: 847 self._offset = index2 848 chunk4, max4 = None, self._offset + 3 849 if max4 <= self._input_size: 850 chunk4 = self._input[self._offset:max4] 851 if chunk4 == 'VRB': 852 address0 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, []) 853 self._offset = self._offset + 3 854 else: 855 address0 = FAILURE 856 if self._offset > self._failure: 857 self._failure = self._offset 858 self._expected = [] 859 if self._offset == self._failure: 860 self._expected.append('\'VRB\'') 861 if address0 is FAILURE: 862 self._offset = index2 863 chunk5, max5 = None, self._offset + 3 864 if max5 <= self._input_size: 865 chunk5 = self._input[self._offset:max5] 866 if chunk5 == '///': 867 address0 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, []) 868 self._offset = self._offset + 3 869 else: 870 address0 = FAILURE 871 if self._offset > self._failure: 872 self._failure = self._offset 873 self._expected = [] 874 if self._offset == self._failure: 875 self._expected.append('"///"') 876 if address0 is FAILURE: 877 self._offset = index2 878 if address0 is FAILURE: 879 address0 = TreeNode(self._input[index1:index1], index1, []) 880 self._offset = index1 881 self._cache['wind_dir'][index0] = (address0, self._offset) 882 return address0 883 884 def _read_wind_spd(self): 885 address0, index0 = FAILURE, self._offset 886 cached = self._cache['wind_spd'].get(index0) 887 if cached: 888 self._offset = cached[1] 889 return cached[0] 890 index1 = self._offset 891 index2 = self._offset 892 index3, elements0 = self._offset, [] 893 address1 = FAILURE 894 chunk0, max0 = None, self._offset + 1 895 if max0 <= self._input_size: 896 chunk0 = self._input[self._offset:max0] 897 if chunk0 is not None and Grammar.REGEX_9.search(chunk0): 898 address1 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 899 self._offset = self._offset + 1 900 else: 901 address1 = FAILURE 902 if self._offset > self._failure: 903 self._failure = self._offset 904 self._expected = [] 905 if self._offset == self._failure: 906 self._expected.append('[\\d]') 907 if address1 is not FAILURE: 908 elements0.append(address1) 909 address2 = FAILURE 910 chunk1, max1 = None, self._offset + 1 911 if max1 <= self._input_size: 912 chunk1 = self._input[self._offset:max1] 913 if chunk1 is not None and Grammar.REGEX_10.search(chunk1): 914 address2 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 915 self._offset = self._offset + 1 916 else: 917 address2 = FAILURE 918 if self._offset > self._failure: 919 self._failure = self._offset 920 self._expected = [] 921 if self._offset == self._failure: 922 self._expected.append('[\\d]') 923 if address2 is not FAILURE: 924 elements0.append(address2) 925 address3 = FAILURE 926 index4 = self._offset 927 chunk2, max2 = None, self._offset + 1 928 if max2 <= self._input_size: 929 chunk2 = self._input[self._offset:max2] 930 if chunk2 is not None and Grammar.REGEX_11.search(chunk2): 931 address3 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 932 self._offset = self._offset + 1 933 else: 934 address3 = FAILURE 935 if self._offset > self._failure: 936 self._failure = self._offset 937 self._expected = [] 938 if self._offset == self._failure: 939 self._expected.append('[\\d]') 940 if address3 is FAILURE: 941 address3 = TreeNode(self._input[index4:index4], index4, []) 942 self._offset = index4 943 if address3 is not FAILURE: 944 elements0.append(address3) 945 else: 946 elements0 = None 947 self._offset = index3 948 else: 949 elements0 = None 950 self._offset = index3 951 else: 952 elements0 = None 953 self._offset = index3 954 if elements0 is None: 955 address0 = FAILURE 956 else: 957 address0 = TreeNode(self._input[index3:self._offset], index3, elements0) 958 self._offset = self._offset 959 if address0 is FAILURE: 960 self._offset = index2 961 chunk3, max3 = None, self._offset + 2 962 if max3 <= self._input_size: 963 chunk3 = self._input[self._offset:max3] 964 if chunk3 == '//': 965 address0 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, []) 966 self._offset = self._offset + 2 967 else: 968 address0 = FAILURE 969 if self._offset > self._failure: 970 self._failure = self._offset 971 self._expected = [] 972 if self._offset == self._failure: 973 self._expected.append('"//"') 974 if address0 is FAILURE: 975 self._offset = index2 976 if address0 is FAILURE: 977 address0 = TreeNode(self._input[index1:index1], index1, []) 978 self._offset = index1 979 self._cache['wind_spd'][index0] = (address0, self._offset) 980 return address0 981 982 def _read_gust(self): 983 address0, index0 = FAILURE, self._offset 984 cached = self._cache['gust'].get(index0) 985 if cached: 986 self._offset = cached[1] 987 return cached[0] 988 index1, elements0 = self._offset, [] 989 address1 = FAILURE 990 chunk0, max0 = None, self._offset + 1 991 if max0 <= self._input_size: 992 chunk0 = self._input[self._offset:max0] 993 if chunk0 == 'G': 994 address1 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 995 self._offset = self._offset + 1 996 else: 997 address1 = FAILURE 998 if self._offset > self._failure: 999 self._failure = self._offset 1000 self._expected = [] 1001 if self._offset == self._failure: 1002 self._expected.append('"G"') 1003 if address1 is not FAILURE: 1004 elements0.append(address1) 1005 address2 = FAILURE 1006 remaining0, index2, elements1, address3 = 1, self._offset, [], True 1007 while address3 is not FAILURE: 1008 chunk1, max1 = None, self._offset + 1 1009 if max1 <= self._input_size: 1010 chunk1 = self._input[self._offset:max1] 1011 if chunk1 is not None and Grammar.REGEX_12.search(chunk1): 1012 address3 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 1013 self._offset = self._offset + 1 1014 else: 1015 address3 = FAILURE 1016 if self._offset > self._failure: 1017 self._failure = self._offset 1018 self._expected = [] 1019 if self._offset == self._failure: 1020 self._expected.append('[\\d]') 1021 if address3 is not FAILURE: 1022 elements1.append(address3) 1023 remaining0 -= 1 1024 if remaining0 <= 0: 1025 address2 = TreeNode(self._input[index2:self._offset], index2, elements1) 1026 self._offset = self._offset 1027 else: 1028 address2 = FAILURE 1029 if address2 is not FAILURE: 1030 elements0.append(address2) 1031 else: 1032 elements0 = None 1033 self._offset = index1 1034 else: 1035 elements0 = None 1036 self._offset = index1 1037 if elements0 is None: 1038 address0 = FAILURE 1039 else: 1040 address0 = TreeNode(self._input[index1:self._offset], index1, elements0) 1041 self._offset = self._offset 1042 self._cache['gust'][index0] = (address0, self._offset) 1043 return address0 1044 1045 def _read_varwind(self): 1046 address0, index0 = FAILURE, self._offset 1047 cached = self._cache['varwind'].get(index0) 1048 if cached: 1049 self._offset = cached[1] 1050 return cached[0] 1051 index1, elements0 = self._offset, [] 1052 address1 = FAILURE 1053 address1 = self._read_sep() 1054 if address1 is not FAILURE: 1055 elements0.append(address1) 1056 address2 = FAILURE 1057 chunk0, max0 = None, self._offset + 1 1058 if max0 <= self._input_size: 1059 chunk0 = self._input[self._offset:max0] 1060 if chunk0 is not None and Grammar.REGEX_13.search(chunk0): 1061 address2 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 1062 self._offset = self._offset + 1 1063 else: 1064 address2 = FAILURE 1065 if self._offset > self._failure: 1066 self._failure = self._offset 1067 self._expected = [] 1068 if self._offset == self._failure: 1069 self._expected.append('[\\d]') 1070 if address2 is not FAILURE: 1071 elements0.append(address2) 1072 address3 = FAILURE 1073 chunk1, max1 = None, self._offset + 1 1074 if max1 <= self._input_size: 1075 chunk1 = self._input[self._offset:max1] 1076 if chunk1 is not None and Grammar.REGEX_14.search(chunk1): 1077 address3 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 1078 self._offset = self._offset + 1 1079 else: 1080 address3 = FAILURE 1081 if self._offset > self._failure: 1082 self._failure = self._offset 1083 self._expected = [] 1084 if self._offset == self._failure: 1085 self._expected.append('[\\d]') 1086 if address3 is not FAILURE: 1087 elements0.append(address3) 1088 address4 = FAILURE 1089 chunk2, max2 = None, self._offset + 1 1090 if max2 <= self._input_size: 1091 chunk2 = self._input[self._offset:max2] 1092 if chunk2 is not None and Grammar.REGEX_15.search(chunk2): 1093 address4 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 1094 self._offset = self._offset + 1 1095 else: 1096 address4 = FAILURE 1097 if self._offset > self._failure: 1098 self._failure = self._offset 1099 self._expected = [] 1100 if self._offset == self._failure: 1101 self._expected.append('[\\d]') 1102 if address4 is not FAILURE: 1103 elements0.append(address4) 1104 address5 = FAILURE 1105 chunk3, max3 = None, self._offset + 1 1106 if max3 <= self._input_size: 1107 chunk3 = self._input[self._offset:max3] 1108 if chunk3 == 'V': 1109 address5 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 1110 self._offset = self._offset + 1 1111 else: 1112 address5 = FAILURE 1113 if self._offset > self._failure: 1114 self._failure = self._offset 1115 self._expected = [] 1116 if self._offset == self._failure: 1117 self._expected.append('"V"') 1118 if address5 is not FAILURE: 1119 elements0.append(address5) 1120 address6 = FAILURE 1121 chunk4, max4 = None, self._offset + 1 1122 if max4 <= self._input_size: 1123 chunk4 = self._input[self._offset:max4] 1124 if chunk4 is not None and Grammar.REGEX_16.search(chunk4): 1125 address6 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 1126 self._offset = self._offset + 1 1127 else: 1128 address6 = FAILURE 1129 if self._offset > self._failure: 1130 self._failure = self._offset 1131 self._expected = [] 1132 if self._offset == self._failure: 1133 self._expected.append('[\\d]') 1134 if address6 is not FAILURE: 1135 elements0.append(address6) 1136 address7 = FAILURE 1137 chunk5, max5 = None, self._offset + 1 1138 if max5 <= self._input_size: 1139 chunk5 = self._input[self._offset:max5] 1140 if chunk5 is not None and Grammar.REGEX_17.search(chunk5): 1141 address7 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 1142 self._offset = self._offset + 1 1143 else: 1144 address7 = FAILURE 1145 if self._offset > self._failure: 1146 self._failure = self._offset 1147 self._expected = [] 1148 if self._offset == self._failure: 1149 self._expected.append('[\\d]') 1150 if address7 is not FAILURE: 1151 elements0.append(address7) 1152 address8 = FAILURE 1153 chunk6, max6 = None, self._offset + 1 1154 if max6 <= self._input_size: 1155 chunk6 = self._input[self._offset:max6] 1156 if chunk6 is not None and Grammar.REGEX_18.search(chunk6): 1157 address8 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 1158 self._offset = self._offset + 1 1159 else: 1160 address8 = FAILURE 1161 if self._offset > self._failure: 1162 self._failure = self._offset 1163 self._expected = [] 1164 if self._offset == self._failure: 1165 self._expected.append('[\\d]') 1166 if address8 is not FAILURE: 1167 elements0.append(address8) 1168 else: 1169 elements0 = None 1170 self._offset = index1 1171 else: 1172 elements0 = None 1173 self._offset = index1 1174 else: 1175 elements0 = None 1176 self._offset = index1 1177 else: 1178 elements0 = None 1179 self._offset = index1 1180 else: 1181 elements0 = None 1182 self._offset = index1 1183 else: 1184 elements0 = None 1185 self._offset = index1 1186 else: 1187 elements0 = None 1188 self._offset = index1 1189 else: 1190 elements0 = None 1191 self._offset = index1 1192 if elements0 is None: 1193 address0 = FAILURE 1194 else: 1195 address0 = TreeNode5(self._input[index1:self._offset], index1, elements0) 1196 self._offset = self._offset 1197 self._cache['varwind'][index0] = (address0, self._offset) 1198 return address0 1199 1200 def _read_vis(self): 1201 address0, index0 = FAILURE, self._offset 1202 cached = self._cache['vis'].get(index0) 1203 if cached: 1204 self._offset = cached[1] 1205 return cached[0] 1206 index1 = self._offset 1207 index2, elements0 = self._offset, [] 1208 address1 = FAILURE 1209 address1 = self._read_sep() 1210 if address1 is not FAILURE: 1211 elements0.append(address1) 1212 address2 = FAILURE 1213 index3 = self._offset 1214 index4, elements1 = self._offset, [] 1215 address3 = FAILURE 1216 chunk0, max0 = None, self._offset + 1 1217 if max0 <= self._input_size: 1218 chunk0 = self._input[self._offset:max0] 1219 if chunk0 is not None and Grammar.REGEX_19.search(chunk0): 1220 address3 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 1221 self._offset = self._offset + 1 1222 else: 1223 address3 = FAILURE 1224 if self._offset > self._failure: 1225 self._failure = self._offset 1226 self._expected = [] 1227 if self._offset == self._failure: 1228 self._expected.append('[\\d]') 1229 if address3 is not FAILURE: 1230 elements1.append(address3) 1231 address4 = FAILURE 1232 chunk1, max1 = None, self._offset + 1 1233 if max1 <= self._input_size: 1234 chunk1 = self._input[self._offset:max1] 1235 if chunk1 is not None and Grammar.REGEX_20.search(chunk1): 1236 address4 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 1237 self._offset = self._offset + 1 1238 else: 1239 address4 = FAILURE 1240 if self._offset > self._failure: 1241 self._failure = self._offset 1242 self._expected = [] 1243 if self._offset == self._failure: 1244 self._expected.append('[\\d]') 1245 if address4 is not FAILURE: 1246 elements1.append(address4) 1247 address5 = FAILURE 1248 chunk2, max2 = None, self._offset + 1 1249 if max2 <= self._input_size: 1250 chunk2 = self._input[self._offset:max2] 1251 if chunk2 is not None and Grammar.REGEX_21.search(chunk2): 1252 address5 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 1253 self._offset = self._offset + 1 1254 else: 1255 address5 = FAILURE 1256 if self._offset > self._failure: 1257 self._failure = self._offset 1258 self._expected = [] 1259 if self._offset == self._failure: 1260 self._expected.append('[\\d]') 1261 if address5 is not FAILURE: 1262 elements1.append(address5) 1263 address6 = FAILURE 1264 chunk3, max3 = None, self._offset + 1 1265 if max3 <= self._input_size: 1266 chunk3 = self._input[self._offset:max3] 1267 if chunk3 is not None and Grammar.REGEX_22.search(chunk3): 1268 address6 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 1269 self._offset = self._offset + 1 1270 else: 1271 address6 = FAILURE 1272 if self._offset > self._failure: 1273 self._failure = self._offset 1274 self._expected = [] 1275 if self._offset == self._failure: 1276 self._expected.append('[\\d]') 1277 if address6 is not FAILURE: 1278 elements1.append(address6) 1279 address7 = FAILURE 1280 index5 = self._offset 1281 chunk4, max4 = None, self._offset + 3 1282 if max4 <= self._input_size: 1283 chunk4 = self._input[self._offset:max4] 1284 if chunk4 == 'NDV': 1285 address7 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, []) 1286 self._offset = self._offset + 3 1287 else: 1288 address7 = FAILURE 1289 if self._offset > self._failure: 1290 self._failure = self._offset 1291 self._expected = [] 1292 if self._offset == self._failure: 1293 self._expected.append('"NDV"') 1294 if address7 is FAILURE: 1295 address7 = TreeNode(self._input[index5:index5], index5, []) 1296 self._offset = index5 1297 if address7 is not FAILURE: 1298 elements1.append(address7) 1299 else: 1300 elements1 = None 1301 self._offset = index4 1302 else: 1303 elements1 = None 1304 self._offset = index4 1305 else: 1306 elements1 = None 1307 self._offset = index4 1308 else: 1309 elements1 = None 1310 self._offset = index4 1311 else: 1312 elements1 = None 1313 self._offset = index4 1314 if elements1 is None: 1315 address2 = FAILURE 1316 else: 1317 address2 = TreeNode(self._input[index4:self._offset], index4, elements1) 1318 self._offset = self._offset 1319 if address2 is FAILURE: 1320 self._offset = index3 1321 index6, elements2 = self._offset, [] 1322 address8 = FAILURE 1323 chunk5, max5 = None, self._offset + 1 1324 if max5 <= self._input_size: 1325 chunk5 = self._input[self._offset:max5] 1326 if chunk5 is not None and Grammar.REGEX_23.search(chunk5): 1327 address8 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 1328 self._offset = self._offset + 1 1329 else: 1330 address8 = FAILURE 1331 if self._offset > self._failure: 1332 self._failure = self._offset 1333 self._expected = [] 1334 if self._offset == self._failure: 1335 self._expected.append('[\\d]') 1336 if address8 is not FAILURE: 1337 elements2.append(address8) 1338 address9 = FAILURE 1339 index7 = self._offset 1340 index8 = self._offset 1341 chunk6, max6 = None, self._offset + 1 1342 if max6 <= self._input_size: 1343 chunk6 = self._input[self._offset:max6] 1344 if chunk6 is not None and Grammar.REGEX_24.search(chunk6): 1345 address9 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 1346 self._offset = self._offset + 1 1347 else: 1348 address9 = FAILURE 1349 if self._offset > self._failure: 1350 self._failure = self._offset 1351 self._expected = [] 1352 if self._offset == self._failure: 1353 self._expected.append('[\\d]') 1354 if address9 is FAILURE: 1355 self._offset = index8 1356 index9, elements3 = self._offset, [] 1357 address10 = FAILURE 1358 index10 = self._offset 1359 index11, elements4 = self._offset, [] 1360 address11 = FAILURE 1361 chunk7, max7 = None, self._offset + 1 1362 if max7 <= self._input_size: 1363 chunk7 = self._input[self._offset:max7] 1364 if chunk7 == ' ': 1365 address11 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 1366 self._offset = self._offset + 1 1367 else: 1368 address11 = FAILURE 1369 if self._offset > self._failure: 1370 self._failure = self._offset 1371 self._expected = [] 1372 if self._offset == self._failure: 1373 self._expected.append('" "') 1374 if address11 is not FAILURE: 1375 elements4.append(address11) 1376 address12 = FAILURE 1377 chunk8, max8 = None, self._offset + 1 1378 if max8 <= self._input_size: 1379 chunk8 = self._input[self._offset:max8] 1380 if chunk8 is not None and Grammar.REGEX_25.search(chunk8): 1381 address12 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 1382 self._offset = self._offset + 1 1383 else: 1384 address12 = FAILURE 1385 if self._offset > self._failure: 1386 self._failure = self._offset 1387 self._expected = [] 1388 if self._offset == self._failure: 1389 self._expected.append('[\\d]') 1390 if address12 is not FAILURE: 1391 elements4.append(address12) 1392 else: 1393 elements4 = None 1394 self._offset = index11 1395 else: 1396 elements4 = None 1397 self._offset = index11 1398 if elements4 is None: 1399 address10 = FAILURE 1400 else: 1401 address10 = TreeNode(self._input[index11:self._offset], index11, elements4) 1402 self._offset = self._offset 1403 if address10 is FAILURE: 1404 address10 = TreeNode(self._input[index10:index10], index10, []) 1405 self._offset = index10 1406 if address10 is not FAILURE: 1407 elements3.append(address10) 1408 address13 = FAILURE 1409 chunk9, max9 = None, self._offset + 1 1410 if max9 <= self._input_size: 1411 chunk9 = self._input[self._offset:max9] 1412 if chunk9 == '/': 1413 address13 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 1414 self._offset = self._offset + 1 1415 else: 1416 address13 = FAILURE 1417 if self._offset > self._failure: 1418 self._failure = self._offset 1419 self._expected = [] 1420 if self._offset == self._failure: 1421 self._expected.append('"/"') 1422 if address13 is not FAILURE: 1423 elements3.append(address13) 1424 address14 = FAILURE 1425 chunk10, max10 = None, self._offset + 1 1426 if max10 <= self._input_size: 1427 chunk10 = self._input[self._offset:max10] 1428 if chunk10 is not None and Grammar.REGEX_26.search(chunk10): 1429 address14 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 1430 self._offset = self._offset + 1 1431 else: 1432 address14 = FAILURE 1433 if self._offset > self._failure: 1434 self._failure = self._offset 1435 self._expected = [] 1436 if self._offset == self._failure: 1437 self._expected.append('[\\d]') 1438 if address14 is not FAILURE: 1439 elements3.append(address14) 1440 else: 1441 elements3 = None 1442 self._offset = index9 1443 else: 1444 elements3 = None 1445 self._offset = index9 1446 else: 1447 elements3 = None 1448 self._offset = index9 1449 if elements3 is None: 1450 address9 = FAILURE 1451 else: 1452 address9 = TreeNode(self._input[index9:self._offset], index9, elements3) 1453 self._offset = self._offset 1454 if address9 is FAILURE: 1455 self._offset = index8 1456 if address9 is FAILURE: 1457 address9 = TreeNode(self._input[index7:index7], index7, []) 1458 self._offset = index7 1459 if address9 is not FAILURE: 1460 elements2.append(address9) 1461 address15 = FAILURE 1462 chunk11, max11 = None, self._offset + 2 1463 if max11 <= self._input_size: 1464 chunk11 = self._input[self._offset:max11] 1465 if chunk11 == 'SM': 1466 address15 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, []) 1467 self._offset = self._offset + 2 1468 else: 1469 address15 = FAILURE 1470 if self._offset > self._failure: 1471 self._failure = self._offset 1472 self._expected = [] 1473 if self._offset == self._failure: 1474 self._expected.append('"SM"') 1475 if address15 is not FAILURE: 1476 elements2.append(address15) 1477 else: 1478 elements2 = None 1479 self._offset = index6 1480 else: 1481 elements2 = None 1482 self._offset = index6 1483 else: 1484 elements2 = None 1485 self._offset = index6 1486 if elements2 is None: 1487 address2 = FAILURE 1488 else: 1489 address2 = TreeNode(self._input[index6:self._offset], index6, elements2) 1490 self._offset = self._offset 1491 if address2 is FAILURE: 1492 self._offset = index3 1493 index12, elements5 = self._offset, [] 1494 address16 = FAILURE 1495 chunk12, max12 = None, self._offset + 1 1496 if max12 <= self._input_size: 1497 chunk12 = self._input[self._offset:max12] 1498 if chunk12 == 'M': 1499 address16 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 1500 self._offset = self._offset + 1 1501 else: 1502 address16 = FAILURE 1503 if self._offset > self._failure: 1504 self._failure = self._offset 1505 self._expected = [] 1506 if self._offset == self._failure: 1507 self._expected.append('"M"') 1508 if address16 is not FAILURE: 1509 elements5.append(address16) 1510 address17 = FAILURE 1511 chunk13, max13 = None, self._offset + 1 1512 if max13 <= self._input_size: 1513 chunk13 = self._input[self._offset:max13] 1514 if chunk13 is not None and Grammar.REGEX_27.search(chunk13): 1515 address17 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 1516 self._offset = self._offset + 1 1517 else: 1518 address17 = FAILURE 1519 if self._offset > self._failure: 1520 self._failure = self._offset 1521 self._expected = [] 1522 if self._offset == self._failure: 1523 self._expected.append('[\\d]') 1524 if address17 is not FAILURE: 1525 elements5.append(address17) 1526 address18 = FAILURE 1527 chunk14, max14 = None, self._offset + 1 1528 if max14 <= self._input_size: 1529 chunk14 = self._input[self._offset:max14] 1530 if chunk14 == '/': 1531 address18 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 1532 self._offset = self._offset + 1 1533 else: 1534 address18 = FAILURE 1535 if self._offset > self._failure: 1536 self._failure = self._offset 1537 self._expected = [] 1538 if self._offset == self._failure: 1539 self._expected.append('"/"') 1540 if address18 is not FAILURE: 1541 elements5.append(address18) 1542 address19 = FAILURE 1543 chunk15, max15 = None, self._offset + 1 1544 if max15 <= self._input_size: 1545 chunk15 = self._input[self._offset:max15] 1546 if chunk15 is not None and Grammar.REGEX_28.search(chunk15): 1547 address19 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 1548 self._offset = self._offset + 1 1549 else: 1550 address19 = FAILURE 1551 if self._offset > self._failure: 1552 self._failure = self._offset 1553 self._expected = [] 1554 if self._offset == self._failure: 1555 self._expected.append('[\\d]') 1556 if address19 is not FAILURE: 1557 elements5.append(address19) 1558 address20 = FAILURE 1559 chunk16, max16 = None, self._offset + 2 1560 if max16 <= self._input_size: 1561 chunk16 = self._input[self._offset:max16] 1562 if chunk16 == 'SM': 1563 address20 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, []) 1564 self._offset = self._offset + 2 1565 else: 1566 address20 = FAILURE 1567 if self._offset > self._failure: 1568 self._failure = self._offset 1569 self._expected = [] 1570 if self._offset == self._failure: 1571 self._expected.append('"SM"') 1572 if address20 is not FAILURE: 1573 elements5.append(address20) 1574 else: 1575 elements5 = None 1576 self._offset = index12 1577 else: 1578 elements5 = None 1579 self._offset = index12 1580 else: 1581 elements5 = None 1582 self._offset = index12 1583 else: 1584 elements5 = None 1585 self._offset = index12 1586 else: 1587 elements5 = None 1588 self._offset = index12 1589 if elements5 is None: 1590 address2 = FAILURE 1591 else: 1592 address2 = TreeNode(self._input[index12:self._offset], index12, elements5) 1593 self._offset = self._offset 1594 if address2 is FAILURE: 1595 self._offset = index3 1596 chunk17, max17 = None, self._offset + 5 1597 if max17 <= self._input_size: 1598 chunk17 = self._input[self._offset:max17] 1599 if chunk17 == 'CAVOK': 1600 address2 = TreeNode(self._input[self._offset:self._offset + 5], self._offset, []) 1601 self._offset = self._offset + 5 1602 else: 1603 address2 = FAILURE 1604 if self._offset > self._failure: 1605 self._failure = self._offset 1606 self._expected = [] 1607 if self._offset == self._failure: 1608 self._expected.append('"CAVOK"') 1609 if address2 is FAILURE: 1610 self._offset = index3 1611 chunk18, max18 = None, self._offset + 4 1612 if max18 <= self._input_size: 1613 chunk18 = self._input[self._offset:max18] 1614 if chunk18 == '////': 1615 address2 = TreeNode(self._input[self._offset:self._offset + 4], self._offset, []) 1616 self._offset = self._offset + 4 1617 else: 1618 address2 = FAILURE 1619 if self._offset > self._failure: 1620 self._failure = self._offset 1621 self._expected = [] 1622 if self._offset == self._failure: 1623 self._expected.append('"////"') 1624 if address2 is FAILURE: 1625 self._offset = index3 1626 if address2 is not FAILURE: 1627 elements0.append(address2) 1628 address21 = FAILURE 1629 index13 = self._offset 1630 address21 = self._read_varvis() 1631 if address21 is FAILURE: 1632 address21 = TreeNode(self._input[index13:index13], index13, []) 1633 self._offset = index13 1634 if address21 is not FAILURE: 1635 elements0.append(address21) 1636 else: 1637 elements0 = None 1638 self._offset = index2 1639 else: 1640 elements0 = None 1641 self._offset = index2 1642 else: 1643 elements0 = None 1644 self._offset = index2 1645 if elements0 is None: 1646 address0 = FAILURE 1647 else: 1648 address0 = TreeNode6(self._input[index2:self._offset], index2, elements0) 1649 self._offset = self._offset 1650 if address0 is FAILURE: 1651 address0 = TreeNode(self._input[index1:index1], index1, []) 1652 self._offset = index1 1653 self._cache['vis'][index0] = (address0, self._offset) 1654 return address0 1655 1656 def _read_varvis(self): 1657 address0, index0 = FAILURE, self._offset 1658 cached = self._cache['varvis'].get(index0) 1659 if cached: 1660 self._offset = cached[1] 1661 return cached[0] 1662 index1, elements0 = self._offset, [] 1663 address1 = FAILURE 1664 address1 = self._read_sep() 1665 if address1 is not FAILURE: 1666 elements0.append(address1) 1667 address2 = FAILURE 1668 chunk0, max0 = None, self._offset + 1 1669 if max0 <= self._input_size: 1670 chunk0 = self._input[self._offset:max0] 1671 if chunk0 is not None and Grammar.REGEX_29.search(chunk0): 1672 address2 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 1673 self._offset = self._offset + 1 1674 else: 1675 address2 = FAILURE 1676 if self._offset > self._failure: 1677 self._failure = self._offset 1678 self._expected = [] 1679 if self._offset == self._failure: 1680 self._expected.append('[\\d]') 1681 if address2 is not FAILURE: 1682 elements0.append(address2) 1683 address3 = FAILURE 1684 chunk1, max1 = None, self._offset + 1 1685 if max1 <= self._input_size: 1686 chunk1 = self._input[self._offset:max1] 1687 if chunk1 is not None and Grammar.REGEX_30.search(chunk1): 1688 address3 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 1689 self._offset = self._offset + 1 1690 else: 1691 address3 = FAILURE 1692 if self._offset > self._failure: 1693 self._failure = self._offset 1694 self._expected = [] 1695 if self._offset == self._failure: 1696 self._expected.append('[\\d]') 1697 if address3 is not FAILURE: 1698 elements0.append(address3) 1699 address4 = FAILURE 1700 chunk2, max2 = None, self._offset + 1 1701 if max2 <= self._input_size: 1702 chunk2 = self._input[self._offset:max2] 1703 if chunk2 is not None and Grammar.REGEX_31.search(chunk2): 1704 address4 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 1705 self._offset = self._offset + 1 1706 else: 1707 address4 = FAILURE 1708 if self._offset > self._failure: 1709 self._failure = self._offset 1710 self._expected = [] 1711 if self._offset == self._failure: 1712 self._expected.append('[\\d]') 1713 if address4 is not FAILURE: 1714 elements0.append(address4) 1715 address5 = FAILURE 1716 chunk3, max3 = None, self._offset + 1 1717 if max3 <= self._input_size: 1718 chunk3 = self._input[self._offset:max3] 1719 if chunk3 is not None and Grammar.REGEX_32.search(chunk3): 1720 address5 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 1721 self._offset = self._offset + 1 1722 else: 1723 address5 = FAILURE 1724 if self._offset > self._failure: 1725 self._failure = self._offset 1726 self._expected = [] 1727 if self._offset == self._failure: 1728 self._expected.append('[\\d]') 1729 if address5 is not FAILURE: 1730 elements0.append(address5) 1731 address6 = FAILURE 1732 index2 = self._offset 1733 chunk4, max4 = None, self._offset + 1 1734 if max4 <= self._input_size: 1735 chunk4 = self._input[self._offset:max4] 1736 if chunk4 is not None and Grammar.REGEX_33.search(chunk4): 1737 address6 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 1738 self._offset = self._offset + 1 1739 else: 1740 address6 = FAILURE 1741 if self._offset > self._failure: 1742 self._failure = self._offset 1743 self._expected = [] 1744 if self._offset == self._failure: 1745 self._expected.append('[NSEW]') 1746 if address6 is FAILURE: 1747 address6 = TreeNode(self._input[index2:index2], index2, []) 1748 self._offset = index2 1749 if address6 is not FAILURE: 1750 elements0.append(address6) 1751 address7 = FAILURE 1752 index3 = self._offset 1753 chunk5, max5 = None, self._offset + 1 1754 if max5 <= self._input_size: 1755 chunk5 = self._input[self._offset:max5] 1756 if chunk5 is not None and Grammar.REGEX_34.search(chunk5): 1757 address7 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 1758 self._offset = self._offset + 1 1759 else: 1760 address7 = FAILURE 1761 if self._offset > self._failure: 1762 self._failure = self._offset 1763 self._expected = [] 1764 if self._offset == self._failure: 1765 self._expected.append('[NSEW]') 1766 if address7 is FAILURE: 1767 address7 = TreeNode(self._input[index3:index3], index3, []) 1768 self._offset = index3 1769 if address7 is not FAILURE: 1770 elements0.append(address7) 1771 else: 1772 elements0 = None 1773 self._offset = index1 1774 else: 1775 elements0 = None 1776 self._offset = index1 1777 else: 1778 elements0 = None 1779 self._offset = index1 1780 else: 1781 elements0 = None 1782 self._offset = index1 1783 else: 1784 elements0 = None 1785 self._offset = index1 1786 else: 1787 elements0 = None 1788 self._offset = index1 1789 else: 1790 elements0 = None 1791 self._offset = index1 1792 if elements0 is None: 1793 address0 = FAILURE 1794 else: 1795 address0 = TreeNode7(self._input[index1:self._offset], index1, elements0) 1796 self._offset = self._offset 1797 self._cache['varvis'][index0] = (address0, self._offset) 1798 return address0 1799 1800 def _read_run(self): 1801 address0, index0 = FAILURE, self._offset 1802 cached = self._cache['run'].get(index0) 1803 if cached: 1804 self._offset = cached[1] 1805 return cached[0] 1806 remaining0, index1, elements0, address1 = 0, self._offset, [], True 1807 while address1 is not FAILURE: 1808 index2, elements1 = self._offset, [] 1809 address2 = FAILURE 1810 address2 = self._read_sep() 1811 if address2 is not FAILURE: 1812 elements1.append(address2) 1813 address3 = FAILURE 1814 chunk0, max0 = None, self._offset + 1 1815 if max0 <= self._input_size: 1816 chunk0 = self._input[self._offset:max0] 1817 if chunk0 == 'R': 1818 address3 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 1819 self._offset = self._offset + 1 1820 else: 1821 address3 = FAILURE 1822 if self._offset > self._failure: 1823 self._failure = self._offset 1824 self._expected = [] 1825 if self._offset == self._failure: 1826 self._expected.append('"R"') 1827 if address3 is not FAILURE: 1828 elements1.append(address3) 1829 address4 = FAILURE 1830 index3 = self._offset 1831 chunk1, max1 = None, self._offset + 1 1832 if max1 <= self._input_size: 1833 chunk1 = self._input[self._offset:max1] 1834 if chunk1 is not None and Grammar.REGEX_35.search(chunk1): 1835 address4 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 1836 self._offset = self._offset + 1 1837 else: 1838 address4 = FAILURE 1839 if self._offset > self._failure: 1840 self._failure = self._offset 1841 self._expected = [] 1842 if self._offset == self._failure: 1843 self._expected.append('[LRC]') 1844 if address4 is FAILURE: 1845 address4 = TreeNode(self._input[index3:index3], index3, []) 1846 self._offset = index3 1847 if address4 is not FAILURE: 1848 elements1.append(address4) 1849 address5 = FAILURE 1850 chunk2, max2 = None, self._offset + 1 1851 if max2 <= self._input_size: 1852 chunk2 = self._input[self._offset:max2] 1853 if chunk2 is not None and Grammar.REGEX_36.search(chunk2): 1854 address5 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 1855 self._offset = self._offset + 1 1856 else: 1857 address5 = FAILURE 1858 if self._offset > self._failure: 1859 self._failure = self._offset 1860 self._expected = [] 1861 if self._offset == self._failure: 1862 self._expected.append('[\\d]') 1863 if address5 is not FAILURE: 1864 elements1.append(address5) 1865 address6 = FAILURE 1866 chunk3, max3 = None, self._offset + 1 1867 if max3 <= self._input_size: 1868 chunk3 = self._input[self._offset:max3] 1869 if chunk3 is not None and Grammar.REGEX_37.search(chunk3): 1870 address6 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 1871 self._offset = self._offset + 1 1872 else: 1873 address6 = FAILURE 1874 if self._offset > self._failure: 1875 self._failure = self._offset 1876 self._expected = [] 1877 if self._offset == self._failure: 1878 self._expected.append('[\\d]') 1879 if address6 is not FAILURE: 1880 elements1.append(address6) 1881 address7 = FAILURE 1882 index4 = self._offset 1883 chunk4, max4 = None, self._offset + 1 1884 if max4 <= self._input_size: 1885 chunk4 = self._input[self._offset:max4] 1886 if chunk4 is not None and Grammar.REGEX_38.search(chunk4): 1887 address7 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 1888 self._offset = self._offset + 1 1889 else: 1890 address7 = FAILURE 1891 if self._offset > self._failure: 1892 self._failure = self._offset 1893 self._expected = [] 1894 if self._offset == self._failure: 1895 self._expected.append('[LRC]') 1896 if address7 is FAILURE: 1897 address7 = TreeNode(self._input[index4:index4], index4, []) 1898 self._offset = index4 1899 if address7 is not FAILURE: 1900 elements1.append(address7) 1901 address8 = FAILURE 1902 chunk5, max5 = None, self._offset + 1 1903 if max5 <= self._input_size: 1904 chunk5 = self._input[self._offset:max5] 1905 if chunk5 == '/': 1906 address8 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 1907 self._offset = self._offset + 1 1908 else: 1909 address8 = FAILURE 1910 if self._offset > self._failure: 1911 self._failure = self._offset 1912 self._expected = [] 1913 if self._offset == self._failure: 1914 self._expected.append('"/"') 1915 if address8 is not FAILURE: 1916 elements1.append(address8) 1917 address9 = FAILURE 1918 index5 = self._offset 1919 index6, elements2 = self._offset, [] 1920 address10 = FAILURE 1921 chunk6, max6 = None, self._offset + 1 1922 if max6 <= self._input_size: 1923 chunk6 = self._input[self._offset:max6] 1924 if chunk6 is not None and Grammar.REGEX_39.search(chunk6): 1925 address10 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 1926 self._offset = self._offset + 1 1927 else: 1928 address10 = FAILURE 1929 if self._offset > self._failure: 1930 self._failure = self._offset 1931 self._expected = [] 1932 if self._offset == self._failure: 1933 self._expected.append('[\\d]') 1934 if address10 is not FAILURE: 1935 elements2.append(address10) 1936 address11 = FAILURE 1937 chunk7, max7 = None, self._offset + 1 1938 if max7 <= self._input_size: 1939 chunk7 = self._input[self._offset:max7] 1940 if chunk7 is not None and Grammar.REGEX_40.search(chunk7): 1941 address11 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 1942 self._offset = self._offset + 1 1943 else: 1944 address11 = FAILURE 1945 if self._offset > self._failure: 1946 self._failure = self._offset 1947 self._expected = [] 1948 if self._offset == self._failure: 1949 self._expected.append('[\\d]') 1950 if address11 is not FAILURE: 1951 elements2.append(address11) 1952 address12 = FAILURE 1953 chunk8, max8 = None, self._offset + 1 1954 if max8 <= self._input_size: 1955 chunk8 = self._input[self._offset:max8] 1956 if chunk8 is not None and Grammar.REGEX_41.search(chunk8): 1957 address12 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 1958 self._offset = self._offset + 1 1959 else: 1960 address12 = FAILURE 1961 if self._offset > self._failure: 1962 self._failure = self._offset 1963 self._expected = [] 1964 if self._offset == self._failure: 1965 self._expected.append('[\\d]') 1966 if address12 is not FAILURE: 1967 elements2.append(address12) 1968 address13 = FAILURE 1969 chunk9, max9 = None, self._offset + 1 1970 if max9 <= self._input_size: 1971 chunk9 = self._input[self._offset:max9] 1972 if chunk9 is not None and Grammar.REGEX_42.search(chunk9): 1973 address13 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 1974 self._offset = self._offset + 1 1975 else: 1976 address13 = FAILURE 1977 if self._offset > self._failure: 1978 self._failure = self._offset 1979 self._expected = [] 1980 if self._offset == self._failure: 1981 self._expected.append('[\\d]') 1982 if address13 is not FAILURE: 1983 elements2.append(address13) 1984 address14 = FAILURE 1985 chunk10, max10 = None, self._offset + 1 1986 if max10 <= self._input_size: 1987 chunk10 = self._input[self._offset:max10] 1988 if chunk10 == 'V': 1989 address14 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 1990 self._offset = self._offset + 1 1991 else: 1992 address14 = FAILURE 1993 if self._offset > self._failure: 1994 self._failure = self._offset 1995 self._expected = [] 1996 if self._offset == self._failure: 1997 self._expected.append('"V"') 1998 if address14 is not FAILURE: 1999 elements2.append(address14) 2000 else: 2001 elements2 = None 2002 self._offset = index6 2003 else: 2004 elements2 = None 2005 self._offset = index6 2006 else: 2007 elements2 = None 2008 self._offset = index6 2009 else: 2010 elements2 = None 2011 self._offset = index6 2012 else: 2013 elements2 = None 2014 self._offset = index6 2015 if elements2 is None: 2016 address9 = FAILURE 2017 else: 2018 address9 = TreeNode(self._input[index6:self._offset], index6, elements2) 2019 self._offset = self._offset 2020 if address9 is FAILURE: 2021 address9 = TreeNode(self._input[index5:index5], index5, []) 2022 self._offset = index5 2023 if address9 is not FAILURE: 2024 elements1.append(address9) 2025 address15 = FAILURE 2026 index7 = self._offset 2027 chunk11, max11 = None, self._offset + 1 2028 if max11 <= self._input_size: 2029 chunk11 = self._input[self._offset:max11] 2030 if chunk11 is not None and Grammar.REGEX_43.search(chunk11): 2031 address15 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 2032 self._offset = self._offset + 1 2033 else: 2034 address15 = FAILURE 2035 if self._offset > self._failure: 2036 self._failure = self._offset 2037 self._expected = [] 2038 if self._offset == self._failure: 2039 self._expected.append('["M" / "P"]') 2040 if address15 is FAILURE: 2041 address15 = TreeNode(self._input[index7:index7], index7, []) 2042 self._offset = index7 2043 if address15 is not FAILURE: 2044 elements1.append(address15) 2045 address16 = FAILURE 2046 chunk12, max12 = None, self._offset + 1 2047 if max12 <= self._input_size: 2048 chunk12 = self._input[self._offset:max12] 2049 if chunk12 is not None and Grammar.REGEX_44.search(chunk12): 2050 address16 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 2051 self._offset = self._offset + 1 2052 else: 2053 address16 = FAILURE 2054 if self._offset > self._failure: 2055 self._failure = self._offset 2056 self._expected = [] 2057 if self._offset == self._failure: 2058 self._expected.append('[\\d]') 2059 if address16 is not FAILURE: 2060 elements1.append(address16) 2061 address17 = FAILURE 2062 chunk13, max13 = None, self._offset + 1 2063 if max13 <= self._input_size: 2064 chunk13 = self._input[self._offset:max13] 2065 if chunk13 is not None and Grammar.REGEX_45.search(chunk13): 2066 address17 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 2067 self._offset = self._offset + 1 2068 else: 2069 address17 = FAILURE 2070 if self._offset > self._failure: 2071 self._failure = self._offset 2072 self._expected = [] 2073 if self._offset == self._failure: 2074 self._expected.append('[\\d]') 2075 if address17 is not FAILURE: 2076 elements1.append(address17) 2077 address18 = FAILURE 2078 chunk14, max14 = None, self._offset + 1 2079 if max14 <= self._input_size: 2080 chunk14 = self._input[self._offset:max14] 2081 if chunk14 is not None and Grammar.REGEX_46.search(chunk14): 2082 address18 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 2083 self._offset = self._offset + 1 2084 else: 2085 address18 = FAILURE 2086 if self._offset > self._failure: 2087 self._failure = self._offset 2088 self._expected = [] 2089 if self._offset == self._failure: 2090 self._expected.append('[\\d]') 2091 if address18 is not FAILURE: 2092 elements1.append(address18) 2093 address19 = FAILURE 2094 chunk15, max15 = None, self._offset + 1 2095 if max15 <= self._input_size: 2096 chunk15 = self._input[self._offset:max15] 2097 if chunk15 is not None and Grammar.REGEX_47.search(chunk15): 2098 address19 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 2099 self._offset = self._offset + 1 2100 else: 2101 address19 = FAILURE 2102 if self._offset > self._failure: 2103 self._failure = self._offset 2104 self._expected = [] 2105 if self._offset == self._failure: 2106 self._expected.append('[\\d]') 2107 if address19 is not FAILURE: 2108 elements1.append(address19) 2109 address20 = FAILURE 2110 index8 = self._offset 2111 chunk16, max16 = None, self._offset + 2 2112 if max16 <= self._input_size: 2113 chunk16 = self._input[self._offset:max16] 2114 if chunk16 == 'FT': 2115 address20 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, []) 2116 self._offset = self._offset + 2 2117 else: 2118 address20 = FAILURE 2119 if self._offset > self._failure: 2120 self._failure = self._offset 2121 self._expected = [] 2122 if self._offset == self._failure: 2123 self._expected.append('"FT"') 2124 if address20 is FAILURE: 2125 address20 = TreeNode(self._input[index8:index8], index8, []) 2126 self._offset = index8 2127 if address20 is not FAILURE: 2128 elements1.append(address20) 2129 address21 = FAILURE 2130 index9 = self._offset 2131 index10, elements3 = self._offset, [] 2132 address22 = FAILURE 2133 index11 = self._offset 2134 chunk17, max17 = None, self._offset + 1 2135 if max17 <= self._input_size: 2136 chunk17 = self._input[self._offset:max17] 2137 if chunk17 == '/': 2138 address22 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 2139 self._offset = self._offset + 1 2140 else: 2141 address22 = FAILURE 2142 if self._offset > self._failure: 2143 self._failure = self._offset 2144 self._expected = [] 2145 if self._offset == self._failure: 2146 self._expected.append('"/"') 2147 if address22 is FAILURE: 2148 address22 = TreeNode(self._input[index11:index11], index11, []) 2149 self._offset = index11 2150 if address22 is not FAILURE: 2151 elements3.append(address22) 2152 address23 = FAILURE 2153 chunk18, max18 = None, self._offset + 1 2154 if max18 <= self._input_size: 2155 chunk18 = self._input[self._offset:max18] 2156 if chunk18 is not None and Grammar.REGEX_48.search(chunk18): 2157 address23 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 2158 self._offset = self._offset + 1 2159 else: 2160 address23 = FAILURE 2161 if self._offset > self._failure: 2162 self._failure = self._offset 2163 self._expected = [] 2164 if self._offset == self._failure: 2165 self._expected.append('[UDN]') 2166 if address23 is not FAILURE: 2167 elements3.append(address23) 2168 else: 2169 elements3 = None 2170 self._offset = index10 2171 else: 2172 elements3 = None 2173 self._offset = index10 2174 if elements3 is None: 2175 address21 = FAILURE 2176 else: 2177 address21 = TreeNode(self._input[index10:self._offset], index10, elements3) 2178 self._offset = self._offset 2179 if address21 is FAILURE: 2180 address21 = TreeNode(self._input[index9:index9], index9, []) 2181 self._offset = index9 2182 if address21 is not FAILURE: 2183 elements1.append(address21) 2184 else: 2185 elements1 = None 2186 self._offset = index2 2187 else: 2188 elements1 = None 2189 self._offset = index2 2190 else: 2191 elements1 = None 2192 self._offset = index2 2193 else: 2194 elements1 = None 2195 self._offset = index2 2196 else: 2197 elements1 = None 2198 self._offset = index2 2199 else: 2200 elements1 = None 2201 self._offset = index2 2202 else: 2203 elements1 = None 2204 self._offset = index2 2205 else: 2206 elements1 = None 2207 self._offset = index2 2208 else: 2209 elements1 = None 2210 self._offset = index2 2211 else: 2212 elements1 = None 2213 self._offset = index2 2214 else: 2215 elements1 = None 2216 self._offset = index2 2217 else: 2218 elements1 = None 2219 self._offset = index2 2220 else: 2221 elements1 = None 2222 self._offset = index2 2223 else: 2224 elements1 = None 2225 self._offset = index2 2226 else: 2227 elements1 = None 2228 self._offset = index2 2229 if elements1 is None: 2230 address1 = FAILURE 2231 else: 2232 address1 = TreeNode8(self._input[index2:self._offset], index2, elements1) 2233 self._offset = self._offset 2234 if address1 is not FAILURE: 2235 elements0.append(address1) 2236 remaining0 -= 1 2237 if remaining0 <= 0: 2238 address0 = TreeNode(self._input[index1:self._offset], index1, elements0) 2239 self._offset = self._offset 2240 else: 2241 address0 = FAILURE 2242 self._cache['run'][index0] = (address0, self._offset) 2243 return address0 2244 2245 def _read_curwx(self): 2246 address0, index0 = FAILURE, self._offset 2247 cached = self._cache['curwx'].get(index0) 2248 if cached: 2249 self._offset = cached[1] 2250 return cached[0] 2251 index1 = self._offset 2252 index2 = self._offset 2253 index3, elements0 = self._offset, [] 2254 address1 = FAILURE 2255 address1 = self._read_sep() 2256 if address1 is not FAILURE: 2257 elements0.append(address1) 2258 address2 = FAILURE 2259 chunk0, max0 = None, self._offset + 2 2260 if max0 <= self._input_size: 2261 chunk0 = self._input[self._offset:max0] 2262 if chunk0 == '//': 2263 address2 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, []) 2264 self._offset = self._offset + 2 2265 else: 2266 address2 = FAILURE 2267 if self._offset > self._failure: 2268 self._failure = self._offset 2269 self._expected = [] 2270 if self._offset == self._failure: 2271 self._expected.append('"//"') 2272 if address2 is not FAILURE: 2273 elements0.append(address2) 2274 else: 2275 elements0 = None 2276 self._offset = index3 2277 else: 2278 elements0 = None 2279 self._offset = index3 2280 if elements0 is None: 2281 address0 = FAILURE 2282 else: 2283 address0 = TreeNode9(self._input[index3:self._offset], index3, elements0) 2284 self._offset = self._offset 2285 if address0 is FAILURE: 2286 self._offset = index2 2287 index4, elements1 = self._offset, [] 2288 address3 = FAILURE 2289 address3 = self._read_sep() 2290 if address3 is not FAILURE: 2291 elements1.append(address3) 2292 address4 = FAILURE 2293 chunk1, max1 = None, self._offset + 3 2294 if max1 <= self._input_size: 2295 chunk1 = self._input[self._offset:max1] 2296 if chunk1 == 'NSW': 2297 address4 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, []) 2298 self._offset = self._offset + 3 2299 else: 2300 address4 = FAILURE 2301 if self._offset > self._failure: 2302 self._failure = self._offset 2303 self._expected = [] 2304 if self._offset == self._failure: 2305 self._expected.append('"NSW"') 2306 if address4 is not FAILURE: 2307 elements1.append(address4) 2308 else: 2309 elements1 = None 2310 self._offset = index4 2311 else: 2312 elements1 = None 2313 self._offset = index4 2314 if elements1 is None: 2315 address0 = FAILURE 2316 else: 2317 address0 = TreeNode10(self._input[index4:self._offset], index4, elements1) 2318 self._offset = self._offset 2319 if address0 is FAILURE: 2320 self._offset = index2 2321 remaining0, index5, elements2, address5 = 0, self._offset, [], True 2322 while address5 is not FAILURE: 2323 index6, elements3 = self._offset, [] 2324 address6 = FAILURE 2325 address6 = self._read_sep() 2326 if address6 is not FAILURE: 2327 elements3.append(address6) 2328 address7 = FAILURE 2329 address7 = self._read_wx() 2330 if address7 is not FAILURE: 2331 elements3.append(address7) 2332 else: 2333 elements3 = None 2334 self._offset = index6 2335 else: 2336 elements3 = None 2337 self._offset = index6 2338 if elements3 is None: 2339 address5 = FAILURE 2340 else: 2341 address5 = TreeNode11(self._input[index6:self._offset], index6, elements3) 2342 self._offset = self._offset 2343 if address5 is not FAILURE: 2344 elements2.append(address5) 2345 remaining0 -= 1 2346 if remaining0 <= 0: 2347 address0 = TreeNode(self._input[index5:self._offset], index5, elements2) 2348 self._offset = self._offset 2349 else: 2350 address0 = FAILURE 2351 if address0 is FAILURE: 2352 self._offset = index2 2353 if address0 is FAILURE: 2354 address0 = TreeNode(self._input[index1:index1], index1, []) 2355 self._offset = index1 2356 self._cache['curwx'][index0] = (address0, self._offset) 2357 return address0 2358 2359 def _read_wx(self): 2360 address0, index0 = FAILURE, self._offset 2361 cached = self._cache['wx'].get(index0) 2362 if cached: 2363 self._offset = cached[1] 2364 return cached[0] 2365 index1, elements0 = self._offset, [] 2366 address1 = FAILURE 2367 index2 = self._offset 2368 index3, elements1 = self._offset, [] 2369 address2 = FAILURE 2370 chunk0, max0 = None, self._offset + 1 2371 if max0 <= self._input_size: 2372 chunk0 = self._input[self._offset:max0] 2373 if chunk0 is not None and Grammar.REGEX_49.search(chunk0): 2374 address2 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 2375 self._offset = self._offset + 1 2376 else: 2377 address2 = FAILURE 2378 if self._offset > self._failure: 2379 self._failure = self._offset 2380 self._expected = [] 2381 if self._offset == self._failure: 2382 self._expected.append('[-+]') 2383 if address2 is not FAILURE: 2384 elements1.append(address2) 2385 address3 = FAILURE 2386 index4 = self._offset 2387 chunk1, max1 = None, self._offset + 1 2388 if max1 <= self._input_size: 2389 chunk1 = self._input[self._offset:max1] 2390 if chunk1 == ' ': 2391 address3 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 2392 self._offset = self._offset + 1 2393 else: 2394 address3 = FAILURE 2395 if self._offset > self._failure: 2396 self._failure = self._offset 2397 self._expected = [] 2398 if self._offset == self._failure: 2399 self._expected.append('" "') 2400 if address3 is FAILURE: 2401 address3 = TreeNode(self._input[index4:index4], index4, []) 2402 self._offset = index4 2403 if address3 is not FAILURE: 2404 elements1.append(address3) 2405 else: 2406 elements1 = None 2407 self._offset = index3 2408 else: 2409 elements1 = None 2410 self._offset = index3 2411 if elements1 is None: 2412 address1 = FAILURE 2413 else: 2414 address1 = TreeNode(self._input[index3:self._offset], index3, elements1) 2415 self._offset = self._offset 2416 if address1 is FAILURE: 2417 address1 = TreeNode(self._input[index2:index2], index2, []) 2418 self._offset = index2 2419 if address1 is not FAILURE: 2420 elements0.append(address1) 2421 address4 = FAILURE 2422 index5 = self._offset 2423 chunk2, max2 = None, self._offset + 2 2424 if max2 <= self._input_size: 2425 chunk2 = self._input[self._offset:max2] 2426 if chunk2 == 'VC': 2427 address4 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, []) 2428 self._offset = self._offset + 2 2429 else: 2430 address4 = FAILURE 2431 if self._offset > self._failure: 2432 self._failure = self._offset 2433 self._expected = [] 2434 if self._offset == self._failure: 2435 self._expected.append('"VC"') 2436 if address4 is FAILURE: 2437 address4 = TreeNode(self._input[index5:index5], index5, []) 2438 self._offset = index5 2439 if address4 is not FAILURE: 2440 elements0.append(address4) 2441 address5 = FAILURE 2442 remaining0, index6, elements2, address6 = 1, self._offset, [], True 2443 while address6 is not FAILURE: 2444 index7 = self._offset 2445 chunk3, max3 = None, self._offset + 2 2446 if max3 <= self._input_size: 2447 chunk3 = self._input[self._offset:max3] 2448 if chunk3 == 'MI': 2449 address6 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, []) 2450 self._offset = self._offset + 2 2451 else: 2452 address6 = FAILURE 2453 if self._offset > self._failure: 2454 self._failure = self._offset 2455 self._expected = [] 2456 if self._offset == self._failure: 2457 self._expected.append('"MI"') 2458 if address6 is FAILURE: 2459 self._offset = index7 2460 chunk4, max4 = None, self._offset + 2 2461 if max4 <= self._input_size: 2462 chunk4 = self._input[self._offset:max4] 2463 if chunk4 == 'BC': 2464 address6 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, []) 2465 self._offset = self._offset + 2 2466 else: 2467 address6 = FAILURE 2468 if self._offset > self._failure: 2469 self._failure = self._offset 2470 self._expected = [] 2471 if self._offset == self._failure: 2472 self._expected.append('"BC"') 2473 if address6 is FAILURE: 2474 self._offset = index7 2475 chunk5, max5 = None, self._offset + 2 2476 if max5 <= self._input_size: 2477 chunk5 = self._input[self._offset:max5] 2478 if chunk5 == 'PR': 2479 address6 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, []) 2480 self._offset = self._offset + 2 2481 else: 2482 address6 = FAILURE 2483 if self._offset > self._failure: 2484 self._failure = self._offset 2485 self._expected = [] 2486 if self._offset == self._failure: 2487 self._expected.append('"PR"') 2488 if address6 is FAILURE: 2489 self._offset = index7 2490 chunk6, max6 = None, self._offset + 2 2491 if max6 <= self._input_size: 2492 chunk6 = self._input[self._offset:max6] 2493 if chunk6 == 'DR': 2494 address6 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, []) 2495 self._offset = self._offset + 2 2496 else: 2497 address6 = FAILURE 2498 if self._offset > self._failure: 2499 self._failure = self._offset 2500 self._expected = [] 2501 if self._offset == self._failure: 2502 self._expected.append('"DR"') 2503 if address6 is FAILURE: 2504 self._offset = index7 2505 chunk7, max7 = None, self._offset + 2 2506 if max7 <= self._input_size: 2507 chunk7 = self._input[self._offset:max7] 2508 if chunk7 == 'BL': 2509 address6 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, []) 2510 self._offset = self._offset + 2 2511 else: 2512 address6 = FAILURE 2513 if self._offset > self._failure: 2514 self._failure = self._offset 2515 self._expected = [] 2516 if self._offset == self._failure: 2517 self._expected.append('"BL"') 2518 if address6 is FAILURE: 2519 self._offset = index7 2520 chunk8, max8 = None, self._offset + 2 2521 if max8 <= self._input_size: 2522 chunk8 = self._input[self._offset:max8] 2523 if chunk8 == 'SH': 2524 address6 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, []) 2525 self._offset = self._offset + 2 2526 else: 2527 address6 = FAILURE 2528 if self._offset > self._failure: 2529 self._failure = self._offset 2530 self._expected = [] 2531 if self._offset == self._failure: 2532 self._expected.append('"SH"') 2533 if address6 is FAILURE: 2534 self._offset = index7 2535 chunk9, max9 = None, self._offset + 2 2536 if max9 <= self._input_size: 2537 chunk9 = self._input[self._offset:max9] 2538 if chunk9 == 'TS': 2539 address6 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, []) 2540 self._offset = self._offset + 2 2541 else: 2542 address6 = FAILURE 2543 if self._offset > self._failure: 2544 self._failure = self._offset 2545 self._expected = [] 2546 if self._offset == self._failure: 2547 self._expected.append('"TS"') 2548 if address6 is FAILURE: 2549 self._offset = index7 2550 chunk10, max10 = None, self._offset + 2 2551 if max10 <= self._input_size: 2552 chunk10 = self._input[self._offset:max10] 2553 if chunk10 == 'FZ': 2554 address6 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, []) 2555 self._offset = self._offset + 2 2556 else: 2557 address6 = FAILURE 2558 if self._offset > self._failure: 2559 self._failure = self._offset 2560 self._expected = [] 2561 if self._offset == self._failure: 2562 self._expected.append('"FZ"') 2563 if address6 is FAILURE: 2564 self._offset = index7 2565 chunk11, max11 = None, self._offset + 2 2566 if max11 <= self._input_size: 2567 chunk11 = self._input[self._offset:max11] 2568 if chunk11 == 'DZ': 2569 address6 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, []) 2570 self._offset = self._offset + 2 2571 else: 2572 address6 = FAILURE 2573 if self._offset > self._failure: 2574 self._failure = self._offset 2575 self._expected = [] 2576 if self._offset == self._failure: 2577 self._expected.append('"DZ"') 2578 if address6 is FAILURE: 2579 self._offset = index7 2580 chunk12, max12 = None, self._offset + 2 2581 if max12 <= self._input_size: 2582 chunk12 = self._input[self._offset:max12] 2583 if chunk12 == 'RA': 2584 address6 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, []) 2585 self._offset = self._offset + 2 2586 else: 2587 address6 = FAILURE 2588 if self._offset > self._failure: 2589 self._failure = self._offset 2590 self._expected = [] 2591 if self._offset == self._failure: 2592 self._expected.append('"RA"') 2593 if address6 is FAILURE: 2594 self._offset = index7 2595 chunk13, max13 = None, self._offset + 2 2596 if max13 <= self._input_size: 2597 chunk13 = self._input[self._offset:max13] 2598 if chunk13 == 'SN': 2599 address6 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, []) 2600 self._offset = self._offset + 2 2601 else: 2602 address6 = FAILURE 2603 if self._offset > self._failure: 2604 self._failure = self._offset 2605 self._expected = [] 2606 if self._offset == self._failure: 2607 self._expected.append('"SN"') 2608 if address6 is FAILURE: 2609 self._offset = index7 2610 chunk14, max14 = None, self._offset + 2 2611 if max14 <= self._input_size: 2612 chunk14 = self._input[self._offset:max14] 2613 if chunk14 == 'SG': 2614 address6 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, []) 2615 self._offset = self._offset + 2 2616 else: 2617 address6 = FAILURE 2618 if self._offset > self._failure: 2619 self._failure = self._offset 2620 self._expected = [] 2621 if self._offset == self._failure: 2622 self._expected.append('"SG"') 2623 if address6 is FAILURE: 2624 self._offset = index7 2625 chunk15, max15 = None, self._offset + 2 2626 if max15 <= self._input_size: 2627 chunk15 = self._input[self._offset:max15] 2628 if chunk15 == 'PL': 2629 address6 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, []) 2630 self._offset = self._offset + 2 2631 else: 2632 address6 = FAILURE 2633 if self._offset > self._failure: 2634 self._failure = self._offset 2635 self._expected = [] 2636 if self._offset == self._failure: 2637 self._expected.append('"PL"') 2638 if address6 is FAILURE: 2639 self._offset = index7 2640 chunk16, max16 = None, self._offset + 2 2641 if max16 <= self._input_size: 2642 chunk16 = self._input[self._offset:max16] 2643 if chunk16 == 'GR': 2644 address6 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, []) 2645 self._offset = self._offset + 2 2646 else: 2647 address6 = FAILURE 2648 if self._offset > self._failure: 2649 self._failure = self._offset 2650 self._expected = [] 2651 if self._offset == self._failure: 2652 self._expected.append('"GR"') 2653 if address6 is FAILURE: 2654 self._offset = index7 2655 chunk17, max17 = None, self._offset + 2 2656 if max17 <= self._input_size: 2657 chunk17 = self._input[self._offset:max17] 2658 if chunk17 == 'GS': 2659 address6 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, []) 2660 self._offset = self._offset + 2 2661 else: 2662 address6 = FAILURE 2663 if self._offset > self._failure: 2664 self._failure = self._offset 2665 self._expected = [] 2666 if self._offset == self._failure: 2667 self._expected.append('"GS"') 2668 if address6 is FAILURE: 2669 self._offset = index7 2670 chunk18, max18 = None, self._offset + 2 2671 if max18 <= self._input_size: 2672 chunk18 = self._input[self._offset:max18] 2673 if chunk18 == 'UP': 2674 address6 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, []) 2675 self._offset = self._offset + 2 2676 else: 2677 address6 = FAILURE 2678 if self._offset > self._failure: 2679 self._failure = self._offset 2680 self._expected = [] 2681 if self._offset == self._failure: 2682 self._expected.append('"UP"') 2683 if address6 is FAILURE: 2684 self._offset = index7 2685 chunk19, max19 = None, self._offset + 2 2686 if max19 <= self._input_size: 2687 chunk19 = self._input[self._offset:max19] 2688 if chunk19 == 'BR': 2689 address6 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, []) 2690 self._offset = self._offset + 2 2691 else: 2692 address6 = FAILURE 2693 if self._offset > self._failure: 2694 self._failure = self._offset 2695 self._expected = [] 2696 if self._offset == self._failure: 2697 self._expected.append('"BR"') 2698 if address6 is FAILURE: 2699 self._offset = index7 2700 chunk20, max20 = None, self._offset + 2 2701 if max20 <= self._input_size: 2702 chunk20 = self._input[self._offset:max20] 2703 if chunk20 == 'FG': 2704 address6 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, []) 2705 self._offset = self._offset + 2 2706 else: 2707 address6 = FAILURE 2708 if self._offset > self._failure: 2709 self._failure = self._offset 2710 self._expected = [] 2711 if self._offset == self._failure: 2712 self._expected.append('"FG"') 2713 if address6 is FAILURE: 2714 self._offset = index7 2715 chunk21, max21 = None, self._offset + 2 2716 if max21 <= self._input_size: 2717 chunk21 = self._input[self._offset:max21] 2718 if chunk21 == 'FU': 2719 address6 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, []) 2720 self._offset = self._offset + 2 2721 else: 2722 address6 = FAILURE 2723 if self._offset > self._failure: 2724 self._failure = self._offset 2725 self._expected = [] 2726 if self._offset == self._failure: 2727 self._expected.append('"FU"') 2728 if address6 is FAILURE: 2729 self._offset = index7 2730 chunk22, max22 = None, self._offset + 2 2731 if max22 <= self._input_size: 2732 chunk22 = self._input[self._offset:max22] 2733 if chunk22 == 'VA': 2734 address6 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, []) 2735 self._offset = self._offset + 2 2736 else: 2737 address6 = FAILURE 2738 if self._offset > self._failure: 2739 self._failure = self._offset 2740 self._expected = [] 2741 if self._offset == self._failure: 2742 self._expected.append('"VA"') 2743 if address6 is FAILURE: 2744 self._offset = index7 2745 chunk23, max23 = None, self._offset + 2 2746 if max23 <= self._input_size: 2747 chunk23 = self._input[self._offset:max23] 2748 if chunk23 == 'DU': 2749 address6 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, []) 2750 self._offset = self._offset + 2 2751 else: 2752 address6 = FAILURE 2753 if self._offset > self._failure: 2754 self._failure = self._offset 2755 self._expected = [] 2756 if self._offset == self._failure: 2757 self._expected.append('"DU"') 2758 if address6 is FAILURE: 2759 self._offset = index7 2760 chunk24, max24 = None, self._offset + 2 2761 if max24 <= self._input_size: 2762 chunk24 = self._input[self._offset:max24] 2763 if chunk24 == 'SA': 2764 address6 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, []) 2765 self._offset = self._offset + 2 2766 else: 2767 address6 = FAILURE 2768 if self._offset > self._failure: 2769 self._failure = self._offset 2770 self._expected = [] 2771 if self._offset == self._failure: 2772 self._expected.append('"SA"') 2773 if address6 is FAILURE: 2774 self._offset = index7 2775 chunk25, max25 = None, self._offset + 2 2776 if max25 <= self._input_size: 2777 chunk25 = self._input[self._offset:max25] 2778 if chunk25 == 'HZ': 2779 address6 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, []) 2780 self._offset = self._offset + 2 2781 else: 2782 address6 = FAILURE 2783 if self._offset > self._failure: 2784 self._failure = self._offset 2785 self._expected = [] 2786 if self._offset == self._failure: 2787 self._expected.append('"HZ"') 2788 if address6 is FAILURE: 2789 self._offset = index7 2790 chunk26, max26 = None, self._offset + 2 2791 if max26 <= self._input_size: 2792 chunk26 = self._input[self._offset:max26] 2793 if chunk26 == 'PO': 2794 address6 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, []) 2795 self._offset = self._offset + 2 2796 else: 2797 address6 = FAILURE 2798 if self._offset > self._failure: 2799 self._failure = self._offset 2800 self._expected = [] 2801 if self._offset == self._failure: 2802 self._expected.append('"PO"') 2803 if address6 is FAILURE: 2804 self._offset = index7 2805 chunk27, max27 = None, self._offset + 2 2806 if max27 <= self._input_size: 2807 chunk27 = self._input[self._offset:max27] 2808 if chunk27 == 'SQ': 2809 address6 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, []) 2810 self._offset = self._offset + 2 2811 else: 2812 address6 = FAILURE 2813 if self._offset > self._failure: 2814 self._failure = self._offset 2815 self._expected = [] 2816 if self._offset == self._failure: 2817 self._expected.append('"SQ"') 2818 if address6 is FAILURE: 2819 self._offset = index7 2820 chunk28, max28 = None, self._offset + 2 2821 if max28 <= self._input_size: 2822 chunk28 = self._input[self._offset:max28] 2823 if chunk28 == 'FC': 2824 address6 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, []) 2825 self._offset = self._offset + 2 2826 else: 2827 address6 = FAILURE 2828 if self._offset > self._failure: 2829 self._failure = self._offset 2830 self._expected = [] 2831 if self._offset == self._failure: 2832 self._expected.append('"FC"') 2833 if address6 is FAILURE: 2834 self._offset = index7 2835 chunk29, max29 = None, self._offset + 2 2836 if max29 <= self._input_size: 2837 chunk29 = self._input[self._offset:max29] 2838 if chunk29 == 'SS': 2839 address6 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, []) 2840 self._offset = self._offset + 2 2841 else: 2842 address6 = FAILURE 2843 if self._offset > self._failure: 2844 self._failure = self._offset 2845 self._expected = [] 2846 if self._offset == self._failure: 2847 self._expected.append('"SS"') 2848 if address6 is FAILURE: 2849 self._offset = index7 2850 chunk30, max30 = None, self._offset + 2 2851 if max30 <= self._input_size: 2852 chunk30 = self._input[self._offset:max30] 2853 if chunk30 == 'DS': 2854 address6 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, []) 2855 self._offset = self._offset + 2 2856 else: 2857 address6 = FAILURE 2858 if self._offset > self._failure: 2859 self._failure = self._offset 2860 self._expected = [] 2861 if self._offset == self._failure: 2862 self._expected.append('"DS"') 2863 if address6 is FAILURE: 2864 self._offset = index7 2865 chunk31, max31 = None, self._offset + 2 2866 if max31 <= self._input_size: 2867 chunk31 = self._input[self._offset:max31] 2868 if chunk31 == 'IC': 2869 address6 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, []) 2870 self._offset = self._offset + 2 2871 else: 2872 address6 = FAILURE 2873 if self._offset > self._failure: 2874 self._failure = self._offset 2875 self._expected = [] 2876 if self._offset == self._failure: 2877 self._expected.append('"IC"') 2878 if address6 is FAILURE: 2879 self._offset = index7 2880 chunk32, max32 = None, self._offset + 2 2881 if max32 <= self._input_size: 2882 chunk32 = self._input[self._offset:max32] 2883 if chunk32 == 'PY': 2884 address6 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, []) 2885 self._offset = self._offset + 2 2886 else: 2887 address6 = FAILURE 2888 if self._offset > self._failure: 2889 self._failure = self._offset 2890 self._expected = [] 2891 if self._offset == self._failure: 2892 self._expected.append('"PY"') 2893 if address6 is FAILURE: 2894 self._offset = index7 2895 if address6 is not FAILURE: 2896 elements2.append(address6) 2897 remaining0 -= 1 2898 if remaining0 <= 0: 2899 address5 = TreeNode(self._input[index6:self._offset], index6, elements2) 2900 self._offset = self._offset 2901 else: 2902 address5 = FAILURE 2903 if address5 is not FAILURE: 2904 elements0.append(address5) 2905 else: 2906 elements0 = None 2907 self._offset = index1 2908 else: 2909 elements0 = None 2910 self._offset = index1 2911 else: 2912 elements0 = None 2913 self._offset = index1 2914 if elements0 is None: 2915 address0 = FAILURE 2916 else: 2917 address0 = TreeNode(self._input[index1:self._offset], index1, elements0) 2918 self._offset = self._offset 2919 self._cache['wx'][index0] = (address0, self._offset) 2920 return address0 2921 2922 def _read_skyc(self): 2923 address0, index0 = FAILURE, self._offset 2924 cached = self._cache['skyc'].get(index0) 2925 if cached: 2926 self._offset = cached[1] 2927 return cached[0] 2928 index1 = self._offset 2929 remaining0, index2, elements0, address1 = 0, self._offset, [], True 2930 while address1 is not FAILURE: 2931 index3, elements1 = self._offset, [] 2932 address2 = FAILURE 2933 address2 = self._read_sep() 2934 if address2 is not FAILURE: 2935 elements1.append(address2) 2936 address3 = FAILURE 2937 address3 = self._read_cover() 2938 if address3 is not FAILURE: 2939 elements1.append(address3) 2940 else: 2941 elements1 = None 2942 self._offset = index3 2943 else: 2944 elements1 = None 2945 self._offset = index3 2946 if elements1 is None: 2947 address1 = FAILURE 2948 else: 2949 address1 = TreeNode12(self._input[index3:self._offset], index3, elements1) 2950 self._offset = self._offset 2951 if address1 is not FAILURE: 2952 elements0.append(address1) 2953 remaining0 -= 1 2954 if remaining0 <= 0: 2955 address0 = TreeNode(self._input[index2:self._offset], index2, elements0) 2956 self._offset = self._offset 2957 else: 2958 address0 = FAILURE 2959 if address0 is FAILURE: 2960 address0 = TreeNode(self._input[index1:index1], index1, []) 2961 self._offset = index1 2962 self._cache['skyc'][index0] = (address0, self._offset) 2963 return address0 2964 2965 def _read_cover(self): 2966 address0, index0 = FAILURE, self._offset 2967 cached = self._cache['cover'].get(index0) 2968 if cached: 2969 self._offset = cached[1] 2970 return cached[0] 2971 index1 = self._offset 2972 index2, elements0 = self._offset, [] 2973 address1 = FAILURE 2974 index3 = self._offset 2975 chunk0, max0 = None, self._offset + 3 2976 if max0 <= self._input_size: 2977 chunk0 = self._input[self._offset:max0] 2978 if chunk0 == 'FEW': 2979 address1 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, []) 2980 self._offset = self._offset + 3 2981 else: 2982 address1 = FAILURE 2983 if self._offset > self._failure: 2984 self._failure = self._offset 2985 self._expected = [] 2986 if self._offset == self._failure: 2987 self._expected.append('"FEW"') 2988 if address1 is FAILURE: 2989 self._offset = index3 2990 chunk1, max1 = None, self._offset + 3 2991 if max1 <= self._input_size: 2992 chunk1 = self._input[self._offset:max1] 2993 if chunk1 == 'SCT': 2994 address1 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, []) 2995 self._offset = self._offset + 3 2996 else: 2997 address1 = FAILURE 2998 if self._offset > self._failure: 2999 self._failure = self._offset 3000 self._expected = [] 3001 if self._offset == self._failure: 3002 self._expected.append('"SCT"') 3003 if address1 is FAILURE: 3004 self._offset = index3 3005 chunk2, max2 = None, self._offset + 3 3006 if max2 <= self._input_size: 3007 chunk2 = self._input[self._offset:max2] 3008 if chunk2 == 'BKN': 3009 address1 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, []) 3010 self._offset = self._offset + 3 3011 else: 3012 address1 = FAILURE 3013 if self._offset > self._failure: 3014 self._failure = self._offset 3015 self._expected = [] 3016 if self._offset == self._failure: 3017 self._expected.append('"BKN"') 3018 if address1 is FAILURE: 3019 self._offset = index3 3020 chunk3, max3 = None, self._offset + 3 3021 if max3 <= self._input_size: 3022 chunk3 = self._input[self._offset:max3] 3023 if chunk3 == 'OVC': 3024 address1 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, []) 3025 self._offset = self._offset + 3 3026 else: 3027 address1 = FAILURE 3028 if self._offset > self._failure: 3029 self._failure = self._offset 3030 self._expected = [] 3031 if self._offset == self._failure: 3032 self._expected.append('"OVC"') 3033 if address1 is FAILURE: 3034 self._offset = index3 3035 chunk4, max4 = None, self._offset + 2 3036 if max4 <= self._input_size: 3037 chunk4 = self._input[self._offset:max4] 3038 if chunk4 == 'VV': 3039 address1 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, []) 3040 self._offset = self._offset + 2 3041 else: 3042 address1 = FAILURE 3043 if self._offset > self._failure: 3044 self._failure = self._offset 3045 self._expected = [] 3046 if self._offset == self._failure: 3047 self._expected.append('"VV"') 3048 if address1 is FAILURE: 3049 self._offset = index3 3050 chunk5, max5 = None, self._offset + 3 3051 if max5 <= self._input_size: 3052 chunk5 = self._input[self._offset:max5] 3053 if chunk5 == '///': 3054 address1 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, []) 3055 self._offset = self._offset + 3 3056 else: 3057 address1 = FAILURE 3058 if self._offset > self._failure: 3059 self._failure = self._offset 3060 self._expected = [] 3061 if self._offset == self._failure: 3062 self._expected.append('"///"') 3063 if address1 is FAILURE: 3064 self._offset = index3 3065 if address1 is not FAILURE: 3066 elements0.append(address1) 3067 address2 = FAILURE 3068 index4 = self._offset 3069 remaining0, index5, elements1, address3 = 0, self._offset, [], True 3070 while address3 is not FAILURE: 3071 chunk6, max6 = None, self._offset + 1 3072 if max6 <= self._input_size: 3073 chunk6 = self._input[self._offset:max6] 3074 if chunk6 is not None and Grammar.REGEX_50.search(chunk6): 3075 address3 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 3076 self._offset = self._offset + 1 3077 else: 3078 address3 = FAILURE 3079 if self._offset > self._failure: 3080 self._failure = self._offset 3081 self._expected = [] 3082 if self._offset == self._failure: 3083 self._expected.append('[\\d]') 3084 if address3 is not FAILURE: 3085 elements1.append(address3) 3086 remaining0 -= 1 3087 if remaining0 <= 0: 3088 address2 = TreeNode(self._input[index5:self._offset], index5, elements1) 3089 self._offset = self._offset 3090 else: 3091 address2 = FAILURE 3092 if address2 is FAILURE: 3093 address2 = TreeNode(self._input[index4:index4], index4, []) 3094 self._offset = index4 3095 if address2 is not FAILURE: 3096 elements0.append(address2) 3097 address4 = FAILURE 3098 index6 = self._offset 3099 index7 = self._offset 3100 chunk7, max7 = None, self._offset + 3 3101 if max7 <= self._input_size: 3102 chunk7 = self._input[self._offset:max7] 3103 if chunk7 == 'TCU': 3104 address4 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, []) 3105 self._offset = self._offset + 3 3106 else: 3107 address4 = FAILURE 3108 if self._offset > self._failure: 3109 self._failure = self._offset 3110 self._expected = [] 3111 if self._offset == self._failure: 3112 self._expected.append('"TCU"') 3113 if address4 is FAILURE: 3114 self._offset = index7 3115 chunk8, max8 = None, self._offset + 2 3116 if max8 <= self._input_size: 3117 chunk8 = self._input[self._offset:max8] 3118 if chunk8 == 'CB': 3119 address4 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, []) 3120 self._offset = self._offset + 2 3121 else: 3122 address4 = FAILURE 3123 if self._offset > self._failure: 3124 self._failure = self._offset 3125 self._expected = [] 3126 if self._offset == self._failure: 3127 self._expected.append('"CB"') 3128 if address4 is FAILURE: 3129 self._offset = index7 3130 chunk9, max9 = None, self._offset + 3 3131 if max9 <= self._input_size: 3132 chunk9 = self._input[self._offset:max9] 3133 if chunk9 == '///': 3134 address4 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, []) 3135 self._offset = self._offset + 3 3136 else: 3137 address4 = FAILURE 3138 if self._offset > self._failure: 3139 self._failure = self._offset 3140 self._expected = [] 3141 if self._offset == self._failure: 3142 self._expected.append('"///"') 3143 if address4 is FAILURE: 3144 self._offset = index7 3145 if address4 is FAILURE: 3146 address4 = TreeNode(self._input[index6:index6], index6, []) 3147 self._offset = index6 3148 if address4 is not FAILURE: 3149 elements0.append(address4) 3150 else: 3151 elements0 = None 3152 self._offset = index2 3153 else: 3154 elements0 = None 3155 self._offset = index2 3156 else: 3157 elements0 = None 3158 self._offset = index2 3159 if elements0 is None: 3160 address0 = FAILURE 3161 else: 3162 address0 = TreeNode(self._input[index2:self._offset], index2, elements0) 3163 self._offset = self._offset 3164 if address0 is FAILURE: 3165 self._offset = index1 3166 index8 = self._offset 3167 chunk10, max10 = None, self._offset + 3 3168 if max10 <= self._input_size: 3169 chunk10 = self._input[self._offset:max10] 3170 if chunk10 == 'CLR': 3171 address0 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, []) 3172 self._offset = self._offset + 3 3173 else: 3174 address0 = FAILURE 3175 if self._offset > self._failure: 3176 self._failure = self._offset 3177 self._expected = [] 3178 if self._offset == self._failure: 3179 self._expected.append('"CLR"') 3180 if address0 is FAILURE: 3181 self._offset = index8 3182 chunk11, max11 = None, self._offset + 3 3183 if max11 <= self._input_size: 3184 chunk11 = self._input[self._offset:max11] 3185 if chunk11 == 'SKC': 3186 address0 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, []) 3187 self._offset = self._offset + 3 3188 else: 3189 address0 = FAILURE 3190 if self._offset > self._failure: 3191 self._failure = self._offset 3192 self._expected = [] 3193 if self._offset == self._failure: 3194 self._expected.append('"SKC"') 3195 if address0 is FAILURE: 3196 self._offset = index8 3197 chunk12, max12 = None, self._offset + 3 3198 if max12 <= self._input_size: 3199 chunk12 = self._input[self._offset:max12] 3200 if chunk12 == 'NSC': 3201 address0 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, []) 3202 self._offset = self._offset + 3 3203 else: 3204 address0 = FAILURE 3205 if self._offset > self._failure: 3206 self._failure = self._offset 3207 self._expected = [] 3208 if self._offset == self._failure: 3209 self._expected.append('"NSC"') 3210 if address0 is FAILURE: 3211 self._offset = index8 3212 chunk13, max13 = None, self._offset + 3 3213 if max13 <= self._input_size: 3214 chunk13 = self._input[self._offset:max13] 3215 if chunk13 == 'NCD': 3216 address0 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, []) 3217 self._offset = self._offset + 3 3218 else: 3219 address0 = FAILURE 3220 if self._offset > self._failure: 3221 self._failure = self._offset 3222 self._expected = [] 3223 if self._offset == self._failure: 3224 self._expected.append('"NCD"') 3225 if address0 is FAILURE: 3226 self._offset = index8 3227 if address0 is FAILURE: 3228 self._offset = index1 3229 address0 = self._read_wx() 3230 if address0 is FAILURE: 3231 self._offset = index1 3232 chunk14, max14 = None, self._offset + 2 3233 if max14 <= self._input_size: 3234 chunk14 = self._input[self._offset:max14] 3235 if chunk14 == '//': 3236 address0 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, []) 3237 self._offset = self._offset + 2 3238 else: 3239 address0 = FAILURE 3240 if self._offset > self._failure: 3241 self._failure = self._offset 3242 self._expected = [] 3243 if self._offset == self._failure: 3244 self._expected.append('"//"') 3245 if address0 is FAILURE: 3246 self._offset = index1 3247 self._cache['cover'][index0] = (address0, self._offset) 3248 return address0 3249 3250 def _read_temp_dewp(self): 3251 address0, index0 = FAILURE, self._offset 3252 cached = self._cache['temp_dewp'].get(index0) 3253 if cached: 3254 self._offset = cached[1] 3255 return cached[0] 3256 index1 = self._offset 3257 index2, elements0 = self._offset, [] 3258 address1 = FAILURE 3259 address1 = self._read_sep() 3260 if address1 is not FAILURE: 3261 elements0.append(address1) 3262 address2 = FAILURE 3263 index3 = self._offset 3264 chunk0, max0 = None, self._offset + 2 3265 if max0 <= self._input_size: 3266 chunk0 = self._input[self._offset:max0] 3267 if chunk0 == '//': 3268 address2 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, []) 3269 self._offset = self._offset + 2 3270 else: 3271 address2 = FAILURE 3272 if self._offset > self._failure: 3273 self._failure = self._offset 3274 self._expected = [] 3275 if self._offset == self._failure: 3276 self._expected.append('"//"') 3277 if address2 is FAILURE: 3278 address2 = TreeNode(self._input[index3:index3], index3, []) 3279 self._offset = index3 3280 if address2 is not FAILURE: 3281 elements0.append(address2) 3282 address3 = FAILURE 3283 address3 = self._read_temp() 3284 if address3 is not FAILURE: 3285 elements0.append(address3) 3286 address4 = FAILURE 3287 chunk1, max1 = None, self._offset + 1 3288 if max1 <= self._input_size: 3289 chunk1 = self._input[self._offset:max1] 3290 if chunk1 == '/': 3291 address4 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 3292 self._offset = self._offset + 1 3293 else: 3294 address4 = FAILURE 3295 if self._offset > self._failure: 3296 self._failure = self._offset 3297 self._expected = [] 3298 if self._offset == self._failure: 3299 self._expected.append('"/"') 3300 if address4 is not FAILURE: 3301 elements0.append(address4) 3302 address5 = FAILURE 3303 address5 = self._read_dewp() 3304 if address5 is not FAILURE: 3305 elements0.append(address5) 3306 address6 = FAILURE 3307 index4 = self._offset 3308 chunk2, max2 = None, self._offset + 2 3309 if max2 <= self._input_size: 3310 chunk2 = self._input[self._offset:max2] 3311 if chunk2 == '//': 3312 address6 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, []) 3313 self._offset = self._offset + 2 3314 else: 3315 address6 = FAILURE 3316 if self._offset > self._failure: 3317 self._failure = self._offset 3318 self._expected = [] 3319 if self._offset == self._failure: 3320 self._expected.append('"//"') 3321 if address6 is FAILURE: 3322 address6 = TreeNode(self._input[index4:index4], index4, []) 3323 self._offset = index4 3324 if address6 is not FAILURE: 3325 elements0.append(address6) 3326 else: 3327 elements0 = None 3328 self._offset = index2 3329 else: 3330 elements0 = None 3331 self._offset = index2 3332 else: 3333 elements0 = None 3334 self._offset = index2 3335 else: 3336 elements0 = None 3337 self._offset = index2 3338 else: 3339 elements0 = None 3340 self._offset = index2 3341 else: 3342 elements0 = None 3343 self._offset = index2 3344 if elements0 is None: 3345 address0 = FAILURE 3346 else: 3347 address0 = TreeNode13(self._input[index2:self._offset], index2, elements0) 3348 self._offset = self._offset 3349 if address0 is FAILURE: 3350 address0 = TreeNode(self._input[index1:index1], index1, []) 3351 self._offset = index1 3352 self._cache['temp_dewp'][index0] = (address0, self._offset) 3353 return address0 3354 3355 def _read_temp(self): 3356 address0, index0 = FAILURE, self._offset 3357 cached = self._cache['temp'].get(index0) 3358 if cached: 3359 self._offset = cached[1] 3360 return cached[0] 3361 index1, elements0 = self._offset, [] 3362 address1 = FAILURE 3363 index2 = self._offset 3364 chunk0, max0 = None, self._offset + 1 3365 if max0 <= self._input_size: 3366 chunk0 = self._input[self._offset:max0] 3367 if chunk0 is not None and Grammar.REGEX_51.search(chunk0): 3368 address1 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 3369 self._offset = self._offset + 1 3370 else: 3371 address1 = FAILURE 3372 if self._offset > self._failure: 3373 self._failure = self._offset 3374 self._expected = [] 3375 if self._offset == self._failure: 3376 self._expected.append('[M]') 3377 if address1 is FAILURE: 3378 address1 = TreeNode(self._input[index2:index2], index2, []) 3379 self._offset = index2 3380 if address1 is not FAILURE: 3381 elements0.append(address1) 3382 address2 = FAILURE 3383 index3 = self._offset 3384 chunk1, max1 = None, self._offset + 1 3385 if max1 <= self._input_size: 3386 chunk1 = self._input[self._offset:max1] 3387 if chunk1 is not None and Grammar.REGEX_52.search(chunk1): 3388 address2 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 3389 self._offset = self._offset + 1 3390 else: 3391 address2 = FAILURE 3392 if self._offset > self._failure: 3393 self._failure = self._offset 3394 self._expected = [] 3395 if self._offset == self._failure: 3396 self._expected.append('[\\d]') 3397 if address2 is FAILURE: 3398 address2 = TreeNode(self._input[index3:index3], index3, []) 3399 self._offset = index3 3400 if address2 is not FAILURE: 3401 elements0.append(address2) 3402 address3 = FAILURE 3403 index4 = self._offset 3404 chunk2, max2 = None, self._offset + 1 3405 if max2 <= self._input_size: 3406 chunk2 = self._input[self._offset:max2] 3407 if chunk2 is not None and Grammar.REGEX_53.search(chunk2): 3408 address3 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 3409 self._offset = self._offset + 1 3410 else: 3411 address3 = FAILURE 3412 if self._offset > self._failure: 3413 self._failure = self._offset 3414 self._expected = [] 3415 if self._offset == self._failure: 3416 self._expected.append('[\\d]') 3417 if address3 is FAILURE: 3418 address3 = TreeNode(self._input[index4:index4], index4, []) 3419 self._offset = index4 3420 if address3 is not FAILURE: 3421 elements0.append(address3) 3422 else: 3423 elements0 = None 3424 self._offset = index1 3425 else: 3426 elements0 = None 3427 self._offset = index1 3428 else: 3429 elements0 = None 3430 self._offset = index1 3431 if elements0 is None: 3432 address0 = FAILURE 3433 else: 3434 address0 = TreeNode(self._input[index1:self._offset], index1, elements0) 3435 self._offset = self._offset 3436 self._cache['temp'][index0] = (address0, self._offset) 3437 return address0 3438 3439 def _read_dewp(self): 3440 address0, index0 = FAILURE, self._offset 3441 cached = self._cache['dewp'].get(index0) 3442 if cached: 3443 self._offset = cached[1] 3444 return cached[0] 3445 index1, elements0 = self._offset, [] 3446 address1 = FAILURE 3447 index2 = self._offset 3448 chunk0, max0 = None, self._offset + 1 3449 if max0 <= self._input_size: 3450 chunk0 = self._input[self._offset:max0] 3451 if chunk0 is not None and Grammar.REGEX_54.search(chunk0): 3452 address1 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 3453 self._offset = self._offset + 1 3454 else: 3455 address1 = FAILURE 3456 if self._offset > self._failure: 3457 self._failure = self._offset 3458 self._expected = [] 3459 if self._offset == self._failure: 3460 self._expected.append('[M]') 3461 if address1 is FAILURE: 3462 address1 = TreeNode(self._input[index2:index2], index2, []) 3463 self._offset = index2 3464 if address1 is not FAILURE: 3465 elements0.append(address1) 3466 address2 = FAILURE 3467 index3 = self._offset 3468 chunk1, max1 = None, self._offset + 1 3469 if max1 <= self._input_size: 3470 chunk1 = self._input[self._offset:max1] 3471 if chunk1 is not None and Grammar.REGEX_55.search(chunk1): 3472 address2 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 3473 self._offset = self._offset + 1 3474 else: 3475 address2 = FAILURE 3476 if self._offset > self._failure: 3477 self._failure = self._offset 3478 self._expected = [] 3479 if self._offset == self._failure: 3480 self._expected.append('[\\d]') 3481 if address2 is FAILURE: 3482 address2 = TreeNode(self._input[index3:index3], index3, []) 3483 self._offset = index3 3484 if address2 is not FAILURE: 3485 elements0.append(address2) 3486 address3 = FAILURE 3487 index4 = self._offset 3488 chunk2, max2 = None, self._offset + 1 3489 if max2 <= self._input_size: 3490 chunk2 = self._input[self._offset:max2] 3491 if chunk2 is not None and Grammar.REGEX_56.search(chunk2): 3492 address3 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 3493 self._offset = self._offset + 1 3494 else: 3495 address3 = FAILURE 3496 if self._offset > self._failure: 3497 self._failure = self._offset 3498 self._expected = [] 3499 if self._offset == self._failure: 3500 self._expected.append('[\\d]') 3501 if address3 is FAILURE: 3502 address3 = TreeNode(self._input[index4:index4], index4, []) 3503 self._offset = index4 3504 if address3 is not FAILURE: 3505 elements0.append(address3) 3506 else: 3507 elements0 = None 3508 self._offset = index1 3509 else: 3510 elements0 = None 3511 self._offset = index1 3512 else: 3513 elements0 = None 3514 self._offset = index1 3515 if elements0 is None: 3516 address0 = FAILURE 3517 else: 3518 address0 = TreeNode(self._input[index1:self._offset], index1, elements0) 3519 self._offset = self._offset 3520 self._cache['dewp'][index0] = (address0, self._offset) 3521 return address0 3522 3523 def _read_altim(self): 3524 address0, index0 = FAILURE, self._offset 3525 cached = self._cache['altim'].get(index0) 3526 if cached: 3527 self._offset = cached[1] 3528 return cached[0] 3529 index1 = self._offset 3530 index2, elements0 = self._offset, [] 3531 address1 = FAILURE 3532 index3 = self._offset 3533 address1 = self._read_sep() 3534 if address1 is FAILURE: 3535 address1 = TreeNode(self._input[index3:index3], index3, []) 3536 self._offset = index3 3537 if address1 is not FAILURE: 3538 elements0.append(address1) 3539 address2 = FAILURE 3540 chunk0, max0 = None, self._offset + 1 3541 if max0 <= self._input_size: 3542 chunk0 = self._input[self._offset:max0] 3543 if chunk0 is not None and Grammar.REGEX_57.search(chunk0): 3544 address2 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 3545 self._offset = self._offset + 1 3546 else: 3547 address2 = FAILURE 3548 if self._offset > self._failure: 3549 self._failure = self._offset 3550 self._expected = [] 3551 if self._offset == self._failure: 3552 self._expected.append('["Q" / "A"]') 3553 if address2 is not FAILURE: 3554 elements0.append(address2) 3555 address3 = FAILURE 3556 chunk1, max1 = None, self._offset + 1 3557 if max1 <= self._input_size: 3558 chunk1 = self._input[self._offset:max1] 3559 if chunk1 is not None and Grammar.REGEX_58.search(chunk1): 3560 address3 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 3561 self._offset = self._offset + 1 3562 else: 3563 address3 = FAILURE 3564 if self._offset > self._failure: 3565 self._failure = self._offset 3566 self._expected = [] 3567 if self._offset == self._failure: 3568 self._expected.append('[\\d]') 3569 if address3 is not FAILURE: 3570 elements0.append(address3) 3571 address4 = FAILURE 3572 chunk2, max2 = None, self._offset + 1 3573 if max2 <= self._input_size: 3574 chunk2 = self._input[self._offset:max2] 3575 if chunk2 is not None and Grammar.REGEX_59.search(chunk2): 3576 address4 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 3577 self._offset = self._offset + 1 3578 else: 3579 address4 = FAILURE 3580 if self._offset > self._failure: 3581 self._failure = self._offset 3582 self._expected = [] 3583 if self._offset == self._failure: 3584 self._expected.append('[\\d]') 3585 if address4 is not FAILURE: 3586 elements0.append(address4) 3587 address5 = FAILURE 3588 chunk3, max3 = None, self._offset + 1 3589 if max3 <= self._input_size: 3590 chunk3 = self._input[self._offset:max3] 3591 if chunk3 is not None and Grammar.REGEX_60.search(chunk3): 3592 address5 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 3593 self._offset = self._offset + 1 3594 else: 3595 address5 = FAILURE 3596 if self._offset > self._failure: 3597 self._failure = self._offset 3598 self._expected = [] 3599 if self._offset == self._failure: 3600 self._expected.append('[\\d]') 3601 if address5 is not FAILURE: 3602 elements0.append(address5) 3603 address6 = FAILURE 3604 chunk4, max4 = None, self._offset + 1 3605 if max4 <= self._input_size: 3606 chunk4 = self._input[self._offset:max4] 3607 if chunk4 is not None and Grammar.REGEX_61.search(chunk4): 3608 address6 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 3609 self._offset = self._offset + 1 3610 else: 3611 address6 = FAILURE 3612 if self._offset > self._failure: 3613 self._failure = self._offset 3614 self._expected = [] 3615 if self._offset == self._failure: 3616 self._expected.append('[\\d]') 3617 if address6 is not FAILURE: 3618 elements0.append(address6) 3619 address7 = FAILURE 3620 index4 = self._offset 3621 chunk5, max5 = None, self._offset + 1 3622 if max5 <= self._input_size: 3623 chunk5 = self._input[self._offset:max5] 3624 if chunk5 == '=': 3625 address7 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 3626 self._offset = self._offset + 1 3627 else: 3628 address7 = FAILURE 3629 if self._offset > self._failure: 3630 self._failure = self._offset 3631 self._expected = [] 3632 if self._offset == self._failure: 3633 self._expected.append('"="') 3634 if address7 is FAILURE: 3635 address7 = TreeNode(self._input[index4:index4], index4, []) 3636 self._offset = index4 3637 if address7 is not FAILURE: 3638 elements0.append(address7) 3639 else: 3640 elements0 = None 3641 self._offset = index2 3642 else: 3643 elements0 = None 3644 self._offset = index2 3645 else: 3646 elements0 = None 3647 self._offset = index2 3648 else: 3649 elements0 = None 3650 self._offset = index2 3651 else: 3652 elements0 = None 3653 self._offset = index2 3654 else: 3655 elements0 = None 3656 self._offset = index2 3657 else: 3658 elements0 = None 3659 self._offset = index2 3660 if elements0 is None: 3661 address0 = FAILURE 3662 else: 3663 address0 = TreeNode(self._input[index2:self._offset], index2, elements0) 3664 self._offset = self._offset 3665 if address0 is FAILURE: 3666 address0 = TreeNode(self._input[index1:index1], index1, []) 3667 self._offset = index1 3668 self._cache['altim'][index0] = (address0, self._offset) 3669 return address0 3670 3671 def _read_remarks(self): 3672 address0, index0 = FAILURE, self._offset 3673 cached = self._cache['remarks'].get(index0) 3674 if cached: 3675 self._offset = cached[1] 3676 return cached[0] 3677 index1 = self._offset 3678 index2, elements0 = self._offset, [] 3679 address1 = FAILURE 3680 index3 = self._offset 3681 address1 = self._read_sep() 3682 if address1 is FAILURE: 3683 address1 = TreeNode(self._input[index3:index3], index3, []) 3684 self._offset = index3 3685 if address1 is not FAILURE: 3686 elements0.append(address1) 3687 address2 = FAILURE 3688 index4 = self._offset 3689 chunk0, max0 = None, self._offset + 3 3690 if max0 <= self._input_size: 3691 chunk0 = self._input[self._offset:max0] 3692 if chunk0 == 'RMK': 3693 address2 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, []) 3694 self._offset = self._offset + 3 3695 else: 3696 address2 = FAILURE 3697 if self._offset > self._failure: 3698 self._failure = self._offset 3699 self._expected = [] 3700 if self._offset == self._failure: 3701 self._expected.append('"RMK"') 3702 if address2 is FAILURE: 3703 self._offset = index4 3704 remaining0, index5, elements1, address3 = 0, self._offset, [], True 3705 while address3 is not FAILURE: 3706 chunk1, max1 = None, self._offset + 5 3707 if max1 <= self._input_size: 3708 chunk1 = self._input[self._offset:max1] 3709 if chunk1 == 'NOSIG': 3710 address3 = TreeNode(self._input[self._offset:self._offset + 5], self._offset, []) 3711 self._offset = self._offset + 5 3712 else: 3713 address3 = FAILURE 3714 if self._offset > self._failure: 3715 self._failure = self._offset 3716 self._expected = [] 3717 if self._offset == self._failure: 3718 self._expected.append('"NOSIG"') 3719 if address3 is not FAILURE: 3720 elements1.append(address3) 3721 remaining0 -= 1 3722 if remaining0 <= 0: 3723 address2 = TreeNode(self._input[index5:self._offset], index5, elements1) 3724 self._offset = self._offset 3725 else: 3726 address2 = FAILURE 3727 if address2 is FAILURE: 3728 self._offset = index4 3729 if address2 is not FAILURE: 3730 elements0.append(address2) 3731 address4 = FAILURE 3732 remaining1, index6, elements2, address5 = 0, self._offset, [], True 3733 while address5 is not FAILURE: 3734 if self._offset < self._input_size: 3735 address5 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 3736 self._offset = self._offset + 1 3737 else: 3738 address5 = FAILURE 3739 if self._offset > self._failure: 3740 self._failure = self._offset 3741 self._expected = [] 3742 if self._offset == self._failure: 3743 self._expected.append('<any char>') 3744 if address5 is not FAILURE: 3745 elements2.append(address5) 3746 remaining1 -= 1 3747 if remaining1 <= 0: 3748 address4 = TreeNode(self._input[index6:self._offset], index6, elements2) 3749 self._offset = self._offset 3750 else: 3751 address4 = FAILURE 3752 if address4 is not FAILURE: 3753 elements0.append(address4) 3754 else: 3755 elements0 = None 3756 self._offset = index2 3757 else: 3758 elements0 = None 3759 self._offset = index2 3760 else: 3761 elements0 = None 3762 self._offset = index2 3763 if elements0 is None: 3764 address0 = FAILURE 3765 else: 3766 address0 = TreeNode(self._input[index2:self._offset], index2, elements0) 3767 self._offset = self._offset 3768 if address0 is FAILURE: 3769 address0 = TreeNode(self._input[index1:index1], index1, []) 3770 self._offset = index1 3771 self._cache['remarks'][index0] = (address0, self._offset) 3772 return address0 3773 3774 def _read_end(self): 3775 address0, index0 = FAILURE, self._offset 3776 cached = self._cache['end'].get(index0) 3777 if cached: 3778 self._offset = cached[1] 3779 return cached[0] 3780 index1 = self._offset 3781 index2, elements0 = self._offset, [] 3782 address1 = FAILURE 3783 index3 = self._offset 3784 address1 = self._read_sep() 3785 if address1 is FAILURE: 3786 address1 = TreeNode(self._input[index3:index3], index3, []) 3787 self._offset = index3 3788 if address1 is not FAILURE: 3789 elements0.append(address1) 3790 address2 = FAILURE 3791 chunk0, max0 = None, self._offset + 1 3792 if max0 <= self._input_size: 3793 chunk0 = self._input[self._offset:max0] 3794 if chunk0 == '=': 3795 address2 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, []) 3796 self._offset = self._offset + 1 3797 else: 3798 address2 = FAILURE 3799 if self._offset > self._failure: 3800 self._failure = self._offset 3801 self._expected = [] 3802 if self._offset == self._failure: 3803 self._expected.append('"="') 3804 if address2 is not FAILURE: 3805 elements0.append(address2) 3806 else: 3807 elements0 = None 3808 self._offset = index2 3809 else: 3810 elements0 = None 3811 self._offset = index2 3812 if elements0 is None: 3813 address0 = FAILURE 3814 else: 3815 address0 = TreeNode(self._input[index2:self._offset], index2, elements0) 3816 self._offset = self._offset 3817 if address0 is FAILURE: 3818 address0 = TreeNode(self._input[index1:index1], index1, []) 3819 self._offset = index1 3820 self._cache['end'][index0] = (address0, self._offset) 3821 return address0 3822 3823 3824class Parser(Grammar): 3825 def __init__(self, input, actions, types): 3826 self._input = input 3827 self._input_size = len(input) 3828 self._actions = actions 3829 self._types = types 3830 self._offset = 0 3831 self._cache = defaultdict(dict) 3832 self._failure = 0 3833 self._expected = [] 3834 3835 def parse(self): 3836 tree = self._read_ob() 3837 if tree is not FAILURE and self._offset == self._input_size: 3838 return tree 3839 if not self._expected: 3840 self._failure = self._offset 3841 self._expected.append('<EOF>') 3842 raise ParseError(format_error(self._input, self._failure, self._expected)) 3843 3844 3845def format_error(input, offset, expected): 3846 lines, line_no, position = input.split('\n'), 0, 0 3847 while position <= offset: 3848 position += len(lines[line_no]) + 1 3849 line_no += 1 3850 message, line = 'Line ' + str(line_no) + ': expected ' + ', '.join(expected) + '\n', lines[line_no - 1] 3851 message += line + '\n' 3852 position -= len(line) + 1 3853 message += ' ' * (offset - position) 3854 return message + '^' 3855 3856def parse(input, actions=None, types=None): 3857 parser = Parser(input, actions, types) 3858 return parser.parse() 3859