summaryrefslogtreecommitdiffstats
path: root/src/vhdlparser.y
blob: c399daeae31f7e49e8d525adb68f6f24bae651e9 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862
1863
1864
1865
1866
1867
1868
1869
1870
1871
1872
1873
1874
1875
1876
1877
1878
1879
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889
1890
1891
1892
1893
1894
1895
1896
1897
1898
1899
1900
1901
1902
1903
1904
1905
1906
1907
1908
1909
1910
1911
1912
1913
1914
1915
1916
1917
1918
1919
1920
1921
1922
1923
1924
1925
1926
1927
1928
1929
1930
1931
1932
1933
1934
1935
1936
1937
1938
1939
1940
1941
1942
1943
1944
1945
1946
1947
1948
1949
1950
1951
1952
1953
1954
1955
1956
1957
1958
1959
1960
1961
1962
1963
1964
1965
1966
1967
1968
1969
1970
1971
1972
1973
1974
1975
1976
1977
1978
1979
1980
1981
1982
1983
1984
1985
1986
1987
1988
1989
1990
1991
1992
1993
1994
1995
1996
1997
1998
1999
2000
2001
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
2026
2027
2028
2029
2030
2031
2032
2033
2034
2035
2036
2037
2038
2039
2040
2041
2042
2043
2044
2045
2046
2047
2048
2049
2050
2051
2052
2053
2054
2055
2056
2057
2058
2059
2060
2061
2062
2063
2064
2065
2066
2067
2068
2069
2070
2071
2072
2073
2074
2075
2076
2077
2078
2079
2080
2081
2082
2083
2084
2085
2086
2087
2088
2089
2090
2091
2092
2093
2094
2095
2096
2097
2098
2099
2100
2101
2102
2103
2104
2105
2106
2107
2108
2109
2110
2111
2112
2113
2114
2115
2116
2117
2118
2119
2120
2121
2122
2123
2124
2125
2126
2127
2128
2129
2130
2131
2132
2133
2134
2135
2136
2137
2138
2139
2140
2141
2142
2143
2144
2145
2146
2147
2148
2149
2150
2151
2152
2153
2154
2155
2156
2157
2158
2159
2160
2161
2162
2163
2164
2165
2166
2167
2168
2169
2170
2171
2172
2173
2174
2175
2176
2177
2178
2179
2180
2181
2182
2183
2184
2185
2186
2187
2188
2189
2190
2191
2192
2193
2194
2195
2196
2197
2198
2199
2200
2201
2202
2203
2204
2205
2206
2207
2208
2209
2210
2211
2212
2213
2214
2215
2216
2217
2218
2219
2220
2221
2222
2223
2224
2225
2226
2227
2228
2229
2230
2231
2232
2233
2234
2235
2236
2237
2238
2239
2240
2241
2242
2243
2244
2245
2246
2247
2248
2249
2250
2251
2252
2253
2254
2255
2256
2257
2258
2259
2260
2261
2262
2263
2264
2265
2266
2267
2268
2269
2270

/********************************************************************************************* 
 * The original was a VHDL parser description to be used with GMD Compiler
 * Tool Box
 * written from:
 * Jan den Ouden, Jaap Hofstede
 * Department of Computer Science (INF/SPA)
 * University of Twente
 * PB 217, 7500 AE ENSCHEDE, The Netherlands
 * Tel: +31 53 893788
 * Email: hofstede@cs.utwente.nl
 * avail at: ftp.cs.utwente.nl in pub/src/VHDL/Grammar
 *
 * author of YACC transformation:
 * Thomas Dettmer
 * Dortmund University
 * Dept. of Computer Scienc, LS1  
 * PB 500 500
 * D-44221 Dortmund (Germany)
 * Phone: +49-231-755-6464
 * e-mail: dettmer@ls1.informatik.uni-dortmund.de
 *****************************************************************
 * 
 * This file is intended not to be used for commercial purposes
 * without permission of the University of Twente and permission
 * of the University of Dortmund
 *
 * NOTE THAT THERE IS NO WARRANTY FOR CORRECTNES, COMPLETENESS, SUPPORT
 * OR ANYTHING ELSE.
 *
 *******************************************************/
/****************************************************************************** 
 * modified for doxygen by M. Kreis
 * extended to VHDL 93/2002/2008 
 ******************************************************************************/


%{
#include <stdio.h>
#include <qcstring.h>
#include <qstringlist.h>

#ifndef YYSTYPE
typedef int YYSTYPE;
#endif
	
struct  YYMM
{
  int itype;	
  QCString qstr;
};	

// define struct instead of union
#define YYSTYPE YYMM

#include "membergroup.h"
#include "vhdldocgen.h"
#include "doxygen.h"
#include "searchindex.h"
#include "vhdlscanner.h"
#include "commentscan.h"
#include "entry.h"

//-----------------------------variables ---------------------------------------------------------------------------
static MyParserVhdl* myconv=0;

static struct s_contVhdl s_str;
static QList<Entry>instFiles;
static int yyLineNr;
static Entry* lastCompound;
static Entry* currentCompound;
static Entry* lastEntity;
static Entry* current;
static Entry* tempEntry;
static Entry* current_root;
static QCString compSpec;
static QCString currName;
static int levelCounter;
static QCString confName;
static QCString genLabels;

static QList<ConfNode> configL;
static ConfNode* currNode;

static int currP=0;

//---------------------------- function --------------------------------------------------------------------------------

int vhdlScanYYlex (void);
void vhdlScanYYerror (char const *);

static void addVhdlType(QCString name,int startLine,
                        int section,int spec,
			const char* args,const char* type,
			Protection prot=Public);
static void addCompInst(char *n, char* instName,char* comp,int line);

static void newEntry();
static void initEntry(Entry *e);
static bool isFuncProcProced();
static void popConfig();

void pushLabel(QCString label)
{
  genLabels+="|"+label;
}

void popLabel()
{
  int u=genLabels.findRev("|");
  if (u<0) return;
  genLabels=genLabels.left(u); 
}

static void popConfig()
{ 
  assert(currNode);
  currNode=currNode->prevNode;
  // printf("\n pop arch %s ",currNode->arch.data());
}

static void addConfigureNode(char* a,char*b, bool isRoot,bool isLeave,bool inlineConf=false)
{
  struct ConfNode* co;
  QCString ent,arch,lab;
  ent=a;
  lab =  VhdlDocGen::parseForConfig(ent,arch);

  if (b)
  {
    ent=b;
    lab=VhdlDocGen::parseForBinding(ent,arch);
  }

  co=new ConfNode(a,b,confName.data());
  if (inlineConf)
  {
    co->isInlineConf=TRUE;
  }

  if (isRoot)
  {
    co->isRoot=true;
    configL.append(co);
    currNode=co;
    currNode->prevNode=currNode;
  }
  else if (!isLeave)
  {
    currNode->addNode(co);
    co->prevNode=currNode;
    currNode=co;
  }
  else
  {
    assert(0);
    co=new ConfNode(a,b,confName.data());
    currNode->addNode(co);
  }
}// addConfigure



//------------------------------------------------------------------------------------------------------------
static bool addLibUseClause(QCString type)
{
  static bool show=Config_getBool("SHOW_INCLUDE_FILES");
  static bool showIEEESTD=Config_getBool("FORCE_LOCAL_INCLUDES");

  if (!show)  // all libraries and included packages are not shown
  {
    return false;
  }

  if (!showIEEESTD) // all standard packages and libraries are not shown
  {  
    type=type.lower();
    if (type.stripPrefix("ieee")) return false;
    if (type.stripPrefix("std")) return false;
  }  
  return true;
}


static bool isFuncProcProced()
{
  if (currP==VhdlDocGen::FUNCTION || 
      currP==VhdlDocGen::PROCEDURE ||  
      currP==VhdlDocGen::PROCESS
     )
  {
    return true;
  }
  return false;
}


void newVhdlEntry()
{
  newEntry();
}

void initVhdlParser()
{
  lastCompound=0;
  lastEntity=0;
  currentCompound=0;
  lastEntity=0;
  current_root=s_str.root;
  current=new Entry();
  initEntry(current);
}

Entry* getCurrentVhdlEntry()
{
  return current;
}
static void initEntry(Entry *e)
{
  e->fileName = s_str.fileName;
  e->lang=SrcLangExt_VHDL;
  initGroupInfo(e);
}

static void addProto(char *s1,char *s2,char *s3,char *s4,char *s5, char *s6)
{
  (void)s3; // avoid unused warning
  (void)s5; // avoid unused warning
  static QRegExp reg("[\\s]");
  QCString name=s2;
  QStringList ql=QStringList::split(",",name,FALSE);

  for (uint u=0;u<ql.count();u++)
  {
    Argument *arg=new Argument;
    arg->name=(QCString)ql[u];
    arg->type=s4;
    arg->defval=s1;
    arg->attrib=s6;
    current->argList->append(arg);
    current->args+=s2;
    current->args+=",";
  }
}

static bool findInstant(QCString inst)
{
  QListIterator<Entry> eli(instFiles);
  Entry *cur;

  for (eli.toFirst();(cur=eli.current());++eli)
  {
    if (stricmp(inst.data(),cur->type.data())==0)
    {
      return true;
    }
  }
  return false;
}//findInst

QList<Entry> & getVhdlInstList()
{
  return instFiles;
}

static void createFunction(QCString impure,int spec,QCString fname)
{
  int it=0;
  current->bodyLine=getParsedLine(spec);
  current->spec=spec; 
  current->section=Entry::FUNCTION_SEC;
  current->exception=impure;
  if (currP==VhdlDocGen::PROCEDURE)
  {
    current->name=impure;
    it=t_PROCEDURE;
  }
  else
  {
    current->name=fname;
    it=t_FUNCTION;
  }

  if (spec==VhdlDocGen::PROCESS)
  {
    it=t_PROCESS;
    current->args=fname;
    current->name=impure;
    if (!fname.isEmpty())
    { 
      QStringList q1=QStringList::split(',',fname);
      for (uint ii=0;ii<q1.count();ii++)
      {
	Argument *arg=new Argument;
	arg->name=(QCString)q1[ii];    
	current->argList->append(arg);
      }
    }
  }  

  current->startLine=getParsedLine(it);
  current->bodyLine=getParsedLine(it);
}

static void addVhdlType(QCString name,int startLine,int section,int spec,
                        const char* args,const char* type,Protection prot)
{
  static QRegExp reg("[\\s]");

  //int startLine=getParsedLine(spec);

  if (isFuncProcProced())
  {
    return;
  }

  // more than one name   ?
  QStringList ql=QStringList::split(",",name,FALSE);

  for (uint u=0;u<ql.count();u++)
  {
    current->name=(QCString)ql[u];
    if (section==Entry::VARIABLE_SEC && 
	!(spec == VhdlDocGen::USE || spec == VhdlDocGen::LIBRARY) 
       )
    {
      current->name.prepend(VhdlDocGen::getRecordNumber());
    }
    current->startLine=startLine;
    current->bodyLine=startLine;
    current->section=section; 
    current->spec=spec;
    current->fileName=s_str.fileName;
    if (current->args.isEmpty())
    {
      current->args=args;
      current->args.replace(reg,"%"); // insert dummy chars because wihte spaces are removed
    }
    current->type=type;
    current->type.replace(reg,"%"); // insert dummy chars because white spaces are removed
    current->protection=prot;
    newEntry();
  }
}

static void newEntry()
{
  if (current->spec==VhdlDocGen::ENTITY       || 
      current->spec==VhdlDocGen::PACKAGE      || 
      current->spec==VhdlDocGen::ARCHITECTURE || 
      current->spec==VhdlDocGen::PACKAGE_BODY
     )
  {
    current_root->addSubEntry(current);
  }
  else
  {
    if (lastCompound) 
    {
      lastCompound->addSubEntry(current);
    }
    else
    {
      if (lastEntity)
      {
	lastEntity->addSubEntry(current);
      }
      else 
      {
	current_root->addSubEntry(current); 
      }
    }
  }
  current = new Entry ;
  initEntry(current);
}

%}

