[lttv.git] / genevent-new / parser.h

#ifndef PARSER_H
#define PARSER_H

/* Extensible array container */

typedef struct _sequence {
  int size;
  int position;
  void **array;
} sequence_t;

void sequence_init(sequence_t *t);
void sequence_dispose(sequence_t *t);
void sequence_push(sequence_t *t, void *elem);
void *sequence_pop(sequence_t *t);


/* Hash table */

typedef struct _table {
  sequence_t keys;
  sequence_t values;
} table_t;

void table_init(table_t *t);
void table_dispose(table_t *t);
void table_insert(table_t *t, char *key, void *value);
void *table_find(table_t *t, char *key);
void table_insert_int(table_t *t, int *key, void *value);
void *table_find_int(table_t *t, int *key);


/* Token types */

typedef enum _token_type {
  ENDFILE,
  FORWARDSLASH,
  LANGLEBRACKET,
  RANGLEBRACKET,
  EQUAL,
  QUOTEDSTRING,
  NUMBER,
  NAME
} token_type_t;


/* State associated with a file being parsed */
typedef struct _parse_file {
  char *name;
  FILE * fp;
  int lineno;
  char *buffer;
  token_type_t type; 
  int unget;
  void (*error) (struct _parse_file *, char *);
} parse_file_t;

void ungetToken(parse_file_t * in);
char *getToken(parse_file_t *in);
char *getForwardslash(parse_file_t *in);
char *getLAnglebracket(parse_file_t *in);
char *getRAnglebracket(parse_file_t *in);
char *getQuotedString(parse_file_t *in);
char *getName(parse_file_t *in);
int   getNumber(parse_file_t *in);
char *getEqual(parse_file_t *in);
char  seekNextChar(parse_file_t *in);

void skipComment(parse_file_t * in);
void skipEOL(parse_file_t * in);

/* Some constants */

static const int BUFFER_SIZE = 1024;


/* Events data types */

typedef enum _data_type {
  INT_FIXED,
  UINT_FIXED,
	POINTER,
	CHAR,
	UCHAR,
	SHORT,
	USHORT,
  INT,
  UINT,
	LONG,
	ULONG,
	SIZE_T,
	SSIZE_T,
	OFF_T,
  FLOAT,
  STRING,
  ENUM,
  ARRAY,
  SEQUENCE,
  STRUCT,
  UNION,
  NONE
} data_type_t;

/* Event type descriptors */

typedef struct _type_descriptor {
  char * type_name; //used for named type
  data_type_t type;
  char *fmt;
  unsigned long long size;
  sequence_t labels; // for enumeration
	sequence_t labels_description;
	int	already_printed;
  sequence_t fields; // for structure
  struct _type_descriptor *nested_type; // for array and sequence 
  int alignment;
} type_descriptor_t;


/* Fields within types */

typedef struct _field{
  char *name;
  char *description;
  type_descriptor_t *type;
} field_t;


/* Events definitions */

typedef struct _event {  
  char *name;
  char *description;
  type_descriptor_t *type; 
  int  per_trace;   /* Is the event able to be logged to a specific trace ? */
  int  per_tracefile;  /* Must we log this event in a specific tracefile ? */
} event_t;

typedef struct _facility {
  char * name;
	char * capname;
  char * description;
  sequence_t events;
  sequence_t unnamed_types;
  table_t named_types;
} facility_t;

int getSizeindex(unsigned int value);
unsigned long long int getSize(parse_file_t *in);
unsigned long getTypeChecksum(unsigned long aCrc, type_descriptor_t * type);

void parseFacility(parse_file_t *in, facility_t * fac);
void parseEvent(parse_file_t *in, event_t *ev, sequence_t * unnamed_types,
    table_t * named_types);
void parseTypeDefinition(parse_file_t *in,
    sequence_t * unnamed_types, table_t * named_types);
type_descriptor_t *parseType(parse_file_t *in,
    type_descriptor_t *t, sequence_t * unnamed_types, table_t * named_types);
