ABC: A System for Sequential Synthesis and Verification
 
Loading...
Searching...
No Matches
Classes | Macros | Typedefs
fifo.h File Reference
#include "stack.h"
#include <string.h>
#include "global.h"
Include dependency graph for fifo.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  unsigned_fifo
 

Macros

#define FIFO(TYPE)
 
#define BEGIN_FIFO(F)
 
#define END_FIFO(F)
 
#define START_FIFO(F)
 
#define LIMIT_FIFO(F)
 
#define ALLOCATED_FIFO(F)
 
#define INIT_FIFO(F)
 
#define EMPTY_FIFO(F)
 
#define FULL_FIFO(F)
 
#define SIZE_FIFO(F)
 
#define MOVABLE_FIFO(F)
 
#define CAPACITY_FIFO(F)
 
#define ENLARGE_FIFO(T, F)
 
#define MOVE_FIFO(F)
 
#define ENQUEUE_FIFO(T, F, E)
 
#define DEQUEUE_FIFO(F, E)
 
#define POP_FIFO(F)
 
#define RELEASE_FIFO(F)
 
#define CLEAR_FIFO(F)
 
#define all_fifo   all_stack
 

Typedefs

typedef struct unsigned_fifo unsigned_fifo
 

Macro Definition Documentation

◆ all_fifo

#define all_fifo   all_stack

Definition at line 98 of file fifo.h.

◆ ALLOCATED_FIFO

#define ALLOCATED_FIFO ( F)
Value:
((F).allocated)

Definition at line 24 of file fifo.h.

◆ BEGIN_FIFO

#define BEGIN_FIFO ( F)
Value:
((F).begin)

Definition at line 20 of file fifo.h.

◆ CAPACITY_FIFO

#define CAPACITY_FIFO ( F)
Value:
(ALLOCATED_FIFO (F) - START_FIFO (F))
START_FIFO
#define START_FIFO(F)
Definition fifo.h:22
ALLOCATED_FIFO
#define ALLOCATED_FIFO(F)
Definition fifo.h:24

Definition at line 33 of file fifo.h.

◆ CLEAR_FIFO

#define CLEAR_FIFO ( F)
Value:
do { \
BEGIN_FIFO (F) = END_FIFO (F) = START_FIFO (F); \
} while (0)
END_FIFO
#define END_FIFO(F)
Definition fifo.h:21

Definition at line 86 of file fifo.h.

86#define CLEAR_FIFO(F) \
87 do { \
88 BEGIN_FIFO (F) = END_FIFO (F) = START_FIFO (F); \
89 } while (0)

◆ DEQUEUE_FIFO

#define DEQUEUE_FIFO ( F,
E )
Value:
do { \
KISSAT_assert (!EMPTY_FIFO (F)); \
(E) = *BEGIN_FIFO (F)++; \
if (MOVABLE_FIFO (F)) \
MOVE_FIFO (F); \
} while (0)
BEGIN_FIFO
#define BEGIN_FIFO(F)
Definition fifo.h:20
EMPTY_FIFO
#define EMPTY_FIFO(F)
Definition fifo.h:28
MOVABLE_FIFO
#define MOVABLE_FIFO(F)
Definition fifo.h:32

Definition at line 68 of file fifo.h.

68#define DEQUEUE_FIFO(F, E) \
69 do { \
70 KISSAT_assert (!EMPTY_FIFO (F)); \
71 (E) = *BEGIN_FIFO (F)++; \
72 if (MOVABLE_FIFO (F)) \
73 MOVE_FIFO (F); \
74 } while (0)

◆ EMPTY_FIFO

#define EMPTY_FIFO ( F)
Value:
(END_FIFO (F) == BEGIN_FIFO (F))

Definition at line 28 of file fifo.h.

◆ END_FIFO

#define END_FIFO ( F)
Value:
((F).end)

Definition at line 21 of file fifo.h.

