home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_200 / 280_01 / misc.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-01-11  |  4.1 KB  |  201 lines
  1. /* [misc.c of JUGPDS Vol.17] */
  2. /*
  3. *****************************************************************
  4. *                                *
  5. *    Written by  Hakuo Katayose (JUG-CP/M No.179)        *
  6. *            49-114 Kawauchi-Sanjuunin-machi        *
  7. *            Sendai, Miyagi 980                          *
  8. *            Phone: 0222-61-3219                *
  9. *                                *
  10. *       Modifird by Toshiya Oota   (JUG-CPM No.10)              *
  11. *                   Sakae ko-po 205                 *
  12. *            5-19-6 Hosoda                *
  13. *            Katusikaku Tokyo 124            *
  14. *                                *
  15. *        for MS-DOS Lattice C V3.1J & 80186/V20/V30    *
  16. *                                *
  17. *    Compiler Option: -ccu -k0(1) -ms -n -v -w        *
  18. *                                *
  19. *    Edited & tested by Y. Monma (JUG-CP/M Disk Editor)    *
  20. *            &  T. Ota   (JUG-CP/M Sub Disk Editor)    *
  21. *                                *
  22. *****************************************************************
  23. */
  24.  
  25. /* Library functions for Software Tools */
  26. /****************************************************************************/
  27. /*                                        */
  28. /*    All functions do not use Lattice C V3.1J                */
  29. /*                                        */
  30. /****************************************************************************/
  31.  
  32. #include "stdio.h"
  33. #include "dos.h"
  34. #include "ctype.h"
  35. #include "tools.h"
  36.  
  37. #if LATTICE
  38. #else
  39. char *strcat(s, t)    /* do not use Lattice C Compiler V3.1 */
  40. char *s, *t;
  41. {
  42. char *p;
  43.  
  44.     p = s;
  45.     while(*s)
  46.         s++;
  47.     strcpy(s, t);
  48.     return p;
  49. }
  50.  
  51. int strlen(s)
  52. char *s;
  53. {
  54. char *p;
  55.     p = s;
  56.     while (*p) p++;
  57.     return(p - s);
  58. }
  59.  
  60. char *strcpy(s, t)
  61. char *s, *t;
  62. {
  63. char *p;
  64.     p = s;
  65.     while (*s++ = *t++)
  66.         ;
  67.     return p;
  68. }
  69.  
  70. int strcmp(s,t)
  71. char *s, *t;
  72. {
  73.     for ( ; *s == *t; s++, t++)
  74.         if (*s == '\0')
  75.             return 0;
  76.     return(*s - *t);
  77. }
  78. #endif
  79.  
  80. /* */
  81. /****************************************************************************/
  82. /*    This function not be user for 8086 System                */
  83. /****************************************************************************/
  84. /*
  85. poke(c,d)
  86. char *c, d;
  87. {
  88.     *c = d;
  89. }
  90. */
  91.  
  92. /****************************************************************************/
  93.  
  94.  
  95. /* Can't compile by [BDS-C compiler]
  96.  
  97. fillbuf(fp)
  98. register FILE *fp;
  99. {
  100.     static char smallbuf[_NFILE];    /* for unbuffering input */
  101.     char *calloc();
  102.  
  103.     if ((fp->_flag & _READ) == 0 || (fp->_flag & (_EOF | _ERR)) != 0)
  104.         return(EOF);
  105.     while (fp->_base == NULL)
  106.         if (fp->_flag & _UNBUF)
  107.             fp->_base = &smallbuf[fp->_fd];
  108.         else if ((fp->_base = calloc(_BUFSIZE, 1)) == NULL)
  109.             fp->_flag |= _UNBUF;
  110.         else
  111.             fp->_flag |= _BIGBUF;
  112.     fp->_ptr = fp->_base;
  113.     fp->_cnt = read(fp->_fd, fp->_ptr, fp->_flag & _UNBUF ? 1 : _BUFSIZE);
  114.     if (--fp->_cnt < 0) {
  115.         if (fp->_cnt == -1)
  116.             fp->_flag |= _EOF;
  117.         else
  118.             fp->_flag |= _ERR;
  119.         fp->_cnt = 0;
  120.         return(EOF);
  121.     }
  122.     return(*fp->_ptr++ & CMASK);
  123. }
  124.  
  125.  
  126. flushbuf(c,fp)
  127. register FILE *fp;
  128. register char c;
  129. {
  130.     extern FILE _iob[];
  131.     int n;
  132.  
  133.     if (fp->_base == NULL)
  134.         return(EOF);
  135.     if ((fp->_flag & _WRITE) == 0 || (fp->_flag & (_EOF|_ERR)) != 0)
  136.         return(EOF);
  137.     fp->_ptr = fp->_base;
  138.     n = ( fp->_flag & _UNBUF ) ? 1 : _BUFSIZE;
  139.     if (write(fp->_fd, fp->_ptr, n) != n) {
  140.         fp->_flag |= _ERR;        
  141.         fprintf(stderr, "write error %d\n", fp->_fd);
  142.         exit(1);
  143.         }
  144.     fp->_ptr = fp->_base;
  145.     *fp->_ptr++ = c;
  146.     fp->_cnt = n-1;
  147.     return(c);
  148. }
  149.  
  150.  
  151. FILE *fopen(name, mode)
  152. register char *name, *mode;
  153. {
  154.     register int fd;
  155.     register FILE *fp;
  156.  
  157.  
  158.     if (*mode != 'r' && *mode != 'w' /* && *mode != 'a' */) {
  159.         fprintf(stderr, "illegal mode %s opening %s\n", mode, name);
  160.         exit(1);
  161.         }
  162.     for (fp = _iob; fp < _iob + _NFILE; fp++)
  163.          if ((fp->_flag & (_READ | _WRITE)) == 0)
  164.             break;
  165.     if (fp >= _iob + _NFILE)
  166.         return(NULL);
  167.     if (*mode == 'w')
  168.         fd = open(name, WRITE);
  169.     else
  170.         fd = open(name, READ);
  171.     if (fd = -1)
  172.         return(NULL);
  173.  
  174.     fp->_fd = fd;
  175.     fp->_cnt = 0;
  176.     fp->_base = NULL;
  177.     fp->_flag &= ~(_READ | _WRITE);
  178.     fp->_flag |= (*mode == 'r') ? _READ : _WRITE;
  179.     return(fp);
  180. }
  181.  
  182.  
  183. char *calloc(n, size)
  184. unsigned n, size;
  185. {
  186.     char *p, *cp;
  187.     char *alloc();
  188.     int i, j;
  189.  
  190.  
  191.     for (i = 0; i < n; i++) {
  192.         if ((p = alloc(size) ) == NULL)
  193.             return(NULL);
  194.         cp = p;
  195.         for (j = 0; j < size; j++)
  196.             *cp++ = 0;
  197.         }
  198.     return((char *)p );
  199. }
  200. */
  201.