/* Copyright (C) 2001-2026 Artifex Software, Inc.

   All Rights Reserved.

   This software is provided AS-IS with no warranty, either express or

   implied.

   This software is distributed under license and may not be copied,

   modified or distributed except as expressly authorized under the terms

   of the license contained in the file LICENSE in this distribution.

   Refer to licensing information at http://www.artifex.com or contact

   Artifex Software, Inc.,  39 Mesa Street, Suite 108A, San Francisco,

   CA 94129, USA, for further information.

*/

/* Array/string/dictionary generic operators for PostScript */

#include "memory_.h"

#include "ghost.h"

#include "gsstruct.h"   /* for st_bytes */

#include "oper.h"

#include "dstack.h"   /* for systemdict */

#include "estack.h"   /* for forall */

#include "iddict.h"

#include "iname.h"

#include "ipacked.h"

#include "ivmspace.h"

#include "store.h"

/* This file implements copy, get, put, getinterval, putinterval, */

/* length, and forall, which apply generically to */

/* arrays, strings, and dictionaries.  (Copy also has a special */

/* meaning for copying the top N elements of the stack.) */

/* See the comment in opdef.h for an invariant which allows */

/* more efficient implementation of forall. */

/* Forward references */

static int zcopy_integer(i_ctx_t *);

static int zcopy_interval(i_ctx_t *);

static int copy_interval(i_ctx_t *, os_ptr, uint, os_ptr, client_name_t);

/* <various1> <various2> copy <various> */

/* <obj1> ... <objn> <int> copy <obj1> ... <objn> <obj1> ... <objn> */

/* Note that this implements copy for arrays and strings, */

/* but not for dictionaries (see zcopy_dict in zdict.c). */

int

zcopy(i_ctx_t *i_ctx_p)

{

    os_ptr op = osp;

    int type;

    check_op(1);

    type = r_type(op);

    if (type == t_integer)

        return zcopy_integer(i_ctx_p);

    check_op(2);

    switch (type) {

        case t_array:

        case t_string:

            return zcopy_interval(i_ctx_p);

        case t_dictionary:

            return zcopy_dict(i_ctx_p);

        default:

            return_op_typecheck(op);

    }

}

/* <obj1> ... <objn> <int> copy <obj1> ... <objn> <obj1> ... <objn> */

static int

zcopy_integer(i_ctx_t *i_ctx_p)

{

    os_ptr op = osp;

    os_ptr op1 = op - 1;

    int count, i;

    int code;

    if ((uint) op->value.intval > (uint)(op - osbot)) {

        /* There might be enough elements in other blocks. */

        check_type(*op, t_integer);

        if (op->value.intval >= (int)ref_stack_count(&o_stack))

            return_error(gs_error_stackunderflow);

        if (op->value.intval < 0)

            return_error(gs_error_rangecheck);

        check_int_ltu(*op, ref_stack_count(&o_stack));

        count = op->value.intval;

    } else if (op1 + (count = op->value.intval) <= ostop) {

        /* Fast case. */

        memcpy((char *)op, (char *)(op - count), count * sizeof(ref));

        push(count - 1);

        return 0;

    }

    /* Do it the slow, general way. */

    code = ref_stack_push(&o_stack, count - 1);

    if (code < 0)

        return code;

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

        ref *o = ref_stack_index(&o_stack, i);

        ref *o1 = ref_stack_index(&o_stack, i + count);

        if (o == NULL || o1 == NULL)

            return_error(gs_error_stackunderflow);

        *o = *o1;

    }

    return 0;

}

/* <array1> <array2> copy <subarray2> */

/* <string1> <string2> copy <substring2> */

static int

zcopy_interval(i_ctx_t *i_ctx_p)

{

    os_ptr op = osp;

    os_ptr op1 = op - 1;

    int code = copy_interval(i_ctx_p, op, 0, op1, "copy");

    if (code < 0)

        return code;

    r_set_size(op, r_size(op1));

    *op1 = *op;

    pop(1);

    return 0;

}

/* <array|dict|name|packedarray|string> length <int> */

static int

zlength(i_ctx_t *i_ctx_p)

{

    os_ptr op = osp;

    check_op(1);

    switch (r_type(op)) {

        case t_array:

        case t_string:

        case t_mixedarray:

        case t_shortarray:

            check_read(*op);

            make_int(op, r_size(op));

            return 0;

        case t_dictionary:

            check_dict_read(*op);

            make_int(op, dict_length(op));

            return 0;

        case t_name: {

            ref str;

            name_string_ref(imemory, op, &str);

            make_int(op, r_size(&str));

            return 0;

        }

        case t_astruct:

            if (gs_object_type(imemory, op->value.pstruct) != &st_bytes)

                return_error(gs_error_typecheck);

            check_read(*op);

            make_int(op, gs_object_size(imemory, op->value.pstruct));

            return 0;

        default:

            return_op_typecheck(op);

    }

}

