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