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