]> pd.if.org Git - pdclib/blobdiff - includes/stdio.h
Documented the unformatted I/O functions.
[pdclib] / includes / stdio.h
index c3122c4afaf21d0a748384316a3f344463b9b035..01c907341ade139797e2d080bfbe318173f1f331 100644 (file)
@@ -26,59 +26,27 @@ typedef _PDCLIB_size_t size_t;
 
 /* See setvbuf(), third argument */
 /* Fully buffered - transmit block-wise */
-#define _IOFBF 1
+#define _IOFBF 2
 /* Line buffered - transmit line-wise */
-#define _IOLBF 2
+#define _IOLBF 1
 /* Not buffered - transmit immediately */
-#define _IONBF 4
+#define _IONBF 0
 
-/* See setbuf(). Minimum 256. */
-#define BUFSIZ 1024
-
-/* Internal-only flags for representing mode */
-#define _PDCLIB_FREAD    1
-#define _PDCLIB_FWRITE   2
-#define _PDCLIB_FAPPEND  4
-#define _PDCLIB_FRW      8
-#define _PDCLIB_FBIN    16
-
-typedef struct _PDCLIB_file_t FILE;
+/* The following are platform-dependant, and defined in _PDCLIB_config.h. */
 typedef _PDCLIB_fpos_t        fpos_t;
-
-/* Must be integer and of negative value */
+typedef struct _PDCLIB_file_t FILE;
 #define EOF -1
-
-/* Maximum number of files this implementation can open simultaneously. Minimum 8. */
-#define FOPEN_MAX 1
-
-/* Maximum file name length (plus terminating \0) this implementation does
-   guarantee can be opened. If there is no limit on the length of filenames,
-   this should be a recommended size for filename buffers.
-*/
-#define FILENAME_MAX 1024
-
-/* Buffer size for tmpnam() */
-#define L_tmpnam 1024
-
-/* Number of distinct file names that can be generated by tmpnam(). */
-#define TMP_MAX 50
+#define BUFSIZ _PDCLIB_BUFSIZ
+#define FOPEN_MAX _PDCLIB_FOPEN_MAX
+#define FILENAME_MAX _PDCLIB_FILENAME_MAX
+#define L_tmpnam _PDCLIB_L_tmpnam
+#define TMP_MAX _PDCLIB_TMP_MAX
 
 /* See fseek(), third argument */
 #define SEEK_CUR 1
 #define SEEK_END 2
 #define SEEK_SET 4
 
-typedef struct
-{
-    _PDCLIB_fd_t   handle;   /* OS-specific file descriptor */
-    _PDCLIB_fpos_t position; /* file position indicator */
-    void *         buffer;   /* file buffer */
-    size_t         bufsize;  /* size of buffer */
-    int            status;   /* misc. status bits */
-  /*mbstate_t      mbstate;*//* multibyte parse state */ /* TODO: Unmask. */
-    FILE *         next;     /* provisions for linked list handling */
-} FILE;
-
 /* Text-mode I/O is at liberty to skip non-printing characters and trailing spaces.
    Binary I/O is at liberty to add trailing zero bytes.
    First operation decides "orientation" of the stream (wide / byte).
@@ -94,10 +62,41 @@ typedef struct
 */
 
 /* Operations on files */
+
+/* Remove the given file. Returns zero if successful, non-zero otherwise. If
+   the file is open, this implementation does flush its buffer and closes the
+   file before removing it. (It might be still accessible by another hard link
+   etc.
+*/
 int remove( const char * filename );
+
+/* Rename the given old file to the given new name. Returns zero if successful,
+   non-zero otherwise. If successful, the file can no longer be accessed under
+   its old name. If the file is open, this implementation does flush its buffer
+   and closes the file before renaming it.
+*/
 int rename( const char * old, const char * new );
