/* composite.c - Handles GS1 Composite Symbols */
/*
    libzint - the open source barcode library
    Copyright (C) 2008-2026 Robin Stuart <rstuart114@gmail.com>

    Redistribution and use in source and binary forms, with or without
    modification, are permitted provided that the following conditions
    are met:

    1. Redistributions of source code must retain the above copyright
       notice, this list of conditions and the following disclaimer.
    2. Redistributions in binary form must reproduce the above copyright
       notice, this list of conditions and the following disclaimer in the
       documentation and/or other materials provided with the distribution.
    3. Neither the name of the project nor the names of its contributors
       may be used to endorse or promote products derived from this software
       without specific prior written permission.

    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
    ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
    ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
    FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
    DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
    OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
    HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
    LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
    OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
    SUCH DAMAGE.
 */
/* SPDX-License-Identifier: BSD-3-Clause */

/* The functions "getBit", "init928" and "encode928" are Copyright (C) 2006 BSI and are
   released with permission under the following terms:

   "Copyright subsists in all BSI publications. BSI also holds the copyright, in the
   UK, of the international standardisation bodies. Except as
   permitted under the Copyright, Designs and Patents Act 1988 no extract may be
   reproduced, stored in a retrieval system or transmitted in any form or by any
   means - electronic, photocopying, recording or otherwise - without prior written
   permission from BSI.

   "This does not preclude the free use, in the course of implementing the standard,
   of necessary details such as symbols, and size, type or grade designations. If these
   details are to be used for any other purpose than implementation then the prior
   written permission of BSI must be obtained."

   The date of publication for these functions is 31 May 2006
 */

#include <assert.h>
#include <math.h>
#include <stdio.h>
#include "common.h"
#include "pdf417.h"
#include "gs1.h"
#include "general_field.h"

#include "composite.h"

INTERNAL int zint_gs1_128_cc(struct zint_symbol *symbol, unsigned char source[], int length, const int cc_mode,
                const int cc_rows);

INTERNAL int zint_eanx_cc(struct zint_symbol *symbol, unsigned char source[], int length, const int cc_rows);
INTERNAL int zint_ean_leading_zeroes(struct zint_symbol *symbol, const unsigned char source[], const int length,
                unsigned char local_source[], int *p_with_addon, unsigned char *zfirst_part,
                unsigned char *zsecond_part);

INTERNAL int zint_dbar_stk_set_height(struct zint_symbol *symbol, const int first_row, const int no_errtxt);
INTERNAL int zint_dbar_omn_cc(struct zint_symbol *symbol, unsigned char source[], int length, const int cc_rows);
INTERNAL int zint_dbar_ltd_cc(struct zint_symbol *symbol, unsigned char source[], int length, const int cc_rows);
INTERNAL int zint_dbar_exp_cc(struct zint_symbol *symbol, unsigned char source[], int length, const int cc_rows);
INTERNAL int zint_dbar_exp_date(const unsigned char source[], const int length, const int position);

INTERNAL int zint_micropdf_variant(const int cols, const int mclength);

static int cc_min(const int first, const int second) {

    if (first <= second)
        return first;
    else
        return second;
}

/* Gets bit in bitString at bitPos */
static int cc_getBit(const unsigned short *bitStr, const int bitPos) {
    return !!(bitStr[bitPos >> 4] & (0x8000 >> (bitPos & 15)));
}

/* Converts bit string to base 928 values, codeWords[0] is highest order */
static int cc_encode928(const unsigned short bitString[], unsigned short codeWords[], const int bitLng) {
    int i, j, b, cwNdx, cwLng;
    for (cwNdx = cwLng = b = 0; b < bitLng; b += 69, cwNdx += 7) {
        const int bitCnt = cc_min(bitLng - b, 69);
        int cwCnt;
        cwLng += cwCnt = bitCnt / 10 + 1;
        for (i = 0; i < cwCnt; i++)
            codeWords[cwNdx + i] = 0; /* init 0 */
        for (i = 0; i < bitCnt; i++) {
            if (cc_getBit(bitString, b + bitCnt - i - 1)) {
                for (j = 0; j < cwCnt; j++)
                    codeWords[cwNdx + j] += cc_pwr928[i][j + 7 - cwCnt];
            }
        }
        for (i = cwCnt - 1; i > 0; i--) {
            /* Add "carries" */
            codeWords[cwNdx + i - 1] += codeWords[cwNdx + i] / 928;
            codeWords[cwNdx + i] %= 928;
        }
    }
    return (cwLng);
}