/* <array|packedarray|string> <index> get <obj> */

/* <dict> <key> get <obj> */

static int

zget(i_ctx_t *i_ctx_p)

{

    int code;

    os_ptr op = osp;

    os_ptr op1 = op - 1;

    ref *pvalue;

    check_op(2);

    switch (r_type(op1)) {

        case t_dictionary:

            check_dict_read(*op1);

            if (dict_find(op1, op, &pvalue) <= 0)

                return_error(gs_error_undefined);

            op[-1] = *pvalue;

            break;

        case t_string:

            check_read(*op1);

            check_int_ltu(*op, r_size(op1));

            make_int(op1, op1->value.bytes[(uint) op->value.intval]);

            break;

        case t_array:

        case t_mixedarray:

        case t_shortarray:

            check_type(*op, t_integer);

            check_read(*op1);

            code = array_get(imemory, op1, op->value.intval, op1);

            if (code < 0)

                return code;

            break;

        case t__invalid:

            return_error(gs_error_stackunderflow);

        default:

            return_error(gs_error_typecheck);

    }

    pop(1);

    return 0;

}

/* <array> <index> <obj> put - */

/* <dict> <key> <value> put - */

/* <string> <index> <int> put - */

static int

zput(i_ctx_t *i_ctx_p)

{

    os_ptr op = osp;

    os_ptr op1 = op - 1;

    os_ptr op2 = op1 - 1;

    byte *sdata;

    uint ssize;

    check_op(3);

    switch (r_type(op2)) {

        case t_dictionary:

            check_dict_write(*op2);

            {

                int code = idict_put(op2, op1, op);

                if (code < 0)

                    return code; /* error */

            }

            break;

        case t_array:

            check_write(*op2);

            check_int_ltu(*op1, r_size(op2));

            store_check_dest(op2, op);

            {

                ref *eltp = op2->value.refs + (uint) op1->value.intval;

                ref_assign_old(op2, eltp, op, "put");

            }

            break;

        case t_mixedarray:  /* packed arrays are read-only */

        case t_shortarray:

            return_error(gs_error_invalidaccess);

        case t_string:

            sdata = op2->value.bytes;

            ssize = r_size(op2);

str:      check_write(*op2);

            check_int_ltu(*op1, ssize);

            check_int_leu(*op, 0xff);

            sdata[(uint)op1->value.intval] = (byte)op->value.intval;

            break;

        case t_astruct:

            if (gs_object_type(imemory, op2->value.pstruct) != &st_bytes)

                return_error(gs_error_typecheck);

            sdata = r_ptr(op2, byte);

            ssize = gs_object_size(imemory, op2->value.pstruct);

            goto str;

        default:

            return_op_typecheck(op2);

    }

    pop(3);

    return 0;

}

/* <seq:array|packedarray|string> <index> <count> getinterval <subseq> */

static int

zgetinterval(i_ctx_t *i_ctx_p)

{

    os_ptr op = osp;

    os_ptr op1 = op - 1;

    os_ptr op2 = op1 - 1;

    uint index;

    uint count;

    check_op(3);

    switch (r_type(op2)) {

        default:

            return_op_typecheck(op2);

        case t_array:

        case t_string:

        case t_mixedarray:

        case t_shortarray:;

    }

    check_read(*op2);

    check_int_leu(*op1, r_size(op2));

    index = op1->value.intval;

    check_int_leu(*op, r_size(op2) - index);

    count = op->value.intval;

    switch (r_type(op2)) {

        case t_array:

            op2->value.refs += index;

            break;

        case t_string:

            op2->value.bytes += index;

            break;

        case t_mixedarray: {

            const ref_packed *packed = op2->value.packed;

            for (; index--;)

                packed = packed_next(packed);

            op2->value.packed = packed;

            break;

        }

        case t_shortarray:

            op2->value.packed += index;

            break;

    }

    r_set_size(op2, count);

    pop(2);

    return 0;

}

/* <array1> <index> <array2|packedarray2> putinterval - */

/* <string1> <index> <string2> putinterval - */

/* <bytestring1> <index> <string2> putinterval - */

static int

zputinterval(i_ctx_t *i_ctx_p)

