genevent/parser.h

   1 #ifndef PARSER_H
   2 #define PARSER_H
   3
   4 /* Extensible array container */
   5
   6 typedef struct _sequence {
   7   int size;
   8   int position;
   9   void **array;
  10 } sequence;
  11
  12 void sequence_init(sequence *t);
  13 void sequence_dispose(sequence *t);
  14 void sequence_push(sequence *t, void *elem);
  15 void *sequence_pop(sequence *t);
  16
  17
  18 /* Hash table */
  19
  20 typedef struct _table {
  21   sequence keys;
  22   sequence values;
  23 } table;
  24
  25 void table_init(table *t);
  26 void table_dispose(table *t);
  27 void table_insert(table *t, char *key, void *value);
  28 void *table_find(table *t, char *key);
  29 void table_insert_int(table *t, int *key, void *value);
  30 void *table_find_int(table *t, int *key);
  31
  32
  33 /* Token types */
  34
  35 typedef enum _token_type {
  36   ENDFILE,
  37   FORWARDSLASH,
  38   LANGLEBRACKET,
  39   RANGLEBRACKET,
  40   EQUAL,
  41   QUOTEDSTRING,
  42   NUMBER,
  43   NAME
  44 } token_type;
  45
  46
  47 /* State associated with a file being parsed */
  48 typedef struct _parse_file {
  49   char *name;
  50   FILE * fp;
  51   int lineno;
  52   char *buffer;
  53   token_type type;
  54   int unget;
  55   void (*error) (struct _parse_file *, char *);
  56 } parse_file;
  57
  58 void ungetToken(parse_file * in);
  59 char *getToken(parse_file *in);
  60 char *getForwardslash(parse_file *in);
  61 char *getLAnglebracket(parse_file *in);
  62 char *getRAnglebracket(parse_file *in);
  63 char *getQuotedString(parse_file *in);
  64 char *getName(parse_file *in);
  65 int   getNumber(parse_file *in);
  66 char *getEqual(parse_file *in);
  67 char  seekNextChar(parse_file *in);
  68
  69 void skipComment(parse_file * in);
  70 void skipEOL(parse_file * in);
  71
  72 /* Some constants */
  73
  74 static const int BUFFER_SIZE = 1024;
  75
  76
  77 /* Events data types */
  78
  79 typedef enum _data_type {
  80   INT,
  81   UINT,
  82         POINTER,
  83         LONG,
  84         ULONG,
  85         SIZE_T,
  86         SSIZE_T,
  87         OFF_T,
  88   FLOAT,
  89   STRING,
  90   ENUM,
  91   ARRAY,
  92   SEQUENCE,
  93   STRUCT,
  94   UNION,
  95   NONE
  96 } data_type;
  97
  98 /* Event type descriptors */
  99
 100 typedef struct _type_descriptor {
 101   char * type_name; //used for named type
 102   data_type type;
 103   char *fmt;
 104   int size;
 105   sequence labels; // for enumeration
 106         sequence labels_description;
 107         int     already_printed;
 108   sequence fields; // for structure
 109   struct _type_descriptor *nested_type; // for array and sequence
 110   int alignment;
 111 } type_descriptor;
 112
 113
 114 /* Fields within types */
 115
 116 typedef struct _field{
 117   char *name;
 118   char *description;
 119   type_descriptor *type;
 120 } field;
 121
 122
 123 /* Events definitions */
 124
 125 typedef struct _event {
 126   char *name;
 127   char *description;
 128   type_descriptor *type;
 129   int  per_trace;   /* Is the event able to be logged to a specific trace ? */
 130   int  per_tracefile;  /* Must we log this event in a specific tracefile ? */
 131 } event;
 132
 133 typedef struct _facility {
 134   char * name;
 135         char * capname;
 136   char * description;
 137   sequence events;
 138   sequence unnamed_types;
 139   table named_types;
 140 } facility;
 141
 142 int getSize(parse_file *in);
 143 unsigned long getTypeChecksum(unsigned long aCrc, type_descriptor * type);
 144
 145 void parseFacility(parse_file *in, facility * fac);
 146 void parseEvent(parse_file *in, event *ev, sequence * unnamed_types, table * named_types);
 147 void parseTypeDefinition(parse_file *in, sequence * unnamed_types, table * named_types);
 148 type_descriptor *parseType(parse_file *in, type_descriptor *t, sequence * unnamed_types, table * named_types);
 149 void parseFields(parse_file *in, type_descriptor *t, sequence * unnamed_types, table * named_types);
 150 void checkNamedTypesImplemented(table * namedTypes);
 151 type_descriptor * find_named_type(char *name, table * named_types);
 152 void generateChecksum(char * facName, unsigned long * checksum, sequence * events);
 153
 154
 155 /* get attributes */
 156 char * getNameAttribute(parse_file *in);
 157 char * getFormatAttribute(parse_file *in);
 158 int    getSizeAttribute(parse_file *in);
 159 int    getValueAttribute(parse_file *in);
 160 char * getValueStrAttribute(parse_file *in);
 161
 162 char * getDescription(parse_file *in);
 163
 164
 165 static char *intOutputTypes[] = {
 166   "int8_t", "int16_t", "int32_t", "int64_t", "short int", "int", "long int" };
 167
 168 static char *uintOutputTypes[] = {
 169   "uint8_t", "uint16_t", "uint32_t", "uint64_t", "unsigned short int",
 170   "unsigned int", "unsigned long int" };
 171
 172 static char *floatOutputTypes[] = {
 173   "undef", "undef", "float", "double", "undef", "float", "double" };
 174
 175
 176 /* Dynamic memory allocation and freeing */
 177
 178 void * memAlloc(int size);
 179 char *allocAndCopy(char * str);
 180 char *appendString(char *s, char *suffix);
 181 void freeTypes(sequence *t);
 182 void freeType(type_descriptor * td);
 183 void freeEvents(sequence *t);
 184 void freeNamedType(table * t);
 185 void error_callback(parse_file *in, char *msg);
 186
 187
 188 //checksum part
 189 static const unsigned int crctab32[] =
 190 {
 191 #include "crc32.tab"
 192 };
 193
 194 static inline unsigned long
 195 partial_crc32_one(unsigned char c, unsigned long crc)
 196 {
 197   return crctab32[(crc ^ c) & 0xff] ^ (crc >> 8);
 198 }
 199
 200 static inline unsigned long
 201 partial_crc32(const char *s, unsigned long crc)
 202 {
 203   while (*s)
 204     crc = partial_crc32_one(*s++, crc);
 205   return crc;
 206 }
 207
 208 static inline unsigned long
 209 crc32(const char *s)
 210 {
 211   return partial_crc32(s, 0xffffffff) ^ 0xffffffff;
 212 }
 213
 214
 215 #endif // PARSER_H