gbarcode 0.98.16-mswin32

data/ext/extconf.rb

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+#
+#  Created by Angel Pizarro on 2007-03-15.
+#  Copyright (c) 2007. All rights reserved.
+require 'mkmf'
+create_makefile('gbarcode')

data/ext/i25.c

@@ -0,0 +1,164 @@
+/*
+ * i25.c -- "interleaved 2 of 5"
+ *
+ * Copyright (c) 1999,2000 Alessandro Rubini (rubini@gnu.org)
+ * Copyright (c) 1999      Prosa Srl. (prosa@prosa.it)
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <errno.h>
+
+#include "barcode.h"
+
+static char *codes[] = {
+    "11331", "31113", "13113", "33111", "11313",
+    "31311", "13311", "11133", "31131", "13131"
+};
+
+static char *guard[] = {"a1a1", "c1a"}; /* begin end */
+
+int Barcode_i25_verify(unsigned char *text)
+{
+    if (!text[0])
+	return -1;
+    while (*text && isdigit(*text))
+	text++;
+    if (*text)
+	return -1; /* a non-digit char */
+    return 0; /* ok */
+}
+
+int Barcode_i25_encode(struct Barcode_Item *bc)
+{
+    unsigned char *text;
+    unsigned char *partial;  /* dynamic */
+    unsigned char *textinfo; /* dynamic */
+    unsigned char *textptr, *p1, *p2, *pd;
+    int i, len, sum[2], textpos, usesum = 0;
+
+    if (bc->partial)
+	free(bc->partial);
+    if (bc->textinfo)
+	free(bc->textinfo);
+    bc->partial = bc->textinfo = NULL; /* safe */
+
+    if (!bc->encoding)
+	bc->encoding = strdup("interleaved 2 of 5");
+
+    text = bc->ascii;
+    if (!bc->ascii) {
+        bc->error = EINVAL;
+        return -1;
+    }
+
+    if ((bc->flags & BARCODE_NO_CHECKSUM)) usesum = 0; else usesum = 1;
+
+    /* create the real text string, padded to an even number of digits */
+    text = malloc(strlen(bc->ascii) + 3); /* leading 0, checksum, term. */
+    if (!text) {
+	bc->error = errno;
+	return -1;
+    }
+    /* add the leading 0 if needed */
+    i = strlen(bc->ascii) + usesum;
+    if (i % 2) {
+	/* add a leading 0 */
+	text[0] = '0';
+	strcpy(text+1, bc->ascii);
+    } else {
+	strcpy(text, bc->ascii);
+    }
+    /* add the trailing checksum if needed, the leading 0 is ignored */
+    if (usesum) {
+	sum[0] = sum[1] = 0;
+	for (i=0; text[i]; i++) 
+	    sum[i%2] += text[i]-'0';
+	/*
+	 * The "even" sum must be multiplied by three, and the *
+	 * rightmost digit is defined as "even". The digits' position
+	 * is already correct, whether or not we added a leading zero.
+	 * (e.g., they are in pos. 0..4 or 1..4 of the string)
+	 */
+	i = sum[0] * 3 + sum[1];
+	strcat(text, "0");
+	text[strlen(text)-1] += (10 - (i%10)) % 10;
+    }
+
+    /* the partial code is 5 * (text + check) + 4(head) + 3(tail) + term. */
+    partial = malloc( (strlen(text) + 3) * 5 +2); /* be large... */
+    if (!partial) {
+        bc->error = errno;
+	free(text);
+        return -1;
+    }
+
+    /* the text information is at most "nnn:fff:c " * (strlen+1) +term */
+    textinfo = malloc(10*(strlen(text)+1) + 2);
+    if (!textinfo) {
+        bc->error = errno;
+        free(partial);
+	free(text);
+        return -1;
+    }
+
+
+    strcpy(partial, "0"); /* the first space */
+    strcat(partial, guard[0]); /* start */
+    textpos = 4; /* width of initial guard */
+    textptr = textinfo;
+
+    len = strlen(text);
+    for (i=0; i<len; i+=2) {
+        if (!isdigit(text[i]) || !isdigit(text[i+1])) {
+            bc->error = EINVAL; /* impossible if text is verified */
+            free(partial);
+            free(textinfo);
+            free(text);
+            return -1;
+        }
+	/* interleave two digits */
+	p1 = codes[text[i]-'0'];
+	p2 = codes[text[i+1]-'0'];
+	pd = partial + strlen(partial); /* destination */
+	while (*p1) {
+	    *(pd++) = *(p1++);
+	    *(pd++) = *(p2++);
+	}
+	*pd = '\0';
+	/* and print the ascii text (but don't print the checksum, if any */
+	if (usesum && strlen(text+i)==2) {
+	    /* print only one digit, discard the checksum */
+	    sprintf(textptr, "%i:12:%c ", textpos, text[i]);
+	} else {
+	    sprintf(textptr, "%i:12:%c %i:12:%c ", textpos, text[i],
+		    textpos+9, text[i+1]);
+	}
+        textpos += 18; /* width of two codes */
+        textptr += strlen(textptr);
+    }
+    strcat(partial, guard[1]);
+
+    bc->partial = partial;
+    bc->textinfo = textinfo;
+    free(text);
+
+    return 0;
+}
+    

