d/freebsd-nq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
adf3764857
freebsd-nq/contrib/bc/include/vm.h
Stefan Eßer 78bc019d22 usr.bin/bc: update to version 5.3.1 
This version adds support for command line editing and history using
the libedit or readline libraries in addition to the line editing
features available in previous versions.

The version in the base system is configured to use libedit.

This allows to choose between emacs and vi line editing commands and
to use command overrides via a ~/.editrc file.

Merge commit 'bd54318046bfee055b140705a5cfd4148e78da07'

PR:		264010

MFC after:	2 weeks
2022-06-11 13:14:37 +02:00

931 lines
23 KiB
C
Raw Blame History

/*
* *****************************************************************************
*
* 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.
*
* *****************************************************************************
*
* Definitions for bc's VM.
*
*/
#ifndef BC_VM_H
#define BC_VM_H
#include <assert.h>
#include <stddef.h>
#include <limits.h>
#include <signal.h>
#if BC_ENABLE_NLS
#ifdef _WIN32
#error NLS is not supported on Windows.
#endif // _WIN32
#include <nl_types.h>
#endif // BC_ENABLE_NLS
#include <version.h>
#include <status.h>
#include <num.h>
#include <lex.h>
#include <parse.h>
#include <program.h>
#include <history.h>
#include <bc.h>
// We don't want to include this file for the library because it's unused.
#if !BC_ENABLE_LIBRARY
#include <file.h>
#endif // !BC_ENABLE_LIBRARY
// This should be obvious. If neither calculator is enabled, barf.
#if !BC_ENABLED && !DC_ENABLED
#error Must define BC_ENABLED, DC_ENABLED, or both
#endif
// CHAR_BIT must be at least 6, for various reasons. I might want to bump this
// to 8 in the future.
#if CHAR_BIT < 6
#error CHAR_BIT must be at least 6.
#endif
// Set defaults.
//
#ifndef BC_ENABLE_NLS
#define BC_ENABLE_NLS (0)
#endif // BC_ENABLE_NLS
#ifndef MAINEXEC
#define MAINEXEC bc
#endif // MAINEXEC
#ifndef _WIN32
#ifndef EXECPREFIX
#define EXECPREFIX
#endif // EXECPREFIX
#else // _WIN32
#undef EXECPREFIX
#endif // _WIN32
/**
* Generate a string from text.
* @parm V The text to generate a string for.
*/
#define GEN_STR(V) #V
/**
* Help generate a string from text. The preprocessor requires this two-step
* process. Trust me.
* @parm V The text to generate a string for.
*/
#define GEN_STR2(V) GEN_STR(V)
/// The version as a string. VERSION must be defined previously, usually by the
/// build system.
#define BC_VERSION GEN_STR2(VERSION)
/// The main executable name as a string. MAINEXEC must be defined previously,
/// usually by the build system.
#define BC_MAINEXEC GEN_STR2(MAINEXEC)
/// The build type as a string. BUILD_TYPE must be defined previously, usually
/// by the build system.
#define BC_BUILD_TYPE GEN_STR2(BUILD_TYPE)
// We only allow an empty executable prefix on Windows.
#ifndef _WIN32
#define BC_EXECPREFIX GEN_STR2(EXECPREFIX)
#else // _WIN32
#define BC_EXECPREFIX ""
#endif // _WIN32
#if !BC_ENABLE_LIBRARY
#if DC_ENABLED
/// The flag for the extended register option.
#define DC_FLAG_X (UINTMAX_C(1) << 0)
#endif // DC_ENABLED
#if BC_ENABLED
/// The flag for the POSIX warning option.
#define BC_FLAG_W (UINTMAX_C(1) << 1)
/// The flag for the POSIX error option.
#define BC_FLAG_S (UINTMAX_C(1) << 2)
/// The flag for the math library option.
#define BC_FLAG_L (UINTMAX_C(1) << 3)
/// The flag for the global stacks option.
#define BC_FLAG_G (UINTMAX_C(1) << 4)
#endif // BC_ENABLED
/// The flag for quiet, though this one is reversed; the option clears the flag.
#define BC_FLAG_Q (UINTMAX_C(1) << 5)
/// The flag for interactive.
#define BC_FLAG_I (UINTMAX_C(1) << 6)
/// The flag for prompt. This is also reversed; the option clears the flag.
#define BC_FLAG_P (UINTMAX_C(1) << 7)
/// The flag for read prompt. This is also reversed; the option clears the flag.
#define BC_FLAG_R (UINTMAX_C(1) << 8)
/// The flag for a leading zero.
#define BC_FLAG_Z (UINTMAX_C(1) << 9)
/// The flag for stdin being a TTY.
#define BC_FLAG_TTYIN (UINTMAX_C(1) << 10)
/// The flag for TTY mode.
#define BC_FLAG_TTY (UINTMAX_C(1) << 11)
/// The flag for reset on SIGINT.
#define BC_FLAG_SIGINT (UINTMAX_C(1) << 12)
/// The flag for exiting with expressions.
#define BC_FLAG_EXPR_EXIT (UINTMAX_C(1) << 13)
/// A convenience macro for getting the TTYIN flag.
#define BC_TTYIN (vm.flags & BC_FLAG_TTYIN)
/// A convenience macro for getting the TTY flag.
#define BC_TTY (vm.flags & BC_FLAG_TTY)
/// A convenience macro for getting the SIGINT flag.
#define BC_SIGINT (vm.flags & BC_FLAG_SIGINT)
#if BC_ENABLED
/// A convenience macro for getting the POSIX error flag.
#define BC_S (vm.flags & BC_FLAG_S)
/// A convenience macro for getting the POSIX warning flag.
#define BC_W (vm.flags & BC_FLAG_W)
/// A convenience macro for getting the math library flag.
#define BC_L (vm.flags & BC_FLAG_L)
/// A convenience macro for getting the global stacks flag.
#define BC_G (vm.flags & BC_FLAG_G)
#endif // BC_ENABLED
#if DC_ENABLED
/// A convenience macro for getting the extended register flag.
#define DC_X (vm.flags & DC_FLAG_X)
#endif // DC_ENABLED
/// A convenience macro for getting the interactive flag.
#define BC_I (vm.flags & BC_FLAG_I)
/// A convenience macro for getting the prompt flag.
#define BC_P (vm.flags & BC_FLAG_P)
/// A convenience macro for getting the read prompt flag.
#define BC_R (vm.flags & BC_FLAG_R)
/// A convenience macro for getting the leading zero flag.
#define BC_Z (vm.flags & BC_FLAG_Z)
/// A convenience macro for getting the expression exit flag.
#define BC_EXPR_EXIT (vm.flags & BC_FLAG_EXPR_EXIT)
#if BC_ENABLED
/// A convenience macro for checking if bc is in POSIX mode.
#define BC_IS_POSIX (BC_S || BC_W)
#if DC_ENABLED
/// Returns true if bc is running.
#define BC_IS_BC (vm.name[0] != 'd')
/// Returns true if dc is running.
#define BC_IS_DC (vm.name[0] == 'd')
#else // DC_ENABLED
/// Returns true if bc is running.
#define BC_IS_BC (1)
/// Returns true if dc is running.
#define BC_IS_DC (0)
#endif // DC_ENABLED
#else // BC_ENABLED
/// A convenience macro for checking if bc is in POSIX mode.
#define BC_IS_POSIX (0)
/// Returns true if bc is running.
#define BC_IS_BC (0)
/// Returns true if dc is running.
#define BC_IS_DC (1)
#endif // BC_ENABLED
/// A convenience macro for checking if the prompt is enabled.
#define BC_PROMPT (BC_P)
#else // !BC_ENABLE_LIBRARY
#define BC_Z (vm.leading_zeroes)
#endif // !BC_ENABLE_LIBRARY
/**
* Returns the max of its two arguments. This evaluates arguments twice, so be
* careful what args you give it.
* @param a The first argument.
* @param b The second argument.
* @return The max of the two arguments.
*/
#define BC_MAX(a, b) ((a) > (b) ? (a) : (b))
/**
* Returns the min of its two arguments. This evaluates arguments twice, so be
* careful what args you give it.
* @param a The first argument.
* @param b The second argument.
* @return The min of the two arguments.
*/
#define BC_MIN(a, b) ((a) < (b) ? (a) : (b))
/// Returns the max obase that is allowed.
#define BC_MAX_OBASE ((BcBigDig) (BC_BASE_POW))
/// Returns the max array size that is allowed.
#define BC_MAX_DIM ((BcBigDig) (SIZE_MAX - 1))
/// Returns the max scale that is allowed.
#define BC_MAX_SCALE ((BcBigDig) (BC_NUM_BIGDIG_MAX - 1))
/// Returns the max string length that is allowed.
#define BC_MAX_STRING ((BcBigDig) (BC_NUM_BIGDIG_MAX - 1))
/// Returns the max identifier length that is allowed.
#define BC_MAX_NAME BC_MAX_STRING
/// Returns the max number size that is allowed.
#define BC_MAX_NUM BC_MAX_SCALE
#if BC_ENABLE_EXTRA_MATH
/// Returns the max random integer that can be returned.
#define BC_MAX_RAND ((BcBigDig) (((BcRand) 0) - 1))
#endif // BC_ENABLE_EXTRA_MATH
/// Returns the max exponent that is allowed.
#define BC_MAX_EXP ((ulong) (BC_NUM_BIGDIG_MAX))
/// Returns the max number of variables that is allowed.
#define BC_MAX_VARS ((ulong) (SIZE_MAX - 1))
#if BC_ENABLE_LINE_LIB
/// The size of the global buffer.
#define BC_VM_BUF_SIZE (1 << 10)
/// The amount of the global buffer allocated to stdin.
#define BC_VM_STDIN_BUF_SIZE (BC_VM_BUF_SIZE - 1)
#else // BC_ENABLE_LINE_LIB
/// The size of the global buffer.
#define BC_VM_BUF_SIZE (1 << 12)
/// The amount of the global buffer allocated to stdout.
#define BC_VM_STDOUT_BUF_SIZE (1 << 11)
/// The amount of the global buffer allocated to stderr.
#define BC_VM_STDERR_BUF_SIZE (1 << 10)
/// The amount of the global buffer allocated to stdin.
#define BC_VM_STDIN_BUF_SIZE (BC_VM_STDERR_BUF_SIZE - 1)
#endif // BC_ENABLE_LINE_LIB
/// The max number of temporary BcNums that can be kept.
#define BC_VM_MAX_TEMPS (1 << 9)
/// The capacity of the one BcNum, which is a constant.
#define BC_VM_ONE_CAP (1)
/**
* Returns true if a BcResult is safe for garbage collection.
* @param r The BcResult to test.
* @return True if @a r is safe to garbage collect.
*/
#define BC_VM_SAFE_RESULT(r) ((r)->t >= BC_RESULT_TEMP)
/// The invalid locale catalog return value.
#define BC_VM_INVALID_CATALOG ((nl_catd) -1)
/**
* Returns true if the *unsigned* multiplication overflows.
* @param a The first operand.
* @param b The second operand.
* @param r The product.
* @return True if the multiplication of @a a and @a b overflows.
*/
#define BC_VM_MUL_OVERFLOW(a, b, r) \
((r) >= SIZE_MAX || ((a) != 0 && (r) / (a) != (b)))
/// The global vm struct. This holds all of the global data besides the file
/// buffers.
typedef struct BcVm
{
/// The current status. This is volatile sig_atomic_t because it is also
/// used in the signal handler. See the development manual
/// (manuals/development.md#async-signal-safe-signal-handling) for more
/// information.
volatile sig_atomic_t status;
/// Non-zero if a jump series is in progress and items should be popped off
/// the jmp_bufs vector. This is volatile sig_atomic_t because it is also
/// used in the signal handler. See the development manual
/// (manuals/development.md#async-signal-safe-signal-handling) for more
/// information.
volatile sig_atomic_t sig_pop;
#if !BC_ENABLE_LIBRARY
/// The parser.
BcParse prs;
/// The program.
BcProgram prog;
/// A buffer for lines for stdin.
BcVec line_buf;
/// A buffer to hold a series of lines from stdin. Sometimes, multiple lines
/// are necessary for parsing, such as a comment that spans multiple lines.
BcVec buffer;
/// A parser to parse read expressions.
BcParse read_prs;
/// A buffer for read expressions.
BcVec read_buf;
#endif // !BC_ENABLE_LIBRARY
/// A vector of jmp_bufs for doing a jump series. This allows exception-type
/// error handling, while allowing me to do cleanup on the way.
BcVec jmp_bufs;
/// The number of temps in the temps array.
size_t temps_len;
#if BC_ENABLE_LIBRARY
/// The vector of contexts for the library.
BcVec ctxts;
/// The vector for creating strings to pass to the client.
BcVec out;
/// The PRNG.
BcRNG rng;
/// The current error.
BclError err;
/// Whether or not bcl should abort on fatal errors.
bool abrt;
/// Whether or not to print leading zeros.
bool leading_zeroes;
/// The number of "references," or times that the library was initialized.
unsigned int refs;
/// Non-zero if bcl is running. This is volatile sig_atomic_t because it is
/// also used in the signal handler. See the development manual
/// (manuals/development.md#async-signal-safe-signal-handling) for more
/// information.
volatile sig_atomic_t running;
#endif // BC_ENABLE_LIBRARY
#if !BC_ENABLE_LIBRARY
/// A pointer to the filename of the current file. This is not owned by the
/// BcVm struct.
const char* file;
/// The message printed when SIGINT happens.
const char* sigmsg;
#endif // !BC_ENABLE_LIBRARY
/// Non-zero when signals are "locked." This is volatile sig_atomic_t
/// because it is also used in the signal handler. See the development
/// manual (manuals/development.md#async-signal-safe-signal-handling) for
/// more information.
volatile sig_atomic_t sig_lock;
/// Non-zero when a signal has been received, but not acted on. This is
/// volatile sig_atomic_t because it is also used in the signal handler. See
/// the development manual
/// (manuals/development.md#async-signal-safe-signal-handling) for more
/// information.
volatile sig_atomic_t sig;
#if !BC_ENABLE_LIBRARY
/// The length of sigmsg.
uchar siglen;
/// The instruction used for returning from a read() call.
uchar read_ret;
/// The flags field used by most macros above.
uint16_t flags;
/// The number of characters printed in the current line. This is used
/// because bc has a limit of the number of characters it can print per
/// line.
uint16_t nchars;
/// The length of the line we can print. The user can set this if they wish.
uint16_t line_len;
/// True if bc should error if expressions are encountered during option
/// parsing, false otherwise.
bool no_exprs;
/// True if bc should exit if expresions are encountered.
bool exit_exprs;
/// True if EOF was encountered.
bool eof;
/// True if bc is currently reading from stdin.
bool is_stdin;
#if BC_ENABLED
/// True if keywords should not be redefined. This is only true for the
/// builtin math libraries for bc.
bool no_redefine;
#endif // BC_ENABLED
#endif // !BC_ENABLE_LIBRARY
/// An array of maxes for the globals.
BcBigDig maxes[BC_PROG_GLOBALS_LEN + BC_ENABLE_EXTRA_MATH];
#if !BC_ENABLE_LIBRARY
/// A vector of filenames to process.
BcVec files;
/// A vector of expressions to process.
BcVec exprs;
/// The name of the calculator under use. This is used by BC_IS_BC and
/// BC_IS_DC.
const char* name;
/// The help text for the calculator.
const char* help;
#if BC_ENABLE_HISTORY
/// The history data.
BcHistory history;
#endif // BC_ENABLE_HISTORY
/// The function to call to get the next lex token.
BcLexNext next;
/// The function to call to parse.
BcParseParse parse;
/// The function to call to parse expressions.
BcParseExpr expr;
/// The text to display to label functions in error messages.
const char* func_header;
/// The names of the categories of errors.
const char* err_ids[BC_ERR_IDX_NELEMS + BC_ENABLED];
/// The messages for each error.
const char* err_msgs[BC_ERR_NELEMS];
#if BC_ENABLE_NLS
/// The locale.
const char* locale;
#endif // BC_ENABLE_NLS
#endif // !BC_ENABLE_LIBRARY
/// The last base used to parse.
BcBigDig last_base;
/// The last power of last_base used to parse.
BcBigDig last_pow;
/// The last exponent of base that equals last_pow.
BcBigDig last_exp;
/// BC_BASE_POW - last_pow.
BcBigDig last_rem;
#if !BC_ENABLE_LIBRARY
/// A buffer of environment arguments. This is the actual value of the
/// environment variable.
char* env_args_buffer;
/// A vector for environment arguments after parsing.
BcVec env_args;
/// A BcNum set to constant 0.
BcNum zero;
#endif // !BC_ENABLE_LIBRARY
/// A BcNum set to constant 1.
BcNum one;
/// A BcNum holding the max number held by a BcBigDig plus 1.
BcNum max;
/// A BcNum holding the max number held by a BcBigDig times 2 plus 1.
BcNum max2;
/// The BcDig array for max.
BcDig max_num[BC_NUM_BIGDIG_LOG10];
/// The BcDig array for max2.
BcDig max2_num[BC_NUM_BIGDIG_LOG10];
// The BcDig array for the one BcNum.
BcDig one_num[BC_VM_ONE_CAP];
#if !BC_ENABLE_LIBRARY
// The BcDig array for the zero BcNum.
BcDig zero_num[BC_VM_ONE_CAP];
/// The stdout file.
BcFile fout;
/// The stderr file.
BcFile ferr;
#if BC_ENABLE_NLS
/// The locale catalog.
nl_catd catalog;
#endif // BC_ENABLE_NLS
/// A pointer to the stdin buffer.
char* buf;
/// The number of items in the input buffer.
size_t buf_len;
/// The slab for constants in the main function. This is separate for
/// garbage collection reasons.
BcVec main_const_slab;
//// The slab for all other strings for the main function.
BcVec main_slabs;
/// The slab for function names, strings in other functions, and constants
/// in other functions.
BcVec other_slabs;
#if BC_ENABLED
/// An array of booleans for which bc keywords have been redefined if
/// BC_REDEFINE_KEYWORDS is non-zero.
bool redefined_kws[BC_LEX_NKWS];
#endif // BC_ENABLED
#endif // !BC_ENABLE_LIBRARY
#if BC_DEBUG_CODE
/// The depth for BC_FUNC_ENTER and BC_FUNC_EXIT.
size_t func_depth;
#endif // BC_DEBUG_CODE
} BcVm;
/**
* Print the copyright banner and help if it's non-NULL.
* @param help The help message to print if it's non-NULL.
*/
void
bc_vm_info(const char* const help);
/**
* The entrance point for bc/dc together.
* @param argc The count of arguments.
* @param argv The argument array.
*/
void
bc_vm_boot(int argc, char* argv[]);
/**
* Initializes some of the BcVm global. This is separate to make things easier
* on the library code.
*/
void
bc_vm_init(void);
/**
* Frees the BcVm global.
*/
void
bc_vm_shutdown(void);
/**
* Add a temp to the temp array.
* @param num The BcDig array to add to the temp array.
*/
void
bc_vm_addTemp(BcDig* num);
/**
* Dish out a temp, or NULL if there are none.
* @return A temp, or NULL if none exist.
*/
BcDig*
bc_vm_takeTemp(void);
/**
* Frees all temporaries.
*/
void
bc_vm_freeTemps(void);
#if !BC_ENABLE_HISTORY || BC_ENABLE_LINE_LIB
/**
* Erases the flush argument if history does not exist because it does not
* matter if history does not exist.
*/
#define bc_vm_putchar(c, t) bc_vm_putchar(c)
#endif // !BC_ENABLE_HISTORY || BC_ENABLE_LINE_LIB
/**
* Print to stdout with limited formating.
* @param fmt The format string.
*/
void
bc_vm_printf(const char* fmt, ...);
/**
* Puts a char into the stdout buffer.
* @param c The character to put on the stdout buffer.
* @param type The flush type.
*/
void
bc_vm_putchar(int c, BcFlushType type);
/**
* Multiplies @a n and @a size and throws an allocation error if overflow
* occurs.
* @param n The number of elements.
* @param size The size of each element.
* @return The product of @a n and @a size.
*/
size_t
bc_vm_arraySize(size_t n, size_t size);
/**
* Adds @a a and @a b and throws an error if overflow occurs.
* @param a The first operand.
* @param b The second operand.
* @return The sum of @a a and @a b.
*/
size_t
bc_vm_growSize(size_t a, size_t b);
/**
* Allocate @a n bytes and throw an allocation error if allocation fails.
* @param n The bytes to allocate.
* @return A pointer to the allocated memory.
*/
void*
bc_vm_malloc(size_t n);
/**
* Reallocate @a ptr to be @a n bytes and throw an allocation error if
* reallocation fails.
* @param ptr The pointer to a memory allocation to reallocate.
* @param n The bytes to allocate.
* @return A pointer to the reallocated memory.
*/
void*
bc_vm_realloc(void* ptr, size_t n);
/**
* Allocates space for, and duplicates, @a str.
* @param str The string to allocate.
* @return The allocated string.
*/
char*
bc_vm_strdup(const char* str);
/**
* Reads a line from stdin into BcVm's buffer field.
* @param clear True if the buffer should be cleared first, false otherwise.
* @return True if a line was read, false otherwise.
*/
bool
bc_vm_readLine(bool clear);
/**
* Reads a line from the command-line expressions into BcVm's buffer field.
* @param clear True if the buffer should be cleared first, false otherwise.
* @return True if a line was read, false otherwise.
*/
bool
bc_vm_readBuf(bool clear);
/**
* A convenience and portability function for OpenBSD's pledge().
* @param promises The promises to pledge().
* @param execpromises The exec promises to pledge().
*/
void
bc_pledge(const char* promises, const char* execpromises);
/**
* Returns the value of an environment variable.
* @param var The environment variable.
* @return The value of the environment variable.
*/
char*
bc_vm_getenv(const char* var);
/**
* Frees an environment variable value.
* @param val The value to free.
*/
void
bc_vm_getenvFree(char* val);
#if BC_DEBUG_CODE
/**
* Start executing a jump series.
* @param f The name of the function that started the jump series.
*/
void
bc_vm_jmp(const char* f);
#else // BC_DEBUG_CODE
/**
* Start executing a jump series.
*/
void
bc_vm_jmp(void);
#endif // BC_DEBUG_CODE
#if BC_ENABLE_LIBRARY
/**
* Handle an error. This is the true error handler. It will start a jump series
* if an error occurred. POSIX errors will not cause jumps when warnings are on
* or no POSIX errors are enabled.
* @param e The error.
*/
void
bc_vm_handleError(BcErr e);
/**
* Handle a fatal error.
* @param e The error.
*/
void
bc_vm_fatalError(BcErr e);
/**
* A function to call at exit.
*/
void
bc_vm_atexit(void);
#else // BC_ENABLE_LIBRARY
/**
* Handle an error. This is the true error handler. It will start a jump series
* if an error occurred. POSIX errors will not cause jumps when warnings are on
* or no POSIX errors are enabled.
* @param e The error.
* @param line The source line where the error occurred.
*/
void
bc_vm_handleError(BcErr e, size_t line, ...);
/**
* Handle a fatal error.
* @param e The error.
*/
#if !BC_ENABLE_MEMCHECK
BC_NORETURN
#endif // !BC_ENABLE_MEMCHECK
void
bc_vm_fatalError(BcErr e);
/**
* A function to call at exit.
* @param status The exit status.
*/
int
bc_vm_atexit(int status);
#endif // BC_ENABLE_LIBRARY
/// A reference to the copyright header.
extern const char bc_copyright[];
/// A reference to the format string for source code line printing.
extern const char* const bc_err_line;
/// A reference to the format string for source code function printing.
extern const char* const bc_err_func_header;
/// A reference to the array of default error category names.
extern const char* bc_errs[];
/// A reference to the array of error category indices for each error.
extern const uchar bc_err_ids[];
/// A reference to the array of default error messages.
extern const char* const bc_err_msgs[];
/// A reference to the pledge() promises at start.
extern const char bc_pledge_start[];
#if BC_ENABLE_HISTORY
/// A reference to the end pledge() promises when using history.
extern const char bc_pledge_end_history[];
#endif // BC_ENABLE_HISTORY
/// A reference to the end pledge() promises when *not* using history.
extern const char bc_pledge_end[];
/// A reference to the global data.
extern BcVm vm;
/// A reference to the global output buffers.
extern char output_bufs[BC_VM_BUF_SIZE];
#endif // BC_VM_H
Reference in New Issue View Git Blame Copy Permalink