mirror of
https://github.com/RGBCube/serenity
synced 2025-07-25 16:57:35 +00:00
Libraries: Create top level directory for libraries.
Things were getting a little crowded in the project root, so this patch moves the Lib*/ directories into Libraries/.
This commit is contained in:
parent
63814ffebf
commit
04b9dc2d30
328 changed files with 36 additions and 36 deletions
619
Libraries/LibC/stdio.cpp
Normal file
619
Libraries/LibC/stdio.cpp
Normal file
|
@ -0,0 +1,619 @@
|
|||
#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 (u8)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 u8*)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();
|
||||
}
|
||||
}
|
Loading…
Add table
Add a link
Reference in a new issue