#include "std.h"

#include "lpc_incl.h"

#include "comm.h"

#include "regexp.h"

#include "backend.h"

#include "qsort.h"

#include "md.h"

#include "efun_protos.h"

#ifdef ARRAY_STATS

int num_arrays;

int total_array_size;

INLINE_STATIC int builtin_sort_array_cmp_fwd PROT((svalue_t *, svalue_t *));

INLINE_STATIC int builtin_sort_array_cmp_rev PROT((svalue_t *, svalue_t *));

INLINE_STATIC int sort_array_cmp PROT((svalue_t *, svalue_t *));

#ifndef NO_ENVIRONMENT

static int deep_inventory_count PROT((object_t *));

static void deep_inventory_collect PROT((object_t *, array_t *, int *));

INLINE_STATIC int alist_cmp PROT((svalue_t *, svalue_t *));

array_t the_null_array =

{

1, /* Ref count, which will ensure that it will

#ifdef DEBUG

1, /* extra ref */

0, /* size */

};

#ifdef PACKAGE_MUDLIB_STATS

static void ms_setup_stats P1(array_t *, p) {

if (current_object) {

assign_stats(&p->stats, current_object);

add_array_size(&p->stats, p->size);

} else {

null_stats(&p->stats);

}

}

#define ms_remove_stats(p) add_array_size(&(p)->stats, -(int)((p)->size))

#define ms_add_array_size(p, n) add_array_size(p, n)

#define ms_setup_stats(x)

#define ms_remove_stats(x)

#define ms_add_array_size(p, n)

static array_t *int_allocate_empty_array P1(int, n) {

array_t *p;

#ifdef ARRAY_STATS

num_arrays++;

total_array_size += sizeof(array_t) + sizeof(svalue_t) * (n-1);

p = ALLOC_ARRAY(n);

p->ref = 1;

p->size = n;

ms_setup_stats(p);

return p;

}

array_t *allocate_empty_array P1(int, n)

{

if (n < 0 || n > max_array_size)

error("Illegal array size.\n");

if (!n) return &the_null_array;

return int_allocate_empty_array(n);

}

static array_t *int_allocate_array P1(int, n)

{

array_t *p = int_allocate_empty_array(n);

while (n--)

p->item[n] = const0;

return p;

}

array_t *allocate_array P1(int, n)

{

array_t *p = allocate_empty_array(n);

while (n--)

p->item[n] = const0;

return p;

}

array_t *allocate_array2 P2(int, n, svalue_t *, svp) {

int i;

array_t *ret;

if (svp->type == T_FUNCTION) {

ret = allocate_array(n);

for (i = 0; i < n; i++) {

svalue_t *r;

push_number(i);

r = call_function_pointer(svp->u.fp, 1);

ret->item[i] = *r;

r->type = T_NUMBER;

}

} else {

ret = allocate_empty_array(n);

for (i = 0; i < n; i++)

assign_svalue_no_free(ret->item + i, svp);

}

return ret;

}

static void dealloc_empty_array P1(array_t *, p) {

ms_remove_stats(p);

#ifdef ARRAY_STATS

num_arrays--;

total_array_size -= sizeof(array_t) + sizeof(svalue_t) *

(p->size - 1);

FREE((char *) p);

}

void dealloc_array P1(array_t *, p)

{

int i;

for (i = p->size; i--;)

free_svalue(&p->item[i], "free_array");

dealloc_empty_array(p);

}

void free_array P1(array_t *, p)

{

if (--(p->ref) > 0 || (p == &the_null_array))

return;

dealloc_array(p);

}

void free_empty_array P1(array_t *, p)

{

if ((--(p->ref) > 0) || (p == &the_null_array))

return;

dealloc_empty_array(p);

}