/* CC-A 2D component */
static void cc_a(struct zint_symbol *symbol, const char source[], const int cc_width) {
    int i, j, bitlen, cwCnt, ecc_cwds, variant;
    int offset, rsCodeWords[8] = {0};
    int LeftRAP, RightRAP, CentreRAP, Cluster;
    unsigned short codeWords[28] = {0};
    unsigned short bitStr[13] = {0};
    char pattern[580];
    int bp = 0;
    const int debug_print = symbol->debug & ZINT_DEBUG_PRINT;

    variant = 0;

    bitlen = (int) strlen(source);

    for (j = 0; j < 13; j++) {
        const int strpos = j * 16;
        if (strpos >= bitlen) {
            break;
        }
        for (i = 0; i < 16 && strpos + i < bitlen; i++) {
            if (source[strpos + i] == '1') {
                bitStr[j] |= (0x8000 >> i);
            }
        }
    }

    /* Encode codeWords from bitStr */
    cwCnt = cc_encode928(bitStr, codeWords, bitlen);

    switch (cc_width) {
        case 2:
            switch (cwCnt) {
                case 6: variant = 0; break;
                case 8: variant = 1; break;
                case 9: variant = 2; break;
                case 11: variant = 3; break;
                case 12: variant = 4; break;
                case 14: variant = 5; break;
                case 17: variant = 6; break;
            }
            break;
        case 3:
            switch (cwCnt) {
                case 8: variant = 7; break;
                case 10: variant = 8; break;
                case 12: variant = 9; break;
                case 14: variant = 10; break;
                case 17: variant = 11; break;
            }
            break;
        case 4:
            switch (cwCnt) {
                case 8: variant = 12; break;
                case 11: variant = 13; break;
                case 14: variant = 14; break;
                case 17: variant = 15; break;
                case 20: variant = 16; break;
            }
            break;
    }

    symbol->rows = cc_aVariants[0][variant];
    ecc_cwds = cc_aVariants[1][variant];
    offset = cc_aVariants[2][variant];

    /* Reed-Solomon error correction */

    for (i = 0; i < cwCnt; i++) {
        const int total = (codeWords[i] + rsCodeWords[ecc_cwds - 1]) % 929;
        for (j = ecc_cwds - 1; j >= 0; j--) {
            if (j == 0) {
                rsCodeWords[j] = (929 - (total * cc_aCoeffs[offset + j]) % 929) % 929;
            } else {
                rsCodeWords[j] = (rsCodeWords[j - 1] + 929 - (total * cc_aCoeffs[offset + j]) % 929) % 929;
            }
        }
    }

    for (j = 0; j < ecc_cwds; j++) {
        if (rsCodeWords[j] != 0) {
            rsCodeWords[j] = 929 - rsCodeWords[j];
        }
    }

    for (i = ecc_cwds - 1; i >= 0; i--) {
        codeWords[cwCnt] = rsCodeWords[i];
        cwCnt++;
    }

    /* Place data into table */
    LeftRAP = cc_aRAPTable[0][variant] - 1;
    CentreRAP = cc_aRAPTable[1][variant] - 1;
    RightRAP = cc_aRAPTable[2][variant] - 1;

    /* Cluster can be 0, 1 or 2 for Cluster(0), Cluster(3) and Cluster(6) */
    Cluster = cc_aRAPTable[3][variant]; /* Pre-divided by 3 */

    for (i = 0; i < symbol->rows; i++) {
        const int k = i * cc_width;
        bp = 0;
        offset = 929 * Cluster;
        /* Copy the data into codebarre */
        if (cc_width != 3) {
            bp = z_bin_append_posn(zint_pdf_rap_side[LeftRAP], 10, pattern, bp);
        }
        bp = z_bin_append_posn(((int) zint_pdf_bitpattern[offset + codeWords[k]]) << 1, 17, pattern, bp);
        if (cc_width >= 2) {
            if (cc_width == 3) {
                bp = z_bin_append_posn(zint_pdf_rap_centre[CentreRAP], 10, pattern, bp);
            }
            bp = z_bin_append_posn(((int) zint_pdf_bitpattern[offset + codeWords[k + 1]]) << 1, 17, pattern, bp);
            if (cc_width >= 3) {
                if (cc_width == 4) {
                    bp = z_bin_append_posn(zint_pdf_rap_centre[CentreRAP], 10, pattern, bp);
                }
                bp = z_bin_append_posn(((int) zint_pdf_bitpattern[offset + codeWords[k + 2]]) << 1, 17, pattern, bp);
                if (cc_width == 4) {
                    bp = z_bin_append_posn(((int) zint_pdf_bitpattern[offset + codeWords[k + 3]]) << 1, 17, pattern,
                                            bp);
                }
            }
        }
        bp = z_bin_append_posn(zint_pdf_rap_side[RightRAP], 10, pattern, bp);
        pattern[bp++] = '1'; /* Stop */

        /* So now pattern[] holds the string of '1's and '0's. - copy this to the symbol */
        for (j = 0; j < bp; j++) {
            if (pattern[j] == '1') {
                z_set_module(symbol, i, j);
            }
        }
        symbol->row_height[i] = 2;

        /* Set up RAPs and Cluster for next row */
        LeftRAP = LeftRAP == 51 ? 0 : LeftRAP + 1;
        CentreRAP = CentreRAP == 51 ? 0 : CentreRAP + 1;
        RightRAP = RightRAP == 51 ? 0 : RightRAP + 1;
        Cluster = Cluster == 2 ? 0 : Cluster + 1;
    }
    symbol->width = bp;

    if (debug_print) {
        printf("CC-A Columns: %d, Rows: %d, Variant: %d, CodeWords: %d\n", cc_width, symbol->rows, variant, cwCnt);
    }
}

/* CC-B 2D component */
static void cc_b(struct zint_symbol *symbol, const char source[], const int cc_width) {
    const int length = (int) strlen(source) / 8;
    int i;
    unsigned char *data_string = (unsigned char *) z_alloca(length + 3);
    short chainemc[180];
    int mclength = 0;
    char pattern[580];
    int variant;
#ifndef NDEBUG
    int ecc_cwds;
#endif
    const int debug_print = symbol->debug & ZINT_DEBUG_PRINT;

    for (i = 0; i < length; i++) {
        const int binloc = i * 8;
        int p;

        data_string[i] = 0;
        for (p = 0; p < 8; p++) {
            if (source[binloc + p] == '1') {
                data_string[i] |= (0x80 >> p);
            }
        }
    }

    /* "the CC-B component shall have codeword 920 in the first symbol character position" (section 9a) */
    chainemc[mclength++] = 920;

    zint_pdf_byteprocess(chainemc, &mclength, data_string, 0, length, 0);

    /* Now figure out which variant of the symbol to use and load values accordingly */

    variant = zint_micropdf_variant(cc_width, mclength);
    assert(variant > 0);

    /* Now we have the variant we can load the data - from here on the same as MicroPDF417 code */
    variant--;
    assert(variant >= 0);
    assert(zint_pdf_MicroVariants[0][variant] == cc_width); /* columns */
    symbol->rows = zint_pdf_MicroVariants[1][variant]; /* rows */
#ifndef NDEBUG
    ecc_cwds = zint_pdf_MicroVariants[2][variant]; /* Number of EC CWs */
#else
    (void) zint_pdf_MicroVariants[2][variant]; /* Number of EC CWs */
#endif
    /* Binary input padded to target length so no padding necessary */
    assert(cc_width * symbol->rows == mclength + ecc_cwds);

    zint_micropdf_expand(symbol, chainemc, mclength, pattern, cc_width, variant, debug_print);

    for (i = 0; i < symbol->rows; i++) {
        symbol->row_height[i] = 2;
    }

    if (debug_print) {
        printf("CC-B Columns: %d, Rows: %d, Variant: %d, CodeWords: %d\n",
                cc_width, symbol->rows, variant + 1, mclength);
    }
}

