Trivial forwarders ***_unlocked -> _PDCLIB_***_unlocked will be implemented (but these functions avoid exposing the _unlocked symbols to code which is only requesting the standard-defined versions)
\r
uint_fast64_t _PDCLIB_ftell64( FILE * stream )\r
{\r
- flockfile( stream );\r
+ _PDCLIB_flockfile( stream );\r
uint_fast64_t pos = _PDCLIB_ftell64_unlocked( stream );\r
- funlockfile( stream );\r
+ _PDCLIB_funlockfile( stream );\r
return pos;\r
}\r
\r
#include <limits.h>
#ifndef REGTEST
+#include <_PDCLIB_io.h>
/* Using an integer's bits as flags for both the conversion flags and length
modifiers.
int character = x; \
if ( status->i < status->n ) { \
if ( status->stream != NULL ) \
- putc_unlocked( character, status->stream ); \
+ _PDCLIB_putc_unlocked( character, status->stream ); \
else \
status->s[status->i] = character; \
} \
#ifndef REGTEST
#include <_PDCLIB_io.h>
-void clearerr_unlocked( FILE * stream )
+void _PDCLIB_clearerr_unlocked( FILE * stream )
{
stream->status &= ~( _PDCLIB_ERRORFLAG | _PDCLIB_EOFFLAG );
}
void clearerr( FILE * stream )
{
- flockfile( stream );
- clearerr_unlocked( stream );
- funlockfile( stream );
+ _PDCLIB_flockfile( stream );
+ _PDCLIB_clearerr_unlocked( stream );
+ _PDCLIB_funlockfile( stream );
}
#endif
#ifndef REGTEST
#include <_PDCLIB_io.h>
-int feof_unlocked( FILE * stream )
+int _PDCLIB_feof_unlocked( FILE * stream )
{
return stream->status & _PDCLIB_EOFFLAG;
}
int feof( FILE * stream )
{
- flockfile( stream );
- int eof = feof_unlocked( stream );
- funlockfile( stream );
+ _PDCLIB_flockfile( stream );
+ int eof = _PDCLIB_feof_unlocked( stream );
+ _PDCLIB_funlockfile( stream );
return eof;
}
#ifndef REGTEST
#include <_PDCLIB_io.h>
-int ferror_unlocked( FILE * stream )
+int _PDCLIB_ferror_unlocked( FILE * stream )
{
return stream->status & _PDCLIB_ERRORFLAG;
}
int ferror( FILE * stream )
{
- flockfile( stream );
- int error = ferror_unlocked( stream );
- funlockfile( stream );
+ _PDCLIB_flockfile( stream );
+ int error = _PDCLIB_ferror_unlocked( stream );
+ _PDCLIB_funlockfile( stream );
return error;
}
extern FILE * _PDCLIB_filelist;
-int fflush_unlocked( FILE * stream )
+int _PDCLIB_fflush_unlocked( FILE * stream )
{
if ( stream == NULL )
{
int fflush( FILE * stream )
{
- flockfile( stream );
- int res = fflush_unlocked(stream);
- funlockfile( stream );
+ _PDCLIB_flockfile( stream );
+ int res = _PDCLIB_fflush_unlocked(stream);
+ _PDCLIB_funlockfile( stream );
return res;
}
#ifndef REGTEST
#include <_PDCLIB_io.h>
-int fgetc_unlocked( FILE * stream )
+int _PDCLIB_fgetc_unlocked( FILE * stream )
{
if ( _PDCLIB_prepread( stream ) == EOF )
{
int fgetc( FILE * stream )
{
- flockfile( stream );
- int c = fgetc_unlocked( stream );
- funlockfile( stream );
+ _PDCLIB_flockfile( stream );
+ int c = _PDCLIB_fgetc_unlocked( stream );
+ _PDCLIB_funlockfile( stream );
return c;
}
#ifndef REGTEST
#include <_PDCLIB_io.h>
-int fgetpos_unlocked( FILE * _PDCLIB_restrict stream, _PDCLIB_fpos_t * _PDCLIB_restrict pos )
+int _PDCLIB_fgetpos_unlocked( FILE * _PDCLIB_restrict stream, _PDCLIB_fpos_t * _PDCLIB_restrict pos )
{
pos->offset = stream->pos.offset + stream->bufidx - stream->ungetidx;
pos->mbs = stream->pos.mbs;
int fgetpos( FILE * _PDCLIB_restrict stream, _PDCLIB_fpos_t * _PDCLIB_restrict pos )
{
- flockfile( stream );
- int res = fgetpos_unlocked( stream, pos );
- funlockfile( stream );
+ _PDCLIB_flockfile( stream );
+ int res = _PDCLIB_fgetpos_unlocked( stream, pos );
+ _PDCLIB_funlockfile( stream );
return res;
}
#ifndef REGTEST
#include <_PDCLIB_io.h>
-char * fgets_unlocked( char * _PDCLIB_restrict s, int size, FILE * _PDCLIB_restrict stream )
+char * _PDCLIB_fgets_unlocked( char * _PDCLIB_restrict s, int size, FILE * _PDCLIB_restrict stream )
{
if ( size == 0 )
{
char * fgets( char * _PDCLIB_restrict s, int size,
FILE * _PDCLIB_restrict stream )
{
- flockfile( stream );
- char* r = fgets_unlocked( s, size, stream );
- funlockfile( stream );
+ _PDCLIB_flockfile( stream );
+ char* r = _PDCLIB_fgets_unlocked( s, size, stream );
+ _PDCLIB_funlockfile( stream );
return r;
}
#include <threads.h>\r
#include <stdlib.h>\r
\r
-void flockfile( FILE * file )\r
+void _PDCLIB_flockfile( FILE * file )\r
{\r
if( mtx_lock( &file->lock ) != thrd_success ) {\r
abort();\r
#ifndef REGTEST
#include <_PDCLIB_io.h>
-int fprintf_unlocked( FILE * _PDCLIB_restrict stream,
+int _PDCLIB_fprintf_unlocked( FILE * _PDCLIB_restrict stream,
const char * _PDCLIB_restrict format, ... )
{
int rc;
va_list ap;
va_start( ap, format );
- rc = vfprintf( stream, format, ap );
+ rc = _PDCLIB_vfprintf_unlocked( stream, format, ap );
va_end( ap );
return rc;
}
int rc;
va_list ap;
va_start( ap, format );
- flockfile( stream );
- rc = vfprintf_unlocked( stream, format, ap );
- funlockfile( stream );
+ _PDCLIB_flockfile( stream );
+ rc = _PDCLIB_vfprintf_unlocked( stream, format, ap );
+ _PDCLIB_funlockfile( stream );
va_end( ap );
return rc;
}
Returns c if successful, EOF otherwise.
If a write error occurs, the error indicator of the stream is set.
*/
-int fputc_unlocked( int c, FILE * stream )
+int _PDCLIB_fputc_unlocked( int c, FILE * stream )
{
if ( _PDCLIB_prepwrite( stream ) == EOF )
{
int fputc( int c, FILE * stream )
{
- flockfile( stream );
- int r = fputc_unlocked( c, stream );
- funlockfile( stream );
+ _PDCLIB_flockfile( stream );
+ int r = _PDCLIB_fputc_unlocked( c, stream );
+ _PDCLIB_funlockfile( stream );
return r;
}
#ifndef REGTEST
#include <_PDCLIB_io.h>
-int fputs_unlocked( const char * _PDCLIB_restrict s,
+int _PDCLIB_fputs_unlocked( const char * _PDCLIB_restrict s,
FILE * _PDCLIB_restrict stream )
{
if ( _PDCLIB_prepwrite( stream ) == EOF )
int fputs( const char * _PDCLIB_restrict s,
FILE * _PDCLIB_restrict stream )
{
- flockfile( stream );
- int r = fputs_unlocked( s, stream );
- funlockfile( stream );
+ _PDCLIB_flockfile( stream );
+ int r = _PDCLIB_fputs_unlocked( s, stream );
+ _PDCLIB_funlockfile( stream );
return r;
}
#include <stdbool.h>
#include <string.h>
-size_t fread_unlocked(
+size_t _PDCLIB_fread_unlocked(
void * _PDCLIB_restrict ptr,
size_t size, size_t nmemb,
FILE * _PDCLIB_restrict stream
size_t size, size_t nmemb,
FILE * _PDCLIB_restrict stream )
{
- flockfile( stream );
- size_t r = fread_unlocked( ptr, size, nmemb, stream );
- funlockfile( stream );
+ _PDCLIB_flockfile( stream );
+ size_t r = _PDCLIB_fread_unlocked( ptr, size, nmemb, stream );
+ _PDCLIB_funlockfile( stream );
return r;
}
FILE * _PDCLIB_restrict stream
)
{
- flockfile( stream );
+ _PDCLIB_flockfile( stream );
unsigned int status = stream->status &
( _IONBF | _IOLBF | _IOFBF | _PDCLIB_FREEBUFFER
if ( ( filename == NULL ) && ( stream->filename == NULL ) )
{
/* TODO: Special handling for mode changes on std-streams */
- funlockfile( stream );
+ _PDCLIB_funlockfile( stream );
return NULL;
}
stream->ops->close(stream->handle);
It does not matter with the current implementation of clearerr(),
but it might start to matter if someone replaced that implementation.
*/
- clearerr( stream );
+ _PDCLIB_clearerr_unlocked( stream );
/* The new filename might not fit the old buffer */
if ( filename == NULL )
{
/* Allocate new buffer */
if ( ( stream->filename = (char *)malloc( strlen( filename ) ) ) == NULL )
{
- funlockfile( stream );
+ _PDCLIB_funlockfile( stream );
return NULL;
}
strcpy( stream->filename, filename );
}
if ( ( mode == NULL ) || ( filename[0] == '\0' ) )
{
- funlockfile( stream );
+ _PDCLIB_funlockfile( stream );
return NULL;
}
if ( ( stream->status = _PDCLIB_filemode( mode ) ) == 0 )
{
- funlockfile( stream );
+ _PDCLIB_funlockfile( stream );
return NULL;
}
/* Re-add the flags we saved above */
if ( ! _PDCLIB_open( &stream->handle, &stream->ops, filename,
stream->status ) )
{
- funlockfile( stream );
+ _PDCLIB_funlockfile( stream );
return NULL;
}
- funlockfile( stream );
+ _PDCLIB_funlockfile( stream );
return stream;
}
#include <stdarg.h>
#ifndef REGTEST
+#include <_PDCLIB_io.h>
-int fscanf_unlocked( FILE * _PDCLIB_restrict stream,
+int _PDCLIB_fscanf_unlocked( FILE * _PDCLIB_restrict stream,
const char * _PDCLIB_restrict format, ... )
{
int rc;
va_list ap;
va_start( ap, format );
- rc = vfscanf_unlocked( stream, format, ap );
+ rc = _PDCLIB_vfscanf_unlocked( stream, format, ap );
va_end( ap );
return rc;
}
#ifndef REGTEST
#include <_PDCLIB_io.h>
-int fseek_unlocked( FILE * stream, long loffset, int whence )
+int _PDCLIB_fseek_unlocked( FILE * stream, long loffset, int whence )
{
_PDCLIB_int64_t offset = loffset;
if ( stream->status & _PDCLIB_FWRITE )
if ( whence == SEEK_CUR )
{
whence = SEEK_SET;
- offset += _PDCLIB_ftell64( stream );
+ offset += _PDCLIB_ftell64_unlocked( stream );
}
return ( _PDCLIB_seek( stream, offset, whence ) != EOF ) ? 0 : EOF;
int fseek( FILE * stream, long loffset, int whence )
{
- flockfile( stream );
- int r = fseek_unlocked( stream, loffset, whence );
- funlockfile( stream );
+ _PDCLIB_flockfile( stream );
+ int r = _PDCLIB_fseek_unlocked( stream, loffset, whence );
+ _PDCLIB_funlockfile( stream );
return r;
}
#ifndef REGTEST
#include <_PDCLIB_io.h>
-int fsetpos_unlocked( FILE * stream,
+int _PDCLIB_fsetpos_unlocked( FILE * stream,
const _PDCLIB_fpos_t * pos )
{
if ( stream->status & _PDCLIB_FWRITE )
int fsetpos( FILE * stream,
const _PDCLIB_fpos_t * pos )
{
- flockfile( stream );
- int res = fsetpos_unlocked( stream, pos );
- funlockfile( stream );
+ _PDCLIB_flockfile( stream );
+ int res = _PDCLIB_fsetpos_unlocked( stream, pos );
+ _PDCLIB_funlockfile( stream );
return res;
}
#include <errno.h>
#ifndef REGTEST
+#include <_PDCLIB_io.h>
-long int ftell_unlocked( FILE * stream )
+long int _PDCLIB_ftell_unlocked( FILE * stream )
{
uint_fast64_t off64 = _PDCLIB_ftell64_unlocked( stream );
long int ftell( FILE * stream )
{
- flockfile( stream );
- long int off = ftell_unlocked( stream );
- funlockfile( stream );
+ _PDCLIB_flockfile( stream );
+ long int off = _PDCLIB_ftell_unlocked( stream );
+ _PDCLIB_funlockfile( stream );
return off;
}
#include <threads.h>\r
#include <stdlib.h>\r
\r
-int ftrylockfile( FILE * file )\r
+int _PDCLIB_ftrylockfile( FILE * file )\r
{\r
int res = mtx_trylock( &file->lock );\r
switch(res) {\r
#include <threads.h>\r
#include <stdlib.h>\r
\r
-void funlockfile( FILE * file )\r
+void _PDCLIB_funlockfile( FILE * file )\r
{\r
int res = mtx_unlock( &file->lock );\r
switch(res) {\r
//TODO OS(2012-08-01): Ascertain purpose of lineend & potentially remove
-size_t fwrite_unlocked( const void * _PDCLIB_restrict ptr,
+size_t _PDCLIB_fwrite_unlocked( const void * _PDCLIB_restrict ptr,
size_t size, size_t nmemb,
FILE * _PDCLIB_restrict stream )
{
size_t size, size_t nmemb,
FILE * _PDCLIB_restrict stream )
{
- flockfile( stream );
- size_t r = fwrite_unlocked( ptr, size, nmemb, stream );
- funlockfile( stream );
+ _PDCLIB_flockfile( stream );
+ size_t r = _PDCLIB_fwrite_unlocked( ptr, size, nmemb, stream );
+ _PDCLIB_funlockfile( stream );
return r;
}
#include <stdio.h>
#ifndef REGTEST
-
-int getc_unlocked( FILE * stream )
+#include <_PDCLIB_io.h>
+
+int _PDCLIB_getc_unlocked( FILE * stream )
{
- return fgetc_unlocked( stream );
+ return _PDCLIB_fgetc_unlocked( stream );
}
int getc( FILE * stream )
#include <stdio.h>
#ifndef REGTEST
+#include <_PDCLIB_io.h>
-int getchar_unlocked( void )
+int _PDCLIB_getchar_unlocked( void )
{
- return fgetc_unlocked( stdin );
+ return _PDCLIB_fgetc_unlocked( stdin );
}
return rc;
}
-int printf_unlocked( const char * _PDCLIB_restrict format, ... )
+int _PDCLIB_printf_unlocked( const char * _PDCLIB_restrict format, ... )
{
int rc;
va_list ap;
va_start( ap, format );
- rc = vfprintf_unlocked( stdout, format, ap );
+ rc = _PDCLIB_vfprintf_unlocked( stdout, format, ap );
va_end( ap );
return rc;
}
#include <stdio.h>
#ifndef REGTEST
+#include <_PDCLIB_io.h>
-int putc_unlocked( int c, FILE * stream )
+int _PDCLIB_putc_unlocked( int c, FILE * stream )
{
- return fputc_unlocked( c, stream );
+ return _PDCLIB_fputc_unlocked( c, stream );
}
#include <stdio.h>
#ifndef REGTEST
+#include <_PDCLIB_io.h>
-int putchar_unlocked( int c )
+int _PDCLIB_putchar_unlocked( int c )
{
- return fputc_unlocked( c, stdout );
+ return _PDCLIB_fputc_unlocked( c, stdout );
}
int putchar( int c )
#include <stdio.h>
#ifndef REGTEST
-#include <_PDCLIB_glue.h>
+#include <_PDCLIB_io.h>
extern char * _PDCLIB_eol;
-int puts_unlocked( const char * s )
+int _PDCLIB_puts_unlocked( const char * s )
{
if ( _PDCLIB_prepwrite( stdout ) == EOF )
{
int puts( const char * s )
{
- flockfile( stdout );
- int r = puts_unlocked( s );
- funlockfile( stdout );
+ _PDCLIB_flockfile( stdout );
+ int r = _PDCLIB_puts_unlocked( s );
+ _PDCLIB_funlockfile( stdout );
return r;
}
#ifndef REGTEST
#include <_PDCLIB_io.h>
-void rewind_unlocked( FILE * stream )
+void _PDCLIB_rewind_unlocked( FILE * stream )
{
stream->status &= ~ _PDCLIB_ERRORFLAG;
- fseek_unlocked( stream, 0L, SEEK_SET );
+ _PDCLIB_fseek_unlocked( stream, 0L, SEEK_SET );
}
void rewind( FILE * stream )
{
- flockfile(stream);
- rewind_unlocked(stream);
- funlockfile(stream);
+ _PDCLIB_flockfile(stream);
+ _PDCLIB_rewind_unlocked(stream);
+ _PDCLIB_funlockfile(stream);
}
#endif
#include <stdarg.h>
#ifndef REGTEST
+#include <_PDCLIB_io.h>
-int scanf_unlocked( const char * _PDCLIB_restrict format, ... )
+int _PDCLIB_scanf_unlocked( const char * _PDCLIB_restrict format, ... )
{
va_list ap;
va_start( ap, format );
- return vfscanf_unlocked( stdin, format, ap );
+ return _PDCLIB_vfscanf_unlocked( stdin, format, ap );
}
int scanf( const char * _PDCLIB_restrict format, ... )
int setvbuf( FILE * _PDCLIB_restrict stream, char * _PDCLIB_restrict buf, int mode, size_t size )
{
- _PDCLIB_lockfile( stream );
+ _PDCLIB_flockfile( stream );
switch ( mode )
{
case _IONBF:
#ifndef REGTEST
#include <_PDCLIB_io.h>
-int ungetc_unlocked( int c, FILE * stream )
+int _PDCLIB_ungetc_unlocked( int c, FILE * stream )
{
if ( c == EOF || stream->ungetidx == _PDCLIB_UNGETCBUFSIZE )
{
int ungetc( int c, FILE * stream )
{
- flockfile( stream );
- int r = ungetc_unlocked( c, stream );
- funlockfile( stream);
+ _PDCLIB_flockfile( stream );
+ int r = _PDCLIB_ungetc_unlocked( c, stream );
+ _PDCLIB_funlockfile( stream);
return r;
}
#ifndef REGTEST
#include <_PDCLIB_io.h>
-int vfprintf_unlocked( FILE * _PDCLIB_restrict stream,
+int _PDCLIB_vfprintf_unlocked( FILE * _PDCLIB_restrict stream,
const char * _PDCLIB_restrict format,
va_list arg )
{
const char * _PDCLIB_restrict format,
va_list arg )
{
- flockfile( stream );
- int r = vfprintf_unlocked( stream, format, arg );
- funlockfile( stream );
+ _PDCLIB_flockfile( stream );
+ int r = _PDCLIB_vfprintf_unlocked( stream, format, arg );
+ _PDCLIB_funlockfile( stream );
return r;
}
#ifndef REGTEST
#include <_PDCLIB_io.h>
-int vfscanf_unlocked( FILE * _PDCLIB_restrict stream,
+int _PDCLIB_vfscanf_unlocked( FILE * _PDCLIB_restrict stream,
const char * _PDCLIB_restrict format,
va_list arg )
{
}
if ( ! feof( stream ) )
{
- ungetc( c, stream );
+ _PDCLIB_ungetc_unlocked( c, stream );
}
}
else
{
/* Non-whitespace char in format string: Match verbatim */
- if ( ( ( c = getc( stream ) ) != *format ) || feof( stream ) )
+ if ( ( ( c = _PDCLIB_getc_unlocked( stream ) ) != *format ) || feof( stream ) )
{
/* Matching error */
if ( ! feof( stream ) && ! ferror( stream ) )
{
- ungetc( c, stream );
+ _PDCLIB_ungetc_unlocked( c, stream );
}
else if ( status.n == 0 )
{
const char * _PDCLIB_restrict format,
va_list arg )
{
- flockfile( stream );
- int r = vfscanf_unlocked( stream, format, arg );
- funlockfile( stream );
+ _PDCLIB_flockfile( stream );
+ int r = _PDCLIB_vfscanf_unlocked( stream, format, arg );
+ _PDCLIB_funlockfile( stream );
return r;
}
#include <stdarg.h>
#ifndef REGTEST
+#include <_PDCLIB_io.h>
-int vprintf_unlocked( const char * _PDCLIB_restrict format,
- _PDCLIB_va_list arg )
+int _PDCLIB_vprintf_unlocked( const char * _PDCLIB_restrict format,
+ _PDCLIB_va_list arg )
{
- return vfprintf_unlocked( stdout, format, arg );
+ return _PDCLIB_vfprintf_unlocked( stdout, format, arg );
}
int vprintf( const char * _PDCLIB_restrict format, _PDCLIB_va_list arg )
#include <stdarg.h>
#ifndef REGTEST
+#include <_PDCLIB_io.h>
-int vscanf_unlocked( const char * _PDCLIB_restrict format, _PDCLIB_va_list arg )
+int _PDCLIB_vscanf_unlocked( const char * _PDCLIB_restrict format,
+ _PDCLIB_va_list arg )
{
- return vfscanf_unlocked( stdin, format, arg );
+ return _PDCLIB_vfscanf_unlocked( stdin, format, arg );
}
int vscanf( const char * _PDCLIB_restrict format, _PDCLIB_va_list arg )
_PDCLIB_size_t length, _PDCLIB_size_t * numCharsWritten );\r
};\r
\r
-/* FILE structure */\r
+/* struct _PDCLIB_file structure */\r
struct _PDCLIB_file\r
{\r
const _PDCLIB_fileops_t * ops;\r
return i;\r
}\r
\r
+/* Unlocked functions - internal names \r
+ *\r
+ * We can't use the functions using their "normal" names internally because that\r
+ * would cause namespace leakage. Therefore, we use them by prefixed internal \r
+ * names\r
+ */\r
+void _PDCLIB_flockfile(struct _PDCLIB_file *file) _PDCLIB_nothrow;\r
+int _PDCLIB_ftrylockfile(struct _PDCLIB_file *file) _PDCLIB_nothrow;\r
+void _PDCLIB_funlockfile(struct _PDCLIB_file *file) _PDCLIB_nothrow;\r
+\r
+int _PDCLIB_getc_unlocked(struct _PDCLIB_file *stream) _PDCLIB_nothrow;\r
+int _PDCLIB_getchar_unlocked(void) _PDCLIB_nothrow;\r
+int _PDCLIB_putc_unlocked(int c, struct _PDCLIB_file *stream) _PDCLIB_nothrow;\r
+int _PDCLIB_putchar_unlocked(int c) _PDCLIB_nothrow;\r
+void _PDCLIB_clearerr_unlocked(struct _PDCLIB_file *stream) _PDCLIB_nothrow; \r
+int _PDCLIB_feof_unlocked(struct _PDCLIB_file *stream) _PDCLIB_nothrow;\r
+int _PDCLIB_ferror_unlocked(struct _PDCLIB_file *stream) _PDCLIB_nothrow;\r
+int _PDCLIB_fflush_unlocked(struct _PDCLIB_file *stream) _PDCLIB_nothrow;\r
+int _PDCLIB_fgetc_unlocked(struct _PDCLIB_file *stream) _PDCLIB_nothrow;\r
+int _PDCLIB_fputc_unlocked(int c, struct _PDCLIB_file *stream) _PDCLIB_nothrow;\r
+_PDCLIB_size_t _PDCLIB_fread_unlocked(void *ptr, _PDCLIB_size_t size, _PDCLIB_size_t n, struct _PDCLIB_file *stream) _PDCLIB_nothrow;\r
+_PDCLIB_size_t _PDCLIB_fwrite_unlocked(const void *ptr, _PDCLIB_size_t size, _PDCLIB_size_t n, struct _PDCLIB_file *stream) _PDCLIB_nothrow;\r
+char *_PDCLIB_fgets_unlocked(char *s, int n, struct _PDCLIB_file *stream) _PDCLIB_nothrow;\r
+int _PDCLIB_fputs_unlocked(const char *s, struct _PDCLIB_file *stream) _PDCLIB_nothrow;\r
+int _PDCLIB_fgetpos_unlocked( struct _PDCLIB_file * _PDCLIB_restrict stream, _PDCLIB_fpos_t * _PDCLIB_restrict pos ) _PDCLIB_nothrow;\r
+int _PDCLIB_fsetpos_unlocked( struct _PDCLIB_file * stream, const _PDCLIB_fpos_t * pos ) _PDCLIB_nothrow;\r
+long int _PDCLIB_ftell_unlocked( struct _PDCLIB_file * stream ) _PDCLIB_nothrow;\r
+int _PDCLIB_fseek_unlocked( struct _PDCLIB_file * stream, long int offset, int whence ) _PDCLIB_nothrow;\r
+void _PDCLIB_rewind_unlocked( struct _PDCLIB_file * stream ) _PDCLIB_nothrow;\r
+\r
+int _PDCLIB_puts_unlocked( const char * s ) _PDCLIB_nothrow;\r
+int _PDCLIB_ungetc_unlocked( int c, struct _PDCLIB_file * stream ) _PDCLIB_nothrow;\r
+\r
+\r
+int _PDCLIB_printf_unlocked( const char * _PDCLIB_restrict format, ... ) _PDCLIB_nothrow;\r
+int _PDCLIB_vprintf_unlocked( const char * _PDCLIB_restrict format, _PDCLIB_va_list arg ) _PDCLIB_nothrow;\r
+int _PDCLIB_fprintf_unlocked( struct _PDCLIB_file * _PDCLIB_restrict stream, const char * _PDCLIB_restrict format, ... ) _PDCLIB_nothrow;\r
+int _PDCLIB_vfprintf_unlocked( struct _PDCLIB_file * _PDCLIB_restrict stream, const char * _PDCLIB_restrict format, _PDCLIB_va_list arg ) _PDCLIB_nothrow;\r
+int _PDCLIB_scanf_unlocked( const char * _PDCLIB_restrict format, ... ) _PDCLIB_nothrow;\r
+int _PDCLIB_vscanf_unlocked( const char * _PDCLIB_restrict format, _PDCLIB_va_list arg ) _PDCLIB_nothrow;\r
+int _PDCLIB_fscanf_unlocked( struct _PDCLIB_file * _PDCLIB_restrict stream, const char * _PDCLIB_restrict format, ... ) _PDCLIB_nothrow;\r
+int _PDCLIB_vfscanf_unlocked( struct _PDCLIB_file * _PDCLIB_restrict stream, const char * _PDCLIB_restrict format, _PDCLIB_va_list arg ) _PDCLIB_nothrow;\r
+\r
#endif\r
projects / pdclib.old / commitdiff