Return to helpfile CVS log

Up to [MW Coherent from dump] / coherent / a / usr / lib

coherent

@__DATE__
__DATE__ -- Date of translation


@__FILE__
__FILE__ -- Source file name


@__LINE__
__LINE__ -- Current line within a source file


@__STDC__
__STDC__ -- Mark a conforming translator


@__TIME__
__TIME__ -- Time source file is translated


@_exit
_exit() -- Terminate a program

void _exit(status) int status;

@abort
abort() -- End program immediately

void abort()

@abs
abs() -- Return the absolute value of an integer

int abs(n) int n;

@access
access() -- Check if a file can be accessed in a given mode

#include <access.h>
int access(filename, mode) char *filename; int mode;

@access.h
access.h -- Check accessibility

#include <access.h>

@acct
acct() -- Enable/disable process accounting

acct(file)
char *file;

@acct.h
acct.h -- Format for process-accounting file

#include <acct.h>

@acos
acos() -- Calculate inverse cosine

#include <math.h>
double acos(arg) double arg;

@action.h
action.h -- Describe parsing action and goto tables

#include <action.h>

@alarm
alarm() -- Set a timer

alarm(n)
unsigned n;

@alloc.h
alloc.h -- Define the allocator

#include <sys/alloc.h>

@ar.h
ar.h -- Format for archive files

#include <ar.h>

@ascii.h
ascii.h -- Define non-printable ASCII characters

#include <ascii.h>

@asctime
asctime() -- Convert time structure to ASCII string

#include <time.h>
#include <sys/types.h>
char *asctime(tmp) tm *tmp;

@asin
asin() -- Calculate inverse sine

#include <math.h>
double asin(arg) double arg;

@ASKCC
ASKCC -- Force prompting for CC names

ASKCC=YES/NO

@assert
assert() -- Check assertion at run time

#include <assert.h>
void assert(expression) int expression;

@assert.h
assert.h -- Define assert()

#include <assert.h>

@atan
atan() -- Calculate inverse tangent

#include <math.h>
double atan(arg) double arg;

@atan2
atan2() -- Calculate inverse tangent

double atan2(num, den) double num, den;

@atof
atof() -- Convert ASCII strings to floating point

double atof(string) char * string;

@atoi
atoi() -- Convert ASCII strings to integers

int atoi(string) char *string;

@atol
atol() -- Convert ASCII strings to long integers

long atol(string) char *string;

@auto
auto -- Note an automatic variable


@break
break -- Exit from loop or switch statement


@brk
brk() -- Change size of data area

brk(addr)
char *addr;

@bsearch
bsearch() -- Search an array

#include <stdlib.h>
char *bsearch(key, array, number, size, comparison)
char *key, *array;
size_t number, size;
int (*comparison)();

@buf.h
buf.h -- Buffer header

#include <sys/buf.h>

@cabs
cabs() -- Complex absolute value function

#include <math.h>
double cabs(z) struct { double r, i; } z;

@calloc
calloc() -- Allocate dynamic memory

char *calloc(count, size) unsigned count, size;

@candaddr
candaddr() -- Convert a daddr_t to canonical format

#include <canon.h>
#include <sys/types.h>
void candaddr(s)
daddr_t s;

@candev
candev() -- Convert a dev_t to canonical format

#include <canon.h>
#include <sys/types.h>
void candev(s)
dev_t s;

@canino
canino() -- Convert an ino_t to canonical format

#include <canon.h>
#include <sys/types.h>
void canino(s)
ino_t s;

@canint
canint() -- Convert an int to canonical format

#include <canon.h>
#include <sys/types.h>
void canint(s)
int s;

@canlong
canlong() -- Convert a long to canonical format

#include <canon.h>
#include <sys/types.h>
void canlong(s)
long s;

@canon.h
canon.h -- Portable layout of binary data

#include <canon.h>
#include <sys/types.h>

@canshort
canshort() -- Convert a short to canonical format

#include <canon.h>
#include <sys/types.h>
void canshort(s)
short s;

@cansize
cansize() -- Convert an fsize_t to canonical format

#include <canon.h>
#include <sys/types.h>
void cansize(s)
size_t s;

@cantime
cantime() -- Convert a time_t to canonical format

#include <canon.h>
#include <sys/types.h>
void cantime(s)
time_t s;

@canvaddr
canvaddr() -- Convert a vaddr_t to canonical format

#include <canon.h>
#include <sys/types.h>
void canvaddr(s)
vaddr_t s;

@case
case -- Introduce entry in switch statement


@ceil
ceil() -- Set numeric ceiling

#include <math.h>
double ceil(z) double z;

@char
char -- Data type


@chars.h
chars.h -- Character definitions

#include <chars.h>

@chdir
chdir() -- Change working directory

chdir(directory) char *directory;

@chmod
chmod() -- Change file-protection modes

#include <sys/stat.h>
chmod(file, mode)
char *file; int mode;

@chown
chown() -- Change ownership of a file

chown(file, uid, gid)
char *file;
short uid, gid;

@chroot
chroot() -- Change process's root directory

int chroot(directory)
char *directory;

@clearerr
clearerr() -- Present stream status

#include <stdio.h>
clearerr(fp) FILE *fp;

@close
close() -- Close a file

int close(fd) int fd;