static array_t *fix_array P2(array_t *, p, int, n) {

#ifdef ARRAY_STATS

num_arrays++;

total_array_size += sizeof(array_t) + sizeof(svalue_t) * (n-1);

p->size = n;

p->ref = 1;

ms_setup_stats(p);

return RESIZE_ARRAY(p, n);

}

INLINE array_t *resize_array P2(array_t *, p, int, n) {

#ifdef ARRAY_STATS

total_array_size += (n - p->size) * sizeof(svalue_t);

ms_remove_stats(p);

p = RESIZE_ARRAY(p, n);

if (!p)

fatal("Out of memory.\n");

p->size = n;

ms_setup_stats(p);

return p;

}

array_t *explode_string P4(char *, str, int, slen, char *, del, int, len)

{

char *p, *beg, *lastdel = 0;

int num, j, limit;

array_t *ret;

char *buff, *tmp;

unsigned short sz;

if (!slen)

return &the_null_array;

/* return an array of length strlen(str) -w- one character per element */

if (len == 0) {

sz = 1;

if (slen > max_array_size) {

slen = max_array_size;

}

ret = int_allocate_empty_array(slen);

for (j = 0; j < slen; j++) {

ret->item[j].type = T_STRING;

ret->item[j].subtype = STRING_MALLOC;

ret->item[j].u.string = tmp = new_string(1, "explode_string: tmp");

tmp[0] = str[j];

tmp[1] = '\0';

}

return ret;

}

if (len == 1) {

char delimeter;

delimeter = *del;

#ifndef REVERSIBLE_EXPLODE_STRING

/*

while (*str == delimeter) {

str++;

slen--;

if (str[0] == '\0') {

return &the_null_array;

}

# ifdef SANE_EXPLODE_STRING

break;

}

/*

for (p = str, num = 0; *p;) {

if (*p == delimeter) {

num++;

lastdel = p;

}

p++;

}

/*

limit = max_array_size;

#ifdef REVERSIBLE_EXPLODE_STRING

num++;

limit--;

if (lastdel != (str + slen - 1)) {

num++;

limit--;

}

if (num > max_array_size) {

num = max_array_size;

}

ret = int_allocate_empty_array(num);

for (p = str, beg = str, num = 0; *p && (num < limit);) {

if (*p == delimeter) {

DEBUG_CHECK(num >= ret->size, "Index out of bounds in explode!\n");

sz = p - beg;

ret->item[num].type = T_STRING;

ret->item[num].subtype = STRING_MALLOC;

ret->item[num].u.string = buff = new_string(sz, "explode_string: buff");

strncpy(buff, beg, sz);

buff[sz] = '\0';

num++;

beg = ++p;

} else {

p++;

}

}

#ifdef REVERSIBLE_EXPLODE_STRING

ret->item[num].type = T_STRING;

ret->item[num].subtype = STRING_MALLOC;

ret->item[num].u.string = string_copy(beg, "explode_string: last, len == 1");

/* Copy last occurence, if there was not a 'del' at the end. */

if (*beg != '\0' && num != limit) {

ret->item[num].type = T_STRING;

ret->item[num].subtype = STRING_MALLOC;

ret->item[num].u.string = string_copy(beg, "explode_string: last, len == 1");

}

return ret;

} /* len == 1 */

#ifndef REVERSIBLE_EXPLODE_STRING

/*

while (strncmp(str, del, len) == 0) {

str += len;

slen -= len;

if (str[0] == '\0') {

return &the_null_array;

}

# ifdef SANE_EXPLODE_STRING

break;

}

/*

for (p = str, num = 0; *p;) {

if (strncmp(p, del, len) == 0) {

num++;

lastdel = p;

p += len;

} else {

p++;

}

}

/*

#ifdef REVERSIBLE_EXPLODE_STRING

num++;

if (lastdel != (str + slen - len)) {

num++;

}

if (num > max_array_size) {

num = max_array_size;

}

ret = int_allocate_empty_array(num);

limit = max_array_size - 1; /* extra element can be added after loop */

for (p = str, beg = str, num = 0; *p && (num < limit);) {

if (strncmp(p, del, len) == 0) {

if (num >= ret->size)

fatal("Index out of bounds in explode!\n");

ret->item[num].type = T_STRING;

ret->item[num].subtype = STRING_MALLOC;

ret->item[num].u.string = buff = new_string(p - beg,

"explode_string: buff");

strncpy(buff, beg, p - beg);

buff[p - beg] = '\0';

num++;

beg = p + len;

p = beg;

} else {

p++;

}

}

/* Copy last occurence, if there was not a 'del' at the end. */

#ifdef REVERSIBLE_EXPLODE_STRING

ret->item[num].type = T_STRING;

ret->item[num].subtype = STRING_MALLOC;

ret->item[num].u.string = string_copy(beg, "explode_string: last, len != 1");

if (*beg != '\0' && num != limit) {

ret->item[num].type = T_STRING;

ret->item[num].subtype = STRING_MALLOC;

ret->item[num].u.string = string_copy(beg, "explode_string: last, len != 1");

}

return ret;

}

