pic/pic.y

   1 /* Copyright (C) 1989, 1990, 1991, 1992 Free Software Foundation, Inc.
   2      Written by James Clark (jjc@jclark.com)
   3
   4 This file is part of groff.
   5
   6 groff is free software; you can redistribute it and/or modify it under
   7 the terms of the GNU General Public License as published by the Free
   8 Software Foundation; either version 2, or (at your option) any later
   9 version.
  10
  11 groff is distributed in the hope that it will be useful, but WITHOUT ANY
  12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14 for more details.
  15
  16 You should have received a copy of the GNU General Public License along
  17 with groff; see the file COPYING.  If not, write to the Free Software
  18 Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
  19 %{
  20 #include "pic.h"
  21 #include "ptable.h"
  22 #include "object.h"
  23
  24 extern int delim_flag;
  25 extern void do_copy(const char *);
  26 extern void copy_rest_thru(const char *, const char *);
  27 extern void copy_file_thru(const char *, const char *, const char *);
  28 extern void push_body(const char *);
  29 extern void do_for(char *var, double from, double to,
  30                    int by_is_multiplicative, double by, char *body);
  31 extern void do_lookahead();
  32
  33 #undef fmod
  34 #undef rand
  35
  36 extern "C" {
  37   double fmod(double, double);
  38   int rand();
  39 }
  40
  41 /* Maximum number of characters produced by printf("%g") */
  42 #define GDIGITS 14
  43
  44 #ifndef __BORLANDC__
  45 #define YYDEBUG 1
  46 #endif /* __BORLANDC__ */
  47
  48 int yylex();
  49 void yyerror(const char *);
  50
  51 void reset(const char *nm);
  52 void reset_all();
  53
  54 place *lookup_label(const char *);
  55 void define_label(const char *label, const place *pl);
  56
  57 direction current_direction;
  58 position current_position;
  59
  60 implement_ptable(place)
  61
  62 PTABLE(place) top_table;
  63
  64 PTABLE(place) *current_table = &top_table;
  65 saved_state *current_saved_state = 0;
  66
  67 object_list olist;
  68
  69 const char *ordinal_postfix(int n);
  70 const char *object_type_name(object_type type);
  71 char *format_number(const char *form, double n);
  72 char *do_sprintf(const char *form, const double *v, int nv);
  73
  74 %}
  75
  76
  77 %union {
  78         char *str;
  79         int n;
  80         double x;
  81         struct { double x, y; } pair;
  82         struct { double x; char *body; } if_data;
  83         struct { char *str; const char *filename; int lineno; } lstr;
  84         struct { double *v; int nv; int maxv; } dv;
  85         struct { double val; int is_multiplicative; } by;
  86         place pl;
  87         object *obj;
  88         corner crn;
  89         path *pth;
  90         object_spec *spec;
  91         saved_state *pstate;
  92         graphics_state state;
  93         object_type obtype;
  94 }
  95
  96 %token <str> LABEL
  97 %token <str> VARIABLE
  98 %token <x> NUMBER
  99 %token <lstr> TEXT
 100 %token <lstr> COMMAND_LINE
 101 %token <str> DELIMITED
 102 %token <n> ORDINAL
 103 %token TH
 104 %token LEFT_ARROW_HEAD
 105 %token RIGHT_ARROW_HEAD
 106 %token DOUBLE_ARROW_HEAD
 107 %token LAST
 108 %token UP
 109 %token DOWN
 110 %token LEFT
 111 %token RIGHT
 112 %token BOX
 113 %token CIRCLE
 114 %token ELLIPSE
 115 %token ARC
 116 %token LINE
 117 %token ARROW
 118 %token MOVE
 119 %token SPLINE
 120 %token HEIGHT
 121 %token RADIUS
 122 %token WIDTH
 123 %token DIAMETER
 124 %token UP
 125 %token DOWN
 126 %token RIGHT
 127 %token LEFT
 128 %token FROM
 129 %token TO
 130 %token AT
 131 %token WITH
 132 %token BY
 133 %token THEN
 134 %token DOTTED
 135 %token DASHED
 136 %token CHOP
 137 %token SAME
 138 %token INVISIBLE
 139 %token LJUST
 140 %token RJUST
 141 %token ABOVE
 142 %token BELOW
 143 %token OF
 144 %token THE
 145 %token WAY
 146 %token BETWEEN
 147 %token AND
 148 %token HERE
 149 %token DOT_N
 150 %token DOT_E
 151 %token DOT_W
 152 %token DOT_S
 153 %token DOT_NE
 154 %token DOT_SE
 155 %token DOT_NW
 156 %token DOT_SW
 157 %token DOT_C
 158 %token DOT_START
 159 %token DOT_END
 160 %token DOT_X
 161 %token DOT_Y
 162 %token DOT_HT
 163 %token DOT_WID
 164 %token DOT_RAD
 165 %token SIN
 166 %token COS
 167 %token ATAN2
 168 %token LOG
 169 %token EXP
 170 %token SQRT
 171 %token MAX
 172 %token MIN
 173 %token INT
 174 %token RAND
 175 %token COPY
 176 %token THRU
 177 %token TOP
 178 %token BOTTOM
 179 %token UPPER
 180 %token LOWER
 181 %token SH
 182 %token PRINT
 183 %token CW
 184 %token CCW
 185 %token FOR
 186 %token DO
 187 %token IF
 188 %token ELSE
 189 %token ANDAND
 190 %token OROR
 191 %token NOTEQUAL
 192 %token EQUALEQUAL
 193 %token LESSEQUAL
 194 %token GREATEREQUAL
 195 %token LEFT_CORNER
 196 %token RIGHT_CORNER
 197 %token CENTER
 198 %token END
 199 %token START
 200 %token RESET
 201 %token UNTIL
 202 %token PLOT
 203 %token THICKNESS
 204 %token FILL
 205 %token ALIGNED
 206 %token SPRINTF
 207 %token COMMAND
 208
 209 %token DEFINE
 210 %token UNDEF
 211
 212 /* this ensures that plot 17 "%g" parses as (plot 17 "%g") */
 213 %left PLOT
 214 %left TEXT SPRINTF
 215
 216 /* give text adjustments higher precedence than TEXT, so that
 217 box "foo" above ljust == box ("foo" above ljust)
 218 */
 219
 220 %left LJUST RJUST ABOVE BELOW
 221
 222 %left LEFT RIGHT
 223 /* Give attributes that take an optional expression a higher
 224 precedence than left and right, so that eg `line chop left'
 225 parses properly. */
 226 %left CHOP DASHED DOTTED UP DOWN FILL
 227 %left LABEL
 228
 229 %left VARIABLE NUMBER '(' SIN COS ATAN2 LOG EXP SQRT MAX MIN INT RAND LAST
 230 %left ORDINAL HERE '`'
 231
 232 /* these need to be lower than '-' */
 233 %left HEIGHT RADIUS WIDTH DIAMETER FROM TO AT THICKNESS
 234
 235 /* these must have higher precedence than CHOP so that `label %prec CHOP'
 236 works */
 237 %left DOT_N DOT_E DOT_W DOT_S DOT_NE DOT_SE DOT_NW DOT_SW DOT_C
 238 %left DOT_START DOT_END TOP BOTTOM LEFT_CORNER RIGHT_CORNER
 239 %left UPPER LOWER CENTER START END
 240
 241 %left ','
 242 %left OROR
 243 %left ANDAND
 244 %left EQUALEQUAL NOTEQUAL
 245 %left '<' '>' LESSEQUAL GREATEREQUAL
 246
 247 %left BETWEEN OF
 248 %left AND
 249
 250 %left '+' '-'
 251 %left '*' '/' '%'
 252 %right '!'
 253 %right '^'
 254
 255 %type <x> expr any_expr text_expr
 256 %type <by> optional_by
 257 %type <pair> expr_pair position_not_place
 258 %type <if_data> simple_if
 259 %type <obj> nth_primitive
 260 %type <crn> corner
 261 %type <pth> path label_path relative_path
 262 %type <pl> place label element element_list middle_element_list
 263 %type <spec> object_spec
 264 %type <pair> position
 265 %type <obtype> object_type
 266 %type <n> optional_ordinal_last ordinal
 267 %type <str> until
 268 %type <dv> sprintf_args
 269 %type <lstr> text print_args print_arg
 270
 271 %%
 272
 273 top:
 274         optional_separator
 275         | element_list
 276                 {
 277                   if (olist.head)
 278                     print_picture(olist.head);
 279                 }
 280         ;
 281
 282
 283 element_list:
 284         optional_separator middle_element_list optional_separator
 285                 { $$ = $2; }
 286         ;
 287
 288 middle_element_list:
 289         element
 290                 { $$ = $1; }
 291         | middle_element_list separator element
 292                 { $$ = $1; }
 293         ;
 294
 295 optional_separator:
 296         /* empty */
 297         | separator
 298         ;
 299
 300 separator:
 301         ';'
 302         | separator ';'
 303         ;
 304
 305 placeless_element:
 306         VARIABLE '=' any_expr
 307                 {
 308                   define_variable($1, $3);
 309                   a_delete $1;
 310                 }
 311         | VARIABLE ':' '=' any_expr
 312                 {
 313                   place *p = lookup_label($1);
 314                   if (!p) {
 315                     lex_error("variable `%1' not defined", $1);
 316                     YYABORT;
 317                   }
 318                   p->obj = 0;
 319                   p->x = $4;
 320                   p->y = 0.0;
 321                   a_delete $1;
 322                 }
 323         | UP
 324                 { current_direction = UP_DIRECTION; }
 325         | DOWN
 326                 { current_direction = DOWN_DIRECTION; }
 327         | LEFT
 328                 { current_direction = LEFT_DIRECTION; }
 329         | RIGHT
 330                 { current_direction = RIGHT_DIRECTION; }
 331         | COMMAND_LINE
 332                 {
 333                   olist.append(make_command_object($1.str, $1.filename,
 334                                                    $1.lineno));
 335                 }
 336         | COMMAND print_args
 337                 {
 338                   olist.append(make_command_object($2.str, $2.filename,
 339                                                    $2.lineno));
 340                 }
 341         | PRINT print_args
 342                 {
 343                   fprintf(stderr, "%s\n", $2.str);
 344                   fflush(stderr);
 345                 }
 346         | SH
 347                 { delim_flag = 1; }
 348           DELIMITED
 349                 {
 350                   delim_flag = 0;
 351                   system($3);
 352                   a_delete $3;
 353                 }
 354         | COPY TEXT
 355                 {
 356                   if (yychar < 0)
 357                     do_lookahead();
 358                   do_copy($2.str);
 359                   // do not delete the filename
 360                 }
 361         | COPY TEXT THRU
 362                 { delim_flag = 2; }
 363           DELIMITED
 364                 { delim_flag = 0; }
 365           until
 366                 {
 367                   if (yychar < 0)
 368                     do_lookahead();
 369                   copy_file_thru($2.str, $5, $7);
 370                   // do not delete the filename
 371                   a_delete $5;
 372                   a_delete $7;
 373                 }
 374         | COPY THRU
 375                 { delim_flag = 2; }
 376           DELIMITED
 377                 { delim_flag = 0; }
 378           until
 379                 {
 380                   if (yychar < 0)
 381                     do_lookahead();
 382                   copy_rest_thru($4, $6);
 383                   a_delete $4;
 384                   a_delete $6;
 385                 }
 386         | FOR VARIABLE '=' expr TO expr optional_by DO
 387                 { delim_flag = 1; }
 388           DELIMITED
 389                 {
 390                   delim_flag = 0;
 391                   if (yychar < 0)
 392                     do_lookahead();
 393                   do_for($2, $4, $6, $7.is_multiplicative, $7.val, $10);
 394                 }
 395         | simple_if
 396                 {
 397                   if (yychar < 0)
 398                     do_lookahead();
 399                   if ($1.x != 0.0)
 400                     push_body($1.body);
 401                   a_delete $1.body;
 402                 }
 403         | simple_if ELSE
 404                 { delim_flag = 1; }
 405           DELIMITED
 406                 {
 407                   delim_flag = 0;
 408                   if (yychar < 0)
 409                     do_lookahead();
 410                   if ($1.x != 0.0)
 411                     push_body($1.body);
 412                   else
 413                     push_body($4);
 414                   a_delete $1.body;
 415                   a_delete $4;
 416                 }
 417         | reset_variables
 418         | RESET
 419                 { define_variable("scale", 1.0); }
 420         ;
 421
 422 reset_variables:
 423         RESET VARIABLE
 424                 { reset($2); a_delete $2; }
 425         | reset_variables VARIABLE
 426                 { reset($2); a_delete $2; }
 427         | reset_variables ',' VARIABLE
 428                 { reset($3); a_delete $3; }
 429         ;
 430
 431 print_args:
 432         print_arg
 433                 { $$ = $1; }
 434         | print_args print_arg
 435                 {
 436                   $$.str = new char[strlen($1.str) + strlen($2.str) + 1];
 437                   strcpy($$.str, $1.str);
 438                   strcat($$.str, $2.str);
 439                   a_delete $1.str;
 440                   a_delete $2.str;
 441                   if ($1.filename) {
 442                     $$.filename = $1.filename;
 443                     $$.lineno = $1.lineno;
 444                   }
 445                   else if ($2.filename) {
 446                     $$.filename = $2.filename;
 447                     $$.lineno = $2.lineno;
 448                   }
 449                 }
 450         ;
 451
 452 print_arg:
 453         expr               %prec ','
 454                 {
 455                   $$.str = new char[GDIGITS + 1];
 456                   sprintf($$.str, "%g", $1);
 457                   $$.filename = 0;
 458                   $$.lineno = 0;
 459                 }
 460         | text
 461                 { $$ = $1; }
 462         | position          %prec ','
 463                 {
 464                   $$.str = new char[GDIGITS + 2 + GDIGITS + 1];
 465                   sprintf($$.str, "%g, %g", $1.x, $1.y);
 466                   $$.filename = 0;
 467                   $$.lineno = 0;
 468                 }
 469
 470 simple_if:
 471         IF any_expr THEN
 472                 { delim_flag = 1; }
 473         DELIMITED
 474                 { delim_flag = 0; $$.x = $2; $$.body = $5; }
 475         ;
 476
 477 until:
 478         /* empty */
 479                 { $$ = 0; }
 480         | UNTIL TEXT
 481                 { $$ = $2.str; }
 482         ;
 483
 484 any_expr:
 485         expr
 486                 { $$ = $1; }
 487         | text_expr
 488                 { $$ = $1; }
 489         ;
 490
 491 text_expr:
 492         text EQUALEQUAL text
 493                 {
 494                   $$ = strcmp($1.str, $3.str) == 0;
 495                   a_delete $1.str;
 496                   a_delete $3.str;
 497                 }
 498         | text NOTEQUAL text
 499                 {
 500                   $$ = strcmp($1.str, $3.str) != 0;
 501                   a_delete $1.str;
 502                   a_delete $3.str;
 503                 }
 504         | text_expr ANDAND text_expr
 505                 { $$ = ($1 != 0.0 && $3 != 0.0); }
 506         | text_expr ANDAND expr
 507                 { $$ = ($1 != 0.0 && $3 != 0.0); }
 508         | expr ANDAND text_expr
 509                 { $$ = ($1 != 0.0 && $3 != 0.0); }
 510         | text_expr OROR text_expr
 511                 { $$ = ($1 != 0.0 || $3 != 0.0); }
 512         | text_expr OROR expr
 513                 { $$ = ($1 != 0.0 || $3 != 0.0); }
 514         | expr OROR text_expr
 515                 { $$ = ($1 != 0.0 || $3 != 0.0); }
 516         | '!' text_expr
 517                 { $$ = ($2 == 0.0); }
 518         ;
 519
 520
 521 optional_by:
 522         /* empty */
 523                 { $$.val = 1.0; $$.is_multiplicative = 0; }
 524         | BY expr
 525                 { $$.val = $2; $$.is_multiplicative = 0; }
 526         | BY '*' expr
 527                 { $$.val = $3; $$.is_multiplicative = 1; }
 528         ;
 529
 530 element:
 531         object_spec
 532                 {
 533                   $$.obj = $1->make_object(&current_position,
 534                                            &current_direction);
 535                   if ($$.obj == 0)
 536                     YYABORT;
 537                   delete $1;
 538                   if ($$.obj)
 539                     olist.append($$.obj);
 540                   else {
 541                     $$.x = current_position.x;
 542                     $$.y = current_position.y;
 543                   }
 544                 }
 545         | LABEL ':' optional_separator element
 546                 { $$ = $4; define_label($1, & $$); a_delete $1; }
 547         | LABEL ':' optional_separator position_not_place
 548                 {
 549                   $$.obj = 0;
 550                   $$.x = $4.x;
 551                   $$.y = $4.y;
 552                   define_label($1, & $$);
 553                   a_delete $1;
 554                 }
 555         | LABEL ':' optional_separator place
 556                 {
 557                   $$ = $4;
 558                   define_label($1, & $$);
 559                   a_delete $1;
 560                 }
 561         | '{'
 562                 {
 563                   $<state>$.x = current_position.x;
 564                   $<state>$.y = current_position.y;
 565                   $<state>$.dir = current_direction;
 566                 }
 567           element_list '}'
 568                 {
 569                   current_position.x = $<state>2.x;
 570                   current_position.y = $<state>2.y;
 571                   current_direction = $<state>2.dir;
 572                 }
 573           optional_element
 574                 {
 575                   $$ = $3;
 576                 }
 577         | placeless_element
 578                 {
 579                   $$.obj = 0;
 580                   $$.x = current_position.x;
 581                   $$.y = current_position.y;
 582                 }
 583         ;
 584
 585 optional_element:
 586         /* empty */
 587                 {}
 588         | element
 589                 {}
 590         ;
 591
 592 object_spec:
 593         BOX
 594                 {
 595                   $$ = new object_spec(BOX_OBJECT);
 596                 }
 597         | CIRCLE
 598                 {
 599                   $$ = new object_spec(CIRCLE_OBJECT);
 600                 }
 601         | ELLIPSE
 602                 {
 603                   $$ = new object_spec(ELLIPSE_OBJECT);
 604                 }
 605         | ARC
 606                 {
 607                   $$ = new object_spec(ARC_OBJECT);
 608                   $$->dir = current_direction;
 609                 }
 610         | LINE
 611                 {
 612                   $$ = new object_spec(LINE_OBJECT);
 613                   lookup_variable("lineht", & $$->segment_height);
 614                   lookup_variable("linewid", & $$->segment_width);
 615                   $$->dir = current_direction;
 616                 }
 617         | ARROW
 618                 {
 619                   $$ = new object_spec(ARROW_OBJECT);
 620                   lookup_variable("lineht", & $$->segment_height);
 621                   lookup_variable("linewid", & $$->segment_width);
 622                   $$->dir = current_direction;
 623                 }
 624         | MOVE
 625                 {
 626                   $$ = new object_spec(MOVE_OBJECT);
 627                   lookup_variable("moveht", & $$->segment_height);
 628                   lookup_variable("movewid", & $$->segment_width);
 629                   $$->dir = current_direction;
 630                 }
 631         | SPLINE
 632                 {
 633                   $$ = new object_spec(SPLINE_OBJECT);
 634                   lookup_variable("lineht", & $$->segment_height);
 635                   lookup_variable("linewid", & $$->segment_width);
 636                   $$->dir = current_direction;
 637                 }
 638         | text   %prec TEXT
 639                 {
 640                   $$ = new object_spec(TEXT_OBJECT);
 641                   $$->text = new text_item($1.str, $1.filename, $1.lineno);
 642                 }
 643         | PLOT expr
 644                 {
 645                   $$ = new object_spec(TEXT_OBJECT);
 646                   $$->text = new text_item(format_number(0, $2), 0, -1);
 647                 }
 648         | PLOT expr text
 649                 {
 650                   $$ = new object_spec(TEXT_OBJECT);
 651                   $$->text = new text_item(format_number($3.str, $2),
 652                                            $3.filename, $3.lineno);
 653                   a_delete $3.str;
 654                 }
 655         | '['
 656                 {
 657                   saved_state *p = new saved_state;
 658                   $<pstate>$ = p;
 659                   p->x = current_position.x;
 660                   p->y = current_position.y;
 661                   p->dir = current_direction;
 662                   p->tbl = current_table;
 663                   p->prev = current_saved_state;
 664                   current_position.x = 0.0;
 665                   current_position.y = 0.0;
 666                   current_table = new PTABLE(place);
 667                   current_saved_state = p;
 668                   olist.append(make_mark_object());
 669                 }
 670           element_list ']'
 671                 {
 672                   current_position.x = $<pstate>2->x;
 673                   current_position.y = $<pstate>2->y;
 674                   current_direction = $<pstate>2->dir;
 675                   $$ = new object_spec(BLOCK_OBJECT);
 676                   olist.wrap_up_block(& $$->oblist);
 677                   $$->tbl = current_table;
 678                   current_table = $<pstate>2->tbl;
 679                   current_saved_state = $<pstate>2->prev;
 680                   delete $<pstate>2;
 681                 }
 682         | object_spec HEIGHT expr
 683                 {
 684                   $$ = $1;
 685                   $$->height = $3;
 686                   $$->flags |= HAS_HEIGHT;
 687                 }
 688         | object_spec RADIUS expr
 689                 {
 690                   $$ = $1;
 691                   $$->radius = $3;
 692                   $$->flags |= HAS_RADIUS;
 693                 }
 694         | object_spec WIDTH expr
 695                 {
 696                   $$ = $1;
 697                   $$->width = $3;
 698                   $$->flags |= HAS_WIDTH;
 699                 }
 700         | object_spec DIAMETER expr
 701                 {
 702                   $$ = $1;
 703                   $$->radius = $3/2.0;
 704                   $$->flags |= HAS_RADIUS;
 705                 }
 706         | object_spec expr %prec HEIGHT
 707                 {
 708                   $$ = $1;
 709                   $$->flags |= HAS_SEGMENT;
 710                   switch ($$->dir) {
 711                   case UP_DIRECTION:
 712                     $$->segment_pos.y += $2;
 713                     break;
 714                   case DOWN_DIRECTION:
 715                     $$->segment_pos.y -= $2;
 716                     break;
 717                   case RIGHT_DIRECTION:
 718                     $$->segment_pos.x += $2;
 719                     break;
 720                   case LEFT_DIRECTION:
 721                     $$->segment_pos.x -= $2;
 722                     break;
 723                   }
 724                 }
 725         | object_spec UP
 726                 {
 727                   $$ = $1;
 728                   $$->dir = UP_DIRECTION;
 729                   $$->flags |= HAS_SEGMENT;
 730                   $$->segment_pos.y += $$->segment_height;
 731                 }
 732         | object_spec UP expr
 733                 {
 734                   $$ = $1;
 735                   $$->dir = UP_DIRECTION;
 736                   $$->flags |= HAS_SEGMENT;
 737                   $$->segment_pos.y += $3;
 738                 }
 739         | object_spec DOWN
 740                 {
 741                   $$ = $1;
 742                   $$->dir = DOWN_DIRECTION;
 743                   $$->flags |= HAS_SEGMENT;
 744                   $$->segment_pos.y -= $$->segment_height;
 745                 }
 746         | object_spec DOWN expr
 747                 {
 748                   $$ = $1;
 749                   $$->dir = DOWN_DIRECTION;
 750                   $$->flags |= HAS_SEGMENT;
 751                   $$->segment_pos.y -= $3;
 752                 }
 753         | object_spec RIGHT
 754                 {
 755                   $$ = $1;
 756                   $$->dir = RIGHT_DIRECTION;
 757                   $$->flags |= HAS_SEGMENT;
 758                   $$->segment_pos.x += $$->segment_width;
 759                 }
 760         | object_spec RIGHT expr
 761                 {
 762                   $$ = $1;
 763                   $$->dir = RIGHT_DIRECTION;
 764                   $$->flags |= HAS_SEGMENT;
 765                   $$->segment_pos.x += $3;
 766                 }
 767         | object_spec LEFT
 768                 {
 769                   $$ = $1;
 770                   $$->dir = LEFT_DIRECTION;
 771                   $$->flags |= HAS_SEGMENT;
 772                   $$->segment_pos.x -= $$->segment_width;
 773                 }
 774         | object_spec LEFT expr
 775                 {
 776                   $$ = $1;
 777                   $$->dir = LEFT_DIRECTION;
 778                   $$->flags |= HAS_SEGMENT;
 779                   $$->segment_pos.x -= $3;
 780                 }
 781         | object_spec FROM position
 782                 {
 783                   $$ = $1;
 784                   $$->flags |= HAS_FROM;
 785                   $$->from.x = $3.x;
 786                   $$->from.y = $3.y;
 787                 }
 788         | object_spec TO position
 789                 {
 790                   $$ = $1;
 791                   if ($$->flags & HAS_SEGMENT)
 792                     $$->segment_list = new segment($$->segment_pos,
 793                                                    $$->segment_is_absolute,
 794                                                    $$->segment_list);
 795                   $$->flags |= HAS_SEGMENT;
 796                   $$->segment_pos.x = $3.x;
 797                   $$->segment_pos.y = $3.y;
 798                   $$->segment_is_absolute = 1;
 799                   $$->flags |= HAS_TO;
 800                   $$->to.x = $3.x;
 801                   $$->to.y = $3.y;
 802                 }
 803         | object_spec AT position
 804                 {
 805                   $$ = $1;
 806                   $$->flags |= HAS_AT;
 807                   $$->at.x = $3.x;
 808                   $$->at.y = $3.y;
 809                   if ($$->type != ARC_OBJECT) {
 810                     $$->flags |= HAS_FROM;
 811                     $$->from.x = $3.x;
 812                     $$->from.y = $3.y;
 813                   }
 814                 }
 815         | object_spec WITH path
 816                 {
 817                   $$ = $1;
 818                   $$->flags |= HAS_WITH;
 819                   $$->with = $3;
 820                 }
 821         | object_spec BY expr_pair
 822                 {
 823                   $$ = $1;
 824                   $$->flags |= HAS_SEGMENT;
 825                   $$->segment_pos.x += $3.x;
 826                   $$->segment_pos.y += $3.y;
 827                 }
 828         | object_spec THEN
 829                 {
 830                   $$ = $1;
 831                   if ($$->flags & HAS_SEGMENT) {
 832                     $$->segment_list = new segment($$->segment_pos,
 833                                                    $$->segment_is_absolute,
 834                                                    $$->segment_list);
 835                     $$->flags &= ~HAS_SEGMENT;
 836                     $$->segment_pos.x = $$->segment_pos.y = 0.0;
 837                     $$->segment_is_absolute = 0;
 838                   }
 839                 }
 840         | object_spec DOTTED
 841                 {
 842                   $$ = $1;
 843                   $$->flags |= IS_DOTTED;
 844                   lookup_variable("dashwid", & $$->dash_width);
 845                 }
 846         | object_spec DOTTED expr
 847                 {
 848                   $$ = $1;
 849                   $$->flags |= IS_DOTTED;
 850                   $$->dash_width = $3;
 851                 }
 852         | object_spec DASHED
 853                 {
 854                   $$ = $1;
 855                   $$->flags |= IS_DASHED;
 856                   lookup_variable("dashwid", & $$->dash_width);
 857                 }
 858         | object_spec DASHED expr
 859                 {
 860                   $$ = $1;
 861                   $$->flags |= IS_DASHED;
 862                   $$->dash_width = $3;
 863                 }
 864         | object_spec FILL
 865                 {
 866                   $$ = $1;
 867                   $$->flags |= IS_DEFAULT_FILLED;
 868                 }
 869         | object_spec FILL expr
 870                 {
 871                   $$ = $1;
 872                   $$->flags |= IS_FILLED;
 873                   $$->fill = $3;
 874                 }
 875         | object_spec CHOP
 876                 {
 877                   $$ = $1;
 878                   // line chop chop means line chop 0 chop 0
 879                   if ($$->flags & IS_DEFAULT_CHOPPED) {
 880                     $$->flags |= IS_CHOPPED;
 881                     $$->flags &= ~IS_DEFAULT_CHOPPED;
 882                     $$->start_chop = $$->end_chop = 0.0;
 883                   }
 884                   else if ($$->flags & IS_CHOPPED) {
 885                     $$->end_chop = 0.0;
 886                   }
 887                   else {
 888                     $$->flags |= IS_DEFAULT_CHOPPED;
 889                   }
 890                 }
 891         | object_spec CHOP expr
 892                 {
 893                   $$ = $1;
 894                   if ($$->flags & IS_DEFAULT_CHOPPED) {
 895                     $$->flags |= IS_CHOPPED;
 896                     $$->flags &= ~IS_DEFAULT_CHOPPED;
 897                     $$->start_chop = 0.0;
 898                     $$->end_chop = $3;
 899                   }
 900                   else if ($$->flags & IS_CHOPPED) {
 901                     $$->end_chop = $3;
 902                   }
 903                   else {
 904                     $$->start_chop = $$->end_chop = $3;
 905                     $$->flags |= IS_CHOPPED;
 906                   }
 907                 }
 908         | object_spec SAME
 909                 {
 910                   $$ = $1;
 911                   $$->flags |= IS_SAME;
 912                 }
 913         | object_spec INVISIBLE
 914                 {
 915                   $$ = $1;
 916                   $$->flags |= IS_INVISIBLE;
 917                 }
 918         | object_spec LEFT_ARROW_HEAD
 919                 {
 920                   $$ = $1;
 921                   $$->flags |= HAS_LEFT_ARROW_HEAD;
 922                 }
 923         | object_spec RIGHT_ARROW_HEAD
 924                 {
 925                   $$ = $1;
 926                   $$->flags |= HAS_RIGHT_ARROW_HEAD;
 927                 }
 928         | object_spec DOUBLE_ARROW_HEAD
 929                 {
 930                   $$ = $1;
 931                   $$->flags |= (HAS_LEFT_ARROW_HEAD|HAS_RIGHT_ARROW_HEAD);
 932                 }
 933         | object_spec CW
 934                 {
 935                   $$ = $1;
 936                   $$->flags |= IS_CLOCKWISE;
 937                 }
 938         | object_spec CCW
 939                 {
 940                   $$ = $1;
 941                   $$->flags &= ~IS_CLOCKWISE;
 942                 }
 943         | object_spec text   %prec TEXT
 944                 {
 945                   $$ = $1;
 946                   for (text_item **p = & $$->text; *p; p = &(*p)->next)
 947                     ;
 948                   *p = new text_item($2.str, $2.filename, $2.lineno);
 949                 }
 950         | object_spec LJUST
 951                 {
 952                   $$ = $1;
 953                   if ($$->text) {
 954                     for (text_item *p = $$->text; p->next; p = p->next)
 955                       ;
 956                     p->adj.h = LEFT_ADJUST;
 957                   }
 958                 }
 959         | object_spec RJUST
 960                 {
 961                   $$ = $1;
 962                   if ($$->text) {
 963                     for (text_item *p = $$->text; p->next; p = p->next)
 964                       ;
 965                     p->adj.h = RIGHT_ADJUST;
 966                   }
 967                 }
 968         | object_spec ABOVE
 969                 {
 970                   $$ = $1;
 971                   if ($$->text) {
 972                     for (text_item *p = $$->text; p->next; p = p->next)
 973                       ;
 974                     p->adj.v = ABOVE_ADJUST;
 975                   }
 976                 }
 977         | object_spec BELOW
 978                 {
 979                   $$ = $1;
 980                   if ($$->text) {
 981                     for (text_item *p = $$->text; p->next; p = p->next)
 982                       ;
 983                     p->adj.v = BELOW_ADJUST;
 984                   }
 985                 }
 986         | object_spec THICKNESS expr
 987                 {
 988                   $$ = $1;
 989                   $$->flags |= HAS_THICKNESS;
 990                   $$->thickness = $3;
 991                 }
 992         | object_spec ALIGNED
 993                 {
 994                   $$ = $1;
 995                   $$->flags |= IS_ALIGNED;
 996                 }
 997         ;
 998
 999 text:
