mirror of
https://github.com/LadybirdBrowser/ladybird.git
synced 2024-11-14 22:31:29 +03:00
620 lines
13 KiB
C++
620 lines
13 KiB
C++
#include <AK/PrintfImplementation.h>
|
|
#include <AK/StdLibExtras.h>
|
|
#include <AK/ValueRestorer.h>
|
|
#include <Kernel/Syscall.h>
|
|
#include <assert.h>
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <stdarg.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <sys/types.h>
|
|
#include <unistd.h>
|
|
|
|
extern "C" {
|
|
|
|
static FILE __default_streams[4];
|
|
FILE* stdin;
|
|
FILE* stdout;
|
|
FILE* stderr;
|
|
FILE* stddbg;
|
|
|
|
void init_FILE(FILE& fp, int fd, int mode)
|
|
{
|
|
fp.fd = fd;
|
|
fp.buffer = fp.default_buffer;
|
|
fp.buffer_size = BUFSIZ;
|
|
fp.mode = mode;
|
|
}
|
|
|
|
static FILE* make_FILE(int fd)
|
|
{
|
|
auto* fp = (FILE*)malloc(sizeof(FILE));
|
|
memset(fp, 0, sizeof(FILE));
|
|
init_FILE(*fp, fd, isatty(fd));
|
|
return fp;
|
|
}
|
|
|
|
void __stdio_init()
|
|
{
|
|
stdin = &__default_streams[0];
|
|
stdout = &__default_streams[1];
|
|
stderr = &__default_streams[2];
|
|
stddbg = &__default_streams[3];
|
|
init_FILE(*stdin, 0, isatty(0) ? _IOLBF : _IOFBF);
|
|
init_FILE(*stdout, 1, isatty(1) ? _IOLBF : _IOFBF);
|
|
init_FILE(*stderr, 2, _IONBF);
|
|
int fd = open("/dev/debuglog", O_WRONLY | O_CLOEXEC);
|
|
if (fd < 0) {
|
|
perror("open /dev/debuglog");
|
|
ASSERT_NOT_REACHED();
|
|
}
|
|
init_FILE(*stddbg, fd, _IOLBF);
|
|
}
|
|
|
|
int setvbuf(FILE* stream, char* buf, int mode, size_t size)
|
|
{
|
|
if (mode != _IONBF && mode != _IOLBF && mode != _IOFBF) {
|
|
errno = EINVAL;
|
|
return -1;
|
|
}
|
|
stream->mode = mode;
|
|
if (buf) {
|
|
stream->buffer = buf;
|
|
stream->buffer_size = size;
|
|
} else {
|
|
stream->buffer = stream->default_buffer;
|
|
stream->buffer_size = BUFSIZ;
|
|
}
|
|
stream->buffer_index = 0;
|
|
return 0;
|
|
}
|
|
|
|
void setbuf(FILE* stream, char* buf)
|
|
{
|
|
setvbuf(stream, buf, buf ? _IOFBF : _IONBF, BUFSIZ);
|
|
}
|
|
|
|
void setlinebuf(FILE* stream)
|
|
{
|
|
setvbuf(stream, nullptr, _IOLBF, 0);
|
|
}
|
|
|
|
int fileno(FILE* stream)
|
|
{
|
|
assert(stream);
|
|
return stream->fd;
|
|
}
|
|
|
|
int feof(FILE* stream)
|
|
{
|
|
assert(stream);
|
|
return stream->eof;
|
|
}
|
|
|
|
int fflush(FILE* stream)
|
|
{
|
|
// FIXME: fflush(NULL) should flush all open output streams.
|
|
ASSERT(stream);
|
|
if (!stream->buffer_index)
|
|
return 0;
|
|
int rc = write(stream->fd, stream->buffer, stream->buffer_index);
|
|
stream->buffer_index = 0;
|
|
stream->error = 0;
|
|
stream->eof = 0;
|
|
if (rc < 0) {
|
|
stream->error = errno;
|
|
return EOF;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
char* fgets(char* buffer, int size, FILE* stream)
|
|
{
|
|
assert(stream);
|
|
ssize_t nread = 0;
|
|
for (;;) {
|
|
if (nread >= size)
|
|
break;
|
|
int ch = fgetc(stream);
|
|
if (ch == EOF) {
|
|
if (nread == 0)
|
|
return nullptr;
|
|
break;
|
|
}
|
|
buffer[nread++] = ch;
|
|
if (!ch || ch == '\n')
|
|
break;
|
|
}
|
|
if (nread < size)
|
|
buffer[nread] = '\0';
|
|
return buffer;
|
|
}
|
|
|
|
int fgetc(FILE* stream)
|
|
{
|
|
assert(stream);
|
|
char ch;
|
|
size_t nread = fread(&ch, sizeof(char), 1, stream);
|
|
if (nread <= 0) {
|
|
stream->eof = nread == 0;
|
|
stream->error = errno;
|
|
return EOF;
|
|
}
|
|
return ch;
|
|
}
|
|
|
|
int getc(FILE* stream)
|
|
{
|
|
return fgetc(stream);
|
|
}
|
|
|
|
int getchar()
|
|
{
|
|
return getc(stdin);
|
|
}
|
|
|
|
ssize_t getdelim(char **lineptr, size_t *n, int delim, FILE *stream)
|
|
{
|
|
char *ptr, *eptr;
|
|
if (*lineptr == nullptr || *n == 0) {
|
|
*n = BUFSIZ;
|
|
if ((*lineptr = static_cast<char*>(malloc(*n))) == nullptr) {
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
for (ptr = *lineptr, eptr = *lineptr + *n;;) {
|
|
int c = fgetc(stream);
|
|
if (c == -1) {
|
|
if (feof(stream)) {
|
|
return ptr == *lineptr ? -1 : ptr - *lineptr;
|
|
} else {
|
|
return -1;
|
|
}
|
|
}
|
|
*ptr++ = c;
|
|
if (c == delim) {
|
|
*ptr = '\0';
|
|
return ptr - *lineptr;
|
|
}
|
|
if (ptr + 2 >= eptr) {
|
|
char *nbuf;
|
|
size_t nbuf_sz = *n * 2;
|
|
ssize_t d = ptr - *lineptr;
|
|
if ((nbuf = static_cast<char*>(realloc(*lineptr, nbuf_sz))) == nullptr) {
|
|
return -1;
|
|
}
|
|
*lineptr = nbuf;
|
|
*n = nbuf_sz;
|
|
eptr = nbuf + nbuf_sz;
|
|
ptr = nbuf + d;
|
|
}
|
|
}
|
|
}
|
|
|
|
ssize_t getline(char **lineptr, size_t *n, FILE *stream)
|
|
{
|
|
return getdelim(lineptr, n, '\n', stream);
|
|
}
|
|
|
|
int ungetc(int c, FILE* stream)
|
|
{
|
|
ASSERT(stream);
|
|
if (stream->have_ungotten)
|
|
return EOF;
|
|
stream->have_ungotten = true;
|
|
stream->ungotten = c;
|
|
stream->eof = false;
|
|
return c;
|
|
}
|
|
|
|
int fputc(int ch, FILE* stream)
|
|
{
|
|
assert(stream);
|
|
assert(stream->buffer_index < stream->buffer_size);
|
|
stream->buffer[stream->buffer_index++] = ch;
|
|
if (stream->buffer_index >= stream->buffer_size)
|
|
fflush(stream);
|
|
else if (stream->mode == _IONBF || (stream->mode == _IOLBF && ch == '\n'))
|
|
fflush(stream);
|
|
if (stream->eof || stream->error)
|
|
return EOF;
|
|
return (byte)ch;
|
|
}
|
|
|
|
int putc(int ch, FILE* stream)
|
|
{
|
|
return fputc(ch, stream);
|
|
}
|
|
|
|
int putchar(int ch)
|
|
{
|
|
return putc(ch, stdout);
|
|
}
|
|
|
|
int fputs(const char* s, FILE* stream)
|
|
{
|
|
for (; *s; ++s) {
|
|
int rc = putc(*s, stream);
|
|
if (rc == EOF)
|
|
return EOF;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int puts(const char* s)
|
|
{
|
|
int rc = fputs(s, stdout);
|
|
if (rc == EOF)
|
|
return EOF;
|
|
return fputc('\n', stdout);
|
|
}
|
|
|
|
void clearerr(FILE* stream)
|
|
{
|
|
assert(stream);
|
|
stream->eof = false;
|
|
stream->error = 0;
|
|
}
|
|
|
|
int ferror(FILE* stream)
|
|
{
|
|
return stream->error;
|
|
}
|
|
|
|
size_t fread(void* ptr, size_t size, size_t nmemb, FILE* stream)
|
|
{
|
|
assert(stream);
|
|
if (!size)
|
|
return 0;
|
|
|
|
ssize_t nread = 0;
|
|
|
|
if (stream->have_ungotten) {
|
|
// FIXME: Support ungotten character even if size != 1.
|
|
ASSERT(size == 1);
|
|
((char*)ptr)[0] = stream->ungotten;
|
|
stream->have_ungotten = false;
|
|
--nmemb;
|
|
if (!nmemb)
|
|
return 1;
|
|
ptr = &((char*)ptr)[1];
|
|
++nread;
|
|
}
|
|
|
|
ssize_t rc = read(stream->fd, ptr, nmemb * size);
|
|
if (rc < 0) {
|
|
stream->error = errno;
|
|
return 0;
|
|
}
|
|
if (rc == 0)
|
|
stream->eof = true;
|
|
nread += rc;
|
|
return nread / size;
|
|
}
|
|
|
|
size_t fwrite(const void* ptr, size_t size, size_t nmemb, FILE* stream)
|
|
{
|
|
assert(stream);
|
|
auto* bytes = (const byte*)ptr;
|
|
ssize_t nwritten = 0;
|
|
for (size_t i = 0; i < (size * nmemb); ++i) {
|
|
int rc = fputc(bytes[i], stream);
|
|
if (rc == EOF)
|
|
break;
|
|
++nwritten;
|
|
}
|
|
return nwritten / size;
|
|
}
|
|
|
|
int fseek(FILE* stream, long offset, int whence)
|
|
{
|
|
assert(stream);
|
|
fflush(stream);
|
|
off_t off = lseek(stream->fd, offset, whence);
|
|
if (off < 0)
|
|
return off;
|
|
stream->eof = false;
|
|
stream->error = 0;
|
|
stream->have_ungotten = false;
|
|
stream->ungotten = 0;
|
|
return 0;
|
|
}
|
|
|
|
long ftell(FILE* stream)
|
|
{
|
|
assert(stream);
|
|
fflush(stream);
|
|
return lseek(stream->fd, 0, SEEK_CUR);
|
|
}
|
|
|
|
void rewind(FILE* stream)
|
|
{
|
|
fseek(stream, 0, SEEK_SET);
|
|
}
|
|
|
|
int dbgprintf(const char* fmt, ...)
|
|
{
|
|
// if this fails, you're printing too early.
|
|
ASSERT(stddbg);
|
|
int errno_backup = errno;
|
|
va_list ap;
|
|
va_start(ap, fmt);
|
|
int ret = vfprintf(stddbg, fmt, ap);
|
|
va_end(ap);
|
|
errno = errno_backup;
|
|
return ret;
|
|
}
|
|
|
|
static void stdout_putch(char*&, char ch)
|
|
{
|
|
putchar(ch);
|
|
}
|
|
|
|
static FILE* __current_stream = nullptr;
|
|
static void stream_putch(char*&, char ch)
|
|
{
|
|
fputc(ch, __current_stream);
|
|
}
|
|
|
|
int vfprintf(FILE* stream, const char* fmt, va_list ap)
|
|
{
|
|
__current_stream = stream;
|
|
return printf_internal(stream_putch, nullptr, fmt, ap);
|
|
}
|
|
|
|
int fprintf(FILE* stream, const char* fmt, ...)
|
|
{
|
|
va_list ap;
|
|
va_start(ap, fmt);
|
|
int ret = vfprintf(stream, fmt, ap);
|
|
va_end(ap);
|
|
return ret;
|
|
}
|
|
|
|
int vprintf(const char* fmt, va_list ap)
|
|
{
|
|
return printf_internal(stdout_putch, nullptr, fmt, ap);
|
|
}
|
|
|
|
int printf(const char* fmt, ...)
|
|
{
|
|
va_list ap;
|
|
va_start(ap, fmt);
|
|
int ret = vprintf(fmt, ap);
|
|
va_end(ap);
|
|
return ret;
|
|
}
|
|
|
|
static void buffer_putch(char*& bufptr, char ch)
|
|
{
|
|
*bufptr++ = ch;
|
|
}
|
|
|
|
int vsprintf(char* buffer, const char* fmt, va_list ap)
|
|
{
|
|
int ret = printf_internal(buffer_putch, buffer, fmt, ap);
|
|
buffer[ret] = '\0';
|
|
return ret;
|
|
}
|
|
|
|
int sprintf(char* buffer, const char* fmt, ...)
|
|
{
|
|
va_list ap;
|
|
va_start(ap, fmt);
|
|
int ret = vsprintf(buffer, fmt, ap);
|
|
buffer[ret] = '\0';
|
|
va_end(ap);
|
|
return ret;
|
|
}
|
|
|
|
static size_t __vsnprintf_space_remaining;
|
|
static void sized_buffer_putch(char*& bufptr, char ch)
|
|
{
|
|
if (__vsnprintf_space_remaining) {
|
|
*bufptr++ = ch;
|
|
--__vsnprintf_space_remaining;
|
|
}
|
|
}
|
|
|
|
int vsnprintf(char* buffer, size_t size, const char* fmt, va_list ap)
|
|
{
|
|
__vsnprintf_space_remaining = size;
|
|
int ret = printf_internal(sized_buffer_putch, buffer, fmt, ap);
|
|
buffer[ret] = '\0';
|
|
return ret;
|
|
}
|
|
|
|
int snprintf(char* buffer, size_t size, const char* fmt, ...)
|
|
{
|
|
va_list ap;
|
|
va_start(ap, fmt);
|
|
int ret = vsnprintf(buffer, size, fmt, ap);
|
|
buffer[ret] = '\0';
|
|
va_end(ap);
|
|
return ret;
|
|
}
|
|
|
|
void perror(const char* s)
|
|
{
|
|
fprintf(stderr, "%s: %s\n", s, strerror(errno));
|
|
}
|
|
|
|
FILE* fopen(const char* pathname, const char* mode)
|
|
{
|
|
int flags = 0;
|
|
if (!strcmp(mode, "r") || !strcmp(mode, "rb"))
|
|
flags = O_RDONLY;
|
|
else if (!strcmp(mode, "r+") || !strcmp(mode, "rb+"))
|
|
flags = O_RDWR;
|
|
else if (!strcmp(mode, "w") || !strcmp(mode, "wb"))
|
|
flags = O_WRONLY | O_CREAT | O_TRUNC;
|
|
else if (!strcmp(mode, "w+") || !strcmp(mode, "wb+"))
|
|
flags = O_RDWR | O_CREAT | O_TRUNC;
|
|
else {
|
|
fprintf(stderr, "FIXME(LibC): fopen('%s', '%s')\n", pathname, mode);
|
|
ASSERT_NOT_REACHED();
|
|
}
|
|
int fd = open(pathname, flags, 0666);
|
|
if (fd < 0)
|
|
return nullptr;
|
|
return make_FILE(fd);
|
|
}
|
|
|
|
FILE* freopen(const char* pathname, const char* mode, FILE* stream)
|
|
{
|
|
(void)pathname;
|
|
(void)mode;
|
|
(void)stream;
|
|
ASSERT_NOT_REACHED();
|
|
}
|
|
|
|
FILE* fdopen(int fd, const char* mode)
|
|
{
|
|
UNUSED_PARAM(mode);
|
|
// FIXME: Verify that the mode matches how fd is already open.
|
|
if (fd < 0)
|
|
return nullptr;
|
|
return make_FILE(fd);
|
|
}
|
|
|
|
int fclose(FILE* stream)
|
|
{
|
|
fflush(stream);
|
|
int rc = close(stream->fd);
|
|
if (stream != &__default_streams[0] && stream != &__default_streams[1] && stream != &__default_streams[2] && stream != &__default_streams[3])
|
|
free(stream);
|
|
return rc;
|
|
}
|
|
|
|
int rename(const char* oldpath, const char* newpath)
|
|
{
|
|
int rc = syscall(SC_rename, oldpath, newpath);
|
|
__RETURN_WITH_ERRNO(rc, rc, -1);
|
|
}
|
|
|
|
char* tmpnam(char*)
|
|
{
|
|
ASSERT_NOT_REACHED();
|
|
}
|
|
|
|
FILE* popen(const char* command, const char* type)
|
|
{
|
|
if (!type || (*type != 'r' && *type != 'w')) {
|
|
errno = EINVAL;
|
|
return nullptr;
|
|
}
|
|
|
|
int pipe_fds[2];
|
|
|
|
int rc = pipe(pipe_fds);
|
|
if (rc < 0) {
|
|
ValueRestorer restorer(errno);
|
|
perror("pipe");
|
|
return nullptr;
|
|
}
|
|
|
|
pid_t child_pid = fork();
|
|
if (!child_pid) {
|
|
if (*type == 'r') {
|
|
int rc = dup2(pipe_fds[1], STDOUT_FILENO);
|
|
if (rc < 0) {
|
|
perror("dup2");
|
|
exit(1);
|
|
}
|
|
close(pipe_fds[0]);
|
|
close(pipe_fds[1]);
|
|
} else if (*type == 'w') {
|
|
int rc = dup2(pipe_fds[0], STDIN_FILENO);
|
|
if (rc < 0) {
|
|
perror("dup2");
|
|
exit(1);
|
|
}
|
|
close(pipe_fds[0]);
|
|
close(pipe_fds[1]);
|
|
}
|
|
|
|
int rc = execl("/bin/sh", "sh", "-c", command, nullptr);
|
|
if (rc < 0)
|
|
perror("execl");
|
|
exit(1);
|
|
}
|
|
|
|
FILE* fp = nullptr;
|
|
if (*type == 'r') {
|
|
fp = make_FILE(pipe_fds[0]);
|
|
close(pipe_fds[1]);
|
|
} else if (*type == 'w') {
|
|
fp = make_FILE(pipe_fds[1]);
|
|
close(pipe_fds[0]);
|
|
}
|
|
|
|
fp->popen_child = child_pid;
|
|
return fp;
|
|
}
|
|
|
|
int pclose(FILE* fp)
|
|
{
|
|
ASSERT(fp);
|
|
ASSERT(fp->popen_child != 0);
|
|
|
|
int wstatus = 0;
|
|
int rc = waitpid(fp->popen_child, &wstatus, 0);
|
|
if (rc < 0)
|
|
return rc;
|
|
|
|
return wstatus;
|
|
}
|
|
|
|
int remove(const char* pathname)
|
|
{
|
|
int rc = unlink(pathname);
|
|
if (rc < 0 && errno != EISDIR)
|
|
return -1;
|
|
return rmdir(pathname);
|
|
}
|
|
|
|
int scanf(const char* fmt, ...)
|
|
{
|
|
va_list ap;
|
|
va_start(ap, fmt);
|
|
int count = vfscanf(stdin, fmt, ap);
|
|
va_end(ap);
|
|
return count;
|
|
}
|
|
|
|
int fscanf(FILE* stream, const char* fmt, ...)
|
|
{
|
|
va_list ap;
|
|
va_start(ap, fmt);
|
|
int count = vfscanf(stream, fmt, ap);
|
|
va_end(ap);
|
|
return count;
|
|
}
|
|
|
|
int sscanf(const char* buffer, const char* fmt, ...)
|
|
{
|
|
va_list ap;
|
|
va_start(ap, fmt);
|
|
int count = vsscanf(buffer, fmt, ap);
|
|
va_end(ap);
|
|
return count;
|
|
}
|
|
|
|
int vfscanf(FILE* stream, const char* fmt, va_list ap)
|
|
{
|
|
char buffer[BUFSIZ];
|
|
if (!fgets(buffer, sizeof(buffer) - 1, stream))
|
|
return -1;
|
|
return vsscanf(buffer, fmt, ap);
|
|
}
|
|
|
|
FILE* tmpfile()
|
|
{
|
|
dbgprintf("FIXME: Implement tmpfile()\n");
|
|
ASSERT_NOT_REACHED();
|
|
}
|
|
}
|