mirror of
https://github.com/zint/zint
synced 2024-11-16 20:57:25 +13:00
Refactor
This commit is contained in:
Rodrigo Torres
Robin Stuart
parent
1882d76b70
commit
4963a772db
@ -184,7 +184,7 @@ int logic_two_of_five(struct zint_symbol *symbol, unsigned char source[], int le
|
||||
/* Code 2 of 5 Interleaved */
|
||||
int interleaved_two_of_five(struct zint_symbol *symbol, const unsigned char source[], size_t length) {
|
||||
|
||||
int i, j, k, error_number;
|
||||
int i, j, error_number;
|
||||
char bars[7], spaces[7], mixed[14], dest[1000];
|
||||
#ifndef _MSC_VER
|
||||
unsigned char temp[length + 2];
|
||||
@ -222,7 +222,7 @@ int interleaved_two_of_five(struct zint_symbol *symbol, const unsigned char sour
|
||||
lookup(NEON, C25InterTable, temp[i + 1], spaces);
|
||||
|
||||
/* then merge (interlace) the strings together */
|
||||
k = 0;
|
||||
int k = 0;
|
||||
for (j = 0; j <= 4; j++) {
|
||||
mixed[k] = bars[j];
|
||||
k++;
|
||||
|
||||
@ -104,7 +104,7 @@ int australia_post(struct zint_symbol *symbol, unsigned char source[], int lengt
|
||||
1 = Tracker and Ascender
|
||||
2 = Tracker and Descender
|
||||
3 = Tracker only */
|
||||
int error_number, zeroes;
|
||||
int error_number;
|
||||
int writer;
|
||||
unsigned int loopey, reader;
|
||||
size_t h;
|
||||
@ -160,7 +160,7 @@ int australia_post(struct zint_symbol *symbol, unsigned char source[], int lengt
|
||||
}
|
||||
|
||||
/* Add leading zeros as required */
|
||||
zeroes = 8 - length;
|
||||
int zeroes = 8 - length;
|
||||
memset(localstr, '0', zeroes);
|
||||
localstr[8] = '\0';
|
||||
}
|
||||
|
||||
@ -135,13 +135,18 @@ static int aztec_text_process(const unsigned char source[], const size_t src_len
|
||||
int reduced_length;
|
||||
int byte_mode = 0;
|
||||
|
||||
encode_mode=(char*)alloca(src_len);
|
||||
reduced_source=(char*)alloca(src_len);
|
||||
reduced_encode_mode=(char*)alloca(src_len);
|
||||
encode_mode=(char*)malloc(src_len);
|
||||
reduced_source=(char*)malloc(src_len);
|
||||
reduced_encode_mode=(char*)malloc(src_len);
|
||||
|
||||
if ((!encode_mode) ||
|
||||
(!reduced_source) ||
|
||||
(!reduced_encode_mode)) return -1;
|
||||
(!reduced_encode_mode)) {
|
||||
free(encode_mode);
|
||||
free(reduced_source);
|
||||
free(reduced_encode_mode);
|
||||
return -1;
|
||||
}
|
||||
|
||||
for (i = 0; i < src_len; i++) {
|
||||
if (source[i] > 128) {
|
||||
@ -803,6 +808,10 @@ static int aztec_text_process(const unsigned char source[], const size_t src_len
|
||||
printf("%s\n", binary_string);
|
||||
}
|
||||
|
||||
free(encode_mode);
|
||||
free(reduced_source);
|
||||
free(reduced_encode_mode);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -842,7 +851,7 @@ static int avoidReferenceGrid(int output) {
|
||||
|
||||
/* Calculate the position of the bits in the grid */
|
||||
static void populate_map() {
|
||||
int layer, start, length, n, i;
|
||||
int layer, n, i;
|
||||
int x, y;
|
||||
|
||||
for (x = 0; x < 151; x++) {
|
||||
@ -852,8 +861,8 @@ static void populate_map() {
|
||||
}
|
||||
|
||||
for (layer = 1; layer < 33; layer++) {
|
||||
start = (112 * (layer - 1)) + (16 * (layer - 1) * (layer - 1)) + 2;
|
||||
length = 28 + ((layer - 1) * 4) + (layer * 4);
|
||||
const int start = (112 * (layer - 1)) + (16 * (layer - 1) * (layer - 1)) + 2;
|
||||
const int length = 28 + ((layer - 1) * 4) + (layer * 4);
|
||||
/* Top */
|
||||
i = 0;
|
||||
x = 64 - ((layer - 1) * 2);
|
||||
|
||||
@ -211,11 +211,9 @@ static int Columns2Rows(CharacterSetTable *T, unsigned char *data, const size_t
|
||||
int useColumns; /* Usable Characters per line */
|
||||
int fillings; /* Number of filling characters */
|
||||
int rowsCur;
|
||||
int charCur;
|
||||
int runChar;
|
||||
int emptyColumns; /* Number of codes still empty in line. */
|
||||
int emptyColumns2; /* Alternative emptyColumns to compare */
|
||||
int fOneLiner; /* Flag if One Liner */
|
||||
int CPaires; /* Number of digit pairs which may fit in the line */
|
||||
int characterSetCur; /* Current Character Set */
|
||||
|
||||
@ -226,9 +224,9 @@ static int Columns2Rows(CharacterSetTable *T, unsigned char *data, const size_t
|
||||
/* >>> Loop until rowsCur<44 */
|
||||
do {
|
||||
memset(pSet,0,dataLength*sizeof(int));
|
||||
charCur=0;
|
||||
int charCur=0;
|
||||
rowsCur=0;
|
||||
fOneLiner=1; /* First try one-Liner */
|
||||
int fOneLiner=1; /* First try one-Liner */
|
||||
|
||||
/* >>> Line and OneLiner-try Loop */
|
||||
do{
|
||||
@ -433,7 +431,6 @@ static int Columns2Rows(CharacterSetTable *T, unsigned char *data, const size_t
|
||||
static int Rows2Columns(CharacterSetTable *T, unsigned char *data, const size_t dataLength,
|
||||
int * pRows, int * pUseColumns, int * pSet, int * pFillings)
|
||||
{
|
||||
int errorCur;
|
||||
int rowsCur;
|
||||
int rowsRequested; /* Number of requested rows */
|
||||
int backupRows = 0;
|
||||
@ -473,7 +470,7 @@ static int Rows2Columns(CharacterSetTable *T, unsigned char *data, const size_t
|
||||
pTestList[testListSize] = testColumns;
|
||||
testListSize++;
|
||||
useColumns=testColumns; /* Make a copy because it may be modified */
|
||||
errorCur = Columns2Rows(T, data, dataLength, &rowsCur, &useColumns, pSet, &fillings);
|
||||
int errorCur = Columns2Rows(T, data, dataLength, &rowsCur, &useColumns, pSet, &fillings);
|
||||
if (errorCur != 0)
|
||||
return errorCur;
|
||||
if (rowsCur<=rowsRequested) {
|
||||
@ -711,7 +708,7 @@ int codablock(struct zint_symbol *symbol,const unsigned char source[], const siz
|
||||
if (columns > 64)
|
||||
columns = 64;
|
||||
#ifdef _DEBUG
|
||||
printf("Auto column count for %d characters:%d\n",dataLength,columns);
|
||||
printf("Auto column count for %zu characters:%d\n",dataLength,columns);
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
@ -188,7 +188,6 @@ int code_11(struct zint_symbol *symbol, unsigned char source[], int length) { /*
|
||||
int c39(struct zint_symbol *symbol, unsigned char source[], const size_t length) {
|
||||
unsigned int i;
|
||||
unsigned int counter;
|
||||
char check_digit;
|
||||
int error_number;
|
||||
char dest[775];
|
||||
char localstr[2] = {0};
|
||||
@ -223,6 +222,7 @@ int c39(struct zint_symbol *symbol, unsigned char source[], const size_t length)
|
||||
|
||||
if ((symbol->symbology == BARCODE_LOGMARS) || (symbol->option_2 == 1)) {
|
||||
|
||||
char check_digit;
|
||||
counter = counter % 43;
|
||||
if (counter < 10) {
|
||||
check_digit = itoc(counter);
|
||||
@ -465,13 +465,13 @@ int c93(struct zint_symbol *symbol, unsigned char source[], int length) {
|
||||
assume no liability for the use of this document." */
|
||||
|
||||
void CheckCharacter() {
|
||||
int i;
|
||||
char part[3];
|
||||
|
||||
if (value == target_value) {
|
||||
/* Target reached - save the generated pattern */
|
||||
strcpy(pattern, "11110");
|
||||
int i;
|
||||
for (i = 0; i < 11; i++) {
|
||||
char part[3];
|
||||
part[0] = itoc(S[i]);
|
||||
part[1] = itoc(B[i]);
|
||||
part[2] = '\0';
|
||||
|
||||
@ -143,7 +143,7 @@ int dq4bi(unsigned char source[], int sourcelen, int position) {
|
||||
static int c1_look_ahead_test(unsigned char source[], int sourcelen, int position, int current_mode, int gs1) {
|
||||
float ascii_count, c40_count, text_count, edi_count, byte_count;
|
||||
char reduced_char;
|
||||
int done, best_scheme, best_count, sp;
|
||||
int done, best_scheme, sp;
|
||||
|
||||
/* Step J */
|
||||
if (current_mode == C1_ASCII) {
|
||||
@ -285,7 +285,7 @@ static int c1_look_ahead_test(unsigned char source[], int sourcelen, int positio
|
||||
|
||||
if (sp == sourcelen) {
|
||||
/* Step K */
|
||||
best_count = (int) edi_count;
|
||||
int best_count = (int) edi_count;
|
||||
|
||||
if (text_count <= best_count) {
|
||||
best_count = (int) text_count;
|
||||
@ -303,7 +303,7 @@ static int c1_look_ahead_test(unsigned char source[], int sourcelen, int positio
|
||||
}
|
||||
|
||||
if (byte_count <= best_count) {
|
||||
best_count = (int) byte_count;
|
||||
// best_count = (int) byte_count;
|
||||
best_scheme = C1_BYTE;
|
||||
}
|
||||
} else {
|
||||
@ -361,11 +361,11 @@ int c1_encode(struct zint_symbol *symbol, unsigned char source[], unsigned int t
|
||||
sp = 0;
|
||||
tp = 0;
|
||||
latch = 0;
|
||||
memset(c40_buffer, 0, 6);
|
||||
memset(c40_buffer, 0, sizeof(*c40_buffer));
|
||||
c40_p = 0;
|
||||
memset(text_buffer, 0, 6);
|
||||
memset(text_buffer, 0, sizeof(*text_buffer));
|
||||
text_p = 0;
|
||||
memset(edi_buffer, 0, 6);
|
||||
memset(edi_buffer, 0, sizeof(*edi_buffer));
|
||||
edi_p = 0;
|
||||
strcpy(decimal_binary, "");
|
||||
|
||||
@ -538,10 +538,10 @@ int c1_encode(struct zint_symbol *symbol, unsigned char source[], unsigned int t
|
||||
|
||||
if (current_mode == C1_C40) {
|
||||
/* Step C - C40 encodation */
|
||||
int shift_set, value, done = 0, latch = 0;
|
||||
|
||||
next_mode = C1_C40;
|
||||
if (c40_p == 0) {
|
||||
int done = 0;
|
||||
if ((length - sp) >= 12) {
|
||||
j = 0;
|
||||
|
||||
@ -558,6 +558,7 @@ int c1_encode(struct zint_symbol *symbol, unsigned char source[], unsigned int t
|
||||
}
|
||||
|
||||
if ((length - sp) >= 8) {
|
||||
int latch = 0;
|
||||
j = 0;
|
||||
|
||||
for (i = 0; i < 8; i++) {
|
||||
@ -592,6 +593,7 @@ int c1_encode(struct zint_symbol *symbol, unsigned char source[], unsigned int t
|
||||
target[tp] = 255; /* Unlatch */
|
||||
tp++;
|
||||
} else {
|
||||
int shift_set, value;
|
||||
if (source[sp] > 127) {
|
||||
c40_buffer[c40_p] = 1;
|
||||
c40_p++;
|
||||
@ -639,10 +641,10 @@ int c1_encode(struct zint_symbol *symbol, unsigned char source[], unsigned int t
|
||||
|
||||
if (current_mode == C1_TEXT) {
|
||||
/* Step D - Text encodation */
|
||||
int shift_set, value, done = 0, latch = 0;
|
||||
|
||||
next_mode = C1_TEXT;
|
||||
if (text_p == 0) {
|
||||
int done = 0;
|
||||
if ((length - sp) >= 12) {
|
||||
j = 0;
|
||||
|
||||
@ -659,6 +661,7 @@ int c1_encode(struct zint_symbol *symbol, unsigned char source[], unsigned int t
|
||||
}
|
||||
|
||||
if ((length - sp) >= 8) {
|
||||
int latch = 0;
|
||||
j = 0;
|
||||
|
||||
for (i = 0; i < 8; i++) {
|
||||
@ -693,6 +696,7 @@ int c1_encode(struct zint_symbol *symbol, unsigned char source[], unsigned int t
|
||||
target[tp] = 255;
|
||||
tp++; /* Unlatch */
|
||||
} else {
|
||||
int shift_set, value;
|
||||
if (source[sp] > 127) {
|
||||
text_buffer[text_p] = 1;
|
||||
text_p++;
|
||||
@ -740,7 +744,6 @@ int c1_encode(struct zint_symbol *symbol, unsigned char source[], unsigned int t
|
||||
|
||||
if (current_mode == C1_EDI) {
|
||||
/* Step E - EDI Encodation */
|
||||
int value = 0, latch = 0;
|
||||
|
||||
next_mode = C1_EDI;
|
||||
if (edi_p == 0) {
|
||||
@ -759,6 +762,7 @@ int c1_encode(struct zint_symbol *symbol, unsigned char source[], unsigned int t
|
||||
}
|
||||
|
||||
if ((length - sp) >= 8) {
|
||||
int latch = 0;
|
||||
j = 0;
|
||||
|
||||
for (i = 0; i < 8; i++) {
|
||||
@ -792,6 +796,7 @@ int c1_encode(struct zint_symbol *symbol, unsigned char source[], unsigned int t
|
||||
target[tp] = 255; /* Unlatch */
|
||||
tp++;
|
||||
} else {
|
||||
int value = 0;
|
||||
if (source[sp] == 13) {
|
||||
value = 0;
|
||||
}
|
||||
@ -1179,7 +1184,7 @@ void block_copy(struct zint_symbol *symbol, char grid[][120], int start_row, int
|
||||
}
|
||||
|
||||
int code_one(struct zint_symbol *symbol, unsigned char source[], int length) {
|
||||
int size = 1, i, j, data_blocks;
|
||||
int size = 1, i, j;
|
||||
|
||||
char datagrid[136][120];
|
||||
int row, col;
|
||||
@ -1439,7 +1444,7 @@ int code_one(struct zint_symbol *symbol, unsigned char source[], int length) {
|
||||
sub_ecc[i] = 0;
|
||||
}
|
||||
|
||||
data_blocks = c1_blocks[size - 1];
|
||||
int data_blocks = c1_blocks[size - 1];
|
||||
|
||||
rs_init_gf(0x12d);
|
||||
rs_init_code(c1_ecc_blocks[size - 1], 0);
|
||||
|
||||
@ -102,16 +102,15 @@ int parunmodd(const unsigned char llyth) {
|
||||
* bring together same type blocks
|
||||
*/
|
||||
void grwp(int *indexliste) {
|
||||
int i, j;
|
||||
|
||||
/* bring together same type blocks */
|
||||
if (*(indexliste) > 1) {
|
||||
i = 1;
|
||||
int i = 1;
|
||||
while (i < *(indexliste)) {
|
||||
if (list[1][i - 1] == list[1][i]) {
|
||||
/* bring together */
|
||||
list[0][i - 1] = list[0][i - 1] + list[0][i];
|
||||
j = i + 1;
|
||||
int j = i + 1;
|
||||
|
||||
/* decreace the list */
|
||||
while (j < *(indexliste)) {
|
||||
@ -131,11 +130,11 @@ void grwp(int *indexliste) {
|
||||
* Implements rules from ISO 15417 Annex E
|
||||
*/
|
||||
void dxsmooth(int *indexliste) {
|
||||
int i, current, last, next, length;
|
||||
int i, last, next;
|
||||
|
||||
for (i = 0; i < *(indexliste); i++) {
|
||||
current = list[1][i];
|
||||
length = list[0][i];
|
||||
int current = list[1][i];
|
||||
int length = list[0][i];
|
||||
if (i != 0) {
|
||||
last = list[1][i - 1];
|
||||
} else {
|
||||
|
||||
@ -89,16 +89,15 @@ static const int C16KStopValues[16] = {
|
||||
};
|
||||
|
||||
static void grwp16(unsigned int *indexliste) {
|
||||
int i, j;
|
||||
|
||||
/* bring together same type blocks */
|
||||
if (*(indexliste) > 1) {
|
||||
i = 1;
|
||||
int i = 1;
|
||||
while(i < (int)*(indexliste)) {
|
||||
if (list[1][i - 1] == list[1][i]) {
|
||||
/* bring together */
|
||||
list[0][i - 1] = list[0][i - 1] + list[0][i];
|
||||
j = i + 1;
|
||||
int j = i + 1;
|
||||
|
||||
/* decreace the list */
|
||||
while(j < (int)*(indexliste)) {
|
||||
@ -116,11 +115,11 @@ static void grwp16(unsigned int *indexliste) {
|
||||
|
||||
/* Implements rules from ISO 15417 Annex E */
|
||||
static void dxsmooth16(unsigned int *indexliste) {
|
||||
int i, current, last, next, length;
|
||||
int i, last, next;
|
||||
|
||||
for(i = 0; i < (int)*(indexliste); i++) {
|
||||
current = list[1][i];
|
||||
length = list[0][i];
|
||||
int current = list[1][i];
|
||||
int length = list[0][i];
|
||||
if (i != 0) {
|
||||
last = list[1][i - 1];
|
||||
} else {
|
||||
@ -258,10 +257,10 @@ static void c16k_set_c(const unsigned char source_a, unsigned char source_b, uns
|
||||
|
||||
int code16k(struct zint_symbol *symbol, unsigned char source[], const size_t length) {
|
||||
char width_pattern[100];
|
||||
int current_row, rows_needed, flip_flop, looper, first_check, second_check;
|
||||
int current_row, rows_needed, looper, first_check, second_check;
|
||||
int indexchaine, f_state;
|
||||
char set[160] = {' '}, fset[160] = {' '}, mode, last_set, current_set;
|
||||
unsigned int pads_needed, indexliste, i, j, k, m, read, mx_reader, writer;
|
||||
unsigned int pads_needed, indexliste, i, j, k, m, read, mx_reader;
|
||||
unsigned int values[160] = {0};
|
||||
unsigned int bar_characters;
|
||||
float glyph_count;
|
||||
@ -705,8 +704,8 @@ int code16k(struct zint_symbol *symbol, unsigned char source[], const size_t len
|
||||
strcat(width_pattern, C16KStartStop[C16KStopValues[current_row]]);
|
||||
|
||||
/* Write the information into the symbol */
|
||||
writer = 0;
|
||||
flip_flop = 1;
|
||||
unsigned int writer = 0;
|
||||
int flip_flop = 1;
|
||||
for (mx_reader = 0; mx_reader < strlen(width_pattern); mx_reader++) {
|
||||
for (looper = 0; looper < ctoi(width_pattern[mx_reader]); looper++) {
|
||||
if (flip_flop == 1) {
|
||||
|
||||
@ -87,11 +87,11 @@ void to_upper(unsigned char source[]) {
|
||||
|
||||
/* Verifies that a string only uses valid characters */
|
||||
int is_sane(const char test_string[], const unsigned char source[], const size_t length) {
|
||||
unsigned int j, latch;
|
||||
unsigned int j;
|
||||
size_t i, lt = strlen(test_string);
|
||||
|
||||
for (i = 0; i < length; i++) {
|
||||
latch = FALSE;
|
||||
unsigned int latch = FALSE;
|
||||
for (j = 0; j < lt; j++) {
|
||||
if (source[i] == test_string[j]) {
|
||||
latch = TRUE;
|
||||
|
||||
@ -54,7 +54,7 @@
|
||||
extern "C" {
|
||||
#endif /* __cplusplus */
|
||||
|
||||
extern size_t ustrlen(const unsigned char source[]);
|
||||
extern size_t ustrlen(const unsigned char data[]);
|
||||
extern int ctoi(const char source);
|
||||
extern char itoc(const int source);
|
||||
extern void to_upper(unsigned char source[]);
|
||||
|
||||
@ -109,9 +109,10 @@ static void init928(void) {
|
||||
|
||||
/* converts bit string to base 928 values, codeWords[0] is highest order */
|
||||
static int encode928(UINT bitString[], UINT codeWords[], int bitLng) {
|
||||
int i, j, b, bitCnt, cwNdx, cwCnt, cwLng;
|
||||
int i, j, b, cwNdx, cwLng;
|
||||
for (cwNdx = cwLng = b = 0; b < bitLng; b += 69, cwNdx += 7) {
|
||||
bitCnt = _min(bitLng - b, 69);
|
||||
int bitCnt = _min(bitLng - b, 69);
|
||||
int cwCnt;
|
||||
cwLng += cwCnt = bitCnt / 10 + 1;
|
||||
for (i = 0; i < cwCnt; i++)
|
||||
codeWords[cwNdx + i] = 0; /* init 0 */
|
||||
@ -132,7 +133,7 @@ static int encode928(UINT bitString[], UINT codeWords[], int bitLng) {
|
||||
|
||||
/* CC-A 2D component */
|
||||
static int cc_a(struct zint_symbol *symbol, char source[], int cc_width) {
|
||||
int i, strpos, segment, bitlen, cwCnt, variant, rows;
|
||||
int i, segment, bitlen, cwCnt, variant, rows;
|
||||
int k, offset, j, total, rsCodeWords[8];
|
||||
int LeftRAPStart, RightRAPStart, CentreRAPStart, StartCluster;
|
||||
int LeftRAP, RightRAP, CentreRAP, Cluster, dummy[5];
|
||||
@ -162,7 +163,7 @@ static int cc_a(struct zint_symbol *symbol, char source[], int cc_width) {
|
||||
local_source[208] = '\0';
|
||||
|
||||
for (segment = 0; segment < 13; segment++) {
|
||||
strpos = segment * 16;
|
||||
int strpos = segment * 16;
|
||||
for (i = 0; i < 16; i++) {
|
||||
if (local_source[strpos + i] == '1') {
|
||||
bitStr[segment] += (0x8000 >> i);
|
||||
@ -335,7 +336,7 @@ static int cc_a(struct zint_symbol *symbol, char source[], int cc_width) {
|
||||
|
||||
/* CC-B 2D component */
|
||||
static int cc_b(struct zint_symbol *symbol, char source[], int cc_width) {
|
||||
int length, i, binloc;
|
||||
int length, i;
|
||||
#ifndef _MSC_VER
|
||||
unsigned char data_string[(strlen(source) / 8) + 3];
|
||||
#else
|
||||
@ -351,7 +352,7 @@ static int cc_b(struct zint_symbol *symbol, char source[], int cc_width) {
|
||||
length = strlen(source) / 8;
|
||||
|
||||
for (i = 0; i < length; i++) {
|
||||
binloc = i * 8;
|
||||
int binloc = i * 8;
|
||||
|
||||
data_string[i] = 0;
|
||||
for (p = 0; p < 8; p++) {
|
||||
@ -368,7 +369,7 @@ static int cc_b(struct zint_symbol *symbol, char source[], int cc_width) {
|
||||
chainemc[mclength] = 920;
|
||||
mclength++;
|
||||
|
||||
byteprocess(chainemc, &mclength, data_string, 0, length, 0);
|
||||
byteprocess(chainemc, &mclength, data_string, 0, length);
|
||||
|
||||
/* Now figure out which variant of the symbol to use and load values accordingly */
|
||||
|
||||
@ -588,7 +589,7 @@ static int cc_b(struct zint_symbol *symbol, char source[], int cc_width) {
|
||||
|
||||
/* CC-C 2D component - byte compressed PDF417 */
|
||||
static int cc_c(struct zint_symbol *symbol, char source[], int cc_width, int ecc_level) {
|
||||
int length, i, p, binloc;
|
||||
int length, i, p;
|
||||
#ifndef _MSC_VER
|
||||
unsigned char data_string[(strlen(source) / 8) + 4];
|
||||
#else
|
||||
@ -602,7 +603,7 @@ static int cc_c(struct zint_symbol *symbol, char source[], int cc_width, int ecc
|
||||
length = strlen(source) / 8;
|
||||
|
||||
for (i = 0; i < length; i++) {
|
||||
binloc = i * 8;
|
||||
int binloc = i * 8;
|
||||
|
||||
data_string[i] = 0;
|
||||
for (p = 0; p < 8; p++) {
|
||||
@ -619,7 +620,7 @@ static int cc_c(struct zint_symbol *symbol, char source[], int cc_width, int ecc
|
||||
chainemc[mclength] = 920; /* CC-C identifier */
|
||||
mclength++;
|
||||
|
||||
byteprocess(chainemc, &mclength, data_string, 0, length, 0);
|
||||
byteprocess(chainemc, &mclength, data_string, 0, length);
|
||||
|
||||
chainemc[0] = mclength;
|
||||
|
||||
@ -962,9 +963,7 @@ int calc_padding_ccc(int binary_length, int *cc_width, int lin_width, int *ecc)
|
||||
static int cc_binary_string(struct zint_symbol *symbol, const char source[], char binary_string[], int cc_mode, int *cc_width, int *ecc, int lin_width) { /* Handles all data encodation from section 5 of ISO/IEC 24723 */
|
||||
int encoding_method, read_posn, d1, d2, alpha_pad;
|
||||
int i, j, ai_crop, fnc1_latch;
|
||||
long int group_val;
|
||||
int ai90_mode, latch, remainder, binary_length;
|
||||
char date_str[4];
|
||||
#ifndef _MSC_VER
|
||||
char general_field[strlen(source) + 1], general_field_type[strlen(source) + 1];
|
||||
#else
|
||||
@ -1007,10 +1006,11 @@ static int cc_binary_string(struct zint_symbol *symbol, const char source[], cha
|
||||
read_posn = 2;
|
||||
} else {
|
||||
/* Production Date (11) or Expiration Date (17) */
|
||||
char date_str[4];
|
||||
date_str[0] = source[2];
|
||||
date_str[1] = source[3];
|
||||
date_str[2] = '\0';
|
||||
group_val = atoi(date_str) * 384;
|
||||
long int group_val = atoi(date_str) * 384;
|
||||
|
||||
date_str[0] = source[4];
|
||||
date_str[1] = source[5];
|
||||
@ -1048,9 +1048,7 @@ static int cc_binary_string(struct zint_symbol *symbol, const char source[], cha
|
||||
#else
|
||||
char* ninety = (char*) _alloca(strlen(source) + 1);
|
||||
#endif
|
||||
char numeric_part[4];
|
||||
int alpha, alphanum, numeric, test1, test2, test3, next_ai_posn;
|
||||
int numeric_value, table3_letter;
|
||||
int alpha, alphanum, numeric, test1, test2, test3;
|
||||
|
||||
/* "This encodation method may be used if an element string with an AI
|
||||
90 occurs at the start of the data message, and if the data field
|
||||
@ -1147,7 +1145,7 @@ static int cc_binary_string(struct zint_symbol *symbol, const char source[], cha
|
||||
}
|
||||
}
|
||||
|
||||
next_ai_posn = 2 + (int)strlen(ninety);
|
||||
int next_ai_posn = 2 + (int)strlen(ninety);
|
||||
|
||||
if (source[next_ai_posn] == '[') {
|
||||
/* There are more AIs afterwords */
|
||||
@ -1171,6 +1169,7 @@ static int cc_binary_string(struct zint_symbol *symbol, const char source[], cha
|
||||
break;
|
||||
}
|
||||
|
||||
char numeric_part[4];
|
||||
if (test1 == 0) {
|
||||
strcpy(numeric_part, "0");
|
||||
} else {
|
||||
@ -1180,9 +1179,9 @@ static int cc_binary_string(struct zint_symbol *symbol, const char source[], cha
|
||||
numeric_part[i] = '\0';
|
||||
}
|
||||
|
||||
numeric_value = atoi(numeric_part);
|
||||
int numeric_value = atoi(numeric_part);
|
||||
|
||||
table3_letter = -1;
|
||||
int table3_letter = -1;
|
||||
if (numeric_value < 31) {
|
||||
table3_letter = posn("BDHIJKLNPQRSTVWZ", ninety[test1]);
|
||||
}
|
||||
|
||||
@ -194,12 +194,12 @@ static void ecc200placement(int *array, const int NR, const int NC) {
|
||||
/* calculate and append ecc code, and if necessary interleave */
|
||||
static void ecc200(unsigned char *binary, const int bytes, const int datablock, const int rsblock, const int skew) {
|
||||
int blocks = (bytes + 2) / datablock, b;
|
||||
int n, p;
|
||||
int n;
|
||||
rs_init_gf(0x12d);
|
||||
rs_init_code(rsblock, 1);
|
||||
for (b = 0; b < blocks; b++) {
|
||||
unsigned char buf[256], ecc[256];
|
||||
p = 0;
|
||||
int p = 0;
|
||||
for (n = b; n < bytes; n += blocks)
|
||||
buf[p++] = binary[n];
|
||||
rs_encode(p, buf, ecc);
|
||||
@ -698,7 +698,6 @@ static int dm200encode(struct zint_symbol *symbol, const unsigned char source[],
|
||||
|
||||
/* step (c) C40 encodation */
|
||||
if (current_mode == DM_C40) {
|
||||
int shift_set, value;
|
||||
|
||||
next_mode = DM_C40;
|
||||
if (*process_p == 0) {
|
||||
@ -712,6 +711,7 @@ static int dm200encode(struct zint_symbol *symbol, const unsigned char source[],
|
||||
next_mode = DM_ASCII;
|
||||
if (debug) printf("ASC ");
|
||||
} else {
|
||||
int shift_set, value;
|
||||
if (source[sp] > 127) {
|
||||
process_buffer[*process_p] = 1;
|
||||
(*process_p)++;
|
||||
@ -761,7 +761,6 @@ static int dm200encode(struct zint_symbol *symbol, const unsigned char source[],
|
||||
|
||||
/* step (d) Text encodation */
|
||||
if (current_mode == DM_TEXT) {
|
||||
int shift_set, value;
|
||||
|
||||
next_mode = DM_TEXT;
|
||||
if (*process_p == 0) {
|
||||
@ -775,6 +774,7 @@ static int dm200encode(struct zint_symbol *symbol, const unsigned char source[],
|
||||
next_mode = DM_ASCII;
|
||||
if (debug) printf("ASC ");
|
||||
} else {
|
||||
int shift_set, value;
|
||||
if (source[sp] > 127) {
|
||||
process_buffer[*process_p] = 1;
|
||||
(*process_p)++;
|
||||
@ -824,7 +824,6 @@ static int dm200encode(struct zint_symbol *symbol, const unsigned char source[],
|
||||
|
||||
/* step (e) X12 encodation */
|
||||
if (current_mode == DM_X12) {
|
||||
int value = 0;
|
||||
|
||||
next_mode = DM_X12;
|
||||
if (*process_p == 0) {
|
||||
@ -838,6 +837,7 @@ static int dm200encode(struct zint_symbol *symbol, const unsigned char source[],
|
||||
next_mode = DM_ASCII;
|
||||
if (debug) printf("ASC ");
|
||||
} else {
|
||||
int value = 0;
|
||||
if (source[sp] == 13) {
|
||||
value = 0;
|
||||
}
|
||||
@ -885,7 +885,6 @@ static int dm200encode(struct zint_symbol *symbol, const unsigned char source[],
|
||||
|
||||
/* step (f) EDIFACT encodation */
|
||||
if (current_mode == DM_EDIFACT) {
|
||||
int value = 0;
|
||||
|
||||
next_mode = DM_EDIFACT;
|
||||
if (*process_p == 3) {
|
||||
@ -897,7 +896,7 @@ static int dm200encode(struct zint_symbol *symbol, const unsigned char source[],
|
||||
(*process_p)++;
|
||||
next_mode = DM_ASCII;
|
||||
} else {
|
||||
value = source[sp];
|
||||
int value = source[sp];
|
||||
|
||||
if (source[sp] >= 64) { // '@'
|
||||
value -= 64;
|
||||
@ -1148,7 +1147,6 @@ int data_matrix_200(struct zint_symbol *symbol,const unsigned char source[], con
|
||||
int taillength, error_number = 0;
|
||||
int H, W, FH, FW, datablock, bytes, rsblock;
|
||||
int last_mode = DM_ASCII;
|
||||
unsigned char *grid = 0;
|
||||
int symbols_left;
|
||||
|
||||
/* inputlen may be decremented by 2 if macro character is used */
|
||||
@ -1247,7 +1245,7 @@ int data_matrix_200(struct zint_symbol *symbol,const unsigned char source[], con
|
||||
NR = H - 2 * (H / FH);
|
||||
places = (int*) malloc(NC * NR * sizeof (int));
|
||||
ecc200placement(places, NR, NC);
|
||||
grid = (unsigned char*) malloc(W * H);
|
||||
unsigned char *grid = (unsigned char*) malloc(W * H);
|
||||
memset(grid, 0, W * H);
|
||||
for (y = 0; y < H; y += FH) {
|
||||
for (x = 0; x < W; x++)
|
||||
|
||||
@ -44,7 +44,7 @@
|
||||
extern "C" {
|
||||
#endif /* __cplusplus */
|
||||
|
||||
extern int data_matrix_200(struct zint_symbol *symbol, const unsigned char source[], const size_t length);
|
||||
extern int data_matrix_200(struct zint_symbol *symbol, const unsigned char source[], const size_t in_length);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
||||
@ -436,7 +436,7 @@ int binary(const unsigned char source[], int position) {
|
||||
int dotcode_encode_message(struct zint_symbol *symbol, const unsigned char source[], int length, unsigned char *codeword_array, int *binary_finish) {
|
||||
int input_position, array_length, i;
|
||||
char encoding_mode;
|
||||
int inside_macro, done;
|
||||
int inside_macro;
|
||||
int debug = symbol->debug;
|
||||
int binary_buffer_size = 0;
|
||||
int lawrencium[6]; // Reversed radix 103 values
|
||||
@ -524,7 +524,7 @@ int dotcode_encode_message(struct zint_symbol *symbol, const unsigned char sourc
|
||||
}
|
||||
|
||||
do {
|
||||
done = 0;
|
||||
int done = 0;
|
||||
/* Step A */
|
||||
if ((input_position == length - 2) && (inside_macro != 0) && (inside_macro != 100)) {
|
||||
// inside_macro only gets set to 97, 98 or 99 if the last two characters are RS/EOT
|
||||
|
||||
@ -40,8 +40,6 @@
|
||||
|
||||
/* Convert Unicode to other character encodings */
|
||||
int utf_to_eci(const int eci, const unsigned char source[], unsigned char dest[], size_t *length) {
|
||||
int glyph;
|
||||
int bytelen;
|
||||
int in_posn;
|
||||
int out_posn;
|
||||
int ext;
|
||||
@ -60,8 +58,8 @@ int utf_to_eci(const int eci, const unsigned char source[], unsigned char dest[]
|
||||
out_posn = 0;
|
||||
do {
|
||||
/* Single byte (ASCII) character */
|
||||
bytelen = 1;
|
||||
glyph = (int) source[in_posn];
|
||||
int bytelen = 1;
|
||||
int glyph = (int) source[in_posn];
|
||||
|
||||
if ((source[in_posn] >= 0x80) && (source[in_posn] < 0xc0)) {
|
||||
/* Something has gone wrong, abort */
|
||||
|
||||
@ -43,13 +43,12 @@
|
||||
|
||||
int count_rectangles(struct zint_symbol *symbol) {
|
||||
int rectangles = 0;
|
||||
int this_row;
|
||||
int latch, i;
|
||||
|
||||
if ((symbol->symbology != BARCODE_MAXICODE) &&
|
||||
((symbol->output_options & BARCODE_DOTTY_MODE) == 0)) {
|
||||
int this_row;
|
||||
for(this_row = 0; this_row < symbol->rows; this_row++) {
|
||||
latch = 0;
|
||||
int i, latch = 0;
|
||||
for(i = 0; i < symbol->width; i++) {
|
||||
if ((module_is_set(symbol, this_row, i)) && (latch == 0)) {
|
||||
latch = 1;
|
||||
@ -68,12 +67,12 @@ int count_rectangles(struct zint_symbol *symbol) {
|
||||
|
||||
int count_circles(struct zint_symbol *symbol) {
|
||||
int circles = 0;
|
||||
int this_row;
|
||||
int i;
|
||||
|
||||
if ((symbol->symbology != BARCODE_MAXICODE) &&
|
||||
((symbol->output_options & BARCODE_DOTTY_MODE) != 0)) {
|
||||
int this_row;
|
||||
for(this_row = 0; this_row < symbol->rows; this_row++) {
|
||||
int i;
|
||||
for(i = 0; i < symbol->width; i++) {
|
||||
if (module_is_set(symbol, this_row, i)) {
|
||||
circles++;
|
||||
@ -87,11 +86,11 @@ int count_circles(struct zint_symbol *symbol) {
|
||||
|
||||
int count_hexagons(struct zint_symbol *symbol) {
|
||||
int hexagons = 0;
|
||||
int this_row;
|
||||
int i;
|
||||
|
||||
if (symbol->symbology == BARCODE_MAXICODE) {
|
||||
int this_row;
|
||||
for(this_row = 0; this_row < symbol->rows; this_row++) {
|
||||
int i;
|
||||
for(i = 0; i < symbol->width; i++) {
|
||||
if (module_is_set(symbol, this_row, i)) {
|
||||
hexagons++;
|
||||
@ -137,7 +136,7 @@ int bump_up(int input) {
|
||||
|
||||
int emf_plot(struct zint_symbol *symbol) {
|
||||
int i, block_width, latch, this_row;
|
||||
float large_bar_height, preset_height, row_height, row_posn;
|
||||
float large_bar_height, preset_height, row_height;
|
||||
FILE *emf_file;
|
||||
int fgred, fggrn, fgblu, bgred, bggrn, bgblu;
|
||||
int error_number = 0;
|
||||
@ -751,7 +750,7 @@ int emf_plot(struct zint_symbol *symbol) {
|
||||
} else {
|
||||
row_height = symbol->row_height[this_row];
|
||||
}
|
||||
row_posn = 0;
|
||||
float row_posn = 0;
|
||||
for (i = 0; i < this_row; i++) {
|
||||
if (symbol->row_height[i] == 0) {
|
||||
row_posn += large_bar_height;
|
||||
|
||||
@ -49,13 +49,13 @@ int number_lat(int gbdata[], const size_t length, const size_t position) {
|
||||
a string which has "2.2.0" (cannot have more than one non-numeric character for each
|
||||
block of three numeric characters) */
|
||||
size_t sp;
|
||||
int numb = 0, nonum = 0, done;
|
||||
int numb = 0, nonum = 0;
|
||||
int tally = 0;
|
||||
|
||||
sp = position;
|
||||
|
||||
do {
|
||||
done = 0;
|
||||
int done = 0;
|
||||
|
||||
if ((gbdata[sp] >= '0') && (gbdata[sp] <= '9')) {
|
||||
numb++;
|
||||
@ -125,7 +125,7 @@ static int seek_forward(int gbdata[], const size_t length, const size_t position
|
||||
possible combinations of input data */
|
||||
|
||||
int number_count, byte_count, mixed_count, upper_count, lower_count, chinese_count;
|
||||
int best_mode, done;
|
||||
int best_mode;
|
||||
size_t sp;
|
||||
int best_count, last = -1;
|
||||
int debug = 0;
|
||||
@ -194,7 +194,7 @@ static int seek_forward(int gbdata[], const size_t length, const size_t position
|
||||
|
||||
for (sp = position; (sp < length) && (sp <= (position + 8)); sp++) {
|
||||
|
||||
done = 0;
|
||||
int done = 0;
|
||||
|
||||
if (gbdata[sp] >= 0xff) {
|
||||
byte_count += 17;
|
||||
@ -347,7 +347,7 @@ static int gm_encode(int gbdata[], const size_t length, char binary[],const int
|
||||
/* Create a binary stream representation of the input data.
|
||||
7 sets are defined - Chinese characters, Numerals, Lower case letters, Upper case letters,
|
||||
Mixed numerals and latters, Control characters and 8-bit binary data */
|
||||
int sp, current_mode, next_mode, last_mode, glyph = 0;
|
||||
int sp, current_mode, last_mode, glyph = 0;
|
||||
int c1, c2, done;
|
||||
int p = 0, ppos;
|
||||
int numbuf[3], punt = 0;
|
||||
@ -383,7 +383,7 @@ static int gm_encode(int gbdata[], const size_t length, char binary[],const int
|
||||
}
|
||||
|
||||
do {
|
||||
next_mode = seek_forward(gbdata, length, sp, current_mode);
|
||||
int next_mode = seek_forward(gbdata, length, sp, current_mode);
|
||||
|
||||
if (next_mode != current_mode) {
|
||||
switch (current_mode) {
|
||||
@ -800,7 +800,7 @@ static int gm_encode(int gbdata[], const size_t length, char binary[],const int
|
||||
static void gm_add_ecc(const char binary[], const size_t data_posn, const int layers, const int ecc_level, int word[]) {
|
||||
int data_cw, i, j, wp, p;
|
||||
int n1, b1, n2, b2, e1, b3, e2;
|
||||
int block_size, data_size, ecc_size;
|
||||
int block_size, ecc_size;
|
||||
int data[1320], block[130];
|
||||
unsigned char data_block[115], ecc_block[70];
|
||||
|
||||
@ -851,7 +851,7 @@ static void gm_add_ecc(const char binary[], const size_t data_posn, const int la
|
||||
} else {
|
||||
ecc_size = e2;
|
||||
}
|
||||
data_size = block_size - ecc_size;
|
||||
int data_size = block_size - ecc_size;
|
||||
|
||||
/* printf("block %d/%d: data %d / ecc %d\n", i + 1, (b1 + b2), data_size, ecc_size);*/
|
||||
|
||||
@ -1000,9 +1000,9 @@ void place_layer_id(char* grid, int size, int layers, int modules, int ecc_level
|
||||
}
|
||||
|
||||
int grid_matrix(struct zint_symbol *symbol, const unsigned char source[], size_t length) {
|
||||
int size, modules, dark, error_number;
|
||||
int size, modules, error_number;
|
||||
int auto_layers, min_layers, layers, auto_ecc_level, min_ecc_level, ecc_level;
|
||||
int x, y, i, j, glyph;
|
||||
int x, y, i;
|
||||
char binary[9300];
|
||||
int data_cw, input_latch = 0;
|
||||
int word[1460], data_max, reader = 0;
|
||||
@ -1035,8 +1035,8 @@ int grid_matrix(struct zint_symbol *symbol, const unsigned char source[], size_t
|
||||
if (utfdata[i] <= 0xff) {
|
||||
gbdata[i] = utfdata[i];
|
||||
} else {
|
||||
j = 0;
|
||||
glyph = 0;
|
||||
int j = 0;
|
||||
int glyph = 0;
|
||||
do {
|
||||
if (gb2312_lookup[j * 2] == utfdata[i]) {
|
||||
glyph = gb2312_lookup[(j * 2) + 1];
|
||||
@ -1174,7 +1174,7 @@ int grid_matrix(struct zint_symbol *symbol, const unsigned char source[], size_t
|
||||
|
||||
/* Add macromodule frames */
|
||||
for (x = 0; x < modules; x++) {
|
||||
dark = 1 - (x & 1);
|
||||
int dark = 1 - (x & 1);
|
||||
for (y = 0; y < modules; y++) {
|
||||
if (dark == 1) {
|
||||
for (i = 0; i < 5; i++) {
|
||||
|
||||
@ -228,11 +228,10 @@ int isFourByte(int glyph, int glyph2) {
|
||||
static void hx_define_mode(char mode[], int source[], const size_t length) {
|
||||
size_t i;
|
||||
char lastmode = 't';
|
||||
int done;
|
||||
|
||||
i = 0;
|
||||
do {
|
||||
done = 0;
|
||||
int done = 0;
|
||||
|
||||
if (isRegion1(source[i])) {
|
||||
mode[i] = '1';
|
||||
@ -330,7 +329,6 @@ int lookup_text2(char input) {
|
||||
|
||||
/* Convert input data to binary stream */
|
||||
static void calculate_binary(char binary[], char mode[], int source[], const size_t length, const int eci, int debug) {
|
||||
int block_length;
|
||||
int position = 0;
|
||||
int i, count, encoding_value;
|
||||
int first_byte, second_byte;
|
||||
@ -355,7 +353,7 @@ static void calculate_binary(char binary[], char mode[], int source[], const siz
|
||||
}
|
||||
|
||||
do {
|
||||
block_length = 0;
|
||||
int block_length = 0;
|
||||
do {
|
||||
block_length++;
|
||||
} while (mode[position + block_length] == mode[position]);
|
||||
@ -373,19 +371,19 @@ static void calculate_binary(char binary[], char mode[], int source[], const siz
|
||||
i = 0;
|
||||
|
||||
while (i < block_length) {
|
||||
int first = 0, second = 0, third = 0;
|
||||
int first = 0;
|
||||
|
||||
first = posn(NEON, (char) source[position + i]);
|
||||
count = 1;
|
||||
encoding_value = first;
|
||||
|
||||
if (i + 1 < block_length && mode[position + i + 1] == 'n') {
|
||||
second = posn(NEON, (char) source[position + i + 1]);
|
||||
int second = posn(NEON, (char) source[position + i + 1]);
|
||||
count = 2;
|
||||
encoding_value = (encoding_value * 10) + second;
|
||||
|
||||
if (i + 2 < block_length && mode[position + i + 2] == 'n') {
|
||||
third = posn(NEON, (char) source[position + i + 2]);
|
||||
int third = posn(NEON, (char) source[position + i + 2]);
|
||||
count = 3;
|
||||
encoding_value = (encoding_value * 10) + third;
|
||||
}
|
||||
@ -910,15 +908,14 @@ void hx_add_ecc(unsigned char fullstream[], unsigned char datastream[], int vers
|
||||
unsigned char data_block[180];
|
||||
unsigned char ecc_block[36];
|
||||
int i, j, block;
|
||||
int batch_size, data_length, ecc_length;
|
||||
int input_position = -1;
|
||||
int output_position = -1;
|
||||
int table_d1_pos = ((version - 1) * 36) + ((ecc_level - 1) * 9);
|
||||
|
||||
for (i = 0; i < 3; i++) {
|
||||
batch_size = hx_table_d1[table_d1_pos + (3 * i)];
|
||||
data_length = hx_table_d1[table_d1_pos + (3 * i) + 1];
|
||||
ecc_length = hx_table_d1[table_d1_pos + (3 * i) + 2];
|
||||
int batch_size = hx_table_d1[table_d1_pos + (3 * i)];
|
||||
int data_length = hx_table_d1[table_d1_pos + (3 * i) + 1];
|
||||
int ecc_length = hx_table_d1[table_d1_pos + (3 * i) + 2];
|
||||
|
||||
for (block = 0; block < batch_size; block++) {
|
||||
for (j = 0; j < data_length; j++) {
|
||||
@ -1228,13 +1225,11 @@ int hx_apply_bitmask(unsigned char *grid, int size) {
|
||||
int han_xin(struct zint_symbol *symbol, const unsigned char source[], size_t length) {
|
||||
int est_binlen;
|
||||
int ecc_level = symbol->option_1;
|
||||
int i, j, version, posn = 0;
|
||||
int i, j, version;
|
||||
int data_codewords = 0, size;
|
||||
int codewords;
|
||||
int bitmask;
|
||||
int error_number;
|
||||
int bin_len;
|
||||
int done;
|
||||
char function_information[36];
|
||||
unsigned char fi_cw[3] = {0, 0, 0};
|
||||
unsigned char fi_ecc[4];
|
||||
@ -1260,14 +1255,14 @@ int han_xin(struct zint_symbol *symbol, const unsigned char source[], size_t len
|
||||
}
|
||||
} else {
|
||||
/* Convert Unicode input to GB-18030 */
|
||||
error_number = utf8toutf16(symbol, source, utfdata, &length);
|
||||
int error_number = utf8toutf16(symbol, source, utfdata, &length);
|
||||
if (error_number != 0) {
|
||||
return error_number;
|
||||
}
|
||||
|
||||
posn = 0;
|
||||
int posn = 0;
|
||||
for (i = 0; i < length; i++) {
|
||||
done = 0;
|
||||
int done = 0;
|
||||
gbdata[posn] = 0;
|
||||
|
||||
/* Single byte characters in range U+0000 -> U+007F */
|
||||
|
||||
@ -36,11 +36,11 @@
|
||||
#include "large.h"
|
||||
|
||||
void binary_add(short int accumulator[], short int input_buffer[]) { /* Binary addition */
|
||||
int i, carry, done;
|
||||
int i, carry;
|
||||
carry = 0;
|
||||
|
||||
for (i = 0; i < 112; i++) {
|
||||
done = 0;
|
||||
int done = 0;
|
||||
if (((input_buffer[i] == 0) && (accumulator[i] == 0))
|
||||
&& ((carry == 0) && (done == 0))) {
|
||||
accumulator[i] = 0;
|
||||
|
||||
@ -102,22 +102,22 @@ void ZBarcode_Delete(struct zint_symbol *symbol) {
|
||||
|
||||
// If there is a rendered version, ensure its memory is released
|
||||
if (symbol->rendered != NULL) {
|
||||
struct zint_render_line *line, *l;
|
||||
struct zint_render_string *string, *s;
|
||||
struct zint_render_ring *ring, *r;
|
||||
struct zint_render_hexagon *hexagon, *h;
|
||||
struct zint_render_line *line;
|
||||
struct zint_render_string *string;
|
||||
struct zint_render_ring *ring;
|
||||
struct zint_render_hexagon *hexagon;
|
||||
|
||||
// Free lines
|
||||
line = symbol->rendered->lines;
|
||||
while (line) {
|
||||
l = line;
|
||||
struct zint_render_line *l = line;
|
||||
line = line->next;
|
||||
free(l);
|
||||
}
|
||||
// Free Strings
|
||||
string = symbol->rendered->strings;
|
||||
while (string) {
|
||||
s = string;
|
||||
struct zint_render_string *s = string;
|
||||
string = string->next;
|
||||
free(s->text);
|
||||
free(s);
|
||||
@ -126,7 +126,7 @@ void ZBarcode_Delete(struct zint_symbol *symbol) {
|
||||
// Free Rings
|
||||
ring = symbol->rendered->rings;
|
||||
while (ring) {
|
||||
r = ring;
|
||||
struct zint_render_ring *r = ring;
|
||||
ring = ring->next;
|
||||
free(r);
|
||||
}
|
||||
@ -134,7 +134,7 @@ void ZBarcode_Delete(struct zint_symbol *symbol) {
|
||||
// Free Hexagons
|
||||
hexagon = symbol->rendered->hexagons;
|
||||
while (hexagon) {
|
||||
h = hexagon;
|
||||
struct zint_render_hexagon *h = hexagon;
|
||||
hexagon = hexagon->next;
|
||||
free(h);
|
||||
}
|
||||
@ -215,9 +215,9 @@ extern int svg_plot(struct zint_symbol *symbol); /* Plot to SVG */
|
||||
extern int emf_plot(struct zint_symbol *symbol); /* Plot to Metafile */
|
||||
|
||||
void error_tag(char error_string[], int error_number) {
|
||||
char error_buffer[100];
|
||||
|
||||
if (error_number != 0) {
|
||||
char error_buffer[100];
|
||||
strcpy(error_buffer, error_string);
|
||||
|
||||
if (error_number > 4) {
|
||||
@ -234,7 +234,6 @@ void error_tag(char error_string[], int error_number) {
|
||||
int dump_plot(struct zint_symbol *symbol) {
|
||||
FILE *f;
|
||||
int i, r;
|
||||
int byt;
|
||||
char hex[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8',
|
||||
'9', 'A', 'B', 'C', 'D', 'E', 'F'};
|
||||
int space = 0;
|
||||
@ -250,7 +249,7 @@ int dump_plot(struct zint_symbol *symbol) {
|
||||
}
|
||||
|
||||
for (r = 0; r < symbol->rows; r++) {
|
||||
byt = 0;
|
||||
int byt = 0;
|
||||
for (i = 0; i < symbol->width; i++) {
|
||||
byt = byt << 1;
|
||||
if (module_is_set(symbol, r, i)) {
|
||||
@ -1083,7 +1082,6 @@ int ZBarcode_Encode(struct zint_symbol *symbol, const unsigned char *source,int
|
||||
|
||||
int ZBarcode_Print(struct zint_symbol *symbol, int rotate_angle) {
|
||||
int error_number;
|
||||
char output[4];
|
||||
|
||||
switch (rotate_angle) {
|
||||
case 0:
|
||||
@ -1104,6 +1102,7 @@ int ZBarcode_Print(struct zint_symbol *symbol, int rotate_angle) {
|
||||
}
|
||||
|
||||
if (strlen(symbol->outfile) > 3) {
|
||||
char output[4];
|
||||
output[0] = symbol->outfile[strlen(symbol->outfile) - 3];
|
||||
output[1] = symbol->outfile[strlen(symbol->outfile) - 2];
|
||||
output[2] = symbol->outfile[strlen(symbol->outfile) - 1];
|
||||
|
||||
@ -588,8 +588,8 @@ void maxi_do_primary_3(char postcode[], int country, int service) {
|
||||
maxi_codeword[9] = ((service & 0x3f0) >> 4);
|
||||
}
|
||||
|
||||
int maxicode(struct zint_symbol *symbol, unsigned char local_source[], int length) {
|
||||
int i, j, block, bit, mode, countrycode = 0, service = 0, lp = 0;
|
||||
int maxicode(struct zint_symbol *symbol, unsigned char local_source[], const int length) {
|
||||
int i, j, block, bit, mode, lp = 0;
|
||||
int bit_pattern[7], internal_error = 0, eclen;
|
||||
char postcode[12], countrystr[4], servicestr[4];
|
||||
|
||||
@ -659,8 +659,8 @@ int maxicode(struct zint_symbol *symbol, unsigned char local_source[], int lengt
|
||||
servicestr[2] = symbol->primary[14];
|
||||
servicestr[3] = '\0';
|
||||
|
||||
countrycode = atoi(countrystr);
|
||||
service = atoi(servicestr);
|
||||
int countrycode = atoi(countrystr);
|
||||
int service = atoi(servicestr);
|
||||
|
||||
if (mode == 2) {
|
||||
maxi_do_primary_2(postcode, countrycode, service);
|
||||
|
||||
@ -235,7 +235,7 @@ int codabar(struct zint_symbol *symbol, unsigned char source[], int length) {
|
||||
int code32(struct zint_symbol *symbol, unsigned char source[], int length) {
|
||||
int i, zeroes, error_number, checksum, checkpart, checkdigit;
|
||||
char localstr[10], risultante[7];
|
||||
long int pharmacode, remainder, devisor;
|
||||
long int pharmacode, devisor;
|
||||
int codeword[6];
|
||||
char tabella[34];
|
||||
|
||||
@ -281,7 +281,7 @@ int code32(struct zint_symbol *symbol, unsigned char source[], int length) {
|
||||
devisor = 33554432;
|
||||
for (i = 5; i >= 0; i--) {
|
||||
codeword[i] = pharmacode / devisor;
|
||||
remainder = pharmacode % devisor;
|
||||
long int remainder = pharmacode % devisor;
|
||||
pharmacode = remainder;
|
||||
devisor /= 32;
|
||||
}
|
||||
|
||||
@ -101,16 +101,15 @@ int quelmode(char codeascii) {
|
||||
|
||||
/* 844 */
|
||||
void regroupe(int *indexliste) {
|
||||
int i, j;
|
||||
|
||||
/* bring together same type blocks */
|
||||
if (*(indexliste) > 1) {
|
||||
i = 1;
|
||||
int i = 1;
|
||||
while (i < *(indexliste)) {
|
||||
if (liste[1][i - 1] == liste[1][i]) {
|
||||
/* bring together */
|
||||
liste[0][i - 1] = liste[0][i - 1] + liste[0][i];
|
||||
j = i + 1;
|
||||
int j = i + 1;
|
||||
|
||||
/* decreace the list */
|
||||
while (j < *(indexliste)) {
|
||||
@ -224,11 +223,9 @@ void pdfsmooth(int *indexliste) {
|
||||
}
|
||||
|
||||
/* 547 */
|
||||
void textprocess(int *chainemc, int *mclength, char chaine[], int start, int length, int block) {
|
||||
void textprocess(int *chainemc, int *mclength, char chaine[], int start, int length) {
|
||||
int j, indexlistet, curtable, listet[2][5000], chainet[5000], wnet;
|
||||
char codeascii;
|
||||
|
||||
codeascii = 0;
|
||||
wnet = 0;
|
||||
|
||||
for (j = 0; j < 1000; j++) {
|
||||
@ -236,7 +233,7 @@ void textprocess(int *chainemc, int *mclength, char chaine[], int start, int len
|
||||
}
|
||||
/* listet will contain the table numbers and the value of each characters */
|
||||
for (indexlistet = 0; indexlistet < length; indexlistet++) {
|
||||
codeascii = chaine[start + indexlistet];
|
||||
char codeascii = chaine[start + indexlistet];
|
||||
switch (codeascii) {
|
||||
case '\t': listet[0][indexlistet] = 12;
|
||||
listet[1][indexlistet] = 12;
|
||||
@ -417,17 +414,8 @@ void textprocess(int *chainemc, int *mclength, char chaine[], int start, int len
|
||||
}
|
||||
|
||||
/* 671 */
|
||||
void byteprocess(int *chainemc, int *mclength, unsigned char chaine[], int start, int length, int block) {
|
||||
void byteprocess(int *chainemc, int *mclength, unsigned char chaine[], int start, int length) {
|
||||
int debug = 0;
|
||||
int len = 0;
|
||||
unsigned int chunkLen = 0;
|
||||
#if defined(_MSC_VER) && _MSC_VER == 1200
|
||||
uint64_t mantisa = 0;
|
||||
uint64_t total = 0;
|
||||
#else
|
||||
uint64_t mantisa = 0ULL;
|
||||
uint64_t total = 0ULL;
|
||||
#endif
|
||||
|
||||
if (debug) printf("\nEntering byte mode at position %d\n", start);
|
||||
|
||||
@ -447,19 +435,21 @@ void byteprocess(int *chainemc, int *mclength, unsigned char chaine[], int start
|
||||
if (debug) printf("901 ");
|
||||
}
|
||||
|
||||
int len = 0;
|
||||
|
||||
while (len < length) {
|
||||
chunkLen = length - len;
|
||||
unsigned int chunkLen = length - len;
|
||||
if (6 <= chunkLen) /* Take groups of 6 */ {
|
||||
chunkLen = 6;
|
||||
len += chunkLen;
|
||||
#if defined(_MSC_VER) && _MSC_VER == 1200
|
||||
total = 0;
|
||||
uint64_t total = 0;
|
||||
#else
|
||||
total = 0ULL;
|
||||
uint64_t total = 0ULL;
|
||||
#endif
|
||||
|
||||
while (chunkLen--) {
|
||||
mantisa = chaine[start++];
|
||||
uint64_t mantisa = chaine[start++];
|
||||
#if defined(_MSC_VER) && _MSC_VER == 1200
|
||||
total |= mantisa << (uint64_t) (chunkLen * 8);
|
||||
#else
|
||||
@ -490,8 +480,8 @@ void byteprocess(int *chainemc, int *mclength, unsigned char chaine[], int start
|
||||
}
|
||||
|
||||
/* 712 */
|
||||
void numbprocess(int *chainemc, int *mclength, char chaine[], int start, int length, int block) {
|
||||
int j, loop, longueur, dummy[100], dumlength, diviseur, nombre;
|
||||
void numbprocess(int *chainemc, int *mclength, char chaine[], int start, int length) {
|
||||
int j, loop, dummy[100], diviseur, nombre;
|
||||
char chainemod[50], chainemult[100], temp;
|
||||
|
||||
strcpy(chainemod, "");
|
||||
@ -504,9 +494,9 @@ void numbprocess(int *chainemc, int *mclength, char chaine[], int start, int len
|
||||
|
||||
j = 0;
|
||||
while (j < length) {
|
||||
dumlength = 0;
|
||||
int dumlength = 0;
|
||||
strcpy(chainemod, "");
|
||||
longueur = length - j;
|
||||
int longueur = length - j;
|
||||
if (longueur > 44) {
|
||||
longueur = 44;
|
||||
}
|
||||
@ -645,13 +635,13 @@ static int pdf417(struct zint_symbol *symbol, unsigned char chaine[], const size
|
||||
for (i = 0; i < indexliste; i++) {
|
||||
switch (liste[1][i]) {
|
||||
case TEX: /* 547 - text mode */
|
||||
textprocess(chainemc, &mclength, (char*) chaine, indexchaine, liste[0][i], i);
|
||||
textprocess(chainemc, &mclength, (char*) chaine, indexchaine, liste[0][i]);
|
||||
break;
|
||||
case BYT: /* 670 - octet stream mode */
|
||||
byteprocess(chainemc, &mclength, chaine, indexchaine, liste[0][i], i);
|
||||
byteprocess(chainemc, &mclength, chaine, indexchaine, liste[0][i]);
|
||||
break;
|
||||
case NUM: /* 712 - numeric mode */
|
||||
numbprocess(chainemc, &mclength, (char*) chaine, indexchaine, liste[0][i], i);
|
||||
numbprocess(chainemc, &mclength, (char*) chaine, indexchaine, liste[0][i]);
|
||||
break;
|
||||
}
|
||||
indexchaine = indexchaine + liste[0][i];
|
||||
@ -974,13 +964,13 @@ int micro_pdf417(struct zint_symbol *symbol, unsigned char chaine[], const size_
|
||||
for (i = 0; i < indexliste; i++) {
|
||||
switch (liste[1][i]) {
|
||||
case TEX: /* 547 - text mode */
|
||||
textprocess(chainemc, &mclength, (char*) chaine, indexchaine, liste[0][i], i);
|
||||
textprocess(chainemc, &mclength, (char*) chaine, indexchaine, liste[0][i]);
|
||||
break;
|
||||
case BYT: /* 670 - octet stream mode */
|
||||
byteprocess(chainemc, &mclength, chaine, indexchaine, liste[0][i], i);
|
||||
byteprocess(chainemc, &mclength, chaine, indexchaine, liste[0][i]);
|
||||
break;
|
||||
case NUM: /* 712 - numeric mode */
|
||||
numbprocess(chainemc, &mclength, (char*) chaine, indexchaine, liste[0][i], i);
|
||||
numbprocess(chainemc, &mclength, (char*) chaine, indexchaine, liste[0][i]);
|
||||
break;
|
||||
}
|
||||
indexchaine = indexchaine + liste[0][i];
|
||||
|
||||
@ -511,4 +511,4 @@ static const unsigned short int rap_centre[52] = {
|
||||
0x2DC, 0x2DE
|
||||
};
|
||||
|
||||
void byteprocess(int *chainemc, int *mclength, unsigned char chaine[], int start, int length, int block);
|
||||
void byteprocess(int *chainemc, int *mclength, unsigned char chaine[], int start, int length);
|
||||
@ -51,7 +51,7 @@ static const char *MSITable[10] = {
|
||||
/* Not MSI/Plessey but the older Plessey standard */
|
||||
int plessey(struct zint_symbol *symbol, unsigned char source[], const size_t length) {
|
||||
|
||||
unsigned int i, check;
|
||||
unsigned int i;
|
||||
unsigned char *checkptr;
|
||||
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 */
|
||||
@ -73,7 +73,7 @@ int plessey(struct zint_symbol *symbol, unsigned char source[], const size_t len
|
||||
|
||||
/* Data area */
|
||||
for (i = 0; i < length; i++) {
|
||||
check = posn(SSET, source[i]);
|
||||
unsigned int check = posn(SSET, source[i]);
|
||||
lookup(SSET, PlessTable, source[i], dest);
|
||||
checkptr[4 * i] = check & 1;
|
||||
checkptr[4 * i + 1] = (check >> 1) & 1;
|
||||
@ -85,11 +85,12 @@ int plessey(struct zint_symbol *symbol, unsigned char source[], const size_t len
|
||||
used in GNU Barcode */
|
||||
|
||||
for (i = 0; i < (4 * length); i++) {
|
||||
if (checkptr[i]) {
|
||||
int j;
|
||||
if (checkptr[i])
|
||||
for (j = 0; j < 9; j++)
|
||||
checkptr[i + j] ^= grid[j];
|
||||
}
|
||||
}
|
||||
|
||||
for (i = 0; i < 8; i++) {
|
||||
switch (checkptr[length * 4 + i]) {
|
||||
@ -171,7 +172,7 @@ int msi_plessey_mod10(struct zint_symbol *symbol, unsigned char source[], int le
|
||||
dau = strtoul(un, NULL, 10);
|
||||
dau *= 2;
|
||||
|
||||
sprintf(tri, "%ld", dau);
|
||||
sprintf(tri, "%lu", dau);
|
||||
|
||||
pedwar = 0;
|
||||
h = strlen(tri);
|
||||
@ -240,7 +241,7 @@ int msi_plessey_mod1010(struct zint_symbol *symbol, unsigned char source[], cons
|
||||
dau = strtoul(un, NULL, 10);
|
||||
dau *= 2;
|
||||
|
||||
sprintf(tri, "%ld", dau);
|
||||
sprintf(tri, "%lu", dau);
|
||||
|
||||
pedwar = 0;
|
||||
h = strlen(tri);
|
||||
@ -270,7 +271,7 @@ int msi_plessey_mod1010(struct zint_symbol *symbol, unsigned char source[], cons
|
||||
dau = strtoul(un, NULL, 10);
|
||||
dau *= 2;
|
||||
|
||||
sprintf(tri, "%ld", dau);
|
||||
sprintf(tri, "%lu", dau);
|
||||
|
||||
pedwar = 0;
|
||||
h = strlen(tri);
|
||||
@ -428,7 +429,7 @@ int msi_plessey_mod1110(struct zint_symbol *symbol, unsigned char source[], cons
|
||||
dau = strtoul(un, NULL, 10);
|
||||
dau *= 2;
|
||||
|
||||
sprintf(tri, "%ld", dau);
|
||||
sprintf(tri, "%lu", dau);
|
||||
|
||||
pedwar = 0;
|
||||
h = strlen(tri);
|
||||
|
||||
@ -76,7 +76,6 @@ int png_pixel_plot(struct zint_symbol *symbol, char *pixelbuf) {
|
||||
struct mainprog_info_type *graphic;
|
||||
png_structp png_ptr;
|
||||
png_infop info_ptr;
|
||||
unsigned char *image_data;
|
||||
int i, row, column;
|
||||
int fgred, fggrn, fgblu, bgred, bggrn, bgblu;
|
||||
|
||||
@ -172,7 +171,7 @@ int png_pixel_plot(struct zint_symbol *symbol, char *pixelbuf) {
|
||||
}
|
||||
}
|
||||
/* write row contents to file */
|
||||
image_data = outdata;
|
||||
unsigned char *image_data = outdata;
|
||||
png_write_row(png_ptr, image_data);
|
||||
}
|
||||
|
||||
|
||||
10
backend/ps.c
10
backend/ps.c
@ -40,8 +40,8 @@
|
||||
#define SSET "0123456789ABCDEF"
|
||||
|
||||
int ps_plot(struct zint_symbol *symbol) {
|
||||
int i, block_width, latch, r, this_row;
|
||||
float textpos, large_bar_height, preset_height, row_height, row_posn;
|
||||
int i, block_width, latch, r;
|
||||
float textpos, large_bar_height, preset_height, row_height;
|
||||
FILE *feps;
|
||||
int fgred, fggrn, fgblu, bgred, bggrn, bgblu;
|
||||
float red_ink, green_ink, blue_ink, red_paper, green_paper, blue_paper;
|
||||
@ -383,7 +383,7 @@ int ps_plot(struct zint_symbol *symbol) {
|
||||
ey = my - 0.5 + yoffset;
|
||||
fy = my + 0.5 + yoffset;
|
||||
|
||||
mx = 2.46 * i + 1.23 + (r & 1 ? 1.23 : 0);
|
||||
mx = 2.46 * i + 1.23 + ((r & 1) ? 1.23 : 0);
|
||||
|
||||
ax = mx + xoffset;
|
||||
bx = mx + 0.86 + xoffset;
|
||||
@ -404,13 +404,13 @@ int ps_plot(struct zint_symbol *symbol) {
|
||||
int addon_latch = 0;
|
||||
|
||||
for (r = 0; r < symbol->rows; r++) {
|
||||
this_row = symbol->rows - r - 1; /* invert r otherwise plots upside down */
|
||||
int this_row = symbol->rows - r - 1; /* invert r otherwise plots upside down */
|
||||
if (symbol->row_height[this_row] == 0) {
|
||||
row_height = large_bar_height;
|
||||
} else {
|
||||
row_height = symbol->row_height[this_row];
|
||||
}
|
||||
row_posn = 0;
|
||||
float row_posn = 0;
|
||||
for (i = 0; i < r; i++) {
|
||||
if (symbol->row_height[symbol->rows - i - 1] == 0) {
|
||||
row_posn += large_bar_height;
|
||||
|
||||
94
backend/qr.c
94
backend/qr.c
@ -149,8 +149,8 @@ static int tribus(const int version,const int a,const int b,const int c) {
|
||||
/* Convert input data to a binary stream and add padding */
|
||||
static void qr_binary(int datastream[], const int version, const int target_binlen, const char mode[], const int jisdata[], const size_t length, const int gs1, const int eci, const int est_binlen,const int debug) {
|
||||
int position = 0;
|
||||
int short_data_block_length, i;
|
||||
char data_block, padbits;
|
||||
int i;
|
||||
char padbits;
|
||||
int current_binlen, current_bytes;
|
||||
int toggle, percent;
|
||||
|
||||
@ -186,8 +186,8 @@ static void qr_binary(int datastream[], const int version, const int target_binl
|
||||
percent = 0;
|
||||
|
||||
do {
|
||||
data_block = mode[position];
|
||||
short_data_block_length = 0;
|
||||
char data_block = mode[position];
|
||||
int short_data_block_length = 0;
|
||||
do {
|
||||
short_data_block_length++;
|
||||
} while (((short_data_block_length + position) < length)
|
||||
@ -370,19 +370,19 @@ static void qr_binary(int datastream[], const int version, const int target_binl
|
||||
i = 0;
|
||||
while (i < short_data_block_length) {
|
||||
int count;
|
||||
int first = 0, second = 0, third = 0, prod;
|
||||
int first = 0, prod;
|
||||
|
||||
first = posn(NEON, (char) jisdata[position + i]);
|
||||
count = 1;
|
||||
prod = first;
|
||||
|
||||
if (i + 1 < short_data_block_length && mode[position + i + 1] == 'N') {
|
||||
second = posn(NEON, (char) jisdata[position + i + 1]);
|
||||
int second = posn(NEON, (char) jisdata[position + i + 1]);
|
||||
count = 2;
|
||||
prod = (prod * 10) + second;
|
||||
|
||||
if (i + 2 < short_data_block_length && mode[position + i + 2] == 'N') {
|
||||
third = posn(NEON, (char) jisdata[position + i + 2]);
|
||||
int third = posn(NEON, (char) jisdata[position + i + 2]);
|
||||
count = 3;
|
||||
prod = (prod * 10) + third;
|
||||
}
|
||||
@ -579,7 +579,6 @@ static void place_align(unsigned char grid[],const int size,int x,int y) {
|
||||
|
||||
static void setup_grid(unsigned char* grid,const int size,const int version) {
|
||||
int i, toggle = 1;
|
||||
int loopsize, x, y, xcoord, ycoord;
|
||||
|
||||
/* Add timing patterns */
|
||||
for (i = 0; i < size; i++) {
|
||||
@ -616,11 +615,12 @@ static void setup_grid(unsigned char* grid,const int size,const int version) {
|
||||
if (version != 1) {
|
||||
/* Version 1 does not have alignment patterns */
|
||||
|
||||
loopsize = qr_align_loopsize[version - 1];
|
||||
int loopsize = qr_align_loopsize[version - 1];
|
||||
int x, y;
|
||||
for (x = 0; x < loopsize; x++) {
|
||||
for (y = 0; y < loopsize; y++) {
|
||||
xcoord = qr_table_e1[((version - 2) * 7) + x];
|
||||
ycoord = qr_table_e1[((version - 2) * 7) + y];
|
||||
int xcoord = qr_table_e1[((version - 2) * 7) + x];
|
||||
int ycoord = qr_table_e1[((version - 2) * 7) + y];
|
||||
|
||||
if (!(grid[(ycoord * size) + xcoord] & 0x10)) {
|
||||
place_align(grid, size, xcoord, ycoord);
|
||||
@ -666,13 +666,13 @@ static void populate_grid(unsigned char* grid,const int size,const int* datastre
|
||||
int direction = 1; /* up */
|
||||
int row = 0; /* right hand side */
|
||||
|
||||
int i, n, x, y;
|
||||
int i, n, y;
|
||||
|
||||
n = cw * 8;
|
||||
y = size - 1;
|
||||
i = 0;
|
||||
do {
|
||||
x = (size - 2) - (row * 2);
|
||||
int x = (size - 2) - (row * 2);
|
||||
if (x < 6)
|
||||
x--; /* skip over vertical timing pattern */
|
||||
|
||||
@ -1005,24 +1005,24 @@ static void add_format_info_eval(unsigned char *eval,const int size,const int ec
|
||||
seq = qr_annex_c[format];
|
||||
|
||||
for (i = 0; i < 6; i++) {
|
||||
eval[(i * size) + 8] = (seq >> i) & 0x01 ? (0x01 >> pattern) : 0x00;
|
||||
eval[(i * size) + 8] = ((seq >> i) & 0x01) ? (0x01 >> pattern) : 0x00;
|
||||
}
|
||||
|
||||
for (i = 0; i < 8; i++) {
|
||||
eval[(8 * size) + (size - i - 1)] = (seq >> i) & 0x01 ? (0x01 >> pattern) : 0x00;
|
||||
eval[(8 * size) + (size - i - 1)] = ((seq >> i) & 0x01) ? (0x01 >> pattern) : 0x00;
|
||||
}
|
||||
|
||||
for (i = 0; i < 6; i++) {
|
||||
eval[(8 * size) + (5 - i)] = (seq >> (i + 9)) & 0x01 ? (0x01 >> pattern) : 0x00;
|
||||
eval[(8 * size) + (5 - i)] = ((seq >> (i + 9)) & 0x01) ? (0x01 >> pattern) : 0x00;
|
||||
}
|
||||
|
||||
for (i = 0; i < 7; i++) {
|
||||
eval[(((size - 7) + i) * size) + 8] = (seq >> (i + 8)) & 0x01 ? (0x01 >> pattern) : 0x00;
|
||||
eval[(((size - 7) + i) * size) + 8] = ((seq >> (i + 8)) & 0x01) ? (0x01 >> pattern) : 0x00;
|
||||
}
|
||||
|
||||
eval[(7 * size) + 8] = (seq >> 6) & 0x01 ? (0x01 >> pattern) : 0x00;
|
||||
eval[(8 * size) + 8] = (seq >> 7) & 0x01 ? (0x01 >> pattern) : 0x00;
|
||||
eval[(8 * size) + 7] = (seq >> 8) & 0x01 ? (0x01 >> pattern) : 0x00;
|
||||
eval[(7 * size) + 8] = ((seq >> 6) & 0x01) ? (0x01 >> pattern) : 0x00;
|
||||
eval[(8 * size) + 8] = ((seq >> 7) & 0x01) ? (0x01 >> pattern) : 0x00;
|
||||
eval[(8 * size) + 7] = ((seq >> 8) & 0x01) ? (0x01 >> pattern) : 0x00;
|
||||
}
|
||||
|
||||
static int apply_bitmask(unsigned char *grid,const int size,const int ecc_level) {
|
||||
@ -1388,7 +1388,6 @@ static int getBinaryLength(const int version,char inputMode[],const int inputDat
|
||||
|
||||
int qr_code(struct zint_symbol *symbol, const unsigned char source[], size_t length) {
|
||||
int i, j, est_binlen;
|
||||
int error_number,glyph;
|
||||
int ecc_level, autosize, version, max_cw, target_binlen, blocks, size;
|
||||
int bitmask, gs1;
|
||||
int canShrink;
|
||||
@ -1414,7 +1413,7 @@ int qr_code(struct zint_symbol *symbol, const unsigned char source[], size_t len
|
||||
}
|
||||
} else {
|
||||
/* Convert Unicode input to Shift-JIS */
|
||||
error_number = utf8toutf16(symbol, source, utfdata, &length);
|
||||
int error_number = utf8toutf16(symbol, source, utfdata, &length);
|
||||
if (error_number != 0) {
|
||||
return error_number;
|
||||
}
|
||||
@ -1424,7 +1423,7 @@ int qr_code(struct zint_symbol *symbol, const unsigned char source[], size_t len
|
||||
jisdata[i] = utfdata[i];
|
||||
} else {
|
||||
j = 0;
|
||||
glyph = 0;
|
||||
int glyph = 0;
|
||||
do {
|
||||
if (sjis_lookup[j * 2] == utfdata[i]) {
|
||||
glyph = sjis_lookup[(j * 2) + 1];
|
||||
@ -1636,8 +1635,7 @@ static int micro_qr_intermediate(char binary[], const int jisdata[], const char
|
||||
/* Convert input data to an "intermediate stage" where data is binary encoded but
|
||||
control information is not */
|
||||
int position = 0;
|
||||
int short_data_block_length, i;
|
||||
char data_block;
|
||||
int i;
|
||||
char buffer[2];
|
||||
|
||||
strcpy(binary, "");
|
||||
@ -1654,8 +1652,8 @@ static int micro_qr_intermediate(char binary[], const int jisdata[], const char
|
||||
return ZINT_ERROR_TOO_LONG;
|
||||
}
|
||||
|
||||
data_block = mode[position];
|
||||
short_data_block_length = 0;
|
||||
char data_block = mode[position];
|
||||
int short_data_block_length = 0;
|
||||
do {
|
||||
short_data_block_length++;
|
||||
} while (((short_data_block_length + position) < length) && (mode[position + short_data_block_length] == data_block));
|
||||
@ -1759,14 +1757,14 @@ static int micro_qr_intermediate(char binary[], const int jisdata[], const char
|
||||
i = 0;
|
||||
while (i < short_data_block_length) {
|
||||
int count;
|
||||
int first = 0, second = 0, prod;
|
||||
int first = 0, prod;
|
||||
|
||||
first = posn(RHODIUM, (char) jisdata[position + i]);
|
||||
count = 1;
|
||||
prod = first;
|
||||
|
||||
if (i + 1 < short_data_block_length && mode[position + i + 1] == 'A') {
|
||||
second = posn(RHODIUM, (char) jisdata[position + i + 1]);
|
||||
int second = posn(RHODIUM, (char) jisdata[position + i + 1]);
|
||||
count = 2;
|
||||
prod = (first * 45) + second;
|
||||
}
|
||||
@ -1807,20 +1805,20 @@ static int micro_qr_intermediate(char binary[], const int jisdata[], const char
|
||||
i = 0;
|
||||
while (i < short_data_block_length) {
|
||||
int count;
|
||||
int first = 0, second = 0, third = 0, prod;
|
||||
int first = 0, prod;
|
||||
|
||||
first = posn(NEON, (char) jisdata[position + i]);
|
||||
count = 1;
|
||||
prod = first;
|
||||
|
||||
if (i + 1 < short_data_block_length && mode[position + i + 1] == 'N') {
|
||||
second = posn(NEON, (char) jisdata[position + i + 1]);
|
||||
int second = posn(NEON, (char) jisdata[position + i + 1]);
|
||||
count = 2;
|
||||
prod = (prod * 10) + second;
|
||||
}
|
||||
|
||||
if (i + 2 < short_data_block_length && mode[position + i + 2] == 'N') {
|
||||
third = posn(NEON, (char) jisdata[position + i + 2]);
|
||||
int third = posn(NEON, (char) jisdata[position + i + 2]);
|
||||
count = 3;
|
||||
prod = (prod * 10) + third;
|
||||
}
|
||||
@ -1985,7 +1983,7 @@ static void microqr_expand_binary(const char binary_stream[], char full_stream[]
|
||||
|
||||
static void micro_qr_m1(char binary_data[]) {
|
||||
int i, j, latch;
|
||||
int bits_total, bits_left, remainder;
|
||||
int bits_total, bits_left;
|
||||
int data_codewords, ecc_codewords;
|
||||
unsigned char data_blocks[4], ecc_blocks[3];
|
||||
|
||||
@ -2016,7 +2014,7 @@ static void micro_qr_m1(char binary_data[]) {
|
||||
|
||||
if (latch == 0) {
|
||||
/* Complete current byte */
|
||||
remainder = 8 - (strlen(binary_data) % 8);
|
||||
int remainder = 8 - (strlen(binary_data) % 8);
|
||||
if (remainder == 8) {
|
||||
remainder = 0;
|
||||
}
|
||||
@ -2029,7 +2027,7 @@ static void micro_qr_m1(char binary_data[]) {
|
||||
if (bits_left > 4) {
|
||||
remainder = (bits_left - 4) / 8;
|
||||
for (i = 0; i < remainder; i++) {
|
||||
strcat(binary_data, i & 1 ? "00010001" : "11101100");
|
||||
strcat(binary_data, (i & 1) ? "00010001" : "11101100");
|
||||
}
|
||||
}
|
||||
bin_append(0, 4, binary_data);
|
||||
@ -2068,7 +2066,7 @@ static void micro_qr_m1(char binary_data[]) {
|
||||
|
||||
static void micro_qr_m2(char binary_data[],const int ecc_mode) {
|
||||
int i, j, latch;
|
||||
int bits_total=0, bits_left, remainder;
|
||||
int bits_total=0, bits_left;
|
||||
int data_codewords=0, ecc_codewords=0;
|
||||
unsigned char data_blocks[6], ecc_blocks[7];
|
||||
|
||||
@ -2095,7 +2093,7 @@ static void micro_qr_m2(char binary_data[],const int ecc_mode) {
|
||||
|
||||
if (latch == 0) {
|
||||
/* Complete current byte */
|
||||
remainder = 8 - (strlen(binary_data) % 8);
|
||||
int remainder = 8 - (strlen(binary_data) % 8);
|
||||
if (remainder == 8) {
|
||||
remainder = 0;
|
||||
}
|
||||
@ -2107,7 +2105,7 @@ static void micro_qr_m2(char binary_data[],const int ecc_mode) {
|
||||
bits_left = bits_total - (int)strlen(binary_data);
|
||||
remainder = bits_left / 8;
|
||||
for (i = 0; i < remainder; i++) {
|
||||
strcat(binary_data, i & 1 ? "00010001" : "11101100");
|
||||
strcat(binary_data, (i & 1) ? "00010001" : "11101100");
|
||||
}
|
||||
}
|
||||
|
||||
@ -2148,7 +2146,7 @@ static void micro_qr_m2(char binary_data[],const int ecc_mode) {
|
||||
|
||||
static void micro_qr_m3(char binary_data[],const int ecc_mode) {
|
||||
int i, j, latch;
|
||||
int bits_total=0, bits_left, remainder;
|
||||
int bits_total=0, bits_left;
|
||||
int data_codewords=0, ecc_codewords=0;
|
||||
unsigned char data_blocks[12], ecc_blocks[9];
|
||||
|
||||
@ -2186,7 +2184,7 @@ static void micro_qr_m3(char binary_data[],const int ecc_mode) {
|
||||
|
||||
if (latch == 0) {
|
||||
/* Complete current byte */
|
||||
remainder = 8 - (strlen(binary_data) % 8);
|
||||
int remainder = 8 - (strlen(binary_data) % 8);
|
||||
if (remainder == 8) {
|
||||
remainder = 0;
|
||||
}
|
||||
@ -2199,7 +2197,7 @@ static void micro_qr_m3(char binary_data[],const int ecc_mode) {
|
||||
if (bits_left > 4) {
|
||||
remainder = (bits_left - 4) / 8;
|
||||
for (i = 0; i < remainder; i++) {
|
||||
strcat(binary_data, i & 1 ? "00010001" : "11101100");
|
||||
strcat(binary_data, (i & 1) ? "00010001" : "11101100");
|
||||
}
|
||||
}
|
||||
bin_append(0, 4, binary_data);
|
||||
@ -2260,7 +2258,7 @@ static void micro_qr_m3(char binary_data[],const int ecc_mode) {
|
||||
|
||||
static void micro_qr_m4(char binary_data[],const int ecc_mode) {
|
||||
int i, j, latch;
|
||||
int bits_total=0, bits_left, remainder;
|
||||
int bits_total=0, bits_left;
|
||||
int data_codewords=0, ecc_codewords=0;
|
||||
unsigned char data_blocks[17], ecc_blocks[15];
|
||||
|
||||
@ -2290,7 +2288,7 @@ static void micro_qr_m4(char binary_data[],const int ecc_mode) {
|
||||
|
||||
if (latch == 0) {
|
||||
/* Complete current byte */
|
||||
remainder = 8 - (strlen(binary_data) % 8);
|
||||
int remainder = 8 - (strlen(binary_data) % 8);
|
||||
if (remainder == 8) {
|
||||
remainder = 0;
|
||||
}
|
||||
@ -2302,7 +2300,7 @@ static void micro_qr_m4(char binary_data[],const int ecc_mode) {
|
||||
bits_left = bits_total - (int)strlen(binary_data);
|
||||
remainder = bits_left / 8;
|
||||
for (i = 0; i < remainder; i++) {
|
||||
strcat(binary_data, i & 1 ? "00010001" : "11101100");
|
||||
strcat(binary_data, (i & 1) ? "00010001" : "11101100");
|
||||
}
|
||||
}
|
||||
|
||||
@ -2382,13 +2380,13 @@ static void micro_populate_grid(unsigned char* grid,const int size,const char fu
|
||||
int direction = 1; /* up */
|
||||
int row = 0; /* right hand side */
|
||||
size_t n;
|
||||
int i,x, y;
|
||||
int i, y;
|
||||
|
||||
n = strlen(full_stream);
|
||||
y = size - 1;
|
||||
i = 0;
|
||||
do {
|
||||
x = (size - 2) - (row * 2);
|
||||
int x = (size - 2) - (row * 2);
|
||||
|
||||
if (!(grid[(y * size) + (x + 1)] & 0xf0)) {
|
||||
if (full_stream[i] == '1') {
|
||||
@ -2551,7 +2549,7 @@ int microqr(struct zint_symbol *symbol, const unsigned char source[], size_t len
|
||||
int j, size;
|
||||
char binary_stream[200];
|
||||
char full_stream[200];
|
||||
int utfdata[40],glyph;
|
||||
int utfdata[40];
|
||||
|
||||
int jisdata[40];
|
||||
char mode[40];
|
||||
@ -2589,7 +2587,7 @@ int microqr(struct zint_symbol *symbol, const unsigned char source[], size_t len
|
||||
jisdata[i] = utfdata[i];
|
||||
} else {
|
||||
j = 0;
|
||||
glyph = 0;
|
||||
int glyph = 0;
|
||||
do {
|
||||
if (sjis_lookup[j * 2] == utfdata[i]) {
|
||||
glyph = sjis_lookup[(j * 2) + 1];
|
||||
|
||||
@ -264,7 +264,7 @@ void draw_hexagon(char *pixelbuf, int image_width, char *scaled_hexagon, int hex
|
||||
|
||||
void draw_letter(char *pixelbuf, unsigned char letter, int xposn, int yposn, int textflags, int image_width, int image_height) {
|
||||
/* Put a letter into a position */
|
||||
int skip, x, y, glyph_no, max_x, max_y;
|
||||
int skip;
|
||||
|
||||
skip = 0;
|
||||
|
||||
@ -281,14 +281,17 @@ void draw_letter(char *pixelbuf, unsigned char letter, int xposn, int yposn, int
|
||||
}
|
||||
|
||||
if (skip == 0) {
|
||||
int glyph_no;
|
||||
if (letter > 128) {
|
||||
glyph_no = letter - 66;
|
||||
} else {
|
||||
glyph_no = letter - 33;
|
||||
}
|
||||
|
||||
int x, y;
|
||||
|
||||
switch (textflags) {
|
||||
int max_x, max_y;
|
||||
case 1: // small font 5x9
|
||||
max_x = 5;
|
||||
max_y = 9;
|
||||
@ -407,14 +410,13 @@ void plot_hexline(char *scaled_hexagon, int hexagon_size, float start_x, float s
|
||||
/* Draw a straight line from start to end */
|
||||
int i;
|
||||
float inc_x, inc_y;
|
||||
float this_x, this_y;
|
||||
|
||||
inc_x = (end_x - start_x) / hexagon_size;
|
||||
inc_y = (end_y - start_y) / hexagon_size;
|
||||
|
||||
for (i = 0; i < hexagon_size; i++) {
|
||||
this_x = start_x + ((float)i * inc_x);
|
||||
this_y = start_y + ((float)i * inc_y);
|
||||
float this_x = start_x + ((float)i * inc_x);
|
||||
float this_y = start_y + ((float)i * inc_y);
|
||||
if (((this_x >= 0) && (this_x < hexagon_size)) && ((this_y >= 0) && (this_y < hexagon_size))) {
|
||||
scaled_hexagon[(hexagon_size * (int)this_y) + (int)this_x] = '1';
|
||||
}
|
||||
@ -424,7 +426,6 @@ void plot_hexline(char *scaled_hexagon, int hexagon_size, float start_x, float s
|
||||
void plot_hexagon(char *scaled_hexagon, int hexagon_size) {
|
||||
/* Create a hexagon shape and fill it */
|
||||
int line, i;
|
||||
char ink;
|
||||
|
||||
float x_offset[6];
|
||||
float y_offset[6];
|
||||
@ -461,7 +462,7 @@ void plot_hexagon(char *scaled_hexagon, int hexagon_size) {
|
||||
|
||||
/* Fill hexagon */
|
||||
for (line = 0; line < hexagon_size; line++) {
|
||||
ink = '0';
|
||||
char ink = '0';
|
||||
for (i = 0; i < hexagon_size; i++) {
|
||||
if (scaled_hexagon[(hexagon_size * line) + i] == '1') {
|
||||
if (i < (hexagon_size / 2)) {
|
||||
@ -480,7 +481,7 @@ void plot_hexagon(char *scaled_hexagon, int hexagon_size) {
|
||||
|
||||
int plot_raster_maxicode(struct zint_symbol *symbol, int rotate_angle, int data_type) {
|
||||
/* Plot a MaxiCode symbol with hexagons and bullseye */
|
||||
int i, row, column, xposn, yposn;
|
||||
int i, row, column, xposn;
|
||||
int image_height, image_width;
|
||||
char *pixelbuf;
|
||||
int error_number;
|
||||
@ -521,7 +522,7 @@ int plot_raster_maxicode(struct zint_symbol *symbol, int rotate_angle, int data_
|
||||
draw_bullseye(pixelbuf, image_width, image_height, (2 * xoffset), (2 * yoffset), scaler * 10);
|
||||
|
||||
for (row = 0; row < symbol->rows; row++) {
|
||||
yposn = row * 9;
|
||||
int yposn = row * 9;
|
||||
for (column = 0; column < symbol->width; column++) {
|
||||
xposn = column * 10;
|
||||
if (module_is_set(symbol, row, column)) {
|
||||
@ -651,7 +652,7 @@ int plot_raster_default(struct zint_symbol *symbol, int rotate_angle, int data_t
|
||||
int i, r, textoffset, yoffset, xoffset, latch, image_width, image_height;
|
||||
char *pixelbuf;
|
||||
int addon_latch = 0, textflags = 0;
|
||||
int this_row, block_width, plot_height, plot_yposn, textpos;
|
||||
int block_width, textpos;
|
||||
float row_height, row_posn;
|
||||
int error_number;
|
||||
int default_text_posn;
|
||||
@ -812,16 +813,16 @@ int plot_raster_default(struct zint_symbol *symbol, int rotate_angle, int data_t
|
||||
|
||||
/* Plot the body of the symbol to the pixel buffer */
|
||||
for (r = 0; r < symbol->rows; r++) {
|
||||
this_row = symbol->rows - r - 1; /* invert r otherwise plots upside down */
|
||||
int this_row = symbol->rows - r - 1; /* invert r otherwise plots upside down */
|
||||
row_posn += row_height;
|
||||
plot_yposn = next_yposn;
|
||||
int plot_yposn = next_yposn;
|
||||
if (symbol->row_height[this_row] == 0) {
|
||||
row_height = large_bar_height;
|
||||
} else {
|
||||
row_height = symbol->row_height[this_row];
|
||||
}
|
||||
next_yposn = (int) (row_posn + row_height);
|
||||
plot_height = next_yposn - plot_yposn;
|
||||
int plot_height = next_yposn - plot_yposn;
|
||||
|
||||
i = 0;
|
||||
if (module_is_set(symbol, this_row, 0)) {
|
||||
|
||||
@ -117,11 +117,11 @@ void rs_init_code(const int nsym, int index) {
|
||||
}
|
||||
|
||||
void rs_encode(const size_t len,const unsigned char *data, unsigned char *res) {
|
||||
int i, k, m;
|
||||
int i, k;
|
||||
for (i = 0; i < rlen; i++)
|
||||
res[i] = 0;
|
||||
for (i = 0; i < len; i++) {
|
||||
m = res[rlen - 1] ^ data[i];
|
||||
int m = res[rlen - 1] ^ data[i];
|
||||
for (k = rlen - 1; k > 0; k--) {
|
||||
if (m && rspoly[k])
|
||||
res[k] = (unsigned char) (res[k - 1] ^ alog[(logt[m] + logt[rspoly[k]]) % logmod]);
|
||||
@ -137,11 +137,11 @@ void rs_encode(const size_t len,const unsigned char *data, unsigned char *res) {
|
||||
|
||||
/* The same as above but for larger bitlengths - Aztec code compatible */
|
||||
void rs_encode_long(const int len, const unsigned int *data, unsigned int *res) {
|
||||
int i, k, m;
|
||||
int i, k;
|
||||
for (i = 0; i < rlen; i++)
|
||||
res[i] = 0;
|
||||
for (i = 0; i < len; i++) {
|
||||
m = res[rlen - 1] ^ data[i];
|
||||
int m = res[rlen - 1] ^ data[i];
|
||||
for (k = rlen - 1; k > 0; k--) {
|
||||
if (m && rspoly[k])
|
||||
res[k] = res[k - 1] ^ alog[(logt[m] + logt[rspoly[k]]) % logmod];
|
||||
|
||||
@ -52,7 +52,7 @@ int render_plot_add_line(struct zint_symbol *symbol, struct zint_render_line *li
|
||||
struct zint_render_ring *render_plot_create_ring(float x, float y, float radius, float line_width);
|
||||
int render_plot_add_ring(struct zint_symbol *symbol, struct zint_render_ring *ring, struct zint_render_ring **last_ring);
|
||||
struct zint_render_hexagon *render_plot_create_hexagon(float x, float y);
|
||||
int render_plot_add_hexagon(struct zint_symbol *symbol, struct zint_render_hexagon *ring, struct zint_render_hexagon **last_hexagon);
|
||||
int render_plot_add_hexagon(struct zint_symbol *symbol, struct zint_render_hexagon *hexagon, struct zint_render_hexagon **last_hexagon);
|
||||
|
||||
int render_plot_add_string(struct zint_symbol *symbol, unsigned char *text, float x, float y, float fsize, float width, struct zint_render_string **last_string);
|
||||
|
||||
@ -60,21 +60,20 @@ int render_plot(struct zint_symbol *symbol, const float width, const float heigh
|
||||
struct zint_render *render;
|
||||
struct zint_render_line *line, *last_line = NULL;
|
||||
struct zint_render_string *last_string = NULL;
|
||||
struct zint_render_ring *ring, *last_ring = NULL;
|
||||
struct zint_render_hexagon *hexagon, *last_hexagon = NULL;
|
||||
struct zint_render_ring *last_ring = NULL;
|
||||
struct zint_render_hexagon *last_hexagon = NULL;
|
||||
|
||||
int i, r, block_width, latch, this_row;
|
||||
float textpos, textwidth, large_bar_height, preset_height, row_height, row_posn = 0.0;
|
||||
int i, r, latch;
|
||||
float textpos, large_bar_height, preset_height, row_height, row_posn = 0.0;
|
||||
// int error_number = 0;
|
||||
int text_offset, text_height, xoffset, yoffset, textdone, main_symbol_width_x, addon_width_x;
|
||||
char addon[6], textpart[10];
|
||||
char addon[6];
|
||||
int large_bar_count, symbol_lead_in, total_symbol_width_x, total_area_width_x;
|
||||
float addon_text_posn;
|
||||
float default_text_posn;
|
||||
float scaler;
|
||||
const char *locale = NULL;
|
||||
int hide_text = 0;
|
||||
float required_aspect;
|
||||
float symbol_aspect = 1;
|
||||
float x_dimension;
|
||||
int upceanflag = 0;
|
||||
@ -225,7 +224,7 @@ int render_plot(struct zint_symbol *symbol, const float width, const float heigh
|
||||
}
|
||||
|
||||
if (large_bar_count == 0) {
|
||||
required_aspect = width / height;
|
||||
float required_aspect = width / height;
|
||||
symbol_aspect = (total_symbol_width_x + (2 * xoffset)) / (preset_height + (2 * yoffset) + text_offset + text_height);
|
||||
symbol->height = (int) preset_height;
|
||||
if (required_aspect > symbol_aspect) {
|
||||
@ -337,6 +336,7 @@ int render_plot(struct zint_symbol *symbol, const float width, const float heigh
|
||||
render->height = 26.86 * scaler;
|
||||
|
||||
/* Central bullseye pattern */
|
||||
struct zint_render_ring *ring;
|
||||
ring = render_plot_create_ring(13.64 * scaler, 13.43 * scaler, 0.85 * scaler, 0.67 * scaler);
|
||||
render_plot_add_ring(symbol, ring, &last_ring);
|
||||
ring = render_plot_create_ring(13.64 * scaler, 13.43 * scaler, 2.20 * scaler, 0.67 * scaler);
|
||||
@ -348,7 +348,7 @@ int render_plot(struct zint_symbol *symbol, const float width, const float heigh
|
||||
for (r = 0; r < symbol->rows; r++) {
|
||||
for (i = 0; i < symbol->width; i++) {
|
||||
if (module_is_set(symbol, r, i)) {
|
||||
hexagon = render_plot_create_hexagon(((i * 0.88) + (r & 1 ? 1.76 : 1.32)) * scaler, ((r * 0.76) + 0.76) * scaler);
|
||||
struct zint_render_hexagon *hexagon = render_plot_create_hexagon(((i * 0.88) + ((r & 1) ? 1.76 : 1.32)) * scaler, ((r * 0.76) + 0.76) * scaler);
|
||||
render_plot_add_hexagon(symbol, hexagon, &last_hexagon);
|
||||
}
|
||||
}
|
||||
@ -360,7 +360,7 @@ int render_plot(struct zint_symbol *symbol, const float width, const float heigh
|
||||
int addon_latch = 0;
|
||||
|
||||
for (r = 0; r < symbol->rows; r++) {
|
||||
this_row = r;
|
||||
int this_row = r;
|
||||
if (symbol->row_height[this_row] == 0) {
|
||||
row_height = large_bar_height;
|
||||
} else {
|
||||
@ -384,7 +384,7 @@ int render_plot(struct zint_symbol *symbol, const float width, const float heigh
|
||||
}
|
||||
|
||||
do {
|
||||
block_width = 0;
|
||||
int block_width = 0;
|
||||
do {
|
||||
block_width++;
|
||||
} while (module_is_set(symbol, this_row, i + block_width) == module_is_set(symbol, this_row, i));
|
||||
@ -419,6 +419,8 @@ int render_plot(struct zint_symbol *symbol, const float width, const float heigh
|
||||
row_posn = (row_posn + large_bar_height) * scaler;
|
||||
|
||||
if (!hide_text) {
|
||||
char textpart[10];
|
||||
float textwidth;
|
||||
if (upceanflag == 8) {
|
||||
/* guard bar extensions and text formatting for EAN-8 */
|
||||
i = 0;
|
||||
|
||||
@ -164,8 +164,8 @@ int rss14(struct zint_symbol *symbol, unsigned char source[], int src_len) {
|
||||
short int accum[112], left_reg[112], right_reg[112], x_reg[112], y_reg[112];
|
||||
int data_character[4], data_group[4], v_odd[4], v_even[4];
|
||||
int data_widths[8][4], checksum, c_left, c_right, total_widths[46], writer;
|
||||
char latch, hrt[15], temp[32];
|
||||
int check_digit, count, separator_row;
|
||||
char latch, temp[32];
|
||||
int separator_row;
|
||||
|
||||
separator_row = 0;
|
||||
|
||||
@ -486,8 +486,9 @@ int rss14(struct zint_symbol *symbol, unsigned char source[], int src_len) {
|
||||
}
|
||||
symbol->rows = symbol->rows + 1;
|
||||
|
||||
count = 0;
|
||||
check_digit = 0;
|
||||
int count = 0;
|
||||
int check_digit = 0;
|
||||
char hrt[15];
|
||||
|
||||
/* Calculate check digit from Annex A and place human readable text */
|
||||
ustrcpy(symbol->text, (unsigned char*) "(01)");
|
||||
@ -1054,10 +1055,10 @@ int rsslimited(struct zint_symbol *symbol, unsigned char source[], int src_len)
|
||||
|
||||
/* Attempts to apply encoding rules from secions 7.2.5.5.1 to 7.2.5.5.3
|
||||
* of ISO/IEC 24724:2006 */
|
||||
int general_rules(char field[], char type[]) {
|
||||
int general_rules(char type[]) {
|
||||
|
||||
int block[2][200], block_count, i, j, k;
|
||||
char current, next, last;
|
||||
char current;
|
||||
|
||||
block_count = 0;
|
||||
|
||||
@ -1066,7 +1067,7 @@ int general_rules(char field[], char type[]) {
|
||||
|
||||
for (i = 1; i < strlen(type); i++) {
|
||||
current = type[i];
|
||||
last = type[i - 1];
|
||||
char last = type[i - 1];
|
||||
|
||||
if (current == last) {
|
||||
block[0][block_count] = block[0][block_count] + 1;
|
||||
@ -1081,7 +1082,7 @@ int general_rules(char field[], char type[]) {
|
||||
|
||||
for (i = 0; i < block_count; i++) {
|
||||
current = block[1][i];
|
||||
next = (block[1][i + 1] & 0xFF);
|
||||
char next = (block[1][i + 1] & 0xFF);
|
||||
|
||||
if ((current == ISOIEC) && (i != (block_count - 1))) {
|
||||
if ((next == ANY_ENC) && (block[0][i + 1] >= 4)) {
|
||||
@ -1205,7 +1206,6 @@ int rss_binary_string(struct zint_symbol *symbol, char source[], char binary_str
|
||||
if (source[18] == '0') {
|
||||
/* (01) and (310x) */
|
||||
char weight_str[7];
|
||||
float weight; /* In kilos */
|
||||
|
||||
for (i = 0; i < 6; i++) {
|
||||
weight_str[i] = source[20 + i];
|
||||
@ -1219,6 +1219,7 @@ int rss_binary_string(struct zint_symbol *symbol, char source[], char binary_str
|
||||
|
||||
if ((source[19] == '3') && (strlen(source) == 26)) {
|
||||
/* (01) and (3103) */
|
||||
float weight; /* In kilos */
|
||||
weight = atof(weight_str) / 1000.0;
|
||||
|
||||
if (weight <= 32.767) {
|
||||
@ -1258,7 +1259,6 @@ int rss_binary_string(struct zint_symbol *symbol, char source[], char binary_str
|
||||
if (source[18] == '0') {
|
||||
/* (01) and (320x) */
|
||||
char weight_str[7];
|
||||
float weight; /* In pounds */
|
||||
|
||||
for (i = 0; i < 6; i++) {
|
||||
weight_str[i] = source[20 + i];
|
||||
@ -1271,6 +1271,7 @@ int rss_binary_string(struct zint_symbol *symbol, char source[], char binary_str
|
||||
|
||||
if (((source[19] == '2') || (source[19] == '3')) && (strlen(source) == 26)) {
|
||||
/* (01) and (3202)/(3203) */
|
||||
float weight; /* In pounds */
|
||||
|
||||
if (source[19] == '3') {
|
||||
weight = (float) (atof(weight_str) / 1000.0F);
|
||||
@ -1454,7 +1455,6 @@ int rss_binary_string(struct zint_symbol *symbol, char source[], char binary_str
|
||||
char group[4];
|
||||
int group_val;
|
||||
char weight_str[8];
|
||||
char date_str[4];
|
||||
|
||||
for (i = 1; i < 5; i++) {
|
||||
group[0] = source[(i * 3)];
|
||||
@ -1476,6 +1476,7 @@ int rss_binary_string(struct zint_symbol *symbol, char source[], char binary_str
|
||||
|
||||
if (strlen(source) == 34) {
|
||||
/* Date information is included */
|
||||
char date_str[4];
|
||||
date_str[0] = source[28];
|
||||
date_str[1] = source[29];
|
||||
date_str[2] = '\0';
|
||||
@ -1592,7 +1593,7 @@ int rss_binary_string(struct zint_symbol *symbol, char source[], char binary_str
|
||||
}
|
||||
}
|
||||
|
||||
latch = general_rules(general_field, general_field_type);
|
||||
latch = general_rules(general_field_type);
|
||||
if (debug) printf("General field type: %s\n", general_field_type);
|
||||
|
||||
last_mode = NUMERIC;
|
||||
@ -1863,8 +1864,6 @@ int rssexpanded(struct zint_symbol *symbol, unsigned char source[], int src_len)
|
||||
char substring[21][14], latch;
|
||||
int char_widths[21][8], checksum, check_widths[8], c_group;
|
||||
int check_char, c_odd, c_even, elements[235], pattern_width, reader, writer;
|
||||
int row, elements_in_sub, special_case_row, left_to_right;
|
||||
int codeblocks, sub_elements[235], stack_rows, current_row, current_block;
|
||||
int separator_row;
|
||||
#ifndef _MSC_VER
|
||||
char reduced[src_len + 1], binary_string[(7 * src_len) + 1];
|
||||
@ -1958,7 +1957,7 @@ int rssexpanded(struct zint_symbol *symbol, unsigned char source[], int src_len)
|
||||
elements in the data characters. */
|
||||
checksum = 0;
|
||||
for (i = 0; i < data_chars; i++) {
|
||||
row = weight_rows[(((data_chars - 2) / 2) * 21) + i];
|
||||
int row = weight_rows[(((data_chars - 2) / 2) * 21) + i];
|
||||
for (j = 0; j < 8; j++) {
|
||||
checksum += (char_widths[i][j] * checksum_weight_exp[(row * 8) + j]);
|
||||
|
||||
@ -2102,7 +2101,7 @@ int rssexpanded(struct zint_symbol *symbol, unsigned char source[], int src_len)
|
||||
* [01]90614141999996[10]1234222222222221
|
||||
* Patch by Daniel Frede
|
||||
*/
|
||||
codeblocks = (data_chars + 1) / 2 + ((data_chars + 1) % 2);
|
||||
int codeblocks = (data_chars + 1) / 2 + ((data_chars + 1) % 2);
|
||||
|
||||
|
||||
if ((symbol->option_2 < 1) || (symbol->option_2 > 10)) {
|
||||
@ -2115,22 +2114,23 @@ int rssexpanded(struct zint_symbol *symbol, unsigned char source[], int src_len)
|
||||
symbol->option_2 = 2;
|
||||
}
|
||||
|
||||
stack_rows = codeblocks / symbol->option_2;
|
||||
int stack_rows = codeblocks / symbol->option_2;
|
||||
if (codeblocks % symbol->option_2 > 0) {
|
||||
stack_rows++;
|
||||
}
|
||||
|
||||
current_block = 0;
|
||||
int current_row, current_block = 0, left_to_right;
|
||||
for (current_row = 1; current_row <= stack_rows; current_row++) {
|
||||
int sub_elements[235];
|
||||
for (i = 0; i < 235; i++) {
|
||||
sub_elements[i] = 0;
|
||||
}
|
||||
special_case_row = 0;
|
||||
int special_case_row = 0;
|
||||
|
||||
/* Row Start */
|
||||
sub_elements[0] = 1; // left guard
|
||||
sub_elements[1] = 1;
|
||||
elements_in_sub = 2;
|
||||
int elements_in_sub = 2;
|
||||
|
||||
/* Row Data */
|
||||
reader = 0;
|
||||
@ -2167,7 +2167,7 @@ int rssexpanded(struct zint_symbol *symbol, unsigned char source[], int src_len)
|
||||
sub_elements[elements_in_sub + 1] = 1;
|
||||
elements_in_sub += 2;
|
||||
|
||||
latch = current_row & 1 ? '0' : '1';
|
||||
latch = (current_row & 1) ? '0' : '1';
|
||||
|
||||
if ((current_row == stack_rows) && (codeblocks != (current_row * symbol->option_2)) &&
|
||||
((current_row & 1) == 0) && ((symbol->option_2 & 1) == 0)) {
|
||||
|
||||
@ -44,7 +44,7 @@
|
||||
#define SSET "0123456789ABCDEF"
|
||||
|
||||
int svg_plot(struct zint_symbol *symbol) {
|
||||
int i, block_width, latch, r, this_row;
|
||||
int i, block_width, latch, r;
|
||||
float textpos, large_bar_height, preset_height, row_height, row_posn = 0.0;
|
||||
FILE *fsvg;
|
||||
int error_number = 0;
|
||||
@ -306,7 +306,7 @@ int svg_plot(struct zint_symbol *symbol) {
|
||||
int addon_latch = 0;
|
||||
|
||||
for (r = 0; r < symbol->rows; r++) {
|
||||
this_row = r;
|
||||
int this_row = r;
|
||||
if (symbol->row_height[this_row] == 0) {
|
||||
row_height = large_bar_height;
|
||||
} else {
|
||||
|
||||
@ -232,7 +232,7 @@ int tif_pixel_plot(struct zint_symbol *symbol, char *pixelbuf) {
|
||||
ifd.y_resolution.type = 5;
|
||||
ifd.y_resolution.count = 1;
|
||||
ifd.y_resolution.offset = free_memory;
|
||||
free_memory += 8;
|
||||
// free_memory += 8;
|
||||
|
||||
ifd.planar_config.tag = 0x11c;
|
||||
ifd.planar_config.type = 3;
|
||||
|
||||
@ -261,7 +261,7 @@ extern "C" {
|
||||
ZINT_EXTERN void ZBarcode_Clear(struct zint_symbol *symbol);
|
||||
ZINT_EXTERN void ZBarcode_Delete(struct zint_symbol *symbol);
|
||||
|
||||
ZINT_EXTERN int ZBarcode_Encode(struct zint_symbol *symbol, const unsigned char *input, int length);
|
||||
ZINT_EXTERN int ZBarcode_Encode(struct zint_symbol *symbol, const unsigned char *source, int in_length);
|
||||
ZINT_EXTERN int ZBarcode_Encode_File(struct zint_symbol *symbol, char *filename);
|
||||
ZINT_EXTERN int ZBarcode_Print(struct zint_symbol *symbol, int rotate_angle);
|
||||
ZINT_EXTERN int ZBarcode_Encode_and_Print(struct zint_symbol *symbol, unsigned char *input, int length, int rotate_angle);
|
||||
|
||||
@ -100,7 +100,7 @@ namespace Zint {
|
||||
m_whitespace = m_zintSymbol->whitespace_width;
|
||||
}
|
||||
|
||||
int QZint::symbol() {
|
||||
int QZint::symbol() const {
|
||||
return m_symbol;
|
||||
}
|
||||
|
||||
@ -112,7 +112,7 @@ namespace Zint {
|
||||
m_input_mode = input_mode;
|
||||
}
|
||||
|
||||
QString QZint::text() {
|
||||
QString QZint::text() const {
|
||||
return m_text;
|
||||
}
|
||||
|
||||
@ -125,7 +125,7 @@ namespace Zint {
|
||||
target_size_vert = height;
|
||||
}
|
||||
|
||||
QString QZint::primaryMessage() {
|
||||
QString QZint::primaryMessage() const {
|
||||
return m_primaryMessage;
|
||||
}
|
||||
|
||||
@ -135,7 +135,7 @@ namespace Zint {
|
||||
|
||||
int QZint::height() {
|
||||
encode();
|
||||
return (m_zintSymbol->height + (m_border != NO_BORDER) ? m_borderWidth * 2 : 0)*(m_zintSymbol->symbology == BARCODE_MAXICODE ? (maxi_width + 1) : 1);
|
||||
return (m_zintSymbol->height + (m_border != NO_BORDER ? m_borderWidth * 2 : 0)*(m_zintSymbol->symbology == BARCODE_MAXICODE ? (maxi_width + 1) : 1));
|
||||
}
|
||||
|
||||
void QZint::setHeight(int height) {
|
||||
@ -152,10 +152,10 @@ namespace Zint {
|
||||
|
||||
int QZint::width() {
|
||||
encode();
|
||||
return (m_zintSymbol->width + (m_border == BOX) ? m_borderWidth * 2 : 0)*(m_zintSymbol->symbology == BARCODE_MAXICODE ? (maxi_width + 1) : 1);
|
||||
return (m_zintSymbol->width + (m_border == BOX ? m_borderWidth * 2 : 0)*(m_zintSymbol->symbology == BARCODE_MAXICODE ? (maxi_width + 1) : 1));
|
||||
}
|
||||
|
||||
float QZint::scale() {
|
||||
float QZint::scale() const {
|
||||
return m_scale;
|
||||
}
|
||||
|
||||
@ -167,7 +167,7 @@ namespace Zint {
|
||||
m_dot_size = dot_size;
|
||||
}
|
||||
|
||||
QColor QZint::fgColor() {
|
||||
QColor QZint::fgColor() const {
|
||||
return m_fgColor;
|
||||
}
|
||||
|
||||
@ -175,7 +175,7 @@ namespace Zint {
|
||||
m_fgColor = fgColor;
|
||||
}
|
||||
|
||||
QColor QZint::bgColor() {
|
||||
QColor QZint::bgColor() const {
|
||||
return m_bgColor;
|
||||
}
|
||||
|
||||
@ -183,7 +183,7 @@ namespace Zint {
|
||||
m_bgColor = bgColor;
|
||||
}
|
||||
|
||||
QZint::BorderType QZint::borderType() {
|
||||
QZint::BorderType QZint::borderType() const {
|
||||
return m_border;
|
||||
}
|
||||
|
||||
@ -191,7 +191,7 @@ namespace Zint {
|
||||
m_border = border;
|
||||
}
|
||||
|
||||
int QZint::borderWidth() {
|
||||
int QZint::borderWidth() const {
|
||||
return m_borderWidth;
|
||||
}
|
||||
|
||||
@ -205,7 +205,7 @@ namespace Zint {
|
||||
m_whitespace = whitespace;
|
||||
}
|
||||
|
||||
int QZint::pdf417CodeWords() {
|
||||
int QZint::pdf417CodeWords() const {
|
||||
return m_pdf417CodeWords;
|
||||
}
|
||||
|
||||
@ -213,7 +213,7 @@ namespace Zint {
|
||||
m_pdf417CodeWords = pdf417CodeWords;
|
||||
}
|
||||
|
||||
int QZint::securityLevel() {
|
||||
int QZint::securityLevel() const {
|
||||
return m_securityLevel;
|
||||
}
|
||||
|
||||
@ -221,11 +221,11 @@ namespace Zint {
|
||||
m_securityLevel = securityLevel;
|
||||
}
|
||||
|
||||
QString QZint::error_message() {
|
||||
QString QZint::error_message() const {
|
||||
return m_lastError;
|
||||
}
|
||||
|
||||
int QZint::mode() {
|
||||
int QZint::mode() const {
|
||||
return m_securityLevel;
|
||||
}
|
||||
|
||||
@ -286,7 +286,7 @@ namespace Zint {
|
||||
}
|
||||
}
|
||||
|
||||
int QZint::module_set(int y_coord, int x_coord) {
|
||||
int QZint::module_set(int y_coord, int x_coord) const {
|
||||
int x_char, x_sub, result;
|
||||
|
||||
x_char = x_coord / 7;
|
||||
@ -304,7 +304,7 @@ namespace Zint {
|
||||
bool textdone;
|
||||
int comp_offset = 0;
|
||||
int xoffset = m_whitespace;
|
||||
int j, main_width = 0, addon_text_height = 0;
|
||||
int main_width = 0, addon_text_height = 0;
|
||||
int yoffset = 0;
|
||||
|
||||
encode();
|
||||
@ -602,7 +602,7 @@ namespace Zint {
|
||||
int block_width;
|
||||
bool latch = true;
|
||||
|
||||
j = 0 + comp_offset;
|
||||
int j = 0 + comp_offset;
|
||||
do {
|
||||
block_width = 0;
|
||||
do {
|
||||
@ -681,7 +681,7 @@ namespace Zint {
|
||||
painter.restore();
|
||||
}
|
||||
|
||||
const QString & QZint::lastError() {
|
||||
const QString & QZint::lastError() const {
|
||||
return m_lastError;
|
||||
}
|
||||
|
||||
|
||||
@ -36,13 +36,13 @@ public:
|
||||
QZint();
|
||||
~QZint();
|
||||
|
||||
int symbol();
|
||||
int symbol() const;
|
||||
void setSymbol(int symbol);
|
||||
|
||||
QString text();
|
||||
QString text() const;
|
||||
void setText(const QString & text);
|
||||
|
||||
QString primaryMessage();
|
||||
QString primaryMessage() const;
|
||||
void setPrimaryMessage(const QString & primaryMessage);
|
||||
|
||||
void setHeight(int height);
|
||||
@ -53,41 +53,41 @@ public:
|
||||
|
||||
void setOption3(int option);
|
||||
|
||||
QColor fgColor();
|
||||
QColor fgColor() const;
|
||||
void setFgColor(const QColor & fgColor);
|
||||
|
||||
QColor bgColor();
|
||||
QColor bgColor() const;
|
||||
void setBgColor(const QColor & bgColor);
|
||||
|
||||
BorderType borderType();
|
||||
BorderType borderType() const;
|
||||
void setBorderType(BorderType border);
|
||||
|
||||
int borderWidth();
|
||||
int borderWidth() const;
|
||||
void setBorderWidth(int boderWidth);
|
||||
|
||||
int pdf417CodeWords();
|
||||
int pdf417CodeWords() const;
|
||||
void setPdf417CodeWords(int pdf417CodeWords);
|
||||
|
||||
int securityLevel();
|
||||
int securityLevel() const;
|
||||
void setSecurityLevel(int securityLevel);
|
||||
|
||||
float scale();
|
||||
float scale() const;
|
||||
void setScale(float scale);
|
||||
|
||||
void setDotSize(float dot_size);
|
||||
|
||||
int mode();
|
||||
int mode() const;
|
||||
void setMode(int securityLevel);
|
||||
|
||||
void setInputMode(int input_mode);
|
||||
|
||||
void setWhitespace(int whitespace);
|
||||
|
||||
QString error_message();
|
||||
QString error_message() const;
|
||||
|
||||
void render(QPainter & painter, const QRectF & paintRect, AspectRatioMode mode=IgnoreAspectRatio);
|
||||
|
||||
const QString & lastError();
|
||||
const QString & lastError() const;
|
||||
bool hasErrors();
|
||||
|
||||
bool save_to_file(QString filename);
|
||||
@ -98,7 +98,7 @@ public:
|
||||
|
||||
private:
|
||||
void encode();
|
||||
int module_set(int y_coord, int x_coord);
|
||||
int module_set(int y_coord, int x_coord) const;
|
||||
|
||||
private:
|
||||
int m_symbol;
|
||||
|
||||
@ -330,7 +330,7 @@ EXPORT BOOL WINAPI DllEntryPoint (HINSTANCE hInstance,
|
||||
#endif
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* Initialisation Procedures */
|
||||
EXPORT int Zint_Init (Tcl_Interp *Interp)
|
||||
EXPORT int Zint_Init (Tcl_Interp *interp)
|
||||
{
|
||||
/*------------------------------------------------------------------------*/
|
||||
#ifdef USE_TCL_STUBS
|
||||
@ -365,7 +365,6 @@ static int Zint(ClientData unused, Tcl_Interp *interp, int objc,
|
||||
Tcl_Obj *CONST objv[])
|
||||
{
|
||||
/* Option list and indexes */
|
||||
char *subCmds[] = {"encode", "symbologies", "version", "help", NULL};
|
||||
enum iCommand {iEncode, iSymbologies, iVersion, iHelp};
|
||||
/* choice of option */
|
||||
int Index;
|
||||
@ -373,6 +372,7 @@ static int Zint(ClientData unused, Tcl_Interp *interp, int objc,
|
||||
/* > Check if option argument is given and decode it */
|
||||
if (objc > 1)
|
||||
{
|
||||
char *subCmds[] = {"encode", "symbologies", "version", "help", NULL};
|
||||
if(Tcl_GetIndexFromObj(interp, objv[1], (const char **) subCmds,
|
||||
"option", 0, &Index)
|
||||
== TCL_ERROR)
|
||||
|
||||
@ -1150,14 +1150,13 @@ getopt (int argc, char *const *argv, const char *optstring)
|
||||
int
|
||||
main (int argc, char **argv)
|
||||
{
|
||||
int c;
|
||||
int digit_optind = 0;
|
||||
|
||||
while (1)
|
||||
{
|
||||
int this_option_optind = optind ? optind : 1;
|
||||
|
||||
c = getopt (argc, argv, "abc:d:0123456789");
|
||||
int c = getopt (argc, argv, "abc:d:0123456789");
|
||||
if (c == -1)
|
||||
break;
|
||||
|
||||
|
||||
@ -99,7 +99,6 @@ libc_hidden_def (getopt_long_only)
|
||||
int
|
||||
main (int argc, char **argv)
|
||||
{
|
||||
int c;
|
||||
int digit_optind = 0;
|
||||
|
||||
while (1)
|
||||
@ -117,7 +116,7 @@ main (int argc, char **argv)
|
||||
{0, 0, 0, 0}
|
||||
};
|
||||
|
||||
c = getopt_long (argc, argv, "abc:d:0123456789",
|
||||
int c = getopt_long (argc, argv, "abc:d:0123456789",
|
||||
long_options, &option_index);
|
||||
if (c == -1)
|
||||
break;
|
||||
|
||||
@ -151,10 +151,10 @@ void show_eci(void) {
|
||||
|
||||
/* Verifies that a string only uses valid characters */
|
||||
int validator(char test_string[], char source[]) {
|
||||
unsigned int i, j, latch;
|
||||
unsigned int i, j;
|
||||
|
||||
for (i = 0; i < strlen(source); i++) {
|
||||
latch = 0;
|
||||
unsigned int latch = 0;
|
||||
for (j = 0; j < strlen(test_string); j++) {
|
||||
if (source[i] == test_string[j]) {
|
||||
latch = 1;
|
||||
@ -434,7 +434,6 @@ int batch_process(struct zint_symbol *symbol, char *filename, int mirror_mode, c
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
struct zint_symbol *my_symbol;
|
||||
int c;
|
||||
int error_number;
|
||||
int rotate_angle;
|
||||
int generated;
|
||||
@ -504,7 +503,7 @@ int main(int argc, char **argv) {
|
||||
{"verbose", 0, 0, 0}, // Currently undocumented, output some debug info
|
||||
{0, 0, 0, 0}
|
||||
};
|
||||
c = getopt_long(argc, argv, "htb:w:d:o:i:rcmpe", long_options, &option_index);
|
||||
int c = getopt_long(argc, argv, "htb:w:d:o:i:rcmpe", long_options, &option_index);
|
||||
if (c == -1) break;
|
||||
|
||||
switch (c) {
|
||||
|
||||
@ -36,7 +36,7 @@ DataWindow::DataWindow()
|
||||
connect(btnOK, SIGNAL( clicked( bool )), SLOT(okay()));
|
||||
}
|
||||
|
||||
DataWindow::DataWindow(QString input)
|
||||
DataWindow::DataWindow(const QString &input)
|
||||
{
|
||||
setupUi(this);
|
||||
txtDataInput->setPlainText(input);
|
||||
|
||||
@ -28,7 +28,7 @@ class DataWindow : public QDialog, private Ui::DataDialog
|
||||
|
||||
public:
|
||||
DataWindow();
|
||||
DataWindow(QString input);
|
||||
explicit DataWindow(const QString &input);
|
||||
~DataWindow();
|
||||
int Valid;
|
||||
QString DataOutput;
|
||||
|
||||
@ -81,7 +81,7 @@ void ExportWindow::process()
|
||||
QString dataString;
|
||||
QString suffix;
|
||||
QString Feedback;
|
||||
int lines, i, j, inputpos, datalen;
|
||||
int lines, i, j, inputpos;
|
||||
|
||||
lines = output_data.count(QChar('\n'), Qt::CaseInsensitive);
|
||||
inputpos = 0;
|
||||
@ -110,7 +110,7 @@ void ExportWindow::process()
|
||||
Feedback = "";
|
||||
|
||||
for(i = 0; i < lines; i++) {
|
||||
datalen = 0;
|
||||
int datalen = 0;
|
||||
for(j = inputpos; ((j < output_data.length()) && (output_data[j] != '\n') ); j++) {
|
||||
datalen++;
|
||||
}
|
||||
@ -119,12 +119,11 @@ void ExportWindow::process()
|
||||
case 0: { /* Same as Data (URL Escaped) */
|
||||
QString url_escaped;
|
||||
int m;
|
||||
char name_char;
|
||||
QChar name_qchar;
|
||||
|
||||
for(m = 0; m < dataString.length(); m++) {
|
||||
name_qchar = dataString[m];
|
||||
name_char = name_qchar.toLatin1();
|
||||
char name_char = name_qchar.toLatin1();
|
||||
|
||||
switch(name_char) {
|
||||
case '\\': url_escaped += "%5C"; break;
|
||||
|
||||
@ -75,7 +75,6 @@ QString SequenceWindow::apply_format(QString raw_number)
|
||||
QString adjusted, reversed;
|
||||
QString format;
|
||||
int format_len, input_len, i, inpos;
|
||||
char format_char;
|
||||
QChar format_qchar;
|
||||
|
||||
format = linFormat->text();
|
||||
@ -86,7 +85,7 @@ QString SequenceWindow::apply_format(QString raw_number)
|
||||
|
||||
for(i = format_len; i > 0; i--) {
|
||||
format_qchar = format[i - 1];
|
||||
format_char = format_qchar.toLatin1();
|
||||
char format_char = format_qchar.toLatin1();
|
||||
switch(format_char) {
|
||||
case '#':
|
||||
if (inpos > 0) {
|
||||
|
||||
Loading…
Reference in New Issue
Block a user