#include <math.h>

double fabs (

   double arg

);

stand-alone

fabs returns the absolute value of arg.

#include <stdio.h>

int fclose (

   FILE *stream

);

server

stack: 256 bytes

fclose causes any buffers for the specified stream to be emptied, and the file to be closed. Buffers allocated by the standard I/O system are freed.

fclose returns non-zero if stream is not associated with an output file, or if buffered data cannot be transferred to that file.

fclose is called automatically upon calling exit.

#include <stdio.h>

int feof (

   FILE *stream

);

server

feof returns non-zero when end of file is read on the named input stream, otherwise zero.

It is implemented as a macro.

#include <stdio.h>

int ferror (

   FILE *stream

);

server

ferror returns non-zero when an error has occurred reading the named stream, otherwise zero.

Unless cleared by clearerr, the error indication lasts until the stream is closed.

ferror is implemented as a macro.

#include <stdio.h>

int fflush (

   FILE *stream

);

server

fflush causes any buffered data for the named output stream to be written to the file or device associated with that stream. The stream remains open.

EOF is returned if stream is not associated with an output file or if buffered data cannot be transferred to that file.

fflush is called automatically by close, and when all streams are implicitly closed by exit.

#include <stdio.h>

int fgetc (

   FILE *stream

);

server

fgetc returns the next character from the specified input stream. Successive calls return successive characters from the stream.

EOF is returned at end of file or if a read error occurs.

fgetc is a genuine function, unlike getc which is a macro.

#include <stdio.h>

int fgetpos (

   FILE   *stream,

   fpos_t *pos

);

server

fgetpos stores the file position in the object pointed to by pos. The type fpos_t is defined in<stdio.h> .

If successful, fgetpos returns zero. If it fails, it returns a non-zero value, and sets errno to EBADF for a bad file descriptor, or EINVAL for any other error.

In the current version of Diamond, you should use fgetpos only with binary files.

#include <stdio.h>

char *fgets (

   char *str,

   int   n,

   FILE *stream

);

server

fgets reads a maximum of n-1 characters from the stream and stores them in the string str. Reading stops when a newline has been stored or when end-of-file is encountered. The last character read into str is followed by a NUL character.

fgets normally returns str. If an error occurs, or if end-of-file is encountered before any characters have been read, fgets returns NULL.

Note that fgets behaves differently from gets with respect to any terminating newline character: fgets keeps the newline, gets deletes it from the string.

#include <math.h>

double floor(double x);

stand-alone

floor returns the largest integer not greater than x, expressed as a floating-point value.

#include <math.h>

double fmod (

   double x,

   double y

);

stand-alone

fmod returns the remainder from x/y.

#include <stdio.h>

FILE *fopen (

   const char *filename,

   const char *type

);

server

stack: 300 bytes

fopen opens the file named by filename and associates a stream with it. fopen returns a pointer to be used to identify the stream in subsequent operations; if filename cannot be accessed in the way requested, the function returns NULL.

type is a character string made up of the following parts:

The second and third parts of the type string may appear in any order. For example, "r+b" and "rb+" are equivalent.

Here are some examples of possible values for type, along with a description of their interpretation.

fopen fails if the file is to be opened for reading ("r") and it does not exist.

For writing ("w") or appending ("a"), the file is created if it does not exist.

If a file is open to read and write (the type argument includes a "+"), it is not possible to switch directly from reading to writing or vice versa. Instead, there must be a call to fseek between them. If this is not done, the results are undefined.

#include <stdio.h>

int fprintf (

   FILE       *stream,

   const char *format,

   ...

);

server

stack: 368 bytes

The arguments that follow the format argument are output to the specified stream, using putc.

The format argument is a character string that controls the way in which the following argument list is converted for output.

The format argument contains two types of object: plain characters, which are simply copied to the output stream, and conversion specifications, each of which causes conversion and output of the next argument. Each conversion specification is introduced by the character '%', following which there may be the following, in the given order:

In no case does a non-existent or small field width cause truncation of a field.

The maximum length for a single converted argument is 512 characters.

fprintf returns the number of characters output, or a negative value if an output error occurred.

#include <stdio.h>

int fputc (

   int   cval,

   FILE *stream

);

server

fputc appends the character cval to the specified output stream. It returns the character written. fputc, unlike putc, is a genuine function rather than a macro.

fputc returns EOF if an error occurs.

#include <stdio.h>

int fputs (

   const char *str,

   FILE       *stream

);

server

fputs copies the NUL-terminated string str to the specified output stream. The NUL character that terminates the string is not written to the stream.

Note that unlike puts, fputs does not append a newline to the output string.

#include <stdio.h>

size_t fread (

   void   *ptr,

   size_t  size,

   size_t  nitems,

   FILE   *stream

);

server

fread reads nitems objects, each size characters in length, from the specified input stream into memory at location ptr. It returns the number of complete items actually read. Zero is returned on error conditions or end of file.

For example, the following code fragment reads ten integer values from the file f into the integer array values:

#include <stdio.h>

FILE *f;

int values[10];

…

fread(values, sizeof(int), 10, f);

Note that the size argument specifies the size of an item in characters, that is, in octets (eight-bit bytes).  fread always reads size octets from the file for each item, and the same number of octets are written to memory.

#include <stdlib.h>

void free (

   void *ap

);

stand-alone

stack: 32 bytes

free returns to the heap memory pointed to by ap, which must have been obtained originally by a call to malloc, memalign, calloc or realloc. If ap is a null pointer, no action is taken.

It is an error to attempt to free space that was not allocated by a call to malloc, memalign, calloc or realloc.

#include <stdio.h>

FILE *freopen (

   const char *filename,

   const char *type,

   FILE       *stream

);

server

freopen substitutes the named file filename in place of the open stream. It returns the original value of stream. The original stream is closed.

freopen is typically used to attach the pre-opened constant names stdin, stdout and stderr to specified files. type is a character string specifying the way in which the file is to be opened. Refer to the description of fopen for a full description of the type string.

freopen returns the pointer NULL if filename cannot be accessed.

#include <math.h>

double frexp (

   double  value,

   int    *exp

);

stand-alone

frexp breaks value into its normalized fraction and an integral power of 2. The function returns the fractional part and the integral part is stored in the variable pointed to by exp.

#include <stdio.h>

int fscanf (

   FILE       *stream,

   const char *format,

   ...

);

server

fscanf reads characters from the specified input stream, interprets them according to a format string and stores the results in the variables pointed to by the arguments following format.

The format string is regarded as a sequence of directives, which are processed one by one. fscanf tries to match each directive with characters read from the input stream; the way in which this matching is done depends on the directive. If a directive does not match characters from the input stream, we say that a matching error has happened and the character which caused the error is not read; fscanf returns at once.

There are three types of directive:

A conversion specification consists of the following, in this order:

Each conversion specification matches a sequence of characters of a particular format, and these characters are read from the input stream. Reading stops when the first character that does not fit into this format is encountered; this character is not read. It is a matching error if no characters are read, that is, if not even one character would fit the assumed format for this specification.

The character sequence that has been read is converted in one of a variety of ways, and the resulting internal value is stored in the variable pointed to by the next argument (unless '*' was included in the specifier). If this variable is not of an appropriate type for the value that has been converted, the effect is undefined.

The following specifiers are recognized:

The conversion specifiers 'E', 'G' and 'X' are treated as being equivalent to 'e', 'g', and 'x'. In addition, for compatibility purposes only, 'F' is accepted as being equivalent to 'lf', that is, a floating-point conversion that expects a pointer to double as the argument. If end-of-file or an input error occurs before any conversion is done, fscanf returns 'EOF'. Otherwise, it returns the number of input items successfully converted and stored. The specifier n and specifiers including a '*' do not count towards this number.

#include <stdio.h>

int fseek (

   FILE     *stream,

   long int  offset,

   int       whence

);

server

stack: 280 bytes

fseek sets the file position indicator of the specified stream. The new position is at the signed distance offset characters from a location specified in whence.

Three macros are provided for specifying whence:

fseek undoes any effects of ungetc; that is, characters which have been 'pushed back' into a stream by ungetc will not subsequently be read. Instead, reading proceeds from the new file position.

fseek returns -1 for improper seeks, or zero for normal completion.

When operating on a text file, fseek's arguments are limited in the following ways:

The ANSI standard also allows fseek to be applied to a text file with whence set to SEEK_CUR and offset set to a value previously found by applying ftell to the same stream. The current version of Diamond does not support this.

#include <stdio.h>

int fsetpos (

   FILE         *stream,

   const fpos_t *pos

);

server

fsetpos sets the file position of the specified stream to the position stored in the object pointed to by pos. This value should have been stored by an earlier call to fgetpos.

If successful, fsetpos returns zero. If it fails, it returns a non-zero value, and sets errno to EBADF for a bad file descriptor, or EINVAL for any other error.

In the current version of Diamond, you should use fsetpos only with binary files.

#include <stdio.h>

long int ftell (

   FILE *stream

);

server

stack: 188 bytes

ftell returns the current value of the offset relative to the beginning of the file associated with the named stream. This offset is measured in characters.

When operating on a text file, ftell may not give an accurate position unless the current position is either at the beginning or the end of the file.

#include <stdio.h>

size_t fwrite (

   const void *ptr,

   size_t      size,

   size_t      nitems,

   FILE       *stream

);

server

fwrite writes nitems objects, each of size characters, from memory at location ptr to the specified output stream.

It returns the number of complete items actually written. Zero is returned on error conditions.

For example, the following code fragment writes the contents of the int array values into the file data:

#include <stdio.h>

FILE *data;

int values[10];

…

fwrite(values, sizeof(int), 10, data);

Note that the size argument specifies the size of an item in characters, that is, in octets (eight-bit bytes).  fwrite always takes size octets from memory for each item, and the same number of octets are written to the file.