/* CC-C 2D component - byte compressed PDF417 */
static void cc_c(struct zint_symbol *symbol, const char source[], const int cc_width, const int ecc) {
    const int length = (int) strlen(source) / 8;
    int i;
    unsigned char *data_string = (unsigned char *) z_alloca(length + 4);
    short chainemc[1000];
    int mclength = 0, ecc_cwds;
    int offset, j, mccorrection[520] = {0};
    int c1, c2, c3, dummy[35];
    char pattern[580];
    int bp = 0;
    const int debug_print = symbol->debug & ZINT_DEBUG_PRINT;

    for (i = 0; i < length; i++) {
        const int binloc = i * 8;
        int p;

        data_string[i] = 0;
        for (p = 0; p < 8; p++) {
            if (source[binloc + p] == '1') {
                data_string[i] |= (0x80 >> p);
            }
        }
    }

    chainemc[mclength++] = 0; /* Space for length descriptor */
    chainemc[mclength++] = 920; /* CC-C identifier */

    zint_pdf_byteprocess(chainemc, &mclength, data_string, 0, length, 0);
    assert(mclength > 0); /* Suppress clang-tidy-23 warning clang-analyzer-security.ArrayBound */

    chainemc[0] = mclength;

    if (debug_print) {
        printf("CC-C Codewords (%d):", mclength);
        for (i = 0; i < mclength; i++) printf(" %d", chainemc[i]);
        fputc('\n', stdout);
    }

    /* 796 - we now take care of the Reed Solomon codes */
    assert(ecc >= 2 && ecc <= 5);
    offset = (2 << ecc) - 2;
    assert(offset >= 0 && offset <= 512); /* Suppress clang-tidy-23 warning clang-analyzer-security.ArrayBound */
    ecc_cwds = 1 << (ecc + 1);

    for (i = 0; i < mclength; i++) {
        const int total = (chainemc[i] + mccorrection[ecc_cwds - 1]) % 929;
        for (j = ecc_cwds - 1; j >= 0; j--) {
            if (j == 0) {
                mccorrection[j] = (929 - (total * zint_pdf_coefrs[offset + j]) % 929) % 929;
            } else {
                mccorrection[j] = (mccorrection[j - 1] + 929 - (total * zint_pdf_coefrs[offset + j]) % 929) % 929;
            }
        }
    }

    for (j = 0; j < ecc_cwds; j++) {
        if (mccorrection[j] != 0) {
            mccorrection[j] = 929 - mccorrection[j];
        }
    }
    /* We add these codes to the string */
    for (i = ecc_cwds - 1; i >= 0; i--) {
        chainemc[mclength++] = mccorrection[i];
    }

    assert(cc_width > 0); /* Suppress clang-tidy-21 clang-analyzer-security.ArrayBound */

    /* 818 - The CW string is finished */
    symbol->rows = mclength / cc_width;
    c1 = (symbol->rows - 1) / 3;
    c2 = ecc * 3 + (symbol->rows - 1) % 3;
    c3 = cc_width - 1;

    /* We now encode each row */
    for (i = 0; i <= symbol->rows - 1; i++) {
        const int k = (i / 3) * 30;
        for (j = 0; j < cc_width; j++) {
            dummy[j + 1] = chainemc[i * cc_width + j];
        }
        switch (i % 3) {
            case 0:
                dummy[0] = k + c1;
                dummy[cc_width + 1] = k + c3;
                offset = 0; /* cluster(0) */
                break;
            case 1:
                dummy[0] = k + c2;
                dummy[cc_width + 1] = k + c1;
                offset = 929; /* cluster(3) */
                break;
            case 2:
                dummy[0] = k + c3;
                dummy[cc_width + 1] = k + c2;
                offset = 1858; /* cluster(6) */
                break;
        }
        bp = 0;
        bp = z_bin_append_posn(0x1FEA8, 17, pattern, bp); /* Row start */

        for (j = 0; j <= cc_width + 1; j++) {
            bp = z_bin_append_posn(((int) zint_pdf_bitpattern[offset + dummy[j]]) << 1, 17, pattern, bp);
        }
        bp = z_bin_append_posn(0x3FA29, 18, pattern, bp); /* Row Stop */

        for (j = 0; j < bp; j++) {
            if (pattern[j] == '1') {
                z_set_module(symbol, i, j);
            }
        }
        symbol->row_height[i] = 3;
    }
    symbol->width = bp;

    if (debug_print) {
        printf("CC-C Columns: %d, Rows: %d, CodeWords: %d, ECC Level: %d\n",
                cc_width, symbol->rows, mclength, ecc);
    }
}

static int cc_a_calc_padding(const int binary_length, const int cc_width) {
    static const short bin_lens[3][7] = {
        { 59,  78,  88, 108, 118, 138, 167 },
        { 78,  98, 118, 138, 167,   0,   0 },
        { 78, 108, 138, 167, 197,   0,   0 },
    };
    const short *bin_len = bin_lens[cc_width - 2];
    int target_bitsize = 0;
    int i;

    for (i = 0; i < ARRAY_SIZE(bin_lens[0]) && bin_len[i]; i++) {
        if (binary_length <= bin_len[i]) {
            target_bitsize = bin_len[i];
            break;
        }
    }

    return target_bitsize;
}

static int cc_b_calc_padding(const int binary_length, const int cc_width) {
    static const short bin_lens[3][11] = {
        { 56, 104, 160, 208, 256, 296, 336,   0,   0,    0,    0 },
        { 32,  72, 112, 152, 208, 304, 416, 536, 648,  768,    0 },
        { 56,  96, 152, 208, 264, 352, 496, 672, 840, 1016, 1184 },
    };
    const short *bin_len = bin_lens[cc_width - 2];
    int target_bitsize = 0;
    int i;

    for (i = 0; i < ARRAY_SIZE(bin_lens[0]) && bin_len[i]; i++) {
        if (binary_length <= bin_len[i]) {
            target_bitsize = bin_len[i];
            break;
        }
    }

    return target_bitsize;
}

static int cc_c_calc_padding(const int binary_length, int *p_cc_width, const int linear_width, int *p_ecc) {
    int target_bitsize;
    int codewords_used, ecc, ecc_cwds, rows;
    int codewords_total, target_codewords, target_bytesize;
    int cc_width;
    const int byte_length = (binary_length + 7) >> 3;

    codewords_used = (byte_length / 6) * 5;
    codewords_used += byte_length % 6;

    /* Recommended minimum ecc levels ISO/IEC 1543:2015 (PDF417) Annex E Table E.1,
       restricted by CC-C codeword max 900 (30 cols * 30 rows), GS1 General Specifications 19.1 5.9.2.3 */
    if (codewords_used <= 40) {
        ecc = 2;
    } else if (codewords_used <= 160) {
        ecc = 3;
    } else if (codewords_used <= 320) {
        ecc = 4;
    } else if (codewords_used <= 833) { /* 900 - 3 - 64 */
        ecc = 5;
    } else if (codewords_used <= 865) { /* 900 - 3 - 32 */
        ecc = 4; /* Not recommended but allow to meet advertised "up to 2361 digits" (allows max 2372) */
    } else {
        return 0;
    }
    *p_ecc = ecc;
    ecc_cwds = 1 << (ecc + 1);

    codewords_used += ecc_cwds;
    codewords_used += 3;
    assert(codewords_used <= 900);

    /* Minimum possible linear width (with GS1_NO_CHECK) is 11*5 (start, FNC1, linkage, data, check) + 13 stop */
    assert(linear_width >= 68);
    /* -52 = 7 left shift (section 12.3 f) + 10 right quiet zone - 17 start + 2x17 row indicators + 18 stop */
    cc_width = linear_width == 68 ? 1 : (linear_width - 52) / 17; /* Ensure > 0 */
    if (cc_width > 30) {
        cc_width = 30;
    }
    assert(cc_width > 0);
    rows = (int) ceil((double) codewords_used / cc_width);
    /* Stop the symbol from becoming too high */
    while (rows > 30 && cc_width < 30) {
        cc_width++;
        rows = (int) ceil((double) codewords_used / cc_width);
    }
    assert(rows <= 30); /* Guaranteed by codewords_used <= 900 */

    if (rows < 3) {
        rows = 3;
    }

    codewords_total = cc_width * rows;
    *p_cc_width = cc_width;

    target_codewords = codewords_total - ecc_cwds;
    target_codewords -= 3;

    target_bytesize = 6 * (target_codewords / 5);
    target_bytesize += target_codewords % 5;

    target_bitsize = target_bytesize << 3;

    return target_bitsize;
}

