home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / scheme / pcscheme / ti / pcscm3_3 / pkxli.arc / EXEC.C next >
Encoding:
C/C++ Source or Header  |  1988-06-07  |  6.8 KB  |  216 lines
  1. /* 
  2.    This program demonstrates how regular DOS executable files can be
  3.    run from XLI and represents an alternative to DOS-CALL.  It also
  4.    provides an example that uses string arguments and the "swap"
  5.    special service call to access them.
  6.  
  7.    User documentation is available under XLI\EXEC.DOC.  EXEC.EXE is
  8.    already provided and can be used immediately by inserting its pathname
  9.    in your .XLI control file.
  10.  
  11.    To generate EXEC.EXE yourself, do the following (substituting
  12.    directory names and setting the path as needed; Lattice C version 3.0
  13.    was used):
  14.  
  15.        lc exec
  16.     masm glue_lc;
  17.     link \lc\s\c+exec+glue_lc,exec,,\lc\s\lc
  18.  
  19.    When EXEC.EXE is loaded, it allocates a block of memory from DOS
  20.    before returning to PCS.  Further external programs, and the Scheme
  21.    heap, are allocated with this block unavailable to them.  On the
  22.    first (XCALL "exec" ...), the block is returned to DOS, and then
  23.    DOS can use it to run other programs in.  In this approach, nothing
  24.    of Scheme needs to be saved or restored, so running another program
  25.    is quick.  On the other hand, Scheme's heap is that much smaller,
  26.    meaning a smaller workspace and more garbage collections.  When PCS
  27.    terminates, this program's termination code makes certain that the
  28.    block gets deallocated (in case it never got called in the first place).
  29. */
  30.    
  31.     
  32.  
  33.  
  34.  
  35. #include "dos.h"
  36.  
  37. #define F_NEAR      0x0001
  38. #define F_INTEGER 0x0002
  39. #define F_PAD      0x0008
  40.  
  41. #define RT_INTEGER 0
  42.  
  43. #define CARRY_BIT 1
  44.  
  45. typedef unsigned short WORD;        /* 16-bit unsigned value */
  46.  
  47. extern WORD _psp;            /* Lattice C variables */
  48. extern WORD _tsize;
  49. extern WORD _oserr;
  50.  
  51. /* Note xwait and xbye are the actual addresses we'll jump to when we
  52.    call XLI from the glue routine.  C calls the glue routine at the
  53.    two entry points xli_wait and xli_bye.  These 2 routines set
  54.    up the stack for calling xwait and xbye.  */
  55. WORD xwait[2];                /* XLI entry points */
  56. WORD xbye[2];
  57.  
  58. struct xli_file_struct {
  59.   WORD id;
  60.   WORD flags;
  61.   WORD table[2];            /* offset in 0, segment in 1 */
  62.   WORD parm_block[2];
  63.   WORD reserved[8];
  64. } file_block;
  65.  
  66. struct xli_routine_struct {
  67.   WORD select;
  68.   WORD special_service;
  69.   WORD ss_args[8];
  70.   WORD reserved[8];
  71.   WORD return_type;
  72.   int return_value;
  73.   int dummy[3];
  74.   char *arg[16];          /* position 0 == filename */
  75.                   /* positions 1..15 are for args */
  76. } parm_block;
  77.  
  78. char table[] =
  79. /* 0        2        4          6      8      10       12      */
  80.   "exec//";
  81.  
  82.  
  83. void main(argc,argv)
  84. int argc;
  85. char *argv[];
  86. {
  87.   int i,flags,allocated;
  88.   WORD psp;
  89. /*WORD memsize;     */
  90.   WORD buffer[2];
  91.   WORD block_ptr;
  92.   union  REGS  regs;
  93.   struct SREGS segregs;
  94.   int xli_wait();
  95.   void xli_bye();
  96.   char *getenv();
  97.   long atol();
  98.   char cmd[128];
  99.   char *local_argv[17];        /* use positions 1..16 */
  100.  
  101. /* -------------------- XLI-specific initialization ----------------------- */
  102.  
  103.   /* Note PSP@ is not necessarily directly accessible in any
  104.      Lattice C memory model. */
  105.   psp = *(&_psp+1);            /* get seg addr of PSP */
  106.  
  107.   /* init file block */
  108.   file_block.id = 0x4252;
  109.   file_block.flags = F_NEAR+F_INTEGER;
  110.   file_block.table[0] = (WORD) table;
  111.   file_block.parm_block[0] = (WORD) &parm_block;
  112.   segread(&segregs);
  113.   file_block.table[1] = segregs.ds;
  114.   file_block.parm_block[1] = segregs.ds;
  115.  
  116.   /* determine link address */
  117.   buffer[0] = (WORD) &file_block;
  118.   buffer[1] = segregs.ds;
  119.  
  120.   /* determine size to keep */
  121. /*memsize = _tsize;   */       /* done in glue routine for S Lattice */
  122.  
  123.   /* establish the link addresses between C and PCS */
  124.   poke((int) psp, 0x5c, (char *) buffer, 4);  /* poke file block@ into PSP */
  125.   peek((int) psp, 0x0a, (char *) xwait, 4);   /* get DOS ret@ */
  126.   xbye[0] = xwait[0];
  127.   xbye[1] = xwait[1];
  128.   xwait[0] += 3;                  /* incr by 3 for normal call */
  129.   xbye[0] += 6;                   /* incr by 6 for termination */
  130.  
  131. /* ==================== start program-specific actions ==================== */
  132.  
  133. /* ----------------------------- initialization --------------------------- */
  134.  
  135.   /* allocate a block of memory */
  136.   regs.x.ax = 0x4800;        /* alloc mem */
  137.   { /* Set size from "XLI" env variable if available; unit size is Kb.
  138.        If var doesn't exist, use 64 Kb.  Convert to paragraphs.   */
  139.     char *block_reserve;
  140.  
  141.     block_reserve = getenv("XLI");
  142.     regs.x.bx = (block_reserve ? atol(block_reserve) * 1024 / 16
  143.                    : 0x1000);
  144.   }
  145.   flags = intdos(®s,®s);
  146.   block_ptr = (flags & CARRY_BIT) ? 0 : regs.x.ax;
  147.   allocated = 1;
  148.  
  149.   /* set all args to -1; since there are a variable # of args,
  150.      a -1 after them delimits them */
  151.   for (i = 0; i < 16; i++) parm_block.arg[i] = (char *) -1;
  152.  
  153. /* ----------------------------- handler loop    --------------------------- */
  154.  
  155.   while (xli_wait()) {
  156.  
  157.     if (!block_ptr) continue;        /* couldn't alloc, just skip */
  158.  
  159.     /* deallocate the block to leave a hole in which we can bid programs */
  160.     if (allocated) {
  161.       regs.x.ax = 0x4900;        /* dealloc mem */
  162.       segregs.es = block_ptr;        /* @block we previously allocated */
  163.       flags = intdosx(®s,®s,&segregs);
  164.       allocated = 0;
  165.     } /* end if */
  166.  
  167.     switch (parm_block.select) {
  168.       int i,error;
  169.  
  170.       case  0: /* get name of executable file */
  171.            parm_block.special_service = 1;
  172.            parm_block.ss_args[0] = 0;
  173.            parm_block.ss_args[1] = 128;
  174.            parm_block.ss_args[2] = (WORD) cmd;
  175.            (void) xli_wait();
  176.            *(cmd + parm_block.ss_args[0]) = '\0';
  177.  
  178.            /* get arguments to executable file */
  179.            for (i = 1; i < 17; i++) local_argv[i] = NULL;
  180.            for (i = 1; i < 16; i++) {
  181.          if ((int) parm_block.arg[i] == -1) break;
  182.          local_argv[i] = cmd + parm_block.ss_args[0] + 1;
  183.          parm_block.special_service = 1;
  184.          parm_block.ss_args[0] = i;
  185.          parm_block.ss_args[1] = cmd + 128 - local_argv[i];
  186.          parm_block.ss_args[2] = (WORD) local_argv[i];
  187.          (void) xli_wait();
  188.          *(local_argv[i] + parm_block.ss_args[0]) = '\0';
  189.            }
  190.  
  191.            /* exec the file and return the termination code */
  192.            /* or -1 if the file doesn't exist */
  193.            error = forkvp(cmd,local_argv);
  194.            parm_block.return_value = (error == -1 ? -1 : wait());
  195.            break;
  196.       default: ;
  197.     } /* end switch */
  198.     parm_block.return_type = RT_INTEGER;
  199.     for (i = 0; i < 16; i++) parm_block.arg[i] = (char *) -1;
  200.   } /* end while */
  201.  
  202. /* ----------------------------- termination    --------------------------- */
  203.  
  204.   /* in case this program was never called, the block we reserved */
  205.   /* is still allocated, so deallocate it */
  206.   if (allocated) {
  207.     regs.x.ax = 0x4900;           /* dealloc mem */
  208.     segregs.es = block_ptr;          /* @block we previously allocated */
  209.     flags = intdosx(®s,®s,&segregs);
  210.     allocated = 0;
  211.   } /* end if */
  212.  
  213.   xli_bye();
  214.  
  215. } /* end main */
  216.