/*-------------------------------------------------------------------------*/
svalue_t *
x_filter_string (svalue_t *sp, int num_arg)
/* EFUN: filter() for strings.
*
* string filter(string arr, string fun, string|object obj, mixed extra, ...)
* string filter(string arr, closure cl, mixed extra, ...)
* string filter(string arr, mapping map)
*
* Filter the elements of <arr> through a filter defined by the other
* arguments, and return an array of those elements, for which the
* filter yields non-zero.
*
* The filter can be a function call:
*
* <obj>-><fun>(elem, <extra>...)
*
* or a mapping query:
*
* <map>[elem]
*
* <obj> can both be an object reference or a filename. If omitted,
* this_object() is used (this also works if the third argument is
* neither a string nor an object).
*/
{
string_t *rc; /* Result string */
string_t *str; /* Argument string */
svalue_t *arg; /* First argument the vm stack */
mp_int slen; /* Argument string length */
char *src, *dest; /* String text work pointers */
char *flags; /* Flag array, one flag for each element of <str>
* (in reverse order). */
mp_int res; /* Number of surviving elements */
res = 0;
/* Locate the args on the stack, extract the string to filter
* and allocate the flags vector.
*/
arg = sp - num_arg + 1;
str = arg->u.str;
slen = (mp_int)mstrsize(str);
/* Every element in flags is associated by index number with an
* element in the vector to filter. The filter function is evaluated
* for every string character, and the associated flag is set to 0
* or 1 according to the result.
* At the end, all 1-flagged elements are gathered and copied
* into the result string.
*/
if (arg[1].type == T_MAPPING)
{
mp_int cnt;
/* --- Filter by mapping query --- */
mapping_t *m;
if (num_arg > 2) {
errorf("Too many arguments to filter(array)\n");
}
/* Allocate memory for the flag array. Simultaneously an error
* handler is pushed onto the stack (after the arguments) for freeing
* the buffer in case of runtime errors. */
flags = xalloc_with_error_handler((size_t)slen + 1);
if (!flags)
{
errorf("Out of memory (%zu bytes) for temporary buffer in filter().\n",
(size_t)slen + 1);
}
sp = inter_sp;
m = arg[1].u.map;
for (src = get_txt(str), cnt = slen; --cnt >= 0; src++)
{
svalue_t key;
put_number(&key, *src);
if (get_map_value(m, &key) == &const0)
{
flags[cnt] = 0;
continue;
}
flags[cnt] = 1;
res++;
}
} else {
/* --- Filter by function call --- */
int error_index;
callback_t cb;
mp_int cnt;
assign_eval_cost();
/* setup_efun_callback() will adopt and therefore remove the
* arguments from arg+1 on to arg+num_arg from the stack and update
* inter_sp. New top-of-stack will be arg. */
error_index = setup_efun_callback(&cb, arg+1, num_arg-1);
if (error_index >= 0)
{
vefun_bad_arg(error_index+2, arg);
/* NOTREACHED */
return arg;
}
/* push the callback structure onto the stack. */
sp = arg + 1;
put_callback(sp, &cb);
/* Allocate memory for the flag array. Simultaneously an error
* handler is pushed onto the stack (after the arguments) for freeing
* the buffer in case of runtime errors. */
inter_sp = sp;
flags = xalloc_with_error_handler((size_t)slen + 1);
if (!flags)
{
errorf("Out of memory (%"PRIdMPINT" bytes) for temporary buffer "
"in filter().\n", slen + 1);
}
sp = inter_sp;
/* Loop over all elements in p and call the filter.
* w is the current element filtered.
*/
for (src = get_txt(str), cnt = slen; --cnt >= 0; src++)
{
svalue_t *v;
flags[cnt] = 0;
if (current_object->flags & O_DESTRUCTED)
continue;
/* Don't call the filter anymore, but fill the
* flags array with 0es.
*/
if (!callback_object(&cb))
{
inter_sp = sp;
errorf("object used by filter(array) destructed");
}
push_number(inter_sp, *src);
v = apply_callback(&cb, 1);
if (!v || (v->type == T_NUMBER && !v->u.number) )
continue;
flags[cnt] = 1;
res++;
}
}
/* flags[] holds the filter results, res is the number of
* elements to keep. Now create the result vector.
*/
rc = alloc_mstring(res);
if (!rc)
{
errorf("Out of memory (%"PRIdMPINT" bytes) for result in filter().\n",
slen+1);
}
for (src = get_txt(str), dest = get_txt(rc), flags = &flags[slen]
; res > 0 ; src++)
{
if (*--flags)
{
*dest++ = *src;
res--;
}
}
/* Cleanup. Arguments for the closure have already been removed. On the
* stack are now the string, the mapping or callback structure and the
* error handler. (Not using pop_n_elems() for 2 elements for saving loop
* and function call overhead.) */
free_svalue(sp--); /* errorhandler, buffer and flags are freed by this. */
free_svalue(sp--); /* mapping or callback structure. */
free_mstring(str); /* string, at arg == sp */
sp->u.str = rc; /* put result here */
return sp;
} /* x_filter_string() */
/*-------------------------------------------------------------------------*/
svalue_t *
x_map_string (svalue_t *sp, int num_arg)
/* EFUN map() for strings
*
* string map(string arg, string func, string|object ob, mixed extra...)
* string map(string arg, closure cl, mixed extra...)
* string map(string arg, mapping m)
*
* Call the function <ob>-><func>() resp. the closure <cl> for
* every element of the array/struct/mapping/string <arg>, and return a result
* made up from the returned values.
*
* It is also possible to map every entry through a lookup <m>[element]. If
* the mapping entry doesn't exist, the original value is kept, otherwise the
* result of the mapping lookup.
*
* Since <arg> is a string, only integer return values are allowed, of which
* only the lower 8 bits are considered.
*
* If <ob> is omitted, or neither an object nor a string, then
* this_object() is used.
*/
{
string_t *res;
string_t *str;
svalue_t *arg;
mp_int len;
char *src, *dest;
inter_sp = sp;
arg = sp - num_arg + 1;
str = arg->u.str;
len = mstrsize(str);
if (arg[1].type == T_MAPPING)
{
/* --- Map through mapping --- */
mapping_t *m;
if (num_arg > 2) {
inter_sp = sp;
errorf("Too many arguments to map(string)\n");
}
m = arg[1].u.map;
res = alloc_mstring(len);
if (!res)
errorf("(map_string) Out of memory: string[%"PRIdMPINT
"] for result\n", len);
push_string(inter_sp, res); /* In case of errors */
for (src = get_txt(str), dest = get_txt(res); --len >= 0; src++, dest++)
{
svalue_t key, *v;
put_number(&key, *src);
v = get_map_value(m, &key);
if (v == &const0)
*dest = *src;
else
{
if (v->type != T_NUMBER)
{
errorf("(map_string) Illegal value: %s, expected string\n"
, typename(v->type)
);
}
*dest = (v->u.number & 0xFF);
}
}
/*--------------------------------------------------------------------*/
string_t *
intersect_strings (const string_t * p_left, const string_t * p_right, Bool bSubtract)
/* !bSubtract: Intersect string <left> with string <right> and return
* a newly allocated string with all those characters which are in
* both strings.
* bSubtract: Subtract string <right> from string <left> and return
* a newly allocated string with all those characters which are in
* <left> but not in <right>.
* The order of the characters returned is their order of appearance
* in <left>.
*/
{
size_t len_left, len_right, len_out;
size_t ix_left, ix_right;
long * pos;
CBool * matches;
const char * left_txt;
char * left, * right, * result_txt;
string_t *result;
len_left = mstrsize(p_left);
len_right = mstrsize(p_right);
xallocate(matches, len_left+1, "intersection matches");
/* +1 so that smalloc won't complain when given an empty left string */
for (ix_left = 0; ix_left < len_left; ix_left++)
matches[ix_left] = bSubtract ? MY_TRUE : MY_FALSE;
/* Sort the two strings */
left = sort_string(p_left, len_left, &pos);
right = sort_string(p_right, len_right, NULL);
/* Intersect the two strings by mutual comparison.
* Each non-matched character in left gets is pos[] set to -1.
*/
len_out = bSubtract ? len_left : 0;
for ( ix_left = 0, ix_right = 0
; ix_left < len_left && ix_right < len_right
; )
{
if (left[ix_left] < right[ix_right])
ix_left++;
else if (left[ix_left] > right[ix_right])
ix_right++;
else /* left[ix_left] == right[ix_right]) */
{
if (!bSubtract)
{
matches[pos[ix_left]] = MY_TRUE;
len_out++;
}
else
{
matches[pos[ix_left]] = MY_FALSE;
len_out--;
}
ix_left++;
}
}
/* Create the result: copy all flagged characters */
memsafe(result = alloc_mstring(len_out), len_out, "intersection result");
left_txt = get_txt((string_t *const)p_left);
result_txt = get_txt(result);
for (ix_left = 0, ix_right = 0; ix_left < len_left; ix_left++)
if (matches[ix_left])
result_txt[ix_right++] = left_txt[ix_left];
/* Free intermediate results */
xfree(pos);
xfree(matches);
xfree(left);
xfree(right);
return result;
} /* intersect_strings() */
svalue_t *
f_psyc_render(svalue_t *sp) {
uint8_t i;
vector_t *v;
string_t *out;
char *meth, *body;
size_t mlen, blen;
mapping_t *map;
psycPacket packet;
psycHeader headers[2];
// unless (sp->type == T_POINTER) return sp;
v = sp->u.vec;
if (VEC_SIZE(v) == PACKET_BODY + 1) {
for (i = PACKET_ROUTING; i <= PACKET_ENTITY; i++) {
headers[i].lines = 0;
if (v->item[i].type == T_MAPPING) {
map = v->item[i].u.map;
if (!MAP_SIZE(map)) continue;
headers[i].modifiers = malloc(sizeof(psycModifier) * MAP_SIZE(v->item[i].u.map));
if (!headers[i].modifiers) {
errorf("Out of memory in psyc_render for modifier table.\n");
return sp; // not reached
}
walk_mapping(map, &fill_header_from_mapping,
&(psyc_modifier_t) {
&headers[i], map->num_values,
i == PACKET_ROUTING ?
PSYC_MODIFIER_ROUTING :
PSYC_MODIFIER_CHECK_LENGTH
});
}
// else ... ignoring possibly invalid args
}
} else {
errorf("Wrong number of elements (%" PRIdMPINT ") "
"in array argument to psyc_render()\n", VEC_SIZE(v));
return sp; // not reached
}
if (v->item[PACKET_METHOD].type == T_STRING) {
meth = get_txt(v->item[PACKET_METHOD].u.str);
mlen = mstrsize(v->item[PACKET_METHOD].u.str);
} else {
meth = NULL;
mlen = 0;
}
if (v->item[PACKET_BODY].type == T_STRING) {
body = get_txt(v->item[PACKET_BODY].u.str);
blen = mstrsize(v->item[PACKET_BODY].u.str);
} else {
body = NULL;
blen = 0;
}
packet = psyc_newPacket2(headers[PACKET_ROUTING].modifiers,
headers[PACKET_ROUTING].lines,
headers[PACKET_ENTITY].modifiers,
headers[PACKET_ENTITY].lines,
meth, mlen, body, blen,
PSYC_PACKET_CHECK_LENGTH);
#ifdef DEBUG
printf("rendering... packet.length = %ld\n", packet.length);
#endif
// alloc_mstring creates an *untabled* string suitable for tmp data
memsafe(out = alloc_mstring(packet.length), packet.length, "f_psyc_render");
psyc_render(&packet, get_txt(out), packet.length);
free_svalue(sp);
put_string(sp, out);
// stack should take care of freeing the string after use
return sp;
} /* f_psyc_render */
