home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / misc / volume3 / mg2a / part12 < prev    next >
Encoding:
Text File  |  1989-02-03  |  58.3 KB  |  2,433 lines
  1. Path: xanth!mcnc!ncsuvx!lll-winken!lll-tis!ames!necntc!ncoast!allbery
  2. From: BLARSON@ECLA.USC.EDU (Bob Larson)
  3. Newsgroups: comp.sources.misc
  4. Subject: v03i036: mg 2a part 12 of 15
  5. Message-ID: <12401301117.47.BLARSON@ECLA.USC.EDU>
  6. Date: 26 May 88 05:01:37 GMT
  7. Sender: allbery@ncoast.UUCP
  8. Reply-To: BLARSON@ECLA.USC.EDU (Bob Larson)
  9. Lines: 2420
  10. Approved: allbery@ncoast.UUCP
  11.  
  12. comp.sources.misc: Volume 3, Issue 36
  13. Submitted-By: "Bob Larson" <BLARSON@ECLA.USC.EDU>
  14. Archive-Name: mg2a/Part12
  15.  
  16. #    This is a shell archive.
  17. #    Remove everything above and including the cut line.
  18. #    Then run the rest of the file through sh.
  19. #----cut here-----cut here-----cut here-----cut here----#
  20. #!/bin/sh
  21. # shar:    Shell Archiver
  22. #    Run the following text with /bin/sh to create:
  23. #    sys/atari/readme.1st
  24. #    sys/atari/alloc.c
  25. #    sys/atari/build.g
  26. #    sys/atari/cinfo.c
  27. #    sys/atari/diredsup.c
  28. #    sys/atari/fileio.c
  29. #    sys/atari/gemstart.s
  30. #    sys/atari/getn.s
  31. #    sys/atari/makesys.mwc
  32. #    sys/atari/mg.ini
  33. #    sys/atari/mglink.inp
  34. #    sys/atari/misc.c
  35. #    sys/atari/sysdef.h
  36. #    sys/atari/term.c
  37. #    sys/atari/ttydef.h
  38. #    sys/atari/ttyio.c
  39. #    sys/atari/varargs.h
  40. # This archive created: Mon May 23 18:14:08 1988
  41. # By:    blarson
  42. if test -d sys
  43. then true
  44. else mkdir sys
  45. fi
  46. if test -d sys/atari
  47. then true
  48. else mkdir sys/atari
  49. fi
  50. cat << \SHAR_EOF > sys/atari/readme.1st
  51. This file documents the Atari-specific features of MG2A.  Please refer
  52. to the MG manual and the tutorial for more general information about
  53. how to use MG.
  54.  
  55. This version of MG has been brought to you by....
  56.  
  57.     Sandra Loosemore (sandra@cs.utah.edu, utah-cs!sandra)
  58.     Marion Hakanson (hakanson@cs.orst.edu, orstcs!hakanson)
  59.  
  60.  
  61.  
  62. Keyboard Handling:
  63. ------------------
  64.  
  65. The ALT key acts as the META key.  The command meta-key-mode can be 
  66. used to toggle this behavior.  (On non-US keyboards, the ALT key is 
  67. normally used as a modifier with certain other keys to produce printing 
  68. characters.)
  69.  
  70. MG supports 8-bit characters, although since neither of us have
  71. European keyboards we have not been able to test this thoroughly.
  72.  
  73. The function keys may be bound to commands, although there are no 
  74. default bindings established for these keys.  F1-F10 are as on the 
  75. keyboard, F11-F20 are the shifted F1-F10, and F21-F28 are Help, Undo, 
  76. Insert, Up, Clr/Home, Left, Down, and Right, respectively.
  77.  
  78.  
  79. Startup Files:
  80. --------------
  81.  
  82. MG looks for its startup file first as MG.INI in the current directory,
  83. and it then looks for the file specified by the environment variable
  84. MGINIT if that fails.  The code to look up the environment variables
  85. checks for all of the various environment styles that are supported
  86. by common shells such as the MWC shell and Gulam, as well as the one
  87. built for the desktop by GEMBOOT.
  88.  
  89.  
  90. Spawning a Shell:
  91. -----------------
  92.  
  93. The suspend-emacs command checks the SHELL environment variable to
  94. determine what program to run.  If the environment variable is not
  95. set, or if the attempt to execute the program fails (i.e., the program
  96. is not found), MG will prompt for a command to execute.
  97.  
  98.  
  99. Other Options:
  100. --------------
  101.  
  102. Most of the optional features described in the MG manual are enabled,
  103. including the GOSMACS and DIRED features.  The major piece of missing
  104. functionality is the regular expression code, which is nonportable and
  105. won't compile on the ST.  There is also no support for backup files yet.
  106.  
  107.  
  108. Rebuilding MG:
  109. --------------
  110.  
  111. MG has been developed using both the Alcyon (v4.14) and Mark Williams 
  112. (v2.0) C compilers.  Makefiles (maketop.mwc and makesys.mwc) are provided 
  113. for MWC, and a Gulam shell script (build.g, also mglink.inp) for Alcyon.  
  114. You may need to tweak these files if you have moved things around.
  115.  
  116. Here is a list of the ST-specific source files:
  117.  
  118.     chrdef.h    Character macro definition file
  119.     sysdef.h    ST-specific definitions
  120.     ttydef.h    More ST-specific definitions
  121.     varargs.h       Definitions for varargs macros
  122.     alloc.c        New "malloc" for Alcyon C, also used by MWC.
  123.     cinfo.c        Character functions.
  124.     diredsup.c    Functions to support the "cd" and "dired" features.
  125.     fileio.c    File i/o functions.
  126.     misc.c        Functions to support "spawn", etc.
  127.     term.c        High-level screen manipulation functions.
  128.     ttyio.c        Low-level terminal i/o functions.
  129.     getn.s        Functions to determine screen resolution.
  130.     gemstart.s      Needed for Alcyon C
  131.  
  132.  
  133. Changes since MG1B:
  134. -------------------
  135.  
  136. File and terminal i/o have been completely rewritten to use low-level
  137. GemDOS functions instead of their C equivalents.  It's now much faster.
  138.  
  139. Improved memory management (new implementation of "malloc" and friends
  140. for Alcyon C) makes the "spawn" command more useful.
  141.  
  142. The use of the ALT key as a meta key and support for 8-bit characters is
  143. new.
  144.  
  145. The old "dirlist" function has been replaced by dired mode.
  146.  
  147. Environment variables are now used to specify the startup file and the
  148. shell to run for suspend-emacs.
  149.  
  150. A few minor cleanups and optimizations, some of which speed things
  151. up markedly.
  152.  
  153.  
  154. Bugs
  155. ----
  156.  
  157. There is a bug in TOS that may result in MG creating multiple copies of
  158. files with the same name.  It only seems to happen with very short files.
  159.  
  160. There has been some question raised about the use of the "conterm"
  161. system variable on the "new" (Mega-ST) TOS ROMs, even though such use
  162. is documented in the MWC manual, and elsewhere.  Perhaps someone can
  163. test this code on such a system and let us know if there are problems.
  164. A workaround would be to use Getshifts() separately, instead of having
  165. the kbshift value returned by Bconin().
  166.  
  167. SHAR_EOF
  168. cat << \SHAR_EOF > sys/atari/alloc.c
  169. /* alloc.c -- replacement malloc and friends
  170.  *
  171.  * author :  Sandra Loosemore
  172.  * date   :  24 Oct 1987
  173.  *
  174.  * This file is a replacement for the usual definitions of malloc and free.
  175.  * The ST Malloc routine is called to get more memory from the system.
  176.  * Note that the memory that is Malloc'ed is never Mfree'd.
  177.  *
  178.  */
  179.  
  180.  
  181. #include <osbind.h>
  182. #define NULL 0L
  183.  
  184.  
  185. /* This is the default size for grabbing memory from the system with Malloc.
  186.  *    If you try to malloc a piece bigger than this, it will Malloc a
  187.  *    piece exactly the right size.  Ideally, it should be quite a bit
  188.  *    larger than the average size of things you are allocating (assuming
  189.  *    you are going to allocate lots of them).
  190.  */
  191.  
  192. static long mchunk = 16384L;           /* Size for grabbing memory */
  193.  
  194.  
  195. /* Each call to malloc returns a chunk; freeing it puts the chunk on
  196.  *    the free list.  The "next" field is only used for freed blocks.
  197.  *      The "nbytes" field is the size of the body of the chunk, not
  198.  *    the entire chunk.
  199.  */
  200.  
  201. typedef struct chunk {
  202.     long nbytes;
  203.     union {
  204.         struct chunk *next;
  205.         char body[1];
  206.         } info;
  207.     } CHUNK;
  208.  
  209. #define Nbytes(c) (c)->nbytes
  210. #define Next(c) (c)->info.next
  211. #define Body(c) (c)->info.body
  212.  
  213. static CHUNK *freelist = NULL;
  214.  
  215.  
  216. /* Return a block at least "size" bytes long.  Grab more memory if there
  217.  *     isn't anything on the free list that big.  If the block is just big
  218.  *     enough, remove it from the free list and return the whole thing.
  219.  *    Otherwise, carve a piece off the front.
  220.  * Note that the size is rounded up to make it an even number, and it must
  221.  *    also be at least big enough to hold the next pointer when the block
  222.  *    is freed.
  223.  */
  224.  
  225. char *alloc (size)
  226.     long size;
  227. {   register CHUNK *this, *last, *new;
  228.     long temp;
  229.     size = (size + 1) & 0xfffe;                       /* Word alignment */
  230.     if (size < sizeof(CHUNK *))  size = sizeof(CHUNK *);   /* Minimum size */
  231.     this = freelist;
  232.     last = NULL;
  233.     while (this != NULL)  {
  234.         if (Nbytes(this) >= size)  break;
  235.         last = this;
  236.         this = Next(this);
  237.         }
  238.     if (this == NULL)  {
  239.         temp = ((size < mchunk) ? mchunk : size);
  240.         this = (CHUNK *) Malloc (temp + sizeof(long));
  241.         if (!this)  return(NULL);
  242.         Nbytes(this) = temp;
  243.     free(Body(this));
  244.         this = freelist;
  245.     last = NULL;
  246.     while (this != NULL)  {
  247.             if (Nbytes(this) >= size)  break;
  248.             last = this;
  249.             this = Next(this);
  250.         }
  251.         }
  252.     temp = Nbytes(this) - size - sizeof(long);
  253.     if (temp <= sizeof(CHUNK))  {               /* Use the whole thing */
  254.         if (last)
  255.         Next(last) = Next(this);
  256.     else
  257.         freelist = Next(this);
  258.         return(Body(this));
  259.         }
  260.     else  {                                         /* Grab some off end */
  261.         new = (CHUNK *) ((char *)this + size + sizeof(long));
  262.     Nbytes(new) = temp;
  263.     Next(new) = Next(this);
  264.     if (last)
  265.         Next(last) = new;
  266.     else
  267.         freelist = new;
  268.     Nbytes(this) = size;
  269.     return(Body(this));
  270.         }
  271.     }
  272.  
  273.  
  274.  
  275. /* These are the user-accessible entry points */
  276.  
  277. char *malloc (size)
  278.     unsigned size;
  279. {   return (alloc((long)size));
  280.     }
  281.  
  282. #if 0    /* calloc not used in mg */
  283. char *calloc (number, size)
  284.     unsigned number, size;
  285. {   return (alloc ((long)number*size));
  286.     }
  287. #endif
  288.  
  289. char *realloc (oldptr, newsize)
  290.     register char *oldptr;
  291.     unsigned newsize;
  292. {   long oldsize;
  293.     register char *newptr;
  294.     register unsigned i;
  295.     CHUNK *block;
  296.     block = (CHUNK *) (oldptr - sizeof(long));
  297.     oldsize = Nbytes(block);
  298.     if (newsize > oldsize)  {
  299.         newptr = alloc((long)newsize);
  300.         for (i=0; i<oldsize; i++)
  301.         newptr[i] = oldptr[i];
  302.         free(oldptr);        
  303.     return(newptr);
  304.         }
  305.     else
  306.         return(oldptr);
  307.     }
  308.  
  309.     
  310. /* Free a pointer.  The freelist is maintained in sorted order, so loop
  311.  *    through until we find the block on either side of the one we're
  312.  *    freeing.  Then see if we can merge this block with either one.
  313.  */
  314.  
  315. free (ptr)
  316.     char *ptr;
  317. {   register CHUNK *last, *this, *block;
  318.  
  319.     /* Find where to insert the block in the free list. */
  320.  
  321.     block = (CHUNK *)(ptr - sizeof(long));
  322.     this = freelist;
  323.     last = NULL;
  324.     while (this && (this < block))  {
  325.         last = this;
  326.     this = Next(this);
  327.     }
  328.  
  329.     /* Can we merge it with the next block?  */
  330.  
  331.     if (this && ((ptr + Nbytes(block)) == this))  {
  332.         Nbytes(block) = Nbytes(block) + Nbytes(this) + sizeof(long);
  333.     Next(block) = Next(this);
  334.     }
  335.     else
  336.         Next(block) = this;
  337.  
  338.     /* Can we merge it with the previous block?  */
  339.  
  340.     if (last && ((Body(last) + Nbytes(last)) == block))  {
  341.         Nbytes(last) = Nbytes(last) + Nbytes(block) + sizeof(long);
  342.     Next(last) = Next(block);
  343.         }
  344.     else if (last)
  345.         Next(last) = block;
  346.     else
  347.         freelist = block;
  348.     }
  349.  
  350.  
  351. /* A debug routine to help me make sure that the freelist is compacted
  352.  *    properly.
  353.  */
  354.  
  355. #ifdef DEBUG
  356.  
  357. dumpfree ()
  358. {   CHUNK *junk;
  359.     printf ("Dump of free list:\n");
  360.     junk = freelist;
  361.     while (junk)  {
  362.         printf ("    Base %ld, size %ld\n", (long)(Body(junk)), Nbytes(junk));
  363.     junk = Next(junk);
  364.     }
  365.     }
  366. #endif
  367. SHAR_EOF
  368. cat << \SHAR_EOF > sys/atari/build.g
  369. # build file for MG using Alcyon C and the GULAM shell
  370. # execute this from the directory sys\atari 
  371. #
  372. #
  373. # First make sure that there are stubs for the include files at top level 
  374. # 
  375. cd ..\..  
  376. if { -e chrdef.h } == 0
  377.     echo '#include "sys\atari\chrdef.h"' > chrdef.h
  378.     endif
  379. if { -e sysdef.h } == 0
  380.     echo '#include "sys\atari\sysdef.h"' > sysdef.h
  381.     endif
  382. if { -e ttydef.h } == 0
  383.     echo '#include "sys\atari\ttydef.h"' > ttydef.h
  384.     endif
  385. if { -e varargs.h } == 0
  386.     echo '#include "sys\atari\varargs.h"' > varargs.h
  387.     endif
  388. #
  389. #
  390. # Recompile all the top-level files
  391. #
  392. cc basic
  393. cc buffer
  394. cc dir
  395. cc dired
  396. cc display
  397. cc echo
  398. cc extend
  399. cc file
  400. cc help
  401. cc kbd
  402. cc keymap
  403. cc line
  404. cc macro
  405. cc main
  406. cc match
  407. cc modes
  408. cc paragrap
  409. cc random
  410. cc re_searc
  411. cc regex
  412. cc region
  413. cc search
  414. cc version
  415. cc window
  416. cc word
  417. #
  418. #
  419. # Now do all of the system-specific ones
  420. #
  421. cd sys\atari
  422. cc alloc
  423. cc cinfo
  424. cc diredsup
  425. cc fileio
  426. cc misc
  427. cc term
  428. cc ttyio
  429. as68 -l -u -s c: gemstart.s
  430. as68 -l -u -s c: getn.s
  431. #
  432. #
  433. # Now do the link
  434. #
  435. aln -c mglink.inp
  436. SHAR_EOF
  437. cat << \SHAR_EOF > sys/atari/cinfo.c
  438. /* cinfo.c -- character class tables for the Atari ST 8-bit character set
  439.  *
  440.  * author :  Sandra Loosemore
  441.  * date   :  26 Oct 1987
  442.  *
  443.  */
  444.  
  445. #include    "..\..\def.h"
  446.  
  447. /*
  448.  * This table, indexed by a character drawn
  449.  * from the 256 member character set, is used by my
  450.  * own character type macros to answer questions about the
  451.  * type of a character. It handles the full multinational
  452.  * character set, and lets me ask some questions that the
  453.  * standard "ctype" macros cannot ask.
  454.  */
  455.  
  456. char cinfo[256] = {
  457.     _C,        _C,        _C,        _C,    /* 0x0X */
  458.     _C,        _C,        _C,        _C,
  459.     _C,        _C,        _C,        _C,
  460.     _C,        _C,        _C,        _C,
  461.     _C,        _C,        _C,        _C,    /* 0x1X */
  462.     _C,        _C,        _C,        _C,
  463.     _C,        _C,        _C,        _C,
  464.     _C,        _C,        _C,        _C,
  465.     0,        _P,        0,        0,    /* 0x2X */
  466.     _W,        _W,        0,        _W,
  467.     0,        0,        0,        0,
  468.     0,        0,        _P,        0,
  469.     _W,        _W,        _W,        _W,    /* 0x3X */
  470.     _W,        _W,        _W,        _W,
  471.     _W,        _W,        0,        0,
  472.     0,        0,        0,        _P,
  473.     0,        _U|_W,        _U|_W,        _U|_W,    /* 0x4X */
  474.     _U|_W,        _U|_W,        _U|_W,        _U|_W,
  475.     _U|_W,        _U|_W,        _U|_W,        _U|_W,
  476.     _U|_W,        _U|_W,        _U|_W,        _U|_W,
  477.     _U|_W,        _U|_W,        _U|_W,        _U|_W,    /* 0x5X */
  478.     _U|_W,        _U|_W,        _U|_W,        _U|_W,
  479.     _U|_W,        _U|_W,        _U|_W,        0,
  480.     0,        0,        0,        0,
  481.     0,        _L|_W,        _L|_W,        _L|_W,    /* 0x6X */
  482.     _L|_W,        _L|_W,        _L|_W,        _L|_W,
  483.     _L|_W,        _L|_W,        _L|_W,        _L|_W,
  484.     _L|_W,        _L|_W,        _L|_W,        _L|_W,
  485.     _L|_W,        _L|_W,        _L|_W,        _L|_W,    /* 0x7X */
  486.     _L|_W,        _L|_W,        _L|_W,        _L|_W,
  487.     _L|_W,        _L|_W,        _L|_W,        0,
  488.     0,        0,        0,        _C,
  489.     _U|_W,        _L|_W,        _L|_W,        _L|_W,    /* 0x8X */
  490.     _L|_W,        _L|_W,        _L|_W,        _L|_W,
  491.     _L|_W,        _L|_W,        _L|_W,        _L|_W,
  492.     _L|_W,        _L|_W,        _U|_W,        _U|_W,
  493.     _U|_W,        _L|_W,        _U|_W,        _L|_W,    /* 0x9X */
  494.     _L|_W,        _L|_W,        _L|_W,        _L|_W,
  495.     _L|_W,        _U|_W,        _U|_W,        0,
  496.     0,        0,        _L|_W,        0,
  497.     _L|_W,        _L|_W,        _L|_W,        _L|_W,    /* 0xAX */
  498.     _L|_W,        _U|_W,        _L|_W,        _L|_W,
  499.     0,        0,        0,        0,
  500.     0,        0,        0,        0,
  501.     _L|_W,        _L|_W,        _U|_W,        _L|_W,    /* 0xBX */
  502.     _L|_W,        _U|_W,        _U|_W,        _U|_W,
  503.     _U|_W,        0,        0,        0,
  504.     0,        0,        0,        0,
  505.     _L|_W,        _U|_W,        0,        0,    /* 0xCX */
  506.     0,        0,        0,        0,
  507.     0,        0,        0,        0,
  508.     0,        0,        0,        0,
  509.     0,        0,        0,        0,    /* 0xDX */
  510.     0,        0,        0,        0,
  511.     0,        0,        0,        0,
  512.     0,        0,        0,        0,
  513.     0,        0,        0,        0,    /* 0xEX */
  514.     0,        0,        0,        0,
  515.     0,        0,        0,        0,
  516.     0,        0,        0,        0,
  517.     0,        0,        0,        0,    /* 0xFX */
  518.     0,        0,        0,        0,
  519.     0,        0,        0,        0,
  520.     0,        0,        0,        0
  521. };
  522.  
  523.  
  524. /* Convert upper to lower and vice versa.  This is borrowed from
  525.  * Bernhard Nebel.
  526.  */
  527.  
  528. char cupper[256] = {
  529.     0x00,    0x01,    0x02,    0x03,    0x04,    0x05,    0x06,    0x07,
  530.     0x08,    0x09,    0x0a,    0x0b,    0x0c,    0x0d,    0x0e,    0x0f,
  531.     0x10,    0x11,    0x12,    0x13,    0x14,    0x15,    0x16,    0x17,
  532.     0x18,    0x19,    0x1a,    0x1b,    0x1c,    0x1d,    0x1e,    0x1f,
  533.     0x20,    0x21,    0x22,    0x23,    0x24,    0x25,    0x26,    0x27,
  534.     0x28,    0x29,    0x2a,    0x2b,    0x2c,    0x2d,    0x2e,    0x2f,
  535.     0x30,    0x31,    0x32,    0x33,    0x34,    0x35,    0x36,    0x37,
  536.     0x38,    0x39,    0x3a,    0x3b,    0x3c,    0x3d,    0x3e,    0x3f,
  537.     0x40,    0x41,    0x42,    0x43,    0x44,    0x45,    0x46,    0x47,
  538.     0x48,    0x49,    0x4a,    0x4b,    0x4c,    0x4d,    0x4e,    0x4f,
  539.     0x50,    0x51,    0x52,    0x53,    0x54,    0x55,    0x56,    0x57,
  540.     0x58,    0x59,    0x5a,    0x5b,    0x5c,    0x5d,    0x5e,    0x5f,
  541.     0x40,    0x41,    0x42,    0x43,    0x44,    0x45,    0x46,    0x47,
  542.     0x48,    0x49,    0x4a,    0x4b,    0x4c,    0x4d,    0x4e,    0x4f,
  543.     0x50,    0x51,    0x52,    0x53,    0x54,    0x55,    0x56,    0x57,
  544.     0x58,    0x59,    0x5a,    0x7b,    0x7c,    0x7d,    0x7e,    0x7f,
  545.     0x80,    0x9a,    0x90,    0x41,    0x8e,    0xb6,    0x8f,    0x80,
  546.     0x45,    0x45,    0x45,    0x49,    0x49,    0x49,    0x8e,    0x8f,
  547.     0x90,    0x92,    0x92,    0x4f,    0x99,    0x4f,    0x55,    0x55,
  548.     0x59,    0x99,    0x9a,    0x9b,    0x9c,    0x9d,    0x9e,    0x9f,
  549.     0x41,    0x49,    0x4f,    0x55,     0xa5,    0xa5,    0x41,    0x4f,
  550.     0xa8,    0xa9,    0xaa,    0xab,    0xac,    0xad,    0xae,    0xaf,
  551.     0xb7,    0xb8,    0xb2,    0xb2,    0xb5,    0xb5,    0xb6,    0xb7,
  552.     0xb8,    0xb9,    0xba,    0xbb,    0xbc,    0xbd,    0xbe,    0xbf,
  553.     0xc1,    0xc1,    0xc2,    0xc3,    0xc4,    0xc5,    0xc6,    0xc7,
  554.     0xc8,    0xc9,    0xca,    0xcb,    0xcc,    0xcd,    0xce,    0xcf,
  555.     0xd0,    0xd1,    0xd2,    0xd3,    0xd4,    0xd5,    0xd6,    0xd7,
  556.     0xd8,    0xd9,    0xda,    0xdb,    0xdc,    0xdd,    0xde,    0xdf,
  557.     0xe0,    0xe1,    0xe2,    0xe3,    0xe4,    0xe5,    0xe6,    0xe7,
  558.     0xe8,    0xe9,    0xea,    0xeb,    0xec,    0xed,    0xee,    0xef,
  559.     0xf0,    0xf1,    0xf2,    0xf3,    0xf4,    0xf5,    0xf6,    0xf7,
  560.     0xf8,    0xf9,    0xfa,    0xfb,    0xfc,    0xfd,    0xfe,    0xff
  561.     };
  562.  
  563. char clower[256] = {
  564.     0x00,    0x01,    0x02,    0x03,    0x04,    0x05,    0x06,    0x07,
  565.     0x08,    0x09,    0x0a,    0x0b,    0x0c,    0x0d,    0x0e,    0x0f,
  566.     0x10,    0x11,    0x12,    0x13,    0x14,    0x15,    0x16,    0x17,
  567.     0x18,    0x19,    0x1a,    0x1b,    0x1c,    0x1d,    0x1e,    0x1f,
  568.     0x20,    0x21,    0x22,    0x23,    0x24,    0x25,    0x26,    0x27,
  569.     0x28,    0x29,    0x2a,    0x2b,    0x2c,    0x2d,    0x2e,    0x2f,
  570.     0x30,    0x31,    0x32,    0x33,    0x34,    0x35,    0x36,    0x37,
  571.     0x38,    0x39,    0x3a,    0x3b,    0x3c,    0x3d,    0x3e,    0x3f,
  572.     0x60,    0x61,    0x62,    0x63,    0x64,    0x65,    0x66,    0x67,
  573.     0x68,    0x69,    0x6a,    0x6b,    0x6c,    0x6d,    0x6e,    0x6f,
  574.     0x70,    0x71,    0x72,    0x73,    0x74,    0x75,    0x76,    0x77,
  575.     0x78,    0x79,    0x7a,    0x5b,    0x5c,    0x5d,    0x5e,    0x5f,
  576.     0x60,    0x61,    0x62,    0x63,    0x64,    0x65,    0x66,    0x67,
  577.     0x68,    0x69,    0x6a,    0x6b,    0x6c,    0x6d,    0x6e,    0x6f,
  578.     0x70,    0x71,    0x72,    0x73,    0x74,    0x75,    0x76,    0x77,
  579.     0x78,    0x79,    0x7a,    0x7b,    0x7c,    0x7d,    0x7e,    0x7f,
  580.     0x87,    0x81,    0x82,    0x83,    0x84,    0x85,    0x86,    0x87,
  581.     0x88,    0x89,    0x8a,    0x8b,    0x8c,    0x8d,    0x84,    0x86,
  582.     0x82,    0x91,    0x91,    0x93,    0x94,    0x95,    0x96,    0x97,
  583.     0x98,    0x94,    0x81,    0x9b,    0x9c,    0x9d,    0x9e,    0x9f,
  584.     0xa0,    0xa1,    0xa2,    0xa3,    0xa4,    0xa4,    0xa6,    0xa7,
  585.     0xa8,    0xa9,    0xaa,    0xab,    0xac,    0xad,    0xae,    0xaf,
  586.     0xb0,    0xb1,    0xb1,    0xb3,    0xb4,    0xb4,    0x85,    0xb0,
  587.     0xb1,    0xb9,    0xba,    0xbb,    0xbc,    0xbd,    0xbe,    0xbf,
  588.     0xc0,    0xc0,    0xc2,    0xc3,    0xc4,    0xc5,    0xc6,    0xc7,
  589.     0xc8,    0xc9,    0xca,    0xcb,    0xcc,    0xcd,    0xce,    0xcf,
  590.     0xd0,    0xd1,    0xd2,    0xd3,    0xd4,    0xd5,    0xd6,    0xd7,
  591.     0xd8,    0xd9,    0xda,    0xdb,    0xdc,    0xdd,    0xde,    0xdf,
  592.     0xe0,    0xe1,    0xe2,    0xe3,    0xe4,    0xe5,    0xe6,    0xe7,
  593.     0xe8,    0xe9,    0xea,    0xeb,    0xec,    0xed,    0xee,    0xef,
  594.     0xf0,    0xf1,    0xf2,    0xf3,    0xf4,    0xf5,    0xf6,    0xf7,
  595.     0xf8,    0xf9,    0xfa,    0xfb,    0xfc,    0xfd,    0xfe,    0xff
  596.     };
  597.     
  598.  
  599. /*
  600.  * Find the name of a keystroke.  Needs to be changed to handle 8-bit printing
  601.  * characters and function keys better.     Returns a pointer to the terminating
  602.  * '\0'.
  603.  */
  604.  
  605. char *keyname(cp, k)
  606. register char *cp;
  607. register int k;
  608. {
  609.     register char *np;
  610. #ifdef    FKEYS
  611.     extern char *keystrings[];
  612. #endif /* FKEYS */
  613.  
  614.     if(k<0) k &= 0377;               /* if char was sign extened */
  615.     switch(k) {
  616.     case CCHR('@'): np = "NUL"; break;
  617.     case CCHR('I'): np = "TAB"; break;
  618.     case CCHR('J'): np = "LFD"; break; /* yuck, but that's what GNU calls it */
  619.     case CCHR('M'): np = "RET"; break;
  620.     case CCHR('['): np = "ESC"; break;
  621.     case ' ':    np = "SPC"; break; /* yuck again */
  622.     case CCHR('?'): np = "DEL"; break;
  623.     default:
  624. #ifdef    FKEYS
  625.         if(k >= KFIRST && k <= KLAST &&
  626.             (np = keystrings[k - KFIRST]) != NULL)
  627.         break;
  628. #endif /* FKEYS */
  629.         if(k > CCHR('?') || k < CCHR('@')) {
  630.         *cp++ = '0';
  631.         *cp++ = ((k>>6)&7) + '0';
  632.         *cp++ = ((k>>3)&7) + '0';
  633.         *cp++ = (k&7) + '0';
  634.         *cp = '\0';
  635.         return cp;
  636.         }
  637.         if(k < ' ') {
  638.         *cp++ = 'C';
  639.         *cp++ = '-';
  640.         k += '@';
  641.         if(ISUPPER(k)) k = TOLOWER(k);
  642.         }
  643.         *cp++ = k;
  644.         *cp = '\0';
  645.         return cp;
  646.     }
  647.     (VOID) strcpy(cp, np);
  648.     return cp + strlen(cp);
  649. }
  650. SHAR_EOF
  651. cat << \SHAR_EOF > sys/atari/diredsup.c
  652. /* diredsup.c -- Atari ST functions for handling DIR and DIRED features
  653.  *
  654.  * author :  Sandra Loosemore
  655.  * date   :  20 Dec 1987
  656.  *
  657.  */
  658.  
  659. #include "..\..\def.h"
  660.  
  661.  
  662. /* ST-specific code to support the DIR features in dir.c
  663.  */
  664.  
  665. #ifndef NO_DIR
  666.  
  667. char *getwd (buffer)
  668.     char *buffer;
  669. {   int drive, i;
  670.     drive = Dgetdrv();
  671.     buffer[0] = (char)drive + 'a';
  672.     buffer[1] = ':';
  673.     Dgetpath (&buffer[2], drive+1);
  674.     for (i=2; buffer[i] != '\0'; i++)
  675.         buffer[i] = TOLOWER(buffer[i]);
  676.     return(buffer);
  677.     }
  678.  
  679. int chdir (buffer)
  680.     char *buffer;
  681. {   int drive;
  682.     if (buffer[1] == ':')  {
  683.         drive = TOLOWER(buffer[0]) - 'a';
  684.     (VOID) Dsetdrv (drive);
  685.     buffer = buffer + 2;
  686.         }
  687.     return ((int)Dsetpath (buffer));
  688.     }
  689.  
  690. #endif
  691.  
  692.  
  693. /* ST-specific code to support the DIRED features in dired.c.
  694.  */
  695.  
  696. #ifndef NO_DIRED
  697.  
  698. #include "..\..\kbd.h"
  699.  
  700.  
  701. /* Various file manipulation functions.  */
  702.  
  703. int rename (fromname, toname)
  704.     char *fromname, *toname;
  705. {   if (Frename(0, fromname, toname) == 0)
  706.         return(0);
  707.     else  {
  708.         ewprintf ("Rename failed.");
  709.         return(-1);
  710.     }
  711.     }
  712.  
  713. int copy (fromname, toname)
  714.     char *fromname, *toname;
  715. {   int from, to, count;
  716.     char buffer[256];
  717.     if ((from = Fopen (fromname, 0)) < 0)  {
  718.         ewprintf ("Could not open input file %s.", fromname);
  719.         return(-1);
  720.         }
  721.     (VOID) Fdelete (toname);
  722.     if ((to = (Fcreate (toname, 0))) < 0)  {
  723.         ewprintf ("Could not open output file %s.", toname);
  724.         Fclose(from);
  725.     return(-1);
  726.         }
  727.     while ((count = Fread(from, (long)256, buffer)) > 0)
  728.         (VOID) Fwrite (to, (long)count, buffer);
  729.     (VOID) Fclose(from);
  730.     (VOID) Fclose(to);
  731.     return(0);
  732.     }
  733.  
  734. int unlink (fname)
  735.     char *fname;
  736. {   if (Fdelete(fname) == 0)
  737.         return(0);
  738.     else
  739.         return(-1);
  740.     }
  741.  
  742. int unlinkdir (fname)
  743.     char *fname;
  744. {   if (Ddelete(fname) == 0)
  745.         return(0);
  746.     else
  747.         return(-1);
  748.     }
  749.  
  750.  
  751. /* Create a dired buffer for the given directory name.  */
  752.  
  753. BUFFER *dired_(dirname)
  754. char *dirname;
  755. {
  756.     register BUFFER *bp;
  757.     BUFFER *findbuffer();
  758.  
  759.     /* Create the dired buffer */
  760.  
  761.     if ((dirname = adjustname(dirname)) == NULL) {
  762.     ewprintf("Bad directory name");
  763.     return NULL;
  764.         }
  765.     if ((bp = findbuffer(dirname)) == NULL) {
  766.     ewprintf("Could not create buffer");
  767.     return NULL;
  768.         }
  769.     if (bclear(bp) != TRUE) return FALSE;
  770.  
  771.     /* Now fill it in.  */
  772.  
  773.     if (!dirlist (bp, dirname))  {
  774.         ewprintf("Could not read directory");
  775.         return FALSE;
  776.         }
  777.  
  778.     /* Clean up and return */
  779.  
  780.     bp->b_dotp = lforw(bp->b_linep);        /* go to first line */
  781.     (VOID) strncpy(bp->b_fname, dirname, NFILEN);
  782.     if((bp->b_modes[0] = name_mode("dired")) == NULL) {
  783.     bp->b_modes[0] = &map_table[0];
  784.     ewprintf("Could not find mode dired");
  785.     return NULL;
  786.         }
  787.     return bp;
  788.     }
  789.  
  790.  
  791. /* Take the name from the line in the buffer and make a filename out of it.
  792.  */
  793.  
  794. d_makename(lp, fn)
  795. register LINE *lp;
  796. register char *fn;
  797. {
  798.     register char *cp;
  799.     register char ch;
  800.     int i;
  801.  
  802.     if(llength(lp) < 55) return ABORT;
  803.     (VOID) strcpy (fn, curbp->b_fname);
  804.     cp = fn + strlen(fn);
  805.     *cp++ = '\\';
  806.     i = 2;
  807.     while ((ch = lgetc(lp,i)) != ' ')  {
  808.         *cp++ = ch;
  809.     i++;
  810.     }
  811.     *cp = '\0';
  812.     return lgetc(lp, 52) == 'd';
  813. }
  814.  
  815.  
  816. /* Here is all the messy code for getting a directory listing.
  817.  *    It is printed out like
  818.  *
  819.  * 0         1         2         3         4         5
  820.  * 01234567890123456789012345678901234567890123456789012345
  821.  *   name----------><-----size  dd-mmm-yyyy  hh:mm:ss  drw
  822.  *
  823.  */
  824.  
  825. typedef struct dta {
  826.     char junk[21];
  827.     char attrib;
  828.     unsigned int timestamp;
  829.     unsigned int datestamp;
  830.     long filesize;
  831.     char name[14];
  832.     } DTA;
  833.  
  834. static char* months[] = {
  835.     "???", "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", 
  836.     "Aug", "Sep", "Oct", "Nov", "Dec"};
  837.  
  838.  
  839. /* Print a number into the character buffer, bumping up the pointer */
  840.  
  841. static char* printit (str, number, width, fill, zero)
  842.     char* str;
  843.     long number;
  844.     int width;
  845.     char fill;
  846. {   int i;
  847.     if (number == 0)   {
  848.         for (i=1; i<width; i++)
  849.         *str++ = fill;
  850.         if (width == 0)
  851.             ;
  852.         else if (zero) 
  853.         *str++ = '0';
  854.         else
  855.         *str++ = fill;
  856.         return (str);
  857.         }
  858.     else  {
  859.         str = printit (str, (number/10), width-1, fill, FALSE);
  860.         *str++ = (char) ((number%10) + (int) '0');
  861.         return (str);
  862.         }
  863.     }
  864.  
  865.  
  866. /* Print a null-terminated string into the buffer */
  867.  
  868. static char* copyit (to, from, width, fill)
  869.     char *from, *to;
  870.     int width;
  871.     char fill;
  872. {   int i;
  873.     char ch;
  874.     i = 0;
  875.     while (*from != '\0')  {
  876.         ch = *from++;
  877.         *to++ = TOLOWER(ch);
  878.         i++;
  879.     }
  880.     while (i < width)  {
  881.         *to++ = fill;
  882.         i++;
  883.         }
  884.     return (to);
  885.     }
  886.  
  887.  
  888. static char* getdate (datestamp, buffer)
  889.     unsigned int datestamp;
  890.     char* buffer;
  891. {   int date, month, year;
  892.  
  893.     date = datestamp & 31;
  894.     month = (datestamp >> 5) & 15;
  895.     year = (datestamp >> 9) + 1980;
  896.     *buffer++ = ' ';
  897.     *buffer++ = ' ';
  898.     buffer = printit (buffer, (long) date, 2, '0', TRUE);
  899.     *buffer++ = '-';
  900.     buffer = copyit (buffer, months[month], 3, ' ');
  901.     *buffer++ = '-';
  902.     buffer = printit (buffer, (long) year, 4, ' ', TRUE);
  903.     return (buffer);
  904.     }
  905.  
  906.  
  907. static char* gettime (timestamp, buffer)
  908.     unsigned int timestamp;
  909.     char* buffer;
  910. {   int second, minute, hour;
  911.  
  912.     second = (timestamp & 31) * 2;
  913.     minute = (timestamp >> 5) & 63;
  914.     hour = (timestamp >> 11);
  915.     *buffer++ = ' ';
  916.     *buffer++ = ' ';
  917.     buffer = printit (buffer, (long) hour, 2, '0', TRUE);
  918.     *buffer++ = ':';
  919.     buffer = printit (buffer, (long) minute, 2, '0', TRUE);
  920.     *buffer++ = ':';
  921.     buffer = printit (buffer, (long) second, 2, '0', TRUE);
  922.     return (buffer);
  923.     }
  924.  
  925.  
  926. static dirlist (bp, dirname)
  927.     BUFFER *bp;
  928.     char *dirname;
  929. {   
  930.     char fname[NFILEN], buf[NFILEN];
  931.     int status;
  932.     DTA my_dta, *old_dta;
  933.     char *bufptr;
  934.  
  935.     (VOID) strcpy (fname, dirname);
  936.     (VOID) strcat (fname, "\\*.*");
  937.     old_dta = (DTA *) Fgetdta ();
  938.     Fsetdta (&my_dta);
  939.     status = Fsfirst (fname, 0x11);
  940.     while (status == 0)  {
  941.         bufptr = buf;
  942.     *bufptr++ = ' ';
  943.     *bufptr++ = ' ';
  944.         bufptr = copyit (bufptr, my_dta.name, 15, ' ');
  945.         bufptr = printit (bufptr, my_dta.filesize, 10, ' ', TRUE);
  946.         bufptr = getdate (my_dta.datestamp, bufptr);
  947.         bufptr = gettime (my_dta.timestamp, bufptr);
  948.     *bufptr++ = ' ';
  949.     *bufptr++ = ' ';
  950.         *bufptr++ = (my_dta.attrib) ? 'd' : '-';  /* directory */
  951.     *bufptr++ = 'r';
  952.         *bufptr++ = (my_dta.attrib) ? '-' : 'w';  /* read-only */
  953.         *bufptr = '\0';
  954.         if (addline(bp, buf) == FALSE)  {
  955.             Fsetdta (old_dta);
  956.             return (FALSE);
  957.             }
  958.         status = Fsnext ();
  959.         }
  960.     Fsetdta (old_dta);
  961.     return (TRUE);
  962.     }
  963.  
  964. #endif
  965. SHAR_EOF
  966. cat << \SHAR_EOF > sys/atari/fileio.c
  967. /* fileio.c -- Atari ST file system interface for MG
  968.  *
  969.  * author :  Sandra Loosemore (from an earlier version by dec-rex!conroy)
  970.  * date   :  24 Oct 1987
  971.  * changes:  Marion Hakanson -- Jan 1988
  972.  *
  973.  */
  974. #include    "..\..\def.h"
  975.  
  976.  
  977. /* Adjustname regularizes a filename.  This fills in the current drive
  978.  *    and directory onto the front if they are not already provided, and
  979.  *    also lowercases it so a case-sensitive string compare can be used
  980.  *    on filenames.
  981.  * This doesn't do the right things with collapsing "..\" and ".\" -- it
  982.  *      doesn't check for them being embedded in pathnames, only at the
  983.  *    front.  Sigh.
  984.  */
  985.  
  986. static char adbuffer[128];
  987.  
  988. char* adjustname (fname)
  989.     char *fname;
  990. {   int i, j, k;
  991.     char pathbuf[128];
  992.  
  993.     if (fname[1] == ':')  {
  994.         j = 2;
  995.         adbuffer[0] = TOLOWER(fname[0]);
  996.     }
  997.     else  {
  998.         adbuffer[0] = (char)Dgetdrv() + 'a';
  999.         j = 0;
  1000.         }
  1001.     adbuffer[1] = ':';
  1002.     i = 2;
  1003.     if (fname[j] != '\\')  {
  1004.         Dgetpath(pathbuf, (int)(adbuffer[0] - 'a' + 1));
  1005.         for (k=0; pathbuf[k] != '\0'; k++)  {
  1006.         adbuffer[i] = TOLOWER(pathbuf[k]);
  1007.         i++;
  1008.         }
  1009.         adbuffer[i] = '\\';
  1010.     i++;
  1011.         }
  1012.     if (fname[j] == '.')  {
  1013.         if (fname[j+1] == '.')  {
  1014.             i = i - 2;
  1015.             while (adbuffer[i] != '\\')  i--;
  1016.             j = j + 2;
  1017.             }
  1018.         else  {
  1019.             j = j + 1;
  1020.             i = i - 1;
  1021.         }
  1022.         }
  1023.     while (fname[j] != '\0')  {
  1024.         adbuffer[i] = TOLOWER(fname[j]);
  1025.         i++;
  1026.         j++;
  1027.         }
  1028.     adbuffer[i] = '\0';
  1029.     return(adbuffer);
  1030.     }
  1031.  
  1032.  
  1033. /* Define some things used later on */
  1034.  
  1035. static int handle;
  1036. #define RBUFSIZE 512
  1037. static char rbuffer[RBUFSIZE];
  1038. static int rbufmax, rbufnext, rbufcr;
  1039. static int rbufeof;
  1040.  
  1041.  
  1042. /* Open and close files.  Store the file handle in "handle".  We'll use 
  1043.  *    it later in the routines that read and write to the file.
  1044.  */
  1045.  
  1046.  
  1047. ffropen (fn)
  1048.     char *fn;
  1049. {   handle = Fopen(fn, 0);
  1050.     if (handle < 0)
  1051.         return(FIOFNF);
  1052.     else  {
  1053.         rbufmax = 0;
  1054.         rbufnext = 0;
  1055.     rbufcr = FALSE;
  1056.     rbufeof = FALSE;
  1057.         return(FIOSUC);
  1058.     }
  1059.     }
  1060.  
  1061.  
  1062. ffwopen (fn)
  1063.     char *fn;
  1064. {   (VOID) Fdelete(fn);
  1065.     handle = Fcreate(fn, 0);
  1066.     if (handle < 0)  {
  1067.     ewprintf("Open of %s failed with error code %d.", fn, handle);
  1068.     return (FIOERR);
  1069.     }
  1070.     else
  1071.     return (FIOSUC);
  1072.     }
  1073.  
  1074. ffclose ()
  1075. {   (VOID) Fclose(handle);
  1076.     return (FIOSUC);
  1077.     }
  1078.  
  1079.  
  1080. /* Write an entire buffer to the already open file.  The last line of 
  1081.  *     the buffer does not have an implied newline.
  1082.  */
  1083.  
  1084. static char *crlf = "\r\n";
  1085.  
  1086. ffputbuf (buf)
  1087.     BUFFER *buf;
  1088. {   LINE *line, *last;
  1089.  
  1090.     last = buf->b_linep;       /* Header line is empty */
  1091.     line = last->l_fp;         /* The first real line */
  1092.  
  1093.     while (line->l_fp != last)  {
  1094.         if ((Fwrite (handle, (long)line->l_used, line->l_text) < 0) ||
  1095.         (Fwrite (handle, 2l, crlf) < 0))  {
  1096.         ewprintf("File write error");
  1097.         return (FIOERR);
  1098.                 }
  1099.         line = line->l_fp;
  1100.         }
  1101.     if (line->l_used > 0)  {
  1102.         if (Fwrite (handle, (long)line->l_used, line->l_text) < 0)  {
  1103.         ewprintf("File write error");
  1104.         return (FIOERR);
  1105.                 }
  1106.         }
  1107.     return(FIOSUC);
  1108.     }
  1109.  
  1110.  
  1111. /* Read a line from the file up to nbuf long.  Set *nbytes to the actual
  1112.  *    count read (excluding the end-of-line marker).  Returns:
  1113.  *        FIOSUC if all is well.
  1114.  *        FIOLONG if no newline was found yet.
  1115.  *        FIOEOF on end-of-file.
  1116.  *        FIOERR if any random errors happened.
  1117.  * The GemDos routine Fread does not break on end-of-line; it will read
  1118.  *    however many characters you tell it to.  So we do a little buffering.
  1119.  *    Remember that crlf is the line terminator.  Cr's and lf's that appear
  1120.  *    by themselves are passed on.
  1121.  */
  1122.  
  1123.  
  1124. ffgetline (buf, nbuf, nbytes)
  1125.     char buf[];
  1126.     int nbuf;
  1127.     int *nbytes;
  1128. {   register int i;
  1129.     register char ch;
  1130.  
  1131.     for (i=0; i<nbuf; i++)  {
  1132.         if (rbufmax == rbufnext)  {
  1133.         if (rbufeof || 
  1134.               ((rbufmax = Fread(handle, (long)RBUFSIZE, rbuffer)) == 0))  {
  1135.                 (*nbytes) = i;
  1136.                 return (FIOEOF);
  1137.                 }
  1138.             else if (rbufmax < 0)  {
  1139.              ewprintf("File read error");
  1140.             return (FIOERR);
  1141.                 }
  1142.         else  {
  1143.         if (rbufmax < RBUFSIZE)  rbufeof = TRUE;
  1144.                 rbufnext = 0;
  1145.         }
  1146.             }
  1147.         ch = rbuffer[rbufnext];
  1148.         rbufnext++;
  1149.         if (rbufcr && (ch == '\n'))  {
  1150.         rbufcr = FALSE;
  1151.         (*nbytes) = i-1;
  1152.             return (FIOSUC);
  1153.             }
  1154.         else  {
  1155.         buf[i] = ch;
  1156.         rbufcr = (ch == '\r');
  1157.             }
  1158.     }
  1159.     return (FIOLONG);
  1160.     }
  1161.  
  1162.  
  1163. #ifndef NO_BACKUP
  1164.  
  1165. /*
  1166.  * Finish this routine when you decide
  1167.  * what the right thing to do when renaming a
  1168.  * file for backup purposes.
  1169.  */
  1170.  
  1171. fbackupfile(fname)
  1172. char    *fname;
  1173. {
  1174.     return (TRUE);
  1175. }
  1176.  
  1177. #endif
  1178.  
  1179.  
  1180.  
  1181. #ifndef NO_STARTUP
  1182.  
  1183. /* Look for a startup file as MG.INI in the current directory, then for
  1184.  *    the file specified by the environment variable MGINIT.
  1185.  */
  1186.  
  1187. char* startupfile (ignore)
  1188.     char *ignore;
  1189. {   int handle;
  1190.     char *foo;
  1191.     extern char *getenv();
  1192.  
  1193.     if ((handle = Fopen ("MG.INI", 0)) >= 0)  {
  1194.         (VOID) Fclose (handle);
  1195.         return("MG.INI");
  1196.         }
  1197.     else if (((foo = getenv("MGINIT")) != NULL) &&
  1198.              ((handle = Fopen (foo, 0)) >= 0))  {
  1199.         (VOID) Fclose (handle);
  1200.         return(foo);
  1201.         }
  1202.     else
  1203.         return(NULL);
  1204.     }
  1205.  
  1206. #endif
  1207.  
  1208. SHAR_EOF
  1209. cat << \SHAR_EOF > sys/atari/gemstart.s
  1210. ******************************************************************************
  1211. *
  1212. *    C runtime startup for CP/M-68k.
  1213. *
  1214. ******************************************************************************
  1215. *
  1216. ltpa=0            * Low TPA address
  1217. htpa=4            * High TPA address
  1218. lcode=8            * Code segment start
  1219. codelen=12        * Code segment length
  1220. ldata=16        * Data segment start
  1221. datalen=20        * Data segment length
  1222. lbss=24            * Bss  segment start
  1223. bsslen=28        * Bss  segment length
  1224. freelen=32        * free segment length
  1225. resvd=36        * Reserved
  1226. fcb2=56            * 2nd parsed fcb
  1227. fcb1=92            * 1st parsed fcb
  1228. command=128        * Command tail
  1229. prtstr=9        * Print string BDOS Call
  1230. exit=0            * BDOS exit call
  1231. .globl    __main
  1232. .globl    __exit
  1233. .globl    __break
  1234. .globl    ___cpmrv
  1235. .globl    __base
  1236. .globl  _sw_
  1237. .globl    __sovf
  1238.  
  1239.  
  1240.     .globl    _crystal
  1241.     .globl    _ctrl_cnts
  1242.  
  1243.  
  1244.         .text
  1245.  
  1246.  
  1247. *
  1248. *  Must be first object file in link statement
  1249. *
  1250.     move.l    a7,a5        * save a7 so we can get the base page address
  1251.     move.l    4(a5),a5    * a5=basepage address
  1252.     move.l    a5,__base    * save for C startup
  1253.     move.l    $c(a5),d0
  1254.     add.l    $14(a5),d0
  1255.     add.l    $1c(a5),d0
  1256.     add.l    #$2000,d0    * d0=basepage+textlen+datalen+bsslen
  1257. *                  (plus room for user stack)
  1258.     move.l    d0,d1
  1259.     add.l    a5,d1        * compute stack top
  1260.     and.l    #-2,d1        * ensure even byte boundary
  1261.     move.l    d1,a7        * setup user stack, 1K above end of BSS
  1262.  
  1263.     move.l    d0,-(sp)
  1264.     move.l    a5,-(sp)
  1265.     clr.w    -(sp)        * junk word
  1266.     move    #$4a,-(sp)    * return excess storage
  1267.     trap    #1
  1268.     add.l    #12,sp
  1269.  
  1270.  
  1271.         move.l    __base,a0        *    Load C external
  1272.         move.l    lbss(a0),a1        *    a1 -> bss region
  1273.         adda.l    bsslen(a0),a1        *    a1 -> 1st heap loc
  1274.  
  1275.         move.l    a1,__break        *    Put in "break" loc
  1276.         lea.l    command(a0),a2        *    a2 -> command line
  1277.         move.b    (a2)+,d0        *    d0 = byte count
  1278.         andi.l    #$ff,d0            *    clear junk
  1279.         move.w    d0,-(a7)        *    push length
  1280.         move.l    a2,-(a7)        *    Push commnd
  1281.         clr.l    a6            *    Clear frame pointer
  1282.         jsr    __main            *    call main routine
  1283.         jmp    __exit            *    call "exit"
  1284.  
  1285. *
  1286. *    For GEMAES calls from AESBIND.ARC or cryslib.o
  1287. *
  1288. _crystal:
  1289.     move.l    4(a7),d1
  1290.     move.w    #200,d0
  1291.     trap    #2
  1292.     rts
  1293.  
  1294. *
  1295. *    control array for vdibind
  1296. *
  1297.     .data
  1298.         .even
  1299. _ctrl_cnts:                 *    Application Manager
  1300.     .dc.b    0, 1, 0            * func 010        
  1301.         .dc.b    2, 1, 1            * func 011        
  1302.         .dc.b    2, 1, 1         * func 012        
  1303.     .dc.b    0, 1, 1            * func 013        
  1304.     .dc.b    2, 1, 1            * func 014        
  1305.     .dc.b    1, 1, 1            * func 015        
  1306.     .dc.b    0, 0, 0            * func 016        
  1307.     .dc.b    0, 0, 0            * func 017        
  1308.     .dc.b    0, 0, 0            * func 008        
  1309.     .dc.b    0, 1, 0            * func 019        
  1310. *                             Event Manager
  1311.     .dc.b    0, 1, 0            * func 020        
  1312.     .dc.b    3, 5, 0            * func 021        
  1313.     .dc.b    5, 5, 0            * func 022        
  1314.     .dc.b    0, 1, 1            * func 023        
  1315.     .dc.b    2, 1, 0            * func 024        
  1316.     .dc.b    16, 7, 1         * func 025        
  1317.     .dc.b    2, 1, 0            * func 026        
  1318.     .dc.b    0, 0, 0            * func 027        
  1319.     .dc.b    0, 0, 0            * func 028        
  1320.     .dc.b    0, 0, 0            * func 009        
  1321. *                             Menu Manager
  1322.     .dc.b    1, 1, 1            * func 030        
  1323.     .dc.b    2, 1, 1            * func 031        
  1324.     .dc.b    2, 1, 1            * func 032        
  1325.     .dc.b    2, 1, 1            * func 033        
  1326.     .dc.b    1, 1, 2            * func 034        
  1327.     .dc.b    1, 1, 1            * func 005        
  1328.     .dc.b    0, 0, 0            * func 006        
  1329.     .dc.b    0, 0, 0            * func 007        
  1330.     .dc.b    0, 0, 0            * func 008        
  1331.     .dc.b    0, 0, 0            * func 009        
  1332. *                             Object Manager
  1333.     .dc.b    2, 1, 1            * func 040        
  1334.     .dc.b    1, 1, 1            * func 041        
  1335.       .dc.b    6, 1, 1            * func 042        
  1336.     .dc.b    4, 1, 1            * func 043        
  1337.     .dc.b    1, 3, 1            * func 044        
  1338.     .dc.b    2, 1, 1            * func 045        
  1339.     .dc.b    4, 2, 1            * func 046        
  1340.     .dc.b    8, 1, 1            * func 047        
  1341.     .dc.b    0, 0, 0            * func 048        
  1342.     .dc.b    0, 0, 0            * func 049        
  1343. *                             Form Manager
  1344.     .dc.b    1, 1, 1            * func 050        
  1345.     .dc.b    9, 1, 1            * func 051        
  1346.     .dc.b    1, 1, 1            * func 002        
  1347.     .dc.b    1, 1, 0            * func 003        
  1348.     .dc.b    0, 5, 1            * func 004        
  1349.     .dc.b    0, 0, 0            * func 005        
  1350.     .dc.b    0, 0, 0            * func 006        
  1351.     .dc.b    0, 0, 0            * func 007        
  1352.     .dc.b    0, 0, 0            * func 008        
  1353.     .dc.b    0, 0, 0            * func 009        
  1354. *                             Dialog Manager
  1355.     .dc.b    0, 0, 0            * func 060        
  1356.     .dc.b    0, 0, 0            * func 061        
  1357.     .dc.b    0, 0, 0            * func 062        
  1358.     .dc.b    0, 0, 0            * func 003        
  1359.     .dc.b    0, 0, 0            * func 004        
  1360.     .dc.b    0, 0, 0            * func 005        
  1361.     .dc.b    0, 0, 0            * func 006        
  1362.     .dc.b    0, 0, 0            * func 007        
  1363.     .dc.b    0, 0, 0            * func 008        
  1364.     .dc.b    0, 0, 0            * func 009        
  1365. *                            Graphics Manager
  1366.     .dc.b    4, 3, 0            * func 070        
  1367.     .dc.b    8, 3, 0            * func 071        
  1368.     .dc.b    6, 1, 0            * func 072        
  1369.     .dc.b    8, 1, 0            * func 073        
  1370.     .dc.b    8, 1, 0            * func 074        
  1371.     .dc.b    4, 1, 1            * func 075        
  1372.     .dc.b    3, 1, 1            * func 076        
  1373.     .dc.b    0, 5, 0            * func 077        
  1374.     .dc.b    1, 1, 1            * func 078        
  1375.     .dc.b    0, 5, 0            * func 009        
  1376. *                            Scrap Manager
  1377.     .dc.b    0, 1, 1            * func 080        
  1378.     .dc.b    0, 1, 1            * func 081        
  1379.     .dc.b    0, 0, 0            * func 082        
  1380.     .dc.b    0, 0, 0            * func 083        
  1381.     .dc.b    0, 0, 0            * func 084        
  1382.     .dc.b    0, 0, 0            * func 005        
  1383.     .dc.b    0, 0, 0            * func 006        
  1384.     .dc.b    0, 0, 0            * func 007        
  1385.     .dc.b    0, 0, 0            * func 008        
  1386.     .dc.b    0, 0, 0            * func 009        
  1387. *                            fseler Manager
  1388.     .dc.b    0, 2, 2            * func 090        
  1389.     .dc.b    0, 0, 0            * func 091        
  1390.     .dc.b    0, 0, 0            * func 092        
  1391.     .dc.b    0, 0, 0            * func 003        
  1392.     .dc.b    0, 0, 0            * func 004        
  1393.     .dc.b    0, 0, 0            * func 005        
  1394.     .dc.b    0, 0, 0            * func 006        
  1395.     .dc.b    0, 0, 0            * func 007        
  1396.     .dc.b    0, 0, 0            * func 008        
  1397.     .dc.b    0, 0, 0         * func 009        
  1398. *                            Window Manager
  1399.     .dc.b    5, 1, 0            * func 100        
  1400.     .dc.b    5, 1, 0            * func 101        
  1401.     .dc.b    1, 1, 0            * func 102        
  1402.     .dc.b    1, 1, 0            * func 103        
  1403.     .dc.b    2, 5, 0            * func 104        
  1404.     .dc.b    6, 1, 0            * func 105        
  1405.     .dc.b    2, 1, 0            * func 106        
  1406.     .dc.b    1, 1, 0            * func 107        
  1407.     .dc.b    6, 5, 0            * func 108        
  1408.     .dc.b    0, 0, 0         * func 009        
  1409. *                            Resource Manger
  1410.     .dc.b    0, 1, 1            * func 110        
  1411.     .dc.b    0, 1, 0            * func 111        
  1412.     .dc.b    2, 1, 0            * func 112        
  1413.     .dc.b    2, 1, 1            * func 113        
  1414.     .dc.b    1, 1, 1            * func 114        
  1415.     .dc.b    0, 0, 0            * func 115        
  1416.     .dc.b    0, 0, 0            * func 006
  1417.     .dc.b    0, 0, 0            * func 007
  1418.     .dc.b    0, 0, 0            * func 008
  1419.     .dc.b    0, 0, 0            * func 009
  1420. *                            Shell Manager
  1421.     .dc.b    0, 1, 2            * func 120
  1422.     .dc.b    3, 1, 2            * func 121
  1423.     .dc.b    1, 1, 1            * func 122
  1424.     .dc.b    1, 1, 1            * func 123
  1425.     .dc.b    0, 1, 1            * func 124
  1426.     .dc.b    0, 1, 2            * func 125
  1427.  
  1428.     .bss
  1429.     .even
  1430. __base:        .ds.l    1            *    -> Base Page
  1431. __break:    .ds.l    1            *    Break function
  1432. ___cpmrv:    .ds.w    1            *    Last CP/M return val
  1433.  
  1434.  
  1435.  
  1436. *
  1437. *
  1438. .globl    _brk
  1439.         .text
  1440. _brk:        
  1441.         movea.l    4(sp),a0        *    New break?
  1442.         move.l     a0,d0
  1443.         lea    $100(a0),a0        *    Chicken factor
  1444.         cmpa.l    a0,sp            *    Compare
  1445.         bhis    brkok            *    OK, continue
  1446.         move.l    #-1,d0            *    Load return reg
  1447.         rts                *    Return
  1448. brkok:
  1449.         move.l    d0,__break        *    Save the break
  1450.         clr.l    d0            *    Set OK return
  1451.         rts                *    return
  1452.         
  1453. .globl    ___BDOS
  1454. ___BDOS:    link    a6,#0            *    link
  1455.         move.w    8(sp),d0        *    Load func code
  1456.         move.l    10(sp),d1        *    Load Paramter
  1457.         trap    #2            *    Enter BDOS
  1458.         cmpa.l    __break,sp        *    Check for stack ovf
  1459.         bhis    noovf            *    NO overflow, continue
  1460. __sovf:        move.w    #prtstr,d0        *    String print
  1461.         lea    ovf,a0            *    a0-> message
  1462.         move.l    a0,d1            *    load proper reg
  1463.         trap    #2            *    Issue message
  1464. __exit:        move.w    #exit,d0        *    Exit
  1465.         trap    #2            *        now
  1466. noovf:                        *    Here if all OK
  1467.         unlk    a6            *
  1468.         rts                *    Back to caller
  1469. *
  1470. *    Block Fill function:
  1471. *
  1472. *    blkfill(dest,char,cnt);
  1473. *
  1474. *    BYTE    *dest;        /* -> area to be filled    */
  1475. *    BYTE    char;        /* =  char to fill    */
  1476. *    WORD    cnt;        /* =  # bytes to fill   */
  1477. *
  1478.     .globl    _blkfill
  1479. _blkfill:
  1480.     move.l    4(a7),a0            *    -> Output area
  1481.     move.w    8(a7),d1            *    =  output char
  1482.     move.w    10(a7),d0            *    =  output count
  1483.     ext.l    d0                *    make it long
  1484.     subq.l    #1,d0                *    decrement
  1485.     ble    filldone            *    Done if le
  1486. fillit:    move.b    d1,(a0)+            *    move a byte
  1487.     dbra    d0,fillit            *    Continue
  1488. filldone: clr.l    d0                *    always return 0
  1489.     rts                    *
  1490.  
  1491. *
  1492. *    Index function to find out if a particular character is in a string.
  1493. *
  1494.     .globl    _index
  1495.     .globl    _strchr
  1496. _index:
  1497. _strchr:
  1498.     move.l    4(a7),a0            *    a0 -> String
  1499.     move.w    8(a7),d0            *    D0 = desired character
  1500. xindex:    tst.b    (a0)                *    EOS?
  1501.     bne    notend                *    No, continue to look
  1502.     clr.l    d0                *    Not found
  1503.     rts                    *    Quit
  1504. notend:    cmp.b    (a0)+,d0            *    check for character
  1505.     bne    xindex                *    
  1506.     move.l    a0,d0                *    Found it
  1507.     subq.l    #1,d0                *    set return pointer
  1508.     rts                    *
  1509. *
  1510. *    Data area
  1511. *
  1512.         .data
  1513.         .globl    ___pname        *    Program Name
  1514.         .globl    ___tname        *    Terminal Name
  1515.         .globl    ___lname        *    List device name
  1516.         .globl    ___xeof            *    ^Z byte
  1517. ovf:        .dc.b    'Stack Overflow$'    *    Error message
  1518. ___pname:    .dc.b    'C runtime',0        *    Program name
  1519. ___tname:    .dc.b    'CON:',0        *    Console name
  1520. ___lname:    .dc.b    'LST:',0        *    List device name
  1521. ___xeof:    .dc.b    $1a            *    Control-Z
  1522.         .end
  1523. SHAR_EOF
  1524. cat << \SHAR_EOF > sys/atari/getn.s
  1525. * Routines to read the size of the display.
  1526. * MicroEMACS works even on a screen that has been blessed
  1527. * by the "hi50" program.
  1528. * MicroEMACS version 30, for the Atari.
  1529.  
  1530.     .text
  1531.  
  1532. * getnrow() -- get number of rows.
  1533.  
  1534.     .globl    _getnrow
  1535.  
  1536. _getnrow:
  1537.  
  1538.     move.l    a2, -(sp)
  1539.     move.l    d2, -(sp)
  1540.     dc.w    $A000
  1541.     move.l    (sp)+, d2
  1542.     movea.l    (sp)+, a2
  1543.  
  1544.     move.w    -42(a0), d0
  1545.     addq.w    #1, d0
  1546.     ext.l    d0
  1547.  
  1548.     rts
  1549.  
  1550. * getncol() -- get number of columns.
  1551.  
  1552.     .globl    _getncol
  1553.  
  1554. _getncol:
  1555.     move.l    a2, -(sp)
  1556.     move.l    d2, -(sp)
  1557.     dc.w    $A000
  1558.     move.l    (sp)+, d2
  1559.     movea.l    (sp)+, a2
  1560.  
  1561.     move.w    -44(a0), d0
  1562.     addq.w    #1, d0
  1563.     ext.l    d0
  1564.  
  1565.     rts
  1566. SHAR_EOF
  1567. cat << \SHAR_EOF > sys/atari/makesys.mwc
  1568. #
  1569. # MWC Makefile for MG (Atari ST) -- system library
  1570. #
  1571. #    Marion Hakanson        Jan '88
  1572.  
  1573. # Note that this Makefile expects the sources to be in ..\..\,
  1574. # as do the source files here.
  1575.  
  1576. # SYSLIB and CFLAGS should be defined by the top level Makefile.
  1577. # These are defaults in case this Makefile is called manually.
  1578. SYSLIB    = libsys.a
  1579.  
  1580. CDEFS    = -DPREFIXREGION
  1581. CFLAGS    = -O -DMWC $(CDEFS)
  1582.  
  1583. OBJ    = cinfo.o fileio.o misc.o term.o ttyio.o
  1584. IND    = diredsup.o alloc.o getn.o
  1585. OBJS    = $(OBJ) $(IND)
  1586. INC    = ..\..\def.h
  1587. OINC    = chrdef.h sysdef.h ttydef.h
  1588.  
  1589.  
  1590. all:    $(SYSLIB)
  1591.     @echo $(SYSLIB) completed.
  1592.  
  1593. $(SYSLIB): $(OBJS)
  1594.     ar rcv $@ $?
  1595.  
  1596.  
  1597. $(OBJ):        $(INC) $(OINC)
  1598.  
  1599. diredsup.o:    $(INC) $(OINC) ..\..\kbd.h
  1600.  
  1601. getn.o:        getn.s
  1602.     as68toas < $? > tmp.s; $(AS) $(ASFLAGS) -o $@ tmp.s; rm tmp.s
  1603.  
  1604.  
  1605. clean:
  1606.     -rm $(OBJS) tmp.s $(SYSLIB)
  1607.  
  1608. SHAR_EOF
  1609. cat << \SHAR_EOF > sys/atari/mg.ini
  1610. (bsmap-mode 1)    ; enable
  1611. ; auto-indent globally
  1612. (global-set-key "\^J" newline)
  1613. (global-set-key "\^M" newline-and-indent)
  1614. ; blink-matching-paren globally
  1615. (global-set-key ")" blink-matching-paren-hack)
  1616. (global-set-key "}" blink-matching-paren-hack)
  1617. (global-set-key "]" blink-matching-paren-hack)
  1618. ; set up special keys (ST)
  1619. (global-set-key "\F21" help)
  1620. (global-set-key "\F21\F21" help-help)
  1621. (global-set-key "\F22" keyboard-quit)
  1622. (global-set-key "\F24" previous-line)
  1623. (global-set-key "\F26" backward-char)
  1624. (global-set-key "\F27" next-line)
  1625. (global-set-key "\F28" forward-char)
  1626. SHAR_EOF
  1627. cat << \SHAR_EOF > sys/atari/mglink.inp
  1628. -u -o ..\..\mg.ttp gemstart.o
  1629.     ..\..\basic.o
  1630.     ..\..\buffer.o
  1631.     ..\..\dir.o
  1632.     ..\..\dired.o
  1633.     ..\..\display.o
  1634.     ..\..\echo.o
  1635.     ..\..\extend.o
  1636.     ..\..\file.o
  1637.     ..\..\help.o
  1638.     ..\..\kbd.o
  1639.     ..\..\keymap.o
  1640.     ..\..\line.o
  1641.     ..\..\macro.o
  1642.     ..\..\main.o
  1643.     ..\..\match.o
  1644.     ..\..\modes.o
  1645.     ..\..\paragrap.o
  1646.     ..\..\random.o
  1647.     ..\..\re_searc.o
  1648.     ..\..\regex.o
  1649.     ..\..\region.o
  1650.     ..\..\search.o
  1651.     ..\..\version.o
  1652.     ..\..\window.o
  1653.     ..\..\word.o
  1654.     alloc.o
  1655.     cinfo.o
  1656.     diredsup.o
  1657.     fileio.o
  1658.     misc.o
  1659.     term.o
  1660.     ttyio.o
  1661.     getn.o
  1662.     C:osbind.o c:gemlib c:libf
  1663. SHAR_EOF
  1664. cat << \SHAR_EOF > sys/atari/misc.c
  1665. /* misc.c -- Miscellaneous ST-specific code for MG.
  1666.  *
  1667.  * author :  Sandra Loosemore
  1668.  * date   :  24 Oct 1987
  1669.  * changes:  Marion Hakanson -- Jan 1988
  1670.  *
  1671.  */
  1672.  
  1673.  
  1674. #include    "..\..\def.h"
  1675.  
  1676. #ifdef MWC
  1677. static char *
  1678. mwc_cpr="Portions of this program, copyright 1984, Mark Williams Co.";
  1679. #endif /* MWC */
  1680.  
  1681.  
  1682. /* Exit as quickly as possible.  */
  1683.  
  1684. VOID panic (s)
  1685.     char* s;
  1686. {   Cconws (s);
  1687.     Pterm (-1);
  1688.     }
  1689.  
  1690.  
  1691. #ifdef MWC
  1692. extern char **environ;
  1693. #else
  1694. typedef struct
  1695.     {
  1696.     char    *p_lowtpa;
  1697.     char    *p_hitpa;
  1698.     char    *p_tbase;
  1699.     long    p_tlen;
  1700.     char    *p_dbase;
  1701.     long    p_dlen;
  1702.     char    *p_bbase;
  1703.     long    p_blen;
  1704.     char    *p_dta;
  1705.     char    *p_parent;
  1706.     char    *p_reserved;
  1707.     char    *p_env;
  1708.     long    p_undefined[20];
  1709.     char    p_cmdlin[128];
  1710.     }
  1711.     BASEPAGE;
  1712.  
  1713. extern BASEPAGE *_base;
  1714. #endif /* MWC */
  1715.  
  1716.  
  1717. /*
  1718.  * The environment code here is borrowed from Dale Schumacher.
  1719.  */
  1720.  
  1721. static char *findenv(var)
  1722.     register char *var;
  1723. /*
  1724.  *    INTERNAL FUNCTION.  This functions attempts to locate <var> in
  1725.  *    the environment.  If <var> is not found, NULL is returned.  If
  1726.  *    the environment is NULL, NULL is returned.  If <var> is found,
  1727.  *    a pointer to the beginning of <var> in the environment is returned.
  1728.  *    BOTH MS-DOS AND TOS ENVIRONMENT FORMATS ARE ACCOMODATED.
  1729.  */
  1730.     {
  1731.     register char *p;
  1732.     register int len;
  1733.  
  1734. #ifdef MWC
  1735.     if((p = *environ) == NULL)
  1736. #else
  1737.     if((p = _base->p_env) == NULL)
  1738. #endif /* MWC */
  1739.         return(NULL);
  1740.     len = strlen(var);
  1741.     while(*p)
  1742.         {
  1743.         if(!strncmp(p, var, len) && (p[len] == '='))
  1744.             return(p);
  1745.         while(*p++)        /* move to next arg */
  1746.             ;
  1747.         }
  1748.     return(NULL);
  1749.     }
  1750.  
  1751.  
  1752. char *getenv(var)
  1753.     register char *var;
  1754. /*
  1755.  *    Search for <var> in the environment.  If <var> is found, a pointer
  1756.  *    to it's value is returned.  NULL is returned if <var> is not found.
  1757.  *    WARNING:  The returned pointer points into the environment and
  1758.  *    must not be modified!
  1759.  */
  1760.     {
  1761.     register char *p, *q;
  1762.     register int len;
  1763.  
  1764.     len = strlen(var);
  1765.     if(p = findenv(var))
  1766.         {
  1767.         p += (len + 1);
  1768.         if(*p == '\0')        /* TOS env format or empty value */
  1769.             {
  1770.             q = p+1;
  1771.             if(*q == '\0')        /* empty value + end of env */
  1772.                 return(p);
  1773.             while(*q && (*q != '='))
  1774.                 ++q;
  1775.             if(*q)            /* empty value */
  1776.                 return(p);
  1777.             else            /* TOS env format */
  1778.                 return(p+1);
  1779.             }
  1780.         }
  1781.     return(p);
  1782.     }
  1783.  
  1784.  
  1785. /* Spawn a command.  You can run anything from this; it prompts you for
  1786.  *    the command to run.
  1787.  * I check for the two most common problems with Pexec:  not finding the
  1788.  *    file, and not having enough memory.  Otherwise, I assume bad status
  1789.  *    codes were the fault of the program, not Pexec, and that the program
  1790.  *    would have told the user what is wrong.
  1791.  */
  1792.  
  1793. spawncli(f, n)
  1794. {   register int s;
  1795.     char fname[NFILEN];
  1796.     char tail[NFILEN];
  1797.     char *shell = getenv("SHELL");
  1798.     extern VOID splitcmd();
  1799.    
  1800.     if (shell && *shell) {
  1801.         (VOID) strcpy(fname, shell);
  1802.         goto tryit;
  1803.     }
  1804.     else
  1805.         shell = NULL;
  1806.     
  1807. askfor:
  1808.     if ((s = ereply("Run program: ", fname, NFILEN)) != TRUE)
  1809.         return (s);
  1810. tryit:
  1811.     ttcolor (CTEXT);
  1812.     ttmove (nrow-1, 0);
  1813.     tteeol ();
  1814.     splitcmd (fname, tail);
  1815.     ttclose ();
  1816.     s = Pexec(0, fname, tail, 0L);
  1817.     ttopen ();
  1818.     if (s == -33) {
  1819.         if (shell) {
  1820.         shell = NULL;
  1821.             ewprintf ("Could not find shell.");
  1822.             sleep(1);
  1823.             goto askfor;
  1824.         }
  1825.         ewprintf ("Could not find file.");
  1826.         return (FALSE);
  1827.     }
  1828.     else if (s == -39) {
  1829.         if (shell) {
  1830.         shell = NULL;
  1831.             ewprintf ("Not enough memory to run shell!");
  1832.             sleep(1);
  1833.             goto askfor;
  1834.         }
  1835.         ewprintf ("Not enough memory to run this program!");
  1836.         return (FALSE);
  1837.     }
  1838.     else {
  1839.         sgarbf = TRUE;          /* Force repaint */
  1840.         Cconws ("Hit any key to return to MG:");
  1841.         (VOID) Crawcin ();
  1842.         return (TRUE);
  1843.         }
  1844. }
  1845.  
  1846.  
  1847. /* Pexec wants the command tail to have a byte count as the first
  1848.  *    character.  This function separates the program name from the command
  1849.  *    tail and adds the byte count.
  1850.  */
  1851.  
  1852. static VOID splitcmd (cmd, tail)
  1853.     char* cmd;
  1854.     char* tail;
  1855. {   int i, j;
  1856.     i = 0;
  1857.     j = 0;
  1858.     while (cmd[i] != '\0') {
  1859.         if (j != 0)  { 
  1860.         tail[j] = cmd[i]; 
  1861.         j++;
  1862.             }
  1863.         else if (cmd[i] == ' ')  {
  1864.             cmd[i] = '\0';
  1865.             tail[1] = ' ';
  1866.             j = 2;
  1867.         }
  1868.         i++;
  1869.         }
  1870.     if (j == 0)  {
  1871.         tail[0] = (char) 1;
  1872.         tail[1] = ' ';
  1873.         tail[2] = '\0';
  1874.         }
  1875.     else {
  1876.         tail[j+1] = '\0';
  1877.         tail[0] = (char) (j-1);
  1878.         }
  1879.     }
  1880.  
  1881.  
  1882.  
  1883.  
  1884. /*
  1885.  * copy 'count' bytes from 'src' to 'dst'. (optimized)
  1886.  */
  1887. VOID bcopy(src, dst, count)
  1888. register char *src, *dst;
  1889. register count;
  1890. {
  1891.     register c1;
  1892.  
  1893.     /*
  1894.     ** The magic number 8 comes from:
  1895.     **   1   max. bytes before a word boundary
  1896.     **   4   min. bytes in a block of long-words
  1897.     **   3   max. bytes after the last long-word in the block
  1898.     */
  1899.     if (count >= 8) {
  1900.         /*
  1901.         ** Advance dst pointer to word boundary.
  1902.         */
  1903.         if (1 & (short)dst) {
  1904.             *dst++ = *src++;
  1905.                 count--;
  1906.     }
  1907.         /*
  1908.         ** If src pointer is (also) aligned, use long-word copy.
  1909.         */
  1910.         if ((1 & (short)src) == 0) {
  1911.             c1 = ((unsigned)count >> 2);
  1912.             while (--c1 >= 0)
  1913.                 *((long *)dst)++ = *((long *)src)++;
  1914.             count &= 3;        /* There are 0,1,2, or 3 bytes left */
  1915.         }
  1916.     }
  1917.     /*
  1918.     ** Copy whatever is left.
  1919.     */
  1920.     while (--count >= 0)
  1921.     *dst++ = *src++;
  1922. }
  1923.  
  1924. /* Busy waiting to fake out sleep.  Thanks to Rich Sansom for the routine
  1925.  *    to poll the system clock.
  1926.  */
  1927.  
  1928. static long *hz_200 = (long *)0x000004ba;    /* system 200 hz clock        */
  1929.  
  1930. #ifdef NO_DPROMPT
  1931. static long read200hz()
  1932. #else
  1933. long read200hz()
  1934. #endif /* NO_DPROMPT */
  1935. {   return(*hz_200);
  1936.     }
  1937.  
  1938.  
  1939. /* Sleep (busily) for n seconds */
  1940.  
  1941. sleep (n)
  1942.     int n;
  1943. {   register long waitfor = (n * 200) + Supexec(read200hz);
  1944.  
  1945.     while (Supexec(read200hz) < waitfor);
  1946.     }
  1947.  
  1948. SHAR_EOF
  1949. cat << \SHAR_EOF > sys/atari/sysdef.h
  1950. /* sysdef.h --  MG header file for Atari ST
  1951.  *
  1952.  * author :  Sandra Loosemore
  1953.  * date   :  24 Oct 1987
  1954.  *
  1955.  */
  1956.  
  1957. #define    NULL    0L            /* So who needs stdio.h?    */
  1958. #include    <osbind.h>
  1959.  
  1960. /* This definition might be missing from your osbind.h */
  1961.  
  1962. #ifndef Supexec
  1963. #define Supexec(a)  xbios(38,a)
  1964. #endif
  1965.  
  1966.  
  1967. #define    KBLOCK        512        /* Kill grow.            */
  1968. #define    GOOD        0        /* Good exit status.        */
  1969. #define NO_VOID_TYPE    1        /* "void" is not a builtin type */
  1970. #ifdef MWC
  1971. #undef    NO_VOID_TYPE
  1972. #define    ZEROARRAY            /* See def.h            */
  1973.     /*
  1974.      * Using the MWC shell, ARGV is always the last environment entry
  1975.      * (if ARGV is not defined, the program was not started from the
  1976.      * MWC shell).  The last environment variable is followed by
  1977.      * the string pointed to by argv[0], then argv[1], etc.  This
  1978.      * means that the non-MWC getenv() in misc.c will take command line
  1979.      * args as environment variables.  It also means that if spawn()
  1980.      * (misc.c) runs the MWC shell, the shell takes this program's args
  1981.      * as its own.  So here we truncate the environment by zeroing out
  1982.      * the first character of argv[0], thus working around both problems.
  1983.      */
  1984. #define SYSINIT (*(argv[0]) = 0)    /* run in main()         */
  1985. #endif /* MWC */
  1986.  
  1987. #define MALLOCROUND(m) ((m)+=1,(m)&=~1)    /* 2-byte blocks (see alloc.c)    */
  1988. #define LOCAL_VARARGS    1        /* For echo.c            */
  1989. #define RSIZE long            /* Type for file/region sizes   */
  1990. #define KCHAR int                       /* 16 bits for keystrokes       */
  1991.  
  1992.  
  1993. /* Enable various things */
  1994.  
  1995. #define DO_METAKEY    1        /* Meta key code */
  1996. #define METABIT        0x200
  1997. #define FKEYS        1        /* Enable fkey code */
  1998. #define GOSMACS     1        /* Goslings compatibility functions */
  1999. #define PREFIXREGION    1        /* Enable prefix-region function */
  2000. #define BSMAP        FALSE        /* BSMAP code, default to off */
  2001.  
  2002. /* Disable some features for now. */
  2003.  
  2004. #define NO_BACKUP    1
  2005.  
  2006.  
  2007. /* Alcyon thinks subtracting two pointers gives a long.  Cast it to int.
  2008.  */
  2009.  
  2010. #define OFFSET(type,member) ((int)((char *)&(((type *)0)->member)-(char *)((type *)0)))
  2011. #ifdef MWC
  2012. #undef    OFFSET
  2013. #endif /* MWC */
  2014.  
  2015. /*
  2016.  * Macros used by the buffer name making code.
  2017.  * Start at the end of the file name, scan to the left
  2018.  * until BDC1 (or BDC2, if defined) is reached. The buffer
  2019.  * name starts just to the right of that location, and
  2020.  * stops at end of string (or at the next BDC3 character,
  2021.  * if defined). BDC2 and BDC3 are mainly for VMS.
  2022.  */
  2023.  
  2024. #define    BDC1    '\\'            /* Buffer names.        */
  2025. #define    BDC2    ':'
  2026.  
  2027.  
  2028. #define fncmp strcmp            /* All filenames are lowercased */
  2029. extern char *strncpy();
  2030.  
  2031. SHAR_EOF
  2032. cat << \SHAR_EOF > sys/atari/term.c
  2033. /* term.c -- screen output code for Atari ST terminal
  2034.  *
  2035.  * author :  Sandra Loosemore (based on an earlier version by dec-rec!conroy)
  2036.  * date   :  24 Oct 1987
  2037.  * changes:  Marion Hakanson -- Jan 1988
  2038.  *
  2039.  * This code simulates scrolling regions by using the
  2040.  * insert line and delete line functions. Should display
  2041.  * handling be taught about this. Based on Rich's code
  2042.  * for the Heath H19.
  2043.  */
  2044.  
  2045. #include    "..\..\def.h"
  2046.  
  2047. #define    BEL    0x07            /* BEL character.        */
  2048. #define    ESC    0x1B            /* ESC character.        */
  2049. #define    LF    0x0A            /* Line feed.            */
  2050.  
  2051. extern int ttrow;
  2052. extern int ttcol;
  2053. extern int tttop;
  2054. extern int ttbot;
  2055. extern int tthue;
  2056.  
  2057. int    tceeol    =    2;        /* Costs.            */
  2058. int    tcinsl, tcdell;            /* Set in ttyio.c:ttopen()    */
  2059.  
  2060.  
  2061. /* Move the cursor to the specified origin 0 row and column position.  Try
  2062.  *    to optimize out extra moves; redisplay may have left the cursor in 
  2063.  *    the right location on the screen last time.
  2064.  */
  2065.  
  2066. VOID ttmove(row, col)
  2067. {   if (ttrow!=row || ttcol!=col) {
  2068.     if (row > nrow)
  2069.         row = nrow;
  2070.     if (col > ncol)
  2071.         col = ncol;
  2072.     ttputc(ESC);
  2073.     ttputc('Y');
  2074.     ttputc(row+' ');
  2075.     ttputc(col+' ');
  2076.     ttrow = row;
  2077.     ttcol = col;
  2078.     }
  2079.     }
  2080.  
  2081.  
  2082. /* Erase to end of line. */
  2083.  
  2084. VOID tteeol()
  2085. {   ttputc(ESC);
  2086.     ttputc('K');
  2087.     }
  2088.  
  2089.  
  2090. /* Erase to end of page. */
  2091.  
  2092. VOID tteeop()
  2093. {   ttputc(ESC);
  2094.     ttputc('J');
  2095.     }
  2096.  
  2097.  
  2098. /* Make a noise.  */
  2099.  
  2100. VOID ttbeep()
  2101. {   ttputc(BEL);
  2102.     ttflush();
  2103.     }
  2104.  
  2105.  
  2106. /* Insert nchunk blank line(s) onto the screen, scrolling the last line on
  2107.  *    the screen off the bottom. This is done with a cluster of clever 
  2108.  *    insert and delete commands, because there are no scroll regions.
  2109.  */
  2110.  
  2111. VOID ttinsl(row, bot, nchunk)
  2112. {   register int    i;
  2113.     if (row == bot) {
  2114.     ttmove(row, 0);
  2115.     tteeol();
  2116.     return;
  2117.     }
  2118.     ttmove(1+bot-nchunk, 0);
  2119.     for (i=0; i<nchunk; i++) {
  2120.     ttputc(ESC);
  2121.     ttputc('M');
  2122.     }
  2123.     ttmove(row, 0);
  2124.     for (i=0; i<nchunk; i++) {
  2125.     ttputc(ESC);
  2126.     ttputc('L');
  2127.     }
  2128.     ttrow = row;
  2129.     ttcol = 0;
  2130.     }
  2131.  
  2132.  
  2133. /* Delete nchunk line(s) at "row", replacing the bottom line on the screen
  2134.  *    with a blank line. This is done with a crafty sequences of insert 
  2135.  *    and delete line sequences since there is no scroll region.  The
  2136.  *     presence of the echo area makes a boundary condition go away.
  2137.  */
  2138.  
  2139. VOID ttdell(row, bot, nchunk)
  2140. {   register int    i;
  2141.     if (row == bot) {
  2142.     ttmove(row, 0);
  2143.     tteeol();
  2144.     return;
  2145.     }
  2146.     ttmove(row, 0);
  2147.     for (i=0; i<nchunk; i++) {
  2148.     ttputc(ESC);
  2149.     ttputc('M');
  2150.     }
  2151.     ttmove(1+bot-nchunk,0);
  2152.     for (i=0; i<nchunk; i++) {
  2153.     ttputc(ESC);
  2154.     ttputc('L');
  2155.     }
  2156.     ttrow = 1+bot-nchunk;
  2157.     ttcol = 0;
  2158.     }
  2159.  
  2160.  
  2161. /* Set display color.  Normal video is text color.  Reverse video is used
  2162.  *     for the mode line.
  2163.  */
  2164.  
  2165. VOID ttcolor(color)
  2166.     register int color;
  2167. {   if (color != tthue) {
  2168.     if (color == CTEXT) {        /* Normal video.    */
  2169.         ttputc(ESC);
  2170.         ttputc('q');
  2171.         } 
  2172.     else if (color == CMODE) {    /* Reverse video.    */
  2173.         ttputc(ESC);
  2174.         ttputc('p');
  2175.         }
  2176.     tthue = color;
  2177.     }
  2178.     }
  2179. SHAR_EOF
  2180. cat << \SHAR_EOF > sys/atari/ttydef.h
  2181. /*
  2182.  * Name:    MicroEMACS
  2183.  *        Atari 520ST header file.
  2184.  * Version:    30
  2185.  * Last edit:    22-Feb-86
  2186.  * By:        rex::conroy
  2187.  *        decvax!decwrl!dec-rhea!dec-rex!conroy
  2188.  */
  2189. #define    GOSLING    1            /* Use fancy redisplay.        */
  2190.  
  2191. #define    NROW    50            /* The "50" is big enough to    */
  2192. #define    NCOL    80            /* deal with the "hi50" screen.    */
  2193.  
  2194. /*
  2195.  * Special keys.
  2196.  */
  2197.  
  2198. #define KFIRST    256
  2199. #define KLAST   284
  2200.  
  2201.  
  2202. /* These i/o functions are NOP's or direct equivalents of BIOS calls.
  2203.  *    Make them #define's so we don't have to go through a useless
  2204.  *    level of indirection.
  2205.  */
  2206.  
  2207. #define ttinit()
  2208. #define tttidy()
  2209. #define ttwindow(top,bot) (top, bot)
  2210. #define ttresize()
  2211. #define ttnowindow()
  2212. #define ttputc(c) Bconout(2, c)        /* Primitive output function    */
  2213. #define ttflush()                    /* A NOP            */
  2214. #define typeahead() ((int)Bconstat(2))    /* Check if there is input    */
  2215. SHAR_EOF
  2216. cat << \SHAR_EOF > sys/atari/ttyio.c
  2217. /* ttyio.c -- Low-level Atari ST terminal input/output handling
  2218.  *
  2219.  * author :  Sandra Loosemore (from an earlier version by dec-rex!conroy)
  2220.  * date   :  24 Oct 1987
  2221.  * changes:  Marion Hakanson -- Jan 1988
  2222.  *
  2223.  */
  2224.  
  2225. #include    "..\..\def.h"
  2226.  
  2227. int    nrow;                /* Terminal size, rows.        */
  2228. int    ncol;                /* Terminal size, columns.    */
  2229.  
  2230. #ifdef DO_METAKEY
  2231. #define RSHIFT   (0x01)
  2232. #define LSHIFT     (0x02)
  2233. #define CTRL     (0x04)
  2234. #define ALTKEY     (0x08)
  2235. #define CAPSLOCK (0x10)
  2236.  
  2237. static struct keytab {
  2238.     char *unshift;
  2239.     char *shift;
  2240.     char *capslock;
  2241.     } *keytable;
  2242.  
  2243.  
  2244. /* Mess with the bit that controls whether we get back all the shift keys
  2245.  *    on each keystroke.
  2246.  */
  2247.  
  2248. static unsigned char oldconterm;
  2249. static unsigned char *conterm = (char *)0x00000484;
  2250.  
  2251. static savect ()
  2252. {   oldconterm = *conterm;
  2253.     *conterm = (oldconterm | 0x8);
  2254.     }
  2255.  
  2256. static restct ()
  2257. {   *conterm = oldconterm;
  2258.     }
  2259. #endif /* DO_METAKEY */
  2260.  
  2261.  
  2262. /* Setup routines.  "getnrow" and "getncol" are assembly language routines.
  2263.  */
  2264.  
  2265. VOID ttopen()
  2266. {   nrow = getnrow();
  2267.     if (nrow > NROW)
  2268.     nrow = NROW;
  2269.     ncol = getncol();
  2270.     if (ncol > NCOL)
  2271.     ncol = NCOL;
  2272.     tcinsl = tcdell = (nrow * 2) + (ncol / 10);
  2273. #ifdef DO_METAKEY
  2274.     (VOID) Supexec(savect);
  2275.     keytable = (struct keytab *)Keytbl(-1L,-1L,-1L);
  2276. #endif /* DO_METAKEY */
  2277.     }
  2278.  
  2279. VOID ttclose()
  2280. {
  2281. #ifdef DO_METAKEY
  2282.     (VOID) Supexec(restct);
  2283. #endif /* DO_METAKEY */
  2284.     }
  2285.  
  2286.  
  2287. /* Keystrokes are returned as 10-bit quantities.
  2288.  *
  2289.  * Codes 0-255 are used for the usual character set.
  2290.  * Codes 256-511 are used for function keys.
  2291.  * Bit 10 (0x200) is the meta bit.
  2292.  *
  2293.  */
  2294. #ifdef FKEYS
  2295.  
  2296. static int keycodes[] = {
  2297.     0x00,    /* dummy for F0 entry */
  2298.     0x3b,    0x3c,    0x3d,    0x3e,    0x3f,
  2299.     0x40,    0x41,    0x42,    0x43,    0x44,
  2300.     0x54,    0x55,    0x56,    0x57,    0x58,
  2301.     0x59,    0x5a,    0x5b,    0x5c,    0x5d,
  2302.     0x62,    0x61,    0x52,    0x48,    0x47,
  2303.     0x4b,    0x50,    0x4d
  2304.         };
  2305.  
  2306. char *keystrings[] = {
  2307. "",        /* dummy for F0 entry */
  2308. "F1",        "F2",        "F3",        "F4",        "F5",
  2309. "F6",        "F7",        "F8",        "F9",        "F10",
  2310. "F11",        "F12",        "F13",        "F14",        "F15",
  2311. "F16",        "F17",        "F18",        "F19",        "F20",
  2312. "Help",        "Undo",        "Insert",    "Up",        "Clr/Home",
  2313. "Left",        "Down",        "Right"
  2314. };
  2315. #endif /* FKEYS */
  2316.  
  2317. /* Use the ALT key as a meta key.  The problem with this is that it
  2318.  *    appears to trash the ascii key code in the low order byte.
  2319.  *    Therefore, we have to resort to looking up the key in the
  2320.  *    system keystroke translation table.
  2321.  * Some non-US keyboards apparently use some ALT combinations to
  2322.  *    get real, printing characters.  If you've got one of these
  2323.  *    beasts you can use meta-key-mode to turn off recognition
  2324.  *    of the ALT key, in which case this routine just returns
  2325.  *    whatever BIOS gave as the key value.  If that approach is
  2326.  *    distasteful, you can also bind a function key to return
  2327.  *    the ALT characters usurped by the meta key mode.
  2328.  */
  2329.  
  2330. KCHAR getkbd()
  2331. {   register int code, bchar;
  2332. #ifdef FKEYS
  2333.     register int i;
  2334. #endif /* FKEYS */
  2335. #ifdef DO_METAKEY
  2336.     register int shifts;
  2337.     extern int use_metakey;        /* set in the generic kbd.c */
  2338. #endif /* DO_METAKEY */
  2339.     union {
  2340.         unsigned long k_rawkey;
  2341.         struct {
  2342.             unsigned char kb_shifts;    /* shift bits */
  2343.             unsigned char kb_code;    /* scan code */
  2344.             unsigned char kb_notused;
  2345.             unsigned char kb_bchar;    /* bios char */
  2346.         } k_break;
  2347.     } keyval;
  2348.  
  2349.     keyval.k_rawkey = Bconin(2);
  2350.     code   = keyval.k_break.kb_code;
  2351.  
  2352. #ifdef FKEYS
  2353.     for (i=KFIRST; i<=KLAST; i++)            /* Was it an Fkey? */
  2354.         if (code == keycodes[i-KFIRST])
  2355.         return((KCHAR)i);
  2356. #endif /* FKEYS */
  2357.  
  2358.     bchar  = keyval.k_break.kb_bchar;
  2359. #ifdef DO_METAKEY
  2360.     shifts = keyval.k_break.kb_shifts;
  2361.  
  2362.     /*
  2363.      * Rule out the case where some shift bit other than what
  2364.      * we're interested in is set (if such a beast ever exists).
  2365.      * If otherwise, just forget about any special handling here.
  2366.      */
  2367.     if (use_metakey == TRUE &&
  2368.             (shifts & ~(CTRL|LSHIFT|RSHIFT|CAPSLOCK)) == ALTKEY)
  2369.         if ((shifts & (CTRL|LSHIFT|RSHIFT|CAPSLOCK)) == 0) /* ALTKEY only */
  2370.         return ((KCHAR)(keytable->unshift[code] | METABIT));
  2371.         else if (shifts & CTRL)
  2372.         return ((KCHAR)(bchar | METABIT));
  2373.         else if (shifts & (LSHIFT|RSHIFT))
  2374.         return ((KCHAR)(keytable->shift[code] | METABIT));
  2375.         else /* (shifts & CAPSLOCK) */
  2376.         return ((KCHAR)(keytable->capslock[code] | METABIT));
  2377.     else
  2378.         return ((KCHAR)bchar);
  2379. #else
  2380.     return ((KCHAR)bchar);
  2381. #endif
  2382.     }
  2383.  
  2384. /* Establish default keypad bindings.  I've only done the arrow keys
  2385.  *    here.
  2386.  */
  2387.  
  2388.  
  2389. VOID ttykeymapinit() { 
  2390. /*  excline("global-set-key f13 previous-line"); */    /* Up arrow */
  2391. /*  excline("global-set-key f15 backward-char"); */     /* Left arrow */  
  2392. /*  excline("global-set-key f16 next-line"); */        /* Down arrow */
  2393. /*  excline("global-set-key f17 forward-char"); */        /* Right arrow */
  2394.     }
  2395.  
  2396.  
  2397. #ifndef NO_DPROMPT
  2398. /*
  2399.  * Return TRUE if we busy-wait for 2 seconds without any keystrokes;
  2400.  * otherwise return FALSE.  See sleep() in misc.c for details.
  2401.  */
  2402.  
  2403. ttwait() {
  2404.     extern long read200hz();
  2405.     register keyhit;
  2406.     register long waitfor = 400L + Supexec(read200hz);
  2407.  
  2408.     while ((keyhit = typeahead()) == 0 && Supexec(read200hz) < waitfor);
  2409.     if (keyhit)
  2410.         return FALSE;
  2411.  
  2412.     return TRUE;
  2413.     }
  2414. #endif /* NO_DPROMPT */
  2415.  
  2416.  
  2417. SHAR_EOF
  2418. cat << \SHAR_EOF > sys/atari/varargs.h
  2419. /*
  2420.  * Varargs, for use on Atari ST (works with MWC, probably others).
  2421.  *    Came from AmigaDOS version, which was borrowed from 4BSD.
  2422.  */
  2423.  
  2424. typedef char        *va_list;
  2425. #define va_dcl        int va_alist;
  2426. #define va_start(pv)    pv = (char *) &va_alist
  2427. #define va_end(pv)    /* Naught to do... */
  2428. #define va_arg(pv, t)    ((t *) (pv += sizeof(t)))[-1]
  2429. SHAR_EOF
  2430. #    End of shell archive
  2431. exit 0
  2432. -------
  2433.