lib/tacontrol.bison

   1 /* tacontrol.bison */
   2
   3 /*
   4  * Copyright (C) 2014-2016 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 /*
  17  * grammar for parsing ttfautohint control instructions
  18  *
  19  * Parsing errors that essentially belong to the lexing stage are handled
  20  * with `store_error_data'; in case the lexer detects an error, it returns
  21  * the right token type but sets `context->error'.  Syntax errors and fatal
  22  * lexer errors (token `INTERNAL_FLEX_ERROR') are handled with
  23  * `TA_control_error'.
  24  */
  25
  26 /*
  27  * Edsko de Vries's article `Writing a Reentrant Parser with Flex and Bison'
  28  * (http://www.phpcompiler.org/articles/reentrantparser.html)
  29  * was extremely helpful in writing this code.
  30  */
  31
  32 %require "2.5" /* we use named references */
  33
  34 %output "tacontrol-bison.c"
  35 %defines "tacontrol-bison.h"
  36
  37 %define api.pure
  38 %error-verbose
  39 %expect 7
  40 %glr-parser
  41 %lex-param { void* scanner }
  42 %locations
  43 %name-prefix "TA_control_"
  44 %parse-param { Control_Context* context }
  45
  46 %code requires {
  47 #include "ta.h"
  48 #include "tashaper.h"
  49
  50 /* we don't change the name prefix of flex functions */
  51 #define TA_control_lex yylex
  52 }
  53
  54 %union {
  55   char character;
  56   Control_Type type;
  57   long integer;
  58   char* name;
  59   number_range* range;
  60   double real;
  61   Control* control;
  62 }
  63
  64 %{
  65 #include <limits.h>
  66 #include "tacontrol-flex.h"
  67
  68 void
  69 TA_control_error(YYLTYPE *locp,
  70                  Control_Context* context,
  71                  char const* msg);
  72
  73 void
  74 store_error_data(const YYLTYPE *locp,
  75                  Control_Context* context,
  76                  TA_Error error);
  77
  78
  79 /* calls to `yylex' in the generated bison code use `scanner' directly */
  80 #define scanner context->scanner
  81 %}
  82
  83 /* INVALID_CHARACTER and INTERNAL_FLEX_ERROR are flex errors */
  84 %token EOE
  85 %token <integer> INTEGER "integer number"
  86 %token INTERNAL_FLEX_ERROR "internal flex error"
  87 %token <character> INVALID_CHARACTER "invalid character"
  88 %token <name> LEFT "left"
  89 %token <name> NAME "glyph name"
  90 %token <name> NODIR "no direction"
  91 %token <name> POINT "point"
  92 %token <real> REAL "real number"
  93 %token <name> RIGHT "right"
  94 %token <name> TOUCH "touch"
  95 %token <name> XSHIFT "x shift"
  96 %token <name> YSHIFT "y shift"
  97
  98 %type <control> entry
  99 %type <integer> font_idx
 100 %type <integer> glyph_idx
 101 %type <range> glyph_idx_range
 102 %type <range> glyph_idx_range_elem
 103 %type <range> glyph_idx_range_elems
 104 %type <range> glyph_idx_set
 105 %type <name> glyph_name
 106 %type <name> glyph_name_
 107 %type <control> input
 108 %type <integer> integer
 109 %type <type> left_right
 110 %type <type> left_right_
 111 %type <type> point_touch
 112 %type <type> point_touch_
 113 %type <range> left_limited
 114 %type <type> no_dir
 115 %type <range> number_set
 116 %type <integer> offset
 117 %type <range> ppem_set
 118 %type <range> range
 119 %type <range> range_elem
 120 %type <range> range_elems
 121 %type <real> real
 122 %type <range> right_limited
 123 %type <integer> script_feature
 124 %type <real> shift
 125 %type <integer> signed_integer
 126 %type <range> unlimited
 127 %type <real> x_shift
 128 %type <real> y_shift
 129
 130 %destructor { TA_control_free($$); } <control>
 131 %destructor { number_set_free($$); } <range>
 132
 133 %printer { fprintf(yyoutput, "`%ld'", $$); } <integer>
 134 %printer { fprintf(yyoutput, "`%s'", $$); } <name>
 135 %printer { fprintf(yyoutput, "`%g'", $$); } <real>
 136 %printer {
 137            char* s;
 138            number_range* nr;
 139
 140
 141            nr = number_set_reverse($$);
 142            s = number_set_show(nr, -1, -1);
 143            (void)number_set_reverse(nr);
 144            if (s)
 145            {
 146              fprintf(yyoutput, "`%s'", s);
 147              free(s);
 148            }
 149            else
 150              fprintf(yyoutput, "allocation error");
 151          } <range>
 152 %printer { fprintf(yyoutput, "`%c'", $$); } INVALID_CHARACTER
 153
 154 %%
 155
 156
 157 /* `number_range' list elements are stored in reversed order; */
 158 /* the call to `TA_control_new' fixes this */
 159
 160 /* `Control' list elements are stored in reversed order, too; */
 161 /* this gets fixed by an explicit call to `TA_control_reverse' */
 162
 163 start:
 164   input
 165     { context->result = TA_control_reverse($input); }
 166 ;
 167
 168 input[result]:
 169   /* empty */
 170     { $result = NULL; }
 171 | input[left] entry
 172     { $result = TA_control_prepend($left, $entry); }
 173 ;
 174
 175 entry:
 176   EOE
 177     { $entry = NULL; }
 178 | font_idx glyph_idx point_touch number_set x_shift y_shift ppem_set EOE
 179     {
 180       $entry = TA_control_new($point_touch,
 181                               $font_idx,
 182                               $glyph_idx,
 183                               $number_set,
 184                               $x_shift,
 185                               $y_shift,
 186                               $ppem_set);
 187       if (!$entry)
 188       {
 189         store_error_data(&@$, context, TA_Err_Control_Allocation_Error);
 190         YYABORT;
 191       }
 192     }
 193 | font_idx glyph_idx left_right number_set EOE
 194     {
 195       $entry = TA_control_new($left_right,
 196                               $font_idx,
 197                               $glyph_idx,
 198                               $number_set,
 199                               0,
 200                               0,
 201                               NULL);
 202       if (!$entry)
 203       {
 204         store_error_data(&@$, context, TA_Err_Control_Allocation_Error);
 205         YYABORT;
 206       }
 207     }
 208 | font_idx glyph_idx left_right number_set '(' offset[left] ',' offset[right] ')' EOE
 209     {
 210       $entry = TA_control_new($left_right,
 211                               $font_idx,
 212                               $glyph_idx,
 213                               $number_set,
 214                               $left,
 215                               $right,
 216                               NULL);
 217       if (!$entry)
 218       {
 219         store_error_data(&@$, context, TA_Err_Control_Allocation_Error);
 220         YYABORT;
 221       }
 222     }
 223 | font_idx glyph_idx no_dir number_set EOE
 224     {
 225       $entry = TA_control_new($no_dir,
 226                               $font_idx,
 227                               $glyph_idx,
 228                               $number_set,
 229                               0,
 230                               0,
 231                               NULL);
 232       if (!$entry)
 233       {
 234         store_error_data(&@$, context, TA_Err_Control_Allocation_Error);
 235         YYABORT;
 236       }
 237     }
 238 | font_idx script_feature glyph_idx_set EOE
 239     {
 240       $entry = TA_control_new(Control_Script_Feature,
 241                               $font_idx,
 242                               $script_feature,
 243                               $glyph_idx_set,
 244                               0,
 245                               0,
 246                               NULL);
 247       if (!$entry)
 248       {
 249         store_error_data(&@$, context, TA_Err_Control_Allocation_Error);
 250         YYABORT;
 251       }
 252     }
 253 ;
 254
 255 font_idx:
 256   /* empty */
 257     {
 258       $font_idx = 0;
 259       context->font_idx = $font_idx;
 260     }
 261 | integer
 262     {
 263       $font_idx = $integer;
 264       if ($font_idx >= context->font->num_sfnts)
 265       {
 266         store_error_data(&@$, context, TA_Err_Control_Invalid_Font_Index);
 267         YYABORT;
 268       }
 269       context->font_idx = $font_idx;
 270     }
 271 ;
 272
 273 glyph_idx:
 274   integer
 275     {
 276       FT_Face face = context->font->sfnts[context->font_idx].face;
 277
 278
 279       $glyph_idx = $integer;
 280       if ($glyph_idx >= face->num_glyphs)
 281       {
 282         store_error_data(&@$, context, TA_Err_Control_Invalid_Glyph_Index);
 283         YYABORT;
 284       }
 285       context->glyph_idx = $glyph_idx;
 286     }
 287 | glyph_name
 288     {
 289       FT_Face face = context->font->sfnts[context->font_idx].face;
 290
 291
 292       /* explicitly compare with `.notdef' */
 293       /* since `FT_Get_Name_Index' returns glyph index 0 */
 294       /* for both this glyph name and invalid ones */
 295       if (!strcmp($glyph_name, ".notdef"))
 296         $glyph_idx = 0;
 297       else
 298       {
 299         $glyph_idx = (long)FT_Get_Name_Index(face, $glyph_name);
 300         if ($glyph_idx == 0)
 301           $glyph_idx = -1;
 302       }
 303
 304       free($glyph_name);
 305
 306       if ($glyph_idx < 0)
 307       {
 308         store_error_data(&@$, context, TA_Err_Control_Invalid_Glyph_Name);
 309         YYABORT;
 310       }
 311       context->glyph_idx = $glyph_idx;
 312     }
 313 ;
 314
 315 glyph_name:
 316   glyph_name_
 317     {
 318       /* `$glyph_name_' was allocated in the lexer */
 319       if (context->error)
 320       {
 321         /* lexing error */
 322         store_error_data(&@$, context, context->error);
 323         YYABORT;
 324       }
 325
 326       $glyph_name = $glyph_name_;
 327     }
 328 ;
 329
 330 glyph_name_:
 331   LEFT
 332 | NAME
 333 | NODIR
 334 | POINT
 335 | RIGHT
 336 | TOUCH
 337 | XSHIFT
 338 | YSHIFT
 339 ;
 340
 341 point_touch:
 342   point_touch_
 343     {
 344       FT_Error error;
 345       FT_Face face = context->font->sfnts[context->font_idx].face;
 346       int num_points;
 347
 348
 349       error = FT_Load_Glyph(face,
 350                             (FT_UInt)context->glyph_idx,
 351                             FT_LOAD_NO_SCALE);
 352       if (error)
 353       {
 354         store_error_data(&@$, context, TA_Err_Control_Invalid_Glyph);
 355         YYABORT;
 356       }
 357
 358       num_points = face->glyph->outline.n_points;
 359
 360       context->number_set_min = 0;
 361       context->number_set_max = num_points - 1;
 362
 363       $point_touch = $point_touch_;
 364     }
 365 ;
 366
 367 point_touch_:
 368   POINT
 369     {
 370       $point_touch_ = Control_Delta_after_IUP;
 371       free($POINT);
 372     }
 373 | TOUCH
 374     {
 375       $point_touch_ = Control_Delta_before_IUP;
 376       free($TOUCH);
 377     }
 378 ;
 379
 380 left_right:
 381   left_right_
 382     {
 383       FT_Error error;
 384       FT_Face face = context->font->sfnts[context->font_idx].face;
 385       int num_points;
 386
 387
 388       error = FT_Load_Glyph(face,
 389                             (FT_UInt)context->glyph_idx,
 390                             FT_LOAD_NO_SCALE);
 391       if (error)
 392       {
 393         store_error_data(&@$, context, TA_Err_Control_Invalid_Glyph);
 394         YYABORT;
 395       }
 396
 397       num_points = face->glyph->outline.n_points;
 398
 399       context->number_set_min = 0;
 400       context->number_set_max = num_points - 1;
 401
 402       $left_right = $left_right_;
 403     }
 404 ;
 405
 406 left_right_:
 407   LEFT
 408     {
 409       $left_right_ = Control_Segment_Left;
 410       free($LEFT);
 411     }
 412 | RIGHT
 413     {
 414       $left_right_ = Control_Segment_Right;
 415       free($RIGHT);
 416     }
 417 ;
 418
 419 no_dir:
 420   NODIR
 421     {
 422       FT_Error error;
 423       FT_Face face = context->font->sfnts[context->font_idx].face;
 424       int num_points;
 425
 426
 427       error = FT_Load_Glyph(face,
 428                             (FT_UInt)context->glyph_idx,
 429                             FT_LOAD_NO_SCALE);
 430       if (error)
 431       {
 432         store_error_data(&@$, context, TA_Err_Control_Invalid_Glyph);
 433         YYABORT;
 434       }
 435
 436       num_points = face->glyph->outline.n_points;
 437
 438       context->number_set_min = 0;
 439       context->number_set_max = num_points - 1;
 440
 441       $no_dir = Control_Segment_None;
 442       free($NODIR);
 443     }
 444 ;
 445
 446 script_feature:
 447   glyph_name[script] glyph_name[feature]
 448     {
 449       long ss;
 450       size_t i, j;
 451       size_t script_idx = 0;
 452       size_t feature_idx = 0;
 453       char feature_name[5];
 454
 455
 456       for (i = 0; i < script_names_size; i++)
 457       {
 458         if (!strcmp($script, script_names[i]))
 459         {
 460           script_idx = i;
 461           break;
 462         }
 463       }
 464
 465       feature_name[4] = '\0';
 466
 467       for (j = 0; j < feature_tags_size; j++)
 468       {
 469         hb_tag_to_string(feature_tags[j], feature_name);
 470
 471         if (!strcmp($feature, feature_name))
 472         {
 473           feature_idx = j;
 474           break;
 475         }
 476       }
 477
 478       free($script);
 479       free($feature);
 480
 481       if (i == script_names_size)
 482       {
 483         store_error_data(&@1, context, TA_Err_Control_Invalid_Script);
 484         YYABORT;
 485       }
 486       if (j == feature_tags_size)
 487       {
 488         store_error_data(&@2, context, TA_Err_Control_Invalid_Feature);
 489         YYABORT;
 490       }
 491
 492       for (ss = 0; ta_style_classes[ss]; ss++)
 493       {
 494         TA_StyleClass style_class = ta_style_classes[ss];
 495
 496
 497         if (script_idx == style_class->script
 498             && feature_idx == style_class->coverage)
 499         {
 500           $script_feature = ss;
 501           break;
 502         }
 503       }
 504       if (!ta_style_classes[ss])
 505       {
 506         store_error_data(&@$, context, TA_Err_Control_Invalid_Style);
 507         YYABORT;
 508       }
 509     }
 510 ;
 511
 512
 513 x_shift:
 514   /* empty */
 515     { $x_shift = 0; }
 516 | XSHIFT shift
 517     {
 518       $x_shift = $shift;
 519       free($XSHIFT);
 520     }
 521 ;
 522
 523 y_shift:
 524   /* empty */
 525     { $y_shift = 0; }
 526 | YSHIFT shift
 527     {
 528       $y_shift = $shift;
 529       free($YSHIFT);
 530     }
 531 ;
 532
 533 shift:
 534   real
 535     {
 536       if ($real < CONTROL_DELTA_SHIFT_MIN || $real > CONTROL_DELTA_SHIFT_MAX)
 537       {
 538         store_error_data(&@$, context, TA_Err_Control_Invalid_Shift);
 539         YYABORT;
 540       }
 541       $shift = $real;
 542     }
 543 ;
 544
 545 offset:
 546   signed_integer
 547     {
 548       if ($signed_integer < SHRT_MIN || $signed_integer > SHRT_MAX)
 549       {
 550         store_error_data(&@$, context, TA_Err_Control_Invalid_Offset);
 551         YYABORT;
 552       }
 553       $offset = $signed_integer;
 554     }
 555 ;
 556
 557 ppem_set:
 558   '@'
 559     {
 560       context->number_set_min = CONTROL_DELTA_PPEM_MIN;
 561       context->number_set_max = CONTROL_DELTA_PPEM_MAX;
 562     }
 563   number_set
 564     { $ppem_set = $number_set; }
 565 ;
 566
 567 integer:
 568   '0'
 569     { $integer = 0; }
 570 | INTEGER
 571     {
 572       if (context->error)
 573       {
 574         /* lexing error */
 575         store_error_data(&@$, context, context->error);
 576         YYABORT;
 577       }
 578
 579       $integer = $INTEGER;
 580     }
 581 ;
 582
 583 signed_integer:
 584   integer
 585     { $signed_integer = $integer; }
 586 | '+' integer
 587     { $signed_integer = $integer; }
 588 | '-' integer
 589     { $signed_integer = -$integer; }
 590 ;
 591
 592 real:
 593   signed_integer
 594     { $real = $signed_integer; }
 595 | REAL
 596     {
 597       if (context->error)
 598       {
 599         /* lexing error */
 600         store_error_data(&@$, context, context->error);
 601         YYABORT;
 602       }
 603
 604       $real = $REAL;
 605     }
 606 | '+' REAL
 607     { $real = $REAL; }
 608 | '-' REAL
 609     { $real = -$REAL; }
 610 ;
 611
 612 number_set:
 613   unlimited
 614     { $number_set = $unlimited; }
 615 | right_limited
 616     { $number_set = $right_limited; }
 617 | left_limited
 618     { $number_set = $left_limited; }
 619 | range_elems
 620     { $number_set = $range_elems; }
 621 | right_limited ',' range_elems
 622     {
 623       $number_set = number_set_prepend($right_limited, $range_elems);
 624       if ($number_set == NUMBERSET_NOT_ASCENDING)
 625       {
 626         number_set_free($right_limited);
 627         number_set_free($range_elems);
 628         store_error_data(&@3, context, TA_Err_Control_Ranges_Not_Ascending);
 629         YYABORT;
 630       }
 631       if ($number_set == NUMBERSET_OVERLAPPING_RANGES)
 632       {
 633         number_set_free($right_limited);
 634         number_set_free($range_elems);
 635         store_error_data(&@3, context, TA_Err_Control_Overlapping_Ranges);
 636         YYABORT;
 637       }
 638     }
 639 | range_elems ',' left_limited
 640     {
 641       $number_set = number_set_prepend($range_elems, $left_limited);
 642       if ($number_set == NUMBERSET_NOT_ASCENDING)
 643       {
 644         number_set_free($range_elems);
 645         number_set_free($left_limited);
 646         store_error_data(&@3, context, TA_Err_Control_Ranges_Not_Ascending);
 647         YYABORT;
 648       }
 649       if ($number_set == NUMBERSET_OVERLAPPING_RANGES)
 650       {
 651         number_set_free($range_elems);
 652         number_set_free($left_limited);
 653         store_error_data(&@3, context, TA_Err_Control_Overlapping_Ranges);
 654         YYABORT;
 655       }
 656     }
 657 ;
 658
 659 unlimited:
 660   '-'
 661     {
 662       $unlimited = number_set_new(context->number_set_min,
 663                                   context->number_set_max,
 664                                   context->number_set_min,
 665                                   context->number_set_max);
 666       /* range of `$unlimited' is always valid */
 667       if ($unlimited == NUMBERSET_ALLOCATION_ERROR)
 668       {
 669         store_error_data(&@$, context, TA_Err_Control_Allocation_Error);
 670         YYABORT;
 671       }
 672     }
 673 ;
 674
 675 right_limited:
 676   '-' integer
 677     {
 678       $right_limited = number_set_new(context->number_set_min,
 679                                       $integer,
 680                                       context->number_set_min,
 681                                       context->number_set_max);
 682       if ($right_limited == NUMBERSET_INVALID_RANGE)
 683       {
 684         store_error_data(&@$, context, TA_Err_Control_Invalid_Range);
 685         YYABORT;
 686       }
 687       if ($right_limited == NUMBERSET_ALLOCATION_ERROR)
 688       {
 689         store_error_data(&@$, context, TA_Err_Control_Allocation_Error);
 690         YYABORT;
 691       }
 692     }
 693 ;
 694
 695 left_limited:
 696   integer '-'
 697     {
 698       $left_limited = number_set_new($integer,
 699                                      context->number_set_max,
 700                                      context->number_set_min,
 701                                      context->number_set_max);
 702       if ($left_limited == NUMBERSET_INVALID_RANGE)
 703       {
 704         store_error_data(&@$, context, TA_Err_Control_Invalid_Range);
 705         YYABORT;
 706       }
 707       if ($left_limited == NUMBERSET_ALLOCATION_ERROR)
 708       {
 709         store_error_data(&@$, context, TA_Err_Control_Allocation_Error);
 710         YYABORT;
 711       }
 712     }
 713 ;
 714
 715 range_elems[result]:
 716   range_elem
 717     { $result = $range_elem; }
 718 | range_elems[left] ',' range_elem
 719     {
 720       $result = number_set_prepend($left, $range_elem);
 721       if ($result == NUMBERSET_NOT_ASCENDING)
 722       {
 723         number_set_free($left);
 724         number_set_free($range_elem);
 725         store_error_data(&@3, context, TA_Err_Control_Ranges_Not_Ascending);
 726         YYABORT;
 727       }
 728       if ($result == NUMBERSET_OVERLAPPING_RANGES)
 729       {
 730         number_set_free($left);
 731         number_set_free($range_elem);
 732         store_error_data(&@3, context, TA_Err_Control_Overlapping_Ranges);
 733         YYABORT;
 734       }
 735     }
 736 ;
 737
 738 range_elem:
 739   integer
 740     {
 741       $range_elem = number_set_new($integer,
 742                                    $integer,
 743                                    context->number_set_min,
 744                                    context->number_set_max);
 745       if ($range_elem == NUMBERSET_INVALID_RANGE)
 746       {
 747         store_error_data(&@$, context, TA_Err_Control_Invalid_Range);
 748         YYABORT;
 749       }
 750       if ($range_elem == NUMBERSET_ALLOCATION_ERROR)
 751       {
 752         store_error_data(&@$, context, TA_Err_Control_Allocation_Error);
 753         YYABORT;
 754       }
 755     }
 756 | range
 757     { $range_elem = $range; }
 758 ;
 759
 760 range:
 761   integer[left] '-' integer[right]
 762     {
 763       $range = number_set_new($left,
 764                               $right,
 765                               context->number_set_min,
 766                               context->number_set_max);
 767       if ($range == NUMBERSET_INVALID_RANGE)
 768       {
 769         store_error_data(&@$, context, TA_Err_Control_Invalid_Range);
 770         YYABORT;
 771       }
 772       if ($range == NUMBERSET_ALLOCATION_ERROR)
 773       {
 774         store_error_data(&@$, context, TA_Err_Control_Allocation_Error);
 775         YYABORT;
 776       }
 777     }
 778 ;
 779
 780 glyph_idx_set:
 781   '@'
 782     {
 783       FT_Face face = context->font->sfnts[context->font_idx].face;
 784
 785
 786       context->number_set_min = 0;
 787       context->number_set_max = face->num_glyphs - 1;
 788     }
 789   glyph_idx_range_elems
 790     { $glyph_idx_set = $glyph_idx_range_elems; }
 791 ;
 792
 793 glyph_idx_range_elems[result]:
 794   glyph_idx_range_elem
 795     { $result = $glyph_idx_range_elem; }
 796 | glyph_idx_range_elems[left] ',' glyph_idx_range_elem
 797     {
 798       /* for glyph_idx_set, ascending order is not enforced */
 799       $result = number_set_insert($left, $glyph_idx_range_elem);
 800       if ($result == NUMBERSET_OVERLAPPING_RANGES)
 801       {
 802         number_set_free($left);
 803         number_set_free($glyph_idx_range_elem);
 804         store_error_data(&@3, context, TA_Err_Control_Overlapping_Ranges);
 805         YYABORT;
 806       }
 807     }
 808 ;
 809
 810 glyph_idx_range_elem:
 811   glyph_idx
 812     {
 813       $glyph_idx_range_elem = number_set_new($glyph_idx,
 814                                              $glyph_idx,
 815                                              context->number_set_min,
 816                                              context->number_set_max);
 817       /* glyph_idx is always valid */
 818       /* since its value was already tested for validity */
 819       if ($glyph_idx_range_elem == NUMBERSET_ALLOCATION_ERROR)
 820       {
 821         store_error_data(&@$, context, TA_Err_Control_Allocation_Error);
 822         YYABORT;
 823       }
 824     }
 825 | glyph_idx_range
 826     { $glyph_idx_range_elem = $glyph_idx_range; }
 827 ;
 828
 829 glyph_idx_range:
 830   glyph_idx[left] '-' glyph_idx[right]
 831     {
 832       $glyph_idx_range = number_set_new($left,
 833                                         $right,
 834                                         context->number_set_min,
 835                                         context->number_set_max);
 836       /* glyph range is always valid */
 837       /* since both `glyph_idx' values were already tested for validity */
 838       if ($glyph_idx_range == NUMBERSET_ALLOCATION_ERROR)
 839       {
 840         store_error_data(&@$, context, TA_Err_Control_Allocation_Error);
 841         YYABORT;
 842       }
 843     }
 844 ;
 845
 846
 847 %%
 848
 849
 850 void
 851 TA_control_error(YYLTYPE *locp,
 852                  Control_Context* context,
 853                  char const* msg)
 854 {
 855   /* if `error' is already set, we have a fatal flex error */
 856   if (!context->error)
 857   {
 858     context->error = TA_Err_Control_Syntax_Error;
 859     strncpy(context->errmsg, msg, sizeof (context->errmsg));
 860   }
 861
 862   context->errline_num = locp->first_line;
 863   context->errline_pos_left = locp->first_column;
 864   context->errline_pos_right = locp->last_column;
 865 }
 866
 867
 868 void
 869 store_error_data(const YYLTYPE *locp,
 870                  Control_Context* context,
 871                  TA_Error error)
 872 {
 873   context->error = error;
 874
 875   context->errline_num = locp->first_line;
 876   context->errline_pos_left = locp->first_column;
 877   context->errline_pos_right = locp->last_column;
 878
 879   context->errmsg[0] = '\0';
 880 }
 881
 882
 883 #if 0
 884
 885 /*
 886  * compile this test program with
 887  *
 888  *   make libnumberset.la
 889  *
 890  *   flex -d tacontrol.flex \
 891  *   && bison -t tacontrol.bison \
 892  *   && gcc -g3 -O0 \
 893  *          -Wall -W \
 894  *          -I.. \
 895  *          -I. \
 896  *          -I/usr/local/include/freetype2 \
 897  *          -I/usr/local/include/harfbuzz \
 898  *          -L.libs \
 899  *          -o tacontrol-bison \
 900  *          tacontrol-bison.c \
 901  *          tacontrol-flex.c \
 902  *          tacontrol.c \
 903  *          -lfreetype \
 904  *          -lnumberset
 905  */
 906
 907 const char* input =
 908   "# Test\n"
 909   "\n"
 910   "# 0 a p 1-3 x 0.3 y -0.2 @ 20-30; \\\n"
 911   "0 exclam p 2-4 x 0.7 y -0.4 @ 6,7,9,10,11; \\\n"
 912   "a p / 12 x 0.5 @ 23-25";
 913
 914
 915 #undef scanner
 916
 917 int
 918 main(int argc,
 919      char** argv)
 920 {
 921   TA_Error error;
 922   int bison_error;
 923   int retval = 1;
 924
 925   Control_Context context;
 926   FONT font;
 927   SFNT sfnts[1];
 928   FT_Library library;
 929   FT_Face face;
 930   const char* filename;
 931
 932
 933   if (argc != 2)
 934   {
 935     fprintf(stderr, "need an outline font as an argument\n");
 936     goto Exit0;
 937   }
 938
 939   filename = argv[1];
 940
 941   error = FT_Init_FreeType(&library);
 942   if (error)
 943   {
 944     fprintf(stderr, "error while initializing FreeType library (0x%X)\n",
 945                     error);
 946     goto Exit0;
 947   }
 948
 949   error = FT_New_Face(library, filename, 0, &face);
 950   if (error)
 951   {
 952     fprintf(stderr, "error while loading font `%s' (0x%X)\n",
 953                     filename,
 954                     error);
 955     goto Exit1;
 956   }
 957
 958   /* we construct a minumum `Font' object */
 959   sfnts[0].face = face;
 960
 961   font.num_sfnts = 1;
 962   font.sfnts = sfnts;
 963   font.control_buf = (char*)input;
 964   font.control_len = strlen(input);
 965
 966   TA_control_debug = 1;
 967
 968   TA_control_scanner_init(&context, &font);
 969   if (context.error)
 970     goto Exit2;
 971
 972   bison_error = TA_control_parse(&context);
 973   if (bison_error)
 974     goto Exit3;
 975
 976   retval = 0;
 977
 978 Exit3:
 979   TA_control_scanner_done(&context);
 980   TA_control_free(context.result);
 981
 982 Exit2:
 983   FT_Done_Face(face);
 984
 985 Exit1:
 986   FT_Done_FreeType(library);
 987
 988 Exit0:
 989   return retval;
 990 }
 991
 992 #endif
 993
 994 /* end of tacontrol.bison */