src/INFN/gen_mcmds.c

/* Note for input file format:

should declare first V,then A, then T all grouped by type
 
 */
#include <stdio.h>
#include <stdlib.h>

#define FLISTNAME "PRH_ParamHandler_INFN_auto.id"
#define TRUE 1 
#define FALSE 0
#define MAXMODE 2

#define SETPARAMETERGEN 0x20
#define TESTDEBUG 0x43

struct list_el
{
  struct list_el *next;
  char string[255];
  int id;
}; 

typedef struct 
{
  char str[255];
  unsigned char code;
} sub_struct;

typedef struct list_el listItem;


listItem *beginList,*beginCommand=NULL; 
unsigned char bufferOut[2048];
int subid;
sub_struct subCommandMode[MAXMODE]={{"SetParameterGen",SETPARAMETERGEN},{"TestDebug",TESTDEBUG}};


void convertHex2Dec(char *str)
{
  char tmp[255]="";
  char dec[10]="";
  char *p,*s;
  unsigned int value;

  if ((p = strstr(str,"0x")) != NULL)
    {
      strncat(tmp,str,p-str);
      sscanf(p+2,"%x",&value);
      sprintf(dec,"%d",value);
      strcat(tmp,dec);
      memcpy(str,tmp,strlen(tmp));
      str[strlen(tmp)]=0;
     }
}

int loadList(char * filename,listItem **first,int command)
{
  FILE *fileList;
  char *s;
  char tmp[255],tmp_1[255];

  int ret = TRUE;

  listItem *loc=NULL,*cur;

  if ((fileList = fopen(filename,"r")) != NULL)
    {
      while (fgets(tmp,254,fileList) != NULL )
         {
           cur = (listItem*)malloc(sizeof(listItem));

           if (loc == NULL)
             {
               *first = cur; loc = cur;
               cur->next = NULL;
             }
           else
             {
               loc->next = cur;
               loc = cur;
               cur->next = NULL;
             }
           
           if (command == TRUE)
             {
               strncpy(cur->string,tmp,strlen(tmp)-1);
             }
           else
             {
               sscanf(tmp,"%s %d\n",tmp_1,&ret);
               strncpy(cur->string,tmp_1,strlen(tmp_1));
             }
           cur->id = ret;
         }
      ret = TRUE;
      fclose(fileList);
    }
  else
    {
      printf("Cannot open file %s!!!\n",FLISTNAME);
      ret = FALSE;
    }

  return(ret);
}

