@#
String-ize operator
@##
Token-pasting operator
@#define
Define an identifier as a macro
#define identifier replacement-list
#define identifier lparen identifier-listopt ) replacement-list
@#elif
Include code conditionally
#elif constant-expression newline groupopt
@#else
Include code conditionally
#else newline groupopt
@#endif
End conditional inclusion of code
#endif
@#if
Include code conditionally
#if constant-expression newline groupopt
@#ifdef
Include code conditionally
#ifdef identifier newline groupopt
@#ifndef
Include code conditionally
#ifndef identifier newline groupopt
@#include
Read another file and include it
#include <file>
#include "file"
@#line
Reset line number
#line number newline
#line number filename newline
#line macros newline
@#undef
Undefine a macro
#undef identifier
@__DATE__
Date of translation
@__FILE__
Source file name
@__LINE__
Current line within a source file
@__STDC__
Mark a conforming translator
@__TIME__
Time source file is translated
@_exit
Terminate a program
void _exit(status) int status;
@abort
End program immediately
void abort()
@abs
Return the absolute value of an integer
int abs(n) int n;
@acct
Enable/disable process accounting
acct(file)
char *file;
@acct.h
Format for process-accounting file
#include <acct.h>
@acos
Calculate inverse cosine
#include <math.h>
double acos(arg) double arg;
@alloc.h
Define the allocator
#include <sys/alloc.h>
@ar.h
Format for archive files
#include <ar.h>
@argv
Argument passed to main
char *argv[];
@ascii.h
Define non-printable ASCII characters
#include <ascii.h>
@asctime
Convert time structure to ASCII string
#include <time.h>
#include <sys/types.h>
char *asctime(tmp) tm *tmp;
@asin
Calculate inverse sine
#include <math.h>
double asin(arg) double arg;
@assert()
Check assertion at run time
#include <assert.h>
void assert(expression) int expression;
@assert.h
Define assert()
#include <assert.h>
@atan
Calculate inverse tangent
#include <math.h>
double atan(arg) double arg;
@atan2
Calculate inverse tangent
double atan2(num, den) double num, den;
@atof
Convert ASCII strings to floating point
double atof(string) char * string;
@atoi
Convert ASCII strings to integers
int atoi(string) char *string;
@atol
Convert ASCII strings to long integers
long atol(string) char *string;
@auto
Note an automatic variable
@break
Exit from loop or switch statement
@brk
Change size of data area
brk(addr)
char *addr;
@buf.h
Buffer header
#include <sys/buf.h>
@cabs
Complex absolute value function
#include <math.h>
double cabs(z) struct { double r, i; } z;
@calloc
Allocate dynamic memory
char *calloc(count, size) unsigned count, size;
@candaddr
Convert a daddr_t to canonical format
#include <canon.h>
#include <sys/types.h>
void candaddr(s)
daddr_t s;
@candev
Convert a dev_t to canonical format
#include <canon.h>
#include <sys/types.h>
void candev(s)
dev_t s;
@canino
Convert a ino_t to canonical format
#include <canon.h>
#include <sys/types.h>
void canino(s)
ino_t s;
@canint
Convert a int to canonical format
#include <canon.h>
#include <sys/types.h>
void canint(s)
int s;
@canlong
Convert a long to canonical format
#include <canon.h>
#include <sys/types.h>
void canlong(s)
long s;
@canon.h
Portable layout of binary data
.B
#include <canon.h>
#include <sys/types.h>
.R
@canshort
Convert a short to canonical format
#include <canon.h>
#include <sys/types.h>
void canshort(s)
short s;
@cansize
Convert an fsize_t to canonical format
#include <canon.h>
#include <sys/types.h>
void cansize(s)
size_t s;
@cantime
Convert a time_t to canonical format
#include <canon.h>
#include <sys/types.h>
void cantime(s)
time_t s;
@canvaddr
Convert a vaddr_t to canonical format
#include <canon.h>
#include <sys/types.h>
void canvaddr(s)
vaddr_t s;
@case
Introduce entry in switch statement
@ceil
Set numeric ceiling
#include <math.h>
double ceil(z) double z;
@char
@chars.h
Character definitions
#include <chars.h>
@chdir
Change working directory
chdir(directory) char *directory;
@chmod
Change file-protection modes
#include <sys/stat.h>
chmod(file, mode)
char *file; int mode;
@chown
Change ownership of a file
chown(file, uid, gid)
char *file ;
short uid, gid;
@chroot
Change process's root directory
int chroot(directory)
char *directory;
@clearerr
Present stream status
#include <stdio.h>
clearerr(fp) FILE *fp;
@close
Close a file
int close(fd) int fd;
@con.h
Configure device drivers
#include <con.h>
@const
const C keyword 
Qualify an identifier as not modifiable
@const.h
Declare machine-dependent constants
#include <sys/const.h>
@continue
Force next iteration of a loop
@cos
Calculate cosine
#include <math.h>
double cos(radian) double radian;
@cosh
Calculate hyperbolic cosine
#include <math.h>
double cosh(radian) double radian;
@creat
Create/truncate a file
int creat(file, mode) char *file; int mode;
@crypt
Encryption using rotor algorithm
char *crypt(key, extra); char *key, *extra;
@ctime
Convert system time to an ASCII string
#include <time.h>
#include <sys/types.h>
char *ctime(timep) time_t *timep;
@ctype.h
Header file for data tests
#include <ctype.h>
@curses
Screen management/windowing routines
@curses.h
Define functions and macros in curses library
#include <curses.h>
@default
Default label in switch statement
@deftty.h
Define default tty settings
#define <sys/deftty.h>
@dir.h
Directory format
@dirent.h
Define dirent
#include <dirent.h>
@do
Introduce a loop
@double
Data type
@dumptape.h
Define data structures used on dump tapes
#include <dumptape.h>
@dup
Duplicate a file descriptor
int dup(fd) int fd;
@dup2
Duplicate a file descriptor
int dup2(fd, newfd) int fd, newfd;
@ebcdic.h
Define manifest constants for non-printable EBCDIC characters
#include <ebcdic.h>
@else
Introduce a conditional statement
@end
extern int end[];
@endgrent
Close group file
#include <grp.h>
endgrent()
@endpwent
Close password file
#include <pwd.h>
endpwent()
@enum
Declare a type and identifiers
@envp
Argument passed to main
char *envp[];
@errno.h
Error numbers used by errno()
#include <errno.h>
@etext
extern int etext[];
@execl
Execute a load module
execl(file, arg1, ..., argn, NULL)
char *file, *arg1, ..., *argn;
@execle
Execute a load module
execle(file, arg1, ..., argn, NULL, env)
char *file, *arg1, ..., *argn, char *env[];
@execlp
Execute a load module
execlp(file, arg1, ..., argn, NULL)
char *file, *arg1, ..., *argn;
@execv
Execute a load module
execv(file, argv)
char *file, *argv[];
@execve
Execute a load module
execve(file, argv, env)
char *file, *argv[], *env[];
@execvp
Execute a load module
execvp(file, argv)
char *file, *argv[];
@exit
Terminate a program gracefully
void exit(status) int status;
@exp
Compute exponent
#include <math.h>
double exp(z) double z;
@extern
Declare storage class
@fabs
Compute absolute value
#include <math.h>
double fabs(z) double z;
@fblk.h
Define the disk-free block
#include <sys/fblk.h>
@fclose
Close a stream
#include <stdio.h>
int fclose(fp) FILE *fp;
@fcntl.h
Manifest constants for file-handling functions
#define <sys/fcntl.h>
@fd.h
Declare file-descriptor structure
#define <sys/fd.h>
@fdioctl.h
Control floppy-disk I/O
#define <sys/fdioctl.h>
@fdisk.h
Fixed-disk constants and structures
#define <sys/fdisk.h>
@fdopen
Open a stream for standard I/O
#include <stdio.h>
FILE *fdopen(fd, type) int fd; char *type;
@feof
Discover stream status
#include <stdio.h>
int feof(fp) FILE *fp;
@ferror
Discover stream status
#include <stdio.h>
int ferror(fp) FILE *fp;
@fflush
Flush output stream's buffer
#include <stdio.h>
int fflush(fp) FILE *fp;
@fgetc
Read character from stream
#include <stdio.h>
int fgetc(fp) FILE *fp;
@fgets
Read line from stream
#include <stdio.h>
char *fgets(s, n, fp) char *s; int n; FILE *fp;
@fgetw
Read integer from stream
#include <stdio.h>
int fgetw(fp) FILE *fp;
@fileno
Get file descriptor
#include <stdio.h>
int fileno(fp) FILE *fp;
@filsys.h
Structures and constants for super block
#define <sys/filsys.h>
@float
Data type
@floor
Set a numeric floor
#include <math.h>
double floor(z) double z;
@fopen
Open a stream for standard I/O
#include <stdio.h>
FILE *fopen (name, type) char *name, *type;
@for
Control a loop
for(initialization; endcondition; modification)
@fork
Create a new process
fork()
@fperr.h
Constants used with floating-point exception codes
#define <fperr.h>
@fprintf
Print formatted output into file stream
int fprintf(fp, format, [arg1, .... argN])
FILE *fp; char *format;
[data type] arg1, ... argN;
@fputc
Write character into file stream
#include <stdio.h>
int fputc(c, fp) char c; FILE *fp;
@fputs
Write string into file stream
#include <stdio.h>
void fputs(string, fp) char *string; FILE *fp;
@fputw
Write an integer into a stream
#include <stdio.h>
int fputw(word, fp) int word; FILE *fp;
@fread
Read data from file stream
#include <stdio.h>
int fread(buffer, size, n, fp)
char *buffer; unsigned size, n; FILE *fp;
@free
Return dynamic memory to free memory pool
void free(ptr) char *ptr;
@freopen
Open file stream for standard I/O
#include <stdio.h>
FILE *freopen (name, type, fp)
char *name, *type; FILE *fp;
@frexp
Separate fraction and exponent
double frexp(real, ep) double real; int *ep;
@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
Seek on file stream
#include <stdio.h>
int fseek(fp, where, how)
FILE *fp; long where; int how;
@fstat
Find file attributes
#include <stat.h>
fstat(descriptor, statptr) int descriptor; struct stat *statptr;
@ftell
Return current position of file pointer
#include <stdio.h>
long ftell(fp) FILE *fp;
@ftime
Get the current time from the operating system
#include <sys/timeb.h>
ftime(tbp) struct timeb *tbp;
@fwrite
Write into file stream
#include <stdio.h>
int fwrite(buffer, size, n, fp)
char *buffer; unsigned size, n; FILE *fp;
@gcd
Set variable to greatest common divisor
#include <mprec.h>
void gcd(a, b, c)
mint *a, *b, *c;
@getc
Read character from file stream
#include <stdio.h>
int getc(fp) FILE *fp;
@getchar
Read character from standard input
#include <stdio.h>
int getchar()
@getegid
Get real group identifier
getegid()
@getenv
Read environmental variable
char *getenv(VARIABLE) char *VARIABLE;
@geteuid
Get effective user id
geteuid()
@getgid
Get real group id
getgid()
@getgrent
Get group file information
#include <grp.h>
struct group *getgrent();
@getgrnam
Get group file information, by group id
#include <grp.h>
struct group *getgrnam(gname);
char *gname;
@getgrgid
Get group file information, by group name
#include <grp.h>
struct group *getgrgid(gid);
int gid;
@getlogin
Get login name
char *getlogin()
@getopt
Get option letter from argv
int getopt(argc, argv, optstring)
int argc;
char **argv;
char *optstring;
extern char *optarg;
extern int optind;
@getpass
Get password with prompting
char *getpass(prompt)
char *prompt;
@getpid
Get process id
getpid()
@getpw
Search password file
getpw(uid, line)
short uid;
char *line;
@getpwent
Get password file information
#include <pwd.h>
struct passwd *getpwent()
@getpwnam
Get password file information, by name
#include <pwd.h>
struct passwd *getpwnam(uname)
char *uname;
@getpwuid
Get password file information, by id
#include <pwd.h>
struct passwd *getpwuid(uid)
int uid;
@gets
Read string from standard input
#include <stdio.h>
char *gets(buffer) char *buffer;
@getuid
Get real group id
geteuid()
@getw
Read word from file stream
#include <stdio.h>
int getw(fp) FILE *fp;
@getwd
Get current working directory name
char *getwd()
@gmtime
Convert system time to calendar structure
#include <time.h>
#include <sys/types.h>
tm *gmtime(timep) time_t *timep;
@goto
Unconditionally jump within a function
@grp.h
Declare group structure
#include <grp.h>
@gtty
Device-dependent control
#include <sgtty.h>
int gtty(fd, sgp)
int fd;
struct sgttyb *sgp;
@hdioctl.h
Control hard-disk I/O
#define <sys/hdioctl.h>
@HOME
User's home directory
HOME=home directory
@hypot
Compute hypotenuse of right triangle
#include <math.h>
double hypot(x, y) double x, y;
@if
Introduce a conditional statement
@index
Find a character in a string
char *index(string, c) char *string; char c;
@ino.h
Constants and structures for disk i-nodes
#define <sys/inode.h>
@inode.h
Constants and structures for memory-resident i-nodes
#define <sys/inode.h>
@int
Data type
@io.h
Constants and structures used by I/O
#define <sys/io.h>
@ioctl
Device-dependent control
ioctl(fd, command, info)
int fd, command;
char *info;
@ipc.h
isalnum
Check if a character is a number or letter
#include <ctype.h>
int isalnum(c) int c;
@isalpha
Check if a character is a letter
#include <ctype.h>
int isalpha(c) int c;
@isascii
Check if a character is an ASCII character
#include <ctype.h>
int isascii(c) int c;
@isatty
Check if a device is a terminal
int isatty(fd) int fd;
@iscntrl
Check if a character is a control character
#include <ctype.h>
int iscntrl(c) int c;
@isdigit
Check if a character is a numeral
#include <ctype.h>
int isdigit(c) int c;
@islower
Check if a character is a lower-case letter
#include <ctype.h>
int islower(c) int c;
@ispos
Return if variable is positive or negative
#include <mprec.h>
int ispos(a)
mint *a;
@isprint
Check if a character is printable
#include <ctype.h>
int isprint(c) int c;
@ispunct
Check if a character is a punctuation mark
#include <ctype.h>
int ispunct(c) int c;
@isspace
Check if a character prints white space
#include <ctype.h>
int isspace(c) int c;
@isupper
Check if a character is an upper-case letter
#include <ctype.h>
int isupper(c) int c;
@itom
Create a multiple-precision integer
#include <mprec.h>
mint *itom(n)
int n;
@j0
Compute Bessel function
#include <math.h>
double j0(z) double z;
@j1
Compute Bessel function
#include <math.h>
double j1(z) double z;
@jn
Compute Bessel function
#include <math.h>
double jn(n, z) int n; double z;
@l.out.h
Object file format
#include <l.out.h>
@l3tol
Convert file system block number to long integer
l3tol(lp, l3p, n)
long *lp;
char *l3p;
unsigned n;
@LASTERROR
Program that last generated an error
LASTERROR=program name
@ldexp
Combine fraction and exponent
double ldexp(f, e) double f; int e;
@link
Create a link
link(old, new)
char *old, *new;
@localtime
Convert system time to calendar structure
#include <time.h>
#include <sys/types.h>
tm *localtime(timep) time_t *timep;
@lock
Prevent process from swapping
lock(flag)
int flag;
@log
Compute natural logarithm
#include <math.h>
double log(z) double z;
@log10
Compute common logarithm
#include <math.h>
double log10(z) double z;
@long
Data type
@longjmp
Return from a non-local goto
#include <setjmp.h>
int longjmp(env, rval) jmp_buf env; int rval
@lseek
Set read/write position
long lseek(fd, where, how)
int fd, how; long where;
@l3tol
Convert long integer to file system block number
ltol3(l3p, lp, n)
char *l3p;
long *lp;
unsigned n;
@machine.h
Machine-dependent definitions
#define <sys/machine.h>
@madd
Add multiple-precision integers
#include <mprec.h>
void madd(a, b, c)
mint *a, *b, *c;
@main
Introduce program's main function
@malloc
Allocate dynamic memory
char *malloc(size) unsigned size;
@malloc.h
math.h
Declare mathematics functions
#include <math.h>
@mcmp
Compare multiple-precision integers
#include <mprec.h>
int mcmp(a, b)
mint *a, *b;
@mcopy
Copy a multiple-precision integer
#include <mprec.h>
void mcopy(a, b)
mint *a, *b;
@mdata.h
Define machine-specific magic numbers
#define <sys/mdata.h>
@mdiv
Divide multiple-precision integers
#include <mprec.h>
void mdiv(a, b, q, r)
mint *a, *b; int q, r;
@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()
Compare two regions
#include <string.h>
int memcmp(region1, region2, count);
char *region1; char *region2; unsigned int count; 
@memcpy()
Copy one region of memory into another
#include <string.h>
char *memcpy(region1, region2, n);
char *region1; char *region2; unsigned int n; 
@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
Test if the arena is corrupted
memok();
@memset()
Fill an area with a character
#include <string.h>
char *memset(buffer, character, n);
char *buffer; int character; unsigned int n); 
@min
Read multiple-precision integer from stdin
#include <mprec.h>
void min(a)
mint *a;
@minit
Condition global or auto multiple-precision integer
#include <mprec.h>
void minit(a)
mint *a;
@mintfr
Free a multiple-precision integer
#include <mprec.h>
void mintfr(a)
mint *a;
@mitom
Reinitialize a multiple-precision integer
#include <mprec.h>
void mitom(n, a)
mint *a; int n;
@mktemp
Generate a temporary file name
char *mktemp(pattern) char *pattern;
@mneg
Negate multiple-precision integer
#include <mprec.h>
void mneg(a, b)
mint *a, *b;
@mnttab.h
Structure for mount table
#define <mnttab.h>
@modf
Separate integral part and fraction
double modf(real, ip) double real, *ip;
@mon.h
Read profile output files
#define <mon.h>
@mount.h
Define the mount table
#define <sys/mount.h>
@mout
Write multiple-precision integer to stdout
#include <mprec.h>
void mout(a)
mint *a;
@mprec.h
Multiple-precision arithmetic
#include <mprec.h>
@msgctl
Message control operations
#include <sys/msg.h>
int msgctl(msqid, command, buf)
int msqid;
int cmd;
struct msqid_ds *buf;
@msgget
Get message queue
#include <sys/msg.h>
msgget(key, msgflg)
key_t key;
int msgflg;
@msgrcv
Receive a message
#include <sys/msg.h>
msgrcv(msqid, msgp, msgsz, msgtyp, msgflg)
int msqid, msgsz, msgflg;
struct msgbuf *msgp;
long msgtyp;
@msgsnd
Send a message
#include <sys/msg.h>
msgsnd(msqid, msgp, msgsz, msgflg)
int msqid, msgsz, msgflg;
struct msgbuf *msgp;
@msig.h
Machine-dependent signals
#include <msig.h>
@msqrt
Compute square root of multiple-precision integer
#include <mprec.h>
voidmsqrt(a, b, r)
mint *a, *b, *r;
@msub
Subtract multiple-precision integers
#include <mprec.h>
void msub(a, b, c)
mint *a, *b, *c;
@mtab.h
Currently mounted file systems
#include <mtab.h>
@mtioctl.h
Magnetic-tape I/O control
#define <sys/mtioctl.h>
@mtioctl.h
Magnetic-tape I/O control
#define <sys/mtioctl.h>
@mtoi
Convert multiple-precision integer to integer
#include <mprec.h>
int mtoi(a)
mint *a;
@mtos
Convert multiple-precision integer to string
#include <mprec.h>
char *mtos(a)
mint *a;
@mtype
Return symbolic machine type
#include <mtype.h>
char *mtype(type)
int type;
@mtype.h
List processor code numbers
#include <mtype.h>
@mult
Multiple multiple-precision integers
#include <mprec.h>
void mult(a, b, c)
mint *a, *b, *c;
@mvfree
Free multiple-precision integer
#include <mprec.h>
void mvfree(a)
mint *a;
@n.out.h
Define n.out file structure
#define <n.out.h>
@nlist
Symbol table lookup
#include <l.out.h>
int nlist(file, nlp)
char *file;
struct nlist *nlp;
@notmem()
Check if memory is allocated
int notmem(ptr);
char *ptr;
@open
Open a file
int open(file, type) char *file; int type;
@param.h
Define machine-specific parameters
#define <sys/param.h>
@PATH
Directories that hold executable files
@path.h
Define/declare constants and functions used with path
#define <path.h>
header files, path, PATH
@pause
Wait for signal
int pause()
@pclose
Close a pipe
#include <stdio.h>
int pclose(fp)
FILE *fp;
@perror
System call error messages
#include <errno.h>
perror(string)
char *string; extern int sys_nerr; extern char *sys_errlist[];
@pipe
Open a pipe
int pipe(fd)
int fd[2];
@pnmatch
Match string pattern
int pnmatch(string, pattern, flag)
char *string, *pattern; int flag;
@poll.h
Define structures/constants used with polling devices
#define <sys/poll.h>
@popen
Open a pipe
#include <stdio.h>
FILE *popen(command, how)
char *command, *how;
@pow
Compute a power of a number
#include <math.h>
double pow(z, x) double z, x;
@pow
Raise multiple-precision integer to power
#include <mprec.h>
void pow(a, b, m, c)
mint *a, *b, *m, *c;
@printf
Print formatted text
int printf(format, [arg1, .... argN])
char *format; [data type] arg1, ... argN;
@proc.h
Define structures/constants used with processes
#define <sys/proc.h>
@PS1
User's default prompt
PS1=prompt
@PS2
Prompt when user enters's sub-shell
PS2=prompt
@ptrace
Trace process execution
#include <signal.h>
int ptrace(command, pid, location, value)
int command, pid, *location, value;
@putc
Write character into stream
#include <stdio.h>
int putc(c, fp) char c; FILE *fp;
@putchar
Write a character onto the standard output
#include <stdio.h>
int putchar(c) char c;
@puts
Write string onto standard output
#include <stdio.h>
void puts(string) char *string
@putw
Write word into stream
#include <stdio.h>
int putw(word, fp) int word; FILE *fp;
@pwd.h
Declare password structure
#include <pwd.h>
@qsort
Sort arrays in memory
void qsort(data, n, size, comp) char *data; int n, size; int (*comp)();
@rand
Generate pseudo-random numbers
int rand()
@read
Read from a file
int read(fd, buffer, n) int fd; char *buffer; int n;
@readonly
Storage class
@realloc
Reallocate dynamic memory
char *realloc(ptr, size) char *ptr; unsigned size;
@register
Storage class
@return
Return a value and control to calling function
@rewind
Reset file pointer
#include <stdio.h>
int rewind(fp) FILE *fp;
@rindex
Find a character in a string
char *rindex(string, c) char *string; char c;
@rpow
Raise multiple-precision integer to power
#include <mprec.h>
void rpow(a, b, c)
mint *a, *b, *c;
@sbrk
Increase a program's data space
char *sbrk(increment) unsigned int increment;
@scanf
Accept and format input
#include <stdio.h>
int scanf(format, arg1, ... argN)
char *format; [data type] *arg1, ... *argN;
@proc.h
Define constants used with scheduling
#define <sys/sched.h>
@sdiv
Divide multiple-precision integers
#include <mprec.h>
void sdiv(a, n, q, ip)
mint *a, *q; int n, *ip;
@semget
#include <sys/sem.h>
semget(key, nsems, semflg)
key_t key;
int nsems, semflg;
@semop
Perform semaphore operations
#include <sys/sem.h>
semop(semid, sops, nsops)
int semid, nsops;
struct sembuf(sops)[];
@setbuf
Set alternative stream buffers
#include <stdio.h>
void setbuf(fp, buffer) FILE *fp; char *buffer;
@setgid
Set group id and user id
int setgid(id) int id;
@setgrent
Rewind group file
#include <grp.h>
struct group *setgrent();
@setjmp
Perform non-local goto
#include <setjmp.h>
int setjmp(env) jmp_buf env;
@setjmp.h
Define setjmp() and longjmp()
#include <setjmp.h>
@setpwent
Rewind password file
#include <pwd.h>
setpwent()
@settz
Set local time zone
#include <time.h>
#include <sys/types.h>
void settz()
extern long timezone
char *txname[2][16]
@setuid
Set user id
int setuid(id) int id;
@SHELL
Name the default shell
SHELL=shell
@shellsort
Sort arrays in memory
void shellsort(data, n, size, comp)
char *data; int n, size; int (*comp)();
@shmctl
Control shared-memory operations
#include <sys/shm.h>
shmctl(shmid, cmd, buf)
int shmid, cmd;
struct shmid_ds *buf;
@shmget
Get shared-memory segment
#include <sys/shm.h>
shmget(key, size, shmflg)
key_t key;
int size, shmflg;
@short
Data type
@signal
Specify disposition of a signal
#include <signal.h>
#include <msig.h>
int (*signal(signum, action))()
int signum, (*action)();
@signal.h
Declare signals
#include <signal.h>
@sin
Calculate sine
#include <math.h>
double sin(radian) double radian;
@sinh
Calculate hyperbolic sine
#include <math.h>
double sinh(radian) double radian;
@sizeof
Return size of a data element
@sload
Load device driver
#include <con.h>
int sload(major, file, conp)
int major;
char *file;
CON *conp;
@smult
Multiple multiple-precision integers
#include <mprec.h>
void smult(a, n, c)
mint *a, *c; int n;
@spow
Raise multiple-precision integer to power
#include <mprec.h>
void spow(a, n, b)
mint *a, *b; int n;
@sprintf
Format output
#include <stdio.h>
int sprintf(string, format [ , arg ] ...)
char *string, *format;
@sqrt
Compute square root
#include <math.h>
double sqrt(z) double z;
@srand
Seed random number generator
void srand(seed) int seed;
@sscanf
Format a string
#include <stdio.h>
int sscanf(string, format [, arg ] ...)
char *string; char *format;
@stat
Find file attributes
#include <sys/stat.h>
int stat(file, statptr)
char *file; struct stat *statptr;
@static
Declare storage class
@stddef.h
Header for standard definitions
#include <stddef.h>
@stdio.h
Declarations and definitions for I/O
@stime
Set the time
#include <sys/types.h>
int stime(timep)
time_t *timep;
@strcat
Concatenate strings
#include <string.h>
char *strcat(string1, string2) char *string1, *string2;
@strcmp
Compare two strings
#include <string.h>
int strcmp(string1, string2) char *string1, *string2;
strcoll() Library function 
@strcoll()
Compare two strings, using locale-specific information
#include <string.h>
int strcoll(string1, string2);
char *string1; char *string2; 
@strcpy
Copy one string into another
#include <string>
char *strcpy(string1, string2) char *string1, *string2;
strcspn() Library function 
@strcspn()
Return length a string excludes characters in another
#include <string.h>
unsigned int strcspn(string1, string2);
char *string1, *string2; 
@stream.h
strerror()
Translate an error number into a string
#include <string.h>
char *strerror(error); int error;
string.h Header 
@string.h
#include <string.h>
@strlen
Measure the length of a string
#include <string.h>
int strlen(string) char *string;
@strncat
Append one string onto another
#include <string.h>
char *strncat(string1, string2, n)
char *string1, *string2; unsigned n;
@strncmp
Compare two strings
#include <string.h>
int strncmp(string1, string2, n)
char *string1, *string2; unsigned n;
@strncpy
Copy one string into another
#include <string.h>
char *strncpy(string1, string2, n)
char *string1, *string2; unsigned n;
@strpbrk()
Find first occurrence of a character from another string
#include <string.h>
char *strpbrk(string1, string2);
char *string1, *string2; 
@strrchr()
Search for rightmost occurrence of a character in a string
#include <string.h>
char *strrchr(string, character);
char *string; int character; 
@strspn()
Return length a string includes characters in another
#include <string.h>
unsigned int strspn(string1, string2);
char *string1; char *string2; 
@strstr()
Find one string within another
#include <string.h>
char *strstr(string1, string2);
char *string1, *string2; 
@strtok()
Break a string into tokens
#include <string.h>
char *strtok(string1, string2);
char *string1, *string2; 
@struct
Data type
@strxfrm()
Transform a string
#include <string.h>
unsigned int strxfrm(string1, string2, n);
char *string1, *string2; unsigned int n; 
@suload
Unload device driver
#include <con.h>
int suload(major)
int major;
@swab
Swap a pair of bytes
void swab(src, dest, nb) char *src, *dest; unsigned nb;
@switch
Test a variable against a table
@system
Pass a command to the shell for execution
int system(commandline) char *commandline;
@tan
Calculate tangent
#include <math.h>
double tan(radian) double radian;
@tanh
Calculate hyperbolic cosine
#include <math.h>
double tanh(radian) double radian;
@tempnam()
Generate a unique name for a temporary file
char *tempnam(directory, name);
char *directory, name; 
@TERM
Name the default terminal type
TERM=terminal type
@termio.h
tgetent
Read termcap entry
int tgetent(bp, name)
char *bp, *name;
@tgetflag
Get termcap Boolean entry
int tgetflag(id)
char *id;
@tgetnum
Get termcap numeric feature
int tgetnum(id)
char *id;
@tgetstr
Get termcap string entry
char *tgetstr(id, area)
char *id, **area;
@tgetent
Read/interpret termcap cursor-addressing string
char *tgoto(cm, destcol, destline)
char *cm;
int destcol, destline;
@time
Get current time
#include <time.h>
time_t time(tp) time_t *tp;
@time.h
Give time-description structure
#include <time.h>
@timeb.h
Declare timeb structure
#include <sys/timeb.h>
@timef.h
timeout.h
Define the timer queue
#define <timeout.h>
@times
Obtain process execution times
#include <sys/times.h>
#include <sys/const.h>
int times(tbp)
struct tbuffer *tbp;
@times.h
TIMEZONE
Time zone information
TIMEZONE=standard:offset[:daylight: date:date:hour:minutes]
@tmpnam()
Generate a unique name for a temporary file
#include <stdio.h>
char *tmpnam(name);
char *name; 
@tolower
Convert characters to lower case
int tolower(c) int c;
@toupper
Convert characters to upper case
#include <ctype.h>
int toupper(c) int c;
@tputs
Read/decode leading padding information
tputs(cp, affcnt, outc)
register char *cp;
int affcnt;
int (*outc)();
@tty.h
Define flags used with tty processing
#define <sys/tty.h>
@ttyname
Identify a terminal
char *ttyname(fd)
int fd;
@ttyslot
Return a terminal's line number
int ttyslot()
@typedef
Define a new data type
@types.h
Declare system-specific data types
#include <sys/types.h>
@umask
Set file creation mask
int umask(mask)
int mask;
@ungetc
Return character to input stream
#include <stdio.h>
int ungetc (c, fp) int c; FILE *fp;
@union
Multiply declare a variable
@unlink
Remove a file
int unlink(name) char *name;
@unsigned
Data type
@USER
Name user's ID
USER=user's ID
@utime
Change file access and modification times
#include <sys/types.h>
int utime(file, times)
char *file;
time_t times[2];
@utmp.h
Login accounting information
#include <utmp.h>
@utsname.h
Define utsname structure
#define <sys/utsname.h>
@v7sgtty.h
UNIX Version 7-style terminal I/O
#define <v7sgtty.h>
@void
Data type
@volatile
volatile C keyword 
Qualify an identifier as frequently changing
@wait
Await completion of a child process
wait(statp)
int *statp;
@while
Introduce a loop
while(condition)
@write
Write to a file
int write(fd, buffer, n)
int fd; char *buffer; int n;
@xgcd
Extended greatest-common-divisor function
#include <mprec.h>
void xgcd(a, b, r, s, g)
mint *a, *b, *r, *s, *g;
@zerop
Indicate if multi-precision integer is zero
#include <mprec.h>
int zerop(a)
mint *a;
@
