Debian Codegraph @

src/nekoml/Parser.nml

raw
1 /*
2 * Copyright (C)2005-2022 Haxe Foundation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included in
12 * all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
19 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
20 * DEALINGS IN THE SOFTWARE.
21 */
22
23 open Nekoml.Ast
24
25 type error_msg {
26 Unexpected : token;
27 Unclosed : string;
28 }
29
30 exception Error : (error_msg , pos)
31
32 function error_msg(msg) {
33 match msg {
34 | Unexpected t -> "Unexpected " + s_token t
35 | Unclosed s -> "Unclosed " + s
36 }
37 }
38
39 var punion = Lexer.punion;
40
41 function error(m,p) {
42 throw Error(m,p)
43 }
44
45 function priority(op) {
46 match op {
47 | "+=" | "-=" | "*=" | "/=" | "|=" | "&=" | "^=" | ":=" -> -3
48 | "&&" | "||" -> -2
49 | "==" | "!=" | ">" | "<" | "<=" | ">=" | "===" | "!==" | "<>" | "=" -> -1
50 | "+" | "-" -> 0
51 | "*" | "/" -> 1
52 | "or" | "and" | "xor" -> 2
53 | "<<" | ">>" | "%" | ">>>" -> 3
54 | _ -> 4
55 }
56 }
57
58 function can_swap(_op,op) {
59 var p1 = priority _op;
60 var p2 = priority op;
61 if p1 < p2 then
62 true
63 else if p1 == p2 then
64 op != "::"
65 else
66 false
67 }
68
69 function rec make_binop(op,e,e2) {
70 var v , p2 = e2;
71 match v {
72 | EBinop (_op,_e,_e2) when can_swap _op op ->
73 var _e = make_binop op e _e;
74 (EBinop _op _e _e2 , punion (pos _e) (pos _e2))
75 | _ ->
76 (EBinop op e e2 , punion (pos e) (pos e2))
77 }
78 }
79
80 function rec make_unop(op,e,p1) {
81 var v , p2 = e;
82 match v {
83 | EBinop (bop,e,e2) -> ( EBinop bop (make_unop op e p1) e2 , punion p1 p2)
84 | _ -> (EUnop op e, punion p1 p2)
85 }
86 }
87
88 function rec make_list_pat(p,l) {
89 match l {
90 | [] -> (PConstr [] "[]" None , p)
91 | x :: l ->
92 var p = snd x;
93 var params = (PTuple [x;make_list_pat p l] , p);
94 (PConstr [] "::" Some(params) , p)
95 }
96 }
97
98 function rec make_list(p,l) {
99 match l {
100 | [] -> (EConst Constr("[]") , p)
101 | x :: l ->
102 var p = snd x;
103 (ECall (EConst Constr("::"), p) [x;make_list p l] , p)
104 }
105 }
106
107 function is_unop(op) {
108 match op {
109 | "-" | "*" | "!" | "&" -> true
110 | _ -> false
111 }
112 }
113
114 function unclosed(s,p) {
115 error (Unclosed s) p
116 }
117
118 function mk(e,p) {
119 (e,p)
120 }
121
122 function rec program(s) {
123 match s {
124 | [< e = expr s; p = program s >] -> e :: p
125 | [< (Semicolon,_); p = program s >] -> p
126 | [< (Eof,_) >] -> []
127 }
128 }
129
130 function rec expr(s) {
131 match s {
132 | [< (BraceOpen,p1); e = block1 s >] ->
133 match s {
134 | [< (BraceClose,p2) >] -> mk e punion(p1,p2)
135 | [< (Eof,_) >] -> unclosed "{" p1
136 }
137 | [< (Keyword Var,p1); (Const (Ident name),_); t = type_opt s; l = vars s; e = expr s >] ->
138 mk EVar((name,t) :: l,e) punion(p1,pos e)
139 | [< (Keyword If,p1); cond = expr s; (Keyword Then,_); e = expr s >] ->
140 match s {
141 | [< (Keyword Else,_); e2 = expr s >] -> mk EIf(cond,e,Some e2) punion(p1,pos e2)
142 | [< >] -> mk EIf(cond,e,None) punion(p1,pos e)
143 }
144 | [< (Keyword Function,p1); r = function_rec s; n = ident_opt s; (ParentOpen _,po); p = parameters_decl s; t = type_opt s; e = expr s >] ->
145 mk EFunction(r,n,p,e,t) punion(p1,pos e)
146 | [< (Keyword Type,p1); pl = type_decl_parameters s; (Const (Ident tname),p2); d , p3 = type_declaration p2 s >] ->
147 mk ETypeDecl(pl,tname,d) punion(p1,p3)
148 | [< (Keyword Exception,p1); (Const (Constr ename),p2); t = type_opt s >] ->
149 mk EErrorDecl(ename,t) punion(p1,p2)
150 | [< (Keyword Match,p1); e = expr s; (BraceOpen,po); pl = patterns_begin s >] ->
151 match s {
152 | [< (BraceClose,pe) >] -> mk EMatch(e,pl) punion(p1,pe)
153 | [< (Eof,_) >] -> unclosed "{" po
154 }
155 | [< (Keyword Try,p1); b = block s; (Keyword Catch,p2); (BraceOpen,po); pl = patterns_begin s >] ->
156 match s {
157 | [< (BraceClose,pe); >] -> mk ETry((EBlock b,punion p1 p2),pl) punion(p1,pe)
158 | [< (Eof,_) >] -> unclosed "{" po
159 }
160 | [< (Keyword While,p1); e = expr s; (BraceOpen,po); b = block s >] ->
161 match s {
162 | [< (BraceClose,pe) >] -> mk EWhile(e,(EBlock b,punion po pe)) punion(po,pe)
163 | [< (Eof,_) >] -> unclosed "{" po
164 }
165 | [< e = expr_short s >] ->
166 e
167 }
168 }
169
170 function rec expr_short(s) {
171 match s {
172 | [< (ParentOpen _,p1); pl = parameters s >] ->
173 match s {
174 | [< (ParentClose,p2) >] -> expr_next (ETupleDecl pl,punion p1 p2) s
175 | [< (Eof,_) >] -> unclosed "(" p1
176 }
177 | [< (Binop op,p) >] ->
178 if ! is_unop op then throw Stream_error;
179 match s {
180 | [< e = expr s >] -> expr_next (make_unop op e p) s
181 }
182 | [< (Const (Constr n),p); e = expr_constr n p s >] ->
183 expr_next e s
184 | [< (Const c,p) >] ->
185 expr_next (EConst c,p) s
186 | [< (BracketOpen,p1); b = block s; (BracketClose,p2) >] ->
187 expr_next (make_list (punion p1 p2) b) s
188 }
189 }
190
191 function rec expr_next(e,s) {
192 match s {
193 | [< (Binop ":",_); t , p = type_path s >] ->
194 expr_next (ETypeAnnot e t,punion (pos e) p) s
195 | [< (ParentOpen false,po); pl = parameters s >] ->
196 match s {
197 | [< (ParentClose,p) >] -> expr_next (ECall e pl,punion (pos e) p) s
198 | [< (Eof,_) >] -> unclosed "(" po
199 }
200 | [< (Dot,_) >] ->
201 match s {
202 | [< (Const (Ident name),p) >] -> expr_next (EField e name,punion (pos e) p) s
203 | [< (BracketOpen,po); e2 = expr s >] ->
204 match s {
205 | [< (BracketClose,p) >] -> expr_next (EArray e e2,punion (pos e) p) s
206 | [< (Eof,_) >] -> unclosed "[" po
207 }
208 }
209 | [< (Binop op,_); e2 = expr s >] ->
210 make_binop op e e2
211 | [< ep = expr_short s >] ->
212 function rec loop(ep) {
213 var p = pos ep;
214 match fst ep {
215 | EApply (e2,l) -> mk EApply(e,e2 :: l) punion(pos e,p)
216 | EBinop (op,e1,e2) -> mk EBinop(op,loop e1,e2) punion(pos e,p)
217 | _ -> mk EApply(e,[ep]) punion(pos e,pos ep)
218 }
219 }
220 loop ep
221 | [< >] ->
222 e
223 }
224 }
225
226 function rec expr_constr(n,p,s) {
227 match s {
228 | [< (Dot,_); e , p2 = expr_constr2 s >] ->
229 match e {
230 | EConst ((Ident _) as c)
231 | EConst ((Constr _) as c) -> mk EConst(Module [n] c) punion(p,p2)
232 | EConst (Module (l,c)) -> mk EConst(Module (n :: l) c) punion(p,p2)
233 | _ -> assert()
234 }
235 | [< >] -> mk EConst(Constr n) p
236 }
237 }
238
239 function rec expr_constr2(s) {
240 match s {
241 | [< (Const (Ident n),p) >] -> mk EConst(Ident n) p
242 | [< (Const (Constr n),p); e = expr_constr n p s >] -> e
243 }
244 }
245
246 function rec block1(s) {
247 match s {
248 | [< (Const (Ident name),p) >] ->
249 match s {
250 | [< (Binop "=",_); e = expr s; l = record_fields s >] -> ERecordDecl ((name,e) :: l)
251 | [< e = expr_next (EConst (Ident name),p) s; b = block s >] -> EBlock (e :: b)
252 }
253 | [< b = block s >] ->
254 EBlock b
255 }
256 }
257
258 function rec record_fields(s) {
259 match s {
260 | [< (Const (Ident name),_); (Binop "=",_); e = expr s; l = record_fields s >] -> (name,e) :: l
261 | [< (Semicolon,_); l = record_fields s >] -> l
262 | [< >] -> []
263 }
264 }
265
266 function rec vars(s) {
267 match s {
268 | [< (Binop "=",_) >] -> []
269 | [< (Comma,_); (Const (Ident name),_); t = type_opt s; l = vars s >] -> (name,t) :: l
270 }
271 }
272
273 function rec block(s) {
274 match s {
275 | [< e = expr s; b = block s >] -> e :: b
276 | [< (Semicolon,_); b = block s >] -> b
277 | [< >] -> []
278 }
279 }
280
281 function rec parameters_decl(s) {
282 match s {
283 | [< (Const (Ident name),_) >] -> parameters_decl_next (ANamed name) s
284 | [< (ParentOpen _,_); l = parameters_decl s >] -> parameters_decl_next (ATuple l) s
285 | [< (ParentClose,_) >] -> []
286 }
287 }
288
289 function rec parameters_decl_next(acc,s) {
290 match s {
291 | [< (Comma,_); p = parameters_decl s >] -> acc :: p
292 | [< (Binop ":",_); t , _ = type_path s >] -> parameters_decl_next ATyped(acc,t) s
293 | [< (ParentClose,_) >] -> [acc]
294 }
295 }
296
297 function rec type_opt(s) {
298 match s {
299 | [< (Binop ":",_); t , _ = type_path s >] -> Some t
300 | [< >] -> None
301 }
302 }
303
304 function rec function_rec(s) {
305 match s {
306 | [< (Const (Ident "rec"),_) >] -> true
307 | [< >] -> false
308 }
309 }
310
311 function rec ident_opt(s) {
312 match s {
313 | [< (Const (Ident name),_) >] -> Some name
314 | [< >] -> None
315 }
316 }
317
318 function rec parameters(s) {
319 match s {
320 | [< e = expr s; p = parameters_next s >] -> e :: p
321 | [< >] -> []
322 }
323 }
324
325 function rec parameters_next(s) {
326 match s {
327 | [< (Comma,_); p = parameters s >] -> p
328 | [< >] -> []
329 }
330 }
331
332 function rec type_path(s) {
333 match s {
334 | [< (Const (Ident tname),p) >] ->
335 type_path_next EType(None,[],tname) p s
336 | [< (Const (Constr m),p); (Dot,_); l = type_path_mod s; (Const (Ident tname),_) >] ->
337 type_path_next EType(None,m :: l,tname) p s
338 | [< (Quote,_); (Const (Ident a),p) >] ->
339 type_path_next (EPoly a) p s
340 | [< (ParentOpen _,_); t , p = type_path s; l , p2 = type_path_list_next p s; (ParentClose,_) >] ->
341 type_path_next (ETuple (t :: l)) p2 s
342 }
343 }
344
345 function rec type_path_list(p,s) {
346 match s {
347 | [< t , p = type_path s; l , p2 = type_path_list_next p s >] -> mk (t :: l) p2
348 }
349 }
350
351 function rec type_path_list_next(p,s) {
352 match s {
353 | [< (Comma,_); t = type_path_list p s >] -> t
354 | [< >] -> ([] , p)
355 }
356 }
357
358 function rec type_path_next(t,p,s) {
359 match s {
360 | [< (Arrow,_); t2 , p = type_path s >] ->
361 mk EArrow(t,t2) p
362 | [< (Const (Ident tname),p) >] ->
363 type_path_next EType(Some t,[],tname) p s
364 | [< (Const (Constr m),p); (Dot,_); l = type_path_mod s; (Const (Ident tname),_) >] ->
365 type_path_next EType(Some t,m :: l,tname) p s
366 | [< >] ->
367 (t , p)
368 }
369 }
370
371 function rec type_path_mod(s) {
372 match s {
373 | [< (Const (Constr m),_); (Dot,_); l = type_path_mod s >] -> m :: l
374 | [< >] -> []
375 }
376 }
377
378 function rec type_decl_parameters(s) {
379 match s {
380 | [< (Quote,_); (Const (Ident a),_); >] -> [a]
381 | [< (ParentOpen _,_); l = type_decl_plist s; (ParentClose,_); >] -> l
382 | [< >] -> []
383 }
384 }
385
386 function rec type_decl_plist(s) {
387 match s {
388 | [< (Quote,_); (Const (Ident a),_); l = type_decl_plist_next s >] -> a :: l
389 }
390 }
391
392 function rec type_decl_plist_next(s) {
393 match s {
394 | [< (Comma,_); l = type_decl_plist s >] -> l
395 | [< >] -> []
396 }
397 }
398
399 function rec type_declaration(p,s) {
400 match s {
401 | [< (BraceOpen,_) >] ->
402 match s {
403 | [< el , p = record_declaration false s >] -> mk ERecord(el) p
404 | [< el , p = union_declaration s >] -> mk EUnion(el) p
405 }
406 | [< (Binop "=",_); t , p = type_path s >] -> mk EAlias(t) p
407 | [< >] -> mk EAbstract p
408 }
409 }
410
411 function rec record_declaration(mut,s) {
412 match s {
413 | [< (BraceClose,p) >] -> mk [] p
414 | [< (Const (Ident "mutable"),_); l = record_declaration true s >] -> l
415 | [< (Semicolon,_); l = record_declaration false s >] -> l
416 | [< (Const (Ident name),_); (Binop ":",_); t , _ = type_path s; l , p = record_declaration false s >] ->
417 mk ((name,mut,t) :: l) p
418 }
419 }
420
421 function rec union_declaration(s) {
422 match s {
423 | [< (BraceClose,p) >] -> mk [] p
424 | [< (Semicolon,_); l = union_declaration s >] -> l
425 | [< (Const (Constr name),_); t = type_opt s; l , p = union_declaration s >] -> mk ((name,t) :: l) p
426 }
427 }
428
429 function rec patterns_begin(s) {
430 match s {
431 | [< (Vertical,_); l = patterns s >] -> l
432 | [< l = patterns s >] -> l
433 }
434 }
435
436 function rec patterns(s) {
437 match s {
438 | [< p = pattern s; pl = pattern_next s; w = when_clause s; (Arrow,pa); b = block s; l = patterns_begin s >] ->
439 var pat = (p :: pl,w,match b { [e] -> e | _ -> mk EBlock(b) pa });
440 pat :: l
441 | [< >] -> []
442 }
443 }
444
445 function rec pattern_next(s) {
446 match s {
447 | [< (Vertical,_); p = pattern s; l = pattern_next s >] -> p :: l
448 | [< >] -> []
449 }
450 }
451
452 function rec pattern(s) {
453 match s {
454 | [< d , p = pattern_decl s >] ->
455 match s {
456 | [< (Const (Ident "as"),_); (Const (Ident v),p2) >] ->
457 mk PAlias(v,(d,p)) punion(p,p2)
458 | [< (Binop "::",_); d2 , p2 = pattern s >] ->
459 mk PConstr([],"::",Some (PTuple [(d,p);(d2,p2)] , punion p p2)) punion(p,p2)
460 | [< t = type_opt s >] ->
461 match t {
462 | None -> mk d p
463 | Some t -> mk PTyped((d,p),t) p
464 }
465 }
466 }
467 }
468
469 function rec pattern_decl(s) {
470 match s {
471 | [< (ParentOpen _,p1); pl = pattern_tuple s; (ParentClose,p2) >] ->
472 mk PTuple(pl) punion(p1,p2)
473 | [< (BraceOpen,p1); (Const (Ident name),_); (Binop "=",_); p = pattern s; pl = pattern_record s; (BraceClose,p2) >] ->
474 mk PRecord((name,p) :: pl,0) punion(p1,p2)
475 | [< (Const (Constr name),p1); l, name2, p2 = pattern_mod_path name p1 s; p , p3 = pattern_opt p2 s >] ->
476 mk PConstr(l,name2,p) punion(p1,p3)
477 | [< (Const (Ident i),p); >] ->
478 mk PIdent(i) p
479 | [< (Const c,p); >] ->
480 mk PConst(c) p
481 | [< (Binop "-",p1); (Const (Int i),p2) >] ->
482 mk PConst(Int (-i)) punion(p1,p2)
483 | [< (BracketOpen,p1); l = pattern_list s; (BracketClose,p2) >] ->
484 make_list_pat (punion p1 p2) l
485 | [< (StreamOpen,p1); l = stream_list s; (StreamClose,p2) >] ->
486 mk PStream(l,0) punion(p1,p2)
487 }
488 }
489
490 function rec pattern_mod_path(name,p,s) {
491 match s {
492 | [< (Dot,_); (Const (Constr n),p); l, n2, p2 = pattern_mod_path n p s >] -> (name :: l , n2 , p2)
493 | [< >] -> ([], name, p)
494 }
495 }
496
497 function rec stream_list(s) {
498 match s {
499 | [< (Const (Ident v),p1) >] ->
500 match s {
501 | [< l = stream_ident_list s; e = expr s >] -> SExpr(v :: l,e) :: stream_next s
502 | [< >] -> SPattern (PIdent v,p1) :: stream_next s
503 }
504 | [< p = pattern s; l = stream_next s >] -> SPattern p :: l
505 | [< >] -> []
506 }
507 }
508
509 function rec stream_ident_list(s) {
510 match s {
511 | [< (Comma,_); (Const (Ident v),_); l = stream_ident_list s >] -> v :: l
512 | [< (Binop "=",_) >] -> []
513 }
514 }
515
516 function rec stream_next(s) {
517 match s {
518 | [< (Semicolon,_); l = stream_list s >] -> l
519 | [< >] -> []
520 }
521 }
522
523 function rec pattern_list(s) {
524 match s {
525 | [< p = pattern s; l = pattern_list_next s >] -> p :: l
526 | [< >] -> []
527 }
528 }
529
530 function rec pattern_list_next(s) {
531 match s {
532 | [< (Semicolon,_); l = pattern_list s >] -> l
533 | [< >] -> []
534 }
535 }
536
537 function rec pattern_tuple(s) {
538 match s {
539 | [< p = pattern s; l = pattern_tuple_next s >] -> p :: l
540 | [< >] -> []
541 }
542 }
543
544 function rec pattern_tuple_next(s) {
545 match s {
546 | [< (Comma,_); l = pattern_tuple s >] -> l
547 | [< >] -> []
548 }
549 }
550
551 function rec pattern_record(s) {
552 match s {
553 | [< (Const (Ident name),_); (Binop "=",_); p = pattern s; l = pattern_record s >] -> (name,p) :: l
554 | [< (Semicolon,_); l = pattern_record s >] -> l
555 | [< >] -> []
556 }
557 }
558
559 function rec pattern_opt(p,s) {
560 match s {
561 | [< p = pattern s >] -> (Some p , snd p)
562 | [< >] -> (None , p)
563 }
564 }
565
566 function rec when_clause(s) {
567 match s {
568 | [< (Keyword When,_); e = expr s >] -> Some e
569 | [< >] -> None
570 }
571 }
572
573 function parse(lex) {
574 var last = &(Eof,Lexer.null_pos);
575 function rec next_token() {
576 var t = Lexer.token lex (*Nekoml.Lexer.token);
577 match fst t {
578 | Comment s | CommentLine s ->
579 next_token()
580 | _ ->
581 last := t;
582 t
583 }
584 };
585 try {
586 var p = program (stream next_token);
587 mk EBlock(p) Lexer.null_pos
588 } catch {
589 Stream_error -> error Unexpected(fst (*last)) snd(*last)
590 }
591 }