home *** CD-ROM | disk | FTP | other *** search
/ ftp.barnyard.co.uk / 2015.02.ftp.barnyard.co.uk.tar / ftp.barnyard.co.uk / cpm / commercial-software / programming / AZTEC302.ZIP / STDIO.ARC < prev    next >
Text File  |  1998-09-16  |  11KB  |  680 lines
  1. agetc.c
  2. /* Copyright (C) 1981,1982 by Manx Software Systems */
  3. #include "stdio.h"
  4.  
  5. agetc(ptr)
  6. register FILE *ptr;
  7. {
  8.     register int c;
  9.  
  10. top:
  11.     if ((c = getc(ptr)) != EOF) {
  12.         switch (c &= 127) {
  13.         case 0x1a:
  14.             ptr->_flags |= _EOF;
  15.             return EOF;
  16.         case '\r':
  17.         case 0:
  18.             goto top;
  19.         }
  20.     }
  21.     return c;
  22. }
  23.  
  24. aputc.c
  25. /* Copyright (C) 1981,1982 by Manx Software Systems */
  26. #include "stdio.h"
  27.  
  28. aputc(c,ptr)
  29. register int c; register FILE *ptr;
  30. {
  31.     if (c == '\n')
  32.         if (putc('\r',ptr) == EOF)
  33.             return EOF;
  34.     return putc(c,ptr);
  35. }
  36.  
  37. fdopen.c
  38. /* Copyright (C) 1984 by Manx Software Systems */
  39. #include "stdio.h"
  40.  
  41. FILE *
  42. fdopen(fd,mode)
  43. char *mode;
  44. {
  45.     register FILE *fp;
  46.     FILE *newstream();
  47.  
  48.     if ((fp = newstream()) == NULL)
  49.         return NULL;
  50.     fp->_unit = fd;
  51.     fp->_flags = _BUSY;
  52.     return fp;
  53. }
  54.  
  55. fgets.c
  56. /* Copyright (C) 1981,1982 by Manx Software Systems */
  57. #include "stdio.h"
  58.  
  59. char *fgets(s, n, fp)
  60. char *s; FILE *fp;
  61. {
  62.     register c;
  63.     register char *cp;
  64.  
  65.     cp = s;
  66.     while (--n > 0 && (c = agetc(fp)) != EOF) {
  67.         *cp++ = c;
  68.         if (c == '\n')
  69.             break;
  70.     }
  71.     *cp = 0;
  72.     if (c == EOF && cp == s)
  73.         return NULL;
  74.     return(s);
  75. }
  76. fopen.c
  77. /* Copyright (C) 1981,1982,1983,1984 by Manx Software Systems */
  78. #include "stdio.h"
  79. #include "fcntl.h"
  80. #include "errno.h"
  81.  
  82. extern int errno;
  83.  
  84. static struct modes {
  85.     char fmode[3];
  86.     int omode;
  87. } modes[] = {
  88.     "r",    O_RDONLY,
  89.     "r+",    O_RDWR,
  90.     "w",    (O_WRONLY|O_CREAT|O_TRUNC),
  91.     "w+",    (O_RDWR|O_CREAT|O_TRUNC),
  92.     "a",    (O_WRONLY|O_CREAT|O_APPEND),
  93.     "a+",    (O_RDWR|O_CREAT|O_APPEND),
  94.     "x",    (O_WRONLY|O_CREAT|O_EXCL),
  95.     "x+",    (O_RDWR|O_CREAT|O_EXCL),
  96.     "",        0,
  97. };
  98.  
  99. FILE *
  100. fopen(name,mode)
  101. char *name,*mode;
  102. {
  103.     register FILE *fp;
  104.     FILE *newstream(), *freopen();
  105.  
  106.     if ((fp = newstream()) == NULL)
  107.         return NULL;
  108.     return freopen(name, mode, fp);
  109. }
  110.  
  111. FILE *
  112. freopen(name, mode, fp)
  113. char *name,*mode; FILE *fp;
  114. {
  115.     register struct modes *mp;
  116.     register int fd;
  117.  
  118.     fclose(fp);
  119.  
  120.     for (mp = modes ; ; ++mp) {
  121.         if (*mp->fmode == 0) {
  122.             errno = EINVAL;
  123.             return NULL;
  124.         }
  125.         if (strcmp(mp->fmode, mode) == 0)
  126.             break;
  127.     }
  128.  
  129. /*
  130.     Don't try to optimize the next 3 lines.  Since _unit is a char,
  131.     assigning to it in the if statement will cause the -1 test to fail
  132.     on unsigned char machines.
  133. */
  134.     if ((fd = open(name, mp->omode)) == -1)
  135.         return (NULL);
  136.     fp->_unit = fd;
  137.     fp->_flags = _BUSY;
  138.     return fp;
  139. }
  140.  
  141. fprintf.c
  142. /* Copyright (C) 1981,1982 by Manx Software Systems */
  143. #include "stdio.h"
  144.  
  145. static FILE *Stream;
  146.  
  147. fprintf(stream,fmt,args)
  148. FILE *stream; char *fmt; unsigned args;
  149. {
  150.     int fpsub();
  151.  
  152.     Stream = stream;
  153.     return format(fpsub,fmt,&args);
  154. }
  155.  
  156. static
  157. fpsub(c)
  158. {
  159.     return aputc(c,Stream);
  160. }
  161. fputs.c
  162. /* Copyright (C) 1981,1982 by Manx Software Systems */
  163. #include "stdio.h"
  164.  
  165. fputs(s,fp)
  166. register char *s;
  167. FILE *fp;
  168. {
  169.     while ( *s )
  170.         if (aputc(*s++,fp) == EOF)
  171.             return(EOF);
  172.     return 0;
  173. }
  174. fread.c
  175. /* Copyright (C) 1981,1982 by Manx Software Systems */
  176. #include "stdio.h"
  177.  
  178. fread(buffer,size,number,stream)
  179. register char *buffer; unsigned size; int number;
  180. FILE *stream;
  181. {
  182.     int total;
  183.     register int c,i;
  184.  
  185.     for ( total = 0 ; total < number ; ++total ) {
  186.         for ( i = size ; i ; --i ) {
  187.             if ( (c = getc(stream)) == EOF )
  188.                 return total;
  189.             *buffer++ = c;
  190.         }
  191.     }
  192.     return total;
  193. }
  194. fscanf.c
  195. /* Copyright (C) 1982 by Manx Software Systems */
  196. #include "stdio.h"
  197.  
  198. static int scnlast;
  199. static FILE *scnfp;
  200.  
  201. fscanf(fp, fmt, args)
  202. FILE *fp; char *fmt; int *args;
  203. {
  204.     int gchar();
  205.  
  206.     scnfp = fp;
  207.     scnlast = 0;
  208.     return scanfmt(gchar, fmt, &args);
  209. }
  210.  
  211. static gchar(what)
  212. {
  213.     if (what == 0) {
  214.         if (feof(scnfp))
  215.             scnlast = EOF;
  216.         else
  217.             scnlast = agetc(scnfp);
  218.     } else
  219.         scnlast = ungetc(scnlast, scnfp);
  220.     return scnlast;
  221. }
  222.  
  223. fseek.c
  224. /* Copyright (c) 1981, 1982 by Manx Software Systems */
  225. #include "stdio.h"
  226.  
  227. fseek(fp,pos,mode)
  228. register FILE *fp;
  229. long pos;
  230. {
  231.     register int i;
  232.     long curpos, lseek();
  233.  
  234.     fp->_flags &= ~_EOF;
  235.     if (fp->_flags & _DIRTY) {
  236.         if (flsh_(fp,-1))
  237.             return EOF;
  238.     } else if (mode == 1 && fp->_bp)
  239.         pos -= fp->_bend - fp->_bp;
  240.     fp->_bp = fp->_bend = NULL;
  241.     if (lseek(fp->_unit, pos, mode) < 0)
  242.         return EOF;
  243.     return 0;
  244. }
  245.  
  246. long ftell(fp)
  247. register FILE *fp;
  248. {
  249.     long pos, lseek();
  250.  
  251.     pos = lseek(fp->_unit, 0L, 1);    /* find out where we are */
  252.     if (fp->_flags & _DIRTY)
  253.         pos += fp->_bp - fp->_buff;
  254.     else if (fp->_bp)
  255.         pos -= fp->_bend - fp->_bp;
  256.     return pos;
  257. }
  258. fwrite.c
  259. /* Copyright (C) 1981,1982 by Manx Software Systems */
  260. #include "stdio.h"
  261.  
  262. fwrite(buffer,size,number,stream)
  263. register char *buffer; unsigned size,number;
  264. FILE *stream;
  265. {
  266.     register unsigned i,max;
  267.  
  268.     max = size * number;
  269.     for ( i = 0 ; i < max ; ++i ) {
  270.         if ( putc(*buffer++,stream) == EOF )
  271.             return 0;
  272.     }
  273.     return number;
  274. }
  275.  
  276. getbuff.c
  277. /* Copyright (C) 1983 by Manx Software Systems */
  278. /* Copyright (C) 1981,1982 by Manx Software Systems */
  279. #include "stdio.h"
  280.  
  281. FILE Cbuffs[MAXSTREAM] = {
  282.     { 0,0,0, _BUSY,0,0,1 },
  283.     { 0,0,0, _BUSY,1,0,1 },
  284.     { 0,0,0, _BUSY,2,0,1 },
  285. };
  286.  
  287. FILE *
  288. newstream()
  289. {
  290.     register FILE *fp;
  291.  
  292.     fp = Cbuffs;
  293.     while (fp->_flags)
  294.         if (++fp >= &Cbuffs[MAXSTREAM])
  295.             return NULL;
  296.     return fp;
  297. }
  298.  
  299. getbuff(ptr)
  300. register FILE *ptr;
  301. {
  302.     char *buffer, *malloc();
  303.  
  304.     if (isatty(ptr->_unit)) {
  305. smlbuff:
  306.         ptr->_buflen = 1;
  307.         ptr->_buff = &ptr->_bytbuf;
  308.         return;
  309.     }
  310.     if ((buffer = malloc(BUFSIZ)) == NULL)
  311.         goto smlbuff;
  312.     ptr->_buflen = BUFSIZ;
  313.     ptr->_flags |= _ALLBUF;
  314.     ptr->_buff = buffer;
  315.     return;
  316. }
  317.  
  318. getc.c
  319. /* Copyright (C) 1982 by Manx Software Systems */
  320. #include "stdio.h"
  321.  
  322. getc(ptr)
  323. register FILE *ptr;
  324. {
  325.     register int len;
  326.  
  327.     if (ptr->_bp >= ptr->_bend) {
  328.         if (ptr->_flags&(_EOF|_IOERR))
  329.             return EOF;
  330.         ptr->_flags &= ~_DIRTY;
  331.         if (ptr->_buff == NULL)
  332.             getbuff(ptr);
  333.         if ((len = read(ptr->_unit,ptr->_buff,ptr->_buflen)) <= 0) {
  334.             ptr->_flags |= len==0 ? _EOF : _IOERR;
  335.             return EOF;
  336.         }
  337.         ptr->_bend = (ptr->_bp = ptr->_buff) + len;
  338.     }
  339.     return *ptr->_bp++ & 255;
  340. }
  341. getchar.c
  342. /* Copyright (C) 1981,1982 by Manx Software Systems */
  343. #include "stdio.h"
  344.  
  345. #undef getchar
  346.  
  347. getchar()
  348. {
  349.     return agetc(stdin);
  350. }
  351. gets.c
  352. /* Copyright (C) 1981,1982 by Manx Software Systems */
  353. #include "stdio.h"
  354.  
  355. #undef getchar
  356.  
  357. char *gets(line)
  358. char *line;
  359. {
  360.     register char *cp;
  361.     register int i;
  362.  
  363.     cp = line;
  364.     while ((i = getchar()) != EOF && i != '\n')
  365.         *cp++ = i;
  366.     *cp = 0;
  367.     if (i == EOF && cp == line)
  368.         return NULL;
  369.     return line;
  370. }
  371. getw.c
  372. /* Copyright (C) 1982 by Manx Software Systems */
  373. #include "stdio.h"
  374.  
  375. getw(stream)
  376. FILE *stream;
  377. {
  378.     register int x1,x2;
  379.  
  380.     if ((x1 = getc(stream)) == EOF || (x2 = getc(stream)) == EOF)
  381.         return EOF;
  382.     return (x2<<8) | x1;
  383. }
  384. printf.c
  385. /* Copyright (C) 1981,1982 by Manx Software Systems */
  386.  
  387. printf(fmt,args)
  388. char *fmt; unsigned args;
  389. {
  390.     extern int putchar();
  391.  
  392.     format(putchar,fmt,&args);
  393. }
  394. putc.c
  395. /* Copyright (C) 1981,1982,1983,1984 by Manx Software Systems */
  396. #include "stdio.h"
  397.  
  398. putc(c,ptr)
  399. int c; register FILE *ptr;
  400. {
  401.     if (ptr->_bp >= ptr->_bend)
  402.         return flsh_(ptr,c&0xff);
  403.     return (*ptr->_bp++ = c) & 0xff;
  404. }
  405.  
  406. static closall()        /* called by exit to close any open files */
  407. {
  408.     register FILE *fp;
  409.  
  410.     for ( fp = Cbuffs ; fp < Cbuffs+MAXSTREAM ; )
  411.         fclose(fp++);
  412. }
  413.  
  414. fclose(ptr)
  415. register FILE *ptr;
  416. {
  417.     register int err;
  418.  
  419.     err = 0;
  420.     if (!ptr)
  421.         return -1;
  422.     if ( ptr->_flags ) {
  423.         if (ptr->_flags&_DIRTY)    /* if modifed flush buffer */
  424.             err = flsh_(ptr,-1);
  425.         err |= close(ptr->_unit);
  426.         if (ptr->_flags&_ALLBUF)
  427.             free(ptr->_buff);
  428.         if (ptr->_flags&_TEMP) {    /* temp file, delete it */
  429.             unlink(ptr->_tmpname);
  430.             free(ptr->_tmpname);
  431.         }
  432.     }
  433.  
  434.     ptr->_buff = 
  435.     ptr->_bend =  /* nothing in buffer */
  436.     ptr->_bp = 0;
  437.     ptr->_flags = 0;
  438.     return err;
  439. }
  440.  
  441. flsh_(ptr,data)
  442. register FILE *ptr;
  443. {
  444.     register int size;
  445.     extern int (*cls_)();
  446.  
  447.     cls_ = closall;
  448.     if (ptr->_flags & _IOERR)
  449.         return EOF;
  450.     if (ptr->_flags & _DIRTY) {
  451.         size = ptr->_bp - ptr->_buff;
  452.         if (write(ptr->_unit, ptr->_buff, size) != size) {
  453. ioerr:
  454.             ptr->_flags |= _IOERR;
  455.             ptr->_bend = ptr->_bp = NULL;
  456.             return EOF;
  457.         }
  458.     }
  459.     if (data == -1) {
  460.         ptr->_flags &= ~_DIRTY;
  461.         ptr->_bend = ptr->_bp = NULL;
  462.         return 0;
  463.     }
  464.     if (ptr->_buff == NULL)
  465.         getbuff(ptr);
  466.     if (ptr->_buflen == 1) {    /* unbuffered I/O */
  467.         if (write(ptr->_unit, &data, 1) != 1)
  468.             goto ioerr;
  469.         return data;
  470.     }
  471.     ptr->_bp = ptr->_buff;
  472.     ptr->_bend = ptr->_buff + ptr->_buflen;
  473.     ptr->_flags |= _DIRTY;
  474.     return (*ptr->_bp++ = data) & 0xff;
  475. }
  476. putchar.c
  477. /* Copyright (C) 1981,1982 by Manx Software Systems */
  478. #include "stdio.h"
  479.  
  480. #undef putchar
  481.  
  482. putchar(c)
  483. {
  484.     return aputc(c,stdout);
  485. }
  486. puterr.c
  487. /* Copyright (C) 1981,1982 by Manx Software Systems */
  488. #include "stdio.h"
  489.  
  490. puterr(c)
  491. {
  492.     return aputc(c, stderr);
  493. }
  494. puts.c
  495. /* Copyright (C) 1981,1982 by Manx Software Systems */
  496.  
  497. puts(str)
  498. register char *str;
  499. {
  500.     while (*str)
  501.         if (putchar(*str++) == -1)
  502.             return -1;
  503.     return putchar('\n');
  504. }
  505. putw.c
  506. /* Copyright (C) 1981,1982 by Manx Software Systems */
  507. #include "stdio.h"
  508.  
  509. putw(w,stream)
  510. register unsigned w;
  511. FILE *stream;
  512. {
  513.     if ( putc(w,stream) < 0 ) 
  514.         return EOF;
  515.     else if ( putc((w>>8),stream) < 0 )
  516.         return EOF;
  517.     return w;
  518. }
  519. scanf.c
  520. /* Copyright (C) 1982 by Manx Software Systems */
  521. #include "stdio.h"
  522.  
  523. static int scnlast;
  524.  
  525. scanf(fmt, args)
  526. char *fmt; int *args;
  527. {
  528.     int gchar();
  529.  
  530.     scnlast = 0;
  531.     return scanfmt(gchar, fmt, &args);
  532. }
  533.  
  534. static gchar(what)
  535. {
  536.     if (what == 0) {
  537.         if (feof(stdin))
  538.             scnlast = EOF;
  539.         else
  540.             scnlast = agetc(stdin);
  541.     } else
  542.         scnlast = ungetc(scnlast, stdin);
  543.     return scnlast;
  544. }
  545.  
  546. setbuf.c
  547. /* Copyright (C) 1981,1982 by Manx Software Systems and Thomas Fenwick */
  548. #include "stdio.h"
  549.  
  550. setbuf(stream, buffer)
  551. register FILE *stream; char *buffer;
  552. {
  553.     if (stream->_buff)
  554.         return;
  555.     if (buffer) {
  556.         stream->_buff = buffer;
  557.         stream->_buflen = BUFSIZ;
  558.     } else {
  559.         stream->_buff = &stream->_bytbuf;
  560.         stream->_buflen = 1;
  561.     }
  562. }
  563.  
  564. tmpfile.c
  565. #include <stdio.h>
  566.  
  567. /* returns a pointer for a temp file which is automatically deleted
  568.     when the program exits; the file is opened for update */
  569.  
  570. FILE * 
  571. tmpfile ()
  572. {
  573.     register char *cp;
  574.     register FILE *fp;
  575.     char *tmpnam(), *malloc();
  576.  
  577.     cp = tmpnam (NULL);
  578.     if ( (fp = fopen (cp, "w+")) == NULL )  
  579.         perror (cp);
  580.     else {
  581.         if ((fp->_tmpname = malloc(strlen(cp)+1)) == NULL) {
  582.             fclose(fp);
  583.             unlink(cp);
  584.             return NULL;
  585.         }
  586.         fp->_flags |= _TEMP;
  587.     }
  588.     return fp;
  589. }
  590.  
  591. tmpnam.c
  592. #include <stdio.h>
  593.  
  594. static char work[] = "AAAAA";
  595.  
  596. char *
  597. tmpnam(s)
  598. char *s;
  599. {
  600.     static char tmpbuf[L_tmpnam];
  601.     register char *cp;
  602.  
  603.     if (s == NULL)
  604.         s = tmpbuf;
  605.     for (;;) {
  606.         strcpy(s,P_tmpdir);
  607.         strcat(s,work);
  608.         strcat(s,"XXX.XXX");
  609.         for (cp = work ; *cp ; ++cp)
  610.             if (*cp == 'Z')
  611.                 *cp = 'A';
  612.             else {
  613.                 ++*cp;
  614.                 break;
  615.             }
  616.         mktemp(s);
  617.     }
  618.     return s;
  619. }
  620. mktemp.c
  621. char *
  622. mktemp(template)
  623. char *template;
  624. {
  625.     register char *cp;
  626.     register unsigned val;
  627.     extern unsigned _dsval;
  628.  
  629.     cp = template;
  630.     cp += strlen(cp);
  631.     for (val = _dsval ; ; )
  632.         if (*--cp == 'X') {
  633.             *cp = val%10 + '0';
  634.             val /= 10;
  635.         } else if (*cp != '.')
  636.             break;
  637.  
  638.     if (*++cp != 0) {
  639.         *cp = 'A';
  640.         while (access(template, 0) == 0) {
  641.             if (*cp == 'Z') {
  642.                 *template = 0;
  643.                 break;
  644.             }
  645.             ++*cp;
  646.         }
  647.     } else {
  648.         if (access(template, 0) == 0)
  649.             *template = 0;
  650.     }
  651.     return template;
  652. }
  653. ungetc.c
  654. /* Copyright (c) 1981, 1982 by Manx Software Systems */
  655. #include "stdio.h"
  656.  
  657. ungetc(c,ptr)
  658. int c; register FILE *ptr;
  659. {
  660.     if (c == EOF || ptr->_bp <= ptr->_buff)
  661.         return EOF;
  662.     *--ptr->_bp = c;
  663.     return c;
  664. }
  665.  
  666. perror.c
  667. #include <stdio.h>
  668. #include <errno.h>
  669.  
  670. perror (s)
  671. char *s;
  672. {
  673.     if (errno < 0 || errno > sys_nerr)
  674.         return -1;
  675.     if (s)
  676.         fprintf (stderr, "%s: ", s);
  677.     fprintf (stderr, "%s\n", sys_errlist[errno]);
  678.     return 0;
  679. }
  680.