lib/tacontrol.flex

   1 /* tacontrol.flex */
   2
   3 /*
   4  * Copyright (C) 2014-2017 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  * lexical analyzer for parsing ttfautohint control instructions
  17  *
  18  * Lexing errors are indicated by setting `context->error' to an appropriate
  19  * value; fatal lexer errors return token `INTERNAL_FLEX_ERROR'.
  20  */
  21
  22 /* you should use flex version >= 2.5.39 to avoid various buglets */
  23 /* that don't have work-arounds */
  24
  25 %option outfile="tacontrol-flex.c"
  26 %option header-file="tacontrol-flex.h"
  27
  28 %option batch
  29 %option bison-bridge
  30 %option bison-locations
  31 %option never-interactive
  32 %option noinput
  33 %option nounput
  34 %option noyyalloc
  35 %option noyyfree
  36 %option noyyrealloc
  37 %option noyywrap
  38 %option reentrant
  39 %option yylineno
  40
  41
  42 %top {
  43 #include "config.h"
  44 }
  45
  46
  47 %{
  48
  49 #include <stdio.h>
  50 #include <string.h>
  51
  52 #include "ta.h"
  53 #include "tacontrol-bison.h"
  54
  55 /* option `yylineno' resets `yycolumn' to 0 after a newline */
  56 /* (since version 2.5.30, March 2003) before the next token gets read; */
  57 /* note we want both line number and column start with value 1 */
  58
  59 #define YY_USER_ACTION \
  60           yylloc->first_line = yylineno + 1; \
  61           yylloc->last_line = yylineno + 1; \
  62           yylloc->first_column = yycolumn; \
  63           yylloc->last_column = yycolumn + (int)yyleng - 1; \
  64           yycolumn += yyleng;
  65
  66 #define YY_EXTRA_TYPE Control_Context*
  67
  68 #define YY_FATAL_ERROR(msg) TA_control_scanner_fatal_error(msg, yyscanner)
  69
  70 /* by default, `yylex' simply calls `exit' (via YY_FATAL_ERROR) */
  71 /* in case of a (more or less) fatal error -- */
  72 /* this is bad for a library, thus we use `longjmp' to catch this, */
  73 /* together with a proper handler for YY_FATAL_ERROR */
  74
  75 #define YY_USER_INIT \
  76           do \
  77           { \
  78             if (setjmp(yyextra->jump_buffer) != 0) \
  79             { \
  80               /* error and error message in `context' already stored by */ \
  81               /* `TA_control_scanner_fatal_error' */ \
  82               return INTERNAL_FLEX_ERROR; \
  83             } \
  84           } while (0)
  85
  86 /* this macro works around flex bug to suppress a compilation warning, */
  87 /* cf. https://sourceforge.net/p/flex/bugs/115 */
  88
  89 #define YY_EXIT_FAILURE ((void)yyscanner, 2)
  90
  91 #define NAME_ASSIGN \
  92           do \
  93           { \
  94             yylval->name = strdup(yytext); \
  95             if (!yylval->name) \
  96               yyextra->error = TA_Err_Control_Allocation_Error; \
  97           } while (0)
  98
  99 void
 100 TA_control_scanner_fatal_error(const char* msg,
 101                                yyscan_t yyscanner);
 102 %}
 103
 104
 105 %%
 106
 107
 108 (?x: [ \t\f]+
 109 ) {
 110   /* skip whitespace */
 111 }
 112
 113 (?x: ( "\n"
 114      | ";"
 115      )+
 116 ) {
 117   /* end of entry */
 118   return EOE;
 119 }
 120
 121 <<EOF>> {
 122   /* we want an EOE token at end of file, too */
 123   if (!yyextra->eof)
 124   {
 125     yyextra->eof = 1;
 126     return EOE;
 127   }
 128   else
 129     yyterminate();
 130 }
 131
 132 (?x: ( "\\\n"
 133      )+
 134 ) {
 135   /* skip escaped newline */
 136 }
 137
 138 (?x: "#" [^\n]*
 139 ) {
 140   /* skip line comment */
 141 }
 142
 143
 144 (?x: [0+-]
 145 ) {
 146   /* values `0' and `-' need special treatment for number ranges */
 147   return yytext[0];
 148 }
 149
 150 (?x:   [1-9] [0-9]*
 151      | "0" [xX] [0-9a-fA-F]+
 152      | "0" [0-7]+
 153 ) {
 154   /* we don't support localized formats like a thousands separator */
 155   errno = 0;
 156   yylval->integer = strtol(yytext, NULL, 0);
 157   if (errno == ERANGE)
 158   {
 159     /* overflow or underflow */
 160     yyextra->error = TA_Err_Control_Overflow;
 161   }
 162   return INTEGER;
 163 }
 164
 165 (?x:   [0-9]* "." [0-9]+
 166      | [0-9]+ "." [0-9]*
 167 ) {
 168   /* we don't support exponents, */
 169   /* and we don't support localized formats like using `,' instead of `.' */
 170   errno = 0;
 171   yylval->real = strtod(yytext, NULL);
 172   if (yylval->real != 0 && errno == ERANGE)
 173   {
 174     /* overflow */
 175     yyextra->error = TA_Err_Control_Overflow;
 176   }
 177   return REAL;
 178 }
 179
 180
 181 (?x: [@,()]
 182 ) {
 183   /* delimiters */
 184   return yytext[0];
 185 }
 186
 187 (?x:   "point"
 188      | "p"
 189 ) {
 190   NAME_ASSIGN;
 191   return POINT;
 192 }
 193
 194 (?x:   "touch"
 195      | "t"
 196 ) {
 197   NAME_ASSIGN;
 198   return TOUCH;
 199 }
 200
 201 (?x:   "xshift"
 202      | "x"
 203 ) {
 204   NAME_ASSIGN;
 205   return XSHIFT;
 206 }
 207
 208 (?x:   "yshift"
 209      | "y"
 210 ) {
 211   NAME_ASSIGN;
 212   return YSHIFT;
 213 }
 214
 215 (?x:   "left"
 216      | "l"
 217 ) {
 218   NAME_ASSIGN;
 219   return LEFT;
 220 }
 221
 222 (?x:   "right"
 223      | "r"
 224 ) {
 225   NAME_ASSIGN;
 226   return RIGHT;
 227 }
 228
 229 (?x:   "nodir"
 230      | "n"
 231 ) {
 232   NAME_ASSIGN;
 233   return NODIR;
 234 }
 235
 236 (?x: [A-Za-z._] [A-Za-z0-9._]*
 237 ) {
 238   NAME_ASSIGN;
 239   return NAME;
 240 }
 241
 242
 243 (?x: .
 244 ) {
 245   /* invalid input */
 246   yylval->character = yytext[0];
 247   return INVALID_CHARACTER;
 248 }
 249
 250
 251 %%
 252
 253
 254 /* the following two routines set `context->error' */
 255
 256 void*
 257 yyalloc(yy_size_t size,
 258         yyscan_t yyscanner)
 259 {
 260   YY_EXTRA_TYPE context;
 261
 262
 263   void* p = malloc(size);
 264   if (!p && yyscanner)
 265   {
 266     context = yyget_extra(yyscanner);
 267     context->error = TA_Err_Control_Allocation_Error;
 268   }
 269   return p;
 270 }
 271
 272
 273 void*
 274 yyrealloc(void* ptr,
 275           yy_size_t size,
 276           yyscan_t yyscanner)
 277 {
 278   YY_EXTRA_TYPE context;
 279
 280
 281   void* p = realloc(ptr, size);
 282   if (!p && yyscanner)
 283   {
 284     context = yyget_extra(yyscanner);
 285     context->error = TA_Err_Control_Allocation_Error;
 286   }
 287   return p;
 288 }
 289
 290
 291 /* we reimplement this routine also to avoid a compiler warning, */
 292 /* cf. https://sourceforge.net/p/flex/bugs/115 */
 293 void
 294 yyfree(void* ptr,
 295        yyscan_t yyscanner)
 296 {
 297   (void)yyscanner;
 298   free(ptr);
 299 }
 300
 301
 302 void
 303 TA_control_scanner_fatal_error(const char* msg,
 304                                yyscan_t yyscanner)
 305 {
 306   YY_EXTRA_TYPE context = yyget_extra(yyscanner);
 307
 308
 309   /* allocation routines set a different error value */
 310   if (!context->error)
 311     context->error = TA_Err_Control_Flex_Error;
 312   strncpy(context->errmsg, msg, sizeof (context->errmsg));
 313
 314   longjmp(context->jump_buffer, 1);
 315
 316   /* the next line, which we never reach, suppresses a warning about */
 317   /* `yy_fatal_error' defined but not used */
 318   yy_fatal_error(msg, yyscanner);
 319 }
 320
 321
 322 void
 323 TA_control_scanner_init(Control_Context* context,
 324                         FONT* font)
 325 {
 326   int flex_error;
 327
 328   yyscan_t scanner;
 329   YY_BUFFER_STATE b;
 330
 331
 332   /* this function sets `errno' in case of error */
 333   flex_error = yylex_init(&scanner);
 334   if (flex_error && errno == ENOMEM)
 335   {
 336     context->error = FT_Err_Out_Of_Memory;
 337     context->errmsg[0] = '\0';
 338     return;
 339   }
 340
 341   /* initialize some context fields */
 342   context->font = font;
 343   context->error = TA_Err_Ok;
 344   context->result = NULL;
 345   context->scanner = scanner;
 346   context->eof = 0;
 347
 348   yyset_extra(context, scanner);
 349
 350   /* by default, `yy_scan_bytes' simply calls `exit' */
 351   /* (via YY_FATAL_ERROR) in case of a (more or less) fatal error -- */
 352   /* this is bad for a library, thus we use `longjmp' to catch this, */
 353   /* together with a proper handler for YY_FATAL_ERROR */
 354   if (setjmp(context->jump_buffer) != 0)
 355   {
 356     /* error and error message in `context' already stored by */
 357     /* `TA_control_scanner_fatal_error' */
 358     return;
 359   }
 360
 361   b = yy_scan_bytes(font->control_buf, font->control_len, scanner);
 362
 363   /* flex bug: these two fields are not initialized, */
 364   /*           causing zillions of valgrind errors; see */
 365   /*           https://sourceforge.net/p/flex/bugs/180 */
 366   b->yy_bs_lineno = 0;
 367   b->yy_bs_column = 0;
 368 }
 369
 370
 371 void
 372 TA_control_scanner_done(Control_Context* context)
 373 {
 374   yylex_destroy(context->scanner);
 375 }
 376
 377
 378 #if 0
 379
 380 const char* input =
 381   "# Test\n"
 382   "\n"
 383   "# 0 a p 1-3 x 0.3 y -0.2 @ 20-30; \\\n"
 384   "0 exclam p 2-4 x 0.7 y -0.4 @ 6,7,9,10,11; \\\n"
 385   "0 a p 2 x 0.5 @ 23-25";
 386
 387
 388 int
 389 main(void)
 390 {
 391   TA_Error error;
 392   int retval = 1;
 393
 394   FONT font;
 395   Control_Context context;
 396
 397   YYSTYPE yylval_param;
 398   YYLTYPE yylloc_param;
 399
 400
 401   /* we only need the control instructions buffer */
 402   font.control_buf = (char*)input;
 403   font.control_len = strlen(input);
 404
 405   TA_control_scanner_init(&context, &font);
 406   if (context.error)
 407     goto Exit;
 408
 409   yyset_debug(1, context.scanner);
 410   while (yylex(&yylval_param, &yylloc_param, context.scanner))
 411   {
 412     if (context.error)
 413       goto Exit;
 414   }
 415
 416   retval = 0;
 417
 418 Exit:
 419   TA_control_scanner_done(&context);
 420
 421   return retval;
 422 }
 423
 424 #endif
 425
 426 /* end of tacontrol.flex */