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 const char*
  37 get_token(const 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 = p;
  47   return 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 Deltas*
  55 get_font_idx(FONT* font,
  56              const 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_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_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_DELTAS_INVALID_FONT_INDEX;
  86   }
  87
  88   *string_p = endptr;
  89   *font_idx_p = font_idx;
  90
  91   return 0;
  92 }
  93
  94
  95 static Deltas*
  96 get_glyph_idx(FONT* font,
  97               long font_idx,
  98               const 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_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_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_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((const char**)&endptr);
 145
 146     token = strndup(s, endptr - s);
 147     if (!token)
 148     {
 149       /* *string_p = s; */
 150       return TA_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_DELTAS_INVALID_GLYPH_NAME;
 171     }
 172   }
 173   else
 174   {
 175     /* invalid */
 176
 177     /* *string_p = s; */
 178     return TA_DELTAS_SYNTAX_ERROR;
 179   }
 180
 181   *string_p = endptr;
 182   *glyph_idx_p = glyph_idx;
 183
 184   return 0;
 185 }
 186
 187
 188 static Deltas*
 189 get_range(const 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 = s + s_len;
 209     return TA_DELTAS_SYNTAX_ERROR;
 210   }
 211
 212   token = strndup(s, s_len);
 213   if (!token)
 214   {
 215     /* *string_p = s; */
 216     return TA_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_DELTAS_ALLOCATION_ERROR;
 229   }
 230
 231   *string_p = endptr;
 232
 233   if (number_set == NUMBERSET_INVALID_CHARACTER)
 234     return TA_DELTAS_INVALID_CHARACTER;
 235   else if (number_set == NUMBERSET_OVERFLOW)
 236     return TA_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_DELTAS_INVALID_POINT_RANGE;
 240   else if (number_set == NUMBERSET_OVERLAPPING_RANGES)
 241     return TA_DELTAS_OVERLAPPING_RANGES;
 242   else if (number_set == NUMBERSET_NOT_ASCENDING)
 243     return TA_DELTAS_NOT_ASCENDING;
 244
 245   *number_set_p = number_set;
 246
 247   return 0;
 248 }
 249
 250
 251 static Deltas*
 252 get_shift(const char** string_p,
 253           double* shift_p,
 254           int min,
 255           int max)
 256 {
 257   const char* s = *string_p;
 258   char* endptr;
 259   double shift;
 260
 261
 262   errno = 0;
 263   shift = strtod(s, &endptr);
 264
 265   if (errno == ERANGE)
 266   {
 267     /* *string_p = s; */
 268     /* this error code should be adjusted by the caller if necessary */
 269     return TA_DELTAS_INVALID_X_RANGE;
 270   }
 271
 272   /* there must be a whitespace character after the number */
 273   if (errno || !isspace(*endptr))
 274   {
 275     *string_p = endptr;
 276     return TA_DELTAS_SYNTAX_ERROR;
 277   }
 278
 279   if (shift < min || shift > max)
 280   {
 281     /* *string_p = s; */
 282     return TA_DELTAS_INVALID_X_RANGE;
 283   }
 284
 285   /* we round the value to a multiple of 1/(2^DELTA_SHIFT) */
 286   shift = floor(shift * DELTA_FACTOR + 0.5) / DELTA_FACTOR;
 287
 288   *string_p = endptr;
 289   *shift_p = shift;
 290
 291   return 0;
 292 }
 293
 294
 295 const char*
 296 TA_deltas_parse(FONT* font,
 297                 const char* s,
 298                 Deltas** deltas_p,
 299                 int x_min, int x_max,
 300                 int y_min, int y_max,
 301                 int ppem_min, int ppem_max)
 302 {
 303   typedef enum State_
 304   { START,
 305     HAD_TOKEN1,
 306     HAD_TOKEN2,
 307     HAD_FONT_IDX,
 308     HAD_GLYPH_IDX,
 309     HAD_P,
 310     HAD_POINTS,
 311     HAD_X,
 312     HAD_X_SHIFT,
 313     HAD_Y,
 314     HAD_Y_SHIFT,
 315     HAD_AT,
 316     HAD_PPEMS
 317   } State;
 318
 319   State state = START;
 320
 321   Deltas* deltas = NULL;
 322   Deltas* error;
 323   const char* pos = s;
 324
 325   const char* token1;
 326   const char* token2;
 327
 328
 329   if (!s)
 330     return NULL;
 331
 332   deltas = (Deltas*)malloc(sizeof (Deltas));
 333   if (!deltas)
 334   {
 335     if (deltas_p)
 336       *deltas_p = TA_DELTAS_ALLOCATION_ERROR;
 337     return s;
 338   }
 339
 340   deltas->font_idx = 0;
 341   deltas->glyph_idx = -1;
 342   deltas->points = NULL;
 343   deltas->x_shift = 0.0;
 344   deltas->y_shift = 0.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 = 0;
 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       /* possibility 1: <font idx> <glyph name> `p' */
 385       if (isdigit(*token1)
 386           && (isdigit(*token2) || isnamestart(*token2))
 387           && (c == 'p' && next_is_space))
 388       {
 389         pos = token1;
 390         if (!(error = get_font_idx(font, &pos, &deltas->font_idx)))
 391           state = HAD_FONT_IDX;
 392       }
 393       /* possibility 2: <glyph name> `p' */
 394       else if ((isdigit(*token1) || isnamestart(*token1))
 395                && (c == 'p' && next_is_space))
 396       {
 397         pos = token1;
 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_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, x_min, x_max)))
 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, y_min, y_max)))
 481         state = HAD_Y_SHIFT;
 482       if (error == TA_DELTAS_INVALID_X_RANGE)
 483         error = TA_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_DELTAS_INVALID_POINT_RANGE)
 501         error = TA_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     *deltas_p = deltas;
 517   }
 518   else
 519   {
 520     TA_deltas_free(deltas);
 521
 522     *deltas_p = error;
 523   }
 524
 525   return pos;
 526 }
 527
 528
 529 void
 530 TA_deltas_free(Deltas* deltas)
 531 {
 532   if (!deltas)
 533     return;
 534
 535   number_set_free(deltas->points);
 536   number_set_free(deltas->ppems);
 537
 538   free(deltas);
 539 }
 540
 541 /* end of tadeltas.c */