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