{

    os_ptr op = osp;

    os_ptr opindex = op - 1;

    os_ptr opto = opindex - 1;

    int code;

    check_op(3);

    switch (r_type(opto)) {

        default:

            return_error(gs_error_typecheck);

        case t__invalid:

            if (r_type(op) != t_array && r_type(op) != t_string && r_type(op) != t__invalid)

                return_error(gs_error_typecheck); /* to match Distiller */

            else

                return_error(gs_error_stackunderflow);

        case t_mixedarray:

        case t_shortarray:

            return_error(gs_error_invalidaccess);

        case t_array:

        case t_string:

            check_write(*opto);

            check_int_leu(*opindex, r_size(opto));

            code = copy_interval(i_ctx_p, opto, (uint)(opindex->value.intval),

                                 op, "putinterval");

            break;

        case t_astruct: {

            uint dsize, ssize, index;

            check_write(*opto);

            if (gs_object_type(imemory, opto->value.pstruct) != &st_bytes)

                return_error(gs_error_typecheck);

            dsize = gs_object_size(imemory, opto->value.pstruct);

            check_int_leu(*opindex, dsize);

            index = (uint)opindex->value.intval;

            check_read_type(*op, t_string);

            ssize = r_size(op);

            if (ssize > dsize - index)

                return_error(gs_error_rangecheck);

            memcpy(r_ptr(opto, byte) + index, op->value.const_bytes, ssize);

            code = 0;

            break;

        }

    }

    if (code >= 0)

        pop(3);

    return code;

}

/*  <dict> <name> <string> .putgstringcopy - */

static int

zputgstringcopy(i_ctx_t *i_ctx_p)

{

    os_ptr op = osp;

    byte *sbody;

    uint size;

    int code;

    avm_space cs = ialloc_space(idmemory);

    avm_space ds = r_space((op - 2));

    avm_space ss = r_space(op);

    /* first, check our operands */

    check_op(3);

    check_read_type(*op, t_string);

    check_type(*(op - 1), t_name);

    check_type(*(op - 2), t_dictionary);

    /* If the string and the dictionary differ in globalness... */

    if (ss != ds) {

        size = r_size(op);

        ialloc_set_space(idmemory, ds);

        sbody = ialloc_string(size, "string");

        if (sbody == 0) {

            ialloc_set_space(idmemory, cs);

            return_error(gs_error_VMerror);

        }

        memcpy(sbody, op->value.bytes, size);

        make_string(op, a_all | icurrent_space, size, sbody);

    }

    /* use dict_put() directly here, because we want to return

       the VM space back before we return in the event of an error

     */

    code = dict_put(op - 2, op - 1, op, &(i_ctx_p->dict_stack));

    /* put the space back how it was */

    if (ss != ds)

        ialloc_set_space(idmemory, cs);

    if (code < 0)

        return code;

    pop(3);

    return 0;

}

/* <array|packedarray|string> <<element> proc> forall - */

/* <dict> <<key> <value> proc> forall - */

static int

    array_continue(i_ctx_t *),

    dict_continue(i_ctx_t *),

    string_continue(i_ctx_t *),

    packedarray_continue(i_ctx_t *);

static int forall_cleanup(i_ctx_t *);

static int

zforall(i_ctx_t *i_ctx_p)

{

    os_ptr op = osp;

    os_ptr obj = op - 1;

    es_ptr ep;

    es_ptr cproc;

    check_estack(6);

    /* check_estack() could cause the exec stack to be copied to a new block

     * so don't caulculate ep and things based on ep until *after* the check

     */

    ep = esp;

    cproc = ep + 4;

    check_proc(*op);

    switch (r_type(obj)) {

        default:

            return_op_typecheck(obj);

        case t_array:

            check_read(*obj);

            make_op_estack(cproc, array_continue);

            break;

        case t_dictionary:

            check_dict_read(*obj);

            make_int(cproc, dict_first(obj));

            ++cproc;

            make_op_estack(cproc, dict_continue);

            break;

        case t_string:

            check_read(*obj);

            make_op_estack(cproc, string_continue);

            break;

        case t_mixedarray:

        case t_shortarray:

            check_read(*obj);

            make_op_estack(cproc, packedarray_continue);

            break;

    }

    /*

     * Push:

     *   - a mark;

     *   - the composite object;

     *   - the procedure;

     *   - the iteration index (only for dictionaries, done above);

     * and invoke the continuation operator.

     */

    make_mark_estack(ep + 1, es_for, forall_cleanup);

    ep[2] = *obj;

    ep[3] = *op;

    esp = cproc - 1;

    ref_stack_pop(&o_stack, 2);

    return (*real_opproc(cproc))(i_ctx_p);

}

/* Continuation operator for arrays */

static int

array_continue(i_ctx_t *i_ctx_p)

{

    os_ptr op = osp;

    es_ptr obj = esp - 1;

    if (r_size(obj)) {   /* continue */

        push(1);

        r_dec_size(obj, 1);

        *op = *obj->value.refs;

        obj->value.refs++;

        esp += 2;

        *esp = obj[1];

        return o_push_estack;

    } else {     /* done */

        esp -= 3;    /* pop mark, object, proc */

        return o_pop_estack;

    }

}

