1 #ifndef ROS_COMMON_H
2 #define ROS_COMMON_H
4 #ifndef __IVY__
5 #include <ros/noivy.h>
6 #endif
8 #include <stddef.h>
9 #include <stdint.h>
10 #include <sys/types.h>
13 typedef ssize_t intreg_t;
14 typedef size_t uintreg_t;
15 typedef int bool;
17 #ifndef NULL
18 #define NULL ((void*) 0)
19 #endif
21 #ifndef TRUE
22 #define TRUE    1
23 #endif
25 #ifndef FALSE
26 #define FALSE   0
27 #endif
29 #define CHECK_FLAG(flags,bit)   ((flags) & (1 << (bit)))
31 #define FOR_CIRC_BUFFER(next, size, var) \
32         for (int _var = 0, var = (next); _var < (size); _var++, var = (var + 1) % (size))
34 // Efficient min and max operations
35 #define MIN(_a, _b)                                             \
36 ({                                                              \
37         typeof(_a) __a = (_a);                                  \
38         typeof(_b) __b = (_b);                                  \
39         __a <= __b ? __a : __b;                                 \
40 })
41 #define MAX(_a, _b)                                             \
42 ({                                                              \
43         typeof(_a) __a = (_a);                                  \
44         typeof(_b) __b = (_b);                                  \
45         __a >= __b ? __a : __b;                                 \
46 })
48 // Rounding operations (efficient when n is a power of 2)
49 // Round down to the nearest multiple of n
50 #define ROUNDDOWN(a, n)                                         \
51 ({                                                              \
52         uint32_t __a = (uint32_t) (a);                          \
53         (typeof(a)) (__a - __a % (n));                          \
54 })
55 // Round up to the nearest multiple of n
56 #define ROUNDUP(a, n)                                           \
57 ({                                                              \
58         uint32_t __n = (uint32_t) (n);                          \
59         (typeof(a)) (ROUNDDOWN((uint32_t) (a) + __n - 1, __n)); \
60 })
62 // Round down to the nearest multiple of n
63 #define PTRROUNDDOWN(a, n)                                              \
64 ({                                                              \
65         char * __a = (char *) (a);                              \
66         (typeof(a)) (__a - (uint32_t)__a % (n));                                \
67 })
68 // Round pointer up to the nearest multiple of n
69 #define PTRROUNDUP(a, n)                                                \
70 ({                                                              \
71         uint32_t __n = (uint32_t) (n);                          \
72         (typeof(a)) (PTRROUNDDOWN((char *) (a) + __n - 1, __n));        \
73 })
75 // Return the integer logarithm of the value provided rounded up
76 static inline uint32_t LOG2(uint32_t value)
77 {
78     uint32_t l = 0;
79     while( (value >> l) > 1 ) ++l;
80     return l;
81 }
83 // Return the offset of 'member' relative to the beginning of a struct type
84 #ifndef offsetof
85 #define offsetof(type, member)  ((size_t) (&((type*)0)->member))
86 #endif
88 // Ivy currently can only handle 63 bits (OCaml thing), so use this to make
89 // a uint64_t programatically
90 #define UINT64(upper, lower) ( (((uint64_t)(upper)) << 32) | (lower) )
94 #define BYTES_FOR_BITMASK(size) (((size) - 1) / 8 + 1)
95 #define BYTES_FOR_BITMASK_WITH_CHECK(size) ((size) ? ((size) - (1)) / (8) + (1) : (0))
98 #define GET_BITMASK_BIT(name, bit) (((name)[(bit)/8] & (1 << ((bit) % 8))) ? 1 : 0)
99 #define SET_BITMASK_BIT(name, bit) ((name)[(bit)/8] |= (1 << ((bit) % 8)))
100 #define CLR_BITMASK_BIT(name, bit) ((name)[(bit)/8] &= ~(1 << ((bit) % 8)))
101 #define SET_BITMASK_BIT_ATOMIC(name, bit) (atomic_orb(&(name)[(bit)/8], (1 << ((bit) % 8))))
102 #define CLR_BITMASK_BIT_ATOMIC(name, bit) (atomic_andb(&(name)[(bit)/8], ~(1 << ((bit) % 8))))
105 ({ \
106         {TRUSTEDBLOCK \
108         } \
109 })
112 ({ \
113         {TRUSTEDBLOCK \
115         } \
116         (name)[BYTES_FOR_BITMASK((size))-1] >>= (((size) % 8) ? (8 - ((size) % 8)) : 0 ); \
117 })
120 ({ \
121         {TRUSTEDBLOCK \
125         } \
126 })
128 // this checks the entire last byte, so keep it 0 in the other macros
129 #define BITMASK_IS_CLEAR(name, size) ({ \
130         uint32_t __n = BYTES_FOR_BITMASK((size)); \
131         bool clear = 1; \
132         while (__n-- > 0) { \
133                 if ((name)[__n]) { \
134                         clear = 0; \
135                         break;\
136                 }\
137         } \
138         clear; })
140 #define PRINT_BITMASK(name, size) { \
141         int i;  \
142         for (i = 0; i < BYTES_FOR_BITMASK(size); i++) { \
143                 int j;  \
144                 for (j = 0; j < 8; j++) \
145                         printk("%x", ((name)[i] >> j) & 1);     \
146         } \
147         printk("\n"); \
148 }
149 /**************************************************************/
150 #endif /* ROS_COMMON_H */