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 /* file : vbl_bcomp.yac */
29 /* date : April 29 1993 */
30 /* version : v1.0 */
31 /* content : yacc rules for behavioural VHDL for Petri Net */
32 /* ###--------------------------------------------------------------### */
33 %{
34 #include <stdio.h>
35 #include <stdlib.h>
36 #include <string.h>
37 #include "mut.h"
38 #include "aut.h"
39 #include "vex.h"
40 #include "vbh.h"
41
42 #include "vbl_utype.h"
43 #include "vbl_bedef.h"
44 #include "vbl_bspec.h"
45 #include "vbl_byacc.h"
46
47 extern int yywrap ( );
48 extern int yylex ( );
49 extern void yyerror ( );
50
51 #if 1
52 # define my_fprintf fprintf( stdout, "%s %d : ", basename(__FILE__), __LINE__ ); fprintf
53 # define my_vbl_error(N,V) \
54 do { fprintf( stderr, "%s %d : ", basename(__FILE__), __LINE__); vbl_error( (long)N, (char *)V); } while(0)
55 # define my_vbl_warning(N,V) \
56 do { fprintf( stderr, "%s %d : ", basename(__FILE__), __LINE__); vbl_warning((long)N, (char *)V); } while(0)
57 #else
58 # define my_fprintf fprintf
59 # define my_vbl_error vbl_error
60 # define my_vbl_warning vbl_warning
61 #endif
62
63 #ifdef VBL_DEBUG
64 #define YYDEBUG 1
65 #endif
66
67 %}
68
69 %union {
70 long valu;
71 char *text;
72 chain_list *pcha;
73 vbl_name name;
74 vbl_vexstr list;
75 struct vbtyp type;
76 };
77
78 %token <valu> tok_AND
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> _IFT
94 %token <valu> _NXOR
95 %token <valu> _NESym
96 %token <valu> _NEXT
97 %token <valu> _NOR
98 %token <valu> _NOT
99 %token <valu> tok_NULL
100 %token <valu> _OR
101 %token <valu> _OUT
102 %token <valu> _XOR
103 %token <valu> ABS
104 %token <valu> ACCESS
105 %token <valu> AFTER
106 %token <valu> ALIAS
107 %token <valu> ALL
108 %token <valu> ARCHITECTURE
109 %token <valu> ARRAY
110 %token <valu> ASSERT
111 %token <valu> ATTRIBUTE
112 %token <text> AbstractLit
113 %token <valu> Ampersand
114 %token <valu> Apostrophe
115 %token <valu> Arrow
116 %token <valu> BLOCK
117 %token <valu> BODY
118 %token <valu> BUS
119 %token <valu> _BUFFER
120 %token <valu> Bar
121 %token <valu> BasedInt
122 %token <valu> BasedReal
123 %token <text> BitStringLit
124 %token <text> _TRUE
125 %token <text> _FALSE
126 %token <valu> Box
127 %token <valu> CASE
128 %token <valu> COMPONENT
129 %token <valu> CONFIGURATION
130 %token <valu> CONSTANT
131 %token <text> CharacterLit
132 %token <valu> Colon
133 %token <valu> Comma
134 %token <valu> DISCONNECT
135 %token <valu> DOWNTO
136 %token <valu> DecimalInt
137 %token <valu> DecimalReal
138 %token <valu> Dot
139 %token <valu> DoubleStar
140 %token <valu> ELSE
141 %token <valu> ELSIF
142 %token <valu> _ENTITY
143 %token <valu> ERROR
144 %token <valu> _EVENT
145 %token <valu> _LEFT
146 %token <valu> _LENGTH
147 %token <valu> _RIGHT
148 %token <valu> _HIGH
149 %token <valu> _LOW
150 %token <valu> FOR
151 %token <valu> FUNCTION
152 %token <valu> GENERATE
153 %token <valu> GENERIC
154 %token <valu> GUARDED
155 %token <valu> IF
156 %token <valu> IS
157 %token <valu> _NS
158 %token <valu> _PS
159 %token <valu> _FS
160 %token <valu> _MS
161 %token <text> Identifier
162 %token <valu> _LIBRARY
163 %token <valu> LOOP
164 %token <valu> LeftParen
165 %token <valu> MAP
166 %token <valu> MOD
167 %token <valu> Minus
168 %token <valu> NEW
169 %token <valu> OF
170 %token <valu> ON
171 %token <valu> OPEN
172 %token <valu> OTHERS
173 %token <valu> _PACKAGE
174 %token <valu> PORT
175 %token <valu> PROCEDURE
176 %token <valu> PROCESS
177 %token <valu> Plus
178 %token <valu> _RANGE
179 %token <valu> _REV_RANGE
180 %token <valu> RECORD
181 %token <valu> REGISTER
182 %token <valu> REM
183 %token <valu> REPORT
184 %token <valu> _RETURN
185 %token <valu> RightParen
186 %token <valu> SELECT
187 %token <valu> SEVERITY
188 %token <valu> SIGNAL
189 %token <valu> _STABLE
190 %token <valu> SUBTYPE
191 %token <valu> Semicolon
192 %token <valu> Slash
193 %token <valu> Star
194 %token <text> StringLit
195 %token <valu> THEN
196 %token <valu> TO
197 %token <valu> TRANSPORT
198 %token <valu> _TYPE
199 %token <valu> UNITS
200 %token <valu> UNTIL
201 %token <valu> USE
202 %token <valu> _VARIABLE
203 %token <valu> VarAsgn
204 %token <valu> WAIT
205 %token <valu> WARNING
206 %token <valu> WHEN
207 %token <valu> WHILE
208 %token <valu> WITH
209
210 %left tok_AND _OR _NAND _NOR _XOR
211 %left _EQSym _NESym _LTSym _LESym _GTSym _GESym
212 %left Plus Minus Ampersand
213 %left Star Slash MOD REM
214 %left DoubleStar
215 %right ABS _NOT
216
217 %type <valu> .SEVERITY__expression.
218 %type <valu> severity__message
219 %type <text> .REPORT__expression.
220 %type <text> report__message
221
222 %type <list> .WHEN__condition.
223 %type <valu> .GUARDED.
224
225 %type <list> .VarAsgn__expression.
226 %type <list> waveform
227 %type <list> waveform_element
228 %type <list> condition
229 %type <list> expression
230 %type <list> .expression.
231 %type <list> guard_expression
232 %type <list> .guard_expression.
233 %type <list> relation..AND__relation..
234 %type <list> relation..OR__relation..
235 %type <list> relation.NAND_NOR_NXOR_relation.
236 %type <list> relation..XOR__relation..
237 %type <list> relation
238 %type <list> simple_expression
239 %type <list> .sign.term..add_op__term..
240 %type <list> term
241 %type <list> factor
242 %type <list> primary
243 %type <valu> relational_operator
244 %type <valu> sign
245 %type <valu> adding_operator
246 %type <valu> multiplying_operator
247 %type <text> literal
248 %type <name> choice
249 %type <pcha> aggregate
250 %type <pcha> element_association
251 %type <pcha> ...element_association..
252
253 %type <list> .condition_clause.
254 %type <list> condition_clause
255 %type <list> .iteration_scheme.
256 %type <list> iteration_scheme
257 %type <list> loop_parameter_specification
258
259 %type <type> type_definition
260 %type <type> scalar_type_definition
261 %type <type> composite_type_definition
262 %type <type> enumeration_type_definition
263 %type <type> subtype_indication
264 %type <type> unconstrained_array_definition
265 %type <type> constrained_array_definition
266 %type <type> array_type_definition
267
268 %type <text> library_clause
269 %type <text> use_clause
270 %type <text> selected_name
271 %type <text> ...selected_name..
272
273 %type <name> index_subtype_definition
274 %type <name> index_constraint
275 %type <name> discrete_range
276 %type <name> qualified_expression
277
278 %type <text> .label.
279 %type <text> label
280 %type <valu> time_label
281 %type <text> a_label
282 %type <name> target
283 %type <text> simple_name
284 %type <text> prefix
285 %type <text> suffix
286 %type <text> type_or_function_name
287 %type <name> name
288 %type <name> attribute_name
289 %type <name> indexed_name
290 %type <name> slice_name
291 %type <text> .simple_name.
292 %type <name> .constraint.
293 %type <name> constraint
294 %type <name> .timeout_clause.
295 %type <name> timeout_clause
296 %type <name> range
297 %type <name> range_constraint
298 %type <valu> direction
299 %type <valu> .mode.
300 %type <valu> .local_port_mode.
301 %type <valu> .procedure_parameter_mode.
302 %type <valu> .procedure_parameter_object_class.
303 %type <valu> .function_parameter_mode.
304 %type <valu> .function_parameter_object_class.
305 %type <name> type_mark
306 %type <valu> .signal_kind.
307 %type <valu> attribute_designator
308 %type <text> designator
309
310 %type <list> generation_scheme
311 %type <list> generate_parameter_specification
312
313 %type <valu> entity_class
314
315 %type <list> constant_VarAsgn__expression
316
317 %start design_file
318
319 %%
320
321 design_file
322 : {
323 /* ###----------------------------------------------### */
324 /* Initializations */
325 /* ###----------------------------------------------### */
326
327 VBL_NM1LST = NULL;
328 VBL_NM2LST = NULL;
329 VBL_LOOPLBLLST = NULL;
330 VBL_LOOPLBL = NULL;
331 VBL_INSLST = NULL;
332 VBL_GRDLST = NULL;
333 VBL_CNDLST = NULL;
334 VBL_LINLST = NULL;
335 VBL_VALLST = NULL;
336 VBL_ENUMVAL = createauthtable( 100 );
337 hshtab = initab ();
338
339 VBL_ERRFLG = 0;
340 VBL_LINNUM = 1;
341 VBL_NUMPTP = 0;
342 VBL_NUMCHOICE = 0;
343
344 VBL_MODNAM = namealloc( "undefined" );
345 VBL_PROCNAM = (char *)0;
346 VBL_PROCNUM = 0;
347 VBL_LOOPNUM = 0;
348 VBL_GNRNAM = (char *)0;
349 VBL_FUNCNAM = (char *)0;
350 VBL_COMPNAM = (char *)0;
351 VBL_BEFUN = (vbfun_list *)0;
352
353 VBL_HEADFIG = vbh_addvbfig( VBL_HEADFIG, 0);
354 VBL_BEFPNT = VBL_HEADFIG;
355
356 VBL_BEPCS = (vbpcs_list *)0;
357 VBL_BEINS = (vbins_list *)0;
358 VBL_BEGNR = (vbgnr_list *)0;
359 VBL_BEMAP = (vbmap_list *)0;
360
361 VBL_GNR_BEPCS = (chain_list *)0;
362 VBL_GNR_BEINS = (chain_list *)0;
363 VBL_GNR_BEGNR = (chain_list *)0;
364 }
365 design_unit
366 ..design_unit..
367 {
368 VBL_BEFPNT->BEPCS = VBL_BEPCS;
369 VBL_BEFPNT->BEINS = VBL_BEINS;
370 VBL_BEFPNT->BEGNR = VBL_BEGNR;
371
372 fretab( hshtab );
373 destroyauthtable( VBL_ENUMVAL );
374 }
375 ;
376
377 ..design_unit..
378 : /*empty*/
379 | design_unit
380 ..design_unit..
381 ;
382
383 design_unit
384 : context_clause
385 library_unit
386 {}
387 ;
388
389 library_unit
390 : primary_unit
391 {}
392 | secondary_unit
393 {}
394 | error
395 {}
396 ;
397
398 primary_unit
399 : entity_declaration
400 {}
401 | configuration_declaration
402 {}
403 | package_declaration
404 {}
405 ;
406
407 secondary_unit
408 : architecture_body
409 {}
410 | package_body
411 {}
412 ;
413
414 library_clause
415 : _LIBRARY
416 logical_name_list
417 Semicolon_ERR
418 { }
419 ;
420
421 logical_name_list
422 : Identifier
423 ...logical_name..
424 { }
425 ;
426
427 ...logical_name..
428 : /*empty*/
429 | ...logical_name..
430 Comma
431 Identifier
432 { }
433 ;
434
435 /* 11.3 */
436 context_clause
437 : ..context_item..
438 { }
439 ;
440
441 ..context_item..
442 : /*empty*/
443 | ..context_item..
444 context_item
445 { }
446 ;
447
448 context_item
449 : library_clause
450 { }
451 | use_clause
452 { }
453 ;
454
455 use_clause
456 : USE
457 selected_name /* package simple name */
458 ...selected_name..
459 Semicolon_ERR
460 {
461 }
462 ;
463
464 /* 1.3 */
465 configuration_declaration
466 : CONFIGURATION
467 Identifier
468 OF
469 Identifier
470 IS
471 block_configuration
472 END_ERR
473 .simple_name.
474 Semicolon_ERR
475 {}
476 | CONFIGURATION error
477 {}
478 ;
479
480 /* block configuration */
481 block_configuration
482 : FOR
483 label
484 END_ERR
485 FOR
486 Semicolon_ERR
487 {}
488 ;
489
490
491 /* Packages */
492
493 /* 2.5 */
494 package_declaration
495 : _PACKAGE
496 Identifier
497 IS
498 {
499 vbfig_list *ScanPkgFig;
500 chain_list *ScanChain;
501 char *Name;
502 char **FuncArray;
503 long Index;
504 long Left = 0;
505 long Right = 0;
506 long AttrLeft = 0;
507 long AttrRight = 0;
508 long Dir;
509 long Signed = 0;
510 vbcst_list *VbhCst;
511 vbaux_list *VbhAux;
512 vbmod_list *VbhMod;
513 vbpor_list *VbhPor;
514 vbgen_list *VbhGen;
515 vbtyp_list *VbhType;
516 vbpcs_list *VbhPcs;
517 vexexpr *VexAtom;
518 long Dynamic;
519 long Oper;
520 chain_list *PackList;
521
522 extern char *vbl_func_std_logic_1164[];
523 extern char *vbl_func_std_logic_arith[];
524 extern char *vbl_func_std_numeric_std[];
525
526 long size=0;
527 struct vbtyp *vbtyp_pnt;
528 VBL_BEFPNT->NAME = $2;
529 VBL_BEFPNT->IS_PACKAGE = 1;
530 VBL_MODNAM = $2;
531
532 vbtyp_pnt = VBL_BEFPNT->BETYP;
533 while(vbtyp_pnt)
534 {
535 size++;
536 vbtyp_pnt = vbtyp_pnt->NEXT;
537 }
538
539 vbtyp_pnt = VBL_BEFPNT->BETYP;
540 VBL_NUMTYP = 0;
541 while(vbtyp_pnt)
542 {
543 addtab(hshtab,vbtyp_pnt->NAME,VBL_MODNAM,VBL_SYMDFN,VBL_TPEDFN);
544 addtab(hshtab,vbtyp_pnt->NAME,VBL_MODNAM,VBL_LBLDFN,vbtyp_pnt->CLASS);
545 addtab(hshtab,vbtyp_pnt->NAME,VBL_MODNAM,VBL_TYPDFN,vbtyp_pnt->INDEX);
546 addtab(hshtab,vbtyp_pnt->NAME,VBL_MODNAM,VBL_WMNDFN,vbtyp_pnt->LEFT);
547 addtab(hshtab,vbtyp_pnt->NAME,VBL_MODNAM,VBL_WMXDFN,vbtyp_pnt->RIGHT);
548 addtab(hshtab,vbtyp_pnt->NAME,VBL_MODNAM,VBL_PNTDFN,(long)vbtyp_pnt);
549 vbtyp_pnt = vbtyp_pnt->NEXT;
550 VBL_NUMTYP++;
551 }
552
553 for ( ScanChain = VBL_NM2LST;
554 ScanChain != (chain_list *)0;
555 ScanChain = ScanChain->NEXT )
556 {
557 FuncArray = (char **)0;
558
559 if ( ! strcmp( ScanChain->DATA, "ieee.std_logic_1164.all" ) )
560 {
561 FuncArray = vbl_func_std_logic_1164;
562 }
563 else
564 if ( ( ! strcmp( ScanChain->DATA, "ieee.std_logic_arith.all" ) ) ||
565 ( ! strcmp( ScanChain->DATA, "ieee.std_logic_signed.all" ) ) ||
566 ( ! strcmp( ScanChain->DATA, "ieee.std_logic_unsigned.all" ) ) )
567 {
568 FuncArray = vbl_func_std_logic_arith;
569 }
570 else
571 if ( ( ! strcmp( ScanChain->DATA, "ieee.numeric_std.all" ) ) ||
572 ( ! strcmp( ScanChain->DATA, "ieee.numeric_bit.all" ) ) )
573 {
574 FuncArray = vbl_func_std_numeric_std;
575 }
576 else
577 {
578 for ( ScanPkgFig = VBL_HEADFIG;
579 ScanPkgFig != (vbfig_list *)0;
580 ScanPkgFig = ScanPkgFig->NEXT )
581 {
582 if ( ( ScanPkgFig->IS_PACKAGE ) &&
583 ( ScanPkgFig->NAME == (char *)ScanChain->DATA ) )
584 {
585 for ( PackList = VBL_BEFPNT->PACK_LIST;
586 PackList != (chain_list *)0;
587 PackList = PackList->NEXT )
588 {
589 if ( PackList->DATA == ScanChain->DATA ) break; /* already included */
590 }
591
592 if ( PackList == (chain_list *)0 )
593 {
594 vbh_dupvbfig( VBL_BEFPNT, ScanPkgFig );
595 }
596
597 /* BECST */
598
599 for ( VbhCst = ScanPkgFig->BECST;
600 VbhCst != (vbcst_list *)0;
601 VbhCst = VbhCst->NEXT )
602 {
603 VbhType = vbh_getvbtyp( VBL_BEFPNT, VbhCst->TYPE->NAME );
604 VexAtom = VbhCst->TARGET;
605
606 if ( ! IsVexNodeAtom( VexAtom ) )
607 {
608 my_fprintf( stdout, "dynamic declaration not supported !\n" );
609 autexit( 1 );
610 }
611
612 Name = GetVexAtomValue( VexAtom );
613
614 /*
615 if ( chktab( hshtab, Name, VBL_MODNAM, VBL_SYMDFN ) )
616 {
617 my_vbl_error( 10, Name );
618 }
619 */
620
621 if ( IsVexAtomBit( VexAtom ) )
622 {
623 Left = -1;
624 Right = -1;
625 }
626 else
627 {
628 Left = VexAtom->LEFT;
629 Right = VexAtom->RIGHT;
630 }
631
632 Signed = ( IsVexNodeSigned( VexAtom ) != 0 );
633 AttrLeft = Left;
634 AttrRight = Right;
635
636 addtab( hshtab, Name, VBL_MODNAM, VBL_SYMDFN, VBL_CSTDFN );
637 addtab( hshtab, Name, VBL_MODNAM, VBL_TYPDFN, VbhType->INDEX );
638 addtab( hshtab, Name, VBL_MODNAM, VBL_WMNDFN, Left );
639 addtab( hshtab, Name, VBL_MODNAM, VBL_WMXDFN, Right );
640 addtab( hshtab, Name, VBL_MODNAM, VBL_ATLDFN, AttrLeft );
641 addtab( hshtab, Name, VBL_MODNAM, VBL_ATRDFN, AttrRight );
642 addtab( hshtab, Name, VBL_MODNAM, VBL_LBLDFN, 0 );
643 addtab( hshtab, Name, VBL_MODNAM, VBL_PNTDFN, (long)VbhCst->VEX );
644 addtab( hshtab, Name, VBL_MODNAM, VBL_SUNDFN, Signed );
645 addtab( hshtab, Name, VBL_MODNAM, VBL_DYNDFN, 0 );
646 }
647
648 /* BEAUX */
649
650 for ( VbhAux = ScanPkgFig->BEAUX;
651 VbhAux != (vbaux_list *)0;
652 VbhAux = VbhAux->NEXT )
653 {
654 VbhType = vbh_getvbtyp( VBL_BEFPNT, VbhAux->TYPE->NAME );
655 VexAtom = VbhAux->TARGET;
656
657 if ( ! IsVexNodeAtom( VexAtom ) )
658 {
659 my_fprintf( stdout, "dynamic declaration not supported !\n" );
660 autexit( 1 );
661 }
662
663 Name = GetVexAtomValue( VexAtom );
664
665 /*
666 if ( chktab( hshtab, Name, VBL_MODNAM, VBL_SYMDFN ) )
667 {
668 my_vbl_error( 10, Name );
669 }
670 */
671
672 Signed = (IsVexNodeSigned( VexAtom ) != 0);
673 Left = VexAtom->LEFT;
674 Right = VexAtom->RIGHT;
675 AttrLeft = Left;
676 AttrRight = Right;
677
678 addtab( hshtab, Name, VBL_MODNAM, VBL_SYMDFN, VBL_SGNDFN );
679 addtab( hshtab, Name, VBL_MODNAM, VBL_TYPDFN, VbhType->INDEX );
680 addtab( hshtab, Name, VBL_MODNAM, VBL_WMNDFN, Left );
681 addtab( hshtab, Name, VBL_MODNAM, VBL_WMXDFN, Right );
682 addtab( hshtab, Name, VBL_MODNAM, VBL_ATLDFN, AttrLeft );
683 addtab( hshtab, Name, VBL_MODNAM, VBL_ATRDFN, AttrRight );
684 addtab( hshtab, Name, VBL_MODNAM, VBL_LBLDFN, VbhAux->KIND );
685 addtab( hshtab, Name, VBL_MODNAM, VBL_PNTDFN, (long)VexAtom );
686 addtab( hshtab, Name, VBL_MODNAM, VBL_SUNDFN, Signed );
687 addtab( hshtab, Name, VBL_MODNAM, VBL_DYNDFN, 0 );
688 }
689
690 /* BEPCS */
691
692 for ( VbhPcs = ScanPkgFig->BEPCS;
693 VbhPcs != (vbpcs_list *)0;
694 VbhPcs = VbhPcs->NEXT )
695 {
696 addtab( hshtab, VbhPcs->LABEL, VBL_MODNAM, VBL_SYMDFN, VBL_LBLDFN );
697 }
698
699 /* BEFUN TO BE DONE */
700
701 if ( ScanPkgFig->BEFUN != (vbfun_list *)0 )
702 {
703 my_fprintf( stdout, "function in package not supported !\n" );
704 autexit( 1 );
705 }
706
707 /* BEATR TO BE DONE */
708
709 if ( ScanPkgFig->BEATR != (vbatr_list *)0 )
710 {
711 my_fprintf( stdout, "attribute in package not supported !\n" );
712 autexit( 1 );
713 }
714
715 /* BEGNR TO BE DONE ??? */
716
717 if ( ScanPkgFig->BEGNR != (vbgnr_list *)0 )
718 {
719 my_fprintf( stdout, "generate in package not supported !\n" );
720 autexit( 1 );
721 }
722
723 /* BEMOD */
724
725 for ( VbhMod = ScanPkgFig->BEMOD;
726 VbhMod != (vbmod_list *)0;
727 VbhMod = VbhMod->NEXT )
728 {
729 addtab(hshtab,VbhMod->NAME,VBL_MODNAM,VBL_SYMDFN,VBL_COMDFN);
730 addtab(hshtab,VbhMod->NAME,VBL_MODNAM,VBL_PNTDFN,(long)VbhMod);
731
732 for ( VbhGen = VbhMod->BEGEN;
733 VbhGen != (vbgen_list *)0;
734 VbhGen = VbhGen->NEXT )
735 {
736 VbhType = vbh_getvbtyp( VBL_BEFPNT, VbhGen->TYPE->NAME );
737 VexAtom = VbhGen->TARGET;
738
739 if ( ! IsVexNodeAtom( VexAtom ) )
740 {
741 my_fprintf( stdout, "dynamic declaration not supported !\n" );
742 autexit( 1 );
743 }
744
745 Name = GetVexAtomValue( VexAtom );
746
747 /*
748 if ( chktab( hshtab, Name, VBL_MODNAM, VBL_SYMDFN ) )
749 {
750 my_vbl_error( 10, Name );
751 }
752 */
753
754 Signed = (IsVexNodeSigned( VexAtom ) != 0);
755 Left = VexAtom->LEFT;
756 Right = VexAtom->RIGHT;
757 AttrLeft = Left;
758 AttrRight = Right;
759
760 addtab( hshtab, Name, VbhMod->NAME, VBL_SYMDFN, VBL_GENDFN );
761 addtab( hshtab, Name, VbhMod->NAME, VBL_TYPDFN, VbhType->INDEX );
762 addtab( hshtab, Name, VbhMod->NAME, VBL_WMNDFN, Left );
763 addtab( hshtab, Name, VbhMod->NAME, VBL_WMXDFN, Right );
764 addtab( hshtab, Name, VbhMod->NAME, VBL_ATLDFN, AttrLeft );
765 addtab( hshtab, Name, VbhMod->NAME, VBL_ATRDFN, AttrRight );
766 addtab( hshtab, Name, VbhMod->NAME, VBL_LBLDFN, VBH_KIND_NONE );
767 addtab( hshtab, Name, VbhMod->NAME, VBL_PNTDFN, (long)VexAtom );
768 addtab( hshtab, Name, VbhMod->NAME, VBL_SUNDFN, Signed );
769 addtab( hshtab, Name, VbhMod->NAME, VBL_DYNDFN, 0 );
770 }
771
772 for ( VbhPor = VbhMod->BEPOR;
773 VbhPor != (vbpor_list *)0;
774 VbhPor = VbhPor->NEXT )
775 {
776 VbhType = vbh_getvbtyp( VBL_BEFPNT, VbhPor->TYPE->NAME );
777 VexAtom = VbhPor->TARGET;
778
779 if ( ! IsVexNodeAtom( VexAtom ) )
780 {
781 Name = getvexatomname( VexAtom );
782 Dynamic = 0;
783
784 if ( IsVexNodeOper( VexAtom ) )
785 {
786 Oper = GetVexOperValue( VexAtom );
787
788 if ( Oper == VEX_DOWNTO ) Dynamic = VBL_DWTDFN;
789 else
790 if ( Oper == VEX_TO ) Dynamic = VBL_UPTDFN;
791
792 Signed = (IsVexNodeSigned( VexAtom ) != 0);
793 Left = (long)GetVexOperand( VexAtom->OPERAND );
794 Right = (long)GetVexOperand( VexAtom->OPERAND->NEXT );
795 AttrLeft = Left;
796 AttrRight = Right;
797 }
798
799 if ( ! Dynamic )
800 {
801 my_fprintf( stdout, "such dynamic declaration not supported !\n" );
802 autexit( 1 );
803 }
804 }
805 else
806 {
807 Name = GetVexAtomValue( VexAtom );
808
809 Signed = (IsVexNodeSigned( VexAtom ) != 0);
810 Left = VexAtom->LEFT;
811 Right = VexAtom->RIGHT;
812 AttrLeft = Left;
813 AttrRight = Right;
814 Dynamic = 0;
815 }
816
817 /*
818 if ( chktab( hshtab, Name, VBL_MODNAM, VBL_SYMDFN ) )
819 {
820 my_vbl_error( 10, Name );
821 }
822 */
823
824 if ( VbhPor->DIR == 'I' ) Dir = VBL_ICNDFN;
825 else
826 if ( VbhPor->DIR == 'O' ) Dir = VBL_OCNDFN;
827 else Dir = VBL_BCNDFN;
828
829 addtab( hshtab, Name, VbhMod->NAME, VBL_SYMDFN, Dir );
830 addtab( hshtab, Name, VbhMod->NAME, VBL_TYPDFN, VbhType->INDEX );
831 addtab( hshtab, Name, VbhMod->NAME, VBL_WMNDFN, Left );
832 addtab( hshtab, Name, VbhMod->NAME, VBL_WMXDFN, Right );
833 addtab( hshtab, Name, VbhMod->NAME, VBL_ATLDFN, AttrLeft );
834 addtab( hshtab, Name, VbhMod->NAME, VBL_ATRDFN, AttrRight );
835 addtab( hshtab, Name, VbhMod->NAME, VBL_LBLDFN, VbhPor->KIND );
836 addtab( hshtab, Name, VbhMod->NAME, VBL_PNTDFN, (long)VexAtom );
837 addtab( hshtab, Name, VbhMod->NAME, VBL_SUNDFN, Signed );
838 addtab( hshtab, Name, VbhMod->NAME, VBL_DYNDFN, Dynamic );
839 }
840 }
841
842 /* BEINS */
843
844 if ( ScanPkgFig->BEINS != (vbins_list *)0 )
845 {
846 my_fprintf( stdout, "instance in package not supported !\n" );
847 autexit( 1 );
848 }
849
850 break;
851 }
852 }
853
854 if ( ScanPkgFig == (vbfig_list *)0 )
855 {
856 my_vbl_error(127,(char *)ScanChain->DATA);
857 }
858 }
859
860 if ( FuncArray != (char **)0 )
861 {
862 Index = 0;
863
864 while ( FuncArray[ Index ] != NULL )
865 {
866 Name = namealloc( FuncArray[ Index ] );
867 addtab ( hshtab, Name, VBL_MODNAM, VBL_SYMDFN, VBL_FUNDFN );
868 Index++;
869 }
870 }
871 }
872
873 freechain( VBL_NM2LST );
874 VBL_NM2LST = NULL;
875 }
876 package_declarative_part
877 END_ERR
878 .simple_name.
879 Semicolon_ERR
880 {
881 if (($7 != NULL) && ($7 != $2)) my_vbl_error (128,$7);
882 }
883 | _PACKAGE
884 error
885 { }
886 ;
887
888 package_declarative_part
889 : ..package_declarative_item..
890 { }
891 ;
892
893 ..package_declarative_item..
894 : /*empty*/
895 | ..package_declarative_item..
896 package_declarative_item
897 { }
898 ;
899
900 package_declarative_item
901 : type_declaration
902 | subtype_declaration
903 | attribute_declaration
904 | constant_declaration
905 | subprogram_declaration
906 | component_declaration
907 | attribute_specification
908 | signal_declaration
909 | error END_ERR
910 Semicolon_ERR
911 ;
912
913 /* 2.6 */
914 /* package bodies */
915
916 package_body
917 : _PACKAGE
918 BODY
919 Identifier
920 IS
921 {
922 if ($3 != VBL_MODNAM) my_vbl_error (128,$3);
923 }
924 package_body_declarative_part
925 END_ERR
926 .simple_name.
927 Semicolon_ERR
928 {
929 if (($8 != NULL) && ($8 != $3)) my_vbl_error (128,$8);
930 }
931 | _PACKAGE
932 BODY
933 error
934 { my_vbl_error ( 129,NULL); }
935 ;
936
937 package_body_declarative_part
938 : ..package_body_declarative_item..
939 ;
940
941 ..package_body_declarative_item..
942 : /*empty*/
943 | ..package_body_declarative_item..
944 package_body_declarative_item
945 ;
946
947 package_body_declarative_item
948 : subprogram_declaration
949 | subprogram_body
950 | type_declaration
951 | subtype_declaration
952 | constant_declaration
953 ;
954
955
956
957 /* 9.6 */
958 component_instantiation_statement
959 : a_label
960 /* Identifier */
961 name
962 {
963 if (chktab (hshtab,$1,VBL_MODNAM,VBL_SYMDFN) != 0)
964 {
965 my_vbl_error (19,$1);
966 }
967
968 addtab (hshtab,$1,VBL_MODNAM,VBL_SYMDFN,VBL_LBLDFN);
969
970 if (chktab (hshtab,$2.NAME,VBL_MODNAM,VBL_SYMDFN) != VBL_COMDFN)
971 {
972 my_vbl_error (125,$2.NAME);
973 }
974
975 VBL_BEINS = vbh_addvbins( VBL_BEINS, $1, $2.NAME, VBL_LINNUM );
976 VBL_COMPNAM = $2.NAME;
977 VBL_BEMAP = (vbmap_list *)0;
978 }
979 .generic_map_aspect.
980 {
981 VBL_BEINS->GEN_MAP = VBL_BEMAP;
982 VBL_BEMAP = (vbmap_list *)0;
983 }
984 .port_map_aspect.
985 {
986 VBL_BEINS->PORT_MAP = VBL_BEMAP;
987 VBL_BEMAP = (vbmap_list *)0;
988 }
989 Semicolon_ERR
990 {
991 vbmod_list *VbMod;
992 vbgen_list *VbGen;
993 vbpor_list *VbPor;
994 vbins_list *VbIns;
995 vbmap_list *VbMap;
996 long Explicit;
997
998 VbMod = (vbmod_list *)chktab(hshtab,$2.NAME,VBL_MODNAM,VBL_PNTDFN);
999 VbIns = VBL_BEINS;
1000
1001 VbIns->PORT_MAP = (vbmap_list *)reverse( (chain_list *)VbIns->PORT_MAP );
1002
1003 VbPor = VbMod->BEPOR;
1004 VbMap = VbIns->PORT_MAP;
1005 Explicit = 0;
1006
1007 while ( ( VbMap != (vbmap_list *)0 ) &&
1008 ( VbPor != (vbpor_list *)0 ) )
1009 {
1010 if ( VbMap->FORMAL == (vexexpr *)0 )
1011 {
1012 if ( Explicit )
1013 {
1014 my_vbl_error (125, VbIns->NAME);
1015 }
1016
1017 VbMap->FORMAL = dupvexexpr( VbPor->TARGET );
1018 VbPor = VbPor->NEXT;
1019 }
1020 else
1021 {
1022 Explicit = 1;
1023 }
1024
1025 VbMap = VbMap->NEXT;
1026 }
1027
1028 if ( VbMap != (vbmap_list *)0 )
1029 {
1030 my_vbl_error (125, VbIns->NAME);
1031 }
1032
1033 VbIns->GEN_MAP = (vbmap_list *)reverse( (chain_list *)VbIns->GEN_MAP );
1034
1035 VbGen = VbMod->BEGEN;
1036 VbMap = VbIns->GEN_MAP;
1037 Explicit = 0;
1038
1039 while ( ( VbMap != (vbmap_list *)0 ) &&
1040 ( VbGen != (vbgen_list *)0 ) )
1041 {
1042 if ( VbMap->FORMAL == (vexexpr *)0 )
1043 {
1044 if ( Explicit )
1045 {
1046 my_vbl_error (125, VbIns->NAME);
1047 }
1048
1049 VbMap->FORMAL = dupvexexpr( VbGen->TARGET );
1050 VbGen = VbGen->NEXT;
1051 }
1052 else
1053 {
1054 Explicit = 1;
1055 }
1056
1057 VbMap = VbMap->NEXT;
1058 }
1059
1060 if ( VbMap != (vbmap_list *)0 )
1061 {
1062 my_vbl_error (125, VbIns->NAME);
1063 }
1064
1065 VBL_COMPNAM = (char *)0;
1066 }
1067 ;
1068
1069 .port_map_aspect.
1070 : /*empty*/
1071 {}
1072 | port_map_aspect
1073 {}
1074 ;
1075 port_map_aspect
1076 :
1077 PORT
1078 MAP
1079 LeftParen /* was: PORT aggregate */
1080 association_list
1081 RightParen_ERR
1082 {}
1083 ;
1084
1085
1086 .generic_map_aspect.
1087 : /*empty*/
1088 {}
1089 | generic_map_aspect
1090 {}
1091 ;
1092 generic_map_aspect
1093 :
1094 GENERIC
1095 MAP
1096 LeftParen
1097 association_list
1098 RightParen_ERR
1099 {}
1100 ;
1101
1102 /* 9.7 */
1103 /*
1104 ** To avoid shift/reduce conflicts, define labeled/unlabeled generate
1105 ** statements.
1106 */
1107 generate_statement
1108 : a_label
1109 {
1110 if ( chktab (hshtab,$1,VBL_MODNAM,VBL_SYMDFN) != 0)
1111 my_vbl_error (19,$1);
1112
1113 addtab( hshtab,$1,VBL_MODNAM,VBL_SYMDFN,VBL_LBLDFN);
1114
1115 VBL_GNRNAM = $1;
1116 }
1117 unlabeled_generate_statement
1118 {
1119 }
1120 ;
1121
1122 unlabeled_generate_statement
1123 : generation_scheme
1124 GENERATE
1125 {
1126 vbl_name *Range;
1127 vbvar_list *VbVar;
1128 short Signed;
1129 long Left;
1130 long Right;
1131 long AttrLeft;
1132 long AttrRight;
1133 char ForUp;
1134
1135 VBL_BEGNR = vbh_addvbgnr( VBL_BEGNR, VBL_GNRNAM, VBL_LINNUM );
1136
1137 if ( $1.IDENT != (char *)0 )
1138 {
1139 if ( chktab( hshtab,$1.IDENT,VBL_MODNAM,VBL_SYMDFN ) != 0 )
1140 {
1141 my_vbl_error (80,$1.IDENT);
1142 }
1143
1144 Range = (vbl_name *)$1.VEX;
1145
1146 if ( Range->DYNAMIC )
1147 {
1148 if ( Range->DYNAMIC == VBL_UPTDFN ) ForUp = 1;
1149 else ForUp = 0;
1150
1151 AttrLeft = -1;
1152 AttrRight = -1;
1153 }
1154 else
1155 {
1156 AttrLeft = Range->LEFT;
1157 AttrRight = Range->RIGHT;
1158
1159 if ( AttrLeft <= AttrRight ) ForUp = 1;
1160 else ForUp = 0;
1161 }
1162
1163 VbVar = (vbvar_list *)vbl_addstr( 'f',0,
1164 get_type(VBH_TYPE_INTEGER),VBH_TYPE_INTEGER,
1165 'I',$1.IDENT, -1, -1, NULL, 0, 0 );
1166 //Target = VbVar->TARGET;
1167 Signed = ( IsVexNodeSigned( VbVar->TARGET ) != 0 );
1168
1169 if ( IsVexAtomBit( VbVar->TARGET ) )
1170 {
1171 Left = -1;
1172 Right = -1;
1173 }
1174 else
1175 {
1176 Left = VbVar->TARGET->LEFT;
1177 Right = VbVar->TARGET->RIGHT;
1178 }
1179
1180 addtab( hshtab,$1.IDENT,VBL_MODNAM,VBL_SYMDFN,VBL_VARDFN);
1181 addtab( hshtab,$1.IDENT,VBL_MODNAM,VBL_TYPDFN,VBH_TYPE_INTEGER);
1182 addtab( hshtab,$1.IDENT,VBL_MODNAM,VBL_WMNDFN,Left);
1183 addtab( hshtab,$1.IDENT,VBL_MODNAM,VBL_WMXDFN,Right);
1184 addtab( hshtab,$1.IDENT,VBL_MODNAM,VBL_ATLDFN,AttrLeft);
1185 addtab( hshtab,$1.IDENT,VBL_MODNAM,VBL_ATRDFN,AttrRight);
1186 addtab( hshtab,$1.IDENT,VBL_MODNAM,VBL_LBLDFN,0);
1187 addtab( hshtab,$1.IDENT,VBL_MODNAM,VBL_PNTDFN,(long)VbVar->TARGET);
1188 addtab( hshtab,$1.IDENT,VBL_MODNAM,VBL_SUNDFN,Signed);
1189
1190 if ( ! Range->DYNAMIC )
1191 {
1192 Range->LEFT = (long)createvexatomlong( AttrLeft , 0, Signed );
1193 Range->RIGHT = (long)createvexatomlong( AttrRight, 0, Signed );
1194 }
1195
1196 VBL_BEGNR->TYPE = VBH_GENERATE_FOR;
1197 VBL_BEGNR->FOR_VARIABLE = VbVar->TARGET;
1198 VBL_BEGNR->FOR_LEFT = (vexexpr *)Range->LEFT;
1199 VBL_BEGNR->FOR_RIGHT = (vexexpr *)Range->RIGHT;
1200 VBL_BEGNR->FOR_UP = ForUp;
1201
1202 autfreeheap( Range, sizeof( vbl_name ) );
1203 }
1204 else
1205 {
1206 VBL_BEGNR->TYPE = VBH_GENERATE_IF;
1207 VBL_BEGNR->IF_COND = $1.VEX;
1208 }
1209
1210 VBL_GNR_BEINS = addchain( VBL_GNR_BEINS, (void *)VBL_BEINS );
1211 VBL_GNR_BEPCS = addchain( VBL_GNR_BEPCS, (void *)VBL_BEPCS );
1212 VBL_GNR_BEGNR = addchain( VBL_GNR_BEGNR, (void *)VBL_BEGNR );
1213
1214 VBL_BEINS = (vbins_list *)0;
1215 VBL_BEPCS = (vbpcs_list *)0;
1216 VBL_BEGNR = (vbgnr_list *)0;
1217
1218 }
1219 set_of_statements
1220 END_ERR
1221 GENERATE
1222 .label.
1223 Semicolon_ERR
1224 {
1225 vbgnr_list *BeGnr;
1226
1227 if ( $1.IDENT != (char *)0 )
1228 {
1229 addtab( hshtab,$1.IDENT,VBL_MODNAM,VBL_SYMDFN,0);
1230 addtab( hshtab,$1.IDENT,VBL_MODNAM,VBL_TYPDFN,0);
1231 addtab( hshtab,$1.IDENT,VBL_MODNAM,VBL_WMNDFN,0);
1232 addtab( hshtab,$1.IDENT,VBL_MODNAM,VBL_WMXDFN,0);
1233 addtab( hshtab,$1.IDENT,VBL_MODNAM,VBL_ATLDFN,0);
1234 addtab( hshtab,$1.IDENT,VBL_MODNAM,VBL_ATRDFN,0);
1235 addtab( hshtab,$1.IDENT,VBL_MODNAM,VBL_LBLDFN,0);
1236 addtab( hshtab,$1.IDENT,VBL_MODNAM,VBL_PNTDFN,0);
1237 addtab( hshtab,$1.IDENT,VBL_MODNAM,VBL_SUNDFN,0);
1238 }
1239
1240 BeGnr = (vbgnr_list *)VBL_GNR_BEGNR->DATA;
1241
1242 BeGnr->BEINS = VBL_BEINS;
1243 BeGnr->BEPCS = VBL_BEPCS;
1244 BeGnr->BEGNR = VBL_BEGNR;
1245
1246 VBL_BEINS = (vbins_list *)VBL_GNR_BEINS->DATA;
1247 VBL_BEPCS = (vbpcs_list *)VBL_GNR_BEPCS->DATA;
1248 VBL_BEGNR = (vbgnr_list *)VBL_GNR_BEGNR->DATA;
1249
1250 VBL_GNR_BEINS = delchain( VBL_GNR_BEINS, VBL_GNR_BEINS );
1251 VBL_GNR_BEPCS = delchain( VBL_GNR_BEPCS, VBL_GNR_BEPCS );
1252 VBL_GNR_BEGNR = delchain( VBL_GNR_BEGNR, VBL_GNR_BEGNR );
1253 }
1254 ;
1255
1256 generation_scheme
1257 : FOR
1258 generate_parameter_specification
1259 {
1260 $$ = $2;
1261 }
1262 | IF
1263 condition
1264 {
1265 $$ = $2;
1266 }
1267 ;
1268
1269 generate_parameter_specification
1270 : Identifier
1271 _IN
1272 discrete_range
1273 {
1274 vbl_name *Range;
1275
1276 Range = (vbl_name *)autallocheap( sizeof( vbl_name ) );
1277 *Range = $3;
1278
1279 $$.IDENT = $1;
1280 $$.VEX = (vexexpr *)Range;
1281 }
1282 ;
1283
1284 association_list
1285 : association_element
1286 ...association_element..
1287 {}
1288 ;
1289
1290 ...association_element..
1291 : /*empty*/
1292 {}
1293 | Comma
1294 association_element
1295 ...association_element..
1296 {
1297 yyerrok;
1298 }
1299 ;
1300
1301 association_element
1302 : name
1303 Arrow
1304 {
1305 VBL_SAVCOMPNAM = VBL_COMPNAM;
1306 VBL_COMPNAM = (char *)0;
1307 }
1308 expression
1309 {
1310 vexexpr *Formal;
1311 vexexpr *Actual;
1312
1313 struct vbl_expr expr1;
1314 struct vbl_expr expr_name;
1315 char *LocalName;
1316 char Buffer[ 40 ];
1317 long left;
1318 long right;
1319 long left_bnd;
1320 long right_bnd;
1321 unsigned char dynamic;
1322 long mode;
1323 long flag;
1324
1325 VBL_COMPNAM = VBL_SAVCOMPNAM;
1326 VBL_SAVCOMPNAM = (char *)0;
1327
1328 flag = $1.FLAG;
1329
1330 if ( ( flag != 0 ) &&
1331 ( flag != VBL_EVENT ) &&
1332 ( flag != VBL_STABLE ) )
1333 {
1334 if ( ( flag != VBL_RANGE ) &&
1335 ( flag != VBL_REV_RANGE ) )
1336 {
1337 sprintf( Buffer, "%ld", $1.LEFT );
1338
1339 expr1.IDENT = Buffer;
1340 expr1.VEX = (vexexpr *)0;
1341 expr1.TYPE = -1;
1342
1343 expr_name = vbl_crtvex( NOPS, expr1, VBL_EMPSTR, -1, -1, 0);
1344 }
1345 else
1346 {
1347 my_vbl_error(124,$1.NAME);
1348 }
1349 }
1350 else
1351 if ( ( $1.NAME[0] == '"' ) ||
1352 ( $1.NAME[0] == '\'') )
1353 {
1354 my_vbl_error(124,$1.NAME);
1355 }
1356 else
1357 {
1358 LocalName = VBL_COMPNAM;
1359 mode = chktab (hshtab,$1.NAME,LocalName,VBL_SYMDFN);
1360
1361 if( mode == 0 || mode == VBL_PRODFN )
1362 {
1363 my_vbl_error (17,$1.NAME);
1364 }
1365
1366 /* LUDO_DYNAMIC */
1367 dynamic = chktab (hshtab,$1.NAME,LocalName,VBL_DYNDFN);
1368 left_bnd = chktab (hshtab,$1.NAME,LocalName,VBL_WMNDFN);
1369 right_bnd = chktab (hshtab,$1.NAME,LocalName,VBL_WMXDFN);
1370
1371 if ( ( ! $1.DYNAMIC ) &&
1372 ( ! dynamic ) )
1373 {
1374 left = $1.LEFT;
1375 right = $1.RIGHT;
1376
1377 if ( left_bnd <= right_bnd )
1378 {
1379 if (left <= right)
1380 {
1381 //in_bound = left - left_bnd;
1382 //out_bound = right - left_bnd;
1383 if ((left < left_bnd) || (right > right_bnd))
1384 {
1385 my_vbl_error (36,$1.NAME);
1386 }
1387 }
1388 else
1389 {
1390 //in_bound = right - left_bnd;
1391 //out_bound = left - left_bnd;
1392 if ((left > right_bnd) || (right < left_bnd))
1393 {
1394 my_vbl_error (36,$1.NAME);
1395 }
1396 }
1397 }
1398 else
1399 {
1400 if (left <= right)
1401 {
1402 //in_bound = left - right_bnd;
1403 //out_bound = right - right_bnd;
1404 if ((left < right_bnd) || (right > left_bnd))
1405 {
1406 my_vbl_error (36,$1.NAME);
1407 }
1408 }
1409 else
1410 {
1411 //in_bound = right - right_bnd;
1412 //out_bound = left - right_bnd;
1413 if ((left > left_bnd) || (right < right_bnd))
1414 {
1415 my_vbl_error (36,$1.NAME);
1416 }
1417 }
1418 }
1419 }
1420 else
1421 {
1422 left = $1.LEFT;
1423 right = $1.RIGHT;
1424 }
1425
1426 {
1427 long type;
1428
1429 expr1.IDENT = $1.NAME;
1430 type = chktab(hshtab,$1.NAME,LocalName,VBL_TYPDFN);
1431 expr1.TYPE = type;
1432 expr1.SIGNED = chktab (hshtab,$1.NAME,LocalName,VBL_SUNDFN);
1433
1434 if ( $1.DYNAMIC )
1435 {
1436 if ( ( mode == VBL_FUNDFN ) ||
1437 ( mode == VBL_TPEDFN ) ||
1438 ( mode == VBL_PRODFN ) )
1439 {
1440 expr1.VEX = (vexexpr *)left;
1441 expr1 =
1442 vbl_crtvex(SUBVAR,expr1,VBL_EMPSTR,expr1.VEX->LEFT,expr1.VEX->RIGHT,0);
1443 }
1444 else
1445 {
1446 expr1 = vbl_crtvex (NOPI,expr1,VBL_EMPSTR,left_bnd,right_bnd,dynamic);
1447
1448 if ( $1.DYNAMIC == VBL_UPTDFN )
1449 {
1450 if ( ( ! dynamic ) ||
1451 ( ! isvexequalexpr( (vexexpr *)left_bnd, (vexexpr *)left ) ) ||
1452 ( ! isvexequalexpr( (vexexpr *)right_bnd, (vexexpr *)right ) ) )
1453 {
1454 expr1 = vbl_crtvex( VEX_TO, expr1,VBL_EMPSTR,left,right,0);
1455 }
1456 }
1457 else
1458 if ( $1.DYNAMIC == VBL_DWTDFN )
1459 {
1460 if ( ( ! dynamic ) ||
1461 ( ! isvexequalexpr( (vexexpr *)left_bnd, (vexexpr *)left ) ) ||
1462 ( ! isvexequalexpr( (vexexpr *)right_bnd, (vexexpr *)right ) ) )
1463 {
1464 expr1 = vbl_crtvex( VEX_DOWNTO, expr1,VBL_EMPSTR,left,right,0);
1465 }
1466 }
1467 else
1468 {
1469 expr1.VEX =
1470 createvexbinexpr( VEX_INDEX_N, 1, expr1.VEX, (vexexpr *)left );
1471 expr1.VEX =
1472 createvexbinexpr( VEX_INDEX_N, 1, expr1.VEX, (vexexpr *)right );
1473 }
1474 }
1475 }
1476 else
1477 {
1478 expr1 = vbl_crtvex (NOPI,expr1,VBL_EMPSTR,left,right,0);
1479 }
1480
1481 if( flag == VBL_EVENT )
1482 {
1483 expr_name = vbl_crtvex (VEX_EVENT,expr1,VBL_EMPSTR,left,right,0);
1484 }
1485 else
1486 if( flag == VBL_STABLE )
1487 {
1488 expr1 = vbl_crtvex(VEX_EVENT,expr1,VBL_EMPSTR,left,right,0);
1489 expr_name = vbl_crtvex (VEX_NOT,expr1,VBL_EMPSTR,-1,-1,0);
1490 }
1491 else
1492 {
1493 expr_name = expr1;
1494 }
1495 }
1496 }
1497
1498 Formal = expr_name.VEX;
1499 Actual = $4.VEX;
1500
1501 VBL_BEMAP = vbh_addvbmap( VBL_BEMAP, Formal, Actual, VBL_LINNUM);
1502 }
1503 | /* actual_part */
1504 expression /* can be name also */
1505 {
1506 vexexpr *Actual;
1507
1508 Actual = $1.VEX;
1509
1510 VBL_BEMAP = vbh_addvbmap( VBL_BEMAP, (vexexpr *)0, Actual, VBL_LINNUM);
1511 }
1512 ;
1513
1514 ...selected_name..
1515 : /*empty*/
1516 { }
1517 | ...selected_name..
1518 Comma
1519 selected_name
1520 { }
1521 ;
1522
1523 /* 4.5 */
1524 component_declaration
1525 : COMPONENT
1526 Identifier
1527 {
1528 VBL_COMPNAM = $2;
1529 VBL_BEFPNT->BEMOD = vbh_addvbmod( VBL_BEFPNT->BEMOD, VBL_COMPNAM, VBL_LINNUM );
1530 addtab(hshtab,$2,VBL_MODNAM,VBL_SYMDFN,VBL_COMDFN);
1531 addtab(hshtab,$2,VBL_MODNAM,VBL_PNTDFN,(long)VBL_BEFPNT->BEMOD);
1532 }
1533 .GENERIC__local_generic_list.
1534 .PORT__local_port_list.
1535 END_ERR
1536 COMPONENT
1537 Semicolon_ERR
1538 { VBL_COMPNAM = (char *)0;
1539 VBL_BEFPNT->BEMOD->BEPOR =
1540 (vbpor_list *)reverse( (chain_list *)VBL_BEFPNT->BEMOD->BEPOR );
1541 VBL_BEFPNT->BEMOD->BEGEN =
1542 (vbgen_list *)reverse( (chain_list *)VBL_BEFPNT->BEMOD->BEGEN );
1543 }
1544
1545 ;
1546
1547 .PORT__local_port_list.
1548 : /*empty*/
1549 | PORT
1550 LeftParen
1551 local_port_list
1552 RightParen_ERR
1553 Semicolon_ERR
1554 { }
1555 ;
1556
1557 local_port_list
1558 : local_port_element
1559 ...local_port_element..
1560 { }
1561 | error RightParen_ERR
1562 { }
1563 ;
1564
1565
1566 ...local_port_element..
1567 : /*empty*/
1568 | ...local_port_element..
1569 Semicolon_ERR
1570 local_port_element
1571 { }
1572 ;
1573
1574
1575 local_port_element
1576 : .SIGNAL.
1577 identifier_list
1578 Colon
1579 .local_port_mode.
1580 type_mark
1581 .constraint.
1582 .signal_kind.
1583 {
1584 char *signame;
1585 vbpor_list *VbPort;
1586 vbtyp_list *VbType;
1587 short Signed;
1588 long Left = 0;
1589 long Right = 0;
1590 long AttrLeft;
1591 long AttrRight;
1592
1593 VbType = val_type( $5.NAME );
1594
1595 if ( $6.DYNAMIC ) /* LUDO_DYNAMIC */
1596 {
1597 AttrLeft = $6.LEFT;
1598 AttrRight = $6.RIGHT;
1599 Left = AttrLeft;
1600 Right = AttrRight;
1601 }
1602 else
1603 if ( ( $6.LEFT == -1 ) &&
1604 ( $6.RIGHT == -1 ) )
1605 {
1606 AttrLeft = VbType->LEFT;
1607 AttrRight = VbType->RIGHT;
1608 }
1609 else
1610 {
1611 AttrLeft = $6.LEFT;
1612 AttrRight = $6.RIGHT;
1613 }
1614
1615 VBL_NM1LST = reverse( VBL_NM1LST );
1616
1617 while (VBL_NM1LST != NULL)
1618 {
1619 signame = (char *)VBL_NM1LST->DATA;
1620 if (chktab (hshtab,signame,VBL_COMPNAM,VBL_SYMDFN) != 0)
1621 my_vbl_error (4,signame);
1622
1623 VbPort = (vbpor_list *)vbl_addstr( 'M',$4, VbType,
1624 $5.TYPE,$5.FLAG,signame,
1625 AttrLeft, AttrRight,
1626 (vexexpr *)0,VBH_KIND_NONE, $6.DYNAMIC);
1627
1628 addtab (hshtab,signame,VBL_COMPNAM,VBL_SYMDFN,$4);
1629
1630 Signed = ( IsVexNodeSigned( VbPort->TARGET ) != 0 );
1631
1632 if ( ( $5.FLAG == 'I' ) && ( $6.DYNAMIC ) )
1633 {
1634 $6.DYNAMIC = VBL_DWTDFN;
1635 }
1636
1637 if ( ! $6.DYNAMIC ) /* LUDO_DYNAMIC */
1638 {
1639 if ( IsVexAtomBit( VbPort->TARGET ) )
1640 {
1641 Left = -1;
1642 Right = -1;
1643 }
1644 else
1645 {
1646 Left = VbPort->TARGET->LEFT;
1647 Right = VbPort->TARGET->RIGHT;
1648 }
1649 }
1650
1651 addtab( hshtab,signame,VBL_COMPNAM,VBL_TYPDFN,$5.TYPE);
1652 addtab( hshtab,signame,VBL_COMPNAM,VBL_WMNDFN,Left );
1653 addtab( hshtab,signame,VBL_COMPNAM,VBL_WMXDFN,Right );
1654 addtab( hshtab,signame,VBL_COMPNAM,VBL_ATLDFN,AttrLeft );
1655 addtab( hshtab,signame,VBL_COMPNAM,VBL_ATRDFN,AttrRight );
1656 addtab( hshtab,signame,VBL_COMPNAM,VBL_LBLDFN,VBH_KIND_NONE);
1657 addtab( hshtab,signame,VBL_COMPNAM,VBL_PNTDFN,(long)VbPort->TARGET);
1658 addtab( hshtab,signame,VBL_COMPNAM,VBL_SUNDFN,Signed);
1659 addtab( hshtab,signame,VBL_COMPNAM,VBL_DYNDFN,$6.DYNAMIC);
1660
1661 VBL_NM1LST = delchain (VBL_NM1LST, VBL_NM1LST);
1662 }
1663 }
1664 ;
1665
1666 .local_port_mode.
1667 : /*empty*/
1668 { $$ = VBL_ICNDFN; }
1669 | _IN
1670 { $$ = VBL_ICNDFN; }
1671 | _OUT
1672 { $$ = VBL_OCNDFN; }
1673 | _INOUT
1674 { $$ = VBL_BCNDFN; }
1675 | _BUFFER
1676 { $$ = VBL_BCNDFN; }
1677 | _LINKAGE
1678 { $$ = VBL_BCNDFN; }
1679 ;
1680
1681 .GENERIC__local_generic_list.
1682 : /*empty*/
1683 | GENERIC
1684 LeftParen
1685 local_generic_list
1686 RightParen_ERR
1687 Semicolon_ERR
1688 { }
1689 ;
1690
1691 local_generic_list
1692 : local_generic_element
1693 ...local_generic_element..
1694 { }
1695 | error RightParen_ERR
1696 { }
1697 ;
1698
1699
1700 ...local_generic_element..
1701 : /*empty*/
1702 { }
1703 | ...local_generic_element..
1704 Semicolon_ERR
1705 local_generic_element
1706 { }
1707 ;
1708
1709
1710 local_generic_element
1711 : .CONSTANT.
1712 identifier_list
1713 Colon
1714 .IN.
1715 type_mark
1716 .constraint.
1717 .VarAsgn__expression.
1718 {
1719 char *signame;
1720 vbgen_list *VbGen;
1721 vbtyp_list *VbType;
1722 vexexpr *VexInit;
1723 short Signed;
1724 long Left;
1725 long Right;
1726 long AttrLeft;
1727 long AttrRight;
1728
1729 if ( $6.DYNAMIC )
1730 {
1731 my_vbl_error (6,NULL);
1732 }
1733
1734 VbType = val_type( $5.NAME );
1735
1736 if ( ( $6.LEFT == -1 ) &&
1737 ( $6.RIGHT == -1 ) )
1738 {
1739 AttrLeft = VbType->LEFT;
1740 AttrRight = VbType->RIGHT;
1741 }
1742 else
1743 {
1744 AttrLeft = $6.LEFT;
1745 AttrRight = $6.RIGHT;
1746 }
1747
1748 VBL_NM1LST = reverse( VBL_NM1LST );
1749
1750 while (VBL_NM1LST != NULL)
1751 {
1752 VexInit = $7.VEX;
1753
1754 if ( ( VexInit != (vexexpr *)0 ) &&
1755 ( VBL_NM1LST->NEXT != (chain_list *)0 ) )
1756 {
1757 VexInit = dupvexexpr( $7.VEX );
1758 }
1759
1760 signame = (char *)VBL_NM1LST->DATA;
1761 if (chktab (hshtab,signame,VBL_COMPNAM,VBL_SYMDFN) != 0)
1762 my_vbl_error (4,signame);
1763
1764 VexInit = simpvexexpr( VexInit );
1765
1766 VbGen = (vbgen_list *)vbl_addstr( 'g',0, VbType,
1767 $5.TYPE,$5.FLAG,signame,
1768 AttrLeft, AttrRight,VexInit,VBH_KIND_NONE, 0);
1769
1770 addtab (hshtab,signame,VBL_COMPNAM,VBL_SYMDFN,VBL_GENDFN);
1771
1772 Signed = ( IsVexNodeSigned( VbGen->TARGET ) != 0 );
1773
1774 if ( IsVexAtomBit( VbGen->TARGET ) )
1775 {
1776 Left = -1;
1777 Right = -1;
1778 }
1779 else
1780 {
1781 Left = VbGen->TARGET->LEFT;
1782 Right = VbGen->TARGET->RIGHT;
1783 }
1784
1785 addtab( hshtab,signame,VBL_COMPNAM,VBL_TYPDFN,$5.TYPE);
1786 addtab( hshtab,signame,VBL_COMPNAM,VBL_WMNDFN,Left );
1787 addtab( hshtab,signame,VBL_COMPNAM,VBL_WMXDFN,Right );
1788 addtab( hshtab,signame,VBL_COMPNAM,VBL_ATLDFN,AttrLeft );
1789 addtab( hshtab,signame,VBL_COMPNAM,VBL_ATRDFN,AttrRight );
1790 addtab( hshtab,signame,VBL_COMPNAM,VBL_LBLDFN,VBH_KIND_NONE);
1791 addtab( hshtab,signame,VBL_COMPNAM,VBL_PNTDFN,(long)VbGen->TARGET);
1792 addtab( hshtab,signame,VBL_COMPNAM,VBL_SUNDFN,Signed);
1793
1794 VBL_NM1LST = delchain (VBL_NM1LST, VBL_NM1LST);
1795 }
1796 }
1797 ;
1798
1799 /* 4.4 */
1800 attribute_declaration
1801 : ATTRIBUTE
1802 Identifier
1803 Colon
1804 simple_name
1805 Semicolon_ERR
1806 {
1807 if ( strcmp( $4, "string" ) )
1808 {
1809 my_vbl_error(9, $2 );
1810 }
1811
1812 addtab(hshtab,$2,VBL_MODNAM,VBL_SYMDFN,VBL_ATTDFN);
1813 }
1814 ;
1815
1816 attribute_specification
1817 : ATTRIBUTE
1818 simple_name
1819 {
1820 if ( ! chktab(hshtab,$2,VBL_MODNAM,VBL_SYMDFN ) )
1821 {
1822 my_vbl_error(9,$2);
1823 }
1824 }
1825 OF
1826 simple_name
1827 Colon
1828 entity_class
1829 IS
1830 StringLit
1831 Semicolon_ERR
1832 {
1833 char Buffer[ 512 ];
1834 long length;
1835
1836 length = strlen( $9 );
1837
1838 strcpy( Buffer, $9 + 1);
1839 Buffer[ length -2 ] = '\0';
1840
1841 $9 = namealloc( Buffer );
1842
1843 VBL_BEFPNT->BEATR = vbh_addvbatr( VBL_BEFPNT->BEATR, $2, $5, $7, $9, VBL_LINNUM );
1844 }
1845 ;
1846
1847 entity_class
1848 : _ENTITY
1849 { $$ = VBH_ATTR_ENTITY; }
1850 | ARCHITECTURE
1851 { $$ = VBH_ATTR_ARCHITECTURE; }
1852 | _PACKAGE
1853 { $$ = VBH_ATTR_PACKAGE; }
1854 | FUNCTION
1855 { $$ = VBH_ATTR_FUNCTION; }
1856 | PROCEDURE
1857 { $$ = VBH_ATTR_PROCEDURE; }
1858 | SUBTYPE
1859 { $$ = VBH_ATTR_SUBTYPE; }
1860 | CONSTANT
1861 { $$ = VBH_ATTR_CONSTANT; }
1862 | _VARIABLE
1863 { $$ = VBH_ATTR_VARIABLE; }
1864 | SIGNAL
1865 { $$ = VBH_ATTR_SIGNAL; }
1866 | _LABEL
1867 { $$ = VBH_ATTR_LABEL; }
1868 | _TYPE
1869 { $$ = VBH_ATTR_TYPE; }
1870 | CONFIGURATION
1871 { $$ = VBH_ATTR_CONFIGURATION; }
1872 | COMPONENT
1873 { $$ = VBH_ATTR_COMPONENT; }
1874 ;
1875
1876 selected_name
1877 : prefix
1878 Dot
1879 suffix
1880 { char buffer[ 128 ]; sprintf( buffer, "%s.%s", $1, $3 );
1881 $$ = namealloc( buffer );
1882 VBL_NM2LST = addchain( VBL_NM2LST, $$ );
1883 }
1884 ;
1885
1886 suffix
1887 : simple_name
1888 { $$ = $1; }
1889 | ALL
1890 { $$ = namealloc( "all" ); }
1891 ;
1892 prefix
1893 : simple_name
1894 { $$ = $1; }
1895 | prefix
1896 Dot
1897 simple_name
1898 { char buffer[ 128 ]; sprintf( buffer, "%s.%s", $1, $3 );
1899 $$ = namealloc( buffer ); }
1900 ;
1901
1902 entity_declaration
1903 : _ENTITY
1904 simple_name
1905 IS
1906 {
1907 vbfig_list *ScanPkgFig;
1908 chain_list *ScanChain;
1909 char *Name;
1910 char **FuncArray;
1911 long Index;
1912 long Left = 0;
1913 long Right = 0;
1914 long AttrLeft = 0;
1915 long AttrRight = 0;
1916 long Dir;
1917 long Signed = 0;
1918 vbcst_list *VbhCst;
1919 vbaux_list *VbhAux;
1920 vbmod_list *VbhMod;
1921 vbpor_list *VbhPor;
1922 vbgen_list *VbhGen;
1923 vbtyp_list *VbhType;
1924 vbpcs_list *VbhPcs;
1925 vexexpr *VexAtom;
1926 chain_list *PackList;
1927 long Dynamic;
1928 long Oper;
1929
1930 extern char *vbl_func_std_logic_1164[];
1931 extern char *vbl_func_std_logic_arith[];
1932 extern char *vbl_func_std_numeric_std[];
1933
1934 long size=0;
1935 struct vbtyp *vbtyp_pnt;
1936 VBL_BEFPNT->NAME = $2;
1937 VBL_MODNAM = $2;
1938
1939 for ( ScanChain = VBL_NM2LST;
1940 ScanChain != (chain_list *)0;
1941 ScanChain = ScanChain->NEXT )
1942 {
1943 FuncArray = (char **)0;
1944
1945 if ( ! strcmp( ScanChain->DATA, "ieee.std_logic_1164.all" ) )
1946 {
1947 FuncArray = vbl_func_std_logic_1164;
1948 }
1949 else
1950 if ( ( ! strcmp( ScanChain->DATA, "ieee.std_logic_arith.all" ) ) ||
1951 ( ! strcmp( ScanChain->DATA, "ieee.std_logic_signed.all" ) ) ||
1952 ( ! strcmp( ScanChain->DATA, "ieee.std_logic_unsigned.all" ) ) )
1953 {
1954 FuncArray = vbl_func_std_logic_arith;
1955 }
1956 else
1957 if ( ( ! strcmp( ScanChain->DATA, "ieee.numeric_std.all" ) ) ||
1958 ( ! strcmp( ScanChain->DATA, "ieee.numeric_bit.all" ) ) )
1959 {
1960 FuncArray = vbl_func_std_numeric_std;
1961 }
1962 else
1963 {
1964 for ( ScanPkgFig = VBL_HEADFIG;
1965 ScanPkgFig != (vbfig_list *)0;
1966 ScanPkgFig = ScanPkgFig->NEXT )
1967 {
1968 if ( ( ScanPkgFig->IS_PACKAGE ) &&
1969 ( ScanPkgFig->NAME == (char *)ScanChain->DATA ) )
1970 {
1971 for ( PackList = VBL_BEFPNT->PACK_LIST;
1972 PackList != (chain_list *)0;
1973 PackList = PackList->NEXT )
1974 {
1975 if ( PackList->DATA == ScanChain->DATA ) break; /* already included */
1976 }
1977
1978 if ( PackList == (chain_list *)0 )
1979 {
1980 vbh_dupvbfig( VBL_BEFPNT, ScanPkgFig );
1981 }
1982
1983 /* BECST */
1984
1985 for ( VbhCst = ScanPkgFig->BECST;
1986 VbhCst != (vbcst_list *)0;
1987 VbhCst = VbhCst->NEXT )
1988 {
1989 VbhType = vbh_getvbtyp( VBL_BEFPNT, VbhCst->TYPE->NAME );
1990 VexAtom = VbhCst->TARGET;
1991
1992 if ( ! IsVexNodeAtom( VexAtom ) )
1993 {
1994 my_fprintf( stdout, "dynamic declaration not supported !\n" );
1995 autexit( 1 );
1996 }
1997
1998 Name = GetVexAtomValue( VexAtom );
1999
2000 /*
2001 if ( chktab( hshtab, Name, VBL_MODNAM, VBL_SYMDFN ) )
2002 {
2003 my_vbl_error( 10, Name );
2004 }
2005 */
2006
2007 if ( IsVexAtomBit( VexAtom ) )
2008 {
2009 Left = -1;
2010 Right = -1;
2011 }
2012 else
2013 {
2014 Left = VexAtom->LEFT;
2015 Right = VexAtom->RIGHT;
2016 }
2017
2018 Signed = ( IsVexNodeSigned( VexAtom ) != 0 );
2019 AttrLeft = Left;
2020 AttrRight = Right;
2021
2022 addtab( hshtab, Name, VBL_MODNAM, VBL_SYMDFN, VBL_CSTDFN );
2023 addtab( hshtab, Name, VBL_MODNAM, VBL_TYPDFN, VbhType->INDEX );
2024 addtab( hshtab, Name, VBL_MODNAM, VBL_WMNDFN, Left );
2025 addtab( hshtab, Name, VBL_MODNAM, VBL_WMXDFN, Right );
2026 addtab( hshtab, Name, VBL_MODNAM, VBL_ATLDFN, AttrLeft );
2027 addtab( hshtab, Name, VBL_MODNAM, VBL_ATRDFN, AttrRight );
2028 addtab( hshtab, Name, VBL_MODNAM, VBL_LBLDFN, 0 );
2029 addtab( hshtab, Name, VBL_MODNAM, VBL_PNTDFN, (long)VbhCst->VEX );
2030 addtab( hshtab, Name, VBL_MODNAM, VBL_SUNDFN, Signed );
2031 addtab( hshtab, Name, VBL_MODNAM, VBL_DYNDFN, 0 );
2032 }
2033
2034 /* BEAUX */
2035
2036 for ( VbhAux = ScanPkgFig->BEAUX;
2037 VbhAux != (vbaux_list *)0;
2038 VbhAux = VbhAux->NEXT )
2039 {
2040 VbhType = vbh_getvbtyp( VBL_BEFPNT, VbhAux->TYPE->NAME );
2041 VexAtom = VbhAux->TARGET;
2042
2043 if ( ! IsVexNodeAtom( VexAtom ) )
2044 {
2045 my_fprintf( stdout, "dynamic declaration not supported !\n" );
2046 autexit( 1 );
2047 }
2048
2049 Name = GetVexAtomValue( VexAtom );
2050
2051 /*
2052 if ( chktab( hshtab, Name, VBL_MODNAM, VBL_SYMDFN ) )
2053 {
2054 my_vbl_error( 10, Name );
2055 }
2056 */
2057
2058 Signed = (IsVexNodeSigned( VexAtom ) != 0);
2059 Left = VexAtom->LEFT;
2060 Right = VexAtom->RIGHT;
2061 AttrLeft = Left;
2062 AttrRight = Right;
2063
2064 addtab( hshtab, Name, VBL_MODNAM, VBL_SYMDFN, VBL_SGNDFN );
2065 addtab( hshtab, Name, VBL_MODNAM, VBL_TYPDFN, VbhType->INDEX );
2066 addtab( hshtab, Name, VBL_MODNAM, VBL_WMNDFN, Left );
2067 addtab( hshtab, Name, VBL_MODNAM, VBL_WMXDFN, Right );
2068 addtab( hshtab, Name, VBL_MODNAM, VBL_ATLDFN, AttrLeft );
2069 addtab( hshtab, Name, VBL_MODNAM, VBL_ATRDFN, AttrRight );
2070 addtab( hshtab, Name, VBL_MODNAM, VBL_LBLDFN, VbhAux->KIND );
2071 addtab( hshtab, Name, VBL_MODNAM, VBL_PNTDFN, (long)VexAtom );
2072 addtab( hshtab, Name, VBL_MODNAM, VBL_SUNDFN, Signed );
2073 addtab( hshtab, Name, VBL_MODNAM, VBL_DYNDFN, 0 );
2074 }
2075
2076 /* BEPCS */
2077
2078 for ( VbhPcs = ScanPkgFig->BEPCS;
2079 VbhPcs != (vbpcs_list *)0;
2080 VbhPcs = VbhPcs->NEXT )
2081 {
2082 addtab( hshtab, VbhPcs->LABEL, VBL_MODNAM, VBL_SYMDFN, VBL_LBLDFN );
2083 }
2084
2085 /* BEFUN TO BE DONE */
2086
2087 if ( ScanPkgFig->BEFUN != (vbfun_list *)0 )
2088 {
2089 my_fprintf( stdout, "function in package not supported !\n" );
2090 autexit( 1 );
2091 }
2092
2093 /* BEATR TO BE DONE */
2094
2095 if ( ScanPkgFig->BEATR != (vbatr_list *)0 )
2096 {
2097 my_fprintf( stdout, "attribute in package not supported !\n" );
2098 autexit( 1 );
2099 }
2100
2101 /* BEGNR TO BE DONE ??? */
2102
2103 if ( ScanPkgFig->BEGNR != (vbgnr_list *)0 )
2104 {
2105 my_fprintf( stdout, "generate in package not supported !\n" );
2106 autexit( 1 );
2107 }
2108
2109 /* BEMOD */
2110
2111 for ( VbhMod = ScanPkgFig->BEMOD;
2112 VbhMod != (vbmod_list *)0;
2113 VbhMod = VbhMod->NEXT )
2114 {
2115 addtab(hshtab,VbhMod->NAME,VBL_MODNAM,VBL_SYMDFN,VBL_COMDFN);
2116 addtab(hshtab,VbhMod->NAME,VBL_MODNAM,VBL_PNTDFN,(long)VbhMod);
2117
2118 for ( VbhGen = VbhMod->BEGEN;
2119 VbhGen != (vbgen_list *)0;
2120 VbhGen = VbhGen->NEXT )
2121 {
2122 VbhType = vbh_getvbtyp( VBL_BEFPNT, VbhGen->TYPE->NAME );
2123 VexAtom = VbhGen->TARGET;
2124
2125 if ( ! IsVexNodeAtom( VexAtom ) )
2126 {
2127 my_fprintf( stdout, "dynamic declaration not supported !\n" );
2128 autexit( 1 );
2129 }
2130
2131 Name = GetVexAtomValue( VexAtom );
2132
2133 /*
2134 if ( chktab( hshtab, Name, VBL_MODNAM, VBL_SYMDFN ) )
2135 {
2136 my_vbl_error( 10, Name );
2137 }
2138 */
2139
2140 Signed = (IsVexNodeSigned( VexAtom ) != 0);
2141 Left = VexAtom->LEFT;
2142 Right = VexAtom->RIGHT;
2143 AttrLeft = Left;
2144 AttrRight = Right;
2145
2146 addtab( hshtab, Name, VbhMod->NAME, VBL_SYMDFN, VBL_GENDFN );
2147 addtab( hshtab, Name, VbhMod->NAME, VBL_TYPDFN, VbhType->INDEX );
2148 addtab( hshtab, Name, VbhMod->NAME, VBL_WMNDFN, Left );
2149 addtab( hshtab, Name, VbhMod->NAME, VBL_WMXDFN, Right );
2150 addtab( hshtab, Name, VbhMod->NAME, VBL_ATLDFN, AttrLeft );
2151 addtab( hshtab, Name, VbhMod->NAME, VBL_ATRDFN, AttrRight );
2152 addtab( hshtab, Name, VbhMod->NAME, VBL_LBLDFN, VBH_KIND_NONE );
2153 addtab( hshtab, Name, VbhMod->NAME, VBL_PNTDFN, (long)VexAtom );
2154 addtab( hshtab, Name, VbhMod->NAME, VBL_SUNDFN, Signed );
2155 addtab( hshtab, Name, VbhMod->NAME, VBL_DYNDFN, 0 );
2156 }
2157
2158 for ( VbhPor = VbhMod->BEPOR;
2159 VbhPor != (vbpor_list *)0;
2160 VbhPor = VbhPor->NEXT )
2161 {
2162 VbhType = vbh_getvbtyp( VBL_BEFPNT, VbhPor->TYPE->NAME );
2163 VexAtom = VbhPor->TARGET;
2164
2165 if ( ! IsVexNodeAtom( VexAtom ) )
2166 {
2167 Name = getvexatomname( VexAtom );
2168 Dynamic = 0;
2169
2170 if ( IsVexNodeOper( VexAtom ) )
2171 {
2172 Oper = GetVexOperValue( VexAtom );
2173
2174 if ( Oper == VEX_DOWNTO ) Dynamic = VBL_DWTDFN;
2175 else
2176 if ( Oper == VEX_TO ) Dynamic = VBL_UPTDFN;
2177
2178 Signed = (IsVexNodeSigned( VexAtom ) != 0);
2179 Left = (long)GetVexOperand( VexAtom->OPERAND->NEXT );
2180 Right = (long)GetVexOperand( VexAtom->OPERAND->NEXT->NEXT );
2181 AttrLeft = Left;
2182 AttrRight = Right;
2183 }
2184
2185 if ( ! Dynamic )
2186 {
2187 my_fprintf( stdout, "such dynamic declaration not supported !\n" );
2188 autexit( 1 );
2189 }
2190 }
2191 else
2192 {
2193 Name = GetVexAtomValue( VexAtom );
2194
2195 Signed = (IsVexNodeSigned( VexAtom ) != 0);
2196 Left = VexAtom->LEFT;
2197 Right = VexAtom->RIGHT;
2198 AttrLeft = Left;
2199 AttrRight = Right;
2200 Dynamic = 0;
2201 }
2202
2203 /*
2204 if ( chktab( hshtab, Name, VBL_MODNAM, VBL_SYMDFN ) )
2205 {
2206 my_vbl_error( 10, Name );
2207 }
2208 */
2209
2210 if ( VbhPor->DIR == 'I' ) Dir = VBL_ICNDFN;
2211 else
2212 if ( VbhPor->DIR == 'O' ) Dir = VBL_OCNDFN;
2213 else Dir = VBL_BCNDFN;
2214
2215 addtab( hshtab, Name, VbhMod->NAME, VBL_SYMDFN, Dir );
2216 addtab( hshtab, Name, VbhMod->NAME, VBL_TYPDFN, VbhType->INDEX );
2217 addtab( hshtab, Name, VbhMod->NAME, VBL_WMNDFN, Left );
2218 addtab( hshtab, Name, VbhMod->NAME, VBL_WMXDFN, Right );
2219 addtab( hshtab, Name, VbhMod->NAME, VBL_ATLDFN, AttrLeft );
2220 addtab( hshtab, Name, VbhMod->NAME, VBL_ATRDFN, AttrRight );
2221 addtab( hshtab, Name, VbhMod->NAME, VBL_LBLDFN, VbhPor->KIND );
2222 addtab( hshtab, Name, VbhMod->NAME, VBL_PNTDFN, (long)VexAtom );
2223 addtab( hshtab, Name, VbhMod->NAME, VBL_SUNDFN, Signed );
2224 addtab( hshtab, Name, VbhMod->NAME, VBL_DYNDFN, Dynamic );
2225 }
2226 }
2227
2228 /* BEINS */
2229
2230 if ( ScanPkgFig->BEINS != (vbins_list *)0 )
2231 {
2232 my_fprintf( stdout, "instance in package not supported !\n" );
2233 autexit( 1 );
2234 }
2235
2236 break;
2237 }
2238 }
2239
2240 if ( ScanPkgFig == (vbfig_list *)0 )
2241 {
2242 my_vbl_error(127,(char *)ScanChain->DATA);
2243 }
2244 }
2245
2246 if ( FuncArray != (char **)0 )
2247 {
2248 Index = 0;
2249
2250 while ( FuncArray[ Index ] != NULL )
2251 {
2252 Name = namealloc( FuncArray[ Index ] );
2253 addtab ( hshtab, Name, VBL_MODNAM, VBL_SYMDFN, VBL_FUNDFN );
2254 Index++;
2255 }
2256 }
2257 }
2258
2259 freechain( VBL_NM2LST );
2260 VBL_NM2LST = NULL;
2261
2262 vbtyp_pnt = VBL_BEFPNT->BETYP;
2263 while(vbtyp_pnt)
2264 {
2265 size++;
2266 vbtyp_pnt = vbtyp_pnt->NEXT;
2267 }
2268
2269 vbtyp_pnt = VBL_BEFPNT->BETYP;
2270 VBL_NUMTYP = 0;
2271 while(vbtyp_pnt)
2272 {
2273 addtab(hshtab,vbtyp_pnt->NAME,VBL_MODNAM,VBL_SYMDFN,VBL_TPEDFN);
2274 addtab(hshtab,vbtyp_pnt->NAME,VBL_MODNAM,VBL_LBLDFN,vbtyp_pnt->CLASS);
2275 addtab(hshtab,vbtyp_pnt->NAME,VBL_MODNAM,VBL_TYPDFN,vbtyp_pnt->INDEX);
2276 addtab(hshtab,vbtyp_pnt->NAME,VBL_MODNAM,VBL_WMNDFN,vbtyp_pnt->LEFT);
2277 addtab(hshtab,vbtyp_pnt->NAME,VBL_MODNAM,VBL_WMXDFN,vbtyp_pnt->RIGHT);
2278 addtab(hshtab,vbtyp_pnt->NAME,VBL_MODNAM,VBL_PNTDFN,(long)vbtyp_pnt);
2279 vbtyp_pnt = vbtyp_pnt->NEXT;
2280 VBL_NUMTYP++;
2281 }
2282
2283 }
2284 .generic_clause.
2285 .port_clause.
2286 END_ERR
2287 .simple_name.
2288 Semicolon_ERR
2289 {
2290 if (($8 != NULL) && ($8 != $2)) my_vbl_error (1,$8);
2291 }
2292 | _ENTITY
2293 error
2294 { my_vbl_error (2,NULL); }
2295 ;
2296
2297 .constraint.
2298 : /*empty*/
2299 {
2300 $$.FLAG = 'U';
2301 $$.LEFT = -1;
2302 $$.RIGHT = -1;
2303 $$.DYNAMIC = 0;
2304 $$.AGGREG = 0;
2305 }
2306 | constraint
2307 {
2308 $$ = $1;
2309 }
2310 ;
2311
2312 constraint
2313 : range_constraint
2314 {
2315 $$ = $1;
2316 }
2317 |
2318 LeftParen
2319 range
2320 RightParen_ERR
2321 {
2322 $$ = $2;
2323 }
2324 ;
2325
2326 range_constraint
2327 : _RANGE
2328 range
2329 { $$ = $2; }
2330 ;
2331
2332 range
2333 : attribute_name
2334 {
2335 if ( ( $1.FLAG != VBL_RANGE ) &&
2336 ( $1.FLAG != VBL_REV_RANGE ) )
2337 {
2338 my_vbl_error (32,NULL);
2339 }
2340
2341 $$ = $1;
2342 }
2343 | simple_expression
2344 direction
2345 simple_expression
2346 {
2347 long Left;
2348 long Right;
2349 long ErrorL;
2350 long ErrorR;
2351
2352 ErrorL = vbl_vextonum( $1.VEX, &Left );
2353 ErrorR = vbl_vextonum( $3.VEX, &Right );
2354
2355 $$.NAME = NULL;
2356 $$.TYPE = $1.TYPE;
2357 $$.SIGNED = 0;
2358 $$.FLAG = 'A';
2359
2360 if ( ( ! ErrorL ) && ( ! ErrorR ) )
2361 {
2362 if (((Left > Right) && ($2 == VBL_UPTDFN)) ||
2363 ((Left < Right) && ($2 == VBL_DWTDFN)))
2364 {
2365 my_vbl_error (32,NULL);
2366 }
2367
2368 $$.LEFT = Left;
2369 $$.RIGHT = Right;
2370 $$.DYNAMIC = 0;
2371 $$.AGGREG = 0;
2372 }
2373 else
2374 {
2375 $$.LEFT = (long)$1.VEX;
2376 $$.RIGHT = (long)$3.VEX;
2377 $$.DYNAMIC = $2;
2378 $$.AGGREG = 0;
2379 }
2380 }
2381 ;
2382
2383 direction
2384 : TO
2385 { $$ = VBL_UPTDFN; }
2386 | DOWNTO
2387 { $$ = VBL_DWTDFN; }
2388 ;
2389
2390 .generic_clause.
2391 : /*empty*/
2392 | generic_clause
2393 {}
2394 ;
2395
2396 generic_clause
2397 : GENERIC
2398 LeftParen
2399 formal_generic_list
2400 RightParen_ERR
2401 Semicolon_ERR
2402 {}
2403 ;
2404
2405 .port_clause.
2406 : /*empty*/
2407 | port_clause
2408 ;
2409
2410 port_clause
2411 : PORT
2412 LeftParen
2413 formal_port_list
2414 RightParen_ERR
2415 Semicolon_ERR {}
2416 | PORT
2417 error
2418 Semicolon_ERR
2419 { my_vbl_error (3,NULL); }
2420 ;
2421
2422 formal_port_list
2423 : formal_port_element
2424 ...formal_port_element..
2425 {}
2426 ;
2427
2428 ...formal_port_element..
2429 : /*empty*/
2430 | ...formal_port_element..
2431 Semicolon_ERR
2432 formal_port_element
2433 {}
2434 ;
2435
2436 formal_port_element
2437 : .SIGNAL.
2438 identifier_list
2439 Colon
2440 .mode.
2441 type_mark
2442 .constraint.
2443 .signal_kind.
2444 .VarAsgn__expression.
2445 {
2446 char *signame;
2447 vbpor_list *VbPort;
2448 vbtyp_list *VbType;
2449 vexexpr *VexInit;
2450 char buffer[ 40 ];
2451 short Signed;
2452 long Left = 0;
2453 long Right = 0;
2454 long AttrLeft;
2455 long AttrRight;
2456 struct vbl_expr expr1;
2457
2458 /* ###----------------------------------------------### */
2459 /* First, check the validity of the declaration. */
2460 /* Then, for each port, create the apropriate set of */
2461 /* structures (vbrin, vbpor, vbout, vbbus) */
2462 /* ###----------------------------------------------### */
2463
2464 VbType = val_type( $5.NAME );
2465
2466 if ( $6.DYNAMIC ) /* LUDO_DYNAMIC */
2467 {
2468 AttrLeft = $6.LEFT;
2469 AttrRight = $6.RIGHT;
2470 Left = AttrLeft;
2471 Right = AttrRight;
2472 }
2473 else
2474 if ( ( $6.LEFT == -1 ) &&
2475 ( $6.RIGHT == -1 ) )
2476 {
2477 AttrLeft = VbType->LEFT;
2478 AttrRight = VbType->RIGHT;
2479 }
2480 else
2481 {
2482 AttrLeft = $6.LEFT;
2483 AttrRight = $6.RIGHT;
2484 }
2485
2486 VBL_NM1LST = reverse (VBL_NM1LST);
2487
2488 if ( ! $6.DYNAMIC ) /* LUDO_DYNAMIC */
2489 {
2490 if ( $8.VEX == (vexexpr *)0 )
2491 {
2492 if ( VbType->CLASS == 'I' )
2493 {
2494 sprintf( buffer, "%ld", AttrLeft );
2495 expr1.IDENT = buffer;
2496 expr1.TYPE = -1;
2497 expr1.VEX = (vexexpr *)0;
2498 expr1 = vbl_crtvex( NOPS, expr1,VBL_EMPSTR,-1,-1,0);
2499
2500 $8.VEX = expr1.VEX;
2501 }
2502 }
2503 }
2504
2505 while (VBL_NM1LST != NULL)
2506 {
2507 VexInit = $8.VEX;
2508
2509 if ( ( VexInit != (vexexpr *)0 ) &&
2510 ( VBL_NM1LST->NEXT != (chain_list *)0 ) )
2511 {
2512 VexInit = dupvexexpr( $8.VEX );
2513 }
2514
2515 signame = (char *)VBL_NM1LST->DATA;
2516 if (chktab (hshtab,signame,VBL_MODNAM,VBL_SYMDFN) != 0)
2517 my_vbl_error (4,signame);
2518
2519 VbPort = (vbpor_list *)vbl_addstr( 'P',$4, VbType,
2520 $5.TYPE,$5.FLAG,signame,
2521 AttrLeft, AttrRight,VexInit,$7, $6.DYNAMIC);
2522
2523 addtab (hshtab,signame,VBL_MODNAM,VBL_SYMDFN,$4);
2524
2525 Signed = ( IsVexNodeSigned( VbPort->TARGET ) != 0 );
2526
2527 if ( ! $6.DYNAMIC ) /* LUDO_DYNAMIC */
2528 {
2529 if ( IsVexAtomBit( VbPort->TARGET ) )
2530 {
2531 Left = -1;
2532 Right = -1;
2533 }
2534 else
2535 {
2536 Left = VbPort->TARGET->LEFT;
2537 Right = VbPort->TARGET->RIGHT;
2538 }
2539 }
2540
2541 addtab( hshtab,signame,VBL_MODNAM,VBL_TYPDFN,$5.TYPE);
2542 addtab( hshtab,signame,VBL_MODNAM,VBL_WMNDFN,Left );
2543 addtab( hshtab,signame,VBL_MODNAM,VBL_WMXDFN,Right );
2544 addtab( hshtab,signame,VBL_MODNAM,VBL_ATLDFN,AttrLeft );
2545 addtab( hshtab,signame,VBL_MODNAM,VBL_ATRDFN,AttrRight );
2546 addtab( hshtab,signame,VBL_MODNAM,VBL_LBLDFN,$7);
2547 addtab( hshtab,signame,VBL_MODNAM,VBL_PNTDFN,(long)VbPort->TARGET);
2548 addtab( hshtab,signame,VBL_MODNAM,VBL_SUNDFN,Signed);
2549 addtab( hshtab,signame,VBL_MODNAM,VBL_DYNDFN,$6.DYNAMIC);
2550
2551 VBL_NM1LST = delchain (VBL_NM1LST, VBL_NM1LST);
2552 }
2553 }
2554 | error
2555 {
2556 my_vbl_error (6,NULL);
2557 }
2558 ;
2559
2560 /* 1.1.1.1 */
2561 formal_generic_list
2562 : formal_generic_element
2563 ...formal_generic_element..
2564 {}
2565 | error RightParen_ERR
2566 {}
2567 ;
2568
2569
2570 ...formal_generic_element..
2571 : /*empty*/
2572 | ...formal_generic_element..
2573 Semicolon_ERR
2574 formal_generic_element
2575 {
2576 }
2577 ;
2578
2579 formal_generic_element
2580 : .CONSTANT.
2581 identifier_list
2582 Colon
2583 .IN.
2584 type_mark
2585 .constraint.
2586 .VarAsgn__expression.
2587 {
2588 char *signame;
2589 char *Value;
2590 vbgen_list *VbGen;
2591 vbmap_list *VbMap;
2592 vbtyp_list *VbType;
2593 vexexpr *VexInit;
2594 char buffer[ 40 ];
2595 short Signed;
2596 long Left;
2597 long Right;
2598 long AttrLeft;
2599 long AttrRight;
2600 struct vbl_expr expr1;
2601
2602 /* ###----------------------------------------------### */
2603 /* First, check the validity of the declaration. */
2604 /* Then, for each port, create the apropriate set of */
2605 /* structures (vbrin, vbgen, vbout, vbbus) */
2606 /* ###----------------------------------------------### */
2607
2608 if ( $6.DYNAMIC )
2609 {
2610 my_vbl_error (126,NULL);
2611 }
2612
2613 VbType = val_type( $5.NAME );
2614
2615 if ( ( $6.LEFT == -1 ) &&
2616 ( $6.RIGHT == -1 ) )
2617 {
2618 AttrLeft = VbType->LEFT;
2619 AttrRight = VbType->RIGHT;
2620 }
2621 else
2622 {
2623 AttrLeft = $6.LEFT;
2624 AttrRight = $6.RIGHT;
2625 }
2626
2627 VBL_NM1LST = reverse (VBL_NM1LST);
2628
2629 if ( $7.VEX == (vexexpr *)0 )
2630 {
2631 if ( VbType->CLASS == 'I' )
2632 {
2633 sprintf( buffer, "%ld", AttrLeft );
2634 expr1.IDENT = buffer;
2635 expr1.TYPE = -1;
2636 expr1.VEX = (vexexpr *)0;
2637 expr1 = vbl_crtvex( NOPS, expr1,VBL_EMPSTR,-1,-1,0);
2638
2639 $7.VEX = expr1.VEX;
2640 }
2641 }
2642
2643 while (VBL_NM1LST != NULL)
2644 {
2645 VexInit = $7.VEX;
2646
2647 if ( ( VexInit != (vexexpr *)0 ) &&
2648 ( VBL_NM1LST->NEXT != (chain_list *)0 ) )
2649 {
2650 VexInit = dupvexexpr( $7.VEX );
2651 }
2652
2653 signame = (char *)VBL_NM1LST->DATA;
2654 if (chktab (hshtab,signame,VBL_MODNAM,VBL_SYMDFN) != 0)
2655 my_vbl_error (4,signame);
2656
2657 for ( VbMap = VBL_GENMAP;
2658 VbMap != (vbmap_list *)0;
2659 VbMap = VbMap->NEXT )
2660 {
2661 Value = GetVexAtomValue( VbMap->FORMAL );
2662
2663 if ( Value == signame )
2664 {
2665 VexInit = dupvexexpr( VbMap->ACTUAL );
2666
2667 break;
2668 }
2669 }
2670
2671 VbGen = (vbgen_list *)vbl_addstr( 'G',0, VbType,
2672 $5.TYPE,$5.FLAG,signame,
2673 AttrLeft,
2674 AttrRight,VexInit,VBH_KIND_NONE, 0);
2675
2676 addtab (hshtab,signame,VBL_MODNAM,VBL_SYMDFN,VBL_GENDFN);
2677
2678 Signed = ( IsVexNodeSigned( VbGen->TARGET ) != 0 );
2679
2680 if ( IsVexAtomBit( VbGen->TARGET ) )
2681 {
2682 Left = -1;
2683 Right = -1;
2684 }
2685 else
2686 {
2687 Left = VbGen->TARGET->LEFT;
2688 Right = VbGen->TARGET->RIGHT;
2689 }
2690
2691 addtab( hshtab,signame,VBL_MODNAM,VBL_TYPDFN,$5.TYPE);
2692 addtab( hshtab,signame,VBL_MODNAM,VBL_WMNDFN,Left );
2693 addtab( hshtab,signame,VBL_MODNAM,VBL_WMXDFN,Right );
2694 addtab( hshtab,signame,VBL_MODNAM,VBL_ATLDFN,AttrLeft );
2695 addtab( hshtab,signame,VBL_MODNAM,VBL_LBLDFN,VBH_KIND_NONE);
2696 addtab( hshtab,signame,VBL_MODNAM,VBL_ATRDFN,AttrRight );
2697 addtab( hshtab,signame,VBL_MODNAM,VBL_PNTDFN,(long)VbGen->TARGET);
2698 addtab( hshtab,signame,VBL_MODNAM,VBL_SUNDFN,Signed);
2699
2700 VBL_NM1LST = delchain (VBL_NM1LST, VBL_NM1LST);
2701 }
2702 }
2703 ;
2704
2705
2706 .SIGNAL.
2707 : /*empty*/
2708 | SIGNAL
2709 {}
2710 ;
2711
2712 .CONSTANT.
2713 : /*empty*/
2714 | CONSTANT
2715 {}
2716 ;
2717
2718 .IN.
2719 : /*empty*/
2720 | _IN
2721 {}
2722 ;
2723
2724 .mode.
2725 : /*empty*/
2726 { $$ = VBL_ICNDFN; }
2727 | _IN
2728 { $$ = VBL_ICNDFN; }
2729 | _OUT
2730 { $$ = VBL_OCNDFN; }
2731 | _INOUT
2732 { $$ = VBL_BCNDFN; }
2733 ;
2734
2735 architecture_body
2736 : ARCHITECTURE
2737 Identifier
2738 OF
2739 simple_name
2740 IS
2741 {
2742 if ($4 != VBL_MODNAM) my_vbl_error (1,$4);
2743 }
2744 architecture_declarative_part
2745 _BEGIN
2746 architecture_statement_part
2747 END_ERR
2748 .simple_name.
2749 Semicolon_ERR
2750 {
2751 if (($11 != NULL) && ($11 != $2)) my_vbl_error (7,$11);
2752 }
2753 | ARCHITECTURE
2754 error
2755 { my_vbl_error (8,NULL); }
2756 ;
2757
2758 architecture_declarative_part
2759 : ..block_declarative_item..
2760 ;
2761
2762 ..block_declarative_item..
2763 : /*empty*/
2764 | ..block_declarative_item..
2765 block_declarative_item
2766 ;
2767
2768 block_declarative_item
2769 : constant_declaration
2770 | signal_declaration
2771 | type_declaration
2772 | variable_declaration
2773 | subtype_declaration
2774 | attribute_declaration
2775 | attribute_specification
2776 | component_declaration
2777 | subprogram_declaration
2778 | subprogram_body
2779 | error
2780 Semicolon_ERR
2781 { my_vbl_error (9,NULL); }
2782 ;
2783
2784 designator
2785 : Identifier
2786 { $$ = $1; }
2787 ;
2788
2789 .procedure_parameter_list.
2790 : /*empty*/
2791 | LeftParen
2792 procedure_parameter_element
2793 ...procedure_parameter_element..
2794 RightParen_ERR
2795 { }
2796 | LeftParen
2797 error
2798 RightParen_ERR
2799 { }
2800 ;
2801
2802
2803 ...procedure_parameter_element..
2804 : /*empty*/
2805 | ...procedure_parameter_element..
2806 Semicolon_ERR
2807 procedure_parameter_element
2808 ;
2809
2810 procedure_parameter_element
2811 : .procedure_parameter_object_class.
2812 identifier_list
2813 Colon
2814 .procedure_parameter_mode.
2815 type_mark
2816 .constraint.
2817 {
2818 char *signame;
2819 char *codedsigname;
2820 char buffer[ 128 ];
2821 vbtyp_list *TypeEnum;
2822 long EnumSize;
2823 vbarg_list *VbPar;
2824 short Signed;
2825 long Left;
2826 long Right;
2827 long AttrLeft;
2828 long AttrRight;
2829
2830 if ( $6.DYNAMIC )
2831 {
2832 my_vbl_error(86,0);
2833 }
2834
2835 if ( $1 == VBH_CLASS_NONE )
2836 {
2837 if ( $4 == VBL_ICNDFN ) $1 = VBH_CLASS_CONSTANT;
2838 else $1 = VBH_CLASS_VARIABLE;
2839 }
2840
2841 TypeEnum = val_type( $5.NAME );
2842 EnumSize = vbl_codeSize( TypeEnum->SIZE - 1 );
2843
2844 if ( ( $6.LEFT == -1 ) &&
2845 ( $6.RIGHT == -1 ) )
2846 {
2847 AttrLeft = TypeEnum->LEFT;
2848 AttrRight = TypeEnum->RIGHT;
2849 }
2850 else
2851 {
2852 AttrLeft = $6.LEFT;
2853 AttrRight = $6.RIGHT;
2854 }
2855
2856 if (chktab( hshtab,VBL_FUNCNAM,VBL_MODNAM,VBL_SYMDFN ) == 0)
2857 {
2858 VBL_NM1LST = reverse( VBL_NM1LST );
2859 while (VBL_NM1LST != NULL)
2860 {
2861 if ( ( TypeEnum->CLASS == 'E' ) &&
2862 ( TypeEnum->INDEX >= VBH_MAX_TYPE ) )
2863 {
2864 signame = (char *)VBL_NM1LST->DATA;
2865
2866 if (chktab (hshtab,signame,VBL_FUNCNAM,VBL_SYMDFN) != 0)
2867 my_vbl_error (80,signame);
2868
2869 sprintf (buffer, "%s.cod.%s", VBL_FUNCNAM, signame);
2870 codedsigname = namealloc ( buffer );
2871
2872 if (chktab (hshtab,codedsigname,VBL_FUNCNAM,VBL_SYMDFN) != 0)
2873 my_vbl_error (80,codedsigname);
2874 /*\
2875 VbPar = (vbarg_list *)vbl_addstr( 'p',$4,val_type($5.NAME),$5.TYPE,
2876 $5.FLAG,codedsigname, AttrLeft,AttrRight,NULL,$1, 0);
2877
2878 Signed = ( IsVexNodeSigned( VbPar->TARGET ) != 0 );
2879
2880 if ( IsVexAtomBit( VbPar->TARGET ) )
2881 {
2882 Left = -1;
2883 Right = -1;
2884 }
2885 else
2886 {
2887 Left = VbPar->TARGET->LEFT;
2888 Right = VbPar->TARGET->RIGHT;
2889 }
2890 \*/
2891 addtab(hshtab,codedsigname,VBL_FUNCNAM,VBL_SYMDFN,VBL_PARDFN);
2892 addtab(hshtab,codedsigname,VBL_FUNCNAM,VBL_TYPDFN,$5.TYPE);
2893 addtab(hshtab,codedsigname,VBL_FUNCNAM,VBL_WMNDFN,-1);
2894 addtab(hshtab,codedsigname,VBL_FUNCNAM,VBL_WMXDFN,-1);
2895 addtab(hshtab,codedsigname,VBL_FUNCNAM,VBL_LBLDFN,0);
2896 addtab(hshtab,codedsigname,VBL_FUNCNAM,VBL_PNTDFN,0);
2897 addtab(hshtab,codedsigname,VBL_FUNCNAM,VBL_SUNDFN,0 );
2898
2899 if ( EnumSize > 1 )
2900 {
2901 VbPar = (vbarg_list *)vbl_addstr( 'p',$4,
2902 get_type(VBH_TYPE_BIT_VECTOR), VBH_TYPE_BIT_VECTOR,
2903 'U',signame, 0,EnumSize-1,NULL,$1, 0);
2904
2905 Signed = ( IsVexNodeSigned( VbPar->TARGET ) != 0 );
2906
2907 addtab (hshtab,signame,VBL_FUNCNAM,VBL_SYMDFN,VBL_PARDFN);
2908 addtab (hshtab,signame,VBL_FUNCNAM,VBL_TYPDFN,VBH_TYPE_BIT_VECTOR);
2909 addtab (hshtab,signame,VBL_FUNCNAM,VBL_WMNDFN,0);
2910 addtab (hshtab,signame,VBL_FUNCNAM,VBL_WMXDFN,EnumSize-1);
2911 addtab (hshtab,signame,VBL_FUNCNAM,VBL_ATLDFN,0);
2912 addtab (hshtab,signame,VBL_FUNCNAM,VBL_ATRDFN,EnumSize-1);
2913 addtab (hshtab,signame,VBL_FUNCNAM,VBL_LBLDFN,0);
2914 addtab (hshtab,signame,VBL_FUNCNAM,VBL_PNTDFN,(long)VbPar->TARGET);
2915 addtab (hshtab,signame,VBL_FUNCNAM,VBL_SUNDFN,Signed);
2916 }
2917 else
2918 {
2919 VbPar = (vbarg_list *)vbl_addstr( 'p',$4,
2920 get_type(VBH_TYPE_BIT),VBH_TYPE_BIT,
2921 'S',signame, -1,-1 ,NULL,$1, 0);
2922
2923 Signed = ( IsVexNodeSigned( VbPar->TARGET ) != 0 );
2924
2925 addtab (hshtab,signame,VBL_FUNCNAM,VBL_SYMDFN,VBL_PARDFN);
2926 addtab (hshtab,signame,VBL_FUNCNAM,VBL_TYPDFN,VBH_TYPE_BIT);
2927 addtab (hshtab,signame,VBL_FUNCNAM,VBL_WMNDFN,-1);
2928 addtab (hshtab,signame,VBL_FUNCNAM,VBL_WMXDFN,-1);
2929 addtab (hshtab,signame,VBL_FUNCNAM,VBL_ATLDFN,0);
2930 addtab (hshtab,signame,VBL_FUNCNAM,VBL_ATRDFN,1);
2931 addtab (hshtab,signame,VBL_FUNCNAM,VBL_LBLDFN,0);
2932 addtab (hshtab,signame,VBL_FUNCNAM,VBL_PNTDFN,(long)VbPar->TARGET);
2933 addtab (hshtab,signame,VBL_FUNCNAM,VBL_SUNDFN,Signed);
2934 }
2935 }
2936 else
2937 {
2938 signame = (char *)VBL_NM1LST->DATA;
2939
2940 if (chktab (hshtab,signame,VBL_FUNCNAM,VBL_SYMDFN) != 0)
2941 my_vbl_error (80,signame);
2942
2943 VbPar = (vbarg_list *)vbl_addstr( 'p',$4,
2944 val_type($5.NAME),$5.TYPE, $5.FLAG,signame,
2945 AttrLeft,AttrRight,NULL,$1, 0);
2946
2947 Signed = ( IsVexNodeSigned( VbPar->TARGET ) != 0 );
2948
2949 if ( IsVexAtomVarWidth( VbPar->TARGET ) )
2950 {
2951 Left = -2;
2952 Right = -2;
2953 }
2954 else
2955 if ( IsVexAtomBit( VbPar->TARGET ) )
2956 {
2957 Left = -1;
2958 Right = -1;
2959 }
2960 else
2961 {
2962 Left = VbPar->TARGET->LEFT;
2963 Right = VbPar->TARGET->RIGHT;
2964 }
2965
2966 addtab (hshtab,signame,VBL_FUNCNAM,VBL_SYMDFN,VBL_PARDFN);
2967 addtab (hshtab,signame,VBL_FUNCNAM,VBL_TYPDFN,$5.TYPE);
2968 addtab (hshtab,signame,VBL_FUNCNAM,VBL_WMNDFN,Left);
2969 addtab (hshtab,signame,VBL_FUNCNAM,VBL_WMXDFN,Right);
2970 addtab (hshtab,signame,VBL_FUNCNAM,VBL_ATLDFN,AttrLeft);
2971 addtab (hshtab,signame,VBL_FUNCNAM,VBL_ATRDFN,AttrRight);
2972 addtab (hshtab,signame,VBL_FUNCNAM,VBL_LBLDFN,0);
2973 addtab (hshtab,signame,VBL_FUNCNAM,VBL_PNTDFN,(long)VbPar->TARGET);
2974 addtab (hshtab,signame,VBL_FUNCNAM,VBL_SUNDFN,Signed);
2975 }
2976
2977 VBL_NM1LST = delchain (VBL_NM1LST,VBL_NM1LST);
2978 }
2979 }
2980 else
2981 {
2982 freechain( VBL_NM1LST );
2983 VBL_NM1LST = (chain_list *)0;
2984 }
2985 }
2986 ;
2987
2988 .procedure_parameter_object_class.
2989 : /*empty*/
2990 { $$ = VBH_CLASS_NONE; }
2991 | _VARIABLE
2992 { $$ = VBH_CLASS_VARIABLE; }
2993 | CONSTANT
2994 { $$ = VBH_CLASS_CONSTANT; }
2995 | SIGNAL
2996 { $$ = VBH_CLASS_SIGNAL; }
2997 ;
2998
2999 .procedure_parameter_mode.
3000 : /*empty*/
3001 { $$ = VBL_ICNDFN; }
3002 | _IN
3003 { $$ = VBL_ICNDFN; }
3004 | _OUT
3005 { $$ = VBL_OCNDFN; }
3006 | _INOUT
3007 { $$ = VBL_BCNDFN; }
3008 ;
3009
3010 .function_parameter_list.
3011 : /*empty*/
3012 | LeftParen
3013 function_parameter_element
3014 ...function_parameter_element..
3015 RightParen_ERR
3016 { }
3017 | LeftParen
3018 error
3019 RightParen_ERR
3020 { }
3021 ;
3022
3023
3024 ...function_parameter_element..
3025 : /*empty*/
3026 | ...function_parameter_element..
3027 Semicolon_ERR
3028 function_parameter_element
3029 ;
3030
3031 function_parameter_element
3032 : .function_parameter_object_class.
3033 identifier_list
3034 Colon
3035 .function_parameter_mode.
3036 type_mark
3037 .constraint.
3038 {
3039 char *signame;
3040 char *codedsigname;
3041 char buffer[ 128 ];
3042 vbtyp_list *TypeEnum;
3043 long EnumSize;
3044 vbarg_list *VbPar;
3045 short Signed;
3046 long Left;
3047 long Right;
3048 long AttrLeft;
3049 long AttrRight;
3050
3051 if ( $6.DYNAMIC )
3052 {
3053 my_vbl_error(86,0);
3054 }
3055
3056 if ( $1 == VBH_CLASS_NONE ) $1 = VBH_CLASS_CONSTANT;
3057
3058 TypeEnum = val_type( $5.NAME );
3059 EnumSize = vbl_codeSize( TypeEnum->SIZE - 1 );
3060
3061 if ( ( $6.LEFT == -1 ) &&
3062 ( $6.RIGHT == -1 ) )
3063 {
3064 AttrLeft = TypeEnum->LEFT;
3065 AttrRight = TypeEnum->RIGHT;
3066 }
3067 else
3068 {
3069 AttrLeft = $6.LEFT;
3070 AttrRight = $6.RIGHT;
3071 }
3072
3073 if (chktab( hshtab,VBL_FUNCNAM,VBL_MODNAM,VBL_SYMDFN ) == 0)
3074 {
3075 VBL_NM1LST = reverse( VBL_NM1LST );
3076 while (VBL_NM1LST != NULL)
3077 {
3078 if ( ( TypeEnum->CLASS == 'E' ) &&
3079 ( TypeEnum->INDEX >= VBH_MAX_TYPE ) )
3080 {
3081 signame = (char *)VBL_NM1LST->DATA;
3082
3083 if (chktab (hshtab,signame,VBL_FUNCNAM,VBL_SYMDFN) != 0)
3084 my_vbl_error (80,signame);
3085
3086 sprintf (buffer, "%s.cod.%s", VBL_FUNCNAM, signame);
3087 codedsigname = namealloc ( buffer );
3088
3089 if (chktab (hshtab,codedsigname,VBL_FUNCNAM,VBL_SYMDFN) != 0)
3090 my_vbl_error (80,codedsigname);
3091 /*\
3092 VbPar = (vbarg_list *)vbl_addstr('p',$4,
3093 val_type($5.NAME),$5.TYPE,
3094 $5.FLAG,codedsigname, AttrLeft,AttrRight, NULL,$1, 0);
3095
3096 Signed = ( IsVexNodeSigned( VbPar->TARGET ) != 0 );
3097
3098 if ( IsVexAtomBit( VbPar->TARGET ) )
3099 {
3100 Left = -1;
3101 Right = -1;
3102 }
3103 else
3104 {
3105 Left = VbPar->TARGET->LEFT;
3106 Right = VbPar->TARGET->RIGHT;
3107 }
3108 \*/
3109 addtab(hshtab,codedsigname,VBL_FUNCNAM,VBL_SYMDFN,VBL_PARDFN);
3110 addtab(hshtab,codedsigname,VBL_FUNCNAM,VBL_TYPDFN,$5.TYPE);
3111 addtab(hshtab,codedsigname,VBL_FUNCNAM,VBL_WMNDFN,-1);
3112 addtab(hshtab,codedsigname,VBL_FUNCNAM,VBL_WMXDFN,-1);
3113 addtab(hshtab,codedsigname,VBL_FUNCNAM,VBL_LBLDFN,0);
3114 addtab(hshtab,codedsigname,VBL_FUNCNAM,VBL_PNTDFN,0);
3115 addtab(hshtab,codedsigname,VBL_FUNCNAM,VBL_SUNDFN,0);
3116
3117 if ( EnumSize > 1 )
3118 {
3119 VbPar = (vbarg_list *)vbl_addstr( 'p',$4,
3120 get_type(VBH_TYPE_BIT_VECTOR), VBH_TYPE_BIT_VECTOR,
3121 'U',signame, 0,EnumSize-1,NULL,$1, 0);
3122
3123 Signed = ( IsVexNodeSigned( VbPar->TARGET ) != 0 );
3124
3125 addtab (hshtab,signame,VBL_FUNCNAM,VBL_SYMDFN,VBL_PARDFN);
3126 addtab (hshtab,signame,VBL_FUNCNAM,VBL_TYPDFN,VBH_TYPE_BIT_VECTOR);
3127 addtab (hshtab,signame,VBL_FUNCNAM,VBL_WMNDFN,0);
3128 addtab (hshtab,signame,VBL_FUNCNAM,VBL_WMXDFN,EnumSize-1);
3129 addtab (hshtab,signame,VBL_FUNCNAM,VBL_ATLDFN,0);
3130 addtab (hshtab,signame,VBL_FUNCNAM,VBL_ATRDFN,EnumSize-1);
3131 addtab (hshtab,signame,VBL_FUNCNAM,VBL_LBLDFN,0);
3132 addtab (hshtab,signame,VBL_FUNCNAM,VBL_PNTDFN,(long)VbPar->TARGET);
3133 addtab (hshtab,signame,VBL_FUNCNAM,VBL_SUNDFN,Signed);
3134 }
3135 else
3136 {
3137 VbPar = (vbarg_list *)vbl_addstr( 'p',$4,
3138 get_type(VBH_TYPE_BIT),VBH_TYPE_BIT,
3139 'S',signame, -1,-1 ,NULL,$1, 0);
3140
3141 Signed = ( IsVexNodeSigned( VbPar->TARGET ) != 0 );
3142
3143 addtab (hshtab,signame,VBL_FUNCNAM,VBL_SYMDFN,VBL_PARDFN);
3144 addtab (hshtab,signame,VBL_FUNCNAM,VBL_TYPDFN,VBH_TYPE_BIT);
3145 addtab (hshtab,signame,VBL_FUNCNAM,VBL_WMNDFN,-1);
3146 addtab (hshtab,signame,VBL_FUNCNAM,VBL_WMXDFN,-1);
3147 addtab (hshtab,signame,VBL_FUNCNAM,VBL_ATLDFN,0);
3148 addtab (hshtab,signame,VBL_FUNCNAM,VBL_ATRDFN,1);
3149 addtab (hshtab,signame,VBL_FUNCNAM,VBL_LBLDFN,0);
3150 addtab (hshtab,signame,VBL_FUNCNAM,VBL_PNTDFN,(long)VbPar->TARGET);
3151 addtab (hshtab,signame,VBL_FUNCNAM,VBL_SUNDFN,Signed);
3152 }
3153 }
3154 else
3155 {
3156 signame = (char *)VBL_NM1LST->DATA;
3157 if (chktab (hshtab,signame,VBL_FUNCNAM,VBL_SYMDFN) != 0)
3158 my_vbl_error (80,signame);
3159
3160 VbPar = (vbarg_list *)vbl_addstr ('p',$4,
3161 val_type($5.NAME),$5.TYPE, $5.FLAG,
3162 signame, AttrLeft,AttrRight,NULL,$1, 0);
3163
3164 Signed = ( IsVexNodeSigned( VbPar->TARGET ) != 0 );
3165
3166 if ( IsVexAtomBit( VbPar->TARGET ) )
3167 {
3168 Left = -1;
3169 Right = -1;
3170 }
3171 else
3172 {
3173 Left = VbPar->TARGET->LEFT;
3174 Right = VbPar->TARGET->RIGHT;
3175 }
3176
3177 addtab (hshtab,signame,VBL_FUNCNAM,VBL_SYMDFN,VBL_PARDFN);
3178 addtab (hshtab,signame,VBL_FUNCNAM,VBL_TYPDFN,$5.TYPE);
3179 addtab (hshtab,signame,VBL_FUNCNAM,VBL_WMNDFN,Left);
3180 addtab (hshtab,signame,VBL_FUNCNAM,VBL_WMXDFN,Right);
3181 addtab (hshtab,signame,VBL_FUNCNAM,VBL_ATLDFN,AttrLeft);
3182 addtab (hshtab,signame,VBL_FUNCNAM,VBL_ATRDFN,AttrRight);
3183 addtab (hshtab,signame,VBL_FUNCNAM,VBL_LBLDFN,0);
3184 addtab (hshtab,signame,VBL_FUNCNAM,VBL_PNTDFN,(long)VbPar->TARGET);
3185 addtab (hshtab,signame,VBL_FUNCNAM,VBL_SUNDFN,Signed);
3186 }
3187
3188 VBL_NM1LST = delchain (VBL_NM1LST,VBL_NM1LST);
3189 }
3190 }
3191 else
3192 {
3193 freechain( VBL_NM1LST );
3194 VBL_NM1LST = (chain_list *)0;
3195 }
3196 }
3197 ;
3198
3199 .function_parameter_object_class.
3200 : /*empty*/
3201 { $$ = VBH_CLASS_NONE; }
3202 | CONSTANT
3203 { $$ = VBH_CLASS_CONSTANT; }
3204 | SIGNAL
3205 { $$ = VBH_CLASS_SIGNAL; }
3206 ;
3207
3208 .function_parameter_mode.
3209 : /*empty*/
3210 { $$ = VBL_ICNDFN; }
3211 | _IN
3212 { $$ = VBL_ICNDFN; }
3213 ;
3214
3215 subprogram_declarative_part
3216 : /*empty*/
3217 |
3218 subprogram_declarative_part
3219 subprogram_declarative_item
3220 ;
3221
3222 subprogram_declarative_item
3223 : constant_declaration
3224 | variable_declaration
3225 | type_declaration
3226 | subtype_declaration
3227 | attribute_declaration
3228 | attribute_specification
3229 ;
3230
3231 subprogram_declaration
3232 : subprogram_specification
3233 {
3234 VBL_FUNCNAM = (char *)0;
3235 }
3236 Semicolon_ERR
3237 ;
3238
3239 subprogram_specification
3240 : PROCEDURE
3241 designator
3242 {
3243 long Mode;
3244
3245 VBL_FUNCNAM = $2;
3246
3247 Mode = chktab(hshtab,VBL_FUNCNAM,VBL_MODNAM,VBL_SYMDFN);
3248
3249 if ( Mode == 0 )
3250 {
3251 VBL_BEFPNT->BEFUN = vbh_addvbfun( VBL_BEFPNT->BEFUN,
3252 VBL_FUNCNAM, NULL, NULL, NULL, VBL_LINNUM );
3253 VBL_BEFUN = VBL_BEFPNT->BEFUN;
3254 }
3255 else
3256 if ( Mode != VBL_PRODFN )
3257 {
3258 my_vbl_error (117,VBL_FUNCNAM);
3259 }
3260 else
3261 {
3262 VBL_BEFUN = (vbfun_list *)chktab( hshtab, VBL_FUNCNAM, VBL_MODNAM, VBL_PNTDFN );
3263 }
3264 }
3265 .procedure_parameter_list.
3266 {
3267 if ( chktab(hshtab,VBL_FUNCNAM,VBL_MODNAM,VBL_SYMDFN) == 0 )
3268 {
3269 VBL_BEFUN->ARGUMENT =
3270 (vbarg_list *)reverse( (chain_list *)VBL_BEFUN->ARGUMENT );
3271
3272 addtab (hshtab,VBL_FUNCNAM,VBL_MODNAM,VBL_SYMDFN,VBL_PRODFN);
3273 addtab (hshtab,VBL_FUNCNAM,VBL_MODNAM,VBL_PNTDFN,(long)VBL_BEFUN);
3274 }
3275 }
3276 | FUNCTION
3277 designator
3278 {
3279 long Mode;
3280
3281 VBL_FUNCNAM = $2;
3282
3283 Mode = chktab(hshtab,VBL_FUNCNAM,VBL_MODNAM,VBL_SYMDFN);
3284
3285 if ( Mode == 0 )
3286 {
3287 VBL_BEFPNT->BEFUN = vbh_addvbfun( VBL_BEFPNT->BEFUN,
3288 VBL_FUNCNAM, NULL, NULL, NULL, VBL_LINNUM );
3289 VBL_BEFUN = VBL_BEFPNT->BEFUN;
3290 }
3291 else
3292 if ( Mode != VBL_FUNDFN )
3293 {
3294 my_vbl_error (116,VBL_FUNCNAM);
3295 }
3296 else
3297 {
3298 VBL_BEFUN = (vbfun_list *)chktab(hshtab,VBL_FUNCNAM,VBL_MODNAM,VBL_PNTDFN);
3299 }
3300 }
3301 .function_parameter_list.
3302 _RETURN
3303 type_mark
3304 {
3305 char *signame;
3306 char buffer[ 128 ];
3307 char *codedsigname;
3308 vbtyp_list *TypeEnum;
3309 short Signed;
3310 long Left;
3311 long Right;
3312 long AttrLeft;
3313 long AttrRight;
3314 long EnumSize;
3315 vbtyp_list *VbType;
3316 vexexpr *VexRet;
3317
3318 if ( $6.DYNAMIC )
3319 {
3320 my_vbl_error(115,0);
3321 }
3322
3323 signame = VBL_FUNCNAM;
3324
3325 TypeEnum = val_type( $6.NAME );
3326 EnumSize = vbl_codeSize( TypeEnum->SIZE - 1 );
3327
3328 AttrLeft = TypeEnum->LEFT;
3329 AttrRight = TypeEnum->RIGHT;
3330
3331 if ( chktab(hshtab,VBL_FUNCNAM,VBL_MODNAM,VBL_SYMDFN) == 0 )
3332 {
3333 if ( ( TypeEnum->CLASS == 'E' ) &&
3334 ( TypeEnum->INDEX >= VBH_MAX_TYPE ) )
3335 {
3336 sprintf (buffer, "%s.cod.%s", VBL_MODNAM, signame);
3337 codedsigname = namealloc ( buffer );
3338
3339 if (chktab (hshtab,codedsigname,VBL_MODNAM,VBL_SYMDFN) != 0)
3340 my_vbl_error (116,codedsigname);
3341 /*\
3342 VexRet = (vexexpr *)vbl_addstr( 'F',0,val_type($6.NAME),$6.TYPE,
3343 $6.FLAG,codedsigname,AttrLeft,AttrRight,NULL,0, 0);
3344
3345 Signed = ( IsVexNodeSigned( VexRet ) != 0 );
3346
3347 if ( IsVexAtomBit( VexRet ) )
3348 {
3349 Left = -1;
3350 Right = -1;
3351 }
3352 else
3353 {
3354 Left = VexRet->LEFT;
3355 Right = VexRet->RIGHT;
3356 }
3357 \*/
3358 addtab (hshtab,codedsigname,VBL_MODNAM,VBL_SYMDFN,VBL_FUNDFN);
3359 addtab (hshtab,codedsigname,VBL_MODNAM,VBL_TYPDFN,$6.TYPE);
3360 addtab (hshtab,codedsigname,VBL_MODNAM,VBL_WMNDFN,-1);
3361 addtab (hshtab,codedsigname,VBL_MODNAM,VBL_WMXDFN,-1);
3362 addtab (hshtab,codedsigname,VBL_MODNAM,VBL_SUNDFN,0);
3363
3364 if ( EnumSize > 1 )
3365 {
3366 VbType = get_type( VBH_TYPE_BIT_VECTOR );
3367 VexRet = (vexexpr *)vbl_addstr('F',0,
3368 VbType,VBH_TYPE_BIT_VECTOR,'U',signame, 0,EnumSize-1,NULL,0, 0);
3369
3370 Signed = ( IsVexNodeSigned( VexRet ) != 0 );
3371
3372 addtab (hshtab,signame,VBL_MODNAM,VBL_SYMDFN,VBL_FUNDFN);
3373 addtab (hshtab,signame,VBL_MODNAM,VBL_TYPDFN,VBH_TYPE_BIT_VECTOR);
3374 addtab (hshtab,signame,VBL_MODNAM,VBL_WMNDFN,0);
3375 addtab (hshtab,signame,VBL_MODNAM,VBL_WMXDFN,EnumSize-1);
3376 addtab (hshtab,signame,VBL_MODNAM,VBL_ATLDFN,0);
3377 addtab (hshtab,signame,VBL_MODNAM,VBL_ATRDFN,TypeEnum->SIZE-1);
3378 addtab (hshtab,signame,VBL_MODNAM,VBL_SUNDFN,Signed);
3379 }
3380 else
3381 {
3382 VbType = get_type(VBH_TYPE_BIT);
3383 VexRet = (vexexpr *)vbl_addstr ('F',0,
3384 VbType,VBH_TYPE_BIT,'S',signame, -1,-1 ,NULL,0, 0);
3385
3386 Signed = ( IsVexNodeSigned( VexRet ) != 0 );
3387
3388 addtab (hshtab,signame,VBL_MODNAM,VBL_SYMDFN,VBL_FUNDFN);
3389 addtab (hshtab,signame,VBL_MODNAM,VBL_TYPDFN,VBH_TYPE_BIT);
3390 addtab (hshtab,signame,VBL_MODNAM,VBL_WMNDFN,-1);
3391 addtab (hshtab,signame,VBL_MODNAM,VBL_WMXDFN,-1);
3392 addtab (hshtab,signame,VBL_MODNAM,VBL_ATLDFN,0);
3393 addtab (hshtab,signame,VBL_MODNAM,VBL_ATRDFN,TypeEnum->SIZE-1);
3394 addtab (hshtab,signame,VBL_MODNAM,VBL_SUNDFN,Signed);
3395 }
3396 }
3397 else
3398 {
3399 VbType = val_type($6.NAME);
3400 VexRet = (vexexpr *)vbl_addstr( 'F',0,VbType,$6.TYPE,
3401 $6.FLAG,signame,-1,-1,NULL,0, 0);
3402
3403 Signed = ( IsVexNodeSigned( VexRet ) != 0 );
3404
3405 if ( IsVexAtomBit( VexRet ) )
3406 {
3407 Left = -1;
3408 Right = -1;
3409 }
3410 else
3411 {
3412 Left = VexRet->LEFT;
3413 Right = VexRet->RIGHT;
3414 }
3415
3416 addtab (hshtab,signame,VBL_MODNAM,VBL_SYMDFN,VBL_FUNDFN);
3417 addtab (hshtab,signame,VBL_MODNAM,VBL_TYPDFN,$6.TYPE);
3418 addtab (hshtab,signame,VBL_MODNAM,VBL_WMNDFN,Left);
3419 addtab (hshtab,signame,VBL_MODNAM,VBL_WMXDFN,Right);
3420 addtab (hshtab,signame,VBL_MODNAM,VBL_ATLDFN,AttrLeft);
3421 addtab (hshtab,signame,VBL_MODNAM,VBL_ATRDFN,AttrRight);
3422 addtab (hshtab,signame,VBL_MODNAM,VBL_SUNDFN,Signed);
3423 }
3424
3425 VBL_BEFUN->RETURN = vbh_addvbarg( (vbarg_list *)0, VexRet, 'O',
3426 VBH_CLASS_NONE, VbType, VBL_LINNUM );
3427 VBL_BEFUN->ARGUMENT =
3428 (vbarg_list *)reverse( (chain_list *)VBL_BEFUN->ARGUMENT );
3429
3430 addtab (hshtab,VBL_FUNCNAM,VBL_MODNAM,VBL_SYMDFN,VBL_FUNDFN);
3431 addtab (hshtab,VBL_FUNCNAM,VBL_MODNAM,VBL_PNTDFN,(long)VBL_BEFUN);
3432 }
3433 }
3434 ;
3435
3436 subprogram_body
3437 : subprogram_specification
3438 IS
3439 subprogram_declarative_part
3440 _BEGIN
3441 {
3442 void *pnt;
3443 pnt = &(VBL_BEFUN->INSTRUCTION);
3444 VBL_INSLST = addchain(NULL,pnt);
3445 }
3446 sequence_of_statements
3447 {
3448 struct ptype **pnt;
3449 struct ptype *ptype;
3450 pnt = (struct ptype**)VBL_INSLST->DATA;
3451 ptype = reversetype(*pnt);
3452 *pnt = ptype;
3453 VBL_INSLST = delchain (VBL_INSLST, VBL_INSLST);
3454 }
3455 END_ERR
3456 .designator.
3457 {
3458 VBL_FUNCNAM = (char *)0;
3459 }
3460 Semicolon_ERR
3461 ;
3462
3463 .designator.
3464 : /*empty*/
3465 | designator
3466 { }
3467 ;
3468
3469 constant_declaration
3470 : CONSTANT
3471 Identifier
3472 Colon
3473 type_mark
3474 .constraint.
3475 constant_VarAsgn__expression
3476 Semicolon_ERR
3477 {
3478 vbtyp_list *Type;
3479 vbcst_list *VbCst;
3480 vexexpr *VexValue;
3481 chain_list *HeadChain;
3482 chain_list *ScanChain;
3483 vbl_vexstr *VexStr;
3484 short Signed;
3485 long Left = 0;
3486 long Right = 0;
3487 short Width;
3488 long AttrLeft;
3489 long AttrRight;
3490
3491 if ( $6.AGGREG )
3492 {
3493 HeadChain = reverse( (chain_list *)$6.IDENT );
3494 ScanChain = HeadChain;
3495
3496 if ( HeadChain->NEXT != (chain_list *)0 )
3497 {
3498 Width = 0;
3499 VexValue = createvexoper( VEX_ARRAY, 1 );
3500
3501 while ( ScanChain != (chain_list *)0 )
3502 {
3503 VexStr = (vbl_vexstr *)ScanChain->DATA;
3504 Width += VexStr->VEX->WIDTH;
3505 addvexhexpr( VexValue, VexStr->VEX );
3506
3507 autfreeheap( VexStr, sizeof( vbl_vexstr ) );
3508
3509 ScanChain = ScanChain->NEXT;
3510 }
3511
3512 VexValue->WIDTH = Width;
3513 }
3514 else
3515 {
3516 VexStr = (vbl_vexstr *)HeadChain->DATA;
3517 VexValue = VexStr->VEX;
3518
3519 autfreeheap( VexStr, sizeof( vbl_vexstr ) );
3520 }
3521
3522 freechain( HeadChain );
3523 }
3524 else
3525 {
3526 VexValue = simpvexexpr( $6.VEX );
3527 }
3528
3529 Type = val_type( $4.NAME );
3530
3531
3532 if ( $5.DYNAMIC )
3533 {
3534 AttrLeft = $5.LEFT;
3535 AttrRight = $5.RIGHT;
3536 Left = AttrLeft;
3537 Right = AttrRight;
3538 }
3539 else
3540 if ( ( $5.LEFT == -1 ) &&
3541 ( $5.RIGHT == -1 ) )
3542 {
3543 AttrLeft = Type->LEFT;
3544 AttrRight = Type->RIGHT;
3545 }
3546 else
3547 {
3548 AttrLeft = $5.LEFT;
3549 AttrRight = $5.RIGHT;
3550 }
3551
3552 VbCst = (vbcst_list *)vbl_addstr( 'C',0,val_type($4.NAME),
3553 $4.TYPE,$4.FLAG,$2,AttrLeft,AttrRight,VexValue,0, $5.DYNAMIC);
3554
3555 Signed = ( IsVexNodeSigned( VbCst->TARGET ) != 0 );
3556
3557 if ( ! $5.DYNAMIC )
3558 {
3559 if ( IsVexAtomBit( VbCst->TARGET ) )
3560 {
3561 Left = -1;
3562 Right = -1;
3563 }
3564 else
3565 {
3566 Left = VbCst->TARGET->LEFT;
3567 Right = VbCst->TARGET->RIGHT;
3568 }
3569 }
3570
3571 addtab(hshtab,$2,VBL_MODNAM,VBL_SYMDFN,VBL_CSTDFN);
3572 addtab(hshtab,$2,VBL_MODNAM,VBL_TYPDFN,$4.TYPE);
3573 addtab(hshtab,$2,VBL_MODNAM,VBL_WMNDFN,Left);
3574 addtab(hshtab,$2,VBL_MODNAM,VBL_WMXDFN,Right);
3575 addtab(hshtab,$2,VBL_MODNAM,VBL_ATLDFN,AttrLeft);
3576 addtab(hshtab,$2,VBL_MODNAM,VBL_ATRDFN,AttrRight);
3577 addtab(hshtab,$2,VBL_MODNAM,VBL_LBLDFN,0);
3578 addtab(hshtab,$2,VBL_MODNAM,VBL_PNTDFN,(long)VbCst->VEX);
3579 addtab(hshtab,$2,VBL_MODNAM,VBL_SUNDFN,Signed );
3580 addtab(hshtab,$2,VBL_MODNAM,VBL_DYNDFN,$5.DYNAMIC );
3581 }
3582 ;
3583
3584 constant_VarAsgn__expression
3585 : VarAsgn
3586 expression
3587 { $$ = $2; }
3588 ;
3589
3590 .VarAsgn__expression.
3591 : /*empty*/
3592 { $$.VEX = NULL ;}
3593 | VarAsgn
3594 expression
3595 { $$ = $2 ;}
3596 ;
3597
3598 variable_declaration
3599 : _VARIABLE
3600 identifier_list
3601 Colon
3602 type_mark
3603 .constraint.
3604 .VarAsgn__expression.
3605 Semicolon_ERR
3606 {
3607 char *LocalName;
3608 char *signame;
3609 char *codedsigname;
3610 char buffer[ 128 ];
3611 vbtyp_list *TypeEnum;
3612 long EnumSize;
3613 vbvar_list *VbVar;
3614 short Signed;
3615 long Left = 0;
3616 long Right = 0;
3617 long AttrLeft;
3618 long AttrRight;
3619 char StrFlag;
3620 vexexpr *VexInit;
3621 struct vbl_expr expr1;
3622
3623 if ( VBL_FUNCNAM != (char *)0 )
3624 {
3625 LocalName = VBL_FUNCNAM;
3626 StrFlag = 'v';
3627 }
3628 else
3629 {
3630 LocalName = VBL_PROCNAM;
3631 StrFlag = 'V';
3632 }
3633
3634 TypeEnum = val_type( $4.NAME );
3635 EnumSize = vbl_codeSize( TypeEnum->SIZE - 1 );
3636
3637 if ( $5.DYNAMIC ) /* LUDO_DYNAMIC */
3638 {
3639 AttrLeft = $5.LEFT;
3640 AttrRight = $5.RIGHT;
3641 Left = AttrLeft;
3642 Right = AttrRight;
3643 }
3644 else
3645 if ( ( $5.LEFT == -1 ) &&
3646 ( $5.RIGHT == -1 ) )
3647 {
3648 AttrLeft = TypeEnum->LEFT;
3649 AttrRight = TypeEnum->RIGHT;
3650 }
3651 else
3652 {
3653 AttrLeft = $5.LEFT;
3654 AttrRight = $5.RIGHT;
3655 }
3656
3657 VBL_NM1LST = reverse (VBL_NM1LST);
3658
3659 if ( ! $5.DYNAMIC ) /* LUDO_DYNAMIC */
3660 {
3661 if ( $6.VEX == (vexexpr *)0 )
3662 {
3663 if ( TypeEnum->CLASS == 'I' )
3664 {
3665 sprintf( buffer, "%ld", AttrLeft );
3666 expr1.IDENT = buffer;
3667 expr1.TYPE = -1;
3668 expr1.VEX = (vexexpr *)0;
3669 expr1 = vbl_crtvex( NOPS, expr1,VBL_EMPSTR,-1,-1,0);
3670
3671 $6.VEX = expr1.VEX;
3672 }
3673 }
3674 }
3675
3676 while (VBL_NM1LST != NULL)
3677 {
3678 VexInit = $6.VEX;
3679
3680 if ( ( VexInit != (vexexpr *)0 ) &&
3681 ( VBL_NM1LST->NEXT != (chain_list *)0 ) )
3682 {
3683 VexInit = dupvexexpr( $6.VEX );
3684 }
3685
3686 if ( ( TypeEnum->CLASS == 'E' ) &&
3687 ( TypeEnum->INDEX >= VBH_MAX_TYPE ) )
3688 {
3689 signame = (char *)VBL_NM1LST->DATA;
3690
3691 if (chktab (hshtab,signame,LocalName,VBL_SYMDFN) != 0)
3692 my_vbl_error (80,signame);
3693
3694 sprintf (buffer, "%s.cod.%s", LocalName, signame);
3695 codedsigname = namealloc ( buffer );
3696
3697 if (chktab (hshtab,codedsigname,LocalName,VBL_SYMDFN) != 0)
3698 my_vbl_error (80,codedsigname);
3699 /*\
3700 VbVar = (vbvar_list *)vbl_addstr(StrFlag,0,val_type($4.NAME),$4.TYPE,
3701 $4.FLAG,codedsigname, AttrLeft,AttrRight, VexInit, 0 , 0);
3702
3703 Signed = ( IsVexNodeSigned( VbVar->TARGET ) != 0 );
3704
3705 if ( IsVexAtomBit( VbVar->TARGET ) )
3706 {
3707 Left = -1;
3708 Right = -1;
3709 }
3710 else
3711 {
3712 Left = VbVar->TARGET->LEFT;
3713 Right = VbVar->TARGET->RIGHT;
3714 }
3715 \*/
3716 addtab(hshtab,codedsigname,LocalName,VBL_SYMDFN,VBL_VARDFN);
3717 addtab(hshtab,codedsigname,LocalName,VBL_TYPDFN,$4.TYPE);
3718 addtab(hshtab,codedsigname,LocalName,VBL_WMNDFN,-1);
3719 addtab(hshtab,codedsigname,LocalName,VBL_WMXDFN,-1);
3720 addtab(hshtab,codedsigname,LocalName,VBL_LBLDFN,0);
3721 addtab(hshtab,codedsigname,LocalName,VBL_PNTDFN,0);
3722 addtab(hshtab,codedsigname,LocalName,VBL_SUNDFN,0);
3723 addtab(hshtab,codedsigname,LocalName,VBL_DYNDFN,0);
3724
3725 if ( VexInit != (vexexpr *)0 ) VexInit = dupvexexpr( VexInit );
3726
3727 if ( EnumSize > 1 )
3728 {
3729 VbVar = (vbvar_list *)vbl_addstr( StrFlag,0,
3730 get_type(VBH_TYPE_BIT_VECTOR),VBH_TYPE_BIT_VECTOR,
3731 'U',signame, 0,EnumSize-1 , VexInit, 0, 0 );
3732
3733 Signed = ( IsVexNodeSigned( VbVar->TARGET ) != 0 );
3734
3735 addtab (hshtab,signame,LocalName,VBL_SYMDFN,VBL_VARDFN);
3736 addtab (hshtab,signame,LocalName,VBL_TYPDFN,VBH_TYPE_BIT_VECTOR);
3737 addtab (hshtab,signame,LocalName,VBL_WMNDFN,0);
3738 addtab (hshtab,signame,LocalName,VBL_WMXDFN,EnumSize-1);
3739 addtab (hshtab,signame,LocalName,VBL_ATLDFN,0);
3740 addtab (hshtab,signame,LocalName,VBL_ATRDFN,EnumSize-1);
3741 addtab (hshtab,signame,LocalName,VBL_LBLDFN,0);
3742 addtab (hshtab,signame,LocalName,VBL_PNTDFN,(long)VbVar->TARGET);
3743 addtab (hshtab,signame,LocalName,VBL_SUNDFN,Signed);
3744 addtab (hshtab,signame,LocalName,VBL_DYNDFN,0);
3745 }
3746 else
3747 {
3748 VbVar = (vbvar_list *)vbl_addstr( StrFlag,0,
3749 get_type(VBH_TYPE_BIT),VBH_TYPE_BIT,
3750 'S',signame, -1,-1 , VexInit, 0, 0 );
3751
3752 Signed = ( IsVexNodeSigned( VbVar->TARGET ) != 0 );
3753
3754 addtab (hshtab,signame,LocalName,VBL_SYMDFN,VBL_VARDFN);
3755 addtab (hshtab,signame,LocalName,VBL_TYPDFN,VBH_TYPE_BIT);
3756 addtab (hshtab,signame,LocalName,VBL_WMNDFN,-1);
3757 addtab (hshtab,signame,LocalName,VBL_WMXDFN,-1);
3758 addtab (hshtab,signame,LocalName,VBL_ATLDFN,0);
3759 addtab (hshtab,signame,LocalName,VBL_ATRDFN,1);
3760 addtab (hshtab,signame,LocalName,VBL_LBLDFN,0);
3761 addtab (hshtab,signame,LocalName,VBL_PNTDFN,(long)VbVar->TARGET);
3762 addtab (hshtab,signame,LocalName,VBL_SUNDFN,Signed);
3763 addtab (hshtab,signame,LocalName,VBL_DYNDFN,0);
3764 }
3765 }
3766 else
3767 {
3768 signame = (char *)VBL_NM1LST->DATA;
3769 if (chktab (hshtab,signame,LocalName,VBL_SYMDFN) != 0)
3770 my_vbl_error (80,signame);
3771
3772 VbVar = (vbvar_list *)vbl_addstr( StrFlag,0,
3773 val_type($4.NAME),$4.TYPE,
3774 $4.FLAG,signame, AttrLeft, AttrRight, VexInit, 0, $5.DYNAMIC);
3775
3776 Signed = ( IsVexNodeSigned( VbVar->TARGET ) != 0 );
3777
3778 if ( ( $4.FLAG == 'I' ) && ( $5.DYNAMIC ) )
3779 {
3780 $5.DYNAMIC = VBL_DWTDFN;
3781 }
3782
3783
3784 if ( ! $5.DYNAMIC ) /* LUDO_DYNAMIC */
3785 {
3786 if ( IsVexAtomBit( VbVar->TARGET ) )
3787 {
3788 Left = -1;
3789 Right = -1;
3790 }
3791 else
3792 {
3793 Left = VbVar->TARGET->LEFT;
3794 Right = VbVar->TARGET->RIGHT;
3795 }
3796 }
3797
3798 addtab (hshtab,signame,LocalName,VBL_SYMDFN,VBL_VARDFN);
3799 addtab (hshtab,signame,LocalName,VBL_TYPDFN,$4.TYPE);
3800 addtab (hshtab,signame,LocalName,VBL_WMNDFN,Left);
3801 addtab (hshtab,signame,LocalName,VBL_WMXDFN,Right);
3802 addtab (hshtab,signame,LocalName,VBL_ATLDFN,AttrLeft);
3803 addtab (hshtab,signame,LocalName,VBL_ATRDFN,AttrRight);
3804 addtab (hshtab,signame,LocalName,VBL_LBLDFN,0);
3805 addtab (hshtab,signame,LocalName,VBL_PNTDFN,(long)VbVar->TARGET);
3806 addtab (hshtab,signame,LocalName,VBL_SUNDFN,Signed);
3807 addtab (hshtab,signame,LocalName,VBL_DYNDFN,$5.DYNAMIC);
3808 }
3809
3810 VBL_NM1LST = delchain (VBL_NM1LST,VBL_NM1LST);
3811 }
3812 }
3813 ;
3814
3815 signal_declaration
3816 : SIGNAL
3817 identifier_list
3818 Colon
3819 type_mark
3820 .constraint.
3821 .signal_kind.
3822 .VarAsgn__expression.
3823 Semicolon_ERR
3824 {
3825 char *signame;
3826 char buffer[ 128 ];
3827 char *codedsigname;
3828 vbtyp_list *TypeEnum;
3829 short Signed;
3830 long Left = 0;
3831 long Right = 0;
3832 long AttrLeft;
3833 long AttrRight;
3834 long EnumSize;
3835 vbaux_list *VbAux;
3836 vexexpr *VexInit;
3837 struct vbl_expr expr1;
3838
3839 TypeEnum = val_type( $4.NAME );
3840 EnumSize = vbl_codeSize( TypeEnum->SIZE - 1 );
3841
3842 if ( ( $4.DYNAMIC ) &&
3843 ( ! $5.DYNAMIC ) )
3844 {
3845 $5.DYNAMIC = $4.DYNAMIC;
3846 $5.LEFT = $4.LEFT;
3847 $5.RIGHT = $4.RIGHT;
3848 }
3849
3850 if ( $5.DYNAMIC ) /* LUDO_DYNAMIC */
3851 {
3852 AttrLeft = $5.LEFT;
3853 AttrRight = $5.RIGHT;
3854 Left = AttrLeft;
3855 Right = AttrRight;
3856 }
3857 else
3858 if ( ( $5.LEFT == -1 ) &&
3859 ( $5.RIGHT == -1 ) )
3860 {
3861 AttrLeft = TypeEnum->LEFT;
3862 AttrRight = TypeEnum->RIGHT;
3863 }
3864 else
3865 {
3866 AttrLeft = $5.LEFT;
3867 AttrRight = $5.RIGHT;
3868 }
3869
3870 VBL_NM1LST = reverse (VBL_NM1LST);
3871
3872 if ( ! $5.DYNAMIC ) /* LUDO_DYNAMIC */
3873 {
3874 if ( $7.VEX == (vexexpr *)0 )
3875 {
3876 if ( TypeEnum->CLASS == 'I' )
3877 {
3878 sprintf( buffer, "%ld", AttrLeft );
3879 expr1.IDENT = buffer;
3880 expr1.TYPE = -1;
3881 expr1.VEX = (vexexpr *)0;
3882 expr1 = vbl_crtvex( NOPS, expr1,VBL_EMPSTR,-1,-1,0);
3883
3884 $7.VEX = expr1.VEX;
3885 }
3886 }
3887 }
3888
3889 while (VBL_NM1LST != NULL)
3890 {
3891 VexInit = $7.VEX;
3892
3893 if ( ( VexInit != (vexexpr *)0 ) &&
3894 ( VBL_NM1LST->NEXT != (chain_list *)0 ) )
3895 {
3896 VexInit = dupvexexpr( $7.VEX );
3897 }
3898
3899 if ( ( TypeEnum->CLASS == 'E' ) &&
3900 ( TypeEnum->INDEX >= VBH_MAX_TYPE ) )
3901 {
3902 signame = (char *)VBL_NM1LST->DATA;
3903
3904 if (chktab (hshtab,signame,VBL_MODNAM,VBL_SYMDFN) != 0)
3905 my_vbl_error (10,signame);
3906
3907 sprintf (buffer, "%s.cod.%s", VBL_MODNAM, signame);
3908 codedsigname = namealloc ( buffer );
3909
3910 if (chktab (hshtab,codedsigname,VBL_MODNAM,VBL_SYMDFN) != 0)
3911 my_vbl_error (10,codedsigname);
3912 /*\
3913 VbAux = (vbaux_list *)vbl_addstr( 'S',0,
3914 val_type($4.NAME),$4.TYPE,
3915 $4.FLAG,codedsigname, AttrLeft, AttrRight,VexInit, $6, 0);
3916
3917 Signed = ( IsVexNodeSigned( VbAux->TARGET ) != 0 );
3918
3919 if ( IsVexAtomBit( VbAux->TARGET ) )
3920 {
3921 Left = -1;
3922 Right = -1;
3923 }
3924 else
3925 {
3926 Left = VbAux->TARGET->LEFT;
3927 Right = VbAux->TARGET->RIGHT;
3928 }
3929 \*/
3930 addtab (hshtab,codedsigname,VBL_MODNAM,VBL_SYMDFN,VBL_SGNDFN);
3931 addtab (hshtab,codedsigname,VBL_MODNAM,VBL_TYPDFN,$4.TYPE);
3932 addtab (hshtab,codedsigname,VBL_MODNAM,VBL_WMNDFN,-1);
3933 addtab (hshtab,codedsigname,VBL_MODNAM,VBL_WMXDFN,-1);
3934 addtab (hshtab,codedsigname,VBL_MODNAM,VBL_LBLDFN,$6);
3935 addtab (hshtab,codedsigname,VBL_MODNAM,VBL_PNTDFN,0);
3936 addtab (hshtab,codedsigname,VBL_MODNAM,VBL_PNTDFN,0);
3937 addtab (hshtab,codedsigname,VBL_MODNAM,VBL_DYNDFN,0);
3938
3939 if ( VexInit != (vexexpr *)0 ) VexInit = dupvexexpr( VexInit );
3940
3941 if ( EnumSize > 1 )
3942 {
3943 VbAux = (vbaux_list *)vbl_addstr ('S',0,
3944 get_type(VBH_TYPE_BIT_VECTOR), VBH_TYPE_BIT_VECTOR,
3945 'U',signame, 0,EnumSize-1 , VexInit, $6, 0);
3946
3947 Signed = ( IsVexNodeSigned( VbAux->TARGET ) != 0 );
3948
3949 addtab (hshtab,signame,VBL_MODNAM,VBL_SYMDFN,VBL_SGNDFN);
3950 addtab (hshtab,signame,VBL_MODNAM,VBL_TYPDFN,VBH_TYPE_BIT_VECTOR);
3951 addtab (hshtab,signame,VBL_MODNAM,VBL_WMNDFN,0);
3952 addtab (hshtab,signame,VBL_MODNAM,VBL_WMXDFN,EnumSize-1);
3953 addtab (hshtab,signame,VBL_MODNAM,VBL_ATLDFN,0);
3954 addtab (hshtab,signame,VBL_MODNAM,VBL_ATRDFN,EnumSize-1);
3955 addtab (hshtab,signame,VBL_MODNAM,VBL_LBLDFN,$6);
3956 addtab (hshtab,signame,VBL_MODNAM,VBL_PNTDFN,(long)VbAux->TARGET);
3957 addtab (hshtab,signame,VBL_MODNAM,VBL_SUNDFN,Signed);
3958 addtab (hshtab,signame,VBL_MODNAM,VBL_DYNDFN,0);
3959 }
3960 else
3961 {
3962 VbAux = (vbaux_list *)vbl_addstr ('S',0,
3963 get_type(VBH_TYPE_BIT),VBH_TYPE_BIT,
3964 'S',signame, -1,-1 , VexInit, $6, 0);
3965
3966 Signed = ( IsVexNodeSigned( VbAux->TARGET ) != 0 );
3967
3968 addtab (hshtab,signame,VBL_MODNAM,VBL_SYMDFN,VBL_SGNDFN);
3969 addtab (hshtab,signame,VBL_MODNAM,VBL_TYPDFN,VBH_TYPE_BIT);
3970 addtab (hshtab,signame,VBL_MODNAM,VBL_WMNDFN,-1);
3971 addtab (hshtab,signame,VBL_MODNAM,VBL_WMXDFN,-1);
3972 addtab (hshtab,signame,VBL_MODNAM,VBL_ATLDFN,0);
3973 addtab (hshtab,signame,VBL_MODNAM,VBL_ATRDFN,1);
3974 addtab (hshtab,signame,VBL_MODNAM,VBL_LBLDFN,$6);
3975 addtab (hshtab,signame,VBL_MODNAM,VBL_PNTDFN,(long)VbAux->TARGET);
3976 addtab (hshtab,signame,VBL_MODNAM,VBL_SUNDFN,Signed);
3977 addtab (hshtab,signame,VBL_MODNAM,VBL_DYNDFN,0);
3978 }
3979 }
3980 else
3981 {
3982 signame = (char *)VBL_NM1LST->DATA;
3983 if (chktab (hshtab,signame,VBL_MODNAM,VBL_SYMDFN) != 0)
3984 my_vbl_error (10,signame);
3985
3986 VbAux = (vbaux_list *)vbl_addstr( 'S',0,
3987 val_type($4.NAME),$4.TYPE,
3988 $4.FLAG,signame, AttrLeft,AttrRight,VexInit, $6,
3989 $5.DYNAMIC);
3990
3991 if ( ( $4.FLAG == 'I' ) && ( $5.DYNAMIC ) )
3992 {
3993 $5.DYNAMIC = VBL_DWTDFN;
3994 }
3995
3996 Signed = ( IsVexNodeSigned( VbAux->TARGET ) != 0 );
3997
3998 if ( ! $5.DYNAMIC ) /* LUDO_DYNAMIC */
3999 {
4000 if ( IsVexAtomBit( VbAux->TARGET ) )
4001 {
4002 Left = -1;
4003 Right = -1;
4004 }
4005 else
4006 {
4007 Left = VbAux->TARGET->LEFT;
4008 Right = VbAux->TARGET->RIGHT;
4009 }
4010 }
4011
4012 addtab (hshtab,signame,VBL_MODNAM,VBL_SYMDFN,VBL_SGNDFN);
4013 addtab (hshtab,signame,VBL_MODNAM,VBL_TYPDFN,$4.TYPE);
4014 addtab (hshtab,signame,VBL_MODNAM,VBL_WMNDFN,Left);
4015 addtab (hshtab,signame,VBL_MODNAM,VBL_WMXDFN,Right);
4016 addtab (hshtab,signame,VBL_MODNAM,VBL_ATLDFN,AttrLeft);
4017 addtab (hshtab,signame,VBL_MODNAM,VBL_ATRDFN,AttrRight);
4018 addtab (hshtab,signame,VBL_MODNAM,VBL_LBLDFN,$6);
4019 addtab (hshtab,signame,VBL_MODNAM,VBL_PNTDFN,(long)VbAux->TARGET);
4020 addtab (hshtab,signame,VBL_MODNAM,VBL_SUNDFN,Signed);
4021 addtab (hshtab,signame,VBL_MODNAM,VBL_DYNDFN,$5.DYNAMIC);
4022 }
4023
4024 VBL_NM1LST = delchain (VBL_NM1LST,VBL_NM1LST);
4025 }
4026 }
4027 ;
4028
4029 type_declaration
4030 : full_type_declaration
4031 ;
4032
4033 full_type_declaration
4034 : _TYPE
4035 Identifier
4036 IS
4037 type_definition
4038 Semicolon_ERR
4039 {
4040 vbtyp_list *VbType;
4041 VbType = vbh_addvbtyp(VBL_BEFPNT,$2,$4.LEFT,
4042 $4.RIGHT,$4.VALUE,$4.SIZE,$4.BYTE,$4.BASE,VBL_NUMTYP,$4.RESOLV,$4.CLASS,
4043 VBL_LINNUM);
4044 if ( $4.DYNAMIC )
4045 {
4046 VbType->DYNAMIC = $4.DYNAMIC;
4047 VbType->DYNAMIC_LEFT = $4.DYNAMIC_LEFT;
4048 VbType->DYNAMIC_RIGHT = $4.DYNAMIC_RIGHT;
4049 }
4050 addtab(hshtab,$2,VBL_MODNAM,VBL_SYMDFN,VBL_TPEDFN);
4051 addtab(hshtab,$2,VBL_MODNAM,VBL_LBLDFN,$4.CLASS);
4052 addtab(hshtab,$2,VBL_MODNAM,VBL_TYPDFN,VBL_NUMTYP);
4053 addtab(hshtab,$2,VBL_MODNAM,VBL_WMNDFN,$4.LEFT);
4054 addtab(hshtab,$2,VBL_MODNAM,VBL_WMXDFN,$4.RIGHT);
4055 addtab(hshtab,$2,VBL_MODNAM,VBL_DYNDFN,$4.DYNAMIC);
4056 addtab(hshtab,$2,VBL_MODNAM,VBL_PNTDFN,(long)VBL_BEFPNT->BETYP);
4057 VBL_NUMTYP++;
4058 }
4059 ;
4060
4061 type_definition
4062 : scalar_type_definition
4063 { $$ = $1; }
4064 | composite_type_definition
4065 { $$ = $1; }
4066 | error Semicolon_ERR
4067 { yyerrok; }
4068 ;
4069
4070 subtype_declaration
4071 : SUBTYPE
4072 Identifier
4073 IS
4074 subtype_indication
4075 Semicolon_ERR
4076 {
4077 vbtyp_list *VbType;
4078 VbType = vbh_addvbtyp(VBL_BEFPNT,$2,$4.LEFT,
4079 $4.RIGHT,$4.VALUE,$4.SIZE,$4.BYTE,$4.BASE,$4.INDEX,$4.RESOLV,$4.CLASS,
4080 VBL_LINNUM);
4081 if ( $4.DYNAMIC )
4082 {
4083 VbType->DYNAMIC = $4.DYNAMIC;
4084 VbType->DYNAMIC_LEFT = $4.DYNAMIC_LEFT;
4085 VbType->DYNAMIC_RIGHT = $4.DYNAMIC_RIGHT;
4086 }
4087 addtab(hshtab,$2,VBL_MODNAM,VBL_SYMDFN,VBL_TPEDFN);
4088 addtab(hshtab,$2,VBL_MODNAM,VBL_LBLDFN,$4.CLASS);
4089 addtab(hshtab,$2,VBL_MODNAM,VBL_TYPDFN,$4.INDEX);
4090 addtab(hshtab,$2,VBL_MODNAM,VBL_WMNDFN,$4.LEFT);
4091 addtab(hshtab,$2,VBL_MODNAM,VBL_WMXDFN,$4.RIGHT);
4092 addtab(hshtab,$2,VBL_MODNAM,VBL_DYNDFN,$4.DYNAMIC);
4093 addtab(hshtab,$2,VBL_MODNAM,VBL_PNTDFN,(long)VBL_BEFPNT->BETYP);
4094 VBL_NUMTYP++;
4095 }
4096 ;
4097
4098 subtype_indication
4099 : type_or_function_name
4100 type_mark
4101 .constraint.
4102 {
4103 struct vbtyp *vbtyp_pnt;
4104 struct vbfun *vbfun_pnt;
4105 long mode;
4106
4107 mode = chktab(hshtab,$1,VBL_MODNAM,VBL_SYMDFN);
4108
4109 vbfun_pnt = (vbfun_list *)chktab(hshtab,$1,VBL_MODNAM,VBL_PNTDFN);
4110 vbtyp_pnt = (vbtyp_list *)chktab(hshtab,$2.NAME,VBL_MODNAM,VBL_PNTDFN);
4111
4112 if ( ( mode != VBL_FUNDFN ) || ( $3.DYNAMIC ) )
4113 {
4114 my_vbl_error(87,0);
4115 }
4116
4117 $$.NAME = NULL;
4118 $$.BASE = vbtyp_pnt;
4119 $$.VALUE = NULL ;
4120 $$.SIZE = 0 ;
4121 $$.INDEX = VBL_NUMTYP;
4122 $$.BYTE = vbtyp_pnt->BYTE;
4123 $$.LEFT = $3.LEFT ;
4124 $$.RIGHT = $3.RIGHT ;
4125 $$.CLASS = $3.FLAG ;
4126 $$.RESOLV = vbfun_pnt;
4127 $$.DYNAMIC = 0;
4128 $$.DYNAMIC_LEFT = (vexexpr *)0;
4129 $$.DYNAMIC_RIGHT = (vexexpr *)0;
4130 }
4131 | type_mark
4132 .constraint.
4133 {
4134 struct vbtyp *vbtyp_pnt;
4135
4136 vbtyp_pnt = (vbtyp_list *)chktab(hshtab,$1.NAME,VBL_MODNAM,VBL_PNTDFN);
4137
4138 $$.NAME = NULL;
4139 $$.BASE = vbtyp_pnt;
4140 $$.VALUE = NULL ;
4141 $$.SIZE = 0 ;
4142 $$.INDEX = VBL_NUMTYP;
4143 $$.BYTE = vbtyp_pnt->BYTE;
4144 $$.RESOLV = NULL ;
4145 $$.CLASS = $2.FLAG;
4146
4147 if ( ! $2.DYNAMIC )
4148 {
4149 $$.LEFT = $2.LEFT ;
4150 $$.RIGHT = $2.RIGHT ;
4151 $$.DYNAMIC = 0;
4152 $$.DYNAMIC_LEFT = (vexexpr *)0;
4153 $$.DYNAMIC_RIGHT = (vexexpr *)0;
4154 }
4155 else
4156 {
4157 $$.LEFT = -2;
4158 $$.RIGHT = -2;
4159 $$.DYNAMIC = $2.DYNAMIC;
4160 $$.DYNAMIC_LEFT = (vexexpr *)$2.LEFT;
4161 $$.DYNAMIC_RIGHT = (vexexpr *)$2.RIGHT;
4162 }
4163 }
4164 ;
4165
4166 type_or_function_name
4167 : simple_name
4168 { $$ = $1; }
4169 ;
4170
4171
4172 scalar_type_definition
4173 : enumeration_type_definition
4174 {
4175 $$ = $1;
4176 }
4177 ;
4178 enumeration_type_definition
4179 : LeftParen
4180 enumeration_literal
4181 ...enumeration_literal..
4182 RightParen_ERR
4183 {
4184 char buffer[ 128 ];
4185 char *enumname;
4186 char *enumval;
4187 long size;
4188 long indice;
4189 long numbit;
4190 char **pnt = NULL;
4191 chain_list *nm1lst;
4192
4193 VBL_NM1LST = reverse (VBL_NM1LST);
4194
4195 nm1lst = VBL_NM1LST;
4196 size = 0;
4197
4198 while (nm1lst != NULL)
4199 {
4200 size++;
4201 nm1lst = nm1lst->NEXT;
4202 }
4203
4204 if( size != 0)
4205 pnt = (char **) autallocblock(size * sizeof(char*));
4206
4207 numbit = vbl_codeSize( size - 1 );
4208 indice = 0;
4209
4210 while (VBL_NM1LST != NULL)
4211 {
4212 sprintf ( buffer, "%s.cod.%s", VBL_MODNAM, (char *)VBL_NM1LST->DATA);
4213 enumname = namealloc ( buffer );
4214
4215 if (chktab (hshtab,enumname,VBL_MODNAM,VBL_SYMDFN) != 0)
4216 my_vbl_error (82,enumname);
4217
4218 enumval = vbl_enumbitstring(indice,size,numbit);
4219
4220 addtab (hshtab,enumname,VBL_MODNAM,VBL_SYMDFN,VBL_CSTDFN);
4221 addtab (hshtab,enumname,VBL_MODNAM,VBL_TYPDFN,VBL_NUMTYP);
4222 addtab (hshtab,enumname,VBL_MODNAM,VBL_WMNDFN,-1);
4223 addtab (hshtab,enumname,VBL_MODNAM,VBL_WMXDFN,-1);
4224 addtab (hshtab,enumname,VBL_MODNAM,VBL_LBLDFN,indice);
4225 addtab (hshtab,enumname,VBL_MODNAM,VBL_PNTDFN,(long)pnt);
4226 addauthelem(VBL_ENUMVAL, enumname, (long)enumval );
4227
4228 pnt[indice++] = enumname;
4229 VBL_NM1LST = delchain (VBL_NM1LST, VBL_NM1LST);
4230 }
4231 $$.VALUE = pnt ;
4232 $$.SIZE = size ;
4233 $$.LEFT = 0 ;
4234 $$.RIGHT = 0 ;
4235 $$.BYTE = size/256 +1;
4236 $$.INDEX = VBL_NUMTYP;
4237 $$.CLASS = 'E' ;
4238 $$.BASE = 0 ;
4239 $$.RESOLV = NULL ;
4240 $$.DYNAMIC = 0;
4241 $$.DYNAMIC_LEFT = NULL;
4242 $$.DYNAMIC_RIGHT = NULL;
4243 }
4244 ;
4245
4246
4247 ...enumeration_literal..
4248 : /*empty*/
4249 | ...enumeration_literal..
4250 Comma
4251 enumeration_literal
4252 { yyerrok; }
4253 ;
4254
4255 enumeration_literal
4256 : Identifier
4257 { VBL_NM1LST = addchain (VBL_NM1LST,$1); }
4258 | CharacterLit
4259 { VBL_NM1LST = addchain (VBL_NM1LST,$1); }
4260 ;
4261
4262 composite_type_definition
4263 : array_type_definition
4264 {
4265 $$ = $1;
4266 }
4267 ;
4268
4269 array_type_definition
4270 : unconstrained_array_definition
4271 {
4272 my_vbl_error(123,NULL);
4273 $$ = $1;
4274 }
4275 | constrained_array_definition
4276 { $$ = $1; }
4277 ;
4278
4279 unconstrained_array_definition
4280 : ARRAY
4281 LeftParen
4282 index_subtype_definition
4283 RightParen_ERR
4284 OF
4285 subtype_indication
4286 {
4287 $$ = $6;
4288 $$.CLASS = 'U';
4289 $$.INDEX = $3.TYPE;
4290 }
4291 ;
4292
4293 constrained_array_definition
4294 : ARRAY
4295 index_constraint
4296 OF
4297 subtype_indication
4298 {
4299 vbtyp_list *NewType;
4300 char *name;
4301 char buffer[ 32 ];
4302
4303 $$ = $4;
4304
4305 if ( $4.CLASS == 'U' )
4306 {
4307 if ( $4.BASE->CLASS != 'A' )
4308 {
4309 my_vbl_error(123,NULL);
4310 }
4311 }
4312 else
4313 if ( $4.CLASS == 'A' )
4314 {
4315 if ( $4.BASE->CLASS != 'U' )
4316 {
4317 my_vbl_error(123,NULL);
4318 }
4319
4320 sprintf( buffer, "_subtype_%ld", VBL_NUMTYP );
4321 name = namealloc( buffer );
4322
4323 NewType = vbh_addvbtyp(VBL_BEFPNT,name,$4.LEFT,
4324 $4.RIGHT,$4.VALUE,$4.SIZE,$4.BYTE,$4.BASE,$4.INDEX,$4.RESOLV,$4.CLASS,
4325 VBL_LINNUM);
4326 addtab(hshtab,name,VBL_MODNAM,VBL_SYMDFN,VBL_TPEDFN);
4327 addtab(hshtab,name,VBL_MODNAM,VBL_LBLDFN,$4.CLASS);
4328 addtab(hshtab,name,VBL_MODNAM,VBL_TYPDFN,$4.INDEX);
4329 addtab(hshtab,name,VBL_MODNAM,VBL_WMNDFN,$4.LEFT);
4330 addtab(hshtab,name,VBL_MODNAM,VBL_WMXDFN,$4.RIGHT);
4331 addtab(hshtab,name,VBL_MODNAM,VBL_PNTDFN,(long)VBL_BEFPNT->BETYP);
4332 VBL_NUMTYP++;
4333
4334 $$.BASE = NewType;
4335 }
4336 else
4337 {
4338 my_vbl_error(123,NULL);
4339 }
4340
4341 $$.CLASS = 'A';
4342 $$.INDEX = $2.TYPE;
4343 $$.DYNAMIC = $2.DYNAMIC;
4344
4345 if ( ! $2.DYNAMIC )
4346 {
4347 $$.LEFT = $2.LEFT;
4348 $$.RIGHT = $2.RIGHT;
4349
4350 $$.DYNAMIC_LEFT = (vexexpr *)0;
4351 $$.DYNAMIC_RIGHT = (vexexpr *)0;
4352 }
4353 else
4354 {
4355 $$.LEFT = -2;
4356 $$.RIGHT = -2;
4357
4358 $$.DYNAMIC_LEFT = (vexexpr *)$2.LEFT;
4359 $$.DYNAMIC_RIGHT = (vexexpr *)$2.RIGHT;
4360 }
4361
4362 }
4363 ;
4364
4365 index_subtype_definition
4366 : name /* type_mark - causes conflict */
4367 _RANGE
4368 Box
4369 {
4370 $$.NAME = $1.NAME;
4371 $$.LEFT = $1.LEFT;
4372 $$.RIGHT = $1.RIGHT;
4373 $$.DYNAMIC = $1.DYNAMIC;
4374 $$.AGGREG = 0;
4375 $$.TYPE = chktab(hshtab,$1.NAME,VBL_MODNAM,VBL_TYPDFN);
4376 $$.FLAG = chktab(hshtab,$1.NAME,VBL_MODNAM,VBL_LBLDFN);
4377
4378 if ( ( $$.TYPE == 0 ) || ( $$.FLAG == 0 ) )
4379 {
4380 my_vbl_error(83,$1.NAME);
4381 }
4382 }
4383 ;
4384
4385 index_constraint
4386 : LeftParen
4387 discrete_range
4388 RightParen_ERR
4389 { $$ = $2;}
4390 ;
4391
4392 discrete_range
4393 : range /* includes attribute_name */
4394 { $$ = $1;}
4395 | name
4396 range_constraint /* subtype_indication - causes conflict */
4397 { $$ = $2;
4398 $$.NAME = $1.NAME;
4399 }
4400 | type_mark /* type_mark causes 2 r/r conflicts - required for
4401 louie's code */
4402 { $$ = $1;}
4403 ;
4404
4405 type_mark
4406 :
4407 simple_name
4408 {
4409 vbtyp_list *VbType;
4410 long type;
4411 $$.NAME = $1;
4412 $$.LEFT = -1;
4413 $$.RIGHT = -1;
4414 $$.DYNAMIC = 0;
4415 $$.AGGREG = 0;
4416 $$.TYPE = chktab(hshtab,$1,VBL_MODNAM,VBL_TYPDFN);
4417 $$.FLAG = chktab(hshtab,$1,VBL_MODNAM,VBL_LBLDFN);
4418 type = chktab(hshtab,$1,VBL_MODNAM,VBL_SYMDFN);
4419
4420 if (type != VBL_TPEDFN || $$.TYPE ==0)
4421 {
4422 my_vbl_error(84,$1);
4423 }
4424
4425 VbType = (vbtyp_list *)chktab( hshtab,$1,VBL_MODNAM,VBL_PNTDFN);
4426 if ( ( VbType != (vbtyp_list *)0 ) &&
4427 ( VbType->DYNAMIC ) )
4428 {
4429 $$.DYNAMIC = VbType->DYNAMIC;
4430 $$.LEFT = (long)VbType->DYNAMIC_LEFT;
4431 $$.RIGHT = (long)VbType->DYNAMIC_RIGHT;
4432 }
4433 }
4434 ;
4435
4436 .signal_kind.
4437 : /*empty*/
4438 { $$ = VBH_KIND_NONE; }
4439 | BUS
4440 { $$ = VBH_KIND_BUS; }
4441 | REGISTER
4442 { $$ = VBH_KIND_REGISTER; }
4443 ;
4444
4445 architecture_statement_part
4446 : ..concurrent_statement..
4447 ;
4448
4449 ..concurrent_statement..
4450 : /*empty*/
4451 | ..concurrent_statement..
4452 concurrent_statement
4453 ;
4454
4455 concurrent_statement
4456 : block_statement
4457 | concurrent_assertion_statement
4458 | process_statement
4459 | concurrent_signal_assignment_statement
4460 | component_instantiation_statement
4461 | generate_statement
4462 | error
4463 Semicolon_ERR
4464 { my_vbl_error (18,NULL); }
4465 ;
4466
4467 concurrent_assertion_statement
4468 : a_label
4469 unlabeled_concurrent_assertion_statement
4470 {
4471 if (chktab (hshtab,$1,VBL_MODNAM,VBL_SYMDFN) != 0)
4472 my_vbl_error (19,$1);
4473
4474 addtab (hshtab,$1,VBL_MODNAM,VBL_SYMDFN,VBL_LABDFN);
4475 }
4476 | unlabeled_concurrent_assertion_statement
4477 ;
4478
4479 unlabeled_concurrent_assertion_statement
4480 : assertion_statement
4481 ;
4482
4483 block_statement
4484 : a_label
4485 BLOCK
4486 .guard_expression.
4487 _BEGIN
4488 {
4489 if (chktab( hshtab, $1,VBL_MODNAM,VBL_SYMDFN) != 0)
4490 my_vbl_error (19,$1);
4491
4492 addtab( hshtab,$1,VBL_MODNAM,VBL_SYMDFN,VBL_LABDFN);
4493
4494 if ($3.VEX != (vexexpr *)0)
4495 {
4496 VBL_GRDLST = addchain( VBL_GRDLST, (char *)$3.VEX );
4497 }
4498
4499 }
4500 set_of_statements
4501 END_ERR
4502 BLOCK
4503 .label.
4504 Semicolon_ERR
4505 {
4506 if ( $3.VEX != (vexexpr *)0 )
4507 {
4508 VBL_GRDLST = delchain( VBL_GRDLST,VBL_GRDLST );
4509 }
4510
4511 if ( ($9 != NULL) &&
4512 ($9 != $1 ) ) my_vbl_error (20,$9);
4513 }
4514 ;
4515
4516 set_of_statements
4517 : ..concurrent_statement..
4518 ;
4519
4520 concurrent_signal_assignment_statement
4521 : a_label
4522 unlabeled_conditional_signal_assignment
4523 {
4524 if (chktab( hshtab,$1,VBL_MODNAM,VBL_SYMDFN) != 0)
4525 my_vbl_error (19,$1);
4526 addtab( hshtab,$1,VBL_MODNAM,VBL_SYMDFN, VBL_LABDFN );
4527 }
4528 | unlabeled_conditional_signal_assignment
4529 | a_label
4530 unlabeled_selected_signal_assignment
4531 {
4532 if (chktab (hshtab,$1,VBL_MODNAM,VBL_SYMDFN) != 0)
4533 my_vbl_error (19,$1);
4534 addtab( hshtab,$1,VBL_MODNAM,VBL_SYMDFN,VBL_LABDFN);
4535 }
4536 | unlabeled_selected_signal_assignment
4537 ;
4538
4539 unlabeled_conditional_signal_assignment
4540 : target
4541 _LESym
4542 .GUARDED.
4543 ..waveform__WHEN__condition__ELSE..
4544 waveform
4545 Semicolon_ERR
4546 {
4547 vbl_vexstr *VexStr;
4548 char Buffer[ 128 ];
4549 char *CodedSigName;
4550 char *Name;
4551 long Index;
4552 vbl_vexstr *ExprCnd;
4553 vbl_vexstr *ExprVal;
4554 long ProcessType;
4555 long Type;
4556 long Mode;
4557 long Width;
4558 long Left;
4559 long Right;
4560 long Left_bnd;
4561 long Right_bnd;
4562 chain_list *SensList;
4563 chain_list *HeadChain;
4564 chain_list *ScanChain;
4565 chain_list *DelChain;
4566 chain_list **PrevChain;
4567 ptype_list **PrevInst;
4568 ptype_list *Inst;
4569 ptype_list *InstIfs;
4570 ptype_list *InstAsg;
4571 vbtyp_list *TypeTarget;
4572 vexexpr *VexTarget;
4573 vexexpr *VexValue;
4574 vexexpr *VexGuard;
4575 long Line;
4576 unsigned char Dynamic;
4577
4578 if ( $1.AGGREG )
4579 {
4580 my_vbl_error(114,NULL);
4581 }
4582
4583 if ( $5.AGGREG )
4584 {
4585 HeadChain = reverse( (chain_list *)$5.IDENT );
4586 ScanChain = HeadChain;
4587
4588 if ( HeadChain->NEXT != (chain_list *)0 )
4589 {
4590 Width = 0;
4591 VexValue = createvexoper( VEX_CONCAT, 1 );
4592
4593 while ( ScanChain != (chain_list *)0 )
4594 {
4595 VexStr = (vbl_vexstr *)ScanChain->DATA;
4596 Width += VexStr->VEX->WIDTH;
4597 addvexhexpr( VexValue, VexStr->VEX );
4598
4599 autfreeheap( VexStr, sizeof( vbl_vexstr ) );
4600
4601 ScanChain = ScanChain->NEXT;
4602 }
4603
4604 VexValue->WIDTH = Width;
4605 }
4606 else
4607 {
4608 VexStr = (vbl_vexstr *)HeadChain->DATA;
4609 VexValue = VexStr->VEX;
4610
4611 autfreeheap( VexStr, sizeof( vbl_vexstr ) );
4612 }
4613
4614 freechain( HeadChain );
4615
4616 $5.AGGREG = 0;
4617 $5.VEX = VexValue;
4618 }
4619
4620 sprintf( Buffer, "%s.cod.%s", VBL_MODNAM, $1.NAME );
4621 CodedSigName = namealloc( Buffer );
4622
4623 Type = chktab( hshtab, CodedSigName, VBL_MODNAM, VBL_TYPDFN );
4624 ProcessType = 0;
4625
4626 if ( Type >= VBH_MAX_TYPE )
4627 {
4628 Mode = chktab( hshtab, $1.NAME, VBL_MODNAM, VBL_SYMDFN );
4629 Dynamic = chktab( hshtab, $1.NAME, VBL_MODNAM, VBL_DYNDFN );
4630
4631 Left = $1.LEFT;
4632 Right = $1.RIGHT;
4633 }
4634 else
4635 {
4636 Type = chktab( hshtab, $1.NAME, VBL_MODNAM, VBL_TYPDFN );
4637 Mode = chktab( hshtab, $1.NAME, VBL_MODNAM, VBL_SYMDFN );
4638 Dynamic = chktab( hshtab, $1.NAME, VBL_MODNAM, VBL_DYNDFN );
4639
4640 Left = $1.LEFT;
4641 Right = $1.RIGHT;
4642 }
4643
4644 if( Mode == VBL_ICNDFN ) my_vbl_error( 21, $1.NAME );
4645 if( Mode == 0 ) my_vbl_error( 17, $1.NAME );
4646
4647 if ( ! $1.DYNAMIC )
4648 {
4649 VexTarget = vbl_dynamicvexatom( $1.NAME, $1.LEFT, $1.RIGHT, 0 );
4650 }
4651 else
4652 {
4653 Left_bnd = chktab (hshtab,$1.NAME,VBL_MODNAM,VBL_WMNDFN);
4654 Right_bnd = chktab (hshtab,$1.NAME,VBL_MODNAM,VBL_WMXDFN);
4655
4656 VexTarget = vbl_dynamicvexatom( $1.NAME, Left_bnd, Right_bnd, Dynamic );
4657
4658 if ( Right == 0 )
4659 {
4660 VexTarget = createvexbinexpr( VEX_INDEX, 1, VexTarget, (vexexpr *)Left );
4661 }
4662 else
4663 {
4664 if ( ( Mode == VBL_FUNDFN ) ||
4665 ( Mode == VBL_PRODFN ) ||
4666 ( Mode == VBL_TPEDFN ) )
4667 {
4668 freevexexpr( VexTarget );
4669 VexTarget = (vexexpr *)Left;
4670 }
4671 else
4672 if ( $1.DYNAMIC == VBL_UPTDFN )
4673 {
4674 if ( ( ! Dynamic ) ||
4675 ( ! isvexequalexpr( (vexexpr *)Left_bnd, (vexexpr *)Left ) ) ||
4676 ( ! isvexequalexpr( (vexexpr *)Right_bnd, (vexexpr *)Right ) ) )
4677 {
4678 VexTarget = createvexternaryexpr( VEX_TO, 1, VexTarget,
4679 (vexexpr *)Left, (vexexpr *)Right );
4680 }
4681 }
4682 else
4683 if ( $1.DYNAMIC == VBL_DWTDFN )
4684 {
4685 if ( ( ! Dynamic ) ||
4686 ( ! isvexequalexpr( (vexexpr *)Left_bnd, (vexexpr *)Left ) ) ||
4687 ( ! isvexequalexpr( (vexexpr *)Right_bnd, (vexexpr *)Right ) ) )
4688 {
4689 VexTarget = createvexternaryexpr( VEX_DOWNTO, 1, VexTarget,
4690 (vexexpr *)Left, (vexexpr *)Right );
4691 }
4692 }
4693 else
4694 {
4695 VexTarget = createvexbinexpr( VEX_INDEX_N, 1, VexTarget, (vexexpr *)Left );
4696 VexTarget = createvexbinexpr( VEX_INDEX_N, 1, VexTarget, (vexexpr *)Right );
4697 }
4698 }
4699 }
4700
4701 if ( $1.SIGNED )
4702 {
4703 SetVexNodeSigned( VexTarget );
4704 }
4705
4706 TypeTarget = get_type( Type );
4707
4708 Inst = (ptype_list *)0;
4709 PrevInst = &Inst;
4710 SensList = (chain_list *)0;
4711
4712 if ( VBL_CNDLST != (chain_list *)0 )
4713 {
4714 VBL_CNDLST = reverse( VBL_CNDLST );
4715 VBL_VALLST = reverse( VBL_VALLST );
4716 VBL_LINLST = reverse( VBL_LINLST );
4717 }
4718
4719 while ( VBL_CNDLST != (chain_list *)0 )
4720 {
4721 ProcessType |= VBH_PROCESS_CONDITIONNAL_MASK;
4722
4723 ExprVal = (vbl_vexstr *)VBL_VALLST->DATA;
4724 ExprCnd = (vbl_vexstr *)VBL_CNDLST->DATA;
4725 Line = (long )VBL_LINLST->DATA;
4726
4727 SensList = unionvexexprsupport( SensList, ExprCnd->VEX );
4728 SensList = unionvexexprsupport( SensList, ExprVal->VEX );
4729
4730 InstAsg = vbh_addvbasg( (ptype_list *)0, dupvexexpr( VexTarget ),
4731 simpvexexprothers( ExprVal->VEX, VexTarget->WIDTH ),
4732 TypeTarget, Line );
4733
4734 InstIfs = vbh_addvbifs( (ptype_list *)0, ExprCnd->VEX, Line );
4735 ((vbifs_list *)InstIfs->DATA)->CNDTRUE = InstAsg;
4736
4737 *PrevInst = InstIfs;
4738 PrevInst = &((vbifs_list *)InstIfs->DATA)->CNDFALSE;
4739
4740 autfreeheap( ExprCnd, sizeof( vbl_vexstr ) );
4741 autfreeheap( ExprVal, sizeof( vbl_vexstr ) );
4742
4743 VBL_CNDLST = delchain( VBL_CNDLST, VBL_CNDLST );
4744 VBL_VALLST = delchain( VBL_VALLST, VBL_VALLST );
4745 VBL_LINLST = delchain( VBL_LINLST, VBL_LINLST );
4746 }
4747
4748 SensList = unionvexexprsupport( SensList, $5.VEX );
4749 *PrevInst = vbh_addvbasg( (ptype_list *)0, VexTarget,
4750 simpvexexprothers( $5.VEX, VexTarget->WIDTH ),
4751 TypeTarget, VBL_LINNUM );
4752 if ( $3 == VBL_GRDDFN )
4753 {
4754 ProcessType |= VBH_PROCESS_GUARDED_MASK;
4755
4756 VexGuard = dupvexexpr( (vexexpr *)VBL_GRDLST->DATA );
4757 SensList = unionvexexprsupport( SensList, VexGuard );
4758
4759 InstIfs = vbh_addvbifs( (ptype_list *)0, VexGuard, VBL_LINNUM );
4760 ((vbifs_list *)InstIfs->DATA)->CNDTRUE = Inst;
4761
4762 Inst = InstIfs;
4763 }
4764
4765 PrevChain = &SensList;
4766 ScanChain = SensList;
4767
4768 while ( ScanChain != (chain_list *)0 )
4769 {
4770 Name = getvexvectorname( ScanChain->DATA, &Index );
4771 Mode = chktab( hshtab, Name, VBL_MODNAM, VBL_SYMDFN );
4772
4773 if ( ( Mode == VBL_CSTDFN ) ||
4774 ( Mode == VBL_GENDFN ) ||
4775 ( Mode == VBL_VARDFN ) )
4776 {
4777 DelChain = ScanChain;
4778 *PrevChain = DelChain->NEXT;
4779 ScanChain = ScanChain->NEXT;
4780
4781 DelChain->NEXT = (chain_list *)0;
4782 freechain( DelChain );
4783 }
4784 else
4785 {
4786 PrevChain = &ScanChain->NEXT;
4787 ScanChain = ScanChain->NEXT;
4788 }
4789 }
4790
4791 Inst = addptype( Inst, VBH_BEWAS,
4792 vbh_addvbwas( SensList, NULL, 0, NULL, VBL_LINNUM ) );
4793 Inst = reversetype( Inst );
4794
4795 VBL_PROCNUM++;
4796 sprintf( Buffer, "p%ld_%ld", VBL_LINNUM, VBL_PROCNUM );
4797 VBL_PROCNAM = namealloc( Buffer );
4798 VBL_BEPCS = vbh_addvbpcs( VBL_BEPCS, VBL_PROCNAM, NULL, Inst, VBL_LINNUM );
4799 VBL_BEPCS->TYPE = ProcessType;
4800 VBL_PROCNAM = (char *)0;
4801 }
4802 ;
4803
4804 ..waveform__WHEN__condition__ELSE..
4805 : /*empty*/
4806 | ..waveform__WHEN__condition__ELSE..
4807 waveform
4808 WHEN
4809 expression
4810 ELSE
4811 {
4812 vbl_vexstr *Expr;
4813
4814 Expr = (vbl_vexstr *)autallocheap( sizeof( vbl_vexstr ) );
4815 Expr->WIDTH = $4.WIDTH;
4816 Expr->VEX = $4.VEX;
4817 VBL_CNDLST = addchain( VBL_CNDLST, (char *)Expr );
4818
4819 Expr = (vbl_vexstr *)autallocheap( sizeof( vbl_vexstr ) );
4820 Expr->WIDTH = $2.WIDTH;
4821 Expr->VEX = $2.VEX;
4822 VBL_VALLST = addchain( VBL_VALLST, (char *)Expr );
4823
4824 VBL_LINLST = addchain( VBL_LINLST, (char *)VBL_LINNUM );
4825 }
4826 ;
4827
4828 unlabeled_selected_signal_assignment
4829 : WITH
4830 expression
4831 {
4832 VBL_CASSIZE = $2.WIDTH - 1;
4833 }
4834 SELECT
4835 target
4836 _LESym
4837 .GUARDED.
4838 waveform__WHEN__choices
4839 ...waveform__WHEN__choices..
4840 Semicolon_ERR
4841 {
4842 char *CodedSigName;
4843 char *Name;
4844 long Index;
4845 char Buffer[ 128 ];
4846 ptype_list *InstCase;
4847 ptype_list *InstAsg;
4848 ptype_list *InstIfs;
4849 ptype_list *Inst;
4850 chain_list *SensList;
4851 vbl_vexstr *ExprVal;
4852 vbcho_list *VbChoice;
4853 vbcas_list *VbCase;
4854 chain_list *ScanCond;
4855 chain_list *ScanChain;
4856 chain_list **PrevChain;
4857 chain_list *DelChain;
4858 vbtyp_list *TypeTarget;
4859 vexexpr *VexTarget;
4860 vexexpr *VexGuard;
4861 char *Value;
4862 long SizeValue;
4863 long NumberChoice;
4864 long Type;
4865 long Mode;
4866 long Left;
4867 long Right;
4868 long Left_bnd;
4869 long Right_bnd;
4870 long Line;
4871 long ProcessType;
4872 unsigned char Dynamic;
4873
4874 if ( $5.AGGREG )
4875 {
4876 my_vbl_error(114,NULL);
4877 }
4878
4879 sprintf( Buffer, "%s.cod.%s", VBL_MODNAM, $5.NAME );
4880 CodedSigName = namealloc( Buffer );
4881 ProcessType = VBH_PROCESS_WITHSELECT_MASK;
4882
4883 Type = chktab( hshtab, CodedSigName, VBL_MODNAM, VBL_TYPDFN );
4884
4885 if ( Type >= VBH_MAX_TYPE )
4886 {
4887 Mode = chktab( hshtab, $5.NAME, VBL_MODNAM, VBL_SYMDFN );
4888 Dynamic = chktab( hshtab, $5.NAME, VBL_MODNAM, VBL_DYNDFN );
4889 Left = $5.LEFT;
4890 Right = $5.RIGHT;
4891 }
4892 else
4893 {
4894 Type = chktab( hshtab, $5.NAME, VBL_MODNAM, VBL_TYPDFN );
4895 Mode = chktab( hshtab, $5.NAME, VBL_MODNAM, VBL_SYMDFN );
4896 Dynamic = chktab( hshtab, $5.NAME, VBL_MODNAM, VBL_DYNDFN );
4897
4898 Left = $5.LEFT;
4899 Right = $5.RIGHT;
4900 }
4901
4902 if( Mode == VBL_ICNDFN ) my_vbl_error( 21, $5.NAME );
4903 if( Mode == 0 ) my_vbl_error( 17, $5.NAME );
4904
4905 if ( ! $5.DYNAMIC )
4906 {
4907 VexTarget = vbl_dynamicvexatom( $5.NAME, $5.LEFT, $5.RIGHT, 0 );
4908 }
4909 else
4910 {
4911 Left_bnd = chktab (hshtab,$5.NAME,VBL_MODNAM,VBL_WMNDFN);
4912 Right_bnd = chktab (hshtab,$5.NAME,VBL_MODNAM,VBL_WMXDFN);
4913
4914 VexTarget = vbl_dynamicvexatom( $5.NAME, Left_bnd, Right_bnd, Dynamic );
4915
4916 if ( Right == 0 )
4917 {
4918 VexTarget = createvexbinexpr( VEX_INDEX, 1, VexTarget,
4919 (vexexpr *)Left );
4920 }
4921 else
4922 {
4923 if ( ( Mode == VBL_FUNDFN ) ||
4924 ( Mode == VBL_TPEDFN ) ||
4925 ( Mode == VBL_PRODFN ) )
4926 {
4927 VexTarget = (vexexpr *)Left;
4928 }
4929 else
4930 if ( $5.DYNAMIC == VBL_UPTDFN )
4931 {
4932 if ( ( ! Dynamic ) ||
4933 ( ! isvexequalexpr( (vexexpr *)Left_bnd, (vexexpr *)Left ) ) ||
4934 ( ! isvexequalexpr( (vexexpr *)Right_bnd, (vexexpr *)Right ) ) )
4935 {
4936 VexTarget = createvexternaryexpr( VEX_TO, 1, VexTarget,
4937 (vexexpr *)Left, (vexexpr *)Right );
4938 }
4939 }
4940 else
4941 if ( $5.DYNAMIC == VBL_DWTDFN )
4942 {
4943 if ( ( ! Dynamic ) ||
4944 ( ! isvexequalexpr( (vexexpr *)Left_bnd, (vexexpr *)Left ) ) ||
4945 ( ! isvexequalexpr( (vexexpr *)Right_bnd, (vexexpr *)Right ) ) )
4946 {
4947 VexTarget = createvexternaryexpr( VEX_DOWNTO, 1, VexTarget,
4948 (vexexpr *)Left, (vexexpr *)Right );
4949 }
4950 }
4951 else
4952 {
4953 VexTarget = createvexbinexpr( VEX_INDEX_N, 1, VexTarget, (vexexpr *)Left );
4954 VexTarget = createvexbinexpr( VEX_INDEX_N, 1, VexTarget, (vexexpr *)Right );
4955 }
4956 }
4957 }
4958
4959 if ( $5.SIGNED )
4960 {
4961 SetVexNodeSigned( VexTarget );
4962 }
4963
4964 TypeTarget = get_type( Type );
4965 SensList = getvexexprsupport( $2.VEX );
4966
4967 InstCase = vbh_addvbcas( (ptype_list *)0, $2.VEX, get_type( $2.TYPE ), VBL_LINNUM );
4968 VbCase = (vbcas_list *)InstCase->DATA;
4969
4970 SizeValue = $2.WIDTH + 1;
4971 NumberChoice = 0;
4972
4973 for ( ScanCond = VBL_CNDLST;
4974 ScanCond != (chain_list *)0;
4975 ScanCond = ScanCond->NEXT )
4976 {
4977 NumberChoice++;
4978 }
4979
4980 VbChoice = (vbcho_list *)autallocblock( sizeof( vbcho_list ) * NumberChoice );
4981
4982 VbCase->CHOICE = VbChoice;
4983 VbCase->SIZE = NumberChoice;
4984
4985 while ( VBL_CNDLST != (chain_list *)0 )
4986 {
4987 NumberChoice = NumberChoice - 1;
4988
4989 ExprVal = (vbl_vexstr *)VBL_VALLST->DATA;
4990 Line = (long )VBL_LINLST->DATA;
4991
4992 ExprVal->VEX = simpvexexprothers( ExprVal->VEX, VexTarget->WIDTH ),
4993
4994 InstAsg = vbh_addvbasg( (ptype_list *)0, dupvexexpr( VexTarget ),
4995 ExprVal->VEX, TypeTarget, Line );
4996
4997 SensList = unionvexexprsupport( SensList, ExprVal->VEX );
4998
4999 Value = (char *)VBL_CNDLST->DATA;
5000 if ( Value == (char *)0 ) Value = namealloc( "others" );
5001
5002 VbChoice[ NumberChoice ].INSTRUCTION = InstAsg;
5003 VbChoice[ NumberChoice ].SIZE = SizeValue;
5004 VbChoice[ NumberChoice ].VALUES = addchain( NULL, Value );
5005
5006 autfreeheap( ExprVal, sizeof( vbl_vexstr ) );
5007
5008 VBL_CNDLST = delchain( VBL_CNDLST, VBL_CNDLST );
5009 VBL_VALLST = delchain( VBL_VALLST, VBL_VALLST );
5010 VBL_LINLST = delchain( VBL_LINLST, VBL_LINLST );
5011 }
5012
5013 if ( $7 == VBL_GRDDFN )
5014 {
5015 ProcessType |= VBH_PROCESS_GUARDED_MASK;
5016
5017 VexGuard = dupvexexpr( (vexexpr *)VBL_GRDLST->DATA );
5018 SensList = unionvexexprsupport( SensList, VexGuard );
5019
5020 InstIfs = vbh_addvbifs( (ptype_list *)0, VexGuard, VBL_LINNUM );
5021 ((vbifs_list *)InstIfs->DATA)->CNDTRUE = InstCase;
5022
5023 Inst = InstIfs;
5024 }
5025 else
5026 {
5027 Inst = InstCase;
5028 }
5029
5030 PrevChain = &SensList;
5031 ScanChain = SensList;
5032
5033 while ( ScanChain != (chain_list *)0 )
5034 {
5035 Name = getvexvectorname( ScanChain->DATA, &Index );
5036 Mode = chktab( hshtab, Name, VBL_MODNAM, VBL_SYMDFN );
5037
5038 if ( ( Mode == VBL_CSTDFN ) ||
5039 ( Mode == VBL_GENDFN ) ||
5040 ( Mode == VBL_VARDFN ) )
5041 {
5042 DelChain = ScanChain;
5043 *PrevChain = DelChain->NEXT;
5044 ScanChain = ScanChain->NEXT;
5045
5046 DelChain->NEXT = (chain_list *)0;
5047 freechain( DelChain );
5048 }
5049 else
5050 {
5051 PrevChain = &ScanChain->NEXT;
5052 ScanChain = ScanChain->NEXT;
5053 }
5054 }
5055
5056 Inst->NEXT = addptype( (ptype_list *)0, VBH_BEWAS,
5057 vbh_addvbwas( SensList, NULL, 0, NULL, VBL_LINNUM ) );
5058
5059 VBL_PROCNUM++;
5060 sprintf( Buffer, "p%ld_%ld", VBL_LINNUM, VBL_PROCNUM );
5061 VBL_PROCNAM = namealloc( Buffer );
5062 VBL_BEPCS = vbh_addvbpcs( VBL_BEPCS, VBL_PROCNAM, NULL, Inst, VBL_LINNUM );
5063 VBL_BEPCS->TYPE = ProcessType;
5064 VBL_PROCNAM = (char *)0;
5065 }
5066 ;
5067
5068 ...waveform__WHEN__choices..
5069 : /*empty*/
5070 | ...waveform__WHEN__choices..
5071 Comma
5072 waveform__WHEN__choices
5073 ;
5074
5075 waveform__WHEN__choices
5076 : waveform
5077 WHEN
5078 choices
5079 {
5080 vbl_vexstr *Expr;
5081
5082 while ( VBL_NUMCHOICE > 0 )
5083 {
5084 Expr = (vbl_vexstr *)autallocheap( sizeof( vbl_vexstr ) );
5085 Expr->WIDTH = $1.WIDTH;
5086 Expr->VEX = dupvexexpr( $1.VEX );
5087
5088 VBL_VALLST = addchain( VBL_VALLST, (char *)Expr );
5089 VBL_NUMCHOICE--;
5090 }
5091
5092 freevexexpr( $1.VEX );
5093 }
5094 ;
5095
5096 process_statement
5097 : a_label
5098 {
5099 if ( chktab (hshtab,$1,VBL_MODNAM,VBL_SYMDFN) != 0)
5100 my_vbl_error (19,$1);
5101
5102 addtab( hshtab,$1,VBL_MODNAM,VBL_SYMDFN, VBL_LABDFN);
5103
5104 VBL_PROCNAM = $1;
5105 }
5106 unlabeled_process_statement
5107 | {
5108 char buffer[ 128 ];
5109 VBL_PROCNUM++;
5110 sprintf( buffer, "p%ld_%ld", VBL_LINNUM, VBL_PROCNUM );
5111 VBL_PROCNAM = namealloc( buffer );
5112 }
5113 unlabeled_process_statement
5114 ;
5115
5116 unlabeled_process_statement
5117 : PROCESS
5118 { VBL_NM1LST = NULL;}
5119 .sensitivity_list.
5120 {
5121 VBL_BEPCS = vbh_addvbpcs( VBL_BEPCS, VBL_PROCNAM,VBL_NM1LST,NULL,VBL_LINNUM );
5122 VBL_BEPCS->TYPE = VBH_PROCESS_SEQUENTIAL_MASK;
5123 VBL_NM1LST = NULL;
5124 }
5125 process_declarative_part
5126 _BEGIN
5127 {
5128 void *pnt;
5129 pnt = &(VBL_BEPCS->INSTRUCTION);
5130 VBL_INSLST = addchain(NULL,pnt);
5131 }
5132 sequence_of_statements
5133 {
5134 struct ptype **pnt;
5135 struct ptype *ptype;
5136 pnt = (struct ptype**)VBL_INSLST->DATA;
5137 ptype = reversetype(*pnt);
5138 *pnt = ptype;
5139 VBL_INSLST = delchain (VBL_INSLST, VBL_INSLST);
5140 }
5141 END_ERR
5142 PROCESS
5143 .label.
5144 Semicolon_ERR
5145 {
5146 VBL_PROCNAM = (char *)0;
5147 yyerrok;
5148 }
5149 ;
5150
5151 process_declarative_part
5152 : ..process_declarative_item..
5153 ;
5154
5155
5156 ..process_declarative_item..
5157 : /*empty*/
5158 | ..process_declarative_item..
5159 process_declarative_item
5160 {
5161 yyerrok;
5162 }
5163 ;
5164
5165 process_declarative_item
5166 : constant_declaration
5167 | variable_declaration
5168 | type_declaration
5169 | subtype_declaration
5170 | attribute_declaration
5171 | attribute_specification
5172 | subprogram_declaration
5173 | subprogram_body
5174 ;
5175
5176 .sensitivity_list.
5177 : /*empty*/
5178 | sensitivity_list
5179 ;
5180
5181 sensitivity_list
5182 : LeftParen
5183 signal_list
5184 RightParen {}
5185 ;
5186
5187 signal_list
5188 : name
5189 ...name..
5190 {
5191 vexexpr *Vex;
5192 chain_list *Chain;
5193
5194 #if THIS_IS_DISABLED
5195 char *LocalName;
5196
5197 if ( chktab(hshtab,$1.NAME,VBL_FUNCNAM,VBL_SYMDFN ) )
5198 {
5199 LocalName = VBL_FUNCNAM;
5200 }
5201 else
5202 if ( chktab(hshtab,$1.NAME,VBL_MODNAM,VBL_SYMDFN ) )
5203 {
5204 LocalName = VBL_MODNAM;
5205 }
5206 else
5207 {
5208 my_vbl_error(17,$1.NAME);
5209 }
5210 #else
5211 if ( !chktab(hshtab,$1.NAME,VBL_FUNCNAM,VBL_SYMDFN)
5212 && !chktab(hshtab,$1.NAME,VBL_MODNAM,VBL_SYMDFN) )
5213 {
5214 my_vbl_error(17,$1.NAME);
5215 }
5216 #endif
5217
5218 if ( ! $1.DYNAMIC )
5219 {
5220 if ( ( $1.LEFT == -1 ) &&
5221 ( $1.RIGHT == -1 ) )
5222 {
5223 Vex = createvexatombit( $1.NAME );
5224 }
5225 else
5226 {
5227 Vex = createvexatomvec( $1.NAME, $1.LEFT, $1.RIGHT );
5228 }
5229 }
5230 else
5231 {
5232 Vex = createvexatomvec( $1.NAME, -1, -1 );
5233 }
5234
5235 Chain = getvexatombitname( Vex );
5236 VBL_NM1LST = append( VBL_NM1LST, Chain );
5237 freevexexpr( Vex );
5238 }
5239 ;
5240
5241 ...name..
5242 : /*empty*/
5243 | Comma
5244 name
5245 ...name..
5246 {
5247 vexexpr *Vex;
5248 chain_list *Chain;
5249
5250 #if THIS_IS_DISABLED
5251 char *LocalName;
5252
5253 if ( chktab(hshtab,$2.NAME,VBL_FUNCNAM,VBL_SYMDFN ) )
5254 {
5255 LocalName = VBL_FUNCNAM;
5256 }
5257 else
5258 if ( chktab(hshtab,$2.NAME,VBL_MODNAM,VBL_SYMDFN ) )
5259 {
5260 LocalName = VBL_MODNAM;
5261 }
5262 else
5263 {
5264 my_vbl_error(17,$2.NAME);
5265 }
5266 #else
5267 if ( !chktab(hshtab,$2.NAME,VBL_FUNCNAM,VBL_SYMDFN)
5268 && !chktab(hshtab,$2.NAME,VBL_MODNAM,VBL_SYMDFN) )
5269 {
5270 my_vbl_error(17,$2.NAME);
5271 }
5272 #endif
5273
5274 if ( ! $2.DYNAMIC )
5275 {
5276 if ( ( $2.LEFT == -1 ) &&
5277 ( $2.RIGHT == -1 ) )
5278 {
5279 Vex = createvexatombit( $2.NAME );
5280 }
5281 else
5282 {
5283 Vex = createvexatomvec( $2.NAME, $2.LEFT, $2.RIGHT );
5284 }
5285 }
5286 else
5287 {
5288 Vex = createvexatomvec( $2.NAME, -1, -1 );
5289 }
5290
5291 Chain = getvexatombitname( Vex );
5292 VBL_NM1LST = append( VBL_NM1LST, Chain );
5293 freevexexpr( Vex );
5294 }
5295 ;
5296
5297 sequence_of_statements
5298 :
5299 | sequence_of_statements
5300 sequential_statement
5301 ;
5302
5303 sequential_statement
5304 : assertion_statement
5305 | variable_assignment_statement
5306 | signal_assignment_statement
5307 | if_statement
5308 | case_statement
5309 | loop_statement
5310 | next_statement
5311 | exit_statement
5312 | return_statement
5313 | null_statement
5314 | procedure_call_statement
5315 | wait_statement
5316 ;
5317
5318 loop_statement
5319 : a_label
5320 {
5321 if ( chktab (hshtab,$1,VBL_MODNAM,VBL_SYMDFN) != 0)
5322 my_vbl_error (19,$1);
5323
5324 VBL_LOOPLBLLST = addchain(VBL_LOOPLBLLST,$1 );
5325 }
5326
5327 unlabeled_loop_statement
5328 |
5329 {
5330 char buffer[ 128 ];
5331
5332 VBL_LOOPNUM++;
5333 sprintf( buffer, "loop_%ld_%ld", VBL_LINNUM, VBL_LOOPNUM );
5334 VBL_LOOPLBLLST = addchain ( VBL_LOOPLBLLST, namealloc( buffer ) );
5335 }
5336 unlabeled_loop_statement
5337 ;
5338
5339 unlabeled_loop_statement
5340 : .iteration_scheme.
5341 LOOP
5342 {
5343 struct ptype **pnt;
5344 vbl_name *Range;
5345 vbvar_list *VbVar;
5346 char *LocalName;
5347 vexexpr *Target;
5348 short Signed;
5349 long Left;
5350 long Right;
5351 long AttrLeft;
5352 long AttrRight;
5353 char StrFlag;
5354 char ForUp;
5355
5356 pnt = (struct ptype**)VBL_INSLST->DATA;
5357 VBL_LOOPLBL = (char *)VBL_LOOPLBLLST->DATA;
5358
5359 if ( $1.IDENT != (char *)0 )
5360 {
5361 if ( VBL_FUNCNAM != (char *)0 )
5362 {
5363 LocalName = VBL_FUNCNAM;
5364 StrFlag = 'v';
5365 }
5366 else
5367 {
5368 LocalName = VBL_PROCNAM;
5369 StrFlag = 'V';
5370 }
5371
5372 Range = (vbl_name *)$1.VEX;
5373
5374 if ( Range->DYNAMIC )
5375 {
5376 if ( Range->DYNAMIC == VBL_UPTDFN ) ForUp = 1;
5377 else ForUp = 0;
5378
5379 AttrLeft = -1;
5380 AttrRight = -1;
5381 }
5382 else
5383 {
5384 AttrLeft = Range->LEFT;
5385 AttrRight = Range->RIGHT;
5386
5387 if ( AttrLeft <= AttrRight ) ForUp = 1;
5388 else ForUp = 0;
5389 }
5390
5391 if ( chktab( hshtab,$1.IDENT,LocalName,VBL_SYMDFN ) != 0 )
5392 {
5393 Target = (vexexpr *)chktab( hshtab, $1.IDENT, LocalName, VBL_PNTDFN );
5394 Signed = ( IsVexNodeSigned( Target ) != 0 );
5395 }
5396 else
5397 {
5398 VbVar = (vbvar_list *)vbl_addstr( StrFlag,0,
5399 get_type(VBH_TYPE_INTEGER),VBH_TYPE_INTEGER,
5400 'I',$1.IDENT, -1, -1, NULL, 0 ,0);
5401 Target = VbVar->TARGET;
5402 Signed = ( IsVexNodeSigned( VbVar->TARGET ) != 0 );
5403
5404 if ( IsVexAtomBit( VbVar->TARGET ) )
5405 {
5406 Left = -1;
5407 Right = -1;
5408 }
5409 else
5410 {
5411 Left = VbVar->TARGET->LEFT;
5412 Right = VbVar->TARGET->RIGHT;
5413 }
5414
5415 addtab( hshtab,$1.IDENT,LocalName,VBL_SYMDFN,VBL_VARDFN);
5416 addtab( hshtab,$1.IDENT,LocalName,VBL_TYPDFN,VBH_TYPE_INTEGER);
5417 addtab( hshtab,$1.IDENT,LocalName,VBL_WMNDFN,Left);
5418 addtab( hshtab,$1.IDENT,LocalName,VBL_WMXDFN,Right);
5419 addtab( hshtab,$1.IDENT,LocalName,VBL_ATLDFN,AttrLeft);
5420 addtab( hshtab,$1.IDENT,LocalName,VBL_ATRDFN,AttrRight);
5421 addtab( hshtab,$1.IDENT,LocalName,VBL_LBLDFN,0);
5422 addtab( hshtab,$1.IDENT,LocalName,VBL_PNTDFN,(long)VbVar->TARGET);
5423 addtab( hshtab,$1.IDENT,LocalName,VBL_SUNDFN,Signed);
5424 }
5425
5426 if ( ! Range->DYNAMIC )
5427 {
5428 Range->LEFT = (long)createvexatomlong( AttrLeft , 0, Signed );
5429 Range->RIGHT = (long)createvexatomlong( AttrRight, 0, Signed );
5430 }
5431
5432 *pnt = vbh_addvbfor(*pnt,VBL_LOOPLBL,dupvexexpr(Target),
5433 Range->LEFT,Range->RIGHT,ForUp, VBL_LINNUM );
5434
5435 VBL_INSLST = addchain( VBL_INSLST,
5436 &(((struct vbfor*)(*pnt)->DATA)->INSTRUCTION));
5437
5438 autfreeheap( Range, sizeof( vbl_name ) );
5439 }
5440 else
5441 if ( $1.VEX != (vexexpr *)0 )
5442 {
5443 *pnt = vbh_addvbwhi(*pnt,VBL_LOOPLBL,$1.VEX, VBL_LINNUM );
5444 VBL_INSLST = addchain( VBL_INSLST,
5445 &(((struct vbwhi*)(*pnt)->DATA)->INSTRUCTION));
5446 }
5447 else
5448 {
5449 *pnt = vbh_addvblop(*pnt,VBL_LOOPLBL, VBL_LINNUM );
5450 VBL_INSLST = addchain( VBL_INSLST,
5451 &(((struct vblop *)(*pnt)->DATA)->INSTRUCTION));
5452 }
5453 }
5454 sequence_of_statements
5455 END_ERR
5456 LOOP
5457 .label.
5458 Semicolon_ERR
5459 {
5460 struct ptype **pnt;
5461 struct ptype *ptype;
5462
5463 pnt = (struct ptype**)VBL_INSLST->DATA;
5464 ptype = reversetype(*pnt);
5465 *pnt = ptype;
5466
5467 if ( $7 != NULL )
5468 {
5469 if ( VBL_LOOPLBLLST->DATA != $7 )
5470 {
5471 my_vbl_error( 95, $7 );
5472 }
5473 }
5474
5475 VBL_INSLST = delchain( VBL_INSLST, VBL_INSLST);
5476 VBL_LOOPLBLLST = delchain( VBL_LOOPLBLLST, VBL_LOOPLBLLST );
5477 VBL_LOOPLBL = (char *)NULL;
5478 }
5479 ;
5480
5481 .iteration_scheme.
5482 : /*empty*/
5483 {
5484 $$ = vbl_crtvex( EMPTYOP,VBL_EMPSTR ,VBL_EMPSTR ,-1,-1,0);
5485 }
5486 | iteration_scheme
5487 {
5488 $$ = $1;
5489 }
5490 ;
5491
5492 iteration_scheme
5493 : WHILE
5494 expression
5495 {
5496 $$ = $2;
5497 }
5498 | FOR
5499 loop_parameter_specification
5500 {
5501 $$ = $2;
5502 }
5503 ;
5504
5505 loop_parameter_specification
5506 : Identifier
5507 _IN
5508 discrete_range
5509 {
5510 vbl_name *Range;
5511
5512 Range = (vbl_name *)autallocheap( sizeof( vbl_name ) );
5513 *Range = $3;
5514
5515 $$.IDENT = $1;
5516 $$.VEX = (vexexpr *)Range;
5517 }
5518 ;
5519
5520 wait_statement
5521 : WAIT
5522 {
5523 if ( ( VBL_BEPCS != NULL ) &&
5524 ( VBL_BEPCS->SENSITIVITY != NULL ) )
5525 {
5526 my_vbl_error(96,NULL);
5527 }
5528 }
5529 .sensitivity_clause.
5530 .condition_clause.
5531 .timeout_clause.
5532 Semicolon_ERR
5533 {
5534 struct ptype **pnt;
5535 struct ptype *ptptyp;
5536 struct vbwas *ptvbwas;
5537
5538 ptvbwas = vbh_addvbwas( VBL_NM1LST, $4.VEX, $5.TYPE,
5539 (vexexpr *)$5.NAME, VBL_LINNUM );
5540
5541 pnt = (struct ptype **) VBL_INSLST->DATA;
5542 ptptyp = addptype(*pnt, VBH_BEWAS, ptvbwas);
5543 *pnt = ptptyp;
5544 VBL_NM1LST = NULL;
5545 }
5546 ;
5547
5548 .sensitivity_clause.
5549 : /*empty*/
5550 { VBL_NM1LST = NULL;}
5551 | sensitivity_clause
5552 ;
5553
5554 sensitivity_clause
5555 : ON
5556 { VBL_NM1LST = NULL;}
5557 signal_list
5558 ;
5559
5560 .condition_clause.
5561 : /*empty*/
5562 { $$ = vbl_crtvex (EMPTYOP ,VBL_EMPSTR ,VBL_EMPSTR ,-1,-1,0); }
5563 | condition_clause
5564 {
5565 $$ = $1;
5566 }
5567 ;
5568
5569 condition_clause
5570 : UNTIL
5571 expression
5572 {
5573 $$ = $2;
5574 }
5575 ;
5576
5577 .timeout_clause.
5578 : /*empty*/
5579 {
5580 $$.NAME = NULL;
5581 $$.LEFT = 0;
5582 $$.RIGHT = 0;
5583 $$.FLAG = 0;
5584 $$.TYPE = 0;
5585 $$.DYNAMIC = 0;
5586 $$.AGGREG = 0;
5587 }
5588 | timeout_clause
5589 {
5590 $$ = $1;
5591 }
5592 ;
5593
5594 timeout_clause
5595 : FOR
5596 simple_expression
5597 time_label
5598 {
5599 $$.NAME = (char *)$2.VEX;
5600 $$.TYPE = $3;
5601 $$.FLAG = 0;
5602 $$.SIGNED = 0;
5603 $$.LEFT = 0;
5604 $$.RIGHT = 0;
5605 $$.AGGREG = 0;
5606 $$.DYNAMIC = 1;
5607
5608 viewvexexprboundln( $2.VEX );
5609 fprintf( stdout, " %ld\n", $3 );
5610 }
5611 ;
5612
5613 time_label
5614 : _FS
5615 {
5616 $$ = VBH_TIME_UNIT_FS;
5617 }
5618 | _PS
5619 {
5620 $$ = VBH_TIME_UNIT_PS;
5621 }
5622 | _NS
5623 {
5624 $$ = VBH_TIME_UNIT_NS;
5625 }
5626 | _MS
5627 {
5628 $$ = VBH_TIME_UNIT_MS;
5629 }
5630 ;
5631
5632 next_statement
5633 : _NEXT
5634 .label.
5635 .WHEN__condition.
5636 Semicolon_ERR
5637 {
5638 struct vbnxt *ptvbnxt;
5639 struct ptype **pnt;
5640
5641 pnt = (struct ptype**)VBL_INSLST->DATA;
5642 ptvbnxt = vbh_addvbnxt($2, $3.VEX,VBL_LINNUM);
5643 *pnt = addptype( *pnt, VBH_BENXT, ptvbnxt );
5644 }
5645 ;
5646
5647 exit_statement
5648 : _EXIT
5649 .label.
5650 .WHEN__condition.
5651 Semicolon_ERR
5652 {
5653 struct vbext *ptvbext;
5654 struct ptype **pnt;
5655
5656 pnt = (struct ptype**)VBL_INSLST->DATA;
5657 ptvbext = vbh_addvbext($2, $3.VEX,VBL_LINNUM);
5658 *pnt = addptype( *pnt, VBH_BEEXT, ptvbext );
5659 }
5660 ;
5661
5662 .WHEN__condition.
5663 : /*empty*/
5664 { $$.VEX = (vexexpr *)0; }
5665 | WHEN
5666 condition
5667 { $$ = $2; }
5668 ;
5669
5670 return_statement
5671 : _RETURN
5672 .expression.
5673 Semicolon_ERR
5674 {
5675 struct vbret *ptvbret;
5676 struct ptype **pnt;
5677
5678 if ( VBL_FUNCNAM == (char *)0 )
5679 {
5680 my_vbl_error(120,NULL);
5681 }
5682
5683 pnt = (struct ptype**)VBL_INSLST->DATA;
5684 ptvbret = vbh_addvbret($2.VEX,VBL_LINNUM);
5685 *pnt = addptype( *pnt, VBH_BERET, ptvbret );
5686 }
5687 ;
5688
5689 .expression.
5690 : /*empty*/
5691 { $$.VEX = (vexexpr *)0; }
5692 | expression
5693 { $$ = $1; }
5694 ;
5695
5696 assertion_statement
5697 : ASSERT
5698 expression
5699 .REPORT__expression.
5700 .SEVERITY__expression.
5701 Semicolon_ERR
5702 { }
5703 ;
5704
5705 variable_assignment_statement
5706 : target
5707 VarAsgn
5708 expression
5709 Semicolon_ERR
5710 {
5711 unsigned long type;
5712 char *codedsigname;
5713 long mode;
5714 long left ,right;
5715 long left_bnd ,right_bnd;
5716 char buffer[128];
5717 struct ptype **pnt;
5718 vexexpr *vex;
5719 char *LocalName = NULL;
5720 vbl_vexstr *VexStr;
5721 vbl_vexstr *VexStr2;
5722 chain_list *ScanChain;
5723 chain_list *ScanChain2;
5724 ptype_list *AsgList;
5725 unsigned char dynamic;
5726
5727 if ( $1.AGGREG )
5728 {
5729 if ( ! $3.AGGREG )
5730 {
5731 my_vbl_error(114,NULL);
5732 }
5733
5734 ScanChain = (chain_list *)$1.NAME;
5735 ScanChain2 = (chain_list *)$3.IDENT;
5736 AsgList = (ptype_list *)0;
5737
5738 while ( ( ScanChain != (chain_list *)0 ) &&
5739 ( ScanChain2 != (chain_list *)0 ) )
5740 {
5741 VexStr = (vbl_vexstr *)ScanChain->DATA;
5742 VexStr2 = (vbl_vexstr *)ScanChain2->DATA;
5743
5744 AsgList = vbh_addvbvar( AsgList, VexStr->VEX,
5745 simpvexexprothers( VexStr2->VEX, VexStr->VEX->WIDTH ),
5746 get_type(VexStr->TYPE), VBL_LINNUM );
5747
5748 autfreeheap( VexStr , sizeof( vbl_vexstr ) );
5749 autfreeheap( VexStr2, sizeof( vbl_vexstr ) );
5750
5751 ScanChain = ScanChain ->NEXT;
5752 ScanChain2 = ScanChain2->NEXT;
5753 }
5754
5755 if ( ( ScanChain != (chain_list *)0 ) ||
5756 ( ScanChain2 != (chain_list *)0 ) )
5757 {
5758 my_vbl_error(114,NULL);
5759 }
5760
5761 freechain( (chain_list *)$1.NAME );
5762 freechain( (chain_list *)$3.IDENT );
5763
5764 pnt = (struct ptype**)(VBL_INSLST->DATA);
5765 *pnt = (struct ptype *)vbh_addvbagr(*pnt, AsgList, VBL_LINNUM );
5766 }
5767 else
5768 {
5769 if ( chktab(hshtab,$1.NAME,VBL_FUNCNAM,VBL_SYMDFN ) )
5770 {
5771 LocalName = VBL_FUNCNAM;
5772 }
5773 else
5774 if ( chktab(hshtab,$1.NAME,VBL_PROCNAM,VBL_SYMDFN ) )
5775 {
5776 LocalName = VBL_PROCNAM;
5777 }
5778 else
5779 {
5780 my_vbl_error(27,$1.NAME);
5781 }
5782
5783 sprintf (buffer, "%s.cod.%s", LocalName, $1.NAME);
5784 codedsigname = namealloc( buffer );
5785
5786 type = chktab(hshtab,codedsigname,LocalName,VBL_TYPDFN);
5787
5788 if ( type >= VBH_MAX_TYPE )
5789 {
5790 mode = chktab(hshtab,$1.NAME,LocalName,VBL_SYMDFN);
5791 dynamic = chktab( hshtab, $1.NAME, LocalName, VBL_DYNDFN );
5792 left = $1.LEFT;
5793 right = $1.RIGHT;
5794 }
5795 else
5796 {
5797 type = chktab(hshtab,$1.NAME,LocalName,VBL_TYPDFN);
5798 mode = chktab(hshtab,$1.NAME,LocalName,VBL_SYMDFN);
5799 dynamic = chktab( hshtab, $1.NAME, LocalName, VBL_DYNDFN );
5800
5801 left = $1.LEFT;
5802 right = $1.RIGHT;
5803 }
5804
5805 if ( ! $1.DYNAMIC )
5806 {
5807 if ( ( $1.LEFT == -1 ) &&
5808 ( $1.RIGHT == -1 ) )
5809 {
5810 vex = createvexatombit( $1.NAME );
5811 }
5812 else
5813 {
5814 vex = createvexatomvec( $1.NAME, $1.LEFT, $1.RIGHT );
5815 }
5816 }
5817 else
5818 {
5819 left_bnd = chktab (hshtab,$1.NAME,LocalName,VBL_WMNDFN);
5820 right_bnd = chktab (hshtab,$1.NAME,LocalName,VBL_WMXDFN);
5821
5822 vex = vbl_dynamicvexatom( $1.NAME, left_bnd, right_bnd, dynamic );
5823
5824 if ( right == 0 )
5825 {
5826 vex = createvexbinexpr( VEX_INDEX, 1, vex, (vexexpr *)left );
5827 }
5828 else
5829 {
5830 if ( ( mode == VBL_FUNDFN ) ||
5831 ( mode == VBL_TPEDFN ) ||
5832 ( mode == VBL_PRODFN ) )
5833 {
5834 vex = (vexexpr *)left;
5835 }
5836 else
5837 if ( $1.DYNAMIC == VBL_UPTDFN )
5838 {
5839 if ( ( ! dynamic ) ||
5840 ( ! isvexequalexpr( (vexexpr *)left_bnd, (vexexpr *)left ) ) ||
5841 ( ! isvexequalexpr( (vexexpr *)right_bnd, (vexexpr *)right ) ) )
5842 {
5843 vex = createvexternaryexpr( VEX_TO, 1, vex,
5844 (vexexpr *)left, (vexexpr *)right );
5845 }
5846 }
5847 else
5848 if ( $1.DYNAMIC == VBL_DWTDFN )
5849 {
5850 if ( ( ! dynamic ) ||
5851 ( ! isvexequalexpr( (vexexpr *)left_bnd, (vexexpr *)left ) ) ||
5852 ( ! isvexequalexpr( (vexexpr *)right_bnd, (vexexpr *)right ) ) )
5853 {
5854 vex = createvexternaryexpr( VEX_DOWNTO, 1, vex,
5855 (vexexpr *)left, (vexexpr *)right );
5856 }
5857 }
5858 else
5859 {
5860 vex = createvexbinexpr( VEX_INDEX_N, 1, vex, (vexexpr *)left );
5861 vex = createvexbinexpr( VEX_INDEX_N, 1, vex, (vexexpr *)right );
5862 }
5863 }
5864 }
5865
5866 pnt = (struct ptype**)(VBL_INSLST->DATA);
5867 *pnt = (struct ptype *)vbh_addvbvar(*pnt,vex,
5868 simpvexexprothers( $3.VEX, vex->WIDTH ),get_type(type),VBL_LINNUM);
5869 }
5870 }
5871 ;
5872
5873 procedure_call_statement
5874 : name
5875 Semicolon_ERR
5876 {
5877 struct vbcal *ptvbcal;
5878 struct ptype **pnt;
5879 vexexpr *VexFunc;
5880
5881 pnt = (struct ptype**)VBL_INSLST->DATA;
5882
5883 if ( chktab( hshtab,$1.NAME,VBL_MODNAM,VBL_SYMDFN) != VBL_PRODFN )
5884 {
5885 my_vbl_error(119,$1.NAME);
5886 }
5887
5888 if ( ! $1.DYNAMIC ) VexFunc = createvexfunc( $1.NAME, 0 );
5889 else VexFunc = (vexexpr *)$1.LEFT;
5890
5891 ptvbcal = vbh_addvbcal( VexFunc, VBL_LINNUM );
5892 *pnt = addptype( *pnt, VBH_BECAL, ptvbcal );
5893 }
5894 ;
5895
5896 signal_assignment_statement
5897 : target
5898 _LESym
5899 waveform
5900 Semicolon_ERR
5901 {
5902 unsigned long type;
5903 long mode;
5904 char buffer[128];
5905 char *codedsigname;
5906 char *LocalName = NULL;
5907 long left ,right;
5908 long left_bnd ,right_bnd;
5909 struct ptype **pnt;
5910 vexexpr *vex;
5911 vbl_vexstr *VexStr;
5912 vbl_vexstr *VexStr2;
5913 chain_list *ScanChain;
5914 chain_list *ScanChain2;
5915 ptype_list *AsgList;
5916 unsigned char dynamic;
5917
5918 if ( $1.AGGREG )
5919 {
5920 if ( ! $3.AGGREG )
5921 {
5922 my_vbl_error(114,NULL);
5923 }
5924
5925 ScanChain = (chain_list *)$1.NAME;
5926 ScanChain2 = (chain_list *)$3.IDENT;
5927 AsgList = (ptype_list *)0;
5928
5929 while ( ( ScanChain != (chain_list *)0 ) &&
5930 ( ScanChain2 != (chain_list *)0 ) )
5931 {
5932 VexStr = (vbl_vexstr *)ScanChain->DATA;
5933 VexStr2 = (vbl_vexstr *)ScanChain2->DATA;
5934
5935 AsgList = vbh_addvbasg( AsgList, VexStr->VEX,
5936 simpvexexprothers( VexStr2->VEX, VexStr->VEX->WIDTH ),
5937 get_type(VexStr->TYPE), VBL_LINNUM );
5938
5939 autfreeheap( VexStr , sizeof( vbl_vexstr ) );
5940 autfreeheap( VexStr2, sizeof( vbl_vexstr ) );
5941
5942 ScanChain = ScanChain ->NEXT;
5943 ScanChain2 = ScanChain2->NEXT;
5944 }
5945
5946 if ( ( ScanChain != (chain_list *)0 ) ||
5947 ( ScanChain2 != (chain_list *)0 ) )
5948 {
5949 my_vbl_error(114,NULL);
5950 }
5951
5952 freechain( (chain_list *)$1.NAME );
5953 freechain( (chain_list *)$3.IDENT );
5954
5955 pnt = (struct ptype**)(VBL_INSLST->DATA);
5956 *pnt = (struct ptype *)vbh_addvbagr(*pnt, AsgList, VBL_LINNUM );
5957 }
5958 else
5959 {
5960 if ( chktab(hshtab,$1.NAME,VBL_FUNCNAM,VBL_SYMDFN ) )
5961 {
5962 LocalName = VBL_FUNCNAM;
5963 }
5964 else
5965 if ( chktab(hshtab,$1.NAME,VBL_MODNAM,VBL_SYMDFN ) )
5966 {
5967 LocalName = VBL_MODNAM;
5968 }
5969 else
5970 {
5971 my_vbl_error(17,$1.NAME);
5972 }
5973
5974 sprintf (buffer, "%s.cod.%s", LocalName, $1.NAME);
5975 codedsigname = namealloc( buffer );
5976
5977 type = chktab(hshtab,codedsigname,LocalName,VBL_TYPDFN);
5978
5979 if ( type >= VBH_MAX_TYPE )
5980 {
5981 mode = chktab(hshtab,$1.NAME,LocalName,VBL_SYMDFN);
5982 dynamic = chktab(hshtab,$1.NAME,LocalName,VBL_DYNDFN);
5983 left = $1.LEFT;
5984 right = $1.RIGHT;
5985 }
5986 else
5987 {
5988 type = chktab(hshtab,$1.NAME,LocalName,VBL_TYPDFN);
5989 mode = chktab(hshtab,$1.NAME,LocalName,VBL_SYMDFN);
5990 dynamic = chktab(hshtab,$1.NAME,LocalName,VBL_DYNDFN);
5991
5992 left = $1.LEFT;
5993 right = $1.RIGHT;
5994 }
5995
5996 if( mode == VBL_ICNDFN) my_vbl_error(21,$1.NAME);
5997 if( mode == 0 ) my_vbl_error(17,$1.NAME);
5998
5999 if ( ! $1.DYNAMIC )
6000 {
6001 if ( ( $1.LEFT == -1 ) &&
6002 ( $1.RIGHT == -1 ) )
6003 {
6004 vex = createvexatombit( $1.NAME );
6005 }
6006 else
6007 {
6008 vex = createvexatomvec( $1.NAME, $1.LEFT, $1.RIGHT );
6009 }
6010 }
6011 else
6012 {
6013 left_bnd = chktab (hshtab,$1.NAME,LocalName,VBL_WMNDFN);
6014 right_bnd = chktab (hshtab,$1.NAME,LocalName,VBL_WMXDFN);
6015
6016 vex = vbl_dynamicvexatom( $1.NAME, left_bnd, right_bnd, dynamic );
6017
6018 if ( right == 0 )
6019 {
6020 vex = createvexbinexpr( VEX_INDEX, 1, vex, (vexexpr *)left );
6021 }
6022 else
6023 {
6024 if ( ( mode == VBL_FUNDFN ) ||
6025 ( mode == VBL_TPEDFN ) ||
6026 ( mode == VBL_PRODFN ) )
6027 {
6028 vex = (vexexpr *)left;
6029 }
6030 else
6031 if ( $1.DYNAMIC == VBL_UPTDFN )
6032 {
6033 if ( ( ! dynamic ) ||
6034 ( ! isvexequalexpr( (vexexpr *)left_bnd, (vexexpr *)left ) ) ||
6035 ( ! isvexequalexpr( (vexexpr *)right_bnd, (vexexpr *)right ) ) )
6036 {
6037 vex = createvexternaryexpr( VEX_TO, 1, vex,
6038 (vexexpr *)left, (vexexpr *)right );
6039 }
6040 }
6041 else
6042 if ( $1.DYNAMIC == VBL_DWTDFN )
6043 {
6044 if ( ( ! dynamic ) ||
6045 ( ! isvexequalexpr( (vexexpr *)left_bnd, (vexexpr *)left ) ) ||
6046 ( ! isvexequalexpr( (vexexpr *)right_bnd, (vexexpr *)right ) ) )
6047 {
6048 vex = createvexternaryexpr( VEX_DOWNTO, 1, vex,
6049 (vexexpr *)left, (vexexpr *)right );
6050 }
6051 }
6052 else
6053 {
6054 vex = createvexbinexpr( VEX_INDEX_N, 1, vex, (vexexpr *)left );
6055 vex = createvexbinexpr( VEX_INDEX_N, 1, vex, (vexexpr *)right );
6056 }
6057 }
6058 }
6059
6060 pnt = (struct ptype**)(VBL_INSLST->DATA);
6061 *pnt = (struct ptype *)vbh_addvbasg(*pnt,vex,
6062 simpvexexprothers($3.VEX, vex->WIDTH ),get_type(type), VBL_LINNUM );
6063 }
6064 }
6065 ;
6066
6067 waveform_element
6068 : expression
6069 .AFTER__delay_expression.
6070 {
6071 $$ = $1;
6072 }
6073 ;
6074
6075 .AFTER__delay_expression.
6076 : /*empty*/
6077 { }
6078 | AFTER
6079 delay_expression
6080 {
6081 my_vbl_warning( 0, "after clauses ignored !" );
6082 }
6083 ;
6084
6085 delay_expression
6086 : AbstractLit
6087 time_label
6088 { }
6089 ;
6090
6091 if_statement
6092 : IF
6093 condition
6094 THEN
6095 {
6096 struct ptype **pnt;
6097
6098 pnt = (struct ptype**)VBL_INSLST->DATA;
6099 *pnt = vbh_addvbifs( *pnt,$2.VEX, VBL_LINNUM );
6100 VBL_INSLST = addchain(VBL_INSLST,&(((struct vbifs*)(*pnt)->DATA)->CNDTRUE));
6101 }
6102 sequence_of_statements
6103 {
6104 struct ptype **pnt;
6105 struct ptype *ptype;
6106
6107 pnt = (struct ptype**)VBL_INSLST->DATA;
6108 ptype = reversetype(*pnt);
6109 *pnt = ptype;
6110 VBL_INSLST = delchain (VBL_INSLST, VBL_INSLST);
6111 pnt = (struct ptype**)VBL_INSLST->DATA;
6112 VBL_INSLST = addchain(VBL_INSLST,&(((struct vbifs*)(*pnt)->DATA)->CNDFALSE));
6113 }
6114 ..ELSIF__THEN__seq_of_stmts..
6115 .ELSE__seq_of_stmts.
6116 END_ERR
6117 IF
6118 Semicolon_ERR
6119 ;
6120
6121 ..ELSIF__THEN__seq_of_stmts..
6122 : /*empty*/
6123 | ..ELSIF__THEN__seq_of_stmts..
6124 ELSIF
6125 condition
6126 THEN
6127 {
6128 struct ptype **pnt;
6129
6130 pnt = (struct ptype**)VBL_INSLST->DATA;
6131 *pnt = vbh_addvbifs(*pnt,$3.VEX, VBL_LINNUM );
6132 VBL_INSLST = addchain(VBL_INSLST,(void*)&((struct vbifs*)(*pnt)->DATA)->CNDTRUE);
6133 }
6134 sequence_of_statements
6135 {
6136 struct ptype **pnt;
6137 struct ptype *ptype;
6138
6139 pnt = (struct ptype**)VBL_INSLST->DATA;
6140 ptype = reversetype(*pnt);
6141 *pnt = ptype;
6142 VBL_INSLST = delchain (VBL_INSLST, VBL_INSLST);
6143 pnt = (struct ptype**)VBL_INSLST->DATA;
6144 VBL_INSLST = delchain (VBL_INSLST, VBL_INSLST);
6145 VBL_INSLST = addchain(VBL_INSLST,&((struct vbifs*)(*pnt)->DATA)->CNDFALSE);
6146 }
6147 ;
6148
6149 .ELSE__seq_of_stmts.
6150 : /*empty*/
6151 {
6152 VBL_INSLST = delchain (VBL_INSLST, VBL_INSLST);
6153 yyerrok;
6154 }
6155 | ELSE
6156 sequence_of_statements
6157 {
6158 struct ptype *ptype;
6159 struct ptype **pnt;
6160 pnt = (struct ptype**)VBL_INSLST->DATA;
6161 ptype = reversetype(*pnt);
6162 *pnt = ptype;
6163 VBL_INSLST = delchain (VBL_INSLST, VBL_INSLST);
6164 yyerrok;
6165 }
6166 ;
6167
6168 case_statement
6169 : CASE
6170 expression
6171 {
6172 struct ptype **pnt;
6173
6174 pnt = (struct ptype**)VBL_INSLST->DATA;
6175
6176 VBL_OTHPNT = NULL;
6177 VBL_CASPNT = NULL;
6178 VBL_CASSIZE = $2.WIDTH - 1;
6179
6180 *pnt = vbh_addvbcas(*pnt,$2.VEX,get_type($2.TYPE), VBL_LINNUM );
6181
6182 VBL_INSLST = addchain( VBL_INSLST,(void*)&(((struct vbcas*)((*pnt)->DATA))->SIZE));
6183 VBL_INSLST = addchain( VBL_INSLST,(void*)&(((struct vbcas*)(*pnt)->DATA)->CHOICE));
6184 }
6185 IS
6186 case_statement_alternative
6187 ..case_statement_alternative..
6188 END_ERR
6189 CASE
6190 Semicolon_ERR
6191 {
6192 unsigned long size=0;
6193 unsigned long *size1;
6194 long indice=0;
6195 struct choice_chain *ch;
6196 struct vbcho **pnt;
6197 struct vbcho *tab = NULL;
6198 struct choice_chain *nm1lst;
6199
6200
6201 nm1lst = VBL_CASPNT;
6202 while (nm1lst != NULL)
6203 {
6204 size++;
6205 nm1lst = nm1lst->NEXT;
6206 }
6207 if ( VBL_OTHPNT != NULL ) size++;
6208
6209 pnt = (struct vbcho**)VBL_INSLST->DATA;
6210 VBL_INSLST = delchain(VBL_INSLST,VBL_INSLST);
6211
6212 if( size != 0)
6213 tab = (struct vbcho*)autallocblock(size*sizeof(struct vbcho));
6214
6215 while(VBL_CASPNT)
6216 {
6217 tab[indice].INSTRUCTION = reversetype(VBL_CASPNT->INSTRUCTION);
6218 tab[indice].SIZE = VBL_CASPNT->SIZE;
6219 tab[indice++].VALUES = VBL_CASPNT->VALUES;
6220 ch = VBL_CASPNT;
6221 VBL_CASPNT =VBL_CASPNT->NEXT;
6222 autfreeblock( ch );
6223 /*free(ch);*/
6224 }
6225 if ( VBL_OTHPNT != NULL )
6226 {
6227 tab[indice].INSTRUCTION = reversetype(VBL_OTHPNT);
6228 tab[indice].SIZE = -1;
6229 tab[indice++].VALUES = addchain( NULL, namealloc("others") );
6230 }
6231 (*pnt) = tab;
6232 size1 = (unsigned long*) VBL_INSLST->DATA;
6233 *size1 = size;
6234 VBL_INSLST = delchain(VBL_INSLST,VBL_INSLST);
6235 }
6236 ;
6237
6238 ..case_statement_alternative..
6239 : /*empty*/
6240 | ..case_statement_alternative..
6241 case_statement_alternative
6242 { yyerrok; }
6243 ;
6244
6245 case_statement_alternative
6246 : WHEN
6247 choices
6248 Arrow
6249 {
6250 VBL_PTYPE = NULL;
6251 VBL_INSLST = addchain(VBL_INSLST,(void*)&VBL_PTYPE);
6252 }
6253 sequence_of_statements
6254 {
6255 if( VBL_CNDLST == NULL)
6256 my_vbl_error(85,"case");
6257 else
6258 if ( VBL_CNDLST->DATA == NULL)
6259 {
6260 VBL_OTHPNT = VBL_PTYPE ;
6261 VBL_CNDLST = delchain(VBL_CNDLST,VBL_CNDLST);
6262 }
6263 else
6264 {
6265 struct choice_chain *NewChoice;
6266 char *Value;
6267 long Length;
6268
6269 NewChoice = (struct choice_chain*)autallocblock(sizeof(struct choice_chain));
6270 NewChoice->VALUES = (chain_list *)0;
6271 NewChoice->SIZE = 0;
6272 NewChoice->INSTRUCTION = VBL_PTYPE;
6273
6274 NewChoice->NEXT = VBL_CASPNT;
6275 VBL_CASPNT = NewChoice;
6276
6277 while(VBL_CNDLST)
6278 {
6279 Value = (char *)VBL_CNDLST->DATA;
6280 Length = strlen( Value );
6281
6282 NewChoice->VALUES = addchain( NewChoice->VALUES, (void *)Value );
6283 if ( NewChoice->SIZE < Length ) NewChoice->SIZE = Length;
6284
6285 VBL_CNDLST = delchain(VBL_CNDLST,VBL_CNDLST);
6286 }
6287 }
6288 VBL_INSLST = delchain(VBL_INSLST,VBL_INSLST);
6289 }
6290 ;
6291
6292 waveform
6293 : waveform_element
6294 { $$ = $1; }
6295 ;
6296
6297 choices
6298 : choice
6299 {
6300 VBL_LINLST = addchain (VBL_LINLST, (void *)VBL_LINNUM );
6301
6302 if ( ! strcmp($1.NAME , "others"))
6303 {
6304 VBL_CNDLST = addchain (VBL_CNDLST,NULL);
6305 }
6306 else
6307 {
6308 VBL_CNDLST = addchain (VBL_CNDLST,(void*)$1.NAME);
6309 }
6310
6311 VBL_NUMCHOICE = 1;
6312 }
6313 ..Bar__choice..
6314 { yyerrok; }
6315 ;
6316
6317 null_statement
6318 : tok_NULL
6319 Semicolon_ERR {}
6320 ;
6321
6322 ..Bar__choice..
6323 : /*empty*/
6324 | ..Bar__choice..
6325 Bar
6326 choice
6327 {
6328 VBL_NUMCHOICE++;
6329
6330 if ((!strcmp($3.NAME , "others")) || (VBL_CNDLST->DATA == NULL))
6331 my_vbl_error (31,NULL);
6332
6333 VBL_CNDLST = addchain (VBL_CNDLST ,(void*)$3.NAME);
6334 VBL_LINLST = addchain (VBL_LINLST ,(void *)VBL_LINNUM );
6335 }
6336 ;
6337
6338 choice
6339 : literal
6340 {
6341 char Buffer[ 512 ];
6342
6343 /* hack */
6344 char delim = '"';
6345 char* scan = strchr($1, '\'');
6346 if (scan) delim = '\'';
6347 Buffer[ 0 ] = delim;
6348 vbl_tobin( &Buffer[1],$1,0,VBL_CASSIZE );
6349 Buffer[ VBL_CASSIZE + 2 ] = delim;
6350 Buffer[ VBL_CASSIZE + 3 ] = '\0';
6351
6352 $$.NAME = namealloc( Buffer );
6353 $$.RIGHT = -1;
6354 $$.TYPE = -1;
6355 $$.LEFT = -1;
6356 $$.DYNAMIC = 0;
6357 $$.AGGREG = 0;
6358 }
6359
6360 | OTHERS
6361 {
6362 $$.RIGHT = -1;
6363 $$.TYPE = -1;
6364 $$.LEFT = -1;
6365 $$.DYNAMIC = 0;
6366 $$.AGGREG = 0;
6367 $$.NAME = namealloc("others");
6368 }
6369 | name
6370 {
6371 vexexpr *VexCst;
6372 long left;
6373 long right;
6374 long left_bnd;
6375 long right_bnd;
6376 long sig_conf;
6377
6378 if ( ( $1.NAME[0] == '"' ) || ( $1.NAME[0] == '\'') )
6379 {
6380 $$.NAME = $1.NAME;
6381 $$.LEFT = -1;
6382 $$.RIGHT = -1;
6383 $$.TYPE = -1;
6384 $$.DYNAMIC = 0;
6385 $$.AGGREG = 0;
6386 }
6387 else
6388 {
6389 sig_conf = chktab (hshtab,$1.NAME,VBL_MODNAM,VBL_SYMDFN);
6390 VexCst = (vexexpr *)chktab (hshtab,$1.NAME,VBL_MODNAM,VBL_PNTDFN);
6391
6392 if (sig_conf == 0)
6393 {
6394 my_vbl_error (17,$1.NAME);
6395 }
6396 else
6397 if (sig_conf != VBL_CSTDFN)
6398 {
6399 my_vbl_error (76,$1.NAME);
6400 }
6401
6402 left_bnd = chktab (hshtab,$1.NAME,VBL_MODNAM,VBL_WMNDFN);
6403 right_bnd = chktab (hshtab,$1.NAME,VBL_MODNAM,VBL_WMXDFN);
6404
6405 left = $1.LEFT;
6406 right = $1.RIGHT;
6407
6408 if (left_bnd <= right_bnd)
6409 {
6410 if (left <= right)
6411 {
6412 //in_bound = left - left_bnd;
6413 //out_bound = right - left_bnd;
6414 if ((left < left_bnd) || (right > right_bnd))
6415 {
6416 my_vbl_error (36,$1.NAME);
6417 }
6418 }
6419 else
6420 {
6421 //in_bound = left - right_bnd;
6422 //out_bound = right - right_bnd;
6423 if ((left > right_bnd) || (right < left_bnd))
6424 {
6425 my_vbl_error (36,$1.NAME);
6426 }
6427 }
6428 }
6429 else
6430 {
6431 if (left <= right)
6432 {
6433 //in_bound = right - left_bnd;
6434 //out_bound = left - left_bnd;
6435 if ((left < right_bnd) || (right > left_bnd))
6436 {
6437 my_vbl_error (36,$1.NAME);
6438 }
6439 }
6440 else
6441 {
6442 //in_bound = right - right_bnd;
6443 //out_bound = left - right_bnd;
6444 if ((left > left_bnd) || (right < right_bnd))
6445 {
6446 my_vbl_error (36,$1.NAME);
6447 }
6448 }
6449 }
6450
6451 $$.NAME = GetVexAtomValue( VexCst );
6452 $$.LEFT = -1;
6453 $$.RIGHT = -1;
6454 $$.TYPE = -1;
6455 $$.DYNAMIC = 0;
6456 $$.AGGREG = 0;
6457 }
6458 }
6459 ;
6460
6461 condition
6462 : expression
6463 { $$ = $1; }
6464 ;
6465
6466 .REPORT__expression.
6467 : /*empty*/
6468 { $$ = NULL;}
6469 | REPORT
6470 report__message
6471 { $$ = $2;}
6472 ;
6473
6474 .SEVERITY__expression.
6475 : /*empty*/
6476 { $$ = 'E';}
6477 | SEVERITY
6478 severity__message
6479 { $$ = $1;}
6480 ;
6481
6482 report__message
6483 : StringLit
6484 { $$ = $1; }
6485 ;
6486
6487 severity__message
6488 : ERROR
6489 { $$ = 'E';}
6490 | WARNING
6491 { $$ = 'W';}
6492 ;
6493
6494 expression
6495 : relation..AND__relation..
6496 { $$ = $1; }
6497 | relation..OR__relation..
6498 { $$ = $1; }
6499 | relation.NAND_NOR_NXOR_relation.
6500 { $$ = $1; }
6501 | relation..XOR__relation..
6502 { $$ = $1; }
6503 ;
6504
6505 relation..AND__relation..
6506 : relation
6507 tok_AND
6508 relation
6509 { $$ = vbl_crtvex (VEX_AND ,$1 ,$3 ,-1,-1,0); }
6510 | relation..AND__relation..
6511 tok_AND
6512 relation
6513 { $$ = vbl_crtvex (VEX_AND ,$1 ,$3 ,-1,-1,0);}
6514 ;
6515
6516 relation..OR__relation..
6517 : relation
6518 _OR
6519 relation
6520 { $$ = vbl_crtvex (VEX_OR ,$1 ,$3 ,-1,-1,0); }
6521 | relation..OR__relation..
6522 _OR
6523 relation
6524 { $$ = vbl_crtvex (VEX_OR ,$1 ,$3 ,-1,-1,0); }
6525 ;
6526
6527 relation.NAND_NOR_NXOR_relation.
6528 : relation
6529 { $$ = $1; }
6530 | relation
6531 _NAND
6532 relation
6533 { $$ = vbl_crtvex (VEX_NAND ,$1 ,$3 ,-1,-1,0); }
6534 | relation
6535 _NOR
6536 relation
6537 { $$ = vbl_crtvex (VEX_NOR ,$1 ,$3 ,-1,-1,0); }
6538 | relation
6539 _NXOR
6540 relation
6541 { $$ = vbl_crtvex (VEX_NXOR ,$1 ,$3 ,-1,-1,0); }
6542 | relation
6543 _IFT
6544 relation
6545 { $$ = vbl_crtvex (VEX_IFT,$1 ,$3 ,-1,-1,0); }
6546 ;
6547
6548 relation..XOR__relation..
6549 : relation
6550 _XOR
6551 relation
6552 { $$ = vbl_crtvex (VEX_XOR ,$1 ,$3 ,-1,-1,0); }
6553 | relation..XOR__relation..
6554 _XOR
6555 relation
6556 { $$ = vbl_crtvex (VEX_XOR ,$1 ,$3 ,-1,-1,0); }
6557 ;
6558
6559 relation
6560 : simple_expression
6561 { $$ = $1; }
6562 | simple_expression
6563 relational_operator
6564 simple_expression
6565 { $$ = vbl_crtvex ($2 ,$1 ,$3 ,-1,-1,0); }
6566 ;
6567
6568 simple_expression
6569 : .sign.term..add_op__term..
6570 { $$ = $1; }
6571 ;
6572
6573 .sign.term..add_op__term..
6574 : term
6575 { $$ = $1; }
6576 | sign
6577 term
6578 { if ( $1 == VEX_NEG )
6579 {
6580 $$ = vbl_crtvex( VEX_NEG,$2,VBL_EMPSTR,-1,-1,0);
6581 }
6582 else
6583 {
6584 $$ = $2;
6585 }
6586 }
6587 | .sign.term..add_op__term..
6588 adding_operator
6589 term
6590 { $$ = vbl_crtvex($2,$1,$3,-1,-1,0); }
6591 ;
6592
6593 adding_operator
6594 : Plus
6595 { $$ = VEX_ADD; }
6596 | Minus
6597 { $$ = VEX_SUB; }
6598 | Ampersand
6599 { $$ = VEX_CONCAT; }
6600 ;
6601 sign
6602 : Plus
6603 { $$ = 0; }
6604 | Minus
6605 { $$ = VEX_NEG; }
6606 ;
6607
6608 multiplying_operator
6609 : Star
6610 { $$ = VEX_MUL; }
6611 | Slash
6612 { $$ = VEX_DIV; }
6613 | MOD
6614 { $$ = VEX_MOD; }
6615 | REM
6616 { $$ = VEX_REM; }
6617 ;
6618
6619 term
6620 : factor
6621 { $$ = $1; }
6622 | term
6623 multiplying_operator
6624 factor
6625 { $$ = vbl_crtvex( $2, $1, $3,-1,-1,0); }
6626 ;
6627
6628 factor
6629 : primary
6630 { $$ = $1; }
6631 | primary
6632 DoubleStar
6633 primary
6634 { $$ = vbl_crtvex( VEX_EXP,$1,$3,-1,-1,0); }
6635 | ABS
6636 primary
6637 {
6638 $$ = vbl_crtvex( VEX_ABS,$2,VBL_EMPSTR,-1,-1,0);
6639 }
6640 | _NOT
6641 primary
6642 { $$ = vbl_crtvex( VEX_NOT,$2,VBL_EMPSTR,-1,-1,0); }
6643 ;
6644
6645 primary
6646 : literal
6647 {
6648 struct vbl_expr expr1;
6649
6650 expr1.IDENT = $1;
6651 expr1.TYPE = -1;
6652 expr1.VEX = (vexexpr *)0;
6653
6654 $$ = vbl_crtvex( NOPS,expr1,VBL_EMPSTR,-1,-1,0);
6655 }
6656 | aggregate
6657 {
6658 vbl_vexstr *VexStr;
6659 chain_list *ScanChain;
6660
6661 ScanChain = $1;
6662
6663 if ( ScanChain == (chain_list *)0 )
6664 {
6665 my_vbl_error(114,NULL);
6666 }
6667
6668 if ( ScanChain->NEXT == (chain_list *)0 )
6669 {
6670 VexStr = (vbl_vexstr *)ScanChain->DATA;
6671
6672 $$ = *VexStr;
6673
6674 autfreeheap( VexStr, sizeof( vbl_vexstr ) );
6675 freechain( ScanChain );
6676 }
6677 else
6678 {
6679 $$.IDENT = (char *)$1;
6680 $$.AGGREG = 1;
6681 }
6682 }
6683 | name
6684 {
6685 struct vbl_expr expr1;
6686 char *LocalName;
6687 char Buffer[ 40 ];
6688 long left;
6689 long right;
6690 long left_bnd;
6691 long right_bnd;
6692 long mode;
6693 long flag;
6694 unsigned char dynamic;
6695
6696 flag = $1.FLAG;
6697
6698 if ( ( flag != 0 ) &&
6699 ( flag != VBL_EVENT ) &&
6700 ( flag != VBL_STABLE ) )
6701 {
6702 if ( ( flag != VBL_RANGE ) &&
6703 ( flag != VBL_REV_RANGE ) )
6704 {
6705 if ( ! $1.DYNAMIC )
6706 {
6707 sprintf( Buffer, "%ld", $1.LEFT );
6708
6709 expr1.IDENT = Buffer;
6710 expr1.VEX = (vexexpr *)0;
6711 expr1.TYPE = -1;
6712
6713 $$ = vbl_crtvex( NOPS, expr1, VBL_EMPSTR, -1, -1,0);
6714 }
6715 else
6716 {
6717 $$.IDENT = (char *)0;
6718 $$.VEX = (vexexpr *)$1.LEFT;
6719 $$.TYPE = -1;
6720 $$.SIGNED = 0;
6721 }
6722 }
6723 else
6724 {
6725 autexit( 1 );
6726 }
6727 }
6728 else
6729 if ( ( $1.NAME[0] == '"' ) ||
6730 ( $1.NAME[0] == '\'') )
6731 {
6732 expr1.IDENT = $1.NAME;
6733 expr1.VEX = (vexexpr *)0;
6734 expr1.TYPE = -1;
6735
6736 $$ = vbl_crtvex( NOPS ,expr1, VBL_EMPSTR, -1, -1,0); /* as for literal */
6737 }
6738 else
6739 {
6740 if ( ( mode = chktab(hshtab,$1.NAME,VBL_FUNCNAM,VBL_SYMDFN ) ) != 0 )
6741 {
6742 LocalName = VBL_FUNCNAM;
6743 }
6744 else
6745 if ( ( mode = chktab(hshtab,$1.NAME,VBL_PROCNAM,VBL_SYMDFN ) ) != 0 )
6746 {
6747 LocalName = VBL_PROCNAM;
6748 }
6749 else
6750 if ( ( VBL_COMPNAM != (char *)0 ) &&
6751 ( ( mode = chktab(hshtab,$1.NAME,VBL_COMPNAM,VBL_SYMDFN ) ) != 0 ) )
6752 {
6753 LocalName = VBL_COMPNAM;
6754 }
6755 else
6756 {
6757 LocalName = VBL_MODNAM;
6758 mode = chktab (hshtab,$1.NAME,LocalName,VBL_SYMDFN);
6759 }
6760
6761 /*\ Skipped for out argument parameter
6762 if ( mode == VBL_OCNDFN )
6763 {
6764 my_vbl_error (26,$1.NAME);
6765 }
6766 \*/
6767
6768 /* LUDO ICI
6769 if( mode == 0 || mode == VBL_TPEDFN || mode == VBL_PRODFN )
6770 */
6771 if( mode == 0 || mode == VBL_PRODFN )
6772 {
6773 my_vbl_error (17,$1.NAME);
6774 }
6775
6776 left_bnd = chktab (hshtab,$1.NAME,LocalName,VBL_WMNDFN);
6777 right_bnd = chktab (hshtab,$1.NAME,LocalName,VBL_WMXDFN);
6778 dynamic = chktab (hshtab,$1.NAME,LocalName,VBL_DYNDFN);
6779
6780 if ( ( ! $1.DYNAMIC ) &&
6781 ( ! dynamic ) )
6782 {
6783 left = $1.LEFT;
6784 right = $1.RIGHT;
6785
6786 if ( ! dynamic )
6787 {
6788 if ( VBL_COMPNAM == (char *)0 )
6789 {
6790 if ( left_bnd <= right_bnd )
6791 {
6792 if (left <= right)
6793 {
6794 //in_bound = left - left_bnd;
6795 //out_bound = right - left_bnd;
6796 if ((left < left_bnd) || (right > right_bnd))
6797 {
6798 my_vbl_error (36,$1.NAME);
6799 }
6800 }
6801 else
6802 {
6803 //in_bound = right - left_bnd;
6804 //out_bound = left - left_bnd;
6805 if ((left > right_bnd) || (right < left_bnd))
6806 {
6807 my_vbl_error (36,$1.NAME);
6808 }
6809 }
6810 }
6811 else
6812 {
6813 if (left <= right)
6814 {
6815 //in_bound = left - right_bnd;
6816 //out_bound = right - right_bnd;
6817 if ((left < right_bnd) || (right > left_bnd))
6818 {
6819 my_vbl_error (36,$1.NAME);
6820 }
6821 }
6822 else
6823 {
6824 //in_bound = right - right_bnd;
6825 //out_bound = left - right_bnd;
6826 if ((left > left_bnd) || (right < right_bnd))
6827 {
6828 my_vbl_error (36,$1.NAME);
6829 }
6830 }
6831 }
6832 }
6833 }
6834 }
6835 else
6836 {
6837 left = $1.LEFT;
6838 right = $1.RIGHT;
6839 }
6840
6841 /*\
6842 if (mode == VBL_CSTDFN)
6843 {
6844 expr1.VEX = (vexexpr *)chktab(hshtab,$1.NAME,LocalName,VBL_PNTDFN);
6845 expr1.IDENT = (char *)expr1.VEX->VALUE;
6846 expr1.TYPE = chktab(hshtab,$1.NAME,LocalName,VBL_TYPDFN);
6847 expr1.SIGNED = chktab (hshtab,$1.NAME,LocalName,VBL_SUNDFN);
6848
6849 $$ = vbl_crtvex (NOPS,expr1,VBL_EMPSTR,in_bound,out_bound,0);
6850 }
6851 else
6852 \*/
6853 {
6854 long type;
6855
6856 expr1.IDENT = $1.NAME;
6857 type = chktab(hshtab,$1.NAME,LocalName,VBL_TYPDFN);
6858 expr1.TYPE = type;
6859 expr1.SIGNED = chktab (hshtab,$1.NAME,LocalName,VBL_SUNDFN);
6860
6861 if ( $1.DYNAMIC )
6862 {
6863 if ( ( mode == VBL_FUNDFN ) ||
6864 ( mode == VBL_TPEDFN ) ||
6865 ( mode == VBL_PRODFN ) )
6866 {
6867 expr1.VEX = (vexexpr *)left;
6868 expr1 = vbl_crtvex(SUBVAR,expr1,VBL_EMPSTR,expr1.VEX->LEFT,expr1.VEX->RIGHT,0);
6869 }
6870 else
6871 {
6872 expr1 = vbl_crtvex (NOPI,expr1,VBL_EMPSTR,left_bnd,right_bnd,dynamic);
6873
6874 if ( $1.DYNAMIC == VBL_UPTDFN )
6875 {
6876 if ( ( ! dynamic ) ||
6877 ( ! isvexequalexpr( (vexexpr *)left_bnd, (vexexpr *)left ) ) ||
6878 ( ! isvexequalexpr( (vexexpr *)right_bnd, (vexexpr *)right ) ) )
6879 {
6880 expr1 = vbl_crtvex( VEX_TO, expr1,VBL_EMPSTR,left,right,0);
6881 }
6882 }
6883 else
6884 if ( $1.DYNAMIC == VBL_DWTDFN )
6885 {
6886 if ( ( ! dynamic ) ||
6887 ( ! isvexequalexpr( (vexexpr *)left_bnd, (vexexpr *)left ) ) ||
6888 ( ! isvexequalexpr( (vexexpr *)right_bnd, (vexexpr *)right ) ) )
6889 {
6890 expr1 = vbl_crtvex( VEX_DOWNTO, expr1,VBL_EMPSTR,left,right,0);
6891 }
6892 }
6893 else
6894 {
6895 expr1.VEX =
6896 createvexbinexpr( VEX_INDEX_N, 1, expr1.VEX, (vexexpr *)left );
6897 expr1.VEX =
6898 createvexbinexpr( VEX_INDEX_N, 1, expr1.VEX, (vexexpr *)right );
6899 }
6900 }
6901 }
6902 else
6903 {
6904 expr1 = vbl_crtvex (NOPI,expr1,VBL_EMPSTR,left,right,0);
6905 }
6906
6907 if( flag == VBL_EVENT )
6908 {
6909 $$ = vbl_crtvex (VEX_EVENT,expr1,VBL_EMPSTR,left,right,0);
6910 }
6911 else
6912 if( flag == VBL_STABLE )
6913 {
6914 expr1 = vbl_crtvex(VEX_EVENT,expr1,VBL_EMPSTR,left,right,0);
6915 $$ = vbl_crtvex (VEX_NOT,expr1,VBL_EMPSTR,-1,-1,0);
6916 }
6917 else
6918 {
6919 $$ = expr1;
6920 }
6921 }
6922 }
6923 }
6924 | qualified_expression
6925 {
6926 struct vbl_expr expr1;
6927
6928 expr1.IDENT = $1.NAME;
6929 expr1.TYPE = $1.TYPE;
6930 expr1.SIGNED = $1.SIGNED;
6931 expr1.VEX = (vexexpr *)$1.LEFT;
6932
6933 expr1 = vbl_crtvex(SUBVAR,expr1,VBL_EMPSTR,expr1.VEX->LEFT,expr1.VEX->RIGHT,0);
6934
6935 $$ = expr1;
6936 }
6937 ;
6938
6939 qualified_expression
6940 : name
6941 Apostrophe
6942 aggregate
6943 {
6944 char *LocalName;
6945 vbl_vexstr *VexStr;
6946 chain_list *ScanChain;
6947 vexexpr *VexExpr;
6948 long Def;
6949
6950 ScanChain = $3;
6951
6952 if ( ( ScanChain == (chain_list *)0 ) ||
6953 ( ScanChain->NEXT != (chain_list *)0 ) )
6954 {
6955 my_vbl_error(122,NULL);
6956 }
6957
6958 if ( ( Def = chktab(hshtab,$1.NAME,VBL_FUNCNAM,VBL_SYMDFN ) ) != 0 )
6959 {
6960 LocalName = VBL_FUNCNAM;
6961 }
6962 else
6963 if ( ( Def = chktab(hshtab,$1.NAME,VBL_PROCNAM,VBL_SYMDFN ) ) != 0 )
6964 {
6965 LocalName = VBL_PROCNAM;
6966 }
6967 else
6968 {
6969 LocalName = VBL_MODNAM;
6970 Def = chktab (hshtab,$1.NAME,LocalName,VBL_SYMDFN);
6971 }
6972
6973 if ( Def == VBL_TPEDFN )
6974 {
6975 VexStr = (vbl_vexstr *)ScanChain->DATA;
6976
6977 VexExpr = createvexfunc( $1.NAME, VexStr->VEX->WIDTH );
6978 addvexhexpr( VexExpr, VexStr->VEX );
6979
6980 autfreeheap( VexStr, sizeof( vbl_vexstr ) );
6981
6982 $$.NAME = $1.NAME;
6983 $$.TYPE = chktab (hshtab,$1.NAME,LocalName,VBL_TYPDFN);
6984 $$.SIGNED = chktab (hshtab,$1.NAME,LocalName,VBL_SUNDFN);
6985 $$.FLAG = 0;
6986 $$.LEFT = (long)VexExpr;
6987 $$.RIGHT = 0;
6988 $$.DYNAMIC = 1;
6989 $$.AGGREG = 0;
6990
6991 freechain( $3 );
6992 }
6993 else
6994 {
6995 my_vbl_error(122, $1.NAME);
6996 }
6997 }
6998 ;
6999
7000 relational_operator
7001 : _EQSym
7002 { $$ = VEX_EQ; }
7003 | _NESym
7004 { $$ = VEX_NE; }
7005 | _GESym
7006 { $$ = VEX_GE; }
7007 | _GTSym
7008 { $$ = VEX_GT; }
7009 | _LESym
7010 { $$ = VEX_LE; }
7011 | _LTSym
7012 { $$ = VEX_LT; }
7013 ;
7014
7015 literal
7016 : AbstractLit
7017 { $$ = $1; }
7018 | CharacterLit
7019 {
7020 $$ = $1; }
7021 | StringLit
7022 { $$ = $1; }
7023 | BitStringLit
7024 { $$ = $1; }
7025 | _TRUE
7026 { $$ = namealloc( "'1'" ); }
7027 | _FALSE
7028 { $$ = namealloc( "'0'" ); }
7029 ;
7030
7031 aggregate
7032 : LeftParen
7033 element_association
7034 ...element_association..
7035 RightParen_ERR
7036 {
7037 if ( $3 != (chain_list *)0 )
7038 {
7039 $2->NEXT = reverse( $3 );
7040 }
7041
7042 $$ = $2;
7043 }
7044 ;
7045
7046 ...element_association..
7047 : /* empty */
7048 {
7049 $$ = (chain_list *)0;
7050 }
7051 | ...element_association..
7052 Comma
7053 element_association
7054 {
7055 if ( $1 != (chain_list *)0 )
7056 {
7057 $3->NEXT = $1;
7058 }
7059
7060 $$ = $3;
7061 }
7062 ;
7063
7064 element_association
7065 : expression
7066 {
7067 vbl_vexstr *VexStr;
7068
7069 VexStr = (vbl_vexstr *)autallocheap( sizeof( vbl_vexstr ) );
7070 *VexStr = $1;
7071
7072 $$ = addchain( (chain_list *)0, VexStr );
7073 }
7074 | OTHERS
7075 Arrow
7076 expression
7077 {
7078 vbl_vexstr *VexStr;
7079
7080 VexStr = (vbl_vexstr *)autallocheap( sizeof( vbl_vexstr ) );
7081 *VexStr = vbl_crtvex( VEX_OTHERS, $3,VBL_EMPSTR,-1,-1,0);
7082
7083 $$ = addchain( (chain_list *)0, VexStr );
7084 }
7085 ;
7086
7087 name
7088 : simple_name
7089 {
7090 authelem *valbitstr;
7091 char *codedsigname;
7092 char *LocalName;
7093 char buffer[128];
7094
7095 if ( chktab(hshtab,$1,VBL_FUNCNAM,VBL_SYMDFN ) )
7096 {
7097 LocalName = VBL_FUNCNAM;
7098 }
7099 else
7100 if ( chktab(hshtab,$1,VBL_PROCNAM,VBL_SYMDFN ) )
7101 {
7102 LocalName = VBL_PROCNAM;
7103 }
7104 else
7105 if ( ( VBL_COMPNAM != (char *)0 ) &&
7106 ( chktab(hshtab,$1,VBL_COMPNAM,VBL_SYMDFN ) ) )
7107 {
7108 LocalName = VBL_COMPNAM;
7109 }
7110 else
7111 {
7112 LocalName = VBL_MODNAM;
7113 }
7114
7115 $$.NAME = $1;
7116 $$.FLAG = 0;
7117
7118 sprintf ( buffer, "%s.cod.%s", LocalName, $1);
7119 codedsigname = namealloc( buffer );
7120 $$.TYPE = chktab (hshtab,codedsigname,LocalName,VBL_TYPDFN);
7121
7122 if ( $$.TYPE >= VBH_MAX_TYPE )
7123 {
7124 if ((valbitstr = searchauthelem(VBL_ENUMVAL, codedsigname )) != NULL)
7125 {
7126 $$.NAME = namealloc((char *)valbitstr->VALUE);
7127 $$.TYPE = VBH_TYPE_BIT_VECTOR ; /* BIT_VECTOR intentionnel */
7128 $$.LEFT = -1;
7129 $$.RIGHT = -1;
7130 $$.DYNAMIC = 0;
7131 $$.AGGREG = 0;
7132 $$.SIGNED = 0;
7133 }
7134 else
7135 {
7136 $$.TYPE = VBH_TYPE_BIT_VECTOR ; /* BIT_VECTOR intentionnel */
7137 $$.LEFT = chktab (hshtab,$1,LocalName,VBL_WMNDFN);
7138 $$.RIGHT = chktab (hshtab,$1,LocalName,VBL_WMXDFN);
7139 $$.DYNAMIC = chktab(hshtab,$1,LocalName,VBL_DYNDFN);
7140 $$.AGGREG = 0;
7141 $$.SIGNED = 0;
7142 }
7143 }
7144 else
7145 {
7146 $$.TYPE = chktab (hshtab,$1,LocalName,VBL_TYPDFN);
7147 $$.LEFT = chktab (hshtab,$1,LocalName,VBL_WMNDFN);
7148 $$.RIGHT = chktab (hshtab,$1,LocalName,VBL_WMXDFN);
7149 $$.SIGNED = chktab (hshtab,$1,LocalName,VBL_SUNDFN);
7150 $$.DYNAMIC = chktab(hshtab,$1,LocalName,VBL_DYNDFN);
7151 $$.AGGREG = 0;
7152
7153 }
7154 }
7155 | indexed_name
7156 { $$ = $1; }
7157 | slice_name
7158 { $$ = $1; }
7159 | attribute_name
7160 { $$ = $1; }
7161 ;
7162
7163 indexed_name
7164 : simple_name
7165 aggregate
7166 {
7167 char *LocalName;
7168 vbl_vexstr *VexStr;
7169 vbfun_list *VbFunc;
7170 chain_list *ScanChain;
7171 vexexpr *VexExpr;
7172 vexexpr *VexRet;
7173 long Index;
7174 long Error;
7175 long Def;
7176
7177 ScanChain = $2;
7178
7179 if ( ScanChain == (chain_list *)0 )
7180 {
7181 my_vbl_error(114,NULL);
7182 }
7183
7184 if ( ( Def = chktab(hshtab,$1,VBL_FUNCNAM,VBL_SYMDFN ) ) != 0 )
7185 {
7186 LocalName = VBL_FUNCNAM;
7187 }
7188 else
7189 if ( ( Def = chktab(hshtab,$1,VBL_PROCNAM,VBL_SYMDFN ) ) != 0 )
7190 {
7191 LocalName = VBL_PROCNAM;
7192 }
7193 else
7194 if ( ( VBL_COMPNAM != (char *)0 ) &&
7195 ( ( Def = chktab(hshtab,$1,VBL_COMPNAM,VBL_SYMDFN ) ) != 0 ) )
7196 {
7197 LocalName = VBL_COMPNAM;
7198 }
7199 else
7200 {
7201 LocalName = VBL_MODNAM;
7202 Def = chktab (hshtab,$1,LocalName,VBL_SYMDFN);
7203 }
7204
7205 if ( ( Def == VBL_FUNDFN ) ||
7206 ( Def == VBL_TPEDFN ) ||
7207 ( Def == VBL_PRODFN ) )
7208 {
7209 if ( Def != VBL_TPEDFN )
7210 {
7211 VexExpr = createvexfunc( $1, 0 );
7212 }
7213
7214 if ( Def == VBL_FUNDFN )
7215 {
7216 VbFunc = (vbfun_list *)chktab( hshtab,$1,LocalName,VBL_PNTDFN);
7217
7218 if ( VbFunc != (vbfun_list *)0 )
7219 {
7220 VexRet = VbFunc->RETURN->TARGET;
7221
7222 VexExpr->LEFT = VexRet->LEFT;
7223 VexExpr->RIGHT = VexRet->RIGHT;
7224 VexExpr->WIDTH = VexRet->WIDTH;
7225
7226 if ( ! IsVexNodeVarWidth( VexRet ) )
7227 {
7228 ClearVexNodeVarWidth( VexExpr );
7229 }
7230 }
7231 }
7232
7233 if ( Def == VBL_TPEDFN )
7234 {
7235 if ( ScanChain->NEXT != (chain_list *)0 )
7236 {
7237 my_vbl_error(114,NULL);
7238 }
7239
7240 VexStr = (vbl_vexstr *)ScanChain->DATA;
7241
7242 VexExpr = createvexfunc( $1, VexStr->VEX->WIDTH );
7243 addvexhexpr( VexExpr, VexStr->VEX );
7244
7245 autfreeheap( VexStr, sizeof( vbl_vexstr ) );
7246 }
7247 else
7248 {
7249 while ( ScanChain != (chain_list *)0 )
7250 {
7251 VexStr = (vbl_vexstr *)ScanChain->DATA;
7252 addvexqexpr( VexExpr, VexStr->VEX );
7253
7254 autfreeheap( VexStr, sizeof( vbl_vexstr ) );
7255 ScanChain = ScanChain->NEXT;
7256 }
7257 }
7258
7259 $$.NAME = $1;
7260 $$.TYPE = chktab (hshtab,$1,LocalName,VBL_TYPDFN);
7261 $$.SIGNED = chktab (hshtab,$1,LocalName,VBL_SUNDFN);
7262 $$.FLAG = 0;
7263 $$.LEFT = (long)VexExpr;
7264 $$.RIGHT = -1;
7265 $$.DYNAMIC = 1;
7266 $$.AGGREG = 0;
7267
7268 freechain( $2 );
7269 }
7270 else
7271 if ( ScanChain->NEXT != (chain_list *)0 )
7272 {
7273 if ( ( ! Def ) ||
7274 ( ScanChain->NEXT->NEXT != (chain_list *)0 ) )
7275 {
7276 my_vbl_error(118,$1);
7277 }
7278
7279 /* ICI */
7280
7281 $$.NAME = $1;
7282 $$.TYPE = chktab (hshtab,$1,LocalName,VBL_TYPDFN);
7283 $$.SIGNED = chktab (hshtab,$1,LocalName,VBL_SUNDFN);
7284 $$.FLAG = 0;
7285
7286 $$.DYNAMIC = VBL_IDXDFN;
7287 $$.AGGREG = 0;
7288
7289 VexStr = (vbl_vexstr *)ScanChain->DATA;
7290 $$.LEFT = (long)VexStr->VEX;
7291 autfreeheap( VexStr, sizeof( vbl_vexstr ) );
7292
7293 ScanChain = ScanChain->NEXT;
7294 VexStr = (vbl_vexstr *)ScanChain->DATA;
7295 $$.RIGHT = (long)VexStr->VEX;
7296 autfreeheap( VexStr, sizeof( vbl_vexstr ) );
7297
7298 freechain( $2 );
7299 }
7300 else
7301 {
7302 VexStr = (vbl_vexstr *)ScanChain->DATA;
7303 Error = vbl_vextonum( VexStr->VEX, &Index );
7304
7305 $$.NAME = $1;
7306 $$.TYPE = chktab (hshtab,$1,LocalName,VBL_TYPDFN);
7307 $$.SIGNED = chktab (hshtab,$1,LocalName,VBL_SUNDFN);
7308 $$.FLAG = 0;
7309 $$.AGGREG = 0;
7310
7311 if ( Error )
7312 {
7313 $$.LEFT = (long)VexStr->VEX;
7314 $$.RIGHT = 0;
7315 $$.DYNAMIC = VBL_UPTDFN;
7316 }
7317 else
7318 {
7319 $$.LEFT = Index;
7320 $$.RIGHT = Index;
7321 $$.DYNAMIC = 0;
7322 }
7323
7324 autfreeheap( VexStr, sizeof( vbl_vexstr ) );
7325 freechain( ScanChain );
7326 }
7327 }
7328 ;
7329
7330 slice_name
7331 : simple_name
7332 LeftParen
7333 simple_expression
7334 direction
7335 simple_expression
7336 RightParen_ERR
7337 {
7338 char *LocalName;
7339 long Left;
7340 long Right;
7341 long ErrorL;
7342 long ErrorR;
7343
7344 if ( chktab(hshtab,$1,VBL_FUNCNAM,VBL_SYMDFN ) )
7345 {
7346 LocalName = VBL_FUNCNAM;
7347 }
7348 else
7349 if ( chktab(hshtab,$1,VBL_PROCNAM,VBL_SYMDFN ) )
7350 {
7351 LocalName = VBL_PROCNAM;
7352 }
7353 else
7354 if ( ( VBL_COMPNAM != (char *)0 ) &&
7355 ( chktab(hshtab,$1,VBL_COMPNAM,VBL_SYMDFN ) ) )
7356 {
7357 LocalName = VBL_COMPNAM;
7358 }
7359 else
7360 {
7361 LocalName = VBL_MODNAM;
7362 }
7363
7364 ErrorL = vbl_vextonum( $3.VEX, &Left );
7365 ErrorR = vbl_vextonum( $5.VEX, &Right );
7366
7367 $$.NAME = $1;
7368 $$.TYPE = chktab (hshtab,$1,LocalName,VBL_TYPDFN);
7369 $$.SIGNED = chktab (hshtab,$1,LocalName,VBL_SUNDFN);
7370 $$.FLAG = 0;
7371 $$.AGGREG = 0;
7372
7373 if ( ( ! ErrorL ) && ( ! ErrorR ) )
7374 {
7375 if (((Left > Right) && ($4 == VBL_UPTDFN)) ||
7376 ((Left < Right) && ($4 == VBL_DWTDFN)))
7377 my_vbl_error (32,$1);
7378
7379 $$.LEFT = Left;
7380 $$.RIGHT = Right;
7381 $$.DYNAMIC = 0;
7382 }
7383 else
7384 {
7385 $$.LEFT = (long)$3.VEX;
7386 $$.RIGHT = (long)$5.VEX;
7387 $$.DYNAMIC = $4;
7388 }
7389 }
7390 ;
7391
7392 attribute_name
7393 : name
7394 Apostrophe
7395 attribute_designator
7396 {
7397 char *LocalName;
7398 long type;
7399 long flag;
7400 long mode;
7401 long AttrLeft;
7402 long AttrRight;
7403 long AttrLow;
7404 long AttrHigh;
7405 unsigned char Dynamic;
7406
7407 if ( ( mode = chktab(hshtab,$1.NAME,VBL_FUNCNAM,VBL_SYMDFN ) ) != 0 )
7408 {
7409 LocalName = VBL_FUNCNAM;
7410 }
7411 else
7412 if ( ( mode = chktab(hshtab,$1.NAME,VBL_PROCNAM,VBL_SYMDFN ) ) != 0 )
7413 {
7414 LocalName = VBL_PROCNAM;
7415 }
7416 else
7417 {
7418 LocalName = VBL_MODNAM;
7419 mode = chktab (hshtab,$1.NAME,LocalName,VBL_SYMDFN);
7420 }
7421
7422 type = chktab (hshtab,$1.NAME,LocalName,VBL_TYPDFN);
7423 flag = $3;
7424
7425 Dynamic = chktab(hshtab,$1.NAME,LocalName,VBL_DYNDFN);
7426
7427 $$.NAME = $1.NAME;
7428 $$.TYPE = type;
7429 $$.LEFT = -1;
7430 $$.RIGHT = -1;
7431 $$.SIGNED = chktab (hshtab,$1.NAME,LocalName,VBL_SUNDFN);
7432 $$.FLAG = $3;
7433 $$.DYNAMIC = Dynamic;
7434
7435 if ( ( flag == VBL_STABLE ) ||
7436 ( flag == VBL_EVENT ) )
7437 {
7438 if ( LocalName != VBL_MODNAM )
7439 my_vbl_error (79,$1.NAME);
7440 }
7441 else
7442 {
7443 AttrLeft = chktab( hshtab,$1.NAME,LocalName,VBL_ATLDFN);
7444 AttrRight = chktab( hshtab,$1.NAME,LocalName,VBL_ATRDFN);
7445
7446 if ( ! Dynamic )
7447 {
7448 if ( AttrLeft > AttrRight )
7449 {
7450 AttrLow = AttrRight;
7451 AttrHigh = AttrLeft;
7452 }
7453 else
7454 {
7455 AttrHigh = AttrRight;
7456 AttrLow = AttrLeft;
7457 }
7458 }
7459 else
7460 {
7461 if ( Dynamic == VBL_UPTDFN )
7462 {
7463 AttrLow = AttrLeft;
7464 AttrHigh = AttrRight;
7465 }
7466 else
7467 {
7468 AttrHigh = AttrLeft;
7469 AttrLow = AttrRight;
7470 }
7471 }
7472
7473 switch ( flag )
7474 {
7475 case VBL_LEFT : $$.LEFT = AttrLeft;
7476 break;
7477
7478 case VBL_RIGHT : $$.LEFT = AttrRight;
7479 break;
7480
7481 case VBL_LOW : $$.LEFT = AttrLow;
7482 break;
7483
7484 case VBL_HIGH : $$.LEFT = AttrHigh;
7485 break;
7486
7487 case VBL_LENGTH : $$.LEFT = 1 + (AttrHigh - AttrLow);
7488 break;
7489
7490 case VBL_RANGE : $$.LEFT = AttrLeft;
7491 $$.RIGHT = AttrRight;
7492 break;
7493
7494 case VBL_REV_RANGE : $$.LEFT = AttrRight;
7495 $$.RIGHT = AttrLeft;
7496 break;
7497 }
7498 }
7499 }
7500 ;
7501
7502 attribute_designator
7503 : _STABLE { $$ = VBL_STABLE; }
7504 | _EVENT { $$ = VBL_EVENT; }
7505 | _LEFT { $$ = VBL_LEFT; }
7506 | _RIGHT { $$ = VBL_RIGHT; }
7507 | _LOW { $$ = VBL_LOW; }
7508 | _HIGH { $$ = VBL_HIGH; }
7509 | _LENGTH { $$ = VBL_LENGTH; }
7510 | _RANGE { $$ = VBL_RANGE; }
7511 | _REV_RANGE { $$ = VBL_REV_RANGE; }
7512 ;
7513
7514 identifier_list
7515 : Identifier
7516 { VBL_NM1LST = addchain (VBL_NM1LST,$1); }
7517 ...identifier..
7518 ;
7519
7520 ...identifier..
7521 : /*empty*/
7522 | ...identifier..
7523 Comma
7524 Identifier
7525 { VBL_NM1LST = addchain (VBL_NM1LST,$3); }
7526 ;
7527
7528 .label.
7529 : /*empty*/
7530 { $$ = NULL; }
7531 | label
7532 { $$ = $1; }
7533 ;
7534
7535 .guard_expression.
7536 : /*empty*/
7537 { $$.VEX = (vexexpr *)0; }
7538 | guard_expression
7539 { $$ = $1; }
7540 ;
7541
7542 guard_expression
7543 : LeftParen
7544 expression
7545 RightParen_ERR
7546 { $$ = $2; }
7547 ;
7548
7549 .GUARDED.
7550 : /*empty*/
7551 {
7552 $$ = VBL_UNGDFN;
7553 }
7554 | GUARDED
7555 {
7556 $$ = VBL_GRDDFN;
7557
7558 if ( VBL_GRDLST == (chain_list *)0 )
7559 my_vbl_error(41,0 );
7560 }
7561 ;
7562
7563 .simple_name.
7564 : /*empty*/
7565 { $$ = NULL; }
7566 | simple_name
7567 { $$ = $1; }
7568 ;
7569
7570 simple_name
7571 : Identifier
7572 { $$ = $1; }
7573 ;
7574
7575 target
7576 : name
7577 { $$ = $1; }
7578 | aggregate
7579 {
7580 $$.NAME = (char *)$1;
7581 $$.LEFT = 0;
7582 $$.RIGHT = 0;
7583 $$.FLAG = 0;
7584 $$.TYPE = 0;
7585 $$.DYNAMIC = 0;
7586 $$.SIGNED = 0;
7587 $$.AGGREG = 1;
7588 }
7589 ;
7590
7591 a_label
7592 : label
7593 Colon
7594 {
7595 $$ = $1;
7596 }
7597 ;
7598
7599 label
7600 : Identifier
7601 { $$ = $1; }
7602 ;
7603
7604 RightParen_ERR
7605 : RightParen
7606 { yyerrok; }
7607 ;
7608
7609 Semicolon_ERR
7610 : Semicolon
7611 { yyerrok; }
7612 ;
7613
7614 END_ERR
7615 : _END
7616 { yyerrok; }
7617 ;
7618
7619 %%
7620
addent(head,key)7621 static struct dct_entry *addent (head , key)
7622 struct dct_entry *head;
7623 char *key;
7624
7625 {
7626 struct dct_entry *entry;
7627 long i;
7628
7629 if (VBL_DCEHED == NULL)
7630 {
7631 VBL_DCEHED = (struct dct_entry *)
7632 autallocblock (sizeof(struct dct_entry) * VBL_ALODFN);
7633
7634 entry = VBL_DCEHED;
7635 for (i=1 ; i<VBL_ALODFN ; i++)
7636 {
7637 entry->next = entry + 1;
7638 entry++;
7639 }
7640 entry->next = NULL;
7641 }
7642
7643 entry = VBL_DCEHED;
7644 VBL_DCEHED = VBL_DCEHED->next;
7645
7646 entry->next = head;
7647 entry->data = NULL;
7648 entry->key = key;
7649
7650 return (entry);
7651 }
7652
addrcd(head,key)7653 static struct dct_recrd *addrcd (head , key)
7654
7655 struct dct_recrd *head;
7656 char *key;
7657
7658 {
7659 struct dct_recrd *recrd;
7660 long i;
7661
7662 if (VBL_DCRHED == NULL)
7663 {
7664 VBL_DCRHED = (struct dct_recrd *)
7665 autallocblock (sizeof(struct dct_recrd) * VBL_ALODFN);
7666
7667 recrd = VBL_DCRHED;
7668 for (i=1 ; i<VBL_ALODFN ; i++)
7669 {
7670 recrd->next = recrd + 1;
7671 recrd++;
7672 }
7673 recrd->next = NULL;
7674 }
7675
7676 recrd = VBL_DCRHED;
7677 VBL_DCRHED = VBL_DCRHED->next;
7678
7679 recrd->next = head;
7680 recrd->fd0_val = 0;
7681 recrd->fd1_val = 0;
7682 recrd->fd2_val = 0;
7683 recrd->fd3_val = 0;
7684 recrd->fd4_val = 0;
7685 recrd->fd5_val = 0;
7686 recrd->fd6_val = 0;
7687 recrd->fd7_val = 0;
7688 recrd->fd8_val = 0;
7689 recrd->pnt_val = 0;
7690 recrd->dyn_val = 0;
7691 recrd->key = key;
7692
7693 return (recrd);
7694 }
7695
initab()7696 static struct dct_entry **initab ()
7697
7698 {
7699 struct dct_entry **head;
7700 long i;
7701
7702 head = (struct dct_entry **)
7703 autallocblock (sizeof(struct dct_entry *) * VBL_HSZDFN);
7704
7705 for (i=0 ; i<VBL_HSZDFN ; i++)
7706 head[i] = NULL;
7707
7708 return (head);
7709 }
7710
addtab(head,key_str,ctx_str,field,valu)7711 static void addtab (head,key_str,ctx_str,field,valu)
7712
7713 struct dct_entry **head;
7714 char *key_str;
7715 char *ctx_str;
7716 long field;
7717 long valu;
7718
7719 {
7720 long found = 0;
7721 long index;
7722 struct dct_entry *entry_pnt;
7723 struct dct_recrd *recrd_pnt;
7724
7725 index = ((unsigned long) key_str) % VBL_HSZDFN;
7726 entry_pnt = head[index];
7727
7728 while (entry_pnt != NULL)
7729 {
7730 if (entry_pnt->key == key_str)
7731 {
7732 found = 1;
7733 break;
7734 }
7735 entry_pnt = entry_pnt->next;
7736 }
7737
7738 if (found == 0)
7739 {
7740 head[index] = addent (head[index],key_str);
7741 entry_pnt = head[index];
7742 }
7743
7744 found = 0;
7745 recrd_pnt = entry_pnt->data;
7746 while (recrd_pnt != NULL)
7747 {
7748 if (recrd_pnt->key == ctx_str)
7749 {
7750 found = 1;
7751 break;
7752 }
7753 recrd_pnt = recrd_pnt->next;
7754 }
7755
7756 if (found == 0)
7757 {
7758 entry_pnt->data = addrcd (entry_pnt->data,ctx_str);
7759 recrd_pnt = entry_pnt->data ;
7760 }
7761
7762 switch (field)
7763 {
7764 case VBL_MODDFN :
7765 recrd_pnt->fd0_val = valu;
7766 break;
7767 case VBL_SYMDFN :
7768 recrd_pnt->fd1_val = valu;
7769 break;
7770 case VBL_TYPDFN :
7771 recrd_pnt->fd2_val = valu;
7772 break;
7773 case VBL_SUNDFN :
7774 recrd_pnt->fd3_val = valu;
7775 break;
7776 case VBL_LBLDFN :
7777 recrd_pnt->fd4_val = valu;
7778 break;
7779 case VBL_WMXDFN :
7780 recrd_pnt->fd5_val = valu;
7781 break;
7782 case VBL_WMNDFN :
7783 recrd_pnt->fd6_val = valu;
7784 break;
7785 case VBL_ATLDFN :
7786 recrd_pnt->fd7_val = valu;
7787 break;
7788 case VBL_ATRDFN :
7789 recrd_pnt->fd8_val = valu;
7790 break;
7791 case VBL_PNTDFN :
7792 recrd_pnt->pnt_val = valu;
7793 break;
7794 case VBL_DYNDFN :
7795 recrd_pnt->dyn_val = valu;
7796 break;
7797 }
7798
7799 }
7800
chktab(head,key_str,ctx_str,field)7801 static long chktab (head,key_str,ctx_str,field)
7802
7803 struct dct_entry **head;
7804 char *key_str;
7805 char *ctx_str;
7806 long field;
7807
7808 {
7809 long found = 0;
7810 long valu = 0;
7811 struct dct_entry *entry_pnt;
7812 struct dct_recrd *recrd_pnt;
7813
7814 entry_pnt = head [((unsigned long)key_str) % VBL_HSZDFN];
7815
7816 while (entry_pnt != NULL)
7817 {
7818 if (entry_pnt->key == key_str)
7819 {
7820 found = 1;
7821 break;
7822 }
7823 entry_pnt = entry_pnt->next;
7824 }
7825
7826 if (found == 1)
7827 {
7828 found = 0;
7829 recrd_pnt = entry_pnt->data;
7830 while (recrd_pnt != NULL)
7831 {
7832 if (recrd_pnt->key == ctx_str)
7833 {
7834 found = 1;
7835 break;
7836 }
7837 recrd_pnt = recrd_pnt->next;
7838 }
7839 if (found == 1)
7840 {
7841 switch (field)
7842 {
7843 case VBL_MODDFN :
7844 valu = recrd_pnt->fd0_val;
7845 break;
7846 case VBL_SYMDFN :
7847 valu = recrd_pnt->fd1_val;
7848 break;
7849 case VBL_TYPDFN :
7850 valu = recrd_pnt->fd2_val;
7851 break;
7852 case VBL_SUNDFN :
7853 valu = recrd_pnt->fd3_val;
7854 break;
7855 case VBL_LBLDFN :
7856 valu = recrd_pnt->fd4_val;
7857 break;
7858 case VBL_WMXDFN :
7859 valu = recrd_pnt->fd5_val;
7860 break;
7861 case VBL_WMNDFN :
7862 valu = recrd_pnt->fd6_val;
7863 break;
7864 case VBL_ATLDFN :
7865 valu = recrd_pnt->fd7_val;
7866 break;
7867 case VBL_ATRDFN :
7868 valu = recrd_pnt->fd8_val;
7869 break;
7870 case VBL_PNTDFN :
7871 valu = recrd_pnt->pnt_val;
7872 break;
7873 case VBL_DYNDFN :
7874 valu = recrd_pnt->dyn_val;
7875 break;
7876 }
7877 }
7878 }
7879
7880 return (valu);
7881 }
7882
fretab(pt_hash)7883 static void fretab (pt_hash)
7884
7885 struct dct_entry **pt_hash;
7886 {
7887 struct dct_entry *pt_entry;
7888 struct dct_entry *pt_nxtentry;
7889 struct dct_recrd *pt_record;
7890 long i;
7891
7892 if (pt_hash != NULL)
7893 {
7894 for (i=0 ; i<VBL_HSZDFN ; i++)
7895 {
7896 if ((pt_entry = pt_hash[i]) != NULL)
7897 {
7898 while (pt_entry != NULL)
7899 {
7900 pt_record = pt_entry->data;
7901
7902 while (pt_record->next != NULL)
7903 pt_record = pt_record->next;
7904
7905 pt_record->next = VBL_DCRHED;
7906 VBL_DCRHED = pt_entry->data;
7907
7908 pt_nxtentry = pt_entry->next;
7909 pt_entry->next = VBL_DCEHED;
7910 VBL_DCEHED = pt_entry;
7911 pt_entry = pt_nxtentry;
7912 }
7913 }
7914 }
7915 autfreeblock(pt_hash);
7916 }
7917 }
7918
vbl_addstr(object,mode,prtype,type,flag,name,left,right,exp,kind,dynamic)7919 static void *vbl_addstr(object,mode,prtype,type,flag,name,left,right,exp,kind,dynamic)
7920
7921 char object;
7922 long mode;
7923 vbtyp_list *prtype;
7924 unsigned char type;
7925 char flag;
7926 char *name;
7927 long left;
7928 long right;
7929 vexexpr *exp;
7930 unsigned char kind;
7931 unsigned char dynamic;
7932
7933 {
7934 ptype_list *GenVar = NULL;
7935 void *pnt = NULL;
7936 char porflg = 0;
7937 char modflg = 0;
7938 char auxflg = 0;
7939 char cstflg = 0;
7940 char varflg = 0;
7941 char funflg = 0;
7942 char conflg = 0;
7943 char parflg = 0;
7944 char genflg = 0;
7945 char gnrflg = 0;
7946 char genmodflg = 0;
7947 char lclmod = 'X';
7948 vexexpr *vex_pnt;
7949 long bitsize;
7950
7951 switch (object)
7952 {
7953 case 'M':
7954
7955 /* ###------------------------------------------------------### */
7956 /* if object is a model port ... */
7957 /* ###------------------------------------------------------### */
7958
7959 modflg = 1;
7960 switch (mode)
7961 {
7962 case VBL_ICNDFN:
7963 lclmod = 'I'; break;
7964 case VBL_OCNDFN:
7965 lclmod = 'O'; break;
7966 case VBL_BCNDFN:
7967 lclmod = 'B'; break;
7968 }
7969 break;
7970
7971 case 'P':
7972
7973 /* ###------------------------------------------------------### */
7974 /* if object is a port ... */
7975 /* ###------------------------------------------------------### */
7976
7977 porflg = 1;
7978 switch (mode)
7979 {
7980 case VBL_ICNDFN:
7981 lclmod = 'I'; break;
7982 case VBL_OCNDFN:
7983 lclmod = 'O'; break;
7984 case VBL_BCNDFN:
7985 lclmod = 'B'; break;
7986 }
7987 break;
7988
7989 case 'p':
7990
7991 /* ###------------------------------------------------------### */
7992 /* if object is a parameter of a function / procedure */
7993 /* ###------------------------------------------------------### */
7994
7995 parflg = 1;
7996 switch (mode)
7997 {
7998 case VBL_ICNDFN:
7999 lclmod = 'I'; break;
8000 case VBL_OCNDFN:
8001 lclmod = 'O'; break;
8002 case VBL_BCNDFN:
8003 lclmod = 'B'; break;
8004 }
8005 break;
8006
8007 case 'S':
8008
8009 /* ###------------------------------------------------------### */
8010 /* if object is a signal ... */
8011 /* ###------------------------------------------------------### */
8012
8013 auxflg = 1;
8014
8015 break;
8016
8017 case 'v':
8018
8019 /* ###------------------------------------------------------### */
8020 /* if object is a variable in function/procedure */
8021 /* ###------------------------------------------------------### */
8022
8023 funflg = 1;
8024
8025 break;
8026
8027 case 'V':
8028
8029 /* ###------------------------------------------------------### */
8030 /* if object is a variable ... */
8031 /* ###------------------------------------------------------### */
8032
8033 varflg = 1;
8034
8035 break;
8036
8037 case 'C':
8038
8039 /* ###------------------------------------------------------### */
8040 /* if object is a constant ... */
8041 /* ###------------------------------------------------------### */
8042
8043 cstflg = 1;
8044
8045 break;
8046
8047 case 'G':
8048
8049 /* ###------------------------------------------------------### */
8050 /* if object is a generic ... */
8051 /* ###------------------------------------------------------### */
8052
8053 genflg = 1;
8054
8055 break;
8056
8057 case 'f':
8058
8059 /* ###------------------------------------------------------### */
8060 /* if object is a for generate variable ... */
8061 /* ###------------------------------------------------------### */
8062
8063 gnrflg = 1;
8064
8065 break;
8066
8067 case 'g':
8068
8069 /* ###------------------------------------------------------### */
8070 /* if object is a generic map ... */
8071 /* ###------------------------------------------------------### */
8072
8073 genmodflg = 1;
8074
8075 break;
8076
8077 case 'F':
8078
8079 /* ###------------------------------------------------------### */
8080 /* if object is a function ... */
8081 /* ###------------------------------------------------------### */
8082
8083 conflg = 1;
8084
8085 break;
8086 }
8087
8088 if ( (flag == 'A') ||
8089 (flag == 'U') )
8090 {
8091 /* ###------------------------------------------------------### */
8092 /* if object is an array ... */
8093 /* ###------------------------------------------------------### */
8094
8095 /* Original
8096 vex_pnt = createvexatomvec( name, left, right );
8097 */
8098
8099 /* Correction */
8100 if ( ( flag == 'A' ) && ( ! dynamic ) )
8101 {
8102 vex_pnt = createvexatomvec( name, prtype->LEFT, prtype->RIGHT );
8103 }
8104 else
8105 {
8106 if ( dynamic )
8107 {
8108 if ( dynamic == VBL_UPTDFN ) vex_pnt = createvexoper( VEX_TO , 0 );
8109 else vex_pnt = createvexoper( VEX_DOWNTO, 0 );
8110
8111 addvexqexpr( vex_pnt, createvexatomvec( name, -1, -1 ) );
8112 addvexqexpr( vex_pnt, dupvexexpr( (vexexpr *)left ) );
8113 addvexqexpr( vex_pnt, dupvexexpr( (vexexpr *)right ) );
8114 }
8115 else
8116 {
8117 vex_pnt = createvexatomvec( name, left, right );
8118 }
8119 }
8120 /* Fin Correction */
8121
8122 if ( prtype->INDEX == VBH_TYPE_SIGNED )
8123 {
8124 SetVexNodeSigned( vex_pnt );
8125 }
8126
8127 if ( auxflg == 1 )
8128 VBL_BEFPNT->BEAUX = vbh_addvbaux(VBL_BEFPNT->BEAUX, vex_pnt,exp,kind,prtype,
8129 VBL_LINNUM );
8130 if ( cstflg == 1 )
8131 VBL_BEFPNT->BECST = vbh_addvbcst(VBL_BEFPNT->BECST, vex_pnt,exp,prtype,
8132 VBL_LINNUM );
8133
8134 if ( genflg == 1 )
8135 VBL_BEFPNT->BEGEN = vbh_addvbgen(VBL_BEFPNT->BEGEN, vex_pnt,exp,prtype,
8136 VBL_LINNUM );
8137 if (porflg == 1)
8138 VBL_BEFPNT->BEPOR = vbh_addvbpor(VBL_BEFPNT->BEPOR, vex_pnt,exp,lclmod,kind,prtype,
8139 VBL_LINNUM );
8140
8141 if (modflg == 1)
8142 VBL_BEFPNT->BEMOD->BEPOR =
8143 vbh_addvbpor(VBL_BEFPNT->BEMOD->BEPOR, vex_pnt,exp,lclmod,kind,prtype,
8144 VBL_LINNUM );
8145 if (genmodflg == 1)
8146 VBL_BEFPNT->BEMOD->BEGEN =
8147 vbh_addvbgen(VBL_BEFPNT->BEMOD->BEGEN, vex_pnt,exp,prtype,
8148 VBL_LINNUM );
8149 if (parflg == 1)
8150 VBL_BEFUN->ARGUMENT = vbh_addvbarg(VBL_BEFUN->ARGUMENT,vex_pnt,lclmod,kind,prtype,
8151 VBL_LINNUM );
8152 if (varflg == 1)
8153 VBL_BEPCS->VARIABLE = vbh_addvbvar(VBL_BEPCS->VARIABLE,vex_pnt,exp,prtype,
8154 VBL_LINNUM );
8155 if (funflg == 1)
8156 VBL_BEFUN->VARIABLE = vbh_addvbvar(VBL_BEFUN->VARIABLE,vex_pnt,exp,prtype,
8157 VBL_LINNUM );
8158 if (gnrflg == 1)
8159 GenVar = vbh_addvbvar( (vbvar_list *)0,vex_pnt,exp,prtype, VBL_LINNUM );
8160 }
8161 else
8162 if ( (flag == 'I') )
8163 {
8164 /* ###------------------------------------------------------### */
8165 /* if object is an integer ... */
8166 /* ###------------------------------------------------------### */
8167
8168 if ( dynamic )
8169 {
8170 vexexpr *new_left;
8171 vexexpr *new_right;
8172
8173 vex_pnt = createvexoper( VEX_NUM_BIT, 0 );
8174 addvexqexpr( vex_pnt, dupvexexpr( (vexexpr *)left ) );
8175 addvexqexpr( vex_pnt, dupvexexpr( (vexexpr *)right ) );
8176
8177 new_left = (vexexpr *)vex_pnt;
8178 new_right = (vexexpr *)createvexatomlit( VEX_ATOM_ZERO );
8179
8180 vex_pnt = createvexternaryexpr(
8181 VEX_DOWNTO, -1, createvexatomvec( name, -1, -1 ),
8182 dupvexexpr( (vexexpr *)new_left ), dupvexexpr( (vexexpr *)new_right ) );
8183
8184 /* It's not clean but ... */
8185 copyvexnode( (vexexpr *)left, new_left );
8186 copyvexnode( (vexexpr *)right, new_right );
8187 }
8188 else
8189 {
8190 if ((left == -1 ) && (right == -1))
8191 {
8192 left = prtype->LEFT;
8193 right = prtype->RIGHT;
8194 }
8195
8196 bitsize = vbl_intSize( left, right );
8197
8198 vex_pnt = createvexatomvec( name, bitsize - 1, 0 );
8199
8200 if ( ( left < 0 ) ||
8201 ( right < 0 ) )
8202 {
8203 SetVexNodeSigned( vex_pnt );
8204 }
8205 }
8206
8207 if ( auxflg == 1 )
8208 VBL_BEFPNT->BEAUX = vbh_addvbaux(VBL_BEFPNT->BEAUX, vex_pnt,exp,kind,prtype,
8209 VBL_LINNUM );
8210 if ( cstflg == 1 )
8211 VBL_BEFPNT->BECST = vbh_addvbcst(VBL_BEFPNT->BECST, vex_pnt,exp,prtype,
8212 VBL_LINNUM );
8213
8214 if ( genflg == 1 )
8215 VBL_BEFPNT->BEGEN = vbh_addvbgen(VBL_BEFPNT->BEGEN, vex_pnt,exp,prtype,
8216 VBL_LINNUM );
8217 if (porflg == 1)
8218 VBL_BEFPNT->BEPOR = vbh_addvbpor(VBL_BEFPNT->BEPOR, vex_pnt,exp,lclmod,kind,prtype,
8219 VBL_LINNUM );
8220 if (modflg == 1)
8221 VBL_BEFPNT->BEMOD->BEPOR =
8222 vbh_addvbpor(VBL_BEFPNT->BEMOD->BEPOR, vex_pnt,exp,lclmod,kind,prtype,
8223 VBL_LINNUM );
8224 if (genmodflg == 1)
8225 VBL_BEFPNT->BEMOD->BEGEN =
8226 vbh_addvbgen(VBL_BEFPNT->BEMOD->BEGEN, vex_pnt,exp,prtype,
8227 VBL_LINNUM );
8228 if (parflg == 1)
8229 VBL_BEFUN->ARGUMENT = vbh_addvbarg(VBL_BEFUN->ARGUMENT, vex_pnt, lclmod,kind,prtype,
8230 VBL_LINNUM );
8231 if (varflg == 1)
8232 VBL_BEPCS->VARIABLE = vbh_addvbvar(VBL_BEPCS->VARIABLE,vex_pnt,exp,prtype,
8233 VBL_LINNUM );
8234 if (funflg == 1)
8235 VBL_BEFUN->VARIABLE = vbh_addvbvar(VBL_BEFUN->VARIABLE,vex_pnt,exp,prtype,
8236 VBL_LINNUM );
8237 if (gnrflg == 1)
8238 GenVar = vbh_addvbvar( (vbvar_list *)0,vex_pnt,exp,prtype, VBL_LINNUM );
8239 }
8240 else
8241 {
8242 vex_pnt = createvexatombit( name );
8243 /* ###------------------------------------------------------### */
8244 /* if object is a scalar ... */
8245 /* ###------------------------------------------------------### */
8246
8247 if (porflg == 1)
8248 VBL_BEFPNT->BEPOR = vbh_addvbpor (VBL_BEFPNT->BEPOR,vex_pnt,exp,lclmod,kind,prtype,
8249 VBL_LINNUM );
8250 if (modflg == 1)
8251 VBL_BEFPNT->BEMOD->BEPOR =
8252 vbh_addvbpor (VBL_BEFPNT->BEMOD->BEPOR,vex_pnt,exp,lclmod,kind,prtype,
8253 VBL_LINNUM );
8254 if (genmodflg == 1)
8255 VBL_BEFPNT->BEMOD->BEGEN =
8256 vbh_addvbgen(VBL_BEFPNT->BEMOD->BEGEN, vex_pnt,exp,prtype,
8257 VBL_LINNUM );
8258 if (parflg == 1)
8259 VBL_BEFUN->ARGUMENT = vbh_addvbarg(VBL_BEFUN->ARGUMENT,vex_pnt,lclmod,kind,prtype,
8260 VBL_LINNUM );
8261 if (auxflg == 1)
8262 VBL_BEFPNT->BEAUX = vbh_addvbaux (VBL_BEFPNT->BEAUX,vex_pnt,exp,kind,prtype,
8263 VBL_LINNUM );
8264 if (cstflg == 1)
8265 VBL_BEFPNT->BECST = vbh_addvbcst (VBL_BEFPNT->BECST,vex_pnt,exp,prtype,
8266 VBL_LINNUM );
8267 if (genflg == 1)
8268 VBL_BEFPNT->BEGEN = vbh_addvbgen (VBL_BEFPNT->BEGEN,vex_pnt,exp,prtype,
8269 VBL_LINNUM );
8270 if (varflg == 1)
8271 VBL_BEPCS->VARIABLE = vbh_addvbvar(VBL_BEPCS->VARIABLE,vex_pnt, exp, prtype,
8272 VBL_LINNUM );
8273 if (funflg == 1)
8274 VBL_BEFUN->VARIABLE = vbh_addvbvar(VBL_BEFUN->VARIABLE,vex_pnt, exp, prtype,
8275 VBL_LINNUM );
8276 if (gnrflg == 1)
8277 GenVar = vbh_addvbvar( (vbvar_list *)0,vex_pnt,exp,prtype, VBL_LINNUM );
8278 }
8279
8280 if (auxflg == 1)
8281 pnt = (void *) VBL_BEFPNT->BEAUX;
8282 if (cstflg == 1)
8283 pnt = (void *) VBL_BEFPNT->BECST;
8284 if (genflg == 1)
8285 pnt = (void *) VBL_BEFPNT->BEGEN;
8286 if (varflg == 1)
8287 pnt = (void *) VBL_BEPCS->VARIABLE->DATA;
8288 if (gnrflg == 1)
8289 {
8290 pnt = (void *) GenVar->DATA;
8291 freeptype( GenVar );
8292 }
8293 if (funflg == 1)
8294 pnt = (void *) VBL_BEFUN->VARIABLE->DATA;
8295 if (porflg == 1)
8296 pnt = (void *) VBL_BEFPNT->BEPOR;
8297 if (modflg == 1)
8298 pnt = (void *) VBL_BEFPNT->BEMOD->BEPOR;
8299 if (genmodflg == 1)
8300 pnt = (void *) VBL_BEFPNT->BEMOD->BEGEN;
8301 if (parflg == 1)
8302 pnt = (void *) VBL_BEFUN->ARGUMENT;
8303 if (conflg == 1)
8304 pnt = (void *) vex_pnt;
8305
8306 return (pnt);
8307 }
8308
val_type(name)8309 static vbtyp_list *val_type(name)
8310
8311 char *name;
8312 {
8313 return( vbh_getvbtyp( VBL_HEADFIG, name ) );
8314 }
8315
get_type(val)8316 static vbtyp_list *get_type(val)
8317
8318 long val;
8319 {
8320 vbtyp_list *Type;
8321
8322 for ( Type = VBL_BEFPNT->BETYP;
8323 Type != (vbtyp_list *)0;
8324 Type = Type->NEXT )
8325 {
8326 if ( Type->INDEX == val ) break;
8327 }
8328
8329 return( Type );
8330 }
8331
reversetype(pnt)8332 static struct ptype *reversetype(pnt)
8333 struct ptype *pnt;
8334 {
8335 return( (ptype_list *)reverse( (chain_list *)pnt ) );
8336 # if 0
8337 struct ptype* revtype;
8338 struct ptype* aux2;
8339 struct ptype* aux1;
8340
8341 if(pnt == NULL || pnt->NEXT == NULL)
8342 return(pnt);
8343 revtype = pnt;
8344 aux1 = pnt->NEXT;
8345 revtype->NEXT = NULL;
8346 while(aux1)
8347 {
8348 aux2 = revtype;
8349 revtype = aux1;
8350 aux1 = aux1->NEXT;
8351 revtype->NEXT = aux2;
8352 }
8353 return(revtype);
8354 # endif
8355 }
8356