@con.h
con.h -- Configure device drivers

#include <con.h>

@const
const -- Qualify an identifier as not modifiable


@const.h
const.h -- Declare machine-dependent constants

#include <sys/const.h>

@continue
continue -- Force next iteration of a loop


@cos
cos() -- Calculate cosine

#include <math.h>
double cos(radian) double radian;

@cosh
cosh() -- Calculate hyperbolic cosine

#include <math.h>
double cosh(radian) double radian;

@creat
creat() -- Create/truncate a file

int creat(file, mode) char *file; int mode;

@crypt
crypt() -- Encryption using rotor algorithm

char *crypt(key, extra); char *key, *extra;

@ctime
ctime() -- Convert system time to an ASCII string

#include <time.h>
#include <sys/types.h>
char *ctime(timep) time_t *timep;

@ctype.h
ctype.h -- Header file for data tests

#include <ctype.h>

@curses.h
curses.h -- Define functions and macros in curses library

#include <curses.h>

@CWD
CWD -- Current working directory


@default
default -- Default label in switch statement


@deftty.h
deftty.h -- Define default tty settings

#include <sys/deftty.h>

@dir.h
dir.h -- Directory format

#include <dir.h>

@dirent.h
dirent.h -- Define dirent

#include <dirent.h>

@div
div() -- Perform integer division

#include <stdlib.h>
div_t div(numerator, denominator)
int numerator, denominator;

@do
do -- Introduce a loop


@double
double -- Data type


@dumptape.h
dumptape.h -- Define data structures used on dump tapes

#include <dumptape.h>

@dup
dup() -- Duplicate a file descriptor

int dup(fd) int fd;

@dup2
dup2() -- Duplicate a file descriptor

int dup2(fd, newfd) int fd, newfd;

@ebcdic.h
ebcdic.h -- Define manifest constants for non-printable EBCDIC characters

#include <ebcdic.h>

@else
else -- Introduce a conditional statement


@endgrent
endgrent() -- Close group file

#include <grp.h>
endgrent()

@endpwent
endpwent() -- Close password file

#include <pwd.h>
endpwent()

@enum
enum -- Declare a type and identifiers


@ENV
ENV -- File read to set environment


@errno.h
errno.h -- Error numbers used by errno()

#include <errno.h>

@execl
execl() -- Execute a load module

execl(file, arg0, arg1, ..., argn, NULL)
char *file, *arg0, *arg1, ..., *argn;

@execle
execle() -- Execute a load module

execle(file, arg0, arg1, ..., argn, NULL, env)
char *file, *arg0, *arg1, ..., *argn, char *env[];

@execlp
execlp() -- Execute a load module

execlp(file, arg0, arg1, ..., argn, NULL)
char *file, *arg0, *arg1, ..., *argn;

@execv
execv() -- Execute a load module

execv(file, argv)
char *file, *argv[];

@execve
execve() -- Execute a load module

execve(file, argv, env)
char *file, *argv[], *env[];

@execvp
execvp() -- Execute a load module

execvp(file, argv)
char *file, *argv[];

@exit
exit() -- Terminate a program gracefully

void exit(status) int status;

@exp
exp() -- Compute exponent

#include <math.h>
double exp(z) double z;

@extern
extern -- Declare storage class


@fabs
fabs() -- Compute absolute value

#include <math.h>
double fabs(z) double z;

@fblk.h
fblk.h -- Define the disk-free block

#include <sys/fblk.h>

@FCEDIT
FCEDIT -- Editor used by fc command


@fclose
fclose() -- Close a stream

#include <stdio.h>
int fclose(fp) FILE *fp;

@fcntl
fcntl() -- Control open files

int fcntl(fd, command, arg)
int fd, cmd;

@fcntl.h
fcntl.h -- Manifest constants for file-handling functions

#include <sys/fcntl.h>

@fd.h
fd.h -- Declare file-descriptor structure

#include <sys/fd.h>

@fdioctl.h
fdioctl.h -- Control floppy-disk I/O

#include <sys/fdioctl.h>

@fdisk.h
fdisk.h -- Fixed-disk constants and structures

#include <sys/fdisk.h>

@fdopen
fdopen() -- Open a stream for standard I/O

#include <stdio.h>
FILE *fdopen(fd, type) int fd; char *type;

@feof
feof() -- Discover stream status

#include <stdio.h>
int feof(fp) FILE *fp;

@ferror
ferror() -- Discover stream status

#include <stdio.h>
int ferror(fp) FILE *fp;

@fflush
fflush() -- Flush output stream's buffer

#include <stdio.h>
int fflush(fp) FILE *fp;

@fgetc
fgetc() -- Read character from stream

#include <stdio.h>
int fgetc(fp) FILE *fp;

@fgets
fgets() -- Read line from stream

#include <stdio.h>
char *fgets(s, n, fp) char *s; int n; FILE *fp;

@fgetw
fgetw() -- Read integer from stream

#include <stdio.h>
int fgetw(fp) FILE *fp;

@fileno
fileno() -- Get file descriptor

#include <stdio.h>
int fileno(fp) FILE *fp;

@filsys.h
filsys.h -- Structures and constants for super block

#include <sys/filsys.h>

@float
float -- Data type


@floor
floor() -- Set a numeric floor