void parseCommand()
{
  listItem *loc;
  char fileName[255];
  int count = 0;
  int VCount = 0,VFirst = TRUE,VSave,VInc;
  int ACount = 0,AFirst = TRUE,ASave,AInc;
  int TCount = 0,TFirst = TRUE,TSave,TInc;

  loc = beginCommand;
  memset(bufferOut,0,2048);

  while (loc != NULL)
    {
      if (count == 0)
        {
          if ((loc->string[0] == 0x0a) || (loc->string[0] == 0x0))
            {
              printf("Finished !");
              exit(0);
            }
          
          strncpy(fileName,loc->string,strlen(loc->string)+1);
          loc = loc->next;
          count++;

          if (strcmp(loc->string,""))
            printf("Processing file: %s\n",fileName);
          
          continue;
        }
      
      if (count == 1)
        {
          if ((subid = returnID(loc->string)) != -1)
            {
              bufferOut[0] = 0;
              bufferOut[1] = subid;
              loc = loc->next;
              count+=3;
              continue;
            }
          else 
            {
              printf("Fatal Error: unknown subcommand %s\n",loc->string);
              exit(1);
            }
        }
      
      if (strcmp(loc->string,""))
        printf("Processing: %s \n",loc->string); 

      convertHex2Dec(loc->string);
      
      switch (subid)           // last subid
        {
        case SETPARAMETERGEN :
          
          switch (loc->string[0])
            {
            case 'V'  :
              {
                char type[255],name[255];
                unsigned int value,id;
                
                sscanf(loc->string,"%s %s %d\n",type,name,&value);
                
                if (VFirst)
                  {
                    VSave = count;   // the place for the command number 
                    VFirst = FALSE;
                    VInc = 1;        // do not consider N after first time 
                  }
                
                if ((id = scanList4ID(name)) != -1)
                  {
                    bufferOut[count+VInc] = id;
                    bufferOut[count+1+VInc] = ((value & 0xff000000) >> 24);
                    bufferOut[count+2+VInc] = ((value & 0x00ff0000) >> 16);
                    bufferOut[count+3+VInc] = ((value & 0x0000ff00) >> 8);
                    bufferOut[count+4+VInc] = value & 0x000000ff;
                    
                    count+=(5+VInc);
                    VCount++;
                    VInc = 0;
                  }
                else 
                  {
                    printf("Fatal Error: unknown macrocommand %s\n",loc->string);
                    exit(1);
                  }
                
                if (loc->next)
                  if (loc->next->string[0] != loc->string[0])
                    bufferOut[VSave] = VCount;
              }
              break;
              
            case 'A' : 
              {
                char type[255],name[255];
                unsigned int value,id,index;
                
                if (VFirst)                      // write 0 if V is not present
                  {
                    bufferOut[count] = 0;
                    count++;
                    VFirst = 0;
                  }
                
                sscanf(loc->string,"%s %s %d %d\n",type,name,&index,&value);
                
                if (AFirst)
                  {
                    ASave = count;   // the place for the command number 
                    AFirst = FALSE;
                    AInc = 1;
                  }
                
                if ((id = scanList4ID(name)) != -1)
                  {
                    bufferOut[count+AInc] = id;
                    bufferOut[count+1+AInc] = index;
                    bufferOut[count+2+AInc] = ((value & 0xff000000) >> 24);
                    bufferOut[count+3+AInc] = ((value & 0x00ff0000) >> 16);
                    bufferOut[count+4+AInc] = ((value & 0x0000ff00) >> 8);
                    bufferOut[count+5+AInc] = value & 0x000000ff;
                    count+=(6+AInc);
                    ACount++;
                    AInc = 0;
                  }
                else 
                  {
                    printf("Fatal Error: unknown macrocommand %s\n",loc->string);
                    exit(1);
                  }
                
                if (loc->next)
                  if (loc->next->string[0] != loc->string[0])
                    bufferOut[ASave] = ACount;
              }
              break;
              
            case 'T'  :
              {
                char type[255],name[255];
                unsigned int value,id,row,col;
                
                sscanf(loc->string,"%s %s %d %d %d\n",type,name,&row,&col,&value);
                
                if (VFirst)                      // write 0 if V is not present
                  {

                    bufferOut[count] = 0;
                    count++;
                    VFirst = 0;
                  }
                
                if (AFirst)                      // write 0 if V is not present
                  {
                    bufferOut[count] = 0;
                    count++;
                    AFirst = 0;
                  }
                
                if (TFirst)
                  {
                    TSave = count;   // the place for the command number 
                    TFirst = FALSE;
                    TInc = 1;
                  }
                
                if ((id = scanList4ID(name)) != -1)
                  {
                    bufferOut[count+TInc] = id;
                    bufferOut[count+1+TInc] = row;
                    bufferOut[count+2+TInc] = col;
                    bufferOut[count+3+TInc] = ((value & 0xff000000) >> 24);
                    bufferOut[count+4+TInc] = ((value & 0x00ff0000) >> 16);
                    bufferOut[count+5+TInc] = ((value & 0x0000ff00) >> 8);
                    bufferOut[count+6+TInc] = value & 0x000000ff;
                    
                    count+=(7+TInc);
                    TCount++;
                    TInc = 0;
                  }
                else 
                  {
                    printf("Fatal Error: unknown macrocommand %s\n",loc->string);
                    exit(1);
                  }
                
                if (loc->next)
                  if (loc->next->string[0] != loc->string[0])
                    bufferOut[TSave] = TCount;
              }
              break; 
            case 0    : 
              {
                int c;
                
                if (VFirst)                      // write 0 if V is not present
                  {
                    bufferOut[count] = 0;
                    count++;
                  }
                
                if (AFirst)                      // write 0 if V is not present
                  {
                    bufferOut[count] = 0;
                    count++;
                  }
                
                if (TFirst)                      // write 0 if V is not present
                  {
                    bufferOut[count] = 0;
                    count++;
                  }
                
                c = count;
                
                while ((count % 4) != 0)
                  count++;
                
                memset(&bufferOut[c],0,count-c);
                
                bufferOut[2] = (((count-4)/4) & 0x0100) >> 8;
                bufferOut[3] = ((count-4)/4) & 0x00ff;      
                
                if (!write2File(fileName,count))
                  {
                    printf("Error writing on file %s\n",fileName);
                    exit(1);
                  }
                
                count = 0;
                VCount = 0; VFirst = TRUE;
                ACount = 0; AFirst = TRUE;
                TCount = 0; TFirst = TRUE;
              }
              break;
              
            default  : 
              printf("Fatal Error : variable identifier not known !\n");
              exit(1);
            }
          break;

        case TESTDEBUG:
          {
            unsigned int value;

            if (loc->string[0])
              {
                sscanf(loc->string,"%d\n",&value);
                                
                bufferOut[count] = ((value & 0xff00) >> 8);
                bufferOut[count+1] = value & 0x00ff;
                count+=2;
              }
            else
              {
                bufferOut[2] = 0;
                bufferOut[3] = 1;
                
                if (!write2File(fileName,count))
                  {
                    printf("Error writing on file %s\n",fileName);
                    exit(1);
                  }
                
                count = 0;
              }
            
          }
          break;
        }
      
      loc = loc->next;
      
    }
}

