[lttv.git] / ltt / branches / poly / ltt / parser.h

#ifndef PARSER_H
#define PARSER_H

/* Extensible array container */

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

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


/* Hash table */

typedef struct _table {
  sequence keys;
  sequence values;
} table;

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


/* Token types */

typedef enum _token_type {
  ENDFILE,
  COMA,
  LPARENTHESIS,
  RPARENTHESIS,
  SEMICOLON,
  EQUAL,
  QUOTEDSTRING,
  NUMBER,
  NAME
} token_type;


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

void ungetToken(parse_file * in);
char *getToken(parse_file *in);
char *getComa(parse_file *in);
char *getLParenthesis(parse_file *in);
char *getRParenthesis(parse_file *in);
char *getSemiColon(parse_file *in);
char *getQuotedString(parse_file *in);
char *getName(parse_file *in);
int getNumber(parse_file *in);
char * getEqual(parse_file *in);

void skipComment(parse_file * in);
void skipEOL(parse_file * in);
int isalpha(char car);
int isalnum(char car);

/* Some constants */

static const int BUFFER_SIZE = 1024;


/* Events data types */

typedef enum _data_type {
  INT,
  UINT,
  FLOAT,
  STRING,
  ENUM,
  ARRAY,
  SEQUENCE,
  STRUCT,
  NONE
} data_type;


/* Event type descriptors */

typedef struct _type_descriptor {
  char * type_name; //used for named type
  data_type type;
  char *fmt;
  int size;
  sequence labels; // for enumeration
  sequence fields; // for structure
  struct _type_descriptor *nested_type; // for array and sequence 
} type_descriptor;


/* Fields within types */

typedef struct _field{
  char *name;
  char *description;
  type_descriptor *type;
} field;


/* Events definitions */

typedef struct _event {  
  char *name;
  char *description;
  type_descriptor *type; 
  int nested;
} event;

int getSize(parse_file *in);
unsigned long getTypeChecksum(unsigned long aCrc, type_descriptor * type, int * nestedStruct);

void parseEvent(parse_file *in, event *ev, sequence * unnamed_types, table * named_types);
void parseTypeDefinition(parse_file *in, sequence * unnamed_types, table * named_types);
type_descriptor *parseType(parse_file *in, type_descriptor *t, sequence * unnamed_types, table * named_types);
void parseFields(parse_file *in, type_descriptor *t, sequence * unnamed_types, table * named_types);
void checkNamedTypesImplemented(table * namedTypes);
type_descriptor * find_named_type(char *name, table * named_types);
void generateChecksum(char * facName, unsigned long * checksum, sequence * events);


static char *intOutputTypes[] = {
  "int8_t", "int16_t", "int32_t", "int64_t", "short int", "int", "long int" };

static char *uintOutputTypes[] = {
  "uint8_t", "uint16_t", "uint32_t", "uint64_t", "unsigned short int", 
  "unsigned int", "unsigned long int" };

static char *floatOutputTypes[] = {
  "undef", "undef", "float", "double", "undef", "float", "double" };


/* Dynamic memory allocation and freeing */

void * memAlloc(int size);
char *allocAndCopy(char * str);
char *appendString(char *s, char *suffix);
void freeTypes(sequence *t);
void freeType(type_descriptor * td);
void freeEvents(sequence *t);
void freeNamedType(table * t);
void error_callback(parse_file *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;
}


#endif // PARSER_H
Commit	Line	Data
6cd62ccf	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	COMA,
	38	LPARENTHESIS,
	39	RPARENTHESIS,
	40	SEMICOLON,
	41	EQUAL,
	42	QUOTEDSTRING,
	43	NUMBER,
	44	NAME
	45	} token_type;
	46
	47
	48	/* State associated with a file being parsed */
	49	typedef struct _parse_file {
	50	char *name;
	51	FILE * fp;
	52	int lineno;
	53	char *buffer;
	54	token_type type;
	55	int unget;
	56	void (error) (struct _parse_file , char *);
	57	} parse_file;
	58
	59	void ungetToken(parse_file * in);
	60	char getToken(parse_file in);
	61	char getComa(parse_file in);
	62	char getLParenthesis(parse_file in);
	63	char getRParenthesis(parse_file in);
	64	char getSemiColon(parse_file in);