#include <math.h>
double floor(z) double z;

@fopen
fopen() -- Open a stream for standard I/O

#include <stdio.h>
FILE *fopen (name, type) char *name, *type;

@for
for -- Control a loop

for(initialization; endcondition; modification)

@fork
fork() -- Create a new process

fork()

@fperr.h
fperr.h -- Constants used with floating-point exception codes

#include <fperr.h>

@fprintf
fprintf() -- Print formatted output into file stream

int fprintf(fp, format, [arg1, .... argN])
FILE *fp; char *format;
[data type] arg1, ... argN;

@fputc
fputc() -- Write character into file stream

#include <stdio.h>
int fputc(c, fp) char c; FILE *fp;

@fputs
fputs() -- Write string into file stream

#include <stdio.h>
int fputs(string, fp) char *string; FILE *fp;

@fputw
fputw() -- Write an integer into a stream

#include <stdio.h>
int fputw(word, fp) int word; FILE *fp;

@fread
fread() -- Read data from file stream

#include <stdio.h>
int fread(buffer, size, n, fp)
char *buffer; unsigned size, n; FILE *fp;

@free
free() -- Return dynamic memory to free memory pool

void free(ptr) char *ptr;

@freopen
freopen() -- Open file stream for standard I/O

#include <stdio.h>
FILE *freopen (name, type, fp)
char *name, *type; FILE *fp;

@frexp
frexp() -- Separate fraction and exponent

double frexp(real, ep) double real; int *ep;

@fscanf
fscanf() -- Format input from a file stream

#include <stdio.h>
int fscanf(fp, format, arg1, ... argN)
FILE *fp; char *format;
[data type] *arg1, ... *argN;

@fseek
fseek() -- Seek on file stream

#include <stdio.h>
int fseek(fp, where, how)
FILE *fp; long where; int how;

@fstat
fstat() -- Find file attributes

#include <sys/stat.h>
fstat(descriptor, statptr) int descriptor; struct stat *statptr;

@ftell
ftell() -- Return current position of file pointer

#include <stdio.h>
long ftell(fp) FILE *fp;

@ftime
ftime() -- Get the current time from the operating system

#include <sys/timeb.h>
ftime(tbp) struct timeb *tbp;

@fwrite
fwrite() -- Write into file stream

#include <stdio.h>
int fwrite(buffer, size, n, fp)
char *buffer; unsigned size, n; FILE *fp;

@gcd
gcd() -- Set variable to greatest common divisor

#include <mprec.h>
void gcd(a, b, c)
mint *a, *b, *c;

@getc
getc() -- Read character from file stream

#include <stdio.h>
int getc(fp) FILE *fp;

@getchar
getchar() -- Read character from standard input

#include <stdio.h>
int getchar()

@getegid
getegid() -- Get effective group identifier

getegid()

@getenv
getenv() -- Read environmental variable

char *getenv(VARIABLE) char *VARIABLE;

@geteuid
geteuid() -- Get effective user identifier

geteuid()

@getgid
getgid() -- Get real group identifier

getgid()

@getgrent
getgrent() -- Get group file information

#include <grp.h>
struct group *getgrent();

@getgrgid
getgrgid() -- Get group file information, by group name

#include <grp.h>
struct group *getgrgid(gid);
int gid;

@getgrnam
getgrnam() -- Get group file information, by group id

#include <grp.h>
struct group *getgrnam(gname);
char *gname;

@getlogin
getlogin() -- Get login name

char *getlogin()

@getopt
getopt() -- Get option letter from argv

int getopt(argc, argv, optstring)
int argc;
char **argv;
char *optstring;
extern char *optarg;
extern int optind;

@getpass
getpass() -- Get password with prompting

char *getpass(prompt)
char *prompt;

@getpid
getpid() -- Get process identifier

getpid()

@getpw
getpw() -- Search password file

getpw(uid, line)
short uid;
char *line;

@getpwent
getpwent() -- Get password file information

#include <pwd.h>
struct passwd *getpwent()

@getpwnam
getpwnam() -- Get password file information, by name

#include <pwd.h>
struct passwd *getpwnam(uname)
char *uname;

@getpwuid
getpwuid() -- Get password file information, by id

#include <pwd.h>
struct passwd *getpwuid(uid)
int uid;

@gets
gets() -- Read string from standard input

#include <stdio.h>
char *gets(buffer) char *buffer;

@getuid
getuid() -- Get real user identifier

getuid()

@getw
getw() -- Read word from file stream

#include <stdio.h>
int getw(fp) FILE *fp;

@getwd
getwd() -- Get current working directory name

char *getwd()

@gmtime
gmtime() -- Convert system time to calendar structure

#include <time.h>
#include <sys/types.h>
tm *gmtime(timep) time_t *timep;

@goto
goto -- Unconditionally jump within a function


@grp.h
grp.h -- Declare group structure

#include <grp.h>

@gtty
gtty() -- Device-dependent control

#include <sgtty.h>
int gtty(fd, sgp)
int fd;
struct sgttyb *sgp;

@hdioctl.h
hdioctl.h -- Control hard-disk I/O

#include <sys/hdioctl.h>

@HOME
HOME -- User's home directory

HOME=home directory

@hypot
hypot() -- Compute hypotenuse of right triangle

