Attribute* cast_operator(Attribute* attr1, int type, int rm_attr1, int lno) {
if(attr1 == NULL)
die(lno, "NULL Attribute error");
int type1 = attr1->type;
Attribute* result;
if(type1 == INT_T && type == FLOAT_T) {
result = new_attr(FLOAT_T, NULL);
result->value.fv = (float)attr1->value.iv;
}
else if(type1 == FLOAT_T && type == INT_T) {
result = new_attr(INT_T, NULL);
result->value.iv = (int)attr1->value.fv;
}
else if(type1 == INT_T && type ==INT_T) {
result = new_attr(INT_T, NULL);
result->value.iv = attr1->value.iv;
}
else if(type1 == FLOAT_T && type == FLOAT_T) {
result = new_attr(FLOAT_T, NULL);
result->value.fv = attr1->value.fv;
}
else
die(lno, "cast_operator: illegal type conversion ");
if(rm_attr1==FLAG_DESTROY_ATTR) destroy_attr(attr1);
return result;
}
static Attribute* math_operator( Attribute* attr1, Attribute* attr2, int op, int lno) {
if(attr1==NULL || attr2==NULL)
die(lno, "NULL pointer for attr1 or attr2\n");
int type1 = attr1->type, type2 = attr2->type, resultype;
Attribute* result;
if(type1 == INT_T && type2 == INT_T) {
result = new_attr(INT_T, NULL);
resultype = INT_T;
}
else if (type1 == INT_T && type2 == FLOAT_T ||
type1 == FLOAT_T && type2 == FLOAT_T ||
type1 == FLOAT_T && type2 == INT_T) {
result = new_attr(FLOAT_T, NULL);
resultype = FLOAT_T;
}
if(resultype == INT_T || resultype == FLOAT_T){
switch (op) {
case OP_ADD :
if(resultype == INT_T)
result->value.iv = attr1->value.iv + attr2->value.iv;
else if (resultype == FLOAT_T)
result->value.fv = attr1->value.fv + attr2->value.fv;
else
die(lno, "math_operator: coding error\n");
break;
case OP_SUB :
if(resultype == INT_T)
result->value.iv = attr1->value.iv - attr2->value.iv;
else if (resultype == FLOAT_T)
result->value.fv = attr1->value.fv - attr2->value.fv;
else
die(lno, "math_operator: coding error\n");
break;
case OP_MUL :
if(resultype == INT_T)
result->value.iv = attr1->value.iv * attr2->value.iv;
else if (resultype == FLOAT_T)
result->value.fv = attr1->value.fv * attr2->value.fv;
else
die(lno, "math_operator: coding error\n");
break;
case OP_DIV :
if(resultype == INT_T)
result->value.iv = attr1->value.iv / attr2->value.iv;
else if (resultype == FLOAT_T)
result->value.fv = attr1->value.fv / attr2->value.fv;
else
die(lno, "math_operator: coding error\n");
break;
default:
die(lno, "math_operator: unsupported op %d.\n",op);
}
}
else
die(lno, "math_operator: unsupported op %d.\n",op);
return result;
}
static int match_fileregex(BSR *bsr, DEV_RECORD *rec, JCR *jcr)
{
if (bsr->fileregex_re == NULL)
return 1;
if (bsr->attr == NULL) {
bsr->attr = new_attr(jcr);
}
/*
* The code breaks if the first record associated with a file is
* not of this type
*/
if (rec->maskedStream == STREAM_UNIX_ATTRIBUTES ||
rec->maskedStream == STREAM_UNIX_ATTRIBUTES_EX) {
bsr->skip_file = false;
if (unpack_attributes_record(jcr, rec->Stream, rec->data, rec->data_len, bsr->attr)) {
if (regexec(bsr->fileregex_re, bsr->attr->fname, 0, NULL, 0) == 0) {
Dmsg2(dbglevel, "Matched pattern, fname=%s FI=%d\n",
bsr->attr->fname, rec->FileIndex);
} else {
Dmsg2(dbglevel, "Didn't match, skipping fname=%s FI=%d\n",
bsr->attr->fname, rec->FileIndex);
bsr->skip_file = true;
}
}
}
return 1;
}
int SubGraphs::edit_attributes( void *object)
{
attr_sItem items[10];
int i;
grow_sAttrInfo *grow_info, *grow_info_p;
int grow_info_cnt;
Attr *attr;
subgraphs_tAttr attrlist_p;
int trace_type;
int dyn_type2;
int dyn_action_type1;
int dyn_action_type2;
grow_GetObjectAttrInfo( (grow_tObject)object, NULL, &grow_info, &grow_info_cnt);
grow_GetNodeClassDynType( object, &trace_type, &dyn_type2, &dyn_action_type1, &dyn_action_type2);
grow_info_p = grow_info;
for ( i = 0; i < grow_info_cnt; i++)
{
items[i].value = grow_info_p->value_p;
strcpy( items[i].name, grow_info_p->name);
if ( grow_info_p->type == glow_eType_TraceColor)
{
switch ( trace_type)
{
case graph_eTrace_DigTone:
case graph_eTrace_DigToneWithError:
items[i].type = glow_eType_ToneOrColor;
break;
default:
items[i].type = glow_eType_Color;
}
}
else
items[i].type = grow_info_p->type;
items[i].size = grow_info_p->size;
items[i].minlimit = 0;
items[i].maxlimit = 0;
if ( strcmp( grow_info_p->name, "Extern") == 0)
items[i].noedit = 0;
else
items[i].noedit = 1;
items[i].multiline = grow_info_p->multiline;
grow_info_p++;
}
attr = new_attr( object, items, i);
attr->client_data = (void *)grow_info;
attr->close_cb = subgraphs_attr_close_cb;
attr->redraw_cb = subgraphs_attr_redraw_cb;
// Insert in attrlist
attrlist_p = (subgraphs_tAttr) calloc( 1, sizeof( *attrlist_p));
attrlist_p->attrctx = attr;
attrlist_p->next = attrlist;
attrlist = attrlist_p;
return 1;
}
Attribute* unary_operator(Attribute* attr1, int op,int rm_attr1, int lno) {
if(attr1 == NULL)
die(lno, "NULL Attribute error");
int type1 = attr1->type;
Attribute* result;
switch(op) {
case OP_PLUS:
if(type1 == INT_T) {
result = new_attr(INT_T, NULL);
result->value.iv = +(attr1->value.iv);
}
else if(type1 == FLOAT_T) {
result = new_attr(FLOAT_T, NULL);
result->value.fv = +(attr1->value.fv);
}
else
die(lno, "unary_operator: incompatible type.\n");
break;
case OP_MINUS:
if(type1 == INT_T) {
result = new_attr(INT_T, NULL);
result->value.iv = -(attr1->value.iv);
}
else if(type1 == FLOAT_T) {
result = new_attr(FLOAT_T, NULL);
result->value.fv = -(attr1->value.fv);
}
else
die(lno, "unary_operator: incompatible type.\n");
break;
case OP_NOT:
if(type1 == BOOL_T) {
result = new_attr(BOOL_T, NULL);
result->value.bv = !(attr1->value.bv);
}
else
die(lno, "unary_operator: incompatible type %d.\n", type1);
break;
default:
die(lno, "unary_operator: unknown operator.\n");
break;
}
if(rm_attr1==FLAG_DESTROY_ATTR) destroy_attr(attr1);
return result;
}
/**
* @brief Change the attribute to "@attr"by searching "@label"
*
* @param fp_src File handler of source nvm file
* @param fp_dest File handler of Destination nvm file
* @param label Label for attribute to be changed
* @param attr The wanted attribute
*
* @return 0 success
-1 failed
*/
static int change_attr(FILE *fp_src, FILE *fp_dest, const char *label, const char *attr)
{
int ret = -1;
char buf[MAX_CONFIG_LEN];
size_t buf_len = sizeof(buf);
char *rest_buf;
size_t rest_len;
int label_len;
size_t attr_len;
size_t write_len;
while (!feof(fp_src))
{
buf[0] = '\0';
label_len = get_label(fp_src, buf, sizeof(buf));
if (label_len <= 0)
{
DEBUG("Get label failed\n");
break;
}
rest_len = buf_len - label_len;
rest_buf = buf + label_len;
if (!memcmp(label, buf, strlen(label)))
{
attr_len = new_attr(fp_src, rest_buf, rest_len, attr);
ret = 0;
}
else
{
attr_len = get_attr_separator(fp_src, rest_buf, rest_len);
}
if (attr_len <= 0)
{
DEBUG("%s, get attribute failed\n", __FUNCTION__);
break;
}
write_len = label_len + attr_len;
/*Write one config to nvm files*/
if (write_len != fwrite(buf, sizeof(char), write_len, fp_dest))
{
DEBUG("write error\n");
return -1;
}
if (0 == ret)
{
break;
}
}
return ret;
}
Attribute* vertex_get_attribute(VertexType* v, char* attribute, int autoNew, int lno){
if(v==NULL)
die(lno, "NULL vertex in function: vertex_get_attribute()\n");
Attribute* attr = g_hash_table_lookup(v->attributes, attribute);
if (attr == NULL && autoNew) {
attr = new_attr(UNKNOWN_T, NULL);
g_hash_table_insert( v->attributes, attribute, attr );
}
return attr;
}
Attribute* edge_get_attribute(EdgeType* e, char* attribute, int autoNew, int lno){
if(e==NULL)
die(lno, "NULL edge in function: edge_get_attribute()\n");
Attribute* attr = g_hash_table_lookup(e->attributes, attribute);
if (attr == NULL && autoNew) {
attr = new_attr(UNKNOWN_T, NULL);
g_hash_table_insert( e->attributes, attribute, attr );
}
return attr;
}
static void do_extract(char *devname)
{
struct stat statp;
enable_backup_privileges(NULL, 1);
jcr = setup_jcr("bextract", devname, bsr, director, VolumeName, 1); /* acquire for read */
if (!jcr) {
exit(1);
}
dev = jcr->read_dcr->dev;
if (!dev) {
exit(1);
}
dcr = jcr->read_dcr;
/* Make sure where directory exists and that it is a directory */
if (stat(where, &statp) < 0) {
berrno be;
Emsg2(M_ERROR_TERM, 0, _("Cannot stat %s. It must exist. ERR=%s\n"),
where, be.bstrerror());
}
if (!S_ISDIR(statp.st_mode)) {
Emsg1(M_ERROR_TERM, 0, _("%s must be a directory.\n"), where);
}
free(jcr->where);
jcr->where = bstrdup(where);
attr = new_attr(jcr);
compress_buf = get_memory(compress_buf_size);
acl_data.last_fname = get_pool_memory(PM_FNAME);
xattr_data.last_fname = get_pool_memory(PM_FNAME);
read_records(dcr, record_cb, mount_next_read_volume);
/* If output file is still open, it was the last one in the
* archive since we just hit an end of file, so close the file.
*/
if (is_bopen(&bfd)) {
set_attributes(jcr, attr, &bfd);
}
free_attr(attr);
free_pool_memory(acl_data.last_fname);
free_pool_memory(xattr_data.last_fname);
clean_device(jcr->dcr);
dev->term();
free_dcr(dcr);
free_jcr(jcr);
printf(_("%u files restored.\n"), num_files);
return;
}
int edge_assign_attribute ( EdgeType* e, char * attr_name, void * val, int type ) {
if(e==NULL)
die(-1, "NULL edge in function: edge_assign_attribute()\n");
if(attr_name==NULL)
die(-1, "NULL attr_name in function: edge_assign_attribute()\n");
Attribute* attr = (Attribute*)g_hash_table_lookup(e->attributes, attr_name);
if (attr != NULL) {
if ( attr->type != type ) {
die(-1, "edge_assign_attribute: attribute type mismatch error \n");
}
}
else {
attr = new_attr( type, NULL );
g_hash_table_insert( e->attributes, attr_name, attr );
}
assign_attr( attr, type, val );
return 0;
}
int vertex_assign_attribute(VertexType* v, char* attr_name, void * val, int type ) {
if(v==NULL)
die(-1, "NULL vertex in function: vertex_assign_attribute()\n");
if(attr_name==NULL)
die(-1, "NULL attr_name in function: vertex_assign_attribute()\n");
Attribute* attr = (Attribute*)g_hash_table_lookup(v->attributes, attr_name);
if (attr != NULL) {
if ( attr->type != type ) {
die(-1, "vertex_assign_attribute: attribute type mismatch error \n");
}
}
else {
attr = new_attr( type, NULL );
g_hash_table_insert( v->attributes, attr_name, attr );
}
assign_attr( attr, type, val );
return 0;
}
int vertex_assign_attribute(VertexType* v, char* attr_name, void * val, int type ) {
if(v==NULL)
die(-1, "NULL vertex in function: vertex_assign_attribute()\n");
if(attr_name==NULL)
die(-1, "NULL attr_name in function: vertex_assign_attribute()\n");
Attribute* attr = (Attribute*)g_hash_table_lookup(v->attributes, attr_name);
if (attr != NULL) {
if ( attr->type != type ) {
die(-1, "vertex_assign_attribute: attribute type mismatch error \n");
}
}
else {
attr = new_attr( type, NULL );
g_hash_table_insert( v->attributes, attr_name, attr );
// GC: in FileReadWrite.c, when we read a graph from xml, need to append info
// to GC
gcRef( (void *) attr, DYN_ATTR_T );
}
assign_attr( attr, type, val );
return 0;
}
static int ti_refresh( int must )
/*******************************/
{
int i;
int incr; // chars per line
LP_PIXEL bufp, sbufp; // buffer and shadow buffer
LP_PIXEL pos; // the address of the current char
LP_PIXEL blankStart; // start of spaces to eos and then complete
// draw
int lastattr = -1;
int bufSize;
LP_PIXEL bufEnd;
bool cls = dirty_area.row1; // line on which we should clr_eos
// and then continue to draw
bool done = false;
// Need these for startup and the refresh key
if( UserForcedTermRefresh ) {
// in the case where a user has forced a refresh we must assume
// the screen is trashed, and so our cursor position is unknown
OldCol = -1;
OldRow = -1;
}
must |= UserForcedTermRefresh;
UserForcedTermRefresh = false;
// Move the cursor & return if dirty box contains no chars
if( dirty_area.row0 == dirty_area.row1 && dirty_area.col0 == dirty_area.col1 ) {
ti_hwcursor();
__flush();
return( 0 );
}
QNXDebugPrintf4( "ti_refresh( %d, %d )->( %d, %d )", dirty_area.row0,
dirty_area.col0, dirty_area.row1, dirty_area.col1 );
// Disable cursor during draw if we can
if( UIData->cursor_type != C_OFF ) {
TI_CURSOR_OFF();
}
// Get our new and old buffers
bufp = UIData->screen.origin;
sbufp = shadow;
// Get some screen statistics
bufSize = UIData->height * UIData->width;
bufEnd = &UIData->screen.origin[bufSize - 1];
incr = UIData->screen.increment;
// Find a place where we could use clear to end of screen
if( OptimizeTerminfo ) {
blankStart = NonBlankEnd( bufEnd, bufSize, *bufEnd ) + 1;
} else {
blankStart = bufEnd;
}
if( blankStart <= UIData->screen.origin && TCAP_CLS ) {
// if we could do it at the top then we might as well
// not bother doing anything else
lastattr = new_attr( UIData->screen.origin->attr, -1 );
done = true;
} else {
lastattr = -1;
if( !must ) {
int r,c;
int pos;
bool diff = false;
while( dirty_area.col0 < dirty_area.col1 ) {
for( r = dirty_area.row0; r < dirty_area.row1; r++ ) {
pos = r * incr + dirty_area.col0;
if( !PIXELEQUAL( bufp[pos], sbufp[pos] ) ) {
diff = true;
break;
}
}
if( diff )
break;
dirty_area.col0++;
}
diff = false;
while( dirty_area.col0 < dirty_area.col1 ) {
for( r = dirty_area.row0; r < dirty_area.row1; r++ ) {
pos = r * incr + dirty_area.col1 - 1;
if( !PIXELEQUAL( bufp[pos], sbufp[pos] ) ) {
diff = true;
break;
}
}
if( diff )
break;
dirty_area.col1--;
}
diff = false;
while( dirty_area.row0 < dirty_area.row1 ) {
for( c = dirty_area.col0; c < dirty_area.col1; c++ ) {
pos = dirty_area.row0 * incr + c;
if( !PIXELEQUAL( bufp[pos], sbufp[pos] ) ) {
diff = true;
break;
}
}
if( diff )
break;
dirty_area.row0++;
}
diff = false;
while( dirty_area.row0 < dirty_area.row1 ) {
for( c = dirty_area.col0; c < dirty_area.col1; c++ ) {
pos = ( dirty_area.row1 - 1 ) * incr + c;
if( !PIXELEQUAL( bufp[pos], sbufp[pos] ) ) {
diff = true;
break;
}
}
if( diff )
break;
dirty_area.row1--;
}
}
if( OptimizeTerminfo ) {
// Set cls if drawing box is bottom part (or whole) of screen
if( dirty_area.col0 == 0 &&
dirty_area.row1 == UIData->height &&
dirty_area.col1 == UIData->width &&
TCAP_CLS ) {
if( clr_eos[0] != '\0' ) {
cls = dirty_area.row0;
} else if( dirty_area.row0 == 0 ) {
cls = 0;
}
}
if( !must ) {
// Adjust cls so refresh looks pretty
for( ; cls < dirty_area.row1; cls++ ) {
int pos;
int pos2;
pos = cls * incr;
pos2 = pos + UIData->width - 1;
if( !PIXELEQUAL( bufp[pos], sbufp[pos] )
&& ( bufp[pos].ch != sbufp[pos2].ch
|| bufp[pos].attr == sbufp[pos2].attr) ) {
break;
}
}
}
/*
if( cls < dirty_area.row1 ) {
// If cls is set to by this point we've decided to clear the area
blankStart = bufEnd;
}
*/
}
}
if( cls == 0 || ( TI_FillColourSet && blankStart < bufp && TCAP_CLS ) ) {
// Clear the screen if cls is set to 0 or if the screen
// is supposed to be blank
if( cls == 0 ) {
TI_RESTORE_COLOUR();
}
TI_CLS();
} else {
// we still have work to do if it turned out we couldn't use the
// blank start after all
done = false;
}
if( !done ) {
// If the screen isn't completely blank we have to do some work
int j;
bool ca_valid; // is cursor address valid?
int rcount; // repeat count
char rchar; // repeated character
bool ralt; // if repeated character is in acs
int rcol; // starting column of repeated chars
bufp += dirty_area.row0 * incr;
sbufp += dirty_area.row0 * incr;
for( i = dirty_area.row0; i < dirty_area.row1; i++ ) {
ca_valid = false;
rcount = 0;
if( i == cls ) {
TI_RESTORE_COLOUR();
TI_CURSOR_MOVE( 0, i );
putp( clr_eos );
ca_valid = true;
//assert( dirty_area.col0==0 && dirty_area.col1==UIData->width );
}
for( j = dirty_area.col0; j < dirty_area.col1; j++ ) {
pos = &bufp[j];
if( !must && (
( cls <= i )
? ( bufp[j].ch == ' ' && ( (bufp[j].attr & 0x70) == 0 ) )
: ( PIXELEQUAL( bufp[j], sbufp[j] ) && pos <= blankStart ) ) ) {
ca_valid = false;
continue;
}
if( !ca_valid ) {
QNXDebugPrintf2( "cursor address %d, %d\n", j, i );
// gotta dump chars before we move
TI_DUMPCHARS();
TI_CURSOR_MOVE( j, i );
ca_valid = true;
}
if( bufp[j].attr != lastattr ) {
// dump before changing attrs too...
TI_DUMPCHARS();
lastattr = new_attr( bufp[j].attr, lastattr );
}
// Clear to end of screen if we can
if( pos > blankStart ) {
if( TI_FillColourSet ) {
// Dump before blank to end of screen...
TI_DUMPCHARS();
putp( clr_eos );
update_shadow();
return( 0 );
} else {
pos = bufEnd;
}
}
if( !TI_ignore_bottom_right || (j != UIData->width - 1) || (i != UIData->height - 1) ) {
// slurp up the char
TI_SLURPCHAR( bufp[j].ch );
OldCol++;
// if we walk off the edge our position is undefined
if( OldCol >= UIData->width ) {
OldCol = -1;
OldRow = -1;
}
}
}
// Make sure we dump any stragglers
TI_DUMPCHARS();
bufp += incr;
sbufp += incr;
}
}
update_shadow();
return( 0 );
}
static int td_refresh( int must )
/*******************************/
{
int i;
int incr;
LP_PIXEL bufp, sbufp;
must |= UserForcedTermRefresh;
UserForcedTermRefresh = false;
if( dirty_area.row0 == dirty_area.row1 && dirty_area.col0 == dirty_area.col1 ) {
td_hwcursor();
__flush();
return( 0 );
}
QNXDebugPrintf4("td_refresh (%d,%d)->(%d,%d)", dirty_area.row0, dirty_area.col0, dirty_area.row1, dirty_area.col1);
if( UIData->cursor_type != C_OFF )
QNX_CURSOR_OFF();
bufp = UIData->screen.origin;
incr = UIData->screen.increment;
sbufp = shadow;
bufp += dirty_area.row0 * incr;
sbufp += dirty_area.row0 * incr;
/*-
* minimize updates
*/
for( i = dirty_area.row0; i < dirty_area.row1; i++ ) {
int j;
int lastattr = -1; // invalid to start
bool ca_valid = false; // is cursor address valid?
for( j = dirty_area.col0; j < dirty_area.col1; j++ ) {
if( !must && PIXELEQUAL( bufp[j], sbufp[j] ) ) {
ca_valid = false;
lastattr = -1;
continue;
}
if( !ca_valid ) {
QNXDebugPrintf2("cursor address %d,%d\n",j,i);
QNX_CURSOR_MOVE( j, i );
ca_valid = true;
}
if( bufp[j].attr != lastattr ) {
lastattr = new_attr( bufp[j].attr, lastattr );
}
if( bufp[j].ch < 0x20 )
__putchar( 033 );
__putchar( bufp[j].ch );
sbufp[j] = bufp[j];
}
bufp += incr;
sbufp += incr;
}
dirty_area.row0 = dirty_area.row1 = 0;
dirty_area.col0 = dirty_area.col1 = 0;
td_hwcursor();
__flush();
return( 0 );
}
int
be_visitor_interface_ss::gen_abstract_ops_helper (
be_interface *node,
be_interface *base,
TAO_OutStream *os)
{
if (!base->is_abstract ())
{
return 0;
}
AST_Decl *d = 0;
be_visitor_context ctx;
ctx.stream (os);
ctx.state (TAO_CodeGen::TAO_ROOT_SS);
for (UTL_ScopeActiveIterator si (base, UTL_Scope::IK_decls);
!si.is_done ();
si.next ())
{
d = si.item ();
if (d == 0)
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("be_visitor_interface_ss::")
ACE_TEXT ("gen_abstract_ops_helper - ")
ACE_TEXT ("bad node in this scope\n")),
-1);
}
AST_Decl::NodeType nt = d->node_type ();
UTL_ScopedName *item_new_name = 0;
UTL_ScopedName *new_name = 0;
if (AST_Decl::NT_op == nt || AST_Decl::NT_attr == nt)
{
ACE_NEW_RETURN (item_new_name,
UTL_ScopedName (d->local_name ()->copy (),
0),
-1);
new_name = (UTL_ScopedName *) node->name ()->copy ();
new_name->nconc (item_new_name);
}
else
{
continue;
}
// We pass the node's is_abstract flag to the operation
// constructor so we will get the right generated operation
// body if we are regenerating an operation from an
// abstract interface in a concrete interface or component.
if (AST_Decl::NT_op == nt)
{
be_operation *op = be_operation::narrow_from_decl (d);
UTL_ScopedName *old_name =
(UTL_ScopedName *) op->name ()->copy ();
op->set_name (new_name);
op->set_defined_in (node);
op->is_abstract (node->is_abstract ());
be_visitor_operation_ss op_visitor (&ctx);
op_visitor.visit_operation (op);
op->set_name (old_name);
op->set_defined_in (base);
op->is_abstract (base->is_abstract ());
}
else if (AST_Decl::NT_attr == nt)
{
AST_Attribute *attr =
AST_Attribute::narrow_from_decl (d);
be_attribute new_attr (attr->readonly (),
attr->field_type (),
0,
attr->is_local (),
attr->is_abstract ());
new_attr.set_defined_in (node);
new_attr.set_name (new_name);
UTL_ExceptList *get_exceptions =
attr->get_get_exceptions ();
if (0 != get_exceptions)
{
new_attr.be_add_get_exceptions (get_exceptions->copy ());
}
UTL_ExceptList *set_exceptions =
attr->get_set_exceptions ();
if (0 != set_exceptions)
{
new_attr.be_add_set_exceptions (set_exceptions->copy ());
}
be_visitor_attribute attr_visitor (&ctx);
attr_visitor.visit_attribute (&new_attr);
ctx.attribute (0);
new_attr.destroy ();
}
}
return 0;
}
/* convert XMLRPC_REQUEST to soap xml dom. */
xml_element* SOAP_REQUEST_to_xml_element(XMLRPC_REQUEST request) {
xml_element* root = xml_elem_new();
/* safety first. */
if (root) {
xml_element* body = xml_elem_new();
root->name = strdup("SOAP-ENV:Envelope");
/* silly namespace stuff */
Q_PushTail(&root->attrs, new_attr("xmlns:SOAP-ENV", "http://schemas.xmlsoap.org/soap/envelope/"));
Q_PushTail(&root->attrs, new_attr("xmlns:xsi", "http://www.w3.org/1999/XMLSchema-instance"));
Q_PushTail(&root->attrs, new_attr("xmlns:xsd", "http://www.w3.org/1999/XMLSchema"));
Q_PushTail(&root->attrs, new_attr("xmlns:SOAP-ENC", "http://schemas.xmlsoap.org/soap/encoding/"));
Q_PushTail(&root->attrs, new_attr("xmlns:si", "http://soapinterop.org/xsd"));
Q_PushTail(&root->attrs, new_attr("xmlns:ns6", "http://testuri.org"));
Q_PushTail(&root->attrs, new_attr("SOAP-ENV:encodingStyle", "http://schemas.xmlsoap.org/soap/encoding/"));
/* Q_PushHead(&root->attrs, new_attr("xmlns:ks", "http://kitchen.sink.org/soap/everything/under/sun"));
JUST KIDDING!! :-) ----> ------------------------------------------------- */
if (body) {
/* go ahead and serialize first... */
xml_element* el_serialized =
SOAP_to_xml_element_worker(request,
XMLRPC_RequestGetData(request));
/* check for fault, in which case, there is no intermediate element */
if (el_serialized && !strcmp(el_serialized->name, TOKEN_FAULT)) {
Q_PushTail(&body->children, el_serialized);
}
/* usual case: not a fault. Add Response element in between. */
else {
xml_element* rpc = xml_elem_new();
if (rpc) {
const char* methodname = XMLRPC_RequestGetMethodName(request);
XMLRPC_REQUEST_TYPE rtype = XMLRPC_RequestGetRequestType(request);
/* if we are making a request, we want to use the methodname as is. */
if (rtype == xmlrpc_request_call) {
if (methodname) {
rpc->name = strdup(methodname);
}
}
/* if it's a response, we append "Response". Also, given xmlrpc-epi
API/architecture, it's likely that we don't have a methodname for
the response, so we have to check that. */
else {
char buf[128];
snprintf(buf, sizeof(buf), "%s%s",
methodname ? methodname : "",
"Response");
rpc->name = strdup(buf);
}
/* add serialized data to method call/response.
add method call/response to body element */
if (rpc->name) {
if(el_serialized) {
if(Q_Size(&el_serialized->children) && rtype == xmlrpc_request_call) {
xml_element* iter = (xml_element*)Q_Head(&el_serialized->children);
while(iter) {
Q_PushTail(&rpc->children, iter);
iter = (xml_element*)Q_Next(&el_serialized->children);
}
xml_elem_free_non_recurse(el_serialized);
}
else {
Q_PushTail(&rpc->children, el_serialized);
}
}
Q_PushTail(&body->children, rpc);
}
else {
/* no method name?!
TODO: fault here...? */
}
}
}
body->name = strdup("SOAP-ENV:Body");
Q_PushTail(&root->children, body);
}
}
return root;
}
Attribute* new_attr_STRING_T(GString* s) {
return new_attr(STRING_T, s);
}
Attribute* new_attr_BOOL_T(bool b) {
return new_attr(BOOL_T, &b);
}
Attribute* new_attr_FLOAT_T(float f) {
return new_attr(FLOAT_T, &f);
}
/* translates data structures to soap/xml. recursive */
xml_element* SOAP_to_xml_element_worker(XMLRPC_REQUEST request, XMLRPC_VALUE node) {
#define BUF_SIZE 128
xml_element* elem_val = NULL;
if (node) {
int bFreeNode = 0; /* sometimes we may need to free 'node' variable */
char buf[BUF_SIZE];
XMLRPC_VALUE_TYPE_EASY type = XMLRPC_GetValueTypeEasy(node);
char* pName = NULL, *pAttrType = NULL;
/* create our return value element */
elem_val = xml_elem_new();
switch (type) {
case xmlrpc_type_struct:
case xmlrpc_type_mixed:
case xmlrpc_type_array:
if (type == xmlrpc_type_array) {
/* array's are _very_ special in soap.
TODO: Should handle sparse/partial arrays here. */
/* determine soap array type. */
const char* type = get_array_soap_type(node);
xml_element_attr* attr_array_type = NULL;
/* specify array kids type and array size. */
snprintf(buf, sizeof(buf), "%s[%i]", type, XMLRPC_VectorSize(node));
attr_array_type = new_attr(TOKEN_ARRAY_TYPE, buf);
Q_PushTail(&elem_val->attrs, attr_array_type);
pAttrType = TOKEN_ARRAY;
}
/* check for fault, which is a rather special case.
(can't these people design anything consistent/simple/elegant?) */
else if (type == xmlrpc_type_struct) {
int fault_type = get_fault_type(node);
if (fault_type) {
if (fault_type == 1) {
/* gen fault from xmlrpc style fault codes
notice that we get a new node, which must be freed herein. */
node = gen_fault_xmlrpc(node, elem_val);
bFreeNode = 1;
}
pName = TOKEN_FAULT;
}
}
{
/* recurse through sub-elements */
XMLRPC_VALUE xIter = XMLRPC_VectorRewind(node);
while ( xIter ) {
xml_element* next_el = SOAP_to_xml_element_worker(request, xIter);
if (next_el) {
Q_PushTail(&elem_val->children, next_el);
}
xIter = XMLRPC_VectorNext(node);
}
}
break;
/* handle scalar types */
case xmlrpc_type_empty:
pAttrType = TOKEN_NULL;
break;
case xmlrpc_type_string:
pAttrType = TOKEN_STRING;
simplestring_addn(&elem_val->text, XMLRPC_GetValueString(node), XMLRPC_GetValueStringLen(node));
break;
case xmlrpc_type_int:
pAttrType = TOKEN_INT;
snprintf(buf, BUF_SIZE, "%i", XMLRPC_GetValueInt(node));
simplestring_add(&elem_val->text, buf);
break;
case xmlrpc_type_boolean:
pAttrType = TOKEN_BOOLEAN;
snprintf(buf, BUF_SIZE, "%i", XMLRPC_GetValueBoolean(node));
simplestring_add(&elem_val->text, buf);
break;
case xmlrpc_type_double:
pAttrType = TOKEN_DOUBLE;
snprintf(buf, BUF_SIZE, "%f", XMLRPC_GetValueDouble(node));
simplestring_add(&elem_val->text, buf);
break;
case xmlrpc_type_datetime:
{
time_t tt = XMLRPC_GetValueDateTime(node);
struct tm *tm = localtime (&tt);
pAttrType = TOKEN_DATETIME;
if(strftime (buf, BUF_SIZE, "%Y-%m-%dT%H:%M:%SZ", tm)) {
simplestring_add(&elem_val->text, buf);
}
}
break;
case xmlrpc_type_base64:
{
struct buffer_st buf;
pAttrType = TOKEN_BASE64;
base64_encode_xmlrpc(&buf, XMLRPC_GetValueBase64(node), XMLRPC_GetValueStringLen(node));
simplestring_addn(&elem_val->text, buf.data, buf.offset );
buffer_delete(&buf);
}
break;
break;
default:
break;
}
/* determining element's name is a bit tricky, due to soap semantics. */
if (!pName) {
/* if the value's type is known... */
if (pAttrType) {
/* see if it has an id (key). If so, use that as name, and type as an attribute. */
pName = (char*)XMLRPC_GetValueID(node);
if (pName) {
Q_PushTail(&elem_val->attrs, new_attr(TOKEN_TYPE, pAttrType));
}
/* otherwise, use the type as the name. */
else {
pName = pAttrType;
}
}
/* if the value's type is not known... (a rare case?) */
else {
/* see if it has an id (key). otherwise, default to generic "item" */
pName = (char*)XMLRPC_GetValueID(node);
if (!pName) {
pName = "item";
}
}
}
elem_val->name = strdup(pName);
/* cleanup */
if (bFreeNode) {
XMLRPC_CleanupValue(node);
}
}
return elem_val;
}
int
be_visitor_interface_sh::gen_abstract_ops_helper (
be_interface *node,
be_interface *base,
TAO_OutStream *os)
{
if (!base->is_abstract ())
{
return 0;
}
AST_Decl *d = 0;
be_visitor_context ctx;
ctx.stream (os);
ctx.state (TAO_CodeGen::TAO_ROOT_SH);
for (UTL_ScopeActiveIterator si (base, UTL_Scope::IK_decls);
!si.is_done ();
si.next ())
{
d = si.item ();
if (d == 0)
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("be_visitor_interface_sh::")
ACE_TEXT ("gen_abstract_ops_helper - ")
ACE_TEXT ("bad node in this scope\n")),
-1);
}
UTL_ScopedName item_new_name (d->local_name (),
0);
if (d->node_type () == AST_Decl::NT_op)
{
be_operation *op = be_operation::narrow_from_decl (d);
be_visitor_operation_sh op_visitor (&ctx);
op_visitor.visit_operation (op);
}
else if (d->node_type () == AST_Decl::NT_attr)
{
AST_Attribute *attr = AST_Attribute::narrow_from_decl (d);
be_attribute new_attr (attr->readonly (),
attr->field_type (),
&item_new_name,
attr->is_local (),
attr->is_abstract ());
new_attr.set_defined_in (node);
UTL_ExceptList *get_exceptions = attr->get_get_exceptions ();
if (0 != get_exceptions)
{
new_attr.be_add_get_exceptions (get_exceptions->copy ());
}
UTL_ExceptList *set_exceptions = attr->get_set_exceptions ();
if (0 != set_exceptions)
{
new_attr.be_add_set_exceptions (set_exceptions->copy ());
}
be_visitor_attribute attr_visitor (&ctx);
attr_visitor.visit_attribute (&new_attr);
ctx.attribute (0);
new_attr.destroy ();
}
}
return 0;
}
static Attribute* math_operator( Attribute* attr1, Attribute* attr2, int op, int lno) {
if(attr1==NULL || attr2==NULL)
die(lno, "NULL pointer for attr1 or attr2\n");
int type1 = attr1->type, type2 = attr2->type, resultype = UNKNOWN_T;
int ia1 = 0, ia2 = 0;
float fa1 = 0., fa2 = 0.;
Attribute* result;
if(type1 == INT_T && type2 == INT_T) {
result = new_attr(INT_T, NULL);
resultype = INT_T;
ia1 = attr1->value.iv;
ia2 = attr2->value.iv;
}
else if (type1 == INT_T && type2 == FLOAT_T ||
type1 == FLOAT_T && type2 == FLOAT_T ||
type1 == FLOAT_T && type2 == INT_T) {
result = new_attr(FLOAT_T, NULL);
resultype = FLOAT_T;
if(type1 == INT_T) fa1 = (float) attr1->value.iv;
else fa1 = attr1->value.fv;
if(type2 == INT_T) fa2 = (float) attr2->value.iv;
else fa2 = attr2->value.fv;
}
if(resultype == INT_T || resultype == FLOAT_T) {
switch (op) {
case OP_ADD :
if(resultype == INT_T)
result->value.iv = ia1 + ia2;
else if (resultype == FLOAT_T)
result->value.fv = fa1 + fa2;
else
die(lno, "math_operator: coding error\n");
break;
case OP_SUB :
if(resultype == INT_T)
result->value.iv = ia1 - ia2;
else if (resultype == FLOAT_T)
result->value.fv = fa1 - fa2;
else
die(lno, "math_operator: coding error\n");
break;
case OP_MUL :
if(resultype == INT_T)
result->value.iv = ia1 * ia2;
else if (resultype == FLOAT_T)
result->value.fv = fa1 * fa2;
else
die(lno, "math_operator: coding error\n");
break;
case OP_DIV :
if(resultype == INT_T)
result->value.iv = ia1 / ia2;
else if (resultype == FLOAT_T)
result->value.fv = fa1 / fa2;
else
die(lno, "math_operator: coding error\n");
break;
default:
die(lno, "math_operator: unsupported op %d.\n",op);
}
}
else
die(lno, "math_operator: unsupported op %d.\n",op);
return result;
}
int main (int argc, char *argv[])
{
int i, ch;
FILE *fd;
char line[1000];
char *VolumeName = NULL;
char *bsrName = NULL;
char *DirectorName = NULL;
bool ignore_label_errors = false;
DIRRES *director = NULL;
setlocale(LC_ALL, "");
bindtextdomain("bareos", LOCALEDIR);
textdomain("bareos");
init_stack_dump();
lmgr_init_thread();
working_directory = "/tmp";
my_name_is(argc, argv, "bls");
init_msg(NULL, NULL); /* initialize message handler */
OSDependentInit();
ff = init_find_files();
while ((ch = getopt(argc, argv, "b:c:D:d:e:i:jkLpvV:?")) != -1) {
switch (ch) {
case 'b':
bsrName = optarg;
break;
case 'c': /* specify config file */
if (configfile != NULL) {
free(configfile);
}
configfile = bstrdup(optarg);
break;
case 'D': /* specify director name */
if (DirectorName != NULL) {
free(DirectorName);
}
DirectorName = bstrdup(optarg);
break;
case 'd': /* debug level */
if (*optarg == 't') {
dbg_timestamp = true;
} else {
debug_level = atoi(optarg);
if (debug_level <= 0) {
debug_level = 1;
}
}
break;
case 'e': /* exclude list */
if ((fd = fopen(optarg, "rb")) == NULL) {
berrno be;
Pmsg2(0, _("Could not open exclude file: %s, ERR=%s\n"),
optarg, be.bstrerror());
exit(1);
}
while (fgets(line, sizeof(line), fd) != NULL) {
strip_trailing_junk(line);
Dmsg1(100, "add_exclude %s\n", line);
add_fname_to_exclude_list(ff, line);
}
fclose(fd);
break;
case 'i': /* include list */
if ((fd = fopen(optarg, "rb")) == NULL) {
berrno be;
Pmsg2(0, _("Could not open include file: %s, ERR=%s\n"),
optarg, be.bstrerror());
exit(1);
}
while (fgets(line, sizeof(line), fd) != NULL) {
strip_trailing_junk(line);
Dmsg1(100, "add_include %s\n", line);
add_fname_to_include_list(ff, 0, line);
}
fclose(fd);
break;
case 'j':
list_jobs = true;
break;
case 'k':
list_blocks = true;
break;
case 'L':
dump_label = true;
break;
case 'p':
ignore_label_errors = true;
forge_on = true;
break;
case 'v':
verbose++;
break;
case 'V': /* Volume name */
VolumeName = optarg;
break;
case '?':
default:
usage();
} /* end switch */
} /* end while */
argc -= optind;
argv += optind;
if (!argc) {
Pmsg0(0, _("No archive name specified\n"));
usage();
}
if (configfile == NULL) {
configfile = bstrdup(CONFIG_FILE);
}
my_config = new_config_parser();
parse_sd_config(my_config, configfile, M_ERROR_TERM);
LockRes();
me = (STORES *)GetNextRes(R_STORAGE, NULL);
if (!me) {
UnlockRes();
Emsg1(M_ERROR_TERM, 0, _("No Storage resource defined in %s. Cannot continue.\n"),
configfile);
}
UnlockRes();
if (DirectorName) {
foreach_res(director, R_DIRECTOR) {
if (bstrcmp(director->hdr.name, DirectorName)) {
break;
}
}
if (!director) {
Emsg2(M_ERROR_TERM, 0, _("No Director resource named %s defined in %s. Cannot continue.\n"),
DirectorName, configfile);
}
}
load_sd_plugins(me->plugin_directory, me->plugin_names);
read_crypto_cache(me->working_directory, "bareos-sd",
get_first_port_host_order(me->SDaddrs));
if (ff->included_files_list == NULL) {
add_fname_to_include_list(ff, 0, "/");
}
for (i=0; i < argc; i++) {
if (bsrName) {
bsr = parse_bsr(NULL, bsrName);
}
jcr = setup_jcr("bls", argv[i], bsr, director, VolumeName, 1); /* acquire for read */
if (!jcr) {
exit(1);
}
jcr->ignore_label_errors = ignore_label_errors;
dev = jcr->dcr->dev;
if (!dev) {
exit(1);
}
dcr = jcr->dcr;
rec = new_record();
attr = new_attr(jcr);
/*
* Assume that we have already read the volume label.
* If on second or subsequent volume, adjust buffer pointer
*/
if (dev->VolHdr.PrevVolumeName[0] != 0) { /* second volume */
Pmsg1(0, _("\n"
"Warning, this Volume is a continuation of Volume %s\n"),
dev->VolHdr.PrevVolumeName);
}
if (list_blocks) {
do_blocks(argv[i]);
} else if (list_jobs) {
do_jobs(argv[i]);
} else {
do_ls(argv[i]);
}
do_close(jcr);
}
if (bsr) {
free_bsr(bsr);
}
term_include_exclude_files(ff);
term_find_files(ff);
return 0;
}
Attribute* new_attr_INT_T(int i) {
return new_attr(INT_T, &i);
}
