The following functions deal with operations on files. The type size_t is the unsigned integral type produced by the sizeof operator.

FILE *fopen(const char *filename, const char *mode)

• fopen opens the named file, and returns a stream, or NULL if the attempt fails. Legal values for mode include:

    "r" open text file for reading
    "w" create text file for writing; discard previous contents if any
    "a" append; open or create text file for writing at end of file
    "r+"        open text file for update (i.e., reading and writing)
    "w+"        create text file for update, discard previous contents if any
    "a+"        append; open or create text file for update, writing at end

• Update mode permits reading and writing the same file; fflush or a file-positioning function must be called between a read and a write or vice versa. If the mode includes b after the initial letter, as in "rb" or "w+b", that indicates a binary file. Filenames are limited to FILENAME_MAX characters. At most FOPEN_MAX files may be open at once.

FILE *freopen(const char *filename, const char *mode, FILE *stream)

• freopen opens the file with the specified mode and associates the stream with it. It returns stream, or NULL if an error occurs. freopen is normally used to change the files associated with stdin, stdout, or stderr.

int fflush(FILE *stream)

• On an output stream, fflush causes any buffered but unwritten data to be written; on an input stream, the effect is undefined. It returns EOF for a write error, and zero otherwise. fflush(NULL) flushes all output streams.

int fclose(FILE *stream)

• fclose flushes any unwritten data for stream, discards any unread buffered input, frees any automatically allocated buffer, then closes the stream. It returns EOF if any errors occurred, and zero otherwise.

int remove(const char *filename)

• remove removes the named file, so that a subsequent attempt to open it will fail. It returns non-zero if the attempt fails.

int rename(const char *oldname, const char *newname)

• rename changes the name of a file; it returns non-zero if the attempt fails.

FILE *tmpfile(void)

• tmpfile creates a temporary file of mode "wb+" that will be automatically removed when closed or when the program terminates normally. tmpfile returns a stream, or NULL if it could not create the file.

char *tmpnam(char s[L_tmpnam])

• tmpnam(NULL) creates a string that is not the name of an existing file, and returns a pointer to an internal static array. tmpnam(s) stores the string in s as well as returning it as the function value; s must have room for at least L_tmpnam characters. tmpnam generates a different name each time it is called; at most TMP_MAX different names are guaranteed during execution of the program. Note that tmpnam creates a name, not a file.

int setvbuf(FILE *stream, char *buf, int mode, size_t size)

• setvbuf controls buffering for the stream; it must be called before reading, writing or any other operation. A mode of _IOFBF causes full buffering, _IOLBF line buffering of text files, and _IONBF no buffering. If buf is not NULL, it will be used as the buffer, otherwise a buffer will be allocated. size determines the buffer size. setvbuf returns non-zero for any error.

void setbuf(FILE *stream, char *buf)

• If buf is NULL, buffering is turned off for the stream. Otherwise, setbuf is equivalent to (void) setvbuf(stream, buf, _IOFBF, BUFSIZ).

1.2. B.1.2 Formatted Output

The printf functions provide formatted output conversion.

   int fprintf(FILE *stream, const char *format, ...)

fprintf converts and writes output to stream under the control of format. The return value is the number of characters written, or negative if an error occurred.

The format string contains two types of objects: ordinary characters, which are copied to the output stream, and conversion specifications, each of which causes conversion and printing of the next successive argument to fprintf. Each conversion specification begins with the character % and ends with a conversion character. Between the % and the conversion character there may be, in order:

The header <math.h> declares mathematical functions and macros.

The macros EDOM and ERANGE (found in <errno.h>) are non-zero integral constants that are used to signal domain and range errors for the functions; HUGE_VAL is a positive double value. A domain error occurs if an argument is outside the domain over which the function is defined. On a domain error, errno is set to EDOM; the return value is implementation-defined. A range error occurs if the result of the function cannot be represented as a double. If the result overflows, the function returns HUGE_VAL with the right sign, and errno is set to ERANGE. If the result underflows, the function returns zero; whether errno is set to ERANGE is implementation-defined.

In the following table, x and y are of type double, n is an int, and all functions return double. Angles for trigonometric functions are expressed in radians.