char *implode_string P3(array_t *, arr, char *, del, int, del_len)

{

int size, i, num;

char *p, *q;

for (i = arr->size, size = 0, num = 0; i--;) {

if (arr->item[i].type == T_STRING) {

size += SVALUE_STRLEN(&arr->item[i]);

num++;

}

}

if (num == 0)

return string_copy("", "implode_string");

p = new_string(size + (num - 1) * del_len, "implode_string: p");

q = p;

for (i = 0, num = 0; i < arr->size; i++) {

if (arr->item[i].type == T_STRING) {

if (num) {

strncpy(p, del, del_len);

p += del_len;

}

size = SVALUE_STRLEN(&arr->item[i]);

strncpy(p, arr->item[i].u.string, size);

p += size;

num++;

}

}

*p = 0;

return q;

}

void implode_array P4(funptr_t *, fp, array_t *, arr,

svalue_t *, dest, int, first_on_stack) {

int i = 0, n;

svalue_t *v;

if (first_on_stack) {

if (!(n = arr->size)) {

*dest = *sp--;

return;

}

} else {

if (!(n = arr->size)) {

*dest = const0;

return;

} else if (n == 1) {

assign_svalue_no_free(dest, &arr->item[0]);

return;

}

}

if (!first_on_stack)

push_svalue(&arr->item[i++]);

while (1) {

push_svalue(&arr->item[i++]);

v = call_function_pointer(fp, 2);

if (!v) {

*dest = const0;

return;

}

if (i < n)

push_svalue(v);

else

break;

}

assign_svalue_no_free(dest, v);

}

array_t *users()

{

register object_t *ob;

int i, j;

array_t *ret;

#ifdef F_SET_HIDE

int display_hidden = 0;

if (num_hidden_users > 0) {

if (current_object->flags & O_HIDDEN) {

display_hidden = 1;

} else {

display_hidden = valid_hide(current_object);

}

}

ret = allocate_empty_array(num_user - (display_hidden ? 0 : num_hidden_users));

ret = allocate_empty_array(num_user);

for (i = j = 0; i < max_users; i++) {

if (!all_users[i]) {

continue;

}

ob = all_users[i]->ob;

#ifdef F_SET_HIDE

if (!display_hidden && (ob->flags & O_HIDDEN))

continue;

ret->item[j].type = T_OBJECT;

ret->item[j].u.ob = ob;

add_ref(ob, "users");

j++;

}

return ret;

}

array_t *slice_array P3(array_t *, p, int, from, int, to)

