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 = NULL;
 154     back = NULL;
 155     line_space = 0;
 156     margin.t = margin.r = margin.b = margin.l = DEFAULT_MARGIN;
 157
 158     add_options (parser);
 159   }
 160   ~view_options_t (void)
 161   {
 162     g_free (fore);
 163     g_free (back);
 164   }
 165
 166   void add_options (option_parser_t *parser);
 167
 168   hb_bool_t annotate;
 169   char *fore;
 170   char *back;
 171   double line_space;
 172   struct margin_t {
 173     double t, r, b, l;
 174   } margin;
 175 };
 176
 177
 178 struct shape_options_t : option_group_t
 179 {
 180   shape_options_t (option_parser_t *parser)
 181   {
 182     direction = language = script = NULL;
 183     bot = eot = preserve_default_ignorables = false;
 184     features = NULL;
 185     num_features = 0;
 186     shapers = NULL;
 187     utf8_clusters = false;
 188     cluster_level = HB_BUFFER_CLUSTER_LEVEL_DEFAULT;
 189     normalize_glyphs = false;
 190     num_iterations = 1;
 191
 192     add_options (parser);
 193   }
 194   ~shape_options_t (void)
 195   {
 196     g_free (direction);
 197     g_free (language);
 198     g_free (script);
 199     free (features);
 200     g_strfreev (shapers);
 201   }
 202
 203   void add_options (option_parser_t *parser);
 204
 205   void setup_buffer (hb_buffer_t *buffer)
 206   {
 207     hb_buffer_set_direction (buffer, hb_direction_from_string (direction, -1));
 208     hb_buffer_set_script (buffer, hb_script_from_string (script, -1));
 209     hb_buffer_set_language (buffer, hb_language_from_string (language, -1));
 210     hb_buffer_set_flags (buffer, (hb_buffer_flags_t) (HB_BUFFER_FLAG_DEFAULT |
 211                          (bot ? HB_BUFFER_FLAG_BOT : 0) |
 212                          (eot ? HB_BUFFER_FLAG_EOT : 0) |
 213                          (preserve_default_ignorables ? HB_BUFFER_FLAG_PRESERVE_DEFAULT_IGNORABLES : 0)));
 214     hb_buffer_set_cluster_level (buffer, cluster_level);
 215     hb_buffer_guess_segment_properties (buffer);
 216   }
 217
 218   void populate_buffer (hb_buffer_t *buffer, const char *text, int text_len,
 219                         const char *text_before, const char *text_after)
 220   {
 221     hb_buffer_clear_contents (buffer);
 222     if (text_before) {
 223       unsigned int len = strlen (text_before);
 224       hb_buffer_add_utf8 (buffer, text_before, len, len, 0);
 225     }
 226     hb_buffer_add_utf8 (buffer, text, text_len, 0, text_len);
 227     if (text_after) {
 228       hb_buffer_add_utf8 (buffer, text_after, -1, 0, 0);
 229     }
 230
 231     if (!utf8_clusters) {
 232       /* Reset cluster values to refer to Unicode character index
 233        * instead of UTF-8 index. */
 234       unsigned int num_glyphs = hb_buffer_get_length (buffer);
 235       hb_glyph_info_t *info = hb_buffer_get_glyph_infos (buffer, NULL);
 236       for (unsigned int i = 0; i < num_glyphs; i++)
 237       {
 238         info->cluster = i;
 239         info++;
 240       }
 241     }
 242
 243     setup_buffer (buffer);
 244   }
 245
 246   hb_bool_t shape (hb_font_t *font, hb_buffer_t *buffer)
 247   {
 248     hb_bool_t res = hb_shape_full (font, buffer, features, num_features, shapers);
 249     if (normalize_glyphs)
 250       hb_buffer_normalize_glyphs (buffer);
 251     return res;
 252   }
 253
 254   void shape_closure (const char *text, int text_len,
 255                       hb_font_t *font, hb_buffer_t *buffer,
 256                       hb_set_t *glyphs)
 257   {
 258     hb_buffer_reset (buffer);
 259     hb_buffer_add_utf8 (buffer, text, text_len, 0, text_len);
 260     setup_buffer (buffer);
 261     hb_ot_shape_glyphs_closure (font, buffer, features, num_features, glyphs);
 262   }
 263
 264   /* Buffer properties */
 265   char *direction;
 266   char *language;
 267   char *script;
 268
 269   /* Buffer flags */
 270   hb_bool_t bot;
 271   hb_bool_t eot;
 272   hb_bool_t preserve_default_ignorables;
 273
 274   hb_feature_t *features;
 275   unsigned int num_features;
 276   char **shapers;
 277   hb_bool_t utf8_clusters;
 278   hb_buffer_cluster_level_t cluster_level;
 279   hb_bool_t normalize_glyphs;
 280   unsigned int num_iterations;
 281 };
 282
 283
 284 struct font_options_t : option_group_t
 285 {
 286   font_options_t (option_parser_t *parser,
 287                   int default_font_size_,
 288                   unsigned int subpixel_bits_) {
 289     default_font_size = default_font_size_;
 290     subpixel_bits = subpixel_bits_;
 291     font_file = NULL;
 292     face_index = 0;
 293     font_size_x = font_size_y = default_font_size;
 294     font_funcs = NULL;
 295
 296     font = NULL;
 297
 298     add_options (parser);
 299   }
 300   ~font_options_t (void) {
 301     g_free (font_file);
 302     g_free (font_funcs);
 303     hb_font_destroy (font);
 304   }
 305
 306   void add_options (option_parser_t *parser);
 307
 308   hb_font_t *get_font (void) const;
 309
 310   char *font_file;
 311   int face_index;
 312   int default_font_size;
 313   unsigned int subpixel_bits;
 314   mutable double font_size_x;
 315   mutable double font_size_y;
 316   char *font_funcs;
 317
 318   private:
 319   mutable hb_font_t *font;
 320 };
 321
 322
 323 struct text_options_t : option_group_t
 324 {
 325   text_options_t (option_parser_t *parser) {
 326     text_before = NULL;
 327     text_after = NULL;
 328
 329     text = NULL;
 330     text_file = NULL;
 331
 332     fp = NULL;
 333     gs = NULL;
 334     line = NULL;
 335     line_len = (unsigned int) -1;
 336
 337     add_options (parser);
 338   }
 339   ~text_options_t (void) {
 340     g_free (text_before);
 341     g_free (text_after);
 342     g_free (text);
 343     g_free (text_file);
 344     if (gs)
 345       g_string_free (gs, true);
 346     if (fp)
 347       fclose (fp);
 348   }
 349
 350   void add_options (option_parser_t *parser);
 351
 352   void post_parse (GError **error G_GNUC_UNUSED) {
 353     if (text && text_file)
 354       g_set_error (error,
 355                    G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE,
 356                    "Only one of text and text-file can be set");
 357   };
 358
 359   const char *get_line (unsigned int *len);
 360
 361   char *text_before;
 362   char *text_after;
 363
 364   char *text;
 365   char *text_file;
 366
 367   private:
 368   FILE *fp;
 369   GString *gs;
 370   char *line;
 371   unsigned int line_len;
 372 };
 373
 374 struct output_options_t : option_group_t
 375 {
 376   output_options_t (option_parser_t *parser,
 377                     const char **supported_formats_ = NULL) {
 378     output_file = NULL;
 379     output_format = NULL;
 380     supported_formats = supported_formats_;
 381     explicit_output_format = false;
 382
 383     fp = NULL;
 384
 385     add_options (parser);
 386   }
 387   ~output_options_t (void) {
 388     g_free (output_file);
 389     g_free (output_format);
 390     if (fp)
 391       fclose (fp);
 392   }
 393
 394   void add_options (option_parser_t *parser);
 395
 396   void post_parse (GError **error G_GNUC_UNUSED)
 397   {
 398     if (output_format)
 399       explicit_output_format = true;
 400
 401     if (output_file && !output_format) {
 402       output_format = strrchr (output_file, '.');
 403       if (output_format)
 404       {
 405           output_format++; /* skip the dot */
 406           output_format = strdup (output_format);
 407       }
 408     }
 409
 410     if (output_file && 0 == strcmp (output_file, "-"))
 411       output_file = NULL; /* STDOUT */
 412   }
 413
 414   FILE *get_file_handle (void);
 415
 416   char *output_file;
 417   char *output_format;
 418   const char **supported_formats;
 419   bool explicit_output_format;
 420
 421   mutable FILE *fp;
 422 };
 423
 424 struct format_options_t : option_group_t
 425 {
 426   format_options_t (option_parser_t *parser) {
 427     show_glyph_names = true;
 428     show_positions = true;
 429     show_clusters = true;
 430     show_text = false;
 431     show_unicode = false;
 432     show_line_num = false;
 433     show_extents = false;
 434
 435     add_options (parser);
 436   }
 437
 438   void add_options (option_parser_t *parser);
 439
 440   void serialize_unicode (hb_buffer_t  *buffer,
 441                           GString      *gs);
 442   void serialize_glyphs (hb_buffer_t  *buffer,
 443                          hb_font_t    *font,
 444                          hb_buffer_serialize_format_t format,
 445                          hb_buffer_serialize_flags_t flags,
 446                          GString      *gs);
 447   void serialize_line_no (unsigned int  line_no,
 448                           GString      *gs);
 449   void serialize_buffer_of_text (hb_buffer_t  *buffer,
 450                                  unsigned int  line_no,
 451                                  const char   *text,
 452                                  unsigned int  text_len,
 453                                  hb_font_t    *font,
 454                                  GString      *gs);
 455   void serialize_message (unsigned int  line_no,
 456                           const char   *msg,
 457                           GString      *gs);
 458   void serialize_buffer_of_glyphs (hb_buffer_t  *buffer,
 459                                    unsigned int  line_no,
 460                                    const char   *text,
 461                                    unsigned int  text_len,
 462                                    hb_font_t    *font,
 463                                    hb_buffer_serialize_format_t output_format,
 464                                    hb_buffer_serialize_flags_t format_flags,
 465                                    GString      *gs);
 466
 467
 468   hb_bool_t show_glyph_names;
 469   hb_bool_t show_positions;
 470   hb_bool_t show_clusters;
 471   hb_bool_t show_text;
 472   hb_bool_t show_unicode;
 473   hb_bool_t show_line_num;
 474   hb_bool_t show_extents;
 475 };
 476
 477 /* fallback implementation for scalbn()/scalbnf() for pre-2013 MSVC */
 478 #if defined (_MSC_VER) && (_MSC_VER < 1800)
 479
 480 #ifndef FLT_RADIX
 481 #define FLT_RADIX 2
 482 #endif
 483
 484 __inline long double scalbn (long double x, int exp)
 485 {
 486   return x * (pow ((long double) FLT_RADIX, exp));
 487 }
 488
 489 __inline float scalbnf (float x, int exp)
 490 {
 491   return x * (pow ((float) FLT_RADIX, exp));
 492 }
 493 #endif
 494
 495 #endif