/
lexer.mll
785 lines (720 loc) · 30.5 KB
/
lexer.mll
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
{
open Parser
open Operators
open Source
let convert_pos pos =
{ file = pos.Lexing.pos_fname;
line = pos.Lexing.pos_lnum;
column = pos.Lexing.pos_cnum - pos.Lexing.pos_bol
}
let region lexbuf =
let left = convert_pos (Lexing.lexeme_start_p lexbuf) in
let right = convert_pos (Lexing.lexeme_end_p lexbuf) in
{left = left; right = right}
let error lexbuf msg = raise (Script.Syntax (region lexbuf, msg))
let error_nest start lexbuf msg =
lexbuf.Lexing.lex_start_p <- start;
error lexbuf msg
let unknown lexbuf = error lexbuf ("unknown operator " ^ Lexing.lexeme lexbuf)
let string s =
let b = Buffer.create (String.length s) in
let i = ref 1 in
while !i < String.length s - 1 do
let c = if s.[!i] <> '\\' then s.[!i] else
match (incr i; s.[!i]) with
| 'n' -> '\n'
| 'r' -> '\r'
| 't' -> '\t'
| '\\' -> '\\'
| '\'' -> '\''
| '\"' -> '\"'
| 'u' ->
let j = !i + 2 in
i := String.index_from s j '}';
let n = int_of_string ("0x" ^ String.sub s j (!i - j)) in
let bs = Utf8.encode [n] in
Buffer.add_substring b bs 0 (String.length bs - 1);
bs.[String.length bs - 1]
| h ->
incr i;
Char.chr (int_of_string ("0x" ^ String.make 1 h ^ String.make 1 s.[!i]))
in Buffer.add_char b c;
incr i
done;
Buffer.contents b
let opt = Lib.Option.get
}
let sign = '+' | '-'
let digit = ['0'-'9']
let hexdigit = ['0'-'9''a'-'f''A'-'F']
let num = digit ('_'? digit)*
let hexnum = hexdigit ('_'? hexdigit)*
let letter = ['a'-'z''A'-'Z']
let symbol =
['+''-''*''/''\\''^''~''=''<''>''!''?''@''#''$''%''&''|'':''`''.''\'']
let space = [' ''\t''\n''\r']
let control = ['\x00'-'\x1f'] # space
let ascii = ['\x00'-'\x7f']
let ascii_no_nl = ascii # '\x0a'
let utf8cont = ['\x80'-'\xbf']
let utf8enc =
['\xc2'-'\xdf'] utf8cont
| ['\xe0'] ['\xa0'-'\xbf'] utf8cont
| ['\xed'] ['\x80'-'\x9f'] utf8cont
| ['\xe1'-'\xec''\xee'-'\xef'] utf8cont utf8cont
| ['\xf0'] ['\x90'-'\xbf'] utf8cont utf8cont
| ['\xf4'] ['\x80'-'\x8f'] utf8cont utf8cont
| ['\xf1'-'\xf3'] utf8cont utf8cont utf8cont
let utf8 = ascii | utf8enc
let utf8_no_nl = ascii_no_nl | utf8enc
let escape = ['n''r''t''\\''\'''\"']
let character =
[^'"''\\''\x00'-'\x1f''\x7f'-'\xff']
| utf8enc
| '\\'escape
| '\\'hexdigit hexdigit
| "\\u{" hexnum '}'
let nat = num | "0x" hexnum
let int = sign nat
let frac = num
let hexfrac = hexnum
let float =
sign? num '.' frac?
| sign? num ('.' frac?)? ('e' | 'E') sign? num
| sign? "0x" hexnum '.' hexfrac?
| sign? "0x" hexnum ('.' hexfrac?)? ('p' | 'P') sign? num
| sign? "inf"
| sign? "nan"
| sign? "nan:" "0x" hexnum
let string = '"' character* '"'
let idchar = letter | digit | '_' | symbol
let name = idchar+
let id = '$' name
let keyword = ['a'-'z'] (letter | digit | '_' | '.' | ':')+
let reserved = (idchar | string)+ | ',' | ';' | '[' | ']' | '{' | '}'
let ixx = "i" ("32" | "64")
let fxx = "f" ("32" | "64")
let nxx = ixx | fxx
let vxxx = "v128"
let pixx = "i" ("8" | "16")
let mixx = ixx | pixx
let mfxx = fxx
let sign = "s" | "u"
let mem_size = "8" | "16" | "32"
let v128_int_shape = "i8x16" | "i16x8" | "i32x4" | "i64x2"
let v128_float_shape = "f32x4" | "f64x2"
let v128_shape = v128_int_shape | v128_float_shape
rule token = parse
| "(" { LPAR }
| ")" { RPAR }
| nat as s { NAT s }
| int as s { INT s }
| float as s { FLOAT s }
| string as s { STRING (string s) }
| '"'character*('\n'|eof) { error lexbuf "unclosed string literal" }
| '"'character*['\x00'-'\x09''\x0b'-'\x1f''\x7f']
{ error lexbuf "illegal control character in string literal" }
| '"'character*'\\'_
{ error_nest (Lexing.lexeme_end_p lexbuf) lexbuf "illegal escape" }
| keyword as s
{ match s with
| "i8" -> PACK_TYPE Pack.Pack8
| "i16" -> PACK_TYPE Pack.Pack16
| "i32" -> NUM_TYPE Types.I32T
| "i64" -> NUM_TYPE Types.I64T
| "f32" -> NUM_TYPE Types.F32T
| "f64" -> NUM_TYPE Types.F64T
| "v128" -> VEC_TYPE Types.V128T
| "i8x16" -> VEC_SHAPE (V128.I8x16 ())
| "i16x8" -> VEC_SHAPE (V128.I16x8 ())
| "i32x4" -> VEC_SHAPE (V128.I32x4 ())
| "i64x2" -> VEC_SHAPE (V128.I64x2 ())
| "f32x4" -> VEC_SHAPE (V128.F32x4 ())
| "f64x2" -> VEC_SHAPE (V128.F64x2 ())
| "any" -> ANY
| "anyref" -> ANYREF
| "none" -> NONE
| "nullref" -> NULLREF
| "eq" -> EQ
| "eqref" -> EQREF
| "i31" -> I31
| "i31ref" -> I31REF
| "structref" -> STRUCTREF
| "arrayref" -> ARRAYREF
| "nofunc" -> NOFUNC
| "funcref" -> FUNCREF
| "nullfuncref" -> NULLFUNCREF
| "extern" -> EXTERN
| "noextern" -> NOEXTERN
| "externref" -> EXTERNREF
| "nullexternref" -> NULLEXTERNREF
| "ref" -> REF
| "null" -> NULL
| "array" -> ARRAY
| "struct" -> STRUCT
| "field" -> FIELD
| "mut" -> MUT
| "sub" -> SUB
| "final" -> FINAL
| "rec" -> REC
| "nop" -> NOP
| "unreachable" -> UNREACHABLE
| "drop" -> DROP
| "block" -> BLOCK
| "loop" -> LOOP
| "end" -> END
| "br" -> BR
| "br_if" -> BR_IF
| "br_table" -> BR_TABLE
| "br_on_null" -> BR_ON_NULL br_on_null
| "br_on_non_null" -> BR_ON_NON_NULL br_on_non_null
| "br_on_cast" -> BR_ON_CAST (br_on_cast, br_on_cast_null)
| "br_on_cast_fail" -> BR_ON_CAST_FAIL (br_on_cast_fail, br_on_cast_fail_null)
| "return" -> RETURN
| "if" -> IF
| "then" -> THEN
| "else" -> ELSE
| "select" -> SELECT
| "call" -> CALL
| "call_ref" -> CALL_REF
| "call_indirect" -> CALL_INDIRECT
| "return_call_ref" -> RETURN_CALL_REF
| "local.get" -> LOCAL_GET
| "local.set" -> LOCAL_SET
| "local.tee" -> LOCAL_TEE
| "global.get" -> GLOBAL_GET
| "global.set" -> GLOBAL_SET
| "table.get" -> TABLE_GET
| "table.set" -> TABLE_SET
| "table.size" -> TABLE_SIZE
| "table.grow" -> TABLE_GROW
| "table.fill" -> TABLE_FILL
| "table.copy" -> TABLE_COPY
| "table.init" -> TABLE_INIT
| "elem.drop" -> ELEM_DROP
| "memory.size" -> MEMORY_SIZE
| "memory.grow" -> MEMORY_GROW
| "memory.fill" -> MEMORY_FILL
| "memory.copy" -> MEMORY_COPY
| "memory.init" -> MEMORY_INIT
| "data.drop" -> DATA_DROP
| "i32.load" -> LOAD (fun a o -> i32_load (opt a 2) o)
| "i64.load" -> LOAD (fun a o -> i64_load (opt a 3) o)
| "f32.load" -> LOAD (fun a o -> f32_load (opt a 2) o)
| "f64.load" -> LOAD (fun a o -> f64_load (opt a 3) o)
| "i32.store" -> STORE (fun a o -> i32_store (opt a 2) o)
| "i64.store" -> STORE (fun a o -> i64_store (opt a 3) o)
| "f32.store" -> STORE (fun a o -> f32_store (opt a 2) o)
| "f64.store" -> STORE (fun a o -> f64_store (opt a 3) o)
| "i32.load8_u" -> LOAD (fun a o -> i32_load8_u (opt a 0) o)
| "i32.load8_s" -> LOAD (fun a o -> i32_load8_s (opt a 0) o)
| "i32.load16_u" -> LOAD (fun a o -> i32_load16_u (opt a 1) o)
| "i32.load16_s" -> LOAD (fun a o -> i32_load16_s (opt a 1) o)
| "i64.load8_u" -> LOAD (fun a o -> i64_load8_u (opt a 0) o)
| "i64.load8_s" -> LOAD (fun a o -> i64_load8_s (opt a 0) o)
| "i64.load16_u" -> LOAD (fun a o -> i64_load16_u (opt a 1) o)
| "i64.load16_s" -> LOAD (fun a o -> i64_load16_s (opt a 1) o)
| "i64.load32_u" -> LOAD (fun a o -> i64_load32_u (opt a 2) o)
| "i64.load32_s" -> LOAD (fun a o -> i64_load32_s (opt a 2) o)
| "i32.store8" -> LOAD (fun a o -> i32_store8 (opt a 0) o)
| "i32.store16" -> LOAD (fun a o -> i32_store16 (opt a 1) o)
| "i64.store8" -> LOAD (fun a o -> i64_store8 (opt a 0) o)
| "i64.store16" -> LOAD (fun a o -> i64_store16 (opt a 1) o)
| "i64.store32" -> LOAD (fun a o -> i64_store32 (opt a 2) o)
| "v128.load" -> VEC_LOAD (fun a o -> v128_load (opt a 4) o)
| "v128.store" -> VEC_STORE (fun a o -> v128_store (opt a 4) o)
| "v128.load8x8_u" -> VEC_LOAD (fun a o -> v128_load8x8_u (opt a 3) o)
| "v128.load8x8_s" -> VEC_LOAD (fun a o -> v128_load8x8_s (opt a 3) o)
| "v128.load16x4_u" -> VEC_LOAD (fun a o -> v128_load16x4_u (opt a 3) o)
| "v128.load16x4_s" -> VEC_LOAD (fun a o -> v128_load16x4_s (opt a 3) o)
| "v128.load32x2_u" -> VEC_LOAD (fun a o -> v128_load32x2_u (opt a 3) o)
| "v128.load32x2_s" -> VEC_LOAD (fun a o -> v128_load32x2_s (opt a 3) o)
| "v128.load8_splat" ->
VEC_LOAD (fun a o -> v128_load8_splat (opt a 0) o)
| "v128.load16_splat" ->
VEC_LOAD (fun a o -> v128_load16_splat (opt a 1) o)
| "v128.load32_splat" ->
VEC_LOAD (fun a o -> v128_load32_splat (opt a 2) o)
| "v128.load64_splat" ->
VEC_LOAD (fun a o -> v128_load64_splat (opt a 3) o)
| "v128.load32_zero" ->
VEC_LOAD (fun a o -> v128_load32_zero (opt a 2) o)
| "v128.load64_zero" ->
VEC_LOAD (fun a o -> v128_load64_zero (opt a 3) o)
| "v128.load8_lane" ->
VEC_LOAD_LANE (fun a o i -> v128_load8_lane (opt a 0) o i)
| "v128.load16_lane" ->
VEC_LOAD_LANE (fun a o i -> v128_load16_lane (opt a 1) o i)
| "v128.load32_lane" ->
VEC_LOAD_LANE (fun a o i -> v128_load32_lane (opt a 2) o i)
| "v128.load64_lane" ->
VEC_LOAD_LANE (fun a o i -> v128_load64_lane (opt a 3) o i)
| "v128.store8_lane" ->
VEC_STORE_LANE (fun a o i -> v128_store8_lane (opt a 0) o i)
| "v128.store16_lane" ->
VEC_STORE_LANE (fun a o i -> v128_store16_lane (opt a 1) o i)
| "v128.store32_lane" ->
VEC_STORE_LANE (fun a o i -> v128_store32_lane (opt a 2) o i)
| "v128.store64_lane" ->
VEC_STORE_LANE (fun a o i -> v128_store64_lane (opt a 3) o i)
| "i32.const" ->
CONST (fun s ->
let n = I32.of_string s.it in i32_const (n @@ s.at), Value.I32 n)
| "i64.const" ->
CONST (fun s ->
let n = I64.of_string s.it in i64_const (n @@ s.at), Value.I64 n)
| "f32.const" ->
CONST (fun s ->
let n = F32.of_string s.it in f32_const (n @@ s.at), Value.F32 n)
| "f64.const" ->
CONST (fun s ->
let n = F64.of_string s.it in f64_const (n @@ s.at), Value.F64 n)
| "v128.const" ->
VEC_CONST
(fun shape ss at ->
let v = V128.of_strings shape (List.map (fun s -> s.it) ss) in
(v128_const (v @@ at), Value.V128 v))
| "ref.null" -> REF_NULL
| "ref.func" -> REF_FUNC
| "ref.i31" -> REF_I31
| "ref.struct" -> REF_STRUCT
| "ref.array" -> REF_ARRAY
| "ref.extern" -> REF_EXTERN
| "ref.host" -> REF_HOST
| "ref.is_null" -> REF_IS_NULL ref_is_null
| "ref.as_non_null" -> REF_AS_NON_NULL ref_as_non_null
| "ref.test" -> REF_TEST (ref_test, ref_test_null)
| "ref.cast" -> REF_CAST (ref_cast, ref_cast_null)
| "ref.eq" -> REF_EQ
| "i31.new" -> I31_NEW
| "i31.get_u" -> I31_GET i31_get_u
| "i31.get_s" -> I31_GET i31_get_s
| "struct.new_canon" -> STRUCT_NEW struct_new_canon
| "struct.new_canon_default" -> STRUCT_NEW struct_new_canon_default
| "struct.get" -> STRUCT_GET struct_get
| "struct.get_u" -> STRUCT_GET struct_get_u
| "struct.get_s" -> STRUCT_GET struct_get_s
| "struct.set" -> STRUCT_SET
| "array.new_canon" -> ARRAY_NEW array_new_canon
| "array.new_canon_default" -> ARRAY_NEW array_new_canon_default
| "array.new_canon_fixed" -> ARRAY_NEW_FIXED
| "array.new_canon_elem" -> ARRAY_NEW_ELEM
| "array.new_canon_data" -> ARRAY_NEW_DATA
| "array.get" -> ARRAY_GET array_get
| "array.get_u" -> ARRAY_GET array_get_u
| "array.get_s" -> ARRAY_GET array_get_s
| "array.set" -> ARRAY_SET
| "array.len" -> ARRAY_LEN
| "extern.internalize" -> EXTERN_CONVERT extern_internalize
| "extern.externalize" -> EXTERN_CONVERT extern_externalize
| "i32.clz" -> UNARY i32_clz
| "i32.ctz" -> UNARY i32_ctz
| "i32.popcnt" -> UNARY i32_popcnt
| "i32.extend8_s" -> UNARY i32_extend8_s
| "i32.extend16_s" -> UNARY i32_extend16_s
| "i64.clz" -> UNARY i64_clz
| "i64.ctz" -> UNARY i64_ctz
| "i64.popcnt" -> UNARY i64_popcnt
| "i64.extend8_s" -> UNARY i64_extend8_s
| "i64.extend16_s" -> UNARY i64_extend16_s
| "i64.extend32_s" -> UNARY i64_extend32_s
| "f32.neg" -> UNARY f32_neg
| "f32.abs" -> UNARY f32_abs
| "f32.sqrt" -> UNARY f32_sqrt
| "f32.ceil" -> UNARY f32_ceil
| "f32.floor" -> UNARY f32_floor
| "f32.trunc" -> UNARY f32_trunc
| "f32.nearest" -> UNARY f32_nearest
| "f64.neg" -> UNARY f64_neg
| "f64.abs" -> UNARY f64_abs
| "f64.sqrt" -> UNARY f64_sqrt
| "f64.ceil" -> UNARY f64_ceil
| "f64.floor" -> UNARY f64_floor
| "f64.trunc" -> UNARY f64_trunc
| "f64.nearest" -> UNARY f64_nearest
| "i32.add" -> BINARY i32_add
| "i32.sub" -> BINARY i32_sub
| "i32.mul" -> BINARY i32_mul
| "i32.div_u" -> BINARY i32_div_u
| "i32.div_s" -> BINARY i32_div_s
| "i32.rem_u" -> BINARY i32_rem_u
| "i32.rem_s" -> BINARY i32_rem_s
| "i32.and" -> BINARY i32_and
| "i32.or" -> BINARY i32_or
| "i32.xor" -> BINARY i32_xor
| "i32.shl" -> BINARY i32_shl
| "i32.shr_u" -> BINARY i32_shr_u
| "i32.shr_s" -> BINARY i32_shr_s
| "i32.rotl" -> BINARY i32_rotl
| "i32.rotr" -> BINARY i32_rotr
| "i64.add" -> BINARY i64_add
| "i64.sub" -> BINARY i64_sub
| "i64.mul" -> BINARY i64_mul
| "i64.div_u" -> BINARY i64_div_u
| "i64.div_s" -> BINARY i64_div_s
| "i64.rem_u" -> BINARY i64_rem_u
| "i64.rem_s" -> BINARY i64_rem_s
| "i64.and" -> BINARY i64_and
| "i64.or" -> BINARY i64_or
| "i64.xor" -> BINARY i64_xor
| "i64.shl" -> BINARY i64_shl
| "i64.shr_u" -> BINARY i64_shr_u
| "i64.shr_s" -> BINARY i64_shr_s
| "i64.rotl" -> BINARY i64_rotl
| "i64.rotr" -> BINARY i64_rotr
| "f32.add" -> BINARY f32_add
| "f32.sub" -> BINARY f32_sub
| "f32.mul" -> BINARY f32_mul
| "f32.div" -> BINARY f32_div
| "f32.min" -> BINARY f32_min
| "f32.max" -> BINARY f32_max
| "f32.copysign" -> BINARY f32_copysign
| "f64.add" -> BINARY f64_add
| "f64.sub" -> BINARY f64_sub
| "f64.mul" -> BINARY f64_mul
| "f64.div" -> BINARY f64_div
| "f64.min" -> BINARY f64_min
| "f64.max" -> BINARY f64_max
| "f64.copysign" -> BINARY f64_copysign
| "i32.eqz" -> TEST i32_eqz
| "i64.eqz" -> TEST i64_eqz
| "i32.eq" -> COMPARE i32_eq
| "i32.ne" -> COMPARE i32_ne
| "i32.lt_u" -> COMPARE i32_lt_u
| "i32.lt_s" -> COMPARE i32_lt_s
| "i32.le_u" -> COMPARE i32_le_u
| "i32.le_s" -> COMPARE i32_le_s
| "i32.gt_u" -> COMPARE i32_gt_u
| "i32.gt_s" -> COMPARE i32_gt_s
| "i32.ge_u" -> COMPARE i32_ge_u
| "i32.ge_s" -> COMPARE i32_ge_s
| "i64.eq" -> COMPARE i64_eq
| "i64.ne" -> COMPARE i64_ne
| "i64.lt_u" -> COMPARE i64_lt_u
| "i64.lt_s" -> COMPARE i64_lt_s
| "i64.le_u" -> COMPARE i64_le_u
| "i64.le_s" -> COMPARE i64_le_s
| "i64.gt_u" -> COMPARE i64_gt_u
| "i64.gt_s" -> COMPARE i64_gt_s
| "i64.ge_u" -> COMPARE i64_ge_u
| "i64.ge_s" -> COMPARE i64_ge_s
| "f32.eq" -> COMPARE f32_eq
| "f32.ne" -> COMPARE f32_ne
| "f32.lt" -> COMPARE f32_lt
| "f32.le" -> COMPARE f32_le
| "f32.gt" -> COMPARE f32_gt
| "f32.ge" -> COMPARE f32_ge
| "f64.eq" -> COMPARE f64_eq
| "f64.ne" -> COMPARE f64_ne
| "f64.lt" -> COMPARE f64_lt
| "f64.le" -> COMPARE f64_le
| "f64.gt" -> COMPARE f64_gt
| "f64.ge" -> COMPARE f64_ge
| "i32.wrap_i64" -> CONVERT i32_wrap_i64
| "i64.extend_i32_s" -> CONVERT i64_extend_i32_s
| "i64.extend_i32_u" -> CONVERT i64_extend_i32_u
| "f32.demote_f64" -> CONVERT f32_demote_f64
| "f64.promote_f32" -> CONVERT f64_promote_f32
| "i32.trunc_f32_u" -> CONVERT i32_trunc_f32_u
| "i32.trunc_f32_s" -> CONVERT i32_trunc_f32_s
| "i64.trunc_f32_u" -> CONVERT i64_trunc_f32_u
| "i64.trunc_f32_s" -> CONVERT i64_trunc_f32_s
| "i32.trunc_f64_u" -> CONVERT i32_trunc_f64_u
| "i32.trunc_f64_s" -> CONVERT i32_trunc_f64_s
| "i64.trunc_f64_u" -> CONVERT i64_trunc_f64_u
| "i64.trunc_f64_s" -> CONVERT i64_trunc_f64_s
| "i32.trunc_sat_f32_u" -> CONVERT i32_trunc_sat_f32_u
| "i32.trunc_sat_f32_s" -> CONVERT i32_trunc_sat_f32_s
| "i64.trunc_sat_f32_u" -> CONVERT i64_trunc_sat_f32_u
| "i64.trunc_sat_f32_s" -> CONVERT i64_trunc_sat_f32_s
| "i32.trunc_sat_f64_u" -> CONVERT i32_trunc_sat_f64_u
| "i32.trunc_sat_f64_s" -> CONVERT i32_trunc_sat_f64_s
| "i64.trunc_sat_f64_u" -> CONVERT i64_trunc_sat_f64_u
| "i64.trunc_sat_f64_s" -> CONVERT i64_trunc_sat_f64_s
| "f32.convert_i32_u" -> CONVERT f32_convert_i32_u
| "f32.convert_i32_s" -> CONVERT f32_convert_i32_s
| "f64.convert_i32_u" -> CONVERT f64_convert_i32_u
| "f64.convert_i32_s" -> CONVERT f64_convert_i32_s
| "f32.convert_i64_u" -> CONVERT f32_convert_i64_u
| "f32.convert_i64_s" -> CONVERT f32_convert_i64_s
| "f64.convert_i64_u" -> CONVERT f64_convert_i64_u
| "f64.convert_i64_s" -> CONVERT f64_convert_i64_s
| "f32.reinterpret_i32" -> CONVERT f32_reinterpret_i32
| "f64.reinterpret_i64" -> CONVERT f64_reinterpret_i64
| "i32.reinterpret_f32" -> CONVERT i32_reinterpret_f32
| "i64.reinterpret_f64" -> CONVERT i64_reinterpret_f64
| "v128.not" -> VEC_UNARY v128_not
| "v128.and" -> VEC_UNARY v128_and
| "v128.andnot" -> VEC_UNARY v128_andnot
| "v128.or" -> VEC_UNARY v128_or
| "v128.xor" -> VEC_UNARY v128_xor
| "v128.bitselect" -> VEC_TERNARY v128_bitselect
| "v128.any_true" -> VEC_TEST v128_any_true
| "i8x16.neg" -> VEC_UNARY i8x16_neg
| "i16x8.neg" -> VEC_UNARY i16x8_neg
| "i32x4.neg" -> VEC_UNARY i32x4_neg
| "i64x2.neg" -> VEC_UNARY i64x2_neg
| "i8x16.abs" -> VEC_UNARY i8x16_abs
| "i16x8.abs" -> VEC_UNARY i16x8_abs
| "i32x4.abs" -> VEC_UNARY i32x4_abs
| "i64x2.abs" -> VEC_UNARY i64x2_abs
| "i8x16.popcnt" -> VEC_UNARY i8x16_popcnt
| "i8x16.avgr_u" -> VEC_UNARY i8x16_avgr_u
| "i16x8.avgr_u" -> VEC_UNARY i16x8_avgr_u
| "f32x4.neg" -> VEC_UNARY f32x4_neg
| "f64x2.neg" -> VEC_UNARY f64x2_neg
| "f32x4.abs" -> VEC_UNARY f32x4_abs
| "f64x2.abs" -> VEC_UNARY f64x2_abs
| "f32x4.sqrt" -> VEC_UNARY f32x4_sqrt
| "f64x2.sqrt" -> VEC_UNARY f64x2_sqrt
| "f32x4.ceil" -> VEC_UNARY f32x4_ceil
| "f64x2.ceil" -> VEC_UNARY f64x2_ceil
| "f32x4.floor" -> VEC_UNARY f32x4_floor
| "f64x2.floor" -> VEC_UNARY f64x2_floor
| "f32x4.trunc" -> VEC_UNARY f32x4_trunc
| "f64x2.trunc" -> VEC_UNARY f64x2_trunc
| "f32x4.nearest" -> VEC_UNARY f32x4_nearest
| "f64x2.nearest" -> VEC_UNARY f64x2_nearest
| "i32x4.trunc_sat_f32x4_u" -> VEC_UNARY i32x4_trunc_sat_f32x4_u
| "i32x4.trunc_sat_f32x4_s" -> VEC_UNARY i32x4_trunc_sat_f32x4_s
| "i32x4.trunc_sat_f64x2_u_zero" ->
VEC_UNARY i32x4_trunc_sat_f64x2_u_zero
| "i32x4.trunc_sat_f64x2_s_zero" ->
VEC_UNARY i32x4_trunc_sat_f64x2_s_zero
| "f64x2.promote_low_f32x4" -> VEC_UNARY f64x2_promote_low_f32x4
| "f32x4.demote_f64x2_zero" -> VEC_UNARY f32x4_demote_f64x2_zero
| "f32x4.convert_i32x4_u" -> VEC_UNARY f32x4_convert_i32x4_u
| "f32x4.convert_i32x4_s" -> VEC_UNARY f32x4_convert_i32x4_s
| "f64x2.convert_low_i32x4_u" -> VEC_UNARY f64x2_convert_low_i32x4_u
| "f64x2.convert_low_i32x4_s" -> VEC_UNARY f64x2_convert_low_i32x4_s
| "i16x8.extadd_pairwise_i8x16_u" ->
VEC_UNARY i16x8_extadd_pairwise_i8x16_u
| "i16x8.extadd_pairwise_i8x16_s" ->
VEC_UNARY i16x8_extadd_pairwise_i8x16_s
| "i32x4.extadd_pairwise_i16x8_u" ->
VEC_UNARY i32x4_extadd_pairwise_i16x8_u
| "i32x4.extadd_pairwise_i16x8_s" ->
VEC_UNARY i32x4_extadd_pairwise_i16x8_s
| "i8x16.eq" -> VEC_BINARY i8x16_eq
| "i16x8.eq" -> VEC_BINARY i16x8_eq
| "i32x4.eq" -> VEC_BINARY i32x4_eq
| "i64x2.eq" -> VEC_BINARY i64x2_eq
| "i8x16.ne" -> VEC_BINARY i8x16_ne
| "i16x8.ne" -> VEC_BINARY i16x8_ne
| "i32x4.ne" -> VEC_BINARY i32x4_ne
| "i64x2.ne" -> VEC_BINARY i64x2_ne
| "i8x16.lt_u" -> VEC_BINARY i8x16_lt_u
| "i8x16.lt_s" -> VEC_BINARY i8x16_lt_s
| "i16x8.lt_u" -> VEC_BINARY i16x8_lt_u
| "i16x8.lt_s" -> VEC_BINARY i16x8_lt_s
| "i32x4.lt_u" -> VEC_BINARY i32x4_lt_u
| "i32x4.lt_s" -> VEC_BINARY i32x4_lt_s
| "i64x2.lt_s" -> VEC_BINARY i64x2_lt_s
| "i8x16.le_u" -> VEC_BINARY i8x16_le_u
| "i8x16.le_s" -> VEC_BINARY i8x16_le_s
| "i16x8.le_u" -> VEC_BINARY i16x8_le_u
| "i16x8.le_s" -> VEC_BINARY i16x8_le_s
| "i32x4.le_u" -> VEC_BINARY i32x4_le_u
| "i32x4.le_s" -> VEC_BINARY i32x4_le_s
| "i64x2.le_s" -> VEC_BINARY i64x2_le_s
| "i8x16.gt_u" -> VEC_BINARY i8x16_gt_u
| "i8x16.gt_s" -> VEC_BINARY i8x16_gt_s
| "i16x8.gt_u" -> VEC_BINARY i16x8_gt_u
| "i16x8.gt_s" -> VEC_BINARY i16x8_gt_s
| "i32x4.gt_u" -> VEC_BINARY i32x4_gt_u
| "i32x4.gt_s" -> VEC_BINARY i32x4_gt_s
| "i64x2.gt_s" -> VEC_BINARY i64x2_gt_s
| "i8x16.ge_u" -> VEC_BINARY i8x16_ge_u
| "i8x16.ge_s" -> VEC_BINARY i8x16_ge_s
| "i16x8.ge_u" -> VEC_BINARY i16x8_ge_u
| "i16x8.ge_s" -> VEC_BINARY i16x8_ge_s
| "i32x4.ge_u" -> VEC_BINARY i32x4_ge_u
| "i32x4.ge_s" -> VEC_BINARY i32x4_ge_s
| "i64x2.ge_s" -> VEC_BINARY i64x2_ge_s
| "f32x4.eq" -> VEC_BINARY f32x4_eq
| "f64x2.eq" -> VEC_BINARY f64x2_eq
| "f32x4.ne" -> VEC_BINARY f32x4_ne
| "f64x2.ne" -> VEC_BINARY f64x2_ne
| "f32x4.lt" -> VEC_BINARY f32x4_lt
| "f64x2.lt" -> VEC_BINARY f64x2_lt
| "f32x4.le" -> VEC_BINARY f32x4_le
| "f64x2.le" -> VEC_BINARY f64x2_le
| "f32x4.gt" -> VEC_BINARY f32x4_gt
| "f64x2.gt" -> VEC_BINARY f64x2_gt
| "f32x4.ge" -> VEC_BINARY f32x4_ge
| "f64x2.ge" -> VEC_BINARY f64x2_ge
| "i8x16.swizzle" -> VEC_BINARY i8x16_swizzle
| "i8x16.add" -> VEC_BINARY i8x16_add
| "i16x8.add" -> VEC_BINARY i16x8_add
| "i32x4.add" -> VEC_BINARY i32x4_add
| "i64x2.add" -> VEC_BINARY i64x2_add
| "i8x16.sub" -> VEC_BINARY i8x16_sub
| "i16x8.sub" -> VEC_BINARY i16x8_sub
| "i32x4.sub" -> VEC_BINARY i32x4_sub
| "i64x2.sub" -> VEC_BINARY i64x2_sub
| "i16x8.mul" -> VEC_BINARY i16x8_mul
| "i32x4.mul" -> VEC_BINARY i32x4_mul
| "i64x2.mul" -> VEC_BINARY i64x2_mul
| "i8x16.add_sat_u" -> VEC_BINARY i8x16_add_sat_u
| "i8x16.add_sat_s" -> VEC_BINARY i8x16_add_sat_s
| "i16x8.add_sat_u" -> VEC_BINARY i16x8_add_sat_u
| "i16x8.add_sat_s" -> VEC_BINARY i16x8_add_sat_s
| "i8x16.sub_sat_u" -> VEC_BINARY i8x16_sub_sat_u
| "i8x16.sub_sat_s" -> VEC_BINARY i8x16_sub_sat_s
| "i16x8.sub_sat_u" -> VEC_BINARY i16x8_sub_sat_u
| "i16x8.sub_sat_s" -> VEC_BINARY i16x8_sub_sat_s
| "i32x4.dot_i16x8_s" -> VEC_BINARY i32x4_dot_i16x8_s
| "i8x16.min_u" -> VEC_BINARY i8x16_min_u
| "i16x8.min_u" -> VEC_BINARY i16x8_min_u
| "i32x4.min_u" -> VEC_BINARY i32x4_min_u
| "i8x16.min_s" -> VEC_BINARY i8x16_min_s
| "i16x8.min_s" -> VEC_BINARY i16x8_min_s
| "i32x4.min_s" -> VEC_BINARY i32x4_min_s
| "i8x16.max_u" -> VEC_BINARY i8x16_max_u
| "i16x8.max_u" -> VEC_BINARY i16x8_max_u
| "i32x4.max_u" -> VEC_BINARY i32x4_max_u
| "i8x16.max_s" -> VEC_BINARY i8x16_max_s
| "i16x8.max_s" -> VEC_BINARY i16x8_max_s
| "i32x4.max_s" -> VEC_BINARY i32x4_max_s
| "f32x4.add" -> VEC_BINARY f32x4_add
| "f64x2.add" -> VEC_BINARY f64x2_add
| "f32x4.sub" -> VEC_BINARY f32x4_sub
| "f64x2.sub" -> VEC_BINARY f64x2_sub
| "f32x4.mul" -> VEC_BINARY f32x4_mul
| "f64x2.mul" -> VEC_BINARY f64x2_mul
| "f32x4.div" -> VEC_BINARY f32x4_div
| "f64x2.div" -> VEC_BINARY f64x2_div
| "f32x4.min" -> VEC_BINARY f32x4_min
| "f64x2.min" -> VEC_BINARY f64x2_min
| "f32x4.max" -> VEC_BINARY f32x4_max
| "f64x2.max" -> VEC_BINARY f64x2_max
| "f32x4.pmin" -> VEC_BINARY f32x4_pmin
| "f64x2.pmin" -> VEC_BINARY f64x2_pmin
| "f32x4.pmax" -> VEC_BINARY f32x4_pmax
| "f64x2.pmax" -> VEC_BINARY f64x2_pmax
| "i16x8.q15mulr_sat_s" -> VEC_BINARY i16x8_q15mulr_sat_s
| "i8x16.narrow_i16x8_u" -> VEC_BINARY i8x16_narrow_i16x8_u
| "i8x16.narrow_i16x8_s" -> VEC_BINARY i8x16_narrow_i16x8_s
| "i16x8.narrow_i32x4_u" -> VEC_BINARY i16x8_narrow_i32x4_u
| "i16x8.narrow_i32x4_s" -> VEC_BINARY i16x8_narrow_i32x4_s
| "i16x8.extend_low_i8x16_u" -> VEC_UNARY i16x8_extend_low_i8x16_u
| "i16x8.extend_low_i8x16_s" -> VEC_UNARY i16x8_extend_low_i8x16_s
| "i16x8.extend_high_i8x16_u" -> VEC_UNARY i16x8_extend_high_i8x16_u
| "i16x8.extend_high_i8x16_s" -> VEC_UNARY i16x8_extend_high_i8x16_s
| "i32x4.extend_low_i16x8_u" -> VEC_UNARY i32x4_extend_low_i16x8_u
| "i32x4.extend_low_i16x8_s" -> VEC_UNARY i32x4_extend_low_i16x8_s
| "i32x4.extend_high_i16x8_u" -> VEC_UNARY i32x4_extend_high_i16x8_u
| "i32x4.extend_high_i16x8_s" -> VEC_UNARY i32x4_extend_high_i16x8_s
| "i64x2.extend_low_i32x4_u" -> VEC_UNARY i64x2_extend_low_i32x4_u
| "i64x2.extend_low_i32x4_s" -> VEC_UNARY i64x2_extend_low_i32x4_s
| "i64x2.extend_high_i32x4_u" -> VEC_UNARY i64x2_extend_high_i32x4_u
| "i64x2.extend_high_i32x4_s" -> VEC_UNARY i64x2_extend_high_i32x4_s
| "i16x8.extmul_low_i8x16_u" -> VEC_UNARY i16x8_extmul_low_i8x16_u
| "i16x8.extmul_low_i8x16_s" -> VEC_UNARY i16x8_extmul_low_i8x16_s
| "i16x8.extmul_high_i8x16_u" -> VEC_UNARY i16x8_extmul_high_i8x16_u
| "i16x8.extmul_high_i8x16_s" -> VEC_UNARY i16x8_extmul_high_i8x16_s
| "i32x4.extmul_low_i16x8_u" -> VEC_UNARY i32x4_extmul_low_i16x8_u
| "i32x4.extmul_low_i16x8_s" -> VEC_UNARY i32x4_extmul_low_i16x8_s
| "i32x4.extmul_high_i16x8_u" -> VEC_UNARY i32x4_extmul_high_i16x8_u
| "i32x4.extmul_high_i16x8_s" -> VEC_UNARY i32x4_extmul_high_i16x8_s
| "i64x2.extmul_low_i32x4_u" -> VEC_UNARY i64x2_extmul_low_i32x4_u
| "i64x2.extmul_low_i32x4_s" -> VEC_UNARY i64x2_extmul_low_i32x4_s
| "i64x2.extmul_high_i32x4_u" -> VEC_UNARY i64x2_extmul_high_i32x4_u
| "i64x2.extmul_high_i32x4_s" -> VEC_UNARY i64x2_extmul_high_i32x4_s
| "i8x16.all_true" -> VEC_TEST i8x16_all_true
| "i16x8.all_true" -> VEC_TEST i16x8_all_true
| "i32x4.all_true" -> VEC_TEST i32x4_all_true
| "i64x2.all_true" -> VEC_TEST i64x2_all_true
| "i8x16.bitmask" -> VEC_BITMASK i8x16_bitmask
| "i16x8.bitmask" -> VEC_BITMASK i16x8_bitmask
| "i32x4.bitmask" -> VEC_BITMASK i32x4_bitmask
| "i64x2.bitmask" -> VEC_BITMASK i64x2_bitmask
| "i8x16.shl" -> VEC_SHIFT i8x16_shl
| "i16x8.shl" -> VEC_SHIFT i16x8_shl
| "i32x4.shl" -> VEC_SHIFT i32x4_shl
| "i64x2.shl" -> VEC_SHIFT i64x2_shl
| "i8x16.shr_u" -> VEC_SHIFT i8x16_shr_u
| "i8x16.shr_s" -> VEC_SHIFT i8x16_shr_s
| "i16x8.shr_u" -> VEC_SHIFT i16x8_shr_u
| "i16x8.shr_s" -> VEC_SHIFT i16x8_shr_s
| "i32x4.shr_u" -> VEC_SHIFT i32x4_shr_u
| "i32x4.shr_s" -> VEC_SHIFT i32x4_shr_s
| "i64x2.shr_u" -> VEC_SHIFT i64x2_shr_u
| "i64x2.shr_s" -> VEC_SHIFT i64x2_shr_s
| "i8x16.shuffle" -> VEC_SHUFFLE
| "i8x16.splat" -> VEC_SPLAT i8x16_splat
| "i16x8.splat" -> VEC_SPLAT i16x8_splat
| "i32x4.splat" -> VEC_SPLAT i32x4_splat
| "i64x2.splat" -> VEC_SPLAT i64x2_splat
| "f32x4.splat" -> VEC_SPLAT f32x4_splat
| "f64x2.splat" -> VEC_SPLAT f64x2_splat
| "i8x16.extract_lane_u" -> VEC_EXTRACT i8x16_extract_lane_u
| "i8x16.extract_lane_s" -> VEC_EXTRACT i8x16_extract_lane_s
| "i16x8.extract_lane_u" -> VEC_EXTRACT i16x8_extract_lane_u
| "i16x8.extract_lane_s" -> VEC_EXTRACT i16x8_extract_lane_s
| "i32x4.extract_lane" -> VEC_EXTRACT i32x4_extract_lane
| "i64x2.extract_lane" -> VEC_EXTRACT i64x2_extract_lane
| "f32x4.extract_lane" -> VEC_EXTRACT f32x4_extract_lane
| "f64x2.extract_lane" -> VEC_EXTRACT f64x2_extract_lane
| "i8x16.replace_lane" -> VEC_REPLACE i8x16_replace_lane
| "i16x8.replace_lane" -> VEC_REPLACE i16x8_replace_lane
| "i32x4.replace_lane" -> VEC_REPLACE i32x4_replace_lane
| "i64x2.replace_lane" -> VEC_REPLACE i64x2_replace_lane
| "f32x4.replace_lane" -> VEC_REPLACE f32x4_replace_lane
| "f64x2.replace_lane" -> VEC_REPLACE f64x2_replace_lane
| "type" -> TYPE
| "func" -> FUNC
| "param" -> PARAM
| "result" -> RESULT
| "start" -> START
| "local" -> LOCAL
| "global" -> GLOBAL
| "table" -> TABLE
| "memory" -> MEMORY
| "elem" -> ELEM
| "data" -> DATA
| "declare" -> DECLARE
| "offset" -> OFFSET
| "item" -> ITEM
| "import" -> IMPORT
| "export" -> EXPORT
| "module" -> MODULE
| "binary" -> BIN
| "quote" -> QUOTE
| "script" -> SCRIPT
| "register" -> REGISTER
| "invoke" -> INVOKE
| "get" -> GET
| "assert_malformed" -> ASSERT_MALFORMED
| "assert_invalid" -> ASSERT_INVALID
| "assert_unlinkable" -> ASSERT_UNLINKABLE
| "assert_return" -> ASSERT_RETURN
| "assert_trap" -> ASSERT_TRAP
| "assert_exhaustion" -> ASSERT_EXHAUSTION
| "nan:canonical" -> NAN Script.CanonicalNan
| "nan:arithmetic" -> NAN Script.ArithmeticNan
| "input" -> INPUT
| "output" -> OUTPUT
| _ -> unknown lexbuf
}
| "offset="(nat as s) { OFFSET_EQ_NAT s }
| "align="(nat as s) { ALIGN_EQ_NAT s }
| id as s { VAR s }
| ";;"utf8_no_nl*eof { EOF }
| ";;"utf8_no_nl*'\n' { Lexing.new_line lexbuf; token lexbuf }
| ";;"utf8_no_nl* { token lexbuf (* causes error on following position *) }
| "(;" { comment (Lexing.lexeme_start_p lexbuf) lexbuf; token lexbuf }
| space#'\n' { token lexbuf }
| '\n' { Lexing.new_line lexbuf; token lexbuf }
| eof { EOF }
| reserved { unknown lexbuf }
| control { error lexbuf "misplaced control character" }
| utf8enc { error lexbuf "misplaced unicode character" }
| _ { error lexbuf "malformed UTF-8 encoding" }
and comment start = parse
| ";)" { () }
| "(;" { comment (Lexing.lexeme_start_p lexbuf) lexbuf; comment start lexbuf }
| '\n' { Lexing.new_line lexbuf; comment start lexbuf }
| utf8_no_nl { comment start lexbuf }
| eof { error_nest start lexbuf "unclosed comment" }
| _ { error lexbuf "malformed UTF-8 encoding" }