Provided by: sc_7.16-3_i386 bug

NAME

       sc - spreadsheet calculator

SYNOPSIS

       sc  [-a]  [-c]  [-e]  [-m]  [-n] [-o] [-q] [-r] [-v] [-x] [-C] [-R] [-P
       range[/address] | /address] [-W range] [file...]

DESCRIPTION

       The spreadsheet calculator sc is based on rectangular tables much  like
       a  financial  spreadsheet.   When invoked, it first looks for a file in
       the user's home directory called .scrc and if found,  reads  that  file
       into  memory.  If that file contains the command ``set scrc'', sc looks
       for a file called .scrc in the current directory, and if  found,  reads
       that  file  into  memory,  too.   Next,  it  reads the options from the
       command line, and finally, it reads in the file or files  specified  on
       the command line and presents the data in a table organized as rows and
       columns of cells.  If invoked without a file  argument,  the  table  is
       initially  empty,  unless it is running in a pipeline, in which case it
       will read its data from the standard input.  If more than one  file  is
       specified,  all files except the first one will be merged.  The default
       filename for saving a file with the Put command will be the same as the
       first  file  specified,  and the other files will be treated as macros.
       If you want to use advanced macros from the  command  line,  the  ``|''
       must be quoted to prevent it from being expanded by the shell.

       Options  begin  with  -.   However,  an  argument of a single - will be
       interpreted to mean that  spreadsheet  data  will  be  taken  from  the
       standard  input.   This is useful for including sc in a pipeline if the
       system supports pipes.  However, if standard input is not  a  terminal,
       the  - is only necessary if there are multiple files and standard input
       is not the last to be read, since standard input is automatically  read
       in  after  all  other  files  in  such  cases  if  it  is not specified
       explicitly, or if there are no other filenames on the command line.  If
       sc is included in a pipeline, and a filename of ``-'' is not specified,
       the standard input will be merged in after all of the other named files
       have been processed.

       The first argument not beginning with a -, or a single - by itself, and
       any subsequent arguments  will  all  be  interpreted  as  filenames  (a
       filename  of - meaning standard input as noted above).  In addition, an
       argument of -- may be used to signify  that  all  subsequent  arguments
       should  be treated as filenames even if they begin with a -, but unlike
       -, -- won't be treated as a filename itself.

       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 an online tutorial, type the command:

              sc /usr/share/doc/sc/tutorial.sc

       To print a quick reference card, type the command:

              scqref | [your_printer_commmand]

