Return to samuel.ca.dat CVS log

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

Annotation of researchv10dc/630/lib/samuel/samuel.ca.dat, revision 1.1

1.1     ! root        1: Bitmap struct{ Word *base; unsigned width; Rectangle rect; }Bitmap;
        !             2: Drect  Rectangle Drect; the rectangle inside the display border
        !             3: Font   struct{short n;char height, ascent;long unused;Bitmap *bits;Fontchar info[];}Font;
        !             4: Fontchar       struct{ short x; char top, bottom, left, width; }Fontchar;
        !             5: Jrect  Bitmap Jrect={0, 0, XMAX, YMAX};
        !             6: Point  struct{ short x; short y; }Point;
        !             7: Pt     Point Pt(x, y) int x, y; create a point from two coordinates
        !             8: Rect   Rectangle Rect(a, b, c, d) int a, b, c, d; create a rectangle from four coordinates
        !             9: Rectangle      struct{ Point origin; Point corner; }Rectangle;
        !            10: Rpt    Rectangle Rpt(p, q) Point p, q; create a rectangle from two points
        !            11: Texture        struct{ Word bits[16]; }Texture;
        !            12: Word   short Word; quantum of display memory
        !            13: _exit  _exit(status) terminate process, for real
        !            14: abort  abort() generate a fault
        !            15: abs    abs(a) integer absolute value
        !            16: access access(fn, mode) char *fn; determine accessibility of file
        !            17: acct   acct(fn) char *fn; turn accounting on or off
        !            18: acos   double acos(x) double x; <math.h>
        !            19: add    Point add(p, q) Point p, q; add two points
        !            20: addr   Word *addr(b, p) Bitmap *b; Point p; Word address of Point in Bitmap
        !            21: alarm  alarm(t) unsigned t; schedule signal after specified time
        !            22: alarm  void alarm(t) unsigned t; wakeup call timer
        !            23: alloc  char *alloc(nbytes) unsigned nbytes; allocate memory
        !            24: arc    arc(x1, y1, x2, y2, x, y, r) double x1, y1, x2, y2, x, y, r; <[i]plot.h>
        !            25: arc    void arc(b, p0, p1, p2, f) Bitmap *b; Point p0, p1, p2; Code f;
        !            26: area   area(r) Rectangle r; area of given rectangle
        !            27: asctime        char *asctime(tm) struct tm *tm; <time.h> convert to standard date string
        !            28: asin   double asin(x) double x; <math.h>
        !            29: assert assert(expression) <assert.h> program verification
        !            30: atan   double atan(x) double x; <math.h>
        !            31: atan2  double atan2(x, y) double x, y; <math.h>
        !            32: atan2  int atan2(x, y) int x, y; inaccurate arc tangent (in degrees)
        !            33: atof   double atof(s) char *s; convert ASCII to double
        !            34: atoi   atoi(s) char *s; convert ASCII to integer
        !            35: atol   long atol(s) char *s; convert ASCII to long
        !            36: bagel  bagel(p, major, minor, c) Point p; Color c; draw an annulus
        !            37: balloc Bitmap *balloc(r) Rectangle r; allocate a bitmap
        !            38: bfree  void bfree(b) Bitmap *b; deallocate a bitmap
        !            39: bitblt void bitblt(sb, r, db, p, f) Bitmap *sb, *db; Rectangle r; Point p; Code f;
        !            40: box    box(x1, y1, x2, y2) double x1, y1, x2, y2; <[i]plot.h>
        !            41: brk    char *brk(ad) change core allocation
        !            42: btclose        void btclose(bt) btree *bt; <bt.h> close a B-tree file
        !            43: btcommit       void btcommit() complete a B-tree transaction
        !            44: btdelete       btdelete(bt, key) btree *bt; mbuf key; <bt.h> remove a record from a B-tree
        !            45: btfirst        btfirst(bt) btree *bt; <bt.h> seek to the beginning of a B-tree file
        !            46: btkey  mbuf btkey(bt) btree *bt; <bt.h> return current B-tree key
        !            47: btopen btree *btopen(fn, typ) char *fn; <bt.h> open a B-tree file
        !            48: btread btread(bt, key, rec) btree *bt; mbuf *key, *rec; <bt.h> read a B-tree record
        !            49: btreclen       btreclen(bt) btree *bt; <bt.h> return current B-tree record length
        !            50: btseek btseek(bt, key) btree *bt; mbuf key; <bt.h> seek to a record in a B-tree file
        !            51: btwrite        btwrite(bt, key, rec) btree *bt; mbuf key, rec; <bt.h> write a record in a B-tree
        !            52: button1        button1() is mouse button 1 (left) depressed?
        !            53: button12       button12() is mouse button 1 or 2 (left, middle) depressed?
        !            54: button123      button123() is any mouse button depressed?
        !            55: button2        button2() is mouse button 2 (middle) depressed?
        !            56: button23       button23() is mouse button 2 or 3 (middle, right) depressed?
        !            57: button3        button3() is mouse button 3 (right) depressed?
        !            58: cabs   double cabs(z) struct { double x, y;} z; <math.h> Euclidean distance
        !            59: calloc char *calloc(nelem, elsize) unsigned nelem, elsize; allocate main memory
        !            60: ceil   double ceil(x) double x; <math.h> ceiling function
        !            61: cfill  cfill(s) char *s; <[i]plot.h>
        !            62: chdir  chdir(fn) char *fn; change current working directory
        !            63: chilidog       chilidog(p0, r0, c0, p1, r1, c1) Point p0, p1; Color c0, c1; draw a deluxe line
        !            64: chmod  chmod(fn, mode) char *fn; change mode of file
        !            65: chown  chown(fn, owner, group) char *fn; change owner and group of a file
        !            66: circle circle(xc, yc, r) double xc, yc, r; <[i]plot.h>
        !            67: circle void circle(b, p, r, f) Bitmap *b; Point p; int r; Code f;
        !            68: clearerr       clearerr(f) FILE *stream; <stdio.h> clear f's error/eof flags
        !            69: clipline       clipline(r, p0, p1) Rectangle r; Point *p0, *p1;  clip a line to the rectangle
        !            70: close  close(fd) close a file
        !            71: closedir       closedir(dirp) DIR *dirp; <ndir.h> close a directory
        !            72: closepic       closepic(f) PICFILE *f; close a picture file
        !            73: closepl        closepl() <[i]plot.h>
        !            74: color  color(s) char *s; <[i]plot.h>
        !            75: cos    double cos(x) double x; <math.h>
        !            76: cos    int cos(d) int d; cosine of d in degrees
        !            77: cosh   double cosh(x) double x; <math.h> hyperbolic cosine
        !            78: creat  creat(fn, mode) char *fn; create a new file
        !            79: crypt  char *crypt(key, salt) char *key, *salt; encrypt a password
        !            80: cspline        cspline(n,  arr) int n[]; double *arr[]; <[i]plot.h>
        !            81: ctime  char *ctime(clock) long *clock; <time.h>
        !            82: cursallow      void cursallow() turn the mouse-tracking cursor on
        !            83: cursinhibit    cursinhibit() turn the mouse-tracking cursor off
        !            84: cursswitch     Texture *cursswitch(t) Texture *t; cursswitch: switch cursor (t==0 gets default)
        !            85: datum  dbminit dbminit(fn) char *fn; open a data base -ldbm
        !            86: defont Font defont; <font.h> default font
        !            87: delete delete(key) datum key; delete a record from a data base -ldbm
        !            88: dialout        dialout(class, telno) char *class, *telno; place call on ACU
        !            89: disc   void disc(b, p, r, f) Bitmap *b; Point p; int r; Code f;
        !            90: display        Bitmap display; the current process's layer
        !            91: div    Point div(p, a) Point p; int a; divide p.x and p.y by a
        !            92: do     do statement while ( expression ) ;
        !            93: dspline        dspline(n,  arr) int n[]; double *arr[]; <[i]plot.h>
        !            94: dup    dup(fd) duplicate an open file descriptor
        !            95: dup2   dup2(fd1, fd2) duplicate an open file descriptor
        !            96: ecvt   char *ecvt(v, ndigit, decpt, sign) double v; int *decpt, *sign;
        !            97: elarc  void elarc(bp, p0, a, b, p1, p2, f) Bitmap *bp; Point p0, p1, p2; int a, b; Code f;
        !            98: eldisc void eldisc(bp, p, a, b, f) Bitmap *bp; Point p; int a, b; Code f;
        !            99: ellipse        void ellipse(bp, p, a, b, f) Bitmap *bp; Point p; int a, b; Code f;
        !           100: encrypt        encrypt(block, edflag) char *block; DES encryption
        !           101: endfsent       int endfsent() <fstab.h> close /etc/fstab
        !           102: endpwent       endpwent() <pwd.h> close /etc/passwd
        !           103: eqpt   int eqpt(p, q) Point p, q; compare two points for equality
        !           104: eqrect int eqrect(r, s) Rectangle r, s; compare two rectangles for equality
        !           105: erase  erase() <[i]plot.h>
        !           106: execl  execl(fn, s, ..., 0) char *fn, *s, ...; execute a file
        !           107: execle execle(fn, s, ..., 0, envp) char *fn, *s, ..., *envp[]; execute a file
        !           108: execv  execv(fn, argv) char *fn, *argv[]; execute a file
        !           109: execve execve(fn, argv, envp) char *fn, *argv[], *envp[]; execute a file
        !           110: exit   exit(status) terminate process
        !           111: exit   void exit(); cease execution
        !           112: exp    double exp(x) double x; <math.h> exponential function
        !           113: fabs   double fabs(x) double x; <math.h> absolute value function
        !           114: fbclr  fbclr(r, c) Rectangle r; Color c;  set rectangle r in the framebuffer to color c
        !           115: fbflags        fbflags(argc, argv, f) char *argv[]; int (*f)(); process flag arguments
        !           116: fbfontclose    fbfontclose(f) struct fbfont *f; close a font
        !           117: fbfontdraw     fbfontdraw(chr, p, ft, c) char chr; Point p; struct fbfont *f; color c; draw a character in the framebuffer
        !           118: fbfontopen     struct fbfont *fbfontopen(name) char *name; open a font file
        !           119: fclose fclose(f) FILE *f; <stdio.h> close a stream
        !           120: fcvt   char *fcvt(v, ndigit, decpt, sign) double v; int *decpt, *sign;
        !           121: fdopen FILE *fdopen(fd, type) char *type; <stdio.h> open an i/o stream
        !           122: feof   feof(f) FILE *f; <stdio.h> is f at eof?
        !           123: ferror ferror(f) FILE *f; <stdio.h> is f in an error state?
        !           124: fetch  datum fetch(key) datum key; get a record from a data base -ldbm
        !           125: fflush fflush(f) FILE *f; <stdio.h> flush a stream
        !           126: ffree  void ffree(f) Font *f; <font.h> free a font
        !           127: fgetc  fgetc(f) FILE *f; <stdio.h> get character from stream
        !           128: fgets  char *fgets(s, n, f) char *s; FILE *f; <stdio.h> get a string from a stream
        !           129: fileno fileno(f) FILE *FD; <stdio.h> get f's file number
        !           130: fill   fill(n,  arr) int n[]; double *arr[]; <[i]plot.h>
        !           131: firstkey       datum firstkey() get the `first' key of a data base -ldbm
        !           132: floor  double floor(x) double x; <math.h> floor function
        !           133: fopen  FILE *fopen(fn, type) char *fn, *type; <stdio.h> open an i/o stream
        !           134: for    for (expression-init; expression-test; expression-iteration) statement
        !           135: fork   fork() spawn new process
        !           136: fprintf        fprintf(f, fmt [, arg]...) FILE *f; char *fmt; <stdio.h> formatted output to stream
        !           137: fputc  fputc(c, f) FILE *f; <stdio.h> put character on a stream
        !           138: fputs  fputs(s, f) char *s; FILE *f; <stdio.h> put a string on a stream
        !           139: frame  frame(x1, y1, x2, y2) double x1, y1, x2, y2; <[i]plot.h>
        !           140: frand  double frand() random double between 0. and 1.
        !           141: fread  fread(ptr, sizeof(*ptr), nitems, f) FILE *f; <stdio.h> buffered binary read input
        !           142: free   free(ptr) char *ptr; free main memory
        !           143: free   void free(s) char *s; deallocate memory
        !           144: freopen        FILE *freopen(fn, type, f) char *fn, *type; FILE *f; <stdio.h> open an i/o stream
        !           145: frexp  double frexp(v, eptr) double v; int *eptr; return fraction, store exponent
        !           146: fscanf fscanf(f, fmt [, ptr]...) FILE *f; char *fmt; <stdio.h> formatted input conversion
        !           147: fseek  fseek(f, offset, ptrname) FILE *f; long offset; <stdio.h> reposition a stream
        !           148: fspline        fspline(n,  arr) int n[]; double *arr[]; <[i]plot.h>
        !           149: fstat  fstat(fd, bp) struct stat *bp; get file status
        !           150: ftell  long ftell(stream) FILE *stream; <stdio.h> get stream's seek pointer
        !           151: ftime  ftime(tp) struct timeb *tp; <sys/types.h> <sys/timeb.h> get date and time
        !           152: ftw    int ftw(fn, func, depth) char *fn; int (*func)(); <ftw.h> traverse a file tree
        !           153: fwrite fwrite(ptr, sizeof(*ptr), nitems, f) FILE *f; <stdio.h> buffered binary output
        !           154: galloc char *galloc(n) allocate garbage-collectable storage
        !           155: gamma  double gamma(x) double x; <math.h> log gamma function
        !           156: garbage        garbage() garbage collector for gfree(.)
        !           157: gcalloc        char *gcalloc(nbytes, where) unsigned long nbytes; char **where; compacting alloc
        !           158: gcd    gcd(a, b) integer greatest common divisor
        !           159: gcfree void gcfree(p) char *p; free gcalloced space.
        !           160: gcvt   char *gcvt(v, ndigit, buf) double v; char *buf; floating output conversion
        !           161: getc   getc(f) FILE *f; <stdio.h> get character from stream
        !           162: getchar        getchar() <stdio.h> get character from stdin
        !           163: getegid        getegid() get effective group id
        !           164: getenv char *getenv(name) char *name; get value for environment name
        !           165: geteuid        geteuid() get effective user id
        !           166: getfont        Font *getfont(file) char *file; <jerqio.h> <font.h> get a font from UNIX
        !           167: getfsent       struct fstab *getfsent() <fstab.h> read next entry from /etc/fstab
        !           168: getfsfile      struct fstab *getfsfile(fn) <fstab.h> char *fn; get fstab entry for file system
        !           169: getfsspec      struct fstab *getfsspec(fn) char *fn; <fstab.h> get fstab entry for special file
        !           170: getgid getgid() get real group id
        !           171: getlogin       char *getlogin() get login name
        !           172: getopt getopt(argc, argv, opt) char *argv[]; char *opt; extern char *optarg; extern int optind; get option letter from argv
        !           173: getpass        char *getpass(prompt) char *prompt; read a password
        !           174: getpgrp        getpgrp(pid) get process group
        !           175: getpid getpid() get process identification
        !           176: getpw  getpw(uid, bp) char *bp; get name from uid
        !           177: getpwent       struct passwd *getpwent() <pwd.h> decode next line of /etc/passwd
        !           178: getpwnam       struct passwd *getpwnam(name) char *name; <pwd.h> decode name's line in /etc/passwd
        !           179: getpwuid       struct passwd *getpwuid(uid) <pwd.h> decode line from /etc/passwd given uid
        !           180: getrect        Rectangle getrect(); get rectangle swept out by user
        !           181: gets   char *gets(s) char *s; <stdio.h> get a string from stdin
        !           182: getuid getuid() get real user id
        !           183: getw   getw(f) FILE *f; <stdio.h> get word from stream
        !           184: gfree  gfree(p) char *p; free garbage-collectable storage
        !           185: gmtime struct tm *gmtime(clock) long *clock; <time.h> convert to UTC time
        !           186: grade  grade(x) double x; <[i]plot.h>
        !           187: gtty   gtty(fd, bp) struct sgttyb *bp; <sgtty.h> control device
        !           188: hotdog hotdog(p0, p1, rad, c) Point p0, p1; Color c; draw a line
        !           189: hsv2rgb        Color hsv2rgb(hsva) Hsva hsva; convert hexcone+a to rgba
        !           190: hypot  double hypot(x, y) double x, y; <math.h> Euclidean distance
        !           191: if     if ( expression ) statement  or  if ( expression ) statement else statement
        !           192: ihypot ihypot(a, b) (int)sqrt(a*a+b*b)
        !           193: index  char *index(s, c) char *s, c; return ptr to first c in s (0 if not found)
        !           194: infont Font *infont(inch) int (*inch)(); <font.h> read a font using (*inch)() to get data
        !           195: initedge       initedge(n) initialize the hotdog line edge table
        !           196: inset  Rectangle inset(r, n) Rectangle r; int n; inset a Rectangle for a border
        !           197: ioctl  ioctl(fd, request, bp) struct sgttyb? *bp; <sgtty.h> control device
        !           198: isalnum        isalnum(c) <ctype.h> is c alphabetic or numeric?
        !           199: isalpha        isalpha(c) <ctype.h> is c alphabetic?
        !           200: isascii        isascii(c) <ctype.h> is c a 7-bit ascii character?
        !           201: isatty isatty(fd) return non-zero iff fd is a tty (i.e. if gtty works)
        !           202: iscntrl        iscntrl(c) <ctype.h> is c a control character or del?
        !           203: isdigit        isdigit(c) <ctype.h> is c a decimal digit?
        !           204: islower        islower(c) <ctype.h> is c lower case alphabetic?
        !           205: isprint        isprint(c) <ctype.h> is c a printing character?
        !           206: ispunct        ispunct(c) <ctype.h> is c a punctuation character? (!isalnum(c) && !iscntrl(c))
        !           207: isspace        isspace(c) <ctype.h> is c white space (sp, ht, cr, nl, ff)?
        !           208: isupper        isupper(c) <ctype.h> is c upper case alphabetic?
        !           209: j0     double j0(x) double x; <math.h> 0th order Bessel function of the first kind
        !           210: j1     double j1(x) double x; <math.h> 1st order Bessel function of the first kind
        !           211: jarc   void jarc(p0, p1, p2, f) Point p0, p1, p2; Code f; draw scaled circular arc
        !           212: jcircle        void jcircle(p, r, f) Point p; int r; Code f; draw scaled circle
        !           213: jdisc  void jdisc(p, r, f) Point p; int r; Code f; draw scaled disc
        !           214: jelarc void jelarc(p0, a, b, p1, p2, f) Point p0, p1, p2; int a, b; Code f; scaled elarc
        !           215: jeldisc        void jeldisc(p, a, b, f) Point p; int a, b; Code f; draw scaled ellipse+interior
        !           216: jellipse       void jellipse(p, a, b, f) Point p; int a, b; Code f; draw scaled ellipse
        !           217: jline  void jline(p, f) Point p; Code f; draw a scaled relative line
        !           218: jlineto        void jlineto(p, f) Point p; Code f; draw a scaled absolute line
        !           219: jmove  void jmove(p) Point p; scaled relative move
        !           220: jmoveto        void jmoveto(p) Point p; scaled absolute move
        !           221: jn     double jn(n, x) double x; <math.h> nth order Bessel function of the first kind
        !           222: jpoint void jpoint(p, f) Point p; Code f; draw scaled single pixel on display
        !           223: jrectf void jrectf(r, f) Rectangle r; Code f; scaled rectangle function on display
        !           224: jsegment       void jsegment(p, q, f) Point p, q; Code f; draw a scaled line segment
        !           225: jstring        Point jstring(s) char *s; jstring: draw string on display at scaled current point
        !           226: jstrwidth      int jstrwidth(s) char *s; <font.h> width of character string in layer coordinates
        !           227: jtexture       void jtexture(r,t,f)Rectangle r;Texture *t;Code f;draw texture in rectangle on display
        !           228: kbdchar        int kbdchar(); read character from keyboard, -1 if no characters have been typed
        !           229: kill   kill(pid, sig) send signal to a process
        !           230: killpg killpg(pgrp, sig) send signal to a process or a process group
        !           231: l3tol  l3tol(lp, cp, n) long *lp; char *cp; convert 3-byte integers to longs
        !           232: lcm    long lcm(a, b) integer least common multiple
        !           233: ldexp  double ldexp(v, exp) double v; reconstruct double from fraction and exponent
        !           234: line   line(x1, y1, x2, y2) double x1, y1, x2, y2; <[i]plot.h>
        !           235: link   link(fn1, fn2) char *fn1, *fn2; link to a file
        !           236: localtime      struct tm *localtime(clock) long *clock; <time.h> convert to local time
        !           237: log    double log(x) double x; <math.h> natural logarithm
        !           238: log10  double log10(x) double x; <math.h> common logarithm
        !           239: longjmp        longjmp(env, val) jmp_buf env; <setjmp.h> non-local goto
        !           240: lrand  long lrand() random integer between 0 and 2^31-1
        !           241: lseek  long lseek(fd, offset, whence) long offset; move read/write pointer
        !           242: lspline        lspline(n,  arr) int n[]; double *arr[]; <[i]plot.h>
        !           243: lstat  lstat(fn, bp) char *fn; struct stat *bp; get file status
        !           244: ltol3  ltol3(cp, lp, n) char *cp; long *lp; convert longs to 3-byte integers
        !           245: malloc char *malloc(size) unsigned size; allocate main memory
        !           246: max    max(a, b) integer maximum
        !           247: menuhit        int menuhit(m, n) Menu *m; int n; present user with menu and get selection
        !           248: min    min(a, b) integer minimum
        !           249: mknod  mknod(fn, mode, ad) char *fn; make a directory or a special file
        !           250: mktemp char *mktemp(template) char *template; make a unique file name
        !           251: modf   double modf(v, iptr) double v, *iptr; return fraction, store integer part
        !           252: monitor        monitor(lowpc, highpc, bp, size, nfunc) int (*lowpc)(), (*highpc)(); short bp[]; prepare execution profile
        !           253: mount  mount(special, fn, rwflag) char *special, *fn;  mount file system
        !           254: mouse  struct {Point xy; Point jxy; int buttons;} mouse;
        !           255: move   move(x, y) double x, y; <[i]plot.h>
        !           256: mul    Point mul(p, a) Point p; int a; multiply p.x and p.y by a
        !           257: muldiv int muldiv(a, b, c) int a, b, c; calculate (a*b)/c accurately
        !           258: nap    void nap(nticks) int nticks; sleep for time in 60ths of a second
        !           259: nextkey        datum nextkey(key) datum key; get the key following the given key -ldbm
        !           260: nice   nice(incr) set program priority
        !           261: nlist  nlist(fn, nl) char *fn; struct nlist nl[]; <nlist.h> get entries from name list
        !           262: norm   int norm(x, y, z) int x, y, z; return norm of three-dimensional vector
        !           263: normalize      normalize(p) struct place *p; convert to normal map coordinates
        !           264: nrand  nrand(x) random integer between 0 and x-1
        !           265: open   open(fn, mode) char *fn; open for reading or writing
        !           266: opendir        DIR *opendir(fn) char *fn; <ndir.h> open a directory
        !           267: openpicr       PICFILE *openpicr(f) char *f; open a picture file to read
        !           268: openpicw       PICFILE *openpicw(f, type, r, nchan, argv, cmap) char *f; Rectangle r; char **argv; unsigned char *cmap; open a picture file to write
        !           269: openpl openpl(s) char *s; <[i]plot.h>
        !           270: orient orient(lat, lon, rot) float lat, lon, rot; set map normalization parameters
        !           271: outfont        int outfont(f, ouch) Font *f; int (*ouch)(); <font.h> write font via (*ouch)()
        !           272: own    int own();  return bit vector indicating which resources have data
        !           273: parabola       parabola(x1, y1, x2, y2, x3, y3) double x1, y1, x2, y2, x3, y3; <[i]plot.h>
        !           274: pause  pause() stop until signal
        !           275: pclose pclose(f) FILE *f; <stdio.h> close f and wait for command
        !           276: pen    pen(s) char *s; <[i]plot.h>
        !           277: perror perror(s) char *s; print system error message
        !           278: pipe   pipe(fd) int fd[2]; create an interprocess channel
        !           279: pizza  pizza(p, rad, c) Point p; Color c; draw a disc
        !           280: point  point(x, y) double dx, dy; <[i]plot.h>
        !           281: point  void point(b, p, f) Bitmap *b; Point p; Code f; draw a single pixel in a bitmap
        !           282: poly   poly(n,  arr) int n[]; double *arr[]; <[i]plot.h>
        !           283: popen  FILE *popen(cmd, type) char *cmd, *type; <stdio.h> initiate I/O to/from a process
        !           284: poppyseed      poppyseed(p, c) Point p; Color c; draw a point-spot
        !           285: pow    double pow(x, y) double x, y; <math.h> power
        !           286: ppause ppause() <[i]plot.h>
        !           287: printf printf(fmt [, arg]...) char *fmt; <stdio.h> formatted output conversion
        !           288: profil profil(bp, size, offset, scale) char *bp; execution time profile
        !           289: project        project(p, xptr, yptr) struct place p; float *xptr, *yptr; map projection
        !           290: ptinrect       int ptinrect(p, r) Point p; Rectangle r; is p within a r?
        !           291: ptopen ptopen(fn) char *fn; find and open a pseudo-terminal file
        !           292: ptrace ptrace(request, pid, ad, data) int *ad; <signal.h> process trace
        !           293: putc   int putc(c, f) char c; FILE *f; <stdio.h> put character on a stream
        !           294: putchar        putchar(c) <stdio.h> put character on stdout
        !           295: puts   puts(s) char *s; <stdio.h> put a string on stdout
        !           296: putw   putw(w, f) FILE *f; <stdio.h> put word on a stream
        !           297: pwdecode       struct passwd *pwdecode(p) char *p; decode given password file entry
        !           298: qsort  qsort(base, nel, width, compar) char *base; int (*compar)(); quicker sort
        !           299: raddp  Rectangle raddp(r, p) Rectangle r; Point p; add p to r.origin and r.corner
        !           300: rand   rand() random integer between 0 and 32767
        !           301: range  range(x1, y1, x2, y2) double x1, y1, x2, y2; <[i]plot.h>
        !           302: rcanon Rectangle rcanon(r) Rectangle r; swap to make r.or.[xy]<=r.co.[xy]
        !           303: rcvchar        int rcvchar(); receive character from host, returns -1 if none available
        !           304: rdiv   Rectangle rdiv(r, d) Rectangle r; divide r.*.[xy] by d
        !           305: rdivp  Rectangle rdivp(r, p) Rectangle r; Point p; divide r.*.x by p.x, r.*.y by p.y
        !           306: re_comp        char *re_comp(s) char *s; compile regular expression
        !           307: re_exec        re_exec(s) char *s; match regular expression
        !           308: read   read(fd, bp, size) char *bp; read from file
        !           309: readdir        struct direct *readdir(dirp) DIR *dirp; <ndir.h> read a directory entry
        !           310: readlink       readlink(fn, bp, size) char *fn, *bp; read a symbolic link
        !           311: readmap        readmap(m) unsigned char m[256][3]; read the framebuffer's colormap
        !           312: readpic        readpic(f, p) PICFILE *f; unsigned char *p; read a line from a picture file
        !           313: readrun        readrun(f, b) PICFILE *f, unsigned char *b; read a run from a picture file
        !           314: realloc        char *realloc(ptr, size) char *ptr; unsigned size; change size of allocated memory
        !           315: realtime       long realtime(); return time since mux was booted in 60ths of a second.
        !           316: reboot reboot(howto) <sys/reboot.h> reboot system or halt processor
        !           317: rectXrect      int rectXrect(r, s) Rectangle r, s; do r and s overlap?
        !           318: rectclip       int rectclip(rp, s) Rectangle *rp, s; clip *rp and s, returns non-zero if non-null
        !           319: rectf  void rectf(b, r, f) Bitmap *b; Rectangle r; Code f; do function on rectangle in b
        !           320: request        void request(r) int r; request I/O resources
        !           321: restore        restore() <[i]plot.h>
        !           322: rewind rewind(stream) <stdio.h> reposition a stream to the beginning
        !           323: rewinddir      rewinddir(dirp) DIR *dirp; <ndir.h> seek to the beginning of a directory
        !           324: rgb2hsv        Hsva rgb2hsv(rgba) Color rgba; convert rgba to hexcone+a
        !           325: rindex char *rindex(s, c) char *s, c; return ptr to last c in s (0 if not found)
        !           326: rmove  rmove(dx, dy) double dx, dy; <[i]plot.h>
        !           327: rmul   Rectangle rmul(r, d) Rectangle r; multiply r.*.[xy] by d
        !           328: rmulp  Rectangle rmulp(r, p) Rectangle r; Point p; multiply r.*.x by p.x, r.*.y by p.y
        !           329: rol    int rol(x, n) int x, n; rotate x n bits left
        !           330: ror    int ror(x, n) int x, n; rotate x n bits right
        !           331: rsubp  Rectangle rsubp(r, p) Rectangle r; Point p; subtract p from r.origin and r.corner
        !           332: rtransform     Rectangle rtransform(r) Rectangle r; transform r from layer to screen coordinates
        !           333: rvec   rvec(dx, dy) double dx, dy; <[i]plot.h>
        !           334: save   save() <[i]plot.h>
        !           335: sbox   sbox(x1, y1, x2, y2) double x1, y1, x2, y2; <[i]plot.h>
        !           336: sbrk   char *sbrk(inc) change core allocation incrementally
        !           337: scanf  scanf(fmt [, ptr]...) char *fmt; <stdio.h> formatted input conversion
        !           338: screenswap     void screenswap(b, r, s) Bitmap *b; Rectangle r, s; swap screen rectangle and bitmap
        !           339: seekdir        seekdir(dirp, loc) DIR *dirp; long loc; <ndir.h> seek in a directory
        !           340: segment        void segment(b, p, q, f) Bitmap *b; Point p, q; Code f; draw a line segment in a bitmap
        !           341: select select(nfd, rdfd, wrfd, milli); fd_set *rdfd, *wrfd; <sys/types.h> i/o multiplexing
        !           342: sendchar       void sendchar(x) int x; send a character to the host
        !           343: sendnchars     void sendnchars(n, p) int n; char *p; send n characters to host
        !           344: setbuf setbuf(f, bp) FILE *f; char *bp; <stdio.h> assign buffering to a stream
        !           345: setfsend       int setfsend() <fstab.h> open and rewind /etc/fstab
        !           346: setgid setgid(gid) set group id
        !           347: setjmp setjmp(env) jmp_buf env; <setjmp.h> prepare for non-local goto
        !           348: setkey setkey(key) char *key; set key for DES encryption
        !           349: setpgrp        setpgrp(pid, pgrp) set process group
        !           350: setpwent       setpwent() <pwd.h> rewind /etc/passwd
        !           351: setuid setuid(uid) set user id
        !           352: sgn    sgn(a) integer sign
        !           353: signal (*signal(sig, func))() void (*func)(); <signal.h> catch or ignore signals
        !           354: sigsys (*sigsys(sig, func))() void (*func)(); <signal.h> catch or ignore signals
        !           355: sin    double sin(x) double x; <math.h>
        !           356: sin    int sin(d) int d; sine of d in degrees
        !           357: sinh   double sinh(x) double x; <math.h> hyperbolic sine
        !           358: skippic        skippic(f) PICFILE *f; skip a scanline in a picture file
        !           359: sleep  sleep(seconds) unsigned seconds; suspend execution for interval
        !           360: sleep  void sleep(nticks) int nticks; sleep for time in 60ths of a second
        !           361: snare  fbreg *snare(n) acquire a framebuffer and return a pointer to its registers
        !           362: splice splice(fd1, fd2, flag) connect two stream file descriptors
        !           363: spline spline(n,  arr) int n[]; double *arr[]; <[i]plot.h>
        !           364: sprintf        sprintf(s, format [, arg]...) char *s, format; <stdio.h> formatted output to string
        !           365: sqrt   double sqrt(x) double x; <math.h> square root
        !           366: sqrt   int sqrt(x) long x; integer square root
        !           367: srand  srand(seed) initialize random number generator (seed between 0 and 32767?)
        !           368: sscanf sscanf(s, fmt [, ptr]...) char *s, *fmt; <stdio.h> formatted input conversion
        !           369: stat   stat(fn, bp) char *fn; struct stat *bp; <sys/types.h> <sys/stat.h> get file status
        !           370: stderr FILE *stderr; <stdio.h> buffered diagnostid output stream
        !           371: stdin  FILE *stdin; <stdio.h> buffered standard input stream
        !           372: stdout FILE *stdout; <stdio.h> buffered standard output stream
        !           373: stime  stime(tp) long *tp; set time
        !           374: store  store(key, content) datum key, content; store a record in a data base -ldbm
        !           375: strcat char *strcat(d, s) char *d, *s; append s to d
        !           376: strchr char *strchr(s, c) char *s, c; return ptr to first c in s (0 if not found)
        !           377: strcmp strcmp(s, t) char *s, *t; compare s to t. <0 if s<t, >0 if s>t, ==0 if s==t
        !           378: strcpy char *strcpy(d, s) char *d, *s; copy s to d
        !           379: string Point string(ft, s, b, p, f) Font *ft; char *s; Bitmap *b; Point p; Code f; <font.h> draw string in bitmap
        !           380: strlen strlen(s) char *s; return length of s (not including the nul)
        !           381: strncat        char *strncat(d, s, n) char *d, *s; append at most n chars of s to d
        !           382: strncmp        strncmp(s, t, n) char *s, t; compare s to t. <0 if s<t, >0 if s>t, ==0 if s==t
        !           383: strncpy        char *strncpy(d, s, n) char *d, *s; copy at most n chars of s to d
        !           384: strrchr        char *strrchr(s, c) char *s, c; return ptr to last c in s (0 if not found)
        !           385: strwidth       int strwidth(f, s) Font *f; char *s; <font.h> width of character string
        !           386: stty   stty(fd, bp) struct sgttyb *bp; <sgtty.h> control device
        !           387: sub    Point sub(p, q) Point p, q; subtract p-q
        !           388: swab   swab(from, to, nbytes) char *from, *to; swap bytes
        !           389: symlink        symlink(fn1, fn2) char *fn1, *fn2; link to a file symbolically
        !           390: sync   sync() update super-block
        !           391: syscall        syscall(number, arg, ...) indirect system call
        !           392: system system(s) char *s; issue a shell command
        !           393: tanh   double tanh(x) double x; <math.h> hyperbolic tangent
        !           394: tell   long tell(fd) read read/write pointer
        !           395: telldir        long telldir(dirp) DIR *dirp; <ndir.h> get a directory's seek pointer
        !           396: text   text(s) char *s; <[i]plot.h>
        !           397: texture        void texture(b, r, t, f) Bitmap *b; Rectangle r; Texture *t; Code f; draw texture in rectangle in bitmap
        !           398: time   time_t time(tloc) time_t *tloc; <sys/types.h> get date and time
        !           399: times  times(bp) struct tms *bp; <sys/types.h> <sys/times.h> get process times
        !           400: timezone       char *timezone(zone, dst) get time zone name
        !           401: trabort        void trabort() abort a B-tree transaction
        !           402: transform      Point transform(p) Point p; transform p from layer to screen coordinates
        !           403: trstart        trstart() start a B-tree transaction
        !           404: ttyname        char *ttyname(fd) returns ptr to name of tty (0 if fd is not a tty)
        !           405: ttyslot        ttyslot() returns number of the entry in /etc/ttys for the control terminal
        !           406: typedef struct {  char *dptr;  int dsize; } datum;
        !           407: umask  umask(complmode) set file creation mode mask
        !           408: umount umount(special) char *special; remove file system
        !           409: uname  uname(name) struct utsname *name; <sys/utsname.h> get system name
        !           410: ungetc ungetc(c, stream) FILE *stream; <stdio.h> push character back into input stream
        !           411: unlink unlink(fn) char *fn; remove directory entry
        !           412: usage  usage(s) char *s; print a usage message
        !           413: utime  utime(fn, timep) char *fn; time_t timep[2]; set file times
        !           414: vadvise        vadvise(param) give advice to paging system
        !           415: valloc char *valloc(size) unsigned size; aligned memory allocator
        !           416: vec    vec(x, y) double x, y; <[i]plot.h>
        !           417: vfork  vfork() spawn new process in a virtual memory efficient way
        !           418: vhangup        vhangup() virtually ``hangup'' the current control terminal
        !           419: 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)
        !           420: vlimit vlimit(resource, value) control maximum system resource consumption
        !           421: vread  vread(fd, bp, size) char *bp; read virtually
        !           422: vswapon        vswapon(fn) char *fn; add a swap device for interleaved paging/swapping
        !           423: vtimes vtimes(par, ch) struct vtimes *par, *ch; get resource utilization information
        !           424: vwrite vwrite(filedes, buffer, nbytes) char *buffer; write (virtually) to file
        !           425: wait   int wait(r) int r; wait for resources.  wait(CPU) lets other processes run
        !           426: wait   wait(status) int *status; wait(0) wait for process to terminate
        !           427: wait3  wait3(status, opt, vtimep) union wait status; struct vtimes *vtimep; wait for process to terminate
        !           428: while  while ( expression ) statement
        !           429: write  write(fd, bp, size) char *bp; write on a file
        !           430: writemap       writemap(m) unsigne char m[256][3]; write the framebuffer's colormap
        !           431: writepic       writepic(f, p) PICFILE *f; unsigned char *p; write a scanline in a picture file
        !           432: y0     double y0(x) double x; <math.h> 0th order Bessel function of the second kind
        !           433: y1     double y1(x) double x; <math.h> 1st order Bessel function of the second kind
        !           434: 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.