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