const char* var2str(const anon_nasl_var* v) { static char s1[16]; if (v == NULL) return NULL; switch (v->var_type) { case VAR2_INT: snprintf(s1, sizeof(s1), "%d", v->v.v_int); return s1; /* buggy if called twice in a row */ case VAR2_STRING: case VAR2_DATA: return v->v.v_str.s_val == NULL ? "" : (const char*)v->v.v_str.s_val; case VAR2_UNDEF: #if NASL_DEBUG > 1 nasl_perror(NULL, "var2str: variable %s is undefined!\n", get_var_name(v)); #endif return NULL; case VAR2_ARRAY: return array2str(&v->v.v_arr); default: #if NASL_DEBUG > 0 nasl_perror(NULL, "var2str: variable %s has unhandled type %d\n", get_var_name(v), v->var_type); #endif return ""; } }
static int var2int(anon_nasl_var* v, int defval) { if (v == NULL) return defval; switch (v->var_type) { case VAR2_INT: return v->v.v_int; case VAR2_STRING: case VAR2_DATA: return atoi(v->v.v_str.s_val); case VAR2_UNDEF: #if NASL_DEBUG > 1 nasl_perror(NULL, "var2int: variable %s is undefined!\n", get_var_name(v)); #endif case VAR2_ARRAY: default: return defval; } /*NOTREACHED*/ }
/*! * \brief Handles the SOAP requests to querry the state variables. * This functionality has been deprecated in the UPnP V1.0 architecture. */ static UPNP_INLINE void handle_query_variable( IN SOCKINFO *info, IN http_message_t *request, IN IXML_Document *xml_doc) { UpnpStateVarRequest *variable = UpnpStateVarRequest_new(); Upnp_FunPtr soap_event_callback; void *cookie; char var_name[LINE_SIZE]; const char *err_str; int err_code; if (get_var_name(xml_doc, var_name) != 0) { send_error_response(info, SOAP_INVALID_VAR, Soap_Invalid_Var, request); return; } /* get info for event */ err_code = get_device_info(request, 1, xml_doc, info->foreign_sockaddr.ss_family, (UpnpString *)UpnpStateVarRequest_get_DevUDN(variable), (UpnpString *)UpnpStateVarRequest_get_ServiceID(variable), &soap_event_callback, &cookie); if (err_code != 0) { send_error_response(info, SOAP_INVALID_VAR, Soap_Invalid_Var, request); return; } UpnpStateVarRequest_set_ErrCode(variable, UPNP_E_SUCCESS); UpnpStateVarRequest_strcpy_StateVarName(variable, var_name); UpnpStateVarRequest_set_CtrlPtIPAddr(variable, &info->foreign_sockaddr); /* send event */ soap_event_callback(UPNP_CONTROL_GET_VAR_REQUEST, variable, cookie); UpnpPrintf(UPNP_INFO, SOAP, __FILE__, __LINE__, "Return from callback for var request\n"); /* validate, and handle result */ if (UpnpStateVarRequest_get_CurrentVal(variable) == NULL) { err_code = SOAP_ACTION_FAILED; err_str = Soap_Action_Failed; send_error_response(info, SOAP_INVALID_VAR, Soap_Invalid_Var, request); return; } if (UpnpStateVarRequest_get_ErrCode(variable) != UPNP_E_SUCCESS) { if (UpnpString_get_Length(UpnpStateVarRequest_get_ErrStr(variable)) > 0) { err_code = SOAP_INVALID_VAR; err_str = Soap_Invalid_Var; } else { err_code = UpnpStateVarRequest_get_ErrCode(variable); err_str = UpnpStateVarRequest_get_ErrStr_cstr(variable); } send_error_response(info, err_code, err_str, request); return; } /* send response */ send_var_query_response(info, UpnpStateVarRequest_get_CurrentVal(variable), request); UpnpStateVarRequest_delete(variable); }
TString get_full_name(TString name, TString prefix) { TString sample = get_sample_name(name); TString sys = get_sys_name(name); TString var = get_var_name(name); TString res(prefix.Data()); //res.Append("__" + sample + "__" + sys + "__" + var); // only for sytematics res.Append("__" + sample); //cout << "sample name = " << sample << " sys = " << sys << " var = " << var << endl; return res; }
void EffectConstant::save_xml(const XmlWriterSharedPtr &writer) const { writer->start_element(String(UTF8("effect_constant"))); EffectNode::save_xml(writer); writer->write_vec4_element(String(UTF8("value")), get_value()); writer->write_element(String(UTF8("var_name")), get_var_name()); writer->write_element(String(UTF8("type")), EffectConstantUtil::get_str(get_type())); writer->end_element(); }
void sccwriter::write_expr( Expr* code, std::ostream& os, int ind, std::string& expr, int opts ) { if( code->getclass()==SYMS_EXPR && is_var( ((SymSExpr*)code)->s ) ) { get_var_name( ((SymSExpr*)code)->s, expr ); indent( os, ind ); os << expr.c_str() << "->inc();" << std::endl; } else { std::ostringstream ss; ss << "e" << exprCount; exprCount++; //declare the expression indent( os, ind ); if( code->getclass()==SYMS_EXPR && !is_var( ((SymSExpr*)code)->s ) ) { os << "static "; } os << "Expr* " << ss.str().c_str() << ";" << std::endl; //write the expression std::ostringstream ss2; ss2 << ss.str().c_str(); write_code( code, os, ind, ss2.str().c_str(), opts ); //if is not a sym expression, then decrement the expression and return null if( opts&opt_write_check_sym_expr ) { indent( os, ind ); os << "if (" << expr.c_str() << "->getclass() != SYM_EXPR) {" << std::endl; indent( os, ind+1 ); os << "exit( 1 );" << std::endl; indent( os, ind ); os << "}" << std::endl; } expr = std::string( ss.str().c_str() ); vars.push_back( expr ); } //increment the counter for memory management //indent( os, ind ); //os << expr.c_str() << "->inc();" << std::endl; }
EffectConstant::EffectConstant(const String &name, const Uint32 id, const EffectConstantType type, Mt19937RandomUuidGenerator &uuid_generator): EffectNode(name, id, uuid_generator()), m_value(0.0f, 0.0f, 0.0f, 1.0f), m_type(type) { m_var_name = get_var_name(); switch (get_type()) { case ect_float: add_output_port(m_var_name, String(), String(UTF8("?")), uuid_generator(), ect_constant); break; case ect_direction_xy: add_output_port(m_var_name, String(UTF8("xy")), uuid_generator(),ect_constant); break; case ect_color_rgb: add_output_port(m_var_name, String(UTF8("rgb")), uuid_generator(), ect_constant); break; case ect_vec2: add_output_port(m_var_name, String(UTF8("xy")), uuid_generator(),ect_constant); break; case ect_vec3: add_output_port(m_var_name, String(UTF8("xyz")), uuid_generator(), ect_constant); break; case ect_vec4: add_output_port(m_var_name, String(UTF8("xyzw")), uuid_generator(), ect_constant); break; } }
/*! * \brief Handles the SOAP requests to querry the state variables. * This functionality has been deprecated in the UPnP V1.0 architecture. */ static UPNP_INLINE void handle_query_variable( int iface, /*! [in] Socket info. */ SOCKINFO *info, /*! [in] HTTP request. */ http_message_t *request, /*! [in] Document containing the variable request SOAP message. */ IXML_Document *xml_doc) { Upnp_FunPtr soap_event_callback; void *cookie; char var_name[LINE_SIZE]; struct Upnp_State_Var_Request variable; const char *err_str; int err_code; /* get var name */ if (get_var_name(xml_doc, var_name) != 0) { send_error_response(info, SOAP_INVALID_VAR, Soap_Invalid_Var, request); return; } /* get info for event */ err_code = get_device_info(iface, request, 1, xml_doc, info->foreign_sockaddr.ss_family, variable.DevUDN, variable.ServiceID, &soap_event_callback, &cookie); if (err_code != 0) { send_error_response(info, SOAP_INVALID_VAR, Soap_Invalid_Var, request); return; } linecopy(variable.ErrStr, ""); variable.ErrCode = UPNP_E_SUCCESS; namecopy(variable.StateVarName, var_name); variable.CurrentVal = NULL; variable.CtrlPtIPAddr = info->foreign_sockaddr; /* send event */ soap_event_callback(UPNP_CONTROL_GET_VAR_REQUEST, &variable, cookie); UpnpPrintf(UPNP_INFO, SOAP, __FILE__, __LINE__, "Return from callback for var request\n"); /* validate, and handle result */ if (variable.CurrentVal == NULL) { send_error_response(info, SOAP_INVALID_VAR, Soap_Invalid_Var, request); return; } if (variable.ErrCode != UPNP_E_SUCCESS) { if (strlen(variable.ErrStr) > 0) { err_code = SOAP_INVALID_VAR; err_str = Soap_Invalid_Var; } else { err_code = variable.ErrCode; err_str = variable.ErrStr; } send_error_response(info, err_code, err_str, request); return; } /* send response */ send_var_query_response(info, variable.CurrentVal, request); ixmlFreeDOMString(variable.CurrentVal); }
void sccwriter::write_code( Expr* code, std::ostream& os, int ind, const char* retModStr, int opts ) { std::string retModString; std::string incString; if ( retModStr ) { retModString = std::string( retModStr ); retModString.append( " = " ); incString = std::string( retModStr ); incString.append( "->inc();" ); } switch( code->getclass() ) { case INT_EXPR: { indent( os, ind ); os << retModString.c_str(); os << "new IntExpr( " << mpz_get_si( ((IntExpr*)code)->n ) << " );" << std::endl; indent( os, ind ); os << incString.c_str() << std::endl; } break; case RAT_EXPR: { mpz_t num, den; mpz_init(num); mpz_init(den); mpq_get_num( num, ((RatExpr*)code)->n ); mpq_get_den( den, ((RatExpr*)code)->n ); indent( os, ind ); os << retModString.c_str(); os << "new RatExpr( " << mpz_get_si( num ) << ", " << mpz_get_si( den ) << " );" << std::endl; indent( os, ind ); os << incString.c_str() << std::endl; } break; case SYMS_EXPR: { //if it is a variable, simply write it to buffer if( is_var( ((SymSExpr*)code)->s ) ) { indent( os, ind ); os << retModString.c_str(); write_variable( ((SymSExpr*)code)->s.c_str(), os ); os << ";" << std::endl; } else //else must look at symbol lookup table { std::string var; get_var_name( ((SymSExpr*)code)->s, var ); indent( os, ind ); os << retModString.c_str() << "e_" << var.c_str() << ";" << std::endl; add_global_sym( var ); } indent( os, ind ); os << incString.c_str() << std::endl; } break; default: switch( code->getop() ) { case APP: { //collect the arguments std::vector< Expr* > argVector; code->collect_args( argVector ); //write the arguments std::vector< std::string > args; for( int a=0; a<(int)argVector.size(); a++ ) { std::string expr; write_expr( argVector[a], os, ind, expr ); args.push_back( expr ); } //write_args( (CExpr*)code, os, ind, 1, args ); Expr* hd = code->get_head(); //map to a program in the case that it is a program if( hd->getop()==PROG && get_prog_index_by_expr( hd )!=-1 ) { indent( os, ind ); os << retModString << "f_" << progNames[ get_prog_index_by_expr( hd ) ].c_str() << "( "; for( int a=0; a<(int)args.size(); a++ ) { os << args[a].c_str(); if( a!=(int)( args.size()-1 ) ){ os << ", "; } } os << " );" << std::endl; for( int a=0; a<(int)args.size(); a++ ) { write_dec( args[a], os, ind ); } } else { #ifdef USE_FLAT_APP std::string expr; write_expr( hd, os, ind, expr ); indent( os, ind ); os << retModString << "new CExpr( APP, "; os << expr.c_str() << ", "; for( int a=0; a<(int)args.size(); a++ ) { os << args[a].c_str(); if( a!=(int)( args.size()-1 ) ){ os << ", "; } } os << " );" << std::endl; #else std::string expr; write_expr( hd, os, ind, expr ); indent( os, ind ); os << retModString; for( int a=0; a<(int)args.size(); a++ ) { os << "new CExpr( APP, "; } os << expr.c_str() << ", "; for( int a=0; a<(int)args.size(); a++ ) { os << args[a].c_str(); os << " )"; if( a!=(int)( args.size()-1 ) ){ os << ", "; } } os << ";" << std::endl; #endif //indent( os, ind ); //os << expr.c_str() << "->dec();" << std::endl; } } break; case MATCH: { //calculate the value for the expression std::string expr; write_expr( ((CExpr*)code)->kids[0], os, ind, expr ); //get the head std::ostringstream sshd; sshd << "e" << exprCount; exprCount++; indent( os, ind ); os << "Expr* " << sshd.str().c_str() << " = " << expr.c_str() << "->followDefs()->get_head();" << std::endl; //write the arguments std::vector< std::string > args; write_args( (CExpr*)code, os, ind, 1, args ); bool encounterDefault = false; //now make an if statement corresponding to the match int a = 0; while( ((CExpr*)code)->kids[a+1] ) { indent( os, ind ); if( a!=0 ){ os << "}else"; } if( ((CExpr*)code)->kids[a+1]->getop()!=CASE ){ encounterDefault = true; os << "{" << std::endl; //write the body of the case write_code( ((CExpr*)code)->kids[a+1], os, ind+1, retModStr ); indent( os, ind ); os << "}" << std::endl; }else{ if( a!=0 ) os << " "; os << "if( " << sshd.str().c_str() << "==" << args[a].c_str() << " ){" << std::endl; //collect args from the variable in the code std::ostringstream ssargs; ssargs << "args" << argsCount; argsCount++; #ifndef USE_FLAT_APP indent( os, ind+1 ); os << "std::vector< Expr* > " << ssargs.str().c_str() << ";" << std::endl; indent( os, ind+1 ); os << expr.c_str() << "->followDefs()->collect_args( " << ssargs.str().c_str() << " );" << std::endl; #endif //set the variables defined in the pattern equal to the arguments std::vector< Expr* > caseArgs; ((CExpr*)((CExpr*)code)->kids[a+1])->kids[0]->collect_args( caseArgs ); for( int b=0; b<(int)caseArgs.size(); b++ ) { indent( os, ind+1 ); os << "Expr* "; write_variable( ((SymSExpr*)caseArgs[b])->s.c_str(), os ); #ifdef USE_FLAT_APP os << " = ((CExpr*)" << expr.c_str() << "->followDefs())->kids[" << b+1 << "];" << std::endl; #else os << " = " << ssargs.str().c_str() << "[" << b << "];" << std::endl; #endif vars.push_back( ((SymSExpr*)caseArgs[b])->s ); } //write the body of the case write_code( ((CExpr*)code)->kids[a+1], os, ind+1, retModStr, opt_write_case_body ); } a++; } if( !encounterDefault ) { indent( os, ind ); os << "}else{" << std::endl; indent( os, ind + 1 ); os << "std::cout << \"Could not find match for expression in function f_"; os << progNames[currProgram].c_str() << " \";" << std::endl; indent( os, ind + 1 ); os << sshd.str().c_str() << "->print( std::cout );" << std::endl; indent( os, ind + 1 ); os << "std::cout << std::endl;" << std::endl; indent( os, ind + 1 ); os << "exit( 1 );" << std::endl; indent( os, ind ); os << "}" << std::endl; } write_dec( expr, os, ind ); for( int a=0; a<(int)args.size(); a++ ) { write_dec( args[a], os, ind ); } } break; case CASE: if( opts&opt_write_case_body ) { write_code( ((CExpr*)code)->kids[1], os, ind, retModStr ); } else { write_code( ((CExpr*)code)->kids[0]->get_head(), os, ind, retModStr ); } break; case DO: { //write each of the children in sequence int counter = 0; while( ((CExpr*)code)->kids[counter] ) { if( ((CExpr*)code)->kids[counter+1]==NULL ) { write_code( ((CExpr*)code)->kids[counter], os, ind, retModStr ); } else { std::string expr; write_expr( ((CExpr*)code)->kids[counter], os, ind, expr ); //clean up memory write_dec( expr, os, ind ); } counter++; } } break; case LET: { indent( os, ind ); os << "Expr* "; write_variable( ((SymSExpr*)((CExpr*)code)->kids[0])->s, os ); os << ";" << std::endl; std::ostringstream ss; write_variable( ((SymSExpr*)((CExpr*)code)->kids[0])->s, ss ); write_code( ((CExpr*)code)->kids[1], os, ind, ss.str().c_str() ); //add it to the variables vars.push_back( ((SymSExpr*)((CExpr*)code)->kids[0])->s ); write_code( ((CExpr*)code)->kids[2], os, ind, retModStr ); //clean up memory indent( os, ind ); write_variable( ((SymSExpr*)((CExpr*)code)->kids[0])->s, os ); os << "->dec();" << std::endl; } break; case FAIL: { indent( os, ind ); os << retModString.c_str() << "NULL;" << std::endl; } break; #ifndef MARKVAR_32 case MARKVAR: { //calculate the value for the expression std::string expr; write_expr( ((CExpr*)code)->kids[0], os, ind, expr, opt_write_check_sym_expr ); //set the mark on the expression indent( os, ind ); os << "if (" << expr.c_str() << "->followDefs()->getmark())" << std::endl; indent( os, ind+1 ); os << expr.c_str() << "->followDefs()->clearmark();" << std::endl; indent( os, ind ); os << "else" << std::endl; indent( os, ind+1 ); os << expr.c_str() << "->followDefs()->setmark();" << std::endl; //write the return if necessary if( retModStr!=NULL ){ indent( os, ind ); os << retModString.c_str() << expr.c_str() << ";" << std::endl; indent( os, ind ); os << incString.c_str() << std::endl; } write_dec( expr, os, ind ); } break; case IFMARKED: { //calculate the value for the expression std::string expr; write_expr( ((CExpr*)code)->kids[0], os, ind, expr, opt_write_check_sym_expr ); //if mark is set, write code for kids[1] indent( os, ind ); os << "if (" << expr.c_str() << "->followDefs()->getmark()){" << std::endl; write_code( ((CExpr*)code)->kids[1], os, ind+1, retModStr ); //else write code for kids[2] indent( os, ind ); os << "}else{" << std::endl; write_code( ((CExpr*)code)->kids[2], os, ind+1, retModStr ); indent( os, ind ); os << "}" << std::endl; //clean up memory write_dec( expr, os, ind ); } break; #else case MARKVAR: { //calculate the value for the expression std::string expr; write_expr( ((CExpr*)code)->kids[1], os, ind, expr, opt_write_check_sym_expr ); //set the mark on the expression indent( os, ind ); os << "if ( ((SymExpr*)" << expr.c_str() << "->followDefs())->getmark("; os << ((IntExpr*)((CExpr*)code)->kids[0])->get_num() << "))" << std::endl; indent( os, ind+1 ); os << "((SymExpr*)" << expr.c_str() << "->followDefs())->clearmark("; os << ((IntExpr*)((CExpr*)code)->kids[0])->get_num() << ");" << std::endl; indent( os, ind ); os << "else" << std::endl; indent( os, ind+1 ); os << "((SymExpr*)" << expr.c_str() << "->followDefs())->setmark("; os << ((IntExpr*)((CExpr*)code)->kids[0])->get_num() << ");" << std::endl; //write the return if necessary if( retModStr!=NULL ){ indent( os, ind ); os << retModString.c_str() << expr.c_str() << ";" << std::endl; indent( os, ind ); os << incString.c_str() << std::endl; } write_dec( expr, os, ind ); } break; case COMPARE: { std::string expr1, expr2; write_expr( ((CExpr*)code)->kids[0], os, ind, expr1, opt_write_check_sym_expr ); write_expr( ((CExpr*)code)->kids[1], os, ind, expr2, opt_write_check_sym_expr ); indent( os, ind ); os << "if( ((SymExpr*)" << expr1.c_str() << ")->followDefs() < ((SymExpr*)" << expr2.c_str() << ")->followDefs() ){" << std::endl; write_code( ((CExpr*)code)->kids[2], os, ind+1, retModStr ); indent( os, ind ); os << "}else{" << std::endl; write_code( ((CExpr*)code)->kids[3], os, ind+1, retModStr ); indent( os, ind ); os << "}" << std::endl; //clean up memory write_dec( expr1, os, ind ); write_dec( expr2, os, ind ); } break; case IFMARKED: { //calculate the value for the expression std::string expr; write_expr( ((CExpr*)code)->kids[1], os, ind, expr, opt_write_check_sym_expr ); //if mark is set, write code for kids[1] indent( os, ind ); os << "if ( ((SymExpr*)" << expr.c_str() << "->followDefs())->getmark("; os << ((IntExpr*)((CExpr*)code)->kids[0])->get_num() << ")){" << std::endl; write_code( ((CExpr*)code)->kids[2], os, ind+1, retModStr ); //else write code for kids[2] indent( os, ind ); os << "}else{" << std::endl; write_code( ((CExpr*)code)->kids[3], os, ind+1, retModStr ); indent( os, ind ); os << "}" << std::endl; //clean up memory write_dec( expr, os, ind ); } break; #endif case ADD: case MUL: case DIV: { //calculate the value for the first expression std::string expr1; write_expr( ((CExpr*)code)->kids[0], os, ind, expr1 ); //calculate the value for the second expression std::string expr2; write_expr( ((CExpr*)code)->kids[1], os, ind, expr2 ); std::ostringstream ss; ss << "rnum" << rnumCount; rnumCount++; indent( os, ind ); os << "if( " << expr1.c_str() << "->followDefs()->getclass()==INT_EXPR ){" << std::endl; indent( os, ind+1 ); os << "mpz_t " << ss.str().c_str() << ";" << std::endl; indent( os, ind+1 ); os << "mpz_init(" << ss.str().c_str() << ");" << std::endl; indent( os, ind+1 ); os << "mpz_"; if( code->getop()==ADD ) os << "add"; else os << "mul"; os << "( " << ss.str().c_str() << ", ((IntExpr*)" << expr1.c_str() << "->followDefs())->n, ((IntExpr*)" << expr2.c_str() << "->followDefs())->n);" << std::endl; indent( os, ind+1 ); os << retModString.c_str() << "new IntExpr(" << ss.str().c_str() << ");" << std::endl; indent( os, ind ); os << "}else if( " << expr1.c_str() << "->followDefs()->getclass()==RAT_EXPR ){" << std::endl; indent( os, ind+1 ); os << "mpq_t " << ss.str().c_str() << ";" << std::endl; indent( os, ind+1 ); os << "mpq_init(" << ss.str().c_str() << ");" << std::endl; indent( os, ind+1 ); os << "mpq_"; if( code->getop()==ADD ) os << "add"; else if( code->getop()==MUL ) os << "mul"; else os << "div"; os << "( " << ss.str().c_str() << ", ((RatExpr*)" << expr1.c_str() << "->followDefs())->n, ((RatExpr*)" << expr2.c_str() << "->followDefs())->n);" << std::endl; indent( os, ind+1 ); os << retModString.c_str() << "new RatExpr(" << ss.str().c_str() << ");" << std::endl; indent( os, ind ); os << "}" << std::endl; //clean up memory write_dec( expr1, os, ind ); write_dec( expr2, os, ind ); } break; case NEG: { //calculate the value for the first expression std::string expr1; write_expr( ((CExpr*)code)->kids[0], os, ind, expr1 ); std::ostringstream ss; ss << "rnum" << rnumCount; rnumCount++; indent( os, ind ); os << "if( " << expr1.c_str() << "->followDefs()->getclass()==INT_EXPR ){" << std::endl; indent( os, ind+1 ); os << "mpz_t " << ss.str().c_str() << ";" << std::endl; indent( os, ind+1 ); os << "mpz_init(" << ss.str().c_str() << ");" << std::endl; indent( os, ind+1 ); os << "mpz_neg( " << ss.str().c_str() << ", ((IntExpr*)" << expr1.c_str() << "->followDefs())->n );" << std::endl; indent( os, ind+1 ); os << retModString.c_str() << "new IntExpr(" << ss.str().c_str() << ");" << std::endl; indent( os, ind ); os << "}else if( " << expr1.c_str() << "->followDefs()->getclass()==RAT_EXPR ){" << std::endl; indent( os, ind+1 ); os << "mpq_t " << ss.str().c_str() << ";" << std::endl; indent( os, ind+1 ); os << "mpq_init(" << ss.str().c_str() << ");" << std::endl; indent( os, ind+1 ); os << "mpq_neg( " << ss.str().c_str() << ", ((RatExpr*)" << expr1.c_str() << "->followDefs())->n );" << std::endl; indent( os, ind+1 ); os << retModString.c_str() << "new RatExpr(" << ss.str().c_str() << ");" << std::endl; indent( os, ind ); os << "}" << std::endl; //clean up memory write_dec( expr1, os, ind ); } break; case IFNEG: case IFZERO: { std::string expr1; write_expr( ((CExpr*)code)->kids[0], os, ind, expr1 ); indent( os, ind ); os << "if( " << expr1.c_str() << "->followDefs()->getclass()==INT_EXPR ){" << std::endl; indent( os, ind+1 ); os << "if( mpz_sgn( ((IntExpr *)" << expr1.c_str() << "->followDefs())->n ) "; if( code->getop()==IFNEG ) os << "<"; else os << "=="; os << " 0 ){" << std::endl; write_code( ((CExpr*)code)->kids[1], os, ind+2, retModStr ); indent( os, ind+1 ); os << "}else{" << std::endl; write_code( ((CExpr*)code)->kids[2], os, ind+2, retModStr ); indent( os, ind+1 ); os << "}" << std::endl; indent( os, ind ); os << "}else if( " << expr1.c_str() << "->followDefs()->getclass()==RAT_EXPR ){" << std::endl; indent( os, ind+1 ); os << "if( mpq_sgn( ((RatExpr *)" << expr1.c_str() << "->followDefs())->n ) "; if( code->getop()==IFNEG ) os << "<"; else os << "=="; os << " 0 ){" << std::endl; write_code( ((CExpr*)code)->kids[1], os, ind+2, retModStr ); indent( os, ind+1 ); os << "}else{" << std::endl; write_code( ((CExpr*)code)->kids[2], os, ind+2, retModStr ); indent( os, ind+1 ); os << "}" << std::endl; indent( os, ind ); os << "}" << std::endl; //clean up memory write_dec( expr1, os, ind ); } break; case RUN:/*?*/break; case PI:/*?*/break; case LAM:/*?*/break; case TYPE:/*?*/break; case KIND:/*?*/break; case ASCRIBE:/*?*/break; case MPZ:/*?*/break; case PROG:/*?*/break; case PROGVARS:/*?*/break; case PAT:/*?*/break; } break; } }
void sccwriter::write_variable( const std::string& n, std::ostream& os ) { std::string nn; get_var_name( n, nn ); os << nn.c_str(); }
/**************************************************************************** * Function : handle_query_variable * * Parameters : * IN SOCKINFO *info : Socket info * IN http_message_t* request : HTTP request * IN IXML_Document *xml_doc : Document containing the variable request * SOAP message * * Description : This action handles the SOAP requests to querry the * state variables. This functionality has been deprecated in * the UPnP V1.0 architecture * * Return : void * * Note : ****************************************************************************/ static UPNP_INLINE void handle_query_variable( IN SOCKINFO * info, IN http_message_t * request, IN IXML_Document * xml_doc ) { Upnp_FunPtr soap_event_callback; void *cookie; char var_name[LINE_SIZE]; struct Upnp_State_Var_Request variable; const char *err_str; int err_code; // get var name if( get_var_name( xml_doc, var_name ) != 0 ) { send_error_response( info, SOAP_INVALID_VAR, Soap_Invalid_Var, request ); return; } // get info for event if( get_device_info( request, 1, xml_doc, variable.DevUDN, variable.ServiceID, &soap_event_callback, &cookie ) != 0 ) { send_error_response( info, SOAP_INVALID_VAR, Soap_Invalid_Var, request ); return; } linecopy( variable.ErrStr, "" ); variable.ErrCode = UPNP_E_SUCCESS; namecopy( variable.StateVarName, var_name ); variable.CurrentVal = NULL; variable.CtrlPtIPAddr = info->foreign_ip_addr; // send event soap_event_callback( UPNP_CONTROL_GET_VAR_REQUEST, &variable, cookie ); UpnpPrintf( UPNP_INFO, SOAP, __FILE__, __LINE__, "Return from callback for var request\n" ); // validate, and handle result if( variable.CurrentVal == NULL ) { err_code = SOAP_ACTION_FAILED; err_str = Soap_Action_Failed; send_error_response( info, SOAP_INVALID_VAR, Soap_Invalid_Var, request ); return; } if( variable.ErrCode != UPNP_E_SUCCESS ) { if( strlen( variable.ErrStr ) > 0 ) { err_code = SOAP_INVALID_VAR; err_str = Soap_Invalid_Var; } else { err_code = variable.ErrCode; err_str = variable.ErrStr; } send_error_response( info, err_code, err_str, request ); return; } // send response send_var_query_response( info, variable.CurrentVal, request ); ixmlFreeDOMString( variable.CurrentVal ); }
tree_cell* nasl_read_var_ref(lex_ctxt* lexic, tree_cell* tc) { tree_cell *ret; anon_nasl_var *v; if (tc == NULL || tc == FAKE_CELL) { nasl_perror(lexic, "nasl_read_var_ref: cannot read NULL or FAKE cell\n"); return NULL; } if (tc->type != REF_VAR) { nasl_perror(lexic, "nasl_read_var_ref: argument (type=%d) is not REF_VAR %s\n", tc->type, get_line_nb(tc)); return NULL; } v = tc->x.ref_val; if (v == NULL) { nasl_perror(lexic, "nasl_read_var_ref: NULL variable in REF_VAR\n"); return NULL; } ret = alloc_tree_cell(tc->line_nb, NULL); switch (v->var_type) { case VAR2_INT: ret->type = CONST_INT; ret->x.i_val = v->v.v_int; if(nasl_trace_enabled())nasl_trace(lexic, "NASL> %s -> %d\n", get_var_name(v), ret->x.i_val); return ret; case VAR2_STRING: ret->type = CONST_STR; /* Fix bad string length */ if (v->v.v_str.s_siz <= 0 && v->v.v_str.s_val[0] != '\0') { v->v.v_str.s_siz = strlen(v->v.v_str.s_val); nasl_perror(lexic, "nasl_read_var_ref: Bad string length fixed\n"); } /* Go on next case */ case VAR2_DATA: ret->type = v->var_type == VAR2_STRING ? CONST_STR : CONST_DATA; if(v->v.v_str.s_val == NULL) { ret->x.str_val = NULL; ret->size = 0; } else { ret->x.str_val = emalloc(v->v.v_str.s_siz); memcpy(ret->x.str_val, v->v.v_str.s_val, v->v.v_str.s_siz); ret->size = v->v.v_str.s_siz; } if(nasl_trace_enabled())nasl_trace(lexic, "NASL> %s -> \"%s\"\n", get_var_name(v), ret->x.str_val); return ret; case VAR2_ARRAY: ret->type = REF_ARRAY; ret->x.ref_val = &v->v.v_arr; return ret; case VAR2_UNDEF: #if NASL_DEBUG > 0 name = get_var_name(v); if (strcmp(name, "NULL") != 0) /* special case */ nasl_perror(lexic, "nasl_read_var_ref: variable %s is undefined %s\n", name, get_line_nb(tc)); #endif if(nasl_trace_enabled())nasl_trace(lexic, "NASL> %s -> undef\n", get_var_name(v), v->var_type); break; default: nasl_perror(lexic, "nasl_read_var_ref: unhandled variable type %d\n", v->var_type); if(nasl_trace_enabled())nasl_trace(lexic, "NASL> %s -> ???? (Var type %d)\n", get_var_name(v), v->var_type); break; } deref_cell(ret); return NULL; }
static anon_nasl_var* create_anon_var(tree_cell* val) { anon_nasl_var *v = emalloc(sizeof(anon_nasl_var)); tree_cell *tc; if (val == NULL || val == FAKE_CELL) { #if NASL_DEBUG > 1 nasl_perror(NULL, "create_anon_var: affecting NULL or FAKE cell to variable %s\n", get_var_name(v)); #endif v->var_type = VAR2_UNDEF; return v; } tc = affect_to_anon_var(v, val); /* Here we might test the return value */ deref_cell(tc); return v; }
static named_nasl_var* create_named_var(const char* name, tree_cell* val) { named_nasl_var *v = emalloc(sizeof(named_nasl_var)); tree_cell *tc; if (name != NULL) v->var_name = estrdup(name); if (val == NULL || val == FAKE_CELL) { #if NASL_DEBUG > 1 nasl_perror(NULL, "create_named_var: affecting NULL or FAKE cell to variable %s\n", get_var_name(v)); #endif v->u.var_type = VAR2_UNDEF; return v; } tc = affect_to_anon_var(&v->u, val); /* Here we might test the return value */ deref_cell(tc); return v; }
static tree_cell* affect_to_anon_var(anon_nasl_var* v1, tree_cell* rval) { anon_nasl_var *v2 = NULL, v0; nasl_array *a = NULL; int t1, t2; void *p; t1 = v1->var_type; if (rval == NULL || rval == FAKE_CELL) { #if NASL_DEBUG > 1 nasl_perror(NULL, "nasl_affect: affecting NULL or FAKE cell undefines variable %s %s\n", get_var_name(v1), get_line_nb(rval)); #endif clear_anon_var(v1); if(nasl_trace_enabled())nasl_trace(NULL, "NASL> %s <- undef\n", get_var_name(v1)); return NULL; } switch (rval->type) { case CONST_INT: t2 = VAR2_INT; break; case CONST_STR: t2 = VAR2_STRING; break; case CONST_DATA: t2 = VAR2_DATA; break; case REF_VAR: v2 = rval->x.ref_val; if (v2 == v1) { #if NASL_DEBUG > 1 nasl_perror(NULL, "Copying variable %s to itself is useless and dangerous!\n", get_var_name(v1)); #endif return FAKE_CELL; } t2 = v2->var_type; if (t2 == VAR2_ARRAY) a = &v2->v.v_arr; /* ? */ break; case REF_ARRAY: case DYN_ARRAY: a = rval->x.ref_val; t2 = VAR2_ARRAY; if (v1->var_type == VAR2_ARRAY && &v1->v.v_arr == a) { #if NASL_DEBUG > 1 nasl_perror(NULL, "Copying array %s to itself is useless and dangerous!\n", get_var_name(v1)); #endif return FAKE_CELL; } break; default: nasl_perror(NULL, "Cannot affect rvalue 0x%x to variable\n", rval->type); return NULL; } /* * Bug #146: when executing * x = 'abc'; x = x; or x = make_list(...); x = x[0]; * the rvalue will be freed before it is copied to the lvalue */ v0 = *v1; if (t1 != VAR2_UNDEF && t2 == VAR2_UNDEF) { #if NASL_DEBUG > 0 nasl_perror(NULL, "Warning: Undefining defined variable %s %s\n", get_var_name(v1), get_line_nb(rval)); #endif } else if (t1 == VAR2_ARRAY && t2 != VAR2_ARRAY) { #if NASL_DEBUG > 1 nasl_perror(NULL, "Warning: affecting non array (0x%x) to array variable %s\n", t2, get_line_nb(rval)); #endif } else if ((t1 == VAR2_INT || t1 == VAR2_STRING || t1 == VAR2_DATA) && t2 == VAR2_ARRAY) { #if NASL_DEBUG > 1 nasl_perror(NULL ,"Warning: affecting array to atomic variable (0x%x) %s\n", t2, get_line_nb(rval)); #endif } /* Bug #146: this fake clear is necessary if we copy an array*/ memset(v1, 0, sizeof(*v1)); /* Bug #146: no risk with the type, we already copied it */ v1->var_type = t2; if (rval->type != REF_VAR && rval->type != REF_ARRAY && rval->type != DYN_ARRAY) switch (t2) { case VAR2_INT: v1->v.v_int = rval->x.i_val; break; case VAR2_STRING: case VAR2_DATA: if( rval->x.str_val == NULL ) { v1->v.v_str.s_val = NULL; v1->v.v_str.s_siz = 0; } else { p = emalloc(rval->size+1); memcpy(p, rval->x.str_val, rval->size+1); v1->v.v_str.s_siz = rval->size; v1->v.v_str.s_val = p; } break; } else /* REF_xxx */ switch(t2) { case VAR2_INT: v1->v.v_int = v2->v.v_int; break; case VAR2_STRING: case VAR2_DATA: if(v2->v.v_str.s_val == NULL) { v1->v.v_str.s_val = NULL; v1->v.v_str.s_siz = 0; } else { p = emalloc(v2->v.v_str.s_siz); memcpy(p, v2->v.v_str.s_val, v2->v.v_str.s_siz); v1->v.v_str.s_siz = v2->v.v_str.s_siz; v1->v.v_str.s_val = p; } break; case VAR2_ARRAY: copy_array(&v1->v.v_arr, a); if (v0.var_type == VAR2_ARRAY) bzero(&v0, sizeof(v0)); /* So that we don't clear the variable twice */ break; } if (nasl_trace_fp != NULL) switch(t2) { case VAR2_INT: nasl_trace(NULL, "NASL> %s <- %d\n", get_var_name(v1), v1->v.v_int); break; case VAR2_STRING: case VAR2_DATA: nasl_trace(NULL, "NASL> %s <- \"%s\"\n", get_var_name(v1), v1->v.v_str.s_val); break; case VAR2_ARRAY: nasl_trace(NULL, "NASL> %s <- (VAR2_ARRAY)\n", get_var_name(v1)); break; default: nasl_trace(NULL, "NASL> %s <- (Type 0x%x)\n", get_var_name(v1), t2); break; } clear_anon_var(&v0); return FAKE_CELL; }
void libwriter::write_file() { //std::cout << "write lib" << std::endl; std::ostringstream os_enum; std::ostringstream os_print; std::ostringstream os_constructor_h; std::ostringstream os_constructor_c; for ( int a=0; a<(int)syms.size(); a++ ) { //std::cout << "sym #" << (a+1) << ": "; //std::cout << ((SymSExpr*)syms[a])->s.c_str() << std::endl; //defs[a]->print( std::cout ); //std::cout << std::endl; if( defs[a]->getclass()==CEXPR ){ //calculate which arguments are required for input std::vector< Expr* > args; std::vector< bool > argsNeed; std::vector< Expr* > argTypes; CExpr* c = ((CExpr*)defs[a]); while( c->getop()==PI ){ //std::cout << c->kids[0] << std::endl; if( ((CExpr*)c->kids[1])->getop()!=RUN ){ args.push_back( c->kids[0] ); argsNeed.push_back( true ); argTypes.push_back( c->kids[1] ); } for( int b=0; b<(int)args.size(); b++ ){ if( argsNeed[b] ){ if( ((CExpr*)c->kids[1])->getop()==RUN ){ if( ((CExpr*)c->kids[1])->kids[1]->free_in( args[b] ) ){ argsNeed[b] = false; } }else{ if( c->kids[1]->free_in( args[b] ) ){ argsNeed[b] = false; } } } } c = (CExpr*)(c->kids[2]); } //record if this declares a judgement if( ((CExpr*)defs[a])->getop()==PI && c->getop()==TYPE ){ //std::cout << "This is a judgement" << std::endl; judgements.push_back( syms[a] ); //record if this declares a proof rule }else if( c->getclass()==CEXPR && std::find( judgements.begin(), judgements.end(), c->kids[0] )!=judgements.end() ){ std::cout << "Handle rule: " << ((SymSExpr*)syms[a])->s.c_str() << std::endl; //std::cout << "These are required to input:" << std::endl; //for( int b=0; b<(int)args.size(); b++ ){ // if( argsNeed[b] ){ // std::cout << ((SymSExpr*)args[b])->s.c_str() << std::endl; // } //} os_enum << " rule_" << ((SymSExpr*)syms[a])->s.c_str() << "," << std::endl; os_print << " case rule_" << ((SymSExpr*)syms[a])->s.c_str() << ": os << \""; os_print << ((SymSExpr*)syms[a])->s.c_str() << "\";break;" << std::endl; std::ostringstream os_args; os_args << "("; bool firstTime = true; for( int b=0; b<(int)args.size(); b++ ){ if( argsNeed[b] ){ if( !firstTime ) os_args << ","; std::string str; get_var_name( ((SymSExpr*)args[b])->s, str ); os_args << " LFSCProof* " << str.c_str(); firstTime = false; } } if( !firstTime ){ os_args << " "; } os_args << ")"; os_constructor_h << " static LFSCProof* make_" << ((SymSExpr*)syms[a])->s.c_str(); os_constructor_h << os_args.str().c_str() << ";" << std::endl; os_constructor_c << "LFSCProof* LFSCProof::make_" << ((SymSExpr*)syms[a])->s.c_str(); os_constructor_c << os_args.str().c_str() << "{" << std::endl; os_constructor_c << " LFSCProof **kids = new LFSCProof *[" << (int)args.size()+1 << "];" << std::endl; for( int b=0; b<(int)args.size(); b++ ){ os_constructor_c << " kids[" << b << "] = "; if( argsNeed[b] ){ std::string str; get_var_name( ((SymSExpr*)args[b])->s, str ); os_constructor_c << str.c_str(); }else{ os_constructor_c << "hole"; } os_constructor_c << ";" << std::endl; } os_constructor_c << " kids[" << (int)args.size() << "] = 0;" << std::endl; os_constructor_c << " return new LFSCProofC( rule_" << ((SymSExpr*)syms[a])->s.c_str() << ", kids );" << std::endl; os_constructor_c << "}" << std::endl << std::endl; } } //write the header static std::string filename( "lfsc_proof" ); std::fstream fsh; std::string fnameh( filename ); fnameh.append(".h"); fsh.open( fnameh.c_str(), std::ios::out ); fsh << "#ifndef LFSC_PROOF_LIB_H" << std::endl; fsh << "#define LFSC_PROOF_LIB_H" << std::endl; fsh << std::endl; fsh << "#include <string>" << std::endl; fsh << std::endl; fsh << "class LFSCProof{" << std::endl; fsh << "protected:" << std::endl; fsh << " enum{" << std::endl; fsh << os_enum.str().c_str(); fsh << " };" << std::endl; fsh << " static LFSCProof* hole;" << std::endl; fsh << " LFSCProof(){}" << std::endl; fsh << "public:" << std::endl; fsh << " virtual ~LFSCProof(){}" << std::endl; fsh << " static void init();" << std::endl; fsh << std::endl; fsh << " //functions to build LFSC proofs" << std::endl; fsh << os_constructor_h.str().c_str(); fsh << std::endl; fsh << " virtual void set_child( int i, LFSCProof* e ) {}" << std::endl; fsh << " virtual void print( std::ostream& os ){}" << std::endl; fsh << "};" << std::endl; fsh << std::endl; fsh << "class LFSCProofC : public LFSCProof{" << std::endl; fsh << " short id;" << std::endl; fsh << " LFSCProof **kids;" << std::endl; fsh << "public:" << std::endl; fsh << " LFSCProofC( short d_id, LFSCProof **d_kids ) : id( d_id ), kids( d_kids ){}" << std::endl; fsh << " void set_child( int i, LFSCProof* e ) { kids[i] = e; }" << std::endl; fsh << " void print( std::ostream& os );" << std::endl; fsh << "};" << std::endl; fsh << std::endl; fsh << "class LFSCProofSym : public LFSCProof{" << std::endl; fsh << "private:" << std::endl; fsh << " std::string s;" << std::endl; fsh << " LFSCProofSym( std::string ss ) : s( ss ){}" << std::endl; fsh << "public:" << std::endl; fsh << " static LFSCProofSym* make( std::string ss ) { return new LFSCProofSym( ss ); }" << std::endl; fsh << " static LFSCProofSym* make( const char* ss ) { return new LFSCProofSym( std::string( ss ) ); }" << std::endl; fsh << " ~LFSCProofSym(){}" << std::endl; fsh << " void print( std::ostream& os ) { os << s.c_str(); }" << std::endl; fsh << "};" << std::endl; fsh << std::endl; fsh << "class LFSCProofLam : public LFSCProof{" << std::endl; fsh << " LFSCProofSym* var;" << std::endl; fsh << " LFSCProof* body;" << std::endl; fsh << " LFSCProof* typ;" << std::endl; fsh << " LFSCProofLam( LFSCProofSym* d_var, LFSCProof* d_body, LFSCProof* d_typ ) : var( d_var ), body( d_body ), typ( d_typ ){}" << std::endl; fsh << "public:" << std::endl; fsh << " static LFSCProof* make( LFSCProofSym* d_var, LFSCProof* d_body, LFSCProof* d_typ = NULL ) {" << std::endl; fsh << " return new LFSCProofLam( d_var, d_body, d_typ );" << std::endl; fsh << " }" << std::endl; fsh << " ~LFSCProofLam(){}" << std::endl; fsh << std::endl; fsh << " void print( std::ostream& os );" << std::endl; fsh << "};" << std::endl; fsh << std::endl; fsh << "#endif" << std::endl; //write the cpp std::fstream fsc; std::string fnamec( filename ); fnamec.append(".cpp"); fsc.open( fnamec.c_str(), std::ios::out ); fsc << "#include \"lfsc_proof.h\"" << std::endl; fsc << std::endl; fsc << "LFSCProof* LFSCProof::hole = NULL;" << std::endl; fsc << std::endl; fsc << "void LFSCProof::init(){" << std::endl; fsc << " hole = LFSCProofSym::make( \"_\" );" << std::endl; fsc << "}" << std::endl; fsc << std::endl; fsc << "void LFSCProofC::print( std::ostream& os ){" << std::endl; fsc << " os << \"(\";" << std::endl; fsc << " switch( id ){" << std::endl; fsc << os_print.str().c_str(); fsc << " }" << std::endl; fsc << " int counter = 0;" << std::endl; fsc << " while( kids[counter] ){" << std::endl; fsc << " os << \" \";" << std::endl; fsc << " kids[counter]->print( os );" << std::endl; fsc << " counter++;" << std::endl; fsc << " }" << std::endl; fsc << " os << \")\";" << std::endl; fsc << "}" << std::endl; fsc << std::endl; fsc << "void LFSCProofLam::print( std::ostream& os ){" << std::endl; fsc << " os << \"(\";" << std::endl; fsc << " if( typ ){" << std::endl; fsc << " os << \"% \";" << std::endl; fsc << " }else{" << std::endl; fsc << " os << \"\\\\ \";" << std::endl; fsc << " }" << std::endl; fsc << " var->print( os );" << std::endl; fsc << " if( typ ){" << std::endl; fsc << " os << \" \";" << std::endl; fsc << " typ->print( os );" << std::endl; fsc << " }" << std::endl; fsc << " os << std::endl;" << std::endl; fsc << " body->print( os );" << std::endl; fsc << " os << \")\";" << std::endl; fsc << "}" << std::endl; fsc << std::endl; fsc << os_constructor_c.str().c_str(); fsc << std::endl; } }
std::string Trick::ClassicCheckPointAgent:: ref_string_from_ptr( void* pointer, ATTRIBUTES* attr, int curr_dim) { std::string reference_string; if ((attr != NULL) && ((curr_dim >= attr->num_index) || (attr->index[curr_dim].size != 0))) { message_publish(MSG_ERROR, "Checkpoint Agent ERROR: ref_string_from_ptr called with a non-pointer type.\n") ; } if (pointer == NULL) { reference_string = "NULL"; } else { ALLOC_INFO *alloc_info; /** Find the allocation that contains the pointer-address. */ alloc_info = mem_mgr->get_alloc_info_of( pointer); if (alloc_info != NULL) { int alloc_elem_size; int alloc_elem_index; int misalignment; alloc_elem_size = alloc_info->size; alloc_elem_index = (int) (((long) pointer - (long) alloc_info->start) / alloc_elem_size); misalignment = (int) (((long) pointer - (long) alloc_info->start) % alloc_elem_size); // If type-checking AND the type specifiers match AND the type we're looking for // is either not structured or if it is, the attr-list that describes the contents // of the structure is the same. if ( (attr != NULL) && (attr->type == alloc_info->type) && ( (attr->type != TRICK_STRUCTURED) || (attr->attr == alloc_info->attr))) { int ii; int n_l_ptrs, n_r_ptrs; // Calculate the number of pointers (asterisks) on the left side of the assignment. n_l_ptrs = attr->num_index - curr_dim; // Calculate the number of pointers (asterisks) on the right side of the assignment. n_r_ptrs = 0; for (ii=0 ; ii <alloc_info->num_index ; ii++) { if (alloc_info->index[ii] == 0) n_r_ptrs++; } if (n_l_ptrs != (n_r_ptrs + 1)) { reference_string = "NULL /*ERROR: # asterisks disagree.*/"; } else { if (misalignment == 0) { std::stringstream workss; if (alloc_info->name != NULL) { workss << "&" << alloc_info->name; if (alloc_info->num_index != 0) { workss << "[" << alloc_elem_index << "]"; } reference_string = workss.str(); } else { std::stringstream ss; ss << "Checkpoint Agent ERROR: The name of the allocation at " << alloc_info->start << " is NULL." << "Therefore, Trick::ClassicCheckPointAgent::ref_string_from_ptr() can't generate a textual reference to it." << std::endl; message_publish(MSG_ERROR, ss.str().c_str() ); reference_string = "ERROR - Allocation name is NULL"; } } else { message_publish(MSG_ERROR, "Checkpoint Agent ERROR: Badly aligned pointer.\n" " It is not aligned with the data object\n" " (of the same type) into which it is pointing.\n") ; reference_string = "ERROR - Badly aligned pointer"; } } } else if (alloc_info->type == TRICK_STRUCTURED) { // The type specifications don't match, but the right-side is structured, // so we apparently the matching type is buried in the right hand side structure. if (alloc_info->name != NULL) { std::string rightside; std::stringstream element_name; element_name << "&" << alloc_info->name; if (alloc_info->num_index != 0) { element_name << '[' << alloc_elem_index << ']'; } rightside = get_var_name( pointer, alloc_info->attr, (char *) alloc_info->start + (alloc_elem_index * alloc_info->size), element_name.str(), &attr ); reference_string = rightside; } else { std::stringstream ss; ss << "Checkpoint Agent ERROR: The name of the allocation at " << alloc_info->start << " is NULL." << "Therefore, Trick::ClassicCheckPointAgent::ref_string_from_ptr() can't generate a textual reference to it." << std::endl; message_publish(MSG_ERROR, ss.str().c_str() ); reference_string = "ERROR - Allocation name is NULL"; } } else { // The type specifications don't match, and the right hand side is not structured if (attr != NULL) { const char* left_type_spec = trickTypeCharString(attr->type, ""); const char* right_type_spec = trickTypeCharString(alloc_info->type, alloc_info->user_type_name); message_publish(MSG_ERROR, "Checkpoint Agent ERROR: Type mismatch. Type specifications disagree.\n" " The left side type specifier is \"%s\" but the right side is \"%s\".\n", left_type_spec, right_type_spec) ; reference_string = "ERROR - Type specifications disagree"; } else { if (misalignment == 0) { std::stringstream workss; if (alloc_info->name != NULL) { workss << "&" << alloc_info->name; if (alloc_info->num_index != 0) { workss << "[" << alloc_elem_index << "]"; } reference_string = workss.str(); } else { std::stringstream ss; ss << "Checkpoint Agent ERROR: The name of the allocation at " << alloc_info->start << " is NULL." << "Therefore, Trick::ClassicCheckPointAgent::ref_string_from_ptr() can't generate a textual reference to it." << std::endl; message_publish(MSG_ERROR, ss.str().c_str() ); reference_string = "ERROR - Allocation name is NULL"; } } else { message_publish(MSG_ERROR, "Checkpoint Agent ERROR: Badly aligned pointer.\n" " It is not aligned with the data object\n" " (of the same type) into which it is pointing.\n") ; reference_string = "ERROR - Badly Aligned Pointer"; } } } } else if ((attr != NULL) && ((curr_dim + 1) == attr->num_index)) { if (attr->type == TRICK_CHARACTER) { std::stringstream ss; write_quoted_str( ss, (const char*)pointer); reference_string = ss.str(); } else if (attr->type == TRICK_WCHAR) { message_publish(MSG_ERROR, "Checkpoint Agent ERROR: TRICK_WCHAR not fully supported yet.\n") ; reference_string = "ERROR: TRICK_WCHAR not fully supported yet."; } else { std::string lname = left_side_name(); message_publish(MSG_ERROR, "Checkpoint Agent ERROR: Pointer <%p> in \"%s\" is not in Trick managed memory\n" "nor is it a character pointer.\n", pointer, lname.c_str()) ; reference_string = "ERROR - Pointer not in Trick managed memory"; } } else { std::string lname = left_side_name(); message_publish(MSG_ERROR, "Checkpoint Agent ERROR: Pointer <%p> in \"%s\" is not in Trick managed memory\n" "nor is it a character pointer.\n", pointer, lname.c_str()) ; reference_string = "ERROR - Pointer not in Trick managed memory"; } } return( reference_string); }
inline String get_var_name(const Uint16 index = 0) const { return get_var_name(get_id(), index); }