%token
t_ABSTRLIST
t_CHARLIST
t_DIGIT
t_STRING
t_LETTER
t_ACCESS
t_AFTER
t_ALIAS
t_ALL
t_AND
t_ARCHITECTURE
t_ARRAY
t_ASSERT
t_ATTRIBUTE
t_BEGIN
t_BLOCK
t_BODY
t_BUFFER
t_BUS
t_CASE
t_COMPONENT
t_CONFIGURATION
t_CONSTANT
t_DISCONNECT
t_DOWNTO
t_ELSE
t_ELSIF
t_END
t_ENTITY
t_EXIT
t_FILE
t_FOR
t_FUNCTION
t_GENERATE
t_GENERIC
t_GUARDED
t_IF
t_IN
t_INOUT
t_IS
t_LABEL
t_LIBRARY
t_LINKAGE
t_LOOP
t_MAP
t_NAND
t_NEW
t_NEXT
t_NOR
t_NULL
t_OF
t_ON
t_OPEN
t_OR
t_OTHERS
t_OUT
t_PACKAGE
t_PORT
t_PROCEDURE
t_PROCESS
t_RANGE
t_RECORD
t_REGISTER
t_REPORT
t_RETURN
t_SELECT
t_SEVERITY
t_SIGNAL
t_SUBTYPE
t_THEN
t_TO
t_TRANSPORT
t_TYPE
t_UNITS
t_UNTIL
t_USE
t_VARIABLE
t_WAIT
t_WHEN
t_WHILE
t_WITH
t_XOR

/* new keywords */
t_IMPURE
t_PURE
t_GROUP
t_POSTPONED
t_SHARED
t_XNOR
t_SLL  
t_SRA 
t_SLA 
t_SRL
t_ROR 
t_ROL
t_UNAFFECTED
/*============== VHDL 2008 keywords   ======================= */

t_ASSUME_GUARANTEE
t_ASSUME
t_CONTEXT
t_COVER
t_DEFAULT
t_FAIRNESS
t_FORCE
t_INERTIAL
t_LITERAL
t_PARAMETER
t_PROTECTED
t_PROPERTY
t_REJECT
t_RELEASE
t_RESTRICT
t_RESTRICT_GUARANTEE
t_SEQUENCE
t_STRONG
t_VMODE
t_VPROP
t_VUNIT


/*============== VHDL binary operators 2008   ======================= */

t_SLSL
t_SRSR
t_QQ
t_QGT
t_QLT
t_QG
t_QL
t_QEQU
t_QNEQU

%nonassoc t_EQSym t_NESym t_LTSym t_LESym t_GTSym t_GESym t_QNEQU t_QEQU t_QL t_QG t_QLT  t_QGT
%left t_Plus t_Minus t_Ampersand
%left MED_PRECEDENCE
%left t_Star t_Slash t_MOD t_REM 
%nonassoc t_DoubleStar t_ABS t_NOT MAX_PRECEDENCE 

/* misc syms */
/*t_Space */

%token 
t_Apostrophe
t_LeftParen
t_RightParen
t_Comma
t_VarAsgn
t_Colon
t_Semicolon
t_Arrow
t_Box
t_Bar
t_Dot
t_Q
t_At
t_Neg
t_LEFTBR
t_RIGHTBR
t_ToolDir
 
%type<qstr> designator literal enumeration_literal physical_literal physical_literal_no_default physical_literal_1
%type<qstr> lib_clause use_clause sel_list entity_decl entity_start entity_decl_2 entity_decl_1 arch_body arch_start arch_body_1 
%type<qstr> config_decl config_start config_decl_2 config_decl_1 config_decl_3 package_decl package_start package_body pack_body_start package_body_2 package_body_1 common_decltve_item 
%type<qstr> config_decltve_item subprog_decl subprog_body interf_list interf_element interf_element_4 interf_element_3 interf_element_2 interf_element_1 mode
%type<qstr> association_list association_list_1 association_list_2 gen_association_list gen_association_list_1 gen_association_list_2 association_element gen_association_element formal_part actual_part mark expr and_relation relation primary name name2 sel_name suffix ifts_name 
%type<qstr> attribute_name aggregate element_association_list2 qualified_expr element_association choices choices_1 choices_2 choice type_decl type_decl_1 type_definition enumeration_type_definition enumeration_type_definition_1 enumeration_type_definition_2 physical_type_definition physical_type_definition_1 physical_type_definition_2 base_unit_decl secondary_unit_decl unconstrained_array_definition unconstrained_array_definition_1 unconstrained_array_definition_2 index_subtype_definition constrained_array_definition record_type_definition record_type_definition_1 record_type_definition_2 element_decl 
%type<qstr> access_type_definition file_type_definition subtype_decl subtype_indic subtype_indic_1 subtype_indic1 subtype_indic1_1 range_constraint index_constraint index_constraint_1 index_constraint_2 discrete_range discrete_range1 range_spec direction constant_decl constant_decl_1 signal_decl signal_decl_2 signal_decl_1 variable_decl variable_decl_1 object_class signal_kind alias_decl file_decl file_decl_1 attribute_decl attribute_spec entity_spec entity_name_list entity_name_list_1 
%type<qstr> entity_name_list_2 entity_class block_stat 
%type<qstr> generate_stat generate_stat_1 procs_stat procs_stat1 procs_stat1_1 sensitivity_list sensitivity_list_1 sensitivity_list_2 
%type<qstr> procedure_call_stat comp_decl comp_decl_2 comp_decl_1 block_config block_config_2 block_config_3 block_config_1 block_config_4 block_spec config_item comp_config comp_config_2 comp_config_1 config_spec binding_indic comp_spec 
%type<qstr> inst_list entity_aspect idf_list procs_stat1_6 
%type<qstr> t_Identifier t_StringLit t_BitStringLit t_AbstractLit t_CharacterLit tbox group_name record_type_simple_name
%type<qstr> entity_class_entry_list entity_class_entry group_constituent_list group_constituent group_declaration group_template_declaration
%type<qstr> procs_stat1_5 comp_1 mark_comp dot_name fi_dec multiplying_operator factor term adding_op
%type<qstr> simple_exp alias_spec sigma signature1 mark_stats mark_stats_1 signature 
%type<qstr> protected_type_body protected_type_declaration alias_name_stat vcomp_stat comp_spec_stat 

%debug

// for debugging set yydebug=1
%initial-action { yydebug=0; } 

%expect 2

// minimum bison version
//%require "2.2"

%%
start: design_file


design_file     : design_unit_list
                   
design_unit_list: design_unit
                          | design_unit_list design_unit  
                          ;            

designator : t_Identifier	                     {$$=$1;}
                   | t_StringLit                       {$$=$1;}
                   ;

literal    : t_AbstractLit                             {$$=$1;}
             | t_CharacterLit                          {$$=$1;}
             | t_BitStringLit                            {$$=$1;}                     
             | physical_literal_no_default     {$$=$1;}
             | t_NULL                                     {$$="null";}
             ;

enumeration_literal  : t_CharacterLit  {$$=$1;}
                                  | t_Identifier       {$$=$1;}

physical_literal     : physical_literal_1 t_Identifier  {$$=$1+" "+$2;}  

physical_literal_1    : /* empty */        {$$="";}
                                 | t_AbstractLit      {$$=$1;}

physical_literal_no_default    : t_AbstractLit t_Identifier   {$$=$1+" "+$2;}  

idf_list : t_Identifier {$$=$1;}
            | idf_list t_Comma t_Identifier {$$=$1+","+$3};
            ;

/*------------------------------------------
--  Desing Unit
--------------------------------------------*/

 design_unit     : context_list lib_unit  
 
 context_list    :  /* empty */
                        | context_list context_item  

 lib_unit    : entity_decl  
                 | config_decl  
                 | package_decl  
                 | arch_body  
                 | package_body  
                 | context_decl
                 | package_instantiation_decl
                 ;
                 
context_item    : lib_clause  
                           | use_clause  
                           ;
                           
lib_clause  : t_LIBRARY idf_list t_Semicolon  
{
                 if (addLibUseClause($2))
                   addVhdlType($2,getParsedLine(t_LIBRARY),Entry::VARIABLE_SEC,VhdlDocGen::LIBRARY,$2.data(),0);              
}

use_clause : t_USE sel_list t_Semicolon  
 {
                 QStringList ql1=QStringList::split(",",$2,FALSE);
                 for (uint j=0;j<ql1.count();j++)
                 {
                   QStringList ql=QStringList::split(".",ql1[j],FALSE);
                   QCString it=(QCString)ql[1];;
                   if (addLibUseClause(it))
                     addVhdlType(it,getParsedLine(t_USE),Entry::VARIABLE_SEC,VhdlDocGen::USE,it.data(),0);              
                 }
 }

sel_list : sel_name		{$$=$1;}
            | sel_list t_Comma sel_name {	$$=$1+","+$3;}
            ;
/*------------------------------------------
--  Library Units
--------------------------------------------*/

entity_decl : entity_start error comp_end_dec  t_Semicolon

entity_decl : entity_start entity_decl_1 entity_decl_2
                     entity_decl_3 entity_decl_4   comp_end_dec  t_Semicolon

entity_start: t_ENTITY t_Identifier t_IS
                      {
                        $$=$2;
                        lastEntity=current;
                        addVhdlType($$,getParsedLine(t_ENTITY),Entry::CLASS_SEC,VhdlDocGen::ENTITY,0,0,Public);
                        //fprintf(stderr,"\n entiy %s : at line %d",$$.data(),s_str.yyLineNr);
                      }
                  ;	


entity_decl_5 :   /* empty */
                       |  t_Identifier
                   
                      ;
entity_decl_4 :  /* empty */
                      | t_BEGIN concurrent_stats  
                      ;
entity_decl_3 :  /* empty */
                       | entity_decl_3 entity_decl_6  
                       ;

entity_decl_6 : entity_decltve_item  

entity_decl_2 : /* empty */  {$$="";}
                       | t_PORT {currP=VhdlDocGen::PORT;}  interf_list t_Semicolon  {currP=0;} 
                       ;
entity_decl_1 :  /* empty */  {$$="";}
                       | t_GENERIC {currP=VhdlDocGen::GENERIC;} interf_list t_Semicolon{currP=0;}  
                       | t_GENERIC error t_Semicolon{currP=0;}  
                   
                       ;


arch_body : arch_start arch_body_1 t_BEGIN concurrent_stats t_END arch_body_2 t_Semicolon 
arch_body : arch_start error t_END arch_body_2 t_Semicolon  

