bc/src/vm.c

/*
 * *****************************************************************************
 *
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2018-2023 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 common to all of bc and dc.
 *
 */

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

#include <signal.h>

#include <setjmp.h>

#ifndef _WIN32

#include <unistd.h>
#include <sys/types.h>
#include <unistd.h>

#else // _WIN32

#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <io.h>

#endif // _WIN32

#include <status.h>
#include <vector.h>
#include <args.h>
#include <vm.h>
#include <read.h>
#include <bc.h>
#if BC_ENABLE_LIBRARY
#include <library.h>
#endif // BC_ENABLE_LIBRARY

#if !BC_ENABLE_LIBRARY

// The actual globals.
char output_bufs[BC_VM_BUF_SIZE];
BcVm vm_data;
BcVm* vm = &vm_data;

#endif // !BC_ENABLE_LIBRARY

#if BC_DEBUG_CODE
BC_NORETURN void
bc_vm_jmp(const char* f)
{
#else // BC_DEBUG_CODE
BC_NORETURN void
bc_vm_jmp(void)
{
#endif

#if BC_ENABLE_LIBRARY
	BcVm* vm = bcl_getspecific();
#endif // BC_ENABLE_LIBRARY

	assert(BC_SIG_EXC(vm));

	BC_SIG_MAYLOCK;

#if BC_DEBUG_CODE
	bc_file_puts(&vm->ferr, bc_flush_none, "Longjmp: ");
	bc_file_puts(&vm->ferr, bc_flush_none, f);
	bc_file_putchar(&vm->ferr, bc_flush_none, '\n');
	bc_file_flush(&vm->ferr, bc_flush_none);
#endif // BC_DEBUG_CODE

#if BC_DEBUG
	assert(vm->jmp_bufs.len - (size_t) vm->sig_pop);
#endif // BC_DEBUG

	if (vm->jmp_bufs.len == 0) abort();
	if (vm->sig_pop) bc_vec_pop(&vm->jmp_bufs);
	else vm->sig_pop = 1;

	siglongjmp(*((sigjmp_buf*) bc_vec_top(&vm->jmp_bufs)), 1);
}

#if !BC_ENABLE_LIBRARY

/**
 * Handles signals. This is the signal handler.
 * @param sig  The signal to handle.
 */
static void
bc_vm_sig(int sig)
{
#if BC_ENABLE_EDITLINE
	// Editline needs this to resize the terminal. This also needs to come first
	// because a resize always needs to happen.
	if (sig == SIGWINCH)
	{
		if (BC_TTY)
		{
			el_resize(vm->history.el);

			// If the signal was a SIGWINCH, clear it because we don't need to
			// print a stack trace in that case.
			if (vm->sig == SIGWINCH)
			{
				vm->sig = 0;
			}
		}

		return;
	}
#endif // BC_ENABLE_EDITLINE

	// There is already a signal in flight if this is true.
	if (vm->status == (sig_atomic_t) BC_STATUS_QUIT || vm->sig != 0)
	{
		if (!BC_I || sig != SIGINT) vm->status = BC_STATUS_QUIT;
		return;
	}

	// We always want to set this because a stack trace can be printed if we do.
	vm->sig = sig;

	// Only reset under these conditions; otherwise, quit.
	if (sig == SIGINT && BC_SIGINT && BC_I)
	{
		int err = errno;

#if BC_ENABLE_EDITLINE
		// Editline needs this, for some unknown reason.
		if (write(STDOUT_FILENO, "^C", 2) != (ssize_t) 2)
		{
			vm->status = BC_STATUS_ERROR_FATAL;
		}
#endif // BC_ENABLE_EDITLINE

		// Write the message.
		if (write(STDOUT_FILENO, vm->sigmsg, vm->siglen) !=
		    (ssize_t) vm->siglen)
		{
			vm->status = BC_STATUS_ERROR_FATAL;
		}

		errno = err;
	}
	else
	{
#if BC_ENABLE_EDITLINE
		if (write(STDOUT_FILENO, "^C", 2) != (ssize_t) 2)
		{
			vm->status = BC_STATUS_ERROR_FATAL;
			return;
		}
#endif // BC_ENABLE_EDITLINE

		vm->status = BC_STATUS_QUIT;
	}

#if BC_ENABLE_LINE_LIB
	// Readline and Editline need this to actually handle sigints correctly.
	if (sig == SIGINT && bc_history_inlinelib)
	{
		bc_history_inlinelib = 0;
		siglongjmp(bc_history_jmpbuf, 1);
	}
#endif // BC_ENABLE_LINE_LIB

	assert(vm->jmp_bufs.len);

	// Only jump if signals are not locked. The jump will happen by whoever
	// unlocks signals.
	if (!vm->sig_lock) BC_JMP;
}

/**
 * Sets up signal handling.
 */
static void
bc_vm_sigaction(void)
{
#ifndef _WIN32

	struct sigaction sa;

	sigemptyset(&sa.sa_mask);
	sa.sa_flags = 0;

	// This mess is to silence a warning on Clang with regards to glibc's
	// sigaction handler, which activates the warning here.
#if BC_CLANG
#pragma clang diagnostic ignored "-Wdisabled-macro-expansion"
#endif // BC_CLANG
	sa.sa_handler = bc_vm_sig;
#if BC_CLANG
#pragma clang diagnostic warning "-Wdisabled-macro-expansion"
#endif // BC_CLANG

	sigaction(SIGTERM, &sa, NULL);
	sigaction(SIGQUIT, &sa, NULL);
	sigaction(SIGINT, &sa, NULL);

#if BC_ENABLE_EDITLINE
	// Editline needs this to resize the terminal.
	if (BC_TTY) sigaction(SIGWINCH, &sa, NULL);
#endif // BC_ENABLE_EDITLINE

#if BC_ENABLE_HISTORY
	if (BC_TTY) sigaction(SIGHUP, &sa, NULL);
#endif // BC_ENABLE_HISTORY

#else // _WIN32

	signal(SIGTERM, bc_vm_sig);
	signal(SIGINT, bc_vm_sig);

#endif // _WIN32
}

void
bc_vm_info(const char* const help)
{
	BC_SIG_ASSERT_LOCKED;

	// Print the banner.
	bc_file_printf(&vm->fout, "%s %s\n%s", vm->name, BC_VERSION, bc_copyright);

	// Print the help.
	if (help != NULL)
	{
		bc_file_putchar(&vm->fout, bc_flush_none, '\n');

#if BC_ENABLED
		if (BC_IS_BC)
		{
			const char* const banner = BC_DEFAULT_BANNER ? "to" : "to not";
			const char* const sigint = BC_DEFAULT_SIGINT_RESET ? "to reset" :
			                                                     "to exit";
			const char* const tty = BC_DEFAULT_TTY_MODE ? "enabled" :
			                                              "disabled";
			const char* const prompt = BC_DEFAULT_PROMPT ? "enabled" :
			                                               "disabled";
			const char* const expr = BC_DEFAULT_EXPR_EXIT ? "to exit" :
			                                                "to not exit";
			const char* const clamp = BC_DEFAULT_DIGIT_CLAMP ? "to clamp" :
			                                                   "to not clamp";

			bc_file_printf(&vm->fout, help, vm->name, vm->name, BC_VERSION,
			               BC_BUILD_TYPE, banner, sigint, tty, prompt, expr,
			               clamp);
		}
#endif // BC_ENABLED

#if DC_ENABLED
		if (BC_IS_DC)
		{
			const char* const sigint = DC_DEFAULT_SIGINT_RESET ? "to reset" :
			                                                     "to exit";
			const char* const tty = DC_DEFAULT_TTY_MODE ? "enabled" :
			                                              "disabled";
			const char* const prompt = DC_DEFAULT_PROMPT ? "enabled" :
			                                               "disabled";
			const char* const expr = DC_DEFAULT_EXPR_EXIT ? "to exit" :
			                                                "to not exit";
			const char* const clamp = DC_DEFAULT_DIGIT_CLAMP ? "to clamp" :
			                                                   "to not clamp";

			bc_file_printf(&vm->fout, help, vm->name, vm->name, BC_VERSION,
			               BC_BUILD_TYPE, sigint, tty, prompt, expr, clamp);
		}
#endif // DC_ENABLED
	}

	// Flush.
	bc_file_flush(&vm->fout, bc_flush_none);
}
#endif // !BC_ENABLE_LIBRARY

#if !BC_ENABLE_LIBRARY && !BC_ENABLE_MEMCHECK
BC_NORETURN
#endif // !BC_ENABLE_LIBRARY && !BC_ENABLE_MEMCHECK
void
bc_vm_fatalError(BcErr e)
{
	bc_err(e);
#if !BC_ENABLE_LIBRARY && !BC_ENABLE_MEMCHECK
	BC_UNREACHABLE
#if !BC_CLANG
	abort();
#endif // !BC_CLANG
#endif // !BC_ENABLE_LIBRARY && !BC_ENABLE_MEMCHECK
}

#if BC_ENABLE_LIBRARY
BC_NORETURN void
bc_vm_handleError(BcErr e)
{
#if BC_ENABLE_LIBRARY
	BcVm* vm = bcl_getspecific();
#endif // BC_ENABLE_LIBRARY

	assert(e < BC_ERR_NELEMS);
	assert(!vm->sig_pop);

	BC_SIG_LOCK;

	// If we have a normal error...
	if (e <= BC_ERR_MATH_DIVIDE_BY_ZERO)
	{
		// Set the error.
		vm->err = (BclError) (e - BC_ERR_MATH_NEGATIVE +
		                      BCL_ERROR_MATH_NEGATIVE);
	}
	// Abort if we should.
	else if (vm->abrt) abort();
	else if (e == BC_ERR_FATAL_ALLOC_ERR) vm->err = BCL_ERROR_FATAL_ALLOC_ERR;
	else vm->err = BCL_ERROR_FATAL_UNKNOWN_ERR;

	BC_JMP;
}
#else // BC_ENABLE_LIBRARY
#if BC_DEBUG
void
bc_vm_handleError(BcErr e, const char* file, int fline, size_t line, ...)
#else // BC_DEBUG
void
bc_vm_handleError(BcErr e, size_t line, ...)
#endif // BC_DEBUG
{
	BcStatus s;
	va_list args;
	uchar id = bc_err_ids[e];
	const char* err_type = vm->err_ids[id];
	sig_atomic_t lock;

	assert(e < BC_ERR_NELEMS);
	assert(!vm->sig_pop);

#if BC_ENABLED
	// Figure out if the POSIX error should be an error, a warning, or nothing.
	if (!BC_S && e >= BC_ERR_POSIX_START)
	{
		if (BC_W)
		{
			// Make sure to not return an error.
			id = UCHAR_MAX;
			err_type = vm->err_ids[BC_ERR_IDX_WARN];
		}
		else return;
	}
#endif // BC_ENABLED

	BC_SIG_TRYLOCK(lock);

	// Make sure all of stdout is written first.
	s = bc_file_flushErr(&vm->fout, bc_flush_err);

	// Just jump out if the flush failed; there's nothing we can do.
	if (BC_ERR(s == BC_STATUS_ERROR_FATAL))
	{
		vm->status = (sig_atomic_t) s;
		BC_JMP;
	}

	// Print the error message.
	va_start(args, line);
	bc_file_putchar(&vm->ferr, bc_flush_none, '\n');
	bc_file_puts(&vm->ferr, bc_flush_none, err_type);
	bc_file_putchar(&vm->ferr, bc_flush_none, ' ');
	bc_file_vprintf(&vm->ferr, vm->err_msgs[e], args);
	va_end(args);

	// Print the extra information if we have it.
	if (BC_NO_ERR(vm->file != NULL))
	{
		// This is the condition for parsing vs runtime.
		// If line is not 0, it is parsing.
		if (line)
		{
			bc_file_puts(&vm->ferr, bc_flush_none, "\n    ");
			bc_file_puts(&vm->ferr, bc_flush_none, vm->file);
			bc_file_printf(&vm->ferr, ":%zu\n", line);
		}
		else
		{
			// Print a stack trace.
			bc_file_putchar(&vm->ferr, bc_flush_none, '\n');
			bc_program_printStackTrace(&vm->prog);
		}
	}
	else
	{
		bc_file_putchar(&vm->ferr, bc_flush_none, '\n');
	}

#if BC_DEBUG
	bc_file_printf(&vm->ferr, "\n    %s:%d\n", file, fline);
#endif // BC_DEBUG

	bc_file_puts(&vm->ferr, bc_flush_none, "\n");

	s = bc_file_flushErr(&vm->ferr, bc_flush_err);

#if !BC_ENABLE_MEMCHECK
	// Because this function is called by a BC_NORETURN function when fatal
	// errors happen, we need to make sure to exit on fatal errors. This will
	// be faster anyway. This function *cannot jump when a fatal error occurs!*
	if (BC_ERR(id == BC_ERR_IDX_FATAL || s == BC_STATUS_ERROR_FATAL))
	{
		exit(bc_vm_atexit((int) BC_STATUS_ERROR_FATAL));
	}
#else // !BC_ENABLE_MEMCHECK
	if (BC_ERR(s == BC_STATUS_ERROR_FATAL)) vm->status = (sig_atomic_t) s;
	else
#endif // !BC_ENABLE_MEMCHECK
	{
		vm->status = (sig_atomic_t) (uchar) (id + 1);
	}

	// Only jump if there is an error.
	if (BC_ERR(vm->status)) BC_JMP;

	BC_SIG_TRYUNLOCK(lock);
}

char*
bc_vm_getenv(const char* var)
{
	char* ret;

#ifndef _WIN32
	ret = getenv(var);
#else // _WIN32
	_dupenv_s(&ret, NULL, var);
#endif // _WIN32

	return ret;
}

void
bc_vm_getenvFree(char* val)
{
	BC_UNUSED(val);
#ifdef _WIN32
	free(val);
#endif // _WIN32
}

/**
 * Sets a flag from an environment variable and the default.
 * @param var   The environment variable.
 * @param def   The default.
 * @param flag  The flag to set.
 */
static void
bc_vm_setenvFlag(const char* const var, int def, uint16_t flag)
{
	// Get the value.
	char* val = bc_vm_getenv(var);

	// If there is no value...
	if (val == NULL)
	{
		// Set the default.
		if (def) vm->flags |= flag;
		else vm->flags &= ~(flag);
	}
	// Parse the value.
	else if (strtoul(val, NULL, 0)) vm->flags |= flag;
	else vm->flags &= ~(flag);

	bc_vm_getenvFree(val);
}

/**
 * Parses the arguments in {B,D]C_ENV_ARGS.
 * @param env_args_name  The environment variable to use.
 * @param scale          A pointer to return the scale that the arguments set,
 *                       if any.
 * @param ibase          A pointer to return the ibase that the arguments set,
 *                       if any.
 * @param obase          A pointer to return the obase that the arguments set,
 *                       if any.
 */
static void
bc_vm_envArgs(const char* const env_args_name, BcBigDig* scale, BcBigDig* ibase,
              BcBigDig* obase)
{
	char *env_args = bc_vm_getenv(env_args_name), *buf, *start;
	char instr = '\0';

	BC_SIG_ASSERT_LOCKED;

	if (env_args == NULL) return;

		// Windows already allocates, so we don't need to.
#ifndef _WIN32
	start = buf = vm->env_args_buffer = bc_vm_strdup(env_args);
#else // _WIN32
	start = buf = vm->env_args_buffer = env_args;
#endif // _WIN32

	assert(buf != NULL);

	// Create two buffers for parsing. These need to stay throughout the entire
	// execution of bc, unfortunately, because of filenames that might be in
	// there.
	bc_vec_init(&vm->env_args, sizeof(char*), BC_DTOR_NONE);
	bc_vec_push(&vm->env_args, &env_args_name);

	// While we haven't reached the end of the args...
	while (*buf)
	{
		// If we don't have whitespace...
		if (!isspace(*buf))
		{
			// If we have the start of a string...
			if (*buf == '"' || *buf == '\'')
			{
				// Set stuff appropriately.
				instr = *buf;
				buf += 1;

				// Check for the empty string.
				if (*buf == instr)
				{
					instr = '\0';
					buf += 1;
					continue;
				}
			}

			// Push the pointer to the args buffer.
			bc_vec_push(&vm->env_args, &buf);

			// Parse the string.
			while (*buf &&
			       ((!instr && !isspace(*buf)) || (instr && *buf != instr)))
			{
				buf += 1;
			}

			// If we did find the end of the string...
			if (*buf)
			{
				if (instr) instr = '\0';

				// Reset stuff.
				*buf = '\0';
				buf += 1;
				start = buf;
			}
			else if (instr) bc_error(BC_ERR_FATAL_OPTION, 0, start);
		}
		// If we have whitespace, eat it.
		else buf += 1;
	}

	// Make sure to push a NULL pointer at the end.
	buf = NULL;
	bc_vec_push(&vm->env_args, &buf);

	// Parse the arguments.
	bc_args((int) vm->env_args.len - 1, bc_vec_item(&vm->env_args, 0), false,
	        scale, ibase, obase);
}

/**
 * Gets the {B,D}C_LINE_LENGTH.
 * @param var  The environment variable to pull it from.
 * @return     The line length.
 */
static size_t
bc_vm_envLen(const char* var)
{
	char* lenv = bc_vm_getenv(var);
	size_t i, len = BC_NUM_PRINT_WIDTH;
	int num;

	// Return the default with none.
	if (lenv == NULL) return len;

	len = strlen(lenv);

	// Figure out if it's a number.
	for (num = 1, i = 0; num && i < len; ++i)
	{
		num = isdigit(lenv[i]);
	}

	// If it is a number...
	if (num)
	{
		// Parse it and clamp it if needed.
		len = (size_t) atoi(lenv) - 1;
		if (len == 1 || len >= UINT16_MAX) len = BC_NUM_PRINT_WIDTH;
	}
	// Set the default.
	else len = BC_NUM_PRINT_WIDTH;

	bc_vm_getenvFree(lenv);

	return len;
}
#endif // BC_ENABLE_LIBRARY

void
bc_vm_shutdown(void)
{
	BC_SIG_ASSERT_LOCKED;

#if BC_ENABLE_NLS
	if (vm->catalog != BC_VM_INVALID_CATALOG) catclose(vm->catalog);
#endif // BC_ENABLE_NLS

#if BC_ENABLE_HISTORY
	// This must always run to ensure that the terminal is back to normal, i.e.,
	// has raw mode disabled. But we should only do it if we did not have a bad
	// terminal because history was not initialized if it is a bad terminal.
	if (BC_TTY && !vm->history.badTerm) bc_history_free(&vm->history);
#endif // BC_ENABLE_HISTORY

#if BC_DEBUG
#if !BC_ENABLE_LIBRARY
	bc_vec_free(&vm->env_args);
	free(vm->env_args_buffer);
	bc_vec_free(&vm->files);
	bc_vec_free(&vm->exprs);

	if (BC_PARSE_IS_INITED(&vm->read_prs, &vm->prog))
	{
		bc_vec_free(&vm->read_buf);
		bc_parse_free(&vm->read_prs);
	}

	bc_parse_free(&vm->prs);
	bc_program_free(&vm->prog);

	bc_slabvec_free(&vm->slabs);
#endif // !BC_ENABLE_LIBRARY

	bc_vm_freeTemps();
#endif // BC_DEBUG

#if !BC_ENABLE_LIBRARY
	// We always want to flush.
	bc_file_free(&vm->fout);
	bc_file_free(&vm->ferr);
#endif // !BC_ENABLE_LIBRARY
}

void
bc_vm_addTemp(BcDig* num)
{
#if BC_ENABLE_LIBRARY
	BcVm* vm = bcl_getspecific();
#endif // BC_ENABLE_LIBRARY

	BC_SIG_ASSERT_LOCKED;

	// If we don't have room, just free.
	if (vm->temps_len == BC_VM_MAX_TEMPS) free(num);
	else
	{
		// Add to the buffer and length.
		vm->temps_buf[vm->temps_len] = num;
		vm->temps_len += 1;
	}
}

BcDig*
bc_vm_takeTemp(void)
{
#if BC_ENABLE_LIBRARY
	BcVm* vm = bcl_getspecific();
#endif // BC_ENABLE_LIBRARY

	BC_SIG_ASSERT_LOCKED;

	if (!vm->temps_len) return NULL;

	vm->temps_len -= 1;

	return vm->temps_buf[vm->temps_len];
}

BcDig*
bc_vm_getTemp(void)
{
#if BC_ENABLE_LIBRARY
	BcVm* vm = bcl_getspecific();
#endif // BC_ENABLE_LIBRARY

	BC_SIG_ASSERT_LOCKED;

	if (!vm->temps_len) return NULL;

	return vm->temps_buf[vm->temps_len - 1];
}

void
bc_vm_freeTemps(void)
{
	size_t i;
#if BC_ENABLE_LIBRARY
	BcVm* vm = bcl_getspecific();
#endif // BC_ENABLE_LIBRARY

	BC_SIG_ASSERT_LOCKED;

	if (!vm->temps_len) return;

	// Free them all...
	for (i = 0; i < vm->temps_len; ++i)
	{
		free(vm->temps_buf[i]);
	}

	vm->temps_len = 0;
}

#if !BC_ENABLE_LIBRARY

size_t
bc_vm_numDigits(size_t val)
{
	size_t digits = 0;

	do
	{
		digits += 1;
		val /= 10;
	}
	while (val != 0);

	return digits;
}

#endif // !BC_ENABLE_LIBRARY

inline size_t
bc_vm_arraySize(size_t n, size_t size)
{
	size_t res = n * size;

	if (BC_ERR(BC_VM_MUL_OVERFLOW(n, size, res)))
	{
		bc_vm_fatalError(BC_ERR_FATAL_ALLOC_ERR);
	}

	return res;
}

inline size_t
bc_vm_growSize(size_t a, size_t b)
{
	size_t res = a + b;

	if (BC_ERR(res >= SIZE_MAX || res < a))
	{
		bc_vm_fatalError(BC_ERR_FATAL_ALLOC_ERR);
	}

	return res;
}

void*
bc_vm_malloc(size_t n)
{
	void* ptr;

	BC_SIG_ASSERT_LOCKED;

	ptr = malloc(n);

	if (BC_ERR(ptr == NULL))
	{
		bc_vm_freeTemps();

		ptr = malloc(n);

		if (BC_ERR(ptr == NULL)) bc_vm_fatalError(BC_ERR_FATAL_ALLOC_ERR);
	}

	return ptr;
}

void*
bc_vm_realloc(void* ptr, size_t n)
{
	void* temp;

	BC_SIG_ASSERT_LOCKED;

	temp = realloc(ptr, n);

	if (BC_ERR(temp == NULL))
	{
		bc_vm_freeTemps();

		temp = realloc(ptr, n);

		if (BC_ERR(temp == NULL)) bc_vm_fatalError(BC_ERR_FATAL_ALLOC_ERR);
	}

	return temp;
}

char*
bc_vm_strdup(const char* str)
{
	char* s;

	BC_SIG_ASSERT_LOCKED;

	s = strdup(str);

	if (BC_ERR(s == NULL))
	{
		bc_vm_freeTemps();

		s = strdup(str);

		if (BC_ERR(s == NULL)) bc_vm_fatalError(BC_ERR_FATAL_ALLOC_ERR);
	}

	return s;
}

#if !BC_ENABLE_LIBRARY
void
bc_vm_printf(const char* fmt, ...)
{
	va_list args;
#if BC_ENABLE_LIBRARY
	BcVm* vm = bcl_getspecific();
#else // BC_ENABLE_LIBRARY
	sig_atomic_t lock;
#endif // BC_ENABLE_LIBRARY

	BC_SIG_TRYLOCK(lock);

	va_start(args, fmt);
	bc_file_vprintf(&vm->fout, fmt, args);
	va_end(args);

	vm->nchars = 0;

	BC_SIG_TRYUNLOCK(lock);
}
#endif // !BC_ENABLE_LIBRARY

void
bc_vm_putchar(int c, BcFlushType type)
{
#if BC_ENABLE_LIBRARY
	BcVm* vm = bcl_getspecific();
	bc_vec_pushByte(&vm->out, (uchar) c);
#else // BC_ENABLE_LIBRARY
	bc_file_putchar(&vm->fout, type, (uchar) c);
	vm->nchars = (c == '\n' ? 0 : vm->nchars + 1);
#endif // BC_ENABLE_LIBRARY
}

#if !BC_ENABLE_LIBRARY

#ifdef __OpenBSD__

/**
 * Aborts with a message. This should never be called because I have carefully
 * made sure that the calls to pledge() and unveil() are correct, but it's here
 * just in case.
 * @param msg  The message to print.
 */
BC_NORETURN static void
bc_abortm(const char* msg)
{
	bc_file_puts(&vm->ferr, bc_flush_none, msg);
	bc_file_puts(&vm->ferr, bc_flush_none, "; this is a bug");
	bc_file_flush(&vm->ferr, bc_flush_none);
	abort();
}

void
bc_pledge(const char* promises, const char* execpromises)
{
	int r = pledge(promises, execpromises);
	if (r) bc_abortm("pledge() failed");
}

#if BC_ENABLE_EXTRA_MATH

/**
 * A convenience and portability function for OpenBSD's unveil().
 * @param path         The path.
 * @param permissions  The permissions for the path.
 */
static void
bc_unveil(const char* path, const char* permissions)
{
	int r = unveil(path, permissions);
	if (r) bc_abortm("unveil() failed");
}

#endif // BC_ENABLE_EXTRA_MATH

#else // __OpenBSD__

void
bc_pledge(const char* promises, const char* execpromises)
{
	BC_UNUSED(promises);
	BC_UNUSED(execpromises);
}

#if BC_ENABLE_EXTRA_MATH
static void
bc_unveil(const char* path, const char* permissions)
{
	BC_UNUSED(path);
	BC_UNUSED(permissions);
}
#endif // BC_ENABLE_EXTRA_MATH

#endif // __OpenBSD__

/**
 * Cleans unneeded variables, arrays, functions, strings, and constants when
 * done executing a line of stdin. This is to prevent memory usage growing
 * without bound. This is an idea from busybox.
 */
static void
bc_vm_clean(void)
{
	BcVec* fns = &vm->prog.fns;
	BcFunc* f = bc_vec_item(fns, BC_PROG_MAIN);
	BcInstPtr* ip = bc_vec_item(&vm->prog.stack, 0);
	bool good = ((vm->status && vm->status != BC_STATUS_QUIT) || vm->sig != 0);

	BC_SIG_ASSERT_LOCKED;

	// If all is good, go ahead and reset.
	if (good) bc_program_reset(&vm->prog);

#if BC_ENABLED
	// bc has this extra condition. If it not satisfied, it is in the middle of
	// a parse.
	if (good && BC_IS_BC) good = !BC_PARSE_NO_EXEC(&vm->prs);
#endif // BC_ENABLED

#if DC_ENABLED
	// For dc, it is safe only when all of the results on the results stack are
	// safe, which means that they are temporaries or other things that don't
	// need strings or constants.
	if (BC_IS_DC)
	{
		size_t i;

		good = true;

		for (i = 0; good && i < vm->prog.results.len; ++i)
		{
			BcResult* r = (BcResult*) bc_vec_item(&vm->prog.results, i);
			good = BC_VM_SAFE_RESULT(r);
		}
	}
#endif // DC_ENABLED

	// If this condition is true, we can get rid of strings,
	// constants, and code.
	if (good && vm->prog.stack.len == 1 && ip->idx == f->code.len)
	{
		// XXX: Nothing can be popped in dc. Deal with it.

#if BC_ENABLED
		if (BC_IS_BC)
		{
			// XXX: you cannot delete strings, functions, or constants in bc.
			// Deal with it.
			bc_vec_popAll(&f->labels);
		}
#endif // BC_ENABLED

		bc_vec_popAll(&f->code);

		ip->idx = 0;
	}
}

/**
 * Process a bunch of text.
 * @param text  The text to process.
 * @param mode  The mode to process in.
 */
static void
bc_vm_process(const char* text, BcMode mode)
{
	// Set up the parser.
	bc_parse_text(&vm->prs, text, mode);

	while (vm->prs.l.t != BC_LEX_EOF)
	{
		// Parsing requires a signal lock. We also don't parse everything; we
		// want to execute as soon as possible for *everything*.
		BC_SIG_LOCK;
		vm->parse(&vm->prs);
		BC_SIG_UNLOCK;

		// Execute if possible.
		if (BC_IS_DC || !BC_PARSE_NO_EXEC(&vm->prs)) bc_program_exec(&vm->prog);

		assert(BC_IS_DC || vm->prog.results.len == 0);

		// Flush in interactive mode.
		if (BC_I) bc_file_flush(&vm->fout, bc_flush_save);
	}
}

#if BC_ENABLED

/**
 * Ends a series of if statements. This is to ensure that full parses happen
 * when a file finishes or stdin has no more data. Without this, bc thinks that
 * it cannot parse any further. But if we reach the end of a file or stdin has
 * no more data, we know we can add an empty else clause.
 */
static void
bc_vm_endif(void)
{
	bc_parse_endif(&vm->prs);
	bc_program_exec(&vm->prog);
}

#endif // BC_ENABLED

/**
 * Processes a file.
 * @param file  The filename.
 */
static void
bc_vm_file(const char* file)
{
	char* data = NULL;
#if BC_ENABLE_LIBRARY
	BcVm* vm = bcl_getspecific();
#endif // BC_ENABLE_LIBRARY

	assert(!vm->sig_pop);

	vm->mode = BC_MODE_FILE;

	// Set up the lexer.
	bc_lex_file(&vm->prs.l, file);

	BC_SIG_LOCK;

	// Read the file.
	data = bc_read_file(file);

	assert(data != NULL);

	BC_SETJMP_LOCKED(vm, err);

	BC_SIG_UNLOCK;

	// Process it.
	bc_vm_process(data, BC_MODE_FILE);

#if BC_ENABLED
	// Make sure to end any open if statements.
	if (BC_IS_BC) bc_vm_endif();
#endif // BC_ENABLED

err:

	BC_SIG_MAYLOCK;

	// Cleanup.
	free(data);
	bc_vm_clean();

	// bc_program_reset(), called by bc_vm_clean(), resets the status.
	// We want it to clear the sig_pop variable in case it was set.
	if (vm->status == (sig_atomic_t) BC_STATUS_SUCCESS) BC_LONGJMP_STOP;

	BC_LONGJMP_CONT(vm);
}

bool
bc_vm_readLine(bool clear)
{
	BcStatus s;
	bool good;

	BC_SIG_ASSERT_NOT_LOCKED;

	// Clear the buffer if desired.
	if (clear) bc_vec_empty(&vm->buffer);

	// Empty the line buffer.
	bc_vec_empty(&vm->line_buf);

	if (vm->eof) return false;

	do
	{
		// bc_read_line() must always return either BC_STATUS_SUCCESS or
		// BC_STATUS_EOF. Everything else, it and whatever it calls, must jump
		// out instead.
		s = bc_read_line(&vm->line_buf, ">>> ");
		vm->eof = (s == BC_STATUS_EOF);
	}
	while (s == BC_STATUS_SUCCESS && !vm->eof && vm->line_buf.len < 1);

	good = (vm->line_buf.len > 1);

	// Concat if we found something.
	if (good) bc_vec_concat(&vm->buffer, vm->line_buf.v);

	return good;
}

/**
 * Processes text from stdin.
 */
static void
bc_vm_stdin(void)
{
	bool clear;

#if BC_ENABLE_LIBRARY
	BcVm* vm = bcl_getspecific();
#endif // BC_ENABLE_LIBRARY

	clear = true;
	vm->mode = BC_MODE_STDIN;

	// Set up the lexer.
	bc_lex_file(&vm->prs.l, bc_program_stdin_name);

	// These are global so that the lexers can access them, but they are
	// allocated and freed in this function because they should only be used for
	// stdin and expressions (they are used in bc_vm_exprs() as well). So they
	// are tied to this function, really. Well, this and bc_vm_readLine(). These
	// are the reasons that we have vm->is_stdin to tell the lexers if we are
	// reading from stdin. Well, both lexers care. And the reason they care is
	// so that if a comment or a string goes across multiple lines, the lexer
	// can request more data from stdin until the comment or string is ended.
	BC_SIG_LOCK;
	bc_vec_init(&vm->buffer, sizeof(uchar), BC_DTOR_NONE);
	bc_vec_init(&vm->line_buf, sizeof(uchar), BC_DTOR_NONE);
	BC_SETJMP_LOCKED(vm, err);
	BC_SIG_UNLOCK;

// This label exists because errors can cause jumps to end up at the err label
// below. If that happens, and the error should be cleared and execution
// continue, then we need to jump back.
restart:

	// While we still read data from stdin.
	while (bc_vm_readLine(clear))
	{
		size_t len = vm->buffer.len - 1;
		const char* str = vm->buffer.v;

		// We don't want to clear the buffer when the line ends with a backslash
		// because a backslash newline is special in bc.
		clear = (len < 2 || str[len - 2] != '\\' || str[len - 1] != '\n');
		if (!clear) continue;

		// Process the data.
		bc_vm_process(vm->buffer.v, BC_MODE_STDIN);

		if (vm->eof) break;
		else
		{
			BC_SIG_LOCK;
			bc_vm_clean();
			BC_SIG_UNLOCK;
		}
	}

#if BC_ENABLED
	// End the if statements.
	if (BC_IS_BC) bc_vm_endif();
#endif // BC_ENABLED

err:

	BC_SIG_MAYLOCK;

	// Cleanup.
	bc_vm_clean();

#if !BC_ENABLE_MEMCHECK
	assert(vm->status != BC_STATUS_ERROR_FATAL);

	vm->status = vm->status == BC_STATUS_QUIT || !BC_I ? vm->status :
	                                                     BC_STATUS_SUCCESS;
#else // !BC_ENABLE_MEMCHECK
	vm->status = vm->status == BC_STATUS_ERROR_FATAL ||
	                     vm->status == BC_STATUS_QUIT || !BC_I ?
	                 vm->status :
	                 BC_STATUS_SUCCESS;
#endif // !BC_ENABLE_MEMCHECK

	if (!vm->status && !vm->eof)
	{
		bc_vec_empty(&vm->buffer);
		BC_LONGJMP_STOP;
		BC_SIG_UNLOCK;
		goto restart;
	}

#if BC_DEBUG
	// Since these are tied to this function, free them here. We only free in
	// debug mode because stdin is always the last thing read.
	bc_vec_free(&vm->line_buf);
	bc_vec_free(&vm->buffer);
#endif // BC_DEBUG

	BC_LONGJMP_CONT(vm);
}

bool
bc_vm_readBuf(bool clear)
{
	size_t len = vm->exprs.len - 1;
	bool more;

	BC_SIG_ASSERT_NOT_LOCKED;

	// Clear the buffer if desired.
	if (clear) bc_vec_empty(&vm->buffer);

	// We want to pop the nul byte off because that's what bc_read_buf()
	// expects.
	bc_vec_pop(&vm->buffer);

	// Read one line of expressions.
	more = bc_read_buf(&vm->buffer, vm->exprs.v, &len);
	bc_vec_pushByte(&vm->buffer, '\0');

	return more;
}

static void
bc_vm_exprs(void)
{
	bool clear;

#if BC_ENABLE_LIBRARY
	BcVm* vm = bcl_getspecific();
#endif // BC_ENABLE_LIBRARY

	clear = true;
	vm->mode = BC_MODE_EXPRS;

	// Prepare the lexer.
	bc_lex_file(&vm->prs.l, bc_program_exprs_name);

	// We initialize this so that the lexer can access it in the case that it
	// needs more data for expressions, such as for a multiline string or
	// comment. See the comment on the allocation of vm->buffer above in
	// bc_vm_stdin() for more information.
	BC_SIG_LOCK;
	bc_vec_init(&vm->buffer, sizeof(uchar), BC_DTOR_NONE);
	BC_SETJMP_LOCKED(vm, err);
	BC_SIG_UNLOCK;

	while (bc_vm_readBuf(clear))
	{
		size_t len = vm->buffer.len - 1;
		const char* str = vm->buffer.v;

		// We don't want to clear the buffer when the line ends with a backslash
		// because a backslash newline is special in bc.
		clear = (len < 2 || str[len - 2] != '\\' || str[len - 1] != '\n');
		if (!clear) continue;

		// Process the data.
		bc_vm_process(vm->buffer.v, BC_MODE_EXPRS);
	}

	// If we were not supposed to clear, then we should process everything. This
	// makes sure that errors get reported.
	if (!clear) bc_vm_process(vm->buffer.v, BC_MODE_EXPRS);

err:

	BC_SIG_MAYLOCK;

	// Cleanup.
	bc_vm_clean();

	// bc_program_reset(), called by bc_vm_clean(), resets the status.
	// We want it to clear the sig_pop variable in case it was set.
	if (vm->status == (sig_atomic_t) BC_STATUS_SUCCESS) BC_LONGJMP_STOP;

	// Since this is tied to this function, free it here. We always free it here
	// because bc_vm_stdin() may or may not use it later.
	bc_vec_free(&vm->buffer);

	BC_LONGJMP_CONT(vm);
}

#if BC_ENABLED

/**
 * Loads a math library.
 * @param name  The name of the library.
 * @param text  The text of the source code.
 */
static void
bc_vm_load(const char* name, const char* text)
{
	bc_lex_file(&vm->prs.l, name);
	bc_parse_text(&vm->prs, text, BC_MODE_FILE);

	BC_SIG_LOCK;

	while (vm->prs.l.t != BC_LEX_EOF)
	{
		vm->parse(&vm->prs);
	}

	BC_SIG_UNLOCK;
}

#endif // BC_ENABLED

/**
 * Loads the default error messages.
 */
static void
bc_vm_defaultMsgs(void)
{
	size_t i;

	// Load the error categories.
	for (i = 0; i < BC_ERR_IDX_NELEMS + BC_ENABLED; ++i)
	{
		vm->err_ids[i] = bc_errs[i];
	}

	// Load the error messages.
	for (i = 0; i < BC_ERR_NELEMS; ++i)
	{
		vm->err_msgs[i] = bc_err_msgs[i];
	}
}

/**
 * Loads the error messages for the locale. If NLS is disabled, this just loads
 * the default messages.
 */
static void
bc_vm_gettext(void)
{
#if BC_ENABLE_NLS
	uchar id = 0;
	int set, msg = 1;
	size_t i;

	// If no locale, load the defaults.
	if (vm->locale == NULL)
	{
		vm->catalog = BC_VM_INVALID_CATALOG;
		bc_vm_defaultMsgs();
		return;
	}

	vm->catalog = catopen(BC_MAINEXEC, NL_CAT_LOCALE);

	// If no catalog, load the defaults.
	if (vm->catalog == BC_VM_INVALID_CATALOG)
	{
		bc_vm_defaultMsgs();
		return;
	}

	// Load the error categories.
	for (set = 1; msg <= BC_ERR_IDX_NELEMS + BC_ENABLED; ++msg)
	{
		vm->err_ids[msg - 1] = catgets(vm->catalog, set, msg, bc_errs[msg - 1]);
	}

	i = 0;
	id = bc_err_ids[i];

	// Load the error messages. In order to understand this loop, you must know
	// the order of messages and categories in the enum and in the locale files.
	for (set = id + 2, msg = 1; i < BC_ERR_NELEMS; ++i, ++msg)
	{
		if (id != bc_err_ids[i])
		{
			msg = 1;
			id = bc_err_ids[i];
			set = id + 2;
		}

		vm->err_msgs[i] = catgets(vm->catalog, set, msg, bc_err_msgs[i]);
	}
#else // BC_ENABLE_NLS
	bc_vm_defaultMsgs();
#endif // BC_ENABLE_NLS
}

/**
 * Starts execution. Really, this is a function of historical accident; it could
 * probably be combined with bc_vm_boot(), but I don't care enough. Really, this
 * function starts when execution of bc or dc source code starts.
 */
static void
bc_vm_exec(void)
{
	size_t i;
#if DC_ENABLED
	bool has_file = false;
#endif // DC_ENABLED

#if BC_ENABLED
	// Load the math libraries.
	if (BC_IS_BC && (vm->flags & BC_FLAG_L))
	{
		// Can't allow redefinitions in the builtin library.
		vm->no_redefine = true;

		bc_vm_load(bc_lib_name, bc_lib);

#if BC_ENABLE_EXTRA_MATH
		if (!BC_IS_POSIX) bc_vm_load(bc_lib2_name, bc_lib2);
#endif // BC_ENABLE_EXTRA_MATH

		// Make sure to clear this.
		vm->no_redefine = false;

		// Execute to ensure that all is hunky dory. Without this, scale can be
		// set improperly.
		bc_program_exec(&vm->prog);
	}
#endif // BC_ENABLED

	// If there are expressions to execute...
	if (vm->exprs.len)
	{
		// Process the expressions.
		bc_vm_exprs();

		// Sometimes, executing expressions means we need to quit.
		if (!vm->no_exprs && vm->exit_exprs && BC_EXPR_EXIT) return;
	}

	// Process files.
	for (i = 0; i < vm->files.len; ++i)
	{
		char* path = *((char**) bc_vec_item(&vm->files, i));
		if (!strcmp(path, "")) continue;
#if DC_ENABLED
		has_file = true;
#endif // DC_ENABLED
		bc_vm_file(path);
	}

#if BC_ENABLE_EXTRA_MATH
	// These are needed for the pseudo-random number generator.
	bc_unveil("/dev/urandom", "r");
	bc_unveil("/dev/random", "r");
	bc_unveil(NULL, NULL);
#endif // BC_ENABLE_EXTRA_MATH

#if BC_ENABLE_HISTORY

	// We need to keep tty if history is enabled, and we need to keep rpath for
	// the times when we read from /dev/urandom.
	if (BC_TTY && !vm->history.badTerm) bc_pledge(bc_pledge_end_history, NULL);
	else
#endif // BC_ENABLE_HISTORY
	{
		bc_pledge(bc_pledge_end, NULL);
	}

#if BC_ENABLE_AFL
	// This is the thing that makes fuzzing with AFL++ so fast. If you move this
	// back, you won't cause any problems, but fuzzing will slow down. If you
	// move this forward, you won't fuzz anything because you will be skipping
	// the reading from stdin.
	__AFL_INIT();
#endif // BC_ENABLE_AFL

	// Execute from stdin. bc always does.
	if (BC_VM_RUN_STDIN(has_file)) bc_vm_stdin();
}

void
bc_vm_boot(int argc, char* argv[])
{
	int ttyin, ttyout, ttyerr;
	bool tty;
	const char* const env_len = BC_VM_LINE_LENGTH_STR;
	const char* const env_args = BC_VM_ENV_ARGS_STR;
	const char* const env_exit = BC_VM_EXPR_EXIT_STR;
	const char* const env_clamp = BC_VM_DIGIT_CLAMP_STR;
	int env_exit_def = BC_VM_EXPR_EXIT_DEF;
	int env_clamp_def = BC_VM_DIGIT_CLAMP_DEF;
	BcBigDig scale = BC_NUM_BIGDIG_MAX;
	BcBigDig env_scale = BC_NUM_BIGDIG_MAX;
	BcBigDig ibase = BC_NUM_BIGDIG_MAX;
	BcBigDig env_ibase = BC_NUM_BIGDIG_MAX;
	BcBigDig obase = BC_NUM_BIGDIG_MAX;
	BcBigDig env_obase = BC_NUM_BIGDIG_MAX;

	// We need to know which of stdin, stdout, and stderr are tty's.
	ttyin = isatty(STDIN_FILENO);
	ttyout = isatty(STDOUT_FILENO);
	ttyerr = isatty(STDERR_FILENO);
	tty = (ttyin != 0 && ttyout != 0 && ttyerr != 0);

	vm->flags |= ttyin ? BC_FLAG_TTYIN : 0;
	vm->flags |= tty ? BC_FLAG_TTY : 0;
	vm->flags |= ttyin && ttyout ? BC_FLAG_I : 0;

	// Set up signals.
	bc_vm_sigaction();

	// Initialize some vm stuff. This is separate to make things easier for the
	// library.
	bc_vm_init();

	// Explicitly set this in case NULL isn't all zeroes.
	vm->file = NULL;

	// Set the error messages.
	bc_vm_gettext();

#if BC_ENABLE_LINE_LIB

	// Initialize the output file buffers.
	bc_file_init(&vm->ferr, stderr);
	bc_file_init(&vm->fout, stdout);

	// Set the input buffer.
	vm->buf = output_bufs;

#else // BC_ENABLE_LINE_LIB

	// Initialize the output file buffers. They each take portions of the global
	// buffer. stdout gets more because it will probably have more data.
	bc_file_init(&vm->ferr, STDERR_FILENO, output_bufs + BC_VM_STDOUT_BUF_SIZE,
	             BC_VM_STDERR_BUF_SIZE);
	bc_file_init(&vm->fout, STDOUT_FILENO, output_bufs, BC_VM_STDOUT_BUF_SIZE);

	// Set the input buffer to the rest of the global buffer.
	vm->buf = output_bufs + BC_VM_STDOUT_BUF_SIZE + BC_VM_STDERR_BUF_SIZE;
#endif // BC_ENABLE_LINE_LIB

	// Set the line length by environment variable.
	vm->line_len = (uint16_t) bc_vm_envLen(env_len);

	bc_vm_setenvFlag(env_exit, env_exit_def, BC_FLAG_EXPR_EXIT);
	bc_vm_setenvFlag(env_clamp, env_clamp_def, BC_FLAG_DIGIT_CLAMP);

	// Clear the files and expressions vectors, just in case. This marks them as
	// *not* allocated.
	bc_vec_clear(&vm->files);
	bc_vec_clear(&vm->exprs);

#if !BC_ENABLE_LIBRARY

	// Initialize the slab vector.
	bc_slabvec_init(&vm->slabs);

#endif // !BC_ENABLE_LIBRARY

	// Initialize the program and main parser. These have to be in this order
	// because the program has to be initialized first, since a pointer to it is
	// passed to the parser.
	bc_program_init(&vm->prog);
	bc_parse_init(&vm->prs, &vm->prog, BC_PROG_MAIN);

	// Set defaults.
	vm->flags |= BC_TTY ? BC_FLAG_P | BC_FLAG_R : 0;
	vm->flags |= BC_I ? BC_FLAG_Q : 0;

#if BC_ENABLED
	if (BC_IS_BC)
	{
		// bc checks this environment variable to see if it should run in
		// standard mode.
		char* var = bc_vm_getenv("POSIXLY_CORRECT");

		vm->flags |= BC_FLAG_S * (var != NULL);
		bc_vm_getenvFree(var);

		// Set whether we print the banner or not.
		if (BC_I) bc_vm_setenvFlag("BC_BANNER", BC_DEFAULT_BANNER, BC_FLAG_Q);
	}
#endif // BC_ENABLED

	// Are we in TTY mode?
	if (BC_TTY)
	{
		const char* const env_tty = BC_VM_TTY_MODE_STR;
		int env_tty_def = BC_VM_TTY_MODE_DEF;
		const char* const env_prompt = BC_VM_PROMPT_STR;
		int env_prompt_def = BC_VM_PROMPT_DEF;

		// Set flags for TTY mode and prompt.
		bc_vm_setenvFlag(env_tty, env_tty_def, BC_FLAG_TTY);
		bc_vm_setenvFlag(env_prompt, tty ? env_prompt_def : 0, BC_FLAG_P);

#if BC_ENABLE_HISTORY
		// If TTY mode is used, activate history.
		if (BC_TTY) bc_history_init(&vm->history);
#endif // BC_ENABLE_HISTORY
	}

	// Process environment and command-line arguments.
	bc_vm_envArgs(env_args, &env_scale, &env_ibase, &env_obase);
	bc_args(argc, argv, true, &scale, &ibase, &obase);

	// This section is here because we don't want the math library to stomp on
	// the user's given value for scale. And we don't want ibase affecting how
	// the scale is interpreted. Also, it's sectioned off just for this comment.
	{
		BC_SIG_UNLOCK;

		scale = scale == BC_NUM_BIGDIG_MAX ? env_scale : scale;
#if BC_ENABLED
		// Assign the library value only if it is used and no value was set.
		scale = scale == BC_NUM_BIGDIG_MAX && BC_L ? 20 : scale;
#endif // BC_ENABLED
		obase = obase == BC_NUM_BIGDIG_MAX ? env_obase : obase;
		ibase = ibase == BC_NUM_BIGDIG_MAX ? env_ibase : ibase;

		if (scale != BC_NUM_BIGDIG_MAX)
		{
			bc_program_assignBuiltin(&vm->prog, true, false, scale);
		}

		if (obase != BC_NUM_BIGDIG_MAX)
		{
			bc_program_assignBuiltin(&vm->prog, false, true, obase);
		}

		// This is last to avoid it affecting the value of the others.
		if (ibase != BC_NUM_BIGDIG_MAX)
		{
			bc_program_assignBuiltin(&vm->prog, false, false, ibase);
		}

		BC_SIG_LOCK;
	}

	// If we are in interactive mode...
	if (BC_I)
	{
		const char* const env_sigint = BC_VM_SIGINT_RESET_STR;
		int env_sigint_def = BC_VM_SIGINT_RESET_DEF;

		// Set whether we reset on SIGINT or not.
		bc_vm_setenvFlag(env_sigint, env_sigint_def, BC_FLAG_SIGINT);
	}

#if BC_ENABLED
	// Disable global stacks in POSIX mode.
	if (BC_IS_POSIX) vm->flags &= ~(BC_FLAG_G);

	// Print the banner if allowed. We have to be in bc, in interactive mode,
	// and not be quieted by command-line option or environment variable.
	if (BC_IS_BC && BC_I && (vm->flags & BC_FLAG_Q))
	{
		bc_vm_info(NULL);
		bc_file_putchar(&vm->fout, bc_flush_none, '\n');
		bc_file_flush(&vm->fout, bc_flush_none);
	}
#endif // BC_ENABLED

	BC_SIG_UNLOCK;

	// Start executing.
	bc_vm_exec();
}
#endif // !BC_ENABLE_LIBRARY

void
bc_vm_init(void)
{
#if BC_ENABLE_LIBRARY
	BcVm* vm = bcl_getspecific();
#endif // BC_ENABLE_LIBRARY

	BC_SIG_ASSERT_LOCKED;

#if !BC_ENABLE_LIBRARY
	// Set up the constant zero.
	bc_num_setup(&vm->zero, vm->zero_num, BC_VM_ONE_CAP);
#endif // !BC_ENABLE_LIBRARY

	// Set up more constant BcNum's.
	bc_num_setup(&vm->one, vm->one_num, BC_VM_ONE_CAP);
	bc_num_one(&vm->one);

	// Set up more constant BcNum's.
	// NOLINTNEXTLINE
	memcpy(vm->max_num, bc_num_bigdigMax,
	       bc_num_bigdigMax_size * sizeof(BcDig));
	// NOLINTNEXTLINE
	memcpy(vm->max2_num, bc_num_bigdigMax2,
	       bc_num_bigdigMax2_size * sizeof(BcDig));
	bc_num_setup(&vm->max, vm->max_num, BC_NUM_BIGDIG_LOG10);
	bc_num_setup(&vm->max2, vm->max2_num, BC_NUM_BIGDIG_LOG10);
	vm->max.len = bc_num_bigdigMax_size;
	vm->max2.len = bc_num_bigdigMax2_size;

	// Set up the maxes for the globals.
	vm->maxes[BC_PROG_GLOBALS_IBASE] = BC_NUM_MAX_POSIX_IBASE;
	vm->maxes[BC_PROG_GLOBALS_OBASE] = BC_MAX_OBASE;
	vm->maxes[BC_PROG_GLOBALS_SCALE] = BC_MAX_SCALE;

#if BC_ENABLE_EXTRA_MATH
	vm->maxes[BC_PROG_MAX_RAND] = ((BcRand) 0) - 1;
#endif // BC_ENABLE_EXTRA_MATH

#if BC_ENABLED
#if !BC_ENABLE_LIBRARY
	// bc has a higher max ibase when it's not in POSIX mode.
	if (BC_IS_BC && !BC_IS_POSIX)
#endif // !BC_ENABLE_LIBRARY
	{
		vm->maxes[BC_PROG_GLOBALS_IBASE] = BC_NUM_MAX_IBASE;
	}
#endif // BC_ENABLED
}

#if BC_ENABLE_LIBRARY
void
bc_vm_atexit(void)
{
#if BC_DEBUG
#if BC_ENABLE_LIBRARY
	BcVm* vm = bcl_getspecific();
#endif // BC_ENABLE_LIBRARY
#endif // BC_DEBUG

	bc_vm_shutdown();

#if BC_DEBUG
	bc_vec_free(&vm->jmp_bufs);
#endif // BC_DEBUG
}
#else // BC_ENABLE_LIBRARY
int
bc_vm_atexit(int status)
{
	// Set the status correctly.
	int s = BC_STATUS_IS_ERROR(status) ? status : BC_STATUS_SUCCESS;

	bc_vm_shutdown();

#if BC_DEBUG
	bc_vec_free(&vm->jmp_bufs);
#endif // BC_DEBUG

	return s;
}
#endif // BC_ENABLE_LIBRARY