int returnID(char *key)
{
  int i;

  for (i=0; i < MAXMODE; i++)
    {
      if (strncmp(key,subCommandMode[i].str,strlen(subCommandMode[i].str)) == 0)
          return subCommandMode[i].code; 
    }
  return(-1);
}

int scanList4ID(char *name)
{
  listItem *loc;

  loc = beginList;
  
  while (loc != NULL)
    {
      if (strncmp(name,loc->string,strlen(loc->string)) == 0)
        return loc->id;
      loc = loc->next;
    }
  return(-1);
}


int write2File(char *filename,int count)
{
  FILE *out;
  int ret = TRUE;
  int i = 0,c;
  char binname[255];
  unsigned short data;

  c = count;

  if ((out = fopen(filename,"w")) != NULL)
    {
      count = count / 2;
      
      while (count--)
        {
          fprintf(out,"0x%02x%02x\n",bufferOut[i],bufferOut[i+1]);
          i+=2;
        }
      fclose(out);
    }
  else 
    ret = FALSE;
  
  
  strcpy(binname,filename);
  strcat(binname,".bin");
  
  if ((out = fopen(binname,"w")) != NULL)
    {
      c = c / 2; i = 0;
      
      while (c--)
        {
          data = *(unsigned short*)&bufferOut[i];
          fputc((unsigned char)((data & 0xff00) >>  8),out);
          fputc((unsigned char)((data & 0x00ff)),out);
          i+=2;
        }
      
      fclose(out);
    }
  else 
    ret = FALSE;
  
  return(ret);
}

void printList(listItem *first)
{
  listItem *loc;
  
  loc = first;

  while (loc != NULL)
    {
      printf("%s %d\n",loc->string,loc->id);
      loc = loc->next;
    }
}
int main (int argc,char *argv[])
{
  if (argc > 1)
    {
      loadList(FLISTNAME,&beginList,FALSE);
      loadList(argv[1],&beginCommand,TRUE);

      printf("Processing file %s\n\n",argv[1]);
      
      parseCommand();
    }
  else
    printf("\nMissing filename !!\n");
  return 0;
}


