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 / tas / sim / sim_meas.c
1 /****************************************************************************/
2 /* */
3 /* Chaine de CAO & VLSI AVERTEC */
4 /* */
5 /* Produit : AVERTEC global tools */
6 /* Fichier : sim_meas.c */
7 /* */
8 /* © copyright 2000 AVERTEC */
9 /* Tous droits reserves */
10 /* */
11 /* Auteur(s) : Antony PINTO */
12 /* */
13 /****************************************************************************/
14
15 #include "sim_meas.h"
16
17 #ifndef __func__
18 #define __func__ __FILE__
19 #endif
20
21 sim_meas_cmd SIM_MEAS;
22 static int set_SIM_MEAS=0;
23
24 static void printMeasCmd_int(FILE *fd, sim_meas_arg *arg);
25 static int existMeasArg(sim_model *model, sim_meas_arg **arg, char *label);
26 static void freeMeasArg_int(sim_meas_arg *arg);
27 static sim_meas_print *allocprn(sim_model *model, char *delay, char *sig1, char *sig2, char sigt[2], char *transition, int delay_type, SIM_FLOAT th_in, SIM_FLOAT th_out);
28 static void addMeas(sim_model *model, char *delay, char *slope, char *sig1, char *sig2, char *transition, int check, int delay_type);
29 static sim_meas_print *freePrn(sim_meas_print *prn);
30
31 /****************************************************************************/
32 /*{{{ External functions */
33 /*{{{ sim_decodeMeasCmd() */
34 /* */
35 /* */
36 /****************************************************************************/
37 void sim_decodeMeasCmd(char *env)
38 {
39 char buf[2048], minibuf[256];
40 int i, j, k, l,dep, type, ind, envlen;
41
42 envlen = (int)strlen(env);
43 memset(&SIM_MEAS,0,sizeof(SIM_MEAS));
44 set_SIM_MEAS=1;
45
46 for (i = 0, j = 0, dep = 0; i < envlen; i++)
47 {
48 buf[j++] = env[i];
49 if (env[i] == '%')
50 {
51 type = 0;
52 ind = 0;
53 switch (env[++i])
54 {
55 case 'n' :
56 type ++;
57 case 't' :
58 type ++;
59 case 'v' :
60 type ++;
61 case 's' :
62 type ++;
63 switch (env[++i])
64 {
65 case '2' :
66 ind ++;
67 case '1' :
68 SIM_MEAS.ARGORDER[dep] = type + SIM_MEAS_A4S*ind;
69 if (type == SIM_MEAS_TRANS)
70 {
71 if (env[++i] == '{')
72 {
73 k = 0;
74 l = 0;
75 while (l < 2)
76 {
77 if (env[++i] != ' ')
78 minibuf[k] = env[i];
79 if (minibuf[k] == ',' || minibuf[k] == '}')
80 {
81 minibuf[k] = '\0';
82 SIM_MEAS.TRANS[ind][l++] =
83 mbkstrdup(minibuf);
84 k = -1;
85 }
86 k ++;
87 if (i > envlen)
88 sim_err("Measure command malformed");
89 }
90 }
91 else
92 sim_war("Token %%%c must have a list of data",
93 env[i-2]);
94 }
95 else if (type == SIM_MEAS_NTRANS)
96 {
97 if (env[++i] == '{')
98 {
99 k = 0;
100 while (env[++i] != '}')
101 if (env[i] != ' ')
102 minibuf[k++] = env[i];
103 else if (i > envlen)
104 sim_err("Measure command malformed");
105 minibuf[k] = '\0';
106 SIM_MEAS.LAST[ind] =
107 mbkstrdup(minibuf);
108 }
109 else
110 sim_war("Token %%%c must have a data",env[i-2]);
111 }
112 break;
113 default :
114 sim_war("Token %%%c must have an index (1,2)",env[i-1]);
115 }
116 break;
117 case 'l' :
118 SIM_MEAS.ARGORDER[dep] = SIM_MEAS_LABEL;
119 break;
120 default :
121 sim_war("Unknown token : %%%c",env[i]);
122 }
123 buf[j++] = 's';
124 dep ++;
125 }
126 }
127 buf[j++] = '\n';
128 buf[j] = '\0';
129 SIM_MEAS.CMDSTR = mbkstrdup(buf);
130 }
131
132 void sim_decodeMeasCmdFree()
133 {
134 int i, j;
135 if (!set_SIM_MEAS) return;
136
137 for (i=0; i<SIM_MEAS_NBSIG; i++)
138 {
139 if (SIM_MEAS.LAST[i]!=NULL) mbkfree(SIM_MEAS.LAST[i]);
140 for (j=0; j<2; j++)
141 if (SIM_MEAS.TRANS[i][j]!=NULL) mbkfree(SIM_MEAS.TRANS[i][j]);
142
143 }
144 if (SIM_MEAS.CMDSTR!=NULL) mbkfree(SIM_MEAS.CMDSTR);
145 }
146
147 /*}}}************************************************************************/
148 /*{{{ sim_affectMeasCmdArg() */
149 /* */
150 /* */
151 /****************************************************************************/
152 void sim_affectMeasCmdArg(sim_model *model, char *label,
153 char *sig1, char trans1, int ntrans1, double val1,
154 char *sig2, char trans2, int ntrans2, double val2)
155 {
156 sim_meas_arg *arg;
157 int i;
158 long ntrans[SIM_MEAS_NBSIG] = { ntrans1, ntrans2 };
159 double val[SIM_MEAS_NBSIG] = { val1 , val2 };
160 char trans[SIM_MEAS_NBSIG] = { trans1 , trans2 };
161 char *sig[SIM_MEAS_NBSIG] = { sig1 , sig2 };
162 char buf[256];
163
164 if (existMeasArg(model,&arg,label))
165 freeMeasArg_int(arg);
166 else
167 {
168 arg = mbkalloc(sizeof(sim_meas_arg));
169 arg->NEXT = model->LARGS;
170 model->LARGS = arg;
171 }
172
173 arg->REFCMD = &SIM_MEAS;
174 arg->ARG[SIM_MEAS_LABEL] = label;
175
176 for (i = 0; i < SIM_MEAS_NBSIG; i ++)
177 {
178 /* signal name */
179 arg->ARG[SIM_MEAS_SIG + SIM_MEAS_A4S*i] = mbkstrdup(sig[i]);
180
181 /* transition type */
182 if (trans[i] == 'U' || trans[i] == 'u')
183 arg->ARG[SIM_MEAS_TRANS + SIM_MEAS_A4S*i] =
184 SIM_MEAS.TRANS[i][SIM_MEAS_UP];
185 else if (trans[i] == 'D' || trans[i] == 'd')
186 arg->ARG[SIM_MEAS_TRANS + SIM_MEAS_A4S*i] =
187 SIM_MEAS.TRANS[i][SIM_MEAS_DN];
188 else
189 {
190 sim_war("Unknown type of transition");
191 arg->ARG[SIM_MEAS_TRANS + SIM_MEAS_A4S*i] = NULL;
192 }
193
194 /* threshold value */
195 sprintf(buf,"%g",val[i]);
196 arg->ARG[SIM_MEAS_VALUE + SIM_MEAS_A4S*i] = mbkstrdup(buf);
197
198 /* number of transition */
199 if (ntrans[i] != SIM_MEASURE_LAST)
200 sprintf(buf,"%ld",ntrans[i]);
201 else
202 sprintf(buf,"%s",SIM_MEAS.LAST[i]);
203
204 arg->ARG[SIM_MEAS_NTRANS + SIM_MEAS_A4S*i] = mbkstrdup(buf);
205 }
206 }
207
208 /*}}}************************************************************************/
209 /*{{{ sim_freeMeasArg() */
210 /* */
211 /* */
212 /****************************************************************************/
213 void sim_freeMeasArg(sim_model *model, char *label)
214 {
215 sim_meas_arg *arg, *tmp;
216
217 for (arg = (sim_meas_arg *)&(model->LARGS); arg->NEXT; arg = arg->NEXT)
218 if (arg->NEXT->ARG[SIM_MEAS_LABEL] == label)
219 {
220 freeMeasArg_int(arg->NEXT);
221 tmp = arg->NEXT;
222 arg->NEXT = arg->NEXT->NEXT;
223 mbkfree(tmp);
224 break;
225 }
226 }
227
228 /*}}}************************************************************************/
229 /*{{{ sim_freeMeasAllArg() */
230 /* */
231 /* */
232 /****************************************************************************/
233 void sim_freeMeasAllArg(sim_model *model)
234 {
235 sim_meas_arg *arg, *tmp;
236
237 for (arg = (sim_meas_arg *)&(model->LARGS); arg->NEXT; )
238 {
239 freeMeasArg_int(arg->NEXT);
240 tmp = arg->NEXT;
241 arg->NEXT = arg->NEXT->NEXT;
242 mbkfree(tmp);
243 }
244 }
245
246 /*}}}************************************************************************/
247 /*{{{ sim_freePrn() */
248 /* */
249 /* */
250 /****************************************************************************/
251 void sim_freePrn(sim_model *model)
252 {
253 model->LPRN = freePrn(model->LPRN);
254 }
255
256 /*}}}************************************************************************/
257 /*{{{ sim_addMeas() */
258 /* */
259 /* */
260 /****************************************************************************/
261 void sim_addMeas(sim_model *model, char *delay, char *slope,
262 char *sig1, char *sig2, char *transition, int delay_type)
263 {
264 addMeas(model,delay,slope,sig1,sig2,transition,1,delay_type);
265 }
266
267 /*}}}************************************************************************/
268 /*{{{ sim_addMeasDelay() */
269 /* */
270 /* */
271 /****************************************************************************/
272 void sim_addMeasDelay(sim_model *model, char *delay,
273 char *sig1, char *sig2, char *transition, int delay_type)
274 {
275 addMeas(model,delay,NULL,sig1,sig2,transition,1,delay_type);
276 }
277
278 /*}}}************************************************************************/
279 /*{{{ sim_addMeasSlope() */
280 /* */
281 /* */
282 /****************************************************************************/
283 void sim_addMeasSlope(sim_model *model, char *slope, char *sig,
284 char *transition, int delay_type)
285 {
286 addMeas(model,NULL,slope,NULL,sig,transition,1,delay_type);
287 }
288
289 /*}}}************************************************************************/
290 /*{{{ sim_addMeasWithoutNameCheck() */
291 /* */
292 /* */
293 /****************************************************************************/
294 void sim_addMeasWithoutNameCheck(sim_model *model, char *delay, char *slope,
295 char *sig1, char *sig2, char *transition, int delay_type)
296 {
297 addMeas(model,delay,slope,sig1,sig2,transition,0,delay_type);
298 }
299
300 /*}}}************************************************************************/
301 /*{{{ sim_addMeasDelayWithoutNameCheck() */
302 /* */
303 /* */
304 /****************************************************************************/
305 void sim_addMeasDelayWithoutNameCheck(sim_model *model, char *delay,
306 char *sig1, char *sig2,
307 char *transition, int delay_type)
308 {
309 addMeas(model,delay,NULL,sig1,sig2,transition,0,delay_type);
310 }
311
312 /*}}}************************************************************************/
313 /*{{{ sim_addMeasSlopeWithoutNameCheck() */
314 /* */
315 /* */
316 /****************************************************************************/
317 void sim_addMeasSlopeWithoutNameCheck(sim_model *model, char *slope,
318 char *sig, char *transition, int delay_type)
319 {
320 addMeas(model,NULL,slope,NULL,sig,transition,0,delay_type);
321 }
322
323 /*}}}************************************************************************/
324 /*{{{ sim_getMeas() */
325 /* */
326 /* */
327 /****************************************************************************/
328 //int sim_getMeas(sim_model *model, char *label, double *value)
329 //{
330 // return !(mfe_labelvalue(model->LLABELS,namealloc(label),value));
331 //}
332
333 int sim_getMcMeas( sim_model *model, char *label, double *value, int idmc )
334 {
335 int res = 0;
336
337 if( V_BOOL_TAB[__SIM_USE_MEAS].VALUE ) {
338
339 res = mfe_labelvalue(model->LLABELS,label,value,idmc);
340
341 return !res;
342 }
343 else if (V_BOOL_TAB[__SIM_USE_PRINT].VALUE) {
344
345 }
346
347 return 0 ;
348 }
349
350 /*}}}************************************************************************/
351 /*{{{ sim_getMeasSlope() */
352 /* */
353 /* */
354 /****************************************************************************/
355 int sim_getMeasSlope(sim_model *model, char *label, double *value)
356 {
357 return sim_getMeas(model,NULL,label,NULL,value);
358 }
359
360 /*}}}************************************************************************/
361 /*{{{ sim_getMeasDelay() */
362 /* */
363 /* */
364 /****************************************************************************/
365 int sim_getMeasDelay(sim_model *model, char *label, double *value)
366 {
367 return sim_getMeas(model,label,NULL,value,NULL);
368 }
369
370 /*}}}************************************************************************/
371 /*{{{ sim_getMeas() */
372 /* */
373 /* */
374 /****************************************************************************/
375 int sim_getMeas(sim_model *model, char *delay, char *slope,
376 double *dval, double *sval)
377 {
378 if (V_BOOL_TAB[__SIM_USE_MEAS].VALUE)
379 {
380 int res = 0;
381
382 if (delay)
383 res += mfe_labelvalue(model->LLABELS,delay,dval,-1);
384 if (slope)
385 res += mfe_labelvalue(model->LLABELS,slope,sval,-1);
386
387 return !res;
388 }
389 else if (V_BOOL_TAB[__SIM_USE_PRINT].VALUE)
390 {
391 sim_meas_print *prnx;
392 int done = 0;
393
394 /* read output file */
395 sim_parse_spiceout(model);
396
397 if (!delay)
398 done ++;
399 else
400 delay = min_namealloc(delay);
401 if (!slope)
402 done ++;
403 else
404 slope = min_namealloc(slope);
405
406 for (prnx = model->LPRN; prnx && done < 2; prnx = prnx->NEXT)
407 if (prnx->LABEL == delay)
408 {
409 *dval = sim_get_trans_delay(model,prnx->DELAY_TYPE,
410 prnx->SIGTYPE[0],prnx->SIGNAME[0],
411 prnx->SIGTYPE[1],prnx->SIGNAME[1],
412 prnx->TRANSITION, prnx->TH_IN, prnx->TH_OUT);
413 done ++;
414 }
415 else if (prnx->LABEL == slope)
416 {
417 *sval = sim_get_trans_slope(model,prnx->DELAY_TYPE,
418 prnx->SIGTYPE[1],prnx->SIGNAME[1],
419 prnx->TRANSITION, prnx->TH_IN, prnx->TH_OUT);
420 done ++;
421 }
422
423 return (done < 2) ? 0 : 1;
424 }
425 else
426 return 0;
427 }
428
429 /*}}}************************************************************************/
430 /*{{{ sim_printMeasCmd() */
431 /* */
432 /* */
433 /****************************************************************************/
434 void sim_printMeasCmd(sim_model *model, FILE *fd)
435 {
436 printMeasCmd_int(fd,(sim_meas_arg *)(model->LARGS));
437 }
438
439 /*}}}************************************************************************/
440 /*}}}************************************************************************/
441 /*{{{ Internal functions */
442 /****************************************************************************/
443 /*{{{ getNodeName() */
444 /* */
445 /* */
446 /****************************************************************************/
447 static inline int getNodeName(sim_model *model, char *signame,
448 char **nodename, char *type)
449 {
450 locon_list *con;
451 losig_list *sig;
452 chain_list *inslist;
453 int res = 1, node;
454 char buf[1024];
455
456 sim_find_by_name(signame,model->FIG,&con,&sig,&inslist);
457
458 if (con)
459 {
460 *type = SIM_IC_LOCON;
461 if (con->PNODE)
462 node = con->PNODE->DATA;
463 else
464 node = sim_run_simu_spice_get_one_node(con->SIG);
465 /* implicit declaration cause it don't have to be there */
466 /* it should be in sim_drive_spice.c */
467 sim_run_simu_spice_name_signal(model,inslist,con->SIG,node,0,buf);
468 *nodename = mbkstrdup(buf);
469 }
470 else if (sig)
471 {
472 *type = SIM_IC_SIGNAL;
473 node = sim_run_simu_spice_get_one_node(sig);
474 sim_run_simu_spice_name_signal(model,inslist,sig,node,0,buf);
475 *nodename = mbkstrdup(buf);
476 }
477 else
478 {
479 fprintf(stderr,"[SIM_WAR] : Problem occured in creating name for %s\n",
480 signame);
481 res = 0;
482 }
483
484 return res;
485 }
486
487 /*}}}************************************************************************/
488 /*{{{ addMeas() */
489 /* */
490 /* */
491 /****************************************************************************/
492 static void addMeas(sim_model *model, char *delay, char *slope,
493 char *sig1, char *sig2, char *transition, int check, int delay_type)
494 {
495 long ntrans[2];
496 double val[2], alim, th_in, th_out, slopelow, slopehigh;
497 char trans[2], *labelname, *sig[2] = {sig1, sig2}, *signame;
498 char sigt[2], buf[2];
499 int i;
500
501 if (!model)
502 return;
503 else
504 {
505 alim = sim_parameter_get_alim(model, 'i');
506 sim_get_THR(model, &th_in, &th_out, &slopelow, &slopehigh);
507 /* make signal name */
508 if (check)
509 {
510 for (i = 0; i < 2; i ++)
511 if (sig[i])
512 {
513 signame = sig[i];
514
515 if (!getNodeName(model,signame,&sig[i],&sigt[i]))
516 {
517 if (i==1) mbkfree(sig[0]);
518 return;
519 }
520 }
521 }
522 else
523 for (i = 0; i < 2; i ++)
524 sig[i] = (sig[i]) ? mbkstrdup(sig[i]) : NULL;
525
526 sim_getTransition(model,transition,trans,ntrans);
527
528 /* add print */
529 if (V_BOOL_TAB[__SIM_USE_PRINT].VALUE)
530 {
531 sim_meas_print *prn;
532
533 if (delay)
534 {
535 labelname = min_namealloc(delay);
536 prn = allocprn(model,labelname,sig1,sig2,sigt,transition,delay_type, th_in, th_out);
537 switch (sigt[0])
538 {
539 case SIM_IC_SIGNAL :
540 sim_measure_set_signal(model,sig1);
541 break;
542 case SIM_IC_LOCON :
543 sim_measure_set_locon(model,sig1);
544 break;
545 }
546 }
547 if (slope)
548 {
549 labelname = min_namealloc(slope);
550 if (!delay)
551 prn = allocprn(model,labelname,sig2,sig2,sigt,transition,delay_type, slopelow, slopehigh);
552 else
553 {
554 if (ntrans[1] == SIM_MEASURE_LAST)
555 sprintf(buf,"%cL",trans[1]);
556 else
557 sprintf(buf,"%c%ld",trans[1],ntrans[1]);
558 prn = allocprn(model,labelname,sig2,sig2,sigt,buf,delay_type,slopelow, slopehigh);
559 }
560 }
561 switch (sigt[1])
562 {
563 case SIM_IC_SIGNAL :
564 sim_measure_set_signal(model,sig2);
565 break;
566 case SIM_IC_LOCON :
567 sim_measure_set_locon(model,sig2);
568 break;
569 }
570 }
571
572 /* add measure */
573 if (V_BOOL_TAB[__SIM_USE_MEAS].VALUE)
574 {
575 if (!SIM_MEAS.CMDSTR)
576 {
577 fprintf(stderr,"[SIM_ERR] : Need a configuration of drive"
578 " rules : simmeascmd\n");
579 mbkexit(1);
580 }
581 else
582 {
583 if (delay)
584 {
585 labelname = min_namealloc(delay);
586 val[0] = th_in;
587 val[1] = th_out;
588 sim_affectMeasCmdArg(model,labelname,
589 sig[0],trans[0],ntrans[0],val[0],
590 sig[1],trans[1],ntrans[1],val[1]);
591 mfe_addlabel(&(model->LLABELS),labelname,model->NBMC);
592 }
593 if (slope)
594 {
595 labelname = min_namealloc(slope);
596 if (!delay)
597 /* sig[1] = mbkstrdup(sig[1]);
598 else*/
599 {
600 trans[1] = trans[0];
601 ntrans[1] = ntrans[0];
602 }
603
604 i = (trans[1] == 'U' || trans[1] == 'u') ? 0 : 1;
605 val[i%2] = slopelow;
606 val[(i+1)%2] = slopehigh;
607
608 sim_affectMeasCmdArg(model,labelname,
609 sig[1],trans[1],ntrans[1],val[0],
610 sig[1],trans[1],ntrans[1],val[1]);
611 mfe_addlabel(&(model->LLABELS),labelname,model->NBMC);
612 }
613 }
614 for (i=0; i<2; i++)
615 if (sig[i]!=NULL) mbkfree(sig[i]);
616 }
617 }
618 }
619
620 /*}}}************************************************************************/
621 /*{{{ sim_getTransition() */
622 /* */
623 /* */
624 /****************************************************************************/
625 int sim_getTransition(sim_model *model, char *trans, char t[2], long n[2])
626 {
627 int i;
628 char *pt;
629
630 for (i = 0, pt = trans; i < 2; i ++)
631 {
632 t[i] = pt[0];
633 if (pt[1] == 'L' || pt[1] == 'l')
634 {
635 n[i] = SIM_MEASURE_LAST;
636 pt = &(pt[2]);
637 }
638 else if (!(n[i] = strtol(&(pt[1]),&pt,10)))
639 n[i] = 1;
640 if (!pt[0])
641 break;
642 }
643
644 switch (sim_parameter_get_tool(model))
645 {
646 }
647
648 return i + 1;
649 }
650
651 /*}}}************************************************************************/
652 /*{{{ printMeasCmd_int() */
653 /* */
654 /* */
655 /****************************************************************************/
656 static void printMeasCmd_int(FILE *fd, sim_meas_arg *arg)
657 {
658 if (arg)
659 {
660 printMeasCmd_int(fd,arg->NEXT);
661 spi_print(fd,arg->REFCMD->CMDSTR,
662 arg->ARG[SIM_MEAS.ARGORDER[0]],
663 arg->ARG[SIM_MEAS.ARGORDER[1]],
664 arg->ARG[SIM_MEAS.ARGORDER[2]],
665 arg->ARG[SIM_MEAS.ARGORDER[3]],
666 arg->ARG[SIM_MEAS.ARGORDER[4]],
667 arg->ARG[SIM_MEAS.ARGORDER[5]],
668 arg->ARG[SIM_MEAS.ARGORDER[6]],
669 arg->ARG[SIM_MEAS.ARGORDER[7]],
670 arg->ARG[SIM_MEAS.ARGORDER[8]]);
671 }
672 }
673
674 /*}}}************************************************************************/
675 /*{{{ existMeasArg() */
676 /* */
677 /* */
678 /****************************************************************************/
679 static int existMeasArg(sim_model *model, sim_meas_arg **arg, char *label)
680 {
681 for (*arg = model->LARGS; *arg; *arg = (*arg)->NEXT)
682 if ((*arg)->ARG[SIM_MEAS_LABEL] == label)
683 break;
684
685 return ((*arg) != NULL);
686 }
687
688 /*}}}************************************************************************/
689 /*{{{ freeMeasArg_int() */
690 /* */
691 /* */
692 /****************************************************************************/
693 static void freeMeasArg_int(sim_meas_arg *arg)
694 {
695 int i;
696 for (i = 0; i < SIM_MEAS_NBSIG; i ++)
697 {
698 if (arg->ARG[SIM_MEAS_VALUE + SIM_MEAS_A4S*i]!=NULL) mbkfree(arg->ARG[SIM_MEAS_VALUE + SIM_MEAS_A4S*i]);
699 }
700 for (i = 0; i < SIM_MEAS_NBSIG; i ++)
701 {
702 if (arg->ARG[SIM_MEAS_NTRANS + SIM_MEAS_A4S*i]!=NULL) mbkfree(arg->ARG[SIM_MEAS_NTRANS + SIM_MEAS_A4S*i]);
703 }
704 // mbkfree(arg->ARG[SIM_MEAS_NTRANS + SIM_MEAS_A4S]);
705 /* mbkfree(arg->ARG[SIM_MEAS_VALUE]);
706 mbkfree(arg->ARG[SIM_MEAS_VALUE + SIM_MEAS_A4S]);*/
707
708 if (arg->ARG[SIM_MEAS_SIG + SIM_MEAS_A4S] == arg->ARG[SIM_MEAS_SIG])
709 {
710 /* case of slope */
711 //mbkfree(arg->ARG[SIM_MEAS_NTRANS]);
712 mbkfree(arg->ARG[SIM_MEAS_SIG]);
713 }
714 else
715 {
716 /* case of delay */
717 // mbkfree(arg->ARG[SIM_MEAS_NTRANS]);
718 mbkfree(arg->ARG[SIM_MEAS_SIG]);
719 mbkfree(arg->ARG[SIM_MEAS_SIG + SIM_MEAS_A4S]);
720 }
721 }
722
723 /*}}}************************************************************************/
724 /*{{{ allocprn() */
725 /* */
726 /* */
727 /****************************************************************************/
728 static sim_meas_print *allocprn(sim_model *model, char *label, char *sig1,
729 char *sig2, char sigt[2], char *transition, int delay_type, SIM_FLOAT th_in, SIM_FLOAT th_out)
730 {
731 sim_meas_print *prn;
732
733 prn = mbkalloc(sizeof(sim_meas_print));
734
735 prn->NEXT = model->LPRN;
736 prn->LABEL = label;
737 prn->SIGNAME[0] = sig1;
738 prn->SIGNAME[1] = sig2;
739 prn->SIGTYPE[0] = sigt[0];
740 prn->SIGTYPE[1] = sigt[1];
741 prn->TRANSITION = mbkstrdup(transition);
742 prn->DELAY_TYPE = delay_type;
743 prn->TH_IN=th_in;
744 prn->TH_OUT=th_out;
745 model->LPRN = prn;
746
747 return prn;
748 }
749
750 /*}}}************************************************************************/
751 /*{{{ freePrn() */
752 /* */
753 /* */
754 /****************************************************************************/
755 static sim_meas_print *freePrn(sim_meas_print *prn)
756 {
757 if (prn)
758 {
759 sim_meas_print *res;
760
761 res = freePrn(prn->NEXT);
762 mbkfree(prn->TRANSITION);
763 mbkfree(prn);
764
765 return res;
766 }
767 return NULL;
768 }
769
770 /*}}}************************************************************************/
771 /*}}}************************************************************************/
772 #if 0
773 /*{{{ Test function for sim_meas */
774 /* */
775 /* /usr/local/bin/gcc -o main -L/users/disk01/antony/dev/Solaris/lib -Xlinker -z -Xlinker allextract -lSim100 -lTut100 -lSim100 -lGsp100 -lEfg100 -lCbh100 -lEqt100 -lTrc102 -lTlc100 -lApi100 -lInf112 -lCns211 -lElp110 -lAvt100 -lMlu501 -lMcl413 -lMal100 -lMsl700 -lMgl100 -lMvl409 -lMel407 -lMhl403 -lMlo501 -lSpf100 -lSpe100 -lBef100 -lBgl100 -lBvl202 -lBeg100 -lBhl110 -lBeh110 -llog202 -lRcn200 -lMut325 -lstdc++ -lnsl -ldl -lm -Xlinker -z -Xlinker defaultextract */
776 /* */
777 /****************************************************************************/
778 int main()
779 {
780 sim_model model[4];
781
782 memset(model,0,sizeof(sim_model) * 4);
783
784 sim_decodeMeasCmd(".meas tran %l"
785 " TRIG v(%s1) val=%v1 %t1{rise1,fall1}=%n1{LAST1}"
786 " TARG v(%s2) val=%v2 %t2{rise2,fall2}=%n2{LAST2}");
787 sim_affectMeasCmdArg(&model[0],"test1","a",'U',15,1.5,"b",'D',16,1.6);
788 printf("-**** test 1 ****-\n");
789 sim_printMeasCmd(&model[0],stdout);
790
791 sim_decodeMeasCmd(".measure tran %l"
792 " TRIG v(%s1) TARG v(%s2)"
793 " val=%v1 val=%v2"
794 " %t1{rise1,fall1}=%n5{LAST1} %y2{rise2,fall2}=%n2{LAST2}");
795 sim_affectMeasCmdArg(&model[1],"test2","a",'U',15,1.5,"b",'D',16,1.6);
796 printf("-**** test 2 ****-\n");
797 sim_printMeasCmd(&model[1],stdout);
798
799 sim_decodeMeasCmd(".measure tran"
800 " val=%v1 val=%v2"
801 " TRIG v(%s1) TARG v(%s2)"
802 " %t1{rise1,fall1}=%n1{LAST1} %t2{rise2,fall2}=%n2{LAST2} %l");
803 sim_affectMeasCmdArg(&model[2],"test3","a",'D',SIM_MEASURE_LAST,1.5,"b",'D',25,1.6);
804 printf("-**** test 3 ****-\n");
805 sim_printMeasCmd(&model[2],stdout);
806
807 sim_decodeMeasCmd(".meas tran %l"
808 " TRIG v(%s1) val=%v1 %t1{rise1,fall1}=%n1{LAST1}"
809 " TARG v(%s2) val=%v2 %t2{rise2,fall2}=%n2{LAST2}");
810 sim_affectMeasCmdArg(&model[3],"test4","a",'U',1 ,1.5,"b",'D',16,1.6);
811 sim_affectMeasCmdArg(&model[3],"test5","b",'U',SIM_MEASURE_LAST,1.5,"c",'D',17,1.7);
812 sim_affectMeasCmdArg(&model[3],"test6","a",'D',1 ,1.5,"b",'U',18,1.4);
813 sim_affectMeasCmdArg(&model[3],"test7","a",'D',1 ,1.5,"c",'D',19,1.5);
814 sim_freeMeasArg(&model[3],"test4");
815 sim_freeMeasAllArg(&model[3]);
816 printf("-**** test 4 ****-\n");
817 sim_printMeasCmd(&model[3],stdout);
818 sim_printMeasCmd(&model[2],stdout);
819
820 return 0;
821 }
822
823 /*}}}************************************************************************/
824 #endif