script engine: more operators supported
[sip-router] / rvalue.h
1 /* 
2  * $Id$
3  * 
4  * Copyright (C) 2008 iptelorg GmbH
5  *
6  * Permission to use, copy, modify, and distribute this software for any
7  * purpose with or without fee is hereby granted, provided that the above
8  * copyright notice and this permission notice appear in all copies.
9  *
10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17  */
18 /**
19  * @file 
20  * @brief rvalue expressions
21  */
22 /* 
23  * History:
24  * --------
25  *  2008-11-30  initial version (andrei)
26  */
27
28 #ifndef _rvalue_h_
29 #define _rvalue_h_
30
31 #include "str.h"
32 #include "usr_avp.h"
33 #include "select.h"
34 #include "pvar.h"
35 #include "route.h"
36 #include "parser/msg_parser.h"
37 #include "action.h"
38
39 enum rval_type{
40         RV_NONE, RV_INT, RV_STR, /* basic types */
41         RV_BEXPR, RV_ACTION_ST,  /* special values */
42         RV_SEL, RV_AVP, RV_PVAR
43 };
44
45 enum rval_expr_op{
46         RVE_NONE_OP,  /* uninit / empty */
47         RVE_RVAL_OP,  /* special op, means that the expr. is in fact a rval */
48         RVE_UMINUS_OP, /* one member expression, returns -(val) */
49         RVE_BOOL_OP,  /* one member evaluate as bool. : (val!=0)*/
50         RVE_LNOT_OP,  /* one member evaluate as bool. : (!val)*/
51         RVE_MUL_OP,   /* 2 members, returns left * right */
52         RVE_DIV_OP,   /* 2 members, returns left / right */
53         RVE_MINUS_OP, /* 2 members, returns left - right */
54         RVE_BAND_OP,  /* 2 members, returns left | right */
55         RVE_BOR_OP,   /* 2 members, returns left & right */
56         RVE_LAND_OP,  /* 2 members, returns left && right */
57         RVE_LOR_OP,   /* 2 members, returns left || right */
58         RVE_GT_OP,    /*  2 members, returns left > right */
59         RVE_GTE_OP,   /*  2 members, returns left >= right */
60         RVE_LT_OP,    /*  2 members, returns left  < right */
61         RVE_LTE_OP,   /*  2 members, returns left <= right */
62         /* common int & str */
63         RVE_PLUS_OP,  /* 2 members, returns left + right  (int or str)*/
64         RVE_EQ_OP,    /*  2 members, returns left == right  (int)*/
65         RVE_DIFF_OP,  /*  2 members, returns left != right  (int)*/
66         /* str only */
67 };
68
69
70 union rval_val{
71         void* p;
72         long  l;
73         str s;
74         avp_spec_t avps;
75         select_t sel;
76         pv_spec_t pvs;
77         struct action* action;
78         struct expr* bexpr;
79 };
80
81
82 struct rvalue{
83         enum rval_type type;
84         int refcnt; /**< refcnt, on 0 the structure is destroyed */
85         union rval_val v;
86         int bsize; /**< extra data size */
87         short flags;
88         char buf[1]; /**< extra data, like string contents can be stored here */
89 };
90
91
92 /* rvalue flags */
93 #define RV_CNT_ALLOCED_F  1  /* free contents  (pkg mem allocated) */
94 #define RV_RV_ALLOCED_F   2  /* free rv itself (pkg_free(rv)) */
95 #define RV_ALL_ALLOCED_F  (RV_CNT_ALLOCED|RV_RV_ALLOCED)
96
97 struct rval_expr{
98         enum rval_expr_op op;
99         union{
100                 struct rval_expr* rve;
101                 struct rvalue rval;
102         }left;
103         union{
104                 struct rval_expr* rve;
105                 struct rvalue rval;
106         }right;
107 };
108
109
110 enum rval_cache_type{
111         RV_CACHE_EMPTY,
112         RV_CACHE_PVAR,
113         RV_CACHE_AVP
114 };
115
116 /** value cache for a rvalue struct.
117   * Used to optimize functions that would need to 
118   * get the value repeatedly (e.g. rval_get_btype() and then rval_get_int())
119   */
120 struct rval_cache{
121         enum rval_cache_type cache_type;
122         enum rval_type val_type;
123         union{
124                 int_str avp_val; /**< avp value */
125                 pv_value_t pval; /**< pvar value */
126         }c;
127 };
128
129
130
131 /** allocates a new rval (should be freed by rval_destroy()). */
132 struct rvalue* rval_new_empty(int extra_size);
133 struct rvalue* rval_new_str(str* s, int extra_size);
134 struct rvalue* rval_new(enum rval_type t, union rval_val* v, int extra_size);
135
136 /** inits a rvalue structure- */
137 void rval_init(struct rvalue* rv, enum rval_type t, union rval_val* v,
138                                         int flags);
139 /** frees a rval_new(), rval_convert() or rval_expr_eval() returned rval. */
140 void rval_destroy(struct rvalue* rv);
141
142 /** frees a rval contents */
143 void rval_clean(struct rvalue* rv);
144
145 /** init a rval_cache struct */
146 #define rval_cache_init(rvc) \
147         do{ (rvc)->cache_type=RV_CACHE_EMPTY; (rvc)->val_type=RV_NONE; }while(0)
148
149 /** destroy a rval_cache struct contents */
150 void rval_cache_clean(struct rval_cache* rvc);
151
152
153 /** convert a rvalue to another type.  */
154 struct rvalue* rval_convert(struct run_act_ctx* h, struct sip_msg* msg, 
155                                                         enum rval_type type, struct rvalue* v,
156                                                         struct rval_cache* c);
157
158 /** get the integer value of an rvalue. */
159 int rval_get_int(struct run_act_ctx* h, struct sip_msg* msg, int* i, 
160                                 struct rvalue* rv, struct rval_cache* cache);
161 /** get the string value of an rv. */
162 int rval_get_str(struct run_act_ctx* h, struct sip_msg* msg,
163                                                                 str* s, struct rvalue* rv,
164                                                                 struct rval_cache* cache);
165 /** get the string value of an rv in a tmp variable */
166 int rval_get_tmp_str(struct run_act_ctx* h, struct sip_msg* msg,
167                                                                 str* tmpv, struct rvalue* rv,
168                                                                 struct rval_cache* cache,
169                                                                 struct rval_cache* tmp_cache);
170
171 /** evals an integer expr  to an int. */
172 int rval_expr_eval_int( struct run_act_ctx* h, struct sip_msg* msg,
173                                                 int* res, struct rval_expr* rve);
174 /** evals a rval expr.. */
175 struct rvalue* rval_expr_eval(struct run_act_ctx* h, struct sip_msg* msg,
176                                                                 struct rval_expr* rve);
177
178 /** guess the type of an expression.  */
179 enum rval_type rve_guess_type(struct rval_expr* rve);
180 /** returns true if expression is constant. */
181 int rve_is_constant(struct rval_expr* rve);
182 /** returns 1 if expression is valid (type-wise).*/
183 int rve_check_type(enum rval_type* type, struct rval_expr* rve);
184
185 /** create a RVE_RVAL_OP rval_expr, containing a single rval of the given type
186   */
187 struct rval_expr* mk_rval_expr_v(enum rval_type rv_type, void* val);
188 /** create a unary op. rval_expr.. */
189 struct rval_expr* mk_rval_expr1(enum rval_expr_op op, struct rval_expr* rve1);
190 /** create a rval_expr. from 2 other rval exprs, using op. */
191 struct rval_expr* mk_rval_expr2(enum rval_expr_op op, struct rval_expr* rve1,
192                                                                                                           struct rval_expr* rve2);
193
194 /** fix a rval_expr. */
195 int fix_rval_expr(void** p);
196 #endif /* _rvalue_h */