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

code cleanup and minor fixes

Browse Source
This commit is contained in:
oxygenic 2012-12-31 14:41:59 +01:00
parent 8c78216dc1
commit 1d241cca05
26 changed files with 1048 additions and 1092 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
backend/code1.h
View File

@ -3,55 +3,41 @@
/* /*
libzint - the open source barcode library libzint - the open source barcode library
Copyright (C) 2009 Robin Stuart <robin@zint.org.uk> Copyright (C) 2009 Robin Stuart <robin@zint.org.uk>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/ */
static int c40_shift[] = { static const int c40_shift[] = {
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 }; 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 };
static int c40_value[] = { static const int c40_value[] = {
0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31, 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,
3,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,4,5,6,7,8,9,10,11,12,13, 3,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,4,5,6,7,8,9,10,11,12,13,
15,16,17,18,19,20,21,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39, 15,16,17,18,19,20,21,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,
22,23,24,25,26,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31 }; 22,23,24,25,26,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31 };
static int text_shift[] = { static const int text_shift[] = {
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
2, 2, 2, 2, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3 }; 2, 2, 2, 2, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3 };
static int text_value[] = { static const int text_value[] = {
0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31, 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,
3,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,4,5,6,7,8,9,10,11,12,13, 3,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,4,5,6,7,8,9,10,11,12,13,
15,16,17,18,19,20,21,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26, 15,16,17,18,19,20,21,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,
22,23,24,25,26,0,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,27,28,29,30,31 }; 22,23,24,25,26,0,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,27,28,29,30,31 };
static int c1_height[] = { 16, 22, 28, 40, 52, 70, 104, 148 }; static const int c1_height[] = { 16, 22, 28, 40, 52, 70, 104, 148 };
static int c1_width[] = { 18, 22, 32, 42, 54, 76, 98, 134 }; static const int c1_width[] = { 18, 22, 32, 42, 54, 76, 98, 134 };
static int c1_data_length[] = { 10, 19, 44, 91, 182, 370, 732, 1480 }; static const int c1_data_length[] = { 10, 19, 44, 91, 182, 370, 732, 1480 };
static int c1_ecc_length[] = { 10, 16, 26, 44, 70, 140, 280, 560 }; static const int c1_ecc_length[] = { 10, 16, 26, 44, 70, 140, 280, 560 };
static int c1_blocks[] = { 1, 1, 1, 1, 1, 2, 4, 8 }; static const int c1_blocks[] = { 1, 1, 1, 1, 1, 2, 4, 8 };
static int c1_data_blocks[] = { 10, 19, 44, 91, 182, 185, 183, 185 }; static const int c1_data_blocks[] = { 10, 19, 44, 91, 182, 185, 183, 185 };
static int c1_ecc_blocks[] = { 10, 16, 26, 44, 70, 70, 70, 70 }; static const int c1_ecc_blocks[] = { 10, 16, 26, 44, 70, 70, 70, 70 };
static int c1_grid_width[] = { 4, 5, 7, 9, 12, 17, 22, 30 }; static const int c1_grid_width[] = { 4, 5, 7, 9, 12, 17, 22, 30 };
static int c1_grid_height[] = { 5, 7, 10, 15, 21, 30, 46, 68 }; static const int c1_grid_height[] = { 5, 7, 10, 15, 21, 30, 46, 68 };
#define C1_ASCII 1 #define C1_ASCII 1
#define C1_C40 2 #define C1_C40 2

102
backend/code128.c
View File

@ -32,7 +32,7 @@ static int list[2][170];
/* Code 128 tables checked against ISO/IEC 15417:2007 */ /* Code 128 tables checked against ISO/IEC 15417:2007 */
static char *C128Table[107] = {"212222", "222122", "222221", "121223", "121322", "131222", "122213", static const char *C128Table[107] = {"212222", "222122", "222221", "121223", "121322", "131222", "122213",
"122312", "132212", "221213", "221312", "231212", "112232", "122132", "122231", "113222", "122312", "132212", "221213", "221312", "231212", "112232", "122132", "122231", "113222",
"123122", "123221", "223211", "221132", "221231", "213212", "223112", "312131", "311222", "123122", "123221", "223211", "221132", "221231", "213212", "223112", "312131", "311222",
"321122", "321221", "312212", "322112", "322211", "212123", "212321", "232121", "111323", "321122", "321221", "312212", "322112", "322211", "212123", "212321", "232121", "111323",
@ -63,6 +63,9 @@ int parunmodd(unsigned char llyth)
return modd; return modd;
} }
/**
* bring together same type blocks
*/
void grwp(int *indexliste) void grwp(int *indexliste)
{ {
int i, j; int i, j;
@ -90,6 +93,9 @@ void grwp(int *indexliste)
} }
} }
/**
* Implements rules from ISO 15417 Annex E
*/
void dxsmooth(int *indexliste) void dxsmooth(int *indexliste)
{ /* Implements rules from ISO 15417 Annex E */ { /* Implements rules from ISO 15417 Annex E */
int i, current, last, next, length; int i, current, last, next, length;
@ -128,6 +134,10 @@ void dxsmooth(int *indexliste)
} }
/**
* Translate Code 128 Set A characters into barcodes.
* This set handles all control characters NULL to US.
*/
void c128_set_a(unsigned char source, char dest[], int values[], int *bar_chars) void c128_set_a(unsigned char source, char dest[], int values[], int *bar_chars)
{ /* Translate Code 128 Set A characters into barcodes */ { /* Translate Code 128 Set A characters into barcodes */
/* This set handles all control characters NULL to US */ /* This set handles all control characters NULL to US */
@ -152,10 +162,13 @@ void c128_set_a(unsigned char source, char dest[], int values[], int *bar_chars)
(*bar_chars)++; (*bar_chars)++;
} }
/**
* Translate Code 128 Set B characters into barcodes.
* This set handles all characters which are not part of long numbers and not
* control characters.
*/
void c128_set_b(unsigned char source, char dest[], int values[], int *bar_chars) void c128_set_b(unsigned char source, char dest[], int values[], int *bar_chars)
{ /* Translate Code 128 Set B characters into barcodes */ {
/* This set handles all characters which are not part of long numbers and not control characters */
if(source > 127) { if(source > 127) {
concat(dest, C128Table[source - 32 - 128]); concat(dest, C128Table[source - 32 - 128]);
values[(*bar_chars)] = source - 32 - 128; values[(*bar_chars)] = source - 32 - 128;
@ -184,10 +197,10 @@ int code_128(struct zint_symbol *symbol, unsigned char source[], int length)
char set[170] = { ' ' }, fset[170] = { ' ' }, mode, last_set, current_set = ' '; char set[170] = { ' ' }, fset[170] = { ' ' }, mode, last_set, current_set = ' ';
float glyph_count; float glyph_count;
char dest[1000]; char dest[1000];
error_number = 0; error_number = 0;
strcpy(dest, ""); strcpy(dest, "");
sourcelen = length; sourcelen = length;
j = 0; j = 0;
@ -200,7 +213,7 @@ int code_128(struct zint_symbol *symbol, unsigned char source[], int length)
strcpy(symbol->errtxt, "Input too long"); strcpy(symbol->errtxt, "Input too long");
return ERROR_TOO_LONG; return ERROR_TOO_LONG;
} }
/* Detect extended ASCII characters */ /* Detect extended ASCII characters */
for(i = 0; i < sourcelen; i++) { for(i = 0; i < sourcelen; i++) {
if(source[i] >= 128) if(source[i] >= 128)
@ -216,13 +229,13 @@ int code_128(struct zint_symbol *symbol, unsigned char source[], int length)
} else { } else {
j = 0; j = 0;
} }
if(j >= 5) { if(j >= 5) {
for(k = i; k > (i - 5); k--) { for(k = i; k > (i - 5); k--) {
fset[k] = 'F'; fset[k] = 'F';
} }
} }
if((j >= 3) && (i == (sourcelen - 1))) { if((j >= 3) && (i == (sourcelen - 1))) {
for(k = i; k > (i - 3); k--) { for(k = i; k > (i - 3); k--) {
fset[k] = 'F'; fset[k] = 'F';
@ -248,7 +261,7 @@ int code_128(struct zint_symbol *symbol, unsigned char source[], int length)
/* Decide on mode using same system as PDF417 and rules of ISO 15417 Annex E */ /* Decide on mode using same system as PDF417 and rules of ISO 15417 Annex E */
indexliste = 0; indexliste = 0;
indexchaine = 0; indexchaine = 0;
mode = parunmodd(source[indexchaine]); mode = parunmodd(source[indexchaine]);
if((symbol->symbology == BARCODE_CODE128B) && (mode == ABORC)) { if((symbol->symbology == BARCODE_CODE128B) && (mode == ABORC)) {
mode = AORB; mode = AORB;
@ -270,7 +283,7 @@ int code_128(struct zint_symbol *symbol, unsigned char source[], int length)
} }
indexliste++; indexliste++;
} while (indexchaine < sourcelen); } while (indexchaine < sourcelen);
dxsmooth(&indexliste); dxsmooth(&indexliste);
/* Resolve odd length LATCHC blocks */ /* Resolve odd length LATCHC blocks */
@ -295,7 +308,7 @@ int code_128(struct zint_symbol *symbol, unsigned char source[], int length)
} }
/* Put set data into set[] */ /* Put set data into set[] */
read = 0; read = 0;
for(i = 0; i < indexliste; i++) { for(i = 0; i < indexliste; i++) {
for(j = 0; j < list[0][i]; j++) { for(j = 0; j < list[0][i]; j++) {
@ -356,7 +369,7 @@ int code_128(struct zint_symbol *symbol, unsigned char source[], int length)
glyph_count = glyph_count + 2.0; glyph_count = glyph_count + 2.0;
} }
} }
if(set[i] == 'C') { if(set[i] == 'C') {
glyph_count = glyph_count + 0.5; glyph_count = glyph_count + 0.5;
} else { } else {
@ -367,8 +380,7 @@ int code_128(struct zint_symbol *symbol, unsigned char source[], int length)
strcpy(symbol->errtxt, "Input too long"); strcpy(symbol->errtxt, "Input too long");
return ERROR_TOO_LONG; return ERROR_TOO_LONG;
} }
/* So now we know what start character to use - we can get on with it! */ /* So now we know what start character to use - we can get on with it! */
if(symbol->output_options & READER_INIT) { if(symbol->output_options & READER_INIT) {
/* Reader Initialisation mode */ /* Reader Initialisation mode */
@ -422,7 +434,7 @@ int code_128(struct zint_symbol *symbol, unsigned char source[], int length)
} }
bar_characters++; bar_characters++;
last_set = set[0]; last_set = set[0];
if(fset[0] == 'F') { if(fset[0] == 'F') {
switch(current_set) { switch(current_set) {
case 'A': case 'A':
@ -441,7 +453,7 @@ int code_128(struct zint_symbol *symbol, unsigned char source[], int length)
bar_characters += 2; bar_characters += 2;
f_state = 1; f_state = 1;
} }
/* Encode the data */ /* Encode the data */
read = 0; read = 0;
do { do {
@ -545,7 +557,7 @@ int code_128(struct zint_symbol *symbol, unsigned char source[], int length)
read += 2; read += 2;
break; break;
} }
} while (read < sourcelen); } while (read < sourcelen);
/* check digit calculation */ /* check digit calculation */
@ -593,7 +605,7 @@ int ean_128(struct zint_symbol *symbol, unsigned char source[], int length)
memset(values, 0, sizeof(values)); memset(values, 0, sizeof(values));
memset(set, ' ', sizeof(set)); memset(set, ' ', sizeof(set));
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 */
@ -607,7 +619,7 @@ int ean_128(struct zint_symbol *symbol, unsigned char source[], int length)
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
} }
} }
/* if part of a composite symbol make room for the separator pattern */ /* if part of a composite symbol make room for the separator pattern */
if(symbol->symbology == BARCODE_EAN128_CC) { if(symbol->symbology == BARCODE_EAN128_CC) {
separator_row = symbol->rows; separator_row = symbol->rows;
@ -620,11 +632,11 @@ int ean_128(struct zint_symbol *symbol, unsigned char source[], int length)
error_number = gs1_verify(symbol, source, length, reduced); error_number = gs1_verify(symbol, source, length, reduced);
if(error_number != 0) { return error_number; } if(error_number != 0) { return error_number; }
} }
/* Decide on mode using same system as PDF417 and rules of ISO 15417 Annex E */ /* Decide on mode using same system as PDF417 and rules of ISO 15417 Annex E */
indexliste = 0; indexliste = 0;
indexchaine = 0; indexchaine = 0;
mode = parunmodd(reduced[indexchaine]); mode = parunmodd(reduced[indexchaine]);
if(reduced[indexchaine] == '[') { if(reduced[indexchaine] == '[') {
mode = ABORC; mode = ABORC;
@ -644,9 +656,9 @@ int ean_128(struct zint_symbol *symbol, unsigned char source[], int length)
} }
indexliste++; indexliste++;
} while (indexchaine < strlen(reduced)); } while (indexchaine < strlen(reduced));
dxsmooth(&indexliste); dxsmooth(&indexliste);
/* Put set data into set[] */ /* Put set data into set[] */
read = 0; read = 0;
for(i = 0; i < indexliste; i++) { for(i = 0; i < indexliste; i++) {
@ -720,7 +732,7 @@ int ean_128(struct zint_symbol *symbol, unsigned char source[], int length)
glyph_count = glyph_count + 1.0; glyph_count = glyph_count + 1.0;
} }
} }
if((set[i] == 'C') && (reduced[i] != '[')) { if((set[i] == 'C') && (reduced[i] != '[')) {
glyph_count = glyph_count + 0.5; glyph_count = glyph_count + 0.5;
} else { } else {
@ -731,7 +743,7 @@ int ean_128(struct zint_symbol *symbol, unsigned char source[], int length)
strcpy(symbol->errtxt, "Input too long"); strcpy(symbol->errtxt, "Input too long");
return ERROR_TOO_LONG; return ERROR_TOO_LONG;
} }
/* So now we know what start character to use - we can get on with it! */ /* So now we know what start character to use - we can get on with it! */
switch(set[0]) switch(set[0])
{ {
@ -749,7 +761,7 @@ int ean_128(struct zint_symbol *symbol, unsigned char source[], int length)
break; break;
} }
bar_characters++; bar_characters++;
concat(dest, C128Table[102]); concat(dest, C128Table[102]);
values[1] = 102; values[1] = 102;
bar_characters++; bar_characters++;
@ -776,7 +788,7 @@ int ean_128(struct zint_symbol *symbol, unsigned char source[], int length)
break; break;
} }
} }
if((set[read] == 'a') || (set[read] == 'b')) { if((set[read] == 'a') || (set[read] == 'b')) {
/* Insert shift character */ /* Insert shift character */
concat(dest, C128Table[98]); concat(dest, C128Table[98]);
@ -809,7 +821,7 @@ int ean_128(struct zint_symbol *symbol, unsigned char source[], int length)
read++; read++;
} }
} while (read < strlen(reduced)); } while (read < strlen(reduced));
/* "...note that the linkage flag is an extra code set character between /* "...note that the linkage flag is an extra code set character between
the last data character and the Symbol Check Character" (GS1 Specification) */ the last data character and the Symbol Check Character" (GS1 Specification) */
@ -834,7 +846,7 @@ int ean_128(struct zint_symbol *symbol, unsigned char source[], int length)
} }
break; break;
} }
if(linkage_flag != 0) { if(linkage_flag != 0) {
concat(dest, C128Table[linkage_flag]); concat(dest, C128Table[linkage_flag]);
values[bar_characters] = linkage_flag; values[bar_characters] = linkage_flag;
@ -860,13 +872,13 @@ int ean_128(struct zint_symbol *symbol, unsigned char source[], int length)
concat(dest, C128Table[total_sum%103]); concat(dest, C128Table[total_sum%103]);
values[bar_characters] = total_sum % 103; values[bar_characters] = total_sum % 103;
bar_characters++; bar_characters++;
/* Stop character */ /* Stop character */
concat(dest, C128Table[106]); concat(dest, C128Table[106]);
values[bar_characters] = 106; values[bar_characters] = 106;
bar_characters++; bar_characters++;
expand(symbol, dest); expand(symbol, dest);
/* Add the separator pattern for composite symbols */ /* Add the separator pattern for composite symbols */
if(symbol->symbology == BARCODE_EAN128_CC) { if(symbol->symbology == BARCODE_EAN128_CC) {
for(i = 0; i < symbol->width; i++) { for(i = 0; i < symbol->width; i++) {
@ -887,7 +899,7 @@ int ean_128(struct zint_symbol *symbol, unsigned char source[], int length)
symbol->text[i] = ')'; symbol->text[i] = ')';
} }
} }
return error_number; return error_number;
} }
@ -896,15 +908,15 @@ int nve_18(struct zint_symbol *symbol, unsigned char source[], int length)
/* Add check digit if encoding an NVE18 symbol */ /* Add check digit if encoding an NVE18 symbol */
int error_number, zeroes, i, nve_check, total_sum, sourcelen; int error_number, zeroes, i, nve_check, total_sum, sourcelen;
unsigned char ean128_equiv[25]; unsigned char ean128_equiv[25];
memset(ean128_equiv, 0, 25); memset(ean128_equiv, 0, 25);
sourcelen = length; sourcelen = length;
if(sourcelen > 17) { if(sourcelen > 17) {
strcpy(symbol->errtxt, "Input too long"); strcpy(symbol->errtxt, "Input too long");
return ERROR_TOO_LONG; return ERROR_TOO_LONG;
} }
error_number = is_sane(NEON, source, length); error_number = is_sane(NEON, source, length);
if(error_number == ERROR_INVALID_DATA) { if(error_number == ERROR_INVALID_DATA) {
strcpy(symbol->errtxt, "Invalid characters in data"); strcpy(symbol->errtxt, "Invalid characters in data");
@ -914,12 +926,12 @@ int nve_18(struct zint_symbol *symbol, unsigned char source[], int length)
strcpy((char *)ean128_equiv, "[00]"); strcpy((char *)ean128_equiv, "[00]");
memset(ean128_equiv + 4, '0', zeroes); memset(ean128_equiv + 4, '0', zeroes);
strcpy((char*)ean128_equiv + 4 + zeroes, (char*)source); strcpy((char*)ean128_equiv + 4 + zeroes, (char*)source);
total_sum = 0; total_sum = 0;
for(i = sourcelen - 1; i >= 0; i--) for(i = sourcelen - 1; i >= 0; i--)
{ {
total_sum += ctoi(source[i]); total_sum += ctoi(source[i]);
if(!(i & 1)) { if(!(i & 1)) {
total_sum += 2 * ctoi(source[i]); total_sum += 2 * ctoi(source[i]);
} }
@ -930,7 +942,7 @@ int nve_18(struct zint_symbol *symbol, unsigned char source[], int length)
ean128_equiv[22] = '\0'; ean128_equiv[22] = '\0';
error_number = ean_128(symbol, ean128_equiv, ustrlen(ean128_equiv)); error_number = ean_128(symbol, ean128_equiv, ustrlen(ean128_equiv));
return error_number; return error_number;
} }
@ -940,23 +952,23 @@ int ean_14(struct zint_symbol *symbol, unsigned char source[], int length)
int i, count, check_digit; int i, count, check_digit;
int error_number, zeroes; int error_number, zeroes;
unsigned char ean128_equiv[20]; unsigned char ean128_equiv[20];
if(length > 13) { if(length > 13) {
strcpy(symbol->errtxt, "Input wrong length"); strcpy(symbol->errtxt, "Input wrong length");
return ERROR_TOO_LONG; return ERROR_TOO_LONG;
} }
error_number = is_sane(NEON, source, length); error_number = is_sane(NEON, source, length);
if(error_number == ERROR_INVALID_DATA) { if(error_number == ERROR_INVALID_DATA) {
strcpy(symbol->errtxt, "Invalid character in data"); strcpy(symbol->errtxt, "Invalid character in data");
return error_number; return error_number;
} }
zeroes = 13 - length; zeroes = 13 - length;
strcpy((char*)ean128_equiv, "[01]"); strcpy((char*)ean128_equiv, "[01]");
memset(ean128_equiv + 4, '0', zeroes); memset(ean128_equiv + 4, '0', zeroes);
ustrcpy(ean128_equiv + 4 + zeroes, source); ustrcpy(ean128_equiv + 4 + zeroes, source);
count = 0; count = 0;
for (i = length - 1; i >= 0; i--) { for (i = length - 1; i >= 0; i--) {
count += ctoi(source[i]); count += ctoi(source[i]);
@ -969,8 +981,8 @@ int ean_14(struct zint_symbol *symbol, unsigned char source[], int length)
if (check_digit == 10) { check_digit = 0; } if (check_digit == 10) { check_digit = 0; }
ean128_equiv[17] = itoc(check_digit); ean128_equiv[17] = itoc(check_digit);
ean128_equiv[18] = '\0'; ean128_equiv[18] = '\0';
error_number = ean_128(symbol, ean128_equiv, ustrlen(ean128_equiv)); error_number = ean_128(symbol, ean128_equiv, ustrlen(ean128_equiv));
return error_number; return error_number;
} }

64
backend/code16k.c
View File

@ -170,16 +170,16 @@ int code16k(struct zint_symbol *symbol, unsigned char source[], int length)
errornum = 0; errornum = 0;
strcpy(width_pattern, ""); strcpy(width_pattern, "");
input_length = length; input_length = length;
if(symbol->input_mode == GS1_MODE) { gs1 = 1; } else { gs1 = 0; } if(symbol->input_mode == GS1_MODE) { gs1 = 1; } else { gs1 = 0; }
if(input_length > 157) { if(input_length > 157) {
strcpy(symbol->errtxt, "Input too long"); strcpy(symbol->errtxt, "Input too long");
return ERROR_TOO_LONG; return ERROR_TOO_LONG;
} }
bar_characters = 0; bar_characters = 0;
/* Detect extended ASCII characters */ /* Detect extended ASCII characters */
for(i = 0; i < input_length; i++) { for(i = 0; i < input_length; i++) {
if(source[i] >=128) { if(source[i] >=128) {
@ -187,7 +187,7 @@ int code16k(struct zint_symbol *symbol, unsigned char source[], int length)
} }
} }
fset[i] = '\0'; fset[i] = '\0';
/* Decide when to latch to extended mode */ /* Decide when to latch to extended mode */
for(i = 0; i < input_length; i++) { for(i = 0; i < input_length; i++) {
j = 0; j = 0;
@ -202,7 +202,7 @@ int code16k(struct zint_symbol *symbol, unsigned char source[], int length)
} }
} }
} }
/* Decide if it is worth reverting to 646 encodation for a few characters */ /* Decide if it is worth reverting to 646 encodation for a few characters */
if(input_length > 1) { if(input_length > 1) {
for(i = 1; i < input_length; i++) { for(i = 1; i < input_length; i++) {
@ -221,14 +221,14 @@ int code16k(struct zint_symbol *symbol, unsigned char source[], int length)
/* Detect mode A, B and C characters */ /* Detect mode A, B and C characters */
indexliste = 0; indexliste = 0;
indexchaine = 0; indexchaine = 0;
mode = parunmodd(source[indexchaine]); mode = parunmodd(source[indexchaine]);
if((gs1) && (source[indexchaine] == '[')) { mode = ABORC; } /* FNC1 */ if((gs1) && (source[indexchaine] == '[')) { mode = ABORC; } /* FNC1 */
for(i = 0; i < 160; i++) { for(i = 0; i < 160; i++) {
list[0][i] = 0; list[0][i] = 0;
} }
do { do {
list[1][indexliste] = mode; list[1][indexliste] = mode;
while ((list[1][indexliste] == mode) && (indexchaine < input_length)) { while ((list[1][indexliste] == mode) && (indexchaine < input_length)) {
@ -239,9 +239,9 @@ int code16k(struct zint_symbol *symbol, unsigned char source[], int length)
} }
indexliste++; indexliste++;
} while (indexchaine < input_length); } while (indexchaine < input_length);
dxsmooth16(&indexliste); dxsmooth16(&indexliste);
/* Put set data into set[] */ /* Put set data into set[] */
read = 0; read = 0;
for(i = 0; i < indexliste; i++) { for(i = 0; i < indexliste; i++) {
@ -256,7 +256,7 @@ int code16k(struct zint_symbol *symbol, unsigned char source[], int length)
read++; read++;
} }
} }
/* Adjust for strings which start with shift characters - make them latch instead */ /* Adjust for strings which start with shift characters - make them latch instead */
if(set[0] == 'a') { if(set[0] == 'a') {
i = 0; i = 0;
@ -265,7 +265,7 @@ int code16k(struct zint_symbol *symbol, unsigned char source[], int length)
i++; i++;
} while (set[i] == 'a'); } while (set[i] == 'a');
} }
if(set[0] == 'b') { if(set[0] == 'b') {
i = 0; i = 0;
do { do {
@ -273,7 +273,7 @@ int code16k(struct zint_symbol *symbol, unsigned char source[], int length)
i++; i++;
} while (set[i] == 'b'); } while (set[i] == 'b');
} }
/* Watch out for odd-length Mode C blocks */ /* Watch out for odd-length Mode C blocks */
c_count = 0; c_count = 0;
for(i = 0; i < read; i++) { for(i = 0; i < read; i++) {
@ -313,7 +313,7 @@ int code16k(struct zint_symbol *symbol, unsigned char source[], int length)
set[i] = 'B'; set[i] = 'B';
} }
} }
/* Make sure the data will fit in the symbol */ /* Make sure the data will fit in the symbol */
last_set = ' '; last_set = ' ';
glyph_count = 0.0; glyph_count = 0.0;
@ -350,34 +350,34 @@ int code16k(struct zint_symbol *symbol, unsigned char source[], int length)
glyph_count = glyph_count + 2.0; glyph_count = glyph_count + 2.0;
} }
} }
if((set[i] == 'C') && (!((gs1) && (source[i] == '[')))) { if((set[i] == 'C') && (!((gs1) && (source[i] == '[')))) {
glyph_count = glyph_count + 0.5; glyph_count = glyph_count + 0.5;
} else { } else {
glyph_count = glyph_count + 1.0; glyph_count = glyph_count + 1.0;
} }
} }
if((gs1) && (set[0] != 'A')) { if((gs1) && (set[0] != 'A')) {
/* FNC1 can be integrated with mode character */ /* FNC1 can be integrated with mode character */
glyph_count--; glyph_count--;
} }
if(glyph_count > 77.0) { if(glyph_count > 77.0) {
strcpy(symbol->errtxt, "Input too long"); strcpy(symbol->errtxt, "Input too long");
return ERROR_TOO_LONG; return ERROR_TOO_LONG;
} }
/* Calculate how tall the symbol will be */ /* Calculate how tall the symbol will be */
glyph_count = glyph_count + 2.0; glyph_count = glyph_count + 2.0;
i = glyph_count; i = glyph_count;
rows_needed = (i/5); rows_needed = (i/5);
if(i%5 > 0) { rows_needed++; } if(i%5 > 0) { rows_needed++; }
if(rows_needed == 1) { if(rows_needed == 1) {
rows_needed = 2; rows_needed = 2;
} }
/* start with the mode character - Table 2 */ /* start with the mode character - Table 2 */
m = 0; m = 0;
switch(set[0]) { switch(set[0]) {
@ -385,7 +385,7 @@ int code16k(struct zint_symbol *symbol, unsigned char source[], int length)
case 'B': m = 1; break; case 'B': m = 1; break;
case 'C': m = 2; break; case 'C': m = 2; break;
} }
if(symbol->output_options & READER_INIT) { if(symbol->output_options & READER_INIT) {
if(m == 2) { m = 5; } if(m == 2) { m = 5; }
if(gs1) { if(gs1) {
@ -429,9 +429,9 @@ int code16k(struct zint_symbol *symbol, unsigned char source[], int length)
bar_characters += 2; bar_characters += 2;
f_state = 1; f_state = 1;
} }
read = 0; read = 0;
/* Encode the data */ /* Encode the data */
do { do {
@ -494,7 +494,7 @@ int code16k(struct zint_symbol *symbol, unsigned char source[], int length)
f_state = 0; f_state = 0;
} }
} }
if((fset[i] == 'f') || (fset[i] == 'n')) { if((fset[i] == 'f') || (fset[i] == 'n')) {
/* Shift extended mode */ /* Shift extended mode */
switch(current_set) { switch(current_set) {
@ -507,13 +507,13 @@ int code16k(struct zint_symbol *symbol, unsigned char source[], int length)
} }
bar_characters++; bar_characters++;
} }
if((set[i] == 'a') || (set[i] == 'b')) { if((set[i] == 'a') || (set[i] == 'b')) {
/* Insert shift character */ /* Insert shift character */
values[bar_characters] = 98; values[bar_characters] = 98;
bar_characters++; bar_characters++;
} }
if(!((gs1) && (source[read] == '['))) { if(!((gs1) && (source[read] == '['))) {
switch(set[read]) switch(set[read])
{ /* Encode data characters */ { /* Encode data characters */
@ -538,7 +538,7 @@ int code16k(struct zint_symbol *symbol, unsigned char source[], int length)
} }
/* printf("tp9 read=%d surrent set=%c\n", read, set[read]); */ /* printf("tp9 read=%d surrent set=%c\n", read, set[read]); */
} while (read < ustrlen(source)); } while (read < ustrlen(source));
pads_needed = 5 - ((bar_characters + 2) % 5); pads_needed = 5 - ((bar_characters + 2) % 5);
if(pads_needed == 5) { if(pads_needed == 5) {
pads_needed = 0; pads_needed = 0;
@ -550,7 +550,7 @@ int code16k(struct zint_symbol *symbol, unsigned char source[], int length)
values[bar_characters] = 106; values[bar_characters] = 106;
bar_characters++; bar_characters++;
} }
/* Calculate check digits */ /* Calculate check digits */
first_sum = 0; first_sum = 0;
second_sum = 0; second_sum = 0;
@ -565,16 +565,16 @@ int code16k(struct zint_symbol *symbol, unsigned char source[], int length)
values[bar_characters] = first_check; values[bar_characters] = first_check;
values[bar_characters + 1] = second_check; values[bar_characters + 1] = second_check;
bar_characters += 2; bar_characters += 2;
for(current_row = 0; current_row < rows_needed; current_row++) { for(current_row = 0; current_row < rows_needed; current_row++) {
strcpy(width_pattern, ""); strcpy(width_pattern, "");
concat(width_pattern, C16KStartStop[C16KStartValues[current_row]]); concat(width_pattern, C16KStartStop[C16KStartValues[current_row]]);
concat(width_pattern, "1"); concat(width_pattern, "1");
for(i = 0; i < 5; i++) { for(i = 0; i < 5; i++) {
concat(width_pattern, C16KTable[values[(current_row * 5) + i]]); concat(width_pattern, C16KTable[values[(current_row * 5) + i]]);
/* printf("[%d] ", values[(current_row * 5) + i]); */ /* printf("[%d] ", values[(current_row * 5) + i]); */
} }
concat(width_pattern, C16KStartStop[C16KStopValues[current_row]]); concat(width_pattern, C16KStartStop[C16KStopValues[current_row]]);
/* printf("\n"); */ /* printf("\n"); */
@ -594,7 +594,7 @@ int code16k(struct zint_symbol *symbol, unsigned char source[], int length)
} }
symbol->row_height[current_row] = 10; symbol->row_height[current_row] = 10;
} }
symbol->rows = rows_needed; symbol->rows = rows_needed;
symbol->width = 70; symbol->width = 70;
return errornum; return errornum;

58
backend/code49.c
View File

