void encode_dict_aux(struct Dict *d, char **si) {
if (d == NULL) {
**si = 'e';
(*si)++;
**si = '\0';
return;
}
switch(d->key_type) {
case 'l':
encode_list(d->key, si);
break;
case 'd':
encode_dict(d->key, si);
break;
case 's':
encode_str(d->key, si);
break;
case 'i':
encode_int(d->key, si);
break;
default:
fprintf(stderr, "error: encode_dict encountered poorly formed subtype\n");
exit(1);
}
switch(d->value_type) {
case 'l':
encode_list(d->value, si);
break;
case 'd':
encode_dict(d->value, si);
break;
case 's':
encode_str(d->value, si);
break;
case 'i':
encode_int(d->value, si);
break;
default:
fprintf(stderr, "error: encode_dict encountered poorly formed subtype\n");
exit(1);
}
encode_dict_aux(d->next, si);
}
int encode_exec_host(pbs_attribute *attr, tlist_head *phead, const char *atname, const char *rsname, int mode, int perm)
{
char *old_str;
char *export_str;
char *pipe;
int rc;
if (attr->at_val.at_str == NULL)
return(PBSE_NONE);
if ((export_str = strdup(attr->at_val.at_str)) == NULL)
return(PBSE_SYSTEM);
while ((pipe = strchr(export_str, '|')) != NULL)
*pipe = '+';
old_str = attr->at_val.at_str;
attr->at_val.at_str = export_str;
rc = encode_str(attr, phead, atname, rsname, mode, perm);
attr->at_val.at_str = old_str;
free(export_str);
return(rc);
}
int encode_exec_host(
pbs_attribute *attr, /* ptr to pbs_attribute */
tlist_head *phead, /* head of attrlist */
const char *atname, /* name of pbs_attribute */
const char *rsname, /* resource name or null */
int mode, /* encode mode, unused here */
int perm) /* only used for resources */
{
char *old_str;
char *export_str;
char *pipe;
int rc;
if (attr->at_val.at_str == NULL)
return(PBSE_NONE);
export_str = strdup(attr->at_val.at_str);
while ((pipe = strchr(export_str, '|')) != NULL)
*pipe = '+';
old_str = attr->at_val.at_str;
attr->at_val.at_str = export_str;
rc = encode_str(attr, phead, atname, rsname, mode, perm);
attr->at_val.at_str = old_str;
free(export_str);
return(rc);
} /* END encode_exec_host() */
void encode_list_aux(struct List *l, char **si) {
// end with e
if (l == NULL) {
**si = 'e';
(*si)++;
**si = '\0';
return;
}
switch(l->type) {
case 'l':
encode_list(l->cnt, si);
break;
case 'd':
encode_dict(l->cnt, si);
break;
case 's':
encode_str(l->cnt, si);
break;
case 'i':
encode_int(l->cnt, si);
break;
default:
fprintf(stderr, "error: encode_list encountered poorly formed subtype\n");
exit(1);
}
encode_list_aux(l->next, si);
}
void
pub3::msgpack::outbuf_t::encode_positive_int (u_int64_t i)
{
if (i <= 0x7f) {
put_byte (i);
} else if (i <= 0xff) {
put_byte (0xcc);
put_byte (i);
} else if (i <= 0xffff) {
put_byte (0xcd);
u_int16_t s = i;
put_int (s);
} else if (i <= 0xffffffff) {
put_byte (0xce);
u_int32_t w = i;
put_int (w);
} else {
if (_jsmode) {
strbuf b;
b << i;
encode_str(b);
} else {
put_byte (0xcf);
put_int (i);
}
}
}
void
pub3::msgpack::outbuf_t::encode_negative_int (int64_t i)
{
assert (i < 0);
if (i >= -32) {
put_byte (i);
} else if (i >= -128){
put_byte (0xd0);
put_byte (i);
} else if (i >= -32768) {
put_byte (0xd1);
int16_t s = i;
put_int (s);
} else if (i >= -2147483648) {
put_byte (0xd2);
int32_t w = i;
put_int (w);
} else {
put_byte (0xd3);
if (_jsmode) {
strbuf b;
b << i;
encode_str(b);
} else {
int64_t q = i;
put_int (q);
}
}
}
/* Encodes the struct in the bcont list. The encoding is null terminated. The size
* parameter does not account for the null at the end.
* NOTE: bfree DOES NOT FREE THIS STRUCT OR ITS CONTENT!
* Accepts: a Bcont struct
* Returns: a Bencoded struct
*/
struct Bencoded *encode(struct Bcont *bcont) {
int size;
char *res;
char *si;
switch(bcont->type) {
case 'l':
size = blen_list(bcont->cnt);
res = (char *)malloc_eoe((1 + size) * sizeof(char));
si = res;
encode_list(bcont->cnt, &si);
break;
case 'd':
size = blen_dict(bcont->cnt);
res = (char *)malloc_eoe((1 + size) * sizeof(char));
si = res;
encode_dict(bcont->cnt, &si);
break;
case 's':
size = blen_str(bcont->cnt);
res = (char *)malloc_eoe((1 + size) * sizeof(char));
si = res;
encode_str(bcont->cnt, &si);
break;
case 'i':
size = blen_int(bcont->cnt);
res = (char *)malloc_eoe((1 + size) * sizeof(char));
si = res;
encode_int(bcont->cnt, &si);
break;
default:
fprintf(stderr, "error: bencode encountered poorly formed subtype\n");
exit(1);
}
struct Bencoded *benc = (struct Bencoded *)malloc_eoe(sizeof(struct Bencoded));
benc->size = size;
benc->cnt = res;
return benc;
}
std::string sprint(const cons_t* p, std::string& s, bool escape)
{
switch ( type_of(p) ) {
case NIL: return s;
case BOOLEAN: return s + to_s(p->boolean);
case CHAR: return s + to_s(p->character, escape);
case REAL: return s + to_s(p->number.real);
case INTEGER: return s + to_s(p->number.integer);
case RATIONAL: return s + to_s(p->number.rational);
case CLOSURE: return s + (escape? to_s(p->closure) : "");
case SYMBOL: return s + *p->symbol;
case STRING: return s + (escape? "\"" + encode_str(p->string) + "\"" : p->string);
case VECTOR: return s + sprint(p->vector, s, escape);
case BYTEVECTOR: return s + sprint(p->bytevector, s, escape);
case CONTINUATION: return s + (escape? to_s(p->continuation) : "");
case SYNTAX: return s + sprint(p->syntax->transformer, s, escape);
case PORT: return s + sprint(p->port, s, escape);
case ENVIRONMENT: return s + sprint(p->environment, s, escape);
case POINTER: return s + sprint(p->pointer, s, escape);
case PAIR: {
std::string head = sprint(car(p), s, escape);
std::string tail = sprint(cdr(p), s, escape);
bool paren = type_of(car(p))==PAIR;
bool dotted = atomp(cdr(p)) && !nullp(cdr(p)) && !emptylistp(cadr(p));
return s
+ (paren? "(" : "")
+ head
+ (paren? ")" : "")
+ (!tail.empty() ? " " : "")
+ (dotted? ". " : "")
+ tail;
}}
return s;
}