#include <math.h>
double hypot(x, y) double x, y;

@if
if -- Introduce a conditional statement


@IFS
IFS -- Characters recognized as white space


@index
index() -- Find a character in a string

char *index(string, c) char *string; char c;

@ino.h
ino.h -- Constants and structures for disk i-nodes

#include <sys/inode.h>

@inode.h
inode.h -- Constants and structures for memory-resident i-nodes

#include <sys/inode.h>

@int
int -- Data type


@io.h
io.h -- Constants and structures used by I/O

#include <sys/io.h>

@ioctl
ioctl() -- Device-dependent control

ioctl(fd, command, info)
int fd, command;
char *info;

@ipc.h
ipc.h -- Definitions for process communications

#include <sys/ipc.h>

@isalnum
isalnum() -- Check if a character is a number or letter

#include <ctype.h>
int isalnum(c) int c;

@isalpha
isalpha() -- Check if a character is a letter

#include <ctype.h>
int isalpha(c) int c;

@isascii
isascii() -- Check if a character is an ASCII character

#include <ctype.h>
int isascii(c) int c;

@isatty
isatty() -- Check if a device is a terminal

int isatty(fd) int fd;

@iscntrl
iscntrl() -- Check if a character is a control character

#include <ctype.h>
int iscntrl(c) int c;

@isdigit
isdigit() -- Check if a character is a numeral

#include <ctype.h>
int isdigit(c) int c;

@islower
islower() -- Check if a character is a lower-case letter

#include <ctype.h>
int islower(c) int c;

@ispos
ispos() -- Return if variable is positive or negative

#include <mprec.h>
int ispos(a)
mint *a;

@isprint
isprint() -- Check if a character is printable

#include <ctype.h>
int isprint(c) int c;

@ispunct
ispunct() -- Check if a character is a punctuation mark

#include <ctype.h>
int ispunct(c) int c;

@isspace
isspace() -- Check if a character prints white space

#include <ctype.h>
int isspace(c) int c;

@isupper
isupper() -- Check if a character is an upper-case letter

#include <ctype.h>
int isupper(c) int c;

@itom
itom() -- Create a multiple-precision integer

#include <mprec.h>
mint *itom(n)
int n;

@j0
j0() -- Compute Bessel function

#include <math.h>
double j0(z) double z;

@j1
j1() -- Compute Bessel function

#include <math.h>
double j1(z) double z;

@jn
jn() -- Compute Bessel function

#include <math.h>
double jn(n, z) int n; double z;

@kill
kill() -- Kill a system process

#include <signal.h>
kill(pid, sig)
int pid, sig;

@KSH_VERSION
KSH_VERSION -- List current version of Korn shell


@l.out.h
l.out.h -- Object file format

#include <l.out.h>

@l3tol
l3tol() -- Convert file system block number to long integer

l3tol(lp, l3p, n)
long *lp;
char *l3p;
unsigned n;

@LASTERROR
LASTERROR -- Program that last generated an error

LASTERROR=program name

@ldexp
ldexp() -- Combine fraction and exponent

double ldexp(f, e) double f; int e;

@ldiv
ldiv() -- Perform long integer division

#include <stdlib.h>
ldiv_t ldiv(numerator, denominator)
long numerator, denominator;

@libraries
libraries -- Overview


@limits.h
limits.h -- Define numerical limits

#include <limits.h>

@link
link() -- Create a link

link(old, new)
char *old, *new;

@localtime
localtime() -- Convert system time to calendar structure

#include <time.h>
#include <sys/types.h>
tm *localtime(timep) time_t *timep;

@log
log() -- Compute natural logarithm

#include <math.h>
double log(z) double z;

@log10
log10() -- Compute common logarithm

#include <math.h>
double log10(z) double z;

@long
long -- Data type


@longjmp
longjmp() -- Return from a non-local goto

#include <setjmp.h>
int longjmp(env, rval) jmp_buf env; int rval;

@lpioctl.h
lpioctl.h -- Definitions for line-printer I/O control

#include <sys/lpioctl.h>

@lseek
lseek() -- Set read/write position

long lseek(fd, where, how)
int fd, how; long where;

@ltol3
ltol3() -- Convert long integer to file system block number

ltol3(l3p, lp, n)
char *l3p;
long *lp;
unsigned n;

@machine.h
machine.h -- Machine-dependent definitions

#include <sys/machine.h>

@madd
madd() -- Add multiple-precision integers

#include <mprec.h>
void madd(a, b, c)
mint *a, *b, *c;

@malloc
malloc() -- Allocate dynamic memory

char *malloc(size) unsigned size;

@malloc.h
malloc.h -- Definitions for memory-allocation functions

#include <sys/malloc.h>

@math.h
math.h -- Declare mathematics functions

#include <math.h>

@mathematics library
mathematics library -- Overview


@mcmp
mcmp() -- Compare multiple-precision integers

#include <mprec.h>
int mcmp(a, b)
mint *a, *b;

@mcopy
mcopy() -- Copy a multiple-precision integer

#include <mprec.h>
void mcopy(a, b)
mint *a, *b;

@mdata.h
mdata.h -- Define machine-specific magic numbers

#include <sys/mdata.h>

@mdiv
mdiv() -- Divide multiple-precision integers

