util/options.cc

   1 /*
   2  * Copyright © 2011,2012  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 #include "options.hh"
  28
  29 #ifdef HAVE_FREETYPE
  30 #include <hb-ft.h>
  31 #endif
  32 #ifdef HAVE_OT
  33 #include <hb-ot.h>
  34 #endif
  35
  36 struct supported_font_funcs_t {
  37         char name[4];
  38         void (*func) (hb_font_t *);
  39 } supported_font_funcs[] =
  40 {
  41 #ifdef HAVE_FREETYPE
  42   {"ft",        hb_ft_font_set_funcs},
  43 #endif
  44 #ifdef HAVE_OT
  45   {"ot",        hb_ot_font_set_funcs},
  46 #endif
  47 };
  48
  49
  50 void
  51 fail (hb_bool_t suggest_help, const char *format, ...)
  52 {
  53   const char *msg;
  54
  55   va_list vap;
  56   va_start (vap, format);
  57   msg = g_strdup_vprintf (format, vap);
  58   va_end (vap);
  59   const char *prgname = g_get_prgname ();
  60   g_printerr ("%s: %s\n", prgname, msg);
  61   if (suggest_help)
  62     g_printerr ("Try `%s --help' for more information.\n", prgname);
  63
  64   exit (1);
  65 }
  66
  67
  68 hb_bool_t debug = false;
  69
  70 static gchar *
  71 shapers_to_string (void)
  72 {
  73   GString *shapers = g_string_new (nullptr);
  74   const char **shaper_list = hb_shape_list_shapers ();
  75
  76   for (; *shaper_list; shaper_list++) {
  77     g_string_append (shapers, *shaper_list);
  78     g_string_append_c (shapers, ',');
  79   }
  80   g_string_truncate (shapers, MAX (0, (gint)shapers->len - 1));
  81
  82   return g_string_free (shapers, false);
  83 }
  84
  85 static G_GNUC_NORETURN gboolean
  86 show_version (const char *name G_GNUC_UNUSED,
  87               const char *arg G_GNUC_UNUSED,
  88               gpointer    data G_GNUC_UNUSED,
  89               GError    **error G_GNUC_UNUSED)
  90 {
  91   g_printf ("%s (%s) %s\n", g_get_prgname (), PACKAGE_NAME, PACKAGE_VERSION);
  92
  93   char *shapers = shapers_to_string ();
  94   g_printf ("Available shapers: %s\n", shapers);
  95   g_free (shapers);
  96   if (strcmp (HB_VERSION_STRING, hb_version_string ()))
  97     g_printf ("Linked HarfBuzz library has a different version: %s\n", hb_version_string ());
  98
  99   exit(0);
 100 }
 101
 102
 103 void
 104 option_parser_t::add_main_options (void)
 105 {
 106   GOptionEntry entries[] =
 107   {
 108     {"version",         0, G_OPTION_FLAG_NO_ARG,
 109                               G_OPTION_ARG_CALLBACK,    (gpointer) &show_version,       "Show version numbers",                 nullptr},
 110     {"debug",           0, 0, G_OPTION_ARG_NONE,        &debug,                         "Free all resources before exit",       nullptr},
 111     {nullptr}
 112   };
 113   g_option_context_add_main_entries (context, entries, nullptr);
 114 }
 115
 116 static gboolean
 117 pre_parse (GOptionContext *context G_GNUC_UNUSED,
 118            GOptionGroup *group G_GNUC_UNUSED,
 119            gpointer data,
 120            GError **error)
 121 {
 122   option_group_t *option_group = (option_group_t *) data;
 123   option_group->pre_parse (error);
 124   return *error == nullptr;
 125 }
 126
 127 static gboolean
 128 post_parse (GOptionContext *context G_GNUC_UNUSED,
 129             GOptionGroup *group G_GNUC_UNUSED,
 130             gpointer data,
 131             GError **error)
 132 {
 133   option_group_t *option_group = static_cast<option_group_t *>(data);
 134   option_group->post_parse (error);
 135   return *error == nullptr;
 136 }
 137
 138 void
 139 option_parser_t::add_group (GOptionEntry   *entries,
 140                             const gchar    *name,
 141                             const gchar    *description,
 142                             const gchar    *help_description,
 143                             option_group_t *option_group)
 144 {
 145   GOptionGroup *group = g_option_group_new (name, description, help_description,
 146                                             static_cast<gpointer>(option_group), nullptr);
 147   g_option_group_add_entries (group, entries);
 148   g_option_group_set_parse_hooks (group, pre_parse, post_parse);
 149   g_option_context_add_group (context, group);
 150 }
 151
 152 void
 153 option_parser_t::parse (int *argc, char ***argv)
 154 {
 155   setlocale (LC_ALL, "");
 156
 157   GError *parse_error = nullptr;
 158   if (!g_option_context_parse (context, argc, argv, &parse_error))
 159   {
 160     if (parse_error != nullptr) {
 161       fail (true, "%s", parse_error->message);
 162       //g_error_free (parse_error);
 163     } else
 164       fail (true, "Option parse error");
 165   }
 166 }
 167
 168
 169 static gboolean
 170 parse_margin (const char *name G_GNUC_UNUSED,
 171               const char *arg,
 172               gpointer    data,
 173               GError    **error G_GNUC_UNUSED)
 174 {
 175   view_options_t *view_opts = (view_options_t *) data;
 176   view_options_t::margin_t &m = view_opts->margin;
 177   switch (sscanf (arg, "%lf%*[ ,]%lf%*[ ,]%lf%*[ ,]%lf", &m.t, &m.r, &m.b, &m.l)) {
 178     case 1: m.r = m.t;
 179     case 2: m.b = m.t;
 180     case 3: m.l = m.r;
 181     case 4: return true;
 182     default:
 183       g_set_error (error, G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE,
 184                    "%s argument should be one to four space-separated numbers",
 185                    name);
 186       return false;
 187   }
 188 }
 189
 190
 191 static gboolean
 192 parse_shapers (const char *name G_GNUC_UNUSED,
 193                const char *arg,
 194                gpointer    data,
 195                GError    **error G_GNUC_UNUSED)
 196 {
 197   shape_options_t *shape_opts = (shape_options_t *) data;
 198   g_strfreev (shape_opts->shapers);
 199   shape_opts->shapers = g_strsplit (arg, ",", 0);
 200   return true;
 201 }
 202
 203 static G_GNUC_NORETURN gboolean
 204 list_shapers (const char *name G_GNUC_UNUSED,
 205               const char *arg G_GNUC_UNUSED,
 206               gpointer    data G_GNUC_UNUSED,
 207               GError    **error G_GNUC_UNUSED)
 208 {
 209   for (const char **shaper = hb_shape_list_shapers (); *shaper; shaper++)
 210     g_printf ("%s\n", *shaper);
 211
 212   exit(0);
 213 }
 214
 215
 216 static gboolean
 217 parse_features (const char *name G_GNUC_UNUSED,
 218                 const char *arg,
 219                 gpointer    data,
 220                 GError    **error G_GNUC_UNUSED)
 221 {
 222   shape_options_t *shape_opts = (shape_options_t *) data;
 223   char *s = (char *) arg;
 224   char *p;
 225
 226   shape_opts->num_features = 0;
 227   g_free (shape_opts->features);
 228   shape_opts->features = nullptr;
 229
 230   if (!*s)
 231     return true;
 232
 233   /* count the features first, so we can allocate memory */
 234   p = s;
 235   do {
 236     shape_opts->num_features++;
 237     p = strchr (p, ',');
 238     if (p)
 239       p++;
 240   } while (p);
 241
 242   shape_opts->features = (hb_feature_t *) calloc (shape_opts->num_features, sizeof (*shape_opts->features));
 243   if (!shape_opts->features)
 244     return false;
 245
 246   /* now do the actual parsing */
 247   p = s;
 248   shape_opts->num_features = 0;
 249   while (p && *p) {
 250     char *end = strchr (p, ',');
 251     if (hb_feature_from_string (p, end ? end - p : -1, &shape_opts->features[shape_opts->num_features]))
 252       shape_opts->num_features++;
 253     p = end ? end + 1 : nullptr;
 254   }
 255
 256   return true;
 257 }
 258
 259 static gboolean
 260 parse_variations (const char *name G_GNUC_UNUSED,
 261                 const char *arg,
 262                 gpointer    data,
 263                 GError    **error G_GNUC_UNUSED)
 264 {
 265   font_options_t *font_opts = (font_options_t *) data;
 266   char *s = (char *) arg;
 267   char *p;
 268
 269   font_opts->num_variations = 0;
 270   g_free (font_opts->variations);
 271   font_opts->variations = nullptr;
 272
 273   if (!*s)
 274     return true;
 275
 276   /* count the variations first, so we can allocate memory */
 277   p = s;
 278   do {
 279     font_opts->num_variations++;
 280     p = strchr (p, ',');
 281     if (p)
 282       p++;
 283   } while (p);
 284
 285   font_opts->variations = (hb_variation_t *) calloc (font_opts->num_variations, sizeof (*font_opts->variations));
 286   if (!font_opts->variations)
 287     return false;
 288
 289   /* now do the actual parsing */
 290   p = s;
 291   font_opts->num_variations = 0;
 292   while (p && *p) {
 293     char *end = strchr (p, ',');
 294     if (hb_variation_from_string (p, end ? end - p : -1, &font_opts->variations[font_opts->num_variations]))
 295       font_opts->num_variations++;
 296     p = end ? end + 1 : nullptr;
 297   }
 298
 299   return true;
 300 }
 301
 302 static gboolean
 303 parse_text (const char *name G_GNUC_UNUSED,
 304             const char *arg,
 305             gpointer    data,
 306             GError    **error G_GNUC_UNUSED)
 307 {
 308   text_options_t *text_opts = (text_options_t *) data;
 309
 310   if (text_opts->text)
 311   {
 312     g_set_error (error, G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE,
 313                  "Either --text or --unicodes can be provided but not both");
 314     return false;
 315   }
 316
 317   text_opts->text = g_strdup (arg);
 318   return true;
 319 }
 320
 321
 322 static gboolean
 323 parse_unicodes (const char *name G_GNUC_UNUSED,
 324                 const char *arg,
 325                 gpointer    data,
 326                 GError    **error G_GNUC_UNUSED)
 327 {
 328   text_options_t *text_opts = (text_options_t *) data;
 329
 330   if (text_opts->text)
 331   {
 332     g_set_error (error, G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE,
 333                  "Either --text or --unicodes can be provided but not both");
 334     return false;
 335   }
 336
 337   GString *gs = g_string_new (nullptr);
 338   char *s = (char *) arg;
 339   char *p;
 340
 341   while (s && *s)
 342   {
 343     while (*s && strchr ("<+>{},;&#\\xXuUnNiI\n\t", *s))
 344       s++;
 345
 346     errno = 0;
 347     hb_codepoint_t u = strtoul (s, &p, 16);
 348     if (errno || s == p)
 349     {
 350       g_set_error (error, G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE,
 351                    "Failed parsing Unicode values at: '%s'", s);
 352       return false;
 353     }
 354
 355     g_string_append_unichar (gs, u);
 356
 357     s = p;
 358   }
 359
 360   text_opts->text = g_string_free (gs, FALSE);
 361   return true;
 362 }
 363
 364
 365 void
 366 view_options_t::add_options (option_parser_t *parser)
 367 {
 368   GOptionEntry entries[] =
 369   {
 370     {"annotate",        0, 0, G_OPTION_ARG_NONE,        &this->annotate,                "Annotate output rendering",                            nullptr},
 371     {"background",      0, 0, G_OPTION_ARG_STRING,      &this->back,                    "Set background color (default: " DEFAULT_BACK ")",     "rrggbb/rrggbbaa"},
 372     {"foreground",      0, 0, G_OPTION_ARG_STRING,      &this->fore,                    "Set foreground color (default: " DEFAULT_FORE ")",     "rrggbb/rrggbbaa"},
 373     {"line-space",      0, 0, G_OPTION_ARG_DOUBLE,      &this->line_space,              "Set space between lines (default: 0)",                 "units"},
 374     {"margin",          0, 0, G_OPTION_ARG_CALLBACK,    (gpointer) &parse_margin,       "Margin around output (default: " G_STRINGIFY(DEFAULT_MARGIN) ")","one to four numbers"},
 375     {nullptr}
 376   };
 377   parser->add_group (entries,
 378                      "view",
 379                      "View options:",
 380                      "Options for output rendering",
 381                      this);
 382 }
 383
 384 void
 385 shape_options_t::add_options (option_parser_t *parser)
 386 {
 387   GOptionEntry entries[] =
 388   {
 389     {"list-shapers",    0, G_OPTION_FLAG_NO_ARG,
 390                               G_OPTION_ARG_CALLBACK,    (gpointer) &list_shapers,       "List available shapers and quit",      nullptr},
 391     {"shaper",          0, G_OPTION_FLAG_HIDDEN,
 392                               G_OPTION_ARG_CALLBACK,    (gpointer) &parse_shapers,      "Hidden duplicate of --shapers",        nullptr},
 393     {"shapers",         0, 0, G_OPTION_ARG_CALLBACK,    (gpointer) &parse_shapers,      "Set comma-separated list of shapers to try","list"},
 394     {"direction",       0, 0, G_OPTION_ARG_STRING,      &this->direction,               "Set text direction (default: auto)",   "ltr/rtl/ttb/btt"},
 395     {"language",        0, 0, G_OPTION_ARG_STRING,      &this->language,                "Set text language (default: $LANG)",   "langstr"},
 396     {"script",          0, 0, G_OPTION_ARG_STRING,      &this->script,                  "Set text script (default: auto)",      "ISO-15924 tag"},
 397     {"bot",             0, 0, G_OPTION_ARG_NONE,        &this->bot,                     "Treat text as beginning-of-paragraph", nullptr},
 398     {"eot",             0, 0, G_OPTION_ARG_NONE,        &this->eot,                     "Treat text as end-of-paragraph",       nullptr},
 399     {"preserve-default-ignorables",0, 0, G_OPTION_ARG_NONE,     &this->preserve_default_ignorables,     "Preserve Default-Ignorable characters",        nullptr},
 400     {"remove-default-ignorables",0, 0, G_OPTION_ARG_NONE,       &this->remove_default_ignorables,       "Remove Default-Ignorable characters",  nullptr},
 401     {"utf8-clusters",   0, 0, G_OPTION_ARG_NONE,        &this->utf8_clusters,           "Use UTF8 byte indices, not char indices",      nullptr},
 402     {"cluster-level",   0, 0, G_OPTION_ARG_INT,         &this->cluster_level,           "Cluster merging level (default: 0)",   "0/1/2"},
 403     {"normalize-glyphs",0, 0, G_OPTION_ARG_NONE,        &this->normalize_glyphs,        "Rearrange glyph clusters in nominal order",    nullptr},
 404     {"verify",          0, 0, G_OPTION_ARG_NONE,        &this->verify,                  "Perform sanity checks on shaping results",     nullptr},
 405     {"num-iterations",  0, 0, G_OPTION_ARG_INT,         &this->num_iterations,          "Run shaper N times (default: 1)",      "N"},
 406     {nullptr}
 407   };
 408   parser->add_group (entries,
 409                      "shape",
 410                      "Shape options:",
 411                      "Options for the shaping process",
 412                      this);
 413
 414   const gchar *features_help = "Comma-separated list of font features\n"
 415     "\n"
 416     "    Features can be enabled or disabled, either globally or limited to\n"
 417     "    specific character ranges.  The format for specifying feature settings\n"
 418     "    follows.  All valid CSS font-feature-settings values other than 'normal'\n"
 419     "    and 'inherited' are also accepted, though, not documented below.\n"
 420     "\n"
 421     "    The range indices refer to the positions between Unicode characters,\n"
 422     "    unless the --utf8-clusters is provided, in which case range indices\n"
 423     "    refer to UTF-8 byte indices. The position before the first character\n"
 424     "    is always 0.\n"
 425     "\n"
 426     "    The format is Python-esque.  Here is how it all works:\n"
 427     "\n"
 428     "      Syntax:       Value:    Start:    End:\n"
 429     "\n"
 430     "    Setting value:\n"
 431     "      \"kern\"        1         0         ∞         # Turn feature on\n"
 432     "      \"+kern\"       1         0         ∞         # Turn feature on\n"
 433     "      \"-kern\"       0         0         ∞         # Turn feature off\n"
 434     "      \"kern=0\"      0         0         ∞         # Turn feature off\n"
 435     "      \"kern=1\"      1         0         ∞         # Turn feature on\n"
 436     "      \"aalt=2\"      2         0         ∞         # Choose 2nd alternate\n"
 437     "\n"
 438     "    Setting index:\n"
 439     "      \"kern[]\"      1         0         ∞         # Turn feature on\n"
 440     "      \"kern[:]\"     1         0         ∞         # Turn feature on\n"
 441     "      \"kern[5:]\"    1         5         ∞         # Turn feature on, partial\n"
 442     "      \"kern[:5]\"    1         0         5         # Turn feature on, partial\n"
 443     "      \"kern[3:5]\"   1         3         5         # Turn feature on, range\n"
 444     "      \"kern[3]\"     1         3         3+1       # Turn feature on, single char\n"
 445     "\n"
 446     "    Mixing it all:\n"
 447     "\n"
 448     "      \"aalt[3:5]=2\" 2         3         5         # Turn 2nd alternate on for range";
 449
 450   GOptionEntry entries2[] =
 451   {
 452     {"features",        0, 0, G_OPTION_ARG_CALLBACK,    (gpointer) &parse_features,     features_help,  "list"},
 453     {nullptr}
 454   };
 455   parser->add_group (entries2,
 456                      "features",
 457                      "Features options:",
 458                      "Options for font features used",
 459                      this);
 460 }
 461
 462 static gboolean
 463 parse_font_size (const char *name G_GNUC_UNUSED,
 464                  const char *arg,
 465                  gpointer    data,
 466                  GError    **error G_GNUC_UNUSED)
 467 {
 468   font_options_t *font_opts = (font_options_t *) data;
 469   if (0 == strcmp (arg, "upem"))
 470   {
 471     font_opts->font_size_y = font_opts->font_size_x = FONT_SIZE_UPEM;
 472     return true;
 473   }
 474   switch (sscanf (arg, "%lf%*[ ,]%lf", &font_opts->font_size_x, &font_opts->font_size_y)) {
 475     case 1: font_opts->font_size_y = font_opts->font_size_x;
 476     case 2: return true;
 477     default:
 478       g_set_error (error, G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE,
 479                    "%s argument should be one or two space-separated numbers",
 480                    name);
 481       return false;
 482   }
 483 }
 484
 485 static gboolean
 486 parse_font_ppem (const char *name G_GNUC_UNUSED,
 487                  const char *arg,
 488                  gpointer    data,
 489                  GError    **error G_GNUC_UNUSED)
 490 {
 491   font_options_t *font_opts = (font_options_t *) data;
 492   switch (sscanf (arg, "%d%*[ ,]%d", &font_opts->x_ppem, &font_opts->y_ppem)) {
 493     case 1: font_opts->y_ppem = font_opts->x_ppem;
 494     case 2: return true;
 495     default:
 496       g_set_error (error, G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE,
 497                    "%s argument should be one or two space-separated numbers",
 498                    name);
 499       return false;
 500   }
 501 }
 502
 503 void
 504 font_options_t::add_options (option_parser_t *parser)
 505 {
 506   char *text = nullptr;
 507
 508   {
 509     static_assert ((ARRAY_LENGTH_CONST (supported_font_funcs) > 0),
 510                    "No supported font-funcs found.");
 511     GString *s = g_string_new (nullptr);
 512     g_string_printf (s, "Set font functions implementation to use (default: %s)\n\n    Supported font function implementations are: %s",
 513                      supported_font_funcs[0].name,
 514                      supported_font_funcs[0].name);
 515     for (unsigned int i = 1; i < ARRAY_LENGTH (supported_font_funcs); i++)
 516     {
 517       g_string_append_c (s, '/');
 518       g_string_append (s, supported_font_funcs[i].name);
 519     }
 520     text = g_string_free (s, FALSE);
 521     parser->free_later (text);
 522   }
 523
 524   char *font_size_text;
 525   if (default_font_size == FONT_SIZE_UPEM)
 526     font_size_text = (char *) "Font size (default: upem)";
 527   else
 528   {
 529     font_size_text = g_strdup_printf ("Font size (default: %d)", default_font_size);
 530     parser->free_later (font_size_text);
 531   }
 532
 533   GOptionEntry entries[] =
 534   {
 535     {"font-file",       0, 0, G_OPTION_ARG_STRING,      &this->font_file,               "Set font file-name",                           "filename"},
 536     {"face-index",      0, 0, G_OPTION_ARG_INT,         &this->face_index,              "Set face index (default: 0)",                  "index"},
 537     {"font-size",       0, default_font_size ? 0 : G_OPTION_FLAG_HIDDEN,
 538                               G_OPTION_ARG_CALLBACK,    (gpointer) &parse_font_size,    font_size_text,                                 "1/2 integers or 'upem'"},
 539     {"font-ppem",       0, 0, G_OPTION_ARG_CALLBACK,    (gpointer) &parse_font_ppem,    "Set x,y pixels per EM (default: 0; disabled)", "1/2 integers"},
 540     {"font-ptem",       0, 0, G_OPTION_ARG_DOUBLE,      &this->ptem,                    "Set font point-size (default: 0; disabled)",   "point-size"},
 541     {"font-funcs",      0, 0, G_OPTION_ARG_STRING,      &this->font_funcs,              text,                                           "impl"},
 542     {nullptr}
 543   };
 544   parser->add_group (entries,
 545                      "font",
 546                      "Font options:",
 547                      "Options for the font",
 548                      this);
 549
 550   const gchar *variations_help = "Comma-separated list of font variations\n"
 551     "\n"
 552     "    Variations are set globally. The format for specifying variation settings\n"
 553     "    follows.  All valid CSS font-variation-settings values other than 'normal'\n"
 554     "    and 'inherited' are also accepted, though, not documented below.\n"
 555     "\n"
 556     "    The format is a tag, optionally followed by an equals sign, followed by a\n"
 557     "    number. For example:\n"
 558     "\n"
 559     "      \"wght=500\"\n"
 560     "      \"slnt=-7.5\"\n";
 561
 562   GOptionEntry entries2[] =
 563   {
 564     {"variations",      0, 0, G_OPTION_ARG_CALLBACK,    (gpointer) &parse_variations,   variations_help,        "list"},
 565     {nullptr}
 566   };
 567   parser->add_group (entries2,
 568                      "variations",
 569                      "Variations options:",
 570                      "Options for font variations used",
 571                      this);
 572 }
 573
 574 void
 575 text_options_t::add_options (option_parser_t *parser)
 576 {
 577   GOptionEntry entries[] =
 578   {
 579     {"text",            0, 0, G_OPTION_ARG_CALLBACK,    (gpointer) &parse_text,         "Set input text",                       "string"},
 580     {"text-file",       0, 0, G_OPTION_ARG_STRING,      &this->text_file,               "Set input text file-name\n\n    If no text is provided, standard input is used for input.\n",          "filename"},
 581     {"unicodes",      'u', 0, G_OPTION_ARG_CALLBACK,    (gpointer) &parse_unicodes,             "Set input Unicode codepoints",         "list of hex numbers"},
 582     {"text-before",     0, 0, G_OPTION_ARG_STRING,      &this->text_before,             "Set text context before each line",    "string"},
 583     {"text-after",      0, 0, G_OPTION_ARG_STRING,      &this->text_after,              "Set text context after each line",     "string"},
 584     {nullptr}
 585   };
 586   parser->add_group (entries,
 587                      "text",
 588                      "Text options:",
 589                      "Options for the input text",
 590                      this);
 591 }
 592
 593 void
 594 output_options_t::add_options (option_parser_t *parser)
 595 {
 596   const char *text;
 597
 598   if (nullptr == supported_formats)
 599     text = "Set output serialization format";
 600   else
 601   {
 602     char *items = g_strjoinv ("/", const_cast<char **> (supported_formats));
 603     text = g_strdup_printf ("Set output format\n\n    Supported output formats are: %s", items);
 604     g_free (items);
 605     parser->free_later ((char *) text);
 606   }
 607
 608   GOptionEntry entries[] =
 609   {
 610     {"output-file",   'o', 0, G_OPTION_ARG_STRING,      &this->output_file,             "Set output file-name (default: stdout)","filename"},
 611     {"output-format", 'O', 0, G_OPTION_ARG_STRING,      &this->output_format,           text,                                   "format"},
 612     {nullptr}
 613   };
 614   parser->add_group (entries,
 615                      "output",
 616                      "Output destination & format options:",
 617                      "Options for the destination & form of the output",
 618                      this);
 619 }
 620
 621
 622
 623 hb_font_t *
 624 font_options_t::get_font (void) const
 625 {
 626   if (font)
 627     return font;
 628
 629   hb_blob_t *blob = nullptr;
 630
 631   /* Create the blob */
 632   {
 633     char *font_data;
 634     unsigned int len = 0;
 635     hb_destroy_func_t destroy;
 636     void *user_data;
 637     hb_memory_mode_t mm;
 638
 639     /* This is a hell of a lot of code for just reading a file! */
 640     if (!font_file)
 641       fail (true, "No font file set");
 642
 643     if (0 == strcmp (font_file, "-")) {
 644       /* read it */
 645       GString *gs = g_string_new (nullptr);
 646       char buf[BUFSIZ];
 647 #if defined(_WIN32) || defined(__CYGWIN__)
 648       setmode (fileno (stdin), O_BINARY);
 649 #endif
 650       while (!feof (stdin)) {
 651         size_t ret = fread (buf, 1, sizeof (buf), stdin);
 652         if (ferror (stdin))
 653           fail (false, "Failed reading font from standard input: %s",
 654                 strerror (errno));
 655         g_string_append_len (gs, buf, ret);
 656       }
 657       len = gs->len;
 658       font_data = g_string_free (gs, false);
 659       user_data = font_data;
 660       destroy = (hb_destroy_func_t) g_free;
 661       mm = HB_MEMORY_MODE_WRITABLE;
 662     } else {
 663       GError *error = nullptr;
 664       GMappedFile *mf = g_mapped_file_new (font_file, false, &error);
 665       if (mf) {
 666         font_data = g_mapped_file_get_contents (mf);
 667         len = g_mapped_file_get_length (mf);
 668         if (len) {
 669           destroy = (hb_destroy_func_t) g_mapped_file_unref;
 670           user_data = (void *) mf;
 671           mm = HB_MEMORY_MODE_READONLY_MAY_MAKE_WRITABLE;
 672         } else
 673           g_mapped_file_unref (mf);
 674       } else {
 675         fail (false, "%s", error->message);
 676         //g_error_free (error);
 677       }
 678       if (!len) {
 679         /* GMappedFile is buggy, it doesn't fail if file isn't regular.
 680          * Try reading.
 681          * https://bugzilla.gnome.org/show_bug.cgi?id=659212 */
 682         GError *error = nullptr;
 683         gsize l;
 684         if (g_file_get_contents (font_file, &font_data, &l, &error)) {
 685           len = l;
 686           destroy = (hb_destroy_func_t) g_free;
 687           user_data = (void *) font_data;
 688           mm = HB_MEMORY_MODE_WRITABLE;
 689         } else {
 690           fail (false, "%s", error->message);
 691           //g_error_free (error);
 692         }
 693       }
 694     }
 695
 696     if (debug)
 697       mm = HB_MEMORY_MODE_DUPLICATE;
 698
 699     blob = hb_blob_create (font_data, len, mm, user_data, destroy);
 700   }
 701
 702   /* Create the face */
 703   hb_face_t *face = hb_face_create (blob, face_index);
 704   hb_blob_destroy (blob);
 705
 706
 707   font = hb_font_create (face);
 708
 709   if (font_size_x == FONT_SIZE_UPEM)
 710     font_size_x = hb_face_get_upem (face);
 711   if (font_size_y == FONT_SIZE_UPEM)
 712     font_size_y = hb_face_get_upem (face);
 713
 714   hb_font_set_ppem (font, x_ppem, y_ppem);
 715   hb_font_set_ptem (font, ptem);
 716
 717   int scale_x = (int) scalbnf (font_size_x, subpixel_bits);
 718   int scale_y = (int) scalbnf (font_size_y, subpixel_bits);
 719   hb_font_set_scale (font, scale_x, scale_y);
 720   hb_face_destroy (face);
 721
 722   hb_font_set_variations (font, variations, num_variations);
 723
 724   void (*set_font_funcs) (hb_font_t *) = nullptr;
 725   if (!font_funcs)
 726   {
 727     set_font_funcs = supported_font_funcs[0].func;
 728   }
 729   else
 730   {
 731     for (unsigned int i = 0; i < ARRAY_LENGTH (supported_font_funcs); i++)
 732       if (0 == g_ascii_strcasecmp (font_funcs, supported_font_funcs[i].name))
 733       {
 734         set_font_funcs = supported_font_funcs[i].func;
 735         break;
 736       }
 737     if (!set_font_funcs)
 738     {
 739       GString *s = g_string_new (nullptr);
 740       for (unsigned int i = 0; i < ARRAY_LENGTH (supported_font_funcs); i++)
 741       {
 742         if (i)
 743           g_string_append_c (s, '/');
 744         g_string_append (s, supported_font_funcs[i].name);
 745       }
 746       char *p = g_string_free (s, FALSE);
 747       fail (false, "Unknown font function implementation `%s'; supported values are: %s; default is %s",
 748             font_funcs,
 749             p,
 750             supported_font_funcs[0].name);
 751       //free (p);
 752     }
 753   }
 754   set_font_funcs (font);
 755
 756   return font;
 757 }
 758
 759
 760 const char *
 761 text_options_t::get_line (unsigned int *len)
 762 {
 763   if (text) {
 764     if (!line) line = text;
 765     if (line_len == (unsigned int) -1)
 766       line_len = strlen (line);
 767
 768     if (!line_len) {
 769       *len = 0;
 770       return nullptr;
 771     }
 772
 773     const char *ret = line;
 774     const char *p = (const char *) memchr (line, '\n', line_len);
 775     unsigned int ret_len;
 776     if (!p) {
 777       ret_len = line_len;
 778       line += ret_len;
 779       line_len = 0;
 780     } else {
 781       ret_len = p - ret;
 782       line += ret_len + 1;
 783       line_len -= ret_len + 1;
 784     }
 785
 786     *len = ret_len;
 787     return ret;
 788   }
 789
 790   if (!fp) {
 791     if (!text_file)
 792       fail (true, "At least one of text or text-file must be set");
 793
 794     if (0 != strcmp (text_file, "-"))
 795       fp = fopen (text_file, "r");
 796     else
 797       fp = stdin;
 798
 799     if (!fp)
 800       fail (false, "Failed opening text file `%s': %s",
 801             text_file, strerror (errno));
 802
 803     gs = g_string_new (nullptr);
 804   }
 805
 806 #ifdef HAVE_SETLINEBUF
 807   setlinebuf (fp);
 808 #else
 809   setvbuf(fp, NULL, _IOLBF, BUFSIZ);
 810 #endif
 811
 812   g_string_set_size (gs, 0);
 813   char buf[BUFSIZ];
 814   while (fgets (buf, sizeof (buf), fp)) {
 815     unsigned int bytes = strlen (buf);
 816     if (bytes && buf[bytes - 1] == '\n') {
 817       bytes--;
 818       g_string_append_len (gs, buf, bytes);
 819       break;
 820     }
 821       g_string_append_len (gs, buf, bytes);
 822   }
 823   if (ferror (fp))
 824     fail (false, "Failed reading text: %s",
 825           strerror (errno));
 826   *len = gs->len;
 827   return !*len && feof (fp) ? nullptr : gs->str;
 828 }
 829
 830
 831 FILE *
 832 output_options_t::get_file_handle (void)
 833 {
 834   if (fp)
 835     return fp;
 836
 837   if (output_file)
 838     fp = fopen (output_file, "wb");
 839   else {
 840 #if defined(_WIN32) || defined(__CYGWIN__)
 841     setmode (fileno (stdout), O_BINARY);
 842 #endif
 843     fp = stdout;
 844   }
 845   if (!fp)
 846     fail (false, "Cannot open output file `%s': %s",
 847           g_filename_display_name (output_file), strerror (errno));
 848
 849 #ifdef HAVE_SETLINEBUF
 850   setlinebuf (fp);
 851 #else
 852   setvbuf(fp, NULL, _IOLBF, BUFSIZ);
 853 #endif
 854
 855   return fp;
 856 }
 857
 858 static gboolean
 859 parse_verbose (const char *name G_GNUC_UNUSED,
 860                const char *arg G_GNUC_UNUSED,
 861                gpointer    data G_GNUC_UNUSED,
 862                GError    **error G_GNUC_UNUSED)
 863 {
 864   format_options_t *format_opts = (format_options_t *) data;
 865   format_opts->show_text = format_opts->show_unicode = format_opts->show_line_num = true;
 866   return true;
 867 }
 868
 869 static gboolean
 870 parse_ned (const char *name G_GNUC_UNUSED,
 871            const char *arg G_GNUC_UNUSED,
 872            gpointer    data G_GNUC_UNUSED,
 873            GError    **error G_GNUC_UNUSED)
 874 {
 875   format_options_t *format_opts = (format_options_t *) data;
 876   format_opts->show_clusters = format_opts->show_advances = false;
 877   return true;
 878 }
 879
 880 void
 881 format_options_t::add_options (option_parser_t *parser)
 882 {
 883   GOptionEntry entries[] =
 884   {
 885     {"show-text",       0, 0, G_OPTION_ARG_NONE,        &this->show_text,               "Prefix each line of output with its corresponding input text",         nullptr},
 886     {"show-unicode",    0, 0, G_OPTION_ARG_NONE,        &this->show_unicode,            "Prefix each line of output with its corresponding input codepoint(s)", nullptr},
 887     {"show-line-num",   0, 0, G_OPTION_ARG_NONE,        &this->show_line_num,           "Prefix each line of output with its corresponding input line number",  nullptr},
 888     {"verbose",       'v', G_OPTION_FLAG_NO_ARG,
 889                               G_OPTION_ARG_CALLBACK,    (gpointer) &parse_verbose,      "Prefix each line of output with all of the above",                     nullptr},
 890     {"no-glyph-names",  0, G_OPTION_FLAG_REVERSE,
 891                               G_OPTION_ARG_NONE,        &this->show_glyph_names,        "Output glyph indices instead of names",                                nullptr},
 892     {"no-positions",    0, G_OPTION_FLAG_REVERSE,
 893                               G_OPTION_ARG_NONE,        &this->show_positions,          "Do not output glyph positions",                                        nullptr},
 894     {"no-advances",     0, G_OPTION_FLAG_REVERSE,
 895                               G_OPTION_ARG_NONE,        &this->show_advances,           "Do not output glyph advances",                                         nullptr},
 896     {"no-clusters",     0, G_OPTION_FLAG_REVERSE,
 897                               G_OPTION_ARG_NONE,        &this->show_clusters,           "Do not output cluster indices",                                        nullptr},
 898     {"show-extents",    0, 0, G_OPTION_ARG_NONE,        &this->show_extents,            "Output glyph extents",                                                 nullptr},
 899     {"show-flags",      0, 0, G_OPTION_ARG_NONE,        &this->show_flags,              "Output glyph flags",                                                   nullptr},
 900     {"ned",           'v', G_OPTION_FLAG_NO_ARG,
 901                               G_OPTION_ARG_CALLBACK,    (gpointer) &parse_ned,          "No Extra Data; Do not output clusters or advances",                    nullptr},
 902     {"trace",         'V', 0, G_OPTION_ARG_NONE,        &this->trace,                   "Output interim shaping results",                                       nullptr},
 903     {nullptr}
 904   };
 905   parser->add_group (entries,
 906                      "output-syntax",
 907                      "Output syntax:\n"
 908          "    text: [<glyph name or index>=<glyph cluster index within input>@<horizontal displacement>,<vertical displacement>+<horizontal advance>,<vertical advance>|...]\n"
 909          "    json: [{\"g\": <glyph name or index>, \"ax\": <horizontal advance>, \"ay\": <vertical advance>, \"dx\": <horizontal displacement>, \"dy\": <vertical displacement>, \"cl\": <glyph cluster index within input>}, ...]\n"
 910          "\nOutput syntax options:",
 911                      "Options for the syntax of the output",
 912                      this);
 913 }
 914
 915 void
 916 format_options_t::serialize_unicode (hb_buffer_t *buffer,
 917                                      GString     *gs)
 918 {
 919   unsigned int num_glyphs = hb_buffer_get_length (buffer);
 920   hb_glyph_info_t *info = hb_buffer_get_glyph_infos (buffer, nullptr);
 921
 922   g_string_append_c (gs, '<');
 923   for (unsigned int i = 0; i < num_glyphs; i++)
 924   {
 925     if (i)
 926       g_string_append_c (gs, ',');
 927     g_string_append_printf (gs, "U+%04X", info->codepoint);
 928     info++;
 929   }
 930   g_string_append_c (gs, '>');
 931 }
 932
 933 void
 934 format_options_t::serialize_glyphs (hb_buffer_t *buffer,
 935                                     hb_font_t   *font,
 936                                     hb_buffer_serialize_format_t output_format,
 937                                     hb_buffer_serialize_flags_t flags,
 938                                     GString     *gs)
 939 {
 940   g_string_append_c (gs, '[');
 941   unsigned int num_glyphs = hb_buffer_get_length (buffer);
 942   unsigned int start = 0;
 943
 944   while (start < num_glyphs)
 945   {
 946     char buf[1024];
 947     unsigned int consumed;
 948     start += hb_buffer_serialize_glyphs (buffer, start, num_glyphs,
 949                                          buf, sizeof (buf), &consumed,
 950                                          font, output_format, flags);
 951     if (!consumed)
 952       break;
 953     g_string_append (gs, buf);
 954   }
 955   g_string_append_c (gs, ']');
 956 }
 957 void
 958 format_options_t::serialize_line_no (unsigned int  line_no,
 959                                      GString      *gs)
 960 {
 961   if (show_line_num)
 962     g_string_append_printf (gs, "%d: ", line_no);
 963 }
 964 void
 965 format_options_t::serialize_buffer_of_text (hb_buffer_t  *buffer,
 966                                             unsigned int  line_no,
 967                                             const char   *text,
 968                                             unsigned int  text_len,
 969                                             hb_font_t    *font,
 970                                             GString      *gs)
 971 {
 972   if (show_text)
 973   {
 974     serialize_line_no (line_no, gs);
 975     g_string_append_c (gs, '(');
 976     g_string_append_len (gs, text, text_len);
 977     g_string_append_c (gs, ')');
 978     g_string_append_c (gs, '\n');
 979   }
 980
 981   if (show_unicode)
 982   {
 983     serialize_line_no (line_no, gs);
 984     serialize_unicode (buffer, gs);
 985     g_string_append_c (gs, '\n');
 986   }
 987 }
 988 void
 989 format_options_t::serialize_message (unsigned int  line_no,
 990                                      const char   *type,
 991                                      const char   *msg,
 992                                      GString      *gs)
 993 {
 994   serialize_line_no (line_no, gs);
 995   g_string_append_printf (gs, "%s: %s", type, msg);
 996   g_string_append_c (gs, '\n');
 997 }
 998 void
 999 format_options_t::serialize_buffer_of_glyphs (hb_buffer_t  *buffer,
1000                                               unsigned int  line_no,
1001                                               const char   *text,
1002                                               unsigned int  text_len,
1003                                               hb_font_t    *font,
1004                                               hb_buffer_serialize_format_t output_format,
1005                                               hb_buffer_serialize_flags_t format_flags,
1006                                               GString      *gs)
1007 {
1008   serialize_line_no (line_no, gs);
1009   serialize_glyphs (buffer, font, output_format, format_flags, gs);
1010   g_string_append_c (gs, '\n');
1011 }
1012
1013 void
1014 subset_options_t::add_options (option_parser_t *parser)
1015 {
1016   GOptionEntry entries[] =
1017   {
1018     {"no-hinting", 0, 0, G_OPTION_ARG_NONE,  &this->drop_hints,   "Whether to drop hints",   nullptr},
1019     {nullptr}
1020   };
1021   parser->add_group (entries,
1022          "subset",
1023          "Subset options:",
1024          "Options subsetting",
1025          this);
1026 }