63 #include <vm.h>
78 BcVm* vm = &vm_data;  variable
93 	BcVm* vm = bcl_getspecific();  local
96 	assert(BC_SIG_EXC(vm));
101 	bc_file_puts(&vm->ferr, bc_flush_none, "Longjmp: ");
102 	bc_file_puts(&vm->ferr, bc_flush_none, f);
103 	bc_file_putchar(&vm->ferr, bc_flush_none, '\n');
104 	bc_file_flush(&vm->ferr, bc_flush_none);
108 	assert(vm->jmp_bufs.len - (size_t) vm->sig_pop);
111 	if (vm->jmp_bufs.len == 0) abort();
112 	if (vm->sig_pop) bc_vec_pop(&vm->jmp_bufs);
113 	else vm->sig_pop = 1;
115 	siglongjmp(*((sigjmp_buf*) bc_vec_top(&vm->jmp_bufs)), 1);
128 	if (vm->status == (sig_atomic_t) BC_STATUS_QUIT || vm->sig != 0)
130 		if (!BC_I || sig != SIGINT) vm->status = BC_STATUS_QUIT;
135 	vm->sig = sig;
146 			vm->status = BC_STATUS_ERROR_FATAL;
151 		if (write(STDOUT_FILENO, vm->sigmsg, vm->siglen) !=
152 		    (ssize_t) vm->siglen)
154 			vm->status = BC_STATUS_ERROR_FATAL;
164 			vm->status = BC_STATUS_ERROR_FATAL;
169 		vm->status = BC_STATUS_QUIT;
181 	assert(vm->jmp_bufs.len);
185 	if (!vm->sig_lock) BC_JMP;
234 	bc_file_printf(&vm->fout, "%s %s\n%s", vm->name, BC_VERSION, bc_copyright);
239 		bc_file_putchar(&vm->fout, bc_flush_none, '\n');
256 			bc_file_printf(&vm->fout, help, vm->name, vm->name, BC_VERSION,
276 			bc_file_printf(&vm->fout, help, vm->name, vm->name, BC_VERSION,
283 	bc_file_flush(&vm->fout, bc_flush_none);
307 	BcVm* vm = bcl_getspecific();  local
311 	assert(!vm->sig_pop);
319 		vm->err = (BclError) (e - BC_ERR_MATH_NEGATIVE +
323 	else if (vm->abrt) abort();
324 	else if (e == BC_ERR_FATAL_ALLOC_ERR) vm->err = BCL_ERROR_FATAL_ALLOC_ERR;
325 	else vm->err = BCL_ERROR_FATAL_UNKNOWN_ERR;
342 	const char* err_type = vm->err_ids[id];
346 	assert(!vm->sig_pop);
356 			err_type = vm->err_ids[BC_ERR_IDX_WARN];
365 	fout_s = bc_file_flushErr(&vm->fout, bc_flush_err);
371 	bc_file_putchar(&vm->ferr, bc_flush_none, '\n');
372 	bc_file_puts(&vm->ferr, bc_flush_none, err_type);
373 	bc_file_putchar(&vm->ferr, bc_flush_none, ' ');
374 	bc_file_vprintf(&vm->ferr, vm->err_msgs[e], args);
378 	if (BC_NO_ERR(vm->file != NULL))
384 			bc_file_puts(&vm->ferr, bc_flush_none, "\n    ");
385 			bc_file_puts(&vm->ferr, bc_flush_none, vm->file);
386 			bc_file_printf(&vm->ferr, ":%zu\n", line);
391 			bc_file_putchar(&vm->ferr, bc_flush_none, '\n');
392 			bc_program_printStackTrace(&vm->prog);
397 		bc_file_putchar(&vm->ferr, bc_flush_none, '\n');
401 	bc_file_printf(&vm->ferr, "\n    %s:%d\n", file, fline);
404 	bc_file_puts(&vm->ferr, bc_flush_none, "\n");
410 		bc_file_putchar(&vm->ferr, bc_flush_none, '\n');
411 		bc_file_puts(&vm->ferr, bc_flush_none,
412 		             vm->err_ids[bc_err_ids[BC_ERR_FATAL_IO_ERR]]);
413 		bc_file_putchar(&vm->ferr, bc_flush_none, ' ');
414 		bc_file_puts(&vm->ferr, bc_flush_none,
415 		             vm->err_msgs[BC_ERR_FATAL_IO_ERR]);
418 	s = bc_file_flushErr(&vm->ferr, bc_flush_err);
434 		vm->status = (sig_atomic_t) fout_s;
438 		vm->status = (sig_atomic_t) s;
443 		vm->status = (sig_atomic_t) (uchar) (id + 1);
447 	if (BC_ERR(vm->status)) BC_JMP;
491 		if (def) vm->flags |= flag;
492 		else vm->flags &= ~(flag);
495 	else if (strtoul(val, NULL, 0)) vm->flags |= flag;
496 	else vm->flags &= ~(flag);
524 	start = buf = vm->env_args_buffer = bc_vm_strdup(env_args);
526 	start = buf = vm->env_args_buffer = env_args;
534 	bc_vec_init(&vm->env_args, sizeof(char*), BC_DTOR_NONE);
535 	bc_vec_push(&vm->env_args, &env_args_name);
560 			bc_vec_push(&vm->env_args, &buf);
587 	bc_vec_push(&vm->env_args, &buf);
590 	bc_args((int) vm->env_args.len - 1, bc_vec_item(&vm->env_args, 0), false,
643 	if (vm->catalog != BC_VM_INVALID_CATALOG) catclose(vm->catalog);
651 	if (BC_TTY && !vm->history.badTerm) bc_history_free(&vm->history);
657 	bc_vec_free(&vm->env_args);
658 	free(vm->env_args_buffer);
659 	bc_vec_free(&vm->files);
660 	bc_vec_free(&vm->exprs);
662 	if (BC_PARSE_IS_INITED(&vm->read_prs, &vm->prog))
664 		bc_vec_free(&vm->read_buf);
665 		bc_parse_free(&vm->read_prs);
668 	bc_parse_free(&vm->prs);
669 	bc_program_free(&vm->prog);
671 	bc_slabvec_free(&vm->slabs);
679 	bc_file_free(&vm->fout);
680 	bc_file_free(&vm->ferr);
688 	BcVm* vm = bcl_getspecific();  local
694 	if (vm->temps_len == BC_VM_MAX_TEMPS) free(num);
698 		vm->temps_buf[vm->temps_len] = num;
699 		vm->temps_len += 1;
707 	BcVm* vm = bcl_getspecific();  local
712 	if (!vm->temps_len) return NULL;
714 	vm->temps_len -= 1;
716 	return vm->temps_buf[vm->temps_len];
723 	BcVm* vm = bcl_getspecific();  local
728 	if (!vm->temps_len) return NULL;
730 	return vm->temps_buf[vm->temps_len - 1];
738 	BcVm* vm = bcl_getspecific();  local
743 	if (!vm->temps_len) return;
746 	for (i = 0; i < vm->temps_len; ++i)
748 		free(vm->temps_buf[i]);
751 	vm->temps_len = 0;
868 	BcVm* vm = bcl_getspecific();  local
876 	bc_file_vprintf(&vm->fout, fmt, args);
879 	vm->nchars = 0;
889 	BcVm* vm = bcl_getspecific();  local
890 	bc_vec_pushByte(&vm->out, (uchar) c);
892 	bc_file_putchar(&vm->fout, type, (uchar) c);
893 	vm->nchars = (c == '\n' ? 0 : vm->nchars + 1);
910 	bc_file_puts(&vm->ferr, bc_flush_none, msg);
911 	bc_file_puts(&vm->ferr, bc_flush_none, "; this is a bug");
912 	bc_file_flush(&vm->ferr, bc_flush_none);
967 	BcVec* fns = &vm->prog.fns;
969 	BcInstPtr* ip = bc_vec_item(&vm->prog.stack, 0);
970 	bool good = ((vm->status && vm->status != BC_STATUS_QUIT) || vm->sig != 0);
975 	if (good) bc_program_reset(&vm->prog);
980 	if (good && BC_IS_BC) good = !BC_PARSE_NO_EXEC(&vm->prs);
993 		for (i = 0; good && i < vm->prog.results.len; ++i)
995 			BcResult* r = (BcResult*) bc_vec_item(&vm->prog.results, i);
1003 	if (good && vm->prog.stack.len == 1 && ip->idx == f->code.len)
1031 	bc_parse_text(&vm->prs, text, mode);
1033 	while (vm->prs.l.t != BC_LEX_EOF)
1038 		vm->parse(&vm->prs);
1042 		if (BC_IS_DC || !BC_PARSE_NO_EXEC(&vm->prs)) bc_program_exec(&vm->prog);
1044 		assert(BC_IS_DC || vm->prog.results.len == 0);
1047 		if (BC_I) bc_file_flush(&vm->fout, bc_flush_save);
1062 	bc_parse_endif(&vm->prs);
1063 	bc_program_exec(&vm->prog);
1077 	BcVm* vm = bcl_getspecific();  local
1080 	assert(!vm->sig_pop);
1082 	vm->mode = BC_MODE_FILE;
1085 	bc_lex_file(&vm->prs.l, file);
1094 	BC_SETJMP_LOCKED(vm, err);
1116 	if (vm->status == (sig_atomic_t) BC_STATUS_SUCCESS) BC_LONGJMP_STOP;
1118 	BC_LONGJMP_CONT(vm);
1132 	if (clear) bc_vec_empty(&vm->buffer);
1135 	bc_vec_empty(&vm->line_buf);
1137 	if (vm->eof) return false;
1144 		s = bc_read_line(&vm->line_buf, ">>> ");
1145 		vm->eof = (s == BC_STATUS_EOF);
1147 	while (s == BC_STATUS_SUCCESS && !vm->eof && vm->line_buf.len < 1);
1149 	good = (vm->line_buf.len > 1);
1152 	if (good) bc_vec_concat(&vm->buffer, vm->line_buf.v);
1166 	BcVm* vm = bcl_getspecific();  local
1170 	vm->mode = BC_MODE_STDIN;
1173 	bc_lex_file(&vm->prs.l, bc_program_stdin_name);
1179 	// are the reasons that we have vm->is_stdin to tell the lexers if we are
1184 	bc_vec_init(&vm->buffer, sizeof(uchar), BC_DTOR_NONE);
1185 	bc_vec_init(&vm->line_buf, sizeof(uchar), BC_DTOR_NONE);
1186 	BC_SETJMP_LOCKED(vm, err);
1197 		size_t len = vm->buffer.len - 1;
1198 		const char* str = vm->buffer.v;
1206 		bc_vm_process(vm->buffer.v, BC_MODE_STDIN);
1208 		if (vm->eof) break;
1230 	assert(vm->status != BC_STATUS_ERROR_FATAL);
1232 	vm->status = vm->status == BC_STATUS_QUIT || !BC_I ? vm->status :
1235 	vm->status = vm->status == BC_STATUS_ERROR_FATAL ||
1236 	                     vm->status == BC_STATUS_QUIT || !BC_I ?
1237 	                 vm->status :
1241 	if (!vm->status && !vm->eof)
1243 		bc_vec_empty(&vm->buffer);
1252 	bc_vec_free(&vm->line_buf);
1253 	bc_vec_free(&vm->buffer);
1256 	BC_LONGJMP_CONT(vm);
1264 	size_t len = vm->exprs.len - 1;
1270 	if (clear) bc_vec_empty(&vm->buffer);
1274 	bc_vec_pop(&vm->buffer);
1277 	more = bc_read_buf(&vm->buffer, vm->exprs.v, &len);
1278 	bc_vec_pushByte(&vm->buffer, '\0');
1289 	BcVm* vm = bcl_getspecific();  local
1293 	vm->mode = BC_MODE_EXPRS;
1296 	bc_lex_file(&vm->prs.l, bc_program_exprs_name);
1300 	// comment. See the comment on the allocation of vm->buffer above in
1303 	bc_vec_init(&vm->buffer, sizeof(uchar), BC_DTOR_NONE);
1304 	BC_SETJMP_LOCKED(vm, err);
1309 		size_t len = vm->buffer.len - 1;
1310 		const char* str = vm->buffer.v;
1318 		bc_vm_process(vm->buffer.v, BC_MODE_EXPRS);
1323 	if (!clear) bc_vm_process(vm->buffer.v, BC_MODE_EXPRS);
1334 	if (vm->status == (sig_atomic_t) BC_STATUS_SUCCESS) BC_LONGJMP_STOP;
1338 	bc_vec_free(&vm->buffer);
1340 	BC_LONGJMP_CONT(vm);
1353 	bc_lex_file(&vm->prs.l, name);
1354 	bc_parse_text(&vm->prs, text, BC_MODE_FILE);
1358 	while (vm->prs.l.t != BC_LEX_EOF)
1360 		vm->parse(&vm->prs);
1379 		vm->err_ids[i] = bc_errs[i];
1385 		vm->err_msgs[i] = bc_err_msgs[i];
1402 	if (vm->locale == NULL)
1404 		vm->catalog = BC_VM_INVALID_CATALOG;
1409 	vm->catalog = catopen(BC_MAINEXEC, NL_CAT_LOCALE);
1412 	if (vm->catalog == BC_VM_INVALID_CATALOG)
1421 		vm->err_ids[msg - 1] = catgets(vm->catalog, set, msg, bc_errs[msg - 1]);
1438 		vm->err_msgs[i] = catgets(vm->catalog, set, msg, bc_err_msgs[i]);
1460 	if (BC_IS_BC && (vm->flags & BC_FLAG_L))
1463 		vm->no_redefine = true;
1472 		vm->no_redefine = false;
1476 		bc_program_exec(&vm->prog);
1483 	if (vm->exprs.len)
1489 		if (vm->status != BC_STATUS_SUCCESS ||
1490 		    (!vm->no_exprs && vm->exit_exprs && BC_EXPR_EXIT))
1497 	for (i = 0; i < vm->files.len; ++i)
1499 		char* path = *((char**) bc_vec_item(&vm->files, i));
1506 		if (vm->status != BC_STATUS_SUCCESS) return;
1520 	if (BC_TTY && !vm->history.badTerm) bc_pledge(bc_pledge_end_history, NULL);
1576 	vm->flags |= ttyin ? BC_FLAG_TTYIN : 0;
1577 	vm->flags |= tty ? BC_FLAG_TTY : 0;
1578 	vm->flags |= ttyin && ttyout ? BC_FLAG_I : 0;
1583 	// Initialize some vm stuff. This is separate to make things easier for the
1588 	vm->file = NULL;
1596 	bc_file_init(&vm->ferr, stderr, true);
1597 	bc_file_init(&vm->fout, stdout, false);
1600 	vm->buf = output_bufs;
1606 	bc_file_init(&vm->ferr, STDERR_FILENO, output_bufs + BC_VM_STDOUT_BUF_SIZE,
1608 	bc_file_init(&vm->fout, STDOUT_FILENO, output_bufs, BC_VM_STDOUT_BUF_SIZE,
1612 	vm->buf = output_bufs + BC_VM_STDOUT_BUF_SIZE + BC_VM_STDERR_BUF_SIZE;
1616 	vm->line_len = (uint16_t) bc_vm_envLen(env_len);
1623 	bc_vec_clear(&vm->files);
1624 	bc_vec_clear(&vm->exprs);
1629 	bc_slabvec_init(&vm->slabs);
1636 	bc_program_init(&vm->prog);
1637 	bc_parse_init(&vm->prs, &vm->prog, BC_PROG_MAIN);
1640 	vm->flags |= BC_TTY ? BC_FLAG_P | BC_FLAG_R : 0;
1641 	vm->flags |= BC_I ? BC_FLAG_Q : 0;
1650 		vm->flags |= BC_FLAG_S * (var != NULL);
1672 		if (BC_TTY) bc_history_init(&vm->history);
1696 			bc_program_assignBuiltin(&vm->prog, true, false, scale);
1701 			bc_program_assignBuiltin(&vm->prog, false, true, obase);
1707 			bc_program_assignBuiltin(&vm->prog, false, false, ibase);
1725 	if (BC_IS_POSIX) vm->flags &= ~(BC_FLAG_G);
1729 	if (BC_IS_BC && BC_I && (vm->flags & BC_FLAG_Q))
1732 		bc_file_putchar(&vm->fout, bc_flush_none, '\n');
1733 		bc_file_flush(&vm->fout, bc_flush_none);
1745 	return (BcStatus) vm->status;
1753 	BcVm* vm = bcl_getspecific();  local
1760 	bc_num_setup(&vm->zero, vm->zero_num, BC_VM_ONE_CAP);
1764 	bc_num_setup(&vm->one, vm->one_num, BC_VM_ONE_CAP);
1765 	bc_num_one(&vm->one);
1769 	memcpy(vm->max_num, bc_num_bigdigMax,
1772 	memcpy(vm->max2_num, bc_num_bigdigMax2,
1774 	bc_num_setup(&vm->max, vm->max_num, BC_NUM_BIGDIG_LOG10);
1775 	bc_num_setup(&vm->max2, vm->max2_num, BC_NUM_BIGDIG_LOG10);
1776 	vm->max.len = bc_num_bigdigMax_size;
1777 	vm->max2.len = bc_num_bigdigMax2_size;
1780 	vm->maxes[BC_PROG_GLOBALS_IBASE] = BC_NUM_MAX_POSIX_IBASE;
1781 	vm->maxes[BC_PROG_GLOBALS_OBASE] = BC_MAX_OBASE;
1782 	vm->maxes[BC_PROG_GLOBALS_SCALE] = BC_MAX_SCALE;
1785 	vm->maxes[BC_PROG_MAX_RAND] = ((BcRand) 0) - 1;
1794 		vm->maxes[BC_PROG_GLOBALS_IBASE] = BC_NUM_MAX_IBASE;
1805 	BcVm* vm = bcl_getspecific();  local
1812 	bc_vec_free(&vm->jmp_bufs);
1825 	bc_vec_free(&vm->jmp_bufs);