/*-----------------------------------------------------------------------------
*
* ID: var_checkadd 07.11.06 0.0.A.
*
* Summary: Проверка локальной переменной на наличие и добавление в таблицу
*
-----------------------------------------------------------------------------*/
uint STDCALL var_checkadd( ps_descid descvar )
{
uint oldoffbvar; // Предыдущее смещение локальной переменной
uint offbvar; // Смещение локальной переменной в таблице
uint num; // Номер локальной переменной
pfvar var; // Указатель на структуру локальной переменной
phashiuint phitem;//Элемент хэштаблицы с локальной переменной
//Поиск в таблице имён если нет добавляем
phitem = (phashiuint)hash_create( &fd.nvars, descvar->name);
//Получение номера переменной если есть
oldoffbvar = phitem->val;
//Если переменная есть и она в текущем блоке, то ошибка
if ( oldoffbvar && oldoffbvar >= fd.oldoffbvar )
msg( MDblname | MSG_LEXNAMEERR, descvar->lex );//Ошибка Идентификатор с таким именем уже есть
//Запись в таблицу смещения новой переменной
phitem->val = offbvar = fd.bvars.use;
//Вызов функции добавления
num = var_add( phitem, descvar );
//Запись дополнительной информации
var = ( pfvar )( fd.bvars.data + offbvar );
if ( oldoffbvar )
{
var->oldoffbvar = oldoffbvar;
}
return num;
}
/*在运行时解析节点的加法运算*/
static void rt_eval_plus ( IL_node *tmp )
{
Var *value_a, * value_b;
/*根据栈中的函数调用情况获取栈中绝对定位下的变量*/
value_a=IL_rt_Evaluate ( tmp->exp->A );
value_b=IL_rt_Evaluate ( tmp->exp->B );
last_tmp_value=var_add ( *value_a,*value_b );
set_tmp(tmp->tmp_index,&last_tmp_value,TMP_ARITH);
}
/*-----------------------------------------------------------------------------
*
* ID: var_addtmp 07.11.06 0.0.A.
*
* Summary: Добавить локальную переменную не имеющую имени
*
-----------------------------------------------------------------------------*/
uint STDCALL var_addtmp( uint type, uint oftype )
{
s_descid descvar;
descvar.oftype = oftype;
descvar.idtype = type;
descvar.flgdesc = DESCID_VAR;
descvar.name = 0;
return var_add( 0, &descvar );
}
static void exec_prefix(char **prefix, int glob)
{
char *value;
assert(prefix);
for (int i = 0; prefix[i]; ++i) {
if (!(value = strchr(prefix[i], '=')))
assert(0);
*value = 0;
if (glob || getenv(prefix[i]) != NULL)
setenv2(prefix[i], value + 1, !0);
else
var_add(shell->var, prefix[i], value + 1);
*value = '=';
}
}
/**
@details
Send mtv event data through the variable server.
-# For each event in the mtv_list
-# call var_add() for all the event information
-# Send the size of list of variables we've added
-# Send the data
-# Clear the var_add list.
*/
int Trick::MTV::send_event_data() {
char varname[80];
const char *mtv_name = "trick_ip.mtv.mtv_list";
unsigned int ii ;
int jj;
for (ii=0; ii < mtv_count; ii++) {
sprintf(varname, "%s[%d][0].name", mtv_name,ii);
var_add(varname);
sprintf(varname, "%s[%d][0].active", mtv_name,ii);
var_add(varname);
sprintf(varname, "%s[%d][0].added", mtv_name,ii);
var_add(varname);
sprintf(varname, "%s[%d][0].condition_count", mtv_name,ii);
var_add(varname);
sprintf(varname, "%s[%d][0].action_count", mtv_name,ii);
var_add(varname);
sprintf(varname, "%s[%d][0].before_after", mtv_name,ii);
var_add(varname);
for (jj=0; jj< mtv_list[ii]->condition_count; jj++) {
sprintf(varname, "%s[%d][0].cond[%d].comment", mtv_name,ii,jj);
var_add(varname);
}
for (jj=0; jj< mtv_list[ii]->action_count; jj++) {
sprintf(varname, "%s[%d][0].act[%d].comment", mtv_name,ii,jj);
var_add(varname);
}
if (mtv_list[ii]->get_before_after() > 0) {
sprintf(varname, "%s[%d][0].target_name", mtv_name,ii);
var_add(varname);
}
}
var_send_list_size() ;
var_send() ;
var_clear() ;
return 0 ;
}
static Var assign_get(Var a,Var b,int mode)
{
switch(mode)
{
case '=':
return b;
break;
case OP_ASSIGN_PLUS:
return var_add(a,b);
break;
case OP_ASSIGN_DIVIDE:
return var_divide(a,b);
break;
case OP_ASSIGN_MINUS:
return var_minus(a,b);
break;
case OP_ASSIGN_MULTIPLE:
return var_multiple(a,b);
break;
}
}
static int operate(struct _var *var_d, struct _var *var_s, struct _operator *operator)
{
#ifdef DEBUG
printf(">>> OPERATING ON %d/%f/%d (%d) %d/%f/%d\n",
var_get_int32(var_d), var_get_float(var_d), var_get_type(var_d),
operator->operation,
var_get_int32(var_s), var_get_float(var_s), var_get_type(var_s));
#endif
switch(operator->operation)
{
case OPER_NOT:
return var_not(var_d);
case OPER_MUL:
return var_mul(var_d, var_s);
case OPER_DIV:
return var_div(var_d, var_s);
case OPER_MOD:
return var_mod(var_d, var_s);
case OPER_PLUS:
return var_add(var_d, var_s);
case OPER_MINUS:
return var_sub(var_d, var_s);
case OPER_LEFT_SHIFT:
return var_shift_left(var_d, var_s);
case OPER_RIGHT_SHIFT:
return var_shift_right(var_d, var_s);
case OPER_AND:
return var_and(var_d, var_s);
case OPER_XOR:
return var_xor(var_d, var_s);
case OPER_OR:
return var_or(var_d, var_s);
default:
printf("Internal Error: WTF, bad operator %d\n", operator->operation);
return 0;
}
}
int Trick::VariableServerThread::var_add(std::string var_name, std::string units_name) {
var_add(var_name) ;
var_units(var_name, units_name) ;
return(0) ;
}
void StreamVm::build_flow_var_table() {
var_clear_table();
m_cur_var_offset=0;
uint32_t ins_id=0;
/* scan all flow var instruction and build */
/* if we found allocate BSS +4 bytes */
if ( m_is_random_var ){
VmFlowVarRec var;
var.m_offset = m_cur_var_offset;
var.m_ins.m_ins_flowv = NULL;
var.m_size_bytes = sizeof(uint32_t);
var_add("___random___",var);
m_cur_var_offset += sizeof(uint32_t);
}
for (auto inst : m_inst_list) {
if ( inst->get_instruction_type() == StreamVmInstruction::itFLOW_MAN ){
StreamVmInstructionFlowMan * ins_man=(StreamVmInstructionFlowMan *)inst;
/* check that instruction is valid */
ins_man->sanity_check(ins_id,this);
VmFlowVarRec var;
/* if this is the first time */
if ( var_lookup( ins_man->m_var_name,var) == true){
std::stringstream ss;
ss << "instruction id '" << ins_id << "' flow variable name " << ins_man->m_var_name << " already exists";
err(ss.str());
}else{
var.m_offset=m_cur_var_offset;
var.m_ins.m_ins_flowv = ins_man;
var.m_size_bytes = ins_man->m_size_bytes;
var_add(ins_man->m_var_name,var);
m_cur_var_offset += ins_man->m_size_bytes;
}
}
if ( inst->get_instruction_type() == StreamVmInstruction::itFLOW_CLIENT ){
StreamVmInstructionFlowClient * ins_man=(StreamVmInstructionFlowClient *)inst;
VmFlowVarRec var;
/* if this is the first time */
if ( var_lookup( ins_man->m_var_name+".ip",var) == true){
std::stringstream ss;
ss << "instruction id '" << ins_id << "' client variable name " << ins_man->m_var_name << " already exists";
err(ss.str());
}
if ( var_lookup( ins_man->m_var_name+".port",var) == true){
std::stringstream ss;
ss << "instruction id '" << ins_id << "' client variable name " << ins_man->m_var_name << " already exists";
err(ss.str());
}
if ( var_lookup( ins_man->m_var_name+".flow_limit",var) == true){
std::stringstream ss;
ss << "instruction id '" << ins_id << "' client variable name " << ins_man->m_var_name << " already exists";
err(ss.str());
}
var.m_offset = m_cur_var_offset;
var.m_ins.m_ins_flow_client = ins_man;
var.m_size_bytes =4;
VmFlowVarRec var_port;
var_port.m_offset = m_cur_var_offset+4;
var_port.m_ins.m_ins_flow_client = ins_man;
var_port.m_size_bytes =2;
VmFlowVarRec var_flow_limit;
var_flow_limit.m_offset = m_cur_var_offset+6;
var_flow_limit.m_ins.m_ins_flow_client = ins_man;
var_flow_limit.m_size_bytes =4;
var_add(ins_man->m_var_name+".ip",var);
var_add(ins_man->m_var_name+".port",var_port);
var_add(ins_man->m_var_name+".flow_limit",var_flow_limit);
m_cur_var_offset += StreamVmInstructionFlowClient::get_flow_var_size();
assert(sizeof(StreamDPFlowClient)==StreamVmInstructionFlowClient::get_flow_var_size());
}
/* limit the flow var size */
if (m_cur_var_offset > StreamVm::svMAX_FLOW_VAR ) {
std::stringstream ss;
ss << "too many flow varibles current size is :" << m_cur_var_offset << " maximum support is " << StreamVm::svMAX_FLOW_VAR;
err(ss.str());
}
ins_id++;
}
ins_id=0;
/* second interation for sanity check and fixups*/
for (auto inst : m_inst_list) {
if (inst->get_instruction_type() == StreamVmInstruction::itPKT_SIZE_CHANGE ) {
StreamVmInstructionChangePktSize *lpPkt =(StreamVmInstructionChangePktSize *)inst;
VmFlowVarRec var;
if ( var_lookup(lpPkt->m_flow_var_name ,var) == false){
std::stringstream ss;
ss << "instruction id '" << ins_id << "' packet size with no valid flow varible name '" << lpPkt->m_flow_var_name << "'" ;
err(ss.str());
}
if ( var.m_size_bytes != 2 ) {
std::stringstream ss;
ss << "instruction id '" << ins_id << "' packet size change should point to a flow varible with size 2 ";
err(ss.str());
}
if ( var.m_ins.m_ins_flowv->m_max_value > m_pkt_size) {
var.m_ins.m_ins_flowv->m_max_value =m_pkt_size;
}
if (var.m_ins.m_ins_flowv->m_min_value > m_pkt_size) {
var.m_ins.m_ins_flowv->m_min_value = m_pkt_size;
}
if ( var.m_ins.m_ins_flowv->m_min_value >= var.m_ins.m_ins_flowv->m_max_value ) {
std::stringstream ss;
ss << "instruction id '" << ins_id << "' min packet size " << var.m_ins.m_ins_flowv->m_min_value << " is bigger or eq to max packet size " << var.m_ins.m_ins_flowv->m_max_value;
err(ss.str());
}
if ( var.m_ins.m_ins_flowv->m_min_value < 60) {
var.m_ins.m_ins_flowv->m_min_value =60;
}
m_expected_pkt_size = (var.m_ins.m_ins_flowv->m_min_value + var.m_ins.m_ins_flowv->m_max_value) / 2;
}
}/* for */
}