1000         TEXT
1001                 {
1002                   $$ = $1;
1003                 }
1004         | SPRINTF '(' TEXT sprintf_args ')'
1005                 {
1006                   $$.filename = $3.filename;
1007                   $$.lineno = $3.lineno;
1008                   $$.str = do_sprintf($3.str, $4.v, $4.nv);
1009                   a_delete $4.v;
1010                   a_delete $3.str;
1011                 }
1012         ;
1013
1014 sprintf_args:
1015         /* empty */
1016                 {
1017                   $$.v = 0;
1018                   $$.nv = 0;
1019                   $$.maxv = 0;
1020                 }
1021         | sprintf_args ',' expr
1022                 {
1023                   $$ = $1;
1024                   if ($$.nv >= $$.maxv) {
1025                     if ($$.nv == 0) {
1026                       $$.v = new double[4];
1027                       $$.maxv = 4;
1028                     }
1029                     else {
1030                       double *oldv = $$.v;
1031                       $$.maxv *= 2;
1032                       $$.v = new double[$$.maxv];
1033                       memcpy($$.v, oldv, $$.nv*sizeof(double));
1034                       a_delete oldv;
1035                     }
1036                   }
1037                   $$.v[$$.nv] = $3;
1038                   $$.nv += 1;
1039                 }
1040         ;
1041
1042 position:
1043         position_not_place
1044                 { $$ = $1; }
1045         | place
1046                 {
1047                   position pos = $1;
1048                   $$.x = pos.x;
1049                   $$.y = pos.y;
1050                 }
1051         ;
1052
1053 position_not_place:
1054         expr_pair
1055                 { $$ = $1; }
1056         | position '+' expr_pair
1057                 {
1058                   $$.x = $1.x + $3.x;
1059                   $$.y = $1.y + $3.y;
1060                 }
1061         | position '-' expr_pair
1062                 {
1063                   $$.x = $1.x - $3.x;
1064                   $$.y = $1.y - $3.y;
1065                 }
1066         | '(' position ',' position ')'
1067                 {
1068                   $$.x = $2.x;
1069                   $$.y = $4.y;
1070                 }
1071         | expr between position AND position
1072                 {
1073                   $$.x = (1.0 - $1)*$3.x + $1*$5.x;
1074                   $$.y = (1.0 - $1)*$3.y + $1*$5.y;
1075                 }
1076         | expr '<' position ',' position '>'
1077                 {
1078                   $$.x = (1.0 - $1)*$3.x + $1*$5.x;
1079                   $$.y = (1.0 - $1)*$3.y + $1*$5.y;
1080                 }
1081         ;
1082
1083 between:
1084         BETWEEN
1085         | OF THE WAY BETWEEN
1086         ;
1087
1088 expr_pair:
1089         expr ',' expr
1090                 { $$.x = $1; $$.y = $3; }
1091         | '(' expr_pair ')'
1092                 { $$ = $2; }
1093         ;
1094
1095 place:
1096         label  %prec CHOP /* line at A left == line (at A) left */
1097                 { $$ = $1; }
1098         | label corner
1099                 {
1100                   path pth($2);
1101                   if (!pth.follow($1, & $$))
1102                     YYABORT;
1103                 }
1104         | corner label
1105                 {
1106                   path pth($1);
1107                   if (!pth.follow($2, & $$))
1108                     YYABORT;
1109                 }
1110         | corner OF label
1111                 {
1112                   path pth($1);
1113                   if (!pth.follow($3, & $$))
1114                     YYABORT;
1115                 }
1116         | HERE
1117                 {
1118                   $$.x = current_position.x;
1119                   $$.y = current_position.y;
1120                   $$.obj = 0;
1121                 }
1122         ;
1123
1124 label:
1125         LABEL
1126                 {
1127                   place *p = lookup_label($1);
1128                   if (!p) {
1129                     lex_error("there is no place `%1'", $1);
1130                     YYABORT;
1131                   }
1132                   $$ = *p;
1133                   a_delete $1;
1134                 }
1135         | nth_primitive
1136                 {
1137                   $$.obj = $1;
1138                 }
1139         | label '.' LABEL
1140                 {
1141                   path pth($3);
1142                   if (!pth.follow($1, & $$))
1143                     YYABORT;
1144                 }
1145         ;
1146
1147 ordinal:
1148         ORDINAL
1149                 { $$ = $1; }
1150         | '`' any_expr TH
1151                 {
1152                   // XXX Check for overflow (and non-integers?).
1153                   $$ = (int)$2;
1154                 }
1155         ;
1156
1157 optional_ordinal_last:
1158         LAST
1159                 { $$ = 1; }
1160         | ordinal LAST
1161                 { $$ = $1; }
1162         ;
1163
1164 nth_primitive:
1165         ordinal object_type
1166                 {
1167                   int count = 0;
1168                   for (object *p = olist.head; p != 0; p = p->next)
1169                     if (p->type() == $2 && ++count == $1) {
1170                       $$ = p;
1171                       break;
1172                     }
1173                   if (p == 0) {
1174                     lex_error("there is no %1%2 %3", $1, ordinal_postfix($1),
1175                               object_type_name($2));
1176                     YYABORT;
1177                   }
1178                 }
1179         | optional_ordinal_last object_type
1180                 {
1181                   int count = 0;
1182                   for (object *p = olist.tail; p != 0; p = p->prev)
1183                     if (p->type() == $2 && ++count == $1) {
1184                       $$ = p;
1185                       break;
1186                     }
1187                   if (p == 0) {
1188                     lex_error("there is no %1%2 last %3", $1,
1189                               ordinal_postfix($1), object_type_name($2));
1190                     YYABORT;
1191                   }
1192                 }
1193         ;
1194
1195 object_type:
1196         BOX
1197                 { $$ = BOX_OBJECT; }
1198         | CIRCLE
1199                 { $$ = CIRCLE_OBJECT; }
1200         | ELLIPSE
1201                 { $$ = ELLIPSE_OBJECT; }
1202         | ARC
1203                 { $$ = ARC_OBJECT; }
1204         | LINE
1205                 { $$ = LINE_OBJECT; }
1206         | ARROW
1207                 { $$ = ARROW_OBJECT; }
1208         | SPLINE
1209                 { $$ = SPLINE_OBJECT; }
1210         | '[' ']'
1211                 { $$ = BLOCK_OBJECT; }
1212         | TEXT
1213                 { $$ = TEXT_OBJECT; }
1214         ;
1215
1216 label_path:
1217         '.' LABEL
1218                 {
1219                   $$ = new path($2);
1220                 }
1221         | label_path '.' LABEL
1222                 {
1223                   $$ = $1;
1224                   $$->append($3);
1225                 }
1226         ;
1227
1228 relative_path:
1229         corner
1230                 {
1231                   $$ = new path($1);
1232                 }
1233         /* give this a lower precedence than LEFT and RIGHT so that
1234            [A: box] with .A left == [A: box] with (.A left) */
1235
1236         | label_path %prec TEXT
1237                 {
1238                   $$ = $1;
1239                 }
1240         | label_path corner
1241                 {
1242                   $$ = $1;
1243                   $$->append($2);
1244                 }
1245         ;
1246
1247 path:
1248         relative_path
1249                 {
1250                   $$ = $1;
1251                 }
1252         /* The rest of these rules are a compatibility sop. */
1253         | ORDINAL LAST object_type relative_path
1254                 {
1255                   lex_warning("`%1%2 last %3' in `with' argument ignored",
1256                               $1, ordinal_postfix($1), object_type_name($3));
1257                   $$ = $4;
1258                 }
1259         | LAST object_type relative_path
1260                 {
1261                   lex_warning("`last %1' in `with' argument ignored",
1262                               object_type_name($2));
1263                   $$ = $3;
1264                 }
1265         | ORDINAL object_type relative_path
1266                 {
1267                   lex_warning("`%1%2 %3' in `with' argument ignored",
1268                               $1, ordinal_postfix($1), object_type_name($2));
1269                   $$ = $3;
1270                 }
1271         | LABEL relative_path
1272                 {
1273                   lex_warning("initial `%1' in `with' argument ignored", $1);
1274                   a_delete $1;
1275                   $$ = $2;
1276                 }
1277         ;
1278
1279 corner:
1280         DOT_N
1281                 { $$ = &object::north; }
1282         | DOT_E
1283                 { $$ = &object::east; }
1284         | DOT_W
1285                 { $$ = &object::west; }
1286         | DOT_S
1287                 { $$ = &object::south; }
1288         | DOT_NE
1289                 { $$ = &object::north_east; }
1290         | DOT_SE
1291                 { $$ = &object:: south_east; }
1292         | DOT_NW
1293                 { $$ = &object::north_west; }
1294         | DOT_SW
1295                 { $$ = &object::south_west; }
1296         | DOT_C
1297                 { $$ = &object::center; }
1298         | DOT_START
1299                 { $$ = &object::start; }
1300         | DOT_END
1301                 { $$ = &object::end; }
1302         | TOP
1303                 { $$ = &object::north; }
1304         | BOTTOM
1305                 { $$ = &object::south; }
1306         | LEFT
1307                 { $$ = &object::west; }
1308         | RIGHT
1309                 { $$ = &object::east; }
1310         | UPPER LEFT
1311                 { $$ = &object::north_west; }
1312         | LOWER LEFT
1313                 { $$ = &object::south_west; }
1314         | UPPER RIGHT
1315                 { $$ = &object::north_east; }
1316         | LOWER RIGHT
1317                 { $$ = &object::south_east; }
1318         | LEFT_CORNER
1319                 { $$ = &object::west; }
1320         | RIGHT_CORNER
1321                 { $$ = &object::east; }
1322         | UPPER LEFT_CORNER
1323                 { $$ = &object::north_west; }
1324         | LOWER LEFT_CORNER
1325                 { $$ = &object::south_west; }
1326         | UPPER RIGHT_CORNER
1327                 { $$ = &object::north_east; }
1328         | LOWER RIGHT_CORNER
1329                 { $$ = &object::south_east; }
1330         | CENTER
1331                 { $$ = &object::center; }
1332         | START
1333                 { $$ = &object::start; }
1334         | END
1335                 { $$ = &object::end; }
1336         ;
1337
1338 expr:
1339         VARIABLE
1340                 {
1341                   if (!lookup_variable($1, & $$)) {
1342                     lex_error("there is no variable `%1'", $1);
1343                     YYABORT;
1344                   }
1345                   a_delete $1;
1346                 }
1347         | NUMBER
1348                 { $$ = $1; }
1349         | place DOT_X
1350                 {
1351                   if ($1.obj != 0)
1352                     $$ = $1.obj->origin().x;
1353                   else
1354                     $$ = $1.x;
1355                 }
1356         | place DOT_Y
1357                 {
1358                   if ($1.obj != 0)
1359                     $$ = $1.obj->origin().y;
1360                   else
1361                     $$ = $1.y;
1362                 }
1363         | place DOT_HT
1364                 {
1365                   if ($1.obj != 0)
1366                     $$ = $1.obj->height();
1367                   else
1368                     $$ = 0.0;
1369                 }
1370         | place DOT_WID
1371                 {
1372                   if ($1.obj != 0)
1373                     $$ = $1.obj->width();
1374                   else
1375                     $$ = 0.0;
1376                 }
1377         | place DOT_RAD
1378                 {
1379                   if ($1.obj != 0)
1380                     $$ = $1.obj->radius();
1381                   else
1382                     $$ = 0.0;
1383                 }
1384         | expr '+' expr
1385                 { $$ = $1 + $3; }
1386         | expr '-' expr
1387                 { $$ = $1 - $3; }
1388         | expr '*' expr
1389                 { $$ = $1 * $3; }
1390         | expr '/' expr
1391                 {
1392                   if ($3 == 0.0) {
1393                     lex_error("division by zero");
1394                     YYABORT;
1395                   }
1396                   $$ = $1/$3;
1397                 }
1398         | expr '%' expr
1399                 {
1400                   if ($3 == 0.0) {
1401                     lex_error("modulus by zero");
1402                     YYABORT;
1403                   }
1404                   $$ = fmod($1, $3);
1405                 }
1406         | expr '^' expr
1407                 {
1408                   errno = 0;
1409                   $$ = pow($1, $3);
1410                   if (errno == EDOM) {
1411                     lex_error("arguments to `^' operator out of domain");
1412                     YYABORT;
1413                   }
1414                   if (errno == ERANGE) {
1415                     lex_error("result of `^' operator out of range");
1416                     YYABORT;
1417                   }
1418                 }
1419         | '-' expr    %prec '!'
1420                 { $$ = -$2; }
1421         | '(' any_expr ')'
1422                 { $$ = $2; }
1423         | SIN '(' any_expr ')'
1424                 {
1425                   errno = 0;
1426                   $$ = sin($3);
1427                   if (errno == ERANGE) {
1428                     lex_error("sin result out of range");
1429                     YYABORT;
1430                   }
1431                 }
1432         | COS '(' any_expr ')'
1433                 {
1434                   errno = 0;
1435                   $$ = cos($3);
1436                   if (errno == ERANGE) {
1437                     lex_error("cos result out of range");
1438                     YYABORT;
1439                   }
1440                 }
1441         | ATAN2 '(' any_expr ',' any_expr ')'
1442                 {
1443                   errno = 0;
1444                   $$ = atan2($3, $5);
1445                   if (errno == EDOM) {
1446                     lex_error("atan2 argument out of domain");
1447                     YYABORT;
1448                   }
1449                   if (errno == ERANGE) {
1450                     lex_error("atan2 result out of range");
1451                     YYABORT;
1452                   }
1453                 }
1454         | LOG '(' any_expr ')'
1455                 {
1456                   errno = 0;
1457                   $$ = log10($3);
1458                   if (errno == ERANGE) {
1459                     lex_error("log result out of range");
1460                     YYABORT;
1461                   }
1462                 }
1463         | EXP '(' any_expr ')'
1464                 {
1465                   errno = 0;
1466                   $$ = pow(10.0, $3);
1467                   if (errno == ERANGE) {
1468                     lex_error("exp result out of range");
1469                     YYABORT;
1470                   }
1471                 }
1472         | SQRT '(' any_expr ')'
1473                 {
1474                   errno = 0;
1475                   $$ = sqrt($3);
1476                   if (errno == EDOM) {
1477                     lex_error("sqrt argument out of domain");
1478                     YYABORT;
1479                   }
1480                 }
1481         | MAX '(' any_expr ',' any_expr ')'
1482                 { $$ = $3 > $5 ? $3 : $5; }
1483         | MIN '(' any_expr ',' any_expr ')'
1484                 { $$ = $3 < $5 ? $3 : $5; }
1485         | INT '(' any_expr ')'
1486                 { $$ = floor($3); }
1487         | RAND '(' any_expr ')'
1488                 { $$ = 1.0 + floor(((rand()&0x7fff)/double(0x7fff))*$3); }
1489         | RAND '(' ')'
1490                 {
1491                   /* return a random number in the range [0,1) */
1492                   /* portable, but not very random */
1493                   $$ = (rand() & 0x7fff) / double(0x8000);
1494                 }
1495         | expr '<' expr
1496                 { $$ = ($1 < $3); }
1497         | expr LESSEQUAL expr
1498                 { $$ = ($1 <= $3); }
1499         | expr '>' expr
1500                 { $$ = ($1 > $3); }
1501         | expr GREATEREQUAL expr
1502                 { $$ = ($1 >= $3); }
1503         | expr EQUALEQUAL expr
1504                 { $$ = ($1 == $3); }
1505         | expr NOTEQUAL expr
1506                 { $$ = ($1 != $3); }
1507         | expr ANDAND expr
1508                 { $$ = ($1 != 0.0 && $3 != 0.0); }
1509         | expr OROR expr
1510                 { $$ = ($1 != 0.0 || $3 != 0.0); }
1511         | '!' expr
1512                 { $$ = ($2 == 0.0); }
1513
1514         ;
1515
1516 %%
1517
1518 /* bison defines const to be empty unless __STDC__ is defined, which it
1519 isn't under cfront */
1520
1521 #ifdef const
1522 #undef const
1523 #endif
1524
1525 static struct {
1526   const char *name;
1527   double val;
1528   int scaled;                // non-zero if val should be multiplied by scale
1529 } defaults_table[] = {
1530   "arcrad", .25, 1,
1531   "arrowht", .1, 1,
1532   "arrowwid", .05, 1,
1533   "circlerad", .25, 1,
1534   "boxht", .5, 1,
1535   "boxwid", .75, 1,
1536   "boxrad", 0.0, 1,
1537   "dashwid", .05, 1,
1538   "ellipseht", .5, 1,
1539   "ellipsewid", .75, 1,
1540   "moveht", .5, 1,
1541   "movewid", .5, 1,
1542   "lineht", .5, 1,
1543   "linewid", .5, 1,
1544   "textht", 0.0, 1,
1545   "textwid", 0.0, 1,
1546   "scale", 1.0, 0,
1547   "linethick", -1.0, 0,         // in points
1548   "fillval", .5, 0,
1549   "arrowhead", 1.0, 0,
1550   "maxpswid", 8.5, 0,
1551   "maxpsht", 11.0, 0,
1552 };
1553
1554 place *lookup_label(const char *label)
1555 {
1556   saved_state *state = current_saved_state;
1557   PTABLE(place) *tbl = current_table;
1558   for (;;) {
1559     place *pl = tbl->lookup(label);
1560     if (pl)
1561       return pl;
1562     if (!state)
1563       return 0;
1564     tbl = state->tbl;
1565     state = state->prev;
1566   }
1567 }
1568
1569 void define_label(const char *label, const place *pl)
1570 {
1571   place *p = new place;
1572   *p = *pl;
1573   current_table->define(label, p);
1574 }
1575
1576 int lookup_variable(const char *name, double *val)
1577 {
1578   place *pl = lookup_label(name);
1579   if (pl) {
1580     *val = pl->x;
1581     return 1;
1582   }
1583   return 0;
1584 }
1585
1586 void define_variable(const char *name, double val)
1587 {
1588   place *p = new place;
1589   p->obj = 0;
1590   p->x = val;
1591   p->y = 0.0;
1592   current_table->define(name, p);
1593   if (strcmp(name, "scale") == 0) {
1594     // When the scale changes, reset all scaled pre-defined variables to
1595     // their default values.
1596     for (int i = 0; i < sizeof(defaults_table)/sizeof(defaults_table[0]); i++)
1597       if (defaults_table[i].scaled)
1598         define_variable(defaults_table[i].name, val*defaults_table[i].val);
1599   }
1600 }
1601
1602 // called once only (not once per parse)
1603
1604 void parse_init()
1605 {
1606   current_direction = RIGHT_DIRECTION;
1607   current_position.x = 0.0;
1608   current_position.y = 0.0;
1609   // This resets everything to its default value.
1610   reset_all();
1611 }
1612
1613 void reset(const char *nm)
1614 {
1615   for (int i = 0; i < sizeof(defaults_table)/sizeof(defaults_table[0]); i++)
1616     if (strcmp(nm, defaults_table[i].name) == 0) {
1617       double val = defaults_table[i].val;
1618       if (defaults_table[i].scaled) {
1619         double scale;
1620         lookup_variable("scale", &scale);
1621         val *= scale;
1622       }
1623       define_variable(defaults_table[i].name, val);
1624       return;
1625     }
1626   lex_error("`%1' is not a predefined variable", nm);
1627 }
1628
1629 void reset_all()
1630 {
1631   // We only have to explicitly reset the pre-defined variables that
1632   // aren't scaled because `scale' is not scaled, and changing the
1633   // value of `scale' will reset all the pre-defined variables that
1634   // are scaled.
1635   for (int i = 0; i < sizeof(defaults_table)/sizeof(defaults_table[0]); i++)
1636     if (!defaults_table[i].scaled)
1637       define_variable(defaults_table[i].name, defaults_table[i].val);
1638 }
1639
1640 // called after each parse
1641
1642 void parse_cleanup()
1643 {
1644   while (current_saved_state != 0) {
1645     delete current_table;
1646     current_table = current_saved_state->tbl;
1647     saved_state *tem = current_saved_state;
1648     current_saved_state = current_saved_state->prev;
1649     delete tem;
1650   }
1651   assert(current_table == &top_table);
1652   PTABLE_ITERATOR(place) iter(current_table);
1653   const char *key;
1654   place *pl;
1655   while (iter.next(&key, &pl))
1656     if (pl->obj != 0) {
1657       position pos = pl->obj->origin();
1658       pl->obj = 0;
1659       pl->x = pos.x;
1660       pl->y = pos.y;
1661     }
1662   while (olist.head != 0) {
1663     object *tem = olist.head;
1664     olist.head = olist.head->next;
1665     delete tem;
1666   }
1667   olist.tail = 0;
1668   current_direction = RIGHT_DIRECTION;
1669   current_position.x = 0.0;
1670   current_position.y = 0.0;
1671 }
1672
1673 const char *ordinal_postfix(int n)
1674 {
1675   if (n < 10 || n > 20)
1676     switch (n % 10) {
1677     case 1:
1678       return "st";
1679     case 2:
1680       return "nd";
1681     case 3:
1682       return "rd";
1683     }
1684   return "th";
1685 }
1686
1687 const char *object_type_name(object_type type)
1688 {
1689   switch (type) {
1690   case BOX_OBJECT:
1691     return "box";
1692   case CIRCLE_OBJECT:
1693     return "circle";
1694   case ELLIPSE_OBJECT:
1695     return "ellipse";
1696   case ARC_OBJECT:
1697     return "arc";
1698   case SPLINE_OBJECT:
1699     return "spline";
1700   case LINE_OBJECT:
1701     return "line";
1702   case ARROW_OBJECT:
1703     return "arrow";
1704   case MOVE_OBJECT:
1705     return "move";
1706   case TEXT_OBJECT:
1707     return "\"\"";
1708   case BLOCK_OBJECT:
1709     return "[]";
1710   case OTHER_OBJECT:
1711   case MARK_OBJECT:
1712   default:
1713     break;
1714   }
1715   return "object";
1716 }
1717
1718 static char sprintf_buf[1024];
1719
1720 char *format_number(const char *form, double n)
1721 {
1722   if (form == 0)
1723     form = "%g";
1724   else {
1725     // this is a fairly feeble attempt at validation of the format
1726     int nspecs = 0;
1727     for (const char *p = form; *p != '\0'; p++)
1728       if (*p == '%') {
1729         if (p[1] == '%')
1730           p++;
1731         else
1732           nspecs++;
1733       }
1734     if (nspecs > 1) {
1735       lex_error("bad format `%1'", form);
1736       return strsave(form);
1737     }
1738   }
1739   sprintf(sprintf_buf, form, n);
1740   return strsave(sprintf_buf);
1741 }
1742
1743 char *do_sprintf(const char *form, const double *v, int nv)
1744 {
1745   string result;
1746   int i = 0;
1747   string one_format;
1748   while (*form) {
1749     if (*form == '%') {
1750       one_format += *form++;
1751       for (; *form != '\0' && strchr("#-+ 0123456789.", *form) != 0; form++)
1752         one_format += *form;
1753       if (*form == '\0' || strchr("eEfgG%", *form) == 0) {
1754         lex_error("bad sprintf format");
1755         result += one_format;
1756         result += form;
1757         break;
1758       }
1759       if (*form == '%') {
1760         one_format += *form++;
1761         one_format += '\0';
1762         sprintf(sprintf_buf, one_format.contents());
1763       }
1764       else {
1765         if (i >= nv) {
1766           lex_error("too few arguments to sprintf");
1767           result += one_format;
1768           result += form;
1769           break;
1770         }
1771         one_format += *form++;
1772         one_format += '\0';
1773         sprintf(sprintf_buf, one_format.contents(), v[i++]);
1774       }
1775       one_format.clear();
1776       result += sprintf_buf;
1777     }
1778     else
1779       result += *form++;
1780   }
1781   result += '\0';
1782   return strsave(result.contents());
1783 }