Browse code
core expr: optimizations fixes for $v op 0|1 -> $v
- fix missing cast for the $v <op> c -> $v optimizations
(e.g. $v - 0 -> $v, 1 * $v -> $v): instead of replacing
$v <op> c with $v use (type_of(<op>)) $v. $v without the cast
to the type produced by the operator is used now only when
type_of($v)==type_of(<op>).
E.g.: 1 * $v -> (int)$v
1 * ($v/$w) -> $v/$w ($v/$w produces always an int, so no
need for the cast)
Bug example: 1*"2"+3 was optimized to "2"+3 == "23" instead of
(int)"2"+3 == 5.
- better debugging messages
Andrei Pelinescu-Onciul authored on 05/05/2009 14:15:01
Showing 1 changed files
| ... | ... |
@@ -2792,6 +2792,37 @@ static int rve_opt_01(struct rval_expr* rve, enum rval_type rve_type) |
| 2792 | 2792 |
enum rval_expr_op op; |
| 2793 | 2793 |
struct cfg_pos pos; |
| 2794 | 2794 |
int right; /* debugging msg */ |
| 2795 |
+ |
|
| 2796 |
+/* helper macro: replace in-place a <ctype> type rve with v (another rve). |
|
| 2797 |
+ * if type_of(v)== <ctype> => rve:=*v (copy v contents into rve and free v) |
|
| 2798 |
+ * else if type_of(v)!=<ctype> => rve:= (ctype) v (casts v to <ctype>) |
|
| 2799 |
+ * Uses pos. |
|
| 2800 |
+ * ctype can be INT or STR |
|
| 2801 |
+ * WARNING: - v might be pkg_free()'d |
|
| 2802 |
+ * - rve members _are_ _not_ freed or destroyed |
|
| 2803 |
+ */ |
|
| 2804 |
+#define replace_rve_type_cast(e, v, ctype) \ |
|
| 2805 |
+ do{\
|
|
| 2806 |
+ if ( rve_guess_type((v)) == RV_##ctype ){\
|
|
| 2807 |
+ /* if type_of($v)==int we don't need to add an \ |
|
| 2808 |
+ int cast operator => replace with v */\ |
|
| 2809 |
+ pos=(e)->fpos; \ |
|
| 2810 |
+ *(e)=*(v); /* replace e with v (in-place) */ \ |
|
| 2811 |
+ (e)->fpos=pos; \ |
|
| 2812 |
+ pkg_free((v)); /* rve_destroy(v_rve) would free everything*/ \ |
|
| 2813 |
+ }else{\
|
|
| 2814 |
+ /* unknown type or str => (int) $v */ \ |
|
| 2815 |
+ (e)->op=RVE_##ctype##_OP; \ |
|
| 2816 |
+ (e)->left.rve=(v); \ |
|
| 2817 |
+ (e)->right.rve=0; \ |
|
| 2818 |
+ }\ |
|
| 2819 |
+ }while(0) |
|
| 2820 |
+ |
|
| 2821 |
+/* helper macro: replace in-place an int type rve with v (another rve).*/ |
|
| 2822 |
+#define replace_int_rve(e, v) replace_rve_type_cast(e, v, INT) |
|
| 2823 |
+/* helper macro: replace in-place a str type rve with v (another rve).*/ |
|
| 2824 |
+#define replace_str_rve(e, v) replace_rve_type_cast(e, v, STR) |
|
| 2825 |
+ |
|
| 2795 | 2826 |
|
| 2796 | 2827 |
rv=0; |
| 2797 | 2828 |
ret=0; |
| ... | ... |
@@ -2827,14 +2858,10 @@ static int rve_opt_01(struct rval_expr* rve, enum rval_type rve_type) |
| 2827 | 2858 |
goto error; |
| 2828 | 2859 |
ret=1; |
| 2829 | 2860 |
}else if (i==1){
|
| 2830 |
- /* $v * 1 -> $v |
|
| 2831 |
- * 1 * $v -> $v */ |
|
| 2861 |
+ /* $v * 1 -> (int)$v |
|
| 2862 |
+ * 1 * $v -> (int)$v */ |
|
| 2832 | 2863 |
rve_destroy(ct_rve); |
| 2833 |
- pos=rve->fpos; |
|
| 2834 |
- *rve=*v_rve; /* replace current expr. with $v */ |
|
| 2835 |
- rve->fpos=pos; |
|
| 2836 |
- pkg_free(v_rve);/* rve_destroy(v_rve) would free |
|
| 2837 |
- everything*/ |
|
| 2864 |
+ replace_int_rve(rve, v_rve); |
|
| 2838 | 2865 |
ret=1; |
| 2839 | 2866 |
} |
| 2840 | 2867 |
break; |
| ... | ... |
@@ -2852,13 +2879,9 @@ static int rve_opt_01(struct rval_expr* rve, enum rval_type rve_type) |
| 2852 | 2879 |
} |
| 2853 | 2880 |
}else if (i==1){
|
| 2854 | 2881 |
if (ct_rve==rve->right.rve){
|
| 2855 |
- /* $v / 1 -> $v */ |
|
| 2882 |
+ /* $v / 1 -> (int)$v */ |
|
| 2856 | 2883 |
rve_destroy(ct_rve); |
| 2857 |
- pos=rve->fpos; |
|
| 2858 |
- *rve=*v_rve; /* replace current expr. with $v */ |
|
| 2859 |
- rve->fpos=pos; |
|
| 2860 |
- pkg_free(v_rve);/* rve_destroy(v_rve) would free |
|
| 2861 |
- everything*/ |
|
| 2884 |
+ replace_int_rve(rve, v_rve); |
|
| 2862 | 2885 |
ret=1; |
| 2863 | 2886 |
} |
| 2864 | 2887 |
} |
| ... | ... |
@@ -2868,11 +2891,7 @@ static int rve_opt_01(struct rval_expr* rve, enum rval_type rve_type) |
| 2868 | 2891 |
if (ct_rve==rve->right.rve){
|
| 2869 | 2892 |
/* $v - 0 -> $v */ |
| 2870 | 2893 |
rve_destroy(ct_rve); |
| 2871 |
- pos=rve->fpos; |
|
| 2872 |
- *rve=*v_rve; /* replace current expr. with $v */ |
|
| 2873 |
- rve->fpos=pos; |
|
| 2874 |
- pkg_free(v_rve);/* rve_destroy(v_rve) would free |
|
| 2875 |
- everything*/ |
|
| 2894 |
+ replace_int_rve(rve, v_rve); |
|
| 2876 | 2895 |
ret=1; |
| 2877 | 2896 |
} |
| 2878 | 2897 |
/* ? 0 - $v -> -($v) ? */ |
| ... | ... |
@@ -2886,19 +2905,15 @@ static int rve_opt_01(struct rval_expr* rve, enum rval_type rve_type) |
| 2886 | 2905 |
goto error; |
| 2887 | 2906 |
ret=1; |
| 2888 | 2907 |
} |
| 2889 |
- /* no 0xffffff optimization for now (haven't decide on |
|
| 2908 |
+ /* no 0xffffff optimization for now (haven't decided on |
|
| 2890 | 2909 |
the number of bits ) */ |
| 2891 | 2910 |
break; |
| 2892 | 2911 |
case RVE_BOR_OP: |
| 2893 | 2912 |
if (i==0){
|
| 2894 |
- /* $v | 0 -> $v |
|
| 2895 |
- * 0 | $v -> $v */ |
|
| 2913 |
+ /* $v | 0 -> (int)$v |
|
| 2914 |
+ * 0 | $v -> (int)$v */ |
|
| 2896 | 2915 |
rve_destroy(ct_rve); |
| 2897 |
- pos=rve->fpos; |
|
| 2898 |
- *rve=*v_rve; /* replace current expr. with $v */ |
|
| 2899 |
- rve->fpos=pos; |
|
| 2900 |
- pkg_free(v_rve);/* rve_destroy(v_rve) would free |
|
| 2901 |
- everything*/ |
|
| 2916 |
+ replace_int_rve(rve, v_rve); |
|
| 2902 | 2917 |
ret=1; |
| 2903 | 2918 |
} |
| 2904 | 2919 |
break; |
| ... | ... |
@@ -2910,14 +2925,10 @@ static int rve_opt_01(struct rval_expr* rve, enum rval_type rve_type) |
| 2910 | 2925 |
goto error; |
| 2911 | 2926 |
ret=1; |
| 2912 | 2927 |
}else if (i==1){
|
| 2913 |
- /* $v && 1 -> $v |
|
| 2914 |
- * 1 && $v -> $v */ |
|
| 2928 |
+ /* $v && 1 -> (int)$v |
|
| 2929 |
+ * 1 && $v -> (int)$v */ |
|
| 2915 | 2930 |
rve_destroy(ct_rve); |
| 2916 |
- pos=rve->fpos; |
|
| 2917 |
- *rve=*v_rve; /* replace current expr. with $v */ |
|
| 2918 |
- rve->fpos=pos; |
|
| 2919 |
- pkg_free(v_rve);/* rve_destroy(v_rve) would free |
|
| 2920 |
- everything*/ |
|
| 2931 |
+ replace_int_rve(rve, v_rve); |
|
| 2921 | 2932 |
ret=1; |
| 2922 | 2933 |
} |
| 2923 | 2934 |
break; |
| ... | ... |
@@ -2929,41 +2940,25 @@ static int rve_opt_01(struct rval_expr* rve, enum rval_type rve_type) |
| 2929 | 2940 |
goto error; |
| 2930 | 2941 |
ret=1; |
| 2931 | 2942 |
}else if (i==0){
|
| 2932 |
- /* $v || 0 -> $v |
|
| 2933 |
- * 0 && $v -> $v */ |
|
| 2943 |
+ /* $v || 0 -> (int)$v |
|
| 2944 |
+ * 0 && $v -> (int)$v */ |
|
| 2934 | 2945 |
rve_destroy(ct_rve); |
| 2935 |
- pos=rve->fpos; |
|
| 2936 |
- *rve=*v_rve; /* replace current expr. with $v */ |
|
| 2937 |
- rve->fpos=pos; |
|
| 2938 |
- pkg_free(v_rve);/* rve_destroy(v_rve) would free |
|
| 2939 |
- everything*/ |
|
| 2946 |
+ replace_int_rve(rve, v_rve); |
|
| 2940 | 2947 |
ret=1; |
| 2941 | 2948 |
} |
| 2942 | 2949 |
break; |
| 2943 | 2950 |
case RVE_PLUS_OP: |
| 2944 | 2951 |
case RVE_IPLUS_OP: |
| 2945 | 2952 |
/* we must make sure that this is an int PLUS |
| 2946 |
- (because "foo"+0 is valid => "foo0") |
|
| 2947 |
- Even if overall type is RV_INT, it's still not safe |
|
| 2948 |
- to optimize a generic PLUS: 0 + $v is not always equivalent |
|
| 2949 |
- to $v (e.g. 0+"1" ==1 != "1") => optimize only if |
|
| 2950 |
- IPLUS (always safe since it converts to int first) or |
|
| 2951 |
- if generic PLUS and result is integer (rve_type) and |
|
| 2952 |
- expression is of the form $v+ct (and not ct+$v). |
|
| 2953 |
- TODO: dropping PLUS_OP all together and relying on the |
|
| 2954 |
- optimizer replacing safe PLUS_OP with IPLUS_OP or CONCAT_OP |
|
| 2955 |
- will simplify things. |
|
| 2953 |
+ (because "foo"+0 is valid => "foo0") => |
|
| 2954 |
+ check if it's an IPLUS or the result is an integer |
|
| 2955 |
+ (which generally means unoptimized <int> + <something>). |
|
| 2956 | 2956 |
*/ |
| 2957 |
- if ((i==0) && ((op==RVE_IPLUS_OP)|| |
|
| 2958 |
- (rve_type==RV_INT && ct_rve==rve->right.rve))){
|
|
| 2959 |
- /* $v + 0 -> $v |
|
| 2960 |
- * 0 + $v -> $v */ |
|
| 2957 |
+ if ((i==0) && ((op==RVE_IPLUS_OP) || (rve_type==RV_INT))){
|
|
| 2958 |
+ /* $v + 0 -> (int)$v |
|
| 2959 |
+ * 0 + $v -> (int)$v */ |
|
| 2961 | 2960 |
rve_destroy(ct_rve); |
| 2962 |
- pos=rve->fpos; |
|
| 2963 |
- *rve=*v_rve; /* replace current expr. with $v */ |
|
| 2964 |
- rve->fpos=pos; |
|
| 2965 |
- pkg_free(v_rve);/* rve_destroy(v_rve) would free |
|
| 2966 |
- everything*/ |
|
| 2961 |
+ replace_int_rve(rve, v_rve); |
|
| 2967 | 2962 |
ret=1; |
| 2968 | 2963 |
} |
| 2969 | 2964 |
break; |
| ... | ... |
@@ -2974,45 +2969,85 @@ static int rve_opt_01(struct rval_expr* rve, enum rval_type rve_type) |
| 2974 | 2969 |
/* debugging messages */ |
| 2975 | 2970 |
if (ret==1){
|
| 2976 | 2971 |
if (right){
|
| 2977 |
- if ((rve->op==RVE_RVAL_OP) && (rve->left.rval.type==RV_INT)) |
|
| 2978 |
- DBG("FIXUP RVE: (%d,%d-%d,%d) optimized"
|
|
| 2979 |
- " op%d($v, %d) -> %d\n", |
|
| 2980 |
- rve->fpos.s_line, rve->fpos.s_col, |
|
| 2981 |
- rve->fpos.e_line, rve->fpos.e_col, |
|
| 2982 |
- op, i, (int)rve->left.rval.v.l); |
|
| 2983 |
- else |
|
| 2972 |
+ if (rve->op==RVE_RVAL_OP){
|
|
| 2973 |
+ if (rve->left.rval.type==RV_INT) |
|
| 2974 |
+ DBG("FIXUP RVE: (%d,%d-%d,%d) optimized"
|
|
| 2975 |
+ " op%d($v, %d) -> %d\n", |
|
| 2976 |
+ rve->fpos.s_line, rve->fpos.s_col, |
|
| 2977 |
+ rve->fpos.e_line, rve->fpos.e_col, |
|
| 2978 |
+ op, i, (int)rve->left.rval.v.l); |
|
| 2979 |
+ else |
|
| 2980 |
+ DBG("FIXUP RVE: (%d,%d-%d,%d) optimized"
|
|
| 2981 |
+ " op%d($v, %d) -> $v (rval)\n", |
|
| 2982 |
+ rve->fpos.s_line, rve->fpos.s_col, |
|
| 2983 |
+ rve->fpos.e_line, rve->fpos.e_col, |
|
| 2984 |
+ op, i); |
|
| 2985 |
+ }else if (rve->op==RVE_INT_OP){
|
|
| 2986 |
+ if (rve->left.rve->op==RVE_RVAL_OP && |
|
| 2987 |
+ rve->left.rve->left.rval.type==RV_INT) |
|
| 2988 |
+ DBG("FIXUP RVE: (%d,%d-%d,%d) optimized"
|
|
| 2989 |
+ " op%d($v, %d) -> (int)%d\n", |
|
| 2990 |
+ rve->fpos.s_line, rve->fpos.s_col, |
|
| 2991 |
+ rve->fpos.e_line, rve->fpos.e_col, |
|
| 2992 |
+ op, i, (int)rve->left.rve->left.rval.v.l); |
|
| 2993 |
+ else |
|
| 2994 |
+ DBG("FIXUP RVE: (%d,%d-%d,%d) optimized"
|
|
| 2995 |
+ " op%d($v, %d) -> (int)$v\n", |
|
| 2996 |
+ rve->fpos.s_line, rve->fpos.s_col, |
|
| 2997 |
+ rve->fpos.e_line, rve->fpos.e_col, |
|
| 2998 |
+ op, i); |
|
| 2999 |
+ }else{
|
|
| 2984 | 3000 |
DBG("FIXUP RVE: (%d,%d-%d,%d) optimized"
|
| 2985 | 3001 |
" op%d($v, %d) -> $v\n", |
| 2986 | 3002 |
rve->fpos.s_line, rve->fpos.s_col, |
| 2987 | 3003 |
rve->fpos.e_line, rve->fpos.e_col, |
| 2988 | 3004 |
op, i); |
| 3005 |
+ } |
|
| 2989 | 3006 |
}else{
|
| 2990 |
- if ((rve->op==RVE_RVAL_OP) && (rve->left.rval.type==RV_INT)) |
|
| 2991 |
- DBG("FIXUP RVE: (%d,%d-%d,%d) optimized"
|
|
| 2992 |
- " op%d(%d, $v) -> %d\n", |
|
| 2993 |
- rve->fpos.s_line, rve->fpos.s_col, |
|
| 2994 |
- rve->fpos.e_line, rve->fpos.e_col, |
|
| 2995 |
- op, i, (int)rve->left.rval.v.l); |
|
| 2996 |
- else |
|
| 3007 |
+ if (rve->op==RVE_RVAL_OP){
|
|
| 3008 |
+ if (rve->left.rval.type==RV_INT) |
|
| 3009 |
+ DBG("FIXUP RVE: (%d,%d-%d,%d) optimized"
|
|
| 3010 |
+ " op%d(%d, $v) -> %d\n", |
|
| 3011 |
+ rve->fpos.s_line, rve->fpos.s_col, |
|
| 3012 |
+ rve->fpos.e_line, rve->fpos.e_col, |
|
| 3013 |
+ op, i, (int)rve->left.rval.v.l); |
|
| 3014 |
+ else |
|
| 3015 |
+ DBG("FIXUP RVE: (%d,%d-%d,%d) optimized"
|
|
| 3016 |
+ " op%d(%d, $v) -> $v (rval)\n", |
|
| 3017 |
+ rve->fpos.s_line, rve->fpos.s_col, |
|
| 3018 |
+ rve->fpos.e_line, rve->fpos.e_col, |
|
| 3019 |
+ op, i); |
|
| 3020 |
+ }else if (rve->op==RVE_INT_OP){
|
|
| 3021 |
+ if (rve->left.rve->op==RVE_RVAL_OP && |
|
| 3022 |
+ rve->left.rve->left.rval.type==RV_INT) |
|
| 3023 |
+ DBG("FIXUP RVE: (%d,%d-%d,%d) optimized"
|
|
| 3024 |
+ " op%d(%d, $v) -> (int)%d\n", |
|
| 3025 |
+ rve->fpos.s_line, rve->fpos.s_col, |
|
| 3026 |
+ rve->fpos.e_line, rve->fpos.e_col, |
|
| 3027 |
+ op, i, (int)rve->left.rve->left.rval.v.l); |
|
| 3028 |
+ else |
|
| 3029 |
+ DBG("FIXUP RVE: (%d,%d-%d,%d) optimized"
|
|
| 3030 |
+ " op%d(%d, $v) -> (int)$v\n", |
|
| 3031 |
+ rve->fpos.s_line, rve->fpos.s_col, |
|
| 3032 |
+ rve->fpos.e_line, rve->fpos.e_col, |
|
| 3033 |
+ op, i); |
|
| 3034 |
+ }else{
|
|
| 2997 | 3035 |
DBG("FIXUP RVE: (%d,%d-%d,%d) optimized"
|
| 2998 | 3036 |
" op%d(%d, $v) -> $v\n", |
| 2999 | 3037 |
rve->fpos.s_line, rve->fpos.s_col, |
| 3000 | 3038 |
rve->fpos.e_line, rve->fpos.e_col, |
| 3001 | 3039 |
op, i); |
| 3040 |
+ } |
|
| 3002 | 3041 |
} |
| 3003 | 3042 |
} |
| 3004 | 3043 |
}else if (rv->type==RV_STR){
|
| 3005 | 3044 |
switch(op){
|
| 3006 | 3045 |
case RVE_CONCAT_OP: |
| 3007 | 3046 |
if (rv->v.s.len==0){
|
| 3008 |
- /* $v . "" -> $v |
|
| 3009 |
- "" . $v -> $v */ |
|
| 3047 |
+ /* $v . "" -> (str)$v |
|
| 3048 |
+ "" . $v -> (str)$v */ |
|
| 3010 | 3049 |
rve_destroy(ct_rve); |
| 3011 |
- pos=rve->fpos; |
|
| 3012 |
- *rve=*v_rve; /* replace current expr. with $v */ |
|
| 3013 |
- rve->fpos=pos; |
|
| 3014 |
- pkg_free(v_rve);/* rve_destroy(v_rve) would free |
|
| 3015 |
- everything*/ |
|
| 3050 |
+ replace_str_rve(rve, v_rve); |
|
| 3016 | 3051 |
ret=1; |
| 3017 | 3052 |
} |
| 3018 | 3053 |
break; |
| ... | ... |
@@ -3027,18 +3062,89 @@ static int rve_opt_01(struct rval_expr* rve, enum rval_type rve_type) |
| 3027 | 3062 |
rve->left.rve=v_rve; |
| 3028 | 3063 |
rve->right.rve=0; |
| 3029 | 3064 |
ret=1; |
| 3065 |
+ DBG("FIXUP RVE: (%d,%d-%d,%d) optimized"
|
|
| 3066 |
+ " op%d($v, \"\") -> strempty($v)\n", |
|
| 3067 |
+ rve->fpos.s_line, rve->fpos.s_col, |
|
| 3068 |
+ rve->fpos.e_line, rve->fpos.e_col, |
|
| 3069 |
+ op); |
|
| 3030 | 3070 |
} |
| 3031 | 3071 |
break; |
| 3032 | 3072 |
default: |
| 3033 | 3073 |
break; |
| 3034 | 3074 |
} |
| 3035 | 3075 |
/* no optimization for generic RVE_PLUS_OP for now, only for RVE_CONCAT_OP |
| 3036 |
- (We could optimize $v + "" or ""+$v, but this ""+$v is a way |
|
| 3037 |
- to force convert $v to str , it might mess up type checking |
|
| 3038 |
- (e.g. errors w/o optimization and no errors with) and it brings |
|
| 3039 |
- a very small benefit anyway (it's unlikely we'll see a lot of |
|
| 3040 |
- "") |
|
| 3041 |
- */ |
|
| 3076 |
+ (RVE_PLUS_OP should be converted to RVE_CONCAT_OP if it's supposed |
|
| 3077 |
+ to work on strings. If it's not converted/optimized it means it's type |
|
| 3078 |
+ can be determined only at runtime => we cannot optimize */ |
|
| 3079 |
+ |
|
| 3080 |
+ /* debugging messages */ |
|
| 3081 |
+ if (ret==1){
|
|
| 3082 |
+ if (right){
|
|
| 3083 |
+ if (rve->op==RVE_RVAL_OP){
|
|
| 3084 |
+ if (rve->left.rval.type==RV_STR) |
|
| 3085 |
+ DBG("FIXUP RVE: (%d,%d-%d,%d) optimized"
|
|
| 3086 |
+ " op%d($v, <string>) -> \"%s\"\n", |
|
| 3087 |
+ rve->fpos.s_line, rve->fpos.s_col, |
|
| 3088 |
+ rve->fpos.e_line, rve->fpos.e_col, |
|
| 3089 |
+ op, rve->left.rval.v.s.s); |
|
| 3090 |
+ else |
|
| 3091 |
+ DBG("FIXUP RVE: (%d,%d-%d,%d) optimized"
|
|
| 3092 |
+ " op%d($v, <string>) -> $v (rval)\n", |
|
| 3093 |
+ rve->fpos.s_line, rve->fpos.s_col, |
|
| 3094 |
+ rve->fpos.e_line, rve->fpos.e_col, op); |
|
| 3095 |
+ }else if (rve->op==RVE_STR_OP){
|
|
| 3096 |
+ if (rve->left.rve->op==RVE_RVAL_OP && |
|
| 3097 |
+ rve->left.rve->left.rval.type==RV_STR) |
|
| 3098 |
+ DBG("FIXUP RVE: (%d,%d-%d,%d) optimized"
|
|
| 3099 |
+ " op%d($v, <string>) -> (str)\"%s\"\n", |
|
| 3100 |
+ rve->fpos.s_line, rve->fpos.s_col, |
|
| 3101 |
+ rve->fpos.e_line, rve->fpos.e_col, |
|
| 3102 |
+ op, rve->left.rve->left.rval.v.s.s); |
|
| 3103 |
+ else |
|
| 3104 |
+ DBG("FIXUP RVE: (%d,%d-%d,%d) optimized"
|
|
| 3105 |
+ " op%d($v, <string>) -> (str)$v\n", |
|
| 3106 |
+ rve->fpos.s_line, rve->fpos.s_col, |
|
| 3107 |
+ rve->fpos.e_line, rve->fpos.e_col, op); |
|
| 3108 |
+ }else{
|
|
| 3109 |
+ DBG("FIXUP RVE: (%d,%d-%d,%d) optimized"
|
|
| 3110 |
+ " op%d($v, <string>) -> $v\n", |
|
| 3111 |
+ rve->fpos.s_line, rve->fpos.s_col, |
|
| 3112 |
+ rve->fpos.e_line, rve->fpos.e_col, op); |
|
| 3113 |
+ } |
|
| 3114 |
+ }else{
|
|
| 3115 |
+ if (rve->op==RVE_RVAL_OP){
|
|
| 3116 |
+ if (rve->left.rval.type==RV_STR) |
|
| 3117 |
+ DBG("FIXUP RVE: (%d,%d-%d,%d) optimized"
|
|
| 3118 |
+ " op%d(<string>, $v) -> \"%s\"\n", |
|
| 3119 |
+ rve->fpos.s_line, rve->fpos.s_col, |
|
| 3120 |
+ rve->fpos.e_line, rve->fpos.e_col, |
|
| 3121 |
+ op, rve->left.rval.v.s.s); |
|
| 3122 |
+ else |
|
| 3123 |
+ DBG("FIXUP RVE: (%d,%d-%d,%d) optimized"
|
|
| 3124 |
+ " op%d(<string>, $v) -> $v (rval)\n", |
|
| 3125 |
+ rve->fpos.s_line, rve->fpos.s_col, |
|
| 3126 |
+ rve->fpos.e_line, rve->fpos.e_col, op); |
|
| 3127 |
+ }else if (rve->op==RVE_STR_OP){
|
|
| 3128 |
+ if (rve->left.rve->op==RVE_RVAL_OP && |
|
| 3129 |
+ rve->left.rve->left.rval.type==RV_STR) |
|
| 3130 |
+ DBG("FIXUP RVE: (%d,%d-%d,%d) optimized"
|
|
| 3131 |
+ " op%d(<string>, $v) -> (str)\"%s\"\n", |
|
| 3132 |
+ rve->fpos.s_line, rve->fpos.s_col, |
|
| 3133 |
+ rve->fpos.e_line, rve->fpos.e_col, |
|
| 3134 |
+ op, rve->left.rve->left.rval.v.s.s); |
|
| 3135 |
+ else |
|
| 3136 |
+ DBG("FIXUP RVE: (%d,%d-%d,%d) optimized"
|
|
| 3137 |
+ " op%d(<string>, $v) -> (str)$v\n", |
|
| 3138 |
+ rve->fpos.s_line, rve->fpos.s_col, |
|
| 3139 |
+ rve->fpos.e_line, rve->fpos.e_col, op); |
|
| 3140 |
+ }else{
|
|
| 3141 |
+ DBG("FIXUP RVE: (%d,%d-%d,%d) optimized"
|
|
| 3142 |
+ " op%d(<string>, $v) -> $v\n", |
|
| 3143 |
+ rve->fpos.s_line, rve->fpos.s_col, |
|
| 3144 |
+ rve->fpos.e_line, rve->fpos.e_col, op); |
|
| 3145 |
+ } |
|
| 3146 |
+ } |
|
| 3147 |
+ } |
|
| 3042 | 3148 |
} |
| 3043 | 3149 |
if (rv) rval_destroy(rv); |
| 3044 | 3150 |
return ret; |
| ... | ... |
@@ -3081,11 +3187,17 @@ static int rve_optimize(struct rval_expr* rve) |
| 3081 | 3187 |
rv=0; |
| 3082 | 3188 |
trv=&rve->left.rval; |
| 3083 | 3189 |
if (trv->type==RV_INT) |
| 3084 |
- DBG("FIXUP RVE: optimized constant int rve (old op %d) to %d\n",
|
|
| 3190 |
+ DBG("FIXUP RVE (%d,%d-%d,%d): optimized constant int rve "
|
|
| 3191 |
+ "(old op %d) to %d\n", |
|
| 3192 |
+ rve->fpos.s_line, rve->fpos.s_col, |
|
| 3193 |
+ rve->fpos.e_line, rve->fpos.e_col, |
|
| 3085 | 3194 |
op, (int)trv->v.l); |
| 3086 | 3195 |
else if (trv->type==RV_STR) |
| 3087 |
- DBG("FIXUP RVE: optimized constant str rve (old op %d) to"
|
|
| 3088 |
- " \"%.*s\"\n", op, trv->v.s.len, trv->v.s.s); |
|
| 3196 |
+ DBG("FIXUP RVE (%d,%d-%d,%d): optimized constant str rve "
|
|
| 3197 |
+ "(old op %d) to \"%.*s\"\n", |
|
| 3198 |
+ rve->fpos.s_line, rve->fpos.s_col, |
|
| 3199 |
+ rve->fpos.e_line, rve->fpos.e_col, |
|
| 3200 |
+ op, trv->v.s.len, trv->v.s.s); |
|
| 3089 | 3201 |
ret=1; |
| 3090 | 3202 |
}else{
|
| 3091 | 3203 |
/* expression is not constant */ |
| ... | ... |
@@ -3095,9 +3207,13 @@ static int rve_optimize(struct rval_expr* rve) |
| 3095 | 3207 |
rve_optimize(rve->left.rve); |
| 3096 | 3208 |
rve_optimize(rve->right.rve); |
| 3097 | 3209 |
if (!rve_check_type(&type, rve, &bad_rve, &bad_type, &exp_type)){
|
| 3098 |
- ERR("optimization failure, type mismatch in expression (%d,%d), "
|
|
| 3210 |
+ ERR("optimization failure while optimizing %d,%d-%d,%d:"
|
|
| 3211 |
+ " type mismatch in expression (%d,%d-%d,%d), " |
|
| 3099 | 3212 |
"type %s, but expected %s\n", |
| 3213 |
+ rve->fpos.s_line, rve->fpos.s_col, |
|
| 3214 |
+ rve->fpos.e_line, rve->fpos.e_col, |
|
| 3100 | 3215 |
bad_rve->fpos.s_line, bad_rve->fpos.s_col, |
| 3216 |
+ bad_rve->fpos.e_line, bad_rve->fpos.e_col, |
|
| 3101 | 3217 |
rval_type_name(bad_type), rval_type_name(exp_type)); |
| 3102 | 3218 |
return 0; |
| 3103 | 3219 |
} |
| ... | ... |
@@ -3112,8 +3228,11 @@ static int rve_optimize(struct rval_expr* rve) |
| 3112 | 3228 |
if (rve_replace_with_ct_rv(rve->right.rve, rv)<0) |
| 3113 | 3229 |
goto error; |
| 3114 | 3230 |
rve->op=RVE_IPLUS_OP; |
| 3115 |
- DBG("FIXUP RVE: optimized $v - a into $v + (%d)\n",
|
|
| 3116 |
- (int)rve->right.rve->left.rval.v.l); |
|
| 3231 |
+ DBG("FIXUP RVE (%d,%d-%d,%d): optimized $v - a into "
|
|
| 3232 |
+ "$v + (%d)\n", |
|
| 3233 |
+ rve->fpos.s_line, rve->fpos.s_col, |
|
| 3234 |
+ rve->fpos.e_line, rve->fpos.e_col, |
|
| 3235 |
+ (int)rve->right.rve->left.rval.v.l); |
|
| 3117 | 3236 |
} |
| 3118 | 3237 |
rval_destroy(rv); |
| 3119 | 3238 |
rv=0; |
| ... | ... |
@@ -3124,7 +3243,7 @@ static int rve_optimize(struct rval_expr* rve) |
| 3124 | 3243 |
l_type=rve_guess_type(rve->left.rve); |
| 3125 | 3244 |
if (l_type==RV_INT){
|
| 3126 | 3245 |
rve->op=RVE_IPLUS_OP; |
| 3127 |
- DBG("FIXUP RVE (%d,%d-%d,%d): changed + into interger plus\n",
|
|
| 3246 |
+ DBG("FIXUP RVE (%d,%d-%d,%d): changed + into integer plus\n",
|
|
| 3128 | 3247 |
rve->fpos.s_line, rve->fpos.s_col, |
| 3129 | 3248 |
rve->fpos.e_line, rve->fpos.e_col); |
| 3130 | 3249 |
}else if (l_type==RV_STR){
|
| ... | ... |
@@ -3178,8 +3297,10 @@ static int rve_optimize(struct rval_expr* rve) |
| 3178 | 3297 |
or a combination of them */ |
| 3179 | 3298 |
if ((rve->op==RVE_PLUS_OP) && |
| 3180 | 3299 |
(rve_guess_type(tmp_rve.left.rve)!=RV_STR)){
|
| 3181 |
- DBG("RVE optimization failed: cannot optimize"
|
|
| 3182 |
- " +(+($v, a), b) when typeof(a)==INT\n"); |
|
| 3300 |
+ DBG("RVE optimization failed (%d,%d-%d,%d): cannot "
|
|
| 3301 |
+ "optimize +(+($v, a), b) when typeof(a)==INT\n", |
|
| 3302 |
+ rve->fpos.s_line, rve->fpos.s_col, |
|
| 3303 |
+ rve->fpos.e_line, rve->fpos.e_col); |
|
| 3183 | 3304 |
return 0; |
| 3184 | 3305 |
} |
| 3185 | 3306 |
if ((rv=rval_expr_eval_new(0, 0, &tmp_rve))==0){
|
| ... | ... |
@@ -3195,12 +3316,17 @@ static int rve_optimize(struct rval_expr* rve) |
| 3195 | 3316 |
rve->left.rve=rve->left.rve->left.rve; |
| 3196 | 3317 |
trv=&rve->right.rve->left.rval; |
| 3197 | 3318 |
if (trv->type==RV_INT) |
| 3198 |
- DBG("FIXUP RVE: optimized int rve: op(op($v, a), b)"
|
|
| 3199 |
- " with op($v, %d); op=%d\n", |
|
| 3319 |
+ DBG("FIXUP RVE (%d,%d-%d,%d): optimized int rve: "
|
|
| 3320 |
+ "op(op($v, a), b) with op($v, %d); op=%d\n", |
|
| 3321 |
+ rve->fpos.s_line, rve->fpos.s_col, |
|
| 3322 |
+ rve->fpos.e_line, rve->fpos.e_col, |
|
| 3200 | 3323 |
(int)trv->v.l, rve->op); |
| 3201 | 3324 |
else if (trv->type==RV_STR) |
| 3202 |
- DBG("FIXUP RVE: optimized str rve op(op($v, a), b)"
|
|
| 3203 |
- " with op($v, \"%.*s\"); op=%d\n", |
|
| 3325 |
+ DBG("FIXUP RVE (%d,%d-%d,%d): optimized str rve "
|
|
| 3326 |
+ "op(op($v, a), b) with op($v, \"%.*s\");" |
|
| 3327 |
+ " op=%d\n", |
|
| 3328 |
+ rve->fpos.s_line, rve->fpos.s_col, |
|
| 3329 |
+ rve->fpos.e_line, rve->fpos.e_col, |
|
| 3204 | 3330 |
trv->v.s.len, trv->v.s.s, rve->op); |
| 3205 | 3331 |
ret=1; |
| 3206 | 3332 |
}else if (rve_is_constant(rve->left.rve->left.rve) && |
| ... | ... |
@@ -3228,12 +3354,17 @@ static int rve_optimize(struct rval_expr* rve) |
| 3228 | 3354 |
rv=0; |
| 3229 | 3355 |
trv=&rve->left.rve->left.rval; |
| 3230 | 3356 |
if (trv->type==RV_INT) |
| 3231 |
- DBG("FIXUP RVE: optimized int rve: op(op(a, $v), b)"
|
|
| 3232 |
- " with op(%d, $v); op=%d\n", |
|
| 3357 |
+ DBG("FIXUP RVE (%d,%d-%d,%d): optimized int rve: "
|
|
| 3358 |
+ "op(op(a, $v), b) with op(%d, $v); op=%d\n", |
|
| 3359 |
+ rve->fpos.s_line, rve->fpos.s_col, |
|
| 3360 |
+ rve->fpos.e_line, rve->fpos.e_col, |
|
| 3233 | 3361 |
(int)trv->v.l, rve->op); |
| 3234 | 3362 |
else if (trv->type==RV_STR) |
| 3235 |
- DBG("FIXUP RVE: optimized str rve op(op(a, $v), b)"
|
|
| 3236 |
- " with op(\"%.*s\", $v); op=%d\n", |
|
| 3363 |
+ DBG("FIXUP RVE (%d,%d-%d,%d): optimized str rve "
|
|
| 3364 |
+ "op(op(a, $v), b) with op(\"%.*s\", $v);" |
|
| 3365 |
+ " op=%d\n", |
|
| 3366 |
+ rve->fpos.s_line, rve->fpos.s_col, |
|
| 3367 |
+ rve->fpos.e_line, rve->fpos.e_col, |
|
| 3237 | 3368 |
trv->v.s.len, trv->v.s.s, rve->op); |
| 3238 | 3369 |
ret=1; |
| 3239 | 3370 |
} |
| ... | ... |
@@ -3269,12 +3400,17 @@ static int rve_optimize(struct rval_expr* rve) |
| 3269 | 3400 |
rve->right.rve=rve->right.rve->left.rve; |
| 3270 | 3401 |
trv=&rve->left.rve->left.rval; |
| 3271 | 3402 |
if (trv->type==RV_INT) |
| 3272 |
- DBG("FIXUP RVE: optimized int rve: op(a, op($v, b))"
|
|
| 3273 |
- " with op(%d, $v); op=%d\n", |
|
| 3403 |
+ DBG("FIXUP RVE (%d,%d-%d,%d): optimized int rve: "
|
|
| 3404 |
+ "op(a, op($v, b)) with op(%d, $v); op=%d\n", |
|
| 3405 |
+ rve->fpos.s_line, rve->fpos.s_col, |
|
| 3406 |
+ rve->fpos.e_line, rve->fpos.e_col, |
|
| 3274 | 3407 |
(int)trv->v.l, rve->op); |
| 3275 | 3408 |
else if (trv->type==RV_STR) |
| 3276 |
- DBG("FIXUP RVE: optimized str rve op(a, op($v, b))"
|
|
| 3277 |
- " with op(\"%.*s\", $v); op=%d\n", |
|
| 3409 |
+ DBG("FIXUP RVE (%d,%d-%d,%d): optimized str rve "
|
|
| 3410 |
+ "op(a, op($v, b)) with op(\"%.*s\", $v);" |
|
| 3411 |
+ " op=%d\n", |
|
| 3412 |
+ rve->fpos.s_line, rve->fpos.s_col, |
|
| 3413 |
+ rve->fpos.e_line, rve->fpos.e_col, |
|
| 3278 | 3414 |
trv->v.s.len, trv->v.s.s, rve->op); |
| 3279 | 3415 |
ret=1; |
| 3280 | 3416 |
}else if (rve_is_constant(rve->right.rve->left.rve)){
|
| ... | ... |
@@ -3288,8 +3424,11 @@ static int rve_optimize(struct rval_expr* rve) |
| 3288 | 3424 |
if ((rve->op==RVE_PLUS_OP) && |
| 3289 | 3425 |
(rve_guess_type(tmp_rve.left.rve) != |
| 3290 | 3426 |
rve_guess_type(tmp_rve.right.rve))){
|
| 3291 |
- DBG("RVE optimization failed: cannot optimize"
|
|
| 3292 |
- " +(a, +(b, $v)) when typeof(a)!=typeof(b)\n"); |
|
| 3427 |
+ DBG("RVE optimization failed (%d,%d-%d,%d): cannot "
|
|
| 3428 |
+ "optimize +(a, +(b, $v)) when " |
|
| 3429 |
+ "typeof(a)!=typeof(b)\n", |
|
| 3430 |
+ rve->fpos.s_line, rve->fpos.s_col, |
|
| 3431 |
+ rve->fpos.e_line, rve->fpos.e_col); |
|
| 3293 | 3432 |
return 0; |
| 3294 | 3433 |
} |
| 3295 | 3434 |
if ((rv=rval_expr_eval_new(0, 0, &tmp_rve))==0){
|
| ... | ... |
@@ -3305,12 +3444,17 @@ static int rve_optimize(struct rval_expr* rve) |
| 3305 | 3444 |
rve->right.rve=rve->right.rve->right.rve; |
| 3306 | 3445 |
trv=&rve->left.rve->left.rval; |
| 3307 | 3446 |
if (trv->type==RV_INT) |
| 3308 |
- DBG("FIXUP RVE: optimized int rve: op(a, op(b, $v))"
|
|
| 3309 |
- " with op(%d, $v); op=%d\n", |
|
| 3447 |
+ DBG("FIXUP RVE (%d,%d-%d,%d): optimized int rve: "
|
|
| 3448 |
+ "op(a, op(b, $v)) with op(%d, $v); op=%d\n", |
|
| 3449 |
+ rve->fpos.s_line, rve->fpos.s_col, |
|
| 3450 |
+ rve->fpos.e_line, rve->fpos.e_col, |
|
| 3310 | 3451 |
(int)trv->v.l, rve->op); |
| 3311 | 3452 |
else if (trv->type==RV_STR) |
| 3312 |
- DBG("FIXUP RVE: optimized str rve op(a, op(b, $v))"
|
|
| 3313 |
- " with op(\"%.*s\", $v); op=%d\n", |
|
| 3453 |
+ DBG("FIXUP RVE (%d,%d-%d,%d): optimized str rve "
|
|
| 3454 |
+ "op(a, op(b, $v)) with op(\"%.*s\", $v);" |
|
| 3455 |
+ " op=%d\n", |
|
| 3456 |
+ rve->fpos.s_line, rve->fpos.s_col, |
|
| 3457 |
+ rve->fpos.e_line, rve->fpos.e_col, |
|
| 3314 | 3458 |
trv->v.s.len, trv->v.s.s, rve->op); |
| 3315 | 3459 |
ret=1; |
| 3316 | 3460 |
} |