lib/tadeltas.y

   1 /* tadeltas.y */
   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
  16 /* grammar for parsing delta exceptions */
  17
  18 /*
  19  * Edsko de Vries's article `Writing a Reentrant Parser with Flex and Bison'
  20  * (http://www.phpcompiler.org/articles/reentrantparser.html)
  21  * was extremely helpful in writing this code.
  22  */
  23
  24 %output "tadeltas-bison.c"
  25 %defines "tadeltas-bison.h"
  26
  27 %define api.pure
  28 %error-verbose
  29 %expect 3
  30 %glr-parser
  31 %lex-param { void* scanner }
  32 %locations
  33 %name-prefix "TA_deltas_"
  34 %parse-param { Deltas_Context* context }
  35 %require "2.5"
  36
  37 %code requires {
  38 #include "ta.h"
  39
  40 /* we don't change the name prefix of flex functions */
  41 #define TA_deltas_lex yylex
  42 }
  43
  44 %union {
  45   long integer;
  46   char* name;
  47   number_range* range;
  48   double real;
  49   Deltas* deltas;
  50 }
  51
  52 %{
  53 #include "tadeltas-flex.h"
  54
  55 void
  56 TA_deltas_error(YYLTYPE *locp,
  57                 Deltas_Context* context,
  58                 char const* msg);
  59
  60 void
  61 store_error_data(YYLTYPE *locp,
  62                  Deltas_Context* context,
  63                  TA_Error error);
  64
  65
  66 /* calls to `yylex' in the generated bison code use `scanner' directly */
  67 #define scanner context->scanner
  68 %}
  69
  70 /* BAD_XXX and INVALID_CHARACTER indicate flex errors */
  71 %token INVALID_CHARACTER
  72 %token EOE
  73 %token <integer> BAD_INTEGER
  74 %token <name> BAD_NAME
  75 %token <real> BAD_REAL
  76 %token <integer> INTEGER
  77 %token <name> NAME
  78 %token <real> REAL
  79
  80 %type <deltas> entry
  81 %type <integer> font_idx
  82 %type <integer> glyph_idx
  83 %type <name> glyph_name
  84 %type <deltas> input
  85 %type <integer> integer
  86 %type <range> left_limited
  87 %type <range> number_set
  88 %type <range> point_set
  89 %type <range> ppem_set
  90 %type <range> range
  91 %type <range> range_elem
  92 %type <range> range_elems
  93 %type <real> real
  94 %type <range> right_limited
  95 %type <real> shift
  96 %type <range> unlimited
  97 %type <real> x_shift
  98 %type <real> y_shift
  99
 100 %destructor { TA_deltas_free($$); } <deltas>
 101 %destructor { number_set_free($$); } <range>
 102
 103
 104 %%
 105
 106
 107 /* `number_range' list elements are stored in reversed order; */
 108 /* the call to `TA_deltas_new' fixes this */
 109 /* (`Deltas' list elements are stored in reversed order, too, */
 110 /* but they don't need to be sorted so we don't care */
 111
 112 start:
 113   input
 114     { context->result = $input; }
 115 ;
 116
 117 input[result]:
 118   /* empty */
 119     { $result = NULL; }
 120 | input[left] entry
 121     { $result = TA_deltas_prepend($left, $entry); }
 122 ;
 123
 124 entry:
 125   EOE
 126     { $entry = NULL; }
 127 | font_idx glyph_idx point_set x_shift y_shift ppem_set EOE
 128     {
 129       $entry = TA_deltas_new($font_idx,
 130                              $glyph_idx,
 131                              $point_set,
 132                              $x_shift,
 133                              $y_shift,
 134                              $ppem_set);
 135       if (!$entry)
 136       {
 137         store_error_data(&@$, context, TA_Err_Deltas_Allocation_Error);
 138         YYABORT;
 139       }
 140     }
 141 ;
 142
 143 font_idx:
 144   /* empty */
 145     {
 146       $font_idx = 0;
 147       context->font_idx = $font_idx;
 148     }
 149 | integer
 150     {
 151       $font_idx = $integer;
 152       if ($font_idx >= context->font->num_sfnts)
 153       {
 154         store_error_data(&@$, context, TA_Err_Deltas_Invalid_Font_Index);
 155         YYABORT;
 156       }
 157       context->font_idx = $font_idx;
 158     }
 159 ;
 160
 161 glyph_idx:
 162   integer
 163     {
 164       FT_Face face = context->font->sfnts[context->font_idx].face;
 165
 166
 167       $glyph_idx = $integer;
 168       if ($glyph_idx >= face->num_glyphs)
 169       {
 170         store_error_data(&@$, context, TA_Err_Deltas_Invalid_Glyph_Index);
 171         YYABORT;
 172       }
 173       context->glyph_idx = $glyph_idx;
 174     }
 175 | glyph_name
 176     {
 177       FT_Face face = context->font->sfnts[context->font_idx].face;
 178
 179
 180       /* explicitly compare with `.notdef' */
 181       /* since `FT_Get_Name_Index' returns glyph index 0 */
 182       /* for both this glyph name and invalid ones */
 183       if (!strcmp($glyph_name, ".notdef"))
 184         $glyph_idx = 0;
 185       else
 186       {
 187         $glyph_idx = FT_Get_Name_Index(face, $glyph_name);
 188         if ($glyph_idx == 0)
 189           $glyph_idx = -1;
 190       }
 191
 192       free($glyph_name);
 193
 194       if ($glyph_idx < 0)
 195       {
 196         store_error_data(&@$, context, TA_Err_Deltas_Invalid_Glyph_Name);
 197         YYABORT;
 198       }
 199       context->glyph_idx = $glyph_idx;
 200     }
 201 ;
 202
 203 glyph_name:
 204   'p'
 205     {
 206       $glyph_name = strdup("p");
 207       if ($glyph_name)
 208       {
 209         store_error_data(&@$, context, TA_Err_Deltas_Allocation_Error);
 210         YYABORT;
 211       }
 212     }
 213 | 'x'
 214     {
 215       $glyph_name = strdup("x");
 216       if ($glyph_name)
 217       {
 218         store_error_data(&@$, context, TA_Err_Deltas_Allocation_Error);
 219         YYABORT;
 220       }
 221     }
 222 | 'y'
 223     {
 224       $glyph_name = strdup("y");
 225       if ($glyph_name)
 226       {
 227         store_error_data(&@$, context, TA_Err_Deltas_Allocation_Error);
 228         YYABORT;
 229       }
 230     }
 231 | NAME
 232     {
 233       /* `$NAME' was allocated in the lexer */
 234       $glyph_name = $NAME;
 235     }
 236 | BAD_NAME
 237     {
 238       $glyph_name = $BAD_NAME;
 239       YYABORT;
 240     }
 241 ;
 242
 243 point_set:
 244   'p'
 245     {
 246       FT_Error error;
 247       FT_Face face = context->font->sfnts[context->font_idx].face;
 248       int num_points;
 249
 250
 251       error = FT_Load_Glyph(face, context->glyph_idx, FT_LOAD_NO_SCALE);
 252       if (error)
 253       {
 254         store_error_data(&@$, context, TA_Err_Deltas_Invalid_Glyph);
 255         YYABORT;
 256       }
 257
 258       num_points = face->glyph->outline.n_points;
 259
 260       context->number_set_min = 0;
 261       context->number_set_max = num_points - 1;
 262     }
 263   number_set
 264     { $point_set = $number_set; }
 265 ;
 266
 267 x_shift:
 268   /* empty */
 269     { $x_shift = 0; }
 270 | 'x' shift
 271     { $x_shift = $shift; }
 272 ;
 273
 274 y_shift:
 275   /* empty */
 276     { $y_shift = 0; }
 277 | 'y' shift
 278     { $y_shift = $shift; }
 279 ;
 280
 281 shift:
 282   real
 283     {
 284       if ($real < DELTA_SHIFT_MIN || $real > DELTA_SHIFT_MAX)
 285       {
 286         store_error_data(&@$, context, TA_Err_Deltas_Invalid_Shift);
 287         YYABORT;
 288       }
 289       $shift = $real;
 290     }
 291 ;
 292
 293 ppem_set:
 294   '@'
 295     {
 296       context->number_set_min = DELTA_PPEM_MIN;
 297       context->number_set_max = DELTA_PPEM_MAX;
 298     }
 299   number_set
 300     { $ppem_set = $number_set; }
 301 ;
 302
 303 integer:
 304   '0'
 305     { $integer = 0; }
 306 | INTEGER
 307     { $integer = $INTEGER; }
 308 | BAD_INTEGER
 309     {
 310       $integer = $BAD_INTEGER;
 311       YYABORT;
 312     }
 313 ;
 314
 315 real:
 316   integer
 317     { $real = $integer; }
 318 | '+' integer
 319     { $real = $integer; }
 320 | '-' integer
 321     { $real = -$integer; }
 322 | REAL
 323     { $real = $REAL; }
 324 | '+' REAL
 325     { $real = $REAL; }
 326 | '-' REAL
 327     { $real = -$REAL; }
 328 | BAD_REAL
 329     {
 330       $real = $BAD_REAL;
 331       YYABORT;
 332     }
 333 | '+' BAD_REAL
 334     {
 335       $real = $BAD_REAL;
 336       YYABORT;
 337     }
 338 | '-' BAD_REAL
 339     {
 340       $real = -$BAD_REAL;
 341       YYABORT;
 342     }
 343 ;
 344
 345 number_set:
 346   unlimited
 347     { $number_set = $unlimited; }
 348 | right_limited
 349     { $number_set = $right_limited; }
 350 | left_limited
 351     { $number_set = $left_limited; }
 352 | range_elems
 353     { $number_set = $range_elems; }
 354 | right_limited ',' range_elems
 355     {
 356       $number_set = number_set_prepend($right_limited, $range_elems);
 357       if ($number_set == NUMBERSET_NOT_ASCENDING)
 358       {
 359         number_set_free($right_limited);
 360         number_set_free($range_elems);
 361         store_error_data(&@$, context, TA_Err_Deltas_Ranges_Not_Ascending);
 362         YYABORT;
 363       }
 364       if ($number_set == NUMBERSET_OVERLAPPING_RANGES)
 365       {
 366         number_set_free($right_limited);
 367         number_set_free($range_elems);
 368         store_error_data(&@$, context, TA_Err_Deltas_Overlapping_Ranges);
 369         YYABORT;
 370       }
 371     }
 372 | range_elems ',' left_limited
 373     {
 374       $number_set = number_set_prepend($range_elems, $left_limited);
 375       if ($number_set == NUMBERSET_NOT_ASCENDING)
 376       {
 377         number_set_free($range_elems);
 378         number_set_free($left_limited);
 379         store_error_data(&@$, context, TA_Err_Deltas_Ranges_Not_Ascending);
 380         YYABORT;
 381       }
 382       if ($number_set == NUMBERSET_OVERLAPPING_RANGES)
 383       {
 384         number_set_free($range_elems);
 385         number_set_free($left_limited);
 386         store_error_data(&@$, context, TA_Err_Deltas_Overlapping_Ranges);
 387         YYABORT;
 388       }
 389     }
 390 ;
 391
 392 unlimited:
 393   '-'
 394     {
 395       $unlimited = number_set_new(context->number_set_min,
 396                                   context->number_set_max,
 397                                   context->number_set_min,
 398                                   context->number_set_max);
 399       /* range of `$unlimited' is always valid */
 400       if ($unlimited == NUMBERSET_ALLOCATION_ERROR)
 401       {
 402         store_error_data(&@$, context, TA_Err_Deltas_Allocation_Error);
 403         YYABORT;
 404       }
 405     }
 406 ;
 407
 408 right_limited:
 409   '-' integer
 410     {
 411       $right_limited = number_set_new(context->number_set_min,
 412                                       $integer,
 413                                       context->number_set_min,
 414                                       context->number_set_max);
 415       if ($right_limited == NUMBERSET_INVALID_RANGE)
 416       {
 417         store_error_data(&@$, context, TA_Err_Deltas_Invalid_Range);
 418         YYABORT;
 419       }
 420       if ($right_limited == NUMBERSET_ALLOCATION_ERROR)
 421       {
 422         store_error_data(&@$, context, TA_Err_Deltas_Allocation_Error);
 423         YYABORT;
 424       }
 425     }
 426 ;
 427
 428 left_limited:
 429   integer '-'
 430     {
 431       $left_limited = number_set_new($integer,
 432                                      context->number_set_max,
 433                                      context->number_set_min,
 434                                      context->number_set_max);
 435       if ($left_limited == NUMBERSET_INVALID_RANGE)
 436       {
 437         store_error_data(&@$, context, TA_Err_Deltas_Invalid_Range);
 438         YYABORT;
 439       }
 440       if ($left_limited == NUMBERSET_ALLOCATION_ERROR)
 441       {
 442         store_error_data(&@$, context, TA_Err_Deltas_Allocation_Error);
 443         YYABORT;
 444       }
 445     }
 446 ;
 447
 448 range_elems[result]:
 449   range_elem
 450     { $result = $range_elem; }
 451 | range_elems[left] ',' range_elem
 452     {
 453       $result = number_set_prepend($left, $range_elem);
 454       if ($result == NUMBERSET_NOT_ASCENDING)
 455       {
 456         number_set_free($left);
 457         number_set_free($range_elem);
 458         store_error_data(&@$, context, TA_Err_Deltas_Ranges_Not_Ascending);
 459         YYABORT;
 460       }
 461       if ($result == NUMBERSET_OVERLAPPING_RANGES)
 462       {
 463         number_set_free($left);
 464         number_set_free($range_elem);
 465         store_error_data(&@$, context, TA_Err_Deltas_Overlapping_Ranges);
 466         YYABORT;
 467       }
 468     }
 469 ;
 470
 471 range_elem:
 472   integer
 473     {
 474       $range_elem = number_set_new($integer,
 475                                    $integer,
 476                                    context->number_set_min,
 477                                    context->number_set_max);
 478       if ($range_elem == NUMBERSET_INVALID_RANGE)
 479       {
 480         store_error_data(&@$, context, TA_Err_Deltas_Invalid_Range);
 481         YYABORT;
 482       }
 483       if ($range_elem == NUMBERSET_ALLOCATION_ERROR)
 484       {
 485         store_error_data(&@$, context, TA_Err_Deltas_Allocation_Error);
 486         YYABORT;
 487       }
 488     }
 489 | range
 490     { $range_elem = $range; }
 491 ;
 492
 493 range:
 494   integer[left] '-' integer[right]
 495     {
 496       $range = number_set_new($left,
 497                               $right,
 498                               context->number_set_min,
 499                               context->number_set_max);
 500       if ($range == NUMBERSET_INVALID_RANGE)
 501       {
 502         store_error_data(&@$, context, TA_Err_Deltas_Invalid_Range);
 503         YYABORT;
 504       }
 505       if ($range == NUMBERSET_ALLOCATION_ERROR)
 506       {
 507         store_error_data(&@$, context, TA_Err_Deltas_Allocation_Error);
 508         YYABORT;
 509       }
 510     }
 511 ;
 512
 513
 514 %%
 515
 516
 517 void
 518 TA_deltas_error(YYLTYPE *locp,
 519                 Deltas_Context* context,
 520                 char const* msg)
 521 {
 522   context->error = TA_Err_Deltas_Syntax_Error;
 523
 524   context->errline_num = locp->first_line;
 525   context->errline_pos_left = locp->first_column;
 526   context->errline_pos_right = locp->last_column;
 527
 528   strncpy(context->errmsg, msg, sizeof (context->errmsg));
 529 }
 530
 531
 532 void
 533 store_error_data(YYLTYPE *locp,
 534                  Deltas_Context* context,
 535                  TA_Error error)
 536 {
 537   context->error = error;
 538
 539   context->errline_num = locp->first_line;
 540   context->errline_pos_left = locp->first_column;
 541   context->errline_pos_right = locp->last_column;
 542
 543   context->errmsg[0] = '\0';
 544 }
 545
 546
 547 #if 1
 548
 549 const char* input =
 550   "# Test\n"
 551   "\n"
 552   "# 0 a p 1-3 x 0.3 y -0.2 @ 20-30; \\\n"
 553   "0 exclam p 2-4 x 0.7 y -0.4 @ 6,7,9,10,11; \\\n"
 554   "a p 12345678901234567890 x 0.5 @ 23-25";
 555
 556
 557 #undef scanner
 558
 559 int
 560 main(int argc,
 561      char** argv)
 562 {
 563   TA_Error error;
 564   Deltas_Context context;
 565   FONT font;
 566   SFNT sfnts[1];
 567   FT_Library library;
 568   FT_Face face;
 569   const char* filename;
 570
 571
 572   if (argc != 2)
 573   {
 574     fprintf(stderr, "need an outline font as an argument\n");
 575     exit(EXIT_FAILURE);
 576   }
 577
 578   filename = argv[1];
 579
 580   error = FT_Init_FreeType(&library);
 581   if (error)
 582   {
 583     fprintf(stderr, "error while initializing FreeType library (0x%X)\n",
 584                     error);
 585     exit(EXIT_FAILURE);
 586   }
 587
 588   error = FT_New_Face(library, filename, 0, &face);
 589   if (error)
 590   {
 591     fprintf(stderr, "error while loading font `%s' (0x%X)\n",
 592                     filename,
 593                     error);
 594     exit(EXIT_FAILURE);
 595   }
 596
 597   /* we construct a minumum Deltas_Context */
 598   sfnts[0].face = face;
 599
 600   font.num_sfnts = 1;
 601   font.sfnts = sfnts;
 602
 603   context.font = &font;
 604
 605   TA_deltas_debug = 1;
 606   error = TA_deltas_scanner_init(&context, input);
 607   if (error)
 608     return 0;
 609   TA_deltas_parse(&context);
 610   TA_deltas_scanner_done(&context);
 611
 612   TA_deltas_free(context.result);
 613
 614   FT_Done_Face(face);
 615   FT_Done_FreeType(library);
 616
 617   return 0;
 618 }
 619
 620 #endif
 621
 622 /* end of tadeltas.y */