65	char getQuotedString(parse_file in);
66	char getName(parse_file in);
67	int getNumber(parse_file *in);
68	char * getEqual(parse_file *in);
69
70	void skipComment(parse_file * in);
71	void skipEOL(parse_file * in);
72	int isalpha(char car);
73	int isalnum(char car);
74
75	/* Some constants */
76
77	static const int BUFFER_SIZE = 1024;
78
79
80	/* Events data types */
81
82	typedef enum _data_type {
83	INT,
84	UINT,
85	FLOAT,
86	STRING,
87	ENUM,
88	ARRAY,
89	SEQUENCE,
90	STRUCT,
91	NONE
92	} data_type;
93
94
95	/* Event type descriptors */
96
97	typedef struct _type_descriptor {
98	char * type_name; //used for named type
99	data_type type;
100	char *fmt;
101	int size;
102	sequence labels; // for enumeration
103	sequence fields; // for structure
104	struct _type_descriptor *nested_type; // for array and sequence
105	} type_descriptor;
106
107
108	/* Fields within types */
109
110	typedef struct _field{
111	char *name;
112	char *description;
113	type_descriptor *type;
114	} field;
115
116
117	/* Events definitions */
118
119	typedef struct _event {
120	char *name;
121	char *description;
122	type_descriptor *type;
123	int nested;
124	} event;
125
126	int getSize(parse_file *in);
127	unsigned long getTypeChecksum(unsigned long aCrc, type_descriptor * type, int * nestedStruct);
128
129	void parseEvent(parse_file in, event ev, sequence * unnamed_types, table * named_types);
130	void parseTypeDefinition(parse_file in, sequence unnamed_types, table * named_types);
131	type_descriptor parseType(parse_file in, type_descriptor t, sequence unnamed_types, table * named_types);
132	void parseFields(parse_file in, type_descriptor t, sequence * unnamed_types, table * named_types);
133	void checkNamedTypesImplemented(table * namedTypes);
134	type_descriptor * find_named_type(char name, table named_types);
135	void generateChecksum(char * facName, unsigned long * checksum, sequence * events);
136
137
138
139	static char *intOutputTypes[] = {
140	"int8_t", "int16_t", "int32_t", "int64_t", "short int", "int", "long int" };
141
142	static char *uintOutputTypes[] = {
143	"uint8_t", "uint16_t", "uint32_t", "uint64_t", "unsigned short int",
144	"unsigned int", "unsigned long int" };
145
146	static char *floatOutputTypes[] = {
147	"undef", "undef", "float", "double", "undef", "float", "double" };
148
149
150	/* Dynamic memory allocation and freeing */
151
152	void * memAlloc(int size);
153	char allocAndCopy(char str);
154	char appendString(char s, char *suffix);
155	void freeTypes(sequence *t);
156	void freeType(type_descriptor * td);
157	void freeEvents(sequence *t);
158	void freeNamedType(table * t);
159	void error_callback(parse_file in, char msg);
160
161
162	//checksum part
163	static const unsigned int crctab32[] =
164	{
165	#include "crc32.tab"
166	};
167
168	static inline unsigned long
169	partial_crc32_one(unsigned char c, unsigned long crc)
170	{
171	return crctab32[(crc ^ c) & 0xff] ^ (crc >> 8);
172	}
173
174	static inline unsigned long
175	partial_crc32(const char *s, unsigned long crc)
176	{
177	while (*s)
178	crc = partial_crc32_one(*s++, crc);
179	return crc;
180	}
181
182	static inline unsigned long
183	crc32(const char *s)
184	{
185	return partial_crc32(s, 0xffffffff) ^ 0xffffffff;
186	}
187
188
189	#endif // PARSER_H