-
Notifications
You must be signed in to change notification settings - Fork 8
/
Copy pathpretty-cvt.sml
1746 lines (1664 loc) · 89.5 KB
/
pretty-cvt.sml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
structure PrettyCvt = struct
open Ast
fun cvtSOURCE_POS {line=n0, col=n1} = PrettyRep.Rec [("line", PrettyRep.Int n0),
("col", PrettyRep.Int n1)]
and cvtLOC {file=s7, span=(x8, x9), post_newline=b11} = PrettyRep.Rec [("file",
PrettyRep.String s7), ("span", PrettyRep.Tuple [cvtSOURCE_POS x8,
cvtSOURCE_POS x9]), ("post_newline", PrettyRep.Bool b11)]
and cvtIDENT s19 = PrettyRep.UniStr s19
and cvtNAMESPACE (Intrinsic) = PrettyRep.Ctor ("Intrinsic", NONE)
| cvtNAMESPACE (OperatorNamespace) = PrettyRep.Ctor ("OperatorNamespace",
NONE)
| cvtNAMESPACE (Private x22) = PrettyRep.Ctor ("Private", SOME (cvtIDENT x22))
| cvtNAMESPACE (Protected x25) = PrettyRep.Ctor ("Protected", SOME (cvtIDENT x25))
| cvtNAMESPACE (Public x28) = PrettyRep.Ctor ("Public", SOME (cvtIDENT x28))
| cvtNAMESPACE (Internal x31) = PrettyRep.Ctor ("Internal", SOME (cvtIDENT x31))
| cvtNAMESPACE (UserNamespace s34) = PrettyRep.Ctor ("UserNamespace",
SOME (PrettyRep.UniStr s34))
| cvtNAMESPACE (AnonUserNamespace n37) = PrettyRep.Ctor ("AnonUserNamespace",
SOME (PrettyRep.Int n37))
| cvtNAMESPACE (LimitedNamespace(x40, x41)) = PrettyRep.Ctor ("LimitedNamespace",
SOME (PrettyRep.Tuple [cvtIDENT x40, cvtNAMESPACE x41]))
and cvtNAME {ns=x45, id=x46} = PrettyRep.Rec [("ns", cvtNAMESPACE x45),
("id", cvtIDENT x46)]
and cvtMULTINAME {nss=ls57, id=x61} = PrettyRep.Rec [("nss", PrettyRep.List (List.map (fn ls53 =>
PrettyRep.List (List.map (fn x52 =>
cvtNAMESPACE x52
) ls53)
) ls57)),
("id", cvtIDENT x61)]
and cvtNUMBER_TYPE (Decimal) = PrettyRep.Ctor ("Decimal", NONE)
| cvtNUMBER_TYPE (Double) = PrettyRep.Ctor ("Double", NONE)
| cvtNUMBER_TYPE (Int) = PrettyRep.Ctor ("Int", NONE)
| cvtNUMBER_TYPE (UInt) = PrettyRep.Ctor ("UInt", NONE)
| cvtNUMBER_TYPE (Number) = PrettyRep.Ctor ("Number", NONE)
and cvtNUMERIC_MODE {numberType=x72, roundingMode=r73, precision=n74} =
PrettyRep.Rec [("numberType", cvtNUMBER_TYPE x72), ("roundingMode",
PrettyRep.DecRm r73), ("precision", PrettyRep.Int n74)]
and cvtBINTYPEOP (Cast) = PrettyRep.Ctor ("Cast", NONE)
| cvtBINTYPEOP (Is) = PrettyRep.Ctor ("Is", NONE)
| cvtBINTYPEOP (To) = PrettyRep.Ctor ("To", NONE)
<<<<<<< .mine
and cvtBINOP (Plus opt80) = PrettyRep.Ctor ("Plus", SOME
(case opt80 of
=======
and cvtBINOP (Plus opt87) = PrettyRep.Ctor ("Plus", SOME
(case opt87 of
>>>>>>> .theirs
NONE => PrettyRep.Ctor ("NONE", NONE)
<<<<<<< .mine
| SOME x79 => PrettyRep.Ctor ("SOME", SOME (cvtNUMERIC_MODE x79))
=======
| SOME x86 => PrettyRep.Ctor ("SOME", SOME (cvtNUMERIC_MODE x86))
>>>>>>> .theirs
))
<<<<<<< .mine
| cvtBINOP (Minus opt87) = PrettyRep.Ctor ("Minus", SOME
(case opt87 of
=======
| cvtBINOP (Minus opt94) = PrettyRep.Ctor ("Minus", SOME
(case opt94 of
>>>>>>> .theirs
NONE => PrettyRep.Ctor ("NONE", NONE)
<<<<<<< .mine
| SOME x86 => PrettyRep.Ctor ("SOME", SOME (cvtNUMERIC_MODE x86))
=======
| SOME x93 => PrettyRep.Ctor ("SOME", SOME (cvtNUMERIC_MODE x93))
>>>>>>> .theirs
))
<<<<<<< .mine
| cvtBINOP (Times opt94) = PrettyRep.Ctor ("Times", SOME
(case opt94 of
=======
| cvtBINOP (Times opt101) = PrettyRep.Ctor ("Times", SOME
(case opt101 of
>>>>>>> .theirs
NONE => PrettyRep.Ctor ("NONE", NONE)
<<<<<<< .mine
| SOME x93 => PrettyRep.Ctor ("SOME", SOME (cvtNUMERIC_MODE x93))
=======
| SOME x100 => PrettyRep.Ctor ("SOME", SOME (cvtNUMERIC_MODE x100))
>>>>>>> .theirs
))
<<<<<<< .mine
| cvtBINOP (Divide opt101) = PrettyRep.Ctor ("Divide", SOME
(case opt101 of
=======
| cvtBINOP (Divide opt108) = PrettyRep.Ctor ("Divide", SOME
(case opt108 of
>>>>>>> .theirs
NONE => PrettyRep.Ctor ("NONE", NONE)
<<<<<<< .mine
| SOME x100 => PrettyRep.Ctor ("SOME", SOME (cvtNUMERIC_MODE x100))
=======
| SOME x107 => PrettyRep.Ctor ("SOME", SOME (cvtNUMERIC_MODE x107))
>>>>>>> .theirs
))
<<<<<<< .mine
| cvtBINOP (Remainder opt108) = PrettyRep.Ctor ("Remainder", SOME
(case opt108 of
=======
| cvtBINOP (Remainder opt115) = PrettyRep.Ctor ("Remainder", SOME
(case opt115 of
>>>>>>> .theirs
NONE => PrettyRep.Ctor ("NONE", NONE)
<<<<<<< .mine
| SOME x107 => PrettyRep.Ctor ("SOME", SOME (cvtNUMERIC_MODE x107))
=======
| SOME x114 => PrettyRep.Ctor ("SOME", SOME (cvtNUMERIC_MODE x114))
>>>>>>> .theirs
))
| cvtBINOP (LeftShift) = PrettyRep.Ctor ("LeftShift", NONE)
| cvtBINOP (RightShift) = PrettyRep.Ctor ("RightShift", NONE)
| cvtBINOP (RightShiftUnsigned) = PrettyRep.Ctor ("RightShiftUnsigned",
NONE)
| cvtBINOP (BitwiseAnd) = PrettyRep.Ctor ("BitwiseAnd", NONE)
| cvtBINOP (BitwiseOr) = PrettyRep.Ctor ("BitwiseOr", NONE)
| cvtBINOP (BitwiseXor) = PrettyRep.Ctor ("BitwiseXor", NONE)
| cvtBINOP (LogicalAnd) = PrettyRep.Ctor ("LogicalAnd", NONE)
| cvtBINOP (LogicalOr) = PrettyRep.Ctor ("LogicalOr", NONE)
| cvtBINOP (InstanceOf) = PrettyRep.Ctor ("InstanceOf", NONE)
| cvtBINOP (In) = PrettyRep.Ctor ("In", NONE)
<<<<<<< .mine
| cvtBINOP (Equals opt125) = PrettyRep.Ctor ("Equals", SOME
(case opt125 of
=======
| cvtBINOP (Equals opt132) = PrettyRep.Ctor ("Equals", SOME
(case opt132 of
>>>>>>> .theirs
NONE => PrettyRep.Ctor ("NONE", NONE)
<<<<<<< .mine
| SOME x124 => PrettyRep.Ctor ("SOME", SOME (cvtNUMERIC_MODE x124))
=======
| SOME x131 => PrettyRep.Ctor ("SOME", SOME (cvtNUMERIC_MODE x131))
>>>>>>> .theirs
))
<<<<<<< .mine
| cvtBINOP (NotEquals opt132) = PrettyRep.Ctor ("NotEquals", SOME
(case opt132 of
=======
| cvtBINOP (NotEquals opt139) = PrettyRep.Ctor ("NotEquals", SOME
(case opt139 of
>>>>>>> .theirs
NONE => PrettyRep.Ctor ("NONE", NONE)
<<<<<<< .mine
| SOME x131 => PrettyRep.Ctor ("SOME", SOME (cvtNUMERIC_MODE x131))
=======
| SOME x138 => PrettyRep.Ctor ("SOME", SOME (cvtNUMERIC_MODE x138))
>>>>>>> .theirs
))
<<<<<<< .mine
| cvtBINOP (StrictEquals opt139) = PrettyRep.Ctor ("StrictEquals", SOME
(case opt139 of
=======
| cvtBINOP (StrictEquals opt146) = PrettyRep.Ctor ("StrictEquals", SOME
(case opt146 of
>>>>>>> .theirs
NONE => PrettyRep.Ctor ("NONE", NONE)
<<<<<<< .mine
| SOME x138 => PrettyRep.Ctor ("SOME", SOME (cvtNUMERIC_MODE x138))
=======
| SOME x145 => PrettyRep.Ctor ("SOME", SOME (cvtNUMERIC_MODE x145))
>>>>>>> .theirs
))
<<<<<<< .mine
| cvtBINOP (StrictNotEquals opt146) = PrettyRep.Ctor ("StrictNotEquals",
=======
| cvtBINOP (StrictNotEquals opt153) = PrettyRep.Ctor ("StrictNotEquals",
>>>>>>> .theirs
SOME
<<<<<<< .mine
(case opt146 of
=======
(case opt153 of
>>>>>>> .theirs
NONE => PrettyRep.Ctor ("NONE", NONE)
<<<<<<< .mine
| SOME x145 => PrettyRep.Ctor ("SOME", SOME (cvtNUMERIC_MODE x145))
=======
| SOME x152 => PrettyRep.Ctor ("SOME", SOME (cvtNUMERIC_MODE x152))
>>>>>>> .theirs
))
<<<<<<< .mine
| cvtBINOP (Less opt153) = PrettyRep.Ctor ("Less", SOME
(case opt153 of
=======
| cvtBINOP (Less opt160) = PrettyRep.Ctor ("Less", SOME
(case opt160 of
>>>>>>> .theirs
NONE => PrettyRep.Ctor ("NONE", NONE)
<<<<<<< .mine
| SOME x152 => PrettyRep.Ctor ("SOME", SOME (cvtNUMERIC_MODE x152))
=======
| SOME x159 => PrettyRep.Ctor ("SOME", SOME (cvtNUMERIC_MODE x159))
>>>>>>> .theirs
))
<<<<<<< .mine
| cvtBINOP (LessOrEqual opt160) = PrettyRep.Ctor ("LessOrEqual", SOME
(case opt160 of
=======
| cvtBINOP (LessOrEqual opt167) = PrettyRep.Ctor ("LessOrEqual", SOME
(case opt167 of
>>>>>>> .theirs
NONE => PrettyRep.Ctor ("NONE", NONE)
<<<<<<< .mine
| SOME x159 => PrettyRep.Ctor ("SOME", SOME (cvtNUMERIC_MODE x159))
=======
| SOME x166 => PrettyRep.Ctor ("SOME", SOME (cvtNUMERIC_MODE x166))
>>>>>>> .theirs
))
<<<<<<< .mine
| cvtBINOP (Greater opt167) = PrettyRep.Ctor ("Greater", SOME
(case opt167 of
=======
| cvtBINOP (Greater opt174) = PrettyRep.Ctor ("Greater", SOME
(case opt174 of
>>>>>>> .theirs
NONE => PrettyRep.Ctor ("NONE", NONE)
<<<<<<< .mine
| SOME x166 => PrettyRep.Ctor ("SOME", SOME (cvtNUMERIC_MODE x166))
=======
| SOME x173 => PrettyRep.Ctor ("SOME", SOME (cvtNUMERIC_MODE x173))
>>>>>>> .theirs
))
<<<<<<< .mine
| cvtBINOP (GreaterOrEqual opt174) = PrettyRep.Ctor ("GreaterOrEqual",
=======
| cvtBINOP (GreaterOrEqual opt181) = PrettyRep.Ctor ("GreaterOrEqual",
>>>>>>> .theirs
SOME
<<<<<<< .mine
(case opt174 of
=======
(case opt181 of
>>>>>>> .theirs
NONE => PrettyRep.Ctor ("NONE", NONE)
<<<<<<< .mine
| SOME x173 => PrettyRep.Ctor ("SOME", SOME (cvtNUMERIC_MODE x173))
=======
| SOME x180 => PrettyRep.Ctor ("SOME", SOME (cvtNUMERIC_MODE x180))
>>>>>>> .theirs
))
| cvtBINOP (Comma) = PrettyRep.Ctor ("Comma", NONE)
and cvtASSIGNOP (Assign) = PrettyRep.Ctor ("Assign", NONE)
<<<<<<< .mine
| cvtASSIGNOP (AssignPlus opt183) = PrettyRep.Ctor ("AssignPlus", SOME
(case opt183 of
=======
| cvtASSIGNOP (AssignPlus opt190) = PrettyRep.Ctor ("AssignPlus", SOME
(case opt190 of
>>>>>>> .theirs
NONE => PrettyRep.Ctor ("NONE", NONE)
<<<<<<< .mine
| SOME x182 => PrettyRep.Ctor ("SOME", SOME (cvtNUMERIC_MODE x182))
=======
| SOME x189 => PrettyRep.Ctor ("SOME", SOME (cvtNUMERIC_MODE x189))
>>>>>>> .theirs
))
<<<<<<< .mine
| cvtASSIGNOP (AssignMinus opt190) = PrettyRep.Ctor ("AssignMinus", SOME
(case opt190 of
=======
| cvtASSIGNOP (AssignMinus opt197) = PrettyRep.Ctor ("AssignMinus", SOME
(case opt197 of
>>>>>>> .theirs
NONE => PrettyRep.Ctor ("NONE", NONE)
<<<<<<< .mine
| SOME x189 => PrettyRep.Ctor ("SOME", SOME (cvtNUMERIC_MODE x189))
=======
| SOME x196 => PrettyRep.Ctor ("SOME", SOME (cvtNUMERIC_MODE x196))
>>>>>>> .theirs
))
<<<<<<< .mine
| cvtASSIGNOP (AssignTimes opt197) = PrettyRep.Ctor ("AssignTimes", SOME
(case opt197 of
=======
| cvtASSIGNOP (AssignTimes opt204) = PrettyRep.Ctor ("AssignTimes", SOME
(case opt204 of
>>>>>>> .theirs
NONE => PrettyRep.Ctor ("NONE", NONE)
<<<<<<< .mine
| SOME x196 => PrettyRep.Ctor ("SOME", SOME (cvtNUMERIC_MODE x196))
=======
| SOME x203 => PrettyRep.Ctor ("SOME", SOME (cvtNUMERIC_MODE x203))
>>>>>>> .theirs
))
<<<<<<< .mine
| cvtASSIGNOP (AssignDivide opt204) = PrettyRep.Ctor ("AssignDivide",
=======
| cvtASSIGNOP (AssignDivide opt211) = PrettyRep.Ctor ("AssignDivide",
>>>>>>> .theirs
SOME
<<<<<<< .mine
(case opt204 of
=======
(case opt211 of
>>>>>>> .theirs
NONE => PrettyRep.Ctor ("NONE", NONE)
<<<<<<< .mine
| SOME x203 => PrettyRep.Ctor ("SOME", SOME (cvtNUMERIC_MODE x203))
=======
| SOME x210 => PrettyRep.Ctor ("SOME", SOME (cvtNUMERIC_MODE x210))
>>>>>>> .theirs
))
<<<<<<< .mine
| cvtASSIGNOP (AssignRemainder opt211) = PrettyRep.Ctor ("AssignRemainder",
=======
| cvtASSIGNOP (AssignRemainder opt218) = PrettyRep.Ctor ("AssignRemainder",
>>>>>>> .theirs
SOME
<<<<<<< .mine
(case opt211 of
=======
(case opt218 of
>>>>>>> .theirs
NONE => PrettyRep.Ctor ("NONE", NONE)
<<<<<<< .mine
| SOME x210 => PrettyRep.Ctor ("SOME", SOME (cvtNUMERIC_MODE x210))
=======
| SOME x217 => PrettyRep.Ctor ("SOME", SOME (cvtNUMERIC_MODE x217))
>>>>>>> .theirs
))
| cvtASSIGNOP (AssignLeftShift) = PrettyRep.Ctor ("AssignLeftShift", NONE)
| cvtASSIGNOP (AssignRightShift) = PrettyRep.Ctor ("AssignRightShift",
NONE)
| cvtASSIGNOP (AssignRightShiftUnsigned) = PrettyRep.Ctor ("AssignRightShiftUnsigned",
NONE)
| cvtASSIGNOP (AssignBitwiseAnd) = PrettyRep.Ctor ("AssignBitwiseAnd",
NONE)
| cvtASSIGNOP (AssignBitwiseOr) = PrettyRep.Ctor ("AssignBitwiseOr", NONE)
| cvtASSIGNOP (AssignBitwiseXor) = PrettyRep.Ctor ("AssignBitwiseXor",
NONE)
| cvtASSIGNOP (AssignLogicalAnd) = PrettyRep.Ctor ("AssignLogicalAnd",
NONE)
| cvtASSIGNOP (AssignLogicalOr) = PrettyRep.Ctor ("AssignLogicalOr", NONE)
and cvtUNOP (Delete) = PrettyRep.Ctor ("Delete", NONE)
| cvtUNOP (Void) = PrettyRep.Ctor ("Void", NONE)
| cvtUNOP (Typeof) = PrettyRep.Ctor ("Typeof", NONE)
<<<<<<< .mine
| cvtUNOP (PreIncrement opt229) = PrettyRep.Ctor ("PreIncrement", SOME
(case opt229 of
=======
| cvtUNOP (PreIncrement opt236) = PrettyRep.Ctor ("PreIncrement", SOME
(case opt236 of
>>>>>>> .theirs
NONE => PrettyRep.Ctor ("NONE", NONE)
<<<<<<< .mine
| SOME x228 => PrettyRep.Ctor ("SOME", SOME (cvtNUMERIC_MODE x228))
=======
| SOME x235 => PrettyRep.Ctor ("SOME", SOME (cvtNUMERIC_MODE x235))
>>>>>>> .theirs
))
<<<<<<< .mine
| cvtUNOP (PreDecrement opt236) = PrettyRep.Ctor ("PreDecrement", SOME
(case opt236 of
=======
| cvtUNOP (PreDecrement opt243) = PrettyRep.Ctor ("PreDecrement", SOME
(case opt243 of
>>>>>>> .theirs
NONE => PrettyRep.Ctor ("NONE", NONE)
<<<<<<< .mine
| SOME x235 => PrettyRep.Ctor ("SOME", SOME (cvtNUMERIC_MODE x235))
=======
| SOME x242 => PrettyRep.Ctor ("SOME", SOME (cvtNUMERIC_MODE x242))
>>>>>>> .theirs
))
<<<<<<< .mine
| cvtUNOP (PostIncrement opt243) = PrettyRep.Ctor ("PostIncrement", SOME
(case opt243 of
=======
| cvtUNOP (PostIncrement opt250) = PrettyRep.Ctor ("PostIncrement", SOME
(case opt250 of
>>>>>>> .theirs
NONE => PrettyRep.Ctor ("NONE", NONE)
<<<<<<< .mine
| SOME x242 => PrettyRep.Ctor ("SOME", SOME (cvtNUMERIC_MODE x242))
=======
| SOME x249 => PrettyRep.Ctor ("SOME", SOME (cvtNUMERIC_MODE x249))
>>>>>>> .theirs
))
<<<<<<< .mine
| cvtUNOP (PostDecrement opt250) = PrettyRep.Ctor ("PostDecrement", SOME
(case opt250 of
=======
| cvtUNOP (PostDecrement opt257) = PrettyRep.Ctor ("PostDecrement", SOME
(case opt257 of
>>>>>>> .theirs
NONE => PrettyRep.Ctor ("NONE", NONE)
<<<<<<< .mine
| SOME x249 => PrettyRep.Ctor ("SOME", SOME (cvtNUMERIC_MODE x249))
=======
| SOME x256 => PrettyRep.Ctor ("SOME", SOME (cvtNUMERIC_MODE x256))
>>>>>>> .theirs
))
<<<<<<< .mine
| cvtUNOP (UnaryPlus opt257) = PrettyRep.Ctor ("UnaryPlus", SOME
(case opt257 of
=======
| cvtUNOP (UnaryPlus opt264) = PrettyRep.Ctor ("UnaryPlus", SOME
(case opt264 of
>>>>>>> .theirs
NONE => PrettyRep.Ctor ("NONE", NONE)
<<<<<<< .mine
| SOME x256 => PrettyRep.Ctor ("SOME", SOME (cvtNUMERIC_MODE x256))
=======
| SOME x263 => PrettyRep.Ctor ("SOME", SOME (cvtNUMERIC_MODE x263))
>>>>>>> .theirs
))
<<<<<<< .mine
| cvtUNOP (UnaryMinus opt264) = PrettyRep.Ctor ("UnaryMinus", SOME
(case opt264 of
=======
| cvtUNOP (UnaryMinus opt271) = PrettyRep.Ctor ("UnaryMinus", SOME
(case opt271 of
>>>>>>> .theirs
NONE => PrettyRep.Ctor ("NONE", NONE)
<<<<<<< .mine
| SOME x263 => PrettyRep.Ctor ("SOME", SOME (cvtNUMERIC_MODE x263))
=======
| SOME x270 => PrettyRep.Ctor ("SOME", SOME (cvtNUMERIC_MODE x270))
>>>>>>> .theirs
))
| cvtUNOP (BitwiseNot) = PrettyRep.Ctor ("BitwiseNot", NONE)
| cvtUNOP (LogicalNot) = PrettyRep.Ctor ("LogicalNot", NONE)
| cvtUNOP (Type) = PrettyRep.Ctor ("Type", NONE)
and cvtVAR_DEFN_TAG (Const) = PrettyRep.Ctor ("Const", NONE)
| cvtVAR_DEFN_TAG (Var) = PrettyRep.Ctor ("Var", NONE)
| cvtVAR_DEFN_TAG (LetVar) = PrettyRep.Ctor ("LetVar", NONE)
| cvtVAR_DEFN_TAG (LetConst) = PrettyRep.Ctor ("LetConst", NONE)
and cvtSPECIAL_TY (Any) = PrettyRep.Ctor ("Any", NONE)
| cvtSPECIAL_TY (Null) = PrettyRep.Ctor ("Null", NONE)
| cvtSPECIAL_TY (Undefined) = PrettyRep.Ctor ("Undefined", NONE)
| cvtSPECIAL_TY (VoidType) = PrettyRep.Ctor ("VoidType", NONE)
<<<<<<< .mine
and cvtPRAGMA (UseNamespace x281) = PrettyRep.Ctor ("UseNamespace", SOME (cvtEXPR x281))
| cvtPRAGMA (UseDefaultNamespace x284) = PrettyRep.Ctor ("UseDefaultNamespace",
SOME (cvtEXPR x284))
| cvtPRAGMA (UseNumber x287) = PrettyRep.Ctor ("UseNumber", SOME (cvtNUMBER_TYPE x287))
| cvtPRAGMA (UseRounding r290) = PrettyRep.Ctor ("UseRounding", SOME (PrettyRep.DecRm r290))
| cvtPRAGMA (UsePrecision n293) = PrettyRep.Ctor ("UsePrecision", SOME (PrettyRep.Int n293))
=======
and cvtPRAGMA (UseNamespace x288) = PrettyRep.Ctor ("UseNamespace", SOME (cvtEXPR x288))
| cvtPRAGMA (UseDefaultNamespace x291) = PrettyRep.Ctor ("UseDefaultNamespace",
SOME (cvtEXPR x291))
| cvtPRAGMA (UseNumber x294) = PrettyRep.Ctor ("UseNumber", SOME (cvtNUMBER_TYPE x294))
| cvtPRAGMA (UseRounding r297) = PrettyRep.Ctor ("UseRounding", SOME (PrettyRep.DecRm r297))
| cvtPRAGMA (UsePrecision n300) = PrettyRep.Ctor ("UsePrecision", SOME (PrettyRep.Int n300))
>>>>>>> .theirs
| cvtPRAGMA (UseStrict) = PrettyRep.Ctor ("UseStrict", NONE)
| cvtPRAGMA (UseStandard) = PrettyRep.Ctor ("UseStandard", NONE)
<<<<<<< .mine
| cvtPRAGMA (Import{package=ls299, name=x303, alias=opt305}) = PrettyRep.Ctor ("Import",
SOME (PrettyRep.Rec [("package", PrettyRep.List (List.map (fn x298 =>
cvtIDENT x298
) ls299)),
("name", cvtIDENT x303), ("alias",
(case opt305 of
=======
| cvtPRAGMA (Import{package=ls306, name=x310, alias=opt312}) = PrettyRep.Ctor ("Import",
SOME (PrettyRep.Rec [("package", PrettyRep.List (List.map (fn x305 =>
cvtIDENT x305
) ls306)),
("name", cvtIDENT x310), ("alias",
(case opt312 of
>>>>>>> .theirs
NONE => PrettyRep.Ctor ("NONE", NONE)
<<<<<<< .mine
| SOME x304 => PrettyRep.Ctor ("SOME", SOME (cvtIDENT x304))
=======
| SOME x311 => PrettyRep.Ctor ("SOME", SOME (cvtIDENT x311))
>>>>>>> .theirs
))]))
and cvtFUNC_NAME_KIND (Ordinary) = PrettyRep.Ctor ("Ordinary", NONE)
| cvtFUNC_NAME_KIND (Operator) = PrettyRep.Ctor ("Operator", NONE)
| cvtFUNC_NAME_KIND (Get) = PrettyRep.Ctor ("Get", NONE)
| cvtFUNC_NAME_KIND (Set) = PrettyRep.Ctor ("Set", NONE)
| cvtFUNC_NAME_KIND (Call) = PrettyRep.Ctor ("Call", NONE)
| cvtFUNC_NAME_KIND (Has) = PrettyRep.Ctor ("Has", NONE)
<<<<<<< .mine
and cvtCLS (Cls{name=x324, nonnullable=b325, extends=opt327, implements=ls332,
classFixtures=x336, instanceFixtures=x337, instanceInits=x338, constructor=opt340,
classType=x344, instanceType=x345}) = PrettyRep.Ctor ("Cls", SOME (PrettyRep.Rec [("name",
cvtNAME x324), ("nonnullable", PrettyRep.Bool b325), ("extends",
(case opt327 of
=======
and cvtCLS (Cls{name=x331, extends=opt333, implements=ls338, classFixtures=x342,
instanceFixtures=x343, instanceInits=x344, constructor=opt346, classType=x350,
instanceType=x351}) = PrettyRep.Ctor ("Cls", SOME (PrettyRep.Rec [("name",
cvtNAME x331), ("extends",
(case opt333 of
>>>>>>> .theirs
NONE => PrettyRep.Ctor ("NONE", NONE)
| SOME x332 => PrettyRep.Ctor ("SOME", SOME (cvtNAME x332))
)), ("implements", PrettyRep.List (List.map (fn x337 => cvtNAME x337
) ls338)), ("classFixtures",
cvtFIXTURES x342), ("instanceFixtures", cvtFIXTURES x343), ("instanceInits",
cvtHEAD x344), ("constructor",
(case opt346 of
NONE => PrettyRep.Ctor ("NONE", NONE)
<<<<<<< .mine
| SOME x339 => PrettyRep.Ctor ("SOME", SOME (cvtCTOR x339))
)), ("classType", cvtTYPE_EXPR x344), ("instanceType", cvtTYPE_EXPR x345)]))
and cvtCTOR (Ctor{settings=x369, superArgs=ls371, func=x375}) = PrettyRep.Ctor ("Ctor",
SOME (PrettyRep.Rec [("settings", cvtHEAD x369), ("superArgs", PrettyRep.List (List.map (fn x370 =>
cvtEXPR x370
) ls371)),
("func", cvtFUNC x375)]))
and cvtFUNC (Func{name=x385, fsig=x386, isNative=b387, block=x388, param=x389,
defaults=ls391, ty=x395}) = PrettyRep.Ctor ("Func", SOME (PrettyRep.Rec [("name",
cvtFUNC_NAME x385), ("fsig", cvtFUNC_SIG x386), ("isNative", PrettyRep.Bool b387),
("block", cvtBLOCK x388), ("param", cvtHEAD x389), ("defaults", PrettyRep.List (List.map (fn x390 =>
cvtEXPR x390
) ls391)),
("ty", cvtFUNC_TYPE x395)]))
and cvtDEFN (ClassDefn x413) = PrettyRep.Ctor ("ClassDefn", SOME (cvtCLASS_DEFN x413))
| cvtDEFN (VariableDefn x416) = PrettyRep.Ctor ("VariableDefn", SOME (cvtVAR_DEFN x416))
| cvtDEFN (FunctionDefn x419) = PrettyRep.Ctor ("FunctionDefn", SOME (cvtFUNC_DEFN x419))
| cvtDEFN (ConstructorDefn x422) = PrettyRep.Ctor ("ConstructorDefn",
SOME (cvtCTOR_DEFN x422))
| cvtDEFN (InterfaceDefn x425) = PrettyRep.Ctor ("InterfaceDefn", SOME (cvtINTERFACE_DEFN x425))
| cvtDEFN (NamespaceDefn x428) = PrettyRep.Ctor ("NamespaceDefn", SOME (cvtNAMESPACE_DEFN x428))
| cvtDEFN (TypeDefn x431) = PrettyRep.Ctor ("TypeDefn", SOME (cvtTYPE_DEFN x431))
and cvtFUNC_SIG (FunctionSignature{typeParams=ls435, params=x439, paramTypes=ls441,
defaults=ls446, ctorInits=opt457, returnType=x461, thisType=opt463,
hasRest=b467}) = PrettyRep.Ctor ("FunctionSignature", SOME (PrettyRep.Rec [("typeParams",
PrettyRep.List (List.map (fn x434 => cvtIDENT x434
) ls435)), ("params", cvtBINDINGS x439),
("paramTypes", PrettyRep.List (List.map (fn x440 => cvtTYPE_EXPR x440
) ls441)), ("defaults", PrettyRep.List (List.map (fn x445 =>
cvtEXPR x445
) ls446)),
=======
| SOME x345 => PrettyRep.Ctor ("SOME", SOME (cvtCTOR x345))
)), ("classType", cvtTYPE_EXPR x350), ("instanceType", cvtTYPE_EXPR x351)]))
and cvtCTOR (Ctor{settings=x373, superArgs=ls375, func=x379}) = PrettyRep.Ctor ("Ctor",
SOME (PrettyRep.Rec [("settings", cvtHEAD x373), ("superArgs", PrettyRep.List (List.map (fn x374 =>
cvtEXPR x374
) ls375)),
("func", cvtFUNC x379)]))
and cvtFUNC (Func{name=x389, fsig=x390, isNative=b391, block=x392, param=x393,
defaults=ls395, ty=x399}) = PrettyRep.Ctor ("Func", SOME (PrettyRep.Rec [("name",
cvtFUNC_NAME x389), ("fsig", cvtFUNC_SIG x390), ("isNative", PrettyRep.Bool b391),
("block", cvtBLOCK x392), ("param", cvtHEAD x393), ("defaults", PrettyRep.List (List.map (fn x394 =>
cvtEXPR x394
) ls395)),
("ty", cvtFUNC_TYPE x399)]))
and cvtDEFN (ClassDefn x417) = PrettyRep.Ctor ("ClassDefn", SOME (cvtCLASS_DEFN x417))
| cvtDEFN (VariableDefn x420) = PrettyRep.Ctor ("VariableDefn", SOME (cvtVAR_DEFN x420))
| cvtDEFN (FunctionDefn x423) = PrettyRep.Ctor ("FunctionDefn", SOME (cvtFUNC_DEFN x423))
| cvtDEFN (ConstructorDefn x426) = PrettyRep.Ctor ("ConstructorDefn",
SOME (cvtCTOR_DEFN x426))
| cvtDEFN (InterfaceDefn x429) = PrettyRep.Ctor ("InterfaceDefn", SOME (cvtINTERFACE_DEFN x429))
| cvtDEFN (NamespaceDefn x432) = PrettyRep.Ctor ("NamespaceDefn", SOME (cvtNAMESPACE_DEFN x432))
| cvtDEFN (TypeDefn x435) = PrettyRep.Ctor ("TypeDefn", SOME (cvtTYPE_DEFN x435))
and cvtFUNC_SIG (FunctionSignature{typeParams=ls439, params=x443, paramTypes=ls445,
defaults=ls450, ctorInits=opt461, returnType=x465, thisType=opt467,
hasRest=b471}) = PrettyRep.Ctor ("FunctionSignature", SOME (PrettyRep.Rec [("typeParams",
PrettyRep.List (List.map (fn x438 => cvtIDENT x438
) ls439)), ("params", cvtBINDINGS x443),
("paramTypes", PrettyRep.List (List.map (fn x444 => cvtTYPE_EXPR x444
) ls445)), ("defaults", PrettyRep.List (List.map (fn x449 =>
cvtEXPR x449
) ls450)),
>>>>>>> .theirs
("ctorInits",
<<<<<<< .mine
(case opt457 of
NONE => PrettyRep.Ctor ("NONE", NONE)
| SOME(x450, ls452) => PrettyRep.Ctor ("SOME", SOME (PrettyRep.Tuple [cvtBINDINGS x450,
PrettyRep.List (List.map (fn x451 => cvtEXPR x451
) ls452)]))
)), ("returnType", cvtTYPE_EXPR x461), ("thisType",
(case opt463 of
=======
(case opt461 of
>>>>>>> .theirs
NONE => PrettyRep.Ctor ("NONE", NONE)
<<<<<<< .mine
| SOME x462 => PrettyRep.Ctor ("SOME", SOME (cvtTYPE_EXPR x462))
)), ("hasRest", PrettyRep.Bool b467)]))
and cvtBINDING (Binding{ident=x487, ty=x488}) = PrettyRep.Ctor ("Binding",
SOME (PrettyRep.Rec [("ident", cvtBINDING_IDENT x487), ("ty", cvtTYPE_EXPR x488)]))
and cvtBINDING_IDENT (TempIdent n496) = PrettyRep.Ctor ("TempIdent", SOME (PrettyRep.Int n496))
| cvtBINDING_IDENT (ParamIdent n499) = PrettyRep.Ctor ("ParamIdent", SOME (PrettyRep.Int n499))
| cvtBINDING_IDENT (PropIdent x502) = PrettyRep.Ctor ("PropIdent", SOME (cvtIDENT x502))
and cvtINIT_STEP (InitStep(x505, x506)) = PrettyRep.Ctor ("InitStep", SOME (PrettyRep.Tuple [cvtBINDING_IDENT x505,
cvtEXPR x506]))
| cvtINIT_STEP (AssignStep(x510, x511)) = PrettyRep.Ctor ("AssignStep",
SOME (PrettyRep.Tuple [cvtEXPR x510, cvtEXPR x511]))
and cvtTYPE_EXPR (SpecialType x515) = PrettyRep.Ctor ("SpecialType", SOME (cvtSPECIAL_TY x515))
| cvtTYPE_EXPR (UnionType ls519) = PrettyRep.Ctor ("UnionType", SOME (PrettyRep.List (List.map (fn x518 =>
cvtTYPE_EXPR x518
) ls519)))
| cvtTYPE_EXPR (ArrayType ls526) = PrettyRep.Ctor ("ArrayType", SOME (PrettyRep.List (List.map (fn x525 =>
cvtTYPE_EXPR x525
) ls526)))
| cvtTYPE_EXPR (TypeName x532) = PrettyRep.Ctor ("TypeName", SOME (cvtIDENT_EXPR x532))
| cvtTYPE_EXPR (ElementTypeRef(x535, n536)) = PrettyRep.Ctor ("ElementTypeRef",
SOME (PrettyRep.Tuple [cvtTYPE_EXPR x535, PrettyRep.Int n536]))
| cvtTYPE_EXPR (FieldTypeRef(x540, x541)) = PrettyRep.Ctor ("FieldTypeRef",
SOME (PrettyRep.Tuple [cvtTYPE_EXPR x540, cvtIDENT x541]))
| cvtTYPE_EXPR (FunctionType x545) = PrettyRep.Ctor ("FunctionType", SOME (cvtFUNC_TYPE x545))
| cvtTYPE_EXPR (ObjectType ls549) = PrettyRep.Ctor ("ObjectType", SOME (PrettyRep.List (List.map (fn x548 =>
cvtFIELD_TYPE x548
) ls549)))
| cvtTYPE_EXPR (AppType{base=x555, args=ls557}) = PrettyRep.Ctor ("AppType",
SOME (PrettyRep.Rec [("base", cvtTYPE_EXPR x555), ("args", PrettyRep.List (List.map (fn x556 =>
cvtTYPE_EXPR x556
) ls557))]))
| cvtTYPE_EXPR (NullableType{expr=x568, nullable=b569}) = PrettyRep.Ctor ("NullableType",
SOME (PrettyRep.Rec [("expr", cvtTYPE_EXPR x568), ("nullable", PrettyRep.Bool b569)]))
| cvtTYPE_EXPR (InstanceType{name=x577, typeParams=ls579, ty=x583, isDynamic=b584}) =
PrettyRep.Ctor ("InstanceType", SOME (PrettyRep.Rec [("name", cvtNAME x577),
("typeParams", PrettyRep.List (List.map (fn x578 => cvtIDENT x578
) ls579)), ("ty", cvtTYPE_EXPR x583),
("isDynamic", PrettyRep.Bool b584)]))
=======
| SOME(x454, ls456) => PrettyRep.Ctor ("SOME", SOME (PrettyRep.Tuple [cvtBINDINGS x454,
PrettyRep.List (List.map (fn x455 => cvtEXPR x455
) ls456)]))
)), ("returnType", cvtTYPE_EXPR x465), ("thisType",
(case opt467 of
NONE => PrettyRep.Ctor ("NONE", NONE)
| SOME x466 => PrettyRep.Ctor ("SOME", SOME (cvtTYPE_EXPR x466))
)), ("hasRest", PrettyRep.Bool b471)]))
and cvtBINDING (Binding{ident=x491, ty=x492}) = PrettyRep.Ctor ("Binding",
SOME (PrettyRep.Rec [("ident", cvtBINDING_IDENT x491), ("ty", cvtTYPE_EXPR x492)]))
and cvtBINDING_IDENT (TempIdent n500) = PrettyRep.Ctor ("TempIdent", SOME (PrettyRep.Int n500))
| cvtBINDING_IDENT (ParamIdent n503) = PrettyRep.Ctor ("ParamIdent", SOME (PrettyRep.Int n503))
| cvtBINDING_IDENT (PropIdent x506) = PrettyRep.Ctor ("PropIdent", SOME (cvtIDENT x506))
and cvtINIT_STEP (InitStep(x509, x510)) = PrettyRep.Ctor ("InitStep", SOME (PrettyRep.Tuple [cvtBINDING_IDENT x509,
cvtEXPR x510]))
| cvtINIT_STEP (AssignStep(x514, x515)) = PrettyRep.Ctor ("AssignStep",
SOME (PrettyRep.Tuple [cvtEXPR x514, cvtEXPR x515]))
and cvtTYPE_EXPR (SpecialType x519) = PrettyRep.Ctor ("SpecialType", SOME (cvtSPECIAL_TY x519))
| cvtTYPE_EXPR (UnionType ls523) = PrettyRep.Ctor ("UnionType", SOME (PrettyRep.List (List.map (fn x522 =>
cvtTYPE_EXPR x522
) ls523)))
| cvtTYPE_EXPR (ArrayType ls530) = PrettyRep.Ctor ("ArrayType", SOME (PrettyRep.List (List.map (fn x529 =>
cvtTYPE_EXPR x529
) ls530)))
| cvtTYPE_EXPR (TypeName x536) = PrettyRep.Ctor ("TypeName", SOME (cvtIDENT_EXPR x536))
| cvtTYPE_EXPR (ElementTypeRef(x539, n540)) = PrettyRep.Ctor ("ElementTypeRef",
SOME (PrettyRep.Tuple [cvtTYPE_EXPR x539, PrettyRep.Int n540]))
| cvtTYPE_EXPR (FieldTypeRef(x544, x545)) = PrettyRep.Ctor ("FieldTypeRef",
SOME (PrettyRep.Tuple [cvtTYPE_EXPR x544, cvtIDENT x545]))
| cvtTYPE_EXPR (FunctionType x549) = PrettyRep.Ctor ("FunctionType", SOME (cvtFUNC_TYPE x549))
| cvtTYPE_EXPR (ObjectType ls553) = PrettyRep.Ctor ("ObjectType", SOME (PrettyRep.List (List.map (fn x552 =>
cvtFIELD_TYPE x552
) ls553)))
| cvtTYPE_EXPR (AppType{base=x559, args=ls561}) = PrettyRep.Ctor ("AppType",
SOME (PrettyRep.Rec [("base", cvtTYPE_EXPR x559), ("args", PrettyRep.List (List.map (fn x560 =>
cvtTYPE_EXPR x560
) ls561))]))
| cvtTYPE_EXPR (NullableType{expr=x572, nullable=b573}) = PrettyRep.Ctor ("NullableType",
SOME (PrettyRep.Rec [("expr", cvtTYPE_EXPR x572), ("nullable", PrettyRep.Bool b573)]))
| cvtTYPE_EXPR (InstanceType{name=x581, typeParams=ls583, ty=x587, isDynamic=b588}) =
PrettyRep.Ctor ("InstanceType", SOME (PrettyRep.Rec [("name", cvtNAME x581),
("typeParams", PrettyRep.List (List.map (fn x582 => cvtIDENT x582
) ls583)), ("ty", cvtTYPE_EXPR x587),
("isDynamic", PrettyRep.Bool b588)]))
| cvtTYPE_EXPR (NominalType x600) = PrettyRep.Ctor ("NominalType", SOME (cvtNAME x600))
>>>>>>> .theirs
and cvtSTMT (EmptyStmt) = PrettyRep.Ctor ("EmptyStmt", NONE)
<<<<<<< .mine
| cvtSTMT (ExprStmt x597) = PrettyRep.Ctor ("ExprStmt", SOME (cvtEXPR x597))
| cvtSTMT (InitStmt{kind=x600, ns=opt602, prototype=b606, static=b607,
temps=x608, inits=ls610}) = PrettyRep.Ctor ("InitStmt", SOME (PrettyRep.Rec [("kind",
cvtVAR_DEFN_TAG x600), ("ns",
(case opt602 of
=======
| cvtSTMT (ExprStmt x604) = PrettyRep.Ctor ("ExprStmt", SOME (cvtEXPR x604))
| cvtSTMT (InitStmt{kind=x607, ns=opt609, prototype=b613, static=b614,
temps=x615, inits=ls617}) = PrettyRep.Ctor ("InitStmt", SOME (PrettyRep.Rec [("kind",
cvtVAR_DEFN_TAG x607), ("ns",
(case opt609 of
>>>>>>> .theirs
NONE => PrettyRep.Ctor ("NONE", NONE)
<<<<<<< .mine
| SOME x601 => PrettyRep.Ctor ("SOME", SOME (cvtEXPR x601))
)), ("prototype", PrettyRep.Bool b606), ("static", PrettyRep.Bool b607),
("temps", cvtBINDINGS x608), ("inits", PrettyRep.List (List.map (fn x609 =>
cvtINIT_STEP x609
) ls610))]))
| cvtSTMT (ClassBlock{ns=opt630, ident=x634, name=opt636, block=x640}) =
=======
| SOME x608 => PrettyRep.Ctor ("SOME", SOME (cvtEXPR x608))
)), ("prototype", PrettyRep.Bool b613), ("static", PrettyRep.Bool b614),
("temps", cvtBINDINGS x615), ("inits", PrettyRep.List (List.map (fn x616 =>
cvtINIT_STEP x616
) ls617))]))
| cvtSTMT (ClassBlock{ns=opt637, ident=x641, name=opt643, block=x647}) =
>>>>>>> .theirs
PrettyRep.Ctor ("ClassBlock", SOME (PrettyRep.Rec [("ns",
<<<<<<< .mine
(case opt630 of
NONE => PrettyRep.Ctor ("NONE", NONE)
| SOME x629 => PrettyRep.Ctor ("SOME", SOME (cvtEXPR x629))
)), ("ident", cvtIDENT x634), ("name",
(case opt636 of
=======
(case opt637 of
>>>>>>> .theirs
NONE => PrettyRep.Ctor ("NONE", NONE)
<<<<<<< .mine
| SOME x635 => PrettyRep.Ctor ("SOME", SOME (cvtNAME x635))
)), ("block", cvtBLOCK x640)]))
| cvtSTMT (ForInStmt x652) = PrettyRep.Ctor ("ForInStmt", SOME (cvtFOR_ENUM_STMT x652))
| cvtSTMT (ThrowStmt x655) = PrettyRep.Ctor ("ThrowStmt", SOME (cvtEXPR x655))
| cvtSTMT (ReturnStmt x658) = PrettyRep.Ctor ("ReturnStmt", SOME (cvtEXPR x658))
| cvtSTMT (BreakStmt opt662) = PrettyRep.Ctor ("BreakStmt", SOME
(case opt662 of
=======
| SOME x636 => PrettyRep.Ctor ("SOME", SOME (cvtEXPR x636))
)), ("ident", cvtIDENT x641), ("name",
(case opt643 of
>>>>>>> .theirs
NONE => PrettyRep.Ctor ("NONE", NONE)
<<<<<<< .mine
| SOME x661 => PrettyRep.Ctor ("SOME", SOME (cvtIDENT x661))
=======
| SOME x642 => PrettyRep.Ctor ("SOME", SOME (cvtNAME x642))
)), ("block", cvtBLOCK x647)]))
| cvtSTMT (ForInStmt x659) = PrettyRep.Ctor ("ForInStmt", SOME (cvtFOR_ENUM_STMT x659))
| cvtSTMT (ThrowStmt x662) = PrettyRep.Ctor ("ThrowStmt", SOME (cvtEXPR x662))
| cvtSTMT (ReturnStmt x665) = PrettyRep.Ctor ("ReturnStmt", SOME (cvtEXPR x665))
| cvtSTMT (BreakStmt opt669) = PrettyRep.Ctor ("BreakStmt", SOME
(case opt669 of
NONE => PrettyRep.Ctor ("NONE", NONE)
| SOME x668 => PrettyRep.Ctor ("SOME", SOME (cvtIDENT x668))
>>>>>>> .theirs
))
<<<<<<< .mine
| cvtSTMT (ContinueStmt opt669) = PrettyRep.Ctor ("ContinueStmt", SOME
(case opt669 of
=======
| cvtSTMT (ContinueStmt opt676) = PrettyRep.Ctor ("ContinueStmt", SOME
(case opt676 of
>>>>>>> .theirs
NONE => PrettyRep.Ctor ("NONE", NONE)
<<<<<<< .mine
| SOME x668 => PrettyRep.Ctor ("SOME", SOME (cvtIDENT x668))
=======
| SOME x675 => PrettyRep.Ctor ("SOME", SOME (cvtIDENT x675))
>>>>>>> .theirs
))
<<<<<<< .mine
| cvtSTMT (BlockStmt x675) = PrettyRep.Ctor ("BlockStmt", SOME (cvtBLOCK x675))
| cvtSTMT (LabeledStmt(x678, x679)) = PrettyRep.Ctor ("LabeledStmt", SOME (PrettyRep.Tuple [cvtIDENT x678,
cvtSTMT x679]))
| cvtSTMT (LetStmt x683) = PrettyRep.Ctor ("LetStmt", SOME (cvtBLOCK x683))
| cvtSTMT (WhileStmt x686) = PrettyRep.Ctor ("WhileStmt", SOME (cvtWHILE_STMT x686))
| cvtSTMT (DoWhileStmt x689) = PrettyRep.Ctor ("DoWhileStmt", SOME (cvtWHILE_STMT x689))
| cvtSTMT (ForStmt x692) = PrettyRep.Ctor ("ForStmt", SOME (cvtFOR_STMT x692))
| cvtSTMT (IfStmt{cnd=x695, thn=x696, els=x697}) = PrettyRep.Ctor ("IfStmt",
SOME (PrettyRep.Rec [("cnd", cvtEXPR x695), ("thn", cvtSTMT x696),
("els", cvtSTMT x697)]))
| cvtSTMT (WithStmt{obj=x707, ty=x708, body=x709}) = PrettyRep.Ctor ("WithStmt",
SOME (PrettyRep.Rec [("obj", cvtEXPR x707), ("ty", cvtTYPE_EXPR x708),
("body", cvtSTMT x709)]))
| cvtSTMT (TryStmt{block=x719, catches=ls721, finally=opt726}) = PrettyRep.Ctor ("TryStmt",
SOME (PrettyRep.Rec [("block", cvtBLOCK x719), ("catches", PrettyRep.List (List.map (fn x720 =>
cvtCATCH_CLAUSE x720
) ls721)),
=======
| cvtSTMT (BlockStmt x682) = PrettyRep.Ctor ("BlockStmt", SOME (cvtBLOCK x682))
| cvtSTMT (LabeledStmt(x685, x686)) = PrettyRep.Ctor ("LabeledStmt", SOME (PrettyRep.Tuple [cvtIDENT x685,
cvtSTMT x686]))
| cvtSTMT (LetStmt x690) = PrettyRep.Ctor ("LetStmt", SOME (cvtBLOCK x690))
| cvtSTMT (WhileStmt x693) = PrettyRep.Ctor ("WhileStmt", SOME (cvtWHILE_STMT x693))
| cvtSTMT (DoWhileStmt x696) = PrettyRep.Ctor ("DoWhileStmt", SOME (cvtWHILE_STMT x696))
| cvtSTMT (ForStmt x699) = PrettyRep.Ctor ("ForStmt", SOME (cvtFOR_STMT x699))
| cvtSTMT (IfStmt{cnd=x702, thn=x703, els=x704}) = PrettyRep.Ctor ("IfStmt",
SOME (PrettyRep.Rec [("cnd", cvtEXPR x702), ("thn", cvtSTMT x703),
("els", cvtSTMT x704)]))
| cvtSTMT (WithStmt{obj=x714, ty=x715, body=x716}) = PrettyRep.Ctor ("WithStmt",
SOME (PrettyRep.Rec [("obj", cvtEXPR x714), ("ty", cvtTYPE_EXPR x715),
("body", cvtSTMT x716)]))
| cvtSTMT (TryStmt{block=x726, catches=ls728, finally=opt733}) = PrettyRep.Ctor ("TryStmt",
SOME (PrettyRep.Rec [("block", cvtBLOCK x726), ("catches", PrettyRep.List (List.map (fn x727 =>
cvtCATCH_CLAUSE x727
) ls728)),
>>>>>>> .theirs
("finally",
<<<<<<< .mine
(case opt726 of
=======
(case opt733 of
>>>>>>> .theirs
NONE => PrettyRep.Ctor ("NONE", NONE)
<<<<<<< .mine
| SOME x725 => PrettyRep.Ctor ("SOME", SOME (cvtBLOCK x725))
=======
| SOME x732 => PrettyRep.Ctor ("SOME", SOME (cvtBLOCK x732))
>>>>>>> .theirs
))]))
<<<<<<< .mine
| cvtSTMT (SwitchStmt{mode=opt740, cond=x744, labels=ls746, cases=ls751}) =
=======
| cvtSTMT (SwitchStmt{mode=opt747, cond=x751, labels=ls753, cases=ls758}) =
>>>>>>> .theirs
PrettyRep.Ctor ("SwitchStmt", SOME (PrettyRep.Rec [("mode",
<<<<<<< .mine
(case opt740 of
=======
(case opt747 of
>>>>>>> .theirs
NONE => PrettyRep.Ctor ("NONE", NONE)
<<<<<<< .mine
| SOME x739 => PrettyRep.Ctor ("SOME", SOME (cvtNUMERIC_MODE x739))
)), ("cond", cvtEXPR x744), ("labels", PrettyRep.List (List.map (fn x745 =>
cvtIDENT x745
) ls746)),
("cases", PrettyRep.List (List.map (fn x750 => cvtCASE x750
) ls751))]))
| cvtSTMT (SwitchTypeStmt{cond=x766, ty=x767, cases=ls769}) = PrettyRep.Ctor ("SwitchTypeStmt",
SOME (PrettyRep.Rec [("cond", cvtEXPR x766), ("ty", cvtTYPE_EXPR x767),
("cases", PrettyRep.List (List.map (fn x768 => cvtTYPE_CASE x768
) ls769))]))
| cvtSTMT (DXNStmt{expr=x782}) = PrettyRep.Ctor ("DXNStmt", SOME (PrettyRep.Rec [("expr",
cvtEXPR x782)]))
and cvtEXPR (TernaryExpr(x788, x789, x790)) = PrettyRep.Ctor ("TernaryExpr",
SOME (PrettyRep.Tuple [cvtEXPR x788, cvtEXPR x789, cvtEXPR x790]))
| cvtEXPR (BinaryExpr(x794, x795, x796)) = PrettyRep.Ctor ("BinaryExpr",
SOME (PrettyRep.Tuple [cvtBINOP x794, cvtEXPR x795, cvtEXPR x796]))
| cvtEXPR (BinaryTypeExpr(x800, x801, x802)) = PrettyRep.Ctor ("BinaryTypeExpr",
SOME (PrettyRep.Tuple [cvtBINTYPEOP x800, cvtEXPR x801, cvtTYPE_EXPR x802]))
| cvtEXPR (ExpectedTypeExpr(x806, x807)) = PrettyRep.Ctor ("ExpectedTypeExpr",
SOME (PrettyRep.Tuple [cvtTYPE_EXPR x806, cvtEXPR x807]))
| cvtEXPR (UnaryExpr(x811, x812)) = PrettyRep.Ctor ("UnaryExpr", SOME (PrettyRep.Tuple [cvtUNOP x811,
cvtEXPR x812]))
| cvtEXPR (TypeExpr x816) = PrettyRep.Ctor ("TypeExpr", SOME (cvtTYPE_EXPR x816))
=======
| SOME x746 => PrettyRep.Ctor ("SOME", SOME (cvtNUMERIC_MODE x746))
)), ("cond", cvtEXPR x751), ("labels", PrettyRep.List (List.map (fn x752 =>
cvtIDENT x752
) ls753)),
("cases", PrettyRep.List (List.map (fn x757 => cvtCASE x757
) ls758))]))
| cvtSTMT (SwitchTypeStmt{cond=x773, ty=x774, cases=ls776}) = PrettyRep.Ctor ("SwitchTypeStmt",
SOME (PrettyRep.Rec [("cond", cvtEXPR x773), ("ty", cvtTYPE_EXPR x774),
("cases", PrettyRep.List (List.map (fn x775 => cvtTYPE_CASE x775
) ls776))]))
| cvtSTMT (Dxns{expr=x789}) = PrettyRep.Ctor ("Dxns", SOME (PrettyRep.Rec [("expr",
cvtEXPR x789)]))
and cvtEXPR (TernaryExpr(x795, x796, x797, x798)) = PrettyRep.Ctor ("TernaryExpr",
SOME (PrettyRep.Tuple [cvtTRIOP x795, cvtEXPR x796, cvtEXPR x797,
cvtEXPR x798]))
| cvtEXPR (BinaryExpr(x802, x803, x804)) = PrettyRep.Ctor ("BinaryExpr",
SOME (PrettyRep.Tuple [cvtBINOP x802, cvtEXPR x803, cvtEXPR x804]))
| cvtEXPR (BinaryTypeExpr(x808, x809, x810)) = PrettyRep.Ctor ("BinaryTypeExpr",
SOME (PrettyRep.Tuple [cvtBINTYPEOP x808, cvtEXPR x809, cvtTYPE_EXPR x810]))
| cvtEXPR (ExpectedTypeExpr(x814, x815)) = PrettyRep.Ctor ("ExpectedTypeExpr",
SOME (PrettyRep.Tuple [cvtTYPE_EXPR x814, cvtEXPR x815]))
| cvtEXPR (UnaryExpr(x819, x820)) = PrettyRep.Ctor ("UnaryExpr", SOME (PrettyRep.Tuple [cvtUNOP x819,
cvtEXPR x820]))
| cvtEXPR (TypeExpr x824) = PrettyRep.Ctor ("TypeExpr", SOME (cvtTYPE_EXPR x824))
>>>>>>> .theirs
| cvtEXPR (ThisExpr) = PrettyRep.Ctor ("ThisExpr", NONE)
<<<<<<< .mine
| cvtEXPR (YieldExpr opt821) = PrettyRep.Ctor ("YieldExpr", SOME
(case opt821 of
=======
| cvtEXPR (YieldExpr opt829) = PrettyRep.Ctor ("YieldExpr", SOME
(case opt829 of
>>>>>>> .theirs
NONE => PrettyRep.Ctor ("NONE", NONE)
<<<<<<< .mine
| SOME x820 => PrettyRep.Ctor ("SOME", SOME (cvtEXPR x820))
=======
| SOME x828 => PrettyRep.Ctor ("SOME", SOME (cvtEXPR x828))
>>>>>>> .theirs
))
<<<<<<< .mine
| cvtEXPR (SuperExpr opt828) = PrettyRep.Ctor ("SuperExpr", SOME
(case opt828 of
=======
| cvtEXPR (SuperExpr opt836) = PrettyRep.Ctor ("SuperExpr", SOME
(case opt836 of
>>>>>>> .theirs
NONE => PrettyRep.Ctor ("NONE", NONE)
<<<<<<< .mine
| SOME x827 => PrettyRep.Ctor ("SOME", SOME (cvtEXPR x827))
=======
| SOME x835 => PrettyRep.Ctor ("SOME", SOME (cvtEXPR x835))
>>>>>>> .theirs
))
<<<<<<< .mine
| cvtEXPR (LiteralExpr x834) = PrettyRep.Ctor ("LiteralExpr", SOME (cvtLITERAL x834))
| cvtEXPR (CallExpr{func=x837, actuals=ls839}) = PrettyRep.Ctor ("CallExpr",
SOME (PrettyRep.Rec [("func", cvtEXPR x837), ("actuals", PrettyRep.List (List.map (fn x838 =>
cvtEXPR x838
) ls839))]))
| cvtEXPR (ApplyTypeExpr{expr=x850, actuals=ls852}) = PrettyRep.Ctor ("ApplyTypeExpr",
SOME (PrettyRep.Rec [("expr", cvtEXPR x850), ("actuals", PrettyRep.List (List.map (fn x851 =>
cvtTYPE_EXPR x851
) ls852))]))
| cvtEXPR (LetExpr{defs=x863, body=x864, head=opt866}) = PrettyRep.Ctor ("LetExpr",
SOME (PrettyRep.Rec [("defs", cvtBINDINGS x863), ("body", cvtEXPR x864),
=======
| cvtEXPR (LiteralExpr x842) = PrettyRep.Ctor ("LiteralExpr", SOME (cvtLITERAL x842))
| cvtEXPR (CallExpr{func=x845, actuals=ls847}) = PrettyRep.Ctor ("CallExpr",
SOME (PrettyRep.Rec [("func", cvtEXPR x845), ("actuals", PrettyRep.List (List.map (fn x846 =>
cvtEXPR x846
) ls847))]))
| cvtEXPR (ApplyTypeExpr{expr=x858, actuals=ls860}) = PrettyRep.Ctor ("ApplyTypeExpr",
SOME (PrettyRep.Rec [("expr", cvtEXPR x858), ("actuals", PrettyRep.List (List.map (fn x859 =>
cvtTYPE_EXPR x859
) ls860))]))
| cvtEXPR (LetExpr{defs=x871, body=x872, head=opt874}) = PrettyRep.Ctor ("LetExpr",
SOME (PrettyRep.Rec [("defs", cvtBINDINGS x871), ("body", cvtEXPR x872),
>>>>>>> .theirs
("head",
<<<<<<< .mine
(case opt866 of
=======
(case opt874 of
>>>>>>> .theirs
NONE => PrettyRep.Ctor ("NONE", NONE)
<<<<<<< .mine
| SOME x865 => PrettyRep.Ctor ("SOME", SOME (cvtHEAD x865))
=======
| SOME x873 => PrettyRep.Ctor ("SOME", SOME (cvtHEAD x873))
>>>>>>> .theirs
))]))
<<<<<<< .mine
| cvtEXPR (NewExpr{obj=x879, actuals=ls881}) = PrettyRep.Ctor ("NewExpr",
SOME (PrettyRep.Rec [("obj", cvtEXPR x879), ("actuals", PrettyRep.List (List.map (fn x880 =>
cvtEXPR x880
) ls881))]))
| cvtEXPR (ObjectRef{base=x892, ident=x893, pos=opt895}) = PrettyRep.Ctor ("ObjectRef",
SOME (PrettyRep.Rec [("base", cvtEXPR x892), ("ident", cvtIDENT_EXPR x893),
("pos",
(case opt895 of
=======
| cvtEXPR (NewExpr{obj=x887, actuals=ls889}) = PrettyRep.Ctor ("NewExpr",
SOME (PrettyRep.Rec [("obj", cvtEXPR x887), ("actuals", PrettyRep.List (List.map (fn x888 =>
cvtEXPR x888
) ls889))]))
| cvtEXPR (ObjectRef{base=x900, ident=x901, loc=opt903}) = PrettyRep.Ctor ("ObjectRef",
SOME (PrettyRep.Rec [("base", cvtEXPR x900), ("ident", cvtIDENT_EXPR x901),
("loc",
(case opt903 of
>>>>>>> .theirs
NONE => PrettyRep.Ctor ("NONE", NONE)
<<<<<<< .mine
| SOME x894 => PrettyRep.Ctor ("SOME", SOME (cvtPOS x894))
=======
| SOME x902 => PrettyRep.Ctor ("SOME", SOME (cvtLOC x902))
>>>>>>> .theirs
))]))
<<<<<<< .mine
| cvtEXPR (LexicalRef{ident=x908, pos=opt910}) = PrettyRep.Ctor ("LexicalRef",
SOME (PrettyRep.Rec [("ident", cvtIDENT_EXPR x908), ("pos",
(case opt910 of
=======
| cvtEXPR (LexicalRef{ident=x916, loc=opt918}) = PrettyRep.Ctor ("LexicalRef",
SOME (PrettyRep.Rec [("ident", cvtIDENT_EXPR x916), ("loc",
(case opt918 of
>>>>>>> .theirs
NONE => PrettyRep.Ctor ("NONE", NONE)
<<<<<<< .mine
| SOME x909 => PrettyRep.Ctor ("SOME", SOME (cvtPOS x909))
=======
| SOME x917 => PrettyRep.Ctor ("SOME", SOME (cvtLOC x917))
>>>>>>> .theirs
))]))
<<<<<<< .mine
| cvtEXPR (SetExpr(x921, x922, x923)) = PrettyRep.Ctor ("SetExpr", SOME (PrettyRep.Tuple [cvtASSIGNOP x921,