#include <mprec.h>
void mdiv(a, b, q, r)
mint *a, *b, *q, *r;

@memccpy
memccpy() -- Copy one region of memory into another up to a requested character

#include <string.h>
char *memccpy(dest, src, c, n)
char *dest, *src; unsigned int c, n;

@memchr
memchr() -- Search a region of memory for a character

#include <string.h>
char *memchr(region, character, n)
char *region; int character; unsigned int n;

@memcmp
memcmp() -- Compare two regions

#include <string.h>
int memcmp(region1, region2, count)
char *region1; char *region2; unsigned int count;

@memcpy
memcpy() -- Copy one region of memory into another

#include <string.h>
char *memcpy(region1, region2, n)
char *region1; char *region2; unsigned int n;

@memmove
memmove() -- Copy region of memory into area it overlaps

#include <string.h>
char *memmove(region1, region2, count)
char *region1, char *region2, unsigned int count;

@memok
memok() -- Test if the arena is corrupted

memok();

@memset
memset() -- Fill an area with a character

#include <string.h>
char *memset(buffer, character, n)
char *buffer; int character; unsigned int n;

@min
min() -- Read multiple-precision integer from stdin

#include <mprec.h>
void min(a)
mint *a;

@minit
minit() -- Condition global or auto multiple-precision integer

#include <mprec.h>
void minit(a)
mint *a;

@mintfr
mintfr() -- Free a multiple-precision integer

#include <mprec.h>
void mintfr(a)
mint *a;

@mitom
mitom() -- Reinitialize a multiple-precision integer

#include <mprec.h>
void mitom(n, a)
mint *a; int n;

@mknod
mknod() -- Create a special file

#include <sys/ino.h>
#include <sys/stat.h>
mknod(name, mode, addr)
char *name; int mode, addr;

@mktemp
mktemp() -- Generate a temporary file name

char *mktemp(pattern) char *pattern;

@mneg
mneg() -- Negate multiple-precision integer

#include <mprec.h>
void mneg(a, b)
mint *a, *b;

@mnttab.h
mnttab.h -- Structure for mount table

#include <mnttab.h>

@modf
modf() -- Separate integral part and fraction

double modf(real, ip) double real, *ip;

@mon.h
mon.h -- Read profile output files

#include <mon.h>

@mount
mount() -- Mount a file system

#include <sys/mount.h>
#include <sys/filsys.h>
mount (special, name,flag)
char *special, *name; int flag;

@mount.h
mount.h -- Define the mount table

#include <sys/mount.h>

@mout
mout() -- Write multiple-precision integer to stdout

#include <mprec.h>
void mout(a)
mint *a;

@mprec.h
mprec.h -- Multiple-precision arithmetic

#include <mprec.h>

@msg.h
msg.h -- Definitions for message facility

#include <sys/msg.h>

@msgctl
msgctl() -- Message control operations

#include <sys/msg.h>
int msgctl(msqid, cmd, buf)
int msqid; int cmd; struct msqid_ds *buf;

@msgget
msgget() -- Get message queue

#include <sys/msg.h>
msgget(key, msgflg)
key_t key; int msgflg;

@msgrcv
msgrcv() -- Receive a message

#include <sys/msg.h>
msgrcv(msqid, msgp, msgsz, msgtyp, msgflg)
int msqid, msgsz, msgflg; struct msgbuf *msgp; long msgtyp;

@msgsnd
msgsnd() -- Send a message

#include <sys/msg.h>
msgsnd(msqid, msgp, msgsz, msgflg)
int msqid, msgsz, msgflg; struct msgbuf *msgp;

@msig.h
msig.h -- Machine-dependent signals

#include <signal.h>

@msqrt
msqrt() -- Compute square root of multiple-precision integer

#include <mprec.h>
void msqrt(a, b, r)
mint *a, *b, *r;

@msub
msub() -- Subtract multiple-precision integers

#include <mprec.h>
void msub(a, b, c)
mint *a, *b, *c;

@mtab.h
mtab.h -- Currently mounted file systems

#include <mtab.h>

@mtioctl.h
mtioctl.h -- Magnetic-tape I/O control

#include <sys/mtioctl.h>

@mtoi
mtoi() -- Convert multiple-precision integer to integer

#include <mprec.h>
int mtoi(a)
mint *a;

@mtos
mtos() -- Convert multiple-precision integer to string

#include <mprec.h>
char *mtos(a) mint *a;

@mtype
mtype() -- Return symbolic machine type

#include <mtype.h>
char *mtype(type)
int type;

@mtype.h
mtype.h -- List processor code numbers

#include <mtype.h>

@mult
mult() -- Multiply multiple-precision integers

#include <mprec.h>
void mult(a, b, c)
mint *a, *b, *c;

@mvfree
mvfree() -- Free multiple-precision integer

#include <mprec.h>
void mvfree(a)
mint *a;

@n.out.h
n.out.h -- Define n.out file structure

#include <n.out.h>

@nlist
nlist() -- Symbol table lookup

#include <l.out.h>
int nlist(file, nlp)
char *file;
struct nlist *nlp;

@notmem
notmem() -- Check if memory is allocated

int notmem(ptr);
char *ptr;

@open
open() -- Open a file

int open(file, type) char *file; int type;

