1/** 2 * Copyright 2014 Paul Querna 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 * 16 */ 17 18/* Portions of this file are on derived from yajl: <https://github.com/lloyd/yajl> */ 19/* 20 * Copyright (c) 2007-2014, Lloyd Hilaiel <me@lloyd.io> 21 * 22 * Permission to use, copy, modify, and/or distribute this software for any 23 * purpose with or without fee is hereby granted, provided that the above 24 * copyright notice and this permission notice appear in all copies. 25 * 26 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 27 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 28 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 29 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 30 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 31 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 32 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 33 */ 34 35package v1 36 37import ( 38 "errors" 39 "fmt" 40 "io" 41) 42 43type FFParseState int 44 45const ( 46 FFParse_map_start FFParseState = iota 47 FFParse_want_key 48 FFParse_want_colon 49 FFParse_want_value 50 FFParse_after_value 51) 52 53type FFTok int 54 55const ( 56 FFTok_init FFTok = iota 57 FFTok_bool FFTok = iota 58 FFTok_colon FFTok = iota 59 FFTok_comma FFTok = iota 60 FFTok_eof FFTok = iota 61 FFTok_error FFTok = iota 62 FFTok_left_brace FFTok = iota 63 FFTok_left_bracket FFTok = iota 64 FFTok_null FFTok = iota 65 FFTok_right_brace FFTok = iota 66 FFTok_right_bracket FFTok = iota 67 68 /* we differentiate between integers and doubles to allow the 69 * parser to interpret the number without re-scanning */ 70 FFTok_integer FFTok = iota 71 FFTok_double FFTok = iota 72 73 FFTok_string FFTok = iota 74 75 /* comment tokens are not currently returned to the parser, ever */ 76 FFTok_comment FFTok = iota 77) 78 79type FFErr int 80 81const ( 82 FFErr_e_ok FFErr = iota 83 FFErr_io FFErr = iota 84 FFErr_string_invalid_utf8 FFErr = iota 85 FFErr_string_invalid_escaped_char FFErr = iota 86 FFErr_string_invalid_json_char FFErr = iota 87 FFErr_string_invalid_hex_char FFErr = iota 88 FFErr_invalid_char FFErr = iota 89 FFErr_invalid_string FFErr = iota 90 FFErr_missing_integer_after_decimal FFErr = iota 91 FFErr_missing_integer_after_exponent FFErr = iota 92 FFErr_missing_integer_after_minus FFErr = iota 93 FFErr_unallowed_comment FFErr = iota 94 FFErr_incomplete_comment FFErr = iota 95 FFErr_unexpected_token_type FFErr = iota // TODO: improve this error 96) 97 98type FFLexer struct { 99 reader *ffReader 100 Output DecodingBuffer 101 Token FFTok 102 Error FFErr 103 BigError error 104 // TODO: convert all of this to an interface 105 lastCurrentChar int 106 captureAll bool 107 buf Buffer 108} 109 110func NewFFLexer(input []byte) *FFLexer { 111 fl := &FFLexer{ 112 Token: FFTok_init, 113 Error: FFErr_e_ok, 114 reader: newffReader(input), 115 Output: &Buffer{}, 116 } 117 // TODO: guess size? 118 //fl.Output.Grow(64) 119 return fl 120} 121 122type LexerError struct { 123 offset int 124 line int 125 char int 126 err error 127} 128 129// Reset the Lexer and add new input. 130func (ffl *FFLexer) Reset(input []byte) { 131 ffl.Token = FFTok_init 132 ffl.Error = FFErr_e_ok 133 ffl.BigError = nil 134 ffl.reader.Reset(input) 135 ffl.lastCurrentChar = 0 136 ffl.Output.Reset() 137} 138 139func (le *LexerError) Error() string { 140 return fmt.Sprintf(`ffjson error: (%T)%s offset=%d line=%d char=%d`, 141 le.err, le.err.Error(), 142 le.offset, le.line, le.char) 143} 144 145func (ffl *FFLexer) WrapErr(err error) error { 146 line, char := ffl.reader.PosWithLine() 147 // TOOD: calcualte lines/characters based on offset 148 return &LexerError{ 149 offset: ffl.reader.Pos(), 150 line: line, 151 char: char, 152 err: err, 153 } 154} 155 156func (ffl *FFLexer) scanReadByte() (byte, error) { 157 var c byte 158 var err error 159 if ffl.captureAll { 160 c, err = ffl.reader.ReadByte() 161 } else { 162 c, err = ffl.reader.ReadByteNoWS() 163 } 164 165 if err != nil { 166 ffl.Error = FFErr_io 167 ffl.BigError = err 168 return 0, err 169 } 170 171 return c, nil 172} 173 174func (ffl *FFLexer) readByte() (byte, error) { 175 176 c, err := ffl.reader.ReadByte() 177 if err != nil { 178 ffl.Error = FFErr_io 179 ffl.BigError = err 180 return 0, err 181 } 182 183 return c, nil 184} 185 186func (ffl *FFLexer) unreadByte() { 187 ffl.reader.UnreadByte() 188} 189 190func (ffl *FFLexer) wantBytes(want []byte, iftrue FFTok) FFTok { 191 for _, b := range want { 192 c, err := ffl.readByte() 193 194 if err != nil { 195 return FFTok_error 196 } 197 198 if c != b { 199 ffl.unreadByte() 200 // fmt.Printf("wanted bytes: %s\n", string(want)) 201 // TODO(pquerna): thsi is a bad error message 202 ffl.Error = FFErr_invalid_string 203 return FFTok_error 204 } 205 206 ffl.Output.WriteByte(c) 207 } 208 209 return iftrue 210} 211 212func (ffl *FFLexer) lexComment() FFTok { 213 c, err := ffl.readByte() 214 if err != nil { 215 return FFTok_error 216 } 217 218 if c == '/' { 219 // a // comment, scan until line ends. 220 for { 221 c, err := ffl.readByte() 222 if err != nil { 223 return FFTok_error 224 } 225 226 if c == '\n' { 227 return FFTok_comment 228 } 229 } 230 } else if c == '*' { 231 // a /* */ comment, scan */ 232 for { 233 c, err := ffl.readByte() 234 if err != nil { 235 return FFTok_error 236 } 237 238 if c == '*' { 239 c, err := ffl.readByte() 240 241 if err != nil { 242 return FFTok_error 243 } 244 245 if c == '/' { 246 return FFTok_comment 247 } 248 249 ffl.Error = FFErr_incomplete_comment 250 return FFTok_error 251 } 252 } 253 } else { 254 ffl.Error = FFErr_incomplete_comment 255 return FFTok_error 256 } 257} 258 259func (ffl *FFLexer) lexString() FFTok { 260 if ffl.captureAll { 261 ffl.buf.Reset() 262 err := ffl.reader.SliceString(&ffl.buf) 263 264 if err != nil { 265 ffl.BigError = err 266 return FFTok_error 267 } 268 269 WriteJson(ffl.Output, ffl.buf.Bytes()) 270 271 return FFTok_string 272 } else { 273 err := ffl.reader.SliceString(ffl.Output) 274 275 if err != nil { 276 ffl.BigError = err 277 return FFTok_error 278 } 279 280 return FFTok_string 281 } 282} 283 284func (ffl *FFLexer) lexNumber() FFTok { 285 var numRead int = 0 286 tok := FFTok_integer 287 288 c, err := ffl.readByte() 289 if err != nil { 290 return FFTok_error 291 } 292 293 /* optional leading minus */ 294 if c == '-' { 295 ffl.Output.WriteByte(c) 296 c, err = ffl.readByte() 297 if err != nil { 298 return FFTok_error 299 } 300 } 301 302 /* a single zero, or a series of integers */ 303 if c == '0' { 304 ffl.Output.WriteByte(c) 305 c, err = ffl.readByte() 306 if err != nil { 307 return FFTok_error 308 } 309 } else if c >= '1' && c <= '9' { 310 for c >= '0' && c <= '9' { 311 ffl.Output.WriteByte(c) 312 c, err = ffl.readByte() 313 if err != nil { 314 return FFTok_error 315 } 316 } 317 } else { 318 ffl.unreadByte() 319 ffl.Error = FFErr_missing_integer_after_minus 320 return FFTok_error 321 } 322 323 if c == '.' { 324 numRead = 0 325 ffl.Output.WriteByte(c) 326 c, err = ffl.readByte() 327 if err != nil { 328 return FFTok_error 329 } 330 331 for c >= '0' && c <= '9' { 332 ffl.Output.WriteByte(c) 333 numRead++ 334 c, err = ffl.readByte() 335 if err != nil { 336 return FFTok_error 337 } 338 } 339 340 if numRead == 0 { 341 ffl.unreadByte() 342 343 ffl.Error = FFErr_missing_integer_after_decimal 344 return FFTok_error 345 } 346 347 tok = FFTok_double 348 } 349 350 /* optional exponent (indicates this is floating point) */ 351 if c == 'e' || c == 'E' { 352 numRead = 0 353 ffl.Output.WriteByte(c) 354 355 c, err = ffl.readByte() 356 if err != nil { 357 return FFTok_error 358 } 359 360 /* optional sign */ 361 if c == '+' || c == '-' { 362 ffl.Output.WriteByte(c) 363 c, err = ffl.readByte() 364 if err != nil { 365 return FFTok_error 366 } 367 } 368 369 for c >= '0' && c <= '9' { 370 ffl.Output.WriteByte(c) 371 numRead++ 372 c, err = ffl.readByte() 373 if err != nil { 374 return FFTok_error 375 } 376 } 377 378 if numRead == 0 { 379 ffl.Error = FFErr_missing_integer_after_exponent 380 return FFTok_error 381 } 382 383 tok = FFTok_double 384 } 385 386 ffl.unreadByte() 387 388 return tok 389} 390 391var true_bytes = []byte{'r', 'u', 'e'} 392var false_bytes = []byte{'a', 'l', 's', 'e'} 393var null_bytes = []byte{'u', 'l', 'l'} 394 395func (ffl *FFLexer) Scan() FFTok { 396 tok := FFTok_error 397 if ffl.captureAll == false { 398 ffl.Output.Reset() 399 } 400 ffl.Token = FFTok_init 401 402 for { 403 c, err := ffl.scanReadByte() 404 if err != nil { 405 if err == io.EOF { 406 return FFTok_eof 407 } else { 408 return FFTok_error 409 } 410 } 411 412 switch c { 413 case '{': 414 tok = FFTok_left_bracket 415 if ffl.captureAll { 416 ffl.Output.WriteByte('{') 417 } 418 goto lexed 419 case '}': 420 tok = FFTok_right_bracket 421 if ffl.captureAll { 422 ffl.Output.WriteByte('}') 423 } 424 goto lexed 425 case '[': 426 tok = FFTok_left_brace 427 if ffl.captureAll { 428 ffl.Output.WriteByte('[') 429 } 430 goto lexed 431 case ']': 432 tok = FFTok_right_brace 433 if ffl.captureAll { 434 ffl.Output.WriteByte(']') 435 } 436 goto lexed 437 case ',': 438 tok = FFTok_comma 439 if ffl.captureAll { 440 ffl.Output.WriteByte(',') 441 } 442 goto lexed 443 case ':': 444 tok = FFTok_colon 445 if ffl.captureAll { 446 ffl.Output.WriteByte(':') 447 } 448 goto lexed 449 case '\t', '\n', '\v', '\f', '\r', ' ': 450 if ffl.captureAll { 451 ffl.Output.WriteByte(c) 452 } 453 break 454 case 't': 455 ffl.Output.WriteByte('t') 456 tok = ffl.wantBytes(true_bytes, FFTok_bool) 457 goto lexed 458 case 'f': 459 ffl.Output.WriteByte('f') 460 tok = ffl.wantBytes(false_bytes, FFTok_bool) 461 goto lexed 462 case 'n': 463 ffl.Output.WriteByte('n') 464 tok = ffl.wantBytes(null_bytes, FFTok_null) 465 goto lexed 466 case '"': 467 tok = ffl.lexString() 468 goto lexed 469 case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9': 470 ffl.unreadByte() 471 tok = ffl.lexNumber() 472 goto lexed 473 case '/': 474 tok = ffl.lexComment() 475 goto lexed 476 default: 477 tok = FFTok_error 478 ffl.Error = FFErr_invalid_char 479 } 480 } 481 482lexed: 483 ffl.Token = tok 484 return tok 485} 486 487func (ffl *FFLexer) scanField(start FFTok, capture bool) ([]byte, error) { 488 switch start { 489 case FFTok_left_brace, 490 FFTok_left_bracket: 491 { 492 end := FFTok_right_brace 493 if start == FFTok_left_bracket { 494 end = FFTok_right_bracket 495 if capture { 496 ffl.Output.WriteByte('{') 497 } 498 } else { 499 if capture { 500 ffl.Output.WriteByte('[') 501 } 502 } 503 504 depth := 1 505 if capture { 506 ffl.captureAll = true 507 } 508 // TODO: work. 509 scanloop: 510 for { 511 tok := ffl.Scan() 512 //fmt.Printf("capture-token: %v end: %v depth: %v\n", tok, end, depth) 513 switch tok { 514 case FFTok_eof: 515 return nil, errors.New("ffjson: unexpected EOF") 516 case FFTok_error: 517 if ffl.BigError != nil { 518 return nil, ffl.BigError 519 } 520 return nil, ffl.Error.ToError() 521 case end: 522 depth-- 523 if depth == 0 { 524 break scanloop 525 } 526 case start: 527 depth++ 528 } 529 } 530 531 if capture { 532 ffl.captureAll = false 533 } 534 535 if capture { 536 return ffl.Output.Bytes(), nil 537 } else { 538 return nil, nil 539 } 540 } 541 case FFTok_bool, 542 FFTok_integer, 543 FFTok_null, 544 FFTok_double: 545 // simple value, return it. 546 if capture { 547 return ffl.Output.Bytes(), nil 548 } else { 549 return nil, nil 550 } 551 552 case FFTok_string: 553 //TODO(pquerna): so, other users expect this to be a quoted string :( 554 if capture { 555 ffl.buf.Reset() 556 WriteJson(&ffl.buf, ffl.Output.Bytes()) 557 return ffl.buf.Bytes(), nil 558 } else { 559 return nil, nil 560 } 561 562 default: 563 return nil, fmt.Errorf("ffjson: invalid capture type: %v", start) 564 } 565 panic("not reached") 566} 567 568// Captures an entire field value, including recursive objects, 569// and converts them to a []byte suitable to pass to a sub-object's 570// UnmarshalJSON 571func (ffl *FFLexer) CaptureField(start FFTok) ([]byte, error) { 572 return ffl.scanField(start, true) 573} 574 575func (ffl *FFLexer) SkipField(start FFTok) error { 576 _, err := ffl.scanField(start, false) 577 return err 578} 579 580// TODO(pquerna): return line number and offset. 581func (err FFErr) ToError() error { 582 switch err { 583 case FFErr_e_ok: 584 return nil 585 case FFErr_io: 586 return errors.New("ffjson: IO error") 587 case FFErr_string_invalid_utf8: 588 return errors.New("ffjson: string with invalid UTF-8 sequence") 589 case FFErr_string_invalid_escaped_char: 590 return errors.New("ffjson: string with invalid escaped character") 591 case FFErr_string_invalid_json_char: 592 return errors.New("ffjson: string with invalid JSON character") 593 case FFErr_string_invalid_hex_char: 594 return errors.New("ffjson: string with invalid hex character") 595 case FFErr_invalid_char: 596 return errors.New("ffjson: invalid character") 597 case FFErr_invalid_string: 598 return errors.New("ffjson: invalid string") 599 case FFErr_missing_integer_after_decimal: 600 return errors.New("ffjson: missing integer after decimal") 601 case FFErr_missing_integer_after_exponent: 602 return errors.New("ffjson: missing integer after exponent") 603 case FFErr_missing_integer_after_minus: 604 return errors.New("ffjson: missing integer after minus") 605 case FFErr_unallowed_comment: 606 return errors.New("ffjson: unallowed comment") 607 case FFErr_incomplete_comment: 608 return errors.New("ffjson: incomplete comment") 609 case FFErr_unexpected_token_type: 610 return errors.New("ffjson: unexpected token sequence") 611 } 612 613 panic(fmt.Sprintf("unknown error type: %v ", err)) 614} 615 616func (state FFParseState) String() string { 617 switch state { 618 case FFParse_map_start: 619 return "map:start" 620 case FFParse_want_key: 621 return "want_key" 622 case FFParse_want_colon: 623 return "want_colon" 624 case FFParse_want_value: 625 return "want_value" 626 case FFParse_after_value: 627 return "after_value" 628 } 629 630 panic(fmt.Sprintf("unknown parse state: %d", int(state))) 631} 632 633func (tok FFTok) String() string { 634 switch tok { 635 case FFTok_init: 636 return "tok:init" 637 case FFTok_bool: 638 return "tok:bool" 639 case FFTok_colon: 640 return "tok:colon" 641 case FFTok_comma: 642 return "tok:comma" 643 case FFTok_eof: 644 return "tok:eof" 645 case FFTok_error: 646 return "tok:error" 647 case FFTok_left_brace: 648 return "tok:left_brace" 649 case FFTok_left_bracket: 650 return "tok:left_bracket" 651 case FFTok_null: 652 return "tok:null" 653 case FFTok_right_brace: 654 return "tok:right_brace" 655 case FFTok_right_bracket: 656 return "tok:right_bracket" 657 case FFTok_integer: 658 return "tok:integer" 659 case FFTok_double: 660 return "tok:double" 661 case FFTok_string: 662 return "tok:string" 663 case FFTok_comment: 664 return "comment" 665 } 666 667 panic(fmt.Sprintf("unknown token: %d", int(tok))) 668} 669 670/* a lookup table which lets us quickly determine three things: 671 * cVEC - valid escaped control char 672 * note. the solidus '/' may be escaped or not. 673 * cIJC - invalid json char 674 * cVHC - valid hex char 675 * cNFP - needs further processing (from a string scanning perspective) 676 * cNUC - needs utf8 checking when enabled (from a string scanning perspective) 677 */ 678 679const ( 680 cVEC int8 = 0x01 681 cIJC int8 = 0x02 682 cVHC int8 = 0x04 683 cNFP int8 = 0x08 684 cNUC int8 = 0x10 685) 686 687var byteLookupTable [256]int8 = [256]int8{ 688 cIJC, /* 0 */ 689 cIJC, /* 1 */ 690 cIJC, /* 2 */ 691 cIJC, /* 3 */ 692 cIJC, /* 4 */ 693 cIJC, /* 5 */ 694 cIJC, /* 6 */ 695 cIJC, /* 7 */ 696 cIJC, /* 8 */ 697 cIJC, /* 9 */ 698 cIJC, /* 10 */ 699 cIJC, /* 11 */ 700 cIJC, /* 12 */ 701 cIJC, /* 13 */ 702 cIJC, /* 14 */ 703 cIJC, /* 15 */ 704 cIJC, /* 16 */ 705 cIJC, /* 17 */ 706 cIJC, /* 18 */ 707 cIJC, /* 19 */ 708 cIJC, /* 20 */ 709 cIJC, /* 21 */ 710 cIJC, /* 22 */ 711 cIJC, /* 23 */ 712 cIJC, /* 24 */ 713 cIJC, /* 25 */ 714 cIJC, /* 26 */ 715 cIJC, /* 27 */ 716 cIJC, /* 28 */ 717 cIJC, /* 29 */ 718 cIJC, /* 30 */ 719 cIJC, /* 31 */ 720 0, /* 32 */ 721 0, /* 33 */ 722 cVEC | cIJC | cNFP, /* 34 */ 723 0, /* 35 */ 724 0, /* 36 */ 725 0, /* 37 */ 726 0, /* 38 */ 727 0, /* 39 */ 728 0, /* 40 */ 729 0, /* 41 */ 730 0, /* 42 */ 731 0, /* 43 */ 732 0, /* 44 */ 733 0, /* 45 */ 734 0, /* 46 */ 735 cVEC, /* 47 */ 736 cVHC, /* 48 */ 737 cVHC, /* 49 */ 738 cVHC, /* 50 */ 739 cVHC, /* 51 */ 740 cVHC, /* 52 */ 741 cVHC, /* 53 */ 742 cVHC, /* 54 */ 743 cVHC, /* 55 */ 744 cVHC, /* 56 */ 745 cVHC, /* 57 */ 746 0, /* 58 */ 747 0, /* 59 */ 748 0, /* 60 */ 749 0, /* 61 */ 750 0, /* 62 */ 751 0, /* 63 */ 752 0, /* 64 */ 753 cVHC, /* 65 */ 754 cVHC, /* 66 */ 755 cVHC, /* 67 */ 756 cVHC, /* 68 */ 757 cVHC, /* 69 */ 758 cVHC, /* 70 */ 759 0, /* 71 */ 760 0, /* 72 */ 761 0, /* 73 */ 762 0, /* 74 */ 763 0, /* 75 */ 764 0, /* 76 */ 765 0, /* 77 */ 766 0, /* 78 */ 767 0, /* 79 */ 768 0, /* 80 */ 769 0, /* 81 */ 770 0, /* 82 */ 771 0, /* 83 */ 772 0, /* 84 */ 773 0, /* 85 */ 774 0, /* 86 */ 775 0, /* 87 */ 776 0, /* 88 */ 777 0, /* 89 */ 778 0, /* 90 */ 779 0, /* 91 */ 780 cVEC | cIJC | cNFP, /* 92 */ 781 0, /* 93 */ 782 0, /* 94 */ 783 0, /* 95 */ 784 0, /* 96 */ 785 cVHC, /* 97 */ 786 cVEC | cVHC, /* 98 */ 787 cVHC, /* 99 */ 788 cVHC, /* 100 */ 789 cVHC, /* 101 */ 790 cVEC | cVHC, /* 102 */ 791 0, /* 103 */ 792 0, /* 104 */ 793 0, /* 105 */ 794 0, /* 106 */ 795 0, /* 107 */ 796 0, /* 108 */ 797 0, /* 109 */ 798 cVEC, /* 110 */ 799 0, /* 111 */ 800 0, /* 112 */ 801 0, /* 113 */ 802 cVEC, /* 114 */ 803 0, /* 115 */ 804 cVEC, /* 116 */ 805 0, /* 117 */ 806 0, /* 118 */ 807 0, /* 119 */ 808 0, /* 120 */ 809 0, /* 121 */ 810 0, /* 122 */ 811 0, /* 123 */ 812 0, /* 124 */ 813 0, /* 125 */ 814 0, /* 126 */ 815 0, /* 127 */ 816 cNUC, /* 128 */ 817 cNUC, /* 129 */ 818 cNUC, /* 130 */ 819 cNUC, /* 131 */ 820 cNUC, /* 132 */ 821 cNUC, /* 133 */ 822 cNUC, /* 134 */ 823 cNUC, /* 135 */ 824 cNUC, /* 136 */ 825 cNUC, /* 137 */ 826 cNUC, /* 138 */ 827 cNUC, /* 139 */ 828 cNUC, /* 140 */ 829 cNUC, /* 141 */ 830 cNUC, /* 142 */ 831 cNUC, /* 143 */ 832 cNUC, /* 144 */ 833 cNUC, /* 145 */ 834 cNUC, /* 146 */ 835 cNUC, /* 147 */ 836 cNUC, /* 148 */ 837 cNUC, /* 149 */ 838 cNUC, /* 150 */ 839 cNUC, /* 151 */ 840 cNUC, /* 152 */ 841 cNUC, /* 153 */ 842 cNUC, /* 154 */ 843 cNUC, /* 155 */ 844 cNUC, /* 156 */ 845 cNUC, /* 157 */ 846 cNUC, /* 158 */ 847 cNUC, /* 159 */ 848 cNUC, /* 160 */ 849 cNUC, /* 161 */ 850 cNUC, /* 162 */ 851 cNUC, /* 163 */ 852 cNUC, /* 164 */ 853 cNUC, /* 165 */ 854 cNUC, /* 166 */ 855 cNUC, /* 167 */ 856 cNUC, /* 168 */ 857 cNUC, /* 169 */ 858 cNUC, /* 170 */ 859 cNUC, /* 171 */ 860 cNUC, /* 172 */ 861 cNUC, /* 173 */ 862 cNUC, /* 174 */ 863 cNUC, /* 175 */ 864 cNUC, /* 176 */ 865 cNUC, /* 177 */ 866 cNUC, /* 178 */ 867 cNUC, /* 179 */ 868 cNUC, /* 180 */ 869 cNUC, /* 181 */ 870 cNUC, /* 182 */ 871 cNUC, /* 183 */ 872 cNUC, /* 184 */ 873 cNUC, /* 185 */ 874 cNUC, /* 186 */ 875 cNUC, /* 187 */ 876 cNUC, /* 188 */ 877 cNUC, /* 189 */ 878 cNUC, /* 190 */ 879 cNUC, /* 191 */ 880 cNUC, /* 192 */ 881 cNUC, /* 193 */ 882 cNUC, /* 194 */ 883 cNUC, /* 195 */ 884 cNUC, /* 196 */ 885 cNUC, /* 197 */ 886 cNUC, /* 198 */ 887 cNUC, /* 199 */ 888 cNUC, /* 200 */ 889 cNUC, /* 201 */ 890 cNUC, /* 202 */ 891 cNUC, /* 203 */ 892 cNUC, /* 204 */ 893 cNUC, /* 205 */ 894 cNUC, /* 206 */ 895 cNUC, /* 207 */ 896 cNUC, /* 208 */ 897 cNUC, /* 209 */ 898 cNUC, /* 210 */ 899 cNUC, /* 211 */ 900 cNUC, /* 212 */ 901 cNUC, /* 213 */ 902 cNUC, /* 214 */ 903 cNUC, /* 215 */ 904 cNUC, /* 216 */ 905 cNUC, /* 217 */ 906 cNUC, /* 218 */ 907 cNUC, /* 219 */ 908 cNUC, /* 220 */ 909 cNUC, /* 221 */ 910 cNUC, /* 222 */ 911 cNUC, /* 223 */ 912 cNUC, /* 224 */ 913 cNUC, /* 225 */ 914 cNUC, /* 226 */ 915 cNUC, /* 227 */ 916 cNUC, /* 228 */ 917 cNUC, /* 229 */ 918 cNUC, /* 230 */ 919 cNUC, /* 231 */ 920 cNUC, /* 232 */ 921 cNUC, /* 233 */ 922 cNUC, /* 234 */ 923 cNUC, /* 235 */ 924 cNUC, /* 236 */ 925 cNUC, /* 237 */ 926 cNUC, /* 238 */ 927 cNUC, /* 239 */ 928 cNUC, /* 240 */ 929 cNUC, /* 241 */ 930 cNUC, /* 242 */ 931 cNUC, /* 243 */ 932 cNUC, /* 244 */ 933 cNUC, /* 245 */ 934 cNUC, /* 246 */ 935 cNUC, /* 247 */ 936 cNUC, /* 248 */ 937 cNUC, /* 249 */ 938 cNUC, /* 250 */ 939 cNUC, /* 251 */ 940 cNUC, /* 252 */ 941 cNUC, /* 253 */ 942 cNUC, /* 254 */ 943 cNUC, /* 255 */ 944} 945