Return to helpfile CVS log

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

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

1.1     ! root        1: @__DATE__
        !             2: __DATE__ -- Date of translation
        !             3: 
        !             4: 
        !             5: @__FILE__
        !             6: __FILE__ -- Source file name
        !             7: 
        !             8: 
        !             9: @__LINE__
        !            10: __LINE__ -- Current line within a source file
        !            11: 
        !            12: 
        !            13: @__STDC__
        !            14: __STDC__ -- Mark a conforming translator
        !            15: 
        !            16: 
        !            17: @__TIME__
        !            18: __TIME__ -- Time source file is translated
        !            19: 
        !            20: 
        !            21: @_exit
        !            22: _exit() -- Terminate a program
        !            23: 
        !            24: void _exit(status) int status;
        !            25: 
        !            26: @abort
        !            27: abort() -- End program immediately
        !            28: 
        !            29: void abort()
        !            30: 
        !            31: @abs
        !            32: abs() -- Return the absolute value of an integer
        !            33: 
        !            34: int abs(n) int n;
        !            35: 
        !            36: @access
        !            37: access() -- Check if a file can be accessed in a given mode
        !            38: 
        !            39: #include <access.h>
        !            40: int access(filename, mode) char *filename; int mode;
        !            41: 
        !            42: @access.h
        !            43: access.h -- Check accessibility
        !            44: 
        !            45: #include <access.h>
        !            46: 
        !            47: @acct
        !            48: acct() -- Enable/disable process accounting
        !            49: 
        !            50: acct(file)
        !            51: char *file;
        !            52: 
        !            53: @acct.h
        !            54: acct.h -- Format for process-accounting file
        !            55: 
        !            56: #include <acct.h>
        !            57: 
        !            58: @acos
        !            59: acos() -- Calculate inverse cosine
        !            60: 
        !            61: #include <math.h>
        !            62: double acos(arg) double arg;
        !            63: 
        !            64: @action.h
        !            65: action.h -- Describe parsing action and goto tables
        !            66: 
        !            67: #include <action.h>
        !            68: 
        !            69: @alarm
        !            70: alarm() -- Set a timer
        !            71: 
        !            72: alarm(n)
        !            73: unsigned n;
        !            74: 
        !            75: @alloc.h
        !            76: alloc.h -- Define the allocator
        !            77: 
        !            78: #include <sys/alloc.h>
        !            79: 
        !            80: @ar.h
        !            81: ar.h -- Format for archive files
        !            82: 
        !            83: #include <ar.h>
        !            84: 
        !            85: @ascii.h
        !            86: ascii.h -- Define non-printable ASCII characters
        !            87: 
        !            88: #include <ascii.h>
        !            89: 
        !            90: @asctime
        !            91: asctime() -- Convert time structure to ASCII string
        !            92: 
        !            93: #include <time.h>
        !            94: #include <sys/types.h>
        !            95: char *asctime(tmp) tm *tmp;
        !            96: 
        !            97: @asin
        !            98: asin() -- Calculate inverse sine
        !            99: 
        !           100: #include <math.h>
        !           101: double asin(arg) double arg;
        !           102: 
        !           103: @ASKCC
        !           104: ASKCC -- Force prompting for CC names
        !           105: 
        !           106: ASKCC=YES/NO
        !           107: 
        !           108: @assert
        !           109: assert() -- Check assertion at run time
        !           110: 
        !           111: #include <assert.h>
        !           112: void assert(expression) int expression;
        !           113: 
        !           114: @assert.h
        !           115: assert.h -- Define assert()
        !           116: 
        !           117: #include <assert.h>
        !           118: 
        !           119: @atan
        !           120: atan() -- Calculate inverse tangent
        !           121: 
        !           122: #include <math.h>
        !           123: double atan(arg) double arg;
        !           124: 
        !           125: @atan2
        !           126: atan2() -- Calculate inverse tangent
        !           127: 
        !           128: double atan2(num, den) double num, den;
        !           129: 
        !           130: @atof
        !           131: atof() -- Convert ASCII strings to floating point
        !           132: 
        !           133: double atof(string) char * string;
        !           134: 
        !           135: @atoi
        !           136: atoi() -- Convert ASCII strings to integers
        !           137: 
        !           138: int atoi(string) char *string;
        !           139: 
        !           140: @atol
        !           141: atol() -- Convert ASCII strings to long integers
        !           142: 
        !           143: long atol(string) char *string;
        !           144: 
        !           145: @auto
        !           146: auto -- Note an automatic variable
        !           147: 
        !           148: 
        !           149: @break
        !           150: break -- Exit from loop or switch statement
        !           151: 
        !           152: 
        !           153: @brk
        !           154: brk() -- Change size of data area
        !           155: 
        !           156: brk(addr)
        !           157: char *addr;
        !           158: 
        !           159: @bsearch
        !           160: bsearch() -- Search an array
        !           161: 
        !           162: #include <stdlib.h>
        !           163: char *bsearch(key, array, number, size, comparison)
        !           164: char *key, *array;
        !           165: size_t number, size;
        !           166: int (*comparison)();
        !           167: 
        !           168: @buf.h
        !           169: buf.h -- Buffer header
        !           170: 
        !           171: #include <sys/buf.h>
        !           172: 
        !           173: @cabs
        !           174: cabs() -- Complex absolute value function
        !           175: 
        !           176: #include <math.h>
        !           177: double cabs(z) struct { double r, i; } z;
        !           178: 
        !           179: @calloc
        !           180: calloc() -- Allocate dynamic memory
        !           181: 
        !           182: char *calloc(count, size) unsigned count, size;
        !           183: 
        !           184: @candaddr
        !           185: candaddr() -- Convert a daddr_t to canonical format
        !           186: 
        !           187: #include <canon.h>
        !           188: #include <sys/types.h>
        !           189: void candaddr(s)
        !           190: daddr_t s;
        !           191: 
        !           192: @candev
        !           193: candev() -- Convert a dev_t to canonical format
        !           194: 
        !           195: #include <canon.h>
        !           196: #include <sys/types.h>
        !           197: void candev(s)
        !           198: dev_t s;
        !           199: 
        !           200: @canino
        !           201: canino() -- Convert an ino_t to canonical format
        !           202: 
        !           203: #include <canon.h>
        !           204: #include <sys/types.h>
        !           205: void canino(s)
        !           206: ino_t s;
        !           207: 
        !           208: @canint
        !           209: canint() -- Convert an int to canonical format
        !           210: 
        !           211: #include <canon.h>
        !           212: #include <sys/types.h>
        !           213: void canint(s)
        !           214: int s;
        !           215: 
        !           216: @canlong
        !           217: canlong() -- Convert a long to canonical format
        !           218: 
        !           219: #include <canon.h>
        !           220: #include <sys/types.h>
        !           221: void canlong(s)
        !           222: long s;
        !           223: 
        !           224: @canon.h
        !           225: canon.h -- Portable layout of binary data
        !           226: 
        !           227: #include <canon.h>
        !           228: #include <sys/types.h>
        !           229: 
        !           230: @canshort
        !           231: canshort() -- Convert a short to canonical format
        !           232: 
        !           233: #include <canon.h>
        !           234: #include <sys/types.h>
        !           235: void canshort(s)
        !           236: short s;
        !           237: 
        !           238: @cansize
        !           239: cansize() -- Convert an fsize_t to canonical format
        !           240: 
        !           241: #include <canon.h>
        !           242: #include <sys/types.h>
        !           243: void cansize(s)
        !           244: size_t s;
        !           245: 
        !           246: @cantime
        !           247: cantime() -- Convert a time_t to canonical format
        !           248: 
        !           249: #include <canon.h>
        !           250: #include <sys/types.h>
        !           251: void cantime(s)
        !           252: time_t s;
        !           253: 
        !           254: @canvaddr
        !           255: canvaddr() -- Convert a vaddr_t to canonical format
        !           256: 
        !           257: #include <canon.h>
        !           258: #include <sys/types.h>
        !           259: void canvaddr(s)
        !           260: vaddr_t s;
        !           261: 
        !           262: @case
        !           263: case -- Introduce entry in switch statement
        !           264: 
        !           265: 
        !           266: @ceil
        !           267: ceil() -- Set numeric ceiling
        !           268: 
        !           269: #include <math.h>
        !           270: double ceil(z) double z;
        !           271: 
        !           272: @char
        !           273: char -- Data type
        !           274: 
        !           275: 
        !           276: @chars.h
        !           277: chars.h -- Character definitions
        !           278: 
        !           279: #include <chars.h>
        !           280: 
        !           281: @chdir
        !           282: chdir() -- Change working directory
        !           283: 
        !           284: chdir(directory) char *directory;
        !           285: 
        !           286: @chmod
        !           287: chmod() -- Change file-protection modes
        !           288: 
        !           289: #include <sys/stat.h>
        !           290: chmod(file, mode)
        !           291: char *file; int mode;
        !           292: 
        !           293: @chown
        !           294: chown() -- Change ownership of a file
        !           295: 
        !           296: chown(file, uid, gid)
        !           297: char *file;
        !           298: short uid, gid;
        !           299: 
        !           300: @chroot
        !           301: chroot() -- Change process's root directory
        !           302: 
        !           303: int chroot(directory)
        !           304: char *directory;
        !           305: 
        !           306: @clearerr
        !           307: clearerr() -- Present stream status
        !           308: 
        !           309: #include <stdio.h>
        !           310: clearerr(fp) FILE *fp;
        !           311: 
        !           312: @close
        !           313: close() -- Close a file
        !           314: 
        !           315: int close(fd) int fd;
        !           316: 
        !           317: @con.h
        !           318: con.h -- Configure device drivers
        !           319: 
        !           320: #include <con.h>
        !           321: 
        !           322: @const
        !           323: const -- Qualify an identifier as not modifiable
        !           324: 
        !           325: 
        !           326: @const.h
        !           327: const.h -- Declare machine-dependent constants
        !           328: 
        !           329: #include <sys/const.h>
        !           330: 
        !           331: @continue
        !           332: continue -- Force next iteration of a loop
        !           333: 
        !           334: 
        !           335: @cos
        !           336: cos() -- Calculate cosine
        !           337: 
        !           338: #include <math.h>
        !           339: double cos(radian) double radian;
        !           340: 
        !           341: @cosh
        !           342: cosh() -- Calculate hyperbolic cosine
        !           343: 
        !           344: #include <math.h>
        !           345: double cosh(radian) double radian;
        !           346: 
        !           347: @creat
        !           348: creat() -- Create/truncate a file
        !           349: 
        !           350: int creat(file, mode) char *file; int mode;
        !           351: 
        !           352: @crypt
        !           353: crypt() -- Encryption using rotor algorithm
        !           354: 
        !           355: char *crypt(key, extra); char *key, *extra;
        !           356: 
        !           357: @ctime
        !           358: ctime() -- Convert system time to an ASCII string
        !           359: 
        !           360: #include <time.h>
        !           361: #include <sys/types.h>
        !           362: char *ctime(timep) time_t *timep;
        !           363: 
        !           364: @ctype.h
        !           365: ctype.h -- Header file for data tests
        !           366: 
        !           367: #include <ctype.h>
        !           368: 
        !           369: @curses.h
        !           370: curses.h -- Define functions and macros in curses library
        !           371: 
        !           372: #include <curses.h>
        !           373: 
        !           374: @CWD
        !           375: CWD -- Current working directory
        !           376: 
        !           377: 
        !           378: @default
        !           379: default -- Default label in switch statement
        !           380: 
        !           381: 
        !           382: @deftty.h
        !           383: deftty.h -- Define default tty settings
        !           384: 
        !           385: #include <sys/deftty.h>
        !           386: 
        !           387: @dir.h
        !           388: dir.h -- Directory format
        !           389: 
        !           390: #include <dir.h>
        !           391: 
        !           392: @dirent.h
        !           393: dirent.h -- Define dirent
        !           394: 
        !           395: #include <dirent.h>
        !           396: 
        !           397: @div
        !           398: div() -- Perform integer division
        !           399: 
        !           400: #include <stdlib.h>
        !           401: div_t div(numerator, denominator)
        !           402: int numerator, denominator;
        !           403: 
        !           404: @do
        !           405: do -- Introduce a loop
        !           406: 
        !           407: 
        !           408: @double
        !           409: double -- Data type
        !           410: 
        !           411: 
        !           412: @dumptape.h
        !           413: dumptape.h -- Define data structures used on dump tapes
        !           414: 
        !           415: #include <dumptape.h>
        !           416: 
        !           417: @dup
        !           418: dup() -- Duplicate a file descriptor
        !           419: 
        !           420: int dup(fd) int fd;
        !           421: 
        !           422: @dup2
        !           423: dup2() -- Duplicate a file descriptor
        !           424: 
        !           425: int dup2(fd, newfd) int fd, newfd;
        !           426: 
        !           427: @ebcdic.h
        !           428: ebcdic.h -- Define manifest constants for non-printable EBCDIC characters
        !           429: 
        !           430: #include <ebcdic.h>
        !           431: 
        !           432: @else
        !           433: else -- Introduce a conditional statement
        !           434: 
        !           435: 
        !           436: @endgrent
        !           437: endgrent() -- Close group file
        !           438: 
        !           439: #include <grp.h>
        !           440: endgrent()
        !           441: 
        !           442: @endpwent
        !           443: endpwent() -- Close password file
        !           444: 
        !           445: #include <pwd.h>
        !           446: endpwent()
        !           447: 
        !           448: @enum
        !           449: enum -- Declare a type and identifiers
        !           450: 
        !           451: 
        !           452: @ENV
        !           453: ENV -- File read to set environment
        !           454: 
        !           455: 
        !           456: @errno.h
        !           457: errno.h -- Error numbers used by errno()
        !           458: 
        !           459: #include <errno.h>
        !           460: 
        !           461: @execl
        !           462: execl() -- Execute a load module
        !           463: 
        !           464: execl(file, arg0, arg1, ..., argn, NULL)
        !           465: char *file, *arg0, *arg1, ..., *argn;
        !           466: 
        !           467: @execle
        !           468: execle() -- Execute a load module
        !           469: 
        !           470: execle(file, arg0, arg1, ..., argn, NULL, env)
        !           471: char *file, *arg0, *arg1, ..., *argn, char *env[];
        !           472: 
        !           473: @execlp
        !           474: execlp() -- Execute a load module
        !           475: 
        !           476: execlp(file, arg0, arg1, ..., argn, NULL)
        !           477: char *file, *arg0, *arg1, ..., *argn;
        !           478: 
        !           479: @execv
        !           480: execv() -- Execute a load module
        !           481: 
        !           482: execv(file, argv)
        !           483: char *file, *argv[];
        !           484: 
        !           485: @execve
        !           486: execve() -- Execute a load module
        !           487: 
        !           488: execve(file, argv, env)
        !           489: char *file, *argv[], *env[];
        !           490: 
        !           491: @execvp
        !           492: execvp() -- Execute a load module
        !           493: 
        !           494: execvp(file, argv)
        !           495: char *file, *argv[];
        !           496: 
        !           497: @exit
        !           498: exit() -- Terminate a program gracefully
        !           499: 
        !           500: void exit(status) int status;
        !           501: 
        !           502: @exp
        !           503: exp() -- Compute exponent
        !           504: 
        !           505: #include <math.h>
        !           506: double exp(z) double z;
        !           507: 
        !           508: @extern
        !           509: extern -- Declare storage class
        !           510: 
        !           511: 
        !           512: @fabs
        !           513: fabs() -- Compute absolute value
        !           514: 
        !           515: #include <math.h>
        !           516: double fabs(z) double z;
        !           517: 
        !           518: @fblk.h
        !           519: fblk.h -- Define the disk-free block
        !           520: 
        !           521: #include <sys/fblk.h>
        !           522: 
        !           523: @FCEDIT
        !           524: FCEDIT -- Editor used by fc command
        !           525: 
        !           526: 
        !           527: @fclose
        !           528: fclose() -- Close a stream
        !           529: 
        !           530: #include <stdio.h>
        !           531: int fclose(fp) FILE *fp;
        !           532: 
        !           533: @fcntl
        !           534: fcntl() -- Control open files
        !           535: 
        !           536: int fcntl(fd, command, arg)
        !           537: int fd, cmd;
        !           538: 
        !           539: @fcntl.h
        !           540: fcntl.h -- Manifest constants for file-handling functions
        !           541: 
        !           542: #include <sys/fcntl.h>
        !           543: 
        !           544: @fd.h
        !           545: fd.h -- Declare file-descriptor structure
        !           546: 
        !           547: #include <sys/fd.h>
        !           548: 
        !           549: @fdioctl.h
        !           550: fdioctl.h -- Control floppy-disk I/O
        !           551: 
        !           552: #include <sys/fdioctl.h>
        !           553: 
        !           554: @fdisk.h
        !           555: fdisk.h -- Fixed-disk constants and structures
        !           556: 
        !           557: #include <sys/fdisk.h>
        !           558: 
        !           559: @fdopen
        !           560: fdopen() -- Open a stream for standard I/O
        !           561: 
        !           562: #include <stdio.h>
        !           563: FILE *fdopen(fd, type) int fd; char *type;
        !           564: 
        !           565: @feof
        !           566: feof() -- Discover stream status
        !           567: 
        !           568: #include <stdio.h>
        !           569: int feof(fp) FILE *fp;
        !           570: 
        !           571: @ferror
        !           572: ferror() -- Discover stream status
        !           573: 
        !           574: #include <stdio.h>
        !           575: int ferror(fp) FILE *fp;
        !           576: 
        !           577: @fflush
        !           578: fflush() -- Flush output stream's buffer
        !           579: 
        !           580: #include <stdio.h>
        !           581: int fflush(fp) FILE *fp;
        !           582: 
        !           583: @fgetc
        !           584: fgetc() -- Read character from stream
        !           585: 
        !           586: #include <stdio.h>
        !           587: int fgetc(fp) FILE *fp;
        !           588: 
        !           589: @fgets
        !           590: fgets() -- Read line from stream
        !           591: 
        !           592: #include <stdio.h>
        !           593: char *fgets(s, n, fp) char *s; int n; FILE *fp;
        !           594: 
        !           595: @fgetw
        !           596: fgetw() -- Read integer from stream
        !           597: 
        !           598: #include <stdio.h>
        !           599: int fgetw(fp) FILE *fp;
        !           600: 
        !           601: @fileno
        !           602: fileno() -- Get file descriptor
        !           603: 
        !           604: #include <stdio.h>
        !           605: int fileno(fp) FILE *fp;
        !           606: 
        !           607: @filsys.h
        !           608: filsys.h -- Structures and constants for super block
        !           609: 
        !           610: #include <sys/filsys.h>
        !           611: 
        !           612: @float
        !           613: float -- Data type
        !           614: 
        !           615: 
        !           616: @floor
        !           617: floor() -- Set a numeric floor
        !           618: 
        !           619: #include <math.h>
        !           620: double floor(z) double z;
        !           621: 
        !           622: @fopen
        !           623: fopen() -- Open a stream for standard I/O
        !           624: 
        !           625: #include <stdio.h>
        !           626: FILE *fopen (name, type) char *name, *type;
        !           627: 
        !           628: @for
        !           629: for -- Control a loop
        !           630: 
        !           631: for(initialization; endcondition; modification)
        !           632: 
        !           633: @fork
        !           634: fork() -- Create a new process
        !           635: 
        !           636: fork()
        !           637: 
        !           638: @fperr.h
        !           639: fperr.h -- Constants used with floating-point exception codes
        !           640: 
        !           641: #include <fperr.h>
        !           642: 
        !           643: @fprintf
        !           644: fprintf() -- Print formatted output into file stream
        !           645: 
        !           646: int fprintf(fp, format, [arg1, .... argN])
        !           647: FILE *fp; char *format;
        !           648: [data type] arg1, ... argN;
        !           649: 
        !           650: @fputc
        !           651: fputc() -- Write character into file stream
        !           652: 
        !           653: #include <stdio.h>
        !           654: int fputc(c, fp) char c; FILE *fp;
        !           655: 
        !           656: @fputs
        !           657: fputs() -- Write string into file stream
        !           658: 
        !           659: #include <stdio.h>
        !           660: int fputs(string, fp) char *string; FILE *fp;
        !           661: 
        !           662: @fputw
        !           663: fputw() -- Write an integer into a stream
        !           664: 
        !           665: #include <stdio.h>
        !           666: int fputw(word, fp) int word; FILE *fp;
        !           667: 
        !           668: @fread
        !           669: fread() -- Read data from file stream
        !           670: 
        !           671: #include <stdio.h>
        !           672: int fread(buffer, size, n, fp)
        !           673: char *buffer; unsigned size, n; FILE *fp;
        !           674: 
        !           675: @free
        !           676: free() -- Return dynamic memory to free memory pool
        !           677: 
        !           678: void free(ptr) char *ptr;
        !           679: 
        !           680: @freopen
        !           681: freopen() -- Open file stream for standard I/O
        !           682: 
        !           683: #include <stdio.h>
        !           684: FILE *freopen (name, type, fp)
        !           685: char *name, *type; FILE *fp;
        !           686: 
        !           687: @frexp
        !           688: frexp() -- Separate fraction and exponent
        !           689: 
        !           690: double frexp(real, ep) double real; int *ep;
        !           691: 
        !           692: @fscanf
        !           693: fscanf() -- Format input from a file stream
        !           694: 
        !           695: #include <stdio.h>
        !           696: int fscanf(fp, format, arg1, ... argN)
        !           697: FILE *fp; char *format;
        !           698: [data type] *arg1, ... *argN;
        !           699: 
        !           700: @fseek
        !           701: fseek() -- Seek on file stream
        !           702: 
        !           703: #include <stdio.h>
        !           704: int fseek(fp, where, how)
        !           705: FILE *fp; long where; int how;
        !           706: 
        !           707: @fstat
        !           708: fstat() -- Find file attributes
        !           709: 
        !           710: #include <sys/stat.h>
        !           711: fstat(descriptor, statptr) int descriptor; struct stat *statptr;
        !           712: 
        !           713: @ftell
        !           714: ftell() -- Return current position of file pointer
        !           715: 
        !           716: #include <stdio.h>
        !           717: long ftell(fp) FILE *fp;
        !           718: 
        !           719: @ftime
        !           720: ftime() -- Get the current time from the operating system
        !           721: 
        !           722: #include <sys/timeb.h>
        !           723: ftime(tbp) struct timeb *tbp;
        !           724: 
        !           725: @fwrite
        !           726: fwrite() -- Write into file stream
        !           727: 
        !           728: #include <stdio.h>
        !           729: int fwrite(buffer, size, n, fp)
        !           730: char *buffer; unsigned size, n; FILE *fp;
        !           731: 
        !           732: @gcd
        !           733: gcd() -- Set variable to greatest common divisor
        !           734: 
        !           735: #include <mprec.h>
        !           736: void gcd(a, b, c)
        !           737: mint *a, *b, *c;
        !           738: 
        !           739: @getc
        !           740: getc() -- Read character from file stream
        !           741: 
        !           742: #include <stdio.h>
        !           743: int getc(fp) FILE *fp;
        !           744: 
        !           745: @getchar
        !           746: getchar() -- Read character from standard input
        !           747: 
        !           748: #include <stdio.h>
        !           749: int getchar()
        !           750: 
        !           751: @getegid
        !           752: getegid() -- Get effective group identifier
        !           753: 
        !           754: getegid()
        !           755: 
        !           756: @getenv
        !           757: getenv() -- Read environmental variable
        !           758: 
        !           759: char *getenv(VARIABLE) char *VARIABLE;
        !           760: 
        !           761: @geteuid
        !           762: geteuid() -- Get effective user identifier
        !           763: 
        !           764: geteuid()
        !           765: 
        !           766: @getgid
        !           767: getgid() -- Get real group identifier
        !           768: 
        !           769: getgid()
        !           770: 
        !           771: @getgrent
        !           772: getgrent() -- Get group file information
        !           773: 
        !           774: #include <grp.h>
        !           775: struct group *getgrent();
        !           776: 
        !           777: @getgrgid
        !           778: getgrgid() -- Get group file information, by group name
        !           779: 
        !           780: #include <grp.h>
        !           781: struct group *getgrgid(gid);
        !           782: int gid;
        !           783: 
        !           784: @getgrnam
        !           785: getgrnam() -- Get group file information, by group id
        !           786: 
        !           787: #include <grp.h>
        !           788: struct group *getgrnam(gname);
        !           789: char *gname;
        !           790: 
        !           791: @getlogin
        !           792: getlogin() -- Get login name
        !           793: 
        !           794: char *getlogin()
        !           795: 
        !           796: @getopt
        !           797: getopt() -- Get option letter from argv
        !           798: 
        !           799: int getopt(argc, argv, optstring)
        !           800: int argc;
        !           801: char **argv;
        !           802: char *optstring;
        !           803: extern char *optarg;
        !           804: extern int optind;
        !           805: 
        !           806: @getpass
        !           807: getpass() -- Get password with prompting
        !           808: 
        !           809: char *getpass(prompt)
        !           810: char *prompt;
        !           811: 
        !           812: @getpid
        !           813: getpid() -- Get process identifier
        !           814: 
        !           815: getpid()
        !           816: 
        !           817: @getpw
        !           818: getpw() -- Search password file
        !           819: 
        !           820: getpw(uid, line)
        !           821: short uid;
        !           822: char *line;
        !           823: 
        !           824: @getpwent
        !           825: getpwent() -- Get password file information
        !           826: 
        !           827: #include <pwd.h>
        !           828: struct passwd *getpwent()
        !           829: 
        !           830: @getpwnam
        !           831: getpwnam() -- Get password file information, by name
        !           832: 
        !           833: #include <pwd.h>
        !           834: struct passwd *getpwnam(uname)
        !           835: char *uname;
        !           836: 
        !           837: @getpwuid
        !           838: getpwuid() -- Get password file information, by id
        !           839: 
        !           840: #include <pwd.h>
        !           841: struct passwd *getpwuid(uid)
        !           842: int uid;
        !           843: 
        !           844: @gets
        !           845: gets() -- Read string from standard input
        !           846: 
        !           847: #include <stdio.h>
        !           848: char *gets(buffer) char *buffer;
        !           849: 
        !           850: @getuid
        !           851: getuid() -- Get real user identifier
        !           852: 
        !           853: getuid()
        !           854: 
        !           855: @getw
        !           856: getw() -- Read word from file stream
        !           857: 
        !           858: #include <stdio.h>
        !           859: int getw(fp) FILE *fp;
        !           860: 
        !           861: @getwd
        !           862: getwd() -- Get current working directory name
        !           863: 
        !           864: char *getwd()
        !           865: 
        !           866: @gmtime
        !           867: gmtime() -- Convert system time to calendar structure
        !           868: 
        !           869: #include <time.h>
        !           870: #include <sys/types.h>
        !           871: tm *gmtime(timep) time_t *timep;
        !           872: 
        !           873: @goto
        !           874: goto -- Unconditionally jump within a function
        !           875: 
        !           876: 
        !           877: @grp.h
        !           878: grp.h -- Declare group structure
        !           879: 
        !           880: #include <grp.h>
        !           881: 
        !           882: @gtty
        !           883: gtty() -- Device-dependent control
        !           884: 
        !           885: #include <sgtty.h>
        !           886: int gtty(fd, sgp)
        !           887: int fd;
        !           888: struct sgttyb *sgp;
        !           889: 
        !           890: @hdioctl.h
        !           891: hdioctl.h -- Control hard-disk I/O
        !           892: 
        !           893: #include <sys/hdioctl.h>
        !           894: 
        !           895: @HOME
        !           896: HOME -- User's home directory
        !           897: 
        !           898: HOME=home directory
        !           899: 
        !           900: @hypot
        !           901: hypot() -- Compute hypotenuse of right triangle
        !           902: 
        !           903: #include <math.h>
        !           904: double hypot(x, y) double x, y;
        !           905: 
        !           906: @if
        !           907: if -- Introduce a conditional statement
        !           908: 
        !           909: 
        !           910: @IFS
        !           911: IFS -- Characters recognized as white space
        !           912: 
        !           913: 
        !           914: @index
        !           915: index() -- Find a character in a string
        !           916: 
        !           917: char *index(string, c) char *string; char c;
        !           918: 
        !           919: @ino.h
        !           920: ino.h -- Constants and structures for disk i-nodes
        !           921: 
        !           922: #include <sys/inode.h>
        !           923: 
        !           924: @inode.h
        !           925: inode.h -- Constants and structures for memory-resident i-nodes
        !           926: 
        !           927: #include <sys/inode.h>
        !           928: 
        !           929: @int
        !           930: int -- Data type
        !           931: 
        !           932: 
        !           933: @io.h
        !           934: io.h -- Constants and structures used by I/O
        !           935: 
        !           936: #include <sys/io.h>
        !           937: 
        !           938: @ioctl
        !           939: ioctl() -- Device-dependent control
        !           940: 
        !           941: ioctl(fd, command, info)
        !           942: int fd, command;
        !           943: char *info;
        !           944: 
        !           945: @ipc.h
        !           946: ipc.h -- Definitions for process communications
        !           947: 
        !           948: #include <sys/ipc.h>
        !           949: 
        !           950: @isalnum
        !           951: isalnum() -- Check if a character is a number or letter
        !           952: 
        !           953: #include <ctype.h>
        !           954: int isalnum(c) int c;
        !           955: 
        !           956: @isalpha
        !           957: isalpha() -- Check if a character is a letter
        !           958: 
        !           959: #include <ctype.h>
        !           960: int isalpha(c) int c;
        !           961: 
        !           962: @isascii
        !           963: isascii() -- Check if a character is an ASCII character
        !           964: 
        !           965: #include <ctype.h>
        !           966: int isascii(c) int c;
        !           967: 
        !           968: @isatty
        !           969: isatty() -- Check if a device is a terminal
        !           970: 
        !           971: int isatty(fd) int fd;
        !           972: 
        !           973: @iscntrl
        !           974: iscntrl() -- Check if a character is a control character
        !           975: 
        !           976: #include <ctype.h>
        !           977: int iscntrl(c) int c;
        !           978: 
        !           979: @isdigit
        !           980: isdigit() -- Check if a character is a numeral
        !           981: 
        !           982: #include <ctype.h>
        !           983: int isdigit(c) int c;
        !           984: 
        !           985: @islower
        !           986: islower() -- Check if a character is a lower-case letter
        !           987: 
        !           988: #include <ctype.h>
        !           989: int islower(c) int c;
        !           990: 
        !           991: @ispos
        !           992: ispos() -- Return if variable is positive or negative
        !           993: 
        !           994: #include <mprec.h>
        !           995: int ispos(a)
        !           996: mint *a;
        !           997: 
        !           998: @isprint
        !           999: isprint() -- Check if a character is printable
        !          1000: 
        !          1001: #include <ctype.h>
        !          1002: int isprint(c) int c;
        !          1003: 
        !          1004: @ispunct
        !          1005: ispunct() -- Check if a character is a punctuation mark
        !          1006: 
        !          1007: #include <ctype.h>
        !          1008: int ispunct(c) int c;
        !          1009: 
        !          1010: @isspace
        !          1011: isspace() -- Check if a character prints white space
        !          1012: 
        !          1013: #include <ctype.h>
        !          1014: int isspace(c) int c;
        !          1015: 
        !          1016: @isupper
        !          1017: isupper() -- Check if a character is an upper-case letter
        !          1018: 
        !          1019: #include <ctype.h>
        !          1020: int isupper(c) int c;
        !          1021: 
        !          1022: @itom
        !          1023: itom() -- Create a multiple-precision integer
        !          1024: 
        !          1025: #include <mprec.h>
        !          1026: mint *itom(n)
        !          1027: int n;
        !          1028: 
        !          1029: @j0
        !          1030: j0() -- Compute Bessel function
        !          1031: 
        !          1032: #include <math.h>
        !          1033: double j0(z) double z;
        !          1034: 
        !          1035: @j1
        !          1036: j1() -- Compute Bessel function
        !          1037: 
        !          1038: #include <math.h>
        !          1039: double j1(z) double z;
        !          1040: 
        !          1041: @jn
        !          1042: jn() -- Compute Bessel function
        !          1043: 
        !          1044: #include <math.h>
        !          1045: double jn(n, z) int n; double z;
        !          1046: 
        !          1047: @kill
        !          1048: kill() -- Kill a system process
        !          1049: 
        !          1050: #include <signal.h>
        !          1051: kill(pid, sig)
        !          1052: int pid, sig;
        !          1053: 
        !          1054: @KSH_VERSION
        !          1055: KSH_VERSION -- List current version of Korn shell
        !          1056: 
        !          1057: 
        !          1058: @l.out.h
        !          1059: l.out.h -- Object file format
        !          1060: 
        !          1061: #include <l.out.h>
        !          1062: 
        !          1063: @l3tol
        !          1064: l3tol() -- Convert file system block number to long integer
        !          1065: 
        !          1066: l3tol(lp, l3p, n)
        !          1067: long *lp;
        !          1068: char *l3p;
        !          1069: unsigned n;
        !          1070: 
        !          1071: @LASTERROR
        !          1072: LASTERROR -- Program that last generated an error
        !          1073: 
        !          1074: LASTERROR=program name
        !          1075: 
        !          1076: @ldexp
        !          1077: ldexp() -- Combine fraction and exponent
        !          1078: 
        !          1079: double ldexp(f, e) double f; int e;
        !          1080: 
        !          1081: @ldiv
        !          1082: ldiv() -- Perform long integer division
        !          1083: 
        !          1084: #include <stdlib.h>
        !          1085: ldiv_t ldiv(numerator, denominator)
        !          1086: long numerator, denominator;
        !          1087: 
        !          1088: @libraries
        !          1089: libraries -- Overview
        !          1090: 
        !          1091: 
        !          1092: @limits.h
        !          1093: limits.h -- Define numerical limits
        !          1094: 
        !          1095: #include <limits.h>
        !          1096: 
        !          1097: @link
        !          1098: link() -- Create a link
        !          1099: 
        !          1100: link(old, new)
        !          1101: char *old, *new;
        !          1102: 
        !          1103: @localtime
        !          1104: localtime() -- Convert system time to calendar structure
        !          1105: 
        !          1106: #include <time.h>
        !          1107: #include <sys/types.h>
        !          1108: tm *localtime(timep) time_t *timep;
        !          1109: 
        !          1110: @log
        !          1111: log() -- Compute natural logarithm
        !          1112: 
        !          1113: #include <math.h>
        !          1114: double log(z) double z;
        !          1115: 
        !          1116: @log10
        !          1117: log10() -- Compute common logarithm
        !          1118: 
        !          1119: #include <math.h>
        !          1120: double log10(z) double z;
        !          1121: 
        !          1122: @long
        !          1123: long -- Data type
        !          1124: 
        !          1125: 
        !          1126: @longjmp
        !          1127: longjmp() -- Return from a non-local goto
        !          1128: 
        !          1129: #include <setjmp.h>
        !          1130: int longjmp(env, rval) jmp_buf env; int rval;
        !          1131: 
        !          1132: @lpioctl.h
        !          1133: lpioctl.h -- Definitions for line-printer I/O control
        !          1134: 
        !          1135: #include <sys/lpioctl.h>
        !          1136: 
        !          1137: @lseek
        !          1138: lseek() -- Set read/write position
        !          1139: 
        !          1140: long lseek(fd, where, how)
        !          1141: int fd, how; long where;
        !          1142: 
        !          1143: @ltol3
        !          1144: ltol3() -- Convert long integer to file system block number
        !          1145: 
        !          1146: ltol3(l3p, lp, n)
        !          1147: char *l3p;
        !          1148: long *lp;
        !          1149: unsigned n;
        !          1150: 
        !          1151: @machine.h
        !          1152: machine.h -- Machine-dependent definitions
        !          1153: 
        !          1154: #include <sys/machine.h>
        !          1155: 
        !          1156: @madd
        !          1157: madd() -- Add multiple-precision integers
        !          1158: 
        !          1159: #include <mprec.h>
        !          1160: void madd(a, b, c)
        !          1161: mint *a, *b, *c;
        !          1162: 
        !          1163: @malloc
        !          1164: malloc() -- Allocate dynamic memory
        !          1165: 
        !          1166: char *malloc(size) unsigned size;
        !          1167: 
        !          1168: @malloc.h
        !          1169: malloc.h -- Definitions for memory-allocation functions
        !          1170: 
        !          1171: #include <sys/malloc.h>
        !          1172: 
        !          1173: @math.h
        !          1174: math.h -- Declare mathematics functions
        !          1175: 
        !          1176: #include <math.h>
        !          1177: 
        !          1178: @mathematics library
        !          1179: mathematics library -- Overview
        !          1180: 
        !          1181: 
        !          1182: @mcmp
        !          1183: mcmp() -- Compare multiple-precision integers
        !          1184: 
        !          1185: #include <mprec.h>
        !          1186: int mcmp(a, b)
        !          1187: mint *a, *b;
        !          1188: 
        !          1189: @mcopy
        !          1190: mcopy() -- Copy a multiple-precision integer
        !          1191: 
        !          1192: #include <mprec.h>
        !          1193: void mcopy(a, b)
        !          1194: mint *a, *b;
        !          1195: 
        !          1196: @mdata.h
        !          1197: mdata.h -- Define machine-specific magic numbers
        !          1198: 
        !          1199: #include <sys/mdata.h>
        !          1200: 
        !          1201: @mdiv
        !          1202: mdiv() -- Divide multiple-precision integers
        !          1203: 
        !          1204: #include <mprec.h>
        !          1205: void mdiv(a, b, q, r)
        !          1206: mint *a, *b, *q, *r;
        !          1207: 
        !          1208: @memccpy
        !          1209: memccpy() -- Copy one region of memory into another up to a requested character
        !          1210: 
        !          1211: #include <string.h>
        !          1212: char *memccpy(dest, src, c, n)
        !          1213: char *dest, *src; unsigned int c, n;
        !          1214: 
        !          1215: @memchr
        !          1216: memchr() -- Search a region of memory for a character
        !          1217: 
        !          1218: #include <string.h>
        !          1219: char *memchr(region, character, n)
        !          1220: char *region; int character; unsigned int n;
        !          1221: 
        !          1222: @memcmp
        !          1223: memcmp() -- Compare two regions
        !          1224: 
        !          1225: #include <string.h>
        !          1226: int memcmp(region1, region2, count)
        !          1227: char *region1; char *region2; unsigned int count;
        !          1228: 
        !          1229: @memcpy
        !          1230: memcpy() -- Copy one region of memory into another
        !          1231: 
        !          1232: #include <string.h>
        !          1233: char *memcpy(region1, region2, n)
        !          1234: char *region1; char *region2; unsigned int n;
        !          1235: 
        !          1236: @memmove
        !          1237: memmove() -- Copy region of memory into area it overlaps
        !          1238: 
        !          1239: #include <string.h>
        !          1240: char *memmove(region1, region2, count)
        !          1241: char *region1, char *region2, unsigned int count;
        !          1242: 
        !          1243: @memok
        !          1244: memok() -- Test if the arena is corrupted
        !          1245: 
        !          1246: memok();
        !          1247: 
        !          1248: @memset
        !          1249: memset() -- Fill an area with a character
        !          1250: 
        !          1251: #include <string.h>
        !          1252: char *memset(buffer, character, n)
        !          1253: char *buffer; int character; unsigned int n;
        !          1254: 
        !          1255: @min
        !          1256: min() -- Read multiple-precision integer from stdin
        !          1257: 
        !          1258: #include <mprec.h>
        !          1259: void min(a)
        !          1260: mint *a;
        !          1261: 
        !          1262: @minit
        !          1263: minit() -- Condition global or auto multiple-precision integer
        !          1264: 
        !          1265: #include <mprec.h>
        !          1266: void minit(a)
        !          1267: mint *a;
        !          1268: 
        !          1269: @mintfr
        !          1270: mintfr() -- Free a multiple-precision integer
        !          1271: 
        !          1272: #include <mprec.h>
        !          1273: void mintfr(a)
        !          1274: mint *a;
        !          1275: 
        !          1276: @mitom
        !          1277: mitom() -- Reinitialize a multiple-precision integer
        !          1278: 
        !          1279: #include <mprec.h>
        !          1280: void mitom(n, a)
        !          1281: mint *a; int n;
        !          1282: 
        !          1283: @mknod
        !          1284: mknod() -- Create a special file
        !          1285: 
        !          1286: #include <sys/ino.h>
        !          1287: #include <sys/stat.h>
        !          1288: mknod(name, mode, addr)
        !          1289: char *name; int mode, addr;
        !          1290: 
        !          1291: @mktemp
        !          1292: mktemp() -- Generate a temporary file name
        !          1293: 
        !          1294: char *mktemp(pattern) char *pattern;
        !          1295: 
        !          1296: @mneg
        !          1297: mneg() -- Negate multiple-precision integer
        !          1298: 
        !          1299: #include <mprec.h>
        !          1300: void mneg(a, b)
        !          1301: mint *a, *b;
        !          1302: 
        !          1303: @mnttab.h
        !          1304: mnttab.h -- Structure for mount table
        !          1305: 
        !          1306: #include <mnttab.h>
        !          1307: 
        !          1308: @modf
        !          1309: modf() -- Separate integral part and fraction
        !          1310: 
        !          1311: double modf(real, ip) double real, *ip;
        !          1312: 
        !          1313: @mon.h
        !          1314: mon.h -- Read profile output files
        !          1315: 
        !          1316: #include <mon.h>
        !          1317: 
        !          1318: @mount
        !          1319: mount() -- Mount a file system
        !          1320: 
        !          1321: #include <sys/mount.h>
        !          1322: #include <sys/filsys.h>
        !          1323: mount (special, name,flag)
        !          1324: char *special, *name; int flag;
        !          1325: 
        !          1326: @mount.h
        !          1327: mount.h -- Define the mount table
        !          1328: 
        !          1329: #include <sys/mount.h>
        !          1330: 
        !          1331: @mout
        !          1332: mout() -- Write multiple-precision integer to stdout
        !          1333: 
        !          1334: #include <mprec.h>
        !          1335: void mout(a)
        !          1336: mint *a;
        !          1337: 
        !          1338: @mprec.h
        !          1339: mprec.h -- Multiple-precision arithmetic
        !          1340: 
        !          1341: #include <mprec.h>
        !          1342: 
        !          1343: @msg.h
        !          1344: msg.h -- Definitions for message facility
        !          1345: 
        !          1346: #include <sys/msg.h>
        !          1347: 
        !          1348: @msgctl
        !          1349: msgctl() -- Message control operations
        !          1350: 
        !          1351: #include <sys/msg.h>
        !          1352: int msgctl(msqid, cmd, buf)
        !          1353: int msqid; int cmd; struct msqid_ds *buf;
        !          1354: 
        !          1355: @msgget
        !          1356: msgget() -- Get message queue
        !          1357: 
        !          1358: #include <sys/msg.h>
        !          1359: msgget(key, msgflg)
        !          1360: key_t key; int msgflg;
        !          1361: 
        !          1362: @msgrcv
        !          1363: msgrcv() -- Receive a message
        !          1364: 
        !          1365: #include <sys/msg.h>
        !          1366: msgrcv(msqid, msgp, msgsz, msgtyp, msgflg)
        !          1367: int msqid, msgsz, msgflg; struct msgbuf *msgp; long msgtyp;
        !          1368: 
        !          1369: @msgsnd
        !          1370: msgsnd() -- Send a message
        !          1371: 
        !          1372: #include <sys/msg.h>
        !          1373: msgsnd(msqid, msgp, msgsz, msgflg)
        !          1374: int msqid, msgsz, msgflg; struct msgbuf *msgp;
        !          1375: 
        !          1376: @msig.h
        !          1377: msig.h -- Machine-dependent signals
        !          1378: 
        !          1379: #include <signal.h>
        !          1380: 
        !          1381: @msqrt
        !          1382: msqrt() -- Compute square root of multiple-precision integer
        !          1383: 
        !          1384: #include <mprec.h>
        !          1385: void msqrt(a, b, r)
        !          1386: mint *a, *b, *r;
        !          1387: 
        !          1388: @msub
        !          1389: msub() -- Subtract multiple-precision integers
        !          1390: 
        !          1391: #include <mprec.h>
        !          1392: void msub(a, b, c)
        !          1393: mint *a, *b, *c;
        !          1394: 
        !          1395: @mtab.h
        !          1396: mtab.h -- Currently mounted file systems
        !          1397: 
        !          1398: #include <mtab.h>
        !          1399: 
        !          1400: @mtioctl.h
        !          1401: mtioctl.h -- Magnetic-tape I/O control
        !          1402: 
        !          1403: #include <sys/mtioctl.h>
        !          1404: 
        !          1405: @mtoi
        !          1406: mtoi() -- Convert multiple-precision integer to integer
        !          1407: 
        !          1408: #include <mprec.h>
        !          1409: int mtoi(a)
        !          1410: mint *a;
        !          1411: 
        !          1412: @mtos
        !          1413: mtos() -- Convert multiple-precision integer to string
        !          1414: 
        !          1415: #include <mprec.h>
        !          1416: char *mtos(a) mint *a;
        !          1417: 
        !          1418: @mtype
        !          1419: mtype() -- Return symbolic machine type
        !          1420: 
        !          1421: #include <mtype.h>
        !          1422: char *mtype(type)
        !          1423: int type;
        !          1424: 
        !          1425: @mtype.h
        !          1426: mtype.h -- List processor code numbers
        !          1427: 
        !          1428: #include <mtype.h>
        !          1429: 
        !          1430: @mult
        !          1431: mult() -- Multiply multiple-precision integers
        !          1432: 
        !          1433: #include <mprec.h>
        !          1434: void mult(a, b, c)
        !          1435: mint *a, *b, *c;
        !          1436: 
        !          1437: @mvfree
        !          1438: mvfree() -- Free multiple-precision integer
        !          1439: 
        !          1440: #include <mprec.h>
        !          1441: void mvfree(a)
        !          1442: mint *a;
        !          1443: 
        !          1444: @n.out.h
        !          1445: n.out.h -- Define n.out file structure
        !          1446: 
        !          1447: #include <n.out.h>
        !          1448: 
        !          1449: @nlist
        !          1450: nlist() -- Symbol table lookup
        !          1451: 
        !          1452: #include <l.out.h>
        !          1453: int nlist(file, nlp)
        !          1454: char *file;
        !          1455: struct nlist *nlp;
        !          1456: 
        !          1457: @notmem
        !          1458: notmem() -- Check if memory is allocated
        !          1459: 
        !          1460: int notmem(ptr);
        !          1461: char *ptr;
        !          1462: 
        !          1463: @open
        !          1464: open() -- Open a file
        !          1465: 
        !          1466: int open(file, type) char *file; int type;
        !          1467: 
        !          1468: @PAGER
        !          1469: PAGER -- Specify Output Filter
        !          1470: 
        !          1471: PAGER=command options
        !          1472: 
        !          1473: @param.h
        !          1474: param.h -- Define machine-specific parameters
        !          1475: 
        !          1476: #include <sys/param.h>
        !          1477: 
        !          1478: @PATH
        !          1479: PATH -- Directories that hold executable files
        !          1480: 
        !          1481: 
        !          1482: @path
        !          1483: path() -- Path name for a file
        !          1484: 
        !          1485: #include <path.h>
        !          1486: #include <stdio.h>
        !          1487: char *path(path, filename, mode);
        !          1488: char *path, *filename;
        !          1489: int mode;
        !          1490: 
        !          1491: @path.h
        !          1492: path.h -- Define/declare constants and functions used with path
        !          1493: 
        !          1494: #include <path.h>
        !          1495: 
        !          1496: @pause
        !          1497: pause() -- Wait for signal
        !          1498: 
        !          1499: int pause()
        !          1500: 
        !          1501: @pclose
        !          1502: pclose() -- Close a pipe
        !          1503: 
        !          1504: #include <stdio.h>
        !          1505: int pclose(fp)
        !          1506: FILE *fp;
        !          1507: 
        !          1508: @perror
        !          1509: perror() -- System call error messages
        !          1510: 
        !          1511: #include <errno.h>
        !          1512: perror(string)
        !          1513: char *string; extern int sys_nerr; extern char *sys_errlist[];
        !          1514: 
        !          1515: @pipe
        !          1516: pipe() -- Open a pipe
        !          1517: 
        !          1518: int pipe(fd)
        !          1519: int fd[2];
        !          1520: 
        !          1521: @pnmatch
        !          1522: pnmatch() -- Match string pattern
        !          1523: 
        !          1524: int pnmatch(string, pattern, flag)
        !          1525: char *string, *pattern; int flag;
        !          1526: 
        !          1527: @poll.h
        !          1528: poll.h -- Define structures/constants used with polling devices
        !          1529: 
        !          1530: #include <sys/poll.h>
        !          1531: 
        !          1532: @popen
        !          1533: popen() -- Open a pipe
        !          1534: 
        !          1535: #include <stdio.h>
        !          1536: FILE *popen(command, how)
        !          1537: char *command, *how;
        !          1538: 
        !          1539: @pow
        !          1540: pow() -- Compute a power of a number
        !          1541: 
        !          1542: #include <math.h>
        !          1543: double pow(z, x) double z, x;
        !          1544: 
        !          1545: @printf
        !          1546: printf() -- Print formatted text
        !          1547: 
        !          1548: int printf(format [,arg1, .... argN])
        !          1549: char *format; [data type] arg1, ... argN;
        !          1550: 
        !          1551: @proc.h
        !          1552: proc.h -- Define structures/constants used with processes
        !          1553: 
        !          1554: #include <sys/proc.h>
        !          1555: 
        !          1556: @PS1
        !          1557: PS1 -- User's default prompt
        !          1558: 
        !          1559: PS1=prompt
        !          1560: 
        !          1561: @PS2
        !          1562: PS2 -- Prompt when user continues command onto additional lines
        !          1563: 
        !          1564: PS2=prompt
        !          1565: 
        !          1566: @ptrace
        !          1567: ptrace() -- Trace process execution
        !          1568: 
        !          1569: #include <signal.h>
        !          1570: int ptrace(command, pid, location, value)
        !          1571: int command, pid, *location, value;
        !          1572: 
        !          1573: @putc
        !          1574: putc() -- Write character into stream
        !          1575: 
        !          1576: #include <stdio.h>
        !          1577: int putc(c, fp) char c; FILE *fp;
        !          1578: 
        !          1579: @putchar
        !          1580: putchar() -- Write a character onto the standard output
        !          1581: 
        !          1582: #include <stdio.h>
        !          1583: int putchar(c) char c;
        !          1584: 
        !          1585: @puts
        !          1586: puts() -- Write string onto standard output
        !          1587: 
        !          1588: #include <stdio.h>
        !          1589: int puts(string) char *string
        !          1590: 
        !          1591: @putw
        !          1592: putw() -- Write word into stream
        !          1593: 
        !          1594: #include <stdio.h>
        !          1595: int putw(word, fp) int word; FILE *fp;
        !          1596: 
        !          1597: @pwd.h
        !          1598: pwd.h -- Declare password structure
        !          1599: 
        !          1600: #include <pwd.h>
        !          1601: 
        !          1602: @qsort
        !          1603: qsort() -- Sort arrays in memory
        !          1604: 
        !          1605: void qsort(data, n, size, comp) char *data; int n, size; int (*comp)();
        !          1606: 
        !          1607: @rand
        !          1608: rand() -- Generate pseudo-random numbers
        !          1609: 
        !          1610: int rand()
        !          1611: 
        !          1612: @ranlib
        !          1613: ranlib -- Definition
        !          1614: 
        !          1615: 
        !          1616: @read
        !          1617: read() -- Read from a file
        !          1618: 
        !          1619: int read(fd, buffer, n) int fd; char *buffer; int n;
        !          1620: 
        !          1621: @readonly
        !          1622: readonly -- Storage class
        !          1623: 
        !          1624: 
        !          1625: @realloc
        !          1626: realloc() -- Reallocate dynamic memory
        !          1627: 
        !          1628: char *realloc(ptr, size) char *ptr; unsigned size;
        !          1629: 
        !          1630: @register
        !          1631: register -- Storage class
        !          1632: 
        !          1633: 
        !          1634: @return
        !          1635: return -- Return a value and control to calling function
        !          1636: 
        !          1637: 
        !          1638: @rewind
        !          1639: rewind() -- Reset file pointer
        !          1640: 
        !          1641: #include <stdio.h>
        !          1642: int rewind(fp) FILE *fp;
        !          1643: 
        !          1644: @rindex
        !          1645: rindex() -- Find a character in a string
        !          1646: 
        !          1647: char *rindex(string, c) char *string; char c;
        !          1648: 
        !          1649: @rpow
        !          1650: rpow() -- Raise multiple-precision integer to power
        !          1651: 
        !          1652: #include <mprec.h>
        !          1653: void rpow(a, b, c)
        !          1654: mint *a, *b, *c;
        !          1655: 
        !          1656: @sbrk
        !          1657: sbrk() -- Increase a program's data space
        !          1658: 
        !          1659: char *sbrk(increment) unsigned int increment;
        !          1660: 
        !          1661: @scanf
        !          1662: scanf() -- Accept and format input
        !          1663: 
        !          1664: #include <stdio.h>
        !          1665: int scanf(format, arg1, ... argN)
        !          1666: char *format; [data type] *arg1, ... *argN;
        !          1667: 
        !          1668: @sched.h
        !          1669: sched.h -- Define constants used with scheduling
        !          1670: 
        !          1671: #include <sys/sched.h>
        !          1672: 
        !          1673: @sdiv
        !          1674: sdiv() -- Divide multiple-precision integers
        !          1675: 
        !          1676: #include <mprec.h>
        !          1677: void sdiv(a, n, q, ip)
        !          1678: mint *a, *q; int n, *ip;
        !          1679: 
        !          1680: @SECONDS
        !          1681: SECONDS -- Number of seconds since current shell started
        !          1682: 
        !          1683: 
        !          1684: @seg.h
        !          1685: seg.h -- Definitions used with segmentation
        !          1686: 
        !          1687: #include <seg.h>
        !          1688: 
        !          1689: @sem.h
        !          1690: sem.h -- Definitions used by semaphore facility
        !          1691: 
        !          1692: #include <sys/sem.h>
        !          1693: 
        !          1694: @semctl
        !          1695: semctl() -- Control semaphore operations
        !          1696: 
        !          1697: #include <sys/sem.h>
        !          1698: semctl(semid, semnum, cmd, arg)
        !          1699: int semid, cmd, semnum;
        !          1700: union semun {
        !          1701:         int val;
        !          1702:         struct semid_ds *buf;
        !          1703:         unsigned short array[];
        !          1704: } arg;
        !          1705: 
        !          1706: @semget
        !          1707: semget() -- Get a set of semaphores
        !          1708: 
        !          1709: #include <sys/sem.h>
        !          1710: semget(key, nsems, semflg)
        !          1711: key_t key; int nsems, semflg;
        !          1712: 
        !          1713: @semop
        !          1714: semop() -- Perform semaphore operations
        !          1715: 
        !          1716: #include <sys/sem.h>
        !          1717: semop(semid, sops, nsops)
        !          1718: int semid, nsops; struct sembuf(sops)[];
        !          1719: 
        !          1720: @setbuf
        !          1721: setbuf() -- Set alternative stream buffers
        !          1722: 
        !          1723: #include <stdio.h>
        !          1724: void setbuf(fp, buffer) FILE *fp; char *buffer;
        !          1725: 
        !          1726: @setgid
        !          1727: setgid() -- Set group id and user id
        !          1728: 
        !          1729: int setgid(id) int id;
        !          1730: 
        !          1731: @setgrent
        !          1732: setgrent() -- Rewind group file
        !          1733: 
        !          1734: #include <grp.h>
        !          1735: struct group *setgrent();
        !          1736: 
        !          1737: @setjmp
        !          1738: setjmp() -- Perform non-local goto
        !          1739: 
        !          1740: #include <setjmp.h>
        !          1741: int setjmp(env) jmp_buf env;
        !          1742: 
        !          1743: @setjmp.h
        !          1744: setjmp.h -- Define setjmp() and longjmp()
        !          1745: 
        !          1746: #include <setjmp.h>
        !          1747: 
        !          1748: @setpwent
        !          1749: setpwent() -- Rewind password file
        !          1750: 
        !          1751: #include <pwd.h>
        !          1752: setpwent()
        !          1753: 
        !          1754: @settz
        !          1755: settz() -- Set local time zone
        !          1756: 
        !          1757: #include <time.h>
        !          1758: #include <sys/types.h>
        !          1759: void settz()
        !          1760: extern long timezone; char *tzname[2][16];
        !          1761: 
        !          1762: @setuid
        !          1763: setuid() -- Set user id
        !          1764: 
        !          1765: int setuid(id) int id;
        !          1766: 
        !          1767: @sgtty.h
        !          1768: sgtty.h -- Definitions used to control terminal I/O
        !          1769: 
        !          1770: #include <sgtty.h>
        !          1771: 
        !          1772: @SHELL
        !          1773: SHELL -- Name the default shell
        !          1774: 
        !          1775: SHELL=shell
        !          1776: 
        !          1777: @shellsort
        !          1778: shellsort() -- Sort arrays in memory
        !          1779: 
        !          1780: void shellsort(data, n, size, comp)
        !          1781: char *data; int n, size; int (*comp)();
        !          1782: 
        !          1783: @shm.h
        !          1784: shm.h -- Definitions used with shared memory
        !          1785: 
        !          1786: #include <sys/shm.h>
        !          1787: 
        !          1788: @shmctl
        !          1789: shmctl() -- Control shared-memory operations
        !          1790: 
        !          1791: #include <sys/shm.h>
        !          1792: shmctl(shmid, cmd, buf)
        !          1793: int shmid, cmd; struct shmid_ds *buf;
        !          1794: 
        !          1795: @shmget
        !          1796: shmget() -- Get shared-memory segment
        !          1797: 
        !          1798: #include <sys/shm.h>
        !          1799: shmget(key, size, shmflg)
        !          1800: key_t key; int size, shmflg;
        !          1801: 
        !          1802: @short
        !          1803: short -- Data type
        !          1804: 
        !          1805: 
        !          1806: @signal
        !          1807: signal() -- Specify disposition of a signal
        !          1808: 
        !          1809: #include <signal.h>
        !          1810: int (*signal(signum, action))()
        !          1811: int signum, (*action)();
        !          1812: 
        !          1813: @signal.h
        !          1814: signal.h -- Declare signals
        !          1815: 
        !          1816: #include <signal.h>
        !          1817: 
        !          1818: @sin
        !          1819: sin() -- Calculate sine
        !          1820: 
        !          1821: #include <math.h>
        !          1822: double sin(radian) double radian;
        !          1823: 
        !          1824: @sinh
        !          1825: sinh() -- Calculate hyperbolic sine
        !          1826: 
        !          1827: #include <math.h>
        !          1828: double sinh(radian) double radian;
        !          1829: 
        !          1830: @sizeof
        !          1831: sizeof -- Return size of a data element
        !          1832: 
        !          1833: 
        !          1834: @sleep
        !          1835: sleep() -- Suspend execution for interval
        !          1836: 
        !          1837: sleep(seconds)
        !          1838: unsigned seconds;
        !          1839: 
        !          1840: @sload
        !          1841: sload() -- Load device driver
        !          1842: 
        !          1843: #include <con.h>
        !          1844: int sload(major, file, conp)
        !          1845: int major; char *file; CON *conp;
        !          1846: 
        !          1847: @smult
        !          1848: smult() -- Multiply multiple-precision integers
        !          1849: 
        !          1850: #include <mprec.h>
        !          1851: void smult(a, n, c)
        !          1852: mint *a, *c; int n;
        !          1853: 
        !          1854: @spow
        !          1855: spow() -- Raise multiple-precision integer to power
        !          1856: 
        !          1857: #include <mprec.h>
        !          1858: void spow(a, n, b)
        !          1859: mint *a, *b; int n;
        !          1860: 
        !          1861: @sprintf
        !          1862: sprintf() -- Format output
        !          1863: 
        !          1864: #include <stdio.h>
        !          1865: int sprintf(string, format [ , arg ] ...)
        !          1866: char *string, *format;
        !          1867: 
        !          1868: @sqrt
        !          1869: sqrt() -- Compute square root
        !          1870: 
        !          1871: #include <math.h>
        !          1872: double sqrt(z) double z;
        !          1873: 
        !          1874: @srand
        !          1875: srand() -- Seed random number generator
        !          1876: 
        !          1877: void srand(seed) int seed;
        !          1878: 
        !          1879: @sscanf
        !          1880: sscanf() -- Format a string
        !          1881: 
        !          1882: #include <stdio.h>
        !          1883: int sscanf(string, format [, arg ] ...)
        !          1884: char *string; char *format;
        !          1885: 
        !          1886: @stat
        !          1887: stat() -- Find file attributes
        !          1888: 
        !          1889: #include <sys/stat.h>
        !          1890: int stat(file, statptr)
        !          1891: char *file; struct stat *statptr;
        !          1892: 
        !          1893: @stat.h
        !          1894: stat.h -- Definitions and declarations used to obtain file status
        !          1895: 
        !          1896: #include <sys/stat.h>
        !          1897: 
        !          1898: @static
        !          1899: static -- Declare storage class
        !          1900: 
        !          1901: 
        !          1902: @stdarg.h
        !          1903: stdarg.h -- Header for variable numbers of arguments
        !          1904: 
        !          1905: #include <stdarg.h>
        !          1906: 
        !          1907: @stddef.h
        !          1908: stddef.h -- Header for standard definitions
        !          1909: 
        !          1910: #include <stddef.h>
        !          1911: 
        !          1912: @stdio.h
        !          1913: stdio.h -- Declarations and definitions for I/O
        !          1914: 
        !          1915: 
        !          1916: @stdlib.h
        !          1917: stdlib.h -- Declare/define general functions
        !          1918: 
        !          1919: #include <stdlib.h>
        !          1920: 
        !          1921: @stime
        !          1922: stime() -- Set the time
        !          1923: 
        !          1924: #include
        !          1925: int stime(timep)
        !          1926: time_t *timep;
        !          1927: 
        !          1928: @strcat
        !          1929: strcat() -- Concatenate strings
        !          1930: 
        !          1931: #include <string.h>
        !          1932: char *strcat(string1, string2)
        !          1933: char *string1, *string2;
        !          1934: 
        !          1935: @strchr
        !          1936: strchr() -- Find a character in a string
        !          1937: 
        !          1938: #include <string.h>
        !          1939: char *strchr(string, character)
        !          1940: char *string; int character;
        !          1941: 
        !          1942: @strcmp
        !          1943: strcmp() -- Compare two strings
        !          1944: 
        !          1945: #include <string.h>
        !          1946: int strcmp(string1, string2)
        !          1947: char *string1, *string2;
        !          1948: 
        !          1949: @strcoll
        !          1950: strcoll() -- Compare two strings, using locale-specific information
        !          1951: 
        !          1952: #include <string.h>
        !          1953: int strcoll(string1, string2)
        !          1954: char *string1; char *string2;
        !          1955: 
        !          1956: @strcpy
        !          1957: strcpy() -- Copy one string into another
        !          1958: 
        !          1959: #include <string.h>
        !          1960: char *strcpy(string1, string2)
        !          1961: char *string1, *string2;
        !          1962: 
        !          1963: @strcspn
        !          1964: strcspn() -- Return length a string excludes characters in another
        !          1965: 
        !          1966: #include <string.h>
        !          1967: unsigned int strcspn(string1, string2)
        !          1968: char *string1, *string2;
        !          1969: 
        !          1970: @stream.h
        !          1971: stream.h -- Definitions for message facility
        !          1972: 
        !          1973: #include <stream.h>
        !          1974: 
        !          1975: @strerror
        !          1976: strerror() -- Translate an error number into a string
        !          1977: 
        !          1978: #include <string.h>
        !          1979: char *strerror(error)
        !          1980: int error;
        !          1981: 
        !          1982: @string.h
        !          1983: string.h -- Declarations for string library
        !          1984: 
        !          1985: #include <string.h>
        !          1986: 
        !          1987: @strlen
        !          1988: strlen() -- Measure the length of a string
        !          1989: 
        !          1990: #include <string.h>
        !          1991: int strlen(string)
        !          1992: char *string;
        !          1993: 
        !          1994: @strncat
        !          1995: strncat() -- Append one string onto another
        !          1996: 
        !          1997: #include <string.h>
        !          1998: char *strncat(string1, string2, n)
        !          1999: char *string1, *string2; unsigned n;
        !          2000: 
        !          2001: @strncmp
        !          2002: strncmp() -- Compare two strings
        !          2003: 
        !          2004: #include <string.h>
        !          2005: int strncmp(string1, string2, n)
        !          2006: char *string1, *string2; unsigned n;
        !          2007: 
        !          2008: @strncpy
        !          2009: strncpy() -- Copy one string into another
        !          2010: 
        !          2011: #include <string.h>
        !          2012: char *strncpy(string1, string2, n)
        !          2013: char *string1, *string2; unsigned n;
        !          2014: 
        !          2015: @strpbrk
        !          2016: strpbrk() -- Find first occurrence of a character from another string
        !          2017: 
        !          2018: #include <string.h>
        !          2019: char *strpbrk(string1, string2)
        !          2020: char *string1, *string2;
        !          2021: 
        !          2022: @strrchr
        !          2023: strrchr() -- Search for rightmost occurrence of a character in a string
        !          2024: 
        !          2025: #include <string.h>
        !          2026: char *strrchr(string, character)
        !          2027: char *string; int character;
        !          2028: 
        !          2029: @strspn
        !          2030: strspn() -- Return length a string includes characters in another
        !          2031: 
        !          2032: #include <string.h>
        !          2033: unsigned int strspn(string1, string2)
        !          2034: char *string1; char *string2;
        !          2035: 
        !          2036: @strstr
        !          2037: strstr() -- Find one string within another
        !          2038: 
        !          2039: #include <string.h>
        !          2040: char *strstr(string1, string2)
        !          2041: char *string1, *string2;
        !          2042: 
        !          2043: @strtod
        !          2044: strtod() -- Convert string to floating-point number
        !          2045: 
        !          2046: #include <stdlib.h>
        !          2047: double strtod(string, tailptr)
        !          2048: char *string; char **tailptr;
        !          2049: 
        !          2050: @strtok
        !          2051: strtok() -- Break a string into tokens
        !          2052: 
        !          2053: #include <string.h>
        !          2054: char *strtok(string1, string2)
        !          2055: char *string1, *string2;
        !          2056: 
        !          2057: @strtol
        !          2058: strtol() -- Convert string to long integer
        !          2059: 
        !          2060: #include <stdlib.h>
        !          2061: long strtol(string, tailptr, base)
        !          2062: char *string; char **tailptr; int base;
        !          2063: 
        !          2064: @strtoul
        !          2065: strtoul() -- Convert string to unsigned long integer
        !          2066: 
        !          2067: #include <stdlib.h>
        !          2068: unsigned long strtoul(string, tailptr, base)
        !          2069: char *string; char **tailptr; int base;
        !          2070: 
        !          2071: @struct
        !          2072: struct -- Data type
        !          2073: 
        !          2074: 
        !          2075: @strxfrm
        !          2076: strxfrm() -- Transform a string
        !          2077: 
        !          2078: #include <string.h>
        !          2079: unsigned int strxfrm(string1, string2, n)
        !          2080: char *string1, *string2; unsigned int n);
        !          2081: 
        !          2082: @stty
        !          2083: stty() -- Set terminal modes
        !          2084: 
        !          2085: #include <sgtty.h>
        !          2086: int stty(fd, sgp)
        !          2087: int fd;
        !          2088: struct sgttyb *sgp;
        !          2089: 
        !          2090: @suload
        !          2091: suload() -- Unload device driver
        !          2092: 
        !          2093: #include <con.h>
        !          2094: int suload(major)
        !          2095: int major;
        !          2096: 
        !          2097: @swab
        !          2098: swab() -- Swap a pair of bytes
        !          2099: 
        !          2100: void swab(src, dest, nb) char *src, *dest; unsigned nb;
        !          2101: 
        !          2102: @switch
        !          2103: switch -- Test a variable against a table
        !          2104: 
        !          2105: 
        !          2106: @sync
        !          2107: sync() -- Flush system buffers
        !          2108: 
        !          2109: sync()
        !          2110: 
        !          2111: @system
        !          2112: system() -- Pass a command to the shell for execution
        !          2113: 
        !          2114: int system(commandline) char *commandline;
        !          2115: 
        !          2116: @tan
        !          2117: tan() -- Calculate tangent
        !          2118: 
        !          2119: #include <math.h>
        !          2120: double tan(radian) double radian;
        !          2121: 
        !          2122: @tanh
        !          2123: tanh() -- Calculate hyperbolic cosine
        !          2124: 
        !          2125: #include <math.h>
        !          2126: double tanh(radian) double radian;
        !          2127: 
        !          2128: @tempnam
        !          2129: tempnam() -- Generate a unique name for a temporary file
        !          2130: 
        !          2131: char *tempnam(directory, name);
        !          2132: char *directory, *name;
        !          2133: 
        !          2134: @TERM
        !          2135: TERM -- Name the default terminal type
        !          2136: 
        !          2137: TERM=terminal type
        !          2138: 
        !          2139: @termio.h
        !          2140: termio.h -- Definitions used with terminal input and output
        !          2141: 
        !          2142: #include <termio.h>
        !          2143: 
        !          2144: @time
        !          2145: time() -- Get current time
        !          2146: 
        !          2147: #include <time.h>
        !          2148: #include <sys/types.h>
        !          2149: time_t time(tp) time_t *tp;
        !          2150: 
        !          2151: @time.h
        !          2152: time.h -- Give time-description structure
        !          2153: 
        !          2154: #include <time.h>
        !          2155: 
        !          2156: @timeb.h
        !          2157: timeb.h -- Declare timeb structure
        !          2158: 
        !          2159: #include <sys/timeb.h>
        !          2160: 
        !          2161: @timef.h
        !          2162: timef.h -- Definitions for user-level timed functions
        !          2163: 
        !          2164: #include <timef.h>
        !          2165: 
        !          2166: @timeout.h
        !          2167: timeout.h -- Define the timer queue
        !          2168: 
        !          2169: #include <timeout.h>
        !          2170: 
        !          2171: @times
        !          2172: times() -- Obtain process execution times
        !          2173: 
        !          2174: #include <sys/times.h>
        !          2175: #include <sys/const.h>
        !          2176: int times(tbp)
        !          2177: struct tbuffer *tbp;
        !          2178: 
        !          2179: @times.h
        !          2180: times.h -- Definitions used with times() system call
        !          2181: 
        !          2182: #include <times.h>
        !          2183: 
        !          2184: @TIMEZONE
        !          2185: TIMEZONE -- Time zone information
        !          2186: 
        !          2187: TIMEZONE=standard:offset[:daylight: date:date:hour:minutes]
        !          2188: 
        !          2189: @tmpnam
        !          2190: tmpnam() -- Generate a unique name for a temporary file
        !          2191: 
        !          2192: #include <stdio.h>
        !          2193: char *tmpnam(name);
        !          2194: char *name;
        !          2195: 
        !          2196: @tolower
        !          2197: tolower() -- Convert characters to lower case
        !          2198: 
        !          2199: #include <ctype.h>
        !          2200: int tolower(c) int c;
        !          2201: 
        !          2202: @tty.h
        !          2203: tty.h -- Define flags used with tty processing
        !          2204: 
        !          2205: #include <sys/tty.h>
        !          2206: 
        !          2207: @ttyname
        !          2208: ttyname() -- Identify a terminal
        !          2209: 
        !          2210: char *ttyname(fd)
        !          2211: int fd;
        !          2212: 
        !          2213: @ttyslot
        !          2214: ttyslot() -- Return a terminal's line number
        !          2215: 
        !          2216: int ttyslot()
        !          2217: 
        !          2218: @typedef
        !          2219: typedef -- Define a new data type
        !          2220: 
        !          2221: 
        !          2222: @types.h
        !          2223: types.h -- Declare system-specific data types
        !          2224: 
        !          2225: #include <sys/types.h>
        !          2226: 
        !          2227: @umask
        !          2228: umask() -- Set file creation mask
        !          2229: 
        !          2230: int umask(mask)
        !          2231: int mask;
        !          2232: 
        !          2233: @umount
        !          2234: umount() -- Unmount a file system
        !          2235: 
        !          2236: umount(filesystem)
        !          2237: char *filesystem;
        !          2238: 
        !          2239: @ungetc
        !          2240: ungetc() -- Return character to input stream
        !          2241: 
        !          2242: #include <stdio.h>
        !          2243: int ungetc (c, fp) int c; FILE *fp;
        !          2244: 
        !          2245: @union
        !          2246: union -- Multiply declare a variable
        !          2247: 
        !          2248: 
        !          2249: @unlink
        !          2250: unlink() -- Remove a file
        !          2251: 
        !          2252: int unlink(name) char *name;
        !          2253: 
        !          2254: @unsigned
        !          2255: unsigned -- Data type
        !          2256: 
        !          2257: 
        !          2258: @uproc.h
        !          2259: uproc.h -- Definitions used with user processes
        !          2260: 
        !          2261: #include <sys/uproc.h>
        !          2262: 
        !          2263: @USER
        !          2264: USER -- Name user's identifier
        !          2265: 
        !          2266: USER=user_identifier
        !          2267: 
        !          2268: @utime
        !          2269: utime() -- Change file access and modification times
        !          2270: 
        !          2271: #include <sys/types.h>
        !          2272: int utime(file, times)
        !          2273: char *file;
        !          2274: time_t times[2];
        !          2275: 
        !          2276: @utmp.h
        !          2277: utmp.h -- Login accounting information
        !          2278: 
        !          2279: #include <utmp.h>
        !          2280: 
        !          2281: @utsname.h
        !          2282: utsname.h -- Define utsname structure
        !          2283: 
        !          2284: #include <sys/utsname.h>
        !          2285: 
        !          2286: @v7sgtty.h
        !          2287: v7sgtty.h -- UNIX Version 7-style terminal I/O
        !          2288: 
        !          2289: #include <v7sgtty.h>
        !          2290: 
        !          2291: @va_arg
        !          2292: va_arg() -- Return pointer to next argument in argument list
        !          2293: 
        !          2294: #include <stdarg.h>
        !          2295: typename *va_arg(listptr, typename)
        !          2296: va_list listptr, typename;
        !          2297: 
        !          2298: @va_end
        !          2299: va_end() -- Tidy up after traversal of argument list
        !          2300: 
        !          2301: #include <stdarg.h>
        !          2302: void va_end(listptr)
        !          2303: va_list listptr;
        !          2304: 
        !          2305: @va_start
        !          2306: va_start() -- Point to beginning of argument list
        !          2307: 
        !          2308: #include <stdargs.h>
        !          2309: void va_start(listptr, rightparm)
        !          2310: va_list listptr, type rightparm;
        !          2311: 
        !          2312: @void
        !          2313: void -- Data type
        !          2314: 
        !          2315: 
        !          2316: @volatile
        !          2317: volatile -- Qualify an identifier as frequently changing
        !          2318: 
        !          2319: 
        !          2320: @wait
        !          2321: wait() -- Await completion of a child process
        !          2322: 
        !          2323: wait(statp)
        !          2324: int *statp;
        !          2325: 
        !          2326: @while
        !          2327: while -- Introduce a loop
        !          2328: 
        !          2329: while(condition)
        !          2330: 
        !          2331: @write
        !          2332: write() -- Write to a file
        !          2333: 
        !          2334: int write(fd, buffer, n)
        !          2335: int fd; char *buffer; int n;
        !          2336: 
        !          2337: @xgcd
        !          2338: xgcd() -- Extended greatest-common-divisor function
        !          2339: 
        !          2340: #include <mprec.h>
        !          2341: void xgcd(a, b, r, s, g)
        !          2342: mint *a, *b, *r, *s, *g;
        !          2343: 
        !          2344: @zerop
        !          2345: zerop() -- Indicate if multi-precision integer is zero
        !          2346: 
        !          2347: #include <mprec.h>
        !          2348: int zerop(a)
        !          2349: mint *a;
        !          2350: 

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