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 / behvhdl / bvl_bspec.c
1 /* ###--------------------------------------------------------------### */
2 /* file : bvl_bspec.c */
3 /* date : Jan 18 1993 */
4 /* version : v106 */
5 /* authors : Pirouz BAZARGAN SABET, VUONG Huu Nghia */
6 /* content : contains all specific functions used to build */
7 /* behaviour data structures : */
8 /* bvl_addgen , bvl_tobin , bvl_cpyabllst, */
9 /* bvl_cpyablstr, bvl_crtabl, bvl_select */
10 /* ###--------------------------------------------------------------### */
11
12 #include <stdio.h>
13 #include <string.h>
14 #include MUT_H
15 #include LOG_H
16 #include BEH_H
17
18 #include "bvl_util.h"
19 #include "bvl_byacc.h"
20 #include "bvl_bspec.h"
21 #include "bvl_bedef.h"
22
23 /* ###--------------------------------------------------------------### */
24 /* function : bvl_addgen */
25 /* description : create one or more BEGEN structures */
26 /* For a scalar a BEGEN is created at the head of */
27 /* existing BEGEN list. */
28 /* For an array (including arraies of one element) a set */
29 /* of BEGENs are created in a sorted list. BEGEN related */
30 /* to the index i of the array is named `name(i)`. The */
31 /* head of the list represents the right bound of the */
32 /* array. This list is then chained to the head of */
33 /* existing BEGEN list. */
34 /* called func. : beh_addbegen, namealloc */
35 /* ###--------------------------------------------------------------### */
36
37 struct begen *
38 bvl_addgen (struct begen *lastgeneric, chain_list *nat_lst, chain_list *nam_lst, char *type, short left, short right)
39
40 /* pointer on the last begen structure */
41 /* generic's value list */
42 /* generic's name list */
43 /* generic's type */
44 /* array's left bound (= -1 if scalar) */
45 /* array's right bound (= -1 if scalar) */
46
47 {
48 char extname[100];
49 char *name;
50 struct begen *ptgen;
51 struct chain *ptauxnam;
52 struct chain *ptauxnat;
53 int i;
54 int inc = 1;
55
56 ptgen = lastgeneric;
57 ptauxnam = nam_lst;
58 ptauxnat = nat_lst;
59
60 if ((left == -1) && (right == -1))
61 if ((ptauxnat != NULL) && (ptauxnat->NEXT == NULL))
62 while (ptauxnam != NULL)
63 {
64 name = namealloc((char *)ptauxnam->DATA);
65 ptgen = beh_addbegen (ptgen,name,type,(void *)ptauxnat->DATA);
66 ptauxnam = ptauxnam->NEXT;
67 }
68 else
69 bvl_error(75,NULL);
70 else
71 {
72 if (left >= right)
73 inc = -1;
74 while (ptauxnam != NULL)
75 {
76 for (i=left ; i!=(right+inc) ; i+=inc)
77 {
78 sprintf (extname,"%s %d",(char *)ptauxnam->DATA,i);
79 name = namealloc(extname);
80 if (ptauxnat != NULL)
81 {
82 ptgen = beh_addbegen (ptgen,name,type,(void *)ptauxnat->DATA);
83 ptauxnat = ptauxnat->NEXT;
84 }
85 else
86 bvl_error(75,NULL);
87 }
88 if (ptauxnat != NULL)
89 bvl_error (75,NULL);
90 ptauxnat = nat_lst;
91 ptauxnam = ptauxnam->NEXT;
92 }
93 }
94 return (ptgen);
95 }
96
97 /* ###--------------------------------------------------------------### */
98 /* function : bvl_cpyabllst */
99 /* description : duplicate bvl_abllst structure */
100 /* called func. : addchain, reverse, copyExpr */
101 /* ###--------------------------------------------------------------### */
102
103 chain_list *
104 bvl_cpyabllst (chain_list *abllst)
105 {
106 struct chain *ptabllst = NULL;
107
108 while (abllst != NULL)
109 {
110 ptabllst = addchain (ptabllst,copyExpr((struct chain *)abllst->DATA));
111 abllst = abllst->NEXT;
112 }
113 ptabllst = reverse (ptabllst);
114 return (ptabllst);
115 }
116
117 /* ###--------------------------------------------------------------### */
118 /* function : bvl_cpyablstr */
119 /* description : duplicate bvlexpr structure */
120 /* called func. : mbkalloc <mbk>, bvl_cpyabllst */
121 /* ###--------------------------------------------------------------### */
122
123 bvlexpr
124 bvl_cpyablstr (bvlexpr ablstr)
125 {
126 bvlexpr ptablstr;
127
128 ptablstr.IDENT = NULL;
129 ptablstr.WIDTH = ablstr.WIDTH;
130 ptablstr.LIST_ABL = bvl_cpyabllst (ablstr.LIST_ABL);
131 return (ptablstr);
132 }
133
134 /* ###--------------------------------------------------------------### */
135 /* function : bvl_crtabl */
136 /* description : combine at most two ABLs and build a new one */
137 /* The following operations can be performed : */
138 /* CONC perform concatenation */
139 /* NOPI initialize a structure for a signal (scalar */
140 /* or array) */
141 /* NOPS initialize a structure for a literal */
142 /* NE create a structure with an ABL representing */
143 /* the 'non equality' of two expressions */
144 /* EQ create a structure with an ABL representing */
145 /* the 'equality' of two expressions */
146 /* NOT perform logical not of an expression */
147 /* AND perform logical and between two expressions*/
148 /* OR perform logical or between two expressions*/
149 /* NAND perform logical nand between two expressions*/
150 /* NOR perform logical nor between two expressions*/
151 /* XOR perform logical xor between two expressions*/
152 /* ANDM perform logical and between two expressions*/
153 /* (the second expression is a scalar) */
154 /* called func. : createAtom , createExpr, addQExpr , beh_toolbug, */
155 /* bvl_error , addchain , freechain */
156 /* ###--------------------------------------------------------------### */
157
158 bvlexpr
159 bvl_crtabl (short oper, bvlexpr expr1, bvlexpr expr2, int left, int right)
160 {
161 char name[256];
162 char *name2;
163 struct chain *ptabl1;
164 struct chain *ptabl2;
165 struct chain *ptaux1;
166 struct chain *ptaux2;
167 bvlexpr result;
168 char lcl_buffer[256];
169 short inc;
170 short i;
171 char true_flag_un = 0;
172 char true_flag_zero = 0;
173 struct chain *abl_un = createAtom("'1'");
174 struct chain *abl_zero = createAtom("'0'");
175
176 result.IDENT = NULL;
177 result.TIME = 0 ;
178 result.LIST_ABL = NULL;
179 result.WIDTH = 0 ;
180
181 switch (oper)
182 {
183 case CONC :
184 if ((expr1.LIST_ABL == NULL) || (expr2.LIST_ABL == NULL))
185 beh_toolbug (4,"bvl_crtabl",NULL,0);
186 else
187 {
188 if (expr1.LIST_ABL == expr2.LIST_ABL)
189 beh_toolbug (16,"bvl_crtabl",NULL,0);
190 else
191 {
192 ptaux2 = expr2.LIST_ABL;
193 while (ptaux2->NEXT != NULL)
194 ptaux2 = ptaux2->NEXT;
195
196 ptaux2->NEXT = expr1.LIST_ABL;
197
198 result.LIST_ABL = expr2.LIST_ABL;
199 result.WIDTH = expr1.WIDTH + expr2.WIDTH;
200
201 expr1.LIST_ABL = NULL;
202 expr2.LIST_ABL = NULL;
203 }
204 }
205 break;
206
207 case NOPI :
208 if ( expr1.IDENT == NULL )
209 beh_toolbug (2,"bvl_crtabl",NULL,0);
210 else
211 {
212 if ((left == -1) && (right == -1))
213 {
214 result.LIST_ABL = addchain(result.LIST_ABL,createAtom(expr1.IDENT));
215 result.WIDTH = 1;
216 }
217 else
218 {
219 if (left <= right)
220 {
221 inc = 1;
222 result.WIDTH = right - left + 1;
223 }
224 else
225 {
226 inc = -1;
227 result.WIDTH = left - right + 1;
228 }
229
230 for (i=left ; i!=(right+inc) ; i+=inc)
231 {
232 sprintf (name,"%s %i",expr1.IDENT,i);
233 name2 = namealloc (name);
234 result.LIST_ABL = addchain (result.LIST_ABL,createAtom(name2));
235 }
236 }
237 expr1.IDENT = NULL;
238 }
239 break;
240
241 case NOPS :
242 if ( expr1.IDENT == NULL )
243 beh_toolbug (2,"bvl_crtabl",NULL,0);
244 else
245 {
246 bvl_tobin (lcl_buffer,expr1.IDENT,-1,-1);
247 if ((left == -1) && (right == -1))
248 {
249 left = 0;
250 right = strlen (lcl_buffer) - 1;
251 }
252
253 for (i=left ; i<=right ; i++)
254 {
255 switch ( lcl_buffer[i] )
256 {
257 case '0' :
258 result.LIST_ABL = addchain (result.LIST_ABL,createAtom("'0'"));
259 break;
260 case '1' :
261 result.LIST_ABL = addchain (result.LIST_ABL,createAtom("'1'"));
262 break;
263 case 'z' :
264 result.LIST_ABL = addchain (result.LIST_ABL,createAtom("'Z'"));
265 break;
266 case 'u' :
267 result.LIST_ABL = addchain (result.LIST_ABL,createAtom("'U'"));
268 break;
269 /*----------- Beware Not VHDL -------------*/
270 case 'd' :
271 result.LIST_ABL = addchain (result.LIST_ABL,createAtom("'D'"));
272 break;
273 default :
274 beh_toolbug (15,"bvl_crtabl",NULL,expr1.IDENT[i]);
275 }
276 }
277 result.WIDTH = right - left + 1;
278 }
279 break;
280
281 case STABLE :
282 if (expr1.LIST_ABL == NULL)
283 beh_toolbug (3,"bvl_crtabl",NULL,0);
284 else
285 {
286 ptaux1 = expr1.LIST_ABL;
287 while (ptaux1 != NULL)
288 {
289 ptabl1 = createExpr (STABLE);
290 addQExpr (ptabl1, (struct chain *)ptaux1->DATA);
291 ptaux1->DATA = ptabl1;
292 ptaux1 = ptaux1->NEXT;
293 }
294
295 result.LIST_ABL = expr1.LIST_ABL;
296 result.WIDTH = expr1.WIDTH;
297
298 expr1.LIST_ABL = NULL;
299 }
300 break;
301
302 case NOT :
303 if (expr1.LIST_ABL == NULL)
304 beh_toolbug (3,"bvl_crtabl",NULL,0);
305 else
306 {
307 ptaux1 = expr1.LIST_ABL;
308 while (ptaux1 != NULL)
309 {
310 ptabl1 = createExpr (NOT);
311 addQExpr (ptabl1, (struct chain *)ptaux1->DATA);
312 ptaux1->DATA = ptabl1;
313 ptaux1 = ptaux1->NEXT;
314 }
315
316 result.LIST_ABL = expr1.LIST_ABL;
317 result.WIDTH = expr1.WIDTH;
318
319 expr1.LIST_ABL = NULL;
320 }
321 break;
322
323 case EQ :
324 if ((expr1.LIST_ABL == NULL) || (expr2.LIST_ABL == NULL))
325 beh_toolbug (4,"bvl_crtabl",NULL,0);
326 else
327 {
328 if (expr1.WIDTH != expr2.WIDTH)
329 {
330 bvl_error (38,NULL);
331 ptabl2 = createAtom ("'1'");
332
333 ptaux1 = expr1.LIST_ABL;
334 while (ptaux1 != NULL)
335 {
336 freeExpr (ptaux1->DATA);
337 ptaux1 = ptaux1->NEXT;
338 }
339 ptaux2 = expr2.LIST_ABL;
340 while (ptaux2 != NULL)
341 {
342 freeExpr (ptaux2->DATA);
343 ptaux2 = ptaux2->NEXT;
344 }
345 }
346 else
347 {
348 ptaux1 = expr1.LIST_ABL;
349 ptaux2 = expr2.LIST_ABL;
350 /* If expr2 = '1' then return expr1 */
351 while(ptaux2 != NULL)
352 {
353 true_flag_un = 1;
354 if(!equalExpr(ptaux2->DATA,abl_un))
355 {
356 /* One abl not abl_un */
357 true_flag_un = 0;
358 break;
359 }
360 ptaux2 = ptaux2->NEXT;
361 }
362 if(true_flag_un == 1)
363 {
364 ptabl1 = (struct chain *)ptaux1->DATA;
365 ptaux1 = ptaux1->NEXT;
366 if(ptaux1 != NULL)
367 {
368 ptabl2 = createExpr(AND);
369 addQExpr(ptabl2,ptabl1);
370 ptabl1 = ptabl2;
371 }
372 while(ptaux1 != NULL)
373 {
374 addQExpr(ptabl1,(struct chain *)ptaux1->DATA);
375 ptaux1 = ptaux1->NEXT;
376 }
377 result.LIST_ABL = addchain(result.LIST_ABL,ptabl1);
378 result.WIDTH = 1;
379 expr1.LIST_ABL = NULL;
380 expr2.LIST_ABL = NULL;
381 }
382 /* If expr2 = '0' then return NOT(expr1) */
383 ptaux2 = expr2.LIST_ABL;
384 true_flag_zero = 0;
385 while(ptaux2 != NULL)
386 {
387 true_flag_zero = 1;
388 if(!equalExpr(ptaux2->DATA,abl_zero))
389 {
390 /* One abl not abl_zero */
391 true_flag_zero = 0;
392 break;
393 }
394 ptaux2 = ptaux2->NEXT;
395 }
396 if(true_flag_zero == 1)
397 {
398 while(ptaux1 != NULL)
399 {
400 ptabl1 = createExpr(NOT);
401 addQExpr(ptabl1,(struct chain *)ptaux1->DATA);
402 ptaux1 = ptaux1->NEXT;
403 if(ptaux1 != NULL)
404 {
405 ptabl2 = createExpr(AND);
406 addQExpr(ptabl2,ptabl1);
407 ptabl1 = ptabl2;
408 }
409 while(ptaux1 != NULL)
410 {
411 ptabl2 = createExpr(NOT);
412 addQExpr(ptabl2,(struct chain *)ptaux1->DATA);
413 addQExpr(ptabl1,ptabl2);
414 ptaux1 = ptaux1->NEXT;
415 }
416 /* --ptabl1 = createExpr(NOT);
417 addQExpr(ptabl1,(struct chain *)ptaux1->DATA);
418 ptaux1->DATA = ptabl1;
419 ptaux1 = ptaux1->NEXT;
420 --- */
421 }
422 result.LIST_ABL = addchain(result.LIST_ABL,ptabl1);
423 result.WIDTH = 1;
424 expr1.LIST_ABL = NULL;
425 expr2.LIST_ABL = NULL;
426 }
427
428
429 ptaux2 = expr2.LIST_ABL;
430 if((true_flag_zero == 0) && (true_flag_un == 0))
431 {
432 ptabl1 = createExpr (XOR);
433 addQExpr (ptabl1, (struct chain *)ptaux1->DATA);
434 addQExpr (ptabl1, (struct chain *)ptaux2->DATA);
435
436 ptaux1 = ptaux1->NEXT;
437 ptaux2 = ptaux2->NEXT;
438
439 while (ptaux1 != NULL)
440 {
441 ptabl2 = createExpr (OR);
442 addQExpr (ptabl2,ptabl1);
443
444 ptabl1 = createExpr (XOR);
445 addQExpr (ptabl1, (struct chain *)ptaux1->DATA);
446 addQExpr (ptabl1, (struct chain *)ptaux2->DATA);
447
448 addQExpr (ptabl2, ptabl1);
449 ptabl1 = ptabl2;
450
451 ptaux1 = ptaux1->NEXT;
452 ptaux2 = ptaux2->NEXT;
453 }
454 ptabl2 = createExpr (NOT);
455 addQExpr (ptabl2, ptabl1);
456
457 result.LIST_ABL = addchain (result.LIST_ABL,ptabl2);
458 result.WIDTH = 1;
459 freechain (expr1.LIST_ABL);
460 freechain (expr2.LIST_ABL);
461 expr1.LIST_ABL = NULL;
462 expr2.LIST_ABL = NULL;
463 }
464 }
465 }
466 break;
467
468 case NE :
469
470 if ((expr1.LIST_ABL == NULL) || (expr2.LIST_ABL == NULL))
471 beh_toolbug (4,"bvl_crtabl",NULL,0);
472 else
473 {
474 if (expr1.WIDTH != expr2.WIDTH)
475 {
476 bvl_error(38,NULL);
477 ptabl1 = createAtom ("'1'");
478
479 ptaux1 = expr1.LIST_ABL;
480 while (ptaux1 != NULL)
481 {
482 freeExpr (ptaux1->DATA);
483 ptaux1 = ptaux1->NEXT;
484 }
485 ptaux2 = expr2.LIST_ABL;
486 while (ptaux2 != NULL)
487 {
488 freeExpr (ptaux2->DATA);
489 ptaux2 = ptaux2->NEXT;
490 }
491 }
492 else
493 {
494 ptaux1 = expr1.LIST_ABL;
495 ptaux2 = expr2.LIST_ABL;
496
497 /* If expr2 = '0' then return expr1 */
498 while(ptaux2 != NULL)
499 {
500 true_flag_zero = 1;
501 if(!equalExpr(ptaux2->DATA,abl_zero))
502 {
503 /* One abl not abl_zero */
504 true_flag_zero = 0;
505 break;
506 }
507 ptaux2 = ptaux2->NEXT;
508 }
509 if(true_flag_zero == 1)
510 {
511 result.LIST_ABL = expr1.LIST_ABL;
512 result.WIDTH = 1;
513 expr1.LIST_ABL = NULL;
514 expr2.LIST_ABL = NULL;
515 }
516 /* If expr2 = '1' then return NOT(expr1) */
517 ptaux2 = expr2.LIST_ABL;
518 true_flag_un = 0;
519 while(ptaux2 != NULL)
520 {
521 true_flag_un = 1;
522 if(!equalExpr(ptaux2->DATA,abl_un))
523 {
524 /* One abl not abl_un */
525 true_flag_un = 0;
526 break;
527 }
528 ptaux2 = ptaux2->NEXT;
529 }
530 if(true_flag_un == 1)
531 {
532 while(ptaux1 != NULL)
533 {
534 ptabl1 = createExpr(NOT);
535 addQExpr(ptabl1,(struct chain *)ptaux1->DATA);
536 ptaux1->DATA = ptabl1;
537 ptaux1 = ptaux1->NEXT;
538 }
539 result.LIST_ABL = expr1.LIST_ABL;
540 result.WIDTH = 1;
541 expr1.LIST_ABL = NULL;
542 expr2.LIST_ABL = NULL;
543 }
544
545
546 ptaux2 = expr2.LIST_ABL;
547 if((true_flag_zero == 0) && (true_flag_un == 0))
548 {
549 ptabl1 = createExpr (XOR);
550 addQExpr (ptabl1, (struct chain *)ptaux1->DATA);
551 addQExpr (ptabl1, (struct chain *)ptaux2->DATA);
552
553 ptaux1 = ptaux1->NEXT;
554 ptaux2 = ptaux2->NEXT;
555
556 for (i=2 ; i<=expr1.WIDTH ; i++)
557 {
558 ptabl2 = createExpr (OR);
559 addQExpr (ptabl2, ptabl1);
560
561 ptabl1 = createExpr (XOR);
562 addQExpr (ptabl1, (struct chain *)ptaux1->DATA);
563 addQExpr (ptabl1, (struct chain *)ptaux2->DATA);
564
565 addQExpr (ptabl2, ptabl1);
566 ptabl1 = ptabl2;
567
568 ptaux1 = ptaux1->NEXT;
569 ptaux2 = ptaux2->NEXT;
570 }
571 result.LIST_ABL = addchain(result.LIST_ABL,ptabl1);
572 result.WIDTH = 1;
573 freechain (expr1.LIST_ABL);
574 freechain (expr2.LIST_ABL);
575 expr1.LIST_ABL = NULL;
576 expr2.LIST_ABL = NULL;
577 }
578 }
579 }
580 break;
581
582 case AND :
583 case NAND :
584 case OR :
585 case NOR :
586 case XOR :
587
588 if (expr1.LIST_ABL == NULL)
589 {
590 if (expr2.LIST_ABL == NULL)
591 beh_toolbug (4,"bvl_crtabl",NULL,0);
592 else
593 {
594 result.LIST_ABL = expr2.LIST_ABL;
595 result.WIDTH = expr2.WIDTH;
596 expr2.LIST_ABL = NULL;
597 }
598 }
599 else
600 {
601 if (expr2.LIST_ABL == NULL)
602 {
603 result.LIST_ABL = expr1.LIST_ABL;
604 result.WIDTH = expr1.WIDTH;
605 expr1.LIST_ABL = NULL;
606 }
607 else
608 {
609 if (expr1.LIST_ABL == expr2.LIST_ABL)
610 beh_toolbug (16,"bvl_crtabl",NULL,0);
611 else
612 {
613 if (expr1.WIDTH != expr2.WIDTH)
614 {
615 bvl_error(38,NULL);
616 }
617 else
618 {
619 ptaux1 = expr1.LIST_ABL;
620 ptaux2 = expr2.LIST_ABL;
621
622 for (i=1 ; i<=expr1.WIDTH ; i++)
623 {
624 ptabl1 = createExpr (oper);
625 addQExpr (ptabl1, (struct chain *)ptaux1->DATA);
626 addQExpr (ptabl1, (struct chain *)ptaux2->DATA);
627
628 ptaux1->DATA = (void *)ptabl1;
629
630 ptaux1 = ptaux1->NEXT;
631 ptaux2 = ptaux2->NEXT;
632 }
633 }
634 result.LIST_ABL = expr1.LIST_ABL;
635 result.WIDTH = expr1.WIDTH;
636 freechain (expr2.LIST_ABL);
637 expr1.LIST_ABL = NULL;
638 expr2.LIST_ABL = NULL;
639 }
640 }
641 }
642 break;
643
644 case ANDM :
645 if ((expr1.LIST_ABL == NULL) || (expr2.LIST_ABL == NULL))
646 beh_toolbug (4,"bvl_crtabl",NULL,0);
647 else
648 {
649 if (expr2.WIDTH != 1)
650 {
651 bvl_error( 38,NULL);
652 }
653 else
654 {
655 ptaux1 = expr1.LIST_ABL;
656 ptaux2 = expr2.LIST_ABL;
657 while (ptaux1 != NULL)
658 {
659 ptabl1 = createExpr (AND);
660 addQExpr (ptabl1, (struct chain *)ptaux1->DATA);
661 addQExpr (ptabl1, copyExpr((struct chain *)ptaux2->DATA));
662 ptaux1->DATA = (void *)ptabl1;
663
664 ptaux1 = ptaux1->NEXT;
665 }
666 }
667 result.LIST_ABL = expr1.LIST_ABL;
668 result.WIDTH = expr1.WIDTH;
669 ptaux2 = expr2.LIST_ABL;
670 while (ptaux2 != NULL)
671 {
672 freeExpr (ptaux2->DATA);
673 ptaux2 = ptaux2->NEXT;
674 }
675 freechain (expr2.LIST_ABL);
676 expr2.LIST_ABL = NULL;
677 expr1.LIST_ABL = NULL;
678 }
679 break;
680
681 default :
682 beh_toolbug (1,"bvl_crtabl",NULL,0);
683 }
684
685 /* may be cleaner */
686 freeExpr(abl_un);
687 freeExpr(abl_zero);
688
689 return (result);
690 }
691
692 /* ###--------------------------------------------------------------### */
693 /* function : bvl_select */
694 /* description : create an abl representing the choice in a selected */
695 /* signal assignment and perform unicity verification */
696 /* using BDDs. */
697 /* called func. : bvl_tobin , bddToAbl , addInputCct , */
698 /* substPhyExpr, initializeCct, createNodeTermBdd, */
699 /* bvl_error , notBdd , applyBinBdd , */
700 /* addchain , namealloc */
701 /* ###--------------------------------------------------------------### */
702
703 void
704 bvl_select (bvlexpr *result, chain_list *ptstr, pNode *ptbdd, bvlexpr ptablstr)
705 {
706 char binstr[256];
707 int i;
708 struct chain *ptauxabl;
709 pNode ptbddres;
710 pNode ptbddnew;
711 pNode ptbddtmp;
712 pNode ptbddaux;
713 char nomvar[10];
714 struct chain *ptnewabl;
715 struct chain *ptnewabl2;
716 static int oth_flg=0;
717 static int last_width=0;
718 static pCircuit pC = NULL;
719
720 result->LIST_ABL = NULL;
721 result->IDENT = NULL;
722
723 ptbddtmp = BDD_zero;
724
725 if (pC == NULL)
726 pC = initializeCct ("-select-",200,0);
727
728 if (*ptbdd == NULL)
729 {
730 if (last_width < ptablstr.WIDTH)
731 {
732 for (; last_width<ptablstr.WIDTH ; last_width++)
733 {
734 sprintf (nomvar,"(%d)",last_width);
735 createNodeTermBdd (addInputCct(pC,nomvar));
736 }
737 }
738 *ptbdd = BDD_zero;
739 oth_flg = 0;
740 }
741
742 while (ptstr != NULL)
743 {
744 bvl_tobin (binstr, (char *)ptstr->DATA,-1,-1);
745 if (oth_flg != 0)
746 {
747 bvl_error(30,NULL);
748 }
749
750 if (strcmp("others", (char *)ptstr->DATA))
751 {
752 ptbddres = BDD_one;
753
754 if (strlen (binstr) != (size_t)ptablstr.WIDTH)
755 {
756 bvl_error(38,NULL);
757 }
758 for (i=0 ; binstr[i]!='\0' ; i++)
759 {
760 ptbddaux = createNodeTermBdd (i+2);
761 if (binstr[i] == '0')
762 ptbddaux = notBdd (ptbddaux);
763 ptbddres = applyBinBdd (AND, ptbddaux, ptbddres);
764 }
765 ptbddnew = applyBinBdd (OR,*ptbdd,ptbddres);
766
767 if (*ptbdd == ptbddnew)
768 {
769 bvl_error(28,NULL);
770 }
771
772 *ptbdd = ptbddnew;
773 }
774 else
775 {
776 oth_flg = 1;
777 ptbddres = notBdd (*ptbdd);
778 *ptbdd = BDD_one;
779 }
780 ptbddtmp = applyBinBdd (OR,ptbddtmp,ptbddres);
781 ptstr = ptstr->NEXT;
782 }
783
784 ptnewabl = bddToAbl (ptbddtmp, pC->pNameI);
785
786 ptauxabl = ptablstr.LIST_ABL;
787 i = ptablstr.WIDTH - 1;
788 while (ptauxabl != NULL)
789 {
790 sprintf (nomvar,"(%i)",i);
791 /*--------
792 substPhyExpr (ptnewabl,namealloc(nomvar),(struct chain *)ptauxabl->DATA);
793 ---------*/
794 ptnewabl2 = substExpr (ptnewabl,namealloc(nomvar),
795 (struct chain *)ptauxabl->DATA);
796 freeExpr (ptnewabl);
797 ptnewabl = ptnewabl2;
798
799 i--;
800 ptauxabl = ptauxabl->NEXT;
801 }
802 result->LIST_ABL = addchain (NULL, ptnewabl);
803 result->WIDTH = 1;
804
805 }
806
807 /* ###--------------------------------------------------------------### */
808 /* function : bvl_tobin */
809 /* description : transform a StringLit, BitStringLit or CharacterLit */
810 /* in a string of '0' and '1's */
811 /* ###--------------------------------------------------------------### */
812
813 int
814 bvl_tobin (char *trg, char *src, int left, int right)
815 {
816 char base;
817 int indx;
818 int j = 0;
819 int errflg = 0;
820 char lcl_trg[256];
821
822 lcl_trg[0] = '\0';
823
824 if (src == NULL)
825 {
826 strcpy (trg,"0");
827 }
828 else
829 {
830 if (!strcmp (src,"others"))
831 {
832 strcpy(trg,src);
833 }
834 else
835 {
836 if ((src[0] != '\'') && (src[0] != '"') && (src[0] != '%'))
837 {
838 base = src[0];
839 indx = 2;
840 }
841 else
842 {
843 base = 'B';
844 indx = 1;
845 }
846
847 switch (base)
848 {
849 case 'B' :
850 case 'b' :
851 while ((lcl_trg[j] = src[indx]) != '\0')
852 {
853 switch (src[indx])
854 {
855 case '0':
856 case '1':
857 case 'z':
858 case 'u':
859 case 'd': /* Beware Not VHDL */
860 j++; break;
861
862 case '%' :
863 case '"' :
864 case '\'':
865 case '_' :
866 break;
867
868 default :
869 errflg = 1; bvl_error(73,src);
870 }
871 indx++;
872 }
873 break;
874
875 case 'O' :
876 case 'o' :
877 while (src[indx] != '\0')
878 {
879 j += 3;
880 switch (src[indx])
881 {
882 case '0' :
883 strcat (lcl_trg,"000"); break;
884 case '1' :
885 strcat (lcl_trg,"001"); break;
886 case '2' :
887 strcat (lcl_trg,"010"); break;
888 case '3' :
889 strcat (lcl_trg,"011"); break;
890 case '4' :
891 strcat (lcl_trg,"100"); break;
892 case '5' :
893 strcat (lcl_trg,"101"); break;
894 case '6' :
895 strcat (lcl_trg,"110"); break;
896 case '7' :
897 strcat (lcl_trg,"111"); break;
898 case '"' :
899 case '%' :
900 case '_' :
901 j -= 3; break;
902 default :
903 j -= 3; errflg = 1; bvl_error(73,src);
904 }
905 indx++;
906 }
907 break;
908
909 case 'X' :
910 case 'x' :
911 while (src[indx] != '\0')
912 {
913 j += 4;
914 switch (src[indx])
915 {
916 case '0' :
917 strcat (lcl_trg,"0000"); break;
918 case '1' :
919 strcat (lcl_trg,"0001"); break;
920 case '2' :
921 strcat (lcl_trg,"0010"); break;
922 case '3' :
923 strcat (lcl_trg,"0011"); break;
924 case '4' :
925 strcat (lcl_trg,"0100"); break;
926 case '5' :
927 strcat (lcl_trg,"0101"); break;
928 case '6' :
929 strcat (lcl_trg,"0110"); break;
930 case '7' :
931 strcat (lcl_trg,"0111"); break;
932 case '8' :
933 strcat (lcl_trg,"1000"); break;
934 case '9' :
935 strcat (lcl_trg,"1001"); break;
936 case 'a' :
937 case 'A' :
938 strcat (lcl_trg,"1010"); break;
939 case 'b' :
940 case 'B' :
941 strcat (lcl_trg,"1011"); break;
942 case 'c' :
943 case 'C' :
944 strcat (lcl_trg,"1100"); break;
945 case 'd' :
946 case 'D' :
947 strcat (lcl_trg,"1101"); break;
948 case 'e' :
949 case 'E' :
950 strcat (lcl_trg,"1110"); break;
951 case 'f' :
952 case 'F' :
953 strcat (lcl_trg,"1111"); break;
954 case '%' :
955 case '"' :
956 case '_' :
957 j -= 4; break;
958 default :
959 j -= 4; errflg = 1; bvl_error(73,src);
960 }
961 indx++;
962 }
963 break;
964
965 default :
966 beh_toolbug (17,"bvl_tobin",NULL,base);
967 }
968
969 if ((j == 0) || (j <= right))
970 {
971 trg[0] = '0';
972 trg[1] = '\0';
973 }
974 else
975 {
976 if (left != -1)
977 {
978 strcpy (trg, &lcl_trg[left]);
979 trg[right - left + 1] = '\0';
980 }
981 else
982 strcpy (trg, lcl_trg);
983 }
984 }
985 }
986
987 return (errflg);
988 }