Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages


home | help
GRAP(1)			  BSD General Commands Manual		       GRAP(1)

     grap -- Kernighan and Bentley's language for typesetting graphs

     grap [-d defines_file] [-D] [-M include path] [-v]	[-u] [-C] [-c] [-h]
	  [filename ...]

     grap is an	implementation of Kernighan and	Bentley's language for type-
     setting graphs, as	described in ``Grap-A Language for Typesetting Graphs,
     Tutorial and User Manual,'' by Jon	L. Bentley and Brian W.	 Kernighan,
     revised May 1991, which is	the primary source for information on how to
     use grap.	As of this writing, it is available electronically at

     This version is a black box implementation	of grap, and some inconsisten-
     cies are to be expected.  The remainder of	this manual page will briefly
     outline the grap language as implemented here.

     grap is a pic(1) pre-processor.  It takes commands	embedded in a troff(1)
     source file which are surrounded by .G1 and .G2 macros, and rewrites them
     into pic commands to display the graph.  Other lines are copied.  Output
     is	always to the standard output, which is	usually	redirected.  Input is
     from the given filenames, which are read in order.	 A filename of - is
     the standard input.  If no	filenames are given, input is read from	the
     standard input.

     Because grap is a pic preprocessor, and gnu pic will output TeX, it is
     possible to use grap with TeX.

     The -d option specifies a file of macro definitions to be read at
     startup, and defaults to /usr/local/share/grap/grap.defines.  The -D op-
     tion inhibits the reading of any initial macros file.  The	defines	file
     can also be given using the GRAP_DEFINES environment variable. (See be-

     -v	prints the version information on the standard output and exits.
     --version is a synonym for	-v.

     -u	makes labels unaligned by default.  This version of grap uses new fea-
     tures of GNU pic to align the left	and right labels with the axes,	that
     is	that the left and right	labels run at right angles to the text of the
     paper.  This may be useful	in porting old grap programs.  -c makes	plot
     strings unclipped by default.  Some versions of grap allow	users to place
     a string anywhere in the coordinate space,	rather than only in the	frame.
     By	default	this version of	grap does not plot any string centered outside
     the frame.	 -c allows strings to be placed	anywhere.  See also the
     clipped and unclipped string modifiers described in the plot statement.

     -M	is followed by a colon-separated list of directories used to search
     for relative pathnames included via copy.	The path is also used to lo-
     cate the defines file, so if the -d changes the defines file name to a
     relative name, it will be searched	for in the path	given by -M.  The
     search path always	includes the current directory,	and by default that
     directory is searched last.

     All grap commands are included between .G1	and .G2	macros,	which are con-
     sumed by grap.  The output	contains pic between .PS and .PE macros.  Any
     arguments to the .G1 macro	in the input are arguments to the .PS macro in
     the output, so graphs can be scaled just like pic diagrams.  If -C	is
     given, any	macro beginning	with .G1 or .G2	is treated as a	.G1 or .G2
     macro, for	compatibility with old versions	of troff.  Using -C also
     forces pure troff syntax on embedded font change commands when strings
     have the size attribute, and all strings to be unclipped.

     The -h flag prints	a brief	help message and exist.	 --help	is a synonym
     for -h.

     It	is possible for	someone	to cause grap to fail by passing a bad format
     string and	data to	the sprintf command.  If grap is integrated as part of
     the printing system, this could conceivably provided a path to breaching
     security on the machine.  If you choose to	use grap as part of a printing
     system run	by the super-user, you should disable sprintf commands.	 This
     can be done by calling grap with the -S flag, setting the GRAP_SAFER en-
     vironment variable, or compiling with the GRAP_SAFER preprocessor symbol
     defined.  (The GNU	configure script included with grap will define	that
     preprocessor symbol if the	--with-grap-safe option	is given.)

     The grap commands are sketched below.  Refer to Kernighan and Bentley's
     paper for the details.

     New versions of groff(1) will invoke grap if -G is	given.

     Commands are separated from one another by	newlines or semicolons (;).

     frame [line_description] [ht height | wid width] [[(top|bottom|left|
     right) line_description] ...]

     frame [ht height |	wid width] [line_description] [[(top|bottom|left|
     right) line_description] ...]

	   This	  describes   how   the	 axes  for  the	 graph	are  drawn.  A
	   line_description is a pic line description, e.g.,  dashed  0.5,  or
	   the literal solid.  It may also include a color keyword followed by
	   the color to	draw the string	in double quotes.   Any	 color	under-
	   stood by the	underlying groff system	can be used.  Color can	nly be
	   used	under GNU pic, and is not available in compatibility mode.

	   If the first	line_description is given, the	frame  is  drawn  with
	   that	 style.	  The  default	is solid.  The height and width	of the
	   frame can also be specified in inches.  The default line style  can
	   be  over-ridden for sides of	the frame by specifying	additional pa-
	   rameters to frame.

	   If no plotting commands have	been given before the frame command is
	   issued,  the	 frame	will  be  output at that point in the plotting
	   stream relative to embedded troff or	pic commands.	Otherwise  the
	   frame  is  output  before  the first	plotted	object (even invisible

     coord [name] [x expr, expr] [y expr, expr]	[log x | log y | log log]

	   The coord command specifies a new coordinate	system or sets	limits
	   on  the default system.  It defines the largest and smallest	values
	   that	can be plotted,	and therefore the scale	of  the	 data  in  the
	   frame.   The	limits for the x and y coordinate systems can be given
	   separately.	If a name is given, that coordinate system is defined,
	   if not the default system is	modified.

	   A coordinate	system created by one coord command may	be modified by
	   subsequent coord commands.  A grap program may declare a coordinate
	   space  using	 coord,	copy a file of data through a macro that plots
	   the data and	finds its maxima and minima, and then define the  size
	   of the coordinate system with a second coord	statement.

	   This	command	also determines	if a scale is plotted logarithmically.
	   log log means the same thing	as log x log y.

     draw [line_name] [line_description] [plot_string]

	   The draw command defines the	style with which a given line will  be
	   plotted.   If line_name is given, the style is associated with that
	   name, otherwise the default style is	set.   line_description	 is  a
	   pic	line  description, and the optional plot_string	is a string to
	   be centered at each point.  The default line	description is	invis,
	   and the default plotting string is a	centered bullet, so by default
	   each	point is a filled circle, and they are unconnected.  If	points
	   are	being  connected,  each	draw command ends any current line and
	   begins a new	one.

	   When	defining a line	style, that is the first draw  command	for  a
	   given  line name, specifying	no plot	string means that there	are to
	   be no plot strings.	Omitting the plot string  on  subsequent  draw
	   commands  addressing	 the  same  named line means not to change the
	   plot	string.	 If a line has been defined with a  plot  string,  and
	   the	format	is  changed  by	 a subsequent draw statement, the plot
	   string can be removed by specifying "" in the draw statement.

	   The plot  string  can  have	its  format  changed  through  several
	   string_modifiers.   String_modifiers	 are described in the descrip-
	   tion	of the plot command.

	   new is a synonym for	draw.

     next [line_name] at [coordinates_name] expr, expr [line_description]

	   The next command plots the given point using	the line  style	 given
	   by  line_name,  or  the  default if none is given.  If line_name is
	   given, it should have been defined by an earlier draw  command,  if
	   not	a  new	line  style with that name is created, initialized the
	   same	way as the  default  style.   The  two	expressions  give  the
	   point's x and y values, relative to the optional coordinate system.
	   That	system should have been	defined	by an earlier  coord  command,
	   if not, grap	will exit.  If the optional line_description is	given,
	   it overrides	the style's  default  line  description.   You	cannot
	   over-ride  the plotting string.  To use a different plotting	string
	   use the plot	command.

	   The coordinates may optionally be enclosed in  parentheses:	(expr,

     quoted_string [string_modifiers] [, quoted_string [string_modifiers]] ...
     at	[coordinates_name] expr, expr

     plot expr [format_string] at [coordinates_name] expr, expr

	   These commands both plot a string at	the given point.  In the first
	   case	 the  literal  strings	are  stacked  above  each  other.  The
	   string_modifiers include the	pic  justification  modifiers  (ljust,
	   rjust, above, and below), and absolute and relative size modifiers.
	   See the pic documentation for the description of the	 justification
	   modifiers.	grap also supports the aligned and unaligned modifiers
	   which are briefly noted in the description of the label command.

	   Strings placed by either format of the plot command are  restricted
	   to  being  within  the  frame.   This can be	overriden by using the
	   unclipped attribute,	which allows a string to be plotted in or  out
	   of  the  frame.   The -c and	-C flags set unclipped on all strings,
	   and to prevent a string from	being plotted outside the  frame  when
	   those flags are active, the clipped attribute can be	used to	retore
	   clipping behavior.  Though clipped or unclipped can be  applied  to
	   any string, it only has meaning for plot statements.

	   size	expr sets the string size to expr points.  If expr is preceded
	   by a	+ or -,	the size  is  increased	 or  decreased	by  that  many

	   If color and	a color	name in	double quotes appears, the string will
	   be rendered in that color under a version of	GNU  troff  that  sup-
	   ports color.	 Color is not available	in compatibility mode.

	   In the second version, the expr is converted	to a string and	placed
	   on the graph.  format_string	is a printf(3)	format	string.	  Only
	   formatting  escapes for printing floating point numbers make	sense.
	   The format string is	only respected if the sprintf command is  also
	   active.   See  the  description  of sprintf for the various ways to
	   disable it.	Plot and sprintf respond differently when grap is run-
	   ning	 safely.   Sprintf  ignores  any arguments, passing the	format
	   string through  without  substitution.   plot  ignores  the	format
	   string completely, plotting expr using the "%g" format.

	   Points  are	specified  the same way	as for next commands, with the
	   same	consequences for undefined coordinate systems.

	   The second form of this command is because the first	 form  can  be
	   used	with a grap sprintf expression (See Expressions).

     ticks (left|right|top|bottom)[ (in|out) [expr]] [on|auto coord_name]

     ticks (left|right|top|bottom) (in|out) [expr] [up expr | down expr	| left
     expr | right expr]	at [coord_name]	expr [format_string] [[, expr
     [format_string]] ...]

     ticks (left|right|top|bottom) (in|out) [expr] [up expr | down expr	| left
     expr | right expr]	from [coord_name] start_expr to	end_expr [by [+|-|*|/]
     by_expr] [format_string]

     ticks [left|right|top|bottom] off

	   This	 command controls the placement	of ticks on the	frame.	By de-
	   fault, ticks	are automatically generated on	the  left  and	bottom
	   sides of the	frame.

	   The	first version of this command turns on the automatic tick gen-
	   eration for a given side.  The in or	out parameter controls the di-
	   rection and length of the ticks.  If	a coord_name is	specified, the
	   ticks are automatically generated using that	coordinate system.  If
	   no  system is specified, the	default	coordinate system is used.  As
	   with	next and plot, the coordinate system must be  declared	before
	   the ticks statement that references it.  This syntax	for requesting
	   automatically generated ticks is an extension, and will not port to
	   older grap implementations.

	   The	second	version	 of  the ticks command overrides the automatic
	   placement of	the ticks by specifying	a list of coordinates at which
	   to  place  the ticks.  If the ticks are not defined with respect to
	   the default coordinate system, the  coord_name  parameter  must  be
	   given.  For each tick a printf(3) style format string can be	given.
	   The format_string defaults to "%g".	The  format  string  can  also
	   take	 string	 modifiers as described	in the plot command.  To place
	   ticks with no labels, specify format_string as "".

	   If sprintf is disabled, ticks behaves as plot with respect  to  the
	   format string.

	   The	labels	on  the	ticks may be shifted by	specifying a direction
	   and the distance in inches to offset	the label.  That  is  the  op-
	   tional direction and	expression immediately preceding the at.

	   The	third  format of the ticks command over-rides the default tick
	   generation with a set of ticks ar regular intervals.	 The syntax is
	   reminiscent	of  programming	 language for loops.  Ticks are	placed
	   starting at start_expr ending at end_expr one unit apart.   If  the
	   by clause is	specified, ticks are by_expr units apart.  If an oper-
	   ator	appears	before by_expr each tick is operated on	by that	opera-
	   tor instead of +.  For example

		       ticks left out from 2 to	32 by *2

	   will	 put ticks at 2, 4, 8, 16, and 32.  If format_string is	speci-
	   fied, all ticks are formatted using it.

	   The parameters preceding the	from act as described above.

	   The at and for forms	of tick	command	may both be issued on the same
	   side	of a frame.  For example:

		       ticks left out from 2 to	32 by *2
		       ticks left in 3,	5, 7

	   will	 put ticks on the left side of the frame pointing out at 2, 4,
	   8, 16, and 32 and in	at 3, 5, and 7.

	   The final form of ticks turns off ticks on a	 given	side.	If  no
	   side	is given the ticks for all sides are cancelled.

	   tick	is a synonym for ticks.

     grid (left|right|top|bottom) [ticks off] [line_description] [up expr |
     down expr | left expr | right expr] [on|auto [coord_name]]

     grid (left|right|top|bottom) [ticks off] [line_description] [up expr |
     down expr | left expr | right expr] at [coord_name] expr [format_string]
     [[, expr [format_string]] ...]

     grid (left|right|top|bottom) [ticks off] [line_description] [up expr |
     down expr | left expr | right expr] from [coord_name] start_expr to
     end_expr [by [+|-|*|/] by_expr] [format_string]

	   The grid command is similar to the ticks command except  that  grid
	   specifies the placement of lines in the frame.  The syntax is simi-
	   lar to ticks	as well.

	   By specifying ticks off in the command, no ticks are	drawn on  that
	   side	 of  the frame.	 If ticks appear on a side by default, or have
	   been	declared by an earlier ticks command,  grid  does  not	cancel
	   them	unless ticks off is specified.

	   Instead  of	a  direction for ticks,	grid allows the	user to	pick a
	   line	description for	the grid lines.	 The usual pic	line  descrip-
	   tions are allowed.

	   Grids  are labelled by default.  To omit labels, specify the	format
	   string as "".

	   If sprintf is disabled, grid	behaves	as plot	with  respect  to  the
	   format string.

     label (left|right|top|bottom) quoted_string [string_modifiers] [,
     quoted_string [string_modifiers]] ...  [up	expr | down expr | left	expr |
     right expr]

	   The label command places a label on the given axis.	It is possible
	   to specify several labels, which will be stacked over each other as
	   in  pic.  The final argument, if present, specifies how many	inches
	   the label is	shifted	from the axis.

	   By default the labels on the	left and right labels run parallel  to
	   the	frame.	 You  can  cancel  this	 by  specifying	unaligned as a

     circle at [coordinate_name] expr, expr [radius expr] [linedesc]

	   This	draws an circle	at the point indicated.	 By default, the  cir-
	   cle	is small, 0.025	inches.	 This can be over-ridden by specifying
	   a radius.  The coordinates of the point are relative	to  the	 named
	   coordinate system, or the default system if none is specified.

	   This	 command  has  been extended to	take a line description, e.g.,
	   dotted.  It also accepts the	filling	extensions described below  in
	   the	bar  command.	It will	also accept a color keyword that gives
	   the color of	the outline of the  circle  in	double	quotes	and  a
	   fillcolor command that sets the color to fill the circle with simi-
	   larly.  Colors are only available when compatibility	mode  is  off,
	   and using a version of GNU pic that supports	color.

     line [line_description] from [coordinate_name] expr, expr to
     [coordinate_name] expr, expr [line_description]

     arrow [line_description] from [coordinate_name] expr, expr	to
     [coordinate_name] expr, expr [line_description]

	   This	draws a	line or	arrow from the first point to the second using
	   the	given  style.	The  default  line  style   is	 solid.	   The
	   line_description  can  be given either before the from or after the
	   to clause.  If both are given the second is used.  It  is  possible
	   to  specify	one point in one coordinate system and one in another,
	   note	that if	both points are	in a named coordinate system (even  if
	   they	 are  in  the  same named coordinate system), both points must
	   have	coordinate_name	given.

     copy ["filename"] [until "string"]	[thru macro]

	   The copy command imports data from another file  into  the  current
	   graph.  The form with only a	filename given is a simple file	inclu-
	   sion; the included file is simply read into the  input  stream  and
	   can	contain	arbitrary grap commands.  The more common case is that
	   it is a number list;	see Number Lists below.

	   The second form takes lines from the	file, splits them  into	 words
	   delimited  by  one  or  more	spaces,	and calls the given macro with
	   those words as parameters.  The macro may either be	defined	 here,
	   or  be a macro defined earlier.  See	Macros for more	information on

	   The filename	may be omitted if the until clause is present.	If  so
	   the	current	 file is treated as the	input file until string	is en-
	   countered at	the beginning of the line.

	   copy	is one of the workhorses of grap.  Check  out  the  paper  and
	   /usr/local/share/doc/grap/examples for more details.
     print (expr|string)

	   Prints its argument to the standard error.

     sh	block

	   This	 passes	 block to sh(1).  Unlike K&B grap no macro or variable
	   expansion is	done.  I believe that this is also true	 for  gnu  pic
	   version  1.10.   See	the Macros section for information on defining

     pic pic_statement

	   This	issues the given pic statements	 in the	enclosing .PS and  .PE
	   at the point	where the command is issued.

	   Statements	that   begin  with  a  period  are  considered	to  be
	   troff(statements) and are output in the enclosing .PS  and  .PE  at
	   the point where the command appears.

	   For	the  purposes  of relative placement of	pic or troff commands,
	   the frame is	output immediately before the first plotted object, or
	   the	frame  statement,  if any.  If the user	specifies pic or troff
	   commands and	neither	any plotable object nor	a frame	 command,  the
	   commands will not be	output.

     graph Name	pic_commands

	   This	command	is used	to position graphs with	respect	to each	other.
	   The current graph is	given the pic name Name	( pic names begin with
	   capital letters).  Any pic commands following the graph are used to
	   position the	next graph.  The frame of the graph is	available  for
	   use	with pic name Frame. The following places a second graph below
	   the first:

		       graph Linear
		       [ graph description ]
		       graph Exponential with .Frame.n at \
			       Linear.Frame.s -	(0, .05)
		       [ graph description ]

     name = expr

	   This	assigns	expr to	the variable  name.   grap  has	 only  numeric
	   (double) variables.

	   Assignment creates a	variable if it does not	exist.	Variables per-
	   sist	across graphs.	Assignments can	cascade; a = b = 35 assigns 35
	   to a	and b.

     bar (up|right) [coordinates_name] offset ht height	[wid width] [base
     base_offset] [line_description]

     bar [coordinates_name] expr, expr,	[coordinates_name] expr, expr,

	   The	bar command facilitates	drawing	bar graphs.  The first form of
	   the command describes the bar somewhat generally and	has grap place
	   it.	 The  bar may extend up	or to the right, is centered on	offset
	   and extends up or right height units	(in the	given coordinate  sys-
	   tem).  For example

		       bar up 3	ht 2

	   draws a 2 unit high bar sitting on the x axis, centered on x=3.  By
	   default bars	are 1 unit wide, but this can be changed with the  wid
	   keyword.  By	default	bars sit on the	base axis, i.e., bars directed
	   up will extend from y=0.  That may be overridden by the  base  key-
	   word.  (The bar described above has corners (2.5, 0)	and (3.5, 2).)

	   The	line description has been extended to include a	fill expr key-
	   word	that specifies the shading inside the bar.  Bars may be	 drawn
	   in  any  line style.	 They support the color	and fillcolor keywords
	   described under circle.

	   The second form of the command draws	a box with the two  points  as
	   corners.   This can be used to draw boxes highlighting certain data
	   as well as bar graphs.  Note	that filled bars will cover data drawn
	   under them.

   Control Flow
     if	expr then block	[else block]

	   The if statement provides simple conditional	execution.  If expr is
	   non-zero, the block after the then statement	is executed.   If  not
	   the	block  after the else is executed, if present.	See Macros for
	   the definition of blocks.  Early versions of	this implementation of
	   grap	treated	the blocks as macros that were defined and expanded in
	   place.  This	led to unnecessary confusion because explicit  separa-
	   tors	 were sometimes	called for.  Now, grap inserts a separator (;)
	   after the last character in block, so constructs like

	   if (x == 3) { y = y + 1 }
	   x = x + 1

	   behave as expected.	A separator is also appended to	the end	 of  a
	   for block.

     for name from from_expr to	to_expr	[by [+|-|*|/] by_expr] do block

	   This	 command executes block	iteratively.  The variable name	is set
	   to from_expr	and incremented	by by_expr until it  exceeds  to_expr.
	   The	iteration has the semantics defined in the ticks command.  The
	   definition of block is discussed in	Marcos.	  See  also  the  note
	   about implicit separators in	the description	of the if command.

	   An =	can be used in place of	from.

     grap supports a most standard arithmetic operators: + - / * ^.  The carat
     (^) is exponentiation.  In	an if statement	grap also supports the C logi-
     cal operators ==, !=, &&, || and unary !.	Also in	an if, == and != are
     overloaded	for the	comparison of quoted strings.  Parentheses are used
     for grouping.

     Assignment	is not allowed in an expression	in any context,	except for
     simple cascading of assignments.  a = b = 35 works	as expected; a = 3.5 *
     (b	= 10) does not execute.

     grap supports the following functions that	take one argument: log,	exp,
     int, sin, cos, sqrt, rand.	 The logarithms	are base 10 and	the trigono-
     metric functions are in radians.  eexp returns Euler's number to the
     given power and ln	returns	the natural logarithm.	The natural log	and
     exponentiation functions are extensions and are probably not available in
     other grap	implementations.

     rand returns a random number uniformly distributed	on [0,1).  The follow-
     ing two argument functions	are supported: atan2, min, max.	 atan2 works
     just like atan2(3).  The random number generator can be seeded by calling
     srand with	a single parameter (converted internally to an integer).  Be-
     cause its return value is of no use, you must use srand as	a separate
     statement,	it is not part of a valid expression.  srand is	not portable.

     The getpid	function takes no arguments and	returns	the process id.	 This
     may be used to seed the random number generator, but do not expect	cryp-
     tographically random values to result.

     Other than	string comparison, no expressions can use strings.  One	string
     valued function exists: sprintf (format, [expr [, expr]] ).  It operates
     like sprintf(3), except returning the value.  It can be used anywhere a
     quoted string is used.  If	grap is	run with -S, the environment variable
     GRAP_SAFER	is defined, or grap has	been compiled for safer	operation, the
     sprintf command will return the format string.  This mode of operation is
     only intended to be used only if grap is being used as part of a super-
     user enabled print	system.

     grap has a	simple but powerful macro facility.  Macros are	defined	using
     the define	command	:

     define name block
     undefine name

	   Every  occurrence  of  name	in the program text is replaced	by the
	   contents of block.  block is	defined	by a series of	statements  in
	   nested { }'s, or a series of	statements surrounded by the same let-
	   ter.	 An example of the latter is

		       define foo  X coord x 1,3 X
	   Each	time foo appears in the	text, it will be replaced by  coord  x
	   1,3.	  Macros  are  literal,	 and can contain newlines.  If a macro
	   does	not span multiple lines, it should end in a semicolon to avoid
	   parsing errors.

	   Macros  can take parameters,	too.  If a macro call is followed by a
	   parenthesized, comma-separated list the  values  starting  with  $1
	   will	 be  replaced in the macro with	the elements of	the list.  A $
	   not followed	by a digit is left unchanged.  This  parsing  is  very
	   rudimentary,	no nesting or parentheses or escaping of commas	is al-
	   lowed.  Also, there is no way to say	argument 1 followed by a digit
	   (${1}0 in sh(1)).

	   The following will draw a line with slope 1.

		       define foo { next at $1,	$2 }
		       for i from 1 to 5 { foo(i,i) }
	   Macros	persist	      across	   graphs.	 The	  file
	   /usr/local/share/grap/grap.defines contains simple macros for plot-
	   ting	common characters.  The	undefine command deletes a macro.

	   See	the  file /usr/local/share/doc/grap/examples for more examples
	   of macros.

   Number Lists
     A whitespace-separated list of numbers is treated specially.  The list is
     taken to be points	to be plotted using the	default	line style on the de-
     fault coordinate system.  If more than two	numbers	are given, the extra
     numbers are taken to be additional	y values to plot at the	first x	value.
     Number lists in DWB grap can be comma-separated, and this grap supports
     that as well.  More precisely, numbers in number lists can	be separated
     by	either whitespace, commas, or both.

	   1 2 3
	   4 5 6

     Will plot points using the	default	line style at (1,2), (1,3),(4,5) and
     (4,6).  A simple way to plot a set	of numbers in a	file named ./data is:

	   copy	"./data"

   Pic Macros
     grap defines pic macros that can be used in embedded pic code to place
     elements in the graph.  The macros	are x_gg, y_gg,	and xy_gg.  These
     macros define pic distances that correspond to the	given argument.	 They
     can be used to size boxes or to plot pic constructs on the	graph.	To
     place a given construct on	the graph, you should add Frame.Origin to it.
     Other coordinate spaces can be used by replacing gg with the name of the
     coordinate	space.	A coordinate space named gg cannot be reliably ac-
     cessed by these macros.

     The macros	are emitted immediately	before the frame is drawn.

     DWB grap may use these as part of its implementation.  This grap provides
     them only for compatibility.  Note	that these are very simple macros, and
     may not do	what you expect	under complex conditions.

     If	the environment	variable GRAP_DEFINES is defined, grap will look for
     its defines file there.  If that value is a relative path name the	path
     specified in the -M option	will be	searched for it.  GRAP_DEFINES over-
     rides the compiled	in location of the defines file, but may be overridden
     by	the -d or -D flags.

     If	GRAP_SAFER is set, sprintf is disabled to prevent forcing grap to core
     dump or smash the stack.


     atan2(3), groff(1), pic(1), printf(3), sh(1), sprintf(3), troff(1)

     There are several small incompatibilities with K&R	grap.  They include
     the sh command not	expanding variables and	macros,	and a more strict ad-
     herence to	parameter order	in the internal	commands.

     Although much improved, the error reporting code can still	be confused.
     Notably, an error in a macro is not detected until	the macro is used, and
     it	produces unusual output	in the error message.

     Iterating many times over a macro with no newlines	can run	grap out of

     This implementation was done by Ted Faber <>.  Bruce
     Lilly <> contributed many bug fixes, including a consid-
     erable revamp of the error	reporting code.	 If you	can actually find an
     error in your grap	code, you can probably thank him.  grap	was designed
     and specified by Brian Kernighan and Jon Bentley.

BSD				August 19, 1998				   BSD


Want to link to this manual page? Use this URL:

home | help