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 #include "hb-private.hh"
  31
  32 #include <stdlib.h>
  33 #include <stddef.h>
  34 #include <string.h>
  35 #include <stdio.h>
  36 #include <assert.h>
  37 #include <math.h>
  38 #include <locale.h>
  39 #include <errno.h>
  40 #include <fcntl.h>
  41 #ifdef HAVE_UNISTD_H
  42 #include <unistd.h> /* for isatty() */
  43 #endif
  44 #if defined(_WIN32) || defined(__CYGWIN__)
  45 #include <io.h> /* for setmode() under Windows */
  46 #endif
  47
  48 #include <hb.h>
  49 #ifdef HAVE_OT
  50 #include <hb-ot.h>
  51 #endif
  52 #include <glib.h>
  53 #include <glib/gprintf.h>
  54
  55 void fail (hb_bool_t suggest_help, const char *format, ...) G_GNUC_NORETURN G_GNUC_PRINTF (2, 3);
  56
  57 struct option_group_t
  58 {
  59   virtual void add_options (struct option_parser_t *parser) = 0;
  60
  61   virtual void pre_parse (GError **error G_GNUC_UNUSED) {};
  62   virtual void post_parse (GError **error G_GNUC_UNUSED) {};
  63 };
  64
  65
  66 struct option_parser_t
  67 {
  68   option_parser_t (const char *usage) {
  69     memset (this, 0, sizeof (*this));
  70     usage_str = usage;
  71     context = g_option_context_new (usage);
  72     to_free = g_ptr_array_new ();
  73
  74     add_main_options ();
  75   }
  76   ~option_parser_t (void) {
  77     g_option_context_free (context);
  78     g_ptr_array_foreach (to_free, (GFunc) g_free, nullptr);
  79     g_ptr_array_free (to_free, TRUE);
  80   }
  81
  82   void add_main_options (void);
  83
  84   void add_group (GOptionEntry   *entries,
  85                   const gchar    *name,
  86                   const gchar    *description,
  87                   const gchar    *help_description,
  88                   option_group_t *option_group);
  89
  90   void free_later (char *p) {
  91     g_ptr_array_add (to_free, p);
  92   }
  93
  94   void parse (int *argc, char ***argv);
  95
  96   G_GNUC_NORETURN void usage (void) {
  97     g_printerr ("Usage: %s [OPTION...] %s\n", g_get_prgname (), usage_str);
  98     exit (1);
  99   }
 100
 101   private:
 102   const char *usage_str;
 103   GOptionContext *context;
 104   GPtrArray *to_free;
 105 };
 106
 107
 108 #define DEFAULT_MARGIN 16
 109 #define DEFAULT_FORE "#000000"
 110 #define DEFAULT_BACK "#FFFFFF"
 111 #define FONT_SIZE_UPEM 0x7FFFFFFF
 112 #define FONT_SIZE_NONE 0
 113
 114 struct view_options_t : option_group_t
 115 {
 116   view_options_t (option_parser_t *parser) {
 117     annotate = false;
 118     fore = nullptr;
 119     back = nullptr;
 120     line_space = 0;
 121     margin.t = margin.r = margin.b = margin.l = DEFAULT_MARGIN;
 122
 123     add_options (parser);
 124   }
 125   ~view_options_t (void)
 126   {
 127     g_free (fore);
 128     g_free (back);
 129   }
 130
 131   void add_options (option_parser_t *parser);
 132
 133   hb_bool_t annotate;
 134   char *fore;
 135   char *back;
 136   double line_space;
 137   struct margin_t {
 138     double t, r, b, l;
 139   } margin;
 140 };
 141
 142
 143 struct shape_options_t : option_group_t
 144 {
 145   shape_options_t (option_parser_t *parser)
 146   {
 147     direction = language = script = nullptr;
 148     bot = eot = preserve_default_ignorables = remove_default_ignorables = false;
 149     features = nullptr;
 150     num_features = 0;
 151     shapers = nullptr;
 152     utf8_clusters = false;
 153     cluster_level = HB_BUFFER_CLUSTER_LEVEL_DEFAULT;
 154     normalize_glyphs = false;
 155     verify = false;
 156     num_iterations = 1;
 157
 158     add_options (parser);
 159   }
 160   ~shape_options_t (void)
 161   {
 162     g_free (direction);
 163     g_free (language);
 164     g_free (script);
 165     free (features);
 166     g_strfreev (shapers);
 167   }
 168
 169   void add_options (option_parser_t *parser);
 170
 171   void setup_buffer (hb_buffer_t *buffer)
 172   {
 173     hb_buffer_set_direction (buffer, hb_direction_from_string (direction, -1));
 174     hb_buffer_set_script (buffer, hb_script_from_string (script, -1));
 175     hb_buffer_set_language (buffer, hb_language_from_string (language, -1));
 176     hb_buffer_set_flags (buffer, (hb_buffer_flags_t)
 177                                  (HB_BUFFER_FLAG_DEFAULT |
 178                                   (bot ? HB_BUFFER_FLAG_BOT : 0) |
 179                                   (eot ? HB_BUFFER_FLAG_EOT : 0) |
 180                                   (preserve_default_ignorables ? HB_BUFFER_FLAG_PRESERVE_DEFAULT_IGNORABLES : 0) |
 181                                   (remove_default_ignorables ? HB_BUFFER_FLAG_REMOVE_DEFAULT_IGNORABLES : 0) |
 182                                   0));
 183     hb_buffer_set_cluster_level (buffer, cluster_level);
 184     hb_buffer_guess_segment_properties (buffer);
 185   }
 186
 187   static void copy_buffer_properties (hb_buffer_t *dst, hb_buffer_t *src)
 188   {
 189     hb_segment_properties_t props;
 190     hb_buffer_get_segment_properties (src, &props);
 191     hb_buffer_set_segment_properties (dst, &props);
 192     hb_buffer_set_flags (dst, hb_buffer_get_flags (src));
 193     hb_buffer_set_cluster_level (dst, hb_buffer_get_cluster_level (src));
 194   }
 195
 196   void populate_buffer (hb_buffer_t *buffer, const char *text, int text_len,
 197                         const char *text_before, const char *text_after)
 198   {
 199     hb_buffer_clear_contents (buffer);
 200     if (text_before) {
 201       unsigned int len = strlen (text_before);
 202       hb_buffer_add_utf8 (buffer, text_before, len, len, 0);
 203     }
 204     hb_buffer_add_utf8 (buffer, text, text_len, 0, text_len);
 205     if (text_after) {
 206       hb_buffer_add_utf8 (buffer, text_after, -1, 0, 0);
 207     }
 208
 209     if (!utf8_clusters) {
 210       /* Reset cluster values to refer to Unicode character index
 211        * instead of UTF-8 index. */
 212       unsigned int num_glyphs = hb_buffer_get_length (buffer);
 213       hb_glyph_info_t *info = hb_buffer_get_glyph_infos (buffer, nullptr);
 214       for (unsigned int i = 0; i < num_glyphs; i++)
 215       {
 216         info->cluster = i;
 217         info++;
 218       }
 219     }
 220
 221     setup_buffer (buffer);
 222   }
 223
 224   hb_bool_t shape (hb_font_t *font, hb_buffer_t *buffer, const char **error=nullptr)
 225   {
 226     hb_buffer_t *text_buffer = nullptr;
 227     if (verify)
 228     {
 229       text_buffer = hb_buffer_create ();
 230       hb_buffer_append (text_buffer, buffer, 0, -1);
 231     }
 232
 233     if (!hb_shape_full (font, buffer, features, num_features, shapers))
 234     {
 235       if (error)
 236         *error = "all shapers failed.";
 237       goto fail;
 238     }
 239
 240     if (normalize_glyphs)
 241       hb_buffer_normalize_glyphs (buffer);
 242
 243     if (verify && !verify_buffer (buffer, text_buffer, font, error))
 244       goto fail;
 245
 246     if (text_buffer)
 247       hb_buffer_destroy (text_buffer);
 248
 249     return true;
 250
 251   fail:
 252     if (text_buffer)
 253       hb_buffer_destroy (text_buffer);
 254
 255     return false;
 256   }
 257
 258   bool verify_buffer (hb_buffer_t  *buffer,
 259                       hb_buffer_t  *text_buffer,
 260                       hb_font_t    *font,
 261                       const char  **error=nullptr)
 262   {
 263     if (!verify_buffer_monotone (buffer, error))
 264       return false;
 265     if (!verify_buffer_safe_to_break (buffer, text_buffer, font, error))
 266       return false;
 267     return true;
 268   }
 269
 270   bool verify_buffer_monotone (hb_buffer_t *buffer, const char **error=nullptr)
 271   {
 272     /* Check that clusters are monotone. */
 273     if (cluster_level == HB_BUFFER_CLUSTER_LEVEL_MONOTONE_GRAPHEMES ||
 274         cluster_level == HB_BUFFER_CLUSTER_LEVEL_MONOTONE_CHARACTERS)
 275     {
 276       bool is_forward = HB_DIRECTION_IS_FORWARD (hb_buffer_get_direction (buffer));
 277
 278       unsigned int num_glyphs;
 279       hb_glyph_info_t *info = hb_buffer_get_glyph_infos (buffer, &num_glyphs);
 280
 281       for (unsigned int i = 1; i < num_glyphs; i++)
 282         if (info[i-1].cluster != info[i].cluster &&
 283             (info[i-1].cluster < info[i].cluster) != is_forward)
 284         {
 285           if (error)
 286             *error = "clusters are not monotone.";
 287           return false;
 288         }
 289     }
 290
 291     return true;
 292   }
 293
 294   bool verify_buffer_safe_to_break (hb_buffer_t  *buffer,
 295                                     hb_buffer_t  *text_buffer,
 296                                     hb_font_t    *font,
 297                                     const char  **error=nullptr)
 298   {
 299     if (cluster_level != HB_BUFFER_CLUSTER_LEVEL_MONOTONE_GRAPHEMES &&
 300         cluster_level != HB_BUFFER_CLUSTER_LEVEL_MONOTONE_CHARACTERS)
 301     {
 302       /* Cannot perform this check without monotone clusters.
 303        * Then again, unsafe-to-break flag is much harder to use without
 304        * monotone clusters. */
 305       return true;
 306     }
 307
 308     /* Check that breaking up shaping at safe-to-break is indeed safe. */
 309
 310     hb_buffer_t *fragment = hb_buffer_create ();
 311     hb_buffer_t *reconstruction = hb_buffer_create ();
 312     copy_buffer_properties (reconstruction, buffer);
 313
 314     unsigned int num_glyphs;
 315     hb_glyph_info_t *info = hb_buffer_get_glyph_infos (buffer, &num_glyphs);
 316
 317     unsigned int num_chars;
 318     hb_glyph_info_t *text = hb_buffer_get_glyph_infos (text_buffer, &num_chars);
 319
 320     /* Chop text and shape fragments. */
 321     bool forward = HB_DIRECTION_IS_FORWARD (hb_buffer_get_direction (buffer));
 322     unsigned int start = 0;
 323     unsigned int text_start = forward ? 0 : num_chars;
 324     unsigned int text_end = text_start;
 325     for (unsigned int end = 1; end < num_glyphs + 1; end++)
 326     {
 327       if (end < num_glyphs &&
 328           (info[end].cluster == info[end-1].cluster ||
 329            info[end-(forward?0:1)].mask & HB_GLYPH_FLAG_UNSAFE_TO_BREAK))
 330           continue;
 331
 332       /* Shape segment corresponding to glyphs start..end. */
 333       if (end == num_glyphs)
 334       {
 335         if (forward)
 336           text_end = num_chars;
 337         else
 338           text_start = 0;
 339       }
 340       else
 341       {
 342         if (forward)
 343         {
 344           unsigned int cluster = info[end].cluster;
 345           while (text_end < num_chars && text[text_end].cluster < cluster)
 346             text_end++;
 347         }
 348         else
 349         {
 350           unsigned int cluster = info[end - 1].cluster;
 351           while (text_start && text[text_start - 1].cluster >= cluster)
 352             text_start--;
 353         }
 354       }
 355       assert (text_start < text_end);
 356
 357       if (0)
 358         printf("start %d end %d text start %d end %d\n", start, end, text_start, text_end);
 359
 360       hb_buffer_clear_contents (fragment);
 361       copy_buffer_properties (fragment, buffer);
 362
 363       /* TODO: Add pre/post context text. */
 364       hb_buffer_flags_t flags = hb_buffer_get_flags (fragment);
 365       if (0 < text_start)
 366         flags = (hb_buffer_flags_t) (flags & ~HB_BUFFER_FLAG_BOT);
 367       if (text_end < num_chars)
 368         flags = (hb_buffer_flags_t) (flags & ~HB_BUFFER_FLAG_EOT);
 369       hb_buffer_set_flags (fragment, flags);
 370
 371       hb_buffer_append (fragment, text_buffer, text_start, text_end);
 372       if (!hb_shape_full (font, fragment, features, num_features, shapers))
 373       {
 374         if (error)
 375           *error = "all shapers failed while shaping fragment.";
 376         hb_buffer_destroy (reconstruction);
 377         hb_buffer_destroy (fragment);
 378         return false;
 379       }
 380       hb_buffer_append (reconstruction, fragment, 0, -1);
 381
 382       start = end;
 383       if (forward)
 384         text_start = text_end;
 385       else
 386         text_end = text_start;
 387     }
 388
 389     bool ret = true;
 390     hb_buffer_diff_flags_t diff = hb_buffer_diff (reconstruction, buffer, (hb_codepoint_t) -1, 0);
 391     if (diff)
 392     {
 393       if (error)
 394         *error = "Safe-to-break test failed.";
 395       ret = false;
 396
 397       /* Return the reconstructed result instead so it can be inspected. */
 398       hb_buffer_set_length (buffer, 0);
 399       hb_buffer_append (buffer, reconstruction, 0, -1);
 400     }
 401
 402     hb_buffer_destroy (reconstruction);
 403     hb_buffer_destroy (fragment);
 404
 405     return ret;
 406   }
 407
 408   void shape_closure (const char *text, int text_len,
 409                       hb_font_t *font, hb_buffer_t *buffer,
 410                       hb_set_t *glyphs)
 411   {
 412     hb_buffer_reset (buffer);
 413     hb_buffer_add_utf8 (buffer, text, text_len, 0, text_len);
 414     setup_buffer (buffer);
 415     hb_ot_shape_glyphs_closure (font, buffer, features, num_features, glyphs);
 416   }
 417
 418   /* Buffer properties */
 419   char *direction;
 420   char *language;
 421   char *script;
 422
 423   /* Buffer flags */
 424   hb_bool_t bot;
 425   hb_bool_t eot;
 426   hb_bool_t preserve_default_ignorables;
 427   hb_bool_t remove_default_ignorables;
 428
 429   hb_feature_t *features;
 430   unsigned int num_features;
 431   char **shapers;
 432   hb_bool_t utf8_clusters;
 433   hb_buffer_cluster_level_t cluster_level;
 434   hb_bool_t normalize_glyphs;
 435   hb_bool_t verify;
 436   unsigned int num_iterations;
 437 };
 438
 439
 440 struct font_options_t : option_group_t
 441 {
 442   font_options_t (option_parser_t *parser,
 443                   int default_font_size_,
 444                   unsigned int subpixel_bits_)
 445   {
 446     variations = nullptr;
 447     num_variations = 0;
 448     default_font_size = default_font_size_;
 449     x_ppem = 0;
 450     y_ppem = 0;
 451     ptem = 0.;
 452     subpixel_bits = subpixel_bits_;
 453     font_file = nullptr;
 454     face_index = 0;
 455     font_size_x = font_size_y = default_font_size;
 456     font_funcs = nullptr;
 457
 458     font = nullptr;
 459
 460     add_options (parser);
 461   }
 462   ~font_options_t (void) {
 463     g_free (font_file);
 464     free (variations);
 465     g_free (font_funcs);
 466     hb_font_destroy (font);
 467   }
 468
 469   void add_options (option_parser_t *parser);
 470
 471   hb_font_t *get_font (void) const;
 472
 473   char *font_file;
 474   int face_index;
 475   hb_variation_t *variations;
 476   unsigned int num_variations;
 477   int default_font_size;
 478   int x_ppem;
 479   int y_ppem;
 480   double ptem;
 481   unsigned int subpixel_bits;
 482   mutable double font_size_x;
 483   mutable double font_size_y;
 484   char *font_funcs;
 485
 486   private:
 487   mutable hb_font_t *font;
 488 };
 489
 490
 491 struct text_options_t : option_group_t
 492 {
 493   text_options_t (option_parser_t *parser) {
 494     text_before = nullptr;
 495     text_after = nullptr;
 496
 497     text = nullptr;
 498     text_file = nullptr;
 499
 500     fp = nullptr;
 501     gs = nullptr;
 502     line = nullptr;
 503     line_len = (unsigned int) -1;
 504
 505     add_options (parser);
 506   }
 507   ~text_options_t (void) {
 508     g_free (text_before);
 509     g_free (text_after);
 510     g_free (text);
 511     g_free (text_file);
 512     if (gs)
 513       g_string_free (gs, true);
 514     if (fp)
 515       fclose (fp);
 516   }
 517
 518   void add_options (option_parser_t *parser);
 519
 520   void post_parse (GError **error G_GNUC_UNUSED) {
 521     if (text && text_file)
 522       g_set_error (error,
 523                    G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE,
 524                    "Only one of text and text-file can be set");
 525   };
 526
 527   const char *get_line (unsigned int *len);
 528
 529   char *text_before;
 530   char *text_after;
 531
 532   char *text;
 533   char *text_file;
 534
 535   private:
 536   FILE *fp;
 537   GString *gs;
 538   char *line;
 539   unsigned int line_len;
 540 };
 541
 542 struct output_options_t : option_group_t
 543 {
 544   output_options_t (option_parser_t *parser,
 545                     const char **supported_formats_ = nullptr) {
 546     output_file = nullptr;
 547     output_format = nullptr;
 548     supported_formats = supported_formats_;
 549     explicit_output_format = false;
 550
 551     fp = nullptr;
 552
 553     add_options (parser);
 554   }
 555   ~output_options_t (void) {
 556     g_free (output_file);
 557     g_free (output_format);
 558     if (fp)
 559       fclose (fp);
 560   }
 561
 562   void add_options (option_parser_t *parser);
 563
 564   void post_parse (GError **error G_GNUC_UNUSED)
 565   {
 566     if (output_format)
 567       explicit_output_format = true;
 568
 569     if (output_file && !output_format) {
 570       output_format = strrchr (output_file, '.');
 571       if (output_format)
 572       {
 573           output_format++; /* skip the dot */
 574           output_format = strdup (output_format);
 575       }
 576     }
 577
 578     if (output_file && 0 == strcmp (output_file, "-"))
 579       output_file = nullptr; /* STDOUT */
 580   }
 581
 582   FILE *get_file_handle (void);
 583
 584   char *output_file;
 585   char *output_format;
 586   const char **supported_formats;
 587   bool explicit_output_format;
 588
 589   mutable FILE *fp;
 590 };
 591
 592 struct format_options_t : option_group_t
 593 {
 594   format_options_t (option_parser_t *parser) {
 595     show_glyph_names = true;
 596     show_positions = true;
 597     show_advances = true;
 598     show_clusters = true;
 599     show_text = false;
 600     show_unicode = false;
 601     show_line_num = false;
 602     show_extents = false;
 603     show_flags = false;
 604     trace = false;
 605
 606     add_options (parser);
 607   }
 608
 609   void add_options (option_parser_t *parser);
 610
 611   void serialize_unicode (hb_buffer_t  *buffer,
 612                           GString      *gs);
 613   void serialize_glyphs (hb_buffer_t  *buffer,
 614                          hb_font_t    *font,
 615                          hb_buffer_serialize_format_t format,
 616                          hb_buffer_serialize_flags_t flags,
 617                          GString      *gs);
 618   void serialize_line_no (unsigned int  line_no,
 619                           GString      *gs);
 620   void serialize_buffer_of_text (hb_buffer_t  *buffer,
 621                                  unsigned int  line_no,
 622                                  const char   *text,
 623                                  unsigned int  text_len,
 624                                  hb_font_t    *font,
 625                                  GString      *gs);
 626   void serialize_message (unsigned int  line_no,
 627                           const char   *type,
 628                           const char   *msg,
 629                           GString      *gs);
 630   void serialize_buffer_of_glyphs (hb_buffer_t  *buffer,
 631                                    unsigned int  line_no,
 632                                    const char   *text,
 633                                    unsigned int  text_len,
 634                                    hb_font_t    *font,
 635                                    hb_buffer_serialize_format_t output_format,
 636                                    hb_buffer_serialize_flags_t format_flags,
 637                                    GString      *gs);
 638
 639
 640   hb_bool_t show_glyph_names;
 641   hb_bool_t show_positions;
 642   hb_bool_t show_advances;
 643   hb_bool_t show_clusters;
 644   hb_bool_t show_text;
 645   hb_bool_t show_unicode;
 646   hb_bool_t show_line_num;
 647   hb_bool_t show_extents;
 648   hb_bool_t show_flags;
 649   hb_bool_t trace;
 650 };
 651
 652 struct subset_options_t : option_group_t
 653 {
 654   subset_options_t (option_parser_t *parser)
 655   {
 656     drop_hints = false;
 657
 658     add_options (parser);
 659   }
 660
 661   void add_options (option_parser_t *parser);
 662
 663   hb_bool_t drop_hints;
 664 };
 665
 666 /* fallback implementation for scalbn()/scalbnf() for pre-2013 MSVC */
 667 #if defined (_MSC_VER) && (_MSC_VER < 1800)
 668
 669 #ifndef FLT_RADIX
 670 #define FLT_RADIX 2
 671 #endif
 672
 673 __inline long double scalbn (long double x, int exp)
 674 {
 675   return x * (pow ((long double) FLT_RADIX, exp));
 676 }
 677
 678 __inline float scalbnf (float x, int exp)
 679 {
 680   return x * (pow ((float) FLT_RADIX, exp));
 681 }
 682 #endif
 683
 684 #endif