pic.y | searchcode

/opensource.apple.com/source/groff/groff-12/groff/pic/pic.y

#
Happy | 1823 lines | 1732 code | 91 blank | 0 comment | 0 complexity | 35f9e9e050a02e779884fbecde1e8cfc MD5 | raw file
Possible License(s): LGPL-2.0, MPL-2.0, GPL-2.0, ISC, LGPL-2.1, Apache-2.0, MPL-2.0-no-copyleft-exception, BSD-3-Clause, WTFPL, MIT, AGPL-1.0, AGPL-3.0

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
<head>
<title>pic.y</title>
<style type="text/css">
.enscript-comment { font-style: italic; color: rgb(178,34,34); }
.enscript-function-name { font-weight: bold; color: rgb(0,0,255); }
.enscript-variable-name { font-weight: bold; color: rgb(184,134,11); }
.enscript-keyword { font-weight: bold; color: rgb(160,32,240); }
.enscript-reference { font-weight: bold; color: rgb(95,158,160); }
.enscript-string { font-weight: bold; color: rgb(188,143,143); }
.enscript-builtin { font-weight: bold; color: rgb(218,112,214); }
.enscript-type { font-weight: bold; color: rgb(34,139,34); }
.enscript-highlight { text-decoration: underline; color: 0; }
</style>
</head>
<body id="top">
<h1 style="margin:8px;" id="f1">pic.y&nbsp;&nbsp;&nbsp;<span style="font-weight: normal; font-size: 0.5em;">[<a href="?txt">plain text</a>]</span></h1>
<hr/>
<div></div>
<pre>
/* Copyright (C) 1989, 1990, 1991, 1992 Free Software Foundation, Inc.
     Written by James Clark (<a href="mailto:jjc@jclark.com">jjc@jclark.com</a>)

This file is part of groff.

groff is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 2, or (at your option) any later
version.

groff is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License along
with groff; see the file COPYING.  If not, write to the Free Software
Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
%{
#include &quot;pic.h&quot;
#include &quot;ptable.h&quot;
#include &quot;object.h&quot;

extern int delim_flag;
extern void do_copy(const char *);
extern void copy_rest_thru(const char *, const char *);
extern void copy_file_thru(const char *, const char *, const char *);
extern void push_body(const char *);
extern void do_for(char *var, double from, double to,
		   int by_is_multiplicative, double by, char *body);
extern void do_lookahead();

#ifndef HAVE_FMOD
extern &quot;C&quot; {
  double fmod(double, double);
}
#endif

#undef rand
extern &quot;C&quot; {
  int rand();
}

/* Maximum number of characters produced by printf(&quot;%g&quot;) */
#define GDIGITS 14

int yylex();
void yyerror(const char *);

void reset(const char *nm);
void reset_all();

place *lookup_label(const char *);
void define_label(const char *label, const place *pl);

direction current_direction;
position current_position;

implement_ptable(place)

PTABLE(place) top_table;

PTABLE(place) *current_table = &amp;top_table;
saved_state *current_saved_state = 0;

object_list olist;

const char *ordinal_postfix(int n);
const char *object_type_name(object_type type);
char *format_number(const char *form, double n);
char *do_sprintf(const char *form, const double *v, int nv);

%}


%union {
	char *str;
	int n;
	double x;
	struct { double x, y; } pair;
	struct { double x; char *body; } if_data;
	struct { char *str; const char *filename; int lineno; } lstr;
	struct { double *v; int nv; int maxv; } dv;
	struct { double val; int is_multiplicative; } by;
	place pl;
	object *obj;
	corner crn;
	path *pth;
	object_spec *spec;
	saved_state *pstate;
	graphics_state state;
	object_type obtype;
}

%token &lt;str&gt; LABEL
%token &lt;str&gt; VARIABLE
%token &lt;x&gt; NUMBER
%token &lt;lstr&gt; TEXT
%token &lt;lstr&gt; COMMAND_LINE
%token &lt;str&gt; DELIMITED
%token &lt;n&gt; ORDINAL
%token TH
%token LEFT_ARROW_HEAD
%token RIGHT_ARROW_HEAD
%token DOUBLE_ARROW_HEAD
%token LAST
%token UP
%token DOWN
%token LEFT
%token RIGHT
%token BOX
%token CIRCLE
%token ELLIPSE
%token ARC
%token LINE
%token ARROW
%token MOVE
%token SPLINE
%token HEIGHT
%token RADIUS
%token WIDTH
%token DIAMETER
%token UP
%token DOWN
%token RIGHT
%token LEFT
%token FROM
%token TO
%token AT
%token WITH
%token BY
%token THEN
%token DOTTED
%token DASHED
%token CHOP
%token SAME
%token INVISIBLE
%token LJUST
%token RJUST
%token ABOVE
%token BELOW
%token OF
%token THE
%token WAY
%token BETWEEN
%token AND
%token HERE
%token DOT_N
%token DOT_E	
%token DOT_W
%token DOT_S
%token DOT_NE
%token DOT_SE
%token DOT_NW
%token DOT_SW
%token DOT_C
%token DOT_START
%token DOT_END
%token DOT_X
%token DOT_Y
%token DOT_HT
%token DOT_WID
%token DOT_RAD
%token SIN
%token COS
%token ATAN2
%token LOG
%token EXP
%token SQRT
%token K_MAX
%token K_MIN
%token INT
%token RAND
%token COPY
%token THRU
%token TOP
%token BOTTOM
%token UPPER
%token LOWER
%token SH
%token PRINT
%token CW
%token CCW
%token FOR
%token DO
%token IF
%token ELSE
%token ANDAND
%token OROR
%token NOTEQUAL
%token EQUALEQUAL
%token LESSEQUAL
%token GREATEREQUAL
%token LEFT_CORNER
%token RIGHT_CORNER
%token CENTER
%token END
%token START
%token RESET
%token UNTIL
%token PLOT
%token THICKNESS
%token FILL
%token ALIGNED
%token SPRINTF
%token COMMAND

%token DEFINE
%token UNDEF

/* this ensures that plot 17 &quot;%g&quot; parses as (plot 17 &quot;%g&quot;) */
%left PLOT
%left TEXT SPRINTF

/* give text adjustments higher precedence than TEXT, so that
box &quot;foo&quot; above ljust == box (&quot;foo&quot; above ljust)
*/

%left LJUST RJUST ABOVE BELOW

%left LEFT RIGHT
/* Give attributes that take an optional expression a higher
precedence than left and right, so that eg `line chop left'
parses properly. */
%left CHOP DASHED DOTTED UP DOWN FILL
%left LABEL

%left VARIABLE NUMBER '(' SIN COS ATAN2 LOG EXP SQRT K_MAX K_MIN INT RAND LAST 
%left ORDINAL HERE '`'