@ -69,13 +69,13 @@ int code_49(struct zint_symbol *symbol, unsigned char source[], int length)
int block_count, c; int block_count, c;
int block_remain; int block_remain;
int block_value; int block_value;
codewords[codeword_count] = 48; /* Numeric Shift */ codewords[codeword_count] = 48; /* Numeric Shift */
codeword_count++; codeword_count++;
block_count = j / 5; block_count = j / 5;
block_remain = j % 5; block_remain = j % 5;
for(c = 0; c < block_count; c++) { for(c = 0; c < block_count; c++) {
if((c == block_count - 1) && (block_remain == 2)) { if((c == block_count - 1) && (block_remain == 2)) {
/* Rule (d) */ /* Rule (d) */
@ -84,7 +84,7 @@ int code_49(struct zint_symbol *symbol, unsigned char source[], int length)
block_value += ctoi(intermediate[i + 1]) * 100; block_value += ctoi(intermediate[i + 1]) * 100;
block_value += ctoi(intermediate[i + 2]) * 10; block_value += ctoi(intermediate[i + 2]) * 10;
block_value += ctoi(intermediate[i + 3]); block_value += ctoi(intermediate[i + 3]);
codewords[codeword_count] = block_value / (48 * 48); codewords[codeword_count] = block_value / (48 * 48);
block_value = block_value - (48 * 48) * codewords[codeword_count]; block_value = block_value - (48 * 48) * codewords[codeword_count];
codeword_count++; codeword_count++;
@ -97,20 +97,20 @@ int code_49(struct zint_symbol *symbol, unsigned char source[], int length)
block_value = ctoi(intermediate[i]) * 100; block_value = ctoi(intermediate[i]) * 100;
block_value += ctoi(intermediate[i + 1]) * 10; block_value += ctoi(intermediate[i + 1]) * 10;
block_value += ctoi(intermediate[i + 2]); block_value += ctoi(intermediate[i + 2]);
codewords[codeword_count] = block_value / 48; codewords[codeword_count] = block_value / 48;
block_value = block_value - 48 * codewords[codeword_count]; block_value = block_value - 48 * codewords[codeword_count];
codeword_count++; codeword_count++;
codewords[codeword_count] = block_value; codewords[codeword_count] = block_value;
codeword_count++; codeword_count++;
i += 3; i += 3;
} else { } else {
block_value = ctoi(intermediate[i]) * 10000; block_value = ctoi(intermediate[i]) * 10000;
block_value += ctoi(intermediate[i + 1]) * 1000; block_value += ctoi(intermediate[i + 1]) * 1000;
block_value += ctoi(intermediate[i + 2]) * 100; block_value += ctoi(intermediate[i + 2]) * 100;
block_value += ctoi(intermediate[i + 3]) * 10; block_value += ctoi(intermediate[i + 3]) * 10;
block_value += ctoi(intermediate[i + 4]); block_value += ctoi(intermediate[i + 4]);
codewords[codeword_count] = block_value / (48 * 48); codewords[codeword_count] = block_value / (48 * 48);
block_value = block_value - (48 * 48) * codewords[codeword_count]; block_value = block_value - (48 * 48) * codewords[codeword_count];
codeword_count++; codeword_count++;
@ -122,7 +122,7 @@ int code_49(struct zint_symbol *symbol, unsigned char source[], int length)
i += 5; i += 5;
} }
} }
switch(block_remain) { switch(block_remain) {
case 1: case 1:
/* Rule (a) */ /* Rule (a) */
@ -135,7 +135,7 @@ int code_49(struct zint_symbol *symbol, unsigned char source[], int length)
block_value = ctoi(intermediate[i]) * 100; block_value = ctoi(intermediate[i]) * 100;
block_value += ctoi(intermediate[i + 1]) * 10; block_value += ctoi(intermediate[i + 1]) * 10;
block_value += ctoi(intermediate[i + 2]); block_value += ctoi(intermediate[i + 2]);
codewords[codeword_count] = block_value / 48; codewords[codeword_count] = block_value / 48;
block_value = block_value - 48 * codewords[codeword_count]; block_value = block_value - 48 * codewords[codeword_count];
codeword_count++; codeword_count++;
@ -150,7 +150,7 @@ int code_49(struct zint_symbol *symbol, unsigned char source[], int length)
block_value += ctoi(intermediate[i + 1]) * 100; block_value += ctoi(intermediate[i + 1]) * 100;
block_value += ctoi(intermediate[i + 2]) * 10; block_value += ctoi(intermediate[i + 2]) * 10;
block_value += ctoi(intermediate[i + 3]); block_value += ctoi(intermediate[i + 3]);
codewords[codeword_count] = block_value / (48 * 48); codewords[codeword_count] = block_value / (48 * 48);
block_value = block_value - (48 * 48) * codewords[codeword_count]; block_value = block_value - (48 * 48) * codewords[codeword_count];
codeword_count++; codeword_count++;
@ -178,26 +178,26 @@ int code_49(struct zint_symbol *symbol, unsigned char source[], int length)
i++; i++;
} }
} while(i < h); } while(i < h);
switch(codewords[0]) { /* Set starting mode value */ switch(codewords[0]) { /* Set starting mode value */
case 48: M = 2; break; case 48: M = 2; break;
case 43: M = 4; break; case 43: M = 4; break;
case 44: M = 5; break; case 44: M = 5; break;
default: M = 0; break; default: M = 0; break;
} }
if(M != 0) { if(M != 0) {
for(i = 0; i < codeword_count; i++) { for(i = 0; i < codeword_count; i++) {
codewords[i] = codewords[i + 1]; codewords[i] = codewords[i + 1];
} }
codeword_count--; codeword_count--;
} }
if(codeword_count > 49) { if(codeword_count > 49) {
strcpy(symbol->errtxt, "Input too long"); strcpy(symbol->errtxt, "Input too long");
return ERROR_TOO_LONG; return ERROR_TOO_LONG;
} }
/* Place codewords in code character array (c grid) */ /* Place codewords in code character array (c grid) */
rows = 0; rows = 0;
do{ do{
@ -211,7 +211,7 @@ int code_49(struct zint_symbol *symbol, unsigned char source[], int length)
} }
rows++; rows++;
} while ((rows * 7) < codeword_count); } while ((rows * 7) < codeword_count);
if((((rows <= 6) && (pad_count < 5))) || (rows > 6) || (rows == 1)) { if((((rows <= 6) && (pad_count < 5))) || (rows > 6) || (rows == 1)) {
/* Add a row */ /* Add a row */
for(i = 0; i < 7; i++) { for(i = 0; i < 7; i++) {
@ -219,20 +219,20 @@ int code_49(struct zint_symbol *symbol, unsigned char source[], int length)
} }
rows++; rows++;
} }
/* Add row count and mode character */ /* Add row count and mode character */
c_grid[rows - 1][6] = (7 * (rows - 2)) + M; c_grid[rows - 1][6] = (7 * (rows - 2)) + M;
/* Add row check character */ /* Add row check character */
for(i = 0; i < rows - 1; i++) { for(i = 0; i < rows - 1; i++) {
int row_sum = 0; int row_sum = 0;
for(j = 0; j < 7; j++) { for(j = 0; j < 7; j++) {
row_sum += c_grid[i][j]; row_sum += c_grid[i][j];
} }
c_grid[i][7] = row_sum % 49; c_grid[i][7] = row_sum % 49;
} }
/* Calculate Symbol Check Characters */ /* Calculate Symbol Check Characters */
posn_val = 0; posn_val = 0;
x_count = c_grid[rows - 1][6] * 20; x_count = c_grid[rows - 1][6] * 20;
@ -247,43 +247,43 @@ int code_49(struct zint_symbol *symbol, unsigned char source[], int length)
posn_val++; posn_val++;
} }
} }
if(rows > 6) { if(rows > 6) {
/* Add Z Symbol Check */ /* Add Z Symbol Check */
c_grid[rows - 1][0] = (z_count % 2401) / 49; c_grid[rows - 1][0] = (z_count % 2401) / 49;
c_grid[rows - 1][1] = (z_count % 2401) % 49; c_grid[rows - 1][1] = (z_count % 2401) % 49;
} }
local_value = (c_grid[rows - 1][0] * 49) + c_grid[rows - 1][1]; local_value = (c_grid[rows - 1][0] * 49) + c_grid[rows - 1][1];
x_count += c49_x_weight[posn_val] * local_value; x_count += c49_x_weight[posn_val] * local_value;
y_count += c49_y_weight[posn_val] * local_value; y_count += c49_y_weight[posn_val] * local_value;
posn_val++; posn_val++;
/* Add Y Symbol Check */ /* Add Y Symbol Check */
c_grid[rows - 1][2] = (y_count % 2401) / 49; c_grid[rows - 1][2] = (y_count % 2401) / 49;
c_grid[rows - 1][3] = (y_count % 2401) % 49; c_grid[rows - 1][3] = (y_count % 2401) % 49;
local_value = (c_grid[rows - 1][2] * 49) + c_grid[rows - 1][3]; local_value = (c_grid[rows - 1][2] * 49) + c_grid[rows - 1][3];
x_count += c49_x_weight[posn_val] * local_value; x_count += c49_x_weight[posn_val] * local_value;
/* Add X Symbol Check */ /* Add X Symbol Check */
c_grid[rows - 1][4] = (x_count % 2401) / 49; c_grid[rows - 1][4] = (x_count % 2401) / 49;
c_grid[rows - 1][5] = (x_count % 2401) % 49; c_grid[rows - 1][5] = (x_count % 2401) % 49;
/* Add last row check character */ /* Add last row check character */
j = 0; j = 0;
for(i = 0; i < 7; i++) { for(i = 0; i < 7; i++) {
j += c_grid[rows - 1][i]; j += c_grid[rows - 1][i];
} }
c_grid[rows - 1][7] = j % 49; c_grid[rows - 1][7] = j % 49;
/* Transfer data to symbol character array (w grid) */ /* Transfer data to symbol character array (w grid) */
for(i = 0; i < rows; i++) { for(i = 0; i < rows; i++) {
for(j = 0; j < 4; j ++) { for(j = 0; j < 4; j ++) {
w_grid[i][j] = (c_grid[i][2 * j] * 49) + c_grid[i][(2 * j) + 1]; w_grid[i][j] = (c_grid[i][2 * j] * 49) + c_grid[i][(2 * j) + 1];
} }
} }
for(i = 0; i < rows; i++) { for(i = 0; i < rows; i++) {
strcpy(pattern, "11"); /* Start character */ strcpy(pattern, "11"); /* Start character */
for(j = 0; j < 4; j++) { for(j = 0; j < 4; j++) {
@ -301,12 +301,12 @@ int code_49(struct zint_symbol *symbol, unsigned char source[], int length)
} }
} }
concat(pattern, "4"); /* Stop character */ concat(pattern, "4"); /* Stop character */
/* Expand into symbol */ /* Expand into symbol */
symbol->row_height[i] = 10; symbol->row_height[i] = 10;
expand(symbol, pattern); expand(symbol, pattern);
} }
symbol->whitespace_width = 10; symbol->whitespace_width = 10;
symbol->output_options = BARCODE_BIND; symbol->output_options = BARCODE_BIND;
symbol->border_width = 2; symbol->border_width = 2;

14
backend/code49.h
View File

@ -21,7 +21,7 @@
/* This data set taken from ANSI/AIM-BC6-2000, 4th April 2000 */ /* This data set taken from ANSI/AIM-BC6-2000, 4th April 2000 */
static char *c49_table7[128] = { static const char *c49_table7[128] = {
/* Table 7: Code 49 ASCII Chart */ /* Table 7: Code 49 ASCII Chart */
"! ", "!A", "!B", "!C", "!D", "!E", "!F", "!G", "!H", "!I", "!J", "!K", "!L", "! ", "!A", "!B", "!C", "!D", "!E", "!F", "!G", "!H", "!I", "!J", "!K", "!L",
"!M", "!N", "!O", "!P", "!Q", "!R", "!S", "!T", "!U", "!V", "!W", "!X", "!Y", "!M", "!N", "!O", "!P", "!Q", "!R", "!S", "!T", "!U", "!V", "!W", "!X", "!Y",
@ -36,27 +36,27 @@ static char *c49_table7[128] = {
}; };
/* Table 5: Check Character Weighting Values */ /* Table 5: Check Character Weighting Values */
int c49_x_weight[] = { static const int c49_x_weight[] = {
1, 9, 31, 26, 2, 12, 17, 23, 37, 18, 22, 6, 27, 44, 15, 43, 1, 9, 31, 26, 2, 12, 17, 23, 37, 18, 22, 6, 27, 44, 15, 43,
39, 11, 13, 5, 41, 33, 36, 8, 4, 32, 3, 19, 40, 25, 29, 10 39, 11, 13, 5, 41, 33, 36, 8, 4, 32, 3, 19, 40, 25, 29, 10
}; };
int c49_y_weight[] = { static const int c49_y_weight[] = {
9, 31, 26, 2, 12, 17, 23, 37, 18, 22, 6, 27, 44, 15, 43, 39, 9, 31, 26, 2, 12, 17, 23, 37, 18, 22, 6, 27, 44, 15, 43, 39,
11, 13, 5, 41, 33, 36, 8, 4, 32, 3, 19, 40, 25, 29, 10, 24 11, 13, 5, 41, 33, 36, 8, 4, 32, 3, 19, 40, 25, 29, 10, 24
}; };
int c49_z_weight[] = { static const int c49_z_weight[] = {
31, 26, 2, 12, 17, 23, 37, 18, 22, 6, 27, 44, 15, 43, 39, 11, 31, 26, 2, 12, 17, 23, 37, 18, 22, 6, 27, 44, 15, 43, 39, 11,
13, 5, 41, 33, 36, 8, 4, 32, 3, 19, 40, 25, 29, 10, 24, 30 13, 5, 41, 33, 36, 8, 4, 32, 3, 19, 40, 25, 29, 10, 24, 30
}; };
static char *c49_table4[8] = { static const char *c49_table4[8] = {
/* Table 4: Row Parity Pattern for Code 49 Symbols */ /* Table 4: Row Parity Pattern for Code 49 Symbols */
"OEEO", "EOEO", "OOEE", "EEOO", "OEOE", "EOOE", "OOOO", "EEEE" "OEEO", "EOEO", "OOEE", "EEOO", "OEOE", "EOOE", "OOOO", "EEEE"
}; };
static char *c49_appxe_even[2401] = { static const char *c49_appxe_even[2401] = {
/* Appendix E - Code 49 Encodation Patterns (Even Symbol Character Parity) */ /* Appendix E - Code 49 Encodation Patterns (Even Symbol Character Parity) */
/* Column 1 */ /* Column 1 */
"11521132", "11521132",
@ -615,7 +615,7 @@ static char *c49_appxe_even[2401] = {
"31412311", "15121132", "24221131", "13321132", "22421131" "31412311", "15121132", "24221131", "13321132", "22421131"
}; };
static char *c49_appxe_odd[2401] = { static const char *c49_appxe_odd[2401] = {
/* Appendix E - Code 49 Encodation Patterns (Odd Symbol Character Parity) */ /* Appendix E - Code 49 Encodation Patterns (Odd Symbol Character Parity) */
/* Column 1 */ /* Column 1 */
"22121116", "22121116",

44
backend/common.c
View File

@ -23,7 +23,7 @@
#include <stdlib.h> #include <stdlib.h>
#include "common.h" #include "common.h"
int ustrlen(unsigned char data[]) { int ustrlen(const unsigned char data[]) {
/* Local replacement for strlen() with unsigned char strings */ /* Local replacement for strlen() with unsigned char strings */
int i; int i;
for (i=0;data[i];i++); for (i=0;data[i];i++);
@ -31,7 +31,7 @@ int ustrlen(unsigned char data[]) {
return i; return i;
} }
void ustrcpy(unsigned char target[], unsigned char source[]) { void ustrcpy(unsigned char target[],const unsigned char source[]) {
/* Local replacement for strcpy() with unsigned char strings */ /* Local replacement for strcpy() with unsigned char strings */
int i, len; int i, len;
@ -52,7 +52,7 @@ void concat(char dest[],const char source[])
dest[i + j] = source[i]; } dest[i + j] = source[i]; }
} }
void uconcat(unsigned char dest[], unsigned char source[]) void uconcat(unsigned char dest[], const unsigned char source[])
{ /* Concatinates dest[] with the contents of source[], copying /0 as well */ { /* Concatinates dest[] with the contents of source[], copying /0 as well */
unsigned int i, j; unsigned int i, j;
@ -104,7 +104,7 @@ int is_sane(char test_string[], unsigned char source[], int length)
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
} }
} }
return 0; return 0;
} }
@ -188,14 +188,14 @@ void unset_module(struct zint_symbol *symbol, int y_coord, int x_coord)
void expand(struct zint_symbol *symbol, char data[]) void expand(struct zint_symbol *symbol, char data[])
{ /* Expands from a width pattern to a bit pattern */ { /* Expands from a width pattern to a bit pattern */
unsigned int reader, n = strlen(data); unsigned int reader, n = strlen(data);
int writer, i; int writer, i;
char latch; char latch;
writer = 0; writer = 0;
latch = '1'; latch = '1';
for(reader = 0; reader < n; reader++) { for(reader = 0; reader < n; reader++) {
for(i = 0; i < ctoi(data[reader]); i++) { for(i = 0; i < ctoi(data[reader]); i++) {
if(latch == '1') { set_module(symbol, symbol->rows, writer); } if(latch == '1') { set_module(symbol, symbol->rows, writer); }
@ -204,7 +204,7 @@ void expand(struct zint_symbol *symbol, char data[])
latch = (latch == '1' ? '0' : '1'); latch = (latch == '1' ? '0' : '1');
} }
if(symbol->symbology != BARCODE_PHARMA) { if(symbol->symbology != BARCODE_PHARMA) {
if(writer > symbol->width) { if(writer > symbol->width) {
symbol->width = writer; symbol->width = writer;
@ -230,7 +230,7 @@ int is_stackable(int symbology) {
if(symbology == BARCODE_TELEPEN_NUM) { return 1; } if(symbology == BARCODE_TELEPEN_NUM) { return 1; }
if(symbology == BARCODE_ITF14) { return 1; } if(symbology == BARCODE_ITF14) { return 1; }
if(symbology == BARCODE_CODE32) { return 1; } if(symbology == BARCODE_CODE32) { return 1; }
return 0; return 0;
} }
@ -243,7 +243,7 @@ int is_extendable(int symbology) {
if(symbology == BARCODE_UPCA_CC) { return 1; } if(symbology == BARCODE_UPCA_CC) { return 1; }
if(symbology == BARCODE_UPCE_CC) { return 1; } if(symbology == BARCODE_UPCE_CC) { return 1; }
if(symbology == BARCODE_EANX_CC) { return 1; } if(symbology == BARCODE_EANX_CC) { return 1; }
return 0; return 0;
} }
@ -251,14 +251,14 @@ int roundup(float input)
{ {
float remainder; float remainder;
int integer_part; int integer_part;
integer_part = (int)input; integer_part = (int)input;
remainder = input - integer_part; remainder = input - integer_part;
if(remainder > 0.1) { if(remainder > 0.1) {
integer_part++; integer_part++;
} }
return integer_part; return integer_part;
} }
@ -269,17 +269,17 @@ int istwodigits(unsigned char source[], int position)
return 1; return 1;
} }
} }
return 0; return 0;
} }
float froundup(float input) float froundup(float input)
{ {
float fraction, output = 0.0; float fraction, output = 0.0;
fraction = input - (int)input; fraction = input - (int)input;
if(fraction > 0.01) { output = (input - fraction) + 1.0; } else { output = input; } if(fraction > 0.01) { output = (input - fraction) + 1.0; } else { output = input; }
return output; return output;
} }
@ -316,7 +316,7 @@ int latin1_process(struct zint_symbol *symbol, unsigned char source[], unsigned
} while(i < *length); } while(i < *length);
preprocessed[j] = '\0'; preprocessed[j] = '\0';
*length = j; *length = j;
return 0; return 0;
} }
@ -324,12 +324,12 @@ int utf8toutf16(struct zint_symbol *symbol, unsigned char source[], int vals[],
{ {
int bpos, jpos, error_number; int bpos, jpos, error_number;
int next; int next;
bpos = 0; bpos = 0;
jpos = 0; jpos = 0;
error_number = 0; error_number = 0;
next = 0; next = 0;
do { do {
if(source[bpos] <= 0x7f) { if(source[bpos] <= 0x7f) {
/* 1 byte mode (7-bit ASCII) */ /* 1 byte mode (7-bit ASCII) */
@ -363,12 +363,12 @@ int utf8toutf16(struct zint_symbol *symbol, unsigned char source[], int vals[],
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
} }
} }
bpos = next; bpos = next;
} while(bpos < *length); } while(bpos < *length);
*length = jpos; *length = jpos;
return error_number; return error_number;
} }

8
backend/common.h
View File

