libc

HomepageMembersTimelineGalleryDownloadBug reports
Browse Download file Permalink
/* $Id$ */
/* Copyright (c) 2004-2020 Pierre Pronchery <khorben@defora.org> */
/* This file is part of DeforaOS System libc */
/* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
* IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
#include "fcntl.h"
#include "unistd.h"
#include "stdarg.h"
#include "stdint.h"
#include "stdlib.h"
#include "string.h"
#include "ctype.h"
#include "limits.h"
#include "syscalls.h"
#include "errno.h"
#include "stdio.h"
#include "start.h"
#ifndef min
# define min(a, b) ((a) > (b) ? (b) : (a))
#endif
/* private */
/* types */
typedef enum _FILEDirection { FD_READ = 0, FD_WRITE = 1 } FILEDirection;
struct _FILE
{
int fd;
int flags;
unsigned char _buf[BUFSIZ];
unsigned char * buf;
unsigned char * mbuf;
size_t bufsiz;
size_t len;
size_t pos;
char eof;
char error;
int fbuf;
FILEDirection dir;
};
typedef int (*print_func)(void * dest, size_t size, const char * buf);
typedef char (*scan_func)(char const * buf, size_t * i);
/* prototypes */
static int _fopen_mode(char const * mode);
static FILE * _fopen_new(int fd, int flags, int fbuf);
static int _vprintf(print_func func, void * dest, size_t size,
char const * format, va_list arg);
static int _vscanf(scan_func func, char const * string, char const * format,
va_list arg);
/* public */
/* variables */
static FILE _stdin =
{
STDIN_FILENO, O_RDONLY, { 0 }, _stdin._buf, NULL, sizeof(_stdin._buf),
0, 0, 0, 0, _IOFBF, FD_READ
};
FILE * stdin = &_stdin;
static FILE _stdout =
{
STDOUT_FILENO, O_WRONLY, { 0 }, _stdout._buf, NULL,
sizeof(_stdout._buf), 0, 0, 0, 0, _IOLBF, FD_WRITE
};
FILE * stdout = &_stdout;
static FILE _stderr =
{
STDERR_FILENO, O_WRONLY, { 0 }, _stderr._buf, NULL,
sizeof(_stderr._buf), 0, 0, 0, 0, _IONBF, FD_WRITE
};
FILE * stderr = &_stderr;
/* functions */
/* clearerr */
void clearerr(FILE * file)
{
file->eof = 0;
file->error = 0;
}
/* ctermid */
char * ctermid(char * buf)
{
static char const devtty[] = "/dev/tty";
static char tty[L_ctermid];
if(buf == NULL)
buf = tty;
/* XXX may overflow */
if(snprintf(buf, L_ctermid, "%s", devtty) >= L_ctermid)
return NULL;
return buf;
}
/* fclose */
int fclose(FILE * file)
{
int ret;
ret = fflush(file);
if(file->fd >= 0)
if(close(file->fd) != 0)
ret = -1;
free(file->mbuf);
free(file);
return ret;
}
/* fdopen */
FILE * fdopen(int fd, char const * mode)
{
return _fopen_new(fd, _fopen_mode(mode), isatty(fd) ? _IONBF : _IOFBF);
}
/* feof */
int feof(FILE * file)
{
return file->eof;
}
/* ferror */
int ferror(FILE * file)
{
return file->error;
}
/* fflush */
int fflush(FILE * file)
{
ssize_t w;
if(file == NULL)
{
errno = ENOSYS; /* FIXME implement */
return EOF;
}
if(file->dir == FD_WRITE)
{
for(; file->pos < file->len; file->pos += w)
if((w = write(file->fd, &file->buf[file->pos], file->len
- file->pos)) < 0)
{
file->error = 1;
return EOF;
}
}
else if(file->dir != FD_READ)
return EOF;
file->pos = 0;
file->len = 0;
return 0;
}
/* fgetc */
int fgetc(FILE * file)
{
unsigned char c;
if(fread(&c, sizeof(c), 1, file) != 1)
return EOF;
return c;
}
/* fgets */
char * fgets(char * str, int size, FILE * file)
{
int i;
int c;
if(size < 0)
{
errno = EINVAL;
return NULL;
}
for(i = 0; i + 1 < size; i++)
{
if((c = fgetc(file)) == EOF)
{
if(i == 0 || !feof(file))
return NULL;
break;
}
str[i] = c;
if(c == '\n')
break;
}
if(++i >= size)
return NULL;
str[i] = '\0';
return str;
}
/* fileno */
int fileno(FILE * file)
{
if(file == NULL)
{
errno = EBADF;
return -1;
}
return file->fd;
}
/* flock */
void flockfile(FILE * file)
{
struct flock fl;
fl.l_start = 0;
fl.l_len = 0;
fl.l_pid = 0;
fl.l_type = F_RDLCK | F_WRLCK;
fl.l_whence = SEEK_SET;
fcntl(file->fd, F_SETLKW, &fl);
}
/* fmemopen */
FILE * fmemopen(void * buffer, size_t size, char const * mode)
{
FILE * file;
int flags;
/* FIXME subsequent file operations untested */
if((flags = _fopen_mode(mode)) == -1)
return NULL;
if((file = _fopen_new(-1, flags, _IONBF)) == NULL)
return NULL;
if(buffer != NULL)
file->buf = buffer;
else
{
if(size == 0)
file->buf = NULL;
else if((file->mbuf = calloc(1, size)) == NULL)
{
fclose(file);
return NULL;
}
else
file->buf = file->mbuf;
}
file->bufsiz = size;
file->len = size;
return file;
}
/* fopen */
FILE * fopen(char const * path, char const * mode)
{
FILE * file;
int flags;
int fd;
if((flags = _fopen_mode(mode)) == -1
|| (fd = open(path, flags, 0777)) < 0)
return NULL;
if((file = _fopen_new(fd, flags, isatty(fd) ? _IONBF : _IOFBF)) == NULL)
{
close(fd);
return NULL;
}
return file;
}
/* fprintf */
int fprintf(FILE * file, char const * format, ...)
{
int ret;
va_list arg;
va_start(arg, format);
ret = vfprintf(file, format, arg);
va_end(arg);
return ret;
}
/* fputc */
int fputc(int c, FILE * file)
{
unsigned char p = c;
if(fwrite(&p, sizeof(char), 1, file) != 1)
return EOF;
return p;
}
/* fputs */
int fputs(char const * str, FILE * file)
{
size_t len;
if((len = strlen(str)) == 0)
return 0;
return fwrite(str, sizeof(char), len, file) == len ? 0 : EOF;
}
/* fread */
size_t fread(void * ptr, size_t size, size_t nb, FILE * file)
{
char * p = (char *)ptr;
size_t i;
size_t j;
size_t len;
ssize_t r;
if(file->dir != FD_READ)
{
if(fflush(file) != 0)
return 0;
else
file->dir = FD_READ;
}
for(i = 0; i < nb; i++)
for(j = 0; j < size; j += len)
{
if(file->pos == file->len)
{
if((r = read(file->fd, file->buf, file->bufsiz))
< 0)
{
file->error = 1;
return i;
}
else if(r == 0)
{
file->eof = 1;
return i;
}
file->pos = 0;
file->len = r;
}
len = min(file->len - file->pos, size - j);
memcpy(p, &file->buf[file->pos], len);
file->pos += len;
p += len;
}
return i;
}
/* freopen */
FILE * freopen(char const * path, char const * mode, FILE * file)
{
int flags;
fflush(file);
if(path == NULL)
{
if((flags = _fopen_mode(mode)) == -1)
{
if(fcntl(file->fd, F_SETFL, flags) == -1)
return NULL;
file->flags = flags;
file->dir = flags & O_WRONLY ? FD_WRITE : FD_READ;
return file;
}
}
close(file->fd);
clearerr(file);
if((flags = _fopen_mode(mode)) == -1
|| (file->fd = open(path, file->flags, 0777)) < 0)
return NULL;
file->flags = flags;
file->dir = flags & O_WRONLY ? FD_WRITE : FD_READ;
file->fbuf = isatty(file->fd) ? _IONBF : _IOFBF;
return file;
}
/* fscanf */
int fscanf(FILE * file, char const * format, ...)
{
int ret;
va_list arg;
va_start(arg, format);
ret = vfscanf(file, format, arg);
va_end(arg);
return ret;
}
/* fseek */
int fseek(FILE * file, long offset, int whence)
{
return fseeko(file, offset, whence);
}
/* fseeko */
int fseeko(FILE * file, off_t offset, int whence)
{
if(whence != SEEK_CUR && whence != SEEK_END && whence != SEEK_SET)
{
errno = EINVAL;
return -1;
}
if(fflush(file) != 0)
return -1;
if(lseek(file->fd, offset, whence) == -1)
return -1;
/* reset the status */
file->eof = (whence == SEEK_END && offset == 0) ? 1 : 0;
file->error = 0;
return 0;
}
/* ftell */
long ftell(FILE * file)
{
long ret;
if((ret = lseek(file->fd, SEEK_CUR, 0)) < 0)
return -1;
/* FIXME not tested */
return ret - file->len + file->pos;
}
/* ftrylock */
int ftrylock(FILE * file)
{
struct flock fl;
fl.l_start = 0;
fl.l_len = 0;
fl.l_pid = 0;
fl.l_type = F_RDLCK | F_WRLCK;
fl.l_whence = SEEK_SET;
return fcntl(file->fd, F_SETLK, &fl);
}
/* funlockfile */
void funlockfile(FILE * file)
{
struct flock fl;
fl.l_start = 0;
fl.l_len = 0;
fl.l_pid = 0;
fl.l_type = F_UNLCK;
fl.l_whence = SEEK_SET;
fcntl(file->fd, F_SETLKW, &fl);
}
/* fwrite */
size_t fwrite(void const * ptr, size_t size, size_t nb, FILE * file)
{
char const * p = (char const *)ptr;
size_t i;
size_t j;
size_t len;
ssize_t w;
size_t x;
if(file->dir != FD_WRITE)
{
if(fflush(file) != 0)
return 0;
file->dir = FD_WRITE;
}
for(i = 0; i < nb; i++)
for(j = 0; j < size; j+=len)
{
len = min(file->bufsiz - file->len, size - j);
memcpy(&file->buf[file->len], p, len);
p += len;
file->len += len;
if(file->len != file->bufsiz) /* buffer is not full */
continue;
x = file->bufsiz - file->pos;
if((w = write(file->fd, &file->buf[file->pos], x)) < 0)
{
file->error = 1;
return i;
}
if((size_t)w != x) /* XXX cast */
file->pos = w; /* buffer is not empty */
else /* buffer is empty */
{
file->pos = 0;
file->len = 0;
}
}
if(file->fbuf == _IOFBF) /* fully buffered */
return nb;
if(file->fbuf == _IOLBF) /* line buffered */
for(j = file->len; j > file->pos; j--)
{
if(file->buf[j - 1] == '\n')
break;
}
else /* unbuffered */
j = file->len;
for(; file->pos < j; file->pos += w) /* empty buffer if necessary */
if((w = write(file->fd, &file->buf[file->pos], j - file->pos))
< 0)
{
file->error = 1;
break; /* XXX should we otherwise report the error? */
}
return nb;
}
/* getc */
int getc(FILE * file)
{
return fgetc(file);
}
/* getc_unlocked */
int getc_unlocked(FILE * file)
{
return getc(file);
}
/* getchar */
int getchar(void)
{
return fgetc(stdin);
}
/* getchar_unlocked */
int getchar_unlocked(void)
{
return getchar();
}
/* pclose */
int pclose(FILE * stream)
{
return fclose(stream);
}
/* perror */
void perror(char const * s)
{
if(s != NULL && *s != '\0')
fprintf(stderr, "%s%s", s, ": ");
/* strerror() never returns NULL */
fputs(strerror(errno), stderr);
fputc('\n', stderr);
}
/* popen */
static void _popen_child(char const * command, int flags, int * fd);
FILE * popen(char const * command, char const * mode)
{
int flags;
pid_t pid;
int fd[2];
if((flags = _fopen_mode(mode)) == -1)
return NULL;
if(pipe(fd) != 0)
return NULL;
if((pid = fork()) == -1)
{
close(fd[0]);
close(fd[1]);
return NULL;
}
if(pid == 0) /* child */
_popen_child(command, flags, fd);
if(flags & O_WRONLY)
close(fd[0]);
else
close(fd[1]);
return _fopen_new(flags & O_WRONLY ? fd[1] : fd[0], flags, _IONBF);
}
static void _popen_child(char const * command, int flags, int * fd)
{
if(flags & O_WRONLY)
{
close(fd[1]);
if(dup2(fd[0], 0) == -1)
exit(127);
}
else
{
close(fd[0]);
if(dup2(fd[1], 1) == -1)
exit(127);
}
execlp("/bin/sh", "sh", "-c", command, NULL);
exit(127);
}
/* printf */
int printf(char const * format, ...)
{
int ret;
va_list arg;
va_start(arg, format);
ret = vfprintf(stdout, format, arg);
va_end(arg);
return ret;
}
/* putc */
int putc(int c, FILE * file)
{
return fputc(c, file);
}
/* putc_unlocked */
int putc_unlocked(int c, FILE * file)
{
return putc(c, file);
}
/* putchar */
int putchar(int c)
{
return fputc(c, stdout);
}
/* putchar_unlocked */
int putchar_unlocked(int c)
{
return putchar(c);
}
/* puts */
int puts(char const * str)
{
size_t i;
if(str == NULL) /* XXX be nice and do not crash */
str = "(null)";
i = strlen(str);
if(fwrite(str, sizeof(char), i, stdout) != i)
return EOF;
fputc('\n', stdout);
return i <= INT_MAX ? i : INT_MAX;
}
/* remove */
int remove(char const * path)
{
if(unlink(path) == 0)
return 0;
if(errno == EISDIR && rmdir(path) == 0)
return 0;
return -1;
}
/* rename */
#ifndef SYS_rename
# warning Unsupported platform: rename() is missing
int rename(char const * from, char const * to)
{
errno = ENOSYS;
return -1;
}
#endif
/* renameat */
#ifndef SYS_renameat
# warning Unsupported platform: renameat() is missing
int renameat(int fromfd, char const * from, int tofd, char const * to)
{
errno = ENOSYS;
return -1;
}
#endif
/* rewind */
void rewind(FILE * file)
{
fseeko(file, 0, SEEK_SET);
}
/* scanf */
int scanf(char const * format, ...)
{
int ret;
va_list arg;
va_start(arg, format);
ret = vfscanf(stdin, format, arg);
va_end(arg);
return ret;
}
/* setbuf */
void setbuf(FILE * file, char * buf)
{
setvbuf(file, buf, (buf != NULL) ? _IOFBF : _IONBF, BUFSIZ);
}
/* setvbuf */
int setvbuf(FILE * file, char * buf, int type, size_t size)
{
if(file->fd < 0 || file->len > 0)
{
errno = EBADF;
return -1;
}
file->buf = (unsigned char *)buf;
file->fbuf = type;
file->bufsiz = size;
return 0;
}
/* snprintf */
int snprintf(char * str, size_t size, char const * format, ...)
{
va_list arg;
int ret;
va_start(arg, format);
ret = vsnprintf(str, size, format, arg);
va_end(arg);
return ret;
}
/* sprintf */
int sprintf(char * str, char const * format, ...)
{
va_list arg;
int ret;
va_start(arg, format);
ret = vsprintf(str, format, arg);
va_end(arg);
return ret;
}
/* sscanf */
int sscanf(char const * str, char const * format, ...)
{
int ret;
va_list arg;
va_start(arg, format);
ret = vsscanf(str, format, arg);
va_end(arg);
return ret;
}
/* tempnam */
char * tempnam(char const * dir, char const * prefix)
{
char const * p;
size_t len;
char * template;
if((p = getenv("TMPDIR")) != NULL)
dir = p;
else if(dir == NULL)
dir = P_tmpdir;
if(dir == NULL)
dir = "/tmp";
if(prefix == NULL)
prefix = "tmp.XXXXXX";
len = strlen(dir) + strlen(prefix) + 2;
if((template = malloc(len)) == NULL)
return NULL;
snprintf(template, len, "%s/%s", dir, prefix);
if(mktemp(template) != NULL)
return template;
free(template);
return NULL;
}
/* tmpfile */
FILE * tmpfile(void)
{
char template[] = P_tmpdir "/tmp.XXXXXX";
int fd;
FILE * file;
if((fd = mkstemp(template)) < 0)
return NULL;
if(unlink(template) != 0
|| (file = fdopen(fd, "w+")) == NULL)
{
close(fd);
return NULL;
}
return file;
}
/* tmpnam */
char * tmpnam(char * str)
{
static char template[] = P_tmpdir "/tmp.XXXXXX";
if(str == NULL)
return mktemp(template);
if(snprintf(str, L_tmpnam, "%s", str) >= L_tmpnam)
return NULL;
return mktemp(str);
}
/* ungetc */
int ungetc(int c, FILE * file)
{
if(c == EOF || c < 0)
{
errno = EINVAL;
return EOF;
}
if(file->len == sizeof(file->buf))
{
errno = ENOBUFS;
return EOF;
}
memmove(&file->buf[file->pos + 1], &file->buf[file->pos], file->len
- file->pos);
file->buf[file->pos] = c; /* XXX c may be silently truncated */
file->len++;
return file->buf[file->pos];
}
/* vfprintf */
static int _fprint(void * dest, size_t size, const char * buf);
int vfprintf(FILE * file, char const * format, va_list arg)
{
return _vprintf(_fprint, file, ~0, format, arg);
}
static int _fprint(void * dest, size_t size, char const buf[])
{
FILE * file = dest;
return (fwrite(buf, sizeof(char), size, file) == size) ? 0 : -1;
}
/* vfscanf */
int vfscanf(FILE * file, char const * format, va_list arg)
{
/* FIXME implement */
errno = ENOSYS;
return -1;
}
/* vprintf */
int vprintf(char const * format, va_list arg)
{
return _vprintf(_fprint, stdout, ~0, format, arg);
}
/* vscanf */
int vscanf(char const * format, va_list arg)
{
return vfscanf(stdin, format, arg);
}
/* vsnprintf */
static int _sprint(void * dest, size_t size, const char * buf);
int vsnprintf(char * str, size_t size, char const * format, va_list arg)
{
int ret;
char * p = str;
size_t i;
if((ret = _vprintf(_sprint, &p, size, format, arg)) < 0)
return ret;
i = ret;
if(i < size)
str[ret] = '\0';
else if(size > 0)
str[size - 1] = '\0';
return ret;
}
static int _sprint(void * dest, size_t size, char const buf[])
{
char ** str = dest;
if(*str == NULL || size == 0)
return 0;
strncpy(*str, buf, size);
*str += size;
return 0;
}
/* vsprintf */
int vsprintf(char * str, char const * format, va_list arg)
{
int ret;
size_t size = (str != NULL) ? -1 : 0;
if((ret = _vprintf(_sprint, &str, size, format, arg)) < 0)
return ret;
if(str != NULL)
str[ret] = '\0';
return ret;
}
/* vsscanf */
int vsscanf(char const * str, char const * format, va_list arg)
{
return _vscanf(NULL, str, format, arg);
}
/* protected */
/* start_stdio */
void __start_stdio(void)
{
if(getenv("PS1") == NULL)
_stdout.flags = _IONBF;
}
/* private */
/* functions */
/* fopen_mode */
/* PRE
* POST
* -1 error
* else corresponding mode */
static int _fopen_mode(char const * mode)
{
int flags;
if(*mode == 'r')
{
flags = O_RDONLY;
if(*(++mode) == 'b')
++mode;
if(*mode == '+' && ++mode)
flags = O_RDWR;
}
else if(*mode == 'w')
{
flags = O_WRONLY | O_CREAT | O_TRUNC;
if(*(++mode) == 'b')
++mode;
if(*mode == '+' && ++mode)
flags = O_RDWR | O_CREAT | O_TRUNC;
}
else if(*mode == 'a')
{
flags = O_WRONLY | O_APPEND | O_CREAT;
if(*(++mode) == 'b')
++mode;
if(*mode == '+' && ++mode)
flags = O_RDWR | O_APPEND | O_CREAT;
}
else
{
errno = EINVAL;
return -1;
}
for(;; mode++)
if(*mode == 'x')
flags |= O_EXCL;
else if(*mode != 'b')
break;
if(*mode != '\0')
{
errno = EINVAL;
return -1;
}
return flags;
}
/* fopen_new */
static FILE * _fopen_new(int fd, int flags, int fbuf)
{
FILE * file;
if(flags == -1)
return NULL;
if((file = malloc(sizeof(*file))) == NULL)
return NULL;
file->flags = flags;
file->buf = file->_buf;
file->mbuf = NULL;
file->bufsiz = sizeof(file->_buf);
file->fd = fd;
file->len = 0;
file->pos = 0;
file->eof = 0;
file->error = 0;
file->dir = (file->flags & O_WRONLY) ? FD_WRITE : FD_READ;
file->fbuf = fbuf;
return file;
}
/* vprintf */
typedef struct _print_args
{
int ret;
int flags;
size_t width;
size_t precision;
int shrt;
print_func func;
void * dest;
size_t * size;
} print_args;
static int _vfprintf_do(print_args * args, char const * buf, size_t len);
static int _vfprintf_do_do(print_args * args, char const * buf, size_t len);
#define FLAGS_HASH 0x01
#define FLAGS_MINUS 0x02
#define FLAGS_PLUS 0x04
#define FLAGS_SPACE 0x08
#define FLAGS_ZERO 0x10
static int _vprintf_flags(char const * p, size_t * i);
static size_t _vprintf_width(char const * p, size_t * i);
static size_t _vprintf_precision(char const * p, size_t * i);
static void _format_lutoa(char * dest, unsigned long n, size_t base, int upper);
static int _format_c(print_args * args, char const * chrp);
static int _format_d(print_args * args, long long * ptr);
static int _format_f(print_args * args, double * ptr);
static int _format_lf(print_args * args, long double * ptr);
static int _format_o(print_args * args, unsigned long long * ptr);
static int _format_s(print_args * args, char const * str);
static int _format_p(print_args * args, void * ptr);
static int _format_u(print_args * args, unsigned long long * ptr);
static int _format_x(print_args * args, unsigned long long * ptr, int upper);
static int _vprintf(print_func func, void * dest, size_t size,
char const * format, va_list arg)
{
print_args args;
char const * p; /* pointer to current format character */
size_t i;
int lng;
int f = 0;
char c;
char const * str;
double e;
long double le;
long long int d;
unsigned long long int u;
void * ptr;
args.ret = 0;
args.func = func;
args.dest = dest;
args.size = &size;
for(p = format; *p != '\0'; p += i)
{
args.flags = 0;
args.width = 0;
args.precision = 0;
args.shrt = 0;
for(i = 0; p[i] != '\0' && p[i] != '%'; i++);
if(i > 0 && _vfprintf_do(&args, p, i) != 0)
return -1;
if(p[i++] != '%')
break;
if(p[i] == '%')
{
if(_vfprintf_do(&args, p++, 1) != 0)
return -1;
continue;
}
args.flags = _vprintf_flags(p, &i);
args.width = _vprintf_width(p, &i);
args.precision = _vprintf_precision(p, &i);
for(lng = 0; p[i] != '\0'; i++)
{
if(p[i] == 'L')
{
if(lng > 0)
{
errno = EINVAL;
return -1;
}
lng = -1;
}
else if(p[i] == 'l')
{
if(lng < 0 || ++lng > 2)
{
errno = EINVAL;
return -1;
}
}
else if(p[i] == 'c')
{
c = va_arg(arg, int);
f = _format_c(&args, &c);
break;
}
else if(p[i] == 'd')
{
if(lng > 1)
d = va_arg(arg, long long int);
else if(lng == 1)
d = va_arg(arg, long int);
else
d = va_arg(arg, int);
f = _format_d(&args, &d);
break;
}
else if(p[i] == 'f')
{
if(lng < 0)
{
le = va_arg(arg, long double);
f = _format_lf(&args, &le);
}
else
{
e = va_arg(arg, double);
f = _format_f(&args, &e);
}
break;
}
else if(p[i] == 'h')
{
if(++args.shrt > 2)
{
errno = EINVAL;
return -1;
}
}
else if(p[i] == 'o')
{
if(lng > 1)
u = va_arg(arg, unsigned long long int);
else if(lng == 1)
u = va_arg(arg, unsigned long int);
else
u = va_arg(arg, unsigned int);
f = _format_o(&args, &u);
break;
}
else if(p[i] == 'p')
{
ptr = va_arg(arg, void *);
f = _format_p(&args, ptr);
break;
}
else if(p[i] == 's')
{
str = va_arg(arg, char const *);
f = _format_s(&args, str);
break;
}
else if(p[i] == 'u')
{
if(lng > 1)
u = va_arg(arg, unsigned long long int);
else if(lng == 1)
u = va_arg(arg, unsigned long int);
else
u = va_arg(arg, unsigned int);
f = _format_u(&args, &u);
break;
}
else if(p[i] == 'x' || p[i] == 'X')
{
if(lng > 1)
u = va_arg(arg, unsigned long long int);
else if(lng == 1)
u = va_arg(arg, unsigned long int);
else
u = va_arg(arg, unsigned int);
f = _format_x(&args, &u, (p[i] == 'X'));
break;
}
else if(p[i] == 'z')
{
if(lng != 0)
{
errno = EINVAL;
return -1;
}
lng = 1;
}
else
{
errno = EINVAL;
return -1;
}
}
if(f != 0)
return -1;
i++;
}
return args.ret;
}
static int _vfprintf_do(print_args * args, char const * buf, size_t len)
{
size_t i;
char padding = ' ';
if(args->flags & FLAGS_MINUS)
{
_vfprintf_do_do(args, buf, len);
for(i = len; i < args->width; i++)
if(_vfprintf_do_do(args, &padding, 1) != 0)
return -1;
return 0;
}
if(args->flags & FLAGS_ZERO)
padding = '0';
for(i = len; i < args->width; i++)
if(_vfprintf_do_do(args, &padding, 1) != 0)
return -1;
return _vfprintf_do_do(args, buf, len);
}
static int _vfprintf_do_do(print_args * args, char const * buf, size_t len)
{
size_t s;
s = min(*(args->size), len);
if(args->func(args->dest, s, buf) != 0)
return -1;
if((size_t)INT_MAX - len < (size_t)(args->ret))
{
errno = ERANGE;
return -1;
}
*(args->size) -= s;
args->ret += len;
return 0;
}
static int _vprintf_flags(char const * p, size_t * i)
{
int flags;
for(flags = 0; p[*i] != '\0'; (*i)++)
{
if(p[*i] == '#')
flags |= FLAGS_HASH;
else if(p[*i] == '-')
flags |= FLAGS_MINUS;
else if(p[*i] == '+')
flags |= FLAGS_PLUS;
else if(p[*i] == ' ')
flags |= FLAGS_SPACE;
else if(p[*i] == '0')
flags |= FLAGS_ZERO;
else
break;
}
return flags;
}
static size_t _vprintf_width(char const * p, size_t * i)
{
size_t width;
for(width = 0; p[*i] != '\0'; (*i)++)
{
if(p[*i] < '0' || p[*i] > '9')
break;
width *= 10;
width += p[*i] - '0';
}
return width;
}
static size_t _vprintf_precision(char const * p, size_t * i)
{
if(p[*i] != '.')
return 0;
(*i)++;
return _vprintf_width(p, i);
}
static int _format_c(print_args * args, char const * chrp)
{
return _vfprintf_do(args, chrp, sizeof(*chrp));
}
static int _format_d(print_args * args, long long * ptr)
{
unsigned long long uval;
char tmp[20] = "-";
if(*ptr >= 0)
return _format_u(args, (unsigned long long *)ptr);
uval = llabs(*ptr);
/* XXX assumes tmp is large enough */
_format_lutoa(&tmp[1], uval, 10, 0);
return _vfprintf_do(args, tmp, strlen(tmp));
}
static int _format_f(print_args * args, double * ptr)
{
/* FIXME really implement */
unsigned long long uval;
if(*ptr >= 0.0)
{
uval = *ptr;
return _format_u(args, &uval);
}
uval = -(*ptr);
if(_vfprintf_do(args, "-", 1) != 0 || _format_u(args, &uval) != 0)
return -1;
return 0;
}
static int _format_lf(print_args * args, long double * ptr)
{
/* FIXME really implement */
unsigned long long uval;
if(*ptr >= 0.0)
{
uval = *ptr;
return _format_u(args, &uval);
}
uval = -(*ptr);
if(_vfprintf_do(args, "-", 1) != 0 || _format_u(args, &uval) != 0)
return -1;
return 0;
}
static int _format_o(print_args * args, unsigned long long * ptr)
{
char tmp[22] = "";
_format_lutoa(tmp, *ptr, 8, 0); /* XXX assumes tmp is large enough */
return _vfprintf_do(args, tmp, strlen(tmp));
}
static int _format_s(print_args * args, char const * str)
{
if(str == NULL) /* XXX be nice and do not crash */
str = "(null)";
return _vfprintf_do(args, str, strlen(str));
}
static int _format_p(print_args * args, void * ptr)
{
char tmp[3 + sizeof(void*) + sizeof(void*)] = "0x";
_format_lutoa(&tmp[2], (long)ptr, 16, 0); /* XXX cast */
return _vfprintf_do(args, tmp, strlen(tmp));
}
static int _format_u(print_args * args, unsigned long long * ptr)
{
char tmp[19] = "";
_format_lutoa(tmp, *ptr, 10, 0); /* XXX assumes tmp is large enough */
return _vfprintf_do(args, tmp, strlen(tmp));
}
static int _format_x(print_args * args, unsigned long long * ptr, int upper)
{
unsigned long u = *ptr;
char tmp[sizeof(long) + sizeof(long) + 1] = "";
if(args->shrt == 1)
u = u & 0xffff;
else if(args->shrt == 2)
u = u & 0xff;
_format_lutoa(tmp, u, 16, upper); /* XXX assumes tmp large enough */
if((args->flags & FLAGS_HASH) == FLAGS_HASH)
if(_vfprintf_do_do(args, "0x", 2) != 0)
return -1;
return _vfprintf_do(args, tmp, strlen(tmp));
}
/* PRE dest is long enough
* POST 2 <= base <= 36 dest is the ascii representation of n
* else dest is an empty string */
static void _format_lutoa(char * dest, unsigned long n, size_t base, int upper)
{
static char const convl[] = "0123456789abcdefghijklmnopqrstuvwxyz";
static char const convu[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
char const * conv = (upper != 0) ? convu : convl;
size_t len = 0;
unsigned long p;
size_t i;
if(base < 2 || base >= sizeof(convl))
{
dest[0] = '\0';
return;
}
if(n == 0)
{
strcpy(dest, "0");
return;
}
/* XXX performing twice the divisions is not optimal */
for(p = n; p > 0; p /= base)
len++;
for(i = len; n > 0; n /= base)
{
p = n % base;
dest[--i] = conv[p];
n -= p;
}
dest[len] = '\0';
}
/* vscanf */
typedef struct _scan_args
{
int ret;
int discard;
int width;
} scan_args;
static size_t _vscanf_do(scan_args * args, char const * string,
char const * format, va_list arg);
static size_t _vscanf_do_bracket(scan_args * args, char const * string,
char const * format, va_list arg);
static size_t _vscanf_do_char(char const * string, char const * format,
va_list arg);
static size_t _vscanf_do_chars(scan_args * args, char const * string,
va_list arg);
static size_t _vscanf_do_double(char const * string, char const * format,
va_list arg);
static size_t _vscanf_do_long(char const * string, char const * format,
va_list arg);
static size_t _vscanf_do_max(char const * string, char const * format,
va_list arg);
static size_t _vscanf_do_short(char const * string, char const * format,
va_list arg);
static size_t _vscanf_do_size(char const * string, char const * format,
va_list arg);
static size_t _vscanf_do_string(scan_args * args, char const * string,
va_list arg);
static int _vscanf(scan_func func, char const * string, char const * format,
va_list arg)
{
scan_args args;
char const * s = string;
char const * f = format;
size_t i;
char * p;
args.ret = 0;
for(i = 0; *f != '\0' && *s != '\0'; f += i)
{
switch(*f)
{
case ' ':
case '\t':
if(!isspace(*s))
break;
/* skip spaces in the format string */
for(i = 1; isspace((unsigned int)f[i]); i++);
/* skip spaces in the original string */
for(; isspace((unsigned int)*s); s++);
break;
case '%':
if((++f)[0] == '*')
{
/* FIXME really implement */
args.discard = 1;
f++;
}
else
args.discard = 0;
/* maximum field width */
if((args.width = strtol(f, &p, 10)) == 0)
args.width = -1;
else
f = p;
if(*f == 'h')
{
if(*(++f) == 'h')
i = _vscanf_do_char(s, ++f,
arg);
else
i = _vscanf_do_short(s, f,
arg);
}
else if(*f == 'j')
i = _vscanf_do_max(s, ++f, arg);
else if(*f == 'L')
i = _vscanf_do_double(s, ++f, arg);
else if(*f == 'l')
i = _vscanf_do_long(s, ++f, arg);
else if(*f == 'z')
i = _vscanf_do_size(s, ++f, arg);
else
i = _vscanf_do(&args, s, f, arg);
if(i == 0)
break;
s += i;
/* FIXME hardcoded */
i = 1;
args.ret++;
break;
default:
i = (*(s++) == f[0]) ? 1 : 0;
break;
}
if(i == 0)
{
args.ret = -1;
break;
}
}
return args.ret;
}
static size_t _vscanf_do(scan_args * args, char const * string,
char const * format, va_list arg)
{
int * d;
float * f;
unsigned int * u;
char * s;
void ** v;
switch(format[0])
{
case 'A':
case 'a':
case 'E':
case 'e':
case 'F':
case 'f':
case 'G':
case 'g':
f = va_arg(arg, float *);
return ((*f = strtof(string, &s)) != 0 && string != s)
? *f : 0;
case 'c':
return _vscanf_do_chars(args, string, arg);
case 'd':
d = va_arg(arg, int *);
*d = strtol(string, &s, 10);
return s - string;
case 'i':
d = va_arg(arg, int *);
*d = strtol(string, &s, 0);
return s - string;
case 'o':
u = va_arg(arg, unsigned int *);
*u = strtol(string, &s, 8);
return s - string;
case 'p':
v = va_arg(arg, void **);
*v = (void *)strtol(string, &s, 16);
return s - string;
case 's':
return _vscanf_do_string(args, string, arg);
case 'u':
u = va_arg(arg, unsigned int *);
*u = strtoul(string, &s, 10);
return s - string;
case 'X':
case 'x':
u = va_arg(arg, unsigned int *);
*u = strtoul(string, &s, 16);
return s - string;
case '[':
return _vscanf_do_bracket(args, string, format, arg);
case '%':
return (*string == '%') ? 1 : 0;
case 'C':
return _vscanf_do_long(string, "c", arg);
case 'S':
return _vscanf_do_long(string, "S", arg);
}
errno = EINVAL;
return 0;
}
static size_t _vscanf_do_bracket(scan_args * args, char const * string,
char const * format, va_list arg)
{
int ret = 1;
int i;
char * s;
if(format[ret] == '^')
/* FIXME really implement */
ret++;
if(format[ret] == ']')
ret++;
/* FIXME really implement */
for(; format[ret] != ']'; ret++);
s = va_arg(arg, char *);
for(i = 0; (args->width <= 0 || i < args->width) && string[i] != '\0';
i++)
s[i] = string[i];
/* FIXME check for any off by one */
s[i] = '\0';
return ret;
}
static size_t _vscanf_do_char(char const * string, char const * format,
va_list arg)
{
char * d;
unsigned char * u;
char * s;
switch(format[0])
{
case 'd':
d = va_arg(arg, char *);
*d = strtol(string, &s, 10);
return s - string;
case 'i':
d = va_arg(arg, char *);
*d = strtol(string, &s, 0);
return s - string;
case 'o':
u = va_arg(arg, unsigned char *);
*u = strtol(string, &s, 8);
return s - string;
case 'u':
u = va_arg(arg, unsigned char *);
*u = strtoul(string, &s, 10);
return s - string;
case 'X':
case 'x':
u = va_arg(arg, unsigned char *);
*u = strtoul(string, &s, 16);
return s - string;
}
errno = EINVAL;
return 0;
}
static size_t _vscanf_do_chars(scan_args * args, char const * string,
va_list arg)
{
size_t ret;
char * s;
size_t width = (args->width > 0) ? args->width : 1;
s = va_arg(arg, char *);
for(ret = 0; ret < width && *string != '\0'; ret++)
*s++ = *string++;
return ret;
}
static size_t _vscanf_do_double(char const * string, char const * format,
va_list arg)
{
long double * f;
char * s;
switch(format[0])
{
case 'A':
case 'a':
case 'E':
case 'e':
case 'F':
case 'f':
case 'G':
case 'g':
f = va_arg(arg, long double *);
return ((*f = strtold(string, &s)) != 0 && string != s)
? *f : 0;
}
errno = EINVAL;
return 0;
}
static size_t _vscanf_do_long(char const * string, char const * format,
va_list arg)
{
long * d;
double * f;
unsigned long * u;
char * s;
switch(format[0])
{
case 'A':
case 'a':
case 'E':
case 'e':
case 'F':
case 'f':
case 'G':
case 'g':
f = va_arg(arg, double *);
return ((*f = strtod(string, &s)) != 0 && string != s)
? *f : 0;
case 'd':
d = va_arg(arg, long *);
*d = strtol(string, &s, 10);
return s - string;
case 'i':
d = va_arg(arg, long *);
*d = strtol(string, &s, 0);
return s - string;
case 'o':
u = va_arg(arg, unsigned long *);
*u = strtol(string, &s, 8);
return s - string;
case 'u':
u = va_arg(arg, unsigned long *);
*u = strtoul(string, &s, 10);
return s - string;
case 'X':
case 'x':
u = va_arg(arg, unsigned long *);
*u = strtoul(string, &s, 16);
return s - string;
case 'c':
case 's':
case '[':
/* FIXME implement */
errno = ENOSYS;
return 0;
}
errno = EINVAL;
return 0;
}
static size_t _vscanf_do_max(char const * string, char const * format,
va_list arg)
{
intmax_t * d;
uintmax_t * u;
char * s;
switch(format[0])
{
case 'd':
d = va_arg(arg, intmax_t *);
*d = strtoll(string, &s, 10);
return s - string;
case 'i':
d = va_arg(arg, intmax_t *);
*d = strtoll(string, &s, 0);
return s - string;
case 'o':
u = va_arg(arg, uintmax_t *);
*u = strtoll(string, &s, 8);
return s - string;
case 'u':
u = va_arg(arg, uintmax_t *);
*u = strtoull(string, &s, 10);
return s - string;
case 'X':
case 'x':
u = va_arg(arg, uintmax_t *);
*u = strtoull(string, &s, 16);
return s - string;
}
errno = EINVAL;
return 0;
}
static size_t _vscanf_do_short(char const * string, char const * format,
va_list arg)
{
short * d;
unsigned short * u;
char * s;
switch(format[0])
{
case 'd':
d = va_arg(arg, short *);
*d = strtol(string, &s, 10);
return s - string;
case 'i':
d = va_arg(arg, short *);
*d = strtol(string, &s, 0);
return s - string;
case 'o':
u = va_arg(arg, unsigned short *);
*u = strtol(string, &s, 8);
return s - string;
case 'u':
u = va_arg(arg, unsigned short *);
*u = strtoul(string, &s, 10);
return s - string;
case 'X':
case 'x':
u = va_arg(arg, unsigned short *);
*u = strtoul(string, &s, 16);
return s - string;
}
errno = EINVAL;
return 0;
}
static size_t _vscanf_do_size(char const * string, char const * format,
va_list arg)
{
ssize_t * d;
size_t * u;
char * s;
switch(format[0])
{
case 'd':
d = va_arg(arg, ssize_t *);
*d = strtoll(string, &s, 10);
return s - string;
case 'i':
d = va_arg(arg, ssize_t *);
*d = strtoll(string, &s, 0);
return s - string;
case 'o':
u = va_arg(arg, size_t *);
*u = strtoll(string, &s, 8);
return s - string;
case 'u':
u = va_arg(arg, size_t *);
*u = strtoull(string, &s, 10);
return s - string;
case 'X':
case 'x':
u = va_arg(arg, size_t *);
*u = strtoull(string, &s, 16);
return s - string;
}
errno = EINVAL;
return 0;
}
static size_t _vscanf_do_string(scan_args * args, char const * string,
va_list arg)
{
int i;
char * s;
s = va_arg(arg, char *);
for(i = 0; (args->width <= 0 || i < args->width)
&& !isspace((unsigned int)string[i])
&& string[i] != '\0'; i++)
s[i] = string[i];
/* FIXME check for any off by one */
s[i] = '\0';
return 1;
}