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