data/ext/library.c

@@ -0,0 +1,244 @@
+/*
+ * library.c -- external functions of libbarcode
+ *
+ * Copyright (c) 1999 Alessandro Rubini (rubini@gnu.org)
+ * Copyright (c) 1999 Prosa Srl. (prosa@prosa.it)
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#ifdef HAVE_UNISTD_H /* sometimes (windows, for instance) it's missing */
+#  include <unistd.h>
+#endif
+#include <errno.h>
+
+#include "barcode.h"
+
+/*
+ * This function allocates a barcode structure and strdup()s the
+ * text string. It returns NULL in case of error
+ */
+struct Barcode_Item *Barcode_Create(char *text)
+{
+    struct Barcode_Item *bc;
+
+    bc = malloc(sizeof(*bc));
+    if (!bc) return NULL;
+
+    memset(bc, 0, sizeof(*bc));
+    bc->ascii = strdup(text);
+    bc->margin = BARCODE_DEFAULT_MARGIN; /* default margin */
+    return bc;
+}
+
+
+/*
+ * Free a barcode structure
+ */
+int Barcode_Delete(struct Barcode_Item *bc)
+{
+    if (bc->ascii)
+	free(bc->ascii);
+    if (bc->partial)
+	free(bc->partial);
+    if (bc->textinfo)
+	free(bc->textinfo);
+    if (bc->encoding)
+	free(bc->encoding);
+    free(bc);
+    return 0; /* always success */
+}
+
+
+/*
+ * The various supported encodings.  This might be extended to support
+ * dynamic addition of extra encodings
+ */
+extern int Barcode_ean_verify(unsigned char *text);
+extern int Barcode_ean_encode(struct Barcode_Item *bc);
+extern int Barcode_upc_verify(unsigned char *text);
+extern int Barcode_upc_encode(struct Barcode_Item *bc);
+extern int Barcode_isbn_verify(unsigned char *text);
+extern int Barcode_isbn_encode(struct Barcode_Item *bc);
+extern int Barcode_39_verify(unsigned char *text);
+extern int Barcode_39_encode(struct Barcode_Item *bc);
+extern int Barcode_128b_verify(unsigned char *text);
+extern int Barcode_128b_encode(struct Barcode_Item *bc);
+extern int Barcode_128c_verify(unsigned char *text);
+extern int Barcode_128c_encode(struct Barcode_Item *bc);
+extern int Barcode_128_verify(unsigned char *text);
+extern int Barcode_128_encode(struct Barcode_Item *bc);
+extern int Barcode_128raw_verify(unsigned char *text);
+extern int Barcode_128raw_encode(struct Barcode_Item *bc);
+extern int Barcode_i25_verify(unsigned char *text);
+extern int Barcode_i25_encode(struct Barcode_Item *bc);
+extern int Barcode_cbr_verify(unsigned char *text);
+extern int Barcode_cbr_encode(struct Barcode_Item *bc);
+extern int Barcode_msi_verify(unsigned char *text);
+extern int Barcode_msi_encode(struct Barcode_Item *bc);
+extern int Barcode_pls_verify(unsigned char *text);
+extern int Barcode_pls_encode(struct Barcode_Item *bc);
+extern int Barcode_93_verify(unsigned char *text);
+extern int Barcode_93_encode(struct Barcode_Item *bc);
+
+
+struct encoding {
+    int type;
+    int (*verify)(unsigned char *text);
+    int (*encode)(struct Barcode_Item *bc);
+};
+
+struct encoding encodings[] = {
+    {BARCODE_EAN,    Barcode_ean_verify,    Barcode_ean_encode},
+    {BARCODE_UPC,    Barcode_upc_verify,    Barcode_upc_encode},
+    {BARCODE_ISBN,   Barcode_isbn_verify,   Barcode_isbn_encode},
+    {BARCODE_128B,   Barcode_128b_verify,   Barcode_128b_encode},
+    {BARCODE_128C,   Barcode_128c_verify,   Barcode_128c_encode},
+    {BARCODE_128RAW, Barcode_128raw_verify, Barcode_128raw_encode},
+    {BARCODE_39,     Barcode_39_verify,     Barcode_39_encode},
+    {BARCODE_I25,    Barcode_i25_verify,    Barcode_i25_encode},
+    {BARCODE_128,    Barcode_128_verify,    Barcode_128_encode},
+    {BARCODE_CBR,    Barcode_cbr_verify,    Barcode_cbr_encode},
+    {BARCODE_PLS,    Barcode_pls_verify,    Barcode_pls_encode},
+    {BARCODE_MSI,    Barcode_msi_verify,    Barcode_msi_encode},
+    {BARCODE_93,     Barcode_93_verify,     Barcode_93_encode},
+    {0,              NULL,                  NULL}
+};
+
+/*
+ * A function to encode a string into bc->partial, ready for
+ * postprocessing to the output file. Meaningful bits for "flags" are
+ * the encoding mask and the no-checksum flag. These bits
+ * get saved in the data structure.
+ */
+int Barcode_Encode(struct Barcode_Item *bc, int flags)
+{
+    int validbits = BARCODE_ENCODING_MASK | BARCODE_NO_CHECKSUM;
+    struct encoding *cptr;
+
+    /* If any flag is cleared in "flags", inherit it from "bc->flags" */
+    if (!(flags & BARCODE_ENCODING_MASK))
+	flags |= bc->flags & BARCODE_ENCODING_MASK;
+    if (!(flags & BARCODE_NO_CHECKSUM))
+	flags |= bc->flags & BARCODE_NO_CHECKSUM;
+    flags = bc->flags = (flags & validbits) | (bc->flags & ~validbits);
+
+    if (!(flags & BARCODE_ENCODING_MASK)) {
+	/* get the first code able to handle the text */
+	for (cptr = encodings; cptr->verify; cptr++)
+	    if (cptr->verify((unsigned char *)bc->ascii)==0)
+		break;
+	if (!cptr->verify) {
+	    bc->error = EINVAL; /* no code can handle this text */
+	    return -1;
+	}
+	flags |= cptr->type; /* this works */
+	bc->flags |= cptr->type;
+    }
+    for (cptr = encodings; cptr->verify; cptr++)
+	if (cptr->type == (flags & BARCODE_ENCODING_MASK))
+	    break;
+    if (!cptr->verify) {
+	bc->error = EINVAL; /* invalid barcode type */
+	return -1;
+    }
+    if (cptr->verify(bc->ascii) != 0) {
+	bc->error = EINVAL;
+	return -1;
+    }
+    return cptr->encode(bc);
+}
+
+
+/* 
+ * When multiple output formats are supported, there will
+ * be a jumpt table like the one for the types. Now we don't need it
+ */
+extern int Barcode_ps_print(struct Barcode_Item *bc, FILE *f);
+extern int Barcode_pcl_print(struct Barcode_Item *bc, FILE *f);
+
+/*
+ * A function to print a partially decoded string. Meaningful bits for
+ * "flags" are the output mask etc. These bits get saved in the data
+ * structure. 
+ */
+int Barcode_Print(struct Barcode_Item *bc, FILE *f, int flags)
+{
+    int validbits = BARCODE_OUTPUT_MASK | BARCODE_NO_ASCII
+	| BARCODE_OUT_NOHEADERS;
+
+    /* If any flag is clear in "flags", inherit it from "bc->flags" */
+    if (!(flags & BARCODE_OUTPUT_MASK))
+	flags |= bc->flags & BARCODE_OUTPUT_MASK;
+    if (!(flags & BARCODE_NO_ASCII))
+	flags |= bc->flags & BARCODE_NO_ASCII;
+    if (!(flags & BARCODE_OUT_NOHEADERS))
+	flags |= bc->flags & BARCODE_OUT_NOHEADERS;
+    flags = bc->flags = (flags & validbits) | (bc->flags & ~validbits);
+
+    if (bc->flags & BARCODE_OUT_PCL)
+       return Barcode_pcl_print(bc, f);
+    return Barcode_ps_print(bc, f);
+}
+
+/*
+ * Choose the position
+ */
+int Barcode_Position(struct Barcode_Item *bc, int wid, int hei,
+		     int xoff, int yoff, double scalef)
+{
+    bc->width = wid; bc->height = hei;
+    bc->xoff = xoff; bc->yoff = yoff;
+    bc->scalef = scalef;
+    return 0;
+}
+
+/*
+ * Do it all in one step
+ */
+int Barcode_Encode_and_Print(char *text, FILE *f, int wid, int hei,
+				    int xoff, int yoff, int flags)
+{
+    struct Barcode_Item * bc;
+    
+    if (!(bc=Barcode_Create(text))) {
+	errno = -ENOMEM;
+	return -1;
+    }
+    if (     Barcode_Position(bc, wid, hei, xoff, yoff, 0.0) < 0
+	  || Barcode_Encode(bc, flags) < 0
+	  || Barcode_Print(bc, f, flags) < 0) {
+	errno = bc->error;
+	Barcode_Delete(bc);
+	return -1;
+    }
+    Barcode_Delete(bc);
+    return 0;
+}
+
+/*
+ * Return the version
+ */
+
+int Barcode_Version(char *vptr)
+{
+    if (vptr)
+	strcpy(vptr, BARCODE_VERSION);
+    return BARCODE_VERSION_INT;
+}

