The sections in this appendix describe implementation-defined behavior. Each section is keyed to the ANSI C Standard (ANSI X3.159-1989), Appendix F, and each point is keyed to the section number of the ANSI C Standard. The bold lines, usually marked with bullets, are items from Appendix F of the ANSI C Standard. Text following the italic lines describes the SGI implementation.
Whether each nonempty sequence of white-space characters other than newline is retained or replaced by one space character (184.108.40.206).
Successful compilations are silent. Diagnostics are, in general, emitted to standard error. Diagnostic messages have the general pattern of file-name,line-number:severity(number): message in -n32 and -64 modes. Diagnostics have a slightly different pattern in -o32 mode. Also, the range of numbers in -o32 mode is disjointed from the range in -n32 and -64 modes.
For example, typical messages from the ANSI C compiler front end in -n32 and -64 mode look like this:
"t4.c”, line 4: error(1020):identifier "x” is undefined "t4.c”, line 5: warning(1551):variable "y” is used before its value is set
Messages can also be issued by other internal compiler passes.
Three classes of messages exist: warning, error, and remark. Warning messages include the notation “warning” (which can be capitalized), and allow the compilation to continue (return code 0). Error messages cause the compilation to fail (return code 1).
Remark messages appear in -n32 and -64 modes only. Typically, remarks are issued only if the -fullwarn option appears on the command line. More control is available with the -diag_warning, -diag_remark, and -diag_error options. (See the cc reference page for more information.)
Warning messages from the compiler front end have a unique diagnostic number. You can suppress these messages individually by putting the number in the numberlist of a -woff numberlist switch to the cc command. numberlist is a comma-separated list of warning numbers and ranges of warning numbers. For example, to suppress the warning message in the previous example, enter
To suppress warning messages numbered 1642, 1643, 1644, and 1759, enter
Support of freestanding environments.
The semantics of the arguments to main (220.127.116.11.1).
int main(int argc, char *argv, char *envp)
The parameters have the following semantics:
argc is the number of arguments on the command line.
argv[0.. argc-1] are pointers to the command-line arguments (strings).
argv is the program name, as it appeared on the command line.
argv[argc ] is a null pointer.
envp is an array of pointers to strings of the form NAME=value, where NAME is the name of an environment variable and value is its value. The array is terminated by a null pointer.
What constitutes an interactive device (18.104.22.168).
The number of significant initial characters (beyond 31) in an identifier without external linkage (3.1.2).
All characters are significant.
The number of significant initial characters (beyond 6) in an identifier with external linkage (3.1.2).
All characters are significant.
Whether case distinctions are significant in an identifier with external linkage (3.1.2).
The members of the source and execution character sets, except as explicitly specified in the standard (2.2.1).
Only the mandated characters are present. The source character set includes all printable ASCII characters, hexadecimal 0x20 through 0x7e, and 0x7 through 0xc (the standard escape sequences).
The values to which the standard escape sequences are translated (2.2.2).
The shift states used for the encoding of multibyte characters (22.214.171.124).
The number of bits in a character in the execution character set (126.96.36.199.1).
The mapping of members of the source character set (in character constants and string literals) to members of the execution character set (188.8.131.52).
The value of an integer character constant that contains a character or escape sequence not represented in the basic execution character set or in the extended character set for a wide character constant (184.108.40.206).
With the exception of newline (0xa), backslash ('\'), and 0xff (end-of-file), eight-bit values appearing in an integer character constant are placed in the resultant integer in the same fashion as are characters that are members of the execution character set (see below). A backslash, newline, or 0xff can be placed in a character constant by preceding it with a backslash (that is, “escaping” it).
The value of an integer character constant that contains more than one character or a wide character constant that contains more than one multibyte character (220.127.116.11).
You can assign up to four characters to an int using a character constant, as the following example illustrates:
int t = 'a'; /* integer value 0x61 */ int t2 = 'ab'; /* integer value 0x6162 */ int t4 = 'abcd'; /* integer value 0x61626364 */ int t4 = 'abcde'; /* error: too many characters for */ /* character constant */
The encoding of multiple characters in an integer consists of the assignment of the corresponding character values of the ncharacters in the constant to the least-significant n bytes of the integer, filling any unused bytes with zeros. The most significant byte assigned contains the value of the lexically first character in the constant.
Because the multibyte character set is identical to the source and execution character sets, the above discussion applies to the assignment of more than one multibyte character to a wide character constant.
The current locale used to convert multibyte characters into corresponding wide character (codes) for a wide character constant (18.104.22.168).
Plain char is the same as unsigned char by default. Use the -signed option to cc to switch the range to be that of signed char.
The representations and sets of values of the various types of integers (22.214.171.124).
Integers are two's complement binary. Table A-1, lists the sizes and ranges of the various types of integer. The use of long long results in a warning in -ansi and -ansiposix modes.
In -o32 and -n32 mode implementations, to take full advantage of the support for 64-bit integral values in -ansi and -ansiposix modes, you can define the macro _LONGLONG on the cc command line when using the types __uint64_t , __int64_t, or library routines that are prototyped in terms of these types.
char, unsigned char
short, signed short
unsigned short int
int, signed int
long, signed long int
-2147483648 (-32 and -n32 modes)
-9223372036854775808 (-64 mode)
2147483647 (-32 and -n32 modes)
9223372036854775807 ( -64 mode)
unsigned long int
4294967295 (-32 and -n32 modes)
18446744073709551615 ( -64 mode)
long long signed long long int
unsigned long long int
The result of converting an integer to a shorter signed integer, or the result of converting an unsigned integer to a signed integer of equal length, if the value cannot be represented (126.96.36.199).
The results of bitwise operations on signed integers (3.3).
The sign of the remainder on integer division (3.3.5).
The result of a right shift of a negative-valued signed integral type (3.3.7).
Single (for float values)
Double (for double values and for long double values in -o32 mode)
Quad precision (for long double values in -n32 and -64 mode).
See ANSI/IEEE Standard 754-1985 and IEEE Standard for Binary Floating-Point Arithmetic. Table A-2, lists ranges of floating point types.
128 (-n32 and -64 modes)
The type of rounding or truncation used when representing a floating-point constant which is within its range.
Conversion of an integral type to a float type, if the integral value is too large to be exactly represented, gives the next higher value.
The direction of truncation or rounding when a floating-point number is converted to a narrower floating-point number.
The type of integer required to hold the maximum size of an array-- that is, the type of the sizeof operator, size_t (188.8.131.52, 4.1.1).
The size of integer required for a pointer to be converted to an integer type (3.3.4).
long ints are large enough to hold pointers in -64 mode. Both are 64 bits wide.
The result is bitwise exact provided the integer type is large enough to hold a pointer.
A long int is large enough to hold the difference between two pointers to elements of the same array in -n32, -o32, and -64 modes.
The extent to which objects can actually be placed in registers by use of the register storage-class specifier (3.5.1).
The compilation system can use up to eight of the register storage-class specifiers for nonoptimized code in -32 mode, and it ignores register specifiers for formal parameters. Use of register specifiers is not recommended.
What is the result if a member of a union object is accessed using a member of a different type (184.108.40.206).
The bits of the accessed member are interpreted according to the type used to access the member. For integral types, the N bits of the type are simply accessed. For floating types, the access might cause a trap if the bits are not a legal floating point value. For pointer types, the 32 bits (64 bits if in -64 mode) of the pointer are picked up. The usability of the pointer depends on whether it points to a valid object or function, and whether it is used appropriately. For example, a pointer whose least-significant bit is set can point to a character, but not to an integer.
The padding and alignment of members of structures (220.127.116.11).
This should present no problem unless binary data written by one implementation are read by another.
Members of structures are on the same boundaries as the base data type alignments anywhere else. A word is 32 bits and is aligned on an address, which is a multiple of 4. unsigned and signed versions of a basic type use identical alignment. Type alignments are given in Table A-3.
Double- word boundary (-32 mode)
Quad-word boundary (-n32 and -64 modes)
Word boundary (-n32 and -32 modes)
double-word boundary ( -64 mode)
Whether a “plain” int bit-field is treated as a signed int bit-field or as an unsigned int bit-field (18.104.22.168).
The order of allocation of bitfields within a unit (22.214.171.124).
Whether a bitfield can straddle a storage-unit boundary (126.96.36.199).
The integer type chosen to represent the values of an enumeration type (188.8.131.52).
|Note: long or long long enumerations are not supported.|
What constitutes an access to an object that has volatile-qualified type (3.5.3).
Objects of volatile-qualified type are accessed only as specified by the abstract semantics, and as would be expected on a RISC architecture, no complex instructions exist (for example, read-modify-write). Volatile objects appearing on the left side of an assignment expression are accessed once for the write. If the assignment is not simple, an additional read access is performed. Volatile objects appearing in other contexts are accessed once per instance. Incrementation and decrementation require both a read and a write access.
Volatile objects that are memory-mapped are accessed only as specified. If such an object is of size char, for example, adjacent bytes are not accessed. If the object is a bitfield, a read may access the entire storage unit containing the field. A write of an unaligned field necessitates a read and write of the storage unit that contains it.
Whether the value of a single-character character constant in a constant expression that controls conditional inclusion matches the value of the same character constant in the execution character set. Whether such a character constant can have a negative value (3.8.1).
The preprocessing and execution phases use exactly the same meanings for character constants.
A single-character character constant is always positive.
The method for locating includable source files (3.8.2).
The support of quoted names for includable source files (3.8.2).
Quoted names are supported for includable source files. For filenames surrounded by “ ”, the includable source files are searched for in the directory of the current include file, then in /usr/include.
The default search list includes /usr/include. You can change this list with various compiler options. See the cc(1) reference page and the -I and -nostdinc options.
The mapping of source file character sequences (3.8.2).
The behavior on each recognized #pragma directive.
See MIPSpro C and C++ Pragmas on the SGI Tech Pubs Library (http://techpubs.sgi.com/library) for details on all supported #pragma directives.
What is the maximum nesting depth of include files (3.8.2).
The null pointer constant to which the macro NULL expands (4.1.5).
#define NULL 0
Assertion failed: EX, file <filename>, line <linenumber>
This is followed by a call to abort (which exits with a SIGABRT).
The statements in the following list are true when operating in the C locale. The C locale is in effect at program start up for programs compiled for pure ANSI C (that is, -ansi), or by invoking setlocale(LC_ALL,”C”) . The C locale can be overridden at start up for any program that does not explicitly invoke setlocale by setting the value of the CHRCLASS environment variable. (See the ctype(3c) reference page .)
isalnum is nonzero for the 26 letters a-z, the 26 letters A-Z, and the digits 0-9.
isalpha is nonzero for the 26 letters a-z and the 26 letters A-Z.
islower is nonzero for the 26 letters a-z.
isupper is nonzero for the 26 letters A-Z.
isprint is nonzero for the ASCII characters space through tilde (~) (0x20 through 0x7e).
iscntrl is nonzero for the ASCII characters NUL through US (0x0 through 0x1f).
The values returned by the mathematics functions on domain errors (4.5.1).
Yes, except intrinsic functions that have been inlined. Note that fabs, fabsf, sqrt, sqrtf, hypotf, fhypot, pow, and powf are intrinsic by default in -xansi and -cckr modes and can be made intrinsic in -ansi mode by using the D__INLINE_INTRINSICS compiler option.
fmod(x,0) gives a domain error and returns the default IEEE Quiet NaN.
The signal set is listed in Table A-4, which is from the signal(2) reference page. The set of signals conforms to the SVR4 ABI. Note that some of the signals are not defined in -ansiposix mode. References in square brackets beside the signal numbers are described under “Signal Notes” in the discussion of signal semantics.
Illegal instruction (not reset when caught)
Race trap (not reset when caught)
Floating point exception
Kill (cannot be caught or ignored)
Bad argument to system call
Write on a pipe with no one to read it
Software termination signal
User-defined signal 1
User-defined signal 2
Termination of a child process
4.3 BSD and POSIX® name
Power fail (not reset when caught)
Window size changes
Urgent condition on I/O channel
Selectable event pending
Stop (cannot be caught or ignored)
Stop signal generated from keyboard
Continue after stop (cannot be ignored)
Background read from control terminal
Background write to control terminal
Virtual time alarm
CPU time limit exceeded [see setrlimit(2)]
File size limit exceeded [see setrlimit(2)]
Reserved for kernel usage
The semantics for each signal recognized by the signal function (184.108.40.206).
In the signal invocation signal(sig, func), func can be the address of a signal handler, handler, or one of the two constant values (defined in <sys/signal.h>) SIG_DFL or SIG_IGN. The semantics of these values are as follows:
Terminate process upon receipt of signal sig. (This is the default if no call to signal for signal sig occurs.) Upon receipt of the signal sig, the receiving process is to be terminated with all of the consequences outlined in the exit(2) reference page. See note 1 under “Signal Notes”.
Ignore signal. The signal sig is to be ignored.
Catch signal. func is the address of function handler.
|Note: The signals SIGKILL, SIGSTOP, and SIGCONT cannot be ignored.|
If func is the address of handler , upon receipt of the signal sig, the receiving process is to invoke handler as follows:
handler (int sig, int code, struct sigcontext *sc);
The remaining arguments are supplied as extensions and are optional. The value of the second argument code is meaningful only in the cases shown in Table A-5.
Divide by zero
Invalid virtual address
Read beyond mapped object
The third argument, sc, is a pointer to a struct sigcontext (defined in <sys/signal.h>) that contains the processor context at the time of the signal. Upon return from handler, the receiving process resumes execution at the point where it was interrupted.
Before entering the signal-catching function, the value of func for the caught signal is set to SIG_DFL, unless the signal is SIGILL, SIGTRAP, or SIGPWR. This means that before exiting the handler, a call to signal is necessary to catch future signals.
Suppose a signal that is to be caught occurs during one of the following routines:
A read, write, or open
An ioctl system call on a slow device (like a terminal, but not a file)
A pause (system call)
A wait system call that does not return immediately due to the existence of a previously stopped or zombie process
|Note: The signals SIGKILL and SIGSTOP cannot be caught.|
If SIG_DFL is assigned for SIGQUIT, SIGILL, SIGTRAP, SIGABRT, SIGEMT, SIGFPE, SIGBUS, SIGSEGV, or SIGSYS, in addition to the process being terminated, a “core image” is constructed in the current working directory of the process, if the following two conditions are met:
The effective user ID and the real user ID of the receiving process are equal.
An ordinary file named core exists and is writable or can be created.
If the file must be created, it has the following properties:
A mode of 0666 modified by the file creation mask (see the umask(2) reference page)
A file owner ID that is the same as the effective user ID of the receiving process
A file group ID that is the same as the effective group ID of the receiving process
|Note: The core file can be truncated if the resultant file size would exceed either ulimit (see the ulimit(2) reference page) or the process's maximum core file size (see the setrlimit(2) reference page).|
For the signals SIGCLD, SIGWINCH, SIGPWR, SIGURG, and SIGIO, the actions associated with each of the three possible values for func are as follows:
Ignore signal. The signal is to be ignored.
Ignore signal. The signal is to be ignored. Also, if sig is SIGCLD, the calling process's child processes do not create zombie processes when they terminate (see the exit(2) reference page).
Catch signal. If the signal is SIGPWR, SIGURG, SIGIO, or SIGWINCH, the action to be taken is the same as that previously described when func is the address of a function. The same is true if the signal is SIGCLD with one exception: while the process is executing the signal-catching function, all terminating child processes are queued. The wait system call removes the first entry of the queue. If the signal system call is used to catch SIGCLD , the signal handler must be reattached when exiting the handler, and at that time--if the queue is not empty--SIGCLD is raised again before signal returns. (See the wait(2) reference page.)
In addition, SIGCLD affects the wait and exit system calls as follows:
If the handler parameter of SIGCLD is set to SIG_IGN and a wait is executed, the wait blocks until all of the calling process's child processes terminate; it then returns a value of -1 with errno set to ECHILD.
If, in the exiting process's parent process, the handler parameter of SIGCLD is set to SIG_IGN, the exiting process does not create a zombie process.
When processing a pipeline, the shell makes the last process in the pipeline the parent of the preceding processes. Do not set SIGCLD to be caught for a process that can be piped into in this manner (and thus become the parent of other processes).
SIGPOLL is issued when a file descriptor corresponding to a STREAMS (see intro(2)) file has a “selectable” event pending. A process must specifically request that this signal be sent using the I_SETSIG ioctl call. Otherwise, the process never receives SIGPOLL.
SIGEMT is never generated on an IRIS 4D system.
SIGTRAP is generated for breakpoint instructions, overflows, divide by zeros, range errors, and multiply overflows. The second argument code gives specific details of the cause of the signal. Possible values are described in <sys/signal.h>.
The signals SIGSTOP, SIGTSTP, SIGTTIN, SIGTTOU, and SIGCONT are used by command interpreters like the C shell (see the csh(1) reference page) to provide job control. The first four signals listed stop the receiving process unless the signal is caught or ignored. SIGCONT resumes a stopped process. SIGTSTP is sent from the terminal driver in response to the SWTCH character being entered from the keyboard (see the termio(7) reference page. SIGTTIN is sent from the terminal driver when a background process attempts to read from its controlling terminal. If SIGTTIN is ignored by the process, then the read returns EIO. SIGTTOU is sent from the terminal driver when a background process attempts to write to its controlling terminal when the terminal is in TOSTOP mode. If SIGTTOU is ignored by the process, then the write succeeds, regardless of the state of the controlling terminal.
signal does not catch an invalid function argument, func, and results are undefined when an attempt is made to execute the function at the bad address.
SIGKILL immediately terminates a process, regardless of its state.
Processes stopped via job control (typically CTRL+Z) do not act upon any delivered signals other than SIGKILL until the job is restarted. Processes blocked via a blockproc system call unblock if they receive a signal that is fatal (that is, a non-job-control signal that they are not catching). These processes remained stopped, however, if the job they are a part of is stopped. Only upon restart do they die. Any non-fatal signals received by a blocked process do not cause the process to be unblocked. An unblockproc or unblockprocall system call is necessary.
If an instance of signal sig is pending when signal(sig, func) is executed, the pending signal is cancelled unless it is SIGKILL .
signal fails if sig is an illegal signal number, including SIGKILL and SIGSTOP, or if an illegal operation is requested (such as ignoring SIGCONT, which is ignored by default). In these cases, signal returns SIG_ERR and sets errno to EINVAL.
After a fork, the child inherits all handlers and signal masks. If any signals are pending for the parent, they are not inherited by the child.
The exec routines reset all caught signals to the default action; ignored signals remain ignored; the blocked signal mask is unchanged and pending signals remain pending.
The following reference pages contain other relevant information: intro(2), blockproc(2), kill(2), pause(2), ptrace(2), sigaction(2), sigset(2), wait(2), setjmp(3c), sigvec, and kill(1).
Upon successful completion, signal returns the previous value of func for the specified signal sig. Otherwise, a value of SIG_ERR is returned and errno is set to indicate the error. SIG_ERR is defined in the <sys/signal.h> header file.
|Caution: Signals raised by the instruction stream, SIGILL, SIGEMT, SIGBUS, and SIGSEGV, will cause infinite loops if their handler returns, or the action is set to SIG_IGN. The POSIX signal routines (sigaction, sigpending, sigprocmask, sigsuspend , sigsetjmp), and the BSD 4.3 signal routines (sigvec, signal, sigblock, sigpause, sigsetmask) must never be used with signal or sigset.|
Before entering the signal-catching function, the value of func for the caught signal is set to SIG_DFL, unless the signal is SIGILL, SIGTRAP, or SIGPWR. This means that before exiting the handler, a signal call is necessary to again set the disposition to catch the signal.
Note that handlers installed by signal execute with no signals blocked, not even the one that invoked the handler.
The default handling and the handling at program startup for each signal recognized by the signal function (220.127.116.11).
If the equivalent of signal (sig, SIG_DFL); is not executed prior to the call of a signal handler, the blocking of the signal that is performed(18.104.22.168).
The equivalent of signal(sig, SIG_DFL ) is executed prior to the call of a signal handler unless the signal is SIGILL, SIGTRAP, or SIGPWR . See the signal reference page for information on the support for the BSD 4.3 signal facilities.
Whether the default handling is reset if the SIGILL signal is received by a handler specified to the signal function (22.214.171.124).
Whether the last line of a text stream requires a terminating newline character (4.9.2).
There is no requirement that the last line of a text stream have a terminating newline: the output is flushed when the program terminates, if not earlier (as a result of fflush call). However, subsequent processes or programs reading the text stream or file might expect the newline to be present; it customarily is in IRIX text files.
Whether space characters that are written out to a text stream immediately before a newline character appear when read in (4.9.2).
All text characters (including spaces before a newline character) written out to a text stream appear exactly as written when read back in.
The number of null characters that can be appended to data written to a binary stream (4.9.2).
The library never appends nulls to data written to a binary stream. Only the characters written by the application are written to the output stream, whether binary or text. Text and binary streams are identical: there is no distinction.
Whether the file position indicator of an append mode stream is initially positioned at the beginning or end of the file (4.9.2).
Whether a write on a text stream causes the associated file to be truncated beyond that point (4.9.3).
The characteristics of file buffering (4.9.3).
Whether a zero-length file actually exists (4.9.3).
The rules for composing valid file names (4.9.3).
It is generally unwise to use *, ?, [, or ] as part of filenames because of the special meaning attached to these characters by the shell (see the sh(1) reference page). Although permitted, the use of unprintable characters should be avoided.
Whether the same file can be opened multiple times (4.9.3).
The effect of the remove function on an open file (126.96.36.199).
For local disk files, a remove(1) removes a directory entry pointing to the file but has no effect on the file or the program with the file open. For files remotely mounted via NFS software, the effect is unpredictable (the file might be removed making further I/O impossible through open streams, or it might behave like a local disk file) and might depend on the version(s) of NFS involved.
The effect if a file with the new name exists prior to a call to the rename function (188.8.131.52).
%p is treated the same as %x.
%p is treated the same as %x.
The interpretation of a - character that is neither the first nor the last character in the scanlist for %[ conversion in the fscanf function (184.108.40.206).
A - character that does not fit the pattern mentioned above is used as a shorthand for ranges of characters. For example, [xabcdefgh] and [xa-h] mean that characters a through h and the character x are in the range (called a scanset in 220.127.116.11).
The value to which the macro errno is set by the fgetpos or ftell function on failure (18.104.22.168, 22.214.171.124).
The message generated is simply a string. The content of the message given for each legal value of errno is given in the list below, which is of the format errno_value:message.
1: No permission match (-o32 mode) 1: Not privileged (-n32 and -64 modes)
2: No such file or directory
3: No such process
4: Interrupted system call
5: I/O error
6: No such device or address
7: Arg list too long
8: Exec format error
9: Bad file number
10: No child processes
11: Resource temporarily unavailable
12: Not enough space
13: Permission denied
14: Bad address
15: Block device required
16: Device or resource busy (-o32 mode) 16: Device busy (-n32 and -64 modes)
17: File exists
18: Cross-device link
19: No such device
20: Not a directory
21: Is a directory
22: Invalid argument
23: Too many open files in system (-o32 mode) 23: File table overflow (-n32 and -64 modes)
24: Too many open files in a process (-o32 mode) 24: Too many open files (-n32 and -64 modes)
25: Inappropriate IOCTL operation (-o32 mode) 25: Not a typewriter (-n32 and -64 modes)
26: Text file busy
27: File too large
28: No space left on device
29: Illegal seek
30: Read-only filesystem
31: Too many links
32: Broken pipe
33: Argument out of domain
34: Result too large
35: No message of desired type
36: Identifier removed
37: Channel number out of range
38: Level 2 not synchronized
39: Level 3 halted
40: Level 3 reset
41: Link number out of range
42: Protocol driver not attached
43: No CSI structure available
44: Level 2 halted
45: Deadlock situation detected/avoided
46: No record locks available
47: Error 47
48: Error 48
49: Error 49
50: Bad exchange descriptor
51: Bad request descriptor
52: Message tables full
53: Anode table overflow
54: Bad request code
55: Invalid slot
56: File locking deadlock
57: Bad font file format
58: Error 58
59: Error 59
60: Not a stream device
61: No data available
62: Timer expired
63: Out of stream resources
64: Machine is not on the network
65: Package not installed
66: Object is remote
67: Link has been severed
68: Advertise error
69: Srmount error
70: Communication error on send
71: Protocol error
72: Error 72
73: Error 73
74: Multihop attempted
75: Error 75
76: Error 76
77: Not a data message
78: Error 78 (-o32 mode) 78: Filename too long ( -n32 and -64 modes)
79: Error 79 (-o32 mode) 79: Value too large for defined data type (-n32 and -64 modes)
80: Name not unique on network
81: File descriptor in bad state
82: Remote address changed
83: Cannot access a needed shared library
84: Accessing a corrupted shared library
85: .lib section in a.out corrupted
86: Attempting to link in more shared libraries than system limit
87: Cannot exec a shared library directly
88: Invalid System Call (-o32 mode) 88: Illegal byte sequence (-n32 and -64 modes)
89: Error 89 (-o32 mode) 89: Operation not applicable (-n32 and -64 modes)
90: Error 90 (-o32 mode) 90: Too many symbolic links in pathname traversal (-n32 and -64 modes)
91: Error 91 (-o32 mode) 91: Restartable system call (-n32 and -64 modes)
92: Error 92 (-o32 mode) 92: If pipe/FIFO, don't sleep in stream head (-n32 and -64 modes)
93: Error 93 (-o32 mode) 93: Directory not empty (-n32 and -64 modes)
94: Error 94 (-o32 mode) 94: Too many users ( -n32 and -64 modes)
95: Error 95 (-o32 mode) 95: Socket operation on non-socket (-n32 and -64 modes)
96: Error 96 (-o32 mode) 96: Destination address required (-n32 and -64 modes)
97: Error 97 (-o32 mode) 97: Message too long ( -n32 and -64 modes)
98: Error 98 (-o32 mode) 98: Protocol wrong type for socket (-n32 and -64 modes)
99: Error 99 (-o32 mode) 99: Option not supported by protocol (-n32 and -64 modes)
100: Error 100
101: Operation would block (-o32 mode) 101: Error 101 (-n32 and -64 modes)
102: Operation now in progress (-o32 mode) 102: Error 102 (-n32 and -64 modes)
103: Operation already in progress (-o32 mode) 103: Error 103 (-n32 and -64 modes)
104: Socket operation on non-socket (-o32 mode) 104: Error 104 (-n32 and -64 modes)
105: Destination address required (-o32 mode) 105: Error 105 (-n32 and -64 modes)
106: Message too long (-o32 mode) 106: Error 106 (-n32 and -64 modes)
107: Protocol wrong type for socket (-o32 mode) 107: Error 107 (-n32 and -64 modes)
108: Option not supported by protocol (-o32 mode) 108: Error 108 (-n32 and -64 modes)
109: Protocol not supported (-o32 mode) 109: Error 109 (-n32 and -64 modes)
110: Socket type not supported (-o32 mode) 110: Error 110 (-n32 and -64 modes)
111: Operation not supported on socket (-o32 mode) 111: Error 111 (-n32 and -64 modes)
112: Protocol family not supported (-o32 mode) 112: Error 112 (-n32 and -64 modes)
113: Address family not supported by protocol family (-o32 mode) 113: Error 113 (-n32 and -64 modes)
114: Address already in use (-o32 mode) 114: Error 114 (-n32 and -64 modes)
115: Can't assign requested address (-o32 mode) 115: Error 115 (-n32 and -64 modes)
116: Network is down (-o32 mode) 116: Error 116 ( -n32 and -64 modes)
117: Network is unreachable (-o32 mode) 117: Error 117 (-n32 and -64 modes)
118: Network dropped connection on reset (-o32 mode) 118: Error 118 (-n32 and -64 modes)
119: Software caused connection abort (-o32 mode) 119: Error 119 (-n32 and -64 modes)
120: Connection reset by peer (-o32 mode) 120: Protocol not supported (-n32 and -64 modes)
121: No buffer space available (-o32 mode) 121: Socket type not supported (-n32 and -64 modes)
122: Socket is already connected (-o32 mode) 122: Operation not supported on transport endpoint (-n32 and -64 modes)
123: Socket is not connected (-o32 mode) 123: Protocol family not supported (-n32 and -64 modes)
124: Can't send after socket shutdown (-o32 mode) 124: Address family not supported by protocol family (-n32 and -64 modes)
125: Too many references: can't splice (-o32 mode) 125: Address already in use (-n32 and -64 modes)
126: Connection timed out (-o32 mode) 126: Cannot assign requested address (-n32 and -64 modes)
127: Connection refused (-o32 mode) 127: Network is down (-n32 and -64 modes)
128: Host is down (-o32 mode) 128: Network is unreachable (-n32 and -64 modes)
129: Host is unreachable (-o32 mode) 129: Network dropped connection because of reset (-n32 and -64 modes)
130: Too many levels of symbolic links (-o32 mode) 130: Software caused connection abort (-n32 and -64 modes)
131: Filename too long (-o32 mode) 131: Connection reset by peer (-n32 and -64 modes)
132: Directory not empty (-o32 mode) 132: No buffer space available (-n32 and -64 modes)
133: Disk quota exceeded (-o32 mode) 133: Transport endpoint is already connected (-n32 and -64 modes)
134: Stale NFS¼® file handle ( -o32 mode) 134: Transport endpoint is not connected (-n32 and -64 modes)
135: Structure needs cleaning (-n32 and -64 modes)
136: Error 136 (-n32 and -64 modes)
137: Not a name file (-n32 and -64 modes)
138: Not available (-n32 and -64 modes)
139: Is a name file (-n32 and -64 modes)
140: Remote I/O error (-n32 and -64 modes)
141: Reserved for future use (-n32 and -64 modes)
142: Error 142 (-n32 and -64 modes)
143: Cannot send after socket shutdown (-n32 and -64 modes)
144: Too many references: cannot splice (-n32 and -64 modes)
145: Connection timed out (-n32 and -64 modes)
146: Connection refused (-n32 and -64 modes)
147: Host is down (-n32 and -64 modes)
148: No route to host (-n32 and -64 modes)
149: Operation already in progress (-n32 and -64 modes)
150: Operation now in progress (-n32 and -64 modes)
151: Stale NFS file handle (-n32 and -64 modes)
See the perror(3c) reference page for further information.
The malloc in libc.a returns a pointer to a zero-length space if a size of zero is requested. Successive calls to malloc return different zero-length pointers. If the library libmalloc.a is used, malloc returns 0 (the NULL pointer).
The set of environment names and the method for altering the environment list used by the getenv function (126.96.36.199).
This sets the value of the environment variable MYNAME to “foo.” If the environment variable MYNAME already existed, its value is changed. If it did not exist, it is added. The string passed to putenv actually becomes part of the environment, and changing it later alters the environment. Further, the string should not be space that was automatically allocated (for example, an auto array); rather, it should be space that is either global or malloced. For more information, see the putenv(3c) reference page.
It is not wise to alter the value of well-known environment variables. For the current list, see the environ(5) reference page.
The contents of the string should be a command string, as if typed to a normal IRIX shell, such as sh(1). A shell ( sh) is forked, and the string is passed to it. The current process waits until the shell has completed and returns the exit status of the shell as the return value.
The contents of the error message strings returned by the strerror function (188.8.131.52).
The string is exactly the same as the string output by perror, which is documented in “errno and perror”.
The local time zone and daylight saving time (4.12.1).
Local time and daylight saving time are determined by the value of the TZ environment variable. TZ is set by init to the default value indicated in the file /etc/TIMEZONE , and this value is inherited in the environment of all processes. If TZ is unset, the local time zone defaults to GMT (Greenwich mean time, or coordinated universal time), and daylight saving time is not in effect. See the reference pages ctime(3c), time(2), timezone(4), environ(5), getenv(3), and other related reference pages for the format of TZ.
The era for the clock function (184.108.40.206).
clock counts seconds from 00:00:00: GMT, January 1, 1970. What was once known as Greenwich mean time (GMT) is now known as coordinated universal time, though the reference pages do not reflect this change yet. See the ctime(3c) reference page for further information.
For information on locale-specific behavior, see the chapter titled “Internationalizing Your Application” in Topics in IRIX Programming. That chapter covers some locale-specific topics to consider when internationalizing an application. Topics include
Overview of Locale-Specific Behavior
Native Language Support and the NLS Database
Using Regular Expressions
Also, that chapter describes setting a locale, location of locale-specific data, cultural items to consider, and GUI concerns.
For additional information on locale-specific behavior, refer to the X/Open Portability Guide, Volume 3, “XSI Supplementary Definitions,” published by Prentice Hall, Englewood Cliffs, New Jersey 07632, ISBN 0-13-685-850-3.
The following extensions are widely used in many systems, but are not portable to all implementations. The inclusion of any extension that can cause a strictly conforming program to become invalid renders an implementation nonconforming. Examples of such extensions are new keywords, or library functions declared in standard headers or predefined macros with names that do not begin with an underscore. The Standard's description of each extension is followed by a definition of any SGI support/nonsupport of each common extension.
In a hosted environment, the main function receives a third argument, char *envp, that points to a null-terminated array of pointers to char. Each of these pointers points to a string that provides information about the environment for this execution of the process (220.127.116.11.1).
Characters other than the underscore _, letters, and digits, that are not defined in the required source character set (such as dollar sign $, or characters in national character sets) can appear in an identifier.
A function identifier, or the identifier of an object (the declaration of which contains the keyword extern) has file scope.
This is true of the compiler when invoked with cc -cckr (that is, when requesting traditional C). When compiling in ANSI mode (by default or with one of the ANSI options) function identifiers (and all other identifiers) have block scope when declared at block level.
A pointer to an object or to void can be cast to a pointer to a function, allowing data to be invoked as a function (3.3.4). A pointer to a function can be cast to a pointer to an object, or to void, allowing a function to be inspected or modified (for example, by a debugger) (3.3.4).
Data can be invoked as a function.
Casting a pointer to a function to a pointer to an object or void does allow a function to be inspected. Normally, functions cannot be written to, because text space is read-only. Dynamically loaded functions are loaded (by a user program) into data space and can be written to.
Types other than int, unsigned int, and signed int can be declared as bitfields, with appropriate maximum widths (18.104.22.168).
The fortran declaration specifier can be used in a function declaration to indicate that calls suitable for Fortran should be generated, or that different representations for external names are to be generated (22.214.171.124).
There can be more than one external definition for the identifier of an object, with or without the explicit use of the keyword extern. If the definitions disagree, or more than one is initialized, the behavior is undefined (3.7.2).
With ANSI C, only one external definition of the object is permitted. If more than one is present, the linker ( ld(1)) gives a warning message. The Strict Ref/Def model is followed (ANSI C Rationale, 126.96.36.199, page 23).
With cc -cckr, the Relaxed Ref/Def model is followed (ANSI C Rationale, 188.8.131.52, page 23): multiple definitions of the same identifier of an object in different files are accepted and all but one of the definitions are treated (silently) as if they had the extern keyword.
If the definitions in different source units disagree, the mismatch is not currently detected by the linker (ld), and the resulting program will probably not work correctly.
Macro names that do not begin with an underscore, describing the translation and execution environments, may be defined by the implementation before translation begins (3.8.8).
This is not true for cc -ansi, which defines ANSI C. Only macro names beginning with two underscores or a single underscore followed by a capital letter are predefined by the implementation before translation begins. The name space is not polluted.
With cc -cckr (traditional C), a C preprocessor is used with a full set of the predefined symbols. For example, sgi is predefined.
With cc -xansi (which is the default for cc), an ANSI C preprocessor and compiler are used and a full set of predefined symbols is defined (including sgi, for example).
Additional mappings from files to streams may be supported (4.9.2), and additional file-opening modes may be specified by characters appended to the mode argument of the fopen function (184.108.40.206).