arch_start : t_ARCHITECTURE t_Identifier t_OF t_Identifier t_IS 
                     {
                        $$=$4;
                        $$+="::";
                        $$+=$2;
                         pushLabel($2);
                        lastCompound=current;
                        addVhdlType($$,getParsedLine(t_ARCHITECTURE),Entry::CLASS_SEC,VhdlDocGen::ARCHITECTURE,0,0,Private);
                      }
arch_body_2  :  /* empty */ 
arch_body_2  : t_Identifier  
arch_body_2  :  t_ARCHITECTURE  t_Identifier
arch_body_2 :  t_ARCHITECTURE  

arch_body_1  :  /* empty */  {$$="";}
                         arch_body_1  : arch_body_1 arch_body_3  

arch_body_3  : block_decltve_item  

config_decl : config_start error  t_END config_decl_2 t_Semicolon {genLabels.resize(0);}
config_decl : config_start config_decl_1 block_config t_END config_decl_2 t_Semicolon {genLabels.resize(0);}
                      {
                             confName="";
                         }

 
config_start : t_CONFIGURATION t_Identifier t_OF t_Identifier t_IS 
                      {
                       confName=$2+"::"+$4;
                        addVhdlType($2.data(),getParsedLine(t_CONFIGURATION),Entry::VARIABLE_SEC,VhdlDocGen::CONFIG,"configuration",$4.data());
                      }

config_decl_2    : /* empty */    {$$="";}
config_decl_2    : t_Identifier  { $$=$1;}
config_decl_2    : t_CONFIGURATION { $$="configuration";}
config_decl_2    : t_CONFIGURATION t_Identifier  { $$=$2;}
config_decl_1    :  /* empty */  {$$="";}
config_decl_1    : config_decl_1 config_decl_3  { $$=$1+" "+$2;} 
config_decl_3    : config_decltve_item                 { $$=$1;}

package_decl  : package_start error t_END package_decl_2 t_Semicolon  
package_decl  : package_start package_decl_1 t_END package_decl_2 t_Semicolon  
package_start : t_PACKAGE t_Identifier t_IS 
                           {
                          lastCompound=current;
                      
                           
         Entry *clone=new Entry(*current);
         clone->section=Entry::NAMESPACE_SEC;
         clone->spec=VhdlDocGen::PACKAGE;
           clone->name=$2;
         clone->startLine= getParsedLine(t_PACKAGE);
           clone->bodyLine= getParsedLine(t_PACKAGE);
      
         clone->protection=Package;
             current_root->addSubEntry(clone);
                
                      
                        addVhdlType($2,getParsedLine(t_PACKAGE),Entry::CLASS_SEC,VhdlDocGen::PACKAGE,0,0,Package);
                        //fprintf(stderr,"\n entiy %s : at line %d",$$.data(),s_str.yyLineNr);
                       }

package_decl_2     :  /* empty */  
package_decl_2     : t_Identifier  {lastCompound=0;}
package_decl_2     : t_PACKAGE t_Identifier {lastCompound=0;}
package_decl_2     : t_PACKAGE {lastCompound=0;}
 
package_decl_1     :  /* empty */  
package_decl_1    : package_decl_22
package_decl_1     : package_decl_1 package_decl_3  
package_decl_3     : package_decltve_item  

package_decl_22: gen_interface_list t_Semicolon
package_decl_22: gen_interface_list
package_decl_22: gen_interface_list gen_assoc_list
package_decl_22: gen_interface_list gen_assoc_list t_Semicolon

package_body    : pack_body_start error t_END package_body_2 t_Semicolon 
package_body    : pack_body_start package_body_1 t_END package_body_2 t_Semicolon  
pack_body_start : t_PACKAGE t_BODY t_Identifier t_IS 
                      {
                        $$=$3;
                        lastCompound=current;
                        $$.prepend("_");
                        addVhdlType($$,getParsedLine(t_PACKAGE) ,Entry::CLASS_SEC,VhdlDocGen::PACKAGE_BODY,0,0,Protected);
                      }
package_body_2  :  /* empty */  {$$="";lastCompound=0;}
package_body_2  : t_Identifier                                            {lastCompound=0;}
package_body_2  : t_PACKAGE t_BODY                         {lastCompound=0;}
package_body_2  : t_PACKAGE t_BODY t_Identifier      {lastCompound=0;}


package_body_1  :  /* empty */  {$$="";}
package_body_1  : package_body_1 package_body_3  
package_body_3  : package_body_decltve_item  



/*------------------------------------------
--  Declarative Item
--------------------------------------------*/

common_decltve_item_1    : package_decl
common_decltve_item_1    : package_instantiation_decl
common_decltve_item_1    : package_body
common_decltve_item_1    : subprogram_instantiation_decl 


common_decltve_item   : type_decl  
common_decltve_item   : subtype_decl  
common_decltve_item   : constant_decl  
common_decltve_item   : file_decl  
common_decltve_item   : alias_decl  
common_decltve_item   : subprog_decl  
common_decltve_item   : use_clause  

entity_decltve_item   : common_decltve_item  
entity_decltve_item   : subprog_body 
entity_decltve_item   : attribute_decl  
entity_decltve_item   : attribute_spec  
entity_decltve_item   : disconnection_spec  
entity_decltve_item   : signal_decl  
entity_decltve_item   : variable_decl 
entity_decltve_item  :  group_template_declaration 
entity_decltve_item :   group_declaration 
entity_decltve_item :  common_decltve_item_1 


block_decltve_item    : common_decltve_item  
block_decltve_item    : subprog_body  
block_decltve_item    : comp_decl  
block_decltve_item    : attribute_decl  
block_decltve_item    : attribute_spec  
block_decltve_item    : config_spec  
block_decltve_item    : disconnection_spec  
block_decltve_item    : signal_decl  
block_decltve_item    : variable_decl
block_decltve_item  : group_template_declaration 
block_decltve_item  : group_declaration
block_decltve_item  :     common_decltve_item_1
block_decltve_item  : tool_directive
block_declarative_part :  block_decltve_item 
                                       | block_declarative_part  block_decltve_item 
                                       
                                       
package_decltve_item  : common_decltve_item  
package_decltve_item  : comp_decl  
package_decltve_item  : attribute_decl  
package_decltve_item  : attribute_spec  
package_decltve_item  : disconnection_spec  
package_decltve_item  : signal_decl  
package_decltve_item  : variable_decl 
package_decltve_item  : group_template_declaration 
 package_decltve_item : group_declaration
 package_decltve_item : package_decl
 package_decltve_item : package_instantiation_decl
 package_decltve_item : subprogram_instantiation_decl
 
package_body_decltve_item  : common_decltve_item  
package_body_decltve_item  : subprog_body  
package_body_decltve_item  :  variable_decl 
package_body_decltve_item  : group_template_declaration 
package_body_decltve_item  : group_declaration
package_body_decltve_item :attribute_decl
package_body_decltve_item :attribute_spec
package_body_decltve_item : common_decltve_item_1

subprog_decltve_item    : common_decltve_item  
subprog_decltve_item    : subprog_body  
subprog_decltve_item    : attribute_decl  
subprog_decltve_item    : attribute_spec  
subprog_decltve_item    : variable_decl  
subprog_decltve_item    : group_template_declaration 
subprog_decltve_item    : group_declaration
subprog_decltve_item    :  common_decltve_item_1

procs_decltve_item  : common_decltve_item  
procs_decltve_item  : subprog_body  
procs_decltve_item  : attribute_decl  
procs_decltve_item  : attribute_spec  
procs_decltve_item  : variable_decl  
procs_decltve_item  : group_template_declaration 
procs_decltve_item  : group_declaration
procs_decltve_item  : common_decltve_item_1

config_decltve_item : attribute_spec  { $$=$1;}
config_decltve_item : use_clause  { $$=$1;}
config_decltve_item : group_declaration { $$=$1;}
config_decltve_item: t_USE t_VUNIT idf_list t_Semicolon { $$=$3;}

/*------------------------------------------
--  Subprograms
--------------------------------------------*/
func_prec: t_PURE
func_prec: t_IMPURE

subprog_decl    : subprog_spec t_Semicolon  {currP=0;}

subprog_spec  : t_PROCEDURE t_Identifier {currP=VhdlDocGen::PROCEDURE; createFunction($2,currP,0); }  subprog_spec_1 {  newEntry(); }
subprog_spec  : func_prec t_FUNCTION designator subprog_spec_2 t_RETURN mark  
subprog_spec  :  t_FUNCTION designator 
{
  currP=VhdlDocGen::FUNCTION;
  createFunction(0,currP,$2.data()); 
}  subprog_spec_2 t_RETURN mark  
{
  tempEntry=current;
  current->type=$6; 
  newEntry();
}

subprog_spec_22: gen_interface_list
subprog_spec_22: gen_interface_list gen_assoc_list

subprog_spec_33: t_PARAMETER  interf_list 
subprog_spec_33:  interf_list 

subprog_spec_2     :  /* empty */ 
subprog_spec_2     : subprog_spec_22 subprog_spec_33
subprog_spec_2     :  subprog_spec_33
subprog_spec_2  : subprog_spec_22
                                                                
subprog_spec_1     :  subprog_spec_2

subprog_body : subprog_spec t_IS  subprog_body_1 t_BEGIN   seq_stats t_END subprog_body_2 t_Semicolon  
{ 
  currP=0;
}
subprog_body : subprog_spec t_IS error  t_END subprog_body_2 t_Semicolon  
{ 
  currP=0;
}
subprog_body_2    :  /* empty */  
subprog_body_2    : designator  
subprog_body_2    : t_FUNCTION 
subprog_body_2    : t_PROCEDURE  
subprog_body_2    : t_PROCEDURE t_Identifier 
subprog_body_2    : t_FUNCTION t_Identifier  
subprog_body_2    : t_FUNCTION t_STRING

 
subprog_body_1    :  /* empty */ 
//subprog_body_1    :  subprogram_instantiation_decl
subprog_body_1    : subprog_body_1 subprog_body_3  
subprog_body_3    : subprog_decltve_item  

/*--------------------------------------------------
--  Interface Lists and Associaton Lists
----------------------------------------------------*/

interf_list  : t_LeftParen interf_element interf_list_1 t_RightParen   {$$="";}
interf_list  : t_LeftParen error t_RightParen   {$$="";}
interf_list_1     :  /* empty */ 
interf_list_1     : interf_list_1 interf_list_2  
interf_list_2     : t_Semicolon interf_element  

    
interf_element  : interface_package_decl  {$$="";}
interf_element  : interface_subprogram_decl   {$$="";}
interf_element  : interf_element_1  t_Identifier  {$$="";}
interf_element    : interf_element_1 idf_list t_Colon interf_element_2 subtype_indic interf_element_3 interf_element_4  
                          {
                            if (currP!=VhdlDocGen::COMPONENT)
                            {      
                              if (currP==VhdlDocGen::FUNCTION ||  currP==VhdlDocGen::PROCEDURE)
			      {
                                addProto($1.data(),$2.data(),$4.data(),$5.data(),$6.data(),$7.data());
			      }
                              else 
			      {
                                QCString i=$5+$6+$7;
                                addVhdlType($2,s_str.iLine,Entry::VARIABLE_SEC,currP,i.data(),$4.data());
                              }
                               //   fprintf(stderr,"\n\n <<port  %s  >>\n",$$.data());
                             } // if component
                           }