void parseFields(parse_file_t *in, type_descriptor_t *t,
    sequence_t * unnamed_types, table_t * named_types);
void checkNamedTypesImplemented(table_t * namedTypes);
type_descriptor_t * find_named_type(char *name, table_t * named_types);
void generateChecksum(char * facName,
    unsigned long * checksum, sequence_t * events);


/* get attributes */
char * getNameAttribute(parse_file_t *in);
char * getFormatAttribute(parse_file_t *in);
int    getSizeAttribute(parse_file_t *in);
int    getValueAttribute(parse_file_t *in);
char * getValueStrAttribute(parse_file_t *in);

char * getDescription(parse_file_t *in);


/* Dynamic memory allocation and freeing */

void * memAlloc(int size);
char *allocAndCopy(char * str);
char *appendString(char *s, char *suffix);
void freeTypes(sequence_t *t);
void freeType(type_descriptor_t * td);
void freeEvents(sequence_t *t);
void freeNamedType(table_t * t);
void error_callback(parse_file_t *in, char *msg);


//checksum part
static const unsigned int crctab32[] =
{
#include "crc32.tab"
};

static inline unsigned long
partial_crc32_one(unsigned char c, unsigned long crc)
{
  return crctab32[(crc ^ c) & 0xff] ^ (crc >> 8);
}

static inline unsigned long
partial_crc32(const char *s, unsigned long crc)
{
  while (*s)
    crc = partial_crc32_one(*s++, crc);
  return crc;
}

static inline unsigned long
crc32(const char *s)
{
  return partial_crc32(s, 0xffffffff) ^ 0xffffffff;
}


extern char *intOutputTypes[];

extern char *uintOutputTypes[];

extern char *floatOutputTypes[];


#endif // PARSER_H
Commit	Line	Data
3583026d	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_t;
	11
	12	void sequence_init(sequence_t *t);
	13	void sequence_dispose(sequence_t *t);
	14	void sequence_push(sequence_t t, void elem);
	15	void sequence_pop(sequence_t t);
	16
	17
	18	/* Hash table */
	19
	20	typedef struct _table {
	21	sequence_t keys;
	22	sequence_t values;
	23	} table_t;
	24
	25	void table_init(table_t *t);
	26	void table_dispose(table_t *t);
	27	void table_insert(table_t t, char key, void *value);
	28	void table_find(table_t t, char *key);
	29	void table_insert_int(table_t t, int key, void *value);
	30	void table_find_int(table_t 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_t;
	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_t type;
	54	int unget;
	55	void (error) (struct _parse_file , char *);
	56	} parse_file_t;
	57
	58	void ungetToken(parse_file_t * in);
	59	char getToken(parse_file_t in);
	60	char getForwardslash(parse_file_t in);
	61	char getLAnglebracket(parse_file_t in);
	62	char getRAnglebracket(parse_file_t in);
	63	char getQuotedString(parse_file_t in);
	64	char getName(parse_file_t in);
