-/* ------------------------------------------------
-Copyright 2014 AT&T Intellectual Property
- Licensed under the Apache License, Version 2.0 (the "License");
- you may not use this file except in compliance with the License.
- You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
- Unless required by applicable law or agreed to in writing, software
- distributed under the License is distributed on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- See the License for the specific language governing permissions and
- limitations under the License.
- ------------------------------------------- */
-#include"parse_partn.h"
-#include "parse_schema.h"
-#include"analyze_fta.h"
-
-
-using namespace std;
-
-
-int find_field(scalarexp_t *se, string &fld){
- vector<scalarexp_t *> operands;
- int o,ret=0;
-
- switch(se->get_operator_type()){
- case SE_LITERAL:
- return 0;
- case SE_PARAM:
- case SE_IFACE_PARAM:
- return 100; // force failure, but no error message.
- case SE_UNARY_OP:
- return find_field(se->get_left_se(), fld);
- case SE_BINARY_OP:
- return find_field(se->get_left_se(), fld)+find_field(se->get_right_se(), fld);
- case SE_COLREF:
- fld = se->get_colref()->get_field();
- return 1;
- case SE_AGGR_STAR:
- case SE_AGGR_SE:
-// Should be no aggregates
- return 0;
- case SE_FUNC:
- return 100; // force failure, but no error message.
- default:
- fprintf(stderr,"INTERNAL ERROR in find_field, unknown operator type %d\n", se->get_operator_type());
- return(-100);
- }
- return(-100);
-}
-
-
-int partn_def_t::verify(table_list *schema, string &err_msg){
- if(schema->find_tbl(protocol) < 0){
- err_msg += "ERROR, partition definition "+name+" uses source "+protocol+", but its not in the schema.\n";
- return 1;
- }
- if(schema->get_schema_type(schema->find_tbl(protocol)) != PROTOCOL_SCHEMA){
- err_msg += "ERROR, partition definition "+name+" uses source "+protocol+", but its not a PROTOCOL.\n";
- return 1;
- }
-
- tablevar_t *fme = new tablevar_t(protocol.c_str());
- tablevar_list_t fm(fme);
-
-// Validate the SE and assign data types.
- int i;
- int retval = 0;
- for(i=0;i<se_list.size();++i){
- int ret = verify_colref(se_list[i],&fm,schema,NULL);
- if(ret){
- err_msg += "ERROR validating entry "+int_to_string(i)+" of partition definition "+name+".\n";
- retval=1;
- }
- }
- if(retval)
- return 1;
-
-// Ensure that the data type is an integer type.
- for(i=0;i<se_list.size();++i){
- data_type *dt = se_list[i]->get_data_type();
- string type_s = dt->get_type_str();
- if(! ( type_s=="UINT" || type_s=="INT" || type_s=="ULLONG" || type_s=="LLONG") ){
- err_msg += "ERROR, entry "+int_to_string(i)+" of partition definition "+name+" has type "+type_s+", but it must be one of UINT, INT, ULLONG, LLONG.\n";
- retval=1;
- }
- }
- if(retval)
- return 1;
-
-// Ensure that each SE ref's a field only once.
- for(i=0;i<se_list.size();++i){
- string fld;
- int ret = find_field(se_list[i],fld);
- if(ret<0){
- err_msg += "ERROR validating entry "+int_to_string(i)+" of partition definition "+name+".\n";
- retval=1;
- }
- if(ret!=1){
- err_msg += "ERROR validating entry "+int_to_string(i)+" of partition definition "+name+": the expression references a field "+int_to_string(ret)+" times, but it should reference a field exactly once.\n";
- retval=1;
- field_list.push_back("");
- }else{
- field_list.push_back(fld);
- }
- }
- if(retval)
- return 1;
-
- return 0;
-
-}
-
-void find_colref_path(scalarexp_t *se, vector<scalarexp_t *> &se_stack){
- vector<scalarexp_t *> operands;
- int o,ret=0;
-
- switch(se->get_operator_type()){
- case SE_LITERAL:
- case SE_PARAM:
- case SE_IFACE_PARAM:
- return ;
- case SE_UNARY_OP:
- find_colref_path(se->get_left_se(), se_stack);
- if(se_stack.size()>0)
- se_stack.push_back(se);
- return;
- case SE_BINARY_OP:
- find_colref_path(se->get_left_se(), se_stack);
- if(se_stack.size()>0){
- se_stack.push_back(se);
- return;
- }
- find_colref_path(se->get_right_se(), se_stack);
- if(se_stack.size()>0)
- se_stack.push_back(se);
- return;
- case SE_COLREF:
- se_stack.push_back(se);
- return;
- case SE_AGGR_STAR:
- case SE_AGGR_SE:
-// Should be no aggregates
- return;
- case SE_FUNC:
- operands = se->get_operands();
- for(o=0;o<operands.size();o++){
- find_colref_path(operands[o], se_stack);
- if(se_stack.size()>0){
- se_stack.push_back(se);
- return;
- }
- }
- return;
- default:
- fprintf(stderr,"INTERNAL ERROR in find_colref_path, unknown operator type %d\n", se->get_operator_type());
- return;
- }
- return;
-}
-
-struct param_int{
- union{
- long int li;
- unsigned long int uli;
- long long int lli;
- unsigned long long int ulli;
- } v;
- dtype d;
-
- void convert_to_final() {};
-
- void load_val(dtype dt, const char *val){
- d=dt;
- switch(dt){
- case u_int_t:
- sscanf(val,"%llu",&(v.ulli));
- break;
- case int_t:
- sscanf(val,"%lld",&(v.lli));
- break;
- case u_llong_t:
- sscanf(val,"%llu",&(v.ulli));
- break;
- case llong_t:
- sscanf(val,"%lld",&(v.lli));
- break;
- default:
- fprintf(stderr,"INTERNAL ERROR, data type %d passed to param_int::load_val.\n",dt);
- exit(1);
- }
- }
-
- void add(dtype dt, param_int &l, param_int &r){
- d=dt;
- if(dt==int_t || dt==llong_t)
- if(l.d==int_t || l.d==llong_t)
- if(r.d==int_t || r.d==llong_t) v.lli = l.v.lli+r.v.lli; else v.lli = l.v.lli+r.v.ulli;
- else
- if(r.d==int_t || r.d==llong_t) v.lli = l.v.ulli+r.v.lli; else v.lli = l.v.ulli+r.v.ulli;
- else
- if(l.d==int_t || l.d==llong_t)
- if(r.d==int_t || r.d==llong_t) v.ulli = l.v.lli+r.v.lli; else v.ulli = l.v.lli+r.v.ulli;
- else
- if(r.d==int_t || r.d==llong_t) v.ulli = l.v.ulli+r.v.lli; else v.ulli = l.v.ulli+r.v.ulli;
- }
- void subtract(dtype dt, param_int &l, param_int &r){
- d=dt;
- if(dt==int_t || dt==llong_t)
- if(l.d==int_t || l.d==llong_t)
- if(r.d==int_t || r.d==llong_t) v.lli = l.v.lli-r.v.lli; else v.lli = l.v.lli-r.v.ulli;
- else
- if(r.d==int_t || r.d==llong_t) v.lli = l.v.ulli-r.v.lli; else v.lli = l.v.ulli-r.v.ulli;
- else
- if(l.d==int_t || l.d==llong_t)
- if(r.d==int_t || r.d==llong_t) v.ulli = l.v.lli-r.v.lli; else v.ulli = l.v.lli-r.v.ulli;
- else
- if(r.d==int_t || r.d==llong_t) v.ulli = l.v.ulli-r.v.lli; else v.ulli = l.v.ulli-r.v.ulli;
- }
- void mult(dtype dt, param_int &l, param_int &r){
- d=dt;
- if(dt==int_t || dt==llong_t)
- if(l.d==int_t || l.d==llong_t)
- if(r.d==int_t || r.d==llong_t) v.lli = l.v.lli*r.v.lli; else v.lli = l.v.lli*r.v.ulli;
- else
- if(r.d==int_t || r.d==llong_t) v.lli = l.v.ulli*r.v.lli; else v.lli = l.v.ulli*r.v.ulli;
- else
- if(l.d==int_t || l.d==llong_t)
- if(r.d==int_t || r.d==llong_t) v.ulli = l.v.lli*r.v.lli; else v.ulli = l.v.lli*r.v.ulli;
- else
- if(r.d==int_t || r.d==llong_t) v.ulli = l.v.ulli*r.v.lli; else v.ulli = l.v.ulli*r.v.ulli;
- }
- void div(dtype dt, param_int &l, param_int &r){
- d=dt;
- if(dt==int_t || dt==llong_t)
- if(l.d==int_t || l.d==llong_t)
- if(r.d==int_t || r.d==llong_t) v.lli = l.v.lli/r.v.lli; else v.lli = l.v.lli/r.v.ulli;
- else
- if(r.d==int_t || r.d==llong_t) v.lli = l.v.ulli/r.v.lli; else v.lli = l.v.ulli/r.v.ulli;
- else
- if(l.d==int_t || l.d==llong_t)
- if(r.d==int_t || r.d==llong_t) v.ulli = l.v.lli/r.v.lli; else v.ulli = l.v.lli/r.v.ulli;
- else
- if(r.d==int_t || r.d==llong_t) v.ulli = l.v.ulli/r.v.lli; else v.ulli = l.v.ulli/r.v.ulli;
- }
- void bit_and(dtype dt, param_int &l, param_int &r){
- d=dt;
- if(dt==int_t || dt==llong_t)
- if(l.d==int_t || l.d==llong_t)
- if(r.d==int_t || r.d==llong_t) v.lli = l.v.lli&r.v.lli; else v.lli = l.v.lli&r.v.ulli;
- else
- if(r.d==int_t || r.d==llong_t) v.lli = l.v.ulli&r.v.lli; else v.lli = l.v.ulli&r.v.ulli;
- else
- if(l.d==int_t || l.d==llong_t)
- if(r.d==int_t || r.d==llong_t) v.ulli = l.v.lli&r.v.lli; else v.ulli = l.v.lli&r.v.ulli;
- else
- if(r.d==int_t || r.d==llong_t) v.ulli = l.v.ulli&r.v.lli; else v.ulli = l.v.ulli&r.v.ulli;
- }
- void bit_or(dtype dt, param_int &l, param_int &r){
- d=dt;
- if(dt==int_t || dt==llong_t)
- if(l.d==int_t || l.d==llong_t)
- if(r.d==int_t || r.d==llong_t) v.lli = l.v.lli|r.v.lli; else v.lli = l.v.lli|r.v.ulli;
- else
- if(r.d==int_t || r.d==llong_t) v.lli = l.v.ulli|r.v.lli; else v.lli = l.v.ulli|r.v.ulli;
- else
- if(l.d==int_t || l.d==llong_t)
- if(r.d==int_t || r.d==llong_t) v.ulli = l.v.lli|r.v.lli; else v.ulli = l.v.lli|r.v.ulli;
- else
- if(r.d==int_t || r.d==llong_t) v.ulli = l.v.ulli|r.v.lli; else v.ulli = l.v.ulli|r.v.ulli;
- }
- void modulo(dtype dt, param_int &l, param_int &r){
- d=dt;
- if(dt==int_t || dt==llong_t)
- if(l.d==int_t || l.d==llong_t)
- if(r.d==int_t || r.d==llong_t) v.lli = l.v.lli%r.v.lli; else v.lli = l.v.lli%r.v.ulli;
- else
- if(r.d==int_t || r.d==llong_t) v.lli = l.v.ulli%r.v.lli; else v.lli = l.v.ulli%r.v.ulli;
- else
- if(l.d==int_t || l.d==llong_t)
- if(r.d==int_t || r.d==llong_t) v.ulli = l.v.lli%r.v.lli; else v.ulli = l.v.lli%r.v.ulli;
- else
- if(r.d==int_t || r.d==llong_t) v.ulli = l.v.ulli%r.v.lli; else v.ulli = l.v.ulli%r.v.ulli;
- }
- void shift_left(dtype dt, param_int &l, param_int &r){
- d=dt;
- if(dt==int_t || dt==llong_t)
- if(l.d==int_t || l.d==llong_t)
- if(r.d==int_t || r.d==llong_t) v.lli = l.v.lli<<r.v.lli; else v.lli = l.v.lli<<r.v.ulli;
- else
- if(r.d==int_t || r.d==llong_t) v.lli = l.v.ulli<<r.v.lli; else v.lli = l.v.ulli<<r.v.ulli;
- else
- if(l.d==int_t || l.d==llong_t)
- if(r.d==int_t || r.d==llong_t) v.ulli = l.v.lli<<r.v.lli; else v.ulli = l.v.lli<<r.v.ulli;
- else
- if(r.d==int_t || r.d==llong_t) v.ulli = l.v.ulli<<r.v.lli; else v.ulli = l.v.ulli<<r.v.ulli;
- }
- void shift_right(dtype dt, param_int &l, param_int &r){
- d=dt;
- if(dt==int_t || dt==llong_t)
- if(l.d==int_t || l.d==llong_t)
- if(r.d==int_t || r.d==llong_t) v.lli = l.v.lli>>r.v.lli; else v.lli = l.v.lli>>r.v.ulli;
- else
- if(r.d==int_t || r.d==llong_t) v.lli = l.v.ulli>>r.v.lli; else v.lli = l.v.ulli>>r.v.ulli;
- else
- if(l.d==int_t || l.d==llong_t)
- if(r.d==int_t || r.d==llong_t) v.ulli = l.v.lli>>r.v.lli; else v.ulli = l.v.lli>>r.v.ulli;
- else
- if(r.d==int_t || r.d==llong_t) v.ulli = l.v.ulli>>r.v.lli; else v.ulli = l.v.ulli>>r.v.ulli;
- }
-
- void plus(dtype dt, param_int &l){
- d=dt;
- if(dt==int_t || dt==llong_t)
- if(l.d==int_t || l.d==llong_t)
- v.lli = l.v.ulli;
- else
- v.lli = l.v.lli;
- else
- if(l.d==int_t || l.d==llong_t)
- v.ulli = l.v.ulli;
- else
- v.ulli = l.v.lli;
- }
- void minus(dtype dt, param_int &l){
- d=dt;
- if(dt==int_t || dt==llong_t)
- if(l.d==int_t || l.d==llong_t)
- v.lli = -l.v.ulli;
- else
- v.lli = -l.v.lli;
- else
- if(l.d==int_t || l.d==llong_t)
- v.ulli = -l.v.ulli;
- else
- v.ulli = -l.v.lli;
- }
- void abs_not(dtype dt, param_int &l){
- d=dt;
- if(dt==int_t || dt==llong_t)
- if(l.d==int_t || l.d==llong_t)
- v.lli = !l.v.ulli;
- else
- v.lli = !l.v.lli;
- else
- if(l.d==int_t || l.d==llong_t)
- v.ulli = !l.v.ulli;
- else
- v.ulli = !l.v.lli;
- }
- void bit_not(dtype dt, param_int &l){
- d=dt;
- if(dt==int_t || dt==llong_t)
- if(l.d==int_t || l.d==llong_t)
- v.lli = ~l.v.ulli;
- else
- v.lli = ~l.v.lli;
- else
- if(l.d==int_t || l.d==llong_t)
- v.ulli = ~l.v.ulli;
- else
- v.ulli = ~l.v.lli;
- }
-};
-
-
-bool int_operand_divides(param_int &lp, param_int &rp){
- if( (lp.d==int_t || lp.d==llong_t)){
- if(lp.v.lli < 0)
- lp.v.ulli = -lp.v.lli;
- else
- lp.v.ulli = lp.v.lli;
- }
- if( (rp.d==int_t || rp.d==llong_t)){
- if(rp.v.lli < 0)
- rp.v.ulli = -rp.v.lli;
- else
- rp.v.ulli = rp.v.lli;
- }
- unsigned long long int d = rp.v.ulli / lp.v.ulli;
- unsigned long long int r = rp.v.ulli - d * lp.v.ulli;
- return d==0;
-}
-
-bool int_operand_implies(param_int &lp, param_int &rp){
- unsigned long long int d = (lp.v.ulli & rp.v.ulli) | (!lp.v.ulli);
- return (~d)==0;
-}
-
-
-
-
-void extract_param_int(scalarexp_t *se, param_int &p_int) {
-param_int lp, rp;
-string op_str;
-dtype dt = se->get_data_type()->get_type();
- switch(se->get_operator_type()){
- case SE_LITERAL:
- p_int.load_val(se->get_data_type()->get_type(),se->to_string().c_str());
- return;
- case SE_UNARY_OP:
- extract_param_int(se->get_left_se(), lp);
- op_str = se->get_op();
- if(op_str=="+") p_int.plus(dt,lp);
- if(op_str=="-") p_int.minus(dt,lp);
- if(op_str=="!") p_int.abs_not(dt,lp);
- if(op_str=="~") p_int.bit_not(dt,lp);
- return;
- case SE_BINARY_OP:
- extract_param_int(se->get_left_se(), lp);
- extract_param_int(se->get_right_se(), rp);
- op_str = se->get_op();
- if(op_str=="+") p_int.add(dt,lp,rp);
- if(op_str=="-") p_int.subtract(dt,lp,rp);
- if(op_str=="*") p_int.mult(dt,lp,rp);
- if(op_str=="/") p_int.div(dt,lp,rp);
- if(op_str=="&") p_int.bit_and(dt,lp,rp);
- if(op_str=="|") p_int.bit_or(dt,lp,rp);
- if(op_str=="%") p_int.modulo(dt,lp,rp);
- if(op_str=="<<") p_int.shift_left(dt,lp,rp);
- if(op_str==">>") p_int.shift_right(dt,lp,rp);
- return;
- default:
- fprintf(stderr,"INTERNAL ERROR in find_field, invalid operator type %d\n", se->get_operator_type());
- exit(1);
- }
- return;
-
-}
-
-
-void get_int_operand(scalarexp_t *parent, scalarexp_t *child, param_int &p_int){
- if(parent->get_operator_type() != SE_BINARY_OP){
- fprintf(stderr,"INTERNAL ERROR, operator type %d in get_int_operand.\n",
-parent->get_operator_type());
- exit(1);
- }
- if(parent->get_right_se() == child){
- extract_param_int(parent->get_left_se(), p_int);
- p_int.convert_to_final();
- }else{
- extract_param_int(parent->get_right_se(), p_int);
- p_int.convert_to_final();
- }
-}
-
-
-bool partition_compatible(scalarexp_t *pse, scalarexp_t *gse){
- vector<scalarexp_t *> pstack, gstack;
-
- find_colref_path(pse, pstack);
- find_colref_path(gse, gstack);
-
- int ppos=0, gpos=0;
- string p_op, g_op;
- param_int p_int, g_int;
-
- while(ppos<pstack.size()-1 && gpos<gstack.size()-1){
-
-// first, try to raise both stack pointers.
- if(ppos<pstack.size()-1 && gpos<gstack.size()-1){
- p_op = pstack[ppos+1]->get_op();
- g_op = gstack[gpos+1]->get_op();
- if(p_op==g_op){
- if(p_op=="/"){
- get_int_operand(pstack[ppos+1],pstack[ppos],p_int);
- get_int_operand(gstack[gpos+1],gstack[gpos],g_int);
- if(int_operand_divides(g_int, p_int)){
- ppos++;
- gpos++;
- continue;
- }else{
- return false;
- }
- }
- if(p_op=="&"){
- get_int_operand(pstack[ppos+1],pstack[ppos],p_int);
- get_int_operand(gstack[gpos+1],gstack[gpos],g_int);
- if(int_operand_implies(p_int, g_int)){
- ppos++;
- gpos++;
- continue;
- }else{
- return false;
- }
- }
- if(p_op=="|"){
- get_int_operand(pstack[ppos+1],pstack[ppos],p_int);
- get_int_operand(gstack[gpos+1],gstack[gpos],g_int);
- if(int_operand_implies(g_int, p_int)){
- ppos++;
- gpos++;
- continue;
- }else{
- return false;
- }
- }
- }
- }
- if(ppos<pstack.size()-1){
- p_op = pstack[ppos+1]->get_op();
- if(p_op=="+" || p_op=="-" || p_op=="*" || p_op=="/" || p_op=="&" || p_op=="|"){
- ppos++;
- continue;
- }
- }
- if(gpos<gstack.size()-1){
- g_op = gstack[gpos+1]->get_op();
- if(g_op=="+" || g_op=="-" || g_op=="*" || g_op=="/" || g_op=="&" || g_op=="|"){
- gpos++;
- continue;
- }
- }
-
- return false; // no reduction rule applies
- }
-
- return true; // reduced both stacks.
-}
-
-
-bool partn_def_t::is_compatible(gb_table *gb_tbl){
- vector<string> gb_flds;
- int i,p,g;
-
- for(i=0;i<gb_tbl->size();++i){
- string gfld;
- if(find_field(gb_tbl->get_def(i),gfld)==1){
- gb_flds.push_back(gfld);
- }else{
- gb_flds.push_back("");
- }
- }
-
- for(p=p;p<se_list.size();++p){
- for(g=0;g<gb_tbl->size();++g){
- if(partition_compatible(se_list[p], gb_tbl->get_def(g)))
- break;
- }
- if(g==gb_tbl->size()){
- return false;
- }
- }
- return true;
-}
+/* ------------------------------------------------\r
+Copyright 2014 AT&T Intellectual Property\r
+ Licensed under the Apache License, Version 2.0 (the "License");\r
+ you may not use this file except in compliance with the License.\r
+ You may obtain a copy of the License at\r
+\r
+ http://www.apache.org/licenses/LICENSE-2.0\r
+\r
+ Unless required by applicable law or agreed to in writing, software\r
+ distributed under the License is distributed on an "AS IS" BASIS,\r
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+ See the License for the specific language governing permissions and\r
+ limitations under the License.\r
+ ------------------------------------------- */\r
+#include"parse_partn.h"\r
+#include "parse_schema.h"\r
+#include"analyze_fta.h"\r
+\r
+\r
+using namespace std;\r
+\r
+\r
+int find_field(scalarexp_t *se, string &fld){\r
+ vector<scalarexp_t *> operands;\r
+ int o,ret=0;\r
+\r
+ switch(se->get_operator_type()){\r
+ case SE_LITERAL:\r
+ return 0;\r
+ case SE_PARAM:\r
+ case SE_IFACE_PARAM:\r
+ return 100; // force failure, but no error message.\r
+ case SE_UNARY_OP:\r
+ return find_field(se->get_left_se(), fld);\r
+ case SE_BINARY_OP:\r
+ return find_field(se->get_left_se(), fld)+find_field(se->get_right_se(), fld);\r
+ case SE_COLREF:\r
+ fld = se->get_colref()->get_field();\r
+ return 1;\r
+ case SE_AGGR_STAR:\r
+ case SE_AGGR_SE:\r
+// Should be no aggregates\r
+ return 0;\r
+ case SE_FUNC:\r
+ return 100; // force failure, but no error message.\r
+ default:\r
+ fprintf(stderr,"INTERNAL ERROR in find_field, unknown operator type %d\n", se->get_operator_type());\r
+ return(-100);\r
+ }\r
+ return(-100);\r
+}\r
+\r
+\r
+int partn_def_t::verify(table_list *schema, string &err_msg){\r
+ if(schema->find_tbl(protocol) < 0){\r
+ err_msg += "ERROR, partition definition "+name+" uses source "+protocol+", but its not in the schema.\n";\r
+ return 1;\r
+ }\r
+ if(schema->get_schema_type(schema->find_tbl(protocol)) != PROTOCOL_SCHEMA){\r
+ err_msg += "ERROR, partition definition "+name+" uses source "+protocol+", but its not a PROTOCOL.\n";\r
+ return 1;\r
+ }\r
+\r
+ tablevar_t *fme = new tablevar_t(protocol.c_str());\r
+ tablevar_list_t fm(fme);\r
+\r
+// Validate the SE and assign data types.\r
+ int i;\r
+ int retval = 0;\r
+ for(i=0;i<se_list.size();++i){\r
+ int ret = verify_colref(se_list[i],&fm,schema,NULL);\r
+ if(ret){\r
+ err_msg += "ERROR validating entry "+int_to_string(i)+" of partition definition "+name+".\n";\r
+ retval=1;\r
+ }\r
+ }\r
+ if(retval)\r
+ return 1;\r
+\r
+// Ensure that the data type is an integer type.\r
+ for(i=0;i<se_list.size();++i){\r
+ data_type *dt = se_list[i]->get_data_type();\r
+ string type_s = dt->get_type_str();\r
+ if(! ( type_s=="UINT" || type_s=="INT" || type_s=="ULLONG" || type_s=="LLONG") ){\r
+ err_msg += "ERROR, entry "+int_to_string(i)+" of partition definition "+name+" has type "+type_s+", but it must be one of UINT, INT, ULLONG, LLONG.\n";\r
+ retval=1;\r
+ }\r
+ }\r
+ if(retval)\r
+ return 1;\r
+\r
+// Ensure that each SE ref's a field only once.\r
+ for(i=0;i<se_list.size();++i){\r
+ string fld;\r
+ int ret = find_field(se_list[i],fld);\r
+ if(ret<0){\r
+ err_msg += "ERROR validating entry "+int_to_string(i)+" of partition definition "+name+".\n";\r
+ retval=1;\r
+ }\r
+ if(ret!=1){\r
+ err_msg += "ERROR validating entry "+int_to_string(i)+" of partition definition "+name+": the expression references a field "+int_to_string(ret)+" times, but it should reference a field exactly once.\n";\r
+ retval=1;\r
+ field_list.push_back("");\r
+ }else{\r
+ field_list.push_back(fld);\r
+ }\r
+ }\r
+ if(retval)\r
+ return 1;\r
+\r
+ return 0;\r
+\r
+}\r
+\r
+void find_colref_path(scalarexp_t *se, vector<scalarexp_t *> &se_stack){\r
+ vector<scalarexp_t *> operands;\r
+ int o,ret=0;\r
+\r
+ switch(se->get_operator_type()){\r
+ case SE_LITERAL:\r
+ case SE_PARAM:\r
+ case SE_IFACE_PARAM:\r
+ return ;\r
+ case SE_UNARY_OP:\r
+ find_colref_path(se->get_left_se(), se_stack);\r
+ if(se_stack.size()>0)\r
+ se_stack.push_back(se);\r
+ return;\r
+ case SE_BINARY_OP:\r
+ find_colref_path(se->get_left_se(), se_stack);\r
+ if(se_stack.size()>0){\r
+ se_stack.push_back(se);\r
+ return;\r
+ }\r
+ find_colref_path(se->get_right_se(), se_stack);\r
+ if(se_stack.size()>0)\r
+ se_stack.push_back(se);\r
+ return;\r
+ case SE_COLREF:\r
+ se_stack.push_back(se);\r
+ return;\r
+ case SE_AGGR_STAR:\r
+ case SE_AGGR_SE:\r
+// Should be no aggregates\r
+ return;\r
+ case SE_FUNC:\r
+ operands = se->get_operands();\r
+ for(o=0;o<operands.size();o++){\r
+ find_colref_path(operands[o], se_stack);\r
+ if(se_stack.size()>0){\r
+ se_stack.push_back(se);\r
+ return;\r
+ }\r
+ }\r
+ return;\r
+ default:\r
+ fprintf(stderr,"INTERNAL ERROR in find_colref_path, unknown operator type %d\n", se->get_operator_type());\r
+ return;\r
+ }\r
+ return;\r
+}\r
+\r
+struct param_int{\r
+ union{\r
+ long int li;\r
+ unsigned long int uli;\r
+ long long int lli;\r
+ unsigned long long int ulli;\r
+ } v;\r
+ dtype d;\r
+\r
+ void convert_to_final() {};\r
+\r
+ void load_val(dtype dt, const char *val){\r
+ d=dt;\r
+ switch(dt){\r
+ case u_int_t:\r
+ sscanf(val,"%llu",&(v.ulli));\r
+ break;\r
+ case int_t:\r
+ sscanf(val,"%lld",&(v.lli));\r
+ break;\r
+ case u_llong_t:\r
+ sscanf(val,"%llu",&(v.ulli));\r
+ break;\r
+ case llong_t:\r
+ sscanf(val,"%lld",&(v.lli));\r
+ break;\r
+ default:\r
+ fprintf(stderr,"INTERNAL ERROR, data type %d passed to param_int::load_val.\n",dt);\r
+ exit(1);\r
+ }\r
+ }\r
+\r
+ void add(dtype dt, param_int &l, param_int &r){\r
+ d=dt;\r
+ if(dt==int_t || dt==llong_t)\r
+ if(l.d==int_t || l.d==llong_t)\r
+ if(r.d==int_t || r.d==llong_t) v.lli = l.v.lli+r.v.lli; else v.lli = l.v.lli+r.v.ulli;\r
+ else\r
+ if(r.d==int_t || r.d==llong_t) v.lli = l.v.ulli+r.v.lli; else v.lli = l.v.ulli+r.v.ulli;\r
+ else\r
+ if(l.d==int_t || l.d==llong_t)\r
+ if(r.d==int_t || r.d==llong_t) v.ulli = l.v.lli+r.v.lli; else v.ulli = l.v.lli+r.v.ulli;\r
+ else\r
+ if(r.d==int_t || r.d==llong_t) v.ulli = l.v.ulli+r.v.lli; else v.ulli = l.v.ulli+r.v.ulli;\r
+ }\r
+ void subtract(dtype dt, param_int &l, param_int &r){\r
+ d=dt;\r
+ if(dt==int_t || dt==llong_t)\r
+ if(l.d==int_t || l.d==llong_t)\r
+ if(r.d==int_t || r.d==llong_t) v.lli = l.v.lli-r.v.lli; else v.lli = l.v.lli-r.v.ulli;\r
+ else\r
+ if(r.d==int_t || r.d==llong_t) v.lli = l.v.ulli-r.v.lli; else v.lli = l.v.ulli-r.v.ulli;\r
+ else\r
+ if(l.d==int_t || l.d==llong_t)\r
+ if(r.d==int_t || r.d==llong_t) v.ulli = l.v.lli-r.v.lli; else v.ulli = l.v.lli-r.v.ulli;\r
+ else\r
+ if(r.d==int_t || r.d==llong_t) v.ulli = l.v.ulli-r.v.lli; else v.ulli = l.v.ulli-r.v.ulli;\r
+ }\r
+ void mult(dtype dt, param_int &l, param_int &r){\r
+ d=dt;\r
+ if(dt==int_t || dt==llong_t)\r
+ if(l.d==int_t || l.d==llong_t)\r
+ if(r.d==int_t || r.d==llong_t) v.lli = l.v.lli*r.v.lli; else v.lli = l.v.lli*r.v.ulli;\r
+ else\r
+ if(r.d==int_t || r.d==llong_t) v.lli = l.v.ulli*r.v.lli; else v.lli = l.v.ulli*r.v.ulli;\r
+ else\r
+ if(l.d==int_t || l.d==llong_t)\r
+ if(r.d==int_t || r.d==llong_t) v.ulli = l.v.lli*r.v.lli; else v.ulli = l.v.lli*r.v.ulli;\r
+ else\r
+ if(r.d==int_t || r.d==llong_t) v.ulli = l.v.ulli*r.v.lli; else v.ulli = l.v.ulli*r.v.ulli;\r
+ }\r
+ void div(dtype dt, param_int &l, param_int &r){\r
+ d=dt;\r
+ if(dt==int_t || dt==llong_t)\r
+ if(l.d==int_t || l.d==llong_t)\r
+ if(r.d==int_t || r.d==llong_t) v.lli = l.v.lli/r.v.lli; else v.lli = l.v.lli/r.v.ulli;\r
+ else\r
+ if(r.d==int_t || r.d==llong_t) v.lli = l.v.ulli/r.v.lli; else v.lli = l.v.ulli/r.v.ulli;\r
+ else\r
+ if(l.d==int_t || l.d==llong_t)\r
+ if(r.d==int_t || r.d==llong_t) v.ulli = l.v.lli/r.v.lli; else v.ulli = l.v.lli/r.v.ulli;\r
+ else\r
+ if(r.d==int_t || r.d==llong_t) v.ulli = l.v.ulli/r.v.lli; else v.ulli = l.v.ulli/r.v.ulli;\r
+ }\r
+ void bit_and(dtype dt, param_int &l, param_int &r){\r
+ d=dt;\r
+ if(dt==int_t || dt==llong_t)\r
+ if(l.d==int_t || l.d==llong_t)\r
+ if(r.d==int_t || r.d==llong_t) v.lli = l.v.lli&r.v.lli; else v.lli = l.v.lli&r.v.ulli;\r
+ else\r
+ if(r.d==int_t || r.d==llong_t) v.lli = l.v.ulli&r.v.lli; else v.lli = l.v.ulli&r.v.ulli;\r
+ else\r
+ if(l.d==int_t || l.d==llong_t)\r
+ if(r.d==int_t || r.d==llong_t) v.ulli = l.v.lli&r.v.lli; else v.ulli = l.v.lli&r.v.ulli;\r
+ else\r
+ if(r.d==int_t || r.d==llong_t) v.ulli = l.v.ulli&r.v.lli; else v.ulli = l.v.ulli&r.v.ulli;\r
+ }\r
+ void bit_or(dtype dt, param_int &l, param_int &r){\r
+ d=dt;\r
+ if(dt==int_t || dt==llong_t)\r
+ if(l.d==int_t || l.d==llong_t)\r
+ if(r.d==int_t || r.d==llong_t) v.lli = l.v.lli|r.v.lli; else v.lli = l.v.lli|r.v.ulli;\r
+ else\r
+ if(r.d==int_t || r.d==llong_t) v.lli = l.v.ulli|r.v.lli; else v.lli = l.v.ulli|r.v.ulli;\r
+ else\r
+ if(l.d==int_t || l.d==llong_t)\r
+ if(r.d==int_t || r.d==llong_t) v.ulli = l.v.lli|r.v.lli; else v.ulli = l.v.lli|r.v.ulli;\r
+ else\r
+ if(r.d==int_t || r.d==llong_t) v.ulli = l.v.ulli|r.v.lli; else v.ulli = l.v.ulli|r.v.ulli;\r
+ }\r
+ void modulo(dtype dt, param_int &l, param_int &r){\r
+ d=dt;\r
+ if(dt==int_t || dt==llong_t)\r
+ if(l.d==int_t || l.d==llong_t)\r
+ if(r.d==int_t || r.d==llong_t) v.lli = l.v.lli%r.v.lli; else v.lli = l.v.lli%r.v.ulli;\r
+ else\r
+ if(r.d==int_t || r.d==llong_t) v.lli = l.v.ulli%r.v.lli; else v.lli = l.v.ulli%r.v.ulli;\r
+ else\r
+ if(l.d==int_t || l.d==llong_t)\r
+ if(r.d==int_t || r.d==llong_t) v.ulli = l.v.lli%r.v.lli; else v.ulli = l.v.lli%r.v.ulli;\r
+ else\r
+ if(r.d==int_t || r.d==llong_t) v.ulli = l.v.ulli%r.v.lli; else v.ulli = l.v.ulli%r.v.ulli;\r
+ }\r
+ void shift_left(dtype dt, param_int &l, param_int &r){\r
+ d=dt;\r
+ if(dt==int_t || dt==llong_t)\r
+ if(l.d==int_t || l.d==llong_t)\r
+ if(r.d==int_t || r.d==llong_t) v.lli = l.v.lli<<r.v.lli; else v.lli = l.v.lli<<r.v.ulli;\r
+ else\r
+ if(r.d==int_t || r.d==llong_t) v.lli = l.v.ulli<<r.v.lli; else v.lli = l.v.ulli<<r.v.ulli;\r
+ else\r
+ if(l.d==int_t || l.d==llong_t)\r
+ if(r.d==int_t || r.d==llong_t) v.ulli = l.v.lli<<r.v.lli; else v.ulli = l.v.lli<<r.v.ulli;\r
+ else\r
+ if(r.d==int_t || r.d==llong_t) v.ulli = l.v.ulli<<r.v.lli; else v.ulli = l.v.ulli<<r.v.ulli;\r
+ }\r
+ void shift_right(dtype dt, param_int &l, param_int &r){\r
+ d=dt;\r
+ if(dt==int_t || dt==llong_t)\r
+ if(l.d==int_t || l.d==llong_t)\r
+ if(r.d==int_t || r.d==llong_t) v.lli = l.v.lli>>r.v.lli; else v.lli = l.v.lli>>r.v.ulli;\r
+ else\r
+ if(r.d==int_t || r.d==llong_t) v.lli = l.v.ulli>>r.v.lli; else v.lli = l.v.ulli>>r.v.ulli;\r
+ else\r
+ if(l.d==int_t || l.d==llong_t)\r
+ if(r.d==int_t || r.d==llong_t) v.ulli = l.v.lli>>r.v.lli; else v.ulli = l.v.lli>>r.v.ulli;\r
+ else\r
+ if(r.d==int_t || r.d==llong_t) v.ulli = l.v.ulli>>r.v.lli; else v.ulli = l.v.ulli>>r.v.ulli;\r
+ }\r
+\r
+ void plus(dtype dt, param_int &l){\r
+ d=dt;\r
+ if(dt==int_t || dt==llong_t)\r
+ if(l.d==int_t || l.d==llong_t)\r
+ v.lli = l.v.ulli;\r
+ else\r
+ v.lli = l.v.lli;\r
+ else\r
+ if(l.d==int_t || l.d==llong_t)\r
+ v.ulli = l.v.ulli;\r
+ else\r
+ v.ulli = l.v.lli;\r
+ }\r
+ void minus(dtype dt, param_int &l){\r
+ d=dt;\r
+ if(dt==int_t || dt==llong_t)\r
+ if(l.d==int_t || l.d==llong_t)\r
+ v.lli = -l.v.ulli;\r
+ else\r
+ v.lli = -l.v.lli;\r
+ else\r
+ if(l.d==int_t || l.d==llong_t)\r
+ v.ulli = -l.v.ulli;\r
+ else\r
+ v.ulli = -l.v.lli;\r
+ }\r
+ void abs_not(dtype dt, param_int &l){\r
+ d=dt;\r
+ if(dt==int_t || dt==llong_t)\r
+ if(l.d==int_t || l.d==llong_t)\r
+ v.lli = !l.v.ulli;\r
+ else\r
+ v.lli = !l.v.lli;\r
+ else\r
+ if(l.d==int_t || l.d==llong_t)\r
+ v.ulli = !l.v.ulli;\r
+ else\r
+ v.ulli = !l.v.lli;\r
+ }\r
+ void bit_not(dtype dt, param_int &l){\r
+ d=dt;\r
+ if(dt==int_t || dt==llong_t)\r
+ if(l.d==int_t || l.d==llong_t)\r
+ v.lli = ~l.v.ulli;\r
+ else\r
+ v.lli = ~l.v.lli;\r
+ else\r
+ if(l.d==int_t || l.d==llong_t)\r
+ v.ulli = ~l.v.ulli;\r
+ else\r
+ v.ulli = ~l.v.lli;\r
+ }\r
+};\r
+\r
+\r
+bool int_operand_divides(param_int &lp, param_int &rp){\r
+ if( (lp.d==int_t || lp.d==llong_t)){\r
+ if(lp.v.lli < 0)\r
+ lp.v.ulli = -lp.v.lli;\r
+ else\r
+ lp.v.ulli = lp.v.lli;\r
+ }\r
+ if( (rp.d==int_t || rp.d==llong_t)){\r
+ if(rp.v.lli < 0)\r
+ rp.v.ulli = -rp.v.lli;\r
+ else\r
+ rp.v.ulli = rp.v.lli;\r
+ }\r
+ unsigned long long int d = rp.v.ulli / lp.v.ulli;\r
+ unsigned long long int r = rp.v.ulli - d * lp.v.ulli;\r
+ return d==0;\r
+}\r
+\r
+bool int_operand_implies(param_int &lp, param_int &rp){\r
+ unsigned long long int d = (lp.v.ulli & rp.v.ulli) | (!lp.v.ulli);\r
+ return (~d)==0;\r
+}\r
+\r
+\r
+\r
+\r
+void extract_param_int(scalarexp_t *se, param_int &p_int) {\r
+param_int lp, rp;\r
+string op_str;\r
+dtype dt = se->get_data_type()->get_type();\r
+ switch(se->get_operator_type()){\r
+ case SE_LITERAL:\r
+ p_int.load_val(se->get_data_type()->get_type(),se->to_string().c_str());\r
+ return;\r
+ case SE_UNARY_OP:\r
+ extract_param_int(se->get_left_se(), lp);\r
+ op_str = se->get_op();\r
+ if(op_str=="+") p_int.plus(dt,lp);\r
+ if(op_str=="-") p_int.minus(dt,lp);\r
+ if(op_str=="!") p_int.abs_not(dt,lp);\r
+ if(op_str=="~") p_int.bit_not(dt,lp);\r
+ return;\r
+ case SE_BINARY_OP:\r
+ extract_param_int(se->get_left_se(), lp);\r
+ extract_param_int(se->get_right_se(), rp);\r
+ op_str = se->get_op();\r
+ if(op_str=="+") p_int.add(dt,lp,rp);\r
+ if(op_str=="-") p_int.subtract(dt,lp,rp);\r
+ if(op_str=="*") p_int.mult(dt,lp,rp);\r
+ if(op_str=="/") p_int.div(dt,lp,rp);\r
+ if(op_str=="&") p_int.bit_and(dt,lp,rp);\r
+ if(op_str=="|") p_int.bit_or(dt,lp,rp);\r
+ if(op_str=="%") p_int.modulo(dt,lp,rp);\r
+ if(op_str=="<<") p_int.shift_left(dt,lp,rp);\r
+ if(op_str==">>") p_int.shift_right(dt,lp,rp);\r
+ return;\r
+ default:\r
+ fprintf(stderr,"INTERNAL ERROR in find_field, invalid operator type %d\n", se->get_operator_type());\r
+ exit(1);\r
+ }\r
+ return;\r
+\r
+}\r
+\r
+\r
+void get_int_operand(scalarexp_t *parent, scalarexp_t *child, param_int &p_int){\r
+ if(parent->get_operator_type() != SE_BINARY_OP){\r
+ fprintf(stderr,"INTERNAL ERROR, operator type %d in get_int_operand.\n",\r
+parent->get_operator_type());\r
+ exit(1);\r
+ }\r
+ if(parent->get_right_se() == child){\r
+ extract_param_int(parent->get_left_se(), p_int);\r
+ p_int.convert_to_final();\r
+ }else{\r
+ extract_param_int(parent->get_right_se(), p_int);\r
+ p_int.convert_to_final();\r
+ }\r
+}\r
+\r
+\r
+bool partition_compatible(scalarexp_t *pse, scalarexp_t *gse){\r
+ vector<scalarexp_t *> pstack, gstack;\r
+\r
+ find_colref_path(pse, pstack);\r
+ find_colref_path(gse, gstack);\r
+\r
+ int ppos=0, gpos=0;\r
+ string p_op, g_op;\r
+ param_int p_int, g_int;\r
+\r
+ while(ppos<pstack.size()-1 && gpos<gstack.size()-1){\r
+\r
+// first, try to raise both stack pointers.\r
+ if(ppos<pstack.size()-1 && gpos<gstack.size()-1){\r
+ p_op = pstack[ppos+1]->get_op();\r
+ g_op = gstack[gpos+1]->get_op();\r
+ if(p_op==g_op){\r
+ if(p_op=="/"){\r
+ get_int_operand(pstack[ppos+1],pstack[ppos],p_int);\r
+ get_int_operand(gstack[gpos+1],gstack[gpos],g_int);\r
+ if(int_operand_divides(g_int, p_int)){\r
+ ppos++;\r
+ gpos++;\r
+ continue;\r
+ }else{\r
+ return false;\r
+ }\r
+ }\r
+ if(p_op=="&"){\r
+ get_int_operand(pstack[ppos+1],pstack[ppos],p_int);\r
+ get_int_operand(gstack[gpos+1],gstack[gpos],g_int);\r
+ if(int_operand_implies(p_int, g_int)){\r
+ ppos++;\r
+ gpos++;\r
+ continue;\r
+ }else{\r
+ return false;\r
+ }\r
+ }\r
+ if(p_op=="|"){\r
+ get_int_operand(pstack[ppos+1],pstack[ppos],p_int);\r
+ get_int_operand(gstack[gpos+1],gstack[gpos],g_int);\r
+ if(int_operand_implies(g_int, p_int)){\r
+ ppos++;\r
+ gpos++;\r
+ continue;\r
+ }else{\r
+ return false;\r
+ }\r
+ }\r
+ }\r
+ }\r
+ if(ppos<pstack.size()-1){\r
+ p_op = pstack[ppos+1]->get_op();\r
+ if(p_op=="+" || p_op=="-" || p_op=="*" || p_op=="/" || p_op=="&" || p_op=="|"){\r
+ ppos++;\r
+ continue;\r
+ }\r
+ }\r
+ if(gpos<gstack.size()-1){\r
+ g_op = gstack[gpos+1]->get_op();\r
+ if(g_op=="+" || g_op=="-" || g_op=="*" || g_op=="/" || g_op=="&" || g_op=="|"){\r
+ gpos++;\r
+ continue;\r
+ }\r
+ }\r
+\r
+ return false; // no reduction rule applies\r
+ }\r
+\r
+ return true; // reduced both stacks.\r
+}\r
+\r
+\r
+bool partn_def_t::is_compatible(gb_table *gb_tbl){\r
+ vector<string> gb_flds;\r
+ int i,p,g;\r
+\r
+ for(i=0;i<gb_tbl->size();++i){\r
+ string gfld;\r
+ if(find_field(gb_tbl->get_def(i),gfld)==1){\r
+ gb_flds.push_back(gfld);\r
+ }else{\r
+ gb_flds.push_back("");\r
+ }\r
+ }\r
+\r
+ for(p=p;p<se_list.size();++p){\r
+ for(g=0;g<gb_tbl->size();++g){\r
+ if(partition_compatible(se_list[p], gb_tbl->get_def(g)))\r
+ break;\r
+ }\r
+ if(g==gb_tbl->size()){\r
+ return false;\r
+ }\r
+ }\r
+ return true;\r
+}\r
Code Review / com / gs-lite.git / blobdiff