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: