mirrors/zint
2
0
Fork 0
mirror of https://github.com/zint/zint synced 2024-11-16 20:57:25 +13:00
Code Issues Actions Packages Projects Releases Wiki Activity

Audit of error codes

Browse Source
This commit is contained in:
Robin Stuart 2017-07-27 16:01:53 +01:00
parent 58e80a9ff7
commit 608b4b9134
38 changed files with 345 additions and 345 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
backend/2of5.c
View File

@ -65,12 +65,12 @@ int matrix_two_of_five(struct zint_symbol *symbol, unsigned char source[], int l
char dest[512]; /* 6 + 80 * 6 + 6 + 1 ~ 512*/ char dest[512]; /* 6 + 80 * 6 + 6 + 1 ~ 512*/
if (length > 80) { if (length > 80) {
strcpy(symbol->errtxt, "Input too long (C01)"); strcpy(symbol->errtxt, "301: Input too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
error_number = is_sane(NEON, source, length); error_number = is_sane(NEON, source, length);
if (error_number == ZINT_ERROR_INVALID_DATA) { if (error_number == ZINT_ERROR_INVALID_DATA) {
strcpy(symbol->errtxt, "Invalid characters in data (C02)"); strcpy(symbol->errtxt, "302: Invalid characters in data");
return error_number; return error_number;
} }
@ -96,12 +96,12 @@ int industrial_two_of_five(struct zint_symbol *symbol, unsigned char source[], i
char dest[512]; /* 6 + 40 * 10 + 6 + 1 */ char dest[512]; /* 6 + 40 * 10 + 6 + 1 */
if (length > 45) { if (length > 45) {
strcpy(symbol->errtxt, "Input too long (C03)"); strcpy(symbol->errtxt, "303: Input too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
error_number = is_sane(NEON, source, length); error_number = is_sane(NEON, source, length);
if (error_number == ZINT_ERROR_INVALID_DATA) { if (error_number == ZINT_ERROR_INVALID_DATA) {
strcpy(symbol->errtxt, "Invalid character in data (C04)"); strcpy(symbol->errtxt, "304: Invalid character in data");
return error_number; return error_number;
} }
@ -126,12 +126,12 @@ int iata_two_of_five(struct zint_symbol *symbol, unsigned char source[], int len
char dest[512]; /* 4 + 45 * 10 + 3 + 1 */ char dest[512]; /* 4 + 45 * 10 + 3 + 1 */
if (length > 45) { if (length > 45) {
strcpy(symbol->errtxt, "Input too long (C05)"); strcpy(symbol->errtxt, "305: Input too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
error_number = is_sane(NEON, source, length); error_number = is_sane(NEON, source, length);
if (error_number == ZINT_ERROR_INVALID_DATA) { if (error_number == ZINT_ERROR_INVALID_DATA) {
strcpy(symbol->errtxt, "Invalid characters in data (C06)"); strcpy(symbol->errtxt, "306: Invalid characters in data");
return error_number; return error_number;
} }
@ -157,12 +157,12 @@ int logic_two_of_five(struct zint_symbol *symbol, unsigned char source[], int le
char dest[512]; /* 4 + 80 * 6 + 3 + 1 */ char dest[512]; /* 4 + 80 * 6 + 3 + 1 */
if (length > 80) { if (length > 80) {
strcpy(symbol->errtxt, "Input too long (C07)"); strcpy(symbol->errtxt, "307: Input too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
error_number = is_sane(NEON, source, length); error_number = is_sane(NEON, source, length);
if (error_number == ZINT_ERROR_INVALID_DATA) { if (error_number == ZINT_ERROR_INVALID_DATA) {
strcpy(symbol->errtxt, "Invalid characters in data (C08)"); strcpy(symbol->errtxt, "308: Invalid characters in data");
return error_number; return error_number;
} }
@ -193,12 +193,12 @@ int interleaved_two_of_five(struct zint_symbol *symbol, const unsigned char sour
#endif #endif
if (length > 89) { if (length > 89) {
strcpy(symbol->errtxt, "Input too long (C09)"); strcpy(symbol->errtxt, "309: Input too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
error_number = is_sane(NEON, source, length); error_number = is_sane(NEON, source, length);
if (error_number == ZINT_ERROR_INVALID_DATA) { if (error_number == ZINT_ERROR_INVALID_DATA) {
strcpy(symbol->errtxt, "Invalid characters in data (C0A)"); strcpy(symbol->errtxt, "310: Invalid characters in data");
return error_number; return error_number;
} }
@ -251,13 +251,13 @@ int itf14(struct zint_symbol *symbol, unsigned char source[], int length) {
count = 0; count = 0;
if (length > 13) { if (length > 13) {
strcpy(symbol->errtxt, "Input too long (C0B)"); strcpy(symbol->errtxt, "311: Input too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
error_number = is_sane(NEON, source, length); error_number = is_sane(NEON, source, length);
if (error_number == ZINT_ERROR_INVALID_DATA) { if (error_number == ZINT_ERROR_INVALID_DATA) {
strcpy(symbol->errtxt, "Invalid character in data (C0D)"); strcpy(symbol->errtxt, "312: Invalid character in data");
return error_number; return error_number;
} }
@ -292,12 +292,12 @@ int dpleit(struct zint_symbol *symbol, unsigned char source[], int length) {
count = 0; count = 0;
if (length > 13) { if (length > 13) {
strcpy(symbol->errtxt, "Input wrong length (C0E)"); strcpy(symbol->errtxt, "313: Input wrong length");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
error_number = is_sane(NEON, source, length); error_number = is_sane(NEON, source, length);
if (error_number == ZINT_ERROR_INVALID_DATA) { if (error_number == ZINT_ERROR_INVALID_DATA) {
strcpy(symbol->errtxt, "Invalid characters in data (C0D)"); strcpy(symbol->errtxt, "314: Invalid characters in data");
return error_number; return error_number;
} }
@ -328,12 +328,12 @@ int dpident(struct zint_symbol *symbol, unsigned char source[], int length) {
count = 0; count = 0;
if (length > 11) { if (length > 11) {
strcpy(symbol->errtxt, "Input wrong length (C0E)"); strcpy(symbol->errtxt, "315: Input wrong length");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
error_number = is_sane(NEON, source, length); error_number = is_sane(NEON, source, length);
if (error_number == ZINT_ERROR_INVALID_DATA) { if (error_number == ZINT_ERROR_INVALID_DATA) {
strcpy(symbol->errtxt, "Invalid characters in data (C0F)"); strcpy(symbol->errtxt, "316: Invalid characters in data");
return error_number; return error_number;
} }

10
backend/auspost.c
View File

@ -138,16 +138,16 @@ int australia_post(struct zint_symbol *symbol, unsigned char source[], int lengt
error_number = is_sane(NEON, source, length); error_number = is_sane(NEON, source, length);
break; break;
default: default:
strcpy(symbol->errtxt, "Auspost input is wrong length (D01)"); strcpy(symbol->errtxt, "401: Auspost input is wrong length");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
if (error_number == ZINT_ERROR_INVALID_DATA) { if (error_number == ZINT_ERROR_INVALID_DATA) {
strcpy(symbol->errtxt, "Invalid characters in data (D02)"); strcpy(symbol->errtxt, "402: Invalid characters in data");
return error_number; return error_number;
} }
} else { } else {
if (length > 8) { if (length > 8) {
strcpy(symbol->errtxt, "Auspost input is too long (D03)"); strcpy(symbol->errtxt, "403: Auspost input is too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
switch (symbol->symbology) { switch (symbol->symbology) {
@ -169,7 +169,7 @@ int australia_post(struct zint_symbol *symbol, unsigned char source[], int lengt
h = strlen(localstr); h = strlen(localstr);
error_number = is_sane(GDSET, (unsigned char *) localstr, h); error_number = is_sane(GDSET, (unsigned char *) localstr, h);
if (error_number == ZINT_ERROR_INVALID_DATA) { if (error_number == ZINT_ERROR_INVALID_DATA) {
strcpy(symbol->errtxt, "Invalid characters in data (D04)"); strcpy(symbol->errtxt, "404: Invalid characters in data");
return error_number; return error_number;
} }
@ -178,7 +178,7 @@ int australia_post(struct zint_symbol *symbol, unsigned char source[], int lengt
dpid[8] = '\0'; dpid[8] = '\0';
error_number = is_sane(NEON, (unsigned char *) dpid, strlen(dpid)); error_number = is_sane(NEON, (unsigned char *) dpid, strlen(dpid));
if (error_number == ZINT_ERROR_INVALID_DATA) { if (error_number == ZINT_ERROR_INVALID_DATA) {
strcpy(symbol->errtxt, "Invalid characters in DPID (D05)"); strcpy(symbol->errtxt, "405: Invalid characters in DPID");
return error_number; return error_number;
} }

20
backend/aztec.c
View File

@ -987,7 +987,7 @@ int aztec(struct zint_symbol *symbol, unsigned char source[], const size_t lengt
comp_loop = 1; comp_loop = 1;
} }
if (gs1 && reader) { if (gs1 && reader) {
strcpy(symbol->errtxt, "Cannot encode in GS1 and Reader Initialisation mode at the same time (E01)"); strcpy(symbol->errtxt, "501: Cannot encode in GS1 and Reader Initialisation mode at the same time");
return ZINT_ERROR_INVALID_OPTION; return ZINT_ERROR_INVALID_OPTION;
} }
@ -996,12 +996,12 @@ int aztec(struct zint_symbol *symbol, unsigned char source[], const size_t lengt
err_code = aztec_text_process(source, length, binary_string, gs1, symbol->eci, symbol->debug); err_code = aztec_text_process(source, length, binary_string, gs1, symbol->eci, symbol->debug);
if (err_code != 0) { if (err_code != 0) {
strcpy(symbol->errtxt, "Input too long or too many extended ASCII characters (E02)"); strcpy(symbol->errtxt, "502: Input too long or too many extended ASCII characters");
return err_code; return err_code;
} }
if (!((symbol->option_1 >= -1) && (symbol->option_1 <= 4))) { if (!((symbol->option_1 >= -1) && (symbol->option_1 <= 4))) {
strcpy(symbol->errtxt, "Invalid error correction level - using default instead (E03)"); strcpy(symbol->errtxt, "503: Invalid error correction level - using default instead");
err_code = ZINT_WARN_INVALID_OPTION; err_code = ZINT_WARN_INVALID_OPTION;
symbol->option_1 = -1; symbol->option_1 = -1;
} }
@ -1089,7 +1089,7 @@ int aztec(struct zint_symbol *symbol, unsigned char source[], const size_t lengt
} }
if (layers == 0) { /* Couldn't find a symbol which fits the data */ if (layers == 0) { /* Couldn't find a symbol which fits the data */
strcpy(symbol->errtxt, "Input too long (too many bits for selected ECC) (E04)"); strcpy(symbol->errtxt, "504: Input too long (too many bits for selected ECC)");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
@ -1195,7 +1195,7 @@ int aztec(struct zint_symbol *symbol, unsigned char source[], const size_t lengt
layers = symbol->option_2 - 4; layers = symbol->option_2 - 4;
} }
if ((symbol->option_2 < 0) || (symbol->option_2 > 36)) { if ((symbol->option_2 < 0) || (symbol->option_2 > 36)) {
strcpy(symbol->errtxt, "Invalid Aztec Code size"); strcpy(symbol->errtxt, "510: Invalid Aztec Code size");
return ZINT_ERROR_INVALID_OPTION; return ZINT_ERROR_INVALID_OPTION;
} }
@ -1281,7 +1281,7 @@ int aztec(struct zint_symbol *symbol, unsigned char source[], const size_t lengt
} }
if (adjusted_length > data_maxsize) { if (adjusted_length > data_maxsize) {
strcpy(symbol->errtxt, "Data too long for specified Aztec Code symbol size (E05)"); strcpy(symbol->errtxt, "505: Data too long for specified Aztec Code symbol size");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
@ -1298,7 +1298,7 @@ int aztec(struct zint_symbol *symbol, unsigned char source[], const size_t lengt
} }
if (reader && (layers > 22)) { if (reader && (layers > 22)) {
strcpy(symbol->errtxt, "Data too long for reader initialisation symbol (E06)"); strcpy(symbol->errtxt, "506: Data too long for reader initialisation symbol");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
@ -1638,12 +1638,12 @@ int aztec_runes(struct zint_symbol *symbol, unsigned char source[], int length)
error_number = 0; error_number = 0;
input_value = 0; input_value = 0;
if (length > 3) { if (length > 3) {
strcpy(symbol->errtxt, "Input too large (E07)"); strcpy(symbol->errtxt, "507: Input too large");
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }
error_number = is_sane(NEON, source, length); error_number = is_sane(NEON, source, length);
if (error_number != 0) { if (error_number != 0) {
strcpy(symbol->errtxt, "Invalid characters in input (E08)"); strcpy(symbol->errtxt, "508: Invalid characters in input");
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }
switch (length) { switch (length) {
@ -1659,7 +1659,7 @@ int aztec_runes(struct zint_symbol *symbol, unsigned char source[], int length)
} }
if (input_value > 255) { if (input_value > 255) {
strcpy(symbol->errtxt, "Input too large (E09)"); strcpy(symbol->errtxt, "509: Input too large");
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }

4
backend/bmp.c
View File

@ -122,7 +122,7 @@ int bmp_pixel_plot(struct zint_symbol *symbol, char *pixelbuf) {
if ((symbol->output_options & BARCODE_STDOUT) != 0) { if ((symbol->output_options & BARCODE_STDOUT) != 0) {
#ifdef _MSC_VER #ifdef _MSC_VER
if (-1 == _setmode(_fileno(stdout), _O_BINARY)) { if (-1 == _setmode(_fileno(stdout), _O_BINARY)) {
strcpy(symbol->errtxt, "Can't open output file"); strcpy(symbol->errtxt, "600: Can't open output file");
free(bitmap_file_start); free(bitmap_file_start);
free(bitmap); free(bitmap);
return ZINT_ERROR_FILE_ACCESS; return ZINT_ERROR_FILE_ACCESS;
@ -133,7 +133,7 @@ int bmp_pixel_plot(struct zint_symbol *symbol, char *pixelbuf) {
if (!(bmp_file = fopen(symbol->outfile, "wb"))) { if (!(bmp_file = fopen(symbol->outfile, "wb"))) {
free(bitmap_file_start); free(bitmap_file_start);
free(bitmap); free(bitmap);
strcpy(symbol->errtxt, "Can't open output file (F00)"); strcpy(symbol->errtxt, "601: Can't open output file");
return ZINT_ERROR_FILE_ACCESS; return ZINT_ERROR_FILE_ACCESS;
} }
} }

8
backend/codablock.c
View File

@ -652,18 +652,18 @@ int codablock(struct zint_symbol *symbol,const unsigned char source[], const siz
/* option1: rows 0: automatic, 1..44 */ /* option1: rows 0: automatic, 1..44 */
rows = symbol->option_1; rows = symbol->option_1;
if (rows > 44) { if (rows > 44) {
strcpy(symbol->errtxt, "Row parameter not in 0..44 (D10)"); strcpy(symbol->errtxt, "410: Row parameter not in 0..44");
return ZINT_ERROR_INVALID_OPTION; return ZINT_ERROR_INVALID_OPTION;
} }
/* option_2: (usable data) columns: 0: automatic, 6..66 */ /* option_2: (usable data) columns: 0: automatic, 6..66 */
columns = symbol->option_2; columns = symbol->option_2;
if ( ! (columns <= 0 || (columns >= 6 && columns <=66)) ) { if ( ! (columns <= 0 || (columns >= 6 && columns <=66)) ) {
strcpy(symbol->errtxt, "Columns parameter not in 0,6..66 (D11)"); strcpy(symbol->errtxt, "411: Columns parameter not in 0,6..66");
return ZINT_ERROR_INVALID_OPTION; return ZINT_ERROR_INVALID_OPTION;
} }
/* GS1 not implemented */ /* GS1 not implemented */
if (symbol->input_mode == GS1_MODE) { if (symbol->input_mode == GS1_MODE) {
strcpy(symbol->errtxt, "GS1 mode not supported (D12)"); strcpy(symbol->errtxt, "412: GS1 mode not supported");
return ZINT_ERROR_INVALID_OPTION; return ZINT_ERROR_INVALID_OPTION;
} }
#ifndef _MSC_VER #ifndef _MSC_VER
@ -725,7 +725,7 @@ int codablock(struct zint_symbol *symbol,const unsigned char source[], const siz
Error=Columns2Rows(T,data,dataLength,&rows,&useColumns,pSet,&fillings); Error=Columns2Rows(T,data,dataLength,&rows,&useColumns,pSet,&fillings);
} }
if (Error != 0) { if (Error != 0) {
strcpy(symbol->errtxt, "data string to long (D13)"); strcpy(symbol->errtxt, "413: Data string to long");
return Error; return Error;
} }
/* Checksum */ /* Checksum */

32
backend/code.c
View File

@ -113,12 +113,12 @@ int code_11(struct zint_symbol *symbol, unsigned char source[], int length) { /*
char checkstr[3]; char checkstr[3];
if (length > 121) { if (length > 121) {
strcpy(symbol->errtxt, "Input too long (C20)"); strcpy(symbol->errtxt, "320: Input too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
error_number = is_sane(SODIUM, source, length); error_number = is_sane(SODIUM, source, length);
if (error_number == ZINT_ERROR_INVALID_DATA) { if (error_number == ZINT_ERROR_INVALID_DATA) {
strcpy(symbol->errtxt, "Invalid characters in data (C21)"); strcpy(symbol->errtxt, "321: Invalid characters in data");
return error_number; return error_number;
} }
c_weight = 1; c_weight = 1;
@ -200,16 +200,16 @@ int c39(struct zint_symbol *symbol, unsigned char source[], const size_t length)
} }
if ((symbol->symbology == BARCODE_LOGMARS) && (length > 59)) { if ((symbol->symbology == BARCODE_LOGMARS) && (length > 59)) {
strcpy(symbol->errtxt, "Input too long (C22)"); strcpy(symbol->errtxt, "322: Input too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} else if (length > 74) { } else if (length > 74) {
strcpy(symbol->errtxt, "Input too long (C23)"); strcpy(symbol->errtxt, "323: Input too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
to_upper(source); to_upper(source);
error_number = is_sane(SILVER, source, length); error_number = is_sane(SILVER, source, length);
if (error_number == ZINT_ERROR_INVALID_DATA) { if (error_number == ZINT_ERROR_INVALID_DATA) {
strcpy(symbol->errtxt, "Invalid characters in data (C24)"); strcpy(symbol->errtxt, "324: Invalid characters in data");
return error_number; return error_number;
} }
@ -297,12 +297,12 @@ int pharmazentral(struct zint_symbol *symbol, unsigned char source[], int length
count = 0; count = 0;
if (length > 7) { if (length > 7) {
strcpy(symbol->errtxt, "Input wrong length (C25)"); strcpy(symbol->errtxt, "325: Input wrong length");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
error_number = is_sane(NEON, source, length); error_number = is_sane(NEON, source, length);
if (error_number == ZINT_ERROR_INVALID_DATA) { if (error_number == ZINT_ERROR_INVALID_DATA) {
strcpy(symbol->errtxt, "Invalid characters in data (C26)"); strcpy(symbol->errtxt, "326: Invalid characters in data");
return error_number; return error_number;
} }
@ -323,7 +323,7 @@ int pharmazentral(struct zint_symbol *symbol, unsigned char source[], int length
localstr[8] = itoc(check_digit); localstr[8] = itoc(check_digit);
localstr[9] = '\0'; localstr[9] = '\0';
if (localstr[8] == 'A') { if (localstr[8] == 'A') {
strcpy(symbol->errtxt, "Invalid PZN Data (C27)"); strcpy(symbol->errtxt, "327: Invalid PZN Data");
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }
error_number = c39(symbol, (unsigned char *) localstr, strlen(localstr)); error_number = c39(symbol, (unsigned char *) localstr, strlen(localstr));
@ -340,7 +340,7 @@ int ec39(struct zint_symbol *symbol, unsigned char source[], int length) {
int error_number; int error_number;
if (length > 74) { if (length > 74) {
strcpy(symbol->errtxt, "Input too long (C28)"); strcpy(symbol->errtxt, "328: Input too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
@ -348,7 +348,7 @@ int ec39(struct zint_symbol *symbol, unsigned char source[], int length) {
for (i = 0; i < (unsigned int) length; i++) { for (i = 0; i < (unsigned int) length; i++) {
if (source[i] > 127) { if (source[i] > 127) {
/* Cannot encode extended ASCII */ /* Cannot encode extended ASCII */
strcpy(symbol->errtxt, "Invalid characters in input data (C29)"); strcpy(symbol->errtxt, "329: Invalid characters in input data");
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }
strcat((char*) buffer, EC39Ctrl[source[i]]); strcat((char*) buffer, EC39Ctrl[source[i]]);
@ -381,7 +381,7 @@ int c93(struct zint_symbol *symbol, unsigned char source[], int length) {
strcpy(buffer, ""); strcpy(buffer, "");
if (length > 107) { if (length > 107) {
strcpy(symbol->errtxt, "Input too long (C2A)"); strcpy(symbol->errtxt, "330: Input too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
@ -389,7 +389,7 @@ int c93(struct zint_symbol *symbol, unsigned char source[], int length) {
for (i = 0; i < length; i++) { for (i = 0; i < length; i++) {
if (source[i] > 127) { if (source[i] > 127) {
/* Cannot encode extended ASCII */ /* Cannot encode extended ASCII */
strcpy(symbol->errtxt, "Invalid characters in input data (C2B)"); strcpy(symbol->errtxt, "331: Invalid characters in input data");
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }
strcat(buffer, C93Ctrl[source[i]]); strcat(buffer, C93Ctrl[source[i]]);
@ -399,7 +399,7 @@ int c93(struct zint_symbol *symbol, unsigned char source[], int length) {
/* Now we can check the true length of the barcode */ /* Now we can check the true length of the barcode */
h = (int) strlen(buffer); h = (int) strlen(buffer);
if (h > 107) { if (h > 107) {
strcpy(symbol->errtxt, "Input too long (C2C)"); strcpy(symbol->errtxt, "332: Input too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
@ -514,12 +514,12 @@ int channel_code(struct zint_symbol *symbol, unsigned char source[], int length)
target_value = 0; target_value = 0;
if (length > 7) { if (length > 7) {
strcpy(symbol->errtxt, "Input too long (C2D)"); strcpy(symbol->errtxt, "333: Input too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
error_number = is_sane(NEON, source, length); error_number = is_sane(NEON, source, length);
if (error_number == ZINT_ERROR_INVALID_DATA) { if (error_number == ZINT_ERROR_INVALID_DATA) {
strcpy(symbol->errtxt, "Invalid characters in data (C2E)"); strcpy(symbol->errtxt, "334: Invalid characters in data");
return error_number; return error_number;
} }
@ -567,7 +567,7 @@ int channel_code(struct zint_symbol *symbol, unsigned char source[], int length)
break; break;
} }
if (range) { if (range) {
strcpy(symbol->errtxt, "Value out of range (C2F)"); strcpy(symbol->errtxt, "335: Value out of range");
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }

16
backend/code1.c
View File

@ -1008,7 +1008,7 @@ int c1_encode(struct zint_symbol *symbol, unsigned char source[], unsigned int t
if (tp > 1480) { if (tp > 1480) {
/* Data is too large for symbol */ /* Data is too large for symbol */
strcpy(symbol->errtxt, "Input data too long (E10)"); strcpy(symbol->errtxt, "511: Input data too long");
return 0; return 0;
} }
} while (sp < length); } while (sp < length);
@ -1153,7 +1153,7 @@ int c1_encode(struct zint_symbol *symbol, unsigned char source[], unsigned int t
/* Re-check length of data */ /* Re-check length of data */
if (tp > 1480) { if (tp > 1480) {
/* Data is too large for symbol */ /* Data is too large for symbol */
strcpy(symbol->errtxt, "Input data too long (E11)"); strcpy(symbol->errtxt, "512: Input data too long");
return 0; return 0;
} }
/* /*
@ -1186,7 +1186,7 @@ int code_one(struct zint_symbol *symbol, unsigned char source[], int length) {
int sub_version = 0; int sub_version = 0;
if ((symbol->option_2 < 0) || (symbol->option_2 > 10)) { if ((symbol->option_2 < 0) || (symbol->option_2 > 10)) {
strcpy(symbol->errtxt, "Invalid symbol size (E12)"); strcpy(symbol->errtxt, "513: Invalid symbol size");
return ZINT_ERROR_INVALID_OPTION; return ZINT_ERROR_INVALID_OPTION;
} }
@ -1199,11 +1199,11 @@ int code_one(struct zint_symbol *symbol, unsigned char source[], int length) {
int block_width; int block_width;
if (length > 18) { if (length > 18) {
strcpy(symbol->errtxt, "Input data too long (E13)"); strcpy(symbol->errtxt, "514: Input data too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
if (is_sane(NEON, source, length) == ZINT_ERROR_INVALID_DATA) { if (is_sane(NEON, source, length) == ZINT_ERROR_INVALID_DATA) {
strcpy(symbol->errtxt, "Invalid input data (Version S encodes numeric input only) (E14)"); strcpy(symbol->errtxt, "515: Invalid input data (Version S encodes numeric input only)");
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }
@ -1313,7 +1313,7 @@ int code_one(struct zint_symbol *symbol, unsigned char source[], int length) {
} }
if (data_length > 38) { if (data_length > 38) {
strcpy(symbol->errtxt, "Input data too long (E15)"); strcpy(symbol->errtxt, "516: Input data too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
@ -1407,7 +1407,7 @@ int code_one(struct zint_symbol *symbol, unsigned char source[], int length) {
data_length = c1_encode(symbol, source, data, length); data_length = c1_encode(symbol, source, data, length);
if (data_length == 0) { if (data_length == 0) {
strcpy(symbol->errtxt, "Input data is too long"); strcpy(symbol->errtxt, "517: Input data is too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
@ -1422,7 +1422,7 @@ int code_one(struct zint_symbol *symbol, unsigned char source[], int length) {
} }
if ((symbol-> option_2 != 0) && (symbol->option_2 < size)) { if ((symbol-> option_2 != 0) && (symbol->option_2 < size)) {
strcpy(symbol->errtxt, "Input too long for selected symbol size"); strcpy(symbol->errtxt, "518: Input too long for selected symbol size");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }

18
backend/code128.c
View File

@ -311,7 +311,7 @@ int code_128(struct zint_symbol *symbol, unsigned char source[], const size_t le
if (sourcelen > 160) { if (sourcelen > 160) {
/* This only blocks rediculously long input - the actual length of the /* This only blocks rediculously long input - the actual length of the
resulting barcode depends on the type of data, so this is trapped later */ resulting barcode depends on the type of data, so this is trapped later */
strcpy(symbol->errtxt, "Input too long (C40)"); strcpy(symbol->errtxt, "340: Input too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
@ -483,7 +483,7 @@ int code_128(struct zint_symbol *symbol, unsigned char source[], const size_t le
} }
} }
if (glyph_count > 60.0) { if (glyph_count > 60.0) {
strcpy(symbol->errtxt, "Input too long (C41)"); strcpy(symbol->errtxt, "341: Input too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
@ -708,13 +708,13 @@ int ean_128(struct zint_symbol *symbol, unsigned char source[], const size_t len
if (length > 160) { if (length > 160) {
/* This only blocks rediculously long input - the actual length of the /* This only blocks rediculously long input - the actual length of the
resulting barcode depends on the type of data, so this is trapped later */ resulting barcode depends on the type of data, so this is trapped later */
strcpy(symbol->errtxt, "Input too long (C42)"); strcpy(symbol->errtxt, "342: Input too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
for (i = 0; i < length; i++) { for (i = 0; i < length; i++) {
if (source[i] == '\0') { if (source[i] == '\0') {
/* Null characters not allowed! */ /* Null characters not allowed! */
strcpy(symbol->errtxt, "NULL character in input data (C43)"); strcpy(symbol->errtxt, "343: NULL character in input data");
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }
} }
@ -844,7 +844,7 @@ int ean_128(struct zint_symbol *symbol, unsigned char source[], const size_t len
} }
} }
if (glyph_count > 60.0) { if (glyph_count > 60.0) {
strcpy(symbol->errtxt, "Input too long (C44)"); strcpy(symbol->errtxt, "344: Input too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
@ -1011,13 +1011,13 @@ int nve_18(struct zint_symbol *symbol, unsigned char source[], int length) {
sourcelen = length; sourcelen = length;
if (sourcelen > 17) { if (sourcelen > 17) {
strcpy(symbol->errtxt, "Input too long (C45)"); strcpy(symbol->errtxt, "345: Input too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
error_number = is_sane(NEON, source, length); error_number = is_sane(NEON, source, length);
if (error_number == ZINT_ERROR_INVALID_DATA) { if (error_number == ZINT_ERROR_INVALID_DATA) {
strcpy(symbol->errtxt, "Invalid characters in data (C46)"); strcpy(symbol->errtxt, "346: Invalid characters in data");
return error_number; return error_number;
} }
zeroes = 17 - sourcelen; zeroes = 17 - sourcelen;
@ -1052,13 +1052,13 @@ int ean_14(struct zint_symbol *symbol, unsigned char source[], int length) {
unsigned char ean128_equiv[20]; unsigned char ean128_equiv[20];
if (length > 13) { if (length > 13) {
strcpy(symbol->errtxt, "Input wrong length (C47)"); strcpy(symbol->errtxt, "347: Input wrong length");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
error_number = is_sane(NEON, source, length); error_number = is_sane(NEON, source, length);
if (error_number == ZINT_ERROR_INVALID_DATA) { if (error_number == ZINT_ERROR_INVALID_DATA) {
strcpy(symbol->errtxt, "Invalid character in data (C48)"); strcpy(symbol->errtxt, "348: Invalid character in data");
return error_number; return error_number;
} }

6
backend/code16k.c
View File

@ -280,7 +280,7 @@ int code16k(struct zint_symbol *symbol, unsigned char source[], const size_t len
} }
if (input_length > 157) { if (input_length > 157) {
strcpy(symbol->errtxt, "Input too long (D20)"); strcpy(symbol->errtxt, "420: Input too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
@ -479,7 +479,7 @@ int code16k(struct zint_symbol *symbol, unsigned char source[], const size_t len
} }
if (glyph_count > 77.0) { if (glyph_count > 77.0) {
strcpy(symbol->errtxt, "Input too long (D21)"); strcpy(symbol->errtxt, "421: Input too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
@ -511,7 +511,7 @@ int code16k(struct zint_symbol *symbol, unsigned char source[], const size_t len
m = 5; m = 5;
} }
if (gs1) { if (gs1) {
strcpy(symbol->errtxt, "Cannot use both GS1 mode and Reader Initialisation (D22)"); strcpy(symbol->errtxt, "422: Cannot use both GS1 mode and Reader Initialisation");
return ZINT_ERROR_INVALID_OPTION; return ZINT_ERROR_INVALID_OPTION;
} else { } else {
if ((set[0] == 'B') && (set[1] == 'C')) { if ((set[0] == 'B') && (set[1] == 'C')) {

6
backend/code49.c
View File

@ -52,7 +52,7 @@ int code_49(struct zint_symbol *symbol, unsigned char source[], const int length
size_t h; size_t h;
if (length > 81) { if (length > 81) {
strcpy(symbol->errtxt, "Input too long (D30)"); strcpy(symbol->errtxt, "430: Input too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
if (symbol->input_mode == GS1_MODE) { if (symbol->input_mode == GS1_MODE) {
@ -64,7 +64,7 @@ int code_49(struct zint_symbol *symbol, unsigned char source[], const int length
for (i = 0; i < length; i++) { for (i = 0; i < length; i++) {
if (source[i] > 127) { if (source[i] > 127) {
strcpy(symbol->errtxt, "Invalid characters in input data (D31)"); strcpy(symbol->errtxt, "431: Invalid characters in input data");
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }
if (gs1 && (source[i] == '[')) if (gs1 && (source[i] == '['))
@ -215,7 +215,7 @@ int code_49(struct zint_symbol *symbol, unsigned char source[], const int length
} }
if (codeword_count > 49) { if (codeword_count > 49) {
strcpy(symbol->errtxt, "Input too long (D32)"); strcpy(symbol->errtxt, "432: Input too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }

6
backend/common.c
View File

@ -256,11 +256,11 @@ int utf8toutf16(struct zint_symbol *symbol, const unsigned char source[], int va
jpos++; jpos++;
} else { } else {
if ((source[bpos] >= 0x80) && (source[bpos] <= 0xbf)) { if ((source[bpos] >= 0x80) && (source[bpos] <= 0xbf)) {
strcpy(symbol->errtxt, "Corrupt Unicode data (B40)"); strcpy(symbol->errtxt, "240: Corrupt Unicode data");
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }
if ((source[bpos] >= 0xc0) && (source[bpos] <= 0xc1)) { if ((source[bpos] >= 0xc0) && (source[bpos] <= 0xc1)) {
strcpy(symbol->errtxt, "Overlong encoding not supported (B41)"); strcpy(symbol->errtxt, "241: Overlong encoding not supported");
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }
@ -277,7 +277,7 @@ int utf8toutf16(struct zint_symbol *symbol, const unsigned char source[], int va
jpos++; jpos++;
} else } else
if (source[bpos] >= 0xf0) { if (source[bpos] >= 0xf0) {
strcpy(symbol->errtxt, "Unicode sequences of more than 3 bytes not supported (B42)"); strcpy(symbol->errtxt, "242: Unicode sequences of more than 3 bytes not supported");
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }
} }

18
backend/composite.c
View File

@ -1103,7 +1103,7 @@ static int cc_binary_string(struct zint_symbol *symbol, const char source[], cha
if (!(((ninety[i] >= '0') && (ninety[i] <= '9')) || ((ninety[i] >= 'A') && (ninety[i] <= 'Z')))) { if (!(((ninety[i] >= '0') && (ninety[i] <= '9')) || ((ninety[i] >= 'A') && (ninety[i] <= 'Z')))) {
if ((ninety[i] != '*') && (ninety[i] != ',') && (ninety[i] != '-') && (ninety[i] != '.') && (ninety[i] != '/')) { if ((ninety[i] != '*') && (ninety[i] != ',') && (ninety[i] != '-') && (ninety[i] != '.') && (ninety[i] != '/')) {
/* An Invalid AI 90 character */ /* An Invalid AI 90 character */
strcpy(symbol->errtxt, "Invalid AI 90 data (D40)"); strcpy(symbol->errtxt, "440: Invalid AI 90 data");
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }
} }
@ -1462,7 +1462,7 @@ static int cc_binary_string(struct zint_symbol *symbol, const char source[], cha
if (latch == 1) { if (latch == 1) {
/* Invalid characters in input data */ /* Invalid characters in input data */
strcpy(symbol->errtxt, "Invalid characters in input data (D41)"); strcpy(symbol->errtxt, "441: Invalid characters in input data");
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }
@ -1668,7 +1668,7 @@ static int cc_binary_string(struct zint_symbol *symbol, const char source[], cha
} }
if (target_bitsize == 0) { if (target_bitsize == 0) {
strcpy(symbol->errtxt, "Input too long for selected 2d component (D42)"); strcpy(symbol->errtxt, "442: Input too long for selected 2d component");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
@ -1711,7 +1711,7 @@ static int cc_binary_string(struct zint_symbol *symbol, const char source[], cha
} }
if (strlen(binary_string) > 11805) { /* (2361 * 5) */ if (strlen(binary_string) > 11805) { /* (2361 * 5) */
strcpy(symbol->errtxt, "Input too long (D43)"); strcpy(symbol->errtxt, "443: Input too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
@ -1730,7 +1730,7 @@ static int cc_binary_string(struct zint_symbol *symbol, const char source[], cha
} }
if (target_bitsize == 0) { if (target_bitsize == 0) {
strcpy(symbol->errtxt, "Input too long for selected 2d component (D44)"); strcpy(symbol->errtxt, "444: Input too long for selected 2d component");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
@ -1798,19 +1798,19 @@ int composite(struct zint_symbol *symbol, unsigned char source[], int length) {
error_number = 0; error_number = 0;
pri_len = (int)strlen(symbol->primary); pri_len = (int)strlen(symbol->primary);
if (pri_len == 0) { if (pri_len == 0) {
strcpy(symbol->errtxt, "No primary (linear) message in 2D composite (D45)"); strcpy(symbol->errtxt, "445: No primary (linear) message in 2D composite");
return ZINT_ERROR_INVALID_OPTION; return ZINT_ERROR_INVALID_OPTION;
} }
if (length > 2990) { if (length > 2990) {
strcpy(symbol->errtxt, "2D component input data too long (D46)"); strcpy(symbol->errtxt, "446: 2D component input data too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
cc_mode = symbol->option_1; cc_mode = symbol->option_1;
if ((cc_mode == 3) && (symbol->symbology != BARCODE_EAN128_CC)) { if ((cc_mode == 3) && (symbol->symbology != BARCODE_EAN128_CC)) {
/* CC-C can only be used with a GS1-128 linear part */ /* CC-C can only be used with a GS1-128 linear part */
strcpy(symbol->errtxt, "Invalid mode (CC-C only valid with GS1-128 linear component) (D47)"); strcpy(symbol->errtxt, "447: Invalid mode (CC-C only valid with GS1-128 linear component)");
return ZINT_ERROR_INVALID_OPTION; return ZINT_ERROR_INVALID_OPTION;
} }
@ -1823,7 +1823,7 @@ int composite(struct zint_symbol *symbol, unsigned char source[], int length) {
/* Do a test run of encoding the linear component to establish its width */ /* Do a test run of encoding the linear component to establish its width */
linear_width = linear_dummy_run((unsigned char *) symbol->primary, pri_len); linear_width = linear_dummy_run((unsigned char *) symbol->primary, pri_len);
if (linear_width == 0) { if (linear_width == 0) {
strcpy(symbol->errtxt, "Invalid data (D48)"); strcpy(symbol->errtxt, "448: Invalid data");
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }
} }

12
backend/dmatrix.c
View File

@ -567,7 +567,7 @@ static int dm200encode(struct zint_symbol *symbol, const unsigned char source[],
if (symbol->output_options & READER_INIT) { if (symbol->output_options & READER_INIT) {
if (gs1) { if (gs1) {
strcpy(symbol->errtxt, "Cannot encode in GS1 mode and Reader Initialisation at the same time (E10)"); strcpy(symbol->errtxt, "519: Cannot encode in GS1 mode and Reader Initialisation at the same time");
return ZINT_ERROR_INVALID_OPTION; return ZINT_ERROR_INVALID_OPTION;
} else { } else {
target[tp] = 234; target[tp] = 234;
@ -1158,7 +1158,7 @@ int data_matrix_200(struct zint_symbol *symbol,const unsigned char source[], con
binlen = dm200encode(symbol, source, binary, &last_mode, &inputlen, process_buffer, &process_p); binlen = dm200encode(symbol, source, binary, &last_mode, &inputlen, process_buffer, &process_p);
if (binlen == 0) { if (binlen == 0) {
strcpy(symbol->errtxt, "Data too long to fit in symbol (E11)"); strcpy(symbol->errtxt, "520: Data too long to fit in symbol");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
@ -1182,7 +1182,7 @@ int data_matrix_200(struct zint_symbol *symbol,const unsigned char source[], con
calcsize++; calcsize++;
} }
if (optionsize != -1) { if (optionsize != -1) {
strcpy(symbol->errtxt, "Can not force square symbols when symbol size is selected"); strcpy(symbol->errtxt, "521: Can not force square symbols when symbol size is selected");
error_number = ZINT_WARN_INVALID_OPTION; error_number = ZINT_WARN_INVALID_OPTION;
} }
} else if (symbol->option_3 != DM_DMRE) { } else if (symbol->option_3 != DM_DMRE) {
@ -1196,7 +1196,7 @@ int data_matrix_200(struct zint_symbol *symbol,const unsigned char source[], con
if (calcsize > optionsize) { if (calcsize > optionsize) {
symbolsize = calcsize; symbolsize = calcsize;
if (optionsize != -1) { if (optionsize != -1) {
strcpy(symbol->errtxt, "Input too long for selected symbol size"); strcpy(symbol->errtxt, "522: Input too long for selected symbol size");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
} }
@ -1206,7 +1206,7 @@ int data_matrix_200(struct zint_symbol *symbol,const unsigned char source[], con
binlen = dm200encode_remainder(binary, binlen, source, inputlen, last_mode, process_buffer, process_p, symbols_left); binlen = dm200encode_remainder(binary, binlen, source, inputlen, last_mode, process_buffer, process_p, symbols_left);
if (binlen > matrixbytes[symbolsize]) { if (binlen > matrixbytes[symbolsize]) {
strcpy(symbol->errtxt, "Data too long to fit in symbol (E12A)"); strcpy(symbol->errtxt, "523: Data too long to fit in symbol");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
@ -1313,7 +1313,7 @@ int dmatrix(struct zint_symbol *symbol, const unsigned char source[], const size
error_number = data_matrix_200(symbol, source, in_length); error_number = data_matrix_200(symbol, source, in_length);
} else { } else {
/* ECC 000 - 140 */ /* ECC 000 - 140 */
strcpy(symbol->errtxt, "Older Data Matrix standards are no longer supported (E13)"); strcpy(symbol->errtxt, "524: Older Data Matrix standards are no longer supported");
error_number = ZINT_ERROR_INVALID_OPTION; error_number = ZINT_ERROR_INVALID_OPTION;
} }

4
backend/dotcode.c
View File

@ -1216,7 +1216,7 @@ int dotcode(struct zint_symbol *symbol, const unsigned char source[], int length
#endif /* _MSC_VER */ #endif /* _MSC_VER */
if (symbol->eci > 811799) { if (symbol->eci > 811799) {
strcpy(symbol->errtxt, "Invalid ECI"); strcpy(symbol->errtxt, "525: Invalid ECI");
return ZINT_ERROR_INVALID_OPTION; return ZINT_ERROR_INVALID_OPTION;
} }
@ -1282,7 +1282,7 @@ int dotcode(struct zint_symbol *symbol, const unsigned char source[], int length
} }
if ((height > 200) || (width > 200)) { if ((height > 200) || (width > 200)) {
strcpy(symbol->errtxt, "Specified symbol size is too large (E20)"); strcpy(symbol->errtxt, "526: Specified symbol size is too large (E20)");
return ZINT_ERROR_INVALID_OPTION; return ZINT_ERROR_INVALID_OPTION;
} }

50
backend/emf.c
View File

@ -174,28 +174,28 @@ int emf_plot(struct zint_symbol *symbol) {
box_t box; box_t box;
#ifndef _MSC_VER #ifndef _MSC_VER
unsigned char local_text[bump_up(ustrlen(symbol->text) + 1)]; unsigned char local_text[bump_up(ustrlen(symbol->text) + 1)];
unsigned char string_buffer[2 * bump_up(ustrlen(symbol->text) + 1)]; unsigned char string_buffer[2 * bump_up(ustrlen(symbol->text) + 1)];
#else #else
unsigned char* local_text; unsigned char* local_text;
unsigned char* string_buffer; unsigned char* string_buffer;
emr_rectangle_t *rectangle, *row_binding; emr_rectangle_t *rectangle, *row_binding;
emr_ellipse_t* circle; emr_ellipse_t* circle;
emr_polygon_t* hexagon; emr_polygon_t* hexagon;
local_text = (unsigned char*) _alloca(bump_up(ustrlen(symbol->text) + 1) * sizeof (unsigned char)); local_text = (unsigned char*) _alloca(bump_up(ustrlen(symbol->text) + 1) * sizeof (unsigned char));
string_buffer = (unsigned char*) _alloca(2 * bump_up(ustrlen(symbol->text) + 1) * sizeof (unsigned char)); string_buffer = (unsigned char*) _alloca(2 * bump_up(ustrlen(symbol->text) + 1) * sizeof (unsigned char));
#endif #endif
row_height = 0; row_height = 0;
textdone = 0; textdone = 0;
comp_offset = 0; comp_offset = 0;
this_rectangle = 0; this_rectangle = 0;
this_circle = 0; this_circle = 0;
this_hexagon = 0; this_hexagon = 0;
dx = 0; dx = 0;
latch = 0; latch = 0;
for(i = 0; i < 6; i++) { for(i = 0; i < 6; i++) {
regw[i] = '\0'; regw[i] = '\0';
regx[i] = '\0'; regx[i] = '\0';
@ -239,12 +239,12 @@ int emf_plot(struct zint_symbol *symbol) {
to_upper((unsigned char*) symbol->bgcolour); to_upper((unsigned char*) symbol->bgcolour);
if (strlen(symbol->fgcolour) != 6) { if (strlen(symbol->fgcolour) != 6) {
strcpy(symbol->errtxt, "Malformed foreground colour target (F41)"); strcpy(symbol->errtxt, "641: Malformed foreground colour target");
return ZINT_ERROR_INVALID_OPTION; return ZINT_ERROR_INVALID_OPTION;
} }
if (strlen(symbol->bgcolour) != 6) { if (strlen(symbol->bgcolour) != 6) {
strcpy(symbol->errtxt, "Malformed background colour target (F42)"); strcpy(symbol->errtxt, "642: Malformed background colour target");
return ZINT_ERROR_INVALID_OPTION; return ZINT_ERROR_INVALID_OPTION;
} }
@ -1016,7 +1016,7 @@ int emf_plot(struct zint_symbol *symbol) {
emf_file = fopen(symbol->outfile, "w"); emf_file = fopen(symbol->outfile, "w");
} }
if (emf_file == NULL) { if (emf_file == NULL) {
strcpy(symbol->errtxt, "Could not open output file (F40)"); strcpy(symbol->errtxt, "640: Could not open output file");
return ZINT_ERROR_FILE_ACCESS; return ZINT_ERROR_FILE_ACCESS;
} }

4
backend/gif.c
View File

@ -279,14 +279,14 @@ int gif_pixel_plot(struct zint_symbol *symbol, char *pixelbuf) {
if ((symbol->output_options & BARCODE_STDOUT) != 0) { if ((symbol->output_options & BARCODE_STDOUT) != 0) {
#ifdef _MSC_VER #ifdef _MSC_VER
if (-1 == _setmode(_fileno(stdout), _O_BINARY)) { if (-1 == _setmode(_fileno(stdout), _O_BINARY)) {
strcpy(symbol->errtxt, "Can't open output file"); strcpy(symbol->errtxt, "610: Can't open output file");
return ZINT_ERROR_FILE_ACCESS; return ZINT_ERROR_FILE_ACCESS;
} }
#endif #endif
gif_file = stdout; gif_file = stdout;
} else { } else {
if (!(gif_file = fopen(symbol->outfile, "wb"))) { if (!(gif_file = fopen(symbol->outfile, "wb"))) {
strcpy(symbol->errtxt, "Can't open output file (F10)"); strcpy(symbol->errtxt, "611: Can't open output file");
return ZINT_ERROR_FILE_ACCESS; return ZINT_ERROR_FILE_ACCESS;
} }
} }

10
backend/gridmtx.c
View File

@ -1044,7 +1044,7 @@ int grid_matrix(struct zint_symbol *symbol, const unsigned char source[], size_t
j++; j++;
} while ((j < 7445) && (glyph == 0)); } while ((j < 7445) && (glyph == 0));
if (glyph == 0) { if (glyph == 0) {
strcpy(symbol->errtxt, "Invalid character in input data (E30)"); strcpy(symbol->errtxt, "530: Invalid character in input data");
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }
gbdata[i] = glyph; gbdata[i] = glyph;
@ -1055,13 +1055,13 @@ int grid_matrix(struct zint_symbol *symbol, const unsigned char source[], size_t
if (symbol->output_options & READER_INIT) reader = 1; if (symbol->output_options & READER_INIT) reader = 1;
if (symbol->eci > 811799) { if (symbol->eci > 811799) {
strcpy(symbol->errtxt, "Invalid ECI"); strcpy(symbol->errtxt, "533: Invalid ECI");
return ZINT_ERROR_INVALID_OPTION; return ZINT_ERROR_INVALID_OPTION;
} }
error_number = gm_encode(gbdata, length, binary, reader, symbol->eci, symbol->debug); error_number = gm_encode(gbdata, length, binary, reader, symbol->eci, symbol->debug);
if (error_number != 0) { if (error_number != 0) {
strcpy(symbol->errtxt, "Input data too long (E31)"); strcpy(symbol->errtxt, "531: Input data too long");
return error_number; return error_number;
} }
@ -1102,7 +1102,7 @@ int grid_matrix(struct zint_symbol *symbol, const unsigned char source[], size_t
if (symbol->option_2 > min_layers) { if (symbol->option_2 > min_layers) {
layers = symbol->option_2; layers = symbol->option_2;
} else { } else {
strcpy(symbol->errtxt, "Input data too long for selected symbol size"); strcpy(symbol->errtxt, "534: Input data too long for selected symbol size");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
} }
@ -1149,7 +1149,7 @@ int grid_matrix(struct zint_symbol *symbol, const unsigned char source[], size_t
} }
if (data_cw > data_max) { if (data_cw > data_max) {
strcpy(symbol->errtxt, "Input data too long (E32)"); strcpy(symbol->errtxt, "532: Input data too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }

24
backend/gs1.c
View File

@ -79,17 +79,17 @@ int gs1_verify(struct zint_symbol *symbol, const unsigned char source[], const s
/* Detect extended ASCII characters */ /* Detect extended ASCII characters */
for (i = 0; i < src_len; i++) { for (i = 0; i < src_len; i++) {
if (source[i] >= 128) { if (source[i] >= 128) {
strcpy(symbol->errtxt, "Extended ASCII characters are not supported by GS1 (B50)"); strcpy(symbol->errtxt, "250: Extended ASCII characters are not supported by GS1");
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }
if (source[i] < 32) { if (source[i] < 32) {
strcpy(symbol->errtxt, "Control characters are not supported by GS1 (B51)"); strcpy(symbol->errtxt, "251: Control characters are not supported by GS1 ");
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }
} }
if (source[0] != '[') { if (source[0] != '[') {
strcpy(symbol->errtxt, "Data does not start with an AI (B52)"); strcpy(symbol->errtxt, "252: Data does not start with an AI");
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }
@ -129,31 +129,31 @@ int gs1_verify(struct zint_symbol *symbol, const unsigned char source[], const s
if (bracket_level != 0) { if (bracket_level != 0) {
/* Not all brackets are closed */ /* Not all brackets are closed */
strcpy(symbol->errtxt, "Malformed AI in input data (brackets don\'t match) (B53)"); strcpy(symbol->errtxt, "253: Malformed AI in input data (brackets don\'t match)");
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }
if (max_bracket_level > 1) { if (max_bracket_level > 1) {
/* Nested brackets */ /* Nested brackets */
strcpy(symbol->errtxt, "Found nested brackets in input data (B54)"); strcpy(symbol->errtxt, "254: Found nested brackets in input data");
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }
if (max_ai_length > 4) { if (max_ai_length > 4) {
/* AI is too long */ /* AI is too long */
strcpy(symbol->errtxt, "Invalid AI in input data (AI too long) (B55)"); strcpy(symbol->errtxt, "255: Invalid AI in input data (AI too long)");
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }
if (min_ai_length <= 1) { if (min_ai_length <= 1) {
/* AI is too short */ /* AI is too short */
strcpy(symbol->errtxt, "Invalid AI in input data (AI too short) (B56)"); strcpy(symbol->errtxt, "256: Invalid AI in input data (AI too short)");
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }
if (ai_latch == 1) { if (ai_latch == 1) {
/* Non-numeric data in AI */ /* Non-numeric data in AI */
strcpy(symbol->errtxt, "Invalid AI in input data (non-numeric characters in AI) (B57)"); strcpy(symbol->errtxt, "257: Invalid AI in input data (non-numeric characters in AI)");
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }
@ -190,7 +190,7 @@ int gs1_verify(struct zint_symbol *symbol, const unsigned char source[], const s
for (i = 0; i < ai_count; i++) { for (i = 0; i < ai_count; i++) {
if (data_length[i] == 0) { if (data_length[i] == 0) {
/* No data for given AI */ /* No data for given AI */
strcpy(symbol->errtxt, "Empty data field in input data (B58)"); strcpy(symbol->errtxt, "258: Empty data field in input data");
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }
} }
@ -286,13 +286,13 @@ int gs1_verify(struct zint_symbol *symbol, const unsigned char source[], const s
} }
if (error_latch == 5) { if (error_latch == 5) {
strcpy(symbol->errtxt, "Invalid data length for AI (B59)"); strcpy(symbol->errtxt, "259: Invalid data length for AI ");
strcat(symbol->errtxt, ai_string); strcat(symbol->errtxt, ai_string);
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }
if (error_latch == 6) { if (error_latch == 6) {
strcpy(symbol->errtxt, "Invalid AI value (B60)"); strcpy(symbol->errtxt, "260: Invalid AI value");
strcat(symbol->errtxt, ai_string); strcat(symbol->errtxt, ai_string);
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }
@ -353,6 +353,6 @@ int ugs1_verify(struct zint_symbol *symbol, const unsigned char source[], const
ustrcpy(reduced, (unsigned char*) temp); ustrcpy(reduced, (unsigned char*) temp);
return 0; return 0;
} }
strcpy(symbol->errtxt, "ugs1_verify overflow (B61)"); strcpy(symbol->errtxt, "261: ugs1_verify overflow");
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }

6
backend/hanxin.c
View File

@ -1364,7 +1364,7 @@ int han_xin(struct zint_symbol *symbol, const unsigned char source[], size_t len
/* Character not found */ /* Character not found */
if (done == 0) { if (done == 0) {
strcpy(symbol->errtxt, "Unknown character in input data (E40)"); strcpy(symbol->errtxt, "540: Unknown character in input data");
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }
} }
@ -1427,7 +1427,7 @@ int han_xin(struct zint_symbol *symbol, const unsigned char source[], size_t len
} }
if (version == 85) { if (version == 85) {
strcpy(symbol->errtxt, "Input too long for selected error correction level (E41)"); strcpy(symbol->errtxt, "541: Input too long for selected error correction level");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
@ -1440,7 +1440,7 @@ int han_xin(struct zint_symbol *symbol, const unsigned char source[], size_t len
} }
if ((symbol->option_2 != 0) && (symbol->option_2 < version)) { if ((symbol->option_2 != 0) && (symbol->option_2 < version)) {
strcpy(symbol->errtxt, "Input too long for selected symbol size"); strcpy(symbol->errtxt, "542: Input too long for selected symbol size");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }

8
backend/imail.c
View File

@ -271,12 +271,12 @@ int imail(struct zint_symbol *symbol, unsigned char source[], int length) {
error_number = 0; error_number = 0;
if (length > 32) { if (length > 32) {
strcpy(symbol->errtxt, "Input too long (D50)"); strcpy(symbol->errtxt, "450: Input too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
error_number = is_sane(SODIUM, source, length); error_number = is_sane(SODIUM, source, length);
if (error_number == ZINT_ERROR_INVALID_DATA) { if (error_number == ZINT_ERROR_INVALID_DATA) {
strcpy(symbol->errtxt, "Invalid characters in data (D51)"); strcpy(symbol->errtxt, "451: Invalid characters in data");
return error_number; return error_number;
} }
@ -311,11 +311,11 @@ int imail(struct zint_symbol *symbol, unsigned char source[], int length) {
} }
if (strlen(tracker) != 20) { if (strlen(tracker) != 20) {
strcpy(symbol->errtxt, "Invalid length tracking code (D52)"); strcpy(symbol->errtxt, "452: Invalid length tracking code");
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }
if (strlen(zip) > 11) { if (strlen(zip) > 11) {
strcpy(symbol->errtxt, "Invalid ZIP code (D53)"); strcpy(symbol->errtxt, "453: Invalid ZIP code");
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }

64
backend/library.c
View File

@ -221,9 +221,9 @@ void error_tag(char error_string[], int error_number) {
strcpy(error_buffer, error_string); strcpy(error_buffer, error_string);
if (error_number > 4) { if (error_number > 4) {
strcpy(error_string, "error: "); strcpy(error_string, "Error ");
} else { } else {
strcpy(error_string, "warning: "); strcpy(error_string, "Warning ");
} }
strcat(error_string, error_buffer); strcat(error_string, error_buffer);
@ -244,7 +244,7 @@ int dump_plot(struct zint_symbol *symbol) {
} else { } else {
f = fopen(symbol->outfile, "w"); f = fopen(symbol->outfile, "w");
if (!f) { if (!f) {
strcpy(symbol->errtxt, "Could not open output file (B01)"); strcpy(symbol->errtxt, "201: Could not open output file");
return ZINT_ERROR_FILE_ACCESS; return ZINT_ERROR_FILE_ACCESS;
} }
} }
@ -292,13 +292,13 @@ static int hibc(struct zint_symbol *symbol, unsigned char source[], size_t lengt
/* without "+" and check: max 110 characters in HIBC 2.6 */ /* without "+" and check: max 110 characters in HIBC 2.6 */
if (length > 110) { if (length > 110) {
strcpy(symbol->errtxt, "Data too long for HIBC LIC (B02)"); strcpy(symbol->errtxt, "202: Data too long for HIBC LIC");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
to_upper(source); to_upper(source);
error_number = is_sane(TECHNETIUM, source, length); error_number = is_sane(TECHNETIUM, source, length);
if (error_number == ZINT_ERROR_INVALID_DATA) { if (error_number == ZINT_ERROR_INVALID_DATA) {
strcpy(symbol->errtxt, "Invalid characters in data (B03)"); strcpy(symbol->errtxt, "203: Invalid characters in data");
return error_number; return error_number;
} }
@ -651,7 +651,7 @@ static int reduced_charset(struct zint_symbol *symbol, const unsigned char *sour
case UNICODE_MODE: case UNICODE_MODE:
error_number = utf_to_eci(symbol->eci, source, preprocessed, &in_length); error_number = utf_to_eci(symbol->eci, source, preprocessed, &in_length);
if (error_number != 0) { if (error_number != 0) {
strcpy(symbol->errtxt, "Invalid characters in input data (B04)"); strcpy(symbol->errtxt, "204: Invalid characters in input data");
return error_number; return error_number;
} }
break; break;
@ -824,7 +824,7 @@ int ZBarcode_Encode(struct zint_symbol *symbol, const unsigned char *source,int
in_length = (int)ustrlen(source); in_length = (int)ustrlen(source);
} }
if (in_length == 0) { if (in_length == 0) {
strcpy(symbol->errtxt, "No input data (B05)"); strcpy(symbol->errtxt, "205: No input data");
error_tag(symbol->errtxt, ZINT_ERROR_INVALID_DATA); error_tag(symbol->errtxt, ZINT_ERROR_INVALID_DATA);
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }
@ -844,7 +844,7 @@ int ZBarcode_Encode(struct zint_symbol *symbol, const unsigned char *source,int
/* First check the symbology field */ /* First check the symbology field */
if (symbol->symbology < 1) { if (symbol->symbology < 1) {
strcpy(symbol->errtxt, "Symbology out of range, using Code 128 (B06)"); strcpy(symbol->errtxt, "206: Symbology out of range, using Code 128");
symbol->symbology = BARCODE_CODE128; symbol->symbology = BARCODE_CODE128;
error_number = ZINT_WARN_INVALID_OPTION; error_number = ZINT_WARN_INVALID_OPTION;
} }
@ -863,7 +863,7 @@ int ZBarcode_Encode(struct zint_symbol *symbol, const unsigned char *source,int
symbol->symbology = BARCODE_UPCA; symbol->symbology = BARCODE_UPCA;
} }
if (symbol->symbology == 19) { if (symbol->symbology == 19) {
strcpy(symbol->errtxt, "Codabar 18 not supported, using Codabar (B07)"); strcpy(symbol->errtxt, "207: Codabar 18 not supported, using Codabar");
symbol->symbology = BARCODE_CODABAR; symbol->symbology = BARCODE_CODABAR;
error_number = ZINT_WARN_INVALID_OPTION; error_number = ZINT_WARN_INVALID_OPTION;
} }
@ -871,7 +871,7 @@ int ZBarcode_Encode(struct zint_symbol *symbol, const unsigned char *source,int
symbol->symbology = BARCODE_UPCA; symbol->symbology = BARCODE_UPCA;
} }
if (symbol->symbology == 27) { if (symbol->symbology == 27) {
strcpy(symbol->errtxt, "UPCD1 not supported (B08)"); strcpy(symbol->errtxt, "208: UPCD1 not supported");
error_number = ZINT_ERROR_INVALID_OPTION; error_number = ZINT_ERROR_INVALID_OPTION;
} }
if (symbol->symbology == 33) { if (symbol->symbology == 33) {
@ -893,7 +893,7 @@ int ZBarcode_Encode(struct zint_symbol *symbol, const unsigned char *source,int
symbol->symbology = BARCODE_NVE18; symbol->symbology = BARCODE_NVE18;
} }
if (symbol->symbology == 54) { if (symbol->symbology == 54) {
strcpy(symbol->errtxt, "General Parcel Code not supported, using Code 128 (B10)"); strcpy(symbol->errtxt, "210: General Parcel Code not supported, using Code 128");
symbol->symbology = BARCODE_CODE128; symbol->symbology = BARCODE_CODE128;
error_number = ZINT_WARN_INVALID_OPTION; error_number = ZINT_WARN_INVALID_OPTION;
} }
@ -907,7 +907,7 @@ int ZBarcode_Encode(struct zint_symbol *symbol, const unsigned char *source,int
symbol->symbology = BARCODE_AUSPOST; symbol->symbology = BARCODE_AUSPOST;
} }
if (symbol->symbology == 73) { if (symbol->symbology == 73) {
strcpy(symbol->errtxt, "Symbology out of range, using Code 128 (B11)"); strcpy(symbol->errtxt, "211: Symbology out of range, using Code 128");
symbol->symbology = BARCODE_CODE128; symbol->symbology = BARCODE_CODE128;
error_number = ZINT_WARN_INVALID_OPTION; error_number = ZINT_WARN_INVALID_OPTION;
} }
@ -921,12 +921,12 @@ int ZBarcode_Encode(struct zint_symbol *symbol, const unsigned char *source,int
symbol->symbology = BARCODE_EAN128; symbol->symbology = BARCODE_EAN128;
} }
if (symbol->symbology == 91) { if (symbol->symbology == 91) {
strcpy(symbol->errtxt, "Symbology out of range, using Code 128 (B12)"); strcpy(symbol->errtxt, "212: Symbology out of range, using Code 128");
symbol->symbology = BARCODE_CODE128; symbol->symbology = BARCODE_CODE128;
error_number = ZINT_WARN_INVALID_OPTION; error_number = ZINT_WARN_INVALID_OPTION;
} }
if ((symbol->symbology >= 94) && (symbol->symbology <= 96)) { if ((symbol->symbology >= 94) && (symbol->symbology <= 96)) {
strcpy(symbol->errtxt, "Symbology out of range, using Code 128 (B13)"); strcpy(symbol->errtxt, "213: Symbology out of range, using Code 128");
symbol->symbology = BARCODE_CODE128; symbol->symbology = BARCODE_CODE128;
error_number = ZINT_WARN_INVALID_OPTION; error_number = ZINT_WARN_INVALID_OPTION;
} }
@ -952,7 +952,7 @@ int ZBarcode_Encode(struct zint_symbol *symbol, const unsigned char *source,int
symbol->symbology = BARCODE_HIBC_BLOCKF; symbol->symbology = BARCODE_HIBC_BLOCKF;
} }
if ((symbol->symbology == 113) || (symbol->symbology == 114)) { if ((symbol->symbology == 113) || (symbol->symbology == 114)) {
strcpy(symbol->errtxt, "Symbology out of range, using Code 128 (B14)"); strcpy(symbol->errtxt, "214: Symbology out of range, using Code 128");
symbol->symbology = BARCODE_CODE128; symbol->symbology = BARCODE_CODE128;
error_number = ZINT_WARN_INVALID_OPTION; error_number = ZINT_WARN_INVALID_OPTION;
} }
@ -960,13 +960,13 @@ int ZBarcode_Encode(struct zint_symbol *symbol, const unsigned char *source,int
symbol->symbology = BARCODE_DOTCODE; symbol->symbology = BARCODE_DOTCODE;
} }
if ((symbol->symbology >= 117) && (symbol->symbology <= 127)) { if ((symbol->symbology >= 117) && (symbol->symbology <= 127)) {
strcpy(symbol->errtxt, "Symbology out of range, using Code 128 (B15)"); strcpy(symbol->errtxt, "215: Symbology out of range, using Code 128");
symbol->symbology = BARCODE_CODE128; symbol->symbology = BARCODE_CODE128;
error_number = ZINT_WARN_INVALID_OPTION; error_number = ZINT_WARN_INVALID_OPTION;
} }
/* Everything from 128 up is Zint-specific */ /* Everything from 128 up is Zint-specific */
if (symbol->symbology >= 144) { if (symbol->symbology >= 144) {
strcpy(symbol->errtxt, "Symbology out of range, using Code 128 (B16)"); strcpy(symbol->errtxt, "216: Symbology out of range, using Code 128");
symbol->symbology = BARCODE_CODE128; symbol->symbology = BARCODE_CODE128;
error_number = ZINT_WARN_INVALID_OPTION; error_number = ZINT_WARN_INVALID_OPTION;
} }
@ -979,12 +979,12 @@ int ZBarcode_Encode(struct zint_symbol *symbol, const unsigned char *source,int
} }
if ((!(supports_eci(symbol->symbology))) && (symbol->eci != 3)) { if ((!(supports_eci(symbol->symbology))) && (symbol->eci != 3)) {
strcpy(symbol->errtxt, "Symbology does not support ECI switching (B17)"); strcpy(symbol->errtxt, "217: Symbology does not support ECI switching");
error_number = ZINT_ERROR_INVALID_OPTION; error_number = ZINT_ERROR_INVALID_OPTION;
} }
if ((symbol->eci < 3) || (symbol->eci > 999999)) { if ((symbol->eci < 3) || (symbol->eci > 999999)) {
strcpy(symbol->errtxt, "Invalid ECI mode (B18)"); strcpy(symbol->errtxt, "218: Invalid ECI mode");
error_number = ZINT_ERROR_INVALID_OPTION; error_number = ZINT_ERROR_INVALID_OPTION;
} }
@ -999,7 +999,7 @@ int ZBarcode_Encode(struct zint_symbol *symbol, const unsigned char *source,int
if (symbol->input_mode == GS1_MODE) { if (symbol->input_mode == GS1_MODE) {
for (i = 0; i < in_length; i++) { for (i = 0; i < in_length; i++) {
if (source[i] == '\0') { if (source[i] == '\0') {
strcpy(symbol->errtxt, "NULL characters not permitted in GS1 mode (B19)"); strcpy(symbol->errtxt, "219: NULL characters not permitted in GS1 mode");
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }
} }
@ -1010,7 +1010,7 @@ int ZBarcode_Encode(struct zint_symbol *symbol, const unsigned char *source,int
} }
in_length =(int)ustrlen(local_source); in_length =(int)ustrlen(local_source);
} else { } else {
strcpy(symbol->errtxt, "Selected symbology does not support GS1 mode (B20)"); strcpy(symbol->errtxt, "220: Selected symbology does not support GS1 mode");
return ZINT_ERROR_INVALID_OPTION; return ZINT_ERROR_INVALID_OPTION;
} }
} else { } else {
@ -1019,7 +1019,7 @@ int ZBarcode_Encode(struct zint_symbol *symbol, const unsigned char *source,int
} }
if ((symbol->dot_size < 0.01) || (symbol->dot_size > 20.0)) { if ((symbol->dot_size < 0.01) || (symbol->dot_size > 20.0)) {
strcpy(symbol->errtxt, "Invalid dot size (B21)"); strcpy(symbol->errtxt, "221: Invalid dot size");
return ZINT_ERROR_INVALID_OPTION; return ZINT_ERROR_INVALID_OPTION;
} }
@ -1042,7 +1042,7 @@ int ZBarcode_Encode(struct zint_symbol *symbol, const unsigned char *source,int
symbol->eci = get_best_eci(local_source, in_length); symbol->eci = get_best_eci(local_source, in_length);
error_number = ZINT_WARN_USES_ECI; error_number = ZINT_WARN_USES_ECI;
strcpy(symbol->errtxt, "Encoded data includes ECI codes (B22)"); strcpy(symbol->errtxt, "222: Encoded data includes ECI codes");
//printf("Data will encode with ECI %d\n", symbol->eci); //printf("Data will encode with ECI %d\n", symbol->eci);
switch (symbol->symbology) { switch (symbol->symbology) {
@ -1092,13 +1092,13 @@ int ZBarcode_Print(struct zint_symbol *symbol, int rotate_angle) {
case 270: case 270:
break; break;
default: default:
strcpy(symbol->errtxt, "Invalid rotation angle (B23)"); strcpy(symbol->errtxt, "223: Invalid rotation angle");
return ZINT_ERROR_INVALID_OPTION; return ZINT_ERROR_INVALID_OPTION;
} }
if (symbol->output_options & BARCODE_DOTTY_MODE) { if (symbol->output_options & BARCODE_DOTTY_MODE) {
if (!(is_matrix(symbol->symbology))) { if (!(is_matrix(symbol->symbology))) {
strcpy(symbol->errtxt, "Selected symbology cannot be rendered as dots (B24)"); strcpy(symbol->errtxt, "224: Selected symbology cannot be rendered as dots");
return ZINT_ERROR_INVALID_OPTION; return ZINT_ERROR_INVALID_OPTION;
} }
} }
@ -1152,19 +1152,19 @@ int ZBarcode_Print(struct zint_symbol *symbol, int rotate_angle) {
if (!(strcmp(output, "EMF"))) { if (!(strcmp(output, "EMF"))) {
error_number = emf_plot(symbol); error_number = emf_plot(symbol);
} else { } else {
strcpy(symbol->errtxt, "Unknown output format (B25)"); strcpy(symbol->errtxt, "225: Unknown output format");
error_tag(symbol->errtxt, ZINT_ERROR_INVALID_OPTION); error_tag(symbol->errtxt, ZINT_ERROR_INVALID_OPTION);
return ZINT_ERROR_INVALID_OPTION; return ZINT_ERROR_INVALID_OPTION;
} }
} else { } else {
strcpy(symbol->errtxt, "Unknown output format (B26)"); strcpy(symbol->errtxt, "226: Unknown output format");
error_tag(symbol->errtxt, ZINT_ERROR_INVALID_OPTION); error_tag(symbol->errtxt, ZINT_ERROR_INVALID_OPTION);
return ZINT_ERROR_INVALID_OPTION; return ZINT_ERROR_INVALID_OPTION;
} }
if (error_number == ZINT_ERROR_INVALID_OPTION) { if (error_number == ZINT_ERROR_INVALID_OPTION) {
/* If libpng is not installed */ /* If libpng is not installed */
strcpy(symbol->errtxt, "Unknown output format (B27)"); strcpy(symbol->errtxt, "227: Unknown output format");
} }
error_tag(symbol->errtxt, error_number); error_tag(symbol->errtxt, error_number);
@ -1181,7 +1181,7 @@ int ZBarcode_Buffer(struct zint_symbol *symbol, int rotate_angle) {
case 270: case 270:
break; break;
default: default:
strcpy(symbol->errtxt, "Invalid rotation angle (B28)"); strcpy(symbol->errtxt, "228: Invalid rotation angle");
return ZINT_ERROR_INVALID_OPTION; return ZINT_ERROR_INVALID_OPTION;
} }
@ -1227,7 +1227,7 @@ int ZBarcode_Encode_File(struct zint_symbol *symbol, char *filename) {
} else { } else {
file = fopen(filename, "rb"); file = fopen(filename, "rb");
if (!file) { if (!file) {
strcpy(symbol->errtxt, "Unable to read input file (B29)"); strcpy(symbol->errtxt, "229: Unable to read input file");
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }
@ -1238,7 +1238,7 @@ int ZBarcode_Encode_File(struct zint_symbol *symbol, char *filename) {
if (fileLen > 7100) { if (fileLen > 7100) {
/* The largest amount of data that can be encoded is 7089 numeric digits in QR Code */ /* The largest amount of data that can be encoded is 7089 numeric digits in QR Code */
strcpy(symbol->errtxt, "Input file too long (B30)"); strcpy(symbol->errtxt, "230: Input file too long");
fclose(file); fclose(file);
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }
@ -1247,7 +1247,7 @@ int ZBarcode_Encode_File(struct zint_symbol *symbol, char *filename) {
/* Allocate memory */ /* Allocate memory */
buffer = (unsigned char *) malloc(fileLen * sizeof (unsigned char)); buffer = (unsigned char *) malloc(fileLen * sizeof (unsigned char));
if (!buffer) { if (!buffer) {
strcpy(symbol->errtxt, "Internal memory error (B31)"); strcpy(symbol->errtxt, "231: Internal memory error");
if (strcmp(filename, "-")) if (strcmp(filename, "-"))
fclose(file); fclose(file);
return ZINT_ERROR_MEMORY; return ZINT_ERROR_MEMORY;

8
backend/maxicode.c
View File

@ -616,7 +616,7 @@ int maxicode(struct zint_symbol *symbol, unsigned char local_source[], int lengt
} }
if ((mode < 2) || (mode > 6)) { /* Only codes 2 to 6 supported */ if ((mode < 2) || (mode > 6)) { /* Only codes 2 to 6 supported */
strcpy(symbol->errtxt, "Invalid Maxicode Mode (E50)"); strcpy(symbol->errtxt, "550: Invalid Maxicode Mode");
return ZINT_ERROR_INVALID_OPTION; return ZINT_ERROR_INVALID_OPTION;
} }
@ -625,13 +625,13 @@ int maxicode(struct zint_symbol *symbol, unsigned char local_source[], int lengt
lp = strlen(symbol->primary); lp = strlen(symbol->primary);
} }
if (lp != 15) { if (lp != 15) {
strcpy(symbol->errtxt, "Invalid Primary String (E51)"); strcpy(symbol->errtxt, "551: Invalid Primary String");
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }
for (i = 9; i < 15; i++) { /* check that country code and service are numeric */ for (i = 9; i < 15; i++) { /* check that country code and service are numeric */
if ((symbol->primary[i] < '0') || (symbol->primary[i] > '9')) { if ((symbol->primary[i] < '0') || (symbol->primary[i] > '9')) {
strcpy(symbol->errtxt, "Invalid Primary String (E52)"); strcpy(symbol->errtxt, "552: Invalid Primary String");
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }
} }
@ -674,7 +674,7 @@ int maxicode(struct zint_symbol *symbol, unsigned char local_source[], int lengt
i = maxi_text_process(mode, local_source, length, symbol->eci); i = maxi_text_process(mode, local_source, length, symbol->eci);
if (i == ZINT_ERROR_TOO_LONG) { if (i == ZINT_ERROR_TOO_LONG) {
strcpy(symbol->errtxt, "Input data too long (E53)"); strcpy(symbol->errtxt, "553: Input data too long");
return i; return i;
} }

24
backend/medical.c
View File

@ -65,19 +65,19 @@ int pharma_one(struct zint_symbol *symbol, unsigned char source[], int length) {
char dest[64]; /* 17 * 2 + 1 */ char dest[64]; /* 17 * 2 + 1 */
if (length > 6) { if (length > 6) {
strcpy(symbol->errtxt, "Input too long (C50)"); strcpy(symbol->errtxt, "350: Input too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
error_number = is_sane(NEON, source, length); error_number = is_sane(NEON, source, length);
if (error_number == ZINT_ERROR_INVALID_DATA) { if (error_number == ZINT_ERROR_INVALID_DATA) {
strcpy(symbol->errtxt, "Invalid characters in data (C51)"); strcpy(symbol->errtxt, "351: Invalid characters in data");
return error_number; return error_number;
} }
tester = atoi((char*) source); tester = atoi((char*) source);
if ((tester < 3) || (tester > 131070)) { if ((tester < 3) || (tester > 131070)) {
strcpy(symbol->errtxt, "Data out of range (C52)"); strcpy(symbol->errtxt, "352: Data out of range");
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }
@ -120,7 +120,7 @@ int pharma_two_calc(struct zint_symbol *symbol, unsigned char source[], char des
tester = atoi((char*) source); tester = atoi((char*) source);
if ((tester < 4) || (tester > 64570080)) { if ((tester < 4) || (tester > 64570080)) {
strcpy(symbol->errtxt, "Data out of range (C53)"); strcpy(symbol->errtxt, "353: Data out of range");
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }
error_number = 0; error_number = 0;
@ -160,12 +160,12 @@ int pharma_two(struct zint_symbol *symbol, unsigned char source[], int length) {
strcpy(height_pattern, ""); strcpy(height_pattern, "");
if (length > 8) { if (length > 8) {
strcpy(symbol->errtxt, "Input too long (C54)"); strcpy(symbol->errtxt, "354: Input too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
error_number = is_sane(NEON, source, length); error_number = is_sane(NEON, source, length);
if (error_number == ZINT_ERROR_INVALID_DATA) { if (error_number == ZINT_ERROR_INVALID_DATA) {
strcpy(symbol->errtxt, "Invalid characters in data (C55)"); strcpy(symbol->errtxt, "355: Invalid characters in data");
return error_number; return error_number;
} }
error_number = pharma_two_calc(symbol, source, height_pattern); error_number = pharma_two_calc(symbol, source, height_pattern);
@ -200,25 +200,25 @@ int codabar(struct zint_symbol *symbol, unsigned char source[], int length) {
strcpy(dest, ""); strcpy(dest, "");
if (length > 60) { /* No stack smashing please */ if (length > 60) { /* No stack smashing please */
strcpy(symbol->errtxt, "Input too long (C56)"); strcpy(symbol->errtxt, "356: Input too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
to_upper(source); to_upper(source);
error_number = is_sane(CALCIUM, source, length); error_number = is_sane(CALCIUM, source, length);
if (error_number == ZINT_ERROR_INVALID_DATA) { if (error_number == ZINT_ERROR_INVALID_DATA) {
strcpy(symbol->errtxt, "Invalid characters in data (C57)"); strcpy(symbol->errtxt, "357: Invalid characters in data");
return error_number; return error_number;
} }
/* Codabar must begin and end with the characters A, B, C or D */ /* Codabar must begin and end with the characters A, B, C or D */
if ((source[0] != 'A') && (source[0] != 'B') && (source[0] != 'C') if ((source[0] != 'A') && (source[0] != 'B') && (source[0] != 'C')
&& (source[0] != 'D')) { && (source[0] != 'D')) {
strcpy(symbol->errtxt, "Invalid characters in data (C58)"); strcpy(symbol->errtxt, "358: Invalid characters in data");
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }
if ((source[length - 1] != 'A') && (source[length - 1] != 'B') && if ((source[length - 1] != 'A') && (source[length - 1] != 'B') &&
(source[length - 1] != 'C') && (source[length - 1] != 'D')) { (source[length - 1] != 'C') && (source[length - 1] != 'D')) {
strcpy(symbol->errtxt, "Invalid characters in data (C59)"); strcpy(symbol->errtxt, "359: Invalid characters in data");
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }
@ -241,12 +241,12 @@ int code32(struct zint_symbol *symbol, unsigned char source[], int length) {
/* Validate the input */ /* Validate the input */
if (length > 8) { if (length > 8) {
strcpy(symbol->errtxt, "Input too long (C5A)"); strcpy(symbol->errtxt, "360: Input too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
error_number = is_sane(NEON, source, length); error_number = is_sane(NEON, source, length);
if (error_number == ZINT_ERROR_INVALID_DATA) { if (error_number == ZINT_ERROR_INVALID_DATA) {
strcpy(symbol->errtxt, "Invalid characters in data (C5B)"); strcpy(symbol->errtxt, "361: Invalid characters in data");
return error_number; return error_number;
} }

4
backend/pcx.c
View File

@ -104,14 +104,14 @@ int pcx_pixel_plot(struct zint_symbol *symbol, char *pixelbuf) {
if (symbol->output_options & BARCODE_STDOUT) { if (symbol->output_options & BARCODE_STDOUT) {
#ifdef _MSC_VER #ifdef _MSC_VER
if (-1 == _setmode(_fileno(stdout), _O_BINARY)) { if (-1 == _setmode(_fileno(stdout), _O_BINARY)) {
strcpy(symbol->errtxt, "Can't open output file"); strcpy(symbol->errtxt, "620: Can't open output file");
return ZINT_ERROR_FILE_ACCESS; return ZINT_ERROR_FILE_ACCESS;
} }
#endif #endif
pcx_file = stdout; pcx_file = stdout;
} else { } else {
if (!(pcx_file = fopen(symbol->outfile, "wb"))) { if (!(pcx_file = fopen(symbol->outfile, "wb"))) {
strcpy(symbol->errtxt, "Can't open output file (F20)"); strcpy(symbol->errtxt, "621: Can't open output file");
return ZINT_ERROR_FILE_ACCESS; return ZINT_ERROR_FILE_ACCESS;
} }
} }

28
backend/pdf417.c
View File

@ -638,7 +638,7 @@ static int pdf417(struct zint_symbol *symbol, unsigned char chaine[], const size
} }
if (symbol->eci > 811799) { if (symbol->eci > 811799) {
strcpy(symbol->errtxt, "Invalid ECI"); strcpy(symbol->errtxt, "472: Invalid ECI");
return ZINT_ERROR_INVALID_OPTION; return ZINT_ERROR_INVALID_OPTION;
} }
@ -834,12 +834,12 @@ int pdf417enc(struct zint_symbol *symbol, unsigned char source[], const size_t l
error_number = 0; error_number = 0;
if ((symbol->option_1 < -1) || (symbol->option_1 > 8)) { if ((symbol->option_1 < -1) || (symbol->option_1 > 8)) {
strcpy(symbol->errtxt, "Security value out of range (D60)"); strcpy(symbol->errtxt, "460: Security value out of range");
symbol->option_1 = -1; symbol->option_1 = -1;
error_number = ZINT_WARN_INVALID_OPTION; error_number = ZINT_WARN_INVALID_OPTION;
} }
if ((symbol->option_2 < 0) || (symbol->option_2 > 30)) { if ((symbol->option_2 < 0) || (symbol->option_2 > 30)) {
strcpy(symbol->errtxt, "Number of columns out of range (D61)"); strcpy(symbol->errtxt, "461: Number of columns out of range");
symbol->option_2 = 0; symbol->option_2 = 0;
error_number = ZINT_WARN_INVALID_OPTION; error_number = ZINT_WARN_INVALID_OPTION;
} }
@ -851,26 +851,26 @@ int pdf417enc(struct zint_symbol *symbol, unsigned char source[], const size_t l
if (codeerr != 0) { if (codeerr != 0) {
switch (codeerr) { switch (codeerr) {
case 1: case 1:
strcpy(symbol->errtxt, "No such file or file unreadable (D62)"); strcpy(symbol->errtxt, "462: No such file or file unreadable");
error_number = ZINT_ERROR_INVALID_OPTION; error_number = ZINT_ERROR_INVALID_OPTION;
break; break;
case 2: case 2:
strcpy(symbol->errtxt, "Input string too long (D63)"); strcpy(symbol->errtxt, "463: Input string too long");
error_number = ZINT_ERROR_TOO_LONG; error_number = ZINT_ERROR_TOO_LONG;
break; break;
case 3: case 3:
strcpy(symbol->errtxt, "Number of codewords per row too small (D64)"); strcpy(symbol->errtxt, "464: Number of codewords per row too small");
error_number = ZINT_WARN_INVALID_OPTION; error_number = ZINT_WARN_INVALID_OPTION;
break; break;
case 4: case 4:
strcpy(symbol->errtxt, "Data too long for specified number of columns (D65)"); strcpy(symbol->errtxt, "465: Data too long for specified number of columns");
error_number = ZINT_ERROR_TOO_LONG; error_number = ZINT_ERROR_TOO_LONG;
break; break;
case ZINT_ERROR_INVALID_OPTION: case ZINT_ERROR_INVALID_OPTION:
error_number = codeerr; error_number = codeerr;
break; break;
default: default:
strcpy(symbol->errtxt, "Something strange happened (D66)"); strcpy(symbol->errtxt, "466: Something strange happened");
error_number = ZINT_ERROR_ENCODING_PROBLEM; error_number = ZINT_ERROR_ENCODING_PROBLEM;
break; break;
} }
@ -943,7 +943,7 @@ int micro_pdf417(struct zint_symbol *symbol, unsigned char chaine[], const size_
} }
if (symbol->eci > 811799) { if (symbol->eci > 811799) {
strcpy(symbol->errtxt, "Invalid ECI"); strcpy(symbol->errtxt, "473: Invalid ECI");
return ZINT_ERROR_INVALID_OPTION; return ZINT_ERROR_INVALID_OPTION;
} }
@ -989,11 +989,11 @@ int micro_pdf417(struct zint_symbol *symbol, unsigned char chaine[], const size_
/* This is where it all changes! */ /* This is where it all changes! */
if (mclength > 126) { if (mclength > 126) {
strcpy(symbol->errtxt, "Input data too long (D67)"); strcpy(symbol->errtxt, "467: Input data too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
if (symbol->option_2 > 4) { if (symbol->option_2 > 4) {
strcpy(symbol->errtxt, "Specified width out of range (D68)"); strcpy(symbol->errtxt, "468: Specified width out of range");
symbol->option_2 = 0; symbol->option_2 = 0;
codeerr = ZINT_WARN_INVALID_OPTION; codeerr = ZINT_WARN_INVALID_OPTION;
} }
@ -1013,21 +1013,21 @@ int micro_pdf417(struct zint_symbol *symbol, unsigned char chaine[], const size_
if ((symbol->option_2 == 1) && (mclength > 20)) { if ((symbol->option_2 == 1) && (mclength > 20)) {
/* the user specified 1 column but the data doesn't fit - go to automatic */ /* the user specified 1 column but the data doesn't fit - go to automatic */
symbol->option_2 = 0; symbol->option_2 = 0;
strcpy(symbol->errtxt, "Specified symbol size too small for data (D69)"); strcpy(symbol->errtxt, "469: Specified symbol size too small for data");
codeerr = ZINT_WARN_INVALID_OPTION; codeerr = ZINT_WARN_INVALID_OPTION;
} }
if ((symbol->option_2 == 2) && (mclength > 37)) { if ((symbol->option_2 == 2) && (mclength > 37)) {
/* the user specified 2 columns but the data doesn't fit - go to automatic */ /* the user specified 2 columns but the data doesn't fit - go to automatic */
symbol->option_2 = 0; symbol->option_2 = 0;
strcpy(symbol->errtxt, "Specified symbol size too small for data (D6A)"); strcpy(symbol->errtxt, "470: Specified symbol size too small for data");
codeerr = ZINT_WARN_INVALID_OPTION; codeerr = ZINT_WARN_INVALID_OPTION;
} }
if ((symbol->option_2 == 3) && (mclength > 82)) { if ((symbol->option_2 == 3) && (mclength > 82)) {
/* the user specified 3 columns but the data doesn't fit - go to automatic */ /* the user specified 3 columns but the data doesn't fit - go to automatic */
symbol->option_2 = 0; symbol->option_2 = 0;
strcpy(symbol->errtxt, "Specified symbol size too small for data (D6B)"); strcpy(symbol->errtxt, "471: Specified symbol size too small for data");
codeerr = ZINT_WARN_INVALID_OPTION; codeerr = ZINT_WARN_INVALID_OPTION;
} }

16
backend/plessey.c
View File

@ -58,12 +58,12 @@ int plessey(struct zint_symbol *symbol, unsigned char source[], const size_t len
int error_number; int error_number;
if (length > 65) { if (length > 65) {
strcpy(symbol->errtxt, "Input too long (C70)"); strcpy(symbol->errtxt, "370: Input too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
error_number = is_sane(SSET, source, length); error_number = is_sane(SSET, source, length);
if (error_number == ZINT_ERROR_INVALID_DATA) { if (error_number == ZINT_ERROR_INVALID_DATA) {
strcpy(symbol->errtxt, "Invalid characters in data (C71)"); strcpy(symbol->errtxt, "371: Invalid characters in data");
return error_number; return error_number;
} }
checkptr = (unsigned char *) calloc(1, length * 4 + 8); checkptr = (unsigned char *) calloc(1, length * 4 + 8);
@ -116,7 +116,7 @@ int msi_plessey(struct zint_symbol *symbol, unsigned char source[], const size_t
char dest[512]; /* 2 + 55 * 8 + 3 + 1 ~ 512 */ char dest[512]; /* 2 + 55 * 8 + 3 + 1 ~ 512 */
if (length > 55) { if (length > 55) {
strcpy(symbol->errtxt, "Input too long (C72)"); strcpy(symbol->errtxt, "372: Input too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
@ -148,7 +148,7 @@ int msi_plessey_mod10(struct zint_symbol *symbol, unsigned char source[], int le
error_number = 0; error_number = 0;
if (length > 18) { if (length > 18) {
strcpy(symbol->errtxt, "Input too long (C73)"); strcpy(symbol->errtxt, "373: Input too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
@ -216,7 +216,7 @@ int msi_plessey_mod1010(struct zint_symbol *symbol, unsigned char source[], cons
if (src_len > 18) { if (src_len > 18) {
/* No Entry Stack Smashers! limit because of str->number conversion*/ /* No Entry Stack Smashers! limit because of str->number conversion*/
strcpy(symbol->errtxt, "Input too long (C74)"); strcpy(symbol->errtxt, "374: Input too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
@ -317,7 +317,7 @@ int msi_plessey_mod11(struct zint_symbol *symbol, unsigned char source[], const
error_number = 0; error_number = 0;
if (src_len > 55) { if (src_len > 55) {
strcpy(symbol->errtxt, "Input too long (C75)"); strcpy(symbol->errtxt, "375: Input too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
@ -380,7 +380,7 @@ int msi_plessey_mod1110(struct zint_symbol *symbol, unsigned char source[], cons
error_number = 0; error_number = 0;
if (src_len > 18) { if (src_len > 18) {
strcpy(symbol->errtxt, "Input too long (C76)"); strcpy(symbol->errtxt, "376: Input too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
@ -466,7 +466,7 @@ int msi_handle(struct zint_symbol *symbol, unsigned char source[], int length) {
error_number = is_sane(NEON, source, length); error_number = is_sane(NEON, source, length);
if (error_number != 0) { if (error_number != 0) {
strcpy(symbol->errtxt, "Invalid characters in input data (C77)"); strcpy(symbol->errtxt, "377: Invalid characters in input data");
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }

10
backend/png.c
View File

@ -102,14 +102,14 @@ int png_pixel_plot(struct zint_symbol *symbol, char *pixelbuf) {
if (symbol->output_options & BARCODE_STDOUT) { if (symbol->output_options & BARCODE_STDOUT) {
#ifdef _MSC_VER #ifdef _MSC_VER
if (-1 == _setmode(_fileno(stdout), _O_BINARY)) { if (-1 == _setmode(_fileno(stdout), _O_BINARY)) {
strcpy(symbol->errtxt, "Can't open output file"); strcpy(symbol->errtxt, "631: Can't open output file");
return ZINT_ERROR_FILE_ACCESS; return ZINT_ERROR_FILE_ACCESS;
} }
#endif #endif
graphic->outfile = stdout; graphic->outfile = stdout;
} else { } else {
if (!(graphic->outfile = fopen(symbol->outfile, "wb"))) { if (!(graphic->outfile = fopen(symbol->outfile, "wb"))) {
strcpy(symbol->errtxt, "Can't open output file (F32)"); strcpy(symbol->errtxt, "632: Can't open output file");
return ZINT_ERROR_FILE_ACCESS; return ZINT_ERROR_FILE_ACCESS;
} }
} }
@ -117,21 +117,21 @@ int png_pixel_plot(struct zint_symbol *symbol, char *pixelbuf) {
/* Set up error handling routine as proc() above */ /* Set up error handling routine as proc() above */
png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, graphic, writepng_error_handler, NULL); png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, graphic, writepng_error_handler, NULL);
if (!png_ptr) { if (!png_ptr) {
strcpy(symbol->errtxt, "Out of memory (F33)"); strcpy(symbol->errtxt, "633: Out of memory");
return ZINT_ERROR_MEMORY; return ZINT_ERROR_MEMORY;
} }
info_ptr = png_create_info_struct(png_ptr); info_ptr = png_create_info_struct(png_ptr);
if (!info_ptr) { if (!info_ptr) {
png_destroy_write_struct(&png_ptr, NULL); png_destroy_write_struct(&png_ptr, NULL);
strcpy(symbol->errtxt, "Out of memory (F34)"); strcpy(symbol->errtxt, "634: Out of memory");
return ZINT_ERROR_MEMORY; return ZINT_ERROR_MEMORY;
} }
/* catch jumping here */ /* catch jumping here */
if (setjmp(graphic->jmpbuf)) { if (setjmp(graphic->jmpbuf)) {
png_destroy_write_struct(&png_ptr, &info_ptr); png_destroy_write_struct(&png_ptr, &info_ptr);
strcpy(symbol->errtxt, "libpng error occurred (F35)"); strcpy(symbol->errtxt, "635: libpng error occurred");
return ZINT_ERROR_MEMORY; return ZINT_ERROR_MEMORY;
} }

36
backend/postal.c
View File

@ -92,12 +92,12 @@ int postnet(struct zint_symbol *symbol, unsigned char source[], char dest[], int
error_number = 0; error_number = 0;
if (length > 38) { if (length > 38) {
strcpy(symbol->errtxt, "Input too long (D80)"); strcpy(symbol->errtxt, "480: Input too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
error_number = is_sane(NEON, source, length); error_number = is_sane(NEON, source, length);
if (error_number == ZINT_ERROR_INVALID_DATA) { if (error_number == ZINT_ERROR_INVALID_DATA) {
strcpy(symbol->errtxt, "Invalid characters in data (D81)"); strcpy(symbol->errtxt, "481: Invalid characters in data");
return error_number; return error_number;
} }
sum = 0; sum = 0;
@ -158,12 +158,12 @@ int planet(struct zint_symbol *symbol, unsigned char source[], char dest[], int
error_number = 0; error_number = 0;
if (length > 38) { if (length > 38) {
strcpy(symbol->errtxt, "Input too long (D82)"); strcpy(symbol->errtxt, "482: Input too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
error_number = is_sane(NEON, source, length); error_number = is_sane(NEON, source, length);
if (error_number == ZINT_ERROR_INVALID_DATA) { if (error_number == ZINT_ERROR_INVALID_DATA) {
strcpy(symbol->errtxt, "Invalid characters in data (D83)"); strcpy(symbol->errtxt, "483: Invalid characters in data");
return error_number; return error_number;
} }
sum = 0; sum = 0;
@ -222,12 +222,12 @@ int korea_post(struct zint_symbol *symbol, unsigned char source[], int length) {
error_number = 0; error_number = 0;
if (length > 6) { if (length > 6) {
strcpy(symbol->errtxt, "Input too long (D84)"); strcpy(symbol->errtxt, "484: Input too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
error_number = is_sane(NEON, source, length); error_number = is_sane(NEON, source, length);
if (error_number == ZINT_ERROR_INVALID_DATA) { if (error_number == ZINT_ERROR_INVALID_DATA) {
strcpy(symbol->errtxt, "Invalid characters in data (D85)"); strcpy(symbol->errtxt, "485: Invalid characters in data");
return error_number; return error_number;
} }
zeroes = 6 - length; zeroes = 6 - length;
@ -262,7 +262,7 @@ int fim(struct zint_symbol *symbol, unsigned char source[], int length) {
char dest[16] = {0}; char dest[16] = {0};
if (length > 1) { if (length > 1) {
strcpy(symbol->errtxt, "Input too long (D86)"); strcpy(symbol->errtxt, "486: Input too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
@ -284,7 +284,7 @@ int fim(struct zint_symbol *symbol, unsigned char source[], int length) {
strcpy(dest, "1111131311111"); strcpy(dest, "1111131311111");
break; break;
default: default:
strcpy(symbol->errtxt, "Invalid characters in data (D87)"); strcpy(symbol->errtxt, "487: Invalid characters in data");
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
break; break;
} }
@ -341,13 +341,13 @@ int royal_plot(struct zint_symbol *symbol, unsigned char source[], int length) {
error_number = 0; error_number = 0;
if (length > 50) { if (length > 50) {
strcpy(symbol->errtxt, "Input too long (D88)"); strcpy(symbol->errtxt, "488: Input too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
to_upper(source); to_upper(source);
error_number = is_sane(KRSET, source, length); error_number = is_sane(KRSET, source, length);
if (error_number == ZINT_ERROR_INVALID_DATA) { if (error_number == ZINT_ERROR_INVALID_DATA) {
strcpy(symbol->errtxt, "Invalid characters in data (D89)"); strcpy(symbol->errtxt, "489: Invalid characters in data");
return error_number; return error_number;
} }
/*check = */rm4scc((char*) source, (unsigned char*) height_pattern, length); /*check = */rm4scc((char*) source, (unsigned char*) height_pattern, length);
@ -387,13 +387,13 @@ int kix_code(struct zint_symbol *symbol, unsigned char source[], int length) {
error_number = 0; error_number = 0;
if (length > 18) { if (length > 18) {
strcpy(symbol->errtxt, "Input too long (D8A)"); strcpy(symbol->errtxt, "490: Input too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
to_upper(source); to_upper(source);
error_number = is_sane(KRSET, source, length); error_number = is_sane(KRSET, source, length);
if (error_number == ZINT_ERROR_INVALID_DATA) { if (error_number == ZINT_ERROR_INVALID_DATA) {
strcpy(symbol->errtxt, "Invalid characters in data (D8B)"); strcpy(symbol->errtxt, "491: Invalid characters in data");
return error_number; return error_number;
} }
@ -435,14 +435,14 @@ int daft_code(struct zint_symbol *symbol, unsigned char source[], int length) {
error_number = 0; error_number = 0;
if (length > 50) { if (length > 50) {
strcpy(symbol->errtxt, "Input too long (D8C)"); strcpy(symbol->errtxt, "492: Input too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
to_upper((unsigned char*) source); to_upper((unsigned char*) source);
error_number = is_sane(DAFTSET, (unsigned char*) source, length); error_number = is_sane(DAFTSET, (unsigned char*) source, length);
if (error_number == ZINT_ERROR_INVALID_DATA) { if (error_number == ZINT_ERROR_INVALID_DATA) {
strcpy(symbol->errtxt, "Invalid characters in data (D8D)"); strcpy(symbol->errtxt, "493: Invalid characters in data");
return error_number; return error_number;
} }
@ -491,12 +491,12 @@ int flattermarken(struct zint_symbol *symbol, unsigned char source[], int length
error_number = 0; error_number = 0;
if (length > 90) { if (length > 90) {
strcpy(symbol->errtxt, "Input too long (D8E)"); strcpy(symbol->errtxt, "494: Input too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
error_number = is_sane(NEON, source, length); error_number = is_sane(NEON, source, length);
if (error_number == ZINT_ERROR_INVALID_DATA) { if (error_number == ZINT_ERROR_INVALID_DATA) {
strcpy(symbol->errtxt, "Invalid characters in data (D8F)"); strcpy(symbol->errtxt, "495: Invalid characters in data");
return error_number; return error_number;
} }
*dest = '\0'; *dest = '\0';
@ -523,7 +523,7 @@ int japan_post(struct zint_symbol *symbol, unsigned char source[], int length) {
#endif #endif
if (length > 20) { if (length > 20) {
strcpy(symbol->errtxt, "Input too long (D8G)"); strcpy(symbol->errtxt, "496: Input too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
@ -538,7 +538,7 @@ int japan_post(struct zint_symbol *symbol, unsigned char source[], int length) {
error_number = is_sane(SHKASUTSET, (unsigned char*) local_source, length); error_number = is_sane(SHKASUTSET, (unsigned char*) local_source, length);
if (error_number == ZINT_ERROR_INVALID_DATA) { if (error_number == ZINT_ERROR_INVALID_DATA) {
strcpy(symbol->errtxt, "Invalid characters in data (D8H)"); strcpy(symbol->errtxt, "497: Invalid characters in data");
return error_number; return error_number;
} }
memset(inter, 'd', 20); /* Pad character CC4 */ memset(inter, 'd', 20); /* Pad character CC4 */

10
backend/ps.c
View File

@ -105,7 +105,7 @@ int ps_plot(struct zint_symbol *symbol) {
feps = fopen(symbol->outfile, "w"); feps = fopen(symbol->outfile, "w");
} }
if (feps == NULL) { if (feps == NULL) {
strcpy(symbol->errtxt, "Could not open output file (F40)"); strcpy(symbol->errtxt, "645: Could not open output file");
#ifdef _MSC_VER #ifdef _MSC_VER
free(local_text); free(local_text);
#endif #endif
@ -117,7 +117,7 @@ int ps_plot(struct zint_symbol *symbol) {
to_upper((unsigned char*) symbol->bgcolour); to_upper((unsigned char*) symbol->bgcolour);
if (strlen(symbol->fgcolour) != 6) { if (strlen(symbol->fgcolour) != 6) {
strcpy(symbol->errtxt, "Malformed foreground colour target (F41)"); strcpy(symbol->errtxt, "646: Malformed foreground colour target");
fclose(feps); fclose(feps);
#ifdef _MSC_VER #ifdef _MSC_VER
free(local_text); free(local_text);
@ -125,7 +125,7 @@ int ps_plot(struct zint_symbol *symbol) {
return ZINT_ERROR_INVALID_OPTION; return ZINT_ERROR_INVALID_OPTION;
} }
if (strlen(symbol->bgcolour) != 6) { if (strlen(symbol->bgcolour) != 6) {
strcpy(symbol->errtxt, "Malformed background colour target (F42)"); strcpy(symbol->errtxt, "647: Malformed background colour target");
fclose(feps); fclose(feps);
#ifdef _MSC_VER #ifdef _MSC_VER
free(local_text); free(local_text);
@ -134,7 +134,7 @@ int ps_plot(struct zint_symbol *symbol) {
} }
error_number = is_sane(SSET, (unsigned char*) symbol->fgcolour, strlen(symbol->fgcolour)); error_number = is_sane(SSET, (unsigned char*) symbol->fgcolour, strlen(symbol->fgcolour));
if (error_number == ZINT_ERROR_INVALID_DATA) { if (error_number == ZINT_ERROR_INVALID_DATA) {
strcpy(symbol->errtxt, "Malformed foreground colour target (F43)"); strcpy(symbol->errtxt, "648: Malformed foreground colour target");
fclose(feps); fclose(feps);
#ifdef _MSC_VER #ifdef _MSC_VER
free(local_text); free(local_text);
@ -143,7 +143,7 @@ int ps_plot(struct zint_symbol *symbol) {
} }
error_number = is_sane(SSET, (unsigned char*) symbol->bgcolour, strlen(symbol->bgcolour)); error_number = is_sane(SSET, (unsigned char*) symbol->bgcolour, strlen(symbol->bgcolour));
if (error_number == ZINT_ERROR_INVALID_DATA) { if (error_number == ZINT_ERROR_INVALID_DATA) {
strcpy(symbol->errtxt, "Malformed background colour target (F44)"); strcpy(symbol->errtxt, "649: Malformed background colour target");
fclose(feps); fclose(feps);
#ifdef _MSC_VER #ifdef _MSC_VER
free(local_text); free(local_text);

28
backend/qr.c
View File

@ -1448,7 +1448,7 @@ int qr_code(struct zint_symbol *symbol, const unsigned char source[], size_t len
j++; j++;
} while ((j < 6843) && (glyph == 0)); } while ((j < 6843) && (glyph == 0));
if (glyph == 0) { if (glyph == 0) {
strcpy(symbol->errtxt, "Invalid character in input data (E60)"); strcpy(symbol->errtxt, "560: Invalid character in input data");
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }
jisdata[i] = glyph; jisdata[i] = glyph;
@ -1479,7 +1479,7 @@ int qr_code(struct zint_symbol *symbol, const unsigned char source[], size_t len
} }
if (est_binlen > (8 * max_cw)) { if (est_binlen > (8 * max_cw)) {
strcpy(symbol->errtxt, "Input too long for selected error correction level (E61)"); strcpy(symbol->errtxt, "561: Input too long for selected error correction level");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
@ -1564,7 +1564,7 @@ int qr_code(struct zint_symbol *symbol, const unsigned char source[], size_t len
} }
if (symbol->option_2 < version) { if (symbol->option_2 < version) {
strcpy(symbol->errtxt, "Input too long for selected symbol size"); strcpy(symbol->errtxt, "569: Input too long for selected symbol size");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
} }
@ -2581,7 +2581,7 @@ int microqr(struct zint_symbol *symbol, const unsigned char source[], size_t len
#endif #endif
if (length > 35) { if (length > 35) {
strcpy(symbol->errtxt, "Input data too long (E62)"); strcpy(symbol->errtxt, "562: Input data too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
@ -2613,7 +2613,7 @@ int microqr(struct zint_symbol *symbol, const unsigned char source[], size_t len
j++; j++;
} while ((j < 6843) && (glyph == 0)); } while ((j < 6843) && (glyph == 0));
if (glyph == 0) { if (glyph == 0) {
strcpy(symbol->errtxt, "Invalid character in input data (E63)"); strcpy(symbol->errtxt, "563: Invalid character in input data");
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }
jisdata[i] = glyph; jisdata[i] = glyph;
@ -2650,7 +2650,7 @@ int microqr(struct zint_symbol *symbol, const unsigned char source[], size_t len
error_number = micro_qr_intermediate(binary_stream, jisdata, mode, length, &kanji_used, &alphanum_used, &byte_used, symbol->debug); error_number = micro_qr_intermediate(binary_stream, jisdata, mode, length, &kanji_used, &alphanum_used, &byte_used, symbol->debug);
if (error_number != 0) { if (error_number != 0) {
strcpy(symbol->errtxt, "Input data too long (E64)"); strcpy(symbol->errtxt, "564: Input data too long");
return error_number; return error_number;
} }
@ -2682,7 +2682,7 @@ int microqr(struct zint_symbol *symbol, const unsigned char source[], size_t len
version_valid[2] = 0; version_valid[2] = 0;
} }
if (binary_count[3] > 128) { if (binary_count[3] > 128) {
strcpy(symbol->errtxt, "Input data too long (E65)"); strcpy(symbol->errtxt, "565: Input data too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
@ -2693,7 +2693,7 @@ int microqr(struct zint_symbol *symbol, const unsigned char source[], size_t len
} }
if (ecc_level == LEVEL_H) { if (ecc_level == LEVEL_H) {
strcpy(symbol->errtxt, "Error correction level H not available (E66)"); strcpy(symbol->errtxt, "566: Error correction level H not available");
return ZINT_ERROR_INVALID_OPTION; return ZINT_ERROR_INVALID_OPTION;
} }
@ -2702,7 +2702,7 @@ int microqr(struct zint_symbol *symbol, const unsigned char source[], size_t len
version_valid[1] = 0; version_valid[1] = 0;
version_valid[2] = 0; version_valid[2] = 0;
if (binary_count[3] > 80) { if (binary_count[3] > 80) {
strcpy(symbol->errtxt, "Input data too long (E67)"); strcpy(symbol->errtxt, "567: Input data too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
} }
@ -2716,7 +2716,7 @@ int microqr(struct zint_symbol *symbol, const unsigned char source[], size_t len
version_valid[2] = 0; version_valid[2] = 0;
} }
if (binary_count[3] > 112) { if (binary_count[3] > 112) {
strcpy(symbol->errtxt, "Input data too long (E68)"); strcpy(symbol->errtxt, "568: Input data too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
} }
@ -2738,7 +2738,7 @@ int microqr(struct zint_symbol *symbol, const unsigned char source[], size_t len
if (symbol->option_2 >= autoversion) { if (symbol->option_2 >= autoversion) {
version = symbol->option_2; version = symbol->option_2;
} else { } else {
strcpy(symbol->errtxt, "Input too long for selected symbol size"); strcpy(symbol->errtxt, "570: Input too long for selected symbol size");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
} }
@ -2919,13 +2919,13 @@ int upnqr(struct zint_symbol *symbol, const unsigned char source[], size_t lengt
} }
break; break;
case GS1_MODE: case GS1_MODE:
strcpy(symbol->errtxt, "UPNQR does not support GS-1 encoding"); strcpy(symbol->errtxt, "571: UPNQR does not support GS-1 encoding");
return ZINT_ERROR_INVALID_OPTION; return ZINT_ERROR_INVALID_OPTION;
break; break;
case UNICODE_MODE: case UNICODE_MODE:
error_number = utf_to_eci(4, source, preprocessed, &length); error_number = utf_to_eci(4, source, preprocessed, &length);
if (error_number != 0) { if (error_number != 0) {
strcpy(symbol->errtxt, "Invalid characters in input data (B04)"); strcpy(symbol->errtxt, "572: Invalid characters in input data");
return error_number; return error_number;
} }
for (i = 0; i < length; i++) { for (i = 0; i < length; i++) {
@ -2941,7 +2941,7 @@ int upnqr(struct zint_symbol *symbol, const unsigned char source[], size_t lengt
ecc_level = LEVEL_M; ecc_level = LEVEL_M;
if (est_binlen > 3320) { if (est_binlen > 3320) {
strcpy(symbol->errtxt, "Input too long for selected symbol"); strcpy(symbol->errtxt, "573: Input too long for selected symbol");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }

20
backend/raster.c
View File

@ -96,7 +96,7 @@ int save_raster_image_to_file(struct zint_symbol *symbol, int image_height, int
char *rotated_pixbuf; char *rotated_pixbuf;
if (!(rotated_pixbuf = (char *) malloc(image_width * image_height))) { if (!(rotated_pixbuf = (char *) malloc(image_width * image_height))) {
strcpy(symbol->errtxt, "Insufficient memory for pixel buffer (F50)"); strcpy(symbol->errtxt, "650: Insufficient memory for pixel buffer");
return ZINT_ERROR_ENCODING_PROBLEM; return ZINT_ERROR_ENCODING_PROBLEM;
} }
@ -118,24 +118,24 @@ int save_raster_image_to_file(struct zint_symbol *symbol, int image_height, int
to_upper((unsigned char*) symbol->bgcolour); to_upper((unsigned char*) symbol->bgcolour);
if (strlen(symbol->fgcolour) != 6) { if (strlen(symbol->fgcolour) != 6) {
strcpy(symbol->errtxt, "Malformed foreground colour target (F51)"); strcpy(symbol->errtxt, "651: Malformed foreground colour target");
free(rotated_pixbuf); free(rotated_pixbuf);
return ZINT_ERROR_INVALID_OPTION; return ZINT_ERROR_INVALID_OPTION;
} }
if (strlen(symbol->bgcolour) != 6) { if (strlen(symbol->bgcolour) != 6) {
strcpy(symbol->errtxt, "Malformed background colour target (F52)"); strcpy(symbol->errtxt, "652: Malformed background colour target");
free(rotated_pixbuf); free(rotated_pixbuf);
return ZINT_ERROR_INVALID_OPTION; return ZINT_ERROR_INVALID_OPTION;
} }
error_number = is_sane(SSET, (unsigned char*) symbol->fgcolour, strlen(symbol->fgcolour)); error_number = is_sane(SSET, (unsigned char*) symbol->fgcolour, strlen(symbol->fgcolour));
if (error_number == ZINT_ERROR_INVALID_DATA) { if (error_number == ZINT_ERROR_INVALID_DATA) {
strcpy(symbol->errtxt, "Malformed foreground colour target (F53)"); strcpy(symbol->errtxt, "653: Malformed foreground colour target");
free(rotated_pixbuf); free(rotated_pixbuf);
return ZINT_ERROR_INVALID_OPTION; return ZINT_ERROR_INVALID_OPTION;
} }
error_number = is_sane(SSET, (unsigned char*) symbol->bgcolour, strlen(symbol->fgcolour)); error_number = is_sane(SSET, (unsigned char*) symbol->bgcolour, strlen(symbol->fgcolour));
if (error_number == ZINT_ERROR_INVALID_DATA) { if (error_number == ZINT_ERROR_INVALID_DATA) {
strcpy(symbol->errtxt, "Malformed background colour target (F54)"); strcpy(symbol->errtxt, "654: Malformed background colour target");
free(rotated_pixbuf); free(rotated_pixbuf);
return ZINT_ERROR_INVALID_OPTION; return ZINT_ERROR_INVALID_OPTION;
} }
@ -495,7 +495,7 @@ int plot_raster_maxicode(struct zint_symbol *symbol, int rotate_angle, int data_
image_height = (300 + (2 * yoffset * 2)) * scaler; image_height = (300 + (2 * yoffset * 2)) * scaler;
if (!(pixelbuf = (char *) malloc(image_width * image_height))) { if (!(pixelbuf = (char *) malloc(image_width * image_height))) {
strcpy(symbol->errtxt, "Insufficient memory for pixel buffer (F55)"); strcpy(symbol->errtxt, "655: Insufficient memory for pixel buffer");
return ZINT_ERROR_ENCODING_PROBLEM; return ZINT_ERROR_ENCODING_PROBLEM;
} else { } else {
for (i = 0; i < (image_width * image_height); i++) { for (i = 0; i < (image_width * image_height); i++) {
@ -506,7 +506,7 @@ int plot_raster_maxicode(struct zint_symbol *symbol, int rotate_angle, int data_
hexagon_size = (int)scaler * 10; hexagon_size = (int)scaler * 10;
if (!(scaled_hexagon = (char *) malloc(hexagon_size * hexagon_size))) { if (!(scaled_hexagon = (char *) malloc(hexagon_size * hexagon_size))) {
strcpy(symbol->errtxt, "Insufficient memory for pixel buffer (F56)"); strcpy(symbol->errtxt, "656: Insufficient memory for pixel buffer");
free(scaled_hexagon); free(scaled_hexagon);
free(pixelbuf); free(pixelbuf);
return ZINT_ERROR_ENCODING_PROBLEM; return ZINT_ERROR_ENCODING_PROBLEM;
@ -617,7 +617,7 @@ int plot_raster_dotty(struct zint_symbol *symbol, int rotate_angle, int data_typ
/* Apply scale options by creating another pixel buffer */ /* Apply scale options by creating another pixel buffer */
if (!(scaled_pixelbuf = (char *) malloc(scale_width * scale_height))) { if (!(scaled_pixelbuf = (char *) malloc(scale_width * scale_height))) {
strcpy(symbol->errtxt, "Insufficient memory for pixel buffer (F57)"); strcpy(symbol->errtxt, "657: Insufficient memory for pixel buffer");
return ZINT_ERROR_ENCODING_PROBLEM; return ZINT_ERROR_ENCODING_PROBLEM;
} else { } else {
for (i = 0; i < (scale_width * scale_height); i++) { for (i = 0; i < (scale_width * scale_height); i++) {
@ -792,7 +792,7 @@ int plot_raster_default(struct zint_symbol *symbol, int rotate_angle, int data_t
image_height = 2 * (symbol->height + textoffset + yoffset + yoffset); image_height = 2 * (symbol->height + textoffset + yoffset + yoffset);
if (!(pixelbuf = (char *) malloc(image_width * image_height))) { if (!(pixelbuf = (char *) malloc(image_width * image_height))) {
strcpy(symbol->errtxt, "Insufficient memory for pixel buffer (F58)"); strcpy(symbol->errtxt, "658: Insufficient memory for pixel buffer");
return ZINT_ERROR_ENCODING_PROBLEM; return ZINT_ERROR_ENCODING_PROBLEM;
} else { } else {
for (i = 0; i < (image_width * image_height); i++) { for (i = 0; i < (image_width * image_height); i++) {
@ -1095,7 +1095,7 @@ int plot_raster_default(struct zint_symbol *symbol, int rotate_angle, int data_t
/* Apply scale options by creating another pixel buffer */ /* Apply scale options by creating another pixel buffer */
if (!(scaled_pixelbuf = (char *) malloc(scale_width * scale_height))) { if (!(scaled_pixelbuf = (char *) malloc(scale_width * scale_height))) {
free(pixelbuf); free(pixelbuf);
strcpy(symbol->errtxt, "Insufficient memory for pixel buffer (F59)"); strcpy(symbol->errtxt, "659: Insufficient memory for pixel buffer");
return ZINT_ERROR_ENCODING_PROBLEM; return ZINT_ERROR_ENCODING_PROBLEM;
} else { } else {
for (i = 0; i < (scale_width * scale_height); i++) { for (i = 0; i < (scale_width * scale_height); i++) {

16
backend/rss.c
View File

@ -170,12 +170,12 @@ int rss14(struct zint_symbol *symbol, unsigned char source[], int src_len) {
separator_row = 0; separator_row = 0;
if (src_len > 13) { if (src_len > 13) {
strcpy(symbol->errtxt, "Input too long (C80)"); strcpy(symbol->errtxt, "380: Input too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
error_number = is_sane(NEON, source, src_len); error_number = is_sane(NEON, source, src_len);
if (error_number == ZINT_ERROR_INVALID_DATA) { if (error_number == ZINT_ERROR_INVALID_DATA) {
strcpy(symbol->errtxt, "Invalid characters in data (C81)"); strcpy(symbol->errtxt, "381: Invalid characters in data");
return error_number; return error_number;
} }
@ -739,17 +739,17 @@ int rsslimited(struct zint_symbol *symbol, unsigned char source[], int src_len)
separator_row = 0; separator_row = 0;
if (src_len > 13) { if (src_len > 13) {
strcpy(symbol->errtxt, "Input too long (C82)"); strcpy(symbol->errtxt, "382: Input too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
error_number = is_sane(NEON, source, src_len); error_number = is_sane(NEON, source, src_len);
if (error_number == ZINT_ERROR_INVALID_DATA) { if (error_number == ZINT_ERROR_INVALID_DATA) {
strcpy(symbol->errtxt, "Invalid characters in data (C83)"); strcpy(symbol->errtxt, "383: Invalid characters in data");
return error_number; return error_number;
} }
if (src_len == 13) { if (src_len == 13) {
if ((source[0] != '0') && (source[0] != '1')) { if ((source[0] != '0') && (source[0] != '1')) {
strcpy(symbol->errtxt, "Input out of range (C84)"); strcpy(symbol->errtxt, "384: Input out of range");
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }
} }
@ -1361,7 +1361,7 @@ int rss_binary_string(struct zint_symbol *symbol, char source[], char binary_str
if ((source[i] < '0') || (source[i] > '9')) { if ((source[i] < '0') || (source[i] > '9')) {
if ((source[i] != '[') && (source[i] != ']')) { if ((source[i] != '[') && (source[i] != ']')) {
/* Something is wrong */ /* Something is wrong */
strcpy(symbol->errtxt, "Invalid characters in input data (C85)"); strcpy(symbol->errtxt, "385: Invalid characters in input data");
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }
} }
@ -1576,7 +1576,7 @@ int rss_binary_string(struct zint_symbol *symbol, char source[], char binary_str
if (latch == 1) { if (latch == 1) {
/* Invalid characters in input data */ /* Invalid characters in input data */
strcpy(symbol->errtxt, "Invalid characters in input data (C86)"); strcpy(symbol->errtxt, "386: Invalid characters in input data");
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }
@ -1812,7 +1812,7 @@ int rss_binary_string(struct zint_symbol *symbol, char source[], char binary_str
} }
if (strlen(binary_string) > 252) { if (strlen(binary_string) > 252) {
strcpy(symbol->errtxt, "Input too long"); strcpy(symbol->errtxt, "387: Input too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }

10
backend/svg.c
View File

@ -105,7 +105,7 @@ int svg_plot(struct zint_symbol *symbol) {
fsvg = fopen(symbol->outfile, "w"); fsvg = fopen(symbol->outfile, "w");
} }
if (fsvg == NULL) { if (fsvg == NULL) {
strcpy(symbol->errtxt, "Could not open output file (F60)"); strcpy(symbol->errtxt, "660: Could not open output file");
return ZINT_ERROR_FILE_ACCESS; return ZINT_ERROR_FILE_ACCESS;
} }
@ -114,24 +114,24 @@ int svg_plot(struct zint_symbol *symbol) {
to_upper((unsigned char*) symbol->bgcolour); to_upper((unsigned char*) symbol->bgcolour);
if (strlen(symbol->fgcolour) != 6) { if (strlen(symbol->fgcolour) != 6) {
strcpy(symbol->errtxt, "Malformed foreground colour target (F61)"); strcpy(symbol->errtxt, "661: Malformed foreground colour target");
fclose(fsvg); fclose(fsvg);
return ZINT_ERROR_INVALID_OPTION; return ZINT_ERROR_INVALID_OPTION;
} }
if (strlen(symbol->bgcolour) != 6) { if (strlen(symbol->bgcolour) != 6) {
strcpy(symbol->errtxt, "Malformed background colour target (F62)"); strcpy(symbol->errtxt, "662: Malformed background colour target");
fclose(fsvg); fclose(fsvg);
return ZINT_ERROR_INVALID_OPTION; return ZINT_ERROR_INVALID_OPTION;
} }
error_number = is_sane(SSET, (unsigned char*) symbol->fgcolour, strlen(symbol->fgcolour)); error_number = is_sane(SSET, (unsigned char*) symbol->fgcolour, strlen(symbol->fgcolour));
if (error_number == ZINT_ERROR_INVALID_DATA) { if (error_number == ZINT_ERROR_INVALID_DATA) {
strcpy(symbol->errtxt, "Malformed foreground colour target (F63)"); strcpy(symbol->errtxt, "663: Malformed foreground colour target");
fclose(fsvg); fclose(fsvg);
return ZINT_ERROR_INVALID_OPTION; return ZINT_ERROR_INVALID_OPTION;
} }
error_number = is_sane(SSET, (unsigned char*) symbol->bgcolour, strlen(symbol->bgcolour)); error_number = is_sane(SSET, (unsigned char*) symbol->bgcolour, strlen(symbol->bgcolour));
if (error_number == ZINT_ERROR_INVALID_DATA) { if (error_number == ZINT_ERROR_INVALID_DATA) {
strcpy(symbol->errtxt, "Malformed background colour target (F64)"); strcpy(symbol->errtxt, "664: Malformed background colour target");
fclose(fsvg); fclose(fsvg);
return ZINT_ERROR_INVALID_OPTION; return ZINT_ERROR_INVALID_OPTION;
} }

10
backend/telepen.c
View File

@ -66,7 +66,7 @@ int telepen(struct zint_symbol *symbol, unsigned char source[], const size_t src
count = 0; count = 0;
if (src_len > 30) { if (src_len > 30) {
strcpy(symbol->errtxt, "Input too long (C90)"); strcpy(symbol->errtxt, "390: Input too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
/* Start character */ /* Start character */
@ -75,7 +75,7 @@ int telepen(struct zint_symbol *symbol, unsigned char source[], const size_t src
for (i = 0; i < src_len; i++) { for (i = 0; i < src_len; i++) {
if (source[i] > 126) { if (source[i] > 126) {
/* Cannot encode extended ASCII */ /* Cannot encode extended ASCII */
strcpy(symbol->errtxt, "Invalid characters in input data (C91)"); strcpy(symbol->errtxt, "391: Invalid characters in input data");
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }
strcat(dest, TeleTable[source[i]]); strcat(dest, TeleTable[source[i]]);
@ -113,14 +113,14 @@ int telepen_num(struct zint_symbol *symbol, unsigned char source[], const size_t
count = 0; count = 0;
if (temp_length > 60) { if (temp_length > 60) {
strcpy(symbol->errtxt, "Input too long (C92)"); strcpy(symbol->errtxt, "392: Input too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
ustrcpy(temp, source); ustrcpy(temp, source);
to_upper(temp); to_upper(temp);
error_number = is_sane(SODIUM, temp, temp_length); error_number = is_sane(SODIUM, temp, temp_length);
if (error_number == ZINT_ERROR_INVALID_DATA) { if (error_number == ZINT_ERROR_INVALID_DATA) {
strcpy(symbol->errtxt, "Invalid characters in data (C93)"); strcpy(symbol->errtxt, "393: Invalid characters in data");
return error_number; return error_number;
} }
@ -137,7 +137,7 @@ int telepen_num(struct zint_symbol *symbol, unsigned char source[], const size_t
for (i = 0; i < temp_length; i += 2) { for (i = 0; i < temp_length; i += 2) {
if (temp[i] == 'X') { if (temp[i] == 'X') {
strcpy(symbol->errtxt, "Invalid position of X in Telepen data (C94)"); strcpy(symbol->errtxt, "394: Invalid position of X in Telepen data");
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }

14
backend/tif.c
View File

@ -57,10 +57,10 @@ int tif_pixel_plot(struct zint_symbol *symbol, char *pixelbuf) {
int free_memory; int free_memory;
int row, column; int row, column;
FILE *tif_file; FILE *tif_file;
#ifdef _MSC_VER #ifdef _MSC_VER
uint32_t* strip_offset; uint32_t* strip_offset;
uint32_t* strip_bytes; uint32_t* strip_bytes;
#endif #endif
tiff_header_t header; tiff_header_t header;
tiff_ifd_t ifd; tiff_ifd_t ifd;
@ -115,7 +115,7 @@ int tif_pixel_plot(struct zint_symbol *symbol, char *pixelbuf) {
free(strip_offset); free(strip_offset);
free(strip_bytes); free(strip_bytes);
#endif #endif
strcpy(symbol->errtxt, "Output file size too big (T00)"); strcpy(symbol->errtxt, "670: Output file size too big");
return ZINT_ERROR_MEMORY; return ZINT_ERROR_MEMORY;
} }
@ -123,14 +123,14 @@ int tif_pixel_plot(struct zint_symbol *symbol, char *pixelbuf) {
if (symbol->output_options & BARCODE_STDOUT) { if (symbol->output_options & BARCODE_STDOUT) {
#ifdef _MSC_VER #ifdef _MSC_VER
if (-1 == _setmode(_fileno(stdout), _O_BINARY)) { if (-1 == _setmode(_fileno(stdout), _O_BINARY)) {
strcpy(symbol->errtxt, "Can't open output file"); strcpy(symbol->errtxt, "671: Can't open output file");
return ZINT_ERROR_FILE_ACCESS; return ZINT_ERROR_FILE_ACCESS;
} }
#endif #endif
tif_file = stdout; tif_file = stdout;
} else { } else {
if (!(tif_file = fopen(symbol->outfile, "wb"))) { if (!(tif_file = fopen(symbol->outfile, "wb"))) {
strcpy(symbol->errtxt, "Can't open output file (T01)"); strcpy(symbol->errtxt, "672: Can't open output file");
return ZINT_ERROR_FILE_ACCESS; return ZINT_ERROR_FILE_ACCESS;
} }
} }

46
backend/upcean.c
View File

@ -137,7 +137,7 @@ int upca(struct zint_symbol *symbol, unsigned char source[], char dest[]) {
} else { } else {
gtin[length - 1] = '\0'; gtin[length - 1] = '\0';
if (source[length - 1] != upc_check(gtin)) { if (source[length - 1] != upc_check(gtin)) {
strcpy(symbol->errtxt, "Invalid check digit (C60)"); strcpy(symbol->errtxt, "270: Invalid check digit");
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }
gtin[length - 1] = upc_check(gtin); gtin[length - 1] = upc_check(gtin);
@ -229,7 +229,7 @@ int upce(struct zint_symbol *symbol, unsigned char source[], char dest[]) {
equivalent[10] = source[4]; equivalent[10] = source[4];
if (((source[2] == '0') || (source[2] == '1')) || (source[2] == '2')) { if (((source[2] == '0') || (source[2] == '1')) || (source[2] == '2')) {
/* Note 1 - "X3 shall not be equal to 0, 1 or 2" */ /* Note 1 - "X3 shall not be equal to 0, 1 or 2" */
strcpy(symbol->errtxt, "Invalid UPC-E data (C61)"); strcpy(symbol->errtxt, "271: Invalid UPC-E data");
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }
break; break;
@ -239,7 +239,7 @@ int upce(struct zint_symbol *symbol, unsigned char source[], char dest[]) {
equivalent[10] = source[4]; equivalent[10] = source[4];
if (source[3] == '0') { if (source[3] == '0') {
/* Note 2 - "X4 shall not be equal to 0" */ /* Note 2 - "X4 shall not be equal to 0" */
strcpy(symbol->errtxt, "Invalid UPC-E data (C62)"); strcpy(symbol->errtxt, "272: Invalid UPC-E data");
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }
break; break;
@ -254,7 +254,7 @@ int upce(struct zint_symbol *symbol, unsigned char source[], char dest[]) {
equivalent[10] = emode; equivalent[10] = emode;
if (source[4] == '0') { if (source[4] == '0') {
/* Note 3 - "X5 shall not be equal to 0" */ /* Note 3 - "X5 shall not be equal to 0" */
strcpy(symbol->errtxt, "Invalid UPC-E data (C63)"); strcpy(symbol->errtxt, "273: Invalid UPC-E data");
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }
break; break;
@ -293,7 +293,7 @@ int upce(struct zint_symbol *symbol, unsigned char source[], char dest[]) {
hrt[8] = '\0'; hrt[8] = '\0';
} else { } else {
if (hrt[7] != check_digit) { if (hrt[7] != check_digit) {
strcpy(symbol->errtxt, "Invalid check digit (C64)"); strcpy(symbol->errtxt, "274: Invalid check digit");
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }
} }
@ -400,7 +400,7 @@ int ean13(struct zint_symbol *symbol, unsigned char source[], char dest[]) {
} else { } else {
gtin[length - 1] = '\0'; gtin[length - 1] = '\0';
if (source[length - 1] != ean_check(gtin)) { if (source[length - 1] != ean_check(gtin)) {
strcpy(symbol->errtxt, "Invalid check digit (C65)"); strcpy(symbol->errtxt, "275: Invalid check digit");
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }
gtin[length - 1] = ean_check(gtin); gtin[length - 1] = ean_check(gtin);
@ -451,7 +451,7 @@ int ean8(struct zint_symbol *symbol, unsigned char source[], char dest[]) {
} else { } else {
gtin[length - 1] = '\0'; gtin[length - 1] = '\0';
if (source[length - 1] != upc_check(gtin)) { if (source[length - 1] != upc_check(gtin)) {
strcpy(symbol->errtxt, "Invalid check digit (C66)"); strcpy(symbol->errtxt, "276: Invalid check digit");
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }
gtin[length - 1] = upc_check(gtin); gtin[length - 1] = upc_check(gtin);
@ -512,26 +512,26 @@ static int isbn(struct zint_symbol *symbol, unsigned char source[], const size_t
to_upper(source); to_upper(source);
error_number = is_sane("0123456789X", source, src_len); error_number = is_sane("0123456789X", source, src_len);
if (error_number == ZINT_ERROR_INVALID_DATA) { if (error_number == ZINT_ERROR_INVALID_DATA) {
strcpy(symbol->errtxt, "Invalid characters in input (C67)"); strcpy(symbol->errtxt, "277: Invalid characters in input");
return error_number; return error_number;
} }
/* Input must be 9, 10 or 13 characters */ /* Input must be 9, 10 or 13 characters */
if (((src_len < 9) || (src_len > 13)) || ((src_len > 10) && (src_len < 13))) { if (((src_len < 9) || (src_len > 13)) || ((src_len > 10) && (src_len < 13))) {
strcpy(symbol->errtxt, "Input wrong length (C68)"); strcpy(symbol->errtxt, "278: Input wrong length");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
if (src_len == 13) /* Using 13 character ISBN */ { if (src_len == 13) /* Using 13 character ISBN */ {
if (!(((source[0] == '9') && (source[1] == '7')) && if (!(((source[0] == '9') && (source[1] == '7')) &&
((source[2] == '8') || (source[2] == '9')))) { ((source[2] == '8') || (source[2] == '9')))) {
strcpy(symbol->errtxt, "Invalid ISBN (C69)"); strcpy(symbol->errtxt, "279: Invalid ISBN");
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }
check_digit = isbn13_check(source); check_digit = isbn13_check(source);
if (source[src_len - 1] != check_digit) { if (source[src_len - 1] != check_digit) {
strcpy(symbol->errtxt, "Incorrect ISBN check (C6A)"); strcpy(symbol->errtxt, "280: Incorrect ISBN check");
return ZINT_ERROR_INVALID_CHECK; return ZINT_ERROR_INVALID_CHECK;
} }
source[12] = '\0'; source[12] = '\0';
@ -542,7 +542,7 @@ static int isbn(struct zint_symbol *symbol, unsigned char source[], const size_t
if (src_len == 10) /* Using 10 digit ISBN */ { if (src_len == 10) /* Using 10 digit ISBN */ {
check_digit = isbn_check(source); check_digit = isbn_check(source);
if (check_digit != source[src_len - 1]) { if (check_digit != source[src_len - 1]) {
strcpy(symbol->errtxt, "Incorrect ISBN check (C6B)"); strcpy(symbol->errtxt, "281: Incorrect ISBN check");
return ZINT_ERROR_INVALID_CHECK; return ZINT_ERROR_INVALID_CHECK;
} }
for (i = 13; i > 0; i--) { for (i = 13; i > 0; i--) {
@ -566,7 +566,7 @@ static int isbn(struct zint_symbol *symbol, unsigned char source[], const size_t
/* Verify check digit */ /* Verify check digit */
check_digit = isbn_check(source); check_digit = isbn_check(source);
if (check_digit != source[ustrlen(source) - 1]) { if (check_digit != source[ustrlen(source) - 1]) {
strcpy(symbol->errtxt, "Incorrect SBN check (C6C)"); strcpy(symbol->errtxt, "282: Incorrect SBN check");
return ZINT_ERROR_INVALID_CHECK; return ZINT_ERROR_INVALID_CHECK;
} }
@ -727,20 +727,20 @@ int eanx(struct zint_symbol *symbol, unsigned char source[], int src_len) {
writer = 0; writer = 0;
if (src_len > 19) { if (src_len > 19) {
strcpy(symbol->errtxt, "Input too long (C6D)"); strcpy(symbol->errtxt, "283: Input too long");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
if (symbol->symbology != BARCODE_ISBNX) { if (symbol->symbology != BARCODE_ISBNX) {
/* ISBN has it's own checking routine */ /* ISBN has it's own checking routine */
error_number = is_sane("0123456789+", source, src_len); error_number = is_sane("0123456789+", source, src_len);
if (error_number == ZINT_ERROR_INVALID_DATA) { if (error_number == ZINT_ERROR_INVALID_DATA) {
strcpy(symbol->errtxt, "Invalid characters in data (C6E)"); strcpy(symbol->errtxt, "284: Invalid characters in data");
return error_number; return error_number;
} }
} else { } else {
error_number = is_sane("0123456789Xx", source, src_len); error_number = is_sane("0123456789Xx", source, src_len);
if (error_number == ZINT_ERROR_INVALID_DATA) { if (error_number == ZINT_ERROR_INVALID_DATA) {
strcpy(symbol->errtxt, "Invalid characters in input (C6F)"); strcpy(symbol->errtxt, "285: Invalid characters in input");
return error_number; return error_number;
} }
} }
@ -799,7 +799,7 @@ int eanx(struct zint_symbol *symbol, unsigned char source[], int src_len) {
case 12: case 12:
case 13: error_number = ean13(symbol, first_part, (char*) dest); case 13: error_number = ean13(symbol, first_part, (char*) dest);
break; break;
default: strcpy(symbol->errtxt, "Invalid length input (C6G)"); default: strcpy(symbol->errtxt, "286: Invalid length input");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
break; break;
@ -829,7 +829,7 @@ int eanx(struct zint_symbol *symbol, unsigned char source[], int src_len) {
symbol->rows += 3; symbol->rows += 3;
error_number = ean13(symbol, first_part, (char*) dest); error_number = ean13(symbol, first_part, (char*) dest);
break; break;
default: strcpy(symbol->errtxt, "Invalid length EAN input (C6H)"); default: strcpy(symbol->errtxt, "287: Invalid length EAN input");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
break; break;
@ -838,7 +838,7 @@ int eanx(struct zint_symbol *symbol, unsigned char source[], int src_len) {
if ((ustrlen(first_part) == 11) || (ustrlen(first_part) == 12)) { if ((ustrlen(first_part) == 11) || (ustrlen(first_part) == 12)) {
error_number = upca(symbol, first_part, (char*) dest); error_number = upca(symbol, first_part, (char*) dest);
} else { } else {
strcpy(symbol->errtxt, "Input wrong length (C6I)"); strcpy(symbol->errtxt, "288: Input wrong length (C6I)");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
break; break;
@ -856,7 +856,7 @@ int eanx(struct zint_symbol *symbol, unsigned char source[], int src_len) {
symbol->rows += 3; symbol->rows += 3;
error_number = upca(symbol, first_part, (char*) dest); error_number = upca(symbol, first_part, (char*) dest);
} else { } else {
strcpy(symbol->errtxt, "UPCA input wrong length (C6J)"); strcpy(symbol->errtxt, "289: UPCA input wrong length");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
break; break;
@ -865,7 +865,7 @@ int eanx(struct zint_symbol *symbol, unsigned char source[], int src_len) {
if ((ustrlen(first_part) >= 6) && (ustrlen(first_part) <= 8)) { if ((ustrlen(first_part) >= 6) && (ustrlen(first_part) <= 8)) {
error_number = upce(symbol, first_part, (char*) dest); error_number = upce(symbol, first_part, (char*) dest);
} else { } else {
strcpy(symbol->errtxt, "Input wrong length (C6K)"); strcpy(symbol->errtxt, "290: Input wrong length");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
break; break;
@ -883,7 +883,7 @@ int eanx(struct zint_symbol *symbol, unsigned char source[], int src_len) {
symbol->rows += 3; symbol->rows += 3;
error_number = upce(symbol, first_part, (char*) dest); error_number = upce(symbol, first_part, (char*) dest);
} else { } else {
strcpy(symbol->errtxt, "UPCE input wrong length (C6L)"); strcpy(symbol->errtxt, "291: UPCE input wrong length");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }
break; break;
@ -909,7 +909,7 @@ int eanx(struct zint_symbol *symbol, unsigned char source[], int src_len) {
strcat((char*) symbol->text, (char*) second_part); strcat((char*) symbol->text, (char*) second_part);
break; break;
default: default:
strcpy(symbol->errtxt, "Invalid length input (C6M)"); strcpy(symbol->errtxt, "292: Invalid length input");
return ZINT_ERROR_TOO_LONG; return ZINT_ERROR_TOO_LONG;
} }

50
frontend/main.c
View File

@ -281,7 +281,7 @@ int batch_process(struct zint_symbol *symbol, char *filename, int mirror_mode, c
if (strlen(format_string) < 127) { if (strlen(format_string) < 127) {
strcpy(format_string, symbol->outfile); strcpy(format_string, symbol->outfile);
} else { } else {
strcpy(symbol->errtxt, "Format string too long (A01)"); strcpy(symbol->errtxt, "101: Format string too long");
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }
} }
@ -292,7 +292,7 @@ int batch_process(struct zint_symbol *symbol, char *filename, int mirror_mode, c
} else { } else {
file = fopen(filename, "rb"); file = fopen(filename, "rb");
if (!file) { if (!file) {
strcpy(symbol->errtxt, "Unable to read input file (A02)"); strcpy(symbol->errtxt, "102: Unable to read input file");
return ZINT_ERROR_INVALID_DATA; return ZINT_ERROR_INVALID_DATA;
} }
} }
@ -415,7 +415,7 @@ int batch_process(struct zint_symbol *symbol, char *filename, int mirror_mode, c
posn++; posn++;
} }
if (posn > 7090) { if (posn > 7090) {
fprintf(stderr, "On line %d: Input data too long (A03)\n", line_count); fprintf(stderr, "103 on line %d: Input data too long\n", line_count);
fflush(stderr); fflush(stderr);
do { do {
character = fgetc(file); character = fgetc(file);
@ -424,7 +424,7 @@ int batch_process(struct zint_symbol *symbol, char *filename, int mirror_mode, c
} while ((!feof(file)) && (line_count < 2000000000)); } while ((!feof(file)) && (line_count < 2000000000));
if (character != '\n') { if (character != '\n') {
fprintf(stderr, "Warning: No newline at end of file (A04)\n"); fprintf(stderr, "warning 104: No newline at end of file\n");
fflush(stderr); fflush(stderr);
} }
@ -570,7 +570,7 @@ int main(int argc, char **argv) {
my_symbol->scale = (float) (atof(optarg)); my_symbol->scale = (float) (atof(optarg));
if (my_symbol->scale < 0.01) { if (my_symbol->scale < 0.01) {
/* Zero and negative values are not permitted */ /* Zero and negative values are not permitted */
fprintf(stderr, "Invalid scale value (A05)\n"); fprintf(stderr, "105: Invalid scale value\n");
fflush(stderr); fflush(stderr);
my_symbol->scale = 1.0; my_symbol->scale = 1.0;
} }
@ -579,7 +579,7 @@ int main(int argc, char **argv) {
my_symbol->dot_size = (float) (atof(optarg)); my_symbol->dot_size = (float) (atof(optarg));
if (my_symbol->dot_size < 0.01) { if (my_symbol->dot_size < 0.01) {
/* Zero and negative values are not permitted */ /* Zero and negative values are not permitted */
fprintf(stderr, "Invalid dot radius value (A06)\n"); fprintf(stderr, "106: Invalid dot radius value\n");
fflush(stderr); fflush(stderr);
my_symbol->dot_size = 4.0F / 5.0F; my_symbol->dot_size = 4.0F / 5.0F;
} }
@ -587,26 +587,26 @@ int main(int argc, char **argv) {
if (!strcmp(long_options[option_index].name, "border")) { if (!strcmp(long_options[option_index].name, "border")) {
error_number = validator(NESET, optarg); error_number = validator(NESET, optarg);
if (error_number == ZINT_ERROR_INVALID_DATA) { if (error_number == ZINT_ERROR_INVALID_DATA) {
fprintf(stderr, "Invalid border width (A07)\n"); fprintf(stderr, "107: Invalid border width\n");
exit(1); exit(1);
} }
if ((atoi(optarg) >= 0) && (atoi(optarg) <= 1000)) { if ((atoi(optarg) >= 0) && (atoi(optarg) <= 1000)) {
my_symbol->border_width = atoi(optarg); my_symbol->border_width = atoi(optarg);
} else { } else {
fprintf(stderr, "Border width out of range (A08)\n"); fprintf(stderr, "108: Border width out of range\n");
fflush(stderr); fflush(stderr);
} }
} }
if (!strcmp(long_options[option_index].name, "height")) { if (!strcmp(long_options[option_index].name, "height")) {
error_number = validator(NESET, optarg); error_number = validator(NESET, optarg);
if (error_number == ZINT_ERROR_INVALID_DATA) { if (error_number == ZINT_ERROR_INVALID_DATA) {
fprintf(stderr, "Invalid symbol height (A09)\n"); fprintf(stderr, "109: Invalid symbol height\n");
exit(1); exit(1);
} }
if ((atoi(optarg) >= 1) && (atoi(optarg) <= 1000)) { if ((atoi(optarg) >= 1) && (atoi(optarg) <= 1000)) {
my_symbol->height = atoi(optarg); my_symbol->height = atoi(optarg);
} else { } else {
fprintf(stderr, "Symbol height out of range (A10)\n"); fprintf(stderr, "110: Symbol height out of range\n");
fflush(stderr); fflush(stderr);
} }
} }
@ -615,7 +615,7 @@ int main(int argc, char **argv) {
if ((atoi(optarg) >= 1) && (atoi(optarg) <= 66)) { if ((atoi(optarg) >= 1) && (atoi(optarg) <= 66)) {
my_symbol->option_2 = atoi(optarg); my_symbol->option_2 = atoi(optarg);
} else { } else {
fprintf(stderr, "Number of columns out of range (A11)\n"); fprintf(stderr, "111: Number of columns out of range\n");
fflush(stderr); fflush(stderr);
} }
} }
@ -623,7 +623,7 @@ int main(int argc, char **argv) {
if ((atoi(optarg) >= 1) && (atoi(optarg) <= 44)) { if ((atoi(optarg) >= 1) && (atoi(optarg) <= 44)) {
my_symbol->option_1 = atoi(optarg); my_symbol->option_1 = atoi(optarg);
} else { } else {
fprintf(stderr, "Number of rows out of range (A12)\n"); fprintf(stderr, "112: Number of rows out of range\n");
fflush(stderr); fflush(stderr);
} }
} }
@ -631,7 +631,7 @@ int main(int argc, char **argv) {
if ((atoi(optarg) >= 1) && (atoi(optarg) <= 84)) { if ((atoi(optarg) >= 1) && (atoi(optarg) <= 84)) {
my_symbol->option_2 = atoi(optarg); my_symbol->option_2 = atoi(optarg);
} else { } else {
fprintf(stderr, "Invalid Version (A13)\n"); fprintf(stderr, "113: Invalid Version\n");
fflush(stderr); fflush(stderr);
} }
} }
@ -639,7 +639,7 @@ int main(int argc, char **argv) {
if ((atoi(optarg) >= 1) && (atoi(optarg) <= 8)) { if ((atoi(optarg) >= 1) && (atoi(optarg) <= 8)) {
my_symbol->option_1 = atoi(optarg); my_symbol->option_1 = atoi(optarg);
} else { } else {
fprintf(stderr, "ECC level out of range (A14)\n"); fprintf(stderr, "114: ECC level out of range\n");
fflush(stderr); fflush(stderr);
} }
} }
@ -647,7 +647,7 @@ int main(int argc, char **argv) {
if (strlen(optarg) <= 90) { if (strlen(optarg) <= 90) {
strcpy(my_symbol->primary, optarg); strcpy(my_symbol->primary, optarg);
} else { } else {
fprintf(stderr, "Primary data string too long (A15)"); fprintf(stderr, "115: Primary data string too long");
fflush(stderr); fflush(stderr);
} }
} }
@ -655,7 +655,7 @@ int main(int argc, char **argv) {
if ((optarg[0] >= '0') && (optarg[0] <= '6')) { if ((optarg[0] >= '0') && (optarg[0] <= '6')) {
my_symbol->option_1 = optarg[0] - '0'; my_symbol->option_1 = optarg[0] - '0';
} else { } else {
fprintf(stderr, "Invalid mode (A16)\n"); fprintf(stderr, "116: Invalid mode\n");
fflush(stderr); fflush(stderr);
} }
} }
@ -663,7 +663,7 @@ int main(int argc, char **argv) {
/* Only certain inputs allowed */ /* Only certain inputs allowed */
error_number = validator(NESET, optarg); error_number = validator(NESET, optarg);
if (error_number == ZINT_ERROR_INVALID_DATA) { if (error_number == ZINT_ERROR_INVALID_DATA) {
fprintf(stderr, "Invalid rotation parameter (A17)\n"); fprintf(stderr, "117: Invalid rotation parameter\n");
exit(1); exit(1);
} }
switch (atoi(optarg)) { switch (atoi(optarg)) {
@ -693,7 +693,7 @@ int main(int argc, char **argv) {
if ((atoi(optarg) >= 0) && (atoi(optarg) <= 999999)) { if ((atoi(optarg) >= 0) && (atoi(optarg) <= 999999)) {
my_symbol->eci = atoi(optarg); my_symbol->eci = atoi(optarg);
} else { } else {
fprintf(stderr, "Invalid ECI code (A18)\n"); fprintf(stderr, "118: Invalid ECI code\n");
fflush(stderr); fflush(stderr);
} }
} }
@ -717,7 +717,7 @@ int main(int argc, char **argv) {
case 'b': case 'b':
error_number = validator(NESET, optarg); error_number = validator(NESET, optarg);
if (error_number == ZINT_ERROR_INVALID_DATA) { if (error_number == ZINT_ERROR_INVALID_DATA) {
fprintf(stderr, "Invalid barcode type (A19)\n"); fprintf(stderr, "119: Invalid barcode type\n");
exit(1); exit(1);
} }
my_symbol->symbology = atoi(optarg); my_symbol->symbology = atoi(optarg);
@ -726,13 +726,13 @@ int main(int argc, char **argv) {
case 'w': case 'w':
error_number = validator(NESET, optarg); error_number = validator(NESET, optarg);
if (error_number == ZINT_ERROR_INVALID_DATA) { if (error_number == ZINT_ERROR_INVALID_DATA) {
fprintf(stderr, "Invalid whitespace value (A20)\n"); fprintf(stderr, "120: Invalid whitespace value\n");
exit(1); exit(1);
} }
if ((atoi(optarg) >= 0) && (atoi(optarg) <= 1000)) { if ((atoi(optarg) >= 0) && (atoi(optarg) <= 1000)) {
my_symbol->whitespace_width = atoi(optarg); my_symbol->whitespace_width = atoi(optarg);
} else { } else {
fprintf(stderr, "Whitespace value out of range (A21)"); fprintf(stderr, "121: Whitespace value out of range");
fflush(stderr); fflush(stderr);
} }
break; break;
@ -759,7 +759,7 @@ int main(int argc, char **argv) {
return 1; return 1;
} }
} else { } else {
fprintf(stderr, "Cannot define data in batch mode (A22)"); fprintf(stderr, "122: Cannot define data in batch mode");
fflush(stderr); fflush(stderr);
} }
break; break;
@ -810,13 +810,13 @@ int main(int argc, char **argv) {
break; break;
default: default:
fprintf(stderr, "?? getopt error 0%o (A23)\n", c); fprintf(stderr, "123: ?? getopt error 0%o\n", c);
fflush(stderr); fflush(stderr);
} }
} }
if (optind < argc) { if (optind < argc) {
fprintf(stderr, "Invalid option "); fprintf(stderr, "125: Invalid option\n");
while (optind < argc) while (optind < argc)
fprintf(stderr, "%s", argv[optind++]); fprintf(stderr, "%s", argv[optind++]);
fprintf(stderr, "\n"); fprintf(stderr, "\n");
@ -824,7 +824,7 @@ int main(int argc, char **argv) {
} }
if (generated == 0) { if (generated == 0) {
fprintf(stderr, "error: No data received, no symbol generated (A24)\n"); fprintf(stderr, "124: No data received, no symbol generated\n");
fflush(stderr); fflush(stderr);
} }

2
frontend_qt/mainwindow.cpp
View File

@ -37,7 +37,7 @@ MainWindow::MainWindow(QWidget* parent, Qt::WindowFlags fl)
: QWidget(parent, fl),m_optionWidget(0) : QWidget(parent, fl),m_optionWidget(0)
{ {
QCoreApplication::setOrganizationName("Zint"); QCoreApplication::setOrganizationName("zint");
QCoreApplication::setOrganizationDomain("zint.org.uk"); QCoreApplication::setOrganizationDomain("zint.org.uk");
QCoreApplication::setApplicationName("Barcode Studio"); QCoreApplication::setApplicationName("Barcode Studio");