Mirrors/zint
1
0
Fork 0
mirror of https://git.code.sf.net/p/zint/code synced 2026-01-07 20:17:06 +00:00
Code Issues Projects Releases Wiki Activity

general: prefix all INTERNAL funcs/tables with zint_, except

Browse Source 
those in "backend/common.h", which are prefixed by `z_` - makes
  symbol clashes more unlikely when zint is statically linked
  (ticket #337, props Ulrich Becker)
DOTCODE: fix padding allowance (10 -> 52 - probable max 35) to
  cover cases with large no. of columns requested and little data,
  to prevent `codeword_array` buffer overflow
AZTEC/CODEONE: some code fiddling
general_field: prefix defines with `GF_`, shorten static funcs
  prefix `general_field_` -> `gf_`
This commit is contained in:
gitlost
2025-08-26 23:48:00 +01:00
parent e18b047a45
commit 39380d6767
106 changed files with 4477 additions and 4360 deletions
Download Patch File Download Diff File Expand all files Collapse all files

119
backend/general_field.c
View File

@@ -1,7 +1,7 @@
/* general_field.c - Handles general field compaction (GS1 DataBar and composites) */
/*
libzint - the open source barcode library
Copyright (C) 2019-2024 Robin Stuart <rstuart114@gmail.com>
Copyright (C) 2019-2025 Robin Stuart <rstuart114@gmail.com>
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
@@ -33,32 +33,32 @@
#include "common.h"
#include "general_field.h"
static const char alphanum_puncs[] = "*,-./";
static const char isoiec_puncs[] = "!\"%&'()*+,-./:;<=>?_ "; /* Note contains space, not in cset82 */
static const char gf_alphanum_puncs[] = "*,-./";
static const char gf_isoiec_puncs[] = "!\"%&'()*+,-./:;<=>?_ "; /* Note contains space, not in cset82 */
#define IS_ISOIEC_F (IS_LWR_F | IS_C82_F | IS_AST_F | IS_PLS_F | IS_MNS_F | IS_SPC_F)
/* Returns type of char at `i`. FNC1 counted as NUMERIC. Returns 0 if invalid char */
static int general_field_type(const char *general_field, const int i) {
static int gf_type(const char *general_field, const int i) {
if (general_field[i] == '\x1D' || z_isdigit(general_field[i])) {
return NUMERIC;
return GF_NUMERIC;
}
if (z_isupper(general_field[i]) || posn(alphanum_puncs, general_field[i]) != -1) {
return ALPHANUMERIC;
if (z_isupper(general_field[i]) || z_posn(gf_alphanum_puncs, general_field[i]) != -1) {
return GF_ALPHANUMERIC;
}
if (!not_sane(IS_ISOIEC_F, (const unsigned char *) general_field + i, 1)) {
return ISOIEC;
if (!z_not_sane(IS_ISOIEC_F, ZCUCP(general_field + i), 1)) {
return GF_ISOIEC;
}
return 0;
}
/* Returns true if next (including `i`) `num` chars of type `type`, or if given (non-zero), `type2` */
static int general_field_next(const char *general_field, int i, const int general_field_len, int num, const int type,
static int gf_next(const char *general_field, int i, const int general_field_len, int num, const int type,
const int type2) {
if (i + num > general_field_len) {
return 0;
}
for (; i < general_field_len && num; i++, num--) {
int type_i = general_field_type(general_field, i);
const int type_i = gf_type(general_field, i);
if ((type_i != type && !type2) || (type_i != type && type_i != type2)) {
return 0;
}
@@ -67,13 +67,13 @@ static int general_field_next(const char *general_field, int i, const int genera
}
/* Returns true if next (including `i`) `num` up to `max_num` chars of type `type` and occur at end */
static int general_field_next_terminate(const char *general_field, int i, const int general_field_len, int num,
static int gf_next_terminate(const char *general_field, int i, const int general_field_len, int num,
const int max_num, const int type) {
if (i + max_num < general_field_len) {
return 0;
}
for (; i < general_field_len; i++, num--) {
if (general_field_type(general_field, i) != type) {
if (gf_type(general_field, i) != type) {
return 0;
}
}
@@ -81,10 +81,10 @@ static int general_field_next_terminate(const char *general_field, int i, const
}
/* Returns true if none of the next (including `i`) `num` chars (or end occurs) of type `type` */
static int general_field_next_none(const char *general_field, int i, const int general_field_len, int num,
static int gf_next_none(const char *general_field, int i, const int general_field_len, int num,
const int type) {
for (; i < general_field_len && num; i++, num--) {
if (general_field_type(general_field, i) == type) {
if (gf_type(general_field, i) == type) {
return 0;
}
}
@@ -93,36 +93,36 @@ static int general_field_next_none(const char *general_field, int i, const int g
/* Attempts to apply encoding rules from sections 7.2.5.5.1 to 7.2.5.5.3
* of ISO/IEC 24724:2011 (same as sections 5.4.1 to 5.4.3 of ISO/IEC 24723:2010) */
INTERNAL int general_field_encode(const char *general_field, const int general_field_len, int *p_mode,
INTERNAL int zint_general_field_encode(const char *general_field, const int general_field_len, int *p_mode,
char *p_last_digit, char binary_string[], int *p_bp) {
int i, d1, d2;
int i;
int mode = *p_mode;
char last_digit = '\0'; /* Set to odd remaining digit at end if any */
int bp = *p_bp;
for (i = 0; i < general_field_len; ) {
int type = general_field_type(general_field, i);
const int type = gf_type(general_field, i);
if (!type) {
return 0;
}
switch (mode) {
case NUMERIC:
case GF_NUMERIC:
if (i < general_field_len - 1) { /* If at least 2 characters remain */
if (type != NUMERIC || general_field_type(general_field, i + 1) != NUMERIC) {
if (type != GF_NUMERIC || gf_type(general_field, i + 1) != GF_NUMERIC) {
/* 7.2.5.5.1/5.4.1 a) */
bp = bin_append_posn(0, 4, binary_string, bp); /* Alphanumeric latch "0000" */
mode = ALPHANUMERIC;
bp = z_bin_append_posn(0, 4, binary_string, bp); /* Alphanumeric latch "0000" */
mode = GF_ALPHANUMERIC;
} else {
d1 = general_field[i] == '\x1D' ? 10 : ctoi(general_field[i]);
d2 = general_field[i + 1] == '\x1D' ? 10 : ctoi(general_field[i + 1]);
bp = bin_append_posn((11 * d1) + d2 + 8, 7, binary_string, bp);
const int d1 = general_field[i] == '\x1D' ? 10 : z_ctoi(general_field[i]);
const int d2 = general_field[i + 1] == '\x1D' ? 10 : z_ctoi(general_field[i + 1]);
bp = z_bin_append_posn((11 * d1) + d2 + 8, 7, binary_string, bp);
i += 2;
}
} else { /* If 1 character remains */
if (type != NUMERIC) {
if (type != GF_NUMERIC) {
/* 7.2.5.5.1/5.4.1 b) */
bp = bin_append_posn(0, 4, binary_string, bp); /* Alphanumeric latch "0000" */
mode = ALPHANUMERIC;
bp = z_bin_append_posn(0, 4, binary_string, bp); /* Alphanumeric latch "0000" */
mode = GF_ALPHANUMERIC;
} else {
/* Ending with single digit.
* 7.2.5.5.1 c) and 5.4.1 c) dealt with separately outside this procedure */
@@ -131,66 +131,65 @@ INTERNAL int general_field_encode(const char *general_field, const int general_f
}
}
break;
case ALPHANUMERIC:
case GF_ALPHANUMERIC:
if (general_field[i] == '\x1D') {
/* 7.2.5.5.2/5.4.2 a) */
bp = bin_append_posn(15, 5, binary_string, bp); /* "01111" */
mode = NUMERIC;
bp = z_bin_append_posn(15, 5, binary_string, bp); /* "01111" */
mode = GF_NUMERIC;
i++;
} else if (type == ISOIEC) {
} else if (type == GF_ISOIEC) {
/* 7.2.5.5.2/5.4.2 b) */
bp = bin_append_posn(4, 5, binary_string, bp); /* ISO/IEC 646 latch "00100" */
mode = ISOIEC;
} else if (general_field_next(general_field, i, general_field_len, 6, NUMERIC, 0)) {
bp = z_bin_append_posn(4, 5, binary_string, bp); /* ISO/IEC 646 latch "00100" */
mode = GF_ISOIEC;
} else if (gf_next(general_field, i, general_field_len, 6, GF_NUMERIC, 0)) {
/* 7.2.5.5.2/5.4.2 c) */
bp = bin_append_posn(0, 3, binary_string, bp); /* Numeric latch "000" */
mode = NUMERIC;
} else if (general_field_next_terminate(general_field, i, general_field_len, 4,
5 /*Can limit to 5 max due to above*/, NUMERIC)) {
bp = z_bin_append_posn(0, 3, binary_string, bp); /* Numeric latch "000" */
mode = GF_NUMERIC;
} else if (gf_next_terminate(general_field, i, general_field_len, 4,
5 /*Can limit to 5 max due to above*/, GF_NUMERIC)) {
/* 7.2.5.5.2/5.4.2 d) */
bp = bin_append_posn(0, 3, binary_string, bp); /* Numeric latch "000" */
mode = NUMERIC;
bp = z_bin_append_posn(0, 3, binary_string, bp); /* Numeric latch "000" */
mode = GF_NUMERIC;
} else if (z_isdigit(general_field[i])) {
bp = bin_append_posn(general_field[i] - 43, 5, binary_string, bp);
bp = z_bin_append_posn(general_field[i] - 43, 5, binary_string, bp);
i++;
} else if (z_isupper(general_field[i])) {
bp = bin_append_posn(general_field[i] - 33, 6, binary_string, bp);
bp = z_bin_append_posn(general_field[i] - 33, 6, binary_string, bp);
i++;
} else {
bp = bin_append_posn(posn(alphanum_puncs, general_field[i]) + 58, 6, binary_string, bp);
bp = z_bin_append_posn(z_posn(gf_alphanum_puncs, general_field[i]) + 58, 6, binary_string, bp);
i++;
}
break;
case ISOIEC:
case GF_ISOIEC:
if (general_field[i] == '\x1D') {
/* 7.2.5.5.3/5.4.3 a) */
bp = bin_append_posn(15, 5, binary_string, bp); /* "01111" */
mode = NUMERIC;
bp = z_bin_append_posn(15, 5, binary_string, bp); /* "01111" */
mode = GF_NUMERIC;
i++;
} else {
int next_10_not_isoiec = general_field_next_none(general_field, i, general_field_len, 10, ISOIEC);
if (next_10_not_isoiec && general_field_next(general_field, i, general_field_len, 4,
NUMERIC, 0)) {
const int next_10_not_isoiec = gf_next_none(general_field, i, general_field_len, 10, GF_ISOIEC);
if (next_10_not_isoiec && gf_next(general_field, i, general_field_len, 4, GF_NUMERIC, 0)) {
/* 7.2.5.5.3/5.4.3 b) */
bp = bin_append_posn(0, 3, binary_string, bp); /* Numeric latch "000" */
mode = NUMERIC;
} else if (next_10_not_isoiec && general_field_next(general_field, i, general_field_len, 5,
ALPHANUMERIC, NUMERIC)) {
bp = z_bin_append_posn(0, 3, binary_string, bp); /* Numeric latch "000" */
mode = GF_NUMERIC;
} else if (next_10_not_isoiec && gf_next(general_field, i, general_field_len, 5,
GF_ALPHANUMERIC, GF_NUMERIC)) {
/* 7.2.5.5.3/5.4.3 c) */
/* Note this rule can produce longer bitstreams if most of the alphanumerics are numeric */
bp = bin_append_posn(4, 5, binary_string, bp); /* Alphanumeric latch "00100" */
mode = ALPHANUMERIC;
bp = z_bin_append_posn(4, 5, binary_string, bp); /* Alphanumeric latch "00100" */
mode = GF_ALPHANUMERIC;
} else if (z_isdigit(general_field[i])) {
bp = bin_append_posn(general_field[i] - 43, 5, binary_string, bp);
bp = z_bin_append_posn(general_field[i] - 43, 5, binary_string, bp);
i++;
} else if (z_isupper(general_field[i])) {
bp = bin_append_posn(general_field[i] - 1, 7, binary_string, bp);
bp = z_bin_append_posn(general_field[i] - 1, 7, binary_string, bp);
i++;
} else if (z_islower(general_field[i])) {
bp = bin_append_posn(general_field[i] - 7, 7, binary_string, bp);
bp = z_bin_append_posn(general_field[i] - 7, 7, binary_string, bp);
i++;
} else {
bp = bin_append_posn(posn(isoiec_puncs, general_field[i]) + 232, 8, binary_string, bp);
bp = z_bin_append_posn(z_posn(gf_isoiec_puncs, general_field[i]) + 232, 8, binary_string, bp);
i++;
}
}