/* Continuation operator for dictionaries */

static int

dict_continue(i_ctx_t *i_ctx_p)

{

    os_ptr op = osp;

    es_ptr obj = esp - 2;

    int index = esp->value.intval;

    if (r_type(obj) != t_dictionary)

        return_error(gs_error_typecheck);

    push(2);     /* make room for key and value */

    if ((index = dict_next(obj, index, op - 1)) >= 0) { /* continue */

        esp->value.intval = index;

        esp += 2;

        *esp = obj[1];

        return o_push_estack;

    } else {     /* done */

        pop(2);      /* undo push */

        esp -= 4;    /* pop mark, object, proc, index */

        return o_pop_estack;

    }

}

/* Continuation operator for strings */

static int

string_continue(i_ctx_t *i_ctx_p)

{

    os_ptr op = osp;

    es_ptr obj = esp - 1;

    if (r_size(obj)) {   /* continue */

        push(1);    /* check for result space on stack BEFORE changing string size */

        r_dec_size(obj, 1); /* Bug 701550 :-O */

        make_int(op, *obj->value.bytes);

        obj->value.bytes++;

        esp += 2;

        *esp = obj[1];

        return o_push_estack;

    } else {     /* done */

        esp -= 3;    /* pop mark, object, proc */

        return o_pop_estack;

    }

}

/* Continuation operator for packed arrays */

static int

packedarray_continue(i_ctx_t *i_ctx_p)

{

    os_ptr op = osp;

    es_ptr obj = esp - 1;

    if (r_size(obj)) {   /* continue */

        const ref_packed *packed = obj->value.packed;

        push(1);

        r_dec_size(obj, 1);

        packed_get(imemory, packed, op);

        obj->value.packed = packed_next(packed);

        esp += 2;

        *esp = obj[1];

        return o_push_estack;

    } else {     /* done */

        esp -= 3;    /* pop mark, object, proc */

        return o_pop_estack;

    }

}

/* Vacuous cleanup procedure */

static int

forall_cleanup(i_ctx_t *i_ctx_p)

{

    return 0;

}

/* ------ Initialization procedure ------ */

const op_def zgeneric_op_defs[] =

{

    {"1copy", zcopy},

    {"2forall", zforall},

    {"2get", zget},

    {"3getinterval", zgetinterval},

    {"1length", zlength},

    {"3put", zput},

    {"3putinterval", zputinterval},

    {"3.putgstringcopy", zputgstringcopy},

                /* Internal operators */

    {"0%array_continue", array_continue},

    {"0%dict_continue", dict_continue},

    {"0%packedarray_continue", packedarray_continue},

    {"0%string_continue", string_continue},

    op_def_end(0)

};

/* ------ Shared routines ------ */

/* Copy an interval from one operand to another. */

/* This is used by both putinterval and string/array copy. */

/* The destination is known to be an array or string, */

/* and the starting index is known to be less than or equal to */

/* its length; nothing else has been checked. */

static int

copy_interval(i_ctx_t *i_ctx_p /* for ref_assign_old */, os_ptr prto,

              uint index, os_ptr prfrom, client_name_t cname)

{

    int fromtype = r_type(prfrom);

    uint fromsize = r_size(prfrom);

    if (!(fromtype == r_type(prto) ||

          ((fromtype == t_shortarray || fromtype == t_mixedarray) &&

           r_type(prto) == t_array))

        )

        return_op_typecheck(prfrom);

    check_read(*prfrom);

    check_write(*prto);

    if (fromsize > r_size(prto) - index)

        return_error(gs_error_rangecheck);

    switch (fromtype) {

        case t_array:

            {     /* We have to worry about aliasing, */

                /* but refcpy_to_old takes care of it for us. */

                return refcpy_to_old(prto, index, prfrom->value.refs,

                                     fromsize, idmemory, cname);

            }

        case t_string:

            { /* memmove takes care of aliasing. */

                memmove(prto->value.bytes + index, prfrom->value.bytes,

                        fromsize);

            }

            break;

        case t_mixedarray:

        case t_shortarray:

            { /* We don't have to worry about aliasing, because */

                /* packed arrays are read-only and hence the destination */

                /* can't be a packed array. */

                uint i;

                const ref_packed *packed = prfrom->value.packed;

                ref *pdest = prto->value.refs + index;

                ref elt;

                for (i = 0; i < fromsize; i++, pdest++) {

                    packed_get(imemory, packed, &elt);

                    ref_assign_old(prto, pdest, &elt, cname);

                    packed = packed_next(packed);

                }

            }

            break;

    }

    return 0;

}