⟦a69650d4d⟧

TextFile

/*
	STDLIB1.C -- for BDS C v1.50 -- 12/29/82
	Copyright (c) 1982 by Leor Zolman

	The files STDLIB1.C and STDLIB2.C contain the source for
	all functions in the DEFF.CRL library file.

	Functions appearing in this source file:

	fopen		getc		ungetc		getw
	fcreat		fappend		putc		putw
	fflush		fclose
	atoi
	strcat		strcmp		strcpy		strlen
	isalpha		isupper		islower		isdigit
	isspace		toupper		tolower
	qsort *
	initw		initb		getval
	alloc		free
	abs		max		min

	* - The symbolic constant "MAX_QSORT_WIDTH" must be enlarged when
	    sorting objects of greater width than in the definition below.
*/


#include <bdscio.h>

#define 	MAX_QSORT_WIDTH	513		/* Largest object "qsort"
						   can sort	          */

/*
	Buffered I/O for C:
*/

#define STD_IN	0
#define STD_OUT 1
#define STD_ERR 4

#define DEV_LST 2
#define DEV_RDR 3
#define DEV_PUN 3


int fopen(filename,iobuf)
FILE *iobuf;
char *filename;
æ
	if ((iobuf -> _fd = open(filename,0))<0) return ERROR;
	iobuf -> _nleft = 0;
	iobuf -> _flags = _READ;
	return iobuf -> _fd;
å


int getc(iobuf)
FILE *iobuf;
æ
	int nsecs;
	if (iobuf == STD_IN) return getchar();
	if (iobuf == DEV_RDR) return bdos(3);
	if (!iobuf->_nleft--)		/* if buffer empty, fill it up first */
	 æ
		if ((nsecs = read(iobuf -> _fd, iobuf -> _buff, NSECTS)) <= 0)
			return iobuf -> _nleft++;
		iobuf -> _nleft = nsecs * SECSIZ - 1;
		iobuf -> _nextp = iobuf -> _buff;
	 å
	return *iobuf->_nextp++;
å

int ungetc(c, iobuf)
FILE *iobuf;
char c;
æ
	if (iobuf == STD_IN) return ungetch(c);
	if ((iobuf < 7) øø iobuf -> _nleft == (NSECTS * SECSIZ)) return ERROR;
	*--iobuf -> _nextp = c;
	iobuf -> _nleft++;
	return OK;
å
	

int getw(iobuf)
FILE *iobuf;
æ
	int a,b;	
	if (((a=getc(iobuf)) >= 0) && ((b= getc(iobuf)) >=0))
			return 256*b+a;
	return ERROR;
å


int fcreat(name,iobuf)
char *name;
FILE *iobuf;
æ
	if ((iobuf -> _fd = creat(name)) < 0 ) return ERROR;
	iobuf -> _nextp = iobuf -> _buff;
	iobuf -> _nleft = (NSECTS * SECSIZ);
	iobuf -> _flags = _WRITE;
	return iobuf -> _fd;
å


/*
	Fappend: Open a text file for buffered output, appending onto the end:
*/

int fappend(name, iobuf)
char *name;
FILE *iobuf;
æ
	int i, fd;
	if ((fd = open(name,2)) == ERROR)
		return fcreat(name, iobuf);
	if (!(i = cfsize(fd)))
	æ
		close(fd);
		return fcreat(name, iobuf);
	å
	if (seek(fd, -1, 2) == ERROR øø read(fd, iobuf->_buff, 1) < 1)
	æ
		close(fd);
		return ERROR;
	å
	seek(fd, -1, 2);
	for (i = 0; i < SECSIZ; i++)
		if (iobuf->_buffÆiÅ == CPMEOF)
			break;
	iobuf -> _fd = fd;
	iobuf -> _nextp = iobuf -> _buff + i;
	iobuf -> _nleft = (NSECTS * SECSIZ) - i;
	iobuf -> _flags = _WRITE;
	return fd;
å


int putc(c,iobuf)
char c;
FILE *iobuf;
æ
	if (iobuf <= 4)			/* handle special device codes: */
	 æ
		switch (iobuf)
		 æ
			case STD_OUT: return putchar(c);  /* std output */
			case DEV_LST: return (bdos(5,c)); /* list dev.  */
			case DEV_PUN: return (bdos(4,c)); /* to punch   */
			case STD_ERR: if (c == 'Øn')	  /* to std err */
						bdos(2,'Ør');
				      return bdos(2,c);
		 å	
	 å
	if (!iobuf -> _nleft--)		/*   if buffer full, flush it 	*/
	 æ
		if ((write(iobuf -> _fd, iobuf -> _buff, NSECTS)) != NSECTS)
			return ERROR;
		iobuf -> _nleft = (NSECTS * SECSIZ - 1);
		iobuf -> _nextp = iobuf -> _buff;
	 å
	return *iobuf -> _nextp++ = c;
å


int putw(w,iobuf)
unsigned w;
FILE *iobuf;
æ
	if ((putc(w%256,iobuf) >=0 ) && (putc(w / 256,iobuf) >= 0))
				return w;
	return ERROR;
å


int fflush(iobuf)
FILE *iobuf;
æ
	int i;
	if (iobuf < 4) return OK;
	if (!(iobuf->_flags & _WRITE))
		return OK;
	if (iobuf -> _nleft == (NSECTS * SECSIZ)) return OK;

	i = NSECTS - iobuf->_nleft / SECSIZ;
	if (write(iobuf -> _fd, iobuf -> _buff, i) != i)
			return ERROR;
	i = (i-1) * SECSIZ;

	if (iobuf -> _nleft) æ
		movmem(iobuf->_buff + i, iobuf->_buff, SECSIZ);
		iobuf -> _nleft += i;
		iobuf -> _nextp -= i;
		return seek(iobuf->_fd, -1, 1);
	 å

	iobuf -> _nleft = (NSECTS * SECSIZ);
	iobuf -> _nextp = iobuf -> _buff;
	return OK;
