Lines Matching full:vm
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;
259 bc_file_printf(&vm->fout, "%s %s\n%s", vm->name, BC_VERSION, bc_copyright);
264 bc_file_putchar(&vm->fout, bc_flush_none, '\n');
281 bc_file_printf(&vm->fout, help, vm->name, vm->name, BC_VERSION,
301 bc_file_printf(&vm->fout, help, vm->name, vm->name, BC_VERSION,
308 bc_file_flush(&vm->fout, bc_flush_none);
332 BcVm* vm = bcl_getspecific(); local
336 assert(!vm->sig_pop);
344 vm->err = (BclError) (e - BC_ERR_MATH_NEGATIVE +
348 else if (vm->abrt) abort();
349 else if (e == BC_ERR_FATAL_ALLOC_ERR) vm->err = BCL_ERROR_FATAL_ALLOC_ERR;
350 else vm->err = BCL_ERROR_FATAL_UNKNOWN_ERR;
367 const char* err_type = vm->err_ids[id];
371 assert(!vm->sig_pop);
381 err_type = vm->err_ids[BC_ERR_IDX_WARN];
390 fout_s = bc_file_flushErr(&vm->fout, bc_flush_err);
396 bc_file_putchar(&vm->ferr, bc_flush_none, '\n');
397 bc_file_puts(&vm->ferr, bc_flush_none, err_type);
398 bc_file_putchar(&vm->ferr, bc_flush_none, ' ');
399 bc_file_vprintf(&vm->ferr, vm->err_msgs[e], args);
403 if (BC_NO_ERR(vm->file != NULL))
409 bc_file_puts(&vm->ferr, bc_flush_none, "\n ");
410 bc_file_puts(&vm->ferr, bc_flush_none, vm->file);
411 bc_file_printf(&vm->ferr, ":%zu\n", line);
416 bc_file_putchar(&vm->ferr, bc_flush_none, '\n');
417 bc_program_printStackTrace(&vm->prog);
422 bc_file_putchar(&vm->ferr, bc_flush_none, '\n');
426 bc_file_printf(&vm->ferr, "\n %s:%d\n", file, fline);
429 bc_file_puts(&vm->ferr, bc_flush_none, "\n");
435 bc_file_putchar(&vm->ferr, bc_flush_none, '\n');
436 bc_file_puts(&vm->ferr, bc_flush_none,
437 vm->err_ids[bc_err_ids[BC_ERR_FATAL_IO_ERR]]);
438 bc_file_putchar(&vm->ferr, bc_flush_none, ' ');
439 bc_file_puts(&vm->ferr, bc_flush_none,
440 vm->err_msgs[BC_ERR_FATAL_IO_ERR]);
443 s = bc_file_flushErr(&vm->ferr, bc_flush_err);
459 vm->status = (sig_atomic_t) fout_s;
463 vm->status = (sig_atomic_t) s;
468 vm->status = (sig_atomic_t) (uchar) (id + 1);
472 if (BC_ERR(vm->status)) BC_JMP;
516 if (def) vm->flags |= flag;
517 else vm->flags &= ~(flag);
520 else if (strtoul(val, NULL, 0)) vm->flags |= flag;
521 else vm->flags &= ~(flag);
549 start = buf = vm->env_args_buffer = bc_vm_strdup(env_args);
551 start = buf = vm->env_args_buffer = env_args;
559 bc_vec_init(&vm->env_args, sizeof(char*), BC_DTOR_NONE);
560 bc_vec_push(&vm->env_args, &env_args_name);
585 bc_vec_push(&vm->env_args, &buf);
612 bc_vec_push(&vm->env_args, &buf);
615 bc_args((int) vm->env_args.len - 1, bc_vec_item(&vm->env_args, 0), false,
668 if (vm->catalog != BC_VM_INVALID_CATALOG) catclose(vm->catalog);
676 if (BC_TTY && !vm->history.badTerm) bc_history_free(&vm->history);
682 bc_vec_free(&vm->env_args);
683 free(vm->env_args_buffer);
684 bc_vec_free(&vm->files);
685 bc_vec_free(&vm->exprs);
687 if (BC_PARSE_IS_INITED(&vm->read_prs, &vm->prog))
689 bc_vec_free(&vm->read_buf);
690 bc_parse_free(&vm->read_prs);
693 bc_parse_free(&vm->prs);
694 bc_program_free(&vm->prog);
696 bc_slabvec_free(&vm->slabs);
704 bc_file_free(&vm->fout);
705 bc_file_free(&vm->ferr);
713 BcVm* vm = bcl_getspecific(); local
719 if (vm->temps_len == BC_VM_MAX_TEMPS) free(num);
723 vm->temps_buf[vm->temps_len] = num;
724 vm->temps_len += 1;
732 BcVm* vm = bcl_getspecific(); local
737 if (!vm->temps_len) return NULL;
739 vm->temps_len -= 1;
741 return vm->temps_buf[vm->temps_len];
748 BcVm* vm = bcl_getspecific(); local
753 if (!vm->temps_len) return NULL;
755 return vm->temps_buf[vm->temps_len - 1];
763 BcVm* vm = bcl_getspecific(); local
768 if (!vm->temps_len) return;
771 for (i = 0; i < vm->temps_len; ++i)
773 free(vm->temps_buf[i]);
776 vm->temps_len = 0;
893 BcVm* vm = bcl_getspecific(); local
901 bc_file_vprintf(&vm->fout, fmt, args);
904 vm->nchars = 0;
914 BcVm* vm = bcl_getspecific(); local
915 bc_vec_pushByte(&vm->out, (uchar) c);
917 bc_file_putchar(&vm->fout, type, (uchar) c);
918 vm->nchars = (c == '\n' ? 0 : vm->nchars + 1);
935 bc_file_puts(&vm->ferr, bc_flush_none, msg);
936 bc_file_puts(&vm->ferr, bc_flush_none, "; this is a bug");
937 bc_file_flush(&vm->ferr, bc_flush_none);
992 BcVec* fns = &vm->prog.fns;
994 BcInstPtr* ip = bc_vec_item(&vm->prog.stack, 0);
995 bool good = ((vm->status && vm->status != BC_STATUS_QUIT) || vm->sig != 0);
1000 if (good) bc_program_reset(&vm->prog);
1005 if (good && BC_IS_BC) good = !BC_PARSE_NO_EXEC(&vm->prs);
1018 for (i = 0; good && i < vm->prog.results.len; ++i)
1020 BcResult* r = (BcResult*) bc_vec_item(&vm->prog.results, i);
1028 if (good && vm->prog.stack.len == 1 && ip->idx == f->code.len)
1056 bc_parse_text(&vm->prs, text, mode);
1058 while (vm->prs.l.t != BC_LEX_EOF)
1063 vm->parse(&vm->prs);
1067 if (BC_IS_DC || !BC_PARSE_NO_EXEC(&vm->prs)) bc_program_exec(&vm->prog);
1069 assert(BC_IS_DC || vm->prog.results.len == 0);
1072 if (BC_I) bc_file_flush(&vm->fout, bc_flush_save);
1087 bc_parse_endif(&vm->prs);
1088 bc_program_exec(&vm->prog);
1102 BcVm* vm = bcl_getspecific(); local
1105 assert(!vm->sig_pop);
1107 vm->mode = BC_MODE_FILE;
1110 bc_lex_file(&vm->prs.l, file);
1119 BC_SETJMP_LOCKED(vm, err);
1141 if (vm->status == (sig_atomic_t) BC_STATUS_SUCCESS) BC_LONGJMP_STOP;
1143 BC_LONGJMP_CONT(vm);
1157 if (clear) bc_vec_empty(&vm->buffer);
1160 bc_vec_empty(&vm->line_buf);
1162 if (vm->eof) return false;
1169 s = bc_read_line(&vm->line_buf, ">>> ");
1170 vm->eof = (s == BC_STATUS_EOF);
1172 while (s == BC_STATUS_SUCCESS && !vm->eof && vm->line_buf.len < 1);
1174 good = (vm->line_buf.len > 1);
1177 if (good) bc_vec_concat(&vm->buffer, vm->line_buf.v);
1191 BcVm* vm = bcl_getspecific(); local
1195 vm->mode = BC_MODE_STDIN;
1198 bc_lex_file(&vm->prs.l, bc_program_stdin_name);
1204 // are the reasons that we have vm->is_stdin to tell the lexers if we are
1209 bc_vec_init(&vm->buffer, sizeof(uchar), BC_DTOR_NONE);
1210 bc_vec_init(&vm->line_buf, sizeof(uchar), BC_DTOR_NONE);
1211 BC_SETJMP_LOCKED(vm, err);
1222 size_t len = vm->buffer.len - 1;
1223 const char* str = vm->buffer.v;
1231 bc_vm_process(vm->buffer.v, BC_MODE_STDIN);
1233 if (vm->eof) break;
1255 assert(vm->status != BC_STATUS_ERROR_FATAL);
1257 vm->status = vm->status == BC_STATUS_QUIT || !BC_I ? vm->status :
1260 vm->status = vm->status == BC_STATUS_ERROR_FATAL ||
1261 vm->status == BC_STATUS_QUIT || !BC_I ?
1262 vm->status :
1266 if (!vm->status && !vm->eof)
1268 bc_vec_empty(&vm->buffer);
1277 bc_vec_free(&vm->line_buf);
1278 bc_vec_free(&vm->buffer);
1281 BC_LONGJMP_CONT(vm);
1289 size_t len = vm->exprs.len - 1;
1295 if (clear) bc_vec_empty(&vm->buffer);
1299 bc_vec_pop(&vm->buffer);
1302 more = bc_read_buf(&vm->buffer, vm->exprs.v, &len);
1303 bc_vec_pushByte(&vm->buffer, '\0');
1314 BcVm* vm = bcl_getspecific(); local
1318 vm->mode = BC_MODE_EXPRS;
1321 bc_lex_file(&vm->prs.l, bc_program_exprs_name);
1325 // comment. See the comment on the allocation of vm->buffer above in
1328 bc_vec_init(&vm->buffer, sizeof(uchar), BC_DTOR_NONE);
1329 BC_SETJMP_LOCKED(vm, err);
1334 size_t len = vm->buffer.len - 1;
1335 const char* str = vm->buffer.v;
1343 bc_vm_process(vm->buffer.v, BC_MODE_EXPRS);
1348 if (!clear) bc_vm_process(vm->buffer.v, BC_MODE_EXPRS);
1359 if (vm->status == (sig_atomic_t) BC_STATUS_SUCCESS) BC_LONGJMP_STOP;
1363 bc_vec_free(&vm->buffer);
1365 BC_LONGJMP_CONT(vm);
1378 bc_lex_file(&vm->prs.l, name);
1379 bc_parse_text(&vm->prs, text, BC_MODE_FILE);
1383 while (vm->prs.l.t != BC_LEX_EOF)
1385 vm->parse(&vm->prs);
1404 vm->err_ids[i] = bc_errs[i];
1410 vm->err_msgs[i] = bc_err_msgs[i];
1427 if (vm->locale == NULL)
1429 vm->catalog = BC_VM_INVALID_CATALOG;
1434 vm->catalog = catopen(BC_MAINEXEC, NL_CAT_LOCALE);
1437 if (vm->catalog == BC_VM_INVALID_CATALOG)
1446 vm->err_ids[msg - 1] = catgets(vm->catalog, set, msg, bc_errs[msg - 1]);
1463 vm->err_msgs[i] = catgets(vm->catalog, set, msg, bc_err_msgs[i]);
1485 if (BC_IS_BC && (vm->flags & BC_FLAG_L))
1488 vm->no_redefine = true;
1497 vm->no_redefine = false;
1501 bc_program_exec(&vm->prog);
1508 if (vm->exprs.len)
1514 if (vm->status != BC_STATUS_SUCCESS ||
1515 (!vm->no_exprs && vm->exit_exprs && BC_EXPR_EXIT))
1522 for (i = 0; i < vm->files.len; ++i)
1524 char* path = *((char**) bc_vec_item(&vm->files, i));
1531 if (vm->status != BC_STATUS_SUCCESS) return;
1545 if (BC_TTY && !vm->history.badTerm) bc_pledge(bc_pledge_end_history, NULL);
1601 vm->flags |= ttyin ? BC_FLAG_TTYIN : 0;
1602 vm->flags |= tty ? BC_FLAG_TTY : 0;
1603 vm->flags |= ttyin && ttyout ? BC_FLAG_I : 0;
1608 // Initialize some vm stuff. This is separate to make things easier for the
1613 vm->file = NULL;
1621 bc_file_init(&vm->ferr, stderr, true);
1622 bc_file_init(&vm->fout, stdout, false);
1625 vm->buf = output_bufs;
1631 bc_file_init(&vm->ferr, STDERR_FILENO, output_bufs + BC_VM_STDOUT_BUF_SIZE,
1633 bc_file_init(&vm->fout, STDOUT_FILENO, output_bufs, BC_VM_STDOUT_BUF_SIZE,
1637 vm->buf = output_bufs + BC_VM_STDOUT_BUF_SIZE + BC_VM_STDERR_BUF_SIZE;
1641 vm->line_len = (uint16_t) bc_vm_envLen(env_len);
1648 bc_vec_clear(&vm->files);
1649 bc_vec_clear(&vm->exprs);
1654 bc_slabvec_init(&vm->slabs);
1661 bc_program_init(&vm->prog);
1662 bc_parse_init(&vm->prs, &vm->prog, BC_PROG_MAIN);
1665 vm->flags |= BC_TTY ? BC_FLAG_P | BC_FLAG_R : 0;
1666 vm->flags |= BC_I ? BC_FLAG_Q : 0;
1675 vm->flags |= BC_FLAG_S * (var != NULL);
1697 if (BC_TTY) bc_history_init(&vm->history);
1721 bc_program_assignBuiltin(&vm->prog, true, false, scale);
1726 bc_program_assignBuiltin(&vm->prog, false, true, obase);
1732 bc_program_assignBuiltin(&vm->prog, false, false, ibase);
1750 if (BC_IS_POSIX) vm->flags &= ~(BC_FLAG_G);
1754 if (BC_IS_BC && BC_I && (vm->flags & BC_FLAG_Q))
1757 bc_file_putchar(&vm->fout, bc_flush_none, '\n');
1758 bc_file_flush(&vm->fout, bc_flush_none);
1770 return (BcStatus) vm->status;
1778 BcVm* vm = bcl_getspecific(); local
1785 bc_num_setup(&vm->zero, vm->zero_num, BC_VM_ONE_CAP);
1789 bc_num_setup(&vm->one, vm->one_num, BC_VM_ONE_CAP);
1790 bc_num_one(&vm->one);
1794 memcpy(vm->max_num, bc_num_bigdigMax,
1797 memcpy(vm->max2_num, bc_num_bigdigMax2,
1799 bc_num_setup(&vm->max, vm->max_num, BC_NUM_BIGDIG_LOG10);
1800 bc_num_setup(&vm->max2, vm->max2_num, BC_NUM_BIGDIG_LOG10);
1801 vm->max.len = bc_num_bigdigMax_size;
1802 vm->max2.len = bc_num_bigdigMax2_size;
1805 vm->maxes[BC_PROG_GLOBALS_IBASE] = BC_NUM_MAX_POSIX_IBASE;
1806 vm->maxes[BC_PROG_GLOBALS_OBASE] = BC_MAX_OBASE;
1807 vm->maxes[BC_PROG_GLOBALS_SCALE] = BC_MAX_SCALE;
1810 vm->maxes[BC_PROG_MAX_RAND] = ((BcRand) 0) - 1;
1819 vm->maxes[BC_PROG_GLOBALS_IBASE] = BC_NUM_MAX_IBASE;
1830 BcVm* vm = bcl_getspecific(); local
1837 bc_vec_free(&vm->jmp_bufs);
1850 bc_vec_free(&vm->jmp_bufs);