parser mod

[lttv.git] / genevent / genevent.c

diff --git a/genevent/genevent.c b/genevent/genevent.c
index 316f15b7a076bf8e44be56b2943a1deb94a1ccf9..d39fd02711ca9e5e17a0fda44e221bf41f4ba04f 100644 (file)
--- a/genevent/genevent.c
+++ b/genevent/genevent.c
@@ -49,14 +49,14 @@ This program is distributed in the hope that it will be useful,
 
 /* Named types may be referenced from anywhere */
 
-facility * fac;
+facility_t * fac;
 
 unsigned alignment = 0;
 
 int main(int argc, char** argv)
 {
   char *token;
-  parse_file in;
+  parse_file_t in;
   char buffer[BUFFER_SIZE];
   int i;
 
@@ -98,7 +98,7 @@ int main(int argc, char** argv)
                                token = getName(&in);
                        
                                if(strcmp("facility",token) == 0) {
-                                       fac = memAlloc(sizeof(facility));
+                                       fac = memAlloc(sizeof(facility_t));
                                        fac->name = NULL;
                                        fac->description = NULL;
                                        sequence_init(&(fac->events));
@@ -139,7 +139,8 @@ int main(int argc, char** argv)
  *Input Params
  *    name         : name of event definition file
  ****************************************************************************/
-void generateFile(char *name){
+void generateFile(char *name)
+{
   char *loadName, *hName, *hIdName, *cName, *tmp, *tmp2;
   FILE * lFp, *hFp, *iFp, *cFp;
   int nbEvent;
@@ -245,7 +246,8 @@ void generateFile(char *name){
  *Output Params
  *    nbEvent           : number of events in the facility
  ****************************************************************************/
-void generateEnumEvent(FILE *fp, char *facName, int * nbEvent, unsigned long checksum) {
+void generateEnumEvent(FILE *fp, char *facName, int * nbEvent,
+                       unsigned long checksum) {
   int pos = 0;
 
   fprintf(fp,"#include <linux/ltt-facilities.h>\n\n");
@@ -258,7 +260,7 @@ void generateEnumEvent(FILE *fp, char *facName, int * nbEvent, unsigned long che
   fprintf(fp,"enum %s_event {\n",facName);
 
   for(pos = 0; pos < fac->events.position;pos++) {
-    fprintf(fp,"\tevent_%s", ((event *)(fac->events.array[pos]))->name);
+    fprintf(fp,"\tevent_%s", ((event_t *)(fac->events.array[pos]))->name);
     if(pos != fac->events.position-1) fprintf(fp,",\n");
   }
   fprintf(fp,"\n};\n\n\n");
@@ -286,26 +288,22 @@ void generateEnumEvent(FILE *fp, char *facName, int * nbEvent, unsigned long che
 static void
 printStruct(FILE * fp, int len, void ** array, char * name, char * facName,
        int * whichTypeFirst, int * hasStrSeq, int * structCount,
-       type_descriptor *type)
+       type_descriptor_t *type)
 {
   int flag = 0;
   int pos;
-  field * fld;
-  type_descriptor * td;
+  field_t * fld;
+  type_descriptor_t * td;
 
   for (pos = 0; pos < len; pos++) {
-    fld  = (field *)array[pos];
+    fld  = (field_t *)array[pos];
     td = fld->type;
     if( td->type == STRING || td->type == SEQUENCE ||
         td->type == ARRAY) {
         (*hasStrSeq)++;
-               }
-//      if (*whichTypeFirst == 0) {
-//        *whichTypeFirst = 1; //struct first
-//      }
+               } else {
       if (flag == 0) {
         flag = 1;
-
         fprintf(fp,"struct %s_%s",name, facName);
         if (structCount) {
           fprintf(fp, "_%d {\n",++*structCount);
@@ -315,19 +313,7 @@ printStruct(FILE * fp, int len, void ** array, char * name, char * facName,
       }
       fprintf(fp, "\t%s %s; /* %s */\n", 
           getTypeStr(td),fld->name,fld->description );
-#if 0
-    } else {
-        if (*whichTypeFirst == 0) {
-        //string or sequence or array first
-          *whichTypeFirst = 2;
-        }
-        (*hasStrSeq)++;
-        if(flag) {
-          fprintf(fp,"} __attribute__ ((packed));\n\n");
-        }
-        flag = 0;
     }
-#endif //0
   }
 
   if(flag) {
@@ -385,7 +371,7 @@ generateTypeDefs(FILE * fp, char *facName)
  *    fp                    : file to be written to
  *    fHead                 : enum type
  ****************************************************************************/
-void generateEnumDefinition(FILE * fp, type_descriptor * type){
+void generateEnumDefinition(FILE * fp, type_descriptor_t * type){
   int pos;
 
   if(type->already_printed) return;
@@ -412,15 +398,15 @@ void generateEnumDefinition(FILE * fp, type_descriptor * type){
  *    facName           : name of facility
  ****************************************************************************/
 void generateStructFunc(FILE * fp, char * facName, unsigned long checksum){
-  event * ev;
-  field * fld;
-  type_descriptor * td;
+  event_t * ev;
+  field_t * fld;
+  type_descriptor_t * td;
   int pos, pos1;
   int hasStrSeq, flag, structCount, seqCount,strCount, whichTypeFirst=0;
   int args_empty;
 
   for(pos = 0; pos < fac->events.position; pos++){
-    ev = (event *) fac->events.array[pos];
+    ev = (event_t *) fac->events.array[pos];
     //yxx    if(ev->nested)continue;
     fprintf(fp,"/****  structure and trace function for event: %s  ****/\n\n",
         ev->name);
@@ -437,7 +423,7 @@ void generateStructFunc(FILE * fp, char * facName, unsigned long checksum){
     //twice.
     if(ev->type != 0)
       for(pos1 = 0; pos1 < ev->type->fields.position; pos1++){
-        fld = (field *)ev->type->fields.array[pos1];
+        fld = (field_t *)ev->type->fields.array[pos1];
         if(fld->type->type == ENUM) generateEnumDefinition(fp, fld->type);      
       }
       
@@ -476,7 +462,7 @@ void generateStructFunc(FILE * fp, char * facName, unsigned long checksum){
     
     if(ev->type != 0) {
       for(pos1 = 0; pos1 < ev->type->fields.position; pos1++){
-        fld  = (field *)ev->type->fields.array[pos1];
+        fld  = (field_t *)ev->type->fields.array[pos1];
         td = fld->type;
         if(!args_empty) fprintf(fp, ", ");
         if(td->type == ARRAY ){
@@ -524,7 +510,7 @@ void generateStructFunc(FILE * fp, char * facName, unsigned long checksum){
 
     if(ev->type != 0) {
       for(pos1 = 0; pos1 < ev->type->fields.position; pos1++){
-        fld  = (field *)ev->type->fields.array[pos1];
+        fld  = (field_t *)ev->type->fields.array[pos1];
         td = fld->type;
         if(!args_empty) fprintf(fp, ", ");
         if(td->type == ARRAY ){
@@ -645,7 +631,7 @@ void generateStructFunc(FILE * fp, char * facName, unsigned long checksum){
     flag = 0;
                if(ev->type != 0)
                        for(pos1 = 0; pos1 < ev->type->fields.position; pos1++){
-                               fld  = (field *)ev->type->fields.array[pos1];
+                               fld  = (field_t *)ev->type->fields.array[pos1];
                                td = fld->type;
                                if(td->type == SEQUENCE || td->type==STRING || td->type==ARRAY){
                                        if(td->type == SEQUENCE) {
@@ -735,7 +721,7 @@ void generateStructFunc(FILE * fp, char * facName, unsigned long checksum){
     structCount = 0;
                if(ev->type != 0)
                        for(pos1 = 0; pos1 < ev->type->fields.position; pos1++){
-                               fld  = (field *)ev->type->fields.array[pos1];
+                               fld  = (field_t *)ev->type->fields.array[pos1];
                                td = fld->type;
        //      if(td->type != STRING && td->type != SEQUENCE && td->type != ARRAY){
        //        if(flag == 0) structCount++;  
@@ -847,7 +833,7 @@ void generateStructFunc(FILE * fp, char * facName, unsigned long checksum){
     //structCount = 0;
                if(ev->type != 0)
                        for(pos1 = 0; pos1 < ev->type->fields.position; pos1++){
-                               fld  = (field *)ev->type->fields.array[pos1];
+                               fld  = (field_t *)ev->type->fields.array[pos1];
                                td = fld->type;
                                if(td->type != ARRAY && td->type != SEQUENCE && td->type != STRING){
                                        //if(flag == 0){
@@ -912,8 +898,8 @@ void generateStructFunc(FILE * fp, char * facName, unsigned long checksum){
  *Return Values
  *    char *            : type string
  ****************************************************************************/
-char * getTypeStr(type_descriptor * td){
-  type_descriptor * t ;
+char * getTypeStr(type_descriptor_t * td){
+  type_descriptor_t * t ;
 
   switch(td->type){
     case INT: