Gavin Howard | 6556eed | 2018-02-27 17:10:27 -0700 | [diff] [blame] | 1 | /* |
Gavin Howard | b5904bf | 2018-02-20 13:28:18 -0700 | [diff] [blame] | 2 | * ***************************************************************************** |
Gavin Howard | 5715b04 | 2018-02-12 16:11:42 -0700 | [diff] [blame] | 3 | * |
Gavin Howard | b5904bf | 2018-02-20 13:28:18 -0700 | [diff] [blame] | 4 | * Copyright 2018 Gavin D. Howard |
Gavin Howard | 5715b04 | 2018-02-12 16:11:42 -0700 | [diff] [blame] | 5 | * |
| 6 | * Permission to use, copy, modify, and/or distribute this software for any |
| 7 | * purpose with or without fee is hereby granted. |
| 8 | * |
| 9 | * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH |
| 10 | * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY |
| 11 | * AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, |
| 12 | * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM |
| 13 | * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR |
| 14 | * OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR |
| 15 | * PERFORMANCE OF THIS SOFTWARE. |
| 16 | * |
Gavin Howard | b5904bf | 2018-02-20 13:28:18 -0700 | [diff] [blame] | 17 | * ***************************************************************************** |
Gavin Howard | 5715b04 | 2018-02-12 16:11:42 -0700 | [diff] [blame] | 18 | * |
| 19 | * Code to execute bc programs. |
| 20 | * |
| 21 | */ |
| 22 | |
Gavin Howard | 27fdfb9 | 2018-03-21 07:56:59 -0600 | [diff] [blame] | 23 | #include <assert.h> |
Gavin Howard | 8a596d4 | 2018-01-15 15:46:01 -0700 | [diff] [blame] | 24 | #include <stdint.h> |
| 25 | #include <stdlib.h> |
| 26 | #include <string.h> |
| 27 | |
Gavin Howard | d525df8 | 2018-02-22 13:34:29 -0700 | [diff] [blame] | 28 | #include <limits.h> |
Gavin Howard | 82cdc6f | 2018-02-20 14:23:19 -0700 | [diff] [blame] | 29 | #include <unistd.h> |
Gavin Howard | 8a596d4 | 2018-01-15 15:46:01 -0700 | [diff] [blame] | 30 | |
Gavin Howard | 13ccc4a | 2018-02-15 14:09:41 -0700 | [diff] [blame] | 31 | #include <program.h> |
| 32 | #include <parse.h> |
Gavin Howard | 2949306 | 2018-03-20 19:57:37 -0600 | [diff] [blame] | 33 | #include <bc.h> |
Gavin Howard | 8a596d4 | 2018-01-15 15:46:01 -0700 | [diff] [blame] | 34 | |
Gavin Howard | 3f68df7 | 2018-03-22 20:30:27 -0600 | [diff] [blame] | 35 | BcStatus bc_program_search(BcProgram *p, BcResult *result, |
| 36 | BcNum **ret, uint8_t flags) |
Gavin Howard | 3affc80 | 2018-02-27 19:57:38 -0700 | [diff] [blame] | 37 | { |
| 38 | BcStatus status; |
Gavin Howard | 4b9bb2b | 2018-03-23 08:11:11 -0600 | [diff] [blame] | 39 | BcEntry entry, *entry_ptr; |
Gavin Howard | 3affc80 | 2018-02-27 19:57:38 -0700 | [diff] [blame] | 40 | BcVec *vec; |
| 41 | BcVecO *veco; |
Gavin Howard | 42d7c6d | 2018-03-20 14:09:01 -0600 | [diff] [blame] | 42 | size_t idx, ip_idx; |
Gavin Howard | 5732343 | 2018-03-14 20:06:35 -0600 | [diff] [blame] | 43 | BcAuto *a; |
Gavin Howard | e3c7c8e | 2018-03-23 08:15:46 -0600 | [diff] [blame] | 44 | int var; |
Gavin Howard | 3affc80 | 2018-02-27 19:57:38 -0700 | [diff] [blame] | 45 | |
Gavin Howard | 42d7c6d | 2018-03-20 14:09:01 -0600 | [diff] [blame] | 46 | for (ip_idx = 0; ip_idx < p->stack.len - 1; ++ip_idx) { |
Gavin Howard | 3affc80 | 2018-02-27 19:57:38 -0700 | [diff] [blame] | 47 | |
Gavin Howard | 97eb856 | 2018-03-21 08:04:29 -0600 | [diff] [blame] | 48 | BcFunc *func; |
| 49 | BcInstPtr *ip; |
| 50 | |
| 51 | ip = bc_vec_item_rev(&p->stack, ip_idx); |
Gavin Howard | 3affc80 | 2018-02-27 19:57:38 -0700 | [diff] [blame] | 52 | |
Gavin Howard | 27fdfb9 | 2018-03-21 07:56:59 -0600 | [diff] [blame] | 53 | assert(ip); |
Gavin Howard | 3affc80 | 2018-02-27 19:57:38 -0700 | [diff] [blame] | 54 | |
Gavin Howard | 42d7c6d | 2018-03-20 14:09:01 -0600 | [diff] [blame] | 55 | if (ip->func == BC_PROGRAM_READ || ip->func == BC_PROGRAM_MAIN) continue; |
Gavin Howard | 3affc80 | 2018-02-27 19:57:38 -0700 | [diff] [blame] | 56 | |
| 57 | func = bc_vec_item(&p->funcs, ip->func); |
| 58 | |
Gavin Howard | 27fdfb9 | 2018-03-21 07:56:59 -0600 | [diff] [blame] | 59 | assert(func); |
Gavin Howard | 3affc80 | 2018-02-27 19:57:38 -0700 | [diff] [blame] | 60 | |
Gavin Howard | 3898d19 | 2018-03-14 20:44:33 -0600 | [diff] [blame] | 61 | for (idx = 0; idx < func->autos.len; ++idx) { |
Gavin Howard | 4b9bb2b | 2018-03-23 08:11:11 -0600 | [diff] [blame] | 62 | |
Gavin Howard | 3898d19 | 2018-03-14 20:44:33 -0600 | [diff] [blame] | 63 | a = bc_vec_item(&func->autos, idx); |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 64 | assert(a); |
Gavin Howard | 4b9bb2b | 2018-03-23 08:11:11 -0600 | [diff] [blame] | 65 | |
Gavin Howard | 3898d19 | 2018-03-14 20:44:33 -0600 | [diff] [blame] | 66 | if (!strcmp(a->name, result->data.id.name)) { |
Gavin Howard | 3affc80 | 2018-02-27 19:57:38 -0700 | [diff] [blame] | 67 | |
Gavin Howard | 90f13ad | 2018-03-17 13:32:16 -0600 | [diff] [blame] | 68 | BcResult *r; |
Gavin Howard | 3898d19 | 2018-03-14 20:44:33 -0600 | [diff] [blame] | 69 | uint8_t cond; |
| 70 | |
| 71 | cond = flags & BC_PROGRAM_SEARCH_VAR; |
| 72 | |
Gavin Howard | bdb2f92 | 2018-03-15 09:25:18 -0600 | [diff] [blame] | 73 | if (!a->var != !cond) return BC_STATUS_EXEC_BAD_TYPE; |
Gavin Howard | 3898d19 | 2018-03-14 20:44:33 -0600 | [diff] [blame] | 74 | |
Gavin Howard | 0c0d192 | 2018-03-21 17:00:21 -0600 | [diff] [blame] | 75 | r = bc_vec_item(&p->results, ip->len + idx); |
Gavin Howard | 3898d19 | 2018-03-14 20:44:33 -0600 | [diff] [blame] | 76 | |
Gavin Howard | 4b9bb2b | 2018-03-23 08:11:11 -0600 | [diff] [blame] | 77 | assert(r); |
Gavin Howard | 3898d19 | 2018-03-14 20:44:33 -0600 | [diff] [blame] | 78 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 79 | if (cond || flags & BC_PROGRAM_SEARCH_ARRAY) *ret = &r->data.num; |
Gavin Howard | 3898d19 | 2018-03-14 20:44:33 -0600 | [diff] [blame] | 80 | else { |
Gavin Howard | 90f13ad | 2018-03-17 13:32:16 -0600 | [diff] [blame] | 81 | status = bc_array_expand(&r->data.array, result->data.id.idx + 1); |
Gavin Howard | 3898d19 | 2018-03-14 20:44:33 -0600 | [diff] [blame] | 82 | if (status) return status; |
Gavin Howard | 90f13ad | 2018-03-17 13:32:16 -0600 | [diff] [blame] | 83 | *ret = bc_vec_item(&r->data.array, result->data.id.idx); |
Gavin Howard | 3898d19 | 2018-03-14 20:44:33 -0600 | [diff] [blame] | 84 | } |
| 85 | |
| 86 | return BC_STATUS_SUCCESS; |
| 87 | } |
Gavin Howard | 5732343 | 2018-03-14 20:06:35 -0600 | [diff] [blame] | 88 | } |
Gavin Howard | 3affc80 | 2018-02-27 19:57:38 -0700 | [diff] [blame] | 89 | } |
| 90 | |
Gavin Howard | e3c7c8e | 2018-03-23 08:15:46 -0600 | [diff] [blame] | 91 | var = flags & BC_PROGRAM_SEARCH_VAR; |
| 92 | vec = var ? &p->vars : &p->arrays; |
| 93 | veco = var ? &p->var_map : &p->array_map; |
Gavin Howard | 3affc80 | 2018-02-27 19:57:38 -0700 | [diff] [blame] | 94 | |
| 95 | entry.name = result->data.id.name; |
| 96 | entry.idx = vec->len; |
| 97 | |
Gavin Howard | ea932f0 | 2018-03-23 09:53:40 -0600 | [diff] [blame] | 98 | status = bc_veco_insert(veco, &entry, &idx); |
Gavin Howard | 3affc80 | 2018-02-27 19:57:38 -0700 | [diff] [blame] | 99 | |
Gavin Howard | ea932f0 | 2018-03-23 09:53:40 -0600 | [diff] [blame] | 100 | if (status != BC_STATUS_VEC_ITEM_EXISTS) { |
Gavin Howard | 3affc80 | 2018-02-27 19:57:38 -0700 | [diff] [blame] | 101 | |
Gavin Howard | ea932f0 | 2018-03-23 09:53:40 -0600 | [diff] [blame] | 102 | // We use this because it has a union of BcNum and BcVec. |
| 103 | BcResult data; |
| 104 | size_t len; |
Gavin Howard | a1ff02f | 2018-03-07 12:32:25 -0700 | [diff] [blame] | 105 | |
Gavin Howard | ea932f0 | 2018-03-23 09:53:40 -0600 | [diff] [blame] | 106 | if (status) return status; |
Gavin Howard | 3affc80 | 2018-02-27 19:57:38 -0700 | [diff] [blame] | 107 | |
Gavin Howard | ea932f0 | 2018-03-23 09:53:40 -0600 | [diff] [blame] | 108 | len = strlen(entry.name) + 1; |
Gavin Howard | a1ff02f | 2018-03-07 12:32:25 -0700 | [diff] [blame] | 109 | |
Gavin Howard | ea932f0 | 2018-03-23 09:53:40 -0600 | [diff] [blame] | 110 | if (!(result->data.id.name = malloc(len))) return BC_STATUS_MALLOC_FAIL; |
Gavin Howard | a1ff02f | 2018-03-07 12:32:25 -0700 | [diff] [blame] | 111 | |
Gavin Howard | ea932f0 | 2018-03-23 09:53:40 -0600 | [diff] [blame] | 112 | strcpy(result->data.id.name, entry.name); |
Gavin Howard | a1ff02f | 2018-03-07 12:32:25 -0700 | [diff] [blame] | 113 | |
Gavin Howard | ea932f0 | 2018-03-23 09:53:40 -0600 | [diff] [blame] | 114 | if (flags & BC_PROGRAM_SEARCH_VAR) |
| 115 | status = bc_num_init(&data.data.num, BC_NUM_DEF_SIZE); |
| 116 | else status = bc_vec_init(&data.data.array, sizeof(BcNum), bc_num_free); |
Gavin Howard | 3affc80 | 2018-02-27 19:57:38 -0700 | [diff] [blame] | 117 | |
Gavin Howard | ea932f0 | 2018-03-23 09:53:40 -0600 | [diff] [blame] | 118 | if (status) return status; |
Gavin Howard | 3affc80 | 2018-02-27 19:57:38 -0700 | [diff] [blame] | 119 | |
Gavin Howard | ea932f0 | 2018-03-23 09:53:40 -0600 | [diff] [blame] | 120 | if ((status = bc_vec_push(vec, &data.data))) return status; |
Gavin Howard | 3affc80 | 2018-02-27 19:57:38 -0700 | [diff] [blame] | 121 | } |
Gavin Howard | 3affc80 | 2018-02-27 19:57:38 -0700 | [diff] [blame] | 122 | |
| 123 | entry_ptr = bc_veco_item(veco, idx); |
| 124 | |
Gavin Howard | 4b9bb2b | 2018-03-23 08:11:11 -0600 | [diff] [blame] | 125 | assert(entry_ptr); |
Gavin Howard | 3affc80 | 2018-02-27 19:57:38 -0700 | [diff] [blame] | 126 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 127 | if (var) { |
Gavin Howard | f23448c | 2018-02-27 20:36:24 -0700 | [diff] [blame] | 128 | *ret = bc_vec_item(vec, entry_ptr->idx); |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 129 | assert(*ret); |
Gavin Howard | 3affc80 | 2018-02-27 19:57:38 -0700 | [diff] [blame] | 130 | } |
| 131 | else { |
| 132 | |
Gavin Howard | 4b9bb2b | 2018-03-23 08:11:11 -0600 | [diff] [blame] | 133 | BcVec *aptr = bc_vec_item(vec, entry_ptr->idx); |
Gavin Howard | 3affc80 | 2018-02-27 19:57:38 -0700 | [diff] [blame] | 134 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 135 | assert(aptr); |
Gavin Howard | 3affc80 | 2018-02-27 19:57:38 -0700 | [diff] [blame] | 136 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 137 | if (flags & BC_PROGRAM_SEARCH_ARRAY) { |
Gavin Howard | f23448c | 2018-02-27 20:36:24 -0700 | [diff] [blame] | 138 | *ret = (BcNum*) aptr; |
| 139 | return BC_STATUS_SUCCESS; |
| 140 | } |
| 141 | |
Gavin Howard | aaa9140 | 2018-02-28 12:31:22 -0700 | [diff] [blame] | 142 | status = bc_array_expand(aptr, result->data.id.idx + 1); |
Gavin Howard | aaa9140 | 2018-02-28 12:31:22 -0700 | [diff] [blame] | 143 | if (status) return status; |
Gavin Howard | 3affc80 | 2018-02-27 19:57:38 -0700 | [diff] [blame] | 144 | |
Gavin Howard | f23448c | 2018-02-27 20:36:24 -0700 | [diff] [blame] | 145 | *ret = bc_vec_item(aptr, result->data.id.idx); |
Gavin Howard | 3affc80 | 2018-02-27 19:57:38 -0700 | [diff] [blame] | 146 | } |
| 147 | |
| 148 | return BC_STATUS_SUCCESS; |
| 149 | } |
| 150 | |
Gavin Howard | 3f68df7 | 2018-03-22 20:30:27 -0600 | [diff] [blame] | 151 | BcStatus bc_program_num(BcProgram *p, BcResult *result, BcNum** num, bool hex) { |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 152 | |
Gavin Howard | 4b9bb2b | 2018-03-23 08:11:11 -0600 | [diff] [blame] | 153 | BcStatus status = BC_STATUS_SUCCESS; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 154 | |
| 155 | switch (result->type) { |
| 156 | |
| 157 | case BC_RESULT_INTERMEDIATE: |
| 158 | case BC_RESULT_SCALE: |
| 159 | { |
| 160 | *num = &result->data.num; |
| 161 | break; |
| 162 | } |
| 163 | |
| 164 | case BC_RESULT_CONSTANT: |
| 165 | { |
| 166 | char** s; |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 167 | size_t len, base; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 168 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 169 | s = bc_vec_item(&p->constants, result->data.id.idx); |
Gavin Howard | 4b9bb2b | 2018-03-23 08:11:11 -0600 | [diff] [blame] | 170 | assert(s); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 171 | len = strlen(*s); |
| 172 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 173 | if ((status = bc_num_init(&result->data.num, len))) return status; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 174 | |
Gavin Howard | cb3ce02 | 2018-03-21 09:13:24 -0600 | [diff] [blame] | 175 | base = hex && len == 1 ? BC_NUM_MAX_INPUT_BASE : p->ibase_t; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 176 | |
Gavin Howard | 5cea43b | 2018-03-02 11:32:11 -0700 | [diff] [blame] | 177 | status = bc_num_parse(&result->data.num, *s, &p->ibase, base); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 178 | |
Gavin Howard | 9ba6c25 | 2018-03-14 01:44:38 -0600 | [diff] [blame] | 179 | if (status) { |
| 180 | bc_num_free(&result->data.num); |
| 181 | return status; |
| 182 | } |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 183 | |
| 184 | *num = &result->data.num; |
| 185 | |
| 186 | result->type = BC_RESULT_INTERMEDIATE; |
| 187 | |
| 188 | break; |
| 189 | } |
| 190 | |
| 191 | case BC_RESULT_VAR: |
Gavin Howard | abcc5e0 | 2018-03-14 16:02:20 -0600 | [diff] [blame] | 192 | case BC_RESULT_ARRAY: |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 193 | { |
Gavin Howard | 92b7ce0 | 2018-03-14 20:04:14 -0600 | [diff] [blame] | 194 | uint8_t flags = result->type == BC_RESULT_VAR ? BC_PROGRAM_SEARCH_VAR : 0; |
Gavin Howard | e661b4a | 2018-02-28 10:53:01 -0700 | [diff] [blame] | 195 | status = bc_program_search(p, result, num, flags); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 196 | break; |
| 197 | } |
| 198 | |
| 199 | case BC_RESULT_LAST: |
| 200 | { |
| 201 | *num = &p->last; |
| 202 | break; |
| 203 | } |
| 204 | |
| 205 | case BC_RESULT_IBASE: |
| 206 | { |
| 207 | *num = &p->ibase; |
| 208 | break; |
| 209 | } |
| 210 | |
| 211 | case BC_RESULT_OBASE: |
| 212 | { |
| 213 | *num = &p->obase; |
| 214 | break; |
| 215 | } |
| 216 | |
| 217 | case BC_RESULT_ONE: |
| 218 | { |
| 219 | *num = &p->one; |
| 220 | break; |
| 221 | } |
| 222 | |
| 223 | default: |
| 224 | { |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 225 | // This is here to prevent compiler warnings in release mode. |
Gavin Howard | 2168fb8 | 2018-03-24 10:40:37 -0600 | [diff] [blame] | 226 | *num = &result->data.num; |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 227 | assert(false); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 228 | break; |
| 229 | } |
| 230 | } |
| 231 | |
| 232 | return status; |
| 233 | } |
Gavin Howard | 6d89b5d | 2018-02-26 13:21:34 -0700 | [diff] [blame] | 234 | |
Gavin Howard | 3f68df7 | 2018-03-22 20:30:27 -0600 | [diff] [blame] | 235 | BcStatus bc_program_binaryOpPrep(BcProgram *p, BcResult **left, BcNum **lval, |
| 236 | BcResult **right, BcNum **rval) |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 237 | { |
| 238 | BcStatus status; |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 239 | BcResult *l, *r; |
Gavin Howard | ef1b52e | 2018-03-20 14:02:57 -0600 | [diff] [blame] | 240 | bool hex; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 241 | |
Gavin Howard | 27fdfb9 | 2018-03-21 07:56:59 -0600 | [diff] [blame] | 242 | assert(p && left && lval && right && rval && |
Gavin Howard | 0c0d192 | 2018-03-21 17:00:21 -0600 | [diff] [blame] | 243 | BC_PROGRAM_CHECK_RESULTS(p, 2)); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 244 | |
Gavin Howard | 0c0d192 | 2018-03-21 17:00:21 -0600 | [diff] [blame] | 245 | r = bc_vec_item_rev(&p->results, 0); |
| 246 | l = bc_vec_item_rev(&p->results, 1); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 247 | |
Gavin Howard | 27fdfb9 | 2018-03-21 07:56:59 -0600 | [diff] [blame] | 248 | assert(r && l); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 249 | |
Gavin Howard | 2168fb8 | 2018-03-24 10:40:37 -0600 | [diff] [blame] | 250 | *left = l; |
| 251 | *right = r; |
| 252 | |
Gavin Howard | ef1b52e | 2018-03-20 14:02:57 -0600 | [diff] [blame] | 253 | hex = l->type == BC_RESULT_IBASE || l->type == BC_RESULT_OBASE; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 254 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 255 | if ((status = bc_program_num(p, l, lval, false))) return status; |
| 256 | if ((status = bc_program_num(p, r, rval, hex))) return status; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 257 | |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 258 | return BC_STATUS_SUCCESS; |
| 259 | } |
| 260 | |
Gavin Howard | 3f68df7 | 2018-03-22 20:30:27 -0600 | [diff] [blame] | 261 | BcStatus bc_program_binaryOpRetire(BcProgram *p, BcResult *result, |
| 262 | BcResultType type) |
Gavin Howard | 5fb956f | 2018-03-05 10:57:16 -0700 | [diff] [blame] | 263 | { |
Gavin Howard | 5fb956f | 2018-03-05 10:57:16 -0700 | [diff] [blame] | 264 | result->type = type; |
| 265 | |
Gavin Howard | 0eb2a37 | 2018-03-24 09:52:55 -0600 | [diff] [blame] | 266 | bc_vec_pop(&p->results); |
| 267 | bc_vec_pop(&p->results); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 268 | |
Gavin Howard | 0c0d192 | 2018-03-21 17:00:21 -0600 | [diff] [blame] | 269 | return bc_vec_push(&p->results, result); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 270 | } |
| 271 | |
Gavin Howard | 3f68df7 | 2018-03-22 20:30:27 -0600 | [diff] [blame] | 272 | BcStatus bc_program_unaryOpPrep(BcProgram *p, BcResult **result, BcNum **val) { |
| 273 | |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 274 | BcStatus status; |
| 275 | BcResult *r; |
Gavin Howard | 195706a | 2018-02-26 17:45:58 -0700 | [diff] [blame] | 276 | |
Gavin Howard | 0c0d192 | 2018-03-21 17:00:21 -0600 | [diff] [blame] | 277 | assert(p && result && val && BC_PROGRAM_CHECK_RESULTS(p, 1)); |
Gavin Howard | 195706a | 2018-02-26 17:45:58 -0700 | [diff] [blame] | 278 | |
Gavin Howard | 0c0d192 | 2018-03-21 17:00:21 -0600 | [diff] [blame] | 279 | r = bc_vec_item_rev(&p->results, 0); |
Gavin Howard | e4cdf56 | 2018-01-23 13:42:39 -0700 | [diff] [blame] | 280 | |
Gavin Howard | 27fdfb9 | 2018-03-21 07:56:59 -0600 | [diff] [blame] | 281 | assert(r); |
Gavin Howard | a4a7289 | 2018-02-27 09:16:10 -0700 | [diff] [blame] | 282 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 283 | if ((status = bc_program_num(p, r, val, false))) return status; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 284 | |
| 285 | *result = r; |
| 286 | |
| 287 | return BC_STATUS_SUCCESS; |
| 288 | } |
| 289 | |
Gavin Howard | 3f68df7 | 2018-03-22 20:30:27 -0600 | [diff] [blame] | 290 | BcStatus bc_program_unaryOpRetire(BcProgram *p, BcResult *result, |
| 291 | BcResultType type) |
Gavin Howard | 5fb956f | 2018-03-05 10:57:16 -0700 | [diff] [blame] | 292 | { |
Gavin Howard | 5fb956f | 2018-03-05 10:57:16 -0700 | [diff] [blame] | 293 | result->type = type; |
Gavin Howard | 0eb2a37 | 2018-03-24 09:52:55 -0600 | [diff] [blame] | 294 | bc_vec_pop(&p->results); |
Gavin Howard | 0c0d192 | 2018-03-21 17:00:21 -0600 | [diff] [blame] | 295 | return bc_vec_push(&p->results, result); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 296 | } |
| 297 | |
Gavin Howard | 3f68df7 | 2018-03-22 20:30:27 -0600 | [diff] [blame] | 298 | BcStatus bc_program_op(BcProgram *p, uint8_t inst) { |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 299 | |
| 300 | BcStatus status; |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 301 | BcResult *operand1, *operand2, result; |
| 302 | BcNum *num1, *num2; |
Gavin Howard | 101b5e6 | 2018-03-26 07:46:27 -0600 | [diff] [blame] | 303 | BcNumBinaryFunc op; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 304 | |
Gavin Howard | 4421cbb | 2018-03-05 14:06:03 -0700 | [diff] [blame] | 305 | status = bc_program_binaryOpPrep(p, &operand1, &num1, &operand2, &num2); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 306 | if (status) return status; |
| 307 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 308 | if ((status = bc_num_init(&result.data.num, BC_NUM_DEF_SIZE))) return status; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 309 | |
Gavin Howard | 101b5e6 | 2018-03-26 07:46:27 -0600 | [diff] [blame] | 310 | op = bc_program_math_ops[inst - BC_INST_POWER]; |
| 311 | if ((status = op(num1, num2, &result.data.num, p->scale))) goto err; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 312 | |
Gavin Howard | 5fb956f | 2018-03-05 10:57:16 -0700 | [diff] [blame] | 313 | status = bc_program_binaryOpRetire(p, &result, BC_RESULT_INTERMEDIATE); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 314 | if (status) goto err; |
| 315 | |
| 316 | return status; |
| 317 | |
| 318 | err: |
| 319 | |
| 320 | bc_num_free(&result.data.num); |
| 321 | |
| 322 | return status; |
| 323 | } |
| 324 | |
Gavin Howard | 3f68df7 | 2018-03-22 20:30:27 -0600 | [diff] [blame] | 325 | BcStatus bc_program_read(BcProgram *p) { |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 326 | |
| 327 | BcStatus status; |
| 328 | BcParse parse; |
| 329 | char *buffer; |
| 330 | size_t size; |
| 331 | BcFunc *func; |
| 332 | BcInstPtr ip; |
| 333 | |
Gavin Howard | a1601ae | 2018-03-17 19:43:28 -0600 | [diff] [blame] | 334 | func = bc_vec_item(&p->funcs, BC_PROGRAM_READ); |
Gavin Howard | ea9a9bd | 2018-03-21 08:04:07 -0600 | [diff] [blame] | 335 | assert(func); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 336 | func->code.len = 0; |
| 337 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 338 | if (!(buffer = malloc(BC_PROGRAM_BUF_SIZE + 1))) return BC_STATUS_MALLOC_FAIL; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 339 | |
| 340 | size = BC_PROGRAM_BUF_SIZE; |
| 341 | |
Gavin Howard | fc4ef0c | 2018-03-22 23:00:25 -0600 | [diff] [blame] | 342 | if (getline(&buffer, &size, stdin) < 0) { |
| 343 | status = BC_STATUS_IO_ERR; |
| 344 | goto io_err; |
| 345 | } |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 346 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 347 | if ((status = bc_parse_init(&parse, p))) goto io_err; |
Gavin Howard | 27fdfb9 | 2018-03-21 07:56:59 -0600 | [diff] [blame] | 348 | bc_lex_init(&parse.lex, "<stdin>"); |
Gavin Howard | 68f2bae | 2018-03-26 13:02:27 -0600 | [diff] [blame] | 349 | if ((status = bc_lex_text(&parse.lex, buffer))) goto exec_err; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 350 | |
Gavin Howard | f4167dc | 2018-03-26 14:19:28 -0600 | [diff] [blame] | 351 | if ((status = bc_parse_expr(&parse, &func->code, BC_PARSE_EXPR_NO_READ))) return status; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 352 | |
Gavin Howard | f4167dc | 2018-03-26 14:19:28 -0600 | [diff] [blame] | 353 | if (parse.lex.token.type != BC_LEX_NEWLINE && |
| 354 | parse.lex.token.type != BC_LEX_EOF) |
| 355 | { |
| 356 | status = BC_STATUS_EXEC_BAD_READ_EXPR; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 357 | goto exec_err; |
| 358 | } |
| 359 | |
Gavin Howard | a1601ae | 2018-03-17 19:43:28 -0600 | [diff] [blame] | 360 | ip.func = BC_PROGRAM_READ; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 361 | ip.idx = 0; |
Gavin Howard | 0c0d192 | 2018-03-21 17:00:21 -0600 | [diff] [blame] | 362 | ip.len = p->results.len; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 363 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 364 | if ((status = bc_vec_push(&p->stack, &ip))) goto exec_err; |
| 365 | if ((status = bc_program_exec(p))) goto exec_err; |
Gavin Howard | ceaf64d | 2018-03-05 11:20:34 -0700 | [diff] [blame] | 366 | |
Gavin Howard | 0eb2a37 | 2018-03-24 09:52:55 -0600 | [diff] [blame] | 367 | bc_vec_pop(&p->stack); |
Gavin Howard | ceaf64d | 2018-03-05 11:20:34 -0700 | [diff] [blame] | 368 | |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 369 | exec_err: |
| 370 | |
| 371 | bc_parse_free(&parse); |
| 372 | |
| 373 | io_err: |
| 374 | |
| 375 | free(buffer); |
| 376 | |
| 377 | return status; |
| 378 | } |
| 379 | |
Gavin Howard | 3f68df7 | 2018-03-22 20:30:27 -0600 | [diff] [blame] | 380 | size_t bc_program_index(uint8_t *code, size_t *start) { |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 381 | |
Gavin Howard | 4cf4992 | 2018-03-12 17:13:50 -0600 | [diff] [blame] | 382 | uint8_t bytes, byte, i; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 383 | size_t result; |
| 384 | |
| 385 | bytes = code[(*start)++]; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 386 | result = 0; |
| 387 | |
Gavin Howard | 030fd97 | 2018-03-13 17:57:09 -0600 | [diff] [blame] | 388 | for (i = 0; i < bytes; ++i) { |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 389 | byte = code[(*start)++]; |
Gavin Howard | 389e69e | 2018-03-13 17:59:27 -0600 | [diff] [blame] | 390 | result |= (((size_t) byte) << (i * CHAR_BIT)); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 391 | } |
| 392 | |
| 393 | return result; |
| 394 | } |
| 395 | |
Gavin Howard | 3f68df7 | 2018-03-22 20:30:27 -0600 | [diff] [blame] | 396 | char* bc_program_name(uint8_t *code, size_t *start) { |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 397 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 398 | char byte, *s, *string, *ptr; |
| 399 | size_t len, i; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 400 | |
| 401 | string = (char*) (code + *start); |
Gavin Howard | c295369 | 2018-03-06 21:33:56 -0700 | [diff] [blame] | 402 | ptr = strchr((char*) string, ':'); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 403 | |
| 404 | if (ptr) len = ((unsigned long) ptr) - ((unsigned long) string); |
| 405 | else len = strlen(string); |
| 406 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 407 | if (!(s = malloc(len + 1))) return NULL; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 408 | |
| 409 | byte = code[(*start)++]; |
| 410 | i = 0; |
| 411 | |
| 412 | while (byte && byte != ':') { |
| 413 | s[i++] = byte; |
| 414 | byte = code[(*start)++]; |
| 415 | } |
| 416 | |
| 417 | s[i] = '\0'; |
| 418 | |
| 419 | return s; |
| 420 | } |
| 421 | |
Gavin Howard | 3f68df7 | 2018-03-22 20:30:27 -0600 | [diff] [blame] | 422 | BcStatus bc_program_printIndex(uint8_t *code, size_t *start) { |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 423 | |
Gavin Howard | 4cf4992 | 2018-03-12 17:13:50 -0600 | [diff] [blame] | 424 | uint8_t bytes, byte, i; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 425 | |
| 426 | bytes = code[(*start)++]; |
| 427 | byte = 1; |
| 428 | |
Gavin Howard | f456d37 | 2018-03-10 20:11:41 -0700 | [diff] [blame] | 429 | if (printf(bc_program_byte_fmt, bytes) < 0) return BC_STATUS_IO_ERR; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 430 | |
Gavin Howard | 4cf4992 | 2018-03-12 17:13:50 -0600 | [diff] [blame] | 431 | for (i = 0; byte && i < bytes; ++i) { |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 432 | byte = code[(*start)++]; |
Gavin Howard | f456d37 | 2018-03-10 20:11:41 -0700 | [diff] [blame] | 433 | if (printf(bc_program_byte_fmt, byte) < 0) return BC_STATUS_IO_ERR; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 434 | } |
| 435 | |
| 436 | return BC_STATUS_SUCCESS; |
| 437 | } |
| 438 | |
Gavin Howard | 3f68df7 | 2018-03-22 20:30:27 -0600 | [diff] [blame] | 439 | BcStatus bc_program_printName(uint8_t *code, size_t *start) { |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 440 | |
Gavin Howard | c0d9f31 | 2018-03-07 15:15:00 -0700 | [diff] [blame] | 441 | BcStatus status; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 442 | char byte; |
| 443 | |
Gavin Howard | c0d9f31 | 2018-03-07 15:15:00 -0700 | [diff] [blame] | 444 | status = BC_STATUS_SUCCESS; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 445 | byte = code[(*start)++]; |
| 446 | |
| 447 | while (byte && byte != ':') { |
| 448 | if (putchar(byte) == EOF) return BC_STATUS_IO_ERR; |
| 449 | byte = code[(*start)++]; |
| 450 | } |
| 451 | |
Gavin Howard | 27fdfb9 | 2018-03-21 07:56:59 -0600 | [diff] [blame] | 452 | assert(byte); |
| 453 | |
| 454 | if (putchar(byte) == EOF) status = BC_STATUS_IO_ERR; |
Gavin Howard | c0d9f31 | 2018-03-07 15:15:00 -0700 | [diff] [blame] | 455 | |
| 456 | return status; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 457 | } |
| 458 | |
Gavin Howard | 3f68df7 | 2018-03-22 20:30:27 -0600 | [diff] [blame] | 459 | BcStatus bc_program_printString(const char *str, size_t *nchars) { |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 460 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 461 | char c, c2; |
Gavin Howard | 4cf4992 | 2018-03-12 17:13:50 -0600 | [diff] [blame] | 462 | size_t len, i; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 463 | int err; |
| 464 | |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 465 | len = strlen(str); |
| 466 | |
Gavin Howard | bc7cae8 | 2018-03-14 13:43:04 -0600 | [diff] [blame] | 467 | for (i = 0; i < len; ++i, ++(*nchars)) { |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 468 | |
| 469 | c = str[i]; |
| 470 | |
Gavin Howard | a141a0f | 2018-03-23 13:16:10 -0600 | [diff] [blame] | 471 | if (c != '\\') err = putchar(c); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 472 | else { |
| 473 | |
| 474 | ++i; |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 475 | assert(i < len); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 476 | c2 = str[i]; |
| 477 | |
| 478 | switch (c2) { |
| 479 | |
| 480 | case 'a': |
| 481 | { |
Gavin Howard | a141a0f | 2018-03-23 13:16:10 -0600 | [diff] [blame] | 482 | err = putchar('\a'); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 483 | break; |
| 484 | } |
| 485 | |
| 486 | case 'b': |
| 487 | { |
Gavin Howard | a141a0f | 2018-03-23 13:16:10 -0600 | [diff] [blame] | 488 | err = putchar('\b'); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 489 | break; |
| 490 | } |
| 491 | |
| 492 | case 'e': |
| 493 | { |
Gavin Howard | a141a0f | 2018-03-23 13:16:10 -0600 | [diff] [blame] | 494 | err = putchar('\\'); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 495 | break; |
| 496 | } |
| 497 | |
| 498 | case 'f': |
| 499 | { |
Gavin Howard | a141a0f | 2018-03-23 13:16:10 -0600 | [diff] [blame] | 500 | err = putchar('\f'); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 501 | break; |
| 502 | } |
| 503 | |
| 504 | case 'n': |
| 505 | { |
Gavin Howard | a141a0f | 2018-03-23 13:16:10 -0600 | [diff] [blame] | 506 | err = putchar('\n'); |
Gavin Howard | bc7cae8 | 2018-03-14 13:43:04 -0600 | [diff] [blame] | 507 | *nchars = SIZE_MAX; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 508 | break; |
| 509 | } |
| 510 | |
| 511 | case 'r': |
| 512 | { |
Gavin Howard | a141a0f | 2018-03-23 13:16:10 -0600 | [diff] [blame] | 513 | err = putchar('\r'); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 514 | break; |
| 515 | } |
| 516 | |
| 517 | case 'q': |
| 518 | { |
Gavin Howard | a141a0f | 2018-03-23 13:16:10 -0600 | [diff] [blame] | 519 | err = putchar('"'); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 520 | break; |
| 521 | } |
| 522 | |
| 523 | case 't': |
| 524 | { |
Gavin Howard | a141a0f | 2018-03-23 13:16:10 -0600 | [diff] [blame] | 525 | err = putchar('\t'); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 526 | break; |
| 527 | } |
| 528 | |
| 529 | default: |
| 530 | { |
| 531 | // Do nothing. |
| 532 | err = 0; |
| 533 | break; |
| 534 | } |
| 535 | } |
| 536 | } |
| 537 | |
Gavin Howard | 16bba75 | 2018-03-15 11:28:29 -0600 | [diff] [blame] | 538 | if (err == EOF) return BC_STATUS_IO_ERR; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 539 | } |
| 540 | |
| 541 | return BC_STATUS_SUCCESS; |
| 542 | } |
| 543 | |
Gavin Howard | 3f68df7 | 2018-03-22 20:30:27 -0600 | [diff] [blame] | 544 | BcStatus bc_program_push(BcProgram *p, uint8_t *code, size_t *start, bool var) { |
| 545 | |
Gavin Howard | 843fa79 | 2018-02-27 16:42:52 -0700 | [diff] [blame] | 546 | BcStatus status; |
| 547 | BcResult result; |
Gavin Howard | 843fa79 | 2018-02-27 16:42:52 -0700 | [diff] [blame] | 548 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 549 | result.data.id.name = bc_program_name(code, start); |
Gavin Howard | 843fa79 | 2018-02-27 16:42:52 -0700 | [diff] [blame] | 550 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 551 | assert(result.data.id.name); |
Gavin Howard | 843fa79 | 2018-02-27 16:42:52 -0700 | [diff] [blame] | 552 | |
| 553 | if (var) { |
| 554 | result.type = BC_RESULT_VAR; |
Gavin Howard | 0c0d192 | 2018-03-21 17:00:21 -0600 | [diff] [blame] | 555 | status = bc_vec_push(&p->results, &result); |
Gavin Howard | 843fa79 | 2018-02-27 16:42:52 -0700 | [diff] [blame] | 556 | } |
| 557 | else { |
| 558 | |
| 559 | BcResult *operand; |
| 560 | BcNum *num; |
| 561 | unsigned long temp; |
| 562 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 563 | if ((status = bc_program_unaryOpPrep(p, &operand, &num))) goto err; |
| 564 | if ((status = bc_num_ulong(num, &temp))) goto err; |
Gavin Howard | 843fa79 | 2018-02-27 16:42:52 -0700 | [diff] [blame] | 565 | |
Gavin Howard | bdb2f92 | 2018-03-15 09:25:18 -0600 | [diff] [blame] | 566 | if (temp > (unsigned long) p->dim_max) { |
| 567 | status = BC_STATUS_EXEC_ARRAY_LEN; |
| 568 | goto err; |
| 569 | } |
| 570 | |
Gavin Howard | 843fa79 | 2018-02-27 16:42:52 -0700 | [diff] [blame] | 571 | result.data.id.idx = (size_t) temp; |
| 572 | |
Gavin Howard | abcc5e0 | 2018-03-14 16:02:20 -0600 | [diff] [blame] | 573 | status = bc_program_unaryOpRetire(p, &result, BC_RESULT_ARRAY); |
Gavin Howard | 843fa79 | 2018-02-27 16:42:52 -0700 | [diff] [blame] | 574 | } |
| 575 | |
| 576 | if (status) goto err; |
| 577 | |
| 578 | return status; |
| 579 | |
| 580 | err: |
| 581 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 582 | free(result.data.id.name); |
Gavin Howard | 843fa79 | 2018-02-27 16:42:52 -0700 | [diff] [blame] | 583 | |
| 584 | return status; |
| 585 | } |
| 586 | |
Gavin Howard | 3f68df7 | 2018-03-22 20:30:27 -0600 | [diff] [blame] | 587 | BcStatus bc_program_negate(BcProgram *p) { |
Gavin Howard | 3a94736 | 2018-03-02 11:25:48 -0700 | [diff] [blame] | 588 | |
| 589 | BcStatus status; |
| 590 | BcResult result; |
| 591 | BcResult *ptr; |
| 592 | BcNum *num; |
| 593 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 594 | if ((status = bc_program_unaryOpPrep(p, &ptr, &num))) return status; |
| 595 | if ((status = bc_num_init(&result.data.num, num->len))) return status; |
| 596 | if ((status = bc_num_copy(&result.data.num, num))) goto err; |
Gavin Howard | 3a94736 | 2018-03-02 11:25:48 -0700 | [diff] [blame] | 597 | |
Gavin Howard | a654f11 | 2018-03-03 09:47:34 -0700 | [diff] [blame] | 598 | result.data.num.neg = !result.data.num.neg; |
| 599 | |
Gavin Howard | 5fb956f | 2018-03-05 10:57:16 -0700 | [diff] [blame] | 600 | status = bc_program_unaryOpRetire(p, &result, BC_RESULT_INTERMEDIATE); |
Gavin Howard | 3a94736 | 2018-03-02 11:25:48 -0700 | [diff] [blame] | 601 | if (status) goto err; |
| 602 | |
| 603 | return status; |
| 604 | |
| 605 | err: |
| 606 | |
| 607 | bc_num_free(&result.data.num); |
| 608 | |
| 609 | return status; |
| 610 | } |
| 611 | |
Gavin Howard | 3f68df7 | 2018-03-22 20:30:27 -0600 | [diff] [blame] | 612 | BcStatus bc_program_logical(BcProgram *p, uint8_t inst) { |
Gavin Howard | 843fa79 | 2018-02-27 16:42:52 -0700 | [diff] [blame] | 613 | |
| 614 | BcStatus status; |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 615 | BcResult *operand1, *operand2, result; |
| 616 | BcNum *num1, *num2; |
Gavin Howard | 843fa79 | 2018-02-27 16:42:52 -0700 | [diff] [blame] | 617 | BcNumInitFunc init; |
| 618 | bool cond; |
Gavin Howard | 5df99ed | 2018-02-27 16:50:26 -0700 | [diff] [blame] | 619 | int cmp; |
Gavin Howard | 843fa79 | 2018-02-27 16:42:52 -0700 | [diff] [blame] | 620 | |
| 621 | status = bc_program_binaryOpPrep(p, &operand1, &num1, &operand2, &num2); |
Gavin Howard | 843fa79 | 2018-02-27 16:42:52 -0700 | [diff] [blame] | 622 | if (status) return status; |
| 623 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 624 | if ((status = bc_num_init(&result.data.num, BC_NUM_DEF_SIZE))) return status; |
Gavin Howard | 843fa79 | 2018-02-27 16:42:52 -0700 | [diff] [blame] | 625 | |
Gavin Howard | 101b5e6 | 2018-03-26 07:46:27 -0600 | [diff] [blame] | 626 | if (inst == BC_INST_BOOL_AND) |
Gavin Howard | 2a064fd | 2018-03-20 15:56:12 -0600 | [diff] [blame] | 627 | cond = bc_num_cmp(num1, &p->zero, NULL) && bc_num_cmp(num2, &p->zero, NULL); |
Gavin Howard | 101b5e6 | 2018-03-26 07:46:27 -0600 | [diff] [blame] | 628 | else if (inst == BC_INST_BOOL_OR) |
Gavin Howard | 2a064fd | 2018-03-20 15:56:12 -0600 | [diff] [blame] | 629 | cond = bc_num_cmp(num1, &p->zero, NULL) || bc_num_cmp(num2, &p->zero, NULL); |
Gavin Howard | 843fa79 | 2018-02-27 16:42:52 -0700 | [diff] [blame] | 630 | else { |
| 631 | |
Gavin Howard | 2a064fd | 2018-03-20 15:56:12 -0600 | [diff] [blame] | 632 | cmp = bc_num_cmp(num1, num2, NULL); |
Gavin Howard | 843fa79 | 2018-02-27 16:42:52 -0700 | [diff] [blame] | 633 | |
| 634 | switch (inst) { |
Gavin Howard | 101b5e6 | 2018-03-26 07:46:27 -0600 | [diff] [blame] | 635 | case BC_INST_REL_EQ: |
Gavin Howard | 843fa79 | 2018-02-27 16:42:52 -0700 | [diff] [blame] | 636 | { |
| 637 | cond = cmp == 0; |
| 638 | break; |
| 639 | } |
| 640 | |
Gavin Howard | 101b5e6 | 2018-03-26 07:46:27 -0600 | [diff] [blame] | 641 | case BC_INST_REL_LE: |
Gavin Howard | 843fa79 | 2018-02-27 16:42:52 -0700 | [diff] [blame] | 642 | { |
| 643 | cond = cmp <= 0; |
| 644 | break; |
| 645 | } |
| 646 | |
Gavin Howard | 101b5e6 | 2018-03-26 07:46:27 -0600 | [diff] [blame] | 647 | case BC_INST_REL_GE: |
Gavin Howard | 843fa79 | 2018-02-27 16:42:52 -0700 | [diff] [blame] | 648 | { |
| 649 | cond = cmp >= 0; |
| 650 | break; |
| 651 | } |
| 652 | |
Gavin Howard | 101b5e6 | 2018-03-26 07:46:27 -0600 | [diff] [blame] | 653 | case BC_INST_REL_NE: |
Gavin Howard | 843fa79 | 2018-02-27 16:42:52 -0700 | [diff] [blame] | 654 | { |
| 655 | cond = cmp != 0; |
| 656 | break; |
| 657 | } |
| 658 | |
Gavin Howard | 101b5e6 | 2018-03-26 07:46:27 -0600 | [diff] [blame] | 659 | case BC_INST_REL_LT: |
Gavin Howard | 843fa79 | 2018-02-27 16:42:52 -0700 | [diff] [blame] | 660 | { |
| 661 | cond = cmp < 0; |
| 662 | break; |
| 663 | } |
| 664 | |
Gavin Howard | 101b5e6 | 2018-03-26 07:46:27 -0600 | [diff] [blame] | 665 | case BC_INST_REL_GT: |
Gavin Howard | 843fa79 | 2018-02-27 16:42:52 -0700 | [diff] [blame] | 666 | { |
| 667 | cond = cmp > 0; |
| 668 | break; |
| 669 | } |
| 670 | |
| 671 | default: |
| 672 | { |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 673 | // This is here to silence a compiler warning in release mode. |
Gavin Howard | f955c23 | 2018-03-21 08:56:58 -0600 | [diff] [blame] | 674 | cond = 0; |
Gavin Howard | 2168fb8 | 2018-03-24 10:40:37 -0600 | [diff] [blame] | 675 | assert(cond); |
Gavin Howard | 27fdfb9 | 2018-03-21 07:56:59 -0600 | [diff] [blame] | 676 | break; |
Gavin Howard | 843fa79 | 2018-02-27 16:42:52 -0700 | [diff] [blame] | 677 | } |
| 678 | } |
Gavin Howard | 843fa79 | 2018-02-27 16:42:52 -0700 | [diff] [blame] | 679 | } |
| 680 | |
Gavin Howard | 17f6649 | 2018-02-27 19:22:18 -0700 | [diff] [blame] | 681 | init = cond ? bc_num_one : bc_num_zero; |
Gavin Howard | 843fa79 | 2018-02-27 16:42:52 -0700 | [diff] [blame] | 682 | init(&result.data.num); |
| 683 | |
Gavin Howard | 5fb956f | 2018-03-05 10:57:16 -0700 | [diff] [blame] | 684 | status = bc_program_binaryOpRetire(p, &result, BC_RESULT_INTERMEDIATE); |
Gavin Howard | 843fa79 | 2018-02-27 16:42:52 -0700 | [diff] [blame] | 685 | if (status) goto err; |
| 686 | |
| 687 | return status; |
| 688 | |
| 689 | err: |
| 690 | |
| 691 | bc_num_free(&result.data.num); |
| 692 | |
| 693 | return status; |
| 694 | } |
| 695 | |
Gavin Howard | 3f68df7 | 2018-03-22 20:30:27 -0600 | [diff] [blame] | 696 | BcStatus bc_program_assign(BcProgram *p, uint8_t inst) { |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 697 | |
| 698 | BcStatus status; |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 699 | BcResult *left, *right, result; |
| 700 | BcNum *lval, *rval; |
Gavin Howard | 101b5e6 | 2018-03-26 07:46:27 -0600 | [diff] [blame] | 701 | BcNumBinaryFunc op; |
Gavin Howard | d5a51e6 | 2018-03-26 12:34:27 -0600 | [diff] [blame] | 702 | unsigned long l, max; |
| 703 | size_t *ptr; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 704 | |
| 705 | status = bc_program_binaryOpPrep(p, &left, &lval, &right, &rval); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 706 | if (status) return status; |
| 707 | |
| 708 | if (left->type == BC_RESULT_CONSTANT || left->type == BC_RESULT_INTERMEDIATE) |
Gavin Howard | bdb2f92 | 2018-03-15 09:25:18 -0600 | [diff] [blame] | 709 | return BC_STATUS_PARSE_BAD_ASSIGN; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 710 | |
Gavin Howard | 101b5e6 | 2018-03-26 07:46:27 -0600 | [diff] [blame] | 711 | if (inst == BC_INST_ASSIGN_DIVIDE && !bc_num_cmp(rval, &p->zero, NULL)) |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 712 | return BC_STATUS_MATH_DIVIDE_BY_ZERO; |
| 713 | |
Gavin Howard | d5a51e6 | 2018-03-26 12:34:27 -0600 | [diff] [blame] | 714 | if (inst == BC_INST_ASSIGN) status = bc_num_copy(lval, rval); |
| 715 | else { |
| 716 | op = bc_program_math_ops[inst - BC_INST_ASSIGN_POWER]; |
| 717 | status = op(lval, rval, lval, p->scale); |
Gavin Howard | b818116 | 2018-02-28 12:58:09 -0700 | [diff] [blame] | 718 | } |
Gavin Howard | d5a51e6 | 2018-03-26 12:34:27 -0600 | [diff] [blame] | 719 | |
| 720 | if (status) return status; |
| 721 | |
| 722 | if (left->type == BC_RESULT_IBASE || left->type == BC_RESULT_OBASE) { |
| 723 | |
| 724 | ptr = left->type == BC_RESULT_IBASE ? &p->ibase_t : &p->obase_t; |
| 725 | max = left->type == BC_RESULT_IBASE ? BC_NUM_MAX_INPUT_BASE : p->base_max; |
| 726 | |
| 727 | if ((status = bc_num_ulong(lval, &l))) return status; |
| 728 | |
| 729 | if (l < BC_NUM_MIN_BASE || l > max) |
| 730 | return left->type - BC_RESULT_IBASE + BC_STATUS_EXEC_BAD_IBASE; |
| 731 | |
| 732 | *ptr = (size_t) l; |
| 733 | } |
| 734 | else if (left->type == BC_RESULT_SCALE) { |
| 735 | |
| 736 | if ((status = bc_num_ulong(lval, &l))) return status; |
| 737 | if (l > (unsigned long) p->scale_max) return BC_STATUS_EXEC_BAD_SCALE; |
| 738 | |
| 739 | p->scale = (size_t) l; |
| 740 | } |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 741 | |
Gavin Howard | 9c4358c | 2018-03-22 20:11:28 -0600 | [diff] [blame] | 742 | if ((status = bc_num_init(&result.data.num, lval->len))) return status; |
| 743 | if ((status = bc_num_copy(&result.data.num, lval))) goto err; |
Gavin Howard | b818116 | 2018-02-28 12:58:09 -0700 | [diff] [blame] | 744 | |
Gavin Howard | 5fb956f | 2018-03-05 10:57:16 -0700 | [diff] [blame] | 745 | status = bc_program_binaryOpRetire(p, &result, BC_RESULT_INTERMEDIATE); |
Gavin Howard | b818116 | 2018-02-28 12:58:09 -0700 | [diff] [blame] | 746 | if (status) goto err; |
| 747 | |
| 748 | return status; |
| 749 | |
| 750 | err: |
| 751 | |
| 752 | bc_num_free(&result.data.num); |
| 753 | |
| 754 | return status; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 755 | } |
| 756 | |
Gavin Howard | 3f68df7 | 2018-03-22 20:30:27 -0600 | [diff] [blame] | 757 | BcStatus bc_program_call(BcProgram *p, uint8_t *code, size_t *idx) { |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 758 | |
| 759 | BcStatus status; |
| 760 | BcInstPtr ip; |
Gavin Howard | 90f13ad | 2018-03-17 13:32:16 -0600 | [diff] [blame] | 761 | size_t nparams, i; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 762 | BcFunc *func; |
Gavin Howard | d6e3b7b | 2018-02-28 12:31:58 -0700 | [diff] [blame] | 763 | BcAuto *auto_ptr; |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 764 | BcResult param, *arg; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 765 | |
Gavin Howard | 53a8933 | 2018-03-23 10:32:24 -0600 | [diff] [blame] | 766 | status = BC_STATUS_SUCCESS; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 767 | nparams = bc_program_index(code, idx); |
| 768 | |
| 769 | ip.idx = 0; |
Gavin Howard | 0c0d192 | 2018-03-21 17:00:21 -0600 | [diff] [blame] | 770 | ip.len = p->results.len; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 771 | ip.func = bc_program_index(code, idx); |
| 772 | |
| 773 | func = bc_vec_item(&p->funcs, ip.func); |
| 774 | |
Gavin Howard | ea9a9bd | 2018-03-21 08:04:07 -0600 | [diff] [blame] | 775 | assert(func); |
| 776 | |
| 777 | if (!func->code.len) return BC_STATUS_EXEC_UNDEFINED_FUNC; |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 778 | if (nparams != func->nparams) return BC_STATUS_EXEC_MISMATCHED_PARAMS; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 779 | |
Gavin Howard | 3d3f73e | 2018-03-19 17:51:14 -0600 | [diff] [blame] | 780 | for (i = 0; i < nparams; ++i) { |
Gavin Howard | d6e3b7b | 2018-02-28 12:31:58 -0700 | [diff] [blame] | 781 | |
Gavin Howard | 3d3f73e | 2018-03-19 17:51:14 -0600 | [diff] [blame] | 782 | auto_ptr = bc_vec_item(&func->autos, i); |
Gavin Howard | 0c0d192 | 2018-03-21 17:00:21 -0600 | [diff] [blame] | 783 | arg = bc_vec_item_rev(&p->results, nparams - 1); |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 784 | assert(auto_ptr && arg); |
Gavin Howard | 90f13ad | 2018-03-17 13:32:16 -0600 | [diff] [blame] | 785 | param.type = auto_ptr->var + BC_RESULT_ARRAY_AUTO; |
Gavin Howard | 5732343 | 2018-03-14 20:06:35 -0600 | [diff] [blame] | 786 | |
Gavin Howard | d6e3b7b | 2018-02-28 12:31:58 -0700 | [diff] [blame] | 787 | if (auto_ptr->var) { |
| 788 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 789 | BcNum *n; |
Gavin Howard | d6e3b7b | 2018-02-28 12:31:58 -0700 | [diff] [blame] | 790 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 791 | if ((status = bc_program_num(p, arg, &n, false))) return status; |
| 792 | if ((status = bc_num_init(¶m.data.num, n->len))) return status; |
Gavin Howard | d6e3b7b | 2018-02-28 12:31:58 -0700 | [diff] [blame] | 793 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 794 | status = bc_num_copy(¶m.data.num, n); |
Gavin Howard | d6e3b7b | 2018-02-28 12:31:58 -0700 | [diff] [blame] | 795 | } |
| 796 | else { |
| 797 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 798 | BcVec *a; |
Gavin Howard | d6e3b7b | 2018-02-28 12:31:58 -0700 | [diff] [blame] | 799 | |
Gavin Howard | 90f13ad | 2018-03-17 13:32:16 -0600 | [diff] [blame] | 800 | if (arg->type != BC_RESULT_VAR || arg->type != BC_RESULT_ARRAY) |
| 801 | return BC_STATUS_EXEC_BAD_TYPE; |
Gavin Howard | d6e3b7b | 2018-02-28 12:31:58 -0700 | [diff] [blame] | 802 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 803 | status = bc_program_search(p, arg, (BcNum**) &a, BC_PROGRAM_SEARCH_ARRAY); |
Gavin Howard | 90f13ad | 2018-03-17 13:32:16 -0600 | [diff] [blame] | 804 | if (status) return status; |
Gavin Howard | d6e3b7b | 2018-02-28 12:31:58 -0700 | [diff] [blame] | 805 | |
Gavin Howard | 90f13ad | 2018-03-17 13:32:16 -0600 | [diff] [blame] | 806 | status = bc_vec_init(¶m.data.array, sizeof(BcNum), bc_num_free); |
Gavin Howard | 90f13ad | 2018-03-17 13:32:16 -0600 | [diff] [blame] | 807 | if (status) return status; |
| 808 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 809 | status = bc_array_copy(¶m.data.array, a); |
Gavin Howard | d6e3b7b | 2018-02-28 12:31:58 -0700 | [diff] [blame] | 810 | } |
| 811 | |
Gavin Howard | 90f13ad | 2018-03-17 13:32:16 -0600 | [diff] [blame] | 812 | if (status) goto err; |
| 813 | |
Gavin Howard | 0c0d192 | 2018-03-21 17:00:21 -0600 | [diff] [blame] | 814 | status = bc_vec_push(&p->results, ¶m); |
Gavin Howard | 90f13ad | 2018-03-17 13:32:16 -0600 | [diff] [blame] | 815 | } |
| 816 | |
| 817 | for (; i < func->autos.len; ++i) { |
| 818 | |
| 819 | auto_ptr = bc_vec_item_rev(&func->autos, i); |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 820 | assert(auto_ptr); |
Gavin Howard | 90f13ad | 2018-03-17 13:32:16 -0600 | [diff] [blame] | 821 | param.type = auto_ptr->var + BC_RESULT_ARRAY_AUTO; |
| 822 | |
| 823 | if (auto_ptr->var) status = bc_num_init(¶m.data.num, BC_NUM_DEF_SIZE); |
| 824 | else status = bc_vec_init(¶m.data.array, sizeof(BcNum), bc_num_free); |
| 825 | |
| 826 | if (status) return status; |
| 827 | |
Gavin Howard | 0c0d192 | 2018-03-21 17:00:21 -0600 | [diff] [blame] | 828 | status = bc_vec_push(&p->results, ¶m); |
Gavin Howard | d6e3b7b | 2018-02-28 12:31:58 -0700 | [diff] [blame] | 829 | } |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 830 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 831 | if (status) goto err; |
| 832 | |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 833 | return bc_vec_push(&p->stack, &ip); |
Gavin Howard | 5732343 | 2018-03-14 20:06:35 -0600 | [diff] [blame] | 834 | |
| 835 | err: |
| 836 | |
Gavin Howard | 90f13ad | 2018-03-17 13:32:16 -0600 | [diff] [blame] | 837 | bc_result_free(¶m); |
Gavin Howard | 5732343 | 2018-03-14 20:06:35 -0600 | [diff] [blame] | 838 | |
| 839 | return status; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 840 | } |
| 841 | |
Gavin Howard | 3f68df7 | 2018-03-22 20:30:27 -0600 | [diff] [blame] | 842 | BcStatus bc_program_return(BcProgram *p, uint8_t inst) { |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 843 | |
| 844 | BcStatus status; |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 845 | BcResult result, *operand; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 846 | BcInstPtr *ip; |
Gavin Howard | c410b0f | 2018-02-27 16:57:05 -0700 | [diff] [blame] | 847 | BcFunc *func; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 848 | |
Gavin Howard | 27fdfb9 | 2018-03-21 07:56:59 -0600 | [diff] [blame] | 849 | assert(BC_PROGRAM_CHECK_STACK(p)); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 850 | |
| 851 | ip = bc_vec_top(&p->stack); |
Gavin Howard | 27fdfb9 | 2018-03-21 07:56:59 -0600 | [diff] [blame] | 852 | assert(ip); |
Gavin Howard | 0c0d192 | 2018-03-21 17:00:21 -0600 | [diff] [blame] | 853 | assert(BC_PROGRAM_CHECK_RESULTS(p, ip->len + inst == BC_INST_RETURN)); |
Gavin Howard | c410b0f | 2018-02-27 16:57:05 -0700 | [diff] [blame] | 854 | func = bc_vec_item(&p->funcs, ip->func); |
Gavin Howard | 27fdfb9 | 2018-03-21 07:56:59 -0600 | [diff] [blame] | 855 | assert(func); |
Gavin Howard | c410b0f | 2018-02-27 16:57:05 -0700 | [diff] [blame] | 856 | |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 857 | result.type = BC_RESULT_INTERMEDIATE; |
| 858 | |
| 859 | if (inst == BC_INST_RETURN) { |
| 860 | |
| 861 | BcNum *num; |
| 862 | |
Gavin Howard | 0c0d192 | 2018-03-21 17:00:21 -0600 | [diff] [blame] | 863 | operand = bc_vec_top(&p->results); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 864 | |
Gavin Howard | 27fdfb9 | 2018-03-21 07:56:59 -0600 | [diff] [blame] | 865 | assert(operand); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 866 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 867 | if ((status = bc_program_num(p, operand, &num, false))) return status; |
| 868 | if ((status = bc_num_init(&result.data.num, num->len))) return status; |
| 869 | if ((status = bc_num_copy(&result.data.num, num))) goto err; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 870 | } |
| 871 | else { |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 872 | status = bc_num_init(&result.data.num, BC_NUM_DEF_SIZE); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 873 | if (status) return status; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 874 | bc_num_zero(&result.data.num); |
| 875 | } |
| 876 | |
Gavin Howard | c410b0f | 2018-02-27 16:57:05 -0700 | [diff] [blame] | 877 | // We need to pop arguments as well, so this takes that into account. |
Gavin Howard | 0eb2a37 | 2018-03-24 09:52:55 -0600 | [diff] [blame] | 878 | bc_vec_npop(&p->results, p->results.len - (ip->len - func->nparams)); |
Gavin Howard | c410b0f | 2018-02-27 16:57:05 -0700 | [diff] [blame] | 879 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 880 | if ((status = bc_vec_push(&p->results, &result))) goto err; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 881 | |
Gavin Howard | 0eb2a37 | 2018-03-24 09:52:55 -0600 | [diff] [blame] | 882 | bc_vec_pop(&p->stack); |
| 883 | |
| 884 | return status; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 885 | |
| 886 | err: |
| 887 | |
| 888 | bc_num_free(&result.data.num); |
| 889 | |
| 890 | return status; |
| 891 | } |
| 892 | |
Gavin Howard | 3f68df7 | 2018-03-22 20:30:27 -0600 | [diff] [blame] | 893 | unsigned long bc_program_scale(BcNum *n) { |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 894 | return (unsigned long) n->rdx; |
| 895 | } |
| 896 | |
Gavin Howard | 3f68df7 | 2018-03-22 20:30:27 -0600 | [diff] [blame] | 897 | unsigned long bc_program_length(BcNum *n) { |
Gavin Howard | 6e2fd06 | 2018-03-20 19:34:12 -0600 | [diff] [blame] | 898 | |
Gavin Howard | 740989f | 2018-03-20 19:36:06 -0600 | [diff] [blame] | 899 | unsigned long len = n->len; |
Gavin Howard | 6e2fd06 | 2018-03-20 19:34:12 -0600 | [diff] [blame] | 900 | |
| 901 | if (n->rdx == n->len) { |
Gavin Howard | 740989f | 2018-03-20 19:36:06 -0600 | [diff] [blame] | 902 | size_t i; |
Gavin Howard | 6e2fd06 | 2018-03-20 19:34:12 -0600 | [diff] [blame] | 903 | for (i = n->len - 1; i < n->len && !n->num[i]; --len, --i); |
| 904 | } |
| 905 | |
| 906 | return len; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 907 | } |
| 908 | |
Gavin Howard | 3f68df7 | 2018-03-22 20:30:27 -0600 | [diff] [blame] | 909 | BcStatus bc_program_builtin(BcProgram *p, uint8_t inst) { |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 910 | |
| 911 | BcStatus status; |
Gavin Howard | 3aa58d1 | 2018-03-05 11:21:18 -0700 | [diff] [blame] | 912 | BcResult *operand; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 913 | BcNum *num1; |
| 914 | BcResult result; |
| 915 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 916 | if ((status = bc_program_unaryOpPrep(p, &operand, &num1))) return status; |
| 917 | if ((status = bc_num_init(&result.data.num, BC_NUM_DEF_SIZE))) return status; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 918 | |
| 919 | if (inst == BC_INST_SQRT) { |
| 920 | status = bc_num_sqrt(num1, &result.data.num, p->scale); |
| 921 | } |
| 922 | else { |
| 923 | |
Gavin Howard | 9bb13e2 | 2018-02-27 17:01:42 -0700 | [diff] [blame] | 924 | BcProgramBuiltInFunc func; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 925 | unsigned long ans; |
| 926 | |
| 927 | func = inst == BC_INST_LENGTH ? bc_program_length : bc_program_scale; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 928 | ans = func(num1); |
| 929 | |
| 930 | status = bc_num_ulong2num(&result.data.num, ans); |
| 931 | } |
| 932 | |
| 933 | if (status) goto err; |
| 934 | |
Gavin Howard | 5fb956f | 2018-03-05 10:57:16 -0700 | [diff] [blame] | 935 | status = bc_program_unaryOpRetire(p, &result, BC_RESULT_INTERMEDIATE); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 936 | if (status) goto err; |
| 937 | |
| 938 | return status; |
| 939 | |
| 940 | err: |
| 941 | |
| 942 | bc_num_free(&result.data.num); |
| 943 | |
| 944 | return status; |
| 945 | } |
| 946 | |
Gavin Howard | 3f68df7 | 2018-03-22 20:30:27 -0600 | [diff] [blame] | 947 | BcStatus bc_program_pushScale(BcProgram *p) { |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 948 | |
| 949 | BcStatus status; |
| 950 | BcResult result; |
| 951 | |
| 952 | result.type = BC_RESULT_SCALE; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 953 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 954 | if ((status = bc_num_init(&result.data.num, BC_NUM_DEF_SIZE))) return status; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 955 | |
| 956 | status = bc_num_ulong2num(&result.data.num, (unsigned long) p->scale); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 957 | if (status) goto err; |
| 958 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 959 | if ((status = bc_vec_push(&p->results, &result))) goto err; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 960 | |
| 961 | return status; |
| 962 | |
| 963 | err: |
| 964 | |
| 965 | bc_num_free(&result.data.num); |
| 966 | |
| 967 | return status; |
| 968 | } |
| 969 | |
Gavin Howard | 3f68df7 | 2018-03-22 20:30:27 -0600 | [diff] [blame] | 970 | BcStatus bc_program_incdec(BcProgram *p, uint8_t inst) { |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 971 | |
| 972 | BcStatus status; |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 973 | BcResult *ptr, result, copy; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 974 | BcNum *num; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 975 | uint8_t inst2; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 976 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 977 | if ((status = bc_program_unaryOpPrep(p, &ptr, &num))) return status; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 978 | |
Gavin Howard | 101b5e6 | 2018-03-26 07:46:27 -0600 | [diff] [blame] | 979 | inst2 = inst == BC_INST_INC_PRE || inst == BC_INST_INC_POST ? |
| 980 | BC_INST_ASSIGN_PLUS : BC_INST_ASSIGN_MINUS; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 981 | |
Gavin Howard | 101b5e6 | 2018-03-26 07:46:27 -0600 | [diff] [blame] | 982 | if (inst == BC_INST_INC_POST || inst == BC_INST_DEC_POST) { |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 983 | copy.type = BC_RESULT_INTERMEDIATE; |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 984 | if ((status = bc_num_init(©.data.num, num->len))) return status; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 985 | } |
| 986 | |
| 987 | result.type = BC_RESULT_ONE; |
| 988 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 989 | if ((status = bc_vec_push(&p->results, &result))) goto err; |
| 990 | if ((status = bc_program_assign(p, inst2))) goto err; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 991 | |
Gavin Howard | 101b5e6 | 2018-03-26 07:46:27 -0600 | [diff] [blame] | 992 | if (inst == BC_INST_INC_POST || inst == BC_INST_DEC_POST) { |
Gavin Howard | 0eb2a37 | 2018-03-24 09:52:55 -0600 | [diff] [blame] | 993 | bc_vec_pop(&p->results); |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 994 | if ((status = bc_vec_push(&p->results, ©))) goto err; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 995 | } |
| 996 | |
| 997 | return status; |
| 998 | |
| 999 | err: |
| 1000 | |
Gavin Howard | 101b5e6 | 2018-03-26 07:46:27 -0600 | [diff] [blame] | 1001 | if (inst == BC_INST_INC_POST || inst == BC_INST_DEC_POST) |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 1002 | bc_num_free(©.data.num); |
| 1003 | |
| 1004 | return status; |
| 1005 | } |
Gavin Howard | e723a15 | 2018-02-27 15:24:00 -0700 | [diff] [blame] | 1006 | |
Gavin Howard | 8d1f1db | 2018-02-23 11:29:41 -0700 | [diff] [blame] | 1007 | BcStatus bc_program_init(BcProgram *p) { |
Gavin Howard | 8a596d4 | 2018-01-15 15:46:01 -0700 | [diff] [blame] | 1008 | |
Gavin Howard | d96bcae | 2018-02-07 19:16:19 -0700 | [diff] [blame] | 1009 | BcStatus s; |
Gavin Howard | 91072cf | 2018-02-08 21:07:51 -0700 | [diff] [blame] | 1010 | size_t idx; |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 1011 | char *main_name, *read_name; |
Gavin Howard | 2534a81 | 2018-02-10 15:34:15 -0700 | [diff] [blame] | 1012 | BcInstPtr ip; |
Gavin Howard | 8a596d4 | 2018-01-15 15:46:01 -0700 | [diff] [blame] | 1013 | |
Gavin Howard | 27fdfb9 | 2018-03-21 07:56:59 -0600 | [diff] [blame] | 1014 | assert(p); |
Gavin Howard | 8a596d4 | 2018-01-15 15:46:01 -0700 | [diff] [blame] | 1015 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 1016 | main_name = read_name = NULL; |
Gavin Howard | bc7cae8 | 2018-03-14 13:43:04 -0600 | [diff] [blame] | 1017 | p->nchars = 0; |
| 1018 | |
Gavin Howard | 6fc7769 | 2018-01-24 18:05:21 -0700 | [diff] [blame] | 1019 | #ifdef _POSIX_BC_BASE_MAX |
Gavin Howard | 4bc73ee | 2018-01-26 11:39:20 -0700 | [diff] [blame] | 1020 | p->base_max = _POSIX_BC_BASE_MAX; |
Gavin Howard | 6fc7769 | 2018-01-24 18:05:21 -0700 | [diff] [blame] | 1021 | #elif defined(_BC_BASE_MAX) |
Gavin Howard | 4bc73ee | 2018-01-26 11:39:20 -0700 | [diff] [blame] | 1022 | p->base_max = _BC_BASE_MAX; |
Gavin Howard | 6fc7769 | 2018-01-24 18:05:21 -0700 | [diff] [blame] | 1023 | #else |
Gavin Howard | 4bc73ee | 2018-01-26 11:39:20 -0700 | [diff] [blame] | 1024 | p->base_max = sysconf(_SC_BC_BASE_MAX); |
Gavin Howard | 6fc7769 | 2018-01-24 18:05:21 -0700 | [diff] [blame] | 1025 | #endif |
| 1026 | |
Gavin Howard | 27fdfb9 | 2018-03-21 07:56:59 -0600 | [diff] [blame] | 1027 | assert(p->base_max <= BC_BASE_MAX_DEF); |
| 1028 | p->base_max = BC_BASE_MAX_DEF; |
| 1029 | |
Gavin Howard | 6fc7769 | 2018-01-24 18:05:21 -0700 | [diff] [blame] | 1030 | #ifdef _POSIX_BC_DIM_MAX |
Gavin Howard | 4bc73ee | 2018-01-26 11:39:20 -0700 | [diff] [blame] | 1031 | p->dim_max = _POSIX_BC_DIM_MAX; |
Gavin Howard | 6fc7769 | 2018-01-24 18:05:21 -0700 | [diff] [blame] | 1032 | #elif defined(_BC_DIM_MAX) |
Gavin Howard | 4bc73ee | 2018-01-26 11:39:20 -0700 | [diff] [blame] | 1033 | p->dim_max = _BC_DIM_MAX; |
Gavin Howard | 6fc7769 | 2018-01-24 18:05:21 -0700 | [diff] [blame] | 1034 | #else |
Gavin Howard | 4bc73ee | 2018-01-26 11:39:20 -0700 | [diff] [blame] | 1035 | p->dim_max = sysconf(_SC_BC_DIM_MAX); |
Gavin Howard | 6fc7769 | 2018-01-24 18:05:21 -0700 | [diff] [blame] | 1036 | #endif |
| 1037 | |
Gavin Howard | 27fdfb9 | 2018-03-21 07:56:59 -0600 | [diff] [blame] | 1038 | assert(p->dim_max <= BC_DIM_MAX_DEF); |
| 1039 | p->dim_max = BC_DIM_MAX_DEF; |
| 1040 | |
Gavin Howard | 6fc7769 | 2018-01-24 18:05:21 -0700 | [diff] [blame] | 1041 | #ifdef _POSIX_BC_SCALE_MAX |
Gavin Howard | 4bc73ee | 2018-01-26 11:39:20 -0700 | [diff] [blame] | 1042 | p->scale_max = _POSIX_BC_SCALE_MAX; |
Gavin Howard | 6fc7769 | 2018-01-24 18:05:21 -0700 | [diff] [blame] | 1043 | #elif defined(_BC_SCALE_MAX) |
Gavin Howard | 4bc73ee | 2018-01-26 11:39:20 -0700 | [diff] [blame] | 1044 | p->scale_max = _BC_SCALE_MAX; |
Gavin Howard | 6fc7769 | 2018-01-24 18:05:21 -0700 | [diff] [blame] | 1045 | #else |
Gavin Howard | 4bc73ee | 2018-01-26 11:39:20 -0700 | [diff] [blame] | 1046 | p->scale_max = sysconf(_SC_BC_SCALE_MAX); |
Gavin Howard | 6fc7769 | 2018-01-24 18:05:21 -0700 | [diff] [blame] | 1047 | #endif |
| 1048 | |
Gavin Howard | 27fdfb9 | 2018-03-21 07:56:59 -0600 | [diff] [blame] | 1049 | assert(p->scale_max <= BC_SCALE_MAX_DEF); |
| 1050 | p->scale_max = BC_SCALE_MAX_DEF; |
| 1051 | |
Gavin Howard | 6fc7769 | 2018-01-24 18:05:21 -0700 | [diff] [blame] | 1052 | #ifdef _POSIX_BC_STRING_MAX |
Gavin Howard | 4bc73ee | 2018-01-26 11:39:20 -0700 | [diff] [blame] | 1053 | p->string_max = _POSIX_BC_STRING_MAX; |
Gavin Howard | 6fc7769 | 2018-01-24 18:05:21 -0700 | [diff] [blame] | 1054 | #elif defined(_BC_STRING_MAX) |
Gavin Howard | 4bc73ee | 2018-01-26 11:39:20 -0700 | [diff] [blame] | 1055 | p->string_max = _BC_STRING_MAX; |
Gavin Howard | 6fc7769 | 2018-01-24 18:05:21 -0700 | [diff] [blame] | 1056 | #else |
Gavin Howard | 4bc73ee | 2018-01-26 11:39:20 -0700 | [diff] [blame] | 1057 | p->string_max = sysconf(_SC_BC_STRING_MAX); |
Gavin Howard | 6fc7769 | 2018-01-24 18:05:21 -0700 | [diff] [blame] | 1058 | #endif |
| 1059 | |
Gavin Howard | 27fdfb9 | 2018-03-21 07:56:59 -0600 | [diff] [blame] | 1060 | assert(p->string_max <= BC_STRING_MAX_DEF); |
| 1061 | p->string_max = BC_STRING_MAX_DEF; |
| 1062 | |
Gavin Howard | 5d74e96 | 2018-02-26 13:44:13 -0700 | [diff] [blame] | 1063 | p->scale = 0; |
| 1064 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 1065 | if ((s = bc_num_init(&p->ibase, BC_NUM_DEF_SIZE))) return s; |
Gavin Howard | 5d74e96 | 2018-02-26 13:44:13 -0700 | [diff] [blame] | 1066 | bc_num_ten(&p->ibase); |
| 1067 | p->ibase_t = 10; |
| 1068 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 1069 | if ((s = bc_num_init(&p->obase, BC_NUM_DEF_SIZE))) goto obase_err; |
Gavin Howard | 5d74e96 | 2018-02-26 13:44:13 -0700 | [diff] [blame] | 1070 | bc_num_ten(&p->obase); |
| 1071 | p->obase_t = 10; |
| 1072 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 1073 | if ((s = bc_num_init(&p->last, BC_NUM_DEF_SIZE))) goto last_err; |
Gavin Howard | 43a027f | 2018-02-26 13:27:10 -0700 | [diff] [blame] | 1074 | bc_num_zero(&p->last); |
Gavin Howard | b5c7721 | 2018-02-14 17:12:34 -0700 | [diff] [blame] | 1075 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 1076 | if ((s = bc_num_init(&p->zero, BC_NUM_DEF_SIZE))) goto zero_err; |
Gavin Howard | 43a027f | 2018-02-26 13:27:10 -0700 | [diff] [blame] | 1077 | bc_num_zero(&p->zero); |
Gavin Howard | 5a8949e | 2018-02-05 16:46:06 -0700 | [diff] [blame] | 1078 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 1079 | if ((s = bc_num_init(&p->one, BC_NUM_DEF_SIZE))) goto one_err; |
Gavin Howard | 43a027f | 2018-02-26 13:27:10 -0700 | [diff] [blame] | 1080 | bc_num_one(&p->one); |
Gavin Howard | 645200e | 2018-02-15 15:33:35 -0700 | [diff] [blame] | 1081 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 1082 | if ((s = bc_vec_init(&p->funcs, sizeof(BcFunc), bc_func_free))) goto func_err; |
Gavin Howard | 8a596d4 | 2018-01-15 15:46:01 -0700 | [diff] [blame] | 1083 | |
Gavin Howard | d96bcae | 2018-02-07 19:16:19 -0700 | [diff] [blame] | 1084 | s = bc_veco_init(&p->func_map, sizeof(BcEntry), bc_entry_free, bc_entry_cmp); |
Gavin Howard | 1ff37d1 | 2018-02-26 09:20:51 -0700 | [diff] [blame] | 1085 | if (s) goto func_map_err; |
Gavin Howard | d96bcae | 2018-02-07 19:16:19 -0700 | [diff] [blame] | 1086 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 1087 | if (!(main_name = malloc(strlen(bc_lang_func_main) + 1))) { |
Gavin Howard | 91072cf | 2018-02-08 21:07:51 -0700 | [diff] [blame] | 1088 | s = BC_STATUS_MALLOC_FAIL; |
Gavin Howard | d50539a | 2018-02-08 20:52:57 -0700 | [diff] [blame] | 1089 | goto name_err; |
| 1090 | } |
| 1091 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 1092 | strcpy(main_name, bc_lang_func_main); |
| 1093 | s = bc_program_addFunc(p, main_name, &idx); |
| 1094 | main_name = NULL; |
Gavin Howard | a1601ae | 2018-03-17 19:43:28 -0600 | [diff] [blame] | 1095 | if (s || idx != BC_PROGRAM_MAIN) goto read_err; |
Gavin Howard | b42810f | 2018-03-09 10:07:58 -0700 | [diff] [blame] | 1096 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 1097 | if (!(read_name = malloc(strlen(bc_lang_func_read) + 1))) { |
Gavin Howard | ed392aa | 2018-02-27 13:09:26 -0700 | [diff] [blame] | 1098 | s = BC_STATUS_MALLOC_FAIL; |
| 1099 | goto read_err; |
| 1100 | } |
| 1101 | |
Gavin Howard | f456d37 | 2018-03-10 20:11:41 -0700 | [diff] [blame] | 1102 | strcpy(read_name, bc_lang_func_read); |
Gavin Howard | 859e290 | 2018-03-17 14:23:35 -0600 | [diff] [blame] | 1103 | s = bc_program_addFunc(p, read_name, &idx); |
Gavin Howard | ed392aa | 2018-02-27 13:09:26 -0700 | [diff] [blame] | 1104 | read_name = NULL; |
Gavin Howard | a1601ae | 2018-03-17 19:43:28 -0600 | [diff] [blame] | 1105 | if (s || idx != BC_PROGRAM_READ) goto var_err; |
Gavin Howard | b42810f | 2018-03-09 10:07:58 -0700 | [diff] [blame] | 1106 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 1107 | ; |
Gavin Howard | d96bcae | 2018-02-07 19:16:19 -0700 | [diff] [blame] | 1108 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 1109 | if ((s = bc_vec_init(&p->vars, sizeof(BcNum), bc_num_free))) goto var_err; |
Gavin Howard | 8a596d4 | 2018-01-15 15:46:01 -0700 | [diff] [blame] | 1110 | |
Gavin Howard | d96bcae | 2018-02-07 19:16:19 -0700 | [diff] [blame] | 1111 | s = bc_veco_init(&p->var_map, sizeof(BcEntry), bc_entry_free, bc_entry_cmp); |
Gavin Howard | 1ff37d1 | 2018-02-26 09:20:51 -0700 | [diff] [blame] | 1112 | if (s) goto var_map_err; |
Gavin Howard | d96bcae | 2018-02-07 19:16:19 -0700 | [diff] [blame] | 1113 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 1114 | if ((s = bc_vec_init(&p->arrays, sizeof(BcVec), bc_vec_free))) goto array_err; |
Gavin Howard | 8a596d4 | 2018-01-15 15:46:01 -0700 | [diff] [blame] | 1115 | |
Gavin Howard | d96bcae | 2018-02-07 19:16:19 -0700 | [diff] [blame] | 1116 | s = bc_veco_init(&p->array_map, sizeof(BcEntry), bc_entry_free, bc_entry_cmp); |
Gavin Howard | 1ff37d1 | 2018-02-26 09:20:51 -0700 | [diff] [blame] | 1117 | if (s) goto array_map_err; |
Gavin Howard | d96bcae | 2018-02-07 19:16:19 -0700 | [diff] [blame] | 1118 | |
| 1119 | s = bc_vec_init(&p->strings, sizeof(char*), bc_string_free); |
Gavin Howard | 1ff37d1 | 2018-02-26 09:20:51 -0700 | [diff] [blame] | 1120 | if (s) goto string_err; |
Gavin Howard | 5a8949e | 2018-02-05 16:46:06 -0700 | [diff] [blame] | 1121 | |
Gavin Howard | 4dbb65b | 2018-03-21 19:47:01 -0600 | [diff] [blame] | 1122 | s = bc_vec_init(&p->constants, sizeof(char*), bc_string_free); |
Gavin Howard | 1ff37d1 | 2018-02-26 09:20:51 -0700 | [diff] [blame] | 1123 | if (s) goto const_err; |
Gavin Howard | e46c682 | 2018-02-08 20:05:39 -0700 | [diff] [blame] | 1124 | |
Gavin Howard | 0c0d192 | 2018-03-21 17:00:21 -0600 | [diff] [blame] | 1125 | s = bc_vec_init(&p->results, sizeof(BcResult), bc_result_free); |
Gavin Howard | 1ff37d1 | 2018-02-26 09:20:51 -0700 | [diff] [blame] | 1126 | if (s) goto expr_err; |
Gavin Howard | 2534a81 | 2018-02-10 15:34:15 -0700 | [diff] [blame] | 1127 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 1128 | if ((s = bc_vec_init(&p->stack, sizeof(BcInstPtr), NULL))) goto stack_err; |
Gavin Howard | 2534a81 | 2018-02-10 15:34:15 -0700 | [diff] [blame] | 1129 | |
Gavin Howard | 0f32a85 | 2018-03-28 12:33:17 -0600 | [diff] [blame^] | 1130 | memset(&ip, 0, sizeof(BcInstPtr)); |
Gavin Howard | 2534a81 | 2018-02-10 15:34:15 -0700 | [diff] [blame] | 1131 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 1132 | if ((s = bc_vec_push(&p->stack, &ip))) goto push_err; |
Gavin Howard | d28e80a | 2018-01-23 18:24:18 -0700 | [diff] [blame] | 1133 | |
Gavin Howard | d96bcae | 2018-02-07 19:16:19 -0700 | [diff] [blame] | 1134 | return s; |
Gavin Howard | 8a596d4 | 2018-01-15 15:46:01 -0700 | [diff] [blame] | 1135 | |
Gavin Howard | ed392aa | 2018-02-27 13:09:26 -0700 | [diff] [blame] | 1136 | push_err: |
Gavin Howard | e4cdf56 | 2018-01-23 13:42:39 -0700 | [diff] [blame] | 1137 | |
Gavin Howard | 602178d | 2018-02-09 12:03:28 -0700 | [diff] [blame] | 1138 | bc_vec_free(&p->stack); |
Gavin Howard | e4cdf56 | 2018-01-23 13:42:39 -0700 | [diff] [blame] | 1139 | |
Gavin Howard | 2534a81 | 2018-02-10 15:34:15 -0700 | [diff] [blame] | 1140 | stack_err: |
| 1141 | |
Gavin Howard | 0c0d192 | 2018-03-21 17:00:21 -0600 | [diff] [blame] | 1142 | bc_vec_free(&p->results); |
Gavin Howard | 2534a81 | 2018-02-10 15:34:15 -0700 | [diff] [blame] | 1143 | |
| 1144 | expr_err: |
Gavin Howard | 4dc4266 | 2018-01-17 15:17:47 -0700 | [diff] [blame] | 1145 | |
Gavin Howard | e46c682 | 2018-02-08 20:05:39 -0700 | [diff] [blame] | 1146 | bc_vec_free(&p->constants); |
| 1147 | |
| 1148 | const_err: |
| 1149 | |
Gavin Howard | 5a8949e | 2018-02-05 16:46:06 -0700 | [diff] [blame] | 1150 | bc_vec_free(&p->strings); |
| 1151 | |
| 1152 | string_err: |
| 1153 | |
Gavin Howard | d96bcae | 2018-02-07 19:16:19 -0700 | [diff] [blame] | 1154 | bc_veco_free(&p->array_map); |
| 1155 | |
| 1156 | array_map_err: |
| 1157 | |
Gavin Howard | 23fa3f3 | 2018-02-05 14:45:39 -0700 | [diff] [blame] | 1158 | bc_vec_free(&p->arrays); |
Gavin Howard | 4dc4266 | 2018-01-17 15:17:47 -0700 | [diff] [blame] | 1159 | |
Gavin Howard | 8a596d4 | 2018-01-15 15:46:01 -0700 | [diff] [blame] | 1160 | array_err: |
| 1161 | |
Gavin Howard | d96bcae | 2018-02-07 19:16:19 -0700 | [diff] [blame] | 1162 | bc_veco_free(&p->var_map); |
| 1163 | |
| 1164 | var_map_err: |
| 1165 | |
Gavin Howard | 23fa3f3 | 2018-02-05 14:45:39 -0700 | [diff] [blame] | 1166 | bc_vec_free(&p->vars); |
Gavin Howard | 8a596d4 | 2018-01-15 15:46:01 -0700 | [diff] [blame] | 1167 | |
| 1168 | var_err: |
| 1169 | |
Gavin Howard | ed392aa | 2018-02-27 13:09:26 -0700 | [diff] [blame] | 1170 | if (read_name) free(read_name); |
| 1171 | |
| 1172 | read_err: |
| 1173 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 1174 | if (main_name) free(main_name); |
Gavin Howard | d50539a | 2018-02-08 20:52:57 -0700 | [diff] [blame] | 1175 | |
| 1176 | name_err: |
| 1177 | |
Gavin Howard | d96bcae | 2018-02-07 19:16:19 -0700 | [diff] [blame] | 1178 | bc_veco_free(&p->func_map); |
| 1179 | |
| 1180 | func_map_err: |
| 1181 | |
Gavin Howard | 23fa3f3 | 2018-02-05 14:45:39 -0700 | [diff] [blame] | 1182 | bc_vec_free(&p->funcs); |
Gavin Howard | 8a596d4 | 2018-01-15 15:46:01 -0700 | [diff] [blame] | 1183 | |
| 1184 | func_err: |
| 1185 | |
Gavin Howard | 8389bb2 | 2018-02-15 17:40:34 -0700 | [diff] [blame] | 1186 | bc_num_free(&p->one); |
Gavin Howard | 91072cf | 2018-02-08 21:07:51 -0700 | [diff] [blame] | 1187 | |
Gavin Howard | b5c7721 | 2018-02-14 17:12:34 -0700 | [diff] [blame] | 1188 | one_err: |
Gavin Howard | 91072cf | 2018-02-08 21:07:51 -0700 | [diff] [blame] | 1189 | |
Gavin Howard | 8389bb2 | 2018-02-15 17:40:34 -0700 | [diff] [blame] | 1190 | bc_num_free(&p->zero); |
Gavin Howard | b5c7721 | 2018-02-14 17:12:34 -0700 | [diff] [blame] | 1191 | |
| 1192 | zero_err: |
| 1193 | |
Gavin Howard | 8389bb2 | 2018-02-15 17:40:34 -0700 | [diff] [blame] | 1194 | bc_num_free(&p->last); |
Gavin Howard | 8a596d4 | 2018-01-15 15:46:01 -0700 | [diff] [blame] | 1195 | |
Gavin Howard | 5d74e96 | 2018-02-26 13:44:13 -0700 | [diff] [blame] | 1196 | last_err: |
| 1197 | |
| 1198 | bc_num_free(&p->obase); |
| 1199 | |
| 1200 | obase_err: |
| 1201 | |
| 1202 | bc_num_free(&p->ibase); |
| 1203 | |
Gavin Howard | d96bcae | 2018-02-07 19:16:19 -0700 | [diff] [blame] | 1204 | return s; |
Gavin Howard | 8a596d4 | 2018-01-15 15:46:01 -0700 | [diff] [blame] | 1205 | } |
| 1206 | |
Gavin Howard | 859e290 | 2018-03-17 14:23:35 -0600 | [diff] [blame] | 1207 | BcStatus bc_program_addFunc(BcProgram *p, char *name, size_t *idx) { |
Gavin Howard | 3b90f9f | 2018-01-17 13:01:33 -0700 | [diff] [blame] | 1208 | |
Gavin Howard | ab67e7c | 2018-02-09 10:35:44 -0700 | [diff] [blame] | 1209 | BcStatus status; |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 1210 | BcEntry entry, *entry_ptr; |
Gavin Howard | ab67e7c | 2018-02-09 10:35:44 -0700 | [diff] [blame] | 1211 | BcFunc f; |
| 1212 | |
Gavin Howard | 27fdfb9 | 2018-03-21 07:56:59 -0600 | [diff] [blame] | 1213 | assert(p && name && idx); |
Gavin Howard | 3b90f9f | 2018-01-17 13:01:33 -0700 | [diff] [blame] | 1214 | |
Gavin Howard | ab67e7c | 2018-02-09 10:35:44 -0700 | [diff] [blame] | 1215 | entry.name = name; |
Gavin Howard | ded20a2 | 2018-03-07 15:15:19 -0700 | [diff] [blame] | 1216 | entry.idx = p->funcs.len; |
Gavin Howard | ab67e7c | 2018-02-09 10:35:44 -0700 | [diff] [blame] | 1217 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 1218 | if ((status = bc_veco_insert(&p->func_map, &entry, idx))) { |
Gavin Howard | b42810f | 2018-03-09 10:07:58 -0700 | [diff] [blame] | 1219 | free(name); |
Gavin Howard | bdb2f92 | 2018-03-15 09:25:18 -0600 | [diff] [blame] | 1220 | if (status != BC_STATUS_VEC_ITEM_EXISTS) return status; |
Gavin Howard | b42810f | 2018-03-09 10:07:58 -0700 | [diff] [blame] | 1221 | } |
Gavin Howard | ded20a2 | 2018-03-07 15:15:19 -0700 | [diff] [blame] | 1222 | |
| 1223 | entry_ptr = bc_veco_item(&p->func_map, *idx); |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 1224 | assert(entry_ptr); |
Gavin Howard | ded20a2 | 2018-03-07 15:15:19 -0700 | [diff] [blame] | 1225 | *idx = entry_ptr->idx; |
Gavin Howard | ab67e7c | 2018-02-09 10:35:44 -0700 | [diff] [blame] | 1226 | |
Gavin Howard | bdb2f92 | 2018-03-15 09:25:18 -0600 | [diff] [blame] | 1227 | if (status == BC_STATUS_VEC_ITEM_EXISTS) { |
Gavin Howard | ab67e7c | 2018-02-09 10:35:44 -0700 | [diff] [blame] | 1228 | |
Gavin Howard | 0ed1232 | 2018-03-17 14:21:15 -0600 | [diff] [blame] | 1229 | BcFunc *func = bc_vec_item(&p->funcs, entry_ptr->idx); |
Gavin Howard | ab67e7c | 2018-02-09 10:35:44 -0700 | [diff] [blame] | 1230 | |
Gavin Howard | ea9a9bd | 2018-03-21 08:04:07 -0600 | [diff] [blame] | 1231 | assert(func); |
Gavin Howard | ab67e7c | 2018-02-09 10:35:44 -0700 | [diff] [blame] | 1232 | |
Gavin Howard | ed392aa | 2018-02-27 13:09:26 -0700 | [diff] [blame] | 1233 | status = BC_STATUS_SUCCESS; |
Gavin Howard | ab67e7c | 2018-02-09 10:35:44 -0700 | [diff] [blame] | 1234 | |
Gavin Howard | 90f13ad | 2018-03-17 13:32:16 -0600 | [diff] [blame] | 1235 | // We need to reset these, so the function can be repopulated. |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 1236 | func->nparams = 0; |
Gavin Howard | 0eb2a37 | 2018-03-24 09:52:55 -0600 | [diff] [blame] | 1237 | bc_vec_npop(&func->autos, func->autos.len); |
| 1238 | bc_vec_npop(&func->code, func->code.len); |
| 1239 | bc_vec_npop(&func->labels, func->labels.len); |
Gavin Howard | ab67e7c | 2018-02-09 10:35:44 -0700 | [diff] [blame] | 1240 | } |
Gavin Howard | ded20a2 | 2018-03-07 15:15:19 -0700 | [diff] [blame] | 1241 | else { |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 1242 | if ((status = bc_func_init(&f))) return status; |
Gavin Howard | ded20a2 | 2018-03-07 15:15:19 -0700 | [diff] [blame] | 1243 | status = bc_vec_push(&p->funcs, &f); |
Gavin Howard | 19470a4 | 2018-03-17 14:21:30 -0600 | [diff] [blame] | 1244 | if (status) bc_func_free(&f); |
Gavin Howard | ded20a2 | 2018-03-07 15:15:19 -0700 | [diff] [blame] | 1245 | } |
| 1246 | |
| 1247 | return status; |
Gavin Howard | 8a596d4 | 2018-01-15 15:46:01 -0700 | [diff] [blame] | 1248 | } |
| 1249 | |
Gavin Howard | abdc2d3 | 2018-03-27 08:01:08 -0600 | [diff] [blame] | 1250 | BcStatus bc_program_reset(BcProgram *p, BcStatus status, bool sig) { |
Gavin Howard | f4167dc | 2018-03-26 14:19:28 -0600 | [diff] [blame] | 1251 | |
| 1252 | BcFunc *func; |
| 1253 | BcInstPtr *ip; |
| 1254 | |
Gavin Howard | abdc2d3 | 2018-03-27 08:01:08 -0600 | [diff] [blame] | 1255 | bc_vec_npop(&p->stack, p->stack.len - 1); |
| 1256 | bc_vec_npop(&p->results, p->results.len); |
| 1257 | |
Gavin Howard | f4167dc | 2018-03-26 14:19:28 -0600 | [diff] [blame] | 1258 | func = bc_vec_item(&p->funcs, 0); |
| 1259 | assert(func); |
| 1260 | ip = bc_vec_top(&p->stack); |
| 1261 | assert(ip); |
| 1262 | |
| 1263 | ip->idx = func->code.len; |
| 1264 | |
Gavin Howard | abdc2d3 | 2018-03-27 08:01:08 -0600 | [diff] [blame] | 1265 | bcg.sig_int_catches += sig; |
| 1266 | |
| 1267 | if (!status && sig && !bcg.interactive) return BC_STATUS_QUIT; |
| 1268 | |
Gavin Howard | 46f0e42 | 2018-03-27 08:12:00 -0600 | [diff] [blame] | 1269 | if (!status && bcg.interactive) { |
| 1270 | fprintf(stderr, "%s", bc_program_ready_prompt); |
| 1271 | fflush(stderr); |
| 1272 | } |
| 1273 | |
Gavin Howard | abdc2d3 | 2018-03-27 08:01:08 -0600 | [diff] [blame] | 1274 | return status; |
Gavin Howard | f4167dc | 2018-03-26 14:19:28 -0600 | [diff] [blame] | 1275 | } |
| 1276 | |
Gavin Howard | 8d1f1db | 2018-02-23 11:29:41 -0700 | [diff] [blame] | 1277 | BcStatus bc_program_exec(BcProgram *p) { |
Gavin Howard | 5b5dc57 | 2018-01-24 11:57:38 -0700 | [diff] [blame] | 1278 | |
Gavin Howard | 7c8dc77 | 2018-02-21 12:12:11 -0700 | [diff] [blame] | 1279 | BcStatus status; |
Gavin Howard | 8d1f1db | 2018-02-23 11:29:41 -0700 | [diff] [blame] | 1280 | uint8_t *code; |
Gavin Howard | 7c8dc77 | 2018-02-21 12:12:11 -0700 | [diff] [blame] | 1281 | size_t idx; |
Gavin Howard | 195706a | 2018-02-26 17:45:58 -0700 | [diff] [blame] | 1282 | BcResult result; |
Gavin Howard | 0a2a674 | 2018-02-27 14:11:26 -0700 | [diff] [blame] | 1283 | BcFunc *func; |
Gavin Howard | 195706a | 2018-02-26 17:45:58 -0700 | [diff] [blame] | 1284 | BcInstPtr *ip; |
Gavin Howard | abdc2d3 | 2018-03-27 08:01:08 -0600 | [diff] [blame] | 1285 | bool cond, sig; |
Gavin Howard | 7c8dc77 | 2018-02-21 12:12:11 -0700 | [diff] [blame] | 1286 | |
Gavin Howard | 0a2a674 | 2018-02-27 14:11:26 -0700 | [diff] [blame] | 1287 | status = BC_STATUS_SUCCESS; |
Gavin Howard | b818116 | 2018-02-28 12:58:09 -0700 | [diff] [blame] | 1288 | cond = false; |
Gavin Howard | 0a2a674 | 2018-02-27 14:11:26 -0700 | [diff] [blame] | 1289 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 1290 | ip = bc_vec_top(&p->stack); |
| 1291 | assert(ip); |
| 1292 | func = bc_vec_item(&p->funcs, ip->func); |
| 1293 | assert(func); |
| 1294 | code = func->code.array; |
| 1295 | |
Gavin Howard | cdee77b | 2018-03-28 12:25:50 -0600 | [diff] [blame] | 1296 | while (!bcg.sig_other && bcg.sig_int == bcg.sig_int_catches && |
| 1297 | ip->idx < func->code.len) |
| 1298 | { |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 1299 | uint8_t inst = code[(ip->idx)++]; |
Gavin Howard | 7c8dc77 | 2018-02-21 12:12:11 -0700 | [diff] [blame] | 1300 | |
Gavin Howard | 7c8dc77 | 2018-02-21 12:12:11 -0700 | [diff] [blame] | 1301 | switch (inst) { |
| 1302 | |
Gavin Howard | 195706a | 2018-02-26 17:45:58 -0700 | [diff] [blame] | 1303 | case BC_INST_CALL: |
| 1304 | { |
| 1305 | status = bc_program_call(p, code, &ip->idx); |
| 1306 | break; |
| 1307 | } |
| 1308 | |
| 1309 | case BC_INST_RETURN: |
| 1310 | case BC_INST_RETURN_ZERO: |
| 1311 | { |
| 1312 | status = bc_program_return(p, inst); |
| 1313 | break; |
| 1314 | } |
| 1315 | |
Gavin Howard | 7c8dc77 | 2018-02-21 12:12:11 -0700 | [diff] [blame] | 1316 | case BC_INST_READ: |
| 1317 | { |
| 1318 | status = bc_program_read(p); |
| 1319 | break; |
| 1320 | } |
| 1321 | |
Gavin Howard | 195706a | 2018-02-26 17:45:58 -0700 | [diff] [blame] | 1322 | case BC_INST_JUMP_ZERO: |
Gavin Howard | 170fcb0 | 2018-02-27 15:27:51 -0700 | [diff] [blame] | 1323 | { |
| 1324 | BcResult *operand; |
| 1325 | BcNum *num; |
| 1326 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 1327 | if ((status = bc_program_unaryOpPrep(p, &operand, &num))) return status; |
Gavin Howard | 2a064fd | 2018-03-20 15:56:12 -0600 | [diff] [blame] | 1328 | cond = bc_num_cmp(num, &p->zero, NULL) == 0; |
Gavin Howard | 0eb2a37 | 2018-03-24 09:52:55 -0600 | [diff] [blame] | 1329 | bc_vec_pop(&p->results); |
Gavin Howard | 170fcb0 | 2018-02-27 15:27:51 -0700 | [diff] [blame] | 1330 | } |
Gavin Howard | 98d071b | 2018-03-19 19:36:23 -0600 | [diff] [blame] | 1331 | // Fallthrough. |
Gavin Howard | 195706a | 2018-02-26 17:45:58 -0700 | [diff] [blame] | 1332 | case BC_INST_JUMP: |
| 1333 | { |
Gavin Howard | 170fcb0 | 2018-02-27 15:27:51 -0700 | [diff] [blame] | 1334 | size_t idx; |
| 1335 | size_t *addr; |
| 1336 | |
| 1337 | idx = bc_program_index(code, &ip->idx); |
| 1338 | addr = bc_vec_item(&func->labels, idx); |
| 1339 | |
Gavin Howard | 27fdfb9 | 2018-03-21 07:56:59 -0600 | [diff] [blame] | 1340 | assert(addr); |
Gavin Howard | 170fcb0 | 2018-02-27 15:27:51 -0700 | [diff] [blame] | 1341 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 1342 | if (inst == BC_INST_JUMP || cond) ip->idx = *addr; |
Gavin Howard | 170fcb0 | 2018-02-27 15:27:51 -0700 | [diff] [blame] | 1343 | |
Gavin Howard | 195706a | 2018-02-26 17:45:58 -0700 | [diff] [blame] | 1344 | break; |
| 1345 | } |
| 1346 | |
| 1347 | case BC_INST_PUSH_VAR: |
Gavin Howard | 101b5e6 | 2018-03-26 07:46:27 -0600 | [diff] [blame] | 1348 | case BC_INST_PUSH_ARRAY_ELEM: |
Gavin Howard | 195706a | 2018-02-26 17:45:58 -0700 | [diff] [blame] | 1349 | { |
Gavin Howard | 843fa79 | 2018-02-27 16:42:52 -0700 | [diff] [blame] | 1350 | status = bc_program_push(p, code, &ip->idx, inst == BC_INST_PUSH_VAR); |
Gavin Howard | 195706a | 2018-02-26 17:45:58 -0700 | [diff] [blame] | 1351 | break; |
| 1352 | } |
| 1353 | |
| 1354 | case BC_INST_PUSH_LAST: |
| 1355 | { |
| 1356 | result.type = BC_RESULT_LAST; |
Gavin Howard | 0c0d192 | 2018-03-21 17:00:21 -0600 | [diff] [blame] | 1357 | status = bc_vec_push(&p->results, &result); |
Gavin Howard | 195706a | 2018-02-26 17:45:58 -0700 | [diff] [blame] | 1358 | break; |
| 1359 | } |
| 1360 | |
| 1361 | case BC_INST_PUSH_SCALE: |
| 1362 | { |
Gavin Howard | a4a7289 | 2018-02-27 09:16:10 -0700 | [diff] [blame] | 1363 | status = bc_program_pushScale(p); |
Gavin Howard | 195706a | 2018-02-26 17:45:58 -0700 | [diff] [blame] | 1364 | break; |
| 1365 | } |
| 1366 | |
| 1367 | case BC_INST_PUSH_IBASE: |
| 1368 | { |
| 1369 | result.type = BC_RESULT_IBASE; |
Gavin Howard | 0c0d192 | 2018-03-21 17:00:21 -0600 | [diff] [blame] | 1370 | status = bc_vec_push(&p->results, &result); |
Gavin Howard | 195706a | 2018-02-26 17:45:58 -0700 | [diff] [blame] | 1371 | break; |
| 1372 | } |
| 1373 | |
| 1374 | case BC_INST_PUSH_OBASE: |
| 1375 | { |
| 1376 | result.type = BC_RESULT_OBASE; |
Gavin Howard | 0c0d192 | 2018-03-21 17:00:21 -0600 | [diff] [blame] | 1377 | status = bc_vec_push(&p->results, &result); |
Gavin Howard | 195706a | 2018-02-26 17:45:58 -0700 | [diff] [blame] | 1378 | break; |
| 1379 | } |
| 1380 | |
| 1381 | case BC_INST_SCALE_FUNC: |
| 1382 | case BC_INST_LENGTH: |
| 1383 | case BC_INST_SQRT: |
| 1384 | { |
| 1385 | status = bc_program_builtin(p, inst); |
| 1386 | break; |
| 1387 | } |
| 1388 | |
| 1389 | case BC_INST_PUSH_NUM: |
| 1390 | { |
Gavin Howard | 195706a | 2018-02-26 17:45:58 -0700 | [diff] [blame] | 1391 | result.type = BC_RESULT_CONSTANT; |
| 1392 | result.data.id.idx = bc_program_index(code, &ip->idx); |
Gavin Howard | 0c0d192 | 2018-03-21 17:00:21 -0600 | [diff] [blame] | 1393 | status = bc_vec_push(&p->results, &result); |
Gavin Howard | 195706a | 2018-02-26 17:45:58 -0700 | [diff] [blame] | 1394 | break; |
| 1395 | } |
| 1396 | |
Gavin Howard | 5c222e3 | 2018-02-28 13:06:41 -0700 | [diff] [blame] | 1397 | case BC_INST_POP: |
| 1398 | { |
Gavin Howard | 0eb2a37 | 2018-03-24 09:52:55 -0600 | [diff] [blame] | 1399 | bc_vec_pop(&p->results); |
Gavin Howard | 5c222e3 | 2018-02-28 13:06:41 -0700 | [diff] [blame] | 1400 | break; |
| 1401 | } |
| 1402 | |
Gavin Howard | 101b5e6 | 2018-03-26 07:46:27 -0600 | [diff] [blame] | 1403 | case BC_INST_INC_POST: |
| 1404 | case BC_INST_DEC_POST: |
| 1405 | case BC_INST_INC_PRE: |
| 1406 | case BC_INST_DEC_PRE: |
Gavin Howard | 195706a | 2018-02-26 17:45:58 -0700 | [diff] [blame] | 1407 | { |
Gavin Howard | e723a15 | 2018-02-27 15:24:00 -0700 | [diff] [blame] | 1408 | status = bc_program_incdec(p, inst); |
Gavin Howard | 195706a | 2018-02-26 17:45:58 -0700 | [diff] [blame] | 1409 | break; |
| 1410 | } |
| 1411 | |
| 1412 | case BC_INST_HALT: |
| 1413 | { |
Gavin Howard | 01d6ec3 | 2018-03-17 19:42:02 -0600 | [diff] [blame] | 1414 | status = BC_STATUS_QUIT; |
Gavin Howard | 195706a | 2018-02-26 17:45:58 -0700 | [diff] [blame] | 1415 | break; |
| 1416 | } |
| 1417 | |
Gavin Howard | 7c8dc77 | 2018-02-21 12:12:11 -0700 | [diff] [blame] | 1418 | case BC_INST_PRINT: |
Gavin Howard | 152f3e8 | 2018-03-07 12:33:15 -0700 | [diff] [blame] | 1419 | case BC_INST_PRINT_EXPR: |
Gavin Howard | 7c8dc77 | 2018-02-21 12:12:11 -0700 | [diff] [blame] | 1420 | { |
Gavin Howard | 3aa58d1 | 2018-03-05 11:21:18 -0700 | [diff] [blame] | 1421 | BcResult *operand; |
Gavin Howard | 8d1f1db | 2018-02-23 11:29:41 -0700 | [diff] [blame] | 1422 | BcNum *num; |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 1423 | bool newline; |
Gavin Howard | 7c8dc77 | 2018-02-21 12:12:11 -0700 | [diff] [blame] | 1424 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 1425 | if ((status = bc_program_unaryOpPrep(p, &operand, &num))) return status; |
Gavin Howard | a883ad9 | 2018-02-22 13:34:41 -0700 | [diff] [blame] | 1426 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 1427 | newline = inst == BC_INST_PRINT; |
| 1428 | status = bc_num_print(num, &p->obase, p->obase_t, newline, &p->nchars); |
Gavin Howard | 534a980 | 2018-02-28 13:06:09 -0700 | [diff] [blame] | 1429 | if (status) return status; |
Gavin Howard | c44ce20 | 2018-02-21 19:02:02 -0700 | [diff] [blame] | 1430 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 1431 | if ((status = bc_num_copy(&p->last, num))) return status; |
Gavin Howard | e351e9d | 2018-02-27 09:16:42 -0700 | [diff] [blame] | 1432 | |
Gavin Howard | 0eb2a37 | 2018-03-24 09:52:55 -0600 | [diff] [blame] | 1433 | bc_vec_pop(&p->results); |
Gavin Howard | 7c8dc77 | 2018-02-21 12:12:11 -0700 | [diff] [blame] | 1434 | |
| 1435 | break; |
| 1436 | } |
| 1437 | |
| 1438 | case BC_INST_STR: |
| 1439 | { |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 1440 | const char **string, *s; |
Gavin Howard | bc7cae8 | 2018-03-14 13:43:04 -0600 | [diff] [blame] | 1441 | size_t len; |
Gavin Howard | 7c8dc77 | 2018-02-21 12:12:11 -0700 | [diff] [blame] | 1442 | |
| 1443 | idx = bc_program_index(code, &ip->idx); |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 1444 | assert(idx < p->strings.len); |
Gavin Howard | 7c8dc77 | 2018-02-21 12:12:11 -0700 | [diff] [blame] | 1445 | string = bc_vec_item(&p->strings, idx); |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 1446 | assert(string); |
Gavin Howard | 0271bfc | 2018-03-14 10:52:48 -0600 | [diff] [blame] | 1447 | |
Gavin Howard | bc7cae8 | 2018-03-14 13:43:04 -0600 | [diff] [blame] | 1448 | s = *string; |
| 1449 | len = strlen(s); |
| 1450 | |
| 1451 | for (idx = 0; idx < len; ++idx) { |
| 1452 | char c = s[idx]; |
Gavin Howard | a141a0f | 2018-03-23 13:16:10 -0600 | [diff] [blame] | 1453 | if (putchar(c) == EOF) return BC_STATUS_IO_ERR; |
Gavin Howard | bc7cae8 | 2018-03-14 13:43:04 -0600 | [diff] [blame] | 1454 | if (c == '\n') p->nchars = SIZE_MAX; |
| 1455 | ++p->nchars; |
| 1456 | } |
Gavin Howard | 7c8dc77 | 2018-02-21 12:12:11 -0700 | [diff] [blame] | 1457 | |
| 1458 | break; |
| 1459 | } |
| 1460 | |
| 1461 | case BC_INST_PRINT_STR: |
| 1462 | { |
Gavin Howard | a1ff02f | 2018-03-07 12:32:25 -0700 | [diff] [blame] | 1463 | const char **string; |
Gavin Howard | 7c8dc77 | 2018-02-21 12:12:11 -0700 | [diff] [blame] | 1464 | |
| 1465 | idx = bc_program_index(code, &ip->idx); |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 1466 | assert(idx < p->strings.len); |
Gavin Howard | 7c8dc77 | 2018-02-21 12:12:11 -0700 | [diff] [blame] | 1467 | string = bc_vec_item(&p->strings, idx); |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 1468 | assert(string); |
Gavin Howard | a1ff02f | 2018-03-07 12:32:25 -0700 | [diff] [blame] | 1469 | |
Gavin Howard | bc7cae8 | 2018-03-14 13:43:04 -0600 | [diff] [blame] | 1470 | status = bc_program_printString(*string, &p->nchars); |
Gavin Howard | 7c8dc77 | 2018-02-21 12:12:11 -0700 | [diff] [blame] | 1471 | |
| 1472 | break; |
| 1473 | } |
| 1474 | |
Gavin Howard | 101b5e6 | 2018-03-26 07:46:27 -0600 | [diff] [blame] | 1475 | case BC_INST_POWER: |
| 1476 | case BC_INST_MULTIPLY: |
| 1477 | case BC_INST_DIVIDE: |
| 1478 | case BC_INST_MODULUS: |
| 1479 | case BC_INST_PLUS: |
| 1480 | case BC_INST_MINUS: |
Gavin Howard | 7c8dc77 | 2018-02-21 12:12:11 -0700 | [diff] [blame] | 1481 | { |
| 1482 | status = bc_program_op(p, inst); |
| 1483 | break; |
| 1484 | } |
| 1485 | |
Gavin Howard | 101b5e6 | 2018-03-26 07:46:27 -0600 | [diff] [blame] | 1486 | case BC_INST_REL_EQ: |
| 1487 | case BC_INST_REL_LE: |
| 1488 | case BC_INST_REL_GE: |
| 1489 | case BC_INST_REL_NE: |
| 1490 | case BC_INST_REL_LT: |
| 1491 | case BC_INST_REL_GT: |
Gavin Howard | 195706a | 2018-02-26 17:45:58 -0700 | [diff] [blame] | 1492 | { |
Gavin Howard | 2c15400 | 2018-02-27 16:43:26 -0700 | [diff] [blame] | 1493 | status = bc_program_logical(p, inst); |
Gavin Howard | 195706a | 2018-02-26 17:45:58 -0700 | [diff] [blame] | 1494 | break; |
| 1495 | } |
| 1496 | |
Gavin Howard | 101b5e6 | 2018-03-26 07:46:27 -0600 | [diff] [blame] | 1497 | case BC_INST_BOOL_NOT: |
Gavin Howard | 195706a | 2018-02-26 17:45:58 -0700 | [diff] [blame] | 1498 | { |
Gavin Howard | e809535 | 2018-02-27 09:17:20 -0700 | [diff] [blame] | 1499 | BcResult *ptr; |
| 1500 | BcNum *num; |
| 1501 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 1502 | if ((status = bc_program_unaryOpPrep(p, &ptr, &num))) return status; |
Gavin Howard | e809535 | 2018-02-27 09:17:20 -0700 | [diff] [blame] | 1503 | |
Gavin Howard | e809535 | 2018-02-27 09:17:20 -0700 | [diff] [blame] | 1504 | status = bc_num_init(&result.data.num, BC_NUM_DEF_SIZE); |
Gavin Howard | e809535 | 2018-02-27 09:17:20 -0700 | [diff] [blame] | 1505 | if (status) return status; |
| 1506 | |
Gavin Howard | 2a064fd | 2018-03-20 15:56:12 -0600 | [diff] [blame] | 1507 | if (bc_num_cmp(num, &p->zero, NULL)) bc_num_one(&result.data.num); |
Gavin Howard | e809535 | 2018-02-27 09:17:20 -0700 | [diff] [blame] | 1508 | else bc_num_zero(&result.data.num); |
| 1509 | |
Gavin Howard | 5fb956f | 2018-03-05 10:57:16 -0700 | [diff] [blame] | 1510 | status = bc_program_unaryOpRetire(p, &result, BC_RESULT_INTERMEDIATE); |
Gavin Howard | e809535 | 2018-02-27 09:17:20 -0700 | [diff] [blame] | 1511 | |
| 1512 | if (status) bc_num_free(&result.data.num); |
| 1513 | |
Gavin Howard | 195706a | 2018-02-26 17:45:58 -0700 | [diff] [blame] | 1514 | break; |
| 1515 | } |
| 1516 | |
Gavin Howard | 101b5e6 | 2018-03-26 07:46:27 -0600 | [diff] [blame] | 1517 | case BC_INST_BOOL_OR: |
| 1518 | case BC_INST_BOOL_AND: |
Gavin Howard | 195706a | 2018-02-26 17:45:58 -0700 | [diff] [blame] | 1519 | { |
Gavin Howard | 2c15400 | 2018-02-27 16:43:26 -0700 | [diff] [blame] | 1520 | status = bc_program_logical(p, inst); |
Gavin Howard | 195706a | 2018-02-26 17:45:58 -0700 | [diff] [blame] | 1521 | break; |
| 1522 | } |
| 1523 | |
Gavin Howard | 101b5e6 | 2018-03-26 07:46:27 -0600 | [diff] [blame] | 1524 | case BC_INST_NEG: |
Gavin Howard | 7c8dc77 | 2018-02-21 12:12:11 -0700 | [diff] [blame] | 1525 | { |
Gavin Howard | 3a94736 | 2018-03-02 11:25:48 -0700 | [diff] [blame] | 1526 | status = bc_program_negate(p); |
Gavin Howard | 7c8dc77 | 2018-02-21 12:12:11 -0700 | [diff] [blame] | 1527 | break; |
| 1528 | } |
| 1529 | |
Gavin Howard | 101b5e6 | 2018-03-26 07:46:27 -0600 | [diff] [blame] | 1530 | case BC_INST_ASSIGN_POWER: |
| 1531 | case BC_INST_ASSIGN_MULTIPLY: |
| 1532 | case BC_INST_ASSIGN_DIVIDE: |
| 1533 | case BC_INST_ASSIGN_MODULUS: |
| 1534 | case BC_INST_ASSIGN_PLUS: |
| 1535 | case BC_INST_ASSIGN_MINUS: |
| 1536 | case BC_INST_ASSIGN: |
Gavin Howard | 6d89b5d | 2018-02-26 13:21:34 -0700 | [diff] [blame] | 1537 | { |
| 1538 | status = bc_program_assign(p, inst); |
| 1539 | break; |
| 1540 | } |
| 1541 | |
Gavin Howard | 7c8dc77 | 2018-02-21 12:12:11 -0700 | [diff] [blame] | 1542 | default: |
| 1543 | { |
Gavin Howard | 27fdfb9 | 2018-03-21 07:56:59 -0600 | [diff] [blame] | 1544 | assert(false); |
Gavin Howard | d11c262 | 2018-02-21 21:16:46 -0700 | [diff] [blame] | 1545 | break; |
Gavin Howard | 7c8dc77 | 2018-02-21 12:12:11 -0700 | [diff] [blame] | 1546 | } |
| 1547 | } |
Gavin Howard | 195706a | 2018-02-26 17:45:58 -0700 | [diff] [blame] | 1548 | |
Gavin Howard | 0a2a674 | 2018-02-27 14:11:26 -0700 | [diff] [blame] | 1549 | if (status) return status; |
| 1550 | |
| 1551 | // We keep getting these because if the size of the |
Gavin Howard | 195706a | 2018-02-26 17:45:58 -0700 | [diff] [blame] | 1552 | // stack changes, pointers may end up being invalid. |
| 1553 | ip = bc_vec_top(&p->stack); |
Gavin Howard | 27fdfb9 | 2018-03-21 07:56:59 -0600 | [diff] [blame] | 1554 | assert(ip); |
Gavin Howard | 0a2a674 | 2018-02-27 14:11:26 -0700 | [diff] [blame] | 1555 | func = bc_vec_item(&p->funcs, ip->func); |
Gavin Howard | 27fdfb9 | 2018-03-21 07:56:59 -0600 | [diff] [blame] | 1556 | assert(func); |
Gavin Howard | a1ff02f | 2018-03-07 12:32:25 -0700 | [diff] [blame] | 1557 | code = func->code.array; |
Gavin Howard | 7c8dc77 | 2018-02-21 12:12:11 -0700 | [diff] [blame] | 1558 | } |
| 1559 | |
Gavin Howard | abdc2d3 | 2018-03-27 08:01:08 -0600 | [diff] [blame] | 1560 | sig = bcg.sig_int != bcg.sig_int_catches; |
| 1561 | |
| 1562 | if (status || sig) status = bc_program_reset(p, status, sig); |
Gavin Howard | f4167dc | 2018-03-26 14:19:28 -0600 | [diff] [blame] | 1563 | |
Gavin Howard | 7c8dc77 | 2018-02-21 12:12:11 -0700 | [diff] [blame] | 1564 | return status; |
| 1565 | } |
| 1566 | |
Gavin Howard | 67c3852 | 2018-02-27 16:00:49 -0700 | [diff] [blame] | 1567 | BcStatus bc_program_print(BcProgram *p) { |
Gavin Howard | 0a2a674 | 2018-02-27 14:11:26 -0700 | [diff] [blame] | 1568 | |
| 1569 | BcStatus status; |
| 1570 | BcFunc *func; |
| 1571 | uint8_t *code; |
Gavin Howard | c0d9f31 | 2018-03-07 15:15:00 -0700 | [diff] [blame] | 1572 | BcInstPtr ip; |
| 1573 | size_t i; |
Gavin Howard | abdc2d3 | 2018-03-27 08:01:08 -0600 | [diff] [blame] | 1574 | bool sig; |
Gavin Howard | 0a2a674 | 2018-02-27 14:11:26 -0700 | [diff] [blame] | 1575 | |
Gavin Howard | 0a2a674 | 2018-02-27 14:11:26 -0700 | [diff] [blame] | 1576 | status = BC_STATUS_SUCCESS; |
| 1577 | |
Gavin Howard | c0d9f31 | 2018-03-07 15:15:00 -0700 | [diff] [blame] | 1578 | for (i = 0; !status && i < p->funcs.len; ++i) { |
Gavin Howard | 0a2a674 | 2018-02-27 14:11:26 -0700 | [diff] [blame] | 1579 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 1580 | ip.idx = ip.len = 0; |
Gavin Howard | c0d9f31 | 2018-03-07 15:15:00 -0700 | [diff] [blame] | 1581 | ip.func = i; |
Gavin Howard | 0a2a674 | 2018-02-27 14:11:26 -0700 | [diff] [blame] | 1582 | |
Gavin Howard | c0d9f31 | 2018-03-07 15:15:00 -0700 | [diff] [blame] | 1583 | func = bc_vec_item(&p->funcs, ip.func); |
Gavin Howard | 27fdfb9 | 2018-03-21 07:56:59 -0600 | [diff] [blame] | 1584 | assert(func); |
Gavin Howard | c0d9f31 | 2018-03-07 15:15:00 -0700 | [diff] [blame] | 1585 | code = func->code.array; |
Gavin Howard | 0a2a674 | 2018-02-27 14:11:26 -0700 | [diff] [blame] | 1586 | |
Gavin Howard | c0d9f31 | 2018-03-07 15:15:00 -0700 | [diff] [blame] | 1587 | if (printf("func[%zu]: ", ip.func) < 0) return BC_STATUS_IO_ERR; |
Gavin Howard | 0a2a674 | 2018-02-27 14:11:26 -0700 | [diff] [blame] | 1588 | |
Gavin Howard | c0d9f31 | 2018-03-07 15:15:00 -0700 | [diff] [blame] | 1589 | while (ip.idx < func->code.len) { |
Gavin Howard | 0a2a674 | 2018-02-27 14:11:26 -0700 | [diff] [blame] | 1590 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 1591 | uint8_t inst = code[ip.idx++]; |
Gavin Howard | 0a2a674 | 2018-02-27 14:11:26 -0700 | [diff] [blame] | 1592 | |
Gavin Howard | fd79719 | 2018-03-26 12:27:01 -0600 | [diff] [blame] | 1593 | if (putchar(bc_lang_inst_chars[inst]) == EOF) return BC_STATUS_IO_ERR; |
Gavin Howard | 0a2a674 | 2018-02-27 14:11:26 -0700 | [diff] [blame] | 1594 | |
Gavin Howard | 642050e | 2018-03-26 12:25:45 -0600 | [diff] [blame] | 1595 | if (inst == BC_INST_PUSH_VAR || inst == BC_INST_PUSH_ARRAY_ELEM) { |
| 1596 | if ((status = bc_program_printName(code, &ip.idx))) return status; |
| 1597 | } |
| 1598 | else if (inst == BC_INST_PUSH_NUM || inst == BC_INST_CALL || |
| 1599 | (inst >= BC_INST_STR && inst <= BC_INST_JUMP_ZERO)) |
| 1600 | { |
| 1601 | if ((status = bc_program_printIndex(code, &ip.idx))) return status; |
| 1602 | if (inst == BC_INST_CALL && (status = bc_program_printIndex(code, &ip.idx))) |
| 1603 | return status; |
Gavin Howard | 0a2a674 | 2018-02-27 14:11:26 -0700 | [diff] [blame] | 1604 | } |
| 1605 | } |
Gavin Howard | c0d9f31 | 2018-03-07 15:15:00 -0700 | [diff] [blame] | 1606 | |
Gavin Howard | c0d9f31 | 2018-03-07 15:15:00 -0700 | [diff] [blame] | 1607 | if (putchar('\n') == EOF) status = BC_STATUS_IO_ERR; |
Gavin Howard | 0a2a674 | 2018-02-27 14:11:26 -0700 | [diff] [blame] | 1608 | } |
| 1609 | |
Gavin Howard | abdc2d3 | 2018-03-27 08:01:08 -0600 | [diff] [blame] | 1610 | sig = bcg.sig_int != bcg.sig_int_catches; |
| 1611 | |
| 1612 | if (status || sig) status = bc_program_reset(p, status, sig); |
Gavin Howard | f4167dc | 2018-03-26 14:19:28 -0600 | [diff] [blame] | 1613 | |
Gavin Howard | 0a2a674 | 2018-02-27 14:11:26 -0700 | [diff] [blame] | 1614 | return status; |
| 1615 | } |
| 1616 | |
| 1617 | void bc_program_free(BcProgram *p) { |
| 1618 | |
Gavin Howard | 2a9c6e9 | 2018-03-20 21:35:18 -0600 | [diff] [blame] | 1619 | if (!p) return; |
Gavin Howard | 0a2a674 | 2018-02-27 14:11:26 -0700 | [diff] [blame] | 1620 | |
Gavin Howard | 0a2a674 | 2018-02-27 14:11:26 -0700 | [diff] [blame] | 1621 | bc_num_free(&p->ibase); |
| 1622 | bc_num_free(&p->obase); |
| 1623 | |
| 1624 | bc_vec_free(&p->funcs); |
| 1625 | bc_veco_free(&p->func_map); |
| 1626 | |
| 1627 | bc_vec_free(&p->vars); |
| 1628 | bc_veco_free(&p->var_map); |
| 1629 | |
| 1630 | bc_vec_free(&p->arrays); |
| 1631 | bc_veco_free(&p->array_map); |
| 1632 | |
| 1633 | bc_vec_free(&p->strings); |
| 1634 | bc_vec_free(&p->constants); |
| 1635 | |
Gavin Howard | 0c0d192 | 2018-03-21 17:00:21 -0600 | [diff] [blame] | 1636 | bc_vec_free(&p->results); |
Gavin Howard | 0a2a674 | 2018-02-27 14:11:26 -0700 | [diff] [blame] | 1637 | bc_vec_free(&p->stack); |
Gavin Howard | 0a2a674 | 2018-02-27 14:11:26 -0700 | [diff] [blame] | 1638 | |
| 1639 | bc_num_free(&p->last); |
| 1640 | bc_num_free(&p->zero); |
| 1641 | bc_num_free(&p->one); |
| 1642 | |
| 1643 | memset(p, 0, sizeof(BcProgram)); |
| 1644 | } |