lily/tfm-reader.cc

   1 /*
   2   tfm-reader.cc --  implement Tex_font_metric_reader
   3
   4   source file of the GNU LilyPond music typesetter
   5
   6   (c) 1999--2001 Jan Nieuwenhuizen <janneke@gnu.org>
   7
   8
   9   some code shamelessly copied from GNU fontutils-0.6/tfm/tfm_input.c
  10  */
  11
  12 #include "tfm-reader.hh"
  13 #include "string-convert.hh"
  14 #include "debug.hh"
  15 #include "warn.hh"
  16
  17 #define format_str String_convert::form_str
  18 #define FIX_UNITY \
  19  (1 << 20)
  20 static const Real fix_to_real (Fix f);
  21
  22
  23 Tex_font_metric_reader::Tex_font_metric_reader (String name)
  24   : input_ (name)
  25 {
  26
  27   for (int i=0; i < TFM_SIZE; i++)
  28     ascii_to_metric_idx_.push (-1);
  29
  30   read_header ();
  31   read_params ();
  32   read_char_metrics ();
  33
  34 }
  35
  36 static const Real
  37 fix_to_real (Fix f)
  38 {
  39   Real r = f / FIX_UNITY + ((Real) (f % FIX_UNITY) / (Real) FIX_UNITY);
  40   return r;
  41 }
  42
  43 /* Most quantities are fixed-point fractions.  */
  44
  45 Real
  46 Tex_font_metric_reader::get_U32_fix_f ()
  47 {
  48   return fix_to_real (input_.get_U32 ());
  49 }
  50
  51 /* Dimensions are a `Fix' scaled by the design size.  */
  52
  53 Real
  54 Tex_font_metric_reader::get_U32_fix_scaled_f ()
  55 {
  56   return get_U32_fix_f () * info_.design_size;
  57 }
  58
  59 String
  60 Tex_font_metric_reader::get_bcpl_str ()
  61 {
  62   U8 length_u8 = input_.get_U8 ();
  63   String str = input_.get_str (length_u8);
  64   return str;
  65 }
  66
  67 /* Here we read the information at the beginning of the file.  We store
  68    the result into the static variables `global_info' and
  69    `tfm_header'.  */
  70 void
  71 Tex_font_metric_reader::read_header ()
  72 {
  73   U16 file_length = input_.get_U16 ();
  74  (void) file_length;
  75   U16 header_length = input_.get_U16 ();
  76
  77   info_.first_charcode = input_.get_U16 ();
  78   info_.last_charcode = input_.get_U16 ();
  79   U16 width_word_count = input_.get_U16 ();
  80   U16 height_word_count = input_.get_U16 ();
  81   U16 depth_word_count = input_.get_U16 ();
  82   U16 italic_correction_word_count = input_.get_U16 ();
  83   U16 lig_kern_word_count = input_.get_U16 ();
  84   U16 kern_word_count = input_.get_U16 ();
  85  (void)kern_word_count;
  86   U16 extensible_word_count = input_.get_U16 ();
  87  (void)extensible_word_count;
  88
  89   header_.param_word_count = input_.get_U16 ();
  90   info_.parameter_count = header_.param_word_count;
  91
  92   header_.char_info_pos = (6 + header_length) * 4;
  93   header_.width_pos = header_.char_info_pos
  94                          + (info_.last_charcode
  95                             - info_.first_charcode + 1) * 4;
  96   header_.height_pos = header_.width_pos + width_word_count * 4;
  97   header_.depth_pos = header_.height_pos + height_word_count * 4;
  98   header_.italic_correction_pos = header_.depth_pos
  99                                      + depth_word_count * 4;
 100   header_.lig_kern_pos = header_.italic_correction_pos
 101     + italic_correction_word_count * 4;
 102   header_.kern_pos = header_.lig_kern_pos + lig_kern_word_count * 4;
 103   /* We don't care about the extensible table.  */
 104
 105   if (header_length < 2)
 106     error (_f ("TFM header of `%s' has only %u word (s)",
 107                input_.name_str ().ch_C (), header_length));
 108
 109   info_.checksum = input_.get_U32 ();
 110   info_.design_size = get_U32_fix_f ();
 111
 112   /* Although the coding scheme might be interesting to the caller, the
 113      font family and face byte probably aren't.  So we don't read them.  */
 114   info_.coding_scheme = header_length > 2
 115     ? get_bcpl_str () : "unspecified";
 116
 117 }
 118
 119 /* Although TFM files are only usable by TeX if they have at least seven
 120    parameters, that is not a requirement of the file format itself, so
 121    we don't impose it.  And they can have many more than seven, of
 122    course.  We do impose a limit of TFM_MAX_FONT_PARAMETERS.  We assume
 123    that `tfm_header' has already been filled in.  */
 124
 125 void
 126 Tex_font_metric_reader::read_params ()
 127 {
 128   /* If we have no font parameters at all, we're done.  */
 129   if (header_.param_word_count == 0)
 130     return;
 131
 132   //brrr
 133   /* Move to the beginning of the parameter table in the file.  */
 134   input_.seek_ch_C (-4 * header_.param_word_count);
 135
 136   /* It's unlikely but possible that this TFM file has more fontdimens
 137      than we can deal with.  */
 138   if (header_.param_word_count > TFM_MAX_FONTDIMENS)
 139     {
 140       warning (_f ("%s: TFM file has %u parameters, which is more than the %u I can handle",
 141                    input_.name_str ().ch_C (),
 142                    header_.param_word_count,
 143                    TFM_MAX_FONTDIMENS));
 144       header_.param_word_count = TFM_MAX_FONTDIMENS;
 145     }
 146
 147   /* The first parameter is different than all the rest, because it
 148      isn't scaled by the design size.  */
 149   info_.parameters[ (TFM_SLANT_PARAMETER) - 1] = get_U32_fix_f ();
 150
 151   for (Char_code i = 2; i <= header_.param_word_count; i++)
 152     info_.parameters[i - 1] = get_U32_fix_scaled_f ();
 153
 154 }
 155
 156 /* Read every character in the TFM file, storing the result in the
 157    static `tfm_char_table'.  We return a copy of that variable.  */
 158
 159 void
 160 Tex_font_metric_reader::read_char_metrics ()
 161 {
 162   for (int i = info_.first_charcode; i <= info_.last_charcode; i++)
 163     {
 164       Tex_font_char_metric tfm_char = read_char_metric (i);
 165       if (tfm_char.exists_b_)
 166         ascii_to_metric_idx_[tfm_char.code_] = char_metrics_.size ();
 167       char_metrics_.push (tfm_char);
 168     }
 169 }
 170
 171 /* Read the character CODE.  If the character doesn't exist, return
 172    NULL.  If it does, save the information in `tfm_char_table', as well
 173    as returning it.  */
 174
 175 Tex_font_char_metric
 176 Tex_font_metric_reader::read_char_metric (Char_code code)
 177 {
 178   Tex_font_char_metric tfm_char;
 179
 180   /* If the character is outside the declared bounds in the file, don't
 181      try to read it. */
 182   if (code < info_.first_charcode || code > info_.last_charcode)
 183     return tfm_char;
 184
 185   //brr
 186   /* Move to the appropriate place in the `char_info' array.  */
 187   input_.seek_ch_C (header_.char_info_pos + (code - info_.first_charcode) * 4);
 188
 189   /* Read the character.  */
 190   tfm_char = read_char ();
 191
 192   if (tfm_char.exists_b_)
 193     tfm_char.code_ = code;
 194
 195   return tfm_char;
 196 }
 197
 198
 199 /* We assume we are positioned at the beginning of a `char_info' word.
 200    We read that word to get the indexes into the dimension tables; then
 201    we go read the tables to get the values (if the character exists).  */
 202
 203 Tex_font_char_metric
 204 Tex_font_metric_reader::read_char ()
 205 {
 206   /* Read the char_info word.  */
 207   U8 width_index = input_.get_U8 ();
 208
 209   U8 packed;
 210   packed = input_.get_U8 ();
 211   U8 height_index = (packed & 0xf0) >> 4;
 212   U8 depth_index = packed & 0x0f;
 213
 214   packed = input_.get_U8 ();
 215   U8 italic_correction_index = (packed & 0xfc) >> 6;
 216   U8 tag = packed & 0x3;
 217
 218   U8 remainder = input_.get_U8 ();
 219
 220   Tex_font_char_metric tfm_char;
 221
 222 #define GET_CHAR_DIMEN(d) \
 223    if (d##_index != 0) \
 224      { \
 225        input_.seek_ch_C (header_.##d##_pos + d##_index*4); \
 226        tfm_char.d##_fix_ = input_.get_U32 (); \
 227        tfm_char.d##_ = fix_to_real (tfm_char.d##_fix_) \
 228                       * info_.design_size; \
 229      }
 230
 231   GET_CHAR_DIMEN (width);
 232   GET_CHAR_DIMEN (height);
 233   GET_CHAR_DIMEN (depth);
 234   GET_CHAR_DIMEN (italic_correction);
 235
 236   /* The other condition for a character existing is that it be between
 237      the first and last character codes given in the header.  We've
 238      already assumed that's true (or we couldn't be positioned at a
 239      `char_info_word').  */
 240   tfm_char.exists_b_ = width_index != 0;
 241
 242   if (tag == 1)
 243     {
 244       input_.seek_ch_C (header_.lig_kern_pos + remainder * 4);
 245       read_lig_kern_program (&tfm_char.ligature_arr_, &tfm_char.kern_arr_);
 246     }
 247
 248   /* We don't handle the other tags.  */
 249   return tfm_char;
 250 }
 251
 252 /* Read a ligature/kern program at the current position, storing the
 253    result into *LIGATURE and *KERN.  We don't distinguish all the kinds
 254    of ligatures that Metafont can output.  */
 255
 256 #define STOP_FLAG 128
 257 #define KERN_FLAG 128
 258
 259 void
 260 Tex_font_metric_reader::read_lig_kern_program (Array <Tfm_ligature>* ligature_arr_p, Array <Tfm_kern>* kern_arr_p)
 261 {
 262   bool end_b;
 263
 264   do
 265     {
 266       end_b = input_.get_U8 () >= STOP_FLAG;
 267
 268       U8 next_char = input_.get_U8 ();
 269       bool kern_step_b = input_.get_U8 () >= KERN_FLAG;
 270       U8 remainder = input_.get_U8 ();
 271
 272
 273       if (kern_step_b)
 274         {
 275           Tfm_kern kern_element;
 276           kern_element.character = next_char;
 277
 278           char const* old_pos = input_.pos_ch_C ();
 279           input_.seek_ch_C (header_.kern_pos + remainder * 4);
 280           kern_element.kern = get_U32_fix_scaled_f ();
 281           input_.set_pos (old_pos);
 282
 283           kern_arr_p->push (kern_element);
 284
 285         }
 286       else
 287         {
 288           Tfm_ligature ligature_element;
 289           ligature_element.character = next_char;
 290           ligature_element.ligature = remainder;
 291           ligature_arr_p->push (ligature_element);
 292
 293         }
 294   } while (!end_b);
 295 }
 296