/* these need to be lower than '-' */
%left HEIGHT RADIUS WIDTH DIAMETER FROM TO AT THICKNESS

/* these must have higher precedence than CHOP so that `label %prec CHOP'
works */
%left DOT_N DOT_E DOT_W DOT_S DOT_NE DOT_SE DOT_NW DOT_SW DOT_C
%left DOT_START DOT_END TOP BOTTOM LEFT_CORNER RIGHT_CORNER
%left UPPER LOWER CENTER START END

%left ','
%left OROR
%left ANDAND
%left EQUALEQUAL NOTEQUAL
%left '&lt;' '&gt;' LESSEQUAL GREATEREQUAL

%left BETWEEN OF
%left AND

%left '+' '-'
%left '*' '/' '%'
%right '!'
%right '^'

%type &lt;x&gt; expr any_expr text_expr
%type &lt;by&gt; optional_by
%type &lt;pair&gt; expr_pair position_not_place
%type &lt;if_data&gt; simple_if
%type &lt;obj&gt; nth_primitive
%type &lt;crn&gt; corner
%type &lt;pth&gt; path label_path relative_path
%type &lt;pl&gt; place label element element_list middle_element_list
%type &lt;spec&gt; object_spec
%type &lt;pair&gt; position
%type &lt;obtype&gt; object_type
%type &lt;n&gt; optional_ordinal_last ordinal
%type &lt;str&gt; until
%type &lt;dv&gt; sprintf_args
%type &lt;lstr&gt; text print_args print_arg

%%

top:
	optional_separator
	| element_list
		{
		  if (olist.head)
		    print_picture(olist.head);
		}
	;


element_list:
	optional_separator middle_element_list optional_separator
		{ $$ = $2; }
	;

middle_element_list:
	element
		{ $$ = $1; }
	| middle_element_list separator element
		{ $$ = $1; }
	;

optional_separator:
	/* empty */
	| separator
	;

separator:
	';'
	| separator ';'
	;