/* Handles all data encodation from section 5 of ISO/IEC 24723 */
static int cc_binary_string(struct zint_symbol *symbol, const unsigned char source[], const int length,
            char binary_string[], const int cc_mode, int *p_cc_width, int *p_ecc, const int linear_width) {
    int encoding_method, read_posn, alpha_pad;
    int i, j, ai_crop, ai_crop_posn, fnc1_latch;
    int ai90_mode, remainder;
    char last_digit = '\0';
    int mode;
    char *general_field = (char *) z_alloca(length + 1);
    int target_bitsize;
    int bp = 0;
    const int debug_print = symbol->debug & ZINT_DEBUG_PRINT;

    encoding_method = 1;
    read_posn = 0;
    ai_crop = 0;
    ai_crop_posn = -1;
    fnc1_latch = 0;
    alpha_pad = 0;
    *p_ecc = 0;
    target_bitsize = 0;
    mode = GF_NUMERIC;

    if (length > 1 && source[0] == '1' && (source[1] == '0' || source[1] == '1' || source[1] == '7')) {
        /* Source starts (10), (11) or (17) */
        if (source[1] == '0' || zint_dbar_exp_date(source, length, 2) >= 0) { /* Check date valid if (11) or (17) */
            encoding_method = 2;
        }
    } else if (length > 1 && source[0] == '9' && source[1] == '0') {
        /* Source starts (90) */
        encoding_method = 3;
    }

    if (encoding_method == 1) {
        binary_string[bp++] = '0';
        if (debug_print) printf("CC-%c Encodation Method: 0\n", 'A' + (cc_mode - 1));

    } else if (encoding_method == 2) {
        /* Encoding Method field "10" - date and lot number */

        bp = z_bin_append_posn(2, 2, binary_string, bp); /* "10" */

        if (source[1] == '0') {
            /* No date data */
            bp = z_bin_append_posn(3, 2, binary_string, bp); /* "11" */
            read_posn = 2;
        } else {
            /* Production Date (11) or Expiration Date (17) */
            assert(length >= 8); /* Due to `zint_dbar_exp_date()` check above */

            bp = z_bin_append_posn(zint_dbar_exp_date(source, length, 2), 16, binary_string, bp);

            if (source[1] == '1') {
                /* Production Date AI 11 */
                binary_string[bp++] = '0';
            } else {
                /* Expiration Date AI 17 */
                binary_string[bp++] = '1';
            }
            read_posn = 8;

            if (read_posn + 1 < length && source[read_posn] == '1' && source[read_posn + 1] == '0') {
                /* Followed by AI 10 - strip this from general field */
                read_posn += 2;
            } else if (source[read_posn]) {
                /* ISO/IEC 24723:2010 5.3.1 "If a lot number does not directly follow the date element string,
                   a FNC1 is encoded following the date element string ..." */
                fnc1_latch = 1;
            } else {
                /* "... even if no more data follows the date element string" */
                /* So still need FNC1 character but can't do single FNC1 in numeric mode, so insert alphanumeric latch
                   "0000" and alphanumeric FNC1 "01111" (this implementation detail taken from BWIPP
                   https://github.com/bwipp/postscriptbarcode Copyright (c) 2004-2019 Terry Burton) */
                /* SPDX-License-Identifier: MIT */
                bp = z_bin_append_posn(15, 9, binary_string, bp); /* "000001111" */
                /* Note an alphanumeric FNC1 is also a numeric latch, so now in numeric mode */
            }
        }

        if (debug_print) {
            printf("CC-%c Encodation Method: 10, Compaction Field: %.*s\n", 'A' + (cc_mode - 1), read_posn, source);
        }

    } else if (encoding_method == 3) {
        /* Encodation Method field of "11" - AI 90 */
        unsigned char *ninety = (unsigned char *) z_alloca(length + 1);
        int ninety_len, alpha, alphanum, numeric, alpha_posn;

        /* "This encodation method may be used if an element string with an AI
        90 occurs at the start of the data message, and if the data field
        following the two-digit AI 90 starts with an alphanumeric string which
        complies with a specific format." (para 5.3.2) */

        i = 0;
        if (length > 2) {
            do {
                ninety[i] = source[i + 2];
                i++;
            } while (i + 2 < length && source[i + 2] != '\x1D');
        }
        ninety[i] = '\0';
        ninety_len = i;

        /* Find out if the AI 90 data is alphabetic or numeric or both */

        alpha = 0;
        alphanum = 0;
        numeric = 0;

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

            if (z_isupper(ninety[i])) {
                /* Character is alphabetic */
                alpha += 1;
            } else if (z_isdigit(ninety[i])) {
                /* Character is numeric */
                numeric += 1;
            } else {
                alphanum += 1;
            }
        }

        /* Must start with 0, 1, 2 or 3 digits followed by an uppercase character */
        alpha_posn = -1;
        if (ninety_len && ninety[0] != '0') { /* Leading zeros are not permitted */
            for (i = 0; i < ninety_len && i < 4; i++) {
                if (z_isupper(ninety[i])) {
                    alpha_posn = i;
                    break;
                }
                if (!z_isdigit(ninety[i])) {
                    break;
                }
            }
        }

        if (alpha_posn != -1) {
            int next_ai_posn;
            int numeric_value;
            int table3_letter;
            /* Encodation method "11" can be used */
            bp = z_bin_append_posn(3, 2, binary_string, bp); /* "11" */

            numeric -= alpha_posn;
            alpha--;

            /* Decide on numeric, alpha or alphanumeric mode */
            /* Alpha mode is a special mode for AI 90 */

            if (alphanum == 0 && alpha > numeric) {
                /* Alpha mode */
                bp = z_bin_append_posn(3, 2, binary_string, bp); /* "11" */
                ai90_mode = 2;
            } else if (alphanum == 0 && alpha == 0) {
                /* Numeric mode */
                bp = z_bin_append_posn(2, 2, binary_string, bp); /* "10" */
                ai90_mode = 3;
            } else {
                /* Note if first 4 are digits then it would be shorter to go into NUMERIC mode first; not
                   implemented */
                /* Alphanumeric mode */
                binary_string[bp++] = '0';
                ai90_mode = 1;
                mode = GF_ALPHANUMERIC;
            }

            next_ai_posn = 2 + ninety_len;

            if (next_ai_posn < length && source[next_ai_posn] == '\x1D') {
                /* There are more AIs afterwards */
                if (next_ai_posn + 2 < length && source[next_ai_posn + 1] == '2' && source[next_ai_posn + 2] == '1') {
                    /* AI 21 follows */
                    ai_crop = 1;
                } else if (next_ai_posn + 4 < length
                        && source[next_ai_posn + 1] == '8' && source[next_ai_posn + 2] == '0'
                        && source[next_ai_posn + 3] == '0' && source[next_ai_posn + 4] == '4') {
                    /* AI 8004 follows */
                    ai_crop = 3;
                }
            }

            switch (ai_crop) {
                case 0:
                    binary_string[bp++] = '0';
                    break;
                case 1:
                    bp = z_bin_append_posn(2, 2, binary_string, bp); /* "10" */
                    ai_crop_posn = next_ai_posn + 1;
                    break;
                case 3:
                    bp = z_bin_append_posn(3, 2, binary_string, bp); /* "11" */
                    ai_crop_posn = next_ai_posn + 1;
                    break;
            }

            numeric_value = alpha_posn ? z_to_int(ninety, alpha_posn) : 0;

            table3_letter = -1;
            if (numeric_value < 31) {
                table3_letter = z_posn("BDHIJKLNPQRSTVWZ", ninety[alpha_posn]);
            }

            if (table3_letter != -1) {
                /* Encoding can be done according to 5.3.2 c) 2) */
                /* five bit binary string representing value before letter */
                bp = z_bin_append_posn(numeric_value, 5, binary_string, bp);

                /* Followed by four bit representation of letter from Table 3 */
                bp = z_bin_append_posn(table3_letter, 4, binary_string, bp);
            } else {
                /* Encoding is done according to 5.3.2 c) 3) */
                bp = z_bin_append_posn(31, 5, binary_string, bp);
                /* ten bit representation of number */
                bp = z_bin_append_posn(numeric_value, 10, binary_string, bp);

                /* five bit representation of ASCII character */
                bp = z_bin_append_posn(ninety[alpha_posn] - 65, 5, binary_string, bp);
            }

            read_posn = alpha_posn + 3; /* +2 for 90 and +1 to go beyond alpha position */

            /* Do Alpha mode encoding of the rest of the AI 90 data field here */
            if (ai90_mode == 2) {
                /* Alpha encodation (section 5.3.3) */
                do {
                    if (z_isupper(source[read_posn])) {
                        bp = z_bin_append_posn(source[read_posn] - 65, 5, binary_string, bp);

                    } else if (z_isdigit(source[read_posn])) {
                        bp = z_bin_append_posn(source[read_posn] + 4, 6, binary_string, bp);

                    } else if (source[read_posn] == '\x1D') {
                        bp = z_bin_append_posn(31, 5, binary_string, bp);
                    }

                    read_posn++;
                } while (source[read_posn - 1] != '\x1D' && source[read_posn - 1] != '\0');
                alpha_pad = 1; /* This is overwritten if a general field is encoded */
            }

            if (debug_print) {
                printf("CC-%c Encodation Method: 11, Compaction Field: %.*s, Binary: %.*s (%d)\n",
                        'A' + (cc_mode - 1), read_posn, source, bp, binary_string, bp);
            }
        } else {
            /* Use general field encodation instead */
            binary_string[bp++] = '0';
            read_posn = 0;
            if (debug_print) printf("CC-%c Encodation Method: 0\n", 'A' + (cc_mode - 1));
        }
    }

    /* The compressed data field has been processed if appropriate - the
    rest of the data (if any) goes into a general-purpose data compaction field */

    j = 0;
    if (fnc1_latch == 1) {
        /* Encodation method "10" has been used but it is not followed by
           AI 10, so a FNC1 character needs to be added */
        general_field[j] = '\x1D';
        j++;
    }

    for (i = read_posn; i < length; i++) {
        /* Skip "[21" or "[8004" AIs if encodation method "11" used */
        if (i == ai_crop_posn) {
            i += ai_crop;
        } else {
            general_field[j] = source[i];
            j++;
        }
    }
    general_field[j] = '\0';

    if (debug_print) {
        printf("Mode %s, General Field: %.40s%s\n",
                mode == GF_NUMERIC ? "NUMERIC" : mode == GF_ALPHANUMERIC ? "ALPHANUMERIC" : "ISO646",
                general_field, j > 40 ? "..." : "");
    }

    if (j != 0) { /* If general field not empty */
        alpha_pad = 0;

        if (!zint_general_field_encode(general_field, j, &mode, &last_digit, binary_string, &bp)) {
            /* Invalid character in input data */
            return z_errtxt(ZINT_ERROR_INVALID_DATA, symbol, 441, "Invalid character in input (2D component)");
        }
    }

    switch (cc_mode) {
        case 1:
            target_bitsize = cc_a_calc_padding(bp, *p_cc_width);
            break;
        case 2:
            target_bitsize = cc_b_calc_padding(bp, *p_cc_width);
            break;
        case 3:
            target_bitsize = cc_c_calc_padding(bp, p_cc_width, linear_width, p_ecc);
            break;
    }

    if (target_bitsize == 0) {
        return z_errtxt(ZINT_ERROR_TOO_LONG, symbol, 442, "Input too long (2D component)");
    }

    remainder = target_bitsize - bp;

    if (last_digit) {
        /* There is still one more numeric digit to encode */

        if (remainder >= 4 && remainder <= 6) {
            /* ISO/IEC 24723:2010 5.4.1 c) 2) "If four to six bits remain, add 1 to the digit value and encode the
               result in the next four bits. ..." */
            bp = z_bin_append_posn(z_ctoi(last_digit) + 1, 4, binary_string, bp);
            if (remainder > 4) {
                /* "... The fifth and sixth bits, if present, shall be “0”s." (Covered by adding truncated
                   alphanumeric latch below but do explicitly anyway) */
                bp = z_bin_append_posn(0, remainder - 4, binary_string, bp);
            }
        } else {
            bp = z_bin_append_posn(11 * z_ctoi(last_digit) + 18, 7, binary_string, bp);
            /* This may push the symbol up to the next size */
        }
    }

    switch (cc_mode) {
        case 1: target_bitsize = cc_a_calc_padding(bp, *p_cc_width); break;
        case 2: target_bitsize = cc_b_calc_padding(bp, *p_cc_width); break;
        case 3: target_bitsize = cc_c_calc_padding(bp, p_cc_width, linear_width, p_ecc); break;
    }

    if (target_bitsize == 0) {
        return z_errtxt(ZINT_ERROR_TOO_LONG, symbol, 444, "Input too long (2D component)");
    }

    if (bp < target_bitsize) {
        /* Now add padding to binary string */
        if (alpha_pad == 1) {
            bp = z_bin_append_posn(31, 5, binary_string, bp); /* "11111" */
            /* Extra FNC1 character required after Alpha encodation (section 5.3.3) */
        }

        if (mode == GF_NUMERIC) {
            bp = z_bin_append_posn(0, 4, binary_string, bp); /* "0000" */
        }

        while (bp < target_bitsize) {
            bp = z_bin_append_posn(4, 5, binary_string, bp); /* "00100" */
        }
    }
    binary_string[target_bitsize] = '\0';

    if (debug_print) {
        printf("ECC: %d, CC width %d\n", *p_ecc, *p_cc_width);
        printf("Binary: %s (%d)\n", binary_string, target_bitsize);
    }

    return 0;
}

