2000-07-07
2000-07-07 01:28:57 by Fredrik Hübinette (Hubbe) <hubbe@hubbe.net>
-
fc26f60c1b0c9d2c25a200df926a9b3bd598bc53
(165 lines)
(+83/-82)
[
Show
| Annotate
]
Branch: 7.9
jumbopatch!
Rev: src/array.c:1.76
Rev: src/docode.c:1.75
Rev: src/encode.c:1.61
Rev: src/error.c:1.52
Rev: src/interpret.c:1.157
Rev: src/interpret.h:1.49
25:
#include "version.h"
#include "bignum.h"
- RCSID("$Id: encode.c,v 1.60 2000/06/24 00:48:13 hubbe Exp $");
+ RCSID("$Id: encode.c,v 1.61 2000/07/07 01:27:16 hubbe Exp $");
/* #define ENCODE_DEBUG */
311:
}else{
push_int(0);
}
- encode_value2(sp-1, data);
+ encode_value2(Pike_sp-1, data);
pop_stack();
break;
}
324: Inside #if defined(PIKE_DEBUG)
#ifdef PIKE_DEBUG
#undef encode_value2
- #define encode_value2(X,Y) do { struct svalue *_=sp; encode_value2_(X,Y); if(sp!=_) fatal("encode_value2 failed!\n"); } while(0)
+ #define encode_value2(X,Y) do { struct svalue *_=Pike_sp; encode_value2_(X,Y); if(Pike_sp!=_) fatal("encode_value2 failed!\n"); } while(0)
#endif
{
418:
* sort function. */
error("Canonical encoding requires basic types in indices.\n");
}
- order = get_switch_order(sp[-2].u.array);
- order_array(sp[-2].u.array, order);
- order_array(sp[-1].u.array, order);
+ order = get_switch_order(Pike_sp[-2].u.array);
+ order_array(Pike_sp[-2].u.array, order);
+ order_array(Pike_sp[-1].u.array, order);
free((char *) order);
}
- code_entry(TAG_MAPPING, sp[-2].u.array->size,data);
- for(i=0; i<sp[-2].u.array->size; i++)
+ code_entry(TAG_MAPPING, Pike_sp[-2].u.array->size,data);
+ for(i=0; i<Pike_sp[-2].u.array->size; i++)
{
- encode_value2(ITEM(sp[-2].u.array)+i, data); /* indices */
- encode_value2(ITEM(sp[-1].u.array)+i, data); /* values */
+ encode_value2(ITEM(Pike_sp[-2].u.array)+i, data); /* indices */
+ encode_value2(ITEM(Pike_sp[-1].u.array)+i, data); /* values */
}
pop_n_elems(2);
break;
447:
}
check_stack(1);
ref_push_array(val->u.multiset->ind);
- order = get_switch_order(sp[-1].u.array);
- order_array(sp[-1].u.array, order);
+ order = get_switch_order(Pike_sp[-1].u.array);
+ order_array(Pike_sp[-1].u.array, order);
free((char *) order);
- for (i = 0; i < sp[-1].u.array->size; i++)
- encode_value2(ITEM(sp[-1].u.array)+i, data);
+ for (i = 0; i < Pike_sp[-1].u.array->size; i++)
+ encode_value2(ITEM(Pike_sp[-1].u.array)+i, data);
pop_stack();
}
else
474: Inside #if defined(AUTO_BIGNUM)
*/
push_int(36);
apply(val->u.object,"digits",1);
- if(sp[-1].type != T_STRING)
+ if(Pike_sp[-1].type != T_STRING)
error("Gmp.mpz->digits did not return a string!\n");
- encode_value2(sp-1, data);
+ encode_value2(Pike_sp-1, data);
pop_stack();
break;
}
486:
error("Canonical encoding of objects not supported.\n");
push_svalue(val);
apply(data->codec, "nameof", 1);
- switch(sp[-1].type)
+ switch(Pike_sp[-1].type)
{
case T_INT:
- if(sp[-1].subtype == NUMBER_UNDEFINED)
+ if(Pike_sp[-1].subtype == NUMBER_UNDEFINED)
{
pop_stack();
push_svalue(val);
f_object_program(1);
code_entry(type_to_tag(val->type), 1,data);
- encode_value2(sp-1, data);
+ encode_value2(Pike_sp-1, data);
pop_stack();
push_svalue(val);
509:
code_entry(type_to_tag(val->type), 0,data);
break;
}
- encode_value2(sp-1, data);
+ encode_value2(Pike_sp-1, data);
pop_stack();
break;
519:
check_stack(1);
push_svalue(val);
apply(data->codec,"nameof", 1);
- if(sp[-1].type == T_INT && sp[-1].subtype==NUMBER_UNDEFINED)
+ if(Pike_sp[-1].type == T_INT && Pike_sp[-1].subtype==NUMBER_UNDEFINED)
{
if(val->subtype != FUNCTION_BUILTIN)
{
527:
code_entry(type_to_tag(val->type), 1, data);
push_svalue(val);
- sp[-1].type=T_OBJECT;
+ Pike_sp[-1].type=T_OBJECT;
ref_push_string(ID_FROM_INT(val->u.object->prog, val->subtype)->name);
f_arrow(2);
- eq=is_eq(sp-1, val);
+ eq=is_eq(Pike_sp-1, val);
pop_stack();
if(eq)
{
540:
map_delete(data->encoded, val);
push_svalue(val);
- sp[-1].type=T_OBJECT;
- encode_value2(sp-1, data);
+ Pike_sp[-1].type=T_OBJECT;
+ encode_value2(Pike_sp-1, data);
ref_push_string(ID_FROM_INT(val->u.object->prog, val->subtype)->name);
- encode_value2(sp-1, data);
+ encode_value2(Pike_sp-1, data);
pop_n_elems(3);
/* Put value back in cache */
554:
}
code_entry(type_to_tag(val->type), 0,data);
- encode_value2(sp-1, data);
+ encode_value2(Pike_sp-1, data);
pop_stack();
break;
567:
check_stack(1);
push_svalue(val);
apply(data->codec,"nameof", 1);
- if(sp[-1].type == val->type)
+ if(Pike_sp[-1].type == val->type)
error("Error in master()->nameof(), same type returned.\n");
- if(sp[-1].type == T_INT && sp[-1].subtype == NUMBER_UNDEFINED)
+ if(Pike_sp[-1].type == T_INT && Pike_sp[-1].subtype == NUMBER_UNDEFINED)
{
INT32 e;
struct program *p=val->u.program;
578:
error("Cannot encode C programs.\n");
code_entry(type_to_tag(val->type), 1,data);
f_version(0);
- encode_value2(sp-1,data);
+ encode_value2(Pike_sp-1,data);
pop_stack();
code_number(p->flags,data);
code_number(p->storage_needed,data);
618:
if(p->inherits[d].parent)
{
ref_push_object(p->inherits[d].parent);
- sp[-1].subtype=p->inherits[d].parent_identifier;
- sp[-1].type=T_FUNCTION;
+ Pike_sp[-1].subtype=p->inherits[d].parent_identifier;
+ Pike_sp[-1].type=T_FUNCTION;
}else if(p->inherits[d].prog){
ref_push_program(p->inherits[d].prog);
}else{
push_int(0);
}
- encode_value2(sp-1,data);
+ encode_value2(Pike_sp-1,data);
pop_stack();
adddata3(p->inherits[d].name);
650:
code_number(p->lfuns[d], data);
}else{
code_entry(type_to_tag(val->type), 0,data);
- encode_value2(sp-1, data);
+ encode_value2(Pike_sp-1, data);
}
pop_stack();
break;
679:
data->counter.u.integer=COUNTER_START;
if(args > 1)
{
- data->codec=sp[1-args].u.object;
+ data->codec=Pike_sp[1-args].u.object;
}else{
data->codec=get_master();
}
SET_ONERROR(tmp, free_encode_data, data);
addstr("\266ke0", 4);
- encode_value2(sp-args, data);
+ encode_value2(Pike_sp-args, data);
UNSET_ONERROR(tmp);
free_mapping(data->encoded);
710:
data->counter.u.integer=COUNTER_START;
if(args > 1)
{
- data->codec=sp[1-args].u.object;
+ data->codec=Pike_sp[1-args].u.object;
}else{
data->codec=get_master();
}
SET_ONERROR(tmp, free_encode_data, data);
addstr("\266ke0", 4);
- encode_value2(sp-args, data);
+ encode_value2(Pike_sp-args, data);
UNSET_ONERROR(tmp);
free_mapping(data->encoded);
872: Inside #if defined(PIKE_DEBUG)
#endif /* 0 */
#ifdef PIKE_DEBUG
if (old_type_mark_stackp > Pike_compiler->pike_type_mark_stackp) {
- fatal("type mark_stack out of sync!\n");
+ fatal("type Pike_interpreter.mark_stack out of sync!\n");
}
#endif /* PIKE_DEBUG */
Pike_compiler->pike_type_mark_stackp = old_type_mark_stackp;
960:
push_type(GETC());
decode_value2(data);
type_stack_mark();
- switch(sp[-1].type)
+ switch(Pike_sp[-1].type)
{
case T_INT:
push_type_int(0);
break;
case T_PROGRAM:
- push_type_int(sp[-1].u.program->id);
+ push_type_int(Pike_sp[-1].u.program->id);
break;
case T_FUNCTION:
{
struct program *prog;
- if (sp[-1].subtype == FUNCTION_BUILTIN) {
+ if (Pike_sp[-1].subtype == FUNCTION_BUILTIN) {
error("Failed to decode object type.\n");
}
- prog = program_from_svalue(sp-1);
+ prog = program_from_svalue(Pike_sp-1);
if (!prog) {
error("Failed to decode object type.\n");
}
987:
default:
error("Failed to decode type "
"(object(%s), expected object(zero|program)).\n",
- get_name_of_type(sp[-1].type));
+ get_name_of_type(Pike_sp[-1].type));
}
pop_stack();
type_stack_reverse();
1011: Inside #if defined(PIKE_DEBUG)
#ifdef PIKE_DEBUG
#undef decode_value2
- #define decode_value2(X) do { struct svalue *_=sp; decode_value2_(X); if(sp!=_+1) fatal("decode_value2 failed!\n"); } while(0)
+ #define decode_value2(X) do { struct svalue *_=Pike_sp; decode_value2_(X); if(Pike_sp!=_+1) fatal("decode_value2 failed!\n"); } while(0)
#endif
1096:
for(e=0;e<num;e++)
{
decode_value2(data);
- ITEM(a)[e]=sp[-1];
- sp--;
- dmalloc_touch_svalue(sp);
+ ITEM(a)[e]=Pike_sp[-1];
+ Pike_sp--;
+ dmalloc_touch_svalue(Pike_sp);
}
ref_push_array(a);
return;
1125:
{
decode_value2(data);
decode_value2(data);
- mapping_insert(m, sp-2, sp-1);
+ mapping_insert(m, Pike_sp-2, Pike_sp-1);
pop_n_elems(2);
}
ref_push_mapping(m);
1153:
for(e=0;e<num;e++)
{
decode_value2(data);
- multiset_insert(m, sp-1);
+ multiset_insert(m, Pike_sp-1);
pop_stack();
}
ref_push_multiset(m);
1180:
break;
case 1:
- if(IS_ZERO(sp-1))
+ if(IS_ZERO(Pike_sp-1))
{
- mapping_insert(data->decoded, &tmp, sp-1);
+ mapping_insert(data->decoded, &tmp, Pike_sp-1);
decode_value2(data);
pop_stack();
}else{
f_call_function(1);
- mapping_insert(data->decoded, &tmp, sp-1);
- push_svalue(sp-1);
+ mapping_insert(data->decoded, &tmp, Pike_sp-1);
+ push_svalue(Pike_sp-1);
decode_value2(data);
if(!data->codec)
error("Failed to decode (no codec)\n");
apply(data->codec,"decode_object",2);
pop_stack();
}
- if(data->pickyness && sp[-1].type != T_OBJECT)
+ if(data->pickyness && Pike_sp[-1].type != T_OBJECT)
error("Failed to decode object.\n");
return;
1222:
error("Object coding not compatible.\n");
break;
}
- if(data->pickyness && sp[-1].type != T_OBJECT)
+ if(data->pickyness && Pike_sp[-1].type != T_OBJECT)
error("Failed to decode (got type %d; expected object).\n",
- sp[-1].type);
+ Pike_sp[-1].type);
break;
case TAG_FUNCTION:
1247:
case 1:
decode_value2(data);
- if(sp[-2].type==T_INT)
+ if(Pike_sp[-2].type==T_INT)
{
pop_stack();
}else{
1259:
error("Function coding not compatible.\n");
break;
}
- if(data->pickyness && sp[-1].type != T_FUNCTION)
+ if(data->pickyness && Pike_sp[-1].type != T_FUNCTION)
error("Failed to decode function.\n");
break;
1276:
decode_value2(data);
/* Keep the value so that we can make a good error-message. */
- prog_code = sp-1;
+ prog_code = Pike_sp-1;
stack_dup();
if(data->codec)
1287:
stack_swap();
f_index(2);
}
- if(data->pickyness && !program_from_svalue(sp-1)) {
+ if(data->pickyness && !program_from_svalue(Pike_sp-1)) {
if ((prog_code->type == T_STRING) &&
(prog_code->u.string->len < 128) &&
(!prog_code->u.string->size_shift)) {
1326:
decode_value2(data);
f_version(0);
- if(!is_eq(sp-1,sp-2))
+ if(!is_eq(Pike_sp-1,Pike_sp-2))
error("Cannot decode programs encoded with other driver version.\n");
pop_n_elems(2);
1438:
decode_value2(data);
if(d==0)
{
- if(sp[-1].type != T_PROGRAM ||
- sp[-1].u.program != p)
+ if(Pike_sp[-1].type != T_PROGRAM ||
+ Pike_sp[-1].u.program != p)
error("Program decode failed!\n");
p->refs--;
}
- switch(sp[-1].type)
+ switch(Pike_sp[-1].type)
{
case T_FUNCTION:
- if(sp[-1].subtype == FUNCTION_BUILTIN)
+ if(Pike_sp[-1].subtype == FUNCTION_BUILTIN)
error("Failed to decode parent.\n");
- p->inherits[d].parent_identifier=sp[-1].subtype;
- p->inherits[d].prog=program_from_svalue(sp-1);
+ p->inherits[d].parent_identifier=Pike_sp[-1].subtype;
+ p->inherits[d].prog=program_from_svalue(Pike_sp-1);
if(!p->inherits[d].prog)
error("Failed to decode parent.\n");
add_ref(p->inherits[d].prog);
- p->inherits[d].parent=sp[-1].u.object;
- sp--;
- dmalloc_touch_svalue(sp);
+ p->inherits[d].parent=Pike_sp[-1].u.object;
+ Pike_sp--;
+ dmalloc_touch_svalue(Pike_sp);
break;
case T_PROGRAM:
p->inherits[d].parent_identifier=0;
- p->inherits[d].prog=sp[-1].u.program;
- sp--;
- dmalloc_touch_svalue(sp);
+ p->inherits[d].prog=Pike_sp[-1].u.program;
+ Pike_sp--;
+ dmalloc_touch_svalue(Pike_sp);
break;
default:
error("Failed to decode inheritance.\n");
1495:
for(d=0;d<p->num_constants;d++)
{
decode_value2(data);
- p->constants[d].sval=*--sp;
- dmalloc_touch_svalue(sp);
+ p->constants[d].sval=*--Pike_sp;
+ dmalloc_touch_svalue(Pike_sp);
getdata3(p->constants[d].name);
}
data->pickyness--;
1540:
error("Failed to restore string. (Illegal type)\n");
}
- mapping_insert(data->decoded, & tmp, sp-1);
+ mapping_insert(data->decoded, & tmp, Pike_sp-1);
}
1619:
if(sizeof(INT32) < sizeof(float)) /* FIXME FIXME FIXME FIXME */
error("Float architecture not supported.\n");
push_int(t); /* WARNING! */
- sp[-1].type = T_FLOAT;
+ Pike_sp[-1].type = T_FLOAT;
return;
case TAG_TYPE:
1695:
check_all_args("decode_value", args,
BIT_STRING, BIT_VOID | BIT_OBJECT | BIT_INT, 0);
- s = sp[-args].u.string;
+ s = Pike_sp[-args].u.string;
if(args<2)
{
codec=get_master();
}
- else if(sp[1-args].type == T_OBJECT)
+ else if(Pike_sp[1-args].type == T_OBJECT)
{
- codec=sp[1-args].u.object;
+ codec=Pike_sp[1-args].u.object;
}
else
{
1715:
INT32 l=s->len;
rec_restore_value(&v, &l);
}
- assign_svalue(sp-args-1, sp-1);
+ assign_svalue(Pike_sp-args-1, Pike_sp-1);
pop_n_elems(args);
}