little_helpers/tikz/sketch-0.2.161/sketch.l

   1 %{
   2
   3 /* sketch.l
   4    Copyright (C) 2005,2006,2007,2008 Eugene K. Ressler, Jr.
   5
   6 This file is part of Sketch, a small, simple system for making
   7 3d drawings with LaTeX and the PSTricks or TikZ package.
   8
   9 Sketch is free software; you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation; either version 3, or (at your option)
  12 any later version.
  13
  14 Sketch is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with Sketch; see the file COPYING.txt.  If not, see
  21 http://www.gnu.org/copyleft */
  22
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include "geometry.h"
  27 #include "symbol.h"
  28 #include "expr.h"
  29 #include "parse.h"
  30 #include "y.tab.h"
  31 #include "error.h"
  32 #include "opts.h"
  33
  34 #if defined(_WIN32) && !defined fileno
  35 #define fileno(F) _fileno(F)
  36 #pragma warning(disable:4102)
  37 #endif
  38
  39 // undo the safety net in polygon.h so flex scanner can use these library functions
  40 #undef malloc
  41 #undef realloc
  42 #undef free
  43 #undef strdup
  44
  45 SRC_LINE line;
  46
  47 #define MAX_INPUT_DEPTH 10
  48
  49 struct {
  50  YY_BUFFER_STATE buffer_state;
  51  SRC_LINE line;
  52 } input_stack[MAX_INPUT_DEPTH];
  53 int input_stack_ptr = 0;
  54
  55 #define INIT_SPECIAL_BUF_SIZE 40
  56
  57 void update_line_number(void)
  58 {
  59   int i;
  60
  61   for (i = 0; yytext[i]; i++)
  62     if (yytext[i] == '\n')
  63       line.number++;
  64 }
  65
  66 %}
  67
  68 %x inputdirective
  69
  70 Identifier [A-Za-z]([A-Za-z0-9_]*[A-Za-z0-9])?
  71 WSnotNL [ \t\r]
  72 WS [ \t\r\n]
  73
  74 %%
  75
  76 [%#].* /* comment; do nothing */
  77
  78 {WSnotNL}+ /* white space; do nothing */
  79
  80 "\n" {
  81   line.number++;
  82 }
  83
  84 "["[^\]=]+=[^\]]+"]" { /* [<stuff>=<stuff>] */
  85   // elide the brackets
  86   yylval.str = safe_malloc(yyleng + 1 - 2);
  87   str_slice(yylval.str, yyleng + 1 - 2, yytext, 1, -1);
  88   return OPTS_STR;
  89 }
  90
  91 "language" {
  92         return LANGUAGE;
  93 }
  94
  95 "pstricks" {
  96         return PSTRICKS;
  97 }
  98
  99 "tikz" {
 100         return TIKZ;
 101 }
 102
 103 "latex" {
 104         return LaTeX;
 105 }
 106
 107 "context" {
 108         return ConTeXt;
 109 }
 110
 111 "input"{WS}* {
 112   update_line_number();
 113   BEGIN(inputdirective);
 114 }
 115
 116 "curve" {
 117   return CURVE;
 118 }
 119
 120 "camera" {
 121   return CAMERA;
 122 }
 123
 124 "def" {
 125   return DEF;
 126 }
 127
 128 "dots" {
 129   return DOTS;
 130 }
 131
 132 "frame" {
 133   return FRAME;
 134 }
 135
 136 "global" {
 137   return GLOBAL;
 138 }
 139
 140 "line" {
 141   return LINE;
 142 }
 143
 144 "polygon" {
 145   return POLYGON;
 146 }
 147
 148 "put" {
 149   return PUT;
 150 }
 151
 152 "repeat" {
 153   return REPEAT;
 154 }
 155
 156 "set" {
 157   return SET;
 158 }
 159
 160 "sweep" {
 161   return SWEEP;
 162 }
 163
 164 "then" {
 165   return THEN;
 166 }
 167
 168 "atan2"{WS}*"(" {
 169   update_line_number();
 170   return ATAN2;
 171 }
 172
 173 "cos"{WS}*"(" {
 174   update_line_number();
 175   return COS;
 176 }
 177
 178 "inverse"{WS}*"(" {
 179   update_line_number();
 180   return INVERSE;
 181 }
 182
 183 "picturebox" {
 184   return PICTUREBOX;
 185 }
 186
 187 "perspective"{WS}*"(" {
 188   update_line_number();
 189   return PERSPECTIVE;
 190 }
 191
 192 "project"{WS}*"(" {
 193   update_line_number();
 194   return PROJECT;
 195 }
 196
 197 "rotate"{WS}*"(" {
 198   update_line_number();
 199   return ROTATE;
 200 }
 201
 202 "scale"{WS}*"(" {
 203   update_line_number();
 204   return SCALE;
 205 }
 206
 207 "sin"{WS}*"(" {
 208   update_line_number();
 209   return SIN;
 210 }
 211
 212 "special"{WS}* {
 213   char *rtn;
 214   int max_rtn_len, delim, i, ch;
 215
 216   update_line_number();
 217
 218   max_rtn_len = INIT_SPECIAL_BUF_SIZE - 1;
 219   rtn = safe_malloc(max_rtn_len + 1);
 220   i = 0;
 221
 222   delim = input();
 223
 224   if (delim == EOF) {
 225     err(line, "expected special text, found end of file");
 226   }
 227   else {
 228     while ((ch = input()) != delim && ch != EOF) {
 229       if (ch == '\n')
 230         ++line.number;
 231       if (i == max_rtn_len) {
 232         max_rtn_len *= 2;
 233         rtn = safe_realloc(rtn, max_rtn_len + 1);
 234       }
 235       rtn[i++] = ch;
 236     }
 237     if (ch != delim)
 238       err(line, "missing end delimeter '%c' in special", delim);
 239   }
 240   rtn[i] = '\0';
 241   yylval.str = rtn;
 242   return SPECIAL;
 243 }
 244
 245 "sqrt"{WS}*"(" {
 246   update_line_number();
 247   return SQRT;
 248 }
 249
 250 "translate"{WS}*"(" {
 251   update_line_number();
 252   return TRANSLATE;
 253 }
 254
 255 "unit"{WS}*"(" {
 256   update_line_number();
 257   return UNIT;
 258 }
 259
 260 "view"{WS}*"(" {
 261   update_line_number();
 262   return VIEW;
 263 }
 264
 265 {Identifier} {
 266   str_slice(yylval.name, sizeof yylval.name, yytext, 0, sizeof yylval.name);
 267   return ID;
 268 }
 269
 270 "<"{Identifier}">" {
 271   str_slice(yylval.name, sizeof yylval.name, yytext, 1, -1);
 272   return ANGLE_ID;
 273 }
 274
 275 "<>" {
 276   return EMPTY_ANGLE;
 277 }
 278
 279 "'"{WS}*"x" {
 280   update_line_number();
 281   yylval.index = 0;
 282   return TICK;
 283 }
 284
 285 "'"{WS}*"y" {
 286   update_line_number();
 287   yylval.index = 1;
 288   return TICK;
 289 }
 290
 291 "'"{WS}*"z" {
 292   update_line_number();
 293   yylval.index = 2;
 294   return TICK;
 295 }
 296
 297 "("{Identifier}")" {
 298   str_slice(yylval.name, sizeof yylval.name, yytext, 1, -1);
 299   return PAREN_ID;
 300 }
 301
 302 "["{Identifier}"]" {
 303   str_slice(yylval.name, sizeof yylval.name, yytext, 1, -1);
 304   return BRACKET_ID;
 305 }
 306
 307 "[["{Identifier}"]]" {
 308   str_slice(yylval.name, sizeof yylval.name, yytext, 2, -2);
 309   return DBL_BRACKET_ID;
 310 }
 311
 312 "{"{Identifier}"}" {
 313   str_slice(yylval.name, sizeof yylval.name, yytext, 1, -1);
 314   return CURLY_ID;
 315 }
 316
 317 (([0-9]+"."[0-9]*)|("."[0-9]+)|([0-9]+))([eE][-+]?[0-9]+)? {
 318   if (sscanf(yytext, FLOAT_SCAN_FMT, &yylval.flt) != 1) {
 319     err(line, "numeric constant %s could not be converted (probably out of range)", yytext);
 320     yylval.flt = 0;
 321   }
 322   return NUM;
 323 }
 324
 325 "("{WS}*{Identifier}{WS}*")" {
 326   warn(line, "found parenthesized identifier '%s'; delete space if you meant a point ref", yytext);
 327   yyless(1);
 328   return '(';
 329 }
 330
 331 "["{WS}*{Identifier}{WS}*"]" {
 332   warn(line, "found id in brackets '%s'; delete space if you meant a vector ref", yytext);
 333   yyless(1);
 334   return '[';
 335 }
 336
 337 "{"{WS}*{Identifier}{WS}*"}" {
 338   warn(line, "found id in braces '%s'; delete space if you meant a drawable ref", yytext);
 339   yyless(1);
 340   return '{';
 341 }
 342
 343 "[["{WS}*{Identifier}{WS}*"]]" {
 344   warn(line, "found id in double-brackets '%s'; delete space if you meant a transform ref", yytext);
 345   yyless(1);
 346   return '[';
 347 }
 348
 349 "<"{WS}*{Identifier}{WS}*">" {
 350   warn(line, "found id in angle-brackets '%s'; delete space if you meant a tag ref", yytext);
 351   yyless(1);
 352   return '<';
 353 }
 354
 355 [-+*/^|.()\[\]{}=,]     {
 356   return yytext[0];
 357 }
 358
 359 <inputdirective>"{"[^}]*"}" {
 360
 361   FILE *f;
 362   char buf[1024];
 363   int i;
 364
 365   if (line.file_name[0] != '/' && line.file_name[0] != '\\')
 366     i = str_last_occurance(line.file_name, "/\\");
 367   if (i >= 0) {
 368     str_slice(buf, sizeof buf, line.file_name, 0, i + 1);
 369   }
 370   else {
 371     buf[0] = '\0';
 372   }
 373
 374   i = strlen(buf);
 375   str_slice(&buf[i], sizeof buf - i, yytext, 1, -1);
 376
 377   if (input_stack_ptr >= MAX_INPUT_DEPTH) {
 378     err(line, "inputs nested too deeply (file '%s' ignored)", buf);
 379   }
 380   else {
 381     f = fopen(buf, "r");
 382     if (f) {
 383       yyin = f;
 384       input_stack[input_stack_ptr].buffer_state = YY_CURRENT_BUFFER;
 385       input_stack[input_stack_ptr].line = line;
 386       input_stack_ptr++;
 387       yy_switch_to_buffer(yy_create_buffer(yyin, YY_BUF_SIZE));
 388       line.number = 1;
 389       line.include_p = 1;
 390       line.file_name = safe_strdup(buf);
 391     }
 392     else
 393       err(line, "can't open input '%s'", buf);
 394   }
 395   BEGIN(INITIAL);
 396 }
 397
 398 <<EOF>> {
 399   if (input_stack_ptr == 0) {
 400     yyterminate();
 401   }
 402   else {
 403     yy_delete_buffer(YY_CURRENT_BUFFER);
 404     // don't free: refs may still exist for def locs in the symbol table
 405     // safe_free(line.file_name);
 406     --input_stack_ptr;
 407     yy_switch_to_buffer(input_stack[input_stack_ptr].buffer_state);
 408     line = input_stack[input_stack_ptr].line;
 409   }
 410 }
 411
 412 .       {
 413   die(line, "bad char '%c' (%d)\n", yytext[0], (int)yytext[0]);
 414 }
 415
 416 %%
 417
 418 void set_lexer_file(char *file_name, FILE *f)
 419 {
 420   line.file_name = safe_strdup(file_name);
 421   line.include_p = 0;
 422   line.number = 1;
 423   yyin = f;
 424 }