264 lines
8.0 KiB
C
264 lines
8.0 KiB
C
|
//----------------------------------------------------------------------------//
|
||
|
|
// GNU GPL OS/K //
|
||
|
|
// //
|
||
|
|
// Desc: Buffer library //
|
||
|
|
// //
|
||
|
|
// //
|
||
|
|
// Copyright © 2018-2019 The OS/K Team //
|
||
|
|
// //
|
||
|
|
// This file is part of OS/K. //
|
||
|
|
// //
|
||
|
|
// OS/K is free software: you can redistribute it and/or modify //
|
||
|
|
// it under the terms of the GNU General Public License as published by //
|
||
|
|
// the Free Software Foundation, either version 3 of the License, or //
|
||
|
|
// any later version. //
|
||
|
|
// //
|
||
|
|
// OS/K is distributed in the hope that it will be useful, //
|
||
|
|
// but WITHOUT ANY WARRANTY//without even the implied warranty of //
|
||
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the //
|
||
|
|
// GNU General Public License for more details. //
|
||
|
|
// //
|
||
|
|
// You should have received a copy of the GNU General Public License //
|
||
|
|
// along with OS/K. If not, see <https://www.gnu.org/licenses/>. //
|
||
|
|
//----------------------------------------------------------------------------//
|
||
|
|
|
||
|
|
#include <kernel/buf.h>
|
||
|
|
#include <extras/malloc.h>
|
||
|
|
|
||
|
|
// Straightforward functions
|
||
|
|
int BGetFlags(Buffer_t *buf) { return buf->flags; }
|
||
|
|
int BGetState(Buffer_t *buf) { return buf->state; }
|
||
|
|
int BGetLineLen(Buffer_t *buf) { return buf->lineLen; }
|
||
|
|
void BSetLineLen(Buffer_t *buf, int len) { buf->lineLen = len; }
|
||
|
|
|
||
|
|
void BLockBuf(Buffer_t *buf)
|
||
|
|
{
|
||
|
|
assert(buf && buf->initDone == INITOK);
|
||
|
|
ExAcquireLock(&buf->lock);
|
||
|
|
}
|
||
|
|
|
||
|
|
void BUnlockBuf(Buffer_t *buf) { ExReleaseLock(&buf->lock); }
|
||
|
|
bool BTrylockBuf(Buffer_t *buf) { return ExAttemptLock(&buf->lock); }
|
||
|
|
|
||
|
|
void BFlushOnClose(Buffer_t *buf) { buf->flags |= BF_FONCLOSE; }
|
||
|
|
|
||
|
|
//
|
||
|
|
// Closes a buffer, not flushing unless the proper flag is set
|
||
|
|
//
|
||
|
|
error_t BCloseBuf(Buffer_t *buf)
|
||
|
|
{
|
||
|
|
if (!buf) return EINVAL;
|
||
|
|
|
||
|
|
assert(buf->initDone == INITOK);
|
||
|
|
ExAcquireLock(&buf->lock);
|
||
|
|
|
||
|
|
if (buf->flags & BF_FONCLOSE) {
|
||
|
|
BFlushBuf(buf);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (buf->flags & BF_ALLOC) {
|
||
|
|
free(buf->buf);
|
||
|
|
}
|
||
|
|
|
||
|
|
buf->buf = buf->rp = buf->wp = NULL;
|
||
|
|
buf->initDone = buf->flags = buf->state = buf->size = 0;
|
||
|
|
|
||
|
|
ExReleaseLock(&buf->lock);
|
||
|
|
KalFreeMemory(buf);
|
||
|
|
|
||
|
|
return EOK;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Opens a pure text buffer (for WRITING only)
|
||
|
|
// If source==NULL, malloc's the internal buffer
|
||
|
|
//
|
||
|
|
#if 0
|
||
|
|
Buffer_t *BOpenPureBuf(char *source, size_t size)
|
||
|
|
{
|
||
|
|
/*Buffer_t *buf = malloc(sizeof *buf);
|
||
|
|
buf->flags = 0;
|
||
|
|
ExInitLock(&buf->lock);*/
|
||
|
|
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
extern BFlusher_t _VGA_BFlusher;
|
||
|
|
|
||
|
|
//
|
||
|
|
// Creates a lined buffer of (nLines + pbCount*nLines) lines each
|
||
|
|
// of lineLen length (pb = playback buffer, for scrolling up)
|
||
|
|
//
|
||
|
|
Buffer_t *BOpenLineBuf(char *source, int mode,
|
||
|
|
int lineLen, int nLines, int pbCount, BFlusher_t flusher)
|
||
|
|
{
|
||
|
|
assert(lineLen > 0 && nLines > 0 && pbCount >= 0);
|
||
|
|
assert(mode == BS_RDWR || mode == BS_RDONLY || mode == BS_WRONLY);
|
||
|
|
|
||
|
|
Buffer_t *buf = malloc(sizeof *buf);
|
||
|
|
|
||
|
|
ExInitLock(&buf->lock, KLOCK_MUTEX);
|
||
|
|
ExAcquireLock(&buf->lock);
|
||
|
|
|
||
|
|
buf->lastLF = 0;
|
||
|
|
buf->state = mode;
|
||
|
|
buf->flags = BF_LINE;
|
||
|
|
buf->nLines = nLines;
|
||
|
|
buf->lineLen = lineLen;
|
||
|
|
buf->size = lineLen * nLines * (pbCount + 1);
|
||
|
|
|
||
|
|
if (source == NULL) {
|
||
|
|
buf->buf = malloc(buf->size);
|
||
|
|
} else {
|
||
|
|
buf->buf = source;
|
||
|
|
}
|
||
|
|
|
||
|
|
buf->wp = buf->rp = buf->buf;
|
||
|
|
buf->flusher = flusher;
|
||
|
|
buf->initDone = INITOK;
|
||
|
|
|
||
|
|
ExReleaseLock(&buf->lock);
|
||
|
|
return buf;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Flushes a buffer, returns EBADF when not possible
|
||
|
|
//
|
||
|
|
error_t BFlushBuf(Buffer_t *buf)
|
||
|
|
{
|
||
|
|
error_t rc;
|
||
|
|
|
||
|
|
assert(buf && buf->initDone == INITOK);
|
||
|
|
|
||
|
|
if (!buf) return EINVAL;
|
||
|
|
if (!buf->flusher || buf->state == BS_EOF || buf->state == BS_ERR) {
|
||
|
|
return EBADF;
|
||
|
|
}
|
||
|
|
|
||
|
|
ExAcquireLock(&buf->lock);
|
||
|
|
rc = buf->flusher(buf);
|
||
|
|
ExReleaseLock(&buf->lock);
|
||
|
|
|
||
|
|
return rc;
|
||
|
|
}
|
||
|
|
|
||
|
|
static error_t bputc(Buffer_t *buf, uchar ch);
|
||
|
|
|
||
|
|
//
|
||
|
|
// Writes a character on a buffer
|
||
|
|
//
|
||
|
|
error_t BPutOnBuf(Buffer_t *buf, uchar ch)
|
||
|
|
{
|
||
|
|
error_t rc;
|
||
|
|
assert(buf && buf->initDone == INITOK);
|
||
|
|
|
||
|
|
if (!buf) return EINVAL;
|
||
|
|
if (buf->state != BS_RDWR && buf->state != BS_WRONLY) {
|
||
|
|
return EBADF;
|
||
|
|
}
|
||
|
|
|
||
|
|
ExAcquireLock(&buf->lock);
|
||
|
|
rc = bputc(buf, ch);
|
||
|
|
ExReleaseLock(&buf->lock);
|
||
|
|
return rc;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Internal, unlocked version of BPutOnBuf
|
||
|
|
//
|
||
|
|
static error_t bputc(Buffer_t *buf, uchar ch)
|
||
|
|
{
|
||
|
|
error_t rc;
|
||
|
|
size_t bufSize, pbCount;
|
||
|
|
|
||
|
|
// Implements playback / scrolling up when line buffering
|
||
|
|
// Note that '\n', '\r' and '\t' can never occur in the buffer
|
||
|
|
// That should change; there should be a flag for it
|
||
|
|
if (buf->flags & BF_LINE) {
|
||
|
|
|
||
|
|
// Deal with carriage returns
|
||
|
|
if (ch == '\r') {
|
||
|
|
buf->wp -= buf->lastLF;
|
||
|
|
buf->lastLF = 0;
|
||
|
|
assert(buf->wp >= buf->buf);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Deal with tabs... we need a tabSize field
|
||
|
|
// We assume tabs are 4 characters long for now
|
||
|
|
else if (ch == '\t') {
|
||
|
|
rc = bputc(buf, ' ');
|
||
|
|
if (rc > 0) return rc;
|
||
|
|
|
||
|
|
while (buf->lastLF % 4 > 0) {
|
||
|
|
rc = bputc(buf, ' ');
|
||
|
|
if (rc > 0) return rc;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Deal with line feeds by filling the rest of the line with spaces
|
||
|
|
// We need a field for choosing a different filler, e.g. '\0'
|
||
|
|
else if (ch == '\n') {
|
||
|
|
assert(buf->lastLF < buf->lineLen);
|
||
|
|
while (buf->lastLF > 0) {
|
||
|
|
rc = bputc(buf, ' ');
|
||
|
|
if (rc > 0) return rc;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Just a regular character
|
||
|
|
else {
|
||
|
|
// Do we have to scroll up?
|
||
|
|
if (buf->wp == buf->buf + buf->size) {
|
||
|
|
// Yes, so we give up a whole playback buffer worth
|
||
|
|
// of lines so we don't have to do this too often
|
||
|
|
// (basically we make the current buffer a pb one)
|
||
|
|
bufSize = buf->nLines * buf->lineLen;
|
||
|
|
pbCount = (buf->size / bufSize) - 1;
|
||
|
|
|
||
|
|
// Paranoia check
|
||
|
|
assert(buf->size >= (size_t)(buf->nLines * buf->lineLen));
|
||
|
|
|
||
|
|
// If we only have one playback buffer we just give up a line
|
||
|
|
if (pbCount == 0) {
|
||
|
|
// Use of memcpy() is safe because the source occur
|
||
|
|
// after the destination
|
||
|
|
memcpy(buf->buf, buf->buf + buf->lineLen,
|
||
|
|
buf->size - buf->lineLen);
|
||
|
|
buf->wp -= buf->lineLen;
|
||
|
|
}
|
||
|
|
|
||
|
|
// We do have a playback buffer worth of lines to give up
|
||
|
|
else {
|
||
|
|
memcpy(buf->buf, buf->buf + bufSize,
|
||
|
|
buf->size - bufSize);
|
||
|
|
buf->wp -= buf->lineLen;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Write the damn thing
|
||
|
|
*buf->wp++ = (char)ch;
|
||
|
|
|
||
|
|
// Did we reach the end of line?
|
||
|
|
if (++buf->lastLF == buf->lineLen) {
|
||
|
|
buf->lastLF = 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return EOK;
|
||
|
|
}
|
||
|
|
|
||
|
|
// No scrolling up when not line-buffering
|
||
|
|
else {
|
||
|
|
if (buf->wp == buf->buf + buf->size) {
|
||
|
|
buf->state = BS_EOF;
|
||
|
|
}
|
||
|
|
|
||
|
|
return ENOSYS;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
error_t BPrintOnBuf(Buffer_t *buf, size_t n, const char *fmt, ...);
|
||
|
|
error_t BPrintOnBufV(Buffer_t *buf, size_t n, const char *fmt, va_list ap);
|
||
|
|
|