interf_element_4  :  /* empty :=*/ {$$="";}
interf_element_4  : t_VarAsgn expr  {$$=":="+$2;}
interf_element_3  :  /* empty */   {$$="";}
interf_element_3  : t_BUFFER {$$="buffer";}
interf_element_3  : t_BUS {$$="bus";}
interf_element_2  :  /* empty */  {$$="";}
interf_element_2  : mode  {$$=$1;}
interf_element_1  :  /* empty */  {$$="";}
interf_element_1  : object_class   {$$=$1;}

mode  : t_IN                     {$$="in";}
mode  : t_OUT                 {$$="out";}
mode  : t_INOUT             {$$="inout";}
mode  : t_BUFFER          {$$="buffer";}
mode  : t_LINKAGE        {$$="link";}

association_list     : t_LeftParen association_element association_list_1 t_RightParen  {$$="("+$2+")";}
association_list_1   :  /* empty */  {$$="";}
association_list_1   : association_list_1 association_list_2  {$$=$1+" "+$2; }
association_list_2   : t_Comma association_element           {$$=", "+$2; }

gen_association_list : t_LeftParen           gen_association_element           gen_association_list_1            t_RightParen 
{     
  QCString str="( "+$2;
  str.append(" )");
  $$=str;
} 
gen_association_list : t_LeftParen  error   t_RightParen {$$="";}
gen_association_list :t_LeftParen t_OPEN  t_RightParen {$$=" ( open ) ";}

gen_association_list_1    :  /* empty */  {$$="";}
gen_association_list_1    : gen_association_list_1   gen_association_list_2  {$$=$1+"?? "+$2; }
gen_association_list_2    : t_Comma         gen_association_element   {$$=","+$2;}

association_element  : formal_part           t_Arrow              actual_part    {$$=$1+"=>"+$3;}
association_element  : actual_part    {$$=$1;}
association_element  : t_Box         {$$="<>";}
association_element  : t_DEFAULT {$$="default";}

/* changed ;gen_association_element   : association_element  */
gen_association_element   : expr     {      $$=$1; }
gen_association_element   : choice  t_Arrow expr 
gen_association_element   :discrete_range1                 {  $$=$1 ;}

formal_part     : name  {$$=$1;}

actual_part     : expr            {$$=$1;}
actual_part     : t_OPEN    {$$="open";}
actual_part     : t_INERTIAL expr    {$$="inertial";}

/*--------------------------------------------------
--  Names and Expressions
----------------------------------------------------*/



expr : and_relation  {$$=$1;}
expr : relation  {$$=$1;}

shift_op: t_SLL  
              | t_SRA 
              | t_SLA 
              |t_SRL
              |t_ROR 
              |t_ROL
              ;
and_relation    : relation  shift_op  relation 
and_relation    : relation  t_AND relation  
and_relation    : relation  t_XOR relation  
and_relation    : relation  t_OR relation  
and_relation    : relation  t_NOR relation
and_relation    : relation  t_XNOR relation
and_relation    : relation  t_NAND relation      
and_relation    : and_relation  t_NAND relation 
and_relation    : and_relation  t_NOR relation
and_relation    : and_relation  t_XNOR relation
and_relation    : and_relation  t_AND relation
and_relation    : and_relation  t_OR relation
and_relation    : and_relation  t_XOR relation

 
                         
/* ;relation   : unary_operator primary   */


relation :  t_QQ primary                                                                               {$$=" ?? "+$2;}
relation   : primary                                                                                       {$$=$1;}
relation   : t_Plus primary  %prec MED_PRECEDENCE                        {$$="+"+$2;}
relation   : t_Minus primary %prec MED_PRECEDENCE                       {$$="-"+$2 ;}
relation   : t_ABS primary    {$$="abs"+$2;} 
relation   : t_NOT primary    {$$="not "+$2;}
relation   : primary t_DoubleStar primary {$$=$1+" ** "+$3;}
relation   : t_Minus primary t_DoubleStar primary {$$=$2+" ** "+$4;}

/* ;    relation : relation binary_operator primary */

relation   : relation t_MOD relation {$$=$1+" mod  "+$3;}
relation   : relation t_REM relation {$$=$1+" rem "+$3;}
relation   : relation t_Ampersand relation {$$=$1+" & "+$3;}
relation   : relation t_Star relation             {$$=$1+" * "+$3;}
relation   : relation t_Plus relation            {$$=$1+" + "+$3;}
relation   : relation t_Minus relation        {$$=$1+" -  "+$3;}
relation   : relation t_LESym relation     {$$=$1+" <= "+$3;}
relation   : relation t_GESym relation  {$$=$1+" >= "+$3;}
relation   : relation t_LTSym relation     {$$=$1+" <  "+$3;}
relation   : relation t_GTSym relation    {$$=$1+" >  "+$3;}
relation   : relation t_EQSym relation   {$$=$1+" ==  "+$3;}
relation   : relation t_NESym relation   {$$=$1+" != "+$3;}
relation   : relation t_Slash relation     {$$=$1+" /"+$3;}
relation   : relation  t_QNEQU  relation  {$$=$1+" ?/="+$3;}
relation    : relation   t_QEQU  relation {$$=$1+" ?="+$3;}
relation    : relation  t_QL  relation    {$$=$1+" ?<"+$3;}
relation    : relation   t_QG  relation   {$$=$1+" ?>"+$3;}
relation    : relation  t_QLT relation    {$$=$1+" ?<="+$3;}
relation    : relation  t_QGT relation    {$$=$1+" ?>="+$3;}



simple_exp: t_Minus  term  { $$ = "-"+$2;}
                   | t_Plus  term     { $$ = "+"+$2;}
                   | term                  { $$ = $1;}
                   | simple_exp  adding_op term { $$ = $1+" "+$2+" "+$3;}

adding_op: t_Ampersand { $$ = "&";}
                  | t_Minus          { $$ = "-";}
                  | t_Plus            { $$ = "+";}
                 ;
                  
term : factor   { $$=$1; }
         |  factor  multiplying_operator factor  { $$ = $1+" "+$2+" "+$3;}
        ;
         
multiplying_operator: t_Star       { $$ = "*";}
                                  | t_REM     { $$ = "rem";}
                                  | t_MOD     { $$ = "mod";}
                                  | t_Slash    { $$ = "/";}
         
factor : primary                                   {  $$=$1; }
          | t_ABS  primary                      {  $$="abs "+$2; }
          | t_NOT  primary                      {  $$="not  "+$2; }
          |  primary t_DoubleStar  primary { $$ = $1+" ** "+$3;}


primary    : name                                  {$$=$1;}
primary    : literal                                  {$$=$1;}
primary    : aggregate                          {$$=$1;}
primary    : qualified_expr                    {$$=$1;}
primary    : allocator                             {$$="";}
primary    : t_LeftParen expr t_RightParen {$$="("+$2+")";}  


name  : mark      {$$=$1;}
name  : name2  {$$=$1;}
name : external_name  {$$="";}
name2 : t_StringLit          {$$=$1;}
name2 : attribute_name   {$$=$1;}
name2 : ifts_name           {$$=$1;}

mark  : t_Identifier   {$$=$1;}	
mark  : sel_name  {$$=$1;}

sel_name   : name t_Dot suffix   {$$=$1+"."+$3;}

suffix     : designator       {$$=$1;}
suffix     : t_CharacterLit {$$=$1;}
suffix     : t_ALL               {$$="all";}

ifts_name  : mark gen_association_list  {$$=$1+" "+$2;}
ifts_name  : name2 gen_association_list  {$$=$1+" "+$2;}


sigma:  t_Apostrophe {$$="'";}
//sigma :  t_LEFTBR signature1 t_RIGHTBR  t_Apostrophe {$$="("+$2;;$$.append(")");$$.append("'");}

attribute_name  : mark  sigma t_Identifier    {$$=$1+"' "+$3;}
attribute_name  :attribute_name     t_LeftParen  expr t_RightParen                       
attribute_name  : name2 sigma t_Identifier   {$$=$1+" '"+$3;}
attribute_name : mark sigma t_RANGE       {$$=$1+"' range ";}
attribute_name : name2 sigma t_RANGE   {$$=$1+"' range ";}

aggregate  : element_association_list2 t_RightParen  {$$=$1+" ) ";}
aggregate  : t_LeftParen choices t_Arrow expr t_RightParen  {$$="( "+$2+ "=>"+$4+" ) ";}


element_association_list2 : t_LeftParen element_association t_Comma element_association  {$$=" ( "+$2+","+$4;}
element_association_list2 : element_association_list2 t_Comma element_association   {$$=$1+","+$3;}
 

qualified_expr : mark t_Apostrophe t_LeftParen expr  t_RightParen    {$$=$1+"'("+$4+" ) ";}
qualified_expr : mark t_Apostrophe aggregate  {$$=$1+"'"+$3;}


allocator  : t_NEW mark mark allocator_1  
allocator  : t_NEW mark allocator_2  
allocator  : t_NEW qualified_expr  
allocator_2     :  /* empty */ 
allocator_2     : gen_association_list  
allocator_1     :  /* empty */ 
allocator_1     : gen_association_list  


/*--------------------------------------------------
--  Element Association and Choices
----------------------------------------------------*/

element_association  : choices t_Arrow expr   {$$=$1+"=> "+$3;} 

element_association  : expr    {$$=$1;}

choices    : choice choices_1      {$$=$1+" "+$2;}
choices_1  :  /* empty */  {$$="";}
choices_1  : choices_1 choices_2  {$$=$1+" "+$2;}
choices_2  : t_Bar choice     {$$=" | "+$2;}

choice     : expr                         {$$=$1;}
choice     : discrete_range1     {$$=$1;}
choice     : t_OTHERS             {$$="others";}

/*--------------------------------------------------
--	Type Declarations
----------------------------------------------------*/
type_decl :  t_TYPE t_Identifier error  t_Semicolon  {$$="";}
type_decl     : t_TYPE t_Identifier type_decl_1 t_Semicolon 
                        {
                             addVhdlType($2,getParsedLine(t_TYPE),Entry::VARIABLE_SEC,VhdlDocGen::TYPE,0,$3.data());
                         }
 type_decl     :  t_TYPE error  t_Semicolon  {$$="";}

type_decl_1   :  /* empty */  {$$="";}
type_decl_1   : t_IS type_definition  {$$="is "+$2;}

type_definition : enumeration_type_definition       {$$=$1;}
type_definition : range_constraint                           {$$=$1;}
type_definition : physical_type_definition              {  $$=$1; }
type_definition : unconstrained_array_definition    {$$=$1;}
type_definition : constrained_array_definition      {$$=$1;}
type_definition : record_type_definition                {$$=$1;}
type_definition : access_type_definition               {$$=$1;}
type_definition : file_type_definition                       {$$=$1;}
type_definition : protected_type_declaration           {$$=$1;}    
type_definition : protected_type_body                    {$$=$1;}


enumeration_type_definition    : t_LeftParen enumeration_literal enumeration_type_definition_1 t_RightParen  {$$="( "+$2+" "+$3+" )";}
enumeration_type_definition_1  :   {$$="";}
enumeration_type_definition_1  : enumeration_type_definition_1 enumeration_type_definition_2   {$$=$1+" "+$2;}
enumeration_type_definition_2  : t_Comma enumeration_literal   {$$=","+$2;}

