lib/tadeltas.c

   1 /* tadeltas.c */
   2
   3 /*
   4  * Copyright (C) 2014 by Werner Lemberg.
   5  *
   6  * This file is part of the ttfautohint library, and may only be used,
   7  * modified, and distributed under the terms given in `COPYING'.  By
   8  * continuing to use, modify, or distribute this file you indicate that you
   9  * have read `COPYING' and understand and accept it fully.
  10  *
  11  * The file `COPYING' mentioned in the previous paragraph is distributed
  12  * with the ttfautohint library.
  13  */
  14
  15 #include <ta.h>
  16 #include <tadeltas.h>
  17 #include <errno.h>
  18 #include <ctype.h>
  19 #include <math.h>
  20
  21
  22 /* a test to check the validity of the first character */
  23 /* in a PostScript glyph name -- for simplicity, we include `.' also */
  24
  25 const char* namestart_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
  26                               "abcdefghijklmnopqrstuvwxyz"
  27                               "._";
  28
  29 static int
  30 isnamestart(int c)
  31 {
  32   return strchr(namestart_chars, c) != NULL;
  33 }
  34
  35
  36 static char*
  37 get_token(char** string_p)
  38 {
  39   const char* s = *string_p;
  40   const char* p = *string_p;
  41
  42
  43   while (*p && !isspace(*p))
  44     p++;
  45
  46   *string_p = (char*)p;
  47   return (char*)s;
  48 }
  49
  50
  51 /* in the following functions, `*string_p' is never '\0'; */
  52 /* in case of error, `*string_p' should be set to a meaningful position */
  53
  54 static TA_Error
  55 get_font_idx(FONT* font,
  56              char** string_p,
  57              long* font_idx_p)
  58 {
  59   const char* s = *string_p;
  60   char* endptr;
  61   long font_idx;
  62
  63
  64   errno = 0;
  65   font_idx = strtol(s, &endptr, 0);
  66
  67   if (errno == ERANGE)
  68   {
  69     /* *string_p = s; */
  70     return TA_Err_Deltas_Invalid_Font_Index;
  71   }
  72
  73   /* there must be a whitespace character after the number */
  74   if (errno || !isspace(*endptr))
  75   {
  76     *string_p = endptr;
  77     return TA_Err_Deltas_Syntax_Error;
  78   }
  79
  80   /* we have already tested that the first character in `s' is a digit, */
  81   /* so `font_idx' can't be negative */
  82   if (font_idx >= font->num_sfnts)
  83   {
  84     /* *string_p = s; */
  85     return TA_Err_Deltas_Invalid_Font_Index;
  86   }
  87
  88   *string_p = endptr;
  89   *font_idx_p = font_idx;
  90
  91   return TA_Err_Ok;
  92 }
  93
  94
  95 static TA_Error
  96 get_glyph_idx(FONT* font,
  97               long font_idx,
  98               char** string_p,
  99               long* glyph_idx_p)
 100 {
 101   const char* s = *string_p;
 102   char* endptr;
 103   long glyph_idx;
 104
 105   FT_Face face = font->sfnts[font_idx].face;
 106
 107
 108   if (isdigit(*s))
 109   {
 110     /* glyph index */
 111
 112     errno = 0;
 113     glyph_idx = strtol(s, &endptr, 0);
 114
 115     if (errno == ERANGE)
 116     {
 117       /* *string_p = s; */
 118       return TA_Err_Deltas_Invalid_Glyph_Index;
 119     }
 120
 121     /* there must be a whitespace character after the number */
 122     if (errno || !isspace(*endptr))
 123     {
 124       *string_p = endptr;
 125       return TA_Err_Deltas_Syntax_Error;
 126     }
 127
 128     /* we have already tested that the first character in `s' is a digit, */
 129     /* so `glyph_idx' can't be negative */
 130     if (glyph_idx >= face->num_glyphs)
 131     {
 132       /* *string_p = s; */
 133       return TA_Err_Deltas_Invalid_Glyph_Index;
 134     }
 135   }
 136   else if (isnamestart(*s))
 137   {
 138     /* glyph name */
 139
 140     char* token;
 141
 142
 143     endptr = (char*)s;
 144     s = get_token(&endptr);
 145
 146     token = strndup(s, endptr - s);
 147     if (!token)
 148     {
 149       /* *string_p = s; */
 150       return TA_Err_Deltas_Allocation_Error;
 151     }
 152
 153     /* explicitly compare with `.notdef' */
 154     /* since `FT_Get_Name_Index' returns glyph index 0 */
 155     /* for both this glyph name and invalid ones */
 156     if (!strcmp(token, ".notdef"))
 157       glyph_idx = 0;
 158     else
 159     {
 160       glyph_idx = FT_Get_Name_Index(face, token);
 161       if (glyph_idx == 0)
 162         glyph_idx = -1;
 163     }
 164
 165     free(token);
 166
 167     if (glyph_idx < 0)
 168     {
 169       /* *string_p = s; */
 170       return TA_Err_Deltas_Invalid_Glyph_Name;
 171     }
 172   }
 173   else
 174   {
 175     /* invalid */
 176
 177     /* *string_p = s; */
 178     return TA_Err_Deltas_Syntax_Error;
 179   }
 180
 181   *string_p = endptr;
 182   *glyph_idx_p = glyph_idx;
 183
 184   return TA_Err_Ok;
 185 }
 186
 187
 188 static TA_Error
 189 get_range(char** string_p,
 190           number_range** number_set_p,
 191           int min,
 192           int max,
 193           const char* delims)
 194 {
 195   const char* s = *string_p;
 196   number_range* number_set = *number_set_p;
 197
 198   size_t s_len = strcspn(s, delims);
 199   char* token;
 200   char* endptr;
 201
 202
 203   /* there must be a whitespace character before the delimiter */
 204   /* if it is not \0 */
 205   if (*delims
 206       && (!s_len || !isspace(s[s_len - 1])))
 207   {
 208     *string_p = (char*)(s + s_len);
 209     return TA_Err_Deltas_Syntax_Error;
 210   }
 211
 212   token = strndup(s, s_len);
 213   if (!token)
 214   {
 215     /* *string_p = s; */
 216     return TA_Err_Deltas_Allocation_Error;
 217   }
 218
 219   endptr = (char*)number_set_parse(token, &number_set, min, max);
 220
 221   /* use offset relative to `s' */
 222   endptr = (char*)s + (endptr - token);
 223   free(token);
 224
 225   if (number_set == NUMBERSET_ALLOCATION_ERROR)
 226   {
 227     /* *string_p = s; */
 228     return TA_Err_Deltas_Allocation_Error;
 229   }
 230
 231   *string_p = endptr;
 232
 233   if (number_set == NUMBERSET_INVALID_CHARACTER)
 234     return TA_Err_Deltas_Invalid_Character;
 235   else if (number_set == NUMBERSET_OVERFLOW)
 236     return TA_Err_Deltas_Overflow;
 237   else if (number_set == NUMBERSET_INVALID_RANGE)
 238     /* this error code should be adjusted by the caller if necessary */
 239     return TA_Err_Deltas_Invalid_Point_Range;
 240   else if (number_set == NUMBERSET_OVERLAPPING_RANGES)
 241     return TA_Err_Deltas_Overlapping_Ranges;
 242   else if (number_set == NUMBERSET_NOT_ASCENDING)
 243     return TA_Err_Deltas_Ranges_Not_Ascending;
 244
 245   *number_set_p = number_set;
 246
 247   return TA_Err_Ok;
 248 }
 249
 250
 251 static TA_Error
 252 get_shift(char** string_p,
 253           char* shift_p)
 254 {
 255   const char* s = *string_p;
 256   char* endptr;
 257   double shift;
 258
 259
 260   errno = 0;
 261   shift = strtod(s, &endptr);
 262
 263   if (errno == ERANGE)
 264   {
 265     /* *string_p = s; */
 266     /* this error code should be adjusted by the caller if necessary */
 267     return TA_Err_Deltas_Invalid_X_Range;
 268   }
 269
 270   /* there must be a whitespace character after the number */
 271   if (errno || !isspace(*endptr))
 272   {
 273     *string_p = endptr;
 274     return TA_Err_Deltas_Syntax_Error;
 275   }
 276
 277   if (shift < DELTA_SHIFT_MIN || shift > DELTA_SHIFT_MAX)
 278   {
 279     /* *string_p = s; */
 280     return TA_Err_Deltas_Invalid_X_Range;
 281   }
 282
 283   *string_p = endptr;
 284
 285   /* we round the value to a multiple of 1/(2^DELTA_SHIFT) */
 286   *shift_p = (char)(shift * DELTA_FACTOR + (shift > 0 ? 0.5 : -0.5));
 287
 288   return TA_Err_Ok;
 289 }
 290
 291
 292 TA_Error
 293 TA_deltas_parse(FONT* font,
 294                 const char* s,
 295                 char** err_pos,
 296                 Deltas** deltas_p,
 297                 int ppem_min, int ppem_max)
 298 {
 299   TA_Error error;
 300
 301   typedef enum State_
 302   { START,
 303     HAD_TOKEN1,
 304     HAD_TOKEN2,
 305     HAD_FONT_IDX,
 306     HAD_GLYPH_IDX,
 307     HAD_P,
 308     HAD_POINTS,
 309     HAD_X,
 310     HAD_X_SHIFT,
 311     HAD_Y,
 312     HAD_Y_SHIFT,
 313     HAD_AT,
 314     HAD_PPEMS
 315   } State;
 316
 317   State state = START;
 318
 319   Deltas* deltas = NULL;
 320   char* pos = (char*)s;
 321
 322   const char* token1;
 323   const char* token2;
 324
 325
 326   if (!s)
 327   {
 328     *err_pos = NULL;
 329     return TA_Err_Ok;
 330   }
 331
 332   deltas = (Deltas*)malloc(sizeof (Deltas));
 333   if (!deltas)
 334   {
 335     *err_pos = (char*)s;
 336
 337     return TA_Err_Deltas_Allocation_Error;
 338   }
 339
 340   deltas->font_idx = 0;
 341   deltas->glyph_idx = -1;
 342   deltas->points = NULL;
 343   deltas->x_shift = 0;
 344   deltas->y_shift = 0;
 345   deltas->ppems = NULL;
 346
 347   for (;;)
 348   {
 349     char c;
 350     int next_is_space;
 351     State old_state = state;
 352
 353
 354     error = TA_Err_Ok;
 355
 356     while (isspace(*pos))
 357       pos++;
 358
 359     /* skip comment */
 360     if (*pos == '#')
 361       while (*pos)
 362         pos++;
 363
 364     /* EOL */
 365     if (!*pos)
 366       break;
 367
 368     c = *pos;
 369     next_is_space = isspace(*(pos + 1));
 370
 371     switch (state)
 372     {
 373     case START:
 374       token1 = get_token(&pos);
 375       state = HAD_TOKEN1;
 376       break;
 377
 378     case HAD_TOKEN1:
 379       token2 = get_token(&pos);
 380       state = HAD_TOKEN2;
 381       break;
 382
 383     case HAD_TOKEN2:
 384       pos = (char*)token1;
 385
 386       /* possibility 1: <font idx> <glyph name> `p' */
 387       if (isdigit(*token1)
 388           && (isdigit(*token2) || isnamestart(*token2))
 389           && (c == 'p' && next_is_space))
 390       {
 391         if (!(error = get_font_idx(font, &pos, &deltas->font_idx)))
 392           state = HAD_FONT_IDX;
 393       }
 394       /* possibility 2: <glyph name> `p' */
 395       else if ((isdigit(*token1) || isnamestart(*token1))
 396                && (c == 'p' && next_is_space))
 397       {
 398         if (!(error = get_glyph_idx(font, deltas->font_idx,
 399                                     &pos, &deltas->glyph_idx)))
 400           state = HAD_GLYPH_IDX;
 401       }
 402       break;
 403
 404     case HAD_FONT_IDX:
 405       /* <glyph idx> */
 406       if (!(error = get_glyph_idx(font, deltas->font_idx,
 407                                   &pos, &deltas->glyph_idx)))
 408         state = HAD_GLYPH_IDX;
 409       break;
 410
 411     case HAD_GLYPH_IDX:
 412       /* `p' */
 413       if (c == 'p' && next_is_space)
 414       {
 415         state = HAD_P;
 416         pos += 2;
 417       }
 418       break;
 419
 420     case HAD_P:
 421       /* <points> */
 422       {
 423         FT_Error ft_error;
 424         FT_Face face = font->sfnts[deltas->font_idx].face;
 425         int num_points;
 426
 427
 428         ft_error = FT_Load_Glyph(face, deltas->glyph_idx, FT_LOAD_NO_SCALE);
 429         if (ft_error)
 430         {
 431           error = TA_Err_Deltas_Invalid_Glyph;
 432           break;
 433         }
 434
 435         num_points = face->glyph->outline.n_points;
 436         if (!(error = get_range(&pos, &deltas->points,
 437                                 0, num_points - 1, "xy@")))
 438           state = HAD_POINTS;
 439       }
 440       break;
 441
 442     case HAD_POINTS:
 443       /* `x' or `y' or `@' */
 444       if (next_is_space)
 445       {
 446         pos += 2;
 447         if (c == 'x')
 448           state = HAD_X;
 449         else if (c == 'y')
 450           state = HAD_Y;
 451         else if (c == '@')
 452           state = HAD_AT;
 453         else
 454           pos -= 2;
 455       }
 456       break;
 457
 458     case HAD_X:
 459       /* <x_shift> */
 460       if (!(error = get_shift(&pos, &deltas->x_shift)))
 461         state = HAD_X_SHIFT;
 462       break;
 463
 464     case HAD_X_SHIFT:
 465       /* 'y' or '@' */
 466       if (next_is_space)
 467       {
 468         pos += 2;
 469         if (c == 'y')
 470           state = HAD_Y;
 471         else if (c == '@')
 472           state = HAD_AT;
 473         else
 474           pos -= 2;
 475       }
 476       break;
 477
 478     case HAD_Y:
 479       /* <y shift> */
 480       if (!(error = get_shift(&pos, &deltas->y_shift)))
 481         state = HAD_Y_SHIFT;
 482       if (error == TA_Err_Deltas_Invalid_X_Range)
 483         error = TA_Err_Deltas_Invalid_Y_Range;
 484       break;
 485
 486     case HAD_Y_SHIFT:
 487       /* '@' */
 488       if (c == '@' && next_is_space)
 489       {
 490         state = HAD_AT;
 491         pos += 2;
 492       }
 493       break;
 494
 495     case HAD_AT:
 496       /* <ppems> */
 497       if (!(error = get_range(&pos, &deltas->ppems,
 498                               ppem_min, ppem_max, "")))
 499         state = HAD_PPEMS;
 500       if (error == TA_Err_Deltas_Invalid_Point_Range)
 501         error = TA_Err_Deltas_Invalid_Ppem_Range;
 502       break;
 503
 504     case HAD_PPEMS:
 505       /* to make compiler happy */
 506       break;
 507     }
 508
 509     if (old_state == state)
 510       break;
 511   }
 512
 513   if (state == HAD_PPEMS)
 514   {
 515     /* success */
 516     if (deltas_p)
 517       *deltas_p = deltas;
 518     else
 519       TA_deltas_free(deltas);
 520   }
 521   else
 522   {
 523     TA_deltas_free(deltas);
 524     *deltas_p = NULL;
 525
 526     if (!error && state != START)
 527       error = TA_Err_Deltas_Syntax_Error;
 528   }
 529
 530   *err_pos = pos;
 531
 532   return error;
 533 }
 534
 535
 536 void
 537 TA_deltas_free(Deltas* deltas)
 538 {
 539   if (!deltas)
 540     return;
 541
 542   number_set_free(deltas->points);
 543   number_set_free(deltas->ppems);
 544
 545   free(deltas);
 546 }
 547
 548
 549 char*
 550 TA_deltas_show(FONT* font,
 551                Deltas* deltas)
 552 {
 553   int ret;
 554   char glyph_name_buf[64];
 555   char* points_buf = NULL;
 556   char* ppems_buf = NULL;
 557   char* deltas_buf = NULL;
 558
 559   FT_Face face;
 560
 561
 562   if (!deltas)
 563     return NULL;
 564
 565   if (deltas->font_idx >= font->num_sfnts)
 566     return NULL;
 567
 568   face = font->sfnts[deltas->font_idx].face;
 569   glyph_name_buf[0] = '\0';
 570   if (FT_HAS_GLYPH_NAMES(face))
 571     FT_Get_Glyph_Name(face, deltas->glyph_idx, glyph_name_buf, 64);
 572
 573   points_buf = number_set_show(deltas->points, -1, -1);
 574   if (!points_buf)
 575     goto Exit;
 576   ppems_buf = number_set_show(deltas->ppems, -1, -1);
 577   if (!ppems_buf)
 578     goto Exit;
 579
 580   /* display glyph index if we don't have a glyph name */
 581   if (*glyph_name_buf)
 582     ret = asprintf(&deltas_buf, "%ld %s p %s x %.20g y %.20g @ %s",
 583                    deltas->font_idx,
 584                    glyph_name_buf,
 585                    points_buf,
 586                    (double)deltas->x_shift / DELTA_FACTOR,
 587                    (double)deltas->y_shift / DELTA_FACTOR,
 588                    ppems_buf);
 589   else
 590     ret = asprintf(&deltas_buf, "%ld %ld p %s x %.20g y %.20g @ %s",
 591                    deltas->font_idx,
 592                    deltas->glyph_idx,
 593                    points_buf,
 594                    (double)deltas->x_shift / DELTA_FACTOR,
 595                    (double)deltas->y_shift / DELTA_FACTOR,
 596                    ppems_buf);
 597
 598 Exit:
 599   free(points_buf);
 600   free(ppems_buf);
 601
 602   if (ret == -1)
 603     return NULL;
 604
 605   return deltas_buf;
 606 }
 607
 608 /* end of tadeltas.c */