{

int cnt;

svalue_t *sv1, *sv2;

if (from < 0)

from = 0;

if (to >= p->size)

to = p->size - 1;

if (from > to) {

free_array(p);

return &the_null_array;

}

if (!(--p->ref)) {

if (from) {

sv1 = p->item + from;

cnt = from;

while (cnt--) free_svalue(--sv1, "slice_array:2");

cnt = to - from + 1;

sv1 = p->item;

sv2 = p->item + from;

while (cnt--) *sv1++ = *sv2++;

} else {

sv2 = p->item + to + 1;

}

cnt = (p->size - 1) - to;

while (cnt--) free_svalue(sv2++, "slice_array:3");

p = resize_array(p, to-from+1);

p->ref = 1;

return p;

} else {

array_t *d;

d = int_allocate_empty_array(to - from + 1);

sv1 = d->item - from;

sv2 = p->item;

for (cnt = from; cnt <= to; cnt++)

assign_svalue_no_free(sv1 + cnt, sv2 + cnt);

return d;

}

}

static array_t *copy_array P1(array_t *, p)

{

array_t *d;

int n;

svalue_t *sv1 = p->item, *sv2;

d = allocate_empty_array(n = p->size);

sv2 = d->item;

while (n--)

assign_svalue_no_free(sv2 + n, sv1 + n);

return d;

}

#ifdef F_COMMANDS

array_t *commands P1(object_t *, ob)

{

sentence_t *s;

array_t *v, *p;

int cnt = 0;

svalue_t *sv;

for (s = ob->sent; s && s->verb; s = s->next) {

if (++cnt == max_array_size) break;

}

v = allocate_empty_array(cnt);

sv = v->item;

for (s = ob->sent; cnt-- && s && s->verb; s = s->next) {

sv->type = T_ARRAY;

(sv++)->u.arr = p = int_allocate_empty_array(4);

p->item[0].type = T_STRING;

p->item[0].u.string = ref_string(s->verb); /* the verb is shared */

p->item[0].subtype = STRING_SHARED;

p->item[1].type = T_NUMBER;

p->item[1].u.number = s->flags;

p->item[2].type = T_OBJECT;

p->item[2].u.ob = s->ob;

p->item[3].type = T_STRING;

if (s->flags & V_FUNCTION) {

p->item[3].u.string = "<function>";

p->item[3].subtype = STRING_CONSTANT;

} else {

p->item[3].u.string = ref_string(s->function.s);

p->item[3].subtype = STRING_SHARED;

}

add_ref(s->ob, "commands");

}

return v;

}

#ifdef F_FILTER

filter_array P2(svalue_t *, arg, int, num_arg)

{

array_t *vec = arg->u.arr, *r;

int size;

if ((size = vec->size) < 1) {

pop_n_elems(num_arg - 1);

return;

}

else {

char *flags;

svalue_t *v;

int res = 0, cnt;

function_to_call_t ftc;

process_efun_callback(1, &ftc, F_FILTER);

flags = new_string(size, "TEMP: filter: flags");

push_malloced_string(flags);

for (cnt = 0; cnt < size; cnt++) {

push_svalue(vec->item + cnt);

v = call_efun_callback(&ftc, 1);

if (!IS_ZERO(v)) {

flags[cnt] = 1;

res++;

} else

flags[cnt] = 0;

}

r = allocate_empty_array(res);

if (res) {

while (cnt--) {

if (flags[cnt])

assign_svalue_no_free(&r->item[--res], vec->item+cnt);

}

}

FREE_MSTR(flags);

sp--;

pop_n_elems(num_arg - 1);

free_array(vec);

sp->u.arr = r;

}

}

filter_string P2(svalue_t *, arg, int, num_arg)

{

if (arg->u.string[0] == 0) {

pop_n_elems(num_arg - 1);

return;

}

else {

int size;

svalue_t *v;

int idx = 0, cnt;

function_to_call_t ftc;

char *str;

unlink_string_svalue(arg);

size = SVALUE_STRLEN(arg);

str = arg->u.string;

process_efun_callback(1, &ftc, F_FILTER);

for (cnt = 0; cnt < size; cnt++) {

push_number(str[cnt]);

v = call_efun_callback(&ftc, 1);

if (!IS_ZERO(v))

str[idx++] = str[cnt];

}

if (idx != cnt)

arg->u.string = extend_string(arg->u.string, idx);

pop_n_elems(num_arg - 1);

}

}