-FILE * tmpfile( void ); /* TODO: Implement. */
-char * tmpnam( char * s ); /* TODO: Implement. */
+
+/* Opens a temporary file with mode "wb+", i.e. binary, update. The file will
+   be removed when it is closed or the process exits normally. Returns a pointer
+   to a FILE handle for this file. This implementation does not remove temporary
+   files if the process aborts abnormally (e.g. abort()).
+*/
+FILE * tmpfile( void );
+
+/* Generates a file name that is not equal to any existing filename AT THE TIME
+   OF GENERATION. It generates a different name each time it is called. If s is
+   a NULL pointer, the name is stored in an internal static array, and a pointer
+   to that array is returned. (This is not thread-safe!) If s is not a NULL
+   pointer, it is assumed to point to an array of at least L_tmpnam characters.
+   The generated name is then stored in s, and s is returned. If tmpnam() is
+   unable to generate a suitable name (because all possible variations do exist
+   already or the function has been called TMP_MAX times already), NULL is
+   returned.
+   Note that this implementation cannot guarantee a file of this name is not
+   generated between the call to tmpnam() and a subsequent fopen().
+*/
+char * tmpnam( char * s );
 
 /* File access functions */
 int fclose( FILE * stream );
@@ -124,16 +123,84 @@ int vsprintf( char * _PDCLIB_restrict s, const char * _PDCLIB_restrict format, _
 int vsscanf( const char * _PDCLIB_restrict s, const char * _PDCLIB_restrict format, _PDCLIB_va_list arg );
 
 /* Character input/output functions */
+
+/* Retrieve the next character from given stream. Returns the character, cast
+   to int, if successful. If EOF is reached, the EOF indicator of the stream
+   is set and EOF returned. If a read error occurs, the error indicator of the
+   stream is set and EOF returned.
+*/
 int fgetc( FILE * stream );
+
+/* Reads at most n-1 characters from given stream into the array s, stopping at
+   \n or EOF. The string read is terminated with \n. Returns s if successful.
+   If EOF is encountered before any characters are read, the contents of s are
+   unchanged, and NULL is returned. If a read error occurs, the contents of s
+   are indeterminate, and NULL is returned.
+*/
 char * fgets( char * _PDCLIB_restrict s, int n, FILE * _PDCLIB_restrict stream );
+
+/* Write the value c (cast to unsigned char) to the given stream. Returns c if
+   successful. If a write error occurs, sets the error indicator of the stream
+   and returns EOF.
+*/
 int fputc( int c, FILE * stream );
+
+fputs( s, stream ) - write s to stream (not including terminating \0). Return >0 if
+                     successful, EOF on write error. (No mention of err!)
+
+/* Write the string s (not including the terminating \0) to the given stream.
+   Returns a value >=0 if successful, EOF if a write error occurs. (The
+   standard does not mention the error indicator; this implementation does set
+   it in such a case.)
+*/
 int fputs( const char * _PDCLIB_restrict s, FILE * _PDCLIB_restrict stream );
-int getc( FILE * stream );
-int getchar( void );
+
+/* Equivalent to fgetc( stream ), but may be implemented as a macro that
+   evaluates its parameter more than once.
+*/
+#define getc( stream ) fgetc( stream )
+
+/* Equivalent to fgetc( stdin ), but may be implemented as a macro. */
+#define getchar() fgetc( stdin )
+
+/* Read characters from given stream into the array s, stopping at \n or EOF.
+   The string read is terminated with \0. Returns s if successful. If EOF is
+   encountered before any characters are read, the contents of s are unchanged,
+   and NULL is returned. If a read error occurs, the contents of s are indeter-
+   minate, and NULL is returned.
+*/
 char * gets( char * s );
-int putc( int c, FILE * stream );
+
+/* Equivalent to fputc( c, stream ), but may be implemented as a macro that
+   evaluates its parameter more than once.
+*/
+#define putc( c, stream ) fputc( c, stream )
+
+/* Equivalent to fputc( c, stdout ), but may be implemented as a macro that
+   evaluates its parameter more than once.
+*/
 int putchar( int c );
+
+/* 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
+   write error occurred.
+*/
 int puts( const char * s );
+
+/* Push the value c (cast to unsigned char) back onto the given (input) stream.
+   A character pushed back in this way will be delivered by subsequent read
+   operations (and skipped by subsequent file positioning operations) as if it
+   has not been read. The external representation of the stream is unaffected
+   by this pushback (it is a buffer operation). One character of pushback is
+   guaranteed, further pushbacks may fail. EOF as value for c does not change
+   the input stream and results in failure of the function.
+   For text files, the file position indicator is indeterminate until all
+   pushed-back characters are read. For binary files, the file position
+   indicator is decremented by each successful call of ungetc(). If the file
+   position indicator for a binary file was zero before the call of ungetc(),
+   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 );
 
 /* Direct input/output functions */