zint/backend/code128.c

/* code128.c - Handles Code 128 and derivatives */
/*
    libzint - the open source barcode library
    Copyright (C) 2008-2024 Robin Stuart <rstuart114@gmail.com>
    Bugfixes thanks to Christian Sakowski and BogDan Vatra

    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 */

#include <assert.h>
#include <stdio.h>
#include "common.h"
#include "code128.h"
#include "gs1.h"

#define C128_SYMBOL_MAX     99
#define C128_SYMBOL_MAX_S   "99" /* String version of above */

static const char KRSET[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
#define KRSET_F (IS_NUM_F | IS_UPR_F)

/* Code 128 tables checked against ISO/IEC 15417:2007 */

INTERNAL_DATA const char C128Table[107][6] = { /* Used by CODABLOCKF and CODE16K also */
    /* Code 128 character encodation - Table 1 (with final CODE16K-only character in place of Stop character) */
    {'2','1','2','2','2','2'}, {'2','2','2','1','2','2'}, {'2','2','2','2','2','1'}, {'1','2','1','2','2','3'},
    {'1','2','1','3','2','2'}, {'1','3','1','2','2','2'}, {'1','2','2','2','1','3'}, {'1','2','2','3','1','2'},
    {'1','3','2','2','1','2'}, {'2','2','1','2','1','3'}, {'2','2','1','3','1','2'}, {'2','3','1','2','1','2'},
    {'1','1','2','2','3','2'}, {'1','2','2','1','3','2'}, {'1','2','2','2','3','1'}, {'1','1','3','2','2','2'},
    {'1','2','3','1','2','2'}, {'1','2','3','2','2','1'}, {'2','2','3','2','1','1'}, {'2','2','1','1','3','2'},
    {'2','2','1','2','3','1'}, {'2','1','3','2','1','2'}, {'2','2','3','1','1','2'}, {'3','1','2','1','3','1'},
    {'3','1','1','2','2','2'}, {'3','2','1','1','2','2'}, {'3','2','1','2','2','1'}, {'3','1','2','2','1','2'},
    {'3','2','2','1','1','2'}, {'3','2','2','2','1','1'}, {'2','1','2','1','2','3'}, {'2','1','2','3','2','1'},
    {'2','3','2','1','2','1'}, {'1','1','1','3','2','3'}, {'1','3','1','1','2','3'}, {'1','3','1','3','2','1'},
    {'1','1','2','3','1','3'}, {'1','3','2','1','1','3'}, {'1','3','2','3','1','1'}, {'2','1','1','3','1','3'},
    {'2','3','1','1','1','3'}, {'2','3','1','3','1','1'}, {'1','1','2','1','3','3'}, {'1','1','2','3','3','1'},
    {'1','3','2','1','3','1'}, {'1','1','3','1','2','3'}, {'1','1','3','3','2','1'}, {'1','3','3','1','2','1'},
    {'3','1','3','1','2','1'}, {'2','1','1','3','3','1'}, {'2','3','1','1','3','1'}, {'2','1','3','1','1','3'},
    {'2','1','3','3','1','1'}, {'2','1','3','1','3','1'}, {'3','1','1','1','2','3'}, {'3','1','1','3','2','1'},
    {'3','3','1','1','2','1'}, {'3','1','2','1','1','3'}, {'3','1','2','3','1','1'}, {'3','3','2','1','1','1'},
    {'3','1','4','1','1','1'}, {'2','2','1','4','1','1'}, {'4','3','1','1','1','1'}, {'1','1','1','2','2','4'},
    {'1','1','1','4','2','2'}, {'1','2','1','1','2','4'}, {'1','2','1','4','2','1'}, {'1','4','1','1','2','2'},
    {'1','4','1','2','2','1'}, {'1','1','2','2','1','4'}, {'1','1','2','4','1','2'}, {'1','2','2','1','1','4'},
    {'1','2','2','4','1','1'}, {'1','4','2','1','1','2'}, {'1','4','2','2','1','1'}, {'2','4','1','2','1','1'},
    {'2','2','1','1','1','4'}, {'4','1','3','1','1','1'}, {'2','4','1','1','1','2'}, {'1','3','4','1','1','1'},
    {'1','1','1','2','4','2'}, {'1','2','1','1','4','2'}, {'1','2','1','2','4','1'}, {'1','1','4','2','1','2'},
    {'1','2','4','1','1','2'}, {'1','2','4','2','1','1'}, {'4','1','1','2','1','2'}, {'4','2','1','1','1','2'},
    {'4','2','1','2','1','1'}, {'2','1','2','1','4','1'}, {'2','1','4','1','2','1'}, {'4','1','2','1','2','1'},
    {'1','1','1','1','4','3'}, {'1','1','1','3','4','1'}, {'1','3','1','1','4','1'}, {'1','1','4','1','1','3'},
    {'1','1','4','3','1','1'}, {'4','1','1','1','1','3'}, {'4','1','1','3','1','1'}, {'1','1','3','1','4','1'},
    {'1','1','4','1','3','1'}, {'3','1','1','1','4','1'}, {'4','1','1','1','3','1'}, {'2','1','1','4','1','2'},
    {'2','1','1','2','1','4'}, {'2','1','1','2','3','2'}, {/* Only used by CODE16K */ '2','1','1','1','3','3'}
};

/* Whether `ch` can be encoded directly in code set `charset` (no shifts) (for `c128_define_mode()` below) */
static int c128_can_aorb(const unsigned char ch, const int charset, const int check_fnc1) {

    if (ch <= 31) {
        return charset == 1 || (check_fnc1 && ch == '\x1D');
    }
    if (ch <= 95) {
        return 1;
    }
    if (ch <= 127) {
        return charset == 2;
    }
    if (ch <= 159) {
        return charset == 1;
    }
    if (ch <= 223) {
        return 1;
    }
    return charset == 2;
}

/* Whether `source[position]` can be encoded in code set C (for `c128_define_mode()` below) */
static int c128_can_c(const unsigned char source[], const int length, const int position, const int check_fnc1) {
    return (position + 1 < length && z_isdigit(source[position]) && z_isdigit(source[position + 1]))
            || (check_fnc1 && source[position] == '\x1D');
}

/* Calculate the cost of encoding from `position` starting in code set `charset` (for `c128_define_mode()` below) */
static int c128_cost(const unsigned char source[], const int length, const int position, const int charset,
            const int ab_only, const char manual_set[C128_MAX], const unsigned char fncs[C128_MAX], int (*costs)[4],
            char (*modes)[4]) {

    /* Check if memoized */
    if (costs[position][charset]) {
        return costs[position][charset];
    } else {
        const int at_end = position + 1 >= length;
        const int check_fnc1 = !fncs || fncs[position];
        const int can_c = c128_can_c(source, length, position, check_fnc1);
        const int manual_c_fail = !can_c && manual_set && manual_set[position] == 3; /* C requested but not doable */
        int min_cost = 999999; /* Max possible cost 2 * 256 */
        int min_latch = 0;
        int tryset;

        /* Try code set C first (preferring C over B over A as seems to better preserve previous encodation) */
        if (!ab_only && can_c && (!manual_set || !manual_set[position] || manual_set[position] == 3)) {
            const int advance = source[position] == '\x1D' ? 1 : 2;
            int cost = 1;
            int latch = 0; /* Continue current `charset` */
            if (charset != 3) {
                cost++;
                latch = 3;
            }
            if (position + advance < length) {
                cost += c128_cost(source, length, position + advance, 3, ab_only, manual_set, fncs, costs, modes);
            }
            if (cost < min_cost) {
                min_cost = cost;
                min_latch = latch;
            }
        }
        /* Then code sets B and A */
        for (tryset = 2; tryset >= 1; tryset--) {
            if (manual_set && manual_set[position] && manual_set[position] != tryset && !manual_c_fail) {
                continue;
            }
            if (c128_can_aorb(source[position], tryset, check_fnc1)) {
                int cost = 1;
                int latch = 0; /* Continue current `charset` */
                if (charset != tryset) {
                    cost++;
                    latch = tryset;
                }
                if (!at_end) {
                    cost += c128_cost(source, length, position + 1, tryset, ab_only, manual_set, fncs, costs, modes);
                }
                if (cost < min_cost) {
                    min_cost = cost;
                    min_latch = latch;
                }
                if (charset != tryset && (charset == 1 || charset == 2)) {
                    cost = 2;
                    latch = 3 + charset; /* Shift A/B */
                    if (!at_end) {
                        cost += c128_cost(source, length, position + 1, charset, ab_only, manual_set, fncs, costs,
                                            modes);
                    }
                    if (cost < min_cost) {
                        min_cost = cost;
                        min_latch = latch;
                    }
                }
            } else if (manual_set && manual_set[position] == tryset) {
                /* Manually set, requires shift */
                int cost = 2;
                int latch = 3 + tryset; /* Shift A/B */
                if (charset != tryset) {
                    cost++;
                }
                if (!at_end) {
                    cost += c128_cost(source, length, position + 1, tryset, ab_only, manual_set, fncs, costs, modes);
                }
                if (cost < min_cost) {
                    min_cost = cost;
                    min_latch = latch;
                }
            }
        }
        assert(min_cost != 999999);

        costs[position][charset] = min_cost;
        modes[position][charset] = min_latch;

        return min_cost;
    }
}

/* Minimal encoding using Divide-And-Conquer with Memoization by Alex Geller - see
   https://github.com/zxing/zxing/commit/94fb277607003c070ffd1413754a782f3f87cbcd
   (note minimal for non-extended characters only, which are dealt with non-optimally by `fset` logic) */
static void c128_define_mode(char set[C128_MAX], const unsigned char source[], const int length,
            const int ab_only, const char manual_set[C128_MAX], const unsigned char fncs[C128_MAX]) {
    int (*costs)[4] = (int (*)[4]) z_alloca(sizeof(int) * 4 * length);
    char (*modes)[4] = (char (*)[4]) z_alloca(4 * length);
    int charset = 0;
    int i;

    memset(costs, 0, sizeof(int) * 4 * length);
    memset(modes, 0, 4 * length);

    c128_cost(source, length, 0 /*position*/, 0 /*charset*/, ab_only, manual_set, fncs, costs, modes);

    for (i = 0; i < length; i++) {
        const int latch = modes[i][charset];
        if (latch >= 4 && latch <= 5) {
            /* Shift A/B */
            charset = latch - 3;
            set[i] = charset == 1 ? 'b' : 'a';
        } else {
            if (latch >= 1 && latch <= 3) {
                charset = latch;
            } /* Else continue in same `charset` */
            assert(charset);
            set[i] = '@' + charset; /* A, B or C */
            if (charset == 3 && source[i] != '\x1D') {
                assert(i + 1 < length); /* Guaranteed by algorithm */
                set[++i] = 'C';
            }
        }
    }
}

/**
 * Translate Code 128 Set A characters into barcodes.
 * This set handles all control characters NUL to US.
 */
INTERNAL void c128_set_a(const unsigned char source, int values[], int *bar_chars) {

    if (source >= 128) {
        if (source < 160) {
            values[(*bar_chars)] = (source - 128) + 64;
        } else {
            values[(*bar_chars)] = (source - 128) - 32;
        }
    } else {
        if (source < 32) {
            values[(*bar_chars)] = source + 64;
        } else {
            values[(*bar_chars)] = source - 32;
        }
    }
    (*bar_chars)++;
}

/**
 * Translate Code 128 Set B characters into barcodes.
 * This set handles all characters which are not part of long numbers and not
 * control characters.
 */
INTERNAL int c128_set_b(const unsigned char source, int values[], int *bar_chars) {
    if (source >= 128 + 32) {
        values[(*bar_chars)] = source - 32 - 128;
    } else if (source >= 128) { /* Should never happen */
        return 0; /* Not reached */
    } else if (source >= 32) {
        values[(*bar_chars)] = source - 32;
    } else { /* Should never happen */
        return 0; /* Not reached */
    }
    (*bar_chars)++;
    return 1;
}

/* Translate Code 128 Set C characters into barcodes
 * This set handles numbers in a compressed form
 */
INTERNAL void c128_set_c(const unsigned char source_a, const unsigned char source_b, int values[], int *bar_chars) {
    values[(*bar_chars)] = 10 * (source_a - '0') + source_b - '0';
    (*bar_chars)++;
}

/* Helper to write out symbol, calculating check digit */
static void c128_expand(struct zint_symbol *symbol, int values[C128_MAX], int bar_characters) {
    char dest[640]; /* (1 (Start) + 2 (max initial extra) + 99 + 1 (check digit)) * 6 + 7 (Stop) == 625 */
    char *d = dest;
    int total_sum;
    int i;

    /* Destination setting and check digit calculation */
    memcpy(d, C128Table[values[0]], 6);
    d += 6;
    total_sum = values[0];

    for (i = 1; i < bar_characters; i++, d += 6) {
        memcpy(d, C128Table[values[i]], 6);
        total_sum += values[i] * i; /* Note can't overflow as 106 * C128_SYMBOL_MAX * C128_SYMBOL_MAX = 1038906 */
    }
    total_sum %= 103;
    memcpy(d, C128Table[total_sum], 6);
    d += 6;
    values[bar_characters++] = total_sum;

    /* Stop character */
    memcpy(d, "2331112", 7);
    d += 7;
    values[bar_characters++] = 106;

    if (symbol->debug & ZINT_DEBUG_PRINT) {
        fputs("Codewords:", stdout);
        for (i = 0; i < bar_characters; i++) {
            printf(" %d", values[i]);
        }
        printf(" (%d)\n", bar_characters);
        printf("Barspaces: %.*s\n", (int) (d - dest), dest);
        printf("Checksum:  %d\n", total_sum);
    }
#ifdef ZINT_TEST
    if (symbol->debug & ZINT_DEBUG_TEST) {
        debug_test_codeword_dump_int(symbol, values, bar_characters);
    }
#endif

    expand(symbol, dest, d - dest);
}

/* Return codeword estimate (character encodation only) */
static int c128_glyph_count(const unsigned char source[], const int length, const char set[C128_MAX],
            const char fset[C128_MAX]) {
    int glyph_count = 0;
    char current_set = 0;
    int f_state = 0;
    int i;

    switch (set[0]) {
        case 'A':
        case 'b': /* Manual switching can cause immediate shift */
            current_set = 'A';
            break;
        case 'B':
        case 'a':
            current_set = 'B';
            break;
        case 'C':
            current_set = 'C';
            break;
    }

    for (i = 0; i < length; i++) {
        if (set[i] != current_set) {
            /* Latch different code set */
            switch (set[0]) {
                case 'A':
                case 'b': /* Manual switching can cause immediate shift */
                    if (current_set != 'A') {
                        current_set = 'A';
                        glyph_count++;
                    }
                    break;
                case 'B':
                case 'a':
                    if (current_set != 'B') {
                        current_set = 'B';
                        glyph_count++;
                    }
                    break;
                case 'C':
                    current_set = 'C';
                    glyph_count++;
                    break;
            }
        }
        if (fset) {
            if ((fset[i] == 'F' && f_state == 0) || (fset[i] == ' ' && f_state == 1)) {
                /* Latch beginning/end of extended mode */
                f_state = !f_state;
                glyph_count += 2;
            } else if ((fset[i] == 'f' && f_state == 0) || (fset[i] == 'n' && f_state == 1)) {
                /* Shift to or from extended mode */
                glyph_count++;
            }
        }
        if ((set[i] == 'a') || (set[i] == 'b')) {
            /* Insert shift character */
            glyph_count++;
        }

        /* Actual character */
        glyph_count++;

        if (set[i] == 'C' && source[i] != '\x1D') {
            i++;
        }
    }

    return glyph_count;
}

/* Handle Code 128, 128B and HIBC 128 */
INTERNAL int code128(struct zint_symbol *symbol, unsigned char source[], int length) {
    int i, j, k, read;
    int error_number;
    int values[C128_MAX] = {0}, bar_characters = 0;
    unsigned char src_buf[C128_MAX + 1];
    unsigned char *src = source;
    char manual_set[C128_MAX] = {0};
    unsigned char fncs[C128_MAX] = {0}; /* Manual FNC1 positions */
    char set[C128_MAX] = {0}, fset[C128_MAX], current_set = 0;
    int f_state = 0;
    int have_fnc1 = 0; /* Whether have at least 1 manual FNC1 */
    char manual_ch = 0;

    /* Suppresses clang-analyzer-core.UndefinedBinaryOperatorResult warning on fset which is fully set */
    assert(length > 0);

    if (length > C128_MAX) {
        /* This only blocks ridiculously long input - the actual length of the
           resulting barcode depends on the type of data, so this is trapped later */
        return errtxtf(ZINT_ERROR_TOO_LONG, symbol, 340, "Input length %d too long (maximum " C128_MAX_S ")", length);
    }

    /* Detect special Code Set escapes for Code 128 in extra escape mode only */
    if ((symbol->input_mode & EXTRA_ESCAPE_MODE) && symbol->symbology == BARCODE_CODE128) {
        j = 0;
        for (i = 0; i < length; i++) {
            if (source[i] == '\\' && i + 2 < length && source[i + 1] == '^'
                    && ((source[i + 2] >= 'A' && source[i + 2] <= 'C') || source[i + 2] == '1'
                        || source[i + 2] == '^')) {
                if (source[i + 2] == '^') { /* Escape sequence '\^^' */
                    manual_set[j] = manual_ch;
                    src_buf[j++] = source[i++];
                    manual_set[j] = manual_ch;
                    src_buf[j++] = source[i++];
                    /* Drop second '^' */
                } else if (source[i + 2] == '1') { /* FNC1 */
                    i += 2;
                    fncs[j] = have_fnc1 = 1;
                    manual_set[j] = manual_ch;
                    src_buf[j++] = '\x1D'; /* Manual FNC1 dummy */
                } else { /* Manual mode A/B/C */
                    i += 2;
                    manual_ch = source[i] - '@'; /* 1 (A), 2 (B), 3 (C) */
                }
            } else {
                manual_set[j] = manual_ch;
                src_buf[j++] = source[i];
            }
        }
        if (j != length) {
            length = j;
            if (length == 0) {
                return errtxt(ZINT_ERROR_INVALID_DATA, symbol, 842, "No input data");
            }
            src = src_buf;
            src[length] = '\0';
            if (symbol->debug & ZINT_DEBUG_PRINT) {
                fputs("MSet: ", stdout);
                for (i = 0; i < length; i++) printf("%c", manual_set[i] + '@');
                fputc('\n', stdout);
            }
        }
    }

    c128_define_mode(set, src, length, symbol->symbology == BARCODE_CODE128AB /*ab_only*/,
                    manual_ch ? manual_set : NULL, have_fnc1 ? fncs : NULL);

    /* Detect extended ASCII characters */
    for (i = 0; i < length; i++) {
        fset[i] = src[i] >= 128 ? 'f' : ' ';
    }

    /* Decide when to latch to extended mode - ISO/IEC 15417:2007 Annex E note 3 */
    j = 0;
    k = 0;
    for (i = 0; i < length; i++) {
        if (fset[i] == 'f') {
            j++;
            if (j >= 4) {
                fset[i] = 'F';
                if (!k) {
                    fset[i - 1] = fset[i - 2] = fset[i - 3] = 'F';
                    k = i;
                }
            }
        } else {
            j = 0;
            k = 0;
        }
    }
    if (j >= 3 && !k) {
        fset[length - 1] = fset[length - 2] = fset[length - 3] = 'F';
    }

    /* Decide if it is worth reverting to ASCII encodation for a few characters as described in 4.3.4.2 (d) */
    for (i = 1; i < length; i++) {
        if ((fset[i - 1] == 'F') && (fset[i] == ' ')) {
            int c = set[i] == 'C'; /* Count code set C so can subtract when deciding below */
            /* Detected a change from extended to ASCII - count how long for */
            for (j = 1; i + j < length && fset[i + j] == ' '; j++) {
                c += set[i + j] == 'C';
            }
            /* Count how many extended beyond */
            for (k = i + j < length; i + j + k < length && fset[i + j + k] != ' '; k++);
            if (j - c < 3 || (j - c < 5 && k > 2)) {
                /* Change to shifting back rather than latching back */
                /* Inverts the same figures recommended by ISO/IEC 15417:2007 Annex E note 3 */
                for (k = 0; k < j; k++) {
                    fset[i + k] = 'n';
                }
            }
        }
    }

    if (symbol->debug & ZINT_DEBUG_PRINT) {
        printf("Data: %.*s (%d)\n", length, src, length);
        printf(" Set: %.*s\n", length, set);
        printf("FSet: %.*s\n", length, fset);
    }

    /* Now we can calculate how long the barcode is going to be - and stop it from
       being too long */
    if ((i = c128_glyph_count(source, length, set, fset)) > C128_SYMBOL_MAX) {
        return errtxtf(ZINT_ERROR_TOO_LONG, symbol, 341,
                        "Input too long, requires %d symbol characters (maximum " C128_SYMBOL_MAX_S ")", i);
    }

    /* So now we know what start character to use - we can get on with it! */
    if (symbol->output_options & READER_INIT) {
        /* Reader Initialisation mode */
        switch (set[0]) {
            case 'A': /* Start A */
            case 'b': /* Manual switching can cause immediate shift */
                values[bar_characters++] = 103;
                current_set = 'A';
                values[bar_characters++] = 96; /* FNC3 */
                break;
            case 'B': /* Start B */
            case 'a':
                values[bar_characters++] = 104;
                current_set = 'B';
                values[bar_characters++] = 96; /* FNC3 */
                break;
            case 'C': /* Start C */
                values[bar_characters++] = 104; /* Start B */
                values[bar_characters++] = 96; /* FNC3 */
                values[bar_characters++] = 99; /* Code C */
                current_set = 'C';
                break;
        }
    } else {
        /* Normal mode */
        switch (set[0]) {
            case 'A': /* Start A */
            case 'b': /* Manual switching can cause immediate shift */
                values[bar_characters++] = 103;
                current_set = 'A';
                break;
            case 'B': /* Start B */
            case 'a':
                values[bar_characters++] = 104;
                current_set = 'B';
                break;
            case 'C': /* Start C */
                values[bar_characters++] = 105;
                current_set = 'C';
                break;
        }
    }

    /* Encode the data */
    for (read = 0; read < length; read++) {

        if (set[read] != current_set) {
            /* Latch different code set */
            switch (set[read]) {
                case 'A':
                case 'b': /* Manual switching can cause immediate shift */
                    if (current_set != 'A') {
                        values[bar_characters++] = 101;
                        current_set = 'A';
                    }
                    break;
                case 'B':
                case 'a':
                    if (current_set != 'B') {
                        values[bar_characters++] = 100;
                        current_set = 'B';
                    }
                    break;
                case 'C':
                    values[bar_characters++] = 99;
                    current_set = 'C';
                    break;
            }
        }

        if ((fset[read] == 'F' && f_state == 0) || (fset[read] == ' ' && f_state == 1)) {
            /* Latch beginning/end of extended mode */
            switch (current_set) {
                case 'A':
                    values[bar_characters++] = 101;
                    values[bar_characters++] = 101;
                    f_state = !f_state;
                    break;
                case 'B':
                    values[bar_characters++] = 100;
                    values[bar_characters++] = 100;
                    f_state = !f_state;
                    break;
            }
        } else if ((fset[read] == 'f' && f_state == 0) || (fset[read] == 'n' && f_state == 1)) {
            /* Shift to or from extended mode */
            switch (current_set) {
                case 'A':
                    values[bar_characters++] = 101; /* FNC4 */
                    break;
                case 'B':
                    values[bar_characters++] = 100; /* FNC4 */
                    break;
            }
        }

        if ((set[read] == 'a') || (set[read] == 'b')) {
            /* Insert shift character */
            values[bar_characters++] = 98;
        }

        /* Encode data characters */
        if (!fncs[read]) {
            switch (set[read]) {
                case 'A':
                case 'a':
                    c128_set_a(src[read], values, &bar_characters);
                    break;
                case 'B':
                case 'b':
                    (void) c128_set_b(src[read], values, &bar_characters);
                    break;
                case 'C':
                    c128_set_c(src[read], src[read + 1], values, &bar_characters);
                    read++;
                    break;
            }
        } else {
            values[bar_characters++] = 102; /* FNC1 in all modes */
        }

    }

    c128_expand(symbol, values, bar_characters);

    /* ISO/IEC 15417:2007 leaves dimensions/height as application specification */

    /* HRT */
    if (have_fnc1) {
        /* Remove any manual FNC1 dummies ('\x1D') */
        for (i = 0, j = 0; i < length; i++) {
            if (!fncs[i]) {
                src[j++] = src[i];
            }
        }
        length = j;
    }
    error_number = hrt_cpy_iso8859_1(symbol, src, length);

    return error_number;
}

/* Handle EAN-128 (Now known as GS1-128), and composite version if `cc_mode` set */
INTERNAL int gs1_128_cc(struct zint_symbol *symbol, unsigned char source[], int length, const int cc_mode,
                const int cc_rows) {
    int i, read;
    int error_number;
    int values[C128_MAX] = {0}, bar_characters = 0;
    char set[C128_MAX] = {0};
    int separator_row = 0, linkage_flag = 0;
    int reduced_length;
    unsigned char *reduced = (unsigned char *) z_alloca(length + 1);

    if (length > C128_MAX) {
        /* This only blocks ridiculously long input - the actual length of the
           resulting barcode depends on the type of data, so this is trapped later */
        return errtxtf(ZINT_ERROR_TOO_LONG, symbol, 342, "Input length %d too long (maximum " C128_MAX_S ")", length);
    }

    /* if part of a composite symbol make room for the separator pattern */
    if (symbol->symbology == BARCODE_GS1_128_CC) {
        separator_row = symbol->rows;
        symbol->row_height[symbol->rows] = 1;
        symbol->rows += 1;
    }

    error_number = gs1_verify(symbol, source, length, reduced);
    if (error_number >= ZINT_ERROR) {
        return error_number;
    }

    reduced_length = (int) ustrlen(reduced);

    c128_define_mode(set, reduced, reduced_length, 0 /*ab_only*/, NULL, NULL /*fncs*/);

    if (symbol->debug & ZINT_DEBUG_PRINT) {
        printf("Data: %s (%d)\n", reduced, reduced_length);
        printf(" Set: %.*s\n", reduced_length, set);
    }

    /* Now we can calculate how long the barcode is going to be - and stop it from
       being too long */
    if ((i = c128_glyph_count(reduced, reduced_length, set, NULL /*fset*/)) > C128_SYMBOL_MAX) {
        return errtxtf(ZINT_ERROR_TOO_LONG, symbol, 344,
                        "Input too long, requires %d symbol characters (maximum " C128_SYMBOL_MAX_S ")", i);
    }

    /* So now we know what start character to use - we can get on with it! */
    assert(set[0] == 'B' || set[0] == 'C');
    switch (set[0]) {
        case 'B': /* Start B */
            values[bar_characters++] = 104;
            break;
        case 'C': /* Start C */
            values[bar_characters++] = 105;
            break;
    }

    values[bar_characters++] = 102; /* FNC1 */

    /* Encode the data */
    for (read = 0; read < reduced_length; read++) {
        assert(set[read] == 'B' || set[read] == 'C');

        if ((read != 0) && (set[read] != set[read - 1])) {
            /* Latch different code set */
            switch (set[read]) {
                case 'B':
                    values[bar_characters++] = 100;
                    break;
                case 'C':
                    values[bar_characters++] = 99;
                    break;
            }
        }

        if (reduced[read] != '\x1D') {
            switch (set[read]) { /* Encode data characters */
                case 'B':
                    (void) c128_set_b(reduced[read], values, &bar_characters);
                    break;
                case 'C':
                    c128_set_c(reduced[read], reduced[read + 1], values, &bar_characters);
                    read++;
                    break;
            }
        } else {
            values[bar_characters++] = 102; /* FNC1 in all modes */
        }
    }

    /* "...note that the linkage flag is an extra code set character between
    the last data character and the Symbol Check Character" (GS1 Specification) */

    /* Linkage flags in GS1-128 are determined by ISO/IEC 24723 section 7.4 */

    switch (cc_mode) {
        case 1:
        case 2:
            /* CC-A or CC-B 2D component */
            switch (set[reduced_length - 1]) {
                case 'B': linkage_flag = 99;
                    break;
                case 'C': linkage_flag = 101;
                    break;
            }
            break;
        case 3:
            /* CC-C 2D component */
            switch (set[reduced_length - 1]) {
                case 'B': linkage_flag = 101;
                    break;
                case 'C': linkage_flag = 100;
                    break;
            }
            break;
    }

    if (linkage_flag != 0) {
        values[bar_characters++] = linkage_flag;
    }

    c128_expand(symbol, values, bar_characters);

    /* Add the separator pattern for composite symbols */
    if (symbol->symbology == BARCODE_GS1_128_CC) {
        for (i = 0; i < symbol->width; i++) {
            if (!(module_is_set(symbol, separator_row + 1, i))) {
                set_module(symbol, separator_row, i);
            }
        }
    }

    if (reduced_length > 48) { /* GS1 General Specifications 5.4.4.3 */
        if (error_number == 0) { /* Don't overwrite any `gs1_verify()` warning */
            error_number = errtxtf(ZINT_WARN_NONCOMPLIANT, symbol, 843,
                                    "Input too long, requires %d characters (maximum 48)", reduced_length);
        }
    }

    if (symbol->output_options & COMPLIANT_HEIGHT) {
        /* GS1 General Specifications 21.0.1 5.12.3.2 table 2, including footnote (**):
           same as ITF-14: "in case of further space constraints" height 5.8mm / 1.016mm (X max) ~ 5.7;
           default 31.75mm / 0.495mm ~ 64.14 */
        const float min_height = 5.70866156f; /* 5.8 / 1.016 */
        const float default_height = 64.1414108f; /* 31.75 / 0.495 */
        if (symbol->symbology == BARCODE_GS1_128_CC) {
            /* Pass back via temporary linear structure */
            symbol->height = symbol->height ? min_height : default_height;
        } else {
            if (error_number == 0) { /* Don't overwrite any `gs1_verify()` warning */
                error_number = set_height(symbol, min_height, default_height, 0.0f, 0 /*no_errtxt*/);
            } else {
                (void) set_height(symbol, min_height, default_height, 0.0f, 1 /*no_errtxt*/);
            }
        }
    } else {
        const float height = 50.0f;
        if (symbol->symbology == BARCODE_GS1_128_CC) {
            symbol->height = height - cc_rows * (cc_mode == 3 ? 3 : 2) - 1.0f;
        } else {
            (void) set_height(symbol, 0.0f, height, 0.0f, 1 /*no_errtxt*/);
        }
    }

    if (symbol->input_mode & GS1PARENS_MODE) {
        i = length < (int) sizeof(symbol->text) ? length : (int) sizeof(symbol->text);
        memcpy(symbol->text, source, i);
    } else {
        int bracket_level = 0; /* Non-compliant closing square brackets may be in text */
        for (i = 0; i < length && i < (int) sizeof(symbol->text); i++) {
            if (source[i] == '[') {
                symbol->text[i] = '(';
                bracket_level++;
            } else if (source[i] == ']' && bracket_level) {
                symbol->text[i] = ')';
                bracket_level--;
            } else {
                symbol->text[i] = source[i];
            }
        }
    }
    if (i == sizeof(symbol->text)) {
        /* Trumps all other warnings */
        error_number = errtxt(ZINT_WARN_HRT_TRUNCATED, symbol, 844, "Human Readable Text truncated");
        i--;
    }
    symbol->text[i] = '\0';

    return error_number;
}

/* Handle EAN-128 (Now known as GS1-128) */
INTERNAL int gs1_128(struct zint_symbol *symbol, unsigned char source[], int length) {
    return gs1_128_cc(symbol, source, length, 0 /*cc_mode*/, 0 /*cc_rows*/);
}

/* Add check digit if encoding an NVE18 symbol */
INTERNAL int nve18(struct zint_symbol *symbol, unsigned char source[], int length) {
    int i;
    int error_number, zeroes;
    unsigned char ean128_equiv[23];

    if (length > 17) {
        return errtxtf(ZINT_ERROR_TOO_LONG, symbol, 345, "Input length %d too long (maximum 17)", length);
    }

    if ((i = not_sane(NEON_F, source, length))) {
        /* Note: for all "at position" error messages, escape sequences not accounted for */
        return errtxtf(ZINT_ERROR_INVALID_DATA, symbol, 346,
                        "Invalid character at position %d in input (digits only)", i);
    }

    zeroes = 17 - length;
    ustrcpy(ean128_equiv, symbol->input_mode & GS1PARENS_MODE ? "(00)" : "[00]");
    memset(ean128_equiv + 4, '0', zeroes);
    ustrcpy(ean128_equiv + 4 + zeroes, source);

    ean128_equiv[21] = gs1_check_digit(ean128_equiv + 4, 17);
    ean128_equiv[22] = '\0';

    error_number = gs1_128(symbol, ean128_equiv, 22);

    return error_number;
}

/* EAN-14 - A version of EAN-128 */
INTERNAL int ean14(struct zint_symbol *symbol, unsigned char source[], int length) {
    int i;
    int error_number, zeroes;
    unsigned char ean128_equiv[19];

    if (length > 13) {
        return errtxtf(ZINT_ERROR_TOO_LONG, symbol, 347, "Input length %d too long (maximum 13)", length);
    }

    if ((i = not_sane(NEON_F, source, length))) {
        return errtxtf(ZINT_ERROR_INVALID_DATA, symbol, 348,
                        "Invalid character at position %d in input (digits only)", i);
    }

    zeroes = 13 - length;
    ustrcpy(ean128_equiv, symbol->input_mode & GS1PARENS_MODE ? "(01)" : "[01]");
    memset(ean128_equiv + 4, '0', zeroes);
    ustrcpy(ean128_equiv + 4 + zeroes, source);

    ean128_equiv[17] = gs1_check_digit(ean128_equiv + 4, 13);
    ean128_equiv[18] = '\0';

    error_number = gs1_128(symbol, ean128_equiv, 18);

    return error_number;
}

/* DPD (Deutscher Paketdienst) Code */
/* Specification at https://esolutions.dpd.com/dokumente/DPD_Parcel_Label_Specification_2.4.1_EN.pdf
 * and identification tag info (Barcode ID) at https://esolutions.dpd.com/dokumente/DPD_Routing_Database_1.3_EN.pdf */
INTERNAL int dpd(struct zint_symbol *symbol, unsigned char source[], int length) {
    int error_number = 0;
    int i, p;
    unsigned char ident_tag;
    unsigned char local_source_buf[29];
    unsigned char *local_source;
    const int mod = 36;
    const int relabel = symbol->option_2 == 1; /* A "relabel" has no identification tag */
    int cd; /* Check digit */

    if ((length != 27 && length != 28) || (length == 28 && relabel)) {
        if (relabel) {
            return errtxtf(ZINT_ERROR_TOO_LONG, symbol, 830, "DPD relabel input length %d wrong (27 only)", length);
        }
        return errtxtf(ZINT_ERROR_TOO_LONG, symbol, 349, "DPD input length %d wrong (27 or 28 only)", length);
    }

    if (length == 27 && !relabel) {
        local_source_buf[0] = '%';
        ustrcpy(local_source_buf + 1, source);
        local_source = local_source_buf;
        length++;
    } else {
        local_source = source;
    }

    ident_tag = local_source[0];

    to_upper(local_source + !relabel, length - !relabel);
    if ((i = not_sane(KRSET_F, local_source + !relabel, length - !relabel))) {
        if (local_source == local_source_buf || relabel) {
            return errtxtf(ZINT_ERROR_INVALID_DATA, symbol, 300,
                        "Invalid character at position %d in input (alphanumerics only)", i);
        }
        return errtxtf(ZINT_ERROR_INVALID_DATA, symbol, 299,
                        "Invalid character at position %d in input (alphanumerics only after first)", i);
    }

    if ((ident_tag < 32) || (ident_tag > 127)) {
        return errtxt(ZINT_ERROR_INVALID_DATA, symbol, 343,
                        "Invalid DPD identification tag (first character), ASCII values 32 to 127 only");
    }

    (void) code128(symbol, local_source, length); /* Only error returned is for large text which can't happen */

    if (!(symbol->output_options & (BARCODE_BOX | BARCODE_BIND | BARCODE_BIND_TOP))) {
        /* If no option has been selected then uses default bind top option */
        symbol->output_options |= BARCODE_BIND_TOP; /* Note won't extend over quiet zones for DPD */
        if (symbol->border_width == 0) { /* Allow override if non-zero */
            symbol->border_width = 3; /* From examples, not mentioned in spec */
        }
    }

    if (symbol->output_options & COMPLIANT_HEIGHT) {
        /* DPD Parcel Label Specification Version 2.4.1 (19.01.2021) Section 4.6.1.2
           25mm / 0.4mm (X max) = 62.5 min, 25mm / 0.375 (X) ~ 66.66 default */
        if (relabel) { /* If relabel then half-size */
            const float default_height = 33.3333321f; /* 12.5 / 0.375 */
            error_number = set_height(symbol, 31.25f, default_height, 0.0f, 0 /*no_errtxt*/);
        } else {
            const float default_height = 66.6666641f; /* 25.0 / 0.375 */
            error_number = set_height(symbol, 62.5f, default_height, 0.0f, 0 /*no_errtxt*/);
        }
    } else {
        (void) set_height(symbol, 0.0f, relabel ? 25.0f : 50.0f, 0.0f, 1 /*no_errtxt*/);
    }

    cd = mod;

    p = 0;
    for (i = !relabel; i < length; i++) {
        symbol->text[p] = local_source[i];
        p++;

        cd += posn(KRSET, local_source[i]);
        if (cd > mod) cd -= mod;
        cd *= 2;
        if (cd >= (mod + 1)) cd -= mod + 1;

        switch (i + relabel) {
            case 4:
            case 7:
            case 11:
            case 15:
            case 19:
            case 21:
            case 24:
            case 27:
                symbol->text[p++] = ' ';
                break;
        }
    }

    cd = mod + 1 - cd;
    if (cd == mod) cd = 0;

    if (cd < 10) {
        symbol->text[p] = cd + '0';
    } else {
        symbol->text[p] = (cd - 10) + 'A';
    }
    p++;

    symbol->text[p] = '\0';

    /* Some compliance checks */
    if (not_sane(NEON_F, local_source + length - 16, 16)) {
        if (not_sane(NEON_F, local_source + length - 3, 3)) { /* 3-digit Country Code (ISO 3166-1) */
            errtxt(0, symbol, 831, "Destination Country Code (last 3 characters) should be numeric");
        } else if (not_sane(NEON_F, local_source + length - 6, 3)) { /* 3-digit Service Code */
            errtxt(0, symbol, 832, "Service Code (characters 6-4 from end) should be numeric");
        } else { /* Last 10 characters of Tracking No. */
            errtxt(0, symbol, 833,
                    "Last 10 characters of Tracking Number (characters 16-7 from end) should be numeric");
        }
        error_number = ZINT_WARN_NONCOMPLIANT;
    }

    return error_number;
}

/* Universal Postal Union S10 */
/* https://www.upu.int/UPU/media/upu/files/postalSolutions/programmesAndServices/standards/S10-12.pdf */
INTERNAL int upu_s10(struct zint_symbol *symbol, unsigned char source[], int length) {
    int i, j;
    unsigned char local_source[13 + 1];
    unsigned char have_check_digit = '\0';
    int check_digit;
    static const char weights[8] = { 8, 6, 4, 2, 3, 5, 9, 7 };
    int error_number = 0;

    if (length != 12 && length != 13) {
        return errtxtf(ZINT_ERROR_TOO_LONG, symbol, 834, "Input length %d wrong (12 or 13 only)", length);
    }
    if (length == 13) { /* Includes check digit - remove for now */
        have_check_digit = source[10];
        memcpy(local_source, source, 10);
        ustrcpy(local_source + 10, source + 11);
    } else {
        ustrcpy(local_source, source);
    }
    to_upper(local_source, length);

    if (!z_isupper(local_source[0]) || !z_isupper(local_source[1])) {
        return errtxt(ZINT_ERROR_INVALID_DATA, symbol, 835,
                        "Invalid character in Service Indictor (first 2 characters) (alphabetic only)");
    }
    if (not_sane(NEON_F, local_source + 2, 12 - 4) || (have_check_digit && !z_isdigit(have_check_digit))) {
        return errtxtf(ZINT_ERROR_INVALID_DATA, symbol, 836,
                        "Invalid character in Serial Number (middle %d characters) (digits only)",
                        have_check_digit ? 9 : 8);
    }
    if (!z_isupper(local_source[10]) || !z_isupper(local_source[11])) {
        return errtxt(ZINT_ERROR_INVALID_DATA, symbol, 837,
                        "Invalid character in Country Code (last 2 characters) (alphabetic only)");
    }

    check_digit = 0;
    for (i = 2; i < 10; i++) { /* Serial Number only */
        check_digit += ctoi(local_source[i]) * weights[i - 2];
    }
    check_digit %= 11;
    check_digit = 11 - check_digit;
    if (check_digit == 10) {
        check_digit = 0;
    } else if (check_digit == 11) {
        check_digit = 5;
    }
    if (have_check_digit && ctoi(have_check_digit) != check_digit) {
        return errtxtf(ZINT_ERROR_INVALID_CHECK, symbol, 838, "Invalid check digit '%1$c', expecting '%2$c'",
                        have_check_digit, itoc(check_digit));
    }
    /* Add in (back) check digit */
    local_source[12] = local_source[11];
    local_source[11] = local_source[10];
    local_source[10] = itoc(check_digit);
    local_source[13] = '\0';

    /* Do some checks on the Service Indicator (first char only) and Country Code */
    if (strchr("JKSTW", local_source[0]) != NULL) { /* These are reserved & cannot be assigned */
        error_number = errtxt(ZINT_WARN_NONCOMPLIANT, symbol, 839,
                                "Invalid Service Indicator (first character should not be any of \"JKSTW\")");
    } else if (strchr("FHIOXY", local_source[0]) != NULL) { /* These aren't allocated as of spec Oct 2017 */
        error_number = errtxt(ZINT_WARN_NONCOMPLIANT, symbol, 840,
                                "Non-standard Service Indicator (first 2 characters)");
    } else if (!gs1_iso3166_alpha2(local_source + 11)) {
        error_number = errtxt(ZINT_WARN_NONCOMPLIANT, symbol, 841,
                                "Country code (last two characters) is not ISO 3166-1");
    }

    (void) code128(symbol, local_source, 13); /* Only error returned is for large text which can't happen */

    j = 0;
    for (i = 0; i < 13; i++) {
        if (i == 2 || i == 5 || i == 8 || i == 11) {
            symbol->text[j++] = ' ';
        }
        symbol->text[j++] = local_source[i];
    }
    symbol->text[j] = '\0';

    if (symbol->output_options & COMPLIANT_HEIGHT) {
        /* Universal Postal Union S10 Section 8, using max X 0.51mm & minimum height 12.5mm or 15% of width */
        const float min_height_min = 24.5098038f; /* 12.5 / 0.51 */
        float min_height = stripf(symbol->width * 0.15f);
        if (min_height < min_height_min) {
            min_height = min_height_min;
        }
        /* Using 50 as default as none recommended */
        if (error_number == 0) {
            error_number = set_height(symbol, min_height, min_height > 50.0f ? min_height : 50.0f, 0.0f,
                                        0 /*no_errtxt*/);
        } else {
            (void) set_height(symbol, min_height, min_height > 50.0f ? min_height : 50.0f, 0.0f, 1 /*no_errtxt*/);
        }
    } else {
        (void) set_height(symbol, 0.0f, 50.0f, 0.0f, 1 /*no_errtxt*/);
    }

    return error_number;
}

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