@PAGER
PAGER -- Specify Output Filter

PAGER=command options

@param.h
param.h -- Define machine-specific parameters

#include <sys/param.h>

@PATH
PATH -- Directories that hold executable files


@path
path() -- Path name for a file

#include <path.h>
#include <stdio.h>
char *path(path, filename, mode);
char *path, *filename;
int mode;

@path.h
path.h -- Define/declare constants and functions used with path

#include <path.h>

@pause
pause() -- Wait for signal

int pause()

@pclose
pclose() -- Close a pipe

#include <stdio.h>
int pclose(fp)
FILE *fp;

@perror
perror() -- System call error messages

#include <errno.h>
perror(string)
char *string; extern int sys_nerr; extern char *sys_errlist[];

@pipe
pipe() -- Open a pipe

int pipe(fd)
int fd[2];

@pnmatch
pnmatch() -- Match string pattern

int pnmatch(string, pattern, flag)
char *string, *pattern; int flag;

@poll.h
poll.h -- Define structures/constants used with polling devices

#include <sys/poll.h>

@popen
popen() -- Open a pipe

#include <stdio.h>
FILE *popen(command, how)
char *command, *how;

@pow
pow() -- Compute a power of a number

#include <math.h>
double pow(z, x) double z, x;

@printf
printf() -- Print formatted text

int printf(format [,arg1, .... argN])
char *format; [data type] arg1, ... argN;

@proc.h
proc.h -- Define structures/constants used with processes

#include <sys/proc.h>

@PS1
PS1 -- User's default prompt

PS1=prompt

@PS2
PS2 -- Prompt when user continues command onto additional lines

PS2=prompt

@ptrace
ptrace() -- Trace process execution

#include <signal.h>
int ptrace(command, pid, location, value)
int command, pid, *location, value;

@putc
putc() -- Write character into stream

#include <stdio.h>
int putc(c, fp) char c; FILE *fp;

@putchar
putchar() -- Write a character onto the standard output

#include <stdio.h>
int putchar(c) char c;

@puts
puts() -- Write string onto standard output

#include <stdio.h>
int puts(string) char *string

@putw
putw() -- Write word into stream

#include <stdio.h>
int putw(word, fp) int word; FILE *fp;

@pwd.h
pwd.h -- Declare password structure

#include <pwd.h>

@qsort
qsort() -- Sort arrays in memory

void qsort(data, n, size, comp) char *data; int n, size; int (*comp)();

@rand
rand() -- Generate pseudo-random numbers

int rand()

@ranlib
ranlib -- Definition


@read
read() -- Read from a file

int read(fd, buffer, n) int fd; char *buffer; int n;

@readonly
readonly -- Storage class


@realloc
realloc() -- Reallocate dynamic memory

char *realloc(ptr, size) char *ptr; unsigned size;

@register
register -- Storage class


@return
return -- Return a value and control to calling function


@rewind
rewind() -- Reset file pointer

#include <stdio.h>
int rewind(fp) FILE *fp;

@rindex
rindex() -- Find a character in a string

char *rindex(string, c) char *string; char c;

@rpow
rpow() -- Raise multiple-precision integer to power

#include <mprec.h>
void rpow(a, b, c)
mint *a, *b, *c;

@sbrk
sbrk() -- Increase a program's data space

char *sbrk(increment) unsigned int increment;

@scanf
scanf() -- Accept and format input

#include <stdio.h>
int scanf(format, arg1, ... argN)
char *format; [data type] *arg1, ... *argN;

@sched.h
sched.h -- Define constants used with scheduling

#include <sys/sched.h>

@sdiv
sdiv() -- Divide multiple-precision integers

#include <mprec.h>
void sdiv(a, n, q, ip)
mint *a, *q; int n, *ip;

@SECONDS
SECONDS -- Number of seconds since current shell started


@seg.h
seg.h -- Definitions used with segmentation

#include <seg.h>

@sem.h
sem.h -- Definitions used by semaphore facility

#include <sys/sem.h>

@semctl
semctl() -- Control semaphore operations

#include <sys/sem.h>
semctl(semid, semnum, cmd, arg)
int semid, cmd, semnum;
union semun {
        int val;
        struct semid_ds *buf;
        unsigned short array[];
} arg;

@semget
semget() -- Get a set of semaphores

#include <sys/sem.h>
semget(key, nsems, semflg)
key_t key; int nsems, semflg;

@semop
semop() -- Perform semaphore operations

#include <sys/sem.h>
semop(semid, sops, nsops)
int semid, nsops; struct sembuf(sops)[];

@setbuf
setbuf() -- Set alternative stream buffers

#include <stdio.h>
void setbuf(fp, buffer) FILE *fp; char *buffer;

@setgid
setgid() -- Set group id and user id

int setgid(id) int id;

@setgrent
setgrent() -- Rewind group file

#include <grp.h>
struct group *setgrent();

@setjmp
setjmp() -- Perform non-local goto

#include <setjmp.h>
int setjmp(env) jmp_buf env;

@setjmp.h
setjmp.h -- Define setjmp() and longjmp()

#include <setjmp.h>

@setpwent
setpwent() -- Rewind password file

#include <pwd.h>
setpwent()

@settz
settz() -- Set local time zone