sin(x) sine of x cos(x) cosine of x tan(x) tangent of x asin(x) sin-1(x) in range [-pi/2,pi/2], x in [-1,1]. acos(x) cos-1(x) in range [0,pi], x in [-1,1]. atan(x) tan-1(x) in range [-pi/2,pi/2]. atan2(y,x) tan-1(y/x) in range [-pi,pi]. sinh(x) hyperbolic sine of x cosh(x) hyperbolic cosine of x tanh(x) hyperbolic tangent of x exp(x) exponential function ex log(x) natural logarithm ln(x), x>0. log10(x) base 10 logarithm log10(x), x>0. pow(x,y) xy. A domain error occurs if x=0 and y<=0, or if x<0 and y is not an integer. sqrt(x) sqare root of x, x>=0. ceil(x) smallest integer not less than x, as a double. floor(x) largest integer not greater than x, as a double. fabs(x) absolute value |x| ldexp(x,n) x*2n frexp(x, int *ip) splits x into a normalized fraction in the interval [1/2,1) which is returned, and a power of 2, which is stored in *exp. If x is zero, both parts of the result are zero. modf(x, double *ip) splits x into integral and fractional parts, each with the same sign as x. It stores the integral part in *ip, and returns the fractional part. fmod(x,y) floating-point remainder of x/y, with the same sign as x. If y is zero, the result is implementation-defined.

5. B.5 Utility Functions: <stdlib.h>

The header <stdlib.h> declares functions for number conversion, storage allocation, and similar tasks.

double atof(const char *s)

• atof converts s to double; it is equivalent to strtod(s, (char**)NULL).

int atoi(const char *s)

• converts s to int; it is equivalent to (int)strtol(s, (char**)NULL, 10).

long atol(const char *s)

• converts s to long; it is equivalent to strtol(s, (char**)NULL, 10).

double strtod(const char *s, char **endp)

• strtod converts the prefix of s to double, ignoring leading white space; it stores a pointer to any unconverted suffix in *endp unless endp is NULL. If the answer would overflow, HUGE_VAL is returned with the proper sign; if the answer would underflow, zero is returned. In either case errno is set to ERANGE.

long strtol(const char *s, char **endp, int base)

• strtol converts the prefix of s to long, ignoring leading white space; it stores a pointer to any unconverted suffix in *endp unless endp is NULL. If base is between 2 and 36, conversion is done assuming that the input is written in that base. If base is zero, the base is 8, 10, or 16; leading 0 implies octal and leading 0x or 0X hexadecimal. Letters in either case represent digits from 10 to base-1; a leading 0x or 0X is permitted in base 16. If the answer would overflow, LONG_MAX or LONG_MIN is returned, depending on the sign of the result, and errno is set to ERANGE.

unsigned long strtoul(const char *s, char **endp, int base)

• strtoul is the same as strtol except that the result is unsigned long and the error value is ULONG_MAX.

int rand(void)

• rand returns a pseudo-random integer in the range 0 to RAND_MAX, which is at least 32767.

void srand(unsigned int seed)

• srand uses seed as the seed for a new sequence of pseudo-random numbers. The initial seed is 1.

void *calloc(size_t nobj, size_t size)

• calloc returns a pointer to space for an array of nobj objects, each of size size, or NULL if the request cannot be satisfied. The space is initialized to zero bytes.

void *malloc(size_t size)

• malloc returns a pointer to space for an object of size size, or NULL if the request cannot be satisfied. The space is uninitialized.

void *realloc(void *p, size_t size)

• realloc changes the size of the object pointed to by p to size. The contents will be unchanged up to the minimum of the old and new sizes. If the new size is larger, the new space is uninitialized. realloc returns a pointer to the new space, or NULL if the request cannot be satisfied, in which case *p is unchanged.

void free(void *p)

• free deallocates the space pointed to by p; it does nothing if p is NULL. p must be a pointer to space previously allocated by calloc, malloc, or realloc.

void abort(void)

• abort causes the program to terminate abnormally, as if by raise(SIGABRT).

void exit(int status)

• exit causes normal program termination. atexit functions are called in reverse order of registration, open files are flushed, open streams are closed, and control is returned to the environment. How status is returned to the environment is implementation-dependent, but zero is taken as successful termination. The values EXIT_SUCCESS and EXIT_FAILURE may also be used.

int atexit(void (*fcn)(void))

• atexit registers the function fcn to be called when the program terminates normally; it returns non-zero if the registration cannot be made.

int system(const char *s)

• system passes the string s to the environment for execution. If s is NULL, system returns non-zero if there is a command processor. If s is not NULL, the return value is implementation-dependent.

char *getenv(const char *name)

• getenv returns the environment string associated with name, or NULL if no string exists. Details are implementation-dependent.

void *bsearch(const void *key, const void *base,

• size_t n, size_t size, int (*cmp)(const void *keyval, const void *datum))

• bsearch searches base[0]...base[n-1] for an item that matches *key. The function cmp must return negative if its first argument (the search key) is less than its second (a table entry), zero if equal, and positive if greater. Items in the array base must be in ascending order. bsearch returns a pointer to a matching item, or NULL if none exists.