65	int getNumber(parse_file_t *in);
66	char getEqual(parse_file_t in);
67	char seekNextChar(parse_file_t *in);
68
69	void skipComment(parse_file_t * in);
70	void skipEOL(parse_file_t * 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 {
2d2d14a7	80	INT_FIXED,
	81	UINT_FIXED,
	82	POINTER,
	83	CHAR,
	84	UCHAR,
	85	SHORT,
	86	USHORT,
3583026d	87	INT,
3583026d	88	UINT,
3583026d	89	LONG,
	90	ULONG,
	91	SIZE_T,
	92	SSIZE_T,
	93	OFF_T,
	94	FLOAT,
	95	STRING,
	96	ENUM,
	97	ARRAY,
	98	SEQUENCE,
	99	STRUCT,
	100	UNION,
	101	NONE
	102	} data_type_t;
	103
	104	/* Event type descriptors */
	105
	106	typedef struct _type_descriptor {
	107	char * type_name; //used for named type
	108	data_type_t type;
	109	char *fmt;
2d2d14a7	110	unsigned long long size;
3583026d	111	sequence_t labels; // for enumeration
	112	sequence_t labels_description;
	113	int already_printed;
	114	sequence_t fields; // for structure
	115	struct _type_descriptor *nested_type; // for array and sequence
	116	int alignment;
	117	} type_descriptor_t;
	118
	119
	120	/* Fields within types */
	121
	122	typedef struct _field{
	123	char *name;
	124	char *description;
	125	type_descriptor_t *type;
	126	} field_t;
	127
	128
	129	/* Events definitions */
	130
	131	typedef struct _event {
	132	char *name;
	133	char *description;
	134	type_descriptor_t *type;
	135	int per_trace; /* Is the event able to be logged to a specific trace ? */
	136	int per_tracefile; /* Must we log this event in a specific tracefile ? */
	137	} event_t;
	138
	139	typedef struct _facility {
	140	char * name;
	141	char * capname;
	142	char * description;
	143	sequence_t events;
	144	sequence_t unnamed_types;
	145	table_t named_types;
	146	} facility_t;
	147
2d2d14a7	148	int getSizeindex(unsigned int value);
2d2d14a7	149	unsigned long long int getSize(parse_file_t *in);
3583026d	150	unsigned long getTypeChecksum(unsigned long aCrc, type_descriptor_t * type);
	151
	152	void parseFacility(parse_file_t in, facility_t fac);
	153	void parseEvent(parse_file_t in, event_t ev, sequence_t * unnamed_types,
	154	table_t * named_types);
	155	void parseTypeDefinition(parse_file_t *in,
	156	sequence_t * unnamed_types, table_t * named_types);
	157	type_descriptor_t parseType(parse_file_t in,
	158	type_descriptor_t t, sequence_t unnamed_types, table_t * named_types);
	159	void parseFields(parse_file_t in, type_descriptor_t t,
	160	sequence_t * unnamed_types, table_t * named_types);
	161	void checkNamedTypesImplemented(table_t * namedTypes);
	162	type_descriptor_t * find_named_type(char name, table_t named_types);
	163	void generateChecksum(char * facName,
	164	unsigned long * checksum, sequence_t * events);
	165
	166
	167	/* get attributes */
	168	char * getNameAttribute(parse_file_t *in);
	169	char * getFormatAttribute(parse_file_t *in);
	170	int getSizeAttribute(parse_file_t *in);
	171	int getValueAttribute(parse_file_t *in);
	172	char * getValueStrAttribute(parse_file_t *in);
	173
	174	char * getDescription(parse_file_t *in);
	175
	176
	177	/* Dynamic memory allocation and freeing */
	178
	179	void * memAlloc(int size);
	180	char allocAndCopy(char str);
	181	char appendString(char s, char *suffix);
	182	void freeTypes(sequence_t *t);
	183	void freeType(type_descriptor_t * td);
	184	void freeEvents(sequence_t *t);
	185	void freeNamedType(table_t * t);
	186	void error_callback(parse_file_t in, char msg);
	187
	188
	189	//checksum part
	190	static const unsigned int crctab32[] =
	191	{
	192	#include "crc32.tab"
	193	};
	194
	195	static inline unsigned long
	196	partial_crc32_one(unsigned char c, unsigned long crc)
	197	{
	198	return crctab32[(crc ^ c) & 0xff] ^ (crc >> 8);
	199	}
	200
	201	static inline unsigned long
	202	partial_crc32(const char *s, unsigned long crc)
	203	{
	204	while (*s)
	205	crc = partial_crc32_one(*s++, crc);
	206	return crc;
	207	}
	208
	209	static inline unsigned long
	210	crc32(const char *s)
	211	{
	212	return partial_crc32(s, 0xffffffff) ^ 0xffffffff;
	213	}
214
215
2d2d14a7	216	extern char *intOutputTypes[];
	217
	218	extern char *uintOutputTypes[];
	219
	220	extern char *floatOutputTypes[];
	221
	222
	223
	224
3583026d	225	#endif // PARSER_H