| Line | Branch | Exec | Source |
|---|---|---|---|
| 1 | /* | ||
| 2 | Copyright 2018, 2020 - 2024 Joel Svensson svenssonjoel@yahoo.se | ||
| 3 | 2022 Benjamin Vedder | ||
| 4 | |||
| 5 | This program is free software: you can redistribute it and/or modify | ||
| 6 | it under the terms of the GNU General Public License as published by | ||
| 7 | the Free Software Foundation, either version 3 of the License, or | ||
| 8 | (at your option) any later version. | ||
| 9 | |||
| 10 | This program is distributed in the hope that it will be useful, | ||
| 11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
| 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
| 13 | GNU General Public License for more details. | ||
| 14 | |||
| 15 | You should have received a copy of the GNU General Public License | ||
| 16 | along with this program. If not, see <http://www.gnu.org/licenses/>. | ||
| 17 | */ | ||
| 18 | |||
| 19 | #include <stdio.h> | ||
| 20 | #include <string.h> | ||
| 21 | #include <ctype.h> | ||
| 22 | #include <inttypes.h> | ||
| 23 | #include <lbm_types.h> | ||
| 24 | #include <lbm_custom_type.h> | ||
| 25 | |||
| 26 | #include "print.h" | ||
| 27 | #include "heap.h" | ||
| 28 | #include "symrepr.h" | ||
| 29 | #include "stack.h" | ||
| 30 | #include "lbm_channel.h" | ||
| 31 | |||
| 32 | #define PRINT 1 | ||
| 33 | #define PRINT_SPACE 2 | ||
| 34 | #define START_LIST 3 | ||
| 35 | #define CONTINUE_LIST 4 | ||
| 36 | #define END_LIST 5 | ||
| 37 | #define PRINT_DOT 6 | ||
| 38 | #define START_ARRAY 7 | ||
| 39 | #define CONTINUE_ARRAY 8 | ||
| 40 | #define END_ARRAY 9 | ||
| 41 | |||
| 42 | static lbm_stack_t print_stack = { NULL, 0, 0}; | ||
| 43 | static bool print_has_stack = false; | ||
| 44 | |||
| 45 | const char *failed_str = "Error: print failed\n"; | ||
| 46 | |||
| 47 | // is_printable_string is turning out to be a headache. | ||
| 48 | // What do we want from this function??? | ||
| 49 | // | ||
| 50 | // Value | Print as | Condition | ||
| 51 | // [0] | [0] | | ||
| 52 | // [1] | [1] | | ||
| 53 | // "" | [0] | (array->size <= 1) => false | ||
| 54 | // "hej" | "hej" | printable characters followed by a 0 | ||
| 55 | // [65 66 67 0 65 66 67 0] | [65 66 67 0 65 66 67 0] | position of first 0 after printable characters = array->size-1 | ||
| 56 | // [0 65 66 0] | [0 65 66 0] | position of first 0 after printable characters = array->size-1 | ||
| 57 | 11106 | bool lbm_value_is_printable_string(lbm_value v, char **str) { | |
| 58 | 11106 | bool is_a_string = false; | |
| 59 | 11106 | lbm_array_header_t *array = lbm_dec_array_r(v); | |
| 60 |
2/2✓ Branch 0 taken 9089 times.
✓ Branch 1 taken 2017 times.
|
11106 | if (array) { |
| 61 | 9089 | char *c_data = (char *)array->data; | |
| 62 |
2/2✓ Branch 0 taken 8071 times.
✓ Branch 1 taken 1018 times.
|
9089 | if (array->size > 1) { // nonzero length |
| 63 | 8071 | unsigned int i = 0; | |
| 64 | 8071 | is_a_string = true; | |
| 65 |
1/2✓ Branch 0 taken 16725 times.
✗ Branch 1 not taken.
|
16725 | for (i = 0; i < array->size; i ++) { |
| 66 |
2/2✓ Branch 0 taken 5141 times.
✓ Branch 1 taken 11584 times.
|
16725 | if (c_data[i] == 0) break; |
| 67 |
5/6✓ Branch 0 taken 2986 times.
✓ Branch 1 taken 8598 times.
✓ Branch 2 taken 56 times.
✓ Branch 3 taken 2930 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 56 times.
|
11584 | if (!isprint((unsigned char)c_data[i]) && ((c_data[i] < 8) || c_data[i] > 13)) { |
| 68 | 2930 | is_a_string = false; | |
| 69 | 2930 | break; | |
| 70 | } | ||
| 71 | } | ||
| 72 |
5/6✓ Branch 0 taken 2117 times.
✓ Branch 1 taken 5954 times.
✓ Branch 2 taken 336 times.
✓ Branch 3 taken 1781 times.
✓ Branch 4 taken 336 times.
✗ Branch 5 not taken.
|
8071 | if (i > 0 && i != array->size-1 && c_data[i-1] != 0) is_a_string = false; |
| 73 |
2/2✓ Branch 0 taken 6290 times.
✓ Branch 1 taken 1781 times.
|
8071 | if (array->size-1 > i) is_a_string = false; |
| 74 |
2/2✓ Branch 0 taken 1781 times.
✓ Branch 1 taken 6290 times.
|
8071 | if (is_a_string) { |
| 75 | 1781 | *str = (char*)array->data; | |
| 76 | } | ||
| 77 | } | ||
| 78 | } | ||
| 79 | 11106 | return is_a_string; | |
| 80 | } | ||
| 81 | |||
| 82 | 1137768 | static int push_n(lbm_stack_t *s, lbm_uint *values, lbm_uint n) { | |
| 83 |
1/2✓ Branch 0 taken 1137768 times.
✗ Branch 1 not taken.
|
1137768 | if (s->sp + n < s->size) { |
| 84 |
2/2✓ Branch 0 taken 2294349 times.
✓ Branch 1 taken 1137768 times.
|
3432117 | for (lbm_uint i = 0; i < n; i ++) { |
| 85 | 2294349 | s->data[s->sp+i] = values[i]; | |
| 86 | } | ||
| 87 | 1137768 | s->sp+=n; | |
| 88 | 1137768 | return 1; | |
| 89 | } | ||
| 90 | ✗ | return 0; | |
| 91 | } | ||
| 92 | |||
| 93 | 44370 | int lbm_print_init(lbm_uint print_stack_size) { | |
| 94 | |||
| 95 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 44370 times.
|
44370 | if (print_stack_size == 0) |
| 96 | ✗ | return 0; | |
| 97 | |||
| 98 | 44370 | lbm_uint *print_stack_storage = (lbm_uint*)lbm_malloc(print_stack_size * sizeof(lbm_uint)); | |
| 99 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 44370 times.
|
44370 | if (!print_stack_storage) return 0; |
| 100 | |||
| 101 |
1/2✓ Branch 0 taken 44370 times.
✗ Branch 1 not taken.
|
44370 | if (lbm_stack_create(&print_stack, print_stack_storage, print_stack_size)) { |
| 102 | 44370 | print_has_stack = true; | |
| 103 | 44370 | return 1; | |
| 104 | } | ||
| 105 | ✗ | return 0; | |
| 106 | } | ||
| 107 | |||
| 108 | #define EMIT_BUFFER_SIZE 30 | ||
| 109 | |||
| 110 | #define EMIT_FAILED -1 | ||
| 111 | #define EMIT_OK 0 | ||
| 112 | |||
| 113 | 1651806 | static int print_emit_string(lbm_char_channel_t *chan, char* str) { | |
| 114 |
2/2✓ Branch 0 taken 14 times.
✓ Branch 1 taken 1651792 times.
|
1651806 | if (str == NULL) return EMIT_FAILED; |
| 115 |
2/2✓ Branch 0 taken 4230469 times.
✓ Branch 1 taken 895056 times.
|
5125525 | while (*str != 0) { |
| 116 | 4230469 | int r = lbm_channel_write(chan, *str); | |
| 117 | 4230469 | str++; | |
| 118 |
2/2✓ Branch 0 taken 756736 times.
✓ Branch 1 taken 3473733 times.
|
4230469 | if (r != CHANNEL_SUCCESS) return EMIT_FAILED; |
| 119 | } | ||
| 120 | 895056 | return EMIT_OK; | |
| 121 | } | ||
| 122 | |||
| 123 | 446018 | static int print_emit_char(lbm_char_channel_t *chan, char c) { | |
| 124 | |||
| 125 | 446018 | int r = lbm_channel_write(chan, c); | |
| 126 |
2/2✓ Branch 0 taken 860 times.
✓ Branch 1 taken 445158 times.
|
446018 | if (r != CHANNEL_SUCCESS) return EMIT_FAILED; |
| 127 | 445158 | return EMIT_OK; | |
| 128 | } | ||
| 129 | |||
| 130 | |||
| 131 | 5401 | static int emit_escape(lbm_char_channel_t *chan, char c) { | |
| 132 |
3/6✓ Branch 0 taken 116 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 168 times.
✓ Branch 5 taken 5117 times.
|
5401 | switch(c) { |
| 133 | 116 | case '"': return print_emit_string(chan, "\\\""); | |
| 134 | ✗ | case '\n': return print_emit_string(chan, "\\n"); | |
| 135 | ✗ | case '\r': return print_emit_string(chan, "\\r"); | |
| 136 | ✗ | case '\t': return print_emit_string(chan, "\\t"); | |
| 137 | 168 | case '\\': return print_emit_string(chan, "\\\\"); | |
| 138 | 5117 | default: | |
| 139 | 5117 | return print_emit_char(chan, c); | |
| 140 | } | ||
| 141 | } | ||
| 142 | |||
| 143 | 1276 | static int print_emit_string_value(lbm_char_channel_t *chan, char* str) { | |
| 144 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1276 times.
|
1276 | if (str == NULL) return EMIT_FAILED; |
| 145 |
2/2✓ Branch 0 taken 5401 times.
✓ Branch 1 taken 1276 times.
|
6677 | while (*str != 0) { |
| 146 | 5401 | int r = emit_escape(chan, *str++); | |
| 147 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 5401 times.
|
5401 | if (r != EMIT_OK) return r; |
| 148 | } | ||
| 149 | 1276 | return EMIT_OK; | |
| 150 | } | ||
| 151 | |||
| 152 | 534430 | static int print_emit_symbol(lbm_char_channel_t *chan, lbm_value sym) { | |
| 153 | 534430 | char *str_ptr = (char*)lbm_get_name_by_symbol(lbm_dec_sym(sym)); | |
| 154 | 534430 | return print_emit_string(chan, str_ptr); | |
| 155 | } | ||
| 156 | |||
| 157 | 79689 | static int print_emit_i(lbm_char_channel_t *chan, lbm_int v) { | |
| 158 | char buf[EMIT_BUFFER_SIZE]; | ||
| 159 | 79689 | snprintf(buf, EMIT_BUFFER_SIZE, "%"PRI_INT, v); | |
| 160 | 79689 | return print_emit_string(chan, buf); | |
| 161 | } | ||
| 162 | |||
| 163 | 43234 | static int print_emit_u(lbm_char_channel_t *chan, lbm_uint v, bool ps) { | |
| 164 | char buf[EMIT_BUFFER_SIZE]; | ||
| 165 |
1/2✓ Branch 0 taken 43234 times.
✗ Branch 1 not taken.
|
43234 | snprintf(buf, EMIT_BUFFER_SIZE, "%"PRI_UINT"%s", v, ps ? "u" : ""); |
| 166 | 43234 | return print_emit_string(chan, buf); | |
| 167 | } | ||
| 168 | |||
| 169 | 852718 | static int print_emit_byte(lbm_char_channel_t *chan, uint8_t v, bool ps) { | |
| 170 | char buf[EMIT_BUFFER_SIZE]; | ||
| 171 |
2/2✓ Branch 0 taken 2016 times.
✓ Branch 1 taken 850702 times.
|
852718 | snprintf(buf, EMIT_BUFFER_SIZE, "%u%s", v, ps ? "b" : ""); |
| 172 | 852718 | return print_emit_string(chan, buf); | |
| 173 | } | ||
| 174 | |||
| 175 | 850 | static int print_emit_float(lbm_char_channel_t *chan, float v, bool ps) { | |
| 176 | char buf[EMIT_BUFFER_SIZE]; | ||
| 177 |
1/2✓ Branch 0 taken 850 times.
✗ Branch 1 not taken.
|
850 | snprintf(buf, EMIT_BUFFER_SIZE, "%"PRI_FLOAT"%s", (double)v, ps ? "f32" : ""); |
| 178 | 850 | return print_emit_string(chan, buf); | |
| 179 | } | ||
| 180 | |||
| 181 | 675 | static int print_emit_double(lbm_char_channel_t *chan, double v, bool ps) { | |
| 182 | char buf[EMIT_BUFFER_SIZE]; | ||
| 183 |
1/2✓ Branch 0 taken 675 times.
✗ Branch 1 not taken.
|
675 | snprintf(buf, EMIT_BUFFER_SIZE, "%lf%s", v, ps ? "f64" : ""); |
| 184 | 675 | return print_emit_string(chan, buf); | |
| 185 | } | ||
| 186 | |||
| 187 | 229 | static int print_emit_u32(lbm_char_channel_t *chan, uint32_t v, bool ps) { | |
| 188 | char buf[EMIT_BUFFER_SIZE]; | ||
| 189 |
1/2✓ Branch 0 taken 229 times.
✗ Branch 1 not taken.
|
229 | snprintf(buf,EMIT_BUFFER_SIZE, "%"PRIu32"%s", v, ps ? "u32" : ""); |
| 190 | 229 | return print_emit_string(chan, buf); | |
| 191 | } | ||
| 192 | |||
| 193 | 4214 | static int print_emit_i32(lbm_char_channel_t *chan, int32_t v, bool ps) { | |
| 194 | char buf[EMIT_BUFFER_SIZE]; | ||
| 195 |
1/2✓ Branch 0 taken 4214 times.
✗ Branch 1 not taken.
|
4214 | snprintf(buf,EMIT_BUFFER_SIZE, "%"PRId32"%s", v, ps ? "i32" : ""); |
| 196 | 4214 | return print_emit_string(chan, buf); | |
| 197 | } | ||
| 198 | |||
| 199 | 224 | static int print_emit_u64(lbm_char_channel_t *chan, uint64_t v, bool ps) { | |
| 200 | char buf[EMIT_BUFFER_SIZE]; | ||
| 201 |
1/2✓ Branch 0 taken 224 times.
✗ Branch 1 not taken.
|
224 | snprintf(buf,EMIT_BUFFER_SIZE, "%"PRIu64"%s", v, ps ? "u64" : ""); |
| 202 | 224 | return print_emit_string(chan, buf); | |
| 203 | } | ||
| 204 | |||
| 205 | 224 | static int print_emit_i64(lbm_char_channel_t *chan, int64_t v, bool ps) { | |
| 206 | char buf[EMIT_BUFFER_SIZE]; | ||
| 207 |
1/2✓ Branch 0 taken 224 times.
✗ Branch 1 not taken.
|
224 | snprintf(buf,EMIT_BUFFER_SIZE, "%"PRId64"%s", v, ps ? "i64" : ""); |
| 208 | 224 | return print_emit_string(chan, buf); | |
| 209 | } | ||
| 210 | |||
| 211 | 101748 | static int print_emit_continuation(lbm_char_channel_t *chan, lbm_value v) { | |
| 212 | char buf[EMIT_BUFFER_SIZE]; | ||
| 213 | 101748 | lbm_uint cont = (v & ~LBM_CONTINUATION_INTERNAL) >> LBM_ADDRESS_SHIFT; | |
| 214 | 101748 | snprintf(buf, EMIT_BUFFER_SIZE, "CONT[" "%"PRI_UINT"]", cont); | |
| 215 | 101748 | return print_emit_string(chan, buf); | |
| 216 | } | ||
| 217 | |||
| 218 | 2 | static int print_emit_custom(lbm_char_channel_t *chan, lbm_value v) { | |
| 219 | 2 | lbm_uint *custom = (lbm_uint*)lbm_car(v); | |
| 220 | int r; // NULL checks works against SYM_NIL. | ||
| 221 |
2/4✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✗ Branch 3 not taken.
|
2 | if (custom && custom[CUSTOM_TYPE_DESCRIPTOR]) { |
| 222 | 2 | r = print_emit_string(chan, (char*)custom[CUSTOM_TYPE_DESCRIPTOR]); | |
| 223 | } else { | ||
| 224 | ✗ | r = print_emit_string(chan, "INVALID_CUSTOM_TYPE"); | |
| 225 | } | ||
| 226 | 2 | return r; | |
| 227 | } | ||
| 228 | |||
| 229 | 112 | static int print_emit_defrag_mem(lbm_char_channel_t *chan, lbm_value v) { | |
| 230 | (void) v; | ||
| 231 | 112 | return print_emit_string(chan, "DM"); | |
| 232 | } | ||
| 233 | |||
| 234 | 24216 | static int print_emit_channel(lbm_char_channel_t *chan, lbm_value v) { | |
| 235 | (void) v; | ||
| 236 | 24216 | return print_emit_string(chan, "~CHANNEL~"); | |
| 237 | } | ||
| 238 | |||
| 239 | 7028 | static int print_emit_array_data(lbm_char_channel_t *chan, lbm_array_header_t *array) { | |
| 240 | |||
| 241 | 7028 | int r = print_emit_char(chan, '['); | |
| 242 | |||
| 243 |
1/2✓ Branch 0 taken 7028 times.
✗ Branch 1 not taken.
|
7028 | if (r == EMIT_OK) { |
| 244 | |||
| 245 |
2/2✓ Branch 0 taken 850702 times.
✓ Branch 1 taken 7028 times.
|
857730 | for (unsigned int i = 0; i < array->size; i ++) { |
| 246 | |||
| 247 | 850702 | char *c_data = (char*)array->data; | |
| 248 | 850702 | r = print_emit_byte(chan, (uint8_t)c_data[i], false); | |
| 249 | |||
| 250 |
4/4✓ Branch 0 taken 94142 times.
✓ Branch 1 taken 756560 times.
✓ Branch 2 taken 88570 times.
✓ Branch 3 taken 5572 times.
|
850702 | if (r == EMIT_OK && i != array->size - 1) { |
| 251 | 88570 | r = print_emit_char(chan, ' '); | |
| 252 | } | ||
| 253 | } | ||
| 254 | |||
| 255 |
2/2✓ Branch 0 taken 560 times.
✓ Branch 1 taken 6468 times.
|
7028 | if (r != EMIT_OK) return r; |
| 256 | 6468 | return print_emit_char(chan, ']'); | |
| 257 | } | ||
| 258 | ✗ | return r; | |
| 259 | } | ||
| 260 | |||
| 261 | 8752 | static int print_emit_bytearray(lbm_char_channel_t *chan, lbm_value v) { | |
| 262 | 8752 | int r = 0; | |
| 263 | char *str; | ||
| 264 | 8752 | lbm_array_header_t *array = lbm_dec_array_r(v); | |
| 265 |
2/2✓ Branch 0 taken 8304 times.
✓ Branch 1 taken 448 times.
|
8752 | if (array) { |
| 266 |
2/2✓ Branch 0 taken 1276 times.
✓ Branch 1 taken 7028 times.
|
8304 | if (lbm_value_is_printable_string(v, &str)) { |
| 267 | 1276 | r = print_emit_char(chan, '"'); | |
| 268 |
1/2✓ Branch 0 taken 1276 times.
✗ Branch 1 not taken.
|
1276 | if (r == EMIT_OK) { |
| 269 | 1276 | r = print_emit_string_value(chan, str); | |
| 270 |
1/2✓ Branch 0 taken 1276 times.
✗ Branch 1 not taken.
|
1276 | if (r == EMIT_OK) { |
| 271 | 1276 | r = print_emit_char(chan, '"'); | |
| 272 | } | ||
| 273 | } | ||
| 274 | } else { | ||
| 275 | 7028 | r= print_emit_array_data(chan, array); | |
| 276 | } | ||
| 277 | } else { | ||
| 278 | 448 | r = print_emit_string(chan, "[INVALID_ARRAY]"); | |
| 279 | } | ||
| 280 | 8752 | return r; | |
| 281 | } | ||
| 282 | |||
| 283 | |||
| 284 | 667559 | static int lbm_print_internal(lbm_char_channel_t *chan, lbm_value v) { | |
| 285 | |||
| 286 | 667559 | lbm_stack_clear(&print_stack); | |
| 287 | 667559 | lbm_value start_print[2] = {v, PRINT}; | |
| 288 | 667559 | push_n(&print_stack, start_print, 2); | |
| 289 | 667559 | bool chan_full = false; | |
| 290 | lbm_value curr; | ||
| 291 | lbm_uint instr; | ||
| 292 | 667559 | int r = EMIT_FAILED; | |
| 293 | |||
| 294 |
3/4✓ Branch 0 taken 1251827 times.
✓ Branch 1 taken 667189 times.
✓ Branch 2 taken 1251827 times.
✗ Branch 3 not taken.
|
2586575 | while (!lbm_stack_is_empty(&print_stack) && !chan_full) { |
| 295 | 1251827 | lbm_pop(&print_stack, &instr); | |
| 296 |
8/10✗ Branch 0 not taken.
✓ Branch 1 taken 359 times.
✓ Branch 2 taken 1077 times.
✓ Branch 3 taken 359 times.
✓ Branch 4 taken 105688 times.
✓ Branch 5 taken 124805 times.
✓ Branch 6 taken 105072 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 7791 times.
✓ Branch 9 taken 906676 times.
|
1251827 | switch (instr) { |
| 297 | 359 | case START_ARRAY: { | |
| 298 | 359 | lbm_pop(&print_stack, &curr); | |
| 299 | 359 | int res = 1; | |
| 300 | 359 | r = print_emit_string(chan, "[|"); | |
| 301 | 359 | lbm_array_header_t *arr = (lbm_array_header_t*)lbm_car(curr); | |
| 302 | 359 | lbm_uint size = arr->size / sizeof(lbm_value); | |
| 303 | 359 | lbm_value *arrdata = (lbm_value*)arr->data; | |
| 304 |
1/2✓ Branch 0 taken 359 times.
✗ Branch 1 not taken.
|
359 | if (size >= 1) { |
| 305 | 359 | lbm_value continuation[5] = | |
| 306 | {1, // next index | ||
| 307 | 359 | (lbm_uint) arr, | |
| 308 | CONTINUE_ARRAY, | ||
| 309 | 359 | arrdata[0], // first elt | |
| 310 | PRINT}; | ||
| 311 |
2/4✓ Branch 0 taken 359 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 359 times.
✗ Branch 3 not taken.
|
359 | res = res && push_n(&print_stack, continuation, 5); |
| 312 | } else { | ||
| 313 | ✗ | res = res && lbm_push(&print_stack, END_ARRAY); | |
| 314 | } | ||
| 315 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 359 times.
|
359 | if (!res) { |
| 316 | ✗ | return EMIT_FAILED; | |
| 317 | } | ||
| 318 | 359 | break; | |
| 319 | } | ||
| 320 | 1077 | case CONTINUE_ARRAY: { | |
| 321 | lbm_uint arr_ptr; | ||
| 322 | lbm_array_header_t *arr; | ||
| 323 | lbm_uint ix; | ||
| 324 | 1077 | int res = 1; | |
| 325 | 1077 | lbm_pop_2(&print_stack, &arr_ptr, &ix); | |
| 326 | 1077 | arr = (lbm_array_header_t *)arr_ptr; | |
| 327 | 1077 | lbm_value *arrdata = (lbm_value*)arr->data; | |
| 328 |
2/2✓ Branch 0 taken 718 times.
✓ Branch 1 taken 359 times.
|
1077 | if (ix < (arr->size / sizeof(lbm_value))) { |
| 329 | 718 | r = print_emit_char(chan, ' '); | |
| 330 | 718 | lbm_value continuation[5] = | |
| 331 | 718 | {ix + 1, | |
| 332 | 718 | (lbm_uint) arr, | |
| 333 | CONTINUE_ARRAY, | ||
| 334 | 718 | arrdata[ix], | |
| 335 | PRINT}; | ||
| 336 |
2/4✓ Branch 0 taken 718 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 718 times.
✗ Branch 3 not taken.
|
718 | res = res && push_n(&print_stack, continuation, 5); |
| 337 | } else { | ||
| 338 |
2/4✓ Branch 0 taken 359 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 359 times.
✗ Branch 3 not taken.
|
359 | res = res && lbm_push(&print_stack, END_ARRAY); |
| 339 | } | ||
| 340 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1077 times.
|
1077 | if (!res) { |
| 341 | ✗ | return EMIT_FAILED; | |
| 342 | } | ||
| 343 | 1077 | break; | |
| 344 | } | ||
| 345 | 359 | case END_ARRAY: { | |
| 346 | 359 | r = print_emit_string(chan, "|]"); | |
| 347 | 359 | break; | |
| 348 | } | ||
| 349 | 105688 | case START_LIST: { | |
| 350 | 105688 | lbm_pop(&print_stack, &curr); | |
| 351 | 105688 | r = print_emit_char(chan, '('); | |
| 352 |
2/2✓ Branch 0 taken 8 times.
✓ Branch 1 taken 105680 times.
|
105688 | if (r != EMIT_OK) return r; |
| 353 | 105680 | lbm_value car_val = lbm_car(curr); | |
| 354 | 105680 | lbm_value cdr_val = lbm_cdr(curr); | |
| 355 | 105680 | int res = 1; | |
| 356 |
3/4✓ Branch 0 taken 17158 times.
✓ Branch 1 taken 88522 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 17158 times.
|
122838 | if (lbm_type_of(cdr_val) == LBM_TYPE_CONS || |
| 357 | 17158 | lbm_type_of(cdr_val) == (LBM_TYPE_CONS | LBM_PTR_TO_CONSTANT_BIT)) { | |
| 358 | 88522 | lbm_value cont[2] = {cdr_val, CONTINUE_LIST}; | |
| 359 |
2/4✓ Branch 0 taken 88522 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 88522 times.
✗ Branch 3 not taken.
|
88522 | res = res && push_n(&print_stack, cont, 2); |
| 360 |
4/4✓ Branch 0 taken 10269 times.
✓ Branch 1 taken 6889 times.
✓ Branch 2 taken 9372 times.
✓ Branch 3 taken 897 times.
|
17158 | } else if (lbm_type_of(cdr_val) == LBM_TYPE_SYMBOL && |
| 361 | cdr_val == ENC_SYM_NIL) { | ||
| 362 |
2/4✓ Branch 0 taken 9372 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 9372 times.
✗ Branch 3 not taken.
|
9372 | res = res && lbm_push(&print_stack, END_LIST); |
| 363 | } else { | ||
| 364 | 7786 | lbm_value cont[4] = {END_LIST, cdr_val, PRINT, PRINT_DOT}; | |
| 365 |
2/4✓ Branch 0 taken 7786 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 7786 times.
✗ Branch 3 not taken.
|
7786 | res = res && push_n(&print_stack, cont, 4); |
| 366 | } | ||
| 367 | 105680 | lbm_value cont[2] = {car_val, PRINT}; | |
| 368 |
2/4✓ Branch 0 taken 105680 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 105680 times.
✗ Branch 3 not taken.
|
105680 | res = res && push_n(&print_stack, cont,2); |
| 369 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 105680 times.
|
105680 | if (!res) { |
| 370 | ✗ | return EMIT_FAILED; | |
| 371 | } | ||
| 372 | 105680 | break; | |
| 373 | } | ||
| 374 | 124805 | case CONTINUE_LIST: { | |
| 375 | 124805 | int res = 1; | |
| 376 | 124805 | lbm_pop(&print_stack, &curr); | |
| 377 | |||
| 378 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 124805 times.
|
124805 | if (lbm_type_of(curr) == LBM_TYPE_SYMBOL && |
| 379 | ✗ | curr == ENC_SYM_NIL) { | |
| 380 | 124625 | break; | |
| 381 | } | ||
| 382 | |||
| 383 | 124805 | lbm_value car_val = lbm_car(curr); | |
| 384 | 124805 | lbm_value cdr_val = lbm_cdr(curr); | |
| 385 | |||
| 386 | 124805 | r = print_emit_char(chan, ' '); | |
| 387 |
2/2✓ Branch 0 taken 180 times.
✓ Branch 1 taken 124625 times.
|
124805 | if (r != EMIT_OK) { |
| 388 | 180 | return r; | |
| 389 | } | ||
| 390 |
3/4✓ Branch 0 taken 88158 times.
✓ Branch 1 taken 36467 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 88158 times.
|
212783 | if (lbm_type_of(cdr_val) == LBM_TYPE_CONS || |
| 391 | 88158 | lbm_type_of(cdr_val) == (LBM_TYPE_CONS | LBM_PTR_TO_CONSTANT_BIT)) { | |
| 392 | 36467 | lbm_value cont[2] = {cdr_val, CONTINUE_LIST}; | |
| 393 |
2/4✓ Branch 0 taken 36467 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 36467 times.
✗ Branch 3 not taken.
|
36467 | res = res && push_n(&print_stack, cont, 2); |
| 394 |
3/4✓ Branch 0 taken 88153 times.
✓ Branch 1 taken 5 times.
✓ Branch 2 taken 88153 times.
✗ Branch 3 not taken.
|
88158 | } else if (lbm_type_of(cdr_val) == LBM_TYPE_SYMBOL && |
| 395 | cdr_val == ENC_SYM_NIL) { | ||
| 396 |
2/4✓ Branch 0 taken 88153 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 88153 times.
✗ Branch 3 not taken.
|
88153 | res = res && lbm_push(&print_stack, END_LIST); |
| 397 | } else { | ||
| 398 | 5 | lbm_value cont[4] = {END_LIST, cdr_val, PRINT, PRINT_DOT}; | |
| 399 |
2/4✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5 times.
✗ Branch 3 not taken.
|
5 | res = res && push_n(&print_stack, cont, 4); |
| 400 | } | ||
| 401 | 124625 | lbm_value cont[2] = {car_val, PRINT}; | |
| 402 |
2/4✓ Branch 0 taken 124625 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 124625 times.
✗ Branch 3 not taken.
|
124625 | res = res && push_n(&print_stack, cont, 2); |
| 403 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 124625 times.
|
124625 | if (!res) { |
| 404 | ✗ | return EMIT_FAILED; | |
| 405 | } | ||
| 406 | 124625 | break; | |
| 407 | } | ||
| 408 | 105072 | case END_LIST: | |
| 409 | 105072 | r = print_emit_char(chan, ')'); | |
| 410 |
2/2✓ Branch 0 taken 112 times.
✓ Branch 1 taken 104960 times.
|
105072 | if (r != EMIT_OK) return r; |
| 411 | 104960 | break; | |
| 412 | ✗ | case PRINT_SPACE: | |
| 413 | ✗ | r = print_emit_char(chan, ' '); | |
| 414 | ✗ | if (r != EMIT_OK) return r; | |
| 415 | ✗ | break; | |
| 416 | 7791 | case PRINT_DOT: | |
| 417 | 7791 | r = print_emit_string(chan, " . "); | |
| 418 |
2/2✓ Branch 0 taken 56 times.
✓ Branch 1 taken 7735 times.
|
7791 | if (r != EMIT_OK) return r; |
| 419 | 7735 | break; | |
| 420 | 906676 | case PRINT: | |
| 421 | 906676 | lbm_pop(&print_stack, &curr); | |
| 422 | |||
| 423 | 906676 | lbm_type t = lbm_type_of(curr); | |
| 424 |
2/2✓ Branch 0 taken 242659 times.
✓ Branch 1 taken 664017 times.
|
906676 | if (lbm_is_ptr(curr)) |
| 425 | 242659 | t = t & LBM_PTR_TO_CONSTANT_MASK; // print constants normally | |
| 426 | |||
| 427 |
18/18✓ Branch 0 taken 105688 times.
✓ Branch 1 taken 534430 times.
✓ Branch 2 taken 79689 times.
✓ Branch 3 taken 43234 times.
✓ Branch 4 taken 2016 times.
✓ Branch 5 taken 850 times.
✓ Branch 6 taken 675 times.
✓ Branch 7 taken 229 times.
✓ Branch 8 taken 4214 times.
✓ Branch 9 taken 224 times.
✓ Branch 10 taken 224 times.
✓ Branch 11 taken 101748 times.
✓ Branch 12 taken 2 times.
✓ Branch 13 taken 24216 times.
✓ Branch 14 taken 8752 times.
✓ Branch 15 taken 112 times.
✓ Branch 16 taken 359 times.
✓ Branch 17 taken 14 times.
|
906676 | switch(t) { |
| 428 | 105688 | case LBM_TYPE_CONS: { | |
| 429 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 105688 times.
|
105688 | if (lbm_dec_ptr(curr) == LBM_PTR_NULL) { |
| 430 | ✗ | print_emit_string(chan, " LBM_NULL "); | |
| 431 | } else { | ||
| 432 | 105688 | lbm_value cont[2] = {curr, START_LIST}; | |
| 433 | 105688 | int res = push_n(&print_stack, cont, 2); | |
| 434 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 105688 times.
|
105688 | if (!res) { |
| 435 | ✗ | print_emit_string(chan," ..."); | |
| 436 | ✗ | return EMIT_OK; | |
| 437 | } | ||
| 438 | } | ||
| 439 | 105688 | break; | |
| 440 | } | ||
| 441 | 534430 | case LBM_TYPE_SYMBOL: | |
| 442 | 534430 | r = print_emit_symbol(chan, curr); | |
| 443 | 534430 | break; | |
| 444 | 79689 | case LBM_TYPE_I: | |
| 445 | 79689 | r = print_emit_i(chan, lbm_dec_i(curr)); | |
| 446 | 79689 | break; | |
| 447 | 43234 | case LBM_TYPE_U: | |
| 448 | 43234 | r = print_emit_u(chan, lbm_dec_u(curr), true); | |
| 449 | 43234 | break; | |
| 450 | 2016 | case LBM_TYPE_CHAR: | |
| 451 | 2016 | r = print_emit_byte(chan, (uint8_t)lbm_dec_char(curr), true); | |
| 452 | 2016 | break; | |
| 453 | 850 | case LBM_TYPE_FLOAT: | |
| 454 | 850 | r = print_emit_float(chan, lbm_dec_float(curr), true); | |
| 455 | 850 | break; | |
| 456 | 675 | case LBM_TYPE_DOUBLE: | |
| 457 | 675 | r = print_emit_double(chan, lbm_dec_double(curr), true); | |
| 458 | 675 | break; | |
| 459 | 229 | case LBM_TYPE_U32: | |
| 460 | 229 | r = print_emit_u32(chan, lbm_dec_u32(curr), true); | |
| 461 | 229 | break; | |
| 462 | 4214 | case LBM_TYPE_I32: | |
| 463 | 4214 | r = print_emit_i32(chan, lbm_dec_i32(curr), true); | |
| 464 | 4214 | break; | |
| 465 | 224 | case LBM_TYPE_U64: | |
| 466 | 224 | r = print_emit_u64(chan, lbm_dec_u64(curr), true); | |
| 467 | 224 | break; | |
| 468 | 224 | case LBM_TYPE_I64: | |
| 469 | 224 | r = print_emit_i64(chan, lbm_dec_i64(curr), true); | |
| 470 | 224 | break; | |
| 471 | 101748 | case LBM_CONTINUATION_INTERNAL_TYPE: | |
| 472 | 101748 | r = print_emit_continuation(chan, curr); | |
| 473 | 101748 | break; | |
| 474 | 2 | case LBM_TYPE_CUSTOM: | |
| 475 | 2 | r = print_emit_custom(chan, curr); | |
| 476 | 2 | break; | |
| 477 | 24216 | case LBM_TYPE_CHANNEL: | |
| 478 | 24216 | r = print_emit_channel(chan, curr); | |
| 479 | 24216 | break; | |
| 480 | 8752 | case LBM_TYPE_ARRAY: | |
| 481 | 8752 | r = print_emit_bytearray(chan, curr); | |
| 482 | 8752 | break; | |
| 483 | 112 | case LBM_TYPE_DEFRAG_MEM: | |
| 484 | 112 | r = print_emit_defrag_mem(chan, curr); | |
| 485 | 112 | break; | |
| 486 | 359 | case LBM_TYPE_LISPARRAY: { | |
| 487 | 359 | lbm_value cont[2] = {curr, START_ARRAY}; | |
| 488 | 359 | int res = push_n(&print_stack, cont, 2); | |
| 489 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 359 times.
|
359 | if (!res) { |
| 490 | ✗ | print_emit_string(chan, " ..."); | |
| 491 | ✗ | return EMIT_OK; | |
| 492 | } | ||
| 493 | 359 | break; | |
| 494 | } | ||
| 495 | 14 | default: | |
| 496 | 14 | return EMIT_FAILED; | |
| 497 | } | ||
| 498 | } | ||
| 499 | } | ||
| 500 | 667189 | return r; | |
| 501 | } | ||
| 502 | |||
| 503 | 667559 | int lbm_print_value(char *buf, unsigned int len, lbm_value v) { | |
| 504 | |||
| 505 | lbm_string_channel_state_t st; | ||
| 506 | lbm_char_channel_t chan; | ||
| 507 | |||
| 508 | 667559 | memset(buf, 0, len); | |
| 509 | 667559 | lbm_create_string_char_channel_size(&st, &chan, buf, len); | |
| 510 |
2/2✓ Branch 0 taken 666615 times.
✓ Branch 1 taken 944 times.
|
667559 | if (lbm_print_internal(&chan,v) == EMIT_OK) |
| 511 | 666615 | return 1; | |
| 512 | 944 | return 0; | |
| 513 | } | ||
| 514 |