util/options.hh

   1 /*
   2  * Copyright © 2011  Google, Inc.
   3  *
   4  *  This is part of HarfBuzz, a text shaping library.
   5  *
   6  * Permission is hereby granted, without written agreement and without
   7  * license or royalty fees, to use, copy, modify, and distribute this
   8  * software and its documentation for any purpose, provided that the
   9  * above copyright notice and the following two paragraphs appear in
  10  * all copies of this software.
  11  *
  12  * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
  13  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
  14  * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
  15  * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
  16  * DAMAGE.
  17  *
  18  * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
  19  * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
  20  * FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
  21  * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
  22  * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
  23  *
  24  * Google Author(s): Behdad Esfahbod
  25  */
  26
  27 #ifndef OPTIONS_HH
  28 #define OPTIONS_HH
  29
  30
  31 #ifdef HAVE_CONFIG_H
  32 #include "config.h"
  33 #endif
  34
  35 #include <stdlib.h>
  36 #include <stddef.h>
  37 #include <string.h>
  38 #include <stdio.h>
  39 #include <math.h>
  40 #include <locale.h>
  41 #include <errno.h>
  42 #include <fcntl.h>
  43 #ifdef HAVE_UNISTD_H
  44 #include <unistd.h> /* for isatty() */
  45 #endif
  46 #if defined(_WIN32) || defined(__CYGWIN__)
  47 #include <io.h> /* for setmode() under Windows */
  48 #endif
  49
  50 #include <hb.h>
  51 #ifdef HAVE_OT
  52 #include <hb-ot.h>
  53 #endif
  54 #include <glib.h>
  55 #include <glib/gprintf.h>
  56
  57 #if !GLIB_CHECK_VERSION (2, 22, 0)
  58 # define g_mapped_file_unref g_mapped_file_free
  59 #endif
  60
  61
  62 /* A few macros copied from hb-private.hh. */
  63
  64 #if __GNUC__ >= 4
  65 #define HB_UNUSED       __attribute__((unused))
  66 #else
  67 #define HB_UNUSED
  68 #endif
  69
  70 #undef MIN
  71 template <typename Type> static inline Type MIN (const Type &a, const Type &b) { return a < b ? a : b; }
  72
  73 #undef MAX
  74 template <typename Type> static inline Type MAX (const Type &a, const Type &b) { return a > b ? a : b; }
  75
  76 #undef  ARRAY_LENGTH
  77 template <typename Type, unsigned int n>
  78 static inline unsigned int ARRAY_LENGTH (const Type (&)[n]) { return n; }
  79 /* A const version, but does not detect erratically being called on pointers. */
  80 #define ARRAY_LENGTH_CONST(__array) ((signed int) (sizeof (__array) / sizeof (__array[0])))
  81
  82 #define _ASSERT_STATIC1(_line, _cond)   HB_UNUSED typedef int _static_assert_on_line_##_line##_failed[(_cond)?1:-1]
  83 #define _ASSERT_STATIC0(_line, _cond)   _ASSERT_STATIC1 (_line, (_cond))
  84 #define ASSERT_STATIC(_cond)            _ASSERT_STATIC0 (__LINE__, (_cond))
  85
  86
  87 void fail (hb_bool_t suggest_help, const char *format, ...) G_GNUC_NORETURN G_GNUC_PRINTF (2, 3);
  88
  89
  90 extern hb_bool_t debug;
  91
  92 struct option_group_t
  93 {
  94   virtual void add_options (struct option_parser_t *parser) = 0;
  95
  96   virtual void pre_parse (GError **error G_GNUC_UNUSED) {};
  97   virtual void post_parse (GError **error G_GNUC_UNUSED) {};
  98 };
  99
 100
 101 struct option_parser_t
 102 {
 103   option_parser_t (const char *usage) {
 104     memset (this, 0, sizeof (*this));
 105     usage_str = usage;
 106     context = g_option_context_new (usage);
 107     to_free = g_ptr_array_new ();
 108
 109     add_main_options ();
 110   }
 111   ~option_parser_t (void) {
 112     g_option_context_free (context);
 113     g_ptr_array_foreach (to_free, (GFunc) g_free, NULL);
 114     g_ptr_array_free (to_free, TRUE);
 115   }
 116
 117   void add_main_options (void);
 118
 119   void add_group (GOptionEntry   *entries,
 120                   const gchar    *name,
 121                   const gchar    *description,
 122                   const gchar    *help_description,
 123                   option_group_t *option_group);
 124
 125   void free_later (char *p) {
 126     g_ptr_array_add (to_free, p);
 127   }
 128
 129   void parse (int *argc, char ***argv);
 130
 131   G_GNUC_NORETURN void usage (void) {
 132     g_printerr ("Usage: %s [OPTION...] %s\n", g_get_prgname (), usage_str);
 133     exit (1);
 134   }
 135
 136   private:
 137   const char *usage_str;
 138   GOptionContext *context;
 139   GPtrArray *to_free;
 140 };
 141
 142
 143 #define DEFAULT_MARGIN 16
 144 #define DEFAULT_FORE "#000000"
 145 #define DEFAULT_BACK "#FFFFFF"
 146 #define FONT_SIZE_UPEM 0x7FFFFFFF
 147 #define FONT_SIZE_NONE 0
 148
 149 struct view_options_t : option_group_t
 150 {
 151   view_options_t (option_parser_t *parser) {
 152     annotate = false;
 153     fore = DEFAULT_FORE;
 154     back = DEFAULT_BACK;
 155     line_space = 0;
 156     margin.t = margin.r = margin.b = margin.l = DEFAULT_MARGIN;
 157
 158     add_options (parser);
 159   }
 160
 161   void add_options (option_parser_t *parser);
 162
 163   hb_bool_t annotate;
 164   const char *fore;
 165   const char *back;
 166   double line_space;
 167   struct margin_t {
 168     double t, r, b, l;
 169   } margin;
 170 };
 171
 172
 173 struct shape_options_t : option_group_t
 174 {
 175   shape_options_t (option_parser_t *parser)
 176   {
 177     direction = language = script = NULL;
 178     bot = eot = preserve_default_ignorables = false;
 179     features = NULL;
 180     num_features = 0;
 181     shapers = NULL;
 182     utf8_clusters = false;
 183     normalize_glyphs = false;
 184     num_iterations = 1;
 185
 186     add_options (parser);
 187   }
 188   ~shape_options_t (void)
 189   {
 190     free (features);
 191     g_strfreev (shapers);
 192   }
 193
 194   void add_options (option_parser_t *parser);
 195
 196   void setup_buffer (hb_buffer_t *buffer)
 197   {
 198     hb_buffer_set_direction (buffer, hb_direction_from_string (direction, -1));
 199     hb_buffer_set_script (buffer, hb_script_from_string (script, -1));
 200     hb_buffer_set_language (buffer, hb_language_from_string (language, -1));
 201     hb_buffer_set_flags (buffer, (hb_buffer_flags_t) (HB_BUFFER_FLAG_DEFAULT |
 202                          (bot ? HB_BUFFER_FLAG_BOT : 0) |
 203                          (eot ? HB_BUFFER_FLAG_EOT : 0) |
 204                          (preserve_default_ignorables ? HB_BUFFER_FLAG_PRESERVE_DEFAULT_IGNORABLES : 0)));
 205     hb_buffer_guess_segment_properties (buffer);
 206   }
 207
 208   void populate_buffer (hb_buffer_t *buffer, const char *text, int text_len,
 209                         const char *text_before, const char *text_after)
 210   {
 211     hb_buffer_clear_contents (buffer);
 212     if (text_before) {
 213       unsigned int len = strlen (text_before);
 214       hb_buffer_add_utf8 (buffer, text_before, len, len, 0);
 215     }
 216     hb_buffer_add_utf8 (buffer, text, text_len, 0, text_len);
 217     if (text_after) {
 218       hb_buffer_add_utf8 (buffer, text_after, -1, 0, 0);
 219     }
 220
 221     if (!utf8_clusters) {
 222       /* Reset cluster values to refer to Unicode character index
 223        * instead of UTF-8 index. */
 224       unsigned int num_glyphs = hb_buffer_get_length (buffer);
 225       hb_glyph_info_t *info = hb_buffer_get_glyph_infos (buffer, NULL);
 226       for (unsigned int i = 0; i < num_glyphs; i++)
 227       {
 228         info->cluster = i;
 229         info++;
 230       }
 231     }
 232
 233     setup_buffer (buffer);
 234   }
 235
 236   hb_bool_t shape (hb_font_t *font, hb_buffer_t *buffer)
 237   {
 238     hb_bool_t res = hb_shape_full (font, buffer, features, num_features, shapers);
 239     if (normalize_glyphs)
 240       hb_buffer_normalize_glyphs (buffer);
 241     return res;
 242   }
 243
 244   void shape_closure (const char *text, int text_len,
 245                       hb_font_t *font, hb_buffer_t *buffer,
 246                       hb_set_t *glyphs)
 247   {
 248     hb_buffer_reset (buffer);
 249     hb_buffer_add_utf8 (buffer, text, text_len, 0, text_len);
 250     setup_buffer (buffer);
 251     hb_ot_shape_glyphs_closure (font, buffer, features, num_features, glyphs);
 252   }
 253
 254   /* Buffer properties */
 255   const char *direction;
 256   const char *language;
 257   const char *script;
 258
 259   /* Buffer flags */
 260   hb_bool_t bot;
 261   hb_bool_t eot;
 262   hb_bool_t preserve_default_ignorables;
 263
 264   hb_feature_t *features;
 265   unsigned int num_features;
 266   char **shapers;
 267   hb_bool_t utf8_clusters;
 268   hb_bool_t normalize_glyphs;
 269   unsigned int num_iterations;
 270 };
 271
 272
 273 struct font_options_t : option_group_t
 274 {
 275   font_options_t (option_parser_t *parser,
 276                   int default_font_size_,
 277                   unsigned int subpixel_bits_) {
 278     default_font_size = default_font_size_;
 279     subpixel_bits = subpixel_bits_;
 280     font_file = NULL;
 281     face_index = 0;
 282     font_size_x = font_size_y = default_font_size;
 283     font_funcs = NULL;
 284
 285     font = NULL;
 286
 287     add_options (parser);
 288   }
 289   ~font_options_t (void) {
 290     hb_font_destroy (font);
 291   }
 292
 293   void add_options (option_parser_t *parser);
 294
 295   hb_font_t *get_font (void) const;
 296
 297   const char *font_file;
 298   int face_index;
 299   int default_font_size;
 300   unsigned int subpixel_bits;
 301   mutable double font_size_x;
 302   mutable double font_size_y;
 303   const char *font_funcs;
 304
 305   private:
 306   mutable hb_font_t *font;
 307 };
 308
 309
 310 struct text_options_t : option_group_t
 311 {
 312   text_options_t (option_parser_t *parser) {
 313     text_before = NULL;
 314     text_after = NULL;
 315
 316     text = NULL;
 317     text_file = NULL;
 318
 319     fp = NULL;
 320     gs = NULL;
 321     text_len = (unsigned int) -1;
 322
 323     add_options (parser);
 324   }
 325   ~text_options_t (void) {
 326     if (gs)
 327       g_string_free (gs, true);
 328     if (fp)
 329       fclose (fp);
 330   }
 331
 332   void add_options (option_parser_t *parser);
 333
 334   void post_parse (GError **error G_GNUC_UNUSED) {
 335     if (text && text_file)
 336       g_set_error (error,
 337                    G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE,
 338                    "Only one of text and text-file can be set");
 339
 340   };
 341
 342   const char *get_line (unsigned int *len);
 343
 344   const char *text_before;
 345   const char *text_after;
 346
 347   const char *text;
 348   const char *text_file;
 349
 350   private:
 351   FILE *fp;
 352   GString *gs;
 353   unsigned int text_len;
 354 };
 355
 356 struct output_options_t : option_group_t
 357 {
 358   output_options_t (option_parser_t *parser,
 359                     const char **supported_formats_ = NULL) {
 360     output_file = NULL;
 361     output_format = NULL;
 362     supported_formats = supported_formats_;
 363     explicit_output_format = false;
 364
 365     fp = NULL;
 366
 367     add_options (parser);
 368   }
 369   ~output_options_t (void) {
 370     if (fp)
 371       fclose (fp);
 372   }
 373
 374   void add_options (option_parser_t *parser);
 375
 376   void post_parse (GError **error G_GNUC_UNUSED)
 377   {
 378     if (output_format)
 379       explicit_output_format = true;
 380
 381     if (output_file && !output_format) {
 382       output_format = strrchr (output_file, '.');
 383       if (output_format)
 384           output_format++; /* skip the dot */
 385     }
 386
 387     if (output_file && 0 == strcmp (output_file, "-"))
 388       output_file = NULL; /* STDOUT */
 389   }
 390
 391   FILE *get_file_handle (void);
 392
 393   const char *output_file;
 394   const char *output_format;
 395   const char **supported_formats;
 396   bool explicit_output_format;
 397
 398   mutable FILE *fp;
 399 };
 400
 401 struct format_options_t : option_group_t
 402 {
 403   format_options_t (option_parser_t *parser) {
 404     show_glyph_names = true;
 405     show_positions = true;
 406     show_clusters = true;
 407     show_text = false;
 408     show_unicode = false;
 409     show_line_num = false;
 410
 411     add_options (parser);
 412   }
 413
 414   void add_options (option_parser_t *parser);
 415
 416   void serialize_unicode (hb_buffer_t  *buffer,
 417                           GString      *gs);
 418   void serialize_glyphs (hb_buffer_t  *buffer,
 419                          hb_font_t    *font,
 420                          hb_buffer_serialize_format_t format,
 421                          hb_buffer_serialize_flags_t flags,
 422                          GString      *gs);
 423   void serialize_line_no (unsigned int  line_no,
 424                           GString      *gs);
 425   void serialize_buffer_of_text (hb_buffer_t  *buffer,
 426                                  unsigned int  line_no,
 427                                  const char   *text,
 428                                  unsigned int  text_len,
 429                                  hb_font_t    *font,
 430                                  GString      *gs);
 431   void serialize_message (unsigned int  line_no,
 432                           const char   *msg,
 433                           GString      *gs);
 434   void serialize_buffer_of_glyphs (hb_buffer_t  *buffer,
 435                                    unsigned int  line_no,
 436                                    const char   *text,
 437                                    unsigned int  text_len,
 438                                    hb_font_t    *font,
 439                                    hb_buffer_serialize_format_t output_format,
 440                                    hb_buffer_serialize_flags_t format_flags,
 441                                    GString      *gs);
 442
 443
 444   hb_bool_t show_glyph_names;
 445   hb_bool_t show_positions;
 446   hb_bool_t show_clusters;
 447   hb_bool_t show_text;
 448   hb_bool_t show_unicode;
 449   hb_bool_t show_line_num;
 450 };
 451
 452
 453 #endif