physical_type_definition : range_constraint  t_UNITS base_unit_decl
physical_type_definition_1 t_END unit_stat
                                           {
                                                 $$=$1;
                                                 current->args=$3+"#"+$4;
                                                 current->args.prepend("units");
                                                 current->spec=VhdlDocGen::UNITS;
                                               }

unit_stat:   t_UNITS  t_Identifier
unit_stat : t_UNITS 


physical_type_definition_1     :  /* empty */ {$$="";}
physical_type_definition_1     : physical_type_definition_1 physical_type_definition_2   {$$=$1+" "+$2;}
physical_type_definition_2     : secondary_unit_decl  {$$=$1+"#";}

base_unit_decl     : t_Identifier t_Semicolon  {$$=$1;}

secondary_unit_decl     : t_Identifier t_EQSym physical_literal t_Semicolon  {$$=$1+"="+$3}

unconstrained_array_definition : t_ARRAY t_LeftParen
index_subtype_definition unconstrained_array_definition_1 t_RightParen t_OF
subtype_indic 
{
  QCString sr1=" array ( "+$3+" "+$4;
  QCString sr2=" ) of "+$7;

  $$=sr1+sr2;
}

unconstrained_array_definition_1    :  {$$="";}
unconstrained_array_definition_1    : unconstrained_array_definition_1 unconstrained_array_definition_2     {$$=$1+"  "+$2}
unconstrained_array_definition_2    : t_Comma index_subtype_definition   {$$=", "+$2}

index_subtype_definition  : mark t_RANGE t_Box   {$$=$1+" range<> ";}

constrained_array_definition   : t_ARRAY index_constraint t_OF subtype_indic  {$$=" array "+$2+" of "+$4;}

record_type_simple_name :/*empty*/      {$$="";}
                                              | t_Identifier  {$$=$1;}
 
record_type_definition : t_RECORD element_decl record_type_definition_1 t_END
t_RECORD record_type_simple_name
{
  QRegExp reg("[\\s]");
  QCString oo=$2+" "+$3; 
  current->spec=VhdlDocGen::RECORD;
  current->args=oo;
   current->args.replace(reg,"%"); 
  current->args.prepend("record");
  $$=$2+" "+$3;
} 
    
record_type_definition_1  :   /*empty*/      {$$="";}
record_type_definition_1  : record_type_definition_1 record_type_definition_2   
   {
      $$=$1+" "+$2; 
    }
record_type_definition_2  : element_decl   {$$=$1;}

element_decl  : idf_list t_Colon subtype_indic t_Semicolon   {$$=$1+":"+$3+"#"; }

access_type_definition    : t_ACCESS subtype_indic   {$$="access "+$2; }

file_type_definition : t_FILE t_OF mark  {$$="file of "+$3; }

/*--------------------------------------------------
--  Subtypes and Constraints
----------------------------------------------------*/

subtype_decl  : t_SUBTYPE t_Identifier t_IS subtype_indic t_Semicolon  
                         {
                              addVhdlType($2,getParsedLine(t_SUBTYPE),Entry::VARIABLE_SEC,VhdlDocGen::SUBTYPE,0,$4.data());
                         }
subtype_decl  : t_SUBTYPE error  t_Semicolon   {$$="";}
subtype_indic   : mark subtype_indic_1                    {$$=$1+" "+$2;};  
subtype_indic   : subtype_indic1                               {$$=$1;}
subtype_indic_1 :  /* empty */  {$$="";}
subtype_indic_1 : gen_association_list                    {$$=$1;}

subtype_indic1  : mark mark range_constraint         {$$=$1+" "+$2+" "+$3;}; 
subtype_indic1  : mark range_constraint                  {$$=$1+" "+$2;}
subtype_indic1  : mark mark subtype_indic1_1       {$$=$1+" "+$2+" "+$3;}
subtype_indic1_1     :  /* empty */  {$$="";}
subtype_indic1_1     : gen_association_list              {$$=$1;}

range_constraint     : t_RANGE range_spec            { $$="range "+$2;} 
//range_constraint        : array_constraint


index_constraint     : t_LeftParen discrete_range index_constraint_1 t_RightParen   { $$="("+$2+" "+$3+")";}
index_constraint_1   :  /* empty */  {$$="";}
index_constraint_1   : index_constraint_1 index_constraint_2                                        { $$=$1+" "+$2;}
index_constraint_2   : t_Comma discrete_range                                                              { $$=","+$2;} 


discrete_range  : subtype_indic          { $$=$1;} 
discrete_range  : range_spec             { $$=$1;} 

discrete_range1 : subtype_indic1          { $$=$1;} 
discrete_range1 : expr direction expr      { $$=$1+"  "+$2+"  "+$3;} 

range_spec  : attribute_name                                  { $$=$1;} 
range_spec  : simple_exp direction simple_exp    { $$=$1+"  "+$2+"  "+$3;}  
                                   

direction  : t_TO             {$$=" to ";}
direction  : t_DOWNTO {$$=" downto ";}  

/*--------------------------------------------------
--  Objects, Aliases, Files, Disconnections
----------------------------------------------------*/

constant_decl : t_CONSTANT idf_list t_Colon subtype_indic constant_decl_1 t_Semicolon  
                          {
                            QCString it=$4+" "+$5;
                          //  fprintf(stderr,"\n currP %d \n",currP);
                            addVhdlType($2,getParsedLine(t_CONSTANT),Entry::VARIABLE_SEC,VhdlDocGen::CONSTANT,0,it.data());                 
                            }
constant_decl_1    :  /* empty */  {$$="";}
constant_decl_1    : t_VarAsgn expr  {$$=":="+$2;}

signal_decl   : t_SIGNAL        idf_list      t_Colon       subtype_indic        signal_decl_1      signal_decl_2         t_Semicolon  
                           {
                                      QCString s=$4+" "+$6;
                                      addVhdlType($2,getParsedLine(t_SIGNAL),Entry::VARIABLE_SEC,VhdlDocGen::SIGNAL,0,s.data());
                               }
signal_decl_2 :  /* empty */  {$$="";}
signal_decl_2 : t_VarAsgn expr      {$$=":="+$2;}
signal_decl_1 :  /* empty */  {$$="";}
signal_decl_1 : signal_kind              {
                                                               $$=$1;
                                                            }



variable_decl : t_VARIABLE idf_list t_Colon subtype_indic variable_decl_1 t_Semicolon  
                                  {
                                    $$=$2+":"+$4+" "+$5;
                                    }
variable_decl : t_SHARED t_VARIABLE idf_list t_Colon subtype_indic variable_decl_1 t_Semicolon  
                      {
                        $$=$5+" "+$6;
                          addVhdlType($3,getParsedLine(t_VARIABLE),Entry::VARIABLE_SEC,VhdlDocGen::SHAREDVARIABLE,0,$$.data());   
                      }
variable_decl_1    :  /* empty */  {$$="";}
variable_decl_1    : t_VarAsgn expr                     {$$=":="+$2;}
 
object_class    : t_CONSTANT                              {$$="constant";}
object_class    : t_SIGNAL                                     {$$="signal";}
object_class    : t_VARIABLE                                {$$="variable";}
object_class    :t_SHARED  t_VARIABLE            {$$="shared";}
object_class    :t_FILE                                              {$$="file";}
object_class    :t_TYPE                                          {$$="type";}

signal_kind     : t_BUS               {$$="bus";}
signal_kind     : t_REGISTER   {$$="register";}

alias_decl    : t_ALIAS  alias_name_stat          alias_spec    t_IS      name  signature     t_Semicolon  
                      {
                                         QCString s=$3+" "+$5+$6;
                                         addVhdlType($2,getParsedLine(t_ALIAS),Entry::VARIABLE_SEC,VhdlDocGen::ALIAS,0,s.data());   
                        }
 alias_decl    : t_ALIAS   alias_name_stat          alias_spec    t_IS error   t_Semicolon  {$$="";}

 alias_name_stat  :  t_Identifier  {$$=$1;}
  alias_name_stat  : t_StringLit  {$$=$1;}
 
 alias_spec :/*empty*/  {$$="";}
                    | t_Colon subtype_indic { $$=","+$2;}
                   ;
   
         
file_decl     : t_FILE   idf_list   t_Colon   subtype_indic   t_IS   file_decl_1   expr   t_Semicolon  
                     { 
                                         addVhdlType($2,getParsedLine(t_FILE),Entry::VARIABLE_SEC,VhdlDocGen::VFILE,0,$4.data());  
                      }
                     
file_decl     : t_FILE   idf_list    t_Colon      t_Identifier        fi_dec     t_Semicolon 
                     {
                                       QCString s=$4+" "+$5;
                                      addVhdlType($2,getParsedLine(t_FILE),Entry::VARIABLE_SEC,VhdlDocGen::VFILE,0,s.data());  
                           }

fi_dec: /*empty*/   {$$="";}
          |  t_OPEN expr t_IS expr {$$="open "+$2+" is "+s_str.qstr; }


file_decl_1   :  /* empty */  {$$="";}
file_decl_1   : mode                  {$$=$1;}

disconnection_spec    : t_DISCONNECT signal_list t_Colon mark t_AFTER expr t_Semicolon  

signal_list     : name signal_list_1  
signal_list     : t_OTHERS  
signal_list     : t_ALL  
signal_list_1   :  /* empty */ 
signal_list_1   : signal_list_1 signal_list_2  
signal_list_2   : t_Comma name  

/*--------------------------------------------------
--  Attribute Declarations and Specifications
----------------------------------------------------*/

attribute_decl     : t_ATTRIBUTE t_Identifier t_Colon mark t_Semicolon  
                             {
                               addVhdlType($2,getParsedLine(t_ATTRIBUTE),Entry::VARIABLE_SEC,VhdlDocGen::ATTRIBUTE,0,$4.data());
                              } 
                 
attribute_spec   : t_ATTRIBUTE t_Identifier t_OF entity_spec t_IS expr t_Semicolon  
                              {
                                QCString oo=$4+" is "+$6;
                               addVhdlType($2,getParsedLine(t_ATTRIBUTE),Entry::VARIABLE_SEC,VhdlDocGen::ATTRIBUTE,0,oo.data());
                              }
                              
entity_spec : entity_name_list signature  t_Colon entity_class  

entity_name_list     : designator entity_name_list_1                    {$$=$1+" "+$2;} 
entity_name_list     : t_OTHERS                                                    {$$="others";}
entity_name_list     : t_ALL                                                             {$$="all";}
entity_name_list_1   :                                                                     /* empty */  {$$="";}
entity_name_list_1   : entity_name_list_1 entity_name_list_2     {$$=$1+" "+$2;} 
entity_name_list_2   : t_Comma designator                                  {$$=","+$2;} 

