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);
134 			el_resize(vm->history.el);
138 			if (vm->sig == SIGWINCH)
140 				vm->sig = 0;
149 	if (vm->status == (sig_atomic_t) BC_STATUS_QUIT || vm->sig != 0)
151 		if (!BC_I || sig != SIGINT) vm->status = BC_STATUS_QUIT;
156 	vm->sig = sig;
167 			vm->status = BC_STATUS_ERROR_FATAL;
172 		if (write(STDOUT_FILENO, vm->sigmsg, vm->siglen) !=
173 		    (ssize_t) vm->siglen)
175 			vm->status = BC_STATUS_ERROR_FATAL;
185 			vm->status = BC_STATUS_ERROR_FATAL;
190 		vm->status = BC_STATUS_QUIT;
202 	assert(vm->jmp_bufs.len);
206 	if (!vm->sig_lock) BC_JMP;
260 	bc_file_printf(&vm->fout, "%s %s\n%s", vm->name, BC_VERSION, bc_copyright);
265 		bc_file_putchar(&vm->fout, bc_flush_none, '\n');
282 			bc_file_printf(&vm->fout, help, vm->name, vm->name, BC_VERSION,
302 			bc_file_printf(&vm->fout, help, vm->name, vm->name, BC_VERSION,
309 	bc_file_flush(&vm->fout, bc_flush_none);
333 	BcVm* vm = bcl_getspecific();  local
337 	assert(!vm->sig_pop);
345 		vm->err = (BclError) (e - BC_ERR_MATH_NEGATIVE +
349 	else if (vm->abrt) abort();
350 	else if (e == BC_ERR_FATAL_ALLOC_ERR) vm->err = BCL_ERROR_FATAL_ALLOC_ERR;
351 	else vm->err = BCL_ERROR_FATAL_UNKNOWN_ERR;
368 	const char* err_type = vm->err_ids[id];
372 	assert(!vm->sig_pop);
382 			err_type = vm->err_ids[BC_ERR_IDX_WARN];
391 	fout_s = bc_file_flushErr(&vm->fout, bc_flush_err);
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);
404 	if (BC_NO_ERR(vm->file != NULL))
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);
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");
436 		bc_file_putchar(&vm->ferr, bc_flush_none, '\n');
437 		bc_file_puts(&vm->ferr, bc_flush_none,
438 		             vm->err_ids[bc_err_ids[BC_ERR_FATAL_IO_ERR]]);
439 		bc_file_putchar(&vm->ferr, bc_flush_none, ' ');
440 		bc_file_puts(&vm->ferr, bc_flush_none,
441 		             vm->err_msgs[BC_ERR_FATAL_IO_ERR]);
444 	s = bc_file_flushErr(&vm->ferr, bc_flush_err);
460 		vm->status = (sig_atomic_t) fout_s;
464 		vm->status = (sig_atomic_t) s;
469 		vm->status = (sig_atomic_t) (uchar) (id + 1);
473 	if (BC_ERR(vm->status)) BC_JMP;
517 		if (def) vm->flags |= flag;
518 		else vm->flags &= ~(flag);
521 	else if (strtoul(val, NULL, 0)) vm->flags |= flag;
522 	else vm->flags &= ~(flag);
550 	start = buf = vm->env_args_buffer = bc_vm_strdup(env_args);
552 	start = buf = vm->env_args_buffer = env_args;
560 	bc_vec_init(&vm->env_args, sizeof(char*), BC_DTOR_NONE);
561 	bc_vec_push(&vm->env_args, &env_args_name);
586 			bc_vec_push(&vm->env_args, &buf);
613 	bc_vec_push(&vm->env_args, &buf);
616 	bc_args((int) vm->env_args.len - 1, bc_vec_item(&vm->env_args, 0), false,
669 	if (vm->catalog != BC_VM_INVALID_CATALOG) catclose(vm->catalog);
677 	if (BC_TTY && !vm->history.badTerm) bc_history_free(&vm->history);
683 	bc_vec_free(&vm->env_args);
684 	free(vm->env_args_buffer);
685 	bc_vec_free(&vm->files);
686 	bc_vec_free(&vm->exprs);
688 	if (BC_PARSE_IS_INITED(&vm->read_prs, &vm->prog))
690 		bc_vec_free(&vm->read_buf);
691 		bc_parse_free(&vm->read_prs);
694 	bc_parse_free(&vm->prs);
695 	bc_program_free(&vm->prog);
697 	bc_slabvec_free(&vm->slabs);
705 	bc_file_free(&vm->fout);
706 	bc_file_free(&vm->ferr);
714 	BcVm* vm = bcl_getspecific();  local
720 	if (vm->temps_len == BC_VM_MAX_TEMPS) free(num);
724 		vm->temps_buf[vm->temps_len] = num;
725 		vm->temps_len += 1;
733 	BcVm* vm = bcl_getspecific();  local
738 	if (!vm->temps_len) return NULL;
740 	vm->temps_len -= 1;
742 	return vm->temps_buf[vm->temps_len];
749 	BcVm* vm = bcl_getspecific();  local
754 	if (!vm->temps_len) return NULL;
756 	return vm->temps_buf[vm->temps_len - 1];
764 	BcVm* vm = bcl_getspecific();  local
769 	if (!vm->temps_len) return;
772 	for (i = 0; i < vm->temps_len; ++i)
774 		free(vm->temps_buf[i]);
777 	vm->temps_len = 0;
894 	BcVm* vm = bcl_getspecific();  local
902 	bc_file_vprintf(&vm->fout, fmt, args);
905 	vm->nchars = 0;
915 	BcVm* vm = bcl_getspecific();  local
916 	bc_vec_pushByte(&vm->out, (uchar) c);
918 	bc_file_putchar(&vm->fout, type, (uchar) c);
919 	vm->nchars = (c == '\n' ? 0 : vm->nchars + 1);
936 	bc_file_puts(&vm->ferr, bc_flush_none, msg);
937 	bc_file_puts(&vm->ferr, bc_flush_none, "; this is a bug");
938 	bc_file_flush(&vm->ferr, bc_flush_none);
993 	BcVec* fns = &vm->prog.fns;
995 	BcInstPtr* ip = bc_vec_item(&vm->prog.stack, 0);
996 	bool good = ((vm->status && vm->status != BC_STATUS_QUIT) || vm->sig != 0);
1001 	if (good) bc_program_reset(&vm->prog);
1006 	if (good && BC_IS_BC) good = !BC_PARSE_NO_EXEC(&vm->prs);
1019 		for (i = 0; good && i < vm->prog.results.len; ++i)
1021 			BcResult* r = (BcResult*) bc_vec_item(&vm->prog.results, i);
1029 	if (good && vm->prog.stack.len == 1 && ip->idx == f->code.len)
1057 	bc_parse_text(&vm->prs, text, mode);
1059 	while (vm->prs.l.t != BC_LEX_EOF)
1064 		vm->parse(&vm->prs);
1068 		if (BC_IS_DC || !BC_PARSE_NO_EXEC(&vm->prs)) bc_program_exec(&vm->prog);
1070 		assert(BC_IS_DC || vm->prog.results.len == 0);
1073 		if (BC_I) bc_file_flush(&vm->fout, bc_flush_save);
1088 	bc_parse_endif(&vm->prs);
1089 	bc_program_exec(&vm->prog);
1103 	BcVm* vm = bcl_getspecific();  local
1106 	assert(!vm->sig_pop);
1108 	vm->mode = BC_MODE_FILE;
1111 	bc_lex_file(&vm->prs.l, file);
1120 	BC_SETJMP_LOCKED(vm, err);
1142 	if (vm->status == (sig_atomic_t) BC_STATUS_SUCCESS) BC_LONGJMP_STOP;
1144 	BC_LONGJMP_CONT(vm);
1158 	if (clear) bc_vec_empty(&vm->buffer);
1161 	bc_vec_empty(&vm->line_buf);
1163 	if (vm->eof) return false;
1170 		s = bc_read_line(&vm->line_buf, ">>> ");
1171 		vm->eof = (s == BC_STATUS_EOF);
1173 	while (s == BC_STATUS_SUCCESS && !vm->eof && vm->line_buf.len < 1);
1175 	good = (vm->line_buf.len > 1);
1178 	if (good) bc_vec_concat(&vm->buffer, vm->line_buf.v);
1192 	BcVm* vm = bcl_getspecific();  local
1196 	vm->mode = BC_MODE_STDIN;
1199 	bc_lex_file(&vm->prs.l, bc_program_stdin_name);
1205 	// are the reasons that we have vm->is_stdin to tell the lexers if we are
1210 	bc_vec_init(&vm->buffer, sizeof(uchar), BC_DTOR_NONE);
1211 	bc_vec_init(&vm->line_buf, sizeof(uchar), BC_DTOR_NONE);
1212 	BC_SETJMP_LOCKED(vm, err);
1223 		size_t len = vm->buffer.len - 1;
1224 		const char* str = vm->buffer.v;
1232 		bc_vm_process(vm->buffer.v, BC_MODE_STDIN);
1234 		if (vm->eof) break;
1256 	assert(vm->status != BC_STATUS_ERROR_FATAL);
1258 	vm->status = vm->status == BC_STATUS_QUIT || !BC_I ? vm->status :
1261 	vm->status = vm->status == BC_STATUS_ERROR_FATAL ||
1262 	                     vm->status == BC_STATUS_QUIT || !BC_I ?
1263 	                 vm->status :
1267 	if (!vm->status && !vm->eof)
1269 		bc_vec_empty(&vm->buffer);
1278 	bc_vec_free(&vm->line_buf);
1279 	bc_vec_free(&vm->buffer);
1282 	BC_LONGJMP_CONT(vm);
1290 	size_t len = vm->exprs.len - 1;
1296 	if (clear) bc_vec_empty(&vm->buffer);
1300 	bc_vec_pop(&vm->buffer);
1303 	more = bc_read_buf(&vm->buffer, vm->exprs.v, &len);
1304 	bc_vec_pushByte(&vm->buffer, '\0');
1315 	BcVm* vm = bcl_getspecific();  local
1319 	vm->mode = BC_MODE_EXPRS;
1322 	bc_lex_file(&vm->prs.l, bc_program_exprs_name);
1326 	// comment. See the comment on the allocation of vm->buffer above in
1329 	bc_vec_init(&vm->buffer, sizeof(uchar), BC_DTOR_NONE);
1330 	BC_SETJMP_LOCKED(vm, err);
1335 		size_t len = vm->buffer.len - 1;
1336 		const char* str = vm->buffer.v;
1344 		bc_vm_process(vm->buffer.v, BC_MODE_EXPRS);
1349 	if (!clear) bc_vm_process(vm->buffer.v, BC_MODE_EXPRS);
1360 	if (vm->status == (sig_atomic_t) BC_STATUS_SUCCESS) BC_LONGJMP_STOP;
1364 	bc_vec_free(&vm->buffer);
1366 	BC_LONGJMP_CONT(vm);
1379 	bc_lex_file(&vm->prs.l, name);
1380 	bc_parse_text(&vm->prs, text, BC_MODE_FILE);
1384 	while (vm->prs.l.t != BC_LEX_EOF)
1386 		vm->parse(&vm->prs);
1405 		vm->err_ids[i] = bc_errs[i];
1411 		vm->err_msgs[i] = bc_err_msgs[i];
1428 	if (vm->locale == NULL)
1430 		vm->catalog = BC_VM_INVALID_CATALOG;
1435 	vm->catalog = catopen(BC_MAINEXEC, NL_CAT_LOCALE);
1438 	if (vm->catalog == BC_VM_INVALID_CATALOG)
1447 		vm->err_ids[msg - 1] = catgets(vm->catalog, set, msg, bc_errs[msg - 1]);
1464 		vm->err_msgs[i] = catgets(vm->catalog, set, msg, bc_err_msgs[i]);
1486 	if (BC_IS_BC && (vm->flags & BC_FLAG_L))
1489 		vm->no_redefine = true;
1498 		vm->no_redefine = false;
1502 		bc_program_exec(&vm->prog);
1509 	if (vm->exprs.len)
1515 		if (vm->status != BC_STATUS_SUCCESS ||
1516 		    (!vm->no_exprs && vm->exit_exprs && BC_EXPR_EXIT))
1523 	for (i = 0; i < vm->files.len; ++i)
1525 		char* path = *((char**) bc_vec_item(&vm->files, i));
1532 		if (vm->status != BC_STATUS_SUCCESS) return;
1546 	if (BC_TTY && !vm->history.badTerm) bc_pledge(bc_pledge_end_history, NULL);
1602 	vm->flags |= ttyin ? BC_FLAG_TTYIN : 0;
1603 	vm->flags |= tty ? BC_FLAG_TTY : 0;
1604 	vm->flags |= ttyin && ttyout ? BC_FLAG_I : 0;
1609 	// Initialize some vm stuff. This is separate to make things easier for the
1614 	vm->file = NULL;
1622 	bc_file_init(&vm->ferr, stderr, true);
1623 	bc_file_init(&vm->fout, stdout, false);
1626 	vm->buf = output_bufs;
1632 	bc_file_init(&vm->ferr, STDERR_FILENO, output_bufs + BC_VM_STDOUT_BUF_SIZE,
1634 	bc_file_init(&vm->fout, STDOUT_FILENO, output_bufs, BC_VM_STDOUT_BUF_SIZE,
1638 	vm->buf = output_bufs + BC_VM_STDOUT_BUF_SIZE + BC_VM_STDERR_BUF_SIZE;
1642 	vm->line_len = (uint16_t) bc_vm_envLen(env_len);
1649 	bc_vec_clear(&vm->files);
1650 	bc_vec_clear(&vm->exprs);
1655 	bc_slabvec_init(&vm->slabs);
1662 	bc_program_init(&vm->prog);
1663 	bc_parse_init(&vm->prs, &vm->prog, BC_PROG_MAIN);
1666 	vm->flags |= BC_TTY ? BC_FLAG_P | BC_FLAG_R : 0;
1667 	vm->flags |= BC_I ? BC_FLAG_Q : 0;
1676 		vm->flags |= BC_FLAG_S * (var != NULL);
1698 		if (BC_TTY) bc_history_init(&vm->history);
1722 			bc_program_assignBuiltin(&vm->prog, true, false, scale);
1727 			bc_program_assignBuiltin(&vm->prog, false, true, obase);
1733 			bc_program_assignBuiltin(&vm->prog, false, false, ibase);
1751 	if (BC_IS_POSIX) vm->flags &= ~(BC_FLAG_G);
1755 	if (BC_IS_BC && BC_I && (vm->flags & BC_FLAG_Q))
1758 		bc_file_putchar(&vm->fout, bc_flush_none, '\n');
1759 		bc_file_flush(&vm->fout, bc_flush_none);
1771 	return (BcStatus) vm->status;
1779 	BcVm* vm = bcl_getspecific();  local
1786 	bc_num_setup(&vm->zero, vm->zero_num, BC_VM_ONE_CAP);
1790 	bc_num_setup(&vm->one, vm->one_num, BC_VM_ONE_CAP);
1791 	bc_num_one(&vm->one);
1795 	memcpy(vm->max_num, bc_num_bigdigMax,
1798 	memcpy(vm->max2_num, bc_num_bigdigMax2,
1800 	bc_num_setup(&vm->max, vm->max_num, BC_NUM_BIGDIG_LOG10);
1801 	bc_num_setup(&vm->max2, vm->max2_num, BC_NUM_BIGDIG_LOG10);
1802 	vm->max.len = bc_num_bigdigMax_size;
1803 	vm->max2.len = bc_num_bigdigMax2_size;
1806 	vm->maxes[BC_PROG_GLOBALS_IBASE] = BC_NUM_MAX_POSIX_IBASE;
1807 	vm->maxes[BC_PROG_GLOBALS_OBASE] = BC_MAX_OBASE;
1808 	vm->maxes[BC_PROG_GLOBALS_SCALE] = BC_MAX_SCALE;
1811 	vm->maxes[BC_PROG_MAX_RAND] = ((BcRand) 0) - 1;
1820 		vm->maxes[BC_PROG_GLOBALS_IBASE] = BC_NUM_MAX_IBASE;
1831 	BcVm* vm = bcl_getspecific();  local
1838 	bc_vec_free(&vm->jmp_bufs);
1851 	bc_vec_free(&vm->jmp_bufs);