lib.h

   1 #ifndef LIB_H
   2 #define LIB_H
   3 /*
   4  * Basic helper routine descriptions for 'sparse'.
   5  *
   6  * Copyright (C) 2003 Transmeta Corp.
   7  *
   8  *  Licensed under the Open Software License version 1.1
   9  */
  10
  11 extern unsigned int hexval(unsigned int c);
  12
  13 struct position {
  14         unsigned int type:6,
  15                      stream:10,
  16                      pos:14,
  17                      newline:1,
  18                      whitespace:1;
  19         unsigned int line;
  20 };
  21
  22 struct ident;
  23 struct token;
  24 struct symbol;
  25 struct symbol_list;
  26 struct statement;
  27 struct statement_list;
  28 struct expression;
  29 struct expression_list;
  30
  31 struct token *skip_to(struct token *, int);
  32 struct token *expect(struct token *, int, const char *);
  33 extern void warn(struct position, const char *, ...);
  34 extern void error(struct position, const char *, ...);
  35
  36 #define __DECLARE_ALLOCATOR(type, x)            \
  37         extern type *__alloc_##x(int);          \
  38         extern void show_##x##_alloc(void);     \
  39         extern void clear_##x##_alloc(void);
  40 #define DECLARE_ALLOCATOR(x) __DECLARE_ALLOCATOR(struct x, x)
  41
  42 DECLARE_ALLOCATOR(ident);
  43 DECLARE_ALLOCATOR(token);
  44 DECLARE_ALLOCATOR(symbol);
  45 DECLARE_ALLOCATOR(expression);
  46 DECLARE_ALLOCATOR(statement);
  47 DECLARE_ALLOCATOR(string);
  48 DECLARE_ALLOCATOR(scope);
  49 __DECLARE_ALLOCATOR(void, bytes);
  50
  51 #define LIST_NODE_NR (29)
  52
  53 struct ptr_list {
  54         int nr;
  55         struct ptr_list *prev;
  56         struct ptr_list *next;
  57         void *list[LIST_NODE_NR];
  58 };
  59
  60 #define ITERATE_FIRST 1
  61 #define ITERATE_LAST 2
  62 void iterate(struct ptr_list *,void (*callback)(void *, void *, int), void*);
  63 extern void add_ptr_list(struct ptr_list **, void *);
  64 extern int ptr_list_size(struct ptr_list *);
  65
  66 #define symbol_list_size(list) ptr_list_size((struct ptr_list *)(list))
  67 #define statement_list_size(list) ptr_list_size((struct ptr_list *)(list))
  68 #define expression_list_size(list) ptr_list_size((struct ptr_list *)(list))
  69
  70 static inline void add_symbol(struct symbol_list **list, struct symbol *sym)
  71 {
  72         add_ptr_list((struct ptr_list **)list, sym);
  73 }
  74
  75 static inline void add_statement(struct statement_list **list, struct statement *stmt)
  76 {
  77         add_ptr_list((struct ptr_list **)list, stmt);
  78 }
  79
  80 static inline void add_expression(struct expression_list **list, struct expression *expr)
  81 {
  82         add_ptr_list((struct ptr_list **)list, expr);
  83 }
  84
  85 static inline void symbol_iterate(struct symbol_list *list, void (*callback)(struct symbol *, void *, int), void *data)
  86 {
  87         iterate((struct ptr_list *)list, (void (*)(void *, void *, int))callback, data);
  88 }
  89
  90 static inline void statement_iterate(struct statement_list *list, void (*callback)(struct statement *, void *, int), void *data)
  91 {
  92         iterate((struct ptr_list *)list, (void (*)(void *, void *, int))callback, data);
  93 }
  94
  95 static inline void expression_iterate(struct expression_list *list, void (*callback)(struct expression *, void *, int), void *data)
  96 {
  97         iterate((struct ptr_list *)list, (void (*)(void *, void *, int))callback, data);
  98 }
  99
 100 #define PREPARE_PTR_LIST(head, ptr)                                                     \
 101         do {                                                                            \
 102                 struct ptr_list *__head##ptr = (struct ptr_list *) (head);              \
 103                 struct ptr_list *__list##ptr = __head##ptr;                             \
 104                 int __nr##ptr = 0;                                                      \
 105                 if (__head##ptr) ptr = (__typeof__(ptr)) __head##ptr->list[0];          \
 106                 else ptr = NULL
 107
 108 #define NEXT_PTR_LIST(ptr)                                                      \
 109                 if (ptr) {                                                              \
 110                         if (++__nr##ptr < __list##ptr->nr) {                            \
 111                                 ptr = (__typeof__(ptr)) __list##ptr->list[__nr##ptr];   \
 112                         } else {                                                        \
 113                                 __list##ptr = __list##ptr->next;                        \
 114                                 ptr = NULL;                                             \
 115                                 if (__list##ptr != __head##ptr) {                       \
 116                                         __nr##ptr = 0;                                  \
 117                                         ptr = (__typeof__(ptr)) __list##ptr->list[0];   \
 118                                 }                                                       \
 119                         }                                                               \
 120                 }
 121
 122 #define RESET_PTR_LIST(ptr) do {                                                        \
 123                 __nr##ptr = 0;                                                          \
 124                 if (__head##ptr) ptr = (__typeof__(ptr)) __head##ptr->list[0];          \
 125         } while (0)
 126
 127
 128 #define FINISH_PTR_LIST(ptr)                                                            \
 129                 (void)(__nr##ptr); /* Sanity-check nesting */                           \
 130         } while (0)
 131
 132 #define FOR_EACH_PTR(head, ptr) do {                                                    \
 133         struct ptr_list *__head = (struct ptr_list *) (head);                           \
 134         struct ptr_list *__list = __head;                                               \
 135         int __flag = ITERATE_FIRST;                                                     \
 136         if (__head) {                                                                   \
 137                 do { int __i;                                                           \
 138                         for (__i = 0; __i < __list->nr; __i++) {                        \
 139                                 if (__i == __list->nr-1 && __list->next == __head)      \
 140                                         __flag |= ITERATE_LAST;                         \
 141                                 do {                                                    \
 142                                         ptr = (__typeof__(ptr)) (__list->list[__i]);    \
 143                                         do {
 144
 145 #define END_FOR_EACH_PTR                } while (0);                                    \
 146                                 } while (0);                                            \
 147                                 __flag = 0;                                             \
 148                         }                                                               \
 149                 } while ((__list = __list->next) != __head);                            \
 150         }                                                                               \
 151 } while (0)
 152
 153 #define FOR_EACH_PTR_REVERSE(head, ptr) do {                                            \
 154         struct ptr_list *__head = (struct ptr_list *) (head);                           \
 155         struct ptr_list *__list = __head;                                               \
 156         int __flag = ITERATE_FIRST;                                                     \
 157         if (__head) {                                                                   \
 158                 do { int __i;                                                           \
 159                         __list = __list->prev;                                          \
 160                         __i = __list->nr;                                               \
 161                         while (--__i >= 0) {                                            \
 162                                 if (__i == 0 && __list == __head)                       \
 163                                         __flag |= ITERATE_LAST;                         \
 164                                 do {                                                    \
 165                                         ptr = (__typeof__(ptr)) (__list->list[__i]);    \
 166                                         do {
 167
 168 #define END_FOR_EACH_PTR_REVERSE        } while (0);                                    \
 169                                 } while (0);                                            \
 170                                 __flag = 0;                                             \
 171                         }                                                               \
 172                 } while (__list != __head);                                             \
 173         }                                                                               \
 174 } while (0)
 175
 176 #define THIS_ADDRESS(x) \
 177         ((__typeof__(&(x))) (__list->list + __i))
 178
 179 #endif