Provided by: barcode_0.98+debian-9.1_amd64 bug


       barcode - a stand alone program to run the barcode library


       barcode [-b - | string] [-e encoding] [-o - | outfile] [ other-flags ]


       The information below is extracted from the texinfo file, which is the preferred source of

       The barcode program is a front-end to access some features of the library from the command
       line.   It  is  able  to  read  user supplied strings from the command line or a data file
       (standard input by default) and encode all of them.


       barcode accepts the following options:

       --help or -h
              Print a usage summary and exit.

       -i filename
              Identify a file where strings to be encoded are read from. If missing (and if -b is
              not  used)  it defaults to standard input. Each data line of the input file will be
              used to create one barcode output.

       -o filename
              Output file. It defaults to standard output.

       -b string
              Specify a single ``barcode'' string to be encoded.  The option can be used multiple
              times  in  order  to  encode  multiple  strings  (this  will  result  in multi-page
              postscript output or a table of barcodes if -t is  specified).   The  strings  must
              match  the encoding chosen; if it doesn't match the program will print a warning to
              stderr and generate ``blank'' output (although not zero-length).  Please note  that
              a string including spaces or other special characters must be properly quoted.

       -e encoding
              encoding  is  the name of the chosen encoding format being used. It defaults to the
              value of the environment variable BARCODE_ENCODING or  to  auto  detection  if  the
              environment is also unset.

       -g geometry
              The  geometry  argument  is  of  the  form  ``[<width>  x  <height>] [+ <xmargin> +
              <ymargin>]'' (with no intervening spaces). Unspecified margin values will result in
              no  margin;  unspecified  size  results  in  default  size.   The  specified values
              represent print points by default, and can be inches, millimeters  or  other  units
              according  to the -u option or the BARCODE_UNIT environment variable.  The argument
              is used to place the printout code on the  page.  Note  that  an  additional  white
              margin  of  10  points  is  added  to  the  printout. If the option is unspecified,
              BARCODE_GEOMETRY is looked up in the environment, if missing a default size and  no
              margin (but the default 10 points) are used.

       -t table-geometry
              Used to print several barcodes to a single page, this option is meant to be used to
              print stickers. The argument is of the form ``<columns> x <lines> [+ <leftmargin> +
              <bottommargin>  [-  <rightmargin> [- <topmargin>]]]'' (with no intervening spaces);
              if missing, the top and right margin will default to be the same as the bottom  and
              left  margin.  The margins are specified in print points or in the chosen unit (see
              -u below).  If the option is not specified,  BARCODE_TABLE  is  looked  up  in  the
              environment,  otherwise no table is printed and each barcode will get its own page.
              The size (but not the position) of a barcode  item  within  a  table  can  also  be
              selected  using  -g  (see  "geometry"  above), without struggling with external and
              internal margins.  I still think management of geometries in a table is suboptimal,
              but I can't make it better without introducing incompatibilities.

       -m margin(s)
              Specifies  an internal margin for each sticker in the table. The argument is of the
              form ``<xmargin>,<ymargin>''  and  the  margin  is  applied  symmetrically  to  the
              sticker.  If  unspecified,  the  environment  variable  BARCODE_MARGIN is used or a
              default internal margin of 10 points is used.

       -n     ``Numeric'' output: don't print the ASCII form of the code, only the bars.

       -c     No checksum character (for encodings that allow it, like code 39, other codes, like
              UPC or EAN, ignore this option).

       -E     Encapsulated  postscript  (default  is  normal  postscript).  When  the  output  is
              generated as EPS only one barcode is encoded.

       -P     PCL output. Please note that the Y direction goes from top to bottom for  PCL,  and
              the origin for an image is the top-left corner instead of the bottom-left

       -p pagesize
              Specify  a  non-default  page  size. The page size can be specified in millimeters,
              inches or plain numbers (for example: "210x297mm", "8.5x11in", "595x842").  A  page
              specification  as  numbers  will  be  interpreted  according  to  the  current unit
              specification (see -u below). If libpaper is available, you can  also  specify  the
              page size with its name, like "A3" or "letter" (libpaper is a standard component of
              Debian GNU/Linux, but may be missing elsewhere). The  default  page  size  is  your
              system-wide default if libpaper is there, A4 otherwise.

       -u unit
              Choose  the  unit  used in size specifications. Accepted values are ``mm'', ``cm'',
              ``in'' and  ``pt''.  By  default,  the  program  will  check  BARCODE_UNIT  in  the
              environment,  and  assume  points otherwise (this behaviour is compatible with 0.92
              and previous versions. If -u appears more than once, each  instance  will  modified
              the behaviour for the arguments at its right, as the command line is processes left
              to right. The program internally works with points, and any size is approximated to
              the  nearest  multiple of one point. The -u option affect -g (geometry), -t (table)
              and -p (page size).


       The program encodes text strings passed either on the command line (with -b) or  retrieved
       from  standard  input.  The  text representation is interpreted according to the following
       rules. When auto-detection of the encoding is enabled (i.e, no explicit encoding  type  is
       specified),  the  encoding  types are scanned to find one that can digest the text string.
       The following list of supported types is sorted in the same order the  library  uses  when
       auto-detecting a suitable encoding for a string.

       EAN    The  EAN  frontend  is  similar  to  UPC;  it  accepts  strings  of digits, 12 or 7
              characters long. Strings of 13  or  8  characters  are  accepted  if  the  provided
              checksum  digit  is correct.  I expect most users to feed input without a checksum,
              though. The add-2 and add-5 extension are accepted for  both  the  EAN-13  and  the
              EAN-8   encodings.    The   following   are   example   of   valid  input  strings:
              ``123456789012'' (EAN-13), ``1234567890128'' (EAN-13  wih  checksum),   ``1234567''
              (EAN-8),  ``12345670  12345''  (EAN-8 with checksum and add-5), ``123456789012 12''
              (EAN-13 with add-2), ``123456789012 12345'' (EAN-13 with add-5).

       UPC    The UPC frontend accepts only strings made up of digits  (and,  if  a  supplemental
              encoding  is  used, a blank to separate it).  It accepts strings of 11 or 12 digits
              (UPC-A) and 6 or 7 or 8 digits (UPC-E).

       The 12th digit of UPC-A is the checksum and is added by the library if  not  specified  in
       the  input;  if  it is specified, it must be the right checksum or the code is rejected as
       invalid.  For UPC-E, 6 digit are considered to be the middle part of the code, a leading 0
       is  assumed  and  the  checksum  is added; 7 digits are either considered the initial part
       (leading digit 0 or 1, checksum missing) or the final part (checksum specified, leading  0
       assumed);  8  digits  are  considered  to  be  the  complete code, with leading 0 or 1 and
       checksum.  For both UPC-A and UPC-E, a trailing string of 2 digits or 5 digits is accepted
       as  well.  Therefore,  the  following are examples of valid strings that can be encoded as
       UPC: ``01234567890'' (UPC-A) ``012345678905'' (UPC-A with checksum),  ``012345''  (UPC-E),
       ``01234567890 12'' (UPC-A, add-2) and ``01234567890 12345'' (UPC-A, add-5), ``0123456 12''
       (UPC-E, add-2).  Please note that when setting BARCODE_ANY to auto-detect the encoding  to
       be  used,  12-digit  strings  and  7-digit  strings will always be identified as EAN. This
       because I expect most user to provide input without a checksum. If  you  need  to  specify
       UPC-with-checksum  as input you must explicitly set BARCODE_UPC as a flag or use -e upc on
       the command line.

       ISBN   ISBN numbers are encoded as EAN-13 symbols, with an  optional  add-5  trailer.  The
              ISBN  frontend  of  the library accepts real ISBN numbers and deals with any hyphen
              and,  if  present,  the  ISBN  checksum  character  before  encoding  data.   Valid
              representations    for   ISBN   strings   are   for   example:   ``1-56592-292-1'',
              ``3-89721-122-X'' and ``3-89721-122-X 06900}''.

       code 128-B
              This encoding can represent all of the printing ASCII characters,  from  the  space
              (32) to DEL (127). The checksum digit is mandatory in this encoding.

       code 128-C
              The  ``C'' variation of Code-128 uses Code-128 symbols to represent two digits at a
              time (Code-128 is made up of 104 symbols whose interpretation is controlled by  the
              start  symbol being used). Code 128-C is thus the most compact way to represent any
              even number of digits. The encoder refuses to deal with an  odd  number  of  digits
              because  the  caller  is  expected  to  provide proper padding to an even number of
              digits.  (Since  Code-128  includes  control  symbols  to  switch  charset,  it  is
              theoretically  possible to represent the odd digit as a Code 128-A or 128-B symbol,
              but this tool doesn't currently implement this option).

       code 128 raw
              Code-128 output represented symbol-by-symbol in the input string.  To override part
              of  the problems outlined below in specifying code128 symbols, this pseudo-encoding
              allows the used to specify a list of code128  symbols  separated  by  spaces.  Each
              symbol  is represented by a number in the range 0-105.  The list should include the
              leading character.The checksum and the stop character are  automatically  added  by
              the  library.  Most  likely this pseudo-encoding will be used with BARCODE_NO_ASCII
              and some external program to supply the printed text.

       code 39
              The code-39 standard can encode uppercase letters, digits, the blank  space,  plus,
              minus, dot, star, dollar, slash, percent.  Any string that is only composed of such
              characters is accepted by the code-39 encoder. To avoid  loosing  information,  the
              encoder  refuses  to  encode  mixed-case strings (a lowercase string is nonetheless
              accepted as a shortcut, but is encoded as uppercase).

       interleaved 2 of 5
              This encoding can  only  represent  an  even  number  of  digits  (odd  digits  are
              represented by bars, and even digits by the interleaving spaces). The name stresses
              the fact that two of the five items (bars or spaces) allocated to each  symbol  are
              wide,  while  the  rest are narrow. The checksum digit is optional (can be disabled
              via BARCODE_NO_CHECKSUM).  Since the number of digits, including the checksum, must
              be  even, a leading zero is inserted in the string being encoded if needed (this is
              specifically stated in the specs I have access to).

       code 128
              Automatic selection between alphabet A, B and C  of  the  Code-128  standard.  This
              encoding  can  represent  all  ASCII symbols, from 0 (NUL) to 127 (DEL), as well as
              four special symbols, named F1, F2, F3, F4. The set of symbols  available  in  this
              encoding  is  not  easily  represented  as  input  to  the  barcode library, so the
              following convention is used.  In the input string, which  is  a  C-language  null-
              terminated  string,  the  NUL char is represented by the value 128 (0x80, 0200) and
              the F1-F4 characters are represented by the values 193-196 (0xc1-0xc4,  0301-0304).
              The values have been chosen to ease their representation as escape sequences.

       Since  the  shell doesn't seem to interpret escape sequences on the command line, the "-b"
       option cannot be easily used to designate the strings to be encoded. As a  workaround  you
       can  resort  to  the command echo, either within back-ticks or used separately to create a
       file that is then fed to the standard-input of  barcode  --  assuming  your  echo  command
       processes escape sequences.  The newline character is especially though to encode (but not
       impossible unless you use a csh variant.

       These problems only apply to the command-line tool; the use of library  functions  doesn't
       give any problem. In needed, you can use the ``code 128 raw'' pseudo-encoding to represent
       code128 symbols by their numerical value. This encoding is used late in the auto-selection
       mechanism because (almost) any input string can be represented using code128.

              Codabar  can  encode the ten digits and a few special symbols (minus, plus, dollar,
              colon, bar, dot). The  characters  ``A'',  ``B'',  ``C''  and  ``D''  are  used  to
              represent  four  different  start/stop  characters. The input string to the barcode
              library can include the start and stop characters or not  include  them  (in  which
              case  ``A''  is  used as start and ``B'' as stop). Start and stop characters in the
              input string can be either all lowercase or all uppercase and are always printed as

              Plessey  barcodes  can  encode all the hexadecimal digits. Alphabetic digits in the
              input string must either be all lowercase or all  uppercase.  The  output  text  is
              always uppercase.

       MSI    MSI  can only encode the decimal digits. While the standard specifies either one or
              two check digits, the current implementation in this  library  only  generates  one
              check digit.

       code 93
              The  code-93  standard  can  natively  encode  48  different  characters, including
              uppercase letters, digits, the blank space, plus, minus, dot, star, dollar,  slash,
              percent,  as  well  as  five  special  characters:  a start/stop delimiter and four
              "shift characters" used for extended encoding.    Using  this  "extended  encoding"
              method,  any  standard  7-bit  ASCII  character can be encoded, but it takes up two
              symbol lengths in barcode if the character is not natively supported  (one  of  the
              48).   The  encoder  here  fully  implements  the  code  93 encoding standard.  Any
              characters natively supported (A-Z, 0-9, ".+-/$ encoded as such  -  for  any  other
              characters  (such  as lower case letters, brackets, parentheses, etc.), the encoder
              will revert to extended encoding.  As a note, the option to  exclude  the  checksum
              will  eliminate  the two modulo-47 checksums (called C and K) from the barcode, but
              this probably will make it unreadable by 9 These checksums are specified to be used
              at the firmware level, and their absence will be interpreted as an invalid barcode.


       While  the  default  output  is  Postscript  (possibly  EPS),  and Postscript can be post-
       processed to almost anything, it is sometimes desirable to create output  directly  usable
       by  the specific printer at hand.  PCL is currently supported as an output format for this
       reason.  Please note that the Y coordinate for PCL goes from  top  to  bottom,  while  for
       Postscript  it  goes from bottom to top. Consistently, while in Postscript you specify the
       bottom-left corner as origin, for PCL you specify the top-left corner.

       Barcode output for PCL Printers (HP LaserJet and compatibles), was  developed  using  PCL5
       Reference manuals from HP.  that really refers to these printers:

       LaserJet III, III P, III D, III Si,

       LaserJet 4 family

       LaserJet 5 family

       LaserJet 6 family

       Color LaserJet

       DeskJet 1200 and 1600.

       However,  barcode  printing  uses  a  very  small subset of PCL, probably also LaserJet II
       should print it without problem, but the resulting text may be horrible.

       The only real difference from one printer to another really  depends  on  which  font  are
       available  in  the  printer,  used  in  printing  the  label  associated  to  the bars (if

       Earlier LaserJet supports only bitmaps fonts, so these are not "scalable".  (Ljet  II  ?),
       Also  these  fonts,  when  available,  have a specified direction, and not all of them are
       available in both Portrait and Landscape mode.

       From LaserJet 4 series, (except 4L/5L that are entry-level printers), Arial scalable  font
       should be available, so it's the "default font" used by this program.

       LaserJet  III  series  printers (and 4L, 5L), don't feature "Arial" as a resident font, so
       you should use BARCODE_OUT_PCL_III instead of BARCODE_OUT_PCL., and  font  the  font  used
       will be "Univers" instead of "Arial".

       Results on compatible printers, may depend on consistency of PCL5 compatibility, in doubt,

       PJL commands are not used here, as it's not very compatible.

       Tested Printers:

       Hp LaserJet 4050

       Hp LaserJet 2100

       Epson N-1200 emul PCL

       Toshiba DP2570 (copier) + PCL option

       Epson EPL-7100 emul. HP LaserJet II: bars print fine but text is bad.


       The current management of borders/margins is far  from  optimal.  The  ``default''  margin
       applied  by  the  library  interferes  with  the external representation, but I feel it is
       mandatory to avoid creating barcode output with no surrounding white space (the problem is
       especially relevant for EPS output).

       EAN-128  is  not  (yet)  supported.  I plan to implement it pretty soon and then bless the
       package as version 1.0.




       Alessandro Rubini <> (maintainer)

       Leonid A. Broukhis <> (several encodings)

       Andrea Scopece <> (PCL output)