doc@pucc-j.UUCP (09/02/86)
Reply-To: dillon%cory.Berkeley.EDU@BERKELEY.EDU (Matt Dillon) This is the library. Each file below must be compiled or assembled, then all the object files JOIN'd together and called MY.LIB (or whatever you want). NOTE: There are too many files to be able to JOIN in one sweep.. you will have to join the files in groups, then join the groups together. why? Some idiot decided the command line couldn't be larger than 255 bytes due to BCPL. #! /bin/sh # This is a shell archive, meaning: # 1. Remove everything above the #! /bin/sh line. # 2. Save the resulting text in a file. # 3. Execute the file with /bin/sh (not csh) to create: # atoi.c # bmov.asm # bset.asm # bzero.asm # check32.c # closelibs.c # free.c # free_memory.c # gets.c # io.c # malloc.c # openlibs.c # puts.c # strcat.asm # strcmp.c # strcpy.asm # strlen.asm # strncat.c # strncmp.c # strncpy.c # wildcmp.c # xalloc.h # xattach.c # xclose.c # xdetach.c # xfilbuf.c # xflush.c # xgetc.c # xgets.c # xmisc.h # xopen.c # xputc.c # xputs.c # xread.c # xseek.c # xsetbuf.c # xstdio.h # xtell.c # xwrite.c # This archive created: Wed Aug 27 19:35:37 1986 export PATH; PATH=/bin:/usr/bin:$PATH echo shar: "extracting 'atoi.c'" '(293 characters)' if test -f 'atoi.c' then echo shar: "will not over-write existing file 'atoi.c'" else cat << \!Funky!Stuff! > 'atoi.c' atoi(str) register char *str; { register long i = 0; register long neg = 0; while (*str == ' ') ++str; if (*str == '-') { ++str; neg = 1; } while (*str >= '0' && *str <= '9') i = (i << 1) + (i << 3) + *str++ - '0'; return ((int)((neg)?-i:i)); } !Funky!Stuff! fi # end of overwriting check echo shar: "extracting 'bmov.asm'" '(890 characters)' if test -f 'bmov.asm' then echo shar: "will not over-write existing file 'bmov.asm'" else cat << \!Funky!Stuff! > 'bmov.asm' ;BMOV.ASM ; written in assembly for speed. Could have written one to write a ; long at a time, but would be lengthy. xdef _bmov _bmov move.l 4(A7),A0 ;source move.l 8(A7),A1 ;destination move.l 12(A7),D0 ;#bytes beq lend ;no bytes to copy cmp.l A0,A1 ;A1 ? A0 beq lend ble destlessrc ;dest > src, backwards copy required add.l D0,A0 add.l D0,A1 loop1 move.b -(A0),-(A1) subq.l #1,D0 bne loop1 rts destlessrc ;dest < src, forwards copy required loop2 move.b (A0)+,(A1)+ subq.l #1,D0 bne loop2 lend rts !Funky!Stuff! fi # end of overwriting check echo shar: "extracting 'bset.asm'" '(438 characters)' if test -f 'bset.asm' then echo shar: "will not over-write existing file 'bset.asm'" else cat << \!Funky!Stuff! > 'bset.asm' ;BSET.ASM ; written in assembly for speed. Could have written one to write a ; long at a time, but would be lengthy. xdef _bset _bset move.l 4(A7),A0 ;pointer move.l 12(A7),D1 ;what to set move.l 8(A7),D0 ;# bytes beq lend ;zero 0 bytes loop2 move.b D1,(A0)+ subq.l #1,D0 bne loop2 lend rts !Funky!Stuff! fi # end of overwriting check echo shar: "extracting 'bzero.asm'" '(393 characters)' if test -f 'bzero.asm' then echo shar: "will not over-write existing file 'bzero.asm'" else cat << \!Funky!Stuff! > 'bzero.asm' ;BZERO.ASM ; written in assembly for speed. Could have written one to write a ; long at a time, but would be lengthy. xdef _bzero _bzero move.l 4(A7),A0 ;pointer move.l 8(A7),D0 ;# bytes beq lend ;zero 0 bytes loop2 clr.b (A0)+ subq.l #1,D0 bne loop2 lend rts !Funky!Stuff! fi # end of overwriting check echo shar: "extracting 'check32.c'" '(205 characters)' if test -f 'check32.c' then echo shar: "will not over-write existing file 'check32.c'" else cat << \!Funky!Stuff! > 'check32.c' check32() { unsigned int i; i = 0; --i; if (i != 0xFFFFFFFF) { puts ("MUST BE COMPILED WITH 32-bit INT's!"); exit (50000); /* no joke */ } } !Funky!Stuff! fi # end of overwriting check echo shar: "extracting 'closelibs.c'" '(254 characters)' if test -f 'closelibs.c' then echo shar: "will not over-write existing file 'closelibs.c'" else cat << \!Funky!Stuff! > 'closelibs.c' #include "xmisc.h" extern long GfxBase; closelibs(mask) unsigned short mask; { register long *base = &GfxBase; for (;mask; mask >>= 1, ++base) { if ((mask & 1) && *base) { CloseLibrary(*base); *base = 0; } } } !Funky!Stuff! fi # end of overwriting check echo shar: "extracting 'free.c'" '(231 characters)' if test -f 'free.c' then echo shar: "will not over-write existing file 'free.c'" else cat << \!Funky!Stuff! > 'free.c' #include "xalloc.h" free(ptr) char *ptr; { register ALLC *a; if (ptr) { a = (ALLC *)(ptr - HSIZE); *a->prev = a->next; if (a->next) a->next->prev = a->prev; FreeMem (a, a->bytes); } } !Funky!Stuff! fi # end of overwriting check echo shar: "extracting 'free_memory.c'" '(211 characters)' if test -f 'free_memory.c' then echo shar: "will not over-write existing file 'free_memory.c'" else cat << \!Funky!Stuff! > 'free_memory.c' #include "xalloc.h" ALLC *Allc_base; free_memory() { register ALLC *next; while(Allc_base) { next = Allc_base->next; FreeMem (Allc_base, Allc_base->bytes); Allc_base = next; } } !Funky!Stuff! fi # end of overwriting check echo shar: "extracting 'gets.c'" '(259 characters)' if test -f 'gets.c' then echo shar: "will not over-write existing file 'gets.c'" else cat << \!Funky!Stuff! > 'gets.c' char * gets(buf) register char *buf; { register int i = 0; register long infh = Input(); while (Read(infh, buf+i, 1L)) { ++i; if (buf[i-1] == 13 || buf[i-1] == 10) break; } return ((i) ? ((buf[i-1] = '\0'), buf) : 0); } !Funky!Stuff! fi # end of overwriting check echo shar: "extracting 'io.c'" '(5475 characters)' if test -f 'io.c' then echo shar: "will not over-write existing file 'io.c'" else cat << \!Funky!Stuff! > 'io.c' /* * IO.C (must be compiled 32-bit ints) * * I/O support for devices. * io_open() - Generalized OpenDevice() which does everything for * you. * * io_close() - Generalized CloseDevice(). Should only be used * with io_open()'d devices. * * long * io_open(device_name, unit, flags, &rreq, &wwreq, req_size, spec1, spec2) * * char *device_name -the device name (ex: "serial.device") * int unit -unit # * int flags -OpenDevice flags * struct IOxxxxxx *rreq -address of pointer (will be filled in) * struct IOxxxxxx *wreq -address of pointer (will be filled in) * int req_size -size of above structures * long spec1,spec2 -special arguments for preinitialization * (depends on the device your openning) * * EXAMPLE: * ---------------------- * typedef struct IOExtSer SIO; * * #define SERFLAGS (SERF_XDISABLED | SERF_SHARED) * SIO *srr, *swr; * long mask; * * mask = io_open("serial.device",0,0,&srr,&swr,sizeof(SIO),SERFLAGS,0); * ... * io_close(srr, swr, sizeof(SIO)); * * ---------------------- * * The structure for rreq and wreq depend on the device you are openning. * You must be sure to specify the correct size. * * Some devices, such as the serial device, require certain fields inside * their IO structures to be initialized before the OpenDevice(). Since * io_open() Allocates these structures for you, these extra parameters * must be passed to io_open() via SPEC1 and SPEC2 in the arguments list * as outlined below: * SPEC1 SPEC2 * console.device window pointer window structure size * parallel.device parallel flags 0 * serial.device serial flags 0 * **ALL OTHERS** 0 0 * * note on audio device: You must ADCMD_ALLOCATE and ADCMD_FREE * manually. * * You also pass io_open() the address of two pointers (e.g. **x). These * will be filled in by io_open() to result in a READ and WRITE request * structure, each with it's own reply port, and with it's io_Command * fields initialized to CMD_READ and CMD_WRITE, respectively. You may * specify a NULL for the **WRITE request structure instead of a * **wreq. This will result in only a READ request structure being * set up. * * You do not have to use the structures for only CMD_READ and CMD_WRITE, * of course, you can use them for any io command. * * a signal MASK with one bit set is returned. This is the signal bit * for the read-request structure (if rreq was NULL, then it is the * signal for the write-request structure). an example mask: * 00000000001000000000000000000000 in binary. * * 0 is returned if the open fails. * * * io_close(rreq, wreq, size) * * specify 0 for the wreq if it doesn't exist (e.g. you passed a * NULL for it in the io_open() ). */ #include <exec/types.h> #include <exec/ports.h> #include <exec/io.h> #include <exec/memory.h> #include <devices/serial.h> #include <devices/parallel.h> #define FAIL(ifzero) if (!ifzero) goto fail typedef struct IORequest IOR; typedef struct IOStdReq STD; typedef struct MsgPort PORT; extern char *AllocMem(); extern PORT *CreatePort(); long io_open(name, unit, od_arg, prr, pww, size, special1, special2) char *name; IOR **prr, **pww; long special1, special2; { PORT *rport, *wport; IOR *rreq, *wreq; int ret; rreq = wreq = NULL; rport = wport = NULL; rport = CreatePort(NULL,0); FAIL(rport); rreq = (IOR *)AllocMem(size, MEMF_PUBLIC|MEMF_CLEAR); FAIL(rreq); if (pww) { wport = CreatePort(NULL,0); FAIL(wport); wreq = (IOR *)AllocMem(size, MEMF_PUBLIC|MEMF_CLEAR); FAIL(wreq); } if (special1) { if (scmp(name, SERIALNAME)) ((struct IOExtSer *)rreq)->io_SerFlags = special1; if (scmp(name, PARALLELNAME)) ((struct IOExtPar *)rreq)->io_ParFlags = special1; if (scmp(name, "console.device")) { ((STD *)rreq)->io_Data = (APTR)special1; ((STD *)rreq)->io_Length= special2; } } rreq->io_Message.mn_ReplyPort = rport; ret = OpenDevice(name, unit, rreq, od_arg); FAIL(!ret); if (pww) { *wreq = *rreq; /* structure assignment */ wreq->io_Message.mn_ReplyPort = wport; wreq->io_Command = CMD_WRITE; *pww = wreq; } rreq->io_Command = CMD_READ; *prr = rreq; return (1 << rport->mp_SigBit); /* return read sig bit */ fail: if (rport) DeletePort(rport); if (wport) DeletePort(wport); if (rreq) FreeMem(rreq, size); if (wreq) FreeMem(wreq, size); return (0); } io_close(rreq, wreq, size) IOR *rreq, *wreq; { if (rreq) { CloseDevice(rreq); if (rreq->io_Message.mn_ReplyPort) DeletePort(rreq->io_Message.mn_ReplyPort); FreeMem (rreq, size); } if (wreq) { if (wreq->io_Message.mn_ReplyPort) DeletePort(wreq->io_Message.mn_ReplyPort); FreeMem (wreq, size); } } scmp(s1, s2) register char *s1, *s2; { while (*s1 == *s2) { if ((*s1 | *s2) == 0) return (1); ++s1; ++s2; } return (0); } !Funky!Stuff! fi # end of overwriting check echo shar: "extracting 'malloc.c'" '(283 characters)' if test -f 'malloc.c' then echo shar: "will not over-write existing file 'malloc.c'" else cat << \!Funky!Stuff! > 'malloc.c' #include "xalloc.h" char * malloc(bytes) { register ALLC *a; a = (ALLC *)AllocMem(bytes + HSIZE, 0); if (Allc_base) Allc_base->prev = &a->next; a->next = Allc_base; a->prev = &Allc_base; a->bytes = bytes + HSIZE; Allc_base = a; return (a->buf); } !Funky!Stuff! fi # end of overwriting check echo shar: "extracting 'openlibs.c'" '(1026 characters)' if test -f 'openlibs.c' then echo shar: "will not over-write existing file 'openlibs.c'" else cat << \!Funky!Stuff! > 'openlibs.c' #include "xmisc.h" long GfxBase; long IntuitionBase; long ExpansionBase; long DiskfontBase; long TranslatorBase; long IconBase; long MathBase; long MathTransBase; long MathIeeeDoubBasBase; long MathIeeeSingBasBase; long LayersBase; long ClistBase; long PotgoBase; long TimerBase; long xfiller15; long xfiller16; openlibs(mask) unsigned short mask; { static char *strarray[] = { "graphics", "intuition", "expansion", "diskfont", "translator", "icon", "math", "mathtrans", "mathieeedoubbas", "mathieeesingbas", "layers", "clist", "potgo", "timer", "x15", "x16" }; register long *base = &GfxBase; register char **str = strarray; char buf[64]; for (; mask; mask >>= 1, ++base, ++str) { if (mask & 1) { strcpy(buf, *str); strcat(buf, ".library"); if ((*base = OpenLibrary(buf, 0)) == 0) goto fail; } } return (1); fail: closelibs(-1); return (0); } !Funky!Stuff! fi # end of overwriting check echo shar: "extracting 'puts.c'" '(187 characters)' if test -f 'puts.c' then echo shar: "will not over-write existing file 'puts.c'" else cat << \!Funky!Stuff! > 'puts.c' puts(buf) char *buf; { register long fh = Output(); register int len = strlen(buf); if (Write(fh, buf, len) == len && Write(fh, "\n", 1)) return (1); return (0); } !Funky!Stuff! fi # end of overwriting check echo shar: "extracting 'strcat.asm'" '(451 characters)' if test -f 'strcat.asm' then echo shar: "will not over-write existing file 'strcat.asm'" else cat << \!Funky!Stuff! > 'strcat.asm' xdef _strcat _strcat move.l 4(A7),A0 ; dest move.l 8(A7),A1 ; src move.l A0,D0 ; return the destination loop1 tst.b (A0)+ ; skip start of string bne loop1 subq.l #1,A0 ; dec. so now points at the 0 loop2 move.b (A1)+,(A0)+ ; src to dest bne loop2 ; until zero rts !Funky!Stuff! fi # end of overwriting check echo shar: "extracting 'strcmp.c'" '(243 characters)' if test -f 'strcmp.c' then echo shar: "will not over-write existing file 'strcmp.c'" else cat << \!Funky!Stuff! > 'strcmp.c' strcmp(s1, s2) register unsigned char *s1, *s2; { while (*s1 && *s2) { x: if (*s1 < *s2) return (-1); if (*s1 > *s2) return (1); ++s1; ++s2; } if (*s1 == *s2) return (0); goto x; } !Funky!Stuff! fi # end of overwriting check echo shar: "extracting 'strcpy.asm'" '(269 characters)' if test -f 'strcpy.asm' then echo shar: "will not over-write existing file 'strcpy.asm'" else cat << \!Funky!Stuff! > 'strcpy.asm' xdef _strcpy _strcpy move.l 4(A7),A0 ; dest move.l 8(A7),A1 ; src loop move.b (A1)+,(A0)+ ; src to dest bne loop ; until zero move.l 4(A7),D0 rts !Funky!Stuff! fi # end of overwriting check echo shar: "extracting 'strlen.asm'" '(260 characters)' if test -f 'strlen.asm' then echo shar: "will not over-write existing file 'strlen.asm'" else cat << \!Funky!Stuff! > 'strlen.asm' xdef _strlen _strlen move.l 4(A7),A0 ;pointer loop tst.b (A0)+ ;loop until 0 bne loop sub.l 4(A7),A0 sub.l #1,A0 move.l A0,D0 rts !Funky!Stuff! fi # end of overwriting check echo shar: "extracting 'strncat.c'" '(224 characters)' if test -f 'strncat.c' then echo shar: "will not over-write existing file 'strncat.c'" else cat << \!Funky!Stuff! > 'strncat.c' char * strncat(dest, src, n) register char *dest, *src; register int n; { register char *orig = dest; while (*dest) ++dest; while (*src && n--) *dest++ = *src++; *dest++ = '\0'; return (orig); } !Funky!Stuff! fi # end of overwriting check echo shar: "extracting 'strncmp.c'" '(291 characters)' if test -f 'strncmp.c' then echo shar: "will not over-write existing file 'strncmp.c'" else cat << \!Funky!Stuff! > 'strncmp.c' strncmp(s1, s2, n) register unsigned char *s1, *s2; register int n; { while (n && *s1 && *s2) { --n; x: if (*s1 < *s2) return (-1); if (*s1 > *s2) return (1); ++s1; ++s2; } if (n == 0 || (*s1 == *s2)) return (0); goto x; } !Funky!Stuff! fi # end of overwriting check echo shar: "extracting 'strncpy.c'" '(194 characters)' if test -f 'strncpy.c' then echo shar: "will not over-write existing file 'strncpy.c'" else cat << \!Funky!Stuff! > 'strncpy.c' char * strncpy(dest, src, n) register char *dest, *src; register int n; { register char *orig = dest; while (*src && n--) *dest++ = *src++; *dest++ = '\0'; return (orig); } !Funky!Stuff! fi # end of overwriting check echo shar: "extracting 'wildcmp.c'" '(1051 characters)' if test -f 'wildcmp.c' then echo shar: "will not over-write existing file 'wildcmp.c'" else cat << \!Funky!Stuff! > 'wildcmp.c' /* * Compare a wild card name with a normal name */ #define MAXB 8 wildcmp(wild, name) char *wild, *name; { register char *w = wild; register char *n = name; char *back[MAXB][2]; int bi = 0; while (*n || *w) { switch (*w) { case '*': if (bi == MAXB) { puts ("Too many levels of '*'"); return (0); } back[bi][0] = w; back[bi][1] = n; ++bi; ++w; continue; goback: --bi; while (bi >= 0 && *back[bi][1] == '\0') --bi; if (bi < 0) return (0); w = back[bi][0] + 1; n = ++back[bi][1]; ++bi; continue; case '?': if (!*n) { if (bi) goto goback; return (0); } break; default: if (*n != *w) { if (bi) goto goback; return (0); } break; } if (*n) ++n; if (*w) ++w; } return (1); } !Funky!Stuff! fi # end of overwriting check echo shar: "extracting 'xalloc.h'" '(206 characters)' if test -f 'xalloc.h' then echo shar: "will not over-write existing file 'xalloc.h'" else cat << \!Funky!Stuff! > 'xalloc.h' typedef struct _ALLC { struct _ALLC *next; struct _ALLC **prev; long bytes; char buf[4]; } ALLC; #define HSIZE 12 extern ALLC *Allc_base; extern char *malloc(), *calloc(); !Funky!Stuff! fi # end of overwriting check echo shar: "extracting 'xattach.c'" '(411 characters)' if test -f 'xattach.c' then echo shar: "will not over-write existing file 'xattach.c'" else cat << \!Funky!Stuff! > 'xattach.c' #include "xstdio.h" FILE * xattach(fh, size) long fh, size; { register FILE *fi; if (size == 0) size = 1; fi = (FILE *)AllocMem((long)sizeof(FILE), MEMF_CLEAR); if (fi) { if (fi->buf = (unsigned char *)AllocMem(fi->max = size, 0)) { fi->pos = fi->vpos = Seek(fi->fh = fh, 0L, 0); return (fi); } FreeMem(fi, (long)sizeof(FILE)); } return (NULL); } !Funky!Stuff! fi # end of overwriting check echo shar: "extracting 'xclose.c'" '(186 characters)' if test -f 'xclose.c' then echo shar: "will not over-write existing file 'xclose.c'" else cat << \!Funky!Stuff! > 'xclose.c' #include "xstdio.h" xclose(fi) register FILE *fi; { if (fi) { xflush(fi); Close(fi->fh); FreeMem(fi->buf, fi->max); FreeMem(fi, (long)sizeof(FILE)); } } !Funky!Stuff! fi # end of overwriting check echo shar: "extracting 'xdetach.c'" '(256 characters)' if test -f 'xdetach.c' then echo shar: "will not over-write existing file 'xdetach.c'" else cat << \!Funky!Stuff! > 'xdetach.c' #include "xstdio.h" long xdetach(fi) register FILE *fi; { register long fh; xflush(fi); Seek(fh = fi->fh, fi->vpos - fi->pos, 0); /* seek to virtual pos */ FreeMem(fi->buf, fi->max); FreeMem(fi, (long)sizeof(FILE)); return (fh); } !Funky!Stuff! fi # end of overwriting check echo shar: "extracting 'xfilbuf.c'" '(374 characters)' if test -f 'xfilbuf.c' then echo shar: "will not over-write existing file 'xfilbuf.c'" else cat << \!Funky!Stuff! > 'xfilbuf.c' #include "xstdio.h" xfilbuf(fi) register FILE *fi; { register long n; register long fh = fi->fh; xflush(fi); if (fi->vpos != fi->pos) Seek(fh, fi->vpos - fi->pos, 0); n = Read(fh, fi->buf, fi->max); if (n <= 0) { fi->pos = fi->vpos; Seek(fh, fi->pos, -1); return (0); } fi->pos = fi->vpos + (fi->i2 = n); return(1); } !Funky!Stuff! fi # end of overwriting check echo shar: "extracting 'xflush.c'" '(569 characters)' if test -f 'xflush.c' then echo shar: "will not over-write existing file 'xflush.c'" else cat << \!Funky!Stuff! > 'xflush.c' /* * NOTE: buffer guarenteed to be empty on return, period. */ #include "xstdio.h" xflush(fi) register FILE *fi; { register long vstart; register int i; register int r = 1; if (fi->stat & FIS_MODIFIED) { vstart = fi->vpos - fi->i1; if (fi->pos != vstart) Seek (fi->fh, vstart - fi->pos, 0); i = Write(fi->fh, fi->buf, fi->i1); if (i != fi->i1) { r = 0; if (i < 0) i = 0; } fi->pos = vstart + i; fi->stat &= ~FIS_MODIFIED; } fi->i1 = fi->i2 = 0; return (r); } !Funky!Stuff! fi # end of overwriting check echo shar: "extracting 'xgetc.c'" '(102 characters)' if test -f 'xgetc.c' then echo shar: "will not over-write existing file 'xgetc.c'" else cat << \!Funky!Stuff! > 'xgetc.c' xgetc(fi) { unsigned char c; if (xread(fi, &c, 1)) return ((int)c); return (-1); } !Funky!Stuff! fi # end of overwriting check echo shar: "extracting 'xgets.c'" '(433 characters)' if test -f 'xgets.c' then echo shar: "will not over-write existing file 'xgets.c'" else cat << \!Funky!Stuff! > 'xgets.c' #include "xstdio.h" xgets(fi, buf, max) register FILE *fi; register char *buf; register long max; { register int i; --max; for (i = 0; i < max; ++i) { if (fi->i1 == fi->i2) { if (xfilbuf(fi) == 0) { buf[0] = '\0'; return(0); } } buf[i] = fi->buf[fi->i1++]; ++fi->vpos; if (buf[i] == '\n') break; } buf[i] = '\0'; return(i+1); } !Funky!Stuff! fi # end of overwriting check echo shar: "extracting 'xmisc.h'" '(507 characters)' if test -f 'xmisc.h' then echo shar: "will not over-write existing file 'xmisc.h'" else cat << \!Funky!Stuff! > 'xmisc.h' #define GRAPHICS_LIB 0x0001L #define INTUITION_LIB 0x0002L #define EXPANSION_LIB 0x0004L #define DISKFONT_LIB 0x0008L #define TRANSLATOR_LIB 0x0010L #define ICON_LIB 0x0020L #define MATH_LIB 0x0040L #define MATHTRANS_LIB 0x0080L #define MATHIEEEDOUBBAS_LIB 0x0100L #define MATHIEEESINGBAS_LIB 0x0200L #define LAYERS_LIB 0x0400L #define CLIST_LIB 0x0800L #define POTGO_LIB 0x1000L #define TIMER_LIB 0x2000L !Funky!Stuff! fi # end of overwriting check echo shar: "extracting 'xopen.c'" '(1028 characters)' if test -f 'xopen.c' then echo shar: "will not over-write existing file 'xopen.c'" else cat << \!Funky!Stuff! > 'xopen.c' #include "xstdio.h" FILE * xopen(name, str, size) register char *name, *str; long size; { register FILE *fi; register int mode; register long fh = 0; if (size < 1) size = 1; fi = (FILE *)AllocMem((long)sizeof(FILE), MEMF_CLEAR); if (fi) { if (str[0] == 'r') { mode = MODE_READONLY; if (str[1] == '+') mode = MODE_READONLY; /* actually rw */ } if (str[0] == 'w') { mode = MODE_NEWFILE; if (str[1] == '+') { if (fh = Open(name, MODE_OLDFILE)) Seek(fh, 0L, 1); } } if (!fh) fh = Open(name, mode); if (fh) { fi->fh = fh; fi->max = size; if (fi->buf = (unsigned char *)AllocMem(size, 0)) { fi->pos = fi->vpos = Seek(fh, 0L, 0); } else { Close(fh); goto fail; } } else { fail: FreeMem(fi, (long)sizeof(FILE)); return(NULL); } } return(fi); } !Funky!Stuff! fi # end of overwriting check echo shar: "extracting 'xputc.c'" '(63 characters)' if test -f 'xputc.c' then echo shar: "will not over-write existing file 'xputc.c'" else cat << \!Funky!Stuff! > 'xputc.c' xputc(fi, c) { char c; return (xwrite(fi, &c, 1)); } !Funky!Stuff! fi # end of overwriting check echo shar: "extracting 'xputs.c'" '(164 characters)' if test -f 'xputs.c' then echo shar: "will not over-write existing file 'xputs.c'" else cat << \!Funky!Stuff! > 'xputs.c' #include "xstdio.h" xputs(fi, buf) FILE *fi; char *buf; { if (xwrite(fi, buf, (long)strlen(buf)) && xwrite(fi, "\n", 1L)) return(1); return(0); } !Funky!Stuff! fi # end of overwriting check echo shar: "extracting 'xread.c'" '(482 characters)' if test -f 'xread.c' then echo shar: "will not over-write existing file 'xread.c'" else cat << \!Funky!Stuff! > 'xread.c' #include "xstdio.h" long xread(fi, buf, n) register FILE *fi; register char *buf; register long n; { register long r, rr = 0; for (;;) { r = fi->i2 - fi->i1; if (r > n) r = n; if (r) { bmov(fi->buf + fi->i1, buf, r); buf += r; n -= r; rr += r; fi->vpos += r; fi->i1 += r; } if (n) { if (xfilbuf(fi)) continue; } break; } return(rr); } !Funky!Stuff! fi # end of overwriting check echo shar: "extracting 'xseek.c'" '(779 characters)' if test -f 'xseek.c' then echo shar: "will not over-write existing file 'xseek.c'" else cat << \!Funky!Stuff! > 'xseek.c' #include "xstdio.h" long xseek(fi, offset, how) register FILE *fi; register long offset, how; { register long abs, i1; if (how < 1) { /* seek beg, seek rel */ abs = offset; /* get absolute offset */ if (!how) abs += fi->vpos; i1 = fi->i1 + abs - fi->vpos; /* figure new index */ if (i1 >= 0 && i1 <= fi->i2) { /* still in buffer? */ fi->i1 = i1; fi->vpos = abs; return (abs); } xflush(fi); Seek(fi->fh, abs, -1); } else { xflush(fi); /* flush buffer and */ Seek(fi->fh, offset, 2); /* seek to new position */ } fi->pos = fi->vpos = Seek(fi->fh, 0L, 0); return (fi->vpos); } !Funky!Stuff! fi # end of overwriting check echo shar: "extracting 'xsetbuf.c'" '(318 characters)' if test -f 'xsetbuf.c' then echo shar: "will not over-write existing file 'xsetbuf.c'" else cat << \!Funky!Stuff! > 'xsetbuf.c' #include "xstdio.h" xsetbuf(fi, size) register FILE *fi; register long size; { register char *newbuf; if (!size) size = 1; xflush(fi); if (newbuf = (char *)AllocMem(size, 0)) { FreeMem(fi->buf, fi->max); fi->buf = newbuf; fi->max = size; return (1); } return (0); } !Funky!Stuff! fi # end of overwriting check echo shar: "extracting 'xstdio.h'" '(683 characters)' if test -f 'xstdio.h' then echo shar: "will not over-write existing file 'xstdio.h'" else cat << \!Funky!Stuff! > 'xstdio.h' typedef struct { long fh; /* file handle */ long i1, i2, max; /* buffer indexes (current, end, bufsize) */ long pos, vpos; /* real current, virtual current */ char stat; /* modified? */ unsigned char *buf; /* za buffer */ } FILE; #define FIS_MODIFIED 0x01 #define MODE_READWRITE 1004 #define MODE_READONLY 1005 #define MODE_OLDFILE 1005 #define MODE_NEWFILE 1006 #define MEMF_CLEAR (1 << 16) #ifndef NULL #define NULL 0 #endif extern FILE *xopen(), *xattach(); extern long xread(), xseek(), xtell(), xdetach(); !Funky!Stuff! fi # end of overwriting check echo shar: "extracting 'xtell.c'" '(75 characters)' if test -f 'xtell.c' then echo shar: "will not over-write existing file 'xtell.c'" else cat << \!Funky!Stuff! > 'xtell.c' #include "xstdio.h" long xtell(fi) FILE *fi; { return (fi->vpos); } !Funky!Stuff! fi # end of overwriting check echo shar: "extracting 'xwrite.c'" '(534 characters)' if test -f 'xwrite.c' then echo shar: "will not over-write existing file 'xwrite.c'" else cat << \!Funky!Stuff! > 'xwrite.c' #include "xstdio.h" xwrite(fi, buf, n) register FILE *fi; register char *buf; register long n; { register long w; for (;;) { w = (fi->max - fi->i1 < n) ? fi->max - fi->i1 : n; bmov(buf, fi->buf + fi->i1, w); n -= w; buf += w; fi->vpos += w; fi->i1 += w; if (fi->i2 < fi->i1) fi->i2 = fi->i1; fi->stat |= FIS_MODIFIED; if (n) { w = xflush(fi); if (w == 0) return (0); continue; } break; } return (1); } !Funky!Stuff! fi # end of overwriting check exit 0 # End of shell archive