@ -27,10 +27,10 @@ extern "C"
{ {
#endif /* __cplusplus */ #endif /* __cplusplus */
extern int ustrlen(unsigned char source[]); extern int ustrlen(const unsigned char source[]);
extern void ustrcpy(unsigned char target[], unsigned char source[]); extern void ustrcpy(unsigned char target[], const unsigned char source[]);
extern void concat(char dest[],const char source[]); extern void concat(char dest[], const char source[]);
extern void uconcat(unsigned char dest[], unsigned char source[]); extern void uconcat(unsigned char dest[], const unsigned char source[]);
extern int ctoi(char source); extern int ctoi(char source);
extern char itoc(int source); extern char itoc(int source);
extern void to_upper(unsigned char source[]); extern void to_upper(unsigned char source[]);

386
backend/composite.c
View File

File diff suppressed because it is too large Load Diff

178
backend/dmatrix.c
View File

@ -201,14 +201,14 @@ int isx12(unsigned char source)
if(source == 32) { return 1; } if(source == 32) { return 1; }
if((source >= '0') && (source <= '9')) { return 1; } if((source >= '0') && (source <= '9')) { return 1; }
if((source >= 'A') && (source <= 'Z')) { return 1; } if((source >= 'A') && (source <= 'Z')) { return 1; }
return 0; return 0;
} }
void dminsert(char binary_string[], int posn, char newbit) void dminsert(char binary_string[], int posn, char newbit)
{ /* Insert a character into the middle of a string at position posn */ { /* Insert a character into the middle of a string at position posn */
int i, end; int i, end;
end = strlen(binary_string); end = strlen(binary_string);
for(i = end; i > posn; i--) { for(i = end; i > posn; i--) {
binary_string[i] = binary_string[i - 1]; binary_string[i] = binary_string[i - 1];
@ -219,7 +219,7 @@ void dminsert(char binary_string[], int posn, char newbit)
void insert_value(unsigned char binary_stream[], int posn, int streamlen, char newbit) void insert_value(unsigned char binary_stream[], int posn, int streamlen, char newbit)
{ {
int i; int i;
for(i = streamlen; i > posn; i--) { for(i = streamlen; i > posn; i--) {
binary_stream[i] = binary_stream[i - 1]; binary_stream[i] = binary_stream[i - 1];
} }
@ -230,11 +230,11 @@ int look_ahead_test(unsigned char source[], int sourcelen, int position, int cur
{ {
/* A custom version of the 'look ahead test' from Annex P */ /* A custom version of the 'look ahead test' from Annex P */
/* This version is deliberately very reluctant to end a data stream with EDIFACT encoding */ /* This version is deliberately very reluctant to end a data stream with EDIFACT encoding */
float ascii_count, c40_count, text_count, x12_count, edf_count, b256_count, best_count; float ascii_count, c40_count, text_count, x12_count, edf_count, b256_count, best_count;
int sp, done, best_scheme; int sp, done, best_scheme;
char reduced_char; char reduced_char;
/* step (j) */ /* step (j) */
if(current_mode == DM_ASCII) { if(current_mode == DM_ASCII) {
ascii_count = 0.0; ascii_count = 0.0;
@ -251,7 +251,7 @@ int look_ahead_test(unsigned char source[], int sourcelen, int position, int cur
edf_count = 2.0; edf_count = 2.0;
b256_count = 2.25; b256_count = 2.25;
} }
switch(current_mode) { switch(current_mode) {
case DM_C40: c40_count = 0.0; break; case DM_C40: c40_count = 0.0; break;
case DM_TEXT: text_count = 0.0; break; case DM_TEXT: text_count = 0.0; break;
@ -259,71 +259,71 @@ int look_ahead_test(unsigned char source[], int sourcelen, int position, int cur
case DM_EDIFACT: edf_count = 0.0; break; case DM_EDIFACT: edf_count = 0.0; break;
case DM_BASE256: b256_count = 0.0; break; case DM_BASE256: b256_count = 0.0; break;
} }
for(sp = position; (sp < sourcelen) && (sp <= (position + 8)); sp++) { for(sp = position; (sp < sourcelen) && (sp <= (position + 8)); sp++) {
if(source[sp] <= 127) { reduced_char = source[sp]; } else { reduced_char = source[sp] - 127; } if(source[sp] <= 127) { reduced_char = source[sp]; } else { reduced_char = source[sp] - 127; }
if((source[sp] >= '0') && (source[sp] <= '9')) { ascii_count += 0.5; } else { ascii_count += 1.0; } if((source[sp] >= '0') && (source[sp] <= '9')) { ascii_count += 0.5; } else { ascii_count += 1.0; }
if(source[sp] > 127) { ascii_count += 1.0; } if(source[sp] > 127) { ascii_count += 1.0; }
done = 0; done = 0;
if(reduced_char == ' ') { c40_count += (2.0 / 3.0); done = 1; } if(reduced_char == ' ') { c40_count += (2.0 / 3.0); done = 1; }
if((reduced_char >= '0') && (reduced_char <= '9')) { c40_count += (2.0 / 3.0); done = 1; } if((reduced_char >= '0') && (reduced_char <= '9')) { c40_count += (2.0 / 3.0); done = 1; }
if((reduced_char >= 'A') && (reduced_char <= 'Z')) { c40_count += (2.0 / 3.0); done = 1; } if((reduced_char >= 'A') && (reduced_char <= 'Z')) { c40_count += (2.0 / 3.0); done = 1; }
if(source[sp] > 127) { c40_count += (4.0 / 3.0); } if(source[sp] > 127) { c40_count += (4.0 / 3.0); }
if(done == 0) { c40_count += (4.0 / 3.0); } if(done == 0) { c40_count += (4.0 / 3.0); }
done = 0; done = 0;
if(reduced_char == ' ') { text_count += (2.0 / 3.0); done = 1; } if(reduced_char == ' ') { text_count += (2.0 / 3.0); done = 1; }
if((reduced_char >= '0') && (reduced_char <= '9')) { text_count += (2.0 / 3.0); done = 1; } if((reduced_char >= '0') && (reduced_char <= '9')) { text_count += (2.0 / 3.0); done = 1; }
if((reduced_char >= 'a') && (reduced_char <= 'z')) { text_count += (2.0 / 3.0); done = 1; } if((reduced_char >= 'a') && (reduced_char <= 'z')) { text_count += (2.0 / 3.0); done = 1; }
if(source[sp] > 127) { text_count += (4.0 / 3.0); } if(source[sp] > 127) { text_count += (4.0 / 3.0); }
if(done == 0) { text_count += (4.0 / 3.0); } if(done == 0) { text_count += (4.0 / 3.0); }
if(isx12(source[sp])) { x12_count += (2.0 / 3.0); } else { x12_count += 4.0; } if(isx12(source[sp])) { x12_count += (2.0 / 3.0); } else { x12_count += 4.0; }
/* step (p) */ /* step (p) */
done = 0; done = 0;
if((source[sp] >= ' ') && (source[sp] <= '^')) { edf_count += (3.0 / 4.0); } else { edf_count += 6.0; } if((source[sp] >= ' ') && (source[sp] <= '^')) { edf_count += (3.0 / 4.0); } else { edf_count += 6.0; }
if(gs1 && (source[sp] == '[')) { edf_count += 6.0; } if(gs1 && (source[sp] == '[')) { edf_count += 6.0; }
if(sp >= (sourcelen - 5)) { edf_count += 6.0; } /* MMmmm fudge! */ if(sp >= (sourcelen - 5)) { edf_count += 6.0; } /* MMmmm fudge! */
/* step (q) */ /* step (q) */
if(gs1 && (source[sp] == '[')) { b256_count += 4.0; } else { b256_count += 1.0; } if(gs1 && (source[sp] == '[')) { b256_count += 4.0; } else { b256_count += 1.0; }
/* printf("%c lat a%.2f c%.2f t%.2f x%.2f e%.2f b%.2f\n", source[sp], ascii_count, c40_count, text_count, x12_count, edf_count, b256_count); */ /* printf("%c lat a%.2f c%.2f t%.2f x%.2f e%.2f b%.2f\n", source[sp], ascii_count, c40_count, text_count, x12_count, edf_count, b256_count); */
} }
best_count = ascii_count; best_count = ascii_count;
best_scheme = DM_ASCII; best_scheme = DM_ASCII;
if(b256_count <= best_count) { if(b256_count <= best_count) {
best_count = b256_count; best_count = b256_count;
best_scheme = DM_BASE256; best_scheme = DM_BASE256;
} }
if(edf_count <= best_count) { if(edf_count <= best_count) {
best_count = edf_count; best_count = edf_count;
best_scheme = DM_EDIFACT; best_scheme = DM_EDIFACT;
} }
if(text_count <= best_count) { if(text_count <= best_count) {
best_count = text_count; best_count = text_count;
best_scheme = DM_TEXT; best_scheme = DM_TEXT;
} }
if(x12_count <= best_count) { if(x12_count <= best_count) {
best_count = x12_count; best_count = x12_count;
best_scheme = DM_X12; best_scheme = DM_X12;
} }
if(c40_count <= best_count) { if(c40_count <= best_count) {
best_count = c40_count; best_count = c40_count;
best_scheme = DM_C40; best_scheme = DM_C40;
} }
return best_scheme; return best_scheme;
} }
@ -331,7 +331,7 @@ int dm200encode(struct zint_symbol *symbol, unsigned char source[], unsigned cha
{ {
/* Encodes data using ASCII, C40, Text, X12, EDIFACT or Base 256 modes as appropriate */ /* Encodes data using ASCII, C40, Text, X12, EDIFACT or Base 256 modes as appropriate */
/* Supports encoding FNC1 in supporting systems */ /* Supports encoding FNC1 in supporting systems */
int sp, tp, i, gs1; int sp, tp, i, gs1;
int current_mode, next_mode; int current_mode, next_mode;
int inputlen = length; int inputlen = length;
@ -357,19 +357,19 @@ int dm200encode(struct zint_symbol *symbol, unsigned char source[], unsigned cha
memset(edifact_buffer, 0, 8); memset(edifact_buffer, 0, 8);
edifact_p = 0; edifact_p = 0;
strcpy(binary, ""); strcpy(binary, "");
/* step (a) */ /* step (a) */
current_mode = DM_ASCII; current_mode = DM_ASCII;
next_mode = DM_ASCII; next_mode = DM_ASCII;
if(symbol->input_mode == GS1_MODE) { gs1 = 1; } else { gs1 = 0; } if(symbol->input_mode == GS1_MODE) { gs1 = 1; } else { gs1 = 0; }
if(gs1) { if(gs1) {
target[tp] = 232; tp++; target[tp] = 232; tp++;
concat(binary, " "); concat(binary, " ");
if(debug) printf("FN1 "); if(debug) printf("FN1 ");
} /* FNC1 */ } /* FNC1 */
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"); strcpy(symbol->errtxt, "Cannot encode in GS1 mode and Reader Initialisation at the same time");
@ -380,15 +380,15 @@ int dm200encode(struct zint_symbol *symbol, unsigned char source[], unsigned cha
if(debug) printf("RP "); if(debug) printf("RP ");
} }
} }
while (sp < inputlen) { while (sp < inputlen) {
current_mode = next_mode; current_mode = next_mode;
/* step (b) - ASCII encodation */ /* step (b) - ASCII encodation */
if(current_mode == DM_ASCII) { if(current_mode == DM_ASCII) {
next_mode = DM_ASCII; next_mode = DM_ASCII;
if(istwodigits(source, sp) && ((sp + 1) != inputlen)) { if(istwodigits(source, sp) && ((sp + 1) != inputlen)) {
target[tp] = (10 * ctoi(source[sp])) + ctoi(source[sp + 1]) + 130; target[tp] = (10 * ctoi(source[sp])) + ctoi(source[sp + 1]) + 130;
if(debug) printf("N%d ", target[tp] - 130); if(debug) printf("N%d ", target[tp] - 130);
@ -396,7 +396,7 @@ int dm200encode(struct zint_symbol *symbol, unsigned char source[], unsigned cha
sp += 2; sp += 2;
} else { } else {
next_mode = look_ahead_test(source, inputlen, sp, current_mode, gs1); next_mode = look_ahead_test(source, inputlen, sp, current_mode, gs1);
if(next_mode != DM_ASCII) { if(next_mode != DM_ASCII) {
switch(next_mode) { switch(next_mode) {
case DM_C40: target[tp] = 230; tp++; concat(binary, " "); case DM_C40: target[tp] = 230; tp++; concat(binary, " ");
@ -432,18 +432,18 @@ int dm200encode(struct zint_symbol *symbol, unsigned char source[], unsigned cha
sp++; sp++;
} }
} }
} }
/* step (c) C40 encodation */ /* step (c) C40 encodation */
if(current_mode == DM_C40) { if(current_mode == DM_C40) {
int shift_set, value; int shift_set, value;
next_mode = DM_C40; next_mode = DM_C40;
if(c40_p == 0) { if(c40_p == 0) {
next_mode = look_ahead_test(source, inputlen, sp, current_mode, gs1); next_mode = look_ahead_test(source, inputlen, sp, current_mode, gs1);
} }
if(next_mode != DM_C40) { if(next_mode != DM_C40) {
target[tp] = 254; tp++; concat(binary, " ");/* Unlatch */ target[tp] = 254; tp++; concat(binary, " ");/* Unlatch */
next_mode = DM_ASCII; next_mode = DM_ASCII;
@ -458,26 +458,26 @@ int dm200encode(struct zint_symbol *symbol, unsigned char source[], unsigned cha
shift_set = c40_shift[source[sp]]; shift_set = c40_shift[source[sp]];
value = c40_value[source[sp]]; value = c40_value[source[sp]];
} }
if(gs1 && (source[sp] == '[')) { if(gs1 && (source[sp] == '[')) {
shift_set = 2; shift_set = 2;
value = 27; /* FNC1 */ value = 27; /* FNC1 */
} }
if(shift_set != 0) { if(shift_set != 0) {
c40_buffer[c40_p] = shift_set - 1; c40_p++; c40_buffer[c40_p] = shift_set - 1; c40_p++;
} }
c40_buffer[c40_p] = value; c40_p++; c40_buffer[c40_p] = value; c40_p++;
if(c40_p >= 3) { if(c40_p >= 3) {
int iv; int iv;
iv = (1600 * c40_buffer[0]) + (40 * c40_buffer[1]) + (c40_buffer[2]) + 1; iv = (1600 * c40_buffer[0]) + (40 * c40_buffer[1]) + (c40_buffer[2]) + 1;
target[tp] = iv / 256; tp++; target[tp] = iv / 256; tp++;
target[tp] = iv % 256; tp++; target[tp] = iv % 256; tp++;
concat(binary, " "); concat(binary, " ");
if (debug) printf("[%d %d %d] ", c40_buffer[0], c40_buffer[1], c40_buffer[2]); if (debug) printf("[%d %d %d] ", c40_buffer[0], c40_buffer[1], c40_buffer[2]);
c40_buffer[0] = c40_buffer[3]; c40_buffer[0] = c40_buffer[3];
c40_buffer[1] = c40_buffer[4]; c40_buffer[1] = c40_buffer[4];
c40_buffer[2] = c40_buffer[5]; c40_buffer[2] = c40_buffer[5];
@ -489,16 +489,16 @@ int dm200encode(struct zint_symbol *symbol, unsigned char source[], unsigned cha
sp++; sp++;
} }
} }
/* step (d) Text encodation */ /* step (d) Text encodation */
if(current_mode == DM_TEXT) { if(current_mode == DM_TEXT) {
int shift_set, value; int shift_set, value;
next_mode = DM_TEXT; next_mode = DM_TEXT;
if(text_p == 0) { if(text_p == 0) {
next_mode = look_ahead_test(source, inputlen, sp, current_mode, gs1); next_mode = look_ahead_test(source, inputlen, sp, current_mode, gs1);
} }
if(next_mode != DM_TEXT) { if(next_mode != DM_TEXT) {
target[tp] = 254; tp++; concat(binary, " ");/* Unlatch */ target[tp] = 254; tp++; concat(binary, " ");/* Unlatch */
next_mode = DM_ASCII; next_mode = DM_ASCII;
@ -513,26 +513,26 @@ int dm200encode(struct zint_symbol *symbol, unsigned char source[], unsigned cha
shift_set = text_shift[source[sp]]; shift_set = text_shift[source[sp]];
value = text_value[source[sp]]; value = text_value[source[sp]];
} }
if(gs1 && (source[sp] == '[')) { if(gs1 && (source[sp] == '[')) {
shift_set = 2; shift_set = 2;
value = 27; /* FNC1 */ value = 27; /* FNC1 */
} }
if(shift_set != 0) { if(shift_set != 0) {
text_buffer[text_p] = shift_set - 1; text_p++; text_buffer[text_p] = shift_set - 1; text_p++;
} }
text_buffer[text_p] = value; text_p++; text_buffer[text_p] = value; text_p++;
if(text_p >= 3) { if(text_p >= 3) {
int iv; int iv;
iv = (1600 * text_buffer[0]) + (40 * text_buffer[1]) + (text_buffer[2]) + 1; iv = (1600 * text_buffer[0]) + (40 * text_buffer[1]) + (text_buffer[2]) + 1;
target[tp] = iv / 256; tp++; target[tp] = iv / 256; tp++;
target[tp] = iv % 256; tp++; target[tp] = iv % 256; tp++;
concat(binary, " "); concat(binary, " ");
if (debug) printf("[%d %d %d] ", text_buffer[0], text_buffer[1], text_buffer[2]); if (debug) printf("[%d %d %d] ", text_buffer[0], text_buffer[1], text_buffer[2]);
text_buffer[0] = text_buffer[3]; text_buffer[0] = text_buffer[3];
text_buffer[1] = text_buffer[4]; text_buffer[1] = text_buffer[4];
text_buffer[2] = text_buffer[5]; text_buffer[2] = text_buffer[5];
@ -544,16 +544,16 @@ int dm200encode(struct zint_symbol *symbol, unsigned char source[], unsigned cha
sp++; sp++;
} }
} }
/* step (e) X12 encodation */ /* step (e) X12 encodation */
if(current_mode == DM_X12) { if(current_mode == DM_X12) {
int value = 0; int value = 0;
next_mode = DM_X12; next_mode = DM_X12;
if(text_p == 0) { if(text_p == 0) {
next_mode = look_ahead_test(source, inputlen, sp, current_mode, gs1); next_mode = look_ahead_test(source, inputlen, sp, current_mode, gs1);
} }
if(next_mode != DM_X12) { if(next_mode != DM_X12) {
target[tp] = 254; tp++; concat(binary, " ");/* Unlatch */ target[tp] = 254; tp++; concat(binary, " ");/* Unlatch */
next_mode = DM_ASCII; next_mode = DM_ASCII;
@ -565,18 +565,18 @@ int dm200encode(struct zint_symbol *symbol, unsigned char source[], unsigned cha
if(source[sp] == ' ') { value = 3; } if(source[sp] == ' ') { value = 3; }
if((source[sp] >= '0') && (source[sp] <= '9')) { value = (source[sp] - '0') + 4; } if((source[sp] >= '0') && (source[sp] <= '9')) { value = (source[sp] - '0') + 4; }
if((source[sp] >= 'A') && (source[sp] <= 'Z')) { value = (source[sp] - 'A') + 14; } if((source[sp] >= 'A') && (source[sp] <= 'Z')) { value = (source[sp] - 'A') + 14; }
x12_buffer[x12_p] = value; x12_p++; x12_buffer[x12_p] = value; x12_p++;
if(x12_p >= 3) { if(x12_p >= 3) {
int iv; int iv;
iv = (1600 * x12_buffer[0]) + (40 * x12_buffer[1]) + (x12_buffer[2]) + 1; iv = (1600 * x12_buffer[0]) + (40 * x12_buffer[1]) + (x12_buffer[2]) + 1;
target[tp] = iv / 256; tp++; target[tp] = iv / 256; tp++;
target[tp] = iv % 256; tp++; target[tp] = iv % 256; tp++;
concat(binary, " "); concat(binary, " ");
if (debug) printf("[%d %d %d] ", x12_buffer[0], x12_buffer[1], x12_buffer[2]); if (debug) printf("[%d %d %d] ", x12_buffer[0], x12_buffer[1], x12_buffer[2]);
x12_buffer[0] = x12_buffer[3]; x12_buffer[0] = x12_buffer[3];
x12_buffer[1] = x12_buffer[4]; x12_buffer[1] = x12_buffer[4];
x12_buffer[2] = x12_buffer[5]; x12_buffer[2] = x12_buffer[5];
@ -588,34 +588,34 @@ int dm200encode(struct zint_symbol *symbol, unsigned char source[], unsigned cha
sp++; sp++;
} }
} }
/* step (f) EDIFACT encodation */ /* step (f) EDIFACT encodation */
if(current_mode == DM_EDIFACT) { if(current_mode == DM_EDIFACT) {
int value = 0; int value = 0;
next_mode = DM_EDIFACT; next_mode = DM_EDIFACT;
if(edifact_p == 3) { if(edifact_p == 3) {
next_mode = look_ahead_test(source, inputlen, sp, current_mode, gs1); next_mode = look_ahead_test(source, inputlen, sp, current_mode, gs1);
} }
if(next_mode != DM_EDIFACT) { if(next_mode != DM_EDIFACT) {
edifact_buffer[edifact_p] = 31; edifact_p++; edifact_buffer[edifact_p] = 31; edifact_p++;
next_mode = DM_ASCII; next_mode = DM_ASCII;
} else { } else {
if((source[sp] >= '@') && (source[sp] <= '^')) { value = source[sp] - '@'; } if((source[sp] >= '@') && (source[sp] <= '^')) { value = source[sp] - '@'; }
if((source[sp] >= ' ') && (source[sp] <= '?')) { value = source[sp]; } if((source[sp] >= ' ') && (source[sp] <= '?')) { value = source[sp]; }
edifact_buffer[edifact_p] = value; edifact_p++; edifact_buffer[edifact_p] = value; edifact_p++;
sp++; sp++;
} }
if(edifact_p >= 4) { if(edifact_p >= 4) {
target[tp] = (edifact_buffer[0] << 2) + ((edifact_buffer[1] & 0x30) >> 4); tp++; target[tp] = (edifact_buffer[0] << 2) + ((edifact_buffer[1] & 0x30) >> 4); tp++;
target[tp] = ((edifact_buffer[1] & 0x0f) << 4) + ((edifact_buffer[2] & 0x3c) >> 2); tp++; target[tp] = ((edifact_buffer[1] & 0x0f) << 4) + ((edifact_buffer[2] & 0x3c) >> 2); tp++;
target[tp] = ((edifact_buffer[2] & 0x03) << 6) + edifact_buffer[3]; tp++; target[tp] = ((edifact_buffer[2] & 0x03) << 6) + edifact_buffer[3]; tp++;
concat(binary, " "); concat(binary, " ");
if (debug) printf("[%d %d %d %d] ", edifact_buffer[0], edifact_buffer[1], edifact_buffer[2], edifact_buffer[3]); if (debug) printf("[%d %d %d %d] ", edifact_buffer[0], edifact_buffer[1], edifact_buffer[2], edifact_buffer[3]);
edifact_buffer[0] = edifact_buffer[4]; edifact_buffer[0] = edifact_buffer[4];
edifact_buffer[1] = edifact_buffer[5]; edifact_buffer[1] = edifact_buffer[5];
edifact_buffer[2] = edifact_buffer[6]; edifact_buffer[2] = edifact_buffer[6];
@ -627,11 +627,11 @@ int dm200encode(struct zint_symbol *symbol, unsigned char source[], unsigned cha
edifact_p -= 4; edifact_p -= 4;
} }
} }
/* step (g) Base 256 encodation */ /* step (g) Base 256 encodation */
if(current_mode == DM_BASE256) { if(current_mode == DM_BASE256) {
next_mode = look_ahead_test(source, inputlen, sp, current_mode, gs1); next_mode = look_ahead_test(source, inputlen, sp, current_mode, gs1);
if(next_mode == DM_BASE256) { if(next_mode == DM_BASE256) {
target[tp] = source[sp]; target[tp] = source[sp];
if(debug) printf("B%02X ", target[tp]); if(debug) printf("B%02X ", target[tp]);
@ -643,13 +643,13 @@ int dm200encode(struct zint_symbol *symbol, unsigned char source[], unsigned cha
if(debug) printf("ASC "); if(debug) printf("ASC ");
} }
} }
if(tp > 1558) { if(tp > 1558) {
return 0; return 0;
} }
} /* while */ } /* while */
/* Empty buffers */ /* Empty buffers */
if(c40_p == 2) { if(c40_p == 2) {
target[tp] = 254; tp++; /* unlatch */ target[tp] = 254; tp++; /* unlatch */
@ -666,7 +666,7 @@ int dm200encode(struct zint_symbol *symbol, unsigned char source[], unsigned cha
if(debug) printf("ASC A%02X ", target[tp - 1] - 1); if(debug) printf("ASC A%02X ", target[tp - 1] - 1);
current_mode = DM_ASCII; current_mode = DM_ASCII;
} }
if(text_p == 2) { if(text_p == 2) {
target[tp] = 254; tp++; /* unlatch */ target[tp] = 254; tp++; /* unlatch */
target[tp] = source[inputlen - 2] + 1; tp++; target[tp] = source[inputlen - 2] + 1; tp++;
@ -682,7 +682,7 @@ int dm200encode(struct zint_symbol *symbol, unsigned char source[], unsigned cha
if(debug) printf("ASC A%02X ", target[tp - 1] - 1); if(debug) printf("ASC A%02X ", target[tp - 1] - 1);
current_mode = DM_ASCII; current_mode = DM_ASCII;
} }
if(x12_p == 2) { if(x12_p == 2) {
target[tp] = 254; tp++; /* unlatch */ target[tp] = 254; tp++; /* unlatch */
target[tp] = source[inputlen - 2] + 1; tp++; target[tp] = source[inputlen - 2] + 1; tp++;
@ -706,9 +706,9 @@ int dm200encode(struct zint_symbol *symbol, unsigned char source[], unsigned cha
if((i == 0) || ((i != 0) && (binary[i - 1] != 'b'))) { if((i == 0) || ((i != 0) && (binary[i - 1] != 'b'))) {
/* start of binary data */ /* start of binary data */
int binary_count; /* length of b256 data */ int binary_count; /* length of b256 data */
for(binary_count = 0; binary[binary_count + i] == 'b'; binary_count++); for(binary_count = 0; binary[binary_count + i] == 'b'; binary_count++);
if(binary_count <= 249) { if(binary_count <= 249) {
dminsert(binary, i, 'b'); dminsert(binary, i, 'b');
insert_value(target, i, tp, binary_count); tp++; insert_value(target, i, tp, binary_count); tp++;
@ -722,17 +722,17 @@ int dm200encode(struct zint_symbol *symbol, unsigned char source[], unsigned cha
} }
i++; i++;
} }
for(i = 0; i < tp; i++) { for(i = 0; i < tp; i++) {
if(binary[i] == 'b') { if(binary[i] == 'b') {
int prn, temp; int prn, temp;
prn = ((149 * (i + 1)) % 255) + 1; prn = ((149 * (i + 1)) % 255) + 1;
temp = target[i] + prn; temp = target[i] + prn;
if (temp <= 255) { target[i] = temp; } else { target[i] = temp - 256; } if (temp <= 255) { target[i] = temp; } else { target[i] = temp - 256; }
} }
} }
if(debug) { if(debug) {
printf("\n\n"); printf("\n\n");
for(i = 0; i < tp; i++){ for(i = 0; i < tp; i++){
@ -740,7 +740,7 @@ int dm200encode(struct zint_symbol *symbol, unsigned char source[], unsigned cha
} }
printf("\n"); printf("\n");
} }
*(last_mode) = current_mode; *(last_mode) = current_mode;
return tp; return tp;
} }
@ -749,7 +749,7 @@ void add_tail(unsigned char target[], int tp, int tail_length, int last_mode)
{ {
/* adds unlatch and pad bits */ /* adds unlatch and pad bits */
int i, prn, temp; int i, prn, temp;
switch(last_mode) { switch(last_mode) {
case DM_C40: case DM_C40:
case DM_TEXT: case DM_TEXT:
@ -757,7 +757,7 @@ void add_tail(unsigned char target[], int tp, int tail_length, int last_mode)
target[tp] = 254; tp++; /* Unlatch */ target[tp] = 254; tp++; /* Unlatch */
tail_length--; tail_length--;
} }
for(i = tail_length; i > 0; i--) { for(i = tail_length; i > 0; i--) {
if(i == tail_length) { if(i == tail_length) {
target[tp] = 129; tp++; /* Pad */ target[tp] = 129; tp++; /* Pad */
@ -783,20 +783,20 @@ int data_matrix_200(struct zint_symbol *symbol, unsigned char source[], int leng
int H, W, FH, FW, datablock, bytes, rsblock; int H, W, FH, FW, datablock, bytes, rsblock;
int last_mode; int last_mode;
unsigned char *grid = 0; unsigned char *grid = 0;
binlen = dm200encode(symbol, source, binary, &last_mode, length); binlen = dm200encode(symbol, source, binary, &last_mode, length);
if(binlen == 0) { if(binlen == 0) {
strcpy(symbol->errtxt, "Data too long to fit in symbol"); strcpy(symbol->errtxt, "Data too long to fit in symbol");
return ERROR_TOO_LONG; return ERROR_TOO_LONG;
} }
if((symbol->option_2 >= 1) && (symbol->option_2 <= 30)) { if((symbol->option_2 >= 1) && (symbol->option_2 <= 30)) {
optionsize = intsymbol[symbol->option_2 - 1]; optionsize = intsymbol[symbol->option_2 - 1];
} else { } else {
optionsize = -1; optionsize = -1;
} }
calcsize = 29; calcsize = 29;
for(i = 29; i > -1; i--) { for(i = 29; i > -1; i--) {
if(matrixbytes[i] >= binlen) { if(matrixbytes[i] >= binlen) {
@ -816,7 +816,7 @@ int data_matrix_200(struct zint_symbol *symbol, unsigned char source[], int leng
calcsize++; calcsize++;
} }
} }
symbolsize = optionsize; symbolsize = optionsize;
if(calcsize > optionsize) { if(calcsize > optionsize) {
symbolsize = calcsize; symbolsize = calcsize;
@ -826,7 +826,7 @@ int data_matrix_200(struct zint_symbol *symbol, unsigned char source[], int leng
strcpy(symbol->errtxt, "Data does not fit in selected symbol size"); strcpy(symbol->errtxt, "Data does not fit in selected symbol size");
} }
} }
H = matrixH[symbolsize]; H = matrixH[symbolsize];
W = matrixW[symbolsize]; W = matrixW[symbolsize];
FH = matrixFH[symbolsize]; FH = matrixFH[symbolsize];
@ -834,13 +834,13 @@ int data_matrix_200(struct zint_symbol *symbol, unsigned char source[], int leng
bytes = matrixbytes[symbolsize]; bytes = matrixbytes[symbolsize];
datablock = matrixdatablock[symbolsize]; datablock = matrixdatablock[symbolsize];
rsblock = matrixrsblock[symbolsize]; rsblock = matrixrsblock[symbolsize];
taillength = bytes - binlen; taillength = bytes - binlen;
if(taillength != 0) { if(taillength != 0) {
add_tail(binary, binlen, taillength, last_mode); add_tail(binary, binlen, taillength, last_mode);
} }
// ecc code // ecc code
if(symbolsize == 29) { skew = 1; } if(symbolsize == 29) { skew = 1; }
ecc200(binary, bytes, datablock, rsblock, skew); ecc200(binary, bytes, datablock, rsblock, skew);
@ -885,17 +885,17 @@ int data_matrix_200(struct zint_symbol *symbol, unsigned char source[], int leng
free(grid); free(grid);
free(places); free(places);
} }
symbol->rows = H; symbol->rows = H;
symbol->width = W; symbol->width = W;
return error_number; return error_number;
} }
int dmatrix(struct zint_symbol *symbol, unsigned char source[], int length) int dmatrix(struct zint_symbol *symbol, unsigned char source[], int length)
{ {
int error_number; int error_number;
if(symbol->option_1 <= 1) { if(symbol->option_1 <= 1) {
/* ECC 200 */ /* ECC 200 */
error_number = data_matrix_200(symbol, source, length); error_number = data_matrix_200(symbol, source, length);

38
backend/dmatrix.h
View File

@ -3,20 +3,6 @@
/* /*
libzint - the open source barcode library libzint - the open source barcode library
Copyright (C) 2009 Robin Stuart <robin@zint.org.uk> Copyright (C) 2009 Robin Stuart <robin@zint.org.uk>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/ */
#include "common.h" #include "common.h"
@ -43,58 +29,58 @@ extern int data_matrix_200(struct zint_symbol *symbol, unsigned char source[], i
#define DM_EDIFACT 5 #define DM_EDIFACT 5
#define DM_BASE256 6 #define DM_BASE256 6
static int c40_shift[] = { static const int c40_shift[] = {
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 }; 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 };
static int c40_value[] = { static const int c40_value[] = {
0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31, 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,
3,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,4,5,6,7,8,9,10,11,12,13, 3,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,4,5,6,7,8,9,10,11,12,13,
15,16,17,18,19,20,21,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39, 15,16,17,18,19,20,21,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,
22,23,24,25,26,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31 }; 22,23,24,25,26,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31 };
static int text_shift[] = { static const int text_shift[] = {
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
2, 2, 2, 2, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3 }; 2, 2, 2, 2, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3 };
static int text_value[] = { static const int text_value[] = {
0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31, 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,
3,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,4,5,6,7,8,9,10,11,12,13, 3,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,4,5,6,7,8,9,10,11,12,13,
15,16,17,18,19,20,21,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26, 15,16,17,18,19,20,21,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,
22,23,24,25,26,0,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,27,28,29,30,31 }; 22,23,24,25,26,0,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,27,28,29,30,31 };
static int intsymbol[] = { static const int intsymbol[] = {
0,1,3,5,7,8,10,12,13,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,2,4,6,9,11,14 }; 0,1,3,5,7,8,10,12,13,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,2,4,6,9,11,14 };
static int matrixH[] = { static const int matrixH[] = {
10, 12, 8, 14, 8, 16, 12, 18, 20, 12, 22, 16, 24, 26, 16, 32, 36, 40, 44, 48, 10, 12, 8, 14, 8, 16, 12, 18, 20, 12, 22, 16, 24, 26, 16, 32, 36, 40, 44, 48,
52, 64, 72, 80, 88, 96, 104, 120, 132, 144 }; 52, 64, 72, 80, 88, 96, 104, 120, 132, 144 };
static int matrixW[] = { static const int matrixW[] = {
10, 12, 18, 14, 32, 16, 26, 18, 20, 36, 22, 36, 24, 26, 48, 32, 36, 40, 44, 10, 12, 18, 14, 32, 16, 26, 18, 20, 36, 22, 36, 24, 26, 48, 32, 36, 40, 44,
48, 52, 64, 72, 80, 88, 96, 104, 120, 132, 144 }; 48, 52, 64, 72, 80, 88, 96, 104, 120, 132, 144 };
static int matrixFH[] = { static const int matrixFH[] = {
10, 12, 8, 14, 8, 16, 12, 18, 20, 12, 22, 16, 24, 26, 16, 16, 18, 20, 22, 24, 10, 12, 8, 14, 8, 16, 12, 18, 20, 12, 22, 16, 24, 26, 16, 16, 18, 20, 22, 24,
26, 16, 18, 20, 22, 24, 26, 20, 22, 24 }; 26, 16, 18, 20, 22, 24, 26, 20, 22, 24 };
static int matrixFW[] = { static const int matrixFW[] = {
10, 12, 18, 14, 16, 16, 26, 18, 20, 18, 22, 18, 24, 26, 24, 16, 18, 20, 22, 10, 12, 18, 14, 16, 16, 26, 18, 20, 18, 22, 18, 24, 26, 24, 16, 18, 20, 22,
24, 26, 16, 18, 20, 22, 24, 26, 20, 22, 24 }; 24, 26, 16, 18, 20, 22, 24, 26, 20, 22, 24 };
static int matrixbytes[] = { static const int matrixbytes[] = {
3, 5, 5, 8, 10, 12, 16, 18, 22, 22, 30, 32, 36, 44, 49, 62, 86, 114, 144, 3, 5, 5, 8, 10, 12, 16, 18, 22, 22, 30, 32, 36, 44, 49, 62, 86, 114, 144,
174, 204, 280, 368, 456, 576, 696, 816, 1050, 1304, 1558 }; 174, 204, 280, 368, 456, 576, 696, 816, 1050, 1304, 1558 };
static int matrixdatablock[] = { static const int matrixdatablock[] = {
3, 5, 5, 8, 10, 12, 16, 18, 22, 22, 30, 32, 36, 44, 49, 62, 86, 114, 144, 3, 5, 5, 8, 10, 12, 16, 18, 22, 22, 30, 32, 36, 44, 49, 62, 86, 114, 144,
174, 102, 140, 92, 114, 144, 174, 136, 175, 163, 156 }; 174, 102, 140, 92, 114, 144, 174, 136, 175, 163, 156 };
static int matrixrsblock[] = { static const int matrixrsblock[] = {
5, 7, 7, 10, 11, 12, 14, 14, 18, 18, 20, 24, 24, 28, 28, 36, 42, 48, 56, 68, 5, 7, 7, 10, 11, 12, 14, 14, 18, 18, 20, 24, 24, 28, 28, 36, 42, 48, 56, 68,
42, 56, 36, 48, 56, 68, 56, 68, 62, 62 }; 42, 56, 36, 48, 56, 68, 56, 68, 62, 62 };

22
backend/font.h
View File

@ -3,26 +3,12 @@
/* /*
libzint - the open source barcode library libzint - the open source barcode library
Copyright (C) 2008 Robin Stuart <robin@zint.org.uk> Copyright (C) 2008 Robin Stuart <robin@zint.org.uk>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/ */
/* This file contains the pixel-by-pixel representation of the "Misc Fixed" font /* This file contains the pixel-by-pixel representation of the "Misc Fixed" font
at 10 point size processed by the Gimp */ at 10 point size processed by the Gimp */
static int ascii_font[9310] = { static const int ascii_font[9310] = {
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
@ -613,7 +599,7 @@ static int ascii_font[9310] = {
0,0,0,0,0,0,0,0,0 0,0,0,0,0,0,0,0,0
}; };
static int ascii_ext_font[9310] = { static const int ascii_ext_font[9310] = {
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
@ -1204,7 +1190,7 @@ static int ascii_ext_font[9310] = {
0,0,1,1,0,0,0,0,0 0,0,1,1,0,0,0,0,0
}; };
static int small_font[] = { static const int small_font[] = {
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
@ -1447,7 +1433,7 @@ static int small_font[] = {
0,0,0,0,0,0,0,0,0,0,0 0,0,0,0,0,0,0,0,0,0,0
}; };
static int small_font_extended[] = { static const int small_font_extended[] = {
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

2
backend/gb2312.h
View File

@ -18,7 +18,7 @@
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/ */
unsigned long int gb2312_lookup[] = { static const unsigned long int gb2312_lookup[] = {
0x00A4, 0xA1E8, 0x00A4, 0xA1E8,
0x00A7, 0xA1EC, 0x00A7, 0xA1EC,
0x00A8, 0xA1A7, 0x00A8, 0xA1A7,

162
backend/gridmtx.c
View File

@ -41,12 +41,12 @@ int number_lat(int gbdata[], int length, int position)
int sp; int sp;
int numb = 0, nonum = 0, done; int numb = 0, nonum = 0, done;
int tally = 0; int tally = 0;
sp = position; sp = position;
do { do {
done = 0; done = 0;
if((gbdata[sp] >= '0') && (gbdata[sp] <= '9')) { numb++; done = 1; } if((gbdata[sp] >= '0') && (gbdata[sp] <= '9')) { numb++; done = 1; }
switch(gbdata[sp]) { switch(gbdata[sp]) {
case ' ': case ' ':
@ -64,7 +64,7 @@ int number_lat(int gbdata[], int length, int position)
sp++; sp++;
} }
} }
if(done == 0) { if(done == 0) {
tally += 80; tally += 80;
} else { } else {
@ -82,14 +82,14 @@ int number_lat(int gbdata[], int length, int position)
nonum = 0; nonum = 0;
} }
} }
sp++; sp++;
} while ((sp < length) && (sp <= (position + 8))); } while ((sp < length) && (sp <= (position + 8)));
if(numb == 0) { if(numb == 0) {
tally += 80; tally += 80;
} }
if(numb > 1) { if(numb > 1) {
if(nonum == 0) { if(nonum == 0) {
tally += 10; tally += 10;
@ -101,7 +101,7 @@ int number_lat(int gbdata[], int length, int position)
tally += 80; tally += 80;
} }
} }
return tally; return tally;
} }
@ -111,14 +111,14 @@ int seek_forward(int gbdata[], int length, int position, int current_mode)
code uses a look-ahead test in the same manner as Data Matrix. This decision was made code uses a look-ahead test in the same manner as Data Matrix. This decision was made
because the "official" algorithm does not provide clear methods for dealing with all because the "official" algorithm does not provide clear methods for dealing with all
possible combinations of input data */ possible combinations of input data */
int number_count, byte_count, mixed_count, upper_count, lower_count, chinese_count; int number_count, byte_count, mixed_count, upper_count, lower_count, chinese_count;
int sp, best_mode, done; int sp, best_mode, done;
int best_count, last = -1; int best_count, last = -1;
int debug = 0; int debug = 0;
if(gbdata[position] > 0xff) { return GM_CHINESE; } if(gbdata[position] > 0xff) { return GM_CHINESE; }
switch(current_mode) { switch(current_mode) {
case GM_CHINESE: case GM_CHINESE:
number_count = 13; number_count = 13;
@ -176,11 +176,11 @@ int seek_forward(int gbdata[], int length, int position, int current_mode)
lower_count = 4; lower_count = 4;
chinese_count = 4; chinese_count = 4;
} }
for(sp = position; (sp < length) && (sp <= (position + 8)); sp++) { for(sp = position; (sp < length) && (sp <= (position + 8)); sp++) {
done = 0; done = 0;
if(gbdata[sp] >= 0xff) { if(gbdata[sp] >= 0xff) {
byte_count += 17; byte_count += 17;
mixed_count += 23; mixed_count += 23;
@ -189,7 +189,7 @@ int seek_forward(int gbdata[], int length, int position, int current_mode)
chinese_count += 13; chinese_count += 13;
done = 1; done = 1;
} }
if((gbdata[sp] >= 'a') && (gbdata[sp] <= 'z')) { if((gbdata[sp] >= 'a') && (gbdata[sp] <= 'z')) {
byte_count += 8; byte_count += 8;
mixed_count += 6; mixed_count += 6;
@ -198,7 +198,7 @@ int seek_forward(int gbdata[], int length, int position, int current_mode)
chinese_count += 13; chinese_count += 13;
done = 1; done = 1;
} }
if((gbdata[sp] >= 'A') && (gbdata[sp] <= 'Z')) { if((gbdata[sp] >= 'A') && (gbdata[sp] <= 'Z')) {
byte_count += 8; byte_count += 8;
mixed_count += 6; mixed_count += 6;
@ -207,7 +207,7 @@ int seek_forward(int gbdata[], int length, int position, int current_mode)
chinese_count += 13; chinese_count += 13;
done = 1; done = 1;
} }
if((gbdata[sp] >= '0') && (gbdata[sp] <= '9')) { if((gbdata[sp] >= '0') && (gbdata[sp] <= '9')) {
byte_count += 8; byte_count += 8;
mixed_count += 6; mixed_count += 6;
@ -216,7 +216,7 @@ int seek_forward(int gbdata[], int length, int position, int current_mode)
chinese_count += 13; chinese_count += 13;
done = 1; done = 1;
} }
if(gbdata[sp] == ' ') { if(gbdata[sp] == ' ') {
byte_count += 8; byte_count += 8;
mixed_count += 6; mixed_count += 6;
@ -225,7 +225,7 @@ int seek_forward(int gbdata[], int length, int position, int current_mode)
chinese_count += 13; chinese_count += 13;
done = 1; done = 1;
} }
if(done == 0) { if(done == 0) {
/* Control character */ /* Control character */
byte_count += 8; byte_count += 8;
@ -234,21 +234,21 @@ int seek_forward(int gbdata[], int length, int position, int current_mode)
lower_count += 13; lower_count += 13;
chinese_count += 13; chinese_count += 13;
} }
if(gbdata[sp] >= 0x7f) { if(gbdata[sp] >= 0x7f) {
mixed_count += 20; mixed_count += 20;
upper_count += 20; upper_count += 20;
lower_count += 20; lower_count += 20;
} }
} }
/* Adjust for <end of line> */ /* Adjust for <end of line> */
for(sp = position; (sp < (length - 1)) && (sp <= (position + 7)); sp++) { for(sp = position; (sp < (length - 1)) && (sp <= (position + 7)); sp++) {
if((gbdata[sp] == 0x13) && (gbdata[sp] == 0x10)) { if((gbdata[sp] == 0x13) && (gbdata[sp] == 0x10)) {
chinese_count -= 13; chinese_count -= 13;
} }
} }
/* Adjust for double digits */ /* Adjust for double digits */
for(sp = position; (sp < (length - 1)) && (sp <= (position + 7)); sp++) { for(sp = position; (sp < (length - 1)) && (sp <= (position + 7)); sp++) {
if(sp != last) { if(sp != last) {
@ -258,40 +258,40 @@ int seek_forward(int gbdata[], int length, int position, int current_mode)
} }
} }
} }
/* Numeric mode is more complex */ /* Numeric mode is more complex */
number_count += number_lat(gbdata, length, position); number_count += number_lat(gbdata, length, position);
if(debug) { printf("C %d / B %d / M %d / U %d / L %d / N %d\n", chinese_count, byte_count, mixed_count, upper_count, lower_count, number_count); } if(debug) { printf("C %d / B %d / M %d / U %d / L %d / N %d\n", chinese_count, byte_count, mixed_count, upper_count, lower_count, number_count); }
best_count = chinese_count; best_count = chinese_count;
best_mode = GM_CHINESE; best_mode = GM_CHINESE;
if(byte_count <= best_count) { if(byte_count <= best_count) {
best_count = byte_count; best_count = byte_count;
best_mode = GM_BYTE; best_mode = GM_BYTE;
} }
if(mixed_count <= best_count) { if(mixed_count <= best_count) {
best_count = mixed_count; best_count = mixed_count;
best_mode = GM_MIXED; best_mode = GM_MIXED;
} }
if(upper_count <= best_count) { if(upper_count <= best_count) {
best_count = upper_count; best_count = upper_count;
best_mode = GM_UPPER; best_mode = GM_UPPER;
} }
if(lower_count <= best_count) { if(lower_count <= best_count) {
best_count = lower_count; best_count = lower_count;
best_mode = GM_LOWER; best_mode = GM_LOWER;
} }
if(number_count <= best_count) { if(number_count <= best_count) {
best_count = number_count; best_count = number_count;
best_mode = GM_NUMBER; best_mode = GM_NUMBER;
} }
return best_mode; return best_mode;
} }
@ -314,13 +314,13 @@ void add_shift_char(char binary[], int shifty)
/* Add a control character to the data stream */ /* Add a control character to the data stream */
int i, debug = 0; int i, debug = 0;
int glyph = 0; int glyph = 0;
for(i = 0; i < 64; i++) { for(i = 0; i < 64; i++) {
if(shift_set[i] == shifty) { if(shift_set[i] == shifty) {
glyph = i; glyph = i;
} }
} }
if(debug) { printf("SHIFT [%d] ", glyph); } if(debug) { printf("SHIFT [%d] ", glyph); }
if(glyph & 0x20) { concat(binary, "1"); } else { concat(binary, "0"); } if(glyph & 0x20) { concat(binary, "1"); } else { concat(binary, "0"); }
@ -343,21 +343,21 @@ int gm_encode(int gbdata[], int length, char binary[], int reader)
int number_pad_posn, debug = 0; int number_pad_posn, debug = 0;
int byte_count_posn = 0, byte_count = 0; int byte_count_posn = 0, byte_count = 0;
int shift, i; int shift, i;
strcpy(binary, ""); strcpy(binary, "");
sp = 0; sp = 0;
current_mode = 0; current_mode = 0;
last_mode = 0; last_mode = 0;
number_pad_posn = 0; number_pad_posn = 0;
if(reader) { if(reader) {
concat(binary, "1010"); /* FNC3 - Reader Initialisation */ concat(binary, "1010"); /* FNC3 - Reader Initialisation */
} }
do { do {
next_mode = seek_forward(gbdata, length, sp, current_mode); next_mode = seek_forward(gbdata, length, sp, current_mode);
if(next_mode != current_mode) { if(next_mode != current_mode) {
switch(current_mode) { switch(current_mode) {
case 0: case 0:
@ -440,7 +440,7 @@ int gm_encode(int gbdata[], int length, char binary[], int reader)
} }
last_mode = current_mode; last_mode = current_mode;
current_mode = next_mode; current_mode = next_mode;
switch(current_mode) { switch(current_mode) {
case GM_CHINESE: case GM_CHINESE:
done = 0; done = 0;
@ -448,7 +448,7 @@ int gm_encode(int gbdata[], int length, char binary[], int reader)
/* GB2312 character */ /* GB2312 character */
c1 = (gbdata[sp] & 0xff00) >> 8; c1 = (gbdata[sp] & 0xff00) >> 8;
c2 = gbdata[sp] & 0xff; c2 = gbdata[sp] & 0xff;
if((c1 >= 0xa0) && (c1 <= 0xa9)) { if((c1 >= 0xa0) && (c1 <= 0xa9)) {
glyph = (0x60 * (c1 - 0xa1)) + (c2 - 0xa0); glyph = (0x60 * (c1 - 0xa1)) + (c2 - 0xa0);
} }
@ -481,7 +481,7 @@ int gm_encode(int gbdata[], int length, char binary[], int reader)
/* Byte value */ /* Byte value */
glyph = 7777 + gbdata[sp]; glyph = 7777 + gbdata[sp];
} }
if(debug) { printf("[%d] ", glyph); } if(debug) { printf("[%d] ", glyph); }
if(glyph & 0x1000) { concat(binary, "1"); } else { concat(binary, "0"); } if(glyph & 0x1000) { concat(binary, "1"); } else { concat(binary, "0"); }
@ -499,7 +499,7 @@ int gm_encode(int gbdata[], int length, char binary[], int reader)
if(glyph & 0x01) { concat(binary, "1"); } else { concat(binary, "0"); } if(glyph & 0x01) { concat(binary, "1"); } else { concat(binary, "0"); }
sp++; sp++;
break; break;
case GM_NUMBER: case GM_NUMBER:
if(last_mode != current_mode) { if(last_mode != current_mode) {
/* Reserve a space for numeric digit padding value (2 bits) */ /* Reserve a space for numeric digit padding value (2 bits) */
@ -508,10 +508,10 @@ int gm_encode(int gbdata[], int length, char binary[], int reader)
} }
p = 0; p = 0;
ppos = -1; ppos = -1;
/* Numeric compression can also include certain combinations of /* Numeric compression can also include certain combinations of
non-numeric character */ non-numeric character */
numbuf[0] = '0'; numbuf[0] = '0';
numbuf[1] = '0'; numbuf[1] = '0';
numbuf[2] = '0'; numbuf[2] = '0';
@ -541,7 +541,7 @@ int gm_encode(int gbdata[], int length, char binary[], int reader)
} }
} }
} while ((p < 3) && (sp < length)); } while ((p < 3) && (sp < length));
if(ppos != -1) { if(ppos != -1) {
switch(punt) { switch(punt) {
case ' ': glyph = 0; break; case ' ': glyph = 0; break;
@ -553,7 +553,7 @@ int gm_encode(int gbdata[], int length, char binary[], int reader)
} }
glyph += ppos; glyph += ppos;
glyph += 1000; glyph += 1000;
if(debug) { printf("[%d] ", glyph); } if(debug) { printf("[%d] ", glyph); }
if(glyph & 0x200) { concat(binary, "1"); } else { concat(binary, "0"); } if(glyph & 0x200) { concat(binary, "1"); } else { concat(binary, "0"); }
@ -567,7 +567,7 @@ int gm_encode(int gbdata[], int length, char binary[], int reader)
if(glyph & 0x02) { concat(binary, "1"); } else { concat(binary, "0"); } if(glyph & 0x02) { concat(binary, "1"); } else { concat(binary, "0"); }
if(glyph & 0x01) { concat(binary, "1"); } else { concat(binary, "0"); } if(glyph & 0x01) { concat(binary, "1"); } else { concat(binary, "0"); }
} }
glyph = (100 * (numbuf[0] - '0')) + (10 * (numbuf[1] - '0')) + (numbuf[2] - '0'); glyph = (100 * (numbuf[0] - '0')) + (10 * (numbuf[1] - '0')) + (numbuf[2] - '0');
if(debug) { printf("[%d] ", glyph); } if(debug) { printf("[%d] ", glyph); }
@ -582,7 +582,7 @@ int gm_encode(int gbdata[], int length, char binary[], int reader)
if(glyph & 0x02) { concat(binary, "1"); } else { concat(binary, "0"); } if(glyph & 0x02) { concat(binary, "1"); } else { concat(binary, "0"); }
if(glyph & 0x01) { concat(binary, "1"); } else { concat(binary, "0"); } if(glyph & 0x01) { concat(binary, "1"); } else { concat(binary, "0"); }
break; break;
case GM_BYTE: case GM_BYTE:
if(last_mode != current_mode) { if(last_mode != current_mode) {
/* Reserve space for byte block length indicator (9 bits) */ /* Reserve space for byte block length indicator (9 bits) */
@ -597,7 +597,7 @@ int gm_encode(int gbdata[], int length, char binary[], int reader)
concat(binary, "LLLLLLLLL"); concat(binary, "LLLLLLLLL");
byte_count = 0; byte_count = 0;
} }
glyph = gbdata[sp]; glyph = gbdata[sp];
if(debug) { printf("[%d] ", glyph); } if(debug) { printf("[%d] ", glyph); }
if(glyph & 0x80) { concat(binary, "1"); } else { concat(binary, "0"); } if(glyph & 0x80) { concat(binary, "1"); } else { concat(binary, "0"); }
@ -611,14 +611,14 @@ int gm_encode(int gbdata[], int length, char binary[], int reader)
sp++; sp++;
byte_count++; byte_count++;
break; break;
case GM_MIXED: case GM_MIXED:
shift = 1; shift = 1;
if((gbdata[sp] >= '0') && (gbdata[sp] <= '9')) { shift = 0; } if((gbdata[sp] >= '0') && (gbdata[sp] <= '9')) { shift = 0; }
if((gbdata[sp] >= 'A') && (gbdata[sp] <= 'Z')) { shift = 0; } if((gbdata[sp] >= 'A') && (gbdata[sp] <= 'Z')) { shift = 0; }
if((gbdata[sp] >= 'a') && (gbdata[sp] <= 'z')) { shift = 0; } if((gbdata[sp] >= 'a') && (gbdata[sp] <= 'z')) { shift = 0; }
if(gbdata[sp] == ' ') { shift = 0; } if(gbdata[sp] == ' ') { shift = 0; }
if(shift == 0) { if(shift == 0) {
/* Mixed Mode character */ /* Mixed Mode character */
glyph = posn(EUROPIUM, gbdata[sp]); glyph = posn(EUROPIUM, gbdata[sp]);
@ -635,15 +635,15 @@ int gm_encode(int gbdata[], int length, char binary[], int reader)
concat(binary, "1111110110"); /* 1014 - shift indicator */ concat(binary, "1111110110"); /* 1014 - shift indicator */
add_shift_char(binary, gbdata[sp]); add_shift_char(binary, gbdata[sp]);
} }
sp++; sp++;
break; break;
case GM_UPPER: case GM_UPPER:
shift = 1; shift = 1;
if((gbdata[sp] >= 'A') && (gbdata[sp] <= 'Z')) { shift = 0; } if((gbdata[sp] >= 'A') && (gbdata[sp] <= 'Z')) { shift = 0; }
if(gbdata[sp] == ' ') { shift = 0; } if(gbdata[sp] == ' ') { shift = 0; }
if(shift == 0) { if(shift == 0) {
/* Upper Case character */ /* Upper Case character */
glyph = posn("ABCDEFGHIJKLMNOPQRSTUVWXYZ ", gbdata[sp]); glyph = posn("ABCDEFGHIJKLMNOPQRSTUVWXYZ ", gbdata[sp]);
@ -659,7 +659,7 @@ int gm_encode(int gbdata[], int length, char binary[], int reader)
concat(binary, "1111101"); /* 127 - shift indicator */ concat(binary, "1111101"); /* 127 - shift indicator */
add_shift_char(binary, gbdata[sp]); add_shift_char(binary, gbdata[sp]);
} }
sp++; sp++;
break; break;
@ -667,7 +667,7 @@ int gm_encode(int gbdata[], int length, char binary[], int reader)
shift = 1; shift = 1;
if((gbdata[sp] >= 'a') && (gbdata[sp] <= 'z')) { shift = 0; } if((gbdata[sp] >= 'a') && (gbdata[sp] <= 'z')) { shift = 0; }
if(gbdata[sp] == ' ') { shift = 0; } if(gbdata[sp] == ' ') { shift = 0; }
if(shift == 0) { if(shift == 0) {
/* Lower Case character */ /* Lower Case character */
glyph = posn("abcdefghijklmnopqrstuvwxyz ", gbdata[sp]); glyph = posn("abcdefghijklmnopqrstuvwxyz ", gbdata[sp]);
@ -683,16 +683,16 @@ int gm_encode(int gbdata[], int length, char binary[], int reader)
concat(binary, "1111101"); /* 127 - shift indicator */ concat(binary, "1111101"); /* 127 - shift indicator */
add_shift_char(binary, gbdata[sp]); add_shift_char(binary, gbdata[sp]);
} }
sp++; sp++;
break; break;
} }
if(strlen(binary) > 9191) { if(strlen(binary) > 9191) {
return ERROR_TOO_LONG; return ERROR_TOO_LONG;
} }
} while(sp < length); } while(sp < length);
if(current_mode == GM_NUMBER) { if(current_mode == GM_NUMBER) {
/* add numeric block padding value */ /* add numeric block padding value */
switch(p) { switch(p) {
@ -701,12 +701,12 @@ int gm_encode(int gbdata[], int length, char binary[], int reader)
case 3: binary[number_pad_posn] = '0'; binary[number_pad_posn + 1] = '0'; break; // 0 pad digits case 3: binary[number_pad_posn] = '0'; binary[number_pad_posn + 1] = '0'; break; // 0 pad digits
} }
} }
if(current_mode == GM_BYTE) { if(current_mode == GM_BYTE) {
/* Add byte block length indicator */ /* Add byte block length indicator */
add_byte_count(binary, byte_count_posn, byte_count); add_byte_count(binary, byte_count_posn, byte_count);
} }
/* Add "end of data" character */ /* Add "end of data" character */
switch(current_mode) { switch(current_mode) {
case GM_CHINESE: concat(binary, "1111111100000"); break; // 8160 case GM_CHINESE: concat(binary, "1111111100000"); break; // 8160
@ -716,14 +716,14 @@ int gm_encode(int gbdata[], int length, char binary[], int reader)
case GM_MIXED: concat(binary, "1111110000"); break; // 1008 case GM_MIXED: concat(binary, "1111110000"); break; // 1008
case GM_BYTE: concat(binary, "0000"); break; // 0 case GM_BYTE: concat(binary, "0000"); break; // 0
} }
/* Add padding bits if required */ /* Add padding bits if required */
p = 7 - (strlen(binary) % 7); p = 7 - (strlen(binary) % 7);
if(p == 7) { p = 0; } if(p == 7) { p = 0; }
for(i = 0; i < p; i++) { for(i = 0; i < p; i++) {
concat(binary, "0"); concat(binary, "0");
} }
if(strlen(binary) > 9191) { if(strlen(binary) > 9191) {
return ERROR_TOO_LONG; return ERROR_TOO_LONG;
} }
@ -814,10 +814,10 @@ void gm_add_ecc(char binary[], int data_posn, int layers, int ecc_level, int wor
void place_macromodule(char grid[], int x, int y, int word1, int word2, int size) void place_macromodule(char grid[], int x, int y, int word1, int word2, int size)
{ {
int i, j; int i, j;
i = (x * 6) + 1; i = (x * 6) + 1;
j = (y * 6) + 1; j = (y * 6) + 1;
if(word2 & 0x40) { grid[(j * size) + i + 2] = '1'; } if(word2 & 0x40) { grid[(j * size) + i + 2] = '1'; }
if(word2 & 0x20) { grid[(j * size) + i + 3] = '1'; } if(word2 & 0x20) { grid[(j * size) + i + 3] = '1'; }
if(word2 & 0x10) { grid[((j + 1) * size) + i] = '1'; } if(word2 & 0x10) { grid[((j + 1) * size) + i] = '1'; }
@ -837,7 +837,7 @@ void place_macromodule(char grid[], int x, int y, int word1, int word2, int size
void place_data_in_grid(int word[], char grid[], int modules, int size) void place_data_in_grid(int word[], char grid[], int modules, int size)
{ {
int x, y, macromodule, offset; int x, y, macromodule, offset;
offset = 13 - ((modules - 1) / 2); offset = 13 - ((modules - 1) / 2);
for(y = 0; y < modules; y++) { for(y = 0; y < modules; y++) {
for(x = 0; x < modules; x++) { for(x = 0; x < modules; x++) {
@ -850,7 +850,7 @@ void place_data_in_grid(int word[], char grid[], int modules, int size)
void place_layer_id(char* grid, int size, int layers, int modules, int ecc_level) void place_layer_id(char* grid, int size, int layers, int modules, int ecc_level)
{ {
/* Place the layer ID into each macromodule */ /* Place the layer ID into each macromodule */
int i, j, layer, start, stop; int i, j, layer, start, stop;
#ifndef _MSC_VER #ifndef _MSC_VER
@ -869,13 +869,13 @@ void place_layer_id(char* grid, int size, int layers, int modules, int ecc_level
layerid[i] = (i + 5 - ecc_level) % 4; layerid[i] = (i + 5 - ecc_level) % 4;
} }
} }
for(i = 0; i < modules; i++) { for(i = 0; i < modules; i++) {
for(j = 0; j < modules; j++) { for(j = 0; j < modules; j++) {
id[(i * modules) + j] = 0; id[(i * modules) + j] = 0;
} }
} }
/* Calculate which value goes in each macromodule */ /* Calculate which value goes in each macromodule */
start = modules / 2; start = modules / 2;
stop = modules / 2; stop = modules / 2;
@ -889,7 +889,7 @@ void place_layer_id(char* grid, int size, int layers, int modules, int ecc_level
start--; start--;
stop++; stop++;
} }
/* Place the data in the grid */ /* Place the data in the grid */
for(i = 0; i < modules; i++) { for(i = 0; i < modules; i++) {
for(j = 0; j < modules; j++) { for(j = 0; j < modules; j++) {
@ -934,7 +934,7 @@ int grid_matrix(struct zint_symbol *symbol, unsigned char source[], int length)
/* Convert Unicode input to GB-2312 */ /* Convert Unicode input to GB-2312 */
error_number = utf8toutf16(symbol, source, utfdata, &length); error_number = utf8toutf16(symbol, source, utfdata, &length);
if(error_number != 0) { return error_number; } if(error_number != 0) { return error_number; }
for(i = 0; i < length; i++) { for(i = 0; i < length; i++) {
if(utfdata[i] <= 0xff) { if(utfdata[i] <= 0xff) {
gbdata[i] = utfdata[i]; gbdata[i] = utfdata[i];
@ -964,10 +964,10 @@ int grid_matrix(struct zint_symbol *symbol, unsigned char source[], int length)
strcpy(symbol->errtxt, "Input data too long"); strcpy(symbol->errtxt, "Input data too long");
return error_number; return error_number;
} }
/* Determine the size of the symbol */ /* Determine the size of the symbol */
data_cw = strlen(binary) / 7; data_cw = strlen(binary) / 7;
auto_layers = 13; auto_layers = 13;
for(i = 12; i > 0; i--) { for(i = 12; i > 0; i--) {
if(gm_recommend_cw[(i - 1)] >= data_cw) { auto_layers = i; } if(gm_recommend_cw[(i - 1)] >= data_cw) { auto_layers = i; }
@ -984,7 +984,7 @@ int grid_matrix(struct zint_symbol *symbol, unsigned char source[], int length)
if(layers == 1) { min_ecc_level = 4; } if(layers == 1) { min_ecc_level = 4; }
if((layers == 2) || (layers == 3)) { min_ecc_level = 2; } if((layers == 2) || (layers == 3)) { min_ecc_level = 2; }
ecc_level = auto_ecc_level; ecc_level = auto_ecc_level;
if((symbol->option_2 >= 1) && (symbol->option_2 <= 13)) { if((symbol->option_2 >= 1) && (symbol->option_2 <= 13)) {
input_latch = 1; input_latch = 1;
if(symbol->option_2 > min_layers) { if(symbol->option_2 > min_layers) {
@ -993,7 +993,7 @@ int grid_matrix(struct zint_symbol *symbol, unsigned char source[], int length)
layers = min_layers; layers = min_layers;
} }
} }
if(input_latch == 1) { if(input_latch == 1) {
auto_ecc_level = 3; auto_ecc_level = 3;
if(layers == 1) { auto_ecc_level = 5; } if(layers == 1) { auto_ecc_level = 5; }
@ -1003,7 +1003,7 @@ int grid_matrix(struct zint_symbol *symbol, unsigned char source[], int length)
layers++; layers++;
} }
} }
if(input_latch == 0) { if(input_latch == 0) {
if((symbol->option_1 >= 1) && (symbol->option_1 <= 5)) { if((symbol->option_1 >= 1) && (symbol->option_1 <= 5)) {
if(symbol->option_1 > min_ecc_level) { if(symbol->option_1 > min_ecc_level) {
@ -1018,7 +1018,7 @@ int grid_matrix(struct zint_symbol *symbol, unsigned char source[], int length)
} while ((data_cw > gm_data_codewords[(5 * (layers - 1)) + (ecc_level - 1)]) && (layers <= 13)); } while ((data_cw > gm_data_codewords[(5 * (layers - 1)) + (ecc_level - 1)]) && (layers <= 13));
} }
} }
data_max = 1313; data_max = 1313;
switch(ecc_level) { switch(ecc_level) {
case 2: data_max = 1167; break; case 2: data_max = 1167; break;
@ -1026,7 +1026,7 @@ int grid_matrix(struct zint_symbol *symbol, unsigned char source[], int length)
case 4: data_max = 875; break; case 4: data_max = 875; break;
case 5: data_max = 729; break; case 5: data_max = 729; break;
} }
if(data_cw > data_max) { if(data_cw > data_max) {
strcpy(symbol->errtxt, "Input data too long"); strcpy(symbol->errtxt, "Input data too long");
return ERROR_TOO_LONG; return ERROR_TOO_LONG;
@ -1047,10 +1047,10 @@ int grid_matrix(struct zint_symbol *symbol, unsigned char source[], int length)
grid[(y * size) + x] = '0'; grid[(y * size) + x] = '0';
} }
} }
place_data_in_grid(word, grid, modules, size); place_data_in_grid(word, grid, modules, size);
place_layer_id(grid, size, layers, modules, ecc_level); place_layer_id(grid, size, layers, modules, ecc_level);
/* Add macromodule frames */ /* Add macromodule frames */
for(x = 0; x < modules; x++) { for(x = 0; x < modules; x++) {
dark = 1 - (x & 1); dark = 1 - (x & 1);
@ -1073,7 +1073,7 @@ int grid_matrix(struct zint_symbol *symbol, unsigned char source[], int length)
/* Copy values to symbol */ /* Copy values to symbol */
symbol->width = size; symbol->width = size;
symbol->rows = size; symbol->rows = size;
for(x = 0; x < size; x++) { for(x = 0; x < size; x++) {
for(y = 0; y < size; y++) { for(y = 0; y < size; y++) {
if(grid[(y * size) + x] == '1') { if(grid[(y * size) + x] == '1') {
@ -1082,6 +1082,6 @@ int grid_matrix(struct zint_symbol *symbol, unsigned char source[], int length)
} }
symbol->row_height[x] = 1; symbol->row_height[x] = 1;
} }
return 0; return 0;
} }

2
backend/gridmtx.h
View File

@ -18,7 +18,7 @@
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/ */
#define GM_NUMBER 1 #define GM_NUMBER 1
#define GM_LOWER 2 #define GM_LOWER 2
#define GM_UPPER 3 #define GM_UPPER 3
#define GM_MIXED 4 #define GM_MIXED 4

38
backend/gs1.c
View File

@ -36,13 +36,13 @@ void itostr(char ai_string[], int ai_value)
{ {
int thou, hund, ten, unit; int thou, hund, ten, unit;
char temp[2]; char temp[2];
strcpy(ai_string, "("); strcpy(ai_string, "(");
thou = ai_value / 1000; thou = ai_value / 1000;
hund = (ai_value - (1000 * thou)) / 100; hund = (ai_value - (1000 * thou)) / 100;
ten = (ai_value - ((1000 * thou) + (100 * hund))) / 10; ten = (ai_value - ((1000 * thou) + (100 * hund))) / 10;
unit = ai_value - ((1000 * thou) + (100 * hund) + (10 * ten)); unit = ai_value - ((1000 * thou) + (100 * hund) + (10 * ten));
temp[1] = '\0'; temp[1] = '\0';
if(ai_value >= 1000) { temp[0] = itoc(thou); concat(ai_string, temp); } if(ai_value >= 1000) { temp[0] = itoc(thou); concat(ai_string, temp); }
if(ai_value >= 100) { temp[0] = itoc(hund); concat(ai_string, temp); } if(ai_value >= 100) { temp[0] = itoc(hund); concat(ai_string, temp); }
@ -60,7 +60,7 @@ int gs1_verify(struct zint_symbol *symbol, unsigned char source[], const unsigne
int bracket_level, max_bracket_level, ai_length, max_ai_length, min_ai_length; int bracket_level, max_bracket_level, ai_length, max_ai_length, min_ai_length;
int ai_value[100], ai_location[100], ai_count, data_location[100], data_length[100]; int ai_value[100], ai_location[100], ai_count, data_location[100], data_length[100];
int error_latch; int error_latch;
/* 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) {
@ -72,12 +72,12 @@ int gs1_verify(struct zint_symbol *symbol, unsigned char source[], const unsigne
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
} }
} }
if(source[0] != '[') { if(source[0] != '[') {
strcpy(symbol->errtxt, "Data does not start with an AI"); strcpy(symbol->errtxt, "Data does not start with an AI");
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
} }
/* Check the position of the brackets */ /* Check the position of the brackets */
bracket_level = 0; bracket_level = 0;
max_bracket_level = 0; max_bracket_level = 0;
@ -100,37 +100,37 @@ int gs1_verify(struct zint_symbol *symbol, unsigned char source[], const unsigne
if(ai_length > max_ai_length) { max_ai_length = ai_length; } if(ai_length > max_ai_length) { max_ai_length = ai_length; }
} }
min_ai_length--; min_ai_length--;
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)"); strcpy(symbol->errtxt, "Malformed AI in input data (brackets don\'t match)");
return ERROR_INVALID_DATA; return 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"); strcpy(symbol->errtxt, "Found nested brackets in input data");
return ERROR_INVALID_DATA; return 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)"); strcpy(symbol->errtxt, "Invalid AI in input data (AI too long)");
return ERROR_INVALID_DATA; return 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)"); strcpy(symbol->errtxt, "Invalid AI in input data (AI too short)");
return ERROR_INVALID_DATA; return 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)"); strcpy(symbol->errtxt, "Invalid AI in input data (non-numeric characters in AI)");
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
} }
ai_count = 0; ai_count = 0;
for(i = 1; i < src_len; i++) { for(i = 1; i < src_len; i++) {
if(source[i - 1] == '[') { if(source[i - 1] == '[') {
@ -145,7 +145,7 @@ int gs1_verify(struct zint_symbol *symbol, unsigned char source[], const unsigne
ai_count++; ai_count++;
} }
} }
for(i = 0; i < ai_count; i++) { for(i = 0; i < ai_count; i++) {
data_location[i] = ai_location[i] + 3; data_location[i] = ai_location[i] + 3;
if(ai_value[i] >= 100) { data_location[i]++; } if(ai_value[i] >= 100) { data_location[i]++; }
@ -156,7 +156,7 @@ int gs1_verify(struct zint_symbol *symbol, unsigned char source[], const unsigne
} while ((source[data_location[i] + data_length[i] - 1] != '[') && (source[data_location[i] + data_length[i] - 1] != '\0')); } while ((source[data_location[i] + data_length[i] - 1] != '[') && (source[data_location[i] + data_length[i] - 1] != '\0'));
data_length[i]--; data_length[i]--;
} }
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 */
@ -164,7 +164,7 @@ int gs1_verify(struct zint_symbol *symbol, unsigned char source[], const unsigne
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
} }
} }
error_latch = 0; error_latch = 0;
strcpy(ai_string, ""); strcpy(ai_string, "");
for(i = 0; i < ai_count; i++) { for(i = 0; i < ai_count; i++) {
@ -238,13 +238,13 @@ int gs1_verify(struct zint_symbol *symbol, unsigned char source[], const unsigne
error_latch += 4; error_latch += 4;
} }
} }
if(error_latch == 5) { if(error_latch == 5) {
strcpy(symbol->errtxt, "Invalid data length for AI "); strcpy(symbol->errtxt, "Invalid data length for AI ");
concat(symbol->errtxt, ai_string); concat(symbol->errtxt, ai_string);
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
} }
if(error_latch == 6) { if(error_latch == 6) {
strcpy(symbol->errtxt, "Invalid AI value "); strcpy(symbol->errtxt, "Invalid AI value ");
concat(symbol->errtxt, ai_string); concat(symbol->errtxt, ai_string);
@ -284,7 +284,7 @@ int gs1_verify(struct zint_symbol *symbol, unsigned char source[], const unsigne
/* The ']' character is simply dropped from the input */ /* The ']' character is simply dropped from the input */
} }
reduced[j] = '\0'; reduced[j] = '\0';
/* the character '[' in the reduced string refers to the FNC1 character */ /* the character '[' in the reduced string refers to the FNC1 character */
return 0; return 0;
} }
@ -298,10 +298,10 @@ int ugs1_verify(struct zint_symbol *symbol, unsigned char source[], const unsign
char* temp = (char*)_alloca(src_len + 5); char* temp = (char*)_alloca(src_len + 5);
#endif #endif
int error_number; int error_number;
error_number = gs1_verify(symbol, source, src_len, temp); error_number = gs1_verify(symbol, source, src_len, temp);
if(error_number != 0) { return error_number; } if(error_number != 0) { return error_number; }
if (strlen(temp) < src_len + 5) { if (strlen(temp) < src_len + 5) {
ustrcpy(reduced, (unsigned char*)temp); ustrcpy(reduced, (unsigned char*)temp);
return 0; return 0;

136
backend/imail.c
View File

@ -3,26 +3,12 @@
/* /*
libzint - the open source barcode library libzint - the open source barcode library
Copyright (C) 2008 Robin Stuart <robin@zint.org.uk> Copyright (C) 2008 Robin Stuart <robin@zint.org.uk>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/ */
/* The function "USPS_MSB_Math_CRC11GenerateFrameCheckSequence" /* The function "USPS_MSB_Math_CRC11GenerateFrameCheckSequence"
is Copyright (C) 2006 United States Postal Service */ is Copyright (C) 2006 United States Postal Service */
static short int BCD[40] = { static const short int BCD[40] = {
0, 0, 0, 0, 0, 0, 0, 0,
1, 0, 0, 0, 1, 0, 0, 0,
0, 1, 0, 0, 0, 1, 0, 0,
@ -45,7 +31,7 @@ static short int BCD[40] = {
/* The following lookup tables were generated using the code in Appendix C */ /* The following lookup tables were generated using the code in Appendix C */
static unsigned short AppxD_I[1287] = { /* Appendix D Table 1 - 5 of 13 characters */ static const unsigned short AppxD_I[1287] = { /* Appendix D Table 1 - 5 of 13 characters */
0x001F, 0x1F00, 0x002F, 0x1E80, 0x0037, 0x1D80, 0x003B, 0x1B80, 0x003D, 0x1780, 0x001F, 0x1F00, 0x002F, 0x1E80, 0x0037, 0x1D80, 0x003B, 0x1B80, 0x003D, 0x1780,
0x003E, 0x0F80, 0x004F, 0x1E40, 0x0057, 0x1D40, 0x005B, 0x1B40, 0x005D, 0x1740, 0x003E, 0x0F80, 0x004F, 0x1E40, 0x0057, 0x1D40, 0x005B, 0x1B40, 0x005D, 0x1740,
0x005E, 0x0F40, 0x0067, 0x1CC0, 0x006B, 0x1AC0, 0x006D, 0x16C0, 0x006E, 0x0EC0, 0x005E, 0x0F40, 0x0067, 0x1CC0, 0x006B, 0x1AC0, 0x006D, 0x16C0, 0x006E, 0x0EC0,
@ -176,7 +162,7 @@ static unsigned short AppxD_I[1287] = { /* Appendix D Table 1 - 5 of 13 characte
0x1823, 0x1883, 0x1843, 0x1445, 0x1249, 0x1151, 0x10E1, 0x0C46, 0x0A4A, 0x0952, 0x1823, 0x1883, 0x1843, 0x1445, 0x1249, 0x1151, 0x10E1, 0x0C46, 0x0A4A, 0x0952,
0x08E2, 0x064C, 0x0554, 0x04E4, 0x0358, 0x02E8, 0x01F0 }; 0x08E2, 0x064C, 0x0554, 0x04E4, 0x0358, 0x02E8, 0x01F0 };
static unsigned short AppxD_II[78] = { /* Appendix D Table II - 2 of 13 characters */ static const unsigned short AppxD_II[78] = { /* Appendix D Table II - 2 of 13 characters */
0x0003, 0x1800, 0x0005, 0x1400, 0x0006, 0x0C00, 0x0009, 0x1200, 0x000A, 0x0A00, 0x0003, 0x1800, 0x0005, 0x1400, 0x0006, 0x0C00, 0x0009, 0x1200, 0x000A, 0x0A00,
0x000C, 0x0600, 0x0011, 0x1100, 0x0012, 0x0900, 0x0014, 0x0500, 0x0018, 0x0300, 0x000C, 0x0600, 0x0011, 0x1100, 0x0012, 0x0900, 0x0014, 0x0500, 0x0018, 0x0300,
0x0021, 0x1080, 0x0022, 0x0880, 0x0024, 0x0480, 0x0028, 0x0280, 0x0030, 0x0180, 0x0021, 0x1080, 0x0022, 0x0880, 0x0024, 0x0480, 0x0028, 0x0280, 0x0030, 0x0180,
@ -186,14 +172,14 @@ static unsigned short AppxD_II[78] = { /* Appendix D Table II - 2 of 13 characte
0x0201, 0x1008, 0x0202, 0x0808, 0x0204, 0x0408, 0x0401, 0x1004, 0x0402, 0x0804, 0x0201, 0x1008, 0x0202, 0x0808, 0x0204, 0x0408, 0x0401, 0x1004, 0x0402, 0x0804,
0x0801, 0x1002, 0x1001, 0x0802, 0x0404, 0x0208, 0x0110, 0x00A0 }; 0x0801, 0x1002, 0x1001, 0x0802, 0x0404, 0x0208, 0x0110, 0x00A0 };
static int AppxD_IV[130] = { /* Appendix D Table IV - Bar-to-Character Mapping (reverse lookup) */ static const int AppxD_IV[130] = { /* Appendix D Table IV - Bar-to-Character Mapping (reverse lookup) */
67, 6, 78, 16, 86, 95, 34, 40, 45, 113, 117, 121, 62, 87, 18, 104, 41, 76, 57, 119, 115, 72, 97, 67, 6, 78, 16, 86, 95, 34, 40, 45, 113, 117, 121, 62, 87, 18, 104, 41, 76, 57, 119, 115, 72, 97,
2, 127, 26, 105, 35, 122, 52, 114, 7, 24, 82, 68, 63, 94, 44, 77, 112, 70, 100, 39, 30, 107, 2, 127, 26, 105, 35, 122, 52, 114, 7, 24, 82, 68, 63, 94, 44, 77, 112, 70, 100, 39, 30, 107,
15, 125, 85, 10, 65, 54, 88, 20, 106, 46, 66, 8, 116, 29, 61, 99, 80, 90, 37, 123, 51, 25, 84, 15, 125, 85, 10, 65, 54, 88, 20, 106, 46, 66, 8, 116, 29, 61, 99, 80, 90, 37, 123, 51, 25, 84,
129, 56, 4, 109, 96, 28, 36, 47, 11, 71, 33, 102, 21, 9, 17, 49, 124, 79, 64, 91, 42, 69, 53, 129, 56, 4, 109, 96, 28, 36, 47, 11, 71, 33, 102, 21, 9, 17, 49, 124, 79, 64, 91, 42, 69, 53,
60, 14, 1, 27, 103, 126, 75, 89, 50, 120, 19, 32, 110, 92, 111, 130, 59, 31, 12, 81, 43, 55, 60, 14, 1, 27, 103, 126, 75, 89, 50, 120, 19, 32, 110, 92, 111, 130, 59, 31, 12, 81, 43, 55,
5, 74, 22, 101, 128, 58, 118, 48, 108, 38, 98, 93, 23, 83, 13, 73, 3 }; 5, 74, 22, 101, 128, 58, 118, 48, 108, 38, 98, 93, 23, 83, 13, 73, 3 };
/*************************************************************************** /***************************************************************************
** USPS_MSB_Math_CRC11GenerateFrameCheckSequence ** USPS_MSB_Math_CRC11GenerateFrameCheckSequence
** **
@ -248,11 +234,11 @@ extern unsigned short
void breakup(short int fcs_bit[], unsigned short usps_crc) void breakup(short int fcs_bit[], unsigned short usps_crc)
{ {
int i; int i;
for(i = 0; i < 13; i++) { for(i = 0; i < 13; i++) {
fcs_bit[i] = 0; fcs_bit[i] = 0;
} }
if(usps_crc >= 4096) { if(usps_crc >= 4096) {
fcs_bit[12] = 1; fcs_bit[12] = 1;
usps_crc -= 4096; usps_crc -= 4096;
@ -330,12 +316,12 @@ int imail(struct zint_symbol *symbol, unsigned char source[], int length)
strcpy(symbol->errtxt, "Invalid characters in data"); strcpy(symbol->errtxt, "Invalid characters in data");
return error_number; return error_number;
} }
strcpy(zip, ""); strcpy(zip, "");
strcpy(tracker, ""); strcpy(tracker, "");
/* separate the tracking code from the routing code */ /* separate the tracking code from the routing code */
read = 0; read = 0;
j = 0; j = 0;
for(i = 0; i < length; i++) { for(i = 0; i < length; i++) {
@ -360,7 +346,7 @@ int imail(struct zint_symbol *symbol, unsigned char source[], int length)
} else { } else {
zip[read] = '\0'; zip[read] = '\0';
} }
if(strlen(tracker) != 20) { if(strlen(tracker) != 20) {
strcpy(symbol->errtxt, "Invalid length tracking code"); strcpy(symbol->errtxt, "Invalid length tracking code");
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
@ -369,25 +355,25 @@ int imail(struct zint_symbol *symbol, unsigned char source[], int length)
strcpy(symbol->errtxt, "Invalid ZIP code"); strcpy(symbol->errtxt, "Invalid ZIP code");
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
} }
/* *** Step 1 - Conversion of Data Fields into Binary Data *** */ /* *** Step 1 - Conversion of Data Fields into Binary Data *** */
/* Routing code first */ /* Routing code first */
for(i = 0; i < 112; i++) { for(i = 0; i < 112; i++) {
accum[i] = 0; accum[i] = 0;
} }
for(read = 0; read < strlen(zip); read++) { for(read = 0; read < strlen(zip); read++) {
for(i = 0; i < 112; i++) { for(i = 0; i < 112; i++) {
x_reg[i] = accum[i]; x_reg[i] = accum[i];
} }
for(i = 0; i < 9; i++) { for(i = 0; i < 9; i++) {
binary_add(accum, x_reg); binary_add(accum, x_reg);
} }
x_reg[0] = BCD[ctoi(zip[read]) * 4]; x_reg[0] = BCD[ctoi(zip[read]) * 4];
x_reg[1] = BCD[(ctoi(zip[read]) * 4) + 1]; x_reg[1] = BCD[(ctoi(zip[read]) * 4) + 1];
x_reg[2] = BCD[(ctoi(zip[read]) * 4) + 2]; x_reg[2] = BCD[(ctoi(zip[read]) * 4) + 2];
@ -395,16 +381,16 @@ int imail(struct zint_symbol *symbol, unsigned char source[], int length)
for(i = 4; i < 112; i++) { for(i = 4; i < 112; i++) {
x_reg[i] = 0; x_reg[i] = 0;
} }
binary_add(accum, x_reg); binary_add(accum, x_reg);
} }
/* add weight to routing code */ /* add weight to routing code */
for(i = 0; i < 112; i++) { for(i = 0; i < 112; i++) {
x_reg[i] = accum[i]; x_reg[i] = accum[i];
} }
if(strlen(zip) > 9) { if(strlen(zip) > 9) {
strcpy(zip_adder, "1000100001"); strcpy(zip_adder, "1000100001");
} else { } else {
@ -418,21 +404,21 @@ int imail(struct zint_symbol *symbol, unsigned char source[], int length)
} }
} }
} }
for(i = 0; i < 112; i++) { for(i = 0; i < 112; i++) {
accum[i] = 0; accum[i] = 0;
} }
for(read = 0; read < strlen(zip_adder); read++) { for(read = 0; read < strlen(zip_adder); read++) {
for(i = 0; i < 112; i++) { for(i = 0; i < 112; i++) {
y_reg[i] = accum[i]; y_reg[i] = accum[i];
} }
for(i = 0; i < 9; i++) { for(i = 0; i < 9; i++) {
binary_add(accum, y_reg); binary_add(accum, y_reg);
} }
y_reg[0] = BCD[ctoi(zip_adder[read]) * 4]; y_reg[0] = BCD[ctoi(zip_adder[read]) * 4];
y_reg[1] = BCD[(ctoi(zip_adder[read]) * 4) + 1]; y_reg[1] = BCD[(ctoi(zip_adder[read]) * 4) + 1];
y_reg[2] = BCD[(ctoi(zip_adder[read]) * 4) + 2]; y_reg[2] = BCD[(ctoi(zip_adder[read]) * 4) + 2];
@ -440,23 +426,23 @@ int imail(struct zint_symbol *symbol, unsigned char source[], int length)
for(i = 4; i < 112; i++) { for(i = 4; i < 112; i++) {
y_reg[i] = 0; y_reg[i] = 0;
} }
binary_add(accum, y_reg); binary_add(accum, y_reg);
} }
binary_add(accum, x_reg); binary_add(accum, x_reg);
/* tracking code */ /* tracking code */
/* multiply by 10 */ /* multiply by 10 */
for(i = 0; i < 112; i++) { for(i = 0; i < 112; i++) {
y_reg[i] = accum[i]; y_reg[i] = accum[i];
} }
for(i = 0; i < 9; i++) { for(i = 0; i < 9; i++) {
binary_add(accum, y_reg); binary_add(accum, y_reg);
} }
/* add first digit of tracker */ /* add first digit of tracker */
y_reg[0] = BCD[ctoi(tracker[0]) * 4]; y_reg[0] = BCD[ctoi(tracker[0]) * 4];
y_reg[1] = BCD[(ctoi(tracker[0]) * 4) + 1]; y_reg[1] = BCD[(ctoi(tracker[0]) * 4) + 1];
@ -465,18 +451,18 @@ int imail(struct zint_symbol *symbol, unsigned char source[], int length)
for(i = 4; i < 112; i++) { for(i = 4; i < 112; i++) {
y_reg[i] = 0; y_reg[i] = 0;
} }
binary_add(accum, y_reg); binary_add(accum, y_reg);
/* multiply by 5 */ /* multiply by 5 */
for(i = 0; i < 112; i++) { for(i = 0; i < 112; i++) {
y_reg[i] = accum[i]; y_reg[i] = accum[i];
} }
for(i = 0; i < 4; i++) { for(i = 0; i < 4; i++) {
binary_add(accum, y_reg); binary_add(accum, y_reg);
} }
/* add second digit */ /* add second digit */
y_reg[0] = BCD[ctoi(tracker[1]) * 4]; y_reg[0] = BCD[ctoi(tracker[1]) * 4];
y_reg[1] = BCD[(ctoi(tracker[1]) * 4) + 1]; y_reg[1] = BCD[(ctoi(tracker[1]) * 4) + 1];
@ -485,9 +471,9 @@ int imail(struct zint_symbol *symbol, unsigned char source[], int length)
for(i = 4; i < 112; i++) { for(i = 4; i < 112; i++) {
y_reg[i] = 0; y_reg[i] = 0;
} }
binary_add(accum, y_reg); binary_add(accum, y_reg);
/* and then the rest */ /* and then the rest */
for(read = 2; read < strlen(tracker); read++) { for(read = 2; read < strlen(tracker); read++) {
@ -495,11 +481,11 @@ int imail(struct zint_symbol *symbol, unsigned char source[], int length)
for(i = 0; i < 112; i++) { for(i = 0; i < 112; i++) {
y_reg[i] = accum[i]; y_reg[i] = accum[i];
} }
for(i = 0; i < 9; i++) { for(i = 0; i < 9; i++) {
binary_add(accum, y_reg); binary_add(accum, y_reg);
} }
y_reg[0] = BCD[ctoi(tracker[read]) * 4]; y_reg[0] = BCD[ctoi(tracker[read]) * 4];
y_reg[1] = BCD[(ctoi(tracker[read]) * 4) + 1]; y_reg[1] = BCD[(ctoi(tracker[read]) * 4) + 1];
y_reg[2] = BCD[(ctoi(tracker[read]) * 4) + 2]; y_reg[2] = BCD[(ctoi(tracker[read]) * 4) + 2];
@ -507,18 +493,18 @@ int imail(struct zint_symbol *symbol, unsigned char source[], int length)
for(i = 4; i < 112; i++) { for(i = 4; i < 112; i++) {
y_reg[i] = 0; y_reg[i] = 0;
} }
binary_add(accum, y_reg); binary_add(accum, y_reg);
} }
/* printf("Binary data 1: "); /* printf("Binary data 1: ");
hex_dump(accum); */ hex_dump(accum); */
/* *** Step 2 - Generation of 11-bit CRC on Binary Data *** */ /* *** Step 2 - Generation of 11-bit CRC on Binary Data *** */
accum[103] = 0; accum[103] = 0;
accum[102] = 0; accum[102] = 0;
memset(byte_array, 0, 13); memset(byte_array, 0, 13);
for(j = 0; j < 13; j++) { for(j = 0; j < 13; j++) {
i = 96 - (8 * j); i = 96 - (8 * j);
@ -532,25 +518,25 @@ int imail(struct zint_symbol *symbol, unsigned char source[], int length)
byte_array[j] += 64 * accum[i + 6]; byte_array[j] += 64 * accum[i + 6];
byte_array[j] += 128 * accum[i + 7]; byte_array[j] += 128 * accum[i + 7];
} }
usps_crc = USPS_MSB_Math_CRC11GenerateFrameCheckSequence(byte_array); usps_crc = USPS_MSB_Math_CRC11GenerateFrameCheckSequence(byte_array);
/* printf("FCS 2: %4.4X\n", usps_crc); */ /* printf("FCS 2: %4.4X\n", usps_crc); */
/* *** Step 3 - Conversion from Binary Data to Codewords *** */ /* *** Step 3 - Conversion from Binary Data to Codewords *** */
/* start with codeword J which is base 636 */ /* start with codeword J which is base 636 */
for(i = 0; i < 112; i++) { for(i = 0; i < 112; i++) {
x_reg[i] = 0; x_reg[i] = 0;
y_reg[i] = 0; y_reg[i] = 0;
} }
x_reg[101] = 1; x_reg[101] = 1;
x_reg[98] = 1; x_reg[98] = 1;
x_reg[97] = 1; x_reg[97] = 1;
x_reg[96] = 1; x_reg[96] = 1;
x_reg[95] = 1; x_reg[95] = 1;
x_reg[94] = 1; x_reg[94] = 1;
for(i = 92; i >= 0; i--) { for(i = 92; i >= 0; i--) {
y_reg[i] = islarger(accum, x_reg); y_reg[i] = islarger(accum, x_reg);
if(y_reg[i] == 1) { if(y_reg[i] == 1) {
@ -558,13 +544,13 @@ int imail(struct zint_symbol *symbol, unsigned char source[], int length)
} }
shiftdown(x_reg); shiftdown(x_reg);
} }
codeword[9] = (accum[9] * 512) + (accum[8] * 256) + (accum[7] * 128) + (accum[6] * 64) + codeword[9] = (accum[9] * 512) + (accum[8] * 256) + (accum[7] * 128) + (accum[6] * 64) +
(accum[5] * 32) + (accum[4] * 16) + (accum[3] * 8) + (accum[2] * 4) + (accum[5] * 32) + (accum[4] * 16) + (accum[3] * 8) + (accum[2] * 4) +
(accum[1] * 2) + accum[0]; (accum[1] * 2) + accum[0];
/* then codewords I to B with base 1365 */ /* then codewords I to B with base 1365 */
for(j = 8; j > 0; j--) { for(j = 8; j > 0; j--) {
for(i = 0; i < 112; i++) { for(i = 0; i < 112; i++) {
accum[i] = y_reg[i]; accum[i] = y_reg[i];
@ -584,18 +570,18 @@ int imail(struct zint_symbol *symbol, unsigned char source[], int length)
} }
shiftdown(x_reg); shiftdown(x_reg);
} }
codeword[j] = (accum[10] * 1024) + (accum[9] * 512) + (accum[8] * 256) + codeword[j] = (accum[10] * 1024) + (accum[9] * 512) + (accum[8] * 256) +
(accum[7] * 128) + (accum[6] * 64) + (accum[5] * 32) + (accum[7] * 128) + (accum[6] * 64) + (accum[5] * 32) +
(accum[4] * 16) + (accum[3] * 8) + (accum[2] * 4) + (accum[4] * 16) + (accum[3] * 8) + (accum[2] * 4) +
(accum[1] * 2) + accum[0]; (accum[1] * 2) + accum[0];
} }
codeword[0] = (y_reg[10] * 1024) + (y_reg[9] * 512) + (y_reg[8] * 256) + codeword[0] = (y_reg[10] * 1024) + (y_reg[9] * 512) + (y_reg[8] * 256) +
(y_reg[7] * 128) + (y_reg[6] * 64) + (y_reg[5] * 32) + (y_reg[7] * 128) + (y_reg[6] * 64) + (y_reg[5] * 32) +
(y_reg[4] * 16) + (y_reg[3] * 8) + (y_reg[2] * 4) + (y_reg[4] * 16) + (y_reg[3] * 8) + (y_reg[2] * 4) +
(y_reg[1] * 2) + y_reg[0]; (y_reg[1] * 2) + y_reg[0];
for(i = 0; i < 8; i++) { for(i = 0; i < 8; i++) {
if(codeword[i] == 1365) { if(codeword[i] == 1365) {
codeword[i] = 0; codeword[i] = 0;
@ -608,23 +594,23 @@ int imail(struct zint_symbol *symbol, unsigned char source[], int length)
printf("%d ", codeword[i]); printf("%d ", codeword[i]);
} }
printf("\n"); */ printf("\n"); */
/* *** Step 4 - Inserting Additional Information into Codewords *** */ /* *** Step 4 - Inserting Additional Information into Codewords *** */
codeword[9] = codeword[9] * 2; codeword[9] = codeword[9] * 2;
if(usps_crc >= 1024) { if(usps_crc >= 1024) {
codeword[0] += 659; codeword[0] += 659;
} }
/* printf("Codewords 4b: "); /* printf("Codewords 4b: ");
for(i = 0; i < 10; i++) { for(i = 0; i < 10; i++) {
printf("%d ", codeword[i]); printf("%d ", codeword[i]);
} }
printf("\n"); */ printf("\n"); */
/* *** Step 5 - Conversion from Codewords to Characters *** */ /* *** Step 5 - Conversion from Codewords to Characters *** */
for(i = 0; i < 10; i++) { for(i = 0; i < 10; i++) {
if(codeword[i] < 1287) { if(codeword[i] < 1287) {
characters[i] = AppxD_I[codeword[i]]; characters[i] = AppxD_I[codeword[i]];
@ -632,7 +618,7 @@ int imail(struct zint_symbol *symbol, unsigned char source[], int length)
characters[i] = AppxD_II[codeword[i] - 1287]; characters[i] = AppxD_II[codeword[i] - 1287];
} }
} }
/* printf("Characters 5a: "); /* printf("Characters 5a: ");
for(i = 0; i < 10; i++) { for(i = 0; i < 10; i++) {
printf("%4.4X ", characters[i]); printf("%4.4X ", characters[i]);
@ -646,7 +632,7 @@ int imail(struct zint_symbol *symbol, unsigned char source[], int length)
characters[i] = 0x1FFF - characters[i]; characters[i] = 0x1FFF - characters[i];
} }
} }
/* printf("Characters 5b: "); /* printf("Characters 5b: ");
for(i = 0; i < 10; i++) { for(i = 0; i < 10; i++) {
printf("%4.4X ", characters[i]); printf("%4.4X ", characters[i]);
@ -654,14 +640,14 @@ int imail(struct zint_symbol *symbol, unsigned char source[], int length)
printf("\n"); */ printf("\n"); */
/* *** Step 6 - Conversion from Characters to the Intelligent Mail Barcode *** */ /* *** Step 6 - Conversion from Characters to the Intelligent Mail Barcode *** */
for(i = 0; i < 10; i++) { for(i = 0; i < 10; i++) {
breakup(bit_pattern, characters[i]); breakup(bit_pattern, characters[i]);
for(j = 0; j < 13; j++) { for(j = 0; j < 13; j++) {
bar_map[AppxD_IV[(13 * i) + j] - 1] = bit_pattern[j]; bar_map[AppxD_IV[(13 * i) + j] - 1] = bit_pattern[j];
} }
} }
strcpy(data_pattern, ""); strcpy(data_pattern, "");
temp[1] = '\0'; temp[1] = '\0';
for(i = 0; i < 65; i++) { for(i = 0; i < 65; i++) {
@ -673,7 +659,7 @@ int imail(struct zint_symbol *symbol, unsigned char source[], int length)
temp[0] = itoc(j); temp[0] = itoc(j);
concat(data_pattern, temp); concat(data_pattern, temp);
} }
/* Translate 4-state data pattern to symbol */ /* Translate 4-state data pattern to symbol */
read = 0; read = 0;
for(i = 0; i < strlen(data_pattern); i++) for(i = 0; i < strlen(data_pattern); i++)

32
backend/large.c
View File

@ -24,7 +24,7 @@
#include "common.h" #include "common.h"
#include "large.h" #include "large.h"
static short int BCD[40] = { static const short int BCD[40] = {
0, 0, 0, 0, 0, 0, 0, 0,
1, 0, 0, 0, 1, 0, 0, 0,
0, 1, 0, 0, 0, 1, 0, 0,
@ -91,7 +91,7 @@ void binary_subtract(short int accumulator[], short int input_buffer[])
/* take input_buffer from accumulator and put answer in accumulator */ /* take input_buffer from accumulator and put answer in accumulator */
int i; int i;
short int sub_buffer[112]; short int sub_buffer[112];
for(i = 0; i < 112; i++) { for(i = 0; i < 112; i++) {
if(input_buffer[i] == 0) { if(input_buffer[i] == 0) {
sub_buffer[i] = 1; sub_buffer[i] = 1;
@ -100,9 +100,9 @@ void binary_subtract(short int accumulator[], short int input_buffer[])
} }
} }
binary_add(accumulator, sub_buffer); binary_add(accumulator, sub_buffer);
sub_buffer[0] = 1; sub_buffer[0] = 1;
for(i = 1; i < 112; i++) { for(i = 1; i < 112; i++) {
sub_buffer[i] = 0; sub_buffer[i] = 0;
} }
@ -112,7 +112,7 @@ void binary_subtract(short int accumulator[], short int input_buffer[])
void shiftdown(short int buffer[]) void shiftdown(short int buffer[])
{ {
int i; int i;
buffer[102] = 0; buffer[102] = 0;
buffer[103] = 0; buffer[103] = 0;
@ -124,11 +124,11 @@ void shiftdown(short int buffer[])
void shiftup(short int buffer[]) void shiftup(short int buffer[])
{ {
int i; int i;
for(i = 102; i > 0; i--) { for(i = 102; i > 0; i--) {
buffer[i] = buffer[i - 1]; buffer[i] = buffer[i - 1];
} }
buffer[0] = 0; buffer[0] = 0;
} }
@ -139,8 +139,8 @@ short int islarger(short int accum[], short int reg[])
latch = 0; latch = 0;
i = 103; i = 103;
larger = 0; larger = 0;
do { do {
if((accum[i] == 1) && (reg[i] == 0)) { if((accum[i] == 1) && (reg[i] == 0)) {
latch = 1; latch = 1;
@ -151,7 +151,7 @@ short int islarger(short int accum[], short int reg[])
} }
i--; i--;
} while ((latch == 0) && (i >= -1)); } while ((latch == 0) && (i >= -1));
return larger; return larger;
} }
@ -159,21 +159,21 @@ void binary_load(short int reg[], char data[], const unsigned int src_len)
{ {
int read, i; int read, i;
short int temp[112] = { 0 }; short int temp[112] = { 0 };
for(i = 0; i < 112; i++) { for(i = 0; i < 112; i++) {
reg[i] = 0; reg[i] = 0;
} }
for(read = 0; read < src_len; read++) { for(read = 0; read < src_len; read++) {
for(i = 0; i < 112; i++) { for(i = 0; i < 112; i++) {
temp[i] = reg[i]; temp[i] = reg[i];
} }
for(i = 0; i < 9; i++) { for(i = 0; i < 9; i++) {
binary_add(reg, temp); binary_add(reg, temp);
} }
temp[0] = BCD[ctoi(data[read]) * 4]; temp[0] = BCD[ctoi(data[read]) * 4];
temp[1] = BCD[(ctoi(data[read]) * 4) + 1]; temp[1] = BCD[(ctoi(data[read]) * 4) + 1];
temp[2] = BCD[(ctoi(data[read]) * 4) + 2]; temp[2] = BCD[(ctoi(data[read]) * 4) + 2];
@ -181,12 +181,12 @@ void binary_load(short int reg[], char data[], const unsigned int src_len)
for(i = 4; i < 112; i++) { for(i = 4; i < 112; i++) {
temp[i] = 0; temp[i] = 0;
} }
binary_add(reg, temp); binary_add(reg, temp);
} }
} }
void hex_dump(short int input_buffer[]) void hex_dump(short int input_buffer[])
{ {
int i, digit, byte_space; int i, digit, byte_space;

90
backend/library.c
View File

@ -34,7 +34,7 @@ struct zint_symbol *ZBarcode_Create()
{ {
struct zint_symbol *symbol; struct zint_symbol *symbol;
int i; int i;
symbol = (struct zint_symbol*)malloc(sizeof(*symbol)); symbol = (struct zint_symbol*)malloc(sizeof(*symbol));
if (!symbol) return NULL; if (!symbol) return NULL;
@ -69,7 +69,7 @@ struct zint_symbol *ZBarcode_Create()
void ZBarcode_Clear(struct zint_symbol *symbol) void ZBarcode_Clear(struct zint_symbol *symbol)
{ {
int i, j; int i, j;
for(i = 0; i < symbol->rows; i++) { for(i = 0; i < symbol->rows; i++) {
for(j = 0; j < symbol->width; j++) { for(j = 0; j < symbol->width; j++) {
unset_module(symbol, i, j); unset_module(symbol, i, j);
@ -188,16 +188,16 @@ extern int svg_plot(struct zint_symbol *symbol);
void error_tag(char error_string[], int error_number) void error_tag(char error_string[], int error_number)
{ {
char error_buffer[100]; char error_buffer[100];
if(error_number != 0) { if(error_number != 0) {
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: ");
} }
concat(error_string, error_buffer); concat(error_string, error_buffer);
} }
} }
@ -240,7 +240,7 @@ int hibc(struct zint_symbol *symbol, unsigned char source[], int length)
{ {
int counter, error_number, i; int counter, error_number, i;
char to_process[40], temp[2], check_digit; char to_process[40], temp[2], check_digit;
if(length > 36) { if(length > 36) {
strcpy(symbol->errtxt, "Data too long for HIBC LIC"); strcpy(symbol->errtxt, "Data too long for HIBC LIC");
return ERROR_TOO_LONG; return ERROR_TOO_LONG;
@ -251,14 +251,14 @@ int hibc(struct zint_symbol *symbol, unsigned char source[], int length)
strcpy(symbol->errtxt, "Invalid characters in data"); strcpy(symbol->errtxt, "Invalid characters in data");
return error_number; return error_number;
} }
strcpy(to_process, "+"); strcpy(to_process, "+");
counter = 41; counter = 41;
for(i = 0; i < length; i++) { for(i = 0; i < length; i++) {
counter += posn(TECHNETIUM, source[i]); counter += posn(TECHNETIUM, source[i]);
} }
counter = counter % 43; counter = counter % 43;
if(counter < 10) { if(counter < 10) {
check_digit = itoc(counter); check_digit = itoc(counter);
} else { } else {
@ -277,14 +277,14 @@ int hibc(struct zint_symbol *symbol, unsigned char source[], int length)
} }
} }
} }
temp[0] = check_digit; temp[0] = check_digit;
temp[1] = '\0'; temp[1] = '\0';
concat(to_process, (char *)source); concat(to_process, (char *)source);
concat(to_process, temp); concat(to_process, temp);
length = strlen(to_process); length = strlen(to_process);
switch(symbol->symbology) { switch(symbol->symbology) {
case BARCODE_HIBC_128: case BARCODE_HIBC_128:
error_number = code_128(symbol, (unsigned char *)to_process, length); error_number = code_128(symbol, (unsigned char *)to_process, length);
@ -315,16 +315,16 @@ int hibc(struct zint_symbol *symbol, unsigned char source[], int length)
error_number = aztec(symbol, (unsigned char *)to_process, length); error_number = aztec(symbol, (unsigned char *)to_process, length);
break; break;
} }
return error_number; return error_number;
} }
int gs1_compliant(int symbology) int gs1_compliant(int symbology)
{ {
/* Returns 1 if symbology supports GS1 data */ /* Returns 1 if symbology supports GS1 data */
int result = 0; int result = 0;
switch(symbology) { switch(symbology) {
case BARCODE_EAN128: case BARCODE_EAN128:
case BARCODE_RSS_EXP: case BARCODE_RSS_EXP:
@ -348,14 +348,14 @@ int gs1_compliant(int symbology)
result = 1; result = 1;
break; break;
} }
return result; return result;
} }
int ZBarcode_ValidID(int symbol_id) int ZBarcode_ValidID(int symbol_id)
{ {
/* Checks whether a symbology is supported */ /* Checks whether a symbology is supported */
int result = 0; int result = 0;
switch(symbol_id) { switch(symbol_id) {
@ -444,14 +444,14 @@ int ZBarcode_ValidID(int symbol_id)
result = 1; result = 1;
break; break;
} }
return result; return result;
} }
int extended_charset(struct zint_symbol *symbol, unsigned char *source, int length) int extended_charset(struct zint_symbol *symbol, unsigned char *source, int length)
{ {
int error_number = 0; int error_number = 0;
/* These are the "elite" standards which can support multiple character sets */ /* These are the "elite" standards which can support multiple character sets */
switch(symbol->symbology) { switch(symbol->symbology) {
case BARCODE_QRCODE: error_number = qr_code(symbol, source, length); break; case BARCODE_QRCODE: error_number = qr_code(symbol, source, length); break;
@ -478,13 +478,13 @@ int reduced_charset(struct zint_symbol *symbol, unsigned char *source, int lengt
symbol->border_width = 2; symbol->border_width = 2;
symbol->output_options = BARCODE_BIND; symbol->output_options = BARCODE_BIND;
} }
if(symbol->symbology == BARCODE_ITF14) { if(symbol->symbology == BARCODE_ITF14) {
symbol->whitespace_width = 20; symbol->whitespace_width = 20;
symbol->border_width = 8; symbol->border_width = 8;
symbol->output_options = BARCODE_BOX; symbol->output_options = BARCODE_BOX;
} }
switch(symbol->input_mode) { switch(symbol->input_mode) {
case DATA_MODE: case DATA_MODE:
case GS1_MODE: case GS1_MODE:
@ -578,7 +578,7 @@ int reduced_charset(struct zint_symbol *symbol, unsigned char *source, int lengt
case BARCODE_MAXICODE: error_number = maxicode(symbol, preprocessed, length); break; case BARCODE_MAXICODE: error_number = maxicode(symbol, preprocessed, length); break;
case BARCODE_AZTEC: error_number = aztec(symbol, preprocessed, length); break; case BARCODE_AZTEC: error_number = aztec(symbol, preprocessed, length); break;
} }
return error_number; return error_number;
} }
@ -650,9 +650,9 @@ int ZBarcode_Encode(struct zint_symbol *symbol, unsigned char *source, int lengt
} else { } else {
error_buffer = error_number; error_buffer = error_number;
} }
if((symbol->input_mode < 0) || (symbol->input_mode > 2)) { symbol->input_mode = DATA_MODE; } if((symbol->input_mode < 0) || (symbol->input_mode > 2)) { symbol->input_mode = DATA_MODE; }
if(symbol->input_mode == GS1_MODE) { if(symbol->input_mode == GS1_MODE) {
for(i = 0; i < length; i++) { for(i = 0; i < length; i++) {
if(source[i] == '\0') { if(source[i] == '\0') {
@ -672,7 +672,7 @@ int ZBarcode_Encode(struct zint_symbol *symbol, unsigned char *source, int lengt
memcpy(local_source, source, length); memcpy(local_source, source, length);
local_source[length] = '\0'; local_source[length] = '\0';
} }
switch(symbol->symbology) { switch(symbol->symbology) {
case BARCODE_QRCODE: case BARCODE_QRCODE:
case BARCODE_MICROQR: case BARCODE_MICROQR:
@ -683,7 +683,7 @@ int ZBarcode_Encode(struct zint_symbol *symbol, unsigned char *source, int lengt
error_number = reduced_charset(symbol, local_source, length); error_number = reduced_charset(symbol, local_source, length);
break; break;
} }
if((symbol->symbology == BARCODE_CODE128) || (symbol->symbology == BARCODE_CODE128B)) { if((symbol->symbology == BARCODE_CODE128) || (symbol->symbology == BARCODE_CODE128B)) {
for(i = 0; i < length; i++) { for(i = 0; i < length; i++) {
if(local_source[i] == '\0') { if(local_source[i] == '\0') {
@ -693,7 +693,7 @@ int ZBarcode_Encode(struct zint_symbol *symbol, unsigned char *source, int lengt
} }
} }
} }
if(error_number == 0) { if(error_number == 0) {
error_number = error_buffer; error_number = error_buffer;
} }
@ -706,7 +706,7 @@ int ZBarcode_Print(struct zint_symbol *symbol, int rotate_angle)
{ {
int error_number; int error_number;
char output[4]; char output[4];
switch(rotate_angle) { switch(rotate_angle) {
case 0: case 0:
case 90: case 90:
@ -718,7 +718,7 @@ int ZBarcode_Print(struct zint_symbol *symbol, int rotate_angle)
return ERROR_INVALID_OPTION; return ERROR_INVALID_OPTION;
break; break;
} }
if(strlen(symbol->outfile) > 3) { if(strlen(symbol->outfile) > 3) {
output[0] = symbol->outfile[strlen(symbol->outfile) - 3]; output[0] = symbol->outfile[strlen(symbol->outfile) - 3];
output[1] = symbol->outfile[strlen(symbol->outfile) - 2]; output[1] = symbol->outfile[strlen(symbol->outfile) - 2];
@ -759,7 +759,7 @@ int ZBarcode_Print(struct zint_symbol *symbol, int rotate_angle)
int ZBarcode_Buffer(struct zint_symbol *symbol, int rotate_angle) int ZBarcode_Buffer(struct zint_symbol *symbol, int rotate_angle)
{ {
int error_number; int error_number;
switch(rotate_angle) { switch(rotate_angle) {
case 0: case 0:
case 90: case 90:
@ -771,7 +771,7 @@ int ZBarcode_Buffer(struct zint_symbol *symbol, int rotate_angle)
return ERROR_INVALID_OPTION; return ERROR_INVALID_OPTION;
break; break;
} }
error_number = bmp_handle(symbol, rotate_angle); error_number = bmp_handle(symbol, rotate_angle);
error_tag(symbol->errtxt, error_number); error_tag(symbol->errtxt, error_number);
return error_number; return error_number;
@ -780,9 +780,9 @@ int ZBarcode_Buffer(struct zint_symbol *symbol, int rotate_angle)
int ZBarcode_Encode_and_Print(struct zint_symbol *symbol, unsigned char *input, int length, int rotate_angle) int ZBarcode_Encode_and_Print(struct zint_symbol *symbol, unsigned char *input, int length, int rotate_angle)
{ {
int error_number; int error_number;
error_number = 0; error_number = 0;
error_number = ZBarcode_Encode(symbol, input, length); error_number = ZBarcode_Encode(symbol, input, length);
if(error_number != 0) { if(error_number != 0) {
return error_number; return error_number;
@ -795,9 +795,9 @@ int ZBarcode_Encode_and_Print(struct zint_symbol *symbol, unsigned char *input,
int ZBarcode_Encode_and_Buffer(struct zint_symbol *symbol, unsigned char *input, int length, int rotate_angle) int ZBarcode_Encode_and_Buffer(struct zint_symbol *symbol, unsigned char *input, int length, int rotate_angle)
{ {
int error_number; int error_number;
error_number = 0; error_number = 0;
error_number = ZBarcode_Encode(symbol, input, length); error_number = ZBarcode_Encode(symbol, input, length);
if(error_number != 0) { if(error_number != 0) {
return error_number; return error_number;
@ -824,12 +824,12 @@ int ZBarcode_Encode_File(struct zint_symbol *symbol, char *filename)
strcpy(symbol->errtxt, "Unable to read input file"); strcpy(symbol->errtxt, "Unable to read input file");
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
} }
/* Get file length */ /* Get file length */
fseek(file, 0, SEEK_END); fseek(file, 0, SEEK_END);
fileLen = ftell(file); fileLen = ftell(file);
fseek(file, 0, SEEK_SET); fseek(file, 0, SEEK_SET);
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"); strcpy(symbol->errtxt, "Input file too long");
@ -837,7 +837,7 @@ int ZBarcode_Encode_File(struct zint_symbol *symbol, char *filename)
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
} }
} }
/* Allocate memory */ /* Allocate memory */
buffer = (unsigned char *)malloc(fileLen * sizeof(unsigned char)); buffer = (unsigned char *)malloc(fileLen * sizeof(unsigned char));
if(!buffer) { if(!buffer) {
@ -846,7 +846,7 @@ int ZBarcode_Encode_File(struct zint_symbol *symbol, char *filename)
fclose(file); fclose(file);
return ERROR_MEMORY; return ERROR_MEMORY;
} }
/* Read file contents into buffer */ /* Read file contents into buffer */
do do
@ -860,7 +860,7 @@ int ZBarcode_Encode_File(struct zint_symbol *symbol, char *filename)
} }
nRead += n; nRead += n;
} while (!feof(file) && (0 < n) && (nRead < fileLen)); } while (!feof(file) && (0 < n) && (nRead < fileLen));
fclose(file); fclose(file);
ret = ZBarcode_Encode(symbol, buffer, nRead); ret = ZBarcode_Encode(symbol, buffer, nRead);
free(buffer); free(buffer);
@ -870,28 +870,28 @@ int ZBarcode_Encode_File(struct zint_symbol *symbol, char *filename)
int ZBarcode_Encode_File_and_Print(struct zint_symbol *symbol, char *filename, int rotate_angle) int ZBarcode_Encode_File_and_Print(struct zint_symbol *symbol, char *filename, int rotate_angle)
{ {
int error_number; int error_number;
error_number = 0; error_number = 0;
error_number = ZBarcode_Encode_File(symbol, filename); error_number = ZBarcode_Encode_File(symbol, filename);
if(error_number != 0) { if(error_number != 0) {
return error_number; return error_number;
} }
return ZBarcode_Print(symbol, rotate_angle); return ZBarcode_Print(symbol, rotate_angle);
} }
int ZBarcode_Encode_File_and_Buffer(struct zint_symbol *symbol, char *filename, int rotate_angle) int ZBarcode_Encode_File_and_Buffer(struct zint_symbol *symbol, char *filename, int rotate_angle)
{ {
int error_number; int error_number;
error_number = 0; error_number = 0;
error_number = ZBarcode_Encode_File(symbol, filename); error_number = ZBarcode_Encode_File(symbol, filename);
if(error_number != 0) { if(error_number != 0) {
return error_number; return error_number;
} }
return ZBarcode_Buffer(symbol, rotate_angle); return ZBarcode_Buffer(symbol, rotate_angle);
} }

6
backend/maxicode.h
View File

@ -19,7 +19,7 @@
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/ */
static int MaxiGrid[] = { /* ISO/IEC 16023 Figure 5 - MaxiCode Module Sequence */ /* 30 x 33 data grid */ static const int MaxiGrid[] = { /* ISO/IEC 16023 Figure 5 - MaxiCode Module Sequence */ /* 30 x 33 data grid */
122, 121, 128, 127, 134, 133, 140, 139, 146, 145, 152, 151, 158, 157, 164, 163, 170, 169, 176, 175, 182, 181, 188, 187, 194, 193, 200, 199, 0, 0, 122, 121, 128, 127, 134, 133, 140, 139, 146, 145, 152, 151, 158, 157, 164, 163, 170, 169, 176, 175, 182, 181, 188, 187, 194, 193, 200, 199, 0, 0,
124, 123, 130, 129, 136, 135, 142, 141, 148, 147, 154, 153, 160, 159, 166, 165, 172, 171, 178, 177, 184, 183, 190, 189, 196, 195, 202, 201, 817, 0, 124, 123, 130, 129, 136, 135, 142, 141, 148, 147, 154, 153, 160, 159, 166, 165, 172, 171, 178, 177, 184, 183, 190, 189, 196, 195, 202, 201, 817, 0,
126, 125, 132, 131, 138, 137, 144, 143, 150, 149, 156, 155, 162, 161, 168, 167, 174, 173, 180, 179, 186, 185, 192, 191, 198, 197, 204, 203, 819, 818, 126, 125, 132, 131, 138, 137, 144, 143, 150, 149, 156, 155, 162, 161, 168, 167, 174, 173, 180, 179, 186, 185, 192, 191, 198, 197, 204, 203, 819, 818,
@ -55,7 +55,7 @@ static int MaxiGrid[] = { /* ISO/IEC 16023 Figure 5 - MaxiCode Module Sequence *
738, 737, 744, 743, 750, 749, 756, 755, 762, 761, 768, 767, 774, 773, 780, 779, 786, 785, 792, 791, 798, 797, 804, 803, 810, 809, 816, 815, 864, 863 738, 737, 744, 743, 750, 749, 756, 755, 762, 761, 768, 767, 774, 773, 780, 779, 786, 785, 792, 791, 798, 797, 804, 803, 810, 809, 816, 815, 864, 863
}; };
int maxiCodeSet[256] = { /* from Appendix A - ASCII character to Code Set (e.g. 2 = Set B) */ static const int maxiCodeSet[256] = { /* from Appendix A - ASCII character to Code Set (e.g. 2 = Set B) */
/* set 0 refers to special characters that fit into more than one set (e.g. GS) */ /* set 0 refers to special characters that fit into more than one set (e.g. GS) */
5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0, 5, 5, 5, 5, 5, 5,
5, 5, 5, 5, 5, 5, 5, 5, 0, 0, 0, 5, 0, 2, 1, 1, 1, 1, 1, 1, 5, 5, 5, 5, 5, 5, 5, 5, 0, 0, 0, 5, 0, 2, 1, 1, 1, 1, 1, 1,
@ -72,7 +72,7 @@ int maxiCodeSet[256] = { /* from Appendix A - ASCII character to Code Set (e.g.
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4
}; };
int maxiSymbolChar[256] = { /* from Appendix A - ASCII character to symbol value */ static const int maxiSymbolChar[256] = { /* from Appendix A - ASCII character to symbol value */
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
20, 21, 22, 23, 24, 25, 26, 30, 28, 29, 30, 35, 32, 53, 34, 35, 36, 37, 38, 39, 20, 21, 22, 23, 24, 25, 26, 30, 28, 29, 30, 35, 32, 53, 34, 35, 36, 37, 38, 39,
40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 37, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 37,

4
backend/maxipng.h
View File

@ -25,7 +25,7 @@
#define SSET "0123456789ABCDEF" #define SSET "0123456789ABCDEF"
static int hexagon[120] = { static const int hexagon[120] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0,
0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0,
@ -40,7 +40,7 @@ static int hexagon[120] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
}; };
static unsigned int bullseye_compressed[] = { static const unsigned int bullseye_compressed[] = {
0,0,0,0,0,255,248,0,0,0,0,0, 0,0,0,0,0,255,248,0,0,0,0,0,
0,0,0,0,31,255,255,192,0,0,0,0, 0,0,0,0,31,255,255,192,0,0,0,0,
0,0,0,1,255,255,255,252,0,0,0,0, 0,0,0,1,255,255,255,252,0,0,0,0,

30
backend/medical.c
View File

@ -37,7 +37,7 @@ int pharma_one(struct zint_symbol *symbol, unsigned char source[], int length)
int counter, error_number, h; int counter, error_number, h;
char inter[18] = { 0 }; /* 131070 -> 17 bits */ char inter[18] = { 0 }; /* 131070 -> 17 bits */
char dest[64]; /* 17 * 2 + 1 */ char dest[64]; /* 17 * 2 + 1 */
error_number = 0; error_number = 0;
if(length > 6) { if(length > 6) {
@ -78,7 +78,7 @@ int pharma_one(struct zint_symbol *symbol, unsigned char source[], int length)
concat(dest, "12"); concat(dest, "12");
} }
} }
expand(symbol, dest); expand(symbol, dest);
return error_number; return error_number;
@ -95,7 +95,7 @@ int pharma_two_calc(struct zint_symbol *symbol, unsigned char source[], char des
int counter, h; int counter, h;
char inter[17]; char inter[17];
int error_number; int error_number;
tester = atoi((char*)source); tester = atoi((char*)source);
if((tester < 4) || (tester > 64570080)) if((tester < 4) || (tester > 64570080))
@ -130,7 +130,7 @@ int pharma_two_calc(struct zint_symbol *symbol, unsigned char source[], char des
dest[h - counter] = inter[counter]; dest[h - counter] = inter[counter];
} }
dest[h + 1] = '\0'; dest[h + 1] = '\0';
return error_number; return error_number;
} }
@ -173,7 +173,7 @@ int pharma_two(struct zint_symbol *symbol, unsigned char source[], int length)
} }
symbol->rows = 2; symbol->rows = 2;
symbol->width = writer - 1; symbol->width = writer - 1;
return error_number; return error_number;
} }
@ -183,7 +183,7 @@ int codabar(struct zint_symbol *symbol, unsigned char source[], int length)
int i, error_number; int i, error_number;
char dest[512]; char dest[512];
error_number = 0; error_number = 0;
strcpy(dest, ""); strcpy(dest, "");
@ -215,7 +215,7 @@ int codabar(struct zint_symbol *symbol, unsigned char source[], int length)
{ {
lookup(CALCIUM, CodaTable, source[i], dest); lookup(CALCIUM, CodaTable, source[i], dest);
} }
expand(symbol, dest); expand(symbol, dest);
ustrcpy(symbol->text, source); ustrcpy(symbol->text, source);
return error_number; return error_number;
@ -228,7 +228,7 @@ int code32(struct zint_symbol *symbol, unsigned char source[], int length)
long int pharmacode, remainder, devisor; long int pharmacode, remainder, devisor;
int codeword[6]; int codeword[6];
char tabella[34]; char tabella[34];
/* Validate the input */ /* Validate the input */
if(length > 8) { if(length > 8) {
strcpy(symbol->errtxt, "Input too long"); strcpy(symbol->errtxt, "Input too long");
@ -239,12 +239,12 @@ int code32(struct zint_symbol *symbol, unsigned char source[], int length)
strcpy(symbol->errtxt, "Invalid characters in data"); strcpy(symbol->errtxt, "Invalid characters in data");
return error_number; return error_number;
} }
/* Add leading zeros as required */ /* Add leading zeros as required */
zeroes = 8 - length; zeroes = 8 - length;
memset(localstr, '0', zeroes); memset(localstr, '0', zeroes);
strcpy(localstr + zeroes, (char*)source); strcpy(localstr + zeroes, (char*)source);
/* Calculate the check digit */ /* Calculate the check digit */
checksum = 0; checksum = 0;
checkpart = 0; checkpart = 0;
@ -258,12 +258,12 @@ int code32(struct zint_symbol *symbol, unsigned char source[], int length)
checksum += checkpart; checksum += checkpart;
} }
} }
/* Add check digit to data string */ /* Add check digit to data string */
checkdigit = checksum % 10; checkdigit = checksum % 10;
localstr[8] = itoc(checkdigit); localstr[8] = itoc(checkdigit);
localstr[9] = '\0'; localstr[9] = '\0';
/* Convert string into an integer value */ /* Convert string into an integer value */
pharmacode = atoi(localstr); pharmacode = atoi(localstr);
@ -275,7 +275,7 @@ int code32(struct zint_symbol *symbol, unsigned char source[], int length)
pharmacode = remainder; pharmacode = remainder;
devisor /= 32; devisor /= 32;
} }
/* Look up values in 'Tabella di conversione' */ /* Look up values in 'Tabella di conversione' */
strcpy(tabella, "0123456789BCDFGHJKLMNPQRSTUVWXYZ"); strcpy(tabella, "0123456789BCDFGHJKLMNPQRSTUVWXYZ");
for(i = 5; i >= 0; i--) { for(i = 5; i >= 0; i--) {
@ -285,10 +285,10 @@ int code32(struct zint_symbol *symbol, unsigned char source[], int length)
/* Plot the barcode using Code 39 */ /* Plot the barcode using Code 39 */
error_number = c39(symbol, (unsigned char*)risultante, strlen(risultante)); error_number = c39(symbol, (unsigned char*)risultante, strlen(risultante));
if(error_number != 0) { return error_number; } if(error_number != 0) { return error_number; }
/* Override the normal text output with the Pharmacode number */ /* Override the normal text output with the Pharmacode number */
ustrcpy(symbol->text, (unsigned char*)"A"); ustrcpy(symbol->text, (unsigned char*)"A");
uconcat(symbol->text, (unsigned char*)localstr); uconcat(symbol->text, (unsigned char*)localstr);
return error_number; return error_number;
} }

136
backend/pdf417.c
View File

@ -74,7 +74,7 @@ int quelmode(char codeascii)
void regroupe(int *indexliste) void regroupe(int *indexliste)
{ {
int i, j; int i, j;
/* bring together same type blocks */ /* bring together same type blocks */
if(*(indexliste) > 1) { if(*(indexliste) > 1) {
i = 1; i = 1;
@ -83,7 +83,7 @@ void regroupe(int *indexliste)
/* bring together */ /* bring together */
liste[0][i - 1] = liste[0][i - 1] + liste[0][i]; liste[0][i - 1] = liste[0][i - 1] + liste[0][i];
j = i + 1; j = i + 1;
/* decreace the list */ /* decreace the list */
while(j < *(indexliste)) { while(j < *(indexliste)) {
liste[0][j - 1] = liste[0][j]; liste[0][j - 1] = liste[0][j];
@ -103,13 +103,13 @@ void regroupe(int *indexliste)
void pdfsmooth(int *indexliste) void pdfsmooth(int *indexliste)
{ {
int i, crnt, last, next, length; int i, crnt, last, next, length;
for(i = 0; i < *(indexliste); i++) { for(i = 0; i < *(indexliste); i++) {
crnt = liste[1][i]; crnt = liste[1][i];
length = liste[0][i]; length = liste[0][i];
if(i != 0) { last = liste[1][i - 1]; } else { last = FALSE; } if(i != 0) { last = liste[1][i - 1]; } else { last = FALSE; }
if(i != *(indexliste) - 1) { next = liste[1][i + 1]; } else { next = FALSE; } if(i != *(indexliste) - 1) { next = liste[1][i + 1]; } else { next = FALSE; }
if(crnt == NUM) { if(crnt == NUM) {
if(i == 0) { /* first block */ if(i == 0) { /* first block */
if(*(indexliste) > 1) { /* and there are others */ if(*(indexliste) > 1) { /* and there are others */
@ -136,7 +136,7 @@ void pdfsmooth(int *indexliste)
length = liste[0][i]; length = liste[0][i];
if(i != 0) { last = liste[1][i - 1]; } else { last = FALSE; } if(i != 0) { last = liste[1][i - 1]; } else { last = FALSE; }
if(i != *(indexliste) - 1) { next = liste[1][i + 1]; } else { next = FALSE; } if(i != *(indexliste) - 1) { next = liste[1][i + 1]; } else { next = FALSE; }
if((crnt == TEX) && (i > 0)) { /* not the first */ if((crnt == TEX) && (i > 0)) { /* not the first */
if(i == *(indexliste) - 1) { /* the last one */ if(i == *(indexliste) - 1) { /* the last one */
if((last == BYT) && (length == 1)) { liste[1][i] = BYT; } if((last == BYT) && (length == 1)) { liste[1][i] = BYT; }
@ -157,10 +157,10 @@ void textprocess(int *chainemc, int *mclength, char chaine[], int start, int len
{ {
int j, indexlistet, curtable, listet[2][5000], chainet[5000], wnet; int j, indexlistet, curtable, listet[2][5000], chainet[5000], wnet;
char codeascii; char codeascii;
codeascii = 0; codeascii = 0;
wnet = 0; wnet = 0;
for(j = 0; j < 1000; j++) { for(j = 0; j < 1000; j++) {
listet[0][j] = 0; listet[0][j] = 0;
} }
@ -189,7 +189,7 @@ void textprocess(int *chainemc, int *mclength, char chaine[], int start, int len
} else { } else {
if(!(listet[0][j] & listet[0][j + 1])) { flag = TRUE; } if(!(listet[0][j] & listet[0][j + 1])) { flag = TRUE; }
} }
if (flag) { /* we change only one character - look for temporary switch */ if (flag) { /* we change only one character - look for temporary switch */
if((listet[0][j] & 1) && (curtable == 2)) { /* T_UPP */ if((listet[0][j] & 1) && (curtable == 2)) { /* T_UPP */
chainet[wnet] = 27; chainet[wnet] = 27;
@ -206,11 +206,11 @@ void textprocess(int *chainemc, int *mclength, char chaine[], int start, int len
flag = FALSE; flag = FALSE;
} }
} }
/* 599 */ /* 599 */
if (!(flag)) { if (!(flag)) {
int newtable; int newtable;
if(j == (length - 1)) { if(j == (length - 1)) {
newtable = listet[0][j]; newtable = listet[0][j];
} else { } else {
@ -220,7 +220,7 @@ void textprocess(int *chainemc, int *mclength, char chaine[], int start, int len
newtable = listet[0][j] & listet[0][j + 1]; newtable = listet[0][j] & listet[0][j + 1];
} }
} }
/* Maintain the first if several tables are possible */ /* Maintain the first if several tables are possible */
switch (newtable) { switch (newtable) {
case 3: case 3:
@ -238,16 +238,16 @@ void textprocess(int *chainemc, int *mclength, char chaine[], int start, int len
case 12: case 12:
newtable = 4; break; newtable = 4; break;
} }
/* 619 - select the switch */ /* 619 - select the switch */
switch (curtable) { switch (curtable) {
case 1: case 1:
switch (newtable) { switch (newtable) {
case 2: chainet[wnet] = 27; wnet++; break; case 2: chainet[wnet] = 27; wnet++; break;
case 4: chainet[wnet] = 28; wnet++; break; case 4: chainet[wnet] = 28; wnet++; break;
case 8: chainet[wnet] = 28; wnet++; chainet[wnet] = 25; wnet++; break; case 8: chainet[wnet] = 28; wnet++; chainet[wnet] = 25; wnet++; break;
} break; } break;
case 2: case 2:
switch (newtable) { switch (newtable) {
case 1: chainet[wnet] = 28; wnet++; chainet[wnet] = 28; wnet++; break; case 1: chainet[wnet] = 28; wnet++; chainet[wnet] = 28; wnet++; break;
case 4: chainet[wnet] = 28; wnet++; break; case 4: chainet[wnet] = 28; wnet++; break;
@ -273,7 +273,7 @@ void textprocess(int *chainemc, int *mclength, char chaine[], int start, int len
} }
} }
} }
/* 663 */ /* 663 */
if (wnet & 1) { if (wnet & 1) {
chainet[wnet] = 29; chainet[wnet] = 29;
@ -282,14 +282,14 @@ void textprocess(int *chainemc, int *mclength, char chaine[], int start, int len
/* Now translate the string chainet into codewords */ /* Now translate the string chainet into codewords */
chainemc[*(mclength)] = 900; chainemc[*(mclength)] = 900;
*(mclength) = *(mclength) + 1; *(mclength) = *(mclength) + 1;
for(j = 0; j < wnet; j+= 2) { for(j = 0; j < wnet; j+= 2) {
int cw_number; int cw_number;
cw_number = (30 * chainet[j]) + chainet[j + 1]; cw_number = (30 * chainet[j]) + chainet[j + 1];
chainemc[*(mclength)] = cw_number; chainemc[*(mclength)] = cw_number;
*(mclength) = *(mclength) + 1; *(mclength) = *(mclength) + 1;
} }
} }
@ -301,7 +301,7 @@ void byteprocess(int *chainemc, int *mclength, unsigned char chaine[], int start
unsigned int chunkLen = 0; unsigned int chunkLen = 0;
uint64_t mantisa = 0ULL; uint64_t mantisa = 0ULL;
uint64_t total = 0ULL; uint64_t total = 0ULL;
if(debug) printf("\nEntering byte mode at position %d\n", start); if(debug) printf("\nEntering byte mode at position %d\n", start);
if(length == 1) { if(length == 1) {
@ -317,7 +317,7 @@ void byteprocess(int *chainemc, int *mclength, unsigned char chaine[], int start
chainemc[(*mclength)++] = 901; chainemc[(*mclength)++] = 901;
if(debug) printf("901 "); if(debug) printf("901 ");
} }
while (len < length) while (len < length)
{ {
chunkLen = length - len; chunkLen = length - len;
@ -359,12 +359,12 @@ void numbprocess(int *chainemc, int *mclength, char chaine[], int start, int len
{ {
int j, loop, longueur, dummy[100], dumlength, diviseur, nombre; int j, loop, longueur, dummy[100], dumlength, diviseur, nombre;
char chainemod[50], chainemult[100], temp; char chainemod[50], chainemult[100], temp;
strcpy(chainemod, ""); strcpy(chainemod, "");
for(loop = 0; loop <= 50; loop++) { for(loop = 0; loop <= 50; loop++) {
dummy[loop] = 0; dummy[loop] = 0;
} }
chainemc[*(mclength)] = 902; chainemc[*(mclength)] = 902;
*(mclength) = *(mclength) + 1; *(mclength) = *(mclength) + 1;
@ -381,7 +381,7 @@ void numbprocess(int *chainemc, int *mclength, char chaine[], int start, int len
chainemod[longueur + 1] = '\0'; chainemod[longueur + 1] = '\0';
do { do {
diviseur = 900; diviseur = 900;
/* 877 - gosub Modulo */ /* 877 - gosub Modulo */
strcpy(chainemult, ""); strcpy(chainemult, "");
nombre = 0; nombre = 0;
@ -402,7 +402,7 @@ void numbprocess(int *chainemc, int *mclength, char chaine[], int start, int len
} }
diviseur = nombre; diviseur = nombre;
/* return to 723 */ /* return to 723 */
for(loop = dumlength; loop > 0; loop--) { for(loop = dumlength; loop > 0; loop--) {
dummy[loop] = dummy[loop - 1]; dummy[loop] = dummy[loop - 1];
} }
@ -431,13 +431,13 @@ int pdf417(struct zint_symbol *symbol, unsigned char chaine[], int length)
/* 456 */ /* 456 */
indexliste = 0; indexliste = 0;
indexchaine = 0; indexchaine = 0;
mode = quelmode(chaine[indexchaine]); mode = quelmode(chaine[indexchaine]);
for(i = 0; i < 1000; i++) { for(i = 0; i < 1000; i++) {
liste[0][i] = 0; liste[0][i] = 0;
} }
/* 463 */ /* 463 */
do { do {
liste[1][indexliste] = mode; liste[1][indexliste] = mode;
@ -448,7 +448,7 @@ int pdf417(struct zint_symbol *symbol, unsigned char chaine[], int length)
} }
indexliste++; indexliste++;
} while (indexchaine < length); } while (indexchaine < length);
/* 474 */ /* 474 */
pdfsmooth(&indexliste); pdfsmooth(&indexliste);
@ -464,7 +464,7 @@ int pdf417(struct zint_symbol *symbol, unsigned char chaine[], int length)
} }
} }
} }
/* 541 - now compress the data */ /* 541 - now compress the data */
indexchaine = 0; indexchaine = 0;
mclength = 0; mclength = 0;
@ -517,16 +517,16 @@ int pdf417(struct zint_symbol *symbol, unsigned char chaine[], int length)
/* stop the symbol from becoming too high */ /* stop the symbol from becoming too high */
symbol->option_2 = symbol->option_2 + 1; symbol->option_2 = symbol->option_2 + 1;
} }
if(longueur + k > 928) { if(longueur + k > 928) {
/* Enforce maximum codeword limit */ /* Enforce maximum codeword limit */
return 2; return 2;
} }
if(((longueur + k) / symbol->option_2) > 90) { if(((longueur + k) / symbol->option_2) > 90) {
return 4; return 4;
} }
/* 781 - Padding calculation */ /* 781 - Padding calculation */
longueur = mclength + 1 + k; longueur = mclength + 1 + k;
i = 0; i = 0;
@ -573,17 +573,17 @@ int pdf417(struct zint_symbol *symbol, unsigned char chaine[], int length)
} }
mccorrection[0] = (929 - (total * coefrs[offset + j]) % 929) % 929; mccorrection[0] = (929 - (total * coefrs[offset + j]) % 929) % 929;
} }
/* we add these codes to the string */ /* we add these codes to the string */
for(i = k - 1; i >= 0; i--) { for(i = k - 1; i >= 0; i--) {
chainemc[mclength++] = mccorrection[i] ? 929 - mccorrection[i] : 0; chainemc[mclength++] = mccorrection[i] ? 929 - mccorrection[i] : 0;
} }
/* 818 - The CW string is finished */ /* 818 - The CW string is finished */
c1 = (mclength / symbol->option_2 - 1) / 3; c1 = (mclength / symbol->option_2 - 1) / 3;
c2 = symbol->option_1 * 3 + (mclength / symbol->option_2 - 1) % 3; c2 = symbol->option_1 * 3 + (mclength / symbol->option_2 - 1) % 3;
c3 = symbol->option_2 - 1; c3 = symbol->option_2 - 1;
/* we now encode each row */ /* we now encode each row */
for(i = 0; i <= (mclength / symbol->option_2) - 1; i++) { for(i = 0; i <= (mclength / symbol->option_2) - 1; i++) {
for(j = 0; j < symbol->option_2 ; j++) { for(j = 0; j < symbol->option_2 ; j++) {
@ -635,7 +635,7 @@ int pdf417(struct zint_symbol *symbol, unsigned char chaine[], int length)
} }
concat(codebarre, "-"); concat(codebarre, "-");
} }
strcpy(pattern, ""); strcpy(pattern, "");
for(loop = 0; loop < strlen(codebarre); loop++) { for(loop = 0; loop < strlen(codebarre); loop++) {
lookup(BRSET, PDFttf, codebarre[loop], pattern); lookup(BRSET, PDFttf, codebarre[loop], pattern);
@ -649,7 +649,7 @@ int pdf417(struct zint_symbol *symbol, unsigned char chaine[], int length)
} }
symbol->rows = (mclength / symbol->option_2); symbol->rows = (mclength / symbol->option_2);
symbol->width = strlen(pattern); symbol->width = strlen(pattern);
/* 843 */ /* 843 */
return codeerr; return codeerr;
} }
@ -660,7 +660,7 @@ int pdf417enc(struct zint_symbol *symbol, unsigned char source[], int length)
int codeerr, error_number; int codeerr, error_number;
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"); strcpy(symbol->errtxt, "Security value out of range");
symbol->option_1 = -1; symbol->option_1 = -1;
@ -674,7 +674,7 @@ int pdf417enc(struct zint_symbol *symbol, unsigned char source[], int length)
/* 349 */ /* 349 */
codeerr = pdf417(symbol, source, length); codeerr = pdf417(symbol, source, length);
/* 352 */ /* 352 */
if(codeerr != 0) { if(codeerr != 0) {
switch(codeerr) { switch(codeerr) {
@ -700,7 +700,7 @@ int pdf417enc(struct zint_symbol *symbol, unsigned char source[], int length)
break; break;
} }
} }
/* 364 */ /* 364 */
return error_number; return error_number;
} }
@ -708,27 +708,27 @@ int pdf417enc(struct zint_symbol *symbol, unsigned char source[], int length)
int micro_pdf417(struct zint_symbol *symbol, unsigned char chaine[], int length) int micro_pdf417(struct zint_symbol *symbol, unsigned char chaine[], int length)
{ /* like PDF417 only much smaller! */ { /* like PDF417 only much smaller! */
int i, k, j, indexchaine, indexliste, mode, longueur, mccorrection[50], offset; int i, k, j, indexchaine, indexliste, mode, longueur, mccorrection[50], offset;
int total, chainemc[2700], mclength, dummy[5], codeerr; int total, chainemc[2700], mclength, dummy[5], codeerr;
char codebarre[100], pattern[580]; char codebarre[100], pattern[580];
int variant, LeftRAPStart, CentreRAPStart, RightRAPStart, StartCluster; int variant, LeftRAPStart, CentreRAPStart, RightRAPStart, StartCluster;
int LeftRAP, CentreRAP, RightRAP, Cluster, writer, flip, loop; int LeftRAP, CentreRAP, RightRAP, Cluster, writer, flip, loop;
int debug = 0; int debug = 0;
/* Encoding starts out the same as PDF417, so use the same code */ /* Encoding starts out the same as PDF417, so use the same code */
codeerr = 0; codeerr = 0;
/* 456 */ /* 456 */
indexliste = 0; indexliste = 0;
indexchaine = 0; indexchaine = 0;
mode = quelmode(chaine[indexchaine]); mode = quelmode(chaine[indexchaine]);
for(i = 0; i < 1000; i++) { for(i = 0; i < 1000; i++) {
liste[0][i] = 0; liste[0][i] = 0;
} }
/* 463 */ /* 463 */
do { do {
liste[1][indexliste] = mode; liste[1][indexliste] = mode;
@ -755,7 +755,7 @@ int micro_pdf417(struct zint_symbol *symbol, unsigned char chaine[], int length)
} }
} }
} }
/* 541 - now compress the data */ /* 541 - now compress the data */
indexchaine = 0; indexchaine = 0;
mclength = 0; mclength = 0;
@ -779,7 +779,7 @@ int micro_pdf417(struct zint_symbol *symbol, unsigned char chaine[], int length)
} }
/* 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"); strcpy(symbol->errtxt, "Input data too long");
return ERROR_TOO_LONG; return ERROR_TOO_LONG;
@ -797,32 +797,32 @@ int micro_pdf417(struct zint_symbol *symbol, unsigned char chaine[], int length)
} }
printf("\n"); printf("\n");
} }
/* Now figure out which variant of the symbol to use and load values accordingly */ /* Now figure out which variant of the symbol to use and load values accordingly */
variant = 0; variant = 0;
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"); strcpy(symbol->errtxt, "Specified symbol size too small for data");
codeerr = WARN_INVALID_OPTION; codeerr = 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"); strcpy(symbol->errtxt, "Specified symbol size too small for data");
codeerr = WARN_INVALID_OPTION; codeerr = 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"); strcpy(symbol->errtxt, "Specified symbol size too small for data");
codeerr = WARN_INVALID_OPTION; codeerr = WARN_INVALID_OPTION;
} }
if(symbol->option_2 == 1) { if(symbol->option_2 == 1) {
/* the user specified 1 column and the data does fit */ /* the user specified 1 column and the data does fit */
variant = 6; variant = 6;
@ -876,7 +876,7 @@ int micro_pdf417(struct zint_symbol *symbol, unsigned char chaine[], int length)
if(variant == 0) { if(variant == 0) {
/* Zint can choose automatically from all available variations */ /* Zint can choose automatically from all available variations */
for(i = 27; i >= 0; i--) { for(i = 27; i >= 0; i--) {
if(MicroAutosize[i] >= mclength) { if(MicroAutosize[i] >= mclength) {
variant = MicroAutosize[i + 28]; variant = MicroAutosize[i + 28];
} }
@ -905,7 +905,7 @@ int micro_pdf417(struct zint_symbol *symbol, unsigned char chaine[], int length)
mclength++; mclength++;
i--; i--;
} }
/* Reed-Solomon error correction */ /* Reed-Solomon error correction */
longueur = mclength; longueur = mclength;
for(loop = 0; loop < 50; loop++) { for(loop = 0; loop < 50; loop++) {
@ -922,7 +922,7 @@ int micro_pdf417(struct zint_symbol *symbol, unsigned char chaine[], int length)
} }
} }
} }
for(j = 0; j < k; j++) { for(j = 0; j < k; j++) {
if(mccorrection[j] != 0) { mccorrection[j] = 929 - mccorrection[j]; } if(mccorrection[j] != 0) { mccorrection[j] = 929 - mccorrection[j]; }
} }
@ -939,20 +939,20 @@ int micro_pdf417(struct zint_symbol *symbol, unsigned char chaine[], int length)
} }
printf("\n"); printf("\n");
} }
/* Now get the RAP (Row Address Pattern) start values */ /* Now get the RAP (Row Address Pattern) start values */
LeftRAPStart = RAPTable[variant]; LeftRAPStart = RAPTable[variant];
CentreRAPStart = RAPTable[variant + 34]; CentreRAPStart = RAPTable[variant + 34];
RightRAPStart = RAPTable[variant + 68]; RightRAPStart = RAPTable[variant + 68];
StartCluster = RAPTable[variant + 102] / 3; StartCluster = RAPTable[variant + 102] / 3;
/* That's all values loaded, get on with the encoding */ /* That's all values loaded, get on with the encoding */
LeftRAP = LeftRAPStart; LeftRAP = LeftRAPStart;
CentreRAP = CentreRAPStart; CentreRAP = CentreRAPStart;
RightRAP = RightRAPStart; RightRAP = RightRAPStart;
Cluster = StartCluster; /* Cluster can be 0, 1 or 2 for Cluster(0), Cluster(3) and Cluster(6) */ Cluster = StartCluster; /* Cluster can be 0, 1 or 2 for Cluster(0), Cluster(3) and Cluster(6) */
if(debug) printf("\nInternal row representation:\n"); if(debug) printf("\nInternal row representation:\n");
for(i = 0; i < symbol->rows; i++) { for(i = 0; i < symbol->rows; i++) {
if(debug) printf("row %d: ", i); if(debug) printf("row %d: ", i);
@ -965,7 +965,7 @@ int micro_pdf417(struct zint_symbol *symbol, unsigned char chaine[], int length)
dummy[j + 1] = chainemc[i * symbol->option_2 + j]; dummy[j + 1] = chainemc[i * symbol->option_2 + j];
if(debug) printf("[%d] ", dummy[j + 1]); if(debug) printf("[%d] ", dummy[j + 1]);
} }
/* Copy the data into codebarre */ /* Copy the data into codebarre */
concat(codebarre, RAPLR[LeftRAP]); concat(codebarre, RAPLR[LeftRAP]);
concat(codebarre, "1"); concat(codebarre, "1");
@ -995,9 +995,9 @@ int micro_pdf417(struct zint_symbol *symbol, unsigned char chaine[], int length)
concat(codebarre, RAPLR[RightRAP]); concat(codebarre, RAPLR[RightRAP]);
concat(codebarre, "1"); /* stop */ concat(codebarre, "1"); /* stop */
if(debug) printf("%s\n", codebarre); if(debug) printf("%s\n", codebarre);
/* Now codebarre is a mixture of letters and numbers */ /* Now codebarre is a mixture of letters and numbers */
writer = 0; writer = 0;
flip = 1; flip = 1;
strcpy(pattern, ""); strcpy(pattern, "");
@ -1023,19 +1023,19 @@ int micro_pdf417(struct zint_symbol *symbol, unsigned char chaine[], int length)
} }
} }
symbol->width = writer; symbol->width = writer;
/* so now pattern[] holds the string of '1's and '0's. - copy this to the symbol */ /* so now pattern[] holds the string of '1's and '0's. - copy this to the symbol */
for(loop = 0; loop < strlen(pattern); loop++) { for(loop = 0; loop < strlen(pattern); loop++) {
if(pattern[loop] == '1') { set_module(symbol, i, loop); } if(pattern[loop] == '1') { set_module(symbol, i, loop); }
} }
symbol->row_height[i] = 2; symbol->row_height[i] = 2;
/* Set up RAPs and Cluster for next row */ /* Set up RAPs and Cluster for next row */
LeftRAP++; LeftRAP++;
CentreRAP++; CentreRAP++;
RightRAP++; RightRAP++;
Cluster++; Cluster++;
if(LeftRAP == 53) { if(LeftRAP == 53) {
LeftRAP = 1; LeftRAP = 1;
} }
@ -1049,7 +1049,7 @@ int micro_pdf417(struct zint_symbol *symbol, unsigned char chaine[], int length)
Cluster = 0; Cluster = 0;
} }
} }
return codeerr; return codeerr;
} }

52
backend/plessey.c
View File

@ -39,12 +39,12 @@ int plessey(struct zint_symbol *symbol, unsigned char source[], int length)
unsigned int i, check; unsigned int i, check;
unsigned char *checkptr; unsigned char *checkptr;
static char grid[9] = {1,1,1,1,0,1,0,0,1}; static const char grid[9] = {1,1,1,1,0,1,0,0,1};
char dest[1024]; /* 8 + 65 * 8 + 8 * 2 + 9 + 1 ~ 1024 */ char dest[1024]; /* 8 + 65 * 8 + 8 * 2 + 9 + 1 ~ 1024 */
int error_number; int error_number;
error_number = 0; error_number = 0;
if(length > 65) { if(length > 65) {
strcpy(symbol->errtxt, "Input too long"); strcpy(symbol->errtxt, "Input too long");
return ERROR_TOO_LONG; return ERROR_TOO_LONG;
@ -90,7 +90,7 @@ int plessey(struct zint_symbol *symbol, unsigned char source[], int length)
/* Stop character */ /* Stop character */
concat(dest, "331311313"); concat(dest, "331311313");
expand(symbol, dest); expand(symbol, dest);
ustrcpy(symbol->text, source); ustrcpy(symbol->text, source);
free(checkptr); free(checkptr);
@ -102,7 +102,7 @@ int msi_plessey(struct zint_symbol *symbol, unsigned char source[], int length)
unsigned int i; unsigned int i;
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"); strcpy(symbol->errtxt, "Input too long");
return ERROR_TOO_LONG; return ERROR_TOO_LONG;
@ -118,7 +118,7 @@ int msi_plessey(struct zint_symbol *symbol, unsigned char source[], int length)
/* Stop character */ /* Stop character */
concat (dest, "121"); concat (dest, "121");
expand(symbol, dest); expand(symbol, dest);
ustrcpy(symbol->text, source); ustrcpy(symbol->text, source);
return 0; return 0;
@ -132,7 +132,7 @@ int msi_plessey_mod10(struct zint_symbol *symbol, unsigned char source[], int le
char un[200], tri[32]; char un[200], tri[32];
int error_number, h; int error_number, h;
char dest[1000]; char dest[1000];
error_number = 0; error_number = 0;
if(length > 18) { if(length > 18) {
@ -203,9 +203,9 @@ int msi_plessey_mod1010(struct zint_symbol *symbol, unsigned char source[], cons
char un[16], tri[32]; char un[16], tri[32];
int error_number, h; int error_number, h;
char dest[1000]; char dest[1000];
error_number = 0; error_number = 0;
if(src_len > 18) { /* No Entry Stack Smashers! limit because of str->number conversion*/ if(src_len > 18) { /* No Entry Stack Smashers! limit because of str->number conversion*/
strcpy(symbol->errtxt, "Input too long"); strcpy(symbol->errtxt, "Input too long");
return ERROR_TOO_LONG; return ERROR_TOO_LONG;
@ -295,7 +295,7 @@ int msi_plessey_mod1010(struct zint_symbol *symbol, unsigned char source[], cons
/* Stop character */ /* Stop character */
concat (dest, "121"); concat (dest, "121");
expand(symbol, dest); expand(symbol, dest);
ustrcpy(symbol->text, source); ustrcpy(symbol->text, source);
@ -312,21 +312,21 @@ int msi_plessey_mod11(struct zint_symbol *symbol, unsigned char source[], const
/* Calculate a Modulo 11 check digit using the system discussed on Wikipedia - /* Calculate a Modulo 11 check digit using the system discussed on Wikipedia -
see http://en.wikipedia.org/wiki/Talk:MSI_Barcode */ see http://en.wikipedia.org/wiki/Talk:MSI_Barcode */
/* uses the IBM weight system */ /* uses the IBM weight system */
int i, weight, x, check; int i, weight, x, check;
int error_number; int error_number;
char dest[1000]; char dest[1000];
error_number = 0; error_number = 0;
if(src_len > 55) { if(src_len > 55) {
strcpy(symbol->errtxt, "Input too long"); strcpy(symbol->errtxt, "Input too long");
return ERROR_TOO_LONG; return ERROR_TOO_LONG;
} }
/* start character */ /* start character */
strcpy(dest, "21"); strcpy(dest, "21");
/* draw data section */ /* draw data section */
for(i = 0; i < src_len; i++) for(i = 0; i < src_len; i++)
{ {
@ -343,7 +343,7 @@ int msi_plessey_mod11(struct zint_symbol *symbol, unsigned char source[], const
weight = 2; weight = 2;
} }
} }
check = (11 - (x % 11)) % 11; check = (11 - (x % 11)) % 11;
if(check == 10) { if(check == 10) {
lookup(NEON, MSITable, '1', dest); lookup(NEON, MSITable, '1', dest);
@ -351,10 +351,10 @@ int msi_plessey_mod11(struct zint_symbol *symbol, unsigned char source[], const
} else { } else {
lookup(NEON, MSITable, itoc(check), dest); lookup(NEON, MSITable, itoc(check), dest);
} }
/* stop character */ /* stop character */
concat (dest, "121"); concat (dest, "121");
expand(symbol, dest); expand(symbol, dest);
ustrcpy(symbol->text, source); ustrcpy(symbol->text, source);
@ -364,7 +364,7 @@ int msi_plessey_mod11(struct zint_symbol *symbol, unsigned char source[], const
symbol->text[src_len] = itoc(check); symbol->text[src_len] = itoc(check);
symbol->text[src_len + 1] = '\0'; symbol->text[src_len + 1] = '\0';
} }
return error_number; return error_number;
} }
@ -373,24 +373,24 @@ int msi_plessey_mod1110(struct zint_symbol *symbol, unsigned char source[], cons
/* Combining the Barcode Island and Wikipedia code */ /* Combining the Barcode Island and Wikipedia code */
/* Verified against http://www.bokai.com/BarcodeJSP/applet/BarcodeSampleApplet.htm */ /* Verified against http://www.bokai.com/BarcodeJSP/applet/BarcodeSampleApplet.htm */
/* Weighted using the IBM system */ /* Weighted using the IBM system */
unsigned long i, weight, x, check, wright, dau, pedwar, pump, h; unsigned long i, weight, x, check, wright, dau, pedwar, pump, h;
char un[16], tri[16]; char un[16], tri[16];
int error_number; int error_number;
char dest[1000]; char dest[1000];
unsigned char temp[32]; unsigned char temp[32];
unsigned int temp_len; unsigned int temp_len;
error_number = 0; error_number = 0;
if(src_len > 18) { if(src_len > 18) {
strcpy(symbol->errtxt, "Input too long"); strcpy(symbol->errtxt, "Input too long");
return ERROR_TOO_LONG; return ERROR_TOO_LONG;
} }
/* start character */ /* start character */
strcpy(dest, "21"); strcpy(dest, "21");
/* draw data section */ /* draw data section */
for(i = 0; i < src_len; i++) for(i = 0; i < src_len; i++)
{ {
@ -407,7 +407,7 @@ int msi_plessey_mod1110(struct zint_symbol *symbol, unsigned char source[], cons
weight = 2; weight = 2;
} }
} }
check = (11 - (x % 11)) % 11; check = (11 - (x % 11)) % 11;
ustrcpy(temp, source); ustrcpy(temp, source);
temp_len = src_len; temp_len = src_len;
@ -421,7 +421,7 @@ int msi_plessey_mod1110(struct zint_symbol *symbol, unsigned char source[], cons
temp[temp_len++] = itoc(check); temp[temp_len++] = itoc(check);
temp[temp_len] = '\0'; temp[temp_len] = '\0';
} }
/* caluculate second (mod 10) check digit */ /* caluculate second (mod 10) check digit */
wright = 0; wright = 0;
i = !(temp_len & 1); i = !(temp_len & 1);
@ -478,7 +478,7 @@ int msi_handle(struct zint_symbol *symbol, unsigned char source[], int length) {
strcpy(symbol->errtxt, "Invalid characters in input data"); strcpy(symbol->errtxt, "Invalid characters in input data");
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
} }
if((symbol->option_2 < 0) || (symbol->option_2 > 4)) { if((symbol->option_2 < 0) || (symbol->option_2 > 4)) {
symbol->option_2 = 0; symbol->option_2 = 0;
@ -491,6 +491,6 @@ int msi_handle(struct zint_symbol *symbol, unsigned char source[], int length) {
case 3: error_number = msi_plessey_mod11(symbol, source, length); break; case 3: error_number = msi_plessey_mod11(symbol, source, length); break;
case 4: error_number = msi_plessey_mod1110(symbol, source, length); break; case 4: error_number = msi_plessey_mod1110(symbol, source, length); break;
} }
return error_number; return error_number;
} }

144
backend/png.c
View File

@ -85,7 +85,7 @@ int png_pixel_plot(struct zint_symbol *symbol, int image_height, int image_width
unsigned char *image_data; unsigned char *image_data;
int i, row, column, errno; int i, row, column, errno;
int fgred, fggrn, fgblu, bgred, bggrn, bgblu; int fgred, fggrn, fgblu, bgred, bggrn, bgblu;
switch(rotate_angle) { switch(rotate_angle) {
case 0: case 0:
case 180: case 180:
@ -98,11 +98,11 @@ int png_pixel_plot(struct zint_symbol *symbol, int image_height, int image_width
graphic->height = image_width; graphic->height = image_width;
break; break;
} }
/* sort out colour options */ /* sort out colour options */
to_upper((unsigned char*)symbol->fgcolour); to_upper((unsigned char*)symbol->fgcolour);
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"); strcpy(symbol->errtxt, "Malformed foreground colour target");
return ERROR_INVALID_OPTION; return ERROR_INVALID_OPTION;
@ -121,14 +121,14 @@ int png_pixel_plot(struct zint_symbol *symbol, int image_height, int image_width
strcpy(symbol->errtxt, "Malformed background colour target"); strcpy(symbol->errtxt, "Malformed background colour target");
return ERROR_INVALID_OPTION; return ERROR_INVALID_OPTION;
} }
fgred = (16 * ctoi(symbol->fgcolour[0])) + ctoi(symbol->fgcolour[1]); fgred = (16 * ctoi(symbol->fgcolour[0])) + ctoi(symbol->fgcolour[1]);
fggrn = (16 * ctoi(symbol->fgcolour[2])) + ctoi(symbol->fgcolour[3]); fggrn = (16 * ctoi(symbol->fgcolour[2])) + ctoi(symbol->fgcolour[3]);
fgblu = (16 * ctoi(symbol->fgcolour[4])) + ctoi(symbol->fgcolour[5]); fgblu = (16 * ctoi(symbol->fgcolour[4])) + ctoi(symbol->fgcolour[5]);
bgred = (16 * ctoi(symbol->bgcolour[0])) + ctoi(symbol->bgcolour[1]); bgred = (16 * ctoi(symbol->bgcolour[0])) + ctoi(symbol->bgcolour[1]);
bggrn = (16 * ctoi(symbol->bgcolour[2])) + ctoi(symbol->bgcolour[3]); bggrn = (16 * ctoi(symbol->bgcolour[2])) + ctoi(symbol->bgcolour[3]);
bgblu = (16 * ctoi(symbol->bgcolour[4])) + ctoi(symbol->bgcolour[5]); bgblu = (16 * ctoi(symbol->bgcolour[4])) + ctoi(symbol->bgcolour[5]);
/* Open output file in binary mode */ /* Open output file in binary mode */
if((symbol->output_options & BARCODE_STDOUT) != 0) { if((symbol->output_options & BARCODE_STDOUT) != 0) {
#ifdef _MSC_VER #ifdef _MSC_VER
@ -144,7 +144,7 @@ int png_pixel_plot(struct zint_symbol *symbol, int image_height, int image_width
return ERROR_FILE_ACCESS; return ERROR_FILE_ACCESS;
} }
} }
/* 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) {
@ -203,7 +203,7 @@ int png_pixel_plot(struct zint_symbol *symbol, int image_height, int image_width
outdata[i + 1] = bggrn; outdata[i + 1] = bggrn;
outdata[i + 2] = bgblu; outdata[i + 2] = bgblu;
break; break;
} }
} }
/* write row contents to file */ /* write row contents to file */
@ -227,10 +227,10 @@ int png_pixel_plot(struct zint_symbol *symbol, int image_height, int image_width
outdata[i + 1] = bggrn; outdata[i + 1] = bggrn;
outdata[i + 2] = bgblu; outdata[i + 2] = bgblu;
break; break;
} }
} }
/* write row contents to file */ /* write row contents to file */
image_data = outdata; image_data = outdata;
png_write_row(png_ptr, image_data); png_write_row(png_ptr, image_data);
@ -252,10 +252,10 @@ int png_pixel_plot(struct zint_symbol *symbol, int image_height, int image_width
outdata[i + 1] = bggrn; outdata[i + 1] = bggrn;
outdata[i + 2] = bgblu; outdata[i + 2] = bgblu;
break; break;
} }
} }
/* write row contents to file */ /* write row contents to file */
image_data = outdata; image_data = outdata;
png_write_row(png_ptr, image_data); png_write_row(png_ptr, image_data);
@ -277,7 +277,7 @@ int png_pixel_plot(struct zint_symbol *symbol, int image_height, int image_width
outdata[i + 1] = bggrn; outdata[i + 1] = bggrn;
outdata[i + 2] = bgblu; outdata[i + 2] = bgblu;
break; break;
} }
} }
@ -302,7 +302,7 @@ int bmp_pixel_plot(struct zint_symbol *symbol, int image_height, int image_width
{ {
int i, row, column, errno; int i, row, column, errno;
int fgred, fggrn, fgblu, bgred, bggrn, bgblu; int fgred, fggrn, fgblu, bgred, bggrn, bgblu;
switch(rotate_angle) { switch(rotate_angle) {
case 0: case 0:
case 180: case 180:
@ -315,17 +315,17 @@ int bmp_pixel_plot(struct zint_symbol *symbol, int image_height, int image_width
symbol->bitmap_height = image_width; symbol->bitmap_height = image_width;
break; break;
} }
if (symbol->bitmap != NULL) if (symbol->bitmap != NULL)
free(symbol->bitmap); free(symbol->bitmap);
symbol->bitmap = (char *) malloc(image_width * image_height * 3); symbol->bitmap = (char *) malloc(image_width * image_height * 3);
/* sort out colour options */ /* sort out colour options */
to_upper((unsigned char*)symbol->fgcolour); to_upper((unsigned char*)symbol->fgcolour);
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"); strcpy(symbol->errtxt, "Malformed foreground colour target");
return ERROR_INVALID_OPTION; return ERROR_INVALID_OPTION;
@ -344,7 +344,7 @@ int bmp_pixel_plot(struct zint_symbol *symbol, int image_height, int image_width
strcpy(symbol->errtxt, "Malformed background colour target"); strcpy(symbol->errtxt, "Malformed background colour target");
return ERROR_INVALID_OPTION; return ERROR_INVALID_OPTION;
} }
fgred = (16 * ctoi(symbol->fgcolour[0])) + ctoi(symbol->fgcolour[1]); fgred = (16 * ctoi(symbol->fgcolour[0])) + ctoi(symbol->fgcolour[1]);
fggrn = (16 * ctoi(symbol->fgcolour[2])) + ctoi(symbol->fgcolour[3]); fggrn = (16 * ctoi(symbol->fgcolour[2])) + ctoi(symbol->fgcolour[3]);
fgblu = (16 * ctoi(symbol->fgcolour[4])) + ctoi(symbol->fgcolour[5]); fgblu = (16 * ctoi(symbol->fgcolour[4])) + ctoi(symbol->fgcolour[5]);
@ -370,7 +370,7 @@ int bmp_pixel_plot(struct zint_symbol *symbol, int image_height, int image_width
symbol->bitmap[i++] = bggrn; symbol->bitmap[i++] = bggrn;
symbol->bitmap[i++] = bgblu; symbol->bitmap[i++] = bgblu;
break; break;
} }
} }
} }
@ -390,7 +390,7 @@ int bmp_pixel_plot(struct zint_symbol *symbol, int image_height, int image_width
symbol->bitmap[i++] = bggrn; symbol->bitmap[i++] = bggrn;
symbol->bitmap[i++] = bgblu; symbol->bitmap[i++] = bgblu;
break; break;
} }
} }
} }
@ -410,7 +410,7 @@ int bmp_pixel_plot(struct zint_symbol *symbol, int image_height, int image_width
symbol->bitmap[i++] = bggrn; symbol->bitmap[i++] = bggrn;
symbol->bitmap[i++] = bgblu; symbol->bitmap[i++] = bgblu;
break; break;
} }
} }
} }
@ -430,7 +430,7 @@ int bmp_pixel_plot(struct zint_symbol *symbol, int image_height, int image_width
symbol->bitmap[i++] = bggrn; symbol->bitmap[i++] = bggrn;
symbol->bitmap[i++] = bgblu; symbol->bitmap[i++] = bgblu;
break; break;
} }
} }
} }
@ -447,11 +447,11 @@ int png_to_file(struct zint_symbol *symbol, int image_height, int image_width, c
char *scaled_pixelbuf; char *scaled_pixelbuf;
int horiz, vert, i; int horiz, vert, i;
int scale_width, scale_height; int scale_width, scale_height;
if(scaler == 0) { scaler = 0.5; } if(scaler == 0) { scaler = 0.5; }
scale_width = image_width * scaler; scale_width = image_width * scaler;
scale_height = image_height * scaler; scale_height = image_height * scaler;
/* 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))) {
printf("Insufficient memory for pixel buffer"); printf("Insufficient memory for pixel buffer");
@ -461,13 +461,13 @@ int png_to_file(struct zint_symbol *symbol, int image_height, int image_width, c
*(scaled_pixelbuf + i) = '0'; *(scaled_pixelbuf + i) = '0';
} }
} }
for(vert = 0; vert < scale_height; vert++) { for(vert = 0; vert < scale_height; vert++) {
for(horiz = 0; horiz < scale_width; horiz++) { for(horiz = 0; horiz < scale_width; horiz++) {
*(scaled_pixelbuf + (vert * scale_width) + horiz) = *(pixelbuf + ((int)(vert / scaler) * image_width) + (int)(horiz / scaler)); *(scaled_pixelbuf + (vert * scale_width) + horiz) = *(pixelbuf + ((int)(vert / scaler) * image_width) + (int)(horiz / scaler));
} }
} }
if(image_type == PNG_DATA) { if(image_type == PNG_DATA) {
#ifndef NO_PNG #ifndef NO_PNG
error_number = png_pixel_plot(symbol, scale_height, scale_width, scaled_pixelbuf, rotate_angle); error_number = png_pixel_plot(symbol, scale_height, scale_width, scaled_pixelbuf, rotate_angle);
@ -477,9 +477,9 @@ int png_to_file(struct zint_symbol *symbol, int image_height, int image_width, c
} else { } else {
error_number = bmp_pixel_plot(symbol, scale_height, scale_width, scaled_pixelbuf, rotate_angle); error_number = bmp_pixel_plot(symbol, scale_height, scale_width, scaled_pixelbuf, rotate_angle);
} }
free(scaled_pixelbuf); free(scaled_pixelbuf);
return error_number; return error_number;
} }
@ -487,11 +487,11 @@ void draw_bar(char *pixelbuf, int xpos, int xlen, int ypos, int ylen, int image_
{ {
/* Draw a rectangle */ /* Draw a rectangle */
int i, j, png_ypos; int i, j, png_ypos;
png_ypos = image_height - ypos - ylen; png_ypos = image_height - ypos - ylen;
/* This fudge is needed because EPS measures height from the bottom up but /* This fudge is needed because EPS measures height from the bottom up but
PNG measures y position from the top down */ PNG measures y position from the top down */
for(i = (xpos); i < (xpos + xlen); i++) { for(i = (xpos); i < (xpos + xlen); i++) {
for( j = (png_ypos); j < (png_ypos + ylen); j++) { for( j = (png_ypos); j < (png_ypos + ylen); j++) {
*(pixelbuf + (image_width * j) + i) = '1'; *(pixelbuf + (image_width * j) + i) = '1';
@ -501,11 +501,11 @@ void draw_bar(char *pixelbuf, int xpos, int xlen, int ypos, int ylen, int image_
int bullseye_pixel(int row, int col) { int bullseye_pixel(int row, int col) {
int block_val, block_pos, return_val; int block_val, block_pos, return_val;
block_val = bullseye_compressed[(row * 12) + (col / 8)]; block_val = bullseye_compressed[(row * 12) + (col / 8)];
return_val = 0; return_val = 0;
block_pos = col % 8; block_pos = col % 8;
switch(block_pos) { switch(block_pos) {
case 0: if((block_val & 0x80) != 0) { return_val = 1; } break; case 0: if((block_val & 0x80) != 0) { return_val = 1; } break;
case 1: if((block_val & 0x40) != 0) { return_val = 1; } break; case 1: if((block_val & 0x40) != 0) { return_val = 1; } break;
@ -516,7 +516,7 @@ int bullseye_pixel(int row, int col) {
case 6: if((block_val & 0x02) != 0) { return_val = 1; } break; case 6: if((block_val & 0x02) != 0) { return_val = 1; } break;
case 7: if((block_val & 0x01) != 0) { return_val = 1; } break; case 7: if((block_val & 0x01) != 0) { return_val = 1; } break;
} }
return return_val; return return_val;
} }
@ -524,7 +524,7 @@ void draw_bullseye(char *pixelbuf, int image_width, int xoffset, int yoffset)
{ {
/* Central bullseye in Maxicode symbols */ /* Central bullseye in Maxicode symbols */
int i, j; int i, j;
for(j = 103; j < 196; j++) { for(j = 103; j < 196; j++) {
for(i = 0; i < 93; i++) { for(i = 0; i < 93; i++) {
if(bullseye_pixel(j - 103, i)) { if(bullseye_pixel(j - 103, i)) {
@ -539,7 +539,7 @@ void draw_hexagon(char *pixelbuf, int image_width, int xposn, int yposn)
{ {
/* Put a hexagon into the pixel buffer */ /* Put a hexagon into the pixel buffer */
int i, j; int i, j;
for(i = 0; i < 12; i++) { for(i = 0; i < 12; i++) {
for(j = 0; j < 10; j++) { for(j = 0; j < 10; j++) {
if(hexagon[(i * 10) + j] == 1) { if(hexagon[(i * 10) + j] == 1) {
@ -553,13 +553,13 @@ void draw_letter(char *pixelbuf, unsigned char letter, int xposn, int yposn, int
{ {
/* Put a letter into a position */ /* Put a letter into a position */
int skip, i, j, glyph_no, alphabet; int skip, i, j, glyph_no, alphabet;
skip = 0; skip = 0;
alphabet = 0; alphabet = 0;
if(letter < 33) { skip = 1; } if(letter < 33) { skip = 1; }
if((letter > 127) && (letter < 161)) { skip = 1; } if((letter > 127) && (letter < 161)) { skip = 1; }
if(skip == 0) { if(skip == 0) {
if(letter > 128) { if(letter > 128) {
alphabet = 1; alphabet = 1;
@ -567,7 +567,7 @@ void draw_letter(char *pixelbuf, unsigned char letter, int xposn, int yposn, int
} else { } else {
glyph_no = letter - 33; glyph_no = letter - 33;
} }
if(smalltext) { if(smalltext) {
for(i = 0; i <= 8; i++) { for(i = 0; i <= 8; i++) {
for(j = 0; j < 5; j++) { for(j = 0; j < 5; j++) {
@ -604,14 +604,14 @@ void draw_string(char *pixbuf, char input_string[], int xposn, int yposn, int sm
{ {
/* Plot a string into the pixel buffer */ /* Plot a string into the pixel buffer */
int i, string_length, string_left_hand; int i, string_length, string_left_hand;
string_length = strlen(input_string); string_length = strlen(input_string);
string_left_hand = xposn - ((7 * string_length) / 2); string_left_hand = xposn - ((7 * string_length) / 2);
for(i = 0; i < string_length; i++) { for(i = 0; i < string_length; i++) {
draw_letter(pixbuf, input_string[i], string_left_hand + (i * 7), yposn, smalltext, image_width, image_height); draw_letter(pixbuf, input_string[i], string_left_hand + (i * 7), yposn, smalltext, image_width, image_height);
} }
} }
int maxi_png_plot(struct zint_symbol *symbol, int rotate_angle, int data_type) int maxi_png_plot(struct zint_symbol *symbol, int rotate_angle, int data_type)
@ -626,7 +626,7 @@ int maxi_png_plot(struct zint_symbol *symbol, int rotate_angle, int data_type)
yoffset = symbol->border_width; yoffset = symbol->border_width;
image_width = 300 + (2 * xoffset * 2); image_width = 300 + (2 * xoffset * 2);
image_height = 300 + (2 * yoffset * 2); image_height = 300 + (2 * yoffset * 2);
if (!(pixelbuf = (char *) malloc(image_width * image_height))) { if (!(pixelbuf = (char *) malloc(image_width * image_height))) {
printf("Insifficient memory for pixel buffer"); printf("Insifficient memory for pixel buffer");
return ERROR_ENCODING_PROBLEM; return ERROR_ENCODING_PROBLEM;
@ -635,9 +635,9 @@ int maxi_png_plot(struct zint_symbol *symbol, int rotate_angle, int data_type)
*(pixelbuf + i) = '0'; *(pixelbuf + i) = '0';
} }
} }
draw_bullseye(pixelbuf, image_width, (2 * xoffset), (2 * yoffset)); draw_bullseye(pixelbuf, image_width, (2 * xoffset), (2 * yoffset));
for(row = 0; row < symbol->rows; row++) { for(row = 0; row < symbol->rows; row++) {
yposn = row * 9; yposn = row * 9;
for(column = 0; column < symbol->width; column++) { for(column = 0; column < symbol->width; column++) {
@ -660,13 +660,13 @@ int maxi_png_plot(struct zint_symbol *symbol, int rotate_angle, int data_type)
draw_bar(pixelbuf, 0, image_width, 0, symbol->border_width * 2, image_width, image_height); draw_bar(pixelbuf, 0, image_width, 0, symbol->border_width * 2, image_width, image_height);
draw_bar(pixelbuf, 0, image_width, 300 + (symbol->border_width * 2), symbol->border_width * 2, image_width, image_height); draw_bar(pixelbuf, 0, image_width, 300 + (symbol->border_width * 2), symbol->border_width * 2, image_width, image_height);
} }
if((symbol->output_options & BARCODE_BOX) != 0) { if((symbol->output_options & BARCODE_BOX) != 0) {
/* side bars */ /* side bars */
draw_bar(pixelbuf, 0, symbol->border_width * 2, 0, image_height, image_width, image_height); draw_bar(pixelbuf, 0, symbol->border_width * 2, 0, image_height, image_width, image_height);
draw_bar(pixelbuf, 300 + ((symbol->border_width + symbol->whitespace_width + symbol->whitespace_width) * 2), symbol->border_width * 2, 0, image_height, image_width, image_height); draw_bar(pixelbuf, 300 + ((symbol->border_width + symbol->whitespace_width + symbol->whitespace_width) * 2), symbol->border_width * 2, 0, image_height, image_width, image_height);
} }
error_number=png_to_file(symbol, image_height, image_width, pixelbuf, rotate_angle, data_type); error_number=png_to_file(symbol, image_height, image_width, pixelbuf, rotate_angle, data_type);
free(pixelbuf); free(pixelbuf);
return error_number; return error_number;
@ -675,9 +675,9 @@ int maxi_png_plot(struct zint_symbol *symbol, int rotate_angle, int data_type)
void to_latin1(unsigned char source[], unsigned char preprocessed[]) void to_latin1(unsigned char source[], unsigned char preprocessed[])
{ {
int j, i, input_length; int j, i, input_length;
input_length = ustrlen(source); input_length = ustrlen(source);
j = 0; j = 0;
i = 0; i = 0;
do { do {
@ -699,7 +699,7 @@ void to_latin1(unsigned char source[], unsigned char preprocessed[])
} }
} while (i < input_length); } while (i < input_length);
preprocessed[j] = '\0'; preprocessed[j] = '\0';
return; return;
} }
@ -757,7 +757,7 @@ int png_plot(struct zint_symbol *symbol, int rotate_angle, int data_type)
} else { } else {
large_bar_height = (symbol->height - preset_height) / large_bar_count; large_bar_height = (symbol->height - preset_height) / large_bar_count;
} }
while(!(module_is_set(symbol, symbol->rows - 1, comp_offset))) { while(!(module_is_set(symbol, symbol->rows - 1, comp_offset))) {
comp_offset++; comp_offset++;
} }
@ -785,14 +785,14 @@ int png_plot(struct zint_symbol *symbol, int rotate_angle, int data_type)
main_width = 96 + comp_offset; main_width = 96 + comp_offset;
} }
} }
if (((symbol->symbology == BARCODE_UPCE) && (symbol->rows == 1)) || (symbol->symbology == BARCODE_UPCE_CC)) { if (((symbol->symbology == BARCODE_UPCE) && (symbol->rows == 1)) || (symbol->symbology == BARCODE_UPCE_CC)) {
if(symbol->whitespace_width == 0) { if(symbol->whitespace_width == 0) {
symbol->whitespace_width = 10; symbol->whitespace_width = 10;
main_width = 51 + comp_offset; main_width = 51 + comp_offset;
} }
} }
latch = 0; latch = 0;
r = 0; r = 0;
/* Isolate add-on text */ /* Isolate add-on text */
@ -818,7 +818,7 @@ int png_plot(struct zint_symbol *symbol, int rotate_angle, int data_type)
yoffset = symbol->border_width; yoffset = symbol->border_width;
image_width = 2 * (symbol->width + xoffset + xoffset); image_width = 2 * (symbol->width + xoffset + xoffset);
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))) {
printf("Insufficient memory for pixel buffer"); printf("Insufficient memory for pixel buffer");
return ERROR_ENCODING_PROBLEM; return ERROR_ENCODING_PROBLEM;
@ -850,14 +850,14 @@ int png_plot(struct zint_symbol *symbol, int rotate_angle, int data_type)
} }
next_yposn = (int)(row_posn + row_height); next_yposn = (int)(row_posn + row_height);
plot_height = next_yposn - plot_yposn; plot_height = next_yposn - plot_yposn;
i = 0; i = 0;
if(module_is_set(symbol, this_row, 0)) { if(module_is_set(symbol, this_row, 0)) {
latch = 1; latch = 1;
} else { } else {
latch = 0; latch = 0;
} }
do { do {
block_width = 0; block_width = 0;
do { do {
@ -878,10 +878,10 @@ int png_plot(struct zint_symbol *symbol, int rotate_angle, int data_type)
latch = 1; latch = 1;
} }
i += block_width; i += block_width;
} while (i < symbol->width); } while (i < symbol->width);
} }
xoffset += comp_offset; xoffset += comp_offset;
if ((((symbol->symbology == BARCODE_EANX) && (symbol->rows == 1)) || (symbol->symbology == BARCODE_EANX_CC)) || (symbol->symbology == BARCODE_ISBNX)) { if ((((symbol->symbology == BARCODE_EANX) && (symbol->rows == 1)) || (symbol->symbology == BARCODE_EANX_CC)) || (symbol->symbology == BARCODE_ISBNX)) {
@ -901,7 +901,7 @@ int png_plot(struct zint_symbol *symbol, int rotate_angle, int data_type)
} }
textpart[4] = '\0'; textpart[4] = '\0';
textpos = 2 * (17 + xoffset); textpos = 2 * (17 + xoffset);
draw_string(pixelbuf, textpart, textpos, default_text_posn, smalltext, image_width, image_height); draw_string(pixelbuf, textpart, textpos, default_text_posn, smalltext, image_width, image_height);
for(i = 0; i < 4; i++) { for(i = 0; i < 4; i++) {
textpart[i] = symbol->text[i + 4]; textpart[i] = symbol->text[i + 4];
@ -911,7 +911,7 @@ int png_plot(struct zint_symbol *symbol, int rotate_angle, int data_type)
draw_string(pixelbuf, textpart, textpos, default_text_posn, smalltext, image_width, image_height); draw_string(pixelbuf, textpart, textpos, default_text_posn, smalltext, image_width, image_height);
textdone = 1; textdone = 1;
switch(strlen(addon)) { switch(strlen(addon)) {
case 2: case 2:
textpos = 2 * (xoffset + 86); textpos = 2 * (xoffset + 86);
draw_string(pixelbuf, addon, textpos, image_height - (addon_text_posn * 2) - 13, smalltext, image_width, image_height); draw_string(pixelbuf, addon, textpos, image_height - (addon_text_posn * 2) - 13, smalltext, image_width, image_height);
break; break;
@ -950,7 +950,7 @@ int png_plot(struct zint_symbol *symbol, int rotate_angle, int data_type)
draw_string(pixelbuf, textpart, textpos, default_text_posn, smalltext, image_width, image_height); draw_string(pixelbuf, textpart, textpos, default_text_posn, smalltext, image_width, image_height);
textdone = 1; textdone = 1;
switch(strlen(addon)) { switch(strlen(addon)) {
case 2: case 2:
textpos = 2 * (xoffset + 114); textpos = 2 * (xoffset + 114);
draw_string(pixelbuf, addon, textpos, image_height - (addon_text_posn * 2) - 13, smalltext, image_width, image_height); draw_string(pixelbuf, addon, textpos, image_height - (addon_text_posn * 2) - 13, smalltext, image_width, image_height);
break; break;
@ -962,12 +962,12 @@ int png_plot(struct zint_symbol *symbol, int rotate_angle, int data_type)
break; break;
} }
} }
if (((symbol->symbology == BARCODE_UPCA) && (symbol->rows == 1)) || (symbol->symbology == BARCODE_UPCA_CC)) { if (((symbol->symbology == BARCODE_UPCA) && (symbol->rows == 1)) || (symbol->symbology == BARCODE_UPCA_CC)) {
/* guard bar extensions and text formatting for UPCA */ /* guard bar extensions and text formatting for UPCA */
latch = 1; latch = 1;
i = 0 + comp_offset; i = 0 + comp_offset;
do { do {
block_width = 0; block_width = 0;
@ -1025,7 +1025,7 @@ int png_plot(struct zint_symbol *symbol, int rotate_angle, int data_type)
draw_string(pixelbuf, textpart, textpos, default_text_posn, smalltext, image_width, image_height); draw_string(pixelbuf, textpart, textpos, default_text_posn, smalltext, image_width, image_height);
textdone = 1; textdone = 1;
switch(strlen(addon)) { switch(strlen(addon)) {
case 2: case 2:
textpos = 2 * (xoffset + 116); textpos = 2 * (xoffset + 116);
draw_string(pixelbuf, addon, textpos, image_height - (addon_text_posn * 2) - 13, smalltext, image_width, image_height); draw_string(pixelbuf, addon, textpos, image_height - (addon_text_posn * 2) - 13, smalltext, image_width, image_height);
break; break;
@ -1035,7 +1035,7 @@ int png_plot(struct zint_symbol *symbol, int rotate_angle, int data_type)
break; break;
} }
} }
if (((symbol->symbology == BARCODE_UPCE) && (symbol->rows == 1)) || (symbol->symbology == BARCODE_UPCE_CC)) { if (((symbol->symbology == BARCODE_UPCE) && (symbol->rows == 1)) || (symbol->symbology == BARCODE_UPCE_CC)) {
/* guard bar extensions and text formatting for UPCE */ /* guard bar extensions and text formatting for UPCE */
@ -1061,7 +1061,7 @@ int png_plot(struct zint_symbol *symbol, int rotate_angle, int data_type)
draw_string(pixelbuf, textpart, textpos, default_text_posn, smalltext, image_width, image_height); draw_string(pixelbuf, textpart, textpos, default_text_posn, smalltext, image_width, image_height);
textdone = 1; textdone = 1;
switch(strlen(addon)) { switch(strlen(addon)) {
case 2: case 2:
textpos = 2 * (xoffset + 70); textpos = 2 * (xoffset + 70);
draw_string(pixelbuf, addon, textpos, image_height - (addon_text_posn * 2) - 13, smalltext, image_width, image_height); draw_string(pixelbuf, addon, textpos, image_height - (addon_text_posn * 2) - 13, smalltext, image_width, image_height);
break; break;
@ -1074,7 +1074,7 @@ int png_plot(struct zint_symbol *symbol, int rotate_angle, int data_type)
} }
xoffset -= comp_offset; xoffset -= comp_offset;
/* Put boundary bars or box around symbol */ /* Put boundary bars or box around symbol */
if(((symbol->output_options & BARCODE_BOX) != 0) || ((symbol->output_options & BARCODE_BIND) != 0)) { if(((symbol->output_options & BARCODE_BOX) != 0) || ((symbol->output_options & BARCODE_BIND) != 0)) {
/* boundary bars */ /* boundary bars */
@ -1089,13 +1089,13 @@ int png_plot(struct zint_symbol *symbol, int rotate_angle, int data_type)
} }
} }
} }
if((symbol->output_options & BARCODE_BOX) != 0) { if((symbol->output_options & BARCODE_BOX) != 0) {
/* side bars */ /* side bars */
draw_bar(pixelbuf, 0, symbol->border_width * 2, textoffset * 2, (symbol->height + (2 * symbol->border_width)) * 2, image_width, image_height); draw_bar(pixelbuf, 0, symbol->border_width * 2, textoffset * 2, (symbol->height + (2 * symbol->border_width)) * 2, image_width, image_height);
draw_bar(pixelbuf, (symbol->width + xoffset + xoffset - symbol->border_width) * 2, symbol->border_width * 2, textoffset * 2, (symbol->height + (2 * symbol->border_width)) * 2, image_width, image_height); draw_bar(pixelbuf, (symbol->width + xoffset + xoffset - symbol->border_width) * 2, symbol->border_width * 2, textoffset * 2, (symbol->height + (2 * symbol->border_width)) * 2, image_width, image_height);
} }
/* Put the human readable text at the bottom */ /* Put the human readable text at the bottom */
if((textdone == 0) && (ustrlen(local_text) != 0)) { if((textdone == 0) && (ustrlen(local_text) != 0)) {
textpos = (image_width / 2); textpos = (image_width / 2);
@ -1111,14 +1111,14 @@ int png_plot(struct zint_symbol *symbol, int rotate_angle, int data_type)
int png_handle(struct zint_symbol *symbol, int rotate_angle) int png_handle(struct zint_symbol *symbol, int rotate_angle)
{ {
int error; int error;
if(symbol->symbology == BARCODE_MAXICODE) { if(symbol->symbology == BARCODE_MAXICODE) {
error = maxi_png_plot(symbol, rotate_angle, PNG_DATA); error = maxi_png_plot(symbol, rotate_angle, PNG_DATA);
} else { } else {
error = png_plot(symbol, rotate_angle, PNG_DATA); error = png_plot(symbol, rotate_angle, PNG_DATA);
} }
return error; return error;
} }
#endif /* NO_PNG */ #endif /* NO_PNG */
@ -1126,13 +1126,13 @@ int png_handle(struct zint_symbol *symbol, int rotate_angle)
int bmp_handle(struct zint_symbol *symbol, int rotate_angle) int bmp_handle(struct zint_symbol *symbol, int rotate_angle)
{ {
int error; int error;
if(symbol->symbology == BARCODE_MAXICODE) { if(symbol->symbology == BARCODE_MAXICODE) {
error = maxi_png_plot(symbol, rotate_angle, BMP_DATA); error = maxi_png_plot(symbol, rotate_angle, BMP_DATA);
} else { } else {
error = png_plot(symbol, rotate_angle, BMP_DATA); error = png_plot(symbol, rotate_angle, BMP_DATA);
} }
return error; return error;
} }

66
backend/postal.c
View File

@ -43,13 +43,13 @@ static const char *KoreaTable[10] = {"1313150613", "0713131313", "0417131313", "
static const char *JapanTable[19] = {"114", "132", "312", "123", "141", "321", "213", "231", "411", "144", static const char *JapanTable[19] = {"114", "132", "312", "123", "141", "321", "213", "231", "411", "144",
"414", "324", "342", "234", "432", "243", "423", "441", "111"}; "414", "324", "342", "234", "432", "243", "423", "441", "111"};
int postnet(struct zint_symbol *symbol, unsigned char source[], char dest[], int length) int postnet(struct zint_symbol *symbol, unsigned char source[], char dest[], int length)
{ {
/* Handles the PostNet system used for Zip codes in the US */ /* Handles the PostNet system used for Zip codes in the US */
unsigned int i, sum, check_digit; unsigned int i, sum, check_digit;
int error_number; int error_number;
error_number = 0; error_number = 0;
if(length > 38) { if(length > 38) {
@ -77,10 +77,10 @@ int postnet(struct zint_symbol *symbol, unsigned char source[], char dest[], int
/* stop character */ /* stop character */
concat (dest, "L"); concat (dest, "L");
return error_number; return error_number;
} }
int post_plot(struct zint_symbol *symbol, unsigned char source[], int length) int post_plot(struct zint_symbol *symbol, unsigned char source[], int length)
{ {
/* Puts PostNet barcodes into the pattern matrix */ /* Puts PostNet barcodes into the pattern matrix */
@ -88,7 +88,7 @@ int post_plot(struct zint_symbol *symbol, unsigned char source[], int length)
unsigned int loopey, h; unsigned int loopey, h;
int writer; int writer;
int error_number; int error_number;
error_number = 0; error_number = 0;
error_number = postnet(symbol, source, height_pattern, length); error_number = postnet(symbol, source, height_pattern, length);
@ -111,7 +111,7 @@ int post_plot(struct zint_symbol *symbol, unsigned char source[], int length)
symbol->row_height[1] = 6; symbol->row_height[1] = 6;
symbol->rows = 2; symbol->rows = 2;
symbol->width = writer - 1; symbol->width = writer - 1;
return error_number; return error_number;
} }
@ -120,9 +120,9 @@ int planet(struct zint_symbol *symbol, unsigned char source[], char dest[], int
/* Handles the PLANET system used for item tracking in the US */ /* Handles the PLANET system used for item tracking in the US */
unsigned int i, sum, check_digit; unsigned int i, sum, check_digit;
int error_number; int error_number;
error_number = 0; error_number = 0;
if(length > 38) { if(length > 38) {
strcpy(symbol->errtxt, "Input too long"); strcpy(symbol->errtxt, "Input too long");
return ERROR_TOO_LONG; return ERROR_TOO_LONG;
@ -159,7 +159,7 @@ int planet_plot(struct zint_symbol *symbol, unsigned char source[], int length)
unsigned int loopey, h; unsigned int loopey, h;
int writer; int writer;
int error_number; int error_number;
error_number = 0; error_number = 0;
error_number = planet(symbol, source, height_pattern, length); error_number = planet(symbol, source, height_pattern, length);
@ -227,14 +227,14 @@ int fim(struct zint_symbol *symbol, unsigned char source[], int length)
{ {
/* The simplest barcode symbology ever! Supported by MS Word, so here it is! */ /* The simplest barcode symbology ever! Supported by MS Word, so here it is! */
/* glyphs from http://en.wikipedia.org/wiki/Facing_Identification_Mark */ /* glyphs from http://en.wikipedia.org/wiki/Facing_Identification_Mark */
char dest[16] = { 0 }; char dest[16] = { 0 };
if(length > 1) { if(length > 1) {
strcpy(symbol->errtxt, "Input too long"); strcpy(symbol->errtxt, "Input too long");
return ERROR_TOO_LONG; return ERROR_TOO_LONG;
} }
switch((char)source[0]) { switch((char)source[0]) {
case 'a': case 'a':
case 'A': case 'A':
@ -257,7 +257,7 @@ int fim(struct zint_symbol *symbol, unsigned char source[], int length)
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
break; break;
} }
expand(symbol, dest); expand(symbol, dest);
return 0; return 0;
} }
@ -292,7 +292,7 @@ char rm4scc(char source[], unsigned char dest[], int length)
/* stop character */ /* stop character */
concat ((char*)dest, "0"); concat ((char*)dest, "0");
return set_copy[check_digit]; return set_copy[check_digit];
} }
@ -306,7 +306,7 @@ int royal_plot(struct zint_symbol *symbol, unsigned char source[], int length)
strcpy(height_pattern, ""); strcpy(height_pattern, "");
error_number = 0; error_number = 0;
if(length > 120) { if(length > 120) {
strcpy(symbol->errtxt, "Input too long"); strcpy(symbol->errtxt, "Input too long");
return ERROR_TOO_LONG; return ERROR_TOO_LONG;
@ -340,7 +340,7 @@ int royal_plot(struct zint_symbol *symbol, unsigned char source[], int length)
symbol->row_height[2] = 3; symbol->row_height[2] = 3;
symbol->rows = 3; symbol->rows = 3;
symbol->width = writer - 1; symbol->width = writer - 1;
return error_number; return error_number;
} }
@ -356,7 +356,7 @@ int kix_code(struct zint_symbol *symbol, unsigned char source[], int length)
strcpy(height_pattern, ""); strcpy(height_pattern, "");
error_number = 0; error_number = 0;
if(length > 18) { if(length > 18) {
strcpy(symbol->errtxt, "Input too long"); strcpy(symbol->errtxt, "Input too long");
return ERROR_TOO_LONG; return ERROR_TOO_LONG;
@ -367,18 +367,18 @@ int kix_code(struct zint_symbol *symbol, unsigned char source[], int length)
strcpy(symbol->errtxt, "Invalid characters in data"); strcpy(symbol->errtxt, "Invalid characters in data");
return error_number; return error_number;
} }
/* Add leading zeroes */ /* Add leading zeroes */
/* zeroes = 11 - length; /* zeroes = 11 - length;
memset(localstr, '0', zeroes); memset(localstr, '0', zeroes);
strcpy(localstr + zeroes, (char *)source);*/ strcpy(localstr + zeroes, (char *)source);*/
strcpy(localstr, (char *)source); strcpy(localstr, (char *)source);
/* Encode data */ /* Encode data */
for (i = 0; i < 18; i++) { for (i = 0; i < 18; i++) {
lookup(KRSET, RoyalTable, localstr[i], height_pattern); lookup(KRSET, RoyalTable, localstr[i], height_pattern);
} }
writer = 0; writer = 0;
h = strlen(height_pattern); h = strlen(height_pattern);
for(loopey = 0; loopey < h; loopey++) for(loopey = 0; loopey < h; loopey++)
@ -400,7 +400,7 @@ int kix_code(struct zint_symbol *symbol, unsigned char source[], int length)
symbol->row_height[2] = 3; symbol->row_height[2] = 3;
symbol->rows = 3; symbol->rows = 3;
symbol->width = writer - 1; symbol->width = writer - 1;
return error_number; return error_number;
} }
@ -412,7 +412,7 @@ int daft_code(struct zint_symbol *symbol, unsigned char source[], int length)
unsigned int loopey, h; unsigned int loopey, h;
int writer, i, error_number; int writer, i, error_number;
strcpy(height_pattern, ""); strcpy(height_pattern, "");
error_number = 0; error_number = 0;
if(length > 50) { if(length > 50) {
strcpy(symbol->errtxt, "Input too long"); strcpy(symbol->errtxt, "Input too long");
@ -425,14 +425,14 @@ int daft_code(struct zint_symbol *symbol, unsigned char source[], int length)
strcpy(symbol->errtxt, "Invalid characters in data"); strcpy(symbol->errtxt, "Invalid characters in data");
return error_number; return error_number;
} }
for (i = 0; i < length; i++) { for (i = 0; i < length; i++) {
if(source[i] == 'D') { concat(height_pattern, "2"); } if(source[i] == 'D') { concat(height_pattern, "2"); }
if(source[i] == 'A') { concat(height_pattern, "1"); } if(source[i] == 'A') { concat(height_pattern, "1"); }
if(source[i] == 'F') { concat(height_pattern, "0"); } if(source[i] == 'F') { concat(height_pattern, "0"); }
if(source[i] == 'T') { concat(height_pattern, "3"); } if(source[i] == 'T') { concat(height_pattern, "3"); }
} }
writer = 0; writer = 0;
h = strlen(height_pattern); h = strlen(height_pattern);
for(loopey = 0; loopey < h; loopey++) for(loopey = 0; loopey < h; loopey++)
@ -448,13 +448,13 @@ int daft_code(struct zint_symbol *symbol, unsigned char source[], int length)
} }
writer += 2; writer += 2;
} }
symbol->row_height[0] = 3; symbol->row_height[0] = 3;
symbol->row_height[1] = 2; symbol->row_height[1] = 2;
symbol->row_height[2] = 3; symbol->row_height[2] = 3;
symbol->rows = 3; symbol->rows = 3;
symbol->width = writer - 1; symbol->width = writer - 1;
return error_number; return error_number;
} }
@ -463,9 +463,9 @@ int flattermarken(struct zint_symbol *symbol, unsigned char source[], int length
but it's supported by TBarCode so it's supported by Zint! */ but it's supported by TBarCode so it's supported by Zint! */
int loop, error_number; int loop, error_number;
char dest[512]; /* 90 * 4 + 1 ~ */ char dest[512]; /* 90 * 4 + 1 ~ */
error_number = 0; error_number = 0;
if(length > 90) { if(length > 90) {
strcpy(symbol->errtxt, "Input too long"); strcpy(symbol->errtxt, "Input too long");
return ERROR_TOO_LONG; return ERROR_TOO_LONG;
@ -543,7 +543,7 @@ int japan_post(struct zint_symbol *symbol, unsigned char source[], int length)
inter[20] = '\0'; inter[20] = '\0';
strcpy(pattern, "13"); /* Start */ strcpy(pattern, "13"); /* Start */
sum = 0; sum = 0;
for(i = 0; i < 20; i++) { for(i = 0; i < 20; i++) {
concat(pattern, JapanTable[posn(KASUTSET, inter[i])]); concat(pattern, JapanTable[posn(KASUTSET, inter[i])]);
@ -559,9 +559,9 @@ int japan_post(struct zint_symbol *symbol, unsigned char source[], int length)
if(check >= 11) { check_char = (check - 11) + 'a'; } if(check >= 11) { check_char = (check - 11) + 'a'; }
concat(pattern, JapanTable[posn(KASUTSET, check_char)]); concat(pattern, JapanTable[posn(KASUTSET, check_char)]);
/* printf("check %c (%d)\n", check_char, check); */ /* printf("check %c (%d)\n", check_char, check); */
concat(pattern, "31"); /* Stop */ concat(pattern, "31"); /* Stop */
/* Resolve pattern to 4-state symbols */ /* Resolve pattern to 4-state symbols */
writer = 0; writer = 0;
h = strlen(pattern); h = strlen(pattern);
@ -578,12 +578,12 @@ int japan_post(struct zint_symbol *symbol, unsigned char source[], int length)
} }
writer += 2; writer += 2;
} }
symbol->row_height[0] = 3; symbol->row_height[0] = 3;
symbol->row_height[1] = 2; symbol->row_height[1] = 2;
symbol->row_height[2] = 3; symbol->row_height[2] = 3;
symbol->rows = 3; symbol->rows = 3;
symbol->width = writer - 1; symbol->width = writer - 1;
return error_number; return error_number;
} }

282
backend/qr.c
View File

@ -33,7 +33,7 @@ int in_alpha(int glyph) {
/* Returns true if input glyph is in the Alphanumeric set */ /* Returns true if input glyph is in the Alphanumeric set */
int retval = 0; int retval = 0;
char cglyph = (char) glyph; char cglyph = (char) glyph;
if((cglyph >= '0') && (cglyph <= '9')) { if((cglyph >= '0') && (cglyph <= '9')) {
retval = 1; retval = 1;
} }
@ -53,7 +53,7 @@ int in_alpha(int glyph) {
retval = 1; retval = 1;
break; break;
} }
return retval; return retval;
} }
@ -61,9 +61,9 @@ void define_mode(char mode[], int jisdata[], int length, int gs1)
{ {
/* Values placed into mode[] are: K = Kanji, B = Binary, A = Alphanumeric, N = Numeric */ /* Values placed into mode[] are: K = Kanji, B = Binary, A = Alphanumeric, N = Numeric */
int i, mlen, j; int i, mlen, j;
for(i = 0; i < length; i++) { for(i = 0; i < length; i++) {
if(jisdata[i] > 0xff) { if(jisdata[i] > 0xff) {
mode[i] = 'K'; mode[i] = 'K';
} else { } else {
mode[i] = 'B'; mode[i] = 'B';
@ -72,7 +72,7 @@ void define_mode(char mode[], int jisdata[], int length, int gs1)
if((jisdata[i] >= '0') && (jisdata[i] <= '9')) { mode[i] = 'N'; } if((jisdata[i] >= '0') && (jisdata[i] <= '9')) { mode[i] = 'N'; }
} }
} }
/* If less than 6 numeric digits together then don't use numeric mode */ /* If less than 6 numeric digits together then don't use numeric mode */
for(i = 0; i < length; i++) { for(i = 0; i < length; i++) {
if(mode[i] == 'N') { if(mode[i] == 'N') {
@ -89,7 +89,7 @@ void define_mode(char mode[], int jisdata[], int length, int gs1)
} }
} }
} }
/* If less than 4 alphanumeric characters together then don't use alphanumeric mode */ /* If less than 4 alphanumeric characters together then don't use alphanumeric mode */
for(i = 0; i < length; i++) { for(i = 0; i < length; i++) {
if(mode[i] == 'A') { if(mode[i] == 'A') {
@ -117,7 +117,7 @@ int estimate_binary_length(char mode[], int length, int gs1)
int n_count = 0; int n_count = 0;
if(gs1) { count += 4; } if(gs1) { count += 4; }
for(i = 0; i < length; i++) { for(i = 0; i < length; i++) {
if(mode[i] != current) { if(mode[i] != current) {
switch(mode[i]) { switch(mode[i]) {
@ -157,7 +157,7 @@ int estimate_binary_length(char mode[], int length, int gs1)
return count; return count;
} }
static inline void qr_bscan(char *binary, int data, int h) static void qr_bscan(char *binary, int data, int h)
{ {
for (; h; h>>=1) { for (; h; h>>=1) {
concat(binary, data & h ? "1" : "0"); concat(binary, data & h ? "1" : "0");
@ -179,11 +179,11 @@ void qr_binary(int datastream[], int version, int target_binlen, char mode[], in
char* binary = (char *)_alloca(est_binlen + 12); char* binary = (char *)_alloca(est_binlen + 12);
#endif #endif
strcpy(binary, ""); strcpy(binary, "");
if(gs1) { if(gs1) {
concat(binary, "0101"); /* FNC1 */ concat(binary, "0101"); /* FNC1 */
} }
if(version <= 9) { if(version <= 9) {
scheme = 1; scheme = 1;
} else if((version >= 10) && (version <= 26)) { } else if((version >= 10) && (version <= 26)) {
@ -191,39 +191,39 @@ void qr_binary(int datastream[], int version, int target_binlen, char mode[], in
} else if(version >= 27) { } else if(version >= 27) {
scheme = 3; scheme = 3;
} }
if(debug) { if(debug) {
for(i = 0; i < length; i++) { for(i = 0; i < length; i++) {
printf("%c", mode[i]); printf("%c", mode[i]);
} }
printf("\n"); printf("\n");
} }
percent = 0; percent = 0;
do { do {
data_block = mode[position]; data_block = mode[position];
short_data_block_length = 0; short_data_block_length = 0;
do { do {
short_data_block_length++; short_data_block_length++;
} while (((short_data_block_length + position) < length) && (mode[position + short_data_block_length] == data_block)); } while (((short_data_block_length + position) < length) && (mode[position + short_data_block_length] == data_block));
switch(data_block) { switch(data_block) {
case 'K': case 'K':
/* Kanji mode */ /* Kanji mode */
/* Mode indicator */ /* Mode indicator */
concat(binary, "1000"); concat(binary, "1000");
/* Character count indicator */ /* Character count indicator */
qr_bscan(binary, short_data_block_length, 0x20 << (scheme*2)); /* scheme = 1..3 */ qr_bscan(binary, short_data_block_length, 0x20 << (scheme*2)); /* scheme = 1..3 */
if(debug) { printf("Kanji block (length %d)\n\t", short_data_block_length); } if(debug) { printf("Kanji block (length %d)\n\t", short_data_block_length); }
/* Character representation */ /* Character representation */
for(i = 0; i < short_data_block_length; i++) { for(i = 0; i < short_data_block_length; i++) {
int jis = jisdata[position + i]; int jis = jisdata[position + i];
int msb, lsb, prod; int msb, lsb, prod;
if(jis > 0x9fff) { jis -= 0xc140; } if(jis > 0x9fff) { jis -= 0xc140; }
msb = (jis & 0xff00) >> 4; msb = (jis & 0xff00) >> 4;
lsb = (jis & 0xff); lsb = (jis & 0xff);
@ -233,24 +233,24 @@ void qr_binary(int datastream[], int version, int target_binlen, char mode[], in
if(debug) { printf("0x%4X ", prod); } if(debug) { printf("0x%4X ", prod); }
} }
if(debug) { printf("\n"); } if(debug) { printf("\n"); }
break; break;
case 'B': case 'B':
/* Byte mode */ /* Byte mode */
/* Mode indicator */ /* Mode indicator */
concat(binary, "0100"); concat(binary, "0100");
/* Character count indicator */ /* Character count indicator */
qr_bscan(binary, short_data_block_length, scheme > 1 ? 0x8000 : 0x80); /* scheme = 1..3 */ qr_bscan(binary, short_data_block_length, scheme > 1 ? 0x8000 : 0x80); /* scheme = 1..3 */
if(debug) { printf("Byte block (length %d)\n\t", short_data_block_length); } if(debug) { printf("Byte block (length %d)\n\t", short_data_block_length); }
/* Character representation */ /* Character representation */
for(i = 0; i < short_data_block_length; i++) { for(i = 0; i < short_data_block_length; i++) {
int byte = jisdata[position + i]; int byte = jisdata[position + i];
if(gs1 && (byte == '[')) { if(gs1 && (byte == '[')) {
byte = 0x1d; /* FNC1 */ byte = 0x1d; /* FNC1 */
} }
@ -259,26 +259,26 @@ void qr_binary(int datastream[], int version, int target_binlen, char mode[], in
if(debug) { printf("0x%2X(%d) ", byte, byte); } if(debug) { printf("0x%2X(%d) ", byte, byte); }
} }
if(debug) { printf("\n"); } if(debug) { printf("\n"); }
break; break;
case 'A': case 'A':
/* Alphanumeric mode */ /* Alphanumeric mode */
/* Mode indicator */ /* Mode indicator */
concat(binary, "0010"); concat(binary, "0010");
/* Character count indicator */ /* Character count indicator */
qr_bscan(binary, short_data_block_length, 0x40 << (2 * scheme)); /* scheme = 1..3 */ qr_bscan(binary, short_data_block_length, 0x40 << (2 * scheme)); /* scheme = 1..3 */
if(debug) { printf("Alpha block (length %d)\n\t", short_data_block_length); } if(debug) { printf("Alpha block (length %d)\n\t", short_data_block_length); }
/* Character representation */ /* Character representation */
i = 0; i = 0;
while ( i < short_data_block_length ) { while ( i < short_data_block_length ) {
int count; int count;
int first = 0, second = 0, prod; int first = 0, second = 0, prod;
if(percent == 0) { if(percent == 0) {
if(gs1 && (jisdata[position + i] == '%')) { if(gs1 && (jisdata[position + i] == '%')) {
first = posn(RHODIUM, '%'); first = posn(RHODIUM, '%');
@ -295,7 +295,7 @@ void qr_binary(int datastream[], int version, int target_binlen, char mode[], in
count = 1; count = 1;
i++; i++;
prod = first; prod = first;
if(mode[position + i] == 'A') { if(mode[position + i] == 'A') {
if(gs1 && (jisdata[position + i] == '%')) { if(gs1 && (jisdata[position + i] == '%')) {
second = posn(RHODIUM, '%'); second = posn(RHODIUM, '%');
@ -320,7 +320,7 @@ void qr_binary(int datastream[], int version, int target_binlen, char mode[], in
i++; i++;
prod = first; prod = first;
percent = 0; percent = 0;
if(mode[position + i] == 'A') { if(mode[position + i] == 'A') {
if(gs1 && (jisdata[position + i] == '%')) { if(gs1 && (jisdata[position + i] == '%')) {
second = posn(RHODIUM, '%'); second = posn(RHODIUM, '%');
@ -344,35 +344,35 @@ void qr_binary(int datastream[], int version, int target_binlen, char mode[], in
if(debug) { printf("0x%4X ", prod); } if(debug) { printf("0x%4X ", prod); }
}; };
if(debug) { printf("\n"); } if(debug) { printf("\n"); }
break; break;
case 'N': case 'N':
/* Numeric mode */ /* Numeric mode */
/* Mode indicator */ /* Mode indicator */
concat(binary, "0001"); concat(binary, "0001");
/* Character count indicator */ /* Character count indicator */
qr_bscan(binary, short_data_block_length, 0x80 << (2 * scheme)); /* scheme = 1..3 */ qr_bscan(binary, short_data_block_length, 0x80 << (2 * scheme)); /* scheme = 1..3 */
if(debug) { printf("Number block (length %d)\n\t", short_data_block_length); } if(debug) { printf("Number block (length %d)\n\t", short_data_block_length); }
/* Character representation */ /* Character representation */
i = 0; i = 0;
while ( i < short_data_block_length ) { while ( i < short_data_block_length ) {
int count; int count;
int first = 0, second = 0, third = 0, prod; int first = 0, second = 0, third = 0, prod;
first = posn(NEON, (char) jisdata[position + i]); first = posn(NEON, (char) jisdata[position + i]);
count = 1; count = 1;
prod = first; prod = first;
if(mode[position + i + 1] == 'N') { if(mode[position + i + 1] == 'N') {
second = posn(NEON, (char) jisdata[position + i + 1]); second = posn(NEON, (char) jisdata[position + i + 1]);
count = 2; count = 2;
prod = (prod * 10) + second; prod = (prod * 10) + second;
if(mode[position + i + 2] == 'N') { if(mode[position + i + 2] == 'N') {
third = posn(NEON, (char) jisdata[position + i + 2]); third = posn(NEON, (char) jisdata[position + i + 2]);
count = 3; count = 3;
@ -383,18 +383,18 @@ void qr_binary(int datastream[], int version, int target_binlen, char mode[], in
qr_bscan(binary, prod, 1 << (3 * count)); /* count = 1..3 */ qr_bscan(binary, prod, 1 << (3 * count)); /* count = 1..3 */
if(debug) { printf("0x%4X (%d)", prod, prod); } if(debug) { printf("0x%4X (%d)", prod, prod); }
i += count; i += count;
}; };
if(debug) { printf("\n"); } if(debug) { printf("\n"); }
break; break;
} }
position += short_data_block_length; position += short_data_block_length;
} while (position < length) ; } while (position < length) ;
/* Terminator */ /* Terminator */
concat(binary, "0000"); concat(binary, "0000");
@ -402,7 +402,7 @@ void qr_binary(int datastream[], int version, int target_binlen, char mode[], in
padbits = 8 - (current_binlen % 8); padbits = 8 - (current_binlen % 8);
if(padbits == 8) { padbits = 0; } if(padbits == 8) { padbits = 0; }
current_bytes = (current_binlen + padbits) / 8; current_bytes = (current_binlen + padbits) / 8;
/* Padding bits */ /* Padding bits */
for(i = 0; i < padbits; i++) { for(i = 0; i < padbits; i++) {
concat(binary, "0"); concat(binary, "0");
@ -420,7 +420,7 @@ void qr_binary(int datastream[], int version, int target_binlen, char mode[], in
if(binary[i * 8 + 6] == '1') { datastream[i] += 0x02; } if(binary[i * 8 + 6] == '1') { datastream[i] += 0x02; }
if(binary[i * 8 + 7] == '1') { datastream[i] += 0x01; } if(binary[i * 8 + 7] == '1') { datastream[i] += 0x01; }
} }
/* Add pad codewords */ /* Add pad codewords */
toggle = 0; toggle = 0;
for(i = current_bytes; i < target_binlen; i++) { for(i = current_bytes; i < target_binlen; i++) {
@ -466,23 +466,23 @@ void add_ecc(int fullstream[], int datastream[], int version, int data_cw, int b
#endif #endif
posn = 0; posn = 0;
for(i = 0; i < blocks; i++) { for(i = 0; i < blocks; i++) {
if(i < qty_short_blocks) { length_this_block = short_data_block_length; } else { length_this_block = short_data_block_length + 1; } if(i < qty_short_blocks) { length_this_block = short_data_block_length; } else { length_this_block = short_data_block_length + 1; }
for(j = 0; j < ecc_block_length; j++) { for(j = 0; j < ecc_block_length; j++) {
ecc_block[j] = 0; ecc_block[j] = 0;
} }
for(j = 0; j < length_this_block; j++) { for(j = 0; j < length_this_block; j++) {
data_block[j] = (unsigned char) datastream[posn + j]; data_block[j] = (unsigned char) datastream[posn + j];
} }
rs_init_gf(0x11d); rs_init_gf(0x11d);
rs_init_code(ecc_block_length, 0); rs_init_code(ecc_block_length, 0);
rs_encode(length_this_block, data_block, ecc_block); rs_encode(length_this_block, data_block, ecc_block);
rs_free(); rs_free();
if(debug) { if(debug) {
printf("Block %d: ", i + 1); printf("Block %d: ", i + 1);
for(j = 0; j < length_this_block; j++) { for(j = 0; j < length_this_block; j++) {
@ -497,29 +497,29 @@ void add_ecc(int fullstream[], int datastream[], int version, int data_cw, int b
} }
printf("\n"); printf("\n");
} }
for(j = 0; j < short_data_block_length; j++) { for(j = 0; j < short_data_block_length; j++) {
interleaved_data[(j * blocks) + i] = (int) data_block[j]; interleaved_data[(j * blocks) + i] = (int) data_block[j];
} }
if(i >= qty_short_blocks){ if(i >= qty_short_blocks){
interleaved_data[(short_data_block_length * blocks) + (i - qty_short_blocks)] = (int) data_block[short_data_block_length]; interleaved_data[(short_data_block_length * blocks) + (i - qty_short_blocks)] = (int) data_block[short_data_block_length];
} }
for(j = 0; j < ecc_block_length; j++) { for(j = 0; j < ecc_block_length; j++) {
interleaved_ecc[(j * blocks) + i] = (int) ecc_block[ecc_block_length - j - 1]; interleaved_ecc[(j * blocks) + i] = (int) ecc_block[ecc_block_length - j - 1];
} }
posn += length_this_block; posn += length_this_block;
} }
for(j = 0; j < data_cw; j++) { for(j = 0; j < data_cw; j++) {
fullstream[j] = interleaved_data[j]; fullstream[j] = interleaved_data[j];
} }
for(j = 0; j < ecc_cw; j++) { for(j = 0; j < ecc_cw; j++) {
fullstream[j + data_cw] = interleaved_ecc[j]; fullstream[j + data_cw] = interleaved_ecc[j];
} }
if(debug) { if(debug) {
printf("\nData Stream: \n"); printf("\nData Stream: \n");
for(j = 0; j < (data_cw + ecc_cw); j++) { for(j = 0; j < (data_cw + ecc_cw); j++) {
@ -532,7 +532,7 @@ void add_ecc(int fullstream[], int datastream[], int version, int data_cw, int b
void place_finder(unsigned char grid[], int size, int x, int y) void place_finder(unsigned char grid[], int size, int x, int y)
{ {
int xp, yp; int xp, yp;
int finder[] = { int finder[] = {
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1,
@ -542,7 +542,7 @@ void place_finder(unsigned char grid[], int size, int x, int y)
1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1,
1, 1, 1, 1, 1, 1, 1 1, 1, 1, 1, 1, 1, 1
}; };
for(xp = 0; xp < 7; xp++) { for(xp = 0; xp < 7; xp++) {
for(yp = 0; yp < 7; yp++) { for(yp = 0; yp < 7; yp++) {
if (finder[xp + (7 * yp)] == 1) { if (finder[xp + (7 * yp)] == 1) {
@ -557,7 +557,7 @@ void place_finder(unsigned char grid[], int size, int x, int y)
void place_align(unsigned char grid[], int size, int x, int y) void place_align(unsigned char grid[], int size, int x, int y)
{ {
int xp, yp; int xp, yp;
int alignment[] = { int alignment[] = {
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 0, 0, 0, 1, 1, 0, 0, 0, 1,
@ -565,10 +565,10 @@ void place_align(unsigned char grid[], int size, int x, int y)
1, 0, 0, 0, 1, 1, 0, 0, 0, 1,
1, 1, 1, 1, 1 1, 1, 1, 1, 1
}; };
x -= 2; x -= 2;
y -= 2; /* Input values represent centre of pattern */ y -= 2; /* Input values represent centre of pattern */
for(xp = 0; xp < 5; xp++) { for(xp = 0; xp < 5; xp++) {
for(yp = 0; yp < 5; yp++) { for(yp = 0; yp < 5; yp++) {
if (alignment[xp + (5 * yp)] == 1) { if (alignment[xp + (5 * yp)] == 1) {
@ -597,12 +597,12 @@ void setup_grid(unsigned char* grid, int size, int version)
toggle = 1; toggle = 1;
} }
} }
/* Add finder patterns */ /* Add finder patterns */
place_finder(grid, size, 0, 0); place_finder(grid, size, 0, 0);
place_finder(grid, size, 0, size - 7); place_finder(grid, size, 0, size - 7);
place_finder(grid, size, size - 7, 0); place_finder(grid, size, size - 7, 0);
/* Add separators */ /* Add separators */
for(i = 0; i < 7; i++) { for(i = 0; i < 7; i++) {
grid[(7 * size) + i] = 0x10; grid[(7 * size) + i] = 0x10;
@ -615,24 +615,24 @@ void setup_grid(unsigned char* grid, int size, int version)
grid[(7 * size) + 7] = 0x10; grid[(7 * size) + 7] = 0x10;
grid[(7 * size) + (size - 8)] = 0x10; grid[(7 * size) + (size - 8)] = 0x10;
grid[((size - 8) * size) + 7] = 0x10; grid[((size - 8) * size) + 7] = 0x10;
/* Add alignment patterns */ /* Add alignment patterns */
if(version != 1) { if(version != 1) {
/* Version 1 does not have alignment patterns */ /* Version 1 does not have alignment patterns */
loopsize = qr_align_loopsize[version - 1]; loopsize = qr_align_loopsize[version - 1];
for(x = 0; x < loopsize; x++) { for(x = 0; x < loopsize; x++) {
for(y = 0; y < loopsize; y++) { for(y = 0; y < loopsize; y++) {
xcoord = qr_table_e1[((version - 2) * 7) + x]; xcoord = qr_table_e1[((version - 2) * 7) + x];
ycoord = qr_table_e1[((version - 2) * 7) + y]; ycoord = qr_table_e1[((version - 2) * 7) + y];
if(!(grid[(ycoord * size) + xcoord] & 0x10)) { if(!(grid[(ycoord * size) + xcoord] & 0x10)) {
place_align(grid, size, xcoord, ycoord); place_align(grid, size, xcoord, ycoord);
} }
} }
} }
} }
/* Reserve space for format information */ /* Reserve space for format information */
for(i = 0; i < 8; i++) { for(i = 0; i < 8; i++) {
grid[(8 * size) + i] += 0x20; grid[(8 * size) + i] += 0x20;
@ -642,7 +642,7 @@ void setup_grid(unsigned char* grid, int size, int version)
} }
grid[(8 * size) + 8] += 20; grid[(8 * size) + 8] += 20;
grid[((size - 1 - 7) * size) + 8] = 0x21; /* Dark Module from Figure 25 */ grid[((size - 1 - 7) * size) + 8] = 0x21; /* Dark Module from Figure 25 */
/* Reserve space for version information */ /* Reserve space for version information */
if(version >= 7) { if(version >= 7) {
for(i = 0; i < 6; i++) { for(i = 0; i < 6; i++) {
@ -679,9 +679,9 @@ void populate_grid(unsigned char* grid, int size, int* datastream, int cw)
{ {
int direction = 1; /* up */ int direction = 1; /* up */
int row = 0; /* right hand side */ int row = 0; /* right hand side */
int i, n, x, y; int i, n, x, y;
n = cw * 8; n = cw * 8;
y = size - 1; y = size - 1;
i = 0; i = 0;
@ -698,7 +698,7 @@ void populate_grid(unsigned char* grid, int size, int* datastream, int cw)
} }
i++; i++;
} }
if(i < n) { if(i < n) {
if(!(grid[(y * size) + x] & 0xf0)) { if(!(grid[(y * size) + x] & 0xf0)) {
if (cwbit(datastream, i)) { if (cwbit(datastream, i)) {
@ -709,7 +709,7 @@ void populate_grid(unsigned char* grid, int size, int* datastream, int cw)
i++; i++;
} }
} }
if(direction) { y--; } else { y++; } if(direction) { y--; } else { y++; }
if(y == -1) { if(y == -1) {
/* reached the top */ /* reached the top */
@ -755,7 +755,7 @@ int evaluate(unsigned char *grid, int size, int pattern)
} }
} }
} }
/* Test 1: Adjacent modules in row/column in same colour */ /* Test 1: Adjacent modules in row/column in same colour */
/* Vertical */ /* Vertical */
for(x = 0; x < size; x++) { for(x = 0; x < size; x++) {
@ -776,7 +776,7 @@ int evaluate(unsigned char *grid, int size, int pattern)
result += (3 + block); result += (3 + block);
} }
} }
/* Horizontal */ /* Horizontal */
for(y = 0; y < size; y++) { for(y = 0; y < size; y++) {
state = local[y * size]; state = local[y * size];
@ -796,9 +796,9 @@ int evaluate(unsigned char *grid, int size, int pattern)
result += (3 + block); result += (3 + block);
} }
} }
/* Test 2 is not implimented */ /* Test 2 is not implimented */
/* Test 3: 1:1:3:1:1 ratio pattern in row/column */ /* Test 3: 1:1:3:1:1 ratio pattern in row/column */
/* Vertical */ /* Vertical */
for(x = 0; x < size; x++) { for(x = 0; x < size; x++) {
@ -816,7 +816,7 @@ int evaluate(unsigned char *grid, int size, int pattern)
} }
} }
} }
/* Horizontal */ /* Horizontal */
for(y = 0; y < size; y++) { for(y = 0; y < size; y++) {
for(x = 0; x < (size - 7); x++) { for(x = 0; x < (size - 7); x++) {
@ -833,7 +833,7 @@ int evaluate(unsigned char *grid, int size, int pattern)
} }
} }
} }
/* Test 4: Proportion of dark modules in entire symbol */ /* Test 4: Proportion of dark modules in entire symbol */
dark_mods = 0; dark_mods = 0;
for(x = 0; x < size; x++) { for(x = 0; x < size; x++) {
@ -849,9 +849,9 @@ int evaluate(unsigned char *grid, int size, int pattern)
} else { } else {
k = (percentage - 50) / 5; k = (percentage - 50) / 5;
} }
result += 10 * k; result += 10 * k;
return result; return result;
} }
@ -876,7 +876,7 @@ int apply_bitmask(unsigned char *grid, int size)
for(x = 0; x < size; x++) { for(x = 0; x < size; x++) {
for(y = 0; y < size; y++) { for(y = 0; y < size; y++) {
mask[(y * size) + x] = 0x00; mask[(y * size) + x] = 0x00;
if (!(grid[(y * size) + x] & 0xf0)) { if (!(grid[(y * size) + x] & 0xf0)) {
if(((y + x) & 1) == 0) { mask[(y * size) + x] += 0x01; } if(((y + x) & 1) == 0) { mask[(y * size) + x] += 0x01; }
if((y & 1) == 0) { mask[(y * size) + x] += 0x02; } if((y & 1) == 0) { mask[(y * size) + x] += 0x02; }
@ -889,21 +889,21 @@ int apply_bitmask(unsigned char *grid, int size)
} }
} }
} }
for(x = 0; x < size; x++) { for(x = 0; x < size; x++) {
for(y = 0; y < size; y++) { for(y = 0; y < size; y++) {
if(grid[(y * size) + x] & 0x01) { p = 0xff; } else { p = 0x00; } if(grid[(y * size) + x] & 0x01) { p = 0xff; } else { p = 0x00; }
eval[(y * size) + x] = mask[(y * size) + x] ^ p; eval[(y * size) + x] = mask[(y * size) + x] ^ p;
} }
} }
/* Evaluate result */ /* Evaluate result */
for(pattern = 0; pattern < 8; pattern++) { for(pattern = 0; pattern < 8; pattern++) {
penalty[pattern] = evaluate(eval, size, pattern); penalty[pattern] = evaluate(eval, size, pattern);
} }
best_pattern = 0; best_pattern = 0;
best_val = penalty[0]; best_val = penalty[0];
for(pattern = 1; pattern < 8; pattern++) { for(pattern = 1; pattern < 8; pattern++) {
@ -912,7 +912,7 @@ int apply_bitmask(unsigned char *grid, int size)
best_val = penalty[pattern]; best_val = penalty[pattern];
} }
} }
/* Apply mask */ /* Apply mask */
for(x = 0; x < size; x++) { for(x = 0; x < size; x++) {
for(y = 0; y < size; y++) { for(y = 0; y < size; y++) {
@ -936,18 +936,18 @@ int apply_bitmask(unsigned char *grid, int size)
} }
} }
} }
return best_pattern; return best_pattern;
} }
void add_format_info(unsigned char *grid, int size, int ecc_level, int pattern) void add_format_info(unsigned char *grid, int size, int ecc_level, int pattern)
{ {
/* Add format information to grid */ /* Add format information to grid */
int format = pattern; int format = pattern;
unsigned int seq; unsigned int seq;
int i; int i;
switch(ecc_level) { switch(ecc_level) {
case LEVEL_L: format += 0x08; break; case LEVEL_L: format += 0x08; break;
case LEVEL_Q: format += 0x18; break; case LEVEL_Q: format += 0x18; break;
@ -955,23 +955,23 @@ void add_format_info(unsigned char *grid, int size, int ecc_level, int pattern)
} }
seq = qr_annex_c[format]; seq = qr_annex_c[format];
for(i = 0; i < 6; i++) { for(i = 0; i < 6; i++) {
grid[(i * size) + 8] += (seq >> i) & 0x01; grid[(i * size) + 8] += (seq >> i) & 0x01;
} }
for(i = 0; i < 8; i++) { for(i = 0; i < 8; i++) {
grid[(8 * size) + (size - i - 1)] += (seq >> i) & 0x01; grid[(8 * size) + (size - i - 1)] += (seq >> i) & 0x01;
} }
for(i = 0; i < 6; i++) { for(i = 0; i < 6; i++) {
grid[(8 * size) + (5 - i)] += (seq >> (i + 9)) & 0x01; grid[(8 * size) + (5 - i)] += (seq >> (i + 9)) & 0x01;
} }
for(i = 0; i < 7; i++) { for(i = 0; i < 7; i++) {
grid[(((size - 7) + i) * size) + 8] += (seq >> (i + 8)) & 0x01; grid[(((size - 7) + i) * size) + 8] += (seq >> (i + 8)) & 0x01;
} }
grid[(7 * size) + 8] += (seq >> 6) & 0x01; grid[(7 * size) + 8] += (seq >> 6) & 0x01;
grid[(8 * size) + 8] += (seq >> 7) & 0x01; grid[(8 * size) + 8] += (seq >> 7) & 0x01;
grid[(8 * size) + 7] += (seq >> 8) & 0x01; grid[(8 * size) + 7] += (seq >> 8) & 0x01;
@ -981,7 +981,7 @@ void add_version_info(unsigned char *grid, int size, int version)
{ {
/* Add version information */ /* Add version information */
int i; int i;
long int version_data = qr_annex_d[version - 7]; long int version_data = qr_annex_d[version - 7];
for(i = 0; i < 6; i++) { for(i = 0; i < 6; i++) {
grid[((size - 11) * size) + i] += (version_data >> (i * 3)) & 0x01; grid[((size - 11) * size) + i] += (version_data >> (i * 3)) & 0x01;
@ -1010,7 +1010,7 @@ int qr_code(struct zint_symbol *symbol, unsigned char source[], int length)
#endif #endif
gs1 = (symbol->input_mode == GS1_MODE); gs1 = (symbol->input_mode == GS1_MODE);
switch(symbol->input_mode) { switch(symbol->input_mode) {
case DATA_MODE: case DATA_MODE:
for(i = 0; i < length; i++) { for(i = 0; i < length; i++) {
@ -1043,10 +1043,10 @@ int qr_code(struct zint_symbol *symbol, unsigned char source[], int length)
} }
break; break;
} }
define_mode(mode, jisdata, length, gs1); define_mode(mode, jisdata, length, gs1);
est_binlen = estimate_binary_length(mode, length, gs1); est_binlen = estimate_binary_length(mode, length, gs1);
ecc_level = LEVEL_L; ecc_level = LEVEL_L;
max_cw = 2956; max_cw = 2956;
if((symbol->option_1 >= 1) && (symbol->option_1 <= 4)) { if((symbol->option_1 >= 1) && (symbol->option_1 <= 4)) {
@ -1057,12 +1057,12 @@ int qr_code(struct zint_symbol *symbol, unsigned char source[], int length)
case 4: ecc_level = LEVEL_H; max_cw = 1276; break; case 4: ecc_level = LEVEL_H; max_cw = 1276; break;
} }
} }
if(est_binlen > (8 * max_cw)) { if(est_binlen > (8 * max_cw)) {
strcpy(symbol->errtxt, "Input too long for selected error correction level"); strcpy(symbol->errtxt, "Input too long for selected error correction level");
return ERROR_TOO_LONG; return ERROR_TOO_LONG;
} }
autosize = 40; autosize = 40;
for(i = 39; i >= 0; i--) { for(i = 39; i >= 0; i--) {
switch(ecc_level) { switch(ecc_level) {
@ -1088,7 +1088,7 @@ int qr_code(struct zint_symbol *symbol, unsigned char source[], int length)
break; break;
} }
} }
if((symbol->option_2 >= 1) && (symbol->option_2 <= 40)) { if((symbol->option_2 >= 1) && (symbol->option_2 <= 40)) {
if (symbol->option_2 > autosize) { if (symbol->option_2 > autosize) {
version = symbol->option_2; version = symbol->option_2;
@ -1098,7 +1098,7 @@ int qr_code(struct zint_symbol *symbol, unsigned char source[], int length)
} else { } else {
version = autosize; version = autosize;
} }
/* Ensure maxium error correction capacity */ /* Ensure maxium error correction capacity */
if(est_binlen <= qr_data_codewords_M[version - 1]) { ecc_level = LEVEL_M; } if(est_binlen <= qr_data_codewords_M[version - 1]) { ecc_level = LEVEL_M; }
if(est_binlen <= qr_data_codewords_Q[version - 1]) { ecc_level = LEVEL_Q; } if(est_binlen <= qr_data_codewords_Q[version - 1]) { ecc_level = LEVEL_Q; }
@ -1121,7 +1121,7 @@ int qr_code(struct zint_symbol *symbol, unsigned char source[], int length)
qr_binary(datastream, version, target_binlen, mode, jisdata, length, gs1, est_binlen); qr_binary(datastream, version, target_binlen, mode, jisdata, length, gs1, est_binlen);
add_ecc(fullstream, datastream, version, target_binlen, blocks); add_ecc(fullstream, datastream, version, target_binlen, blocks);
size = qr_sizes[version - 1]; size = qr_sizes[version - 1];
#ifndef _MSC_VER #ifndef _MSC_VER
unsigned char grid[size * size]; unsigned char grid[size * size];
@ -1134,7 +1134,7 @@ int qr_code(struct zint_symbol *symbol, unsigned char source[], int length)
grid[(i * size) + j] = 0; grid[(i * size) + j] = 0;
} }
} }
setup_grid(grid, size, version); setup_grid(grid, size, version);
populate_grid(grid, size, fullstream, qr_total_codewords[version - 1]); populate_grid(grid, size, fullstream, qr_total_codewords[version - 1]);
bitmask = apply_bitmask(grid, size); bitmask = apply_bitmask(grid, size);
@ -1142,7 +1142,7 @@ int qr_code(struct zint_symbol *symbol, unsigned char source[], int length)
if(version >= 7) { if(version >= 7) {
add_version_info(grid, size, version); add_version_info(grid, size, version);
} }
symbol->width = size; symbol->width = size;
symbol->rows = size; symbol->rows = size;
@ -1154,7 +1154,7 @@ int qr_code(struct zint_symbol *symbol, unsigned char source[], int length)
} }
symbol->row_height[i] = 1; symbol->row_height[i] = 1;
} }
return 0; return 0;
} }
@ -1168,7 +1168,7 @@ int micro_qr_intermediate(char binary[], int jisdata[], char mode[], int length,
int short_data_block_length, i; int short_data_block_length, i;
char data_block; char data_block;
char buffer[2]; char buffer[2];
strcpy(binary, ""); strcpy(binary, "");
if(debug) { if(debug) {
@ -1177,37 +1177,37 @@ int micro_qr_intermediate(char binary[], int jisdata[], char mode[], int length,
} }
printf("\n"); printf("\n");
} }
do { do {
if(strlen(binary) > 128) { if(strlen(binary) > 128) {
return ERROR_TOO_LONG; return ERROR_TOO_LONG;
} }
data_block = mode[position]; data_block = mode[position];
short_data_block_length = 0; short_data_block_length = 0;
do { do {
short_data_block_length++; short_data_block_length++;
} while (((short_data_block_length + position) < length) && (mode[position + short_data_block_length] == data_block)); } while (((short_data_block_length + position) < length) && (mode[position + short_data_block_length] == data_block));
switch(data_block) { switch(data_block) {
case 'K': case 'K':
/* Kanji mode */ /* Kanji mode */
/* Mode indicator */ /* Mode indicator */
concat(binary, "K"); concat(binary, "K");
*kanji_used = 1; *kanji_used = 1;
/* Character count indicator */ /* Character count indicator */
buffer[0] = short_data_block_length; buffer[0] = short_data_block_length;
buffer[1] = '\0'; buffer[1] = '\0';
concat(binary, buffer); concat(binary, buffer);
if(debug) { printf("Kanji block (length %d)\n\t", short_data_block_length); } if(debug) { printf("Kanji block (length %d)\n\t", short_data_block_length); }
/* Character representation */ /* Character representation */
for(i = 0; i < short_data_block_length; i++) { for(i = 0; i < short_data_block_length; i++) {
int jis = jisdata[position + i]; int jis = jisdata[position + i];
int msb, lsb, prod; int msb, lsb, prod;
if(jis > 0x9fff) { jis -= 0xc140; } if(jis > 0x9fff) { jis -= 0xc140; }
msb = (jis & 0xff00) >> 4; msb = (jis & 0xff00) >> 4;
lsb = (jis & 0xff); lsb = (jis & 0xff);
@ -1216,28 +1216,28 @@ int micro_qr_intermediate(char binary[], int jisdata[], char mode[], int length,
qr_bscan(binary, prod, 0x1000); qr_bscan(binary, prod, 0x1000);
if(debug) { printf("0x%4X ", prod); } if(debug) { printf("0x%4X ", prod); }
if(strlen(binary) > 128) { if(strlen(binary) > 128) {
return ERROR_TOO_LONG; return ERROR_TOO_LONG;
} }
} }
if(debug) { printf("\n"); } if(debug) { printf("\n"); }
break; break;
case 'B': case 'B':
/* Byte mode */ /* Byte mode */
/* Mode indicator */ /* Mode indicator */
concat(binary, "B"); concat(binary, "B");
*byte_used = 1; *byte_used = 1;
/* Character count indicator */ /* Character count indicator */
buffer[0] = short_data_block_length; buffer[0] = short_data_block_length;
buffer[1] = '\0'; buffer[1] = '\0';
concat(binary, buffer); concat(binary, buffer);
if(debug) { printf("Byte block (length %d)\n\t", short_data_block_length); } if(debug) { printf("Byte block (length %d)\n\t", short_data_block_length); }
/* Character representation */ /* Character representation */
for(i = 0; i < short_data_block_length; i++) { for(i = 0; i < short_data_block_length; i++) {
int byte = jisdata[position + i]; int byte = jisdata[position + i];
@ -1245,38 +1245,38 @@ int micro_qr_intermediate(char binary[], int jisdata[], char mode[], int length,
qr_bscan(binary, byte, 0x80); qr_bscan(binary, byte, 0x80);
if(debug) { printf("0x%4X ", byte); } if(debug) { printf("0x%4X ", byte); }
if(strlen(binary) > 128) { if(strlen(binary) > 128) {
return ERROR_TOO_LONG; return ERROR_TOO_LONG;
} }
} }
if(debug) { printf("\n"); } if(debug) { printf("\n"); }
break; break;
case 'A': case 'A':
/* Alphanumeric mode */ /* Alphanumeric mode */
/* Mode indicator */ /* Mode indicator */
concat(binary, "A"); concat(binary, "A");
*alphanum_used = 1; *alphanum_used = 1;
/* Character count indicator */ /* Character count indicator */
buffer[0] = short_data_block_length; buffer[0] = short_data_block_length;
buffer[1] = '\0'; buffer[1] = '\0';
concat(binary, buffer); concat(binary, buffer);
if(debug) { printf("Alpha block (length %d)\n\t", short_data_block_length); } if(debug) { printf("Alpha block (length %d)\n\t", short_data_block_length); }
/* Character representation */ /* Character representation */
i = 0; i = 0;
while ( i < short_data_block_length ) { while ( i < short_data_block_length ) {
int count; int count;
int first = 0, second = 0, prod; int first = 0, second = 0, prod;
first = posn(RHODIUM, (char) jisdata[position + i]); first = posn(RHODIUM, (char) jisdata[position + i]);
count = 1; count = 1;
prod = first; prod = first;
if(mode[position + i + 1] == 'A') { if(mode[position + i + 1] == 'A') {
second = posn(RHODIUM, (char) jisdata[position + i + 1]); second = posn(RHODIUM, (char) jisdata[position + i + 1]);
count = 2; count = 2;
@ -1286,45 +1286,45 @@ int micro_qr_intermediate(char binary[], int jisdata[], char mode[], int length,
qr_bscan(binary, prod, 1 << (5 * count)); /* count = 1..2 */ qr_bscan(binary, prod, 1 << (5 * count)); /* count = 1..2 */
if(debug) { printf("0x%4X ", prod); } if(debug) { printf("0x%4X ", prod); }
if(strlen(binary) > 128) { if(strlen(binary) > 128) {
return ERROR_TOO_LONG; return ERROR_TOO_LONG;
} }
i += 2; i += 2;
}; };
if(debug) { printf("\n"); } if(debug) { printf("\n"); }
break; break;
case 'N': case 'N':
/* Numeric mode */ /* Numeric mode */
/* Mode indicator */ /* Mode indicator */
concat(binary, "N"); concat(binary, "N");
/* Character count indicator */ /* Character count indicator */
buffer[0] = short_data_block_length; buffer[0] = short_data_block_length;
buffer[1] = '\0'; buffer[1] = '\0';
concat(binary, buffer); concat(binary, buffer);
if(debug) { printf("Number block (length %d)\n\t", short_data_block_length); } if(debug) { printf("Number block (length %d)\n\t", short_data_block_length); }
/* Character representation */ /* Character representation */
i = 0; i = 0;
while ( i < short_data_block_length ) { while ( i < short_data_block_length ) {
int count; int count;
int first = 0, second = 0, third = 0, prod; int first = 0, second = 0, third = 0, prod;
first = posn(NEON, (char) jisdata[position + i]); first = posn(NEON, (char) jisdata[position + i]);
count = 1; count = 1;
prod = first; prod = first;
if(mode[position + i + 1] == 'N') { if(mode[position + i + 1] == 'N') {
second = posn(NEON, (char) jisdata[position + i + 1]); second = posn(NEON, (char) jisdata[position + i + 1]);
count = 2; count = 2;
prod = (prod * 10) + second; prod = (prod * 10) + second;
} }
if(mode[position + i + 2] == 'N') { if(mode[position + i + 2] == 'N') {
third = posn(NEON, (char) jisdata[position + i + 2]); third = posn(NEON, (char) jisdata[position + i + 2]);
count = 3; count = 3;