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 / bdd / log_vectabl.c
1 /****************************************************************************/
2 /* */
3 /* Chaine de CAO & VLSI AVERTEC */
4 /* */
5 /* Produit : VECTABL Version 1.00 */
6 /* Fichier : log_vectabl.c */
7 /* */
8 /* (c) copyright 2002 AVERTEC */
9 /* Tous droits reserves */
10 /* */
11 /* Auteur(s) : Antony PINTO */
12 /* */
13 /****************************************************************************/
14
15 #include <stdio.h>
16 #include <stdlib.h>
17 #include <string.h>
18 #include MUT_H
19 #include LOG_H
20 #include AVT_H
21
22 /*}}}************************************************************************/
23 /*{{{ */
24 /* functions declarations */
25 /* */
26 /****************************************************************************/
27 char *replicateBitStr ( char *bitstr ,
28 int n );
29 chain_list *concatAbl ( chain_list *expr1 ,
30 chain_list *expr2 );
31 chain_list *replicateAbl ( chain_list *expr ,
32 int n );
33 chain_list *getAblAtPos ( chain_list *expr ,
34 int pos );
35 int getVectAblRange ( chain_list *expr ,
36 int *left ,
37 int *right );
38 char *getVectAblVarName ( chain_list *expr );
39 int verifyVectAbl ( chain_list *expr );
40 int getAtomSize ( chain_list *expr );
41 chain_list *getAblAtIndex ( chain_list *expr ,
42 int left ,
43 int right ,
44 int index );
45 chain_list *createBitStr ( char *bitstr );
46 int isBitStr ( char *bitstr );
47 void freeBitStrTable ( );
48 char *makeBitStr ( char *bistr );
49 char *invertBitStr ( char *bitstr );
50 chain_list *downCat(chain_list *expr);
51
52 ht *LOG_BITSTRTABLE = NULL;
53
54 char *genBitStr(int n,char car);
55
56 /****************************************************************************/
57 /*{{{ concatAbl() */
58 /* */
59 /* */
60 /****************************************************************************/
61 chain_list *concatAbl(chain_list *expr1, chain_list *expr2)
62 {
63 chain_list *resExpr;
64 chain_list *chainx;
65 int vectSize;
66
67 vectSize = verifyVectAbl(expr1) + verifyVectAbl(expr2);
68
69 if (!ATOM(expr1) && OPER(expr1)==CAT)
70 {
71 resExpr = expr1;
72 for (chainx=resExpr->NEXT; chainx->NEXT; chainx=chainx->NEXT)
73 ;
74 if (!ATOM(expr2) && OPER(expr2)==CAT)
75 {
76 freechain(CAR(expr2));
77 expr2 = delchain(expr2,expr2);
78 }
79 else
80 expr2 = addchain(NULL,expr2);
81 // addQExpr(resExpr,expr2);
82 chainx->NEXT = expr2;
83 }
84 else if (!ATOM(expr2) && OPER(expr2)==CAT)
85 {
86
87 resExpr = expr2;
88 addHExpr(resExpr,expr1);
89 }
90 // else if (OPER(expr1)==REPLICATE)
91 // else if (OPER(expr2)==REPLICATE)
92 else if (!ATOM(expr1) && !ATOM(expr2)
93 && OPER(expr1) == OPER(expr2)
94 && lengthExpr(expr1) == lengthExpr(expr2))
95 {
96 resExpr = createExpr(OPER(expr1));
97 while ((expr1 = CDR(expr1)) && (expr2 = CDR(expr2)))
98 addQExpr(resExpr,concatAbl(CAR(expr1),CAR(expr2)));
99 }
100 else
101 {
102 resExpr = createExpr(CAT);
103 addHExpr(resExpr,expr2);
104 addHExpr(resExpr,expr1);
105 }
106
107 if (CDAR(resExpr))
108 VECT_S(resExpr) = vectSize;
109 else
110 CDAR(resExpr) = addchain(NULL,(void *)(long)vectSize);
111
112 return resExpr;
113 }
114
115 /*}}}************************************************************************/
116 /*{{{ */
117 /* */
118 /* reduce a concatenation by grouping same atom radical */
119 /* return the way of the reduce operation 0 for upto, 1 for downto */
120 /****************************************************************************/
121 /*int simplifyCat(chain_list *expr)
122 {
123 chain_list *tmp = expr;
124
125 if (ATOM(expr))
126 return -1;
127 else if (OPER(expr) == CAT)
128 {
129 while (tmp)
130
131
132
133 }
134 else
135 while (tmp = CDR(tmp))
136 return simplifyCat(CAR(expr));
137 }
138 */
139
140 /*}}}************************************************************************/
141 /*{{{ replicateAbl() */
142 /* */
143 /* */
144 /****************************************************************************/
145 chain_list *replicateAbl(chain_list *expr, int n)
146 {
147 chain_list *resExpr;
148 int vectSize;
149 int replicateTimes;
150
151 resExpr = expr;
152 if (!ATOM(resExpr) && OPER(resExpr)==REPLICATE)
153 {
154 replicateTimes = (int)(VECT_S(resExpr) * n);
155 vectSize = verifyVectAbl(resExpr) * n;
156 VECT_S(resExpr) = vectSize;
157 REP_NB(resExpr) = replicateTimes;
158 }
159 else if (ATOM(resExpr) && isBitStr(resExpr->DATA))
160 {
161 resExpr->DATA = replicateBitStr(expr->DATA,n);
162 }
163 else
164 {
165 resExpr = createExpr(REPLICATE);
166 CDR(resExpr) = addchain(NULL,expr);
167 replicateTimes = n;
168 vectSize = verifyVectAbl(expr) * n;
169 CDAR(resExpr) = addchain(NULL,(void *)(long)n);
170 CDAR(resExpr) = addchain(CDAR(resExpr),(void *)(long)vectSize);
171 }
172
173 return resExpr;
174 }
175
176 /*}}}************************************************************************/
177 /*{{{ getAblAtPos() */
178 /* */
179 /* */
180 /****************************************************************************/
181 chain_list *getAblAtPos(chain_list *expr, int pos)
182 {
183 chain_list *resExpr = NULL;
184 chain_list *subExpr;
185 chain_list *exprx;
186 char buf[255];
187 chain_list *chainx;
188 int count = 0;
189 int countNext = 0;
190 int bit;
191 int vectSize;
192 int left;
193
194 vectSize = verifyVectAbl(expr);
195
196 if (vectSize > pos)
197 {
198 if (ATOM(expr))
199 {
200 if (getAtomSize(expr) == 1)
201 resExpr = addchain(NULL,expr->DATA);
202 else if (isBitStr(expr->DATA))
203 {
204 sprintf(buf,"'%c'",((char*)expr->DATA)[pos+1]);
205 resExpr = addchain(NULL,namealloc(buf));
206 }
207 else
208 {
209 bit = getVectAblRange(expr,&left,NULL);
210 bit = left + (bit * pos);
211 sprintf(buf,"%s %d",getVectAblVarName(expr),bit);
212 resExpr = addchain(NULL,namealloc(buf));
213 }
214 }
215 else if (vectSize == 1)
216 resExpr = copyExpr(expr);
217 else if (OPER(expr) == CAT)
218 {
219 for (chainx = expr->NEXT; chainx; chainx = chainx->NEXT)
220 {
221 countNext = count + verifyVectAbl(CAR(chainx));
222 if (pos<countNext)
223 break;
224 else
225 count = countNext;
226 }
227 resExpr = getAblAtPos(CAR(chainx),pos-count);
228 }
229 else if (OPER(expr) == REPLICATE)
230 {
231 count = VECT_S(expr)/REP_NB(expr);
232 if (count==1)
233 resExpr = getAblAtPos(CADR(expr),0);
234 else
235 resExpr = getAblAtPos(CADR(expr),pos%count);
236 }
237 else
238 {
239 resExpr = createExpr(OPER(expr));
240 exprx = resExpr;
241 for (chainx = expr->NEXT; chainx; chainx = chainx->NEXT)
242 {
243 subExpr = getAblAtPos(CAR(chainx),pos);
244 exprx->NEXT = addchain(NULL,subExpr);
245 exprx = exprx->NEXT;
246 }
247 }
248 }
249 else
250 resExpr = NULL;
251
252 return resExpr;
253 }
254
255 /*}}}************************************************************************/
256 /*{{{ downCat() */
257 /* */
258 /* move concatenation to leaf */
259 /****************************************************************************/
260 chain_list *downCat(chain_list *expr)
261 {
262 if (expr)
263 {
264 if (OPER(expr) == CAT)
265 {
266 chain_list *abl = expr;
267 chain_list *res = CADR(expr);
268
269 while ((abl = CDR(abl)))
270 if (isBitStr(VALUE_ATOM(CAR(abl))))
271 return expr;
272 abl = CDR(expr);
273 while ((abl = CDR(abl)))
274 res = concatAbl(res,CAR(abl));
275 return res;
276 }
277 else
278 return expr;
279 }
280 else
281 return expr;
282 }
283
284 /*}}}************************************************************************/
285 /*{{{ getVectAblRange() */
286 /* */
287 /* */
288 /****************************************************************************/
289 int getVectAblRange(chain_list *expr, int *left, int *right)
290 {
291 int res;
292 long pos1;
293 long pos2;
294 int leFt;
295 int riGht;
296
297 if (ATOM(expr))
298 {
299 if ((pos2 = (long)strchr(expr->DATA,':')))
300 {
301 pos1 = (long)strchr(expr->DATA,' ');
302 leFt = atoi((char *)(pos1+1));
303 riGht = atoi((char *)(pos2+1));
304 if (left) *left = leFt;
305 if (right) *right = riGht;
306 res = (leFt>riGht)?-1:1;
307 }
308 else res = 0;
309 }
310 else res = 0;
311
312 return res;
313 }
314
315 /*}}}************************************************************************/
316 /*{{{ repToCatVectAbl() */
317 /* */
318 /* convert a replicate abl onto a cat abl */
319 /* */
320 /****************************************************************************/
321 void repToCatVectAbl(chain_list *expr)
322 {
323 int i;
324 int nb;
325 chain_list *tmpExpr;
326 chain_list *cpyExpr;
327 chain_list *resExpr;
328
329 if (OPER(expr) == REPLICATE)
330 {
331 nb = REP_NB(expr);
332 resExpr = addchain(NULL,NULL);
333 CAR(resExpr) = CAR(expr);
334 OPER(resExpr) = CAT;
335 CDR(CDAR(resExpr)) = delchain(CDR(CDAR(resExpr)),CDR(CDAR(resExpr)));
336 for (i = 0; i < nb; i ++)
337 {
338 cpyExpr = copyExpr(expr);
339 for (tmpExpr = cpyExpr; CDR(tmpExpr); tmpExpr = CDR(tmpExpr))
340 ;
341 CDR(tmpExpr) = CDR(resExpr);
342 CDR(resExpr) = CDR(cpyExpr);
343 CDR(cpyExpr) = NULL;
344 freeExpr(cpyExpr);
345 }
346 CDR(expr) = CDR(resExpr);
347 delchain(resExpr,resExpr);
348 }
349 }
350
351 /*}}}************************************************************************/
352 /*{{{ changeAblAtRange() */
353 /* */
354 /* substitute abl on range by a new abl */
355 /* mode 1 only subsitute undefined abl on range */
356 /* */
357 /* expr : 0 left right n */
358 /* +-------+--------+------+ */
359 /* |xxxxxxx| added |xxxxxx| */
360 /* +-------+--------+------+ */
361 /* mode 1 |xxxxxxx|"UUUUUU"|xxxxxx| */
362 /* mode 2 |xxxxxxx|existing|xxxxxx| */
363 /* +-------+--------+------+ */
364 /* | ^ expr | */
365 /* +---/|\-----------------+ */
366 /* | */
367 /* pos (current position) */
368 /* */
369 /****************************************************************************/
370 int changeAblAtRange(chain_list *expr,int left,int right,chain_list *added,
371 int mode)
372 {
373 int vsize;
374 int i;
375 char buf1[255];
376 char buf2[255];
377 char *buft;
378 chain_list *tmpExpr;
379 int al,ar; // atome caracterisation
380 char *an;
381 chain_list *nl;
382 chain_list *nr;
383
384 // only mode 1
385 if ((vsize = verifyVectAbl(expr)) >= right)
386 {
387 int tmp;
388 chain_list *abl;
389
390 if (ATOM(expr))
391 {
392 switch (mode)
393 {
394 case 1 :
395 if (isBitStr(VALUE_ATOM(expr)))
396 {
397 for (i = left; i <= right; i ++)
398 if ( (VALUE_ATOM(expr))[i+1] != 'u')
399 return 0;
400 }
401 else
402 return 0;
403 case 2 :
404 if (isBitStr(VALUE_ATOM(expr)))
405 {
406 sprintf(buf1,"%s",VALUE_ATOM(expr)); // before
407 buf1[0] = (left == 1) ? '\'' : '"';
408 buf1[left+1] = (left == 1) ? '\'' : '"';
409 buf1[left+2] = '\0';
410 nl = (left == 0) ? NULL : createBitStr(buf1);
411
412 sprintf(buf2,"%s",VALUE_ATOM(expr)); // after
413 buf2[vsize+1] = (right == vsize-1) ? '\'' : '"';
414 buft = (char*)((long)&buf2 + right + 1);
415 buft[0] = (right == vsize-1) ? '\'' : '"';
416 nr = (right == vsize-1) ? NULL : createBitStr(buft);
417 }
418 else
419 {
420 getVectAtomRange(expr,&an,&al,&ar);
421 if (al<ar) // good range direction
422 {
423 nl = createVectAtom(an, al, al+left-1);
424 nr = createVectAtom(an, al+right+1, ar);
425 }
426 else
427 {
428 nl = createVectAtom(an, al, al-left+1);
429 nr = createVectAtom(an, al-right-1, ar);
430 }
431 }
432 }
433 tmpExpr = (nl) ? concatAbl(nl,added) : added;
434 tmpExpr = (nr) ? concatAbl(tmpExpr,nr) : tmpExpr;
435 // tmpExpr = downCat(tmpExpr);
436 CAR(expr) = CAR(tmpExpr);
437 CDR(expr) = CDR(tmpExpr);
438 delchain(tmpExpr,tmpExpr);
439 return 2;
440 }
441 else switch (OPER(expr))
442 {
443 case CAT :
444 abl = expr;
445 abl = CDR(abl);
446 for (i = 0; abl ;abl = CDR(abl))
447 {
448 tmp = verifyVectAbl(CAR(abl));
449 if (i <= left && right < tmp+i)
450 {
451 if (changeAblAtRange(CAR(abl),left-i,right-i,added,mode))
452 {
453 chain_list *delExpr = NULL;
454 chain_list *abl2;
455
456 if (OPER(CAR(abl)) == CAT)
457 {
458 delExpr = CAR(abl);
459 tmpExpr = CDR(abl);
460 CAR(abl) = CAR(CDR(delExpr));
461 CDR(abl) = CDR(CDR(delExpr));
462 while (CDR(abl))
463 abl = CDR(abl);
464 CDR(abl) = tmpExpr;
465 CDR(delExpr) = NULL;
466 freeExpr(delExpr);
467 }
468 abl2 = downCat(expr);
469 CDR(expr) = CDR(abl2);
470 CAR(expr) = CAR(abl2);
471 return 1;
472 }
473 }
474 else
475 i += tmp;
476 }
477 return 0;
478 case REPLICATE :
479 repToCatVectAbl(expr);
480 return changeAblAtRange(expr,left,right,added,mode);
481 default :
482 avt_errmsg(LOG_ERRMSG,"000",AVT_ERROR,"157");
483 // printf("pas traite changeAblAtRange() def\n");
484 // return 0;
485 }
486 return 1;
487 }
488 else
489 return 0;
490 }
491
492 /*}}}************************************************************************/
493 /*{{{ createVectAtomName() */
494 /* */
495 /* */
496 /****************************************************************************/
497 char *createVectAtomName(char *name,int left,int right)
498 {
499 char buf[255];
500
501 if (left != right)
502 sprintf(buf,"%s %d:%d",name,left,right);
503 else
504 sprintf(buf,"%s %d",name,left);
505 return namealloc(buf);
506 }
507
508 /*}}}************************************************************************/
509 /*{{{ createVectAtom() */
510 /* */
511 /* */
512 /****************************************************************************/
513 chain_list *createVectAtom(char *name,int left,int right)
514 {
515 return createAtom(createVectAtomName(name,left,right));
516 }
517
518 /*}}}************************************************************************/
519 /*{{{ getVectAtomRange() */
520 /* */
521 /* */
522 /****************************************************************************/
523 void getVectAtomRange(chain_list *expr,char **name,int *left, int*right)
524 {
525 char buf[255];
526 char tmp[16];
527 int i = 0;
528 int j = 0;
529 int done = 0;
530
531 sprintf(buf,"%s",(char *)expr->DATA);
532 while (buf[i] != ' ') i++;
533 buf[i] = '\0';
534 *name = namealloc(buf);
535 i++;
536 while (buf[i] != '\0')
537 {
538 if (buf[i] == ':')
539 {
540 tmp[j] = '\0';
541 *left = atoi(tmp);
542 done = 1;
543 j = 0;
544 }
545 else
546 tmp[j++] = buf[i];
547 i ++;
548 }
549 tmp[j] = '\0';
550 *right = atoi(tmp);
551 if (!done)
552 *left = atoi(tmp);
553 }
554
555 /*}}}************************************************************************/
556 /*{{{ getAblAtIndex() */
557 /* */
558 /* */
559 /****************************************************************************/
560 chain_list *getAblAtIndex(chain_list *expr,int left,int right,int index)
561 {
562 int pos;
563
564 pos = left - index;
565 if (left<right)
566 pos = 0 - pos;
567
568 return getAblAtPos(expr,pos);
569 }
570
571 /*}}}************************************************************************/
572 /*{{{ getVectAblVarName() */
573 /* */
574 /* */
575 /****************************************************************************/
576 char *getVectAblVarName(chain_list *expr)
577 {
578 char *res;
579 char buf[255];
580 int i = 0;
581
582 if (ATOM(expr))
583 {
584 sprintf(buf,"%s",(char *)expr->DATA);
585 while (buf[i]!=' ' && buf[i] != '\0')
586 i++;
587 buf[i] = '\0';
588 res = namealloc(buf);
589 }
590 else res = NULL;
591
592 return res;
593 }
594
595 /*}}}************************************************************************/
596 /*{{{ initBitStrTable() */
597 /* */
598 /* */
599 /****************************************************************************/
600 void initBitStrTable()
601 {
602 LOG_BITSTRTABLE = addht(200);
603 addhtitem(LOG_BITSTRTABLE,namealloc("'0'"),1);
604 addhtitem(LOG_BITSTRTABLE,namealloc("'1'"),1);
605 addhtitem(LOG_BITSTRTABLE,namealloc("'d'"),1);
606 addhtitem(LOG_BITSTRTABLE,namealloc("'u'"),1);
607 addhtitem(LOG_BITSTRTABLE,namealloc("'z'"),1);
608 }
609
610 /*}}}************************************************************************/
611 /*{{{ verifyVectAbl() */
612 /* */
613 /* */
614 /****************************************************************************/
615 int verifyVectAbl(chain_list *expr)
616 {
617 int res = 0;
618 chain_list *chainx;
619 int vectSize;
620
621 if (ATOM(expr))
622 res = getAtomSize(expr);
623 else if (CDAR(expr) && VECT_S(expr))
624 res = (int)VECT_S(expr);
625 else
626 {
627 for (chainx=expr->NEXT;chainx;chainx=chainx->NEXT)
628 {
629 vectSize = verifyVectAbl(CAR(chainx));
630 if (!res) res = vectSize;
631 else if (vectSize!=res)
632 return 0;
633 }
634 if (CDAR(expr))
635 VECT_S(expr) = res;
636 else
637 CDAR(expr) = addchain(NULL,(void *)(long)res);
638 }
639
640 return res;
641 }
642
643 /*}}}************************************************************************/
644 /*{{{ getAtomSize() */
645 /* */
646 /* */
647 /****************************************************************************/
648 int getAtomSize(chain_list *expr)
649 {
650 int res;
651 long pos1;
652 long pos2;
653
654 if (isBitStr(expr->DATA))
655 res = strlen(expr->DATA) - 2;
656 else if ((pos2 = (long)strchr(expr->DATA,':')))
657 {
658 pos1 = (long)strchr(expr->DATA,' ');
659 if (pos1 == 0)
660 res = 1;
661 else
662 res = abs(atoi((char *)(pos1+1)) - atoi((char *)(pos2+1))) + 1;
663 }
664 else res = 1;
665
666 return res;
667 }
668
669 /*}}}************************************************************************/
670 /*{{{ invertVectAbl() */
671 /* */
672 /* */
673 /****************************************************************************/
674 void invertVectAbl(chain_list *expr)
675 {
676 chain_list *chainx;
677
678 if (ATOM(expr)) invertAtom(expr);
679 else switch (OPER(expr))
680 {
681 case CAT :
682 CDR(expr) = reverse(CDR(expr));
683 default :
684 for (chainx=CDR(expr);chainx;chainx=chainx->NEXT)
685 invertVectAbl(CAR(chainx));
686 }
687 }
688
689 /*}}}************************************************************************/
690 /*{{{ invertAtom() */
691 /* */
692 /* */
693 /****************************************************************************/
694 void invertAtom(chain_list *expr)
695 {
696 int left;
697 int right;
698 char *pos1;
699 char *pos2;
700 char *name;
701 char buf[255];
702
703 if (ATOM(expr))
704 {
705 name = mbkstrdup(expr->DATA);
706 if (isBitStr(expr->DATA))
707 {
708 expr->DATA = invertBitStr(expr->DATA);
709 }
710 else if ((pos2 = strchr(name,':')))
711 {
712 pos1 = strchr(name,' ');
713 *pos1 = '\0';
714 left = atoi(pos1+1);
715 right= atoi(pos2+1);
716 sprintf(buf,"%s %d:%d",name,right,left);
717 expr->DATA = namealloc(buf);
718 }
719 mbkfree(name);
720 }
721 }
722
723 /*}}}************************************************************************/
724 /*{{{ invertBitStr() */
725 /* */
726 /* */
727 /****************************************************************************/
728 char *invertBitStr(char *bitstr)
729 {
730 char buf[1024];
731 char tmp[1024];
732 int i, j;
733
734 sprintf(tmp,"%s",bitstr);
735 for (i=strlen(tmp)-1,j=0;i>=0;i--,j++)
736 buf[j] = tmp[i];
737 buf[++j] = '\0';
738
739 return makeBitStr(buf);
740 }
741
742 /*}}}************************************************************************/
743 /*{{{ createBitStr() */
744 /* */
745 /* */
746 /****************************************************************************/
747 chain_list *createBitStr(char *bitstr)
748 {
749 if (*bitstr == '\'' || *bitstr == '"')
750 return createAtom(makeBitStr(bitstr));
751 else
752 {
753 char buf[1024];
754
755 if (*(bitstr+1) != '\0')
756 sprintf(buf,"\"%s\"",bitstr);
757 else
758 sprintf(buf,"'%s'",bitstr);
759 return createAtom(makeBitStr(buf));
760 }
761 }
762
763 /*}}}************************************************************************/
764 /*{{{ makeBitStr() */
765 /* */
766 /* fait d'une chaine de caractere une bitstring */
767 /****************************************************************************/
768 char *makeBitStr(char *bitstr)
769 {
770 char *res;
771
772 res = namealloc(bitstr);
773 if (!LOG_BITSTRTABLE)
774 initBitStrTable();
775 addhtitem(LOG_BITSTRTABLE,res,1);
776
777 return res;
778 }
779
780 /*}}}************************************************************************/
781 /*{{{ genOneBitStr() */
782 /* */
783 /* generate a bitstring of one (n lenght) */
784 /****************************************************************************/
785 char *genOneBitStr(int n)
786 {
787 return genBitStr(n,'1');
788 }
789
790 /*}}}************************************************************************/
791 /*{{{ genZeroBitStr() */
792 /* */
793 /* generate a bitstring of zero (n lenght) */
794 /****************************************************************************/
795 char *genZeroBitStr(int n)
796 {
797 return genBitStr(n,'0');
798 }
799
800 /*}}}************************************************************************/
801 /*{{{ genHZBitStr() */
802 /* */
803 /* generate a bitstring of one (n lenght) */
804 /****************************************************************************/
805 char *genHZBitStr(int n)
806 {
807 return genBitStr(n,'z');
808 }
809
810 /*}}}************************************************************************/
811 /*{{{ genBitStr() */
812 /* */
813 /* */
814 /****************************************************************************/
815 char *genBitStr(int n,char car)
816 {
817 char buf[255];
818 int i;
819
820 buf[0] = (n == 1) ? '\'' : '"';
821 for (i = 1; i <= n; )
822 buf[i++] = car;
823 buf[i++] = (n == 1) ? '\'' : '"';
824 buf[i] = '\0';
825
826 return makeBitStr(buf);
827 }
828
829 /*}}}************************************************************************/
830 /*{{{ replicateBitStr() */
831 /* */
832 /* */
833 /****************************************************************************/
834 char *replicateBitStr(char *bitstr, int n)
835 {
836 char buf[511];
837 int i, j, len, k;
838
839 k = 0;
840 buf[k++] = '"';
841 len = strlen(bitstr) - 2;
842 for (j = 0; j < n; j ++)
843 for (i = 1; i <= len; i ++)
844 buf [k++] = bitstr[i];
845
846 buf[k++] = '"';
847 buf[k++] = '\0';
848
849 return makeBitStr(buf);
850 }
851
852 /*}}}************************************************************************/
853 /*{{{ fprintHZBitStr() */
854 /* */
855 /* */
856 /****************************************************************************/
857 void fprintHZBitStr(FILE *file,char *bitstr)
858 {
859 unsigned int i;
860 unsigned int n = strlen(bitstr) - 2;
861
862 fprintf(file,"%c",(n == 1) ? '\'' : '"');
863 for (i = 0; i < n; i ++)
864 fprintf(file,"Z");
865 fprintf(file,"%c",(n == 1) ? '\'' : '"');
866 }
867
868 /*}}}************************************************************************/
869 /*{{{ genUBitStr() */
870 /* */
871 /* generate a bitstring of one (n lenght) */
872 /****************************************************************************/
873 char *genUBitStr(int n)
874 {
875 return genBitStr(n,'u');
876 }
877
878 /*}}}************************************************************************/
879 /*{{{ getBitStr() */
880 /* */
881 /* create an easy to drive copy of the bitstring */
882 /* */
883 /****************************************************************************/
884 char *getBitStr(char *str)
885 {
886 char buf[255];
887 int i, n, j;
888
889 n = strlen(str);
890
891 for (i = 0, j = 0; i <= n; i ++)
892 {
893 switch (str[i])
894 {
895 case 'u' : buf[j++] = 'U'; break;
896 case 'z' : buf[j++] = 'Z'; break;
897 case 'd' : buf[j++] = 'D'; break;
898 default : buf[j++] = str[i]; break;
899 }
900 }
901 return mbkstrdup(buf);
902 }
903
904 /*}}}************************************************************************/
905 /*{{{ fprintUBitStr() */
906 /* */
907 /* */
908 /****************************************************************************/
909 void fprintUBitStr(FILE *file,char *bitstr)
910 {
911 int i;
912 int n;
913
914 n = strlen(bitstr)-2;
915
916 if (n==1)
917 fprintf(file,"'");
918 else
919 fprintf(file,"\"");
920 for (i = 0; i < n; i++)
921 fprintf(file,"U");
922 if (n==1)
923 fprintf(file,"'");
924 else
925 fprintf(file,"\"");
926 }
927
928 /*}}}************************************************************************/
929 /*{{{ notBitStr() */
930 /* */
931 /* invert a bitstring */
932 /****************************************************************************/
933 char *notBitStr(char *bitstr)
934 {
935 char buf[255];
936 int i;
937
938 for (i = 0; bitstr[i-1] != '\0'; i ++)
939 if (bitstr[i] == '0')
940 buf[i] = '1';
941 else if (bitstr[i] == '1')
942 buf[i] = '0';
943 else
944 buf[i] = bitstr[i];
945
946 return makeBitStr(buf);
947 }
948
949 /*}}}************************************************************************/
950 /*{{{ isBitStr() */
951 /* */
952 /* */
953 /****************************************************************************/
954 int isBitStr(char *bitstr)
955 {
956 if (!LOG_BITSTRTABLE)
957 initBitStrTable();
958 return
959 (gethtitem(LOG_BITSTRTABLE,bitstr) == 1);
960 }
961
962 /*}}}************************************************************************/
963 /*{{{ freeBitStrTable() */
964 /* */
965 /* */
966 /****************************************************************************/
967 void freeBitStrTable()
968 {
969 delht(LOG_BITSTRTABLE);
970 }