entity_class    : t_ENTITY                               {$$="entity";}
entity_class    : t_ARCHITECTURE              {$$="architecture";}
entity_class    : t_PACKAGE                          {$$="package";}
entity_class    : t_CONFIGURATION            {$$="configuration";}
entity_class    : t_COMPONENT                    {$$="component";}
entity_class    : t_LABEL                                {$$="label";}   
entity_class    : t_TYPE                                  {$$="type";}
entity_class    : t_SUBTYPE                           {$$="subtype";}
entity_class    : t_PROCEDURE                     {$$="procedure";}
entity_class    :  t_FUNCTION                          {$$="";}
entity_class    : t_SIGNAL                                {$$="signal";}
entity_class    : t_VARIABLE                           {$$="variable";}
entity_class    : t_CONSTANT                         {$$="constant";}
entity_class    : t_GROUP                                {$$="group";}
entity_class    : t_FILE                                      {$$="file";}
entity_class    : t_UNITS                                      {$$="units";}
entity_class    : t_LITERAL                                      {$$="literal";}
entity_class    : t_SEQUENCE                         {$$="sequence";}
entity_class    : t_PROPERTY                                      {$$="property";}


/*--------------------------------------------------
--  Schemes

--------------------------------------------------------------------------*/


if_generation_scheme    : if_scheme  


if_scheme    : t_IF expr t_GENERATE  generate_statement_body  if_scheme_1 if_scheme_2 
if_scheme    : t_IF lable expr t_GENERATE  generate_statement_body  if_scheme_1 if_scheme_2 

if_scheme_2  :  /* empty */
if_scheme_2  : t_ELSE t_GENERATE  generate_statement_body  
if_scheme_2  : t_ELSE lable t_GENERATE  generate_statement_body  
if_scheme_1  :  /* empty */
if_scheme_1  : if_scheme_1 if_scheme_3  
if_scheme_3  : t_ELSIF expr t_GENERATE generate_statement_body  
if_scheme_3  : t_ELSIF lable expr t_GENERATE generate_statement_body  

generation_scheme    : for_scheme  

iteration_scheme     : for_scheme  
iteration_scheme     : while_scheme  

for_scheme : t_FOR t_Identifier t_IN discrete_range
for_scheme : t_FOR lable t_Identifier t_IN discrete_range

while_scheme    : t_WHILE expr  

/*--------------------------------------------------
--  Concurrent Statements
----------------------------------------------------*/

concurrent_stats     : concurrent_stats_1  
concurrent_stats_1   :  /* empty */
concurrent_stats_1   : concurrent_stats_1 concurrent_stats_2  
concurrent_stats_2   : concurrent_stat  

concurrent_stat : block_stat  
 | concurrent_assertion_stat  
 | concurrent_procedure_call  
 | concurrent_signal_assign_stat  
 | comp_inst_stat  
 | generate_stat  
 | procs_stat  

block_stat : t_Identifier t_Colon t_BLOCK block_stat_0 block_stat_1 block_stat_2
block_stat_3 block_stat_4 t_BEGIN concurrent_stats t_END t_BLOCK block_stat_5
t_Semicolon 
block_stat_5    :  /* empty */
block_stat_5    : t_Identifier  
block_stat_4    :  /* empty */
block_stat_4    : block_stat_4 block_stat_6  
block_stat_6    : block_decltve_item  
block_stat_3    :  /* empty */
block_stat_3    : t_PORT interf_list t_Semicolon block_stat_7  
//block_sta_7    :  /* empty */
block_stat_7    : t_PORT t_MAP association_list t_Semicolon  
block_stat_2    :  /* empty */
block_stat_2    : t_GENERIC interf_list t_Semicolon block_stat_8  
block_stat_8    :  /* empty */
block_stat_8    : t_GENERIC t_MAP association_list t_Semicolon  
block_stat_1    :  /* empty */
block_stat_1    : t_LeftParen expr t_RightParen  block_stat_0
block_stat_0:  /* empty */
block_stat_0: t_IS

dot_name:t_Identifier                                         {$$=$1;}
                | dot_name  t_Dot t_Identifier            {$$=$1+"."+$3;}
                ;
                
mark_comp: dot_name  comp_1      {$$=$1+" "+$2;}
mark_comp: dot_name                     {$$=$1;}

comp_1: t_LeftParen t_Identifier  t_RightParen  {$$="("+$2+")";}
            
 vcomp_stat :t_CONFIGURATION       {$$="configurátion";yyLineNr=s_str.iLine;}
 vcomp_stat :   t_ENTITY                        {$$="entity";yyLineNr=s_str.iLine;}
 vcomp_stat : t_COMPONENT               {$$="component";yyLineNr=s_str.iLine;}
                
comp_inst_stat   :  t_Identifier   t_Colon  name   {yyLineNr=s_str.iLine;}     t_GENERIC t_MAP association_list comp_inst_stat_1 t_Semicolon  
                             {
                                addCompInst($1.data(),$3.data(),0,yyLineNr);
                               }
comp_inst_stat   :  t_Identifier   t_Colon     name   {yyLineNr=s_str.iLine;}    t_PORT t_MAP association_list t_Semicolon  
                              {
                               addCompInst($1.data(),$3.data(),0,yyLineNr);
                             }

comp_inst_stat   :  t_Identifier  t_Colon   vcomp_stat  mark_comp    t_PORT t_MAP association_list t_Semicolon  
                             {
                                  addCompInst($1.data(),$4.data(),$3.data(),yyLineNr);
                              }
comp_inst_stat   :  t_Identifier  t_Colon  vcomp_stat   mark_comp        t_GENERIC t_MAP association_list comp_inst_stat_1 t_Semicolon  
                              {
                                addCompInst($1.data(),$4.data(),$3.data(),yyLineNr);
                              }        
comp_inst_stat_1 :  /* empty */
comp_inst_stat_1 : t_PORT t_MAP association_list  

concurrent_assertion_stat :  t_Identifier t_Colon  assertion_stat  
concurrent_assertion_stat :  assertion_stat  

concurrent_assertion_stat :  t_Identifier t_Colon  t_POSTPONED  assertion_stat  
concurrent_assertion_stat :   t_POSTPONED assertion_stat  

concurrent_procedure_call : t_Identifier t_Colon procedure_call_stat  
concurrent_procedure_call : procedure_call_stat  

concurrent_procedure_call : t_Identifier t_Colon t_POSTPONED procedure_call_stat  
concurrent_procedure_call : t_POSTPONED procedure_call_stat  


concurrent_signal_assign_stat    : t_Identifier t_Colon condal_signal_assign  
concurrent_signal_assign_stat    : condal_signal_assign  

concurrent_signal_assign_stat    : t_Identifier t_Colon  t_POSTPONED  condal_signal_assign  
concurrent_signal_assign_stat    : t_POSTPONED  condal_signal_assign  

concurrent_signal_assign_stat    : t_Identifier t_Colon t_POSTPONED sel_signal_assign  
concurrent_signal_assign_stat    : t_POSTPONED sel_signal_assign  

concurrent_signal_assign_stat    : t_Identifier t_Colon sel_signal_assign  
concurrent_signal_assign_stat    : sel_signal_assign  


condal_signal_assign  : target t_LESym opts   condal_wavefrms t_Semicolon  

condal_wavefrms:wavefrm
condal_wavefrms:wavefrm t_WHEN expr 
condal_wavefrms:wavefrm  t_WHEN expr t_ELSE condal_wavefrms 

wavefrm   : wavefrm_element wavefrm_1  
wavefrm  : t_UNAFFECTED 
wavefrm_1 :  /* empty */
wavefrm_1 : wavefrm_1 wavefrm_2  
wavefrm_2 : t_Comma wavefrm_element  

wavefrm_element     : expr wavefrm_element_1  
wavefrm_element_1   : /* empty */ 
wavefrm_element_1   : t_AFTER expr  
wavefrm_element_1   : t_NULL wavefrm_element_2     
wavefrm_element_1   : t_NULL 
 

wavefrm_element_2  :  t_AFTER expr  
                                              
target     : name  
target     : aggregate  

opts    : opts_1 opts_2  

opts_2  :  /* empty */
opts_2  : t_TRANSPORT  
opts_2  :   t_REJECT expr t_INERTIAL
opts_2  :   t_INERTIAL   

opts_1  :  /* empty */
opts_1  : t_GUARDED  

sel_signal_assign : t_WITH expr t_SELECT target t_LESym opts sel_wavefrms t_Semicolon 

sel_wavefrms   : sel_wavefrms_1 wavefrm t_WHEN choices  
sel_wavefrms_1 :  /* empty */
sel_wavefrms_1 : sel_wavefrms_1 sel_wavefrms_2  
sel_wavefrms_2 : wavefrm t_WHEN choices t_Comma  

gen_stat1: /* empty */ 
        |  block_declarative_part  t_BEGIN
        | t_BEGIN
 
 // problem with double end
 // end;
 // end generate;
                          
generate_statement_body:  gen_stat1 concurrent_stats 
       
generate_stat : t_Identifier  t_Colon { pushLabel($1); }  generation_scheme t_GENERATE            
                        gen_stat1 concurrent_stats  opstat

// stems from VHDL 2008 generate_statement_body
 opstat : end_stats t_END   generate_stat_1 t_Semicolon { popLabel(); }
 opstat : t_END   generate_stat_1 t_Semicolon { popLabel(); }
 
generate_stat : t_Identifier  t_Colon  { pushLabel($1); } if_generation_scheme             
                      opstat //    t_END   generate_stat_1 t_Semicolon { popLabel(); }

generate_stat :  t_Identifier  t_Colon case_scheme                                          

generate_stat_1 : t_GENERATE   {   $$=""; }
generate_stat_1 : t_GENERATE t_Identifier   {   $$=$2; }
   
   
 //end_stats : 
 end_stats :   t_END t_Semicolon
 end_stats :    t_END t_Identifier  t_Semicolon 
  
   
   
procs_stat    : t_Identifier t_Colon procs_stat1  
                                    {
                                         current->name=$1;
                                             current->endBodyLine=s_str.yyLineNr;
                                           newEntry();
                                    }
   
   
procs_stat    : procs_stat1
                                   { 
                                         current->name=VhdlDocGen::getProcessNumber(); 
                                         current->endBodyLine=s_str.yyLineNr;
                                         newEntry();
                                    }   
                      
procs_stat1 : procs_stat1_5 {currP=VhdlDocGen::PROCESS;}  t_PROCESS procs_stat1_1 procs_stat1_2 t_BEGIN seq_stats t_END
                       procs_stat1_3 t_Semicolon     {currP=0;}
                           {
                               createFunction(currName,VhdlDocGen::PROCESS,$4.data());
                            }
procs_stat1 : error t_END procs_stat1_3  t_Semicolon     {currP=0;}
                   

procs_stat1_3 :  /* empty */
procs_stat1_3 : procs_stat1_5  t_PROCESS  procs_stat1_6

procs_stat1_5 :  /* empty */  {$$="";}
procs_stat1_5 : t_POSTPONED  {$$="postponed";}

procs_stat1_6 :  /* empty */ {$$="";}
procs_stat1_6 : t_Identifier {$$=$1;}

procs_stat1_2 :  /* empty */
procs_stat1_2 :  t_IS
procs_stat1_2 : procs_stat1_2 procs_stat1_4  
procs_stat1_4 : procs_decltve_item                                      
procs_stat1_1 :  /* empty */      {$$="";}                                        
procs_stat1_1 : t_LeftParen t_ALL t_RightParen  {$$="all";}
procs_stat1_1 : t_LeftParen sensitivity_list t_RightParen  {$$=$2;}