int sameval P2(svalue_t *, arg1, svalue_t *, arg2)

{

DEBUG_CHECK(!arg1 || !arg2, "Null pointer passed to sameval.\n");

switch (arg1->type | arg2->type) {

case T_NUMBER:

return arg1->u.number == arg2->u.number;

case T_ARRAY:

case T_CLASS:

return arg1->u.arr == arg2->u.arr;

case T_STRING:

if (SVALUE_STRLEN_DIFFERS(arg1, arg2)) return 0;

return !strcmp(arg1->u.string, arg2->u.string);

case T_OBJECT:

return arg1->u.ob == arg2->u.ob;

case T_MAPPING:

return arg1->u.map == arg2->u.map;

case T_FUNCTION:

return arg1->u.fp == arg2->u.fp;

case T_REAL:

return arg1->u.real == arg2->u.real;

#ifndef NO_BUFFER_TYPE

case T_BUFFER:

return arg1->u.buf == arg2->u.buf;

}

return 0;

}

#ifdef F_UNIQUE_ARRAY

typedef struct unique_s {

} unique_t;

typedef struct unique_list_s {

unique_t *head;

struct unique_list_s *next;

} unique_list_t;

static unique_list_t *g_u_list = 0;

static void unique_array_error_handler PROT((void)) {

unique_list_t *unlist = g_u_list;

unique_t *uptr = unlist->head, *nptr;

g_u_list = g_u_list->next;

while (uptr) {

nptr = uptr->next;

FREE((char *) uptr->indices);

free_svalue(&uptr->mark, "unique_array_error_handler");

FREE((char *) uptr);

uptr = nptr;

}

FREE((char *)unlist);

}

void f_unique_array PROT((void)) {

array_t *v, *ret;

int size, i, numkeys = 0, *ind, num_arg = st_num_arg;

svalue_t *skipval, *sv, *svp;

unique_list_t *unlist;

unique_t **head, *uptr, *nptr;

funptr_t *fp = 0;

char *func;

size = (v = (sp - num_arg + 1)->u.arr)->size;

if (!size) {

if (num_arg == 3) free_svalue(sp--, "f_unique_array");

free_svalue(sp--, "f_unique_array");

return;

}

if (num_arg == 3) {

skipval = sp;

if ((sp-1)->type == T_FUNCTION) fp = (sp-1)->u.fp;

else func = (sp-1)->u.string;

}

else {

skipval = &const0;

if (sp->type == T_FUNCTION) fp = sp->u.fp;

else func = sp->u.string;

}

unlist = ALLOCATE(unique_list_t, TAG_TEMPORARY, "f_unique_array:1");

unlist->next = g_u_list;

unlist->head = 0;

head = &unlist->head;

g_u_list = unlist;

STACK_INC;

sp->type = T_ERROR_HANDLER;

sp->u.error_handler = unique_array_error_handler;

for (i = 0; i < size; i++) {

if (fp) {

push_svalue(v->item + i);

sv = call_function_pointer(fp, 1);

} else if ((v->item + i)->type == T_OBJECT) {

sv = apply(func, (v->item + i)->u.ob, 0, ORIGIN_EFUN);

} else sv = 0;

if (sv && !sameval(sv, skipval)) {

uptr = *head;

while (uptr) {

if (sameval(sv, &uptr->mark)) {

uptr->indices = RESIZE(uptr->indices, uptr->count + 1, int,

TAG_TEMPORARY, "f_unique_array:2");

uptr->indices[uptr->count++] = i;

break;

}

uptr = uptr->next;

}

if (!uptr) {

numkeys++;

uptr = ALLOCATE(unique_t, TAG_TEMPORARY, "f_unique_array:3");

uptr->indices = ALLOCATE(int, TAG_TEMPORARY, "f_unique_array:4");

uptr->count = 1;

uptr->indices[0] = i;

uptr->next = *head;

assign_svalue_no_free(&uptr->mark, sv);

*head = uptr;

}

}

}

ret = allocate_empty_array(numkeys);

uptr = *head;

svp = v->item;

while (numkeys--) {

nptr = uptr->next;

(sv = ret->item + numkeys)->type = T_ARRAY;

sv->u.arr = allocate_empty_array(i = uptr->count);

skipval = sv->u.arr->item + i;

ind = uptr->indices;

while (i--) {

assign_svalue_no_free(--skipval, svp + ind[i]);

}

FREE((char *)ind);

free_svalue(&uptr->mark, "f_unique_array");

FREE((char *)uptr);

uptr = nptr;

}

unlist = g_u_list->next;

FREE((char *)g_u_list);

g_u_list = unlist;

sp--;

pop_n_elems(num_arg - 1);

free_array(v);

sp->u.arr = ret;

}

