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 | a54cabf | 2018-03-28 14:50:33 -0600 | [diff] [blame] | 31 | #include <io.h> |
Gavin Howard | 13ccc4a | 2018-02-15 14:09:41 -0700 | [diff] [blame] | 32 | #include <program.h> |
| 33 | #include <parse.h> |
Gavin Howard | 2949306 | 2018-03-20 19:57:37 -0600 | [diff] [blame] | 34 | #include <bc.h> |
Gavin Howard | 8a596d4 | 2018-01-15 15:46:01 -0700 | [diff] [blame] | 35 | |
Gavin Howard | 3f68df7 | 2018-03-22 20:30:27 -0600 | [diff] [blame] | 36 | BcStatus bc_program_search(BcProgram *p, BcResult *result, |
Gavin Howard | 375263e | 2018-09-04 15:10:18 -0600 | [diff] [blame] | 37 | BcNum **ret, bool var) |
Gavin Howard | 3affc80 | 2018-02-27 19:57:38 -0700 | [diff] [blame] | 38 | { |
| 39 | BcStatus status; |
Gavin Howard | 4b9bb2b | 2018-03-23 08:11:11 -0600 | [diff] [blame] | 40 | BcEntry entry, *entry_ptr; |
Gavin Howard | 3affc80 | 2018-02-27 19:57:38 -0700 | [diff] [blame] | 41 | BcVec *vec; |
| 42 | BcVecO *veco; |
Gavin Howard | 42d7c6d | 2018-03-20 14:09:01 -0600 | [diff] [blame] | 43 | size_t idx, ip_idx; |
Gavin Howard | 5732343 | 2018-03-14 20:06:35 -0600 | [diff] [blame] | 44 | BcAuto *a; |
Gavin Howard | 3729646 | 2018-09-07 15:57:03 -0600 | [diff] [blame] | 45 | // We use this because it has a union of BcNum and BcVec. |
| 46 | BcResult data; |
Gavin Howard | 3affc80 | 2018-02-27 19:57:38 -0700 | [diff] [blame] | 47 | |
Gavin Howard | 42d7c6d | 2018-03-20 14:09:01 -0600 | [diff] [blame] | 48 | for (ip_idx = 0; ip_idx < p->stack.len - 1; ++ip_idx) { |
Gavin Howard | 3affc80 | 2018-02-27 19:57:38 -0700 | [diff] [blame] | 49 | |
Gavin Howard | 97eb856 | 2018-03-21 08:04:29 -0600 | [diff] [blame] | 50 | BcFunc *func; |
Gavin Howard | ce8fb79 | 2018-09-04 15:08:36 -0600 | [diff] [blame] | 51 | BcInstPtr *ip = bc_vec_item_rev(&p->stack, ip_idx); |
Gavin Howard | 97eb856 | 2018-03-21 08:04:29 -0600 | [diff] [blame] | 52 | |
Gavin Howard | 42d7c6d | 2018-03-20 14:09:01 -0600 | [diff] [blame] | 53 | if (ip->func == BC_PROGRAM_READ || ip->func == BC_PROGRAM_MAIN) continue; |
Gavin Howard | 3affc80 | 2018-02-27 19:57:38 -0700 | [diff] [blame] | 54 | |
| 55 | func = bc_vec_item(&p->funcs, ip->func); |
| 56 | |
Gavin Howard | 3898d19 | 2018-03-14 20:44:33 -0600 | [diff] [blame] | 57 | for (idx = 0; idx < func->autos.len; ++idx) { |
Gavin Howard | 4b9bb2b | 2018-03-23 08:11:11 -0600 | [diff] [blame] | 58 | |
Gavin Howard | 3898d19 | 2018-03-14 20:44:33 -0600 | [diff] [blame] | 59 | a = bc_vec_item(&func->autos, idx); |
Gavin Howard | 4b9bb2b | 2018-03-23 08:11:11 -0600 | [diff] [blame] | 60 | |
Gavin Howard | 3898d19 | 2018-03-14 20:44:33 -0600 | [diff] [blame] | 61 | if (!strcmp(a->name, result->data.id.name)) { |
Gavin Howard | 3affc80 | 2018-02-27 19:57:38 -0700 | [diff] [blame] | 62 | |
Gavin Howard | 375263e | 2018-09-04 15:10:18 -0600 | [diff] [blame] | 63 | BcResult *r = bc_vec_item(&p->results, ip->len + idx); |
Gavin Howard | 3898d19 | 2018-03-14 20:44:33 -0600 | [diff] [blame] | 64 | |
Gavin Howard | 39b6408 | 2018-09-02 00:10:18 -0600 | [diff] [blame] | 65 | if (!a->var != !var) return BC_STATUS_EXEC_BAD_TYPE; |
Gavin Howard | 375263e | 2018-09-04 15:10:18 -0600 | [diff] [blame] | 66 | *ret = &r->data.num; |
Gavin Howard | 3898d19 | 2018-03-14 20:44:33 -0600 | [diff] [blame] | 67 | |
| 68 | return BC_STATUS_SUCCESS; |
| 69 | } |
Gavin Howard | 5732343 | 2018-03-14 20:06:35 -0600 | [diff] [blame] | 70 | } |
Gavin Howard | 3affc80 | 2018-02-27 19:57:38 -0700 | [diff] [blame] | 71 | } |
| 72 | |
Gavin Howard | e3c7c8e | 2018-03-23 08:15:46 -0600 | [diff] [blame] | 73 | vec = var ? &p->vars : &p->arrays; |
| 74 | veco = var ? &p->var_map : &p->array_map; |
Gavin Howard | 3affc80 | 2018-02-27 19:57:38 -0700 | [diff] [blame] | 75 | |
| 76 | entry.name = result->data.id.name; |
| 77 | entry.idx = vec->len; |
| 78 | |
Gavin Howard | ea932f0 | 2018-03-23 09:53:40 -0600 | [diff] [blame] | 79 | status = bc_veco_insert(veco, &entry, &idx); |
Gavin Howard | 3affc80 | 2018-02-27 19:57:38 -0700 | [diff] [blame] | 80 | |
Gavin Howard | ea932f0 | 2018-03-23 09:53:40 -0600 | [diff] [blame] | 81 | if (status != BC_STATUS_VEC_ITEM_EXISTS) { |
Gavin Howard | 3affc80 | 2018-02-27 19:57:38 -0700 | [diff] [blame] | 82 | |
Gavin Howard | 39b6408 | 2018-09-02 00:10:18 -0600 | [diff] [blame] | 83 | size_t len = strlen(entry.name) + 1; |
Gavin Howard | a1ff02f | 2018-03-07 12:32:25 -0700 | [diff] [blame] | 84 | |
Gavin Howard | ea932f0 | 2018-03-23 09:53:40 -0600 | [diff] [blame] | 85 | if (status) return status; |
Gavin Howard | 3affc80 | 2018-02-27 19:57:38 -0700 | [diff] [blame] | 86 | |
Gavin Howard | ea932f0 | 2018-03-23 09:53:40 -0600 | [diff] [blame] | 87 | if (!(result->data.id.name = malloc(len))) return BC_STATUS_MALLOC_FAIL; |
Gavin Howard | ea932f0 | 2018-03-23 09:53:40 -0600 | [diff] [blame] | 88 | strcpy(result->data.id.name, entry.name); |
Gavin Howard | a1ff02f | 2018-03-07 12:32:25 -0700 | [diff] [blame] | 89 | |
Gavin Howard | 39b6408 | 2018-09-02 00:10:18 -0600 | [diff] [blame] | 90 | if (var) status = bc_num_init(&data.data.num, BC_NUM_DEF_SIZE); |
Gavin Howard | ea932f0 | 2018-03-23 09:53:40 -0600 | [diff] [blame] | 91 | 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] | 92 | |
Gavin Howard | 3729646 | 2018-09-07 15:57:03 -0600 | [diff] [blame] | 93 | if (status) goto num_err; |
Gavin Howard | a628aa2 | 2018-09-12 13:52:45 -0600 | [diff] [blame] | 94 | if ((status = bc_vec_push(vec, 1, &data.data))) goto err; |
Gavin Howard | 3affc80 | 2018-02-27 19:57:38 -0700 | [diff] [blame] | 95 | } |
Gavin Howard | 3affc80 | 2018-02-27 19:57:38 -0700 | [diff] [blame] | 96 | |
| 97 | entry_ptr = bc_veco_item(veco, idx); |
Gavin Howard | 375263e | 2018-09-04 15:10:18 -0600 | [diff] [blame] | 98 | *ret = bc_vec_item(vec, entry_ptr->idx); |
Gavin Howard | 3affc80 | 2018-02-27 19:57:38 -0700 | [diff] [blame] | 99 | |
| 100 | return BC_STATUS_SUCCESS; |
Gavin Howard | 3729646 | 2018-09-07 15:57:03 -0600 | [diff] [blame] | 101 | |
| 102 | err: |
| 103 | if (var) bc_num_free(&data.data.num); |
| 104 | else bc_vec_free(&data.data.array); |
| 105 | num_err: |
| 106 | free(result->data.id.name); |
| 107 | return status; |
Gavin Howard | 3affc80 | 2018-02-27 19:57:38 -0700 | [diff] [blame] | 108 | } |
| 109 | |
Gavin Howard | 39b6408 | 2018-09-02 00:10:18 -0600 | [diff] [blame] | 110 | BcStatus bc_program_num(BcProgram *p, BcResult *result, BcNum **num, bool hex) { |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 111 | |
Gavin Howard | 4b9bb2b | 2018-03-23 08:11:11 -0600 | [diff] [blame] | 112 | BcStatus status = BC_STATUS_SUCCESS; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 113 | |
| 114 | switch (result->type) { |
| 115 | |
Gavin Howard | 45ff357 | 2018-05-15 16:33:58 -0600 | [diff] [blame] | 116 | case BC_RESULT_TEMP: |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 117 | case BC_RESULT_SCALE: |
| 118 | { |
| 119 | *num = &result->data.num; |
| 120 | break; |
| 121 | } |
| 122 | |
| 123 | case BC_RESULT_CONSTANT: |
| 124 | { |
Gavin Howard | f51b189 | 2018-09-04 10:38:51 -0600 | [diff] [blame] | 125 | char **s = bc_vec_item(&p->constants, result->data.id.idx); |
| 126 | size_t base, len = strlen(*s); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 127 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 128 | if ((status = bc_num_init(&result->data.num, len))) return status; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 129 | |
Gavin Howard | 1dc4f09 | 2018-09-21 10:46:52 -0600 | [diff] [blame] | 130 | base = hex && len == 1 ? BC_NUM_MAX_IBASE : p->ibase_t; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 131 | |
Gavin Howard | 45ff357 | 2018-05-15 16:33:58 -0600 | [diff] [blame] | 132 | if ((status = bc_num_parse(&result->data.num, *s, &p->ibase, base))) { |
Gavin Howard | 9ba6c25 | 2018-03-14 01:44:38 -0600 | [diff] [blame] | 133 | bc_num_free(&result->data.num); |
| 134 | return status; |
| 135 | } |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 136 | |
| 137 | *num = &result->data.num; |
Gavin Howard | 45ff357 | 2018-05-15 16:33:58 -0600 | [diff] [blame] | 138 | result->type = BC_RESULT_TEMP; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 139 | |
| 140 | break; |
| 141 | } |
| 142 | |
Gavin Howard | 375263e | 2018-09-04 15:10:18 -0600 | [diff] [blame] | 143 | case BC_RESULT_ARRAY_ELEM: |
| 144 | { |
| 145 | BcVec *vec; |
| 146 | |
| 147 | if ((status = bc_program_search(p, result, num, 0))) return status; |
| 148 | |
| 149 | vec = (BcVec*) *num; |
| 150 | |
| 151 | if (vec->len <= result->data.id.idx) { |
| 152 | status = bc_array_expand(vec, result->data.id.idx + 1); |
| 153 | if (status) return status; |
| 154 | } |
| 155 | |
| 156 | *num = bc_vec_item(vec, result->data.id.idx); |
| 157 | |
| 158 | break; |
| 159 | } |
| 160 | |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 161 | case BC_RESULT_VAR: |
Gavin Howard | abcc5e0 | 2018-03-14 16:02:20 -0600 | [diff] [blame] | 162 | case BC_RESULT_ARRAY: |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 163 | { |
Gavin Howard | 375263e | 2018-09-04 15:10:18 -0600 | [diff] [blame] | 164 | status = bc_program_search(p, result, num, result->type == BC_RESULT_VAR); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 165 | break; |
| 166 | } |
| 167 | |
| 168 | case BC_RESULT_LAST: |
| 169 | { |
| 170 | *num = &p->last; |
| 171 | break; |
| 172 | } |
| 173 | |
| 174 | case BC_RESULT_IBASE: |
| 175 | { |
| 176 | *num = &p->ibase; |
| 177 | break; |
| 178 | } |
| 179 | |
| 180 | case BC_RESULT_OBASE: |
| 181 | { |
| 182 | *num = &p->obase; |
| 183 | break; |
| 184 | } |
| 185 | |
| 186 | case BC_RESULT_ONE: |
| 187 | { |
| 188 | *num = &p->one; |
| 189 | break; |
| 190 | } |
| 191 | |
| 192 | default: |
| 193 | { |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 194 | // This is here to prevent compiler warnings in release mode. |
Gavin Howard | 2168fb8 | 2018-03-24 10:40:37 -0600 | [diff] [blame] | 195 | *num = &result->data.num; |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 196 | assert(false); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 197 | break; |
| 198 | } |
| 199 | } |
| 200 | |
| 201 | return status; |
| 202 | } |
Gavin Howard | 6d89b5d | 2018-02-26 13:21:34 -0700 | [diff] [blame] | 203 | |
Gavin Howard | 3f68df7 | 2018-03-22 20:30:27 -0600 | [diff] [blame] | 204 | BcStatus bc_program_binaryOpPrep(BcProgram *p, BcResult **left, BcNum **lval, |
Gavin Howard | 584db5b | 2018-09-21 10:28:32 -0600 | [diff] [blame] | 205 | BcResult **right, BcNum **rval, bool assign) |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 206 | { |
| 207 | BcStatus status; |
Gavin Howard | ef1b52e | 2018-03-20 14:02:57 -0600 | [diff] [blame] | 208 | bool hex; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 209 | |
Gavin Howard | 45ff357 | 2018-05-15 16:33:58 -0600 | [diff] [blame] | 210 | assert(p && left && lval && right && rval && BC_PROGRAM_CHECK_RESULTS(p, 2)); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 211 | |
Gavin Howard | f51b189 | 2018-09-04 10:38:51 -0600 | [diff] [blame] | 212 | *right = bc_vec_item_rev(&p->results, 0); |
| 213 | *left = bc_vec_item_rev(&p->results, 1); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 214 | |
Gavin Howard | 4c8ff2d | 2018-09-18 15:24:07 -0600 | [diff] [blame] | 215 | if ((*left)->type == BC_RESULT_ARRAY || |
| 216 | (*left)->type == BC_RESULT_ARRAY_AUTO || |
| 217 | (*right)->type == BC_RESULT_ARRAY || |
| 218 | (*right)->type == BC_RESULT_ARRAY_AUTO) |
| 219 | { |
| 220 | return BC_STATUS_EXEC_BAD_TYPE; |
| 221 | } |
| 222 | |
Gavin Howard | 584db5b | 2018-09-21 10:28:32 -0600 | [diff] [blame] | 223 | hex = assign && ((*left)->type == BC_RESULT_IBASE || |
| 224 | (*right)->type == BC_RESULT_OBASE); |
Gavin Howard | 2168fb8 | 2018-03-24 10:40:37 -0600 | [diff] [blame] | 225 | |
Gavin Howard | f51b189 | 2018-09-04 10:38:51 -0600 | [diff] [blame] | 226 | if ((status = bc_program_num(p, *left, lval, false))) return status; |
| 227 | if ((status = bc_program_num(p, *right, rval, hex))) return status; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 228 | |
Gavin Howard | ee938c0 | 2018-09-21 12:27:44 -0600 | [diff] [blame^] | 229 | // We run this again under these conditions in case any vector has been |
| 230 | // reallocated out from under the BcNums or arrays we had. |
| 231 | if (((*left)->type == (*right)->type) && |
| 232 | ((*left)->type == BC_RESULT_VAR || (*left)->type == BC_RESULT_ARRAY_ELEM)) |
| 233 | { |
| 234 | status = bc_program_num(p, *left, lval, false); |
| 235 | } |
| 236 | |
| 237 | return status; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 238 | } |
| 239 | |
Gavin Howard | 3f68df7 | 2018-03-22 20:30:27 -0600 | [diff] [blame] | 240 | BcStatus bc_program_binaryOpRetire(BcProgram *p, BcResult *result, |
| 241 | BcResultType type) |
Gavin Howard | 5fb956f | 2018-03-05 10:57:16 -0700 | [diff] [blame] | 242 | { |
Gavin Howard | 5fb956f | 2018-03-05 10:57:16 -0700 | [diff] [blame] | 243 | result->type = type; |
Gavin Howard | 0eb2a37 | 2018-03-24 09:52:55 -0600 | [diff] [blame] | 244 | bc_vec_pop(&p->results); |
| 245 | bc_vec_pop(&p->results); |
Gavin Howard | a628aa2 | 2018-09-12 13:52:45 -0600 | [diff] [blame] | 246 | return bc_vec_push(&p->results, 1, result); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 247 | } |
| 248 | |
Gavin Howard | 38bea81 | 2018-09-20 12:01:25 -0600 | [diff] [blame] | 249 | BcStatus bc_program_unaryOpPrep(BcProgram *p, BcResult **result, |
| 250 | BcNum **val, bool array_allowed) |
| 251 | { |
Gavin Howard | 0c0d192 | 2018-03-21 17:00:21 -0600 | [diff] [blame] | 252 | assert(p && result && val && BC_PROGRAM_CHECK_RESULTS(p, 1)); |
Gavin Howard | 4c8ff2d | 2018-09-18 15:24:07 -0600 | [diff] [blame] | 253 | |
Gavin Howard | f51b189 | 2018-09-04 10:38:51 -0600 | [diff] [blame] | 254 | *result = bc_vec_item_rev(&p->results, 0); |
Gavin Howard | 4c8ff2d | 2018-09-18 15:24:07 -0600 | [diff] [blame] | 255 | |
Gavin Howard | 38bea81 | 2018-09-20 12:01:25 -0600 | [diff] [blame] | 256 | if (((*result)->type == BC_RESULT_ARRAY_AUTO || |
| 257 | (*result)->type == BC_RESULT_ARRAY) && !array_allowed) |
Gavin Howard | 4c8ff2d | 2018-09-18 15:24:07 -0600 | [diff] [blame] | 258 | { |
| 259 | return BC_STATUS_EXEC_BAD_TYPE; |
| 260 | } |
| 261 | |
Gavin Howard | f51b189 | 2018-09-04 10:38:51 -0600 | [diff] [blame] | 262 | return bc_program_num(p, *result, val, false); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 263 | } |
| 264 | |
Gavin Howard | 3f68df7 | 2018-03-22 20:30:27 -0600 | [diff] [blame] | 265 | BcStatus bc_program_unaryOpRetire(BcProgram *p, BcResult *result, |
| 266 | BcResultType type) |
Gavin Howard | 5fb956f | 2018-03-05 10:57:16 -0700 | [diff] [blame] | 267 | { |
Gavin Howard | 5fb956f | 2018-03-05 10:57:16 -0700 | [diff] [blame] | 268 | result->type = type; |
Gavin Howard | 0eb2a37 | 2018-03-24 09:52:55 -0600 | [diff] [blame] | 269 | bc_vec_pop(&p->results); |
Gavin Howard | a628aa2 | 2018-09-12 13:52:45 -0600 | [diff] [blame] | 270 | return bc_vec_push(&p->results, 1, result); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 271 | } |
| 272 | |
Gavin Howard | 3f68df7 | 2018-03-22 20:30:27 -0600 | [diff] [blame] | 273 | BcStatus bc_program_op(BcProgram *p, uint8_t inst) { |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 274 | |
| 275 | BcStatus status; |
Gavin Howard | 584db5b | 2018-09-21 10:28:32 -0600 | [diff] [blame] | 276 | BcResult *opd1, *opd2, res; |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 277 | BcNum *num1, *num2; |
Gavin Howard | 6e0f3c5 | 2018-08-27 17:28:22 -0600 | [diff] [blame] | 278 | BcNumBinaryOp op; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 279 | |
Gavin Howard | 584db5b | 2018-09-21 10:28:32 -0600 | [diff] [blame] | 280 | status = bc_program_binaryOpPrep(p, &opd1, &num1, &opd2, &num2, false); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 281 | if (status) return status; |
Gavin Howard | 45ff357 | 2018-05-15 16:33:58 -0600 | [diff] [blame] | 282 | if ((status = bc_num_init(&res.data.num, BC_NUM_DEF_SIZE))) return status; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 283 | |
Gavin Howard | f51b189 | 2018-09-04 10:38:51 -0600 | [diff] [blame] | 284 | op = bc_program_ops[inst - BC_INST_POWER]; |
Gavin Howard | 45ff357 | 2018-05-15 16:33:58 -0600 | [diff] [blame] | 285 | if ((status = op(num1, num2, &res.data.num, p->scale))) goto err; |
| 286 | if ((status = bc_program_binaryOpRetire(p, &res, BC_RESULT_TEMP))) goto err; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 287 | |
| 288 | return status; |
| 289 | |
| 290 | err: |
Gavin Howard | 45ff357 | 2018-05-15 16:33:58 -0600 | [diff] [blame] | 291 | bc_num_free(&res.data.num); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 292 | return status; |
| 293 | } |
| 294 | |
Gavin Howard | 3f68df7 | 2018-03-22 20:30:27 -0600 | [diff] [blame] | 295 | BcStatus bc_program_read(BcProgram *p) { |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 296 | |
| 297 | BcStatus status; |
| 298 | BcParse parse; |
| 299 | char *buffer; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 300 | BcInstPtr ip; |
Gavin Howard | 8317a79 | 2018-09-04 22:34:53 -0600 | [diff] [blame] | 301 | size_t size = BC_BUF_SIZE; |
Gavin Howard | c891dcf | 2018-09-04 15:12:22 -0600 | [diff] [blame] | 302 | BcFunc *func = bc_vec_item(&p->funcs, BC_PROGRAM_READ); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 303 | |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 304 | func->code.len = 0; |
| 305 | |
Gavin Howard | c891dcf | 2018-09-04 15:12:22 -0600 | [diff] [blame] | 306 | if (!(buffer = malloc(size + 1))) return BC_STATUS_MALLOC_FAIL; |
Gavin Howard | 8199030 | 2018-03-29 21:35:31 -0600 | [diff] [blame] | 307 | if ((status = bc_io_getline(&buffer, &size)))goto io_err; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 308 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 309 | if ((status = bc_parse_init(&parse, p))) goto io_err; |
Gavin Howard | 9697ea8 | 2018-09-20 11:15:37 -0600 | [diff] [blame] | 310 | bc_lex_file(&parse.lex, bc_program_stdin_name); |
Gavin Howard | 68f2bae | 2018-03-26 13:02:27 -0600 | [diff] [blame] | 311 | if ((status = bc_lex_text(&parse.lex, buffer))) goto exec_err; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 312 | |
Gavin Howard | 79be14a | 2018-09-12 16:39:27 -0600 | [diff] [blame] | 313 | status = bc_parse_expr(&parse, &func->code, BC_PARSE_NOREAD, |
Gavin Howard | 38c4819 | 2018-09-14 08:57:05 -0600 | [diff] [blame] | 314 | bc_parse_next_read); |
Gavin Howard | c891dcf | 2018-09-04 15:12:22 -0600 | [diff] [blame] | 315 | if (status) return status; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 316 | |
Gavin Howard | f4167dc | 2018-03-26 14:19:28 -0600 | [diff] [blame] | 317 | if (parse.lex.token.type != BC_LEX_NEWLINE && |
| 318 | parse.lex.token.type != BC_LEX_EOF) |
| 319 | { |
| 320 | status = BC_STATUS_EXEC_BAD_READ_EXPR; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 321 | goto exec_err; |
| 322 | } |
| 323 | |
Gavin Howard | a1601ae | 2018-03-17 19:43:28 -0600 | [diff] [blame] | 324 | ip.func = BC_PROGRAM_READ; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 325 | ip.idx = 0; |
Gavin Howard | 0c0d192 | 2018-03-21 17:00:21 -0600 | [diff] [blame] | 326 | ip.len = p->results.len; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 327 | |
Gavin Howard | a628aa2 | 2018-09-12 13:52:45 -0600 | [diff] [blame] | 328 | if ((status = bc_vec_push(&p->stack, 1, &ip))) goto exec_err; |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 329 | if ((status = bc_program_exec(p))) goto exec_err; |
Gavin Howard | ceaf64d | 2018-03-05 11:20:34 -0700 | [diff] [blame] | 330 | |
Gavin Howard | 0eb2a37 | 2018-03-24 09:52:55 -0600 | [diff] [blame] | 331 | bc_vec_pop(&p->stack); |
Gavin Howard | ceaf64d | 2018-03-05 11:20:34 -0700 | [diff] [blame] | 332 | |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 333 | exec_err: |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 334 | bc_parse_free(&parse); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 335 | io_err: |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 336 | free(buffer); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 337 | return status; |
| 338 | } |
| 339 | |
Gavin Howard | 3f68df7 | 2018-03-22 20:30:27 -0600 | [diff] [blame] | 340 | size_t bc_program_index(uint8_t *code, size_t *start) { |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 341 | |
Gavin Howard | f51b189 | 2018-09-04 10:38:51 -0600 | [diff] [blame] | 342 | uint8_t bytes = code[(*start)++], i = 0; |
| 343 | size_t res = 0; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 344 | |
Gavin Howard | f51b189 | 2018-09-04 10:38:51 -0600 | [diff] [blame] | 345 | for (; i < bytes; ++i) res |= (((size_t) code[(*start)++]) << (i * CHAR_BIT)); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 346 | |
Gavin Howard | f51b189 | 2018-09-04 10:38:51 -0600 | [diff] [blame] | 347 | return res; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 348 | } |
| 349 | |
Gavin Howard | 3f68df7 | 2018-03-22 20:30:27 -0600 | [diff] [blame] | 350 | char* bc_program_name(uint8_t *code, size_t *start) { |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 351 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 352 | size_t len, i; |
Gavin Howard | f51b189 | 2018-09-04 10:38:51 -0600 | [diff] [blame] | 353 | char byte, *s, *string = (char*) (code + *start), *ptr = strchr(string, ':'); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 354 | |
| 355 | if (ptr) len = ((unsigned long) ptr) - ((unsigned long) string); |
| 356 | else len = strlen(string); |
| 357 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 358 | if (!(s = malloc(len + 1))) return NULL; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 359 | |
Gavin Howard | f6e3fb3 | 2018-08-09 13:48:59 -0600 | [diff] [blame] | 360 | for (byte = (char) code[(*start)++], i = 0; byte && byte != ':'; ++i) { |
Gavin Howard | 45ff357 | 2018-05-15 16:33:58 -0600 | [diff] [blame] | 361 | s[i] = byte; |
Gavin Howard | f6e3fb3 | 2018-08-09 13:48:59 -0600 | [diff] [blame] | 362 | byte = (char) code[(*start)++]; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 363 | } |
| 364 | |
| 365 | s[i] = '\0'; |
| 366 | |
| 367 | return s; |
| 368 | } |
| 369 | |
Gavin Howard | 3f68df7 | 2018-03-22 20:30:27 -0600 | [diff] [blame] | 370 | BcStatus bc_program_printString(const char *str, size_t *nchars) { |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 371 | |
Gavin Howard | f51b189 | 2018-09-04 10:38:51 -0600 | [diff] [blame] | 372 | size_t i, len = strlen(str); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 373 | |
Gavin Howard | bc7cae8 | 2018-03-14 13:43:04 -0600 | [diff] [blame] | 374 | for (i = 0; i < len; ++i, ++(*nchars)) { |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 375 | |
Gavin Howard | f51b189 | 2018-09-04 10:38:51 -0600 | [diff] [blame] | 376 | int err; |
| 377 | char c, c2; |
Gavin Howard | f6e3fb3 | 2018-08-09 13:48:59 -0600 | [diff] [blame] | 378 | |
Gavin Howard | 45ff357 | 2018-05-15 16:33:58 -0600 | [diff] [blame] | 379 | if ((c = str[i]) != '\\') err = putchar(c); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 380 | else { |
| 381 | |
| 382 | ++i; |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 383 | assert(i < len); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 384 | c2 = str[i]; |
| 385 | |
| 386 | switch (c2) { |
| 387 | |
| 388 | case 'a': |
| 389 | { |
Gavin Howard | a141a0f | 2018-03-23 13:16:10 -0600 | [diff] [blame] | 390 | err = putchar('\a'); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 391 | break; |
| 392 | } |
| 393 | |
| 394 | case 'b': |
| 395 | { |
Gavin Howard | a141a0f | 2018-03-23 13:16:10 -0600 | [diff] [blame] | 396 | err = putchar('\b'); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 397 | break; |
| 398 | } |
| 399 | |
| 400 | case 'e': |
| 401 | { |
Gavin Howard | a141a0f | 2018-03-23 13:16:10 -0600 | [diff] [blame] | 402 | err = putchar('\\'); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 403 | break; |
| 404 | } |
| 405 | |
| 406 | case 'f': |
| 407 | { |
Gavin Howard | a141a0f | 2018-03-23 13:16:10 -0600 | [diff] [blame] | 408 | err = putchar('\f'); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 409 | break; |
| 410 | } |
| 411 | |
| 412 | case 'n': |
| 413 | { |
Gavin Howard | a141a0f | 2018-03-23 13:16:10 -0600 | [diff] [blame] | 414 | err = putchar('\n'); |
Gavin Howard | bc7cae8 | 2018-03-14 13:43:04 -0600 | [diff] [blame] | 415 | *nchars = SIZE_MAX; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 416 | break; |
| 417 | } |
| 418 | |
| 419 | case 'r': |
| 420 | { |
Gavin Howard | a141a0f | 2018-03-23 13:16:10 -0600 | [diff] [blame] | 421 | err = putchar('\r'); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 422 | break; |
| 423 | } |
| 424 | |
| 425 | case 'q': |
| 426 | { |
Gavin Howard | a141a0f | 2018-03-23 13:16:10 -0600 | [diff] [blame] | 427 | err = putchar('"'); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 428 | break; |
| 429 | } |
| 430 | |
| 431 | case 't': |
| 432 | { |
Gavin Howard | a141a0f | 2018-03-23 13:16:10 -0600 | [diff] [blame] | 433 | err = putchar('\t'); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 434 | break; |
| 435 | } |
| 436 | |
| 437 | default: |
| 438 | { |
| 439 | // Do nothing. |
| 440 | err = 0; |
| 441 | break; |
| 442 | } |
| 443 | } |
| 444 | } |
| 445 | |
Gavin Howard | 16bba75 | 2018-03-15 11:28:29 -0600 | [diff] [blame] | 446 | if (err == EOF) return BC_STATUS_IO_ERR; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 447 | } |
| 448 | |
| 449 | return BC_STATUS_SUCCESS; |
| 450 | } |
| 451 | |
Gavin Howard | 375263e | 2018-09-04 15:10:18 -0600 | [diff] [blame] | 452 | BcStatus bc_program_push(BcProgram *p, uint8_t *code, size_t *start, |
| 453 | uint8_t inst) |
| 454 | { |
Gavin Howard | 843fa79 | 2018-02-27 16:42:52 -0700 | [diff] [blame] | 455 | BcStatus status; |
| 456 | BcResult result; |
Gavin Howard | 843fa79 | 2018-02-27 16:42:52 -0700 | [diff] [blame] | 457 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 458 | result.data.id.name = bc_program_name(code, start); |
Gavin Howard | 843fa79 | 2018-02-27 16:42:52 -0700 | [diff] [blame] | 459 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 460 | assert(result.data.id.name); |
Gavin Howard | 843fa79 | 2018-02-27 16:42:52 -0700 | [diff] [blame] | 461 | |
Gavin Howard | 375263e | 2018-09-04 15:10:18 -0600 | [diff] [blame] | 462 | if (inst == BC_INST_PUSH_VAR || inst == BC_INST_PUSH_ARRAY) { |
| 463 | result.type = inst == BC_INST_PUSH_VAR ? BC_RESULT_VAR : BC_RESULT_ARRAY; |
Gavin Howard | a628aa2 | 2018-09-12 13:52:45 -0600 | [diff] [blame] | 464 | status = bc_vec_push(&p->results, 1, &result); |
Gavin Howard | 843fa79 | 2018-02-27 16:42:52 -0700 | [diff] [blame] | 465 | } |
| 466 | else { |
| 467 | |
| 468 | BcResult *operand; |
| 469 | BcNum *num; |
| 470 | unsigned long temp; |
| 471 | |
Gavin Howard | 38bea81 | 2018-09-20 12:01:25 -0600 | [diff] [blame] | 472 | if ((status = bc_program_unaryOpPrep(p, &operand, &num, false))) goto err; |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 473 | if ((status = bc_num_ulong(num, &temp))) goto err; |
Gavin Howard | 843fa79 | 2018-02-27 16:42:52 -0700 | [diff] [blame] | 474 | |
Gavin Howard | 0dd566d | 2018-03-28 19:29:34 -0600 | [diff] [blame] | 475 | if (temp > (unsigned long) BC_MAX_DIM) { |
Gavin Howard | bdb2f92 | 2018-03-15 09:25:18 -0600 | [diff] [blame] | 476 | status = BC_STATUS_EXEC_ARRAY_LEN; |
| 477 | goto err; |
| 478 | } |
| 479 | |
Gavin Howard | 843fa79 | 2018-02-27 16:42:52 -0700 | [diff] [blame] | 480 | result.data.id.idx = (size_t) temp; |
Gavin Howard | 375263e | 2018-09-04 15:10:18 -0600 | [diff] [blame] | 481 | status = bc_program_unaryOpRetire(p, &result, BC_RESULT_ARRAY_ELEM); |
Gavin Howard | 843fa79 | 2018-02-27 16:42:52 -0700 | [diff] [blame] | 482 | } |
| 483 | |
Gavin Howard | 843fa79 | 2018-02-27 16:42:52 -0700 | [diff] [blame] | 484 | err: |
Gavin Howard | 39b6408 | 2018-09-02 00:10:18 -0600 | [diff] [blame] | 485 | if (status) free(result.data.id.name); |
Gavin Howard | 843fa79 | 2018-02-27 16:42:52 -0700 | [diff] [blame] | 486 | return status; |
| 487 | } |
| 488 | |
Gavin Howard | 3f68df7 | 2018-03-22 20:30:27 -0600 | [diff] [blame] | 489 | BcStatus bc_program_negate(BcProgram *p) { |
Gavin Howard | 3a94736 | 2018-03-02 11:25:48 -0700 | [diff] [blame] | 490 | |
| 491 | BcStatus status; |
Gavin Howard | 45ff357 | 2018-05-15 16:33:58 -0600 | [diff] [blame] | 492 | BcResult result, *ptr; |
Gavin Howard | 3a94736 | 2018-03-02 11:25:48 -0700 | [diff] [blame] | 493 | BcNum *num; |
| 494 | |
Gavin Howard | 38bea81 | 2018-09-20 12:01:25 -0600 | [diff] [blame] | 495 | if ((status = bc_program_unaryOpPrep(p, &ptr, &num, false))) return status; |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 496 | if ((status = bc_num_init(&result.data.num, num->len))) return status; |
| 497 | if ((status = bc_num_copy(&result.data.num, num))) goto err; |
Gavin Howard | 3a94736 | 2018-03-02 11:25:48 -0700 | [diff] [blame] | 498 | |
Gavin Howard | a654f11 | 2018-03-03 09:47:34 -0700 | [diff] [blame] | 499 | result.data.num.neg = !result.data.num.neg; |
| 500 | |
Gavin Howard | 45ff357 | 2018-05-15 16:33:58 -0600 | [diff] [blame] | 501 | if ((status = bc_program_unaryOpRetire(p, &result, BC_RESULT_TEMP))) goto err; |
Gavin Howard | 3a94736 | 2018-03-02 11:25:48 -0700 | [diff] [blame] | 502 | |
| 503 | return status; |
| 504 | |
| 505 | err: |
Gavin Howard | 3a94736 | 2018-03-02 11:25:48 -0700 | [diff] [blame] | 506 | bc_num_free(&result.data.num); |
Gavin Howard | 3a94736 | 2018-03-02 11:25:48 -0700 | [diff] [blame] | 507 | return status; |
| 508 | } |
| 509 | |
Gavin Howard | 3f68df7 | 2018-03-22 20:30:27 -0600 | [diff] [blame] | 510 | BcStatus bc_program_logical(BcProgram *p, uint8_t inst) { |
Gavin Howard | 843fa79 | 2018-02-27 16:42:52 -0700 | [diff] [blame] | 511 | |
| 512 | BcStatus status; |
Gavin Howard | 584db5b | 2018-09-21 10:28:32 -0600 | [diff] [blame] | 513 | BcResult *opd1, *opd2, res; |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 514 | BcNum *num1, *num2; |
Gavin Howard | 843fa79 | 2018-02-27 16:42:52 -0700 | [diff] [blame] | 515 | bool cond; |
Gavin Howard | f6e3fb3 | 2018-08-09 13:48:59 -0600 | [diff] [blame] | 516 | ssize_t cmp; |
Gavin Howard | 843fa79 | 2018-02-27 16:42:52 -0700 | [diff] [blame] | 517 | |
Gavin Howard | 584db5b | 2018-09-21 10:28:32 -0600 | [diff] [blame] | 518 | status = bc_program_binaryOpPrep(p, &opd1, &num1, &opd2, &num2, false); |
Gavin Howard | 843fa79 | 2018-02-27 16:42:52 -0700 | [diff] [blame] | 519 | if (status) return status; |
| 520 | |
Gavin Howard | 45ff357 | 2018-05-15 16:33:58 -0600 | [diff] [blame] | 521 | if ((status = bc_num_init(&res.data.num, BC_NUM_DEF_SIZE))) return status; |
Gavin Howard | 843fa79 | 2018-02-27 16:42:52 -0700 | [diff] [blame] | 522 | |
Gavin Howard | 101b5e6 | 2018-03-26 07:46:27 -0600 | [diff] [blame] | 523 | if (inst == BC_INST_BOOL_AND) |
Gavin Howard | 6a804cf | 2018-05-17 16:54:12 -0600 | [diff] [blame] | 524 | cond = bc_num_cmp(num1, &p->zero) && bc_num_cmp(num2, &p->zero); |
Gavin Howard | 101b5e6 | 2018-03-26 07:46:27 -0600 | [diff] [blame] | 525 | else if (inst == BC_INST_BOOL_OR) |
Gavin Howard | 6a804cf | 2018-05-17 16:54:12 -0600 | [diff] [blame] | 526 | cond = bc_num_cmp(num1, &p->zero) || bc_num_cmp(num2, &p->zero); |
Gavin Howard | 843fa79 | 2018-02-27 16:42:52 -0700 | [diff] [blame] | 527 | else { |
| 528 | |
Gavin Howard | 6a804cf | 2018-05-17 16:54:12 -0600 | [diff] [blame] | 529 | cmp = bc_num_cmp(num1, num2); |
Gavin Howard | 843fa79 | 2018-02-27 16:42:52 -0700 | [diff] [blame] | 530 | |
| 531 | switch (inst) { |
Gavin Howard | 101b5e6 | 2018-03-26 07:46:27 -0600 | [diff] [blame] | 532 | case BC_INST_REL_EQ: |
Gavin Howard | 843fa79 | 2018-02-27 16:42:52 -0700 | [diff] [blame] | 533 | { |
| 534 | cond = cmp == 0; |
| 535 | break; |
| 536 | } |
| 537 | |
Gavin Howard | 101b5e6 | 2018-03-26 07:46:27 -0600 | [diff] [blame] | 538 | case BC_INST_REL_LE: |
Gavin Howard | 843fa79 | 2018-02-27 16:42:52 -0700 | [diff] [blame] | 539 | { |
| 540 | cond = cmp <= 0; |
| 541 | break; |
| 542 | } |
| 543 | |
Gavin Howard | 101b5e6 | 2018-03-26 07:46:27 -0600 | [diff] [blame] | 544 | case BC_INST_REL_GE: |
Gavin Howard | 843fa79 | 2018-02-27 16:42:52 -0700 | [diff] [blame] | 545 | { |
| 546 | cond = cmp >= 0; |
| 547 | break; |
| 548 | } |
| 549 | |
Gavin Howard | 101b5e6 | 2018-03-26 07:46:27 -0600 | [diff] [blame] | 550 | case BC_INST_REL_NE: |
Gavin Howard | 843fa79 | 2018-02-27 16:42:52 -0700 | [diff] [blame] | 551 | { |
| 552 | cond = cmp != 0; |
| 553 | break; |
| 554 | } |
| 555 | |
Gavin Howard | 101b5e6 | 2018-03-26 07:46:27 -0600 | [diff] [blame] | 556 | case BC_INST_REL_LT: |
Gavin Howard | 843fa79 | 2018-02-27 16:42:52 -0700 | [diff] [blame] | 557 | { |
| 558 | cond = cmp < 0; |
| 559 | break; |
| 560 | } |
| 561 | |
Gavin Howard | 101b5e6 | 2018-03-26 07:46:27 -0600 | [diff] [blame] | 562 | case BC_INST_REL_GT: |
Gavin Howard | 843fa79 | 2018-02-27 16:42:52 -0700 | [diff] [blame] | 563 | { |
| 564 | cond = cmp > 0; |
| 565 | break; |
| 566 | } |
| 567 | |
| 568 | default: |
| 569 | { |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 570 | // This is here to silence a compiler warning in release mode. |
Gavin Howard | f955c23 | 2018-03-21 08:56:58 -0600 | [diff] [blame] | 571 | cond = 0; |
Gavin Howard | 2168fb8 | 2018-03-24 10:40:37 -0600 | [diff] [blame] | 572 | assert(cond); |
Gavin Howard | 27fdfb9 | 2018-03-21 07:56:59 -0600 | [diff] [blame] | 573 | break; |
Gavin Howard | 843fa79 | 2018-02-27 16:42:52 -0700 | [diff] [blame] | 574 | } |
| 575 | } |
Gavin Howard | 843fa79 | 2018-02-27 16:42:52 -0700 | [diff] [blame] | 576 | } |
| 577 | |
Gavin Howard | 45ff357 | 2018-05-15 16:33:58 -0600 | [diff] [blame] | 578 | (cond ? bc_num_one : bc_num_zero)(&res.data.num); |
Gavin Howard | 843fa79 | 2018-02-27 16:42:52 -0700 | [diff] [blame] | 579 | |
Gavin Howard | 45ff357 | 2018-05-15 16:33:58 -0600 | [diff] [blame] | 580 | if ((status = bc_program_binaryOpRetire(p, &res, BC_RESULT_TEMP))) goto err; |
Gavin Howard | 843fa79 | 2018-02-27 16:42:52 -0700 | [diff] [blame] | 581 | |
| 582 | return status; |
| 583 | |
| 584 | err: |
Gavin Howard | 45ff357 | 2018-05-15 16:33:58 -0600 | [diff] [blame] | 585 | bc_num_free(&res.data.num); |
Gavin Howard | 843fa79 | 2018-02-27 16:42:52 -0700 | [diff] [blame] | 586 | return status; |
| 587 | } |
| 588 | |
Gavin Howard | 3f68df7 | 2018-03-22 20:30:27 -0600 | [diff] [blame] | 589 | BcStatus bc_program_assign(BcProgram *p, uint8_t inst) { |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 590 | |
| 591 | BcStatus status; |
Gavin Howard | 45ff357 | 2018-05-15 16:33:58 -0600 | [diff] [blame] | 592 | BcResult *left, *right, res; |
| 593 | BcNum *l, *r; |
Gavin Howard | 45ff357 | 2018-05-15 16:33:58 -0600 | [diff] [blame] | 594 | unsigned long val, max; |
Gavin Howard | 584db5b | 2018-09-21 10:28:32 -0600 | [diff] [blame] | 595 | bool assign = inst == BC_INST_ASSIGN; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 596 | |
Gavin Howard | 584db5b | 2018-09-21 10:28:32 -0600 | [diff] [blame] | 597 | status = bc_program_binaryOpPrep(p, &left, &l, &right, &r, assign); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 598 | if (status) return status; |
| 599 | |
Gavin Howard | 45ff357 | 2018-05-15 16:33:58 -0600 | [diff] [blame] | 600 | if (left->type == BC_RESULT_CONSTANT || left->type == BC_RESULT_TEMP) |
Gavin Howard | bdb2f92 | 2018-03-15 09:25:18 -0600 | [diff] [blame] | 601 | return BC_STATUS_PARSE_BAD_ASSIGN; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 602 | |
Gavin Howard | 6a804cf | 2018-05-17 16:54:12 -0600 | [diff] [blame] | 603 | if (inst == BC_INST_ASSIGN_DIVIDE && !bc_num_cmp(r, &p->zero)) |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 604 | return BC_STATUS_MATH_DIVIDE_BY_ZERO; |
| 605 | |
Gavin Howard | 584db5b | 2018-09-21 10:28:32 -0600 | [diff] [blame] | 606 | if (assign) status = bc_num_copy(l, r); |
Gavin Howard | f51b189 | 2018-09-04 10:38:51 -0600 | [diff] [blame] | 607 | else status = bc_program_ops[inst - BC_INST_ASSIGN_POWER](l, r, l, p->scale); |
Gavin Howard | d5a51e6 | 2018-03-26 12:34:27 -0600 | [diff] [blame] | 608 | |
| 609 | if (status) return status; |
| 610 | |
| 611 | if (left->type == BC_RESULT_IBASE || left->type == BC_RESULT_OBASE) { |
| 612 | |
Gavin Howard | 1dc4f09 | 2018-09-21 10:46:52 -0600 | [diff] [blame] | 613 | size_t * ptr = left->type == BC_RESULT_IBASE ? &p->ibase_t : &p->obase_t; |
Gavin Howard | d5a51e6 | 2018-03-26 12:34:27 -0600 | [diff] [blame] | 614 | |
Gavin Howard | 45ff357 | 2018-05-15 16:33:58 -0600 | [diff] [blame] | 615 | if ((status = bc_num_ulong(l, &val))) return status; |
Gavin Howard | d5a51e6 | 2018-03-26 12:34:27 -0600 | [diff] [blame] | 616 | |
Gavin Howard | 691cfd5 | 2018-09-21 10:47:58 -0600 | [diff] [blame] | 617 | max = left->type == BC_RESULT_IBASE ? BC_NUM_MAX_IBASE : BC_MAX_OBASE; |
| 618 | |
Gavin Howard | 45ff357 | 2018-05-15 16:33:58 -0600 | [diff] [blame] | 619 | if (val < BC_NUM_MIN_BASE || val > max) |
Gavin Howard | 8d482d9 | 2018-09-21 10:30:20 -0600 | [diff] [blame] | 620 | return left->type == BC_RESULT_IBASE ? BC_STATUS_EXEC_BAD_IBASE : |
| 621 | BC_STATUS_EXEC_BAD_OBASE; |
Gavin Howard | d5a51e6 | 2018-03-26 12:34:27 -0600 | [diff] [blame] | 622 | |
Gavin Howard | 45ff357 | 2018-05-15 16:33:58 -0600 | [diff] [blame] | 623 | *ptr = (size_t) val; |
Gavin Howard | d5a51e6 | 2018-03-26 12:34:27 -0600 | [diff] [blame] | 624 | } |
| 625 | else if (left->type == BC_RESULT_SCALE) { |
| 626 | |
Gavin Howard | 45ff357 | 2018-05-15 16:33:58 -0600 | [diff] [blame] | 627 | if ((status = bc_num_ulong(l, &val))) return status; |
| 628 | if (val > (unsigned long) BC_MAX_SCALE) return BC_STATUS_EXEC_BAD_SCALE; |
Gavin Howard | d5a51e6 | 2018-03-26 12:34:27 -0600 | [diff] [blame] | 629 | |
Gavin Howard | 45ff357 | 2018-05-15 16:33:58 -0600 | [diff] [blame] | 630 | p->scale = (size_t) val; |
Gavin Howard | d5a51e6 | 2018-03-26 12:34:27 -0600 | [diff] [blame] | 631 | } |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 632 | |
Gavin Howard | 45ff357 | 2018-05-15 16:33:58 -0600 | [diff] [blame] | 633 | if ((status = bc_num_init(&res.data.num, l->len))) return status; |
| 634 | if ((status = bc_num_copy(&res.data.num, l))) goto err; |
Gavin Howard | b818116 | 2018-02-28 12:58:09 -0700 | [diff] [blame] | 635 | |
Gavin Howard | 45ff357 | 2018-05-15 16:33:58 -0600 | [diff] [blame] | 636 | if ((status = bc_program_binaryOpRetire(p, &res, BC_RESULT_TEMP))) goto err; |
Gavin Howard | b818116 | 2018-02-28 12:58:09 -0700 | [diff] [blame] | 637 | |
| 638 | return status; |
| 639 | |
| 640 | err: |
Gavin Howard | 45ff357 | 2018-05-15 16:33:58 -0600 | [diff] [blame] | 641 | bc_num_free(&res.data.num); |
Gavin Howard | b818116 | 2018-02-28 12:58:09 -0700 | [diff] [blame] | 642 | return status; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 643 | } |
| 644 | |
Gavin Howard | 3f68df7 | 2018-03-22 20:30:27 -0600 | [diff] [blame] | 645 | BcStatus bc_program_call(BcProgram *p, uint8_t *code, size_t *idx) { |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 646 | |
Gavin Howard | f51b189 | 2018-09-04 10:38:51 -0600 | [diff] [blame] | 647 | BcStatus status = BC_STATUS_SUCCESS; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 648 | BcInstPtr ip; |
Gavin Howard | f51b189 | 2018-09-04 10:38:51 -0600 | [diff] [blame] | 649 | size_t i, nparams = bc_program_index(code, idx); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 650 | BcFunc *func; |
Gavin Howard | d6e3b7b | 2018-02-28 12:31:58 -0700 | [diff] [blame] | 651 | BcAuto *auto_ptr; |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 652 | BcResult param, *arg; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 653 | |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 654 | ip.idx = 0; |
Gavin Howard | 0c0d192 | 2018-03-21 17:00:21 -0600 | [diff] [blame] | 655 | ip.len = p->results.len; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 656 | ip.func = bc_program_index(code, idx); |
| 657 | |
| 658 | func = bc_vec_item(&p->funcs, ip.func); |
| 659 | |
Gavin Howard | ea9a9bd | 2018-03-21 08:04:07 -0600 | [diff] [blame] | 660 | if (!func->code.len) return BC_STATUS_EXEC_UNDEFINED_FUNC; |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 661 | if (nparams != func->nparams) return BC_STATUS_EXEC_MISMATCHED_PARAMS; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 662 | |
Gavin Howard | 3d3f73e | 2018-03-19 17:51:14 -0600 | [diff] [blame] | 663 | for (i = 0; i < nparams; ++i) { |
Gavin Howard | d6e3b7b | 2018-02-28 12:31:58 -0700 | [diff] [blame] | 664 | |
Gavin Howard | 3d3f73e | 2018-03-19 17:51:14 -0600 | [diff] [blame] | 665 | auto_ptr = bc_vec_item(&func->autos, i); |
Gavin Howard | 0c0d192 | 2018-03-21 17:00:21 -0600 | [diff] [blame] | 666 | arg = bc_vec_item_rev(&p->results, nparams - 1); |
Gavin Howard | 90f13ad | 2018-03-17 13:32:16 -0600 | [diff] [blame] | 667 | param.type = auto_ptr->var + BC_RESULT_ARRAY_AUTO; |
Gavin Howard | 5732343 | 2018-03-14 20:06:35 -0600 | [diff] [blame] | 668 | |
Gavin Howard | 1ce8325 | 2018-09-04 15:21:47 -0600 | [diff] [blame] | 669 | if (!auto_ptr->var != (arg->type == BC_RESULT_ARRAY)) |
| 670 | return BC_STATUS_EXEC_BAD_TYPE; |
| 671 | |
Gavin Howard | d6e3b7b | 2018-02-28 12:31:58 -0700 | [diff] [blame] | 672 | if (auto_ptr->var) { |
| 673 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 674 | BcNum *n; |
Gavin Howard | d6e3b7b | 2018-02-28 12:31:58 -0700 | [diff] [blame] | 675 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 676 | if ((status = bc_program_num(p, arg, &n, false))) return status; |
| 677 | if ((status = bc_num_init(¶m.data.num, n->len))) return status; |
Gavin Howard | d6e3b7b | 2018-02-28 12:31:58 -0700 | [diff] [blame] | 678 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 679 | status = bc_num_copy(¶m.data.num, n); |
Gavin Howard | d6e3b7b | 2018-02-28 12:31:58 -0700 | [diff] [blame] | 680 | } |
| 681 | else { |
| 682 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 683 | BcVec *a; |
Gavin Howard | d6e3b7b | 2018-02-28 12:31:58 -0700 | [diff] [blame] | 684 | |
Gavin Howard | 71815ed | 2018-09-04 16:33:13 -0600 | [diff] [blame] | 685 | if ((status = bc_program_search(p, arg, (BcNum**) &a, 0))) return status; |
Gavin Howard | 90f13ad | 2018-03-17 13:32:16 -0600 | [diff] [blame] | 686 | status = bc_vec_init(¶m.data.array, sizeof(BcNum), bc_num_free); |
Gavin Howard | 90f13ad | 2018-03-17 13:32:16 -0600 | [diff] [blame] | 687 | if (status) return status; |
| 688 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 689 | status = bc_array_copy(¶m.data.array, a); |
Gavin Howard | d6e3b7b | 2018-02-28 12:31:58 -0700 | [diff] [blame] | 690 | } |
| 691 | |
Gavin Howard | a628aa2 | 2018-09-12 13:52:45 -0600 | [diff] [blame] | 692 | if (status || (status = bc_vec_push(&p->results, 1, ¶m))) goto err; |
Gavin Howard | 90f13ad | 2018-03-17 13:32:16 -0600 | [diff] [blame] | 693 | } |
| 694 | |
Gavin Howard | 45ff357 | 2018-05-15 16:33:58 -0600 | [diff] [blame] | 695 | for (; !status && i < func->autos.len; ++i) { |
Gavin Howard | 90f13ad | 2018-03-17 13:32:16 -0600 | [diff] [blame] | 696 | |
| 697 | auto_ptr = bc_vec_item_rev(&func->autos, i); |
Gavin Howard | 90f13ad | 2018-03-17 13:32:16 -0600 | [diff] [blame] | 698 | param.type = auto_ptr->var + BC_RESULT_ARRAY_AUTO; |
| 699 | |
| 700 | if (auto_ptr->var) status = bc_num_init(¶m.data.num, BC_NUM_DEF_SIZE); |
| 701 | else status = bc_vec_init(¶m.data.array, sizeof(BcNum), bc_num_free); |
| 702 | |
| 703 | if (status) return status; |
Gavin Howard | a628aa2 | 2018-09-12 13:52:45 -0600 | [diff] [blame] | 704 | status = bc_vec_push(&p->results, 1, ¶m); |
Gavin Howard | d6e3b7b | 2018-02-28 12:31:58 -0700 | [diff] [blame] | 705 | } |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 706 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 707 | if (status) goto err; |
| 708 | |
Gavin Howard | a628aa2 | 2018-09-12 13:52:45 -0600 | [diff] [blame] | 709 | return bc_vec_push(&p->stack, 1, &ip); |
Gavin Howard | 5732343 | 2018-03-14 20:06:35 -0600 | [diff] [blame] | 710 | |
| 711 | err: |
Gavin Howard | 90f13ad | 2018-03-17 13:32:16 -0600 | [diff] [blame] | 712 | bc_result_free(¶m); |
Gavin Howard | 5732343 | 2018-03-14 20:06:35 -0600 | [diff] [blame] | 713 | return status; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 714 | } |
| 715 | |
Gavin Howard | 3f68df7 | 2018-03-22 20:30:27 -0600 | [diff] [blame] | 716 | BcStatus bc_program_return(BcProgram *p, uint8_t inst) { |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 717 | |
| 718 | BcStatus status; |
Gavin Howard | f51b189 | 2018-09-04 10:38:51 -0600 | [diff] [blame] | 719 | BcResult result; |
Gavin Howard | c410b0f | 2018-02-27 16:57:05 -0700 | [diff] [blame] | 720 | BcFunc *func; |
Gavin Howard | f51b189 | 2018-09-04 10:38:51 -0600 | [diff] [blame] | 721 | BcInstPtr *ip = bc_vec_top(&p->stack); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 722 | |
Gavin Howard | 27fdfb9 | 2018-03-21 07:56:59 -0600 | [diff] [blame] | 723 | assert(BC_PROGRAM_CHECK_STACK(p)); |
Gavin Howard | 0c0d192 | 2018-03-21 17:00:21 -0600 | [diff] [blame] | 724 | assert(BC_PROGRAM_CHECK_RESULTS(p, ip->len + inst == BC_INST_RETURN)); |
Gavin Howard | c410b0f | 2018-02-27 16:57:05 -0700 | [diff] [blame] | 725 | |
Gavin Howard | f51b189 | 2018-09-04 10:38:51 -0600 | [diff] [blame] | 726 | func = bc_vec_item(&p->funcs, ip->func); |
Gavin Howard | 45ff357 | 2018-05-15 16:33:58 -0600 | [diff] [blame] | 727 | result.type = BC_RESULT_TEMP; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 728 | |
| 729 | if (inst == BC_INST_RETURN) { |
| 730 | |
| 731 | BcNum *num; |
Gavin Howard | f51b189 | 2018-09-04 10:38:51 -0600 | [diff] [blame] | 732 | BcResult *operand = bc_vec_top(&p->results); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 733 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 734 | if ((status = bc_program_num(p, operand, &num, false))) return status; |
| 735 | if ((status = bc_num_init(&result.data.num, num->len))) return status; |
| 736 | if ((status = bc_num_copy(&result.data.num, num))) goto err; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 737 | } |
| 738 | else { |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 739 | status = bc_num_init(&result.data.num, BC_NUM_DEF_SIZE); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 740 | if (status) return status; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 741 | bc_num_zero(&result.data.num); |
| 742 | } |
| 743 | |
Gavin Howard | c410b0f | 2018-02-27 16:57:05 -0700 | [diff] [blame] | 744 | // 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] | 745 | bc_vec_npop(&p->results, p->results.len - (ip->len - func->nparams)); |
Gavin Howard | c410b0f | 2018-02-27 16:57:05 -0700 | [diff] [blame] | 746 | |
Gavin Howard | a628aa2 | 2018-09-12 13:52:45 -0600 | [diff] [blame] | 747 | if ((status = bc_vec_push(&p->results, 1, &result))) goto err; |
Gavin Howard | 0eb2a37 | 2018-03-24 09:52:55 -0600 | [diff] [blame] | 748 | bc_vec_pop(&p->stack); |
| 749 | |
| 750 | return status; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 751 | |
| 752 | err: |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 753 | bc_num_free(&result.data.num); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 754 | return status; |
| 755 | } |
| 756 | |
Gavin Howard | 3f68df7 | 2018-03-22 20:30:27 -0600 | [diff] [blame] | 757 | unsigned long bc_program_scale(BcNum *n) { |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 758 | return (unsigned long) n->rdx; |
| 759 | } |
| 760 | |
Gavin Howard | 77d489d | 2018-09-04 15:14:06 -0600 | [diff] [blame] | 761 | unsigned long bc_program_len(BcNum *n) { |
Gavin Howard | 6e2fd06 | 2018-03-20 19:34:12 -0600 | [diff] [blame] | 762 | |
Gavin Howard | 740989f | 2018-03-20 19:36:06 -0600 | [diff] [blame] | 763 | unsigned long len = n->len; |
Gavin Howard | 6e2fd06 | 2018-03-20 19:34:12 -0600 | [diff] [blame] | 764 | |
| 765 | if (n->rdx == n->len) { |
Gavin Howard | f6e3fb3 | 2018-08-09 13:48:59 -0600 | [diff] [blame] | 766 | size_t i; |
Gavin Howard | 6e2fd06 | 2018-03-20 19:34:12 -0600 | [diff] [blame] | 767 | for (i = n->len - 1; i < n->len && !n->num[i]; --len, --i); |
| 768 | } |
| 769 | |
| 770 | return len; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 771 | } |
| 772 | |
Gavin Howard | 3f68df7 | 2018-03-22 20:30:27 -0600 | [diff] [blame] | 773 | BcStatus bc_program_builtin(BcProgram *p, uint8_t inst) { |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 774 | |
| 775 | BcStatus status; |
Gavin Howard | 3aa58d1 | 2018-03-05 11:21:18 -0700 | [diff] [blame] | 776 | BcResult *operand; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 777 | BcNum *num1; |
| 778 | BcResult result; |
| 779 | |
Gavin Howard | 38bea81 | 2018-09-20 12:01:25 -0600 | [diff] [blame] | 780 | status = bc_program_unaryOpPrep(p, &operand, &num1, inst == BC_INST_LENGTH); |
| 781 | if (status) return status; |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 782 | 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] | 783 | |
Gavin Howard | 45ff357 | 2018-05-15 16:33:58 -0600 | [diff] [blame] | 784 | if (inst == BC_INST_SQRT) |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 785 | status = bc_num_sqrt(num1, &result.data.num, p->scale); |
Gavin Howard | 71815ed | 2018-09-04 16:33:13 -0600 | [diff] [blame] | 786 | else if (inst == BC_INST_LENGTH && operand->type == BC_RESULT_ARRAY) { |
Gavin Howard | 77d489d | 2018-09-04 15:14:06 -0600 | [diff] [blame] | 787 | BcVec *vec = (BcVec*) num1; |
| 788 | status = bc_num_ulong2num(&result.data.num, (unsigned long) vec->len); |
| 789 | } |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 790 | else { |
Gavin Howard | 7061017 | 2018-09-05 20:30:08 -0600 | [diff] [blame] | 791 | assert(operand->type != BC_RESULT_ARRAY); |
Gavin Howard | 77d489d | 2018-09-04 15:14:06 -0600 | [diff] [blame] | 792 | BcProgramBuiltIn f = inst == BC_INST_LENGTH ? bc_program_len : |
| 793 | bc_program_scale; |
| 794 | status = bc_num_ulong2num(&result.data.num, f(num1)); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 795 | } |
| 796 | |
Gavin Howard | 21427f5 | 2018-09-05 10:40:20 -0600 | [diff] [blame] | 797 | if (status || (status = bc_program_unaryOpRetire(p, &result, BC_RESULT_TEMP))) |
| 798 | goto err; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 799 | |
| 800 | err: |
Gavin Howard | 39b6408 | 2018-09-02 00:10:18 -0600 | [diff] [blame] | 801 | if (status) bc_num_free(&result.data.num); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 802 | return status; |
| 803 | } |
| 804 | |
Gavin Howard | 3f68df7 | 2018-03-22 20:30:27 -0600 | [diff] [blame] | 805 | BcStatus bc_program_pushScale(BcProgram *p) { |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 806 | |
| 807 | BcStatus status; |
| 808 | BcResult result; |
| 809 | |
| 810 | result.type = BC_RESULT_SCALE; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 811 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 812 | 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] | 813 | status = bc_num_ulong2num(&result.data.num, (unsigned long) p->scale); |
Gavin Howard | a628aa2 | 2018-09-12 13:52:45 -0600 | [diff] [blame] | 814 | if (status || (status = bc_vec_push(&p->results, 1, &result))) goto err; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 815 | |
| 816 | return status; |
| 817 | |
| 818 | err: |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 819 | bc_num_free(&result.data.num); |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 820 | return status; |
| 821 | } |
| 822 | |
Gavin Howard | 3f68df7 | 2018-03-22 20:30:27 -0600 | [diff] [blame] | 823 | BcStatus bc_program_incdec(BcProgram *p, uint8_t inst) { |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 824 | |
| 825 | BcStatus status; |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 826 | BcResult *ptr, result, copy; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 827 | BcNum *num; |
Gavin Howard | 7061017 | 2018-09-05 20:30:08 -0600 | [diff] [blame] | 828 | uint8_t inst2 = inst; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 829 | |
Gavin Howard | 38bea81 | 2018-09-20 12:01:25 -0600 | [diff] [blame] | 830 | if ((status = bc_program_unaryOpPrep(p, &ptr, &num, false))) return status; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 831 | |
Gavin Howard | 101b5e6 | 2018-03-26 07:46:27 -0600 | [diff] [blame] | 832 | if (inst == BC_INST_INC_POST || inst == BC_INST_DEC_POST) { |
Gavin Howard | 45ff357 | 2018-05-15 16:33:58 -0600 | [diff] [blame] | 833 | copy.type = BC_RESULT_TEMP; |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 834 | if ((status = bc_num_init(©.data.num, num->len))) return status; |
Gavin Howard | e8bbdcc | 2018-09-06 13:06:02 -0600 | [diff] [blame] | 835 | if ((status = bc_num_copy(©.data.num, num))) goto err; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 836 | } |
| 837 | |
| 838 | result.type = BC_RESULT_ONE; |
Gavin Howard | 45ff357 | 2018-05-15 16:33:58 -0600 | [diff] [blame] | 839 | inst = inst == BC_INST_INC_PRE || inst == BC_INST_INC_POST ? |
| 840 | BC_INST_ASSIGN_PLUS : BC_INST_ASSIGN_MINUS; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 841 | |
Gavin Howard | a628aa2 | 2018-09-12 13:52:45 -0600 | [diff] [blame] | 842 | if ((status = bc_vec_push(&p->results, 1, &result))) goto err; |
Gavin Howard | 45ff357 | 2018-05-15 16:33:58 -0600 | [diff] [blame] | 843 | if ((status = bc_program_assign(p, inst))) goto err; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 844 | |
Gavin Howard | 7061017 | 2018-09-05 20:30:08 -0600 | [diff] [blame] | 845 | if (inst2 == BC_INST_INC_POST || inst2 == BC_INST_DEC_POST) { |
Gavin Howard | 0eb2a37 | 2018-03-24 09:52:55 -0600 | [diff] [blame] | 846 | bc_vec_pop(&p->results); |
Gavin Howard | a628aa2 | 2018-09-12 13:52:45 -0600 | [diff] [blame] | 847 | if ((status = bc_vec_push(&p->results, 1, ©))) goto err; |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 848 | } |
| 849 | |
| 850 | return status; |
| 851 | |
| 852 | err: |
| 853 | |
Gavin Howard | 7061017 | 2018-09-05 20:30:08 -0600 | [diff] [blame] | 854 | if (inst2 == BC_INST_INC_POST || inst2 == BC_INST_DEC_POST) |
Gavin Howard | 8409507 | 2018-02-27 15:36:58 -0700 | [diff] [blame] | 855 | bc_num_free(©.data.num); |
| 856 | |
| 857 | return status; |
| 858 | } |
Gavin Howard | e723a15 | 2018-02-27 15:24:00 -0700 | [diff] [blame] | 859 | |
Gavin Howard | 0011a3a | 2018-03-29 23:11:32 -0600 | [diff] [blame] | 860 | BcStatus bc_program_init(BcProgram *p, size_t line_len) { |
Gavin Howard | 8a596d4 | 2018-01-15 15:46:01 -0700 | [diff] [blame] | 861 | |
Gavin Howard | d96bcae | 2018-02-07 19:16:19 -0700 | [diff] [blame] | 862 | BcStatus s; |
Gavin Howard | 91072cf | 2018-02-08 21:07:51 -0700 | [diff] [blame] | 863 | size_t idx; |
Gavin Howard | f51b189 | 2018-09-04 10:38:51 -0600 | [diff] [blame] | 864 | char *main_name = NULL, *read_name = NULL; |
Gavin Howard | 2534a81 | 2018-02-10 15:34:15 -0700 | [diff] [blame] | 865 | BcInstPtr ip; |
Gavin Howard | 8a596d4 | 2018-01-15 15:46:01 -0700 | [diff] [blame] | 866 | |
Gavin Howard | 27fdfb9 | 2018-03-21 07:56:59 -0600 | [diff] [blame] | 867 | assert(p); |
Gavin Howard | 8a596d4 | 2018-01-15 15:46:01 -0700 | [diff] [blame] | 868 | |
Gavin Howard | f3cf028 | 2018-09-21 10:54:58 -0600 | [diff] [blame] | 869 | assert((unsigned long) sysconf(_SC_BC_BASE_MAX) <= BC_MAX_OBASE); |
Gavin Howard | 84d19a6 | 2018-09-13 13:51:32 -0600 | [diff] [blame] | 870 | assert((unsigned long) sysconf(_SC_BC_DIM_MAX) <= BC_MAX_DIM); |
| 871 | assert((unsigned long) sysconf(_SC_BC_SCALE_MAX) <= BC_MAX_SCALE); |
| 872 | assert((unsigned long) sysconf(_SC_BC_STRING_MAX) <= BC_MAX_STRING); |
Gavin Howard | 57c843e | 2018-03-28 19:28:08 -0600 | [diff] [blame] | 873 | |
Gavin Howard | 0011a3a | 2018-03-29 23:11:32 -0600 | [diff] [blame] | 874 | p->nchars = p->scale = 0; |
| 875 | p->line_len = line_len; |
Gavin Howard | 5d74e96 | 2018-02-26 13:44:13 -0700 | [diff] [blame] | 876 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 877 | 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] | 878 | bc_num_ten(&p->ibase); |
| 879 | p->ibase_t = 10; |
| 880 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 881 | 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] | 882 | bc_num_ten(&p->obase); |
| 883 | p->obase_t = 10; |
| 884 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 885 | 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] | 886 | bc_num_zero(&p->last); |
Gavin Howard | b5c7721 | 2018-02-14 17:12:34 -0700 | [diff] [blame] | 887 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 888 | 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] | 889 | bc_num_zero(&p->zero); |
Gavin Howard | 5a8949e | 2018-02-05 16:46:06 -0700 | [diff] [blame] | 890 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 891 | 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] | 892 | bc_num_one(&p->one); |
Gavin Howard | 645200e | 2018-02-15 15:33:35 -0700 | [diff] [blame] | 893 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 894 | 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] | 895 | |
Gavin Howard | d96bcae | 2018-02-07 19:16:19 -0700 | [diff] [blame] | 896 | 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] | 897 | if (s) goto func_map_err; |
Gavin Howard | d96bcae | 2018-02-07 19:16:19 -0700 | [diff] [blame] | 898 | |
Gavin Howard | ff66e29 | 2018-03-28 12:47:58 -0600 | [diff] [blame] | 899 | if (!(main_name = malloc(sizeof(bc_lang_func_main)))) { |
Gavin Howard | 91072cf | 2018-02-08 21:07:51 -0700 | [diff] [blame] | 900 | s = BC_STATUS_MALLOC_FAIL; |
Gavin Howard | d50539a | 2018-02-08 20:52:57 -0700 | [diff] [blame] | 901 | goto name_err; |
| 902 | } |
| 903 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 904 | strcpy(main_name, bc_lang_func_main); |
| 905 | s = bc_program_addFunc(p, main_name, &idx); |
Gavin Howard | ff52612 | 2018-09-06 19:58:52 -0600 | [diff] [blame] | 906 | if (s || idx != BC_PROGRAM_MAIN) goto name_err; |
Gavin Howard | 7061017 | 2018-09-05 20:30:08 -0600 | [diff] [blame] | 907 | main_name = NULL; |
Gavin Howard | b42810f | 2018-03-09 10:07:58 -0700 | [diff] [blame] | 908 | |
Gavin Howard | ff66e29 | 2018-03-28 12:47:58 -0600 | [diff] [blame] | 909 | if (!(read_name = malloc(sizeof(bc_lang_func_read)))) { |
Gavin Howard | ed392aa | 2018-02-27 13:09:26 -0700 | [diff] [blame] | 910 | s = BC_STATUS_MALLOC_FAIL; |
Gavin Howard | ff52612 | 2018-09-06 19:58:52 -0600 | [diff] [blame] | 911 | goto name_err; |
Gavin Howard | ed392aa | 2018-02-27 13:09:26 -0700 | [diff] [blame] | 912 | } |
| 913 | |
Gavin Howard | f456d37 | 2018-03-10 20:11:41 -0700 | [diff] [blame] | 914 | strcpy(read_name, bc_lang_func_read); |
Gavin Howard | 859e290 | 2018-03-17 14:23:35 -0600 | [diff] [blame] | 915 | s = bc_program_addFunc(p, read_name, &idx); |
Gavin Howard | ff52612 | 2018-09-06 19:58:52 -0600 | [diff] [blame] | 916 | if (s || idx != BC_PROGRAM_READ) goto name_err; |
Gavin Howard | 7061017 | 2018-09-05 20:30:08 -0600 | [diff] [blame] | 917 | read_name = NULL; |
Gavin Howard | b42810f | 2018-03-09 10:07:58 -0700 | [diff] [blame] | 918 | |
Gavin Howard | ff52612 | 2018-09-06 19:58:52 -0600 | [diff] [blame] | 919 | if ((s = bc_vec_init(&p->vars, sizeof(BcNum), bc_num_free))) goto name_err; |
Gavin Howard | d96bcae | 2018-02-07 19:16:19 -0700 | [diff] [blame] | 920 | 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] | 921 | if (s) goto var_map_err; |
Gavin Howard | d96bcae | 2018-02-07 19:16:19 -0700 | [diff] [blame] | 922 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 923 | if ((s = bc_vec_init(&p->arrays, sizeof(BcVec), bc_vec_free))) goto array_err; |
Gavin Howard | d96bcae | 2018-02-07 19:16:19 -0700 | [diff] [blame] | 924 | 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] | 925 | if (s) goto array_map_err; |
Gavin Howard | d96bcae | 2018-02-07 19:16:19 -0700 | [diff] [blame] | 926 | |
| 927 | s = bc_vec_init(&p->strings, sizeof(char*), bc_string_free); |
Gavin Howard | 1ff37d1 | 2018-02-26 09:20:51 -0700 | [diff] [blame] | 928 | if (s) goto string_err; |
Gavin Howard | 5a8949e | 2018-02-05 16:46:06 -0700 | [diff] [blame] | 929 | |
Gavin Howard | 4dbb65b | 2018-03-21 19:47:01 -0600 | [diff] [blame] | 930 | s = bc_vec_init(&p->constants, sizeof(char*), bc_string_free); |
Gavin Howard | 1ff37d1 | 2018-02-26 09:20:51 -0700 | [diff] [blame] | 931 | if (s) goto const_err; |
Gavin Howard | e46c682 | 2018-02-08 20:05:39 -0700 | [diff] [blame] | 932 | |
Gavin Howard | 0c0d192 | 2018-03-21 17:00:21 -0600 | [diff] [blame] | 933 | s = bc_vec_init(&p->results, sizeof(BcResult), bc_result_free); |
Gavin Howard | 1ff37d1 | 2018-02-26 09:20:51 -0700 | [diff] [blame] | 934 | if (s) goto expr_err; |
Gavin Howard | 2534a81 | 2018-02-10 15:34:15 -0700 | [diff] [blame] | 935 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 936 | 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] | 937 | |
Gavin Howard | 0f32a85 | 2018-03-28 12:33:17 -0600 | [diff] [blame] | 938 | memset(&ip, 0, sizeof(BcInstPtr)); |
Gavin Howard | 2534a81 | 2018-02-10 15:34:15 -0700 | [diff] [blame] | 939 | |
Gavin Howard | a628aa2 | 2018-09-12 13:52:45 -0600 | [diff] [blame] | 940 | if ((s = bc_vec_push(&p->stack, 1, &ip))) goto push_err; |
Gavin Howard | d28e80a | 2018-01-23 18:24:18 -0700 | [diff] [blame] | 941 | |
Gavin Howard | d96bcae | 2018-02-07 19:16:19 -0700 | [diff] [blame] | 942 | return s; |
Gavin Howard | 8a596d4 | 2018-01-15 15:46:01 -0700 | [diff] [blame] | 943 | |
Gavin Howard | ed392aa | 2018-02-27 13:09:26 -0700 | [diff] [blame] | 944 | push_err: |
Gavin Howard | 602178d | 2018-02-09 12:03:28 -0700 | [diff] [blame] | 945 | bc_vec_free(&p->stack); |
Gavin Howard | 2534a81 | 2018-02-10 15:34:15 -0700 | [diff] [blame] | 946 | stack_err: |
Gavin Howard | 0c0d192 | 2018-03-21 17:00:21 -0600 | [diff] [blame] | 947 | bc_vec_free(&p->results); |
Gavin Howard | 2534a81 | 2018-02-10 15:34:15 -0700 | [diff] [blame] | 948 | expr_err: |
Gavin Howard | e46c682 | 2018-02-08 20:05:39 -0700 | [diff] [blame] | 949 | bc_vec_free(&p->constants); |
Gavin Howard | e46c682 | 2018-02-08 20:05:39 -0700 | [diff] [blame] | 950 | const_err: |
Gavin Howard | 5a8949e | 2018-02-05 16:46:06 -0700 | [diff] [blame] | 951 | bc_vec_free(&p->strings); |
Gavin Howard | 5a8949e | 2018-02-05 16:46:06 -0700 | [diff] [blame] | 952 | string_err: |
Gavin Howard | d96bcae | 2018-02-07 19:16:19 -0700 | [diff] [blame] | 953 | bc_veco_free(&p->array_map); |
Gavin Howard | d96bcae | 2018-02-07 19:16:19 -0700 | [diff] [blame] | 954 | array_map_err: |
Gavin Howard | 23fa3f3 | 2018-02-05 14:45:39 -0700 | [diff] [blame] | 955 | bc_vec_free(&p->arrays); |
Gavin Howard | 8a596d4 | 2018-01-15 15:46:01 -0700 | [diff] [blame] | 956 | array_err: |
Gavin Howard | d96bcae | 2018-02-07 19:16:19 -0700 | [diff] [blame] | 957 | bc_veco_free(&p->var_map); |
Gavin Howard | d96bcae | 2018-02-07 19:16:19 -0700 | [diff] [blame] | 958 | var_map_err: |
Gavin Howard | 23fa3f3 | 2018-02-05 14:45:39 -0700 | [diff] [blame] | 959 | bc_vec_free(&p->vars); |
Gavin Howard | d50539a | 2018-02-08 20:52:57 -0700 | [diff] [blame] | 960 | name_err: |
Gavin Howard | d96bcae | 2018-02-07 19:16:19 -0700 | [diff] [blame] | 961 | bc_veco_free(&p->func_map); |
Gavin Howard | d96bcae | 2018-02-07 19:16:19 -0700 | [diff] [blame] | 962 | func_map_err: |
Gavin Howard | 23fa3f3 | 2018-02-05 14:45:39 -0700 | [diff] [blame] | 963 | bc_vec_free(&p->funcs); |
Gavin Howard | 8a596d4 | 2018-01-15 15:46:01 -0700 | [diff] [blame] | 964 | func_err: |
Gavin Howard | 8389bb2 | 2018-02-15 17:40:34 -0700 | [diff] [blame] | 965 | bc_num_free(&p->one); |
Gavin Howard | b5c7721 | 2018-02-14 17:12:34 -0700 | [diff] [blame] | 966 | one_err: |
Gavin Howard | 8389bb2 | 2018-02-15 17:40:34 -0700 | [diff] [blame] | 967 | bc_num_free(&p->zero); |
Gavin Howard | b5c7721 | 2018-02-14 17:12:34 -0700 | [diff] [blame] | 968 | zero_err: |
Gavin Howard | 8389bb2 | 2018-02-15 17:40:34 -0700 | [diff] [blame] | 969 | bc_num_free(&p->last); |
Gavin Howard | 5d74e96 | 2018-02-26 13:44:13 -0700 | [diff] [blame] | 970 | last_err: |
Gavin Howard | 5d74e96 | 2018-02-26 13:44:13 -0700 | [diff] [blame] | 971 | bc_num_free(&p->obase); |
Gavin Howard | 5d74e96 | 2018-02-26 13:44:13 -0700 | [diff] [blame] | 972 | obase_err: |
Gavin Howard | 5d74e96 | 2018-02-26 13:44:13 -0700 | [diff] [blame] | 973 | bc_num_free(&p->ibase); |
Gavin Howard | d96bcae | 2018-02-07 19:16:19 -0700 | [diff] [blame] | 974 | return s; |
Gavin Howard | 8a596d4 | 2018-01-15 15:46:01 -0700 | [diff] [blame] | 975 | } |
| 976 | |
Gavin Howard | 859e290 | 2018-03-17 14:23:35 -0600 | [diff] [blame] | 977 | BcStatus bc_program_addFunc(BcProgram *p, char *name, size_t *idx) { |
Gavin Howard | 3b90f9f | 2018-01-17 13:01:33 -0700 | [diff] [blame] | 978 | |
Gavin Howard | ab67e7c | 2018-02-09 10:35:44 -0700 | [diff] [blame] | 979 | BcStatus status; |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 980 | BcEntry entry, *entry_ptr; |
Gavin Howard | ab67e7c | 2018-02-09 10:35:44 -0700 | [diff] [blame] | 981 | BcFunc f; |
| 982 | |
Gavin Howard | 27fdfb9 | 2018-03-21 07:56:59 -0600 | [diff] [blame] | 983 | assert(p && name && idx); |
Gavin Howard | 3b90f9f | 2018-01-17 13:01:33 -0700 | [diff] [blame] | 984 | |
Gavin Howard | ab67e7c | 2018-02-09 10:35:44 -0700 | [diff] [blame] | 985 | entry.name = name; |
Gavin Howard | ded20a2 | 2018-03-07 15:15:19 -0700 | [diff] [blame] | 986 | entry.idx = p->funcs.len; |
Gavin Howard | ab67e7c | 2018-02-09 10:35:44 -0700 | [diff] [blame] | 987 | |
Gavin Howard | ff52612 | 2018-09-06 19:58:52 -0600 | [diff] [blame] | 988 | status = bc_veco_insert(&p->func_map, &entry, idx); |
| 989 | |
| 990 | if (status) { |
| 991 | free(name); |
| 992 | if (status != BC_STATUS_VEC_ITEM_EXISTS) return status; |
Gavin Howard | b42810f | 2018-03-09 10:07:58 -0700 | [diff] [blame] | 993 | } |
Gavin Howard | ded20a2 | 2018-03-07 15:15:19 -0700 | [diff] [blame] | 994 | |
| 995 | entry_ptr = bc_veco_item(&p->func_map, *idx); |
Gavin Howard | ded20a2 | 2018-03-07 15:15:19 -0700 | [diff] [blame] | 996 | *idx = entry_ptr->idx; |
Gavin Howard | ab67e7c | 2018-02-09 10:35:44 -0700 | [diff] [blame] | 997 | |
Gavin Howard | bdb2f92 | 2018-03-15 09:25:18 -0600 | [diff] [blame] | 998 | if (status == BC_STATUS_VEC_ITEM_EXISTS) { |
Gavin Howard | ab67e7c | 2018-02-09 10:35:44 -0700 | [diff] [blame] | 999 | |
Gavin Howard | 0ed1232 | 2018-03-17 14:21:15 -0600 | [diff] [blame] | 1000 | BcFunc *func = bc_vec_item(&p->funcs, entry_ptr->idx); |
Gavin Howard | ed392aa | 2018-02-27 13:09:26 -0700 | [diff] [blame] | 1001 | status = BC_STATUS_SUCCESS; |
Gavin Howard | ab67e7c | 2018-02-09 10:35:44 -0700 | [diff] [blame] | 1002 | |
Gavin Howard | 90f13ad | 2018-03-17 13:32:16 -0600 | [diff] [blame] | 1003 | // We need to reset these, so the function can be repopulated. |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 1004 | func->nparams = 0; |
Gavin Howard | 0eb2a37 | 2018-03-24 09:52:55 -0600 | [diff] [blame] | 1005 | bc_vec_npop(&func->autos, func->autos.len); |
| 1006 | bc_vec_npop(&func->code, func->code.len); |
| 1007 | bc_vec_npop(&func->labels, func->labels.len); |
Gavin Howard | ab67e7c | 2018-02-09 10:35:44 -0700 | [diff] [blame] | 1008 | } |
Gavin Howard | ded20a2 | 2018-03-07 15:15:19 -0700 | [diff] [blame] | 1009 | else { |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 1010 | if ((status = bc_func_init(&f))) return status; |
Gavin Howard | a628aa2 | 2018-09-12 13:52:45 -0600 | [diff] [blame] | 1011 | if ((status = bc_vec_push(&p->funcs, 1, &f))) bc_func_free(&f); |
Gavin Howard | ded20a2 | 2018-03-07 15:15:19 -0700 | [diff] [blame] | 1012 | } |
| 1013 | |
| 1014 | return status; |
Gavin Howard | 8a596d4 | 2018-01-15 15:46:01 -0700 | [diff] [blame] | 1015 | } |
| 1016 | |
Gavin Howard | 0dfe292 | 2018-05-22 13:57:02 -0600 | [diff] [blame] | 1017 | BcStatus bc_program_reset(BcProgram *p, BcStatus status) { |
Gavin Howard | f4167dc | 2018-03-26 14:19:28 -0600 | [diff] [blame] | 1018 | |
| 1019 | BcFunc *func; |
| 1020 | BcInstPtr *ip; |
| 1021 | |
Gavin Howard | abdc2d3 | 2018-03-27 08:01:08 -0600 | [diff] [blame] | 1022 | bc_vec_npop(&p->stack, p->stack.len - 1); |
| 1023 | bc_vec_npop(&p->results, p->results.len); |
| 1024 | |
Gavin Howard | f4167dc | 2018-03-26 14:19:28 -0600 | [diff] [blame] | 1025 | func = bc_vec_item(&p->funcs, 0); |
Gavin Howard | f4167dc | 2018-03-26 14:19:28 -0600 | [diff] [blame] | 1026 | ip = bc_vec_top(&p->stack); |
Gavin Howard | f4167dc | 2018-03-26 14:19:28 -0600 | [diff] [blame] | 1027 | ip->idx = func->code.len; |
| 1028 | |
Gavin Howard | 3e8e6d1 | 2018-06-21 15:36:34 -0600 | [diff] [blame] | 1029 | if (!status && bcg.signe && !bcg.tty) return BC_STATUS_QUIT; |
Gavin Howard | abdc2d3 | 2018-03-27 08:01:08 -0600 | [diff] [blame] | 1030 | |
Gavin Howard | 0dfe292 | 2018-05-22 13:57:02 -0600 | [diff] [blame] | 1031 | bcg.sigc += bcg.signe; |
| 1032 | bcg.signe = bcg.sig != bcg.sigc; |
Gavin Howard | abdc2d3 | 2018-03-27 08:01:08 -0600 | [diff] [blame] | 1033 | |
Gavin Howard | a049214 | 2018-08-29 15:28:35 -0600 | [diff] [blame] | 1034 | if (!status || status == BC_STATUS_EXEC_SIGNAL) { |
| 1035 | if (bcg.tty) { |
| 1036 | fprintf(stderr, "%s", bc_program_ready_prompt); |
| 1037 | fflush(stderr); |
| 1038 | status = BC_STATUS_SUCCESS; |
| 1039 | } |
| 1040 | else status = BC_STATUS_QUIT; |
Gavin Howard | 46f0e42 | 2018-03-27 08:12:00 -0600 | [diff] [blame] | 1041 | } |
| 1042 | |
Gavin Howard | abdc2d3 | 2018-03-27 08:01:08 -0600 | [diff] [blame] | 1043 | return status; |
Gavin Howard | f4167dc | 2018-03-26 14:19:28 -0600 | [diff] [blame] | 1044 | } |
| 1045 | |
Gavin Howard | 8d1f1db | 2018-02-23 11:29:41 -0700 | [diff] [blame] | 1046 | BcStatus bc_program_exec(BcProgram *p) { |
Gavin Howard | 5b5dc57 | 2018-01-24 11:57:38 -0700 | [diff] [blame] | 1047 | |
Gavin Howard | f51b189 | 2018-09-04 10:38:51 -0600 | [diff] [blame] | 1048 | BcStatus status = BC_STATUS_SUCCESS; |
| 1049 | const char **string, *s; |
Gavin Howard | 432b8b9 | 2018-08-09 10:53:03 -0600 | [diff] [blame] | 1050 | size_t idx, len, *addr; |
Gavin Howard | 195706a | 2018-02-26 17:45:58 -0700 | [diff] [blame] | 1051 | BcResult result; |
Gavin Howard | 432b8b9 | 2018-08-09 10:53:03 -0600 | [diff] [blame] | 1052 | BcResult *ptr; |
| 1053 | BcNum *num; |
Gavin Howard | f51b189 | 2018-09-04 10:38:51 -0600 | [diff] [blame] | 1054 | bool cond = false; |
| 1055 | BcInstPtr *ip = bc_vec_top(&p->stack); |
| 1056 | BcFunc *func = bc_vec_item(&p->funcs, ip->func); |
| 1057 | uint8_t *code = func->code.array; |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 1058 | |
Gavin Howard | 2bb7bfc | 2018-03-28 15:19:45 -0600 | [diff] [blame] | 1059 | while (!status && !bcg.sig_other && ip->idx < func->code.len) { |
Gavin Howard | 368459a | 2018-03-28 13:23:51 -0600 | [diff] [blame] | 1060 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 1061 | uint8_t inst = code[(ip->idx)++]; |
Gavin Howard | 7c8dc77 | 2018-02-21 12:12:11 -0700 | [diff] [blame] | 1062 | |
Gavin Howard | 7c8dc77 | 2018-02-21 12:12:11 -0700 | [diff] [blame] | 1063 | switch (inst) { |
| 1064 | |
Gavin Howard | 195706a | 2018-02-26 17:45:58 -0700 | [diff] [blame] | 1065 | case BC_INST_CALL: |
| 1066 | { |
| 1067 | status = bc_program_call(p, code, &ip->idx); |
| 1068 | break; |
| 1069 | } |
| 1070 | |
| 1071 | case BC_INST_RETURN: |
| 1072 | case BC_INST_RETURN_ZERO: |
| 1073 | { |
| 1074 | status = bc_program_return(p, inst); |
| 1075 | break; |
| 1076 | } |
| 1077 | |
Gavin Howard | 7c8dc77 | 2018-02-21 12:12:11 -0700 | [diff] [blame] | 1078 | case BC_INST_READ: |
| 1079 | { |
| 1080 | status = bc_program_read(p); |
| 1081 | break; |
| 1082 | } |
| 1083 | |
Gavin Howard | 195706a | 2018-02-26 17:45:58 -0700 | [diff] [blame] | 1084 | case BC_INST_JUMP_ZERO: |
Gavin Howard | 170fcb0 | 2018-02-27 15:27:51 -0700 | [diff] [blame] | 1085 | { |
Gavin Howard | 38bea81 | 2018-09-20 12:01:25 -0600 | [diff] [blame] | 1086 | if ((status = bc_program_unaryOpPrep(p, &ptr, &num, false))) |
| 1087 | return status; |
Gavin Howard | 6a804cf | 2018-05-17 16:54:12 -0600 | [diff] [blame] | 1088 | cond = !bc_num_cmp(num, &p->zero); |
Gavin Howard | 0eb2a37 | 2018-03-24 09:52:55 -0600 | [diff] [blame] | 1089 | bc_vec_pop(&p->results); |
Gavin Howard | 170fcb0 | 2018-02-27 15:27:51 -0700 | [diff] [blame] | 1090 | } |
Gavin Howard | 98d071b | 2018-03-19 19:36:23 -0600 | [diff] [blame] | 1091 | // Fallthrough. |
Gavin Howard | 195706a | 2018-02-26 17:45:58 -0700 | [diff] [blame] | 1092 | case BC_INST_JUMP: |
| 1093 | { |
Gavin Howard | 170fcb0 | 2018-02-27 15:27:51 -0700 | [diff] [blame] | 1094 | idx = bc_program_index(code, &ip->idx); |
| 1095 | addr = bc_vec_item(&func->labels, idx); |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 1096 | if (inst == BC_INST_JUMP || cond) ip->idx = *addr; |
Gavin Howard | 195706a | 2018-02-26 17:45:58 -0700 | [diff] [blame] | 1097 | break; |
| 1098 | } |
| 1099 | |
| 1100 | case BC_INST_PUSH_VAR: |
Gavin Howard | 101b5e6 | 2018-03-26 07:46:27 -0600 | [diff] [blame] | 1101 | case BC_INST_PUSH_ARRAY_ELEM: |
Gavin Howard | 375263e | 2018-09-04 15:10:18 -0600 | [diff] [blame] | 1102 | case BC_INST_PUSH_ARRAY: |
Gavin Howard | 195706a | 2018-02-26 17:45:58 -0700 | [diff] [blame] | 1103 | { |
Gavin Howard | 375263e | 2018-09-04 15:10:18 -0600 | [diff] [blame] | 1104 | status = bc_program_push(p, code, &ip->idx, inst); |
Gavin Howard | 195706a | 2018-02-26 17:45:58 -0700 | [diff] [blame] | 1105 | break; |
| 1106 | } |
| 1107 | |
Gavin Howard | a20bbd0 | 2018-09-12 11:52:52 -0600 | [diff] [blame] | 1108 | case BC_INST_PUSH_IBASE: |
Gavin Howard | 195706a | 2018-02-26 17:45:58 -0700 | [diff] [blame] | 1109 | case BC_INST_PUSH_LAST: |
Gavin Howard | a20bbd0 | 2018-09-12 11:52:52 -0600 | [diff] [blame] | 1110 | case BC_INST_PUSH_OBASE: |
Gavin Howard | 195706a | 2018-02-26 17:45:58 -0700 | [diff] [blame] | 1111 | { |
Gavin Howard | a20bbd0 | 2018-09-12 11:52:52 -0600 | [diff] [blame] | 1112 | result.type = inst - BC_INST_PUSH_IBASE + BC_RESULT_IBASE; |
Gavin Howard | a628aa2 | 2018-09-12 13:52:45 -0600 | [diff] [blame] | 1113 | status = bc_vec_push(&p->results, 1, &result); |
Gavin Howard | 195706a | 2018-02-26 17:45:58 -0700 | [diff] [blame] | 1114 | break; |
| 1115 | } |
| 1116 | |
| 1117 | case BC_INST_PUSH_SCALE: |
| 1118 | { |
Gavin Howard | a4a7289 | 2018-02-27 09:16:10 -0700 | [diff] [blame] | 1119 | status = bc_program_pushScale(p); |
Gavin Howard | 195706a | 2018-02-26 17:45:58 -0700 | [diff] [blame] | 1120 | break; |
| 1121 | } |
| 1122 | |
Gavin Howard | 195706a | 2018-02-26 17:45:58 -0700 | [diff] [blame] | 1123 | case BC_INST_SCALE_FUNC: |
| 1124 | case BC_INST_LENGTH: |
| 1125 | case BC_INST_SQRT: |
| 1126 | { |
| 1127 | status = bc_program_builtin(p, inst); |
| 1128 | break; |
| 1129 | } |
| 1130 | |
| 1131 | case BC_INST_PUSH_NUM: |
| 1132 | { |
Gavin Howard | 195706a | 2018-02-26 17:45:58 -0700 | [diff] [blame] | 1133 | result.type = BC_RESULT_CONSTANT; |
| 1134 | result.data.id.idx = bc_program_index(code, &ip->idx); |
Gavin Howard | a628aa2 | 2018-09-12 13:52:45 -0600 | [diff] [blame] | 1135 | status = bc_vec_push(&p->results, 1, &result); |
Gavin Howard | 195706a | 2018-02-26 17:45:58 -0700 | [diff] [blame] | 1136 | break; |
| 1137 | } |
| 1138 | |
Gavin Howard | 5c222e3 | 2018-02-28 13:06:41 -0700 | [diff] [blame] | 1139 | case BC_INST_POP: |
| 1140 | { |
Gavin Howard | 0eb2a37 | 2018-03-24 09:52:55 -0600 | [diff] [blame] | 1141 | bc_vec_pop(&p->results); |
Gavin Howard | 5c222e3 | 2018-02-28 13:06:41 -0700 | [diff] [blame] | 1142 | break; |
| 1143 | } |
| 1144 | |
Gavin Howard | 101b5e6 | 2018-03-26 07:46:27 -0600 | [diff] [blame] | 1145 | case BC_INST_INC_PRE: |
| 1146 | case BC_INST_DEC_PRE: |
Gavin Howard | e8bbdcc | 2018-09-06 13:06:02 -0600 | [diff] [blame] | 1147 | case BC_INST_INC_POST: |
| 1148 | case BC_INST_DEC_POST: |
Gavin Howard | 195706a | 2018-02-26 17:45:58 -0700 | [diff] [blame] | 1149 | { |
Gavin Howard | e723a15 | 2018-02-27 15:24:00 -0700 | [diff] [blame] | 1150 | status = bc_program_incdec(p, inst); |
Gavin Howard | 195706a | 2018-02-26 17:45:58 -0700 | [diff] [blame] | 1151 | break; |
| 1152 | } |
| 1153 | |
| 1154 | case BC_INST_HALT: |
| 1155 | { |
Gavin Howard | 01d6ec3 | 2018-03-17 19:42:02 -0600 | [diff] [blame] | 1156 | status = BC_STATUS_QUIT; |
Gavin Howard | 195706a | 2018-02-26 17:45:58 -0700 | [diff] [blame] | 1157 | break; |
| 1158 | } |
| 1159 | |
Gavin Howard | 7c8dc77 | 2018-02-21 12:12:11 -0700 | [diff] [blame] | 1160 | case BC_INST_PRINT: |
Gavin Howard | 152f3e8 | 2018-03-07 12:33:15 -0700 | [diff] [blame] | 1161 | case BC_INST_PRINT_EXPR: |
Gavin Howard | 7c8dc77 | 2018-02-21 12:12:11 -0700 | [diff] [blame] | 1162 | { |
Gavin Howard | 38bea81 | 2018-09-20 12:01:25 -0600 | [diff] [blame] | 1163 | if ((status = bc_program_unaryOpPrep(p, &ptr, &num, false))) |
| 1164 | return status; |
Gavin Howard | a883ad9 | 2018-02-22 13:34:41 -0700 | [diff] [blame] | 1165 | |
Gavin Howard | 45ff357 | 2018-05-15 16:33:58 -0600 | [diff] [blame] | 1166 | status = bc_num_print(num, &p->obase, p->obase_t, inst == BC_INST_PRINT, |
Gavin Howard | 0011a3a | 2018-03-29 23:11:32 -0600 | [diff] [blame] | 1167 | &p->nchars, p->line_len); |
Gavin Howard | 534a980 | 2018-02-28 13:06:09 -0700 | [diff] [blame] | 1168 | if (status) return status; |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 1169 | if ((status = bc_num_copy(&p->last, num))) return status; |
Gavin Howard | e351e9d | 2018-02-27 09:16:42 -0700 | [diff] [blame] | 1170 | |
Gavin Howard | 0eb2a37 | 2018-03-24 09:52:55 -0600 | [diff] [blame] | 1171 | bc_vec_pop(&p->results); |
Gavin Howard | 7c8dc77 | 2018-02-21 12:12:11 -0700 | [diff] [blame] | 1172 | |
| 1173 | break; |
| 1174 | } |
| 1175 | |
| 1176 | case BC_INST_STR: |
| 1177 | { |
Gavin Howard | 7c8dc77 | 2018-02-21 12:12:11 -0700 | [diff] [blame] | 1178 | idx = bc_program_index(code, &ip->idx); |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 1179 | assert(idx < p->strings.len); |
Gavin Howard | 7c8dc77 | 2018-02-21 12:12:11 -0700 | [diff] [blame] | 1180 | string = bc_vec_item(&p->strings, idx); |
Gavin Howard | 0271bfc | 2018-03-14 10:52:48 -0600 | [diff] [blame] | 1181 | |
Gavin Howard | bc7cae8 | 2018-03-14 13:43:04 -0600 | [diff] [blame] | 1182 | s = *string; |
| 1183 | len = strlen(s); |
| 1184 | |
| 1185 | for (idx = 0; idx < len; ++idx) { |
| 1186 | char c = s[idx]; |
Gavin Howard | a141a0f | 2018-03-23 13:16:10 -0600 | [diff] [blame] | 1187 | if (putchar(c) == EOF) return BC_STATUS_IO_ERR; |
Gavin Howard | bc7cae8 | 2018-03-14 13:43:04 -0600 | [diff] [blame] | 1188 | if (c == '\n') p->nchars = SIZE_MAX; |
| 1189 | ++p->nchars; |
| 1190 | } |
Gavin Howard | 7c8dc77 | 2018-02-21 12:12:11 -0700 | [diff] [blame] | 1191 | |
| 1192 | break; |
| 1193 | } |
| 1194 | |
| 1195 | case BC_INST_PRINT_STR: |
| 1196 | { |
Gavin Howard | 7c8dc77 | 2018-02-21 12:12:11 -0700 | [diff] [blame] | 1197 | idx = bc_program_index(code, &ip->idx); |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 1198 | assert(idx < p->strings.len); |
Gavin Howard | 7c8dc77 | 2018-02-21 12:12:11 -0700 | [diff] [blame] | 1199 | string = bc_vec_item(&p->strings, idx); |
Gavin Howard | bc7cae8 | 2018-03-14 13:43:04 -0600 | [diff] [blame] | 1200 | status = bc_program_printString(*string, &p->nchars); |
Gavin Howard | 7c8dc77 | 2018-02-21 12:12:11 -0700 | [diff] [blame] | 1201 | break; |
| 1202 | } |
| 1203 | |
Gavin Howard | 101b5e6 | 2018-03-26 07:46:27 -0600 | [diff] [blame] | 1204 | case BC_INST_POWER: |
| 1205 | case BC_INST_MULTIPLY: |
| 1206 | case BC_INST_DIVIDE: |
| 1207 | case BC_INST_MODULUS: |
| 1208 | case BC_INST_PLUS: |
| 1209 | case BC_INST_MINUS: |
Gavin Howard | 7c8dc77 | 2018-02-21 12:12:11 -0700 | [diff] [blame] | 1210 | { |
| 1211 | status = bc_program_op(p, inst); |
| 1212 | break; |
| 1213 | } |
| 1214 | |
Gavin Howard | 101b5e6 | 2018-03-26 07:46:27 -0600 | [diff] [blame] | 1215 | case BC_INST_REL_EQ: |
| 1216 | case BC_INST_REL_LE: |
| 1217 | case BC_INST_REL_GE: |
| 1218 | case BC_INST_REL_NE: |
| 1219 | case BC_INST_REL_LT: |
| 1220 | case BC_INST_REL_GT: |
Gavin Howard | 195706a | 2018-02-26 17:45:58 -0700 | [diff] [blame] | 1221 | { |
Gavin Howard | 2c15400 | 2018-02-27 16:43:26 -0700 | [diff] [blame] | 1222 | status = bc_program_logical(p, inst); |
Gavin Howard | 195706a | 2018-02-26 17:45:58 -0700 | [diff] [blame] | 1223 | break; |
| 1224 | } |
| 1225 | |
Gavin Howard | 101b5e6 | 2018-03-26 07:46:27 -0600 | [diff] [blame] | 1226 | case BC_INST_BOOL_NOT: |
Gavin Howard | 195706a | 2018-02-26 17:45:58 -0700 | [diff] [blame] | 1227 | { |
Gavin Howard | 38bea81 | 2018-09-20 12:01:25 -0600 | [diff] [blame] | 1228 | if ((status = bc_program_unaryOpPrep(p, &ptr, &num, false))) |
| 1229 | return status; |
Gavin Howard | e809535 | 2018-02-27 09:17:20 -0700 | [diff] [blame] | 1230 | status = bc_num_init(&result.data.num, BC_NUM_DEF_SIZE); |
Gavin Howard | e809535 | 2018-02-27 09:17:20 -0700 | [diff] [blame] | 1231 | if (status) return status; |
| 1232 | |
Gavin Howard | 2444f27 | 2018-09-11 12:25:53 -0600 | [diff] [blame] | 1233 | if (!bc_num_cmp(num, &p->zero)) bc_num_one(&result.data.num); |
Gavin Howard | e809535 | 2018-02-27 09:17:20 -0700 | [diff] [blame] | 1234 | else bc_num_zero(&result.data.num); |
| 1235 | |
Gavin Howard | 45ff357 | 2018-05-15 16:33:58 -0600 | [diff] [blame] | 1236 | status = bc_program_unaryOpRetire(p, &result, BC_RESULT_TEMP); |
Gavin Howard | e809535 | 2018-02-27 09:17:20 -0700 | [diff] [blame] | 1237 | if (status) bc_num_free(&result.data.num); |
| 1238 | |
Gavin Howard | 195706a | 2018-02-26 17:45:58 -0700 | [diff] [blame] | 1239 | break; |
| 1240 | } |
| 1241 | |
Gavin Howard | 101b5e6 | 2018-03-26 07:46:27 -0600 | [diff] [blame] | 1242 | case BC_INST_BOOL_OR: |
| 1243 | case BC_INST_BOOL_AND: |
Gavin Howard | 195706a | 2018-02-26 17:45:58 -0700 | [diff] [blame] | 1244 | { |
Gavin Howard | 2c15400 | 2018-02-27 16:43:26 -0700 | [diff] [blame] | 1245 | status = bc_program_logical(p, inst); |
Gavin Howard | 195706a | 2018-02-26 17:45:58 -0700 | [diff] [blame] | 1246 | break; |
| 1247 | } |
| 1248 | |
Gavin Howard | 101b5e6 | 2018-03-26 07:46:27 -0600 | [diff] [blame] | 1249 | case BC_INST_NEG: |
Gavin Howard | 7c8dc77 | 2018-02-21 12:12:11 -0700 | [diff] [blame] | 1250 | { |
Gavin Howard | 3a94736 | 2018-03-02 11:25:48 -0700 | [diff] [blame] | 1251 | status = bc_program_negate(p); |
Gavin Howard | 7c8dc77 | 2018-02-21 12:12:11 -0700 | [diff] [blame] | 1252 | break; |
| 1253 | } |
| 1254 | |
Gavin Howard | 101b5e6 | 2018-03-26 07:46:27 -0600 | [diff] [blame] | 1255 | case BC_INST_ASSIGN_POWER: |
| 1256 | case BC_INST_ASSIGN_MULTIPLY: |
| 1257 | case BC_INST_ASSIGN_DIVIDE: |
| 1258 | case BC_INST_ASSIGN_MODULUS: |
| 1259 | case BC_INST_ASSIGN_PLUS: |
| 1260 | case BC_INST_ASSIGN_MINUS: |
| 1261 | case BC_INST_ASSIGN: |
Gavin Howard | 6d89b5d | 2018-02-26 13:21:34 -0700 | [diff] [blame] | 1262 | { |
| 1263 | status = bc_program_assign(p, inst); |
| 1264 | break; |
| 1265 | } |
| 1266 | |
Gavin Howard | 7c8dc77 | 2018-02-21 12:12:11 -0700 | [diff] [blame] | 1267 | default: |
| 1268 | { |
Gavin Howard | 27fdfb9 | 2018-03-21 07:56:59 -0600 | [diff] [blame] | 1269 | assert(false); |
Gavin Howard | d11c262 | 2018-02-21 21:16:46 -0700 | [diff] [blame] | 1270 | break; |
Gavin Howard | 7c8dc77 | 2018-02-21 12:12:11 -0700 | [diff] [blame] | 1271 | } |
| 1272 | } |
Gavin Howard | 195706a | 2018-02-26 17:45:58 -0700 | [diff] [blame] | 1273 | |
Gavin Howard | 0dfe292 | 2018-05-22 13:57:02 -0600 | [diff] [blame] | 1274 | if ((status && status != BC_STATUS_QUIT) || bcg.signe) |
| 1275 | status = bc_program_reset(p, status); |
Gavin Howard | 0a2a674 | 2018-02-27 14:11:26 -0700 | [diff] [blame] | 1276 | |
Gavin Howard | 432b8b9 | 2018-08-09 10:53:03 -0600 | [diff] [blame] | 1277 | // We need to update because if the stack changes, pointers may be invalid. |
Gavin Howard | 195706a | 2018-02-26 17:45:58 -0700 | [diff] [blame] | 1278 | ip = bc_vec_top(&p->stack); |
Gavin Howard | 0a2a674 | 2018-02-27 14:11:26 -0700 | [diff] [blame] | 1279 | func = bc_vec_item(&p->funcs, ip->func); |
Gavin Howard | a1ff02f | 2018-03-07 12:32:25 -0700 | [diff] [blame] | 1280 | code = func->code.array; |
Gavin Howard | 7c8dc77 | 2018-02-21 12:12:11 -0700 | [diff] [blame] | 1281 | } |
| 1282 | |
| 1283 | return status; |
| 1284 | } |
| 1285 | |
Gavin Howard | 84590c8 | 2018-03-28 15:38:44 -0600 | [diff] [blame] | 1286 | void bc_program_free(BcProgram *p) { |
| 1287 | |
Gavin Howard | bc20f3d | 2018-09-11 10:26:04 -0600 | [diff] [blame] | 1288 | assert(p); |
Gavin Howard | 84590c8 | 2018-03-28 15:38:44 -0600 | [diff] [blame] | 1289 | |
| 1290 | bc_num_free(&p->ibase); |
| 1291 | bc_num_free(&p->obase); |
| 1292 | |
| 1293 | bc_vec_free(&p->funcs); |
| 1294 | bc_veco_free(&p->func_map); |
| 1295 | |
| 1296 | bc_vec_free(&p->vars); |
| 1297 | bc_veco_free(&p->var_map); |
| 1298 | |
| 1299 | bc_vec_free(&p->arrays); |
| 1300 | bc_veco_free(&p->array_map); |
| 1301 | |
| 1302 | bc_vec_free(&p->strings); |
| 1303 | bc_vec_free(&p->constants); |
| 1304 | |
| 1305 | bc_vec_free(&p->results); |
| 1306 | bc_vec_free(&p->stack); |
| 1307 | |
| 1308 | bc_num_free(&p->last); |
| 1309 | bc_num_free(&p->zero); |
| 1310 | bc_num_free(&p->one); |
Gavin Howard | 84590c8 | 2018-03-28 15:38:44 -0600 | [diff] [blame] | 1311 | } |
| 1312 | |
| 1313 | #ifndef NDEBUG |
| 1314 | BcStatus bc_program_printIndex(uint8_t *code, size_t *start) { |
| 1315 | |
Gavin Howard | f51b189 | 2018-09-04 10:38:51 -0600 | [diff] [blame] | 1316 | uint8_t byte, i, bytes = code[(*start)++]; |
Gavin Howard | 4b62f4a | 2018-08-30 15:46:56 -0600 | [diff] [blame] | 1317 | unsigned long val = 0; |
Gavin Howard | 24c675f | 2018-06-22 16:00:02 -0600 | [diff] [blame] | 1318 | |
Gavin Howard | 45ff357 | 2018-05-15 16:33:58 -0600 | [diff] [blame] | 1319 | for (byte = 1, i = 0; byte && i < bytes; ++i) { |
Gavin Howard | 84590c8 | 2018-03-28 15:38:44 -0600 | [diff] [blame] | 1320 | byte = code[(*start)++]; |
Gavin Howard | 4b62f4a | 2018-08-30 15:46:56 -0600 | [diff] [blame] | 1321 | if (byte) val |= ((unsigned long) byte) << (CHAR_BIT * sizeof(uint8_t) * i); |
Gavin Howard | 84590c8 | 2018-03-28 15:38:44 -0600 | [diff] [blame] | 1322 | } |
| 1323 | |
Gavin Howard | 7061017 | 2018-09-05 20:30:08 -0600 | [diff] [blame] | 1324 | return printf(" (%lu) ", val) < 0 ? BC_STATUS_IO_ERR : BC_STATUS_SUCCESS; |
Gavin Howard | 84590c8 | 2018-03-28 15:38:44 -0600 | [diff] [blame] | 1325 | } |
| 1326 | |
| 1327 | BcStatus bc_program_printName(uint8_t *code, size_t *start) { |
| 1328 | |
Gavin Howard | 45ff357 | 2018-05-15 16:33:58 -0600 | [diff] [blame] | 1329 | BcStatus status = BC_STATUS_SUCCESS; |
Gavin Howard | f6e3fb3 | 2018-08-09 13:48:59 -0600 | [diff] [blame] | 1330 | char byte = (char) code[(*start)++]; |
Gavin Howard | 84590c8 | 2018-03-28 15:38:44 -0600 | [diff] [blame] | 1331 | |
Gavin Howard | 9d76063 | 2018-08-30 13:03:51 -0600 | [diff] [blame] | 1332 | if (printf(" (\"") < 0) status = BC_STATUS_IO_ERR; |
| 1333 | |
Gavin Howard | f6e3fb3 | 2018-08-09 13:48:59 -0600 | [diff] [blame] | 1334 | for (; byte && byte != ':'; byte = (char) code[(*start)++]) { |
Gavin Howard | 84590c8 | 2018-03-28 15:38:44 -0600 | [diff] [blame] | 1335 | if (putchar(byte) == EOF) return BC_STATUS_IO_ERR; |
Gavin Howard | 84590c8 | 2018-03-28 15:38:44 -0600 | [diff] [blame] | 1336 | } |
| 1337 | |
| 1338 | assert(byte); |
| 1339 | |
Gavin Howard | 9d76063 | 2018-08-30 13:03:51 -0600 | [diff] [blame] | 1340 | if (printf("\") ") < 0) status = BC_STATUS_IO_ERR; |
Gavin Howard | 84590c8 | 2018-03-28 15:38:44 -0600 | [diff] [blame] | 1341 | |
| 1342 | return status; |
| 1343 | } |
| 1344 | |
Gavin Howard | 67c3852 | 2018-02-27 16:00:49 -0700 | [diff] [blame] | 1345 | BcStatus bc_program_print(BcProgram *p) { |
Gavin Howard | 0a2a674 | 2018-02-27 14:11:26 -0700 | [diff] [blame] | 1346 | |
Gavin Howard | f51b189 | 2018-09-04 10:38:51 -0600 | [diff] [blame] | 1347 | BcStatus status = BC_STATUS_SUCCESS; |
Gavin Howard | 0a2a674 | 2018-02-27 14:11:26 -0700 | [diff] [blame] | 1348 | BcFunc *func; |
| 1349 | uint8_t *code; |
Gavin Howard | c0d9f31 | 2018-03-07 15:15:00 -0700 | [diff] [blame] | 1350 | BcInstPtr ip; |
| 1351 | size_t i; |
Gavin Howard | 0a2a674 | 2018-02-27 14:11:26 -0700 | [diff] [blame] | 1352 | |
Gavin Howard | 8b3cb5b | 2018-03-28 15:20:15 -0600 | [diff] [blame] | 1353 | for (i = 0; !status && !bcg.sig_other && i < p->funcs.len; ++i) { |
Gavin Howard | 0a2a674 | 2018-02-27 14:11:26 -0700 | [diff] [blame] | 1354 | |
Gavin Howard | f6e3fb3 | 2018-08-09 13:48:59 -0600 | [diff] [blame] | 1355 | bool sig; |
| 1356 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 1357 | ip.idx = ip.len = 0; |
Gavin Howard | c0d9f31 | 2018-03-07 15:15:00 -0700 | [diff] [blame] | 1358 | ip.func = i; |
Gavin Howard | 0a2a674 | 2018-02-27 14:11:26 -0700 | [diff] [blame] | 1359 | |
Gavin Howard | c0d9f31 | 2018-03-07 15:15:00 -0700 | [diff] [blame] | 1360 | func = bc_vec_item(&p->funcs, ip.func); |
Gavin Howard | c0d9f31 | 2018-03-07 15:15:00 -0700 | [diff] [blame] | 1361 | code = func->code.array; |
Gavin Howard | 0a2a674 | 2018-02-27 14:11:26 -0700 | [diff] [blame] | 1362 | |
Gavin Howard | 9d76063 | 2018-08-30 13:03:51 -0600 | [diff] [blame] | 1363 | if (printf("func[%zu]:\n", ip.func) < 0) return BC_STATUS_IO_ERR; |
Gavin Howard | 0a2a674 | 2018-02-27 14:11:26 -0700 | [diff] [blame] | 1364 | |
Gavin Howard | c0d9f31 | 2018-03-07 15:15:00 -0700 | [diff] [blame] | 1365 | while (ip.idx < func->code.len) { |
Gavin Howard | 0a2a674 | 2018-02-27 14:11:26 -0700 | [diff] [blame] | 1366 | |
Gavin Howard | b09d9b1 | 2018-03-23 09:57:07 -0600 | [diff] [blame] | 1367 | uint8_t inst = code[ip.idx++]; |
Gavin Howard | 0a2a674 | 2018-02-27 14:11:26 -0700 | [diff] [blame] | 1368 | |
Gavin Howard | fd79719 | 2018-03-26 12:27:01 -0600 | [diff] [blame] | 1369 | 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] | 1370 | |
Gavin Howard | 375263e | 2018-09-04 15:10:18 -0600 | [diff] [blame] | 1371 | if (inst == BC_INST_PUSH_VAR || inst == BC_INST_PUSH_ARRAY_ELEM || |
| 1372 | inst == BC_INST_PUSH_ARRAY) |
| 1373 | { |
Gavin Howard | 642050e | 2018-03-26 12:25:45 -0600 | [diff] [blame] | 1374 | if ((status = bc_program_printName(code, &ip.idx))) return status; |
| 1375 | } |
| 1376 | else if (inst == BC_INST_PUSH_NUM || inst == BC_INST_CALL || |
| 1377 | (inst >= BC_INST_STR && inst <= BC_INST_JUMP_ZERO)) |
| 1378 | { |
| 1379 | if ((status = bc_program_printIndex(code, &ip.idx))) return status; |
| 1380 | if (inst == BC_INST_CALL && (status = bc_program_printIndex(code, &ip.idx))) |
| 1381 | return status; |
Gavin Howard | 0a2a674 | 2018-02-27 14:11:26 -0700 | [diff] [blame] | 1382 | } |
| 1383 | } |
Gavin Howard | c0d9f31 | 2018-03-07 15:15:00 -0700 | [diff] [blame] | 1384 | |
Gavin Howard | 9d76063 | 2018-08-30 13:03:51 -0600 | [diff] [blame] | 1385 | if (printf("\n\n") < 0) status = BC_STATUS_IO_ERR; |
Gavin Howard | 368459a | 2018-03-28 13:23:51 -0600 | [diff] [blame] | 1386 | |
Gavin Howard | 0dfe292 | 2018-05-22 13:57:02 -0600 | [diff] [blame] | 1387 | sig = bcg.sig != bcg.sigc; |
| 1388 | if (status || sig) status = bc_program_reset(p, status); |
Gavin Howard | 0a2a674 | 2018-02-27 14:11:26 -0700 | [diff] [blame] | 1389 | } |
| 1390 | |
Gavin Howard | 0a2a674 | 2018-02-27 14:11:26 -0700 | [diff] [blame] | 1391 | return status; |
| 1392 | } |
Gavin Howard | 84590c8 | 2018-03-28 15:38:44 -0600 | [diff] [blame] | 1393 | #endif // NDEBUG |