placeless_element:
	VARIABLE '=' any_expr
		{
		  define_variable($1, $3);
		  a_delete $1;
		}
	| VARIABLE ':' '=' any_expr
		{
		  place *p = lookup_label($1);
		  if (!p) {
		    lex_error(&quot;variable `%1' not defined&quot;, $1);
		    YYABORT;
		  }
		  p-&gt;obj = 0;
		  p-&gt;x = $4;
		  p-&gt;y = 0.0;
		  a_delete $1;
		}
	| UP
		{ current_direction = UP_DIRECTION; }
	| DOWN
		{ current_direction = DOWN_DIRECTION; }
	| LEFT
		{ current_direction = LEFT_DIRECTION; }
	| RIGHT
		{ current_direction = RIGHT_DIRECTION; }
	| COMMAND_LINE
		{
		  olist.append(make_command_object($1.str, $1.filename,
						   $1.lineno));
		}
	| COMMAND print_args
		{
		  olist.append(make_command_object($2.str, $2.filename,
						   $2.lineno));
		}
	| PRINT print_args
		{
		  fprintf(stderr, &quot;%s\n&quot;, $2.str);
		  a_delete $2.str;
	          fflush(stderr);
		}
	| SH
		{ delim_flag = 1; }
	  DELIMITED
		{
		  delim_flag = 0;
		  if (safer_flag)
		    lex_error(&quot;unsafe to run command `%1'&quot;, $3);
		  else
		    system($3);
		  a_delete $3;
		}
	| COPY TEXT
		{
		  if (yychar &lt; 0)
		    do_lookahead();
		  do_copy($2.str);
		  // do not delete the filename
		}
	| COPY TEXT THRU
		{ delim_flag = 2; }
	  DELIMITED 
		{ delim_flag = 0; }
	  until
		{
		  if (yychar &lt; 0)
		    do_lookahead();
		  copy_file_thru($2.str, $5, $7);
		  // do not delete the filename
		  a_delete $5;
		  a_delete $7;
		}
	| COPY THRU
		{ delim_flag = 2; }
	  DELIMITED
		{ delim_flag = 0; }
	  until
		{
		  if (yychar &lt; 0)
		    do_lookahead();
		  copy_rest_thru($4, $6);
		  a_delete $4;
		  a_delete $6;
		}
	| FOR VARIABLE '=' expr TO expr optional_by DO
	  	{ delim_flag = 1; }
	  DELIMITED
	  	{
		  delim_flag = 0;
		  if (yychar &lt; 0)
		    do_lookahead();
		  do_for($2, $4, $6, $7.is_multiplicative, $7.val, $10); 
		}
	| simple_if
		{
		  if (yychar &lt; 0)
		    do_lookahead();
		  if ($1.x != 0.0)
		    push_body($1.body);
		  a_delete $1.body;
		}
	| simple_if ELSE
		{ delim_flag = 1; }
	  DELIMITED
		{
		  delim_flag = 0;
		  if (yychar &lt; 0)
		    do_lookahead();
		  if ($1.x != 0.0)
		    push_body($1.body);
		  else
		    push_body($4);
		  a_delete $1.body;
		  a_delete $4;
		}
	| reset_variables
	| RESET
		{ define_variable(&quot;scale&quot;, 1.0); }
	;

reset_variables:
	RESET VARIABLE
		{ reset($2); a_delete $2; }
	| reset_variables VARIABLE
		{ reset($2); a_delete $2; }
	| reset_variables ',' VARIABLE
		{ reset($3); a_delete $3; }
	;

print_args:
	print_arg
		{ $$ = $1; }
	| print_args print_arg
		{
		  $$.str = new char[strlen($1.str) + strlen($2.str) + 1];
		  strcpy($$.str, $1.str);
		  strcat($$.str, $2.str);
		  a_delete $1.str;
		  a_delete $2.str;
		  if ($1.filename) {
		    $$.filename = $1.filename;
		    $$.lineno = $1.lineno;
		  }
		  else if ($2.filename) {
		    $$.filename = $2.filename;
		    $$.lineno = $2.lineno;
		  }
		}
	;

print_arg:
  	expr               %prec ','
		{
		  $$.str = new char[GDIGITS + 1];
		  sprintf($$.str, &quot;%g&quot;, $1);
		  $$.filename = 0;
		  $$.lineno = 0;
		}
	| text
		{ $$ = $1; }
	| position          %prec ','
		{
		  $$.str = new char[GDIGITS + 2 + GDIGITS + 1];
		  sprintf($$.str, &quot;%g, %g&quot;, $1.x, $1.y);
		  $$.filename = 0;
		  $$.lineno = 0;
		}

simple_if:
	IF any_expr THEN
		{ delim_flag = 1; }
	DELIMITED
		{ delim_flag = 0; $$.x = $2; $$.body = $5; }
	;

until:
	/* empty */
		{ $$ = 0; }
	| UNTIL TEXT
		{ $$ = $2.str; }
	;
	
any_expr:
	expr
		{ $$ = $1; }
	| text_expr
		{ $$ = $1; }
	;
	
text_expr:
	text EQUALEQUAL text
		{
		  $$ = strcmp($1.str, $3.str) == 0;
		  a_delete $1.str;
		  a_delete $3.str;
		}
	| text NOTEQUAL text
		{
		  $$ = strcmp($1.str, $3.str) != 0;
		  a_delete $1.str;
		  a_delete $3.str;
		}
	| text_expr ANDAND text_expr
		{ $$ = ($1 != 0.0 &amp;&amp; $3 != 0.0); }
	| text_expr ANDAND expr
		{ $$ = ($1 != 0.0 &amp;&amp; $3 != 0.0); }
	| expr ANDAND text_expr
		{ $$ = ($1 != 0.0 &amp;&amp; $3 != 0.0); }
	| text_expr OROR text_expr
		{ $$ = ($1 != 0.0 || $3 != 0.0); }
	| text_expr OROR expr
		{ $$ = ($1 != 0.0 || $3 != 0.0); }
	| expr OROR text_expr
		{ $$ = ($1 != 0.0 || $3 != 0.0); }
	| '!' text_expr
		{ $$ = ($2 == 0.0); }
	;


optional_by:
	/* empty */
		{ $$.val = 1.0; $$.is_multiplicative = 0; }
	| BY expr
		{ $$.val = $2; $$.is_multiplicative = 0; }
	| BY '*' expr
		{ $$.val = $3; $$.is_multiplicative = 1; }
	;

element:
	object_spec
		{
		  $$.obj = $1-&gt;make_object(&amp;current_position,
					   &amp;current_direction);
		  if ($$.obj == 0)
		    YYABORT;
		  delete $1;
		  if ($$.obj)
		    olist.append($$.obj);
		  else {
		    $$.x = current_position.x;
		    $$.y = current_position.y;
		  }
		}
	| LABEL ':' optional_separator element
		{ $$ = $4; define_label($1, &amp; $$); a_delete $1; }
	| LABEL ':' optional_separator position_not_place
		{
		  $$.obj = 0;
		  $$.x = $4.x;
		  $$.y = $4.y;
		  define_label($1, &amp; $$);
		  a_delete $1;
		}
	| LABEL ':' optional_separator place
		{
		  $$ = $4;
		  define_label($1, &amp; $$);
		  a_delete $1;
		}
	| '{'
		{
		  $&lt;state&gt;$.x = current_position.x;
		  $&lt;state&gt;$.y = current_position.y;
		  $&lt;state&gt;$.dir = current_direction;
		}
	  element_list '}'
		{
		  current_position.x = $&lt;state&gt;2.x;
		  current_position.y = $&lt;state&gt;2.y;
		  current_direction = $&lt;state&gt;2.dir;
		}
	  optional_element
		{
		  $$ = $3;
		}
	| placeless_element
		{
		  $$.obj = 0;
		  $$.x = current_position.x;
		  $$.y = current_position.y;
		}
	;

optional_element:
	/* empty */
		{}
	| element
		{}
	;

object_spec:
	BOX
		{
		  $$ = new object_spec(BOX_OBJECT);
		}
	| CIRCLE
		{
		  $$ = new object_spec(CIRCLE_OBJECT);
		}
	| ELLIPSE
		{
		  $$ = new object_spec(ELLIPSE_OBJECT);
		}
	| ARC
		{
		  $$ = new object_spec(ARC_OBJECT);
		  $$-&gt;dir = current_direction;
		}
	| LINE
		{
		  $$ = new object_spec(LINE_OBJECT);
		  lookup_variable(&quot;lineht&quot;, &amp; $$-&gt;segment_height);
		  lookup_variable(&quot;linewid&quot;, &amp; $$-&gt;segment_width);
		  $$-&gt;dir = current_direction;
		}
	| ARROW
		{
		  $$ = new object_spec(ARROW_OBJECT);
		  lookup_variable(&quot;lineht&quot;, &amp; $$-&gt;segment_height);
		  lookup_variable(&quot;linewid&quot;, &amp; $$-&gt;segment_width);
		  $$-&gt;dir = current_direction;
		}
	| MOVE
		{
		  $$ = new object_spec(MOVE_OBJECT);
		  lookup_variable(&quot;moveht&quot;, &amp; $$-&gt;segment_height);
		  lookup_variable(&quot;movewid&quot;, &amp; $$-&gt;segment_width);
		  $$-&gt;dir = current_direction;
		}
	| SPLINE
		{
		  $$ = new object_spec(SPLINE_OBJECT);
		  lookup_variable(&quot;lineht&quot;, &amp; $$-&gt;segment_height);
		  lookup_variable(&quot;linewid&quot;, &amp; $$-&gt;segment_width);
		  $$-&gt;dir = current_direction;
		}
	| text   %prec TEXT
		{
		  $$ = new object_spec(TEXT_OBJECT);
		  $$-&gt;text = new text_item($1.str, $1.filename, $1.lineno);
		}
	| PLOT expr
		{
		  $$ = new object_spec(TEXT_OBJECT);
		  $$-&gt;text = new text_item(format_number(0, $2), 0, -1);
		}
	| PLOT expr text
		{
		  $$ = new object_spec(TEXT_OBJECT);
		  $$-&gt;text = new text_item(format_number($3.str, $2),
					   $3.filename, $3.lineno);
		  a_delete $3.str;
		}
	| '[' 
		{
		  saved_state *p = new saved_state;
		  $&lt;pstate&gt;$ = p;
		  p-&gt;x = current_position.x;
		  p-&gt;y = current_position.y;
		  p-&gt;dir = current_direction;
		  p-&gt;tbl = current_table;
		  p-&gt;prev = current_saved_state;
		  current_position.x = 0.0;
		  current_position.y = 0.0;
		  current_table = new PTABLE(place);
		  current_saved_state = p;
		  olist.append(make_mark_object());
		}
	  element_list ']'
		{
		  current_position.x = $&lt;pstate&gt;2-&gt;x;
		  current_position.y = $&lt;pstate&gt;2-&gt;y;
		  current_direction = $&lt;pstate&gt;2-&gt;dir;
		  $$ = new object_spec(BLOCK_OBJECT);
		  olist.wrap_up_block(&amp; $$-&gt;oblist);
		  $$-&gt;tbl = current_table;
		  current_table = $&lt;pstate&gt;2-&gt;tbl;
		  current_saved_state = $&lt;pstate&gt;2-&gt;prev;
		  delete $&lt;pstate&gt;2;
		}
	| object_spec HEIGHT expr
		{
		  $$ = $1;
		  $$-&gt;height = $3;
		  $$-&gt;flags |= HAS_HEIGHT;
		}
	| object_spec RADIUS expr
		{
		  $$ = $1;
		  $$-&gt;radius = $3;
		  $$-&gt;flags |= HAS_RADIUS;
		}
	| object_spec WIDTH expr
		{
		  $$ = $1;
		  $$-&gt;width = $3;
		  $$-&gt;flags |= HAS_WIDTH;
		}
	| object_spec DIAMETER expr
		{
		  $$ = $1;
		  $$-&gt;radius = $3/2.0;
		  $$-&gt;flags |= HAS_RADIUS;
		}
	| object_spec expr %prec HEIGHT
		{
		  $$ = $1;
		  $$-&gt;flags |= HAS_SEGMENT;
		  switch ($$-&gt;dir) {
		  case UP_DIRECTION:
		    $$-&gt;segment_pos.y += $2;
		    break;
		  case DOWN_DIRECTION:
		    $$-&gt;segment_pos.y -= $2;
		    break;
		  case RIGHT_DIRECTION:
		    $$-&gt;segment_pos.x += $2;
		    break;
		  case LEFT_DIRECTION:
		    $$-&gt;segment_pos.x -= $2;
		    break;
		  }
		}
	| object_spec UP
		{
		  $$ = $1;
		  $$-&gt;dir = UP_DIRECTION;
		  $$-&gt;flags |= HAS_SEGMENT;
		  $$-&gt;segment_pos.y += $$-&gt;segment_height;
		}
	| object_spec UP expr
		{
		  $$ = $1;
		  $$-&gt;dir = UP_DIRECTION;
		  $$-&gt;flags |= HAS_SEGMENT;
		  $$-&gt;segment_pos.y += $3;
		}
	| object_spec DOWN
		{
		  $$ = $1;
		  $$-&gt;dir = DOWN_DIRECTION;
		  $$-&gt;flags |= HAS_SEGMENT;
		  $$-&gt;segment_pos.y -= $$-&gt;segment_height;
		}
	| object_spec DOWN expr
		{
		  $$ = $1;
		  $$-&gt;dir = DOWN_DIRECTION;
		  $$-&gt;flags |= HAS_SEGMENT;
		  $$-&gt;segment_pos.y -= $3;
		}
	| object_spec RIGHT
		{
		  $$ = $1;
		  $$-&gt;dir = RIGHT_DIRECTION;
		  $$-&gt;flags |= HAS_SEGMENT;
		  $$-&gt;segment_pos.x += $$-&gt;segment_width;
		}
	| object_spec RIGHT expr
		{
		  $$ = $1;
		  $$-&gt;dir = RIGHT_DIRECTION;
		  $$-&gt;flags |= HAS_SEGMENT;
		  $$-&gt;segment_pos.x += $3;
		}
	| object_spec LEFT
		{
		  $$ = $1;
		  $$-&gt;dir = LEFT_DIRECTION;
		  $$-&gt;flags |= HAS_SEGMENT;
		  $$-&gt;segment_pos.x -= $$-&gt;segment_width;
		}
	| object_spec LEFT expr
		{
		  $$ = $1;
		  $$-&gt;dir = LEFT_DIRECTION;
		  $$-&gt;flags |= HAS_SEGMENT;
		  $$-&gt;segment_pos.x -= $3;
		}
	| object_spec FROM position
		{
		  $$ = $1;
		  $$-&gt;flags |= HAS_FROM;
		  $$-&gt;from.x = $3.x;
		  $$-&gt;from.y = $3.y;
		}
	| object_spec TO position
		{
		  $$ = $1;
		  if ($$-&gt;flags &amp; HAS_SEGMENT)
		    $$-&gt;segment_list = new segment($$-&gt;segment_pos,
						   $$-&gt;segment_is_absolute,
						   $$-&gt;segment_list);
		  $$-&gt;flags |= HAS_SEGMENT;
		  $$-&gt;segment_pos.x = $3.x;
		  $$-&gt;segment_pos.y = $3.y;
		  $$-&gt;segment_is_absolute = 1;
		  $$-&gt;flags |= HAS_TO;
		  $$-&gt;to.x = $3.x;
		  $$-&gt;to.y = $3.y;
		}
	| object_spec AT position
		{
		  $$ = $1;
		  $$-&gt;flags |= HAS_AT;
		  $$-&gt;at.x = $3.x;
		  $$-&gt;at.y = $3.y;
		  if ($$-&gt;type != ARC_OBJECT) {
		    $$-&gt;flags |= HAS_FROM;
		    $$-&gt;from.x = $3.x;
		    $$-&gt;from.y = $3.y;
		  }
		}
	| object_spec WITH path
		{
		  $$ = $1;
		  $$-&gt;flags |= HAS_WITH;
		  $$-&gt;with = $3;
		}
	| object_spec BY expr_pair
		{
		  $$ = $1;
		  $$-&gt;flags |= HAS_SEGMENT;
		  $$-&gt;segment_pos.x += $3.x;
		  $$-&gt;segment_pos.y += $3.y;
		}
	| object_spec THEN
  		{
		  $$ = $1;
		  if ($$-&gt;flags &amp; HAS_SEGMENT) {
		    $$-&gt;segment_list = new segment($$-&gt;segment_pos,
						   $$-&gt;segment_is_absolute,
						   $$-&gt;segment_list);
		    $$-&gt;flags &amp;= ~HAS_SEGMENT;
		    $$-&gt;segment_pos.x = $$-&gt;segment_pos.y = 0.0;
		    $$-&gt;segment_is_absolute = 0;
		  }
		}
	| object_spec DOTTED
		{
		  $$ = $1;
		  $$-&gt;flags |= IS_DOTTED;
		  lookup_variable(&quot;dashwid&quot;, &amp; $$-&gt;dash_width);
		}
	| object_spec DOTTED expr
		{
		  $$ = $1;
		  $$-&gt;flags |= IS_DOTTED;
		  $$-&gt;dash_width = $3;
		}
	| object_spec DASHED
		{
		  $$ = $1;
		  $$-&gt;flags |= IS_DASHED;
		  lookup_variable(&quot;dashwid&quot;, &amp; $$-&gt;dash_width);
		}
	| object_spec DASHED expr
		{
		  $$ = $1;
		  $$-&gt;flags |= IS_DASHED;
		  $$-&gt;dash_width = $3;
		}
	| object_spec FILL
		{
		  $$ = $1;
		  $$-&gt;flags |= IS_DEFAULT_FILLED;
		}
	| object_spec FILL expr
		{
		  $$ = $1;
		  $$-&gt;flags |= IS_FILLED;
		  $$-&gt;fill = $3;
		}
	| object_spec CHOP
  		{
		  $$ = $1;
		  // line chop chop means line chop 0 chop 0
		  if ($$-&gt;flags &amp; IS_DEFAULT_CHOPPED) {
		    $$-&gt;flags |= IS_CHOPPED;
		    $$-&gt;flags &amp;= ~IS_DEFAULT_CHOPPED;
		    $$-&gt;start_chop = $$-&gt;end_chop = 0.0;
		  }
		  else if ($$-&gt;flags &amp; IS_CHOPPED) {
		    $$-&gt;end_chop = 0.0;
		  }
		  else {
		    $$-&gt;flags |= IS_DEFAULT_CHOPPED;
		  }
		}
	| object_spec CHOP expr
		{
		  $$ = $1;
		  if ($$-&gt;flags &amp; IS_DEFAULT_CHOPPED) {
		    $$-&gt;flags |= IS_CHOPPED;
		    $$-&gt;flags &amp;= ~IS_DEFAULT_CHOPPED;
		    $$-&gt;start_chop = 0.0;
		    $$-&gt;end_chop = $3;
		  }
		  else if ($$-&gt;flags &amp; IS_CHOPPED) {
		    $$-&gt;end_chop = $3;
		  }
		  else {
		    $$-&gt;start_chop = $$-&gt;end_chop = $3;
		    $$-&gt;flags |= IS_CHOPPED;
		  }
		}
	| object_spec SAME
		{
		  $$ = $1;
		  $$-&gt;flags |= IS_SAME;
		}
	| object_spec INVISIBLE
		{
		  $$ = $1;
		  $$-&gt;flags |= IS_INVISIBLE;
		}
	| object_spec LEFT_ARROW_HEAD
		{
		  $$ = $1;
		  $$-&gt;flags |= HAS_LEFT_ARROW_HEAD;
		}
	| object_spec RIGHT_ARROW_HEAD
		{
		  $$ = $1;
		  $$-&gt;flags |= HAS_RIGHT_ARROW_HEAD;
		}
	| object_spec DOUBLE_ARROW_HEAD
		{
		  $$ = $1;
		  $$-&gt;flags |= (HAS_LEFT_ARROW_HEAD|HAS_RIGHT_ARROW_HEAD);
		}
	| object_spec CW
		{
		  $$ = $1;
		  $$-&gt;flags |= IS_CLOCKWISE;
		}
	| object_spec CCW
		{
		  $$ = $1;
		  $$-&gt;flags &amp;= ~IS_CLOCKWISE;
		}
	| object_spec text   %prec TEXT
		{
		  $$ = $1;
		  text_item **p;
		  for (p = &amp; $$-&gt;text; *p; p = &amp;(*p)-&gt;next)
		    ;
		  *p = new text_item($2.str, $2.filename, $2.lineno);
		}
	| object_spec LJUST
		{
		  $$ = $1;
		  if ($$-&gt;text) {
		    text_item *p;
		    for (p = $$-&gt;text; p-&gt;next; p = p-&gt;next)
		      ;
		    p-&gt;adj.h = LEFT_ADJUST;
		  }
		}
	| object_spec RJUST
		{
		  $$ = $1;
		  if ($$-&gt;text) {
		    text_item *p;
		    for (p = $$-&gt;text; p-&gt;next; p = p-&gt;next)
		      ;
		    p-&gt;adj.h = RIGHT_ADJUST;
		  }
		}
	| object_spec ABOVE
		{
		  $$ = $1;
		  if ($$-&gt;text) {
		    text_item *p;
		    for (p = $$-&gt;text; p-&gt;next; p = p-&gt;next)
		      ;
		    p-&gt;adj.v = ABOVE_ADJUST;
		  }
		}
	| object_spec BELOW
		{
		  $$ = $1;
		  if ($$-&gt;text) {
		    text_item *p;
		    for (p = $$-&gt;text; p-&gt;next; p = p-&gt;next)
		      ;
		    p-&gt;adj.v = BELOW_ADJUST;
		  }
		}
	| object_spec THICKNESS expr
		{
		  $$ = $1;
		  $$-&gt;flags |= HAS_THICKNESS;
		  $$-&gt;thickness = $3;
		}
	| object_spec ALIGNED
		{
		  $$ = $1;
		  $$-&gt;flags |= IS_ALIGNED;
		}
	;

text:
	TEXT
		{
		  $$ = $1;
		}
	| SPRINTF '(' TEXT sprintf_args ')'
		{
		  $$.filename = $3.filename;
		  $$.lineno = $3.lineno;
		  $$.str = do_sprintf($3.str, $4.v, $4.nv);
		  a_delete $4.v;
		  a_delete $3.str;
		}
	;

sprintf_args:
	/* empty */
		{
		  $$.v = 0;
		  $$.nv = 0;
		  $$.maxv = 0;
		}
	| sprintf_args ',' expr
		{
		  $$ = $1;
		  if ($$.nv &gt;= $$.maxv) {
		    if ($$.nv == 0) {
		      $$.v = new double[4];
		      $$.maxv = 4;
		    }
		    else {
		      double *oldv = $$.v;
		      $$.maxv *= 2;
		      $$.v = new double[$$.maxv];
		      memcpy($$.v, oldv, $$.nv*sizeof(double));
		      a_delete oldv;
		    }
		  }
		  $$.v[$$.nv] = $3;
		  $$.nv += 1;
		}
	;

position:
  	position_not_place
		{ $$ = $1; }
	| place
  		{
		  position pos = $1;
		  $$.x = pos.x;
		  $$.y = pos.y;
		}
	;

position_not_place:
	expr_pair
		{ $$ = $1; }
	| position '+' expr_pair
		{
		  $$.x = $1.x + $3.x;
		  $$.y = $1.y + $3.y;
		}
	| position '-' expr_pair
		{
		  $$.x = $1.x - $3.x;
		  $$.y = $1.y - $3.y;
		}
	| '(' position ',' position ')'
		{
		  $$.x = $2.x;
		  $$.y = $4.y;
		}
	| expr between position AND position
		{
		  $$.x = (1.0 - $1)*$3.x + $1*$5.x;
		  $$.y = (1.0 - $1)*$3.y + $1*$5.y;
		}
	| expr '&lt;' position ',' position '&gt;'
		{
		  $$.x = (1.0 - $1)*$3.x + $1*$5.x;
		  $$.y = (1.0 - $1)*$3.y + $1*$5.y;
		}
	;

between:
	BETWEEN
	| OF THE WAY BETWEEN
	;

expr_pair:
	expr ',' expr
		{ $$.x = $1; $$.y = $3; }
	| '(' expr_pair ')'
		{ $$ = $2; }
	;

place:
	label  %prec CHOP /* line at A left == line (at A) left */
		{ $$ = $1; }
	| label corner
		{
		  path pth($2);
		  if (!pth.follow($1, &amp; $$))
		    YYABORT;
		}
	| corner label
		{
		  path pth($1);
		  if (!pth.follow($2, &amp; $$))
		    YYABORT;
		}
	| corner OF label
		{
		  path pth($1);
		  if (!pth.follow($3, &amp; $$))
		    YYABORT;
		}
	| HERE
		{
		  $$.x = current_position.x;
		  $$.y = current_position.y;
		  $$.obj = 0;
		}
	;

label:
	LABEL
		{
		  place *p = lookup_label($1);
		  if (!p) {
		    lex_error(&quot;there is no place `%1'&quot;, $1);
		    YYABORT;
		  }
		  $$ = *p;
		  a_delete $1;
		}
	| nth_primitive
		{
		  $$.obj = $1;
		}
	| label '.' LABEL
		{
		  path pth($3);
		  if (!pth.follow($1, &amp; $$))
		    YYABORT;
		}
	;

ordinal:
	ORDINAL
		{ $$ = $1; }
	| '`' any_expr TH
		{
		  // XXX Check for overflow (and non-integers?).
		  $$ = (int)$2;
		}
	;

optional_ordinal_last:
        LAST
		{ $$ = 1; }
  	| ordinal LAST
		{ $$ = $1; }
	;

nth_primitive:
	ordinal object_type
		{
		  int count = 0;
		  object *p;
		  for (p = olist.head; p != 0; p = p-&gt;next)
		    if (p-&gt;type() == $2 &amp;&amp; ++count == $1) {
		      $$ = p;
		      break;
		    }
		  if (p == 0) {
		    lex_error(&quot;there is no %1%2 %3&quot;, $1, ordinal_postfix($1),
			      object_type_name($2));
		    YYABORT;
		  }
		}
	| optional_ordinal_last object_type
		{
		  int count = 0;
		  object *p;
		  for (p = olist.tail; p != 0; p = p-&gt;prev)
		    if (p-&gt;type() == $2 &amp;&amp; ++count == $1) {
		      $$ = p;
		      break;
		    }
		  if (p == 0) {
		    lex_error(&quot;there is no %1%2 last %3&quot;, $1,
			      ordinal_postfix($1), object_type_name($2));
		    YYABORT;
		  }
		}
	;

object_type:
	BOX
  		{ $$ = BOX_OBJECT; }
	| CIRCLE
		{ $$ = CIRCLE_OBJECT; }
	| ELLIPSE
		{ $$ = ELLIPSE_OBJECT; }
	| ARC
		{ $$ = ARC_OBJECT; }
	| LINE
		{ $$ = LINE_OBJECT; }
	| ARROW
		{ $$ = ARROW_OBJECT; }
	| SPLINE
		{ $$ = SPLINE_OBJECT; }
	| '[' ']'
		{ $$ = BLOCK_OBJECT; }
	| TEXT
		{ $$ = TEXT_OBJECT; }
	;

label_path:
 	'.' LABEL
		{
		  $$ = new path($2);
		}
	| label_path '.' LABEL
		{
		  $$ = $1;
		  $$-&gt;append($3);
		}
	;

relative_path:
	corner
		{
		  $$ = new path($1);
		}
	/* give this a lower precedence than LEFT and RIGHT so that
	   [A: box] with .A left == [A: box] with (.A left) */

  	| label_path %prec TEXT
		{
		  $$ = $1;
		}
	| label_path corner
		{
		  $$ = $1;
		  $$-&gt;append($2);
		}
	;

path:
	relative_path
		{
		  $$ = $1;
		}
	| '(' relative_path ',' relative_path ')'
		{
		  $$ = $2;
		  $$-&gt;set_ypath($4);
		}
	/* The rest of these rules are a compatibility sop. */
	| ORDINAL LAST object_type relative_path
		{
		  lex_warning(&quot;`%1%2 last %3' in `with' argument ignored&quot;,
			      $1, ordinal_postfix($1), object_type_name($3));
		  $$ = $4;
		}
	| LAST object_type relative_path
		{
		  lex_warning(&quot;`last %1' in `with' argument ignored&quot;,
			      object_type_name($2));
		  $$ = $3;
		}
	| ORDINAL object_type relative_path
		{
		  lex_warning(&quot;`%1%2 %3' in `with' argument ignored&quot;,
			      $1, ordinal_postfix($1), object_type_name($2));
		  $$ = $3;
		}
	| LABEL relative_path
		{
		  lex_warning(&quot;initial `%1' in `with' argument ignored&quot;, $1);
		  a_delete $1;
		  $$ = $2;
		}
	;

corner:
	DOT_N
		{ $$ = &amp;object::north; }
	| DOT_E	
		{ $$ = &amp;object::east; }
	| DOT_W
		{ $$ = &amp;object::west; }
	| DOT_S
		{ $$ = &amp;object::south; }
	| DOT_NE
		{ $$ = &amp;object::north_east; }
	| DOT_SE
		{ $$ = &amp;object:: south_east; }
	| DOT_NW
		{ $$ = &amp;object::north_west; }
	| DOT_SW
		{ $$ = &amp;object::south_west; }
	| DOT_C
		{ $$ = &amp;object::center; }
	| DOT_START
		{ $$ = &amp;object::start; }
	| DOT_END
		{ $$ = &amp;object::end; }
  	| TOP
		{ $$ = &amp;object::north; }
	| BOTTOM
		{ $$ = &amp;object::south; }
	| LEFT
		{ $$ = &amp;object::west; }
	| RIGHT
		{ $$ = &amp;object::east; }
	| UPPER LEFT
		{ $$ = &amp;object::north_west; }
	| LOWER LEFT
		{ $$ = &amp;object::south_west; }
	| UPPER RIGHT
		{ $$ = &amp;object::north_east; }
	| LOWER RIGHT
		{ $$ = &amp;object::south_east; }
	| LEFT_CORNER
		{ $$ = &amp;object::west; }
	| RIGHT_CORNER
		{ $$ = &amp;object::east; }
	| UPPER LEFT_CORNER
		{ $$ = &amp;object::north_west; }
	| LOWER LEFT_CORNER
		{ $$ = &amp;object::south_west; }
	| UPPER RIGHT_CORNER
		{ $$ = &amp;object::north_east; }
	| LOWER RIGHT_CORNER
		{ $$ = &amp;object::south_east; }
	| CENTER
		{ $$ = &amp;object::center; }
	| START
		{ $$ = &amp;object::start; }
	| END
		{ $$ = &amp;object::end; }
	;

expr:
	VARIABLE
		{
		  if (!lookup_variable($1, &amp; $$)) {
		    lex_error(&quot;there is no variable `%1'&quot;, $1);
		    YYABORT;
		  }
		  a_delete $1;
		}
	| NUMBER
		{ $$ = $1; }
	| place DOT_X
  		{
		  if ($1.obj != 0)
		    $$ = $1.obj-&gt;origin().x;
		  else
		    $$ = $1.x;
		}			
	| place DOT_Y
		{
		  if ($1.obj != 0)
		    $$ = $1.obj-&gt;origin().y;
		  else
		    $$ = $1.y;
		}
	| place DOT_HT
		{
		  if ($1.obj != 0)
		    $$ = $1.obj-&gt;height();
		  else
		    $$ = 0.0;
		}
	| place DOT_WID
		{
		  if ($1.obj != 0)
		    $$ = $1.obj-&gt;width();
		  else
		    $$ = 0.0;
		}
	| place DOT_RAD
		{
		  if ($1.obj != 0)
		    $$ = $1.obj-&gt;radius();
		  else
		    $$ = 0.0;
		}
	| expr '+' expr
		{ $$ = $1 + $3; }
	| expr '-' expr
		{ $$ = $1 - $3; }
	| expr '*' expr
		{ $$ = $1 * $3; }
	| expr '/' expr
		{
		  if ($3 == 0.0) {
		    lex_error(&quot;division by zero&quot;);
		    YYABORT;
		  }
		  $$ = $1/$3;
		}
	| expr '%' expr
		{
		  if ($3 == 0.0) {
		    lex_error(&quot;modulus by zero&quot;);
		    YYABORT;
		  }
		  $$ = fmod($1, $3);
		}
	| expr '^' expr
		{
		  errno = 0;
		  $$ = pow($1, $3);
		  if (errno == EDOM) {
		    lex_error(&quot;arguments to `^' operator out of domain&quot;);
		    YYABORT;
		  }
		  if (errno == ERANGE) {
		    lex_error(&quot;result of `^' operator out of range&quot;);
		    YYABORT;
		  }
		}
	| '-' expr    %prec '!'
		{ $$ = -$2; }
	| '(' any_expr ')'
		{ $$ = $2; }
	| SIN '(' any_expr ')'
		{
		  errno = 0;
		  $$ = sin($3);
		  if (errno == ERANGE) {
		    lex_error(&quot;sin result out of range&quot;);
		    YYABORT;
		  }
		}
	| COS '(' any_expr ')'
		{
		  errno = 0;
		  $$ = cos($3);
		  if (errno == ERANGE) {
		    lex_error(&quot;cos result out of range&quot;);
		    YYABORT;
		  }
		}
	| ATAN2 '(' any_expr ',' any_expr ')'
		{
		  errno = 0;
		  $$ = atan2($3, $5);
		  if (errno == EDOM) {
		    lex_error(&quot;atan2 argument out of domain&quot;);
		    YYABORT;
		  }
		  if (errno == ERANGE) {
		    lex_error(&quot;atan2 result out of range&quot;);
		    YYABORT;
		  }
		}
	| LOG '(' any_expr ')'
		{
		  errno = 0;
		  $$ = log10($3);
		  if (errno == ERANGE) {
		    lex_error(&quot;log result out of range&quot;);
		    YYABORT;
		  }
		}
	| EXP '(' any_expr ')'
		{
		  errno = 0;
		  $$ = pow(10.0, $3);
		  if (errno == ERANGE) {
		    lex_error(&quot;exp result out of range&quot;);
		    YYABORT;
		  }
		}
	| SQRT '(' any_expr ')'
		{
		  errno = 0;
		  $$ = sqrt($3);
		  if (errno == EDOM) {
		    lex_error(&quot;sqrt argument out of domain&quot;);
		    YYABORT;
		  }
		}
	| K_MAX '(' any_expr ',' any_expr ')'
		{ $$ = $3 &gt; $5 ? $3 : $5; }
	| K_MIN '(' any_expr ',' any_expr ')'
		{ $$ = $3 &lt; $5 ? $3 : $5; }
	| INT '(' any_expr ')'
		{ $$ = floor($3); }
	| RAND '(' any_expr ')'
		{ $$ = 1.0 + floor(((rand()&amp;0x7fff)/double(0x7fff))*$3); }
	| RAND '(' ')'
		{
		  /* return a random number in the range [0,1) */
		  /* portable, but not very random */
		  $$ = (rand() &amp; 0x7fff) / double(0x8000);
		}
	| expr '&lt;' expr
		{ $$ = ($1 &lt; $3); }
	| expr LESSEQUAL expr
		{ $$ = ($1 &lt;= $3); }
	| expr '&gt;' expr
		{ $$ = ($1 &gt; $3); }
	| expr GREATEREQUAL expr
		{ $$ = ($1 &gt;= $3); }
	| expr EQUALEQUAL expr
		{ $$ = ($1 == $3); }
	| expr NOTEQUAL expr
		{ $$ = ($1 != $3); }
	| expr ANDAND expr
		{ $$ = ($1 != 0.0 &amp;&amp; $3 != 0.0); }
	| expr OROR expr
		{ $$ = ($1 != 0.0 || $3 != 0.0); }
	| '!' expr
		{ $$ = ($2 == 0.0); }

	;

%%

/* bison defines const to be empty unless __STDC__ is defined, which it
isn't under cfront */

#ifdef const
#undef const
#endif

static struct {
  const char *name;
  double val;
  int scaled;		     // non-zero if val should be multiplied by scale
} defaults_table[] = {
  { &quot;arcrad&quot;, .25, 1 },
  { &quot;arrowht&quot;, .1, 1 },
  { &quot;arrowwid&quot;, .05, 1 },
  { &quot;circlerad&quot;, .25, 1 },
  { &quot;boxht&quot;, .5, 1 },
  { &quot;boxwid&quot;, .75, 1 },
  { &quot;boxrad&quot;, 0.0, 1 },
  { &quot;dashwid&quot;, .05, 1 },
  { &quot;ellipseht&quot;, .5, 1 },
  { &quot;ellipsewid&quot;, .75, 1 },
  { &quot;moveht&quot;, .5, 1 },
  { &quot;movewid&quot;, .5, 1 },
  { &quot;lineht&quot;, .5, 1 },
  { &quot;linewid&quot;, .5, 1 },
  { &quot;textht&quot;, 0.0, 1 },
  { &quot;textwid&quot;, 0.0, 1 },
  { &quot;scale&quot;, 1.0, 0 },
  { &quot;linethick&quot;, -1.0, 0 },		// in points
  { &quot;fillval&quot;, .5, 0 },
  { &quot;arrowhead&quot;, 1.0, 0 },
  { &quot;maxpswid&quot;, 8.5, 0 },
  { &quot;maxpsht&quot;, 11.0, 0 },
};

place *lookup_label(const char *label)
{
  saved_state *state = current_saved_state;
  PTABLE(place) *tbl = current_table;
  for (;;) {
    place *pl = tbl-&gt;lookup(label);
    if (pl)
      return pl;
    if (!state)
      return 0;
    tbl = state-&gt;tbl;
    state = state-&gt;prev;
  }
}

void define_label(const char *label, const place *pl)
{
  place *p = new place;
  *p = *pl;
  current_table-&gt;define(label, p);
}

int lookup_variable(const char *name, double *val)
{
  place *pl = lookup_label(name);
  if (pl) {
    *val = pl-&gt;x;
    return 1;
  }
  return 0;
}

void define_variable(const char *name, double val)
{
  place *p = new place;
  p-&gt;obj = 0;
  p-&gt;x = val;
  p-&gt;y = 0.0;
  current_table-&gt;define(name, p);
  if (strcmp(name, &quot;scale&quot;) == 0) {
    // When the scale changes, reset all scaled pre-defined variables to
    // their default values.
    for (int i = 0; i &lt; sizeof(defaults_table)/sizeof(defaults_table[0]); i++) 
      if (defaults_table[i].scaled)
	define_variable(defaults_table[i].name, val*defaults_table[i].val);
  }
}

// called once only (not once per parse)

void parse_init()
{
  current_direction = RIGHT_DIRECTION;
  current_position.x = 0.0;
  current_position.y = 0.0;
  // This resets everything to its default value.
  reset_all();
}

void reset(const char *nm)
{
  for (int i = 0; i &lt; sizeof(defaults_table)/sizeof(defaults_table[0]); i++)
    if (strcmp(nm, defaults_table[i].name) == 0) {
      double val = defaults_table[i].val;
      if (defaults_table[i].scaled) {
	double scale;
	lookup_variable(&quot;scale&quot;, &amp;scale);
	val *= scale;
      }
      define_variable(defaults_table[i].name, val);
      return;
    }
  lex_error(&quot;`%1' is not a predefined variable&quot;, nm);
}

void reset_all()
{
  // We only have to explicitly reset the pre-defined variables that
  // aren't scaled because `scale' is not scaled, and changing the
  // value of `scale' will reset all the pre-defined variables that
  // are scaled.
  for (int i = 0; i &lt; sizeof(defaults_table)/sizeof(defaults_table[0]); i++)
    if (!defaults_table[i].scaled)
      define_variable(defaults_table[i].name, defaults_table[i].val);
}

// called after each parse

void parse_cleanup()
{
  while (current_saved_state != 0) {
    delete current_table;
    current_table = current_saved_state-&gt;tbl;
    saved_state *tem = current_saved_state;
    current_saved_state = current_saved_state-&gt;prev;
    delete tem;
  }
  assert(current_table == &amp;top_table);
  PTABLE_ITERATOR(place) iter(current_table);
  const char *key;
  place *pl;
  while (iter.next(&amp;key, &amp;pl))
    if (pl-&gt;obj != 0) {
      position pos = pl-&gt;obj-&gt;origin();
      pl-&gt;obj = 0;
      pl-&gt;x = pos.x;
      pl-&gt;y = pos.y;
    }
  while (olist.head != 0) {
    object *tem = olist.head;
    olist.head = olist.head-&gt;next;
    delete tem;
  }
  olist.tail = 0;
  current_direction = RIGHT_DIRECTION;
  current_position.x = 0.0;
  current_position.y = 0.0;
}

const char *ordinal_postfix(int n)
{
  if (n &lt; 10 || n &gt; 20)
    switch (n % 10) {
    case 1:
      return &quot;st&quot;;
    case 2:
      return &quot;nd&quot;;
    case 3:
      return &quot;rd&quot;;
    }
  return &quot;th&quot;;
}

const char *object_type_name(object_type type)
{
  switch (type) {
  case BOX_OBJECT:
    return &quot;box&quot;;
  case CIRCLE_OBJECT:
    return &quot;circle&quot;;
  case ELLIPSE_OBJECT:
    return &quot;ellipse&quot;;
  case ARC_OBJECT:
    return &quot;arc&quot;;
  case SPLINE_OBJECT:
    return &quot;spline&quot;;
  case LINE_OBJECT:
    return &quot;line&quot;;
  case ARROW_OBJECT:
    return &quot;arrow&quot;;
  case MOVE_OBJECT:
    return &quot;move&quot;;
  case TEXT_OBJECT:
    return &quot;\&quot;\&quot;&quot;;
  case BLOCK_OBJECT:
    return &quot;[]&quot;;
  case OTHER_OBJECT:
  case MARK_OBJECT:
  default:
    break;
  }
  return &quot;object&quot;;
}

static char sprintf_buf[1024];

char *format_number(const char *form, double n)
{
  if (form == 0)
    form = &quot;%g&quot;;
  else {
    // this is a fairly feeble attempt at validation of the format
    int nspecs = 0;
    for (const char *p = form; *p != '\0'; p++)
      if (*p == '%') {
	if (p[1] == '%')
	  p++;
	else
	  nspecs++;
      }
    if (nspecs &gt; 1) {
      lex_error(&quot;bad format `%1'&quot;, form);
      return strsave(form);
    }
  }
  sprintf(sprintf_buf, form, n);
  return strsave(sprintf_buf);
}

char *do_sprintf(const char *form, const double *v, int nv)
{
  string result;
  int i = 0;
  string one_format;
  while (*form) {
    if (*form == '%') {
      one_format += *form++;
      for (; *form != '\0' &amp;&amp; strchr(&quot;#-+ 0123456789.&quot;, *form) != 0; form++)
	one_format += *form;
      if (*form == '\0' || strchr(&quot;eEfgG%&quot;, *form) == 0) {
	lex_error(&quot;bad sprintf format&quot;);
	result += one_format;
	result += form;
	break;
      }
      if (*form == '%') {
	one_format += *form++;
	one_format += '\0';
	sprintf(sprintf_buf, one_format.contents());
      }
      else {
	if (i &gt;= nv) {
	  lex_error(&quot;too few arguments to sprintf&quot;);
	  result += one_format;
	  result += form;
	  break;
	}
	one_format += *form++;
	one_format += '\0';
	sprintf(sprintf_buf, one_format.contents(), v[i++]);
      }
      one_format.clear();
      result += sprintf_buf;
    }
    else
      result += *form++;
  }
  result += '\0';
  return strsave(result.contents());
}
</pre>
<hr />
</body></html>