// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
/******************************************************************************
 *
 * Module Name: exconcat - Concatenate-type AML operators
 *
 * Copyright (C) 2000 - 2025, Intel Corp.
 *
 *****************************************************************************/

#include <acpi/acpi.h>
#include "accommon.h"
#include "acinterp.h"
#include "amlresrc.h"

#define _COMPONENT          ACPI_EXECUTER
ACPI_MODULE_NAME("exconcat")

/* Local Prototypes */
static acpi_status
acpi_ex_convert_to_object_type_string(union acpi_operand_object *obj_desc,
                                      union acpi_operand_object **result_desc);

/*******************************************************************************
 *
 * FUNCTION:    acpi_ex_do_concatenate
 *
 * PARAMETERS:  operand0            - First source object
 *              operand1            - Second source object
 *              actual_return_desc  - Where to place the return object
 *              walk_state          - Current walk state
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Concatenate two objects with the ACPI-defined conversion
 *              rules as necessary.
 * NOTE:
 * Per the ACPI spec (up to 6.1), Concatenate only supports Integer,
 * String, and Buffer objects. However, we support all objects here
 * as an extension. This improves the usefulness of both Concatenate
 * and the Printf/Fprintf macros. The extension returns a string
 * describing the object type for the other objects.
 * 02/2016.
 *
 ******************************************************************************/

acpi_status
acpi_ex_do_concatenate(union acpi_operand_object *operand0,
                       union acpi_operand_object *operand1,
                       union acpi_operand_object **actual_return_desc,
                       struct acpi_walk_state *walk_state)
{
        union acpi_operand_object *local_operand0 = operand0;
        union acpi_operand_object *local_operand1 = operand1;
        union acpi_operand_object *temp_operand1 = NULL;
        union acpi_operand_object *return_desc;
        char *buffer;
        acpi_object_type operand0_type;
        acpi_object_type operand1_type;
        acpi_status status;

        ACPI_FUNCTION_TRACE(ex_do_concatenate);

        /* Operand 0 preprocessing */

        switch (operand0->common.type) {
        case ACPI_TYPE_INTEGER:
        case ACPI_TYPE_STRING:
        case ACPI_TYPE_BUFFER:

                operand0_type = operand0->common.type;
                break;

        default:

                /* For all other types, get the "object type" string */

                status =
                    acpi_ex_convert_to_object_type_string(operand0,
                                                          &local_operand0);
                if (ACPI_FAILURE(status)) {
                        goto cleanup;
                }

                operand0_type = ACPI_TYPE_STRING;
                break;
        }

        /* Operand 1 preprocessing */

        switch (operand1->common.type) {
        case ACPI_TYPE_INTEGER:
        case ACPI_TYPE_STRING:
        case ACPI_TYPE_BUFFER:

                operand1_type = operand1->common.type;
                break;

        default:

                /* For all other types, get the "object type" string */

                status =
                    acpi_ex_convert_to_object_type_string(operand1,
                                                          &local_operand1);
                if (ACPI_FAILURE(status)) {
                        goto cleanup;
                }

                operand1_type = ACPI_TYPE_STRING;
                break;
        }

        /*
         * Convert the second operand if necessary. The first operand (0)
         * determines the type of the second operand (1) (See the Data Types
         * section of the ACPI specification). Both object types are
         * guaranteed to be either Integer/String/Buffer by the operand
         * resolution mechanism.
         */
        switch (operand0_type) {
        case ACPI_TYPE_INTEGER:

                status =
                    acpi_ex_convert_to_integer(local_operand1, &temp_operand1,
                                               ACPI_IMPLICIT_CONVERSION);
                break;

        case ACPI_TYPE_BUFFER:

                status =
                    acpi_ex_convert_to_buffer(local_operand1, &temp_operand1);
                break;

        case ACPI_TYPE_STRING:

                switch (operand1_type) {
                case ACPI_TYPE_INTEGER:
                case ACPI_TYPE_STRING:
                case ACPI_TYPE_BUFFER:

                        /* Other types have already been converted to string */

                        status =
                            acpi_ex_convert_to_string(local_operand1,
                                                      &temp_operand1,
                                                      ACPI_IMPLICIT_CONVERT_HEX);
                        break;

                default:

                        status = AE_OK;
                        break;
                }
                break;

        default:

                ACPI_ERROR((AE_INFO, "Invalid object type: 0x%X",
                            operand0->common.type));
                status = AE_AML_INTERNAL;
        }

        if (ACPI_FAILURE(status)) {
                goto cleanup;
        }

        /* Take care with any newly created operand objects */

        if ((local_operand1 != operand1) && (local_operand1 != temp_operand1)) {
                acpi_ut_remove_reference(local_operand1);
        }

        local_operand1 = temp_operand1;

