| Line | Branch | Exec | Source |
|---|---|---|---|
| 1 | /* | ||
| 2 | Copyright 2019, 2021, 2024 Joel Svensson svenssonjoel@yahoo.se | ||
| 3 | |||
| 4 | This program is free software: you can redistribute it and/or modify | ||
| 5 | it under the terms of the GNU General Public License as published by | ||
| 6 | the Free Software Foundation, either version 3 of the License, or | ||
| 7 | (at your option) any later version. | ||
| 8 | |||
| 9 | This program is distributed in the hope that it will be useful, | ||
| 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
| 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
| 12 | GNU General Public License for more details. | ||
| 13 | |||
| 14 | You should have received a copy of the GNU General Public License | ||
| 15 | along with this program. If not, see <http://www.gnu.org/licenses/>. | ||
| 16 | */ | ||
| 17 | |||
| 18 | #include <lbm_memory.h> | ||
| 19 | #include <lbm_types.h> | ||
| 20 | #include <string.h> | ||
| 21 | |||
| 22 | #include "stack.h" | ||
| 23 | #include "print.h" | ||
| 24 | |||
| 25 | #define STACK_UNUSED_BYTE 0x55 | ||
| 26 | #ifndef LBM64 | ||
| 27 | #define STACK_UNUSED_WORD 0x55555555 | ||
| 28 | #else | ||
| 29 | #define STACK_UNUSED_WORD 0x5555555555555555 | ||
| 30 | #endif | ||
| 31 | |||
| 32 | 22596 | int lbm_stack_allocate(lbm_stack_t *s, lbm_uint stack_size) { | |
| 33 | 22596 | int r = 0; | |
| 34 | 22596 | s->data = lbm_memory_allocate(stack_size); | |
| 35 |
2/2✓ Branch 0 taken 22540 times.
✓ Branch 1 taken 56 times.
|
22596 | if (s->data) { |
| 36 | 22540 | memset(s->data, STACK_UNUSED_BYTE, stack_size * sizeof(lbm_uint)); | |
| 37 | 22540 | s->sp = 0; | |
| 38 | 22540 | s->size = stack_size; | |
| 39 | 22540 | r = 1; | |
| 40 | } | ||
| 41 | 22596 | return r; | |
| 42 | } | ||
| 43 | |||
| 44 | 43008 | int lbm_stack_create(lbm_stack_t *s, lbm_uint* data, lbm_uint stack_size) { | |
| 45 | 43008 | s->data = data; | |
| 46 | 43008 | memset(s->data, STACK_UNUSED_BYTE, stack_size * sizeof(lbm_uint)); | |
| 47 | 43008 | s->sp = 0; | |
| 48 | 43008 | s->size = stack_size; | |
| 49 | 43008 | return 1; | |
| 50 | } | ||
| 51 | |||
| 52 | ✗ | lbm_uint lbm_get_max_stack(lbm_stack_t *s) { | |
| 53 | ✗ | lbm_uint unused = 0; | |
| 54 | ✗ | for (int i = (int)s->size-1 ; i >= 0; i --) { | |
| 55 | ✗ | if (s->data[i] == STACK_UNUSED_WORD) { | |
| 56 | ✗ | unused ++; | |
| 57 | } else { | ||
| 58 | ✗ | break; | |
| 59 | } | ||
| 60 | } | ||
| 61 | ✗ | return s->size - unused; | |
| 62 | } | ||
| 63 | |||
| 64 | 22312 | void lbm_stack_free(lbm_stack_t *s) { | |
| 65 |
1/2✓ Branch 0 taken 22312 times.
✗ Branch 1 not taken.
|
22312 | if (s->data) { |
| 66 | 22312 | lbm_memory_free(s->data); | |
| 67 | } | ||
| 68 | 22312 | } | |
| 69 | |||
| 70 | 45336 | void lbm_stack_clear(lbm_stack_t *s) { | |
| 71 | 45336 | s->sp = 0; | |
| 72 | 45336 | } | |
| 73 | |||
| 74 | 215443959 | int lbm_stack_drop(lbm_stack_t *s, lbm_uint n) { | |
| 75 | |||
| 76 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 215443959 times.
|
215443959 | if (n > s->sp) return 0; |
| 77 | |||
| 78 | 215443959 | s->sp -= n; | |
| 79 | 215443959 | return 1; | |
| 80 | } | ||
| 81 | |||
| 82 | 18720420 | int lbm_push(lbm_stack_t *s, lbm_uint val) { | |
| 83 | 18720420 | int res = 1; | |
| 84 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 18720420 times.
|
18720420 | if (s->sp == s->size) { |
| 85 | ✗ | return 0; | |
| 86 | } | ||
| 87 | 18720420 | s->data[s->sp++] = val; | |
| 88 | 18720420 | return res; | |
| 89 | } | ||
| 90 | |||
| 91 | 452368963 | int lbm_pop(lbm_stack_t *s, lbm_uint *val) { | |
| 92 | 452368963 | s->sp--; | |
| 93 | 452368963 | *val = s->data[s->sp]; | |
| 94 | 452368963 | return 1; | |
| 95 | } | ||
| 96 | |||
| 97 | 6503125 | int lbm_pop_2(lbm_stack_t *s, lbm_uint *r0, lbm_uint *r1) { | |
| 98 | 6503125 | s->sp--; | |
| 99 | 6503125 | *r0 = s->data[s->sp--]; | |
| 100 | 6503125 | *r1 = s->data[s->sp]; | |
| 101 | 6503125 | return 1; | |
| 102 | } | ||
| 103 | |||
| 104 | 352251 | int lbm_pop_3(lbm_stack_t *s, lbm_uint *r0, lbm_uint *r1, lbm_uint *r2) { | |
| 105 | 352251 | s->sp--; | |
| 106 | 352251 | *r0 = s->data[s->sp--]; | |
| 107 | 352251 | *r1 = s->data[s->sp--]; | |
| 108 | 352251 | *r2 = s->data[s->sp]; | |
| 109 | 352251 | return 1; | |
| 110 | } | ||
| 111 | |||
| 112 |