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);
}
