void
__printf_flush(struct __printf_io *io)
{
__sfvwrite(io->fp, &io->uio);
__printf_init(io);
}
/*
* Write the given string to the given file.
*/
int
fputs(const char *s, FILE *fp)
{
struct __suio uio;
struct __siov iov;
int r;
_DIAGASSERT(s != NULL);
_DIAGASSERT(fp != NULL);
if(fp == NULL) {
errno = EINVAL;
return (EOF);
}
if (s == NULL)
s = "(null)";
iov.iov_base = __UNCONST(s);
uio.uio_resid = (int)(iov.iov_len = strlen(s));
uio.uio_iov = &iov;
uio.uio_iovcnt = 1;
FLOCKFILE(fp);
_SET_ORIENTATION(fp, -1);
r = __sfvwrite(fp, &uio);
FUNLOCKFILE(fp);
return r;
}
/*
* Write the given string to stdout, appending a newline.
*/
int
puts(char const *s)
{
size_t c;
struct __suio uio;
struct __siov iov[2];
int r;
_DIAGASSERT(s != NULL);
if (s == NULL)
s = "(null)";
c = strlen(s);
iov[0].iov_base = __UNCONST(s);
iov[0].iov_len = c;
iov[1].iov_base = __UNCONST("\n");
iov[1].iov_len = 1;
uio.uio_resid = (int)(c + 1);
uio.uio_iov = &iov[0];
uio.uio_iovcnt = 2;
FLOCKFILE(stdout);
r = __sfvwrite(stdout, &uio);
FUNLOCKFILE(stdout);
return (r ? EOF : '\n');
}
/*
* Like __fputwc_unlock, but handles fake string (__SSTR) files properly.
* File must already be locked.
*/
static wint_t
__xfputwc(wchar_t wc, FILE *fp, locale_t locale)
{
mbstate_t mbs;
char buf[MB_LEN_MAX];
struct __suio uio;
struct __siov iov;
size_t len;
if ((fp->_flags & __SSTR) == 0)
return (__fputwc_unlock(wc, fp, locale));
memset(&mbs, 0, sizeof(mbs));
len = wcrtomb(buf, wc, &mbs);
if (len == (size_t)-1) {
fp->_flags |= __SERR;
errno = EILSEQ;
return (WEOF);
}
uio.uio_iov = &iov;
uio.uio_resid = len;
uio.uio_iovcnt = 1;
iov.iov_base = buf;
iov.iov_len = len;
return (__sfvwrite(fp, &uio) != EOF ? (wint_t)wc : WEOF);
}
/*
* Write `count' objects (each size `size') from memory to the given file.
* Return the number of whole objects written.
*/
size_t
fwrite(const void *buf, size_t size, size_t count, FILE *fp)
{
size_t n;
struct __suio uio;
struct __siov iov;
int ret;
/*
* ANSI and SUSv2 require a return value of 0 if size or count are 0.
*/
if ((n = count * size) == 0)
return (0);
iov.iov_base = (void *)buf;
uio.uio_resid = iov.iov_len = n;
uio.uio_iov = &iov;
uio.uio_iovcnt = 1;
/*
* The usual case is success (__sfvwrite returns 0);
* skip the divide if this happens, since divides are
* generally slow and since this occurs whenever size==0.
*/
FLOCKFILE(fp);
_SET_ORIENTATION(fp, -1);
ret = __sfvwrite(fp, &uio);
FUNLOCKFILE(fp);
if (ret == 0)
return (count);
return ((n - uio.uio_resid) / size);
}
int
putw(int w, FILE *fp)
{
struct __suio uio;
struct __siov iov;
iov.iov_base = &w;
iov.iov_len = uio.uio_resid = sizeof(w);
uio.uio_iov = &iov;
uio.uio_iovcnt = 1;
return (__sfvwrite(fp, &uio));
}
/*
* Flush out all the vectors defined by the given uio,
* then reset it so that it can be reused.
*/
static int
__sprint(FILE *fp, struct __suio *uio)
{
int err;
if (uio->uio_resid == 0) {
uio->uio_iovcnt = 0;
return (0);
}
err = __sfvwrite(fp, uio);
uio->uio_resid = 0;
uio->uio_iovcnt = 0;
return (err);
}
int
putw(int w, FILE *fp)
{
int retval;
struct __suio uio;
struct __siov iov;
iov.iov_base = &w;
iov.iov_len = uio.uio_resid = sizeof(w);
uio.uio_iov = &iov;
uio.uio_iovcnt = 1;
FLOCKFILE(fp);
retval = __sfvwrite(fp, &uio);
FUNLOCKFILE(fp);
return (retval);
}
int _puts_r(struct _reent *ptr, const char *s)
{
size_t c = strlen(s);
struct __suio uio;
struct __siov iov[2];
iov[0].iov_base = s;
iov[0].iov_len = c;
iov[1].iov_base = "\n";
iov[1].iov_len = 1;
uio.uio_resid = c + 1;
uio.uio_iov = &iov[0];
uio.uio_iovcnt = 2;
return (__sfvwrite(_stdout_r(ptr), &uio) ? EOF : '\n');
}
/*
* Write the given string to the given file.
*/
int
fputs(const char *s, FILE *fp)
{
struct __suio uio;
struct __siov iov;
int ret;
iov.iov_base = (void *)s;
iov.iov_len = uio.uio_resid = strlen(s);
uio.uio_iov = &iov;
uio.uio_iovcnt = 1;
FLOCKFILE(fp);
_SET_ORIENTATION(fp, -1);
ret = __sfvwrite(fp, &uio);
FUNLOCKFILE(fp);
return (ret);
}
wint_t
__fputwc_unlock(wchar_t wc, FILE *fp)
{
struct wchar_io_data *wcio;
mbstate_t *st;
size_t size;
char buf[MB_LEN_MAX];
struct __suio uio;
struct __siov iov;
_DIAGASSERT(fp != NULL);
if(fp == NULL) {
errno = EINVAL;
return (WEOF);
}
/* LINTED we don't play with buf */
iov.iov_base = (void *)buf;
uio.uio_iov = &iov;
uio.uio_iovcnt = 1;
_SET_ORIENTATION(fp, 1);
wcio = WCIO_GET(fp);
if (wcio == 0) {
errno = ENOMEM;
return WEOF;
}
wcio->wcio_ungetwc_inbuf = 0;
st = &wcio->wcio_mbstate_out;
size = wcrtomb(buf, wc, st);
if (size == (size_t)-1) {
errno = EILSEQ;
return WEOF;
}
_DIAGASSERT(size != 0);
uio.uio_resid = (int)(iov.iov_len = size);
if (__sfvwrite(fp, &uio)) {
return WEOF;
}
return (wint_t)wc;
}
int fputs
(
const char * s, /* string */
FILE * fp /* stream to write to */
)
{
struct __suio uio;
struct __siov iov;
if (OBJ_VERIFY (fp, fpClassId) != OK)
return (EOF);
iov.iov_base = (void *)s;
iov.iov_len = uio.uio_resid = strlen (s);
uio.uio_iov = &iov;
uio.uio_iovcnt = 1;
return (__sfvwrite (fp, &uio));
}
int puts(
const char *str
)
{
struct __suio uio;
struct __siov iov[2];
size_t len = strlen(str);
iov[0].iov_base = (void *) str;
iov[0].iov_len = len;
iov[1].iov_base = "\n";
iov[1].iov_len = 1;
uio.uio_resid = len + 1;
uio.uio_iov = &iov[0];
uio.uio_iovcnt = 2;
return ((__sfvwrite(stdout, &uio)) ? (EOF) : ('\n'));
}
/*
* Write the given string to stdout, appending a newline.
*/
int
puts(const char *s)
{
size_t c = strlen(s);
struct __suio uio;
struct __siov iov[2];
int ret;
iov[0].iov_base = (void *)s;
iov[0].iov_len = c;
iov[1].iov_base = "\n";
iov[1].iov_len = 1;
uio.uio_resid = c + 1;
uio.uio_iov = &iov[0];
uio.uio_iovcnt = 2;
FLOCKFILE(stdout);
_SET_ORIENTATION(stdout, -1);
ret = __sfvwrite(stdout, &uio);
FUNLOCKFILE(stdout);
return (ret ? EOF : '\n');
}
/*
* Write the given string to stdout, appending a newline.
*/
int
puts(char const *s)
{
int retval;
size_t c;
struct __suio uio;
struct __siov iov[2];
iov[0].iov_base = (void *)s;
iov[0].iov_len = c = strlen(s);
iov[1].iov_base = "\n";
iov[1].iov_len = 1;
uio.uio_resid = c + 1;
uio.uio_iov = &iov[0];
uio.uio_iovcnt = 2;
FLOCKFILE(stdout);
ORIENT(stdout, -1);
retval = __sfvwrite(stdout, &uio) ? EOF : '\n';
FUNLOCKFILE(stdout);
return (retval);
}
/*
* Like __fputwc, but handles fake string (__SSTR) files properly.
* File must already be locked.
*/
static wint_t
__xfputwc(wchar_t wc, FILE *fp)
{
mbstate_t mbs;
char buf[MB_LEN_MAX];
struct __suio uio;
struct __siov iov;
size_t len;
if ((fp->_flags & __SSTR) == 0)
return (__fputwc(wc, fp));
mbs = initial_mbs;
if ((len = wcrtomb(buf, wc, &mbs)) == (size_t)-1) {
fp->_flags |= __SERR;
return (WEOF);
}
uio.uio_iov = &iov;
uio.uio_resid = len;
uio.uio_iovcnt = 1;
iov.iov_base = buf;
iov.iov_len = len;
return (__sfvwrite(fp, &uio) != EOF ? (wint_t)wc : WEOF);
}
Supporting OS subroutines required: <<close>>, <<fstat>>, <<isatty>>,
<<lseek>>, <<read>>, <<sbrk>>, <<write>>.
*/
#include <stdio.h>
#include <string.h>
#include "fvwrite.h"
/*
* Write the given string to the given file.
*/
int
_DEFUN (fputs, (s, fp),
char _CONST * s _AND
FILE * fp)
{
int result;
struct __suio uio;
struct __siov iov;
iov.iov_base = s;
iov.iov_len = uio.uio_resid = strlen (s);
uio.uio_iov = &iov;
uio.uio_iovcnt = 1;
_flockfile(fp);
result = __sfvwrite (fp, &uio);
_funlockfile(fp);
return result;
}
*/
#include "namespace.h"
#include <stdio.h>
#include <string.h>
#include "un-namespace.h"
#include "libc_private.h"
#include "local.h"
#include "priv_stdio.h"
/*
* Write the given string to the given file.
*/
int
fputs(const char * __restrict s, FILE * __restrict fp)
{
int retval;
struct __suio uio;
struct __siov iov;
iov.iov_base = __DECONST(char *, s);
iov.iov_len = uio.uio_resid = strlen(s);
uio.uio_iov = &iov;
uio.uio_iovcnt = 1;
FLOCKFILE(fp);
ORIENT(fp, -1);
retval = __sfvwrite(fp, &uio);
FUNLOCKFILE(fp);
return (retval);
}
