home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_200 / 201_01 / execute.c < prev    next >
Encoding:
C/C++ Source or Header  |  1980-01-01  |  4.3 KB  |  252 lines
  1. #define    PRIVATE    static
  2. #define    PUBLIC    extern
  3. #define    NULL    0
  4. #define    VOID    int
  5. #define    BOOLEAN    int
  6.  
  7. VOID _chain(program, args)
  8. char *program, *args ;
  9.     {
  10.     char *path ;
  11.     PRIVATE char *Full_Path_Name() ;
  12.  
  13.     if (path = Full_Path_Name(program))
  14.         {
  15.         chain(path, args)) ;
  16.         }
  17.     }
  18.  
  19.  
  20. int _exec(program, args)
  21. char *program, *args ;
  22.     {
  23.     char *path ;
  24.     PRIVATE char *Full_Path_Name() ;
  25.  
  26.     if (path = Full_Path_Name(program))
  27.         {
  28.         return (exec(path, args)) ;
  29.         }
  30.     return 255 ;
  31.     }
  32.  
  33. PRIVATE char *Full_Path_Name(file)
  34. char *file ;
  35.     {
  36.     char cur_path[200], sav_dir[80], *dir, *ptr, program[80] ;
  37.     static char path[80] ;
  38.     int sav_drv ;
  39.     PRIVATE char *Strip_Drive() ;
  40.     PRIVATE VOID Get_Cur_Path(), Get_Cur_Dir() ;
  41.     PRIVATE VOID Set_Cur_Drv(), Set_Cur_Dir() ;
  42.     PRIVATE int Get_Cur_Drv() ;
  43.     PRIVATE BOOLEAN Found() ;
  44.  
  45.     /* convert program name to upper case */
  46.     strcpy(program, file) ;
  47.     for (ptr = program; *ptr; ptr++)
  48.         {
  49.         *ptr = toupper(*ptr) ;
  50.         }
  51.  
  52.     /* look in current directory first */
  53.     if (Found(program))
  54.         {
  55.         strcpy(path, program) ;
  56.         return path ;
  57.         }
  58.  
  59.     /* save context */
  60.     Get_Cur_Dir(sav_dir) ;
  61.     sav_drv = Get_Cur_Drv() ;
  62.  
  63.     /* look for COMSPEC in environment */
  64.     if (!strcmp(program, "COMMAND.COM") && (dir = Get_Env_Str("COMSPEC")))
  65.         {
  66.         if (Found(dir))
  67.             {
  68.             strcpy(path, dir) ;
  69.             Set_Cur_Drv(sav_drv) ;
  70.             Set_Cur_Dir(sav_dir) ;
  71.             return path ;
  72.             }
  73.         }
  74.  
  75.     Get_Cur_Path(cur_path) ;
  76.     if (!*cur_path)
  77.         {
  78.         return 0 ;
  79.         }
  80.  
  81.     dir = cur_path ;
  82.     do
  83.         {
  84.         if (ptr = index(dir, ';'))
  85.             {
  86.             *ptr++ = NULL ;
  87.             }
  88.         dir = Strip_Drive(dir, sav_drv) ;
  89.  
  90.         if (*dir == '\\')
  91.             {
  92.             Set_Cur_Dir("\\") ;
  93.             dir++ ;
  94.             }
  95.         else
  96.             {
  97.             Set_Cur_Dir(sav_dir) ;
  98.             }
  99.         Set_Cur_Dir(dir) ;
  100.  
  101.         if (Found(program))
  102.             {
  103.             path[0] = 'A' + Get_Cur_Drv() ;
  104.             path[1] = ':' ;
  105.             Get_Cur_Dir(&path[2]) ;
  106.             if (path[3])
  107.                 {
  108.                 strcat(path, "\\") ;
  109.                 }
  110.             strcat(path, program) ;
  111.             Set_Cur_Drv(sav_drv) ;
  112.             Set_Cur_Dir(sav_dir) ;
  113.             return path ;
  114.             }
  115.         dir = ptr ;
  116.         }
  117.     while (*ptr) ;
  118.  
  119.     /* restore context */
  120.     Set_Cur_Drv(sav_drv) ;
  121.     Set_Cur_Dir(sav_dir) ;
  122.  
  123.     return 0 ;
  124.     }
  125.  
  126. PRIVATE VOID Get_Cur_Path(cur_path)
  127. char *cur_path ;
  128.     {
  129.     PRIVATE char *Get_Env_Str() ;
  130.     char *ptr ;
  131.  
  132.     *cur_path = NULL ;
  133.     if (ptr = Get_Env_Str("PATH"))
  134.         {
  135.         strcpy(cur_path,ptr) ;
  136.         }
  137.     }
  138.  
  139. PRIVATE char *Get_Env_Str(var)
  140. char *var ;
  141.     {
  142.     PUBLIC VOID chain() ;
  143.     unsigned offset = 0 ;
  144.     char *ptr ;
  145.     static char bfr[200] ;
  146.     extern unsigned _pcb ;    /* Pgm Ctl Blk: contents is segment of PSP */
  147.     union
  148.         {
  149.         unsigned seg ;    /* environment segment */
  150.         char byte[2] ;    /* unpacked form */
  151.         } env ;
  152.  
  153.     /* retrieve paragraph address of environment strings */
  154.     env.byte[0] = _peek(0x2C, _pcb) ;
  155.     env.byte[1] = _peek(0x2D, _pcb) ;
  156.  
  157.     while (_peek(offset, env.seg))
  158.         {
  159.         ptr = bfr ;
  160.         do /* copy string */
  161.             {
  162.             } while (*ptr++ = toupper(_peek(offset++, env.seg))) ;
  163.         *(ptr = index(bfr, '=')) = NULL ;
  164.         if (!strcmp(bfr, var))
  165.             {
  166.             return ptr + 1 ;
  167.             }
  168.         }
  169.     return 0 ;
  170.     }
  171.  
  172. PRIVATE VOID Get_Cur_Dir(bfr)
  173. char *bfr ;
  174.     {
  175.     PUBLIC int _rax, _rdx, _rds, _rsi ;
  176.  
  177.     *bfr = '\\' ;
  178.     _rax = 0x4700 ;
  179.     _rsi = bfr + 1 ;
  180.     _rds = _showds() ;
  181.     _rdx = 0 ;
  182.     _doint(0x21) ;
  183.     }
  184.  
  185. PRIVATE VOID Set_Cur_Dir(dir)
  186. char *dir ;
  187.     {
  188.     PUBLIC int _rax, _rdx, _rds ;
  189.  
  190.     _rax = 0x3B00 ;
  191.     _rdx = dir ;
  192.     _rds = _showds() ;
  193.     _doint(0x21) ;
  194.     }
  195.  
  196. PRIVATE int Get_Cur_Drv()
  197.     {
  198.     PUBLIC int _rax ;
  199.  
  200.     _rax = 0x1900 ;
  201.     _doint(0x21) ;
  202.     return _rax & 0xFF ;
  203.     }
  204.  
  205. PRIVATE VOID Set_Cur_Drv(drive)
  206. unsigned drive ;
  207.     {
  208.     PUBLIC int _rax, _rdx ;
  209.  
  210.     _rax = 0x0E00 ;
  211.     _rdx = drive ;
  212.     _doint(0x21) ;
  213.     }
  214.  
  215. PRIVATE BOOLEAN Found(file)
  216. char *file ;
  217.     {
  218.     PUBLIC int _rax, _rdx, _rcx, _rds, _carryf ;
  219.     char bfr[64] ;
  220.  
  221.     _rax = 0x1A00 ;
  222.     _rds = _showds() ;
  223.     _rdx = bfr ;
  224.     _doint(0x21) ;
  225.  
  226.     _rax = 0x4E00 ;
  227.     _rds = _showds() ;
  228.     _rdx = file ;
  229.     _rcx = 0 ;
  230.     _doint(0x21) ;
  231.  
  232.     return ! _carryf ;
  233.     }
  234.  
  235. PRIVATE char *Strip_Drive(dir, drv)
  236. char *dir ;
  237. int drv ;
  238.     {
  239.     PRIVATE Set_Cur_Drv() ;
  240.  
  241.     if (dir[1] == ':')
  242.         {
  243.         Set_Cur_Drv(toupper(*dir) - 'A') ;
  244.         dir += 2 ;
  245.         }
  246.     else
  247.         {
  248.         Set_Cur_Drv(drv) ;
  249.         }
  250.     return dir ;
  251.     }
  252.