2 * *****************************************************************************
4 * SPDX-License-Identifier: BSD-2-Clause
6 * Copyright (c) 2018-2020 Gavin D. Howard and contributors.
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions are met:
11 * * Redistributions of source code must retain the above copyright notice, this
12 * list of conditions and the following disclaimer.
14 * * Redistributions in binary form must reproduce the above copyright notice,
15 * this list of conditions and the following disclaimer in the documentation
16 * and/or other materials provided with the distribution.
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
19 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
22 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
23 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
24 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
25 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
26 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
27 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
28 * POSSIBILITY OF SUCH DAMAGE.
30 * *****************************************************************************
32 * Code to manipulate data structures in programs.
44 void bc_id_free(void *id) {
47 free(((BcId*) id)->name);
51 void bc_string_free(void *string) {
53 assert(string != NULL && (*((char**) string)) != NULL);
54 if (BC_IS_BC) free(*((char**) string));
57 void bc_const_free(void *constant) {
58 BcConst *c = constant;
60 assert(c->val != NULL);
66 void bc_func_insert(BcFunc *f, BcProgram *p, char *name,
67 BcType type, size_t line)
74 idx = bc_program_search(p, name, type == BC_TYPE_VAR);
76 for (i = 0; i < f->autos.len; ++i) {
77 BcLoc *id = bc_vec_item(&f->autos, i);
78 if (BC_ERR(idx == id->loc && type == (BcType) id->idx)) {
79 const char *array = type == BC_TYPE_ARRAY ? "[]" : "";
80 bc_vm_error(BC_ERR_PARSE_DUP_LOCAL, line, name, array);
87 bc_vec_push(&f->autos, &a);
91 void bc_func_init(BcFunc *f, const char *name) {
95 assert(f != NULL && name != NULL);
97 bc_vec_init(&f->code, sizeof(uchar), NULL);
99 bc_vec_init(&f->consts, sizeof(BcConst), bc_const_free);
104 bc_vec_init(&f->strs, sizeof(char*), bc_string_free);
106 bc_vec_init(&f->autos, sizeof(BcLoc), NULL);
107 bc_vec_init(&f->labels, sizeof(size_t), NULL);
117 void bc_func_reset(BcFunc *f) {
119 BC_SIG_ASSERT_LOCKED;
122 bc_vec_npop(&f->code, f->code.len);
124 bc_vec_npop(&f->consts, f->consts.len);
129 bc_vec_npop(&f->strs, f->strs.len);
131 bc_vec_npop(&f->autos, f->autos.len);
132 bc_vec_npop(&f->labels, f->labels.len);
140 void bc_func_free(void *func) {
142 #if BC_ENABLE_FUNC_FREE
144 BcFunc *f = (BcFunc*) func;
146 BC_SIG_ASSERT_LOCKED;
149 bc_vec_free(&f->code);
151 bc_vec_free(&f->consts);
157 bc_vec_free(&f->strs);
159 bc_vec_free(&f->autos);
160 bc_vec_free(&f->labels);
165 #else // BC_ENABLE_FUNC_FREE
167 #endif // BC_ENABLE_FUNC_FREE
170 void bc_array_init(BcVec *a, bool nums) {
171 BC_SIG_ASSERT_LOCKED;
172 if (nums) bc_vec_init(a, sizeof(BcNum), bc_num_free);
173 else bc_vec_init(a, sizeof(BcVec), bc_vec_free);
174 bc_array_expand(a, 1);
177 void bc_array_copy(BcVec *d, const BcVec *s) {
181 BC_SIG_ASSERT_LOCKED;
183 assert(d != NULL && s != NULL);
184 assert(d != s && d->size == s->size && d->dtor == s->dtor);
186 bc_vec_npop(d, d->len);
187 bc_vec_expand(d, s->cap);
190 for (i = 0; i < s->len; ++i) {
191 BcNum *dnum = bc_vec_item(d, i), *snum = bc_vec_item(s, i);
192 bc_num_createCopy(dnum, snum);
196 void bc_array_expand(BcVec *a, size_t len) {
200 BC_SIG_ASSERT_LOCKED;
202 bc_vec_expand(a, len);
204 if (a->size == sizeof(BcNum) && a->dtor == bc_num_free) {
206 while (len > a->len) {
207 bc_num_init(&n, BC_NUM_DEF_SIZE);
213 assert(a->size == sizeof(BcVec) && a->dtor == bc_vec_free);
214 while (len > a->len) {
215 bc_array_init(&v, true);
221 void bc_result_clear(BcResult *r) {
222 r->t = BC_RESULT_TEMP;
223 bc_num_clear(&r->d.n);
227 void bc_result_copy(BcResult *d, BcResult *src) {
229 assert(d != NULL && src != NULL);
231 BC_SIG_ASSERT_LOCKED;
238 case BC_RESULT_IBASE:
239 case BC_RESULT_SCALE:
240 case BC_RESULT_OBASE:
241 #if BC_ENABLE_EXTRA_MATH
243 #endif // BC_ENABLE_EXTRA_MATH
245 bc_num_createCopy(&d->d.n, &src->d.n);
251 case BC_RESULT_ARRAY:
253 case BC_RESULT_ARRAY_ELEM:
255 memcpy(&d->d.loc, &src->d.loc, sizeof(BcLoc));
261 memcpy(&d->d.n, &src->d.n, sizeof(BcNum));
285 void bc_result_free(void *result) {
287 BcResult *r = (BcResult*) result;
289 BC_SIG_ASSERT_LOCKED;
296 case BC_RESULT_IBASE:
297 case BC_RESULT_SCALE:
298 case BC_RESULT_OBASE:
299 #if BC_ENABLE_EXTRA_MATH
301 #endif // BC_ENABLE_EXTRA_MATH
303 bc_num_free(&r->d.n);
309 case BC_RESULT_ARRAY:
311 case BC_RESULT_ARRAY_ELEM: