Return to helpfile CVS log

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

Annotation of coherent/c/usr/lib/helpfile, revision 1.1

1.1     ! root        1: @#
        !             2: String-ize operator
        !             3: @##
        !             4: Token-pasting operator
        !             5: @#define
        !             6: Define an identifier as a macro
        !             7: #define identifier replacement-list
        !             8: #define identifier lparen identifier-listopt ) replacement-list
        !             9: @#elif
        !            10: Include code conditionally
        !            11: #elif constant-expression newline groupopt
        !            12: @#else
        !            13: Include code conditionally
        !            14: #else newline groupopt
        !            15: @#endif
        !            16: End conditional inclusion of code
        !            17: #endif
        !            18: @#if
        !            19: Include code conditionally
        !            20: #if constant-expression newline groupopt
        !            21: @#ifdef
        !            22: Include code conditionally
        !            23: #ifdef identifier newline groupopt
        !            24: @#ifndef
        !            25: Include code conditionally
        !            26: #ifndef identifier newline groupopt
        !            27: @#include
        !            28: Read another file and include it
        !            29: #include <file>
        !            30: #include "file"
        !            31: @#line
        !            32: Reset line number
        !            33: #line number newline
        !            34: #line number filename newline
        !            35: #line macros newline
        !            36: @#undef
        !            37: Undefine a macro
        !            38: #undef identifier
        !            39: @__DATE__
        !            40: Date of translation
        !            41: @__FILE__
        !            42: Source file name
        !            43: @__LINE__
        !            44: Current line within a source file
        !            45: @__STDC__
        !            46: Mark a conforming translator
        !            47: @__TIME__
        !            48: Time source file is translated
        !            49: @_exit
        !            50: Terminate a program
        !            51: void _exit(status) int status;
        !            52: @abort
        !            53: End program immediately
        !            54: void abort()
        !            55: @abs
        !            56: Return the absolute value of an integer
        !            57: int abs(n) int n;
        !            58: @acct
        !            59: Enable/disable process accounting
        !            60: acct(file)
        !            61: char *file;
        !            62: @acct.h
        !            63: Format for process-accounting file
        !            64: #include <acct.h>
        !            65: @acos
        !            66: Calculate inverse cosine
        !            67: #include <math.h>
        !            68: double acos(arg) double arg;
        !            69: @alloc.h
        !            70: Define the allocator
        !            71: #include <sys/alloc.h>
        !            72: @ar.h
        !            73: Format for archive files
        !            74: #include <ar.h>
        !            75: @argv
        !            76: Argument passed to main
        !            77: char *argv[];
        !            78: @ascii.h
        !            79: Define non-printable ASCII characters
        !            80: #include <ascii.h>
        !            81: @asctime
        !            82: Convert time structure to ASCII string
        !            83: #include <time.h>
        !            84: #include <sys/types.h>
        !            85: char *asctime(tmp) tm *tmp;
        !            86: @asin
        !            87: Calculate inverse sine
        !            88: #include <math.h>
        !            89: double asin(arg) double arg;
        !            90: @assert()
        !            91: Check assertion at run time
        !            92: #include <assert.h>
        !            93: void assert(expression) int expression;
        !            94: @assert.h
        !            95: Define assert()
        !            96: #include <assert.h>
        !            97: @atan
        !            98: Calculate inverse tangent
        !            99: #include <math.h>
        !           100: double atan(arg) double arg;
        !           101: @atan2
        !           102: Calculate inverse tangent
        !           103: double atan2(num, den) double num, den;
        !           104: @atof
        !           105: Convert ASCII strings to floating point
        !           106: double atof(string) char * string;
        !           107: @atoi
        !           108: Convert ASCII strings to integers
        !           109: int atoi(string) char *string;
        !           110: @atol
        !           111: Convert ASCII strings to long integers
        !           112: long atol(string) char *string;
        !           113: @auto
        !           114: Note an automatic variable
        !           115: @break
        !           116: Exit from loop or switch statement
        !           117: @brk
        !           118: Change size of data area
        !           119: brk(addr)
        !           120: char *addr;
        !           121: @buf.h
        !           122: Buffer header
        !           123: #include <sys/buf.h>
        !           124: @cabs
        !           125: Complex absolute value function
        !           126: #include <math.h>
        !           127: double cabs(z) struct { double r, i; } z;
        !           128: @calloc
        !           129: Allocate dynamic memory
        !           130: char *calloc(count, size) unsigned count, size;
        !           131: @candaddr
        !           132: Convert a daddr_t to canonical format
        !           133: #include <canon.h>
        !           134: #include <sys/types.h>
        !           135: void candaddr(s)
        !           136: daddr_t s;
        !           137: @candev
        !           138: Convert a dev_t to canonical format
        !           139: #include <canon.h>
        !           140: #include <sys/types.h>
        !           141: void candev(s)
        !           142: dev_t s;
        !           143: @canino
        !           144: Convert a ino_t to canonical format
        !           145: #include <canon.h>
        !           146: #include <sys/types.h>
        !           147: void canino(s)
        !           148: ino_t s;
        !           149: @canint
        !           150: Convert a int to canonical format
        !           151: #include <canon.h>
        !           152: #include <sys/types.h>
        !           153: void canint(s)
        !           154: int s;
        !           155: @canlong
        !           156: Convert a long to canonical format
        !           157: #include <canon.h>
        !           158: #include <sys/types.h>
        !           159: void canlong(s)
        !           160: long s;
        !           161: @canon.h
        !           162: Portable layout of binary data
        !           163: .B
        !           164: #include <canon.h>
        !           165: #include <sys/types.h>
        !           166: .R
        !           167: @canshort
        !           168: Convert a short to canonical format
        !           169: #include <canon.h>
        !           170: #include <sys/types.h>
        !           171: void canshort(s)
        !           172: short s;
        !           173: @cansize
        !           174: Convert an fsize_t to canonical format
        !           175: #include <canon.h>
        !           176: #include <sys/types.h>
        !           177: void cansize(s)
        !           178: size_t s;
        !           179: @cantime
        !           180: Convert a time_t to canonical format
        !           181: #include <canon.h>
        !           182: #include <sys/types.h>
        !           183: void cantime(s)
        !           184: time_t s;
        !           185: @canvaddr
        !           186: Convert a vaddr_t to canonical format
        !           187: #include <canon.h>
        !           188: #include <sys/types.h>
        !           189: void canvaddr(s)
        !           190: vaddr_t s;
        !           191: @case
        !           192: Introduce entry in switch statement
        !           193: @ceil
        !           194: Set numeric ceiling
        !           195: #include <math.h>
        !           196: double ceil(z) double z;
        !           197: @char
        !           198: @chars.h
        !           199: Character definitions
        !           200: #include <chars.h>
        !           201: @chdir
        !           202: Change working directory
        !           203: chdir(directory) char *directory;
        !           204: @chmod
        !           205: Change file-protection modes
        !           206: #include <sys/stat.h>
        !           207: chmod(file, mode)
        !           208: char *file; int mode;
        !           209: @chown
        !           210: Change ownership of a file
        !           211: chown(file, uid, gid)
        !           212: char *file ;
        !           213: short uid, gid;
        !           214: @chroot
        !           215: Change process's root directory
        !           216: int chroot(directory)
        !           217: char *directory;
        !           218: @clearerr
        !           219: Present stream status
        !           220: #include <stdio.h>
        !           221: clearerr(fp) FILE *fp;
        !           222: @close
        !           223: Close a file
        !           224: int close(fd) int fd;
        !           225: @con.h
        !           226: Configure device drivers
        !           227: #include <con.h>
        !           228: @const
        !           229: const C keyword 
        !           230: Qualify an identifier as not modifiable
        !           231: @const.h
        !           232: Declare machine-dependent constants
        !           233: #include <sys/const.h>
        !           234: @continue
        !           235: Force next iteration of a loop
        !           236: @cos
        !           237: Calculate cosine
        !           238: #include <math.h>
        !           239: double cos(radian) double radian;
        !           240: @cosh
        !           241: Calculate hyperbolic cosine
        !           242: #include <math.h>
        !           243: double cosh(radian) double radian;
        !           244: @creat
        !           245: Create/truncate a file
        !           246: int creat(file, mode) char *file; int mode;
        !           247: @crypt
        !           248: Encryption using rotor algorithm
        !           249: char *crypt(key, extra); char *key, *extra;
        !           250: @ctime
        !           251: Convert system time to an ASCII string
        !           252: #include <time.h>
        !           253: #include <sys/types.h>
        !           254: char *ctime(timep) time_t *timep;
        !           255: @ctype.h
        !           256: Header file for data tests
        !           257: #include <ctype.h>
        !           258: @curses
        !           259: Screen management/windowing routines
        !           260: @curses.h
        !           261: Define functions and macros in curses library
        !           262: #include <curses.h>
        !           263: @default
        !           264: Default label in switch statement
        !           265: @deftty.h
        !           266: Define default tty settings
        !           267: #define <sys/deftty.h>
        !           268: @dir.h
        !           269: Directory format
        !           270: @dirent.h
        !           271: Define dirent
        !           272: #include <dirent.h>
        !           273: @do
        !           274: Introduce a loop
        !           275: @double
        !           276: Data type
        !           277: @dumptape.h
        !           278: Define data structures used on dump tapes
        !           279: #include <dumptape.h>
        !           280: @dup
        !           281: Duplicate a file descriptor
        !           282: int dup(fd) int fd;
        !           283: @dup2
        !           284: Duplicate a file descriptor
        !           285: int dup2(fd, newfd) int fd, newfd;
        !           286: @ebcdic.h
        !           287: Define manifest constants for non-printable EBCDIC characters
        !           288: #include <ebcdic.h>
        !           289: @else
        !           290: Introduce a conditional statement
        !           291: @end
        !           292: extern int end[];
        !           293: @endgrent
        !           294: Close group file
        !           295: #include <grp.h>
        !           296: endgrent()
        !           297: @endpwent
        !           298: Close password file
        !           299: #include <pwd.h>
        !           300: endpwent()
        !           301: @enum
        !           302: Declare a type and identifiers
        !           303: @envp
        !           304: Argument passed to main
        !           305: char *envp[];
        !           306: @errno.h
        !           307: Error numbers used by errno()
        !           308: #include <errno.h>
        !           309: @etext
        !           310: extern int etext[];
        !           311: @execl
        !           312: Execute a load module
        !           313: execl(file, arg1, ..., argn, NULL)
        !           314: char *file, *arg1, ..., *argn;
        !           315: @execle
        !           316: Execute a load module
        !           317: execle(file, arg1, ..., argn, NULL, env)
        !           318: char *file, *arg1, ..., *argn, char *env[];
        !           319: @execlp
        !           320: Execute a load module
        !           321: execlp(file, arg1, ..., argn, NULL)
        !           322: char *file, *arg1, ..., *argn;
        !           323: @execv
        !           324: Execute a load module
        !           325: execv(file, argv)
        !           326: char *file, *argv[];
        !           327: @execve
        !           328: Execute a load module
        !           329: execve(file, argv, env)
        !           330: char *file, *argv[], *env[];
        !           331: @execvp
        !           332: Execute a load module
        !           333: execvp(file, argv)
        !           334: char *file, *argv[];
        !           335: @exit
        !           336: Terminate a program gracefully
        !           337: void exit(status) int status;
        !           338: @exp
        !           339: Compute exponent
        !           340: #include <math.h>
        !           341: double exp(z) double z;
        !           342: @extern
        !           343: Declare storage class
        !           344: @fabs
        !           345: Compute absolute value
        !           346: #include <math.h>
        !           347: double fabs(z) double z;
        !           348: @fblk.h
        !           349: Define the disk-free block
        !           350: #include <sys/fblk.h>
        !           351: @fclose
        !           352: Close a stream
        !           353: #include <stdio.h>
        !           354: int fclose(fp) FILE *fp;
        !           355: @fcntl.h
        !           356: Manifest constants for file-handling functions
        !           357: #define <sys/fcntl.h>
        !           358: @fd.h
        !           359: Declare file-descriptor structure
        !           360: #define <sys/fd.h>
        !           361: @fdioctl.h
        !           362: Control floppy-disk I/O
        !           363: #define <sys/fdioctl.h>
        !           364: @fdisk.h
        !           365: Fixed-disk constants and structures
        !           366: #define <sys/fdisk.h>
        !           367: @fdopen
        !           368: Open a stream for standard I/O
        !           369: #include <stdio.h>
        !           370: FILE *fdopen(fd, type) int fd; char *type;
        !           371: @feof
        !           372: Discover stream status
        !           373: #include <stdio.h>
        !           374: int feof(fp) FILE *fp;
        !           375: @ferror
        !           376: Discover stream status
        !           377: #include <stdio.h>
        !           378: int ferror(fp) FILE *fp;
        !           379: @fflush
        !           380: Flush output stream's buffer
        !           381: #include <stdio.h>
        !           382: int fflush(fp) FILE *fp;
        !           383: @fgetc
        !           384: Read character from stream
        !           385: #include <stdio.h>
        !           386: int fgetc(fp) FILE *fp;
        !           387: @fgets
        !           388: Read line from stream
        !           389: #include <stdio.h>
        !           390: char *fgets(s, n, fp) char *s; int n; FILE *fp;
        !           391: @fgetw
        !           392: Read integer from stream
        !           393: #include <stdio.h>
        !           394: int fgetw(fp) FILE *fp;
        !           395: @fileno
        !           396: Get file descriptor
        !           397: #include <stdio.h>
        !           398: int fileno(fp) FILE *fp;
        !           399: @filsys.h
        !           400: Structures and constants for super block
        !           401: #define <sys/filsys.h>
        !           402: @float
        !           403: Data type
        !           404: @floor
        !           405: Set a numeric floor
        !           406: #include <math.h>
        !           407: double floor(z) double z;
        !           408: @fopen
        !           409: Open a stream for standard I/O
        !           410: #include <stdio.h>
        !           411: FILE *fopen (name, type) char *name, *type;
        !           412: @for
        !           413: Control a loop
        !           414: for(initialization; endcondition; modification)
        !           415: @fork
        !           416: Create a new process
        !           417: fork()
        !           418: @fperr.h
        !           419: Constants used with floating-point exception codes
        !           420: #define <fperr.h>
        !           421: @fprintf
        !           422: Print formatted output into file stream
        !           423: int fprintf(fp, format, [arg1, .... argN])
        !           424: FILE *fp; char *format;
        !           425: [data type] arg1, ... argN;
        !           426: @fputc
        !           427: Write character into file stream
        !           428: #include <stdio.h>
        !           429: int fputc(c, fp) char c; FILE *fp;
        !           430: @fputs
        !           431: Write string into file stream
        !           432: #include <stdio.h>
        !           433: void fputs(string, fp) char *string; FILE *fp;
        !           434: @fputw
        !           435: Write an integer into a stream
        !           436: #include <stdio.h>
        !           437: int fputw(word, fp) int word; FILE *fp;
        !           438: @fread
        !           439: Read data from file stream
        !           440: #include <stdio.h>
        !           441: int fread(buffer, size, n, fp)
        !           442: char *buffer; unsigned size, n; FILE *fp;
        !           443: @free
        !           444: Return dynamic memory to free memory pool
        !           445: void free(ptr) char *ptr;
        !           446: @freopen
        !           447: Open file stream for standard I/O
        !           448: #include <stdio.h>
        !           449: FILE *freopen (name, type, fp)
        !           450: char *name, *type; FILE *fp;
        !           451: @frexp
        !           452: Separate fraction and exponent
        !           453: double frexp(real, ep) double real; int *ep;
        !           454: @fscanf
        !           455: Format input from a file stream
        !           456: #include <stdio.h>
        !           457: int fscanf(fp, format, arg1, ... argN)
        !           458: FILE *fp; char *format;
        !           459: [data type] *arg1, ... *argN;
        !           460: @fseek
        !           461: Seek on file stream
        !           462: #include <stdio.h>
        !           463: int fseek(fp, where, how)
        !           464: FILE *fp; long where; int how;
        !           465: @fstat
        !           466: Find file attributes
        !           467: #include <stat.h>
        !           468: fstat(descriptor, statptr) int descriptor; struct stat *statptr;
        !           469: @ftell
        !           470: Return current position of file pointer
        !           471: #include <stdio.h>
        !           472: long ftell(fp) FILE *fp;
        !           473: @ftime
        !           474: Get the current time from the operating system
        !           475: #include <sys/timeb.h>
        !           476: ftime(tbp) struct timeb *tbp;
        !           477: @fwrite
        !           478: Write into file stream
        !           479: #include <stdio.h>
        !           480: int fwrite(buffer, size, n, fp)
        !           481: char *buffer; unsigned size, n; FILE *fp;
        !           482: @gcd
        !           483: Set variable to greatest common divisor
        !           484: #include <mprec.h>
        !           485: void gcd(a, b, c)
        !           486: mint *a, *b, *c;
        !           487: @getc
        !           488: Read character from file stream
        !           489: #include <stdio.h>
        !           490: int getc(fp) FILE *fp;
        !           491: @getchar
        !           492: Read character from standard input
        !           493: #include <stdio.h>
        !           494: int getchar()
        !           495: @getegid
        !           496: Get real group identifier
        !           497: getegid()
        !           498: @getenv
        !           499: Read environmental variable
        !           500: char *getenv(VARIABLE) char *VARIABLE;
        !           501: @geteuid
        !           502: Get effective user id
        !           503: geteuid()
        !           504: @getgid
        !           505: Get real group id
        !           506: getgid()
        !           507: @getgrent
        !           508: Get group file information
        !           509: #include <grp.h>
        !           510: struct group *getgrent();
        !           511: @getgrnam
        !           512: Get group file information, by group id
        !           513: #include <grp.h>
        !           514: struct group *getgrnam(gname);
        !           515: char *gname;
        !           516: @getgrgid
        !           517: Get group file information, by group name
        !           518: #include <grp.h>
        !           519: struct group *getgrgid(gid);
        !           520: int gid;
        !           521: @getlogin
        !           522: Get login name
        !           523: char *getlogin()
        !           524: @getopt
        !           525: Get option letter from argv
        !           526: int getopt(argc, argv, optstring)
        !           527: int argc;
        !           528: char **argv;
        !           529: char *optstring;
        !           530: extern char *optarg;
        !           531: extern int optind;
        !           532: @getpass
        !           533: Get password with prompting
        !           534: char *getpass(prompt)
        !           535: char *prompt;
        !           536: @getpid
        !           537: Get process id
        !           538: getpid()
        !           539: @getpw
        !           540: Search password file
        !           541: getpw(uid, line)
        !           542: short uid;
        !           543: char *line;
        !           544: @getpwent
        !           545: Get password file information
        !           546: #include <pwd.h>
        !           547: struct passwd *getpwent()
        !           548: @getpwnam
        !           549: Get password file information, by name
        !           550: #include <pwd.h>
        !           551: struct passwd *getpwnam(uname)
        !           552: char *uname;
        !           553: @getpwuid
        !           554: Get password file information, by id
        !           555: #include <pwd.h>
        !           556: struct passwd *getpwuid(uid)
        !           557: int uid;
        !           558: @gets
        !           559: Read string from standard input
        !           560: #include <stdio.h>
        !           561: char *gets(buffer) char *buffer;
        !           562: @getuid
        !           563: Get real group id
        !           564: geteuid()
        !           565: @getw
        !           566: Read word from file stream
        !           567: #include <stdio.h>
        !           568: int getw(fp) FILE *fp;
        !           569: @getwd
        !           570: Get current working directory name
        !           571: char *getwd()
        !           572: @gmtime
        !           573: Convert system time to calendar structure
        !           574: #include <time.h>
        !           575: #include <sys/types.h>
        !           576: tm *gmtime(timep) time_t *timep;
        !           577: @goto
        !           578: Unconditionally jump within a function
        !           579: @grp.h
        !           580: Declare group structure
        !           581: #include <grp.h>
        !           582: @gtty
        !           583: Device-dependent control
        !           584: #include <sgtty.h>
        !           585: int gtty(fd, sgp)
        !           586: int fd;
        !           587: struct sgttyb *sgp;
        !           588: @hdioctl.h
        !           589: Control hard-disk I/O
        !           590: #define <sys/hdioctl.h>
        !           591: @HOME
        !           592: User's home directory
        !           593: HOME=home directory
        !           594: @hypot
        !           595: Compute hypotenuse of right triangle
        !           596: #include <math.h>
        !           597: double hypot(x, y) double x, y;
        !           598: @if
        !           599: Introduce a conditional statement
        !           600: @index
        !           601: Find a character in a string
        !           602: char *index(string, c) char *string; char c;
        !           603: @ino.h
        !           604: Constants and structures for disk i-nodes
        !           605: #define <sys/inode.h>
        !           606: @inode.h
        !           607: Constants and structures for memory-resident i-nodes
        !           608: #define <sys/inode.h>
        !           609: @int
        !           610: Data type
        !           611: @io.h
        !           612: Constants and structures used by I/O
        !           613: #define <sys/io.h>
        !           614: @ioctl
        !           615: Device-dependent control
        !           616: ioctl(fd, command, info)
        !           617: int fd, command;
        !           618: char *info;
        !           619: @ipc.h
        !           620: isalnum
        !           621: Check if a character is a number or letter
        !           622: #include <ctype.h>
        !           623: int isalnum(c) int c;
        !           624: @isalpha
        !           625: Check if a character is a letter
        !           626: #include <ctype.h>
        !           627: int isalpha(c) int c;
        !           628: @isascii
        !           629: Check if a character is an ASCII character
        !           630: #include <ctype.h>
        !           631: int isascii(c) int c;
        !           632: @isatty
        !           633: Check if a device is a terminal
        !           634: int isatty(fd) int fd;
        !           635: @iscntrl
        !           636: Check if a character is a control character
        !           637: #include <ctype.h>
        !           638: int iscntrl(c) int c;
        !           639: @isdigit
        !           640: Check if a character is a numeral
        !           641: #include <ctype.h>
        !           642: int isdigit(c) int c;
        !           643: @islower
        !           644: Check if a character is a lower-case letter
        !           645: #include <ctype.h>
        !           646: int islower(c) int c;
        !           647: @ispos
        !           648: Return if variable is positive or negative
        !           649: #include <mprec.h>
        !           650: int ispos(a)
        !           651: mint *a;
        !           652: @isprint
        !           653: Check if a character is printable
        !           654: #include <ctype.h>
        !           655: int isprint(c) int c;
        !           656: @ispunct
        !           657: Check if a character is a punctuation mark
        !           658: #include <ctype.h>
        !           659: int ispunct(c) int c;
        !           660: @isspace
        !           661: Check if a character prints white space
        !           662: #include <ctype.h>
        !           663: int isspace(c) int c;
        !           664: @isupper
        !           665: Check if a character is an upper-case letter
        !           666: #include <ctype.h>
        !           667: int isupper(c) int c;
        !           668: @itom
        !           669: Create a multiple-precision integer
        !           670: #include <mprec.h>
        !           671: mint *itom(n)
        !           672: int n;
        !           673: @j0
        !           674: Compute Bessel function
        !           675: #include <math.h>
        !           676: double j0(z) double z;
        !           677: @j1
        !           678: Compute Bessel function
        !           679: #include <math.h>
        !           680: double j1(z) double z;
        !           681: @jn
        !           682: Compute Bessel function
        !           683: #include <math.h>
        !           684: double jn(n, z) int n; double z;
        !           685: @l.out.h
        !           686: Object file format
        !           687: #include <l.out.h>
        !           688: @l3tol
        !           689: Convert file system block number to long integer
        !           690: l3tol(lp, l3p, n)
        !           691: long *lp;
        !           692: char *l3p;
        !           693: unsigned n;
        !           694: @LASTERROR
        !           695: Program that last generated an error
        !           696: LASTERROR=program name
        !           697: @ldexp
        !           698: Combine fraction and exponent
        !           699: double ldexp(f, e) double f; int e;
        !           700: @link
        !           701: Create a link
        !           702: link(old, new)
        !           703: char *old, *new;
        !           704: @localtime
        !           705: Convert system time to calendar structure
        !           706: #include <time.h>
        !           707: #include <sys/types.h>
        !           708: tm *localtime(timep) time_t *timep;
        !           709: @lock
        !           710: Prevent process from swapping
        !           711: lock(flag)
        !           712: int flag;
        !           713: @log
        !           714: Compute natural logarithm
        !           715: #include <math.h>
        !           716: double log(z) double z;
        !           717: @log10
        !           718: Compute common logarithm
        !           719: #include <math.h>
        !           720: double log10(z) double z;
        !           721: @long
        !           722: Data type
        !           723: @longjmp
        !           724: Return from a non-local goto
        !           725: #include <setjmp.h>
        !           726: int longjmp(env, rval) jmp_buf env; int rval
        !           727: @lseek
        !           728: Set read/write position
        !           729: long lseek(fd, where, how)
        !           730: int fd, how; long where;
        !           731: @l3tol
        !           732: Convert long integer to file system block number
        !           733: ltol3(l3p, lp, n)
        !           734: char *l3p;
        !           735: long *lp;
        !           736: unsigned n;
        !           737: @machine.h
        !           738: Machine-dependent definitions
        !           739: #define <sys/machine.h>
        !           740: @madd
        !           741: Add multiple-precision integers
        !           742: #include <mprec.h>
        !           743: void madd(a, b, c)
        !           744: mint *a, *b, *c;
        !           745: @main
        !           746: Introduce program's main function
        !           747: @malloc
        !           748: Allocate dynamic memory
        !           749: char *malloc(size) unsigned size;
        !           750: @malloc.h
        !           751: math.h
        !           752: Declare mathematics functions
        !           753: #include <math.h>
        !           754: @mcmp
        !           755: Compare multiple-precision integers
        !           756: #include <mprec.h>
        !           757: int mcmp(a, b)
        !           758: mint *a, *b;
        !           759: @mcopy
        !           760: Copy a multiple-precision integer
        !           761: #include <mprec.h>
        !           762: void mcopy(a, b)
        !           763: mint *a, *b;
        !           764: @mdata.h
        !           765: Define machine-specific magic numbers
        !           766: #define <sys/mdata.h>
        !           767: @mdiv
        !           768: Divide multiple-precision integers
        !           769: #include <mprec.h>
        !           770: void mdiv(a, b, q, r)
        !           771: mint *a, *b; int q, r;
        !           772: @memchr()
        !           773: Search a region of memory for a character
        !           774: #include <string.h>
        !           775: char *memchr(region, character, n);
        !           776: char *region; int character; unsigned int n; 
        !           777: @memcmp()
        !           778: Compare two regions
        !           779: #include <string.h>
        !           780: int memcmp(region1, region2, count);
        !           781: char *region1; char *region2; unsigned int count; 
        !           782: @memcpy()
        !           783: Copy one region of memory into another
        !           784: #include <string.h>
        !           785: char *memcpy(region1, region2, n);
        !           786: char *region1; char *region2; unsigned int n; 
        !           787: @memmove()
        !           788: Copy region of memory into area it overlaps
        !           789: #include <string.h>
        !           790: char *memmove(region1, region2, count);
        !           791: char *region1, char *region2, unsigned int count; 
        !           792: @memok
        !           793: Test if the arena is corrupted
        !           794: memok();
        !           795: @memset()
        !           796: Fill an area with a character
        !           797: #include <string.h>
        !           798: char *memset(buffer, character, n);
        !           799: char *buffer; int character; unsigned int n); 
        !           800: @min
        !           801: Read multiple-precision integer from stdin
        !           802: #include <mprec.h>
        !           803: void min(a)
        !           804: mint *a;
        !           805: @minit
        !           806: Condition global or auto multiple-precision integer
        !           807: #include <mprec.h>
        !           808: void minit(a)
        !           809: mint *a;
        !           810: @mintfr
        !           811: Free a multiple-precision integer
        !           812: #include <mprec.h>
        !           813: void mintfr(a)
        !           814: mint *a;
        !           815: @mitom
        !           816: Reinitialize a multiple-precision integer
        !           817: #include <mprec.h>
        !           818: void mitom(n, a)
        !           819: mint *a; int n;
        !           820: @mktemp
        !           821: Generate a temporary file name
        !           822: char *mktemp(pattern) char *pattern;
        !           823: @mneg
        !           824: Negate multiple-precision integer
        !           825: #include <mprec.h>
        !           826: void mneg(a, b)
        !           827: mint *a, *b;
        !           828: @mnttab.h
        !           829: Structure for mount table
        !           830: #define <mnttab.h>
        !           831: @modf
        !           832: Separate integral part and fraction
        !           833: double modf(real, ip) double real, *ip;
        !           834: @mon.h
        !           835: Read profile output files
        !           836: #define <mon.h>
        !           837: @mount.h
        !           838: Define the mount table
        !           839: #define <sys/mount.h>
        !           840: @mout
        !           841: Write multiple-precision integer to stdout
        !           842: #include <mprec.h>
        !           843: void mout(a)
        !           844: mint *a;
        !           845: @mprec.h
        !           846: Multiple-precision arithmetic
        !           847: #include <mprec.h>
        !           848: @msgctl
        !           849: Message control operations
        !           850: #include <sys/msg.h>
        !           851: int msgctl(msqid, command, buf)
        !           852: int msqid;
        !           853: int cmd;
        !           854: struct msqid_ds *buf;
        !           855: @msgget
        !           856: Get message queue
        !           857: #include <sys/msg.h>
        !           858: msgget(key, msgflg)
        !           859: key_t key;
        !           860: int msgflg;
        !           861: @msgrcv
        !           862: Receive a message
        !           863: #include <sys/msg.h>
        !           864: msgrcv(msqid, msgp, msgsz, msgtyp, msgflg)
        !           865: int msqid, msgsz, msgflg;
        !           866: struct msgbuf *msgp;
        !           867: long msgtyp;
        !           868: @msgsnd
        !           869: Send a message
        !           870: #include <sys/msg.h>
        !           871: msgsnd(msqid, msgp, msgsz, msgflg)
        !           872: int msqid, msgsz, msgflg;
        !           873: struct msgbuf *msgp;
        !           874: @msig.h
        !           875: Machine-dependent signals
        !           876: #include <msig.h>
        !           877: @msqrt
        !           878: Compute square root of multiple-precision integer
        !           879: #include <mprec.h>
        !           880: voidmsqrt(a, b, r)
        !           881: mint *a, *b, *r;
        !           882: @msub
        !           883: Subtract multiple-precision integers
        !           884: #include <mprec.h>
        !           885: void msub(a, b, c)
        !           886: mint *a, *b, *c;
        !           887: @mtab.h
        !           888: Currently mounted file systems
        !           889: #include <mtab.h>
        !           890: @mtioctl.h
        !           891: Magnetic-tape I/O control
        !           892: #define <sys/mtioctl.h>
        !           893: @mtioctl.h
        !           894: Magnetic-tape I/O control
        !           895: #define <sys/mtioctl.h>
        !           896: @mtoi
        !           897: Convert multiple-precision integer to integer
        !           898: #include <mprec.h>
        !           899: int mtoi(a)
        !           900: mint *a;
        !           901: @mtos
        !           902: Convert multiple-precision integer to string
        !           903: #include <mprec.h>
        !           904: char *mtos(a)
        !           905: mint *a;
        !           906: @mtype
        !           907: Return symbolic machine type
        !           908: #include <mtype.h>
        !           909: char *mtype(type)
        !           910: int type;
        !           911: @mtype.h
        !           912: List processor code numbers
        !           913: #include <mtype.h>
        !           914: @mult
        !           915: Multiple multiple-precision integers
        !           916: #include <mprec.h>
        !           917: void mult(a, b, c)
        !           918: mint *a, *b, *c;
        !           919: @mvfree
        !           920: Free multiple-precision integer
        !           921: #include <mprec.h>
        !           922: void mvfree(a)
        !           923: mint *a;
        !           924: @n.out.h
        !           925: Define n.out file structure
        !           926: #define <n.out.h>
        !           927: @nlist
        !           928: Symbol table lookup
        !           929: #include <l.out.h>
        !           930: int nlist(file, nlp)
        !           931: char *file;
        !           932: struct nlist *nlp;
        !           933: @notmem()
        !           934: Check if memory is allocated
        !           935: int notmem(ptr);
        !           936: char *ptr;
        !           937: @open
        !           938: Open a file
        !           939: int open(file, type) char *file; int type;
        !           940: @param.h
        !           941: Define machine-specific parameters
        !           942: #define <sys/param.h>
        !           943: @PATH
        !           944: Directories that hold executable files
        !           945: @path.h
        !           946: Define/declare constants and functions used with path
        !           947: #define <path.h>
        !           948: header files, path, PATH
        !           949: @pause
        !           950: Wait for signal
        !           951: int pause()
        !           952: @pclose
        !           953: Close a pipe
        !           954: #include <stdio.h>
        !           955: int pclose(fp)
        !           956: FILE *fp;
        !           957: @perror
        !           958: System call error messages
        !           959: #include <errno.h>
        !           960: perror(string)
        !           961: char *string; extern int sys_nerr; extern char *sys_errlist[];
        !           962: @pipe
        !           963: Open a pipe
        !           964: int pipe(fd)
        !           965: int fd[2];
        !           966: @pnmatch
        !           967: Match string pattern
        !           968: int pnmatch(string, pattern, flag)
        !           969: char *string, *pattern; int flag;
        !           970: @poll.h
        !           971: Define structures/constants used with polling devices
        !           972: #define <sys/poll.h>
        !           973: @popen
        !           974: Open a pipe
        !           975: #include <stdio.h>
        !           976: FILE *popen(command, how)
        !           977: char *command, *how;
        !           978: @pow
        !           979: Compute a power of a number
        !           980: #include <math.h>
        !           981: double pow(z, x) double z, x;
        !           982: @pow
        !           983: Raise multiple-precision integer to power
        !           984: #include <mprec.h>
        !           985: void pow(a, b, m, c)
        !           986: mint *a, *b, *m, *c;
        !           987: @printf
        !           988: Print formatted text
        !           989: int printf(format, [arg1, .... argN])
        !           990: char *format; [data type] arg1, ... argN;
        !           991: @proc.h
        !           992: Define structures/constants used with processes
        !           993: #define <sys/proc.h>
        !           994: @PS1
        !           995: User's default prompt
        !           996: PS1=prompt
        !           997: @PS2
        !           998: Prompt when user enters's sub-shell
        !           999: PS2=prompt
        !          1000: @ptrace
        !          1001: Trace process execution
        !          1002: #include <signal.h>
        !          1003: int ptrace(command, pid, location, value)
        !          1004: int command, pid, *location, value;
        !          1005: @putc
        !          1006: Write character into stream
        !          1007: #include <stdio.h>
        !          1008: int putc(c, fp) char c; FILE *fp;
        !          1009: @putchar
        !          1010: Write a character onto the standard output
        !          1011: #include <stdio.h>
        !          1012: int putchar(c) char c;
        !          1013: @puts
        !          1014: Write string onto standard output
        !          1015: #include <stdio.h>
        !          1016: void puts(string) char *string
        !          1017: @putw
        !          1018: Write word into stream
        !          1019: #include <stdio.h>
        !          1020: int putw(word, fp) int word; FILE *fp;
        !          1021: @pwd.h
        !          1022: Declare password structure
        !          1023: #include <pwd.h>
        !          1024: @qsort
        !          1025: Sort arrays in memory
        !          1026: void qsort(data, n, size, comp) char *data; int n, size; int (*comp)();
        !          1027: @rand
        !          1028: Generate pseudo-random numbers
        !          1029: int rand()
        !          1030: @read
        !          1031: Read from a file
        !          1032: int read(fd, buffer, n) int fd; char *buffer; int n;
        !          1033: @readonly
        !          1034: Storage class
        !          1035: @realloc
        !          1036: Reallocate dynamic memory
        !          1037: char *realloc(ptr, size) char *ptr; unsigned size;
        !          1038: @register
        !          1039: Storage class
        !          1040: @return
        !          1041: Return a value and control to calling function
        !          1042: @rewind
        !          1043: Reset file pointer
        !          1044: #include <stdio.h>
        !          1045: int rewind(fp) FILE *fp;
        !          1046: @rindex
        !          1047: Find a character in a string
        !          1048: char *rindex(string, c) char *string; char c;
        !          1049: @rpow
        !          1050: Raise multiple-precision integer to power
        !          1051: #include <mprec.h>
        !          1052: void rpow(a, b, c)
        !          1053: mint *a, *b, *c;
        !          1054: @sbrk
        !          1055: Increase a program's data space
        !          1056: char *sbrk(increment) unsigned int increment;
        !          1057: @scanf
        !          1058: Accept and format input
        !          1059: #include <stdio.h>
        !          1060: int scanf(format, arg1, ... argN)
        !          1061: char *format; [data type] *arg1, ... *argN;
        !          1062: @proc.h
        !          1063: Define constants used with scheduling
        !          1064: #define <sys/sched.h>
        !          1065: @sdiv
        !          1066: Divide multiple-precision integers
        !          1067: #include <mprec.h>
        !          1068: void sdiv(a, n, q, ip)
        !          1069: mint *a, *q; int n, *ip;
        !          1070: @semget
        !          1071: #include <sys/sem.h>
        !          1072: semget(key, nsems, semflg)
        !          1073: key_t key;
        !          1074: int nsems, semflg;
        !          1075: @semop
        !          1076: Perform semaphore operations
        !          1077: #include <sys/sem.h>
        !          1078: semop(semid, sops, nsops)
        !          1079: int semid, nsops;
        !          1080: struct sembuf(sops)[];
        !          1081: @setbuf
        !          1082: Set alternative stream buffers
        !          1083: #include <stdio.h>
        !          1084: void setbuf(fp, buffer) FILE *fp; char *buffer;
        !          1085: @setgid
        !          1086: Set group id and user id
        !          1087: int setgid(id) int id;
        !          1088: @setgrent
        !          1089: Rewind group file
        !          1090: #include <grp.h>
        !          1091: struct group *setgrent();
        !          1092: @setjmp
        !          1093: Perform non-local goto
        !          1094: #include <setjmp.h>
        !          1095: int setjmp(env) jmp_buf env;
        !          1096: @setjmp.h
        !          1097: Define setjmp() and longjmp()
        !          1098: #include <setjmp.h>
        !          1099: @setpwent
        !          1100: Rewind password file
        !          1101: #include <pwd.h>
        !          1102: setpwent()
        !          1103: @settz
        !          1104: Set local time zone
        !          1105: #include <time.h>
        !          1106: #include <sys/types.h>
        !          1107: void settz()
        !          1108: extern long timezone
        !          1109: char *txname[2][16]
        !          1110: @setuid
        !          1111: Set user id
        !          1112: int setuid(id) int id;
        !          1113: @SHELL
        !          1114: Name the default shell
        !          1115: SHELL=shell
        !          1116: @shellsort
        !          1117: Sort arrays in memory
        !          1118: void shellsort(data, n, size, comp)
        !          1119: char *data; int n, size; int (*comp)();
        !          1120: @shmctl
        !          1121: Control shared-memory operations
        !          1122: #include <sys/shm.h>
        !          1123: shmctl(shmid, cmd, buf)
        !          1124: int shmid, cmd;
        !          1125: struct shmid_ds *buf;
        !          1126: @shmget
        !          1127: Get shared-memory segment
        !          1128: #include <sys/shm.h>
        !          1129: shmget(key, size, shmflg)
        !          1130: key_t key;
        !          1131: int size, shmflg;
        !          1132: @short
        !          1133: Data type
        !          1134: @signal
        !          1135: Specify disposition of a signal
        !          1136: #include <signal.h>
        !          1137: #include <msig.h>
        !          1138: int (*signal(signum, action))()
        !          1139: int signum, (*action)();
        !          1140: @signal.h
        !          1141: Declare signals
        !          1142: #include <signal.h>
        !          1143: @sin
        !          1144: Calculate sine
        !          1145: #include <math.h>
        !          1146: double sin(radian) double radian;
        !          1147: @sinh
        !          1148: Calculate hyperbolic sine
        !          1149: #include <math.h>
        !          1150: double sinh(radian) double radian;
        !          1151: @sizeof
        !          1152: Return size of a data element
        !          1153: @sload
        !          1154: Load device driver
        !          1155: #include <con.h>
        !          1156: int sload(major, file, conp)
        !          1157: int major;
        !          1158: char *file;
        !          1159: CON *conp;
        !          1160: @smult
        !          1161: Multiple multiple-precision integers
        !          1162: #include <mprec.h>
        !          1163: void smult(a, n, c)
        !          1164: mint *a, *c; int n;
        !          1165: @spow
        !          1166: Raise multiple-precision integer to power
        !          1167: #include <mprec.h>
        !          1168: void spow(a, n, b)
        !          1169: mint *a, *b; int n;
        !          1170: @sprintf
        !          1171: Format output
        !          1172: #include <stdio.h>
        !          1173: int sprintf(string, format [ , arg ] ...)
        !          1174: char *string, *format;
        !          1175: @sqrt
        !          1176: Compute square root
        !          1177: #include <math.h>
        !          1178: double sqrt(z) double z;
        !          1179: @srand
        !          1180: Seed random number generator
        !          1181: void srand(seed) int seed;
        !          1182: @sscanf
        !          1183: Format a string
        !          1184: #include <stdio.h>
        !          1185: int sscanf(string, format [, arg ] ...)
        !          1186: char *string; char *format;
        !          1187: @stat
        !          1188: Find file attributes
        !          1189: #include <sys/stat.h>
        !          1190: int stat(file, statptr)
        !          1191: char *file; struct stat *statptr;
        !          1192: @static
        !          1193: Declare storage class
        !          1194: @stddef.h
        !          1195: Header for standard definitions
        !          1196: #include <stddef.h>
        !          1197: @stdio.h
        !          1198: Declarations and definitions for I/O
        !          1199: @stime
        !          1200: Set the time
        !          1201: #include <sys/types.h>
        !          1202: int stime(timep)
        !          1203: time_t *timep;
        !          1204: @strcat
        !          1205: Concatenate strings
        !          1206: #include <string.h>
        !          1207: char *strcat(string1, string2) char *string1, *string2;
        !          1208: @strcmp
        !          1209: Compare two strings
        !          1210: #include <string.h>
        !          1211: int strcmp(string1, string2) char *string1, *string2;
        !          1212: strcoll() Library function 
        !          1213: @strcoll()
        !          1214: Compare two strings, using locale-specific information
        !          1215: #include <string.h>
        !          1216: int strcoll(string1, string2);
        !          1217: char *string1; char *string2; 
        !          1218: @strcpy
        !          1219: Copy one string into another
        !          1220: #include <string>
        !          1221: char *strcpy(string1, string2) char *string1, *string2;
        !          1222: strcspn() Library function 
        !          1223: @strcspn()
        !          1224: Return length a string excludes characters in another
        !          1225: #include <string.h>
        !          1226: unsigned int strcspn(string1, string2);
        !          1227: char *string1, *string2; 
        !          1228: @stream.h
        !          1229: strerror()
        !          1230: Translate an error number into a string
        !          1231: #include <string.h>
        !          1232: char *strerror(error); int error;
        !          1233: string.h Header 
        !          1234: @string.h
        !          1235: #include <string.h>
        !          1236: @strlen
        !          1237: Measure the length of a string
        !          1238: #include <string.h>
        !          1239: int strlen(string) char *string;
        !          1240: @strncat
        !          1241: Append one string onto another
        !          1242: #include <string.h>
        !          1243: char *strncat(string1, string2, n)
        !          1244: char *string1, *string2; unsigned n;
        !          1245: @strncmp
        !          1246: Compare two strings
        !          1247: #include <string.h>
        !          1248: int strncmp(string1, string2, n)
        !          1249: char *string1, *string2; unsigned n;
        !          1250: @strncpy
        !          1251: Copy one string into another
        !          1252: #include <string.h>
        !          1253: char *strncpy(string1, string2, n)
        !          1254: char *string1, *string2; unsigned n;
        !          1255: @strpbrk()
        !          1256: Find first occurrence of a character from another string
        !          1257: #include <string.h>
        !          1258: char *strpbrk(string1, string2);
        !          1259: char *string1, *string2; 
        !          1260: @strrchr()
        !          1261: Search for rightmost occurrence of a character in a string
        !          1262: #include <string.h>
        !          1263: char *strrchr(string, character);
        !          1264: char *string; int character; 
        !          1265: @strspn()
        !          1266: Return length a string includes characters in another
        !          1267: #include <string.h>
        !          1268: unsigned int strspn(string1, string2);
        !          1269: char *string1; char *string2; 
        !          1270: @strstr()
        !          1271: Find one string within another
        !          1272: #include <string.h>
        !          1273: char *strstr(string1, string2);
        !          1274: char *string1, *string2; 
        !          1275: @strtok()
        !          1276: Break a string into tokens
        !          1277: #include <string.h>
        !          1278: char *strtok(string1, string2);
        !          1279: char *string1, *string2; 
        !          1280: @struct
        !          1281: Data type
        !          1282: @strxfrm()
        !          1283: Transform a string
        !          1284: #include <string.h>
        !          1285: unsigned int strxfrm(string1, string2, n);
        !          1286: char *string1, *string2; unsigned int n; 
        !          1287: @suload
        !          1288: Unload device driver
        !          1289: #include <con.h>
        !          1290: int suload(major)
        !          1291: int major;
        !          1292: @swab
        !          1293: Swap a pair of bytes
        !          1294: void swab(src, dest, nb) char *src, *dest; unsigned nb;
        !          1295: @switch
        !          1296: Test a variable against a table
        !          1297: @system
        !          1298: Pass a command to the shell for execution
        !          1299: int system(commandline) char *commandline;
        !          1300: @tan
        !          1301: Calculate tangent
        !          1302: #include <math.h>
        !          1303: double tan(radian) double radian;
        !          1304: @tanh
        !          1305: Calculate hyperbolic cosine
        !          1306: #include <math.h>
        !          1307: double tanh(radian) double radian;
        !          1308: @tempnam()
        !          1309: Generate a unique name for a temporary file
        !          1310: char *tempnam(directory, name);
        !          1311: char *directory, name; 
        !          1312: @TERM
        !          1313: Name the default terminal type
        !          1314: TERM=terminal type
        !          1315: @termio.h
        !          1316: tgetent
        !          1317: Read termcap entry
        !          1318: int tgetent(bp, name)
        !          1319: char *bp, *name;
        !          1320: @tgetflag
        !          1321: Get termcap Boolean entry
        !          1322: int tgetflag(id)
        !          1323: char *id;
        !          1324: @tgetnum
        !          1325: Get termcap numeric feature
        !          1326: int tgetnum(id)
        !          1327: char *id;
        !          1328: @tgetstr
        !          1329: Get termcap string entry
        !          1330: char *tgetstr(id, area)
        !          1331: char *id, **area;
        !          1332: @tgetent
        !          1333: Read/interpret termcap cursor-addressing string
        !          1334: char *tgoto(cm, destcol, destline)
        !          1335: char *cm;
        !          1336: int destcol, destline;
        !          1337: @time
        !          1338: Get current time
        !          1339: #include <time.h>
        !          1340: time_t time(tp) time_t *tp;
        !          1341: @time.h
        !          1342: Give time-description structure
        !          1343: #include <time.h>
        !          1344: @timeb.h
        !          1345: Declare timeb structure
        !          1346: #include <sys/timeb.h>
        !          1347: @timef.h
        !          1348: timeout.h
        !          1349: Define the timer queue
        !          1350: #define <timeout.h>
        !          1351: @times
        !          1352: Obtain process execution times
        !          1353: #include <sys/times.h>
        !          1354: #include <sys/const.h>
        !          1355: int times(tbp)
        !          1356: struct tbuffer *tbp;
        !          1357: @times.h
        !          1358: TIMEZONE
        !          1359: Time zone information
        !          1360: TIMEZONE=standard:offset[:daylight: date:date:hour:minutes]
        !          1361: @tmpnam()
        !          1362: Generate a unique name for a temporary file
        !          1363: #include <stdio.h>
        !          1364: char *tmpnam(name);
        !          1365: char *name; 
        !          1366: @tolower
        !          1367: Convert characters to lower case
        !          1368: int tolower(c) int c;
        !          1369: @toupper
        !          1370: Convert characters to upper case
        !          1371: #include <ctype.h>
        !          1372: int toupper(c) int c;
        !          1373: @tputs
        !          1374: Read/decode leading padding information
        !          1375: tputs(cp, affcnt, outc)
        !          1376: register char *cp;
        !          1377: int affcnt;
        !          1378: int (*outc)();
        !          1379: @tty.h
        !          1380: Define flags used with tty processing
        !          1381: #define <sys/tty.h>
        !          1382: @ttyname
        !          1383: Identify a terminal
        !          1384: char *ttyname(fd)
        !          1385: int fd;
        !          1386: @ttyslot
        !          1387: Return a terminal's line number
        !          1388: int ttyslot()
        !          1389: @typedef
        !          1390: Define a new data type
        !          1391: @types.h
        !          1392: Declare system-specific data types
        !          1393: #include <sys/types.h>
        !          1394: @umask
        !          1395: Set file creation mask
        !          1396: int umask(mask)
        !          1397: int mask;
        !          1398: @ungetc
        !          1399: Return character to input stream
        !          1400: #include <stdio.h>
        !          1401: int ungetc (c, fp) int c; FILE *fp;
        !          1402: @union
        !          1403: Multiply declare a variable
        !          1404: @unlink
        !          1405: Remove a file
        !          1406: int unlink(name) char *name;
        !          1407: @unsigned
        !          1408: Data type
        !          1409: @USER
        !          1410: Name user's ID
        !          1411: USER=user's ID
        !          1412: @utime
        !          1413: Change file access and modification times
        !          1414: #include <sys/types.h>
        !          1415: int utime(file, times)
        !          1416: char *file;
        !          1417: time_t times[2];
        !          1418: @utmp.h
        !          1419: Login accounting information
        !          1420: #include <utmp.h>
        !          1421: @utsname.h
        !          1422: Define utsname structure
        !          1423: #define <sys/utsname.h>
        !          1424: @v7sgtty.h
        !          1425: UNIX Version 7-style terminal I/O
        !          1426: #define <v7sgtty.h>
        !          1427: @void
        !          1428: Data type
        !          1429: @volatile
        !          1430: volatile C keyword 
        !          1431: Qualify an identifier as frequently changing
        !          1432: @wait
        !          1433: Await completion of a child process
        !          1434: wait(statp)
        !          1435: int *statp;
        !          1436: @while
        !          1437: Introduce a loop
        !          1438: while(condition)
        !          1439: @write
        !          1440: Write to a file
        !          1441: int write(fd, buffer, n)
        !          1442: int fd; char *buffer; int n;
        !          1443: @xgcd
        !          1444: Extended greatest-common-divisor function
        !          1445: #include <mprec.h>
        !          1446: void xgcd(a, b, r, s, g)
        !          1447: mint *a, *b, *r, *s, *g;
        !          1448: @zerop
        !          1449: Indicate if multi-precision integer is zero
        !          1450: #include <mprec.h>
        !          1451: int zerop(a)
        !          1452: mint *a;
        !          1453: @

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