#include <time.h>
#include <sys/types.h>
void settz()
extern long timezone; char *tzname[2][16];

@setuid
setuid() -- Set user id

int setuid(id) int id;

@sgtty.h
sgtty.h -- Definitions used to control terminal I/O

#include <sgtty.h>

@SHELL
SHELL -- Name the default shell

SHELL=shell

@shellsort
shellsort() -- Sort arrays in memory

void shellsort(data, n, size, comp)
char *data; int n, size; int (*comp)();

@shm.h
shm.h -- Definitions used with shared memory

#include <sys/shm.h>

@shmctl
shmctl() -- Control shared-memory operations

#include <sys/shm.h>
shmctl(shmid, cmd, buf)
int shmid, cmd; struct shmid_ds *buf;

@shmget
shmget() -- Get shared-memory segment

#include <sys/shm.h>
shmget(key, size, shmflg)
key_t key; int size, shmflg;

@short
short -- Data type


@signal
signal() -- Specify disposition of a signal

#include <signal.h>
int (*signal(signum, action))()
int signum, (*action)();

@signal.h
signal.h -- Declare signals

#include <signal.h>

@sin
sin() -- Calculate sine

#include <math.h>
double sin(radian) double radian;

@sinh
sinh() -- Calculate hyperbolic sine

#include <math.h>
double sinh(radian) double radian;

@sizeof
sizeof -- Return size of a data element


@sleep
sleep() -- Suspend execution for interval

sleep(seconds)
unsigned seconds;

@sload
sload() -- Load device driver

#include <con.h>
int sload(major, file, conp)
int major; char *file; CON *conp;

@smult
smult() -- Multiply multiple-precision integers

#include <mprec.h>
void smult(a, n, c)
mint *a, *c; int n;

@spow
spow() -- Raise multiple-precision integer to power

#include <mprec.h>
void spow(a, n, b)
mint *a, *b; int n;

@sprintf
sprintf() -- Format output

#include <stdio.h>
int sprintf(string, format [ , arg ] ...)
char *string, *format;

@sqrt
sqrt() -- Compute square root

#include <math.h>
double sqrt(z) double z;

@srand
srand() -- Seed random number generator

void srand(seed) int seed;

@sscanf
sscanf() -- Format a string

#include <stdio.h>
int sscanf(string, format [, arg ] ...)
char *string; char *format;

@stat
stat() -- Find file attributes

#include <sys/stat.h>
int stat(file, statptr)
char *file; struct stat *statptr;

@stat.h
stat.h -- Definitions and declarations used to obtain file status

#include <sys/stat.h>

@static
static -- Declare storage class


@stdarg.h
stdarg.h -- Header for variable numbers of arguments

#include <stdarg.h>

@stddef.h
stddef.h -- Header for standard definitions

#include <stddef.h>

@stdio.h
stdio.h -- Declarations and definitions for I/O


@stdlib.h
stdlib.h -- Declare/define general functions

#include <stdlib.h>

@stime
stime() -- Set the time

#include
int stime(timep)
time_t *timep;

@strcat
strcat() -- Concatenate strings

#include <string.h>
char *strcat(string1, string2)
char *string1, *string2;

@strchr
strchr() -- Find a character in a string

#include <string.h>
char *strchr(string, character)
char *string; int character;

@strcmp
strcmp() -- Compare two strings

#include <string.h>
int strcmp(string1, string2)
char *string1, *string2;

@strcoll
strcoll() -- Compare two strings, using locale-specific information

#include <string.h>
int strcoll(string1, string2)
char *string1; char *string2;

@strcpy
strcpy() -- Copy one string into another

#include <string.h>
char *strcpy(string1, string2)
char *string1, *string2;

@strcspn
strcspn() -- Return length a string excludes characters in another

#include <string.h>
unsigned int strcspn(string1, string2)
char *string1, *string2;

@stream.h
stream.h -- Definitions for message facility

#include <stream.h>

@strerror
strerror() -- Translate an error number into a string

#include <string.h>
char *strerror(error)
int error;

@string.h
string.h -- Declarations for string library

#include <string.h>

@strlen
strlen() -- Measure the length of a string

#include <string.h>
int strlen(string)
char *string;

@strncat
strncat() -- Append one string onto another

#include <string.h>
char *strncat(string1, string2, n)
char *string1, *string2; unsigned n;

@strncmp
strncmp() -- Compare two strings

#include <string.h>
int strncmp(string1, string2, n)
char *string1, *string2; unsigned n;

@strncpy
strncpy() -- Copy one string into another

#include <string.h>
char *strncpy(string1, string2, n)
char *string1, *string2; unsigned n;

@strpbrk
strpbrk() -- Find first occurrence of a character from another string

#include <string.h>
char *strpbrk(string1, string2)
char *string1, *string2;

@strrchr
strrchr() -- Search for rightmost occurrence of a character in a string

#include <string.h>
char *strrchr(string, character)
char *string; int character;

@strspn
strspn() -- Return length a string includes characters in another

#include <string.h>
unsigned int strspn(string1, string2)
char *string1; char *string2;

@strstr
strstr() -- Find one string within another

#include <string.h>
char *strstr(string1, string2)
char *string1, *string2;

@strtod
strtod() -- Convert string to floating-point number