void qsort(void *base, size_t n, size_t size,

• int (*cmp)(const void *, const void *))

• qsort sorts into ascending order an array base[0]...base[n-1] of objects of size size. The comparison function cmp is as in bsearch.

int abs(int n)

• abs returns the absolute value of its int argument.

long labs(long n)

• labs returns the absolute value of its long argument.

div_t div(int num, int denom)

• div computes the quotient and remainder of num/denom. The results are stored in the int members quot and rem of a structure of type div_t.

ldiv_t ldiv(long num, long denom)

• ldiv computes the quotient and remainder of num/denom. The results are stored in the long members quot and rem of a structure of type ldiv_t.

6. B.6 Diagnostics: <assert.h>

The assert macro is used to add diagnostics to programs:

• void assert(int expression)

If expression is zero when

• assert(expression)

is executed, the assert macro will print on stderr a message, such as

• Assertion failed: expression, file filename, line nnn

It then calls abort to terminate execution. The source filename and line number come from the preprocessor macros FILE and LINE.

If NDEBUG is defined at the time <assert.h> is included, the assert macro is ignored.

7. B.7 Variable Argument Lists: <stdarg.h>

The header <stdarg.h> provides facilities for stepping through a list of function arguments of unknown number and type.

Suppose lastarg is the last named parameter of a function f with a variable number of arguments. Then declare within f a variable of type va_list that will point to each argument in turn:

• va_list ap;

ap must be initialized once with the macro va_start before any unnamed argument is accessed:

• va_start(va_list ap, lastarg);

Thereafter, each execution of the macro va_arg will produce a value that has the type and value of the next unnamed argument, and will also modify ap so the next use of va_arg returns the next argument:

• type va_arg(va_list ap, type);

The macro

• void va_end(va_list ap);

must be called once after the arguments have been processed but before f is exited.

8. B.8 Non-local Jumps: <setjmp.h>

The declarations in <setjmp.h> provide a way to avoid the normal function call and return sequence, typically to permit an immediate return from a deeply nested function call.

int setjmp(jmp_buf env)

• The macro setjmp saves state information in env for use by longjmp. The return is zero from a direct call of setjmp, and non-zero from a subsequent call of longjmp. A call to setjmp can only occur in certain contexts, basically the test of if, switch, and loops, and only in simple relational expressions.
  • if (setjmp(env) == 0)

    • get here on direct call

    else

    • get here by calling longjmp

void longjmp(jmp_buf env, int val)

• longjmp restores the state saved by the most recent call to setjmp, using the information saved in env, and execution resumes as if the setjmp function had just executed and returned the non-zero value val. The function containing the setjmp must not have terminated. Accessible objects have the values they had at the time longjmp was called, except that non-volatile automatic variables in the function calling setjmp become undefined if they were changed after the setjmp call.

9. B.9 Signals: <signal.h>

The header <signal.h> provides facilities for handling exceptional conditions that arise during execution, such as an interrupt signal from an external source or an error in execution.

void (*signal(int sig, void (*handler)(int)))(int)

signal determines how subsequent signals will be handled. If handler is SIG_DFL, the implementation-defined default behavior is used, if it is SIG_IGN, the signal is ignored; otherwise, the function pointed to by handler will be called, with the argument of the type of signal. Valid signals include

SIGABRT abnormal termination, e.g., from abort SIGFPE arithmetic error, e.g., zero divide or overflow SIGILL illegal function image, e.g., illegal instruction SIGINT interactive attention, e.g., interrupt SIGSEGV illegal storage access, e.g., access outside memory limits SIGTERM termination request sent to this program

signal returns the previous value of handler for the specific signal, or SIG_ERR if an error occurs.

When a signal sig subsequently occurs, the signal is restored to its default behavior; then the signal-handler function is called, as if by (*handler)(sig). If the handler returns, execution will resume where it was when the signal occurred.

The initial state of signals is implementation-defined.

int raise(int sig)

raise sends the signal sig to the program; it returns non-zero if unsuccessful.

10. B.10 Date and Time Functions: <time.h>

The header <time.h> declares types and functions for manipulating date and time. Some functions process local time, which may differ from calendar time, for example because of time zone. clock_t and time_t are arithmetic types representing times, and struct tm holds the components of a calendar time:

int tm_sec; seconds after the minute (0,61) int tm_min; minutes after the hour (0,59) int tm_hour; hours since midnight (0,23) int tm_mday; day of the month (1,31) int tm_mon; months since January (0,11) int tm_year; years since 1900 int tm_wday; days since Sunday (0,6) int tm_yday; days since January 1 (0,365) int tm_isdst; Daylight Saving Time flag

tm_isdst is positive if Daylight Saving Time is in effect, zero if not, and negative if the information is not available.

