home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / tvos200.zip / CPL / WATSTUB.C < prev    next >
C/C++ Source or Header  |  1995-04-19  |  11KB  |  572 lines
  1. /*
  2.  *    watstub.c:    WatCOM stub routines
  3.  *    ================================
  4.  *    (C)1995 by F.Jalvingh; All rights reserved.
  5.  *
  6.  *
  7.  *    $Header: s:/prj/apl/ICCSTUB.C_V 1.3 93/05/10 13:28:39 JAL Exp Locker: JAL $
  8.  *
  9.  *    Revision log:
  10.  *    -------------
  11.  *    $Log:    ICCSTUB.C_V $
  12.  *    Revision 1.3  93/05/10    13:28:39  JAL
  13.  *    Misc changes.
  14.  *
  15.  *    Revision 1.2  92/09/25    13:53:14  JAL
  16.  *    New 32-bits stuff..
  17.  *
  18.  *    Revision 1.1  92/08/24    14:22:20  JAL
  19.  *    Initial revision
  20.  *
  21.  *    Revision 1.2  92/06/18    14:22:33  HJB
  22.  *    Error in getdisk() solved.
  23.  *
  24.  *    Revision 1.1  91/10/20    20:44:13  JAL
  25.  *    Initial revision
  26.  *
  27.  *
  28.  */
  29. #if defined(__WATCOMC__)
  30.  
  31. #include    <stdio.h>
  32. #include    <stdlib.h>
  33. #include    <malloc.h>
  34. #include    <string.h>
  35. #include    <io.h>
  36. #include    <errno.h>
  37.  
  38. static char rcsid[] = "$Header: s:/prj/apl/ICCSTUB.C_V 1.3 93/05/10 13:28:39 JAL Exp Locker: JAL $";
  39.  
  40. #define NUL         '\0'
  41. #define EQ            ==
  42. #define NE            !=
  43. #define UWORD        unsigned short
  44.  
  45. #if defined(__WATCOMC__) && defined(__FLAT__) && !defined(__32BITS__)
  46. # define    __32BITS__
  47. #endif
  48.  
  49.  
  50. #ifdef    __OS2__
  51. #define INCL_BASE
  52. #define INCL_DOSMISC
  53. #define INCL_DOS
  54. #define INCL_SUB
  55. #define INCL_DOSERRORS
  56. #define INCL_DOSFILEMGR
  57. #define INCL_NOPMAPI
  58.  
  59. #if defined(__32BITS__)
  60. #include    <os2.h>
  61. #else
  62. #include    <os2/os2.h>
  63. #endif
  64.  
  65. #endif
  66.  
  67. char *searchpath(char *name)
  68. {
  69.     static char buffer[82];
  70.     char        *p, *pout, *pin, lastch;
  71.  
  72.     p    = getenv("PATH");                       /* Try to find PATH= variable, */
  73.     if(p EQ NULL) return NULL;                    /* There's no path! */
  74.  
  75.     /**** Now, for each subpath in the path try if the file passed can    ****/
  76.     /**** be accessed..                                                 ****/
  77.     while(*p NE NUL)
  78.     {
  79.         pout    = buffer;
  80.         lastch    = NUL;
  81.         while(*p NE ';' && *p NE NUL)
  82.         {
  83.             lastch    = *p++;
  84.             if( (pout-buffer) < sizeof(buffer)-2)
  85.                 *pout++ = lastch;
  86.         }
  87.         if(lastch != '\\' && lastch != ':')
  88.             *pout++ = '\\';
  89.  
  90.         /**** Now copy user-name part.. ****/
  91.         pin = name;
  92.         while(*pin NE NUL)
  93.         {
  94.             if( (pout-buffer) < sizeof(buffer)-2)
  95.             {
  96.                 *pout++ = *pin++;
  97.             }
  98.             else
  99.                 break;
  100.         }
  101.         *pout = NUL;
  102.  
  103.         if(access(buffer, 0) == 0) return buffer;
  104.         if(*p EQ ';') p++;
  105.     }
  106.     return NULL;
  107. }
  108.  
  109.  
  110. unsigned long coreleft(void)
  111. {
  112. #ifndef __OS2__
  113.     unsigned short seg;
  114.  
  115.     _dos_allocmem(0, &seg);
  116.     return (unsigned long)seg * 16l;
  117. #else
  118. # if defined(__32BITS__)
  119.     ULONG        c;
  120.  
  121.     DosQuerySysInfo(QSV_TOTAVAILMEM, QSV_TOTAVAILMEM, &c, sizeof(c));
  122.     return c;
  123. # else
  124.     unsigned long    c;
  125.  
  126.     DosMemAvail(&c);
  127.     return c;
  128. # endif
  129. #endif
  130. }
  131.  
  132.  
  133. unsigned long farcoreleft(void)
  134. {
  135.     return coreleft();
  136. }
  137.  
  138.  
  139. static void CopyIt(char *dst, const char *src, unsigned maxlen)
  140. {
  141.     if (dst)
  142.     {
  143.         if(strlen(src) >= maxlen)
  144.         {
  145.             strncpy(dst, src, maxlen);
  146.             dst[maxlen] = 0;
  147.         }
  148.         else
  149.             strcpy(dst, src);
  150.     }
  151. }
  152.  
  153. static int DotFound(char *pb)
  154. {
  155.     if (*(pb-1) == '.')
  156.         pb--;
  157.  
  158.     switch (*--pb)
  159.     {
  160.         case ':'  : if (*(pb-2) != '\0') break;
  161.         case '/'  :
  162.         case '\\' :
  163.         case '\0' : return 1;
  164.     }
  165.  
  166.     return 0;
  167. }
  168.  
  169. #define WILDCARDS 0x01
  170. #define EXTENSION 0x02
  171. #define FILENAME  0x04
  172. #define DIRECTORY 0x08
  173. #define DRIVE      0x10
  174.  
  175. #define MAXPATH   80
  176. #define MAXDRIVE  3
  177. #define MAXDIR      66
  178. #define MAXFILE   9
  179. #define MAXEXT      5
  180.  
  181. int fnsplit(const char *pathp, char *drivep, char *dirp, char *namep, char *extp)
  182. {
  183.     register char    *pb;
  184.     register int    wrk;
  185.     int     ret;
  186.     char    buf[MAXPATH+2];
  187.  
  188.     /**** Set all string to default value zero ****/
  189.     ret = 0;
  190.     if (drivep) *drivep = 0;
  191.     if (dirp)    *dirp    = 0;
  192.     if (namep)    *namep    = 0;
  193.     if (extp)    *extp    = 0;
  194.  
  195.     /**** Copy filename into template up to MAXPATH characters ****/
  196.     pb = buf;
  197.     while (*pathp == ' ') pathp++;
  198.  
  199.     if ((wrk = strlen(pathp)) > MAXPATH)
  200.         wrk = MAXPATH;
  201.  
  202.     *pb++ = 0;
  203.     strncpy(pb, pathp, wrk);
  204.     *(pb += wrk) = 0;
  205.  
  206.     /**** Split the filename and fill corresponding nonzero pointers ****/
  207.     wrk = 0;
  208.     for (;;)
  209.     {
  210.         switch (*--pb)
  211.         {
  212.             case '.'  : if (!wrk && (*(pb+1) == '\0')) wrk = DotFound(pb);
  213.                         if ((!wrk) && ((ret & EXTENSION) == 0))
  214.                         {
  215.                             ret |= EXTENSION;
  216.                             CopyIt(extp, pb, MAXEXT - 1);
  217.                             *pb = 0;
  218.                         }
  219.                         continue;
  220.  
  221.             case ':'  : if (pb != &buf[2]) continue;
  222.  
  223.             case '\0' : if (wrk)
  224.                         {
  225.                             if (*++pb)
  226.                                 ret |= DIRECTORY;
  227.                             CopyIt(dirp, pb, MAXDIR - 1);
  228.                             *pb-- = 0;
  229.                             break;
  230.                         }
  231.  
  232.             case '/'  :
  233.             case '\\' : if (!wrk)
  234.                         {
  235.                             wrk++;
  236.                             if (*++pb)
  237.                                 ret |= FILENAME;
  238.                             CopyIt(namep, pb, MAXFILE - 1);
  239.                             *pb-- = 0;
  240.                             if (*pb == 0 || (*pb == ':' && pb == &buf[2]))
  241.                                 break;
  242.                         }
  243.                         continue;
  244.  
  245.             case '*'  :
  246.             case '?'  : if (!wrk) ret |= WILDCARDS;
  247.  
  248.             default   : continue;
  249.         }
  250.  
  251.         break;
  252.     }
  253.  
  254.     if (*pb == ':')
  255.     {
  256.         if (buf[1])
  257.             ret |= DRIVE;
  258.         CopyIt(drivep, &buf[1], MAXDRIVE - 1);
  259.     }
  260.  
  261.     return (ret);
  262. }
  263.  
  264.  
  265. void fnmerge(char *out, char *drive, char *dir, char *name, char *ext)
  266. {
  267.     *out    = '\0';
  268.     if(*drive != '\0') strcpy(out, drive);
  269.     if(*dir   != '\0') strcat(out, dir);
  270.     if(*name  != '\0') strcat(out, name);
  271.     if(*ext   != '\0') strcat(out, ext);
  272. }
  273.  
  274.  
  275. #ifdef    __OS2__
  276. /*
  277.  *        getftime() for OS/2..
  278.  */
  279. int getftime(int ha, struct ftime *ft)
  280. {
  281. #if defined(__32BITS__)
  282.     ULONG        errc;
  283.     FILESTATUS3 fs;
  284.  
  285.     errc= DosQueryFileInfo(ha, 1, &fs, sizeof(fs));
  286.     if(errc)
  287.     {
  288.         memset(ft, 0, sizeof(ft));
  289.         return -1;
  290.     }
  291.     * (UWORD *)ft = * (UWORD *) &fs.ftimeLastWrite;
  292.     ((UWORD *)ft)[1] = *(UWORD *) &fs.fdateLastWrite;
  293.  
  294. #else
  295.     FILESTATUS        fs;
  296.     typedef unsigned int UWORD;
  297.  
  298.     DosQFileInfo(ha, 0x0001, &fs, sizeof(fs));
  299.     * (UWORD *)ft = * (UWORD *) &fs.ftimeLastWrite;
  300.     ((UWORD *)ft)[1] = *(UWORD *) &fs.fdateLastWrite;
  301. #endif
  302.     return 0;
  303. }
  304.  
  305.  
  306. /*
  307.  *    setftime() for OS/2
  308.  */
  309. int setftime(int ha, struct ftime *ft)
  310. {
  311.     FILESTATUS        fs;
  312.     UWORD            errc, *p;
  313.  
  314.     memset(&fs, 0, sizeof(fs));
  315.     errc= DosQFileInfo(ha, 0x0001, &fs, sizeof(fs));
  316.     if(errc) return -1;
  317.  
  318.     /**** Change the FILESTATUS structure.. ****/
  319.     p    = (UWORD *) &fs.ftimeLastWrite;
  320.     *p    = * (UWORD *)ft;
  321.  
  322.     p    = (UWORD *) &fs.fdateLastWrite;
  323.     *p    = ((UWORD *)ft)[1];
  324.     errc= DosSetFileInfo(ha, 0x0001, &fs, sizeof(fs));
  325.     return errc == 0 ? 0 : -1;
  326. }
  327. #endif
  328.  
  329.  
  330. /*
  331.  *        farmalloc() does a MSC halloc..
  332.  */
  333. void *farmalloc(unsigned long size)
  334. {
  335.     return malloc(size);
  336. }
  337.  
  338.  
  339. void farfree(void *s)
  340. {
  341.     free(s);
  342. }
  343.  
  344.  
  345. #ifdef    __OS2__
  346.  
  347. struct    ffblk
  348. {
  349.     char        ff_reserved[21];
  350.     char        ff_attrib;
  351.     unsigned    ff_ftime;
  352.     unsigned    ff_fdate;
  353.     long        ff_fsize;
  354.     char        ff_name[13];
  355. };
  356.  
  357.  
  358. /*
  359.  *        findfirst() searches a '1st' file..
  360.  */
  361. int findfirst(char *path, struct ffblk *ff, int attrib)
  362. {
  363. #ifdef __32BITS__
  364.     FILEFINDBUF3    fb;
  365.     HDIR            hdir = 0xffff;        /* HDIR_SYSTEM */
  366.     ULONG            count = 1,            /* File count, */
  367.                     err;
  368.  
  369.     err = DosFindFirst(path, &hdir, attrib, &fb, sizeof(fb), &count, 1l);
  370.     if(err)
  371.     {
  372.         /**** Translate error.. ****/
  373.         switch(err)
  374.         {
  375.             case ERROR_PATH_NOT_FOUND:    errno = ENOENT; break;
  376.             case ERROR_NO_MORE_FILES:    errno = EMFILE; break;
  377.             default:                    errno = EINVAL; break;
  378.         }
  379.         return -1;
  380.     }
  381. #else
  382.     FILEFINDBUF     fb;
  383.     HDIR            hdir = 0xffff;        /* HDIR_SYSTEM */
  384.     USHORT            count = 1,            /* File count, */
  385.                     err;
  386.  
  387.     err = DosFindFirst(path, &hdir, attrib, &fb, sizeof(fb), &count, 0l);
  388.     if(err)
  389.     {
  390.         /**** Translate error.. ****/
  391.         switch(err)
  392.         {
  393.             case ERROR_PATH_NOT_FOUND:    errno = ENOENT; break;
  394.             case ERROR_NO_MORE_FILES:    errno = EMFILE; break;
  395.             default:                    errno = EINVAL; break;
  396.         }
  397.         return -1;
  398.     }
  399. #endif
  400.  
  401.     /**** Translate find buffer..    ****/
  402.     memcpy(ff->ff_reserved, &hdir, sizeof(hdir));    /* Save handle, */
  403.     ff->ff_attrib    = (char)fb.attrFile;        /* Copy file attributes, */
  404.     memcpy(&ff->ff_ftime, &fb.ftimeLastWrite, sizeof(ff->ff_ftime));
  405.     memcpy(&ff->ff_fdate, &fb.fdateLastWrite, sizeof(ff->ff_fdate));
  406.     ff->ff_fsize    = fb.cbFile;
  407.     memcpy(ff->ff_name, fb.achName, sizeof(ff->ff_name));
  408.     return 0;
  409. }
  410.  
  411.  
  412. /*
  413.  *        findnext() finds the next file..
  414.  */
  415. int findnext(struct ffblk *ff)
  416. {
  417. #ifdef __32BITS__
  418.     FILEFINDBUF3    fb;
  419.     HDIR            hdir;
  420.     ULONG            count = 1,
  421.                     err;
  422.  
  423.     /**** Get HDIR from reserved area,    ****/
  424.     memcpy(&hdir, ff->ff_reserved, sizeof(hdir));
  425.     err = DosFindNext(hdir, &fb, sizeof(fb), &count);
  426.     if(err NE 0)
  427.     {
  428.         switch(err)
  429.         {
  430.             case ERROR_PATH_NOT_FOUND:    errno = ENOENT; break;
  431.             case ERROR_NO_MORE_FILES:    errno = EMFILE; break;
  432.             default:                    errno = EINVAL; break;
  433.         }
  434.         return -1;
  435.     }
  436. #else
  437.     FILEFINDBUF     fb;
  438.     HDIR            hdir;
  439.     USHORT            count = 1,
  440.                     err;
  441.  
  442.     /**** Get HDIR from reserved area,    ****/
  443.     memcpy(&hdir, ff->ff_reserved, sizeof(hdir));
  444.     err = DosFindNext(hdir, &fb, sizeof(fb), &count);
  445.     if(err NE 0)
  446.     {
  447.         switch(err)
  448.         {
  449.             case ERROR_PATH_NOT_FOUND:    errno = ENOENT; break;
  450.             case ERROR_NO_MORE_FILES:    errno = EMFILE; break;
  451.             default:                    errno = EINVAL; break;
  452.         }
  453.         return -1;
  454.     }
  455. #endif
  456.  
  457.     /**** Copy..    ****/
  458.     ff->ff_attrib    = (char)fb.attrFile;        /* Copy file attributes, */
  459.     memcpy(&ff->ff_ftime, &fb.ftimeLastWrite, sizeof(ff->ff_ftime));
  460.     memcpy(&ff->ff_fdate, &fb.fdateLastWrite, sizeof(ff->ff_fdate));
  461.     ff->ff_fsize    = fb.cbFile;
  462.     memcpy(ff->ff_name, fb.achName, sizeof(ff->ff_name));
  463.     return 0;
  464. }
  465.  
  466.  
  467. int getcurdir(int drive, char *dir)
  468. {
  469. #ifdef __32BITS__
  470.     ULONG    bytes;
  471.  
  472.     bytes    = 0;
  473.     DosQueryCurrentDir(drive, NULL, &bytes);
  474.     if(bytes > MAXPATH) return -1;
  475.     DosQCurDir(drive, dir, &bytes);
  476.     return 0;
  477. #else
  478.     USHORT    bytes;
  479.  
  480.     bytes    = 0;
  481.     DosQCurDir(drive, NULL, &bytes);
  482.     if(bytes > MAXPATH) return -1;
  483.     DosQCurDir(drive, dir, &bytes);
  484.     return 0;
  485. #endif
  486. }
  487.  
  488.  
  489. int getdisk(void)
  490. {
  491. #ifdef    __32BITS__
  492.     ULONG    drive, numdrives;
  493.  
  494.     DosQueryCurrentDisk(&drive, &numdrives);
  495. #else
  496.     USHORT    drive;
  497.     ULONG    numdrives;
  498.  
  499.     DosQCurDisk(&drive, &numdrives);
  500. #endif
  501.     return (int)drive - 1;
  502.  
  503. }
  504.  
  505.  
  506. int setdisk(int drive)
  507. {
  508. #if defined(__32BITS__)
  509.     return (int)DosSetDefaultDisk((ULONG)drive + 1);
  510. #else
  511.     return (int)DosSelectDisk((USHORT)drive + 1);  /* Bcc getdisk: 'A' = 0; MSC DosSelectdisk: 'A' = 1 */
  512. #endif
  513. }
  514.  
  515.  
  516. char *getpass(char *prompt)
  517. {
  518.     static char buf[20];
  519.     char        *p;
  520.  
  521.     puts(prompt);
  522.  
  523.     fgets(buf, 8, stdin);
  524.     for(p = buf; *p NE NUL && *p NE 0x0a && *p NE 0x0d; ) p++;
  525.     *p = NUL;
  526.  
  527.     return buf;
  528. }
  529.  
  530.  
  531. #define LK_UNLCK    0    /* unlock the file region */
  532. #define LK_LOCK     1    /* lock the file region */
  533. #define LK_NBLCK    2    /* non-blocking lock */
  534. #define LK_RLCK     3    /* lock for writing */
  535. #define LK_NBRLCK    4    /* non-blocking lock for writing */
  536.  
  537.  
  538. int locking(int h, int mode, long bytes)
  539. {
  540.     ULONG        errc;
  541.     FILELOCK    fl, fu;
  542.  
  543.     if(mode == LK_LOCK)
  544.     {
  545.         fl.lOffset    = tell(h);
  546.         fl.lRange    = bytes;
  547.         fu.lOffset    = 0;
  548.         fu.lRange    = 0;
  549.     }
  550.     else if(mode == LK_UNLCK)
  551.     {
  552.         fu.lOffset    = tell(h);
  553.         fu.lRange    = bytes;
  554.         fl.lOffset    = 0;
  555.         fl.lRange    = 0;
  556.     }
  557.     else
  558.     {
  559.         puts("Illegal LOCK mode");
  560.         exit(30);
  561.     }
  562.  
  563.     errc= DosSetFileLocks(h, &fu, &fl, 20000, 0);
  564.     if(errc != 0) return -1;
  565.     return 0;
  566. }
  567.  
  568.  
  569. #endif /* __OS2__ */
  570.  
  571. #endif
  572.