| 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 |
} |