src/file.c

/*
 * *****************************************************************************
 *
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2018-2021 Gavin D. Howard and contributors.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * * Redistributions of source code must retain the above copyright notice, this
 *   list of conditions and the following disclaimer.
 *
 * * 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.
 *
 * *****************************************************************************
 *
 * Code for implementing buffered I/O on my own terms.
 *
 */

#include <assert.h>
#include <errno.h>
#include <string.h>

#ifndef _WIN32
#include <unistd.h>
#endif // _WIN32

#include <file.h>
#include <vm.h>

/**
 * Translates an integer into a string.
 * @param val  The value to translate.
 * @param buf  The return parameter.
 */
static void bc_file_ultoa(unsigned long long val, char buf[BC_FILE_ULL_LENGTH])
{
	char buf2[BC_FILE_ULL_LENGTH];
	size_t i, len;

	// We need to make sure the entire thing is zeroed.
	memset(buf2, 0, BC_FILE_ULL_LENGTH);

	// The i = 1 is to ensure that there is a null byte at the end.
	for (i = 1; val; ++i) {

		unsigned long long mod = val % 10;

		buf2[i] = ((char) mod) + '0';
		val /= 10;
	}

	len = i;

	// Since buf2 is reversed, reverse it into buf.
	for (i = 0; i < len; ++i) buf[i] = buf2[len - i - 1];
}

/**
 * Output to the file directly.
 * @param fd   The file descriptor.
 * @param buf  The buffer of data to output.
 * @param n    The number of bytes to output.
 * @return     A status indicating error or success. We could have a fatal I/O
 *             error or EOF.
 */
static BcStatus bc_file_output(int fd, const char *buf, size_t n) {

	size_t bytes = 0;
	sig_atomic_t lock;

	BC_SIG_TRYLOCK(lock);

	// While the number of bytes written is less than intended...
	while (bytes < n) {

		// Write.
		ssize_t written = write(fd, buf + bytes, n - bytes);

		// Check for error and return, if any.
		if (BC_ERR(written == -1))
			return errno == EPIPE ? BC_STATUS_EOF : BC_STATUS_ERROR_FATAL;

		bytes += (size_t) written;
	}

	BC_SIG_TRYUNLOCK(lock);

	return BC_STATUS_SUCCESS;
}

BcStatus bc_file_flushErr(BcFile *restrict f, BcFlushType type)
{
	BcStatus s;

	// If there is stuff to output...
	if (f->len) {

#if BC_ENABLE_HISTORY

		// If history is enabled...
		if (BC_TTY) {

			// If we have been told to save the extras, and there *are*
			// extras...
			if (f->buf[f->len - 1] != '\n' &&
			    (type == BC_FLUSH_SAVE_EXTRAS_CLEAR ||
			     type == BC_FLUSH_SAVE_EXTRAS_NO_CLEAR))
			{
				size_t i;

				// Look for the last newline.
				for (i = f->len - 2; i < f->len && f->buf[i] != '\n'; --i);

				i += 1;

				// Save the extras.
				bc_vec_string(&vm.history.extras, f->len - i, f->buf + i);
			}
			// Else clear the extras if told to.
			else if (type >= BC_FLUSH_NO_EXTRAS_CLEAR) {
				bc_vec_popAll(&vm.history.extras);
			}
		}
#endif // BC_ENABLE_HISTORY

		// Actually output.
		s = bc_file_output(f->fd, f->buf, f->len);
		f->len = 0;
	}
	else s = BC_STATUS_SUCCESS;

	return s;
}

void bc_file_flush(BcFile *restrict f, BcFlushType type) {

	BcStatus s = bc_file_flushErr(f, type);

	// If we have an error...
	if (BC_ERR(s)) {

		// For EOF, set it and jump.
		if (s == BC_STATUS_EOF) {
			vm.status = (sig_atomic_t) s;
			BC_JMP;
		}
		// Blow up on fatal error. Okay, not blow up, just quit.
		else bc_vm_fatalError(BC_ERR_FATAL_IO_ERR);
	}
}