        /*
         * Both operands are now known to be the same object type
         * (Both are Integer, String, or Buffer), and we can now perform
         * the concatenation.
         *
         * There are three cases to handle, as per the ACPI spec:
         *
         * 1) Two Integers concatenated to produce a new Buffer
         * 2) Two Strings concatenated to produce a new String
         * 3) Two Buffers concatenated to produce a new Buffer
         */
        switch (operand0_type) {
        case ACPI_TYPE_INTEGER:

                /* Result of two Integers is a Buffer */
                /* Need enough buffer space for two integers */

                return_desc = acpi_ut_create_buffer_object((acpi_size)
                                                           ACPI_MUL_2
                                                           (acpi_gbl_integer_byte_width));
                if (!return_desc) {
                        status = AE_NO_MEMORY;
                        goto cleanup;
                }

                buffer = (char *)return_desc->buffer.pointer;

                /* Copy the first integer, LSB first */

                memcpy(buffer, &operand0->integer.value,
                       acpi_gbl_integer_byte_width);

                /* Copy the second integer (LSB first) after the first */

                memcpy(buffer + acpi_gbl_integer_byte_width,
                       &local_operand1->integer.value,
                       acpi_gbl_integer_byte_width);
                break;

        case ACPI_TYPE_STRING:

                /* Result of two Strings is a String */

                return_desc = acpi_ut_create_string_object(((acpi_size)
                                                            local_operand0->
                                                            string.length +
                                                            local_operand1->
                                                            string.length));
                if (!return_desc) {
                        status = AE_NO_MEMORY;
                        goto cleanup;
                }

                buffer = return_desc->string.pointer;

                /* Concatenate the strings */

                strcpy(buffer, local_operand0->string.pointer);
                strcat(buffer, local_operand1->string.pointer);
                break;

        case ACPI_TYPE_BUFFER:

                /* Result of two Buffers is a Buffer */

                return_desc = acpi_ut_create_buffer_object(((acpi_size)
                                                            operand0->buffer.
                                                            length +
                                                            local_operand1->
                                                            buffer.length));
                if (!return_desc) {
                        status = AE_NO_MEMORY;
                        goto cleanup;
                }

                buffer = (char *)return_desc->buffer.pointer;

                /* Concatenate the buffers */

                memcpy(buffer, operand0->buffer.pointer,
                       operand0->buffer.length);
                memcpy(buffer + operand0->buffer.length,
                       local_operand1->buffer.pointer,
                       local_operand1->buffer.length);
                break;

        default:

                /* Invalid object type, should not happen here */

                ACPI_ERROR((AE_INFO, "Invalid object type: 0x%X",
                            operand0->common.type));
                status = AE_AML_INTERNAL;
                goto cleanup;
        }

        *actual_return_desc = return_desc;

cleanup:
        if (local_operand0 != operand0) {
                acpi_ut_remove_reference(local_operand0);
        }

        if (local_operand1 != operand1) {
                acpi_ut_remove_reference(local_operand1);
        }

        return_ACPI_STATUS(status);
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ex_convert_to_object_type_string
 *
 * PARAMETERS:  obj_desc            - Object to be converted
 *              return_desc         - Where to place the return object
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Convert an object of arbitrary type to a string object that
 *              contains the namestring for the object. Used for the
 *              concatenate operator.
 *
 ******************************************************************************/

static acpi_status
acpi_ex_convert_to_object_type_string(union acpi_operand_object *obj_desc,
                                      union acpi_operand_object **result_desc)
{
        union acpi_operand_object *return_desc;
        const char *type_string;

        type_string = acpi_ut_get_type_name(obj_desc->common.type);

        return_desc = acpi_ut_create_string_object(((acpi_size)strlen(type_string) + 9));       /* 9 For "[ Object]" */
        if (!return_desc) {
                return (AE_NO_MEMORY);
        }

        strcpy(return_desc->string.pointer, "[");
        strcat(return_desc->string.pointer, type_string);
        strcat(return_desc->string.pointer, " Object]");

        *result_desc = return_desc;
        return (AE_OK);
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ex_concat_template
 *
 * PARAMETERS:  operand0            - First source object
 *              operand1            - Second source object
 *              actual_return_desc  - Where to place the return object
 *              walk_state          - Current walk state
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Concatenate two resource templates
 *
 ******************************************************************************/

acpi_status
acpi_ex_concat_template(union acpi_operand_object *operand0,
                        union acpi_operand_object *operand1,
                        union acpi_operand_object **actual_return_desc,
                        struct acpi_walk_state *walk_state)
{
        acpi_status status;
        union acpi_operand_object *return_desc;
        u8 *new_buf;
        u8 *end_tag;
        acpi_size length0;
        acpi_size length1;
        acpi_size new_length;

        ACPI_FUNCTION_TRACE(ex_concat_template);

        /*
         * Find the end_tag descriptor in each resource template.
         * Note1: returned pointers point TO the end_tag, not past it.
         * Note2: zero-length buffers are allowed; treated like one end_tag
         */

        /* Get the length of the first resource template */

        status = acpi_ut_get_resource_end_tag(operand0, &end_tag);
        if (ACPI_FAILURE(status)) {
                return_ACPI_STATUS(status);
        }

        length0 = ACPI_PTR_DIFF(end_tag, operand0->buffer.pointer);

        /* Get the length of the second resource template */

        status = acpi_ut_get_resource_end_tag(operand1, &end_tag);
        if (ACPI_FAILURE(status)) {
                return_ACPI_STATUS(status);
        }

        length1 = ACPI_PTR_DIFF(end_tag, operand1->buffer.pointer);

        /* Combine both lengths, minimum size will be 2 for end_tag */

        new_length = length0 + length1 + sizeof(struct aml_resource_end_tag);

        /* Create a new buffer object for the result (with one end_tag) */

        return_desc = acpi_ut_create_buffer_object(new_length);
        if (!return_desc) {
                return_ACPI_STATUS(AE_NO_MEMORY);
        }

        /*
         * Copy the templates to the new buffer, 0 first, then 1 follows. One
         * end_tag descriptor is copied from Operand1.
         */
        new_buf = return_desc->buffer.pointer;
        memcpy(new_buf, operand0->buffer.pointer, length0);
        memcpy(new_buf + length0, operand1->buffer.pointer, length1);

        /* Insert end_tag and set the checksum to zero, means "ignore checksum" */

        new_buf[new_length - 1] = 0;
        new_buf[new_length - 2] = ACPI_RESOURCE_NAME_END_TAG | 1;

        /* Return the completed resource template */

        *actual_return_desc = return_desc;
        return_ACPI_STATUS(AE_OK);
}