◆ ENLARGE_FIFO

#define ENLARGE_FIFO ( T,
F )
Value:
do { \
size_t OLD_BEGIN_OFFSET = BEGIN_FIFO (F) - START_FIFO (F); \
size_t OLD_END_OFFSET = END_FIFO (F) - START_FIFO (F); \
size_t OLD_CAPACITY = CAPACITY_FIFO (F); \
size_t NEW_CAPACITY = OLD_CAPACITY ? 2 * OLD_CAPACITY : 2; \
size_t OLD_BYTES = OLD_CAPACITY * sizeof *BEGIN_FIFO (F); \
size_t NEW_BYTES = NEW_CAPACITY * sizeof *BEGIN_FIFO (F); \
START_FIFO (F) = \
(T*) kissat_realloc (solver, START_FIFO (F), OLD_BYTES, NEW_BYTES); \
ALLOCATED_FIFO (F) = START_FIFO (F) + NEW_CAPACITY; \
LIMIT_FIFO (F) = START_FIFO (F) + NEW_CAPACITY / 2; \
BEGIN_FIFO (F) = START_FIFO (F) + OLD_BEGIN_OFFSET; \
END_FIFO (F) = START_FIFO (F) + OLD_END_OFFSET; \
KISSAT_assert (BEGIN_FIFO (F) < LIMIT_FIFO (F)); \
} while (0)
kissat_realloc
void * kissat_realloc(kissat *solver, void *p, size_t old_bytes, size_t new_bytes)
Definition allocate.c:123
LIMIT_FIFO
#define LIMIT_FIFO(F)
Definition fifo.h:23
CAPACITY_FIFO
#define CAPACITY_FIFO(F)
Definition fifo.h:33
solver
#define solver
Definition kitten.c:211

Definition at line 35 of file fifo.h.

35#define ENLARGE_FIFO(T, F) \
36 do { \
37 size_t OLD_BEGIN_OFFSET = BEGIN_FIFO (F) - START_FIFO (F); \
38 size_t OLD_END_OFFSET = END_FIFO (F) - START_FIFO (F); \
39 size_t OLD_CAPACITY = CAPACITY_FIFO (F); \
40 size_t NEW_CAPACITY = OLD_CAPACITY ? 2 * OLD_CAPACITY : 2; \
41 size_t OLD_BYTES = OLD_CAPACITY * sizeof *BEGIN_FIFO (F); \
42 size_t NEW_BYTES = NEW_CAPACITY * sizeof *BEGIN_FIFO (F); \
43 START_FIFO (F) = \
44 (T*) kissat_realloc (solver, START_FIFO (F), OLD_BYTES, NEW_BYTES); \
45 ALLOCATED_FIFO (F) = START_FIFO (F) + NEW_CAPACITY; \
46 LIMIT_FIFO (F) = START_FIFO (F) + NEW_CAPACITY / 2; \
47 BEGIN_FIFO (F) = START_FIFO (F) + OLD_BEGIN_OFFSET; \
48 END_FIFO (F) = START_FIFO (F) + OLD_END_OFFSET; \
49 KISSAT_assert (BEGIN_FIFO (F) < LIMIT_FIFO (F)); \
50 } while (0)

◆ ENQUEUE_FIFO

#define ENQUEUE_FIFO ( T,
F,
E )
Value:
do { \
if (FULL_FIFO (F)) \
ENLARGE_FIFO (T, F); \
*END_FIFO (F)++ = (E); \
} while (0)
FULL_FIFO
#define FULL_FIFO(F)
Definition fifo.h:29

Definition at line 61 of file fifo.h.

61#define ENQUEUE_FIFO(T, F, E) \
62 do { \
63 if (FULL_FIFO (F)) \
64 ENLARGE_FIFO (T, F); \
65 *END_FIFO (F)++ = (E); \
66 } while (0)

◆ FIFO

