Return to samuel.ca.dat CVS log

Up to [Research Unix] / researchv10dc / 630 / lib / samuel

researchv10 Dan Cross

Bitmap	struct{ Word *base; unsigned width; Rectangle rect; }Bitmap;
Drect	Rectangle Drect; the rectangle inside the display border
Font	struct{short n;char height, ascent;long unused;Bitmap *bits;Fontchar info[];}Font;
Fontchar	struct{ short x; char top, bottom, left, width; }Fontchar;
Jrect	Bitmap Jrect={0, 0, XMAX, YMAX};
Point	struct{ short x; short y; }Point;
Pt	Point Pt(x, y) int x, y; create a point from two coordinates
Rect	Rectangle Rect(a, b, c, d) int a, b, c, d; create a rectangle from four coordinates
Rectangle	struct{ Point origin; Point corner; }Rectangle;
Rpt	Rectangle Rpt(p, q) Point p, q; create a rectangle from two points
Texture	struct{ Word bits[16]; }Texture;
Word	short Word; quantum of display memory
_exit	_exit(status) terminate process, for real
abort	abort() generate a fault
abs	abs(a) integer absolute value
access	access(fn, mode) char *fn; determine accessibility of file
acct	acct(fn) char *fn; turn accounting on or off
acos	double acos(x) double x; <math.h>
add	Point add(p, q) Point p, q; add two points
addr	Word *addr(b, p) Bitmap *b; Point p; Word address of Point in Bitmap
alarm	alarm(t) unsigned t; schedule signal after specified time
alarm	void alarm(t) unsigned t; wakeup call timer
alloc	char *alloc(nbytes) unsigned nbytes; allocate memory
arc	arc(x1, y1, x2, y2, x, y, r) double x1, y1, x2, y2, x, y, r; <[i]plot.h>
arc	void arc(b, p0, p1, p2, f) Bitmap *b; Point p0, p1, p2; Code f;
area	area(r) Rectangle r; area of given rectangle
asctime	char *asctime(tm) struct tm *tm; <time.h> convert to standard date string
asin	double asin(x) double x; <math.h>
assert	assert(expression) <assert.h> program verification
atan	double atan(x) double x; <math.h>
atan2	double atan2(x, y) double x, y; <math.h>
atan2	int atan2(x, y) int x, y; inaccurate arc tangent (in degrees)
atof	double atof(s) char *s; convert ASCII to double
atoi	atoi(s) char *s; convert ASCII to integer
atol	long atol(s) char *s; convert ASCII to long
bagel	bagel(p, major, minor, c) Point p; Color c; draw an annulus
balloc	Bitmap *balloc(r) Rectangle r; allocate a bitmap
bfree	void bfree(b) Bitmap *b; deallocate a bitmap
bitblt	void bitblt(sb, r, db, p, f) Bitmap *sb, *db; Rectangle r; Point p; Code f;
box	box(x1, y1, x2, y2) double x1, y1, x2, y2; <[i]plot.h>
brk	char *brk(ad) change core allocation
btclose	void btclose(bt) btree *bt; <bt.h> close a B-tree file
btcommit	void btcommit() complete a B-tree transaction
btdelete	btdelete(bt, key) btree *bt; mbuf key; <bt.h> remove a record from a B-tree
btfirst	btfirst(bt) btree *bt; <bt.h> seek to the beginning of a B-tree file
btkey	mbuf btkey(bt) btree *bt; <bt.h> return current B-tree key
btopen	btree *btopen(fn, typ) char *fn; <bt.h> open a B-tree file
btread	btread(bt, key, rec) btree *bt; mbuf *key, *rec; <bt.h> read a B-tree record
btreclen	btreclen(bt) btree *bt; <bt.h> return current B-tree record length
btseek	btseek(bt, key) btree *bt; mbuf key; <bt.h> seek to a record in a B-tree file
btwrite	btwrite(bt, key, rec) btree *bt; mbuf key, rec; <bt.h> write a record in a B-tree
button1	button1() is mouse button 1 (left) depressed?
button12	button12() is mouse button 1 or 2 (left, middle) depressed?
button123	button123() is any mouse button depressed?
button2	button2() is mouse button 2 (middle) depressed?
button23	button23() is mouse button 2 or 3 (middle, right) depressed?
button3	button3() is mouse button 3 (right) depressed?
cabs	double cabs(z) struct { double x, y;} z; <math.h> Euclidean distance
calloc	char *calloc(nelem, elsize) unsigned nelem, elsize; allocate main memory
ceil	double ceil(x) double x; <math.h> ceiling function
cfill	cfill(s) char *s; <[i]plot.h>
chdir	chdir(fn) char *fn; change current working directory
chilidog	chilidog(p0, r0, c0, p1, r1, c1) Point p0, p1; Color c0, c1; draw a deluxe line
chmod	chmod(fn, mode) char *fn; change mode of file
chown	chown(fn, owner, group) char *fn; change owner and group of a file
circle	circle(xc, yc, r) double xc, yc, r; <[i]plot.h>
circle	void circle(b, p, r, f) Bitmap *b; Point p; int r; Code f;
clearerr	clearerr(f) FILE *stream; <stdio.h> clear f's error/eof flags
clipline	clipline(r, p0, p1) Rectangle r; Point *p0, *p1;  clip a line to the rectangle
close	close(fd) close a file
closedir	closedir(dirp) DIR *dirp; <ndir.h> close a directory
closepic	closepic(f) PICFILE *f; close a picture file
closepl	closepl() <[i]plot.h>
color	color(s) char *s; <[i]plot.h>
cos	double cos(x) double x; <math.h>
cos	int cos(d) int d; cosine of d in degrees
cosh	double cosh(x) double x; <math.h> hyperbolic cosine
creat	creat(fn, mode) char *fn; create a new file
crypt	char *crypt(key, salt) char *key, *salt; encrypt a password
cspline	cspline(n,  arr) int n[]; double *arr[]; <[i]plot.h>
ctime	char *ctime(clock) long *clock; <time.h>
cursallow	void cursallow() turn the mouse-tracking cursor on
cursinhibit	cursinhibit() turn the mouse-tracking cursor off
cursswitch	Texture *cursswitch(t) Texture *t; cursswitch: switch cursor (t==0 gets default)
datum	dbminit	dbminit(fn) char *fn; open a data base -ldbm
defont	Font defont; <font.h> default font
delete	delete(key) datum key; delete a record from a data base -ldbm
dialout	dialout(class, telno) char *class, *telno; place call on ACU
disc	void disc(b, p, r, f) Bitmap *b; Point p; int r; Code f;
display	Bitmap display; the current process's layer
div	Point div(p, a) Point p; int a; divide p.x and p.y by a
do	do statement while ( expression ) ;
dspline	dspline(n,  arr) int n[]; double *arr[]; <[i]plot.h>
dup	dup(fd) duplicate an open file descriptor
dup2	dup2(fd1, fd2) duplicate an open file descriptor
ecvt	char *ecvt(v, ndigit, decpt, sign) double v; int *decpt, *sign;
elarc	void elarc(bp, p0, a, b, p1, p2, f) Bitmap *bp; Point p0, p1, p2; int a, b; Code f;
eldisc	void eldisc(bp, p, a, b, f) Bitmap *bp; Point p; int a, b; Code f;
ellipse	void ellipse(bp, p, a, b, f) Bitmap *bp; Point p; int a, b; Code f;
encrypt	encrypt(block, edflag) char *block; DES encryption
endfsent	int endfsent() <fstab.h> close /etc/fstab
endpwent	endpwent() <pwd.h> close /etc/passwd
eqpt	int eqpt(p, q) Point p, q; compare two points for equality
eqrect	int eqrect(r, s) Rectangle r, s; compare two rectangles for equality
erase	erase() <[i]plot.h>
execl	execl(fn, s, ..., 0) char *fn, *s, ...; execute a file
execle	execle(fn, s, ..., 0, envp) char *fn, *s, ..., *envp[]; execute a file
execv	execv(fn, argv) char *fn, *argv[]; execute a file
execve	execve(fn, argv, envp) char *fn, *argv[], *envp[]; execute a file
exit	exit(status) terminate process
exit	void exit(); cease execution
exp	double exp(x) double x; <math.h> exponential function
fabs	double fabs(x) double x; <math.h> absolute value function
fbclr	fbclr(r, c) Rectangle r; Color c;  set rectangle r in the framebuffer to color c
fbflags	fbflags(argc, argv, f) char *argv[]; int (*f)(); process flag arguments
fbfontclose	fbfontclose(f) struct fbfont *f; close a font
fbfontdraw	fbfontdraw(chr, p, ft, c) char chr; Point p; struct fbfont *f; color c; draw a character in the framebuffer
fbfontopen	struct fbfont *fbfontopen(name) char *name; open a font file
fclose	fclose(f) FILE *f; <stdio.h> close a stream
fcvt	char *fcvt(v, ndigit, decpt, sign) double v; int *decpt, *sign;
fdopen	FILE *fdopen(fd, type) char *type; <stdio.h> open an i/o stream
feof	feof(f) FILE *f; <stdio.h> is f at eof?
ferror	ferror(f) FILE *f; <stdio.h> is f in an error state?
fetch	datum fetch(key) datum key; get a record from a data base -ldbm
fflush	fflush(f) FILE *f; <stdio.h> flush a stream
ffree	void ffree(f) Font *f; <font.h> free a font
fgetc	fgetc(f) FILE *f; <stdio.h> get character from stream
fgets	char *fgets(s, n, f) char *s; FILE *f; <stdio.h> get a string from a stream
fileno	fileno(f) FILE *FD; <stdio.h> get f's file number
fill	fill(n,  arr) int n[]; double *arr[]; <[i]plot.h>
firstkey	datum firstkey() get the `first' key of a data base -ldbm
floor	double floor(x) double x; <math.h> floor function
fopen	FILE *fopen(fn, type) char *fn, *type; <stdio.h> open an i/o stream
for	for (expression-init; expression-test; expression-iteration) statement
fork	fork() spawn new process
fprintf	fprintf(f, fmt [, arg]...) FILE *f; char *fmt; <stdio.h> formatted output to stream
fputc	fputc(c, f) FILE *f; <stdio.h> put character on a stream
fputs	fputs(s, f) char *s; FILE *f; <stdio.h> put a string on a stream
frame	frame(x1, y1, x2, y2) double x1, y1, x2, y2; <[i]plot.h>
frand	double frand() random double between 0. and 1.
fread	fread(ptr, sizeof(*ptr), nitems, f) FILE *f; <stdio.h> buffered binary read input
free	free(ptr) char *ptr; free main memory
free	void free(s) char *s; deallocate memory
freopen	FILE *freopen(fn, type, f) char *fn, *type; FILE *f; <stdio.h> open an i/o stream
frexp	double frexp(v, eptr) double v; int *eptr; return fraction, store exponent
fscanf	fscanf(f, fmt [, ptr]...) FILE *f; char *fmt; <stdio.h> formatted input conversion
fseek	fseek(f, offset, ptrname) FILE *f; long offset; <stdio.h> reposition a stream
fspline	fspline(n,  arr) int n[]; double *arr[]; <[i]plot.h>
fstat	fstat(fd, bp) struct stat *bp; get file status
ftell	long ftell(stream) FILE *stream; <stdio.h> get stream's seek pointer
ftime	ftime(tp) struct timeb *tp; <sys/types.h> <sys/timeb.h> get date and time
ftw	int ftw(fn, func, depth) char *fn; int (*func)(); <ftw.h> traverse a file tree
fwrite	fwrite(ptr, sizeof(*ptr), nitems, f) FILE *f; <stdio.h> buffered binary output
galloc	char *galloc(n) allocate garbage-collectable storage
gamma	double gamma(x) double x; <math.h> log gamma function
garbage	garbage() garbage collector for gfree(.)
gcalloc	char *gcalloc(nbytes, where) unsigned long nbytes; char **where; compacting alloc
gcd	gcd(a, b) integer greatest common divisor
gcfree	void gcfree(p) char *p; free gcalloced space.
gcvt	char *gcvt(v, ndigit, buf) double v; char *buf; floating output conversion
getc	getc(f) FILE *f; <stdio.h> get character from stream
getchar	getchar() <stdio.h> get character from stdin
getegid	getegid() get effective group id
getenv	char *getenv(name) char *name; get value for environment name
geteuid	geteuid() get effective user id
getfont	Font *getfont(file) char *file; <jerqio.h> <font.h> get a font from UNIX
getfsent	struct fstab *getfsent() <fstab.h> read next entry from /etc/fstab
getfsfile	struct fstab *getfsfile(fn) <fstab.h> char *fn; get fstab entry for file system
getfsspec	struct fstab *getfsspec(fn) char *fn; <fstab.h> get fstab entry for special file
getgid	getgid() get real group id
getlogin	char *getlogin() get login name
getopt	getopt(argc, argv, opt) char *argv[]; char *opt; extern char *optarg; extern int optind; get option letter from argv
getpass	char *getpass(prompt) char *prompt; read a password
getpgrp	getpgrp(pid) get process group
getpid	getpid() get process identification
getpw	getpw(uid, bp) char *bp; get name from uid
getpwent	struct passwd *getpwent() <pwd.h> decode next line of /etc/passwd
getpwnam	struct passwd *getpwnam(name) char *name; <pwd.h> decode name's line in /etc/passwd
getpwuid	struct passwd *getpwuid(uid) <pwd.h> decode line from /etc/passwd given uid
getrect	Rectangle getrect(); get rectangle swept out by user
gets	char *gets(s) char *s; <stdio.h> get a string from stdin
getuid	getuid() get real user id
getw	getw(f) FILE *f; <stdio.h> get word from stream
gfree	gfree(p) char *p; free garbage-collectable storage
gmtime	struct tm *gmtime(clock) long *clock; <time.h> convert to UTC time
grade	grade(x) double x; <[i]plot.h>
gtty	gtty(fd, bp) struct sgttyb *bp; <sgtty.h> control device
hotdog	hotdog(p0, p1, rad, c) Point p0, p1; Color c; draw a line
hsv2rgb	Color hsv2rgb(hsva) Hsva hsva; convert hexcone+a to rgba
hypot	double hypot(x, y) double x, y; <math.h> Euclidean distance
if	if ( expression ) statement  or  if ( expression ) statement else statement
ihypot	ihypot(a, b) (int)sqrt(a*a+b*b)
index	char *index(s, c) char *s, c; return ptr to first c in s (0 if not found)
infont	Font *infont(inch) int (*inch)(); <font.h> read a font using (*inch)() to get data
initedge	initedge(n) initialize the hotdog line edge table
inset	Rectangle inset(r, n) Rectangle r; int n; inset a Rectangle for a border
ioctl	ioctl(fd, request, bp) struct sgttyb? *bp; <sgtty.h> control device
isalnum	isalnum(c) <ctype.h> is c alphabetic or numeric?
isalpha	isalpha(c) <ctype.h> is c alphabetic?
isascii	isascii(c) <ctype.h> is c a 7-bit ascii character?
isatty	isatty(fd) return non-zero iff fd is a tty (i.e. if gtty works)
iscntrl	iscntrl(c) <ctype.h> is c a control character or del?
isdigit	isdigit(c) <ctype.h> is c a decimal digit?
islower	islower(c) <ctype.h> is c lower case alphabetic?
isprint	isprint(c) <ctype.h> is c a printing character?
ispunct	ispunct(c) <ctype.h> is c a punctuation character? (!isalnum(c) && !iscntrl(c))
isspace	isspace(c) <ctype.h> is c white space (sp, ht, cr, nl, ff)?
isupper	isupper(c) <ctype.h> is c upper case alphabetic?
j0	double j0(x) double x; <math.h> 0th order Bessel function of the first kind
j1	double j1(x) double x; <math.h> 1st order Bessel function of the first kind
jarc	void jarc(p0, p1, p2, f) Point p0, p1, p2; Code f; draw scaled circular arc
jcircle	void jcircle(p, r, f) Point p; int r; Code f; draw scaled circle
jdisc	void jdisc(p, r, f) Point p; int r; Code f; draw scaled disc
jelarc	void jelarc(p0, a, b, p1, p2, f) Point p0, p1, p2; int a, b; Code f; scaled elarc
jeldisc	void jeldisc(p, a, b, f) Point p; int a, b; Code f; draw scaled ellipse+interior
jellipse	void jellipse(p, a, b, f) Point p; int a, b; Code f; draw scaled ellipse
jline	void jline(p, f) Point p; Code f; draw a scaled relative line
jlineto	void jlineto(p, f) Point p; Code f; draw a scaled absolute line
jmove	void jmove(p) Point p; scaled relative move
jmoveto	void jmoveto(p) Point p; scaled absolute move
jn	double jn(n, x) double x; <math.h> nth order Bessel function of the first kind
jpoint	void jpoint(p, f) Point p; Code f; draw scaled single pixel on display
jrectf	void jrectf(r, f) Rectangle r; Code f; scaled rectangle function on display
jsegment	void jsegment(p, q, f) Point p, q; Code f; draw a scaled line segment
jstring	Point jstring(s) char *s; jstring: draw string on display at scaled current point
jstrwidth	int jstrwidth(s) char *s; <font.h> width of character string in layer coordinates
jtexture	void jtexture(r,t,f)Rectangle r;Texture *t;Code f;draw texture in rectangle on display
kbdchar	int kbdchar(); read character from keyboard, -1 if no characters have been typed
kill	kill(pid, sig) send signal to a process
killpg	killpg(pgrp, sig) send signal to a process or a process group
l3tol	l3tol(lp, cp, n) long *lp; char *cp; convert 3-byte integers to longs
lcm	long lcm(a, b) integer least common multiple
ldexp	double ldexp(v, exp) double v; reconstruct double from fraction and exponent
line	line(x1, y1, x2, y2) double x1, y1, x2, y2; <[i]plot.h>
link	link(fn1, fn2) char *fn1, *fn2; link to a file
localtime	struct tm *localtime(clock) long *clock; <time.h> convert to local time
log	double log(x) double x; <math.h> natural logarithm
log10	double log10(x) double x; <math.h> common logarithm
longjmp	longjmp(env, val) jmp_buf env; <setjmp.h> non-local goto
lrand	long lrand() random integer between 0 and 2^31-1
lseek	long lseek(fd, offset, whence) long offset; move read/write pointer
lspline	lspline(n,  arr) int n[]; double *arr[]; <[i]plot.h>
lstat	lstat(fn, bp) char *fn; struct stat *bp; get file status
ltol3	ltol3(cp, lp, n) char *cp; long *lp; convert longs to 3-byte integers
malloc	char *malloc(size) unsigned size; allocate main memory
max	max(a, b) integer maximum
menuhit	int menuhit(m, n) Menu *m; int n; present user with menu and get selection
min	min(a, b) integer minimum
mknod	mknod(fn, mode, ad) char *fn; make a directory or a special file
mktemp	char *mktemp(template) char *template; make a unique file name
modf	double modf(v, iptr) double v, *iptr; return fraction, store integer part
monitor	monitor(lowpc, highpc, bp, size, nfunc) int (*lowpc)(), (*highpc)(); short bp[]; prepare execution profile
mount	mount(special, fn, rwflag) char *special, *fn;  mount file system
mouse	struct {Point xy; Point jxy; int buttons;} mouse;
move	move(x, y) double x, y; <[i]plot.h>
mul	Point mul(p, a) Point p; int a; multiply p.x and p.y by a
muldiv	int muldiv(a, b, c) int a, b, c; calculate (a*b)/c accurately
nap	void nap(nticks) int nticks; sleep for time in 60ths of a second
nextkey	datum nextkey(key) datum key; get the key following the given key -ldbm
nice	nice(incr) set program priority
nlist	nlist(fn, nl) char *fn; struct nlist nl[]; <nlist.h> get entries from name list
norm	int norm(x, y, z) int x, y, z; return norm of three-dimensional vector
normalize	normalize(p) struct place *p; convert to normal map coordinates
nrand	nrand(x) random integer between 0 and x-1
open	open(fn, mode) char *fn; open for reading or writing
opendir	DIR *opendir(fn) char *fn; <ndir.h> open a directory
openpicr	PICFILE *openpicr(f) char *f; open a picture file to read
openpicw	PICFILE *openpicw(f, type, r, nchan, argv, cmap) char *f; Rectangle r; char **argv; unsigned char *cmap; open a picture file to write
openpl	openpl(s) char *s; <[i]plot.h>
orient	orient(lat, lon, rot) float lat, lon, rot; set map normalization parameters
outfont	int outfont(f, ouch) Font *f; int (*ouch)(); <font.h> write font via (*ouch)()
own	int own();  return bit vector indicating which resources have data
parabola	parabola(x1, y1, x2, y2, x3, y3) double x1, y1, x2, y2, x3, y3; <[i]plot.h>
pause	pause() stop until signal
pclose	pclose(f) FILE *f; <stdio.h> close f and wait for command
pen	pen(s) char *s; <[i]plot.h>
perror	perror(s) char *s; print system error message
pipe	pipe(fd) int fd[2]; create an interprocess channel
pizza	pizza(p, rad, c) Point p; Color c; draw a disc
point	point(x, y) double dx, dy; <[i]plot.h>
point	void point(b, p, f) Bitmap *b; Point p; Code f; draw a single pixel in a bitmap
poly	poly(n,  arr) int n[]; double *arr[]; <[i]plot.h>
popen	FILE *popen(cmd, type) char *cmd, *type; <stdio.h> initiate I/O to/from a process
poppyseed	poppyseed(p, c) Point p; Color c; draw a point-spot
pow	double pow(x, y) double x, y; <math.h> power
ppause	ppause() <[i]plot.h>
printf	printf(fmt [, arg]...) char *fmt; <stdio.h> formatted output conversion
profil	profil(bp, size, offset, scale) char *bp; execution time profile
project	project(p, xptr, yptr) struct place p; float *xptr, *yptr; map projection
ptinrect	int ptinrect(p, r) Point p; Rectangle r; is p within a r?
ptopen	ptopen(fn) char *fn; find and open a pseudo-terminal file
ptrace	ptrace(request, pid, ad, data) int *ad; <signal.h> process trace
putc	int putc(c, f) char c; FILE *f; <stdio.h> put character on a stream
putchar	putchar(c) <stdio.h> put character on stdout
puts	puts(s) char *s; <stdio.h> put a string on stdout
putw	putw(w, f) FILE *f; <stdio.h> put word on a stream
pwdecode	struct passwd *pwdecode(p) char *p; decode given password file entry
qsort	qsort(base, nel, width, compar) char *base; int (*compar)(); quicker sort
raddp	Rectangle raddp(r, p) Rectangle r; Point p; add p to r.origin and r.corner
rand	rand() random integer between 0 and 32767
range	range(x1, y1, x2, y2) double x1, y1, x2, y2; <[i]plot.h>
rcanon	Rectangle rcanon(r) Rectangle r; swap to make r.or.[xy]<=r.co.[xy]
rcvchar	int rcvchar(); receive character from host, returns -1 if none available
rdiv	Rectangle rdiv(r, d) Rectangle r; divide r.*.[xy] by d
rdivp	Rectangle rdivp(r, p) Rectangle r; Point p; divide r.*.x by p.x, r.*.y by p.y
re_comp	char *re_comp(s) char *s; compile regular expression
re_exec	re_exec(s) char *s; match regular expression
read	read(fd, bp, size) char *bp; read from file
readdir	struct direct *readdir(dirp) DIR *dirp; <ndir.h> read a directory entry
readlink	readlink(fn, bp, size) char *fn, *bp; read a symbolic link
readmap	readmap(m) unsigned char m[256][3]; read the framebuffer's colormap
readpic	readpic(f, p) PICFILE *f; unsigned char *p; read a line from a picture file
readrun	readrun(f, b) PICFILE *f, unsigned char *b; read a run from a picture file
realloc	char *realloc(ptr, size) char *ptr; unsigned size; change size of allocated memory
realtime	long realtime(); return time since mux was booted in 60ths of a second.
reboot	reboot(howto) <sys/reboot.h> reboot system or halt processor
rectXrect	int rectXrect(r, s) Rectangle r, s; do r and s overlap?
rectclip	int rectclip(rp, s) Rectangle *rp, s; clip *rp and s, returns non-zero if non-null
rectf	void rectf(b, r, f) Bitmap *b; Rectangle r; Code f; do function on rectangle in b
request	void request(r) int r; request I/O resources
restore	restore() <[i]plot.h>
rewind	rewind(stream) <stdio.h> reposition a stream to the beginning
rewinddir	rewinddir(dirp) DIR *dirp; <ndir.h> seek to the beginning of a directory
rgb2hsv	Hsva rgb2hsv(rgba) Color rgba; convert rgba to hexcone+a
rindex	char *rindex(s, c) char *s, c; return ptr to last c in s (0 if not found)
rmove	rmove(dx, dy) double dx, dy; <[i]plot.h>
rmul	Rectangle rmul(r, d) Rectangle r; multiply r.*.[xy] by d
rmulp	Rectangle rmulp(r, p) Rectangle r; Point p; multiply r.*.x by p.x, r.*.y by p.y
rol	int rol(x, n) int x, n; rotate x n bits left
ror	int ror(x, n) int x, n; rotate x n bits right
rsubp	Rectangle rsubp(r, p) Rectangle r; Point p; subtract p from r.origin and r.corner
rtransform	Rectangle rtransform(r) Rectangle r; transform r from layer to screen coordinates
rvec	rvec(dx, dy) double dx, dy; <[i]plot.h>
save	save() <[i]plot.h>
sbox	sbox(x1, y1, x2, y2) double x1, y1, x2, y2; <[i]plot.h>
sbrk	char *sbrk(inc) change core allocation incrementally
scanf	scanf(fmt [, ptr]...) char *fmt; <stdio.h> formatted input conversion
screenswap	void screenswap(b, r, s) Bitmap *b; Rectangle r, s; swap screen rectangle and bitmap
seekdir	seekdir(dirp, loc) DIR *dirp; long loc; <ndir.h> seek in a directory
segment	void segment(b, p, q, f) Bitmap *b; Point p, q; Code f; draw a line segment in a bitmap
select	select(nfd, rdfd, wrfd, milli); fd_set *rdfd, *wrfd; <sys/types.h> i/o multiplexing
sendchar	void sendchar(x) int x; send a character to the host
sendnchars	void sendnchars(n, p) int n; char *p; send n characters to host
setbuf	setbuf(f, bp) FILE *f; char *bp; <stdio.h> assign buffering to a stream
setfsend	int setfsend() <fstab.h> open and rewind /etc/fstab
setgid	setgid(gid) set group id
setjmp	setjmp(env) jmp_buf env; <setjmp.h> prepare for non-local goto
setkey	setkey(key) char *key; set key for DES encryption
setpgrp	setpgrp(pid, pgrp) set process group
setpwent	setpwent() <pwd.h> rewind /etc/passwd
setuid	setuid(uid) set user id
sgn	sgn(a) integer sign
signal	(*signal(sig, func))() void (*func)(); <signal.h> catch or ignore signals
sigsys	(*sigsys(sig, func))() void (*func)(); <signal.h> catch or ignore signals
sin	double sin(x) double x; <math.h>
sin	int sin(d) int d; sine of d in degrees
sinh	double sinh(x) double x; <math.h> hyperbolic sine
skippic	skippic(f) PICFILE *f; skip a scanline in a picture file
sleep	sleep(seconds) unsigned seconds; suspend execution for interval
sleep	void sleep(nticks) int nticks; sleep for time in 60ths of a second
snare	fbreg *snare(n) acquire a framebuffer and return a pointer to its registers
splice	splice(fd1, fd2, flag) connect two stream file descriptors
spline	spline(n,  arr) int n[]; double *arr[]; <[i]plot.h>
sprintf	sprintf(s, format [, arg]...) char *s, format; <stdio.h> formatted output to string
sqrt	double sqrt(x) double x; <math.h> square root
sqrt	int sqrt(x) long x; integer square root
srand	srand(seed) initialize random number generator (seed between 0 and 32767?)
sscanf	sscanf(s, fmt [, ptr]...) char *s, *fmt; <stdio.h> formatted input conversion
stat	stat(fn, bp) char *fn; struct stat *bp; <sys/types.h> <sys/stat.h> get file status
stderr	FILE *stderr; <stdio.h> buffered diagnostid output stream
stdin	FILE *stdin; <stdio.h> buffered standard input stream
stdout	FILE *stdout; <stdio.h> buffered standard output stream
stime	stime(tp) long *tp; set time
store	store(key, content) datum key, content; store a record in a data base -ldbm
strcat	char *strcat(d, s) char *d, *s; append s to d
strchr	char *strchr(s, c) char *s, c; return ptr to first c in s (0 if not found)
strcmp	strcmp(s, t) char *s, *t; compare s to t. <0 if s<t, >0 if s>t, ==0 if s==t
strcpy	char *strcpy(d, s) char *d, *s; copy s to d
string	Point string(ft, s, b, p, f) Font *ft; char *s; Bitmap *b; Point p; Code f; <font.h> draw string in bitmap
strlen	strlen(s) char *s; return length of s (not including the nul)
strncat	char *strncat(d, s, n) char *d, *s; append at most n chars of s to d
strncmp	strncmp(s, t, n) char *s, t; compare s to t. <0 if s<t, >0 if s>t, ==0 if s==t
strncpy	char *strncpy(d, s, n) char *d, *s; copy at most n chars of s to d
strrchr	char *strrchr(s, c) char *s, c; return ptr to last c in s (0 if not found)
strwidth	int strwidth(f, s) Font *f; char *s; <font.h> width of character string
stty	stty(fd, bp) struct sgttyb *bp; <sgtty.h> control device
sub	Point sub(p, q) Point p, q; subtract p-q
swab	swab(from, to, nbytes) char *from, *to; swap bytes
symlink	symlink(fn1, fn2) char *fn1, *fn2; link to a file symbolically
sync	sync() update super-block
syscall	syscall(number, arg, ...) indirect system call
system	system(s) char *s; issue a shell command
tanh	double tanh(x) double x; <math.h> hyperbolic tangent
tell	long tell(fd) read read/write pointer
telldir	long telldir(dirp) DIR *dirp; <ndir.h> get a directory's seek pointer
text	text(s) char *s; <[i]plot.h>
texture	void texture(b, r, t, f) Bitmap *b; Rectangle r; Texture *t; Code f; draw texture in rectangle in bitmap
time	time_t time(tloc) time_t *tloc; <sys/types.h> get date and time
times	times(bp) struct tms *bp; <sys/types.h> <sys/times.h> get process times
timezone	char *timezone(zone, dst) get time zone name
trabort	void trabort() abort a B-tree transaction
transform	Point transform(p) Point p; transform p from layer to screen coordinates
trstart	trstart() start a B-tree transaction
ttyname	char *ttyname(fd) returns ptr to name of tty (0 if fd is not a tty)
ttyslot	ttyslot() returns number of the entry in /etc/ttys for the control terminal
typedef struct {  char *dptr;  int dsize; } datum;
umask	umask(complmode) set file creation mode mask
umount	umount(special) char *special; remove file system
uname	uname(name) struct utsname *name; <sys/utsname.h> get system name
ungetc	ungetc(c, stream) FILE *stream; <stdio.h> push character back into input stream
unlink	unlink(fn) char *fn; remove directory entry
usage	usage(s) char *s; print a usage message
utime	utime(fn, timep) char *fn; time_t timep[2]; set file times
vadvise	vadvise(param) give advice to paging system
valloc	char *valloc(size) unsigned size; aligned memory allocator
vec	vec(x, y) double x, y; <[i]plot.h>
vfork	vfork() spawn new process in a virtual memory efficient way
vhangup	vhangup() virtually ``hangup'' the current control terminal
view2d	view2d(fd,nx,ny,time,u,v,fixuv,pmin,pmax,p) short nx, ny, time, u, v, fixuv, pmin, pmax, p[]; movie of a function f(x, y, t)
vlimit	vlimit(resource, value) control maximum system resource consumption
vread	vread(fd, bp, size) char *bp; read virtually
vswapon	vswapon(fn) char *fn; add a swap device for interleaved paging/swapping
vtimes	vtimes(par, ch) struct vtimes *par, *ch; get resource utilization information
vwrite	vwrite(filedes, buffer, nbytes) char *buffer; write (virtually) to file
wait	int wait(r) int r; wait for resources.  wait(CPU) lets other processes run
wait	wait(status) int *status; wait(0) wait for process to terminate
wait3	wait3(status, opt, vtimep) union wait status; struct vtimes *vtimep; wait for process to terminate
while	while ( expression ) statement
write	write(fd, bp, size) char *bp; write on a file
writemap	writemap(m) unsigne char m[256][3]; write the framebuffer's colormap
writepic	writepic(f, p) PICFILE *f; unsigned char *p; write a scanline in a picture file
y0	double y0(x) double x; <math.h> 0th order Bessel function of the second kind
y1	double y1(x) double x; <math.h> 1st order Bessel function of the second kind
yn	double yn(n, x) double x; <math.h> nth order Bessel function of the second kind

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.