/***************************************************************
  MPU-PRINTF.C

       This file contains source code of public formatted
       output functions for LIBMPUIO library.

       PART OF : MPUIO - library .

       Copyright (C) 2000 - 2026  by Andrey V.Kosteltsev.
       All Rights Reserved.
 ***************************************************************/

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <libmpuio.h>
#include <mpu-symbols.h>
#include <mpu-libio.h>


int
mpu_vfprintf( mpu_FILE *stream, const __mpu_char16_t *format, va_list args )
{
  return( __mpu_IO_vfprintf( stream, format, args ) );

} /* End of mpu_vfprintf() */


int
mpu_fprintf( mpu_FILE *stream, const __mpu_char16_t *format, ... )
{
  va_list  args;
  int      ret;

  va_start( args, format );
  ret = mpu_vfprintf( stream, format, args );
  va_end( args );

  return( ret );

} /* End of mpu_fprintf() */


int
mpu_vprintf( const __mpu_char16_t *format, va_list args )
{
  return( mpu_vfprintf( mpu_stdout, format, args ) );

} /* End of mpu_vprintf() */


int
mpu_printf( const __mpu_char16_t *format, ... )
{
  va_list  args;
  int      ret;

  va_start( args, format );
  ret = mpu_vprintf( format, args );
  va_end( args );

  return( ret );

} /* End of mpu_printf() */


/***************************************************************
  Write formatted output to STREAM without locking it.
 ***************************************************************/
int
mpu_vfprintf_unlocked( mpu_FILE *stream, const __mpu_char16_t *format,
                       va_list args )
{
  return( __mpu_IO_vfprintf_unlocked( stream, format, args ) );

} /* End of mpu_vfprintf_unlocked() */


/***************************************************************
  Write formatted output to STREAM without locking it.
 ***************************************************************/
int
mpu_fprintf_unlocked( mpu_FILE *stream, const __mpu_char16_t *format, ... )
{
  va_list  args;
  int      ret;

  va_start( args, format );
  ret = mpu_vfprintf_unlocked( stream, format, args );
  va_end( args );

  return( ret );

} /* End of mpu_fprintf_unlocked() */


/***************************************************************
  Write formatted output to mpu_stdout using a va_list without
  locking the standard output stream.
 ***************************************************************/
int
mpu_vprintf_unlocked( const __mpu_char16_t *format, va_list args )
{
  return( mpu_vfprintf_unlocked( mpu_stdout, format, args ) );

} /* End of mpu_vprintf_unlocked() */


/***************************************************************
  Write formatted output to mpu_stdout without locking it.
 ***************************************************************/
int
mpu_printf_unlocked( const __mpu_char16_t *format, ... )
{
  va_list  args;
  int      ret;

  va_start( args, format );
  ret = mpu_vprintf_unlocked( format, args );
  va_end( args );

  return( ret );

} /* End of mpu_printf_unlocked() */


int
mpu_vsnprintf( __mpu_char16_t *string, size_t size,
               const __mpu_char16_t *format, va_list args )
{
  mpu_FILE         *stream;
  __mpu_IO_strfile *sf;
  int               ret;

  if( size != 0 && string == (__mpu_char16_t *)0 )
  {
    errno = EINVAL;
    return( mpu_EOF );
  }

  stream = __mpu_IO_str_open_counted( string,
                                      size ? size - 1 : 0 );
  if( stream == (mpu_FILE *)0 )
    return( mpu_EOF );

  ret = __mpu_IO_vfprintf( stream, format, args );

  sf = (__mpu_IO_strfile *)stream->_cookie;
  if( size != 0 )
  {
    size_t  pos = sf->pos < sf->capacity ? sf->pos : sf->capacity;
    string[pos] = 0;
  }

  mpu_fclose( stream );

  return( ret );

} /* End of mpu_vsnprintf() */


int
mpu_snprintf( __mpu_char16_t *string, size_t size,
              const __mpu_char16_t *format, ... )
{
  va_list  args;
  int      ret;

  va_start( args, format );
  ret = mpu_vsnprintf( string, size, format, args );
  va_end( args );

  return( ret );

} /* End of mpu_snprintf() */


