#endif
/* See setvbuf(), third argument */
-#define _IOFBF 2
-#define _IOLBF 1
-#define _IONBF 0
+#define _IOFBF 1
+#define _IOLBF 2
+#define _IONBF 4
/* The following are platform-dependant, and defined in _PDCLIB_config.h. */
-typedef _PDCLIB_fpos_t fpos_t;
+typedef struct _PDCLIB_fpos_t fpos_t;
typedef struct _PDCLIB_file_t FILE;
#define EOF -1
#define BUFSIZ _PDCLIB_BUFSIZ
#define TMP_MAX _PDCLIB_TMP_MAX
/* See fseek(), third argument */
-#define SEEK_CUR 1
-#define SEEK_END 2
-#define SEEK_SET 4
+#define SEEK_CUR _PDCLIB_SEEK_CUR
+#define SEEK_END _PDCLIB_SEEK_END
+#define SEEK_SET _PDCLIB_SEEK_SET
-extern FILE * stdin;
-extern FILE * stdout;
-extern FILE * stderr;
+extern struct _PDCLIB_file_t * stdin;
+extern struct _PDCLIB_file_t * stdout;
+extern struct _PDCLIB_file_t * stderr;
/* Operations on files */
This implementation does not remove temporary files if the process aborts
abnormally (e.g. abort()).
*/
-FILE * tmpfile( void );
+struct _PDCLIB_file_t * tmpfile( void );
/* Generate a file name that is not equal to any existing filename AT THE TIME
OF GENERATION. Generate a different name each time it is called.
/* Close the file associated with the given stream (after flushing its buffers).
Returns zero if successful, EOF if any errors occur.
*/
-int fclose( FILE * stream );
+int fclose( struct _PDCLIB_file_t * stream );
/* Flush the buffers of the given output stream. If the stream is an input
stream, or an update stream with the last operation being an input operation,
Returns zero if successful, EOF if a write error occurs.
Sets the error indicator of the stream if a write error occurs.
*/
-int fflush( FILE * stream );
+int fflush( struct _PDCLIB_file_t * stream );
/* Open the file with the given filename in the given mode, and return a stream
handle for it in which error and end-of-file indicator are cleared. Defined
given.
The stream is fully buffered if and only if it can be determined not to
- refer to an interactive device. As the generic code of this implementation
- cannot determine this, _IOLBF (line buffering) is used for all streams.
+ refer to an interactive device.
If the mode string begins with but is longer than one of the above sequences
the implementation is at liberty to ignore the additional characters, or do
Returns a pointer to the stream handle if successfull, NULL otherwise.
*/
-FILE * fopen( const char * _PDCLIB_restrict filename, const char * _PDCLIB_restrict mode );
+struct _PDCLIB_file_t * fopen( const char * _PDCLIB_restrict filename, const char * _PDCLIB_restrict mode );
/* Close any file currently associated with the given stream. Open the file
identified by the given filename with the given mode (equivalent to fopen()),
This implementation allows the following mode changes: TODO
(Primary use of this function is to redirect stdin, stdout, and stderr.)
*/
-FILE * freopen( const char * _PDCLIB_restrict filename, const char * _PDCLIB_restrict mode, FILE * _PDCLIB_restrict stream );
+struct _PDCLIB_file_t * freopen( const char * _PDCLIB_restrict filename, const char * _PDCLIB_restrict mode, struct _PDCLIB_file_t * _PDCLIB_restrict stream );
/* If buf is a NULL pointer, call setvbuf( stream, NULL, _IONBF, BUFSIZ ).
If buf is not a NULL pointer, call setvbuf( stream, buf, _IOFBF, BUFSIZ ).
*/
-void setbuf( FILE * _PDCLIB_restrict stream, char * _PDCLIB_restrict buf );
+void setbuf( struct _PDCLIB_file_t * _PDCLIB_restrict stream, char * _PDCLIB_restrict buf );
/* Set the given stream to the given buffering mode. If buf is not a NULL
pointer, use buf as file buffer (of given size). If buf is a NULL pointer,
setvbuf()) has been performed.
Returns zero if successful, nonzero otherwise.
*/
-int setvbuf( FILE * _PDCLIB_restrict stream, char * _PDCLIB_restrict buf, int mode, size_t size );
+int setvbuf( struct _PDCLIB_file_t * _PDCLIB_restrict stream, char * _PDCLIB_restrict buf, int mode, size_t size );
/* Formatted input/output functions */
usual to these special values, '#' and '0' have no effect.
e,E The argument from the argument stack is assumed to be of type double,
and converted to a decimal floating point in normalized exponential
- notation ([?]d.ddd e±dd). "Normalized" means one nonzero digit before
+ notation ([?]d.ddd edd). "Normalized" means one nonzero digit before
the decimal point, unless the value is zero. The number of digits after
the decimal point is specified by the precision (default 6), the value
being rounded appropriately. If precision is zero (and the '#' flag is
Infinity or NaN values are represented as for 'f' and 'F' conversions,
respectively.
a,A The argument from the argument stack is assumed to be of type double,
- and converted to a floating point hexadecimal notation ([?]0xh.hhhh p±d)
+ and converted to a floating point hexadecimal notation ([?]0xh.hhhh pd)
with one hexadecimal digit (being nonzero if the value is normalized,
and otherwise unspecified) before the decimal point, and the number of
digits after the decimal point being specified by the precision. If no
Returns the number of characters written if successful, a negative value
otherwise.
*/
-int fprintf( FILE * _PDCLIB_restrict stream, const char * _PDCLIB_restrict format, ... );
+int fprintf( struct _PDCLIB_file_t * _PDCLIB_restrict stream, const char * _PDCLIB_restrict format, ... );
/* TODO: fscanf() documentation */
/*
- Write output to the given stream, as defined by the given format string and
- 0..n subsequent arguments (the argument stack).
-
- The format string is written to the given stream verbatim, except for any
- conversion specifiers included, which start with the letter '%' and are
- documented below. If the given conversion specifiers require more arguments
- from the argument stack than provided, behaviour is undefined. Additional
- arguments not required by conversion specifiers are evaluated but otherwise
- ignored.
-
- (The standard specifies the format string is allowed to contain multibyte
- character sequences as long as it starts and ends in initial shift state,
- but this is not yet supported by this implementation, which interprets the
- format string as sequence of char.)
- TODO: Add multibyte support to printf() functions.
-
- Read input from the given stream, as defined by the given format string and
- 0..n subsequent arguments (the argument stack).
+ Read input from a given stream, as defined by the given format string, and
+ store converted input in the objects pointed to by 0..n subsequent arguments
+ (the argument stack).
The format string contains a sequence of directives that are expected to
match the input. If such a directive fails to match, the function returns
argument stack, behaviour is undefined. Additional arguments not required
by any conversion specifications are evaluated, but otherwise ignored.
-The format shall be a multibyte character sequence, beginning and ending in its initial
-shift state. The format is composed of zero or more directives: one or more white-space
-characters, an ordinary multibyte character (neither % nor a white-space character), or a
-conversion speci?cation. Each conversion speci?cation is introduced by the character %.
-After the %, the following appear in sequence:
-? An optional assignment-suppressing character *.
-? An optional nonzero decimal integer that speci?es the maximum ?eld width (in
- characters).
-? An optional length modi?er that speci?es the size of the receiving object.
-? A conversion speci?er character that speci?es the type of conversion to be applied.
-The fscanf function executes each directive of the format in turn. If a directive fails, as
-detailed below, the function returns. Failures are described as input failures (due to the
-occurrence of an encoding error or the unavailability of input characters), or matching
-failures (due to inappropriate input).
-A directive composed of white-space character(s) is executed by reading input up to the
-?rst non-white-space character (which remains unread), or until no more characters can
-be read.
-A directive that is an ordinary multibyte character is executed by reading the next
-characters of the stream. If any of those characters differ from the ones composing the
-directive, the directive fails and the differing and subsequent characters remain unread.
-Similarly, if end-of-?le, an encoding error, or a read error prevents a character from being
-read, the directive fails.
-A directive that is a conversion speci?cation de?nes a set of matching input sequences, as
-described below for each speci?er. A conversion speci?cation is executed in the
-following steps:
-Input white-space characters (as speci?ed by the isspace function) are skipped, unless
-the speci?cation includes a [, c, or n speci?er.241)
-These white-space characters are not counted against a speci?ed ?eld width.
-An input item is read from the stream, unless the speci?cation includes an n speci?er. An
-input item is de?ned as the longest sequence of input characters which does not exceed
-any speci?ed ?eld width and which is, or is a pre?x of, a matching input sequence.242)
-fscanf pushes back at most one input character onto the input stream. Therefore, some sequences
-that are acceptable to strtod, strtol, etc., are unacceptable to fscanf.
-The ?rst character, if any, after the input item remains unread. If the length of the input
-item is zero, the execution of the directive fails; this condition is a matching failure unless
-end-of-?le, an encoding error, or a read error prevented input from the stream, in which
-case it is an input failure.
-Except in the case of a % speci?er, the input item (or, in the case of a %n directive, the
-count of input characters) is converted to a type appropriate to the conversion speci?er. If
-the input item is not a matching sequence, the execution of the directive fails: this
-condition is a matching failure. Unless assignment suppression was indicated by a *, the
-result of the conversion is placed in the object pointed to by the ?rst argument following
-the format argument that has not already received a conversion result. If this object
-does not have an appropriate type, or if the result of the conversion cannot be represented
-in the object, the behavior is unde?ned.
-The length modi?ers and their meanings are:
-
+ (The standard specifies the format string is allowed to contain multibyte
+ character sequences as long as it starts and ends in initial shift state,
+ but this is not yet supported by this implementation, which interprets the
+ format string as sequence of char.)
+ TODO: Add multibyte support to scanf() functions.
+
+ A conversion specifier consists of:
+ - Optional assignment-suppressing character ('*') that makes the conversion
+ read input as usual, but does not assign the conversion result.
+ - Optional maximum field width as decimal integer.
+ - Optional length modifier specifying the size of the argument (one of "hh",
+ "ll", or one of the characters "hljztL").
+ - Conversion specifier character specifying the type of conversion to be
+ applied (and the type of the next argument from the argument stack). One
+ of the characters "diouxXaAeEfFgGcs[pn%".
+
LENGTH MODIFIERS
hh For "diouxXn" conversions, the next pointer from the argument stack is
assumed to point to a variable of of char width.
A, E, F, G and X are valid, and equivalent to their lowercase counterparts.
+ All conversions except [, c, or n imply that whitespace characters from the
+ input stream are consumed until a non-whitespace character is encountered.
+ Such whitespaces do not count against a maximum field width.
+
+ Conversions push at most one character back into the input stream. That
+ implies that some character sequences converted by the strtol() and strtod()
+ function families are not converted identically by the scnaf() function
+ family.
+
Returns the number of input items successfully assigned. This can be zero if
an early mismatch occurs. Returns EOF if an input failure occurs before the
first conversion.
*/
-int fscanf( FILE * _PDCLIB_restrict stream, const char * _PDCLIB_restrict format, ... );
+int fscanf( struct _PDCLIB_file_t * _PDCLIB_restrict stream, const char * _PDCLIB_restrict format, ... );
/* Equivalent to fprintf( stdout, format, ... ). */
int printf( const char * _PDCLIB_restrict format, ... );
is passed as va_list parameter. Note that va_list is not declared by
<stdio.h>.
*/
-int vfprintf( FILE * _PDCLIB_restrict stream, const char * _PDCLIB_restrict format, _PDCLIB_va_list arg );
+int vfprintf( struct _PDCLIB_file_t * _PDCLIB_restrict stream, const char * _PDCLIB_restrict format, _PDCLIB_va_list arg );
/* Equivalent to fscanf( stream, format, ... ), except that the argument stack
is passed as va_list parameter. Note that va_list is not declared by
<stdio.h>.
*/
-int vfscanf( FILE * _PDCLIB_restrict stream, const char * _PDCLIB_restrict format, _PDCLIB_va_list arg );
+int vfscanf( struct _PDCLIB_file_t * _PDCLIB_restrict stream, const char * _PDCLIB_restrict format, _PDCLIB_va_list arg );
/* Equivalent to fprintf( stdout, format, ... ), except that the argument stack
is passed as va_list parameter. Note that va_list is not declared by
If end-of-file is reached, the EOF indicator of the stream is set.
If a read error occurs, the error indicator of the stream is set.
*/
-int fgetc( FILE * stream );
+int fgetc( struct _PDCLIB_file_t * stream );
/* Read at most n-1 characters from given stream into the array s, stopping at
\n or EOF. Terminate the read string with \n. If EOF is encountered before
If a read error occurs, the error indicator of the stream is set. In this
case, the contents of s are indeterminate.
*/
-char * fgets( char * _PDCLIB_restrict s, int n, FILE * _PDCLIB_restrict stream );
+char * fgets( char * _PDCLIB_restrict s, int n, struct _PDCLIB_file_t * _PDCLIB_restrict stream );
/* Write the value c (cast to unsigned char) to the given stream.
Returns c if successful, EOF otherwise.
If a write error occurs, sets the error indicator of the stream is set.
*/
-int fputc( int c, FILE * stream );
+int fputc( int c, struct _PDCLIB_file_t * stream );
/* Write the string s (not including the terminating \0) to the given stream.
Returns a value >=0 if successful, EOF otherwise.
This implementation does set the error indicator of the stream if a write
error occurs.
*/
-int fputs( const char * _PDCLIB_restrict s, FILE * _PDCLIB_restrict stream );
+int fputs( const char * _PDCLIB_restrict s, struct _PDCLIB_file_t * _PDCLIB_restrict stream );
/* Equivalent to fgetc( stream ), but may be implemented as a macro that
evaluates its parameter more than once.
/* Equivalent to fputc( c, stdout ), but may be implemented as a macro that
evaluates its parameter more than once.
*/
-int putchar( int c );
+#define putchar( c ) putc( c, stdout )
/* Write the string s (not including the terminating \0) to stdout, and append
a newline to the output. Returns a value >= 0 when successful, EOF if a
behaviour is undefined. (Older versions of the library allowed such a call.)
Returns the pushed-back character if successful, EOF if it fails.
*/
-int ungetc( int c, FILE * stream );
+int ungetc( int c, struct _PDCLIB_file_t * stream );
/* Direct input/output functions */
indeterminate. If a partial element is read, its value is indeterminate.
If size or nmemb are zero, the function does nothing and returns zero.
*/
-size_t fread( void * _PDCLIB_restrict ptr, size_t size, size_t nmemb, FILE * _PDCLIB_restrict stream );
+size_t fread( void * _PDCLIB_restrict ptr, size_t size, size_t nmemb, struct _PDCLIB_file_t * _PDCLIB_restrict stream );
/* Write up to nmemb elements of given size from buffer pointed to by ptr to
the given stream. Returns the number of elements successfully written, which
indeterminate. If size or nmemb are zero, the function does nothing and
returns zero.
*/
-size_t fwrite( const void * _PDCLIB_restrict ptr, size_t size, size_t nmemb, FILE * _PDCLIB_restrict stream );
+size_t fwrite( const void * _PDCLIB_restrict ptr, size_t size, size_t nmemb, struct _PDCLIB_file_t * _PDCLIB_restrict stream );
/* File positioning functions */
Returns zero if successful, nonzero otherwise.
TODO: Implementation-defined errno setting for fgetpos().
*/
-int fgetpos( FILE * _PDCLIB_restrict stream, fpos_t * _PDCLIB_restrict pos );
+int fgetpos( struct _PDCLIB_file_t * _PDCLIB_restrict stream, fpos_t * _PDCLIB_restrict pos );
/* Set the position indicator for the given stream to the given offset from:
- the beginning of the file if whence is SEEK_SET,
Returns zero if successful, nonzero otherwise. If a read/write error occurs,
the error indicator for the given stream is set.
*/
-int fseek( FILE * stream, long int offset, int whence );
+int fseek( struct _PDCLIB_file_t * stream, long int offset, int whence );
/* Set the position indicator (and, where appropriate the mbstate_t status
object) for the given stream to the given pos object (created by an earlier
the error indicator for the given stream is set.
TODO: Implementation-defined errno setting for fsetpos().
*/
-int fsetpos( FILE * stream, const fpos_t * pos );
+int fsetpos( struct _PDCLIB_file_t * stream, const fpos_t * pos );
/* Return the current offset of the given stream from the beginning of the
associated file. For text streams, the exact value returned is unspecified
Returns -1L if unsuccessful.
TODO: Implementation-defined errno setting for ftell().
*/
-long int ftell( FILE * stream );
+long int ftell( struct _PDCLIB_file_t * stream );
/* Equivalent to (void)fseek( stream, 0L, SEEK_SET ), except that the error
indicator for the stream is also cleared.
*/
-void rewind( FILE * stream );
+void rewind( struct _PDCLIB_file_t * stream );
/* Error-handling functions */
/* Clear the end-of-file and error indicators for the given stream. */
-void clearerr( FILE * stream );
+void clearerr( struct _PDCLIB_file_t * stream );
/* Return zero if the end-of-file indicator for the given stream is not set,
nonzero otherwise.
*/
-int feof( FILE * stream );
+int feof( struct _PDCLIB_file_t * stream );
/* Return zero if the error indicator for the given stream is not set, nonzero
otherwise.
*/
-int ferror( FILE * stream );
+int ferror( struct _PDCLIB_file_t * stream );
/* If s is neither a NULL pointer nor an empty string, print the string to
stderr (with appended colon (':') and a space) first. In any case, print an
projects / pdclib / blobdiff