home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / gnu / fontutils-0.6 / fontconvert / main.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-10-23  |  22.5 KB  |  716 lines
  1. /* fontconvert -- various operations on a bitmap font.
  2.  
  3. Copyright (C) 1992 Free Software Foundation, Inc.
  4.  
  5. This program is free software; you can redistribute it and/or modify
  6. it under the terms of the GNU General Public License as published by
  7. the Free Software Foundation; either version 2, or (at your option)
  8. any later version.
  9.  
  10. This program is distributed in the hope that it will be useful,
  11. but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13. GNU General Public License for more details.
  14.  
  15. You should have received a copy of the GNU General Public License
  16. along with this program; if not, write to the Free Software
  17. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  18.  
  19. #include "config.h"
  20.  
  21. #include "charspec.h"
  22. #include "cmdline.h"
  23. #include "encoding.h"
  24. #include "font.h"
  25. #include "getopt.h"
  26. #include "libfile.h"
  27. #include "list.h"
  28. #include "report.h"
  29.  
  30. #include "filter.h"
  31. #include "output-epsf.h"
  32. #include "output-gf.h"
  33. #include "output-tfm.h"
  34. #include "random.h"
  35.  
  36.  
  37. /* How much to adjust the baseline of output characters by.  We rely on
  38.    this being initialized to all zeros by C.  (-baseline-adjust)  */
  39. int baseline_adjust[MAX_CHARCODE + 1];
  40.  
  41. /* If `column_split[N]' is non-NULL, we break character N into new
  42.    characters at each of the columns specified.  We depend on this being
  43.    initialized to all zeros.  (-column-split)  */
  44. int *column_split[MAX_CHARCODE + 1];
  45.  
  46. /* The names of fonts to be concatenated onto the main font in the
  47.    output.  (-concat)  */
  48. list_type fontname_list;
  49.  
  50. /* The resolution of the font we will read, in pixels per inch.  We
  51.    don't deal with nonsquare pixels.  (-dpi)  */
  52. string dpi = "300";
  53.  
  54. /* The design size which will affect both the GF and TFM output, unless
  55.    the tfm-header `designsize' option overrides it.  (-designsize)  
  56.    `design_size_ratio' is the ratio of the input design size to the
  57.    output design size.  */
  58. real design_size = 0.0;
  59. static real design_size_ratio;
  60.  
  61. /* The name of the encoding file specified by the user, and the
  62.    structure we parse it into.  (-encoding)  */
  63. static encoding_info_type *encoding_info = NULL;
  64.  
  65. /* If `omit[n]' is true for an element N, we throw away that character
  66.    in that output.  (-omit)  */ 
  67. static boolean omit[MAX_CHARCODE + 1];
  68.    
  69. /* An explicitly specified output filename.  (-output-file)  */
  70. string output_name = NULL;
  71.  
  72. /* Says which characters we should process.  This is independent of the
  73.    ordering in the font file.  (-range)  */
  74. int starting_char = 0;
  75. int ending_char = MAX_CHARCODE;
  76.  
  77. /* The variable `translate' maps character codes in the input font to
  78.    character codes in the output; by default, maps everything to
  79.    themselves.  (-remap)  */ 
  80. charcode_type translate[MAX_CHARCODE + 1];
  81.  
  82. /* Says whether to output an EPS file for each character.  (-epsf)  */
  83. boolean wants_epsf = false;
  84.  
  85. /* Says whether to output a GF file.  (-gf)  */
  86. boolean wants_gf = false;
  87.  
  88. /* Says whether to output the font as plain text.  (-text)  */
  89. boolean wants_text = false;
  90.  
  91. /* Says whether to output a TFM file.  (-tfm)  */
  92. boolean wants_tfm = false;
  93.  
  94.  
  95.  
  96. static void append_concat_list (list_type *, string);
  97. static bitmap_type column_extract (bitmap_type, unsigned, unsigned);
  98. static void do_char (char_info_type);
  99. static void do_split_char (char_info_type, int[]);
  100. static string read_command_line (int, string []);
  101. static void scan_baseline_adjust (string);
  102. static void scan_column_split (string);
  103. static void scan_omit_list (string);
  104. static void scan_remap_list (string);
  105.  
  106. /* Fontconvert provides a grabbag of operations: almost every
  107.    manipulation on bitmap fonts we found useful we threw here.  */
  108.  
  109. int
  110. main (int argc, string argv[])
  111. {
  112.   int code;
  113.   bitmap_font_type f;
  114.   string *first_element;
  115.   string font_name;
  116.   unsigned this_font;
  117.   unsigned char_count = 0;
  118.  
  119.   /* Initialize the character code translation array before parsing the
  120.      command line, since we probably will not be told to remap every
  121.      character.  */
  122.   for (code = 0; code <= MAX_CHARCODE; code++)
  123.     translate[code] = code;
  124.  
  125.   /* Initialize the list of fonts to do to have one empty element at the
  126.      beginning, which we will fill in with the main font name.  */
  127.   fontname_list = list_init ();
  128.   first_element = LIST_TAPPEND (&fontname_list, string);
  129.   
  130.   /* Read all the arguments.  */
  131.   font_name = read_command_line (argc, argv);
  132.   
  133.   /* Put the main font name in the list.  */
  134.   *first_element = font_name;
  135.  
  136.   /* If no output name was specified on the command line, use the root
  137.      part of the input name.  We've already removed the suffix in
  138.      `read_command_line'.  */
  139.   if (output_name == NULL)
  140.     output_name = basename (font_name);
  141.  
  142.   if (wants_gf && wants_tfm && find_suffix (output_name) != NULL)
  143.     FATAL ("The GF and TFM output files' suffixes can't be the same");
  144.  
  145.   /* Open the main font specially, since we need to know some basic
  146.      information for most of the output formats.  We don't need to close
  147.      it again, as opening a font twice does no harm.  */
  148.   f = get_bitmap_font (font_name, atou (dpi));
  149.  
  150.   if (wants_epsf)
  151.     epsf_start_output (output_name);
  152.   if (wants_gf)
  153.     gf_start_output (font_name, output_name, dpi,
  154.                      BITMAP_FONT_COMMENT (f)); 
  155.   if (wants_tfm)
  156.     tfm_start_output (font_name, output_name, design_size,
  157.               BITMAP_FONT_DESIGN_SIZE (f));
  158.  
  159.  
  160.   /* Have to do this after `tfm_start_output', as it needs to know if
  161.      design_size is set or not.  */
  162.   if (design_size == 0.0)  
  163.     design_size = BITMAP_FONT_DESIGN_SIZE (f);
  164.   
  165.   design_size_ratio = BITMAP_FONT_DESIGN_SIZE (f) / design_size;
  166.  
  167.   /* Go through each input font.  */
  168.   for (this_font = 0; this_font < LIST_SIZE (fontname_list); this_font++)
  169.     {
  170.       string font_name = *(string *) LIST_ELT (fontname_list, this_font);
  171.       f = get_bitmap_font (font_name, atou (dpi));
  172.  
  173.       if (wants_tfm)
  174.         tfm_start_font (font_name);
  175.         
  176.       REPORT1 ("(%s", BITMAP_FONT_FILENAME (f));
  177.       
  178.       /* The main loop: convert each character.  */
  179.       for (code = starting_char; code <= ending_char; code++)
  180.         {
  181.           char_info_type *c = get_char (font_name, code);
  182.  
  183.           if (c == NULL) continue;
  184.  
  185.           REPORT2 ("%c[%u", ++char_count % 8 ? ' ' : '\n', code);
  186.  
  187.           if (omit[code])
  188.             REPORT (" omit");
  189.           else
  190.             {
  191.               /* If this character isn't supposed to split, just output it.
  192.                  Otherwise, output each of the pieces after splitting.  */
  193.               if (column_split[code] == NULL)
  194.                 do_char (*c);
  195.               else
  196.                 do_split_char (*c, column_split[code]);
  197.             }
  198.  
  199.           REPORT ("]");
  200.         }
  201.  
  202.       close_font (font_name);
  203.       REPORT (")\n");
  204.     }
  205.   
  206.   if (wants_epsf)
  207.     epsf_finish_output ();
  208.  
  209.   /* We must finish the TFM output before GF, because `gf_finish_output'
  210.      might want to open a TFM file -- and we can only have one TFM file
  211.      open at a time.  (Because we haven't rewritten the TFM library.)  */
  212.   if (wants_tfm)
  213.     tfm_finish_output ();
  214.  
  215.   if (wants_gf)
  216.     gf_finish_output (design_size, atof (dpi));
  217.  
  218.   return 0;
  219. }
  220.  
  221. /* Output the character in whatever forms have been requested.  */
  222.  
  223. static void
  224. do_char (char_info_type c)
  225. {
  226.   static boolean char_done_p[MAX_CHARCODE + 1];
  227.   
  228.   charcode_type original_code = CHARCODE (c);
  229.  
  230.   /* Do the character code translation.  */
  231.   charcode_type code = CHARCODE (c) = translate[original_code];
  232.   
  233.   if (char_done_p[code])
  234.     {
  235.       WARNING1 ("Character %d already output", CHARCODE (c));
  236.       return;
  237.     }
  238.  
  239.   char_done_p[code] = true;
  240.  
  241.   if (filter_passes > 0)
  242.     filter_bitmap (CHAR_BITMAP (c));
  243.  
  244.   if (random_max > 0.0)
  245.     {
  246.       bounding_box_type adjust_bb;
  247.       randomize_bitmap (&CHAR_BITMAP (c), &adjust_bb);
  248.       CHAR_MIN_ROW (c) -= MIN_ROW (adjust_bb);
  249.       CHAR_MAX_ROW (c) += MAX_ROW (adjust_bb);
  250.       CHAR_MIN_COL (c) -= MIN_COL (adjust_bb);
  251.       CHAR_MAX_COL (c) += MAX_COL (adjust_bb);
  252.     }
  253.  
  254.   /* If the `baseline_adjust' value is positive, the baseline should
  255.      move up, i.e., we subtract from the height and add to the depth.
  256.      But since the depth is represented as the minimum row, which can be
  257.      negative, we must subtract from it to make it ``larger''.  */
  258.   CHAR_MIN_ROW (c) -= baseline_adjust[code];
  259.   CHAR_MAX_ROW (c) -= baseline_adjust[code];
  260.   
  261.   /* Text output is already implemented in the library.  */
  262.   if (wants_text)
  263.     {
  264.       puts ("\f");
  265.       print_char (stdout, c);
  266.     }
  267.  
  268.   if (wants_epsf)
  269.     epsf_output_char (c);
  270.  
  271.   if (wants_gf)
  272.     gf_output_char (c, design_size_ratio);
  273.  
  274.   if (wants_tfm)
  275.     tfm_output_char (c, atof (dpi));
  276.  
  277.   if (original_code != code)
  278.     REPORT1 ("->%u", code);
  279.     
  280.     /* Free the space here, instead of in the caller, since we may
  281.        change the bitmap.  */
  282.     free_bitmap (&CHAR_BITMAP (c));
  283. }
  284.  
  285.  
  286. /* Output the character C in pieces, the division points being the
  287.    columns in SPLIT.  */
  288.  
  289. static void
  290. do_split_char (char_info_type c, int split[])
  291. {
  292.   unsigned last_col = 0;
  293.   unsigned n_split = 0;
  294.  
  295.   REPORT (" (");
  296.  
  297.   /* We exit the loop after splitting the last character.  */
  298.   while (true)
  299.     {
  300.       int diff;
  301.       char_info_type split_char = c;
  302.       int this_col = *split++;
  303.       unsigned split_col = this_col != -1
  304.                            ? this_col : BITMAP_WIDTH (CHAR_BITMAP (c));
  305.  
  306.       /* Change the character code of this piece.  */
  307.       CHARCODE (split_char) += n_split;
  308.  
  309.       REPORT1 ("%u", CHARCODE (split_char));
  310.  
  311.       /* Take the chunk from the big bitmap.  */
  312.       CHAR_BITMAP (split_char)
  313.         = column_extract (CHAR_BITMAP (c), last_col, split_col);
  314.       
  315.       /* Move the right column over.  */
  316.       diff = BITMAP_WIDTH (CHAR_BITMAP (c))
  317.              - BITMAP_WIDTH (CHAR_BITMAP (split_char));
  318.       CHAR_MAX_COL (split_char) -= diff;
  319.       CHAR_SET_WIDTH (split_char) -= diff;
  320.       
  321.       /* Output it.  */
  322.       do_char (split_char);
  323.  
  324.       /* Exit the loop if we just output the last piece.  */
  325.       if (this_col == -1)
  326.         break;
  327.  
  328.       n_split++;
  329.       last_col = this_col;
  330.       REPORT (",");
  331.     }
  332.  
  333.   REPORT (")");
  334.   free_bitmap (&CHAR_BITMAP (c));
  335. }
  336.  
  337. /* Return the part of the bitmap SOURCE that lies between the columns
  338.    START and FINISH - 1, inclusive.  */
  339.  
  340. static bitmap_type
  341. column_extract (bitmap_type source, unsigned start, unsigned finish)
  342. {
  343.   unsigned this_row;
  344.   dimensions_type d = { BITMAP_HEIGHT (source), finish - start };
  345.   bitmap_type answer = new_bitmap (d);
  346.   
  347.   /* Move to the given starting column.  */
  348.   BITMAP_BITS (source) += start;
  349.   
  350.   for (this_row = 0; this_row < BITMAP_HEIGHT (source); this_row++)
  351.     {
  352.       one_byte *answer_row = BITMAP_ROW (answer, this_row);
  353.       
  354.       memcpy (answer_row, BITMAP_BITS (source), BITMAP_WIDTH (answer));
  355.       BITMAP_BITS (source) += BITMAP_WIDTH (source);
  356.     }
  357.   
  358.   return answer;
  359. }
  360.  
  361. /* Reading the options.  */
  362.  
  363. /* This is defined in version.c.  */
  364. extern string version_string;
  365.  
  366. #define USAGE "Options:
  367. <font_name> should be a filename, possibly with a resolution, e.g.,
  368.   `cmr10' or `cmr10.300'.\n"                        \
  369.   GETOPT_USAGE                                \
  370. "baseline-adjust <char1>:<integer1>,<char2>:<integer2>,...: move the baseline
  371.   of each <char> by the corresponding <integer>.  A positive number
  372.   moves the baseline up, a negative one down.
  373. column-split <char>@<column1>,...,<columnN>: split the character with
  374.   code <char> (before remapping) before each of the <column>s, producing n
  375.   new characters, with codes <char>, <char> + 1, ..., <char> + n, whose
  376.   bitmaps go from 0 to <column1> - 1 (inclusive), then <column1> to
  377.   <column2> - 1, ..., from <columnN> to the bitmap width.
  378.   Give the <column>s in bitmap coordinates, i.e., starting at zero.
  379.   To split more than one character, give this option for each.
  380. concat <font_name>,<font_name>,...: concatenate the main input font with
  381.   the given <font_name>s; if a character code exists in more than one
  382.   font, it's the first occurrence that counts.
  383. designsize <real>: use this as the design size for both the GF and TFM
  384.   output files, if any, unless overridden by `designsize' in the
  385.   `tfm-header' option.
  386. dpi <unsigned>: use a resolution of <unsigned>; default is 300.
  387. encoding <filename>: read encoding information for the character specs
  388.   from `<filename>.enc'; there is no default.  Must come before any
  389.   options which use character specs.
  390. epsf: output each character as an Encapsulated PostScript file named
  391.   <font_name>-<code>.eps, where <code> is the character code in decimal.
  392. filter-passes <unsigned>: do the filtering this many times on each
  393.   character; default is 0.
  394. filter-size <unsigned>: half the size of the filter cell, i.e., a side
  395.   is this number * 2 + 1; default is 1.
  396. filter-threshold <real>: if the average of the pixels in the filter cell
  397.   is greater than this, change the pixel; default is .5.
  398. fontdimens <fontdimen>:<real>,<fontdimen>:<real>,...: assign each <real>
  399.   to the corresponding <fontdimen> when outputting a TFM file.  A
  400.   <fontdimen> can be either one of the standard names (in either upper
  401.   or lowercase), or a number between 1 and 30.  Each <real> is taken to
  402.   be in points (except in the case of the <fontdimen> `slant' (parameter
  403.   1), which is a dimensionless number).
  404. gf: write a GF file to `<font_name>.<dpi>gf'.  If this would overwrite the
  405.   input file, write to `x<font_name>.<dpi>gf' instead.
  406. help: print this message.
  407. omit <char1>,<char2>,...: omit the characters with the given codes or names
  408.   (before remapping) from the output.
  409. output-file <filename>: use <filename> as the output filename if it has
  410.    a suffix, and as the base of the output files if it doesn't.  It
  411.    cannot have a suffix if using the `epsf' option, or both the `gf' and the
  412.    `tfm' option.  Default is the base part of the input font name.
  413. random <real>: move each pixel a (uniformly) random distance between
  414.    -<real> and <real> in both x and y; default is 0.
  415. random-threshold <real>: if randomizing, do not move pixels with
  416.   probability <real>; default is 0.2.
  417. range <char1>-<char2>: only process characters between <char1> and
  418.   <char2> in the input font, inclusive.
  419. remap <char1>:<char2>,<char1>:<char2>,...: for each pair, make the input
  420.   character with code <char1> have code <char2> in the output.
  421. text: output the font to stdout as plain text, using `*'s and ` 's.
  422. tfm: write a TFM file to `<font_name>.tfm'.
  423. tfm-header: <header-item>:<value>,<header-item>:<value>,...: assign each
  424.   <value> to the corresponding <header-item> when outputting a TFM file.
  425.   A <header-item> is one of `checksum', `designsize' or `codingscheme',
  426.   with casefolding. `checksum' requires an unsigned integer,
  427.   `designsize' a real, with 1.0 <= designsize < 2048, and `codingscheme'
  428.   a string of length less than 40 containing no parens or commas.
  429. verbose: print brief progress reports on stdout.
  430. version: print the version number of this program.
  431. "
  432.  
  433. /* We return the name of the font to process.  */
  434.  
  435. static string
  436. read_command_line (int argc, string argv[])
  437. {
  438.   int g;   /* `getopt' return code.  */
  439.   int option_index;
  440.   boolean explicit_dpi = false;
  441.   boolean printed_version = false;
  442.   struct option long_options[]
  443.     = { { "baseline-adjust",    1, 0, 0 },
  444.         { "column-split",    1, 0, 0 },
  445.         { "concat",        1, 0, 0 },
  446.         { "designsize",    1, 0, 0 },
  447.         { "dpi",        1, (int *) &explicit_dpi, 1 },
  448.         { "encoding",        1, 0, 0 },
  449.         { "epsf",        0, (int *) &wants_epsf, 1 },
  450.         { "filter-passes",    1, 0, 0 },
  451.         { "filter-size",    1, 0, 0 },
  452.         { "filter-threshold",    1, 0, 0 },
  453.         { "fontdimens",        1, 0, 0 },
  454.         { "gf",            0, (int *) &wants_gf, 1 },
  455.         { "help",        0, 0, 0 },
  456.         { "omit",        1, 0, 0 },
  457.         { "output-file",    1, 0, 0 },
  458.         { "random",        1, 0, 0 },
  459.         { "random-threshold",    1, 0, 0 },
  460.         { "range",        1, 0, 0 },
  461.         { "remap",        1, 0, 0 },
  462.         { "text",        0, (int *) &wants_text, 1 },
  463.         { "tfm",        0, (int *) &wants_tfm, 1 },
  464.         { "tfm-header",        1, 0, 0 },
  465.         { "verbose",        0, (int *) &verbose, 1 },
  466.         { "version",        0, (int *) &printed_version, 1 },
  467.         { 0, 0, 0, 0 } };
  468.  
  469.   while (true)
  470.     {
  471.       g = getopt_long_only (argc, argv, "", long_options, &option_index);
  472.       
  473.       if (g == EOF)
  474.         break;
  475.  
  476.       if (g == '?')
  477.         exit (1);  /* Unknown option.  */
  478.   
  479.       assert (g == 0); /* We have no short option names.  */
  480.       
  481.       if (ARGUMENT_IS ("baseline-adjust"))
  482.         scan_baseline_adjust (optarg);
  483.         
  484.       else if (ARGUMENT_IS ("column-split"))
  485.         scan_column_split (optarg);
  486.         
  487.       else if (ARGUMENT_IS ("concat"))
  488.         append_concat_list (&fontname_list, optarg);
  489.         
  490.       else if (ARGUMENT_IS ("designsize"))
  491.         {
  492.           design_size = atof (optarg);
  493.           TFM_CHECK_DESIGN_SIZE (design_size);
  494.         }
  495.  
  496.       else if (ARGUMENT_IS ("dpi"))
  497.         dpi = optarg;
  498.  
  499.       else if (ARGUMENT_IS ("encoding"))
  500.     {
  501.           if (encoding_info == NULL)
  502.             encoding_info = XTALLOC1 (encoding_info_type);
  503.       *encoding_info = read_encoding_file (optarg);
  504.     }
  505.  
  506.       else if (ARGUMENT_IS ("filter-passes"))
  507.         filter_passes = atou (optarg);
  508.  
  509.       else if (ARGUMENT_IS ("filter-size"))
  510.         filter_size = atou (optarg);
  511.       
  512.       else if (ARGUMENT_IS ("filter-threshold"))
  513.         {
  514.           filter_threshold = atof (optarg);
  515.           if (filter_threshold <= 0.0)
  516.             FATAL1 ("The filter threshold should be positive, not %f",
  517.                     filter_threshold);
  518.         }
  519.       
  520.       else if (ARGUMENT_IS ("fontdimens"))
  521.         fontdimens = optarg;
  522.  
  523.       else if (ARGUMENT_IS ("help"))
  524.         {
  525.           fprintf (stderr, "Usage: %s [options] <font_name>.\n", argv[0]);
  526.           fprintf (stderr, USAGE);
  527.           exit (0);
  528.         }
  529.       
  530.       else if (ARGUMENT_IS ("omit"))
  531.         scan_omit_list (optarg);
  532.         
  533.       else if (ARGUMENT_IS ("output-file"))
  534.         output_name = optarg;
  535.         
  536.       else if (ARGUMENT_IS ("range"))
  537.         GET_RANGE (optarg, starting_char, ending_char);
  538.       
  539.       else if (ARGUMENT_IS ("random"))
  540.         random_max = atof (optarg);
  541.  
  542.       else if (ARGUMENT_IS ("random-threshold"))
  543.         random_threshold = atof (optarg);
  544.  
  545.       else if (ARGUMENT_IS ("remap"))
  546.         scan_remap_list (optarg);
  547.  
  548.       else if (ARGUMENT_IS ("text"))
  549.         report_file = stderr;
  550.  
  551.       else if (ARGUMENT_IS ("tfm-header"))
  552.         tfm_header = optarg;
  553.  
  554.       else if (ARGUMENT_IS ("version"))
  555.         printf ("%s.\n", version_string);
  556.       
  557.       /* Else it was just a flag; getopt has already done the assignment.  */
  558.     }
  559.   
  560.   FINISH_COMMAND_LINE ();
  561. }
  562.  
  563. /* The string S specifies baseline adjustments for individual
  564.    characters: `<charcode>:<adjustment>,...'.  We set the element
  565.    <charcode> of the global array `baseline_adjust' to the <adjustment>.  */
  566.    
  567. static void
  568. scan_baseline_adjust (string s)
  569. {
  570.   string spec;
  571.   
  572.   for (spec = strtok (s, ARG_SEP); spec != NULL; spec = strtok (NULL, ARG_SEP))
  573.     {
  574.       string code;
  575.       string adjust = strchr (spec, ':');
  576.       
  577.       if (adjust == NULL)
  578.         FATAL1 ("Baseline adjustments look like `<code>:<integer>', not `%s'",
  579.                 spec);
  580.       
  581.       code = substring (spec, 0, adjust - spec - 1);
  582.  
  583.       baseline_adjust[xparse_charspec (code, encoding_info)] 
  584.         = atoi (adjust + 1);
  585.     }
  586. }
  587.  
  588.  
  589. /* The string S says how to split a single character into multiple
  590.    characters: `<charcode>@<column1>,...<columnN>'.  We set the element
  591.    <charcode> of the global array `column_split' to the list of the
  592.    integers.  */
  593.  
  594. static void
  595. scan_column_split (string s)
  596. {
  597.   string code;
  598.   string column_list = strchr (s, '@');
  599.   
  600.   if (column_list == NULL)
  601.     FATAL1 ("Column splits look like `<code>@<column>,<column>,...', not `%s'",
  602.       s);
  603.  
  604.   code = substring (s, 0, column_list - s - 1);
  605.   
  606.   column_split[xparse_charspec (code, encoding_info)] 
  607.     = scan_unsigned_list (column_list + 1);
  608. }
  609.  
  610.  
  611. /* The string S is a list of font names, separated by commas.  We append
  612.    each onto CONCAT_LIST.  */
  613.  
  614. static void
  615. append_concat_list (list_type *concat_list, string s)
  616. {
  617.   string name;
  618.   
  619.   /* The main routine must initialize CONCAT_LIST before we are called.  */
  620.   assert (concat_list != NULL && LIST_SIZE (*concat_list) > 0);
  621.   
  622.   for (name = strtok (s, ARG_SEP); name != NULL; name = strtok (NULL, ARG_SEP))
  623.     {
  624.       string *new = LIST_TAPPEND (concat_list, string);
  625.       *new = name;
  626.     }
  627. }
  628.  
  629.  
  630. /* The string L is a list of character codes separated by commas; we
  631.    omit those characters in the output.  Here, we parse the list and set
  632.    elements of the global array `omit' according to what we find.  */
  633.  
  634. static void
  635. scan_omit_list (string l)
  636. {
  637.   string map;
  638.   
  639.   for (map = strtok (l, ARG_SEP); map != NULL; map = strtok (NULL, ARG_SEP))
  640.     {
  641.       charcode_type code = xparse_charspec (map, encoding_info);
  642.       omit[code] = true;
  643.     }
  644. }
  645.  
  646.  
  647. /* The string L is a list of remappings to apply, in the form
  648.    <code1>:<code2>,<code1>:<code2>,...  where <code1> is a character
  649.    code in the original font, and <code2> is the character code to write
  650.    it as.  No checking for remappings to or from the same character is
  651.    done here.
  652.    
  653.    We set elements of the global array `translate' according to what we
  654.    find.  */
  655.  
  656. static void
  657. scan_remap_list (string l)
  658. {
  659.   string map; /* A single remapping.  */
  660.   
  661.   for (map = strtok (l, ARG_SEP); map != NULL; map = strtok (NULL, ARG_SEP))
  662.     {
  663.       one_byte original, target;
  664.       string original_str, target_str;
  665.       unsigned length = strlen (map);
  666.       
  667.       /* Ignore empty mappings, as in `a:b,,c:d'.  */
  668.       if (length == 0)
  669.         continue;
  670.       
  671.       else if (length < 3)
  672.         {
  673.           WARNING1 ("Mapping `%s' too short to be valid", map);
  674.           continue;
  675.         }
  676.  
  677.       else if (*map == ':')
  678.         { /* Must have form `::<code>'.  */
  679.           original_str = ":";
  680.           if (*(map + 1) != ':')
  681.             {
  682.               WARNING1 ("Mapping `%s' doesn't have form `<code>:<code>'", map);
  683.               continue;
  684.             }
  685.           target_str = map + 2;
  686.         }
  687.  
  688.       else if (*(map + length - 1) == ':')
  689.         { /* Must have form `<code>::'.  */
  690.           target_str = ":";
  691.           if (*(map + length - 2) != ':')
  692.             {
  693.               WARNING1 ("Mapping `%s' doesn't have form `<code>:<code>'", map);
  694.               continue;
  695.             }
  696.           original_str = substring (map, 0, length - 3);
  697.         }
  698.         
  699.       else
  700.         { /* Must have form `<code>:<code>'.  */
  701.           target_str = strchr (map, ':');
  702.           if (target_str == NULL)
  703.             {
  704.               WARNING1 ("Mapping `%s' doesn't have form `<code>:<code>'", map);
  705.               continue;
  706.             }
  707.           target_str++;
  708.           original_str = substring (map, 0, target_str - 2 - map);
  709.         }
  710.  
  711.       original = xparse_charspec (original_str, encoding_info);
  712.       target = xparse_charspec (target_str, encoding_info);
  713.       translate[original] = target;
  714.     }
  715. }
  716.