      K                                                             XSPREAD 3.0 (1)       	      NAME *           xspread - spreadsheet calculator  
      SYNOPSIS L           xspread [ -c ] [ -m ] [ -n ] [ -r ] [ -x ] [ -N ] [ _f_i_l_e ]        DESCRIPTIONY           The spreadsheet calculator _x_s_p_r_e_a_d is based on rectangular tables J           much like a financial spreadsheet.  When invoked it presents youJ           with a table organized as rows and columns of cells.  If invokedS           without a _f_i_l_e argument, the table is initially empty.  Otherwise X           _f_i_l_e is read in (see the _G_e_t command below).  Each cell may haveG           associated with it a numeric value, a label string, and/or an J           expression (formula) which evaluates to a numeric value or label3           string, often based on other cell values.   3           For a on-line tutorial, type the command:   "                xspread tutorial.sc  <           To print a quick reference card, type the command:  3                xspreadqref | [your_printer_command]         OPTIONS  E           -c   Start the program with the recalculation being done in                 column order.  G           -m   Start the program with automatic recalculation disabled. G                The spreadsheet will be recalculated only when the ``@''                 command is used.   I           -n   Start the program in quick numeric entry mode (see below).   I           -r   Start the program with the recalculation being done in row &                order (default option).  T           -x   Cause the _G_e_t and _P_u_t commands (see below) to encrypt and"                decrypt data files.  G           -N   This flag allows you to turn the arror cursor on or off. I                Normally the cursor is on, but this flag will change it to                 the opposite.  E           -R   Start the program with automatic newline action set to -                increment the row (see below).   E           -C   Start the program with automatic newline action set to 0                increment the column (see below).  L           All of these options can be changed with the ^_T and _S commandsU           (see below) while _x_s_p_r_e_a_d is running.  Options specified when     K                                                                           1                   XSPREAD 3.0 (1)    S           _x_s_p_r_e_a_d is invoked override options saved in the data file.              General Information   G           The screen is divided into four regions.  The top line is for K           entering commands and displaying cell values.  The second line is U           for messages from _x_s_p_r_e_a_d.  The third line and the first four I           columns show the column and row numbers, from which are derived M           cell addresses, e.g.  _A_0 for the cell in column A, row 0.  Note Q           that column names are case-insensitive: you can enter _A_0 or _a_0.   K           The rest of the screen forms a window looking at a portion of the I           table.  The total number of display rows and columns available, I           hence the number of table rows and columns displayed, is set by V           _c_u_r_s_e_s(3) and may be overridden by setting the LINES and COLUMNS.           environment variables, respectively.  C           The screen has two cursors: a cell cursor, indicated by a J           highlighted cell and a ``<'' on the screen, and a character cur-I           sor, indicated by the terminal's hardware cursor.  The cell and J           character cursors are often the same.  They differ when you type$           a command on the top line.  K           If a cell's numeric value is wider than the column width (see the M           _f command), the cell is filled with asterisks.  If a cell's label G           string is wider than the column width, it is truncated at the >           start of the next non-blank cell in the row, if any.  I           Cursor control commands and row and column commands can be pre- H           fixed by a numeric argument which indicates how many times theM           command is to be executed.  You can type ^_U before a repeat count J           if quick numeric entry mode is enabled or if the number is to be@           entered while the character cursor is on the top line.  K           Commands which use the terminal's control key, such as ^_N, work E           both when a command is being typed and when in normal mode.              Changing Options    M           ^T_o  Toggle options.  This command allows you to switch the state M                of one option selected by _o.  A small menu lists the choices O                for _o when you type ^_T.  The options selected are saved when H                the data and formulas are saved so that you will have the>                same setup next time you enter the spreadsheet.  G                a Automatic Recalculation.  When set, each change in the K                  spreadsheet causes the entire spreadsheet be recalculated. D                  Normally this is not noticeable, but for very largeK                  spreadsheets, it may be faster to clear automatic recalcu- J                  lation mode and update the spreadsheet via explicit ``@''B                  commands.  Default is automatic recalculation on.  I                c Current cell highlighting.  If enabled, the current cell           2            K                                                             XSPREAD 3.0 (1)     G                  is highlighted (using the terminal's standout mode, if K                  available) in addition to being marked by the cell cursor.   F                e External function execution.  When disabled, externalQ                  functions (see @_e_x_t() below) are not called.  This saves a K                  lot of time at each screen update.  External functions are J                  disabled by default.  If disabled, and external functionsF                  are used anywhere, a warning is printed each time theO                  screen is updated, and the result of @_e_x_t() is the value B                  from the previous call, if any, or a null string.  I                l Autolabeling.  If enabled, using the define command (/d) I                  causes a label to be automatically generated in the cell K                  to the left of the defined cell.  This is only done if the @                  cell to the left is empty.  Default is enabled.  K                n Quick numeric entry.  If enabled, a typed digit is assumed I                  to be the start of a numeric value for the current cell, I                  not a repeat count, unless preceded by ^_U.  The cursor R                  controls (^_P, ^_N, ^_B, ^_F) in this mode will end a numeric                  entry.   I                t Top line display.  If enabled, the name and value of the K                  current cell is displayed on the top line.  If there is an K                  associated label string, the first character of the string H                  value is ``|'' for a centered string, ``<'' for a left-K                  string or ``>'' for a rightstring (see below), followed by Z                  "_s_t_r_i_n_g" for a constant string or {_e_x_p_r} for a stringF                  expression.  A constant string may be preceded with aK                  backslash (`\').  In this case the constant string will be K                  used as a ``wheel'' to fill a column, e.g. "\-" for a line H                  in a column, and "\Yeh " for "Yeh Yeh Ye".  If the cellU                  has a numeric value, it follows as [_v_a_l_u_e], which may be a (                  constant or expression.  0                x Encryption.  See the -x option.  I                $ Dollar prescale.  If enabled, all numeric constants (not K                  expressions) which you enter are multiplied by 0.01 so you I                  don't have to keep typing the decimal point if you enter (                  lots of dollar figures.  J                r Newline action.  This option toggles between three cases.H                  The default is no action.  If this option is used once,J                  after each command which is terminated by a newline char-H                  acter is completed, the current cell will be moved downK                  one row.  If this option is used again, after each command I                  which is terminated by a newline character is completed, J                  the current cell will be moved right one column.  AnotherD                  use of this option will restore the default action.  K                z Set newline action limits.  This option sets limits to thehK                  newline action option above.  When this option is invoked, K                  the row and column of the current cell are remembered.  If     K                                                                           3                   XSPREAD 3.0 (1)    J                  a later newline action would take the current cell to theI                  right of the remembered column, then the current cell isaI                  instead moved to the first column of the next row.  If atE                  newline action would take the current cell below thetJ                  remembered row, then the current cell is instead moved to0                  the top row of the next column.  F                The quick numeric entry, newline action and set newlineH                action limits options can be combined to allow very quickE                entry of large amounts of data.  If all the data to belJ                entered is in a single row or column then setting the quickJ                numeric entry and the appropriate newline action will allowI                the numbers to be entered without any explicit commands toN;                position the current cell or enter a number.   I                If the data entry involves several entries in each row for K                many rows, then setting the quick numeric entry option, set- I                ting the newline action to move right after each entry and F                setting the newline action limits on the last column onJ                which data should be entered will allow the data to enteredK                quickly.  If necessary, columns which do not need data to be J                entered can be hidden with the z command.  Similar arrange-J                ments can be made for entering several rows of data in each                column.  C           S    Set options.  This command allows you to set variousiF                options.  A small menu lists the options that cannot be*                changed through ^_T above.                  byrows/bycolsH                  Specify the order cell evaluation when updating.  TheseH                  options also affect the order in which cells are filledL                  (see /_f) and whether a row or column is cleared by an _x                  command.                   iterations=_neK                  Set the maximum number of recalculations before the screenn\                  is displayed again. _I_t_e_r_a_t_i_o_n_s is set to 10 by default.                  tblstyle=_srF                  Control the output of the _T command.  _s can be: 0Q                  (default) to give colon delimited fields, with no _t_b_l con-mE                  trol lines; tbl to give colon delimited fields, with T                  _t_b_l(1) control lines; latex to give a _L_a_T_e_X tabularx                  environment; slatex to give a _S_L_a_T_e_X (_S_c_a_n_d_i_n_a_v_i_a_n _L_a_T_e_X)K                  tabular environment; tex to give a _T_e_X simple tabbedtK                  alignment with ampersands as delimiters; and frame to giveh2                  a tblstyle output for FrameMaker.  [                Other _S_e_t options are normally used only in _x_s_p_r_e_a_d datatM                files since they are available through ^_T.  You can also use.!                them interactivelyd  !                autocalc/!autocalcp          4            K                                                             XSPREAD 3.0 (1)t    6                     Set/clear auto recalculation mode.                  numeric/!numeric +                     Set/clear numeric mode.   !                prescale/!prescalei4                     Set/clear numeric prescale mode.                  extfun/!extfun^6                     Enable/disable external functions.                  cellcur/!cellcur =                     Set/clear current cell highlighting mode.s                  toprow/!toprow 3                     Set/clear top row display mode.   '                rndinfinity/!rndinfinity K                     default: round-to-even (banker's round), *.5 will round I                     to the closest even number; doing a 'set rndinfinity' F                     will round *.5 up to the next integer (rounding to                     infinity).                  craction=_n L                     Set the newline action.  _n can be: 0 (default) to giveG                     no action; 1 to move down after each entry; or 2 to 0                     move right after each entry.                  rowlimit=_n F                     Set the remembered limit for the maximum row belowJ                     which the current cell will be moved to the top of theH                     next column if the newline action is set to move theJ                     current cell down.  _n can be -1 (default) to disable"                     this facility.                  collimit=_naJ                     Set the remembered limit for the maximum column to theH                     right of which the current cell will be moved to theH                     left of the next row if the newline action is set toL                     move the current cell right.  _n can be -1 (default) to*                     disable this facility.  !           Cursor Control Commandsa    ;           ^P   Move the cell cursor up to the previous row.   9           ^N   Move the cell cursor down to the next row.s  8           ^B   Move the cell cursor backward one column.  7           ^F   Move the cell cursor forward one column.n             h, j, k, l    K                                                                           5                   XSPREAD 3.0 (1)    H                If the character cursor is not on the top line, these areM                alternate, _v_i-compatible cell cursor controls (left, down,e9                up, right).  Space is just like l (right).t             H, J, K, LI                If the character cursor is not on the top line, these move @                the cursor by half pages (left, down, up, right).  J           ^H   If the character cursor is not on the top line, ^_H is the                same as ^_B.             SPACE H                If the character cursor is not on the top line, the space'                bar is the same as ^_F.   G           TAB  If the character cursor is on the top line, TAB starts ahE                range (see below).  Otherwise, it is the same as ^_F.              Arrow KeysI                The terminal's arrow keys provide another alternate set of J                cell cursor controls if they exist and are supported in theW                appropriate _t_e_r_m_c_a_p entry.  Some terminals have arrow keyseK                which conflict with other control key codes.  For example, anK                terminal might send ^_H when the back arrow key is pressed.fJ                In these cases, the conflicting arrow key performs the same9                function as the key combination it mimics.a  F           ^    Move the cell cursor up to row 0 of the current column.  E           #    Move the cell cursor down to the last valid row of the                 current column.  G           0    Move the cell cursor backward to column A of the current M                row.  This command must be prefixed with ^_U if quick numericd%                entry mode is enabled.   K           $    Move the cell cursor forward to the last valid column of theo                current row.   K           b    Scan the cursor backward (left and up) to the previous valid                 cell.  I           w    Scan the cursor forward (right and down) to the next valide                cell.  O           ^E_d  Go to end of range.  Follow ^_E by a direction indicator sucheN                as ^_P or _j.  If the cell cursor starts on a non-blank cell,J                it goes in the indicated direction until the last non-blankI                adjacent cell.  If the cell cursor starts on a blank cell,oK                it goes in the indicated direction until the first non-blank F                cell.  This command is useful when specifying ranges ofG                adjacent cells (see below), especially when the range ise.                bigger than the visible window.            6            K                                                             XSPREAD 3.0 (1)     X           g    Go to a cell.  _x_s_p_r_e_a_d prompts for a cell's name, a regularI                expression surrounded by quotes, or a number.  If a cell's O                name such as _a_e_1_2_2 or a the name of a defined range isaG                given, the cell cursor goes directly to that cell.  If a ^                quoted regular expression such as " _T_a_x _T_a_b_l_e " or " ^_J_a_n]                [_0-_9]*$ " is given, _x_s_p_r_e_a_d searches for a cell containing aoS                string matching the regular expression.  See _r_e_g_e_x(_3) or.O                _e_d(_1) for more details on the form of regular expressions.nV                If a number is given, _x_s_p_r_e_a_d will search for a cell con-K                taining that number.  Searches for either strings or numberssI                proceed forward from the current cell, wrapping back to a0 I                at the end of the table, and terminate at the current cell J                if the string or number is not found.  You may also go to aG                cell with an ERROR (divide by zero, etc in this cell) or T                INVALID (references a cell containing an ERROR).  _g _e_r_r_o_r[                will take you to the next ERROR, while _g _i_n_v_a_l_i_d take you tosK                the next invalid.  The last _g command is saved, and can bed=                re-issued by entering _g<_r_e_t_u_r_n>.c  )           Cell Entry and Editing Commandsi  D           Cells can contain both a numeric value and a string value.J           Either value can be the result of an expression, but not both atK           once, i.e. each cell can have only one expression associated with K           it.  Entering a valid numeric expression alters the cell's previ-wE           ous numeric value, if any, and replaces the cell's previous I           string expression, if any, leaving only the previously computedlK           constant label string.  Likewise, entering a valid string expres-iG           sion alters the cell's the previous label string, if any, andeJ           replaces the cell's previous numeric expression, if any, leaving>           only the previously computed constant numeric value.  F           =    Enter a numeric constant or expression into the currentW                cell.  _x_s_p_r_e_a_d prompts for the expression on the top line. E                The usual way to enter a number into a cell is to type H                ``='', then enter the number in response to the prompt onE                the top line.  The quick numeric entry option, enabled_K                through the -n option or ^_T command, shows the prompt whenrI                you enter the first digit of a number (you can skip typingn                ``='').  G           <    Enter a label string into the current cell to be flushede6                left against the left edge of the cell.  K           "    Enter a label string into the current cell to be centered in                 the column.  G           >    Enter a label string into the current cell to be flushedt8                right against the right edge of the cell.  H           F    Enter a format string into the current cell.  This formatK                string overrides the precision specified with the ``f'' com-iJ                mand.  The format only applies to numeric values.  The fol-F                lowing characters can be used to build a format string:    K                                                                           7.                  XSPREAD 3.0 (1)      F                # Digit placeholder.  If the number has fewer digits onK                  either side of the decimal point than  there are `#' char- C                  acters in the format, the extra `#' characters arelG                  ignored.  The number is rounded to the number of digitoF                  placeholders as there are to the right of the decimalJ                  point.  If there are more digits in the number than thereG                  are digit placeholders on the left side of the decimall8                  point, then those digits are displayed.  K                0 Digit placeholder.  Same as for `#' except that the number K                  is padded with zeroes on either side of the decimal point. J                  The number of zeroes used in padding is determined by theI                  number of digit placeholders after the `0' for digits on H                  the left side of the decimal point and by the number ofJ                  digit placeholders before the `0' for digits on the right+                  side of the decimal point.  I                . Decimal point.  Determines how many digits are placed oneE                  the right and left sides of the decimal point in thetJ                  number.  Note that numbers smaller than 1 will begin withK                  a decimal point if the left side of the decimal point con-oK                  tains only a `#' digit placeholder.  Use a `0' placeholdera:                  to get a leading zero in decimal formats.  G                % Percentage.  For each `%' character in the format, the K                  actual number gets multiplied by 100 (only for purposes ofvJ                  formatting -- the original number is left unmodified) andJ                  the `%' character is placed in the same position as it is                  in the format.   J                , Thousands separator.  The presence of a `,' in the formatK                  (multiple commas are treated as one) will cause the number H                  to be formatted with a `,' separating each set of threeH                  digits in the integer part of the number with numbering=                  beginning from the right end of the integer.,  G                \ Quote.  This character causes the next character to be^I                  inserted into the formatted string directly with no spe- %                  cial interpretation.t                  E- E+ e- e+F                  Scientific format.  Causes the number to formatted inJ                  scientific notation.  The case of the `E' or `e' given isG                  preserved.  If the format uses a `+', then the sign iseK                  always given for the exponent value.  If the format uses a I                  `-', then the sign is only given when the exponent valueoI                  is negative.  Note that if there is no digit placeholder J                  following the `+' or `-', then that part of the formattedH                  number is left out.  In general, there should be one or>                  more digit placeholders after the `+' or `-'.  J                ; Format selector.  Use this character to separate the for-J                  mat into two distinct formats.  The format to the left of          8            K                                                             XSPREAD 3.0 (1)     K                  the `;' character will be used if the number given is zero K                  or positive.  The format to the right of the `;' character 9                  is used if the number given is negative.e  G                Some example formats are integer (``0'' or ``#''), fixedrG                (``0.00''), percentage (``0%'' or ``0.00%''), scientificiD                (``0.00E+00''), and currency (``$#,0.00;($#,0.00)'').  E           Strings you enter must start with ".  You can leave off the Y           trailing " and _x_s_p_r_e_a_d will add it for you.  You can also enter a D           string expression by backspacing over the opening " in the           prompt.h  H           e    Edit the value associated with the current cell.  This isI                identical to ``='' except that the command line starts outhH                containing the old numeric value or expression associatedC                with the cell.  The editing in this mode is vi-like.n  &                ^hMove back a character  ;                + Forward through history (neat) (same as j)   <                - Backward through history (neat) (same as k)                  ESC                  Done editingG                  TAB3                  Mark && append a range (ex: A0:A0) K                  TAB, move around within a range; TAB, append range string.                   CRSave  !                $ Goto last columnn  *                . Insert current dot buffer  3                / Search for a string in the history /                  ESC  edit the string you typedT                  CR   search                  ^h   backspace                   0 Goto column 0  &                D Delete to end of line  A                I Insert at column 0; ESC revert back to edit modeo  ;                R Replace mode; ESC revert back to edit moder  ,                X Delete the char to the left  B                a Append after cursor; ESC revert back to edit mode      K                                                                           9                   XSPREAD 3.0 (1)    !                b Move back a word   :                c Change mode; ESC revert back to edit mode                  d Delete ...o                  b    back wordl%                  f    forward (right)                   h    back chars                  l    forwardLI                  t    delete forward up to a given char (next char typed) .                  w    delete next word forward  )                f Find the next char typed   !                h Move left a charc  C                i Insert before cursor; ESC revert back to edit mode_  ;                j Forward through history (neat) (same as +)d  <                k Backward through history (neat) (same as -)  "                l Move right a char                   n Continue search                  q Stop editing.                  r Replace chare                  t Goto a char                  u Undou                  w Forward a wordp  >                x Delete the current char (moving to the right)  I           E    Edit the string associated with the current cell.  This isyJ                identical to ``<'', ``"'', or ``>'' except that the commandI                line starts out containing the old string value or expres-f;                sion associated with the cell.  SEE e ABOVE.p  L           To enter and edit a cell's number part, use the ``='' and _e com-H           mands.  To enter and edit a cell's string part, use the ``<'',L           ``"'', ``>'', and _E commands.  See the sections below on numeric6           and string expressions for more information.  H           x    Clear the current cell.  Deletes the numeric value, labelK                string, and/or numeric or string expression.  You can prefixuF                this command with a count of the number of cells on theJ                current row to clear.  The current column is used if columnK                recalculation order is set.  Cells cleared with this commandEQ                may be recalled with any of the _p_u_l_l commands (see below).s          10g            K                                                             XSPREAD 3.0 (1)d    Q           m    Mark a cell to be used as the source for the _c_o_p_y command.t  J           c    Copy the last marked cell to the current cell, updating rowI                and column references in its numeric or string expression,t                if any.  G           +    If not in numeric mode, add the current numeric argument.H                (default 1) to the value of the current cell.  In numericH                mode, ``+'' introduces a new numeric expression or value,!                the same as ``=''.   I           -    If not in numeric mode, subtract the current numeric argu- G                ment (default 1) from the value of the current cell.  In F                numeric mode, ``-'' introduces a new, negative, numeric/                expression or value, like ``=''.a             RETURNJ                If you are not editing a cell (top line is empty), pressingV                RETURN will make _x_s_p_r_e_a_d enter insert mode. At this pointH                you may type any valid command or press ESC once to edit.             File Commands     I           G    Get a new database from a file.  If encryption is enabled, A                the file is decrypted before it is loaded into thet                spreadsheet.i  F           P    Put the current database into a file.  If encryption isA                enabled, the file is encrypted before it is saved.   G           W    Write a listing of the current database into a file in a D                form that matches its appearance on the screen.  ThisP                differs from the _P_u_t command in that its files are intendedW                to be reloaded with _G_e_t, while _W_r_i_t_e produces a file foraG                people to look at.  Hidden rows or columns are not showneK                when the data is printed.  During the database write processhG                there is automatic file extension.  The default databasefG                extension is ``.asc''.  The extension may be bypassed byl"                command line entry.  E           T    Write a listing of the current database to a file, butPK                include delimiters suitable for processing by the _t_b_l,aW                _L_a_T_e_X, or _T_e_X table processors.  The delimiters are con-e`                trolled by the _t_b_l_s_t_y_l_e option.  See _S_e_t above.  The delim-M                iters are a colon (:) for style _0 or _t_b_l and an amper-nW                sand (&) for style _l_a_t_e_x or _t_e_x.  During the table write F                process there is automatic file extension.  The defaultJ                extensions are as follows, for 0 (default) the extension isI                ``.cln'', for tbl the extension is ``.tbl'', for latex the H                extension is ``.lat'', for tex the extension is ``.tex''.D                All extensions may be bypassed by command line entry.        K                                                                          11                   XSPREAD 3.0 (1)    e           With the _P_u_t, _W_r_i_t_e, and _T_a_b_l_e commands, the optional range argu-fE           ment writes a subset of the spreadsheet to the output file.e  [           With the _W_r_i_t_e and _T_a_b_l_e commands, if you try to write to thetU           last file used with the _G_e_t or _P_u_t commands, or the file speci- X           fied on the command line when _x_s_p_r_e_a_d was invoked, you are askedI           to confirm that the (potentially) dangerous operation is really            what you want.  d           The three output commands, _P_u_t, _W_r_i_t_e, and _T_a_b_l_e, can pipe theirG           (unencrypted only) output to a program.  To use this feature, G           enter ``| program'' to the prompt asking for a filename.  For O           example, to redirect the output of the _W_r_i_t_e command to the 0           printer, you might enter ``| lpr -p''.  F           M    Merge the database from the named file into the currentJ                database.  Values and expressions defined in the named fileK                are read into the current spreadsheet overwriting the exist-r6                ing entries at matching cell locations.  W           R    Run macros.  Since _x_s_p_r_e_a_d files are saved as ASCII files,rG                it is possible to use them as primitive macro definitionwN                files.  The _R_u_n command makes this easier.  It's like theT                _M_e_r_g_e command, but prints a saved path name as the start ofK                the filename to merge in.  The string to use is set with theuV                _D_e_f_i_n_e command.  To write macros, you must be familiar withO                the file format written by the _P_u_t command.  This facility =                is still primitive and could be much improved.i  >           D    Define a path for the _R_u_n command to use.  J           All file operations take a filename as the first argument to theK           prompt on the top line.  The prompt supplies a " to aid in typingCK           in the filename.  The filename can also be obtained from a cell's F           label string or string expression.  In this case, delete theH           leading " with the backspace key and enter a cell name such asQ           _a_2_2 instead.  If the resulting string starts with ``|'', the rest C           of the string is interpreted as a UNIX command, as above.d  !           Row and Column Commands   K           These commands can be used on either rows or columns.  The seconduF           letter of the command is either a row designator (one of theY           characters _r, ^_B, ^_F, _h, _l) or a column designator (one of _c, ^_P,aP           ^_N, _k, _j).  A small menu lists the choices for the second letterH           when you type the first letter of one of these commands.  Com-G           mands which move or copy cells also modify the row and column I           references in affected cell expressions.  The references may be R           frozen by using the _f_i_x_e_d operator or using the $ character in0           the reference to the cell (see below).             ir, icH                Insert a new row (column) by moving the row (column) con-I                taining the cell cursor, and all following rows (columns),           12             K                                                             XSPREAD 3.0 (1)     F                down (right) one row (column).  The new row (column) is                empty.              ar, acJ                Append a new row (column) immediately following the currentH                row (column).  It is initialized as a copy of the current                one.r             dr, dc/                Delete the current row (column).e             pr, pc, pmJ                Pull deleted rows (columns) back into the spreadsheet.  TheI                last deleted set of cells is put back into the spreadsheet O                at the current location.  _p_r inserts enough rows to hold theeM                data.  _p_c inserts enough columns to hold the data.  _p_mtI                (merge) does not insert rows or columns; it overwrites thesC                cells beginning at the current cell cursor location.              vr, vcK                Remove expressions from the affected rows (columns), leavingrI                only the values which were in the cells before the commande                was executed.             zr, zcI                Hide (``zap'') the current row (column).  This keeps a row K                (column) from being displayed but keeps it in the data base.rH                The status of the rows and columns is saved with the dataK                base so hidden rows and columns will be still be hidden whenrJ                you reload the spreadsheet.  Hidden rows or columns are not*                printed by the _W command.             sr, scK                Show hidden rows (columns).  Enter a range of rows (columns) F                to be revealed.  The default is the first range of rowsK                (columns) currently hidden.  This command ignores the repeat                count, if any.   H           f    Set the output format to be used for printing the numericF                values in each cell in the current column.  Enter threeH                numbers: the total width in characters of the column, theI                number of significant digits (digits to follow the decimal.J                point for engineering notation), and the format type.  For-K                mat types are 0 for fixed point (-0.00010), 1 for scientificmK                notation (-1.00E-04), 2 for engineering notation (-100.00u),1K                3 for dates (05/15/92), and 4 for modulo 3 exponent notation'I                (-100.E-06).  Values are rounded off to the least signifi-iD                cant digit displayed.  The total column width affectsI                displays of strings as well as numbers.  A preceding countsH                can be used to affect more than one column.  This command<                has only a column version (no second letter).             @myrow, @mycolI                Are functions that return the row or column of the current     K                                                                          13s                  XSPREAD 3.0 (1)    H                cell respectively.  ex: The cell directly above a cell inJ                the D column could then be accessed by @nval("d",@myrow-1).J                NOTE: @myrow and @mycol can't be used in specifying ranges.             Range Commands  D           Range operations affect a rectangular region on the screenH           defined by the upper left and lower right cells in the region.J           All of the commands in this class start with a slash; the secondF           letter of the command indicates which command.  A small menuF           lists the choices for the second letter when you type ``/''.X           _x_s_p_r_e_a_d prompts for needed parameters for each command.  PhrasesG           surrounded by square brackets in the prompt are informationalW8           only and may be erased with the backspace key.  K           Prompts requesting variable names may be satisfied with either an Q           explicit variable name, such as _A_1_0, or with a variable name pre-eL           viously defined in a /_d command (see below).  Range name promptsW           require either an explicit range such as _A_1_0:_B_2_0, or a range name K           previously defined with a /_d command.  A default range shown inDK           the second line is used if you omit the range from the command oriJ           press the TAB key (see below).  The default range can be changedO           by moving the cell cursor via the control commands (^_P, ^_N, ^_B, F           ^_F) or the arrow keys.  The cells in the default range areI           highlighted (using the terminal's standout mode, if available).   E           /x   Clear a range.  Cells cleared with this command may be >                recalled with any of the _p_u_l_l commands.  H           /v   Values only.  This command removes the expressions from aJ                range of cells, leaving just the values of the expressions.  J           /c   Copy a source range to a destination range.  The source andH                destination may be different sizes.  The result is alwaysI                one or more full copies of the source.  Copying a row to amG                row yields a row.  Copying a column to a column yields a J                column.  Copying a range to anything yields a range.  Copy-H                ing a row to a column or a column to a row yields a rangeJ                with as many copies of the source as there are cells in theI                destination.  This command can be used to duplicate a celloG                through an arbitrary range by making the source a singlet6                cell range such as _b_2_0:_b_2_0.  F           /f   Fill a range with constant values starting with a givenF                value and increasing by a given increment.  Each row isJ                filled before moving on to the next row if row order recal-F                culation is set.  Column order fills each column in theH                range before moving on to the next column.  The start andJ                increment numbers may be positive or negative.  To fill allD                cells with the same value, give an increment of zero.  J           /d   Use this command to assign a symbolic name to a single cellJ                or a rectangular range of cells on the screen.  The parame-G                ters are the name, surrounded by "", and either a single           14D            K                                                             XSPREAD 3.0 (1)f    V                cell name such as _A_1_0 or a range such as _a_1:_b_2_0.  NamesH                defined in this fashion are used by the program in futureJ                prompts, may be entered in response to prompts requesting aH                cell or range name, and are saved when the spreadsheet isQ                saved with the _P_u_t command.  Names defined must be more thaneE                two alpha characters long to differentiate them from a K                column names, and must not have embedded special characters.rK                Names may include the character ``_'' or numerals as long astA                they occur after the first three alpha characters.a  F           /l   Use this command to lock the current cell or a range ofK                cells, i.e make them immune to any type of editing. A locked D                cell can't be changed in anyway until it is unlocked.  H           /U   This command is the opposite of the /_l command and thus;                unlocks a locked cell and makes it editable.t  E           /s   This command lists (shows) the currently defined rangerJ                names.  If there are no defined range names, then a messageY                is given, otherwise it pipes output to _s_o_r_t, then to _l_e_s_s.eJ                If the environment variable PAGER is set, its value is used(                in place of _l_e_s_s.  F           /u   Use this command to undefine a previously defined range                name.  H           /F   Use this command to assign a value format string (see the=                ``F'' cell entry command) to a range of cells.               Miscellaneous Commands               QS           q W           ^C   Exit from _x_s_p_r_e_a_d.  If you made any changes since the last e                _G_e_t or _P_u_t, _x_s_p_r_e_a_d asks about saving your data before exit-e                ing.w             ^G2           ESC  Abort entry of the current command.  J           ?    Enter an interactive help facility.  Lets you look up briefG                summaries of the main features of the program.  The help I                facility is structured like this manual page so it is easy >                to find more information on a particular topic.  W           !    Shell escape.  _x_s_p_r_e_a_d prompts for a shell command to run.oI                End the command line with the RETURN key.  If the environ-wJ                ment variable SHELL is defined, that shell is run.  If not,F                /bin/sh is used.  Giving a null command line starts theJ                shell in interactive mode.  A second ``!'' repeats the pre-                vious command.s  !           ^L   Redraw the screen.w    K                                                                          15c                  XSPREAD 3.0 (1)    I           ^R   Redraw the screen with special highlighting of cells to be H                filled in.  This is useful for finding values you need toI                provide or update in a form with which you aren't familiar :                or of which you have forgotten the details.  J                It's also useful for checking a form you are creating.  AllJ                cells which contain constant numeric values (not the resultJ                of a numeric expression) are highlighted temporarily, untilJ                the next screen change, however minor.  To avoid ambiguity,B                the current range (if any) and current cell are not                highlighted.m  J           ^X   This command is similar to ^_R, but highlights cells whichI                have expressions.  It also displays the expressions in the H                highlighted cells as left-flushed strings, instead of theH                numeric values and/or label strings of those cells.  ThisJ                command makes it easier to check expressions, at least whenI                they fit in their cells or the following cell(s) are blank0I                so the expressions can slop over (like label strings).  IntH                the latter case, the slop over is not cleared on the nextL                screen update, so you may want to type ^_L after the ^_X in,                order to clean up the screen.  ,           @    Recalculates the spreadsheet.  K           ^V   Type, in the command line, the name of the current cell (thelE                one at the cell cursor).  This is useful when entering C                expressions which refer to other cells in the table.   H           ^W   Type, in the command line, the expression attached to theD                current cell.  If there is none, the result is ``?''.  J           ^A   Type, in the command line, the numeric value of the current                cell, if any.  O           The ^_V, ^_W, and ^_A commands only work when the character cursorg@           is on the command line and beyond the first character.  F           TAB  When the character cursor is on the top line, defines aJ                range of cells via the cursor control commands or the arrowH                keys.  The range is highlighted, starts at the cell whereI                you typed TAB, and continues through the current cell cur-hJ                sor.  Pressing TAB again causes the highlighted range to beG                entered into the command line and the highlighting to bebF                turned off.  This is most useful for defining ranges toM                functions such as @_s_u_m().  Pressing ``)'' acts just likeaF                typing the TAB key the second time and adds the closingI                ``)''.  Note that when you give a range command, you don't K                need to press the first TAB to begin defining a range start-a)                ing with the current cell.0                  16             K                                                             XSPREAD 3.0 (1)                Variable Names  G           Normally, a variable name is just the name of a cell, such as K           _K_2_0.  The value is the numeric or string value of the cell,            according to context.B  J           When a cell's expression (formula) is copied to another locatione           via _c_o_p_y or _r_a_n_g_e-_c_o_p_y, variable references are by default offseteJ           by the amount the formula moved.  This allows the new formula toJ           work on new data.  If cell references are not to change, you canT           either use the _f_i_x_e_d operator (see below), or one of the follow-*           ing variations on the cell name.  V           _K_2_0  References cell _K_2_0; the reference changes when the formula                is copied.t             $_K$_2_0 N                Always refers to cell _K_2_0; the reference stays fixed when%                the formula is copied.o  Q           $_K_2_0 Keeps the column fixed at column K; the row is free to vary.C  Q           _K$_2_0 Similarly, this fixes the row and allows the column to vary.   J           These conventions also hold on defined ranges.  Range referencesI           vary when formulas containing them are copied.  If the range is G           defined with fixed variable references, the references do not            change.u             fixed_F                To make a variable not change automatically when a cellQ                moves, put the word _f_i_x_e_d in front of the reference, for &                example: B1 * fixed C3.             Numeric Expressions   I           Numeric expressions used with the ``='' and _e commands have a G           fairly conventional syntax.  Terms may be constants, variable J           names, parenthesized expressions, and negated terms.  Ranges mayN           be operated upon with range functions such as sum (@_s_u_m()) andP           average (@_a_v_g()).  Terms may be combined using binary operators.             -e   Negation.             e+e  Addition.             e-e  Subtraction.e             e*e  Multiplication.             e/e  Division.             e1%e2                 e1 mod e2.     K                                                                          170                  XSPREAD 3.0 (1)               e^e  Exponentiation.  
           e<ee           e<=e
           e=e            e!=e           e>=eJ           e>e  Relationals: true (1) if and only if the indicated relationK                holds, else false (0).  Note that ``<='', ``!='', and ``>=''u:                are converted to their ``~()'' equivalents.  $           ~e   Boolean operator NOT.  $           e&e  Boolean operator AND.  #           e|e  Boolean operator OR.c             @if(e,e,e)           e?e:eyJ                Conditional: If the first expression is true then the valueK                of the second is returned, otherwise the value of the third.n8           Operator precedence from highest to lowest is:                -, ~m                ^                *, /                 +, -a"                <, <=, =, !=, >=, >                &                |                ?:t  "           Built-in Range Functions  0           These functions return numeric values.J           @sum(r)           Sum all valid (nonblank) entries in the regionJ                             whose two corners are defined by the two vari-Q                             able names (e.g.  _c_5:_e_1_4) or the range namee&                             specified.J           @prod(r)          Multiply together all valid (nonblank) entries4                             in the specified region.G           @avg(r)           Average all valid (nonblank) entries in thee-                             specified region.sE           @count(r)         Count all valid (nonblank) entries in the -                             specified region. E           @max(r)           Return the maximum value in the specified K                             region.  See also the multi argument version of_-                             @_m_a_x below.aE           @min(r)           Return the minimum value in the specifiedoK                             region.  See also the multi argument version off-                             @_m_i_n below. G           @stddev(r)        Return the sample standard deviation of the :                             cells in the specified region.           @lookup(e,r)J           @lookup(se,r)     Evaluates the expression then searches through          18_            K                                                             XSPREAD 3.0 (1)R    J                             the range _r for a matching value.  The rangeE                             should be either a single row or a singlelJ                             column.  The expression can be either a stringK                             expression or a numeric expression.  If it is adI                             numeric expression, the range is searched for M                             the the last value less than or equal to _e.  IfdF                             the expression is a string expression, theI                             string portions of the cells in the range arepJ                             searched for an exact string match.  The valueK                             returned is the numeric value from the next row J                             and the same column as the match, if the rangeH                             was a single row, or the value from the nextG                             column and the same row as the match if thee6                             range was a single column.             @hlookup(e,r,n)aJ           @hlookup(se,r,n)  Evaluates the expression then searches throughI                             the first row in the range _r for a matching I                             value.  The expression can be either a string K                             expression or a numeric expression.  If it is amK                             numeric expression, the row is searched for thedM                             the last value less than or equal to _e.  If thenI                             expression is a string expression, the stringrI                             portions of the cells in the row are searched J                             for an exact string match.  The value returnedI                             is the numeric value from the same column _nl1                             rows below the match.h             @vlookup(e,r,n)VJ           @vlookup(se,r,n)  Evaluates the expression then searches throughL                             the first column in the range _r for a matchingI                             value.  The expression can be either a string,K                             expression or a numeric expression.  If it is acJ                             numeric expression, the column is searched forM                             the the last value less than or equal to _e.  If F                             the expression is a string expression, theJ                             string portions of the cells in the column areJ                             searched for an exact string match.  The valueK                             returned is the numeric value from the same row B                             _n columns to the right of the match.  M           @index(e,r)       Use the value of the expression _e to index into K                             the range _r.  The numeric value at that posi- K                             tion is returned. The value 1 selects the first I                             item in the range, 2 selects the second item, M                             etc.  _R should be either a single row or a sin- '                             gle column.d  M           @stindex(e,r)     Use the value of _e to index into the range _r.oJ                             The string value at that position is returned.E                             The value 1 selects the first item in the G                             range, 2 selects the second item, etc.  The K                             range should be either a single row or a singlea#                             column.l    K                                                                          19                   XSPREAD 3.0 (1)      $           Built-in Numeric Functions  H           All of these functions operate on floating point numbers (dou-J           bles) and return numeric values.  Most of them are standard sys-P           tem functions more fully described in _m_a_t_h(3).  The trig func-/           tions operate with angles in radians.a  :           @sqrt(e)          Return the square root of _e.  C           @exp(e)           Return the exponential function of _e.e  @           @ln(e)            Return the natural logarithm of _e.  @           @log(e)           Return the base 10 logarithm of _e.  L           @floor(e)         Return the largest integer not greater than _e.  J           @ceil(e)          Return the smallest integer not less than _e.  G           @rnd(e)           Round _e to the nearest integer.  default: J                             round-to-even (banker's round), *.5 will roundI                             to the closest even number; 'set rndinfinity'sB                             will round *.5 up to the next integer.  O           @round(e,n)       Round _e to _n decimal places.  n may be positive K                             to round off the right side of the decimal, and D                             negative to round off the left side. See=                             @rnd(e) above for rounding types.e             @abs(e).=           @fabs(e)          Return the absolute value of _e.iH           @pow(e1,e2)       Return _e_1 raised to the power of _e_2.H           @hypot(e1,e2)     Return sqrt(e1*e1+e2*e2), taking precautions:                             against unwarranted overflows.9           pi  @pi           A constant quite close to pi.u>           @dtr(e)           Convert _e in degrees to radians.>           @rtd(e)           Convert _e in radians to degrees.           @sin(e).           @cos(e)SJ           @tan(e)           Return trigonometric functions of radian argu-J                             ments.  The magnitude of the arguments are notA                             checked to assure meaningful results.   L           @asin(e)          Return the arc sine of _e in the range -pi/2 to!                             pi/2.   J           @acos(e)          Return the arc cosine of _e in the range 0 to                             pi.   L           @atan(e)          Return the arc tangent of _e in the range -pi/2$                             to pi/2.  Q           @atan2(e1,e2)     Returns the arc tangent of _e_1/_e_2 in the range           20|            K                                                             XSPREAD 3.0 (1)i    &                             -pi to pi.  K           @max(e1,e2,...)   Return the maximum of the values of the expres-tI                             sions.  Two or more expressions may be speci- K                             fied.  See also the range version of @_m_a_x "                             above.  K           @min(e1,e2,...)   Return the minimum of the values of the expres-FI                             sions.  Two or more expressions may be speci-mK                             fied.  See also the range version of @_m_i_n "                             above.  I           @ston(se)         Convert string expression _s_e to a numeric_"                             value.  P           @eqs(se1,se2)     Return 1 if string expression _s_e_1 has the sameN                             value as string expression _s_e_2, 0 otherwise.  J           @nval(se,e)       Return the numeric value of a cell selected byN                             name.  String expression _s_e must evaluate to aL                             column name (``A''-``AE'') and _e must evaluateO                             to a row number (0-199). If _s_e or _e is out of I                             bounds, or the cell has no numeric value, the K                             result is 0.  You can use this for simple tableuJ                             lookups.  Be sure the table doesn't move unex-F                             pectedly!  See also @_s_v_a_l() below.             String Expressions  H           String expressions are made up of constant strings (charactersG           surrounded by double quotation marks), variables (cell names, F           which refer to the cells' label strings or expressions), andJ           string functions.  Note that string expressions are only allowedJ           when entering a cell's label string, not its numeric part.  AlsoJ           note that string expression results may be left or right flushedH           or centered, according to the type of the cell's string label.  G           #    Concatenate strings.  For example, the string expressione  !                     A0 # "zy dog"   F                displays the string ``the lazy dog'' in the cell if the6                value of _A_0's string is ``the la''.  #           Built-in String Functions     L           @substr(se,e1,e2) Extract and return from string expression _s_eL                             the substring indexed by character number _e_1L                             through character number _e_2 (defaults to theR                             size of _s_e if beyond the end of it).  If _e_1 isM                             less than 1 or greater than _e_2, the result is :                             the null string.  For example,      K                                                                          21i                  XSPREAD 3.0 (1)    >                                  @substr ("Nice jacket", 4, 7)  9                             returns the string ``e jac''.n  N           @fmt(se,e)        Convert a number to a string.  The argument _s_eX                             must be a valid _p_r_i_n_t_f(3) format string.  _e isK                             converted according to the standard rules.  Forc3                             example, the expressionl  9                                  @fmt ("**%6.3f**", 10.5)   L                             yields the string ``**10.500**''.  _e is a dou-J                             ble, so applicable formats are e, E, f, g, and?                             G.  Try ``%g'' as a starting point.   I           @sval(se,e)       Return the string value of a cell selected by N                             name.  String expression _s_e must evaluate to aL                             column name (``A''-``AE'') and _e must evaluateO                             to a row number (0-199). If _s_e or _e is out of H                             bounds, or the cell has no string value, theH                             result is the null string.  You can use thisH                             for simple table lookups.  Be sure the table6                             doesn't move unexpectedly!  I           @upper(e)         and @lower(e) will case the string expressiont.                             to upper or lower.  G           @capital(e)       will convert the first letter of words in a G                             string into upper case and other letters tohH                             lower case (the latter if all letters of the3                             string are upper case).   I           @upper(e)         and @lower(e) will case the string expression .                             to upper or lower.  G           @capital(e)       will convert the first letter of words in a 3                             string into upper case.a  J           @ext(se,e)        Call an external function (program or script).J                             The purpose is to allow arbitrary functions onJ                             values, e.g. table lookups and interpolations.L                             String expression _s_e is a command or commandV                             line to call with _p_o_p_e_n(3).  The value of _e isJ                             converted to a string and appended to the com-Q                             mand line as an argument.  The result of @_e_x_t() K                             is a string: the first line printed to standard K                             output by the command.  The command should emitlK                             exactly one output line.  Additional output, orgK                             output to standard error, messes up the screen.mL                             @_e_x_t() returns a null string and prints anI                             appropriate warning if external functions are O                             disabled, _s_e is null, or the attempt to run the *                             command fails.            22             K                                                             XSPREAD 3.0 (1)e    I                             External functions can be slow to run, and ifrH                             enabled are called at each screen update, soI                             they are disabled by default.  You can enable L                             them with ^_T when you really want them called.  -                             A simple example:   2                                  @ext ("echo", a1)  S                             You can use @_s_t_o_n() to convert the @_e_x_t() B                             result back to a number.  For example:  F                                  @ston (@ext ("form.sc.ext", a9 + b9))  K                             Note that you can built a command line (includ- K                             ing more argument values) from a string expres-aI                             sion with concatenation.  You can also "hide" J                             the second argument by ending the command lineI                             (first argument) with `` #'' (shell comment).   G           @coltoa(e)        Returns a string name for a column from the ;                             numeric argument.  For example:   2                                  @coltoa(@mycol-1)B                                  @nval(coltoa(@mycol-1), @myrow+1)      &           Built-in Financial Functions  E           Financial functions compute the mortgage (or loan) payment, F           future value, and the present value functions.  Each acceptsJ           three arguments, an amount, a rate of interest (per period), andG           the number of periods.  These functions are the same as those H           commonly found in other spreadsheets and financial calculators  O           @pmt(e1,e2,e3)    @_p_m_t(60000,.01,360) computes the monthly pay-eE                             ments for a $60000 mortgage at 12% annual F                             interest (.01 per month) for 30 years (360$                             months).  N           @fv(e1,e2,e3)     @_f_v(100,.005,36) computes the future value forI                             of 36 monthly payments of $100 at 6% interest,G                             (.005 per month).  It answers the question: K                             "How much will I have in 36 months if I deposit I                             $100 per month in a savings account paying 6% 9                             interest compounded monthly?"t  O           @pv(e1,e2,e3)     @_p_v(1000,.015,36) computes the present value ofrK                             an a ordinary annuity of 36 monthly payments of I                             $1000 at 18% annual interest.  It answers the J                             question: "How much can I borrow at 18% for 30<                             years if I pay $1000 per month?"      K                                                                          23a                  XSPREAD 3.0 (1)    *           Built-in Date and Time Functions  S           Time for _x_s_p_r_e_a_d follows the system standard: the number of Q           seconds since 1970.  All date and time functions except @_d_a_t_e()'&           return numbers, not strings.  I           @now              Return the current time encoded as the number G                             of seconds since the beginning of the epoch ?                             (December 31, 1969, midnight, GMT.)l  Q           @dts(e1,e2,e3)    @_d_t_s(9,14,1988) converts the date September 14, K                             1988 to the number of seconds from the epoch to I                             the first second of 9/14/88, local time.  ForsQ                             example, @_d_a_t_e(@_d_t_s(12,14,1976)) yieldss  ]                                  _T_u_e _D_e_c _1_4 _0_0:_0_0:_0_0 _1_9_7_6   H                             The month should be range from  1 to 12, theI                             day should range from 1 to the number of days G                             in the specified month, and the year should 4                             range from 1970 to 1999.  P           @tts(e1,e2,e3)    @_t_t_s(8,20,45) converts the time 8:40:45 to theG                             number of seconds since midnight, the nighttH                             before.  The hour should range from 0 to 23;J                             the minutes and seconds should range from 0 to                             59.e  Q           The following functions take the time in seconds (e.g. from @_n_o_w) K           as an argument and return the specified value.  The functions allb)           convert from GMT to local time.   K           @date(e)          Convert the time in seconds to a date string 24 B                             characters long in the following form:  ]                                  _S_u_n _S_e_p _1_6 _0_1:_0_3:_5_2 _1_9_7_3   J                             Note that you can extract parts of this fixed-E                             format string with @_s_u_b_s_t_r().   J           @year(e)          Return the year.  Valid years begin with 1970.D                             The last legal year is system dependent.  J           @month(e)         Return the month, encoded as 1 (January) to 12'                             (December).e  H           @day(e)           Return the day of the month, encoded as 1 to                             31.   F           @hour(e)          Return the number of hours since midnight,/                             encoded as 0 to 23.o  G           @minute(e)        Return the number of minutes since the lasta:                             full hour, encoded as 0 to 59.          24             K                                                             XSPREAD 3.0 (1)     G           @second(e)        Return the number of seconds since the last <                             full minute, encoded as 0 to 59.             Spreadsheet Update  G           Re-evaluation of spreadsheet expressions is done by row or by I           column depending on the selected calculation order.  Evaluation ^           is repeated up to _i_t_e_r_a_t_i_o_n_s times for each update if necessary,O           so forward references usually work as expected.  See _s_e_t above. H           If stability is not reached after ten iterations, a warning isJ           printed.  This is usually due to a long series of forward refer-L           ences, or to unstable cyclic references (for example, set _A_0's"           expression to ``A0+1'').  I           @numiter          Returns the number of iterations performed so                               far.  
      FILES  F           tutorial.sc                             tutorial spreadsheet  
      SEE ALSO -           bc(1), dc(1), crypt(1), pxspread(1)   	      BUGScJ           Top-to-bottom, left-to-right evaluation of expressions is silly.C           A proper following of the dependency graph with (perhaps) 7           recourse to relaxation should be implemented.   P           Only one previous value is saved from any call of @_e_x_t().  If itH           is used more than once in a spreadsheet and external functionsI           are enabled and later disabled, the last returned value pops up            in several places.  I           On some systems, if the cell cursor is in column 0 with toplinerI           enabled (so the current cell is highlighted), or if any cell inlD           column 0 is highlighted, the corresponding row number getsI           displayed and then blanked during a screen refresh.  This looks +           like a bug in _c_u_r_s_e_s.   K           Many commands give no indication (a message or beep) if they haveoJ           null effect.  Some should give confirmation of their action, but           they don't.         AUTHORSI           This is a much modified version of a public domain spread sheet I           originally authored by James Gosling, and subsequently modified N           and posted to USENET by Mark Weiser under the name _v_c.  The pro-G           gram was subsequently renamed _s_c, and further modified by I           numerous contributors, Jeff Buhrt of Proslink, Inc.  ({sequent, H           uunet}!sawmill!prslnk!buhrt) and Robert Bond of Sequent, prom-F           inent among them.  Other contributors include: Tom Anderson,H           Glenn T. Barry, Gregory Bond, Stephen (Steve) M. Brooks, PeterF           Brower, John Campbell, Lawrence Cipriani, Jim Clausing, Dave    K                                                                          25x                  XSPREAD 3.0 (1)    K           Close, Chris Cole, Jonathan Crompron, David I. Dalva, Glen Ditch- H           field, Sam Drake, James P. Dugal, Paul Eggert, Andy Fyfe, JackK           Goral, Piercarlo "Peter" Grandi, Henk Hesselink, Jeffrey C Honig, G           Kurt Horton, Jonathan I. Kamens, Peter King, Tom Kloos, Casey H           Leedom, Jay Lepreau, Dave Lewis, Rick Linck, Soren Lundsgaard,H           Tad Mannes, Rob McMahon, Chris Metcalf, Mark Nagel, Ulf Noren,F           Marius Olafsson, Gene H. Olson, Henk P. Penning, Rick Perry,I           Larry Philps, Eric Putz, Jim Richardson, Michael Richardson, R. F           P. C. Rodgers, Kim Sanders, Mike Schwartz, Alan Silverstein,G           Lowell Skoog, Herr Soeryantono, Tim Theisen, Tom Tkacik, Andy J           Valencia, Adri Verhoef, Rick Walker, Petri Wessman, and Tim Wil-           son.                                                                                              26p      