#define FIFO ( TYPE)
Value:
struct { \
TYPE *begin; \
TYPE *end; \
TYPE *start; \
TYPE *limit; \
TYPE *allocated; \
}
TYPE
@ TYPE
Definition inflate.h:34

Definition at line 11 of file fifo.h.

11#define FIFO(TYPE) \
12 struct { \
13 TYPE *begin; \
14 TYPE *end; \
15 TYPE *start; \
16 TYPE *limit; \
17 TYPE *allocated; \
18 }

◆ FULL_FIFO

#define FULL_FIFO ( F)
Value:
(END_FIFO (F) == ALLOCATED_FIFO (F))

Definition at line 29 of file fifo.h.

◆ INIT_FIFO

#define INIT_FIFO ( F)
Value:
memset (&(F), 0, sizeof (F))
memset
char * memset()

Definition at line 26 of file fifo.h.

◆ LIMIT_FIFO

#define LIMIT_FIFO ( F)
Value:
((F).limit)

Definition at line 23 of file fifo.h.

◆ MOVABLE_FIFO

#define MOVABLE_FIFO ( F)
Value:
(BEGIN_FIFO (F) == LIMIT_FIFO (F))

Definition at line 32 of file fifo.h.

◆ MOVE_FIFO

#define MOVE_FIFO ( F)
Value:
do { \
size_t SIZE = SIZE_FIFO (F); \
size_t BYTES = SIZE * sizeof *BEGIN_FIFO (F); \
memmove (START_FIFO (F), BEGIN_FIFO (F), BYTES); \
BEGIN_FIFO (F) = START_FIFO (F); \
END_FIFO (F) = BEGIN_FIFO (F) + SIZE; \
} while (0)
SIZE
#define SIZE(set)
Definition espresso.h:112
SIZE_FIFO
#define SIZE_FIFO(F)
Definition fifo.h:30

Definition at line 52 of file fifo.h.

52#define MOVE_FIFO(F) \
53 do { \
54 size_t SIZE = SIZE_FIFO (F); \
55 size_t BYTES = SIZE * sizeof *BEGIN_FIFO (F); \
56 memmove (START_FIFO (F), BEGIN_FIFO (F), BYTES); \
57 BEGIN_FIFO (F) = START_FIFO (F); \
58 END_FIFO (F) = BEGIN_FIFO (F) + SIZE; \
59 } while (0)

◆ POP_FIFO

#define POP_FIFO ( F)
Value:
(KISSAT_assert (!EMPTY_FIFO (F)), *--END_FIFO (F))
KISSAT_assert
#define KISSAT_assert(ignore)
Definition global.h:13

Definition at line 76 of file fifo.h.

◆ RELEASE_FIFO

#define RELEASE_FIFO ( F)
Value:
do { \
size_t CAPACITY = CAPACITY_FIFO (F); \
size_t BYTES = CAPACITY * sizeof *BEGIN_FIFO (F); \
kissat_free (solver, START_FIFO (F), BYTES); \
INIT_FIFO (F); \
} while (0)

Definition at line 78 of file fifo.h.

78#define RELEASE_FIFO(F) \
79 do { \
80 size_t CAPACITY = CAPACITY_FIFO (F); \
81 size_t BYTES = CAPACITY * sizeof *BEGIN_FIFO (F); \
82 kissat_free (solver, START_FIFO (F), BYTES); \
83 INIT_FIFO (F); \
84 } while (0)

◆ SIZE_FIFO

#define SIZE_FIFO ( F)
Value:
(END_FIFO (F) - BEGIN_FIFO (F))

Definition at line 30 of file fifo.h.

◆ START_FIFO

#define START_FIFO ( F)
Value:
((F).start)

Definition at line 22 of file fifo.h.

Typedef Documentation

◆ unsigned_fifo

typedef struct unsigned_fifo unsigned_fifo

Definition at line 96 of file fifo.h.