131 lines
2.9 KiB
C
131 lines
2.9 KiB
C
#ifndef _stack_h_INCLUDED
|
|
#define _stack_h_INCLUDED
|
|
|
|
#include <stdlib.h>
|
|
|
|
#define STACK(TYPE) \
|
|
struct { TYPE * begin; TYPE * end; TYPE * allocated; }
|
|
|
|
#define FULL_STACK(S) ((S).end == (S).allocated)
|
|
#define EMPTY_STACK(S) ((S).begin == (S).end)
|
|
#define SIZE_STACK(S) ((size_t)((S).end - (S).begin))
|
|
#define CAPACITY_STACK(S) ((size_t)((S).allocated - (S).begin))
|
|
|
|
#define INIT_STACK(S) \
|
|
do { \
|
|
(S).begin = (S).end = (S).allocated = 0; \
|
|
} while (0)
|
|
|
|
#define TOP_STACK(S) \
|
|
(END_STACK (S)[assert (!EMPTY_STACK (S)), -1])
|
|
|
|
#define PEEK_STACK(S,N) \
|
|
(BEGIN_STACK (S)[assert ((N) < SIZE_STACK (S)), (N)])
|
|
|
|
#define POKE_STACK(S,N,E) \
|
|
do { \
|
|
PEEK_STACK (S,N) = (E); \
|
|
} while (0)
|
|
|
|
#define POP_STACK(S) \
|
|
(assert (!EMPTY_STACK (S)), *--(S).end)
|
|
|
|
#define ENLARGE_STACK(S) \
|
|
do { \
|
|
assert (FULL_STACK (S)); \
|
|
kissat_stack_enlarge (solver, (chars*) &(S), sizeof *(S).begin); \
|
|
} while (0)
|
|
|
|
#define SHRINK_STACK(S) \
|
|
do { \
|
|
if (!FULL_STACK (S)) \
|
|
kissat_shrink_stack (solver, (chars*) &(S), sizeof *(S).begin); \
|
|
} while (0)
|
|
|
|
#define PUSH_STACK(S,E) \
|
|
do { \
|
|
if (FULL_STACK(S)) \
|
|
ENLARGE_STACK (S); \
|
|
*(S).end++ = (E); \
|
|
} while (0)
|
|
|
|
#define BEGIN_STACK(S) (S).begin
|
|
#define END_STACK(S) (S).end
|
|
|
|
#define RELEASE_STACK(S) \
|
|
do { \
|
|
kissat_dealloc (solver, (S).begin, CAPACITY_STACK (S), sizeof *(S).begin); \
|
|
INIT_STACK (S); \
|
|
} while (0)
|
|
|
|
#define CLEAR_STACK(S) \
|
|
do { \
|
|
(S).end = (S).begin; \
|
|
} while (0)
|
|
|
|
#define RESIZE_STACK(S,NEW_SIZE) \
|
|
do { \
|
|
assert ((NEW_SIZE) <= SIZE_STACK (S)); \
|
|
(S).end = (S).begin + (NEW_SIZE); \
|
|
} while (0)
|
|
|
|
#define SET_END_OF_STACK(S,P) \
|
|
do { \
|
|
assert (BEGIN_STACK (S) <= (P)); \
|
|
assert ((P) <= END_STACK(S)); \
|
|
if ((P) == END_STACK (S)) \
|
|
break; \
|
|
(S).end = (P); \
|
|
} while (0)
|
|
|
|
#define RELEASE_STACK(S) \
|
|
do { \
|
|
kissat_dealloc (solver, (S).begin, CAPACITY_STACK (S), sizeof *(S).begin); \
|
|
INIT_STACK (S); \
|
|
} while (0)
|
|
|
|
#define REMOVE_STACK(T,S,E) \
|
|
do { \
|
|
assert (!EMPTY_STACK (S)); \
|
|
T * END_REMOVE_STACK = END_STACK (S); \
|
|
T * P_REMOVE_STACK = BEGIN_STACK (S); \
|
|
while (*P_REMOVE_STACK != (E)) \
|
|
{ \
|
|
P_REMOVE_STACK++; \
|
|
assert (P_REMOVE_STACK != END_REMOVE_STACK); \
|
|
} \
|
|
P_REMOVE_STACK++; \
|
|
while (P_REMOVE_STACK != END_REMOVE_STACK) \
|
|
{ \
|
|
P_REMOVE_STACK[-1] = *P_REMOVE_STACK; \
|
|
P_REMOVE_STACK++; \
|
|
} \
|
|
(S).end--; \
|
|
} while (0)
|
|
|
|
#define all_stack(T,E,S) \
|
|
T E, * E_PTR = BEGIN_STACK(S), * E_END = END_STACK(S); \
|
|
E_PTR != E_END && (E = *E_PTR, true); \
|
|
++E_PTR
|
|
|
|
#define all_pointers(T,E,S) \
|
|
T * E, ** E_PTR = BEGIN_STACK(S), ** E_END = END_STACK(S); \
|
|
E_PTR != E_END && (E = *E_PTR, true); \
|
|
++E_PTR
|
|
|
|
// *INDENT-OFF*
|
|
|
|
typedef STACK (char) chars;
|
|
typedef STACK (int) ints;
|
|
typedef STACK (size_t) sizes;
|
|
typedef STACK (unsigned) unsigneds;
|
|
|
|
// *INDENT-ON*
|
|
|
|
struct kissat;
|
|
|
|
void kissat_stack_enlarge (struct kissat *, chars *, size_t size_of_element);
|
|
void kissat_shrink_stack (struct kissat *, chars *, size_t size_of_element);
|
|
|
|
#endif
|