#include <stdlib.h>
double strtod(string, tailptr)
char *string; char **tailptr;

@strtok
strtok() -- Break a string into tokens

#include <string.h>
char *strtok(string1, string2)
char *string1, *string2;

@strtol
strtol() -- Convert string to long integer

#include <stdlib.h>
long strtol(string, tailptr, base)
char *string; char **tailptr; int base;

@strtoul
strtoul() -- Convert string to unsigned long integer

#include <stdlib.h>
unsigned long strtoul(string, tailptr, base)
char *string; char **tailptr; int base;

@struct
struct -- Data type


@strxfrm
strxfrm() -- Transform a string

#include <string.h>
unsigned int strxfrm(string1, string2, n)
char *string1, *string2; unsigned int n);

@stty
stty() -- Set terminal modes

#include <sgtty.h>
int stty(fd, sgp)
int fd;
struct sgttyb *sgp;

@suload
suload() -- Unload device driver

#include <con.h>
int suload(major)
int major;

@swab
swab() -- Swap a pair of bytes

void swab(src, dest, nb) char *src, *dest; unsigned nb;

@switch
switch -- Test a variable against a table


@sync
sync() -- Flush system buffers

sync()

@system
system() -- Pass a command to the shell for execution

int system(commandline) char *commandline;

@tan
tan() -- Calculate tangent

#include <math.h>
double tan(radian) double radian;

@tanh
tanh() -- Calculate hyperbolic cosine

#include <math.h>
double tanh(radian) double radian;

@tempnam
tempnam() -- Generate a unique name for a temporary file

char *tempnam(directory, name);
char *directory, *name;

@TERM
TERM -- Name the default terminal type

TERM=terminal type

@termio.h
termio.h -- Definitions used with terminal input and output

#include <termio.h>

@time
time() -- Get current time

#include <time.h>
#include <sys/types.h>
time_t time(tp) time_t *tp;

@time.h
time.h -- Give time-description structure

#include <time.h>

@timeb.h
timeb.h -- Declare timeb structure

#include <sys/timeb.h>

@timef.h
timef.h -- Definitions for user-level timed functions

#include <timef.h>

@timeout.h
timeout.h -- Define the timer queue

#include <timeout.h>

@times
times() -- Obtain process execution times

#include <sys/times.h>
#include <sys/const.h>
int times(tbp)
struct tbuffer *tbp;

@times.h
times.h -- Definitions used with times() system call

#include <times.h>

@TIMEZONE
TIMEZONE -- Time zone information

TIMEZONE=standard:offset[:daylight: date:date:hour:minutes]

@tmpnam
tmpnam() -- Generate a unique name for a temporary file

#include <stdio.h>
char *tmpnam(name);
char *name;

@tolower
tolower() -- Convert characters to lower case

#include <ctype.h>
int tolower(c) int c;

@tty.h
tty.h -- Define flags used with tty processing

#include <sys/tty.h>

@ttyname
ttyname() -- Identify a terminal

char *ttyname(fd)
int fd;

@ttyslot
ttyslot() -- Return a terminal's line number

int ttyslot()

@typedef
typedef -- Define a new data type


@types.h
types.h -- Declare system-specific data types

#include <sys/types.h>

@umask
umask() -- Set file creation mask

int umask(mask)
int mask;

@umount
umount() -- Unmount a file system

umount(filesystem)
char *filesystem;

@ungetc
ungetc() -- Return character to input stream

#include <stdio.h>
int ungetc (c, fp) int c; FILE *fp;

@union
union -- Multiply declare a variable


@unlink
unlink() -- Remove a file

int unlink(name) char *name;

@unsigned
unsigned -- Data type


@uproc.h
uproc.h -- Definitions used with user processes

#include <sys/uproc.h>

@USER
USER -- Name user's identifier

USER=user_identifier

@utime
utime() -- Change file access and modification times

#include <sys/types.h>
int utime(file, times)
char *file;
time_t times[2];

@utmp.h
utmp.h -- Login accounting information

#include <utmp.h>

@utsname.h
utsname.h -- Define utsname structure

#include <sys/utsname.h>

@v7sgtty.h
v7sgtty.h -- UNIX Version 7-style terminal I/O

#include <v7sgtty.h>

@va_arg
va_arg() -- Return pointer to next argument in argument list

#include <stdarg.h>
typename *va_arg(listptr, typename)
va_list listptr, typename;

@va_end
va_end() -- Tidy up after traversal of argument list

#include <stdarg.h>
void va_end(listptr)
va_list listptr;

@va_start
va_start() -- Point to beginning of argument list

#include <stdargs.h>
void va_start(listptr, rightparm)
va_list listptr, type rightparm;

@void
void -- Data type


@volatile
volatile -- Qualify an identifier as frequently changing


@wait
wait() -- Await completion of a child process

wait(statp)
int *statp;

@while
while -- Introduce a loop

while(condition)

@write
write() -- Write to a file

int write(fd, buffer, n)
int fd; char *buffer; int n;

@xgcd
xgcd() -- Extended greatest-common-divisor function

#include <mprec.h>
void xgcd(a, b, r, s, g)
mint *a, *b, *r, *s, *g;

@zerop
zerop() -- Indicate if multi-precision integer is zero

#include <mprec.h>
int zerop(a)
mint *a;

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