5.16.7.23.1. Patterns

Start data section to src/flx_parse.mly[32 /35 ] Next Prev First Last
  2323: pattern:
  2324:   | as_pattern WHEN expr
  2325:     {
  2326:       `PAT_when
  2327:       (
  2328:         rsrange (src_of_pat $1) (src_of_expr $3),
  2329:         $1,
  2330:         $3
  2331:       )
  2332:     }
  2333:   | as_pattern { $1 }
  2334: 
  2335: as_pattern:
  2336:   | variant_pattern AS NAME
  2337:     {
  2338:       `PAT_as
  2339:       (
  2340:         rsrange (src_of_pat $1) (slift (fst $3)),
  2341:         $1,
  2342:         snd $3
  2343:       )
  2344:     }
  2345:   | variant_pattern { $1 }
  2346: 
  2347: variant_pattern:
  2348:   | tuple_pattern { $1 }
  2349: tuple_pattern:
  2350:   | coercive_pattern_list
  2351:     {
  2352:       match $1 with
  2353:       | [x] -> x
  2354:       | _ -> `PAT_tuple
  2355:         (
  2356:           rsrange (src_of_pat (List.hd $1)) (src_of_pat (list_last $1)),
  2357:           $1
  2358:         )
  2359:     }
  2360: 
  2361: coercive_pattern_list:
  2362:   | coercive_pattern COMMA coercive_pattern_list { $1 :: $3 }
  2363:   | coercive_pattern { [$1] }
  2364: 
  2365: coercive_pattern:
  2366:   | atomic_pattern COLON arrow
  2367:     {
  2368:       let sr = rsrange (src_of_pat $1) (src_of_expr $3) in
  2369:       let t = typecode_of_expr $3 in
  2370:       `PAT_coercion (sr,$1,t)
  2371:     }
  2372:   | atomic_pattern { $1 }
  2373: 
  2374: atomic_pattern:
  2375:   /* constants */
  2376:   | STRING { `PAT_string (slift (fst $1), snd $1) }
  2377:   | integral
  2378:     {
  2379:       let sr,t,v = $1 in
  2380:       `PAT_int (sr,t,v)
  2381:     }
  2382:   | NAN { `PAT_nan (slift $1) }
  2383: 
  2384:   /* ranges */
  2385:   | STRING DOTDOT STRING
  2386:     {
  2387:       `PAT_string_range (rstoken (fst $1) (fst $3), snd $1, snd $3)
  2388:     }
  2389:   | integral DOTDOT integral
  2390:     {
  2391:       let sr1,t1,v1 = $1
  2392:       and sr2,t2,v2 = $3
  2393:       in
  2394:       `PAT_int_range (rsrange sr1 sr2, t1,v1,t2,v2)
  2395:     }
  2396: 
  2397:   | floating DOTDOT floating
  2398:     {
  2399:       let sr1,v1 = $1
  2400:       and sr2,v2 = $3
  2401:       in
  2402:       `PAT_float_range
  2403:       (
  2404:        rsrange sr1 sr2,
  2405:        v1, v2
  2406:       )
  2407:     }
  2408: 
  2409:   /* other */
  2410:   | ctor_pattern { $1 }
  2411:   /*
  2412:   | QUEST NAME { `PAT_name (rstoken $1 (fst $2), snd $2) }
  2413:   */
  2414:   | QUEST NAME { let sr = rstoken $1 (fst $2)in `PAT_as (sr,`PAT_any sr, snd $2) }
  2415:   | QUEST { `PAT_any (slift $1) }
  2416:   | UNDERSCORE { `PAT_any (slift $1) }
  2417:   | LPAR pattern RPAR { $2 }
  2418:   | REGEXP STRING LPAR basic_name_comma_list RPAR
  2419:     {
  2420:       let names = List.map snd $4 in
  2421:       `PAT_regexp (rstoken $1 $5, snd $2, names)
  2422:     }
  2423:   | STRUCT LBRACE pat_assigns RBRACE
  2424:     {
  2425:       `PAT_record (rstoken $1 $4, $3)
  2426:     }
  2427: 
  2428: pat_assign:
  2429:   | NAME EQUAL pattern SEMI { snd $1, $3 }
  2430: pat_assigns:
  2431:   | pat_assign pat_assigns  { $1 :: $2 }
  2432:   | pat_assign { [$1] }
  2433: 
  2434: ctor_pattern:
  2435:   | ctor_name atomic_pattern
  2436:     {
  2437:       `PAT_nonconst_ctor
  2438:       (
  2439:         rsrange (src_of_expr $1) (src_of_pat $2),
  2440:         qualified_name_of_expr $1,
  2441:         $2
  2442:       )
  2443:     }
  2444:   | ctor_name
  2445:     {
  2446:       `PAT_const_ctor
  2447:       (
  2448:         src_of_expr $1,
  2449:         qualified_name_of_expr $1
  2450:       )
  2451:     }
  2452: 
  2453: ctor_name:
  2454:   | qualified_name
  2455:     {
  2456:       $1
  2457:       (*
  2458:       match $1 with sr,name,ts ->
  2459:       `AST_name (sr,name,ts)
  2460:       *)
  2461:     }
  2462: 
  2463:   | CASE INTEGER {
  2464:       let sr,t,v = $2 in
  2465:       `AST_case_tag (rstoken $1 sr, Big_int.int_of_big_int v)
  2466:     }
  2467: 
  2468: integral:
  2469:   | INTEGER { let sr,t,v = $1 in slift sr, t, v }
  2470:   | MINUS INTEGER
  2471:     {
  2472:       let sr,t,v = $2 in
  2473:       rstoken $1 sr, t, (Big_int.minus_big_int v)
  2474:     }
  2475: 
  2476: floating:
  2477:   | FLOAT
  2478:     {
  2479:       let sr,t,v = $1 in
  2480:       slift sr, Float_plus (t,v)
  2481:     }
  2482:   | MINUS FLOAT
  2483:     {
  2484:       let sr,t,v = $2 in
  2485:       rstoken $1 sr, Float_minus (t,v)
  2486:     }
  2487:   | INF { slift $1, Float_inf }
  2488:   | MINUS INF { slift $1, Float_minus_inf }
  2489: 
  2490: basic_name:
  2491:   | NAME { $1 }
  2492: basic_name_comma_list:
  2493:   | basic_name COMMA basic_name_comma_list { $1 :: $3 }
  2494:   | basic_name { [$1] }
  2495:   | { [] }
  2496: 
End data section to src/flx_parse.mly[32]