home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / misc / volume20 / sc / part07 < prev    next >
Text File  |  1991-06-05  |  26KB  |  942 lines
  1. Newsgroups: comp.sources.misc
  2. From: Jeff Buhrt <prslnk!buhrt@cs.indiana.edu>
  3. Subject:  v20i041:  sc - The SC Spreadsheet, release 6.16, Part07/07
  4. Message-ID: <1991Jun5.172904.12368@sparky.IMD.Sterling.COM>
  5. X-Md4-Signature: cc484f48731c14dbcb951c230a939d4c
  6. Date: Wed, 5 Jun 1991 17:29:04 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 41
  11. Archive-name: sc/part07
  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:  VMS_NOTES crypt.c psc.doc tutorial.sc vmtbl.c xmalloc.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 7 (of 7)."'
  23. if test -f 'VMS_NOTES' -a "${1}" != "-c" ; then 
  24.   echo shar: Will not clobber existing file \"'VMS_NOTES'\"
  25. else
  26.   echo shar: Extracting \"'VMS_NOTES'\" \(4341 characters\)
  27.   sed "s/^X//" >'VMS_NOTES' <<'END_OF_FILE'
  28. XFrom: ihnp4!gargoyle!oddjob!noao!arizona!naucse!jdc (John Campbell)
  29. XTo: arizona!noao!oddjob!gargoyle!ihnp4!nsc!nscpdc!rgb
  30. XSubject: VMS SC
  31. X
  32. XVMS USERS:
  33. X
  34. XBob Bond has been generous enough to give me free rein in adding what I
  35. Xthink is needed to make SC run on VMS.  Any problems with VMS should be
  36. Xdirected to me--they are not Bob's fault.
  37. X
  38. XThe VMS SC is "SIMPLE" for the most part, except that the arrow keys
  39. X(instead of hjkl) will move you around the cells.  The VMS version of SC
  40. Xwill not interact with the Bourne shell (obviously), which means that CRYPT
  41. Xand EXTERNAL FUNCTIONS will not be available.
  42. X
  43. XIf you have a 'C' compiler and GNU Bison then you should be able to get
  44. XSC running on VMS by following the instructions below.
  45. X
  46. XStep 1:  Get all the files
  47. X
  48. XI've heard of a few sites that can unpack unix shar files directly on
  49. XVMS.  Most people, however, will need access to a unix machine to get
  50. Xthe original distribution unpacked.  At this time you should also build
  51. Xexperres.h and statres.h and perhaps run the man pages off if you need
  52. Xto port the documentation. To build the two "missing" hearder files:
  53. X   sed <gram.y >experres.h -f eres.sed
  54. X   sed <gram.y >statres.h -f sres.sed
  55. X
  56. XStep 2: Cut out BUILD.COM and GETOPT.C
  57. X
  58. XAt the end of this file are two other pieces: BUILD.COM and GETOPT.C.  After
  59. Xyou've moved everything to VMS, cut BUILD.COM and GETOPT.C out of here and
  60. Xput them in the same directory as the rest of the SC distribution.
  61. X
  62. XStep 3: Build it
  63. X
  64. XTheoretically all you now need to do is @BUILD and SC (as well as PSC)
  65. Xwill be running on VMS.  If you have problems feel free to contact me
  66. Xat ...!arizona!naucse!jdc  (or even call at 602-523-6259).
  67. X
  68. X---------------------cut here for BUILD.COM--------------------------
  69. X$! VMS command file to build SC and PSC (requires bison)
  70. X$! SC:
  71. X$ bison -d gram.y
  72. X$ ren gram_tab.c gram.c
  73. X$ cc  /define=("SIMPLE","SIGVOID") sc.c
  74. X$ cc  /define=("SIMPLE","SIGVOID") gram.c
  75. X$ cc  /define=("SIMPLE","SIGVOID") lex.c
  76. X$ cc  /define=("SIMPLE","SIGVOID") interp
  77. X$ cc  /define=("SIMPLE","SIGVOID") cmds
  78. X$ cc  /define=("SIMPLE","SIGVOID") xmalloc
  79. X$ cc  /define=("SIMPLE","SIGVOID") range
  80. X$ cc  /define=("SIMPLE","SIGVOID") help
  81. X$ link sc.obj,lex.obj,gram.obj,interp.obj,cmds.obj,xmalloc.obj,-
  82. X       range.obj,help.obj,sys$library:vaxcrtl.olb/lib
  83. X$ !
  84. X$ ! Create VMS foreign command symbol to test SC
  85. X$ !
  86. X$ sc == "$" + f$logical("SYS$DISK") + f$directory() + "SC.EXE"
  87. X$!
  88. X$! Now PSC
  89. X$!
  90. X$ cc psc.c
  91. X$ cc getopt.c
  92. X$ link psc,getopt,sys$library:vaxcrtl.olb/lib
  93. X$ !
  94. X$ ! Create VMS foreign command symbol to test PSC (Note that
  95. X$ ! PSC reads SYS$INPUT and writes to SYS$OUTPUT, so use
  96. X$ ! DEFINE/USER to redirect.)
  97. X$ !
  98. X$ psc == "$" + f$logical("SYS$DISK") + f$directory() + "PSC.EXE"
  99. X
  100. X---------------------cut here for GETOPT.C------------------------
  101. X/*
  102. X * getopt - get option letter from argv
  103. X *      This software is in the public domain
  104. X *      Originally written by Henry Spencer at the U. of Toronto
  105. X */
  106. X
  107. X#include <stdio.h>
  108. X
  109. Xchar    *optarg;        /* Global argument pointer. */
  110. Xint     optind = 0;     /* Global argv index. */
  111. X
  112. Xstatic char     *scan = NULL;   /* Private scan pointer. */
  113. X
  114. X/* extern char     *index();  obsolete, used strchr (JDC). */
  115. X
  116. Xint
  117. Xgetopt(argc, argv, optstring)
  118. Xint argc;
  119. Xchar *argv[];
  120. Xchar *optstring;
  121. X{
  122. X        register char c;
  123. X        register char *place;
  124. X
  125. X        optarg = NULL;
  126. X
  127. X        if (scan == NULL || *scan == '\0') {
  128. X                if (optind == 0)
  129. X                        optind++;
  130. X
  131. X                if (optind >= argc || argv[optind][0] != '-' || argv[optind][1] == '\0')
  132. X                        return(EOF);
  133. X                if (strcmp(argv[optind], "--")==0) {
  134. X                        optind++;
  135. X                        return(EOF);
  136. X                }
  137. X
  138. X                scan = argv[optind]+1;
  139. X                optind++;
  140. X        }
  141. X
  142. X        c = *scan++;
  143. X        place = strchr(optstring, c);
  144. X
  145. X        if (place == NULL || c == ':') {
  146. X                fprintf(stderr, "%s: unknown option -%c\n", argv[0], c);
  147. X                return('?');
  148. X        }
  149. X
  150. X        place++;
  151. X        if (*place == ':') {
  152. X                if (*scan != '\0') {
  153. X                        optarg = scan;
  154. X                        scan = NULL;
  155. X                } else {
  156. X                        optarg = argv[optind];
  157. X                        optind++;
  158. X                }
  159. X        }
  160. X
  161. X        return(c);
  162. X}
  163. END_OF_FILE
  164.   if test 4341 -ne `wc -c <'VMS_NOTES'`; then
  165.     echo shar: \"'VMS_NOTES'\" unpacked with wrong size!
  166.   fi
  167.   # end of 'VMS_NOTES'
  168. fi
  169. if test -f 'crypt.c' -a "${1}" != "-c" ; then 
  170.   echo shar: Will not clobber existing file \"'crypt.c'\"
  171. else
  172.   echo shar: Extracting \"'crypt.c'\" \(3897 characters\)
  173.   sed "s/^X//" >'crypt.c' <<'END_OF_FILE'
  174. X/*
  175. X * Encryption utilites
  176. X * Bradley Williams    
  177. X * {allegra,ihnp4,uiucdcs,ctvax}!convex!williams
  178. X * $Revision: 6.16 $
  179. X */
  180. X
  181. X#include <stdio.h>
  182. X#include <curses.h>
  183. X
  184. X#if defined(BSD42) || defined(BSD43)
  185. X#include <sys/types.h>
  186. X#include <sys/file.h>
  187. X#else
  188. X#include <fcntl.h>
  189. X#endif
  190. X
  191. X#include "sc.h"
  192. X
  193. Xchar        *strcpy();
  194. Xchar        *getpass();
  195. X
  196. X#ifdef SYSV3
  197. Xvoid exit();
  198. X#endif
  199. X
  200. Xint         Crypt = 0;
  201. X#define MAXKEYWORDSIZE 30
  202. Xchar        KeyWord[MAXKEYWORDSIZE] = {""};
  203. X
  204. Xvoid
  205. Xcreadfile (save, eraseflg)
  206. Xchar *save;
  207. Xint  eraseflg;
  208. X{
  209. X    register FILE *f;
  210. X    int pipefd[2];
  211. X    int fildes;
  212. X    int pid;
  213. X
  214. X    if (eraseflg && strcmp(save, curfile) && modcheck(" first")) return;
  215. X
  216. X    if ((fildes = open(findhome(save), O_RDONLY, 0)) < 0)
  217. X    {
  218. X    error ("Can't read file \"%s\"", save);
  219. X    return;
  220. X    }
  221. X
  222. X    if (eraseflg) erasedb ();
  223. X
  224. X    if (pipe(pipefd) < 0) {
  225. X    error("Can't make pipe to child");
  226. X    return;
  227. X    }
  228. X
  229. X    deraw();
  230. X    (void) strcpy(KeyWord, getpass("Enter key:"));
  231. X    goraw();
  232. X
  233. X    if ((pid=fork()) == 0)              /* if child  */
  234. X    {
  235. X    (void) close (0);          /* close stdin */
  236. X    (void) close (1);          /* close stdout */
  237. X    (void) close (pipefd[0]);      /* close pipe input */
  238. X    (void) dup (fildes);          /* standard in from file */
  239. X    (void) dup (pipefd[1]);          /* connect to pipe */
  240. X    (void) fprintf (stderr, " ");
  241. X    (void) execl (CRYPT_PATH, "crypt", KeyWord, 0);
  242. X
  243. X    exit (-127);
  244. X    }
  245. X    else                  /* else parent */
  246. X    {
  247. X    (void) close (fildes);
  248. X    (void) close (pipefd[1]);      /* close pipe output */
  249. X    if ((f = fdopen (pipefd[0], "r")) == (FILE *)0)
  250. X    {
  251. X        (void) kill (pid, -9);
  252. X        error ("Can't fdopen file \"%s\"", save);
  253. X        (void) close (pipefd[0]);
  254. X        return;
  255. X    }
  256. X    }
  257. X
  258. X    loading++;
  259. X    while (fgets(line,sizeof line,f)) {
  260. X    linelim = 0;
  261. X    if (line[0] != '#') (void) yyparse ();
  262. X    }
  263. X    --loading;
  264. X    (void) fclose (f);
  265. X    (void) close (pipefd[0]);
  266. X    while (pid != wait(&fildes)) /**/;
  267. X    linelim = -1;
  268. X    modflg++;
  269. X    if (eraseflg) {
  270. X    (void) strcpy (curfile, save);
  271. X    modflg = 0;
  272. X    }
  273. X    EvalAll();
  274. X}
  275. X
  276. Xint
  277. Xcwritefile (fname, r0, c0, rn, cn)
  278. Xchar *fname;
  279. Xint r0, c0, rn, cn;
  280. X{
  281. X    register FILE *f;
  282. X    int pipefd[2];
  283. X    int fildes;
  284. X    int pid;
  285. X    char save[PATHLEN];
  286. X    char *fn;
  287. X    char *busave;
  288. X
  289. X    if (*fname == '\0') fname = &curfile[0];
  290. X
  291. X    fn = fname;
  292. X    while (*fn && (*fn == ' '))  /* Skip leading blanks */
  293. X    fn++;
  294. X
  295. X    if ( *fn == '|' ) {
  296. X    error ("Can't have encrypted pipe");
  297. X    return(-1);
  298. X    }
  299. X
  300. X    (void) strcpy(save,fname);
  301. X
  302. X    busave = findhome(save);
  303. X#ifdef DOBACKUPS
  304. X    if (!backup_file(busave) &&
  305. X    (yn_ask("Could not create backup copy, Save anyhow?: (y,n)") != 1))
  306. X        return(0);
  307. X#endif
  308. X    if ((fildes = open (busave, O_TRUNC|O_WRONLY|O_CREAT, 0600)) < 0)
  309. X    {
  310. X    error ("Can't create file \"%s\"", save);
  311. X    return(-1);
  312. X    }
  313. X
  314. X    if (pipe (pipefd) < 0) {
  315. X    error ("Can't make pipe to child\n");
  316. X    return(-1);
  317. X    }
  318. X
  319. X    if (KeyWord[0] == '\0') {
  320. X    deraw();
  321. X    (void) strcpy(KeyWord, getpass("Enter key:"));
  322. X    goraw();
  323. X    }
  324. X
  325. X    if ((pid=fork()) == 0)              /* if child  */
  326. X    {
  327. X    (void) close (0);              /* close stdin */
  328. X    (void) close (1);              /* close stdout */
  329. X    (void) close (pipefd[1]);          /* close pipe output */
  330. X    (void) dup (pipefd[0]);              /* connect to pipe input */
  331. X    (void) dup (fildes);              /* standard out to file */
  332. X    (void) fprintf (stderr, " ");
  333. X    (void) execl (CRYPT_PATH, "crypt", KeyWord, 0);
  334. X    exit (-127);
  335. X    }
  336. X    else                  /* else parent */
  337. X    {
  338. X    (void) close (fildes);
  339. X    (void) close (pipefd[0]);          /* close pipe input */
  340. X    f = fdopen (pipefd[1], "w");
  341. X    if (f == 0)
  342. X    {
  343. X        (void) kill (pid, -9);
  344. X        error ("Can't fdopen file \"%s\"", save);
  345. X        (void) close (pipefd[1]);
  346. X        return(-1);
  347. X    }
  348. X    }
  349. X
  350. X    write_fd(f, r0, c0, rn, cn);
  351. X
  352. X    (void) fclose (f);
  353. X    (void) close (pipefd[1]);
  354. X    while (pid != wait(&fildes)) /**/;
  355. X    (void) strcpy(curfile,save);
  356. X
  357. X    modflg = 0;
  358. X    error ("File \"%s\" written (encrypted).", curfile);
  359. X    return(0);
  360. X}
  361. X
  362. END_OF_FILE
  363.   if test 3897 -ne `wc -c <'crypt.c'`; then
  364.     echo shar: \"'crypt.c'\" unpacked with wrong size!
  365.   fi
  366.   # end of 'crypt.c'
  367. fi
  368. if test -f 'psc.doc' -a "${1}" != "-c" ; then 
  369.   echo shar: Will not clobber existing file \"'psc.doc'\"
  370. else
  371.   echo shar: Extracting \"'psc.doc'\" \(2314 characters\)
  372.   sed "s/^X//" >'psc.doc' <<'END_OF_FILE'
  373. X.\" $Revision $
  374. X.TH PPNAME 1
  375. X.SH NAME
  376. Xppname \- prepare pname files
  377. X.SH SYNOPSIS
  378. X.B ppname
  379. X[
  380. X.I -fLkrSPv
  381. X]
  382. X[
  383. X.I -s cell
  384. X]
  385. X[
  386. X.I -R n
  387. X]
  388. X[
  389. X.I -C n
  390. X]
  391. X[
  392. X.I -n n
  393. X]
  394. X[
  395. X.I -d c
  396. X]
  397. X
  398. X.SH DESCRIPTION
  399. X.I Ppname
  400. Xis used to prepare data for input to the spread sheet calculator
  401. X.I pname(1).
  402. XIt accepts normal ascii data on standard input.  Standard output
  403. Xis a
  404. X.I pname
  405. Xfile.
  406. XWith no options, 
  407. X.I ppname
  408. Xstarts the spread sheet in cell A0.  Strings are right justified.
  409. XAll data on a line is entered on the same row; new input lines
  410. Xcause the output row number to increment by one.  The default delimiters
  411. Xare tab and space.  The column formats are set to one larger
  412. Xthan the number of columns required to hold the largest value
  413. Xin the column.
  414. X
  415. XOptions:
  416. X
  417. X.IP "\-f"
  418. XOmit column width calculations.  This option is for preparing
  419. Xdata to be merged with an existing spreadsheet.  If the option is not
  420. Xspecified, the column widths calculated for the data read by
  421. X.I ppname
  422. Xwill override those already set in the existing spreadsheet.
  423. X
  424. X.IP "\-L"
  425. XLeft justify strings.
  426. X
  427. X.IP "\-k"
  428. XKeep all delimiters.  This option causes the output cell to change on
  429. Xeach new delimiter encountered in the input stream.   The default
  430. Xaction is to condense multiple delimters to one, so that the cell only
  431. Xchanges once per input data item.
  432. X
  433. X.IP "\-r"
  434. XOutput the data by row first then column.  For input consisting of a single
  435. Xcolumn, this
  436. Xoption will result in output of one row with multiple columns
  437. Xinstead of a single
  438. Xcolumn spread sheet.
  439. X
  440. X.IP "\-s cell"
  441. XStart the top left corner of the spread sheet in 
  442. X.I cell.
  443. XFor example, 
  444. X.I "-s B33"
  445. Xwill arrange the output data so that the
  446. Xspread sheet starts in column B, row 33.
  447. X
  448. X.IP "\-R n"
  449. XIncrement by
  450. X.I n 
  451. Xon each new output row.
  452. X
  453. X.IP "\-C n"
  454. XIncrement by
  455. X.I n 
  456. Xon each new output column.
  457. X
  458. X.IP "\-n n"
  459. XOutput 
  460. X.I n
  461. Xrows before advancing to the next column.  This option is used when
  462. Xthe input is arranged in a single column and the spread sheet is to
  463. Xhave multiple columns, each of which is to be length
  464. X.I n.
  465. X
  466. X.IP "\-d c"
  467. XUse the single character
  468. X.I c
  469. Xas the delimiter between input fields.
  470. X
  471. X.IP "\-P"
  472. XPlain numbers only.
  473. XA field is a number only when there is no imbeded [-+eE].
  474. X
  475. X.IP "\-S"
  476. XAll numbers are strings.
  477. X
  478. X.IP "\-v"
  479. XPrint the version of
  480. Xppname
  481. X
  482. X.SH SEE ALSO
  483. Xpname(1)
  484. X
  485. X.SH AUTHOR
  486. X
  487. XRobert Bond
  488. END_OF_FILE
  489.   if test 2314 -ne `wc -c <'psc.doc'`; then
  490.     echo shar: \"'psc.doc'\" unpacked with wrong size!
  491.   fi
  492.   # end of 'psc.doc'
  493. fi
  494. if test -f 'tutorial.sc' -a "${1}" != "-c" ; then 
  495.   echo shar: Will not clobber existing file \"'tutorial.sc'\"
  496. else
  497.   echo shar: Extracting \"'tutorial.sc'\" \(4327 characters\)
  498.   sed "s/^X//" >'tutorial.sc' <<'END_OF_FILE'
  499. X# This data file was generated by the Spreadsheet Calculator.
  500. X# You almost certainly shouldn't edit it.
  501. X
  502. Xdefine "page5" A89
  503. Xdefine "page1" A9
  504. Xdefine "page2" A29
  505. Xdefine "page3" A49
  506. Xdefine "page4" A70
  507. Xleftstring A1 = "This is a brief sc tutorial."
  508. Xleftstring A3 = "Cells are named by their column and row number.  For example,"
  509. Xleftstring A4 = "Cell A4"
  510. Xleftstring B4 = "Cell B4"
  511. Xleftstring C4 = "Cell C4"
  512. Xleftstring A5 = "Cell A5"
  513. Xleftstring A6 = "Cell A6"
  514. Xleftstring C6 = "Cell C6"
  515. Xleftstring A7 = "Cells range from A0 to ZZ(some number depending on free memory)."
  516. Xleftstring A8 = "Cells can also be named by the user.  See 'range names' in the manual."
  517. Xleftstring page1 = "You can move the cursor a couple of different ways:"
  518. Xleftstring A11 = "^n, j and the <DOWN> arrow key go down"
  519. Xleftstring A12 = "^p, k and the <UP> arrow key go up"
  520. Xleftstring A13 = "^b, h and the <LEFT> arrow key go left"
  521. Xleftstring A14 = "^f, l and the <RIGHT> arrow key go right"
  522. Xleftstring A15 = "You can go directly to a cell by typing 'g' and the cell name. "
  523. Xleftstring A16 = "'g c6' will take you to cell c6."
  524. Xleftstring A18 = "Cells can contain numbers, formulas, or text."
  525. Xleftstring A19 = "Most of the cells on this page contain text."
  526. Xleftstring C20 = "<Type 'g page2' to continue>"
  527. Xleftstring A22 = "Cell d22 contains text"
  528. Xleftstring D22 = "Text "
  529. Xleftstring A23 = "Cell d23 contains a number"
  530. Xlet D23 = 123.34
  531. Xleftstring A24 = "Cell d24 contains a formula"
  532. Xlet D24 = D23+88
  533. Xleftstring A26 = "To see what the cell contains, just move the cursor"
  534. Xleftstring A27 = "onto the cell.  The contents will show up on line 1 in the brackets."
  535. Xleftstring page2 = "You can enter data into cells like this:"
  536. Xleftstring B30 = "'<text' enters left justified text."
  537. Xleftstring B31 = "'>text' enters right justified text."
  538. Xleftstring B32 = "'=number' enters a number"
  539. Xleftstring B33 = "'=formula' enters a formula."
  540. Xleftstring A35 = "Try duplicating d22 through d24 in e22 though e24."
  541. Xleftstring A37 = "You erase a cell by typing 'x' with the cursor on the cell."
  542. Xleftstring C40 = "<Type 'g page3' to continue>"
  543. Xleftstring A42 = "Here is a typical use for numbers and formulas:"
  544. Xlet A44 = 10.3
  545. Xlet B44 = 1877.5
  546. Xlet C44 = 234.7
  547. Xlet E44 = @sum(A44:C44)
  548. Xlet A45 = 44.56
  549. Xlet B45 = 44.3
  550. Xlet C45 = -3
  551. Xlet E45 = @sum(A45:C45)
  552. Xlet A46 = 88.74
  553. Xlet B46 = 8000
  554. Xlet C46 = -9
  555. Xlet E46 = @sum(A46:C46)
  556. Xlet A47 = 99.2
  557. Xlet B47 = -88
  558. Xlet C47 = -44.6
  559. Xlet E47 = @sum(A47:C47)
  560. Xlet page3 = @sum(A44:A47)
  561. Xlet B49 = @sum(B44:B47)
  562. Xlet C49 = @sum(C44:C47)
  563. Xlet E49 = @sum(A44:C47)
  564. Xleftstring A51 = "The data is entered in a44 through c47."
  565. Xleftstring A52 = "Cells a49, b49 and c49 sum their respective columns."
  566. Xleftstring A53 = "Cells e44, e45, e46, and e47 sum their respective rows."
  567. Xleftstring A54 = "Cell E49 is a grand total."
  568. Xleftstring A55 = "Try changing some of the data cells and watch the sums change."
  569. Xleftstring A57 = "You can also edit cells by putting the cursor on the cell and typing:"
  570. Xleftstring B58 = "'e' to edit the numeric portion."
  571. Xleftstring B59 = "'E' to edit the string portion."
  572. Xleftstring C60 = "<Type 'g page4' to continue>"
  573. Xleftstring A62 = "Since you are reading this, you know that you can load "
  574. Xleftstring A63 = "a data base from a file by typing the file name as an"
  575. Xleftstring A64 = "argument to the program.  You can also load or save a "
  576. Xleftstring A65 = "data base using the file commands:"
  577. Xleftstring B67 = "'G file'"
  578. Xleftstring C67 = "Gets the data from an sc file."
  579. Xleftstring B68 = "'P file'"
  580. Xleftstring C68 = "Puts the data from the spreadsheet into a file."
  581. Xleftstring page4 = "Try 'P foo.sc' to write this to the file foo.sc"
  582. Xleftstring A71 = "The Get command erases the current spreadsheet.  "
  583. Xleftstring A72 = "To merge a spreadsheet with the one currently in"
  584. Xleftstring A73 = "the machine, use:"
  585. Xleftstring B75 = "'M file'"
  586. Xleftstring C75 = "Merge the data from a saved sc file."
  587. Xleftstring A77 = "You can also get human readable versions of the data"
  588. Xleftstring A78 = "by using the Write command:"
  589. Xleftstring C80 = "<Type 'g page5' to continue>"
  590. Xleftstring A82 = "Try 'W tut.txt' for a clear text version of the tutorial."
  591. Xleftstring A85 = "This is the end of the tutorial.  We have explored"
  592. Xleftstring A86 = "The basic commands.  Much more detail is available"
  593. Xleftstring A87 = "in the man page."
  594. Xleftstring D91 = "GOOD LUCK!"
  595. END_OF_FILE
  596.   if test 4327 -ne `wc -c <'tutorial.sc'`; then
  597.     echo shar: \"'tutorial.sc'\" unpacked with wrong size!
  598.   fi
  599.   # end of 'tutorial.sc'
  600. fi
  601. if test -f 'vmtbl.c' -a "${1}" != "-c" ; then 
  602.   echo shar: Will not clobber existing file \"'vmtbl.c'\"
  603. else
  604.   echo shar: Extracting \"'vmtbl.c'\" \(5294 characters\)
  605.   sed "s/^X//" >'vmtbl.c' <<'END_OF_FILE'
  606. X/*    SC    A Spreadsheet Calculator
  607. X *        Spreadsheet 'tbl' creation
  608. X *
  609. X *        original by James Gosling, September 1982
  610. X *        modifications by Mark Weiser and Bruce Israel,
  611. X *            University of Maryland
  612. X *
  613. X *              More mods Robert Bond, 12/86
  614. X *        More mods by Alan Silverstein, 3-4/88, see list of changes.
  615. X *        Currently supported by sequent!sawmill!buhrt (Jeff Buhrt)
  616. X *        $Revision: 6.16 $
  617. X *
  618. X */
  619. X#ifdef PSC
  620. X# include <stdio.h>
  621. X#else /* PSC */
  622. X# include <curses.h>
  623. X#endif /* PSC */
  624. X
  625. X#include "sc.h"
  626. X
  627. X/*
  628. X * check to see if *rowp && *colp are currently allocated, if not expand the
  629. X * current size if we can.
  630. X */
  631. X#ifndef PSC
  632. Xvoid
  633. Xcheckbounds(rowp, colp)
  634. Xint    *rowp;
  635. Xint    *colp;
  636. X{
  637. X    if (*rowp < 0)
  638. X        *rowp = 0;
  639. X    else if (*rowp >= maxrows)
  640. X    {    if (*colp >= maxcols)
  641. X        {    if (!growtbl(GROWBOTH, *rowp, *colp))
  642. X            {    *rowp = maxrows -1;
  643. X                *colp = maxcols -1;
  644. X            }
  645. X            return;
  646. X        }
  647. X        else
  648. X        {    if (!growtbl(GROWROW, *rowp, 0))
  649. X                *rowp = maxrows-1;
  650. X            return;
  651. X        }
  652. X    }
  653. X    if (*colp < 0) 
  654. X        *colp = 0;
  655. X    else if (*colp >= maxcols)
  656. X    {    if (!growtbl(GROWCOL, 0, *colp))
  657. X            *colp = maxcols-1;
  658. X    }
  659. X}
  660. X#endif /* !PSC */
  661. X    
  662. X/* xrealloc will just xmalloc if oldptr is == NULL */
  663. X#define GROWALLOC(newptr, oldptr, nelem, type, msg) \
  664. X    newptr = (type *)xrealloc((char *)oldptr, \
  665. X                     (unsigned)(nelem*sizeof(type))); \
  666. X    if (newptr == (type *)NULL) \
  667. X    {   error(msg); \
  668. X        return(FALSE); \
  669. X    } \
  670. X    oldptr = newptr /* wait incase we can't alloc */
  671. X
  672. Xstatic    char    nolonger[] = "The table can't be any longer";
  673. Xstatic    char    nowider[] = "The table can't be any wider";
  674. X
  675. X/*
  676. X * grow the main && auxiliary tables (reset maxrows/maxcols as needed)
  677. X * toprow &&/|| topcol tell us a better guess of how big to become.
  678. X * we return TRUE if we could grow, FALSE if not....
  679. X */
  680. Xint
  681. Xgrowtbl(rowcol, toprow, topcol)
  682. Xint    rowcol;
  683. Xint    toprow, topcol;
  684. X{
  685. X    struct ent ***tbl2;
  686. X    struct ent ** nullit;
  687. X    int    cnt;
  688. X    int    *fwidth2;
  689. X    int    *precision2;
  690. X    int     *realfmt2;
  691. X    char    *col_hidden2;
  692. X    char    *row_hidden2;
  693. X    int    newrows, newcols;
  694. X    int    i;
  695. X
  696. X#ifndef PSC
  697. X    newrows = maxrows;
  698. X#endif /* !PSC */
  699. X
  700. X    newcols = maxcols;
  701. X    if (rowcol == GROWNEW)
  702. X    {
  703. X#ifndef PSC
  704. X        maxrows = toprow = 0;
  705. X        /* when we first start up, fill the screen w/ cells */
  706. X        {    int startval;
  707. X            startval = LINES - RESROW;
  708. X            newrows = startval > MINROWS ? startval : MINROWS;
  709. X            startval = ((COLS) - RESCOL) / DEFWIDTH;
  710. X            newcols = startval > MINCOLS ? startval : MINCOLS;
  711. X        }
  712. X#else
  713. X        newcols = MINCOLS;
  714. X#endif /* !PSC */
  715. X        maxcols = topcol = 0;
  716. X    }
  717. X#ifndef PSC
  718. X    /* set how much to grow */
  719. X    if ((rowcol == GROWROW) || (rowcol == GROWBOTH))
  720. X    {    if (toprow > maxrows)
  721. X            newrows = GROWAMT + toprow;
  722. X        else
  723. X            newrows += GROWAMT;
  724. X    }
  725. X#endif /* !PSC */
  726. X    if ((rowcol == GROWCOL) || (rowcol == GROWBOTH))
  727. X    {    if ((rowcol == GROWCOL) && ((maxcols == ABSMAXCOLS) ||
  728. X                    (topcol >= ABSMAXCOLS)))
  729. X        {    error(nowider);
  730. X            return(FALSE);
  731. X        }
  732. X
  733. X        if (topcol > maxcols)
  734. X            newcols = GROWAMT + topcol;
  735. X        else
  736. X            newcols += GROWAMT;
  737. X
  738. X        if (newcols > ABSMAXCOLS)
  739. X            newcols = ABSMAXCOLS;
  740. X    }
  741. X
  742. X#ifndef PSC
  743. X    if ((rowcol == GROWROW) || (rowcol == GROWBOTH) || (rowcol == GROWNEW))
  744. X    {
  745. X        struct ent *** lnullit;
  746. X        int    lcnt;
  747. X
  748. X        GROWALLOC(row_hidden2, row_hidden, newrows, char, nolonger);
  749. X        memset(row_hidden+maxrows, 0, (newrows-maxrows)*sizeof(char));
  750. X
  751. X        /*
  752. X         * alloc tbl row pointers, per net.lang.c, calloc does not
  753. X         * necessarily fill in NULL pointers
  754. X         */
  755. X        GROWALLOC(tbl2, tbl, newrows, struct ent **, nolonger);
  756. X        for(lnullit = tbl+maxrows, lcnt = 0; lcnt < newrows-maxrows;
  757. X                            lcnt++, lnullit++)
  758. X            *lnullit = (struct ent **)NULL;
  759. X/*        memset(tbl+maxrows, (char *)NULL, (newrows-maxrows)*(sizeof(struct ent **)));*/
  760. X    }
  761. X#endif /* !PSC */
  762. X
  763. X    if ((rowcol == GROWCOL) || (rowcol == GROWBOTH) || (rowcol == GROWNEW))
  764. X    {
  765. X        GROWALLOC(fwidth2, fwidth, newcols, int, nowider);
  766. X        GROWALLOC(precision2, precision, newcols, int, nowider);
  767. X        GROWALLOC(realfmt2, realfmt, newcols, int, nowider);
  768. X#ifdef PSC
  769. X        memset(fwidth+maxcols, 0, (newcols-maxcols)*sizeof(int));
  770. X        memset(precision+maxcols, 0, (newcols-maxcols)*sizeof(int));
  771. X        memset(realfmt+maxcols, 0, (newcols-maxcols)*sizeof(int));
  772. X    }
  773. X#else
  774. X        GROWALLOC(col_hidden2, col_hidden, newcols, char, nowider);
  775. X        memset(col_hidden+maxcols, 0, (newcols-maxcols)*sizeof(char));
  776. X        for (i = maxcols; i < newcols; i++) {
  777. X            fwidth[i] = DEFWIDTH;
  778. X            precision[i] = DEFPREC;
  779. X            realfmt[i]= DEFREFMT;
  780. X        }
  781. X
  782. X        /* [re]alloc the space for each row */
  783. X        for (i = 0; i < maxrows; i++)
  784. X        {
  785. X            if ((tbl[i] = (struct ent **)xrealloc((char *)tbl[i],
  786. X            (unsigned)(newcols * sizeof(struct ent **)))) == (struct ent **)0)
  787. X            {    error(nowider);
  788. X                return(FALSE);
  789. X            }
  790. X        for(nullit = ATBL(tbl, i, maxcols), cnt = 0;
  791. X                cnt < newcols-maxcols; cnt++, nullit++)
  792. X            *nullit = (struct ent *)NULL;
  793. X/*        memset((char *)ATBL(tbl,i, maxcols), 0,
  794. X               (newcols-maxcols)*sizeof(struct ent **));
  795. X*/               
  796. X        }
  797. X    }
  798. X    else
  799. X        i = maxrows;
  800. X
  801. X    /* fill in the bottom of the table */
  802. X    for (; i < newrows; i++)
  803. X    {    if ((tbl[i] = (struct ent **)xmalloc((unsigned)(newcols *
  804. X                sizeof(struct ent **)))) == (struct ent **)0)
  805. X        {    error(nowider);
  806. X            return(FALSE);
  807. X        }
  808. X        for(nullit = tbl[i], cnt = 0; cnt < newcols; cnt++, nullit++)
  809. X            *nullit = (struct ent *)NULL;
  810. X/*        memset((char *)tbl[i], 0, newcols*sizeof(struct ent **));*/
  811. X    }
  812. X
  813. X    FullUpdate++;
  814. X    maxrows = newrows;
  815. X#endif /* PSC */
  816. X
  817. X    maxcols = newcols;
  818. X    return(TRUE);
  819. X}
  820. END_OF_FILE
  821.   if test 5294 -ne `wc -c <'vmtbl.c'`; then
  822.     echo shar: \"'vmtbl.c'\" unpacked with wrong size!
  823.   fi
  824.   # end of 'vmtbl.c'
  825. fi
  826. if test -f 'xmalloc.c' -a "${1}" != "-c" ; then 
  827.   echo shar: Will not clobber existing file \"'xmalloc.c'\"
  828. else
  829.   echo shar: Extracting \"'xmalloc.c'\" \(1356 characters\)
  830.   sed "s/^X//" >'xmalloc.c' <<'END_OF_FILE'
  831. X/*
  832. X * A safer saner malloc, for careless programmers
  833. X * $Revision: 6.16 $
  834. X */
  835. X
  836. X#include <stdio.h>
  837. X#include <curses.h>
  838. X#include "sc.h"
  839. X
  840. Xextern    char *malloc();
  841. Xextern    char *realloc();
  842. Xextern    void free();
  843. Xvoid    fatal();
  844. X
  845. X#ifdef SYSV3
  846. Xextern void free();
  847. Xextern void exit();
  848. X#endif
  849. X
  850. X#define    MAGIC    (double)1234567890.1234456789
  851. X
  852. Xchar *
  853. Xxmalloc(n)
  854. Xunsigned n;
  855. X{
  856. X    register char *ptr;
  857. X
  858. X    if ((ptr = malloc(n + sizeof(double))) == NULL)
  859. X        fatal("xmalloc: no memory");
  860. X    *((double *) ptr) = MAGIC;        /* magic number */
  861. X    return(ptr + sizeof(double));
  862. X}
  863. X
  864. X/* we make sure realloc will do a malloc if needed */
  865. Xchar *
  866. Xxrealloc(ptr, n)
  867. Xchar    *ptr;
  868. Xunsigned n;
  869. X{
  870. X    if (ptr == NULL)
  871. X        return(xmalloc(n));
  872. X
  873. X    ptr -= sizeof(double);
  874. X    if (*((double *) ptr) != MAGIC)
  875. X        fatal("xrealloc: storage not xmalloc'ed");
  876. X
  877. X    if ((ptr = realloc(ptr, n + sizeof(double))) == NULL)
  878. X        fatal("xmalloc: no memory");
  879. X    *((double *) ptr) = MAGIC;        /* magic number */
  880. X    return(ptr + sizeof(double));
  881. X}
  882. X
  883. Xvoid
  884. Xxfree(p)
  885. Xchar *p;
  886. X{
  887. X    if (p == NULL)
  888. X        fatal("xfree: NULL");
  889. X    p -= sizeof(double);
  890. X    if (*((double *) p) != MAGIC)
  891. X        fatal("xfree: storage not malloc'ed");
  892. X    free(p);
  893. X}
  894. X
  895. X#ifdef PSC
  896. Xvoid
  897. Xfatal(str)
  898. Xchar *str;
  899. X{
  900. X    (void) fprintf(stderr,"%s\n", str);
  901. X    exit(1);
  902. X}
  903. X#else
  904. Xvoid
  905. Xfatal(str)
  906. Xchar *str;
  907. X{
  908. X    deraw();
  909. X    (void) fprintf(stderr,"%s\n", str);
  910. X    diesave();
  911. X    exit(1);
  912. X}
  913. X#endif /* PSC */
  914. END_OF_FILE
  915.   if test 1356 -ne `wc -c <'xmalloc.c'`; then
  916.     echo shar: \"'xmalloc.c'\" unpacked with wrong size!
  917.   fi
  918.   # end of 'xmalloc.c'
  919. fi
  920. echo shar: End of archive 7 \(of 7\).
  921. cp /dev/null ark7isdone
  922. MISSING=""
  923. for I in 1 2 3 4 5 6 7 ; do
  924.     if test ! -f ark${I}isdone ; then
  925.     MISSING="${MISSING} ${I}"
  926.     fi
  927. done
  928. if test "${MISSING}" = "" ; then
  929.     echo You have unpacked all 7 archives.
  930.     rm -f ark[1-9]isdone
  931. else
  932.     echo You still must unpack the following archives:
  933.     echo "        " ${MISSING}
  934. fi
  935. exit 0
  936. exit 0 # Just in case...
  937. -- 
  938. Kent Landfield                   INTERNET: kent@sparky.IMD.Sterling.COM
  939. Sterling Software, IMD           UUCP:     uunet!sparky!kent
  940. Phone:    (402) 291-8300         FAX:      (402) 291-4362
  941. Please send comp.sources.misc-related mail to kent@uunet.uu.net.
  942.