home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / misc / volume20 / sc / part04 < prev    next >
Text File  |  1991-06-05  |  56KB  |  2,122 lines
  1. Newsgroups: comp.sources.misc
  2. From: Jeff Buhrt <prslnk!buhrt@cs.indiana.edu>
  3. Subject:  v20i038:  sc - The SC Spreadsheet, release 6.16, Part04/07
  4. Message-ID: <1991Jun5.172814.12170@sparky.IMD.Sterling.COM>
  5. X-Md4-Signature: 69e0a465a0fb1cf87d861e349692b612
  6. Date: Wed, 5 Jun 1991 17:28:14 GMT
  7. Approved: kent@sparky.imd.sterling.com
  8.  
  9. Submitted-by: Jeff Buhrt <prslnk!buhrt@cs.indiana.edu>
  10. Posting-number: Volume 20, Issue 38
  11. Archive-name: sc/part04
  12.  
  13. #! /bin/sh
  14. # into a shell via "sh file" or similar.  To overwrite existing files,
  15. # type "sh file -c".
  16. # The tool that generated this appeared in the comp.sources.unix newsgroup;
  17. # send mail to comp-sources-unix@uunet.uu.net if you want that tool.
  18. # Contents:  help.c range.c sc.c
  19. # Wrapped by kent@sparky on Wed Jun  5 09:22:20 1991
  20. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  21. echo If this archive is complete, you will see the following message:
  22. echo '          "shar: End of archive 4 (of 7)."'
  23. if test -f 'help.c' -a "${1}" != "-c" ; then 
  24.   echo shar: Will not clobber existing file \"'help.c'\"
  25. else
  26.   echo shar: Extracting \"'help.c'\" \(18188 characters\)
  27.   sed "s/^X//" >'help.c' <<'END_OF_FILE'
  28. X/*
  29. X * Help functions for sc 
  30. X * R. Bond, 1988
  31. X * J. Buhrt 1990
  32. X * $Revision: 6.16 $
  33. X */
  34. X
  35. X#ifdef QREF
  36. X#include <stdio.h>
  37. Xchar    *header = " Quick Reference\n\n$Revision: 6.16 $";
  38. X#else
  39. X#include <curses.h>
  40. X#include "sc.h"
  41. X#endif /* QREF */
  42. X
  43. Xchar *intro[] = {
  44. X" ",
  45. X" Overview:",
  46. X" ",
  47. X" A:   This overview",
  48. X" B:   Options",
  49. X" C:   Cursor movement commands",
  50. X" D:   Cell entry and editing commands",
  51. X" E:   Line Editing",
  52. X" F:   File commands",
  53. X" G:   Row and column commands",
  54. X" H:   Range commands",
  55. X" I:   Miscellaneous commands",
  56. X" J:   Variable names/Expressions",
  57. X" K:   Range functions",
  58. X" L:   Numeric functions",
  59. X" M:   String functions",
  60. X" N:   Financial functions",
  61. X" O:   Time and date functions",
  62. X" ",
  63. X" Q:   Return to main spreadsheet",
  64. X(char *)0
  65. X};
  66. X
  67. Xchar *options[] = {
  68. X" ",
  69. X" B: Options",
  70. X" ",
  71. X"     ^To  Toggle options. Toggle one option selected by o:",
  72. X" ",
  73. X"          a    Recalculate automatically or on ``@'' commands.",
  74. X"          c    Current cell highlighting enable/disable.",  
  75. X"          e    External function execution enable/disable.",
  76. X"          l    Autolabeling defined cells enable/disable.",
  77. X"          n    If enabled, a digit starts a numeric value.",
  78. X"          t    Top line display enable/disable.",
  79. X"          x    Encrypt/decrypt database and listing files.",
  80. X"          $    Dollar prescale.  If enabled, all numeric constants.",
  81. X"               (not expressions) entered are multipled by 0.01.",
  82. X" ",
  83. X"     S    Set options.  Options include:",
  84. X" ",
  85. X"          byrows        Recalculate in row order. (default)",
  86. X"          bycols        Recalculate in column order.",
  87. X"          iterations=n  Set the number of iterations allowed. (10)",
  88. X"          tblstyle=xx   Set ``T'' output style to:",
  89. X"                        0 (none), tex, latex, slatex, or tbl.",
  90. X"          rndinfinity   Round to infinity (round .5 up vs to nearest even).",
  91. X(char *)0
  92. X};
  93. X
  94. Xchar *cursor[] = {
  95. X" ",
  96. X" C: Cell cursor movement (always OK):",
  97. X" ",
  98. X"     ^N ^P ^B ^F Down, up, back, forward",
  99. X"     ^Ed         Go to end of range.  Follow ^E by a direction indicator",
  100. X"                 such as ^P or j.",
  101. X"     Arrow keys (if the terminal and termcap support them.)",
  102. X" ",
  103. X" Cell cursor movement if no prompt active:",
  104. X"     j,k,l,h    Down, up, right, left",
  105. X"     J,K,L,H    Down, up, right, left by 1/2 pages",
  106. X"     SPACE      Forward",
  107. X"     ^H         Back",
  108. X"     TAB        Forward, otherwise starts/ends a range",
  109. X"     ^          Up to row 0 of the current column.",
  110. X"     #          Down to the last valid row of the current column.",
  111. X"     0          Back to column A.  Preface with ^U if numeric mode.",
  112. X"     $          Forward to the last valid column of the current row.",
  113. X"     b          Back then up to the previous valid cell.",
  114. X"     w          Forward then down to the next valid cell.",
  115. X"     g          Go to a cell.  Cell name, range name, quoted string,",
  116. X"                a number, 'error', or 'invalid' to specify which cell.",
  117. X(char *)0
  118. X};
  119. X
  120. X
  121. Xchar *cell[] = {
  122. X" ",
  123. X" D: Cell entry and editing commands:",
  124. X" ",
  125. X"     =    Enter a numeric constant or expression.",
  126. X"     <    Enter a left justified string or string expression.",
  127. X"     \",>  Enter a right justified string or string expression.",
  128. X"     e    Edit the current cell's numeric value.",
  129. X"     E    Edit the current cell's string part.",
  130. X"     F    Assign a format to the current cell's numeric value.",
  131. X"     x    Clear the current cell.",
  132. X"     c    Copy the last marked cell to the current cell.",
  133. X"     m    Mark a cell to be used as the source for ``c''",
  134. X"     +    Increment numeric part",
  135. X"     -    Decrement numeric part",
  136. X"  RETURN  Enter insert mode if the input line was empty (ESC to edit)",
  137. X" ",
  138. X"     In numeric mode, a decimal digit, ``+'', ``-'', and ``.'' all start",
  139. X"     a new numeric constant or expression.",
  140. X(char *)0
  141. X};
  142. X
  143. X
  144. Xchar *vi[] = {
  145. X" ",
  146. X" E: Line Editor",
  147. X" ",
  148. X"     Hitting the ESC key while entering any command on the top line",
  149. X"     will start a one-line vi-style editor.  Supported commands:",
  150. X" ",
  151. X"     ESC q        Abort command entry.",
  152. X"     h l          Move cursor forward, backward.",
  153. X"     0 $          Move cursor to the beginning, end of the line.",
  154. X"     b w          Move cursor forward/back one word.",
  155. X"     fc           Move cursor to character c.",
  156. X"     tc           Move the cursor the the character before c.",
  157. X"     i a          Enter insert mode before/after the cursor.",
  158. X"     I            Move to cursor column 0 and enter insert mode.",
  159. X"     x X          Delete the character under/before the cursor.",
  160. X"     rc           Replace the character under the cursor with c.",
  161. X"     cm           Change - m = b,f,h,l,t or w.",
  162. X"     dm           Delete - m = b,f,h,l,t or w.",
  163. X"     R            Enter replace (overstrike) mode.",
  164. X"     + j - k /    Forward/backward/search the command history.",
  165. X"     n            Repeat last history search.",
  166. X"     . u          Repeat/undo the last command.",
  167. X(char *)0
  168. X};
  169. X
  170. Xchar *file[] = {
  171. X" ",
  172. X" F: File commands:",
  173. X" ",
  174. X"     G    Get a new database from a file. ",
  175. X"     M    Merge a new file into the current database.",
  176. X"     P    Put the current database into a file.",
  177. X"     W    Write a listing of the current database into a file in",
  178. X"          a form that matches its appearance on the screen.",
  179. X"     T    Write a listing of the current database to a file, but",
  180. X"          put delimiters between each pair of fields.",
  181. X"          Optionally brackets output with control lines for ``tbl'',",
  182. X"          ``LaTeX'', ``SLaTex'', or ``TeX''.",
  183. X" ",
  184. X"     If encryption mode is set, file I/O will be encrypted/decrypted.",
  185. X"     ``\"| program\"'' for a file name will pipe (unencrypted) output to",
  186. X"     a program for Put, Write and Table.  If a cell name is used",
  187. X"     as the file name, the cell's string part will be used as the",
  188. X"     file name.",
  189. X(char *)0
  190. X};
  191. X
  192. X
  193. Xchar *row[] = {
  194. X" ",
  195. X" G: Row and column commands:",
  196. X" ",
  197. X"     ir, ic      Insert a new, empty row (column)",
  198. X"     ar, ac      Append a new copy of the current row (column)",
  199. X"     dr, dc      Delete the current row (column)",
  200. X"     pr, pc, pm  Pull deleted cells back into the spreadsheet",
  201. X"                 Insert rows, columns or merge the cells.",
  202. X"     vr, vc      Remove expressions from the affected rows (columns),",
  203. X"                 leaving only the values.",
  204. X"     zr, zc      Hide (``zap'') the current row (column)",
  205. X"     sr, sc      Show hidden rows (columns)",
  206. X"     f           Set the output format to be used with the values of",
  207. X"                 each cell in this column.  Enter field width and",
  208. X"                 number of fractional digits.  A preceding count can be",
  209. X"                 used to change more than one column.",
  210. X" ",
  211. X"     Commands which move or copy cells also modify the row and column ",
  212. X"     references in the new cell expressions.  Use ``fixed'' or the",
  213. X"     ``$'' style cell reference to supress the change.",
  214. X" ",
  215. X"     @myrow, @mycol    return the row or column of the current cell",
  216. X(char *)0
  217. X};
  218. X
  219. X
  220. Xchar *range[] = {
  221. X" ",
  222. X" H: Range commands:",
  223. X" ",
  224. X"     /x   Clear a range. ",
  225. X"     /v   Remove the expressions from a range of cells, leaving ",
  226. X"          just the values.",
  227. X"     /c   Copy a source range to a destination range.",
  228. X"     /f   Fill a range with constant values starting with a given",
  229. X"          value and increasing by a given increment.",
  230. X"     /d   Assign a name to a cell or a range of cells.  Give the",
  231. X"          the name, surrounded by quotes, and either a cell name such",
  232. X"          as ``A10'' or a range such as ``a1:b20''.",
  233. X"     /s   Shows the currently defined range names.  Pipe output to",
  234. X"          sort, then to less.",
  235. X"     /u   Use this command to undefine a previously defined range name.",
  236. X"     /F   Assign a format string to a range of cells.",
  237. X" ",
  238. X"     Range operations affect a rectangular region on the screen",
  239. X"     defined by the upper left and lower right cells in the region.",
  240. X"     A range is specified by giving the cell names separated by ``:'',",
  241. X"     such as ``a20:k52''.  Another way to refer to a range is to use",
  242. X"     a name previously defined using ``/d''.",
  243. X(char *)0
  244. X};
  245. X
  246. X
  247. Xchar *misc[] = {
  248. X" ",
  249. X" I: Miscellaneous commands:",
  250. X" ",
  251. X"     Q q ^C   Exit from the program.",
  252. X"     ^G ESC   Abort entry of the current command.",
  253. X"     ?        Help",
  254. X"     !        Shell escape.  Enter a command to run.  ``!!'' repeats",
  255. X"              the last command.  Just ``!'' starts an interactive shell.",
  256. X"     ^L       Redraw the screen.",
  257. X"     ^R       Redraw the screen.  Highlight cells with values but no",
  258. X"              expressions.",
  259. X"     ^X       Redraw the screen.  Show formulas, not values.",
  260. X"     @        Recalculate the spreadsheet.",
  261. X"     ^V       Type, in the command line, the name of the current cell.",
  262. X"     ^W       Type, in the command line, the current cell's expression.",
  263. X"     ^A       Type, in the command line, the current cell's numeric value.",
  264. X"     TAB      When the character cursor is on the top line TAB can be used",
  265. X"              to start or stop the display of the default range.",
  266. X(char *)0
  267. X};
  268. X
  269. Xchar *var[] = {
  270. X" ",
  271. X" J: Variable names:",
  272. X" ",
  273. X"     K20    Row and column can vary on copies.",
  274. X"     $K$20  Row and column stay fixed on copies.",
  275. X"     $K20   Row can vary; column stays fixed on copies.",
  276. X"     K$20   Row stays fixed; column can vary on copies.",
  277. X"     fixed  holds following expession fixed on copies.",
  278. X"     Cells and ranges can be given a symbolic name via ``/d''.",
  279. X" ",
  280. X" Expressions:",
  281. X"     -e      Negation                e<=e  Less than or equal",
  282. X"     e+e     Addition                e=e   Equal",
  283. X"     e-e     Subtraction             e!=e  Not Equal",
  284. X"     e*e     Multiplication          e>=e  Greater than or equal",
  285. X"     e/e     Division                e>e  Greater than",
  286. X"     e%e     Modulo                  e<e  Less than",
  287. X"     e^e     Exponentiation          e&e  Boolean operator AND.",
  288. X"     ~e      Boolean operator NOT    e|e  Boolean operator OR",
  289. X"     e?e1:e2  or @if(e,e1,e2)",
  290. X"             Conditional: If e is non zero then then e1, else e2.",
  291. X"     Terms may be constants, variables, and parenthesized expressions.",
  292. X(char *)0
  293. X};
  294. X
  295. Xchar *rangef[] = {
  296. X" ",
  297. X" K: Range functions:",
  298. X" ",
  299. X"     @sum(r)           Sum all valid cells in the range.",
  300. X"     @prod(r)          Multiply together all valid cells in the range.",
  301. X"     @avg(r)           Average all valid cells in the range.",
  302. X"     @count(r)         Count all valid cells in the range.",
  303. X"     @max(r)           Return the maximum value in the range.",
  304. X"     @min(r)           Return the minimum value in the range.",
  305. X"     @stddev(r)        Return the sample standard deviation of ",
  306. X"                       the cells in the range.",
  307. X"     @index(e,r) @stindex(e,r)",
  308. X"                       Return the numeric (string) value of the cell at",
  309. X"                       index e into range r.",
  310. X"     @lookup(e,r) @hlookup(e,r,n) @vlookup(e,r,n)",
  311. X"                       Search through the range r for a value that",
  312. X"                       matches e.  If e is numeric, the last value <= e",
  313. X"                       matches; if string, an exact match is required.",
  314. X"                       @lookup searches a single row (column) and returns",
  315. X"                       the value from the next column (row); @hlookup",
  316. X"                       (@vlookup) searches the first row (column) in r and",
  317. X"                       returns the value n columns (rows) from the match.",
  318. X(char *)0
  319. X};
  320. X
  321. Xchar *numericf[] = {
  322. X" ",
  323. X" L: Numeric functions:",
  324. X" ",
  325. X"     @atan2(e1,e2)     Arc tangent of e1/e2.",
  326. X"     @ceil(e)          Smallest integer not less than e.",
  327. X"     @eqs(se1,se2)     1 if string expr se1 has the same value as se2.",
  328. X"     @exp(e)           Exponential function of e.",
  329. X"     @abs(e) @fabs(e)  Absolute value of e.",
  330. X"     @floor(e)         The largest integer not greater than e.",
  331. X"     @hypot(x,y)       Sqrt(x*x+y*y).",
  332. X"     @max(e1,e2,...)   The maximum of the values of the e's.",
  333. X"     @min(e1,e2,...)   The minimum of the values of the e's",
  334. X"     @nval(se,e)       The numeric value of a named cell.",
  335. X"     pi                A constant quite close to pi.",
  336. X"     @pow(e1,e2)       e1 raised to the power of e2.",
  337. X"     @rnd(e)           Round e to the nearest integer.",
  338. X"     @round(e,n)       Round e to n decimal places.",
  339. X"     @sqrt(e)          Square root of e.",
  340. X"     @ston(se)         Convert string expr se to a numeric",
  341. X"     @ln(e)   @log(e)           Natural/base 10 logarithm of e.",
  342. X"     @dtr(e)  @rtd(e)           Convert degrees to/from radians.",
  343. X"     @cos(e)  @sin(e)  @tan(e)  Trig functions of radian arguments.",
  344. X"     @asin(e) @acos(e) @atan(e) Inverse trig function.",
  345. X(char *)0
  346. X};
  347. X
  348. Xchar *stringf[] = {
  349. X" ",
  350. X" M: String functions:",
  351. X" ",
  352. X"     #                 Concatenate strings.  For example, the",
  353. X"                       string expression ``A0 # \"zy dog\"'' yields",
  354. X"                       ``the lazy dog'' if A0 is ``the la''.",
  355. X"     @substr(se,e1,e2) Extract characters e1 through e2 from the",
  356. X"                       string expression se.  For example,",
  357. X"                       ``@substr(\"Nice jacket\" 4, 7)'' yields ",
  358. X"                       ``e ja''.",
  359. X"     @fmt(se,e)        Convert a number to a string using sprintf(3).",
  360. X"                       For example,  ``@fmt(\"*%6.3f*\",10.5)'' yields",
  361. X"                       ``*10.500*''.  Use formats are e, E, f, g, and G.", 
  362. X"     @sval(se,e)       Return the string value of a cell selected by name.",
  363. X"     @ext(se,e)        Call an external function (program or",
  364. X"                       script).  Convert e to a string and append it",
  365. X"                       to the command line as an argument.  @ext yields",
  366. X"                       a string: the first line printed to standard",
  367. X"                       output by the command.",
  368. X"     @coltoa(e)        Return a column letter(s) from the passed number",
  369. X"     String expressions are made up of constant strings (characters",
  370. X"     surrounded by quotes), variables, and string functions.",
  371. X(char *)0
  372. X};
  373. X
  374. X
  375. Xchar *finf[] = {
  376. X" ",
  377. X" N: Financial functions:",
  378. X" ",
  379. X"     @pmt(e1,e2,e3)    @pmt(60000,.01,360) computes the monthly",
  380. X"                       payments for a $60000 mortgage at 12%",
  381. X"                       annual interest (.01 per month) for 30",
  382. X"                       years (360 months).",
  383. X" ",
  384. X"     @fv(e1,e2,e3)     @fv(100,.005,36) computes the future value",
  385. X"                       of 36 monthly payments of $100 at 6%",
  386. X"                       interest (.005 per month).  It answers the",
  387. X"                       question:  ``How much will I have in 36",
  388. X"                       months if I deposit $100 per month in a",
  389. X"                       savings account paying 6% interest com-",
  390. X"                       pounded monthly?''",
  391. X" ",
  392. X"     @pv(e1,e2,e3)     @pv(1000,.015,36) computes the present",
  393. X"                       value of an ordinary annuity of 36",
  394. X"                       monthly payments of $1000 at 18% annual",
  395. X"                       interest.  It answers the question: ``How",
  396. X"                       much can I borrow at 18% for 30 years if I",
  397. X"                       pay $1000 per month?''",
  398. X(char *)0
  399. X};
  400. X
  401. X
  402. Xchar *timef[] = {
  403. X" ",
  404. X" O: Time and date functions:",
  405. X" ",
  406. X"     @now              Return the time encoded in seconds since 1970.",
  407. X"     @dts(m,d,y)       Return m/d/y encoded in seconds since 1970.",
  408. X"     @tts(h,m,s)       Return h:m:s encoded in seconds since midnight.",
  409. X" ",
  410. X"     All of the following take an argument expressed in seconds:",
  411. X" ",
  412. X"     @date(e)          Convert the time in seconds to a date",
  413. X"                       string 24 characters long in the following",
  414. X"                       form: ``Sun Sep 16 01:03:52 1973''.  Note",
  415. X"                       that you can extract pieces of this fixed format",
  416. X"                       string with @substr.",
  417. X"     @year(e)          Return the year.  Valid years begin with 1970.",
  418. X"     @month(e)         Return the month: 1 (Jan) to 12 (Dec).",
  419. X"     @day(e)           Return the day of the month: 1 to 31.",
  420. X"     @hour(e)          Return the number of hours since midnight: 0 to 23.",
  421. X"     @minute(e)        Return the number of minutes since the",
  422. X"                       last full hour: 0 to 59.",
  423. X"     @second(e)        Return the number of seconds since the",
  424. X"                       last full minute: 0 to 59.",
  425. X(char *)0
  426. X};
  427. X
  428. X#ifndef QREF
  429. Xstatic    int    pscreen();
  430. X
  431. Xvoid
  432. Xhelp()
  433. X{
  434. X    int option;
  435. X    char **ns = intro;
  436. X
  437. X    while((option = pscreen(ns)) != 'q' && option != 'Q') {
  438. X        switch (option) {
  439. X    case 'a': case 'A': ns = intro; break;
  440. X    case 'b': case 'B': ns = options; break;
  441. X    case 'c': case 'C': ns = cursor; break;
  442. X    case 'd': case 'D': ns = cell; break;
  443. X    case 'e': case 'E': ns = vi; break;
  444. X    case 'f': case 'F': ns = file; break;
  445. X    case 'g': case 'G': ns = row; break;
  446. X    case 'h': case 'H': ns = range; break;
  447. X    case 'i': case 'I': ns = misc; break;
  448. X    case 'j': case 'J': ns = var; break;
  449. X    case 'k': case 'K': ns = rangef; break;
  450. X    case 'l': case 'L': ns = numericf; break;
  451. X    case 'm': case 'M': ns = stringf; break;
  452. X    case 'n': case 'N': ns = finf; break;
  453. X    case 'o': case 'O': ns = timef; break;
  454. X    default: ns = intro; break;
  455. X    }
  456. X    }
  457. X    FullUpdate++;
  458. X    (void) move(1,0);
  459. X    (void) clrtobot();
  460. X}
  461. X
  462. Xstatic    int
  463. Xpscreen(screen)
  464. Xchar *screen[];
  465. X{
  466. X    int lineno;
  467. X    int dbline;
  468. X
  469. X    (void) move(1,0);
  470. X    (void) clrtobot();
  471. X    dbline = 1;
  472. X    for (lineno = 0; screen[lineno]; lineno++) {
  473. X    (void) move(dbline++, 4);
  474. X    (void) addstr (screen[lineno]);
  475. X    (void) clrtoeol();
  476. X    }
  477. X    (void) move(0,0);
  478. X    (void) printw("Which Screen? [a-o, q]");
  479. X    (void) clrtoeol();
  480. X    (void) refresh();
  481. X    return(nmgetch());
  482. X}
  483. X#else
  484. Xchar    ** pages[] = { intro, options, cursor, cell, vi, file, row,
  485. X            range, misc, var, rangef, numericf, stringf,
  486. X            finf, timef, NULL};
  487. X
  488. Xvoid
  489. Xmain()
  490. X{   int    lineno;
  491. X    char    ***pagep = pages;
  492. X
  493. X    while (*pagep)
  494. X    {
  495. X    (void) fputs(SCNAME, stdout);
  496. X    (void) puts(header);
  497. X
  498. X    for (lineno = 0; (*pagep)[lineno]; lineno++) {
  499. X        (void) puts((*pagep)[lineno]);
  500. X    }
  501. X    (void) putchar('\f');
  502. X    pagep++;
  503. X    }
  504. X    (void) exit(0);
  505. X}
  506. X#endif /* QREF */
  507. END_OF_FILE
  508.   if test 18188 -ne `wc -c <'help.c'`; then
  509.     echo shar: \"'help.c'\" unpacked with wrong size!
  510.   fi
  511.   # end of 'help.c'
  512. fi
  513. if test -f 'range.c' -a "${1}" != "-c" ; then 
  514.   echo shar: Will not clobber existing file \"'range.c'\"
  515. else
  516.   echo shar: Extracting \"'range.c'\" \(5832 characters\)
  517.   sed "s/^X//" >'range.c' <<'END_OF_FILE'
  518. X
  519. X/*    SC    A Spreadsheet Calculator
  520. X *        Range Manipulations
  521. X *
  522. X *              Robert Bond, 4/87
  523. X *
  524. X *        $Revision: 6.16 $
  525. X */
  526. X
  527. X#include <sys/types.h>
  528. X#ifdef BSD42
  529. X#include <strings.h>
  530. X#else
  531. X#ifndef SYSIII
  532. X#include <string.h>
  533. X#endif
  534. X#endif
  535. X
  536. X#include <stdio.h>
  537. X#include <curses.h>
  538. X#include <ctype.h>
  539. X#include "sc.h"
  540. X
  541. Xstatic struct range *rng_base;
  542. X
  543. Xvoid
  544. Xadd_range(name, left, right, is_range)
  545. Xchar *name;
  546. Xstruct ent_ptr left, right;
  547. Xint is_range;
  548. X{
  549. X    struct range *r;
  550. X    register char *p;
  551. X    int len;
  552. X    int minr,minc,maxr,maxc;
  553. X    int minrf, mincf, maxrf, maxcf;
  554. X    register struct ent *rcp;
  555. X
  556. X    if (left.vp->row < right.vp->row) {
  557. X    minr = left.vp->row; minrf = left.vf & FIX_ROW;
  558. X    maxr = right.vp->row; maxrf = right.vf & FIX_ROW;
  559. X    } else {
  560. X    minr = right.vp->row; minrf = right.vf & FIX_ROW;
  561. X    maxr = left.vp->row; maxrf = right.vf & FIX_ROW;
  562. X    } 
  563. X
  564. X    if (left.vp->col < right.vp->col) {
  565. X    minc = left.vp->col; mincf = left.vf & FIX_COL;
  566. X    maxc = right.vp->col; maxcf = right.vf & FIX_COL;
  567. X    } else {
  568. X    minc = right.vp->col; mincf = right.vf & FIX_COL;
  569. X    maxc = left.vp->col; maxcf = left.vf & FIX_COL;
  570. X    } 
  571. X
  572. X    left.vp = lookat(minr, minc);
  573. X    left.vf = minrf | mincf;
  574. X    right.vp = lookat(maxr, maxc);
  575. X    right.vf = maxrf | maxcf;
  576. X
  577. X    if (find_range(name, strlen(name), (struct ent *)0, (struct ent *)0)) {
  578. X    error("Error: range name already defined");
  579. X    xfree(name);
  580. X    return;
  581. X    }
  582. X
  583. X    if (strlen(name) <= 2) {
  584. X    error("Invalid range name - too short");
  585. X    xfree(name);
  586. X    return;
  587. X    }
  588. X
  589. X    for(p=name, len=0; *p; p++, len++)
  590. X    if (!((isalpha(*p) && (len<=2)) ||
  591. X        ((isdigit(*p) || isalpha(*p) || (*p == '_')) && (len>2)))) {
  592. X        error("Invalid range name - illegal combination");
  593. X        xfree(name);
  594. X        return;
  595. X    }
  596. X 
  597. X    if(autolabel && minc>0 && !is_range) {
  598. X    rcp = lookat(minr,minc-1);
  599. X    if (rcp->label==0 && rcp->expr==0 && rcp->v==0)
  600. X        label(rcp, name, 0);
  601. X    }
  602. X
  603. X    r = (struct range *)xmalloc((unsigned)sizeof(struct range));
  604. X    r->r_name = name;
  605. X    r->r_left = left;
  606. X    r->r_right = right;
  607. X    r->r_next = rng_base;
  608. X    r->r_prev = (struct range *)0;
  609. X    r->r_is_range = is_range;
  610. X    if (rng_base)
  611. X        rng_base->r_prev = r;
  612. X    rng_base = r;
  613. X}
  614. X
  615. Xvoid
  616. Xdel_range(left, right)
  617. Xstruct ent *left, *right;
  618. X{
  619. X    register struct range *r;
  620. X    int minr,minc,maxr,maxc;
  621. X
  622. X    minr = left->row < right->row ? left->row : right->row;
  623. X    minc = left->col < right->col ? left->col : right->col;
  624. X    maxr = left->row > right->row ? left->row : right->row;
  625. X    maxc = left->col > right->col ? left->col : right->col;
  626. X
  627. X    left = lookat(minr, minc);
  628. X    right = lookat(maxr, maxc);
  629. X
  630. X    if (!(r = find_range((char *)0, 0, left, right))) 
  631. X    return;
  632. X
  633. X    if (r->r_next)
  634. X        r->r_next->r_prev = r->r_prev;
  635. X    if (r->r_prev)
  636. X        r->r_prev->r_next = r->r_next;
  637. X    else
  638. X    rng_base = r->r_next;
  639. X    xfree((char *)(r->r_name));
  640. X    xfree((char *)r);
  641. X}
  642. X
  643. Xvoid
  644. Xclean_range()
  645. X{
  646. X    register struct range *r;
  647. X    register struct range *nextr;
  648. X
  649. X    r = rng_base;
  650. X    rng_base = (struct range *)0;
  651. X
  652. X    while (r) {
  653. X    nextr = r->r_next;
  654. X    xfree((char *)(r->r_name));
  655. X    xfree((char *)r);
  656. X    r = nextr;
  657. X    }
  658. X}
  659. X
  660. X/* Match on name or lmatch, rmatch */
  661. X
  662. Xstruct range *
  663. Xfind_range(name, len, lmatch, rmatch)
  664. Xchar *name;
  665. Xint len;
  666. Xstruct ent *lmatch;
  667. Xstruct ent *rmatch;
  668. X{
  669. X    struct range *r;
  670. X    register char *rp, *np;
  671. X    register int c;
  672. X
  673. X    if (name) {
  674. X    for (r = rng_base; r; r = r->r_next) {
  675. X        for (np = name, rp = r->r_name, c = len;
  676. X         c && *rp && (*rp == *np);
  677. X         rp++, np++, c--) /* */;
  678. X        if (!c && !*rp)
  679. X        return(r);
  680. X    }
  681. X    return((struct range *)0);
  682. X    }
  683. X
  684. X    for (r = rng_base; r; r= r->r_next) {
  685. X    if ((lmatch == r->r_left.vp) && (rmatch == r->r_right.vp)) 
  686. X        return(r);
  687. X    }
  688. X    return((struct range *)0);
  689. X}
  690. X
  691. Xvoid
  692. Xsync_ranges()
  693. X{
  694. X    register struct range *r;
  695. X
  696. X    r = rng_base;
  697. X    while(r) {
  698. X    r->r_left.vp = lookat(r->r_left.vp->row, r->r_left.vp->col);
  699. X    r->r_right.vp = lookat(r->r_right.vp->row, r->r_right.vp->col);
  700. X    r = r->r_next;
  701. X    }
  702. X}
  703. X
  704. Xvoid
  705. Xwrite_range(f)
  706. XFILE *f;
  707. X{
  708. X    register struct range *r;
  709. X
  710. X    for (r = rng_base; r; r = r->r_next) {
  711. X    (void) fprintf(f, "define \"%s\" %s%s%s%d",
  712. X            r->r_name,
  713. X            r->r_left.vf & FIX_COL ? "$":"",
  714. X            coltoa(r->r_left.vp->col), 
  715. X            r->r_left.vf & FIX_ROW ? "$":"",
  716. X            r->r_left.vp->row);
  717. X    if (r->r_is_range)
  718. X        (void) fprintf(f, ":%s%s%s%d\n",
  719. X                r->r_right.vf & FIX_COL ? "$":"",
  720. X                coltoa(r->r_right.vp->col), 
  721. X                r->r_right.vf & FIX_ROW ? "$":"",
  722. X                r->r_right.vp->row);
  723. X    else
  724. X        (void) fprintf(f, "\n");
  725. X    }
  726. X}
  727. X
  728. Xvoid
  729. Xlist_range(f)
  730. XFILE *f;
  731. X{
  732. X    register struct range *r;
  733. X
  734. X    (void) fprintf(f, "%-30s %s\n\n","Name","Definition");
  735. X
  736. X    for (r = rng_base; r; r = r->r_next) {
  737. X    (void) fprintf(f, "%-30s %s%s%s%d",
  738. X                r->r_name,
  739. X                r->r_left.vf & FIX_COL ? "$":"",
  740. X                coltoa(r->r_left.vp->col), 
  741. X                r->r_left.vf & FIX_ROW ? "$":"",
  742. X                r->r_left.vp->row);
  743. X    if (r->r_is_range)
  744. X        (void) fprintf(f, ":%s%s%s%d\n",
  745. X                r->r_right.vf & FIX_COL ? "$":"",
  746. X                coltoa(r->r_right.vp->col), 
  747. X                r->r_right.vf & FIX_ROW ? "$":"",
  748. X                r->r_right.vp->row);
  749. X    else
  750. X        (void) fprintf(f, "\n");
  751. X    }
  752. X}
  753. X
  754. Xchar *
  755. Xv_name(row, col)
  756. Xint row, col;
  757. X{
  758. X    struct ent *v;
  759. X    struct range *r;
  760. X    static char buf[20];
  761. X
  762. X    v = lookat(row, col);
  763. X    if (r = find_range((char *)0, 0, v, v)) {
  764. X    return(r->r_name);
  765. X    } else {
  766. X        (void) sprintf(buf, "%s%d", coltoa(col), row);
  767. X    return(buf);
  768. X    }
  769. X}
  770. X
  771. Xchar *
  772. Xr_name(r1, c1, r2, c2)
  773. Xint r1, c1, r2, c2;
  774. X{
  775. X    struct ent *v1, *v2;
  776. X    struct range *r;
  777. X    static char buf[100];
  778. X
  779. X    v1 = lookat(r1, c1);
  780. X    v2 = lookat(r2, c2);
  781. X    if (r = find_range((char *)0, 0, v1, v2)) {
  782. X    return(r->r_name);
  783. X    } else {
  784. X        (void) sprintf(buf, "%s", v_name(r1, c1));
  785. X    (void) sprintf(buf+strlen(buf), ":%s", v_name(r2, c2));
  786. X    return(buf);
  787. X    }
  788. X}
  789. X
  790. Xint
  791. Xare_ranges()
  792. X{
  793. X    return (rng_base != 0);
  794. X}
  795. END_OF_FILE
  796.   if test 5832 -ne `wc -c <'range.c'`; then
  797.     echo shar: \"'range.c'\" unpacked with wrong size!
  798.   fi
  799.   # end of 'range.c'
  800. fi
  801. if test -f 'sc.c' -a "${1}" != "-c" ; then 
  802.   echo shar: Will not clobber existing file \"'sc.c'\"
  803. else
  804.   echo shar: Extracting \"'sc.c'\" \(27052 characters\)
  805.   sed "s/^X//" >'sc.c' <<'END_OF_FILE'
  806. X /*    SC    A Spreadsheet Calculator
  807. X *        Main driver
  808. X *
  809. X *        original by James Gosling, September 1982
  810. X *        modifications by Mark Weiser and Bruce Israel,
  811. X *            University of Maryland
  812. X *
  813. X *              More mods Robert Bond, 12/86
  814. X *        More mods by Alan Silverstein, 3-4/88, see list of changes.
  815. X *        Currently supported by sequent!sawmill!buhrt (Jeff Buhrt)
  816. X *        $Revision: 6.16 $
  817. X *
  818. X */
  819. X
  820. X#include <sys/types.h>
  821. X#include <signal.h>
  822. X#include <curses.h>
  823. X#include <ctype.h>
  824. X
  825. X#ifdef BSD42
  826. X#include <strings.h>
  827. X#else
  828. X#ifndef SYSIII
  829. X#include <string.h>
  830. X#endif
  831. X#endif
  832. X
  833. X#include <stdio.h>
  834. X#include "sc.h"
  835. X
  836. Xextern    char    *getenv();
  837. Xextern    void    startdisp(), stopdisp();
  838. X
  839. X#ifdef SYSV3
  840. Xvoid exit();
  841. X#endif
  842. X
  843. X#ifndef SAVENAME
  844. X#define    SAVENAME "SC.SAVE" /* file name to use for emergency saves */
  845. X#endif /* SAVENAME */
  846. X
  847. X#ifndef DFLT_PAGER
  848. X#define    DFLT_PAGER "more"    /* more is probably more widespread than less */
  849. X#endif /* DFLT_PAGER */
  850. X
  851. X#define MAXCMD 160    /* for ! command below */
  852. X
  853. X/* Globals defined in sc.h */
  854. X
  855. Xstruct ent ***tbl;
  856. Xint strow = 0, stcol = 0;
  857. Xint currow = 0, curcol = 0;
  858. Xint savedrow, savedcol;
  859. Xint FullUpdate = 0;
  860. Xint ClearScreen = 0;    /* don't try to be smart */
  861. Xint maxrow, maxcol;
  862. Xint maxrows, maxcols;
  863. Xint *fwidth;
  864. Xint *precision;
  865. Xint *realfmt;
  866. Xchar *col_hidden;
  867. Xchar *row_hidden;
  868. Xchar line[FBUFLEN];
  869. Xint changed;
  870. Xstruct ent *to_fix;
  871. Xint modflg;
  872. Xint numeric;
  873. Xchar *mdir;
  874. Xint showsc, showsr;    /* Starting cell for highlighted range */
  875. X
  876. Xvoid    update();
  877. Xvoid    repaint();
  878. X
  879. Xchar curfile[PATHLEN];
  880. Xchar    revmsg[80];
  881. X
  882. Xint  linelim = -1;
  883. X
  884. Xint  showtop   = 1;    /* Causes current cell value display in top line  */
  885. Xint  showcell  = 1;    /* Causes current cell to be highlighted      */
  886. Xint  showrange = 0;    /* Causes ranges to be highlighted          */
  887. Xint  showneed  = 0;    /* Causes cells needing values to be highlighted  */
  888. Xint  showexpr  = 0;    /* Causes cell exprs to be displayed, highlighted */
  889. X
  890. Xint  autocalc = 1 ;    /* 1 to calculate after each update */
  891. Xint  autolabel = 1;     /* If room, causes label to be created after a define*/
  892. Xint  calc_order = BYROWS;
  893. Xint  tbl_style = 0;    /* headers for T command output */
  894. Xint  rndinfinity = 0;
  895. Xint  numeric_field = 0; /* Started the line editing with a number */
  896. X#ifdef    SIGWINCH
  897. Xint  hitwinch = 0;    /* got a SIGWINCH? */
  898. X#endif
  899. X
  900. Xextern    int lastmx, lastmy;    /* Screen address of the cursor */
  901. Xextern    int lastcol, cols;    /* Spreadsheet Column the cursor was in last */
  902. X
  903. X/* a linked list of free [struct ent]'s, uses .next as the pointer */
  904. Xstruct ent *freeents = NULL;
  905. X
  906. Xextern    int    seenerr;
  907. Xextern    char    *rev;
  908. X
  909. X#ifdef VMS
  910. Xint VMS_read_raw = 0;
  911. X#endif
  912. X
  913. X/* return a pointer to a cell's [struct ent *], creating if needed */
  914. Xstruct ent *
  915. Xlookat(row,col)
  916. Xint    row, col;
  917. X{
  918. X    register struct ent **pp;
  919. X
  920. X    checkbounds(&row, &col);
  921. X    pp = ATBL(tbl, row, col);
  922. X    if (*pp == (struct ent *)0) {
  923. X        if (freeents != NULL)
  924. X    {    *pp = freeents;
  925. X        freeents = freeents->next;
  926. X    }
  927. X    else
  928. X        *pp = (struct ent *) xmalloc((unsigned)sizeof(struct ent));
  929. X    if (row>maxrow) maxrow = row;
  930. X    if (col>maxcol) maxcol = col;
  931. X    (*pp)->label = (char *)0;
  932. X    (*pp)->row = row;
  933. X    (*pp)->col = col;
  934. X    (*pp)->flags = 0;
  935. X    (*pp)->expr = (struct enode *)0;
  936. X    (*pp)->v = (double) 0.0;
  937. X    (*pp)->format = (char *)0;
  938. X    (*pp)->cellerror = CELLOK;
  939. X    (*pp)->next = NULL;
  940. X    }
  941. X    return *pp;
  942. X}
  943. X
  944. X/*
  945. X * This structure is used to keep ent structs around before they
  946. X * are deleted to allow the sync_refs routine a chance to fix the
  947. X * variable references.
  948. X * We also use it as a last-deleted buffer for the 'p' command.
  949. X */
  950. Xvoid
  951. Xfree_ent(p)
  952. Xregister struct ent *p;
  953. X{
  954. X    p->next = to_fix;
  955. X    to_fix = p;
  956. X    p->flags |= is_deleted;
  957. X}
  958. X
  959. X/* free deleted cells */
  960. Xvoid
  961. Xflush_saved()
  962. X{
  963. X    register struct ent *p;
  964. X    register struct ent *q;
  965. X
  966. X    if (!(p = to_fix))
  967. X    return;
  968. X    while (p) {
  969. X    (void) clearent(p);
  970. X    q = p->next;
  971. X    p->next = freeents;    /* put this ent on the front of freeents */
  972. X    freeents = p;
  973. X    p = q;
  974. X    }
  975. X    to_fix = NULL;
  976. X}
  977. X
  978. Xchar    *progname;
  979. X
  980. Xint
  981. Xmain (argc, argv)
  982. Xint argc;
  983. Xchar  **argv;
  984. X{
  985. X    int     inloop = 1;
  986. X    register int   c;
  987. X    int     edistate = -1;
  988. X    int     arg = 1;
  989. X    int     narg;
  990. X    int     nedistate;
  991. X    int        running;
  992. X    char    *revi;
  993. X    int        anychanged = FALSE;
  994. X
  995. X    /*
  996. X     * Keep command line options around until the file is read so the
  997. X     * command line overrides file options
  998. X     */
  999. X
  1000. X    int Mopt = 0;
  1001. X    int Nopt = 0;
  1002. X    int Copt = 0; 
  1003. X    int Ropt = 0;
  1004. X
  1005. X    int tempx, tempy;     /* Temp versions of curx, cury */
  1006. X
  1007. X    if ((revi = strrchr(argv[0], '/')) != NULL)
  1008. X    progname = revi+1;
  1009. X    else
  1010. X    progname = argv[0];
  1011. X
  1012. X    while (argc > 1 && argv[1][0] == '-') {
  1013. X    argv++;
  1014. X    argc--;
  1015. X        switch (argv[0][1]) {
  1016. X        case 'x':
  1017. X#ifdef VMS
  1018. X            (void) fprintf(stderr, "Crypt not available for VMS\n");
  1019. X            exit(1);
  1020. X#else 
  1021. X            Crypt = 1;
  1022. X#endif
  1023. X            break;
  1024. X        case 'm':
  1025. X            Mopt = 1;
  1026. X            break;
  1027. X        case 'n':
  1028. X            Nopt = 1;
  1029. X            break;
  1030. X        case 'c':
  1031. X            Copt = 1;
  1032. X            break;
  1033. X        case 'r':
  1034. X            Ropt = 1;
  1035. X            break;
  1036. X        default:
  1037. X            (void) fprintf(stderr,"%s: unrecognized option: \"%c\"\n",
  1038. X            progname,argv[0][1]);
  1039. X            exit(1);
  1040. X    }
  1041. X    }
  1042. X
  1043. X    *curfile ='\0';
  1044. X
  1045. X    startdisp();
  1046. X    signals();
  1047. X
  1048. X    /* setup the spreadsheet arrays, initscr() will get the screen size */
  1049. X    if (!growtbl(GROWNEW, 0, 0))
  1050. X    {    stopdisp();
  1051. X    exit(1);
  1052. X    }
  1053. X
  1054. X    /*
  1055. X     * Build revision message for later use:
  1056. X     */
  1057. X
  1058. X    (void) strcpy (revmsg, progname);
  1059. X    for (revi = rev; (*revi++) != ':'; );    /* copy after colon */
  1060. X    (void) strcat (revmsg, revi);
  1061. X    revmsg [strlen (revmsg) - 2] = 0;        /* erase last character */
  1062. X    (void) strcat (revmsg, ":  Type '?' for help.");
  1063. X
  1064. X    if (argc > 1) {
  1065. X    (void) strcpy(curfile,argv[1]);
  1066. X    readfile (argv[1], 0);
  1067. X    }
  1068. X
  1069. X    if (Mopt)
  1070. X    autocalc = 0;
  1071. X    if (Nopt)
  1072. X    numeric = 1;
  1073. X    if (Copt)
  1074. X    calc_order = BYCOLS;
  1075. X    if (Ropt)
  1076. X    calc_order = BYROWS;
  1077. X
  1078. X    modflg = 0;
  1079. X#ifdef VENIX
  1080. X    setbuf (stdin, NULL);
  1081. X#endif
  1082. X    FullUpdate++;
  1083. X
  1084. X    while (inloop) { running = 1;
  1085. X    while (running) {
  1086. X    nedistate = -1;
  1087. X    narg = 1;
  1088. X    if (edistate < 0 && linelim < 0 && autocalc && (changed || FullUpdate))
  1089. X    {    EvalAll ();
  1090. X         if (changed)        /* if EvalAll changed or was before */
  1091. X        anychanged = TRUE;
  1092. X         changed = 0;
  1093. X    }
  1094. X    else        /* any cells change? */
  1095. X    if (changed)
  1096. X         anychanged = TRUE;
  1097. X
  1098. X#ifdef    SIGWINCH
  1099. X    /* got a SIGWINCH? */
  1100. X    if (hitwinch)
  1101. X    {    stopdisp();
  1102. X        startdisp();
  1103. X        FullUpdate++;
  1104. X    }
  1105. X#endif
  1106. X    update(anychanged);
  1107. X    anychanged = FALSE;
  1108. X#ifndef SYSV3    /* HP/Ux 3.1 this may not be wanted */
  1109. X    (void) refresh(); /* 5.3 does a refresh in getch */ 
  1110. X#endif
  1111. X    c = nmgetch();
  1112. X    getyx(stdscr, tempy, tempx);
  1113. X    (void) move (1, 0);
  1114. X    (void) clrtoeol ();
  1115. X    (void) move(tempy, tempx);
  1116. X/*    (void) fflush (stdout);*/
  1117. X    seenerr = 0;
  1118. X    showneed = 0;    /* reset after each update */
  1119. X    showexpr = 0;
  1120. X
  1121. X    /*
  1122. X     * there seems to be some question about what to do w/ the iscntrl
  1123. X     * some BSD systems are reportedly broken as well
  1124. X     */
  1125. X    /* if ((c < ' ') || ( c == DEL ))   how about international here ? PB */
  1126. X#if    pyr
  1127. X       if ( iscntrl(c) || (c >= 011 && c <= 015) )    /* iscntrl broken in OSx4.1 */
  1128. X#else
  1129. X       if ( iscntrl(c) )
  1130. X#endif
  1131. X        switch (c) {
  1132. X#ifdef SIGTSTP
  1133. X        case ctl('z'):
  1134. X            (void) deraw();
  1135. X            (void) kill(0, SIGTSTP); /* Nail process group */
  1136. X
  1137. X            /* the pc stops here */
  1138. X
  1139. X            (void) goraw();
  1140. X            break;
  1141. X#endif
  1142. X        case ctl('r'):
  1143. X            showneed = 1;
  1144. X        case ctl('l'):
  1145. X            FullUpdate++;
  1146. X            ClearScreen++;
  1147. X            (void) clearok(stdscr,1);
  1148. X            break;
  1149. X        case ctl('x'):
  1150. X            FullUpdate++;
  1151. X            showexpr = 1;
  1152. X            (void) clearok(stdscr,1);
  1153. X            break;
  1154. X        default:
  1155. X            error ("No such command (^%c)", c + 0100);
  1156. X            break;
  1157. X        case ctl('b'):
  1158. X            if (numeric_field) {
  1159. X            write_line(ctl('m'));
  1160. X            numeric_field = 0;
  1161. X            }
  1162. X            backcol(arg);
  1163. X            break;
  1164. X        case ctl('c'):
  1165. X            running = 0;
  1166. X            break;
  1167. X
  1168. X        case ctl('e'):
  1169. X
  1170. X            switch (nmgetch()) {
  1171. X            case ctl('p'): case 'k':    doend (-1, 0);    break;
  1172. X            case ctl('n'): case 'j':    doend ( 1, 0);    break;
  1173. X            case ctl('b'): case 'h':
  1174. X            case ctl('h'):        doend ( 0,-1);    break;
  1175. X            case ctl('f'): case 'l':
  1176. X            case ctl('i'): case ' ':    doend ( 0, 1);    break;
  1177. X
  1178. X            case ESC:
  1179. X            case ctl('g'):
  1180. X            break;
  1181. X
  1182. X            default:
  1183. X            error("Invalid ^E command");
  1184. X            break;
  1185. X            }
  1186. X
  1187. X            break;
  1188. X
  1189. X        case ctl('f'):
  1190. X            if (numeric_field) {
  1191. X            write_line(ctl('m'));
  1192. X            numeric_field = 0;
  1193. X            }
  1194. X            forwcol(arg);
  1195. X            break;
  1196. X
  1197. X        case ctl('g'):
  1198. X            showrange = 0;
  1199. X            linelim = -1;
  1200. X            (void) move (1, 0);
  1201. X            (void) clrtoeol ();
  1202. X            break;
  1203. X
  1204. X        case ESC:    /* ctl('[') */
  1205. X            write_line(ESC);
  1206. X            break;
  1207. X
  1208. X        case ctl('d'):
  1209. X            write_line(ctl('d'));
  1210. X            break;
  1211. X
  1212. X        case DEL:
  1213. X        case ctl('h'):
  1214. X            if (linelim < 0) {    /* not editing line */
  1215. X            backcol(arg);    /* treat like ^B    */
  1216. X            break;
  1217. X            }
  1218. X            write_line(ctl('h'));
  1219. X            break;
  1220. X
  1221. X        case ctl('i'):         /* tab */
  1222. X            if (linelim < 0) {    /* not editing line */
  1223. X            forwcol(arg);
  1224. X            break;
  1225. X            }
  1226. X            if (!showrange) {
  1227. X            startshow();
  1228. X            } else {
  1229. X            showdr();
  1230. X            linelim = strlen(line);
  1231. X            line[linelim++] = ' ';
  1232. X            line[linelim] = '\0';
  1233. X            showrange = 0;
  1234. X            }
  1235. X            linelim = strlen (line);
  1236. X            break;
  1237. X
  1238. X        case ctl('m'):
  1239. X        case ctl('j'):
  1240. X            numeric_field = 0;
  1241. X            write_line(ctl('m'));
  1242. X            break;
  1243. X
  1244. X        case ctl('n'):
  1245. X            if (numeric_field) {
  1246. X            write_line(ctl('m'));
  1247. X            numeric_field = 0;
  1248. X            }
  1249. X            forwrow(arg);
  1250. X            break;
  1251. X
  1252. X        case ctl('p'):
  1253. X            if (numeric_field) {
  1254. X            write_line(ctl('m'));
  1255. X            numeric_field = 0;
  1256. X            }
  1257. X            backrow(arg);
  1258. X            break;
  1259. X
  1260. X        case ctl('q'):
  1261. X            break;    /* ignore flow control */
  1262. X
  1263. X        case ctl('s'):
  1264. X            break;    /* ignore flow control */
  1265. X
  1266. X        case ctl('t'):
  1267. X            error(
  1268. X"Toggle: a:auto  c:cell  e:ext funcs  n:numeric  t:top  x:encrypt  $:pre-scale");
  1269. X            (void) refresh();
  1270. X
  1271. X            switch (nmgetch()) {
  1272. X            case 'a': case 'A':
  1273. X            case 'm': case 'M':
  1274. X                autocalc ^= 1;
  1275. X                error("Automatic recalculation %sabled.",
  1276. X                autocalc ? "en":"dis");
  1277. X                break;
  1278. X            case 'n': case 'N':
  1279. X                numeric = (! numeric);
  1280. X                error ("Numeric input %sabled.",
  1281. X                    numeric ? "en" : "dis");
  1282. X                break;
  1283. X            case 't': case 'T':
  1284. X                showtop = (! showtop);
  1285. X                error ("Top line %sabled.", showtop ? "en" : "dis");
  1286. X                break;
  1287. X            case 'c': case 'C':
  1288. X                showcell = (! showcell);
  1289. X                repaint(lastmx, lastmy, fwidth[lastcol]);
  1290. X                error ("Cell highlighting %sabled.",
  1291. X                    showcell ? "en" : "dis");
  1292. X                break;
  1293. X            case 'x': case 'X':
  1294. X                Crypt = (! Crypt);
  1295. X                error ("Encryption %sabled.", Crypt? "en" : "dis");
  1296. X                break;
  1297. X            case 'l': case 'L':
  1298. X                autolabel = (! autolabel);
  1299. X                error ("Autolabel %sabled.",
  1300. X                   autolabel? "en" : "dis");
  1301. X                break;
  1302. X            case '$':
  1303. X                if (prescale == 1.0) {
  1304. X                error ("Prescale enabled.");
  1305. X                prescale = 0.01;
  1306. X                } else {
  1307. X                prescale = 1.0;
  1308. X                error ("Prescale disabled.");
  1309. X                }
  1310. X                break;
  1311. X            case 'e': case 'E':
  1312. X                extfunc = (! extfunc);
  1313. X                error ("External functions %sabled.",
  1314. X                    extfunc? "en" : "dis");
  1315. X                break;
  1316. X            case ESC:
  1317. X            case ctl('g'):
  1318. X                --modflg;    /* negate the modflg++ */
  1319. X                break;
  1320. X            default:
  1321. X                error ("Invalid toggle command");
  1322. X                --modflg;    /* negate the modflg++ */
  1323. X            }
  1324. X            FullUpdate++;
  1325. X            modflg++;
  1326. X            break;
  1327. X
  1328. X        case ctl('u'):
  1329. X            narg = arg * 4;
  1330. X            nedistate = 1;
  1331. X            break;
  1332. X
  1333. X        case ctl('v'):    /* insert variable name */
  1334. X            if (linelim > 0)
  1335. X                ins_string(v_name(currow, curcol));
  1336. X            break;
  1337. X
  1338. X        case ctl('w'):    /* insert variable expression */
  1339. X            if (linelim > 0)  {
  1340. X            static    char *temp = NULL, *temp1 = NULL;
  1341. X            static    unsigned    templen = 0;
  1342. X            int templim;
  1343. X
  1344. X            /* xrealloc will xmalloc if needed */
  1345. X            if (strlen(line)+1 > templen)
  1346. X            {    templen = strlen(line)+40;
  1347. X
  1348. X                temp = xrealloc(temp, templen);
  1349. X                temp1= xrealloc(temp1, templen);
  1350. X            }
  1351. X            strcpy(temp, line);
  1352. X            templim = linelim;
  1353. X            linelim = 0;        /* reset line to empty    */
  1354. X            editexp(currow,curcol);
  1355. X            strcpy(temp1, line);
  1356. X            strcpy(line, temp);
  1357. X            linelim = templim;
  1358. X            ins_string(temp1);
  1359. X            }
  1360. X            break;
  1361. X
  1362. X        case ctl('a'):    /* insert variable value */
  1363. X            if (linelim > 0) {
  1364. X            struct ent *p = *ATBL(tbl, currow, curcol);
  1365. X            char temp[100];
  1366. X
  1367. X            if (p && p -> flags & is_valid) {
  1368. X                (void) sprintf (temp, "%.*f",
  1369. X                    precision[curcol],p -> v);
  1370. X                ins_string(temp);
  1371. X            }
  1372. X            }
  1373. X            break;
  1374. X
  1375. X        } /* End of the control char switch stmt */
  1376. X    else if (isdigit(c) && ((numeric && edistate >= 0) ||
  1377. X            (!numeric && (linelim < 0 || edistate >= 0)))) {
  1378. X        /* we got a leading number */
  1379. X        if (edistate != 0) {
  1380. X        /* First char of the count */
  1381. X        if (c == '0')      /* just a '0' goes to left col */
  1382. X            curcol = 0;
  1383. X        else {
  1384. X            nedistate = 0;
  1385. X            narg = c - '0';
  1386. X        }
  1387. X        } else {
  1388. X        /* Succeeding count chars */
  1389. X        nedistate = 0;
  1390. X        narg = arg * 10 + (c - '0');
  1391. X        }
  1392. X    } else if (linelim >= 0) {
  1393. X        /* Editing line */
  1394. X        switch(c) {
  1395. X        case ')':
  1396. X        if (showrange) {
  1397. X            showdr();
  1398. X            showrange = 0;
  1399. X            linelim = strlen (line);
  1400. X        }
  1401. X        break;
  1402. X        default:
  1403. X        break;
  1404. X        }
  1405. X        write_line(c);
  1406. X
  1407. X    } else if (!numeric && ( c == '+' || c == '-' ) ) {
  1408. X        /* increment/decrement ops */
  1409. X        register struct ent *p = *ATBL(tbl, currow, curcol);
  1410. X        if (!p)
  1411. X        continue;
  1412. X        if (p->expr && !(p->flags & is_strexpr)) {
  1413. X        error("Can't increment/decrement a formula\n");
  1414. X        continue;
  1415. X        }
  1416. X        FullUpdate++;
  1417. X        modflg++;
  1418. X        if( c == '+' )
  1419. X            p -> v += (double) arg;
  1420. X        else
  1421. X        p -> v -= (double) arg;
  1422. X    } else
  1423. X        /* switch on a normal command character */
  1424. X        switch (c) {
  1425. X        case ':':
  1426. X            break;    /* Be nice to vi users */
  1427. X
  1428. X        case '@':
  1429. X            EvalAll ();
  1430. X            changed = 0;
  1431. X            anychanged = TRUE;
  1432. X            break;
  1433. X
  1434. X        case '0': case '1': case '2': case '3': case '4':
  1435. X        case '5': case '6': case '7': case '8': case '9':
  1436. X        case '-': case '.': case '+':
  1437. X            numeric_field = 1;
  1438. X            (void) sprintf(line,"let %s = %c",
  1439. X                v_name(currow, curcol), c);
  1440. X            linelim = strlen (line);
  1441. X            insert_mode();
  1442. X            break;
  1443. X
  1444. X        case '=':
  1445. X            (void) sprintf(line,"let %s = ",
  1446. X                    v_name(currow, curcol));
  1447. X            linelim = strlen (line);
  1448. X            insert_mode();
  1449. X            break;
  1450. X
  1451. X        case '!':
  1452. X            {
  1453. X            /*
  1454. X             *  "! command"  executes command
  1455. X             *  "!"    forks a shell
  1456. X             *  "!!" repeats last command
  1457. X             */
  1458. X#ifdef VMS
  1459. X            error("Not implemented on VMS");
  1460. X#else /* VMS */
  1461. X            char *shl;
  1462. X            int pid, temp;
  1463. X            char cmd[MAXCMD];
  1464. X            static char lastcmd[MAXCMD];
  1465. X
  1466. X            if (!(shl = getenv("SHELL")))
  1467. X            shl = "/bin/sh";
  1468. X
  1469. X            deraw();
  1470. X            (void) fputs("! ", stdout);
  1471. X            (void) fflush(stdout);
  1472. X            (void) fgets(cmd, MAXCMD, stdin);
  1473. X            cmd[strlen(cmd) - 1] = '\0';    /* clobber \n */
  1474. X            if(strcmp(cmd,"!") == 0)        /* repeat? */
  1475. X                (void) strcpy(cmd, lastcmd);
  1476. X            else
  1477. X                (void) strcpy(lastcmd, cmd);
  1478. X
  1479. X            if (modflg)
  1480. X            {
  1481. X            (void) puts ("[No write since last change]");
  1482. X            (void) fflush (stdout);
  1483. X            }
  1484. X
  1485. X            if (!(pid = fork()))
  1486. X            {
  1487. X            (void) signal (SIGINT, SIG_DFL);  /* reset */
  1488. X            if(strlen(cmd))
  1489. X                (void)execl(shl,shl,"-c",cmd,(char *)0);
  1490. X            else
  1491. X                (void) execl(shl, shl, (char *)0);
  1492. X            exit(-127);
  1493. X            }
  1494. X
  1495. X            while (pid != wait(&temp));
  1496. X
  1497. X            (void) printf("Press RETURN to continue ");
  1498. X            fflush(stdout);
  1499. X            (void)nmgetch();
  1500. X            goraw();
  1501. X#endif /* VMS */
  1502. X            break;
  1503. X            }
  1504. X
  1505. X        /*
  1506. X         * Range commands:
  1507. X         */
  1508. X
  1509. X        case '/':
  1510. X            error (
  1511. X"Range:  x:erase  v:value  c:copy  f:fill  d:define  s:show  u:undefine  F:fmt");
  1512. X            (void) refresh();
  1513. X
  1514. X            switch (nmgetch()) {
  1515. X            case 'c':
  1516. X            (void) sprintf(line,"copy [dest_range src_range] ");
  1517. X            linelim = strlen(line);
  1518. X            startshow();
  1519. X            insert_mode();
  1520. X            break;
  1521. X            case 'x':
  1522. X            (void) sprintf(line,"erase [range] ");
  1523. X            linelim = strlen(line);
  1524. X            startshow();
  1525. X            insert_mode();
  1526. X            break;
  1527. X            case 'v':
  1528. X            (void) sprintf(line, "value [range] ");
  1529. X            linelim = strlen(line);
  1530. X            startshow();
  1531. X            insert_mode();
  1532. X            break;
  1533. X            case 'f':
  1534. X            (void) sprintf(line,"fill [range start inc] ");
  1535. X            linelim = strlen(line);
  1536. X            startshow();
  1537. X            insert_mode();
  1538. X            break;
  1539. X            case 'd':
  1540. X            (void) sprintf(line,"define [string range] \"");
  1541. X            linelim = strlen(line);
  1542. X            startshow();
  1543. X            insert_mode();
  1544. X            modflg++;
  1545. X            break;
  1546. X            case 'u':
  1547. X            (void) sprintf(line,"undefine [range] ");
  1548. X            linelim = strlen(line);
  1549. X            insert_mode();
  1550. X            modflg++;
  1551. X            break;
  1552. X            case 's':
  1553. X            if(are_ranges())
  1554. X            {
  1555. X            FILE *f;
  1556. X            int pid;
  1557. X            char px[MAXCMD] ;
  1558. X            char *pager;
  1559. X
  1560. X            (void) strcpy(px, "| sort | ");
  1561. X            if(!(pager = getenv("PAGER")))
  1562. X                pager = DFLT_PAGER;
  1563. X            (void) strcat(px,pager);
  1564. X            f = openout(px, &pid);
  1565. X            if (!f) {
  1566. X                error("Can't open pipe to sort");
  1567. X                break;
  1568. X            }
  1569. X            list_range(f);
  1570. X            closeout(f, pid);
  1571. X            }
  1572. X            else error("No ranges defined");
  1573. X            break;
  1574. X            case 'F':
  1575. X            (void) sprintf(line, "fmt [range \"format\"] ");
  1576. X            linelim = strlen(line);
  1577. X            startshow();
  1578. X            insert_mode();
  1579. X            break;
  1580. X            case ESC:
  1581. X            case ctl('g'):
  1582. X            break;
  1583. X           default:
  1584. X            error("Invalid region command");
  1585. X            break;
  1586. X           }
  1587. X           break;
  1588. X
  1589. X        /*
  1590. X         * Row/column commands:
  1591. X         */
  1592. X
  1593. X        case 'i':
  1594. X        case 'a':
  1595. X        case 'd':
  1596. X        case 'p':
  1597. X        case 'v':
  1598. X        case 'z':
  1599. X        case 's':
  1600. X            {
  1601. X            register rcqual;
  1602. X
  1603. X            if (! (rcqual = get_rcqual (c))) {
  1604. X                error ("Invalid row/column command");
  1605. X                break;
  1606. X            }
  1607. X
  1608. X            error ("");    /* clear line */
  1609. X
  1610. X            if ( rcqual == ESC || rcqual == ctl('g'))
  1611. X                break;
  1612. X
  1613. X            switch (c) {
  1614. X
  1615. X            case 'i':
  1616. X                if (rcqual == 'r')    insertrow(arg);
  1617. X                else        opencol(curcol, arg);
  1618. X                break;
  1619. X
  1620. X            case 'a':
  1621. X                if (rcqual == 'r')    while (arg--) duprow();
  1622. X                else        while (arg--) dupcol();
  1623. X                break;
  1624. X
  1625. X            case 'd':
  1626. X                if (rcqual == 'r')    deleterow(arg);
  1627. X                else        closecol(curcol, arg);
  1628. X                break;
  1629. X
  1630. X            case 'p':
  1631. X                while (arg--)    pullcells(rcqual);
  1632. X                break;
  1633. X
  1634. X            /*
  1635. X             * turn an area starting at currow/curcol into
  1636. X             * constants vs expressions - not reversable
  1637. X             */
  1638. X            case 'v':
  1639. X                if (rcqual == 'r')
  1640. X                valueize_area(currow, 0,
  1641. X                          currow + arg - 1, maxcol);
  1642. X                else
  1643. X                valueize_area(0, curcol,
  1644. X                          maxrow, curcol + arg - 1);
  1645. X                modflg = 1;
  1646. X                break;
  1647. X
  1648. X            case 'z':
  1649. X                if (rcqual == 'r')    hiderow(arg);
  1650. X                else        hidecol(arg);
  1651. X                break;
  1652. X
  1653. X            case 's':
  1654. X                /* special case; no repeat count */
  1655. X
  1656. X                if (rcqual == 'r')    rowshow_op();
  1657. X                else        colshow_op();
  1658. X                break;
  1659. X            }
  1660. X            break;
  1661. X            }
  1662. X
  1663. X        case '$':
  1664. X            {
  1665. X            register struct ent *p;
  1666. X
  1667. X            curcol = maxcols - 1;
  1668. X            while (!VALID_CELL(p, currow, curcol) && curcol > 0)
  1669. X            curcol--;
  1670. X            break;
  1671. X            }
  1672. X        case '#':
  1673. X            {
  1674. X            register struct ent *p;
  1675. X
  1676. X            currow = maxrows - 1;
  1677. X            while (!VALID_CELL(p, currow, curcol) && currow > 0)
  1678. X            currow--;
  1679. X            break;
  1680. X            }
  1681. X        case 'w':
  1682. X            {
  1683. X            register struct ent *p;
  1684. X
  1685. X            while (--arg>=0) {
  1686. X            do {
  1687. X                if (curcol < maxcols - 1)
  1688. X                curcol++;
  1689. X                else {
  1690. X                if (currow < maxrows - 1) {
  1691. X                    while(++currow < maxrows - 1 &&
  1692. X                        row_hidden[currow]) /* */;
  1693. X                    curcol = 0;
  1694. X                } else {
  1695. X                    error("At end of table");
  1696. X                    break;
  1697. X                }
  1698. X                }
  1699. X            } while(col_hidden[curcol] ||
  1700. X                !VALID_CELL(p, currow, curcol));
  1701. X            }
  1702. X            break;
  1703. X            }
  1704. X        case 'b':
  1705. X            {
  1706. X            register struct ent *p;
  1707. X
  1708. X            while (--arg>=0) {
  1709. X            do {
  1710. X                if (curcol) 
  1711. X                curcol--;
  1712. X                else {
  1713. X                if (currow) {
  1714. X                    while(--currow &&
  1715. X                    row_hidden[currow]) /* */;
  1716. X                    curcol = maxcols - 1;
  1717. X                } else {
  1718. X                    error ("At start of table");
  1719. X                    break;
  1720. X                }
  1721. X                }
  1722. X            } while(col_hidden[curcol] ||
  1723. X                !VALID_CELL(p, currow, curcol));
  1724. X            }
  1725. X            break;
  1726. X            }
  1727. X        case '^':
  1728. X            currow = 0;
  1729. X            break;
  1730. X        case '?':
  1731. X            help();
  1732. X            break;
  1733. X        case '"':
  1734. X            (void) sprintf (line, "label %s = \"",
  1735. X                    v_name(currow, curcol));
  1736. X            linelim = strlen (line);
  1737. X            insert_mode();
  1738. X            break;
  1739. X        case '<':
  1740. X            (void) sprintf (line, "leftstring %s = \"",
  1741. X                v_name(currow, curcol));
  1742. X            linelim = strlen (line);
  1743. X            insert_mode();
  1744. X            break;
  1745. X        case '>':
  1746. X            (void) sprintf (line, "rightstring %s = \"",
  1747. X               v_name(currow, curcol));
  1748. X            linelim = strlen (line);
  1749. X            insert_mode();
  1750. X            break;
  1751. X        case 'e':
  1752. X            editv (currow, curcol);
  1753. X            edit_mode();
  1754. X            break;
  1755. X        case 'E':
  1756. X            edits (currow, curcol);
  1757. X            edit_mode();
  1758. X            break;
  1759. X        case 'f':
  1760. X            if (arg == 1)
  1761. X            (void) sprintf (line, "format [for column] %s ",
  1762. X                coltoa(curcol));
  1763. X            else {
  1764. X            (void) sprintf(line, "format [for columns] %s:",
  1765. X                coltoa(curcol));
  1766. X            (void) sprintf(line+strlen(line), "%s ",
  1767. X                coltoa(curcol+arg-1));
  1768. X            }
  1769. X            error("Current format is %d %d %d",
  1770. X            fwidth[curcol],precision[curcol],realfmt[curcol]);
  1771. X            linelim = strlen (line);
  1772. X            insert_mode();
  1773. X            break;
  1774. X        case 'F': {
  1775. X            register struct ent *p = *ATBL(tbl, currow, curcol);
  1776. X            if (p && p->format)
  1777. X            {    (void) sprintf(line, "fmt [format] %s \"%s",
  1778. X                   v_name(currow, curcol), p->format);
  1779. X            edit_mode();
  1780. X            }
  1781. X            else
  1782. X            {    (void) sprintf(line, "fmt [format] %s \"",
  1783. X                   v_name(currow, curcol));
  1784. X            insert_mode();
  1785. X            }
  1786. X            linelim = strlen(line);
  1787. X            break;
  1788. X        }
  1789. X        case 'g':
  1790. X            (void) sprintf (line, "goto [v] ");
  1791. X            linelim = strlen (line);
  1792. X            insert_mode();
  1793. X            break;
  1794. X        case 'P':
  1795. X            (void) sprintf (line, "put [\"dest\" range] \"");
  1796. X            if (*curfile)
  1797. X            error ("Default path is \"%s\"",curfile);
  1798. X            linelim = strlen (line);
  1799. X            insert_mode();
  1800. X            break;
  1801. X        case 'M':
  1802. X            (void) sprintf (line, "merge [\"source\"] \"");
  1803. X            linelim = strlen (line);
  1804. X            insert_mode();
  1805. X            break;
  1806. X        case 'R':
  1807. X            if (mdir)
  1808. X            (void) sprintf (line,"merge [\"macro_file\"] \"%s/", mdir);
  1809. X            else
  1810. X            (void) sprintf (line,"merge [\"macro_file\"] \"");
  1811. X            linelim = strlen (line);
  1812. X            insert_mode();
  1813. X            break;
  1814. X        case 'D':
  1815. X            (void) sprintf (line, "mdir [\"macro_directory\"] \"");
  1816. X            linelim = strlen (line);
  1817. X            insert_mode();
  1818. X            break;
  1819. X        case 'G':
  1820. X            (void) sprintf (line, "get [\"source\"] \"");
  1821. X            if (*curfile)
  1822. X            error ("Default file is \"%s\"",curfile);
  1823. X            linelim = strlen (line);
  1824. X            insert_mode();
  1825. X            break;
  1826. X        case 'W':
  1827. X            (void) sprintf (line, "write [\"dest\" range] \"");
  1828. X            linelim = strlen (line);
  1829. X            insert_mode();
  1830. X            break;
  1831. X        case 'S':    /* set options */
  1832. X            (void) sprintf (line, "set ");
  1833. X            error("Options:byrows,bycols,iterations=n,tblstyle=(0|tbl|latex|slatex|tex),rndinfinity");
  1834. X            linelim = strlen (line);
  1835. X            insert_mode();
  1836. X            break;
  1837. X        case 'T':    /* tbl output */
  1838. X            (void) sprintf (line, "tbl [\"dest\" range] \"");
  1839. X            linelim = strlen (line);
  1840. X            insert_mode();
  1841. X            break;
  1842. X        case 'x':
  1843. X            {
  1844. X            register struct ent **pp;
  1845. X            register int c1;
  1846. X
  1847. X            flush_saved();
  1848. X            if(calc_order == BYROWS) {
  1849. X              for (c1 = curcol; arg-- && c1 < maxcols; c1++) {
  1850. X            pp = ATBL(tbl, currow, c1);
  1851. X            if (*pp) {
  1852. X                free_ent(*pp);
  1853. X                *pp = (struct ent *)0;
  1854. X            }
  1855. X              }
  1856. X            }
  1857. X            else {
  1858. X              for (c1 = currow; arg-- && c1 < maxrows; c1++) {
  1859. X            pp = ATBL(tbl, c1, curcol);
  1860. X            if (*pp) {
  1861. X                free_ent(*pp);
  1862. X                *pp = (struct ent *)0;
  1863. X            }
  1864. X              }
  1865. X            }
  1866. X            sync_refs();
  1867. X            modflg++;
  1868. X            FullUpdate++;
  1869. X            }
  1870. X            break;
  1871. X        case 'Q':
  1872. X        case 'q':
  1873. X            running = 0;
  1874. X            break;
  1875. X        case 'h':
  1876. X            backcol(arg);
  1877. X            break;
  1878. X        case 'j':
  1879. X            forwrow(arg);
  1880. X            break;
  1881. X        case 'k':
  1882. X            backrow(arg);
  1883. X            break;
  1884. X        case 'H':
  1885. X            backcol((curcol-stcol+1)+1);
  1886. X            break;
  1887. X#ifdef KEY_NPAGE
  1888. X        case KEY_NPAGE:            /* page precedente */
  1889. X#endif
  1890. X        case 'J':
  1891. X            forwrow(LINES-RESROW-(currow-strow)+1);
  1892. X            break;
  1893. X#ifdef    KEY_PPAGE
  1894. X        case KEY_PPAGE:            /* page suivante */
  1895. X#endif
  1896. X        case 'K':
  1897. X            backrow((currow-strow+1)+3);
  1898. X            break;
  1899. X        case 'L':
  1900. X            forwcol(cols-(curcol-stcol)+1);
  1901. X            break;
  1902. X        case ' ':
  1903. X        case 'l':
  1904. X            forwcol(arg);
  1905. X            break;
  1906. X        case 'm':
  1907. X            savedrow = currow;
  1908. X            savedcol = curcol;
  1909. X            break;
  1910. X        case 'c': {
  1911. X            register struct ent *p = *ATBL(tbl, savedrow, savedcol);
  1912. X            register c1;
  1913. X            register struct ent *n;
  1914. X            if (!p)
  1915. X            break;
  1916. X            FullUpdate++;
  1917. X            modflg++;
  1918. X            for (c1 = curcol; arg-- && c1 < maxcols; c1++) {
  1919. X            n = lookat (currow, c1);
  1920. X            (void) clearent(n);
  1921. X            copyent( n, p, currow - savedrow, c1 - savedcol);
  1922. X            }
  1923. X            break;
  1924. X        }
  1925. X        default:
  1926. X            if ((toascii(c)) != c)
  1927. X            error ("Weird character, decimal %d\n",
  1928. X                (int) c);
  1929. X            else
  1930. X                error ("No such command (%c)", c);
  1931. X            break;
  1932. X        }
  1933. X    edistate = nedistate;
  1934. X    arg = narg;
  1935. X    }                /* while (running) */
  1936. X    inloop = modcheck(" before exiting");
  1937. X    }                /*  while (inloop) */
  1938. X    stopdisp();
  1939. X#ifdef VMS    /* Until VMS "fixes" exit we should say 1 here */
  1940. X    exit(1);
  1941. X#else
  1942. X    exit(0);
  1943. X#endif
  1944. X    /*NOTREACHED*/
  1945. X}
  1946. X
  1947. X/* show the current range (see ^I), we are moving around to define a range */
  1948. Xvoid
  1949. Xstartshow()
  1950. X{
  1951. X    showrange = 1;
  1952. X    showsr = currow;
  1953. X    showsc = curcol;
  1954. X}
  1955. X
  1956. X/* insert the range we defined by moving around the screen, see startshow() */
  1957. Xvoid
  1958. Xshowdr()
  1959. X{
  1960. X    int     minsr, minsc, maxsr, maxsc;
  1961. X
  1962. X    minsr = showsr < currow ? showsr : currow;
  1963. X    minsc = showsc < curcol ? showsc : curcol;
  1964. X    maxsr = showsr > currow ? showsr : currow;
  1965. X    maxsc = showsc > curcol ? showsc : curcol;
  1966. X    (void) sprintf (line+linelim,"%s", r_name(minsr, minsc, maxsr, maxsc));
  1967. X}
  1968. X
  1969. X/* set the calculation order */
  1970. Xvoid
  1971. Xsetorder(i)
  1972. Xint i;
  1973. X{
  1974. X    if((i == BYROWS)||(i == BYCOLS))
  1975. X        calc_order = i;
  1976. X}
  1977. X
  1978. Xvoid
  1979. Xsetauto(i)
  1980. Xint i;
  1981. X{
  1982. X    autocalc = i;
  1983. X}
  1984. X
  1985. Xvoid
  1986. Xsignals()
  1987. X{
  1988. X#ifdef SIGVOID
  1989. X    void quit();
  1990. X    void time_out();
  1991. X    void dump_me();
  1992. X#ifdef    SIGWINCH
  1993. X    void winchg();
  1994. X#endif
  1995. X#else
  1996. X    int quit();
  1997. X    int time_out();
  1998. X    int dump_me();
  1999. X#ifdef    SIGWINCH
  2000. X    int winchg();
  2001. X#endif
  2002. X#endif
  2003. X
  2004. X    (void) signal(SIGINT, SIG_IGN);
  2005. X    (void) signal(SIGQUIT, dump_me);
  2006. X    (void) signal(SIGPIPE, quit);
  2007. X    (void) signal(SIGTERM, quit);
  2008. X    (void) signal(SIGALRM, time_out);
  2009. X    (void) signal(SIGFPE, quit);
  2010. X    (void) signal(SIGBUS, quit);
  2011. X#ifdef    SIGWINCH
  2012. X    (void) signal(SIGWINCH, winchg);
  2013. X#endif
  2014. X}
  2015. X
  2016. X#ifdef    SIGWINCH
  2017. X#ifdef SIGVOID
  2018. Xvoid
  2019. X#else
  2020. Xint
  2021. X#endif
  2022. Xwinchg()
  2023. X{    hitwinch++;
  2024. X}
  2025. X#endif
  2026. X
  2027. X#ifdef SIGVOID
  2028. Xvoid
  2029. X#else
  2030. Xint
  2031. X#endif
  2032. Xquit()
  2033. X{
  2034. X    diesave();
  2035. X    stopdisp();
  2036. X    exit(1);
  2037. X}
  2038. X
  2039. X#ifdef SIGVOID
  2040. Xvoid
  2041. X#else
  2042. Xint
  2043. X#endif
  2044. Xdump_me()
  2045. X{
  2046. X    diesave();
  2047. X    deraw();
  2048. X    abort();
  2049. X}
  2050. X
  2051. X/* try to save the current spreadsheet if we can */
  2052. Xvoid
  2053. Xdiesave()
  2054. X{   char    path[PATHLEN];
  2055. X
  2056. X    if (modcheck(" before Spreadsheet dies") == 1)
  2057. X    {    (void) sprintf(path, "~/%s", SAVENAME);
  2058. X    if (writefile(path, 0, 0, maxrow, maxcol) < 0)
  2059. X    {
  2060. X        (void) sprintf(path, "/tmp/%s", SAVENAME);
  2061. X        if (writefile(path, 0, 0, maxrow, maxcol) < 0)
  2062. X        error("Couldn't save current spreadsheet, Sorry");
  2063. X    }
  2064. X    }
  2065. X}
  2066. X
  2067. X/* check if tbl was modified and ask to save */
  2068. Xint
  2069. Xmodcheck(endstr)
  2070. Xchar *endstr;
  2071. X{
  2072. X    if (modflg && curfile[0]) {
  2073. X    int    yn_ans;
  2074. X    char    lin[100];
  2075. X
  2076. X    (void) sprintf (lin,"File \"%s\" is modified, save%s? ",curfile,endstr);
  2077. X    if ((yn_ans = yn_ask(lin)) < 0)
  2078. X        return(1);
  2079. X    else
  2080. X    if (yn_ans == 1)
  2081. X    {    if (writefile(curfile, 0, 0, maxrow, maxcol) < 0)
  2082. X         return (1);
  2083. X    }
  2084. X    } else if (modflg) {
  2085. X    int    yn_ans;
  2086. X
  2087. X    if ((yn_ans = yn_ask("Do you want a chance to save the data? ")) < 0)
  2088. X        return(1);
  2089. X    else
  2090. X        return(yn_ans);
  2091. X    }
  2092. X    return(0);
  2093. X}
  2094. END_OF_FILE
  2095.   if test 27052 -ne `wc -c <'sc.c'`; then
  2096.     echo shar: \"'sc.c'\" unpacked with wrong size!
  2097.   fi
  2098.   # end of 'sc.c'
  2099. fi
  2100. echo shar: End of archive 4 \(of 7\).
  2101. cp /dev/null ark4isdone
  2102. MISSING=""
  2103. for I in 1 2 3 4 5 6 7 ; do
  2104.     if test ! -f ark${I}isdone ; then
  2105.     MISSING="${MISSING} ${I}"
  2106.     fi
  2107. done
  2108. if test "${MISSING}" = "" ; then
  2109.     echo You have unpacked all 7 archives.
  2110.     rm -f ark[1-9]isdone
  2111. else
  2112.     echo You still must unpack the following archives:
  2113.     echo "        " ${MISSING}
  2114. fi
  2115. exit 0
  2116. exit 0 # Just in case...
  2117. -- 
  2118. Kent Landfield                   INTERNET: kent@sparky.IMD.Sterling.COM
  2119. Sterling Software, IMD           UUCP:     uunet!sparky!kent
  2120. Phone:    (402) 291-8300         FAX:      (402) 291-4362
  2121. Please send comp.sources.misc-related mail to kent@uunet.uu.net.
  2122.