5.16.10. Executable Expressions

Start data section to src/flx_parse.mly[35 /35 ] Prev First
  2628: expr:
  2629:   | LET pattern EQUAL expr IN expr
  2630:     {
  2631:       let sr = rsrange (slift $1) (src_of_expr $6) in
  2632:       `AST_letin (sr,($2,$4,$6))
  2633:     }
  2634:   | rvalue { $1 }
  2635: 
  2636: rvalue:
  2637:   | lambda { $1 }
  2638: 
  2639: /* cannot use fun_args, since ambiguity on the third case (NAME) */
  2640: lambda_fun_arg:
  2641:   | LPAR parameter_comma_list WHEN expr RPAR { rstoken $1 $3,($2,Some $4) }
  2642:   | LPAR parameter_comma_list RPAR { rstoken $1 $3,($2,None) }
  2643: 
  2644: lambda_fun_args:
  2645:   | lambda_fun_arg lambda_fun_args      { $1 :: $2 }
  2646:   | lambda_fun_arg               { [$1] }
  2647: 
  2648: lambda:
  2649:   | dollar_apply { $1 }
  2650: 
  2651:   | adjectives FUNCTION tvarlist lambda_fun_args opt_type_expr EQUAL compound
  2652:     {
  2653:       let sr = rsrange (slift $2) (fst $7) in
  2654:       let vs = $3 in
  2655:       let args = List.map snd $4 in
  2656:       let ret,traint = $5 in
  2657:       let body = snd $7 in
  2658:       `AST_lambda ( sr,(vs,args, ret, body))
  2659:     }
  2660: 
  2661:   | adjectives FUNCTION tvarlist lambda_fun_args opt_type_expr EQRIGHTARROW expr
  2662:     {
  2663:       let sr = rsrange (slift $2) (src_of_expr $7) in
  2664:       let vs = $3 in
  2665:       let args = List.map snd $4 in
  2666:       let body = [`AST_fun_return (sr,$7)] in
  2667:       let ret,traint = $5 in
  2668:       `AST_lambda (sr, (vs,args, ret, body))
  2669:     }
  2670: 
  2671:   | adjectives PROCEDURE tvarlist lambda_fun_args compound
  2672:     {
  2673:       let sr = rsrange (slift $2) (fst $5) in
  2674:       let vs = $3 in
  2675:       let args = List.map snd $4 in
  2676:       `AST_lambda ( sr, (vs,args, `AST_void sr, snd $5))
  2677:     }
  2678: 
  2679:   | adjectives PROCEDURE tvarlist compound
  2680:     {
  2681:       let sr = rsrange (slift $2) (fst $4) in
  2682:       let vs = $3 in
  2683:       `AST_lambda ( sr, (vs,[[],None], `AST_void sr, snd $4))
  2684:     }
  2685: 
  2686: dollar_apply:
  2687:   | tuple UNLESS expr THEN dollar_apply
  2688:     {
  2689:       let sr = rsrange (src_of_expr $1) (src_of_expr $5) in
  2690:       let revcond = apl $2 "lnot" $3 in
  2691:       `AST_cond (sr,(revcond,$1,$5))
  2692:     }
  2693: 
  2694:   | tuple DOLLAR dollar_apply
  2695:     {
  2696:       let sr = rsexpr $1 $3 in
  2697:       `AST_apply (sr, ($1,$3))
  2698:     }
  2699: 
  2700:   | tuple { $1 }
  2701: 
  2702: tuple:
  2703:   | or_condition tuple_suffix
  2704:     {
  2705:       let lst = $1 :: $2 in
  2706:       `AST_tuple ( rslist lst, lst)
  2707:     }
  2708:   | or_condition                        { $1 }
  2709: 
  2710: tuple_suffix:
  2711:   | COMMA or_condition tuple_suffix     { $2 :: $3 }
  2712:   | COMMA or_condition                  { [$2] }
  2713: 
  2714: /* oring formation is 'psuedo-associative' */
  2715: typeexpr: or_condition { $1 }
  2716: or_condition:
  2717:   | and_condition OR or_list
  2718:     {
  2719:       let sr = rsrange
  2720:         (src_of_expr $1)
  2721:         (src_of_expr (list_last $3))
  2722:       in
  2723:       `AST_orlist (sr,$1 :: $3)
  2724:     }
  2725:   | and_condition { $1 }
  2726: 
  2727: or_list:
  2728:   | and_condition OR or_list              { $1 :: $3 }
  2729:   | and_condition                         { [$1] }
  2730: 
  2731: /* oring formation is 'psuedo-associative' */
  2732: and_condition:
  2733:   | not_condition AND and_list
  2734:     {
  2735:       let sr = rsrange
  2736:         (src_of_expr $1)
  2737:         (src_of_expr (list_last $3))
  2738:       in
  2739:       `AST_andlist (sr,$1 :: $3)
  2740:     }
  2741:   | not_condition { $1 }
  2742: 
  2743: and_list:
  2744:   | not_condition AND and_list              { $1 :: $3 }
  2745:   | not_condition                         { [$1] }
  2746: 
  2747: notop:
  2748:   | NOT {$1,"lnot"}
  2749: not_condition:
  2750:   | notop not_condition                 { apl (fst $1) (snd $1) $2 }
  2751:   | comparison                          { $1 }
  2752: 
  2753: chain_cmp_op:
  2754:   | ANDEQEQUAL                         { "eq",$1}
  2755:   | ANDNOTEQUAL                        { "ne",$1}
  2756:   | ANDLESS                            { "lt",$1}
  2757:   | ANDGREATER                         { "gt",$1}
  2758:   | ANDLESSEQUAL                       { "le",$1}
  2759:   | ANDGREATEREQUAL                    { "ge",$1}
  2760: 
  2761: cmp_item:
  2762:   | chain_cmp_op sum                   { $1,$2 }
  2763: 
  2764: cmp_item_list:
  2765:   | cmp_item cmp_item_list             { $1 :: $2 }
  2766:   | cmp_item                           { [$1] }
  2767: 
  2768: cmp_op:
  2769:   | EQEQUAL                            { "eq",$1 }
  2770:   | NOTEQUAL                           { "ne",$1 }
  2771:   | LESS                               { "lt",$1 }
  2772:   | GREATER                            { "gt",$1 }
  2773:   | LESSEQUAL                          { "le",$1 }
  2774:   | GREATEREQUAL                       { "ge",$1 }
  2775:   | ISIN                               { "_isin",$1 }
  2776:     /* hack */
  2777: 
  2778: comparison:
  2779:   | sum cmp_op sum cmp_item_list
  2780:     {
  2781:       let dummy_sr:range_srcref = ("",0,0,0,0) in
  2782:       let unit_tuple:expr_t = `AST_tuple (dummy_sr,[]) in
  2783:       let sr:range_srcref = rsrange (src_of_expr $1) (src_of_expr (snd (list_last $4))) in
  2784:       let si i = string_of_int i in
  2785:       let nm s = `AST_name (dummy_sr,s,[]) in
  2786:       let rec p n lst =
  2787:         match lst with
  2788:         | [] -> []
  2789:         | ((op,opsrc),ex) :: t ->
  2790:            `AST_val_decl(slift opsrc,"_t"^si (n+1), dfltvs,None, Some ex)
  2791:            ::
  2792:            `AST_val_decl
  2793:            (
  2794:              slift opsrc,
  2795:              "_r"^si (n+1),
  2796:              dfltvs,
  2797:              None,
  2798:              Some
  2799:              (
  2800:                apl2 opsrc "land"
  2801:                [
  2802:                  nm ("_r"^si n);
  2803:                  apl2 opsrc op
  2804:                  [
  2805:                    nm ("_t"^si n);
  2806:                    nm ("_t"^si (n+1))
  2807:                  ]
  2808:                ]
  2809:              )
  2810:            )
  2811:            ::
  2812:            p (n+1) t
  2813:       in
  2814:       let stmts =
  2815:         let n = List.length $4 in
  2816:         `AST_val_decl (src_of_expr $3,"_t0",dfltvs,None,Some $3) ::
  2817:         `AST_val_decl
  2818:         (
  2819:           rsrange (src_of_expr $1) (src_of_expr $3),
  2820:           "_r0",dfltvs,
  2821:           None,
  2822:           Some (apl2 (snd $2) (fst $2) [$1; nm "_t0"])
  2823:         )
  2824:         ::
  2825:         p 0 $4
  2826:         @
  2827:         [`AST_fun_return (sr,`AST_name(sr,"_r"^si n,[]))]
  2828:       in
  2829:       `AST_apply
  2830:       (
  2831:         sr,
  2832:         (
  2833:           `AST_lambda (sr,(dfltvs,[[],None],flx_bool, stmts)),
  2834:           unit_tuple
  2835:         )
  2836:       )
  2837:     }
  2838:   | sum cmp_op sum                      { apl2 (snd $2) (fst $2) [$1; $3] }
  2839:   | as_expr                             { $1 }
  2840: 
  2841: as_expr:
  2842:   | as_expr AS NAME
  2843:     {
  2844:       let sr = rsrange (src_of_expr $1) (slift (fst $3)) in
  2845:       `AST_as (sr,($1,snd $3))
  2846:     }
  2847:   | setunion { $1 }
  2848: 
  2849: setunion:
  2850:   | user10 VBARVBAR setunion_list
  2851:     {
  2852:       let sr = rsrange
  2853:         (src_of_expr $1)
  2854:         (src_of_expr (list_last $3))
  2855:       in
  2856:       `AST_setunion (sr,$1 :: $3)
  2857:     }
  2858:   | user10 { $1 }
  2859: 
  2860: setunion_list:
  2861:   | user10 VBARVBAR setunion_list { $1 :: $3 }
  2862:   | user10 { [$1] }
  2863: 
  2864: user10:
  2865:   | user10 USER10 setintersection
  2866:     {
  2867:       let sr,op,fn = $2 in
  2868:       apl2 sr fn [$1;$3]
  2869:     }
  2870:   | setintersection { $1 }
  2871: 
  2872: setintersection:
  2873:   | arrow AMPERAMPER setintersection_list
  2874:     {
  2875:       let sr = rsrange
  2876:         (src_of_expr $1)
  2877:         (src_of_expr (list_last $3))
  2878:       in
  2879:       `AST_setintersection (sr,$1 :: $3)
  2880:     }
  2881:   | arrow { $1 }
  2882: 
  2883: setintersection_list:
  2884:   | arrow AMPERAMPER setintersection_list { $1 :: $3 }
  2885:   | arrow { [$1] }
  2886: 
  2887: 
  2888: arrow:
  2889:   | case_literal RIGHTARROW arrow
  2890:     {
  2891:       let sr = rsexpr $1 $3 in
  2892:       `AST_arrow (sr,($1,$3))
  2893:     }
  2894:   | case_literal LONGRIGHTARROW arrow
  2895:     {
  2896:       let sr = rsexpr $1 $3 in
  2897:       `AST_longarrow (sr,($1,$3))
  2898:     }
  2899:   | case_literal { $1 }
  2900: 
  2901: case_literal:
  2902:   | CASE INTEGER
  2903:     {
  2904:       let sr,t,v = $2 in
  2905:       `AST_case_tag (rstoken $1 sr, Big_int.int_of_big_int v)
  2906:     }
  2907:   | CASE INTEGER OF sum
  2908:     {
  2909:       let _,_,v = $2 in
  2910:       `AST_typed_case
  2911:       (
  2912:         rsrange (slift $1) (src_of_expr $4),
  2913:         Big_int.int_of_big_int v,
  2914:         typecode_of_expr $4
  2915:       )
  2916:     }
  2917:   | CASE NAME OF sum
  2918:     {
  2919:       let sr =  rsrange (slift $1) (src_of_expr $4) in
  2920:       let s = snd $2 in
  2921:       let e = $4 in
  2922:       `AST_variant (sr,(s,e))
  2923:     }
  2924: 
  2925:   | bor { $1 }
  2926: 
  2927: bor:
  2928:   | bor SLOSHVBAR bxor { apl2 $2 "bor" [$1;$3] }
  2929:   | bxor { $1 }
  2930: 
  2931: bxor:
  2932:   | bxor SLOSHCIRCUMFLEX band { apl2 $2 "bxor" [$1;$3] }
  2933:   | band { $1 }
  2934: 
  2935: band:
  2936:   | band SLOSHAMPER shift { apl2 $2 "band" [$1;$3] }
  2937:   | shift { $1 }
  2938: 
  2939: shift:
  2940:   | shift LEFTSHIFT sum { apl2 $2 "shl" [$1;$3] }
  2941:   | shift RIGHTSHIFT sum { apl2 $2 "shr" [$1;$3] }
  2942:   | sum { $1 }
  2943: 
  2944: /* sum formation is 'psuedo-associative' */
  2945: sum:
  2946:   | subtraction PLUS sum_list
  2947:     {
  2948:       let sr = rsrange
  2949:         (src_of_expr $1)
  2950:         (src_of_expr (list_last $3))
  2951:       in
  2952:       `AST_sum (sr,$1 :: $3)
  2953:     }
  2954:   | subtraction { $1 }
  2955: 
  2956: sum_list:
  2957:   | subtraction PLUS sum_list { $1 :: $3 }
  2958:   | subtraction { [$1] }
  2959: 
  2960: subtraction:
  2961:   | subtraction MINUS product { apl2 $2 "sub" [$1; $3] }
  2962:   | product { $1 }
  2963: 
  2964: /* product formation is 'psuedo-associative' */
  2965: product:
  2966:   | term STAR product_list
  2967:     {
  2968:       let sr = rsrange
  2969:         (src_of_expr $1)
  2970:         (src_of_expr (list_last $3))
  2971:       in
  2972:       `AST_product (sr,$1 :: $3)
  2973:     }
  2974:   | term                                { $1 }
  2975: product_list:
  2976:   | term STAR product_list              { $1 :: $3 }
  2977:   | term                                { [$1] }
  2978: 
  2979: 
  2980: /* division is left associative: note higher precedence
  2981:    the product, so that
  2982: 
  2983:    a * b/c * d -> a * (b/c) * d
  2984: */
  2985: term:
  2986:   | term SLASH power                    { apl2 $2 "div" [$1; $3] }
  2987:   | term PERCENT power                  { apl2 $2 "mod" [$1; $3] }
  2988:   | prefixed { $1 }
  2989: 
  2990: /* note weird recursion here: we need to support
  2991:   -x ** -x = -(x**(-x))
  2992: */
  2993: prefixed:
  2994:   | LVAL power
  2995:     {
  2996:       `AST_lvalue
  2997:       (
  2998:         rsrange (slift $1) (src_of_expr $2),
  2999:         $2
  3000:       )
  3001:     }
  3002:   /*
  3003:   | HASH power  { apl $1 "len" $2 }
  3004:   */
  3005:   | EXCLAMATION power  { apl $1 "excl" $2 }
  3006:   | PLUS power  { apl $1 "pos" $2 }
  3007:   | MINUS power { apl $1 "neg" $2 }
  3008:   | TILDE power { apl $1 "compl" $2 }
  3009:   | power       { $1 }
  3010: 
  3011: /* exponentiation is right associative */
  3012: power:
  3013:   | superscript STARSTAR prefixed      { apl2 $2 "pow" [$1; $3] }
  3014:   | superscript { $1 }
  3015: 
  3016: superscript:
  3017:   | superscript CIRCUMFLEX refr
  3018:     {
  3019:       let sr = rsrange (src_of_expr $1) (src_of_expr $3) in
  3020:       `AST_superscript (sr, ($1, $3))
  3021:     }
  3022: 
  3023:   | refr { $1 }
  3024: refr:
  3025:   | UNION LBRACE type_sum_items2 RBRACE
  3026:     {
  3027:       let sr = rstoken $1 $4 in
  3028:       let ls = map (fun (s,_,vs,t)->s,t) $3 in
  3029:       `AST_variant_type (sr,ls)
  3030:     }
  3031: 
  3032:   | STRUCT compound {
  3033:      let sr = rsrange (slift $1) (fst $2) in
  3034:      let es = snd $2 in
  3035:      let flag = ref `Unk in
  3036:      (* this crud distinguishes "a=e;" from "a:t;"  *)
  3037:      let f (stmt:statement_t) = match stmt with
  3038:        | `AST_assign (_,sname,(`Name (_,lhs),None), rhs)
  3039:        | `AST_assign (_,sname,(`Expr (_,`AST_name (_,lhs,[])),None), rhs)
  3040:          when sname = "_set" ->
  3041:          if !flag = `Unk then flag := `Ex
  3042:          else if !flag = `Ty then
  3043:           Flx_exceptions.clierr sr
  3044:           "anonymous struct type components require coercions!"
  3045:          ;
  3046:          lhs,rhs
  3047:        | `AST_call (_,`AST_coercion(_,(`AST_name(_,lhs,[]),rhs)),`AST_tuple (_,[])) ->
  3048:          if !flag = `Unk then flag := `Ty
  3049:          else if !flag = `Ex then
  3050:           Flx_exceptions.clierr sr
  3051:           "anonymous struct components require assignments!"
  3052:          ;
  3053:          lhs,`AST_expr (sr,"dummy",rhs)
  3054: 
  3055:        | _ -> Flx_exceptions.clierr sr
  3056:          "anonymous struct components require assignments!"
  3057:      in
  3058: 
  3059:      let es: (string * expr_t) list = map f es in
  3060:      if !flag = `Unk then
  3061:        if length es = 0 then `AST_tuple (sr,[])
  3062:        else
  3063:          Flx_exceptions.clierr sr
  3064:          "anonymous struct: unrecognizable components!"
  3065:      else if !flag = `Ex then
  3066:        (`AST_record (sr,es):> expr_t)
  3067:      else if !flag = `Ty then
  3068:        let es : (string * typecode_t) list  = map (fun (lhs,x) ->
  3069:          match x with
  3070:          | `AST_expr (_,_,rhs) -> lhs, rhs
  3071:          | _ -> assert false
  3072:          ) es
  3073:        in
  3074:        (`AST_record_type (sr,es) :> expr_t)
  3075:      else assert false
  3076:    }
  3077: 
  3078:   | AMPER refr
  3079:     {
  3080:       `AST_ref
  3081:       (
  3082:         rsrange (slift $1) (src_of_expr $2),
  3083:         $2
  3084:       )
  3085:     }
  3086:   | STAR refr { apl $1 "deref" $2 }
  3087:   | DEREF refr
  3088:     {
  3089:       `AST_deref
  3090:       (
  3091:         rsrange (slift $1) (src_of_expr $2),
  3092:         $2
  3093:       )
  3094:     }
  3095:   | NEW refr
  3096:     {
  3097:       `AST_new
  3098:       (
  3099:         rsrange (slift $1) (src_of_expr $2),
  3100:         $2
  3101:       )
  3102:     }
  3103: 
  3104:   | application { $1 }
  3105: 
  3106: /* applications is left associative */
  3107: application:
  3108:   | application coercion
  3109:     {
  3110:       `AST_apply (rsexpr $1 $2, ($1, $2))
  3111:     }
  3112: /*
  3113:   | MAP coercion coercion
  3114:     {
  3115:       `AST_map (rsrange (slift $1) (src_of_expr $3), $2, $3)
  3116:     }
  3117: */
  3118:   | CASENO coercion {
  3119:       let sr = rsrange (slift $1) (src_of_expr $2) in
  3120:       `AST_case_index (sr,$2)
  3121:     }
  3122: 
  3123:   | MACRO CTOR NAME coercion
  3124:     {
  3125:       let sr = rsrange (slift $1) (src_of_expr $4) in
  3126:       `AST_macro_ctor (sr,(snd $3,$4))
  3127:     }
  3128: 
  3129:   | coercion { $1 }
  3130: 
  3131: 
  3132: coercion:
  3133:   | coercion COLON factor
  3134:     {
  3135:       `AST_coercion (slift $2, ($1, typecode_of_expr $3))
  3136:     }
  3137:   | suffixed_name                  { ($1:>expr_t) }
  3138:   | factor                         { $1 }
  3139: 
  3140: 
  3141: factor:
  3142:   | hash_name                        { ($1:>expr_t) }
  3143:   | factor DOT LSQB expr RSQB          { apl2 $3 "subscript" [$1; $4] }
  3144:   | factor DOT LSQB expr TO expr RSQB  { apl2 $3 "substring" [$1; $4; $6] }
  3145:   | factor DOT LSQB expr TO RSQB       { apl2 $3 "copyfrom" [$1; $4] }
  3146:   | factor DOT LSQB TO expr RSQB       { apl2 $3 "copyto" [$1; $5] }
  3147:   | factor DOT simple_name_parts
  3148:     {
  3149:       let rsr,name,ts = $3 in
  3150:       let sr = rsrange (src_of_expr $1) rsr in
  3151:       `AST_dot (sr, ($1, `AST_name (sr,name,ts)))
  3152:     }
  3153:   | factor DOTRIGHTARROW simple_name_parts
  3154:     {
  3155:       let rsr,name,ts = $3 in
  3156:       let sr = rsrange (src_of_expr $1) rsr in
  3157:       let x = apl $2 "deref" $1 in
  3158:       `AST_dot (sr, (x, `AST_name (sr,name,ts)))
  3159:     }
  3160:   | factor DOT LPAR INTEGER RPAR
  3161:     {
  3162:       match $4 with
  3163:       | (sr,t,v) ->
  3164:         let n =
  3165:           try Big_int.int_of_big_int v
  3166:           with _ ->
  3167:             failwith
  3168:             (
  3169:               "[parser] Tuple index " ^
  3170:               Big_int.string_of_big_int v ^
  3171:               " too big in " ^
  3172:               short_string_of_src (slift sr)
  3173:              )
  3174:         in
  3175:           let sr = rsrange (src_of_expr $1) (slift $5) in
  3176:           `AST_get_n (sr, (n,$1))
  3177:     }
  3178: 
  3179: hash_name:
  3180:   | HASH hash_name { `AST_lift ((slift $1), $2) }
  3181:   | the_name { $1 }
  3182: 
  3183: the_name:
  3184:   | NOEXPAND qualified_name
  3185:     {
  3186:       let e = ($2:>expr_t) in
  3187:       let sr = src_of_expr e in
  3188:       let sr = rsrange (slift $1) sr in
  3189:       `AST_noexpand (sr,e)
  3190:     }
  3191:   | THE qualified_name
  3192:   {
  3193:     let sr = src_of_expr $2 in
  3194:     let sr = rsrange (slift $1) sr in
  3195:     let qn = qualified_name_of_expr $2 in
  3196:     (`AST_the (sr,qn))
  3197:   }
  3198:   | qualified_name { $1 }
  3199:   | QUEST NAME { `AST_patvar (rstoken $1 (fst $2), snd $2) }
  3200:   | atom { $1 }
  3201: 
  3202: qualified_name:
  3203:   | qualified_name COLONCOLON simple_name_parts
  3204:     {
  3205:       match $3 with sr,name,ts ->
  3206:       let sr = rsrange (src_of_expr $1) sr in
  3207:       `AST_lookup (sr,($1, name, ts))
  3208:     }
  3209: 
  3210:   | simple_name_parts
  3211:     {
  3212:       match $1 with sr,name,ts ->
  3213:       (`AST_name (sr,name,ts):>expr_t)
  3214:     }
  3215: 
  3216: elif:
  3217:   | ELIF expr THEN expr { $2,$4 }
  3218: 
  3219: elifs:
  3220:   | elifs elif { $2 :: $1 }
  3221:   | elif { [$1] }
  3222: 
  3223: else_part:
  3224:   | elifs ELSE expr
  3225:     {
  3226:       List.fold_left (* actually a right fold cause list is reversed *)
  3227:       (fun result (cond,thn) ->
  3228:         let sr = rsrange (src_of_expr cond) (src_of_expr result) in
  3229:         `AST_cond
  3230:         (
  3231:           sr,
  3232:           (
  3233:             cond,
  3234:             thn,
  3235:             result
  3236:           )
  3237:         )
  3238:       )
  3239:       $3 $1
  3240:     }
  3241:   | ELSE expr { $2 }
  3242: 
  3243: cond:
  3244:   | IF expr THEN expr else_part ENDIF
  3245:     {
  3246:       `AST_cond (rstoken $1 $6,($2,$4,$5))
  3247:     }
  3248: 
  3249: expr_code_prefix:
  3250:   | CODE LSQB expr RSQB
  3251:     {
  3252:      $1,
  3253:      typecode_of_expr $3
  3254:     }
  3255: 
  3256: 
  3257: 
  3258: atom:
  3259:   | UNDERSCORE { `AST_patany (slift $1) }
  3260:   | CALLBACK LSQB qualified_name RSQB
  3261:     {
  3262:       let sr = rstoken $1 $4 in
  3263:       let qn = qualified_name_of_expr $3 in
  3264:       `AST_callback (sr,qn)
  3265:     }
  3266: 
  3267:   | DOTDOTDOT { `AST_ellipsis (slift $1) }
  3268: 
  3269:   | type_match_expr { $1 }
  3270:   | expr_code_prefix NAME
  3271:     {
  3272:       let sr = rstoken (fst $1) (fst $2) in
  3273:       let s = snd $2 in
  3274:       let t = snd $1 in
  3275:       `AST_expr (sr,s,t)
  3276:     }
  3277: 
  3278:   | expr_code_prefix STRING
  3279:     {
  3280:       let sr = rstoken (fst $1) (fst $2) in
  3281:       let s = snd $2 in
  3282:       let t = snd $1 in
  3283:       `AST_expr (sr,s,t)
  3284:     }
  3285: 
  3286:   | LSQBAR expr RSQBAR
  3287:     {
  3288:       let sr = rstoken $1 $3 in
  3289:       match $2 with
  3290:       | `AST_tuple (_,ls) -> `AST_arrayof (sr,ls)
  3291:       | x -> `AST_arrayof (sr,[x])
  3292:     }
  3293: 
  3294:   | LBRACE expr RBRACE
  3295:     {
  3296:       let sr = rstoken $1 $3 in
  3297:       `AST_lambda
  3298:       (
  3299:         sr,
  3300:         (
  3301:           dfltvs,
  3302:           [[],None],
  3303:           `TYP_none,
  3304:           [`AST_fun_return (sr,$2)]
  3305:         )
  3306:       )
  3307:     }
  3308:   | glr_parse { $1 }
  3309:   | match_expr { $1 }
  3310:   | regmatch_expr { $1 }
  3311:   | typecase { $1 }
  3312:   | compound
  3313:     {
  3314:       let sr, stmts = $1 in
  3315:       `AST_lambda
  3316:       (
  3317:         sr,
  3318:         (dfltvs,[[],None], `TYP_none, stmts)
  3319:       )
  3320: 
  3321:     }
  3322:   | LPAR expr RPAR      { $2 }
  3323:   | LPAR RPAR           { `AST_tuple (rstoken $1 $2,[]) }
  3324:   | literal             { $1 }
  3325:   | cond                { $1 }
  3326:   | FSTRING
  3327:     {
  3328:       let sr,s = $1 in
  3329:       let sr = slift sr in
  3330:       `AST_vsprintf (sr,s)
  3331:     }
  3332:   | QSTRING
  3333:     {
  3334:       let sr,s = $1 in
  3335:       let sr = slift sr in
  3336:       `AST_interpolate (sr,s)
  3337:     }
  3338: 
  3339:   | USERLB expr USERRB
  3340:     {
  3341:       let sr1,fnmap,lsym =$1 and sr2,rsym = $3 in
  3342:       let sr = rstoken sr1 sr2 in
  3343:       try
  3344:         let fn = List.assoc rsym fnmap in
  3345:         apl2 (fst $3) fn [$2]
  3346:       with Not_found ->
  3347:         Flx_exceptions.clierr sr "Mismatched brackets"
  3348:     }
  3349: 
  3350: literal:
  3351:   | integer_literal { $1 }
  3352:   | string_literal { $1 }
  3353:   | float_literal { $1 }
  3354: 
  3355: integer_literal:
  3356:   | INTEGER
  3357:     { let sr,t,v = $1 in
  3358:       `AST_literal (slift sr, `AST_int (t,v))
  3359:     }
  3360: 
  3361: float_literal:
  3362:   | FLOAT
  3363:     {
  3364:       let sr,t,v = $1 in
  3365:       `AST_literal (slift sr, `AST_float (t,v))
  3366:     }
  3367: 
  3368: string_literal:
  3369:   | STRING
  3370:     {
  3371:       let sr,s = $1 in
  3372:       `AST_literal (slift sr, `AST_string s)
  3373:     }
  3374: 
  3375:   | WSTRING
  3376:     {
  3377:       let sr,s = $1 in
  3378:       `AST_literal (slift sr, `AST_wstring s)
  3379:     }
  3380: 
  3381:   | USTRING
  3382:     {
  3383:       let sr,s = $1 in
  3384:       `AST_literal (slift sr, `AST_ustring s)
  3385:     }
  3386: 
  3387:   | CSTRING
  3388:     {
  3389:       let sr,s = $1 in
  3390:       `AST_literal (slift sr, `AST_cstring s)
  3391:     }
  3392: 
  3393: simple_name_parts:
  3394:   | NAME LSQB expr RSQB
  3395:     {
  3396:       rsrange (slift (fst $1)) (slift $4),
  3397:       snd $1,
  3398:       match typecode_of_expr $3 with
  3399:       | `TYP_type_tuple ls -> ls
  3400:       | x -> [x]
  3401:     }
  3402: 
  3403:   | NAME
  3404:     {
  3405:       slift (fst $1),
  3406:       snd $1,
  3407:       []
  3408:     }
  3409: 
  3410: suffixed_name:
  3411:   | qualified_name OF factor
  3412:     {
  3413:       `AST_suffix
  3414:       (
  3415:         rsrange (src_of_expr $1) (src_of_expr $3),
  3416:         (qualified_name_of_expr $1, typecode_of_expr $3)
  3417:       )
  3418:     }
  3419: 
  3420: %%
  3421: (* trailer *)
  3422: 
End data section to src/flx_parse.mly[35]