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