OPTIONS

       -a     Do not run the autorun macro, if one is specified in the file.

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

       -e     Start   the   program  with  round-to-even  (banker's  rounding)
              enabled.

       -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).

       -o     Start the program with  automatic  optimization  of  expressions
              enabled.

       -q     Quit  after  loading all files, but before becoming interactive.
              This is useful in shell scripts for getting information  from  a
              file,  for  example, or using sc as a non-interactive calculator
              using the eval command.

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

       -v     When  piping  data  out  using the -P option (below), change all
              expressions to values.  The -v option must precede the -P option
              to  have  an  effect.   If the -P option is used more than once,
              there must be a separate -v option for each instance of  the  -P
              option.

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

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

       -P range[/address]
       -P /address
              Pipe  a range to standard output.  The output is similar to that
              of the Put command (below),  except  that  only  cell  data  and
              formatting  information  for  cells  in  the  range  are output,
              without all of the colors, range definitions, column formatting,
              etc.   The  optional /address is used to adjust all addresses in
              the range to a new starting point.  This is useful  for  copying
              data   from  one  file  to  another,  especially  when  used  in
              conjunction with the -v option  (above),  using  something  like
              merge  "|sc -v -Prange/address filename" (note the pipe symbol).
              This option may be used  more  than  once  to  specify  multiple
              ranges.   Note,  however, that the -v option must precede the -P
              option on the command line, and there  must  be  a  separate  -v
              option  for  each instance of the -P option.  Any instance of -P
              not preceded by  its  own  -v  option  will  output  unevaluated
              expressions.

              A range of ``%'' may be used to refer to the entire spreadsheet.
              If the range is left out, as shown in the second form above,  sc
              will  be started interactively in navigate mode, allowing you to
              navigate the spreadsheet and highlight the  range  you  want  to
              output.    Pressing   ESC,  ^G,  or  q  will  terminate  without
              outputting any data.

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

       -W     Pipe  a  range  to  standard output.  The output is identical to
              that of the Write command (below).  This option may be used more
              than  once  to specify multiple ranges.  A range of ``%'' may be
              used to refer to the entire spreadsheet.

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

   Personal Initialization File
       When sc first starts, it looks for a file in the user's home  directory
       called  .scrc  and  if found, loads it into memory.  The format of this
       file is the same as any other sc  file,  but  should  be  reserved  for
       setting  certain  defaults.   Any  options  set  which  have equivalent
       command line options may be overridden by the command  line.   If  that
       file  contains  the  command ``set scrc'', sc will then look for a file
       called .scrc in the current directory, and if  found,  load  that  file
       into memory, too (this is analogous to the ``set exrc'' command used by
       vi/ex).  These ``dotfiles'' may be created by any text editor.  Several
       commands exist specifically for setting default file name extensions in
       the .scrc file, although they may also be used  from  macros,  ordinary
       spreadsheet  files,  or  from within sc at the command line.  They will
       not, however, be saved along with the file.  The extensions  should  be
       quoted, and should not include the preceding `.' (e.g., scext "sc" will
       add the extension .sc ).  These commands are:

       scext  This is the default extension for normal sc files (those created
              with  the  Put  command).   If  this command is not used, all sc
              files will be saved  without  an  extension,  and  any  existing
              extension  will  not be removed.  Setting this option causes all
              sc files to be saved with the specified extension added,  unless
              it  is  already  present.   If  the  file  name  already  has an
              extension of .sc, it will first be removed.  Any other extension
              will not be removed.

       ascext This  is the default extension for plain text files created with
              the Write command.  The file name will first be checked  to  see
              if  it  already  has an extension of either .sc or the extension
              specified with scext above, and if either one  exists,  it  will
              first  be  removed  before  adding  the  new extension.  If this
              option is not set, a default of .asc will be used.

       tbl0ext
              This is the default extension for files  created  with  the  Tbl
              command  if  tblstyle is set to 0 (default).  The file name will
              first be checked to see if it already has an extension of either
              .sc  or  the extension specified with scext above, and if either
              one exists, it will first  be  removed  before  adding  the  new
              extension.  If this option is not set, a default of .cln will be
              used.

       tblext This is the default extension for files  created  with  the  Tbl
              command  if tblstyle is set to tbl.  The file name will first be
              checked to see if it already has an extension of either  .sc  or
              the  extension  specified  with  scext  above, and if either one
              exists,  it  will  first  be  removed  before  adding  the   new
              extension.  If this option is not set, a default of .tbl will be
              used.

       latexext
              This is the default extension for files  created  with  the  Tbl
              command  if  tblstyle is set to latex.  The file name will first
              be checked to see if it already has an extension of  either  .sc
              or  the  extension specified with scext above, and if either one
              exists,  it  will  first  be  removed  before  adding  the   new
              extension.  If this option is not set, a default of .lat will be
              used.

       slatexext
              This is the default extension for files  created  with  the  Tbl
              command  if tblstyle is set to slatex.  The file name will first
              be checked to see if it already has an extension of  either  .sc
              or  the  extension specified with scext above, and if either one
              exists,  it  will  first  be  removed  before  adding  the   new
              extension.  If this option is not set, a default of .stx will be
              used.

       texext This is the default extension for files  created  with  the  Tbl
              command  if tblstyle is set to tex.  The file name will first be
              checked to see if it already has an extension of either  .sc  or
              the  extension  specified  with  scext  above, and if either one
              exists,  it  will  first  be  removed  before  adding  the   new
              extension.  If this option is not set, a default of .tex will be
              used.

   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
       table.  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 either a
       highlighted cell or a ``<'' on the  screen,  and  a  character  cursor,
       indicated by the terminal's hardware cursor.

       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.

   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.  Unless otherwise noted, 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
                     recalculated.   Normally  this is not noticeable, but for
                     very large  spreadsheets,  it  may  be  faster  to  clear
                     automatic  recalculation  mode and update the spreadsheet
                     via  explicit  ``@''  commands.   Default  is   automatic
                     recalculation on.

              b      Braille  enhancement mode.  See the braille section under
                     the Set command below for a complete description  of  how
                     to use this mode.  This option is not saved when saving a
                     file, to allow blind and sighted users  to  easily  share
                     files.  It is intended for use in a user's .scrc file.

              c      Current  cell highlighting.  If enabled, the current cell
                     is highlighted (using the terminal's  standout  mode,  if
                     available)  and  the  cell  pointer  ``<'' is turned off.
                     This is enabled by default.

              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
                     functions 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.

              i      Automatic  insertion of rows/columns.  If this is enabled
                     and craction is set to move the cell cursor  either  down
                     or  to the right after entering data into a cell, and the
                     last cell in a row/column in the scrolling portion  of  a
                     framed  range was just filled, causing the cell cursor to
                     move outside of this range,  a  new  column/row  will  be
                     inserted,  thus  enlarging  the range and allowing you to
                     continue  entering  data  into  the  row/column   without
                     overwriting  the  frame (which may contain expressions of
                     some sort, such as totals).  If autowrap is also enabled,
                     it  will  take precedence, and a new row/column will only
                     be inserted after entering data in  the  very  last  cell
                     (bottom  right  corner)  of  the  scrolling  range.   The
                     default is no automatic insertion.

              w      Automatic wrap to next row/column.  If  this  is  enabled
                     and  craction  is set to move the cell cursor either down
                     or to the right after entering data into a cell, and  the
                     last  cell  in a row/column in the scrolling portion of a
                     framed range was just filled, causing the cell cursor  to
                     move  outside of this range, the cell cursor will move to
                     the first cell in the next row/column in this range.   If
                     this  would  also  take  the  cursor out of the scrolling
                     portion of the range, the  cursor  will  remain  in  last
                     edited  cell  instead, unless autoinsert is also enabled,
                     in which case a new row/column will be added so that  the
                     cursor can wrap.  The default is no autowrap.

              l      Autolabeling.   If enabled, using the define command (rd)
                     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
                     assumed  to  be  the  start  of  a  numeric value for the
                     current cell, not a repeat count, unless preceded by  ^U.
                     Also,  the  `+'  and  `-' keys will enter insert mode and
                     append a `+' or `-' to the existing contents of the cell,
                     allowing  the  user to easily add to or subtract from the
                     current  numeric  contents  of  the  cell.   The   cursor
                     controls  (^P, ^N, or any of the arrow keys) in this mode
                     will end a numeric entry if  the  entry  was  started  by
                     pressing  `+',  `-',  or  a digit.  Switching from insert
                     mode to edit mode  will  cause  the  cursor  controls  to
                     revert to their normal functions.

              o      Automatic   optimization  of  expressions.   If  this  is
                     enabled, expressions which evaluate  to  a  constant  are
                     automatically  optimized upon entry.  For example, if you
                     enter @pow(2,32) into a cell, the value  4294967296  will
                     be stored in that cell, whereas if optimization is turned
                     off, the calculated value  will  be  displayed,  but  the
                     actual  expression  will  be  stored in the cell instead.
                     This allows you to edit the  expression  instead  of  re-
                     entering  it  from  scratch  when you just want to make a
                     minor change.  Default is automatic optimization off.

              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),
                     followed  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.

              $      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 is a 3-way toggle which  determines
                     which  direction to move after pressing the RETURN key to
                     enter data into a cell.  It has the same effect as  using
                     the  set (S) command to set the value of craction.  After
                     selecting this option,  you  will  be  prompted  for  the
                     direction  you  want  to move.  Valid directions are down
                     (craction=1) and to the right (craction=2).  Pressing  j,
                     ^N,  or the cursor-down key will cause the cursor to move
                     down a cell each  time  you  press  the  RETURN  key  and
                     pressing  l,  the cursor-right key, or the space bar will
                     cause the cursor to move one cell to the right.  Pressing
                     the   RETURN   key   at  the  prompt  selects  no  action
                     (craction=0, which means that the cursor will  remain  in
                     the current cell).  No action is the default unless sc is
                     started with either the -R or -C option.  This option  is
                     ignored  if  the cell into which data is being entered is
                     not the current cell.

              s      Enable/disable color slop.  If a cell's label  string  is
                     wider  than  the column width, it will slop over into the
                     next cell to the right if that cell is  empty.   However,
                     if  that  cell  is  in  a  different color range than the
                     first, this slopover  will  be  disabled,  regardless  of
                     whether  the  colors  assigned  to  the  two  ranges  are
                     different or not.  If cslop is enabled, strings may  slop
                     over even if the next cell is in a different color range,
                     carrying their color with them, which may cause a  ragged
                     boundary between the ranges, but may allow the strings to
                     be seen in their entirety.  Cslop is disabled by default.

              x      Encryption.  See the -x option.

              z      Set newline action limits.  This option  sets  limits  to
                     the  newline  action  option  above.  When this option is
                     invoked, the row and  column  of  the  current  cell  are
                     remembered.   If  a  later  newline action would take the
                     current cell to the right of the remembered column,  then
                     the  current 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.

              C      Color.  This option enables color, and must be set before
                     any other color options, such as colorneg (color negative
                     numbers) or colorerr (color cells with errors), will have
                     an  effect.   On a slow connection, turning off color can
                     noticeably speed up screen updates.

              E      Color cells with errors.  Setting this option will  cause
                     all  cells  with  expressions  which evaluate to ERROR or
                     INVALID to be set to color 3.  Color must be enabled  for
                     this option to take effect.

              N      Color  negative  numbers.   When  this option is set, all
                     cells containing negative numbers will have  their  color
                     number incremented by one.  Cells with color 8 will cycle
                     back to color 1.  Color must be enabled for  this  option
                     to take effect.

              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
              entered 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.  An alternative
              to setting newline action limits is to  enclose  the  range  for
              entry  in  a  frame (see "Framed Ranges" below), and setting the
              autowrap option.  Setting autoinsert will  insert  new  rows  as
              needed  if the frame includes data at the bottom.  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 rf) 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
                     (default) to give colon delimited  fields,  with  no  tbl
                     control  lines;  tbl to give colon delimited fields, with
                     tbl(1) control lines;  latex  to  give  a  LaTeX  tabular
                     environment; 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.

              pagesize=n
                     Set the page size for the  PageUp,  PageDown,  J,  and  K
                     commands.  If set to 0, the default is to move up or down
                     half the number of rows displayed on the  screen,  or  if
                     the current cell is in a framed range, half the number of
                     displayed rows in the scrolling region of that range.

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

              autocalc/!autocalc
                     Set/clear auto recalculation mode.

              autoinsert/!autoinsert
                     Set/clear automatic insertion mode.

              autowrap/!autowrap
                     Set/clear autowrap mode.

              optimize/!optimize
                     Set/clear auto optimize mode.

              numeric/!numeric
                     Set/clear numeric mode.

              prescale/!prescale
                     Set/clear numeric prescale mode.

              extfun/!extfun
                     Enable/disable external functions.

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

              rndtoeven/!rndtoeven
                     Default: *.5 will be rounded  up  to  the  next  integer;
                     doing  a  'set  rndtoeven' will cause it to be rounded to
                     the closest even number instead (aka banker's  rounding).
                     Round-to-even  has  advantages  over the default rounding
                     for  some  applications.   For  example,  if  X+Y  is  an
                     integer, then X+Y = rnd(X)+rnd(Y) with round-to-even, but
                     not always with the  defaulting  rounding  method.   This
                     could  be an advantage, for example, when trying to split
                     an odd amount of money  evenly  between  two  people  (it
                     would   determine  who  gets  the  extra  penny).   Note:
                     rndtoeven only effects the @rnd and @round functions.  It
                     has  no  effect  on  how  a  number is rounded to fit the
                     display format of a cell.

              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
                     facility.

              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.

              color/!color
                     Enable color.  This option must  be  set  for  any  other
                     color  options,  such  as  colorneg  or colorerr, to take
                     effect.  On a slow  connection,  turning  off  color  can
                     noticeably speed up screen updates.

              colorneg/!colorneg
                     Color  negative  numbers.   When  this option is set, all
                     cells containing negative numbers will have  their  color
                     number  increased  by one.  Cells with color 8 will cycle
                     back to color 1.  Color must be enabled for  this  option
                     to take effect.

              colorerr/!colorerr
                     Color  cells with errors.  Setting this option will cause
                     all cells with expressions which  evaluate  to  ERROR  or
                     INVALID  to be set to color 3.  Color must be enabled for
                     this option to take effect.

              cslop/!cslop
                     Enable color slop.  If a cell's  label  string  is  wider
                     than  the  column  width, it will slop over into the next
                     cell to the right if that cell  is  empty.   However,  if
                     that  cell  is in a different color range than the first,
                     this slop over will be disabled,  regardless  of  whether
                     the  colors  assigned  to the two ranges are different or
                     not.  If cslop is enabled, strings may slop over even  if
                     the  next  cell  is  in a different color range, carrying
                     their color with them, which may cause a ragged  boundary
                     between  the ranges, but may allow the strings to be seen
                     in their entirety.  Cslop is disabled by default.

              The following Set options are considered  personal  preferences,
              or  are  terminal  dependent,  and  are therefore not saved when
              saving a file, but are instead intended  for  use  in  a  user's
              .scrc file.

              braille/!braille
                     Set/clear   braille   enhancement   mode.   When  braille
                     enhancement mode is set, the cursor behaves in  a  manner
                     that makes the use of sc much easier when using a braille
                     display.  In spite of its name, this mode also works well
                     with screen readers such as SpeakUp, and can even be used
                     by sighted users to make cutting and  pasting  using  the
                     screen program much easier.

                     There are actually two different braille modes.  When the
                     braille option is set, the C command, which  is  normally
                     used  to set colors, will instead change from one braille
                     mode to the other.  If it is desired to set/change colors
                     so  you  can  share files with others not using a braille
                     display, braille  mode  will  have  to  be  switched  off
                     temporarily,  and  then  switched back on after the color
                     operation is done.

                     When the braille option is set, the default braille  mode
                     will  cause  the cursor to be positioned at the left edge
                     of the current cell, while  the  alternate  braille  mode
                     will  cause  the  cursor to be placed at the beginning of
                     the top line, which will contain information such as  the
                     current  cell  address,  contents of the cell, and column
                     formatting information.  The column names  will  also  be
                     moved  to  the  left  edge of their respective columns in
                     order to remain aligned with the cursor as  it  moves  up
                     and down the column.

                     In either mode, the cursor will be placed in the top line
                     when editing a line, except when  switching  to  navigate
                     mode,  in  which case the cursor will be placed in either
                     the current cell (default braille  mode)  or  the  second
                     line,  where  the  cell  address or default range will be
                     displayed (alternate braille mode).

                     Whenever a message is displayed on the second line,  such
                     as  an  error  message or prompt for further information,
                     both modes will cause the cursor  to  be  placed  at  the
                     beginning of that message.  After this message goes away,
                     the cursor will  revert  to  its  former  behavior.   The
                     easiest   way  to  make  this  message  go  away  without
                     effecting anything, except  in  the  cases  where  it  is
                     asking  the  user  for  more information, is to press CC,
                     which effectively changes modes twice, with a net  effect
                     of leaving sc in the original mode.

              locale/!locale
                     If  locale  support is compiled into sc, this option will
                     cause certain locale-dependent  behaviors,  such  as  the
                     display   of   numbers  and  the  determination  of  word
                     boundaries for some operations in edit mode.   Note  that
                     if this option is set and the environment variable LC_ALL
                     is unrecognized, unset, or set  to  either  ``POSIX''  or
                     ``C'', commas in format commands will be ignored.

              cellcur/!cellcur
                     Set/clear current cell highlighting mode.  This option is
                     included  here  because  it  is  likely  to  be  terminal
                     dependent  and/or a user preference, and therefore is not
                     saved when saving a file.

              scrc   It tells sc to also read the file .scrc  in  the  current
                     directory  when  starting.   Settings  in  this file will
                     override those  in  $HOME/.scrc  but  may  themselves  be
                     overridden  by  command line options.  Setting this could
                     be a potential security risk, since starting sc  with  an
                     unknown   .scrc   could   potentially  execute  arbitrary
                     commands.  This risk is probably  very  slight,  since  a
                     spreadsheet  program  is not likely to be run in just any
                     directory, and should never be run as root.

   Cursor Control Commands

       ^A     Go to cell A0 (same as HOME).

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

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

       ^H     Move the cell cursor backward one column.

       SPACE  Move the cell cursor forward one column.  When in navigate mode,
              if a range is highlighted, insert the highlighted range into the
              command line, followed by a space, while remaining  in  navigate
              mode.   This  is  useful  when  entering  copy,  move,  or frame
              commands,  for  example,  which  accept  more  than  one   range
              argument.

       h, j, k, l
              These  are  alternate, vi-compatible cell cursor controls (left,
              down, up, right).  Space is just like l (right).

       H, J, K, L
              These move the cursor by half pages (left, down, up, right).  If
              pagesize  is  nonzero,  up/down paging will be by pagesize rows,
              instead.

       ^F, ^B Same as J and K above.

       PAGE-DOWN PAGE-UP
              Same as J and K above.

       TAB    If the character cursor  is  on  the  top  line,  TAB  tries  to
              complete  a range name if the character immediately preceding it
              is alphanumeric or ``_'', and starts a range if not (see below).
              Otherwise, move the cell cursor forward one column.

       HOME   Go to cell A0.

       END    Same as ^E (see below).

       Arrow Keys
              The  terminal's arrow keys provide another alternate set of cell
              cursor  controls  if  they  exist  and  are  supported  in   the
              appropriate termcap entry.  Some terminals have arrow keys which
              conflict 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.

       g      Go to  a  cell.   sc  prompts  for  a  cell's  name,  a  regular
              expression  surrounded by quotes, or a number.  If a cell's name
              such as ae122 or the name of a defined range is given, the  cell
              cursor  goes  directly  to  that  cell.   If  a  quoted  regular
              expression such as " Tax Table " or " ^Jan [0-9]*$ "  is  given,
              sc  searches for a cell containing a string matching the regular
              expression.  See regex(3) or ed(1) for more details on the  form
              of regular expressions.

              You  can  also  search  formatted  numbers  or expressions using
              regular expressions by  preceding  the  opening  quotes  of  the
              regular  expression  with  a  ``#'' (for formatted numbers) or a
              ``%'' (for expressions).  These  are  handy  for  searching  for
              dates  within a specified range or cells which reference a given
              cell, for  example,  although  they  are  somewhat  slower  than
              searching  through  ordinary  strings, since all numbers must be
              formatted or  expressions  decompiled  on  the  fly  during  the
              search.

              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>.
              You can also repeat the last search by pressing n.

              An optional second argument is available whose  meaning  depends
              on  whether you're doing a search or jumping to a specific cell.
              When doing a search, the second argument specifies  a  range  to
              search.   When  jumping  to a specific cell, the second argument
              specifies which cell should be in the upper lefthand  corner  of
              the  screen,  if  possible,  which  allows  you  to position the
              destination cell where you want it on the screen.

       ^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
              command  is useful when specifying ranges of adjacent cells (see
              below), especially when the range is  bigger  than  the  visible
              window.

              If  ^E is pressed twice in succession, or if it is pressed after
              another ^E or a ^Y, it  will  cause  the  screen  to  scroll  up
              without  moving  the  cell  cursor,  unless  the  cell cursor is
              already at the top of the screen, in which case, it will  remain
              at the top of the visible screen.

       ^Y     Causes the screen to scroll down without moving the cell cursor,
              unless the cell cursor is already at the bottom of  the  screen,
              in  which  case,  it  will  remain  at the bottom of the visible
              screen.

       mx     Mark the current cell.  sc will prompt for a lowercase letter to
              be  used  as  a mark specifier.  Marked cells may be used as the
              source for the c (copy a marked cell) command, or as the  target
              of  a  ` or ' (go to marked cell) command.  In addition to cells
              marked with lowercase letters, sc also automatically  marks  the
              last  nine cells that have been edited with the numbers 1-9, and
              the current cell being edited  with  the  number  0.   When  not
              editing  a  cell,  marks 0 and 1 usually refer to the same cell,
              unless the last edit was begun in one cell, but the cell address
              was changed before pressing the RETURN key, or the last edit was
              aborted prematurely.

       `x     Jump to a  previously  marked  cell.   If  the  target  cell  is
              currently on the screen, sc will simply jump to the target cell,
              making it current.  Otherwise, sc will  attempt  to  center  the
              cell  on  the screen, if possible.  As a special case, following
              the ` with another ` will return you to the  cell  you  were  in
              before  the last g, ', `, *, or ^E (or END key) was used to jump
              to another cell.

       'x     Jump to a previously marked cell.  ' works just like ` ,  except
              that  '  will  attempt  to  restore  the marked cell to the same
              position on the screen as when it was marked.  It does  this  by
              remembering  which cell was in the upper left hand corner of the
              screen at the time the mark was set, and restoring that cell  to
              its  original position.  As a special case, following the ' with
              another ' will return you to the cell you  were  in  before  the
              last  g, ', `, *, or ^E (or END key) was used to jump to another
              cell, and will also try to position that cell on the  screen  in
              the same position as when you left it.

       z<RETURN>
              Move  the  current row to the top of the screen.  If the current
              row is in a framed range, move the current row to the top of the
              scrolling region.

       z.     Move the current row to the center of the screen.

       z|     Move the current column to the center of the screen.

       zc     Center the current cell both horizontally and vertically.

   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,
       leaving only the previously computed constant label string.   Likewise,
       entering 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
              number in response to the prompt on the  top  line.   The  quick
              numeric  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  ``='').   If  you want to begin
              entering an expression in the current  cell,  but  you  want  to
              start  out  in  navigate  mode (e.g. to enter cell addresses, or
              sums of ranges using ``@sum''), use the  ``+''  command  instead
              (see below).

       <      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.

       {      Left justify the string in the current cell.

       |      Center the string in the current cell.

       }      Right justify the string in the current cell.

       F      Enter a format string into the current cell.  This format string
              overrides the precision specified with the f command unless & is
              present in the fractional part of the format string (see below).
              The  format only applies to numeric values.  There are two types
              of format strings allowed: standard numeric  and  date.   (Note:
              these  format  strings  may  also  be used with the f command to
              create user-defined format types.)  The following characters can
              be used to build a standard numeric format string:

              #      Digit  placeholder.   If  the  number has fewer digits on
                     either side of the  decimal  point  than  there  are  `#'
                     characters  in  the  format, the extra `#' characters are
                     ignored.  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
                     number  is  padded  with  zeroes  on  either  side of the
                     decimal point.  The number of zeroes used in  padding  is
                     determined  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
                     digits 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
                     number.  If locale is set,  the  decimal  point  for  the
                     user's  current  locale  will  be  used when formatting a
                     number.  Note that numbers smaller than 1 will begin with
                     a  decimal  point  if  the left side of the decimal point
                     contains  only  a  `#'  digit  placeholder.   Use  a  `0'
                     placeholder 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
                     number  to be formatted with a `,' separating each set of
                     three digits in the  integer  part  of  the  number  with
                     numbering  beginning  from  the right end of the integer.
                     If locale is set, the thousands separator for the  user's
                     current  locale  will  be used in place of the comma.  If
                     the environment variable LC_ALL is  unset,  unrecognized,
                     or  is  set  to  ``POSIX''  or  ``C'',  any commas in the
                     format string will be ignored.

              &      Precision.   When  this  character  is  present  in   the
                     fractional  part  of  the  number,  it is equivalent to a
                     number of 0's equal to the  precision  specified  in  the
                     column  format command.  For example, if the precision is
                     3, `&' is equivalent to `000'.

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

              E- E+ e- e+
                     Scientific format.  Causes the number to be 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
                     placeholder 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
                     format 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)'').

              Date  format  strings  are identified by the presence of a ^D in
              the first postition.  If this is present, the remainder  of  the
              string  is passed to the strftime() function, and therefore uses
              the  same  conversion  specifiers  as  strftime().    For   more
              information  on  conversion  specifiers for date format strings,
              see the man page for strftime(3).

       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
              identical  to  ``=''  except  that  the  command line starts out
              containing the old numeric value or expression  associated  with
              the cell.  The editing in this mode is vi-like.

              ^H     Move back a character

              ^V, v  Enter  navigate  mode.   This mode allows you to navigate
                     the  spreadsheet  while  editing  a  command.   When   in
                     navigate  mode,  v  will  insert the numeric value of the
                     current cell, if any, into  the  command  line,  instead,
                     while  ^V  will  return  to  the  previous mode (like the
                     ESCAPE key).

              ^W     Insert the expression attached to the current  cell  into
                     the command line.  If there is none, the result is ``?''.
                     This only works while in navigate mode.

              ^A     In navigate mode, go to cell A0.  When  not  in  navigate
                     mode, jump to the beginning of the line instead.

              ^E     Jump  to the end of the line.  Unlike ``$'' (below), this
                     can also be used from insert mode.

              TAB    If the character  immediately  preceding  the  cursor  is
                     alphanumeric  or  ``_'', TAB tries to find a match in the
                     list of range names, and if one is found, the  name  will
                     be  completed on the command line.  If there are multiple
                     matches,  pressing  TAB  repeatedly  without  any   other
                     intervening  keys  will  cycle  through  all of the valid
                     matches.  If  the  character  immediately  preceding  the
                     cursor  is not alphanumeric or ``_'', TAB defines a range
                     of cells via the cursor control  commands  or  the  arrow
                     keys.  Pressing TAB automatically switches sc to navigate
                     mode if you haven't already done so using the ^V command,
                     and  the range is highlighted, starting at the cell where
                     you typed TAB, and continuing through the  current  cell.
                     Pressing  TAB  again  causes  the highlighted range to be
                     inserted into the command line, the  highlighting  to  be
                     turned  off,  and the previous mode to be restored.  This
                     is most useful for defining ranges to functions  such  as
                     @sum().  Pressing ``)'' acts just like typing the TAB key
                     the second time and adds the closing  ``)''.   Note  that
                     when  you  give a range command, if the first argument to
                     the command is a range, you don't need to press the first
                     TAB  to  begin defining a range starting with the current
                     cell.

              :      Synonym for TAB, when in navigate mode.

              ` '    In navigate mode, go to marked cell.

              *      In navigate mode, go to note linked to current cell.

              +      Forward through history (same as j)

              -      Backward through history (same as k)

              ESC    Done editing

              CR     Save.  When in navigate mode,  insert  the  name  of  the
                     current  cell  (the  one  at  the  cell  cursor) into the
                     command line.  This is useful when  entering  expressions
                     which refer to other cells in the table.

              $      Goto last column

              %      Goto matching parenthesis

              .      Insert  current  dot buffer.  When in navigate mode, this
                     is a synonym for : or TAB.

              ;      Repeat the last f, F, t, or T command.

              ,      Repeat the last f, F, t, or T command, but in the reverse
                     direction.

              ~      Change the case of the character under the cursor.

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

              ?      Search  forward  for  a  string in the history (see ``/''
                     above)

              0      Goto column 0

              B      Move back  a  word.   Like  b,  except  words  are  space
                     delimited only.

              C      Change  to  end  of line (delete first, then enter insert
                     mode)

              D      Delete to end of line

              F      Find the next char typed, moving backwards in the line

              G      Go to the  end  of  history,  i.e.,  to  the  line  being
                     currently entered

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

              N      Repeat the last search in the opposite direction

              P      Insert the most recently deleted text before the cursor

              R      Replace mode; ESC revert back to edit mode

              T      Goto a char, moving backwards in the line

              W      Forward a word.  Like w, except words are space delimited
                     only.

              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.   In  navigate
                     mode, insert color range which includes the current cell.

              d      Delete ...
                     0    delete to beginning of line
                     $    delete to end of line
                     b    back word
                     e    delete to end of 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

              e      Forward to next end-of-word

              f      Find  the  next char typed.  In navigate mode, insert the
                     outer frame range which includes the current cell.

              g      In navigate mode, allows you to `goto' a cell  or  range,
                     just  like  the  regular  goto command.  Ignored in edit,
                     insert or replace modes.

              h      Move left a char

              i      Insert before cursor; ESC revert back to edit mode

              j      Forward through history (same as +)

              k      Backward through history (same as -)

              l      Move right a char

              n      Repeat the last search (find the next match)

              o      When highlighting a range in navigate mode, move  to  the
                     opposite corner of the highlighted range.

              p      Insert the most recently deleted text after the cursor

              q      Stop editing

              r      Replace  char.   In navigate mode, insert the inner frame
                     range which includes the current cell.

              s      Delete current char and enter  insert  mode  (stands  for
                     substitute)

              t      Goto a char

              u      Undo

              w      Forward a word

              x      Delete the current char (moving to the right)

              y      Copies to the delete buffer without deleting.  Use like d
                     (above).

       E      Edit the string associated  with  the  current  cell.   This  is
              identical to ``<'', ``\'', or ``>'' except that the command line
              starts  out  containing  the  old  string  value  or  expression
              associated 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 expressions for more information.

       Note that the descriptions of the ``+'' and ``-''  commands  below  may
       seem  very  confusing  at  first, but once they're understood, they can
       facilitate the rapid entry of expressions which add and subtract  large
       numbers  of  cells  and  sums  of  ranges  of  cells, so read them over
       carefully several times until you understand them.

       "      Specify a named buffer for the  next  yank/delete/pull  command.
              Buffers  are  named  with  a  single  character.   Buffers ``a''
              through ``z'' are general purpose buffers, buffers ``1'' through
              ``9''  hold the last nine deletions, with buffer ``1'' being the
              most recent, and buffer ``0''  holds  the  last  cell  or  range
              yanked.   Buffer  ``"''  is  the default buffer, which holds the
              last cell or range that was deleted or yanked.

       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
              recalculation order is set.  Cells cleared with this command may
              be recalled with any of the pull commands (see below).

       mx     Mark the current cell.  sc will prompt for a lowercase letter to
              be used as a mark specifier.  Marked cells may be  used  as  the
              source for the copy command, or as the target of a ` or ' (go to
              marked cell) command.

       cx     Copy a marked cell to the current cell, adjusting row and column
              references in its numeric or string expression, if any.  sc will
              prompt for the name of the cell to be copied,  which  may  be  a
              lowercase  letter  specified  previously  with  the m command, a
              digit 1-9 to reference one of the last nine edited cells (0 will
              reference  the  last cell in which an edit was begun, regardless
              of whether  the  edit  was  completed  or  not),  or  ``.''   to
              reference  the  current cell, which, as a special case, is to be
              used as a source rather than a destination, and is to be  copied
              into  a  range  which includes the current cell.  When ``.''  is
              specified, the current cell is set as the default  source  range
              for  the  range  copy (rc) command, and then the copy command is
              entered into the command line and sc switches to navigate  mode.
              Moving  the  cell  cursor  will  then  highlight the destination
              range.  After the desired range is highlighted, press RETURN  to
              execute the copy.

       +      If  not  in  numeric  mode,  add  the  current  numeric argument
              (default 1) to the value of the current cell.  The current value
              of  the  cell  must  not  be  an expression.  In numeric mode, +
              switches to insert mode and  appends  a  ``+''  to  the  current
              expression  or  value,  if  any,  which  makes it easy to add to
              existing data.

              In navigate mode, + inserts the current cell  address  into  the
              line,  followed  by  another +, and sc remains in navigate mode,
              unless a range is highlighted.  If a range  is  highlighted  and
              the  character  immediately  preceding  the cursor is a ``+'' or
              ``-'', or the cursor is at the beginning  of  an  empty  ``let''
              expression,  the  string ``@sum('' will be inserted, followed by
              the highlighted range,  followed  by  ``)+''.   If  a  range  is
              highlighted  and  the character immediately preceding the cursor
              is not a ``+'' or ``-'', and the cursor is not at the  beginning
              of  an  empty  ``let'' expression, the highlighted range will be
              inserted, followed by  ``)+''.

       -      If not in numeric mode, subtract the  current  numeric  argument
              (default  1)  from  the  value of the current cell.  The current
              value of the cell must not be an expression.  In numeric mode, -
              switches  to  insert  mode  and  appends  a ``-'' to the current
              expression or value, if any, which makes  it  easy  to  subtract
              from existing data.

              In  navigate  mode,  - inserts the current cell address into the
              line, followed by another -, and sc remains  in  navigate  mode,
              unless  a  range  is highlighted.  If a range if highlighted and
              the character immediately preceding the cursor  is  a  ``+''  or
              ``-'',  or  the  cursor  is at the beginning of an empty ``let''
              expression, the string ``@sum('' will be inserted,  followed  by
              the  highlighted  range,  followed  by  ``)-''.   If  a range is
              highlighted and the character immediately preceding  the  cursor
              is  not a ``+'' or ``-'', and the cursor is not at the beginning
              of an empty ``let'' expression, the highlighted  range  will  be
              inserted, followed by  ``)-''.

       RETURN If  you  are  not  editing  a cell (top line is empty), pressing
              RETURN 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.

       ZZ     Save  the  current database into a file if it has been modified,
              and then quit.  This is like the P command  followed  by  the  q
              command,  except  that the default filename will be used instead
              of prompting you for one, and the file will only be saved if  it
              was modified.  If there is no default filename, an error message
              will be displayed, and no action taken.

       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
              table processors.  The delimiters are controlled by the tblstyle
              option.   See  Set  above.   The  delimiters 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
       (potentially) dangerous operation is really what you want.

       The three output commands,  Put,  Write,  and  Table,  can  pipe  their
       (unencrypted only) output to a program.  To use this feature, enter ``|
       program'' 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
              database.   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.  There are two different kinds of macros that can be
              used with sc: simple macros, which  are  stored  in  plain  text
              files,  and  advanced  macros,  which  are executable files, and
              which can be written in the language of your  choice.   Advanced
              macros are only available on systems that support pipes.

              Simple  macros  are interpreted by sc's internal parser, and use
              the  same  commands  used  to  enter  data  and  perform   other
              operations  (the  single key commands are shortcuts which switch
              to input mode after first entering the  beginning  of  the  full
              command  for you).  These are also the same commands found in sc
              files created with the Put command.  Since sc files are saved as
              ASCII  files,  it  is  possible  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.

              Advanced macros use executable files that are started by sc as a
              child  process  with  stdin and stdout redirected back to sc for
              bidirectional communication.  Special commands are available for
              requesting   information   such  as  cell  contents,  formatting
              information,  or  the  current  location  of  the  cell  cursor.
              Commands  are  written  to  stdout,  and responses are read from
              stdin.  To use advanced macros, the filename must be preceded by
              a  | (the pipe symbol), and the file must be executable.  If the
              pathname set with the Define command begins with a |, all  files
              in  that  path  will be executed as advanced macros.  It is also
              possible to include a filename as part of the  path  when  using
              advanced  macros,  which  allows you to put multiple macros in a
              single file, and  use  the  Run  command  to  add  command  line
              arguments  or  options  to  determine which macro should be run.
              Advanced macros are relatively new, and documentation  is  still
              incomplete.   This  feature  will probably be enhanced in future
              releases.

       A      Specify a macro to be automatically  run  whenever  the  current
              sheet is reloaded from a file.

       D      Define a path for the Run command to use (see above).

       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
       filename.  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
       resulting  string  starts  with  ``|'',  the  rest  of  the  string  is
       interpreted as a UNIX command, as above.

   Row and Column Commands
       These  are  two-letter  commands  which  can  be used on either rows or
       columns.  The exceptions  are  the  f  command,  which  only  works  on
       columns,  and  therefore  doesn't  require  a  second letter, and the p
       command which, in addition to operating on rows or columns, has several
       other  options  for  merging the data in directly, without opening up a
       new row or column.  There are also a few special cases  where  pressing
       the  same  letter  twice will affect only the current cell instead of a
       row or column (except for ZZ, which is a special case all its own).

       In all of the remaining cases, the second letter of the command will be
       either  r  or c, depending on whether the operation should be performed
       on rows or columns, respectively (additional options for the p  command
       and  the double letter cases are listed below).  A small menu lists the
       choices for the second letter when you type the first letter of one  of
       these commands.

       Alternatively,  you may define a range of rows or columns by moving the
       cell cursor, either a cell at a time, or by pages (roughly 1/2  screen,
       unless  the  pagesize option has been set), but this only works for the
       d, y, and Z commands.  Vertical cursor movement will begin highlighting
       rows,  and  horizontal  movement  will highlight columns.  Pressing the
       RETURN key will then perform the  chosen  operation  on  the  specified
       rows/columns.

       Commands  which 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).  Commands which create new rows or  columns  will  include
       all  newly  created  cells in the same ranges (named, framed, color, or
       those used in expressions) as their counterparts in the current row  or
       column.   This  can  sometimes  be  a  significant factor when deciding
       whether to use ir/ic or or/oc.

       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.   Inserting
              rows while the cell cursor is in a framed range will only effect
              rows in that range, leaving all  rows  to  the  left  and  right
              untouched.

       or, oc Open a new row (column).  These commands work like the ir and ic
              commands, except that the new  row  (column)  will  be  inserted
              after the current row (column) instead of before it.

       ar, ac Append  a new row (column) immediately following the current row
              (column).  It is initialized as  a  copy  of  the  current  one.
              Appending  rows  while the cell cursor is in a framed range will
              only effect rows in that range, leaving all rows to the left and
              right untouched.

       dr, dc, dd
              Delete  the  current  row (column).  dd deletes the current cell
              (i.e., it is a synonym for x).  Deleting  rows  while  the  cell
              cursor is in a framed range will only effect rows in that range,
              leaving all rows to the left and right untouched.

       yr, yc, yy
              Yank a copy of the current row (column) into the  delete  buffer
              without  actually  deleting  it.   yy  yanks  the  current  cell
              (similar to x, but without actually deleting the contents of the
              cell).   Yanking rows while the cell cursor is in a framed range
              will only copy the portion of each row contained in that  range,
              while ignoring everything outside the range.

       pr, pc, pp, pm, px, pt, pC, p.
              Pull  deleted rows/columns/cells back into the spreadsheet.  The
              last set of cells that was deleted or yanked 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.
              pp  (paste)  does  not insert rows or columns; it overwrites the
              cells beginning at the current cell cursor location.  pm (merge)
              merges  the  cells  in  at the current cell cursor location, but
              does not  erase  the  destination  range  first  like  pp.   The
              difference  between  pp  and  pm  is  similar  to the difference
              between the Get and Merge commands.  pf (format) works  like  pm
              except  that  only  cell  formatting  information  is merged in,
              leaving the actual data untouched.  This makes it easy  to  copy
              cell  formats  from one part of the spreadsheet to another, such
              as when expanding an existing spreadsheet file.   px  (exchange)
              copies  the  contents  of  the  delete  buffer  into  the  range
              beginning  at  the   current   cell   cursor   location,   while
              simultaneously  copying the contents of this range back into the
              delete buffer, replacing its current contents.   pt  (transpose)
              overwrites  the  cells  beginning  at  the  current  cell cursor
              location like pp, but  transposes  rows  for  columns  and  vice
              versa.  pC (copy) works like pp, except that all cell references
              are adjusted in the same way that they are for the copy command.
              p.   is the same as pC, except that it switches to navigate mode
              and allows you to define the destination range to be used.  This
              works  like  the  copy  command in that if the source range (the
              contents of the delete buffer) is a single row, column, or cell,
              multiple copies may be made.

       vr, vc, vv
              Remove  expressions  from  the  affected rows (columns), leaving
              only the values which were in the cells before the  command  was
              executed.   When  used  in  a  framed range, vr only affects the
              portion of the the row inside the range, leaving the rest of the
              row  unchanged.   vv  only  affects  the contents of the current
              cell.

       Zr, Zc, ZZ
              Hide (``zap'') the current  row  (column).   This  keeps  a  row
              (column)  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 still be hidden when you reload
              the spreadsheet.  Hidden rows or columns are not printed by  the
              W  command.  The ZZ command is a special case.  It does not hide
              anything.  Instead, the file will be saved, if modified, and  sc
              will exit.  See ZZ above, under File Commands.

       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.  This command has only a
              column version (no second letter).  You may  change  the  column
              width  by pressing the h, <, or cursor left key to reduce it, or
              the l, >, or cursor right key to increase it.  Likewise, you may
              change  the  precision  (the  number of digits to follow decimal
              points) by pressing the j, -, or cursor down key to  reduce  it,
              or  the  k,  +,  or  cursor up key to increase it.  You may also
              change the format type for the column by pressing any digit.  If
              the  f  command is preceded by a numeric argument, that argument
              will determine how many columns  should  be  changed,  beginning
              with  the  current  column,  and  in the case of incrementing or
              decrementing the width or precision of the columns, each  column
              will be incremented or decremented separately, regardless of its
              initial values.  Several formatting operations may be  performed
              in sequence.  To leave the formatting command, simply press ESC,
              ^G, q, or RETURN .

              Alternatively, you may press SPACE to get the format command  in
              the  top  line  and  enter all three values directly.  In order,
              these are: the total width in  characters  of  the  column,  the
              precision,  and  the  format type.  Format types are 0 for fixed
              point, 1 for scientific notation, 2 for engineering notation,  3
              for  dates  with  a  two digit year, and 4 for dates with a four
              digit year.  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.

              You  can  also  create your own format types by pressing = after
              the f command, followed by any digit (see the  F  command  above
              under  Cell  Entry and Editing Commands for a description of how
              to build a format string).  Format  numbers  0  through  4  will
              supersede  the  built-in format types, while numbers 5 through 9
              will supplement them.  User defined format types may be used  in
              the same way as the built-in types.  For example, the command

                     format 5 = "#,0.& ;(#,0.&)"

              will  define  a  currency  format  which may then be assigned to
              column C, for example, with the command

                     format C 10 2 5

       @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
              column could then be  accessed  by  @nval("d",@myrow-1).   NOTE:
              @myrow and @mycol can't be used in specifying ranges.

       @lastrow, @lastcol
              These  return  the  last  row  and  column  of  the spreadsheet,
              respectively.  They are useful for macros designed to default to
              the whole spreadsheet.

   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
       commands  in  this  class  begin  with  ``r''; the second letter of the
       command indicates which command.  A small menu lists  the  choices  for
       the  second  letter  when  you  type  ``r''.   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
       explicit variable name, such as A10, or with a variable name previously
       defined in a rd command (see below).  Range name prompts require either
       an  explicit  range such as A10:B20, or a range name previously defined
       with a rd 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
       control  commands  (^P  or  ^N)  or  the  arrow keys.  The cells in the
       default range are highlighted (using the terminal's standout  mode,  if
       available).

       rx     Clear a range.  Cells cleared with this command will be saved in
              the delete buffer, and may be recalled  with  any  of  the  pull
              commands.

       ry     Yank  a  range.  Like rx, cells yanked with this command will be
              saved in the delete buffer, and may be recalled with any of  the
              pull  commands.   This command differs from rx, however, in that
              the original cells will not be cleared.  Although  this  command
              may  be  used to copy a range of cells, it treats all references
              as fixed.  Use rc if you want references to be relative  to  the
              cell which contains them unless specified otherwise, either with
              the @fixed operator or using the $ character in the reference to
              the cell.

       rc     Copy  a  source  range  to  a destination range.  The source and
              destination 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.

              If  the  source  range  is omitted (second argument), the source
              range from the last copy command will be used, unless a range is
              currently  highlighted, in which case the highlighted range will
              be copied instead.  If both the  source  range  and  destination
              range  are  omitted,  the  current  cell  will  be  used  as the
              destination, unless a range is currently highlighted,  in  which
              case  the  highlighted  range will serve as the destination, and
              the source range from the last copy command will be copied  into
              that destination.

       rm     Move  a  source range to a destination range.  This differs from
              deleting a range with rx and pulling it back in with pm in  that
              any  expressions  that reference a cell in the range to be moved
              will reference the cell at  its  new  address  after  the  move.
              Unlike  the  rc  command,  the destination of a move is a single
              cell, which will be the upper  lefthand  corner  of  the  source
              range after the move.

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

       rs     Sort a range.  The rows in the specified range  will  be  sorted
              according  to  criteria  given  in  the  form  of  a  string  of
              characters.   This  string,  enclosed  in  double  quotes,   may
              comprise  a  single criterion or multiple criteria in decreasing
              order of precedence.  Each criterion has  three  parts,  all  of
              which  are  mandatory.   The  first  part is a single character,
              which must be either + or -, which specifies  whether  the  sort
              should  be  done in ascending or descending order, respectively.
              The second part, which is  also  a  single  character,  must  be
              either # or $, and is used to specify whether the sort should be
              based  on  the  numeric   portion   or   the   string   portion,
              respectively,  of  the cells being used for the comparison.  The
              third part may be either one or  two  characters,  and  must  be
              alphabetic  (case  insensitive),  and specifies the column to be
              used when making the comparisons.  This column must  be  in  the
              range being sorted.  Any number of criteria may be concatenated,
              and will be used in the order specified.   If  no  criteria  are
              specified,  the  default behavior is to sort in ascending order,
              first by string and then by number, using the leftmost column of
              the  range  being  sorted.  This is equivalent to specifying the
              sort criteria to be " +$a+#a ", where both a's are  replaced  by
              the name of the leftmost column of the range being sorted.

       rf     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
              positive or negative.  To fill all cells with  the  same  value,
              give an increment of zero.

       r{     Left justify all strings in the specified range.

       r}     Right justify all strings in the specified range.

       r|     Center all strings in the specified range.

       rd     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
              response to prompts requesting a cell or  range  name,  and  are
              saved when the spreadsheet is saved with the Put command.  Names
              defined may be any combination of  alphanumeric  characters  and
              `_'  as  long  as the name isn't a valid cell address.  Thus, x,
              H2SO4, and 3rdDay are all valid names, but H2 is not.

       rl     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 any way until it is unlocked.

       rU     This command is the opposite of the rl command and thus  unlocks
              a locked cell and makes it editable.

       rS     This  command  shows lists of the currently defined range names,
              framed ranges, and color definitions and ranges, one  after  the
              other.   The  output  of this command will be piped to less.  If
              the environment variable PAGER is set,  its  value  is  used  in
              place of less.

       ru     Use this command to undefine a previously defined range name.

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

       rr     This command is  used  for  creating,  modifying,  and  deleting
              framed  ranges.   A  framed  range, is one which has a number of
              rows or columns specified at the top, bottom, left, and/or right
              (the  frame) which must remain onscreen whenever the cell cursor
              is within that range.  In other words, a frame  consists  of  an
              outer range and an inner range, where the inner range is allowed
              to scroll within the outer range.  Once a frame is defined,  the
              inner  range  may  be resized, but the outer range remains fixed
              unless rows or columns are added or deleted within the range.

              When this command is invoked, you will be prompted for the  type
              of  frame-related  action  you  would  like to perform.  You may
              select an option from the list by typing its first letter.

              The options are top, bottom, left, right, all, and unframe.   If
              you choose top, bottom, left, or right, you will be prompted for
              a range and number of rows/columns.  The range may be omitted if
              the  cell  cursor  is  in  a previously defined framed range, in
              which case that range's outer range will be used  instead.   The
              number  of  rows/columns  will  set  or  adjust the width of the
              corresponding side of the frame.  If all of these widths are set
              to  zero,  the  frame  will  be  undefined  (same as the unframe
              command).

              If you choose all, you will be prompted for an outer  range  and
              an inner range, in which case the inner range will scroll within
              the outer range, and any rows or columns outside  of  the  inner
              range,  but inside the outer range will be part of the ``frame''
              that is to remain onscreen.  The outer range may be  omitted  if
              the  cell  cursor  is  in  a previously defined framed range, in
              which case the previously defined  outer  range  will  be  used.
              However,  if  a  single  range is specified on the command line,
              while another  range  wholly  contained  within  this  range  is
              highlighted,  the  specified  range  will  be  used as the outer
              range, and the highlighted range  will  be  used  as  the  inner
              range.   If  no  range  is  specified on the command line, but a
              range is  highlighted,  and  the  highlighted  range  is  wholly
              contained   within   a  previously  defined  framed  range,  the
              highlighted range will be used  as  the  inner  range,  and  the
              previously defined outer range will be used as the outer range.

              If  you choose unframe, you will be prompted for a range, and if
              the range is found in the list of  frames,  the  frame  will  be
              deleted, and the framing will no longer be active (the specified
              range must be the outer range of the previously defined frame to
              be  deleted).  The range may be omitted if the cell cursor is in
              a previously defined framed range, in which case that range will
              be used by default.

              Framed  ranges  may not be nested or overlapping.  If you try to
              define a  range  that  contains  any  cells  in  common  with  a
              previously  defined  framed  range,  an  error  message  will be
              issued, and the frame will not be created.

       rC     This  command  defines  a   color   range,   and   specifies   a
              foreground/background  pair  to  be  used  for  that range.  See
              "Color Commands" below for more information.

   Note Commands
       A note is a cell or range of cells that can be jumped to  quickly  from
       another  cell  by  creating  a special link in that cell.  The note may
       contain text explaining the contents of the cell containing  the  link,
       similar  to  a  footnote,  or  it  may  simply  be  another part of the
       spreadsheet that is related to the cell in some way.   When  you  press
       the `n' key, you will get a short prompt asking you whether you want to
       add or delete a note, or to ``show'' (by highlighting) which  cells  on
       the screen have attached notes.

       If  a  cell  with  an  attached  note contains numeric data, it will be
       preceded with an ``*''.  If color is available and turned on, the ``*''
       will  be  displayed  with  color  4.   Also,  the  note address will be
       displayed in curly braces on the top line, preceded by an  ``*'',  when
       the cell is current (e.g.  {*AC30:AE43} or {*note1} for a named range).
       You may also use the *s (Note/Show) command to highlight all  cells  on
       the current screen with attached notes.

       *a     Add  a  note.  This will bring up the addnote command in the top
              line, followed by the target address of the cell where you  want
              the note added.  You must then enter the cell or range where the
              note resides to add the note.  If you omit the note  address  or
              range,  the  currently  highlighted range, if any, will be used.
              Otherwise, the current cell will be used (you would, of  course,
              want to move away from the cell in which the addnote command was
              invoked in the latter case).

       *d     Delete a note.  If there is a note attached to the current cell,
              the link will be removed (deleted).  The note itself will not be
              removed from the spreadsheet.  If it is  no  longer  needed,  it
              must be deleted in a separate step.

       *s     Show all notes on the current screen.  If there are any cells on
              the visible portion of the spreadsheet  which  contain  attached
              notes, they will be highlighted until the next screen change, no
              matter how minor.  Simply moving to a new cell will be enough to
              turn off the highlighting.

       **     Jump  to  a  note.   If  there is a note attached to the current
              cell, you will be immediately transported to that cell.  You may
              return from the note to where you were by pressing ` twice.

   Color Commands
       Color may be enabled by setting the color option (``set color''), or by
       toggling it with ^TC (control-T followed by an uppercase C).  If  color
       is  enabled, you may define up to eight color pairs, each consisting of
       a foreground color and a background color.  Each of these colors may be
       defined  by  an expression which is evaluated at the same time the rest
       of the spreadsheet is evaluated.   Color  expressions  may  be  simple,
       specifying  only a foreground color and a background color, or they may
       be arbitrarily complex, causing the colors to change based  upon  other
       data in the spreadsheet, for example.  Color ranges may then be defined
       using the rC command, with a color number (1-8) assigned to  the  range
       (see below).

       Some  of  the  color  numbers  may  have  special meaning under certain
       circumstances, but may also be used explicitly at the same  time.   For
       example,  color  1 is the default color pair if color is enabled but no
       color has been defined for a given cell.  It is also the color used for
       the  column  and row labels and the top two lines of the display, which
       are used for prompts, input, error messages, etc.  Color 2,  while  not
       explicitly  used  for  all  negative numbers, will be used for negative
       numbers in cells which have no other color  defined  when  colorneg  is
       turned  on  (``set colorneg'' or ^TN).  This is because colorneg causes
       all cells with negative numbers to have their color number  incremented
       by  one  (cycling back to color 1 if the cell is defined as using color
       8).  Color 3 is used for all cells with errors (ERROR or  INVALID),  if
       colorerr  is  set  (``set colorerr'' or ^TE), regardless of which color
       they have been defined to use, or whether they have been defined to use
       any  color  at  all.   Color  4  is  used  to highlight the ``*'' which
       signifies that a cell has a note attached.

       If two color ranges are nested or overlapping, any cell that is  common
       to  both will be displayed using the color of the most recently defined
       color range.  You can list all color definitions and color ranges  with
       the rS (show) command (see below).

       C      This  command  first  prompts you for the color number you would
              like to define (or redefine).  After selecting a  number  (1-8),
              you  may  enter  an  expression which defines the foreground and
              background colors.  If the  chosen  color  has  previously  been
              defined,  the old definition will be presented for editing.  The
              syntax of the color command is:

                     color number = expression

              where number is the number of the color pair you want to define,
              and expression is the definition.  If the expression is missing,
              the specified color number will be unset (it will revert to  its
              default  start-up  colors).  Unlike setting it explicitly to its
              original value, this will not cause the expression to be written
              to  the  file  when  saved.  See below for an explanation of the
              format of a color expression.

       rC     This  command  defines  a   color   range,   and   specifies   a
              foreground/background  pair to be used for that range.  Although
              this  command  also  uses  the  color  command,  the  syntax  is
              different from that used for defining a color pair.  This syntax
              is:

                     color range number

       rS     This command shows lists of the currently defined  range  names,
              framed  ranges,  and color definitions and ranges, one after the
              other.  The output of this command will be piped  to  less.   If
              the  environment  variable  PAGER  is  set, its value is used in
              place of less.

       Color expressions are exactly like any other  numeric  expression,  and
       may contain any function or operator that is valid in any other numeric
       expression.  There are, however special functions designed specifically
       for defining colors.  These functions are:

               @black
               @red
               @green
               @yellow
               @blue
               @magenta
               @cyan
               @white

       Although  these  function  names are intended to reflect the color they
       produce, and use the same names  as  the  curses  colors,  @yellow  may
       appear  as  brown  on  many displays, especially those based on the VGA
       standard.

       In addition to special functions for specifying colors, there is also a
       special  operator  for  combining  two such colors into a single number
       which specifies  both  a  foreground  and  a  background  color.   This
       operator is the semicolon (;).  For example, the command

              color 1 = @white;@green

       will  set  the  foreground  color  to white and the background color to
       green for any cell or range of cells defined to use color 1,  or  which
       have no color defined.  If the semicolon operator is not used, and only
       one color is specified, that color will be used for the foreground, and
       the background will default to black.

       Although the above example is the easiest way to specify foreground and
       background colors, and will  probably  meet  most  people's  needs,  sc
       allows  much  more power and flexibility, should the need arise, due to
       the fact that any  color  can  be  specified  by  an  expression.   For
       example,

              color 5 = B23<E75?(@black;@cyan):(@white;@magenta)

       will cause all cells defined with color 5 to be displayed as black text
       on a cyan background if the numeric value in cell B23 is less than  the
       numeric  value  in cell E75; otherwise, they will be displayed as white
       text on a magenta background.  If you prefer to have the foreground and
       background  colors  dependent  on  different  criteria,  you  could  do
       something like this:

              color 5 = (B23<E75?@white:@cyan);(D5%2?@red:@blue)

       This will cause the text color for color 5 to be either white or  cyan,
       depending  on  the  numeric  values  in  cells  B23  and E75, as in the
       previous example, and the background color to be either  red  or  blue,
       depending on whether the numeric value in cell D5 is odd or even.

       Note that although a color expression may contain any function which is
       valid in any other numeric expression, the @myrow and @mycol  functions
       will  always  evaluate to 0.  This is because a color expression is not
       tied to any particular cell, but is instead  evaluated  once,  and  the
       result used for all cells defined to use that color.

       Also  note  that  if  a color expression results in an error, the color
       will default to black text on a black background.  If color  1  results
       in  an error, color will be disabled so that you can see the input line
       to correct the error, after which  color  will  need  to  be  reenabled
       manually.

       Default  colors  are  in effect for all colors until defined otherwise.
       These default colors are as follows:

               color 1 = @white;@blue
               color 2 = @red;@blue
               color 3 = @white;@red
               color 4 = @black;@yellow
               color 5 = @black;@cyan
               color 6 = @red;@cyan
               color 7 = @white;@black
               color 8 = @red;@black

   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
              summaries 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, although it may not
              be completely up-to-date.

       !      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.

       ~      Abbreviations.   You may set abbreviations to speed up the entry
              of repetitive data.  Abbreviations work much like  abbreviations
              in  vi,  except  that  when  defining  an abbreviation, both the
              abbreviation and the expanded  text  must  be  contained  within
              quotes,  separated  by  a  single space.  If more than one space
              separates the abbreviation from the expanded text,  it  will  be
              included as part of the expanded text.

              There  are three types of abbreviations available in sc.  In the
              first type, all characters must be either alphanumeric or ``_''.
              In  the  second type, the last character must be alphanumeric or
              ``_'', but all other characters  must  not  be  alphanumeric  or
              ``_''.   Neither  type  may  contain  spaces.  The third type of
              abbreviation is a single character, and must be alphanumeric  or
              ``_''.

              When  using  abbreviations,  the  first  type  must  be  at  the
              beginning of the line, or must  be  preceded  by  any  character
              which  is not alphanumeric or ``_''.  The second type must be at
              the beginning of the line, or must  be  preceded  either  by  an
              alphanumeric  character,  ``_'',  or  a space.  Single character
              abbreviations must be at the beginning of the line  or  preceded
              by a space.

              Abbreviations  will  be  automatically  expanded  as soon as the
              space bar or return key is pressed, or when pressing the ESC key
              at  the end of the abbreviation to switch to edit mode.  You can
              also force an abbreviation to be expanded by following it with a
              ^], which won't be inserted into the line.  If you don't want an
              abbreviation to be expanded, you must either press ^V  twice  or
              switch  to  edit  mode  and  back  again  somewhere  within  the
              abbreviation (pressing ^V twice also has the effect of switching
              to navigate mode and back again).

              If  the  string  in the abbreviation command contains no spaces,
              the  entire  string  will  be  looked  up   in   the   list   of
              abbreviations, and if found, the definition will be displayed in
              the form of the original abbreviation command used to define it.
              When  looking  up  an  abbreviation  in  this manner, be sure to
              disable abbreviation  expansion,  as  described  above,  or  the
              results may not be what you expect.

              If  the  string  is empty, a list of all abbreviations and their
              corresponding expanded text will be output to your pager.   Note
              that  abbreviations  are  not  saved with the file.  This allows
              each user to create his own file  of  abbreviations  and  either
              merge them in or include them in his own .scrc file, rather than
              force all users who access a  file  to  use  the  same  list  of
              abbreviations.

       ^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
              provide 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
              highlighted  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.

   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,
       parenthesized  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.  The @sum, @prod, @avg,  @count,
       @max,  @min, and @stddev functions may take an optional second argument
       which is an expression that is to be evaluated for  each  cell  in  the
       specified  range  to  determine which cells to include in the function.
       Only those cells for which the expression evaluates to true  (non-zero)
       will  be  used  in  calculating  the  value  of  the  function.  Before
       evaluation for each cell, the expression is first converted  as  if  it
       was  being  copied  from  the cell in the upper left-hand corner of the
       range into the cell  under  consideration,  with  all  cell  references
       adjusted  accordingly.  Because the parts of the expression that should
       remain fixed during the evaluation of the function may not  necessarily
       be  the  same  as those which should remain fixed during an actual copy
       operation, the rules  for  adjusting  cell  references  during  a  copy
       operation  are  slightly  different  than normal.  In particular, these
       rules differ in two different ways.

       The first difference is that the @fixed operator is  ignored  during  a
       copy  operation  unless it is enclosed in parentheses.  This is so that
       selected cells whose addresses should remain  fixed  during  any  given
       evaluation  of  a  range  function can be adjusted relative to the cell
       containing the range function  when  copied  (the  $  prefix  is  still
       honored  for  these cells when copying).  Enclosing the @fixed operator
       in parentheses will have the opposite effect.  That is, it  will  cause
       cell  references  to  be fixed while copying, while allowing them to be
       adjusted when the  function  is  being  evaluated,  subject  to  any  $
       prefixes  present.  Note that only the @fixed operator itself should be
       enclosed in parentheses for this to work properly.

       The second difference is that any references  in  the  expression  that
       refer to cells in the range in the first argument of the range function
       will have any $ prefixes ignored, and the references  will  be  treated
       instead  as  if  they  had  the same $ prefixes as the left side of the
       range argument.  For example, if the left side of  the  range  argument
       (the  cell  address on the left side of the colon) has a fixed row, but
       does not have a fixed column, any cell references that refer  to  cells
       in  that  range  will  also have a fixed row, but will not have a fixed
       column.  This is so that if the range  reference  moves  when  copying,
       references to any cells in that range will also move accordingly.

       Note  that the test expression will be evaluated once for every cell in
       the range, which means that excessive use of these functions  with  the
       optional test expression, or the use of overly complex test expressions
       or with very large ranges can greatly slow down the recalculation of  a
       spreadsheet,  and  may require turning off autocalc for speed, and then
       manually recalculating with the @ command.

       @sum(r)
       @sum(r,e)         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.   The
                         optional  second  argument is an expression which can
                         be used to determine which cells in the range to  sum
                         (see above).

       @prod(r)
       @prod(r,e)        Multiply together all valid (nonblank) entries in the
                         specified region.  The optional second argument is an
                         expression which can be used to determine which cells
                         in the range to multiply (see above).

       @avg(r)
       @avg(r,e)         Average all valid (nonblank) entries in the specified
                         region.    The   optional   second   argument  is  an
                         expression which can be used to determine which cells
                         in the range to average (see above).

       @count(r)
       @count(r,e)       Count  all  valid (nonblank) entries in the specified
                         region.   The  optional   second   argument   is   an
                         expression which can be used to determine which cells
                         in the range to count (see above).

       @max(r)
       @max(r,e)         Return the maximum value  in  the  specified  region.
                         The  optional  second argument is an expression which
                         can be used to exclude specific cells  in  the  range
                         when determining this maximum value (see above).  See
                         also the multi argument version of @max below.

       @min(r)
       @min(r,e)         Return the minimum value  in  the  specified  region.
                         The  optional  second argument is an expression which
                         can be used to exclude specific cells  in  the  range
                         when determining this minimum value (see above).  See
                         also the multi argument version of @min below.

       @stddev(r)
       @stddev(r,e)      Return the sample standard deviation of the cells  in
                         the  specified  region.  The optional second argument
                         is  an  expression  which  can  be  used  to  exclude
                         specific  cells  in  the  range  when calculating the
                         standard deviation (see above).

       @rows(r)          Return the number of rows in the specified range.

       @cols(r)          Return the number of columns in the specified range.

       @lookup(e,r)
       @lookup(r,e)
       @lookup(se,r)
       @lookup(r,se)     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
                         expression  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 returned 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(r,e,n)
       @hlookup(se,r,n)
       @hlookup(r,se,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
                         numeric 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
                         expression,  the  string portions of the cells in the
                         row are searched for  an  exact  string  match.   The
                         value  returned  is  the  numeric value from the same
                         column n rows below the match.

       @vlookup(e,r,n)
       @vlookup(r,e,n)
       @vlookup(se,r,n)
       @vlookup(r,se,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(e1,r)
       @index(r,e1)
       @index(r,e1,e2)   Use  the values of expressions e1 and (optionally) e2
                         to index into the range r.  The numeric value at that
                         position  is returned.  With two arguments, the range
                         should be either a single row or a single column.  An
                         expression with the value 1 selects the first item in
                         the range, 2 selects  the  second  item,  etc.   With
                         three  arguments,  the range must come first, and the
                         second and third arguments will then  be  interpreted
                         as  row and column, respectively, for indexing into a
                         two-dimensional table.

       @stindex(e1,r)
       @stindex(r,e1)
       @stindex(r,e1,e2) Use the values of expressions e1 and (optionally)  e2
                         to  index into the range r.  The string value at that
                         position is returned.  With two arguments, the  range
                         should be either a single row or a single column.  An
                         expression with the value 1 selects the first item in
                         the  range,  2  selects  the  second item, etc.  With
                         three arguments, the range must come first,  and  the
                         second  and  third arguments will then be interpreted
                         as row and column, respectively, for indexing into  a
                         two-dimensional table.

   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: *.5 will be
                         rounded   up  to  the  next  integer;  doing  a  'set
                         rndtoeven' will cause it to be rounded to the closest
                         even  number instead (aka banker's round).  Round-to-
                         even has advantages over  the  default  rounding  for
                         some   applications.   For  example,  if  X+Y  is  an
                         integer, then X+Y = rnd(X)+rnd(Y) with round-to-even,
                         but  not  always with the defaulting rounding method.
                         This could be an advantage, for example, when  trying
                         to  split  an  odd amount of money evenly between two
                         people (it would determine who gets the extra penny).

       @round(e,n)       Round e to n decimal places.  n may  be  positive  to
                         round  off  the right side of the decimal or 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               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
                         assure 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.

       @err              Force an error.  This will force the expression which
                         contains it to result in an error.

   String Expressions
       String  expressions  are  made  up  of  constant  strings   (characters
       surrounded  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

       @filename(e)      Return  the  current  default  filename, as specified
                         when the file was first loaded or created, or  during
                         the last save, with the Put command.  If e is 0, only
                         the actual filename will be returned, with  any  path
                         removed.  If non-zero, the full path specified on the
                         command line or in the last Get or Put  command  will
                         be  returned.  If the path begins with ``~'', it will
                         be expanded to the appropriate users home directory.

       @substr(se,e1,e2) Extract and return  from  string  expression  se  the
                         substring  indexed  by  character  number  e1 through
                         character 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, 8)

                         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(se)
       @lower(se)        will case the string expression to upper or lower.

       @capital(se)      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).

       @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
                         expression  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  output,  or  output  to  standard  error,
                         messes up the screen.  @ext() returns a  null  string
                         and   prints   an  appropriate  warning  if  external
                         functions are disabled, 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
                         disabled  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  build a command line (including
                         more argument values) from a string  expression  with
                         concatenation.    You  can  also  "hide"  the  second
                         argument 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
       spreadsheets 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 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
                         ordinary  annuity  of 36 monthly payments of $1000 at
                         18% annual interest.  It answers the  question:  "How
                         much  can  I borrow at 18% for 3 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
       the  beginning  of  1970.   All  date and time functions except @date()
       return numbers, not strings.

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

       @dts(e1,e2,e3)    Convert a date to the  number  of  seconds  from  the
                         epoch  to  the  first  second  of the specified date,
                         local time.  Dates may be specified in either (m,d,y)
                         or  (y,m,d) format, although the latter is preferred,
                         since it's more universally recognized (m,d,y is only
                         used  in  America).   If  e2  >  12  or e3 > 31, then
                         (m,d,y) is assumed.  Otherwise, (y,m,d)  is  assumed.
                         For example, @date(@dts(1976,12,14)) yields

                              Tue Dec 14 00:00:00 1976

                         The  month should range from  1 to 12; the day should
                         range from 1 to the number of days in  the  specified
                         month;  and the year should include the century (e.g.
                         1999 instead of  99).   Any  date  capable  of  being
                         handled by the system is valid, typically 14 Dec 1901
                         to 18 Jan 2038 on a system that uses a 32 bit time_t.
                         Invalid  dates  or  dates  outside of this range will
                         return ERROR.  For rapid entry of  dates  using  only
                         the  numeric keypad, sc provides the alternate syntax
                         y.m.d or m.d.y, which is automatically  converted  to
                         the @dts(...) format above.  The year, month, and day
                         must be entered numerically in the alternate  syntax;
                         formulas are not allowed.

       @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
                         seconds 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)
       @date(e,se)       Convert the time in seconds to a date string.  With a
                         single   numeric   argument,  the  date  will  be  24
                         characters 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().   A format string compatible
                         with the strftime() function may optionally be  given
                         as  a second argument to override the default format.
                         See the strftime(3) man page for details.

       @year(e)          Return  the  year.   Valid  years  begin  with  1970,
                         although many systems will return years prior to 1970
                         if e is negative.  The  last  legal  year  is  system
                         dependent.

       @month(e)         Return  the  month,  encoded  as  1  (January)  to 12
                         (December).

       @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.

   Programmable Function Keys
       Function  keys  can  be  used in sc if your terminal supports them, and
       they are programmable.  To program the function keys, you use the  fkey
       command.   This command may be used in a .scrc file or a macro file, or
       it may be entered directly into sc's command  line.   Defined  function
       keys  will  be  saved with the file.  There is no shortcut, as there is
       with most commands, so the full command must  be  typed  in.   Pressing
       enter  when not editing a line will start you off with a blank line for
       this purpose.  The format of the fkey command is:

              fkey n = "command"

       where n is the function key number (n = 1 for F1, n = 2 for F2,  etc.),
       and command is the command to be run.  For example,

              fkey 2 = "merge \"|~/scmacros/macro1\""

       will run the macro called macro1 located in a subdirectory of your home
       directory called scmacros when  the  F2  key  is  pressed.   Note  that
       embedded quotes must be escaped by a backslash.  If you want to include
       the cell address of the current cell in the command line, you may do so
       by entering ``$$'' in its place in the command.  For example,

              fkey 5 = "fmt $$ \"^D%A\""

       will  cause  the  F5 key to format the current cell to display the full
       weekday name of the numeric date value stored there.  The ^D is a CTRL-
       D character, which denotes a date format.

       Although  it  may  be  overridden  by  the  fkey command, the F1 key is
       predefined by default to  execute  man  sc.   Unlike  the  user-defined
       function keys, this definition will also work in edit, insert, replace,
       and navigate modes.

       To undefine a function key, merely define it as the empty string  ("").
       Undefining the F1 key will restore the default behavior.

   Plugins
       There  are three ways in which external programs can be used as plugins
       with sc.  First, they can be used as external commands.  When  used  as
       an  external command, any command not recognized by sc will be searched
       for first in $HOME/.sc/plugins, and then in  /usr/share/doc/sc/plugins.
       If  found,  it  will be run with its standard input and standard output
       redirected back to sc.  These are used to send commands to, and receive
       responses back from sc in the same way that advanced macros do.

       The  second and third ways that programs can be used as plugins with sc
       are to automatically convert files to and from sc format based on their
       extensions.  In order to use them in this way, you must first associate
       a given extension to a corresponding plugin (for  reading)  or  plugout
       (for  writing)  using  the plugin and plugout commands.  These commands
       should be placed in your .scrc file, and have the following syntax:

              plugin "ext" = "programname"

       or

              plugout "ext" = "programname"

       where ext is the extension and programname is the name  of  the  plugin
       program  to  be used for filenames with that extension.  For input, the
       plugin merely reads the specified file, performs whatever conversion is
       necessary,  and  writes  the  resulting  data  to standard output.  For
       output, the plugin writes sc commands to standard output and reads  the
       replies  from  standard  input  in  the same way that an advanced macro
       would, and then converts the data to the appropriate format and  writes
       it to a file with the specified filename.

FILES

       /usr/share/doc/sc/tutorial.sc Tutorial spreadsheet.

       $HOME/.scrc                   Initialization commands.

       ./.scrc                       More initialization commands.

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
       relaxation should be implemented.

       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
       originally authored by James Gosling,  and  subsequently  modified  and
       posted  to  USENET  by  Mark Weiser under the name vc.  The program was
       subsequently renamed sc, and further modified by numerous contributors,
       Jeff  Buhrt  of  Proslink,  Inc.  and Robert Bond of Sequent, prominent
       among   them.     The    current    maintainer    is    Chuck    Martin
       (nrocinu@myrealbox.com).

       Other contributors include: 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  Ditchfield,  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,  Michael  Lapsley,  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
       Wilson.