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

FreeBSD Manual Pages

  
 
  

home | help
SC 6.21	(1)		    General Commands Manual		   SC 6.21 (1)

NAME
       sc - spreadsheet	calculator

SYNOPSIS
       sc [ -c ] [ -m ]	[ -n ] [ -r ] [	-x ] [ file ]

DESCRIPTION
       The  spreadsheet	calculator sc is based on rectangular tables much like
       a financial spreadsheet.	 When invoked it presents you with a table or-
       ganized	as rows	and columns of cells.  If invoked without a file argu-
       ment, the table is initially empty.  Otherwise file is read in (see the
       Get  command  below).   Each cell may have associated with it a numeric
       value, a	label string, and/or an	expression (formula)  which  evaluates
       to a numeric value or label string, often based on other	cell values.

       For a on-line tutorial, type the	command:

	      sc /usr/local/share/sc/tutorial.sc

       To print	a quick	reference card,	type the command:

	      scqref | [your_printer_commmand]

OPTIONS
       -c     Start  the  program  with	the recalculation being	done in	column
	      order.

       -m     Start the	program	with automatic	recalculation  disabled.   The
	      spreadsheet  will	be recalculated	only when the ``@'' command is
	      used.

       -n     Start the	program	in quick numeric entry mode (see below).

       -r     Start the	program	with the recalculation being done in row order
	      (default option).

       -x     Cause  the  Get  and Put commands	(see below) to encrypt and de-
	      crypt data files.

       -R     Start the	program	with automatic newline action set to increment
	      the row (see below).

       -C     Start the	program	with automatic newline action set to increment
	      the column (see below).

       All of these options can	be changed with	the ^T and S commands (see be-
       low)  while  sc is running.  Options specified when sc is invoked over-
       ride options saved in the data file.

   General Information
       The screen is divided into four regions.	 The top line is for  entering
       commands	 and  displaying cell values.  The second line is for messages
       from sc.	 The third line	and the	first four columns show	the column and
       row  numbers,  from  which are derived cell addresses, e.g.  A0 for the
       cell in column A, row 0.	 Note that column names	are  case-insensitive:
       you can enter A0	or a0.

       The  rest  of the screen	forms a	window looking at a portion of the ta-
       ble.  The total number of display rows and columns available, hence the
       number of table rows and	columns	displayed, is set by curses(3) and may
       be overridden by	setting	the LINES and COLUMNS  environment  variables,
       respectively.

       The  screen  has	two cursors: a cell cursor, indicated by a highlighted
       cell and	a ``<''	on the screen, and a character	cursor,	 indicated  by
       the terminal's hardware cursor.	The cell and character cursors are of-
       ten the same.  They differ when you type	a command on the top line.

       If a cell's numeric value is wider than the column  width  (see	the  f
       command),  the cell is filled with asterisks.  If a cell's label	string
       is wider	than the column	width, it is truncated at  the	start  of  the
       next non-blank cell in the row, if any.

       Cursor  control commands	and row	and column commands can	be prefixed by
       a numeric argument which	indicates how many times the command is	to  be
       executed.  You can type ^U before a repeat count	if quick numeric entry
       mode is enabled or if the number	is to be entered while	the  character
       cursor is on the	top line.

       Commands	 which	use  the terminal's control key, such as ^N, work both
       when a command is being typed and when in normal	mode.

   Changing Options

       ^To    Toggle options.  This command allows you to switch the state  of
	      one  option selected by o.  A small menu lists the choices for o
	      when you type ^T.	 The options selected are saved	when the  data
	      and formulas are saved so	that you will have the same setup next
	      time you enter the spreadsheet.

	      a	     Automatic Recalculation.  When set, each  change  in  the
		     spreadsheet  causes  the  entire  spreadsheet be recalcu-
		     lated.  Normally this is not  noticeable,	but  for  very
		     large  spreadsheets,  it may be faster to clear automatic
		     recalculation mode	and update  the	 spreadsheet  via  ex-
		     plicit  ``@''  commands.  Default is automatic recalcula-
		     tion on.

	      c	     Current cell highlighting.	 If enabled, the current  cell
		     is	 highlighted  (using  the terminal's standout mode, if
		     available)	in addition to being marked by the  cell  cur-
		     sor.

	      e	     External  function	 execution.   When  disabled, external
		     functions (see @ext() below) are not called.  This	 saves
		     a	lot of time at each screen update.  External functions
		     are disabled by default.  If disabled, and	external func-
		     tions  are	 used anywhere,	a warning is printed each time
		     the screen	is updated, and	the result of  @ext()  is  the
		     value from	the previous call, if any, or a	null string.

	      l	     Autolabeling.   If	enabled, using the define command (/d)
		     causes a label to be automatically	generated in the  cell
		     to	 the  left  of the defined cell.  This is only done if
		     the cell to the left is empty.  Default is	enabled.

	      n	     Quick numeric entry.  If enabled, a typed	digit  is  as-
		     sumed  to be the start of a numeric value for the current
		     cell, not a repeat	count, unless  preceded	 by  ^U.   The
		     cursor  controls (^P, ^N, ^B, ^F) in this mode will end a
		     numeric entry.

	      t	     Top line display.	If enabled, the	name and value of  the
		     current  cell  is displayed on the	top line.  If there is
		     an	associated label string, the first  character  of  the
		     string  value is ``|'' for	a centered string, ``<'' for a
		     leftstring	or ``>'' for a rightstring (see	 below),  fol-
		     lowed  by	"string" for a constant	string or {expr} for a
		     string expression.	 A constant string  may	 be  preceeded
		     with a backslash (`\').  In this case the constant	string
		     will be used as a ``wheel'' to fill a column,  e.g.  "\-"
		     for a line	in a column, and "\Yeh " for "Yeh Yeh Ye".  If
		     the cell has a numeric  value,  it	 follows  as  [value],
		     which may be a constant or	expression.

	      x	     Encryption.  See the -x option.

	      $	     Dollar  prescale.	If enabled, all	numeric	constants (not
		     expressions) which	you enter are multipled	by 0.01	so you
		     don't  have to keep typing	the decimal point if you enter
		     lots of dollar figures.

	      r	     Newline action.  This option toggles between three	cases.
		     The  default  is no action.  If this option is used once,
		     after each	command	which is terminated by a newline char-
		     acter  is	completed, the current cell will be moved down
		     one row.  If this option is used again, after  each  com-
		     mand  which  is terminated	by a newline character is com-
		     pleted, the current cell will be moved right one  column.
		     Another  use  of this option will restore the default ac-
		     tion.

	      z	     Set newline action	limits.	 This option  sets  limits  to
		     the newline action	option above.  When this option	is in-
		     voked, the	row and	column of the current cell are	remem-
		     bered.   If a later newline action	would take the current
		     cell to the right of the remembered column, then the cur-
		     rent  cell	 is  instead  moved to the first column	of the
		     next row.	If a newline action  would  take  the  current
		     cell  below  the remembered row, then the current cell is
		     instead moved to the top row of the next column.

	      The quick	numeric	entry, newline action and set  newline	action
	      limits  options  can  be	combined  to allow very	quick entry of
	      large amounts of data.  If all the data to be entered  is	 in  a
	      single  row  or  column then setting the quick numeric entry and
	      the appropriate newline action will allow	the numbers to be  en-
	      tered without any	explicit commands to position the current cell
	      or enter a number.

	      If the data entry	involves several entries in each row for  many
	      rows,  then  setting the quick numeric entry option, setting the
	      newline action to	move right after each entry  and  setting  the
	      newline action limits on the last	column on which	data should be
	      entered will allow the data to entered quickly.	If  necessary,
	      columns  which do	not need data to be entered can	be hidden with
	      the z command.  Similar arrangements can be  made	 for  entering
	      several rows of data in each column.

       S      Set options.  This command allows	you to set various options.  A
	      small menu lists the options that	cannot be changed  through  ^T
	      above.

	      byrows/bycols
		     Specify  the  order cell evaluation when updating.	 These
		     options also affect the order in which cells  are	filled
		     (see  /f)	and whether a row or column is cleared by an x
		     command.

	      iterations=n
		     Set the  maximum  number  of  recalculations  before  the
		     screen  is	 displayed  again.  Iterations is set to 10 by
		     default.

	      tblstyle=s
		     Control the output	of the T command.  s can  be:  0  (de-
		     fault)  to	 give colon delimited fields, with no tbl con-
		     trol lines; tbl to	 give  colon  delimited	 fields,  with
		     tbl(1) control lines; latex to give a LaTeX tabular envi-
		     ronment; slatex to	give  a	 SLaTeX	 (Scandinavian	LaTeX)
		     tabular  environment;  tex	 to  give  a TeX simple	tabbed
		     alignment with ampersands as  delimiters;	and  frame  to
		     give a tblstyle output for	FrameMaker.

	      Other  Set options are normally used only	in sc data files since
	      they are available through ^T.  You can also use	them  interac-
	      tively

	      autocalc/!autocalc
		     Set/clear auto recalculation mode.

	      numeric/!numeric
		     Set/clear numeric mode.

	      prescale/!prescale
		     Set/clear numeric prescale	mode.

	      extfun/!extfun
		     Enable/disable external functions.

	      cellcur/!cellcur
		     Set/clear current cell highlighting mode.

	      toprow/!toprow
		     Set/clear top row display mode.

	      rndinfinity/!rndinfinity
		     default:  round-to-even  (banker's	round),	*.5 will round
		     to	the closest even number;  doing	 a  'set  rndinfinity'
		     will round	*.5 up to the next integer (rounding to	infin-
		     ity).

	      craction=n
		     Set the newline action.  n	can be:	0 (default) to give no
		     action;  1	 to  move  down	after each entry; or 2 to move
		     right after each entry.

	      rowlimit=n
		     Set the remembered	limit for the maximum row below	 which
		     the  current  cell	 will  be moved	to the top of the next
		     column if the newline action is set to move  the  current
		     cell  down.  n can	be -1 (default)	to disable this	facil-
		     ity.

	      collimit=n
		     Set the remembered	limit for the maximum  column  to  the
		     right of which the	current	cell will be moved to the left
		     of	the next row if	the newline action is set to move  the
		     current  cell  right.   n	can be -1 (default) to disable
		     this facility.

   Cursor Control Commands

       ^P     Move the cell cursor up to the previous row.

       ^N     Move the cell cursor down	to the next row.

       ^B     Move the cell cursor backward one	column.

       ^F     Move the cell cursor forward one column.

       h, j, k,	l
	      If the character cursor is not on	the top	line, these are	alter-
	      nate,  vi-compatible  cell  cursor  controls  (left,  down,  up,
	      right).  Space is	just like l (right).

       H, J, K,	L
	      If the character cursor is not on	the top	line, these  move  the
	      cursor by	half pages (left, down,	up, right).

       ^H     If  the  character cursor	is not on the top line,	^H is the same
	      as ^B.

       SPACE  If the character cursor is not on	the top	line, the space	bar is
	      the same as ^F.

       TAB    If  the  character cursor	is on the top line, TAB	starts a range
	      (see below).  Otherwise, it is the same as ^F.

       Arrow Keys
	      The terminal's arrow keys	provide	another	alternate set of  cell
	      cursor controls if they exist and	are supported in the appropri-
	      ate termcap entry.  Some terminals have arrow  keys  which  con-
	      flict  with  other  control  key codes.  For example, a terminal
	      might send ^H when the back arrow	 key  is  pressed.   In	 these
	      cases,  the  conflicting arrow key performs the same function as
	      the key combination it mimics.

       ^      Move the cell cursor up to row 0 of the current column.

       #      Move the cell cursor down	to the last valid row of  the  current
	      column.

       0      Move  the	 cell  cursor backward to column A of the current row.
	      This command must	be prefixed with ^U  if	 quick	numeric	 entry
	      mode is enabled.

       $      Move  the	 cell  cursor  forward to the last valid column	of the
	      current row.

       b      Scan the cursor backward (left and up)  to  the  previous	 valid
	      cell.

       w      Scan the cursor forward (right and down) to the next valid cell.

       ^Ed    Go  to end of range.  Follow ^E by a direction indicator such as
	      ^P or j.	If the cell cursor starts on a non-blank cell, it goes
	      in  the  indicated  direction  until the last non-blank adjacent
	      cell.  If	the cell cursor	starts on a blank cell,	it goes	in the
	      indicated	 direction  until the first non-blank cell.  This com-
	      mand is useful when specifying ranges of adjacent	cells (see be-
	      low),  especially	when the range is bigger than the visible win-
	      dow.

       g      Go to a cell.  sc	prompts	for a cell's name, a  regular  expres-
	      sion  surrounded	by quotes, or a	number.	 If a cell's name such
	      as ae122 or a the	name of	a defined range	 is  given,  the  cell
	      cursor  goes directly to that cell.  If a	quoted regular expres-
	      sion such	as " Tax Table " or " ^Jan  [0-9]*$  "	is  given,  sc
	      searches for a cell containing a string matching the regular ex-
	      pression.	 See regex(3) or ed(1) for more	details	on the form of
	      regular expressions.  If a number	is given, sc will search for a
	      cell containing that number.  Searches  for  either  strings  or
	      numbers  proceed forward from the	current	cell, wrapping back to
	      a0 at the	end of the table, and terminate	at the current cell if
	      the  string  or  number is not found.  You may also go to	a cell
	      with an ERROR (divide by zero, etc  in  this  cell)  or  INVALID
	      (references  a cell containing an	ERROR).	 g error will take you
	      to the next ERROR, while g invalid take you to the next invalid.
	      The  last	 g  command is saved, and can be re-issued by entering
	      g_return_.

   Cell	Entry and Editing Commands
       Cells can contain both a	numeric	value  and  a  string  value.	Either
       value  can  be  the result of an	expression, but	not both at once, i.e.
       each cell can have only one expression associated with it.  Entering  a
       valid  numeric  expression alters the cell's previous numeric value, if
       any, and	replaces the cell's previous string expression,	if any,	 leav-
       ing  only the previously	computed constant label	string.	 Likewise, en-
       tering a	valid string expression	alters the cell's the  previous	 label
       string, if any, and replaces the	cell's previous	numeric	expression, if
       any, leaving only the previously	computed constant numeric value.

       =      Enter a numeric constant or expression into  the	current	 cell.
	      sc prompts for the expression on the top line.  The usual	way to
	      enter a number into a cell is to type ``='', then	enter the num-
	      ber  in  response	 to the	prompt on the top line.	 The quick nu-
	      meric entry option, enabled through the -n option	or ^T command,
	      shows the	prompt when you	enter the first	digit of a number (you
	      can skip typing ``='').

       <      Enter a label string into	the current cell to  be	 flushed  left
	      against the left edge of the cell.

       "      Enter a label string into	the current cell to be centered	in the
	      column.

       >      Enter a label string into	the current cell to be	flushed	 right
	      against the right	edge of	the cell.

       F      Enter a format string into the current cell.  This format	string
	      overrides	the precision specified	with the ``f''	command.   The
	      format only applies to numeric values.  The following characters
	      can be used to build a format string:

	      #	     Digit placeholder.	 If the	number has fewer digits	on ei-
		     ther  side	of the decimal point than  there are `#' char-
		     acters in the format, the extra `#'  characters  are  ig-
		     nored.   The  number  is  rounded	to the number of digit
		     placeholders as there are to the  right  of  the  decimal
		     point.  If	there are more digits in the number than there
		     are digit placeholders on the left	side  of  the  decimal
		     point, then those digits are displayed.

	      0	     Digit  placeholder.  Same as for `#' except that the num-
		     ber is padded with	zeroes on either side of  the  decimal
		     point.   The  number  of zeroes used in padding is	deter-
		     mined by the number of digit placeholders after  the  `0'
		     for  digits  on the left side of the decimal point	and by
		     the number	of digit placeholders before the `0' for  dig-
		     its on the	right side of the decimal point.

	      .	     Decimal  point.  Determines how many digits are placed on
		     the right and left	sides of the decimal point in the num-
		     ber.   Note that numbers smaller than 1 will begin	with a
		     decimal point if the left side of the decimal point  con-
		     tains  only  a  `#'  digit	placeholder.  Use a `0'	place-
		     holder to get a leading zero in decimal formats.

	      %	     Percentage.  For each `%' character in  the  format,  the
		     actual  number  gets multiplied by	100 (only for purposes
		     of	formatting -- the original number is left  unmodified)
		     and  the  `%' character is	placed in the same position as
		     it	is in the format.

	      ,	     Thousands separator.  The presence	of a `,' in the	format
		     (multiple	commas are treated as one) will	cause the num-
		     ber to be formatted with a	`,'  separating	 each  set  of
		     three  digits in the integer part of the number with num-
		     bering beginning from the right end of the	integer.

	      \	     Quote.  This character causes the next  character	to  be
		     inserted  into the	formatted string directly with no spe-
		     cial interpretation.

	      E- E+ e- e+
		     Scientific	format.	 Causes	the  number  to	 formatted  in
		     scientific	notation.  The case of the `E' or `e' given is
		     preserved.	 If the	format uses a `+', then	 the  sign  is
		     always  given for the exponent value.  If the format uses
		     a `-', then the sign is  only  given  when	 the  exponent
		     value is negative.	 Note that if there is no digit	place-
		     holder following the `+' or `-', then that	 part  of  the
		     formatted	number	is left	out.  In general, there	should
		     be	one or more digit placeholders after the `+' or	`-'.

	      ;	     Format selector.  Use this	character to separate the for-
		     mat into two distinct formats.  The format	to the left of
		     the `;' character will be used if	the  number  given  is
		     zero  or  positive.   The	format to the right of the `;'
		     character is used if the number given is negative.

	      Some  example  formats  are  integer  (``0''  or	``#''),	 fixed
	      (``0.00''),   percentage	 (``0%''   or  ``0.00%''),  scientific
	      (``0.00E+00''), and currency (``$#,0.00;($#,0.00)'').

       Strings you enter must start with ".  You can leave off the trailing  "
       and  sc will add	it for you.  You can also enter	a string expression by
       backspacing over	the opening " in the prompt.

       e      Edit the value associated	with the current cell.	This is	 iden-
	      tical  to	``='' except that the command line starts out contain-
	      ing the old numeric value	 or  expression	 associated  with  the
	      cell.  The editing in this mode is vi-like.

	      ^h     Move back a character

	      +	     Forward through history (neat) (same as j)

	      -	     Backward through history (neat) (same as k)

	      ESC    Done editing

	      TAB    Mark && append a range (ex: A0:A0)
		     TAB,  move	 around	 within	 a  range;  TAB,  append range
		     string.

	      CR     Save

	      $	     Goto last column

	      .	     Insert current dot	buffer

	      /	     Search for	a string in the	history
		     ESC  edit the string you typed
		     CR	  search
		     ^h	  backspace

	      0	     Goto column 0

	      D	     Delete to send

	      I	     Insert at column 0; ESC revert back to edit mode

	      R	     Replace mode; ESC revert back to edit mode

	      X	     Delete the	char to	the left

	      a	     Append after cursor; ESC revert back to edit mode

	      b	     Move back a word

	      c	     Change mode; ESC revert back to edit mode

	      d	     Delete ...
		     b	  back word
		     f	  forward (right)
		     h	  back char
		     l	  forward
		     t	  delete forward up to a given char (next char typed)
		     w	  delete next word forward

	      f	     Find the next char	typed

	      h	     Move left a char

	      i	     Insert before cursor; ESC revert back to edit mode

	      j	     Forward through history (neat) (same as +)

	      k	     Backward through history (neat) (same as -)

	      l	     Move right	a char

	      n	     Continue search

	      q	     Stop editing

	      r	     Replace char

	      t	     Goto a char

	      u	     Undo

	      w	     Forward a word

	      x	     Delete the	current	char (moving to	the right)

       E      Edit the string associated with the current cell.	 This is iden-
	      tical  to	 ``<'',	 ``"'',	 or ``>'' except that the command line
	      starts out containing the	old string value or expression associ-
	      ated with	the cell.  SEE e ABOVE.

       To  enter  and edit a cell's number part, use the ``='' and e commands.
       To enter	and edit a cell's string part, use the	``<'',	``"'',	``>'',
       and  E  commands.  See the sections below on numeric and	string expres-
       sions for more information.

       x      Clear the	 current  cell.	  Deletes  the	numeric	 value,	 label
	      string,  and/or  numeric	or  string expression.	You can	prefix
	      this command with	a count	of the number of cells on the  current
	      row  to  clear.  The current column is used if column recalcula-
	      tion order is set.  Cells	cleared	with this command may  be  re-
	      called with any of the pull commands (see	below).

       m      Mark a cell to be	used as	the source for the copy	command.

       c      Copy  the	last marked cell to the	current	cell, updating row and
	      column references	in its numeric or string expression, if	any.

       +      If not in	numeric	mode, add the current  numeric	argument  (de-
	      fault  1)	 to  the  value	of the current cell.  In numeric mode,
	      ``+'' introduces a new numeric expression	or value, the same  as
	      ``=''.

       -      If  not  in  numeric mode, subtract the current numeric argument
	      (default 1) from the value of  the  current  cell.   In  numeric
	      mode,  ``-''  introduces	a new, negative, numeric expression or
	      value, like ``=''.

       RETURN If you are not editing a cell (top line is empty), pressing  RE-
	      TURN  will make sc enter insert mode. At this point you may type
	      any valid	command	or press ESC once to edit.

   File	Commands

       G      Get a new	database from a	file.  If encryption is	 enabled,  the
	      file is decrypted	before it is loaded into the spreadsheet.

       P      Put the current database into a file.  If	encryption is enabled,
	      the file is encrypted before it is saved.

       W      Write a listing of the current database into a file  in  a  form
	      that  matches  its  appearance on	the screen.  This differs from
	      the Put command in that its files	are intended  to  be  reloaded
	      with  Get,  while	 Write	produces a file	for people to look at.
	      Hidden rows or columns are not shown when	the data is printed.

       T      Write a listing of the current database to a file,  but  include
	      delimiters suitable for processing by the	tbl, LaTeX, or TeX ta-
	      ble processors.  The delimiters are controlled by	 the  tblstyle
	      option.	See Set	above.	The delimiters are are a colon (:) for
	      style 0 or tbl and an ampersand (&) for style latex or tex.

       With the	Put, Write, and	Table commands,	the  optional  range  argument
       writes a	subset of the spreadsheet to the output	file.

       With the	Write and Table	commands, if you try to	write to the last file
       used with the Get or Put	commands, or the file specified	on the command
       line  when  sc  was  invoked, you are asked to confirm that the (poten-
       tially) dangerous operation is really what you want.

       The three output	commands, Put, Write, and Table, can pipe their	(unen-
       crypted only) output to a program.  To use this feature,	enter ``| pro-
       gram'' to the prompt asking for a filename.  For	example,  to  redirect
       the output of the Write command to the printer, you might enter ``| lpr
       -p''.

       M      Merge the	database from the named	file into  the	current	 data-
	      base.  Values and	expressions defined in the named file are read
	      into the current spreadsheet overwriting the existing entries at
	      matching cell locations.

       R      Run macros.  Since sc files are saved as ASCII files, it is pos-
	      sible to use them	as primitive macro definition files.  The  Run
	      command  makes  this  easier.   It's like	the Merge command, but
	      prints a saved path name as the start of the filename  to	 merge
	      in.  The string to use is	set with the Define command.  To write
	      macros, you must be familiar with	the file format	written	by the
	      Put command.  This facility is still primitive and could be much
	      improved.

       D      Define a path for	the Run	command	to use.

       All file	operations take	a filename as the first	argument to the	prompt
       on the top line.	 The prompt supplies a " to aid	in typing in the file-
       name.  The filename can also be obtained	from a cell's label string  or
       string  expression.   In	 this  case,  delete  the  leading  " with the
       backspace key and enter a cell name such	as a22 instead.	  If  the  re-
       sulting string starts with ``|'', the rest of the string	is interpreted
       as a UNIX command, as above.

   Row and Column Commands
       These commands can be used on either rows or columns.  The second  let-
       ter of the command is either a row designator (one of the characters r,
       ^B, ^F, h, l) or	a column designator (one of c, ^P, ^N, k, j).  A small
       menu  lists  the	 choices for the second	letter when you	type the first
       letter of one of	these commands.	 Commands which	 move  or  copy	 cells
       also modify the row and column references in affected cell expressions.
       The references may be frozen by using the fixed operator	or using the $
       character in the	reference to the cell (see below).

       ir, ic Insert  a	new row	(column) by moving the row (column) containing
	      the cell cursor, and all following rows (columns), down  (right)
	      one row (column).	 The new row (column) is empty.

       ar, ac Append  a	new row	(column) immediately following the current row
	      (column).	 It is initialized as a	copy of	the current one.

       dr, dc Delete the current row (column).

       pr, pc, pm
	      Pull deleted rows	(columns) back into the	spreadsheet.  The last
	      deleted  set  of	cells  is put back into	the spreadsheet	at the
	      current location.	 pr inserts enough rows	to hold	the data.   pc
	      inserts  enough  columns	to hold	the data.  pm (merge) does not
	      insert rows or columns; it overwrites the	cells beginning	at the
	      current cell cursor location.

       vr, vc Remove  expressions  from	 the  affected rows (columns), leaving
	      only the values which were in the	cells before the  command  was
	      executed.

       zr, zc Hide (``zap'') the current row (column).	This keeps a row (col-
	      umn) from	being displayed	but keeps it in	the  data  base.   The
	      status  of  the  rows and	columns	is saved with the data base so
	      hidden rows and columns will be still be hidden when you	reload
	      the  spreadsheet.	 Hidden	rows or	columns	are not	printed	by the
	      W	command.

       sr, sc Show hidden rows (columns).  Enter a range of rows (columns)  to
	      be  revealed.   The default is the first range of	rows (columns)
	      currently	hidden.	 This command ignores  the  repeat  count,  if
	      any.

       f      Set the output format to be used for printing the	numeric	values
	      in each cell in the current column.  Enter  three	 numbers:  the
	      total width in characters	of the column, the number of digits to
	      follow decimal points, and the format type.  Format types	are  0
	      for  fixed  point,  1 for	scientific notation, 2 for engineering
	      notation,	and 3 for dates.  Values are rounded off to the	 least
	      significant  digit  displayed.   The  total column width affects
	      displays of strings as well as numbers.  A preceding  count  can
	      be used to affect	more than one column.  This command has	only a
	      column version (no second	letter).

       @myrow, @mycol
	      Are functions that return	the row	or column of the current  cell
	      respectively.   ex: The cell directly above a cell in the	D col-
	      umn could	then be	accessed by @nval("d",@myrow-1).  NOTE:	@myrow
	      and @mycol can't be used in specifying ranges.

   Range Commands
       Range  operations  affect a rectangular region on the screen defined by
       the upper left and lower	right cells in the region.  All	 of  the  com-
       mands  in  this class start with	a slash; the second letter of the com-
       mand indicates which command.  A	small menu lists the choices  for  the
       second  letter  when  you type ``/''.  sc prompts for needed parameters
       for each	command.  Phrases surrounded by	square brackets	in the	prompt
       are informational only and may be erased	with the backspace key.

       Prompts	requesting  variable names may be satisfied with either	an ex-
       plicit variable name, such as A10, or with a variable  name  previously
       defined in a /d command (see below).  Range name	prompts	require	either
       an explicit range such as A10:B20, or a range name  previously  defined
       with a /d command.  A default range shown in the	second line is used if
       you omit	the range from the command or press the	TAB key	 (see  below).
       The default range can be	changed	by moving the cell cursor via the con-
       trol commands (^P, ^N, ^B, ^F) or the arrow keys.  The cells in the de-
       fault  range  are  highlighted  (using the terminal's standout mode, if
       available).

       /x     Clear a range.  Cells cleared with this command may be  recalled
	      with any of the pull commands.

       /v     Values  only.  This command removes the expressions from a range
	      of cells,	leaving	just the values	of the expressions.

       /c     Copy a source range to a destination range.  The source and des-
	      tination	may  be	 different sizes.  The result is always	one or
	      more full	copies of the source.  Copying a row to	a row yields a
	      row.   Copying  a	column to a column yields a column.  Copying a
	      range to anything	yields a range.	 Copying a row to a column  or
	      a	 column	 to  a	row  yields a range with as many copies	of the
	      source as	there are cells	in the destination.  This command  can
	      be used to duplicate a cell through an arbitrary range by	making
	      the source a single cell range such as b20:b20.

       /f     Fill a range with	constant values	starting with  a  given	 value
	      and  increasing by a given increment.  Each row is filled	before
	      moving on	to the next row	if row	order  recalculation  is  set.
	      Column  order fills each column in the range before moving on to
	      the next column.	The start and increment	numbers	may  be	 posi-
	      tive  or	negative.  To fill all cells with the same value, give
	      an increment of zero.

       /d     Use this command to assign a symbolic name to a single cell or a
	      rectangular  range  of  cells on the screen.  The	parameters are
	      the name,	surrounded by "", and either a single cell  name  such
	      as A10 or	a range	such as	a1:b20.	 Names defined in this fashion
	      are used by the program in future	prompts, may be	entered	in re-
	      sponse to	prompts	requesting a cell or range name, and are saved
	      when the spreadsheet is saved with the Put command.   Names  de-
	      fined must be more than two alpha	characters long	to differenti-
	      ate them from a column names, and	must not have embedded special
	      characters.   Names  may include the character ``_'' or numerals
	      as long as they occur after the first three alpha	characters.

       /l     Use this command to lock the current cell	or a range  of	cells,
	      i.e make them immune to any type of editing. A locked cell can't
	      be changed in anyway until it is unlocked.

       /U     This command is the opposite of the /l command and thus  unlocks
	      a	locked cell and	makes it editable.

       /s     This  command  lists  (shows) the	currently defined range	names.
	      If there are no defined range names, then	a  message  is	given,
	      otherwise	 it  pipes output to sort, then	to less.  If the envi-
	      ronment variable PAGER is	set, its value is  used	 in  place  of
	      less.

       /u     Use this command to undefine a previously	defined	range name.

       /F     Use  this	command	to assign a value format string	(see the ``F''
	      cell entry command) to a range of	cells.

   Miscellaneous Commands

       Q
       q
       ^C     Exit from	sc.  If	you made any changes since  the	 last  Get  or
	      Put, sc asks about saving	your data before exiting.

       ^G
       ESC    Abort entry of the current command.

       ?      Enter an interactive help	facility.  Lets	you look up brief sum-
	      maries of	the main features of the program.  The	help  facility
	      is  structured  like this	manual page so it is easy to find more
	      information on a particular topic.

       !      Shell escape.  sc	prompts	for a shell command to run.   End  the
	      command  line  with the RETURN key.  If the environment variable
	      SHELL is defined,	that shell is run.  If not, /bin/sh  is	 used.
	      Giving a null command line starts	the shell in interactive mode.
	      A	second ``!'' repeats the previous command.

       ^L     Redraw the screen.

       ^R     Redraw the screen	with  special  highlighting  of	 cells	to  be
	      filled  in.   This is useful for finding values you need to pro-
	      vide or update in	a form with which you aren't  familiar	or  of
	      which you	have forgotten the details.

	      It's  also  useful  for  checking	 a form	you are	creating.  All
	      cells which contain constant numeric values (not the result of a
	      numeric  expression) are highlighted temporarily,	until the next
	      screen change, however minor.  To	avoid ambiguity,  the  current
	      range (if	any) and current cell are not highlighted.

       ^X     This  command  is	similar	to ^R, but highlights cells which have
	      expressions.  It also displays  the  expressions	in  the	 high-
	      lighted  cells  as  left-flushed strings,	instead	of the numeric
	      values and/or label strings of those cells.  This	command	 makes
	      it  easier to check expressions, at least	when they fit in their
	      cells or the following cell(s) are blank so the expressions  can
	      slop  over  (like	 label strings).  In the latter	case, the slop
	      over is not cleared on the next screen update, so	you  may  want
	      to type ^L after the ^X in order to clean	up the screen.

       @      Recalculates the spreadsheet.

       ^V     Type, in the command line, the name of the current cell (the one
	      at the cell cursor).  This is useful when	 entering  expressions
	      which refer to other cells in the	table.

       ^W     Type,  in	 the command line, the expression attached to the cur-
	      rent cell.  If there is none, the	result is ``?''.

       ^A     Type, in the command line, the  numeric  value  of  the  current
	      cell, if any.

       The  ^V,	 ^W, and ^A commands only work when the	character cursor is on
       the command line	and beyond the first character.

       TAB    When the character cursor	is on the top line, defines a range of
	      cells  via  the  cursor control commands or the arrow keys.  The
	      range is highlighted, starts at the cell where  you  typed  TAB,
	      and  continues  through  the  current cell cursor.  Pressing TAB
	      again causes the highlighted range to be entered into  the  com-
	      mand  line  and the highlighting to be turned off.  This is most
	      useful for defining ranges to functions such as @sum().	Press-
	      ing  ``)'' acts just like	typing the TAB key the second time and
	      adds the closing ``)''.  Note that when you give	a  range  com-
	      mand,  you don't need to press the first TAB to begin defining a
	      range starting with the current cell.

   Variable Names
       Normally, a variable name is just the name of a cell, such as K20.  The
       value is	the numeric or string value of the cell, according to context.

       When  a	cell's	expression (formula) is	copied to another location via
       copy or range-copy, variable references are by default  offset  by  the
       amount  the  formula moved.  This allows	the new	formula	to work	on new
       data.  If cell references are not to change, you	 can  either  use  the
       fixed  operator	(see below), or	one of the following variations	on the
       cell name.

       K20    References cell K20; the reference changes when the  formula  is
	      copied.

       $K$20  Always  refers  to  cell K20; the	reference stays	fixed when the
	      formula is copied.

       $K20   Keeps the	column fixed at	column K; the row is free to vary.

       K$20   Similarly, this fixes the	row and	allows the column to vary.

       These conventions also hold on defined ranges.  Range  references  vary
       when formulas containing	them are copied.  If the range is defined with
       fixed variable references, the references do not	change.

       fixed  To make a	variable not change automatically when a  cell	moves,
	      put  the word fixed in front of the reference, for example: B1 *
	      fixed C3.

   Numeric Expressions
       Numeric expressions used	with the ``='' and e commands  have  a	fairly
       conventional syntax.  Terms may be constants, variable names, parenthe-
       sized expressions, and negated terms.  Ranges may be operated upon with
       range  functions	 such as sum (@sum()) and average (@avg()).  Terms may
       be combined using binary	operators.

       -e     Negation.

       e+e    Addition.

       e-e    Subtraction.

       e*e    Multiplication.

       e/e    Division.

       e1%e2  e1 mod e2.

       e^e    Exponentiation.

       e<e
       e<=e
       e=e
       e!=e
       e>=e
       e>e    Relationals: true	(1) if and  only  if  the  indicated  relation
	      holds, else false	(0).  Note that	``<='',	``!='',	and ``>='' are
	      converted	to their ``~()'' equivalents.

       ~e     Boolean operator NOT.

       e&e    Boolean operator AND.

       e|e    Boolean operator OR.

       @if(e,e,e)
       e?e:e  Conditional: If the first	expression is true then	the  value  of
	      the second is returned, otherwise	the value of the third.
       Operator	precedence from	highest	to lowest is:
	      -, ~
	      ^
	      *, /
	      +, -
	      <, <=, =,	!=, >=,	>
	      &
	      |
	      ?:
   Built-in Range Functions
       These functions return numeric values.
       @sum(r)		 Sum  all valid	(nonblank) entries in the region whose
			 two corners are defined by  the  two  variable	 names
			 (e.g.	c5:e14)	or the range name specified.
       @prod(r)		 Multiply together all valid (nonblank)	entries	in the
			 specified region.
       @avg(r)		 Average all valid (nonblank) entries in the specified
			 region.
       @count(r)	 Count	all  valid (nonblank) entries in the specified
			 region.
       @max(r)		 Return	the maximum value  in  the  specified  region.
			 See also the multi argument version of	@max below.
       @min(r)		 Return	 the  minimum  value  in the specified region.
			 See also the multi argument version of	@min below.
       @stddev(r)	 Return	the sample standard deviation of the cells  in
			 the specified region.
       @lookup(e,r)
       @lookup(se,r)	 Evaluates  the	 expression  then searches through the
			 range r for a matching	value.	The  range  should  be
			 either	 a single row or a single column.  The expres-
			 sion can be either a string expression	or  a  numeric
			 expression.  If it is a numeric expression, the range
			 is searched for the the last value less than or equal
			 to  e.	 If the	expression is a	string expression, the
			 string	 portions  of  the  cells  in  the  range  are
			 searched  for	an  exact string match.	 The value re-
			 turned	is the numeric value from the next row and the
			 same  column  as the match, if	the range was a	single
			 row, or the value from	the next column	and  the  same
			 row as	the match if the range was a single column.

       @hlookup(e,r,n)
       @hlookup(se,r,n)	 Evaluates  the	 expression  then searches through the
			 first row in the range	r for a	matching  value.   The
			 expression can	be either a string expression or a nu-
			 meric expression.  If it is a numeric expression, the
			 row  is  searched for the the last value less than or
			 equal to e.  If the expression	is  a  string  expres-
			 sion, the string portions of the cells	in the row are
			 searched for an exact string match.   The  value  re-
			 turned	 is  the  numeric value	from the same column n
			 rows below the	match.

       @vlookup(e,r,n)
       @vlookup(se,r,n)	 Evaluates the expression then	searches  through  the
			 first	column	in  the	 range r for a matching	value.
			 The expression	can be either a	string expression or a
			 numeric  expression.	If it is a numeric expression,
			 the column is searched	for the	the  last  value  less
			 than  or  equal  to e.	 If the	expression is a	string
			 expression, the string	portions of the	cells  in  the
			 column	 are  searched for an exact string match.  The
			 value returned	is the numeric value from the same row
			 n columns to the right	of the match.

       @index(e,r)	 Use  the  value of the	expression e to	index into the
			 range r.  The numeric value at	that position  is  re-
			 turned.   The	value  1 selects the first item	in the
			 range,	2 selects the second item, etc.	 R  should  be
			 either	a single row or	a single column.

       @stindex(e,r)	 Use  the  value  of e to index	into the range r.  The
			 string	value at that position is returned.  The value
			 1  selects the	first item in the range, 2 selects the
			 second	item, etc.  The	range should be	either a  sin-
			 gle row or a single column.

   Built-in Numeric Functions
       All  of these functions operate on floating point numbers (doubles) and
       return numeric values.  Most of them are	standard system	functions more
       fully  described	in math(3).  The trig functions	operate	with angles in
       radians.

       @sqrt(e)		 Return	the square root	of e.

       @exp(e)		 Return	the exponential	function of e.

       @ln(e)		 Return	the natural logarithm of e.

       @log(e)		 Return	the base 10 logarithm of e.

       @floor(e)	 Return	the largest integer not	greater	than e.

       @ceil(e)		 Return	the smallest integer not less than e.

       @rnd(e)		 Round e to the	nearest	integer.   default:  round-to-
			 even  (banker's round), *.5 will round	to the closest
			 even number; 'set rndinfinity'	will round *.5	up  to
			 the next integer.

       @round(e,n)	 Round	e  to  n decimal places.  n may	be positive to
			 round off the right side of the decimal, and negative
			 to  round  off	 the  left side. See @rnd(e) above for
			 rounding types.

       @abs(e)
       @fabs(e)		 Return	the absolute value of e.
       @pow(e1,e2)	 Return	e1 raised to the power of e2.
       @hypot(e1,e2)	 Return	sqrt(e1*e1+e2*e2), taking precautions  against
			 unwarranted overflows.
       pi  @pi		 A constant quite close	to pi.
       @dtr(e)		 Convert e in degrees to radians.
       @rtd(e)		 Convert e in radians to degrees.
       @sin(e)
       @cos(e)
       @tan(e)		 Return	 trigonometric	functions of radian arguments.
			 The magnitude of the arguments	are not	checked	to as-
			 sure meaningful results.

       @asin(e)		 Return	the arc	sine of	e in the range -pi/2 to	pi/2.

       @acos(e)		 Return	the arc	cosine of e in the range 0 to pi.

       @atan(e)		 Return	 the  arc  tangent  of e in the	range -pi/2 to
			 pi/2.

       @atan2(e1,e2)	 Returns the arc tangent of e1/e2 in the range -pi  to
			 pi.

       @max(e1,e2,...)	 Return	 the maximum of	the values of the expressions.
			 Two or	more expressions may be	specified.   See  also
			 the range version of @max above.

       @min(e1,e2,...)	 Return	 the minimum of	the values of the expressions.
			 Two or	more expressions may be	specified.   See  also
			 the range version of @min above.

       @ston(se)	 Convert string	expression se to a numeric value.

       @eqs(se1,se2)	 Return	 1 if string expression	se1 has	the same value
			 as string expression se2, 0 otherwise.

       @nval(se,e)	 Return	the numeric value of a cell selected by	 name.
			 String	 expression  se	must evaluate to a column name
			 (``A''-``AE'')	and e must evaluate to	a  row	number
			 (0-199).   If	se  or e is out	of bounds, or the cell
			 has no	numeric	value, the result is 0.	 You  can  use
			 this  for  simple  table  lookups.  Be	sure the table
			 doesn't move unexpectedly!  See also @sval() below.

   String Expressions
       String expressions are made up of  constant  strings  (characters  sur-
       rounded	by double quotation marks), variables (cell names, which refer
       to the cells's label strings or	expressions),  and  string  functions.
       Note  that  string  expressions are only	allowed	when entering a	cell's
       label string, not its numeric part.  Also note that  string  expression
       results may be left or right flushed or centered, according to the type
       of the cell's string label.

       #      Concatenate strings.  For	example, the string expression

		   A0 #	"zy dog"

	      displays the string ``the	lazy dog'' in the cell if the value of
	      A0's string is ``the la''.

   Built-in String Functions

       @substr(se,e1,e2) Extract and return from string	expression se the sub-
			 string	indexed	by character number e1 through charac-
			 ter  number  e2 (defaults to the size of se if	beyond
			 the end of it).  If e1	is less	than 1 or greater than
			 e2, the result	is the null string.  For example,

			      @substr ("Nice jacket", 4, 7)

			 returns the string ``e	jac''.

       @fmt(se,e)	 Convert  a  number to a string.  The argument se must
			 be a valid printf(3) format string.  e	 is  converted
			 according  to	the  standard rules.  For example, the
			 expression

			      @fmt ("**%6.3f**", 10.5)

			 yields	the string ``**10.500**''.  e is a double,  so
			 applicable formats are	e, E, f, g, and	G.  Try	``%g''
			 as a starting point.

       @sval(se,e)	 Return	the string value of a cell selected  by	 name.
			 String	 expression  se	must evaluate to a column name
			 (``A''-``AE'')	and e must evaluate to	a  row	number
			 (0-199).   If	se  or e is out	of bounds, or the cell
			 has no	string value, the result is the	 null  string.
			 You  can  use this for	simple table lookups.  Be sure
			 the table doesn't move	unexpectedly!

       @upper(e)	 and @lower(e) will case the string expression to  up-
			 per or	lower.

       @capital(e)	 will  convert	the  first letter of words in a	string
			 into upper case and other letters to lower case  (the
			 latter	if all letters of the string are upper case).

       @upper(e)	 and  @lower(e)	will case the string expression	to up-
			 per or	lower.

       @capital(e)	 will convert the first	letter of words	 in  a	string
			 into upper case.

       @ext(se,e)	 Call  an  external function (program or script).  The
			 purpose is to allow arbitrary	functions  on  values,
			 e.g.  table  lookups  and interpolations.  String ex-
			 pression se is	a command or command line to call with
			 popen(3).   The  value	 of e is converted to a	string
			 and appended to the command line as an	argument.  The
			 result	 of @ext() is a	string:	the first line printed
			 to standard  output  by  the  command.	  The  command
			 should	emit exactly one output	line.  Additional out-
			 put, or output	 to  standard  error,  messes  up  the
			 screen.   @ext()  returns a null string and prints an
			 appropriate warning if	external  functions  are  dis-
			 abled,	 se is null, or	the attempt to run the command
			 fails.

			 External functions can	be slow	to run,	and if enabled
			 are  called  at  each screen update, so they are dis-
			 abled by default.  You	can enable them	with  ^T  when
			 you really want them called.

			 A simple example:

			      @ext ("echo", a1)

			 You can use @ston() to	convert	the @ext() result back
			 to a number.  For example:

			      @ston (@ext ("form.sc.ext", a9 + b9))

			 Note that you can built  a  command  line  (including
			 more  argument	 values) from a	string expression with
			 concatenation.	 You can also "hide" the second	 argu-
			 ment by ending	the command line (first	argument) with
			 `` #''	(shell comment).

       @coltoa(e)	 Returns a string name for a column from  the  numeric
			 argument.  For	example:

			      @coltoa(@mycol-1)	       @nval(coltoa(@mycol-1),
			 @myrow+1)

   Built-in Financial Functions
       Financial functions compute the	mortgage  (or  loan)  payment,	future
       value,  and the present value functions.	 Each accepts three arguments,
       an amount, a rate of interest (per period), and the number of  periods.
       These  functions	 are the same as those commonly	found in other spread-
       sheets and financial calculators

       @pmt(e1,e2,e3)	 @pmt(60000,.01,360) computes the monthly payments for
			 a  $60000  mortgage  at  12% annual interest (.01 per
			 month)	for 30 years (360 months).

       @fv(e1,e2,e3)	 @fv(100,.005,36) computes the future value for	of  36
			 monthly  payments  of	$100  at 6% interest (.005 per
			 month).  It answers the question: "How	 much  will  I
			 have  in  36  months if I deposit $100	per month in a
			 savings  account  paying   6%	 interest   compounded
			 monthly?"

       @pv(e1,e2,e3)	 @pv(1000,.015,36)  computes the present value of an a
			 ordinary annuity of 36	monthly	payments of  $1000  at
			 18%  annual  interest.	 It answers the	question: "How
			 much can I borrow at 18% for 30 years if I pay	 $1000
			 per month?"

   Built-in Date and Time Functions
       Time  for  sc  follows the system standard: the number of seconds since
       1970.  All date and time	functions except @date() return	 numbers,  not
       strings.

       @now		 Return	the current time encoded as the	number of sec-
			 onds since the	beginning of the epoch	(December  31,
			 1969, midnight, GMT.)

       @dts(e1,e2,e3)	 @dts(9,14,1988)  converts the date September 14, 1988
			 to the	number of seconds from the epoch to the	 first
			 second	  of   9/14/88,	  local	 time.	 For  example,
			 @date(@dts(12,14,1976)) yields

			      Tue Dec 14 00:00:00 1976

			 The month should be range from	  1  to	 12,  the  day
			 should	 range	from  1	 to  the number	of days	in the
			 specified month, and the year should range from  1970
			 to 1999.

       @tts(e1,e2,e3)	 @tts(8,20,45) converts	the time 8:40:45 to the	number
			 of seconds since midnight,  the  night	 before.   The
			 hour  should range from 0 to 23; the minutes and sec-
			 onds should range from	0 to 59.

       The following functions take the	time in	seconds	(e.g. from @now) as an
       argument	 and  return  the  specified value.  The functions all convert
       from GMT	to local time.

       @date(e)		 Convert the time in seconds to	a date string 24 char-
			 acters	long in	the following form:

			      Sun Sep 16 01:03:52 1973

			 Note  that you	can extract parts of this fixed-format
			 string	with @substr().

       @year(e)		 Return	the year.  Valid years begin with  1970.   The
			 last legal year is system dependent.

       @month(e)	 Return	 the  month, encoded as	1 (January) to 12 (De-
			 cember).

       @day(e)		 Return	the day	of the month, encoded as 1 to 31.

       @hour(e)		 Return	the number of hours since midnight, encoded as
			 0 to 23.

       @minute(e)	 Return	 the  number  of  minutes  since the last full
			 hour, encoded as 0 to 59.

       @second(e)	 Return	the number of  seconds	since  the  last  full
			 minute, encoded as 0 to 59.

   Spreadsheet Update
       Re-evaluation  of  spreadsheet  expressions is done by row or by	column
       depending on the	selected calculation order.  Evaluation	is repeated up
       to iterations times for each update if necessary, so forward references
       usually work as expected.  See set above.  If stability is not  reached
       after  ten  iterations, a warning is printed.  This is usually due to a
       long series of forward references, or  to  unstable  cyclic  references
       (for example, set A0's expression to ``A0+1'').

       @numiter		 Returns the number of iterations performed so far.

FILES
       /usr/local/share/sc/tutorial.sc	       tutorial	spreadsheet

SEE ALSO
       bc(1), dc(1), crypt(1), psc(1)

BUGS
       Top-to-bottom,  left-to-right  evaluation  of  expressions is silly.  A
       proper following	of the dependency graph	with (perhaps) recourse	to re-
       laxation	should be implemented.

       Only  one  previous  value  is saved from any call of @ext().  If it is
       used more than once in a	spreadsheet and	external functions are enabled
       and later disabled, the last returned value pops	up in several places.

       On some systems,	if the cell cursor is in column	0 with topline enabled
       (so the current cell is highlighted), or	if any cell  in	 column	 0  is
       highlighted,  the  corresponding	 row  number  gets  displayed and then
       blanked during a	screen refresh.	 This looks like a bug in curses.

       Many commands give no indication	(a message or beep) if they have  null
       effect.	Some should give confirmation of their action, but they	don't.

AUTHORS
       This  is	a much modified	version	of a public domain spread sheet	origi-
       nally authored by James Gosling,	and subsequently modified  and	posted
       to  USENET  by  Mark  Weiser under the name vc.	The program was	subse-
       quently renamed sc, and further modified	by numerous contributors, Jeff
       Buhrt  of  Proslink,  Inc.  ({sequent, uunet}!sawmill!prslnk!buhrt) and
       Robert Bond of Sequent, prominent among them.  Other  contributors  in-
       clude:  Tom  Anderson, Glenn T. Barry, Gregory Bond, Stephen (Steve) M.
       Brooks, Peter Brower, John Campbell, Lawrence Cipriani,	Jim  Clausing,
       Dave  Close, Chris Cole,	Jonathan Crompron, David I. Dalva, Glen	Ditch-
       field, Sam Drake, James P. Dugal, Paul Eggert, Andy Fyfe,  Jack	Goral,
       Piercarlo "Peter" Grandi, Henk Hesselink, Jeffrey C Honig, Kurt Horton,
       Jonathan	I. Kamens, Peter King, Tom Kloos, Casey	Leedom,	 Jay  Lepreau,
       Dave  Lewis,  Rick  Linck,  Soren  Lundsgaard, Tad Mannes, Rob McMahon,
       Chris Metcalf, Mark Nagel, Ulf Noren, Marius Olafsson, Gene  H.	Olson,
       Henk  P.	 Penning, Rick Perry, Larry Philps, Eric Putz, Jim Richardson,
       Michael Richardson, R. P. C. Rodgers, Kim Sanders, Mike Schwartz,  Alan
       Silverstein,  Lowell  Skoog, Herr Soeryantono, Tim Theisen, Tom Tkacik,
       Andy Valencia, Adri Verhoef, Rick Walker, Petri Wessman,	and  Tim  Wil-
       son.

								   SC 6.21 (1)

NAME | SYNOPSIS | DESCRIPTION | OPTIONS | FILES | SEE ALSO | BUGS | AUTHORS

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=sc&manpath=FreeBSD+6.0-RELEASE+and+Ports>

home | help