array_t *add_array P2(array_t *, p, array_t *, r)

{

int cnt, res;

array_t *d; /* destination */

/*

if (p->size == 0) {

p->ref--;

return r->ref > 1 ? (r->ref--, copy_array(r)) : r;

}

if (r->size == 0) {

r->ref--;

return p->ref > 1 ? (p->ref--, copy_array(p)) : p;

}

res = p->size + r->size;

if (res < 0 || res > max_array_size)

error("result of array addition is greater than maximum array size.\n");

/* x += x */

if ((p == r) && (p->ref == 2)) {

int osize = p->size;

p->ref = 1;

d = resize_array(p, res);

/* copy myself */

for (cnt = osize; cnt--; )

assign_svalue_no_free(&d->item[--res], &d->item[cnt]);

return d;

}

/* transfer svalues for ref 1 target array */

if (p->ref == 1) {

d = resize_array(p, res);

/* note that d->ref is already 1, which is right */

} else {

d = int_allocate_empty_array(res);

for (cnt = p->size; cnt--;)

assign_svalue_no_free(&d->item[cnt], &p->item[cnt]);

p->ref--;

}

/* transfer svalues from ref 1 source array */

if (r->ref == 1) {

for (cnt = r->size; cnt--;)

d->item[--res] = r->item[cnt];

dealloc_empty_array(r);

} else {

for (cnt = r->size; cnt--;)

assign_svalue_no_free(&d->item[--res], &r->item[cnt]);

r->ref--;

}

return d;

}

#ifndef NO_ENVIRONMENT

array_t *all_inventory P2(object_t *, ob, int, override)

{

array_t *d;

object_t *cur;

int cnt, res;

int display_hidden;

if (override) {

display_hidden = 1;

} else {

display_hidden = -1;

}

cnt = 0;

for (cur = ob->contains; cur; cur = cur->next_inv) {

#ifdef F_SET_HIDE

if (cur->flags & O_HIDDEN) {

if (display_hidden == -1) {

display_hidden = valid_hide(current_object);

}

if (display_hidden)

cnt++;

} else

cnt++;

}

if (!cnt)

return &the_null_array;

d = int_allocate_empty_array(cnt);

cur = ob->contains;

for (res = 0; res < cnt; res++) {

#ifdef F_SET_HIDE

if ((cur->flags & O_HIDDEN) && !display_hidden) {

cur = cur->next_inv;

res--;

continue;

}

d->item[res].type = T_OBJECT;

d->item[res].u.ob = cur;

add_ref(cur, "all_inventory");

cur = cur->next_inv;

}

return d;

}

#ifdef F_MAP

map_array P2(svalue_t *, arg, int, num_arg)

{

array_t *arr = arg->u.arr;

array_t *r;