[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 
	struct _type_descriptor *length_type; // for 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; 
	sequence_t fields;	/* event fields */
  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, field_t *f,
    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
be97b953	116	struct _type_descriptor *length_type; // for sequence
3583026d	117	int alignment;
	118	} type_descriptor_t;
	119
	120
	121	/* Fields within types */
	122
	123	typedef struct _field{
	124	char *name;
	125	char *description;
	126	type_descriptor_t *type;
	127	} field_t;
	128
	129
	130	/* Events definitions */
	131
	132	typedef struct _event {
	133	char *name;
	134	char *description;
47299663	135	//type_descriptor_t *type;
47299663	136	sequence_t fields; /* event fields */
3583026d	137	int per_trace; /* Is the event able to be logged to a specific trace ? */
	138	int per_tracefile; /* Must we log this event in a specific tracefile ? */
	139	} event_t;
	140
	141	typedef struct _facility {
	142	char * name;
	143	char * capname;
	144	char * description;
	145	sequence_t events;
	146	sequence_t unnamed_types;
	147	table_t named_types;
	148	} facility_t;
	149
2d2d14a7	150	int getSizeindex(unsigned int value);
2d2d14a7	151	unsigned long long int getSize(parse_file_t *in);
3583026d	152	unsigned long getTypeChecksum(unsigned long aCrc, type_descriptor_t * type);
	153
	154	void parseFacility(parse_file_t in, facility_t fac);
	155	void parseEvent(parse_file_t in, event_t ev, sequence_t * unnamed_types,
	156	table_t * named_types);
	157	void parseTypeDefinition(parse_file_t *in,
	158	sequence_t * unnamed_types, table_t * named_types);
	159	type_descriptor_t parseType(parse_file_t in,
	160	type_descriptor_t t, sequence_t unnamed_types, table_t * named_types);
47299663	161	void parseFields(parse_file_t in, field_t f,
3583026d	162	sequence_t * unnamed_types, table_t * named_types);
	163	void checkNamedTypesImplemented(table_t * namedTypes);
	164	type_descriptor_t * find_named_type(char name, table_t named_types);
	165	void generateChecksum(char * facName,
	166	unsigned long * checksum, sequence_t * events);
	167
	168
	169	/* get attributes */
	170	char * getNameAttribute(parse_file_t *in);
	171	char * getFormatAttribute(parse_file_t *in);
	172	int getSizeAttribute(parse_file_t *in);
	173	int getValueAttribute(parse_file_t *in);
	174	char * getValueStrAttribute(parse_file_t *in);
	175
	176	char * getDescription(parse_file_t *in);
	177
	178
	179	/* Dynamic memory allocation and freeing */
	180
	181	void * memAlloc(int size);
	182	char allocAndCopy(char str);
	183	char appendString(char s, char *suffix);
	184	void freeTypes(sequence_t *t);
	185	void freeType(type_descriptor_t * td);
	186	void freeEvents(sequence_t *t);
	187	void freeNamedType(table_t * t);
	188	void error_callback(parse_file_t in, char msg);
	189
	190
	191	//checksum part
	192	static const unsigned int crctab32[] =
	193	{
	194	#include "crc32.tab"
	195	};
	196
	197	static inline unsigned long
	198	partial_crc32_one(unsigned char c, unsigned long crc)
	199	{
	200	return crctab32[(crc ^ c) & 0xff] ^ (crc >> 8);
	201	}
	202
	203	static inline unsigned long
	204	partial_crc32(const char *s, unsigned long crc)
	205	{
	206	while (*s)
	207	crc = partial_crc32_one(*s++, crc);
	208	return crc;
	209	}
	210
	211	static inline unsigned long
	212	crc32(const char *s)
	213	{
	214	return partial_crc32(s, 0xffffffff) ^ 0xffffffff;
	215	}
	216
	217
2d2d14a7	218	extern char *intOutputTypes[];
	219
	220	extern char *uintOutputTypes[];
	221
	222	extern char *floatOutputTypes[];
	223
	224
	225
	226
3583026d	227	#endif // PARSER_H