home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / altsrcs / 3 / 3499 < prev    next >
Internet Message Format  |  1991-06-19  |  56KB
  1. From: pgf@cayman.COM (Paul Fox)
  2. Newsgroups: alt.sources
  3. Subject: Vile 13/17 - vi feel-alike (multi-window)
  4. Message-ID: <4532@cayman.COM>
  5. Date: 7 Jun 91 22:10:09 GMT
  6.  
  7. #!/bin/sh
  8. # this is vileshar.13 (part 13 of Vile)
  9. # do not concatenate these parts, unpack them in order with /bin/sh
  10. # file shorten/COPYING continued
  11. #
  12. if test ! -r _shar_seq_.tmp; then
  13.     echo 'Please unpack part 1 first!'
  14.     exit 1
  15. fi
  16. (read Scheck
  17.  if test "$Scheck" != 13; then
  18.     echo Please unpack part "$Scheck" next!
  19.     exit 1
  20.  else
  21.     exit 0
  22.  fi
  23. ) < _shar_seq_.tmp || exit 1
  24. echo 'x - continuing file shorten/COPYING'
  25. sed 's/^X//' << 'SHAR_EOF' >> 'shorten/COPYING' &&
  26. for the physical act of transferring a copy.
  27. X
  28. X  2. You may modify your copy or copies of GNU Emacs source code or
  29. any portion of it, and copy and distribute such modifications under
  30. the terms of Paragraph 1 above, provided that you also do the following:
  31. X
  32. X    a) cause the modified files to carry prominent notices stating
  33. X    that you changed the files and the date of any change; and
  34. X
  35. X    b) cause the whole of any work that you distribute or publish,
  36. X    that in whole or in part contains or is a derivative of GNU Emacs
  37. X    or any part thereof, to be licensed at no charge to all third
  38. X    parties on terms identical to those contained in this License
  39. X    Agreement (except that you may choose to grant more extensive
  40. X    warranty protection to some or all third parties, at your option).
  41. X
  42. X    c) if the modified program serves as a text editor, cause it when
  43. X    started running in the simplest and usual way, to print an
  44. X    announcement including a valid copyright notice "Copyright (C)
  45. X    1988 Free Software Foundation, Inc." (or with the year that is
  46. X    appropriate), saying that there is no warranty (or else, saying
  47. X    that you provide a warranty) and that users may redistribute the
  48. X    program under these conditions, and telling the user how to view a
  49. X    copy of this License Agreement.
  50. X
  51. X    d) You may charge a distribution fee for the physical act of
  52. X    transferring a copy, and you may at your option offer warranty
  53. X    protection in exchange for a fee.
  54. X
  55. Mere aggregation of another unrelated program with this program (or its
  56. derivative) on a volume of a storage or distribution medium does not bring
  57. the other program under the scope of these terms.
  58. X
  59. X  3. You may copy and distribute GNU Emacs (or a portion or derivative of it,
  60. under Paragraph 2) in object code or executable form under the terms of
  61. Paragraphs 1 and 2 above provided that you also do one of the following:
  62. X
  63. X    a) accompany it with the complete corresponding machine-readable
  64. X    source code, which must be distributed under the terms of
  65. X    Paragraphs 1 and 2 above; or,
  66. X
  67. X    b) accompany it with a written offer, valid for at least three
  68. X    years, to give any third party free (except for a nominal
  69. X    shipping charge) a complete machine-readable copy of the
  70. X    corresponding source code, to be distributed under the terms of
  71. X    Paragraphs 1 and 2 above; or,
  72. X
  73. X    c) accompany it with the information you received as to where the
  74. X    corresponding source code may be obtained.  (This alternative is
  75. X    allowed only for noncommercial distribution and only if you
  76. X    received the program in object code or executable form alone.)
  77. X
  78. For an executable file, complete source code means all the source code for
  79. all modules it contains; but, as a special exception, it need not include
  80. source code for modules which are standard libraries that accompany the
  81. operating system on which the executable file runs.
  82. X
  83. X  4. You may not copy, sublicense, distribute or transfer GNU Emacs
  84. except as expressly provided under this License Agreement.  Any attempt
  85. otherwise to copy, sublicense, distribute or transfer GNU Emacs is void and
  86. your rights to use GNU Emacs under this License agreement shall be
  87. automatically terminated.  However, parties who have received computer
  88. software programs from you with this License Agreement will not have
  89. their licenses terminated so long as such parties remain in full compliance.
  90. X
  91. X  5. If you wish to incorporate parts of GNU Emacs into other free programs
  92. whose distribution conditions are different, write to the Free Software
  93. Foundation.  We have not yet worked out a simple rule that can be stated
  94. here, but we will often permit this.  We will be guided by the two goals of
  95. preserving the free status of all derivatives of our free software and of
  96. promoting the sharing and reuse of software.
  97. X
  98. Your comments and suggestions about our licensing policies and our
  99. software are welcome!  Please contact the Free Software Foundation, Inc.,
  100. 675 Mass Ave, Cambridge, MA 02139, or call (617) 876-3296.
  101. X
  102. X               NO WARRANTY
  103. X
  104. X  BECAUSE GNU EMACS IS LICENSED FREE OF CHARGE, WE PROVIDE ABSOLUTELY
  105. NO WARRANTY, TO THE EXTENT PERMITTED BY APPLICABLE STATE LAW.  EXCEPT
  106. WHEN OTHERWISE STATED IN WRITING, FREE SOFTWARE FOUNDATION, INC,
  107. RICHARD M. STALLMAN AND/OR OTHER PARTIES PROVIDE GNU EMACS "AS IS"
  108. WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
  109. BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
  110. FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY
  111. AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE GNU EMACS
  112. PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY
  113. SERVICING, REPAIR OR CORRECTION.
  114. X
  115. X IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW WILL FREE SOFTWARE
  116. FOUNDATION, INC., RICHARD M. STALLMAN, AND/OR ANY OTHER PARTY WHO MAY
  117. MODIFY AND REDISTRIBUTE GNU EMACS AS PERMITTED ABOVE, BE LIABLE TO YOU
  118. FOR DAMAGES, INCLUDING ANY LOST PROFITS, LOST MONIES, OR OTHER
  119. SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR
  120. INABILITY TO USE (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA
  121. BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY THIRD PARTIES OR A
  122. FAILURE OF THE PROGRAM TO OPERATE WITH PROGRAMS NOT DISTRIBUTED BY
  123. FREE SOFTWARE FOUNDATION, INC.) THE PROGRAM, EVEN IF YOU HAVE BEEN
  124. ADVISED OF THE POSSIBILITY OF SUCH DAMAGES, OR FOR ANY CLAIM BY ANY
  125. OTHER PARTY.
  126. SHAR_EOF
  127. echo 'File shorten/COPYING is complete' &&
  128. chmod 0444 shorten/COPYING ||
  129. echo 'restore of shorten/COPYING failed'
  130. Wc_c="`wc -c < 'shorten/COPYING'`"
  131. test 7910 -eq "$Wc_c" ||
  132.     echo 'shorten/COPYING: original size 7910, current size' "$Wc_c"
  133. # ============= shorten/defines.c ==============
  134. echo 'x - extracting shorten/defines.c (Text)'
  135. sed 's/^X//' << 'SHAR_EOF' > 'shorten/defines.c' &&
  136. #include <stdio.h>
  137. X
  138. int count;
  139. X
  140. main ()
  141. {
  142. X    char buffer[512];
  143. X
  144. X    while (gets (buffer))
  145. X      {
  146. X    printf ("#define %s zz%4.4dzz\n", buffer, count++);
  147. X      }
  148. X    return (0);
  149. }
  150. SHAR_EOF
  151. chmod 0444 shorten/defines.c ||
  152. echo 'restore of shorten/defines.c failed'
  153. Wc_c="`wc -c < 'shorten/defines.c'`"
  154. test 178 -eq "$Wc_c" ||
  155.     echo 'shorten/defines.c: original size 178, current size' "$Wc_c"
  156. # ============= shorten/dups.c ==============
  157. echo 'x - extracting shorten/dups.c (Text)'
  158. sed 's/^X//' << 'SHAR_EOF' > 'shorten/dups.c' &&
  159. /*
  160. X *    Quick and dirty program to select adjacent records that are common
  161. X *    in the first <arg> character positions.
  162. X *
  163. X */
  164. X 
  165. #include <stdio.h>
  166. X
  167. #define MAXSIZE 512
  168. X
  169. char ping[MAXSIZE];
  170. char pong[MAXSIZE];
  171. X
  172. int flipflop = 0;
  173. int size = MAXSIZE-1;
  174. X
  175. main (argc, argv)
  176. X     int argc;
  177. X     char *argv[];
  178. {
  179. X    register int index;
  180. X    char *newbuf();
  181. X    
  182. X    if (argc == 2)
  183. X      {
  184. X    size = atoi (argv[1]);
  185. X      }
  186. X    while (newbuf() != NULL)
  187. X      {
  188. X    for (index=0; index < size; index++)
  189. X      {
  190. X        if (ping[index] != pong[index])
  191. X          {
  192. X        break;
  193. X          }
  194. X      }
  195. X    if (index == size)
  196. X      {
  197. X        printf ("%s\n", ping);
  198. X        printf ("%s\n", pong);
  199. X      }
  200. X      }
  201. X    return (0);
  202. }
  203. X
  204. char *
  205. newbuf ()
  206. {
  207. X  char *bufp;
  208. X
  209. X  if (flipflop)
  210. X    {
  211. X      bufp = ping;
  212. X      flipflop = 0;
  213. X    }
  214. X  else
  215. X    {
  216. X      bufp = pong;
  217. X      flipflop = 1;
  218. X    }
  219. X  return (gets (bufp));
  220. }
  221. SHAR_EOF
  222. chmod 0444 shorten/dups.c ||
  223. echo 'restore of shorten/dups.c failed'
  224. Wc_c="`wc -c < 'shorten/dups.c'`"
  225. test 857 -eq "$Wc_c" ||
  226.     echo 'shorten/dups.c: original size 857, current size' "$Wc_c"
  227. # ============= shorten/header.h ==============
  228. echo 'x - extracting shorten/header.h (Text)'
  229. sed 's/^X//' << 'SHAR_EOF' > 'shorten/header.h' &&
  230. /* Header file to remap longnames to shortnames.  Note that not
  231. X   all cpp's support longnames.  In particular, most pre 5.2 UniSoft
  232. X   ports only support 16 unique characters.  To bootstrap GNU emacs
  233. X   to a 5.0 UniPlus+ system I had to port the 5.2 cpp (with FLEXNAMES)
  234. X   to the development system.  This was about a 1 hour job with sources.
  235. X   Alternatively, m4 can probably be used but this is not as clean and
  236. X   requires some changes to the default make rules (add rule to go from
  237. X   a ".cm4" file to a ".c" file and rule to go from a ".hm4" file to
  238. X   a ".h" file.  There are too many changes for sed to handle in a single
  239. X   pass.    Fred Fish, UniSoft Systems. */
  240. SHAR_EOF
  241. chmod 0444 shorten/header.h ||
  242. echo 'restore of shorten/header.h failed'
  243. Wc_c="`wc -c < 'shorten/header.h'`"
  244. test 674 -eq "$Wc_c" ||
  245.     echo 'shorten/header.h: original size 674, current size' "$Wc_c"
  246. # ============= shorten/names.c ==============
  247. echo 'x - extracting shorten/names.c (Text)'
  248. sed 's/^X//' << 'SHAR_EOF' > 'shorten/names.c' &&
  249. /*
  250. X *    A quick and dirty C program to spit out possible identifiers
  251. X *    from a stream of *.c and *.h files.  Takes a single parameter
  252. X *    which specifies the minimum length of an identifier to be
  253. X *    extracted.
  254. X *
  255. X */
  256. X 
  257. #include <stdio.h>
  258. #include <ctype.h>
  259. X
  260. #define FIRSTCHAR(a) (isalpha(a) || (a)=='_')
  261. #define OTHERCHAR(a) (FIRSTCHAR(a) || isdigit(a))
  262. #define TRUE 1
  263. #define FALSE 0
  264. X
  265. int size = 0;
  266. char buffer[512];
  267. char *bp = buffer;
  268. X
  269. main (argc, argv)
  270. X     int argc;
  271. X     char *argv[];
  272. {
  273. X  register int ch;
  274. X  register int spitout;
  275. X  register int eating_comment;
  276. X
  277. X  if (argc == 2)
  278. X    {
  279. X      size = atoi (argv[1]);
  280. X    }
  281. X  spitout = FALSE;
  282. X  eating_comment = FALSE;
  283. X  while ((ch = getchar()) != EOF)
  284. X    {
  285. X      if (ch == '/')
  286. X    {
  287. X      if ((ch = getchar()) == EOF)
  288. X        {
  289. X          fprintf (stderr, "unexpected EOF!\n");
  290. X          exit (1);
  291. X        }
  292. X      else
  293. X        {
  294. X          if (ch == '*')
  295. X        {
  296. X          eating_comment = TRUE;
  297. X        }
  298. X          else
  299. X        {
  300. X          ungetc (ch, stdin);
  301. X        }
  302. X        }
  303. X    }
  304. X      else if (eating_comment && ch == '*')
  305. X    {
  306. X      if ((ch = getchar()) == EOF)
  307. X        {
  308. X          fprintf (stderr, "unexpected EOF!\n");
  309. X          exit (1);
  310. X        }
  311. X      else
  312. X        {
  313. X          if (ch == '/')
  314. X        {
  315. X          eating_comment = FALSE;
  316. X        }
  317. X          else
  318. X        {
  319. X          ungetc (ch, stdin);
  320. X        }
  321. X        }
  322. X    }
  323. X      else if (!eating_comment)
  324. X    {
  325. X      if (!spitout && FIRSTCHAR(ch))
  326. X        {
  327. X          spitout = TRUE;
  328. X          *bp++ = ch;
  329. X        }
  330. X      else if (spitout && OTHERCHAR(ch))
  331. X        {
  332. X          *bp++ = ch;
  333. X        }
  334. X      else if (spitout)
  335. X        {
  336. X          *bp++ = '\000';
  337. X          bp = buffer;
  338. X          if (strlen (bp) >= size)
  339. X        {
  340. X          printf ("%s\n", bp);
  341. X        }
  342. X          spitout = FALSE;
  343. X        }
  344. X    }
  345. X    }
  346. X  return (0);
  347. }
  348. SHAR_EOF
  349. chmod 0444 shorten/names.c ||
  350. echo 'restore of shorten/names.c failed'
  351. Wc_c="`wc -c < 'shorten/names.c'`"
  352. test 1637 -eq "$Wc_c" ||
  353.     echo 'shorten/names.c: original size 1637, current size' "$Wc_c"
  354. # ============= shorten/reserved ==============
  355. echo 'x - extracting shorten/reserved (Text)'
  356. sed 's/^X//' << 'SHAR_EOF' > 'shorten/reserved' &&
  357. int
  358. char
  359. float
  360. double
  361. struct
  362. union
  363. long
  364. short
  365. unsigned
  366. auto
  367. extern
  368. register
  369. typedef
  370. static
  371. goto
  372. return
  373. sizeof
  374. break
  375. continue
  376. if
  377. else
  378. for
  379. do
  380. while
  381. switch
  382. case
  383. default
  384. entry
  385. include
  386. define
  387. defined
  388. undef
  389. undefined
  390. undefine
  391. SHAR_EOF
  392. chmod 0444 shorten/reserved ||
  393. echo 'restore of shorten/reserved failed'
  394. Wc_c="`wc -c < 'shorten/reserved'`"
  395. test 220 -eq "$Wc_c" ||
  396.     echo 'shorten/reserved: original size 220, current size' "$Wc_c"
  397. # ============= shorten/special ==============
  398. echo 'x - extracting shorten/special (Text)'
  399. sed 's/^X//' << 'SHAR_EOF' > 'shorten/special' &&
  400. SHAR_EOF
  401. chmod 0444 shorten/special ||
  402. echo 'restore of shorten/special failed'
  403. Wc_c="`wc -c < 'shorten/special'`"
  404. test 0 -eq "$Wc_c" ||
  405.     echo 'shorten/special: original size 0, current size' "$Wc_c"
  406. # ============= spawn.c ==============
  407. echo 'x - extracting spawn.c (Text)'
  408. sed 's/^X//' << 'SHAR_EOF' > 'spawn.c' &&
  409. /*    Spawn:    various DOS access commands
  410. X        for MicroEMACS
  411. */
  412. X
  413. #include        <stdio.h>
  414. #include    "estruct.h"
  415. #include        "edef.h"
  416. #if BSD | USG
  417. #include    <sys/types.h>
  418. #include    <sys/stat.h>
  419. #endif
  420. X
  421. #if     AMIGA
  422. #define  NEW   1006L
  423. #endif
  424. X
  425. #if        ST520 & MEGAMAX
  426. #include <osbind.h>
  427. #include <string.h>
  428. #define LOAD_EXEC 0     /* load and execute the program */
  429. char    *STcmd,        /* the command filename & path  */
  430. X    *STargs,    /* command args (if any)        */
  431. X    *STenv,        /* environment                  */
  432. X    *STwork;    /* work area            */
  433. #endif
  434. X
  435. #if     VMS
  436. #define EFN     0                               /* Event flag.          */
  437. X
  438. #include        <ssdef.h>                       /* Random headers.      */
  439. #include        <stsdef.h>
  440. #include        <descrip.h>
  441. #include        <iodef.h>
  442. X
  443. extern  int     oldmode[3];                     /* In "termio.c"        */
  444. extern  int     newmode[3];                     /* In "termio.c"        */
  445. extern  short   iochan;                         /* In "termio.c"        */
  446. #endif
  447. X
  448. #if     UNIX
  449. #include        <signal.h>
  450. #include        <string.h>
  451. #endif
  452. X
  453. #if    MSDOS & (MSC | TURBO)
  454. #include    <process.h>
  455. #endif
  456. X
  457. /*
  458. X * Create a subjob with a copy of the command intrepreter in it. When the
  459. X * command interpreter exits, mark the screen as garbage so that you do a full
  460. X * repaint. The message at the start in VMS puts out a newline.
  461. X * Under some (unknown) condition, you don't get one free when DCL starts up.
  462. X */
  463. spawncli(f, n)
  464. {
  465. #if     UNIX
  466. # if     NeWS
  467. X    mlwrite("Not availible under NeWS");
  468. X    return(FALSE);
  469. # else
  470. X        register char *cp;
  471. X        char    *getenv();
  472. X        
  473. X        movecursor(term.t_nrow, 0);             /* Seek to last line.   */
  474. X    ttclean(TRUE);
  475. X        TTputc('\n');
  476. X        if ((cp = getenv("SHELL")) != NULL && *cp != '\0')
  477. X                system(cp);
  478. X        else
  479. X                system("exec /bin/sh");
  480. X        TTflush();
  481. X    ttunclean();
  482. X        sgarbf = TRUE;
  483. X        return(TRUE);
  484. # endif /* News */
  485. #endif /* UNIX */
  486. X
  487. #if    AMIGA
  488. X        long newcli;
  489. X        mlwrite("[Starting new CLI]");
  490. X        sgarbf = TRUE;
  491. X        Execute("NEWCLI \"CON:0/0/640/200/MicroEMACS Subprocess\"", 0L, 0L);
  492. X        return(TRUE);
  493. #endif
  494. X
  495. #if     VMS
  496. X        movecursor(term.t_nrow, 0);             /* In last line.        */
  497. X        mlputs("[Starting DCL]\r\n");
  498. X        TTflush();                          /* Ignore "ttcol".      */
  499. X        sgarbf = TRUE;
  500. X        return (sys(NULL));                     /* NULL => DCL.         */
  501. #endif
  502. #if     CPM
  503. X        mlwrite("Not in CP/M-86");
  504. X    return FALSE;
  505. #endif
  506. #if    ST520
  507. X    mlwrite("Not in TOS");
  508. X    return FALSE;
  509. #endif
  510. #if     MSDOS & (AZTEC | MSC | TURBO)
  511. X        movecursor(term.t_nrow, 0);             /* Seek to last line.   */
  512. X        TTflush();
  513. X    TTkclose();
  514. X    system("command.com");
  515. X    TTkopen();
  516. X        sgarbf = TRUE;
  517. X        return(TRUE);
  518. #endif
  519. #if     MSDOS & LATTICE
  520. X        movecursor(term.t_nrow, 0);             /* Seek to last line.   */
  521. X        TTflush();
  522. X    TTkclose();
  523. X        sys("\\command.com", "");               /* Run CLI.             */
  524. X    TTkopen();
  525. X        sgarbf = TRUE;
  526. X        return(TRUE);
  527. #endif
  528. }
  529. X
  530. #if UNIX && defined(SIGTSTP)
  531. X
  532. bktoshell()        /* suspend MicroEMACS and wait to wake up */
  533. {
  534. #if     NeWS
  535. X    mlwrite("Not availible under NeWS");
  536. X    return(FALSE);
  537. #else
  538. X    int pid;
  539. X
  540. X    vttidy(TRUE);
  541. X    pid = getpid();
  542. X    kill(pid,SIGTSTP);
  543. #endif
  544. }
  545. X
  546. rtfrmshell()
  547. {
  548. #if     NeWS
  549. X    mlwrite("Not available under NeWS");
  550. X    return(FALSE);
  551. #else
  552. X    ttunclean();
  553. X    curwp->w_flag = WFHARD;  /* is this needed, with sgarbf == TRUE? */
  554. X    sgarbf = TRUE;
  555. #if USG
  556. X    signal(SIGCONT,rtfrmshell);    /* suspend & restart */
  557. X    update(TRUE);
  558. #endif
  559. #endif
  560. }
  561. #endif /* SIGTSTP */
  562. X
  563. #if UNIX
  564. pressreturn()
  565. {
  566. X    int s;
  567. X
  568. X        mlputs("[Press return to continue]");
  569. X        TTflush();
  570. X    /* loop for a CR, a space, or a : to do another named command */
  571. X        while ((s = kbd_key()) != '\r' && s != ' ' && s != kcod2key(abortc)) {
  572. X        extern CMDFUNC f_namedcmd;
  573. X                if (kcod2fnc(s) == &f_namedcmd) {
  574. X            tungetc(kcod2key(s));
  575. X            break;
  576. X        }
  577. X    }
  578. }
  579. #endif
  580. X
  581. respawn(f,n) {
  582. X    spawn(f,n,TRUE);
  583. }
  584. X
  585. /*
  586. X * Run a one-liner in a subjob. When the command returns, wait for a single
  587. X * character to be typed, then mark the screen as garbage so a full repaint is
  588. X * done.
  589. X */
  590. /* the #ifdefs have been totally separated, for readability */
  591. spawn(f, n, rerun)
  592. {
  593. X
  594. #if  UNIX
  595. X        register int    s;
  596. X        static char oline[NLINE];    /* command line send to shell */
  597. X        char    line[NLINE];    /* command line send to shell */
  598. X    register char    *cp;
  599. X    char        line2[NLINE];
  600. X    int cb;
  601. X    char prompt[50];
  602. X    char *getenv();
  603. X
  604. X    if (!rerun) {
  605. X        if (cb = anycb())
  606. X            sprintf(prompt,"Warning: %d modified buffer%s: !",
  607. X                cb, cb>1 ? "s":"");
  608. X        else
  609. X            sprintf(prompt,": !");
  610. X
  611. X            if ((s=mlreply(prompt, oline, NLINE)) != TRUE)
  612. X                    return (s);
  613. X    } else {
  614. X        if (!oline[0])
  615. X            return FALSE;
  616. X        mlwrite(": !%s",oline);
  617. X    }
  618. X    strcpy(line,oline);
  619. X        if ((cp = getenv("SHELL")) == NULL || *cp == '\0')
  620. X                cp = "/bin/sh";
  621. X    sprintf(line2, "%s -c \"%s\"", cp, line);
  622. #if    NeWS
  623. X    system(line2);
  624. #else
  625. X    ttclean(TRUE);
  626. X    system(line2);
  627. X        TTflush();
  628. X    ttunclean();
  629. X        sgarbf = TRUE;
  630. X    pressreturn();
  631. #endif /* NeWS */
  632. X        return (TRUE);
  633. #endif /* UNIX */
  634. X
  635. #if     AMIGA
  636. X        register int    s;
  637. X        static char oline[NLINE];    /* command line send to shell */
  638. X        char    line[NLINE];    /* command line send to shell */
  639. X    register char    *cp;
  640. X    char        line2[NLINE];
  641. X        long newcli;
  642. X
  643. X
  644. X        if ((s=mlreply("cmd: !", oline, NLINE)) != TRUE)
  645. X                return (s);
  646. X    strcpy(line,oline);
  647. X        newcli = Open("CON:0/0/640/200/MicroEMACS Subprocess", NEW);
  648. X        Execute(line, 0L, newcli);
  649. X        Close(newcli);
  650. X        tgetc();     /* Pause.               */
  651. X        sgarbf = TRUE;
  652. X        return(TRUE);
  653. #endif
  654. #if    ST520 & MEGAMAX
  655. X        register int    s;
  656. X        static char oline[NLINE];    /* command line send to shell */
  657. X        char    line[NLINE];    /* command line send to shell */
  658. X    register char    *cp;
  659. X    char        line2[NLINE];
  660. X
  661. X    int i,j,k;
  662. X    char *sptr,*tptr;
  663. X
  664. X        if ((s=mlreply("cmd: !", oline, NLINE)) != TRUE)
  665. X                return(s);
  666. X    strcpy(line,oline);
  667. X    movecursor(term.t_nrow - 1, 0);
  668. X    TTclose();
  669. X    /*
  670. X     * break the line into the command and its args
  671. X     * be cute about it, if there is no '.' in the filename, try
  672. X     * to find .prg, .tos or .ttp in that order
  673. X     * in any case check to see that the file exists before we run 
  674. X     * amok
  675. X     */
  676. X    STenv = NULL;
  677. X    if((tptr = index(&line[0],' ')) == NULL) { /* no args */
  678. X        STcmd = malloc(strlen(line) + 1);
  679. X        strcpy(STcmd,line);
  680. X        STargs = NULL;
  681. X    }
  682. X    else {  /* seperate out the args from the command */
  683. X        /* resist the temptation to do ptr arithmetic */
  684. X        STcmd = malloc(strlen(line) + 1);
  685. X        for(i = 0,sptr = &line[0]; sptr != tptr; sptr++,i++)
  686. X            STcmd[i] = *sptr;
  687. X        STcmd[i] = '\0';
  688. X        for(; *tptr == ' ' || *tptr == '\t'; tptr++);
  689. X        if(*tptr == '\0')
  690. X            STargs = NULL;
  691. X        else {
  692. X            STargs = malloc(strlen(tptr) + 2);
  693. /* first byte of STargs is the length of the string */
  694. X            STargs[0] = strlen(tptr);
  695. X            STargs[1] = NULL; /* fake it for strcat */
  696. X            strcat(STargs,tptr);
  697. X        }
  698. X    }
  699. X    /*
  700. X     * before we issue the command look for the '.', if it's not there
  701. X     * try adding .prg, .tos and .ttp to see if they exist, if not
  702. X     * issue the command as is
  703. X     */
  704. X    if((tptr = index(STcmd,'.')) == NULL) {
  705. X         STwork = malloc(strlen(STcmd) + 4);
  706. X         strcpy(STwork,STcmd);
  707. X         strcat(STwork,".prg");
  708. X         tptr = index(STwork,'.');
  709. X         if(Fsfirst(1,STwork) != 0) { /* try .tos */
  710. X             strcpy(tptr,".tos");
  711. X             if(Fsfirst(1,STwork) != 0) { /* try .ttp */
  712. X                 strcpy(tptr,".ttp");
  713. X                 if(Fsfirst(1,STwork) != 0) /* never mind */
  714. X                     *STwork = NULL;
  715. X                 }
  716. X             }
  717. X     }
  718. X     if(*STwork != NULL)
  719. X            Pexec(LOAD_EXEC,STwork,STargs,STenv);         
  720. X    else
  721. X            Pexec(LOAD_EXEC,STcmd,STargs,STenv);
  722. X    TTopen();
  723. X        mlputs("\r\n\n[End]");                  /* Pause.               */
  724. X        TTgetc();                 /* Pause.               */
  725. X        sgarbf = TRUE;
  726. X        return (TRUE);
  727. #endif
  728. #if     VMS
  729. X        register int    s;
  730. X        static char oline[NLINE];    /* command line send to shell */
  731. X        char    line[NLINE];    /* command line send to shell */
  732. X    register char    *cp;
  733. X    char        line2[NLINE];
  734. X
  735. X
  736. X        if ((s=mlreply("cmd: !", oline, NLINE)) != TRUE)
  737. X                return (s);
  738. X    strcpy(line,oline);
  739. X        TTputc('\n');                /* Already have '\r'    */
  740. X        TTflush();
  741. X        s = sys(line);                          /* Run the command.     */
  742. X        mlputs("\r\n\n[End]");                  /* Pause.               */
  743. X        TTflush();
  744. X        tgetc();
  745. X        sgarbf = TRUE;
  746. X        return (s);
  747. #endif
  748. #if     CPM
  749. X        mlwrite("Not in CP/M-86");
  750. X        return (FALSE);
  751. #endif
  752. #if     MSDOS | (ST520 & LATTICE)
  753. X        register int    s;
  754. X        static char oline[NLINE];    /* command line send to shell */
  755. X        char    line[NLINE];    /* command line send to shell */
  756. X    register char    *cp;
  757. X    char        line2[NLINE];
  758. X
  759. X
  760. X        if ((s=mlreply("cmd: !", oline, NLINE)) != TRUE)
  761. X                return(s);
  762. X    strcpy(line,oline);
  763. X    movecursor(term.t_nrow - 1, 0);
  764. X    TTkclose();
  765. X        system(line);
  766. X    TTkopen();
  767. X    /* if we are interactive, pause here */
  768. X    if (clexec == FALSE) {
  769. X            mlputs("\r\n\n[End]");
  770. X            tgetc();
  771. X        }
  772. X        sgarbf = TRUE;
  773. X        return (TRUE);
  774. #endif
  775. }
  776. X
  777. #if UNIX
  778. /*
  779. X * Pipe a one line command into a window
  780. X */
  781. pipecmd(f, n)
  782. {
  783. X    register WINDOW *wp;    /* pointer to new window */
  784. X    register BUFFER *bp;    /* pointer to buffer to zot */
  785. X        static char oline[NLINE];    /* command line send to shell */
  786. X        register int    s;
  787. X    static char bname[] = "[Output]";
  788. X    int cb;
  789. X    char prompt[50];
  790. X
  791. X
  792. X    /* if it doesn't start with '!', or if that's all it is */
  793. X    if (oline[0] != '!' || oline[1] == '\0') {
  794. X        oline[0] = '!';
  795. X        oline[1] = '\0';
  796. X    }
  797. X
  798. X    if (cb = anycb())
  799. X        sprintf(prompt,"Warning: %d modified buffer%s. !",
  800. X            cb, cb>1 ? "s":"");
  801. X    else
  802. X        sprintf(prompt,"!");
  803. X        
  804. X    /* get the command to pipe in */
  805. X        if ((s=mlreply(prompt, &oline[1], NLINE)) != TRUE)
  806. X                return(s);
  807. X
  808. X    /* first check if we are already here */
  809. X    bp = bfind(bname, OK_CREAT, 0);
  810. X    if (bp == NULL)
  811. X        return FALSE;
  812. X
  813. X    /* and read the stuff in */
  814. X    if (popupbuff(bp) != TRUE || 
  815. X        swbuffer(bp) != TRUE || 
  816. X        readin(oline, FALSE, bp, TRUE) != TRUE) {
  817. X        return(FALSE);
  818. X    }
  819. X    strcpy(bp->b_bname,bname);
  820. X    strncpy(bp->b_fname, oline, NFILEN-1);
  821. X    bp->b_mode |= MDVIEW;
  822. X    return TRUE;
  823. }
  824. X
  825. #else /* ! UNIX */
  826. X
  827. /*
  828. X * Pipe a one line command into a window
  829. X */
  830. pipecmd(f, n)
  831. {
  832. X        register int    s;    /* return status from CLI */
  833. X    register WINDOW *wp;    /* pointer to new window */
  834. X    register BUFFER *bp;    /* pointer to buffer to zot */
  835. X        static char oline[NLINE];    /* command line send to shell */
  836. X        char    line[NLINE];    /* command line send to shell */
  837. X    static char bname[] = "[output]";
  838. X    WINDOW *ocurwp;        /* save the current window during delete */
  839. X
  840. #if    AMIGA
  841. X    static char filnam[] = "ram:command";
  842. X        long newcli;
  843. #else
  844. X    static char filnam[NSTRING] = "command";
  845. #endif
  846. X
  847. #if    MSDOS
  848. X    char *tmp;
  849. X    char *getenv();
  850. X    FILE *fp;
  851. X    FILE *fopen();
  852. #endif
  853. X
  854. #if    MSDOS
  855. X    if ((tmp = getenv("TMP")) == NULL)
  856. X        strcpy(filnam, "command");
  857. X    else {
  858. X        strcpy(filnam, tmp);
  859. X                strcat(filnam,"\\command");
  860. X        }
  861. #endif
  862. #if     VMS
  863. X    mlwrite("Not availible under VMS");
  864. X    return(FALSE);
  865. #endif
  866. #if     CPM
  867. X        mlwrite("Not availible under CP/M-86");
  868. X        return(FALSE);
  869. #endif
  870. X    /* get the command to pipe in */
  871. X        if ((s=mlreply("cmd: <", oline, NLINE)) != TRUE)
  872. X                return(s);
  873. X
  874. X    strcpy(line,oline);
  875. X
  876. X    /* get rid of the command output buffer if it exists */
  877. X        if ((bp=bfind(bname, NO_CREAT, 0)) != FALSE) {
  878. X        /* try to make sure we are off screen */
  879. X        wp = wheadp;
  880. X        ocurwp = NULL;
  881. X        while (wp != NULL) {
  882. X            if (wp->w_bufp == bp) {
  883. X                if (curwp != wp) {
  884. X                    ocurwp = curwp;
  885. X                    curwp = wp;
  886. X                }
  887. X                delwind(FALSE, 1);
  888. X                if (ocurwp != NULL)
  889. X                    curwp = ocurwp;
  890. X                break;
  891. X            }
  892. X            wp = wp->w_wndp;
  893. X        }
  894. X        if (zotbuf(bp) != TRUE)
  895. X
  896. X            return(FALSE);
  897. X    }
  898. X
  899. #if     AMIGA
  900. X        newcli = Open("CON:0/0/640/200/MicroEMACS Subprocess", NEW);
  901. X    strcat(line, " >");
  902. X    strcat(line, filnam);
  903. X        Execute(line, 0L, newcli);
  904. X    s = TRUE;
  905. X        Close(newcli);
  906. X        sgarbf = TRUE;
  907. #endif
  908. #if     MSDOS
  909. X    strcat(line," >>");
  910. X    strcat(line,filnam);
  911. X    movecursor(term.t_nrow - 1, 0);
  912. X    TTkclose();
  913. X        system(line);
  914. X    TTkopen();
  915. X        sgarbf = TRUE;
  916. X    if ((fp = fopen(filnam, "r")) == NULL) {
  917. X        s = FALSE;
  918. X    } else {
  919. X        fclose(fp);
  920. X        s = TRUE;
  921. X    }
  922. #endif
  923. X
  924. X    if (s != TRUE)
  925. X        return(s);
  926. X
  927. X    /* split the current window to make room for the command output */
  928. X    if (splitwind(FALSE, 1) == FALSE)
  929. X            return(FALSE);
  930. X
  931. X    /* and read the stuff in */
  932. X    if (getfile(filnam, FALSE) == FALSE)
  933. X        return(FALSE);
  934. X
  935. X    /* make this window in VIEW mode, update all mode lines */
  936. X    curwp->w_bufp->b_mode |= MDVIEW;
  937. X    wp = wheadp;
  938. X    while (wp != NULL) {
  939. X        wp->w_flag |= WFMODE;
  940. X        wp = wp->w_wndp;
  941. X    }
  942. X
  943. #if FINDERR
  944. X    strcpy(febuff,bp->b_bname);
  945. X    newfebuff = TRUE;
  946. #endif
  947. X
  948. X    /* and get rid of the temporary file */
  949. X    unlink(filnam);
  950. X    return(TRUE);
  951. }
  952. #endif /* UNIX */
  953. X
  954. /* run a region through an external filter, replace it with its output */
  955. filterregion(f,n)
  956. {
  957. X        static char oline[NLINE];    /* command line send to shell */
  958. X        char    line[NLINE];    /* command line send to shell */
  959. X    FILE *fr, *fw;
  960. X    int s;
  961. X
  962. X    /* get the filter name and its args */
  963. X        if ((s=mlreply("!", oline, NLINE)) != TRUE)
  964. X                return(s);
  965. X    strcpy(line,oline);
  966. X    if ((s = inout_popen(&fr, &fw, line)) != TRUE) {
  967. X        mlwrite("Couldn't open pipe or command");
  968. X        return s;
  969. X    }
  970. X
  971. X    killregion(f,n);
  972. X    if (fork()) {
  973. X        fclose(fw);
  974. X        /* backline(FALSE,1); */
  975. X        curwp->w_dotp = lback(curwp->w_dotp);
  976. X        s = ifile(NULL,TRUE,fr);
  977. X        npclose(fr);
  978. X        firstnonwhite();
  979. X        setmark();
  980. X        return s;
  981. X    } else {
  982. X        KILL *kp;        /* pointer into kill register */
  983. X        kregcirculate(FALSE);
  984. X        /* make sure there is something to put */
  985. X        if (kbs[ukb].kbufh == NULL)
  986. X            return TRUE;        /* not an error, just nothing */
  987. X
  988. X        kp = kbs[ukb].kbufh;
  989. X        while (kp != NULL) {
  990. X            if (kp->d_next == NULL)
  991. X                fwrite(kp->d_chunk, 1, kbs[ukb].kused, fw);
  992. X            else
  993. X                fwrite(kp->d_chunk, 1, KBLOCK, fw);
  994. X            kp = kp->d_next;
  995. X        }
  996. X        fflush(fw);
  997. X        fclose(fw);
  998. X        exit (0);
  999. X    }
  1000. }
  1001. X
  1002. /*
  1003. X * filter a buffer through an external DOS program
  1004. X * this is obsolete, the filterregion code is better.
  1005. X */
  1006. filter(f, n)
  1007. {
  1008. X        register int    s;    /* return status from CLI */
  1009. X    register BUFFER *bp;    /* pointer to buffer to zot */
  1010. X        static char oline[NLINE];    /* command line send to shell */
  1011. X        char    line[NLINE];    /* command line send to shell */
  1012. X    char tmpnam[NFILEN];    /* place to store real file name */
  1013. X    static char bname1[] = "fltinp";
  1014. X
  1015. #if    AMIGA
  1016. X    static char filnam1[] = "ram:fltinp";
  1017. X    static char filnam2[] = "ram:fltout";
  1018. X        long newcli;
  1019. #else
  1020. X    static char filnam1[] = "fltinp";
  1021. X    static char filnam2[] = "fltout";
  1022. #endif
  1023. X
  1024. #if     VMS
  1025. X    mlwrite("Not availible under VMS");
  1026. X    return(FALSE);
  1027. #endif
  1028. #if     CPM
  1029. X        mlwrite("Not availible under CP/M-86");
  1030. X        return(FALSE);
  1031. #endif
  1032. X    /* get the filter name and its args */
  1033. X        if ((s=mlreply("cmd: |", oline, NLINE)) != TRUE)
  1034. X                return(s);
  1035. X    strcpy(line,oline);
  1036. X
  1037. X    /* setup the proper file names */
  1038. X    bp = curbp;
  1039. X    strcpy(tmpnam, bp->b_fname);    /* save the original name */
  1040. X    strcpy(bp->b_fname, bname1);    /* set it to our new one */
  1041. X
  1042. X    /* write it out, checking for errors */
  1043. X    if (writeout(filnam1,curbp,TRUE) != TRUE) {
  1044. X        mlwrite("[Cannot write filter file]");
  1045. X        strcpy(bp->b_fname, tmpnam);
  1046. X        return(FALSE);
  1047. X    }
  1048. X
  1049. #if     AMIGA
  1050. X        newcli = Open("CON:0/0/640/200/MicroEMACS Subprocess", NEW);
  1051. X    strcat(line, " <ram:fltinp >ram:fltout");
  1052. X        Execute(line,0L,newcli);
  1053. X    s = TRUE;
  1054. X        Close(newcli);
  1055. X        sgarbf = TRUE;
  1056. #endif
  1057. #if     MSDOS
  1058. X    strcat(line," <fltinp >fltout");
  1059. X    movecursor(term.t_nrow - 1, 0);
  1060. X    TTkclose();
  1061. X        system(line);
  1062. X    TTkopen();
  1063. X        sgarbf = TRUE;
  1064. X    s = TRUE;
  1065. #endif
  1066. #if     UNIX
  1067. #if    ! NeWS
  1068. X        ttclean(TRUE);
  1069. #endif
  1070. X    strcat(line," <fltinp >fltout");
  1071. X        system(line);
  1072. #if    ! NeWS
  1073. X        ttunclean();
  1074. X        TTflush();
  1075. X        sgarbf = TRUE;
  1076. #endif
  1077. X       s = TRUE;
  1078. #endif
  1079. X
  1080. X    /* on failure, escape gracefully */
  1081. X    if (s != TRUE || (readin(filnam2,FALSE,curbp,TRUE) == FALSE)) {
  1082. X        mlwrite("[Execution failed]");
  1083. X        strcpy(bp->b_fname, tmpnam);
  1084. X        unlink(filnam1);
  1085. X        unlink(filnam2);
  1086. X        return(s);
  1087. X    }
  1088. X
  1089. X    /* reset file name */
  1090. X    strcpy(bp->b_fname, tmpnam);    /* restore name */
  1091. X    bp->b_flag |= BFCHG;        /* flag it as changed */
  1092. X
  1093. X    /* and get rid of the temporary file */
  1094. X    unlink(filnam1);
  1095. X    unlink(filnam2);
  1096. X    return(TRUE);
  1097. }
  1098. X
  1099. #if     VMS
  1100. /*
  1101. X * Run a command. The "cmd" is a pointer to a command string, or NULL if you
  1102. X * want to run a copy of DCL in the subjob (this is how the standard routine
  1103. X * LIB$SPAWN works. You have to do wierd stuff with the terminal on the way in
  1104. X * and the way out, because DCL does not want the channel to be in raw mode.
  1105. X */
  1106. sys(cmd)
  1107. register char   *cmd;
  1108. {
  1109. X        struct  dsc$descriptor  cdsc;
  1110. X        struct  dsc$descriptor  *cdscp;
  1111. X        long    status;
  1112. X        long    substatus;
  1113. X        long    iosb[2];
  1114. X
  1115. X        status = SYS$QIOW(EFN, iochan, IO$_SETMODE, iosb, 0, 0,
  1116. X                          oldmode, sizeof(oldmode), 0, 0, 0, 0);
  1117. X        if (status!=SS$_NORMAL || (iosb[0]&0xFFFF)!=SS$_NORMAL)
  1118. X                return (FALSE);
  1119. X        cdscp = NULL;                           /* Assume DCL.          */
  1120. X        if (cmd != NULL) {                      /* Build descriptor.    */
  1121. X                cdsc.dsc$a_pointer = cmd;
  1122. X                cdsc.dsc$w_length  = strlen(cmd);
  1123. X                cdsc.dsc$b_dtype   = DSC$K_DTYPE_T;
  1124. X                cdsc.dsc$b_class   = DSC$K_CLASS_S;
  1125. X                cdscp = &cdsc;
  1126. X        }
  1127. X        status = LIB$SPAWN(cdscp, 0, 0, 0, 0, 0, &substatus, 0, 0, 0);
  1128. X        if (status != SS$_NORMAL)
  1129. X                substatus = status;
  1130. X        status = SYS$QIOW(EFN, iochan, IO$_SETMODE, iosb, 0, 0,
  1131. X                          newmode, sizeof(newmode), 0, 0, 0, 0);
  1132. X        if (status!=SS$_NORMAL || (iosb[0]&0xFFFF)!=SS$_NORMAL)
  1133. X                return (FALSE);
  1134. X        if ((substatus&STS$M_SUCCESS) == 0)     /* Command failed.      */
  1135. X                return (FALSE);
  1136. X        return (TRUE);
  1137. }
  1138. #endif
  1139. X
  1140. #if    ~AZTEC & ~MSC & ~TURBO & MSDOS
  1141. X
  1142. /*
  1143. X * This routine, once again by Bob McNamara, is a C translation of the "system"
  1144. X * routine in the MWC-86 run time library. It differs from the "system" routine
  1145. X * in that it does not unconditionally append the string ".exe" to the end of
  1146. X * the command name. We needed to do this because we want to be able to spawn
  1147. X * off "command.com". We really do not understand what it does, but if you don't
  1148. X * do it exactly "malloc" starts doing very very strange things.
  1149. X */
  1150. sys(cmd, tail)
  1151. char    *cmd;
  1152. char    *tail;
  1153. {
  1154. #if MWC86
  1155. X        register unsigned n;
  1156. X        extern   char     *__end;
  1157. X
  1158. X        n = __end + 15;
  1159. X        n >>= 4;
  1160. X        n = ((n + dsreg() + 16) & 0xFFF0) + 16;
  1161. X        return(execall(cmd, tail, n));
  1162. #endif
  1163. X
  1164. #if LATTICE
  1165. X        return(forklp(cmd, tail, (char *)NULL));
  1166. #endif
  1167. }
  1168. #endif
  1169. X
  1170. #if    MSDOS & LATTICE
  1171. /*    System: a modified version of lattice's system() function
  1172. X        that detects the proper switchar and uses it
  1173. X        written by Dana Hogget                */
  1174. X
  1175. system(cmd)
  1176. X
  1177. char *cmd;    /*  Incoming command line to execute  */
  1178. X
  1179. {
  1180. X    char *getenv();
  1181. X    static char *swchar = "/C";    /*  Execution switch  */
  1182. X    union REGS inregs;    /*  parameters for dos call  */
  1183. X    union REGS outregs;    /*  Return results from dos call  */
  1184. X    char *shell;        /*  Name of system command processor  */
  1185. X    char *p;        /*  Temporary pointer  */
  1186. X    int ferr;        /*  Error condition if any  */
  1187. X
  1188. X    /*  get name of system shell  */
  1189. X    if ((shell = getenv("COMSPEC")) == NULL) {
  1190. X        return (-1);        /*  No shell located  */
  1191. X    }
  1192. X
  1193. X    p = cmd;
  1194. X    while (isspace(*p)) {        /*  find out if null command */
  1195. X        p++;
  1196. X    }
  1197. X
  1198. X    /**  If the command line is not empty, bring up the shell  **/
  1199. X    /**  and execute the command.  Otherwise, bring up the     **/
  1200. X    /**  shell in interactive mode.   **/
  1201. X
  1202. X    if (p && *p) {
  1203. X        /**  detect current switch character and us it  **/
  1204. X        inregs.h.ah = 0x37;    /*  get setting data  */
  1205. X        inregs.h.al = 0x00;    /*  get switch character  */
  1206. X        intdos(&inregs, &outregs);
  1207. X        *swchar = outregs.h.dl;
  1208. X        ferr = forkl(shell, "command", swchar, cmd, (char *)NULL);
  1209. X    } else {
  1210. X        ferr = forkl(shell, "command", (char *)NULL);
  1211. X    }
  1212. X
  1213. X    return (ferr ? ferr : wait());
  1214. }
  1215. #endif
  1216. SHAR_EOF
  1217. chmod 0444 spawn.c ||
  1218. echo 'restore of spawn.c failed'
  1219. Wc_c="`wc -c < 'spawn.c'`"
  1220. test 20300 -eq "$Wc_c" ||
  1221.     echo 'spawn.c: original size 20300, current size' "$Wc_c"
  1222. # ============= st520.c ==============
  1223. echo 'x - extracting st520.c (Text)'
  1224. sed 's/^X//' << 'SHAR_EOF' > 'st520.c' &&
  1225. /*
  1226. X
  1227. The routines in this file provide support for the Atari 520 or 1040ST
  1228. using VT52 emulation.  The I/O services are provided here as well.  It
  1229. compiles into nothing if not a 520ST style device.
  1230. X
  1231. */
  1232. X
  1233. #define    termdef    1            /* don't define "term" external */
  1234. X
  1235. #include        <stdio.h>
  1236. #include        "estruct.h"
  1237. #include    "edef.h"
  1238. X
  1239. #if     ATARI & ST520 & MEGAMAX
  1240. #include    <osbind.h>
  1241. X
  1242. #define LINEA_INIT 0xA000
  1243. #define V_CEL_WR   -0x28
  1244. X
  1245. #define V_CEL_MY   -0x2a
  1246. #define V_CEL_HT   -0x2e
  1247. #define V_FNT_AD   -0x16
  1248. #define V_OFF_AD   -0x0a
  1249. #define V_DISAB    -346
  1250. X
  1251. #define NROW    25                      /* Screen size.                 */
  1252. #define NCOL    80                      /* Edit if you want to.         */
  1253. #define    MARGIN    8            /* size of minimim margin and    */
  1254. #define    SCRSIZ    64            /* scroll size for extended lines */
  1255. #define    NPAUSE    25            /* # times thru update to pause */
  1256. #define BIAS    0x20                    /* Origin 0 coordinate bias.    */
  1257. #define ESC     0x1B                    /* ESC character.               */
  1258. #define BEL     0x07                    /* ascii bell character         */
  1259. X
  1260. extern  int     ttopen();               /* Forward references.          */
  1261. extern  int     ttgetc();
  1262. extern  int     ttputc();
  1263. extern  int     ttflush();
  1264. extern  int     ttclose();
  1265. extern  int     st520move();
  1266. extern  int     st520eeol();
  1267. extern  int     st520eeop();
  1268. extern  int     st520beep();
  1269. extern  int     st520open();
  1270. extern    int    st520close();
  1271. extern    int    st520rev();
  1272. extern  int st520kopen();
  1273. extern  int st520kclose();
  1274. extern    int st520chgrez();
  1275. X
  1276. #if    COLOR
  1277. extern    int    st520fcol();
  1278. extern    int    st520bcol();
  1279. X
  1280. int        cfcolor = -1;        /* current fg (character) color */
  1281. int        cbcolor = -1;        /* current bg color */
  1282. int        oldpal[8];        /* pallette when emacs was invoked */
  1283. int        newpal[8] = {        /* default emacs pallette */
  1284. X    0x000, 0x700, 0x070, 0x770, 0x007, 0x707, 0x077, 0x777};
  1285. #endif
  1286. X
  1287. int STncolors = 0;        /* number of colors  */
  1288. int STrez;            /* physical screen resolution */    
  1289. X
  1290. /*
  1291. X * Dispatch table. All the
  1292. X * hard fields just point into the
  1293. X * terminal I/O code.
  1294. X */
  1295. TERM    term    = {
  1296. X        NROW-1,
  1297. X        NCOL,
  1298. X    MARGIN,
  1299. X    MARGIN,
  1300. X    SCRSIZ,
  1301. X    NPAUSE,
  1302. X        &st520open,
  1303. X        &st520close,
  1304. X    &st520kopen,
  1305. X    &st520kclose,
  1306. X        &ttgetc,
  1307. X        &ttputc,
  1308. X        &ttflush,
  1309. X        &st520move,
  1310. X        &st520eeol,
  1311. X        &st520eeop,
  1312. X        &st520beep,
  1313. X        &st520rev
  1314. #if    MULTREZ
  1315. X    , &st520chgrez
  1316. #endif
  1317. #if    COLOR
  1318. X    , &st520fcol,
  1319. X    &st520bcol
  1320. #endif
  1321. };
  1322. X    struct KBDvecs {
  1323. X        int (*midivec) ();
  1324. X        int (*vkbderr) ();
  1325. X        int (*vmiderr) ();
  1326. X        int (*statvec) ();
  1327. X        int (*mousevec) ();
  1328. X        int (*clockvec) ();
  1329. X        int (*joyvec) ();
  1330. X        int (*midisys) ();
  1331. X        int (*ikbdsys) ();
  1332. X    };
  1333. X    struct Param {
  1334. X        char topmode;
  1335. X        char buttons;
  1336. X        char xparam;
  1337. X        char yparam;
  1338. X        int xmax,ymax;
  1339. X        int xinitial,yinitial;
  1340. X    };
  1341. X    struct KBDvecs *kbdvecs;
  1342. X    struct Param *paramp;
  1343. X    char kbdcmds[25];
  1344. X
  1345. st520move(row, col)
  1346. {
  1347. X        ttputc(ESC);
  1348. X        ttputc('Y');
  1349. X        ttputc(row+BIAS);
  1350. X        ttputc(col+BIAS);
  1351. }
  1352. X
  1353. st520eeol()
  1354. {
  1355. X        ttputc(ESC);
  1356. X        ttputc('K');
  1357. }
  1358. X
  1359. st520eeop()
  1360. {
  1361. X
  1362. #if    COLOR
  1363. X        st520fcol(gfcolor);
  1364. X        st520bcol(gbcolor);
  1365. #endif
  1366. X        ttputc(ESC);
  1367. X        ttputc('J');
  1368. }
  1369. X
  1370. st520rev(status)    /* set the reverse video state */
  1371. X
  1372. int status;    /* TRUE = reverse video, FALSE = normal video */
  1373. X
  1374. {
  1375. X
  1376. X    if(status) {
  1377. X        ttputc(ESC);
  1378. X        ttputc('p');
  1379. X    }
  1380. X    else {
  1381. X        ttputc(ESC);
  1382. X        ttputc('q');
  1383. X    }
  1384. }
  1385. X
  1386. #if    COLOR
  1387. st520fcol(color)
  1388. int color;    
  1389. {
  1390. X        if(color == cfcolor || !STncolors)
  1391. X            return;
  1392. X        else {
  1393. X
  1394. X            ttputc(ESC);
  1395. X            ttputc('b');
  1396. X            ttputc(color & 0x0f);
  1397. X            cfcolor = color;
  1398. X        }
  1399. }
  1400. X
  1401. st520bcol(color)
  1402. int color;
  1403. {
  1404. X        if(color == cbcolor || !STncolors)
  1405. X            return;
  1406. X        else {
  1407. X            ttputc(ESC);
  1408. X            ttputc('c');
  1409. X            ttputc(color & 0x0f);
  1410. X            cbcolor = color;
  1411. X        }
  1412. X
  1413. }
  1414. #endif
  1415. X
  1416. st520beep()
  1417. {
  1418. #ifdef    BEL
  1419. X        ttputc(BEL);
  1420. X        ttflush();
  1421. #endif
  1422. }
  1423. X
  1424. st520open()
  1425. {
  1426. X    int i,j,k;
  1427. X    long phys, log;    /* screen bases */
  1428. X    
  1429. /* IMPORTANT: it is ABSOLUTELY necessary that the default resolution be the
  1430. X *    largest possible so that display will allocate (malloc) the maximum
  1431. X *    size for the VIDEO arrray
  1432. X */
  1433. X    STrez = Getrez();
  1434. X    switch(STrez) {
  1435. X        case 0: /* low res 25x40 16 colors */
  1436. X            phys = Physbase();
  1437. X            log  = Logbase();
  1438. X            Setscreen(log, phys, 1);
  1439. X            STrez = 1;
  1440. X            /* fall thru to med res */
  1441. X
  1442. X        case 1: /* med res 25x80 4 colors */
  1443. X            term.t_nrow = 25 - 1;
  1444. X            term.t_ncol  = 80;
  1445. X            grez = 1;
  1446. #if    COLOR
  1447. X            STncolors = 4;
  1448. X            for(i=0;i<8;i++) {
  1449. X                oldpal[i] = Setcolor(i,newpal[i]);
  1450. X            }
  1451. #endif
  1452. X            break;
  1453. X        case 2: /* high res 25x80 no colors */
  1454. X            term.t_nrow  = 40 - 1;
  1455. X            term.t_ncol  = 80;
  1456. X            grez = 2;
  1457. X            make_8x10(); /* create a smaller font */
  1458. X            set_40();    /* and go to 40 line mode */
  1459. #if    COLOR
  1460. X            STncolors = 0;
  1461. #endif
  1462. X            break;
  1463. X    }
  1464. X
  1465. X    revexist = TRUE;
  1466. X    eolexist = TRUE;
  1467. X    paramp = (struct Param *)malloc(sizeof(struct Param));
  1468. X    kbdvecs = (struct KBDvecs *)Kbdvbase();
  1469. X    paramp -> topmode = 0;
  1470. X    paramp -> buttons = 4;
  1471. X    paramp -> xparam = 8;
  1472. X    paramp -> yparam = 10;
  1473. X    paramp -> xmax = 79;
  1474. X    paramp -> ymax = 23;
  1475. X    paramp -> xinitial = 0;
  1476. X    paramp -> yinitial = 0;
  1477. X    Initmous(1,paramp,kbdvecs -> mousevec);
  1478. X
  1479. X    i = 0;
  1480. X    kbdcmds[i++] = 0x0a;    /*set mouse keycode mode */
  1481. X    kbdcmds[i++] = 0x08;
  1482. X    kbdcmds[i++] = 0x0a;
  1483. X    Ikbdws(i-1,&kbdcmds[0]);
  1484. X    Cursconf(1,0);
  1485. X    Cursconf(3,0);
  1486. X    Cconout(27);Cconout('E');
  1487. X        ttopen();
  1488. }
  1489. X
  1490. st520close()
  1491. X
  1492. {
  1493. X    int i,j,k;
  1494. X
  1495. X    i = 0;
  1496. X    kbdcmds[i++] = 0x80;    /*reset mouse keycode mode */
  1497. X    kbdcmds[i++] = 0x01;
  1498. X    Ikbdws(i-1,&kbdcmds[0]);
  1499. X    if(grez == 2 && STrez == 2) /* b/w monitor in 40 row mode */
  1500. X        restore();
  1501. X
  1502. #if        COLOR
  1503. X    for(i=0;i<STncolors;i++)
  1504. X        Setcolor(i,oldpal[i]);
  1505. #endif
  1506. X    Cconout(27);Cconout('E');
  1507. X    paramp -> buttons = 0;
  1508. X    Initmous(2,paramp,kbdvecs -> mousevec);
  1509. X    i = 0;
  1510. X    kbdcmds[i++] = 0x80;    /*reset the keyboard*/
  1511. X    kbdcmds[i++] = 0x01;
  1512. X    Ikbdws(i-1,&kbdcmds[0]);
  1513. X    Cursconf(1,0);
  1514. X    ttclose();
  1515. }
  1516. st520kopen()
  1517. {
  1518. X
  1519. }
  1520. st520kclose()
  1521. {
  1522. X
  1523. }
  1524. X
  1525. st520chgrez(nurez)
  1526. int nurez;
  1527. {
  1528. X    int ierr, i, j ,k;
  1529. X    long phys, log;    /* screen bases */
  1530. X    char dum[80]; /* for debugging only */
  1531. X        
  1532. X    if(grez == nurez)
  1533. X        return(TRUE);
  1534. X        
  1535. X    if(STrez == 2) { /* b/w monitor-only allow hi | med rez */
  1536. X        switch(nurez) {
  1537. X            case 2: /* high res */
  1538. X                term.t_nrow  = 40 - 1;
  1539. X                term.t_ncol  = 80;
  1540. X                make_8x10(); /* create a smaller font */
  1541. X                set_40();    /* and go to 40 line mode */
  1542. X                grez = 2;
  1543. X                sgarbf = TRUE;
  1544. X                onlywind(1,1);
  1545. X                break;
  1546. X            case 1: /* med res */
  1547. X                term.t_nrow  = 25 - 1;
  1548. X                term.t_ncol  = 80;
  1549. X                restore();
  1550. X                grez = 1;
  1551. X                sgarbf = TRUE;
  1552. X                onlywind(1,1);
  1553. X                break;
  1554. X            default:
  1555. X                mlwrite("Invalid resolution");
  1556. X                return(FALSE);
  1557. X                break;
  1558. X        }
  1559. X    }
  1560. X    else { /* color monitor-only allow low | medium resolution */
  1561. X        phys = Physbase();
  1562. X        log  = Logbase();
  1563. X        switch(nurez) {
  1564. X            case 1:
  1565. X                term.t_nrow  = 25 - 1;
  1566. X                term.t_ncol  = 80;
  1567. X                Setscreen(log, phys, 1);
  1568. X                STncolors = 4;
  1569. X                grez = 1;
  1570. X                sgarbf = TRUE;
  1571. X                onlywind(1,1);
  1572. X                break;
  1573. X            case 0:
  1574. X                term.t_nrow  = 25 - 1;
  1575. X                term.t_ncol  = 40;
  1576. X                Setscreen(log, phys, 0);
  1577. X                STncolors = 8;
  1578. X                grez = 0;
  1579. X                sgarbf = TRUE;
  1580. X                onlywind(1,1);
  1581. X                break;
  1582. X            default:
  1583. X                mlwrite("%Invalid resolution");
  1584. X                return(FALSE);
  1585. X                break;
  1586. X        }
  1587. X    }
  1588. }            
  1589. X
  1590. STcurblink(onoff)
  1591. int onoff;
  1592. {
  1593. X    if(onoff)
  1594. X        Cursconf(2,0);
  1595. X    else
  1596. X        Cursconf(3,0);
  1597. }
  1598. X
  1599. X
  1600. char parm_save[28];
  1601. long fnt_8x10[640];
  1602. X
  1603. make_8x10()
  1604. {
  1605. X    int i,j,k;
  1606. X    long savea23[2];
  1607. X    
  1608. X    for(i=0;i<640;i++)
  1609. X        fnt_8x10[i] = 0;
  1610. X        
  1611. X    asm {
  1612. X    movem.l    A2-A3,savea23(A6)
  1613. X    
  1614. X    dc.w    LINEA_INIT        ;A1 -> array of font headers
  1615. X
  1616. X    lea    parm_save(A4),A2    ;A2 -> parameters savearea
  1617. X    move.l    V_OFF_AD(A0),(A2)+
  1618. X    move.l    V_FNT_AD(A0),(A2)+
  1619. X    move.w    V_CEL_HT(A0),(A2)+
  1620. X    move.w    V_CEL_MY(A0),(A2)+
  1621. X    move.w    V_CEL_WR(A0),(A2)+
  1622. X
  1623. X
  1624. X    move.l    04(A1),A1        ; A1 -> 8x8 font header
  1625. X    move.l    76(A1),A2        ; A2 -> 8x8 font data
  1626. X    lea    fnt_8x10+0x100(A4),A3    ; A3 -> 2nd line of font buffer
  1627. X    move.w    #0x200-1,D0        ; D0 <- longword counter for font xfer
  1628. X
  1629. fnt_loop:
  1630. X
  1631. X    move.l    (A2)+,(A3)+
  1632. X    dbf    D0,fnt_loop
  1633. X        
  1634. X    movem.l    savea23(A6),A2-A3
  1635. X    }
  1636. X    
  1637. }
  1638. X
  1639. set_40()
  1640. {
  1641. X    long    savea23[2];
  1642. X    
  1643. X    asm {
  1644. X    
  1645. ;
  1646. ;  use the 8x10 character set: 40 line mode
  1647. ;
  1648. X
  1649. X    movem.l    A2-A3,savea23(A6)
  1650. X    
  1651. X    dc.w    LINEA_INIT
  1652. X
  1653. X    move.l    04(A1),A1        ; A1 -> 8x8 font header
  1654. X    move.l    72(A1),V_OFF_AD(A0)    ; v_off_ad <- 8x8  offset table addr
  1655. X    lea    fnt_8x10(A4),A2
  1656. X    move.l    A2,V_FNT_AD(A0)        ; v_fnt_ad <- 8x10 font data addr
  1657. X
  1658. X    move.w    #10,V_CEL_HT(A0)    ; v_cel_ht <- 10   8x10 cell height
  1659. X    move.w    #39,V_CEL_MY(A0)    ; v_cel_my <- 39   maximum cell "Y"
  1660. X    move.w    #800,V_CEL_WR(A0)    ; v_cel_wr <- 800  offset to cell Y+1
  1661. X
  1662. X    movem.l savea23,A2-A3
  1663. X    }
  1664. }
  1665. X
  1666. set_20()
  1667. {
  1668. X    long    savea23[2];
  1669. X
  1670. X    asm {
  1671. X        
  1672. ;
  1673. ;  use the 8x10 character set: 20 line mode
  1674. ;
  1675. X
  1676. X    movem.l    A2-A3,savea23(A6)
  1677. X    
  1678. X    dc.w    LINEA_INIT        ; A0 -> line A variables
  1679. X
  1680. X    move.l    04(A1),A1        ; A1 -> 8x8 font header
  1681. X    move.l    72(A1),V_OFF_AD(A0)    ; v_off_ad <- 8x8  offset table addr
  1682. X    lea    fnt_8x10(A4),A2
  1683. X    move.l    A2,V_FNT_AD(A0)        ; v_fnt_ad <- 8x10 font data addr
  1684. X
  1685. X    move.w    #10,V_CEL_HT(A0)    ; v_cel_ht <- 10   8x10 cell height
  1686. X    move.w    #19,V_CEL_MY(A0)    ; v_cel_my <- 19   maximum cell "Y"
  1687. X    move.w    #1600,V_CEL_WR(A0)    ; v_cel_wr <- 800  offset to cell Y+1
  1688. X    
  1689. X    movem.l    savea23,A2-A3
  1690. X    }
  1691. }
  1692. X
  1693. X
  1694. restore()
  1695. {
  1696. X    long savea23[2];
  1697. X    
  1698. X    asm {
  1699. X    
  1700. ;  return what was saved in parameter save zone    
  1701. X
  1702. X    movem.l    A2-A3,savea23(A6)
  1703. X
  1704. X    dc.w    LINEA_INIT        ; a0 -> line A variables
  1705. X
  1706. X    lea    parm_save(A4),A2    ; a2 -> parameter save area
  1707. X    move.l    (A2)+,V_OFF_AD(A0)
  1708. X    move.l    (A2)+,V_FNT_AD(A0)
  1709. X    move.w    (A2)+,V_CEL_HT(A0)
  1710. X    move.w    (A2)+,V_CEL_MY(A0)
  1711. X    move.w    (A2)+,V_CEL_WR(A0)
  1712. X    
  1713. X    movem.l    savea23(A6),A2-A3
  1714. X    }          
  1715. }
  1716. GetCurStat(onoff)
  1717. int    onoff;
  1718. {
  1719. X    long savea23[2];
  1720. X
  1721. X    asm {
  1722. X    movem.l    A2-A3,savea23(A6)
  1723. X
  1724. X    dc.w    LINEA_INIT        ; a0 -> line A variables
  1725. X    move.w    V_DISAB(A0),onoff(A6)    ; 0 = cursor visible
  1726. X    moveq    #0,D0
  1727. X    move.w    V_DISAB(A0),D0    
  1728. X    movem.l    savea23(A6),A2-A3
  1729. X    }          
  1730. }
  1731. #else
  1732. #if    ATARI & ST520 & LATTICE
  1733. X
  1734. /*
  1735. X    These routines provide support for the ATARI 1040ST using
  1736. the LATTICE compiler using the virtual VT52 Emulator
  1737. X
  1738. */
  1739. X
  1740. #define NROW    40                      /* Screen size.                 */
  1741. #define NCOL    80                      /* Edit if you want to.         */
  1742. #define    MARGIN    8            /* size of minimim margin and    */
  1743. #define    SCRSIZ    64            /* scroll size for extended lines */
  1744. #define    NPAUSE    300            /* # times thru update to pause */
  1745. #define BIAS    0x20                    /* Origin 0 coordinate bias.    */
  1746. #define ESC     0x1B                    /* ESC character.               */
  1747. #define BEL     0x07                    /* ASCII bell character         */
  1748. X
  1749. /****    ST Internals definitions        *****/
  1750. X
  1751. /*    BIOS calls */
  1752. X
  1753. #define    BCONSTAT    1    /* return input device status */
  1754. #define    CONIN        2    /* read character from device */
  1755. #define    BCONOUT        3    /* write character to device */
  1756. X
  1757. /*    XBIOS calls */
  1758. X
  1759. #define    INITMOUS    0    /* initialize the mouse */
  1760. #define    GETREZ        4    /* get current resolution */
  1761. #define    SETSCREEN    5    /* set screen resolution */
  1762. #define    SETPALETTE    6    /* set the color pallette */
  1763. #define    SETCOLOR    7    /* set or read a color */
  1764. #define    CURSCONF    21    /* set cursor configuration */
  1765. #define    IKBDWS        25    /* intelligent keyboard send command */
  1766. #define    KBDVBASE    34    /* get keyboard table base */
  1767. X
  1768. /*    GEMDOS calls */
  1769. X
  1770. #define    EXEC        0x4b    /* Exec off a process */
  1771. X
  1772. #define    CON        2    /* CON: Keyboard and screen device */
  1773. X
  1774. /*    LINE A variables    */
  1775. X
  1776. #define LINEA_INIT 0xA000
  1777. #define V_CEL_WR   -0x28
  1778. #define V_CEL_MY   -0x2a
  1779. #define V_CEL_HT   -0x2e
  1780. #define V_FNT_AD   -0x16
  1781. #define V_OFF_AD   -0x0a
  1782. #define V_DISAB    -346
  1783. X
  1784. /*    Palette color definitions    */
  1785. X
  1786. #define    LOWPAL    "000700070770007707077777"
  1787. #define    MEDPAL    "000700007777"
  1788. #define    HIGHPAL    "000111"
  1789. X
  1790. /*    ST Global definitions        */
  1791. X
  1792. /* keyboard vector table */
  1793. struct KVT {
  1794. X    long midivec;        /* midi input */
  1795. X    long vkbderr;        /* keyboard error */
  1796. X    long vmiderr;        /* MIDI error */
  1797. X    long statvec;        /* IKBD status */
  1798. X    int (*mousevec)();    /* mouse vector */
  1799. X    long clockvec;        /* clock vector */
  1800. X    long joyvec;        /* joystict vector */
  1801. } *ktable;
  1802. X
  1803. int (*sysmint)();            /* system mouse interupt handler */
  1804. X
  1805. /* mouse parameter table */
  1806. struct Param {
  1807. X    char topmode;
  1808. X    char buttons;
  1809. X    char xparam;
  1810. X    char yparam;
  1811. X    int xmax,ymax;
  1812. X    int xinitial,yinitial;
  1813. } mparam;
  1814. X
  1815. int initrez;            /* initial screen resolution */
  1816. int currez;            /* current screen resolution */
  1817. char resname[][8] = {        /* screen resolution names */
  1818. X    "LOW", "MEDIUM", "HIGH", "DENSE"
  1819. };
  1820. short spalette[16];            /* original color palette settings */
  1821. short palette[16];            /* current palette settings */
  1822. X
  1823. extern  int     ttopen();               /* Forward references.          */
  1824. extern  int     ttgetc();
  1825. extern  int     ttputc();
  1826. extern  int     ttflush();
  1827. extern  int     ttclose();
  1828. extern  int     stmove();
  1829. extern  int     steeol();
  1830. extern  int     steeop();
  1831. extern  int     stbeep();
  1832. extern  int     stopen();
  1833. extern    int    stclose();
  1834. extern    int    stgetc();
  1835. extern    int    stputc();
  1836. extern    int    strev();
  1837. extern    int    strez();
  1838. extern    int    stkopen();
  1839. extern    int    stkclose();
  1840. X
  1841. #if    COLOR
  1842. extern    int    stfcol();
  1843. extern    int    stbcol();
  1844. #endif
  1845. X
  1846. /*
  1847. X * Dispatch table. All the
  1848. X * hard fields just point into the
  1849. X * terminal I/O code.
  1850. X */
  1851. TERM    term    = {
  1852. X    NROW-1,
  1853. X        NROW-1,
  1854. X        NCOL,
  1855. X        NCOL,
  1856. X    MARGIN,
  1857. X    SCRSIZ,
  1858. X    NPAUSE,
  1859. X        &stopen,
  1860. X        &stclose,
  1861. X    &stkopen,
  1862. X    &stkclose,
  1863. X        &stgetc,
  1864. X    &stputc,
  1865. X        &ttflush,
  1866. X        &stmove,
  1867. X        &steeol,
  1868. X        &steeop,
  1869. X        &stbeep,
  1870. X        &strev,
  1871. X    &strez
  1872. #if    COLOR
  1873. X    , &stfcol,
  1874. X    &stbcol
  1875. #endif
  1876. };
  1877. X
  1878. stmove(row, col)
  1879. {
  1880. X        stputc(ESC);
  1881. X        stputc('Y');
  1882. X        stputc(row+BIAS);
  1883. X        stputc(col+BIAS);
  1884. }
  1885. X
  1886. steeol()
  1887. {
  1888. X        stputc(ESC);
  1889. X        stputc('K');
  1890. }
  1891. X
  1892. steeop()
  1893. {
  1894. #if    COLOR
  1895. X    stfcol(gfcolor);
  1896. X    stbcol(gbcolor);
  1897. #endif
  1898. X        stputc(ESC);
  1899. X        stputc('J');
  1900. }
  1901. X
  1902. strev(status)    /* set the reverse video state */
  1903. X
  1904. int status;    /* TRUE = reverse video, FALSE = normal video */
  1905. X
  1906. {
  1907. X    if (currez > 1) {
  1908. X        stputc(ESC);
  1909. X        stputc(status ? 'p' : 'q');
  1910. X    }
  1911. }
  1912. X
  1913. #if    COLOR
  1914. mapcol(clr)    /* medium rez color translation */
  1915. X
  1916. int clr;    /* emacs color number to translate */
  1917. X
  1918. {
  1919. X    static int mctable[] = {0, 1, 2, 3, 2, 1, 2, 3};
  1920. X
  1921. X    if (currez != 1)
  1922. X        return(clr);
  1923. X    else
  1924. X        return(mctable[clr]);
  1925. }
  1926. X
  1927. stfcol(color)    /* set the forground color */
  1928. X
  1929. int color;    /* color to set forground to */
  1930. X
  1931. {
  1932. X    if (currez < 2) {
  1933. X        stputc(ESC);
  1934. X        stputc('b');
  1935. X        stputc(mapcol(color));
  1936. X    }
  1937. }
  1938. X
  1939. stbcol(color)    /* set the background color */
  1940. X
  1941. int color;    /* color to set background to */
  1942. X
  1943. X
  1944. {
  1945. X    if (currez < 2) {
  1946. X        stputc(ESC);
  1947. X        stputc('c');
  1948. X        stputc(mapcol(color));
  1949. X    }
  1950. }
  1951. #endif
  1952. X
  1953. stbeep()
  1954. {
  1955. X        stputc(BEL);
  1956. X        ttflush();
  1957. }
  1958. X
  1959. domouse()    /* mouse interupt handler */
  1960. X
  1961. {
  1962. X    return((*sysmint)());
  1963. }
  1964. X
  1965. stkopen()    /* open the keyboard (and mouse) */
  1966. X
  1967. {
  1968. X    /* grab the keyboard vector table */
  1969. X    ktable = (struct KVT *)xbios(KBDVBASE);
  1970. X    sysmint = ktable->mousevec;    /* save mouse vector */
  1971. X
  1972. X    /* initialize the mouse */
  1973. X    mparam.topmode = 0;
  1974. X    mparam.buttons = 4;
  1975. X    mparam.xparam = 8;
  1976. X    mparam.yparam = 10;
  1977. X    mparam.xmax = 79;
  1978. X    mparam.ymax = 23;
  1979. X    mparam.xinitial = 0;
  1980. X    mparam.yinitial = 0;
  1981. X    xbios(INITMOUS, 4, &mparam, &domouse);
  1982. }
  1983. X
  1984. stopen()    /* open the screen */
  1985. X
  1986. {
  1987. X    int i;
  1988. X
  1989. X        ttopen();
  1990. X    eolexist = TRUE;
  1991. X
  1992. X    /* switch to a steady cursor */
  1993. X    xbios(CURSCONF, 3);
  1994. X
  1995. X    /* save the current color palette */
  1996. X    for (i=0; i<16; i++)
  1997. X        spalette[i] = xbios(SETCOLOR, i, -1);
  1998. X
  1999. X    /* and find the current resolution */
  2000. X    initrez = currez = xbios(GETREZ);
  2001. X    strcpy(sres, resname[currez]);
  2002. X
  2003. X    /* set up the screen size and palette */
  2004. X    switch (currez) {
  2005. X        case 0:    term.t_mrow = 25 - 1;
  2006. X            term.t_nrow = 25 - 1;
  2007. X            term.t_ncol = 40;
  2008. X            strcpy(palstr, LOWPAL);
  2009. X            break;
  2010. X
  2011. X        case 1: term.t_mrow = 25 - 1;
  2012. X            term.t_nrow = 25 - 1;
  2013. X            strcpy(palstr, MEDPAL);
  2014. X            break;
  2015. X
  2016. X        case 2: term.t_mrow = 40 - 1;
  2017. X            term.t_nrow = 25 - 1;
  2018. X            strcpy(palstr, HIGHPAL);
  2019. X    }
  2020. X
  2021. X    /* and set up the default palette */
  2022. X    spal(palstr);
  2023. X
  2024. X    stputc(ESC);    /* automatic overflow off */
  2025. X    stputc('w');
  2026. X    stputc(ESC);    /* turn cursor on */
  2027. X    stputc('e');
  2028. }
  2029. X
  2030. stkclose()    /* close the keyboard (and mouse) */
  2031. X
  2032. {
  2033. X    static char resetcmd[] = {0x80, 0x01};    /* keyboard reset command */
  2034. X
  2035. X    /* restore the mouse interupt routines */
  2036. X    xbios(INITMOUS, 2, &mparam, (long)sysmint);
  2037. X
  2038. X    /* and reset the keyboard controller */
  2039. X    xbios(IKBDWS, 1, &resetcmd[0]);
  2040. }
  2041. X
  2042. stclose()
  2043. X
  2044. {
  2045. X    stputc(ESC);    /* auto overflow on */
  2046. X    stputc('v');
  2047. X
  2048. X    /* switch to a flashing cursor */
  2049. X    xbios(CURSCONF, 2);
  2050. X
  2051. X    /* restore the original screen resolution */
  2052. X    strez(resname[initrez]);
  2053. X
  2054. X    /* restore the original palette settings */
  2055. X    xbios(SETPALETTE, spalette);
  2056. X
  2057. X    ttclose();
  2058. }
  2059. X
  2060. /*     spal(pstr):    reset the current palette according to a
  2061. X            "palette string" of the form
  2062. X
  2063. X    000111222333444555666777
  2064. X
  2065. X    which contains the octal values for the palette registers
  2066. */
  2067. X
  2068. spal(pstr)
  2069. X
  2070. char *pstr;    /* palette string */
  2071. X
  2072. {
  2073. X    int pal;    /* current palette position */
  2074. X    int clr;    /* current color value */
  2075. X    int i;
  2076. X
  2077. X    for (pal = 0; pal < 16; pal++) {
  2078. X        if (*pstr== 0)
  2079. X            break;
  2080. X
  2081. X        /* parse off a color */
  2082. X        clr = 0;
  2083. X        for (i = 0; i < 3; i++)
  2084. X            if (*pstr)
  2085. X                clr = clr * 16 + (*pstr++ - '0');
  2086. X        palette[pal] = clr;
  2087. X    };
  2088. X
  2089. X    /* and now set it */
  2090. X    xbios(SETPALETTE, palette);
  2091. }
  2092. X
  2093. stgetc()    /* get a char from the keyboard */
  2094. X
  2095. {
  2096. X    int rval;        /* return value from BIOS call */
  2097. X    static int funkey = 0;    /* held fuction key scan code */
  2098. X
  2099. X    /* if there is a pending function key, return it */
  2100. X    if (funkey) {
  2101. X        rval = funkey;
  2102. X        funkey = 0;
  2103. X    } else {
  2104. X        /* waiting... flash the cursor */
  2105. X        xbios(CURSCONF, 2);
  2106. X
  2107. X        /* get the character */
  2108. X        rval = bios(CONIN, CON);
  2109. X        if ((rval & 255) == 0) {
  2110. X            funkey = (rval >> 16) & 255;
  2111. X            rval = 0;
  2112. X        }
  2113. X
  2114. X        /* and switch to a steady cursor */
  2115. X        xbios(CURSCONF, 3);
  2116. X    }
  2117. X
  2118. X    return(rval & 255);
  2119. }
  2120. X
  2121. stputc(c)    /* output char c to the screen */
  2122. X
  2123. char c;        /* character to print out */
  2124. X
  2125. {
  2126. X    bios(BCONOUT, CON, c);
  2127. }
  2128. X
  2129. strez(newrez)    /* change screen resolution */
  2130. X
  2131. char *newrez;    /* requested resolution */
  2132. X
  2133. {
  2134. X    int nrez;    /* requested new resolution */
  2135. X
  2136. X    /* first, decode the resolution name */
  2137. X    for (nrez = 0; nrez < 4; nrez++)
  2138. X        if (strcmp(newrez, resname[nrez]) == 0)
  2139. X            break;
  2140. X    if (nrez == 4) {
  2141. X        mlwrite("%%No such resolution");
  2142. X        return(FALSE);
  2143. X    }
  2144. X
  2145. X    /* next, make sure this resolution is legal for this monitor */
  2146. X    if ((currez < 2 && nrez > 1) || (currez > 1 && nrez < 2)) {
  2147. X        mlwrite("%%Resolution illegal for this monitor");
  2148. X        return(FALSE);
  2149. X    }
  2150. X
  2151. X    /* eliminate non-changes */
  2152. X    if (currez == nrez)
  2153. X        return(TRUE);
  2154. X
  2155. X    /* finally, make the change */
  2156. X    switch (nrez) {
  2157. X        case 0:    /* low resolution - 16 colors */
  2158. X            newwidth(TRUE, 40);
  2159. X            strcpy(palstr, LOWPAL);
  2160. X            xbios(SETSCREEN, -1, -1, 0);
  2161. X            break;
  2162. X
  2163. X        case 1:    /* medium resolution - 4 colors */
  2164. X            newwidth(TRUE, 80);
  2165. X            strcpy(palstr, MEDPAL);
  2166. X            xbios(SETSCREEN, -1, -1, 1);
  2167. X            break;
  2168. X
  2169. X        case 2:    /* High resolution - 2 colors - 25 lines */
  2170. X            newscreensize(25, term.t_ncol);
  2171. X            strcpy(palstr, HIGHPAL);
  2172. X            /* change char set back to normal */
  2173. X            break;
  2174. X
  2175. X        case 3:    /* Dense resolution - 2 colors - 40 lines */
  2176. X            newscreensize(40, term.t_ncol);
  2177. X            strcpy(palstr, HIGHPAL);
  2178. X            /*change char set size */
  2179. X            break;
  2180. X    }
  2181. X
  2182. X    /* and set up the default palette */
  2183. X    spal(palstr);
  2184. X    currez = nrez;
  2185. X    strcpy(sres, resname[currez]);
  2186. X
  2187. X    stputc(ESC);    /* automatic overflow off */
  2188. X    stputc('w');
  2189. X    stputc(ESC);    /* turn cursor on */
  2190. X    stputc('e');
  2191. X
  2192. X    return(TRUE);
  2193. }
  2194. X
  2195. system(cmd)    /* call the system to execute a new program */
  2196. X
  2197. char *cmd;    /* command to execute */
  2198. X
  2199. {
  2200. X    char *pptr;            /* pointer into program name */
  2201. X    char pname[NSTRING];        /* name of program to execute */
  2202. X    char tail[NSTRING];        /* command tail */
  2203. X
  2204. X    /* scan off program name.... */
  2205. X    pptr = pname;
  2206. X    while (*cmd && (*cmd != ' ' && *cmd != '\t'))
  2207. X        *pptr++ = *cmd++;
  2208. X    *pptr = 0;
  2209. X
  2210. X    /* create program name length/string */
  2211. X    tail[0] = strlen(cmd);
  2212. X    strcpy(&tail[1], cmd);
  2213. X
  2214. X    /* go do it! */
  2215. X    return(gemdos(        (int)EXEC,
  2216. X                (int)0,
  2217. X                (char *)pname,
  2218. X                (char *)tail,
  2219. X                (char *)NULL));
  2220. }
  2221. X
  2222. #if    TYPEAH
  2223. typahead()
  2224. X
  2225. {
  2226. X    int rval;    /* return value from BIOS call */
  2227. X
  2228. X    /* get the status of the console */
  2229. X    rval = bios(BCONSTAT, CON);
  2230. X
  2231. X    /* end return the results */
  2232. X    if (rval == 0)
  2233. X        return(FALSE);
  2234. X    else
  2235. X        return(TRUE);
  2236. }
  2237. #endif
  2238. X
  2239. #if    FLABEL
  2240. fnclabel(f, n)        /* label a function key */
  2241. X
  2242. int f,n;    /* default flag, numeric argument [unused] */
  2243. X
  2244. {
  2245. X    /* on machines with no function keys...don't bother */
  2246. X    return(TRUE);
  2247. }
  2248. #endif
  2249. #else
  2250. sthello()
  2251. {
  2252. }
  2253. #endif
  2254. #endif
  2255. X
  2256. SHAR_EOF
  2257. chmod 0444 st520.c ||
  2258. echo 'restore of st520.c failed'
  2259. Wc_c="`wc -c < 'st520.c'`"
  2260. test 19931 -eq "$Wc_c" ||
  2261.     echo 'st520.c: original size 19931, current size' "$Wc_c"
  2262. # ============= tags ==============
  2263. echo 'x - extracting tags (Text)'
  2264. sed 's/^X//' << 'SHAR_EOF' > 'tags' &&
  2265. ABORT    estruct.h    /^#define ABORT    2            \/* Death, ESC, abort, etc.    *\/$/
  2266. ABS    estruct.h    /^#define ABS    0x10    \/* command causes absolute (i.e. non-relative) motion *\/$/
  2267. AEDIT    estruct.h    /^#define    AEDIT    1    \/* advanced editing options: e.g. en\/detabbing    *\/$/
  2268. ALTDOTO    undo.c    /^#define ALTDOTO(bp) (bp->b_uddotos[1^(bp->b_udstki/
  2269. ALTDOTP    undo.c    /^#define ALTDOTP(bp) (bp->b_uddotps[1^(bp->b_udstki/
  2270. ALTSTK    undo.c    /^#define ALTSTK(bp) (&(bp->b_udstks[1^(bp->b_udstki/
  2271. AMG_MAXBUF    termio.c    /^#define AMG_MAXBUF      1024L$/
  2272. AMIGA    estruct.h    /^#define AMIGA    0            \/* AmigaDOS            *\/$/
  2273. ANSI    estruct.h    /^#define ANSI    0            \/* ANSI escape sequences    *\/$/
  2274. ANY    estruct.h    /^#define    ANY        2$/
  2275. APROP    estruct.h    /^#define    APROP    1    \/* Add code for Apropos command    (needs REBIND)    *\/$/
  2276. AT386    estruct.h    /^#define AT386    0            \/* AT style 386 unix console    *\/$/
  2277. ATARI    estruct.h    /^#define    ATARI    0            \/* Atari 520\/1040ST screen    *\/$/
  2278. AZTEC    estruct.h    /^#define    AZTEC    0    \/* Aztec C 3.20e *\/$/
  2279. BACK    csrch.c    /^#define BACK 0$/
  2280. BANG    estruct.h    /^#define BANG    (4<<16)        \/* allow a ! after the command name *\/$/
  2281. BEL    tcap.c    /^#define BEL     0x07$/
  2282. BFCHG    estruct.h    /^#define BFCHG    0x02            \/* Changed since last write    *\/$/
  2283. SHAR_EOF
  2284. true || echo 'restore of tags failed'
  2285. echo 'End of Vile part 13'
  2286. echo 'File tags is continued in part 14'
  2287. echo 14 > _shar_seq_.tmp
  2288. exit 0
  2289. -- 
  2290.         paul fox, pgf@cayman.com, (617)494-1999
  2291.         Cayman Systems, 26 Landsdowne St., Cambridge, MA 02139
  2292.