Appendix A. Implementation-Defined Behavior

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.

Translation (F.3.1)

  • Whether each nonempty sequence of white-space characters other than newline is retained or replaced by one space character (

    A nonempty sequence of white-space characters (other than newline) is retained.

  • How a diagnostic is identified (

    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.

  • Classes of diagnostic messages, their return codes and control over them.

    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

    -woff 1551

    To suppress warning messages numbered 1642, 1643, 1644, and 1759, enter

    -woff 1642-1644,1759

Environment (F.3.2)

  • Support of freestanding environments.

    No support is provided for a freestanding environment.

  • The semantics of the arguments to main (

    main is defined to have the two required parameters argc and argv . A third parameter, envp, is provided as an extension. That is, main would have the equivalent of the following prototype:

    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[0] 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 (

    Asynchronous terminals, including windows, are interactive devices and are, by default, line buffered. In addition, the standard error device, stderr, is unbuffered by default.

Identifiers (F.3.3)

  • 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).

    Case distinctions are always significant.

Characters (F.3.4)

  • 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 escape sequences are translated as specified for standard ASCII: \a = 0x7, \b = 0x8, \f = 0xc, \n = 0xa, \r = 0xd, \t = 0x9, \v=0xb

  • The shift states used for the encoding of multibyte characters (

    The multibyte character set is identical to the source and execution character sets. There are no shift states.

  • The number of bits in a character in the execution character set (

    There are eight bits per character.

  • The mapping of members of the source character set (in character constants and string literals) to members of the execution character set (

    The mapping is the identity mapping.

  • 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 (

    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 (

    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 (

    The mapping is the identity mapping to the standard ASCII character set. The C locale is used.

  • Whether a “plain” char has the same range of values as signed char or unsigned char.

    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.

Integers (F.3.5)

  • The representations and sets of values of the various types of integers (

    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.

    Table A-1. Integer Types and Ranges


    Range: Low


    Size (bits)

    signed char




    char, unsigned char




    short, signed short




    unsigned short int




    int, signed int




    unsigned 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 (

    The least significant n bits ( n being the length of the result integer) of the source are copied to the result.

  • The results of bitwise operations on signed integers (3.3).

    With the exception of right-shift of a negative signed integer (defined below), operations on signed and unsigned integers produce the same bitwise results.

  • The sign of the remainder on integer division (3.3.5).

    The sign of the remainder is that of the numerator.

  • The result of a right shift of a negative-valued signed integral type (3.3.7).

    The sign bit is propagated, so the result value is still negative.

Floating Point (F.3.6)

  • The representations and sets of values of the various types of floating-point numbers (

    The representation is IEEE:

    • 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.

    Table A-2. Ranges of floating point Types


    Range: Min


    Size (Bits)









    long double



    128 (-n32 and -64 modes)

  • The type of rounding or truncation used when representing a floating-point constant which is within its range.

    Per IEEE, the rounding is round-to-nearest (IEEE Standard 754, sections 4.1 and 5.5). If the two values are equally near, then the one with the least significant bit zero is chosen.

  • The direction of truncation when an integral number is converted to a floating-point number that cannot exactly represent the original value (

    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.

    Per IEEE, the rounding is round-to-nearest (IEEE Standard 754, Section 4.1 and 5.5). If the two values are equally near, then the one with the least significant bit zero is chosen.

Arrays and Pointers (F.3.7)

  • The type of integer required to hold the maximum size of an array-- that is, the type of the sizeof operator, size_t (, 4.1.1).

    An unsigned long holds the maximum array size.

  • 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 -n32 and -o32 mode. Both are 32 bits wide.

    long ints are large enough to hold pointers in -64 mode. Both are 64 bits wide.

  • The result of casting a pointer to an integer or vice versa (3.3.4).

    The result is bitwise exact provided the integer type is large enough to hold a pointer.

  • The type of integer required to hold the difference between two pointers to elements of the same array, ptrdiff_t (3.3.6, 4.1.1).

    An int is large enough to hold the difference between two pointers to elements of the same array in -o32 and -n32 modes.

    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.

Registers (F.3.8)

  • 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.

    The register storage-class specifier is always ignored and the compilation system makes its own decision about what should be in registers for optimized code (-O2 and above).

Structures, Unions, Enumerations, and Bitfields (F.3.9)

  • What is the result if a member of a union object is accessed using a member of a different type (

    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 (

    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.

    Table A-3. Alignment of Structure Members



    long double

    Double- word boundary (-32 mode)

    Quad-word boundary (-n32 and -64 modes)


    Double-word boundary


    Word boundary

    long long

    Double-word boundary


    Word boundary (-n32 and -32 modes)

    double-word boundary ( -64 mode)


    Word boundary


    Word boundary


    Half-word boundary


    Byte boundary

  • Whether a “plain” int bit-field is treated as a signed int bit-field or as an unsigned int bit-field (

    A “plain” int bit-field is treated as a signed int bit-field.

  • The order of allocation of bitfields within a unit (

    Bits in a bitfield are allocated with the most-significant bit first within a unit.

  • Whether a bitfield can straddle a storage-unit boundary (

    Bitfields cannot straddle storage unit boundaries (relative to the beginning of the struct or union), where a storage unit can be of size 8, 16, 32, or 64 bits.

  • The integer type chosen to represent the values of an enumeration type (

    The int type is always used.

Note: long or long long enumerations are not supported.

Qualifiers (F.3.10)

  • 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.

Declarators (F.3.11)

  • The maximum number of declarators that can modify an arithmetic, structure, or union type (3.5.4).

    There is no limit.

Statements (F.3.12)

  • The maximum number of case values in a switch statement (

    There is no limit.

Preprocessing Directives (F.3.13)

  • 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).

    For filenames surrounded by < >, the includable source files are searched for 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 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 mapping is the identity mapping.

  • The behavior on each recognized #pragma directive.

    See MIPSpro C and C++ Pragmas on the SGI Tech Pubs Library ( for details on all supported #pragma directives.

  • The definitions for __DATE __ and __TIME__ when, respectively, the date and time of translation are not available.

    The date and time of translation are always available in this implementation.

  • What is the maximum nesting depth of include files (3.8.2).

    The maximum nesting depth of include files is 200.

Library Functions (F.3.14)

  • The null pointer constant to which the macro NULL expands (4.1.5).

    The NULL pointer constant expands to an int with value zero. That is,

    #define NULL 0

  • The diagnostic printed by and the termination behavior of the assert function (4.2).

    If an assertion given by assert(EX) fails, the following message is printed on stderr using _write to its underlying fileno:

    Assertion failed: EX, file <filename>, line <linenumber> 

    This is followed by a call to abort (which exits with a SIGABRT).

  • The sets of characters tested for by the isalnum, isalpha, iscntrl, islower, isprint, and isupper functions (4.3.1).

    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).

    The value returned by the math functions on domain errors is the default IEEE Quiet NaN in all cases except the following:

    • The functions pow and powf return -HUGE_VAL when the first argument is zero and the second argument is negative. When both arguments are zero, pow() and powf() return 1.0.

    • The functions atan2 and atan2f return zero when both arguments are zero.

  • Whether mathematics functions set the integer expression errno to the value of the macro RANGE on underflow range 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.

  • Whether a domain error occurs or zero is returned when the fmodfunction has a second argument of zero (

    fmod(x,0) gives a domain error and returns the default IEEE Quiet NaN.


  • The set of signals for the signal function (

    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.

    Table A-4. Signals















    Illegal instruction (not reset when caught)



    Race trap (not reset when caught)



    IOT instruction






    MT instruction



    Floating point exception



    Kill (cannot be caught or ignored)



    Bus error



    Segmentation violation



    Bad argument to system call



    Write on a pipe with no one to read it



    Alarm clock



    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



    Input/output possible



    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



    Profiling 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 (

    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.

    Table A-5. Valid Codes in a Signal-Catching Function




    User breakpoint



    User breakpoint



    Integer overflow



    Divide by zero



    Multiply overflow



    Invalid virtual address



    Read-only 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

    The signal catching function is executed and then the interrupted system call returns a -1 to the calling process with errno set to EINTR.

    Note: The signals SIGKILL and SIGSTOP cannot be caught.

Signal Notes

  1. 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:

    1. The effective user ID and the real user ID of the receiving process are equal.

    2. 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).

  2. 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).

  3. 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.

  4. SIGEMT is never generated on an IRIS 4D system.

  5. 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>.

  6. 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 (

    Each signal is set to SIG_DFL at program start up.

  • 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(

    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 (


Streams and Files

  • 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).

    The file position indicator of an append stream is initially positioned at the end of the file.

  • Whether a write on a text stream causes the associated file to be truncated beyond that point (4.9.3).

    A write on a text stream does not cause the associated file to be truncated.

  • The characteristics of file buffering (4.9.3).

    Files are fully buffered, as described in paragraph 3, section 4.9.3, of ANSI X3.159-1989.

  • Whether a zero-length file actually exists (4.9.3).

    Zero-length files exist, but have no data, so a read on such a file returns an immediate EOF.

  • The rules for composing valid file names (4.9.3).

    Filenames consist of 1 to FILENAME_MAX characters. These characters can be selected from the set of all character values excluding \0 (null) and the ASCII code for / (slash).

    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).

    A file can be open any number of times.

  • The effect of the remove function on an open file (

    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 (

    If the new name exists, the file with that new name is removed (See the rm(1) reference page) before the rename is done.

  • The output for %p conversion in the fprintf function (

    %p is treated the same as %x.

  • The input for %p conversion in the fscanf function (

    %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 (

    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

Temporary Files

  • Whether a temporary file is removed if a program terminates abnormally (

    Temporary files are removed if a program terminates abnormally.

errno and perror

  • The value to which the macro errno is set by the fgetpos or ftell function on failure (,

    errno is set to EBADF (9) by the fgetpos or ftell function on failure.

  • The messages generated by the perror function (

    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.

Memory Allocation

  • The behavior of the calloc, malloc, or realloc function if the size requested is zero (4.10.3).

    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).

abort Function

  • The behavior of the abort function with regard to open and temporary files (

    Open files are not flushed, but are closed. Temporary files are removed.

exit Function

  • The status returned by the exit function if the value of the argument is other than zero, EXIT_SUCCESS or EXIT_FAILURE (

    The status returned to the environment is the least significant eight bits of the value passed to exit.

getenv Function

  • The set of environment names and the method for altering the environment list used by the getenv function (

    Any string can be used as the name of an environment variable, and any string can be used for its value. The function putenv alters the environment list of the application. For example,


    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.

system Function

  • The contents and mode of execution of the string passed to the system function (

    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.

strerror Function

  • The contents of the error message strings returned by the strerror function (

    The string is exactly the same as the string output by perror, which is documented in “errno and perror”.

Time Zones and the clock Function

  • 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 (

    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.

Locale-Specific Behavior (F.4)

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

  • Cultural Data

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.

Common Extensions (F.5)

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.

Environment Arguments (F.5.1)

  • 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 (

    This extension is supported.

Specialized Identifiers

  • 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.

    If the -dollar option is given to cc, then the dollar sign ($) is allowed in identifiers.

Lengths and Cases of Identifiers

  • All characters in identifiers (with or without external linkage) are significant and case distinctions are observed (3.1.2).

    All characters are significant. Case distinctions are observed.

Scopes of Identifiers (F.5.4)

  • 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.

Writable String Literals (F.5.5)

  • String literals are modifiable. Identical string literals shall be distinct (3.1.4).

    All string literals are distinct and writable when the -use_readwrite_const option is in effect. Otherwise, string literals may not be writable.

Other Arithmetic Types (F.5.6)

  • Other arithmetic types, such as long long int and their appropriate conversions, are defined (


Function Pointer Casts (F.5.7)

  • 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).

    Function pointers can be cast to a pointer to an object, or to void, and vice versa.

    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.

Non-int Bit-Field Types (F.5.8)

  • Types other than int, unsigned int, and signed int can be declared as bitfields, with appropriate maximum widths (

    A bitfield can be any integral type in -xansi and -cckr modes. However, bitfields of types other than int, signed int, and unsigned int result in a warning diagnostic in -ansi mode.

fortran Keyword (F.5.9)

  • 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 (

    The fortran keyword is not supported in this ANSI C. With cc -cckr, that keyword is accepted but ignored.

asm Keyword (F.5.10)

  • The asm keyword can be used to insert assembly language code directly into the translator output. The most common implementation is via statement of the form asm (character-string-literal) (3.6).

    The asm keyword is not supported.

Multiple External Definitions (F.5.11)

  • 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,, page 23).

    With cc -cckr, the Relaxed Ref/Def model is followed (ANSI C Rationale,, 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.

Empty Macro Arguments (F.5.12)

  • A macro argument can consist of no preprocessing tokens (3.8.3).

    This extension is supported. For example, one could define a macro such as

    #define notokargs() macrovalue

Predefined Macro Names (F.5.13)

  • 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).

Extra Arguments for Signal Handlers (F.5.14)

  • Handlers for specific signals can be called with extra arguments in addition to the signal number.

    SGI supports System V, POSIX, and BSD signal handlers. Extra arguments to the handler are available for your use. See the signal reference page.

Additional Stream Types and File-Opening Modes (F.5.15)

  • 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 (

    There are no additional modes supported. There are no additional mappings. The UNIX approach is used, as mentioned in the ANSI C Rationale, Section 4.9.2, page 90.

Defined File Position Indicator (F.5.16)

  • The file position indicator is decremented by each successful call to the ungetc function for a text stream, except if its value was zero before a call (

    The SGI C compiler supports only the one character of pushback guaranteed by the standard.