sensitivity_list     : name sensitivity_list_1                           {$$=$1+" "+$2;}
sensitivity_list_1   :  /* empty */                                            {$$="";}
sensitivity_list_1   : sensitivity_list_1 sensitivity_list_2      {$$=$1+" "+$2;}
sensitivity_list_2   : t_Comma name                                   {$$=","+$2;}

/*--------------------------------------------------
--  Sequential Statements
----------------------------------------------------*/

seq_stats     : seq_stats_1  
seq_stats_1   :  /* empty */
seq_stats_1   : seq_stats_1 seq_stats_2  
seq_stats_2   : seq_stat  

seq_stat : assertion_stat  
seq_stat : lable assertion_stat  
seq_stat : case_stat  
seq_stat : exit_stat  
seq_stat : if_stat  
seq_stat : loop_stat  
seq_stat : next_stat  
seq_stat : null_stat  
seq_stat : procedure_call_stat  
seq_stat : return_stat  
seq_stat :lable  signal_assign_stat 
seq_stat : signal_assign_stat
seq_stat : variable_assign_stat  
seq_stat : wait_stat  
seq_stat : lable wait_stat
seq_stat : report_statement


      
report_statement : loop_stat_1   t_REPORT expr assertion_stat_2  t_Semicolon

assertion_stat  : t_ASSERT expr assertion_stat_1 assertion_stat_2 t_Semicolon  
assertion_stat_2     :  /* empty */
assertion_stat_2     : t_SEVERITY expr  
assertion_stat_1     :  /* empty */
assertion_stat_1     : t_REPORT expr  

choice_stat :  /* empty */
choice_stat :  t_Q                  

choice_stat_1:  /* empty */
choice_stat_1 :  t_Q  
choice_stat_1 : t_Identifier

case_stat  : t_CASE choice_stat expr t_IS case_stat_alternative case_stat_1 t_END t_CASE choice_stat_1  t_Semicolon  
case_stat  : lable t_CASE choice_stat expr t_IS case_stat_alternative case_stat_1 t_END t_CASE choice_stat_1  t_Semicolon  

case_stat  : t_CASE error t_END t_CASE choice_stat_1  t_Semicolon 
case_stat_1     :  /* empty */
case_stat_1     : case_stat_1 case_stat_2  
case_stat_2     : case_stat_alternative  

case_stat_alternative     : t_WHEN choices t_Arrow seq_stats  

exit_stat  : t_EXIT exit_stat_1 exit_stat_2 t_Semicolon  
exit_stat_2     :  /* empty */
exit_stat_2     : t_WHEN expr  
exit_stat_1     :  /* empty */
exit_stat_1     : t_Identifier  

if_stat    : t_IF expr t_THEN seq_stats if_stat_1 if_stat_2 t_END t_IF t_Semicolon  
if_stat  :  t_IF expr t_THEN  error  t_END t_IF  t_Semicolon  
if_stat_2  :  /* empty */
if_stat_2  : t_ELSE seq_stats  
if_stat_1  :  /* empty */
if_stat_1  : if_stat_1 if_stat_3  
if_stat_3  : t_ELSIF expr t_THEN seq_stats  

loop_stat  : loop_stat_1 loop_stat_2 t_LOOP seq_stats t_END t_LOOP loop_stat_3 t_Semicolon  
loop_stat_3     :  /* empty */
loop_stat_3     : t_Identifier  
loop_stat_2     :  /* epty */
loop_stat_2     : iteration_scheme  
loop_stat_1     :  /* empty */
loop_stat_1     : t_Identifier t_Colon  

next_stat  : t_NEXT next_stat_1 next_stat_2 t_Semicolon  
next_stat_2     :  /* empty */
next_stat_2     : t_WHEN expr  
next_stat_1     :  /* empty */
next_stat_1     : t_Identifier  

null_stat  : t_NULL t_Semicolon  

procedure_call_stat  : name t_Semicolon  

return_stat     : t_RETURN return_stat_1 t_Semicolon  
return_stat_1   :  /* empty */
return_stat_1   : expr  

signal_assign_stat    : target t_LESym wavefrm t_Semicolon  
                                  |  target t_LESym delay_mechanism wavefrm t_Semicolon  
                                   |  target t_LESym t_FORCE inout_stat  expr t_Semicolon  
                                   |  target  t_LESym t_RELEASE inout_stat  t_Semicolon 
                                     | selected_signal_assignment
                                   | conditional_signal_assignment
                                   ;
                                   


variable_assign_stat  :   variable_assign_stat_1 t_Semicolon  
                                      |  conditional_variable_assignment 
                                      | lable selected_variable_assignment
                                      |  selected_variable_assignment

lable:   t_Identifier t_Colon
variable_assign_stat_1:  target t_VarAsgn expr
variable_assign_stat_1: lable  target t_VarAsgn expr

wait_stat  : t_WAIT wait_stat_1 wait_stat_2 wait_stat_3 t_Semicolon  
wait_stat_3     :  /* empty */
wait_stat_3     : t_FOR expr  
wait_stat_2     :  /* empty */
wait_stat_2     : t_UNTIL expr  
wait_stat_1     :  /* empty */
wait_stat_1     : t_ON sensitivity_list  


/*--------------------------------------------------
--  Components and Configurations
----------------------------------------------------*/
 comp_end_dec : t_END {lastEntity=0;lastCompound=0;genLabels.resize(0);}
                             |  t_END  t_COMPONENT entity_decl_5
                             |  t_END  t_ARCHITECTURE entity_decl_5 {lastCompound=0;genLabels.resize(0);}
                             |  t_END  t_ENTITY entity_decl_5 {lastEntity=0;genLabels.resize(0);}
                             |  t_END t_Identifier {lastEntity=0;lastCompound=0;genLabels.resize(0);}

 iss :/*empty*/  {currP=VhdlDocGen::COMPONENT;}
        |  t_IS       {currP=VhdlDocGen::COMPONENT;}
         
comp_decl     : t_COMPONENT t_Identifier iss comp_decl_1 comp_decl_2 comp_end_dec  t_Semicolon  
                          {
                            addVhdlType($2,getParsedLine(t_COMPONENT),Entry::VARIABLE_SEC,VhdlDocGen::COMPONENT,0,0);
                            currP=0;
                          } 
comp_decl_2   :  /* empty */ {$$="";}
comp_decl_2   : t_PORT interf_list t_Semicolon                  {$$=$2;} 
comp_decl_1   :  /* empty */   {$$="";} 
comp_decl_1   : t_GENERIC interf_list t_Semicolon          {$$=$2;} 

block_config  : t_FOR block_spec block_config_1 block_config_2 t_END t_FOR t_Semicolon  
          {
           popConfig();
          }
          
block_config  :   t_FOR    error   t_END t_FOR  t_Semicolon  {$$="";} 
block_config_2     :  /* empty */ {$$="";}  
block_config_2     : block_config_2 block_config_3          
  {
    $$=$1+"  ";
    } 
block_config_3     : config_item                                                {$$=$1;} 
block_config_1     :  /* empty */ {$$="";}  
block_config_1     : block_config_1 block_config_4              
 {
   $$=$1;
  } 
block_config_4     : use_clause                                                {$$=$1;} 

block_spec  : name                 {
$$=$1;
 
 if(levelCounter==0)
  addConfigureNode($1.data(),NULL,TRUE,FALSE);
 else
   addConfigureNode($1.data(),NULL,FALSE,FALSE);
}  

config_item   : block_config    {
$$=$1;
 }  

config_item   : comp_config   {
                                                  $$=$1;
                                                  }  

comp_config   : t_FOR comp_spec comp_config_1 comp_config_2 t_END t_FOR t_Semicolon  
                         {
                           $$=$2+" "+$3+" "+$4;
                           popConfig();
                         } 
comp_config_2 :  /* empty */       {$$="";}  
comp_config_2 : block_config   {$$=$1;}  
comp_config_1 :  /*empty*/         {$$="";}  

comp_config_1 : binding_indic_1  binding_indic_2  t_Semicolon   {$$="";}  
comp_config_1 : t_USE t_VUNIT idf_list  t_Semicolon    {$$="";}  
comp_config_1 : t_USE binding_indic t_Semicolon  
                           {
                                  addConfigureNode(compSpec.data(),$2.data(),FALSE,FALSE);
                           }       

config_spec : t_FOR comp_spec    comp_spec_stat  t_Semicolon                                                   {addConfigureNode($2.data(),$3.data(),TRUE,FALSE,TRUE);currNode->confVhdl=lastCompound->name; }
config_spec :  t_FOR  comp_spec  comp_spec_stat  t_Semicolon   t_END t_FOR  t_Semicolon {addConfigureNode($2.data(),$3.data(),TRUE,FALSE,TRUE);currNode->confVhdl=lastCompound->name; }
                    
comp_spec_stat :  t_USE  binding_indic     { $$=$2;}
comp_spec_stat    : t_USE t_VUNIT idf_list t_Semicolon  {$$="";}  
comp_spec_stat  :  binding_indic_1  binding_indic_2         {$$="";}  

comp_spec   : inst_list t_Colon expr
 {
               $$=$1+":"+$3;
                compSpec=$$;
   }  



inst_list   : idf_list          {$$=$1;}    
inst_list   : t_ALL           {$$="all";}    
inst_list   : t_OTHERS  {$$="others";}

binding_indic   : entity_aspect binding_indic_1 binding_indic_2  
                           {
                               $$=$1;
                           }

binding_indic_2 :  

binding_indic_2 : t_PORT t_MAP association_list  

binding_indic_1 :  

binding_indic_1 : t_GENERIC t_MAP association_list  


entity_aspect   : t_ENTITY name                   {$$="entity "+$2;}    

entity_aspect   : t_CONFIGURATION mark  {$$="configuration "+ $2;}    

entity_aspect : t_OPEN  {$$="open ";}    
;

group_constituent : t_Identifier        {$$=$1;}    
                               |  t_CharacterLit {$$=$1;}    
                               ;

group_constituent_list : group_constituent                                                                {$$=$1;}    
                                      |  group_constituent_list  t_Comma  group_constituent     {$$=$1+","+$3;}                             
                                      ;
                                       
 group_declaration : t_GROUP t_Identifier t_Colon group_name   t_LeftParen  group_constituent_list  t_RightParen t_Semicolon                                    
                                 {
                                  // $$=$2+":"+$4+$6;
                                  $$="("+$4+$6+")";
                                    addVhdlType($2,getParsedLine(t_GROUP),Entry::VARIABLE_SEC,VhdlDocGen::GROUP,$$.data(),0);
                                  }
                                 
 group_template_declaration :  t_GROUP  t_Identifier t_IS  t_LeftParen  entity_class_entry_list  t_RightParen t_Semicolon      
                                 {
                                   $$=$2+":"+$5;
                                   addVhdlType($2,getParsedLine(t_GROUP),Entry::VARIABLE_SEC,VhdlDocGen::GROUP,$5.data(),0);
                                  }
  
   group_template_declaration: t_GROUP  t_Identifier t_IS  t_LeftParen error t_Semicolon  t_RightParen {$$="";}  
  entity_class_entry : entity_class tbox
  
  tbox :  /* empty */ {$$="";}  
  tbox :  t_Box    {$$="<>";}           
        
 entity_class_entry_list :    entity_class_entry   {$$=$1;}                                                              
                                        |    entity_class_entry_list  t_Comma entity_class_entry {$$=$1+","+$3;}      
                                        ;