void bc_file_write(BcFile *restrict f, BcFlushType type,
                   const char *buf, size_t n)
{
	// If we have enough to flush, do it.
	if (n > f->cap - f->len) {
		bc_file_flush(f, type);
		assert(!f->len);
	}

	// If the output is large enough to flush by itself, just output it.
	// Otherwise, put it into the buffer.
	if (BC_UNLIKELY(n > f->cap - f->len)) bc_file_output(f->fd, buf, n);
	else {
		memcpy(f->buf + f->len, buf, n);
		f->len += n;
	}
}

void bc_file_printf(BcFile *restrict f, const char *fmt, ...)
{
	va_list args;

	va_start(args, fmt);
	bc_file_vprintf(f, fmt, args);
	va_end(args);
}

void bc_file_vprintf(BcFile *restrict f, const char *fmt, va_list args) {

	char *percent;
	const char *ptr = fmt;
	char buf[BC_FILE_ULL_LENGTH];

	// This is a poor man's printf(). While I could look up algorithms to make
	// it as fast as possible, and should when I write the standard library for
	// a new language, for bc, outputting is not the bottleneck. So we cheese it
	// for now.

	// Find each percent sign.
	while ((percent = strchr(ptr, '%')) != NULL) {

		char c;

		// If the percent sign is not where we are, write what's inbetween to
		// the buffer.
		if (percent != ptr) {
			size_t len = (size_t) (percent - ptr);
			bc_file_write(f, bc_flush_none, ptr, len);
		}

		c = percent[1];

		// We only parse some format specifiers, the ones bc uses. If you add
		// more, you need to make sure to add them here.
		if (c == 'c') {

			uchar uc = (uchar) va_arg(args, int);

			bc_file_putchar(f, bc_flush_none, uc);
		}
		else if (c == 's') {

			char *s = va_arg(args, char*);

			bc_file_puts(f, bc_flush_none, s);
		}
#if BC_DEBUG_CODE
		// We only print signed integers in debug code.
		else if (c == 'd') {

			int d = va_arg(args, int);

			// Take care of negative. Let's not worry about overflow.
			if (d < 0) {
				bc_file_putchar(f, bc_flush_none, '-');
				d = -d;
			}

			// Either print 0 or translate and print.
			if (!d) bc_file_putchar(f, bc_flush_none, '0');
			else {
				bc_file_ultoa((unsigned long long) d, buf);
				bc_file_puts(f, bc_flush_none, buf);
			}
		}
#endif // BC_DEBUG_CODE
		else {

			unsigned long long ull;

			// These are the ones that it expects from here. Fortunately, all of
			// these are unsigned types, so they can use the same code, more or
			// less.
			assert((c == 'l' || c == 'z') && percent[2] == 'u');

			if (c == 'z') ull = (unsigned long long) va_arg(args, size_t);
			else ull = (unsigned long long) va_arg(args, unsigned long);

			// Either print 0 or translate and print.
			if (!ull) bc_file_putchar(f, bc_flush_none, '0');
			else {
				bc_file_ultoa(ull, buf);
				bc_file_puts(f, bc_flush_none, buf);
			}
		}

		// Increment to the next spot after the specifier.
		ptr = percent + 2 + (c == 'l' || c == 'z');
	}

	// If we get here, there are no more percent signs, so we just output
	// whatever is left.
	if (ptr[0]) bc_file_puts(f, bc_flush_none, ptr);
}

void bc_file_puts(BcFile *restrict f, BcFlushType type, const char *str) {
	bc_file_write(f, type, str, strlen(str));
}

void bc_file_putchar(BcFile *restrict f, BcFlushType type, uchar c) {

	if (f->len == f->cap) bc_file_flush(f, type);

	assert(f->len < f->cap);

	f->buf[f->len] = (char) c;
	f->len += 1;
}

void bc_file_init(BcFile *f, int fd, char *buf, size_t cap) {

	BC_SIG_ASSERT_LOCKED;

	f->fd = fd;
	f->buf = buf;
	f->len = 0;
	f->cap = cap;
}

void bc_file_free(BcFile *f) {
	BC_SIG_ASSERT_LOCKED;
	bc_file_flush(f, bc_flush_none);
}