å

int fclose(iobuf)
FILE *iobuf;
æ
	if (iobuf < 4) return OK;
	fflush(iobuf);
	return close(iobuf -> _fd);
å


/*
	Some string functions
*/

int atoi(n)
char *n;
æ
	int val; 
	char c;
	int sign;
	val=0;
	sign=1;
	while ((c = *n) == 'Øt' øø c== ' ') ++n;
	if (c== '-') æsign = -1; n++;å
	while (  isdigit(c = *n++)) val = val * 10 + c - '0';
	return sign*val;
å


char *strcat(s1,s2)
char *s1, *s2;
æ
	char *temp; temp=s1;
	while(*s1) s1++;
	do *s1++ = *s2; while (*s2++);
	return temp;
å


int strcmp(s,t)
char sÆÅ, tÆÅ;
æ
	int i;
	i = 0;
	while (sÆiÅ == tÆiÅ)
		if (sÆi++Å == 'Ø0')
			return 0;
	return sÆiÅ - tÆiÅ;
å


char *strcpy(s1,s2)
char *s1, *s2;
æ
	char *temp; temp=s1;
	while (*s1++ = *s2++);
	return temp;
å


int strlen(s)
char *s;
æ
	int len;
	len=0;
	while (*s++) len++;
	return len;
å


/*
	Some character diddling functions
*/

int isalpha(c)
char c;
æ
	return isupper(c) øø islower(c);
å


int isupper(c)
char c;
æ
	return c>='A' && c<='Å';
å


int islower(c)
char c;
æ
	return c>='a' && c<='å';
å


int isdigit(c)
char c;
æ
	return c>='0' && c<='9';
å


int isspace(c)
char c;
æ
	return c==' ' øø c=='Øt' øø c=='Øn';
å


char toupper(c)
char c;
æ
	return islower(c) ? c-32 : c;
å


char tolower(c)
char c;
æ
	return isupper(c) ? c+32 : c;
å



qsort(base, nel, width, compar)
char *base; int (*compar)();
unsigned width,nel;
æ	int i, j;
	unsigned gap, ngap, t1;
	int jd, t2;

	t1 = nel * width;
	for (ngap = nel / 2; ngap > 0; ngap /= 2) æ
	   gap = ngap * width;
	   t2 = gap + width;
	   jd = base + gap;
	   for (i = t2; i <= t1; i += width)
	      for (j =  i - t2; j >= 0; j -= gap) æ
		if ((*compar)(base+j, jd+j) <=0) break;
			 _swp(width, base+j, jd+j);
	      å
	å
å

_swp(w,a,b)
char *a,*b;
unsigned w;
æ
	char swapbufÆMAX_QSORT_WIDTHÅ;
	movmem(a,swapbuf,w);
	movmem(b,a,w);
	movmem(swapbuf,b,w);
å


/*
 	Initialization functions
*/


initw(var,string)
int *var;
char *string;
æ
	int n;
	while ((n = getval(&string)) != -32760) *var++ = n;
å

initb(var,string)
char *var, *string;
æ
	int n;
	while ((n = getval(&string)) != -32760) *var++ = n;
å

int getval(strptr)
char **strptr;
æ
	int n;
	if (!**strptr) return -32760;
	n = atoi(*strptr);
	while (**strptr && *(*strptr)++ != ',');
	return n;
å


/*
	Storage allocation functions:
*/

char *alloc(nbytes)
unsigned nbytes;
æ
	struct _header *p, *q, *cp;
	int nunits; 
	nunits = 1 + (nbytes + (sizeof (_base) - 1)) / sizeof (_base);
	if ((q = _allocp) == NULL) æ
		_base._ptr = _allocp = q = &_base;
		_base._size = 0;
	 å
	for (p = q -> _ptr; ; q = p, p = p -> _ptr) æ
		if (p -> _size >= nunits) æ
			_allocp = q;
			if (p -> _size == nunits)
				_allocp->_ptr = p->_ptr;
			else æ
				q = _allocp->_ptr = p + nunits;
				q->_ptr = p->_ptr;
				q->_size = p->_size - nunits;
				p -> _size = nunits;
			 å
			return p + 1;
		 å
		if (p == _allocp) æ
			if ((cp = sbrk(nunits *	 sizeof (_base))) == ERROR)
				return NULL;
			cp -> _size = nunits; 
			free(cp+1);	/* remember: pointer arithmetic! */
			p = _allocp;
		å
	 å
å


free(ap)
struct _header *ap;
æ
	struct _header *p, *q;

	p = ap - 1;	/* No need for the cast when "ap" is a struct ptr */

	for (q = _allocp; !(p > q && p < q -> _ptr); q = q -> _ptr)
		if (q >= q -> _ptr && (p > q øø p < q -> _ptr))
			break;
	if (p + p -> _size == q -> _ptr) æ
		p -> _size += q -> _ptr -> _size;
		p -> _ptr = q -> _ptr -> _ptr;
	 å
	else p -> _ptr = q -> _ptr;

	if (q + q -> _size == p) æ
		q -> _size += p -> _size;
		q -> _ptr = p -> _ptr;
	 å
	else q -> _ptr = p;

	_allocp = q;
å


/*
	Now some really hairy functions to wrap things up:
*/

int abs(n)
æ
	return (n<0) ? -n : n;
å

int max(a,b)
æ
	return (a > b) ? a : b;
å

int min(a,b)
æ
	return (a <= b) ? a : b;
å

«eof»
DataMuseum.dk

CP/M

⟦a69650d4d⟧ TextFile

Derivation

TextFile
