script engine: string switch optimization and fixup

- fixup and optimize (if constant) string switches

switch.c

@@ -22,6 +22,7 @@
  * History:
  * --------
  *  2009-02-02  initial version (andrei)
+ *  2009-02-19  string and RE switch support added (andrei)
 */
 
 #include "switch.h"
@@ -84,6 +85,32 @@ static struct switch_jmp_table* mk_switch_jmp_table(int jmp_size, int rest)
 
 
 
+/** create a match cond table structure (pkg_malloc'ed).
+ * @return 0 on error, pointer on success
+ */
+static struct match_cond_table* mk_match_cond_table(int n)
+{
+	struct match_cond_table* mct;
+	
+	/* allocate everything in a single block, better for cache locality */
+	mct=pkg_malloc(ROUND_POINTER(sizeof(*mct))+
+					ROUND_POINTER(n*sizeof(mct->match[0]))+
+					n*sizeof(mct->jump[0]));
+	if (mct==0) return 0;
+	mct->n=n;
+	mct->match=(struct match_str*)((char*)mct+ROUND_POINTER(sizeof(*mct)));
+	mct->jump=(struct action**)
+				((char*)mct->match+ROUND_POINTER(n*sizeof(mct->match[0])));
+	mct->def=0;
+	return mct;
+}
+
+
+
+static int fix_match(struct action* t);
+
+
+
 void destroy_case_stms(struct case_stms *lst)
 {
 	struct case_stms* l;
@@ -138,6 +165,11 @@ int fix_switch(struct action* t)
 	def_jmp_bm=0;
 	labels_no=0;
 	default_found=0;
+	/* check if string switch (first case is string or RE) */
+	for (c=(struct case_stms*)t->val[1].u.data; c && c->is_default; c=c->next);
+	if (c && (c->type==MATCH_STR || c->type==MATCH_RE))
+		return fix_match(t);
+	
 	sw_rve=(struct rval_expr*)t->val[0].u.data;
 	/*  handle null actions: optimize away if no
 	   sideffects */
@@ -159,12 +191,17 @@ int fix_switch(struct action* t)
 	n=0;
 	for (c=(struct case_stms*)t->val[1].u.data; c; c=c->next){
 		if (c->ct_rve){
+			if (c->type!=MATCH_INT){
+				LOG(L_ERR, "ERROR: fix_switch: wrong case type %d (int"
+							"expected)\n", c->type);
+				return E_UNSPEC;
+			}
 			if (!rve_is_constant(c->ct_rve)){
 				LOG(L_ERR, "ERROR: fix_switch: non constant "
 						"expression in case\n");
 				return E_BUG;
 			}
-			if (rval_expr_eval_int(0, 0,  &c->int_label, c->ct_rve)
+			if (rval_expr_eval_int(0, 0,  &c->label.match_int, c->ct_rve)
 					<0){
 				LOG(L_ERR, "ERROR: fix_switch: case expression"
 						" (%d,%d) has non-interger type\n",
@@ -183,7 +220,7 @@ int fix_switch(struct action* t)
 				return E_UNSPEC;
 			}
 			default_found=1;
-			c->int_label=-1;
+			c->label.match_int=-1;
 			c->is_default=1;
 			def_a=c->actions;
 		}
@@ -241,14 +278,14 @@ int fix_switch(struct action* t)
 			def_jmp_bm=tail;
 		} else {
 			for (j=0; j<n; j++){
-				if (cond[j]==c->int_label){
+				if (cond[j]==c->label.match_int){
 					LOG(L_ERR, "ERROR: fix_switch: duplicate case (%d,%d)\n",
 							c->ct_rve->fpos.s_line, c->ct_rve->fpos.s_col);
 					ret=E_UNSPEC;
 					goto error;
 				}
 			}
-			cond[n]=c->int_label;
+			cond[n]=c->label.match_int;
 			jmp_bm[n]=tail;
 			n++;
 		}
@@ -371,4 +408,300 @@ error:
 	return ret;
 }
 
+
+
+/** fixup function for MATCH_T actions.
+ * can produce 3 different action types:
+ *  - BLOCK_T (actions) - actions grouped in a block, break ends the block
+ *    execution.
+ *  - EVAL_T (cond)  - null switch block, but the condition has to be
+ *                       evaluated due to possible side-effects.
+ *  - MATCH_COND_T(cond, jumps) - condition table
+ */
+static int fix_match(struct action* t)
+{
+	struct case_stms* c;
+	int n, i, j, ret;
+	struct action* a;
+	struct action* block;
+	struct action* def_a;
+	struct action* action_lst;
+	struct action** tail;
+	struct match_cond_table* mct;
+	int labels_no;
+	struct action** def_jmp_bm;
+	struct match_str* match;
+	struct action*** jmp_bm;
+	int default_found;
+	struct rval_expr* m_rve;
+	struct rvalue* rv;
+	regex_t* regex;
+	str s;
+	
+	ret=E_BUG;
+	match=0;
+	jmp_bm=0;
+	def_jmp_bm=0;
+	labels_no=0;
+	default_found=0;
+	rv=0;
+	s.s=0;
+	s.len=0;
+	m_rve=(struct rval_expr*)t->val[0].u.data;
+	/*  handle null actions: optimize away if no
+	   sideffects */
+	if (t->val[1].u.data==0){
+		if (!rve_has_side_effects(m_rve)){
+			t->type=BLOCK_T;
+			rve_destroy(m_rve);
+			t->val[0].type=BLOCK_ST;
+			t->val[0].u.data=0;
+			DBG("MATCH: null switch optimized away\n");
+		}else{
+			t->type=EVAL_T;
+			t->val[0].type=RVE_ST;
+			DBG("MATCH: null switch turned to EVAL_T\n");
+		}
+		return 0;
+	}
+	def_a=0;
+	n=0;
+	for (c=(struct case_stms*)t->val[1].u.data; c; c=c->next){
+		if (c->ct_rve){
+			if (c->type!=MATCH_STR && c->type!=MATCH_RE){
+				LOG(L_ERR, "ERROR: fix_match: wrong case type %d (string"
+							"or RE expected)\n", c->type);
+				return E_UNSPEC;
+			}
+			if (!rve_is_constant(c->ct_rve)){
+				LOG(L_ERR, "ERROR: fix_match: non constant "
+						"expression in case\n");
+				ret=E_BUG;
+				goto error;
+			}
+			if ((rv=rval_expr_eval(0, 0, c->ct_rve)) == 0 ){
+				LOG(L_ERR, "ERROR: fix_match: bad case expression"
+						" (%d,%d)\n",
+						c->ct_rve->fpos.s_line,
+						c->ct_rve->fpos.s_col);
+				ret=E_BUG;
+				goto error;
+			}
+			if (rval_get_str(0, 0, &s, rv, 0)<0){
+				LOG(L_ERR, "ERROR: fix_match (%d,%d): out of memory?\n",
+						c->ct_rve->fpos.s_line,
+						c->ct_rve->fpos.s_col);
+				ret=E_BUG;
+				goto error;
+			}
+			if (c->type==MATCH_RE){
+				if ((regex=pkg_malloc(sizeof(regex_t))) == 0){
+					LOG(L_ERR, "ERROR: fix_match: out of memory\n");
+					ret=E_OUT_OF_MEM;
+					goto error;
+				}
+				if (regcomp(regex, s.s, 
+							REG_EXTENDED | REG_NOSUB | c->re_flags) !=0){
+					pkg_free(regex);
+					regex=0;
+					LOG(L_ERR, "ERROR: fix_match (%d, %d): bad regular"
+								" expression %.*s\n",
+							c->ct_rve->fpos.s_line,
+							c->ct_rve->fpos.s_col,
+							s.len, ZSW(s.s));
+					ret=E_UNSPEC;
+					goto error;
+				}
+				c->label.match_re=regex;
+				regex=0;
+			}else if (c->type==MATCH_STR){
+				c->label.match_str=s;
+				s.s=0;
+				s.len=0;
+			}else{
+				LOG(L_CRIT, "BUG: fix_match (%d,%d): wrong case type %d\n",
+						c->ct_rve->fpos.s_line, c->ct_rve->fpos.s_col,
+						c->type);
+				ret=E_BUG;
+				goto error;
+			}
+			c->is_default=0;
+			n++; /* count only non-default cases */
+			/* cleanup */
+			rval_destroy(rv);
+			rv=0;
+			if (s.s){
+				pkg_free(s.s);
+				s.s=0;
+				s.len=0;
+			}
+		}else{
+			if (default_found){
+				LOG(L_ERR, "ERROR: fix_match: more then one \"default\""
+						" label found (%d, %d)\n",
+						c->ct_rve->fpos.s_line,
+						c->ct_rve->fpos.s_col);
+				ret=E_UNSPEC;
+				goto error;
+			}
+			default_found=1;
+			c->is_default=1;
+			def_a=c->actions;
+		}
+		if ( c->actions && ((ret=fix_actions(c->actions))<0))
+			goto error;
+	}
+	DBG("MATCH: %d cases, %d default\n", n, default_found);
+	/*: handle n==0 (no case only a default:) */
+	if (n==0){
+		if (default_found){
+			if (!rve_has_side_effects(m_rve)){
+				t->type=BLOCK_T;
+				rve_destroy(m_rve);
+				destroy_case_stms(t->val[1].u.data);
+				t->val[0].type=BLOCK_ST;
+				t->val[0].u.data=def_a;
+				t->val[1].type=0;
+				t->val[1].u.data=0;
+				DBG("MATCH: default only switch optimized away (BLOCK_T)\n");
+				return 0;
+			}
+			DBG("MATCH: default only switch with side-effect...\n");
+		}else{
+			LOG(L_CRIT, "BUG: fix_match: empty switch not expected at this"
+					" point\n");
+			ret=E_BUG;
+			goto error;
+		}
+	}
+	labels_no=n;
+	match=pkg_malloc(sizeof(match[0])*n);
+	jmp_bm=pkg_malloc(sizeof(jmp_bm[0])*n);
+	if (match==0 || jmp_bm==0){
+		LOG(L_ERR, "ERROR: fix_match: memory allocation failure\n");
+		ret=E_OUT_OF_MEM;
+		goto error;
+	}
+	
+	/* fill condition table and jump point bookmarks and "flatten" the action 
+	   lists (transform them into a single list for the entire switch, rather
+	    then one block per case ) */
+	n=0;
+	action_lst=0;
+	tail=&action_lst;
+	for (c=(struct case_stms*)t->val[1].u.data; c; c=c->next){
+		a=c->actions;
+		if (a){
+			for (; a->next; a=a->next);
+			if (action_lst==0)
+				action_lst=c->actions;
+			else
+				*tail=c->actions;
+		}
+		if (c->is_default){
+			def_jmp_bm=tail;
+		} else{
+			match[n].type=c->type;
+			if (match[n].type == MATCH_STR){
+				for (j=0; j<n; j++){
+					if ( match[j].type == c->type &&
+						 match[j].l.s.len ==  c->label.match_str.len &&
+						 memcmp(match[j].l.s.s, c->label.match_str.s,
+							 		match[j].l.s.len) == 0 ){
+						LOG(L_ERR, "ERROR: fix_match: duplicate case"
+								" (%d,%d)\n", c->ct_rve->fpos.s_line,
+								c->ct_rve->fpos.s_col);
+						ret=E_UNSPEC;
+						goto error;
+					}
+				}
+				match[n].flags=0;
+				match[n].l.s=c->label.match_str;
+				c->label.match_str.s=0; /* prevent s being freed */
+				c->label.match_str.len=0;
+			} else {
+				match[n].flags=c->re_flags | REG_EXTENDED | REG_NOSUB;
+				match[n].l.regex=c->label.match_re;
+				c->label.match_re=0;
+			}
+			jmp_bm[n]=tail;
+			n++;
+		}
+		if (c->actions)
+			tail=&a->next;
+	}
+	/* handle constant rve w/ no side-effects: replace the whole case 
+	   with the case rve block */
+	if ( (scr_opt_lev>=2) &&
+			!rve_has_side_effects(m_rve) && rve_is_constant(m_rve)){
+		if ((rv=rval_expr_eval(0, 0, m_rve)) == 0){
+			LOG(L_ERR, "ERROR: fix_match: bad expression (%d,%d)\n", 
+					m_rve->fpos.s_line, m_rve->fpos.s_col);
+			ret=E_UNSPEC;
+			goto error;
+		}
+		if (rval_get_str(0, 0, &s, rv, 0) < 0 ){
+				LOG(L_ERR, "ERROR: fix_match (%d,%d): bad string expression\n",
+						m_rve->fpos.s_line,
+						m_rve->fpos.s_col);
+			ret=E_UNSPEC;
+			goto error;
+		}
+		/* start with the "default:" value in case nothing is found */
+		block=def_jmp_bm?*def_jmp_bm:0;
+		for (i=0; i<n; i++){
+			if (((match[i].type == MATCH_STR) && (match[i].l.s.len == s.len) &&
+					(memcmp(match[i].l.s.s, s.s, s.len) == 0)) ||
+				((match[i].type == MATCH_RE) && 
+					regexec(match[i].l.regex, s.s, 0, 0, 0) == 0) ) {
+				block=*jmp_bm[i];
+				break;
+			}
+		}
+		DBG("MATCH: constant switch(\"%.*s\") with %d cases optimized away"
+				" to case no. %d\n", s.len, ZSW(s.s), n, i);
+		/* cleanup */
+		rval_destroy(rv);
+		rv=0;
+		pkg_free(s.s);
+		s.s=0;
+		s.len=0;
+		ret=0;
+		/* replace with BLOCK_ST */
+		rve_destroy(m_rve);
+		destroy_case_stms(t->val[1].u.data);
+		t->type=BLOCK_T;
+		t->val[0].type=BLOCK_ST;
+		t->val[0].u.data=block;
+		t->val[1].type=0;
+		t->val[1].u.data=0;
+		goto end;
+	}
+	mct=mk_match_cond_table(n);
+	if (mct==0){
+		LOG(L_ERR, "ERROR: fix_match: memory allocation error\n");
+		ret=E_OUT_OF_MEM;
+		goto error;
+	}
+	mct->n=n;
+	for (i=0; i<n; i++){
+		mct->match[i]=match[i];
+		mct->jump[i]=*jmp_bm[i];
+	}
+	mct->def=def_jmp_bm?*def_jmp_bm:0;
+	t->type=MATCH_COND_T;
+	t->val[1].type=MATCH_CONDTABLE_ST;
+	t->val[1].u.data=mct;
+	DBG("MATCH: optimized to match condtable (%d) default: %s\n ",
+				mct->n, mct->def?"yes":"no");
+		ret=0;
+end:
+error:
+	if (match) pkg_free(match);
+	if (jmp_bm) pkg_free(jmp_bm);
+	/* cleanup rv & s*/
+	if (rv) rval_destroy(rv);
+	if (s.s) pkg_free(s.s);
+	return ret;
+}
 /* vi: set ts=4 sw=4 tw=79:ai:cindent: */