data/ext/msi.c

@@ -0,0 +1,155 @@
+/*
+ * msi.c -- encoding for MSI-Plessey
+ *
+ * Copyright (c) 2000 Leonid A. Broukhis (leob@mailcom.com)
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <errno.h>
+
+#include "barcode.h"
+
+
+/* Patterns */
+static char *patterns[] = { "13", "31" };
+
+static char *fillers[] = { "031", "131" };
+
+static int width = 16 /* each character uses 4 patterns */,
+	startpos = 6 /* length of the first filler */;
+
+/*
+ * Check that the text can be encoded. Returns 0 or -1.
+ */
+int Barcode_msi_verify(unsigned char *text)
+{
+    int i;
+
+    if (!strlen(text))
+	return -1;
+    for (i=0; text[i]; i++) {
+        if (!isdigit(text[i]))
+            return -1;
+    }
+    return 0;
+}
+
+static int add_one(char *ptr, int code)
+{
+    sprintf(ptr, "%s%s%s%s", 
+	patterns[(code >> 3) & 1],
+	patterns[(code >> 2) & 1],
+	patterns[(code >> 1) & 1],
+	patterns[code & 1]);
+    return 0;
+}
+
+/*
+ * The encoding functions fills the "partial" and "textinfo" fields.
+ * Lowercase chars are converted to uppercase
+ */
+int Barcode_msi_encode(struct Barcode_Item *bc)
+{
+    static char *text;
+    static char *partial;  /* dynamic */
+    static char *textinfo; /* dynamic */
+    char *ptr, *textptr;
+    int i, code, textpos, usesum, checksum = 0;
+
+    if (bc->partial)
+	free(bc->partial);
+    if (bc->textinfo)
+	free(bc->textinfo);
+    bc->partial = bc->textinfo = NULL; /* safe */
+
+    if (!bc->encoding)
+	bc->encoding = strdup("msi");
+
+    if ((bc->flags & BARCODE_NO_CHECKSUM))
+	usesum = 0;
+    else
+	usesum = 1;
+
+    text = bc->ascii;
+
+    /* the partial code is head + 8 * (text + check) + tail + margin + term. */
+    partial = malloc( 3 + 8 * (strlen(text) + 1) + 3 + 2 );
+    if (!partial) {
+        bc->error = errno;
+        return -1;
+    }
+
+    /* the text information is at most "nnn:fff:c " * strlen +term */
+    textinfo = malloc(10*strlen(text) + 2);
+    if (!textinfo) {
+        bc->error = errno;
+        free(partial);
+        return -1;
+    }
+
+    strcpy(partial, fillers[0]);
+    ptr = partial + strlen(partial);
+    textptr = textinfo;
+    textpos = startpos;
+    
+    for (i=0; i<strlen(text); i++) {
+        code = text[i] - '0';
+        add_one(ptr, code);
+        sprintf(textptr, "%i:12:%c ", textpos, text[i]);
+        
+        textpos += width; /* width of each code */
+        textptr += strlen(textptr);
+        ptr += strlen(ptr); 
+	if (usesum) {
+	/* For a code ...FEDCBA the checksum is computed
+	 * as the sum of digits of the number ...FDB plus
+	 * the sum of digits of the number ...ECA * 2.
+	 * Which is equivalent to the sum of each digit of ...ECA doubled
+	 * plus carry.
+	 */
+	    if ((i ^ strlen(text)) & 1) {
+		/* a last digit, 2 away from last, etc. */
+		checksum += 2 * code + (2 * code) / 10;
+	    } else {
+		checksum += code;
+	    }
+	}
+    }
+    /* Some implementations use a double checksum. Currently the only way
+     * to print a barcode with double checksum is to put the checksum
+     * digit printed below at the end of a code in the command line
+     * and re-run the program.
+     */
+    if (usesum) {
+	/* the check digit is the complement of the checksum
+	 * to a multiple of 10.
+	 */
+	checksum = (checksum + 9) / 10 * 10 - checksum;
+	/* fprintf(stderr, "Checksum: %d\n", checksum); */
+	add_one(ptr, checksum);
+	ptr += strlen(ptr);
+    }
+
+    strcpy(ptr, fillers[1]);
+    bc->partial = partial;
+    bc->textinfo = textinfo;
+
+    return 0;
+}