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