group_name : t_Identifier    {$$=$1;}    
group_name:  t_StringLit     {$$=$1;}    
                             
 t_Identifier : t_LETTER 
  {
  $$=s_str.qstr;               
  }
 
 
 t_BitStringLit :t_DIGIT  
  {
  $$=s_str.qstr;                                     
 }
 
 
  t_StringLit :  t_STRING
  {
  $$=s_str.qstr;                                     
 }

   t_AbstractLit :  t_ABSTRLIST
  {
  $$=s_str.qstr;                                     
 } 
  
 t_CharacterLit :  t_CHARLIST
  {
  $$=s_str.qstr;                                     
 } 


/*--------------------------------------------------
--  VHDL 2002 extensions
-- to do: must be added
-----------------------------------------------------*/
protected_type_declaration:t_PROTECTED protected_stats t_END protected_stat_1 {$$="";}
protected_type_declaration:t_PROTECTED error  t_END protected_stat_1 {$$="";}
 
 protected_stats : /* empty */
 protected_stats :  protected_stats   protected_stat_decl_1
 protected_stat_decl_1: protected_type_declaration_item  
 protected_stat_1:t_PROTECTED
 protected_stat_1:t_PROTECTED t_Identifier

protected_type_declaration_item  : use_clause
protected_type_declaration_item  : attribute_spec
protected_type_declaration_item  : subprog_decl 
protected_type_declaration_item  :  subprogram_instantiation_decl

protected_type_body : t_PROTECTED t_BODY protected_body_stats t_END protected_body_stat_1 {$$="";}
protected_type_body : t_PROTECTED t_BODY error t_END protected_body_stat_1 {$$="";}

 protected_body_stats : /* empty */
 protected_body_stats :  protected_body_stats   protected_body_stat_decl_1
 protected_body_stat_decl_1: protected_type_body_declaration_item

protected_body_stat_1: t_PROTECTED t_BODY
protected_body_stat_1: t_PROTECTED t_BODY t_Identifier

protected_type_body_declaration_item: subprog_decltve_item // same as subprog



/*--------------------------------------------------
--  VHDL 2008 extensions
-- to do: must be added
-----------------------------------------------------*/
 context_ref : t_CONTEXT  sel_list t_Semicolon
  
 context_decl : t_CONTEXT t_Identifier t_IS libustcont_stats t_END context_stat_1 t_Semicolon
 context_decl : t_CONTEXT t_Identifier t_IS  t_END context_stat_1 t_Semicolon

context_stat_1: t_CONTEXT
context_stat_1: t_CONTEXT t_Identifier

   libustcont_stats :   libustcont_stat  
  libustcont_stats :     libustcont_stats  libustcont_stat  
 
  libustcont_stat : use_clause
  libustcont_stat : lib_clause
  libustcont_stat : context_ref 
 
package_instantiation_decl: t_PACKAGE t_Identifier t_IS t_NEW dot_name signature t_Semicolon;
package_instantiation_decl: t_PACKAGE t_Identifier t_IS t_NEW dot_name signature  gen_assoc_list t_Semicolon 
package_instantiation_decl: t_PACKAGE error  t_Identifier t_IS t_NEW t_Semicolon; 
 
subprogram_instantiation_decl: t_FUNCTION  t_Identifier t_IS   t_NEW dot_name  signature  t_Semicolon
subprogram_instantiation_decl: t_FUNCTION  t_Identifier t_IS t_NEW dot_name  signature gen_assoc_list t_Semicolon 
subprogram_instantiation_decl: t_FUNCTION   t_Identifier t_IS   t_NEW error t_Semicolon 

signature:/*empty*/  {$$="";}
signature: t_LEFTBR signature1 t_RIGHTBR {$$="["+$2+" ]";}
signature: t_LEFTBR  t_RIGHTBR {$$="[ ]";}



signature1: t_RETURN mark {$$="return "+$2;}
signature1:mark_stats  { $$=$1;}
signature1: mark_stats  t_RETURN mark  {$$=$1+" return "+$3;}

mark_stats : mark {$$=$1;}
mark_stats: mark_stats mark_stats_1  {$$=$1+" "+$2;}
mark_stats_1: t_Comma mark {$$=" , "+$2;}

case_scheme:  t_CASE expr t_GENERATE when_stats ttend  t_END t_GENERATE generate_stat_1  t_Semicolon 
case_scheme:  t_CASE expr t_GENERATE when_stats   t_END t_GENERATE generate_stat_1  t_Semicolon 
case_scheme: t_CASE error  t_GENERATE error   t_END t_GENERATE generate_stat_1  t_Semicolon

when_stats_1 : t_WHEN lable choices t_Arrow generate_statement_body
when_stats_1 : t_WHEN choices t_Arrow generate_statement_body
when_stats : when_stats  when_stats_1
when_stats : when_stats_1

  ttend :t_END t_Semicolon
   ttend : t_END t_Identifier t_Semicolon

conditional_signal_assignment : conditional_waveform_assignment
conditional_signal_assignment : conditional_force_assignment
 
conditional_waveform_assignment:   target t_LESym  wavefrm_element t_WHEN expr else_wave_list t_Semicolon
conditional_waveform_assignment:   target t_LESym delay_mechanism wavefrm_element t_WHEN expr else_wave_list t_Semicolon

conditional_waveform_assignment:   target t_LESym  wavefrm_element t_WHEN expr  t_Semicolon
conditional_waveform_assignment:   target t_LESym delay_mechanism  wavefrm_element t_WHEN expr  t_Semicolon
conditional_waveform_assignment:   target t_LESym error t_Semicolon

else_wave_list: t_ELSE expr t_WHEN expr
else_wave_list: t_ELSE expr

conditional_force_assignment:  target t_LESym t_FORCE  inout_stat expr t_WHEN expr  else_stat    t_Semicolon
conditional_force_assignment:  target t_LESym t_FORCE  inout_stat expr t_WHEN expr    t_Semicolon

selected_signal_assignment : selected_waveform_assignment
selected_signal_assignment : selected_force_assignment

selected_waveform_assignment: t_WITH expr t_SELECT choice_stat 
                                                        target t_LESym delay_stat sel_wave_list 

delay_stat : 
delay_stat : delay_mechanism
                 
sel_wave_list :    wavefrm_element t_WHEN choices t_Comma  sel_wave_list 
sel_wave_list :    sel_wave_list_1

sel_wave_list_1 :  wavefrm_element  t_WHEN choices t_Semicolon

selected_force_assignment: t_WITH expr t_SELECT choice_stat target t_LESym t_FORCE 
                                                  inout_stat sel_var_list  

  inout_stat : 
  inout_stat :  t_IN
  inout_stat :  t_OUT

delay_mechanism : t_TRANSPORT
                                   | t_REJECT expr t_INERTIAL
                                   |  t_INERTIAL

 conditional_variable_assignment : variable_assign_stat_1 t_WHEN expr  else_stat    t_Semicolon
 conditional_variable_assignment : variable_assign_stat_1 t_WHEN expr     t_Semicolon

else_stat : t_ELSE expr t_WHEN expr
else_stat : else_stat t_ELSE expr t_WHEN expr
else_stat :  t_ELSE expr 

selected_variable_assignment: t_WITH expr t_SELECT choice_stat select_name t_VarAsgn sel_var_list  

 sel_var_list :    expr t_WHEN choices t_Comma  sel_var_list 
 sel_var_list :    sel_var_list_1

 sel_var_list_1 :  expr t_WHEN choices t_Semicolon

select_name:name
                     | aggregate

interface_subprogram_decl: iproc
                                              | ifunc
                                              ;
iproc: t_PROCEDURE t_Identifier param
ifunc: func_prec t_FUNCTION   func_name param t_RETURN mark return_is
ifunc:  t_FUNCTION   func_name param t_RETURN mark return_is


func_name: t_Identifier
                   |   t_StringLit // "?<"
                   ;
   
return_is:  /* empty */
              | t_IS  t_Identifier
              | t_IS t_Box   
                   
param: /* empty */
param: t_PARAMETER
param: t_PARAMETER t_LeftParen interf_element interf_list_1  t_RightParen
param:t_LeftParen  interf_element interf_list_1 t_RightParen

interface_package_decl: t_PACKAGE t_Identifier t_IS t_NEW dot_name 
interface_package_decl: t_PACKAGE t_Identifier t_IS t_NEW dot_name     gen_assoc_list                                       
  
gen_assoc_list :     t_GENERIC t_MAP   association_list
   
          
gen_interface_list :     t_GENERIC  interf_list   
                                                          
external_name: t_SLSL sig_stat external_pathname t_Colon  subtype_indic  t_SRSR

sig_stat:  t_CONSTANT
sig_stat:  t_SIGNAL
sig_stat:  t_VARIABLE

external_pathname: absolute_pathname
                               | relative_pathname
                               | package_path_name
                               ;

absolute_pathname:  t_Dot  pathname_element_list t_Identifier
absolute_pathname:  t_Dot   t_Identifier

relative_pathname: t_Neg t_Dot  pathname_element_list t_Identifier
relative_pathname: t_Neg t_Dot   t_Identifier

pathname_element: t_Identifier
                                  |  t_Identifier t_LeftParen expr  t_RightParen
                                  ;
       
 pathname_element_list: pathname_element t_Dot      
                                        |  pathname_element_list pathname_element t_Dot  
                                  
package_path_name: t_At dot_name

tool_directive : t_ToolDir
{
// fprintf(stderr,"\n  tooldir %s",s_str.qstr.data() );
}


%%
extern FILE* yyout;
extern YYSTYPE vhdlScanYYlval;

void vhdlScanYYerror(const char* /*str*/)
{
 // fprintf(stderr,"\n<---error at line %d  : [ %s]   in file : %s ---->",s_str.yyLineNr,s_str.qstr.data(),s_str.fileName);
 // exit(0);
}

int MyParserVhdl::parse(MyParserVhdl* conv)
{
  myconv=conv;
  return vhdlScanYYparse();
} 

int lex(void)
{
  return myconv->doLex(); 
}

struct s_contVhdl*  getVhdlCont()
{
  return &s_str;
}

Entry* getVhdlCompound()
{
  if (lastEntity) return lastEntity;
  if (lastCompound) return lastCompound;
  return NULL;
}

QList<ConfNode>& getVhdlConfiguration() { return  configL; }
 
static void addCompInst(char *n, char* instName, char* comp,int iLine)
{

  current->spec=VhdlDocGen::COMPONENT_INST;
  current->section=Entry::VARIABLE_SEC;
  current->startLine=iLine;
  current->bodyLine=iLine;
  current->type=instName;                                  // foo:instname e.g proto or work. proto(ttt)
  current->exception=genLabels;                       // |arch|label1:label2...
  current->name=n;                                              // foo  
  current->args=lastCompound->name;             // architecture name
  current->includeName=comp;                          // component/enity/configuration

  //printf(" \n genlable: [%s]  inst: [%s]  name: [%s] \n",genLabels.data(),instName,n);

  if (lastCompound)
  {
    current->args=lastCompound->name;
    if (!findInstant(current->type))
    {   
      initEntry(current);
      instFiles.append(new Entry(*current));
    }
    current->reset();
  }
  else
  {
    newEntry();
  }
}