/* Calculate the width of the linear part (primary) */
static int cc_linear_dummy_run(struct zint_symbol *symbol, unsigned char *source, int length) {
    struct zint_symbol dummy = {0};
    int error_number;
    int linear_width;

    dummy.symbology = BARCODE_GS1_128_CC;
    dummy.option_1 = -1;
    /* Verified later via `linear` symbol (unless GS1SYNTAXENGINE_MODE, when already verified) */
    dummy.input_mode = symbol->input_mode | GS1NOCHECK_MODE;
    dummy.debug = symbol->debug;
    error_number = zint_gs1_128_cc(&dummy, source, length, 3 /*cc_mode*/, 0 /*cc_rows*/);
    linear_width = dummy.width;
    if (error_number >= ZINT_ERROR || (symbol->debug & ZINT_DEBUG_TEST)) {
        (void) z_errtxt(0, symbol, -1, dummy.errtxt);
    }

    if (error_number >= ZINT_ERROR) {
        return 0;
    }
    return linear_width;
}

INTERNAL int zint_composite(struct zint_symbol *symbol, unsigned char source[], int length) {
    int error_number = 0, warn_number;
    int cc_mode, cc_width = 0, ecc = 0;
    int i, j;
    /* Allow for 8 bits + 5-bit latch per char + 1000 bits overhead/padding */
    const unsigned int bs = 13 * length + 1000 + 1;
    char *binary_string = (char *) z_alloca(bs);
    int primary_len;
    struct zint_symbol *linear;
    int top_shift, bottom_shift;
    int linear_width = 0;
    const int content_segs = symbol->output_options & BARCODE_CONTENT_SEGS;
    const int debug_print = symbol->debug & ZINT_DEBUG_PRINT;

    if (debug_print) printf("Reduced length: %d\n", length);

    /* Hack to initialize `warn_number` to warning (if any) returned by `zint_gs1_verify()` */
    warn_number = symbol->warn_level >> 8;
    symbol->warn_level &= 0xFF;
    assert(warn_number < ZINT_ERROR);

    /* Perform sanity checks on input options first */
    primary_len = (int) strlen(symbol->primary);
    if (primary_len == 0) {
        return z_errtxt(ZINT_ERROR_INVALID_DATA, symbol, 445, "No primary (linear component)");
    }
    if (primary_len >= (int) sizeof(symbol->primary)) {
        return z_errtxt(ZINT_ERROR_INVALID_DATA, symbol, 854,
                        "Invalid primary (linear component), must be NUL-terminated");
    }
    if (length > 2990) {
        return z_errtxtf(ZINT_ERROR_TOO_LONG, symbol, 446,
                        "2D component input too long, requires %d characters (maximum 2990)", length);
    }

    cc_mode = symbol->option_1;
    if (cc_mode == 3 && symbol->symbology != BARCODE_GS1_128_CC) {
        /* CC-C can only be used with a GS1-128 linear part */
        return z_errtxt(ZINT_ERROR_INVALID_OPTION, symbol, 447,
                        "Invalid mode (CC-C only valid with GS1-128 linear component)");
    }

    if (symbol->symbology == BARCODE_GS1_128_CC) {
        /* Do a test run of encoding the linear component to establish its width */
        linear_width = cc_linear_dummy_run(symbol, ZUCP(symbol->primary), primary_len);
        if (linear_width == 0) { /* Only catches `GS1NOCHECK_MODE` errors */
            return z_errtxt_adj(ZINT_ERROR_INVALID_DATA, symbol, "%1$s%2$s", " (linear component)");
        }
        if (debug_print) {
            printf("GS1-128 linear width: %d\n", linear_width);
        }
    }

    switch (symbol->symbology) {
            /* Determine width of 2D component according to ISO/IEC 24723 Table 1 */
        case BARCODE_EANX_CC:
        case BARCODE_EAN8_CC:
        case BARCODE_EAN13_CC:
            if (primary_len < 20) {
                int padded_primary_len;
                int with_addon;
                unsigned char padded_primary[21];
                if (!zint_ean_leading_zeroes(symbol, ZCUCP(symbol->primary), primary_len, padded_primary,
                                            &with_addon, NULL, NULL)) {
                    return z_errtxt_adj(ZINT_ERROR_TOO_LONG, symbol, "%1$s%2$s", " (linear component)");
                }
                padded_primary_len = (int) z_ustrlen(padded_primary);
                if (padded_primary_len <= 7 || symbol->symbology == BARCODE_EAN8_CC) { /* EAN-8 */
                    cc_width = 3;
                } else {
                    switch (padded_primary_len) {
                        case 10: /* EAN-8 + 2 */
                            cc_width = 3;
                            break;
                        case 13: /* EAN-13 CHK or EAN-8 + 5 */
                            cc_width = with_addon ? 3 : 4;
                            break;
                        case 12: /* EAN-13 */
                        case 15: /* EAN-13 + 2 */
                        case 16: /* EAN-13 CHK + 2 */
                        case 18: /* EAN-13 + 5 */
                        case 19: /* EAN-13 CHK + 5 */
                            cc_width = 4;
                            break;
                    }
                }
            }
            if (cc_width == 0) {
                return z_errtxtf(ZINT_ERROR_TOO_LONG, symbol, 449, "Input length %d wrong (linear component)",
                                primary_len);
            }
            break;
        case BARCODE_GS1_128_CC: cc_width = 4; break;
        case BARCODE_DBAR_OMN_CC: cc_width = 4; break;
        case BARCODE_DBAR_LTD_CC: cc_width = 3; break;
        case BARCODE_DBAR_EXP_CC: cc_width = 4; break;
        case BARCODE_UPCA_CC: cc_width = 4; break;
        case BARCODE_UPCE_CC: cc_width = 2; break;
        case BARCODE_DBAR_STK_CC: cc_width = 2; break;
        case BARCODE_DBAR_OMNSTK_CC: cc_width = 2; break;
        case BARCODE_DBAR_EXPSTK_CC: cc_width = 4; break;
    }

    if (cc_mode < 1 || cc_mode > 3) {
        cc_mode = 1;
    }

    if (cc_mode == 1) {
        i = cc_binary_string(symbol, source, length, binary_string, cc_mode, &cc_width, &ecc, linear_width);
        if (i == ZINT_ERROR_TOO_LONG) {
            symbol->errtxt[0] = '\0'; /* Unset error text */
            cc_mode = 2;
        } else if (i != 0) {
            return i;
        }
    }

    if (cc_mode == 2) {
        /* If the data didn't fit into CC-A it is recalculated for CC-B */
        i = cc_binary_string(symbol, source, length, binary_string, cc_mode, &cc_width, &ecc, linear_width);
        if (i == ZINT_ERROR_TOO_LONG) {
            if (symbol->symbology != BARCODE_GS1_128_CC) {
                return ZINT_ERROR_TOO_LONG;
            }
            symbol->errtxt[0] = '\0'; /* Unset error text */
            cc_mode = 3;
        } else if (i != 0) {
            return i;
        }
    }

    if (cc_mode == 3) {
        /* If the data didn't fit in CC-B (and linear part is GS1-128) it is recalculated for CC-C */
        i = cc_binary_string(symbol, source, length, binary_string, cc_mode, &cc_width, &ecc, linear_width);
        if (i != 0) {
            return i;
        }
    }

    symbol->rows = 0; /* Composites are not stackable */

    assert(cc_mode >= 1 && cc_mode <= 3);
    switch (cc_mode) {
        /* Note that ecc is only relevant to CC-C */
        case 1: cc_a(symbol, binary_string, cc_width); break;
        case 2: cc_b(symbol, binary_string, cc_width); break;
        case 3: cc_c(symbol, binary_string, cc_width, ecc); break;
    }

    if (warn_number == 0 && symbol->option_1 >= 1 && symbol->option_1 <= 3 && symbol->option_1 != cc_mode) {
        warn_number = ZEXT z_errtxtf(ZINT_WARN_INVALID_OPTION, symbol, 443,
                                    "Composite type changed from CC-%1$c to CC-%2$c",
                                    'A' + (symbol->option_1 - 1), 'A' + (cc_mode - 1));
    }

    /* Feedback options */
    symbol->option_1 = cc_mode;

    /* 2D component done, now calculate linear component */
    linear = ZBarcode_Create(); /* Symbol contains the 2D component and Linear contains the rest */

    linear->symbology = symbol->symbology;
    linear->input_mode = symbol->input_mode;
#ifdef ZINT_HAVE_GS1SE
    if (symbol->input_mode & GS1SYNTAXENGINE_MODE) {
        linear->input_mode |= GS1NOCHECK_MODE; /* Already verified in `ZBarcode_Encode_Segs()` */
    }
#endif
    linear->output_options = symbol->output_options;
    linear->show_hrt = symbol->show_hrt;
    linear->option_2 = symbol->option_2;
    linear->option_3 = symbol->option_3;
    /* If symbol->height given minimum row height will be returned, else default height */
    linear->height = symbol->height;
    linear->debug = symbol->debug;

    if (linear->symbology != BARCODE_GS1_128_CC) {
        /* Set the "component linkage" flag in the linear component */
        linear->option_1 = 2;
    }

    switch (symbol->symbology) {
        case BARCODE_EANX_CC:
        case BARCODE_EAN8_CC:
        case BARCODE_EAN13_CC:
            error_number = zint_eanx_cc(linear, ZUCP(symbol->primary), primary_len, symbol->rows);
            break;
        case BARCODE_GS1_128_CC:
            /* GS1-128 needs to know which type of 2D component is used */
            error_number = zint_gs1_128_cc(linear, ZUCP(symbol->primary), primary_len, cc_mode, symbol->rows);
            break;
        case BARCODE_DBAR_OMN_CC:
            error_number = zint_dbar_omn_cc(linear, ZUCP(symbol->primary), primary_len, symbol->rows);
            break;
        case BARCODE_DBAR_LTD_CC:
            error_number = zint_dbar_ltd_cc(linear, ZUCP(symbol->primary), primary_len, symbol->rows);
            break;
        case BARCODE_DBAR_EXP_CC:
            error_number = zint_dbar_exp_cc(linear, ZUCP(symbol->primary), primary_len, symbol->rows);
            break;
        case BARCODE_UPCA_CC:
            error_number = zint_eanx_cc(linear, ZUCP(symbol->primary), primary_len, symbol->rows);
            break;
        case BARCODE_UPCE_CC:
            error_number = zint_eanx_cc(linear, ZUCP(symbol->primary), primary_len, symbol->rows);
            break;
        case BARCODE_DBAR_STK_CC:
            error_number = zint_dbar_omn_cc(linear, ZUCP(symbol->primary), primary_len, symbol->rows);
            break;
        case BARCODE_DBAR_OMNSTK_CC:
            error_number = zint_dbar_omn_cc(linear, ZUCP(symbol->primary), primary_len, symbol->rows);
            break;
        case BARCODE_DBAR_EXPSTK_CC:
            error_number = zint_dbar_exp_cc(linear, ZUCP(symbol->primary), primary_len, symbol->rows);
            break;
    }

    if (error_number) {
        ZEXT z_errtxtf(0, symbol, -1, "%1$s%2$s", linear->errtxt, " (linear component)");
        if (error_number >= ZINT_ERROR) {
            ZBarcode_Delete(linear);
            return error_number;
        }
    }

    /* Merge the linear component with the 2D component */

    top_shift = 0;
    bottom_shift = 0;

    switch (symbol->symbology) {
            /* Determine horizontal alignment (according to section 12.3) */
        case BARCODE_EANX_CC:
        case BARCODE_EAN8_CC:
        case BARCODE_EAN13_CC:
            switch (linear->text_length) { /* Use zero-padded length */
                case 8: /* EAN-8 */
                case 11: /* EAN-8 + 2 */
                case 14: /* EAN-8 + 5 */
                    if (cc_mode == 1) {
                        bottom_shift = 3;
                    } else {
                        bottom_shift = 13;
                    }
                    break;
                case 13: /* EAN-13 */
                case 16: /* EAN-13 + 2 */
                case 19: /* EAN-13 + 5 */
                    bottom_shift = 2;
                    break;
            }
            break;
        case BARCODE_GS1_128_CC:
            if (cc_mode == 3) {
                bottom_shift = 7; /* ISO/IEC 24723:2010 12.3 f) */
            } else {
                /* ISO/IEC 24723:2010 12.3 g) "GS1-128 components linked to the right quiet zone of the CC-A or CC-B:
                   the CC-A or CC-B component is aligned with the last space module of one of the rightmost symbol
                   characters of the linear component. To calculate the target Code 128 symbol character position for
                   alignment, number the positions from right to left (0 is the Stop character, 1 is the Check
                   character, etc.), and then Position = (total number of Code 128 symbol characters – 9) div 2"
                 */
                const int num_symbols = (linear_width - 2) / 11;
                const int position = (num_symbols - 9) / 2;
                /* Less 1 to align with last space module */
                int calc_shift = linear->width - position * 11 - 1 - symbol->width;
                if (position) {
                    calc_shift -= 2; /* Less additional stop modules */
                }
                if (calc_shift > 0) {
                    top_shift = calc_shift;
                } else if (calc_shift < 0) {
                    bottom_shift = -calc_shift;
                }
            }
            break;
        case BARCODE_DBAR_OMN_CC:
            bottom_shift = 4;
            break;
        case BARCODE_DBAR_LTD_CC:
            if (cc_mode == 1) {
                top_shift = 1;
            } else {
                bottom_shift = 9;
            }
            break;
        case BARCODE_DBAR_EXP_CC:
            for (j = 1; !z_module_is_set(linear, 1, j - 1) && z_module_is_set(linear, 1, j); j++);
            top_shift = j;
            break;
        case BARCODE_UPCA_CC:
            bottom_shift = 2;
            break;
        case BARCODE_UPCE_CC:
            bottom_shift = 2;
            break;
        case BARCODE_DBAR_STK_CC:
            top_shift = 1;
            break;
        case BARCODE_DBAR_OMNSTK_CC:
            top_shift = 1;
            break;
        case BARCODE_DBAR_EXPSTK_CC:
            for (j = 1; !z_module_is_set(linear, 1, j - 1) && z_module_is_set(linear, 1, j); j++);
            top_shift = j;
            break;
    }

    if (debug_print) {
        printf("Top shift: %d, Bottom shift: %d\n", top_shift, bottom_shift);
    }

    if (top_shift != 0) {
        /* Move the 2D component of the symbol horizontally */
        for (i = 0; i < symbol->rows; i++) {
            for (j = (symbol->width + top_shift); j >= top_shift; j--) {
                if (z_module_is_set(symbol, i, j - top_shift)) {
                    z_set_module(symbol, i, j);
                } else {
                    z_unset_module(symbol, i, j);
                }
            }
            for (j = 0; j < top_shift; j++) {
                z_unset_module(symbol, i, j);
            }
        }
    }

    /* Merge linear and 2D components into one structure */
    for (i = 0; i < linear->rows; i++) {
        symbol->row_height[symbol->rows + i] = linear->row_height[i];
        for (j = 0; j <= linear->width; j++) {
            if (z_module_is_set(linear, i, j)) {
                z_set_module(symbol, i + symbol->rows, j + bottom_shift);
            } else {
                z_unset_module(symbol, i + symbol->rows, j + bottom_shift);
            }
        }
    }
    if (linear->width + bottom_shift > symbol->width + top_shift) {
        symbol->width = linear->width + bottom_shift;
    } else if (symbol->width + top_shift > linear->width + bottom_shift) {
        symbol->width += top_shift;
    }
    symbol->rows += linear->rows;
    if (symbol->output_options & COMPLIANT_HEIGHT) {
        /* Avoid overwriting any `zint_gs1_verify()` warning */
        const int no_errtxt = error_number != 0 || warn_number != 0;
        if (symbol->symbology == BARCODE_DBAR_STK_CC) {
            /* Databar Stacked needs special treatment due to asymmetric rows */
            if (!no_errtxt) {
                error_number = zint_dbar_stk_set_height(symbol, symbol->rows - linear->rows + 1 /*first_row*/,
                                                            no_errtxt);
            } else {
                (void) zint_dbar_stk_set_height(symbol, symbol->rows - linear->rows + 1 /*first_row*/, no_errtxt);
            }
        } else if (symbol->symbology == BARCODE_DBAR_EXP_CC || symbol->symbology == BARCODE_DBAR_EXPSTK_CC) {
            /* If symbol->height given then min row height was returned, else default height */
            if (!no_errtxt) {
                error_number = z_set_height(symbol, symbol->height ? linear->height : 0.0f,
                                            symbol->height ? 0.0f : linear->height, 0.0f, no_errtxt);
            } else {
                (void) z_set_height(symbol, symbol->height ? linear->height : 0.0f,
                                    symbol->height ? 0.0f : linear->height, 0.0f, no_errtxt);
            }
        } else {
            /* If symbol->height given then min row height was returned, else default height */
            /* Avoid overwriting any previous warning (e.g. EAN-8 with add-on) */
            if (!no_errtxt) {
                error_number = z_set_height(symbol, symbol->height ? linear->height : 0.0f,
                                            symbol->height ? 0.0f : linear->height, 0.0f, no_errtxt);
            } else {
                (void) z_set_height(symbol, symbol->height ? linear->height : 0.0f,
                                            symbol->height ? 0.0f : linear->height, 0.0f, no_errtxt);
            }
        }
    } else {
        if (symbol->symbology == BARCODE_DBAR_STK_CC) {
            (void) zint_dbar_stk_set_height(symbol, symbol->rows - linear->rows + 1 /*first_row*/,
                                                1 /*no_errtxt*/);
        } else {
            (void) z_set_height(symbol, symbol->height ? linear->height : 0.0f,
                                symbol->height ? 0.0f : linear->height, 0.0f, 1 /*no_errtxt*/);
        }
    }

    z_hrt_cpy_nochk(symbol, linear->text, linear->text_length);

    if (content_segs) {
        assert(linear->content_segs && linear->content_segs[0].source);
        /* First linear, then pipe '|' separator (following BWIPP & GS1 Syntax Engine), then composite */
        if (z_ct_cpy_cat(symbol, linear->content_segs[0].source, linear->content_segs[0].length, '|', source,
                        length)) {
            ZBarcode_Delete(linear);
            return ZINT_ERROR_MEMORY; /* `z_ct_cpy_cat()` only fails with OOM */
        }
    }

    ZBarcode_Delete(linear);

    return error_number ? error_number : warn_number;
}

/* vim: set ts=4 sw=4 et : */
