sr-dev December 2008

sr-dev@lists.kamailio.org

11 participants
70 discussions

git:master: Merge commit 'origin/daniel/pv'

by Andrei Pelinescu-Onciul

Module: sip-router Branch: master Commit: 7f8d719463e954604ffba935b1f82ada2b07850e URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=7f8d719… Author: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Committer: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Date: Fri Dec 19 14:57:57 2008 +0100 Merge commit 'origin/daniel/pv' * commit 'origin/daniel/pv': fix add/lookup pv name fix pv&t lookup due to signness pv api updates - list of PVs types syncronized with Kamailio Conflicts: pvapi.c ---

15 years, 11 months

git:master: script engine: minor fix

by Andrei Pelinescu-Onciul

Module: sip-router Branch: master Commit: 75fc3dbf97269b6bdb1c36f9f81276cdba4f359a URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=75fc3db… Author: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Committer: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Date: Fri Dec 19 14:40:52 2008 +0100 script engine: minor fix - warning fixes and minor rval_expr_eval_rvint() fix --- rvalue.c | 4 +++- 1 files changed, 3 insertions(+), 1 deletions(-) diff --git a/rvalue.c b/rvalue.c index 6471e85..9e020ef 100644 --- a/rvalue.c +++ b/rvalue.c @@ -1449,6 +1449,7 @@ int rval_expr_eval_rvint( struct run_act_ctx* h, rv1=0; rv2=0; + ret=-1; switch(rve->op){ case RVE_RVAL_OP: rv1=&rve->left.rval; @@ -1506,7 +1507,7 @@ int rval_expr_eval_rvint( struct run_act_ctx* h, rval_cache_clean(&c1); goto error; } - int_intop2(res_i, rve->op, i, j); + ret=int_intop2(res_i, rve->op, i, j); *res_rv=0; }else{ rv2=rval_expr_eval(h, msg, rve->right.rve); @@ -1559,6 +1560,7 @@ struct rvalue* rval_expr_eval(struct run_act_ctx* h, struct sip_msg* msg, rv1=0; rv2=0; + ret=0; switch(rve->op){ case RVE_RVAL_OP: rv_ref(&rve->left.rval);

15 years, 11 months

git:master: Merge commit 'origin/andrei/script_vars'

by Andrei Pelinescu-Onciul

Module: sip-router Branch: master Commit: 2cd96a356359eb75022f1f6ea7c9dfbbcd9323aa URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=2cd96a3… Author: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Committer: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Date: Fri Dec 19 14:32:32 2008 +0100 Merge commit 'origin/andrei/script_vars' * commit 'origin/andrei/script_vars': (30 commits) script parsing: helper function updated & moved script engine: different operators for int and str + script engine: keep file pos. info when optimizing script engine: optimize op($v, ct) where ct=0 or 1 script engine: optimize $v - ct script engine: pvar & avp fixes script: fix pvar parsing script parsing: better expression error reporting script parsing: expression type checking on startup script engine: rve_check_type() extended pvars: silent version for pv_parse_spec script parsing: better error reporting script parsing: fix line/column counting in strings script parsing: support for breaking strings script engine: more rvalue optimizations script engine: better debugging info core: new command line option (debugging) script engine: rvalue fixes & cleanup script engine: expression optimizations script parsing: fixed wrong operators in expr. ... ---

15 years, 11 months

git:master: Merge commit 'origin/andrei/fixups'

by Andrei Pelinescu-Onciul

Module: sip-router Branch: master Commit: d8d8f53af2f1cb048cf87506c6bbdbfc39c3f338 URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=d8d8f53… Author: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Committer: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Date: Fri Dec 19 14:30:14 2008 +0100 Merge commit 'origin/andrei/fixups' * commit 'origin/andrei/fixups': avp: comments fix fixups: added kamailio compatible fixups fixups: support for PVE & PVS in get_*_fparam() fixups: fix param function using a param type mask fixups: generic fixups work now on kamailio pvars select: comments for parse_select() avp: minor fixes & comments sr_module: identing and whitespace ---

15 years, 11 months

git:master: Merge commit 'origin/ser_core_cvs'

by Andrei Pelinescu-Onciul

Module: sip-router Branch: master Commit: 3ab8aff76a4c81c004511e87bfd7ffb38b6d9555 URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=3ab8aff… Author: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Committer: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Date: Fri Dec 19 14:24:50 2008 +0100 Merge commit 'origin/ser_core_cvs' * commit 'origin/ser_core_cvs': dns: fix build warnings when compiling without ipv6 core: fix build on Darwin doc: tcp tunning update sctp: SO_REUSEADDR on the sctp sockets tcp: fix for async write another switch where PROTO_SCTP was missing - added case sctp protocol decoded in RPC dst_blacklist.view clean up whitespace in makefile added README.prefix_route Use explicit comparison with NULL, it's more clear and shuts off gcc, Fix warnings on LP64 plarforms out there (all 64-bit amd64/emt64 unixes added new module prefix_route update RPM spec file t_suspend() and t_continue() functions have been documented. dns: naptr local preferences fix more type punning warnings fixed avp: warning fixes & more sane usr_avp struct dns cache: fixed missing sctp SRV queries dns: fixed missing sctp SRV queries ---

15 years, 11 months

git:andrei/script_vars: script parsing: helper function updated & moved

by Andrei Pelinescu-Onciul

Module: sip-router Branch: andrei/script_vars Commit: 33d560253c7fe8dd652251bc057873906edb2682 URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=33d5602… Author: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Committer: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Date: Fri Dec 19 14:20:41 2008 +0100 script parsing: helper function updated & moved - helper function for computing the file position of an expression --- cfg.y | 23 +---------------------- route_struct.c | 24 ++++++++++++++++++++++++ route_struct.h | 3 +++ 3 files changed, 28 insertions(+), 22 deletions(-) diff --git a/cfg.y b/cfg.y index 7ced7c1..63c9eb4 100644 --- a/cfg.y +++ b/cfg.y @@ -201,8 +201,6 @@ static struct rvalue* rval_tmp; static void warn(char* s); static void get_cpos(struct cfg_pos* pos); -static void get_rve2_pos(struct cfg_pos* res, - struct cfg_pos* pos1, struct cfg_pos* pos2); static struct rval_expr* mk_rve_rval(enum rval_type, void* v); static struct rval_expr* mk_rve1(enum rval_expr_op op, struct rval_expr* rve1); static struct rval_expr* mk_rve2(enum rval_expr_op op, struct rval_expr* rve1, @@ -2613,25 +2611,6 @@ static void yyerror(char* format, ...) -static void get_rve2_pos(struct cfg_pos* res, - struct cfg_pos* pos1, struct cfg_pos* pos2) -{ - *res=*pos1; - if ((res->s_line == 0) || (res->s_line > pos2->s_line)){ - res->s_line=pos2->s_line; - res->s_col=pos2->s_col; - }else if ((res->s_line == pos2->s_line) && (res->s_col > pos2->s_col)){ - res->s_col=pos2->s_col; - } - if ((res->e_line == 0) || (res->e_line < pos2->e_line)){ - res->e_line=pos2->e_line; - res->e_col=pos2->e_col; - }else if ((res->e_line == pos2->e_line) && (res->e_col < pos2->e_col)){ - res->e_col=pos2->e_col; - } -} - - /** mk_rval_expr_v wrapper. * checks mk_rval_expr_v return value and sets the cfg. pos * (line and column numbers) @@ -2688,7 +2667,7 @@ static struct rval_expr* mk_rve2(enum rval_expr_op op, struct rval_expr* rve1, if ((rve1==0) || (rve2==0)) return 0; - get_rve2_pos(&pos, &rve1->fpos, &rve2->fpos); + cfg_pos_join(&pos, &rve1->fpos, &rve2->fpos); ret=mk_rval_expr2(op, rve1, rve2, &pos); if (ret && (rve_check_type(&type, ret, &bad_rve, &bad_t, &exp_t)!=1)){ yyerror_at(&pos, "bad expression: type mismatch:" diff --git a/route_struct.c b/route_struct.c index 5cf74ee..7fce4b8 100644 --- a/route_struct.c +++ b/route_struct.c @@ -52,6 +52,30 @@ #include "ut.h" /* ZSW() */ + +/** joins to cfg file positions into a new one. */ +void cfg_pos_join(struct cfg_pos* res, + struct cfg_pos* pos1, struct cfg_pos* pos2) +{ + struct cfg_pos ret; + ret=*pos1; + if ((ret.s_line == 0) || (ret.s_line > pos2->s_line)){ + ret.s_line=pos2->s_line; + ret.s_col=pos2->s_col; + }else if ((ret.s_line == pos2->s_line) && (ret.s_col > pos2->s_col)){ + ret.s_col=pos2->s_col; + } + if ((ret.e_line == 0) || (ret.e_line < pos2->e_line)){ + ret.e_line=pos2->e_line; + ret.e_col=pos2->e_col; + }else if ((ret.e_line == pos2->e_line) && (ret.e_col < pos2->e_col)){ + ret.e_col=pos2->e_col; + } + *res=ret; +} + + + struct expr* mk_exp(int op, struct expr* left, struct expr* right) { struct expr * e; diff --git a/route_struct.h b/route_struct.h index ba5046e..76aac25 100644 --- a/route_struct.h +++ b/route_struct.h @@ -167,5 +167,8 @@ void print_action(struct action* a); void print_actions(struct action* a); void print_expr(struct expr* exp); +/** joins to cfg file positions into a new one. */ +void cfg_pos_join(struct cfg_pos* res, + struct cfg_pos* pos1, struct cfg_pos* pos2); #endif

15 years, 11 months

git:andrei/script_vars: script engine: different operators for int and str +

by Andrei Pelinescu-Onciul

Module: sip-router Branch: andrei/script_vars Commit: 1b9b3fd68c37ac7e3b4afb753c8424ae3f6c6e0f URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=1b9b3fd… Author: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Committer: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Date: Thu Dec 18 14:46:05 2008 +0100 script engine: different operators for int and str + - different operators for integer + (RVE_IPLUS_OP) and str plus (RVE_CONCAT_OP). The generic plus (RVE_PLUS_OP) is still present, the new operators are only used in internal optimizations (see below) for now. - if an expression involving the generic '+' is always of type int or str, replace the generic '+' with the interger or string version (makes further optimizations possible). --- rvalue.c | 112 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++--- rvalue.h | 4 ++- 2 files changed, 110 insertions(+), 6 deletions(-) diff --git a/rvalue.c b/rvalue.c index 2a1ea88..6471e85 100644 --- a/rvalue.c +++ b/rvalue.c @@ -385,10 +385,13 @@ enum rval_type rve_guess_type( struct rval_expr* rve) case RVE_LTE_OP: case RVE_EQ_OP: case RVE_DIFF_OP: + case RVE_IPLUS_OP: return RV_INT; case RVE_PLUS_OP: /* '+' evaluates to the type of the left operand */ return rve_guess_type(rve->left.rve); + case RVE_CONCAT_OP: + return RV_STR; case RVE_NONE_OP: break; } @@ -437,6 +440,8 @@ int rve_is_constant(struct rval_expr* rve) case RVE_EQ_OP: case RVE_DIFF_OP: case RVE_PLUS_OP: + case RVE_IPLUS_OP: + case RVE_CONCAT_OP: return rve_is_constant(rve->left.rve) && rve_is_constant(rve->right.rve); case RVE_NONE_OP: @@ -473,6 +478,8 @@ static int rve_op_unary(enum rval_expr_op op) case RVE_EQ_OP: case RVE_DIFF_OP: case RVE_PLUS_OP: + case RVE_IPLUS_OP: + case RVE_CONCAT_OP: return 0; case RVE_NONE_OP: return -1; @@ -532,6 +539,7 @@ int rve_check_type(enum rval_type* type, struct rval_expr* rve, case RVE_GTE_OP: case RVE_LT_OP: case RVE_LTE_OP: + case RVE_IPLUS_OP: *type=RV_INT; if (rve_check_type(&type1, rve->left.rve, bad_rve, bad_t, exp_t)){ if (type1==RV_STR){ @@ -587,6 +595,28 @@ int rve_check_type(enum rval_type* type, struct rval_expr* rve, return 1; } } + case RVE_CONCAT_OP: + *type=RV_STR; + if (rve_check_type(&type1, rve->left.rve, bad_rve, bad_t, exp_t)){ + if (rve_check_type(&type2, rve->right.rve, bad_rve, bad_t, + exp_t)){ + if ((type2!=type1) && (type1!=RV_NONE) && + (type2!=RV_NONE) && + !(type1==RV_STR && type2==RV_INT)){ + if (bad_rve) *bad_rve=rve->right.rve; + if (bad_t) *bad_t=type2; + if (exp_t) *exp_t=type1; + return 0; + } + if (type1==RV_INT){ + if (bad_rve) *bad_rve=rve->left.rve; + if (bad_t) *bad_t=type1; + if (exp_t) *exp_t=RV_STR; + return 0; + } + return 1; + } + } case RVE_NONE_OP: break; } @@ -936,6 +966,7 @@ inline static int int_intop2(int* res, enum rval_expr_op op, int v1, int v2) { switch(op){ case RVE_PLUS_OP: + case RVE_IPLUS_OP: *res=v1+v2; break; case RVE_MINUS_OP: @@ -981,6 +1012,10 @@ inline static int int_intop2(int* res, enum rval_expr_op op, int v1, int v2) case RVE_DIFF_OP: *res=v1 != v2; break; + case RVE_CONCAT_OP: + *res=0; + /* invalid operand for int */ + return -1; default: BUG("rv unsupported intop %d\n", op); return -1; @@ -1286,6 +1321,7 @@ int rval_expr_eval_int( struct run_act_ctx* h, struct sip_msg* msg, case RVE_DIV_OP: case RVE_MINUS_OP: case RVE_PLUS_OP: + case RVE_IPLUS_OP: case RVE_BOR_OP: case RVE_BAND_OP: case RVE_GT_OP: @@ -1376,6 +1412,10 @@ int rval_expr_eval_int( struct run_act_ctx* h, struct sip_msg* msg, rval_destroy(rv2); break; #endif + case RVE_CONCAT_OP: + *res=0; + ret=-1; + break; case RVE_NONE_OP: /*default:*/ BUG("invalid rval int expression operation %d\n", rve->op); @@ -1446,6 +1486,7 @@ int rval_expr_eval_rvint( struct run_act_ctx* h, case RVE_LTE_OP: case RVE_EQ_OP: case RVE_DIFF_OP: + case RVE_IPLUS_OP: /* operator forces integer type */ ret=rval_expr_eval_int(h, msg, res_i, rve); *res_rv=0; @@ -1479,6 +1520,10 @@ int rval_expr_eval_rvint( struct run_act_ctx* h, } rval_cache_clean(&c1); break; + case RVE_CONCAT_OP: + *res_rv=rval_expr_eval(h, msg, rve); + ret=-(*res_rv==0); + break; case RVE_NONE_OP: /*default:*/ BUG("invalid rval expression operation %d\n", rve->op); @@ -1535,6 +1580,7 @@ struct rvalue* rval_expr_eval(struct run_act_ctx* h, struct sip_msg* msg, case RVE_LTE_OP: case RVE_EQ_OP: case RVE_DIFF_OP: + case RVE_IPLUS_OP: /* operator forces integer type */ r=rval_expr_eval_int(h, msg, &i, rve); if (likely(r==0)){ @@ -1603,6 +1649,19 @@ struct rvalue* rval_expr_eval(struct run_act_ctx* h, struct sip_msg* msg, } rval_cache_clean(&c1); break; + case RVE_CONCAT_OP: + rv1=rval_expr_eval(h, msg, rve->left.rve); + if (unlikely(rv1==0)){ + ERR("rval expression evaluation failed\n"); + goto error; + } + rv2=rval_expr_eval(h, msg, rve->right.rve); + if (unlikely(rv2==0)){ + ERR("rval expression evaluation failed\n"); + goto error; + } + ret=rval_str_add2(h, msg, rv1, 0, rv2, 0); + break; case RVE_NONE_OP: /*default:*/ BUG("invalid rval expression operation %d\n", rve->op); @@ -1767,8 +1826,10 @@ struct rval_expr* mk_rval_expr2(enum rval_expr_op op, struct rval_expr* rve1, case RVE_LT_OP: case RVE_LTE_OP: case RVE_PLUS_OP: + case RVE_IPLUS_OP: case RVE_EQ_OP: case RVE_DIFF_OP: + case RVE_CONCAT_OP: break; default: BUG("unsupported operator %d\n", op); @@ -1802,6 +1863,8 @@ static int rve_op_is_assoc(enum rval_expr_op op) case RVE_MINUS_OP: return 0; case RVE_PLUS_OP: + case RVE_IPLUS_OP: + case RVE_CONCAT_OP: case RVE_MUL_OP: case RVE_BAND_OP: case RVE_BOR_OP: @@ -1838,6 +1901,7 @@ static int rve_op_is_commutative(enum rval_expr_op op, enum rval_type type) return 0; case RVE_PLUS_OP: return type==RV_INT; /* commutative only for INT*/ + case RVE_IPLUS_OP: case RVE_MUL_OP: case RVE_BAND_OP: case RVE_BOR_OP: @@ -1851,6 +1915,7 @@ static int rve_op_is_commutative(enum rval_expr_op op, enum rval_type type) case RVE_LTE_OP: case RVE_EQ_OP: case RVE_DIFF_OP: + case RVE_CONCAT_OP: return 0; } return 0; @@ -2158,9 +2223,10 @@ static int rve_opt_01(struct rval_expr* rve, enum rval_type rve_type) } break; case RVE_PLUS_OP: + case RVE_IPLUS_OP: /* we must make sure that this is an int PLUS (because "foo"+0 is valid => "foo0") */ - if ((i==0) && (rve_type==RV_INT)){ + if ((i==0) && ((op==RVE_IPLUS_OP)||(rve_type==RV_INT))){ /* $v + 0 -> $v * 0 + $v -> $v */ rve_destroy(ct_rve); @@ -2206,14 +2272,32 @@ static int rve_opt_01(struct rval_expr* rve, enum rval_type rve_type) op, i); } } - } - /* no optimization for strings for now + }else if (rv->type==RV_STR){ + switch(op){ + case RVE_CONCAT_OP: + if (rv->v.s.len==0){ + /* $v . "" -> $v + "" . $v -> $v */ + rve_destroy(ct_rve); + pos=rve->fpos; + *rve=*v_rve; /* replace current expr. with $v */ + rve->fpos=pos; + pkg_free(v_rve);/* rve_destroy(v_rve) would free + everything*/ + ret=1; + } + break; + default: + break; + } + /* no optimization for generic RVE_PLUS_OP for now, only for RVE_CONCAT_OP (We could optimize $v + "" or ""+$v, but this ""+$v is a way to force convert $v to str , it might mess up type checking (e.g. errors w/o optimization and no errors with) and it brings a very small benefit anyway (it's unlikely we'll see a lot of "") */ + } if (rv) rval_destroy(rv); return ret; error: @@ -2232,7 +2316,7 @@ static int rve_optimize(struct rval_expr* rve) enum rval_expr_op op; int flags; struct rval_expr tmp_rve; - enum rval_type type; + enum rval_type type, l_type; struct rval_expr* bad_rve; enum rval_type bad_type, exp_type; @@ -2285,7 +2369,7 @@ static int rve_optimize(struct rval_expr* rve) rv->v.l=-rv->v.l; if (rve_replace_with_ct_rv(rve->right.rve, rv)<0) goto error; - rve->op=RVE_PLUS_OP; + rve->op=RVE_IPLUS_OP; DBG("FIXUP RVE: optimized $v - a into $v + (%d)\n", (int)rve->right.rve->left.rval.v.l); } @@ -2293,6 +2377,22 @@ static int rve_optimize(struct rval_expr* rve) rv=0; } + /* e1 PLUS_OP e2 -> change op if we know e1 basic type */ + if (rve->op==RVE_PLUS_OP){ + l_type=rve_guess_type(rve->left.rve); + if (l_type==RV_INT){ + rve->op=RVE_IPLUS_OP; + DBG("FIXUP RVE (%d,%d-%d,%d): changed + into interger plus\n", + rve->fpos.s_line, rve->fpos.s_col, + rve->fpos.e_line, rve->fpos.e_col); + }else if (l_type==RV_STR){ + rve->op=RVE_CONCAT_OP; + DBG("FIXUP RVE (%d,%d-%d,%d): changed + into string concat\n", + rve->fpos.s_line, rve->fpos.s_col, + rve->fpos.e_line, rve->fpos.e_col); + } + } + /* $v * 0 => 0; $v * 1 => $v (for *, /, &, |, &&, ||, +, -) */ if (rve_opt_01(rve, type)==1){ /* success, rve was changed => return now @@ -2510,8 +2610,10 @@ int fix_rval_expr(void** p) case RVE_LT_OP: case RVE_LTE_OP: case RVE_PLUS_OP: + case RVE_IPLUS_OP: case RVE_EQ_OP: case RVE_DIFF_OP: + case RVE_CONCAT_OP: ret=fix_rval_expr((void**)&rve->left.rve); if (ret<0) return ret; ret=fix_rval_expr((void**)&rve->right.rve); diff --git a/rvalue.h b/rvalue.h index f36f189..a694c0d 100644 --- a/rvalue.h +++ b/rvalue.h @@ -59,10 +59,12 @@ enum rval_expr_op{ RVE_GTE_OP, /* 2 members, returns left >= right */ RVE_LT_OP, /* 2 members, returns left < right */ RVE_LTE_OP, /* 2 members, returns left <= right */ + RVE_IPLUS_OP, /* 2 members, integer +, returns int(a)+int(b) */ /* common int & str */ - RVE_PLUS_OP, /* 2 members, returns left + right (int or str)*/ + RVE_PLUS_OP, /* generic plus (int or str) returns left + right */ RVE_EQ_OP, /* 2 members, returns left == right (int)*/ RVE_DIFF_OP, /* 2 members, returns left != right (int)*/ + RVE_CONCAT_OP,/* string concatenation, returns left . right */ /* str only */ };

15 years, 11 months

git:andrei/script_vars: script engine: optimize op($v, ct) where ct=0 or 1

by Andrei Pelinescu-Onciul

Module: sip-router Branch: andrei/script_vars Commit: 5184c21a634b700a3800665269ca659c53e86fe9 URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=5184c21… Author: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Committer: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Date: Thu Dec 18 12:51:50 2008 +0100 script engine: optimize op($v, ct) where ct=0 or 1 - optimize: $v*0->0, 0*$v->0, $v*1->$v 1*$v->$v $v/1->$v, 0/$v->0 $v-0->$v $v&0->0, 0&$v->0 $v|0->$v, 0|$v->$v $v&&0->0, 0&&$v->0, $v&&1->$v, 1&&$v->$v $v||1->1, 1||$v->1, $v||0->$v, 0||$v->$v $v+0->$v, 0+$v->$v if typeof(expression) is int (forced by the context) - fix runtime && and ||: 0 && expr -> don't evaluate expr, return 0 1 || expr -> don't evaluate expr, return 1 --- rvalue.c | 284 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 files changed, 280 insertions(+), 4 deletions(-) diff --git a/rvalue.c b/rvalue.c index 558ab70..ce9e3d3 100644 --- a/rvalue.c +++ b/rvalue.c @@ -1288,8 +1288,6 @@ int rval_expr_eval_int( struct run_act_ctx* h, struct sip_msg* msg, case RVE_PLUS_OP: case RVE_BOR_OP: case RVE_BAND_OP: - case RVE_LAND_OP: - case RVE_LOR_OP: case RVE_GT_OP: case RVE_GTE_OP: case RVE_LT_OP: @@ -1302,6 +1300,34 @@ int rval_expr_eval_int( struct run_act_ctx* h, struct sip_msg* msg, break; ret=int_intop2(res, rve->op, i1, i2); break; + case RVE_LAND_OP: + if (unlikely( + (ret=rval_expr_eval_int(h, msg, &i1, rve->left.rve)) <0) ) + break; + if (i1==0){ + *res=0; + }else{ + if (unlikely( (ret=rval_expr_eval_int(h, msg, &i2, + rve->right.rve)) <0) ) + break; + *res=i1 && i2; + } + ret=0; + break; + case RVE_LOR_OP: + if (unlikely( + (ret=rval_expr_eval_int(h, msg, &i1, rve->left.rve)) <0) ) + break; + if (i1){ + *res=1; + }else{ + if (unlikely( (ret=rval_expr_eval_int(h, msg, &i2, + rve->right.rve)) <0) ) + break; + *res=i1 || i2; + } + ret=0; + break; case RVE_EQ_OP: case RVE_DIFF_OP: /* if left is string, eval left & right as string and @@ -1593,6 +1619,32 @@ error: +/** evals a rval expr and always returns a new rval. + * like rval_expr_eval, but always returns a new rvalue (never a reference + * to an exisiting one). + * WARNING: result must be rval_destroy()'ed if non-null (it might be + * a reference to another rval). The result can be modified only + * if rv_chg_in_place() returns true. + * @result rvalue on success, 0 on error + */ +struct rvalue* rval_expr_eval_new(struct run_act_ctx* h, struct sip_msg* msg, + struct rval_expr* rve) +{ + struct rvalue* ret; + struct rvalue* rv; + + ret=rval_expr_eval(h, msg, rve); + if (ret && !rv_chg_in_place(ret)){ + rv=ret; + /* create a new rv */ + ret=rval_new(rv->type, &rv->v, 0); + rval_destroy(rv); + } + return ret; +} + + + /** create a RVE_RVAL_OP rval_expr, containing a single rval of the given type. * * @param rv_type - rval type @@ -1941,6 +1993,221 @@ static int rve_replace_with_ct_rv(struct rval_expr* rve, struct rvalue* rv) +/** optimize op($v, 0) or op($v, 1). + * Note: internal use only from rve_optimize + * It should be called after ct optimization, for non-contant + * expressions (the left or right side is not constant). + * @return 1 on success (rve was changed), 0 on failure and -1 on error + */ +static int rve_opt_01(struct rval_expr* rve, enum rval_type rve_type) +{ + struct rvalue* rv; + struct rval_expr* ct_rve; + struct rval_expr* v_rve; + int i; + int ret; + enum rval_expr_op op; + int right; /* debugging msg */ + + rv=0; + ret=0; + right=0; + + if (rve_is_constant(rve->right.rve)){ + ct_rve=rve->right.rve; + v_rve=rve->left.rve; + right=1; + }else if (rve_is_constant(rve->left.rve)){ + ct_rve=rve->left.rve; + v_rve=rve->right.rve; + right=0; + }else + return 0; /* op($v, $w) */ + + /* rval_expr_eval_new() instead of rval_expr_eval() to avoid + referencing a ct_rve->left.rval if ct_rve is a rval, which + would prevent rve_destroy(ct_rve) from working */ + if ((rv=rval_expr_eval_new(0, 0, ct_rve))==0){ + ERR("optimization failure, bad expression\n"); + goto error; + } + op=rve->op; + if (rv->type==RV_INT){ + i=rv->v.l; + switch(op){ + case RVE_MUL_OP: + if (i==0){ + /* $v * 0 -> 0 + * 0 * $v -> 0 */ + if (rve_replace_with_ct_rv(rve, rv)<0) + goto error; + ret=1; + }else if (i==1){ + /* $v * 1 -> $v + * 1 * $v -> $v */ + rve_destroy(ct_rve); + *rve=*v_rve; /* replace current expr. with $v */ + pkg_free(v_rve);/* rve_destroy(v_rve) would free + everything*/ + ret=1; + } + break; + case RVE_DIV_OP: + if (i==0){ + if (ct_rve==rve->left.rve){ + /* 0 / $v -> 0 */ + if (rve_replace_with_ct_rv(rve, rv)<0) + goto error; + ret=1; + }else{ + /* $v / 0 */ + ERR("RVE divide by 0 at %d,%d\n", + ct_rve->fpos.s_line, ct_rve->fpos.s_col); + } + }else if (i==1){ + if (ct_rve==rve->right.rve){ + /* $v / 1 -> $v */ + rve_destroy(ct_rve); + *rve=*v_rve; /* replace current expr. with $v */ + pkg_free(v_rve);/* rve_destroy(v_rve) would free + everything*/ + ret=1; + } + } + break; + case RVE_MINUS_OP: + if (i==0){ + if (ct_rve==rve->right.rve){ + /* $v - 0 -> $v */ + rve_destroy(ct_rve); + *rve=*v_rve; /* replace current expr. with $v */ + pkg_free(v_rve);/* rve_destroy(v_rve) would free + everything*/ + ret=1; + } + /* ? 0 - $v -> -($v) ? */ + } + break; + case RVE_BAND_OP: + if (i==0){ + /* $v & 0 -> 0 + * 0 & $v -> 0 */ + if (rve_replace_with_ct_rv(rve, rv)<0) + goto error; + ret=1; + } + /* no 0xffffff optimization for now (haven't decide on + the number of bits ) */ + break; + case RVE_BOR_OP: + if (i==0){ + /* $v | 0 -> $v + * 0 | $v -> $v */ + rve_destroy(ct_rve); + *rve=*v_rve; /* replace current expr. with $v */ + pkg_free(v_rve);/* rve_destroy(v_rve) would free + everything*/ + ret=1; + } + break; + case RVE_LAND_OP: + if (i==0){ + /* $v && 0 -> 0 + * 0 && $v -> 0 */ + if (rve_replace_with_ct_rv(rve, rv)<0) + goto error; + ret=1; + }else if (i==1){ + /* $v && 1 -> $v + * 1 && $v -> $v */ + rve_destroy(ct_rve); + *rve=*v_rve; /* replace current expr. with $v */ + pkg_free(v_rve);/* rve_destroy(v_rve) would free + everything*/ + ret=1; + } + break; + case RVE_LOR_OP: + if (i==1){ + /* $v || 1 -> 1 + * 1 || $v -> 1 */ + if (rve_replace_with_ct_rv(rve, rv)<0) + goto error; + ret=1; + }else if (i==0){ + /* $v || 0 -> $v + * 0 && $v -> $v */ + rve_destroy(ct_rve); + *rve=*v_rve; /* replace current expr. with $v */ + pkg_free(v_rve);/* rve_destroy(v_rve) would free + everything*/ + ret=1; + } + break; + case RVE_PLUS_OP: + /* we must make sure that this is an int PLUS + (because "foo"+0 is valid => "foo0") */ + if ((i==0) && (rve_type==RV_INT)){ + /* $v + 0 -> $v + * 0 + $v -> $v */ + rve_destroy(ct_rve); + *rve=*v_rve; /* replace current expr. with $v */ + pkg_free(v_rve);/* rve_destroy(v_rve) would free + everything*/ + ret=1; + } + break; + default: + /* do nothing */ + break; + } + /* debugging messages */ + if (ret==1){ + if (right){ + if ((rve->op==RVE_RVAL_OP) && (rve->left.rval.type==RV_INT)) + DBG("FIXUP RVE: (%d,%d-%d,%d) optimized" + " op%d($v, %d) -> %d\n", + rve->fpos.s_line, rve->fpos.s_col, + rve->fpos.e_line, rve->fpos.s_col, + op, i, (int)rve->left.rval.v.l); + else + DBG("FIXUP RVE: (%d,%d-%d,%d) optimized" + " op%d($v, %d) -> $v\n", + rve->fpos.s_line, rve->fpos.s_col, + rve->fpos.e_line, rve->fpos.s_col, + op, i); + }else{ + if ((rve->op==RVE_RVAL_OP) && (rve->left.rval.type==RV_INT)) + DBG("FIXUP RVE: (%d,%d-%d,%d) optimized" + " op%d(%d, $v) -> %d\n", + rve->fpos.s_line, rve->fpos.s_col, + rve->fpos.e_line, rve->fpos.s_col, + op, i, (int)rve->left.rval.v.l); + else + DBG("FIXUP RVE: (%d,%d-%d,%d) optimized" + " op%d(%d, $v) -> $v\n", + rve->fpos.s_line, rve->fpos.s_col, + rve->fpos.e_line, rve->fpos.s_col, + op, i); + } + } + } + /* no optimization for strings for now + (We could optimize $v + "" or ""+$v, but this ""+$v is a way + to force convert $v to str , it might mess up type checking + (e.g. errors w/o optimization and no errors with) and it brings + a very small benefit anyway (it's unlikely we'll see a lot of + "") + */ + if (rv) rval_destroy(rv); + return ret; +error: + if (rv) rval_destroy(rv); + return -1; +} + + + /** tries to optimize a rval_expr. */ static int rve_optimize(struct rval_expr* rve) { @@ -1987,8 +2254,9 @@ static int rve_optimize(struct rval_expr* rve) rve_optimize(rve->left.rve); rve_optimize(rve->right.rve); if (!rve_check_type(&type, rve, &bad_rve, &bad_type, &exp_type)){ - ERR("optimization failure, type mismatch in expression, " + ERR("optimization failure, type mismatch in expression (%d,%d), " "type %s, but expected %s\n", + bad_rve->fpos.s_line, bad_rve->fpos.s_col, rval_type_name(bad_type), rval_type_name(exp_type)); return 0; } @@ -2010,7 +2278,14 @@ static int rve_optimize(struct rval_expr* rve) rv=0; } - /* TODO: $v * 0 => 0; $v * 1 => $v (for *, /, &, |, &&, ||, +, -) */ + /* $v * 0 => 0; $v * 1 => $v (for *, /, &, |, &&, ||, +, -) */ + if (rve_opt_01(rve, type)==1){ + /* success, rve was changed => return now + (since this is recursively invoked the "new" rve + is already optimized) */ + ret=1; + goto end; + } /* op(op($v, a), b) => op($v, op(a,b)) */ if (rve_is_constant(rve->right.rve)){ @@ -2170,6 +2445,7 @@ static int rve_optimize(struct rval_expr* rve) } /* op(op($v,a), op($w,b)) => no optimizations for now (TODO) */ } +end: return ret; error: if (rv) rval_destroy(rv);

15 years, 11 months

git:andrei/script_vars: script engine: keep file pos. info when optimizing

by Andrei Pelinescu-Onciul

Module: sip-router Branch: andrei/script_vars Commit: 991da23d6c14caa4eff82a150bca7fc4c59330b7 URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=991da23… Author: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Committer: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Date: Thu Dec 18 13:33:57 2008 +0100 script engine: keep file pos. info when optimizing - try to keep a reasonable value for an optimized rv. expression script file position - fix file position in debugging messages --- rvalue.c | 23 +++++++++++++++++++---- 1 files changed, 19 insertions(+), 4 deletions(-) diff --git a/rvalue.c b/rvalue.c index ce9e3d3..2a1ea88 100644 --- a/rvalue.c +++ b/rvalue.c @@ -2007,6 +2007,7 @@ static int rve_opt_01(struct rval_expr* rve, enum rval_type rve_type) int i; int ret; enum rval_expr_op op; + struct cfg_pos pos; int right; /* debugging msg */ rv=0; @@ -2046,7 +2047,9 @@ static int rve_opt_01(struct rval_expr* rve, enum rval_type rve_type) /* $v * 1 -> $v * 1 * $v -> $v */ rve_destroy(ct_rve); + pos=rve->fpos; *rve=*v_rve; /* replace current expr. with $v */ + rve->fpos=pos; pkg_free(v_rve);/* rve_destroy(v_rve) would free everything*/ ret=1; @@ -2068,7 +2071,9 @@ static int rve_opt_01(struct rval_expr* rve, enum rval_type rve_type) if (ct_rve==rve->right.rve){ /* $v / 1 -> $v */ rve_destroy(ct_rve); + pos=rve->fpos; *rve=*v_rve; /* replace current expr. with $v */ + rve->fpos=pos; pkg_free(v_rve);/* rve_destroy(v_rve) would free everything*/ ret=1; @@ -2080,7 +2085,9 @@ static int rve_opt_01(struct rval_expr* rve, enum rval_type rve_type) if (ct_rve==rve->right.rve){ /* $v - 0 -> $v */ rve_destroy(ct_rve); + pos=rve->fpos; *rve=*v_rve; /* replace current expr. with $v */ + rve->fpos=pos; pkg_free(v_rve);/* rve_destroy(v_rve) would free everything*/ ret=1; @@ -2104,7 +2111,9 @@ static int rve_opt_01(struct rval_expr* rve, enum rval_type rve_type) /* $v | 0 -> $v * 0 | $v -> $v */ rve_destroy(ct_rve); + pos=rve->fpos; *rve=*v_rve; /* replace current expr. with $v */ + rve->fpos=pos; pkg_free(v_rve);/* rve_destroy(v_rve) would free everything*/ ret=1; @@ -2121,7 +2130,9 @@ static int rve_opt_01(struct rval_expr* rve, enum rval_type rve_type) /* $v && 1 -> $v * 1 && $v -> $v */ rve_destroy(ct_rve); + pos=rve->fpos; *rve=*v_rve; /* replace current expr. with $v */ + rve->fpos=pos; pkg_free(v_rve);/* rve_destroy(v_rve) would free everything*/ ret=1; @@ -2138,7 +2149,9 @@ static int rve_opt_01(struct rval_expr* rve, enum rval_type rve_type) /* $v || 0 -> $v * 0 && $v -> $v */ rve_destroy(ct_rve); + pos=rve->fpos; *rve=*v_rve; /* replace current expr. with $v */ + rve->fpos=pos; pkg_free(v_rve);/* rve_destroy(v_rve) would free everything*/ ret=1; @@ -2151,7 +2164,9 @@ static int rve_opt_01(struct rval_expr* rve, enum rval_type rve_type) /* $v + 0 -> $v * 0 + $v -> $v */ rve_destroy(ct_rve); + pos=rve->fpos; *rve=*v_rve; /* replace current expr. with $v */ + rve->fpos=pos; pkg_free(v_rve);/* rve_destroy(v_rve) would free everything*/ ret=1; @@ -2168,26 +2183,26 @@ static int rve_opt_01(struct rval_expr* rve, enum rval_type rve_type) DBG("FIXUP RVE: (%d,%d-%d,%d) optimized" " op%d($v, %d) -> %d\n", rve->fpos.s_line, rve->fpos.s_col, - rve->fpos.e_line, rve->fpos.s_col, + rve->fpos.e_line, rve->fpos.e_col, op, i, (int)rve->left.rval.v.l); else DBG("FIXUP RVE: (%d,%d-%d,%d) optimized" " op%d($v, %d) -> $v\n", rve->fpos.s_line, rve->fpos.s_col, - rve->fpos.e_line, rve->fpos.s_col, + rve->fpos.e_line, rve->fpos.e_col, op, i); }else{ if ((rve->op==RVE_RVAL_OP) && (rve->left.rval.type==RV_INT)) DBG("FIXUP RVE: (%d,%d-%d,%d) optimized" " op%d(%d, $v) -> %d\n", rve->fpos.s_line, rve->fpos.s_col, - rve->fpos.e_line, rve->fpos.s_col, + rve->fpos.e_line, rve->fpos.e_col, op, i, (int)rve->left.rval.v.l); else DBG("FIXUP RVE: (%d,%d-%d,%d) optimized" " op%d(%d, $v) -> $v\n", rve->fpos.s_line, rve->fpos.s_col, - rve->fpos.e_line, rve->fpos.s_col, + rve->fpos.e_line, rve->fpos.e_col, op, i); } }

15 years, 11 months

git:andrei/script_vars: script engine: optimize $v - ct

by Andrei Pelinescu-Onciul

Module: sip-router Branch: andrei/script_vars Commit: 73f4a76ec264fdad4921c4ba26ecb1f6dadc81e9 URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=73f4a76… Author: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Committer: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Date: Thu Dec 18 09:45:06 2008 +0100 script engine: optimize $v - ct - $v - ct transformed into $v + (-ct) which is easier to optimize further --- rvalue.c | 19 ++++++++++++++++++- 1 files changed, 18 insertions(+), 1 deletions(-) diff --git a/rvalue.c b/rvalue.c index 063be00..558ab70 100644 --- a/rvalue.c +++ b/rvalue.c @@ -1992,7 +1992,24 @@ static int rve_optimize(struct rval_expr* rve) rval_type_name(bad_type), rval_type_name(exp_type)); return 0; } - /* TODO: $v - a => $v + (-a) */ + /* $v - a => $v + (-a) (easier to optimize)*/ + if ((rve->op==RVE_MINUS_OP) && (rve_is_constant(rve->right.rve))){ + if ((rv=rval_expr_eval(0, 0, rve->right.rve))==0){ + ERR("optimization failure, bad expression\n"); + goto error; + } + if (rv->type==RV_INT){ + rv->v.l=-rv->v.l; + if (rve_replace_with_ct_rv(rve->right.rve, rv)<0) + goto error; + rve->op=RVE_PLUS_OP; + DBG("FIXUP RVE: optimized $v - a into $v + (%d)\n", + (int)rve->right.rve->left.rval.v.l); + } + rval_destroy(rv); + rv=0; + } + /* TODO: $v * 0 => 0; $v * 1 => $v (for *, /, &, |, &&, ||, +, -) */ /* op(op($v, a), b) => op($v, op(a,b)) */

15 years, 11 months

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

sr-dev December 2008