int
mpu_vsprintf( __mpu_char16_t *string,
              const __mpu_char16_t *format, va_list args )
{
  mpu_FILE         *stream;
  __mpu_IO_strfile *sf;
  int               ret;

  if( string == (__mpu_char16_t *)0 )
  {
    errno = EINVAL;
    return( mpu_EOF );
  }

  stream = __mpu_IO_str_open( string, SIZE_MAX, 0, __MPU_IO_NOLIST );
  if( stream == (mpu_FILE *)0 )
     return( mpu_EOF );

  ret = __mpu_IO_vfprintf( stream, format, args );

  sf = (__mpu_IO_strfile *)stream->_cookie;
  string[sf->pos] = 0;

  mpu_fclose( stream );

  return( ret );

} /* End of mpu_vsprintf() */


int
mpu_sprintf( __mpu_char16_t *string, const __mpu_char16_t *format, ... )
{
  va_list  args;
  int      ret;

  va_start( args, format );
  ret = mpu_vsprintf( string, format, args );
  va_end( args );

  return( ret );

} /* End of mpu_sprintf() */

/***************************************************************
  Allocate a dynamically sized UCS-2 string and write formatted
  output into it.  The caller owns *STRING on success.
 ***************************************************************/
int
mpu_vasprintf( __mpu_char16_t **string, const __mpu_char16_t *format,
               va_list args )
{
  mpu_FILE        *stream;
  __mpu_char16_t  *buffer = (__mpu_char16_t *)0;
  size_t           size = 0;
  int              ret;
  int              close_ret;
  int              saved_errno;

  if( string == (__mpu_char16_t **)0 )
  {
    errno = EINVAL;
    return( mpu_EOF );
  }

  *string = (__mpu_char16_t *)0;

  stream = __mpu_IO_str_open_memstream( &buffer, &size,
                                        __MPU_IO_NOLIST );
  if( stream == (mpu_FILE *)0 )
    return( mpu_EOF );

  ret = __mpu_IO_vfprintf( stream, format, args );
  saved_errno = errno;

  close_ret = mpu_fclose( stream );
  if( ret == mpu_EOF )
  {
    free( buffer );
    *string = (__mpu_char16_t *)0;
    errno = saved_errno;
    return( mpu_EOF );
  }

  if( close_ret == mpu_EOF )
  {
    saved_errno = errno;
    free( buffer );
    *string = (__mpu_char16_t *)0;
    errno = saved_errno;
    return( mpu_EOF );
  }

  *string = buffer;
  return( ret );

} /* End of mpu_vasprintf() */


/***************************************************************
  Allocate a dynamically sized UCS-2 string and write formatted
  output into it.  The caller owns *STRING on success.
 ***************************************************************/
int
mpu_asprintf( __mpu_char16_t **string, const __mpu_char16_t *format, ... )
{
  va_list  args;
  int      ret;

  va_start( args, format );
  ret = mpu_vasprintf( string, format, args );
  va_end( args );

  return( ret );

} /* End of mpu_asprintf() */


/***************************************************************
  Write formatted UCS-2 text as UTF-8 to FD without taking
  ownership of the caller's descriptor.
 ***************************************************************/
int
mpu_vdprintf( int fd, const __mpu_char16_t *format, va_list args )
{
  mpu_FILE  *stream;
  int        dupfd;
  int        ret;
  int        close_ret;
  int        saved_errno;

  dupfd = dup( fd );
  if( dupfd < 0 )
    return( mpu_EOF );

  stream = __mpu_IO_file_open( dupfd, __MPU_IO_NO_READS |
                               __MPU_IO_NOLIST );
  if( stream == (mpu_FILE *)0 )
  {
    saved_errno = errno;
    close( dupfd );
    errno = saved_errno;
    return( mpu_EOF );
  }

  ret = __mpu_IO_vfprintf( stream, format, args );
  saved_errno = errno;

  close_ret = mpu_fclose( stream );
  if( ret == mpu_EOF )
  {
    errno = saved_errno;
    return( mpu_EOF );
  }

  if( close_ret == mpu_EOF )
    return( mpu_EOF );

  return( ret );

} /* End of mpu_vdprintf() */


/***************************************************************
  Write formatted UCS-2 text as UTF-8 to FD without taking
  ownership of the caller's descriptor.
 ***************************************************************/
int
mpu_dprintf( int fd, const __mpu_char16_t *format, ... )
{
  va_list  args;
  int      ret;

  va_start( args, format );
  ret = mpu_vdprintf( fd, format, args );
  va_end( args );

  return( ret );

} /* End of mpu_dprintf() */