projects / tas-yagle.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Initial version of donated sources by Avertec, 3.4p5.
[tas-yagle.git] / distrib / sources / mbk / mbk_fileextract.c
1 /****************************************************************************/
2 /* */
3 /* Chaine de CAO & VLSI AVERTEC */
4 /* */
5 /* Produit : AVERTEC global tools */
6 /* Fichier : mbk_fileextract.c */
7 /* */
8 /* © copyright 2000 AVERTEC */
9 /* Tous droits reserves */
10 /* */
11 /* Auteur(s) : Antony PINTO */
12 /* */
13 /****************************************************************************/
14
15 #include <stdlib.h>
16 #include "mbk_fileextract.h"
17
18 static int mfe_error();
19
20 static void newlabel(label_table **table);
21 static void freelabel(label_table *label, int nbmc);
22 static void newrule(extract_rules **ruleslist);
23 static void freerule(extract_rules *rule);
24 static void allocref(label_ref **ref);
25 static int affectlabel(label_ref *ref, char *label, double value, int match, int nbmc);
26 static void duplabel(label_ref **new, label_table *tbl);
27 static void freeref(label_ref **ref);
28 static int decodeline(char *buf, extract_rules *rules, label_ref *ref, int usemc);
29
30 static int __getline(FILE *fd, char *buf);
31 static int istoken(char *buf, char *token, int *offset);
32 static int isvalue(char *buf, double *value, int *offset);
33 static int istext(char *buf, char text[], int *offset);
34 static int matchline(char *head, extract_rules *rule, label_ref *ref, int usemc);
35 static int matchtoken(char *head, char *token, int *offset, char *label, double *value, char *isval);
36 static int matchtableline(char *head, extract_rules *rule);
37
38 static int domatchvarval(label_ref *ref, extract_rules *rule);
39
40 static int MFE_DEBUG_MODE = 0;
41
42 #define GO2ERR(x) do { ret = (x); goto endfunc; } while(0)
43
44 #if 0
45 /*{{{ */
46 /*{{{ Memory tracing */
47 /****************************************************************************/
48 /*{{{ */
49 static void *alloc[2048][2];
50 static int nballoc;
51
52 void initmemory()
53 {
54 nballoc = 0;
55 memset(alloc,0,2048 * 2 * sizeof(void *));
56 }
57
58 void print_alloue()
59 {
60 int i;
61 long res = 0;
62
63 printf("There is %d blocs allocated\n",nballoc);
64 for (i = 0; i < 2048; i ++)
65 if (alloc[i][0])
66 res += (long) alloc[i][1];
67 printf("It makes %ld bytes\n",res);
68 }
69
70 int closememory()
71 {
72 if (nballoc != 0)
73 {
74 printf("All memory allocated hasn't been freed\n");
75 print_alloue();
76 }
77 return nballoc;
78 }
79
80 void *alloue(int size)
81 {
82 void *res;
83 int i;
84
85 if (nballoc > 2048)
86 {
87 printf("error\n");
88 exit(1);
89 }
90 res = mbkalloc(size);
91 for (i = 0; i < 2048; i ++)
92 if (!alloc[i][0])
93 {
94 alloc[i][0] = res;
95 alloc[i][1] = (void *)size;
96 break;
97 }
98 nballoc ++;
99
100 return res;
101 }
102
103 void desalloue(void *ptr)
104 {
105 int i;
106
107 for (i = 0; i < 2048; i ++)
108 if (alloc[i][0] == ptr)
109 {
110 mbkfree(alloc[i][0]);
111 alloc[i][0] = NULL;
112 alloc[i][1] = NULL;
113 break;
114 }
115 nballoc --;
116 }
117
118 char *copystr(char *str)
119 {
120 void *res;
121 int i;
122
123 if (nballoc > 2048)
124 {
125 printf("error\n");
126 exit(1);
127 }
128 res = mbkstrdup(str);
129 for (i = 0; i < 2048; i ++)
130 if (!alloc[i][0])
131 {
132 alloc[i][0] = res;
133 alloc[i][1] = (void *)strlen(str);
134 break;
135 }
136 nballoc ++;
137
138 return res;
139 }
140
141 /*}}}************************************************************************/
142 /*}}}************************************************************************/
143
144 static void print_error(FILE *fd, int code);
145 static void print_rule(extract_rules *rule);
146 static void ruletostr(char *buf, extract_rules *rule);
147
148 /*{{{ tests functions */
149 /*{{{ print_error() */
150 /* */
151 /* */
152 /****************************************************************************/
153 static void print_error(FILE *fd, int code)
154 {
155 fprintf(fd,"[RUL_ERR] ");
156 switch (code)
157 {
158 case RULE_TYPE_ERR :
159 fprintf(fd,"unknow type\n");
160 break;
161 case RULE_BEGE_ERR :
162 fprintf(fd,"unable to decode begin and end\n");
163 break;
164 case RULE_TOOT_ERR :
165 fprintf(fd,"too much token (superior to 1024)\n");
166 break;
167 case RULE_RULE_ERR :
168 fprintf(fd,"rule problem\n");
169 break;
170 }
171 }
172
173 /*}}}************************************************************************/
174 /*{{{ print_rule() */
175 /* */
176 /* */
177 /****************************************************************************/
178 static void print_rule(extract_rules *rule)
179 {
180 int i;
181
182 if (rule->TYPE == RULE_TYPE_LINE)
183 printf("type : line\n");
184 else if (rule->TYPE == RULE_TYPE_TABLE)
185 printf("type : table\n");
186 // printf("begin : %s\n",(rule->BEGIN) ? rule->BEGIN : "NULL");
187 // printf("end : %s\n",(rule->END) ? rule->END : "NULL");
188 printf("begin : %s\n",rule->BEGIN);
189 printf("end : %s\n",rule->END);
190 printf("nbtoken : %d\n",rule->NBTOKEN);
191 for (i = 0; i < rule->NBTOKEN; i ++)
192 printf("token %3d : %s\n",i,rule->TOKEN[i]);
193 printf("next : %p\n",rule->NEXT);
194 }
195
196 /*}}}************************************************************************/
197 /*{{{ */
198 /* */
199 /* */
200 /****************************************************************************/
201 static int testrule(int trace)
202 {
203 extract_rules *rules_list = NULL, *rx, *tmp;
204 int res, i, nberr;
205 char *ruletab[] =
206 {
207 "line:/begin/end0/:# %r %t %y %u %f",
208 "line://end1/:& %r %t %y %u %f" ,
209 "line:/beginend2/:* %r %t %y %u %f" ,
210 "line:begin/end3/:^%r %t %y %u %f" ,
211 "line:/begin/end4:u %r %t %y %u %f" ,
212 "table:/begin/end5/: okri %v kflk %t" ,
213 "array:/begin/end6/:%r %t %y %u %f"
214 };
215 int restab[] =
216 {
217 0 , RULE_TYPE_LINE , 1, 1 , 6,
218 0 , RULE_TYPE_LINE , 1, 1 , 6,
219 RULE_BEGE_ERR , 0 , 0, 0 , 0,
220 RULE_BEGE_ERR , 0 , 0, 0 , 0,
221 RULE_BEGE_ERR , 0 , 0, 0 , 0,
222 0 , RULE_TYPE_TABLE , 1, 1 , 3,
223 RULE_TYPE_ERR , 0 , 0, 0 , 0,
224 };
225
226 initmemory();
227 nberr = 0;
228
229 if (trace) printf("-**** %s readrules ****-\n",__func__);
230 for (i = 0; i < (int)(sizeof(ruletab) / sizeof(char *)); i ++)
231 {
232 if (trace) printf("-**************-\n");
233 if (trace) printf(" %d, %s\n",i,ruletab[i]);
234 if (trace) printf("-**************-\n");
235 if ((res = mfe_addrule(&rules_list,ruletab[i])))
236 {
237 if (trace) print_error(stderr,res);
238 }
239 else
240 {
241 if (trace) print_rule(rules_list);
242 }
243 if (!i)
244 tmp = rules_list;
245 if (res != restab[i*5]) nberr ++;
246 if (!res)
247 {
248 if (rules_list->TYPE != restab[i*5 + 1]) nberr ++;
249 if (rules_list->BEGIN && !restab[i*5 + 2]) nberr ++;
250 if (!rules_list->BEGIN && restab[i*5 + 2]) nberr ++;
251 if (rules_list->END && !restab[i*5 + 3]) nberr ++;
252 if (!rules_list->END && restab[i*5 + 3]) nberr ++;
253 if (rules_list->NBTOKEN != restab[i*5 + 4]) nberr ++;
254 }
255 }
256 mfe_delrule(&rules_list,tmp);
257 if (trace) printf("-**** %s del ****-\n",__func__);
258 for (rx = rules_list; rx; rx = rx->NEXT)
259 {
260 if (trace) print_rule(rx);
261 }
262 mfe_freerules(&rules_list);
263
264 if (trace) printf("-**** %s free ****-\n",__func__);
265 if (closememory()) nberr ++;
266
267 if (nberr) printf("%s %d errors\n",__func__,nberr);
268
269 return nberr;
270 }
271
272 /*}}}************************************************************************/
273 /*{{{ */
274 /* */
275 /* */
276 /****************************************************************************/
277 static int testlabels(int trace)
278 {
279 char *labtab[] =
280 {
281 "sig1",
282 "sig2",
283 "sig3",
284 "sig4",
285 "sig5",
286 "sig6",
287 "sig7",
288 "sig8",
289 "sig9"
290 };
291 int i;
292
293 return 0;
294 }
295
296 /*}}}************************************************************************/
297 /*{{{ */
298 /* */
299 /* */
300 /****************************************************************************/
301 static int testisvalue(int trace)
302 {
303 double res1[] = {
304 0.0e0,
305 1.5e10,
306 -6.5e-1,
307 -1855.59,
308 582563258
309 }, value;
310 char *test1[] = {
311 "0.0e0",
312 "1.5e10",
313 "-6.5e-1",
314 "-1855.59",
315 "582563258"
316 }, buf[2048];
317 unsigned int i;
318 int nberr = 0, offset, set;
319
320 if (trace) printf("-**** %s 1 ****-\n",__func__);
321 for (i = 0; i < sizeof(res1)/sizeof(double); i ++)
322 {
323 offset = 0;
324 if (isvalue(test1[i],&value,&offset))
325 {
326 if (trace) printf(" tested : %s\n",test1[i]);
327 if (trace) printf(" error code\n");
328 nberr++;
329 }
330 if (value != res1[i])
331 {
332 if (trace) printf(" tested : %s\n",test1[i]);
333 if (trace) printf(" obtained : %g\n",value);
334 nberr++;
335 }
336 if (offset != (int)(5+i))
337 {
338 if (trace) printf(" tested : %s\n",test1[i]);
339 if (trace) printf(" offset : %d\n",offset);
340 nberr++;
341 }
342 }
343
344 if (trace) printf("-**** %s 2 ****-\n",__func__);
345 buf[0] = '\0';
346 for (i = 0; i < sizeof(res1)/sizeof(double); i ++)
347 {
348 strcat(buf,test1[i]);
349 strcat(buf," ");
350 }
351
352 offset = 0;
353 set = 0;
354 for (i = 0; i < sizeof(res1)/sizeof(double); i ++)
355 {
356 set += 5 + i;
357 if (isvalue(buf,&value,&offset))
358 {
359 if (trace) printf(" tested : %s\n",test1[i]);
360 if (trace) printf(" error code\n");
361 nberr++;
362 }
363 if (value != res1[i])
364 {
365 if (trace) printf(" tested : %s\n",test1[i]);
366 if (trace) printf(" obtained : %g\n",value);
367 nberr++;
368 }
369 if (offset != set)
370 {
371 if (trace) printf(" tested : %s\n",test1[i]);
372 if (trace) printf(" offset : %d\n",offset);
373 nberr++;
374 }
375 set ++;
376 }
377
378 if (nberr) printf("%s %d errors\n",__func__,nberr);
379
380 return nberr;
381 }
382
383 /*}}}************************************************************************/
384 /*{{{ */
385 /* */
386 /* */
387 /****************************************************************************/
388 static int testistoken(int trace)
389 {
390 int nberr = 0, offset;
391
392 if (trace) printf("-**** %s ****-\n",__func__);
393 offset = 0;
394 if (istoken("test du token","test",&offset)) nberr++;
395 if (istoken("test du token","du",&offset)) nberr++;
396 if (istoken("test du token","token",&offset)) nberr++;
397
398 if (nberr) printf("%s %d errors\n",__func__,nberr);
399
400 return nberr;
401 }
402
403 /*}}}************************************************************************/
404 /*{{{ */
405 /* */
406 /* */
407 /****************************************************************************/
408 static int testistext(int trace)
409 {
410 char *test1[] = {
411 "test15",
412 "89test2",
413 "test4+_4"
414 }, buf[2048], test2[2048];
415 int res[] = {
416 1,
417 0,
418 1
419 };
420 unsigned int i;
421 int nberr = 0, offset, set;
422
423 if (trace) printf("-**** %s 1 ****-\n",__func__);
424 for (i = 0; i < sizeof(res)/sizeof(double); i ++)
425 {
426 offset = 0;
427 if (istext(test1[i],buf,&offset) && res[i])
428 {
429 if (trace) printf(" tested : %s\n",test1[i]);
430 if (trace) printf(" error code\n");
431 nberr++;
432 }
433 if (strcmp(test1[i],buf))
434 {
435 if (trace) printf(" tested : %s\n",test1[i]);
436 if (trace) printf(" obtained : %s\n",buf);
437 nberr++;
438 }
439 if (offset != (int)(6+i))
440 {
441 if (trace) printf(" tested : %s\n",test1[i]);
442 if (trace) printf(" offset : %d\n",offset);
443 nberr++;
444 }
445 }
446
447 if (trace) printf("-**** %s 2 ****-\n",__func__);
448 test2[0] = '\0';
449 for (i = 0; i < sizeof(res)/sizeof(double); i ++)
450 {
451 strcat(test2,test1[i]);
452 strcat(test2," ");
453 }
454
455 offset = 0;
456 set = 0;
457 for (i = 0; i < sizeof(res)/sizeof(double); i ++)
458 {
459 set += 6 + i;
460 if (istext(test2,buf,&offset) && res[i])
461 {
462 if (trace) printf(" tested : %s\n",test1[i]);
463 if (trace) printf(" error code\n");
464 nberr++;
465 }
466 if (strcmp(buf,test1[i]))
467 {
468 if (trace) printf(" tested : %s\n",test1[i]);
469 if (trace) printf(" obtained : %s\n",buf);
470 nberr++;
471 }
472 if (offset != set)
473 {
474 if (trace) printf(" tested : %s\n",test1[i]);
475 if (trace) printf(" offset : %d\n",offset);
476 nberr++;
477 }
478 set ++;
479 }
480
481 if (nberr) printf("%s %d errors\n",__func__,nberr);
482
483 return nberr;
484 }
485
486 /*}}}************************************************************************/
487 /*{{{ */
488 /* */
489 /* */
490 /****************************************************************************/
491 static void filetitan(FILE * fd)
492 {
493 fprintf(fd,
494 "Measure results from Transient analysis:\n"
495 " ==============================================================================\n"
496 "\n"
497 " --- Nominal Run, Temperature = -30.000 (Deg C)\n"
498 "\n"
499 " Measure Statement | Result | Trigger Point | Target Point\n"
500 " ------------------------------------------------------------------------------\n"
501 " D_RISE | 2.24824269E-09 | 9.50000000E-10 | 3.19824269E-09\n"
502 " D_FALL | 2.37524146E-09 | 1.95000000E-09 | 4.32524146E-09\n");
503 }
504
505 /*}}}************************************************************************/
506 /*{{{ */
507 /* */
508 /* */
509 /****************************************************************************/
510 static void filehsp(FILE * fd)
511 {
512 fprintf(fd,
513 "$DATA1 SOURCE='HSPICE' VERSION='2002.2' \n"
514 ".TITLE ' '\n"
515 " d_rise d_fall temper alter# \n"
516 " 5.369e-09 5.669e-09 110.0000 1.0000\n"
517 );
518 }
519
520 /*}}}************************************************************************/
521 /*{{{ filehsp2() */
522 /* */
523 /* */
524 /****************************************************************************/
525 static void filehsp2(FILE * fd)
526 {
527 fprintf(fd,
528 "$DATA1 SOURCE='HSPICE' VERSION='U-2003.03'\n"
529 ".TITLE '*e'\n"
530 "sim_slope_sig129 sim_delay_sig131___sig129 sim_slope_sig131\n"
531 "sim_delay_sig218___sig131 sim_slope_sig218 sim_delay_sig147___sig218\n"
532 "sim_slope_sig147 sim_delay_sig216___sig147 sim_slope_sig216\n"
533 "sim_delay_sig151___sig216 sim_slope_sig151 sim_delay_sig214___sig151 \n"
534 "sim_slope_sig214 sim_delay_sig159___sig214 sim_slope_sig159 \n"
535 "sim_delay_tran18_grid___sig159 sim_slope_tran7_drain \n"
536 "sim_delay_tran7_drain___tran18_grid sim_slope_tran18_grid \n"
537 "sim_delay_tran7_grid___tran7_drain sim_slope_tran15_source \n"
538 "sim_delay_tran15_source___tran7_grid sim_slope_tran7_grid \n"
539 "sim_delay_sig196___tran15_source sim_slope_sig196 sim_delay_sig202___sig196\n"
540 "sim_slope_sig202 sim_delay_sig203___sig202 sim_delay_sig203___sig131 temper\n"
541 "alter#\n"
542 "5.208e-09 -1.923e-10 1.311e-08 1.070e-08 5.642e-10 3.349e-10 2.148e-09\n"
543 "1.496e-09 5.225e-10 3.084e-10 2.141e-09 1.716e-09 5.709e-10 3.261e-10\n"
544 "2.201e-09 1.793e-09 1.306e-09 6.667e-13 1.306e-09 5.070e-10 4.767e-09\n"
545 "1.853e-12 4.768e-09 3.402e-09 9.945e-10 5.941e-10 3.596e-10 3.751e-10\n"
546 "2.156e-08 125.0000 1.0000\n"
547 );
548 }
549
550 /*}}}************************************************************************/
551 /*{{{ testfile() */
552 /* */
553 /* */
554 /****************************************************************************/
555 static int testfile(int trace)
556 {
557 double value;
558 int nberr, j, i;
559 char *rule[] = {
560 "line:/EXTRACT INFORMATION/1****/:* %l = %v targ= %0 trig= %0",
561 "line:///:%l | %v | %0 | %0",
562 "table:/.TITLE ' '//:%l %v"
563 };
564 char *filename[] = {
565 "main.eldo.chi",
566 "sim_save_titan.tr.measure",
567 "main.hsp.mt0"
568 };
569 char *label[2] = {
570 "d_rise" , "d_fall"
571 };
572 double res[][2] = {
573 { 5.3665e-09 , 5.6704e-09 },
574 { 2.24824269E-09 , 2.37524146E-09 },
575 { 5.369e-9 , 5.669e-09 }
576 };
577 int nblabel = (int)(sizeof(label)/sizeof(char*));
578 int nbtest = (int)(sizeof(rule)/sizeof(char*));
579 extract_rules *rules = NULL;
580 label_ref *labels = NULL;
581
582 nberr = 0;
583 initmemory();
584
585 for (i = 0; i < nbtest; i ++)
586 {
587 if (trace) printf("-**** %s %s ****-\n",__func__,filename[i]);
588
589 mfe_addrule(&rules,rule[i]);
590
591 for (j = 0; j < nblabel; j ++)
592 mfe_addlabel(&labels,label[j],0);
593
594 mfe_fileextractlabel(filename[i],rules,labels,0);
595
596 for (j = 0; j < nblabel; j ++)
597 if (!mfe_labelvalue(labels,label[j],&value,-1))
598 {
599 if (trace) printf(" %s = %g\n",label[j],value);
600 if (value - res[i][j] > 1e-12 || value - res[i][j] < -1e-12) nberr++;
601 }
602 else
603 nberr ++;
604
605
606 mfe_freelabels(&labels);
607 mfe_freerules(&rules);
608
609 }
610 if (closememory()) nberr ++;
611
612 if (nberr) printf("%s %d errors\n",__func__,nberr);
613
614 return nberr;
615 }
616
617 /*}}}************************************************************************/
618 /*{{{ testfile2() */
619 /* */
620 /* */
621 /****************************************************************************/
622 static int testfile2(int trace)
623 {
624 double value;
625 int nberr, j;
626 char *rule = "table:/.TITLE '*e'//:%l %v";
627 char *filename = "main.hsp.mt01";
628 char *label[29] = {
629 "sim_slope_sig129", "sim_delay_sig131___sig129", "sim_slope_sig131",
630 "sim_delay_sig218___sig131", "sim_slope_sig218", "sim_delay_sig147___sig218",
631 "sim_slope_sig147", "sim_delay_sig216___sig147", "sim_slope_sig216",
632 "sim_delay_sig151___sig216", "sim_slope_sig151", "sim_delay_sig214___sig151",
633 "sim_slope_sig214", "sim_delay_sig159___sig214", "sim_slope_sig159",
634 "sim_delay_tran18_grid___sig159", "sim_slope_tran7_drain",
635 "sim_delay_tran7_drain___tran18_grid", "sim_slope_tran18_grid",
636 "sim_delay_tran7_grid___tran7_drain", "sim_slope_tran15_source",
637 "sim_delay_tran15_source___tran7_grid", "sim_slope_tran7_grid",
638 "sim_delay_sig196___tran15_source", "sim_slope_sig196", "sim_delay_sig202___sig196",
639 "sim_slope_sig202", "sim_delay_sig203___sig202", "sim_delay_sig203___sig131"
640 };
641 double res[29] = {
642 5.208e-09 , -1.923e-10 , 1.311e-08 , 1.070e-08 , 5.642e-10 , 3.349e-10 , 2.148e-09 ,
643 1.496e-09 , 5.225e-10 , 3.084e-10 , 2.141e-09 , 1.716e-09 , 5.709e-10 , 3.261e-10 ,
644 2.201e-09 , 1.793e-09 , 1.306e-09 , 6.667e-13 , 1.306e-09 , 5.070e-10 , 4.767e-09 ,
645 1.853e-12 , 4.768e-09 , 3.402e-09 , 9.945e-10 , 5.941e-10 , 3.596e-10 , 3.751e-10 ,
646 2.156e-08
647 };
648 int nblabel = (int)(sizeof(label)/sizeof(char*));
649 extract_rules *rules = NULL;
650 label_ref *labels = NULL;
651 FILE *tmpfile;
652
653 tmpfile = fopen(filename ,"w");
654 filehsp2(tmpfile);
655 fclose(tmpfile);
656
657 nberr = 0;
658 initmemory();
659
660 if (trace) printf("-**** %s %s ****-\n",__func__,filename);
661
662 mfe_addrule(&rules,rule);
663
664 for (j = 0; j < nblabel; j ++)
665 {
666 //if (trace) printf("-**** adding label %s in database\n",label[j]);
667 mfe_addlabel(&labels,label[j],0);
668 }
669
670 mfe_fileextractlabel(filename,rules,labels,0);
671
672 for (j = 0; j < nblabel; j ++)
673 if (!mfe_labelvalue(labels,label[j],&value,-1))
674 {
675 if (trace) printf(" %s = %g\n",label[j],value);
676 if (value - res[j] > 1e-12 || value - res[j] < -1e-12) nberr++;
677 }
678 else
679 nberr ++;
680
681
682 mfe_freelabels(&labels);
683 mfe_freerules(&rules);
684
685 if (closememory()) nberr ++;
686
687 if (nberr) printf("%s %d errors\n",__func__,nberr);
688
689 return nberr;
690 }
691
692 /*}}}************************************************************************/
693 /*{{{ */
694 /* */
695 /* */
696 /****************************************************************************/
697 static int testglobal(int trace)
698 {
699 double value;
700 FILE *tmpfile;
701 char buf[2][26];
702 int nberr, i, j;
703 extract_rules *rules = NULL;
704 char *type[] = {
705 "titan",
706 "hsp" };
707 void (*func[])(FILE*) = {
708 filetitan,
709 filehsp };
710 char *rule[] = {
711 "line:///:%l | %v | %0 | %0",
712 "table:/.TITLE ' '//:%l %v" };
713 label_ref *labels = NULL;
714 char *label[] = {
715 "d_rise",
716 "d_fall"
717 };
718 double res[][2] = {
719 { 2.24824269E-09 , 2.37524146E-09 },
720 { 5.369e-9 , 5.669e-09}
721 };
722
723 nberr = 0;
724 initmemory();
725
726 if (trace) printf("-**** %s ****-\n",__func__);
727
728 /* 1 - titan */
729 /* 2 - hsp */
730 for (i = 0; i < (int)(sizeof(buf)/(26*sizeof(char))); i ++)
731 {
732 sprintf(buf[i],"%stestfileXXXXXX",type[i]);
733 mktemp(buf[i]);
734 if (trace) printf("-**** %s generating testfile %s ****-\n",__func__,buf[i]);
735 tmpfile = fopen(buf[i],"w");
736 func[i](tmpfile);
737 fclose(tmpfile);
738 }
739
740 for (i = 0; i < 2; i ++)
741 {
742 if (trace) printf("-**** %s starting test %s ****-\n",__func__,buf[i]);
743 mfe_addrule(&rules,rule[i]);
744 for (j = 0; j < 2; j ++)
745 mfe_addlabel(&labels,label[j],0);
746
747 mfe_fileextractlabel(buf[i],rules,labels,0);
748
749 for (j = 0; j < 2; j ++)
750 if (!mfe_labelvalue(labels,label[j],&value,-1))
751 {
752 if (trace) printf(" %s = %g\n",label[j],value);
753 if (value - res[i][j] > 1e-19 || value - res[i][j] < -1e-19) nberr++;
754 }
755 else
756 nberr ++;
757
758
759 mfe_freelabels(&labels);
760 mfe_freerules(&rules);
761
762 // unlink(buf[i]);
763 }
764 if (closememory()) nberr ++;
765
766 if (nberr) printf("%s %d errors\n",__func__,nberr);
767
768 return nberr;
769 }
770
771 /*}}}************************************************************************/
772 /*{{{ */
773 /* */
774 /* */
775 /****************************************************************************/
776 static int testduplication(int trace)
777 {
778 extract_rules *rules = NULL, *duprules, *rx;
779 label_ref *ref = NULL, *dupref;
780 char *rule[] = {
781 "line:/EXTRACT INFORMATION/1****/:* %l = %v targ= %0 trig= %0",
782 "line:///:%l | %v | %0 | %0",
783 "table:/.TITLE ' '//:%l %v"
784 }, *label[] = {
785 "d_rise" , "d_fall", "test_2"
786 };
787 int nblabel = (int)(sizeof(label)/sizeof(char*));
788 int nbrule = (int)(sizeof(rule)/sizeof(char*));
789
790 int i, nberr = 0;
791 double value;
792 char buf[2048];
793
794 if (trace) printf("-**** %s ****-\n",__func__);
795
796 initmemory();
797
798 for (i = 0; i < nbrule; i++)
799 mfe_addrule(&rules,rule[i]);
800 for (i = 0; i < nblabel; i ++)
801 mfe_addlabel(&ref,label[i],0);
802
803 if (trace) printf("-**** %s affect ref ****-\n",__func__);
804 for (i = 0; i < nblabel; i ++)
805 {
806 if (affectlabel(ref,min_namealloc(label[i]),(double)i,LABL_FOUND,0)) nberr ++;
807 if (mfe_labelvalue(ref,min_namealloc(label[i]),&value,-1)) nberr ++;
808 if (trace) printf(" %s = %g\n",label[i],value);
809 }
810
811 if (trace) printf("-**** %s affiche rules ****-\n",__func__);
812 for (i = nbrule, rx = rules; i > 0; i --, rx = rx->NEXT)
813 {
814 ruletostr(buf,rx);
815 if (trace) printf(" %s\n",buf);
816 if (trace) printf(" %s\n",rule[i-1]);
817 if (strcmp(rule[i-1],buf)) nberr ++;
818 }
819
820 if (trace) printf("-**** %s duplication ****-\n",__func__);
821 mfe_duprules(&duprules,rules);
822 mfe_duplabels(&dupref,ref);
823
824 if (trace) printf("-**** %s free ****-\n",__func__);
825 mfe_freerules(&rules);
826 mfe_freelabels(&ref);
827
828 if (trace) printf("-**** %s affiche duprules ****-\n",__func__);
829 for (i = nbrule, rx = duprules; i > 0; i --, rx = rx->NEXT)
830 {
831 ruletostr(buf,rx);
832 if (trace) printf(" %s\n",buf);
833 if (trace) printf(" %s\n",rule[i-1]);
834 if (strcmp(rule[i-1],buf)) nberr ++;
835 }
836
837 for (i = 0; i < nblabel; i ++)
838 {
839 if (mfe_labelvalue(dupref,label[i],&value,-1) != LABL_NOTFOUND)
840 nberr ++;
841 if (trace) printf(" %s = %g\n",label[i],value);
842 }
843
844 mfe_freerules(&duprules);
845 mfe_freelabels(&dupref);
846
847 if (closememory()) nberr ++;
848 if (nberr) printf("%s %d errors\n",__func__,nberr);
849 return nberr;
850 }
851
852 /*}}}************************************************************************/
853 /*{{{ main() */
854 /* */
855 /* test function for mbk_fileextract */
856 /* */
857 /* />gcc -o main -L$AVT_DISTRIB_DIR/lib -Xlinker -z -Xlinker allextract \
858 -lMut325 -lstdc++ -lnsl -ldl -lm -Xlinker -z -Xlinker defaultextract */
859 /* />main */
860 /* */
861 /****************************************************************************/
862 int main(int argc, char *argv[])
863 {
864 int trace;
865 int nberr = 0;
866
867 mbkenv();
868
869 trace = (argc > 1);
870
871 nberr += testrule(trace);
872 nberr += testisvalue(trace);
873 nberr += testistoken(trace);
874 nberr += testistext(trace);
875 nberr += testglobal(trace);
876 nberr += testfile(trace);
877 nberr += testfile2(trace);
878 nberr += testduplication(trace);
879
880 if (nberr) printf("total : %d errors\n",nberr);
881 else printf("ok : %d error\n",nberr);
882
883 return 0;
884 }
885
886 /*}}}************************************************************************/
887 /*{{{ ruletostr() */
888 /* */
889 /* */
890 /****************************************************************************/
891 static void ruletostr(char *buf, extract_rules *rule)
892 {
893 int i;
894
895 buf[0] = '\0';
896
897 if (rule->TYPE == RULE_TYPE_LINE)
898 strcat(buf,"line:/");
899 else if (rule->TYPE == RULE_TYPE_TABLE)
900 strcat(buf,"table:/");
901
902 strcat(buf,rule->BEGIN);
903 strcat(buf,"/");
904 strcat(buf,rule->END);
905 strcat(buf,"/:");
906 for (i = 0; i < rule->NBTOKEN; i ++)
907 {
908 if (i)
909 strcat(buf," ");
910 strcat(buf,rule->TOKEN[i]);
911 }
912 }
913
914 /*}}}************************************************************************/
915 /*}}}************************************************************************/
916 /*}}}************************************************************************/
917 #else
918 /*{{{ */
919 #define alloue(size) mbkalloc(size)
920 #define desalloue(ptr) mbkfree(ptr)
921 #define copystr(str) mbkstrdup(str)
922 #define initmemory()
923 #define closememory() 0
924 /*}}}************************************************************************/
925 #endif
926 /****************************************************************************/
927 /*{{{ Static functions */
928 /****************************************************************************/
929 /*{{{ mfe_error() */
930 /* */
931 /* */
932 /****************************************************************************/
933 static int mfe_error()
934 {
935 fprintf(stderr,"[MFE_ERR]\n");
936 EXIT(0);
937 return 0;
938 }
939
940 /*}}}************************************************************************/
941 /*{{{ newrule() */
942 /* */
943 /* */
944 /****************************************************************************/
945 static void newrule(extract_rules **ruleslist)
946 {
947 extract_rules *neo;
948
949 neo = alloue(sizeof(extract_rules));
950 memset(neo,0,sizeof(extract_rules));
951 neo->NEXT = *ruleslist;
952 *ruleslist = neo;
953 }
954
955 /*}}}************************************************************************/
956 /*{{{ freerule() */
957 /* */
958 /* */
959 /****************************************************************************/
960 static void freerule(extract_rules *rule)
961 {
962 if (rule)
963 {
964 int i;
965
966 if (rule->BEGIN)
967 desalloue(rule->BEGIN);
968 if (rule->END)
969 desalloue(rule->END);
970 for (i = 0; i < rule->NBTOKEN; i ++)
971 desalloue(rule->TOKEN[i]);
972 if (rule->TOKEN)
973 desalloue(rule->TOKEN);
974 desalloue(rule);
975 }
976 }
977
978 /*}}}************************************************************************/
979 /*{{{ newlabel() */
980 /* */
981 /* */
982 /****************************************************************************/
983 static void newlabel(label_table **table)
984 {
985 label_table *neo;
986
987 neo = alloue(sizeof(label_table));
988 memset(neo,0,sizeof(label_table));
989 neo->NEXT = *table;
990 *table = neo;
991 }
992
993 /*}}}************************************************************************/
994 /*{{{ freelabel() */
995 /* */
996 /* */
997 /****************************************************************************/
998 static void freelabel(label_table *label, int cleanmc)
999 {
1000 if (label) {
1001 if( cleanmc )
1002 mbkfree( label->VALUE.MC.TABLE );
1003 desalloue(label);
1004 }
1005 }
1006
1007 /*}}}************************************************************************/
1008 /*{{{ allocref() */
1009 /* */
1010 /* */
1011 /****************************************************************************/
1012 static void allocref(label_ref **ref)
1013 {
1014 *ref = alloue(sizeof(label_ref));
1015 memset(*ref,0,sizeof(label_ref));
1016 (*ref)->REFTBL = addht(50);
1017 }
1018
1019 /*}}}************************************************************************/
1020 /*{{{ freeref() */
1021 /* */
1022 /* */
1023 /****************************************************************************/
1024 static void freeref(label_ref **ref)
1025 {
1026 delht((*ref)->REFTBL);
1027 desalloue(*ref);
1028 *ref = NULL;
1029 }
1030
1031 /*}}}************************************************************************/
1032 /*{{{ affectlabel() */
1033 /* */
1034 /* */
1035 /****************************************************************************/
1036 static int affectlabel(label_ref *ref, char *label, double value, int match, int usemc)
1037 {
1038 label_table *lbl;
1039 int n;
1040
1041 if ((lbl= (label_table*)gethtitem(ref->REFTBL,label)) == (void*)EMPTYHT)
1042 return LABL_ULBL_ERR;
1043 else
1044 {
1045 if (MFE_DEBUG_MODE)
1046 printf("[MFE_MES] storing %g for %s\n",value,label);
1047 if( usemc > 0 ) {
1048 n = lbl->VALUE.MC.NBMC ;
1049 if( n < lbl->VALUE.MC.MAXMC ) {
1050 lbl->VALUE.MC.TABLE[n] = value ;
1051 lbl->VALUE.MC.NBMC++ ;
1052 }
1053 }
1054 else
1055 lbl->VALUE.NUMBER = value ;
1056 lbl->FLAG = match;
1057
1058 return 0;
1059 }
1060 }
1061
1062 /*}}}************************************************************************/
1063 /*{{{ duplabel() */
1064 /* */
1065 /* */
1066 /****************************************************************************/
1067 static void duplabel(label_ref **new, label_table *tbl)
1068 {
1069 if (tbl)
1070 {
1071 duplabel(new, tbl->NEXT);
1072 mfe_addlabel(new,tbl->LABEL,0);
1073 }
1074 }
1075
1076 /*}}}************************************************************************/
1077 /*{{{ __getline() */
1078 /* */
1079 /* */
1080 /****************************************************************************/
1081 static int __getline(FILE *fd, char *buf)
1082 {
1083 int len;
1084
1085 if (fgets(buf,MFE_CHAR_IN_LINE,fd))
1086 if ((len = strlen(buf)) != MFE_CHAR_IN_LINE - 1)
1087 {
1088 buf[len-1] = '\0';
1089 len--;
1090 while (len>=0)
1091 {
1092 if (buf[len]<' ') buf[len]=' ';
1093 len--;
1094 }
1095 return 0;
1096 }
1097 else
1098 return MFE_LONGLINE_ERR;
1099 else
1100 return 1;
1101 }
1102
1103 /*}}}************************************************************************/
1104 /*{{{ istext() */
1105 /* */
1106 /* */
1107 /****************************************************************************/
1108 static int istext(char *buf, char text[], int *offset)
1109 {
1110 int i = 0;
1111
1112 while (buf[*offset] == ' ')
1113 if (buf[*offset] == '\0')
1114 return RULE_MATC_ERR;
1115 else
1116 (*offset) ++;
1117
1118 if (isalpha((int)buf[*offset]))
1119 {
1120 while (buf[*offset] != ' ' && buf[*offset] != '=' && buf[*offset] != '\0')
1121 {
1122 if (text)
1123 text[i++] = buf[(*offset)++];
1124 }
1125 if (text)
1126 text[i] = '\0';
1127
1128 return 0;
1129 }
1130 else
1131 return RULE_MATC_ERR;
1132
1133 }
1134
1135 /*}}}************************************************************************/
1136 /*{{{ istoken() */
1137 /* */
1138 /* */
1139 /****************************************************************************/
1140 static int istoken(char *buf, char *token, int *offset)
1141 {
1142 int i = 0;
1143
1144 while (buf[*offset] == ' ')
1145 if (buf[*offset] == '\0')
1146 return RULE_MATC_ERR;
1147 else
1148 (*offset) ++;
1149
1150 while (buf[*offset] != ' ' && buf[*offset] != '\0')
1151 if (token[i]=='\0') break;
1152 else
1153 if (token[i++] != buf[(*offset)++])
1154 return RULE_MATC_ERR;
1155
1156 return 0;
1157 }
1158
1159 /*}}}************************************************************************/
1160 /*{{{ isvalue() */
1161 /* */
1162 /* */
1163 /****************************************************************************/
1164 static int isvalue(char *buf, double *value, int *offset)
1165 {
1166 char *endptr;
1167 double valtmp;
1168
1169 valtmp = strtod(buf + (*offset)*sizeof(char), &endptr);
1170 if (*offset == endptr - buf)
1171 {
1172 (*offset) ++;
1173 return RULE_MATC_ERR;
1174 }
1175 *offset = endptr - buf;
1176 if (value)
1177 *value = valtmp;
1178
1179 if (isnan(valtmp))
1180 return RULE_MATC_ERR;
1181 else
1182 return 0;
1183 }
1184
1185 /*}}}************************************************************************/
1186 /*{{{ matchtoken() */
1187 /* */
1188 /* */
1189 /****************************************************************************/
1190 static int matchtoken(char *head, char *token, int *offset,
1191 char *label, double *value, char *isval)
1192 {
1193 char *tail;
1194 int res, len;
1195
1196 if (token[0] == '%')
1197 switch (token[1])
1198 {
1199 case 'l' :
1200 res = istext(head,label,offset);
1201 if (isval)
1202 isval[0] = label[0];
1203 len = strlen(token);
1204 if (len > 2)
1205 {
1206 tail = label + strlen(label) - (len-2);
1207 if (!strcmp(tail, token+2))
1208 tail[0] = 0;
1209 else
1210 res = RULE_UTOK_ERR;
1211 }
1212 if (MFE_DEBUG_MODE)
1213 printf("[MFE_MES] %s match token %s\n",label,token);
1214 break;
1215 case 'i' :
1216 res = istext(head,NULL,offset);
1217 break;
1218 case 'v' :
1219 res = isvalue(head,value,offset);
1220 if (MFE_DEBUG_MODE)
1221 printf("[MFE_MES] %g match token %s\n",*value,token);
1222 if (isval)
1223 isval[0] = -1;
1224 break;
1225 case '0' :
1226 res = isvalue(head,NULL,offset);
1227 break;
1228 default :
1229 res = RULE_UTOK_ERR;
1230 break;
1231 }
1232 else
1233 res = istoken(head,token,offset);
1234
1235 return res;
1236 }
1237
1238 /*}}}************************************************************************/
1239 /*{{{ matchline() */
1240 /* */
1241 /* */
1242 /****************************************************************************/
1243 static int matchline(char *head, extract_rules *rule, label_ref *ref, int usemc)
1244 {
1245 double value;
1246 char label[1024], *name;
1247 int i, offset;
1248
1249 label[0] = '\0';
1250 value = 0.0;
1251
1252 for (i = 0, offset = 0; i < rule->NBTOKEN; i ++)
1253 if (matchtoken(head,rule->TOKEN[i],&offset,label,&value,0))
1254 break;
1255
1256 if (label[0] != '\0' && i == rule->NBTOKEN && (name = min_namefind(label)))
1257 {
1258 affectlabel(ref,name,value,LABL_FOUND,usemc);
1259 return 0;
1260 }
1261 else
1262 return RULE_FTOK_ERR;
1263 }
1264
1265 /*}}}************************************************************************/
1266 /*{{{ matchtableline() */
1267 /* */
1268 /* simple revision */
1269 /****************************************************************************/
1270 static int matchtableline(char *head, extract_rules *rule)
1271 {
1272 char *token, label[1024], is /*what is*/;
1273 int i, offset, res;
1274 double value;
1275
1276 token = rule->TOKEN[rule->LINE];
1277
1278 if (!rule->LBLLIST)
1279 rule->LBLLIST = alloue(500 * sizeof(label_list));
1280
1281 offset = 0;
1282 for (i = 0; head[offset] != '\0'; i ++)
1283 {
1284 is = '\0';
1285 if ((res = matchtoken(head,token,&offset,label,&value,&is)))
1286 {
1287 if (!rule->LINE)
1288 rule->NBELT1ST = rule->NBELT;
1289 (rule->LINE) ++;
1290 rule ->NBELT = 0;
1291
1292 if (rule->LINE > rule->NBTOKEN-1)
1293 {
1294 rule->LINE = 0;
1295 rule ->NBELT = 0;
1296 rule ->NBELT1ST = 0;
1297
1298 // printf("[MFE_WAR] Be carefull, maybe the file hasn't been generated by unix systems\n");
1299
1300 return 1;
1301 }
1302
1303 return matchtableline(head,rule);
1304 }
1305 else
1306 {
1307 switch (is)
1308 {
1309 case -1 :
1310 rule->LBLLIST[rule->NBELT].VALUE = value;
1311 case '\0' :
1312 break;
1313 default :
1314 rule->LBLLIST[rule->NBELT].LABEL = min_namefind(label);
1315 }
1316 (rule->NBELT) ++;
1317 }
1318
1319 while (head[offset] == ' ')
1320 offset ++;
1321 }
1322
1323 return 0;
1324 }
1325
1326 /*}}}************************************************************************/
1327 /*{{{ domatchvarval() */
1328 /* */
1329 /* */
1330 /****************************************************************************/
1331 static int domatchvarval(label_ref *ref, extract_rules *rule)
1332 {
1333 int i;
1334
1335 for (i = 0; i < rule->NBELT; i ++)
1336 if (rule->LBLLIST[i].LABEL)
1337 affectlabel(ref,rule->LBLLIST[i].LABEL,
1338 rule->LBLLIST[i].VALUE,LABL_FOUND,-1);
1339
1340 return 0;
1341 }
1342
1343 /*}}}************************************************************************/
1344 /*{{{ decodeline() */
1345 /* */
1346 /* */
1347 /****************************************************************************/
1348 static int decodeline(char *buf, extract_rules *rules, label_ref *ref, int usemc)
1349 {
1350 extract_rules *rx;
1351
1352 for (rx = rules; rx; rx = rx->NEXT)
1353 {
1354 if (rx->ACTIVATED != RULE_UNACTIVATED)
1355 if (rx->END[0] && strstr(buf,rx->END))
1356 rx->ACTIVATED = RULE_UNACTIVATED;
1357 else switch (rx->TYPE)
1358 {
1359 case RULE_TYPE_LINE :
1360 matchline(buf,rx,ref,usemc);
1361 break;
1362 case RULE_TYPE_TABLE :
1363 if (matchtableline(buf,rx))
1364 {
1365 rx->NBELT = 0;
1366 }
1367 else if (rx->LINE == rx->NBTOKEN-1 && rx->NBELT == rx->NBELT1ST)
1368 {
1369 domatchvarval(ref,rx);
1370 rx->NBELT = 0;
1371 }
1372 break;
1373 default :
1374 return RULE_TYPE_ERR;
1375 }
1376 else
1377 if (strstr(buf,rx->BEGIN))
1378 rx->ACTIVATED = RULE_ACTIVATED;
1379 }
1380 return 0;
1381 }
1382
1383 /*}}}************************************************************************/
1384 /*}}}************************************************************************/
1385 /*{{{ Extern Functions */
1386 /****************************************************************************/
1387 /*{{{ mfe_addrule() */
1388 /* */
1389 /* */
1390 /****************************************************************************/
1391 int mfe_addrule(extract_rules **ruleslist, char *rule)
1392 {
1393 int i, nbtoken, ret = 0;
1394 char *token[1024], *next, *begend[2], line[2048];
1395 extract_rules *res;
1396
1397 // momentatly disable NEXT field
1398 if (!(*ruleslist))
1399 newrule(ruleslist);
1400
1401 res = *ruleslist;
1402 sprintf(line,"%s",rule);
1403 next = line;
1404
1405 /* find type */
1406 if (next[0] == 't' && next[1] == 'a' && next[2] == 'b' && next[3] == 'l' &&
1407 next[4] == 'e' && next[5] == ':')
1408 {
1409 next = next + 6 * sizeof(char);
1410 res->TYPE = RULE_TYPE_TABLE;
1411 }
1412 else if (next[0] == 'l' && next[1] == 'i' && next[2] == 'n' &&
1413 next[3] == 'e' && next[4] == ':')
1414 {
1415 next = next + 5 * sizeof(char);
1416 res->TYPE = RULE_TYPE_LINE;
1417 }
1418 else
1419 GO2ERR(RULE_TYPE_ERR);
1420
1421 if (!ret)
1422 {
1423 /* find begin and end */
1424 for (i = 0; i < 3; i ++)
1425 {
1426 if (next[0] != '/')
1427 GO2ERR(RULE_BEGE_ERR);
1428 next[0] = '\0';
1429 next = next + sizeof(char);
1430 if (i >= 2)
1431 continue;
1432 begend[i] = next;
1433 if (!(next = strchr(next,'/')))
1434 GO2ERR(RULE_BEGE_ERR);
1435 }
1436 res->BEGIN = copystr(begend[0]);
1437 res->END = copystr(begend[1]);
1438 if (next[0] == ':')
1439 next = next + sizeof(char);
1440 else
1441 GO2ERR(RULE_BEGE_ERR);
1442
1443 /* find token(s) */
1444 nbtoken = 0;
1445 if (res->TYPE == RULE_TYPE_LINE)
1446 for (i = 0, nbtoken = 0; next[i] != '\0'; i ++)
1447 {
1448 int j = i;
1449
1450 while (next[j] == ' ')
1451 next[j++] = '\0';
1452 if (j != i || i == 0)
1453 {
1454 i = j;
1455 token[nbtoken++] = next + i * sizeof(char);
1456 if (nbtoken > 1023)
1457 GO2ERR(RULE_TOOT_ERR);
1458 }
1459 }
1460 else if (res->TYPE == RULE_TYPE_TABLE)
1461 for (i = 0, nbtoken = 0; next[i] != '\0'; i ++)
1462 {
1463 int j = i;
1464
1465 while (next[j] == ' ')
1466 j ++;
1467 if (next[j] == '%' || i == 0)
1468 {
1469 i = j;
1470 if (i)
1471 next[i-1] = '\0';
1472 token[nbtoken++] = next + i * sizeof(char);
1473 if (nbtoken > 1023)
1474 GO2ERR(RULE_TOOT_ERR);
1475 }
1476 }
1477
1478 res->TOKEN = alloue(nbtoken * sizeof(char *));
1479 res->NBTOKEN = nbtoken;
1480 for (i = 0; i < nbtoken; i ++)
1481 res->TOKEN[i] = copystr(token[i]);
1482 }
1483 endfunc :
1484 if (ret)
1485 mfe_delrule(ruleslist,*ruleslist);
1486 return ret;
1487 }
1488
1489 /*}}}************************************************************************/
1490 /*{{{ mfe_delrule() */
1491 /* */
1492 /* */
1493 /****************************************************************************/
1494 int mfe_delrule(extract_rules **ruleslist, extract_rules *rule)
1495 {
1496 extract_rules *rx, head;
1497
1498 head.NEXT = *ruleslist;
1499 for (rx = &head; rx->NEXT; rx = rx->NEXT)
1500 if (rx->NEXT == rule)
1501 {
1502 rx->NEXT = rx->NEXT->NEXT;
1503 freerule(rule);
1504 *ruleslist = head.NEXT;
1505
1506 return 0;
1507 }
1508
1509 return 1;
1510 }
1511
1512 /*}}}************************************************************************/
1513 /*{{{ mfe_freerules() */
1514 /* */
1515 /* */
1516 /****************************************************************************/
1517 void mfe_freerules(extract_rules **ruleslist)
1518 {
1519 if (*ruleslist)
1520 {
1521 mfe_freerules(&((*ruleslist)->NEXT));
1522 freerule(*ruleslist);
1523 *ruleslist = NULL;
1524 }
1525 }
1526
1527 /*}}}************************************************************************/
1528 /*{{{ mfe_duprules() */
1529 /* */
1530 /* */
1531 /****************************************************************************/
1532 void mfe_duprules(extract_rules **newrules, extract_rules *rules)
1533 {
1534 if (rules)
1535 {
1536 int i;
1537
1538 mfe_duprules(newrules,rules->NEXT);
1539 newrule(newrules);
1540 (*newrules)->TYPE = rules->TYPE;
1541 (*newrules)->ACTIVATED = rules->ACTIVATED;
1542 (*newrules)->NBTOKEN = rules->NBTOKEN;
1543 (*newrules)->TOKEN = alloue(rules->NBTOKEN * sizeof(char *));
1544 for (i = 0; i < rules->NBTOKEN; i ++)
1545 (*newrules)->TOKEN[i] = copystr(rules->TOKEN[i]);
1546 (*newrules)->BEGIN = copystr(rules->BEGIN);
1547 (*newrules)->END = copystr(rules->END);
1548 }
1549 else
1550 *newrules = NULL;
1551 }
1552
1553 /*}}}************************************************************************/
1554 /*{{{ mfe_addlabel() */
1555 /* */
1556 /* */
1557 /****************************************************************************/
1558 int mfe_addlabel(label_ref **ref, char *label, int nbmc)
1559 {
1560 long res;
1561
1562 label = min_namealloc(label);
1563 if (!*ref)
1564 allocref(ref);
1565 res = gethtitem((*ref)->REFTBL,label);
1566 if (res != EMPTYHT)
1567 return LABL_LEXI_WAR;
1568 else
1569 {
1570 label_table **tbl;
1571
1572 tbl = &((*ref)->LABTBL);
1573 newlabel(tbl);
1574 (*tbl)->LABEL = label;
1575 (*tbl)->FLAG = LABL_NOTFOUND;
1576 if( nbmc > 0 ) {
1577 (*tbl)->VALUE.MC.TABLE = (double*)mbkalloc( sizeof(double)*nbmc );
1578 (*tbl)->VALUE.MC.NBMC = 0 ;
1579 (*tbl)->VALUE.MC.MAXMC = nbmc ;
1580 }
1581 addhtitem((*ref)->REFTBL,label,(long)*tbl);
1582
1583 return 0;
1584 }
1585 }
1586
1587 /*}}}************************************************************************/
1588 /*{{{ mfe_dellabel() */
1589 /* */
1590 /* */
1591 /****************************************************************************/
1592 int mfe_dellabel(label_ref **ref, char *label)
1593 {
1594 label_table *tbl, *tx, head;
1595
1596 tbl = (label_table *)gethtitem((*ref)->REFTBL,label);
1597 if (tbl == (label_table*)EMPTYHT)
1598 return LABL_ULBL_ERR;
1599 else
1600 {
1601 head.NEXT = (*ref)->LABTBL;
1602 for (tx = &head; tx->NEXT; tx = tx->NEXT)
1603 if (tx->NEXT == tbl)
1604 {
1605 delhtitem((*ref)->REFTBL,label);
1606 freelabel(tbl,0);
1607 if (!head.NEXT)
1608 freeref(ref);
1609 else
1610 (*ref)->LABTBL = head.NEXT;
1611
1612 return 0;
1613 }
1614
1615 return LABL_PLBL_ERR;
1616 }
1617 }
1618
1619 /*}}}************************************************************************/
1620 /*{{{ mfe_freelabels() */
1621 /* */
1622 /* */
1623 /****************************************************************************/
1624 void mfe_freelabels(label_ref **ref, int cleanmc)
1625 {
1626 if (*ref)
1627 {
1628 label_table *tx, *txx;
1629
1630 for (tx = (*ref)->LABTBL; tx; )
1631 {
1632 txx = tx->NEXT;
1633 freelabel(tx, cleanmc);
1634 tx = txx;
1635 }
1636 freeref(ref);
1637 }
1638 }
1639
1640 /*}}}************************************************************************/
1641 /*{{{ mfe_duplabels() */
1642 /* */
1643 /* */
1644 /****************************************************************************/
1645 void mfe_duplabels(label_ref **table, label_ref *ref)
1646 {
1647 allocref(table);
1648 duplabel(table,ref->LABTBL);
1649 }
1650
1651 /*}}}************************************************************************/
1652 /*{{{ mfe_fileextractlabel() */
1653 /* */
1654 /* */
1655 /****************************************************************************/
1656 int mfe_fileextractlabel(char *filename, extract_rules *rules, label_ref *ref, int nbmc)
1657 {
1658 FILE *fd;
1659 extract_rules *rx;
1660 char *buf;
1661 int usemc;
1662
1663 if (!rules || !ref)
1664 return 1;
1665 else
1666 {
1667 if( nbmc > 0 )
1668 usemc = 1 ;
1669 else
1670 usemc = 0 ;
1671
1672 /* init rules */
1673 for (rx = rules; rx; rx = rx->NEXT)
1674 if (!rx->BEGIN[0])
1675 rx->ACTIVATED = 1;
1676 if ((fd = mbkfopen(filename,NULL,"r")))
1677 {
1678 if (getenv("MFE_DEBUG"))
1679 MFE_DEBUG_MODE = 1;
1680 buf = alloue(MFE_LINE_SIZE);
1681 /* read lines */
1682 while (!feof(fd) && __getline(fd,buf)!=1)
1683 if (decodeline(buf,rules,ref,usemc))
1684 break;
1685
1686 /* free rules buffer if needed */
1687 for (rx = rules; rx; rx = rx->NEXT)
1688 if (rx->LBLLIST)
1689 {
1690 desalloue(rx->LBLLIST);
1691 rx->LBLLIST = NULL;
1692 }
1693
1694 desalloue(buf);
1695 fclose(fd);
1696
1697 return 0;
1698 }
1699 else
1700 return 1;
1701 }
1702 }
1703
1704 /*}}}************************************************************************/
1705 /*{{{ mfe_labelvalue() */
1706 /* */
1707 /* */
1708 /****************************************************************************/
1709 int mfe_labelvalue(label_ref *ref, char *label, double *value, int idmc)
1710 {
1711 long res;
1712
1713 label = min_namealloc(label);
1714 if (ref && ref->REFTBL)
1715 if ((res = gethtitem(ref->REFTBL,label)) == EMPTYHT)
1716 {
1717 if (MFE_DEBUG_MODE)
1718 printf("[MFE_MES] %s doesn't match anything\n",label);
1719
1720 return LABL_ULBL_ERR;
1721 }
1722 else
1723 {
1724 label_table *table = (void *)res;
1725
1726 if (table->FLAG == LABL_NOTFOUND)
1727 return LABL_NOTFOUND;
1728 else
1729 {
1730 if (value) {
1731 if( idmc >= 0 )
1732 *value = table->VALUE.MC.TABLE[ idmc ];
1733 else
1734 *value = table->VALUE.NUMBER;
1735 }
1736 if (MFE_DEBUG_MODE)
1737 printf("[MFE_MES] %s match, result is: %g\n",label,*value);
1738
1739 return LABL_FOUND; /* 0 */
1740 }
1741 }
1742 else
1743 return LABL_UTBL_ERR;
1744 }
1745
1746 /*}}}************************************************************************/
1747 /*{{{ mfe_cleanLabel() */
1748 /* */
1749 /* */
1750 /****************************************************************************/
1751 void mfe_cleanLabel(label_ref *ref)
1752 {
1753 label_table *tx;
1754
1755 if (ref)
1756 for (tx = ref->LABTBL; tx; tx = tx->NEXT)
1757 {
1758 tx->FLAG = LABL_NOTFOUND;
1759 }
1760 }
1761
1762 /*}}}************************************************************************/
1763 /*}}}************************************************************************/
1764
1765 int mfe_readmeasure(char *filename, void *mferules, char *rule, char *label, double *value)
1766 {
1767 int err;
1768 extract_rules *crules = (extract_rules *)mferules;
1769 label_ref *labels = NULL;
1770
1771 if (rule!=NULL) mfe_addrule(&crules,rule);
1772
1773 mfe_addlabel(&labels,label, 0);
1774
1775 mfe_fileextractlabel(filename,crules,labels,0);
1776
1777 err=mfe_labelvalue(labels,label,value,-1);
1778
1779 mfe_freelabels(&labels,0);
1780 if (rule!=NULL) mfe_freerules(&crules);
1781
1782 return err;
1783 }
1784
1785 static int cutword(char *buf, char **tab, int max)
1786 {
1787 char *r, *res;
1788 int i;
1789
1790 i=0;
1791 res=strtok_r(buf, " ", &r);
1792 while (res!=NULL && i<max)
1793 {
1794 tab[i]=res;
1795 res=strtok_r(NULL, " ", &r);
1796 i++;
1797 }
1798 return i;
1799 }
1800 void mfe_read_montecarlo_ltspice(char *filename, label_ref *ref)
1801 {
1802 FILE *f;
1803 char *buf;
1804 char *tab[5];
1805 int i, il, lastidx;
1806 char *label=NULL;
1807
1808 if ((f=fopen(filename,"r"))!=NULL)
1809 {
1810 buf = alloue(MFE_LINE_SIZE);
1811 while (!feof(f) && __getline(f, buf)!=1)
1812 {
1813 i=cutword(buf, tab, 5);
1814 if (i==2 && strcasecmp(tab[0],"Measurement:")==0)
1815 {
1816 label=min_namefind(tab[1]);
1817 lastidx=0;
1818 } else if (i==0 || (i==4 && label!=NULL && strcasecmp(tab[1],label)==0 && strcasecmp(tab[2],"from")==0 && strcasecmp(tab[3],"to")==0))
1819 {
1820 }
1821 else if (i==4)
1822 {
1823 il=atoi(tab[0]);
1824 if (il!=0)
1825 {
1826 for (i=lastidx+1; i<il; i++)
1827 affectlabel(ref,label,-1,LABL_FOUND,1);
1828 affectlabel(ref,label,atof(tab[1]),LABL_FOUND,1);
1829 lastidx=il;
1830 }
1831 else label=NULL;
1832 }
1833 else
1834 label=NULL;
1835 }
1836 desalloue(buf);
1837 fclose(f);
1838 }
1839 }
1840