clock_t clock(void)

• clock returns the processor time used by the program since the beginning of execution, or -1 if unavailable. clock()/CLK_PER_SEC is a time in seconds.

time_t time(time_t *tp)

• time returns the current calendar time or -1 if the time is not available. If tp is not NULL, the return value is also assigned to *tp.

double difftime(time_t time2, time_t time1)

• difftime returns time2-time1 expressed in seconds.

time_t mktime(struct tm *tp)

• mktime converts the local time in the structure *tp into calendar time in the same representation used by time. The components will have values in the ranges shown. mktime returns the calendar time or -1 if it cannot be represented.

The next four functions return pointers to static objects that may be overwritten by other calls.

char *asctime(const struct tm *tp)

• asctime< converts the time in the structure *tp into a string of the form

  • Sun Jan 3 15:14:13 1988\n\0

char *ctime(const time_t *tp)

• ctime converts the calendar time *tp to local time; it is equivalent to
  • asctime(localtime(tp))

struct tm *gmtime(const time_t *tp)

• gmtime converts the calendar time *tp into Coordinated Universal Time (UTC). It returns NULL if UTC is not available. The name gmtime has historical significance.

struct tm *localtime(const time_t *tp)

• localtime converts the calendar time *tp into local time.

size_t strftime(char *s, size_t smax, const char *fmt, const struct tm *tp)

• strftime formats date and time information from *tp into s according to fmt, which is analogous to a printf format. Ordinary characters (including the terminating '\0') are copied into s. Each %c is replaced as described below, using values appropriate for the local environment. No more than smax characters are placed into s. strftime returns the number of characters, excluding the '\0', or zero if more than smax characters were produced.

%a abbreviated weekday name. %A full weekday name. %b abbreviated month name. %B full month name. %c local date and time representation. %d day of the month (01-31). %H hour (24-hour clock) (00-23). %I hour (12-hour clock) (01-12). %j day of the year (001-366). %m month (01-12). %M minute (00-59). %p local equivalent of AM or PM. %S second (00-61). %U week number of the year (Sunday as 1st day of week) (00-53). %w weekday (0-6, Sunday is 0). %W week number of the year (Monday as 1st day of week) (00-53). %x local date representation. %X local time representation. %y year without century (00-99). %Y year with century. %Z time zone name, if any. %% %

11. B.11 Implementation-defined Limits: <limits.h> and <float.h>

The header <limits.h> defines constants for the sizes of integral types. The values below are acceptable minimum magnitudes; larger values may be used.

CHAR_BIT        8       bits in a char
CHAR_MAX        UCHAR_MAX or SCHAR_MAX          maximum value of char
CHAR_MIN        0 or SCHAR_MIN  maximum value of char
INT_MAX         32767   maximum value of int
INT_MIN         -32767  minimum value of int
LONG_MAX        2147483647      maximum value of long
LONG_MIN        -2147483647     minimum value of long
SCHAR_MAX       +127    maximum value of signed char
SCHAR_MIN       -127    minimum value of signed char
SHRT_MAX        +32767  maximum value of short
SHRT_MIN        -32767  minimum value of short
UCHAR_MAX       255     maximum value of unsigned char
UINT_MAX        65535   maximum value of unsigned int
ULONG_MAX       4294967295      maximum value of unsigned long
USHRT_MAX       65535   maximum value of unsigned short

The names in the table below, a subset of <float.h>, are constants related to floating-point arithmetic. When a value is given, it represents the minimum magnitude for the corresponding quantity. Each implementation defines appropriate values.

FLT_RADIX       2       radix of exponent, representation, e.g., 2, 16
FLT_ROUNDS              floating-point rounding mode for addition
FLT_DIG         6       decimal digits of precision
FLT_EPSILON     1E-5    smallest number x such that 1.0+x != 1.0
FLT_MANT_DIG            number of base FLT_RADIX in mantissa
FLT_MAX         1E+37   maximum floating-point number
FLT_MAX_EXP             maximum n such that FLT_RADIXn-1 is representable
FLT_MIN         1E-37   minimum normalized floating-point number
FLT_MIN_EXP             minimum n such that 10n is a normalized number
DBL_DIG         10      decimal digits of precision
DBL_EPSILON     1E-9    smallest number x such that 1.0+x != 1.0
DBL_MANT_DIG            number of base FLT_RADIX in mantissa
DBL_MAX         1E+37   maximum double floating-point number
DBL_MAX_EXP             maximum n such that FLT_RADIXn-1 is representable
DBL_MIN         1E-37   minimum normalized double floating-point number
DBL_MIN_EXP             minimum n such that 10^n^ is a normalized number