codebase/c_stack.h at main · 7amdev/codebase · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
#ifndef Stack_H
#define Stack_H

#ifndef Stack_Free
#include <stdlib.h>
#define Stack_Free free
#endif // Stack_Free

#ifndef Stack_Assert
#include <assert.h>
#define Stack_Assert assert
#endif // Stack_Assert

#include <stdbool.h>

#define Stack_Items_Length(items) (sizeof(items) / sizeof(*(items)))

#define Stack_push(stack, item_in, item_out)                                    \
do {                                                                            \
    Stack_Assert(Stack_is_full(stack) == false && "ERROR: Stack is full!");     \
    (stack)->items[(stack)->top] = (item_in);                                   \
    (stack)->top += 1;                                                          \
    if ((item_out) != NULL) *(item_out) = (stack)->items[(stack)->top - 1];     \
} while (0)

#define Stack_pop(stack, item_out)                                              \
do {                                                                            \
    Stack_Assert(Stack_is_empty(stack) == false && "ERROR: Stack is empty!");   \
    (stack)->top -= 1;                                                          \
    if ((item_out) != NULL) *(item_out) = (stack)->items[(stack)->top];         \
} while (0)

#define Stack_peek(stack, item_out, offset)                         \
do {                                                                \
    if (Stack_is_empty(stack)) break;                               \
    int index = (stack)->top - 1 - (offset);                        \
    if (index < 0) break;                                           \
    Stack_Assert(index >= 0);                                       \
    Stack_Assert(index < (stack)->top);                             \
    if ((item_out) != NULL) *(item_out) = (stack)->items[index];    \
} while (0)

#define Stack_is_full(stack)  ((stack)->top == Stack_Items_Length((stack)->items))

#define Stack_is_empty(stack) ((stack)->top == 0)

#define Stack_is_out_of_bounds(stack, offset) (         \
    ((stack)->top - 1 - offset) < 0             ||      \
    ((stack)->top - 1 - offset) >= (stack)->top         \
)

#define Stack_reset(stack)    (stack)->top = 0

#define Stack_free(stack) Stack_Free(stack)

//
// Stack Pointer Implementation
//

#define StackPointer_count(stack)    (int)(  (stack)->top - (stack)->items  )
#define StackPointer_is_full(stack)  ( ((stack)->top - (stack)->items) == Stack_Items_Length((stack)->items) )
#define StackPointer_is_empty(stack) ( (stack)->top == (stack)->items )

#define StackPointer_init(stack)    \
do {                                \
    (stack)->top = (stack)->items;  \
} while (0)

#define StackPointer_reset(stack)  StackPointer_init(stack)

#define StackPointer_push(stack, item_in, item_out)         \
do {                                                        \
    Stack_Assert(!StackPointer_is_full(stack));             \
    *(stack)->top = (item_in);                              \
    if (item_out) *(item_out) = *(stack)->top;              \
    (stack)->top += 1;                                      \
} while (0)

#define StackPointer_pop(stack, item_out)                   \
do {                                                        \
    Stack_Assert(!StackPointer_is_empty(stack));            \
    (stack)->top -= 1;                                      \
    if (item_out) *(item_out) = *(stack)->top;              \
} while (0)

typedef struct {
    int   offset;
    bool *error;
    const char **error_msg;
} PeekOptions;

#define StackPointer_peek(stack, item_out, ...)     \
    StackPointer_peek_option(                       \
        (stack),                                    \
        (item_out),                                 \
        (PeekOptions) {__VA_ARGS__}                 \
    )

#define StackPointer_peek_option(stack, item_out, options)              \
do {                                                                    \
    void *addr = (stack)->top - 1 - (options).offset;                   \
    if (addr < (stack)->items || addr >= (stack)->top) {                \
        if ((options).error)                                            \
            *(options).error = true;                                    \
        if ((options).error_msg)                                        \
            *(options).error_msg = "Out-of-Bounds access lookup.";      \
        break;                                                          \
    }                                                                   \
    if ((options).error_msg)    *(options).error_msg = "";              \
    if ((options).error)        *(options).error = false;               \
    if (item_out) *item_out = *((stack)->top - 1 - (options).offset);   \
} while (0)


#define StackPointer_free(stack)     Stack_Free(stack)

#endif // Stack_H