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 /*
 293  * Parse a delta exceptions line.
 294  *
 295  * In case of success (this is, the delta exceptions description in `s' is
 296  * valid), `pos' is a pointer to the final zero byte in string `s'.  In case
 297  * of an error, it points to the offending character in string `s'.
 298  *
 299  * If s is NULL, the function exits immediately, with NULL as the value of
 300  * `pos'.
 301  *
 302  * If the user provides a non-NULL `deltas' value, `deltas_parse' stores the
 303  * parsed result in `*deltas', allocating the necessary memory.  If there is
 304  * no data (for example, an empty string or whitespace only) nothing gets
 305  * allocated, and `*deltas' is set to NULL.
 306  *
 307  */
 308
 309 static TA_Error
 310 deltas_parse_line(FONT* font,
 311                   const char* s,
 312                   char** err_pos,
 313                   Deltas** deltas_p,
 314                   int ppem_min, int ppem_max)
 315 {
 316   TA_Error error;
 317
 318   typedef enum State_
 319   { START,
 320     HAD_TOKEN1,
 321     HAD_TOKEN2,
 322     HAD_FONT_IDX,
 323     HAD_GLYPH_IDX,
 324     HAD_P,
 325     HAD_POINTS,
 326     HAD_X,
 327     HAD_X_SHIFT,
 328     HAD_Y,
 329     HAD_Y_SHIFT,
 330     HAD_AT,
 331     HAD_PPEMS
 332   } State;
 333
 334   State state = START;
 335
 336   char* pos = (char*)s;
 337
 338   const char* token1;
 339   const char* token2;
 340
 341   long font_idx = 0;
 342   long glyph_idx = -1;
 343   number_range* points = NULL;
 344   char x_shift = 0;
 345   char y_shift = 0;
 346   number_range* ppems = NULL;
 347
 348
 349   if (!s)
 350   {
 351     *err_pos = NULL;
 352     return TA_Err_Ok;
 353   }
 354
 355   for (;;)
 356   {
 357     char c;
 358     int next_is_space;
 359     State old_state = state;
 360
 361
 362     error = TA_Err_Ok;
 363
 364     while (isspace(*pos))
 365       pos++;
 366
 367     /* skip comment */
 368     if (*pos == '#')
 369       while (*pos)
 370         pos++;
 371
 372     /* EOL */
 373     if (!*pos)
 374       break;
 375
 376     c = *pos;
 377     next_is_space = isspace(*(pos + 1));
 378
 379     switch (state)
 380     {
 381     case START:
 382       token1 = get_token(&pos);
 383       state = HAD_TOKEN1;
 384       break;
 385
 386     case HAD_TOKEN1:
 387       token2 = get_token(&pos);
 388       state = HAD_TOKEN2;
 389       break;
 390
 391     case HAD_TOKEN2:
 392       pos = (char*)token1;
 393
 394       /* possibility 1: <font idx> <glyph name> `p' */
 395       if (isdigit(*token1)
 396           && (isdigit(*token2) || isnamestart(*token2))
 397           && (c == 'p' && next_is_space))
 398       {
 399         if (!(error = get_font_idx(font, &pos, &font_idx)))
 400           state = HAD_FONT_IDX;
 401       }
 402       /* possibility 2: <glyph name> `p' */
 403       else if ((isdigit(*token1) || isnamestart(*token1))
 404                && (c == 'p' && next_is_space))
 405       {
 406         if (!(error = get_glyph_idx(font, font_idx,
 407                                     &pos, &glyph_idx)))
 408           state = HAD_GLYPH_IDX;
 409       }
 410       break;
 411
 412     case HAD_FONT_IDX:
 413       /* <glyph idx> */
 414       if (!(error = get_glyph_idx(font, font_idx,
 415                                   &pos, &glyph_idx)))
 416         state = HAD_GLYPH_IDX;
 417       break;
 418
 419     case HAD_GLYPH_IDX:
 420       /* `p' */
 421       if (c == 'p' && next_is_space)
 422       {
 423         state = HAD_P;
 424         pos += 2;
 425       }
 426       break;
 427
 428     case HAD_P:
 429       /* <points> */
 430       {
 431         FT_Error ft_error;
 432         FT_Face face = font->sfnts[font_idx].face;
 433         int num_points;
 434
 435
 436         ft_error = FT_Load_Glyph(face, glyph_idx, FT_LOAD_NO_SCALE);
 437         if (ft_error)
 438         {
 439           error = TA_Err_Deltas_Invalid_Glyph;
 440           break;
 441         }
 442
 443         num_points = face->glyph->outline.n_points;
 444         if (!(error = get_range(&pos, deltas_p ? &points : NULL,
 445                                 0, num_points - 1, "xy@")))
 446           state = HAD_POINTS;
 447       }
 448       break;
 449
 450     case HAD_POINTS:
 451       /* `x' or `y' or `@' */
 452       if (next_is_space)
 453       {
 454         pos += 2;
 455         if (c == 'x')
 456           state = HAD_X;
 457         else if (c == 'y')
 458           state = HAD_Y;
 459         else if (c == '@')
 460           state = HAD_AT;
 461         else
 462           pos -= 2;
 463       }
 464       break;
 465
 466     case HAD_X:
 467       /* <x_shift> */
 468       if (!(error = get_shift(&pos, &x_shift)))
 469         state = HAD_X_SHIFT;
 470       break;
 471
 472     case HAD_X_SHIFT:
 473       /* 'y' or '@' */
 474       if (next_is_space)
 475       {
 476         pos += 2;
 477         if (c == 'y')
 478           state = HAD_Y;
 479         else if (c == '@')
 480           state = HAD_AT;
 481         else
 482           pos -= 2;
 483       }
 484       break;
 485
 486     case HAD_Y:
 487       /* <y shift> */
 488       if (!(error = get_shift(&pos, &y_shift)))
 489         state = HAD_Y_SHIFT;
 490       if (error == TA_Err_Deltas_Invalid_X_Range)
 491         error = TA_Err_Deltas_Invalid_Y_Range;
 492       break;
 493
 494     case HAD_Y_SHIFT:
 495       /* '@' */
 496       if (c == '@' && next_is_space)
 497       {
 498         state = HAD_AT;
 499         pos += 2;
 500       }
 501       break;
 502
 503     case HAD_AT:
 504       /* <ppems> */
 505       if (!(error = get_range(&pos, deltas_p ? &ppems : NULL,
 506                               ppem_min, ppem_max, "")))
 507         state = HAD_PPEMS;
 508       if (error == TA_Err_Deltas_Invalid_Point_Range)
 509         error = TA_Err_Deltas_Invalid_Ppem_Range;
 510       break;
 511
 512     case HAD_PPEMS:
 513       /* to make compiler happy */
 514       break;
 515     }
 516
 517     if (old_state == state)
 518       break;
 519   }
 520
 521   if (state == HAD_PPEMS)
 522   {
 523     /* success */
 524     if (deltas_p)
 525     {
 526       Deltas* deltas = (Deltas*)malloc(sizeof (Deltas));
 527
 528
 529       if (!deltas)
 530       {
 531         number_set_free(points);
 532         number_set_free(ppems);
 533
 534         *err_pos = (char*)s;
 535
 536         return TA_Err_Deltas_Allocation_Error;
 537       }
 538
 539       deltas->font_idx = font_idx;
 540       deltas->glyph_idx = glyph_idx;
 541       deltas->points = points;
 542       deltas->x_shift = x_shift;
 543       deltas->y_shift = y_shift;
 544       deltas->ppems = ppems;
 545       deltas->next = NULL;
 546
 547       *deltas_p = deltas;
 548     }
 549   }
 550   else
 551   {
 552     if (deltas_p)
 553     {
 554       number_set_free(points);
 555       number_set_free(ppems);
 556
 557       *deltas_p = NULL;
 558     }
 559
 560     if (!error && state != START)
 561       error = TA_Err_Deltas_Syntax_Error;
 562   }
 563
 564   *err_pos = pos;
 565
 566   return error;
 567 }
 568
 569
 570 void
 571 TA_deltas_free(Deltas* deltas)
 572 {
 573   while (deltas)
 574   {
 575     Deltas* tmp;
 576
 577
 578     number_set_free(deltas->points);
 579     number_set_free(deltas->ppems);
 580
 581     tmp = deltas;
 582     deltas = deltas->next;
 583     free(tmp);
 584   }
 585 }
 586
 587
 588 /* `len' is the length of the returned string */
 589
 590 char*
 591 deltas_show_line(FONT* font,
 592                  int* len,
 593                  Deltas* deltas)
 594 {
 595   int ret;
 596   char glyph_name_buf[64];
 597   char* points_buf = NULL;
 598   char* ppems_buf = NULL;
 599   char* deltas_buf = NULL;
 600
 601   FT_Face face;
 602
 603
 604   if (!deltas)
 605     return NULL;
 606
 607   if (deltas->font_idx >= font->num_sfnts)
 608     return NULL;
 609
 610   face = font->sfnts[deltas->font_idx].face;
 611   glyph_name_buf[0] = '\0';
 612   if (FT_HAS_GLYPH_NAMES(face))
 613     FT_Get_Glyph_Name(face, deltas->glyph_idx, glyph_name_buf, 64);
 614
 615   points_buf = number_set_show(deltas->points, -1, -1);
 616   if (!points_buf)
 617     goto Exit;
 618   ppems_buf = number_set_show(deltas->ppems, -1, -1);
 619   if (!ppems_buf)
 620     goto Exit;
 621
 622   /* display glyph index if we don't have a glyph name */
 623   if (*glyph_name_buf)
 624     ret = asprintf(&deltas_buf, "%ld %s p %s x %.20g y %.20g @ %s",
 625                    deltas->font_idx,
 626                    glyph_name_buf,
 627                    points_buf,
 628                    (double)deltas->x_shift / DELTA_FACTOR,
 629                    (double)deltas->y_shift / DELTA_FACTOR,
 630                    ppems_buf);
 631   else
 632     ret = asprintf(&deltas_buf, "%ld %ld p %s x %.20g y %.20g @ %s",
 633                    deltas->font_idx,
 634                    deltas->glyph_idx,
 635                    points_buf,
 636                    (double)deltas->x_shift / DELTA_FACTOR,
 637                    (double)deltas->y_shift / DELTA_FACTOR,
 638                    ppems_buf);
 639
 640 Exit:
 641   free(points_buf);
 642   free(ppems_buf);
 643
 644   if (ret == -1)
 645     return NULL;
 646
 647   *len = ret;
 648
 649   return deltas_buf;
 650 }
 651
 652
 653 char*
 654 TA_deltas_show(FONT* font,
 655                Deltas* deltas)
 656 {
 657   char* s;
 658   int s_len;
 659
 660
 661   /* we return an empty string if there is no data */
 662   s = (char*)malloc(1);
 663   if (!s)
 664     return NULL;
 665
 666   *s = '\0';
 667   s_len = 1;
 668
 669   while (deltas)
 670   {
 671     char* tmp;
 672     int tmp_len;
 673     char* s_new;
 674     int s_len_new;
 675
 676
 677     tmp = deltas_show_line(font, &tmp_len, deltas);
 678     if (!tmp)
 679     {
 680       free(s);
 681       return NULL;
 682     }
 683
 684     /* append current line to buffer, followed by a newline character */
 685     s_len_new = s_len + tmp_len + 1;
 686     s_new = (char*)realloc(s, s_len_new);
 687     if (!s_new)
 688     {
 689       free(s);
 690       free(tmp);
 691       return NULL;
 692     }
 693
 694     strcpy(s_new + s_len - 1, tmp);
 695     s_new[s_len_new - 2] = '\n';
 696     s_new[s_len_new - 1] = '\0';
 697
 698     s = s_new;
 699     s_len = s_len_new;
 700
 701     free(tmp);
 702
 703     deltas = deltas->next;
 704   }
 705
 706   return s;
 707 }
 708
 709
 710 /* Get a line from a buffer, starting at `pos'.  The final EOL */
 711 /* character (or character pair) of the line (if existing) gets removed. */
 712 /* After the call, `pos' points to the position right after the line in */
 713 /* the buffer.  The line is allocated with `malloc'; it returns NULL for */
 714 /* end of data and allocation errors; the latter can be recognized by a */
 715 /* changed value of `pos'.  */
 716
 717 static char*
 718 get_line(char** pos)
 719 {
 720   const char* start = *pos;
 721   const char* p = start;
 722   size_t len;
 723   char* s;
 724
 725
 726   if (!*p)
 727     return NULL;
 728
 729   while (*p)
 730   {
 731     if (*p == '\n' || *p == '\r')
 732       break;
 733
 734     p++;
 735   }
 736
 737   len = p - start + 1;
 738
 739   if (*p == '\r')
 740   {
 741     len--;
 742     p++;
 743
 744     if (*p == '\n')
 745       p++;
 746   }
 747   else if (*p == '\n')
 748   {
 749     len--;
 750     p++;
 751   }
 752
 753   *pos = (char*)p;
 754
 755   s = (char*)malloc(len + 1);
 756   if (!s)
 757     return NULL;
 758
 759   if (len)
 760     strncpy(s, start, len);
 761   s[len] = '\0';
 762
 763   return s;
 764 }
 765
 766
 767 TA_Error
 768 TA_deltas_parse(FONT* font,
 769                 Deltas** deltas,
 770                 unsigned int* errlinenum_p,
 771                 char** errline_p,
 772                 char** errpos_p)
 773 {
 774   FT_Error error;
 775
 776   Deltas* cur;
 777   Deltas* new_deltas;
 778   Deltas* tmp;
 779   Deltas* list;
 780
 781   unsigned int linenum;
 782
 783   char* bufpos;
 784   char* bufpos_old;
 785
 786
 787   /* nothing to do if no data */
 788   if (!font->deltas_buf)
 789     return TA_Err_Ok;
 790
 791   bufpos = font->deltas_buf;
 792   bufpos_old = bufpos;
 793
 794   linenum = 0;
 795   cur = NULL;
 796
 797   /* parse line by line */
 798   for (;;)
 799   {
 800     char* line;
 801     char* errpos;
 802
 803
 804     line = get_line(&bufpos);
 805     if (!line)
 806     {
 807       if (bufpos == bufpos_old) /* end of data */
 808         break;
 809
 810       *errlinenum_p = linenum;
 811       *errline_p = NULL;
 812       *errpos_p = NULL;
 813
 814       return FT_Err_Out_Of_Memory;
 815     }
 816
 817     error = deltas_parse_line(font,
 818                               line,
 819                               &errpos,
 820                               deltas ? &new_deltas : NULL,
 821                               DELTA_PPEM_MIN, DELTA_PPEM_MAX);
 822     if (error)
 823     {
 824       *errlinenum_p = linenum;
 825       *errline_p = line;
 826       *errpos_p = errpos;
 827
 828       TA_deltas_free(cur);
 829
 830       return error;
 831     }
 832
 833     if (deltas && new_deltas)
 834     {
 835       new_deltas->next = cur;
 836       cur = new_deltas;
 837     }
 838
 839     free(line);
 840     linenum++;
 841     bufpos_old = bufpos;
 842   }
 843
 844   /* success; now reverse list to have elements in original order */
 845   list = NULL;
 846
 847   while (cur)
 848   {
 849     tmp = cur;
 850     cur = cur->next;
 851     tmp->next = list;
 852     list = tmp;
 853   }
 854
 855   if (deltas)
 856     *deltas = list;
 857
 858   return TA_Err_Ok;
 859 }
 860
 861
 862 /*
 863  *
 864  * Using
 865  *
 866  *   delta_shift = 3   ,
 867  *
 868  * the possible shift values in the instructions are indexed as follows:
 869  *
 870  *    0   -1px
 871  *    1   -7/8px
 872  *   ...
 873  *    7   -1/8px
 874  *    8    1/8px
 875  *   ...
 876  *   14    7/8px
 877  *   15    1px
 878  *
 879  * (note that there is no index for a zero shift).
 880  */
 881
 882
 883 /* end of tadeltas.c */