1	kusanagi	1.1	/* Note for input file format:
2
3			should declare first V,then A, then T all grouped by type
4
5			*/
6			#include <stdio.h>
7			#include <stdlib.h>
8
9			#define FLISTNAME "PRH_ParamHandler_INFN_auto.id"
10			#define TRUE 1
11			#define FALSE 0
12			#define MAXMODE 2
13
14			#define SETPARAMETERGEN 0x20
15			#define TESTDEBUG 0x43
16
17			struct list_el
18			{
19			struct list_el *next;
20			char string[255];
21			int id;
22			};
23
24			typedef struct
25			{
26			char str[255];
27			unsigned char code;
28			} sub_struct;
29
30			typedef struct list_el listItem;
31
32
33			listItem beginList,beginCommand=NULL;
34			unsigned char bufferOut[2048];
35			int subid;
36			sub_struct subCommandMode[MAXMODE]={{"SetParameterGen",SETPARAMETERGEN},{"TestDebug",TESTDEBUG}};
37
38
39			void convertHex2Dec(char *str)
40			{
41			char tmp[255]="";
42			char dec[10]="";
43			char p,s;
44			unsigned int value;
45
46			if ((p = strstr(str,"0x")) != NULL)
47			{
48			strncat(tmp,str,p-str);
49			sscanf(p+2,"%x",&value);
50			sprintf(dec,"%d",value);
51			strcat(tmp,dec);
52			memcpy(str,tmp,strlen(tmp));
53			str[strlen(tmp)]=0;
54			}
55			}
56
57			int loadList(char * filename,listItem **first,int command)
58			{
59			FILE *fileList;
60			char *s;
61			char tmp[255],tmp_1[255];
62
63			int ret = TRUE;
64
65			listItem loc=NULL,cur;
66
67			if ((fileList = fopen(filename,"r")) != NULL)
68			{
69			while (fgets(tmp,254,fileList) != NULL )
70			{
71			cur = (listItem*)malloc(sizeof(listItem));
72
73			if (loc == NULL)
74			{
75			*first = cur; loc = cur;
76			cur->next = NULL;
77			}
78			else
79			{
80			loc->next = cur;
81			loc = cur;
82			cur->next = NULL;
83			}
84
85			if (command == TRUE)
86			{
87			strncpy(cur->string,tmp,strlen(tmp)-1);
88			}
89			else
90			{
91			sscanf(tmp,"%s %d\n",tmp_1,&ret);
92			strncpy(cur->string,tmp_1,strlen(tmp_1));
93			}
94			cur->id = ret;
95			}
96			ret = TRUE;
97			fclose(fileList);
98			}
99			else
100			{
101			printf("Cannot open file %s!!!\n",FLISTNAME);
102			ret = FALSE;
103			}
104
105			return(ret);
106			}
107
108			void parseCommand()
109			{
110			listItem *loc;
111			char fileName[255];
112			int count = 0;
113			int VCount = 0,VFirst = TRUE,VSave,VInc;
114			int ACount = 0,AFirst = TRUE,ASave,AInc;
115			int TCount = 0,TFirst = TRUE,TSave,TInc;
116
117			loc = beginCommand;
118			memset(bufferOut,0,2048);
119
120			while (loc != NULL)
121			{
122			if (count == 0)
123			{
124			if ((loc->string[0] == 0x0a) \|\| (loc->string[0] == 0x0))
125			{
126			printf("Finished !");
127			exit(0);
128			}
129
130			strncpy(fileName,loc->string,strlen(loc->string)+1);
131			loc = loc->next;
132			count++;
133
134			if (strcmp(loc->string,""))
135			printf("Processing file: %s\n",fileName);
136
137			continue;
138			}
139
140			if (count == 1)
141			{
142			if ((subid = returnID(loc->string)) != -1)
143			{
144			bufferOut[0] = 0;
145			bufferOut[1] = subid;
146			loc = loc->next;
147			count+=3;
148			continue;
149			}
150			else
151			{
152			printf("Fatal Error: unknown subcommand %s\n",loc->string);
153			exit(1);
154			}
155			}
156
157			if (strcmp(loc->string,""))
158			printf("Processing: %s \n",loc->string);
159
160			convertHex2Dec(loc->string);
161
162			switch (subid) // last subid
163			{
164			case SETPARAMETERGEN :
165
166			switch (loc->string[0])
167			{
168			case 'V' :
169			{
170			char type[255],name[255];
171			unsigned int value,id;
172
173			sscanf(loc->string,"%s %s %d\n",type,name,&value);
174
175			if (VFirst)
176			{
177			VSave = count; // the place for the command number
178			VFirst = FALSE;
179			VInc = 1; // do not consider N after first time
180			}
181
182			if ((id = scanList4ID(name)) != -1)
183			{
184			bufferOut[count+VInc] = id;
185			bufferOut[count+1+VInc] = ((value & 0xff000000) >> 24);
186			bufferOut[count+2+VInc] = ((value & 0x00ff0000) >> 16);
187			bufferOut[count+3+VInc] = ((value & 0x0000ff00) >> 8);
188			bufferOut[count+4+VInc] = value & 0x000000ff;
189
190			count+=(5+VInc);
191			VCount++;
192			VInc = 0;
193			}
194			else
195			{
196			printf("Fatal Error: unknown macrocommand %s\n",loc->string);
197			exit(1);
198			}
199
200			if (loc->next)
201			if (loc->next->string[0] != loc->string[0])
202			bufferOut[VSave] = VCount;
203			}
204			break;
205
206			case 'A' :
207			{
208			char type[255],name[255];
209			unsigned int value,id,index;
210
211			if (VFirst) // write 0 if V is not present
212			{
213			bufferOut[count] = 0;
214			count++;
215			VFirst = 0;
216			}
217
218			sscanf(loc->string,"%s %s %d %d\n",type,name,&index,&value);
219
220			if (AFirst)
221			{
222			ASave = count; // the place for the command number
223			AFirst = FALSE;
224			AInc = 1;
225			}
226
227			if ((id = scanList4ID(name)) != -1)
228			{
229			bufferOut[count+AInc] = id;
230			bufferOut[count+1+AInc] = index;
231			bufferOut[count+2+AInc] = ((value & 0xff000000) >> 24);
232			bufferOut[count+3+AInc] = ((value & 0x00ff0000) >> 16);
233			bufferOut[count+4+AInc] = ((value & 0x0000ff00) >> 8);
234			bufferOut[count+5+AInc] = value & 0x000000ff;
235			count+=(6+AInc);
236			ACount++;
237			AInc = 0;
238			}
239			else
240			{
241			printf("Fatal Error: unknown macrocommand %s\n",loc->string);
242			exit(1);
243			}
244
245			if (loc->next)
246			if (loc->next->string[0] != loc->string[0])
247			bufferOut[ASave] = ACount;
248			}
249			break;
250
251			case 'T' :
252			{
253			char type[255],name[255];
254			unsigned int value,id,row,col;
255
256			sscanf(loc->string,"%s %s %d %d %d\n",type,name,&row,&col,&value);
257
258			if (VFirst) // write 0 if V is not present
259			{
260
261			bufferOut[count] = 0;
262			count++;
263			VFirst = 0;
264			}
265
266			if (AFirst) // write 0 if V is not present
267			{
268			bufferOut[count] = 0;
269			count++;
270			AFirst = 0;
271			}
272
273			if (TFirst)
274			{
275			TSave = count; // the place for the command number
276			TFirst = FALSE;
277			TInc = 1;
278			}
279
280			if ((id = scanList4ID(name)) != -1)
281			{
282			bufferOut[count+TInc] = id;
283			bufferOut[count+1+TInc] = row;
284			bufferOut[count+2+TInc] = col;
285			bufferOut[count+3+TInc] = ((value & 0xff000000) >> 24);
286			bufferOut[count+4+TInc] = ((value & 0x00ff0000) >> 16);
287			bufferOut[count+5+TInc] = ((value & 0x0000ff00) >> 8);
288			bufferOut[count+6+TInc] = value & 0x000000ff;
289
290			count+=(7+TInc);
291			TCount++;
292			TInc = 0;
293			}
294			else
295			{
296			printf("Fatal Error: unknown macrocommand %s\n",loc->string);
297			exit(1);
298			}
299
300			if (loc->next)
301			if (loc->next->string[0] != loc->string[0])
302			bufferOut[TSave] = TCount;
303			}
304			break;
305			case 0 :
306			{
307			int c;
308
309			if (VFirst) // write 0 if V is not present
310			{
311			bufferOut[count] = 0;
312			count++;
313			}
314
315			if (AFirst) // write 0 if V is not present
316			{
317			bufferOut[count] = 0;
318			count++;
319			}
320
321			if (TFirst) // write 0 if V is not present
322			{
323			bufferOut[count] = 0;
324			count++;
325			}
326
327			c = count;
328
329			while ((count % 4) != 0)
330			count++;
331
332			memset(&bufferOut[c],0,count-c);
333
334			bufferOut[2] = (((count-4)/4) & 0x0100) >> 8;
335			bufferOut[3] = ((count-4)/4) & 0x00ff;
336
337			if (!write2File(fileName,count))
338			{
339			printf("Error writing on file %s\n",fileName);
340			exit(1);
341			}
342
343			count = 0;
344			VCount = 0; VFirst = TRUE;
345			ACount = 0; AFirst = TRUE;
346			TCount = 0; TFirst = TRUE;
347			}
348			break;
349
350			default :
351			printf("Fatal Error : variable identifier not known !\n");
352			exit(1);
353			}
354			break;
355
356			case TESTDEBUG:
357			{
358			unsigned int value;
359
360			if (loc->string[0])
361			{
362			sscanf(loc->string,"%d\n",&value);
363
364			bufferOut[count] = ((value & 0xff00) >> 8);
365			bufferOut[count+1] = value & 0x00ff;
366			count+=2;
367			}
368			else
369			{
370			bufferOut[2] = 0;
371			bufferOut[3] = 1;
372
373			if (!write2File(fileName,count))
374			{
375			printf("Error writing on file %s\n",fileName);
376			exit(1);
377			}
378
379			count = 0;
380			}
381
382			}
383			break;
384			}
385
386			loc = loc->next;
387
388			}
389			}
390
391			int returnID(char *key)
392			{
393			int i;
394
395			for (i=0; i < MAXMODE; i++)
396			{
397			if (strncmp(key,subCommandMode[i].str,strlen(subCommandMode[i].str)) == 0)
398			return subCommandMode[i].code;
399			}
400			return(-1);
401			}
402
403			int scanList4ID(char *name)
404			{
405			listItem *loc;
406
407			loc = beginList;
408
409			while (loc != NULL)
410			{
411			if (strncmp(name,loc->string,strlen(loc->string)) == 0)
412			return loc->id;
413			loc = loc->next;
414			}
415			return(-1);
416			}
417
418
419			int write2File(char *filename,int count)
420			{
421			FILE *out;
422			int ret = TRUE;
423			int i = 0,c;
424			char binname[255];
425			unsigned short data;
426
427			c = count;
428
429			if ((out = fopen(filename,"w")) != NULL)
430			{
431			count = count / 2;
432
433			while (count--)
434			{
435			fprintf(out,"0x%02x%02x\n",bufferOut[i],bufferOut[i+1]);
436			i+=2;
437			}
438			fclose(out);
439			}
440			else
441			ret = FALSE;
442
443
444			strcpy(binname,filename);
445			strcat(binname,".bin");
446
447			if ((out = fopen(binname,"w")) != NULL)
448			{
449			c = c / 2; i = 0;
450
451			while (c--)
452			{
453			data = (unsigned short)&bufferOut[i];
454			fputc((unsigned char)((data & 0xff00) >> 8),out);
455			fputc((unsigned char)((data & 0x00ff)),out);
456			i+=2;
457			}
458
459			fclose(out);
460			}
461			else
462			ret = FALSE;
463
464			return(ret);
465			}
466
467			void printList(listItem *first)
468			{
469			listItem *loc;
470
471			loc = first;
472
473			while (loc != NULL)
474			{
475			printf("%s %d\n",loc->string,loc->id);
476			loc = loc->next;
477			}
478			}
479			int main (int argc,char *argv[])
480			{
481			if (argc > 1)
482			{
483			loadList(FLISTNAME,&beginList,FALSE);
484			loadList(argv[1],&beginCommand,TRUE);
485
486			printf("Processing file %s\n\n",argv[1]);
487
488			parseCommand();
489			}
490			else
491			printf("\nMissing filename !!\n");
492			return 0;
493			}
494
495