1 /*------------------------------------------------------------\
2 | |
3 | This file is part of the Alliance CAD System Copyright |
4 | (C) Laboratoire LIP6 - D�partement ASIM Universite P&M Curie|
5 | |
6 | Home page : http://www-asim.lip6.fr/alliance/ |
7 | E-mail : mailto:alliance-users@asim.lip6.fr |
8 | |
9 | This progam is free software; you can redistribute it |
10 | and/or modify it under the terms of the GNU Library General|
11 | Public License as published by the Free Software Foundation |
12 | either version 2 of the License, or (at your option) any |
13 | later version. |
14 | |
15 | Alliance VLSI CAD System is distributed in the hope that |
16 | it will be useful, but WITHOUT ANY WARRANTY; |
17 | without even the implied warranty of MERCHANTABILITY or |
18 | FITNESS FOR A PARTICULAR PURPOSE. See the GNU General |
19 | Public License for more details. |
20 | |
21 | You should have received a copy of the GNU General Public |
22 | License along with the GNU C Library; see the file COPYING. |
23 | If not, write to the Free Software Foundation, Inc., |
24 | 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. |
25 | |
26 \------------------------------------------------------------*/
27 /* ###--------------------------------------------------------------### */
28 /* */
29 /* file : fbl_bcomp.yac */
30 /* date : NOV 5 1992 */
31 /* version : v100 */
32 /* author : P. BAZARGAN, M. HANAFI */
33 /* Modified by Ludovic Jacome */
34 /* content : yacc rules for fbhavioural VHDL */
35 /* */
36 /* ###--------------------------------------------------------------### */
37
38 %{
39 #include <stdio.h>
40 #include <string.h>
41 #include <stdlib.h>
42
43 #include "mut.h"
44 #include "aut.h"
45 #include "abl.h"
46 #include "bdd.h"
47 #include "fvh.h"
48
49 #include "fbl_utype.h"
50 #include "fbl_bedef.h"
51 #include "fbl_bspec.h"
52 #include "fbl_byacc.h"
53
54 static struct dct_entry *addent ();
55 static struct dct_recrd *addrcd ();
56 static struct dct_entry **initab ();
57 static void addtab ();
58 static long chktab ();
59 static void fretab ();
60 void *fbl_addstr ();
61 long fbl_chkdcl ();
62 struct ptype *reversetype();
63 struct choice_chain *order_choice();
64 %}
65
66 %union {
67 long valu;
68 char *text;
69 struct ptype *ptyp;
70 struct fbpcs proc;
71 struct g_type dble;
72 fbl_name name;
73 fbl_ablstr list;
74 struct fbtyp type;
75 };
76
77 %token <valu> tok_AND
78 %token <valu> Pragma
79 %token <valu> _BEGIN
80 %token <valu> _END
81 %token <valu> _EQSym
82 %token <valu> _EXIT
83 %token <valu> _FILE
84 %token <valu> _GESym
85 %token <valu> _GTSym
86 %token <valu> _IN
87 %token <valu> _INOUT
88 %token <valu> _LABEL
89 %token <valu> _LESym
90 %token <valu> _LINKAGE
91 %token <valu> _LTSym
92 %token <valu> _NAND
93 %token <valu> _NESym
94 %token <valu> _NEXT
95 %token <valu> _NOR
96 %token <valu> _NOT
97 %token tok_NULL
98 %token <valu> _OR
99 %token <valu> _OUT
100 %token <valu> _XOR
101 %token <valu> ABS
102 %token <valu> ACCESS
103 %token <valu> AFTER
104 %token <valu> ALIAS
105 %token <valu> ALL
106 %token <valu> ARCHITECTURE
107 %token <valu> ARRAY
108 %token <valu> ASSERT
109 %token <valu> ATTRIBUTE
110 %token <text> AbstractLit
111 %token <valu> Ampersand
112 %token <valu> Apostrophe
113 %token <valu> Arrow
114 %token <valu> _BLOCK
115 %token <valu> BODY
116 %token <valu> BUFFER
117 %token <valu> BUS
118 %token <valu> Bar
119 %token <valu> BasedInt
120 %token <valu> BasedReal
121 %token <text> BitStringLit
122 %token <valu> Box
123 %token <valu> CASE
124 %token <valu> COMPONENT
125 %token <valu> CONFIGURATION
126 %token <valu> CONSTANT
127 %token <text> CharacterLit
128 %token <valu> Colon
129 %token <valu> Comma
130 %token <valu> DISCONNECT
131 %token <valu> DOWNTO
132 %token <valu> DecimalInt
133 %token <valu> DecimalReal
134 %token <valu> Dot
135 %token <valu> DoubleStar
136 %token <valu> ELSE
137 %token <valu> ELSIF
138 %token <valu> ENTITY
139 %token <valu> ERROR
140 %token <valu> FOR
141 %token <valu> FUNCTION
142 %token <valu> GENERATE
143 %token <valu> GENERIC
144 %token <valu> GUARDED
145 %token <valu> IF
146 %token <valu> IS
147 %token <text> Identifier
148 %token <valu> LIBRARY
149 %token <valu> LOOP
150 %token LeftParen
151 %token <valu> MAP
152 %token <valu> MOD
153 %token <valu> Minus
154 %token <valu> NEW
155 %token <valu> OF
156 %token <valu> ON
157 %token <valu> OPEN
158 %token <valu> OTHERS
159 %token <valu> _PACKAGE
160 %token PORT
161 %token <valu> PROCEDURE
162 %token <valu> PROCESS
163 %token <valu> Plus
164 %token <valu> RANGE
165 %token <valu> RECORD
166 %token <valu> REGISTER
167 %token <valu> REM
168 %token <valu> REPORT
169 %token <valu> RETURN
170 %token <valu> RightParen
171 %token <valu> SELECT
172 %token <valu> SEVERITY
173 %token SIGNAL
174 %token _STABLE
175 %token _EVENT
176 %token <valu> SUBTYPE
177 %token <valu> Semicolon
178 %token <valu> Star
179 %token <text> StringLit
180 %token <valu> THEN
181 %token <valu> TO
182 %token <valu> TRANSPORT
183 %token <valu> FBHTYPE
184 %token <valu> UNITS
185 %token <valu> UNTIL
186 %token <valu> USE
187 %token <valu> VARIABLE
188 %token <valu> VarAsgn
189 %token <valu> WAIT
190 %token <valu> WARNING
191 %token <valu> WHEN
192 %token <valu> WHILE
193 %token <valu> WITH
194
195 %left tok_AND _OR _NAND _NOR _XOR
196 %left _EQSym _NESym
197 %left _NOT
198
199
200 %type <valu> .SEVERITY__expression.
201 %type <valu> severity__message
202 %type <text> .REPORT__expression.
203 %type <text> report__message
204 %type <text> .guard_expression.
205 %type <text> guard_expression
206
207
208 %type <list> waveform
209 %type <list> waveform_element
210 %type <list> ...waveform__WHEN__choices..
211 %type <list> waveform__WHEN__choices
212 %type <list> condition
213 %type <list> expression
214 %type <list> relation..AND__relation..
215 %type <list> relation..OR__relation..
216 %type <list> relation.NAND_NOR__relation.
217 %type <list> relation..XOR__relation..
218 %type <list> relation
219 %type <list> simple_expression
220 %type <list> .sign.term..add_op__term..
221 %type <list> term
222 %type <list> factor
223 %type <list> primary
224 %type <valu> relational_operator
225 %type <text> literal
226 %type <name> choice
227 %type <list> aggregate
228
229 %type <valu> .GUARDED.
230
231 %type <type> type_definition
232 %type <type> scalar_type_definition
233 %type <type> composite_type_definition
234 %type <type> enumeration_type_definition
235 %type <type> subtype_indication
236 %type <type> unconstrained_array_definition
237 %type <type> constrained_array_definition
238 %type <type> array_type_definition
239
240 %type <name> index_subtype_definition
241 %type <name> index_constraint
242 %type <name> discrete_range
243
244 %type <text> .label.
245 %type <text> label
246 %type <text> a_label
247 %type <name> target
248 %type <text> simple_name
249 %type <name> name
250 %type <name> attribute_name
251 %type <name> indexed_name
252 %type <name> slice_name
253 %type <text> .simple_name.
254 %type <name> .constraint.
255 %type <name> constraint
256 %type <name> range
257 %type <name> range_constraint
258 %type <valu> direction
259 %type <valu> abstractlit
260 %type <valu> .mode.
261 %type <name> type_mark
262 %type <valu> .signal_kind.
263 %type <valu> attribute_designator
264
265
266 %type <text> constant_VarAsgn__expression
267
268 %start design_file
269
270 %%
271
272 design_file
273 : /* empty */
274 {
275 /* ###----------------------------------------------### */
276 /* Initializations */
277 /* ###----------------------------------------------### */
278 FBL_NM1LST = 0;
279 FBL_GRDLST = 0;
280 FBL_CNDLST = 0;
281 FBL_VALLST = 0;
282
283 hshtab = initab ();
284
285 FBL_ERRFLG = 0;
286 FBL_LINNUM = 1;
287 FBL_NUMPTP = 0;
288 FBL_HEADFIG = (fbfig_list *)0;
289
290 FBL_MODNAM = 0;
291 FBL_BEFPNT = fbh_addfbfig (FBL_HEADFIG,0);
292 FBL_HEADFIG = FBL_BEFPNT;
293 FBL_HASH_ASG_FSM = createauthtable( 1000 );
294 }
295 design_unit
296 ..design_unit..
297 {
298 struct fbbus *fbbus_pnt;
299 struct fbreg *fbreg_pnt;
300 struct fbout *fbout_pnt;
301 struct fbaux *fbaux_pnt;
302 authelem *Element;
303
304 /* ###----------------------------------------------### */
305 /* Checking that each output have at least one driver*/
306 /* ###----------------------------------------------### */
307
308 /*printf("liste des types\n");
309 fbtyp_pnt = FBL_BEFPNT->BETYP;
310 while (fbtyp_pnt != 0)
311 {
312 printf("name : %s [%d]\n",fbtyp_pnt->NAME,j);
313 printf("class : %c \n",fbtyp_pnt->CLASS);
314 printf("BASE : %d \n",fbtyp_pnt->BASE);
315 printf("INDEX : %d \n",fbtyp_pnt->INDEX);
316 printf("TYPE : %d \n",chktab (hshtab,fbtyp_pnt->NAME,FBL_MODNAM,FBL_TYPDFN) );
317 if(fbtyp_pnt->VALUE != 0)
318 for ( i= 0; i< fbtyp_pnt->SIZE ; i++)
319 printf("VAL : %s \n",*(fbtyp_pnt->VALUE + i));
320 fbtyp_pnt = fbtyp_pnt->NEXT;
321 j++;
322 }*/
323
324 fbout_pnt = FBL_BEFPNT->BEOUT;
325 while (fbout_pnt != 0)
326 {
327 Element = searchauthelem( FBL_HASH_ASG_FSM, fbout_pnt->NAME );
328 if ( Element != (authelem *)0 ) SetFbhAssignByFsm( fbout_pnt );
329
330 /* LUDO
331 if ( (fbout_pnt->ABL == 0) &&
332 (! IsFbhAssignByFsm( fbout_pnt ) ) )
333 {
334 fbl_error (40,fbout_pnt->NAME);
335 }
336 */
337 fbout_pnt = fbout_pnt->NEXT;
338 }
339
340 /*fbrin_pnt = FBL_BEFPNT->BERIN;
341 while (fbout_pnt != 0)
342 {
343 printf("%s \n",fbrin_pnt->NAME);
344 if (fbout_pnt->ABL == 0)
345 fbl_error (40,fbrin_pnt->NAME);
346 fbrin_pnt = fbrin_pnt->NEXT;
347 }*/
348
349 /*fbpcs_pnt = FBL_BEFPNT->BEPCS;
350 while (fbpcs_pnt != 0)
351 {
352 struct fbpgm *fbpgm;
353 struct ptype *fbtyp;
354 printf("label : %s \n",fbpcs_pnt->LABEL);
355 fbpgm = FBL_BEFPNT->BEPGM;
356 while(fbpgm)
357 {
358 fbpgm = fbpgm->NEXT;
359 }
360 fbtyp = fbpcs_pnt->INSTRUCTION;
361 while(fbtyp)
362 {
363 display_fbh(fbtyp);
364 fbtyp = fbtyp->NEXT;
365 }
366 fbpcs_pnt = fbpcs_pnt->NEXT;
367 }*/
368
369 fbaux_pnt = FBL_BEFPNT->BEAUX;
370 while (fbaux_pnt != 0)
371 {
372 Element = searchauthelem( FBL_HASH_ASG_FSM, fbaux_pnt->NAME );
373 if ( Element != (authelem *)0 ) SetFbhAssignByFsm( fbaux_pnt );
374
375 if ( (fbaux_pnt->ABL == 0) &&
376 (! IsFbhAssignByFsm( fbaux_pnt ) ) )
377 {
378 fbl_error (40,fbaux_pnt->NAME);
379 }
380 fbaux_pnt = fbaux_pnt->NEXT;
381 }
382
383 fbbus_pnt = FBL_BEFPNT->BEBUS;
384 while (fbbus_pnt != 0)
385 {
386 if (fbbus_pnt->BIABL == 0)
387 {
388 fbl_error (40,fbbus_pnt->NAME);
389 }
390 fbbus_pnt = fbbus_pnt->NEXT;
391 }
392
393 fbreg_pnt = FBL_BEFPNT->BEREG;
394 while (fbreg_pnt != 0)
395 {
396 if (fbreg_pnt->BIABL == 0)
397 {
398 fbl_error (40,fbreg_pnt->NAME);
399 }
400 fbreg_pnt = fbreg_pnt->NEXT;
401 }
402 fretab (hshtab);
403 destroyauthtable( FBL_HASH_ASG_FSM );
404 }
405 ;
406
407 ..design_unit..
408 : /*empty*/
409 | design_unit
410 ..design_unit..
411 ;
412
413 design_unit
414 : context_clause
415 library_unit
416 ;
417
418 library_unit
419 : primary_unit
420 { }
421 | secondary_unit
422 { }
423 | error
424 { }
425 ;
426
427 primary_unit
428 : entity_declaration
429 { }
430 ;
431
432 secondary_unit
433 : architecture_body
434 { }
435 ;
436
437 library_clause
438 : LIBRARY
439 logical_name_list
440 Semicolon_ERR
441 { }
442 ;
443
444 logical_name_list
445 : Identifier
446 ...logical_name..
447 { }
448 ;
449
450 ...logical_name..
451 : /*empty*/
452 | ...logical_name..
453 Comma
454 Identifier
455 { }
456 ;
457
458 /* 11.3 */
459 context_clause
460 : ..context_item..
461 { }
462 ;
463
464 ..context_item..
465 : /*empty*/
466 | ..context_item..
467 context_item
468 { }
469 ;
470
471 context_item
472 : library_clause
473 { }
474 | use_clause
475 { }
476 ;
477
478 use_clause
479 : USE
480 selected_name /* package simple name */
481 ...selected_name..
482 Semicolon_ERR
483 {
484 }
485 ;
486
487 ...selected_name..
488 : /*empty*/
489 { }
490 | ...selected_name..
491 Comma
492 selected_name
493 { }
494 ;
495
496 selected_name
497 : prefix
498 Dot
499 suffix
500 {
501 }
502 ;
503
504 suffix
505 : simple_name
506 { }
507 | ALL
508 { }
509 ;
510
511 prefix
512 : simple_name
513 { }
514 | prefix
515 Dot
516 simple_name
517 { }
518 ;
519
520 entity_declaration
521 : ENTITY
522 simple_name
523 IS
524 {
525 long type,size=0;
526 struct fbtyp *fbtyp_pnt;
527 char *name;
528 char *name_bit;
529 char *name_bit_vector;
530 char *name_std_logic;
531 char *name_std_ulogic;
532 char *name_std_logic_vector;
533 char *name_std_ulogic_vector;
534 FBL_BEFPNT->NAME = $2;
535 FBL_MODNAM = $2;
536
537 fbtyp_pnt = fbh_prdeftyp();
538 FBL_BEFPNT->BETYP = fbtyp_pnt;
539 FBL_NUMTYP =1;
540 while(fbtyp_pnt)
541 {
542 size++;
543 fbtyp_pnt = fbtyp_pnt->NEXT;
544 }
545
546 name_bit = namealloc( "bit" );
547 name_bit_vector = namealloc( "bit_vector" );
548 name_std_logic = namealloc( "std_logic" );
549 name_std_ulogic = namealloc( "std_ulogic" );
550 name_std_logic_vector = namealloc( "std_logic_vector" );
551 name_std_ulogic_vector = namealloc( "std_ulogic_vector" );
552
553 fbtyp_pnt =FBL_BEFPNT->BETYP ;
554 while(fbtyp_pnt)
555 {
556 type = val_type(fbtyp_pnt->NAME);
557 addtab(hshtab,fbtyp_pnt->NAME,FBL_MODNAM,FBL_SIGDFN,FBL_TPEDFN);
558 addtab(hshtab,fbtyp_pnt->NAME,FBL_MODNAM,FBL_USRDFN,type);
559 addtab(hshtab,fbtyp_pnt->NAME,FBL_MODNAM,FBL_LBLDFN,fbtyp_pnt->CLASS);
560 addtab(hshtab,fbtyp_pnt->NAME,FBL_MODNAM,FBL_TYPDFN,size +1 - FBL_NUMTYP);
561 addtab(hshtab,fbtyp_pnt->NAME,FBL_MODNAM,FBL_PNTDFN,(long)fbtyp_pnt);
562 if ( ( fbtyp_pnt->NAME == name_bit ) ||
563 ( fbtyp_pnt->NAME == name_bit_vector ) )
564 {
565 if ( fbtyp_pnt->NAME == name_bit ) name = name_std_logic;
566 else name = name_std_logic_vector;
567
568 addtab(hshtab,name,FBL_MODNAM,FBL_SIGDFN,FBL_TPEDFN);
569 addtab(hshtab,name,FBL_MODNAM,FBL_USRDFN,type);
570 addtab(hshtab,name,FBL_MODNAM,FBL_LBLDFN,fbtyp_pnt->CLASS);
571 addtab(hshtab,name,FBL_MODNAM,FBL_TYPDFN,size +1 - FBL_NUMTYP);
572 addtab(hshtab,name,FBL_MODNAM,FBL_PNTDFN,(long)fbtyp_pnt);
573
574 if ( fbtyp_pnt->NAME == name_bit ) name = name_std_ulogic;
575 else name = name_std_ulogic_vector;
576
577 addtab(hshtab,name,FBL_MODNAM,FBL_SIGDFN,FBL_TPEDFN);
578 addtab(hshtab,name,FBL_MODNAM,FBL_USRDFN,type);
579 addtab(hshtab,name,FBL_MODNAM,FBL_LBLDFN,fbtyp_pnt->CLASS);
580 addtab(hshtab,name,FBL_MODNAM,FBL_TYPDFN,size +1 - FBL_NUMTYP);
581 addtab(hshtab,name,FBL_MODNAM,FBL_PNTDFN,(long)fbtyp_pnt);
582 }
583 fbtyp_pnt = fbtyp_pnt->NEXT;
584 FBL_NUMTYP++;
585 }
586 }
587 .port_clause.
588 END_ERR
589 .simple_name.
590 Semicolon_ERR
591 {
592 if (($7 != 0) && ($7 != $2))
593 {
594 fbl_error (1,$7);
595 }
596 }
597 | ENTITY
598 error
599 { fbl_error (2,0); }
600 ;
601
602 .constraint.
603 : /*empty*/
604 {
605 $$.FLAG = 'U';
606 $$.LEFT = -1;
607 $$.RIGHT = -1;
608 }
609 | constraint
610 { $$ = $1; }
611 ;
612
613 constraint
614 : LeftParen
615 range
616 RightParen_ERR
617 { $$ = $2; }
618 ;
619
620 range_constraint
621 : RANGE
622 range
623 { $$ = $2; }
624 ;
625
626 range
627 : abstractlit
628 direction
629 abstractlit
630 {
631 $$.FLAG = 'A';
632 $$.LEFT = $1;
633 $$.RIGHT = $3;
634
635 if ((($1 > $3) && ($2 == FBL_UPTDFN)) ||
636 (($1 < $3) && ($2 == FBL_DWTDFN)) ||
637 (($1 < 0 ) || ($2 < 0 )))
638 {
639 fbl_error (32,0);
640 }
641 }
642 ;
643
644 direction
645 : TO
646 { $$ = FBL_UPTDFN; }
647 | DOWNTO
648 { $$ = FBL_DWTDFN; }
649 ;
650
651 .port_clause.
652 : /*empty*/
653 | port_clause
654 ;
655
656 port_clause
657 : PORT
658 LeftParen
659 formal_port_list
660 RightParen_ERR
661 Semicolon_ERR
662 | PORT
663 error
664 Semicolon_ERR
665 { fbl_error (3,0); }
666 ;
667
668 formal_port_list
669 : formal_port_element
670 ...formal_port_element..
671 ;
672
673 ...formal_port_element..
674 : /*empty*/
675 | ...formal_port_element..
676 Semicolon_ERR
677 formal_port_element
678 ;
679
680 formal_port_element
681 : .SIGNAL.
682 identifier_list
683 Colon
684 .mode.
685 type_mark
686 .constraint.
687 .signal_kind.
688 {
689 char *signame;
690 long sigconf;
691 void *pnt;
692
693 /* ###----------------------------------------------### */
694 /* First, check the validity of the declaration. */
695 /* Then, for each port, create the apropriate set of */
696 /* structures (fbrin, fbpor, fbout, fbbus) */
697 /* ###----------------------------------------------### */
698
699 fbl_chkdcl ('P', $4, val_type($5.NAME), $5.FLAG, $7, $6.FLAG,&sigconf);
700
701 FBL_NM1LST = reverse (FBL_NM1LST);
702 while (FBL_NM1LST != 0)
703 {
704 signame = (char *)FBL_NM1LST->DATA;
705 if (chktab (hshtab,signame,FBL_MODNAM,FBL_SIGDFN) != 0)
706 {
707 fbl_error (4,signame);
708 }
709
710 pnt = fbl_addstr (FBL_BEFPNT,'P',$4,val_type($5.NAME),$5.TYPE,$5.FLAG,signame,
711 $6.LEFT,$6.RIGHT);
712
713 addtab (hshtab,signame,FBL_MODNAM,FBL_SIGDFN,sigconf);
714 addtab (hshtab,signame,FBL_MODNAM,FBL_TYPDFN,$5.TYPE);
715 addtab (hshtab,signame,FBL_MODNAM,FBL_WMNDFN,$6.LEFT);
716 addtab (hshtab,signame,FBL_MODNAM,FBL_WMXDFN,$6.RIGHT);
717 addtab (hshtab,signame,FBL_MODNAM,FBL_LBLDFN,$7);
718 addtab (hshtab,signame,FBL_MODNAM,FBL_PNTDFN,(long)pnt);
719
720 FBL_NM1LST = delchain (FBL_NM1LST, FBL_NM1LST);
721 }
722 }
723 | error
724 {
725 /* ###----------------------------------------------### */
726 /* The following 3 lines reject tokens until the */
727 /* sync. token 'Semicolon' is found */
728 /* ###----------------------------------------------### */
729
730 /*do
731 yychar = yylex ();
732 while ((yychar != Semicolon) && (yychar != 0));
733 yyerrok;
734 */
735 fbl_error (6,0);
736 }
737 ;
738
739 .SIGNAL.
740 : /*empty*/
741 | SIGNAL
742 ;
743
744 .mode.
745 : /*empty*/
746 { $$ = FBL_ICNDFN; }
747 | _IN
748 { $$ = FBL_ICNDFN; }
749 | _OUT
750 { $$ = FBL_OCNDFN; }
751 | _INOUT
752 { $$ = FBL_BCNDFN; }
753 ;
754
755 architecture_body
756 : ARCHITECTURE
757 Identifier
758 OF
759 simple_name
760 IS
761 {
762 if ($4 != FBL_MODNAM)
763 {
764 fbl_error (1,$4);
765 }
766 }
767 architecture_declarative_part
768 {
769 struct fbtyp *listfbtyp;
770 struct fbtyp *fbtypaux;
771 struct fbtyp *revfbtyp = 0;
772 listfbtyp = FBL_BEFPNT->BETYP;
773 revfbtyp = listfbtyp;
774 listfbtyp = listfbtyp->NEXT;
775 revfbtyp->NEXT = 0;
776 while(listfbtyp != 0)
777 {
778 fbtypaux = revfbtyp;
779 revfbtyp = listfbtyp;
780 listfbtyp = listfbtyp->NEXT;
781 revfbtyp->NEXT = fbtypaux;
782 }
783
784 FBL_BEFPNT->BETYP = fbh_crtfbtyp(revfbtyp);
785 }
786 _BEGIN
787 architecture_statement_part
788 END_ERR
789 .simple_name.
790 Semicolon_ERR
791 {
792 if (($12 != 0) && ($12 != $2))
793 {
794 fbl_error (7,$12);
795 }
796 }
797 | ARCHITECTURE
798 error
799 { fbl_error (8,0); }
800 ;
801
802 architecture_declarative_part
803 : ..block_declarative_item..
804 ;
805
806 ..block_declarative_item..
807 : /*empty*/
808 | ..block_declarative_item..
809 block_declarative_item
810 ;
811
812 block_declarative_item
813 : signal_declaration
814 | type_declaration
815 | subtype_declaration
816 | constant_declaration
817 | pragma_declaration
818 | error
819 Semicolon_ERR
820 { fbl_error (9,0); }
821 ;
822
823 pragma_declaration
824 : Pragma
825 {
826 char pragma[30];
827 char type[128];
828 char name[128];
829 char value[128];
830 char *pt = NULL;
831 long field;
832
833 field = sscanf((char *)$1,"-- %s %s %s %s", pragma,type,name,value);
834
835 if ( field == 3 ) pt = (void *)0;
836 else
837 if ( field == 4 ) pt = namealloc( value );
838 else
839 {
840 fbl_error (86,0);
841 }
842
843 FBL_BEFPNT->BEPGM = fbh_addfbpgm(FBL_BEFPNT->BEPGM,type,name,pt);
844 FBL_BEFPNT->BEPGM->LINE_NUM = FBL_LINNUM;
845 }
846 ;
847
848 constant_declaration
849 : CONSTANT
850 Identifier
851 Colon
852 type_mark
853 .constraint.
854 constant_VarAsgn__expression
855 Semicolon_ERR
856 {
857 long sigconf;
858
859 if (fbl_chkdcl ('C',0,val_type($4.NAME),$4.FLAG,0,$5.FLAG,&sigconf) == 0)
860 {
861 addtab (hshtab,$2,FBL_MODNAM,FBL_WMNDFN,$5.LEFT);
862 addtab (hshtab,$2,FBL_MODNAM,FBL_WMXDFN,$5.RIGHT);
863 addtab (hshtab,$2,FBL_MODNAM,FBL_SIGDFN,sigconf);
864 addtab (hshtab,$2,FBL_MODNAM,FBL_TYPDFN,-1);
865 addtab (hshtab,$2,0,FBL_PNTDFN,$6);
866 }
867 }
868 ;
869
870 constant_VarAsgn__expression
871 : VarAsgn
872 literal
873 { $$ = $2; }
874 ;
875
876 signal_declaration
877 : SIGNAL
878 identifier_list
879 Colon
880 type_mark
881 .constraint.
882 .signal_kind.
883 Semicolon_ERR
884 {
885 char *signame;
886 long sigconf;
887 void *pnt;
888
889 /*errflg =*/ fbl_chkdcl ('S',0,val_type($4.NAME),$4.FLAG,$6,$5.FLAG,&sigconf);
890
891 /* ###----------------------------------------------### */
892 /* First, check the validity of the declaration. */
893 /* Then, for each signal, create the apropriate set of */
894 /* structures (fbrin, fbreg, fbaux, fbbux)
895 */
896 /* ###----------------------------------------------### */
897
898 /*if( val_type($4.NAME) != -1)
899 fbl_error(81,$4.NAME);*/
900 /*else */
901 {
902 FBL_NM1LST = reverse (FBL_NM1LST);
903 while (FBL_NM1LST != 0)
904 {
905 signame = (char *)FBL_NM1LST->DATA;
906 if (chktab (hshtab,signame,FBL_MODNAM,FBL_SIGDFN) != 0)
907 {
908 fbl_error (10,signame);
909 }
910
911 pnt = fbl_addstr (FBL_BEFPNT,'S',0,val_type($4.NAME),$4.TYPE,
912 $4.FLAG,signame, $5.LEFT,$5.RIGHT);
913
914 addtab (hshtab,signame,FBL_MODNAM,FBL_SIGDFN,sigconf);
915 addtab (hshtab,signame,FBL_MODNAM,FBL_TYPDFN,$4.TYPE);
916 addtab (hshtab,signame,FBL_MODNAM,FBL_WMNDFN,$5.LEFT);
917 addtab (hshtab,signame,FBL_MODNAM,FBL_WMXDFN,$5.RIGHT);
918 addtab (hshtab,signame,FBL_MODNAM,FBL_LBLDFN,$6);
919 addtab (hshtab,signame,FBL_MODNAM,FBL_PNTDFN,(long)pnt);
920
921 FBL_NM1LST = delchain (FBL_NM1LST,FBL_NM1LST);
922
923 }
924 }
925 }
926 ;
927
928 type_declaration
929 : full_type_declaration
930 ;
931
932 full_type_declaration
933 : FBHTYPE
934 Identifier
935 IS
936 type_definition
937 {
938 FBL_BEFPNT->BETYP = fbh_addfbtyp(FBL_BEFPNT->BETYP,$2,$4.LEFT,
939 $4.RIGHT,$4.VALUE,$4.SIZE,$4.BYTE,$4.BASE,$4.INDEX,$4.RESOLV,$4.CLASS);
940 FBL_BEFPNT->BETYP->LINE_NUM = FBL_LINNUM;
941 addtab(hshtab,$2,FBL_MODNAM,FBL_SIGDFN,FBL_TPEDFN);
942 addtab(hshtab,$2,FBL_MODNAM,FBL_LBLDFN,$4.CLASS);
943 addtab(hshtab,$2,FBL_MODNAM,FBL_TYPDFN,FBL_NUMTYP);
944 addtab (hshtab,$2,FBL_MODNAM,FBL_PNTDFN,(long)FBL_BEFPNT->BETYP);
945 FBL_NUMTYP++;
946 }
947 Semicolon_ERR
948 ;
949
950 type_definition
951 : scalar_type_definition
952 { $$ = $1; }
953 | composite_type_definition
954 { $$ = $1; }
955 | error Semicolon_ERR
956 { yyerrok; }
957 ;
958
959 subtype_declaration
960 : SUBTYPE
961 Identifier
962 IS
963 subtype_indication
964 {
965 FBL_BEFPNT->BETYP = fbh_addfbtyp(FBL_BEFPNT->BETYP,$2,$4.LEFT,
966 $4.RIGHT,$4.VALUE,$4.SIZE,$4.BYTE,$4.BASE,$4.INDEX,$4.RESOLV,$4.CLASS);
967 FBL_BEFPNT->BETYP->LINE_NUM = FBL_LINNUM;
968 addtab(hshtab,$2,FBL_MODNAM,FBL_SIGDFN,FBL_TPEDFN);
969 addtab(hshtab,$2,FBL_MODNAM,FBL_LBLDFN,$4.CLASS);
970 addtab(hshtab,$2,FBL_MODNAM,FBL_TYPDFN,FBL_NUMTYP);
971 addtab (hshtab,$2,FBL_MODNAM,FBL_PNTDFN,(long)FBL_BEFPNT->BETYP);
972 FBL_NUMTYP++;
973 }
974 Semicolon_ERR
975 ;
976
977 subtype_indication
978 : type_mark
979 .constraint.
980 { struct fbtyp *fbtyp_pnt;
981 fbtyp_pnt = (struct fbtyp*)chktab(hshtab,$1,FBL_MODNAM,FBL_PNTDFN);
982 $$.BASE = $1.TYPE ;
983 $$.VALUE = 0 ;
984 $$.SIZE = 0 ;
985 $$.BYTE = fbtyp_pnt->BYTE ;
986 $$.LEFT = $2.LEFT ;
987 $$.RIGHT = $2.RIGHT ;
988 $$.CLASS = 'S' ;
989 $$.RESOLV = 0 ;
990 }
991 ;
992
993 scalar_type_definition
994 : enumeration_type_definition
995 {
996 $$ = $1;
997 }
998 ;
999 enumeration_type_definition
1000 : LeftParen
1001 enumeration_literal
1002 ...enumeration_literal..
1003 RightParen_ERR
1004 {
1005 char *enumname;
1006 long size=0;
1007 long indice=0;
1008 char **pnt = NULL;
1009 chain_list *nm1lst;
1010
1011 FBL_NM1LST = reverse (FBL_NM1LST);
1012
1013 nm1lst = FBL_NM1LST;
1014 while (nm1lst != 0)
1015 {
1016 size++;
1017 nm1lst = nm1lst->NEXT;
1018 }
1019 if( size != 0)
1020 pnt = (char **) malloc(size * sizeof(char*));
1021
1022 while (FBL_NM1LST != 0)
1023 {
1024 enumname = namealloc((char *)FBL_NM1LST->DATA);
1025 if (chktab (hshtab,enumname,FBL_MODNAM,FBL_SIGDFN) != 0)
1026 {
1027 fbl_error (82,enumname);
1028 }
1029
1030 addtab (hshtab,enumname,FBL_MODNAM,FBL_SIGDFN,FBL_CSTDFN);
1031 addtab (hshtab,enumname,FBL_MODNAM,FBL_TYPDFN,FBL_NUMTYP);
1032 addtab (hshtab,enumname,FBL_MODNAM,FBL_USRDFN,size);
1033 addtab (hshtab,enumname,FBL_MODNAM,FBL_WMNDFN,-1);
1034 addtab (hshtab,enumname,FBL_MODNAM,FBL_WMXDFN,-1);
1035 addtab (hshtab,enumname,FBL_MODNAM,FBL_LBLDFN,indice);
1036 addtab (hshtab,enumname,FBL_MODNAM,FBL_PNTDFN,(long)pnt);
1037
1038 pnt[indice++] = enumname;
1039 FBL_NM1LST = delchain (FBL_NM1LST, FBL_NM1LST);
1040 }
1041 $$.VALUE = pnt ;
1042 $$.SIZE = size ;
1043 $$.LEFT = 0 ;
1044 $$.RIGHT = 0 ;
1045 $$.BYTE = size/256 +1;
1046 $$.CLASS = 'E' ;
1047 $$.BASE = 0 ;
1048 $$.RESOLV = 0 ;
1049 }
1050 ;
1051
1052
1053 ...enumeration_literal..
1054 : /*empty*/
1055 | ...enumeration_literal..
1056 Comma
1057 enumeration_literal
1058 { yyerrok; }
1059 ;
1060
1061 enumeration_literal
1062 : Identifier
1063 { FBL_NM1LST = addchain (FBL_NM1LST,$1); }
1064 | CharacterLit
1065 { FBL_NM1LST = addchain (FBL_NM1LST,$1); }
1066 ;
1067
1068
1069 composite_type_definition
1070 : array_type_definition
1071 {
1072 $$ = $1;
1073 }
1074 ;
1075
1076 array_type_definition
1077 : unconstrained_array_definition
1078 { $$ = $1; }
1079 | constrained_array_definition
1080 { $$ = $1; }
1081 ;
1082
1083 unconstrained_array_definition
1084 : ARRAY
1085 LeftParen
1086 index_subtype_definition
1087 RightParen_ERR
1088 OF
1089 subtype_indication
1090 {
1091 $$ = $6;
1092 $$.CLASS = 'U';
1093 $$.INDEX = $3.TYPE;
1094 }
1095 ;
1096
1097 constrained_array_definition
1098 : ARRAY
1099 index_constraint
1100 OF
1101 subtype_indication
1102 { $$ = $4;
1103 $$.CLASS = 'A';
1104 $$.INDEX = $2.TYPE;
1105 }
1106 ;
1107
1108 index_subtype_definition
1109 : name /* type_mark - causes conflict */
1110 RANGE
1111 Box
1112 {
1113 $$.NAME = $1.NAME;
1114 $$.LEFT = $1.LEFT;
1115 $$.RIGHT = $1.RIGHT;
1116 /*$$.TYPE = chktab(hshtab,$1,FBL_MODNAM,FBL_TYPDFN); */
1117 $$.TYPE = $1.TYPE;
1118 $$.FLAG = chktab(hshtab,$1,FBL_MODNAM,FBL_LBLDFN);
1119 if ($$.TYPE == 0 || $$.FLAG ==0)
1120 {
1121 fbl_error(83,$1.NAME);
1122 }
1123 }
1124 ;
1125
1126 index_constraint
1127 : LeftParen
1128 discrete_range
1129 RightParen_ERR
1130 { $$ = $2;}
1131 ;
1132
1133 discrete_range
1134 : range /* includes attribute_name */
1135 { $$ = $1;}
1136 | name
1137 range_constraint /* subtype_indication - causes conflict */
1138 { $$ = $2;
1139 $$.NAME = $1.NAME;
1140 }
1141 | type_mark /* type_mark causes 2 r/r conflicts - required for
1142 louie's code */
1143 { $$ = $1;}
1144 ;
1145
1146 type_mark
1147 : simple_name
1148 {
1149 long type;
1150 $$.NAME = $1;
1151 $$.LEFT = -1;
1152 $$.RIGHT = -1;
1153 $$.TYPE = chktab(hshtab,$1,FBL_MODNAM,FBL_TYPDFN);
1154 $$.FLAG = chktab(hshtab,$1,FBL_MODNAM,FBL_LBLDFN);
1155 type = chktab(hshtab,$1,FBL_MODNAM,FBL_SIGDFN);
1156 if (type != FBL_TPEDFN || $$.TYPE ==0)
1157 {
1158 fbl_error(84,$1);
1159 }
1160 }
1161 ;
1162
1163
1164 .signal_kind.
1165 : /*empty*/
1166 { $$ = 0; }
1167 | REGISTER
1168 { $$ = REGISTER; }
1169 | BUS
1170 { $$ = BUS; }
1171 ;
1172
1173 architecture_statement_part
1174 : ..concurrent_statement..
1175 ;
1176
1177 ..concurrent_statement..
1178 : /*empty*/
1179 | ..concurrent_statement..
1180 concurrent_statement
1181 ;
1182
1183 concurrent_statement
1184 : process_statement
1185 | block_statement
1186 | concurrent_assertion_statement
1187 | concurrent_signal_assignment_statement
1188 | error
1189 Semicolon_ERR
1190 { fbl_error (18,0); }
1191 ;
1192
1193 /* DEBUT LUDO */
1194
1195 block_statement
1196 : a_label
1197 _BLOCK
1198 .guard_expression.
1199 _BEGIN
1200 {
1201 if (chktab (hshtab,$1,FBL_MODNAM,FBL_LBLDFN) != 0)
1202 {
1203 fbl_error (19,$1);
1204 }
1205
1206 addtab (hshtab,$1,FBL_MODNAM,FBL_LBLDFN,1);
1207 if ($3 != NULL)
1208 FBL_GRDLST = addchain (FBL_GRDLST,(char *)$3);
1209 }
1210 set_of_statements
1211 END_ERR
1212 _BLOCK
1213 .label.
1214 Semicolon_ERR
1215 {
1216 if ($3 != NULL)
1217 FBL_GRDLST = delchain (FBL_GRDLST,FBL_GRDLST);
1218 if (($9 != NULL) && ($9 != $1))
1219 {
1220 fbl_error (20,$9);
1221 }
1222 }
1223 ;
1224
1225 set_of_statements
1226 : ..concurrent_statement..
1227 ;
1228
1229 concurrent_assertion_statement
1230 : a_label
1231 unlabeled_concurrent_assertion_statement
1232 {
1233 if (chktab (hshtab,$1,FBL_MODNAM,FBL_LBLDFN) != 0)
1234 {
1235 fbl_error (19,$1);
1236 }
1237
1238 addtab (hshtab,$1,FBL_MODNAM,FBL_LBLDFN,1);
1239 if (FBL_ERRFLG == 0)
1240 FBL_BEFPNT->BEMSG->LABEL = $1;
1241 }
1242 | unlabeled_concurrent_assertion_statement
1243 ;
1244
1245 concurrent_signal_assignment_statement
1246 : a_label
1247 unlabeled_conditional_signal_assignment
1248 {
1249 if (chktab (hshtab,$1,FBL_MODNAM,FBL_LBLDFN) != 0)
1250 {
1251 fbl_error (19,$1);
1252 }
1253 addtab (hshtab,$1,FBL_MODNAM,FBL_LBLDFN,1);
1254 }
1255 | unlabeled_conditional_signal_assignment
1256 | a_label
1257 unlabeled_selected_signal_assignment
1258 {
1259 if (chktab (hshtab,$1,FBL_MODNAM,FBL_LBLDFN) != 0)
1260 {
1261 {
1262 fbl_error (19,$1);
1263 }
1264 }
1265 addtab (hshtab,$1,FBL_MODNAM,FBL_LBLDFN,1);
1266 }
1267 | unlabeled_selected_signal_assignment
1268 ;
1269
1270 unlabeled_concurrent_assertion_statement
1271 : assertion_statement
1272 ;
1273
1274 unlabeled_conditional_signal_assignment
1275 : target
1276 _LESym
1277 .GUARDED.
1278 ..waveform__WHEN__condition__ELSE..
1279 waveform
1280 Semicolon_ERR
1281 {
1282 long i;
1283 struct fbout *fbout_pnt;
1284 struct fbbus *fbbus_pnt;
1285 struct fbreg *fbreg_pnt;
1286 struct fbaux *fbaux_pnt;
1287 struct fbbux *fbbux_pnt;
1288 struct chain *abl_pnt;
1289 struct fbl_expr expr0;
1290 struct fbl_expr expr1;
1291 struct fbl_expr expr2;
1292 struct fbl_expr expr3;
1293 struct fbl_expr expr4;
1294 struct fbl_expr expr5;
1295 struct fbl_expr expr6;
1296 long rev_flg = 0;
1297 long left_bnd;
1298 long right_bnd;
1299 long left;
1300 long right;
1301 long in_bound;
1302 long out_bound;
1303 long sig_width;
1304 long sig_conf;
1305
1306 expr4 = $5;
1307
1308 while (FBL_CNDLST != NULL)
1309 {
1310 expr5 = *((fbl_ablstr *) FBL_CNDLST->DATA);
1311 expr6 = *((fbl_ablstr *) FBL_VALLST->DATA);
1312
1313 expr0 = fbl_cpyablstr (expr5);
1314 expr1 = fbl_crtabl (ABL_NOT , expr5, FBL_EMPSTR,-1,-1);
1315 expr5 = expr0;
1316 expr2 = fbl_crtabl (ANDM, expr4, expr1 ,-1,-1);
1317 expr3 = fbl_crtabl (ANDM, expr6, expr5 ,-1,-1);
1318 expr4 = fbl_crtabl (ABL_OR , expr2, expr3 ,-1,-1);
1319
1320 FBL_CNDLST = delchain (FBL_CNDLST,FBL_CNDLST);
1321 FBL_VALLST = delchain (FBL_VALLST,FBL_VALLST);
1322 }
1323
1324 left_bnd = chktab (hshtab,$1.NAME,FBL_MODNAM,FBL_WMNDFN);
1325 right_bnd = chktab (hshtab,$1.NAME,FBL_MODNAM,FBL_WMXDFN);
1326 sig_conf = chktab (hshtab,$1.NAME,FBL_MODNAM,FBL_SIGDFN);
1327
1328 left = $1.LEFT;
1329 right = $1.RIGHT;
1330
1331 if (left_bnd <= right_bnd)
1332 {
1333 sig_width = right_bnd - left_bnd + 1;
1334 if (left <= right)
1335 {
1336 rev_flg = 0;
1337 in_bound = right_bnd - right;
1338 out_bound = right_bnd - left;
1339 if ((left < left_bnd) || (right > right_bnd))
1340 {
1341 fbl_error (36,$1.NAME);
1342 }
1343 }
1344 else
1345 {
1346 rev_flg = 1;
1347 in_bound = right_bnd - left;
1348 out_bound = right_bnd - right;
1349 if ((left > right_bnd) || (right < left_bnd))
1350 {
1351 fbl_error (36,$1.NAME);
1352 }
1353 }
1354 }
1355 else
1356 {
1357 sig_width = left_bnd - right_bnd + 1;
1358 if (left <= right)
1359 {
1360 rev_flg = 1;
1361 in_bound = left - right_bnd;
1362 out_bound = right - right_bnd;
1363 if ((left < right_bnd) || (right > left_bnd))
1364 {
1365 fbl_error (36,$1.NAME);
1366 }
1367 }
1368 else
1369 {
1370 rev_flg = 0;
1371 in_bound = right - right_bnd;
1372 out_bound = left - right_bnd;
1373 if ((left > left_bnd) || (right < right_bnd))
1374 {
1375 fbl_error (36,$1.NAME);
1376 }
1377 }
1378 }
1379
1380 if ((out_bound - in_bound + 1) != expr4.WIDTH)
1381 {
1382 fbl_error (35,$1.NAME);
1383 }
1384
1385 if (rev_flg == 1)
1386 expr4.LIST_ABL = reverse (expr4.LIST_ABL);
1387
1388 abl_pnt = expr4.LIST_ABL;
1389
1390 switch (sig_conf)
1391 {
1392 case (FBL_ICNDFN + FBL_BITDFN + FBL_NORDFN) :
1393 {
1394 fbl_error (21,$1.NAME);
1395 }
1396 break;
1397
1398 case (FBL_OCNDFN + FBL_BITDFN + FBL_NORDFN) :
1399 case (FBL_BCNDFN + FBL_BITDFN + FBL_NORDFN) :
1400 if ($3 == FBL_GRDDFN)
1401 {
1402 fbl_error (22,$1.NAME);
1403 }
1404 fbout_pnt = (struct fbout *)
1405 chktab (hshtab,$1.NAME,FBL_MODNAM,FBL_PNTDFN);
1406 if (FBL_ERRFLG == 0)
1407 {
1408 for (i=0 ; i<sig_width ; i++)
1409 {
1410 if (i >= in_bound)
1411 {
1412 if (fbout_pnt->ABL != NULL)
1413 {
1414 fbl_error (39,fbout_pnt->NAME);
1415 }
1416 else
1417 fbout_pnt->ABL = (struct chain *)abl_pnt->DATA;
1418 abl_pnt = abl_pnt->NEXT;
1419 }
1420 if (i >= out_bound)
1421 break;
1422 fbout_pnt = fbout_pnt->NEXT;
1423 }
1424 }
1425 break;
1426
1427 case (FBL_OCNDFN + FBL_MUXDFN + FBL_BUSDFN) :
1428 case (FBL_OCNDFN + FBL_WORDFN + FBL_BUSDFN) :
1429 case (FBL_BCNDFN + FBL_MUXDFN + FBL_BUSDFN) :
1430 case (FBL_BCNDFN + FBL_WORDFN + FBL_BUSDFN) :
1431 if (($3 != FBL_GRDDFN) || (FBL_GRDLST == NULL))
1432 {
1433 fbl_error (23,$1.NAME);
1434 }
1435 fbbus_pnt = (struct fbbus *)
1436 chktab (hshtab,$1.NAME,FBL_MODNAM,FBL_PNTDFN);
1437 if (FBL_ERRFLG == 0)
1438 {
1439 for (i=0 ; i<sig_width ; i++)
1440 {
1441 if (i >= in_bound)
1442 {
1443 fbbus_pnt->BINODE = fbh_addbinode (fbbus_pnt->BINODE,
1444 NULL,NULL);
1445 fbbus_pnt->BIABL = fbh_addbiabl (fbbus_pnt->BIABL,
1446 FBL_LBLNAM,
1447 dupablexpr(FBL_GRDLST->DATA) ,
1448 abl_pnt->DATA);
1449 abl_pnt = abl_pnt->NEXT;
1450 }
1451 if (i >= out_bound)
1452 break;
1453 fbbus_pnt = fbbus_pnt->NEXT;
1454 }
1455 }
1456 break;
1457
1458 case (FBL_BITDFN + FBL_NORDFN):
1459 if ($3 == FBL_GRDDFN)
1460 {
1461 fbl_error (22,$1.NAME);
1462 }
1463 fbaux_pnt = (struct fbaux *)
1464 chktab (hshtab,$1.NAME,FBL_MODNAM,FBL_PNTDFN);
1465 if (FBL_ERRFLG == 0)
1466 {
1467 for (i=0 ; i<sig_width ; i++)
1468 {
1469 if (i >= in_bound)
1470 {
1471 if (fbaux_pnt->ABL != NULL)
1472 {
1473 fbl_error (39,fbaux_pnt->NAME);
1474 }
1475 else
1476 fbaux_pnt->ABL = (struct chain *)abl_pnt->DATA;
1477 abl_pnt = abl_pnt->NEXT;
1478 }
1479 if (i >= out_bound)
1480 break;
1481 fbaux_pnt = fbaux_pnt->NEXT;
1482 }
1483 }
1484 break;
1485
1486 case (FBL_RBIDFN + FBL_REGDFN):
1487 if (($3 != FBL_GRDDFN) || (FBL_GRDLST == NULL))
1488 {
1489 fbl_error (23,$1.NAME);
1490 }
1491 fbreg_pnt = (struct fbreg *)
1492 chktab (hshtab,$1.NAME,FBL_MODNAM,FBL_PNTDFN);
1493 if (FBL_ERRFLG == 0)
1494 {
1495 for (i=0 ; i<sig_width ; i++)
1496 {
1497 if (i >= in_bound)
1498 {
1499 fbreg_pnt->BINODE = fbh_addbinode (fbreg_pnt->BINODE,
1500 NULL,NULL);
1501 fbreg_pnt->BIABL = fbh_addbiabl (fbreg_pnt->BIABL,
1502 FBL_LBLNAM,
1503 dupablexpr(FBL_GRDLST->DATA) ,
1504 abl_pnt->DATA);
1505 abl_pnt = abl_pnt->NEXT;
1506 }
1507 if (i >= out_bound)
1508 break;
1509 fbreg_pnt = fbreg_pnt->NEXT;
1510 }
1511 }
1512 break;
1513
1514 case (FBL_MUXDFN + FBL_BUSDFN) :
1515 case (FBL_WORDFN + FBL_BUSDFN) :
1516 if (($3 != FBL_GRDDFN) || (FBL_GRDLST == NULL))
1517 {
1518 fbl_error (23,$1.NAME);
1519 }
1520 fbbux_pnt = (struct fbbux *)
1521 chktab (hshtab,$1.NAME,FBL_MODNAM,FBL_PNTDFN);
1522 if (FBL_ERRFLG == 0)
1523 {
1524 for (i=0 ; i<sig_width ; i++)
1525 {
1526 if (i >= in_bound)
1527 {
1528 fbbux_pnt->BINODE = fbh_addbinode (fbbux_pnt->BINODE,
1529 NULL,NULL);
1530 fbbux_pnt->BIABL = fbh_addbiabl (fbbux_pnt->BIABL,
1531 FBL_LBLNAM,
1532 dupablexpr(FBL_GRDLST->DATA) ,
1533 abl_pnt->DATA);
1534 abl_pnt = abl_pnt->NEXT;
1535 }
1536 if (i >= out_bound)
1537 break;
1538 fbbux_pnt = fbbux_pnt->NEXT;
1539 }
1540 }
1541 break;
1542
1543 default :
1544 {
1545 fbl_error (17,$1.NAME);
1546 }
1547 break;
1548 }
1549 }
1550 ;
1551
1552 ..waveform__WHEN__condition__ELSE..
1553 : /*empty*/
1554 | ..waveform__WHEN__condition__ELSE..
1555 waveform
1556 WHEN
1557 expression
1558 ELSE
1559 {
1560 struct fbl_expr *expr_pnt;
1561
1562 expr_pnt = (fbl_ablstr *)mbkalloc(sizeof(fbl_ablstr));
1563 expr_pnt->WIDTH = $4.WIDTH;
1564 expr_pnt->LIST_ABL = $4.LIST_ABL;
1565 FBL_CNDLST = addchain (FBL_CNDLST,(char *) expr_pnt);
1566
1567 expr_pnt = (fbl_ablstr *)mbkalloc(sizeof(fbl_ablstr));
1568 expr_pnt->WIDTH = $2.WIDTH;
1569 expr_pnt->LIST_ABL = $2.LIST_ABL;
1570 FBL_VALLST = addchain (FBL_VALLST,(char *) expr_pnt);
1571 }
1572 ;
1573
1574 unlabeled_selected_signal_assignment
1575 : WITH
1576 expression
1577 {
1578 FBL_SLCEXP = $2;
1579 FBL_BDDPNT = NULL;
1580 }
1581 SELECT
1582 target
1583 _LESym
1584 .GUARDED.
1585 waveform__WHEN__choices
1586 ...waveform__WHEN__choices..
1587 Semicolon_ERR
1588 {
1589 long i;
1590 struct fbout *fbout_pnt;
1591 struct fbbus *fbbus_pnt;
1592 struct fbreg *fbreg_pnt;
1593 struct fbaux *fbaux_pnt;
1594 struct fbbux *fbbux_pnt;
1595 struct chain *abl_pnt;
1596 struct fbl_expr expr1;
1597 long rev_flg = 0;
1598 long left_bnd;
1599 long right_bnd;
1600 long left;
1601 long right;
1602 long in_bound;
1603 long out_bound;
1604 long sig_width;
1605 long sig_conf;
1606
1607 expr1 = fbl_crtabl (ABL_OR ,$8 ,$9,-1,-1);
1608 if (FBL_BDDPNT != getlogbddnodeone())
1609 {
1610 fbl_error (25,NULL);
1611 }
1612 left_bnd = chktab (hshtab,$5.NAME,FBL_MODNAM,FBL_WMNDFN);
1613 right_bnd = chktab (hshtab,$5.NAME,FBL_MODNAM,FBL_WMXDFN);
1614 sig_conf = chktab (hshtab,$5.NAME,FBL_MODNAM,FBL_SIGDFN);
1615
1616 left = $5.LEFT;
1617 right = $5.RIGHT;
1618 if (left_bnd <= right_bnd)
1619 {
1620 sig_width = right_bnd - left_bnd + 1;
1621 if (left <= right)
1622 {
1623 rev_flg = 0;
1624 in_bound = right_bnd - right;
1625 out_bound = right_bnd - left;
1626 if ((left < left_bnd) || (right > right_bnd))
1627 {
1628 fbl_error (36,$5.NAME);
1629 }
1630 }
1631 else
1632 {
1633 rev_flg = 1;
1634 in_bound = right_bnd - left;
1635 out_bound = right_bnd - right;
1636 if ((left > right_bnd) || (right < left_bnd))
1637 {
1638 fbl_error (36,$5.NAME);
1639 }
1640 }
1641 }
1642 else
1643 {
1644 sig_width = left_bnd - right_bnd + 1;
1645 if (left <= right)
1646 {
1647 rev_flg = 1;
1648 in_bound = left - right_bnd;
1649 out_bound = right - right_bnd;
1650 if ((left < right_bnd) || (right > left_bnd))
1651 {
1652 fbl_error (36,$5.NAME);
1653 }
1654 }
1655 else
1656 {
1657 rev_flg = 0;
1658 in_bound = right - right_bnd;
1659 out_bound = left - right_bnd;
1660 if ((left > left_bnd) || (right < right_bnd))
1661 {
1662 fbl_error (36,$5.NAME);
1663 }
1664 }
1665 }
1666
1667 if ((out_bound - in_bound + 1) != expr1.WIDTH)
1668 {
1669 fbl_error (35,$5.NAME);
1670 }
1671
1672 if (rev_flg == 1)
1673 expr1.LIST_ABL = reverse (expr1.LIST_ABL);
1674
1675 abl_pnt = expr1.LIST_ABL;
1676
1677 switch (sig_conf)
1678 {
1679 case (FBL_ICNDFN + FBL_BITDFN + FBL_NORDFN) :
1680 {
1681 fbl_error (21,$5.NAME);
1682 }
1683 break;
1684
1685 case (FBL_OCNDFN + FBL_BITDFN + FBL_NORDFN) :
1686 case (FBL_BCNDFN + FBL_BITDFN + FBL_NORDFN) :
1687 if ($7 == FBL_GRDDFN)
1688 {
1689 fbl_error (22,$5.NAME);
1690 }
1691 fbout_pnt = (struct fbout *)
1692 chktab (hshtab,$5.NAME,FBL_MODNAM,FBL_PNTDFN);
1693 if (FBL_ERRFLG == 0)
1694 {
1695 for (i=0 ; i<sig_width ; i++)
1696 {
1697 if (i >= in_bound)
1698 {
1699 if (fbout_pnt->ABL != NULL)
1700 {
1701 fbl_error (39,fbout_pnt->NAME);
1702 }
1703 else
1704 fbout_pnt->ABL = (struct chain *)abl_pnt->DATA;
1705 abl_pnt = abl_pnt->NEXT;
1706 }
1707 if (i >= out_bound)
1708 break;
1709 fbout_pnt = fbout_pnt->NEXT;
1710 }
1711 }
1712 break;
1713
1714 case (FBL_OCNDFN + FBL_MUXDFN + FBL_BUSDFN) :
1715 case (FBL_OCNDFN + FBL_WORDFN + FBL_BUSDFN) :
1716 case (FBL_BCNDFN + FBL_MUXDFN + FBL_BUSDFN) :
1717 case (FBL_BCNDFN + FBL_WORDFN + FBL_BUSDFN) :
1718 if (($7 != FBL_GRDDFN) || (FBL_GRDLST == NULL))
1719 {
1720 fbl_error (23,$5.NAME);
1721 }
1722 fbbus_pnt = (struct fbbus *)
1723 chktab (hshtab,$5.NAME,FBL_MODNAM,FBL_PNTDFN);
1724 if (FBL_ERRFLG == 0)
1725 {
1726 for (i=0 ; i<sig_width ; i++)
1727 {
1728 if (i >= in_bound)
1729 {
1730 fbbus_pnt->BINODE = fbh_addbinode (fbbus_pnt->BINODE,
1731 NULL,NULL);
1732 fbbus_pnt->BIABL = fbh_addbiabl (fbbus_pnt->BIABL,
1733 FBL_LBLNAM,
1734 dupablexpr(FBL_GRDLST->DATA) ,
1735 abl_pnt->DATA);
1736 abl_pnt = abl_pnt->NEXT;
1737 }
1738 if (i >= out_bound)
1739 break;
1740 fbbus_pnt = fbbus_pnt->NEXT;
1741 }
1742 }
1743 break;
1744
1745 case (FBL_BITDFN + FBL_NORDFN):
1746 if ($7 == FBL_GRDDFN)
1747 {
1748 fbl_error (22,$5.NAME);
1749 }
1750 fbaux_pnt = (struct fbaux *)
1751 chktab (hshtab,$5.NAME,FBL_MODNAM,FBL_PNTDFN);
1752 if (FBL_ERRFLG == 0)
1753 {
1754 for (i=0 ; i<sig_width ; i++)
1755 {
1756 if (i >= in_bound)
1757 {
1758 if (fbaux_pnt->ABL != NULL)
1759 {
1760 fbl_error (39,fbaux_pnt->NAME);
1761 }
1762 else
1763 {
1764 fbaux_pnt->ABL = (struct chain *)abl_pnt->DATA;
1765 }
1766 abl_pnt = abl_pnt->NEXT;
1767 }
1768 if (i >= out_bound)
1769 break;
1770 fbaux_pnt = fbaux_pnt->NEXT;
1771 }
1772 }
1773 break;
1774
1775 case (FBL_RBIDFN + FBL_REGDFN):
1776 if (($7 != FBL_GRDDFN) || (FBL_GRDLST == NULL))
1777 {
1778 fbl_error (23,$5.NAME);
1779 }
1780 fbreg_pnt = (struct fbreg *)
1781 chktab (hshtab,$5.NAME,FBL_MODNAM,FBL_PNTDFN);
1782 if (FBL_ERRFLG == 0)
1783 {
1784 for (i=0 ; i<sig_width ; i++)
1785 {
1786 if (i >= in_bound)
1787 {
1788 fbreg_pnt->BINODE = fbh_addbinode (fbreg_pnt->BINODE,
1789 NULL,NULL);
1790 fbreg_pnt->BIABL = fbh_addbiabl (fbreg_pnt->BIABL,
1791 FBL_LBLNAM,
1792 dupablexpr(FBL_GRDLST->DATA) ,
1793 abl_pnt->DATA);
1794 abl_pnt = abl_pnt->NEXT;
1795 }
1796 if (i >= out_bound)
1797 break;
1798 fbreg_pnt = fbreg_pnt->NEXT;
1799 }
1800 }
1801 break;
1802
1803 case (FBL_MUXDFN + FBL_BUSDFN) :
1804 case (FBL_WORDFN + FBL_BUSDFN) :
1805 if (($7 != FBL_GRDDFN) || (FBL_GRDLST == NULL))
1806 {
1807 fbl_error (23,$5.NAME);
1808 }
1809 fbbux_pnt = (struct fbbux *)
1810 chktab (hshtab,$5.NAME,FBL_MODNAM,FBL_PNTDFN);
1811 if (FBL_ERRFLG == 0)
1812 {
1813 for (i=0 ; i<sig_width ; i++)
1814 {
1815 if (i >= in_bound)
1816 {
1817 fbbux_pnt->BINODE = fbh_addbinode (fbbux_pnt->BINODE,
1818 NULL,NULL);
1819 fbbux_pnt->BIABL = fbh_addbiabl (fbbux_pnt->BIABL,
1820 FBL_LBLNAM,
1821 dupablexpr(FBL_GRDLST->DATA) ,
1822 abl_pnt->DATA);
1823 abl_pnt = abl_pnt->NEXT;
1824 }
1825 if (i >= out_bound)
1826 break;
1827 fbbux_pnt = fbbux_pnt->NEXT;
1828 }
1829 }
1830 break;
1831
1832 default :
1833 {
1834 fbl_error (17,$5.NAME);
1835 }
1836 break;
1837 }
1838 }
1839 ;
1840 /* FIN LUDO */
1841
1842 process_statement
1843 : a_label
1844 {
1845 FBL_LBLNAM = namealloc($1);
1846 }
1847 unlabeled_process_statement
1848 | {
1849 char buffer[ 64 ];
1850
1851 sprintf( buffer, "process_%ld", FBL_LINNUM );
1852 FBL_LBLNAM = namealloc( buffer );
1853 }
1854 unlabeled_process_statement
1855 ;
1856
1857 unlabeled_process_statement
1858 : PROCESS
1859 {FBL_NM1LST = 0 ;}
1860 .sensitivity_list.
1861 { FBL_BEFPNT->BEPCS = fbh_addfbpcs(FBL_BEFPNT->BEPCS,FBL_LBLNAM,FBL_NM1LST,0,0,0);
1862 FBL_BEFPNT->BEPCS->LINE_NUM = FBL_LINNUM;
1863 FBL_NM1LST = 0; }
1864 process_declarative_part
1865 _BEGIN
1866 {
1867 void *pnt;
1868 pnt = (void *)(&(FBL_BEFPNT->BEPCS->INSTRUCTION));
1869 FBL_NM1LST = addchain(0,pnt);
1870 }
1871
1872 sequence_of_statements
1873 {
1874 struct ptype **pnt;
1875 struct ptype *ptype;
1876 pnt = (struct ptype**)FBL_NM1LST->DATA;
1877 ptype = reversetype(*pnt);
1878 *pnt = ptype;
1879 FBL_NM1LST = delchain (FBL_NM1LST, FBL_NM1LST);
1880 }
1881 END_ERR
1882 PROCESS
1883 .label.
1884 Semicolon_ERR
1885 {
1886 yyerrok;
1887 }
1888 ;
1889
1890 process_declarative_part
1891 : ..process_declarative_item..
1892 ;
1893
1894
1895 ..process_declarative_item..
1896 : /*empty*/
1897 | ..process_declarative_item..
1898 process_declarative_item
1899 {
1900 yyerrok;
1901 }
1902 ;
1903
1904 process_declarative_item
1905 : constant_declaration
1906 | type_declaration
1907 | subtype_declaration
1908 ;
1909
1910 .sensitivity_list.
1911 : /*empty*/
1912 | sensitivity_list
1913 ;
1914
1915 sensitivity_list
1916 : LeftParen
1917 signal_list
1918 RightParen
1919 ;
1920
1921 signal_list
1922 : name
1923 ...name..
1924 {
1925 if($1.TYPE == 0)
1926 {
1927 fbl_error(17,$1.NAME) ;
1928 }
1929 FBL_NM1LST = addchain (FBL_NM1LST,$1.NAME); }
1930 ;
1931
1932 ...name..
1933 : /*empty*/
1934 | Comma
1935 name
1936 ...name..
1937 {
1938 if($2.TYPE == 0)
1939 {
1940 fbl_error(17,$2.NAME) ;
1941 }
1942 FBL_NM1LST = addchain (FBL_NM1LST,$2.NAME); }
1943 ;
1944
1945 sequence_of_statements
1946 : ..sequential_statement..
1947 ;
1948
1949 ..sequential_statement..
1950 : /*empty*/
1951 | ..sequential_statement..
1952 sequential_statement
1953 ;
1954
1955 sequential_statement
1956 : assertion_statement
1957 | signal_assignment_statement
1958 | if_statement
1959 | case_statement
1960 | null_statement
1961 ;
1962
1963
1964 assertion_statement
1965 : ASSERT
1966 expression
1967 .REPORT__expression.
1968 .SEVERITY__expression.
1969 Semicolon_ERR
1970 {
1971 FBL_BEFPNT->BEMSG = fbh_addfbmsg(FBL_BEFPNT->BEMSG,0,$4,$3,$2.LIST_ABL->DATA,0);
1972 FBL_BEFPNT->BEMSG->LINE_NUM = FBL_LINNUM;
1973 }
1974 ;
1975
1976 signal_assignment_statement
1977 : target
1978 _LESym
1979 waveform
1980 Semicolon_ERR
1981 { unsigned long type;
1982 long sig_conf,i;
1983 long left_bnd,right_bnd;
1984 long in_bound,out_bound;
1985 long left ,right;
1986 long rev_flg, debut;
1987 long sig_width;
1988 struct chain *abl_pnt;
1989 char extname[100];
1990 struct fbl_expr expr;
1991 struct ptype **pnt;
1992
1993 type = chktab(hshtab,$1.NAME,FBL_MODNAM,FBL_TYPDFN);
1994 sig_conf = chktab(hshtab,$1.NAME,FBL_MODNAM,FBL_SIGDFN);
1995
1996 if( type == 0)
1997 {
1998 fbl_error(17,$1.NAME);
1999 }
2000
2001 addauthelem( FBL_HASH_ASG_FSM, $1.NAME, 1 );
2002
2003 left_bnd = chktab (hshtab,$1.NAME,FBL_MODNAM,FBL_WMNDFN);
2004 right_bnd = chktab (hshtab,$1.NAME,FBL_MODNAM,FBL_WMXDFN);
2005
2006 left = $1.LEFT;
2007 right = $1.RIGHT;
2008
2009 expr = $3;
2010
2011 if (left_bnd <= right_bnd)
2012 {
2013 sig_width = right_bnd - left_bnd + 1;
2014 if (left <= right)
2015 {
2016 rev_flg = 0;
2017 in_bound = right_bnd - right;
2018 out_bound = right_bnd - left;
2019 if ((left < left_bnd) || (right > right_bnd))
2020 {
2021 fbl_error (36,$1.NAME);
2022 }
2023 debut = left;
2024 }
2025
2026 else
2027 {
2028 rev_flg = 1;
2029 in_bound = right_bnd - left;
2030 out_bound = right_bnd - right;
2031 if ((left > right_bnd) || (right < left_bnd))
2032 {
2033 fbl_error (36,$1.NAME);
2034 }
2035 debut = right;
2036 }
2037 }
2038 else
2039 {
2040 sig_width = left_bnd - right_bnd + 1;
2041 if (left <= right)
2042 {
2043 rev_flg = 1;
2044 in_bound = left - right_bnd;
2045 out_bound = right - right_bnd;
2046 if ((left < right_bnd) || (right > left_bnd))
2047 {
2048 fbl_error (36,$1.NAME);
2049 }
2050 debut = left;
2051 }
2052 else
2053 {
2054 rev_flg = 0;
2055 in_bound = right - right_bnd;
2056 out_bound = left - right_bnd;
2057 if ((left > left_bnd) || (right < right_bnd))
2058 {
2059 fbl_error (36,$1.NAME);
2060 }
2061 debut = right;
2062 }
2063 }
2064 if ((out_bound - in_bound + 1) != expr.WIDTH)
2065 {
2066 fbl_error (35,$1.NAME);
2067 }
2068
2069 if (rev_flg == 1)
2070 expr.LIST_ABL = reverse (expr.LIST_ABL);
2071
2072 abl_pnt = expr.LIST_ABL;
2073
2074
2075 if( sig_conf == FBL_ICNDFN)
2076 {
2077 fbl_error(21,$1.NAME);
2078 }
2079 /* LUDO
2080 else if( sig_conf == 0)
2081 {
2082 fbl_error(17,$1.NAME);
2083 }
2084 */
2085 else
2086 {
2087 pnt = (struct ptype**)(FBL_NM1LST->DATA);
2088 if(sig_width >1)
2089 {
2090 for (i=0 ; i<sig_width ; i++)
2091 {
2092 char *newname;
2093
2094 sprintf (extname,"%s %ld",$1.NAME,i+debut-in_bound);
2095 newname = namealloc( extname );
2096 if (i >= in_bound)
2097 {
2098 *pnt =fbh_addfbasg(*pnt,newname, (struct chain *)abl_pnt->DATA,type);
2099 ((struct fbasg *)((*pnt)->DATA))->LINE_NUM = FBL_LINNUM;
2100 abl_pnt = abl_pnt->NEXT;
2101
2102 addauthelem( FBL_HASH_ASG_FSM, newname, 1 );
2103 }
2104 if (i >= out_bound)
2105 break;
2106 }
2107 }
2108 else
2109 {
2110 *pnt = fbh_addfbasg(*pnt,$1.NAME,abl_pnt->DATA,type);
2111 ((struct fbasg *)((*pnt)->DATA))->LINE_NUM = FBL_LINNUM;
2112 }
2113 }
2114 }
2115 ;
2116
2117 waveform_element
2118 : expression
2119 { $$ = $1; }
2120 ;
2121
2122 if_statement
2123 : IF
2124 condition
2125 THEN
2126 {
2127 struct ptype **pnt;
2128 pnt = (struct ptype**)FBL_NM1LST->DATA;
2129 *pnt = fbh_addfbifs(*pnt,$2.LIST_ABL->DATA);
2130 ((struct fbifs *)((*pnt)->DATA))->LINE_NUM = FBL_LINNUM;
2131 FBL_NM1LST = addchain(FBL_NM1LST,&(((struct fbifs*)(*pnt)->DATA)->CNDTRUE));
2132 }
2133 sequence_of_statements
2134 {
2135 struct ptype **pnt;
2136 struct ptype *ptype;
2137 pnt = (struct ptype**)FBL_NM1LST->DATA;
2138 ptype = reversetype(*pnt);
2139 *pnt = ptype;
2140 FBL_NM1LST = delchain (FBL_NM1LST, FBL_NM1LST);
2141 pnt = (struct ptype**)FBL_NM1LST->DATA;
2142 FBL_NM1LST = addchain(FBL_NM1LST,&(((struct fbifs*)(*pnt)->DATA)->CNDFALSE));
2143 }
2144 ..ELSIF__THEN__seq_of_stmts..
2145 .ELSE__seq_of_stmts.
2146 END_ERR
2147 IF
2148 Semicolon_ERR
2149 ;
2150
2151 ..ELSIF__THEN__seq_of_stmts..
2152 : /*empty*/
2153 | ..ELSIF__THEN__seq_of_stmts..
2154 ELSIF
2155 condition
2156 THEN
2157 {
2158 struct ptype **pnt;
2159 pnt = (struct ptype**)FBL_NM1LST->DATA;
2160 *pnt = fbh_addfbifs(*pnt,$3.LIST_ABL->DATA);
2161 ((struct fbifs *)((*pnt)->DATA))->LINE_NUM = FBL_LINNUM;
2162 FBL_NM1LST = addchain(FBL_NM1LST,(void*)&((struct fbifs*)(*pnt)->DATA)->CNDTRUE);
2163 }
2164 sequence_of_statements
2165 {
2166 struct ptype **pnt;
2167 struct ptype *ptype;
2168 pnt = (struct ptype**)FBL_NM1LST->DATA;
2169 ptype = reversetype(*pnt);
2170 *pnt = ptype;
2171 FBL_NM1LST = delchain (FBL_NM1LST, FBL_NM1LST);
2172 pnt = (struct ptype**)FBL_NM1LST->DATA;
2173 FBL_NM1LST = delchain (FBL_NM1LST, FBL_NM1LST);
2174 FBL_NM1LST = addchain(FBL_NM1LST,&((struct fbifs*)(*pnt)->DATA)->CNDFALSE);
2175 yyerrok; }
2176 ;
2177
2178 .ELSE__seq_of_stmts.
2179 : /*empty*/
2180 {
2181 FBL_NM1LST = delchain (FBL_NM1LST, FBL_NM1LST);
2182 yyerrok;
2183 }
2184 | ELSE
2185 sequence_of_statements
2186 {
2187 struct ptype *ptype;
2188 struct ptype **pnt;
2189 pnt = (struct ptype**)FBL_NM1LST->DATA;
2190 ptype = reversetype(*pnt);
2191 *pnt = ptype;
2192 FBL_NM1LST = delchain (FBL_NM1LST, FBL_NM1LST);
2193 yyerrok;
2194 }
2195 ;
2196
2197 case_statement
2198 : CASE
2199 expression
2200 {
2201 struct ptype **pnt;
2202
2203 pnt = (struct ptype**)FBL_NM1LST->DATA;
2204
2205 /*fbcas = (struct fbcas *)mbkalloc(sizeof(struct fbcas));
2206 fbcas->CHOICE = 0;
2207 fbcas->USER = 0;
2208 fbcas->LINE_NUM = 0;
2209 fbcas->SIZE = 0;
2210 fbcas->TYPE = $2.TYPE;
2211 fbcas->ABL = $2.LIST_ABL->DATA;*/
2212 FBL_OTHPNT = 0;
2213 *pnt = fbh_addfbcas(*pnt,$2.LIST_ABL->DATA,$2.TYPE);
2214 ((struct fbcas *)((*pnt)->DATA))->LINE_NUM = FBL_LINNUM;
2215 FBL_NM1LST = addchain(FBL_NM1LST,(void*)&(((struct fbcas*)((*pnt)->DATA))->SIZE));
2216 FBL_NM1LST = addchain(FBL_NM1LST,(void*)&(((struct fbcas*)(*pnt)->DATA)->CHOICE));
2217 }
2218 IS
2219 case_statement_alternative
2220 ..case_statement_alternative..
2221 END_ERR
2222 CASE
2223 Semicolon_ERR
2224 {
2225 unsigned long size=1;
2226 unsigned long *size1;
2227 long indice=0;
2228 struct fbcho **pnt;
2229 struct fbcho *tab = NULL;
2230 struct choice_chain *nm1lst;
2231
2232
2233 nm1lst = FBL_CASPNT;
2234 while (nm1lst != 0)
2235 {
2236 size++;
2237 nm1lst = nm1lst->NEXT;
2238 }
2239 pnt = (struct fbcho**)FBL_NM1LST->DATA;
2240 FBL_NM1LST = delchain(FBL_NM1LST,FBL_NM1LST);
2241 if( size != 0)
2242 tab = (struct fbcho*)mbkalloc(size*sizeof(struct fbcho));
2243 while(FBL_CASPNT)
2244 {
2245 tab[indice].INSTRUCTION = reversetype(FBL_CASPNT->INSTRUCTION);
2246 tab[indice].SIZE = FBL_CASPNT->SIZE;
2247 tab[indice++].VALUE = FBL_CASPNT->VALUE;
2248 /*ch = FBL_CASPNT;*/
2249 FBL_CASPNT =FBL_CASPNT->NEXT;
2250 /*free(ch);*/
2251 }
2252 tab[indice].INSTRUCTION = reversetype(FBL_OTHPNT);
2253 tab[indice].SIZE = -1;
2254 tab[indice++].VALUE = namealloc("others");
2255 (*pnt) = tab;
2256 size1 = (unsigned long*) FBL_NM1LST->DATA;
2257 *size1 = size;
2258 FBL_NM1LST = delchain(FBL_NM1LST,FBL_NM1LST);
2259 FBL_OTHPNT = 0;
2260 }
2261 ;
2262
2263 ..case_statement_alternative..
2264 : /*empty*/
2265 | ..case_statement_alternative..
2266 case_statement_alternative
2267 { yyerrok; }
2268 ;
2269
2270 case_statement_alternative
2271 : WHEN
2272 choices
2273 Arrow {
2274 FBL_PTYPE = 0;
2275 FBL_NM1LST = addchain(FBL_NM1LST,(void*)&FBL_PTYPE);
2276 }
2277 sequence_of_statements
2278 {
2279 if( FBL_CNDLST == 0)
2280 {
2281 fbl_error(85,"case");
2282 }
2283 else if ( FBL_CNDLST->DATA == 0)
2284 {
2285 FBL_OTHPNT = FBL_PTYPE ;
2286 while (FBL_CNDLST )
2287 {
2288 FBL_CNDLST = delchain(FBL_CNDLST,FBL_CNDLST);
2289 }
2290 }
2291 else
2292 while(FBL_CNDLST)
2293 {
2294 char* val;
2295 val = (char *)FBL_CNDLST->DATA;
2296 FBL_CASPNT = order_choice(FBL_CASPNT,FBL_PTYPE,val,strlen(val));
2297 FBL_CNDLST = delchain(FBL_CNDLST,FBL_CNDLST);
2298 }
2299 FBL_NM1LST = delchain(FBL_NM1LST,FBL_NM1LST);
2300 }
2301 ;
2302
2303 /* DEBUT LUDO */
2304
2305 ...waveform__WHEN__choices..
2306 : /*empty*/
2307 {
2308 $$ = FBL_EMPSTR;
2309 }
2310 | ...waveform__WHEN__choices..
2311 Comma
2312 waveform__WHEN__choices
2313 {
2314 $$ = fbl_crtabl (ABL_OR,$1,$3,-1,-1);
2315 }
2316 ;
2317
2318 waveform__WHEN__choices
2319 : waveform
2320 WHEN
2321 choices2
2322 {
2323 fbl_ablstr expr1;
2324
2325 fbl_select (&expr1,FBL_NM1LST,&FBL_BDDPNT,&FBL_SLCEXP);
2326 freechain (FBL_NM1LST);
2327 FBL_NM1LST = NULL;
2328
2329 $$ = fbl_crtabl(ANDM,$1,expr1,-1,-1);
2330 }
2331 ;
2332
2333 choices2
2334 : choice
2335 {
2336 FBL_NM1LST = addchain (NULL ,$1.NAME);
2337 }
2338 ..Bar__choice2..
2339 { yyerrok; }
2340 ;
2341
2342 ..Bar__choice2..
2343 : /*empty*/
2344 | ..Bar__choice2..
2345 Bar
2346 choice
2347 {
2348 if (!strncmp($3.NAME,"others",7))
2349 {
2350 fbl_error (30,NULL);
2351 }
2352 FBL_NM1LST = addchain (FBL_NM1LST ,$3.NAME);
2353 fprintf( stdout, "%s%d: %s\n", basename(__FILE__),__LINE__,$3.NAME );
2354 }
2355 ;
2356
2357
2358 /* FIN LUDO */
2359
2360 waveform
2361 : waveform_element
2362 { $$ = $1; }
2363 ;
2364
2365 choices
2366 : choice
2367 {
2368 if (strcmp($1.NAME , "others"))
2369 FBL_CNDLST = addchain (0 ,(void*)$1.NAME);
2370 else
2371 FBL_CNDLST = addchain (0 ,0);
2372 }
2373 ..Bar__choice..
2374 { yyerrok; }
2375 ;
2376
2377 null_statement
2378 : tok_NULL
2379 Semicolon_ERR
2380 ;
2381
2382 ..Bar__choice..
2383 : /*empty*/
2384 | ..Bar__choice..
2385 Bar
2386 choice
2387 {
2388 if (!strcmp($3.NAME , "others") || FBL_CNDLST->DATA == 0)
2389 {
2390 fbl_error (31,0);
2391 }
2392 FBL_CNDLST = addchain (FBL_CNDLST ,(void*)$3.NAME);
2393 }
2394 ;
2395
2396 choice
2397 : literal
2398 {
2399 $$.NAME = $1;
2400 $$.RIGHT = -1;
2401 $$.TYPE = -1;
2402 $$.LEFT = -1;}
2403 | OTHERS
2404 {
2405 $$.RIGHT = -1;
2406 $$.TYPE = -1;
2407 $$.LEFT = -1;
2408 $$.NAME = namealloc("others");}
2409 | name
2410 {
2411 char *val;
2412 char val2[256];
2413 long left;
2414 long right;
2415 long in_bound;
2416 long out_bound;
2417 long left_bnd;
2418 long right_bnd;
2419 long sig_conf;
2420
2421 strcpy (val2,"B\"");
2422 sig_conf = chktab (hshtab,$1.NAME,FBL_MODNAM,FBL_SIGDFN);
2423 val = (char *) chktab (hshtab,$1.NAME,0,FBL_PNTDFN);
2424 if (sig_conf == 0)
2425 {
2426 fbl_error (17,$1.NAME);
2427 }
2428 else
2429 {
2430 if (sig_conf != FBL_CSTDFN)
2431 {
2432 fbl_error (76,$1.NAME);
2433 }
2434 }
2435
2436 left_bnd = chktab (hshtab,$1.NAME,FBL_MODNAM,FBL_WMNDFN);
2437 right_bnd = chktab (hshtab,$1.NAME,FBL_MODNAM,FBL_WMXDFN);
2438
2439 left = $1.LEFT;
2440 right = $1.RIGHT;
2441
2442 if (left_bnd <= right_bnd)
2443 {
2444 if (left <= right)
2445 {
2446 in_bound = left - left_bnd;
2447 out_bound = right - left_bnd;
2448 if ((left < left_bnd) || (right > right_bnd))
2449 {
2450 fbl_error (36,$1.NAME);
2451 }
2452 }
2453 else
2454 {
2455 in_bound = left - right_bnd;
2456 out_bound = right - right_bnd;
2457 if ((left > right_bnd) || (right < left_bnd))
2458 {
2459 fbl_error (36,$1.NAME);
2460 }
2461 }
2462 }
2463 else
2464 {
2465 if (left <= right)
2466 {
2467 in_bound = right - left_bnd;
2468 out_bound = left - left_bnd;
2469 if ((left < right_bnd) || (right > left_bnd))
2470 {
2471 fbl_error (36,$1.NAME);
2472 }
2473 }
2474 else
2475 {
2476 in_bound = right - right_bnd;
2477 out_bound = left - right_bnd;
2478 if ((left > left_bnd) || (right < right_bnd))
2479 {
2480 fbl_error (36,$1.NAME);
2481 }
2482 }
2483 }
2484 if( chktab (hshtab,$1.NAME,FBL_MODNAM,FBL_TYPDFN) == -1)
2485 {
2486 fbl_tobin (&val2[2],val,in_bound,out_bound);
2487 strcat (val2,"\"");
2488 $$.NAME = namealloc (val2);
2489 $$.LEFT = -1;
2490 $$.RIGHT = -1;
2491 $$.TYPE = -1;
2492 }
2493 else
2494 {
2495 $$.LEFT = $1.LEFT;
2496 $$.RIGHT = $1.RIGHT;
2497 $$.TYPE = $1.TYPE;
2498 /* sig_conf = chktab(hshtab,$1.NAME,FBL_MODNAM,FBL_LBLDFN) ;
2499 $$.NAME = (char *)fbl_numtobin(sig_conf); */
2500 $$.NAME = $1.NAME;
2501 }
2502 }
2503 ;
2504
2505 condition
2506 : expression
2507 { $$ = $1; }
2508 ;
2509
2510 .REPORT__expression.
2511 : /*empty*/
2512 { $$ = 0;}
2513 | REPORT
2514 report__message
2515 { $$ = $2;}
2516 ;
2517
2518 .SEVERITY__expression.
2519 : /*empty*/
2520 { $$ = 'E';}
2521 | SEVERITY
2522 severity__message
2523 { $$ = $1;}
2524 ;
2525
2526 report__message
2527 : StringLit
2528 { fbl_stostr($1);}
2529 ;
2530
2531 severity__message
2532 : ERROR
2533 { $$ = 'E';}
2534 | WARNING
2535 { $$ = 'W';}
2536 ;
2537
2538 expression
2539 : relation..AND__relation..
2540 { $$ = $1; }
2541 | relation..OR__relation..
2542 { $$ = $1; }
2543 | relation.NAND_NOR__relation.
2544 { $$ = $1; }
2545 | relation..XOR__relation..
2546 { $$ = $1; }
2547 ;
2548
2549 relation..AND__relation..
2550 : relation
2551 tok_AND
2552 relation
2553 { $$ = fbl_crtabl (ABL_AND ,$1 ,$3 ,-1,-1); }
2554 | relation..AND__relation..
2555 tok_AND
2556 relation
2557 { $$ = fbl_crtabl (ABL_AND ,$1 ,$3 ,-1,-1);}
2558 ;
2559
2560 relation..OR__relation..
2561 : relation
2562 _OR
2563 relation
2564 { $$ = fbl_crtabl (ABL_OR ,$1 ,$3 ,-1,-1); }
2565 | relation..OR__relation..
2566 _OR
2567 relation
2568 { $$ = fbl_crtabl (ABL_OR ,$1 ,$3 ,-1,-1); }
2569 ;
2570
2571 relation.NAND_NOR__relation.
2572 : relation
2573 { $$ = $1; }
2574 | relation
2575 _NAND
2576 relation
2577 { $$ = fbl_crtabl (ABL_NAND ,$1 ,$3 ,-1,-1); }
2578 | relation
2579 _NOR
2580 relation
2581 { $$ = fbl_crtabl (ABL_NAND ,$1 ,$3 ,-1,-1); }
2582 ;
2583
2584 relation..XOR__relation..
2585 : relation
2586 _XOR
2587 relation
2588 { $$ = fbl_crtabl (ABL_XOR ,$1 ,$3 ,-1,-1); }
2589 | relation..XOR__relation..
2590 _XOR
2591 relation
2592 { $$ = fbl_crtabl (ABL_XOR ,$1 ,$3 ,-1,-1); }
2593 ;
2594
2595 relation
2596 : simple_expression
2597 { $$ = $1; }
2598 | simple_expression
2599 relational_operator
2600 simple_expression
2601 { $$ = fbl_crtabl ($2 ,$1 ,$3 ,-1,-1); }
2602 ;
2603
2604 simple_expression
2605 : .sign.term..add_op__term..
2606 { $$ = $1; }
2607 ;
2608
2609 .sign.term..add_op__term..
2610 : term
2611 { $$ = $1; }
2612 | .sign.term..add_op__term..
2613 Ampersand
2614 term
2615 { $$ = fbl_crtabl (CONC,$1,$3,-1,-1); }
2616 ;
2617
2618 term
2619 : factor
2620 { $$ = $1; }
2621 ;
2622
2623 factor
2624 : primary
2625 { $$ = $1; }
2626 | _NOT
2627 primary
2628 { $$ = fbl_crtabl (ABL_NOT,$2,FBL_EMPSTR,-1,-1); }
2629 ;
2630
2631 primary
2632 : literal
2633 {
2634 struct fbl_expr expr1;
2635
2636 expr1.IDENT = $1;
2637 expr1.TYPE = -1;
2638 $$ = fbl_crtabl (NOPS,expr1,FBL_EMPSTR,-1,-1);
2639 }
2640 | aggregate
2641 { $$ = $1; }
2642 | name
2643 {
2644 struct fbl_expr expr1;
2645 long left;
2646 long right;
2647 long left_bnd;
2648 long right_bnd;
2649 long in_bound;
2650 long out_bound;
2651 long mode;
2652 long type;
2653
2654 mode = chktab (hshtab,$1.NAME,FBL_MODNAM,FBL_SIGDFN);
2655 type = chktab(hshtab,$1.NAME,FBL_MODNAM,FBL_TYPDFN);
2656 if( mode == FBL_OCNDFN)
2657 {
2658 {
2659 fbl_error (26,$1.NAME);
2660 }
2661 $$.IDENT = 0;
2662 $$.LIST_ABL = 0;
2663 $$.WIDTH = 0;
2664 $$.TYPE = 0;
2665 }
2666 else if( type == 0 || mode == FBL_TPEDFN)
2667 {
2668 {
2669 fbl_error (17,$1.NAME);
2670 }
2671 $$.IDENT = 0;
2672 $$.LIST_ABL = 0;
2673 $$.WIDTH = 0;
2674 $$.TYPE = 0;
2675 }
2676 else
2677 {
2678 left_bnd = chktab (hshtab,$1.NAME,FBL_MODNAM,FBL_WMNDFN);
2679 right_bnd = chktab (hshtab,$1.NAME,FBL_MODNAM,FBL_WMXDFN);
2680
2681 left = $1.LEFT;
2682 right = $1.RIGHT;
2683
2684 if (left_bnd <= right_bnd)
2685 {
2686 if (left <= right)
2687 {
2688 in_bound = left - left_bnd;
2689 out_bound = right - left_bnd;
2690 if ((left < left_bnd) || (right > right_bnd))
2691 {
2692 fbl_error (36,$1.NAME);
2693 }
2694 }
2695 else
2696 {
2697 in_bound = right - left_bnd;
2698 out_bound = left - left_bnd;
2699 if ((left > right_bnd) || (right < left_bnd))
2700 {
2701 fbl_error (36,$1.NAME);
2702 }
2703 }
2704 }
2705 else
2706 {
2707 if (left <= right)
2708 {
2709 in_bound = left - right_bnd;
2710 out_bound = right - right_bnd;
2711 if ((left < right_bnd) || (right > left_bnd))
2712 {
2713 fbl_error (36,$1.NAME);
2714 }
2715 }
2716 else
2717 {
2718 in_bound = right - right_bnd;
2719 out_bound = left - right_bnd;
2720 if ((left > left_bnd) || (right < right_bnd))
2721 {
2722 fbl_error (36,$1.NAME);
2723 }
2724 }
2725 }
2726
2727 /* LUDO
2728 if ( mode == FBL_VARDFN)
2729 {
2730 expr1.IDENT = 0;
2731 expr1.TYPE = chktab(hshtab,$1.NAME,FBL_MODNAM,FBL_TYPDFN);
2732
2733 expr1.LIST_ABL = (struct chain *)chktab(hshtab,$1.NAME,FBL_MODNAM,FBL_PNTDFN);
2734 $$ = fbl_crtabl (SUBVAR,expr1,FBL_EMPSTR,in_bound,out_bound);
2735 }
2736 else
2737 */
2738 if ((mode != FBL_CSTDFN)||
2739 (chktab(hshtab,$1.NAME,FBL_MODNAM,FBL_TYPDFN) != -1))
2740 {
2741 expr1.IDENT = $1.NAME;
2742 /*prtype =*/ chktab(hshtab,$1.NAME,FBL_MODNAM,FBL_USRDFN);
2743 if(val_type((FBL_BEFPNT->BETYP + type -1)->NAME) !=-1)
2744 expr1.TYPE = chktab(hshtab,namealloc("bit"),FBL_MODNAM,FBL_TYPDFN);
2745 else
2746 expr1.TYPE = type;
2747 if($1.FLAG == 'X')
2748 {
2749 expr1 = fbl_crtabl (NOPI,expr1,FBL_EMPSTR,left,right);
2750 $$ = fbl_crtabl (ABL_STABLE,expr1,FBL_EMPSTR,left,right);
2751 }
2752 else
2753 if($1.FLAG == 'x')
2754 {
2755 expr1 = fbl_crtabl (NOPI,expr1,FBL_EMPSTR,left,right);
2756 expr1 = fbl_crtabl (ABL_STABLE,expr1,FBL_EMPSTR,left,right);
2757 $$ = fbl_crtabl (ABL_NOT,expr1,FBL_EMPSTR,left,right);
2758 }
2759 else
2760 {
2761 $$ = fbl_crtabl (NOPI,expr1,FBL_EMPSTR,left,right);
2762 }
2763 }
2764 else
2765 {
2766 expr1.IDENT = (char *)chktab(hshtab,$1.NAME,0,FBL_PNTDFN);
2767 expr1.TYPE =(long)-1;/*dec, cast long */
2768 $$ = fbl_crtabl (NOPS,expr1,FBL_EMPSTR,in_bound,out_bound);
2769 }
2770 }
2771 }
2772 ;
2773
2774 relational_operator
2775 : _EQSym
2776 { $$ = EQ; }
2777 | _NESym
2778 { $$ = NE; }
2779 | _GESym
2780 { $$ = GE; }
2781 | _GTSym
2782 { $$ = GT; }
2783 | _LESym
2784 { $$ = LE; }
2785 | _LTSym
2786 { $$ = LT; }
2787 ;
2788
2789 literal
2790 : CharacterLit
2791 { $$ = $1; }
2792 | StringLit
2793 { $$ = $1; }
2794 | BitStringLit
2795 { $$ = $1; }
2796 ;
2797
2798 aggregate
2799 : LeftParen
2800 expression
2801 RightParen
2802 { $$ = $2; }
2803 ;
2804
2805 name
2806 : simple_name
2807 {
2808 $$.NAME = $1;
2809 $$.TYPE = chktab (hshtab,$1,FBL_MODNAM,FBL_TYPDFN);
2810 $$.LEFT = chktab (hshtab,$1,FBL_MODNAM,FBL_WMNDFN);
2811 $$.RIGHT = chktab (hshtab,$1,FBL_MODNAM,FBL_WMXDFN);
2812 }
2813 | indexed_name
2814 { $$ = $1; }
2815 | slice_name
2816 { $$ = $1; }
2817 | attribute_name
2818 { $$ = $1; }
2819 ;
2820
2821 indexed_name
2822 : simple_name
2823 LeftParen
2824 abstractlit
2825 RightParen_ERR
2826 {
2827 $$.NAME = $1;
2828 $$.LEFT = $3;
2829 $$.TYPE = chktab (hshtab,$1,FBL_MODNAM,FBL_TYPDFN);
2830 $$.RIGHT = $3;
2831 }
2832 ;
2833
2834 slice_name
2835 : simple_name
2836 LeftParen
2837 abstractlit
2838 direction
2839 abstractlit
2840 RightParen_ERR
2841 {
2842 if ((($3 > $5) && ($4 == FBL_UPTDFN)) ||
2843 (($3 < $5) && ($4 == FBL_DWTDFN)))
2844 {
2845 fbl_error (32,$1);
2846 }
2847
2848 $$.NAME = $1;
2849 $$.TYPE = chktab (hshtab,$1,FBL_MODNAM,FBL_TYPDFN);
2850 $$.LEFT = $3;
2851 $$.RIGHT = $5;
2852 }
2853 ;
2854
2855 attribute_name
2856 : simple_name
2857 Apostrophe
2858 attribute_designator
2859 {
2860 char extname[100];
2861 char *lclname;
2862 long sig_conf;
2863 long type;
2864 long kind;
2865 struct fbl_expr expr1;
2866 struct fbl_expr expr2;
2867 struct chain *ptabl;
2868
2869 sprintf (extname,"%s'delayed",$1);
2870 lclname = namealloc (extname);
2871
2872 if (chktab (hshtab,lclname,FBL_MODNAM,FBL_SIGDFN) == 0 )
2873 {
2874 sig_conf = chktab (hshtab,$1,FBL_MODNAM,FBL_SIGDFN);
2875 switch (sig_conf)
2876 {
2877 case (FBL_ICNDFN + FBL_BITDFN + FBL_NORDFN) :
2878 case (FBL_BCNDFN + FBL_BITDFN + FBL_NORDFN) :
2879 case (FBL_BCNDFN + FBL_MUXDFN + FBL_BUSDFN) :
2880 case (FBL_BCNDFN + FBL_WORDFN + FBL_BUSDFN) :
2881 case (FBL_BITDFN + FBL_NORDFN):
2882 case (FBL_MUXDFN + FBL_BUSDFN):
2883 case (FBL_WORDFN + FBL_BUSDFN):
2884 case (FBL_RBIDFN + FBL_REGDFN):
2885 break;
2886 default :
2887 {
2888 fbl_error (79,$1);
2889 }
2890 }
2891 type = chktab (hshtab,$1,FBL_MODNAM,FBL_TYPDFN);
2892 kind = chktab (hshtab,$1,FBL_MODNAM,FBL_LBLDFN);
2893
2894 if (chktab (hshtab,$1,FBL_MODNAM,FBL_WMNDFN) != -1)
2895 {
2896 fbl_error (79,$1);
2897 }
2898
2899 if (FBL_ERRFLG == 0)
2900 {
2901 expr1.IDENT = $1;
2902 expr1.WIDTH = 1;
2903 expr2 = fbl_crtabl (NOPI,expr1,FBL_EMPSTR,-1,-1);
2904 ptabl = (struct chain*)expr2.LIST_ABL->DATA;
2905 FBL_BEFPNT->BEDLY = fbh_addfbaux(FBL_BEFPNT->BEDLY,lclname,
2906 ptabl,0,type);
2907 FBL_BEFPNT->BEDLY->LINE_NUM = FBL_LINNUM;
2908 /* LUDO addtab (hshtab,$1,FBL_MODNAM,FBL_STBDFN,1); */
2909 addtab (hshtab,lclname,FBL_MODNAM,FBL_WMNDFN,-1);
2910 addtab (hshtab,lclname,FBL_MODNAM,FBL_WMXDFN,-1);
2911 addtab (hshtab,lclname,FBL_MODNAM,FBL_TYPDFN, type);
2912 addtab (hshtab,lclname,FBL_MODNAM,FBL_LBLDFN, kind);
2913 addtab (hshtab,lclname,FBL_MODNAM,FBL_SIGDFN,
2914 (FBL_ICNDFN + FBL_BITDFN + FBL_NORDFN));
2915 }
2916 }
2917 $$.NAME = $1;
2918 $$.LEFT = -1;
2919 $$.RIGHT = -1;
2920 if ( $3 == FBL_STABLE ) $$.FLAG = 'X';
2921 else $$.FLAG = 'x';
2922 }
2923 ;
2924
2925 attribute_designator
2926 : _STABLE { $$ = FBL_STABLE; }
2927 | _EVENT { $$ = FBL_EVENT; }
2928 ;
2929
2930 identifier_list
2931 : Identifier
2932 { FBL_NM1LST = addchain (FBL_NM1LST,$1); }
2933 ...identifier..
2934 ;
2935
2936 ...identifier..
2937 : /*empty*/
2938 | ...identifier..
2939 Comma
2940 Identifier
2941 { FBL_NM1LST = addchain (FBL_NM1LST,$3); }
2942 ;
2943
2944 .label.
2945 : /*empty*/
2946 { $$ = 0; }
2947 | label
2948 { $$ = $1; }
2949 ;
2950
2951 /* DEBUT LUDO */
2952
2953 .guard_expression.
2954 : /*empty*/
2955 { $$ = NULL; }
2956 | guard_expression
2957 { $$ = $1; }
2958 ;
2959
2960 guard_expression
2961 : LeftParen
2962 expression
2963 RightParen_ERR
2964 { $$ = (char *)$2.LIST_ABL->DATA; }
2965 ;
2966
2967 .GUARDED.
2968 : /*empty*/
2969 { $$ = FBL_UNGDFN ; }
2970 | GUARDED
2971 { $$ = FBL_GRDDFN; }
2972 ;
2973
2974 /* FIN LUDO */
2975
2976 .simple_name.
2977 : /*empty*/
2978 { $$ = 0; }
2979 | simple_name
2980 { $$ = $1; }
2981 ;
2982
2983 simple_name
2984 : Identifier
2985 { $$ = $1; }
2986 ;
2987
2988 target
2989 : name
2990 { $$ = $1; }
2991 ;
2992
2993 a_label
2994 : label
2995 Colon
2996 {
2997 FBL_LBLNAM = $1;
2998 $$ = $1;
2999 }
3000 ;
3001
3002 label
3003 : Identifier
3004 { $$ = $1; }
3005 ;
3006
3007 abstractlit
3008 : AbstractLit
3009 { $$ = atoi($1); }
3010 ;
3011
3012 RightParen_ERR
3013 : RightParen
3014 { yyerrok; }
3015 ;
3016
3017 Semicolon_ERR
3018 : Semicolon
3019 { yyerrok; }
3020 ;
3021
3022 END_ERR
3023 : _END
3024 { yyerrok; }
3025 ;
3026 %%
addent(head,key)3027 static struct dct_entry *addent (head , key)
3028 struct dct_entry *head;
3029 char *key;
3030
3031 {
3032 struct dct_entry *entry;
3033 long i;
3034
3035 if (FBL_DCEHED == 0)
3036 {
3037 FBL_DCEHED = (struct dct_entry *)
3038 mbkalloc (sizeof(struct dct_entry) * FBL_ALODFN);
3039
3040 entry = FBL_DCEHED;
3041 for (i=1 ; i<FBL_ALODFN ; i++)
3042 {
3043 entry->next = entry + 1;
3044 entry++;
3045 }
3046 entry->next = 0;
3047 }
3048
3049 entry = FBL_DCEHED;
3050 FBL_DCEHED = FBL_DCEHED->next;
3051
3052 entry->next = head;
3053 entry->data = 0;
3054 entry->key = key;
3055
3056 return (entry);
3057 }
3058
addrcd(head,key)3059 static struct dct_recrd *addrcd (head , key)
3060
3061 struct dct_recrd *head;
3062 char *key;
3063
3064 {
3065 struct dct_recrd *recrd;
3066 long i;
3067
3068 if (FBL_DCRHED == 0)
3069 {
3070 FBL_DCRHED = (struct dct_recrd *)
3071 mbkalloc (sizeof(struct dct_recrd) * FBL_ALODFN);
3072
3073 recrd = FBL_DCRHED;
3074 for (i=1 ; i<FBL_ALODFN ; i++)
3075 {
3076 recrd->next = recrd + 1;
3077 recrd++;
3078 }
3079 recrd->next = 0;
3080 }
3081
3082 recrd = FBL_DCRHED;
3083 FBL_DCRHED = FBL_DCRHED->next;
3084
3085 recrd->next = head;
3086 recrd->fd0_val = 0;
3087 recrd->fd1_val = 0;
3088 recrd->fd2_val = 0;
3089 recrd->fd3_val = 0;
3090 recrd->fd4_val = 0;
3091 recrd->fd5_val = 0;
3092 recrd->fd6_val = 0;
3093 recrd->pnt_val = 0;
3094 recrd->key = key;
3095
3096 return (recrd);
3097 }
3098
initab()3099 static struct dct_entry **initab ()
3100
3101 {
3102 struct dct_entry **head;
3103 long i;
3104
3105 head = (struct dct_entry **)
3106 mbkalloc (sizeof(struct dct_entry *) * FBL_HSZDFN);
3107
3108 for (i=0 ; i<FBL_HSZDFN ; i++)
3109 head[i] = 0;
3110
3111 return (head);
3112 }
3113
addtab(head,key_str,ctx_str,field,valu)3114 static void addtab (head,key_str,ctx_str,field,valu)
3115
3116 struct dct_entry **head;
3117 char *key_str;
3118 char *ctx_str;
3119 long field;
3120 long valu;
3121
3122 {
3123 long found = 0;
3124 long index;
3125 struct dct_entry *entry_pnt;
3126 struct dct_recrd *recrd_pnt;
3127
3128 index = ((unsigned long) key_str) % FBL_HSZDFN;
3129 entry_pnt = head[index];
3130
3131 while (entry_pnt != 0)
3132 {
3133 if (entry_pnt->key == key_str)
3134 {
3135 found = 1;
3136 break;
3137 }
3138 entry_pnt = entry_pnt->next;
3139 }
3140
3141 if (found == 0)
3142 {
3143 head[index] = addent (head[index],key_str);
3144 entry_pnt = head[index];
3145 }
3146
3147 found = 0;
3148 recrd_pnt = entry_pnt->data;
3149 while (recrd_pnt != 0)
3150 {
3151 if (recrd_pnt->key == ctx_str)
3152 {
3153 found = 1;
3154 break;
3155 }
3156 recrd_pnt = recrd_pnt->next;
3157 }
3158
3159 if (found == 0)
3160 {
3161 entry_pnt->data = addrcd (entry_pnt->data,ctx_str);
3162 recrd_pnt = entry_pnt->data ;
3163 }
3164
3165 switch (field)
3166 {
3167 case 0 :
3168 recrd_pnt->fd0_val = valu;
3169 break;
3170 case 1 :
3171 recrd_pnt->fd1_val = valu;
3172 break;
3173 case 2 :
3174 recrd_pnt->fd2_val = valu;
3175 break;
3176 case 3 :
3177 recrd_pnt->fd3_val = valu;
3178 break;
3179 case 4 :
3180 recrd_pnt->fd4_val = valu;
3181 break;
3182 case 5 :
3183 recrd_pnt->fd5_val = valu;
3184 break;
3185 case 6 :
3186 recrd_pnt->fd6_val = valu;
3187 break;
3188 case 7 :
3189 recrd_pnt->pnt_val = valu;
3190 break;
3191 }
3192
3193 }
3194
chktab(head,key_str,ctx_str,field)3195 static long chktab (head,key_str,ctx_str,field)
3196
3197 struct dct_entry **head;
3198 char *key_str;
3199 char *ctx_str;
3200 long field;
3201
3202 {
3203 long found = 0;
3204 long valu = 0;
3205 struct dct_entry *entry_pnt;
3206 struct dct_recrd *recrd_pnt;
3207
3208 entry_pnt = head [((unsigned long)key_str) % FBL_HSZDFN];
3209
3210 while (entry_pnt != 0)
3211 {
3212 if (entry_pnt->key == key_str)
3213 {
3214 found = 1;
3215 break;
3216 }
3217 entry_pnt = entry_pnt->next;
3218 }
3219
3220 if (found == 1)
3221 {
3222 found = 0;
3223 recrd_pnt = entry_pnt->data;
3224 while (recrd_pnt != 0)
3225 {
3226 if (recrd_pnt->key == ctx_str)
3227 {
3228 found = 1;
3229 break;
3230 }
3231 recrd_pnt = recrd_pnt->next;
3232 }
3233 if (found == 1)
3234 {
3235 switch (field)
3236 {
3237 case 0 :
3238 valu = recrd_pnt->fd0_val;
3239 break;
3240 case 1 :
3241 valu = recrd_pnt->fd1_val;
3242 break;
3243 case 2 :
3244 valu = recrd_pnt->fd2_val;
3245 break;
3246 case 3 :
3247 valu = recrd_pnt->fd3_val;
3248 break;
3249 case 4 :
3250 valu = recrd_pnt->fd4_val;
3251 break;
3252 case 5 :
3253 valu = recrd_pnt->fd5_val;
3254 break;
3255 case 6 :
3256 valu = recrd_pnt->fd6_val;
3257 break;
3258 case 7 :
3259 valu = recrd_pnt->pnt_val;
3260 break;
3261 }
3262 }
3263 }
3264
3265 return (valu);
3266 }
3267
fretab(pt_hash)3268 static void fretab (pt_hash)
3269
3270 struct dct_entry **pt_hash;
3271 {
3272 struct dct_entry *pt_entry;
3273 struct dct_entry *pt_nxtentry;
3274 struct dct_recrd *pt_record;
3275 long i;
3276
3277 if (pt_hash != 0)
3278 {
3279 for (i=0 ; i<FBL_HSZDFN ; i++)
3280 {
3281 if ((pt_entry = pt_hash[i]) != 0)
3282 {
3283 while (pt_entry != 0)
3284 {
3285 pt_record = pt_entry->data;
3286
3287 while (pt_record->next != 0)
3288 pt_record = pt_record->next;
3289
3290 pt_record->next = FBL_DCRHED;
3291 FBL_DCRHED = pt_entry->data;
3292
3293 pt_nxtentry = pt_entry->next;
3294 pt_entry->next = FBL_DCEHED;
3295 FBL_DCEHED = pt_entry;
3296 pt_entry = pt_nxtentry;
3297 }
3298 }
3299 }
3300 free (pt_hash);
3301 }
3302 }
3303
fbl_addstr(ptfig,object,mode,prtype,type,flag,name,left,right)3304 void *fbl_addstr (ptfig,object,mode,prtype,type,flag,name,left,right)
3305
3306 struct fbfig *ptfig;
3307 char object;
3308 long mode;
3309 long prtype;
3310 unsigned char type;
3311 char flag;
3312 char *name;
3313 short left;
3314 short right;
3315
3316 {
3317 void *pnt = 0;
3318 char porflg = 0;
3319 char rinflg = 0;
3320 char outflg = 0;
3321 char busflg = 0;
3322 char auxflg = 0;
3323 char buxflg = 0;
3324 char regflg = 0;
3325 char lclmod = 'B';
3326 char lcltyp = type;
3327 char extname[100];
3328 short i;
3329 short inc = 1;
3330
3331 switch (object)
3332 {
3333 case 'P':
3334
3335 /* ###------------------------------------------------------### */
3336 /* if object is a port ... */
3337 /* ###------------------------------------------------------### */
3338
3339 porflg = 1;
3340 switch (mode)
3341 {
3342 case FBL_ICNDFN:
3343 lclmod = 'I'; lcltyp = type ; rinflg = 1; break;
3344 case FBL_OCNDFN:
3345 switch (prtype)
3346 {
3347 case BIT :
3348 lclmod = 'O'; lcltyp = type ; outflg = 1; break;
3349 case MUX_BIT :
3350 lclmod = 'Z'; lcltyp = type; busflg = 1; break;
3351 case WOR_BIT :
3352 lclmod = 'Z'; lcltyp = type; busflg = 1; break;
3353 }
3354 break;
3355 case FBL_BCNDFN:
3356 rinflg = 1;
3357 switch (prtype)
3358 {
3359 case BIT:
3360 lclmod = 'B'; lcltyp = type; outflg = 1; rinflg =1;break;
3361 case MUX_BIT:
3362 lclmod = 'T'; lcltyp = type; busflg = 1;rinflg =1; break;
3363 case WOR_BIT:
3364 lclmod = 'T'; lcltyp = type; busflg = 1; rinflg =1;break;
3365 }
3366 break;
3367 }
3368 break;
3369
3370 case 'S':
3371
3372 /* ###------------------------------------------------------### */
3373 /* if object is a signal ... */
3374 /* ###------------------------------------------------------### */
3375
3376 switch (prtype)
3377 {
3378 case BIT:
3379 lcltyp = type; auxflg = 1; break;
3380 case REG_BIT :
3381 rinflg = 1; regflg = 1; break;
3382 case MUX_BIT :
3383 lcltyp = type; rinflg = 1; buxflg = 1; break;
3384 case WOR_BIT :
3385 lcltyp = type; rinflg = 1; buxflg = 1; break;
3386 default : lcltyp = type ; auxflg =1;break;
3387 }
3388 break;
3389 }
3390
3391 if (flag == 'A' || flag == 'U')
3392 {
3393 /* ###------------------------------------------------------### */
3394 /* if object is an array ... */
3395 /* ###------------------------------------------------------### */
3396
3397 if (left >= right)
3398 inc = -1;
3399
3400 for (i=left ; i!=(right+inc) ; i+=inc)
3401 {
3402 sprintf (extname,"%s %d",name,i);
3403
3404 if (porflg == 1)
3405 {
3406 ptfig->BEPOR = fbh_addfbpor (ptfig->BEPOR,extname,lclmod,lcltyp);
3407 ptfig->BEPOR->LINE_NUM = FBL_LINNUM;
3408 }
3409 if (rinflg == 1)
3410 {
3411 ptfig->BERIN = fbh_addfbrin (ptfig->BERIN,extname);
3412 ptfig->BERIN->LINE_NUM = FBL_LINNUM;
3413 }
3414 if (outflg == 1)
3415 {
3416 ptfig->BEOUT = fbh_addfbout (ptfig->BEOUT,extname,0,0,lcltyp);
3417 ptfig->BEOUT->LINE_NUM = FBL_LINNUM;
3418 }
3419 if (busflg == 1)
3420 {
3421 ptfig->BEBUS = fbh_addfbbus (ptfig->BEBUS,extname,0,0,lcltyp);
3422 ptfig->BEBUS->LINE_NUM = FBL_LINNUM;
3423 }
3424 if (auxflg == 1)
3425 {
3426 ptfig->BEAUX = fbh_addfbaux (ptfig->BEAUX,extname,0,0,lcltyp);
3427 ptfig->BEAUX->LINE_NUM = FBL_LINNUM;
3428 }
3429 if (buxflg == 1)
3430 {
3431 ptfig->BEBUX = fbh_addfbbux (ptfig->BEBUX,extname,0,0,lcltyp);
3432 ptfig->BEBUX->LINE_NUM = FBL_LINNUM;
3433 }
3434 if (regflg == 1)
3435 {
3436 ptfig->BEREG = fbh_addfbreg (ptfig->BEREG,extname,0,0);
3437 ptfig->BEREG->LINE_NUM = FBL_LINNUM;
3438 }
3439 }
3440 }
3441 else
3442 {
3443 /* ###------------------------------------------------------### */
3444 /* if object is a scalar ... */
3445 /* ###------------------------------------------------------### */
3446
3447 if (porflg == 1)
3448 {
3449 ptfig->BEPOR = fbh_addfbpor (ptfig->BEPOR,name,lclmod,lcltyp);
3450 ptfig->BEPOR->LINE_NUM = FBL_LINNUM;
3451 }
3452 if (rinflg == 1)
3453 {
3454 ptfig->BERIN = fbh_addfbrin (ptfig->BERIN,name);
3455 ptfig->BERIN->LINE_NUM = FBL_LINNUM;
3456 }
3457 if (outflg == 1)
3458 {
3459 ptfig->BEOUT = fbh_addfbout (ptfig->BEOUT,name,0,0,lcltyp);
3460 ptfig->BEOUT->LINE_NUM = FBL_LINNUM;
3461 }
3462 if (busflg == 1)
3463 {
3464 ptfig->BEBUS = fbh_addfbbus (ptfig->BEBUS,name,0,0,lcltyp);
3465 ptfig->BEBUS->LINE_NUM = FBL_LINNUM;
3466 }
3467 if (auxflg == 1)
3468 {
3469 ptfig->BEAUX = fbh_addfbaux (ptfig->BEAUX,name,0,0,lcltyp);
3470 ptfig->BEAUX->LINE_NUM = FBL_LINNUM;
3471 }
3472 if (buxflg == 1)
3473 {
3474 ptfig->BEBUX = fbh_addfbbux (ptfig->BEBUX,name,0,0,lcltyp);
3475 ptfig->BEBUX->LINE_NUM = FBL_LINNUM;
3476 }
3477 if (regflg == 1)
3478 {
3479 ptfig->BEREG = fbh_addfbreg (ptfig->BEREG,name,0,0);
3480 ptfig->BEREG->LINE_NUM = FBL_LINNUM;
3481 }
3482
3483 }
3484
3485 if (outflg == 1)
3486 {
3487 pnt = (void *) ptfig->BEOUT;
3488 }
3489 if (busflg == 1)
3490 {
3491 pnt = (void *) ptfig->BEBUS;
3492 }
3493 if (auxflg == 1)
3494 {
3495 pnt = (void *) ptfig->BEAUX;
3496 }
3497 if (buxflg == 1)
3498 {
3499 pnt = (void *) ptfig->BEBUX;
3500 }
3501 if (regflg == 1)
3502 {
3503 pnt = (void *) ptfig->BEREG;
3504 }
3505
3506 return (pnt);
3507 }
3508
fbl_chkdcl(object,mode,type,flag,kind,constraint,conf)3509 long fbl_chkdcl (object,mode,type,flag,kind,constraint,conf)
3510
3511 char object;
3512 long mode;
3513 long type;
3514 char flag;
3515 long kind;
3516 char constraint;
3517 long *conf;
3518
3519 {
3520 long errflg = 0;
3521 long lclcnf = 0;
3522
3523 if (flag != constraint && constraint !='U' && flag !='U')
3524 {
3525 errflg = 1;
3526 {
3527 fbl_error (33,0);
3528 }
3529 }
3530 else
3531 {
3532 switch (object)
3533 {
3534 case 'P':
3535 /* ###------------------------------------------------------### */
3536 /* If object is a port : */
3537 /* - if type is bit, no guard indication can be used */
3538 /* - if type is wor_bit or mux_bit, bus kind must be used */
3539 /* - other types are illegal */
3540 /* ###------------------------------------------------------### */
3541
3542 switch (type)
3543 {
3544 case BIT :
3545
3546 lclcnf += FBL_BITDFN + FBL_NORDFN;
3547 switch (mode)
3548 {
3549 case _IN :
3550 lclcnf += FBL_ICNDFN; break;
3551 case _OUT:
3552 lclcnf += FBL_OCNDFN; break;
3553 case _INOUT :
3554 lclcnf += FBL_BCNDFN; break;
3555 case _LINKAGE :
3556 case 0 :
3557 errflg = 1; break;
3558 }
3559 if (kind != 0)
3560 errflg = 1;
3561 break;
3562
3563 case MUX_BIT :
3564
3565 lclcnf += FBL_MUXDFN + FBL_BUSDFN;
3566 switch (mode)
3567 {
3568 case _OUT :
3569 lclcnf += FBL_OCNDFN; break;
3570 case _INOUT :
3571 lclcnf += FBL_BCNDFN; break;
3572 case _IN :
3573 case _LINKAGE :
3574 case 0 :
3575 errflg = 1; break;
3576 }
3577 if (kind != BUS)
3578 errflg = 1;
3579 break;
3580
3581 case WOR_BIT :
3582
3583 lclcnf += FBL_WORDFN + FBL_BUSDFN;
3584 switch (mode)
3585 {
3586 case _OUT :
3587 lclcnf += FBL_OCNDFN; break;
3588 case _INOUT :
3589 lclcnf += FBL_BCNDFN; break;
3590 case _IN :
3591 case _LINKAGE :
3592 case 0 :
3593 errflg = 1; break;
3594 }
3595 if (kind != BUS)
3596 errflg = 1;
3597 break;
3598
3599 case REG_BIT :
3600 case NATURAL:
3601
3602 errflg = 1;
3603 break;
3604 }
3605 if (errflg == 1)
3606 {
3607 fbl_error (5,0);
3608 }
3609 break;
3610
3611 case 'G':
3612 /* ###------------------------------------------------------### */
3613 /* If object is a generic : */
3614 /* - only natural type is allowed */
3615 /* ###------------------------------------------------------### */
3616
3617 if ((type != NATURAL) || (mode != 0) || (kind != 0))
3618 {
3619 errflg = 1;
3620 {
3621 fbl_error (77,0);
3622 }
3623 }
3624 break;
3625
3626 case 'S':
3627 /* ###------------------------------------------------------### */
3628 /* If object is a signal : */
3629 /* - no mode can be specified */
3630 /* - if type is bit no guard indication can be used */
3631 /* - if type is wor_bit or mux_bit, bus kind must be used */
3632 /* - if type is reg_bit, register kind must be used */
3633 /* - other types are illegal */
3634 /* ###------------------------------------------------------### */
3635
3636 switch (type)
3637 {
3638 case BIT:
3639 lclcnf += FBL_BITDFN + FBL_NORDFN;
3640 if ((mode != 0) || (kind != 0))
3641 errflg = 1;
3642 break;
3643 case MUX_BIT:
3644 lclcnf += FBL_MUXDFN + FBL_BUSDFN;
3645 if ((mode != 0) || (kind != BUS))
3646 errflg = 1;
3647 break;
3648 case WOR_BIT:
3649 lclcnf += FBL_WORDFN + FBL_BUSDFN;
3650 if ((mode != 0) || (kind != BUS))
3651 errflg = 1;
3652 break;
3653 case REG_BIT:
3654 lclcnf += FBL_RBIDFN + FBL_REGDFN;
3655 if ((mode != 0) || (kind != REGISTER))
3656 errflg = 1;
3657 break;
3658 case NATURAL:
3659 errflg = 1; break;
3660 }
3661
3662 if (mode != 0)
3663 errflg = 1;
3664
3665 if (errflg == 1)
3666 {
3667 fbl_error (11,NULL);
3668 }
3669 break;
3670
3671 case 'C':
3672 /* ###------------------------------------------------------### */
3673 /* If object is a constant : */
3674 /* - only bit type without any other indication is legal */
3675 /* ###------------------------------------------------------### */
3676
3677 lclcnf += FBL_CSTDFN;
3678 if ((type != BIT) || (mode != 0) || (kind != 0))
3679 {
3680 errflg = 1;
3681 {
3682 fbl_error (78,NULL);
3683 }
3684 }
3685 break;
3686 }
3687 }
3688
3689 *conf = lclcnf;
3690 return (errflg);
3691 }
3692
val_type(name)3693 long val_type(name)
3694 char *name;
3695 {
3696 if(!name)
3697 return(-1);
3698 if (!strcmp(name,"severity_level"))
3699 return(SEVERITY_LEVEL);
3700 if (!strcmp(name,"boolean"))
3701 return(BOOLEAN);
3702 if (!strcmp(name,"bit"))
3703 return(BIT);
3704 if (!strcmp(name,"mux_bit"))
3705 return(MUX_BIT);
3706 if (!strcmp(name,"wor_bit"))
3707 return(WOR_BIT);
3708 if (!strcmp(name,"reg_bit"))
3709 return(REG_BIT);
3710 if (!strcmp(name,"bit_vector"))
3711 return(BIT);
3712 if (!strcmp(name,"mux_vector"))
3713 return(MUX_BIT);
3714 if (!strcmp(name,"wor_vector"))
3715 return(WOR_BIT);
3716 if (!strcmp(name,"reg_vector"))
3717 return(REG_BIT);
3718 if (!strcmp(name,"integer"))
3719 return(INTEGER);
3720 if (!strcmp(name,"natural"))
3721 return(NATURAL);
3722 if (!strcmp(name,"std_logic"))
3723 return(BIT);
3724 if (!strcmp(name,"std_ulogic"))
3725 return(BIT);
3726 if (!strcmp(name,"std_logic_vector"))
3727 return(BIT);
3728 if (!strcmp(name,"std_ulogic_vector"))
3729 return(BIT);
3730 return( -1 );
3731 }
reversetype(pnt)3732 struct ptype *reversetype(pnt)
3733 struct ptype *pnt;
3734 {
3735 struct ptype* revtype;
3736 struct ptype* aux2;
3737 struct ptype* aux1;
3738
3739 if(pnt == 0 || pnt->NEXT == 0)
3740 return(pnt);
3741 revtype = pnt;
3742 aux1 = pnt->NEXT;
3743 revtype->NEXT = 0;
3744 while(aux1)
3745 {
3746 aux2 = revtype;
3747 revtype = aux1;
3748 aux1 = aux1->NEXT;
3749 revtype->NEXT = aux2;
3750 }
3751 return(revtype);
3752 }
3753
addchoice(lastpnt,type,val,size)3754 struct choice_chain *addchoice(lastpnt,type,val,size)
3755 struct choice_chain *lastpnt;
3756 struct ptype *type;
3757 char *val;
3758 unsigned long size;
3759 {
3760 struct choice_chain *pnt;
3761
3762 pnt = (struct choice_chain*)mbkalloc(sizeof(struct choice_chain));
3763 pnt->VALUE = val;
3764 pnt->SIZE = size;
3765 pnt->INSTRUCTION = type;
3766 pnt->NEXT = lastpnt;
3767 return(pnt);
3768 }
3769
order_choice(pnt,type,val,size)3770 struct choice_chain *order_choice(pnt,type,val,size)
3771 struct choice_chain *pnt;
3772 struct ptype *type;
3773 char *val;
3774 unsigned long size;
3775 {
3776 struct choice_chain *aux1;
3777 struct choice_chain *aux2;
3778
3779 if(!pnt)
3780 {
3781 aux1 = addchoice (pnt,type,val,size);
3782 return(aux1);
3783 }
3784
3785 if(strcmp(pnt->VALUE,val)>0)
3786 {
3787 aux1 =addchoice(pnt,type,val,size);
3788 return(aux1);
3789 }
3790
3791 aux1 =pnt;
3792 aux2 =pnt->NEXT;
3793 while(aux2)
3794 {
3795 if(strcmp(aux2->VALUE, val)>0)
3796 {
3797 aux2 = addchoice (aux2,type,val,size);
3798 aux1->NEXT = aux2;
3799 return(pnt);
3800 }
3801 aux1 = aux2;
3802 aux2 = aux2->NEXT;
3803 }
3804 aux2 = addchoice (aux2,type,val,size);
3805 aux1->NEXT = aux2;
3806 return(pnt);
3807 }
3808
3809