2 * *****************************************************************************
4 * SPDX-License-Identifier: BSD-2-Clause
6 * Copyright (c) 2018-2023 Gavin D. Howard and contributors.
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions are met:
11 * * Redistributions of source code must retain the above copyright notice, this
12 * list of conditions and the following disclaimer.
14 * * Redistributions in binary form must reproduce the above copyright notice,
15 * this list of conditions and the following disclaimer in the documentation
16 * and/or other materials provided with the distribution.
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
19 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
22 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
23 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
24 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
25 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
26 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
27 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
28 * POSSIBILITY OF SUCH DAMAGE.
30 * *****************************************************************************
32 * Code common to all of bc and dc.
49 #include <sys/types.h>
54 #define WIN32_LEAN_AND_MEAN
68 #endif // BC_ENABLE_LIBRARY
70 #if !BC_ENABLE_LIBRARY
72 // The actual globals.
73 char output_bufs[BC_VM_BUF_SIZE];
77 #endif // !BC_ENABLE_LIBRARY
81 bc_vm_jmp(const char* f)
83 #else // BC_DEBUG_CODE
90 BcVm* vm = bcl_getspecific();
91 #endif // BC_ENABLE_LIBRARY
93 assert(BC_SIG_EXC(vm));
98 bc_file_puts(&vm->ferr, bc_flush_none, "Longjmp: ");
99 bc_file_puts(&vm->ferr, bc_flush_none, f);
100 bc_file_putchar(&vm->ferr, bc_flush_none, '\n');
101 bc_file_flush(&vm->ferr, bc_flush_none);
102 #endif // BC_DEBUG_CODE
105 assert(vm->jmp_bufs.len - (size_t) vm->sig_pop);
108 if (vm->jmp_bufs.len == 0) abort();
109 if (vm->sig_pop) bc_vec_pop(&vm->jmp_bufs);
110 else vm->sig_pop = 1;
112 siglongjmp(*((sigjmp_buf*) bc_vec_top(&vm->jmp_bufs)), 1);
115 #if !BC_ENABLE_LIBRARY
118 * Handles signals. This is the signal handler.
119 * @param sig The signal to handle.
124 #if BC_ENABLE_EDITLINE
125 // Editline needs this to resize the terminal. This also needs to come first
126 // because a resize always needs to happen.
131 el_resize(vm->history.el);
133 // If the signal was a SIGWINCH, clear it because we don't need to
134 // print a stack trace in that case.
135 if (vm->sig == SIGWINCH)
143 #endif // BC_ENABLE_EDITLINE
145 // There is already a signal in flight if this is true.
146 if (vm->status == (sig_atomic_t) BC_STATUS_QUIT || vm->sig != 0)
148 if (!BC_I || sig != SIGINT) vm->status = BC_STATUS_QUIT;
152 // We always want to set this because a stack trace can be printed if we do.
155 // Only reset under these conditions; otherwise, quit.
156 if (sig == SIGINT && BC_SIGINT && BC_I)
160 #if BC_ENABLE_EDITLINE
161 // Editline needs this, for some unknown reason.
162 if (write(STDOUT_FILENO, "^C", 2) != (ssize_t) 2)
164 vm->status = BC_STATUS_ERROR_FATAL;
166 #endif // BC_ENABLE_EDITLINE
168 // Write the message.
169 if (write(STDOUT_FILENO, vm->sigmsg, vm->siglen) !=
170 (ssize_t) vm->siglen)
172 vm->status = BC_STATUS_ERROR_FATAL;
179 #if BC_ENABLE_EDITLINE
180 if (write(STDOUT_FILENO, "^C", 2) != (ssize_t) 2)
182 vm->status = BC_STATUS_ERROR_FATAL;
185 #endif // BC_ENABLE_EDITLINE
187 vm->status = BC_STATUS_QUIT;
190 #if BC_ENABLE_LINE_LIB
191 // Readline and Editline need this to actually handle sigints correctly.
192 if (sig == SIGINT && bc_history_inlinelib)
194 bc_history_inlinelib = 0;
195 siglongjmp(bc_history_jmpbuf, 1);
197 #endif // BC_ENABLE_LINE_LIB
199 assert(vm->jmp_bufs.len);
201 // Only jump if signals are not locked. The jump will happen by whoever
203 if (!vm->sig_lock) BC_JMP;
207 * Sets up signal handling.
210 bc_vm_sigaction(void)
216 sigemptyset(&sa.sa_mask);
219 // This mess is to silence a warning on Clang with regards to glibc's
220 // sigaction handler, which activates the warning here.
222 #pragma clang diagnostic ignored "-Wdisabled-macro-expansion"
224 sa.sa_handler = bc_vm_sig;
226 #pragma clang diagnostic warning "-Wdisabled-macro-expansion"
229 sigaction(SIGTERM, &sa, NULL);
230 sigaction(SIGQUIT, &sa, NULL);
231 sigaction(SIGINT, &sa, NULL);
233 #if BC_ENABLE_EDITLINE
234 // Editline needs this to resize the terminal.
235 if (BC_TTY) sigaction(SIGWINCH, &sa, NULL);
236 #endif // BC_ENABLE_EDITLINE
238 #if BC_ENABLE_HISTORY
239 if (BC_TTY) sigaction(SIGHUP, &sa, NULL);
240 #endif // BC_ENABLE_HISTORY
244 signal(SIGTERM, bc_vm_sig);
245 signal(SIGINT, bc_vm_sig);
251 bc_vm_info(const char* const help)
253 BC_SIG_ASSERT_LOCKED;
256 bc_file_printf(&vm->fout, "%s %s\n%s", vm->name, BC_VERSION, bc_copyright);
261 bc_file_putchar(&vm->fout, bc_flush_none, '\n');
266 const char* const banner = BC_DEFAULT_BANNER ? "to" : "to not";
267 const char* const sigint = BC_DEFAULT_SIGINT_RESET ? "to reset" :
269 const char* const tty = BC_DEFAULT_TTY_MODE ? "enabled" :
271 const char* const prompt = BC_DEFAULT_PROMPT ? "enabled" :
273 const char* const expr = BC_DEFAULT_EXPR_EXIT ? "to exit" :
275 const char* const clamp = BC_DEFAULT_DIGIT_CLAMP ? "to clamp" :
278 bc_file_printf(&vm->fout, help, vm->name, vm->name, BC_VERSION,
279 BC_BUILD_TYPE, banner, sigint, tty, prompt, expr,
287 const char* const sigint = DC_DEFAULT_SIGINT_RESET ? "to reset" :
289 const char* const tty = DC_DEFAULT_TTY_MODE ? "enabled" :
291 const char* const prompt = DC_DEFAULT_PROMPT ? "enabled" :
293 const char* const expr = DC_DEFAULT_EXPR_EXIT ? "to exit" :
295 const char* const clamp = DC_DEFAULT_DIGIT_CLAMP ? "to clamp" :
298 bc_file_printf(&vm->fout, help, vm->name, vm->name, BC_VERSION,
299 BC_BUILD_TYPE, sigint, tty, prompt, expr, clamp);
305 bc_file_flush(&vm->fout, bc_flush_none);
307 #endif // !BC_ENABLE_LIBRARY
309 #if !BC_ENABLE_LIBRARY && !BC_ENABLE_MEMCHECK
311 #endif // !BC_ENABLE_LIBRARY && !BC_ENABLE_MEMCHECK
313 bc_vm_fatalError(BcErr e)
316 #if !BC_ENABLE_LIBRARY && !BC_ENABLE_MEMCHECK
321 #endif // !BC_ENABLE_LIBRARY && !BC_ENABLE_MEMCHECK
324 #if BC_ENABLE_LIBRARY
326 bc_vm_handleError(BcErr e)
328 #if BC_ENABLE_LIBRARY
329 BcVm* vm = bcl_getspecific();
330 #endif // BC_ENABLE_LIBRARY
332 assert(e < BC_ERR_NELEMS);
333 assert(!vm->sig_pop);
337 // If we have a normal error...
338 if (e <= BC_ERR_MATH_DIVIDE_BY_ZERO)
341 vm->err = (BclError) (e - BC_ERR_MATH_NEGATIVE +
342 BCL_ERROR_MATH_NEGATIVE);
344 // Abort if we should.
345 else if (vm->abrt) abort();
346 else if (e == BC_ERR_FATAL_ALLOC_ERR) vm->err = BCL_ERROR_FATAL_ALLOC_ERR;
347 else vm->err = BCL_ERROR_FATAL_UNKNOWN_ERR;
351 #else // BC_ENABLE_LIBRARY
354 bc_vm_handleError(BcErr e, const char* file, int fline, size_t line, ...)
357 bc_vm_handleError(BcErr e, size_t line, ...)
362 uchar id = bc_err_ids[e];
363 const char* err_type = vm->err_ids[id];
366 assert(e < BC_ERR_NELEMS);
367 assert(!vm->sig_pop);
370 // Figure out if the POSIX error should be an error, a warning, or nothing.
371 if (!BC_S && e >= BC_ERR_POSIX_START)
375 // Make sure to not return an error.
377 err_type = vm->err_ids[BC_ERR_IDX_WARN];
383 BC_SIG_TRYLOCK(lock);
385 // Make sure all of stdout is written first.
386 s = bc_file_flushErr(&vm->fout, bc_flush_err);
388 // Just jump out if the flush failed; there's nothing we can do.
389 if (BC_ERR(s == BC_STATUS_ERROR_FATAL))
391 vm->status = (sig_atomic_t) s;
395 // Print the error message.
396 va_start(args, line);
397 bc_file_putchar(&vm->ferr, bc_flush_none, '\n');
398 bc_file_puts(&vm->ferr, bc_flush_none, err_type);
399 bc_file_putchar(&vm->ferr, bc_flush_none, ' ');
400 bc_file_vprintf(&vm->ferr, vm->err_msgs[e], args);
403 // Print the extra information if we have it.
404 if (BC_NO_ERR(vm->file != NULL))
406 // This is the condition for parsing vs runtime.
407 // If line is not 0, it is parsing.
410 bc_file_puts(&vm->ferr, bc_flush_none, "\n ");
411 bc_file_puts(&vm->ferr, bc_flush_none, vm->file);
412 bc_file_printf(&vm->ferr, ":%zu\n", line);
416 // Print a stack trace.
417 bc_file_putchar(&vm->ferr, bc_flush_none, '\n');
418 bc_program_printStackTrace(&vm->prog);
423 bc_file_putchar(&vm->ferr, bc_flush_none, '\n');
427 bc_file_printf(&vm->ferr, "\n %s:%d\n", file, fline);
430 bc_file_puts(&vm->ferr, bc_flush_none, "\n");
432 s = bc_file_flushErr(&vm->ferr, bc_flush_err);
434 #if !BC_ENABLE_MEMCHECK
435 // Because this function is called by a BC_NORETURN function when fatal
436 // errors happen, we need to make sure to exit on fatal errors. This will
437 // be faster anyway. This function *cannot jump when a fatal error occurs!*
438 if (BC_ERR(id == BC_ERR_IDX_FATAL || s == BC_STATUS_ERROR_FATAL))
440 exit(bc_vm_atexit((int) BC_STATUS_ERROR_FATAL));
442 #else // !BC_ENABLE_MEMCHECK
443 if (BC_ERR(s == BC_STATUS_ERROR_FATAL)) vm->status = (sig_atomic_t) s;
445 #endif // !BC_ENABLE_MEMCHECK
447 vm->status = (sig_atomic_t) (uchar) (id + 1);
450 // Only jump if there is an error.
451 if (BC_ERR(vm->status)) BC_JMP;
453 BC_SIG_TRYUNLOCK(lock);
457 bc_vm_getenv(const char* var)
464 _dupenv_s(&ret, NULL, var);
471 bc_vm_getenvFree(char* val)
480 * Sets a flag from an environment variable and the default.
481 * @param var The environment variable.
482 * @param def The default.
483 * @param flag The flag to set.
486 bc_vm_setenvFlag(const char* const var, int def, uint16_t flag)
489 char* val = bc_vm_getenv(var);
491 // If there is no value...
495 if (def) vm->flags |= flag;
496 else vm->flags &= ~(flag);
499 else if (strtoul(val, NULL, 0)) vm->flags |= flag;
500 else vm->flags &= ~(flag);
502 bc_vm_getenvFree(val);
506 * Parses the arguments in {B,D]C_ENV_ARGS.
507 * @param env_args_name The environment variable to use.
508 * @param scale A pointer to return the scale that the arguments set,
510 * @param ibase A pointer to return the ibase that the arguments set,
512 * @param obase A pointer to return the obase that the arguments set,
516 bc_vm_envArgs(const char* const env_args_name, BcBigDig* scale, BcBigDig* ibase,
519 char *env_args = bc_vm_getenv(env_args_name), *buf, *start;
522 BC_SIG_ASSERT_LOCKED;
524 if (env_args == NULL) return;
526 // Windows already allocates, so we don't need to.
528 start = buf = vm->env_args_buffer = bc_vm_strdup(env_args);
530 start = buf = vm->env_args_buffer = env_args;
535 // Create two buffers for parsing. These need to stay throughout the entire
536 // execution of bc, unfortunately, because of filenames that might be in
538 bc_vec_init(&vm->env_args, sizeof(char*), BC_DTOR_NONE);
539 bc_vec_push(&vm->env_args, &env_args_name);
541 // While we haven't reached the end of the args...
544 // If we don't have whitespace...
547 // If we have the start of a string...
548 if (*buf == '"' || *buf == '\'')
550 // Set stuff appropriately.
554 // Check for the empty string.
563 // Push the pointer to the args buffer.
564 bc_vec_push(&vm->env_args, &buf);
568 ((!instr && !isspace(*buf)) || (instr && *buf != instr)))
573 // If we did find the end of the string...
576 if (instr) instr = '\0';
583 else if (instr) bc_error(BC_ERR_FATAL_OPTION, 0, start);
585 // If we have whitespace, eat it.
589 // Make sure to push a NULL pointer at the end.
591 bc_vec_push(&vm->env_args, &buf);
593 // Parse the arguments.
594 bc_args((int) vm->env_args.len - 1, bc_vec_item(&vm->env_args, 0), false,
595 scale, ibase, obase);
599 * Gets the {B,D}C_LINE_LENGTH.
600 * @param var The environment variable to pull it from.
601 * @return The line length.
604 bc_vm_envLen(const char* var)
606 char* lenv = bc_vm_getenv(var);
607 size_t i, len = BC_NUM_PRINT_WIDTH;
610 // Return the default with none.
611 if (lenv == NULL) return len;
615 // Figure out if it's a number.
616 for (num = 1, i = 0; num && i < len; ++i)
618 num = isdigit(lenv[i]);
621 // If it is a number...
624 // Parse it and clamp it if needed.
625 len = (size_t) atoi(lenv) - 1;
626 if (len == 1 || len >= UINT16_MAX) len = BC_NUM_PRINT_WIDTH;
629 else len = BC_NUM_PRINT_WIDTH;
631 bc_vm_getenvFree(lenv);
635 #endif // BC_ENABLE_LIBRARY
640 BC_SIG_ASSERT_LOCKED;
643 if (vm->catalog != BC_VM_INVALID_CATALOG) catclose(vm->catalog);
644 #endif // BC_ENABLE_NLS
646 #if BC_ENABLE_HISTORY
647 // This must always run to ensure that the terminal is back to normal, i.e.,
648 // has raw mode disabled. But we should only do it if we did not have a bad
649 // terminal because history was not initialized if it is a bad terminal.
650 if (BC_TTY && !vm->history.badTerm) bc_history_free(&vm->history);
651 #endif // BC_ENABLE_HISTORY
654 #if !BC_ENABLE_LIBRARY
655 bc_vec_free(&vm->env_args);
656 free(vm->env_args_buffer);
657 bc_vec_free(&vm->files);
658 bc_vec_free(&vm->exprs);
660 if (BC_PARSE_IS_INITED(&vm->read_prs, &vm->prog))
662 bc_vec_free(&vm->read_buf);
663 bc_parse_free(&vm->read_prs);
666 bc_parse_free(&vm->prs);
667 bc_program_free(&vm->prog);
669 bc_slabvec_free(&vm->slabs);
670 #endif // !BC_ENABLE_LIBRARY
675 #if !BC_ENABLE_LIBRARY
676 // We always want to flush.
677 bc_file_free(&vm->fout);
678 bc_file_free(&vm->ferr);
679 #endif // !BC_ENABLE_LIBRARY
683 bc_vm_addTemp(BcDig* num)
685 #if BC_ENABLE_LIBRARY
686 BcVm* vm = bcl_getspecific();
687 #endif // BC_ENABLE_LIBRARY
689 BC_SIG_ASSERT_LOCKED;
691 // If we don't have room, just free.
692 if (vm->temps_len == BC_VM_MAX_TEMPS) free(num);
695 // Add to the buffer and length.
696 vm->temps_buf[vm->temps_len] = num;
704 #if BC_ENABLE_LIBRARY
705 BcVm* vm = bcl_getspecific();
706 #endif // BC_ENABLE_LIBRARY
708 BC_SIG_ASSERT_LOCKED;
710 if (!vm->temps_len) return NULL;
714 return vm->temps_buf[vm->temps_len];
720 #if BC_ENABLE_LIBRARY
721 BcVm* vm = bcl_getspecific();
722 #endif // BC_ENABLE_LIBRARY
724 BC_SIG_ASSERT_LOCKED;
726 if (!vm->temps_len) return NULL;
728 return vm->temps_buf[vm->temps_len - 1];
732 bc_vm_freeTemps(void)
735 #if BC_ENABLE_LIBRARY
736 BcVm* vm = bcl_getspecific();
737 #endif // BC_ENABLE_LIBRARY
739 BC_SIG_ASSERT_LOCKED;
741 if (!vm->temps_len) return;
744 for (i = 0; i < vm->temps_len; ++i)
746 free(vm->temps_buf[i]);
752 #if !BC_ENABLE_LIBRARY
755 bc_vm_numDigits(size_t val)
769 #endif // !BC_ENABLE_LIBRARY
772 bc_vm_arraySize(size_t n, size_t size)
774 size_t res = n * size;
776 if (BC_ERR(BC_VM_MUL_OVERFLOW(n, size, res)))
778 bc_vm_fatalError(BC_ERR_FATAL_ALLOC_ERR);
785 bc_vm_growSize(size_t a, size_t b)
789 if (BC_ERR(res >= SIZE_MAX || res < a))
791 bc_vm_fatalError(BC_ERR_FATAL_ALLOC_ERR);
798 bc_vm_malloc(size_t n)
802 BC_SIG_ASSERT_LOCKED;
806 if (BC_ERR(ptr == NULL))
812 if (BC_ERR(ptr == NULL)) bc_vm_fatalError(BC_ERR_FATAL_ALLOC_ERR);
819 bc_vm_realloc(void* ptr, size_t n)
823 BC_SIG_ASSERT_LOCKED;
825 temp = realloc(ptr, n);
827 if (BC_ERR(temp == NULL))
831 temp = realloc(ptr, n);
833 if (BC_ERR(temp == NULL)) bc_vm_fatalError(BC_ERR_FATAL_ALLOC_ERR);
840 bc_vm_strdup(const char* str)
844 BC_SIG_ASSERT_LOCKED;
848 if (BC_ERR(s == NULL))
854 if (BC_ERR(s == NULL)) bc_vm_fatalError(BC_ERR_FATAL_ALLOC_ERR);
860 #if !BC_ENABLE_LIBRARY
862 bc_vm_printf(const char* fmt, ...)
865 #if BC_ENABLE_LIBRARY
866 BcVm* vm = bcl_getspecific();
867 #else // BC_ENABLE_LIBRARY
869 #endif // BC_ENABLE_LIBRARY
871 BC_SIG_TRYLOCK(lock);
874 bc_file_vprintf(&vm->fout, fmt, args);
879 BC_SIG_TRYUNLOCK(lock);
881 #endif // !BC_ENABLE_LIBRARY
884 bc_vm_putchar(int c, BcFlushType type)
886 #if BC_ENABLE_LIBRARY
887 BcVm* vm = bcl_getspecific();
888 bc_vec_pushByte(&vm->out, (uchar) c);
889 #else // BC_ENABLE_LIBRARY
890 bc_file_putchar(&vm->fout, type, (uchar) c);
891 vm->nchars = (c == '\n' ? 0 : vm->nchars + 1);
892 #endif // BC_ENABLE_LIBRARY
895 #if !BC_ENABLE_LIBRARY
900 * Aborts with a message. This should never be called because I have carefully
901 * made sure that the calls to pledge() and unveil() are correct, but it's here
903 * @param msg The message to print.
905 BC_NORETURN static void
906 bc_abortm(const char* msg)
908 bc_file_puts(&vm->ferr, bc_flush_none, msg);
909 bc_file_puts(&vm->ferr, bc_flush_none, "; this is a bug");
910 bc_file_flush(&vm->ferr, bc_flush_none);
915 bc_pledge(const char* promises, const char* execpromises)
917 int r = pledge(promises, execpromises);
918 if (r) bc_abortm("pledge() failed");
921 #if BC_ENABLE_EXTRA_MATH
924 * A convenience and portability function for OpenBSD's unveil().
925 * @param path The path.
926 * @param permissions The permissions for the path.
929 bc_unveil(const char* path, const char* permissions)
931 int r = unveil(path, permissions);
932 if (r) bc_abortm("unveil() failed");
935 #endif // BC_ENABLE_EXTRA_MATH
940 bc_pledge(const char* promises, const char* execpromises)
943 BC_UNUSED(execpromises);
946 #if BC_ENABLE_EXTRA_MATH
948 bc_unveil(const char* path, const char* permissions)
951 BC_UNUSED(permissions);
953 #endif // BC_ENABLE_EXTRA_MATH
955 #endif // __OpenBSD__
958 * Cleans unneeded variables, arrays, functions, strings, and constants when
959 * done executing a line of stdin. This is to prevent memory usage growing
960 * without bound. This is an idea from busybox.
965 BcVec* fns = &vm->prog.fns;
966 BcFunc* f = bc_vec_item(fns, BC_PROG_MAIN);
967 BcInstPtr* ip = bc_vec_item(&vm->prog.stack, 0);
968 bool good = ((vm->status && vm->status != BC_STATUS_QUIT) || vm->sig != 0);
970 BC_SIG_ASSERT_LOCKED;
972 // If all is good, go ahead and reset.
973 if (good) bc_program_reset(&vm->prog);
976 // bc has this extra condition. If it not satisfied, it is in the middle of
978 if (good && BC_IS_BC) good = !BC_PARSE_NO_EXEC(&vm->prs);
982 // For dc, it is safe only when all of the results on the results stack are
983 // safe, which means that they are temporaries or other things that don't
984 // need strings or constants.
991 for (i = 0; good && i < vm->prog.results.len; ++i)
993 BcResult* r = (BcResult*) bc_vec_item(&vm->prog.results, i);
994 good = BC_VM_SAFE_RESULT(r);
999 // If this condition is true, we can get rid of strings,
1000 // constants, and code.
1001 if (good && vm->prog.stack.len == 1 && ip->idx == f->code.len)
1003 // XXX: Nothing can be popped in dc. Deal with it.
1008 // XXX: you cannot delete strings, functions, or constants in bc.
1010 bc_vec_popAll(&f->labels);
1012 #endif // BC_ENABLED
1014 bc_vec_popAll(&f->code);
1021 * Process a bunch of text.
1022 * @param text The text to process.
1023 * @param mode The mode to process in.
1026 bc_vm_process(const char* text, BcMode mode)
1028 // Set up the parser.
1029 bc_parse_text(&vm->prs, text, mode);
1031 while (vm->prs.l.t != BC_LEX_EOF)
1033 // Parsing requires a signal lock. We also don't parse everything; we
1034 // want to execute as soon as possible for *everything*.
1036 vm->parse(&vm->prs);
1039 // Execute if possible.
1040 if (BC_IS_DC || !BC_PARSE_NO_EXEC(&vm->prs)) bc_program_exec(&vm->prog);
1042 assert(BC_IS_DC || vm->prog.results.len == 0);
1044 // Flush in interactive mode.
1045 if (BC_I) bc_file_flush(&vm->fout, bc_flush_save);
1052 * Ends a series of if statements. This is to ensure that full parses happen
1053 * when a file finishes or stdin has no more data. Without this, bc thinks that
1054 * it cannot parse any further. But if we reach the end of a file or stdin has
1055 * no more data, we know we can add an empty else clause.
1060 bc_parse_endif(&vm->prs);
1061 bc_program_exec(&vm->prog);
1064 #endif // BC_ENABLED
1068 * @param file The filename.
1071 bc_vm_file(const char* file)
1074 #if BC_ENABLE_LIBRARY
1075 BcVm* vm = bcl_getspecific();
1076 #endif // BC_ENABLE_LIBRARY
1078 assert(!vm->sig_pop);
1080 vm->mode = BC_MODE_FILE;
1082 // Set up the lexer.
1083 bc_lex_file(&vm->prs.l, file);
1088 data = bc_read_file(file);
1090 assert(data != NULL);
1092 BC_SETJMP_LOCKED(vm, err);
1097 bc_vm_process(data, BC_MODE_FILE);
1100 // Make sure to end any open if statements.
1101 if (BC_IS_BC) bc_vm_endif();
1102 #endif // BC_ENABLED
1112 // bc_program_reset(), called by bc_vm_clean(), resets the status.
1113 // We want it to clear the sig_pop variable in case it was set.
1114 if (vm->status == (sig_atomic_t) BC_STATUS_SUCCESS) BC_LONGJMP_STOP;
1116 BC_LONGJMP_CONT(vm);
1120 bc_vm_readLine(bool clear)
1125 BC_SIG_ASSERT_NOT_LOCKED;
1127 // Clear the buffer if desired.
1128 if (clear) bc_vec_empty(&vm->buffer);
1130 // Empty the line buffer.
1131 bc_vec_empty(&vm->line_buf);
1133 if (vm->eof) return false;
1137 // bc_read_line() must always return either BC_STATUS_SUCCESS or
1138 // BC_STATUS_EOF. Everything else, it and whatever it calls, must jump
1140 s = bc_read_line(&vm->line_buf, ">>> ");
1141 vm->eof = (s == BC_STATUS_EOF);
1143 while (s == BC_STATUS_SUCCESS && !vm->eof && vm->line_buf.len < 1);
1145 good = (vm->line_buf.len > 1);
1147 // Concat if we found something.
1148 if (good) bc_vec_concat(&vm->buffer, vm->line_buf.v);
1154 * Processes text from stdin.
1161 #if BC_ENABLE_LIBRARY
1162 BcVm* vm = bcl_getspecific();
1163 #endif // BC_ENABLE_LIBRARY
1166 vm->mode = BC_MODE_STDIN;
1168 // Set up the lexer.
1169 bc_lex_file(&vm->prs.l, bc_program_stdin_name);
1171 // These are global so that the lexers can access them, but they are
1172 // allocated and freed in this function because they should only be used for
1173 // stdin and expressions (they are used in bc_vm_exprs() as well). So they
1174 // are tied to this function, really. Well, this and bc_vm_readLine(). These
1175 // are the reasons that we have vm->is_stdin to tell the lexers if we are
1176 // reading from stdin. Well, both lexers care. And the reason they care is
1177 // so that if a comment or a string goes across multiple lines, the lexer
1178 // can request more data from stdin until the comment or string is ended.
1180 bc_vec_init(&vm->buffer, sizeof(uchar), BC_DTOR_NONE);
1181 bc_vec_init(&vm->line_buf, sizeof(uchar), BC_DTOR_NONE);
1182 BC_SETJMP_LOCKED(vm, err);
1185 // This label exists because errors can cause jumps to end up at the err label
1186 // below. If that happens, and the error should be cleared and execution
1187 // continue, then we need to jump back.
1190 // While we still read data from stdin.
1191 while (bc_vm_readLine(clear))
1193 size_t len = vm->buffer.len - 1;
1194 const char* str = vm->buffer.v;
1196 // We don't want to clear the buffer when the line ends with a backslash
1197 // because a backslash newline is special in bc.
1198 clear = (len < 2 || str[len - 2] != '\\' || str[len - 1] != '\n');
1199 if (!clear) continue;
1201 // Process the data.
1202 bc_vm_process(vm->buffer.v, BC_MODE_STDIN);
1214 // End the if statements.
1215 if (BC_IS_BC) bc_vm_endif();
1216 #endif // BC_ENABLED
1225 #if !BC_ENABLE_MEMCHECK
1226 assert(vm->status != BC_STATUS_ERROR_FATAL);
1228 vm->status = vm->status == BC_STATUS_QUIT || !BC_I ? vm->status :
1230 #else // !BC_ENABLE_MEMCHECK
1231 vm->status = vm->status == BC_STATUS_ERROR_FATAL ||
1232 vm->status == BC_STATUS_QUIT || !BC_I ?
1235 #endif // !BC_ENABLE_MEMCHECK
1237 if (!vm->status && !vm->eof)
1239 bc_vec_empty(&vm->buffer);
1246 // Since these are tied to this function, free them here. We only free in
1247 // debug mode because stdin is always the last thing read.
1248 bc_vec_free(&vm->line_buf);
1249 bc_vec_free(&vm->buffer);
1252 BC_LONGJMP_CONT(vm);
1256 bc_vm_readBuf(bool clear)
1258 size_t len = vm->exprs.len - 1;
1261 BC_SIG_ASSERT_NOT_LOCKED;
1263 // Clear the buffer if desired.
1264 if (clear) bc_vec_empty(&vm->buffer);
1266 // We want to pop the nul byte off because that's what bc_read_buf()
1268 bc_vec_pop(&vm->buffer);
1270 // Read one line of expressions.
1271 more = bc_read_buf(&vm->buffer, vm->exprs.v, &len);
1272 bc_vec_pushByte(&vm->buffer, '\0');
1282 #if BC_ENABLE_LIBRARY
1283 BcVm* vm = bcl_getspecific();
1284 #endif // BC_ENABLE_LIBRARY
1287 vm->mode = BC_MODE_EXPRS;
1289 // Prepare the lexer.
1290 bc_lex_file(&vm->prs.l, bc_program_exprs_name);
1292 // We initialize this so that the lexer can access it in the case that it
1293 // needs more data for expressions, such as for a multiline string or
1294 // comment. See the comment on the allocation of vm->buffer above in
1295 // bc_vm_stdin() for more information.
1297 bc_vec_init(&vm->buffer, sizeof(uchar), BC_DTOR_NONE);
1298 BC_SETJMP_LOCKED(vm, err);
1301 while (bc_vm_readBuf(clear))
1303 size_t len = vm->buffer.len - 1;
1304 const char* str = vm->buffer.v;
1306 // We don't want to clear the buffer when the line ends with a backslash
1307 // because a backslash newline is special in bc.
1308 clear = (len < 2 || str[len - 2] != '\\' || str[len - 1] != '\n');
1309 if (!clear) continue;
1311 // Process the data.
1312 bc_vm_process(vm->buffer.v, BC_MODE_EXPRS);
1315 // If we were not supposed to clear, then we should process everything. This
1316 // makes sure that errors get reported.
1317 if (!clear) bc_vm_process(vm->buffer.v, BC_MODE_EXPRS);
1326 // bc_program_reset(), called by bc_vm_clean(), resets the status.
1327 // We want it to clear the sig_pop variable in case it was set.
1328 if (vm->status == (sig_atomic_t) BC_STATUS_SUCCESS) BC_LONGJMP_STOP;
1330 // Since this is tied to this function, free it here. We always free it here
1331 // because bc_vm_stdin() may or may not use it later.
1332 bc_vec_free(&vm->buffer);
1334 BC_LONGJMP_CONT(vm);
1340 * Loads a math library.
1341 * @param name The name of the library.
1342 * @param text The text of the source code.
1345 bc_vm_load(const char* name, const char* text)
1347 bc_lex_file(&vm->prs.l, name);
1348 bc_parse_text(&vm->prs, text, BC_MODE_FILE);
1352 while (vm->prs.l.t != BC_LEX_EOF)
1354 vm->parse(&vm->prs);
1360 #endif // BC_ENABLED
1363 * Loads the default error messages.
1366 bc_vm_defaultMsgs(void)
1370 // Load the error categories.
1371 for (i = 0; i < BC_ERR_IDX_NELEMS + BC_ENABLED; ++i)
1373 vm->err_ids[i] = bc_errs[i];
1376 // Load the error messages.
1377 for (i = 0; i < BC_ERR_NELEMS; ++i)
1379 vm->err_msgs[i] = bc_err_msgs[i];
1384 * Loads the error messages for the locale. If NLS is disabled, this just loads
1385 * the default messages.
1395 // If no locale, load the defaults.
1396 if (vm->locale == NULL)
1398 vm->catalog = BC_VM_INVALID_CATALOG;
1399 bc_vm_defaultMsgs();
1403 vm->catalog = catopen(BC_MAINEXEC, NL_CAT_LOCALE);
1405 // If no catalog, load the defaults.
1406 if (vm->catalog == BC_VM_INVALID_CATALOG)
1408 bc_vm_defaultMsgs();
1412 // Load the error categories.
1413 for (set = 1; msg <= BC_ERR_IDX_NELEMS + BC_ENABLED; ++msg)
1415 vm->err_ids[msg - 1] = catgets(vm->catalog, set, msg, bc_errs[msg - 1]);
1421 // Load the error messages. In order to understand this loop, you must know
1422 // the order of messages and categories in the enum and in the locale files.
1423 for (set = id + 2, msg = 1; i < BC_ERR_NELEMS; ++i, ++msg)
1425 if (id != bc_err_ids[i])
1432 vm->err_msgs[i] = catgets(vm->catalog, set, msg, bc_err_msgs[i]);
1434 #else // BC_ENABLE_NLS
1435 bc_vm_defaultMsgs();
1436 #endif // BC_ENABLE_NLS
1440 * Starts execution. Really, this is a function of historical accident; it could
1441 * probably be combined with bc_vm_boot(), but I don't care enough. Really, this
1442 * function starts when execution of bc or dc source code starts.
1449 bool has_file = false;
1450 #endif // DC_ENABLED
1453 // Load the math libraries.
1454 if (BC_IS_BC && (vm->flags & BC_FLAG_L))
1456 // Can't allow redefinitions in the builtin library.
1457 vm->no_redefine = true;
1459 bc_vm_load(bc_lib_name, bc_lib);
1461 #if BC_ENABLE_EXTRA_MATH
1462 if (!BC_IS_POSIX) bc_vm_load(bc_lib2_name, bc_lib2);
1463 #endif // BC_ENABLE_EXTRA_MATH
1465 // Make sure to clear this.
1466 vm->no_redefine = false;
1468 // Execute to ensure that all is hunky dory. Without this, scale can be
1470 bc_program_exec(&vm->prog);
1472 #endif // BC_ENABLED
1474 // If there are expressions to execute...
1477 // Process the expressions.
1480 // Sometimes, executing expressions means we need to quit.
1481 if (!vm->no_exprs && vm->exit_exprs && BC_EXPR_EXIT) return;
1485 for (i = 0; i < vm->files.len; ++i)
1487 char* path = *((char**) bc_vec_item(&vm->files, i));
1488 if (!strcmp(path, "")) continue;
1491 #endif // DC_ENABLED
1495 #if BC_ENABLE_EXTRA_MATH
1496 // These are needed for the pseudo-random number generator.
1497 bc_unveil("/dev/urandom", "r");
1498 bc_unveil("/dev/random", "r");
1499 bc_unveil(NULL, NULL);
1500 #endif // BC_ENABLE_EXTRA_MATH
1502 #if BC_ENABLE_HISTORY
1504 // We need to keep tty if history is enabled, and we need to keep rpath for
1505 // the times when we read from /dev/urandom.
1506 if (BC_TTY && !vm->history.badTerm) bc_pledge(bc_pledge_end_history, NULL);
1508 #endif // BC_ENABLE_HISTORY
1510 bc_pledge(bc_pledge_end, NULL);
1514 // This is the thing that makes fuzzing with AFL++ so fast. If you move this
1515 // back, you won't cause any problems, but fuzzing will slow down. If you
1516 // move this forward, you won't fuzz anything because you will be skipping
1517 // the reading from stdin.
1519 #endif // BC_ENABLE_AFL
1521 // Execute from stdin. bc always does.
1522 if (BC_VM_RUN_STDIN(has_file)) bc_vm_stdin();
1526 bc_vm_boot(int argc, char* argv[])
1528 int ttyin, ttyout, ttyerr;
1530 const char* const env_len = BC_VM_LINE_LENGTH_STR;
1531 const char* const env_args = BC_VM_ENV_ARGS_STR;
1532 const char* const env_exit = BC_VM_EXPR_EXIT_STR;
1533 const char* const env_clamp = BC_VM_DIGIT_CLAMP_STR;
1534 int env_exit_def = BC_VM_EXPR_EXIT_DEF;
1535 int env_clamp_def = BC_VM_DIGIT_CLAMP_DEF;
1536 BcBigDig scale = BC_NUM_BIGDIG_MAX;
1537 BcBigDig env_scale = BC_NUM_BIGDIG_MAX;
1538 BcBigDig ibase = BC_NUM_BIGDIG_MAX;
1539 BcBigDig env_ibase = BC_NUM_BIGDIG_MAX;
1540 BcBigDig obase = BC_NUM_BIGDIG_MAX;
1541 BcBigDig env_obase = BC_NUM_BIGDIG_MAX;
1543 // We need to know which of stdin, stdout, and stderr are tty's.
1544 ttyin = isatty(STDIN_FILENO);
1545 ttyout = isatty(STDOUT_FILENO);
1546 ttyerr = isatty(STDERR_FILENO);
1547 tty = (ttyin != 0 && ttyout != 0 && ttyerr != 0);
1549 vm->flags |= ttyin ? BC_FLAG_TTYIN : 0;
1550 vm->flags |= tty ? BC_FLAG_TTY : 0;
1551 vm->flags |= ttyin && ttyout ? BC_FLAG_I : 0;
1556 // Initialize some vm stuff. This is separate to make things easier for the
1560 // Explicitly set this in case NULL isn't all zeroes.
1563 // Set the error messages.
1566 #if BC_ENABLE_LINE_LIB
1568 // Initialize the output file buffers.
1569 bc_file_init(&vm->ferr, stderr);
1570 bc_file_init(&vm->fout, stdout);
1572 // Set the input buffer.
1573 vm->buf = output_bufs;
1575 #else // BC_ENABLE_LINE_LIB
1577 // Initialize the output file buffers. They each take portions of the global
1578 // buffer. stdout gets more because it will probably have more data.
1579 bc_file_init(&vm->ferr, STDERR_FILENO, output_bufs + BC_VM_STDOUT_BUF_SIZE,
1580 BC_VM_STDERR_BUF_SIZE);
1581 bc_file_init(&vm->fout, STDOUT_FILENO, output_bufs, BC_VM_STDOUT_BUF_SIZE);
1583 // Set the input buffer to the rest of the global buffer.
1584 vm->buf = output_bufs + BC_VM_STDOUT_BUF_SIZE + BC_VM_STDERR_BUF_SIZE;
1585 #endif // BC_ENABLE_LINE_LIB
1587 // Set the line length by environment variable.
1588 vm->line_len = (uint16_t) bc_vm_envLen(env_len);
1590 bc_vm_setenvFlag(env_exit, env_exit_def, BC_FLAG_EXPR_EXIT);
1591 bc_vm_setenvFlag(env_clamp, env_clamp_def, BC_FLAG_DIGIT_CLAMP);
1593 // Clear the files and expressions vectors, just in case. This marks them as
1595 bc_vec_clear(&vm->files);
1596 bc_vec_clear(&vm->exprs);
1598 #if !BC_ENABLE_LIBRARY
1600 // Initialize the slab vector.
1601 bc_slabvec_init(&vm->slabs);
1603 #endif // !BC_ENABLE_LIBRARY
1605 // Initialize the program and main parser. These have to be in this order
1606 // because the program has to be initialized first, since a pointer to it is
1607 // passed to the parser.
1608 bc_program_init(&vm->prog);
1609 bc_parse_init(&vm->prs, &vm->prog, BC_PROG_MAIN);
1612 vm->flags |= BC_TTY ? BC_FLAG_P | BC_FLAG_R : 0;
1613 vm->flags |= BC_I ? BC_FLAG_Q : 0;
1618 // bc checks this environment variable to see if it should run in
1620 char* var = bc_vm_getenv("POSIXLY_CORRECT");
1622 vm->flags |= BC_FLAG_S * (var != NULL);
1623 bc_vm_getenvFree(var);
1625 // Set whether we print the banner or not.
1626 if (BC_I) bc_vm_setenvFlag("BC_BANNER", BC_DEFAULT_BANNER, BC_FLAG_Q);
1628 #endif // BC_ENABLED
1630 // Are we in TTY mode?
1633 const char* const env_tty = BC_VM_TTY_MODE_STR;
1634 int env_tty_def = BC_VM_TTY_MODE_DEF;
1635 const char* const env_prompt = BC_VM_PROMPT_STR;
1636 int env_prompt_def = BC_VM_PROMPT_DEF;
1638 // Set flags for TTY mode and prompt.
1639 bc_vm_setenvFlag(env_tty, env_tty_def, BC_FLAG_TTY);
1640 bc_vm_setenvFlag(env_prompt, tty ? env_prompt_def : 0, BC_FLAG_P);
1642 #if BC_ENABLE_HISTORY
1643 // If TTY mode is used, activate history.
1644 if (BC_TTY) bc_history_init(&vm->history);
1645 #endif // BC_ENABLE_HISTORY
1648 // Process environment and command-line arguments.
1649 bc_vm_envArgs(env_args, &env_scale, &env_ibase, &env_obase);
1650 bc_args(argc, argv, true, &scale, &ibase, &obase);
1652 // This section is here because we don't want the math library to stomp on
1653 // the user's given value for scale. And we don't want ibase affecting how
1654 // the scale is interpreted. Also, it's sectioned off just for this comment.
1658 scale = scale == BC_NUM_BIGDIG_MAX ? env_scale : scale;
1660 // Assign the library value only if it is used and no value was set.
1661 scale = scale == BC_NUM_BIGDIG_MAX && BC_L ? 20 : scale;
1662 #endif // BC_ENABLED
1663 obase = obase == BC_NUM_BIGDIG_MAX ? env_obase : obase;
1664 ibase = ibase == BC_NUM_BIGDIG_MAX ? env_ibase : ibase;
1666 if (scale != BC_NUM_BIGDIG_MAX)
1668 bc_program_assignBuiltin(&vm->prog, true, false, scale);
1671 if (obase != BC_NUM_BIGDIG_MAX)
1673 bc_program_assignBuiltin(&vm->prog, false, true, obase);
1676 // This is last to avoid it affecting the value of the others.
1677 if (ibase != BC_NUM_BIGDIG_MAX)
1679 bc_program_assignBuiltin(&vm->prog, false, false, ibase);
1685 // If we are in interactive mode...
1688 const char* const env_sigint = BC_VM_SIGINT_RESET_STR;
1689 int env_sigint_def = BC_VM_SIGINT_RESET_DEF;
1691 // Set whether we reset on SIGINT or not.
1692 bc_vm_setenvFlag(env_sigint, env_sigint_def, BC_FLAG_SIGINT);
1696 // Disable global stacks in POSIX mode.
1697 if (BC_IS_POSIX) vm->flags &= ~(BC_FLAG_G);
1699 // Print the banner if allowed. We have to be in bc, in interactive mode,
1700 // and not be quieted by command-line option or environment variable.
1701 if (BC_IS_BC && BC_I && (vm->flags & BC_FLAG_Q))
1704 bc_file_putchar(&vm->fout, bc_flush_none, '\n');
1705 bc_file_flush(&vm->fout, bc_flush_none);
1707 #endif // BC_ENABLED
1714 #endif // !BC_ENABLE_LIBRARY
1719 #if BC_ENABLE_LIBRARY
1720 BcVm* vm = bcl_getspecific();
1721 #endif // BC_ENABLE_LIBRARY
1723 BC_SIG_ASSERT_LOCKED;
1725 #if !BC_ENABLE_LIBRARY
1726 // Set up the constant zero.
1727 bc_num_setup(&vm->zero, vm->zero_num, BC_VM_ONE_CAP);
1728 #endif // !BC_ENABLE_LIBRARY
1730 // Set up more constant BcNum's.
1731 bc_num_setup(&vm->one, vm->one_num, BC_VM_ONE_CAP);
1732 bc_num_one(&vm->one);
1734 // Set up more constant BcNum's.
1736 memcpy(vm->max_num, bc_num_bigdigMax,
1737 bc_num_bigdigMax_size * sizeof(BcDig));
1739 memcpy(vm->max2_num, bc_num_bigdigMax2,
1740 bc_num_bigdigMax2_size * sizeof(BcDig));
1741 bc_num_setup(&vm->max, vm->max_num, BC_NUM_BIGDIG_LOG10);
1742 bc_num_setup(&vm->max2, vm->max2_num, BC_NUM_BIGDIG_LOG10);
1743 vm->max.len = bc_num_bigdigMax_size;
1744 vm->max2.len = bc_num_bigdigMax2_size;
1746 // Set up the maxes for the globals.
1747 vm->maxes[BC_PROG_GLOBALS_IBASE] = BC_NUM_MAX_POSIX_IBASE;
1748 vm->maxes[BC_PROG_GLOBALS_OBASE] = BC_MAX_OBASE;
1749 vm->maxes[BC_PROG_GLOBALS_SCALE] = BC_MAX_SCALE;
1751 #if BC_ENABLE_EXTRA_MATH
1752 vm->maxes[BC_PROG_MAX_RAND] = ((BcRand) 0) - 1;
1753 #endif // BC_ENABLE_EXTRA_MATH
1756 #if !BC_ENABLE_LIBRARY
1757 // bc has a higher max ibase when it's not in POSIX mode.
1758 if (BC_IS_BC && !BC_IS_POSIX)
1759 #endif // !BC_ENABLE_LIBRARY
1761 vm->maxes[BC_PROG_GLOBALS_IBASE] = BC_NUM_MAX_IBASE;
1763 #endif // BC_ENABLED
1766 #if BC_ENABLE_LIBRARY
1771 #if BC_ENABLE_LIBRARY
1772 BcVm* vm = bcl_getspecific();
1773 #endif // BC_ENABLE_LIBRARY
1779 bc_vec_free(&vm->jmp_bufs);
1782 #else // BC_ENABLE_LIBRARY
1784 bc_vm_atexit(int status)
1786 // Set the status correctly.
1787 int s = BC_STATUS_IS_ERROR(status) ? status : BC_STATUS_SUCCESS;
1792 bc_vec_free(&vm->jmp_bufs);
1797 #endif // BC_ENABLE_LIBRARY