Find Usages Diff Raw Download HTML Widget
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions 
1
   /*
2
    * Copyright 2000-2013  The Apache Software Foundation
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
  package org.whattf.datatype;
19
  
22
  
24
  
25
  public class SvgPathData extends AbstractDatatype {

    
Package-private constructor 
29
  
30
      protected SvgPathData() {
31
          super();
32
      }
33
  
34
      private static StringReader reader;
35
  
36
      private static StringBuilder context;
37
  
38
      private static final int MAX_CONTEXT_LENGTH = 20;
39
  
40
      private void appendToContext(int i) {
41
          if (i != -1) {
42
              if (.length() == ) {
43
                  .deleteCharAt(0);
44
              }
45
              .append((char) i);
46
          }
47
      }

    
The current character. 
51
  
52
      private int current;
53
  
54
      @Override public void checkValid(CharSequence literal)
55
              throws DatatypeException {
56
  
57
           = new StringReader(literal.toString());
58
           = new StringBuilder();
59
  
60
          try {
61
               = .read();
62
              appendToContext();
63
          } catch (IOException e) {
64
              throw new RuntimeException(e);
65
          }
66
  
67
          loop: for (;;) {
68
              try {
69
                  switch () {
70
                      case 0xD:
71
                      case 0xA:
72
                      case 0x20:
73
                      case 0x9:
74
                           = .read();
75
                          appendToContext();
76
                          break;
77
                      case 'z':
78
                      case 'Z':
79
                           = .read();
80
                          appendToContext();
81
                          break;
82
                      case 'm':
83
                          checkm();
84
                          break;
85
                      case 'M':
86
                          checkM();
87
                          break;
88
                      case 'l':
89
                          checkl();
90
                          break;
91
                      case 'L':
92
                          checkL();
93
                          break;
94
                      case 'h':
95
                          checkh();
96
                          break;
97
                      case 'H':
98
                          checkH();
99
                          break;
100
                     case 'v':
101
                         checkv();
102
                         break;
103
                     case 'V':
104
                         checkV();
105
                         break;
106
                     case 'c':
107
                         checkc();
108
                         break;
109
                     case 'C':
110
                         checkC();
111
                         break;
112
                     case 'q':
113
                         checkq();
114
                         break;
115
                     case 'Q':
116
                         checkQ();
117
                         break;
118
                     case 's':
119
                         checks();
120
                         break;
121
                     case 'S':
122
                         checkS();
123
                         break;
124
                     case 't':
125
                         checkt();
126
                         break;
127
                     case 'T':
128
                         checkT();
129
                         break;
130
                     case 'a':
131
                         checka();
132
                         break;
133
                     case 'A':
134
                         checkA();
135
                         break;
136
                     case -1:
137
                         break loop;
138
                     default:
139
                         throw newDatatypeException("Expected command but "
140
                                 + "found \u201c" + (char) 
141
                                 + "\u201d (context: \u201c"
142
                                 + .toString() + "\u201d).");
143
                 }
144
             } catch (IOException e) {
145
                 try {
146
                     skipSubPath();
147
                 } catch (IOException ioe) {
148
                     throw new RuntimeException(ioe);
149
                 }
150
                 throw new RuntimeException(e);
151
             }
152
         }
153
 
154
         try {
155
             skipSpaces();
156
             if ( != -1) {
157
                 throw newDatatypeException("Found unexpected character "
158
                         + "\u201c" + (char)  + "\u201d.");
159
             }
160
         } catch (IOException e) {
161
             throw new RuntimeException(e);
162
         }
163
     }

    
Checks an 'm' command. 
167
 
168
     private void checkm() throws DatatypeException, IOException {
169
         if (.length() == 0) {
170
             appendToContext();
171
         }
172
          = .read();
173
         appendToContext();
174
         skipSpaces();
175
 
176
         checkArg('m', "x coordinate");
177
         skipCommaSpaces();
178
         checkArg('m', "y coordinate");
179
 
180
         boolean expectNumber = skipCommaSpaces2();
181
         _checkl('m', expectNumber);
182
     }

    
Checks an 'M' command. 
186
 
187
     private void checkM() throws DatatypeException, IOException {
188
         if (.length() == 0) {
189
             appendToContext();
190
         }
191
          = .read();
192
         appendToContext();
193
         skipSpaces();
194
 
195
         checkArg('M', "x coordinate");
196
         skipCommaSpaces();
197
         checkArg('M', "y coordinate");
198
 
199
         boolean expectNumber = skipCommaSpaces2();
200
         _checkL('M', expectNumber);
201
     }

    
Checks an 'l' command. 
205
 
206
     private void checkl() throws DatatypeException, IOException {
207
         if (.length() == 0) {
208
             appendToContext();
209
         }
210
          = .read();
211
         appendToContext();
212
         skipSpaces();
213
         _checkl('l', true);
214
     }
215
 
216
     private void _checkl(char command, boolean expectNumber)
217
             throws IOException, DatatypeException {
218
         for (;;) {
219
             switch () {
220
                 default:
221
                     if (expectNumber) {
222
                         reportUnexpected("coordinate pair for " + "\u201c"
223
                                 + command + "\u201d command", );
224
                         skipSubPath();
225
                     }
226
                     return;
227
                 case '+':
228
                 case '-':
229
                 case '.':
230
                 case '0':
231
                 case '1':
232
                 case '2':
233
                 case '3':
234
                 case '4':
235
                 case '5':
236
                 case '6':
237
                 case '7':
238
                 case '8':
239
                 case '9':
240
                     break;
241
             }
242
             checkArg(command, "x coordinate");
243
             skipCommaSpaces();
244
             checkArg(command, "y coordinate");
245
 
246
             expectNumber = skipCommaSpaces2();
247
         }
248
     }

    
Checks an 'L' command. 
252
 
253
     private void checkL() throws DatatypeException, IOException {
254
         if (.length() == 0) {
255
             appendToContext();
256
         }
257
          = .read();
258
         appendToContext();
259
         skipSpaces();
260
         _checkL('L', true);
261
     }
262
 
263
     private void _checkL(char command, boolean expectNumber)
264
             throws IOException, DatatypeException {
265
         for (;;) {
266
             switch () {
267
                 default:
268
                     if (expectNumber) {
269
                         reportUnexpected("coordinate pair for " + "\u201c"
270
                                 + command + "\u201d command", );
271
                         skipSubPath();
272
                     }
273
                     return;
274
                 case '+':
275
                 case '-':
276
                 case '.':
277
                 case '0':
278
                 case '1':
279
                 case '2':
280
                 case '3':
281
                 case '4':
282
                 case '5':
283
                 case '6':
284
                 case '7':
285
                 case '8':
286
                 case '9':
287
                     break;
288
             }
289
             checkArg(command, "x coordinate");
290
             skipCommaSpaces();
291
             checkArg(command, "y coordinate");
292
 
293
             expectNumber = skipCommaSpaces2();
294
         }
295
     }

    
Checks an 'h' command. 
299
 
300
     private void checkh() throws DatatypeException, IOException {
301
         if (.length() == 0) {
302
             appendToContext();
303
         }
304
          = .read();
305
         appendToContext();
306
         skipSpaces();
307
         boolean expectNumber = true;
308
 
309
         for (;;) {
310
             switch () {
311
                 default:
312
                     if (expectNumber)
313
                         reportNonNumber('h', );
314
                     return;
315
 
316
                 case '+':
317
                 case '-':
318
                 case '.':
319
                 case '0':
320
                 case '1':
321
                 case '2':
322
                 case '3':
323
                 case '4':
324
                 case '5':
325
                 case '6':
326
                 case '7':
327
                 case '8':
328
                 case '9':
329
                     break;
330
             }
331
             checkArg('h', "x coordinate");
332
 
333
             expectNumber = skipCommaSpaces2();
334
         }
335
     }

    
Checks an 'H' command. 
339
 
340
     private void checkH() throws DatatypeException, IOException {
341
         if (.length() == 0) {
342
             appendToContext();
343
         }
344
          = .read();
345
         appendToContext();
346
         skipSpaces();
347
         boolean expectNumber = true;
348
 
349
         for (;;) {
350
             switch () {
351
                 default:
352
                     if (expectNumber)
353
                         reportNonNumber('H', );
354
                     return;
355
 
356
                 case '+':
357
                 case '-':
358
                 case '.':
359
                 case '0':
360
                 case '1':
361
                 case '2':
362
                 case '3':
363
                 case '4':
364
                 case '5':
365
                 case '6':
366
                 case '7':
367
                 case '8':
368
                 case '9':
369
                     break;
370
             }
371
             checkArg('H', "x coordinate");
372
 
373
             expectNumber = skipCommaSpaces2();
374
         }
375
     }

    
Checks a 'v' command. 
379
 
380
     private void checkv() throws DatatypeException, IOException {
381
         if (.length() == 0) {
382
             appendToContext();
383
         }
384
          = .read();
385
         appendToContext();
386
         skipSpaces();
387
         boolean expectNumber = true;
388
 
389
         for (;;) {
390
             switch () {
391
                 default:
392
                     if (expectNumber)
393
                         reportNonNumber('v', );
394
                     return;
395
 
396
                 case '+':
397
                 case '-':
398
                 case '.':
399
                 case '0':
400
                 case '1':
401
                 case '2':
402
                 case '3':
403
                 case '4':
404
                 case '5':
405
                 case '6':
406
                 case '7':
407
                 case '8':
408
                 case '9':
409
                     break;
410
             }
411
             checkArg('v', "y coordinate");
412
 
413
             expectNumber = skipCommaSpaces2();
414
         }
415
     }

    
Checks a 'V' command. 
419
 
420
     private void checkV() throws DatatypeException, IOException {
421
         if (.length() == 0) {
422
             appendToContext();
423
         }
424
          = .read();
425
         appendToContext();
426
         skipSpaces();
427
         boolean expectNumber = true;
428
 
429
         for (;;) {
430
             switch () {
431
                 default:
432
                     if (expectNumber)
433
                         reportNonNumber('V', );
434
                     return;
435
 
436
                 case '+':
437
                 case '-':
438
                 case '.':
439
                 case '0':
440
                 case '1':
441
                 case '2':
442
                 case '3':
443
                 case '4':
444
                 case '5':
445
                 case '6':
446
                 case '7':
447
                 case '8':
448
                 case '9':
449
                     break;
450
             }
451
             checkArg('V', "y coordinate");
452
 
453
             expectNumber = skipCommaSpaces2();
454
         }
455
     }

    
Checks a 'c' command. 
459
 
460
     private void checkc() throws DatatypeException, IOException {
461
         if (.length() == 0) {
462
             appendToContext();
463
         }
464
          = .read();
465
         appendToContext();
466
         skipSpaces();
467
         boolean expectNumber = true;
468
 
469
         for (;;) {
470
             switch () {
471
                 default:
472
                     if (expectNumber)
473
                         reportNonNumber('c', );
474
                     return;
475
 
476
                 case '+':
477
                 case '-':
478
                 case '.':
479
                 case '0':
480
                 case '1':
481
                 case '2':
482
                 case '3':
483
                 case '4':
484
                 case '5':
485
                 case '6':
486
                 case '7':
487
                 case '8':
488
                 case '9':
489
                     break;
490
             }
491
 
492
             checkArg('c', "x1 coordinate");
493
             skipCommaSpaces();
494
             checkArg('c', "y1 coordinate");
495
             skipCommaSpaces();
496
             checkArg('c', "x2 coordinate");
497
             skipCommaSpaces();
498
             checkArg('c', "y2 coordinate");
499
             skipCommaSpaces();
500
             checkArg('c', "x coordinate");
501
             skipCommaSpaces();
502
             checkArg('c', "y coordinate");
503
 
504
             expectNumber = skipCommaSpaces2();
505
         }
506
     }

    
Checks a 'C' command. 
510
 
511
     private void checkC() throws DatatypeException, IOException {
512
         if (.length() == 0) {
513
             appendToContext();
514
         }
515
          = .read();
516
         appendToContext();
517
         skipSpaces();
518
         boolean expectNumber = true;
519
 
520
         for (;;) {
521
             switch () {
522
                 default:
523
                     if (expectNumber)
524
                         reportNonNumber('C', );
525
                     return;
526
 
527
                 case '+':
528
                 case '-':
529
                 case '.':
530
                 case '0':
531
                 case '1':
532
                 case '2':
533
                 case '3':
534
                 case '4':
535
                 case '5':
536
                 case '6':
537
                 case '7':
538
                 case '8':
539
                 case '9':
540
                     break;
541
             }
542
 
543
             checkArg('C', "x1 coordinate");
544
             skipCommaSpaces();
545
             checkArg('C', "y1 coordinate");
546
             skipCommaSpaces();
547
             checkArg('C', "x2 coordinate");
548
             skipCommaSpaces();
549
             checkArg('C', "y2 coordinate");
550
             skipCommaSpaces();
551
             checkArg('C', "x coordinate");
552
             skipCommaSpaces();
553
             checkArg('C', "y coordinate");
554
 
555
             expectNumber = skipCommaSpaces2();
556
         }
557
     }

    
Checks a 'q' command. 
561
 
562
     private void checkq() throws DatatypeException, IOException {
563
         if (.length() == 0) {
564
             appendToContext();
565
         }
566
          = .read();
567
         appendToContext();
568
         skipSpaces();
569
         boolean expectNumber = true;
570
 
571
         for (;;) {
572
             switch () {
573
                 default:
574
                     if (expectNumber)
575
                         reportNonNumber('q', );
576
                     return;
577
 
578
                 case '+':
579
                 case '-':
580
                 case '.':
581
                 case '0':
582
                 case '1':
583
                 case '2':
584
                 case '3':
585
                 case '4':
586
                 case '5':
587
                 case '6':
588
                 case '7':
589
                 case '8':
590
                 case '9':
591
                     break;
592
             }
593
 
594
             checkArg('q', "x1 coordinate");
595
             skipCommaSpaces();
596
             checkArg('q', "y1 coordinate");
597
             skipCommaSpaces();
598
             checkArg('q', "x coordinate");
599
             skipCommaSpaces();
600
             checkArg('q', "y coordinate");
601
 
602
             expectNumber = skipCommaSpaces2();
603
         }
604
     }

    
Checks a 'Q' command. 
608
 
609
     private void checkQ() throws DatatypeException, IOException {
610
         if (.length() == 0) {
611
             appendToContext();
612
         }
613
          = .read();
614
         appendToContext();
615
         skipSpaces();
616
         boolean expectNumber = true;
617
 
618
         for (;;) {
619
             switch () {
620
                 default:
621
                     if (expectNumber)
622
                         reportNonNumber('Q', );
623
                     return;
624
 
625
                 case '+':
626
                 case '-':
627
                 case '.':
628
                 case '0':
629
                 case '1':
630
                 case '2':
631
                 case '3':
632
                 case '4':
633
                 case '5':
634
                 case '6':
635
                 case '7':
636
                 case '8':
637
                 case '9':
638
                     break;
639
             }
640
 
641
             checkArg('Q', "x1 coordinate");
642
             skipCommaSpaces();
643
             checkArg('Q', "y1 coordinate");
644
             skipCommaSpaces();
645
             checkArg('Q', "x coordinate");
646
             skipCommaSpaces();
647
             checkArg('Q', "y coordinate");
648
 
649
             expectNumber = skipCommaSpaces2();
650
         }
651
     }

    
Checks an 's' command. 
655
 
656
     private void checks() throws DatatypeException, IOException {
657
         if (.length() == 0) {
658
             appendToContext();
659
         }
660
          = .read();
661
         appendToContext();
662
         skipSpaces();
663
         boolean expectNumber = true;
664
 
665
         for (;;) {
666
             switch () {
667
                 default:
668
                     if (expectNumber)
669
                         reportNonNumber('s', );
670
                     return;
671
 
672
                 case '+':
673
                 case '-':
674
                 case '.':
675
                 case '0':
676
                 case '1':
677
                 case '2':
678
                 case '3':
679
                 case '4':
680
                 case '5':
681
                 case '6':
682
                 case '7':
683
                 case '8':
684
                 case '9':
685
                     break;
686
             }
687
 
688
             checkArg('s', "x2 coordinate");
689
             skipCommaSpaces();
690
             checkArg('s', "y2 coordinate");
691
             skipCommaSpaces();
692
             checkArg('s', "x coordinate");
693
             skipCommaSpaces();
694
             checkArg('s', "y coordinate");
695
 
696
             expectNumber = skipCommaSpaces2();
697
         }
698
     }

    
Checks an 'S' command. 
702
 
703
     private void checkS() throws DatatypeException, IOException {
704
         if (.length() == 0) {
705
             appendToContext();
706
         }
707
          = .read();
708
         appendToContext();
709
         skipSpaces();
710
         boolean expectNumber = true;
711
 
712
         for (;;) {
713
             switch () {
714
                 default:
715
                     if (expectNumber)
716
                         reportNonNumber('S', );
717
                     return;
718
 
719
                 case '+':
720
                 case '-':
721
                 case '.':
722
                 case '0':
723
                 case '1':
724
                 case '2':
725
                 case '3':
726
                 case '4':
727
                 case '5':
728
                 case '6':
729
                 case '7':
730
                 case '8':
731
                 case '9':
732
                     break;
733
             }
734
 
735
             checkArg('S', "x2 coordinate");
736
             skipCommaSpaces();
737
             checkArg('S', "y2 coordinate");
738
             skipCommaSpaces();
739
             checkArg('S', "x coordinate");
740
             skipCommaSpaces();
741
             checkArg('S', "y coordinate");
742
 
743
             expectNumber = skipCommaSpaces2();
744
         }
745
     }

    
Checks a 't' command. 
749
 
750
     private void checkt() throws DatatypeException, IOException {
751
         if (.length() == 0) {
752
             appendToContext();
753
         }
754
          = .read();
755
         appendToContext();
756
         skipSpaces();
757
         boolean expectNumber = true;
758
 
759
         for (;;) {
760
             switch () {
761
                 default:
762
                     if (expectNumber)
763
                         reportNonNumber('t', );
764
                     return;
765
 
766
                 case '+':
767
                 case '-':
768
                 case '.':
769
                 case '0':
770
                 case '1':
771
                 case '2':
772
                 case '3':
773
                 case '4':
774
                 case '5':
775
                 case '6':
776
                 case '7':
777
                 case '8':
778
                 case '9':
779
                     break;
780
             }
781
 
782
             checkArg('t', "x coordinate");
783
             skipCommaSpaces();
784
             checkArg('t', "y coordinate");
785
 
786
             expectNumber = skipCommaSpaces2();
787
         }
788
     }

    
Checks a 'T' command. 
792
 
793
     private void checkT() throws DatatypeException, IOException {
794
         if (.length() == 0) {
795
             appendToContext();
796
         }
797
          = .read();
798
         appendToContext();
799
         skipSpaces();
800
         boolean expectNumber = true;
801
 
802
         for (;;) {
803
             switch () {
804
                 default:
805
                     if (expectNumber)
806
                         reportNonNumber('T', );
807
                     return;
808
 
809
                 case '+':
810
                 case '-':
811
                 case '.':
812
                 case '0':
813
                 case '1':
814
                 case '2':
815
                 case '3':
816
                 case '4':
817
                 case '5':
818
                 case '6':
819
                 case '7':
820
                 case '8':
821
                 case '9':
822
                     break;
823
             }
824
 
825
             checkArg('T', "x coordinate");
826
             skipCommaSpaces();
827
             checkArg('T', "y coordinate");
828
 
829
             expectNumber = skipCommaSpaces2();
830
         }
831
     }

    
Checks an 'a' command. 
835
 
836
     private void checka() throws DatatypeException, IOException {
837
         if (.length() == 0) {
838
             appendToContext();
839
         }
840
          = .read();
841
         appendToContext();
842
         skipSpaces();
843
         boolean expectNumber = true;
844
 
845
         for (;;) {
846
             switch () {
847
                 default:
848
                     if (expectNumber)
849
                         reportNonNumber('a', );
850
                     return;
851
 
852
                 case '+':
853
                 case '-':
854
                 case '.':
855
                 case '0':
856
                 case '1':
857
                 case '2':
858
                 case '3':
859
                 case '4':
860
                 case '5':
861
                 case '6':
862
                 case '7':
863
                 case '8':
864
                 case '9':
865
                     break;
866
             }
867
 
868
             checkArg('a', "rx radius");
869
             skipCommaSpaces();
870
             checkArg('a', "ry radius");
871
             skipCommaSpaces();
872
             checkArg('a', "x-axis-rotation");
873
             skipCommaSpaces();
874
 
875
             switch () {
876
                 default:
877
                     reportUnexpected("\u201c0\u201d or \u201c1\u201d "
878
                             + "for large-arc-flag for \u201ca\u201d command",
879
                             );
880
                     skipSubPath();
881
                     return;
882
                 case '0':
883
                 case '1':
884
                     break;
885
             }
886
 
887
              = .read();
888
             appendToContext();
889
             skipCommaSpaces();
890
 
891
             switch () {
892
                 default:
893
                     reportUnexpected("\u201c0\u201d or \u201c1\u201d "
894
                             + "for sweep-flag for \u201ca\u201d command",
895
                             );
896
                     skipSubPath();
897
                     return;
898
                 case '0':
899
                 case '1':
900
                     break;
901
             }
902
 
903
              = .read();
904
             appendToContext();
905
             skipCommaSpaces();
906
 
907
             checkArg('a', "x coordinate");
908
             skipCommaSpaces();
909
             checkArg('a', "y coordinate");
910
 
911
             expectNumber = skipCommaSpaces2();
912
         }
913
     }

    
Checks an 'A' command. 
917
 
918
     private void checkA() throws DatatypeException, IOException {
919
         if (.length() == 0) {
920
             appendToContext();
921
         }
922
          = .read();
923
         appendToContext();
924
         skipSpaces();
925
         boolean expectNumber = true;
926
 
927
         for (;;) {
928
             switch () {
929
                 default:
930
                     if (expectNumber)
931
                         reportNonNumber('A', );
932
                     return;
933
 
934
                 case '+':
935
                 case '-':
936
                 case '.':
937
                 case '0':
938
                 case '1':
939
                 case '2':
940
                 case '3':
941
                 case '4':
942
                 case '5':
943
                 case '6':
944
                 case '7':
945
                 case '8':
946
                 case '9':
947
                     break;
948
             }
949
 
950
             checkArg('A', "rx radius");
951
             skipCommaSpaces();
952
             checkArg('A', "ry radius");
953
             skipCommaSpaces();
954
             checkArg('A', "x-axis-rotation");
955
             skipCommaSpaces();
956
 
957
             switch () {
958
                 default:
959
                     reportUnexpected("\u201c0\u201d or \u201c1\u201d "
960
                             + "for large-arc-flag for \u201cA\u201d command",
961
                             );
962
                     skipSubPath();
963
                     return;
964
                 case '0':
965
                 case '1':
966
                     break;
967
             }
968
 
969
              = .read();
970
             appendToContext();
971
             skipCommaSpaces();
972
 
973
             switch () {
974
                 default:
975
                     reportUnexpected("\u201c0\u201d or \u201c1\u201d "
976
                             + "for sweep-flag for \u201cA\u201d command",
977
                             );
978
                     skipSubPath();
979
                     return;
980
                 case '0':
981
                 case '1':
982
                     break;
983
             }
984
 
985
              = .read();
986
             appendToContext();
987
             skipCommaSpaces();
988
 
989
             checkArg('A', "x coordinate");
990
             skipCommaSpaces();
991
             checkArg('A', "y coordinate");
992
 
993
             expectNumber = skipCommaSpaces2();
994
         }
995
     }

    
Checks a command argument. 
999
 
1000
    private void checkArg(char command, String arg) throws DatatypeException,
1001
            IOException {
1002
        int mant = 0;
1003
        int mantDig = 0;
1004
        boolean mantPos = true;
1005
        boolean mantRead = false;
1007
        int exp = 0;
1008
        int expDig = 0;
1009
        int expAdj = 0;
1010
        boolean expPos = true;
1012
        switch () {
1013
            case '-':
1014
                mantPos = false;
1015
            case '+':
1016
                 = .read();
1017
                appendToContext();
1018
        }
1020
        m1: switch () {
1021
            default:
1022
                reportUnexpected(arg + " for \u201c" + command
1023
                        + "\u201d command", );
1024
                skipSubPath();
1025
                return;
1027
            case '.':
1028
                break;
1030
            case '0':
1031
                mantRead = true;
1032
                l: for (;;) {
1033
                     = .read();
1034
                    appendToContext();
1035
                    switch () {
1036
                        case '1':
1037
                        case '2':
1038
                        case '3':
1039
                        case '4':
1040
                        case '5':
1041
                        case '6':
1042
                        case '7':
1043
                        case '8':
1044
                        case '9':
1045
                            break l;
1046
                        case '.':
1047
                        case 'e':
1048
                        case 'E':
1049
                            break m1;
1050
                        default:
1051
                            return;
1052
                        case '0':
1053
                    }
1054
                }
1056
            case '1':
1057
            case '2':
1058
            case '3':
1059
            case '4':
1060
            case '5':
1061
            case '6':
1062
            case '7':
1063
            case '8':
1064
            case '9':
1065
                mantRead = true;
1066
                l: for (;;) {
1067
                    if (mantDig < 9) {
1068
                        mantDig++;
1069
                        mant = mant * 10 + ( - '0');
1070
                    } else {
1071
                        expAdj++;
1072
                    }
1073
                     = .read();
1074
                    appendToContext();
1075
                    switch () {
1076
                        default:
1077
                            break l;
1078
                        case '0':
1079
                        case '1':
1080
                        case '2':
1081
                        case '3':
1082
                        case '4':
1083
                        case '5':
1084
                        case '6':
1085
                        case '7':
1086
                        case '8':
1087
                        case '9':
1088
                    }
1089
                }
1090
        }
1092
        if ( == '.') {
1093
             = .read();
1094
            appendToContext();
1095
            m2: switch () {
1096
                default:
1097
                case 'e':
1098
                case 'E':
1099
                    if (!mantRead) {
1100
                        reportNonNumber(command, );
1101
                        return;
1102
                    }
1103
                    break;
1105
                case '0':
1106
                    if (mantDig == 0) {
1107
                        l: for (;;) {
1108
                             = .read();
1109
                            appendToContext();
1110
                            expAdj--;
1111
                            switch () {
1112
                                case '1':
1113
                                case '2':
1114
                                case '3':
1115
                                case '4':
1116
                                case '5':
1117
                                case '6':
1118
                                case '7':
1119
                                case '8':
1120
                                case '9':
1121
                                    break l;
1122
                                default:
1123
                                    if (!mantRead) {
1124
                                        return;
1125
                                    }
1126
                                    break m2;
1127
                                case '0':
1128
                            }
1129
                        }
1130
                    }
1131
                case '1':
1132
                case '2':
1133
                case '3':
1134
                case '4':
1135
                case '5':
1136
                case '6':
1137
                case '7':
1138
                case '8':
1139
                case '9':
1140
                    l: for (;;) {
1141
                        if (mantDig < 9) {
1142
                            mantDig++;
1143
                            mant = mant * 10 + ( - '0');
1144
                            expAdj--;
1145
                        }
1146
                         = .read();
1147
                        appendToContext();
1148
                        switch () {
1149
                            default:
1150
                                break l;
1151
                            case '0':
1152
                            case '1':
1153
                            case '2':
1154
                            case '3':
1155
                            case '4':
1156
                            case '5':
1157
                            case '6':
1158
                            case '7':
1159
                            case '8':
1160
                            case '9':
1161
                        }
1162
                    }
1163
            }
1164
        }
1166
        switch () {
1167
            case 'e':
1168
            case 'E':
1169
                 = .read();
1170
                appendToContext();
1171
                switch () {
1172
                    default:
1173
                        reportNonNumber(command, );
1174
                        return;
1175
                    case '-':
1176
                        expPos = false;
1177
                    case '+':
1178
                         = .read();
1179
                        appendToContext();
1180
                        switch () {
1181
                            default:
1182
                                reportNonNumber(command, );
1183
                                return;
1184
                            case '0':
1185
                            case '1':
1186
                            case '2':
1187
                            case '3':
1188
                            case '4':
1189
                            case '5':
1190
                            case '6':
1191
                            case '7':
1192
                            case '8':
1193
                            case '9':
1194
                        }
1195
                    case '0':
1196
                    case '1':
1197
                    case '2':
1198
                    case '3':
1199
                    case '4':
1200
                    case '5':
1201
                    case '6':
1202
                    case '7':
1203
                    case '8':
1204
                    case '9':
1205
                }
1207
                en: switch () {
1208
                    case '0':
1209
                        l: for (;;) {
1210
                             = .read();
1211
                            appendToContext();
1212
                            switch () {
1213
                                case '1':
1214
                                case '2':
1215
                                case '3':
1216
                                case '4':
1217
                                case '5':
1218
                                case '6':
1219
                                case '7':
1220
                                case '8':
1221
                                case '9':
1222
                                    break l;
1223
                                default:
1224
                                    break en;
1225
                                case '0':