vrq
cnode_def.h
Go to the documentation of this file.
1 
2 
3 
4 /*****************************************************************************
5  * Copyright (C) 1997-2009, Mark Hummel
6  * This file is part of Vrq.
7  *
8  * Vrq is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public
10  * License as published by the Free Software Foundation; either
11  * version 2 of the License, or (at your option) any later version.
12  *
13  * Vrq is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public
19  * License along with this library; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor,
21  * Boston, MA 02110-1301 USA
22  *****************************************************************************
23  */
24 
25 
26 /*********************************************************
27  * Warning: This file is machine generate, do not edit
28  ********************************************************/
29 
632 #ifdef DEFINE_ENUM
633 
636 enum NodeOp_t {
640  /*
641  * ERROR node
642  * Description: error node
643  * Number Of Arguments: 0
644  */
649  /*
650  * VCONSTANT node
651  * Description: vector constant
652  * Number Of Arguments: 1
653  * arg0: CVector* Pointer to vector
654  */
659  /*
660  * RCONSTANT node
661  * Description: real constant
662  * Number Of Arguments: 1
663  * arg0: char* Pointer to string
664  */
669  /*
670  * COMMENT node
671  * Description: comment
672  * Number Of Arguments: 1
673  * arg0: const char* Pointer to string
674  */
679  /*
680  * VRQ node
681  * Description: vrq comment
682  * Number Of Arguments: 1
683  * arg0: const char* Pointer to string
684  */
689  /*
690  * PRAGMA node
691  * Description: program pragma
692  * Number Of Arguments: 2
693  * arg0: const char* Pointer to string
694  * arg1: int Length of string
695  */
700  /*
701  * ELIST node
702  * Description: expression list
703  * Number Of Arguments: 2
704  * arg0: CNode* expression1
705  * arg1: CNode* expression2
706  */
711  /*
712  * WIDTH node
713  * Description: expression width change
714  * Number Of Arguments: 2
715  * arg0: CNode* width expression
716  * arg1: CNode* expression
717  */
722  /*
723  * NOP node
724  * Description: no operation
725  * Number Of Arguments: 0
726  */
731  /*
732  * SUB node
733  * Description: subtract
734  * Number Of Arguments: 2
735  * arg0: CNode* expression 1
736  * arg1: CNode* expression 2
737  */
742  /*
743  * MUL node
744  * Description: multiply
745  * Number Of Arguments: 2
746  * arg0: CNode* expression 1
747  * arg1: CNode* expression 2
748  */
753  /*
754  * DIV node
755  * Description: divide
756  * Number Of Arguments: 2
757  * arg0: CNode* expression 1
758  * arg1: CNode* expression 2
759  */
764  /*
765  * POW node
766  * Description: exponent
767  * Number Of Arguments: 2
768  * arg0: CNode* expression 1
769  * arg1: CNode* expression 2
770  */
775  /*
776  * ADD node
777  * Description: addition
778  * Number Of Arguments: 2
779  * arg0: CNode* expression 1
780  * arg1: CNode* expression 2
781  */
786  /*
787  * LSH node
788  * Description: logical left shift
789  * Number Of Arguments: 2
790  * arg0: CNode* expression 1
791  * arg1: CNode* expression 2
792  */
797  /*
798  * RSH node
799  * Description: logical right shift
800  * Number Of Arguments: 2
801  * arg0: CNode* expression 1
802  * arg1: CNode* expression 2
803  */
808  /*
809  * LSHA node
810  * Description: arithmetic left shift
811  * Number Of Arguments: 2
812  * arg0: CNode* expression 1
813  * arg1: CNode* expression 2
814  */
819  /*
820  * RSHA node
821  * Description: arithmetic right shift
822  * Number Of Arguments: 2
823  * arg0: CNode* expression 1
824  * arg1: CNode* expression 2
825  */
830  /*
831  * MOD node
832  * Description: modulus
833  * Number Of Arguments: 2
834  * arg0: CNode* expression 1
835  * arg1: CNode* expression 2
836  */
841  /*
842  * OR node
843  * Description: bitwise or
844  * Number Of Arguments: 2
845  * arg0: CNode* expression 1
846  * arg1: CNode* expression 2
847  */
852  /*
853  * AND node
854  * Description: bitwise and
855  * Number Of Arguments: 2
856  * arg0: CNode* expression 1
857  * arg1: CNode* expression 2
858  */
863  /*
864  * ANDANDAND node
865  * Description: triple and
866  * Number Of Arguments: 2
867  * arg0: CNode* expression 1
868  * arg1: CNode* expression 2
869  */
874  /*
875  * XOR node
876  * Description: bitwise xor
877  * Number Of Arguments: 2
878  * arg0: CNode* expression 1
879  * arg1: CNode* expression 2
880  */
885  /*
886  * XNOR node
887  * Description: bitwise xnor
888  * Number Of Arguments: 2
889  * arg0: CNode* expression 1
890  * arg1: CNode* expression 2
891  */
896  /*
897  * INSTANCE_REF node
898  * Description: instance reference
899  * Number Of Arguments: 1
900  * arg0: CInstance* Pointer to a instance
901  */
906  /*
907  * GATE_REF node
908  * Description: gate instance
909  * Number Of Arguments: 1
910  * arg0: CGate* Pointer to a gate
911  */
916  /*
917  * TASK_ENABLE node
918  * Description: call to a task
919  * Number Of Arguments: 2
920  * arg0: CSymbol* Pointer to symbol for task to call
921  * arg1: CNode* Argument expression list
922  */
927  /*
928  * SYSTASK_CALL node
929  * Description: call to enable a systask
930  * Number Of Arguments: 2
931  * arg0: CSymbol* Pointer to symbol for systask to call
932  * arg1: CNode* Argument expression list
933  */
938  /*
939  * TIMING_CALL node
940  * Description: call to a timing task
941  * Number Of Arguments: 2
942  * arg0: CSymbol* Pointer to symbol of timing task
943  * arg1: CNode* Argument expression list
944  */
949  /*
950  * FUNCTION_CALL node
951  * Description: call to a function
952  * Number Of Arguments: 3
953  * arg0: CSymbol* Pointer to symbol of the function
954  * arg1: CNode* Argument expression list
955  * arg2: CScope* Scope containing expression
956  */
961  /*
962  * ARRAY node
963  * Description: dimensioned reference (array/bit select)
964  * Number Of Arguments: 2
965  * arg0: CNode* Reference to variable
966  * arg1: CNode* List of index expressions
967  */
972  /*
973  * NET_REF node
974  * Description: reference to net
975  * Number Of Arguments: 1
976  * arg0: CNet* Pointer to net
977  */
982  /*
983  * VAR_REF node
984  * Description: reference to variable
985  * Number Of Arguments: 1
986  * arg0: CVar* Pointer to variable
987  */
992  /*
993  * PARAM_REF node
994  * Description: reference to parameter
995  * Number Of Arguments: 1
996  * arg0: CParam* Pointer to parameter
997  */
1002  /*
1003  * PORT_REF node
1004  * Description: reference to port
1005  * Number Of Arguments: 1
1006  * arg0: CPortDir* Pointer to port
1007  */
1012  /*
1013  * FWD_REF node
1014  * Description: reference to a forward declared variable
1015  * Number Of Arguments: 1
1016  * arg0: CFref* Pointer to forward declared variable
1017  */
1022  /*
1023  * GENVAR_REF node
1024  * Description: reference to a genvar
1025  * Number Of Arguments: 1
1026  * arg0: CGenvar* Pointer to a genvar
1027  */
1032  /*
1033  * ENUM_REF node
1034  * Description: reference to a enum
1035  * Number Of Arguments: 1
1036  * arg0: CEnum* Pointer to a enum
1037  */
1042  /*
1043  * TYPE_REF node
1044  * Description: reference to a type
1045  * Number Of Arguments: 1
1046  * arg0: CTypedef* Pointer to a typedef
1047  */
1052  /*
1053  * NET_DECL node
1054  * Description: net declaration
1055  * Number Of Arguments: 2
1056  * arg0: CNet* Pointer to a net
1057  * arg1: CNode* continous assignment (optional)
1058  */
1063  /*
1064  * VAR_DECL node
1065  * Description: variable declaration
1066  * Number Of Arguments: 2
1067  * arg0: CVar* Pointer to a variable
1068  * arg1: CNode* procedural assignment (optional)
1069  */
1074  /*
1075  * PARAM_DECL node
1076  * Description: parameter declaration
1077  * Number Of Arguments: 1
1078  * arg0: CParam* Pointer to a parameter
1079  */
1084  /*
1085  * SPECPARAM_DECL node
1086  * Description: specify parameter declaration
1087  * Number Of Arguments: 1
1088  * arg0: CParam* Pointer to a specify parameter
1089  */
1094  /*
1095  * PORT_DECL node
1096  * Description: port declaration
1097  * Number Of Arguments: 1
1098  * arg0: CPortDir* Pointer to a port
1099  */
1104  /*
1105  * GENVAR_DECL node
1106  * Description: genvar declaration
1107  * Number Of Arguments: 1
1108  * arg0: CGenvar* Pointer to a genvar
1109  */
1114  /*
1115  * TYPEDEF_DECL node
1116  * Description: type declaration
1117  * Number Of Arguments: 1
1118  * arg0: CTypedef* Pointer to a typedef
1119  */
1124  /*
1125  * LIST node
1126  * Description: list of nodes
1127  * Number Of Arguments: 2
1128  * arg0: CNode* node 1
1129  * arg1: CNode* node 2
1130  */
1135  /*
1136  * RANGE node
1137  * Description: vector decl range specification
1138  * Number Of Arguments: 2
1139  * arg0: CNode* msb expression, if lsb is null range is msb-1:0
1140  * arg1: CNode* lsb expression, if NULL range is msb-1:0
1141  */
1146  /*
1147  * SLICE node
1148  * Description: vector subrange
1149  * Number Of Arguments: 2
1150  * arg0: CNode* msb expression
1151  * arg1: CNode* lsb expression
1152  */
1157  /*
1158  * PSLICE node
1159  * Description: vector subrange with ascending index select
1160  * Number Of Arguments: 2
1161  * arg0: CNode* index expression
1162  * arg1: CNode* width expression
1163  */
1168  /*
1169  * MSLICE node
1170  * Description: vector subrange with descending index select
1171  * Number Of Arguments: 2
1172  * arg0: CNode* index expression
1173  * arg1: CNode* width expression
1174  */
1179  /*
1180  * CVRI node
1181  * Description: convert real to integer
1182  * Number Of Arguments: 1
1183  * arg0: CNode* expression
1184  */
1189  /*
1190  * CVIR node
1191  * Description: convert integer to real
1192  * Number Of Arguments: 1
1193  * arg0: CNode* expression
1194  */
1199  /*
1200  * REP node
1201  * Description: replication operator
1202  * Number Of Arguments: 2
1203  * arg0: CNode* replication expression
1204  * arg1: CNode* expression to replicate
1205  */
1210  /*
1211  * CAT node
1212  * Description: concatenation operator
1213  * Number Of Arguments: 2
1214  * arg0: CNode* expression 1
1215  * arg1: CNode* expression 2
1216  */
1221  /*
1222  * UCAT node
1223  * Description: unary concat
1224  * Number Of Arguments: 1
1225  * arg0: CNode* expression
1226  */
1231  /*
1232  * COM node
1233  * Description: bitwise complement
1234  * Number Of Arguments: 1
1235  * arg0: CNode* expression
1236  */
1241  /*
1242  * NEG node
1243  * Description: negation
1244  * Number Of Arguments: 1
1245  * arg0: CNode* expression
1246  */
1251  /*
1252  * PLUS node
1253  * Description: unary plus
1254  * Number Of Arguments: 1
1255  * arg0: CNode* expression
1256  */
1261  /*
1262  * NOT node
1263  * Description: logical complement
1264  * Number Of Arguments: 1
1265  * arg0: CNode* expression
1266  */
1271  /*
1272  * GT node
1273  * Description: greater than
1274  * Number Of Arguments: 2
1275  * arg0: CNode* expression 1
1276  * arg1: CNode* expression 2
1277  */
1282  /*
1283  * GE node
1284  * Description: greater than or equal
1285  * Number Of Arguments: 2
1286  * arg0: CNode* expression 1
1287  * arg1: CNode* expression 2
1288  */
1293  /*
1294  * LT node
1295  * Description: less than
1296  * Number Of Arguments: 2
1297  * arg0: CNode* expression 1
1298  * arg1: CNode* expression 2
1299  */
1304  /*
1305  * LE node
1306  * Description: less than or equal
1307  * Number Of Arguments: 2
1308  * arg0: CNode* expression 1
1309  * arg1: CNode* expression 2
1310  */
1315  /*
1316  * LAND node
1317  * Description: logical and
1318  * Number Of Arguments: 2
1319  * arg0: CNode* expression 1
1320  * arg1: CNode* expression 2
1321  */
1326  /*
1327  * LOR node
1328  * Description: logical or
1329  * Number Of Arguments: 2
1330  * arg0: CNode* expression 1
1331  * arg1: CNode* expression 2
1332  */
1337  /*
1338  * CEQ node
1339  * Description: case equal
1340  * Number Of Arguments: 2
1341  * arg0: CNode* expression 1
1342  * arg1: CNode* expression 2
1343  */
1348  /*
1349  * CNE node
1350  * Description: case not equal
1351  * Number Of Arguments: 2
1352  * arg0: CNode* expression 1
1353  * arg1: CNode* expression 2
1354  */
1359  /*
1360  * EQ node
1361  * Description: equal
1362  * Number Of Arguments: 2
1363  * arg0: CNode* expression 1
1364  * arg1: CNode* expression 2
1365  */
1370  /*
1371  * NE node
1372  * Description: not equal
1373  * Number Of Arguments: 2
1374  * arg0: CNode* expression 1
1375  * arg1: CNode* expression 2
1376  */
1381  /*
1382  * RAND node
1383  * Description: reduction and
1384  * Number Of Arguments: 1
1385  * arg0: CNode* expression
1386  */
1391  /*
1392  * RNAND node
1393  * Description: reduction nand
1394  * Number Of Arguments: 1
1395  * arg0: CNode* expression
1396  */
1401  /*
1402  * ROR node
1403  * Description: reduction or
1404  * Number Of Arguments: 1
1405  * arg0: CNode* expression
1406  */
1411  /*
1412  * RNOR node
1413  * Description: reduction nor
1414  * Number Of Arguments: 1
1415  * arg0: CNode* expression
1416  */
1421  /*
1422  * RXOR node
1423  * Description: reduction xor
1424  * Number Of Arguments: 1
1425  * arg0: CNode* expression
1426  */
1431  /*
1432  * RXNOR node
1433  * Description: reduction xnor
1434  * Number Of Arguments: 1
1435  * arg0: CNode* expression
1436  */
1441  /*
1442  * HOOK node
1443  * Description: condition expression operator
1444  * Number Of Arguments: 3
1445  * arg0: CNode* condition expression
1446  * arg1: CNode* true expression
1447  * arg2: CNode* false expression
1448  */
1453  /*
1454  * INIT node
1455  * Description: initial block
1456  * Number Of Arguments: 1
1457  * arg0: CNode*
1458  */
1463  /*
1464  * ALWAYS node
1465  * Description: always block
1466  * Number Of Arguments: 1
1467  * arg0: CNode*
1468  */
1473  /*
1474  * ALWAYS_LATCH node
1475  * Description: always latch block
1476  * Number Of Arguments: 1
1477  * arg0: CNode*
1478  */
1483  /*
1484  * ALWAYS_FF node
1485  * Description: always flip-flop block
1486  * Number Of Arguments: 1
1487  * arg0: CNode*
1488  */
1493  /*
1494  * ALWAYS_COMB node
1495  * Description: always combinational logic block
1496  * Number Of Arguments: 1
1497  * arg0: CNode*
1498  */
1503  /*
1504  * EVENT node
1505  * Description: event statement
1506  * Number Of Arguments: 2
1507  * arg0: CNode* event expression (NULL for @*)
1508  * arg1: CNode* statement
1509  */
1514  /*
1515  * BLOCK_REF node
1516  * Description: statement block
1517  * Number Of Arguments: 3
1518  * arg0: CBlock* pointer to block
1519  * arg1: CNode* list of statements
1520  * arg2: bool true if begin/end is invisible
1521  */
1526  /*
1527  * SPECIFY_REF node
1528  * Description: specify block
1529  * Number Of Arguments: 2
1530  * arg0: CSpecify* pointer to specify structure
1531  * arg1: CNode* list of statements
1532  */
1537  /*
1538  * ASSIGN node
1539  * Description: procedural assignment
1540  * Number Of Arguments: 3
1541  * arg0: CNode* event expression
1542  * arg1: CNode* lval
1543  * arg2: CNode* rval
1544  */
1549  /*
1550  * GASSIGN node
1551  * Description: generate intialize assignment
1552  * Number Of Arguments: 3
1553  * arg0: bool declare genvar
1554  * arg1: CNode* lval
1555  * arg2: CNode* rval
1556  */
1561  /*
1562  * ADD_ASSIGN node
1563  * Description: procedural assignment with add
1564  * Number Of Arguments: 3
1565  * arg0: CNode* event expression
1566  * arg1: CNode* lval
1567  * arg2: CNode* rval
1568  */
1573  /*
1574  * SUB_ASSIGN node
1575  * Description: procedural assignment with subtract
1576  * Number Of Arguments: 3
1577  * arg0: CNode* event expression
1578  * arg1: CNode* lval
1579  * arg2: CNode* rval
1580  */
1585  /*
1586  * MUL_ASSIGN node
1587  * Description: procedural assignment with mul
1588  * Number Of Arguments: 3
1589  * arg0: CNode* event expression
1590  * arg1: CNode* lval
1591  * arg2: CNode* rval
1592  */
1597  /*
1598  * DIV_ASSIGN node
1599  * Description: procedural assignment with div
1600  * Number Of Arguments: 3
1601  * arg0: CNode* event expression
1602  * arg1: CNode* lval
1603  * arg2: CNode* rval
1604  */
1609  /*
1610  * MOD_ASSIGN node
1611  * Description: procedural assignment with mod
1612  * Number Of Arguments: 3
1613  * arg0: CNode* event expression
1614  * arg1: CNode* lval
1615  * arg2: CNode* rval
1616  */
1621  /*
1622  * AND_ASSIGN node
1623  * Description: procedural assignment with bitwise and
1624  * Number Of Arguments: 3
1625  * arg0: CNode* event expression
1626  * arg1: CNode* lval
1627  * arg2: CNode* rval
1628  */
1633  /*
1634  * OR_ASSIGN node
1635  * Description: procedural assignment with bitwise or
1636  * Number Of Arguments: 3
1637  * arg0: CNode* event expression
1638  * arg1: CNode* lval
1639  * arg2: CNode* rval
1640  */
1645  /*
1646  * XOR_ASSIGN node
1647  * Description: procedural assignment with bitwise xor
1648  * Number Of Arguments: 3
1649  * arg0: CNode* event expression
1650  * arg1: CNode* lval
1651  * arg2: CNode* rval
1652  */
1657  /*
1658  * LSH_ASSIGN node
1659  * Description: procedural assignment with left shift
1660  * Number Of Arguments: 3
1661  * arg0: CNode* event expression
1662  * arg1: CNode* lval
1663  * arg2: CNode* rval
1664  */
1669  /*
1670  * RSH_ASSIGN node
1671  * Description: procedural assignment with right shift
1672  * Number Of Arguments: 3
1673  * arg0: CNode* event expression
1674  * arg1: CNode* lval
1675  * arg2: CNode* rval
1676  */
1681  /*
1682  * LSHA_ASSIGN node
1683  * Description: procedural assignment with left arithmetic shift
1684  * Number Of Arguments: 3
1685  * arg0: CNode* event expression
1686  * arg1: CNode* lval
1687  * arg2: CNode* rval
1688  */
1693  /*
1694  * RSHA_ASSIGN node
1695  * Description: procedural assignment with right arithmetic shift
1696  * Number Of Arguments: 3
1697  * arg0: CNode* event expression
1698  * arg1: CNode* lval
1699  * arg2: CNode* rval
1700  */
1705  /*
1706  * FORCE node
1707  * Description: force statement
1708  * Number Of Arguments: 2
1709  * arg0: CNode* lval
1710  * arg1: CNode* expression
1711  */
1716  /*
1717  * RELEASE node
1718  * Description: release statement
1719  * Number Of Arguments: 1
1720  * arg0: CNode* lval
1721  */
1726  /*
1727  * NBASSIGN node
1728  * Description: nonblocking assignment
1729  * Number Of Arguments: 3
1730  * arg0: CNode* event expression
1731  * arg1: CNode* lval
1732  * arg2: CNode* rval
1733  */
1738  /*
1739  * POSEDGE node
1740  * Description: positive event qualifier
1741  * Number Of Arguments: 1
1742  * arg0: CNode* expression
1743  */
1748  /*
1749  * NEGEDGE node
1750  * Description: negative event qualifier
1751  * Number Of Arguments: 1
1752  * arg0: CNode* expression
1753  */
1758  /*
1759  * EDGE node
1760  * Description: edge qualifier
1761  * Number Of Arguments: 2
1762  * arg0: CNode*
1763  * arg1: Edge_t edge specification
1764  */
1769  /*
1770  * EVOR node
1771  * Description: event or
1772  * Number Of Arguments: 2
1773  * arg0: CNode* expression 1
1774  * arg1: CNode* expression 2
1775  */
1780  /*
1781  * DELAY node
1782  * Description: delay statement
1783  * Number Of Arguments: 2
1784  * arg0: CNode* delay expression
1785  * arg1: CNode* statements
1786  */
1791  /*
1792  * MTM node
1793  * Description: min/typ/max expression
1794  * Number Of Arguments: 3
1795  * arg0: CNode* minimum expression
1796  * arg1: CNode* typical expression
1797  * arg2: CNode* maximum expression
1798  */
1803  /*
1804  * IF node
1805  * Description: if statement
1806  * Number Of Arguments: 4
1807  * arg0: CNode* condition
1808  * arg1: CNode* true statements
1809  * arg2: CNode* false statements
1810  * arg3: ConditionalType type
1811  */
1816  /*
1817  * FOREVER node
1818  * Description: forever statement
1819  * Number Of Arguments: 1
1820  * arg0: CNode* statements
1821  */
1826  /*
1827  * REPEAT node
1828  * Description: repeat statement
1829  * Number Of Arguments: 2
1830  * arg0: CNode* condition
1831  * arg1: CNode* statements
1832  */
1837  /*
1838  * WHILE node
1839  * Description: while statement
1840  * Number Of Arguments: 2
1841  * arg0: CNode* condition
1842  * arg1: CNode* statements
1843  */
1848  /*
1849  * WAIT node
1850  * Description: wait statement
1851  * Number Of Arguments: 2
1852  * arg0: CNode* condition
1853  * arg1: CNode* statements
1854  */
1859  /*
1860  * FOR node
1861  * Description: for statement
1862  * Number Of Arguments: 4
1863  * arg0: CNode* initial statement
1864  * arg1: CNode* condition
1865  * arg2: CNode* assignment statement
1866  * arg3: CNode* statements
1867  */
1872  /*
1873  * CASE node
1874  * Description: case statement
1875  * Number Of Arguments: 3
1876  * arg0: CNode* condition
1877  * arg1: CNode* list of case items
1878  * arg2: ConditionalType type
1879  */
1884  /*
1885  * CASEX node
1886  * Description: casex statement
1887  * Number Of Arguments: 3
1888  * arg0: CNode* condition
1889  * arg1: CNode* list of case items
1890  * arg2: ConditionalType type
1891  */
1896  /*
1897  * CASEZ node
1898  * Description: casez statement
1899  * Number Of Arguments: 3
1900  * arg0: CNode* condition
1901  * arg1: CNode* list of case items
1902  * arg2: ConditionalType type
1903  */
1908  /*
1909  * CASEITEM node
1910  * Description: case item
1911  * Number Of Arguments: 2
1912  * arg0: CNode* list of expressions (NULL for default)
1913  * arg1: CNode* statement
1914  */
1919  /*
1920  * CASSIGN node
1921  * Description: continious assignment
1922  * Number Of Arguments: 4
1923  * arg0: StrengthPair_t* assignment strength
1924  * arg1: CNode* delay expression
1925  * arg2: CNode* lval
1926  * arg3: CNode* rval expression
1927  */
1932  /*
1933  * ARG node
1934  * Description: port connection
1935  * Number Of Arguments: 2
1936  * arg0: CSymbol* port name
1937  * arg1: CNode* port expression
1938  */
1943  /*
1944  * IMPORT node
1945  * Description: import item
1946  * Number Of Arguments: 1
1947  * arg0: CSymbol* package::symbol or package(for wildcard)
1948  */
1953  /*
1954  * FUNCTION_DEF node
1955  * Description: function definition
1956  * Number Of Arguments: 1
1957  * arg0: CFunction*
1958  */
1963  /*
1964  * MODULE_DEF node
1965  * Description: module definition
1966  * Number Of Arguments: 1
1967  * arg0: CModule*
1968  */
1973  /*
1974  * PACKAGE_DEF node
1975  * Description: package definition
1976  * Number Of Arguments: 1
1977  * arg0: CPackage*
1978  */
1983  /*
1984  * REPEAT_CONTROL node
1985  * Description: repeat control
1986  * Number Of Arguments: 2
1987  * arg0: CNode* expression
1988  * arg1: CNode* event control
1989  */
1994  /*
1995  * DELAY_CONTROL node
1996  * Description: delay control
1997  * Number Of Arguments: 1
1998  * arg0: CNode* expression
1999  */
2004  /*
2005  * EVENT_CONTROL node
2006  * Description: event control
2007  * Number Of Arguments: 1
2008  * arg0: CNode* event expression (NULL for @*)
2009  */
2014  /*
2015  * EXTERNAL_REF node
2016  * Description: external reference
2017  * Number Of Arguments: 1
2018  * arg0: CSymbol* pointer to symbol
2019  */
2024  /*
2025  * PORT_DEF node
2026  * Description: port definition
2027  * Number Of Arguments: 1
2028  * arg0: CPort* pointer to port
2029  */
2034  /*
2035  * DEFPARAM node
2036  * Description: defparam statement
2037  * Number Of Arguments: 2
2038  * arg0: CNode* external reference
2039  * arg1: CNode* expression
2040  */
2045  /*
2046  * PATH node
2047  * Description: path statement
2048  * Number Of Arguments: 7
2049  * arg0: int
2050  * arg1: CNode* edge int[-1,0,1]
2051  * arg2: int Input list
2052  * arg3: int Left polarity int[-1,0,1]
2053  * arg4: CNode* Operation type int [0 = *>, 1 = =>]
2054  * arg5: int Output list
2055  * arg6: CNode* Right polarity int[-1,0,1]
2056  */
2061  /*
2062  * PATH_ASSIGN node
2063  * Description: path assignment statement
2064  * Number Of Arguments: 3
2065  * arg0: CNode* condition
2066  * arg1: CNode* path
2067  * arg2: CNode* expression
2068  */
2073  /*
2074  * IFNONE_PATH_ASSIGN node
2075  * Description: ifnone path assignment statement
2076  * Number Of Arguments: 2
2077  * arg0: CNode* path
2078  * arg1: CNode* expression
2079  */
2084  /*
2085  * TRIGGER node
2086  * Description: event trigger
2087  * Number Of Arguments: 1
2088  * arg0: CNode* event reference
2089  */
2094  /*
2095  * PASSIGN node
2096  * Description: procedural assignment
2097  * Number Of Arguments: 2
2098  * arg0: CNode* lval
2099  * arg1: CNode* expression
2100  */
2105  /*
2106  * DEASSIGN node
2107  * Description: deassign statement
2108  * Number Of Arguments: 1
2109  * arg0: CNode* lval
2110  */
2115  /*
2116  * DISABLE node
2117  * Description: disable statement
2118  * Number Of Arguments: 1
2119  * arg0: CSymbol* pointer to symbol
2120  */
2125  /*
2126  * ATTRIBUTE node
2127  * Description: attribute specification
2128  * Number Of Arguments: 1
2129  * arg0: CAttr* pointer to attribute
2130  */
2135  /*
2136  * GIF node
2137  * Description: structural if statement
2138  * Number Of Arguments: 3
2139  * arg0: CNode* condition
2140  * arg1: CNode* true statement
2141  * arg2: CNode* false statement
2142  */
2147  /*
2148  * GFOR node
2149  * Description: structural for statement
2150  * Number Of Arguments: 4
2151  * arg0: CNode* initial statement
2152  * arg1: CNode* condition
2153  * arg2: CNode* assignment statement
2154  * arg3: CNode* statement
2155  */
2160  /*
2161  * GCASE node
2162  * Description: structural case statement
2163  * Number Of Arguments: 2
2164  * arg0: CNode* condition
2165  * arg1: CNode* list of case items
2166  */
2171  /*
2172  * TABLE node
2173  * Description: udp table
2174  * Number Of Arguments: 1
2175  * arg0: CNode* list of table entries
2176  */
2181  /*
2182  * TABLE_ENTRY node
2183  * Description: udp table entry
2184  * Number Of Arguments: 1
2185  * arg0: CNode* list of table symbols
2186  */
2191  /*
2192  * TABLE_SYMBOL node
2193  * Description: udp table symbol
2194  * Number Of Arguments: 1
2195  * arg0: char* string of udp characters
2196  */
2201  /*
2202  * PORTLIST_END node
2203  * Description: sentinal at end of port list
2204  * Number Of Arguments: 0
2205  */
2210  /*
2211  * MACRO_EXPR node
2212  * Description: expression represented by a macro
2213  * Number Of Arguments: 2
2214  * arg0: const char* alternate expression, may be NULL
2215  * arg1: CNode*
2216  */
2221  /*
2222  * ENUM_SPEC node
2223  * Description: enum specification
2224  * Number Of Arguments: 3
2225  * arg0: CSymbol* Pointer to enum base symbol
2226  * arg1: CNode* range expression
2227  * arg2: CNode* starting expression value
2228  */
2233  /*
2234  * MEMBER node
2235  * Description: member reference (structure, class or external
2236  * Number Of Arguments: 2
2237  * arg0: CNode* Reference to variable
2238  * arg1: CSymbol* member symbol
2239  */
2244  /*
2245  * RETURN node
2246  * Description: return
2247  * Number Of Arguments: 1
2248  * arg0: CNode*
2249  */
2254  /*
2255  * PREINC node
2256  * Description: preincrement
2257  * Number Of Arguments: 1
2258  * arg0: CNode* expression
2259  */
2264  /*
2265  * POSTINC node
2266  * Description: postincrement
2267  * Number Of Arguments: 1
2268  * arg0: CNode* expression
2269  */
2274  /*
2275  * PREDEC node
2276  * Description: predecrement
2277  * Number Of Arguments: 1
2278  * arg0: CNode* expression
2279  */
2284  /*
2285  * POSTDEC node
2286  * Description: postdecrement
2287  * Number Of Arguments: 1
2288  * arg0: CNode* expression
2289  */
2294  /*
2295  * CAST node
2296  * Description: data type change
2297  * Number Of Arguments: 2
2298  * arg0: CNode* type reference or width expression
2299  * arg1: CNode* expression
2300  */
2305  /*
2306  * ASSIGNMENT_PATTERN node
2307  * Description: assignment_pattern
2308  * Number Of Arguments: 1
2309  * arg0: CNode* concatenation expression
2310  */
2315  /*
2316  * DOLLAR node
2317  * Description: queue dimension
2318  * Number Of Arguments: 0
2319  */
2321 };
2322 extern const char* nodeOpName[];
2323 extern const char* nodeOpDescription[];
2324 #endif // DEFINE_ENUM
2325 #ifdef DEFINE_METHODS
2326 const char* nodeOpName[] = {
2327  "ERROR",
2328  "VCONSTANT",
2329  "RCONSTANT",
2330  "COMMENT",
2331  "VRQ",
2332  "PRAGMA",
2333  "ELIST",
2334  "WIDTH",
2335  "NOP",
2336  "SUB",
2337  "MUL",
2338  "DIV",
2339  "POW",
2340  "ADD",
2341  "LSH",
2342  "RSH",
2343  "LSHA",
2344  "RSHA",
2345  "MOD",
2346  "OR",
2347  "AND",
2348  "ANDANDAND",
2349  "XOR",
2350  "XNOR",
2351  "INSTANCE_REF",
2352  "GATE_REF",
2353  "TASK_ENABLE",
2354  "SYSTASK_CALL",
2355  "TIMING_CALL",
2356  "FUNCTION_CALL",
2357  "ARRAY",
2358  "NET_REF",
2359  "VAR_REF",
2360  "PARAM_REF",
2361  "PORT_REF",
2362  "FWD_REF",
2363  "GENVAR_REF",
2364  "ENUM_REF",
2365  "TYPE_REF",
2366  "NET_DECL",
2367  "VAR_DECL",
2368  "PARAM_DECL",
2369  "SPECPARAM_DECL",
2370  "PORT_DECL",
2371  "GENVAR_DECL",
2372  "TYPEDEF_DECL",
2373  "LIST",
2374  "RANGE",
2375  "SLICE",
2376  "PSLICE",
2377  "MSLICE",
2378  "CVRI",
2379  "CVIR",
2380  "REP",
2381  "CAT",
2382  "UCAT",
2383  "COM",
2384  "NEG",
2385  "PLUS",
2386  "NOT",
2387  "GT",
2388  "GE",
2389  "LT",
2390  "LE",
2391  "LAND",
2392  "LOR",
2393  "CEQ",
2394  "CNE",
2395  "EQ",
2396  "NE",
2397  "RAND",
2398  "RNAND",
2399  "ROR",
2400  "RNOR",
2401  "RXOR",
2402  "RXNOR",
2403  "HOOK",
2404  "INIT",
2405  "ALWAYS",
2406  "ALWAYS_LATCH",
2407  "ALWAYS_FF",
2408  "ALWAYS_COMB",
2409  "EVENT",
2410  "BLOCK_REF",
2411  "SPECIFY_REF",
2412  "ASSIGN",
2413  "GASSIGN",
2414  "ADD_ASSIGN",
2415  "SUB_ASSIGN",
2416  "MUL_ASSIGN",
2417  "DIV_ASSIGN",
2418  "MOD_ASSIGN",
2419  "AND_ASSIGN",
2420  "OR_ASSIGN",
2421  "XOR_ASSIGN",
2422  "LSH_ASSIGN",
2423  "RSH_ASSIGN",
2424  "LSHA_ASSIGN",
2425  "RSHA_ASSIGN",
2426  "FORCE",
2427  "RELEASE",
2428  "NBASSIGN",
2429  "POSEDGE",
2430  "NEGEDGE",
2431  "EDGE",
2432  "EVOR",
2433  "DELAY",
2434  "MTM",
2435  "IF",
2436  "FOREVER",
2437  "REPEAT",
2438  "WHILE",
2439  "WAIT",
2440  "FOR",
2441  "CASE",
2442  "CASEX",
2443  "CASEZ",
2444  "CASEITEM",
2445  "CASSIGN",
2446  "ARG",
2447  "IMPORT",
2448  "FUNCTION_DEF",
2449  "MODULE_DEF",
2450  "PACKAGE_DEF",
2451  "REPEAT_CONTROL",
2452  "DELAY_CONTROL",
2453  "EVENT_CONTROL",
2454  "EXTERNAL_REF",
2455  "PORT_DEF",
2456  "DEFPARAM",
2457  "PATH",
2458  "PATH_ASSIGN",
2459  "IFNONE_PATH_ASSIGN",
2460  "TRIGGER",
2461  "PASSIGN",
2462  "DEASSIGN",
2463  "DISABLE",
2464  "ATTRIBUTE",
2465  "GIF",
2466  "GFOR",
2467  "GCASE",
2468  "TABLE",
2469  "TABLE_ENTRY",
2470  "TABLE_SYMBOL",
2471  "PORTLIST_END",
2472  "MACRO_EXPR",
2473  "ENUM_SPEC",
2474  "MEMBER",
2475  "RETURN",
2476  "PREINC",
2477  "POSTINC",
2478  "PREDEC",
2479  "POSTDEC",
2480  "CAST",
2481  "ASSIGNMENT_PATTERN",
2482  "DOLLAR",
2483 NULL
2484 };
2485 const char* nodeOpDescription[] = {
2486  "error node",
2487  "vector constant",
2488  "real constant",
2489  "comment",
2490  "vrq comment",
2491  "program pragma",
2492  "expression list",
2493  "expression width change",
2494  "no operation",
2495  "subtract",
2496  "multiply",
2497  "divide",
2498  "exponent",
2499  "addition",
2500  "logical left shift",
2501  "logical right shift",
2502  "arithmetic left shift",
2503  "arithmetic right shift",
2504  "modulus",
2505  "bitwise or",
2506  "bitwise and",
2507  "triple and",
2508  "bitwise xor",
2509  "bitwise xnor",
2510  "instance reference",
2511  "gate instance",
2512  "call to a task",
2513  "call to enable a systask",
2514  "call to a timing task",
2515  "call to a function",
2516  "dimensioned reference (array/bit select)",
2517  "reference to net",
2518  "reference to variable",
2519  "reference to parameter",
2520  "reference to port",
2521  "reference to a forward declared variable",
2522  "reference to a genvar",
2523  "reference to a enum",
2524  "reference to a type",
2525  "net declaration",
2526  "variable declaration",
2527  "parameter declaration",
2528  "specify parameter declaration",
2529  "port declaration",
2530  "genvar declaration",
2531  "type declaration",
2532  "list of nodes",
2533  "vector decl range specification",
2534  "vector subrange",
2535  "vector subrange with ascending index select",
2536  "vector subrange with descending index select",
2537  "convert real to integer",
2538  "convert integer to real",
2539  "replication operator",
2540  "concatenation operator",
2541  "unary concat",
2542  "bitwise complement",
2543  "negation",
2544  "unary plus",
2545  "logical complement",
2546  "greater than",
2547  "greater than or equal",
2548  "less than",
2549  "less than or equal",
2550  "logical and",
2551  "logical or",
2552  "case equal",
2553  "case not equal",
2554  "equal",
2555  "not equal",
2556  "reduction and",
2557  "reduction nand",
2558  "reduction or",
2559  "reduction nor",
2560  "reduction xor",
2561  "reduction xnor",
2562  "condition expression operator",
2563  "initial block",
2564  "always block",
2565  "always latch block",
2566  "always flip-flop block",
2567  "always combinational logic block",
2568  "event statement",
2569  "statement block",
2570  "specify block",
2571  "procedural assignment",
2572  "generate intialize assignment",
2573  "procedural assignment with add",
2574  "procedural assignment with subtract",
2575  "procedural assignment with mul",
2576  "procedural assignment with div",
2577  "procedural assignment with mod",
2578  "procedural assignment with bitwise and",
2579  "procedural assignment with bitwise or",
2580  "procedural assignment with bitwise xor",
2581  "procedural assignment with left shift",
2582  "procedural assignment with right shift",
2583  "procedural assignment with left arithmetic shift",
2584  "procedural assignment with right arithmetic shift",
2585  "force statement",
2586  "release statement",
2587  "nonblocking assignment",
2588  "positive event qualifier",
2589  "negative event qualifier",
2590  "edge qualifier",
2591  "event or",
2592  "delay statement",
2593  "min/typ/max expression",
2594  "if statement",
2595  "forever statement",
2596  "repeat statement",
2597  "while statement",
2598  "wait statement",
2599  "for statement",
2600  "case statement",
2601  "casex statement",
2602  "casez statement",
2603  "case item",
2604  "continious assignment",
2605  "port connection",
2606  "import item",
2607  "function definition",
2608  "module definition",
2609  "package definition",
2610  "repeat control",
2611  "delay control",
2612  "event control",
2613  "external reference",
2614  "port definition",
2615  "defparam statement",
2616  "path statement",
2617  "path assignment statement",
2618  "ifnone path assignment statement",
2619  "event trigger",
2620  "procedural assignment",
2621  "deassign statement",
2622  "disable statement",
2623  "attribute specification",
2624  "structural if statement",
2625  "structural for statement",
2626  "structural case statement",
2627  "udp table",
2628  "udp table entry",
2629  "udp table symbol",
2630  "sentinal at end of port list",
2631  "expression represented by a macro",
2632  "enum specification",
2633  "member reference (structure, class or external",
2634  "return",
2635  "preincrement",
2636  "postincrement",
2637  "predecrement",
2638  "postdecrement",
2639  "data type change",
2640  "assignment_pattern",
2641  "queue dimension",
2642 NULL
2643 };
2644 #endif // DEFINE_METHODS
2645 
2646 
2647 #ifdef DEFINE_CONSTRUCTOR
2648 
2656 inline CNode* cERROR( Coord_t* loc=NULL )
2657 {
2658  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eERROR );
2659  return n;
2660 }
2669 inline CNode* cERROR( CObstack* heap, Coord_t* loc=NULL )
2670 {
2671  CNode* n = new(heap) CNode( loc, eERROR );
2672  return n;
2673 }
2682 inline CNode* cVCONSTANT( CVector* a0, Coord_t* loc=NULL )
2683 {
2684  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eVCONSTANT );
2685  n->Arg<CVector*>(0) = a0;
2686  return n;
2687 }
2697 inline CNode* cVCONSTANT( CObstack* heap, CVector* a0, Coord_t* loc=NULL )
2698 {
2699  CNode* n = new(heap) CNode( loc, eVCONSTANT );
2700  n->Arg<CVector*>(0) = a0;
2701  return n;
2702 }
2711 inline CNode* cRCONSTANT( char* a0, Coord_t* loc=NULL )
2712 {
2713  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRCONSTANT );
2714  n->Arg<char*>(0) = a0;
2715  return n;
2716 }
2726 inline CNode* cRCONSTANT( CObstack* heap, char* a0, Coord_t* loc=NULL )
2727 {
2728  CNode* n = new(heap) CNode( loc, eRCONSTANT );
2729  n->Arg<char*>(0) = a0;
2730  return n;
2731 }
2740 inline CNode* cCOMMENT( const char* a0, Coord_t* loc=NULL )
2741 {
2742  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCOMMENT );
2743  n->Arg<const char*>(0) = a0;
2744  return n;
2745 }
2755 inline CNode* cCOMMENT( CObstack* heap, const char* a0, Coord_t* loc=NULL )
2756 {
2757  CNode* n = new(heap) CNode( loc, eCOMMENT );
2758  n->Arg<const char*>(0) = a0;
2759  return n;
2760 }
2769 inline CNode* cVRQ( const char* a0, Coord_t* loc=NULL )
2770 {
2771  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eVRQ );
2772  n->Arg<const char*>(0) = a0;
2773  return n;
2774 }
2784 inline CNode* cVRQ( CObstack* heap, const char* a0, Coord_t* loc=NULL )
2785 {
2786  CNode* n = new(heap) CNode( loc, eVRQ );
2787  n->Arg<const char*>(0) = a0;
2788  return n;
2789 }
2799 inline CNode* cPRAGMA( const char* a0, int a1, Coord_t* loc=NULL )
2800 {
2801  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePRAGMA );
2802  n->Arg<const char*>(0) = a0;
2803  n->Arg<int>(1) = a1;
2804  return n;
2805 }
2816 inline CNode* cPRAGMA( CObstack* heap, const char* a0, int a1, Coord_t* loc=NULL )
2817 {
2818  CNode* n = new(heap) CNode( loc, ePRAGMA );
2819  n->Arg<const char*>(0) = a0;
2820  n->Arg<int>(1) = a1;
2821  return n;
2822 }
2832 inline CNode* cELIST( CNode* a0, CNode* a1, Coord_t* loc=NULL )
2833 {
2834  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eELIST );
2835  n->Arg<CNode*>(0) = a0;
2836  n->Arg<CNode*>(1) = a1;
2837  return n;
2838 }
2849 inline CNode* cELIST( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
2850 {
2851  CNode* n = new(heap) CNode( loc, eELIST );
2852  n->Arg<CNode*>(0) = a0;
2853  n->Arg<CNode*>(1) = a1;
2854  return n;
2855 }
2865 inline CNode* cWIDTH( CNode* a0, CNode* a1, Coord_t* loc=NULL )
2866 {
2867  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eWIDTH );
2868  n->Arg<CNode*>(0) = a0;
2869  n->Arg<CNode*>(1) = a1;
2870  return n;
2871 }
2882 inline CNode* cWIDTH( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
2883 {
2884  CNode* n = new(heap) CNode( loc, eWIDTH );
2885  n->Arg<CNode*>(0) = a0;
2886  n->Arg<CNode*>(1) = a1;
2887  return n;
2888 }
2896 inline CNode* cNOP( Coord_t* loc=NULL )
2897 {
2898  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eNOP );
2899  return n;
2900 }
2909 inline CNode* cNOP( CObstack* heap, Coord_t* loc=NULL )
2910 {
2911  CNode* n = new(heap) CNode( loc, eNOP );
2912  return n;
2913 }
2923 inline CNode* cSUB( CNode* a0, CNode* a1, Coord_t* loc=NULL )
2924 {
2925  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eSUB );
2926  n->Arg<CNode*>(0) = a0;
2927  n->Arg<CNode*>(1) = a1;
2928  return n;
2929 }
2940 inline CNode* cSUB( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
2941 {
2942  CNode* n = new(heap) CNode( loc, eSUB );
2943  n->Arg<CNode*>(0) = a0;
2944  n->Arg<CNode*>(1) = a1;
2945  return n;
2946 }
2956 inline CNode* cMUL( CNode* a0, CNode* a1, Coord_t* loc=NULL )
2957 {
2958  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eMUL );
2959  n->Arg<CNode*>(0) = a0;
2960  n->Arg<CNode*>(1) = a1;
2961  return n;
2962 }
2973 inline CNode* cMUL( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
2974 {
2975  CNode* n = new(heap) CNode( loc, eMUL );
2976  n->Arg<CNode*>(0) = a0;
2977  n->Arg<CNode*>(1) = a1;
2978  return n;
2979 }
2989 inline CNode* cDIV( CNode* a0, CNode* a1, Coord_t* loc=NULL )
2990 {
2991  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eDIV );
2992  n->Arg<CNode*>(0) = a0;
2993  n->Arg<CNode*>(1) = a1;
2994  return n;
2995 }
3006 inline CNode* cDIV( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
3007 {
3008  CNode* n = new(heap) CNode( loc, eDIV );
3009  n->Arg<CNode*>(0) = a0;
3010  n->Arg<CNode*>(1) = a1;
3011  return n;
3012 }
3022 inline CNode* cPOW( CNode* a0, CNode* a1, Coord_t* loc=NULL )
3023 {
3024  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePOW );
3025  n->Arg<CNode*>(0) = a0;
3026  n->Arg<CNode*>(1) = a1;
3027  return n;
3028 }
3039 inline CNode* cPOW( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
3040 {
3041  CNode* n = new(heap) CNode( loc, ePOW );
3042  n->Arg<CNode*>(0) = a0;
3043  n->Arg<CNode*>(1) = a1;
3044  return n;
3045 }
3055 inline CNode* cADD( CNode* a0, CNode* a1, Coord_t* loc=NULL )
3056 {
3057  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eADD );
3058  n->Arg<CNode*>(0) = a0;
3059  n->Arg<CNode*>(1) = a1;
3060  return n;
3061 }
3072 inline CNode* cADD( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
3073 {
3074  CNode* n = new(heap) CNode( loc, eADD );
3075  n->Arg<CNode*>(0) = a0;
3076  n->Arg<CNode*>(1) = a1;
3077  return n;
3078 }
3088 inline CNode* cLSH( CNode* a0, CNode* a1, Coord_t* loc=NULL )
3089 {
3090  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eLSH );
3091  n->Arg<CNode*>(0) = a0;
3092  n->Arg<CNode*>(1) = a1;
3093  return n;
3094 }
3105 inline CNode* cLSH( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
3106 {
3107  CNode* n = new(heap) CNode( loc, eLSH );
3108  n->Arg<CNode*>(0) = a0;
3109  n->Arg<CNode*>(1) = a1;
3110  return n;
3111 }
3121 inline CNode* cRSH( CNode* a0, CNode* a1, Coord_t* loc=NULL )
3122 {
3123  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRSH );
3124  n->Arg<CNode*>(0) = a0;
3125  n->Arg<CNode*>(1) = a1;
3126  return n;
3127 }
3138 inline CNode* cRSH( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
3139 {
3140  CNode* n = new(heap) CNode( loc, eRSH );
3141  n->Arg<CNode*>(0) = a0;
3142  n->Arg<CNode*>(1) = a1;
3143  return n;
3144 }
3154 inline CNode* cLSHA( CNode* a0, CNode* a1, Coord_t* loc=NULL )
3155 {
3156  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eLSHA );
3157  n->Arg<CNode*>(0) = a0;
3158  n->Arg<CNode*>(1) = a1;
3159  return n;
3160 }
3171 inline CNode* cLSHA( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
3172 {
3173  CNode* n = new(heap) CNode( loc, eLSHA );
3174  n->Arg<CNode*>(0) = a0;
3175  n->Arg<CNode*>(1) = a1;
3176  return n;
3177 }
3187 inline CNode* cRSHA( CNode* a0, CNode* a1, Coord_t* loc=NULL )
3188 {
3189  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRSHA );
3190  n->Arg<CNode*>(0) = a0;
3191  n->Arg<CNode*>(1) = a1;
3192  return n;
3193 }
3204 inline CNode* cRSHA( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
3205 {
3206  CNode* n = new(heap) CNode( loc, eRSHA );
3207  n->Arg<CNode*>(0) = a0;
3208  n->Arg<CNode*>(1) = a1;
3209  return n;
3210 }
3220 inline CNode* cMOD( CNode* a0, CNode* a1, Coord_t* loc=NULL )
3221 {
3222  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eMOD );
3223  n->Arg<CNode*>(0) = a0;
3224  n->Arg<CNode*>(1) = a1;
3225  return n;
3226 }
3237 inline CNode* cMOD( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
3238 {
3239  CNode* n = new(heap) CNode( loc, eMOD );
3240  n->Arg<CNode*>(0) = a0;
3241  n->Arg<CNode*>(1) = a1;
3242  return n;
3243 }
3253 inline CNode* cOR( CNode* a0, CNode* a1, Coord_t* loc=NULL )
3254 {
3255  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eOR );
3256  n->Arg<CNode*>(0) = a0;
3257  n->Arg<CNode*>(1) = a1;
3258  return n;
3259 }
3270 inline CNode* cOR( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
3271 {
3272  CNode* n = new(heap) CNode( loc, eOR );
3273  n->Arg<CNode*>(0) = a0;
3274  n->Arg<CNode*>(1) = a1;
3275  return n;
3276 }
3286 inline CNode* cAND( CNode* a0, CNode* a1, Coord_t* loc=NULL )
3287 {
3288  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eAND );
3289  n->Arg<CNode*>(0) = a0;
3290  n->Arg<CNode*>(1) = a1;
3291  return n;
3292 }
3303 inline CNode* cAND( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
3304 {
3305  CNode* n = new(heap) CNode( loc, eAND );
3306  n->Arg<CNode*>(0) = a0;
3307  n->Arg<CNode*>(1) = a1;
3308  return n;
3309 }
3319 inline CNode* cANDANDAND( CNode* a0, CNode* a1, Coord_t* loc=NULL )
3320 {
3321  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eANDANDAND );
3322  n->Arg<CNode*>(0) = a0;
3323  n->Arg<CNode*>(1) = a1;
3324  return n;
3325 }
3336 inline CNode* cANDANDAND( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
3337 {
3338  CNode* n = new(heap) CNode( loc, eANDANDAND );
3339  n->Arg<CNode*>(0) = a0;
3340  n->Arg<CNode*>(1) = a1;
3341  return n;
3342 }
3352 inline CNode* cXOR( CNode* a0, CNode* a1, Coord_t* loc=NULL )
3353 {
3354  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eXOR );
3355  n->Arg<CNode*>(0) = a0;
3356  n->Arg<CNode*>(1) = a1;
3357  return n;
3358 }
3369 inline CNode* cXOR( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
3370 {
3371  CNode* n = new(heap) CNode( loc, eXOR );
3372  n->Arg<CNode*>(0) = a0;
3373  n->Arg<CNode*>(1) = a1;
3374  return n;
3375 }
3385 inline CNode* cXNOR( CNode* a0, CNode* a1, Coord_t* loc=NULL )
3386 {
3387  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eXNOR );
3388  n->Arg<CNode*>(0) = a0;
3389  n->Arg<CNode*>(1) = a1;
3390  return n;
3391 }
3402 inline CNode* cXNOR( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
3403 {
3404  CNode* n = new(heap) CNode( loc, eXNOR );
3405  n->Arg<CNode*>(0) = a0;
3406  n->Arg<CNode*>(1) = a1;
3407  return n;
3408 }
3417 inline CNode* cINSTANCE_REF( CInstance* a0, Coord_t* loc=NULL )
3418 {
3419  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eINSTANCE_REF );
3420  n->Arg<CInstance*>(0) = a0;
3421  return n;
3422 }
3432 inline CNode* cINSTANCE_REF( CObstack* heap, CInstance* a0, Coord_t* loc=NULL )
3433 {
3434  CNode* n = new(heap) CNode( loc, eINSTANCE_REF );
3435  n->Arg<CInstance*>(0) = a0;
3436  return n;
3437 }
3446 inline CNode* cGATE_REF( CGate* a0, Coord_t* loc=NULL )
3447 {
3448  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eGATE_REF );
3449  n->Arg<CGate*>(0) = a0;
3450  return n;
3451 }
3461 inline CNode* cGATE_REF( CObstack* heap, CGate* a0, Coord_t* loc=NULL )
3462 {
3463  CNode* n = new(heap) CNode( loc, eGATE_REF );
3464  n->Arg<CGate*>(0) = a0;
3465  return n;
3466 }
3476 inline CNode* cTASK_ENABLE( CSymbol* a0, CNode* a1, Coord_t* loc=NULL )
3477 {
3478  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eTASK_ENABLE );
3479  n->Arg<CSymbol*>(0) = a0;
3480  n->Arg<CNode*>(1) = a1;
3481  return n;
3482 }
3493 inline CNode* cTASK_ENABLE( CObstack* heap, CSymbol* a0, CNode* a1, Coord_t* loc=NULL )
3494 {
3495  CNode* n = new(heap) CNode( loc, eTASK_ENABLE );
3496  n->Arg<CSymbol*>(0) = a0;
3497  n->Arg<CNode*>(1) = a1;
3498  return n;
3499 }
3509 inline CNode* cSYSTASK_CALL( CSymbol* a0, CNode* a1, Coord_t* loc=NULL )
3510 {
3511  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eSYSTASK_CALL );
3512  n->Arg<CSymbol*>(0) = a0;
3513  n->Arg<CNode*>(1) = a1;
3514  return n;
3515 }
3526 inline CNode* cSYSTASK_CALL( CObstack* heap, CSymbol* a0, CNode* a1, Coord_t* loc=NULL )
3527 {
3528  CNode* n = new(heap) CNode( loc, eSYSTASK_CALL );
3529  n->Arg<CSymbol*>(0) = a0;
3530  n->Arg<CNode*>(1) = a1;
3531  return n;
3532 }
3542 inline CNode* cTIMING_CALL( CSymbol* a0, CNode* a1, Coord_t* loc=NULL )
3543 {
3544  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eTIMING_CALL );
3545  n->Arg<CSymbol*>(0) = a0;
3546  n->Arg<CNode*>(1) = a1;
3547  return n;
3548 }
3559 inline CNode* cTIMING_CALL( CObstack* heap, CSymbol* a0, CNode* a1, Coord_t* loc=NULL )
3560 {
3561  CNode* n = new(heap) CNode( loc, eTIMING_CALL );
3562  n->Arg<CSymbol*>(0) = a0;
3563  n->Arg<CNode*>(1) = a1;
3564  return n;
3565 }
3576 inline CNode* cFUNCTION_CALL( CSymbol* a0, CNode* a1, CScope* a2, Coord_t* loc=NULL )
3577 {
3578  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eFUNCTION_CALL );
3579  n->Arg<CSymbol*>(0) = a0;
3580  n->Arg<CNode*>(1) = a1;
3581  n->Arg<CScope*>(2) = a2;
3582  return n;
3583 }
3595 inline CNode* cFUNCTION_CALL( CObstack* heap, CSymbol* a0, CNode* a1, CScope* a2, Coord_t* loc=NULL )
3596 {
3597  CNode* n = new(heap) CNode( loc, eFUNCTION_CALL );
3598  n->Arg<CSymbol*>(0) = a0;
3599  n->Arg<CNode*>(1) = a1;
3600  n->Arg<CScope*>(2) = a2;
3601  return n;
3602 }
3612 inline CNode* cARRAY( CNode* a0, CNode* a1, Coord_t* loc=NULL )
3613 {
3614  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eARRAY );
3615  n->Arg<CNode*>(0) = a0;
3616  n->Arg<CNode*>(1) = a1;
3617  return n;
3618 }
3629 inline CNode* cARRAY( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
3630 {
3631  CNode* n = new(heap) CNode( loc, eARRAY );
3632  n->Arg<CNode*>(0) = a0;
3633  n->Arg<CNode*>(1) = a1;
3634  return n;
3635 }
3644 inline CNode* cNET_REF( CNet* a0, Coord_t* loc=NULL )
3645 {
3646  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eNET_REF );
3647  n->Arg<CNet*>(0) = a0;
3648  return n;
3649 }
3659 inline CNode* cNET_REF( CObstack* heap, CNet* a0, Coord_t* loc=NULL )
3660 {
3661  CNode* n = new(heap) CNode( loc, eNET_REF );
3662  n->Arg<CNet*>(0) = a0;
3663  return n;
3664 }
3673 inline CNode* cVAR_REF( CVar* a0, Coord_t* loc=NULL )
3674 {
3675  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eVAR_REF );
3676  n->Arg<CVar*>(0) = a0;
3677  return n;
3678 }
3688 inline CNode* cVAR_REF( CObstack* heap, CVar* a0, Coord_t* loc=NULL )
3689 {
3690  CNode* n = new(heap) CNode( loc, eVAR_REF );
3691  n->Arg<CVar*>(0) = a0;
3692  return n;
3693 }
3702 inline CNode* cPARAM_REF( CParam* a0, Coord_t* loc=NULL )
3703 {
3704  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePARAM_REF );
3705  n->Arg<CParam*>(0) = a0;
3706  return n;
3707 }
3717 inline CNode* cPARAM_REF( CObstack* heap, CParam* a0, Coord_t* loc=NULL )
3718 {
3719  CNode* n = new(heap) CNode( loc, ePARAM_REF );
3720  n->Arg<CParam*>(0) = a0;
3721  return n;
3722 }
3731 inline CNode* cPORT_REF( CPortDir* a0, Coord_t* loc=NULL )
3732 {
3733  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePORT_REF );
3734  n->Arg<CPortDir*>(0) = a0;
3735  return n;
3736 }
3746 inline CNode* cPORT_REF( CObstack* heap, CPortDir* a0, Coord_t* loc=NULL )
3747 {
3748  CNode* n = new(heap) CNode( loc, ePORT_REF );
3749  n->Arg<CPortDir*>(0) = a0;
3750  return n;
3751 }
3760 inline CNode* cFWD_REF( CFref* a0, Coord_t* loc=NULL )
3761 {
3762  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eFWD_REF );
3763  n->Arg<CFref*>(0) = a0;
3764  return n;
3765 }
3775 inline CNode* cFWD_REF( CObstack* heap, CFref* a0, Coord_t* loc=NULL )
3776 {
3777  CNode* n = new(heap) CNode( loc, eFWD_REF );
3778  n->Arg<CFref*>(0) = a0;
3779  return n;
3780 }
3789 inline CNode* cGENVAR_REF( CGenvar* a0, Coord_t* loc=NULL )
3790 {
3791  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eGENVAR_REF );
3792  n->Arg<CGenvar*>(0) = a0;
3793  return n;
3794 }
3804 inline CNode* cGENVAR_REF( CObstack* heap, CGenvar* a0, Coord_t* loc=NULL )
3805 {
3806  CNode* n = new(heap) CNode( loc, eGENVAR_REF );
3807  n->Arg<CGenvar*>(0) = a0;
3808  return n;
3809 }
3818 inline CNode* cENUM_REF( CEnum* a0, Coord_t* loc=NULL )
3819 {
3820  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eENUM_REF );
3821  n->Arg<CEnum*>(0) = a0;
3822  return n;
3823 }
3833 inline CNode* cENUM_REF( CObstack* heap, CEnum* a0, Coord_t* loc=NULL )
3834 {
3835  CNode* n = new(heap) CNode( loc, eENUM_REF );
3836  n->Arg<CEnum*>(0) = a0;
3837  return n;
3838 }
3847 inline CNode* cTYPE_REF( CTypedef* a0, Coord_t* loc=NULL )
3848 {
3849  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eTYPE_REF );
3850  n->Arg<CTypedef*>(0) = a0;
3851  return n;
3852 }
3862 inline CNode* cTYPE_REF( CObstack* heap, CTypedef* a0, Coord_t* loc=NULL )
3863 {
3864  CNode* n = new(heap) CNode( loc, eTYPE_REF );
3865  n->Arg<CTypedef*>(0) = a0;
3866  return n;
3867 }
3877 inline CNode* cNET_DECL( CNet* a0, CNode* a1, Coord_t* loc=NULL )
3878 {
3879  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eNET_DECL );
3880  n->Arg<CNet*>(0) = a0;
3881  n->Arg<CNode*>(1) = a1;
3882  return n;
3883 }
3894 inline CNode* cNET_DECL( CObstack* heap, CNet* a0, CNode* a1, Coord_t* loc=NULL )
3895 {
3896  CNode* n = new(heap) CNode( loc, eNET_DECL );
3897  n->Arg<CNet*>(0) = a0;
3898  n->Arg<CNode*>(1) = a1;
3899  return n;
3900 }
3910 inline CNode* cVAR_DECL( CVar* a0, CNode* a1, Coord_t* loc=NULL )
3911 {
3912  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eVAR_DECL );
3913  n->Arg<CVar*>(0) = a0;
3914  n->Arg<CNode*>(1) = a1;
3915  return n;
3916 }
3927 inline CNode* cVAR_DECL( CObstack* heap, CVar* a0, CNode* a1, Coord_t* loc=NULL )
3928 {
3929  CNode* n = new(heap) CNode( loc, eVAR_DECL );
3930  n->Arg<CVar*>(0) = a0;
3931  n->Arg<CNode*>(1) = a1;
3932  return n;
3933 }
3942 inline CNode* cPARAM_DECL( CParam* a0, Coord_t* loc=NULL )
3943 {
3944  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePARAM_DECL );
3945  n->Arg<CParam*>(0) = a0;
3946  return n;
3947 }
3957 inline CNode* cPARAM_DECL( CObstack* heap, CParam* a0, Coord_t* loc=NULL )
3958 {
3959  CNode* n = new(heap) CNode( loc, ePARAM_DECL );
3960  n->Arg<CParam*>(0) = a0;
3961  return n;
3962 }
3971 inline CNode* cSPECPARAM_DECL( CParam* a0, Coord_t* loc=NULL )
3972 {
3973  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eSPECPARAM_DECL );
3974  n->Arg<CParam*>(0) = a0;
3975  return n;
3976 }
3986 inline CNode* cSPECPARAM_DECL( CObstack* heap, CParam* a0, Coord_t* loc=NULL )
3987 {
3988  CNode* n = new(heap) CNode( loc, eSPECPARAM_DECL );
3989  n->Arg<CParam*>(0) = a0;
3990  return n;
3991 }
4000 inline CNode* cPORT_DECL( CPortDir* a0, Coord_t* loc=NULL )
4001 {
4002  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePORT_DECL );
4003  n->Arg<CPortDir*>(0) = a0;
4004  return n;
4005 }
4015 inline CNode* cPORT_DECL( CObstack* heap, CPortDir* a0, Coord_t* loc=NULL )
4016 {
4017  CNode* n = new(heap) CNode( loc, ePORT_DECL );
4018  n->Arg<CPortDir*>(0) = a0;
4019  return n;
4020 }
4029 inline CNode* cGENVAR_DECL( CGenvar* a0, Coord_t* loc=NULL )
4030 {
4031  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eGENVAR_DECL );
4032  n->Arg<CGenvar*>(0) = a0;
4033  return n;
4034 }
4044 inline CNode* cGENVAR_DECL( CObstack* heap, CGenvar* a0, Coord_t* loc=NULL )
4045 {
4046  CNode* n = new(heap) CNode( loc, eGENVAR_DECL );
4047  n->Arg<CGenvar*>(0) = a0;
4048  return n;
4049 }
4058 inline CNode* cTYPEDEF_DECL( CTypedef* a0, Coord_t* loc=NULL )
4059 {
4060  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eTYPEDEF_DECL );
4061  n->Arg<CTypedef*>(0) = a0;
4062  return n;
4063 }
4073 inline CNode* cTYPEDEF_DECL( CObstack* heap, CTypedef* a0, Coord_t* loc=NULL )
4074 {
4075  CNode* n = new(heap) CNode( loc, eTYPEDEF_DECL );
4076  n->Arg<CTypedef*>(0) = a0;
4077  return n;
4078 }
4088 inline CNode* cLIST( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4089 {
4090  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eLIST );
4091  n->Arg<CNode*>(0) = a0;
4092  n->Arg<CNode*>(1) = a1;
4093  return n;
4094 }
4105 inline CNode* cLIST( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4106 {
4107  CNode* n = new(heap) CNode( loc, eLIST );
4108  n->Arg<CNode*>(0) = a0;
4109  n->Arg<CNode*>(1) = a1;
4110  return n;
4111 }
4121 inline CNode* cRANGE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4122 {
4123  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRANGE );
4124  n->Arg<CNode*>(0) = a0;
4125  n->Arg<CNode*>(1) = a1;
4126  return n;
4127 }
4138 inline CNode* cRANGE( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4139 {
4140  CNode* n = new(heap) CNode( loc, eRANGE );
4141  n->Arg<CNode*>(0) = a0;
4142  n->Arg<CNode*>(1) = a1;
4143  return n;
4144 }
4154 inline CNode* cSLICE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4155 {
4156  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eSLICE );
4157  n->Arg<CNode*>(0) = a0;
4158  n->Arg<CNode*>(1) = a1;
4159  return n;
4160 }
4171 inline CNode* cSLICE( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4172 {
4173  CNode* n = new(heap) CNode( loc, eSLICE );
4174  n->Arg<CNode*>(0) = a0;
4175  n->Arg<CNode*>(1) = a1;
4176  return n;
4177 }
4187 inline CNode* cPSLICE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4188 {
4189  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePSLICE );
4190  n->Arg<CNode*>(0) = a0;
4191  n->Arg<CNode*>(1) = a1;
4192  return n;
4193 }
4204 inline CNode* cPSLICE( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4205 {
4206  CNode* n = new(heap) CNode( loc, ePSLICE );
4207  n->Arg<CNode*>(0) = a0;
4208  n->Arg<CNode*>(1) = a1;
4209  return n;
4210 }
4220 inline CNode* cMSLICE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4221 {
4222  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eMSLICE );
4223  n->Arg<CNode*>(0) = a0;
4224  n->Arg<CNode*>(1) = a1;
4225  return n;
4226 }
4237 inline CNode* cMSLICE( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4238 {
4239  CNode* n = new(heap) CNode( loc, eMSLICE );
4240  n->Arg<CNode*>(0) = a0;
4241  n->Arg<CNode*>(1) = a1;
4242  return n;
4243 }
4252 inline CNode* cCVRI( CNode* a0, Coord_t* loc=NULL )
4253 {
4254  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCVRI );
4255  n->Arg<CNode*>(0) = a0;
4256  return n;
4257 }
4267 inline CNode* cCVRI( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
4268 {
4269  CNode* n = new(heap) CNode( loc, eCVRI );
4270  n->Arg<CNode*>(0) = a0;
4271  return n;
4272 }
4281 inline CNode* cCVIR( CNode* a0, Coord_t* loc=NULL )
4282 {
4283  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCVIR );
4284  n->Arg<CNode*>(0) = a0;
4285  return n;
4286 }
4296 inline CNode* cCVIR( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
4297 {
4298  CNode* n = new(heap) CNode( loc, eCVIR );
4299  n->Arg<CNode*>(0) = a0;
4300  return n;
4301 }
4311 inline CNode* cREP( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4312 {
4313  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eREP );
4314  n->Arg<CNode*>(0) = a0;
4315  n->Arg<CNode*>(1) = a1;
4316  return n;
4317 }
4328 inline CNode* cREP( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4329 {
4330  CNode* n = new(heap) CNode( loc, eREP );
4331  n->Arg<CNode*>(0) = a0;
4332  n->Arg<CNode*>(1) = a1;
4333  return n;
4334 }
4344 inline CNode* cCAT( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4345 {
4346  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCAT );
4347  n->Arg<CNode*>(0) = a0;
4348  n->Arg<CNode*>(1) = a1;
4349  return n;
4350 }
4361 inline CNode* cCAT( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4362 {
4363  CNode* n = new(heap) CNode( loc, eCAT );
4364  n->Arg<CNode*>(0) = a0;
4365  n->Arg<CNode*>(1) = a1;
4366  return n;
4367 }
4376 inline CNode* cUCAT( CNode* a0, Coord_t* loc=NULL )
4377 {
4378  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eUCAT );
4379  n->Arg<CNode*>(0) = a0;
4380  return n;
4381 }
4391 inline CNode* cUCAT( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
4392 {
4393  CNode* n = new(heap) CNode( loc, eUCAT );
4394  n->Arg<CNode*>(0) = a0;
4395  return n;
4396 }
4405 inline CNode* cCOM( CNode* a0, Coord_t* loc=NULL )
4406 {
4407  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCOM );
4408  n->Arg<CNode*>(0) = a0;
4409  return n;
4410 }
4420 inline CNode* cCOM( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
4421 {
4422  CNode* n = new(heap) CNode( loc, eCOM );
4423  n->Arg<CNode*>(0) = a0;
4424  return n;
4425 }
4434 inline CNode* cNEG( CNode* a0, Coord_t* loc=NULL )
4435 {
4436  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eNEG );
4437  n->Arg<CNode*>(0) = a0;
4438  return n;
4439 }
4449 inline CNode* cNEG( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
4450 {
4451  CNode* n = new(heap) CNode( loc, eNEG );
4452  n->Arg<CNode*>(0) = a0;
4453  return n;
4454 }
4463 inline CNode* cPLUS( CNode* a0, Coord_t* loc=NULL )
4464 {
4465  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePLUS );
4466  n->Arg<CNode*>(0) = a0;
4467  return n;
4468 }
4478 inline CNode* cPLUS( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
4479 {
4480  CNode* n = new(heap) CNode( loc, ePLUS );
4481  n->Arg<CNode*>(0) = a0;
4482  return n;
4483 }
4492 inline CNode* cNOT( CNode* a0, Coord_t* loc=NULL )
4493 {
4494  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eNOT );
4495  n->Arg<CNode*>(0) = a0;
4496  return n;
4497 }
4507 inline CNode* cNOT( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
4508 {
4509  CNode* n = new(heap) CNode( loc, eNOT );
4510  n->Arg<CNode*>(0) = a0;
4511  return n;
4512 }
4522 inline CNode* cGT( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4523 {
4524  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eGT );
4525  n->Arg<CNode*>(0) = a0;
4526  n->Arg<CNode*>(1) = a1;
4527  return n;
4528 }
4539 inline CNode* cGT( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4540 {
4541  CNode* n = new(heap) CNode( loc, eGT );
4542  n->Arg<CNode*>(0) = a0;
4543  n->Arg<CNode*>(1) = a1;
4544  return n;
4545 }
4555 inline CNode* cGE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4556 {
4557  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eGE );
4558  n->Arg<CNode*>(0) = a0;
4559  n->Arg<CNode*>(1) = a1;
4560  return n;
4561 }
4572 inline CNode* cGE( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4573 {
4574  CNode* n = new(heap) CNode( loc, eGE );
4575  n->Arg<CNode*>(0) = a0;
4576  n->Arg<CNode*>(1) = a1;
4577  return n;
4578 }
4588 inline CNode* cLT( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4589 {
4590  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eLT );
4591  n->Arg<CNode*>(0) = a0;
4592  n->Arg<CNode*>(1) = a1;
4593  return n;
4594 }
4605 inline CNode* cLT( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4606 {
4607  CNode* n = new(heap) CNode( loc, eLT );
4608  n->Arg<CNode*>(0) = a0;
4609  n->Arg<CNode*>(1) = a1;
4610  return n;
4611 }
4621 inline CNode* cLE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4622 {
4623  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eLE );
4624  n->Arg<CNode*>(0) = a0;
4625  n->Arg<CNode*>(1) = a1;
4626  return n;
4627 }
4638 inline CNode* cLE( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4639 {
4640  CNode* n = new(heap) CNode( loc, eLE );
4641  n->Arg<CNode*>(0) = a0;
4642  n->Arg<CNode*>(1) = a1;
4643  return n;
4644 }
4654 inline CNode* cLAND( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4655 {
4656  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eLAND );
4657  n->Arg<CNode*>(0) = a0;
4658  n->Arg<CNode*>(1) = a1;
4659  return n;
4660 }
4671 inline CNode* cLAND( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4672 {
4673  CNode* n = new(heap) CNode( loc, eLAND );
4674  n->Arg<CNode*>(0) = a0;
4675  n->Arg<CNode*>(1) = a1;
4676  return n;
4677 }
4687 inline CNode* cLOR( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4688 {
4689  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eLOR );
4690  n->Arg<CNode*>(0) = a0;
4691  n->Arg<CNode*>(1) = a1;
4692  return n;
4693 }
4704 inline CNode* cLOR( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4705 {
4706  CNode* n = new(heap) CNode( loc, eLOR );
4707  n->Arg<CNode*>(0) = a0;
4708  n->Arg<CNode*>(1) = a1;
4709  return n;
4710 }
4720 inline CNode* cCEQ( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4721 {
4722  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCEQ );
4723  n->Arg<CNode*>(0) = a0;
4724  n->Arg<CNode*>(1) = a1;
4725  return n;
4726 }
4737 inline CNode* cCEQ( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4738 {
4739  CNode* n = new(heap) CNode( loc, eCEQ );
4740  n->Arg<CNode*>(0) = a0;
4741  n->Arg<CNode*>(1) = a1;
4742  return n;
4743 }
4753 inline CNode* cCNE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4754 {
4755  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCNE );
4756  n->Arg<CNode*>(0) = a0;
4757  n->Arg<CNode*>(1) = a1;
4758  return n;
4759 }
4770 inline CNode* cCNE( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4771 {
4772  CNode* n = new(heap) CNode( loc, eCNE );
4773  n->Arg<CNode*>(0) = a0;
4774  n->Arg<CNode*>(1) = a1;
4775  return n;
4776 }
4786 inline CNode* cEQ( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4787 {
4788  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eEQ );
4789  n->Arg<CNode*>(0) = a0;
4790  n->Arg<CNode*>(1) = a1;
4791  return n;
4792 }
4803 inline CNode* cEQ( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4804 {
4805  CNode* n = new(heap) CNode( loc, eEQ );
4806  n->Arg<CNode*>(0) = a0;
4807  n->Arg<CNode*>(1) = a1;
4808  return n;
4809 }
4819 inline CNode* cNE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4820 {
4821  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eNE );
4822  n->Arg<CNode*>(0) = a0;
4823  n->Arg<CNode*>(1) = a1;
4824  return n;
4825 }
4836 inline CNode* cNE( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4837 {
4838  CNode* n = new(heap) CNode( loc, eNE );
4839  n->Arg<CNode*>(0) = a0;
4840  n->Arg<CNode*>(1) = a1;
4841  return n;
4842 }
4851 inline CNode* cRAND( CNode* a0, Coord_t* loc=NULL )
4852 {
4853  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRAND );
4854  n->Arg<CNode*>(0) = a0;
4855  return n;
4856 }
4866 inline CNode* cRAND( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
4867 {
4868  CNode* n = new(heap) CNode( loc, eRAND );
4869  n->Arg<CNode*>(0) = a0;
4870  return n;
4871 }
4880 inline CNode* cRNAND( CNode* a0, Coord_t* loc=NULL )
4881 {
4882  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRNAND );
4883  n->Arg<CNode*>(0) = a0;
4884  return n;
4885 }
4895 inline CNode* cRNAND( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
4896 {
4897  CNode* n = new(heap) CNode( loc, eRNAND );
4898  n->Arg<CNode*>(0) = a0;
4899  return n;
4900 }
4909 inline CNode* cROR( CNode* a0, Coord_t* loc=NULL )
4910 {
4911  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eROR );
4912  n->Arg<CNode*>(0) = a0;
4913  return n;
4914 }
4924 inline CNode* cROR( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
4925 {
4926  CNode* n = new(heap) CNode( loc, eROR );
4927  n->Arg<CNode*>(0) = a0;
4928  return n;
4929 }
4938 inline CNode* cRNOR( CNode* a0, Coord_t* loc=NULL )
4939 {
4940  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRNOR );
4941  n->Arg<CNode*>(0) = a0;
4942  return n;
4943 }
4953 inline CNode* cRNOR( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
4954 {
4955  CNode* n = new(heap) CNode( loc, eRNOR );
4956  n->Arg<CNode*>(0) = a0;
4957  return n;
4958 }
4967 inline CNode* cRXOR( CNode* a0, Coord_t* loc=NULL )
4968 {
4969  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRXOR );
4970  n->Arg<CNode*>(0) = a0;
4971  return n;
4972 }
4982 inline CNode* cRXOR( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
4983 {
4984  CNode* n = new(heap) CNode( loc, eRXOR );
4985  n->Arg<CNode*>(0) = a0;
4986  return n;
4987 }
4996 inline CNode* cRXNOR( CNode* a0, Coord_t* loc=NULL )
4997 {
4998  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRXNOR );
4999  n->Arg<CNode*>(0) = a0;
5000  return n;
5001 }
5011 inline CNode* cRXNOR( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
5012 {
5013  CNode* n = new(heap) CNode( loc, eRXNOR );
5014  n->Arg<CNode*>(0) = a0;
5015  return n;
5016 }
5027 inline CNode* cHOOK( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5028 {
5029  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eHOOK );
5030  n->Arg<CNode*>(0) = a0;
5031  n->Arg<CNode*>(1) = a1;
5032  n->Arg<CNode*>(2) = a2;
5033  return n;
5034 }
5046 inline CNode* cHOOK( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5047 {
5048  CNode* n = new(heap) CNode( loc, eHOOK );
5049  n->Arg<CNode*>(0) = a0;
5050  n->Arg<CNode*>(1) = a1;
5051  n->Arg<CNode*>(2) = a2;
5052  return n;
5053 }
5062 inline CNode* cINIT( CNode* a0, Coord_t* loc=NULL )
5063 {
5064  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eINIT );
5065  n->Arg<CNode*>(0) = a0;
5066  return n;
5067 }
5077 inline CNode* cINIT( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
5078 {
5079  CNode* n = new(heap) CNode( loc, eINIT );
5080  n->Arg<CNode*>(0) = a0;
5081  return n;
5082 }
5091 inline CNode* cALWAYS( CNode* a0, Coord_t* loc=NULL )
5092 {
5093  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eALWAYS );
5094  n->Arg<CNode*>(0) = a0;
5095  return n;
5096 }
5106 inline CNode* cALWAYS( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
5107 {
5108  CNode* n = new(heap) CNode( loc, eALWAYS );
5109  n->Arg<CNode*>(0) = a0;
5110  return n;
5111 }
5120 inline CNode* cALWAYS_LATCH( CNode* a0, Coord_t* loc=NULL )
5121 {
5122  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eALWAYS_LATCH );
5123  n->Arg<CNode*>(0) = a0;
5124  return n;
5125 }
5135 inline CNode* cALWAYS_LATCH( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
5136 {
5137  CNode* n = new(heap) CNode( loc, eALWAYS_LATCH );
5138  n->Arg<CNode*>(0) = a0;
5139  return n;
5140 }
5149 inline CNode* cALWAYS_FF( CNode* a0, Coord_t* loc=NULL )
5150 {
5151  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eALWAYS_FF );
5152  n->Arg<CNode*>(0) = a0;
5153  return n;
5154 }
5164 inline CNode* cALWAYS_FF( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
5165 {
5166  CNode* n = new(heap) CNode( loc, eALWAYS_FF );
5167  n->Arg<CNode*>(0) = a0;
5168  return n;
5169 }
5178 inline CNode* cALWAYS_COMB( CNode* a0, Coord_t* loc=NULL )
5179 {
5180  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eALWAYS_COMB );
5181  n->Arg<CNode*>(0) = a0;
5182  return n;
5183 }
5193 inline CNode* cALWAYS_COMB( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
5194 {
5195  CNode* n = new(heap) CNode( loc, eALWAYS_COMB );
5196  n->Arg<CNode*>(0) = a0;
5197  return n;
5198 }
5208 inline CNode* cEVENT( CNode* a0, CNode* a1, Coord_t* loc=NULL )
5209 {
5210  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eEVENT );
5211  n->Arg<CNode*>(0) = a0;
5212  n->Arg<CNode*>(1) = a1;
5213  return n;
5214 }
5225 inline CNode* cEVENT( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
5226 {
5227  CNode* n = new(heap) CNode( loc, eEVENT );
5228  n->Arg<CNode*>(0) = a0;
5229  n->Arg<CNode*>(1) = a1;
5230  return n;
5231 }
5242 inline CNode* cBLOCK_REF( CBlock* a0, CNode* a1, bool a2, Coord_t* loc=NULL )
5243 {
5244  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eBLOCK_REF );
5245  n->Arg<CBlock*>(0) = a0;
5246  n->Arg<CNode*>(1) = a1;
5247  n->Arg<bool>(2) = a2;
5248  return n;
5249 }
5261 inline CNode* cBLOCK_REF( CObstack* heap, CBlock* a0, CNode* a1, bool a2, Coord_t* loc=NULL )
5262 {
5263  CNode* n = new(heap) CNode( loc, eBLOCK_REF );
5264  n->Arg<CBlock*>(0) = a0;
5265  n->Arg<CNode*>(1) = a1;
5266  n->Arg<bool>(2) = a2;
5267  return n;
5268 }
5278 inline CNode* cSPECIFY_REF( CSpecify* a0, CNode* a1, Coord_t* loc=NULL )
5279 {
5280  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eSPECIFY_REF );
5281  n->Arg<CSpecify*>(0) = a0;
5282  n->Arg<CNode*>(1) = a1;
5283  return n;
5284 }
5295 inline CNode* cSPECIFY_REF( CObstack* heap, CSpecify* a0, CNode* a1, Coord_t* loc=NULL )
5296 {
5297  CNode* n = new(heap) CNode( loc, eSPECIFY_REF );
5298  n->Arg<CSpecify*>(0) = a0;
5299  n->Arg<CNode*>(1) = a1;
5300  return n;
5301 }
5312 inline CNode* cASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5313 {
5314  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eASSIGN );
5315  n->Arg<CNode*>(0) = a0;
5316  n->Arg<CNode*>(1) = a1;
5317  n->Arg<CNode*>(2) = a2;
5318  return n;
5319 }
5331 inline CNode* cASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5332 {
5333  CNode* n = new(heap) CNode( loc, eASSIGN );
5334  n->Arg<CNode*>(0) = a0;
5335  n->Arg<CNode*>(1) = a1;
5336  n->Arg<CNode*>(2) = a2;
5337  return n;
5338 }
5349 inline CNode* cGASSIGN( bool a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5350 {
5351  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eGASSIGN );
5352  n->Arg<bool>(0) = a0;
5353  n->Arg<CNode*>(1) = a1;
5354  n->Arg<CNode*>(2) = a2;
5355  return n;
5356 }
5368 inline CNode* cGASSIGN( CObstack* heap, bool a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5369 {
5370  CNode* n = new(heap) CNode( loc, eGASSIGN );
5371  n->Arg<bool>(0) = a0;
5372  n->Arg<CNode*>(1) = a1;
5373  n->Arg<CNode*>(2) = a2;
5374  return n;
5375 }
5386 inline CNode* cADD_ASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5387 {
5388  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eADD_ASSIGN );
5389  n->Arg<CNode*>(0) = a0;
5390  n->Arg<CNode*>(1) = a1;
5391  n->Arg<CNode*>(2) = a2;
5392  return n;
5393 }
5405 inline CNode* cADD_ASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5406 {
5407  CNode* n = new(heap) CNode( loc, eADD_ASSIGN );
5408  n->Arg<CNode*>(0) = a0;
5409  n->Arg<CNode*>(1) = a1;
5410  n->Arg<CNode*>(2) = a2;
5411  return n;
5412 }
5423 inline CNode* cSUB_ASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5424 {
5425  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eSUB_ASSIGN );
5426  n->Arg<CNode*>(0) = a0;
5427  n->Arg<CNode*>(1) = a1;
5428  n->Arg<CNode*>(2) = a2;
5429  return n;
5430 }
5442 inline CNode* cSUB_ASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5443 {
5444  CNode* n = new(heap) CNode( loc, eSUB_ASSIGN );
5445  n->Arg<CNode*>(0) = a0;
5446  n->Arg<CNode*>(1) = a1;
5447  n->Arg<CNode*>(2) = a2;
5448  return n;
5449 }
5460 inline CNode* cMUL_ASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5461 {
5462  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eMUL_ASSIGN );
5463  n->Arg<CNode*>(0) = a0;
5464  n->Arg<CNode*>(1) = a1;
5465  n->Arg<CNode*>(2) = a2;
5466  return n;
5467 }
5479 inline CNode* cMUL_ASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5480 {
5481  CNode* n = new(heap) CNode( loc, eMUL_ASSIGN );
5482  n->Arg<CNode*>(0) = a0;
5483  n->Arg<CNode*>(1) = a1;
5484  n->Arg<CNode*>(2) = a2;
5485  return n;
5486 }
5497 inline CNode* cDIV_ASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5498 {
5499  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eDIV_ASSIGN );
5500  n->Arg<CNode*>(0) = a0;
5501  n->Arg<CNode*>(1) = a1;
5502  n->Arg<CNode*>(2) = a2;
5503  return n;
5504 }
5516 inline CNode* cDIV_ASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5517 {
5518  CNode* n = new(heap) CNode( loc, eDIV_ASSIGN );
5519  n->Arg<CNode*>(0) = a0;
5520  n->Arg<CNode*>(1) = a1;
5521  n->Arg<CNode*>(2) = a2;
5522  return n;
5523 }
5534 inline CNode* cMOD_ASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5535 {
5536  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eMOD_ASSIGN );
5537  n->Arg<CNode*>(0) = a0;
5538  n->Arg<CNode*>(1) = a1;
5539  n->Arg<CNode*>(2) = a2;
5540  return n;
5541 }
5553 inline CNode* cMOD_ASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5554 {
5555  CNode* n = new(heap) CNode( loc, eMOD_ASSIGN );
5556  n->Arg<CNode*>(0) = a0;
5557  n->Arg<CNode*>(1) = a1;
5558  n->Arg<CNode*>(2) = a2;
5559  return n;
5560 }
5571 inline CNode* cAND_ASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5572 {
5573  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eAND_ASSIGN );
5574  n->Arg<CNode*>(0) = a0;
5575  n->Arg<CNode*>(1) = a1;
5576  n->Arg<CNode*>(2) = a2;
5577  return n;
5578 }
5590 inline CNode* cAND_ASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5591 {
5592  CNode* n = new(heap) CNode( loc, eAND_ASSIGN );
5593  n->Arg<CNode*>(0) = a0;
5594  n->Arg<CNode*>(1) = a1;
5595  n->Arg<CNode*>(2) = a2;
5596  return n;
5597 }
5608 inline CNode* cOR_ASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5609 {
5610  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eOR_ASSIGN );
5611  n->Arg<CNode*>(0) = a0;
5612  n->Arg<CNode*>(1) = a1;
5613  n->Arg<CNode*>(2) = a2;
5614  return n;
5615 }
5627 inline CNode* cOR_ASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5628 {
5629  CNode* n = new(heap) CNode( loc, eOR_ASSIGN );
5630  n->Arg<CNode*>(0) = a0;
5631  n->Arg<CNode*>(1) = a1;
5632  n->Arg<CNode*>(2) = a2;
5633  return n;
5634 }
5645 inline CNode* cXOR_ASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5646 {
5647  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eXOR_ASSIGN );
5648  n->Arg<CNode*>(0) = a0;
5649  n->Arg<CNode*>(1) = a1;
5650  n->Arg<CNode*>(2) = a2;
5651  return n;
5652 }
5664 inline CNode* cXOR_ASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5665 {
5666  CNode* n = new(heap) CNode( loc, eXOR_ASSIGN );
5667  n->Arg<CNode*>(0) = a0;
5668  n->Arg<CNode*>(1) = a1;
5669  n->Arg<CNode*>(2) = a2;
5670  return n;
5671 }
5682 inline CNode* cLSH_ASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5683 {
5684  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eLSH_ASSIGN );
5685  n->Arg<CNode*>(0) = a0;
5686  n->Arg<CNode*>(1) = a1;
5687  n->Arg<CNode*>(2) = a2;
5688  return n;
5689 }
5701 inline CNode* cLSH_ASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5702 {
5703  CNode* n = new(heap) CNode( loc, eLSH_ASSIGN );
5704  n->Arg<CNode*>(0) = a0;
5705  n->Arg<CNode*>(1) = a1;
5706  n->Arg<CNode*>(2) = a2;
5707  return n;
5708 }
5719 inline CNode* cRSH_ASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5720 {
5721  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRSH_ASSIGN );
5722  n->Arg<CNode*>(0) = a0;
5723  n->Arg<CNode*>(1) = a1;
5724  n->Arg<CNode*>(2) = a2;
5725  return n;
5726 }
5738 inline CNode* cRSH_ASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5739 {
5740  CNode* n = new(heap) CNode( loc, eRSH_ASSIGN );
5741  n->Arg<CNode*>(0) = a0;
5742  n->Arg<CNode*>(1) = a1;
5743  n->Arg<CNode*>(2) = a2;
5744  return n;
5745 }
5756 inline CNode* cLSHA_ASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5757 {
5758  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eLSHA_ASSIGN );
5759  n->Arg<CNode*>(0) = a0;
5760  n->Arg<CNode*>(1) = a1;
5761  n->Arg<CNode*>(2) = a2;
5762  return n;
5763 }
5775 inline CNode* cLSHA_ASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5776 {
5777  CNode* n = new(heap) CNode( loc, eLSHA_ASSIGN );
5778  n->Arg<CNode*>(0) = a0;
5779  n->Arg<CNode*>(1) = a1;
5780  n->Arg<CNode*>(2) = a2;
5781  return n;
5782 }
5793 inline CNode* cRSHA_ASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5794 {
5795  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRSHA_ASSIGN );
5796  n->Arg<CNode*>(0) = a0;
5797  n->Arg<CNode*>(1) = a1;
5798  n->Arg<CNode*>(2) = a2;
5799  return n;
5800 }
5812 inline CNode* cRSHA_ASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5813 {
5814  CNode* n = new(heap) CNode( loc, eRSHA_ASSIGN );
5815  n->Arg<CNode*>(0) = a0;
5816  n->Arg<CNode*>(1) = a1;
5817  n->Arg<CNode*>(2) = a2;
5818  return n;
5819 }
5829 inline CNode* cFORCE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
5830 {
5831  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eFORCE );
5832  n->Arg<CNode*>(0) = a0;
5833  n->Arg<CNode*>(1) = a1;
5834  return n;
5835 }
5846 inline CNode* cFORCE( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
5847 {
5848  CNode* n = new(heap) CNode( loc, eFORCE );
5849  n->Arg<CNode*>(0) = a0;
5850  n->Arg<CNode*>(1) = a1;
5851  return n;
5852 }
5861 inline CNode* cRELEASE( CNode* a0, Coord_t* loc=NULL )
5862 {
5863  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRELEASE );
5864  n->Arg<CNode*>(0) = a0;
5865  return n;
5866 }
5876 inline CNode* cRELEASE( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
5877 {
5878  CNode* n = new(heap) CNode( loc, eRELEASE );
5879  n->Arg<CNode*>(0) = a0;
5880  return n;
5881 }
5892 inline CNode* cNBASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5893 {
5894  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eNBASSIGN );
5895  n->Arg<CNode*>(0) = a0;
5896  n->Arg<CNode*>(1) = a1;
5897  n->Arg<CNode*>(2) = a2;
5898  return n;
5899 }
5911 inline CNode* cNBASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5912 {
5913  CNode* n = new(heap) CNode( loc, eNBASSIGN );
5914  n->Arg<CNode*>(0) = a0;
5915  n->Arg<CNode*>(1) = a1;
5916  n->Arg<CNode*>(2) = a2;
5917  return n;
5918 }
5927 inline CNode* cPOSEDGE( CNode* a0, Coord_t* loc=NULL )
5928 {
5929  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePOSEDGE );
5930  n->Arg<CNode*>(0) = a0;
5931  return n;
5932 }
5942 inline CNode* cPOSEDGE( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
5943 {
5944  CNode* n = new(heap) CNode( loc, ePOSEDGE );
5945  n->Arg<CNode*>(0) = a0;
5946  return n;
5947 }
5956 inline CNode* cNEGEDGE( CNode* a0, Coord_t* loc=NULL )
5957 {
5958  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eNEGEDGE );
5959  n->Arg<CNode*>(0) = a0;
5960  return n;
5961 }
5971 inline CNode* cNEGEDGE( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
5972 {
5973  CNode* n = new(heap) CNode( loc, eNEGEDGE );
5974  n->Arg<CNode*>(0) = a0;
5975  return n;
5976 }
5986 inline CNode* cEDGE( CNode* a0, Edge_t a1, Coord_t* loc=NULL )
5987 {
5988  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eEDGE );
5989  n->Arg<CNode*>(0) = a0;
5990  n->Arg<Edge_t>(1) = a1;
5991  return n;
5992 }
6003 inline CNode* cEDGE( CObstack* heap, CNode* a0, Edge_t a1, Coord_t* loc=NULL )
6004 {
6005  CNode* n = new(heap) CNode( loc, eEDGE );
6006  n->Arg<CNode*>(0) = a0;
6007  n->Arg<Edge_t>(1) = a1;
6008  return n;
6009 }
6019 inline CNode* cEVOR( CNode* a0, CNode* a1, Coord_t* loc=NULL )
6020 {
6021  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eEVOR );
6022  n->Arg<CNode*>(0) = a0;
6023  n->Arg<CNode*>(1) = a1;
6024  return n;
6025 }
6036 inline CNode* cEVOR( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
6037 {
6038  CNode* n = new(heap) CNode( loc, eEVOR );
6039  n->Arg<CNode*>(0) = a0;
6040  n->Arg<CNode*>(1) = a1;
6041  return n;
6042 }
6052 inline CNode* cDELAY( CNode* a0, CNode* a1, Coord_t* loc=NULL )
6053 {
6054  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eDELAY );
6055  n->Arg<CNode*>(0) = a0;
6056  n->Arg<CNode*>(1) = a1;
6057  return n;
6058 }
6069 inline CNode* cDELAY( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
6070 {
6071  CNode* n = new(heap) CNode( loc, eDELAY );
6072  n->Arg<CNode*>(0) = a0;
6073  n->Arg<CNode*>(1) = a1;
6074  return n;
6075 }
6086 inline CNode* cMTM( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
6087 {
6088  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eMTM );
6089  n->Arg<CNode*>(0) = a0;
6090  n->Arg<CNode*>(1) = a1;
6091  n->Arg<CNode*>(2) = a2;
6092  return n;
6093 }
6105 inline CNode* cMTM( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
6106 {
6107  CNode* n = new(heap) CNode( loc, eMTM );
6108  n->Arg<CNode*>(0) = a0;
6109  n->Arg<CNode*>(1) = a1;
6110  n->Arg<CNode*>(2) = a2;
6111  return n;
6112 }
6124 inline CNode* cIF( CNode* a0, CNode* a1, CNode* a2, ConditionalType a3, Coord_t* loc=NULL )
6125 {
6126  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eIF );
6127  n->Arg<CNode*>(0) = a0;
6128  n->Arg<CNode*>(1) = a1;
6129  n->Arg<CNode*>(2) = a2;
6130  n->Arg<ConditionalType>(3) = a3;
6131  return n;
6132 }
6145 inline CNode* cIF( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, ConditionalType a3, Coord_t* loc=NULL )
6146 {
6147  CNode* n = new(heap) CNode( loc, eIF );
6148  n->Arg<CNode*>(0) = a0;
6149  n->Arg<CNode*>(1) = a1;
6150  n->Arg<CNode*>(2) = a2;
6151  n->Arg<ConditionalType>(3) = a3;
6152  return n;
6153 }
6162 inline CNode* cFOREVER( CNode* a0, Coord_t* loc=NULL )
6163 {
6164  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eFOREVER );
6165  n->Arg<CNode*>(0) = a0;
6166  return n;
6167 }
6177 inline CNode* cFOREVER( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
6178 {
6179  CNode* n = new(heap) CNode( loc, eFOREVER );
6180  n->Arg<CNode*>(0) = a0;
6181  return n;
6182 }
6192 inline CNode* cREPEAT( CNode* a0, CNode* a1, Coord_t* loc=NULL )
6193 {
6194  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eREPEAT );
6195  n->Arg<CNode*>(0) = a0;
6196  n->Arg<CNode*>(1) = a1;
6197  return n;
6198 }
6209 inline CNode* cREPEAT( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
6210 {
6211  CNode* n = new(heap) CNode( loc, eREPEAT );
6212  n->Arg<CNode*>(0) = a0;
6213  n->Arg<CNode*>(1) = a1;
6214  return n;
6215 }
6225 inline CNode* cWHILE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
6226 {
6227  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eWHILE );
6228  n->Arg<CNode*>(0) = a0;
6229  n->Arg<CNode*>(1) = a1;
6230  return n;
6231 }
6242 inline CNode* cWHILE( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
6243 {
6244  CNode* n = new(heap) CNode( loc, eWHILE );
6245  n->Arg<CNode*>(0) = a0;
6246  n->Arg<CNode*>(1) = a1;
6247  return n;
6248 }
6258 inline CNode* cWAIT( CNode* a0, CNode* a1, Coord_t* loc=NULL )
6259 {
6260  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eWAIT );
6261  n->Arg<CNode*>(0) = a0;
6262  n->Arg<CNode*>(1) = a1;
6263  return n;
6264 }
6275 inline CNode* cWAIT( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
6276 {
6277  CNode* n = new(heap) CNode( loc, eWAIT );
6278  n->Arg<CNode*>(0) = a0;
6279  n->Arg<CNode*>(1) = a1;
6280  return n;
6281 }
6293 inline CNode* cFOR( CNode* a0, CNode* a1, CNode* a2, CNode* a3, Coord_t* loc=NULL )
6294 {
6295  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eFOR );
6296  n->Arg<CNode*>(0) = a0;
6297  n->Arg<CNode*>(1) = a1;
6298  n->Arg<CNode*>(2) = a2;
6299  n->Arg<CNode*>(3) = a3;
6300  return n;
6301 }
6314 inline CNode* cFOR( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, CNode* a3, Coord_t* loc=NULL )
6315 {
6316  CNode* n = new(heap) CNode( loc, eFOR );
6317  n->Arg<CNode*>(0) = a0;
6318  n->Arg<CNode*>(1) = a1;
6319  n->Arg<CNode*>(2) = a2;
6320  n->Arg<CNode*>(3) = a3;
6321  return n;
6322 }
6333 inline CNode* cCASE( CNode* a0, CNode* a1, ConditionalType a2, Coord_t* loc=NULL )
6334 {
6335  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCASE );
6336  n->Arg<CNode*>(0) = a0;
6337  n->Arg<CNode*>(1) = a1;
6338  n->Arg<ConditionalType>(2) = a2;
6339  return n;
6340 }
6352 inline CNode* cCASE( CObstack* heap, CNode* a0, CNode* a1, ConditionalType a2, Coord_t* loc=NULL )
6353 {
6354  CNode* n = new(heap) CNode( loc, eCASE );
6355  n->Arg<CNode*>(0) = a0;
6356  n->Arg<CNode*>(1) = a1;
6357  n->Arg<ConditionalType>(2) = a2;
6358  return n;
6359 }
6370 inline CNode* cCASEX( CNode* a0, CNode* a1, ConditionalType a2, Coord_t* loc=NULL )
6371 {
6372  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCASEX );
6373  n->Arg<CNode*>(0) = a0;
6374  n->Arg<CNode*>(1) = a1;
6375  n->Arg<ConditionalType>(2) = a2;
6376  return n;
6377 }
6389 inline CNode* cCASEX( CObstack* heap, CNode* a0, CNode* a1, ConditionalType a2, Coord_t* loc=NULL )
6390 {
6391  CNode* n = new(heap) CNode( loc, eCASEX );
6392  n->Arg<CNode*>(0) = a0;
6393  n->Arg<CNode*>(1) = a1;
6394  n->Arg<ConditionalType>(2) = a2;
6395  return n;
6396 }
6407 inline CNode* cCASEZ( CNode* a0, CNode* a1, ConditionalType a2, Coord_t* loc=NULL )
6408 {
6409  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCASEZ );
6410  n->Arg<CNode*>(0) = a0;
6411  n->Arg<CNode*>(1) = a1;
6412  n->Arg<ConditionalType>(2) = a2;
6413  return n;
6414 }
6426 inline CNode* cCASEZ( CObstack* heap, CNode* a0, CNode* a1, ConditionalType a2, Coord_t* loc=NULL )
6427 {
6428  CNode* n = new(heap) CNode( loc, eCASEZ );
6429  n->Arg<CNode*>(0) = a0;
6430  n->Arg<CNode*>(1) = a1;
6431  n->Arg<ConditionalType>(2) = a2;
6432  return n;
6433 }
6443 inline CNode* cCASEITEM( CNode* a0, CNode* a1, Coord_t* loc=NULL )
6444 {
6445  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCASEITEM );
6446  n->Arg<CNode*>(0) = a0;
6447  n->Arg<CNode*>(1) = a1;
6448  return n;
6449 }
6460 inline CNode* cCASEITEM( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
6461 {
6462  CNode* n = new(heap) CNode( loc, eCASEITEM );
6463  n->Arg<CNode*>(0) = a0;
6464  n->Arg<CNode*>(1) = a1;
6465  return n;
6466 }
6478 inline CNode* cCASSIGN( StrengthPair_t* a0, CNode* a1, CNode* a2, CNode* a3, Coord_t* loc=NULL )
6479 {
6480  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCASSIGN );
6481  n->Arg<StrengthPair_t*>(0) = a0;
6482  n->Arg<CNode*>(1) = a1;
6483  n->Arg<CNode*>(2) = a2;
6484  n->Arg<CNode*>(3) = a3;
6485  return n;
6486 }
6499 inline CNode* cCASSIGN( CObstack* heap, StrengthPair_t* a0, CNode* a1, CNode* a2, CNode* a3, Coord_t* loc=NULL )
6500 {
6501  CNode* n = new(heap) CNode( loc, eCASSIGN );
6502  n->Arg<StrengthPair_t*>(0) = a0;
6503  n->Arg<CNode*>(1) = a1;
6504  n->Arg<CNode*>(2) = a2;
6505  n->Arg<CNode*>(3) = a3;
6506  return n;
6507 }
6517 inline CNode* cARG( CSymbol* a0, CNode* a1, Coord_t* loc=NULL )
6518 {
6519  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eARG );
6520  n->Arg<CSymbol*>(0) = a0;
6521  n->Arg<CNode*>(1) = a1;
6522  return n;
6523 }
6534 inline CNode* cARG( CObstack* heap, CSymbol* a0, CNode* a1, Coord_t* loc=NULL )
6535 {
6536  CNode* n = new(heap) CNode( loc, eARG );
6537  n->Arg<CSymbol*>(0) = a0;
6538  n->Arg<CNode*>(1) = a1;
6539  return n;
6540 }
6549 inline CNode* cIMPORT( CSymbol* a0, Coord_t* loc=NULL )
6550 {
6551  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eIMPORT );
6552  n->Arg<CSymbol*>(0) = a0;
6553  return n;
6554 }
6564 inline CNode* cIMPORT( CObstack* heap, CSymbol* a0, Coord_t* loc=NULL )
6565 {
6566  CNode* n = new(heap) CNode( loc, eIMPORT );
6567  n->Arg<CSymbol*>(0) = a0;
6568  return n;
6569 }
6578 inline CNode* cFUNCTION_DEF( CFunction* a0, Coord_t* loc=NULL )
6579 {
6580  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eFUNCTION_DEF );
6581  n->Arg<CFunction*>(0) = a0;
6582  return n;
6583 }
6593 inline CNode* cFUNCTION_DEF( CObstack* heap, CFunction* a0, Coord_t* loc=NULL )
6594 {
6595  CNode* n = new(heap) CNode( loc, eFUNCTION_DEF );
6596  n->Arg<CFunction*>(0) = a0;
6597  return n;
6598 }
6607 inline CNode* cMODULE_DEF( CModule* a0, Coord_t* loc=NULL )
6608 {
6609  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eMODULE_DEF );
6610  n->Arg<CModule*>(0) = a0;
6611  return n;
6612 }
6622 inline CNode* cMODULE_DEF( CObstack* heap, CModule* a0, Coord_t* loc=NULL )
6623 {
6624  CNode* n = new(heap) CNode( loc, eMODULE_DEF );
6625  n->Arg<CModule*>(0) = a0;
6626  return n;
6627 }
6636 inline CNode* cPACKAGE_DEF( CPackage* a0, Coord_t* loc=NULL )
6637 {
6638  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePACKAGE_DEF );
6639  n->Arg<CPackage*>(0) = a0;
6640  return n;
6641 }
6651 inline CNode* cPACKAGE_DEF( CObstack* heap, CPackage* a0, Coord_t* loc=NULL )
6652 {
6653  CNode* n = new(heap) CNode( loc, ePACKAGE_DEF );
6654  n->Arg<CPackage*>(0) = a0;
6655  return n;
6656 }
6666 inline CNode* cREPEAT_CONTROL( CNode* a0, CNode* a1, Coord_t* loc=NULL )
6667 {
6668  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eREPEAT_CONTROL );
6669  n->Arg<CNode*>(0) = a0;
6670  n->Arg<CNode*>(1) = a1;
6671  return n;
6672 }
6683 inline CNode* cREPEAT_CONTROL( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
6684 {
6685  CNode* n = new(heap) CNode( loc, eREPEAT_CONTROL );
6686  n->Arg<CNode*>(0) = a0;
6687  n->Arg<CNode*>(1) = a1;
6688  return n;
6689 }
6698 inline CNode* cDELAY_CONTROL( CNode* a0, Coord_t* loc=NULL )
6699 {
6700  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eDELAY_CONTROL );
6701  n->Arg<CNode*>(0) = a0;
6702  return n;
6703 }
6713 inline CNode* cDELAY_CONTROL( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
6714 {
6715  CNode* n = new(heap) CNode( loc, eDELAY_CONTROL );
6716  n->Arg<CNode*>(0) = a0;
6717  return n;
6718 }
6727 inline CNode* cEVENT_CONTROL( CNode* a0, Coord_t* loc=NULL )
6728 {
6729  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eEVENT_CONTROL );
6730  n->Arg<CNode*>(0) = a0;
6731  return n;
6732 }
6742 inline CNode* cEVENT_CONTROL( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
6743 {
6744  CNode* n = new(heap) CNode( loc, eEVENT_CONTROL );
6745  n->Arg<CNode*>(0) = a0;
6746  return n;
6747 }
6756 inline CNode* cEXTERNAL_REF( CSymbol* a0, Coord_t* loc=NULL )
6757 {
6758  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eEXTERNAL_REF );
6759  n->Arg<CSymbol*>(0) = a0;
6760  return n;
6761 }
6771 inline CNode* cEXTERNAL_REF( CObstack* heap, CSymbol* a0, Coord_t* loc=NULL )
6772 {
6773  CNode* n = new(heap) CNode( loc, eEXTERNAL_REF );
6774  n->Arg<CSymbol*>(0) = a0;
6775  return n;
6776 }
6785 inline CNode* cPORT_DEF( CPort* a0, Coord_t* loc=NULL )
6786 {
6787  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePORT_DEF );
6788  n->Arg<CPort*>(0) = a0;
6789  return n;
6790 }
6800 inline CNode* cPORT_DEF( CObstack* heap, CPort* a0, Coord_t* loc=NULL )
6801 {
6802  CNode* n = new(heap) CNode( loc, ePORT_DEF );
6803  n->Arg<CPort*>(0) = a0;
6804  return n;
6805 }
6815 inline CNode* cDEFPARAM( CNode* a0, CNode* a1, Coord_t* loc=NULL )
6816 {
6817  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eDEFPARAM );
6818  n->Arg<CNode*>(0) = a0;
6819  n->Arg<CNode*>(1) = a1;
6820  return n;
6821 }
6832 inline CNode* cDEFPARAM( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
6833 {
6834  CNode* n = new(heap) CNode( loc, eDEFPARAM );
6835  n->Arg<CNode*>(0) = a0;
6836  n->Arg<CNode*>(1) = a1;
6837  return n;
6838 }
6853 inline CNode* cPATH( int a0, CNode* a1, int a2, int a3, CNode* a4, int a5, CNode* a6, Coord_t* loc=NULL )
6854 {
6855  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePATH );
6856  n->Arg<int>(0) = a0;
6857  n->Arg<CNode*>(1) = a1;
6858  n->Arg<int>(2) = a2;
6859  n->Arg<int>(3) = a3;
6860  n->Arg<CNode*>(4) = a4;
6861  n->Arg<int>(5) = a5;
6862  n->Arg<CNode*>(6) = a6;
6863  return n;
6864 }
6880 inline CNode* cPATH( CObstack* heap, int a0, CNode* a1, int a2, int a3, CNode* a4, int a5, CNode* a6, Coord_t* loc=NULL )
6881 {
6882  CNode* n = new(heap) CNode( loc, ePATH );
6883  n->Arg<int>(0) = a0;
6884  n->Arg<CNode*>(1) = a1;
6885  n->Arg<int>(2) = a2;
6886  n->Arg<int>(3) = a3;
6887  n->Arg<CNode*>(4) = a4;
6888  n->Arg<int>(5) = a5;
6889  n->Arg<CNode*>(6) = a6;
6890  return n;
6891 }
6902 inline CNode* cPATH_ASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
6903 {
6904  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePATH_ASSIGN );
6905  n->Arg<CNode*>(0) = a0;
6906  n->Arg<CNode*>(1) = a1;
6907  n->Arg<CNode*>(2) = a2;
6908  return n;
6909 }
6921 inline CNode* cPATH_ASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
6922 {
6923  CNode* n = new(heap) CNode( loc, ePATH_ASSIGN );
6924  n->Arg<CNode*>(0) = a0;
6925  n->Arg<CNode*>(1) = a1;
6926  n->Arg<CNode*>(2) = a2;
6927  return n;
6928 }
6938 inline CNode* cIFNONE_PATH_ASSIGN( CNode* a0, CNode* a1, Coord_t* loc=NULL )
6939 {
6940  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eIFNONE_PATH_ASSIGN );
6941  n->Arg<CNode*>(0) = a0;
6942  n->Arg<CNode*>(1) = a1;
6943  return n;
6944 }
6955 inline CNode* cIFNONE_PATH_ASSIGN( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
6956 {
6957  CNode* n = new(heap) CNode( loc, eIFNONE_PATH_ASSIGN );
6958  n->Arg<CNode*>(0) = a0;
6959  n->Arg<CNode*>(1) = a1;
6960  return n;
6961 }
6970 inline CNode* cTRIGGER( CNode* a0, Coord_t* loc=NULL )
6971 {
6972  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eTRIGGER );
6973  n->Arg<CNode*>(0) = a0;
6974  return n;
6975 }
6985 inline CNode* cTRIGGER( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
6986 {
6987  CNode* n = new(heap) CNode( loc, eTRIGGER );
6988  n->Arg<CNode*>(0) = a0;
6989  return n;
6990 }
7000 inline CNode* cPASSIGN( CNode* a0, CNode* a1, Coord_t* loc=NULL )
7001 {
7002  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePASSIGN );
7003  n->Arg<CNode*>(0) = a0;
7004  n->Arg<CNode*>(1) = a1;
7005  return n;
7006 }
7017 inline CNode* cPASSIGN( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
7018 {
7019  CNode* n = new(heap) CNode( loc, ePASSIGN );
7020  n->Arg<CNode*>(0) = a0;
7021  n->Arg<CNode*>(1) = a1;
7022  return n;
7023 }
7032 inline CNode* cDEASSIGN( CNode* a0, Coord_t* loc=NULL )
7033 {
7034  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eDEASSIGN );
7035  n->Arg<CNode*>(0) = a0;
7036  return n;
7037 }
7047 inline CNode* cDEASSIGN( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
7048 {
7049  CNode* n = new(heap) CNode( loc, eDEASSIGN );
7050  n->Arg<CNode*>(0) = a0;
7051  return n;
7052 }
7061 inline CNode* cDISABLE( CSymbol* a0, Coord_t* loc=NULL )
7062 {
7063  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eDISABLE );
7064  n->Arg<CSymbol*>(0) = a0;
7065  return n;
7066 }
7076 inline CNode* cDISABLE( CObstack* heap, CSymbol* a0, Coord_t* loc=NULL )
7077 {
7078  CNode* n = new(heap) CNode( loc, eDISABLE );
7079  n->Arg<CSymbol*>(0) = a0;
7080  return n;
7081 }
7090 inline CNode* cATTRIBUTE( CAttr* a0, Coord_t* loc=NULL )
7091 {
7092  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eATTRIBUTE );
7093  n->Arg<CAttr*>(0) = a0;
7094  return n;
7095 }
7105 inline CNode* cATTRIBUTE( CObstack* heap, CAttr* a0, Coord_t* loc=NULL )
7106 {
7107  CNode* n = new(heap) CNode( loc, eATTRIBUTE );
7108  n->Arg<CAttr*>(0) = a0;
7109  return n;
7110 }
7121 inline CNode* cGIF( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
7122 {
7123  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eGIF );
7124  n->Arg<CNode*>(0) = a0;
7125  n->Arg<CNode*>(1) = a1;
7126  n->Arg<CNode*>(2) = a2;
7127  return n;
7128 }
7140 inline CNode* cGIF( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
7141 {
7142  CNode* n = new(heap) CNode( loc, eGIF );
7143  n->Arg<CNode*>(0) = a0;
7144  n->Arg<CNode*>(1) = a1;
7145  n->Arg<CNode*>(2) = a2;
7146  return n;
7147 }
7159 inline CNode* cGFOR( CNode* a0, CNode* a1, CNode* a2, CNode* a3, Coord_t* loc=NULL )
7160 {
7161  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eGFOR );
7162  n->Arg<CNode*>(0) = a0;
7163  n->Arg<CNode*>(1) = a1;
7164  n->Arg<CNode*>(2) = a2;
7165  n->Arg<CNode*>(3) = a3;
7166  return n;
7167 }
7180 inline CNode* cGFOR( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, CNode* a3, Coord_t* loc=NULL )
7181 {
7182  CNode* n = new(heap) CNode( loc, eGFOR );
7183  n->Arg<CNode*>(0) = a0;
7184  n->Arg<CNode*>(1) = a1;
7185  n->Arg<CNode*>(2) = a2;
7186  n->Arg<CNode*>(3) = a3;
7187  return n;
7188 }
7198 inline CNode* cGCASE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
7199 {
7200  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eGCASE );
7201  n->Arg<CNode*>(0) = a0;
7202  n->Arg<CNode*>(1) = a1;
7203  return n;
7204 }
7215 inline CNode* cGCASE( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
7216 {
7217  CNode* n = new(heap) CNode( loc, eGCASE );
7218  n->Arg<CNode*>(0) = a0;
7219  n->Arg<CNode*>(1) = a1;
7220  return n;
7221 }
7230 inline CNode* cTABLE( CNode* a0, Coord_t* loc=NULL )
7231 {
7232  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eTABLE );
7233  n->Arg<CNode*>(0) = a0;
7234  return n;
7235 }
7245 inline CNode* cTABLE( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
7246 {
7247  CNode* n = new(heap) CNode( loc, eTABLE );
7248  n->Arg<CNode*>(0) = a0;
7249  return n;
7250 }
7259 inline CNode* cTABLE_ENTRY( CNode* a0, Coord_t* loc=NULL )
7260 {
7261  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eTABLE_ENTRY );
7262  n->Arg<CNode*>(0) = a0;
7263  return n;
7264 }
7274 inline CNode* cTABLE_ENTRY( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
7275 {
7276  CNode* n = new(heap) CNode( loc, eTABLE_ENTRY );
7277  n->Arg<CNode*>(0) = a0;
7278  return n;
7279 }
7288 inline CNode* cTABLE_SYMBOL( char* a0, Coord_t* loc=NULL )
7289 {
7290  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eTABLE_SYMBOL );
7291  n->Arg<char*>(0) = a0;
7292  return n;
7293 }
7303 inline CNode* cTABLE_SYMBOL( CObstack* heap, char* a0, Coord_t* loc=NULL )
7304 {
7305  CNode* n = new(heap) CNode( loc, eTABLE_SYMBOL );
7306  n->Arg<char*>(0) = a0;
7307  return n;
7308 }
7316 inline CNode* cPORTLIST_END( Coord_t* loc=NULL )
7317 {
7318  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePORTLIST_END );
7319  return n;
7320 }
7329 inline CNode* cPORTLIST_END( CObstack* heap, Coord_t* loc=NULL )
7330 {
7331  CNode* n = new(heap) CNode( loc, ePORTLIST_END );
7332  return n;
7333 }
7343 inline CNode* cMACRO_EXPR( const char* a0, CNode* a1, Coord_t* loc=NULL )
7344 {
7345  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eMACRO_EXPR );
7346  n->Arg<const char*>(0) = a0;
7347  n->Arg<CNode*>(1) = a1;
7348  return n;
7349 }
7360 inline CNode* cMACRO_EXPR( CObstack* heap, const char* a0, CNode* a1, Coord_t* loc=NULL )
7361 {
7362  CNode* n = new(heap) CNode( loc, eMACRO_EXPR );
7363  n->Arg<const char*>(0) = a0;
7364  n->Arg<CNode*>(1) = a1;
7365  return n;
7366 }
7377 inline CNode* cENUM_SPEC( CSymbol* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
7378 {
7379  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eENUM_SPEC );
7380  n->Arg<CSymbol*>(0) = a0;
7381  n->Arg<CNode*>(1) = a1;
7382  n->Arg<CNode*>(2) = a2;
7383  return n;
7384 }
7396 inline CNode* cENUM_SPEC( CObstack* heap, CSymbol* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
7397 {
7398  CNode* n = new(heap) CNode( loc, eENUM_SPEC );
7399  n->Arg<CSymbol*>(0) = a0;
7400  n->Arg<CNode*>(1) = a1;
7401  n->Arg<CNode*>(2) = a2;
7402  return n;
7403 }
7413 inline CNode* cMEMBER( CNode* a0, CSymbol* a1, Coord_t* loc=NULL )
7414 {
7415  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eMEMBER );
7416  n->Arg<CNode*>(0) = a0;
7417  n->Arg<CSymbol*>(1) = a1;
7418  return n;
7419 }
7430 inline CNode* cMEMBER( CObstack* heap, CNode* a0, CSymbol* a1, Coord_t* loc=NULL )
7431 {
7432  CNode* n = new(heap) CNode( loc, eMEMBER );
7433  n->Arg<CNode*>(0) = a0;
7434  n->Arg<CSymbol*>(1) = a1;
7435  return n;
7436 }
7445 inline CNode* cRETURN( CNode* a0, Coord_t* loc=NULL )
7446 {
7447  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRETURN );
7448  n->Arg<CNode*>(0) = a0;
7449  return n;
7450 }
7460 inline CNode* cRETURN( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
7461 {
7462  CNode* n = new(heap) CNode( loc, eRETURN );
7463  n->Arg<CNode*>(0) = a0;
7464  return n;
7465 }
7474 inline CNode* cPREINC( CNode* a0, Coord_t* loc=NULL )
7475 {
7476  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePREINC );
7477  n->Arg<CNode*>(0) = a0;
7478  return n;
7479 }
7489 inline CNode* cPREINC( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
7490 {
7491  CNode* n = new(heap) CNode( loc, ePREINC );
7492  n->Arg<CNode*>(0) = a0;
7493  return n;
7494 }
7503 inline CNode* cPOSTINC( CNode* a0, Coord_t* loc=NULL )
7504 {
7505  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePOSTINC );
7506  n->Arg<CNode*>(0) = a0;
7507  return n;
7508 }
7518 inline CNode* cPOSTINC( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
7519 {
7520  CNode* n = new(heap) CNode( loc, ePOSTINC );
7521  n->Arg<CNode*>(0) = a0;
7522  return n;
7523 }
7532 inline CNode* cPREDEC( CNode* a0, Coord_t* loc=NULL )
7533 {
7534  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePREDEC );
7535  n->Arg<CNode*>(0) = a0;
7536  return n;
7537 }
7547 inline CNode* cPREDEC( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
7548 {
7549  CNode* n = new(heap) CNode( loc, ePREDEC );
7550  n->Arg<CNode*>(0) = a0;
7551  return n;
7552 }
7561 inline CNode* cPOSTDEC( CNode* a0, Coord_t* loc=NULL )
7562 {
7563  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePOSTDEC );
7564  n->Arg<CNode*>(0) = a0;
7565  return n;
7566 }
7576 inline CNode* cPOSTDEC( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
7577 {
7578  CNode* n = new(heap) CNode( loc, ePOSTDEC );
7579  n->Arg<CNode*>(0) = a0;
7580  return n;
7581 }
7591 inline CNode* cCAST( CNode* a0, CNode* a1, Coord_t* loc=NULL )
7592 {
7593  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCAST );
7594  n->Arg<CNode*>(0) = a0;
7595  n->Arg<CNode*>(1) = a1;
7596  return n;
7597 }
7608 inline CNode* cCAST( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
7609 {
7610  CNode* n = new(heap) CNode( loc, eCAST );
7611  n->Arg<CNode*>(0) = a0;
7612  n->Arg<CNode*>(1) = a1;
7613  return n;
7614 }
7623 inline CNode* cASSIGNMENT_PATTERN( CNode* a0, Coord_t* loc=NULL )
7624 {
7625  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eASSIGNMENT_PATTERN );
7626  n->Arg<CNode*>(0) = a0;
7627  return n;
7628 }
7638 inline CNode* cASSIGNMENT_PATTERN( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
7639 {
7640  CNode* n = new(heap) CNode( loc, eASSIGNMENT_PATTERN );
7641  n->Arg<CNode*>(0) = a0;
7642  return n;
7643 }
7651 inline CNode* cDOLLAR( Coord_t* loc=NULL )
7652 {
7653  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eDOLLAR );
7654  return n;
7655 }
7664 inline CNode* cDOLLAR( CObstack* heap, Coord_t* loc=NULL )
7665 {
7666  CNode* n = new(heap) CNode( loc, eDOLLAR );
7667  return n;
7668 }
7669 #endif // DEFINE_CONSTUCTOR
7670 
7671 
7672 /*********************************************************
7673  * Warning: This file is machine generate, do not edit
7674  ********************************************************/
7675 
7676 
7677 
7678 
7679 #ifdef DEFINE_METHODS
7680 
7681 /************************************
7682  * ArgCount
7683  * - return number of arguments for node
7684  ***********************************/
7686 {
7687  switch( op ) {
7688  case eERROR:
7689  return 0;
7690  case eVCONSTANT:
7691  return 1;
7692  case eRCONSTANT:
7693  return 1;
7694  case eCOMMENT:
7695  return 1;
7696  case eVRQ:
7697  return 1;
7698  case ePRAGMA:
7699  return 2;
7700  case eELIST:
7701  return 2;
7702  case eWIDTH:
7703  return 2;
7704  case eNOP:
7705  return 0;
7706  case eSUB:
7707  return 2;
7708  case eMUL:
7709  return 2;
7710  case eDIV:
7711  return 2;
7712  case ePOW:
7713  return 2;
7714  case eADD:
7715  return 2;
7716  case eLSH:
7717  return 2;
7718  case eRSH:
7719  return 2;
7720  case eLSHA:
7721  return 2;
7722  case eRSHA:
7723  return 2;
7724  case eMOD:
7725  return 2;
7726  case eOR:
7727  return 2;
7728  case eAND:
7729  return 2;
7730  case eANDANDAND:
7731  return 2;
7732  case eXOR:
7733  return 2;
7734  case eXNOR:
7735  return 2;
7736  case eINSTANCE_REF:
7737  return 1;
7738  case eGATE_REF:
7739  return 1;
7740  case eTASK_ENABLE:
7741  return 2;
7742  case eSYSTASK_CALL:
7743  return 2;
7744  case eTIMING_CALL:
7745  return 2;
7746  case eFUNCTION_CALL:
7747  return 3;
7748  case eARRAY:
7749  return 2;
7750  case eNET_REF:
7751  return 1;
7752  case eVAR_REF:
7753  return 1;
7754  case ePARAM_REF:
7755  return 1;
7756  case ePORT_REF:
7757  return 1;
7758  case eFWD_REF:
7759  return 1;
7760  case eGENVAR_REF:
7761  return 1;
7762  case eENUM_REF:
7763  return 1;
7764  case eTYPE_REF:
7765  return 1;
7766  case eNET_DECL:
7767  return 2;
7768  case eVAR_DECL:
7769  return 2;
7770  case ePARAM_DECL:
7771  return 1;
7772  case eSPECPARAM_DECL:
7773  return 1;
7774  case ePORT_DECL:
7775  return 1;
7776  case eGENVAR_DECL:
7777  return 1;
7778  case eTYPEDEF_DECL:
7779  return 1;
7780  case eLIST:
7781  return 2;
7782  case eRANGE:
7783  return 2;
7784  case eSLICE:
7785  return 2;
7786  case ePSLICE:
7787  return 2;
7788  case eMSLICE:
7789  return 2;
7790  case eCVRI:
7791  return 1;
7792  case eCVIR:
7793  return 1;
7794  case eREP:
7795  return 2;
7796  case eCAT:
7797  return 2;
7798  case eUCAT:
7799  return 1;
7800  case eCOM:
7801  return 1;
7802  case eNEG:
7803  return 1;
7804  case ePLUS:
7805  return 1;
7806  case eNOT:
7807  return 1;
7808  case eGT:
7809  return 2;
7810  case eGE:
7811  return 2;
7812  case eLT:
7813  return 2;
7814  case eLE:
7815  return 2;
7816  case eLAND:
7817  return 2;
7818  case eLOR:
7819  return 2;
7820  case eCEQ:
7821  return 2;
7822  case eCNE:
7823  return 2;
7824  case eEQ:
7825  return 2;
7826  case eNE:
7827  return 2;
7828  case eRAND:
7829  return 1;
7830  case eRNAND:
7831  return 1;
7832  case eROR:
7833  return 1;
7834  case eRNOR:
7835  return 1;
7836  case eRXOR:
7837  return 1;
7838  case eRXNOR:
7839  return 1;
7840  case eHOOK:
7841  return 3;
7842  case eINIT:
7843  return 1;
7844  case eALWAYS:
7845  return 1;
7846  case eALWAYS_LATCH:
7847  return 1;
7848  case eALWAYS_FF:
7849  return 1;
7850  case eALWAYS_COMB:
7851  return 1;
7852  case eEVENT:
7853  return 2;
7854  case eBLOCK_REF:
7855  return 3;
7856  case eSPECIFY_REF:
7857  return 2;
7858  case eASSIGN:
7859  return 3;
7860  case eGASSIGN:
7861  return 3;
7862  case eADD_ASSIGN:
7863  return 3;
7864  case eSUB_ASSIGN:
7865  return 3;
7866  case eMUL_ASSIGN:
7867  return 3;
7868  case eDIV_ASSIGN:
7869  return 3;
7870  case eMOD_ASSIGN:
7871  return 3;
7872  case eAND_ASSIGN:
7873  return 3;
7874  case eOR_ASSIGN:
7875  return 3;
7876  case eXOR_ASSIGN:
7877  return 3;
7878  case eLSH_ASSIGN:
7879  return 3;
7880  case eRSH_ASSIGN:
7881  return 3;
7882  case eLSHA_ASSIGN:
7883  return 3;
7884  case eRSHA_ASSIGN:
7885  return 3;
7886  case eFORCE:
7887  return 2;
7888  case eRELEASE:
7889  return 1;
7890  case eNBASSIGN:
7891  return 3;
7892  case ePOSEDGE:
7893  return 1;
7894  case eNEGEDGE:
7895  return 1;
7896  case eEDGE:
7897  return 2;
7898  case eEVOR:
7899  return 2;
7900  case eDELAY:
7901  return 2;
7902  case eMTM:
7903  return 3;
7904  case eIF:
7905  return 4;
7906  case eFOREVER:
7907  return 1;
7908  case eREPEAT:
7909  return 2;
7910  case eWHILE:
7911  return 2;
7912  case eWAIT:
7913  return 2;
7914  case eFOR:
7915  return 4;
7916  case eCASE:
7917  return 3;
7918  case eCASEX:
7919  return 3;
7920  case eCASEZ:
7921  return 3;
7922  case eCASEITEM:
7923  return 2;
7924  case eCASSIGN:
7925  return 4;
7926  case eARG:
7927  return 2;
7928  case eIMPORT:
7929  return 1;
7930  case eFUNCTION_DEF:
7931  return 1;
7932  case eMODULE_DEF:
7933  return 1;
7934  case ePACKAGE_DEF:
7935  return 1;
7936  case eREPEAT_CONTROL:
7937  return 2;
7938  case eDELAY_CONTROL:
7939  return 1;
7940  case eEVENT_CONTROL:
7941  return 1;
7942  case eEXTERNAL_REF:
7943  return 1;
7944  case ePORT_DEF:
7945  return 1;
7946  case eDEFPARAM:
7947  return 2;
7948  case ePATH:
7949  return 7;
7950  case ePATH_ASSIGN:
7951  return 3;
7952  case eIFNONE_PATH_ASSIGN:
7953  return 2;
7954  case eTRIGGER:
7955  return 1;
7956  case ePASSIGN:
7957  return 2;
7958  case eDEASSIGN:
7959  return 1;
7960  case eDISABLE:
7961  return 1;
7962  case eATTRIBUTE:
7963  return 1;
7964  case eGIF:
7965  return 3;
7966  case eGFOR:
7967  return 4;
7968  case eGCASE:
7969  return 2;
7970  case eTABLE:
7971  return 1;
7972  case eTABLE_ENTRY:
7973  return 1;
7974  case eTABLE_SYMBOL:
7975  return 1;
7976  case ePORTLIST_END:
7977  return 0;
7978  case eMACRO_EXPR:
7979  return 2;
7980  case eENUM_SPEC:
7981  return 3;
7982  case eMEMBER:
7983  return 2;
7984  case eRETURN:
7985  return 1;
7986  case ePREINC:
7987  return 1;
7988  case ePOSTINC:
7989  return 1;
7990  case ePREDEC:
7991  return 1;
7992  case ePOSTDEC:
7993  return 1;
7994  case eCAST:
7995  return 2;
7996  case eASSIGNMENT_PATTERN:
7997  return 1;
7998  case eDOLLAR:
7999  return 0;
8000  default:
8001  MASSERT(FALSE);
8002  }
8003  return 0;
8004 }
8005 
8006 /************************************
8007  * Precedence
8008  * - return precedence of operator
8009  * result 0 - 13
8010  ***********************************/
8012 {
8013  switch( op ) {
8014  case eERROR:
8015  return 13;
8016  case eVCONSTANT:
8017  return 13;
8018  case eRCONSTANT:
8019  return 13;
8020  case eCOMMENT:
8021  return 13;
8022  case eVRQ:
8023  return 13;
8024  case ePRAGMA:
8025  return 13;
8026  case eELIST:
8027  return 13;
8028  case eWIDTH:
8029  return 13;
8030  case eSUB:
8031  return 9;
8032  case eMUL:
8033  return 10;
8034  case eDIV:
8035  return 10;
8036  case ePOW:
8037  return 11;
8038  case eADD:
8039  return 9;
8040  case eLSH:
8041  return 8;
8042  case eRSH:
8043  return 8;
8044  case eLSHA:
8045  return 8;
8046  case eRSHA:
8047  return 8;
8048  case eMOD:
8049  return 10;
8050  case eOR:
8051  return 3;
8052  case eAND:
8053  return 5;
8054  case eANDANDAND:
8055  return 0;
8056  case eXOR:
8057  return 4;
8058  case eXNOR:
8059  return 4;
8060  case eSYSTASK_CALL:
8061  return 13;
8062  case eFUNCTION_CALL:
8063  return 13;
8064  case eARRAY:
8065  return 13;
8066  case eNET_REF:
8067  return 13;
8068  case eVAR_REF:
8069  return 13;
8070  case ePARAM_REF:
8071  return 13;
8072  case ePORT_REF:
8073  return 13;
8074  case eFWD_REF:
8075  return 13;
8076  case eGENVAR_REF:
8077  return 13;
8078  case eENUM_REF:
8079  return 13;
8080  case eTYPE_REF:
8081  return 13;
8082  case eRANGE:
8083  return 13;
8084  case eSLICE:
8085  return 13;
8086  case ePSLICE:
8087  return 13;
8088  case eMSLICE:
8089  return 13;
8090  case eCVRI:
8091  return 13;
8092  case eCVIR:
8093  return 13;
8094  case eREP:
8095  return 13;
8096  case eCAT:
8097  return 13;
8098  case eUCAT:
8099  return 13;
8100  case eCOM:
8101  return 12;
8102  case eNEG:
8103  return 12;
8104  case ePLUS:
8105  return 12;
8106  case eNOT:
8107  return 12;
8108  case eGT:
8109  return 7;
8110  case eGE:
8111  return 7;
8112  case eLT:
8113  return 7;
8114  case eLE:
8115  return 7;
8116  case eLAND:
8117  return 2;
8118  case eLOR:
8119  return 1;
8120  case eCEQ:
8121  return 6;
8122  case eCNE:
8123  return 6;
8124  case eEQ:
8125  return 6;
8126  case eNE:
8127  return 6;
8128  case eRAND:
8129  return 12;
8130  case eRNAND:
8131  return 12;
8132  case eROR:
8133  return 12;
8134  case eRNOR:
8135  return 12;
8136  case eRXOR:
8137  return 12;
8138  case eRXNOR:
8139  return 12;
8140  case eHOOK:
8141  return 0;
8142  case ePOSEDGE:
8143  return 13;
8144  case eNEGEDGE:
8145  return 13;
8146  case eEDGE:
8147  return 13;
8148  case eEVOR:
8149  return 13;
8150  case eMTM:
8151  return 13;
8152  case eEXTERNAL_REF:
8153  return 13;
8154  case eMACRO_EXPR:
8155  return 13;
8156  case eMEMBER:
8157  return 13;
8158  case ePREINC:
8159  return 12;
8160  case ePOSTINC:
8161  return 12;
8162  case ePREDEC:
8163  return 12;
8164  case ePOSTDEC:
8165  return 12;
8166  case eCAST:
8167  return 13;
8168  case eASSIGNMENT_PATTERN:
8169  return 13;
8170  case eDOLLAR:
8171  return 13;
8172  default:
8173  MASSERT( FALSE );
8174  return 13;
8175  }
8176 }
8177 
8178 /************************************************
8179  IsConstant
8180  - return true if expression is constant
8181 **************************************************/
8182 
8184 {
8185  switch( op ) {
8186  case eERROR:
8187  return FALSE;
8188  case eVCONSTANT:
8189  return TRUE;
8190  case eRCONSTANT:
8191  return TRUE;
8192  case eCOMMENT:
8193  return TRUE;
8194  case eVRQ:
8195  return TRUE;
8196  case ePRAGMA:
8197  return TRUE;
8198  case eELIST:
8199  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8200  case eWIDTH:
8201  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8202  case eSUB:
8203  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8204  case eMUL:
8205  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8206  case eDIV:
8207  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8208  case ePOW:
8209  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8210  case eADD:
8211  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8212  case eLSH:
8213  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8214  case eRSH:
8215  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8216  case eLSHA:
8217  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8218  case eRSHA:
8219  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8220  case eMOD:
8221  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8222  case eOR:
8223  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8224  case eAND:
8225  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8226  case eANDANDAND:
8227  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8228  case eXOR:
8229  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8230  case eXNOR:
8231  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8232  case eSYSTASK_CALL:
8233  return TRUE;
8234  case eFUNCTION_CALL:
8235  return Arg<CNode*>(1)->IsConstant();
8236  case eARRAY:
8237  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8238  case eNET_REF:
8239  return FALSE;
8240  case eVAR_REF:
8241  return FALSE;
8242  case ePARAM_REF:
8243  return TRUE;
8244  case ePORT_REF:
8245  return FALSE;
8246  case eFWD_REF:
8247  return FALSE;
8248  case eGENVAR_REF:
8249  return TRUE;
8250  case eENUM_REF:
8251  return TRUE;
8252  case eTYPE_REF:
8253  return TRUE;
8254  case eRANGE:
8255  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8256  case eSLICE:
8257  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8258  case ePSLICE:
8259  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8260  case eMSLICE:
8261  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8262  case eCVRI:
8263  return Arg<CNode*>(0)->IsConstant();
8264  case eCVIR:
8265  return Arg<CNode*>(0)->IsConstant();
8266  case eREP:
8267  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8268  case eCAT:
8269  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8270  case eUCAT:
8271  return Arg<CNode*>(0)->IsConstant();
8272  case eCOM:
8273  return Arg<CNode*>(0)->IsConstant();
8274  case eNEG:
8275  return Arg<CNode*>(0)->IsConstant();
8276  case ePLUS:
8277  return Arg<CNode*>(0)->IsConstant();
8278  case eNOT:
8279  return Arg<CNode*>(0)->IsConstant();
8280  case eGT:
8281  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8282  case eGE:
8283  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8284  case eLT:
8285  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8286  case eLE:
8287  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8288  case eLAND:
8289  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8290  case eLOR:
8291  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8292  case eCEQ:
8293  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8294  case eCNE:
8295  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8296  case eEQ:
8297  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8298  case eNE:
8299  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8300  case eRAND:
8301  return Arg<CNode*>(0)->IsConstant();
8302  case eRNAND:
8303  return Arg<CNode*>(0)->IsConstant();
8304  case eROR:
8305  return Arg<CNode*>(0)->IsConstant();
8306  case eRNOR:
8307  return Arg<CNode*>(0)->IsConstant();
8308  case eRXOR:
8309  return Arg<CNode*>(0)->IsConstant();
8310  case eRXNOR:
8311  return Arg<CNode*>(0)->IsConstant();
8312  case eHOOK:
8313  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant() && Arg<CNode*>(2)->IsConstant();
8314  case eMTM:
8315  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant() && Arg<CNode*>(2)->IsConstant();
8316  case eEXTERNAL_REF:
8317  return FALSE;
8318  case eMACRO_EXPR:
8319  return TRUE;
8320  case eMEMBER:
8321  return Arg<CNode*>(0)->IsConstant();
8322  case ePREINC:
8323  return Arg<CNode*>(0)->IsConstant();
8324  case ePOSTINC:
8325  return Arg<CNode*>(0)->IsConstant();
8326  case ePREDEC:
8327  return Arg<CNode*>(0)->IsConstant();
8328  case ePOSTDEC:
8329  return Arg<CNode*>(0)->IsConstant();
8330  case eCAST:
8331  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8332  case eASSIGNMENT_PATTERN:
8333  return Arg<CNode*>(0)->IsConstant();
8334  case eDOLLAR:
8335  return TRUE;
8336  default:
8337  MASSERT( FALSE );
8338  }
8339 
8340  return TRUE;
8341 }
8342 
8343 /************************************************
8344  IsVolatile
8345  - return false if expression is constant
8346  and not dependent upon parameters
8347 **************************************************/
8348 
8350 {
8351  switch( op ) {
8352  case eERROR:
8353  return TRUE;
8354  case eVCONSTANT:
8355  return FALSE;
8356  case eRCONSTANT:
8357  return FALSE;
8358  case eCOMMENT:
8359  return FALSE;
8360  case eVRQ:
8361  return FALSE;
8362  case ePRAGMA:
8363  return FALSE;
8364  case eELIST:
8365  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8366  case eWIDTH:
8367  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8368  case eSUB:
8369  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8370  case eMUL:
8371  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8372  case eDIV:
8373  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8374  case ePOW:
8375  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8376  case eADD:
8377  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8378  case eLSH:
8379  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8380  case eRSH:
8381  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8382  case eLSHA:
8383  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8384  case eRSHA:
8385  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8386  case eMOD:
8387  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8388  case eOR:
8389  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8390  case eAND:
8391  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8392  case eANDANDAND:
8393  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8394  case eXOR:
8395  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8396  case eXNOR:
8397  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8398  case eSYSTASK_CALL:
8399  return TRUE;
8400  case eFUNCTION_CALL:
8401  return Arg<CNode*>(1)->IsVolatile();
8402  case eARRAY:
8403  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8404  case eNET_REF:
8405  return TRUE;
8406  case eVAR_REF:
8407  return TRUE;
8408  case ePARAM_REF:
8409  return TRUE;
8410  case ePORT_REF:
8411  return TRUE;
8412  case eFWD_REF:
8413  return TRUE;
8414  case eGENVAR_REF:
8415  return TRUE;
8416  case eENUM_REF:
8417  return Arg<CEnum*>(0)->GetExpression()->IsVolatile();
8418  case eTYPE_REF:
8419  return FALSE;
8420  case eRANGE:
8421  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8422  case eSLICE:
8423  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8424  case ePSLICE:
8425  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8426  case eMSLICE:
8427  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8428  case eCVRI:
8429  return Arg<CNode*>(0)->IsVolatile();
8430  case eCVIR:
8431  return Arg<CNode*>(0)->IsVolatile();
8432  case eREP:
8433  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8434  case eCAT:
8435  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8436  case eUCAT:
8437  return Arg<CNode*>(0)->IsVolatile();
8438  case eCOM:
8439  return Arg<CNode*>(0)->IsVolatile();
8440  case eNEG:
8441  return Arg<CNode*>(0)->IsVolatile();
8442  case ePLUS:
8443  return Arg<CNode*>(0)->IsVolatile();
8444  case eNOT:
8445  return Arg<CNode*>(0)->IsVolatile();
8446  case eGT:
8447  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8448  case eGE:
8449  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8450  case eLT:
8451  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8452  case eLE:
8453  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8454  case eLAND:
8455  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8456  case eLOR:
8457  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8458  case eCEQ:
8459  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8460  case eCNE:
8461  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8462  case eEQ:
8463  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8464  case eNE:
8465  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8466  case eRAND:
8467  return Arg<CNode*>(0)->IsVolatile();
8468  case eRNAND:
8469  return Arg<CNode*>(0)->IsVolatile();
8470  case eROR:
8471  return Arg<CNode*>(0)->IsVolatile();
8472  case eRNOR:
8473  return Arg<CNode*>(0)->IsVolatile();
8474  case eRXOR:
8475  return Arg<CNode*>(0)->IsVolatile();
8476  case eRXNOR:
8477  return Arg<CNode*>(0)->IsVolatile();
8478  case eHOOK:
8479  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile() || Arg<CNode*>(2)->IsVolatile();
8480  case eMTM:
8481  return TRUE;
8482  case eEXTERNAL_REF:
8483  return TRUE;
8484  case eMACRO_EXPR:
8485  return Arg<CNode*>(1) ? Arg<CNode*>(1)->IsVolatile() : TRUE;
8486  case eMEMBER:
8487  return Arg<CNode*>(0)->IsVolatile();
8488  case ePREINC:
8489  return Arg<CNode*>(0)->IsVolatile();
8490  case ePOSTINC:
8491  return Arg<CNode*>(0)->IsVolatile();
8492  case ePREDEC:
8493  return Arg<CNode*>(0)->IsVolatile();
8494  case ePOSTDEC:
8495  return Arg<CNode*>(0)->IsVolatile();
8496  case eCAST:
8497  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8498  case eASSIGNMENT_PATTERN:
8499  return Arg<CNode*>(0)->IsVolatile();
8500  case eDOLLAR:
8501  return FALSE;
8502  default:
8503  MASSERT( FALSE );
8504  }
8505 
8506  return TRUE;
8507 }
8508 
8509 
8510 /************************************************
8511  IsWidthConstant
8512  - return true if expression has a constant width
8513 **************************************************/
8514 
8516 {
8517  switch( GetOp() ) {
8518  case eERROR:
8519  return TRUE;
8520  case eVCONSTANT:
8521  return Arg<CVector*>(0)->IsWidthConstant();
8522  case eRCONSTANT:
8523  return TRUE;
8524  case eELIST:
8525  return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
8526  case eWIDTH:
8527  return Arg<CNode*>(0)->IsConstant();
8528  case eSUB:
8529  return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
8530  case eMUL:
8531  return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
8532  case eDIV:
8533  return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
8534  case ePOW:
8535  return Arg<CNode*>(0)->IsWidthConstant();
8536  case eADD:
8537  return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
8538  case eLSH:
8539  return Arg<CNode*>(0)->IsWidthConstant();
8540  case eRSH:
8541  return Arg<CNode*>(0)->IsWidthConstant();
8542  case eLSHA:
8543  return Arg<CNode*>(0)->IsWidthConstant();
8544  case eRSHA:
8545  return Arg<CNode*>(0)->IsWidthConstant();
8546  case eMOD:
8547  return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
8548  case eOR:
8549  return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
8550  case eAND:
8551  return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
8552  case eANDANDAND:
8553  return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
8554  case eXOR:
8555  return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
8556  case eXNOR:
8557  return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
8558  case eSYSTASK_CALL:
8559  return Systask::WidthConstant(Arg<CSymbol*>(0),Arg<CNode*>(1));
8560  case eFUNCTION_CALL:
8561  return CFunction::WidthConstant(Arg<CSymbol*>(0),Arg<CNode*>(1),Arg<CScope*>(2));
8562  case eARRAY:
8563  return Array::WidthConstant(Arg<CNode*>(0),Arg<CNode*>(1));
8564  case eNET_REF:
8565  return Arg<CNet*>(0)->IsWidthConstant();
8566  case eVAR_REF:
8567  return Arg<CVar*>(0)->IsWidthConstant();
8568  case ePARAM_REF:
8569  return Arg<CParam*>(0)->IsWidthConstant();
8570  case ePORT_REF:
8571  return Arg<CPortDir*>(0)->IsWidthConstant();
8572  case eFWD_REF:
8573  return Arg<CFref*>(0)->IsWidthConstant();
8574  case eGENVAR_REF:
8575  return Arg<CGenvar*>(0)->IsWidthConstant();
8576  case eENUM_REF:
8577  return Arg<CEnum*>(0)->IsWidthConstant();
8578  case eTYPE_REF:
8579  return TRUE;
8580  case eRANGE:
8581  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8582  case eSLICE:
8583  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8584  case ePSLICE:
8585  return Arg<CNode*>(1)->IsConstant();
8586  case eMSLICE:
8587  return Arg<CNode*>(1)->IsConstant();
8588  case eCVRI:
8589  return TRUE;
8590  case eCVIR:
8591  return TRUE;
8592  case eREP:
8593  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsWidthConstant();
8594  case eCAT:
8595  return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
8596  case eUCAT:
8597  return Arg<CNode*>(0)->IsWidthConstant();
8598  case eCOM:
8599  return Arg<CNode*>(0)->IsWidthConstant();
8600  case eNEG:
8601  return Arg<CNode*>(0)->IsWidthConstant();
8602  case ePLUS:
8603  return Arg<CNode*>(0)->IsWidthConstant();
8604  case eNOT:
8605  return TRUE;
8606  case eGT:
8607  return TRUE;
8608  case eGE:
8609  return TRUE;
8610  case eLT:
8611  return TRUE;
8612  case eLE:
8613  return TRUE;
8614  case eLAND:
8615  return TRUE;
8616  case eLOR:
8617  return TRUE;
8618  case eCEQ:
8619  return TRUE;
8620  case eCNE:
8621  return TRUE;
8622  case eEQ:
8623  return TRUE;
8624  case eNE:
8625  return TRUE;
8626  case eRAND:
8627  return TRUE;
8628  case eRNAND:
8629  return TRUE;
8630  case eROR:
8631  return TRUE;
8632  case eRNOR:
8633  return TRUE;
8634  case eRXOR:
8635  return TRUE;
8636  case eRXNOR:
8637  return TRUE;
8638  case eHOOK:
8639  return Arg<CNode*>(1)->IsWidthConstant() && Arg<CNode*>(2)->IsWidthConstant();
8640  case eMTM:
8641  return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant() && Arg<CNode*>(2)->IsWidthConstant();
8642  case eEXTERNAL_REF:
8643  return External::WidthConstant(Arg<CSymbol*>(0));
8644  case eATTRIBUTE:
8645  return TRUE;
8646  case eMACRO_EXPR:
8647  return Arg<CNode*>(1)->IsWidthConstant();
8648  case eMEMBER:
8649  return Member::WidthConstant(Arg<CNode*>(0),Arg<CSymbol*>(1));
8650  case ePREINC:
8651  return Arg<CNode*>(0)->IsWidthConstant();
8652  case ePOSTINC:
8653  return Arg<CNode*>(0)->IsWidthConstant();
8654  case ePREDEC:
8655  return Arg<CNode*>(0)->IsWidthConstant();
8656  case ePOSTDEC:
8657  return Arg<CNode*>(0)->IsWidthConstant();
8658  case eCAST:
8659  return Arg<CNode*>(0)->IsWidthConstant();
8660  case eASSIGNMENT_PATTERN:
8661  return TRUE;
8662  case eDOLLAR:
8663  return TRUE;
8664  default:
8665  MASSERT( FALSE );
8666  return 0;
8667  }
8668 }
8669 
8670 /************************************************
8671  IsWidthVolatile
8672  - return true if expression has a volatile width
8673 **************************************************/
8674 
8676 {
8677  switch( GetOp() ) {
8678  case eERROR:
8679  return FALSE;
8680  case eVCONSTANT:
8681  return Arg<CVector*>(0)->IsWidthVolatile();
8682  case eRCONSTANT:
8683  return FALSE;
8684  case eELIST:
8685  return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
8686  case eWIDTH:
8687  return Arg<CNode*>(0)->IsVolatile();
8688  case eSUB:
8689  return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
8690  case eMUL:
8691  return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
8692  case eDIV:
8693  return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
8694  case ePOW:
8695  return Arg<CNode*>(0)->IsWidthVolatile();
8696  case eADD:
8697  return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
8698  case eLSH:
8699  return Arg<CNode*>(0)->IsWidthVolatile();
8700  case eRSH:
8701  return Arg<CNode*>(0)->IsWidthVolatile();
8702  case eLSHA:
8703  return Arg<CNode*>(0)->IsWidthVolatile();
8704  case eRSHA:
8705  return Arg<CNode*>(0)->IsWidthVolatile();
8706  case eMOD:
8707  return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
8708  case eOR:
8709  return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
8710  case eAND:
8711  return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
8712  case eANDANDAND:
8713  return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
8714  case eXOR:
8715  return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
8716  case eXNOR:
8717  return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
8718  case eSYSTASK_CALL:
8719  return Systask::WidthVolatile(Arg<CSymbol*>(0),Arg<CNode*>(1));
8720  case eFUNCTION_CALL:
8721  return CFunction::WidthVolatile(Arg<CSymbol*>(0),Arg<CNode*>(1),Arg<CScope*>(2));
8722  case eARRAY:
8723  return Array::WidthVolatile(Arg<CNode*>(0),Arg<CNode*>(1));
8724  case eNET_REF:
8725  return Arg<CNet*>(0)->IsWidthVolatile();
8726  case eVAR_REF:
8727  return Arg<CVar*>(0)->IsWidthVolatile();
8728  case ePARAM_REF:
8729  return Arg<CParam*>(0)->IsWidthVolatile();
8730  case ePORT_REF:
8731  return Arg<CPortDir*>(0)->IsWidthVolatile();
8732  case eFWD_REF:
8733  return Arg<CFref*>(0)->IsWidthVolatile();
8734  case eGENVAR_REF:
8735  return Arg<CGenvar*>(0)->IsWidthVolatile();
8736  case eENUM_REF:
8737  return Arg<CEnum*>(0)->IsWidthVolatile();
8738  case eTYPE_REF:
8739  return FALSE;
8740  case eRANGE:
8741  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8742  case eSLICE:
8743  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8744  case ePSLICE:
8745  return Arg<CNode*>(1)->IsVolatile();
8746  case eMSLICE:
8747  return Arg<CNode*>(1)->IsVolatile();
8748  case eCVRI:
8749  return FALSE;
8750  case eCVIR:
8751  return FALSE;
8752  case eREP:
8753  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
8754  case eCAT:
8755  return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
8756  case eUCAT:
8757  return Arg<CNode*>(0)->IsWidthVolatile();
8758  case eCOM:
8759  return Arg<CNode*>(0)->IsWidthVolatile();
8760  case eNEG:
8761  return Arg<CNode*>(0)->IsWidthVolatile();
8762  case ePLUS:
8763  return Arg<CNode*>(0)->IsWidthVolatile();
8764  case eNOT:
8765  return FALSE;
8766  case eGT:
8767  return FALSE;
8768  case eGE:
8769  return FALSE;
8770  case eLT:
8771  return FALSE;
8772  case eLE:
8773  return FALSE;
8774  case eLAND:
8775  return FALSE;
8776  case eLOR:
8777  return FALSE;
8778  case eCEQ:
8779  return FALSE;
8780  case eCNE:
8781  return FALSE;
8782  case eEQ:
8783  return FALSE;
8784  case eNE:
8785  return FALSE;
8786  case eRAND:
8787  return FALSE;
8788  case eRNAND:
8789  return FALSE;
8790  case eROR:
8791  return FALSE;
8792  case eRNOR:
8793  return FALSE;
8794  case eRXOR:
8795  return FALSE;
8796  case eRXNOR:
8797  return FALSE;
8798  case eHOOK:
8799  return Arg<CNode*>(1)->IsWidthVolatile() || Arg<CNode*>(2)->IsWidthVolatile();
8800  case eMTM:
8801  return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile() || Arg<CNode*>(2)->IsWidthVolatile();
8802  case eEXTERNAL_REF:
8803  return External::WidthVolatile(Arg<CSymbol*>(0));
8804  case eATTRIBUTE:
8805  return FALSE;
8806  case eMACRO_EXPR:
8807  return Arg<CNode*>(1)->IsWidthVolatile();
8808  case eMEMBER:
8809  return Member::WidthVolatile(Arg<CNode*>(0),Arg<CSymbol*>(1));
8810  case ePREINC:
8811  return Arg<CNode*>(0)->IsWidthVolatile();
8812  case ePOSTINC:
8813  return Arg<CNode*>(0)->IsWidthVolatile();
8814  case ePREDEC:
8815  return Arg<CNode*>(0)->IsWidthVolatile();
8816  case ePOSTDEC:
8817  return Arg<CNode*>(0)->IsWidthVolatile();
8818  case eCAST:
8819  return Arg<CNode*>(0)->IsWidthVolatile();
8820  case eASSIGNMENT_PATTERN:
8821  return FALSE;
8822  case eDOLLAR:
8823  return FALSE;
8824  default:
8825  MASSERT( FALSE );
8826  return 0;
8827  }
8828 
8829 }
8830 
8831 /************************************************
8832  GetWidthExp
8833  - return expression tree for width of
8834  expression, return NULL if not-determinable
8835 **************************************************/
8836 
8838 {
8839  switch( GetOp() ) {
8840  case eERROR: {
8841  CNode* temp0;
8842  CNode* temp1;
8843  CNode* temp2;
8844  return NULL;
8845  }
8846  case eVCONSTANT: {
8847  CNode* temp0;
8848  CNode* temp1;
8849  CNode* temp2;
8850  return Arg<CVector*>(0)->GetWidthExp();
8851  }
8852  case eRCONSTANT: {
8853  CNode* temp0;
8854  CNode* temp1;
8855  CNode* temp2;
8856  return NULL;
8857  }
8858  case eELIST: {
8859  CNode* temp0;
8860  CNode* temp1;
8861  CNode* temp2;
8862  return ((temp0=Arg<CNode*>(0)->GetWidthExp()) && (temp1=Arg<CNode*>(1)->GetWidthExp())) ? cADD_N(temp0,temp1,NULL) : NULL;
8863  }
8864  case eWIDTH: {
8865  CNode* temp0;
8866  CNode* temp1;
8867  CNode* temp2;
8868  return cINT32(Arg<CNode*>(0)->EvalINT32());
8869  }
8870  case eSUB: {
8871  CNode* temp0;
8872  CNode* temp1;
8873  CNode* temp2;
8874  return ((temp0=Arg<CNode*>(0)->GetWidthExp()) && (temp1=Arg<CNode*>(1)->GetWidthExp())) ? cMAX_N(temp0,temp1,NULL) : NULL;
8875  }
8876  case eMUL: {
8877  CNode* temp0;
8878  CNode* temp1;
8879  CNode* temp2;
8880  return ((temp0=Arg<CNode*>(0)->GetWidthExp()) && (temp1=Arg<CNode*>(1)->GetWidthExp())) ? cMAX_N(temp0,temp1,NULL) : NULL;
8881  }
8882  case eDIV: {
8883  CNode* temp0;
8884  CNode* temp1;
8885  CNode* temp2;
8886  return ((temp0=Arg<CNode*>(0)->GetWidthExp()) && (temp1=Arg<CNode*>(1)->GetWidthExp())) ? cMAX_N(temp0,temp1,NULL) : NULL;
8887  }
8888  case ePOW: {
8889  CNode* temp0;
8890  CNode* temp1;
8891  CNode* temp2;
8892  return Arg<CNode*>(0)->GetWidthExp();
8893  }
8894  case eADD: {
8895  CNode* temp0;
8896  CNode* temp1;
8897  CNode* temp2;
8898  return ((temp0=Arg<CNode*>(0)->GetWidthExp()) && (temp1=Arg<CNode*>(1)->GetWidthExp())) ? cMAX_N(temp0,temp1,NULL) : NULL;
8899  }
8900  case eLSH: {
8901  CNode* temp0;
8902  CNode* temp1;
8903  CNode* temp2;
8904  return Arg<CNode*>(0)->GetWidthExp();
8905  }
8906  case eRSH: {
8907  CNode* temp0;
8908  CNode* temp1;
8909  CNode* temp2;
8910  return Arg<CNode*>(0)->GetWidthExp();
8911  }
8912  case eLSHA: {
8913  CNode* temp0;
8914  CNode* temp1;
8915  CNode* temp2;
8916  return Arg<CNode*>(0)->GetWidthExp();
8917  }
8918  case eRSHA: {
8919  CNode* temp0;
8920  CNode* temp1;
8921  CNode* temp2;
8922  return Arg<CNode*>(0)->GetWidthExp();
8923  }
8924  case eMOD: {
8925  CNode* temp0;
8926  CNode* temp1;
8927  CNode* temp2;
8928  return ((temp0=Arg<CNode*>(0)->GetWidthExp()) && (temp1=Arg<CNode*>(1)->GetWidthExp())) ? cMAX_N(temp0,temp1,NULL) : NULL;
8929  }
8930  case eOR: {
8931  CNode* temp0;
8932  CNode* temp1;
8933  CNode* temp2;
8934  return ((temp0=Arg<CNode*>(0)->GetWidthExp()) && (temp1=Arg<CNode*>(1)->GetWidthExp())) ? cMAX_N(temp0,temp1,NULL) : NULL;
8935  }
8936  case eAND: {
8937  CNode* temp0;
8938  CNode* temp1;
8939  CNode* temp2;
8940  return ((temp0=Arg<CNode*>(0)->GetWidthExp()) && (temp1=Arg<CNode*>(1)->GetWidthExp())) ? cMAX_N(temp0,temp1,NULL) : NULL;
8941  }
8942  case eANDANDAND: {
8943  CNode* temp0;
8944  CNode* temp1;
8945  CNode* temp2;
8946  return ((temp0=Arg<CNode*>(0)->GetWidthExp()) && (temp1=Arg<CNode*>(1)->GetWidthExp())) ? cMAX_N(temp0,temp1,NULL) : NULL;
8947  }
8948  case eXOR: {
8949  CNode* temp0;
8950  CNode* temp1;
8951  CNode* temp2;
8952  return ((temp0=Arg<CNode*>(0)->GetWidthExp()) && (temp1=Arg<CNode*>(1)->GetWidthExp())) ? cMAX_N(temp0,temp1,NULL) : NULL;
8953  }
8954  case eXNOR: {
8955  CNode* temp0;
8956  CNode* temp1;
8957  CNode* temp2;
8958  return ((temp0=Arg<CNode*>(0)->GetWidthExp()) && (temp1=Arg<CNode*>(1)->GetWidthExp())) ? cMAX_N(temp0,temp1,NULL) : NULL;
8959  }
8960  case eSYSTASK_CALL: {
8961  CNode* temp0;
8962  CNode* temp1;
8963  CNode* temp2;
8964  return Systask::WidthExp(Arg<CSymbol*>(0),Arg<CNode*>(1));
8965  }
8966  case eFUNCTION_CALL: {
8967  CNode* temp0;
8968  CNode* temp1;
8969  CNode* temp2;
8970  return CFunction::WidthExp(Arg<CSymbol*>(0),Arg<CNode*>(1),Arg<CScope*>(2));
8971  }
8972  case eARRAY: {
8973  CNode* temp0;
8974  CNode* temp1;
8975  CNode* temp2;
8976  return Array::WidthExp(Arg<CNode*>(0),Arg<CNode*>(1));
8977  }
8978  case eNET_REF: {
8979  CNode* temp0;
8980  CNode* temp1;
8981  CNode* temp2;
8982  return Arg<CNet*>(0)->GetWidthExp();
8983  }
8984  case eVAR_REF: {
8985  CNode* temp0;
8986  CNode* temp1;
8987  CNode* temp2;
8988  return Arg<CVar*>(0)->GetWidthExp();
8989  }
8990  case ePARAM_REF: {
8991  CNode* temp0;
8992  CNode* temp1;
8993  CNode* temp2;
8994  return Arg<CParam*>(0)->GetWidthExp();
8995  }
8996  case ePORT_REF: {
8997  CNode* temp0;
8998  CNode* temp1;
8999  CNode* temp2;
9000  return Arg<CPortDir*>(0)->GetWidthExp();
9001  }
9002  case eFWD_REF: {
9003  CNode* temp0;
9004  CNode* temp1;
9005  CNode* temp2;
9006  return Arg<CFref*>(0)->GetWidthExp();
9007  }
9008  case eGENVAR_REF: {
9009  CNode* temp0;
9010  CNode* temp1;
9011  CNode* temp2;
9012  return Arg<CGenvar*>(0)->GetWidthExp();
9013  }
9014  case eENUM_REF: {
9015  CNode* temp0;
9016  CNode* temp1;
9017  CNode* temp2;
9018  return Arg<CEnum*>(0)->GetWidthExp();
9019  }
9020  case eTYPE_REF: {
9021  CNode* temp0;
9022  CNode* temp1;
9023  CNode* temp2;
9024  return cINT32(32);
9025  }
9026  case eRANGE: {
9027  CNode* temp0;
9028  CNode* temp1;
9029  CNode* temp2;
9030  return (1 && 1) ? cABSDIFFPLUS1_N(Arg<CNode*>(0)->Clone(),Arg<CNode*>(1)->Clone(),NULL) : NULL;
9031  }
9032  case eSLICE: {
9033  CNode* temp0;
9034  CNode* temp1;
9035  CNode* temp2;
9036  return (1 && 1) ? cABSDIFFPLUS1_N(Arg<CNode*>(0)->Clone(),Arg<CNode*>(1)->Clone(),NULL) : NULL;
9037  }
9038  case ePSLICE: {
9039  CNode* temp0;
9040  CNode* temp1;
9041  CNode* temp2;
9042  return Arg<CNode*>(1);
9043  }
9044  case eMSLICE: {
9045  CNode* temp0;
9046  CNode* temp1;
9047  CNode* temp2;
9048  return Arg<CNode*>(1);
9049  }
9050  case eCVRI: {
9051  CNode* temp0;
9052  CNode* temp1;
9053  CNode* temp2;
9054  return cINT32(32);
9055  }
9056  case eCVIR: {
9057  CNode* temp0;
9058  CNode* temp1;
9059  CNode* temp2;
9060  return NULL;
9061  }
9062  case eREP: {
9063  CNode* temp0;
9064  CNode* temp1;
9065  CNode* temp2;
9066  return (1 && (temp1=Arg<CNode*>(1)->GetWidthExp())) ? cMUL_N(Arg<CNode*>(0)->Clone(),temp1,NULL) : NULL;
9067  }
9068  case eCAT: {
9069  CNode* temp0;
9070  CNode* temp1;
9071  CNode* temp2;
9072  return ((temp0=Arg<CNode*>(0)->GetWidthExp()) && (temp1=Arg<CNode*>(1)->GetWidthExp())) ? cADD_N(temp0,temp1,NULL) : NULL;
9073  }
9074  case eUCAT: {
9075  CNode* temp0;
9076  CNode* temp1;
9077  CNode* temp2;
9078  return Arg<CNode*>(0)->GetWidthExp();
9079  }
9080  case eCOM: {
9081  CNode* temp0;
9082  CNode* temp1;
9083  CNode* temp2;
9084  return Arg<CNode*>(0)->GetWidthExp();
9085  }
9086  case eNEG: {
9087  CNode* temp0;
9088  CNode* temp1;
9089  CNode* temp2;
9090  return Arg<CNode*>(0)->GetWidthExp();
9091  }
9092  case ePLUS: {
9093  CNode* temp0;
9094  CNode* temp1;
9095  CNode* temp2;
9096  return Arg<CNode*>(0)->GetWidthExp();
9097  }
9098  case eNOT: {
9099  CNode* temp0;
9100  CNode* temp1;
9101  CNode* temp2;
9102  return cINT32(1);
9103  }
9104  case eGT: {
9105  CNode* temp0;
9106  CNode* temp1;
9107  CNode* temp2;
9108  return cINT32(1);
9109  }
9110  case eGE: {
9111  CNode* temp0;
9112  CNode* temp1;
9113  CNode* temp2;
9114  return cINT32(1);
9115  }
9116  case eLT: {
9117  CNode* temp0;
9118  CNode* temp1;
9119  CNode* temp2;
9120  return cINT32(1);
9121  }
9122  case eLE: {
9123  CNode* temp0;
9124  CNode* temp1;
9125  CNode* temp2;
9126  return cINT32(1);
9127  }
9128  case eLAND: {
9129  CNode* temp0;
9130  CNode* temp1;
9131  CNode* temp2;
9132  return cINT32(1);
9133  }
9134  case eLOR: {
9135  CNode* temp0;
9136  CNode* temp1;
9137  CNode* temp2;
9138  return cINT32(1);
9139  }
9140  case eCEQ: {
9141  CNode* temp0;
9142  CNode* temp1;
9143  CNode* temp2;
9144  return cINT32(1);
9145  }
9146  case eCNE: {
9147  CNode* temp0;
9148  CNode* temp1;
9149  CNode* temp2;
9150  return cINT32(1);
9151  }
9152  case eEQ: {
9153  CNode* temp0;
9154  CNode* temp1;
9155  CNode* temp2;
9156  return cINT32(1);
9157  }
9158  case eNE: {
9159  CNode* temp0;
9160  CNode* temp1;
9161  CNode* temp2;
9162  return cINT32(1);
9163  }
9164  case eRAND: {
9165  CNode* temp0;
9166  CNode* temp1;
9167  CNode* temp2;
9168  return cINT32(1);
9169  }
9170  case eRNAND: {
9171  CNode* temp0;
9172  CNode* temp1;
9173  CNode* temp2;
9174  return cINT32(1);
9175  }
9176  case eROR: {
9177  CNode* temp0;
9178  CNode* temp1;
9179  CNode* temp2;
9180  return cINT32(1);
9181  }
9182  case eRNOR: {
9183  CNode* temp0;
9184  CNode* temp1;
9185  CNode* temp2;
9186  return cINT32(1);
9187  }
9188  case eRXOR: {
9189  CNode* temp0;
9190  CNode* temp1;
9191  CNode* temp2;
9192  return cINT32(1);
9193  }
9194  case eRXNOR: {
9195  CNode* temp0;
9196  CNode* temp1;
9197  CNode* temp2;
9198  return cINT32(1);
9199  }
9200  case eHOOK: {
9201  CNode* temp0;
9202  CNode* temp1;
9203  CNode* temp2;
9204  return ((temp1=Arg<CNode*>(1)->GetWidthExp()) && (temp2=Arg<CNode*>(2)->GetWidthExp())) ? cMAX_N(temp1,temp2,NULL) : NULL;
9205  }
9206  case eMTM: {
9207  CNode* temp0;
9208  CNode* temp1;
9209  CNode* temp2;
9210  return ((temp0=Arg<CNode*>(0)->GetWidthExp()) && (temp1=Arg<CNode*>(1)->GetWidthExp()) && (temp2=Arg<CNode*>(2)->GetWidthExp())) ? cMAX_N(temp0,temp1,temp2,NULL) : NULL;
9211  }
9212  case eEXTERNAL_REF: {
9213  CNode* temp0;
9214  CNode* temp1;
9215  CNode* temp2;
9216  return External::WidthExp(Arg<CSymbol*>(0));
9217  }
9218  case eATTRIBUTE: {
9219  CNode* temp0;
9220  CNode* temp1;
9221  CNode* temp2;
9222  return cINT32(0);
9223  }
9224  case eMACRO_EXPR: {
9225  CNode* temp0;
9226  CNode* temp1;
9227  CNode* temp2;
9228  return Arg<CNode*>(1)->GetWidthExp();
9229  }
9230  case eMEMBER: {
9231  CNode* temp0;
9232  CNode* temp1;
9233  CNode* temp2;
9234  return Member::WidthExp(Arg<CNode*>(0),Arg<CSymbol*>(1));
9235  }
9236  case ePREINC: {
9237  CNode* temp0;
9238  CNode* temp1;
9239  CNode* temp2;
9240  return Arg<CNode*>(0)->GetWidthExp();
9241  }
9242  case ePOSTINC: {
9243  CNode* temp0;
9244  CNode* temp1;
9245  CNode* temp2;
9246  return Arg<CNode*>(0)->GetWidthExp();
9247  }
9248  case ePREDEC: {
9249  CNode* temp0;
9250  CNode* temp1;
9251  CNode* temp2;
9252  return Arg<CNode*>(0)->GetWidthExp();
9253  }
9254  case ePOSTDEC: {
9255  CNode* temp0;
9256  CNode* temp1;
9257  CNode* temp2;
9258  return Arg<CNode*>(0)->GetWidthExp();
9259  }
9260  case eCAST: {
9261  CNode* temp0;
9262  CNode* temp1;
9263  CNode* temp2;
9264  return Arg<CNode*>(0)->GetWidthExp();
9265  }
9266  case eASSIGNMENT_PATTERN: {
9267  CNode* temp0;
9268  CNode* temp1;
9269  CNode* temp2;
9270  return NULL;
9271  }
9272  case eDOLLAR: {
9273  CNode* temp0;
9274  CNode* temp1;
9275  CNode* temp2;
9276  return NULL;
9277  }
9278  default:
9279  MASSERT( FALSE );
9280  return NULL;
9281  }
9282 }
9283 
9284 /************************************************
9285  IsWidthEvaluateable
9286  - return true if expression width can be evaluated
9287 **************************************************/
9288 
9290 {
9291  switch( GetOp() ) {
9292  case eERROR:
9293  return FALSE;
9294  case eVCONSTANT:
9295  return Arg<CVector*>(0)->IsWidthEvaluateable();
9296  case eRCONSTANT:
9297  return FALSE;
9298  case eELIST:
9299  return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
9300  case eWIDTH:
9301  return Arg<CNode*>(0)->IsEvaluateable();
9302  case eSUB:
9303  return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
9304  case eMUL:
9305  return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
9306  case eDIV:
9307  return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
9308  case ePOW:
9309  return Arg<CNode*>(0)->IsWidthEvaluateable();
9310  case eADD:
9311  return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
9312  case eLSH:
9313  return Arg<CNode*>(0)->IsWidthEvaluateable();
9314  case eRSH:
9315  return Arg<CNode*>(0)->IsWidthEvaluateable();
9316  case eLSHA:
9317  return Arg<CNode*>(0)->IsWidthEvaluateable();
9318  case eRSHA:
9319  return Arg<CNode*>(0)->IsWidthEvaluateable();
9320  case eMOD:
9321  return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
9322  case eOR:
9323  return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
9324  case eAND:
9325  return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
9326  case eANDANDAND:
9327  return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
9328  case eXOR:
9329  return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
9330  case eXNOR:
9331  return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
9332  case eSYSTASK_CALL:
9333  return Systask::WidthEvaluateable(Arg<CSymbol*>(0),Arg<CNode*>(1));
9334  case eFUNCTION_CALL:
9335  return CFunction::WidthEvaluateable(Arg<CSymbol*>(0),Arg<CNode*>(1),Arg<CScope*>(2));
9336  case eARRAY:
9337  return Array::WidthEvaluateable(Arg<CNode*>(0),Arg<CNode*>(1));
9338  case eNET_REF:
9339  return Arg<CNet*>(0)->IsWidthEvaluateable();
9340  case eVAR_REF:
9341  return Arg<CVar*>(0)->IsWidthEvaluateable();
9342  case ePARAM_REF:
9343  return Arg<CParam*>(0)->IsWidthEvaluateable();
9344  case ePORT_REF:
9345  return Arg<CPortDir*>(0)->IsWidthEvaluateable();
9346  case eFWD_REF:
9347  return Arg<CFref*>(0)->IsWidthEvaluateable();
9348  case eGENVAR_REF:
9349  return Arg<CGenvar*>(0)->IsWidthEvaluateable();
9350  case eENUM_REF:
9351  return Arg<CEnum*>(0)->IsWidthEvaluateable();
9352  case eTYPE_REF:
9353  return TRUE;
9354  case eRANGE:
9355  return Arg<CNode*>(0)->IsEvaluateable() && Arg<CNode*>(1)->IsEvaluateable();
9356  case eSLICE:
9357  return Arg<CNode*>(0)->IsEvaluateable() && Arg<CNode*>(1)->IsEvaluateable();
9358  case ePSLICE:
9359  return Arg<CNode*>(1)->IsEvaluateable();
9360  case eMSLICE:
9361  return Arg<CNode*>(1)->IsEvaluateable();
9362  case eCVRI:
9363  return TRUE;
9364  case eCVIR:
9365  return FALSE;
9366  case eREP:
9367  return Arg<CNode*>(0)->IsEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
9368  case eCAT:
9369  return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
9370  case eUCAT:
9371  return Arg<CNode*>(0)->IsWidthEvaluateable();
9372  case eCOM:
9373  return Arg<CNode*>(0)->IsWidthEvaluateable();
9374  case eNEG:
9375  return Arg<CNode*>(0)->IsWidthEvaluateable();
9376  case ePLUS:
9377  return Arg<CNode*>(0)->IsWidthEvaluateable();
9378  case eNOT:
9379  return TRUE;
9380  case eGT:
9381  return TRUE;
9382  case eGE:
9383  return TRUE;
9384  case eLT:
9385  return TRUE;
9386  case eLE:
9387  return TRUE;
9388  case eLAND:
9389  return TRUE;
9390  case eLOR:
9391  return TRUE;
9392  case eCEQ:
9393  return TRUE;
9394  case eCNE:
9395  return TRUE;
9396  case eEQ:
9397  return TRUE;
9398  case eNE:
9399  return TRUE;
9400  case eRAND:
9401  return TRUE;
9402  case eRNAND:
9403  return TRUE;
9404  case eROR:
9405  return TRUE;
9406  case eRNOR:
9407  return TRUE;
9408  case eRXOR:
9409  return TRUE;
9410  case eRXNOR:
9411  return TRUE;
9412  case eHOOK:
9413  return Arg<CNode*>(1)->IsWidthEvaluateable() && Arg<CNode*>(2)->IsWidthEvaluateable();
9414  case eMTM:
9415  return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable() && Arg<CNode*>(2)->IsWidthEvaluateable();
9416  case eEXTERNAL_REF:
9417  return External::WidthEvaluateable(Arg<CSymbol*>(0));
9418  case eATTRIBUTE:
9419  return TRUE;
9420  case eMACRO_EXPR:
9421  return Arg<CNode*>(1)->IsWidthEvaluateable();
9422  case eMEMBER:
9423  return Member::WidthEvaluateable(Arg<CNode*>(0),Arg<CSymbol*>(1));
9424  case ePREINC:
9425  return Arg<CNode*>(0)->IsWidthEvaluateable();
9426  case ePOSTINC:
9427  return Arg<CNode*>(0)->IsWidthEvaluateable();
9428  case ePREDEC:
9429  return Arg<CNode*>(0)->IsWidthEvaluateable();
9430  case ePOSTDEC:
9431  return Arg<CNode*>(0)->IsWidthEvaluateable();
9432  case eCAST:
9433  return Arg<CNode*>(0)->IsWidthEvaluateable();
9434  case eASSIGNMENT_PATTERN:
9435  return FALSE;
9436  case eDOLLAR:
9437  return FALSE;
9438  default:
9439  MASSERT( FALSE );
9440  return 0;
9441  }
9442 }
9443 
9444 /************************************************
9445  IsNonX
9446  - return true if expression cannot be X(or Z)
9447  exclude any variable with attribute
9448  specified by exclude and optionally integers.
9449 **************************************************/
9450 
9451 int CNode::IsNonX( int integerIsNonX, char* exclude )
9452 {
9453  switch( GetOp() ) {
9454  case eERROR:
9455  return FALSE;
9456  case eVCONSTANT:
9457  return !Arg<CVector*>(0)->HasXZ();
9458  case eRCONSTANT:
9459  return TRUE;
9460  case eELIST:
9461  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9462  case eWIDTH:
9463  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9464  case eSUB:
9465  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9466  case eMUL:
9467  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9468  case eDIV:
9469  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9470  case ePOW:
9471  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9472  case eADD:
9473  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9474  case eLSH:
9475  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9476  case eRSH:
9477  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9478  case eLSHA:
9479  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9480  case eRSHA:
9481  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9482  case eMOD:
9483  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9484  case eOR:
9485  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9486  case eAND:
9487  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9488  case eANDANDAND:
9489  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9490  case eXOR:
9491  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9492  case eXNOR:
9493  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9494  case eSYSTASK_CALL:
9495  return FALSE;
9496  case eFUNCTION_CALL:
9497  return FALSE;
9498  case eARRAY:
9499  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9500  case eNET_REF:
9501  return Arg<CDecl*>(0)->HasAttribute( exclude ) ||
9502 
9503  (integerIsNonX && Arg<CDecl*>(0)->GetDataType()->GetVarDataType() == eINT);
9504  case eVAR_REF:
9505  return Arg<CDecl*>(0)->GetDataType()->GetTwoState() ||
9506 
9507  Arg<CDecl*>(0)->GetNodeType() == eR ||
9508 
9509  Arg<CDecl*>(0)->HasAttribute( exclude ) ||
9510 
9511  (integerIsNonX && Arg<CDecl*>(0)->GetDataType()->GetVarDataType() == eINTEGER);
9512  case ePARAM_REF:
9513  return TRUE;
9514  case ePORT_REF:
9515  return Arg<CDecl*>(0)->HasAttribute( exclude ) ||
9516 
9517  (integerIsNonX && Arg<CDecl*>(0)->GetDataType()->GetVarDataType() == eINT);
9518  case eFWD_REF:
9519  return FALSE;
9520  case eGENVAR_REF:
9521  return TRUE;
9522  case eENUM_REF:
9523  return Arg<CEnum*>(0)->GetExpression()->IsNonX( integerIsNonX, exclude );
9524  case eTYPE_REF:
9525  return TRUE;
9526  case eRANGE:
9527  return FALSE;
9528  case eSLICE:
9529  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9530  case ePSLICE:
9531  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9532  case eMSLICE:
9533  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9534  case eCVRI:
9535  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9536  case eCVIR:
9537  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9538  case eREP:
9539  return Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9540  case eCAT:
9541  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9542  case eUCAT:
9543  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9544  case eCOM:
9545  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9546  case eNEG:
9547  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9548  case ePLUS:
9549  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9550  case eNOT:
9551  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9552  case eGT:
9553  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9554  case eGE:
9555  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9556  case eLT:
9557  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9558  case eLE:
9559  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9560  case eLAND:
9561  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9562  case eLOR:
9563  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9564  case eCEQ:
9565  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9566  case eCNE:
9567  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9568  case eEQ:
9569  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9570  case eNE:
9571  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9572  case eRAND:
9573  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9574  case eRNAND:
9575  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9576  case eROR:
9577  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9578  case eRNOR:
9579  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9580  case eRXOR:
9581  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9582  case eRXNOR:
9583  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9584  case eHOOK:
9585  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(2)->IsNonX( integerIsNonX, exclude );
9586  case ePOSEDGE:
9587  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9588  case eNEGEDGE:
9589  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9590  case eEVOR:
9591  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9592  case eMTM:
9593  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(2)->IsNonX( integerIsNonX, exclude );
9594  case eEXTERNAL_REF:
9595  return FALSE;
9596  case eMACRO_EXPR:
9597  return Arg<CNode*>(1) ? Arg<CNode*>(1)->IsNonX(integerIsNonX, exclude) : FALSE;
9598  case eMEMBER:
9599  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9600  case ePREINC:
9601  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9602  case ePOSTINC:
9603  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9604  case ePREDEC:
9605  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9606  case ePOSTDEC:
9607  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9608  case eCAST:
9609  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9610  case eASSIGNMENT_PATTERN:
9611  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9612  case eDOLLAR:
9613  return FALSE;
9614  default:
9615  MASSERT( FALSE );
9616  return 0;
9617  }
9618 }
9619 
9620 /***********************************************
9621  Clone
9622  - clone a copy of this tree use
9623  stack)for storage
9624 ************************************************/
9625 
9627 {
9628  int nodeMask = 0;
9629  switch( GetOp() ) {
9630  case eERROR:
9631  nodeMask = 0;
9632  break;
9633  case eVCONSTANT:
9634  nodeMask = 0;
9635  break;
9636  case eRCONSTANT:
9637  nodeMask = 0;
9638  break;
9639  case eCOMMENT:
9640  nodeMask = 0;
9641  break;
9642  case eVRQ:
9643  nodeMask = 0;
9644  break;
9645  case ePRAGMA:
9646  nodeMask = 0;
9647  break;
9648  case eELIST:
9649  nodeMask = 3;
9650  break;
9651  case eWIDTH:
9652  nodeMask = 3;
9653  break;
9654  case eNOP:
9655  nodeMask = 0;
9656  break;
9657  case eSUB:
9658  nodeMask = 3;
9659  break;
9660  case eMUL:
9661  nodeMask = 3;
9662  break;
9663  case eDIV:
9664  nodeMask = 3;
9665  break;
9666  case ePOW:
9667  nodeMask = 3;
9668  break;
9669  case eADD:
9670  nodeMask = 3;
9671  break;
9672  case eLSH:
9673  nodeMask = 3;
9674  break;
9675  case eRSH:
9676  nodeMask = 3;
9677  break;
9678  case eLSHA:
9679  nodeMask = 3;
9680  break;
9681  case eRSHA:
9682  nodeMask = 3;
9683  break;
9684  case eMOD:
9685  nodeMask = 3;
9686  break;
9687  case eOR:
9688  nodeMask = 3;
9689  break;
9690  case eAND:
9691  nodeMask = 3;
9692  break;
9693  case eANDANDAND:
9694  nodeMask = 3;
9695  break;
9696  case eXOR:
9697  nodeMask = 3;
9698  break;
9699  case eXNOR:
9700  nodeMask = 3;
9701  break;
9702  case eINSTANCE_REF:
9703  nodeMask = 0;
9704  break;
9705  case eGATE_REF:
9706  nodeMask = 0;
9707  break;
9708  case eTASK_ENABLE:
9709  nodeMask = 2;
9710  break;
9711  case eSYSTASK_CALL:
9712  nodeMask = 2;
9713  break;
9714  case eTIMING_CALL:
9715  nodeMask = 2;
9716  break;
9717  case eFUNCTION_CALL:
9718  nodeMask = 2;
9719  break;
9720  case eARRAY:
9721  nodeMask = 3;
9722  break;
9723  case eNET_REF:
9724  nodeMask = 0;
9725  break;
9726  case eVAR_REF:
9727  nodeMask = 0;
9728  break;
9729  case ePARAM_REF:
9730  nodeMask = 0;
9731  break;
9732  case ePORT_REF:
9733  nodeMask = 0;
9734  break;
9735  case eFWD_REF:
9736  nodeMask = 0;
9737  break;
9738  case eGENVAR_REF:
9739  nodeMask = 0;
9740  break;
9741  case eENUM_REF:
9742  nodeMask = 0;
9743  break;
9744  case eTYPE_REF:
9745  nodeMask = 0;
9746  break;
9747  case eNET_DECL:
9748  nodeMask = 2;
9749  break;
9750  case eVAR_DECL:
9751  nodeMask = 2;
9752  break;
9753  case ePARAM_DECL:
9754  nodeMask = 0;
9755  break;
9756  case eSPECPARAM_DECL:
9757  nodeMask = 0;
9758  break;
9759  case ePORT_DECL:
9760  nodeMask = 0;
9761  break;
9762  case eGENVAR_DECL:
9763  nodeMask = 0;
9764  break;
9765  case eTYPEDEF_DECL:
9766  nodeMask = 0;
9767  break;
9768  case eLIST:
9769  nodeMask = 3;
9770  break;
9771  case eRANGE:
9772  nodeMask = 3;
9773  break;
9774  case eSLICE:
9775  nodeMask = 3;
9776  break;
9777  case ePSLICE:
9778  nodeMask = 3;
9779  break;
9780  case eMSLICE:
9781  nodeMask = 3;
9782  break;
9783  case eCVRI:
9784  nodeMask = 1;
9785  break;
9786  case eCVIR:
9787  nodeMask = 1;
9788  break;
9789  case eREP:
9790  nodeMask = 3;
9791  break;
9792  case eCAT:
9793  nodeMask = 3;
9794  break;
9795  case eUCAT:
9796  nodeMask = 1;
9797  break;
9798  case eCOM:
9799  nodeMask = 1;
9800  break;
9801  case eNEG:
9802  nodeMask = 1;
9803  break;
9804  case ePLUS:
9805  nodeMask = 1;
9806  break;
9807  case eNOT:
9808  nodeMask = 1;
9809  break;
9810  case eGT:
9811  nodeMask = 3;
9812  break;
9813  case eGE:
9814  nodeMask = 3;
9815  break;
9816  case eLT:
9817  nodeMask = 3;
9818  break;
9819  case eLE:
9820  nodeMask = 3;
9821  break;
9822  case eLAND:
9823  nodeMask = 3;
9824  break;
9825  case eLOR:
9826  nodeMask = 3;
9827  break;
9828  case eCEQ:
9829  nodeMask = 3;
9830  break;
9831  case eCNE:
9832  nodeMask = 3;
9833  break;
9834  case eEQ:
9835  nodeMask = 3;
9836  break;
9837  case eNE:
9838  nodeMask = 3;
9839  break;
9840  case eRAND:
9841  nodeMask = 1;
9842  break;
9843  case eRNAND:
9844  nodeMask = 1;
9845  break;
9846  case eROR:
9847  nodeMask = 1;
9848  break;
9849  case eRNOR:
9850  nodeMask = 1;
9851  break;
9852  case eRXOR:
9853  nodeMask = 1;
9854  break;
9855  case eRXNOR:
9856  nodeMask = 1;
9857  break;
9858  case eHOOK:
9859  nodeMask = 7;
9860  break;
9861  case eINIT:
9862  nodeMask = 1;
9863  break;
9864  case eALWAYS:
9865  nodeMask = 1;
9866  break;
9867  case eALWAYS_LATCH:
9868  nodeMask = 1;
9869  break;
9870  case eALWAYS_FF:
9871  nodeMask = 1;
9872  break;
9873  case eALWAYS_COMB:
9874  nodeMask = 1;
9875  break;
9876  case eEVENT:
9877  nodeMask = 3;
9878  break;
9879  case eBLOCK_REF:
9880  nodeMask = 2;
9881  break;
9882  case eSPECIFY_REF:
9883  nodeMask = 2;
9884  break;
9885  case eASSIGN:
9886  nodeMask = 7;
9887  break;
9888  case eGASSIGN:
9889  nodeMask = 6;
9890  break;
9891  case eADD_ASSIGN:
9892  nodeMask = 7;
9893  break;
9894  case eSUB_ASSIGN:
9895  nodeMask = 7;
9896  break;
9897  case eMUL_ASSIGN:
9898  nodeMask = 7;
9899  break;
9900  case eDIV_ASSIGN:
9901  nodeMask = 7;
9902  break;
9903  case eMOD_ASSIGN:
9904  nodeMask = 7;
9905  break;
9906  case eAND_ASSIGN:
9907  nodeMask = 7;
9908  break;
9909  case eOR_ASSIGN:
9910  nodeMask = 7;
9911  break;
9912  case eXOR_ASSIGN:
9913  nodeMask = 7;
9914  break;
9915  case eLSH_ASSIGN:
9916  nodeMask = 7;
9917  break;
9918  case eRSH_ASSIGN:
9919  nodeMask = 7;
9920  break;
9921  case eLSHA_ASSIGN:
9922  nodeMask = 7;
9923  break;
9924  case eRSHA_ASSIGN:
9925  nodeMask = 7;
9926  break;
9927  case eFORCE:
9928  nodeMask = 3;
9929  break;
9930  case eRELEASE:
9931  nodeMask = 1;
9932  break;
9933  case eNBASSIGN:
9934  nodeMask = 7;
9935  break;
9936  case ePOSEDGE:
9937  nodeMask = 1;
9938  break;
9939  case eNEGEDGE:
9940  nodeMask = 1;
9941  break;
9942  case eEDGE:
9943  nodeMask = 1;
9944  break;
9945  case eEVOR:
9946  nodeMask = 3;
9947  break;
9948  case eDELAY:
9949  nodeMask = 3;
9950  break;
9951  case eMTM:
9952  nodeMask = 7;
9953  break;
9954  case eIF:
9955  nodeMask = 7;
9956  break;
9957  case eFOREVER:
9958  nodeMask = 1;
9959  break;
9960  case eREPEAT:
9961  nodeMask = 3;
9962  break;
9963  case eWHILE:
9964  nodeMask = 3;
9965  break;
9966  case eWAIT:
9967  nodeMask = 3;
9968  break;
9969  case eFOR:
9970  nodeMask = 15;
9971  break;
9972  case eCASE:
9973  nodeMask = 3;
9974  break;
9975  case eCASEX:
9976  nodeMask = 3;
9977  break;
9978  case eCASEZ:
9979  nodeMask = 3;
9980  break;
9981  case eCASEITEM:
9982  nodeMask = 3;
9983  break;
9984  case eCASSIGN:
9985  nodeMask = 14;
9986  break;
9987  case eARG:
9988  nodeMask = 2;
9989  break;
9990  case eIMPORT:
9991  nodeMask = 0;
9992  break;
9993  case eFUNCTION_DEF:
9994  nodeMask = 0;
9995  break;
9996  case eMODULE_DEF:
9997  nodeMask = 0;
9998  break;
9999  case ePACKAGE_DEF:
10000  nodeMask = 0;
10001  break;
10002  case eREPEAT_CONTROL:
10003  nodeMask = 3;
10004  break;
10005  case eDELAY_CONTROL:
10006  nodeMask = 1;
10007  break;
10008  case eEVENT_CONTROL:
10009  nodeMask = 1;
10010  break;
10011  case eEXTERNAL_REF:
10012  nodeMask = 0;
10013  break;
10014  case ePORT_DEF:
10015  nodeMask = 0;
10016  break;
10017  case eDEFPARAM:
10018  nodeMask = 3;
10019  break;
10020  case ePATH:
10021  nodeMask = 82;
10022  break;
10023  case ePATH_ASSIGN:
10024  nodeMask = 7;
10025  break;
10026  case eIFNONE_PATH_ASSIGN:
10027  nodeMask = 3;
10028  break;
10029  case eTRIGGER:
10030  nodeMask = 1;
10031  break;
10032  case ePASSIGN:
10033  nodeMask = 3;
10034  break;
10035  case eDEASSIGN:
10036  nodeMask = 1;
10037  break;
10038  case eDISABLE:
10039  nodeMask = 0;
10040  break;
10041  case eATTRIBUTE:
10042  nodeMask = 0;
10043  break;
10044  case eGIF:
10045  nodeMask = 7;
10046  break;
10047  case eGFOR:
10048  nodeMask = 15;
10049  break;
10050  case eGCASE:
10051  nodeMask = 3;
10052  break;
10053  case eTABLE:
10054  nodeMask = 1;
10055  break;
10056  case eTABLE_ENTRY:
10057  nodeMask = 1;
10058  break;
10059  case eTABLE_SYMBOL:
10060  nodeMask = 0;
10061  break;
10062  case ePORTLIST_END:
10063  nodeMask = 0;
10064  break;
10065  case eMACRO_EXPR:
10066  nodeMask = 2;
10067  break;
10068  case eENUM_SPEC:
10069  nodeMask = 6;
10070  break;
10071  case eMEMBER:
10072  nodeMask = 1;
10073  break;
10074  case eRETURN:
10075  nodeMask = 1;
10076  break;
10077  case ePREINC:
10078  nodeMask = 1;
10079  break;
10080  case ePOSTINC:
10081  nodeMask = 1;
10082  break;
10083  case ePREDEC:
10084  nodeMask = 1;
10085  break;
10086  case ePOSTDEC:
10087  nodeMask = 1;
10088  break;
10089  case eCAST:
10090  nodeMask = 3;
10091  break;
10092  case eASSIGNMENT_PATTERN:
10093  nodeMask = 1;
10094  break;
10095  case eDOLLAR:
10096  nodeMask = 0;
10097  break;
10098  default:
10099  MASSERT( FALSE );
10100  }
10101 
10102  CNode* n = new(stack) CNode( &loc, op );
10103  n->width = width;
10104  n->type = type;
10105  n->fixedWidth = fixedWidth;
10106  if( attributes ) {
10107  n->attributes = attributes->Clone(heap);
10108  }
10109  for( int i = 0; i < ArgCount(); i++ ) {
10110  if( ((nodeMask>>i)&1) && Arg<CNode*>(i) ) {
10111  n->Arg<CNode*>(i) = Arg<CNode*>(i)->Clone(heap);
10112  } else {
10113  void* tmp = Arg<void*>(i);
10114  n->Arg<void*>(i) = tmp;
10115  }
10116  }
10117  return n;
10118 }
10119 
10120 
10121 /***********************************************
10122  PreVisit1
10123  - traverse tree, evoking
10124  parent then leaves.
10125  Callback may terminate traversal of subtree early.
10126 ************************************************/
10127 
10128 void CNode::PreVisit1( int (*func)(CNode*, void*), void* data )
10129 {
10130  if( !(*func)( this, data ) ) {
10131  return;
10132  }
10133 
10134  if( GetAttributes() ) {
10135  GetAttributes()->PreVisit1( func, data );
10136  }
10137 
10138  int nodeMask = 0;
10139  switch( GetOp() ) {
10140  case eERROR:
10141  nodeMask = 0;
10142  break;
10143  case eVCONSTANT:
10144  nodeMask = 1;
10145  break;
10146  case eRCONSTANT:
10147  nodeMask = 1;
10148  break;
10149  case eCOMMENT:
10150  nodeMask = 1;
10151  break;
10152  case eVRQ:
10153  nodeMask = 1;
10154  break;
10155  case ePRAGMA:
10156  nodeMask = 3;
10157  break;
10158  case eELIST:
10159  nodeMask = 0;
10160  break;
10161  case eWIDTH:
10162  nodeMask = 0;
10163  break;
10164  case eNOP:
10165  nodeMask = 0;
10166  break;
10167  case eSUB:
10168  nodeMask = 0;
10169  break;
10170  case eMUL:
10171  nodeMask = 0;
10172  break;
10173  case eDIV:
10174  nodeMask = 0;
10175  break;
10176  case ePOW:
10177  nodeMask = 0;
10178  break;
10179  case eADD:
10180  nodeMask = 0;
10181  break;
10182  case eLSH:
10183  nodeMask = 0;
10184  break;
10185  case eRSH:
10186  nodeMask = 0;
10187  break;
10188  case eLSHA:
10189  nodeMask = 0;
10190  break;
10191  case eRSHA:
10192  nodeMask = 0;
10193  break;
10194  case eMOD:
10195  nodeMask = 0;
10196  break;
10197  case eOR:
10198  nodeMask = 0;
10199  break;
10200  case eAND:
10201  nodeMask = 0;
10202  break;
10203  case eANDANDAND:
10204  nodeMask = 0;
10205  break;
10206  case eXOR:
10207  nodeMask = 0;
10208  break;
10209  case eXNOR:
10210  nodeMask = 0;
10211  break;
10212  case eINSTANCE_REF:
10213  nodeMask = 1;
10214  if(Arg<CInstance*>(0)) Arg<CInstance*>(0)->PreVisit1( func, data );
10215  break;
10216  case eGATE_REF:
10217  nodeMask = 1;
10218  if(Arg<CGate*>(0)) Arg<CGate*>(0)->PreVisit1( func, data );
10219  break;
10220  case eTASK_ENABLE:
10221  nodeMask = 1;
10222  break;
10223  case eSYSTASK_CALL:
10224  nodeMask = 1;
10225  break;
10226  case eTIMING_CALL:
10227  nodeMask = 1;
10228  break;
10229  case eFUNCTION_CALL:
10230  nodeMask = 5;
10231  break;
10232  case eARRAY:
10233  nodeMask = 0;
10234  break;
10235  case eNET_REF:
10236  return;
10237  case eVAR_REF:
10238  return;
10239  case ePARAM_REF:
10240  return;
10241  case ePORT_REF:
10242  return;
10243  case eFWD_REF:
10244  return;
10245  case eGENVAR_REF:
10246  return;
10247  case eENUM_REF:
10248  return;
10249  case eTYPE_REF:
10250  return;
10251  case eNET_DECL:
10252  nodeMask = 1;
10253  if(Arg<CNet*>(0)) Arg<CNet*>(0)->PreVisit1( func, data );
10254  break;
10255  case eVAR_DECL:
10256  nodeMask = 1;
10257  if(Arg<CVar*>(0)) Arg<CVar*>(0)->PreVisit1( func, data );
10258  break;
10259  case ePARAM_DECL:
10260  nodeMask = 1;
10261  if(Arg<CParam*>(0)) Arg<CParam*>(0)->PreVisit1( func, data );
10262  break;
10263  case eSPECPARAM_DECL:
10264  nodeMask = 1;
10265  if(Arg<CParam*>(0)) Arg<CParam*>(0)->PreVisit1( func, data );
10266  break;
10267  case ePORT_DECL:
10268  nodeMask = 1;
10269  if(Arg<CPortDir*>(0)) Arg<CPortDir*>(0)->PreVisit1( func, data );
10270  break;
10271  case eGENVAR_DECL:
10272  nodeMask = 1;
10273  if(Arg<CGenvar*>(0)) Arg<CGenvar*>(0)->PreVisit1( func, data );
10274  break;
10275  case eTYPEDEF_DECL:
10276  nodeMask = 1;
10277  if(Arg<CTypedef*>(0)) Arg<CTypedef*>(0)->PreVisit1( func, data );
10278  break;
10279  case eLIST:
10280  nodeMask = 0;
10281  break;
10282  case eRANGE:
10283  nodeMask = 0;
10284  break;
10285  case eSLICE:
10286  nodeMask = 0;
10287  break;
10288  case ePSLICE:
10289  nodeMask = 0;
10290  break;
10291  case eMSLICE:
10292  nodeMask = 0;
10293  break;
10294  case eCVRI:
10295  nodeMask = 0;
10296  break;
10297  case eCVIR:
10298  nodeMask = 0;
10299  break;
10300  case eREP:
10301  nodeMask = 0;
10302  break;
10303  case eCAT:
10304  nodeMask = 0;
10305  break;
10306  case eUCAT:
10307  nodeMask = 0;
10308  break;
10309  case eCOM:
10310  nodeMask = 0;
10311  break;
10312  case eNEG:
10313  nodeMask = 0;
10314  break;
10315  case ePLUS:
10316  nodeMask = 0;
10317  break;
10318  case eNOT:
10319  nodeMask = 0;
10320  break;
10321  case eGT:
10322  nodeMask = 0;
10323  break;
10324  case eGE:
10325  nodeMask = 0;
10326  break;
10327  case eLT:
10328  nodeMask = 0;
10329  break;
10330  case eLE:
10331  nodeMask = 0;
10332  break;
10333  case eLAND:
10334  nodeMask = 0;
10335  break;
10336  case eLOR:
10337  nodeMask = 0;
10338  break;
10339  case eCEQ:
10340  nodeMask = 0;
10341  break;
10342  case eCNE:
10343  nodeMask = 0;
10344  break;
10345  case eEQ:
10346  nodeMask = 0;
10347  break;
10348  case eNE:
10349  nodeMask = 0;
10350  break;
10351  case eRAND:
10352  nodeMask = 0;
10353  break;
10354  case eRNAND:
10355  nodeMask = 0;
10356  break;
10357  case eROR:
10358  nodeMask = 0;
10359  break;
10360  case eRNOR:
10361  nodeMask = 0;
10362  break;
10363  case eRXOR:
10364  nodeMask = 0;
10365  break;
10366  case eRXNOR:
10367  nodeMask = 0;
10368  break;
10369  case eHOOK:
10370  nodeMask = 0;
10371  break;
10372  case eINIT:
10373  nodeMask = 0;
10374  break;
10375  case eALWAYS:
10376  nodeMask = 0;
10377  break;
10378  case eALWAYS_LATCH:
10379  nodeMask = 0;
10380  break;
10381  case eALWAYS_FF:
10382  nodeMask = 0;
10383  break;
10384  case eALWAYS_COMB:
10385  nodeMask = 0;
10386  break;
10387  case eEVENT:
10388  nodeMask = 0;
10389  break;
10390  case eBLOCK_REF:
10391  nodeMask = 5;
10392  if(Arg<CBlock*>(0)) Arg<CBlock*>(0)->PreVisit1( func, data );
10393  break;
10394  case eSPECIFY_REF:
10395  nodeMask = 1;
10396  if(Arg<CSpecify*>(0)) Arg<CSpecify*>(0)->PreVisit1( func, data );
10397  break;
10398  case eASSIGN:
10399  nodeMask = 0;
10400  break;
10401  case eGASSIGN:
10402  nodeMask = 1;
10403  break;
10404  case eADD_ASSIGN:
10405  nodeMask = 0;
10406  break;
10407  case eSUB_ASSIGN:
10408  nodeMask = 0;
10409  break;
10410  case eMUL_ASSIGN:
10411  nodeMask = 0;
10412  break;
10413  case eDIV_ASSIGN:
10414  nodeMask = 0;
10415  break;
10416  case eMOD_ASSIGN:
10417  nodeMask = 0;
10418  break;
10419  case eAND_ASSIGN:
10420  nodeMask = 0;
10421  break;
10422  case eOR_ASSIGN:
10423  nodeMask = 0;
10424  break;
10425  case eXOR_ASSIGN:
10426  nodeMask = 0;
10427  break;
10428  case eLSH_ASSIGN:
10429  nodeMask = 0;
10430  break;
10431  case eRSH_ASSIGN:
10432  nodeMask = 0;
10433  break;
10434  case eLSHA_ASSIGN:
10435  nodeMask = 0;
10436  break;
10437  case eRSHA_ASSIGN:
10438  nodeMask = 0;
10439  break;
10440  case eFORCE:
10441  nodeMask = 0;
10442  break;
10443  case eRELEASE:
10444  nodeMask = 0;
10445  break;
10446  case eNBASSIGN:
10447  nodeMask = 0;
10448  break;
10449  case ePOSEDGE:
10450  nodeMask = 0;
10451  break;
10452  case eNEGEDGE:
10453  nodeMask = 0;
10454  break;
10455  case eEDGE:
10456  nodeMask = 2;
10457  break;
10458  case eEVOR:
10459  nodeMask = 0;
10460  break;
10461  case eDELAY:
10462  nodeMask = 0;
10463  break;
10464  case eMTM:
10465  nodeMask = 0;
10466  break;
10467  case eIF:
10468  nodeMask = 8;
10469  break;
10470  case eFOREVER:
10471  nodeMask = 0;
10472  break;
10473  case eREPEAT:
10474  nodeMask = 0;
10475  break;
10476  case eWHILE:
10477  nodeMask = 0;
10478  break;
10479  case eWAIT:
10480  nodeMask = 0;
10481  break;
10482  case eFOR:
10483  nodeMask = 0;
10484  break;
10485  case eCASE:
10486  nodeMask = 4;
10487  break;
10488  case eCASEX:
10489  nodeMask = 4;
10490  break;
10491  case eCASEZ:
10492  nodeMask = 4;
10493  break;
10494  case eCASEITEM:
10495  nodeMask = 0;
10496  break;
10497  case eCASSIGN:
10498  nodeMask = 1;
10499  break;
10500  case eARG:
10501  nodeMask = 1;
10502  break;
10503  case eIMPORT:
10504  nodeMask = 1;
10505  break;
10506  case eFUNCTION_DEF:
10507  nodeMask = 1;
10508  if(Arg<CFunction*>(0)) Arg<CFunction*>(0)->PreVisit1( func, data );
10509  break;
10510  case eMODULE_DEF:
10511  nodeMask = 1;
10512  if(Arg<CModule*>(0)) Arg<CModule*>(0)->PreVisit1( func, data );
10513  break;
10514  case ePACKAGE_DEF:
10515  nodeMask = 1;
10516  if(Arg<CPackage*>(0)) Arg<CPackage*>(0)->PreVisit1( func, data );
10517  break;
10518  case eREPEAT_CONTROL:
10519  nodeMask = 0;
10520  break;
10521  case eDELAY_CONTROL:
10522  nodeMask = 0;
10523  break;
10524  case eEVENT_CONTROL:
10525  nodeMask = 0;
10526  break;
10527  case eEXTERNAL_REF:
10528  nodeMask = 1;
10529  break;
10530  case ePORT_DEF:
10531  nodeMask = 1;
10532  if(Arg<CPort*>(0)) Arg<CPort*>(0)->PreVisit1( func, data );
10533  break;
10534  case eDEFPARAM:
10535  nodeMask = 0;
10536  break;
10537  case ePATH:
10538  nodeMask = 45;
10539  break;
10540  case ePATH_ASSIGN:
10541  nodeMask = 0;
10542  break;
10543  case eIFNONE_PATH_ASSIGN:
10544  nodeMask = 0;
10545  break;
10546  case eTRIGGER:
10547  nodeMask = 0;
10548  break;
10549  case ePASSIGN:
10550  nodeMask = 0;
10551  break;
10552  case eDEASSIGN:
10553  nodeMask = 0;
10554  break;
10555  case eDISABLE:
10556  nodeMask = 1;
10557  break;
10558  case eATTRIBUTE:
10559  nodeMask = 1;
10560  if(Arg<CAttr*>(0)) Arg<CAttr*>(0)->PreVisit1( func, data );
10561  break;
10562  case eGIF:
10563  nodeMask = 0;
10564  break;
10565  case eGFOR:
10566  nodeMask = 0;
10567  break;
10568  case eGCASE:
10569  nodeMask = 0;
10570  break;
10571  case eTABLE:
10572  nodeMask = 0;
10573  break;
10574  case eTABLE_ENTRY:
10575  nodeMask = 0;
10576  break;
10577  case eTABLE_SYMBOL:
10578  nodeMask = 1;
10579  break;
10580  case ePORTLIST_END:
10581  nodeMask = 0;
10582  break;
10583  case eMACRO_EXPR:
10584  nodeMask = 1;
10585  break;
10586  case eENUM_SPEC:
10587  nodeMask = 1;
10588  break;
10589  case eMEMBER:
10590  nodeMask = 2;
10591  break;
10592  case eRETURN:
10593  nodeMask = 0;
10594  break;
10595  case ePREINC:
10596  nodeMask = 0;
10597  break;
10598  case ePOSTINC:
10599  nodeMask = 0;
10600  break;
10601  case ePREDEC:
10602  nodeMask = 0;
10603  break;
10604  case ePOSTDEC:
10605  nodeMask = 0;
10606  break;
10607  case eCAST:
10608  nodeMask = 0;
10609  break;
10610  case eASSIGNMENT_PATTERN:
10611  nodeMask = 0;
10612  break;
10613  case eDOLLAR:
10614  nodeMask = 0;
10615  break;
10616  }
10617 
10618  /*
10619  * special case LIST nodes for tail recursion optimizations
10620  */
10621  if( GetOp() != eLIST ) {
10622  for( int i = 0; i < ArgCount(); i++ ) {
10623  if( Arg<CNode*>(i) && !((nodeMask>>i)&1) ) Arg<CNode*>(i)->PreVisit1( func, data );
10624  }
10625  } else {
10626  CNode* n = this;
10627  while( 1 ) {
10628  if( n->Arg<CNode*>(0) ) {
10629  n->Arg<CNode*>(0)->PreVisit1( func, data );
10630  }
10631  if( !n->Arg<CNode*>(1) || n->Arg<CNode*>(1)->GetOp() != eLIST ) {
10632  break;
10633  }
10634  n = n->Arg<CNode*>(1);
10635  if( !(*func)( n, data ) ) {
10636  return;
10637  }
10638  if( n->GetAttributes() ) {
10639  n->GetAttributes()->PreVisit1( func, data );
10640  }
10641  }
10642  if( n->Arg<CNode*>(1) ) {
10643  n->Arg<CNode*>(1)->PreVisit1( func, data );
10644  }
10645  }
10646 }
10647 
10648 
10649 /***********************************************
10650  PostVisit1
10651  - traverse tree, evoking
10652  leaves then parent.
10653 ************************************************/
10654 void CNode::PostVisit1( void (*func)(CNode*, void*), void* data )
10655 {
10656  if( GetAttributes() ) {
10657  GetAttributes()->PostVisit1( func, data );
10658  }
10659 
10660  int nodeMask = 0;
10661  switch( GetOp() ) {
10662  case eERROR:
10663  nodeMask = 0;
10664  break;
10665  case eVCONSTANT:
10666  nodeMask = 1;
10667  break;
10668  case eRCONSTANT:
10669  nodeMask = 1;
10670  break;
10671  case eCOMMENT:
10672  nodeMask = 1;
10673  break;
10674  case eVRQ:
10675  nodeMask = 1;
10676  break;
10677  case ePRAGMA:
10678  nodeMask = 3;
10679  break;
10680  case eELIST:
10681  nodeMask = 0;
10682  break;
10683  case eWIDTH:
10684  nodeMask = 0;
10685  break;
10686  case eNOP:
10687  nodeMask = 0;
10688  break;
10689  case eSUB:
10690  nodeMask = 0;
10691  break;
10692  case eMUL:
10693  nodeMask = 0;
10694  break;
10695  case eDIV:
10696  nodeMask = 0;
10697  break;
10698  case ePOW:
10699  nodeMask = 0;
10700  break;
10701  case eADD:
10702  nodeMask = 0;
10703  break;
10704  case eLSH:
10705  nodeMask = 0;
10706  break;
10707  case eRSH:
10708  nodeMask = 0;
10709  break;
10710  case eLSHA:
10711  nodeMask = 0;
10712  break;
10713  case eRSHA:
10714  nodeMask = 0;
10715  break;
10716  case eMOD:
10717  nodeMask = 0;
10718  break;
10719  case eOR:
10720  nodeMask = 0;
10721  break;
10722  case eAND:
10723  nodeMask = 0;
10724  break;
10725  case eANDANDAND:
10726  nodeMask = 0;
10727  break;
10728  case eXOR:
10729  nodeMask = 0;
10730  break;
10731  case eXNOR:
10732  nodeMask = 0;
10733  break;
10734  case eINSTANCE_REF:
10735  nodeMask = 1;
10736  if(Arg<CInstance*>(0)) Arg<CInstance*>(0)->PostVisit1( func, data );
10737  break;
10738  case eGATE_REF:
10739  nodeMask = 1;
10740  if(Arg<CGate*>(0)) Arg<CGate*>(0)->PostVisit1( func, data );
10741  break;
10742  case eTASK_ENABLE:
10743  nodeMask = 1;
10744  break;
10745  case eSYSTASK_CALL:
10746  nodeMask = 1;
10747  break;
10748  case eTIMING_CALL:
10749  nodeMask = 1;
10750  break;
10751  case eFUNCTION_CALL:
10752  nodeMask = 5;
10753  break;
10754  case eARRAY:
10755  nodeMask = 0;
10756  break;
10757  case eNET_REF:
10758  nodeMask = ~0;
10759  break;
10760  case eVAR_REF:
10761  nodeMask = ~0;
10762  break;
10763  case ePARAM_REF:
10764  nodeMask = ~0;
10765  break;
10766  case ePORT_REF:
10767  nodeMask = ~0;
10768  break;
10769  case eFWD_REF:
10770  nodeMask = ~0;
10771  break;
10772  case eGENVAR_REF:
10773  nodeMask = ~0;
10774  break;
10775  case eENUM_REF:
10776  nodeMask = ~0;
10777  break;
10778  case eTYPE_REF:
10779  nodeMask = ~0;
10780  break;
10781  case eNET_DECL:
10782  nodeMask = 1;
10783  if(Arg<CNet*>(0)) Arg<CNet*>(0)->PostVisit1( func, data );
10784  break;
10785  case eVAR_DECL:
10786  nodeMask = 1;
10787  if(Arg<CVar*>(0)) Arg<CVar*>(0)->PostVisit1( func, data );
10788  break;
10789  case ePARAM_DECL:
10790  nodeMask = 1;
10791  if(Arg<CParam*>(0)) Arg<CParam*>(0)->PostVisit1( func, data );
10792  break;
10793  case eSPECPARAM_DECL:
10794  nodeMask = 1;
10795  if(Arg<CParam*>(0)) Arg<CParam*>(0)->PostVisit1( func, data );
10796  break;
10797  case ePORT_DECL:
10798  nodeMask = 1;
10799  if(Arg<CPortDir*>(0)) Arg<CPortDir*>(0)->PostVisit1( func, data );
10800  break;
10801  case eGENVAR_DECL:
10802  nodeMask = 1;
10803  if(Arg<CGenvar*>(0)) Arg<CGenvar*>(0)->PostVisit1( func, data );
10804  break;
10805  case eTYPEDEF_DECL:
10806  nodeMask = 1;
10807  if(Arg<CTypedef*>(0)) Arg<CTypedef*>(0)->PostVisit1( func, data );
10808  break;
10809  case eLIST:
10810  nodeMask = 0;
10811  break;
10812  case eRANGE:
10813  nodeMask = 0;
10814  break;
10815  case eSLICE:
10816  nodeMask = 0;
10817  break;
10818  case ePSLICE:
10819  nodeMask = 0;
10820  break;
10821  case eMSLICE:
10822  nodeMask = 0;
10823  break;
10824  case eCVRI:
10825  nodeMask = 0;
10826  break;
10827  case eCVIR:
10828  nodeMask = 0;
10829  break;
10830  case eREP:
10831  nodeMask = 0;
10832  break;
10833  case eCAT:
10834  nodeMask = 0;
10835  break;
10836  case eUCAT:
10837  nodeMask = 0;
10838  break;
10839  case eCOM:
10840  nodeMask = 0;
10841  break;
10842  case eNEG:
10843  nodeMask = 0;
10844  break;
10845  case ePLUS:
10846  nodeMask = 0;
10847  break;
10848  case eNOT:
10849  nodeMask = 0;
10850  break;
10851  case eGT:
10852  nodeMask = 0;
10853  break;
10854  case eGE:
10855  nodeMask = 0;
10856  break;
10857  case eLT:
10858  nodeMask = 0;
10859  break;
10860  case eLE:
10861  nodeMask = 0;
10862  break;
10863  case eLAND:
10864  nodeMask = 0;
10865  break;
10866  case eLOR:
10867  nodeMask = 0;
10868  break;
10869  case eCEQ:
10870  nodeMask = 0;
10871  break;
10872  case eCNE:
10873  nodeMask = 0;
10874  break;
10875  case eEQ:
10876  nodeMask = 0;
10877  break;
10878  case eNE:
10879  nodeMask = 0;
10880  break;
10881  case eRAND:
10882  nodeMask = 0;
10883  break;
10884  case eRNAND:
10885  nodeMask = 0;
10886  break;
10887  case eROR:
10888  nodeMask = 0;
10889  break;
10890  case eRNOR:
10891  nodeMask = 0;
10892  break;
10893  case eRXOR:
10894  nodeMask = 0;
10895  break;
10896  case eRXNOR:
10897  nodeMask = 0;
10898  break;
10899  case eHOOK:
10900  nodeMask = 0;
10901  break;
10902  case eINIT:
10903  nodeMask = 0;
10904  break;
10905  case eALWAYS:
10906  nodeMask = 0;
10907  break;
10908  case eALWAYS_LATCH:
10909  nodeMask = 0;
10910  break;
10911  case eALWAYS_FF:
10912  nodeMask = 0;
10913  break;
10914  case eALWAYS_COMB:
10915  nodeMask = 0;
10916  break;
10917  case eEVENT:
10918  nodeMask = 0;
10919  break;
10920  case eBLOCK_REF:
10921  nodeMask = 5;
10922  if(Arg<CBlock*>(0)) Arg<CBlock*>(0)->PostVisit1( func, data );
10923  break;
10924  case eSPECIFY_REF:
10925  nodeMask = 1;
10926  if(Arg<CSpecify*>(0)) Arg<CSpecify*>(0)->PostVisit1( func, data );
10927  break;
10928  case eASSIGN:
10929  nodeMask = 0;
10930  break;
10931  case eGASSIGN:
10932  nodeMask = 1;
10933  break;
10934  case eADD_ASSIGN:
10935  nodeMask = 0;
10936  break;
10937  case eSUB_ASSIGN:
10938  nodeMask = 0;
10939  break;
10940  case eMUL_ASSIGN:
10941  nodeMask = 0;
10942  break;
10943  case eDIV_ASSIGN:
10944  nodeMask = 0;
10945  break;
10946  case eMOD_ASSIGN:
10947  nodeMask = 0;
10948  break;
10949  case eAND_ASSIGN:
10950  nodeMask = 0;
10951  break;
10952  case eOR_ASSIGN:
10953  nodeMask = 0;
10954  break;
10955  case eXOR_ASSIGN:
10956  nodeMask = 0;
10957  break;
10958  case eLSH_ASSIGN:
10959  nodeMask = 0;
10960  break;
10961  case eRSH_ASSIGN:
10962  nodeMask = 0;
10963  break;
10964  case eLSHA_ASSIGN:
10965  nodeMask = 0;
10966  break;
10967  case eRSHA_ASSIGN:
10968  nodeMask = 0;
10969  break;
10970  case eFORCE:
10971  nodeMask = 0;
10972  break;
10973  case eRELEASE:
10974  nodeMask = 0;
10975  break;
10976  case eNBASSIGN:
10977  nodeMask = 0;
10978  break;
10979  case ePOSEDGE:
10980  nodeMask = 0;
10981  break;
10982  case eNEGEDGE:
10983  nodeMask = 0;
10984  break;
10985  case eEDGE:
10986  nodeMask = 2;
10987  break;
10988  case eEVOR:
10989  nodeMask = 0;
10990  break;
10991  case eDELAY:
10992  nodeMask = 0;
10993  break;
10994  case eMTM:
10995  nodeMask = 0;
10996  break;
10997  case eIF:
10998  nodeMask = 8;
10999  break;
11000  case eFOREVER:
11001  nodeMask = 0;
11002  break;
11003  case eREPEAT:
11004  nodeMask = 0;
11005  break;
11006  case eWHILE:
11007  nodeMask = 0;
11008  break;
11009  case eWAIT:
11010  nodeMask = 0;
11011  break;
11012  case eFOR:
11013  nodeMask = 0;
11014  break;
11015  case eCASE:
11016  nodeMask = 4;
11017  break;
11018  case eCASEX:
11019  nodeMask = 4;
11020  break;
11021  case eCASEZ:
11022  nodeMask = 4;
11023  break;
11024  case eCASEITEM:
11025  nodeMask = 0;
11026  break;
11027  case eCASSIGN:
11028  nodeMask = 1;
11029  break;
11030  case eARG:
11031  nodeMask = 1;
11032  break;
11033  case eIMPORT:
11034  nodeMask = 1;
11035  break;
11036  case eFUNCTION_DEF:
11037  nodeMask = 1;
11038  if(Arg<CFunction*>(0)) Arg<CFunction*>(0)->PostVisit1( func, data );
11039  break;
11040  case eMODULE_DEF:
11041  nodeMask = 1;
11042  if(Arg<CModule*>(0)) Arg<CModule*>(0)->PostVisit1( func, data );
11043  break;
11044  case ePACKAGE_DEF:
11045  nodeMask = 1;
11046  if(Arg<CPackage*>(0)) Arg<CPackage*>(0)->PostVisit1( func, data );
11047  break;
11048  case eREPEAT_CONTROL:
11049  nodeMask = 0;
11050  break;
11051  case eDELAY_CONTROL:
11052  nodeMask = 0;
11053  break;
11054  case eEVENT_CONTROL:
11055  nodeMask = 0;
11056  break;
11057  case eEXTERNAL_REF:
11058  nodeMask = 1;
11059  break;
11060  case ePORT_DEF:
11061  nodeMask = 1;
11062  if(Arg<CPort*>(0)) Arg<CPort*>(0)->PostVisit1( func, data );
11063  break;
11064  case eDEFPARAM:
11065  nodeMask = 0;
11066  break;
11067  case ePATH:
11068  nodeMask = 45;
11069  break;
11070  case ePATH_ASSIGN:
11071  nodeMask = 0;
11072  break;
11073  case eIFNONE_PATH_ASSIGN:
11074  nodeMask = 0;
11075  break;
11076  case eTRIGGER:
11077  nodeMask = 0;
11078  break;
11079  case ePASSIGN:
11080  nodeMask = 0;
11081  break;
11082  case eDEASSIGN:
11083  nodeMask = 0;
11084  break;
11085  case eDISABLE:
11086  nodeMask = 1;
11087  break;
11088  case eATTRIBUTE:
11089  nodeMask = 1;
11090  if(Arg<CAttr*>(0)) Arg<CAttr*>(0)->PostVisit1( func, data );
11091  break;
11092  case eGIF:
11093  nodeMask = 0;
11094  break;
11095  case eGFOR:
11096  nodeMask = 0;
11097  break;
11098  case eGCASE:
11099  nodeMask = 0;
11100  break;
11101  case eTABLE:
11102  nodeMask = 0;
11103  break;
11104  case eTABLE_ENTRY:
11105  nodeMask = 0;
11106  break;
11107  case eTABLE_SYMBOL:
11108  nodeMask = 1;
11109  break;
11110  case ePORTLIST_END:
11111  nodeMask = 0;
11112  break;
11113  case eMACRO_EXPR:
11114  nodeMask = 1;
11115  break;
11116  case eENUM_SPEC:
11117  nodeMask = 1;
11118  break;
11119  case eMEMBER:
11120  nodeMask = 2;
11121  break;
11122  case eRETURN:
11123  nodeMask = 0;
11124  break;
11125  case ePREINC:
11126  nodeMask = 0;
11127  break;
11128  case ePOSTINC:
11129  nodeMask = 0;
11130  break;
11131  case ePREDEC:
11132  nodeMask = 0;
11133  break;
11134  case ePOSTDEC:
11135  nodeMask = 0;
11136  break;
11137  case eCAST:
11138  nodeMask = 0;
11139  break;
11140  case eASSIGNMENT_PATTERN:
11141  nodeMask = 0;
11142  break;
11143  case eDOLLAR:
11144  nodeMask = 0;
11145  break;
11146  }
11147 
11148  /*
11149  * special case LIST nodes for tail recursion optimizations
11150  */
11151  if( GetOp() != eLIST ) {
11152  for( int i = 0; i < ArgCount(); i++ ) {
11153  if( Arg<CNode*>(i) && !((nodeMask>>i)&1) ) Arg<CNode*>(i)->PostVisit1( func, data );
11154  }
11155  } else {
11156  std::stack<CNode*> visitLog;
11157  CNode* n = this;
11158  while( 1 ) {
11159  if( n->Arg<CNode*>(0) ) {
11160  n->Arg<CNode*>(0)-> PostVisit1( func, data );
11161  }
11162  if( !n->Arg<CNode*>(1) || n->Arg<CNode*>(1)->GetOp() != eLIST ) {
11163  break;
11164  }
11165  visitLog.push(n);
11166  n = n->Arg<CNode*>(1);
11167  if( n->GetAttributes() ) {
11168  n->GetAttributes()->PostVisit1( func, data );
11169  }
11170  }
11171  if( n->Arg<CNode*>(1) ) {
11172  n->Arg<CNode*>(1)->PostVisit1( func, data );
11173  }
11174  while( !visitLog.empty() ) {
11175  CNode* top = visitLog.top();
11176  if( top->Arg<CNode*>(1) ) {
11177  (*func)(top->Arg<CNode*>(1),data);
11178  }
11179  visitLog.pop();
11180  }
11181  }
11182 
11183  (*func)( this, data );
11184 }
11185 
11186 /***********************************************
11187  PostSubVisit1
11188  - traverse tree, evoking
11189  leaves then parents, substituting
11190  results
11191 ************************************************/
11192 
11193 CNode* CNode::PostSubVisit1( CNode* (*func)(CNode*, void*), void* data )
11194 {
11195  if( GetAttributes() ) {
11196  SetAttributes( GetAttributes()->PostSubVisit1( func, data ) );
11197  }
11198 
11199  int nodeMask = 0;
11200  switch( GetOp() ) {
11201  case eERROR:
11202  nodeMask = 0;
11203  break;
11204  case eVCONSTANT:
11205  nodeMask = 1;
11206  break;
11207  case eRCONSTANT:
11208  nodeMask = 1;
11209  break;
11210  case eCOMMENT:
11211  nodeMask = 1;
11212  break;
11213  case eVRQ:
11214  nodeMask = 1;
11215  break;
11216  case ePRAGMA:
11217  nodeMask = 3;
11218  break;
11219  case eELIST:
11220  nodeMask = 0;
11221  break;
11222  case eWIDTH:
11223  nodeMask = 0;
11224  break;
11225  case eNOP:
11226  nodeMask = 0;
11227  break;
11228  case eSUB:
11229  nodeMask = 0;
11230  break;
11231  case eMUL:
11232  nodeMask = 0;
11233  break;
11234  case eDIV:
11235  nodeMask = 0;
11236  break;
11237  case ePOW:
11238  nodeMask = 0;
11239  break;
11240  case eADD:
11241  nodeMask = 0;
11242  break;
11243  case eLSH:
11244  nodeMask = 0;
11245  break;
11246  case eRSH:
11247  nodeMask = 0;
11248  break;
11249  case eLSHA:
11250  nodeMask = 0;
11251  break;
11252  case eRSHA:
11253  nodeMask = 0;
11254  break;
11255  case eMOD:
11256  nodeMask = 0;
11257  break;
11258  case eOR:
11259  nodeMask = 0;
11260  break;
11261  case eAND:
11262  nodeMask = 0;
11263  break;
11264  case eANDANDAND:
11265  nodeMask = 0;
11266  break;
11267  case eXOR:
11268  nodeMask = 0;
11269  break;
11270  case eXNOR:
11271  nodeMask = 0;
11272  break;
11273  case eINSTANCE_REF:
11274  nodeMask = 1;
11275  if(Arg<CInstance*>(0)) Arg<CInstance*>(0)->PostSubVisit1( func, data );
11276  break;
11277  case eGATE_REF:
11278  nodeMask = 1;
11279  if(Arg<CGate*>(0)) Arg<CGate*>(0)->PostSubVisit1( func, data );
11280  break;
11281  case eTASK_ENABLE:
11282  nodeMask = 1;
11283  break;
11284  case eSYSTASK_CALL:
11285  nodeMask = 1;
11286  break;
11287  case eTIMING_CALL:
11288  nodeMask = 1;
11289  break;
11290  case eFUNCTION_CALL:
11291  nodeMask = 5;
11292  break;
11293  case eARRAY:
11294  nodeMask = 0;
11295  break;
11296  case eNET_REF:
11297  nodeMask = ~0;
11298  break;
11299  case eVAR_REF:
11300  nodeMask = ~0;
11301  break;
11302  case ePARAM_REF:
11303  nodeMask = ~0;
11304  break;
11305  case ePORT_REF:
11306  nodeMask = ~0;
11307  break;
11308  case eFWD_REF:
11309  nodeMask = ~0;
11310  break;
11311  case eGENVAR_REF:
11312  nodeMask = ~0;
11313  break;
11314  case eENUM_REF:
11315  nodeMask = ~0;
11316  break;
11317  case eTYPE_REF:
11318  nodeMask = ~0;
11319  break;
11320  case eNET_DECL:
11321  nodeMask = 1;
11322  if(Arg<CNet*>(0)) Arg<CNet*>(0)->PostSubVisit1( func, data );
11323  break;
11324  case eVAR_DECL:
11325  nodeMask = 1;
11326  if(Arg<CVar*>(0)) Arg<CVar*>(0)->PostSubVisit1( func, data );
11327  break;
11328  case ePARAM_DECL:
11329  nodeMask = 1;
11330  if(Arg<CParam*>(0)) Arg<CParam*>(0)->PostSubVisit1( func, data );
11331  break;
11332  case eSPECPARAM_DECL:
11333  nodeMask = 1;
11334  if(Arg<CParam*>(0)) Arg<CParam*>(0)->PostSubVisit1( func, data );
11335  break;
11336  case ePORT_DECL:
11337  nodeMask = 1;
11338  if(Arg<CPortDir*>(0)) Arg<CPortDir*>(0)->PostSubVisit1( func, data );
11339  break;
11340  case eGENVAR_DECL:
11341  nodeMask = 1;
11342  if(Arg<CGenvar*>(0)) Arg<CGenvar*>(0)->PostSubVisit1( func, data );
11343  break;
11344  case eTYPEDEF_DECL:
11345  nodeMask = 1;
11346  if(Arg<CTypedef*>(0)) Arg<CTypedef*>(0)->PostSubVisit1( func, data );
11347  break;
11348  case eLIST:
11349  nodeMask = 0;
11350  break;
11351  case eRANGE:
11352  nodeMask = 0;
11353  break;
11354  case eSLICE:
11355  nodeMask = 0;
11356  break;
11357  case ePSLICE:
11358  nodeMask = 0;
11359  break;
11360  case eMSLICE:
11361  nodeMask = 0;
11362  break;
11363  case eCVRI:
11364  nodeMask = 0;
11365  break;
11366  case eCVIR:
11367  nodeMask = 0;
11368  break;
11369  case eREP:
11370  nodeMask = 0;
11371  break;
11372  case eCAT:
11373  nodeMask = 0;
11374  break;
11375  case eUCAT:
11376  nodeMask = 0;
11377  break;
11378  case eCOM:
11379  nodeMask = 0;
11380  break;
11381  case eNEG:
11382  nodeMask = 0;
11383  break;
11384  case ePLUS:
11385  nodeMask = 0;
11386  break;
11387  case eNOT:
11388  nodeMask = 0;
11389  break;
11390  case eGT:
11391  nodeMask = 0;
11392  break;
11393  case eGE:
11394  nodeMask = 0;
11395  break;
11396  case eLT:
11397  nodeMask = 0;
11398  break;
11399  case eLE:
11400  nodeMask = 0;
11401  break;
11402  case eLAND:
11403  nodeMask = 0;
11404  break;
11405  case eLOR:
11406  nodeMask = 0;
11407  break;
11408  case eCEQ:
11409  nodeMask = 0;
11410  break;
11411  case eCNE:
11412  nodeMask = 0;
11413  break;
11414  case eEQ:
11415  nodeMask = 0;
11416  break;
11417  case eNE:
11418  nodeMask = 0;
11419  break;
11420  case eRAND:
11421  nodeMask = 0;
11422  break;
11423  case eRNAND:
11424  nodeMask = 0;
11425  break;
11426  case eROR:
11427  nodeMask = 0;
11428  break;
11429  case eRNOR:
11430  nodeMask = 0;
11431  break;
11432  case eRXOR:
11433  nodeMask = 0;
11434  break;
11435  case eRXNOR:
11436  nodeMask = 0;
11437  break;
11438  case eHOOK:
11439  nodeMask = 0;
11440  break;
11441  case eINIT:
11442  nodeMask = 0;
11443  break;
11444  case eALWAYS:
11445  nodeMask = 0;
11446  break;
11447  case eALWAYS_LATCH:
11448  nodeMask = 0;
11449  break;
11450  case eALWAYS_FF:
11451  nodeMask = 0;
11452  break;
11453  case eALWAYS_COMB:
11454  nodeMask = 0;
11455  break;
11456  case eEVENT:
11457  nodeMask = 0;
11458  break;
11459  case eBLOCK_REF:
11460  nodeMask = 5;
11461  if(Arg<CBlock*>(0)) Arg<CBlock*>(0)->PostSubVisit1( func, data );
11462  break;
11463  case eSPECIFY_REF:
11464  nodeMask = 1;
11465  if(Arg<CSpecify*>(0)) Arg<CSpecify*>(0)->PostSubVisit1( func, data );
11466  break;
11467  case eASSIGN:
11468  nodeMask = 0;
11469  break;
11470  case eGASSIGN:
11471  nodeMask = 1;
11472  break;
11473  case eADD_ASSIGN:
11474  nodeMask = 0;
11475  break;
11476  case eSUB_ASSIGN:
11477  nodeMask = 0;
11478  break;
11479  case eMUL_ASSIGN:
11480  nodeMask = 0;
11481  break;
11482  case eDIV_ASSIGN:
11483  nodeMask = 0;
11484  break;
11485  case eMOD_ASSIGN:
11486  nodeMask = 0;
11487  break;
11488  case eAND_ASSIGN:
11489  nodeMask = 0;
11490  break;
11491  case eOR_ASSIGN:
11492  nodeMask = 0;
11493  break;
11494  case eXOR_ASSIGN:
11495  nodeMask = 0;
11496  break;
11497  case eLSH_ASSIGN:
11498  nodeMask = 0;
11499  break;
11500  case eRSH_ASSIGN:
11501  nodeMask = 0;
11502  break;
11503  case eLSHA_ASSIGN:
11504  nodeMask = 0;
11505  break;
11506  case eRSHA_ASSIGN:
11507  nodeMask = 0;
11508  break;
11509  case eFORCE:
11510  nodeMask = 0;
11511  break;
11512  case eRELEASE:
11513  nodeMask = 0;
11514  break;
11515  case eNBASSIGN:
11516  nodeMask = 0;
11517  break;
11518  case ePOSEDGE:
11519  nodeMask = 0;
11520  break;
11521  case eNEGEDGE:
11522  nodeMask = 0;
11523  break;
11524  case eEDGE:
11525  nodeMask = 2;
11526  break;
11527  case eEVOR:
11528  nodeMask = 0;
11529  break;
11530  case eDELAY:
11531  nodeMask = 0;
11532  break;
11533  case eMTM:
11534  nodeMask = 0;
11535  break;
11536  case eIF:
11537  nodeMask = 8;
11538  break;
11539  case eFOREVER:
11540  nodeMask = 0;
11541  break;
11542  case eREPEAT:
11543  nodeMask = 0;
11544  break;
11545  case eWHILE:
11546  nodeMask = 0;
11547  break;
11548  case eWAIT:
11549  nodeMask = 0;
11550  break;
11551  case eFOR:
11552  nodeMask = 0;
11553  break;
11554  case eCASE:
11555  nodeMask = 4;
11556  break;
11557  case eCASEX:
11558  nodeMask = 4;
11559  break;
11560  case eCASEZ:
11561  nodeMask = 4;
11562  break;
11563  case eCASEITEM:
11564  nodeMask = 0;
11565  break;
11566  case eCASSIGN:
11567  nodeMask = 1;
11568  break;
11569  case eARG:
11570  nodeMask = 1;
11571  break;
11572  case eIMPORT:
11573  nodeMask = 1;
11574  break;
11575  case eFUNCTION_DEF:
11576  nodeMask = 1;
11577  if(Arg<CFunction*>(0)) Arg<CFunction*>(0)->PostSubVisit1( func, data );
11578  break;
11579  case eMODULE_DEF:
11580  nodeMask = 1;
11581  if(Arg<CModule*>(0)) Arg<CModule*>(0)->PostSubVisit1( func, data );
11582  break;
11583  case ePACKAGE_DEF:
11584  nodeMask = 1;
11585  if(Arg<CPackage*>(0)) Arg<CPackage*>(0)->PostSubVisit1( func, data );
11586  break;
11587  case eREPEAT_CONTROL:
11588  nodeMask = 0;
11589  break;
11590  case eDELAY_CONTROL:
11591  nodeMask = 0;
11592  break;
11593  case eEVENT_CONTROL:
11594  nodeMask = 0;
11595  break;
11596  case eEXTERNAL_REF:
11597  nodeMask = 1;
11598  break;
11599  case ePORT_DEF:
11600  nodeMask = 1;
11601  if(Arg<CPort*>(0)) Arg<CPort*>(0)->PostSubVisit1( func, data );
11602  break;
11603  case eDEFPARAM:
11604  nodeMask = 0;
11605  break;
11606  case ePATH:
11607  nodeMask = 45;
11608  break;
11609  case ePATH_ASSIGN:
11610  nodeMask = 0;
11611  break;
11612  case eIFNONE_PATH_ASSIGN:
11613  nodeMask = 0;
11614  break;
11615  case eTRIGGER:
11616  nodeMask = 0;
11617  break;
11618  case ePASSIGN:
11619  nodeMask = 0;
11620  break;
11621  case eDEASSIGN:
11622  nodeMask = 0;
11623  break;
11624  case eDISABLE:
11625  nodeMask = 1;
11626  break;
11627  case eATTRIBUTE:
11628  nodeMask = 1;
11629  if(Arg<CAttr*>(0)) Arg<CAttr*>(0)->PostSubVisit1( func, data );
11630  break;
11631  case eGIF:
11632  nodeMask = 0;
11633  break;
11634  case eGFOR:
11635  nodeMask = 0;
11636  break;
11637  case eGCASE:
11638  nodeMask = 0;
11639  break;
11640  case eTABLE:
11641  nodeMask = 0;
11642  break;
11643  case eTABLE_ENTRY:
11644  nodeMask = 0;
11645  break;
11646  case eTABLE_SYMBOL:
11647  nodeMask = 1;
11648  break;
11649  case ePORTLIST_END:
11650  nodeMask = 0;
11651  break;
11652  case eMACRO_EXPR:
11653  nodeMask = 1;
11654  break;
11655  case eENUM_SPEC:
11656  nodeMask = 1;
11657  break;
11658  case eMEMBER:
11659  nodeMask = 2;
11660  break;
11661  case eRETURN:
11662  nodeMask = 0;
11663  break;
11664  case ePREINC:
11665  nodeMask = 0;
11666  break;
11667  case ePOSTINC:
11668  nodeMask = 0;
11669  break;
11670  case ePREDEC:
11671  nodeMask = 0;
11672  break;
11673  case ePOSTDEC:
11674  nodeMask = 0;
11675  break;
11676  case eCAST:
11677  nodeMask = 0;
11678  break;
11679  case eASSIGNMENT_PATTERN:
11680  nodeMask = 0;
11681  break;
11682  case eDOLLAR:
11683  nodeMask = 0;
11684  break;
11685  }
11686 
11687  /*
11688  * special case LIST nodes for tail recursion optimizations
11689  */
11690  if( GetOp() != eLIST ) {
11691  for( int i = 0; i < ArgCount(); i++ ) {
11692  if( Arg<CNode*>(i) && !((nodeMask>>i)&1) ) Arg<CNode*>(i) = Arg<CNode*>(i)->PostSubVisit1( func, data );
11693  }
11694  } else {
11695  std::stack<CNode*> visitLog;
11696  CNode* n = this;
11697  while( 1 ) {
11698  if( n->Arg<CNode*>(0) ) {
11699  n->Arg<CNode*>(0) = n->Arg<CNode*>(0)->
11700  PostSubVisit1( func, data );
11701  }
11702  if( !n->Arg<CNode*>(1) || n->Arg<CNode*>(1)->GetOp() != eLIST ) {
11703  break;
11704  }
11705  visitLog.push(n);
11706  n = n->Arg<CNode*>(1);
11707  if( n->GetAttributes() ) {
11708  n->SetAttributes( n->GetAttributes()->PostSubVisit1( func, data ) );
11709  }
11710  }
11711  if( n->Arg<CNode*>(1) ) {
11712  n->Arg<CNode*>(1) = n->Arg<CNode*>(1)->PostSubVisit1( func, data );
11713  }
11714  while( !visitLog.empty() ) {
11715  CNode* top = visitLog.top();
11716  if( top->Arg<CNode*>(1) ) {
11717  top->Arg<CNode*>(1) = (*func)(top->Arg<CNode*>(1),data);
11718  }
11719  visitLog.pop();
11720  }
11721  }
11722 
11723  return (*func)( this, data );
11724 }
11725 
11726 /***********************************************
11727  Hash
11728  - returns a unique hash number
11729  representing tree
11730  The following is always true:
11731  Equivilent(n1,n2) => Hash(n1) == Hash(n2)
11732 ************************************************/
11733 
11734 unsigned CNode::Hash()
11735 {
11736  unsigned result = GetOp();
11737  int nodeMask = 0;
11738  switch( GetOp() ) {
11739  case eERROR:
11740  nodeMask = 0;
11741  break;
11742  case eVCONSTANT:
11743  nodeMask = 1;
11744  result ^= Arg<CVector*>(0)->Hash();
11745  break;
11746  case eRCONSTANT:
11747  nodeMask = 1;
11748  result ^= strlen(Arg<char*>(0));
11749  break;
11750  case eCOMMENT:
11751  nodeMask = 1;
11752  result ^= strlen(Arg<char*>(0));
11753  break;
11754  case eVRQ:
11755  nodeMask = 1;
11756  result ^= strlen(Arg<char*>(0));
11757  break;
11758  case ePRAGMA:
11759  nodeMask = 3;
11760  result ^= strlen(Arg<char*>(0));
11761  result ^= Arg<int>(1);
11762  break;
11763  case eELIST:
11764  nodeMask = 0;
11765  break;
11766  case eWIDTH:
11767  nodeMask = 0;
11768  break;
11769  case eNOP:
11770  nodeMask = 0;
11771  break;
11772  case eSUB:
11773  nodeMask = 0;
11774  break;
11775  case eMUL:
11776  nodeMask = 0;
11777  break;
11778  case eDIV:
11779  nodeMask = 0;
11780  break;
11781  case ePOW:
11782  nodeMask = 0;
11783  break;
11784  case eADD:
11785  nodeMask = 0;
11786  break;
11787  case eLSH:
11788  nodeMask = 0;
11789  break;
11790  case eRSH:
11791  nodeMask = 0;
11792  break;
11793  case eLSHA:
11794  nodeMask = 0;
11795  break;
11796  case eRSHA:
11797  nodeMask = 0;
11798  break;
11799  case eMOD:
11800  nodeMask = 0;
11801  break;
11802  case eOR:
11803  nodeMask = 0;
11804  break;
11805  case eAND:
11806  nodeMask = 0;
11807  break;
11808  case eANDANDAND:
11809  nodeMask = 0;
11810  break;
11811  case eXOR:
11812  nodeMask = 0;
11813  break;
11814  case eXNOR:
11815  nodeMask = 0;
11816  break;
11817  case eINSTANCE_REF:
11818  nodeMask = 1;
11819  result ^= Arg<unsigned long>(0);
11820  break;
11821  case eGATE_REF:
11822  nodeMask = 1;
11823  result ^= Arg<unsigned long>(0);
11824  break;
11825  case eTASK_ENABLE:
11826  nodeMask = 1;
11827  result ^= Arg<unsigned long>(0);
11828  break;
11829  case eSYSTASK_CALL:
11830  nodeMask = 1;
11831  result ^= Arg<unsigned long>(0);
11832  break;
11833  case eTIMING_CALL:
11834  nodeMask = 1;
11835  result ^= Arg<unsigned long>(0);
11836  break;
11837  case eFUNCTION_CALL:
11838  nodeMask = 5;
11839  result ^= Arg<unsigned long>(0);
11840  result ^= Arg<unsigned long>(2);
11841  break;
11842  case eARRAY:
11843  nodeMask = 0;
11844  break;
11845  case eNET_REF:
11846  nodeMask = 1;
11847  result ^= Arg<unsigned long>(0);
11848  break;
11849  case eVAR_REF:
11850  nodeMask = 1;
11851  result ^= Arg<unsigned long>(0);
11852  break;
11853  case ePARAM_REF:
11854  nodeMask = 1;
11855  result ^= Arg<unsigned long>(0);
11856  break;
11857  case ePORT_REF:
11858  nodeMask = 1;
11859  result ^= Arg<unsigned long>(0);
11860  break;
11861  case eFWD_REF:
11862  nodeMask = 1;
11863  result ^= Arg<unsigned long>(0);
11864  break;
11865  case eGENVAR_REF:
11866  nodeMask = 1;
11867  result ^= Arg<unsigned long>(0);
11868  break;
11869  case eENUM_REF:
11870  nodeMask = 1;
11871  result ^= Arg<unsigned long>(0);
11872  break;
11873  case eTYPE_REF:
11874  nodeMask = 1;
11875  result ^= Arg<unsigned long>(0);
11876  break;
11877  case eNET_DECL:
11878  nodeMask = 1;
11879  result ^= Arg<unsigned long>(0);
11880  break;
11881  case eVAR_DECL:
11882  nodeMask = 1;
11883  result ^= Arg<unsigned long>(0);
11884  break;
11885  case ePARAM_DECL:
11886  nodeMask = 1;
11887  result ^= Arg<unsigned long>(0);
11888  break;
11889  case eSPECPARAM_DECL:
11890  nodeMask = 1;
11891  result ^= Arg<unsigned long>(0);
11892  break;
11893  case ePORT_DECL:
11894  nodeMask = 1;
11895  result ^= Arg<unsigned long>(0);
11896  break;
11897  case eGENVAR_DECL:
11898  nodeMask = 1;
11899  result ^= Arg<unsigned long>(0);
11900  break;
11901  case eTYPEDEF_DECL:
11902  nodeMask = 1;
11903  result ^= Arg<unsigned long>(0);
11904  break;
11905  case eLIST:
11906  nodeMask = 0;
11907  break;
11908  case eRANGE:
11909  nodeMask = 0;
11910  break;
11911  case eSLICE:
11912  nodeMask = 0;
11913  break;
11914  case ePSLICE:
11915  nodeMask = 0;
11916  break;
11917  case eMSLICE:
11918  nodeMask = 0;
11919  break;
11920  case eCVRI:
11921  nodeMask = 0;
11922  break;
11923  case eCVIR:
11924  nodeMask = 0;
11925  break;
11926  case eREP:
11927  nodeMask = 0;
11928  break;
11929  case eCAT:
11930  nodeMask = 0;
11931  break;
11932  case eUCAT:
11933  nodeMask = 0;
11934  break;
11935  case eCOM:
11936  nodeMask = 0;
11937  break;
11938  case eNEG:
11939  nodeMask = 0;
11940  break;
11941  case ePLUS:
11942  nodeMask = 0;
11943  break;
11944  case eNOT:
11945  nodeMask = 0;
11946  break;
11947  case eGT:
11948  nodeMask = 0;
11949  break;
11950  case eGE:
11951  nodeMask = 0;
11952  break;
11953  case eLT:
11954  nodeMask = 0;
11955  break;
11956  case eLE:
11957  nodeMask = 0;
11958  break;
11959  case eLAND:
11960  nodeMask = 0;
11961  break;
11962  case eLOR:
11963  nodeMask = 0;
11964  break;
11965  case eCEQ:
11966  nodeMask = 0;
11967  break;
11968  case eCNE:
11969  nodeMask = 0;
11970  break;
11971  case eEQ:
11972  nodeMask = 0;
11973  break;
11974  case eNE:
11975  nodeMask = 0;
11976  break;
11977  case eRAND:
11978  nodeMask = 0;
11979  break;
11980  case eRNAND:
11981  nodeMask = 0;
11982  break;
11983  case eROR:
11984  nodeMask = 0;
11985  break;
11986  case eRNOR:
11987  nodeMask = 0;
11988  break;
11989  case eRXOR:
11990  nodeMask = 0;
11991  break;
11992  case eRXNOR:
11993  nodeMask = 0;
11994  break;
11995  case eHOOK:
11996  nodeMask = 0;
11997  break;
11998  case eINIT:
11999  nodeMask = 0;
12000  break;
12001  case eALWAYS:
12002  nodeMask = 0;
12003  break;
12004  case eALWAYS_LATCH:
12005  nodeMask = 0;
12006  break;
12007  case eALWAYS_FF:
12008  nodeMask = 0;
12009  break;
12010  case eALWAYS_COMB:
12011  nodeMask = 0;
12012  break;
12013  case eEVENT:
12014  nodeMask = 0;
12015  break;
12016  case eBLOCK_REF:
12017  nodeMask = 5;
12018  result ^= Arg<unsigned long>(0);
12019  result ^= Arg<bool>(2);
12020  break;
12021  case eSPECIFY_REF:
12022  nodeMask = 1;
12023  result ^= Arg<unsigned long>(0);
12024  break;
12025  case eASSIGN:
12026  nodeMask = 0;
12027  break;
12028  case eGASSIGN:
12029  nodeMask = 1;
12030  result ^= Arg<bool>(0);
12031  break;
12032  case eADD_ASSIGN:
12033  nodeMask = 0;
12034  break;
12035  case eSUB_ASSIGN:
12036  nodeMask = 0;
12037  break;
12038  case eMUL_ASSIGN:
12039  nodeMask = 0;
12040  break;
12041  case eDIV_ASSIGN:
12042  nodeMask = 0;
12043  break;
12044  case eMOD_ASSIGN:
12045  nodeMask = 0;
12046  break;
12047  case eAND_ASSIGN:
12048  nodeMask = 0;
12049  break;
12050  case eOR_ASSIGN:
12051  nodeMask = 0;
12052  break;
12053  case eXOR_ASSIGN:
12054  nodeMask = 0;
12055  break;
12056  case eLSH_ASSIGN:
12057  nodeMask = 0;
12058  break;
12059  case eRSH_ASSIGN:
12060  nodeMask = 0;
12061  break;
12062  case eLSHA_ASSIGN:
12063  nodeMask = 0;
12064  break;
12065  case eRSHA_ASSIGN:
12066  nodeMask = 0;
12067  break;
12068  case eFORCE:
12069  nodeMask = 0;
12070  break;
12071  case eRELEASE:
12072  nodeMask = 0;
12073  break;
12074  case eNBASSIGN:
12075  nodeMask = 0;
12076  break;
12077  case ePOSEDGE:
12078  nodeMask = 0;
12079  break;
12080  case eNEGEDGE:
12081  nodeMask = 0;
12082  break;
12083  case eEDGE:
12084  nodeMask = 2;
12085  result ^= (unsigned long)Arg<Edge_t>(1);
12086  break;
12087  case eEVOR:
12088  nodeMask = 0;
12089  break;
12090  case eDELAY:
12091  nodeMask = 0;
12092  break;
12093  case eMTM:
12094  nodeMask = 0;
12095  break;
12096  case eIF:
12097  nodeMask = 8;
12098  result ^= Arg<unsigned long>(3);
12099  break;
12100  case eFOREVER:
12101  nodeMask = 0;
12102  break;
12103  case eREPEAT:
12104  nodeMask = 0;
12105  break;
12106  case eWHILE:
12107  nodeMask = 0;
12108  break;
12109  case eWAIT:
12110  nodeMask = 0;
12111  break;
12112  case eFOR:
12113  nodeMask = 0;
12114  break;
12115  case eCASE:
12116  nodeMask = 4;
12117  result ^= Arg<unsigned long>(2);
12118  break;
12119  case eCASEX:
12120  nodeMask = 4;
12121  result ^= Arg<unsigned long>(2);
12122  break;
12123  case eCASEZ:
12124  nodeMask = 4;
12125  result ^= Arg<unsigned long>(2);
12126  break;
12127  case eCASEITEM:
12128  nodeMask = 0;
12129  break;
12130  case eCASSIGN:
12131  nodeMask = 1;
12132  result ^= Arg<unsigned long>(0);
12133  break;
12134  case eARG:
12135  nodeMask = 1;
12136  result ^= Arg<unsigned long>(0);
12137  break;
12138  case eIMPORT:
12139  nodeMask = 1;
12140  result ^= Arg<unsigned long>(0);
12141  break;
12142  case eFUNCTION_DEF:
12143  nodeMask = 1;
12144  result ^= Arg<unsigned long>(0);
12145  break;
12146  case eMODULE_DEF:
12147  nodeMask = 1;
12148  result ^= Arg<unsigned long>(0);
12149  break;
12150  case ePACKAGE_DEF:
12151  nodeMask = 1;
12152  result ^= Arg<unsigned long>(0);
12153  break;
12154  case eREPEAT_CONTROL:
12155  nodeMask = 0;
12156  break;
12157  case eDELAY_CONTROL:
12158  nodeMask = 0;
12159  break;
12160  case eEVENT_CONTROL:
12161  nodeMask = 0;
12162  break;
12163  case eEXTERNAL_REF:
12164  nodeMask = 1;
12165  result ^= Arg<unsigned long>(0);
12166  break;
12167  case ePORT_DEF:
12168  nodeMask = 1;
12169  result ^= Arg<unsigned long>(0);
12170  break;
12171  case eDEFPARAM:
12172  nodeMask = 0;
12173  break;
12174  case ePATH:
12175  nodeMask = 45;
12176  result ^= Arg<int>(0);
12177  result ^= Arg<int>(2);
12178  result ^= Arg<int>(3);
12179  result ^= Arg<int>(5);
12180  break;
12181  case ePATH_ASSIGN:
12182  nodeMask = 0;
12183  break;
12184  case eIFNONE_PATH_ASSIGN:
12185  nodeMask = 0;
12186  break;
12187  case eTRIGGER:
12188  nodeMask = 0;
12189  break;
12190  case ePASSIGN:
12191  nodeMask = 0;
12192  break;
12193  case eDEASSIGN:
12194  nodeMask = 0;
12195  break;
12196  case eDISABLE:
12197  nodeMask = 1;
12198  result ^= Arg<unsigned long>(0);
12199  break;
12200  case eATTRIBUTE:
12201  nodeMask = 1;
12202  result ^= Arg<unsigned long>(0);
12203  break;
12204  case eGIF:
12205  nodeMask = 0;
12206  break;
12207  case eGFOR:
12208  nodeMask = 0;
12209  break;
12210  case eGCASE:
12211  nodeMask = 0;
12212  break;
12213  case eTABLE:
12214  nodeMask = 0;
12215  break;
12216  case eTABLE_ENTRY:
12217  nodeMask = 0;
12218  break;
12219  case eTABLE_SYMBOL:
12220  nodeMask = 1;
12221  result ^= strlen(Arg<char*>(0));
12222  break;
12223  case ePORTLIST_END:
12224  nodeMask = 0;
12225  break;
12226  case eMACRO_EXPR:
12227  nodeMask = 1;
12228  result ^= strlen(Arg<char*>(0));
12229  break;
12230  case eENUM_SPEC:
12231  nodeMask = 1;
12232  result ^= Arg<unsigned long>(0);
12233  break;
12234  case eMEMBER:
12235  nodeMask = 2;
12236  result ^= Arg<unsigned long>(1);
12237  break;
12238  case eRETURN:
12239  nodeMask = 0;
12240  break;
12241  case ePREINC:
12242  nodeMask = 0;
12243  break;
12244  case ePOSTINC:
12245  nodeMask = 0;
12246  break;
12247  case ePREDEC:
12248  nodeMask = 0;
12249  break;
12250  case ePOSTDEC:
12251  nodeMask = 0;
12252  break;
12253  case eCAST:
12254  nodeMask = 0;
12255  break;
12256  case eASSIGNMENT_PATTERN:
12257  nodeMask = 0;
12258  break;
12259  case eDOLLAR:
12260  nodeMask = 0;
12261  break;
12262  }
12263 
12264  for( int i = 0; i < ArgCount(); i++ ) {
12265  if( !((nodeMask>>i)&1) && Arg<CNode*>(i) ) result ^= Arg<CNode*>(i)->Hash();
12266  }
12267  return result;
12268 }
12269 
12270 /***********************************************
12271  Equivalent
12272  - returns TRUE if both trees are equivalent
12273  Note: this currently will only match if
12274  the trees are structurally the same.
12275  It does not attempt rename and match
12276  leaf declarations.
12277  In the future this may be expanded
12278  to match if the trees are functionally
12279  equivalent.
12280 ************************************************/
12281 
12282 int Equivalent( CNode* a, CNode* b )
12283 {
12284  /*
12285  * handles NULL/NULL and trivial equivalence case
12286  */
12287  if( a == b ) {
12288  return TRUE;
12289  }
12290  /*
12291  * reject if one is NULL but not the other
12292  */
12293  if( a == NULL || b == NULL ) {
12294  return FALSE;
12295  }
12296  /*
12297  * reject if node types are different
12298  */
12299  if( a->GetOp() != b->GetOp() ) {
12300  return FALSE;
12301  }
12302 
12303  int nodeMask = 0;
12304  switch( a->GetOp() ) {
12305  case eERROR:
12306  nodeMask = 0;
12307  break;
12308  case eVCONSTANT:
12309  nodeMask = 1;
12310  if( !(*a->Arg<CVector*>(0)==*b->Arg<CVector*>(0)) ) { return FALSE; }
12311  break;
12312  case eRCONSTANT:
12313  nodeMask = 1;
12314  if( !(!strcmp(a->Arg<char*>(0),b->Arg<char*>(0))) ) { return FALSE; }
12315  break;
12316  case eCOMMENT:
12317  nodeMask = 1;
12318  if( !(!strcmp(a->Arg<char*>(0),b->Arg<char*>(0))) ) { return FALSE; }
12319  break;
12320  case eVRQ:
12321  nodeMask = 1;
12322  if( !(!strcmp(a->Arg<char*>(0),b->Arg<char*>(0))) ) { return FALSE; }
12323  break;
12324  case ePRAGMA:
12325  nodeMask = 3;
12326  if( !(!strcmp(a->Arg<char*>(0),b->Arg<char*>(0))) ) { return FALSE; }
12327  if( !(a->Arg<int>(1)==b->Arg<int>(1)) ) { return FALSE; }
12328  break;
12329  case eELIST:
12330  nodeMask = 0;
12331  break;
12332  case eWIDTH:
12333  nodeMask = 0;
12334  break;
12335  case eNOP:
12336  nodeMask = 0;
12337  break;
12338  case eSUB:
12339  nodeMask = 0;
12340  break;
12341  case eMUL:
12342  nodeMask = 0;
12343  break;
12344  case eDIV:
12345  nodeMask = 0;
12346  break;
12347  case ePOW:
12348  nodeMask = 0;
12349  break;
12350  case eADD:
12351  nodeMask = 0;
12352  break;
12353  case eLSH:
12354  nodeMask = 0;
12355  break;
12356  case eRSH:
12357  nodeMask = 0;
12358  break;
12359  case eLSHA:
12360  nodeMask = 0;
12361  break;
12362  case eRSHA:
12363  nodeMask = 0;
12364  break;
12365  case eMOD:
12366  nodeMask = 0;
12367  break;
12368  case eOR:
12369  nodeMask = 0;
12370  break;
12371  case eAND:
12372  nodeMask = 0;
12373  break;
12374  case eANDANDAND:
12375  nodeMask = 0;
12376  break;
12377  case eXOR:
12378  nodeMask = 0;
12379  break;
12380  case eXNOR:
12381  nodeMask = 0;
12382  break;
12383  case eINSTANCE_REF:
12384  nodeMask = 1;
12385  if( !(a->Arg<CInstance*>(0)==b->Arg<CInstance*>(0)) ) { return FALSE; }
12386  break;
12387  case eGATE_REF:
12388  nodeMask = 1;
12389  if( !(a->Arg<CGate*>(0)==b->Arg<CGate*>(0)) ) { return FALSE; }
12390  break;
12391  case eTASK_ENABLE:
12392  nodeMask = 1;
12393  if( !(a->Arg<CSymbol*>(0)==b->Arg<CSymbol*>(0)) ) { return FALSE; }
12394  break;
12395  case eSYSTASK_CALL:
12396  nodeMask = 1;
12397  if( !(a->Arg<CSymbol*>(0)==b->Arg<CSymbol*>(0)) ) { return FALSE; }
12398  break;
12399  case eTIMING_CALL:
12400  nodeMask = 1;
12401  if( !(a->Arg<CSymbol*>(0)==b->Arg<CSymbol*>(0)) ) { return FALSE; }
12402  break;
12403  case eFUNCTION_CALL:
12404  nodeMask = 5;
12405  if( !(a->Arg<CSymbol*>(0)==b->Arg<CSymbol*>(0)) ) { return FALSE; }
12406  if( !(a->Arg<CScope*>(2)==b->Arg<CScope*>(2)) ) { return FALSE; }
12407  break;
12408  case eARRAY:
12409  nodeMask = 0;
12410  break;
12411  case eNET_REF:
12412  nodeMask = 1;
12413  if( !(a->Arg<CNet*>(0)==b->Arg<CNet*>(0)) ) { return FALSE; }
12414  break;
12415  case eVAR_REF:
12416  nodeMask = 1;
12417  if( !(a->Arg<CVar*>(0)==b->Arg<CVar*>(0)) ) { return FALSE; }
12418  break;
12419  case ePARAM_REF:
12420  nodeMask = 1;
12421  if( !(a->Arg<CParam*>(0)==b->Arg<CParam*>(0)) ) { return FALSE; }
12422  break;
12423  case ePORT_REF:
12424  nodeMask = 1;
12425  if( !(a->Arg<CPortDir*>(0)==b->Arg<CPortDir*>(0)) ) { return FALSE; }
12426  break;
12427  case eFWD_REF:
12428  nodeMask = 1;
12429  if( !(a->Arg<CFref*>(0)==b->Arg<CFref*>(0)) ) { return FALSE; }
12430  break;
12431  case eGENVAR_REF:
12432  nodeMask = 1;
12433  if( !(a->Arg<CGenvar*>(0)==b->Arg<CGenvar*>(0)) ) { return FALSE; }
12434  break;
12435  case eENUM_REF:
12436  nodeMask = 1;
12437  MASSERT(FALSE); // arg0<CEnum*>
12438  break;
12439  case eTYPE_REF:
12440  nodeMask = 1;
12441  MASSERT(FALSE); // arg0<CTypedef*>
12442  break;
12443  case eNET_DECL:
12444  nodeMask = 1;
12445  if( !(a->Arg<CNet*>(0)==b->Arg<CNet*>(0)) ) { return FALSE; }
12446  break;
12447  case eVAR_DECL:
12448  nodeMask = 1;
12449  if( !(a->Arg<CVar*>(0)==b->Arg<CVar*>(0)) ) { return FALSE; }
12450  break;
12451  case ePARAM_DECL:
12452  nodeMask = 1;
12453  if( !(a->Arg<CParam*>(0)==b->Arg<CParam*>(0)) ) { return FALSE; }
12454  break;
12455  case eSPECPARAM_DECL:
12456  nodeMask = 1;
12457  if( !(a->Arg<CParam*>(0)==b->Arg<CParam*>(0)) ) { return FALSE; }
12458  break;
12459  case ePORT_DECL:
12460  nodeMask = 1;
12461  if( !(a->Arg<CPortDir*>(0)==b->Arg<CPortDir*>(0)) ) { return FALSE; }
12462  break;
12463  case eGENVAR_DECL:
12464  nodeMask = 1;
12465  if( !(a->Arg<CGenvar*>(0)==b->Arg<CGenvar*>(0)) ) { return FALSE; }
12466  break;
12467  case eTYPEDEF_DECL:
12468  nodeMask = 1;
12469  MASSERT(FALSE); // arg0<CTypedef*>
12470  break;
12471  case eLIST:
12472  nodeMask = 0;
12473  break;
12474  case eRANGE:
12475  nodeMask = 0;
12476  break;
12477  case eSLICE:
12478  nodeMask = 0;
12479  break;
12480  case ePSLICE:
12481  nodeMask = 0;
12482  break;
12483  case eMSLICE:
12484  nodeMask = 0;
12485  break;
12486  case eCVRI:
12487  nodeMask = 0;
12488  break;
12489  case eCVIR:
12490  nodeMask = 0;
12491  break;
12492  case eREP:
12493  nodeMask = 0;
12494  break;
12495  case eCAT:
12496  nodeMask = 0;
12497  break;
12498  case eUCAT:
12499  nodeMask = 0;
12500  break;
12501  case eCOM:
12502  nodeMask = 0;
12503  break;
12504  case eNEG:
12505  nodeMask = 0;
12506  break;
12507  case ePLUS:
12508  nodeMask = 0;
12509  break;
12510  case eNOT:
12511  nodeMask = 0;
12512  break;
12513  case eGT:
12514  nodeMask = 0;
12515  break;
12516  case eGE:
12517  nodeMask = 0;
12518  break;
12519  case eLT:
12520  nodeMask = 0;
12521  break;
12522  case eLE:
12523  nodeMask = 0;
12524  break;
12525  case eLAND:
12526  nodeMask = 0;
12527  break;
12528  case eLOR:
12529  nodeMask = 0;
12530  break;
12531  case eCEQ:
12532  nodeMask = 0;
12533  break;
12534  case eCNE:
12535  nodeMask = 0;
12536  break;
12537  case eEQ:
12538  nodeMask = 0;
12539  break;
12540  case eNE:
12541  nodeMask = 0;
12542  break;
12543  case eRAND:
12544  nodeMask = 0;
12545  break;
12546  case eRNAND:
12547  nodeMask = 0;
12548  break;
12549  case eROR:
12550  nodeMask = 0;
12551  break;
12552  case eRNOR:
12553  nodeMask = 0;
12554  break;
12555  case eRXOR:
12556  nodeMask = 0;
12557  break;
12558  case eRXNOR:
12559  nodeMask = 0;
12560  break;
12561  case eHOOK:
12562  nodeMask = 0;
12563  break;
12564  case eINIT:
12565  nodeMask = 0;
12566  break;
12567  case eALWAYS:
12568  nodeMask = 0;
12569  break;
12570  case eALWAYS_LATCH:
12571  nodeMask = 0;
12572  break;
12573  case eALWAYS_FF:
12574  nodeMask = 0;
12575  break;
12576  case eALWAYS_COMB:
12577  nodeMask = 0;
12578  break;
12579  case eEVENT:
12580  nodeMask = 0;
12581  break;
12582  case eBLOCK_REF:
12583  nodeMask = 5;
12584  if( !(a->Arg<CBlock*>(0)==b->Arg<CBlock*>(0)) ) { return FALSE; }
12585  MASSERT(FALSE); // arg2<bool>
12586  break;
12587  case eSPECIFY_REF:
12588  nodeMask = 1;
12589  if( !(a->Arg<CSpecify*>(0)==b->Arg<CSpecify*>(0)) ) { return FALSE; }
12590  break;
12591  case eASSIGN:
12592  nodeMask = 0;
12593  break;
12594  case eGASSIGN:
12595  nodeMask = 1;
12596  MASSERT(FALSE); // arg0<bool>
12597  break;
12598  case eADD_ASSIGN:
12599  nodeMask = 0;
12600  break;
12601  case eSUB_ASSIGN:
12602  nodeMask = 0;
12603  break;
12604  case eMUL_ASSIGN:
12605  nodeMask = 0;
12606  break;
12607  case eDIV_ASSIGN:
12608  nodeMask = 0;
12609  break;
12610  case eMOD_ASSIGN:
12611  nodeMask = 0;
12612  break;
12613  case eAND_ASSIGN:
12614  nodeMask = 0;
12615  break;
12616  case eOR_ASSIGN:
12617  nodeMask = 0;
12618  break;
12619  case eXOR_ASSIGN:
12620  nodeMask = 0;
12621  break;
12622  case eLSH_ASSIGN:
12623  nodeMask = 0;
12624  break;
12625  case eRSH_ASSIGN:
12626  nodeMask = 0;
12627  break;
12628  case eLSHA_ASSIGN:
12629  nodeMask = 0;
12630  break;
12631  case eRSHA_ASSIGN:
12632  nodeMask = 0;
12633  break;
12634  case eFORCE:
12635  nodeMask = 0;
12636  break;
12637  case eRELEASE:
12638  nodeMask = 0;
12639  break;
12640  case eNBASSIGN:
12641  nodeMask = 0;
12642  break;
12643  case ePOSEDGE:
12644  nodeMask = 0;
12645  break;
12646  case eNEGEDGE:
12647  nodeMask = 0;
12648  break;
12649  case eEDGE:
12650  nodeMask = 2;
12651  if( !(a->Arg<Edge_t>(1)==b->Arg<Edge_t>(1)) ) { return FALSE; }
12652  break;
12653  case eEVOR:
12654  nodeMask = 0;
12655  break;
12656  case eDELAY:
12657  nodeMask = 0;
12658  break;
12659  case eMTM:
12660  nodeMask = 0;
12661  break;
12662  case eIF:
12663  nodeMask = 8;
12664  MASSERT(FALSE); // arg3<ConditionalType>
12665  break;
12666  case eFOREVER:
12667  nodeMask = 0;
12668  break;
12669  case eREPEAT:
12670  nodeMask = 0;
12671  break;
12672  case eWHILE:
12673  nodeMask = 0;
12674  break;
12675  case eWAIT:
12676  nodeMask = 0;
12677  break;
12678  case eFOR:
12679  nodeMask = 0;
12680  break;
12681  case eCASE:
12682  nodeMask = 4;
12683  MASSERT(FALSE); // arg2<ConditionalType>
12684  break;
12685  case eCASEX:
12686  nodeMask = 4;
12687  MASSERT(FALSE); // arg2<ConditionalType>
12688  break;
12689  case eCASEZ:
12690  nodeMask = 4;
12691  MASSERT(FALSE); // arg2<ConditionalType>
12692  break;
12693  case eCASEITEM:
12694  nodeMask = 0;
12695  break;
12696  case eCASSIGN:
12697  nodeMask = 1;
12698  if( !(a->Arg<StrengthPair_t*>(0)==b->Arg<StrengthPair_t*>(0)) ) { return FALSE; }
12699  break;
12700  case eARG:
12701  nodeMask = 1;
12702  if( !(a->Arg<CSymbol*>(0)==b->Arg<CSymbol*>(0)) ) { return FALSE; }
12703  break;
12704  case eIMPORT:
12705  nodeMask = 1;
12706  if( !(a->Arg<CSymbol*>(0)==b->Arg<CSymbol*>(0)) ) { return FALSE; }
12707  break;
12708  case eFUNCTION_DEF:
12709  nodeMask = 1;
12710  if( !(a->Arg<CFunction*>(0)==b->Arg<CFunction*>(0)) ) { return FALSE; }
12711  break;
12712  case eMODULE_DEF:
12713  nodeMask = 1;
12714  if( !(a->Arg<CModule*>(0)==b->Arg<CModule*>(0)) ) { return FALSE; }
12715  break;
12716  case ePACKAGE_DEF:
12717  nodeMask = 1;
12718  if( !(a->Arg<CPackage*>(0)==b->Arg<CPackage*>(0)) ) { return FALSE; }
12719  break;
12720  case eREPEAT_CONTROL:
12721  nodeMask = 0;
12722  break;
12723  case eDELAY_CONTROL:
12724  nodeMask = 0;
12725  break;
12726  case eEVENT_CONTROL:
12727  nodeMask = 0;
12728  break;
12729  case eEXTERNAL_REF:
12730  nodeMask = 1;
12731  if( !(a->Arg<CSymbol*>(0)==b->Arg<CSymbol*>(0)) ) { return FALSE; }
12732  break;
12733  case ePORT_DEF:
12734  nodeMask = 1;
12735  if( !(a->Arg<CPort*>(0)==b->Arg<CPort*>(0)) ) { return FALSE; }
12736  break;
12737  case eDEFPARAM:
12738  nodeMask = 0;
12739  break;
12740  case ePATH:
12741  nodeMask = 45;
12742  if( !(a->Arg<int>(0)==b->Arg<int>(0)) ) { return FALSE; }
12743  if( !(a->Arg<int>(2)==b->Arg<int>(2)) ) { return FALSE; }
12744  if( !(a->Arg<int>(3)==b->Arg<int>(3)) ) { return FALSE; }
12745  if( !(a->Arg<int>(5)==b->Arg<int>(5)) ) { return FALSE; }
12746  break;
12747  case ePATH_ASSIGN:
12748  nodeMask = 0;
12749  break;
12750  case eIFNONE_PATH_ASSIGN:
12751  nodeMask = 0;
12752  break;
12753  case eTRIGGER:
12754  nodeMask = 0;
12755  break;
12756  case ePASSIGN:
12757  nodeMask = 0;
12758  break;
12759  case eDEASSIGN:
12760  nodeMask = 0;
12761  break;
12762  case eDISABLE:
12763  nodeMask = 1;
12764  if( !(a->Arg<CSymbol*>(0)==b->Arg<CSymbol*>(0)) ) { return FALSE; }
12765  break;
12766  case eATTRIBUTE:
12767  nodeMask = 1;
12768  if( !(a->Arg<CAttr*>(0)==b->Arg<CAttr*>(0)) ) { return FALSE; }
12769  break;
12770  case eGIF:
12771  nodeMask = 0;
12772  break;
12773  case eGFOR:
12774  nodeMask = 0;
12775  break;
12776  case eGCASE:
12777  nodeMask = 0;
12778  break;
12779  case eTABLE:
12780  nodeMask = 0;
12781  break;
12782  case eTABLE_ENTRY:
12783  nodeMask = 0;
12784  break;
12785  case eTABLE_SYMBOL:
12786  nodeMask = 1;
12787  if( !(!strcmp(a->Arg<char*>(0),b->Arg<char*>(0))) ) { return FALSE; }
12788  break;
12789  case ePORTLIST_END:
12790  nodeMask = 0;
12791  break;
12792  case eMACRO_EXPR:
12793  nodeMask = 1;
12794  if( !(!strcmp(a->Arg<char*>(0),b->Arg<char*>(0))) ) { return FALSE; }
12795  break;
12796  case eENUM_SPEC:
12797  nodeMask = 1;
12798  if( !(a->Arg<CSymbol*>(0)==b->Arg<CSymbol*>(0)) ) { return FALSE; }
12799  break;
12800  case eMEMBER:
12801  nodeMask = 2;
12802  if( !(a->Arg<CSymbol*>(1)==b->Arg<CSymbol*>(1)) ) { return FALSE; }
12803  break;
12804  case eRETURN:
12805  nodeMask = 0;
12806  break;
12807  case ePREINC:
12808  nodeMask = 0;
12809  break;
12810  case ePOSTINC:
12811  nodeMask = 0;
12812  break;
12813  case ePREDEC:
12814  nodeMask = 0;
12815  break;
12816  case ePOSTDEC:
12817  nodeMask = 0;
12818  break;
12819  case eCAST:
12820  nodeMask = 0;
12821  break;
12822  case eASSIGNMENT_PATTERN:
12823  nodeMask = 0;
12824  break;
12825  case eDOLLAR:
12826  nodeMask = 0;
12827  break;
12828  }
12829 
12830  for( int i = 0; i < a->ArgCount(); i++ ) {
12831  if( !((nodeMask>>i)&1) &&
12832  !Equivalent(a->Arg<CNode*>(i),b->Arg<CNode*>(i)) ) return FALSE;
12833  }
12834  return TRUE;
12835 }
12836 
12837 /*************************************************
12838  IsEvaluateable
12839  - returns true if expression can be evaluated
12840 **************************************************/
12841 
12843 {
12844  switch( op ) {
12845  case eFUNCTION_CALL:
12846  return CFunction::Evaluateable(Arg<CSymbol*>(0),Arg<CNode*>(1),Arg<CBlock*>(2));;
12847  case ePARAM_REF:
12848  return Arg<CParam*>(0)->GetExpression()->IsEvaluateable();
12849  case eENUM_REF:
12850  return Arg<CParam*>(0)->GetExpression()->IsEvaluateable();
12851  case eMACRO_EXPR:
12852  return Arg<CNode*>(1) ? Arg<CNode*>(1)->IsEvaluateable() : FALSE;
12853  case eVCONSTANT:
12854  case eRCONSTANT:
12855  return TRUE;
12856  case eWIDTH:
12857  case eSUB:
12858  case eMUL:
12859  case eDIV:
12860  case ePOW:
12861  case eADD:
12862  case eLSH:
12863  case eRSH:
12864  case eLSHA:
12865  case eRSHA:
12866  case eMOD:
12867  case eOR:
12868  case eAND:
12869  case eXOR:
12870  case eXNOR:
12871  case eCVRI:
12872  case eCVIR:
12873  case eREP:
12874  case eCAT:
12875  case eUCAT:
12876  case eCOM:
12877  case eNEG:
12878  case ePLUS:
12879  case eNOT:
12880  case eGT:
12881  case eGE:
12882  case eLT:
12883  case eLE:
12884  case eLAND:
12885  case eLOR:
12886  case eCEQ:
12887  case eCNE:
12888  case eEQ:
12889  case eNE:
12890  case eRAND:
12891  case eRNAND:
12892  case eROR:
12893  case eRNOR:
12894  case eRXOR:
12895  case eRXNOR:
12896  case eHOOK:
12897  break;
12898  case eERROR:
12899  case eCOMMENT:
12900  case eVRQ:
12901  case ePRAGMA:
12902  case eELIST:
12903  case eNOP:
12904  case eANDANDAND:
12905  case eINSTANCE_REF:
12906  case eGATE_REF:
12907  case eTASK_ENABLE:
12908  case eSYSTASK_CALL:
12909  case eTIMING_CALL:
12910  case eARRAY:
12911  case eNET_REF:
12912  case eVAR_REF:
12913  case ePORT_REF:
12914  case eFWD_REF:
12915  case eGENVAR_REF:
12916  case eTYPE_REF:
12917  case eNET_DECL:
12918  case eVAR_DECL:
12919  case ePARAM_DECL:
12920  case eSPECPARAM_DECL:
12921  case ePORT_DECL:
12922  case eGENVAR_DECL:
12923  case eTYPEDEF_DECL:
12924  case eLIST:
12925  case eRANGE:
12926  case eSLICE:
12927  case ePSLICE:
12928  case eMSLICE:
12929  case eINIT:
12930  case eALWAYS:
12931  case eALWAYS_LATCH:
12932  case eALWAYS_FF:
12933  case eALWAYS_COMB:
12934  case eEVENT:
12935  case eBLOCK_REF:
12936  case eSPECIFY_REF:
12937  case eASSIGN:
12938  case eGASSIGN:
12939  case eADD_ASSIGN:
12940  case eSUB_ASSIGN:
12941  case eMUL_ASSIGN:
12942  case eDIV_ASSIGN:
12943  case eMOD_ASSIGN:
12944  case eAND_ASSIGN:
12945  case eOR_ASSIGN:
12946  case eXOR_ASSIGN:
12947  case eLSH_ASSIGN:
12948  case eRSH_ASSIGN:
12949  case eLSHA_ASSIGN:
12950  case eRSHA_ASSIGN:
12951  case eFORCE:
12952  case eRELEASE:
12953  case eNBASSIGN:
12954  case ePOSEDGE:
12955  case eNEGEDGE:
12956  case eEDGE:
12957  case eEVOR:
12958  case eDELAY:
12959  case eMTM:
12960  case eIF:
12961  case eFOREVER:
12962  case eREPEAT:
12963  case eWHILE:
12964  case eWAIT:
12965  case eFOR:
12966  case eCASE:
12967  case eCASEX:
12968  case eCASEZ:
12969  case eCASEITEM:
12970  case eCASSIGN:
12971  case eARG:
12972  case eIMPORT:
12973  case eFUNCTION_DEF:
12974  case eMODULE_DEF:
12975  case ePACKAGE_DEF:
12976  case eREPEAT_CONTROL:
12977  case eDELAY_CONTROL:
12978  case eEVENT_CONTROL:
12979  case eEXTERNAL_REF:
12980  case ePORT_DEF:
12981  case eDEFPARAM:
12982  case ePATH:
12983  case ePATH_ASSIGN:
12984  case eIFNONE_PATH_ASSIGN:
12985  case eTRIGGER:
12986  case ePASSIGN:
12987  case eDEASSIGN:
12988  case eDISABLE:
12989  case eATTRIBUTE:
12990  case eGIF:
12991  case eGFOR:
12992  case eGCASE:
12993  case eTABLE:
12994  case eTABLE_ENTRY:
12995  case eTABLE_SYMBOL:
12996  case ePORTLIST_END:
12997  case eENUM_SPEC:
12998  case eMEMBER:
12999  case eRETURN:
13000  case ePREINC:
13001  case ePOSTINC:
13002  case ePREDEC:
13003  case ePOSTDEC:
13004  case eCAST:
13005  case eASSIGNMENT_PATTERN:
13006  case eDOLLAR:
13007  return FALSE;
13008  default:
13009  MASSERT( FALSE );
13010  }
13011 
13012  for( int i = 0; i < ArgCount(); i++ ) {
13013  if( !Arg<CNode*>(i)->IsEvaluateable() ) return FALSE;
13014  }
13015 
13016  return TRUE;
13017 }
13018 
13019 /*************************************************
13020  _EvalVector
13021  - Helper function for EvalVector.
13022  Evaluates constant vector expression tree.
13023  Requires tree nodes to be labeled and
13024  augmented with conversion nodes.
13025 **************************************************/
13026 
13027 
13028 void CNode::_EvalVector( CVector& v )
13029 {
13030  switch( op ) {
13031  case eVCONSTANT:
13032  { int width = v.GetWidth(); v.SetWidth(Arg<CVector*>(0)->GetWidth()); v = *Arg<CVector*>(0); v.SetWidth(width); };
13033  break;
13034  case eWIDTH:
13035  {CVector vi(Arg<CNode*>(1)->width); vi.Signed(Arg<CNode*>(1)->type==eS);v.Signed(type==eS); Arg<CNode*>(1)->_EvalVector(vi); vi.SetWidth(width);vi.Signed(type==eS); v = vi;};
13036  break;
13037  case eSUB:
13038  EVAL_VECTOR_BINARY(Sub);
13039  break;
13040  case eMUL:
13041  EVAL_VECTOR_BINARY(Mul);
13042  break;
13043  case eDIV:
13044  EVAL_VECTOR_BINARY(Div);
13045  break;
13046  case ePOW:
13047  EVAL_VECTOR_BINARY(Pow);
13048  break;
13049  case eADD:
13050  EVAL_VECTOR_BINARY(Add);
13051  break;
13052  case eLSH:
13053  EVAL_VECTOR_BINARY_SELF_RIGHT(Lsh);
13054  break;
13055  case eRSH:
13056  EVAL_VECTOR_BINARY_SELF_RIGHT(Rsh);
13057  break;
13058  case eLSHA:
13059  EVAL_VECTOR_BINARY_SELF_RIGHT(Lsha);
13060  break;
13061  case eRSHA:
13062  EVAL_VECTOR_BINARY_SELF_RIGHT(Rsha);
13063  break;
13064  case eMOD:
13065  EVAL_VECTOR_BINARY(Mod);
13066  break;
13067  case eOR:
13068  EVAL_VECTOR_BINARY(Or);
13069  break;
13070  case eAND:
13071  EVAL_VECTOR_BINARY(And);
13072  break;
13073  case eXOR:
13074  EVAL_VECTOR_BINARY(Xor);
13075  break;
13076  case eXNOR:
13077  EVAL_VECTOR_BINARY(Xnor);
13078  break;
13079  case eFUNCTION_CALL:
13080  CFunction::EvalVector(v,Arg<CSymbol*>(0),Arg<CNode*>(1),Arg<CBlock*>(2));;
13081  break;
13082  case ePARAM_REF:
13083  EVAL_VECTOR_PARAM_REF();
13084  break;
13085  case eENUM_REF:
13086  EVAL_VECTOR_ENUM_REF();
13087  break;
13088  case eCVRI:
13089  v.LoadReal( Arg<CNode*>(0)->_EvalReal() );
13090  break;
13091  case eREP:
13092  EVAL_VECTOR_BINARY(Rep);
13093  break;
13094  case eCAT:
13095  EVAL_VECTOR_BINARY(Cat);
13096  break;
13097  case eUCAT:
13098  { CVector vv(Arg<CNode*>(0)->width); Arg<CNode*>(0)->_EvalVector(vv); v = vv;};
13099  break;
13100  case eCOM:
13101  EVAL_VECTOR_UNARY(Com);
13102  break;
13103  case eNEG:
13104  EVAL_VECTOR_UNARY(Neg);
13105  break;
13106  case ePLUS:
13107  EVAL_VECTOR_UNARY(Plus);
13108  break;
13109  case eNOT:
13110  EVAL_VECTOR_UNARY(Not);
13111  break;
13112  case eGT:
13113  EVAL_RELATIONAL(Gt);
13114  break;
13115  case eGE:
13116  EVAL_RELATIONAL(Ge);
13117  break;
13118  case eLT:
13119  EVAL_RELATIONAL(Lt);
13120  break;
13121  case eLE:
13122  EVAL_RELATIONAL(Le);
13123  break;
13124  case eLAND:
13125  EVAL_VECTOR_BINARY(Land);
13126  break;
13127  case eLOR:
13128  EVAL_VECTOR_BINARY(Lor);
13129  break;
13130  case eCEQ:
13131  EVAL_RELATIONAL(Ceq);
13132  break;
13133  case eCNE:
13134  EVAL_RELATIONAL(Cne);
13135  break;
13136  case eEQ:
13137  EVAL_RELATIONAL(Eq);
13138  break;
13139  case eNE:
13140  EVAL_RELATIONAL(Ne);
13141  break;
13142  case eRAND:
13143  EVAL_VECTOR_UNARY_SELF(Rand);
13144  break;
13145  case eRNAND:
13146  EVAL_VECTOR_UNARY_SELF(Rnand);
13147  break;
13148  case eROR:
13149  EVAL_VECTOR_UNARY_SELF(Ror);
13150  break;
13151  case eRNOR:
13152  EVAL_VECTOR_UNARY_SELF(Rnor);
13153  break;
13154  case eRXOR:
13155  EVAL_VECTOR_UNARY_SELF(Rxor);
13156  break;
13157  case eRXNOR:
13158  EVAL_VECTOR_UNARY_SELF(Rxnor);
13159  break;
13160  case eHOOK:
13161  EVAL_VECTOR_HOOK();
13162  break;
13163  case eMACRO_EXPR:
13164  Arg<CNode*>(1)->EvalVector(v);
13165  break;
13166  default:
13167  MASSERT( FALSE );
13168  }
13169 }
13170 
13171 
13172 /*************************************************
13173  _EvalReal
13174  - Helper function for EvalReal.
13175  Evaluates constant real expression tree.
13176  Requires tree nodes to be labeled and
13177  augmented with conversion nodes.
13178 **************************************************/
13179 
13180 double CNode::_EvalReal()
13181 {
13182  double d;
13183  switch( op ) {
13184  case eRCONSTANT:
13185  d = s2d(Arg<char*>(0));
13186  break;
13187  case eSUB:
13188  EVAL_REAL_BINARY(Sub);
13189  break;
13190  case eMUL:
13191  EVAL_REAL_BINARY(Mul);
13192  break;
13193  case eDIV:
13194  EVAL_REAL_BINARY(Div);
13195  break;
13196  case ePOW:
13197  EVAL_REAL_BINARY(Pow);
13198  break;
13199  case eADD:
13200  EVAL_REAL_BINARY(Add);
13201  break;
13202  case eFUNCTION_CALL:
13203  d = CFunction::EvalReal(Arg<CSymbol*>(0),Arg<CNode*>(1),Arg<CBlock*>(2));;
13204  break;
13205  case ePARAM_REF:
13206  EVAL_REAL_PARAM_REF();
13207  break;
13208  case eENUM_REF:
13209  EVAL_REAL_ENUM_REF();
13210  break;
13211  case eCVIR:
13212  { CVector v(Arg<CNode*>(0)->width); v.Signed(Arg<CNode*>(0)->type == eS); Arg<CNode*>(0)->_EvalVector(v); d = v.GetReal(); };
13213  break;
13214  case eNEG:
13215  EVAL_REAL_UNARY(Neg);
13216  break;
13217  case ePLUS:
13218  EVAL_REAL_UNARY(Plus);
13219  break;
13220  case eHOOK:
13221  EVAL_REAL_HOOK();
13222  break;
13223  case eMACRO_EXPR:
13224  d = Arg<CNode*>(1)->EvalReal();
13225  break;
13226  default:
13227  MASSERT( FALSE );
13228  }
13229  return d;
13230 }
13231 /************************************************
13232  ConditionalWiden
13233  - return non-zero if op conditionally
13234  widens operands
13235 **************************************************/
13236 int CNode::ConditionalWiden()
13237 {
13238  switch( GetOp() ) {
13239  case eVCONSTANT:
13240  return 0;
13241  case eRCONSTANT:
13242  return 0;
13243  case eELIST:
13244  return 0;
13245  case eWIDTH:
13246  return 0;
13247  case eSUB:
13248  return 0;
13249  case eMUL:
13250  return 0;
13251  case eDIV:
13252  return 0;
13253  case ePOW:
13254  return 0;
13255  case eADD:
13256  return 0;
13257  case eLSH:
13258  return 0;
13259  case eRSH:
13260  return 0;
13261  case eLSHA:
13262  return 0;
13263  case eRSHA:
13264  return 0;
13265  case eMOD:
13266  return 0;
13267  case eOR:
13268  return 1;
13269  case eAND:
13270  return 1;
13271  case eANDANDAND:
13272  return 0;
13273  case eXOR:
13274  return 1;
13275  case eXNOR:
13276  return 1;
13277  case eSYSTASK_CALL:
13278  return 0;
13279  case eFUNCTION_CALL:
13280  return 0;
13281  case eARRAY:
13282  return 0;
13283  case eNET_REF:
13284  return 0;
13285  case eVAR_REF:
13286  return 0;
13287  case ePARAM_REF:
13288  return 0;
13289  case ePORT_REF:
13290  return 0;
13291  case eFWD_REF:
13292  return 0;
13293  case eGENVAR_REF:
13294  return 0;
13295  case eENUM_REF:
13296  return 0;
13297  case eTYPE_REF:
13298  return 0;
13299  case eRANGE:
13300  return 0;
13301  case eSLICE:
13302  return 0;
13303  case ePSLICE:
13304  return 0;
13305  case eMSLICE:
13306  return 0;
13307  case eCVRI:
13308  return 0;
13309  case eCVIR:
13310  return 0;
13311  case eREP:
13312  return 0;
13313  case eCAT:
13314  return 0;
13315  case eUCAT:
13316  return 0;
13317  case eCOM:
13318  return 0;
13319  case eNEG:
13320  return 0;
13321  case ePLUS:
13322  return 0;
13323  case eNOT:
13324  return 0;
13325  case eGT:
13326  return 0;
13327  case eGE:
13328  return 0;
13329  case eLT:
13330  return 0;
13331  case eLE:
13332  return 0;
13333  case eLAND:
13334  return 0;
13335  case eLOR:
13336  return 0;
13337  case eCEQ:
13338  return 0;
13339  case eCNE:
13340  return 0;
13341  case eEQ:
13342  return 0;
13343  case eNE:
13344  return 0;
13345  case eRAND:
13346  return 0;
13347  case eRNAND:
13348  return 0;
13349  case eROR:
13350  return 0;
13351  case eRNOR:
13352  return 0;
13353  case eRXOR:
13354  return 0;
13355  case eRXNOR:
13356  return 0;
13357  case eHOOK:
13358  return 0;
13359  case ePOSEDGE:
13360  return 0;
13361  case eNEGEDGE:
13362  return 0;
13363  case eEVOR:
13364  return 0;
13365  case eMTM:
13366  return 0;
13367  case eEXTERNAL_REF:
13368  return 0;
13369  case eATTRIBUTE:
13370  return 0;
13371  case eMACRO_EXPR:
13372  return 0;
13373  case eMEMBER:
13374  return 0;
13375  case ePREINC:
13376  return 0;
13377  case ePOSTINC:
13378  return 0;
13379  case ePREDEC:
13380  return 0;
13381  case ePOSTDEC:
13382  return 0;
13383  case eCAST:
13384  return 0;
13385  case eASSIGNMENT_PATTERN:
13386  return 0;
13387  case eDOLLAR:
13388  return 0;
13389  default:
13390  MASSERT( FALSE );
13391  }
13392  return 0;
13393 }
13394 
13395 /************************************************
13396  NodeMask
13397  - return a bit vector with 1's where the
13398  type is CNode*
13399 **************************************************/
13400 unsigned CNode::NodeMask()
13401 {
13402  switch( GetOp() ) {
13403  case eERROR:
13404  return 0;
13405  case eVCONSTANT:
13406  return 0;
13407  case eRCONSTANT:
13408  return 0;
13409  case eCOMMENT:
13410  return 0;
13411  case eVRQ:
13412  return 0;
13413  case ePRAGMA:
13414  return 0;
13415  case eELIST:
13416  return 3;
13417  case eWIDTH:
13418  return 3;
13419  case eNOP:
13420  return 0;
13421  case eSUB:
13422  return 3;
13423  case eMUL:
13424  return 3;
13425  case eDIV:
13426  return 3;
13427  case ePOW:
13428  return 3;
13429  case eADD:
13430  return 3;
13431  case eLSH:
13432  return 3;
13433  case eRSH:
13434  return 3;
13435  case eLSHA:
13436  return 3;
13437  case eRSHA:
13438  return 3;
13439  case eMOD:
13440  return 3;
13441  case eOR:
13442  return 3;
13443  case eAND:
13444  return 3;
13445  case eANDANDAND:
13446  return 3;
13447  case eXOR:
13448  return 3;
13449  case eXNOR:
13450  return 3;
13451  case eINSTANCE_REF:
13452  return 0;
13453  case eGATE_REF:
13454  return 0;
13455  case eTASK_ENABLE:
13456  return 2;
13457  case eSYSTASK_CALL:
13458  return 2;
13459  case eTIMING_CALL:
13460  return 2;
13461  case eFUNCTION_CALL:
13462  return 2;
13463  case eARRAY:
13464  return 3;
13465  case eNET_REF:
13466  return 0;
13467  case eVAR_REF:
13468  return 0;
13469  case ePARAM_REF:
13470  return 0;
13471  case ePORT_REF:
13472  return 0;
13473  case eFWD_REF:
13474  return 0;
13475  case eGENVAR_REF:
13476  return 0;
13477  case eENUM_REF:
13478  return 0;
13479  case eTYPE_REF:
13480  return 0;
13481  case eNET_DECL:
13482  return 2;
13483  case eVAR_DECL:
13484  return 2;
13485  case ePARAM_DECL:
13486  return 0;
13487  case eSPECPARAM_DECL:
13488  return 0;
13489  case ePORT_DECL:
13490  return 0;
13491  case eGENVAR_DECL:
13492  return 0;
13493  case eTYPEDEF_DECL:
13494  return 0;
13495  case eLIST:
13496  return 3;
13497  case eRANGE:
13498  return 3;
13499  case eSLICE:
13500  return 3;
13501  case ePSLICE:
13502  return 3;
13503  case eMSLICE:
13504  return 3;
13505  case eCVRI:
13506  return 1;
13507  case eCVIR:
13508  return 1;
13509  case eREP:
13510  return 3;
13511  case eCAT:
13512  return 3;
13513  case eUCAT:
13514  return 1;
13515  case eCOM:
13516  return 1;
13517  case eNEG:
13518  return 1;
13519  case ePLUS:
13520  return 1;
13521  case eNOT:
13522  return 1;
13523  case eGT:
13524  return 3;
13525  case eGE:
13526  return 3;
13527  case eLT:
13528  return 3;
13529  case eLE:
13530  return 3;
13531  case eLAND:
13532  return 3;
13533  case eLOR:
13534  return 3;
13535  case eCEQ:
13536  return 3;
13537  case eCNE:
13538  return 3;
13539  case eEQ:
13540  return 3;
13541  case eNE:
13542  return 3;
13543  case eRAND:
13544  return 1;
13545  case eRNAND:
13546  return 1;
13547  case eROR:
13548  return 1;
13549  case eRNOR:
13550  return 1;
13551  case eRXOR:
13552  return 1;
13553  case eRXNOR:
13554  return 1;
13555  case eHOOK:
13556  return 7;
13557  case eINIT:
13558  return 1;
13559  case eALWAYS:
13560  return 1;
13561  case eALWAYS_LATCH:
13562  return 1;
13563  case eALWAYS_FF:
13564  return 1;
13565  case eALWAYS_COMB:
13566  return 1;
13567  case eEVENT:
13568  return 3;
13569  case eBLOCK_REF:
13570  return 2;
13571  case eSPECIFY_REF:
13572  return 2;
13573  case eASSIGN:
13574  return 7;
13575  case eGASSIGN:
13576  return 6;
13577  case eADD_ASSIGN:
13578  return 7;
13579  case eSUB_ASSIGN:
13580  return 7;
13581  case eMUL_ASSIGN:
13582  return 7;
13583  case eDIV_ASSIGN:
13584  return 7;
13585  case eMOD_ASSIGN:
13586  return 7;
13587  case eAND_ASSIGN:
13588  return 7;
13589  case eOR_ASSIGN:
13590  return 7;
13591  case eXOR_ASSIGN:
13592  return 7;
13593  case eLSH_ASSIGN:
13594  return 7;
13595  case eRSH_ASSIGN:
13596  return 7;
13597  case eLSHA_ASSIGN:
13598  return 7;
13599  case eRSHA_ASSIGN:
13600  return 7;
13601  case eFORCE:
13602  return 3;
13603  case eRELEASE:
13604  return 1;
13605  case eNBASSIGN:
13606  return 7;
13607  case ePOSEDGE:
13608  return 1;
13609  case eNEGEDGE:
13610  return 1;
13611  case eEDGE:
13612  return 1;
13613  case eEVOR:
13614  return 3;
13615  case eDELAY:
13616  return 3;
13617  case eMTM:
13618  return 7;
13619  case eIF:
13620  return 7;
13621  case eFOREVER:
13622  return 1;
13623  case eREPEAT:
13624  return 3;
13625  case eWHILE:
13626  return 3;
13627  case eWAIT:
13628  return 3;
13629  case eFOR:
13630  return 15;
13631  case eCASE:
13632  return 3;
13633  case eCASEX:
13634  return 3;
13635  case eCASEZ:
13636  return 3;
13637  case eCASEITEM:
13638  return 3;
13639  case eCASSIGN:
13640  return 14;
13641  case eARG:
13642  return 2;
13643  case eIMPORT:
13644  return 0;
13645  case eFUNCTION_DEF:
13646  return 0;
13647  case eMODULE_DEF:
13648  return 0;
13649  case ePACKAGE_DEF:
13650  return 0;
13651  case eREPEAT_CONTROL:
13652  return 3;
13653  case eDELAY_CONTROL:
13654  return 1;
13655  case eEVENT_CONTROL:
13656  return 1;
13657  case eEXTERNAL_REF:
13658  return 0;
13659  case ePORT_DEF:
13660  return 0;
13661  case eDEFPARAM:
13662  return 3;
13663  case ePATH:
13664  return 82;
13665  case ePATH_ASSIGN:
13666  return 7;
13667  case eIFNONE_PATH_ASSIGN:
13668  return 3;
13669  case eTRIGGER:
13670  return 1;
13671  case ePASSIGN:
13672  return 3;
13673  case eDEASSIGN:
13674  return 1;
13675  case eDISABLE:
13676  return 0;
13677  case eATTRIBUTE:
13678  return 0;
13679  case eGIF:
13680  return 7;
13681  case eGFOR:
13682  return 15;
13683  case eGCASE:
13684  return 3;
13685  case eTABLE:
13686  return 1;
13687  case eTABLE_ENTRY:
13688  return 1;
13689  case eTABLE_SYMBOL:
13690  return 0;
13691  case ePORTLIST_END:
13692  return 0;
13693  case eMACRO_EXPR:
13694  return 2;
13695  case eENUM_SPEC:
13696  return 6;
13697  case eMEMBER:
13698  return 1;
13699  case eRETURN:
13700  return 1;
13701  case ePREINC:
13702  return 1;
13703  case ePOSTINC:
13704  return 1;
13705  case ePREDEC:
13706  return 1;
13707  case ePOSTDEC:
13708  return 1;
13709  case eCAST:
13710  return 3;
13711  case eASSIGNMENT_PATTERN:
13712  return 1;
13713  case eDOLLAR:
13714  return 0;
13715  default:
13716  MASSERT( FALSE );
13717  }
13718  return 0;
13719 }
13720 
13721 /************************************************
13722  WidthFixed
13723  - return non-zero if op has fixed
13724  self determined width
13725 **************************************************/
13726 int CNode::WidthFixed()
13727 {
13728  switch( GetOp() ) {
13729  case eVCONSTANT:
13730  return NodeMask()==0;
13731  case eRCONSTANT:
13732  return 1;
13733  case eELIST:
13734  return NodeMask()==0;
13735  case eWIDTH:
13736  return NodeMask()==0;
13737  case eSUB:
13738  return NodeMask()==0;
13739  case eMUL:
13740  return NodeMask()==0;
13741  case eDIV:
13742  return NodeMask()==0;
13743  case ePOW:
13744  return NodeMask()==0;
13745  case eADD:
13746  return NodeMask()==0;
13747  case eLSH:
13748  return NodeMask()==0;
13749  case eRSH:
13750  return NodeMask()==0;
13751  case eLSHA:
13752  return NodeMask()==0;
13753  case eRSHA:
13754  return NodeMask()==0;
13755  case eMOD:
13756  return NodeMask()==0;
13757  case eOR:
13758  return NodeMask()==0;
13759  case eAND:
13760  return NodeMask()==0;
13761  case eANDANDAND:
13762  return NodeMask()==0;
13763  case eXOR:
13764  return NodeMask()==0;
13765  case eXNOR:
13766  return NodeMask()==0;
13767  case eSYSTASK_CALL:
13768  return NodeMask()==0;
13769  case eFUNCTION_CALL:
13770  return NodeMask()==0;
13771  case eARRAY:
13772  return NodeMask()==0;
13773  case eNET_REF:
13774  return NodeMask()==0;
13775  case eVAR_REF:
13776  return NodeMask()==0;
13777  case ePARAM_REF:
13778  return NodeMask()==0;
13779  case ePORT_REF:
13780  return NodeMask()==0;
13781  case eFWD_REF:
13782  return NodeMask()==0;
13783  case eGENVAR_REF:
13784  return NodeMask()==0;
13785  case eENUM_REF:
13786  return NodeMask()==0;
13787  case eTYPE_REF:
13788  return 1;
13789  case eRANGE:
13790  return NodeMask()==0;
13791  case eSLICE:
13792  return NodeMask()==0;
13793  case ePSLICE:
13794  return NodeMask()==0;
13795  case eMSLICE:
13796  return NodeMask()==0;
13797  case eCVRI:
13798  return 1;
13799  case eCVIR:
13800  return 1;
13801  case eREP:
13802  return NodeMask()==0;
13803  case eCAT:
13804  return NodeMask()==0;
13805  case eUCAT:
13806  return NodeMask()==0;
13807  case eCOM:
13808  return NodeMask()==0;
13809  case eNEG:
13810  return NodeMask()==0;
13811  case ePLUS:
13812  return NodeMask()==0;
13813  case eNOT:
13814  return 1;
13815  case eGT:
13816  return 1;
13817  case eGE:
13818  return 1;
13819  case eLT:
13820  return 1;
13821  case eLE:
13822  return 1;
13823  case eLAND:
13824  return 1;
13825  case eLOR:
13826  return 1;
13827  case eCEQ:
13828  return 1;
13829  case eCNE:
13830  return 1;
13831  case eEQ:
13832  return 1;
13833  case eNE:
13834  return 1;
13835  case eRAND:
13836  return 1;
13837  case eRNAND:
13838  return 1;
13839  case eROR:
13840  return 1;
13841  case eRNOR:
13842  return 1;
13843  case eRXOR:
13844  return 1;
13845  case eRXNOR:
13846  return 1;
13847  case eHOOK:
13848  return NodeMask()==0;
13849  case ePOSEDGE:
13850  return NodeMask()==0;
13851  case eNEGEDGE:
13852  return NodeMask()==0;
13853  case eEVOR:
13854  return NodeMask()==0;
13855  case eMTM:
13856  return NodeMask()==0;
13857  case eEXTERNAL_REF:
13858  return NodeMask()==0;
13859  case eATTRIBUTE:
13860  return 1;
13861  case eMACRO_EXPR:
13862  return NodeMask()==0;
13863  case eMEMBER:
13864  return NodeMask()==0;
13865  case ePREINC:
13866  return NodeMask()==0;
13867  case ePOSTINC:
13868  return NodeMask()==0;
13869  case ePREDEC:
13870  return NodeMask()==0;
13871  case ePOSTDEC:
13872  return NodeMask()==0;
13873  case eCAST:
13874  return NodeMask()==0;
13875  case eASSIGNMENT_PATTERN:
13876  return 1;
13877  case eDOLLAR:
13878  return 1;
13879  default:
13880  MASSERT( FALSE );
13881  }
13882  return 0;
13883 }
13884 
13885 /************************************************
13886  _LabelBits
13887  - labels type and width fields bottom up
13888 **************************************************/
13891  int error;
13892 };
13893 
13894 void CNode::_LabelBits( CNode* n, void* arg )
13895 {
13896  /*
13897  * If label caching is enabled, don't remark nodes
13898  * already visited. Also disable caching when the
13899  * the eval stack is in use and the node was allocated from
13900  * it as its pointers are temporary and will be recycled.
13901  */
13902  if( labelCacheEnabled && (evalCount == 0 || !evalHeap.IsOwner(n)) ) {
13903  if( labelCache.find(n) != labelCache.end() ) {
13904  return;
13905  }
13906  labelCache[n] = 1;
13907  }
13908 
13909 
13910  LabelBitsInfo* info = (LabelBitsInfo*)arg;
13911  int suppressErrorMessages = info->suppressErrorMessages;
13912  unsigned nodeMask = n->NodeMask();
13913  int conditionalWiden = n->ConditionalWiden();
13914 
13915  switch( n->GetOp() ) {
13916  case eVCONSTANT:
13917  n->type = n->Arg<CVector*>(0)->GetNodeType();
13918  break;
13919  case eRCONSTANT:
13920  if(1) {
13921  n->type = eR;
13922  }
13923  break;
13924  case eELIST:
13925  if( n->Arg<CNode*>(0)->type == eR ) {
13926  info->error = 1;
13927  if( !suppressErrorMessages ) {
13928  error(n->GetCoord(), "Illegal expression operand" );
13929  }
13930  } else if( n->Arg<CNode*>(1)->type == eR ) {
13931  info->error = 1;
13932  if( !suppressErrorMessages ) {
13933  error(n->GetCoord(), "Illegal expression operand" );
13934  }
13935  } else if(1) {
13936  n->type = eB;
13937  }
13938  break;
13939  case eWIDTH:
13940  if( n->Arg<CNode*>(1)->type == eS ) {
13941  n->type = eS;
13942  } else if(1) {
13943  n->type = eB;
13944  }
13945  break;
13946  case eSUB:
13947  if( n->Arg<CNode*>(0)->type == eR ) {
13948  n->type = eR;
13949  } else if( n->Arg<CNode*>(1)->type == eR ) {
13950  n->type = eR;
13951  } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
13952  n->type = eS;
13953  } else if(1) {
13954  n->type = eB;
13955  }
13956  break;
13957  case eMUL:
13958  if( n->Arg<CNode*>(0)->type == eR ) {
13959  n->type = eR;
13960  } else if( n->Arg<CNode*>(1)->type == eR ) {
13961  n->type = eR;
13962  } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
13963  n->type = eS;
13964  } else if(1) {
13965  n->type = eB;
13966  }
13967  break;
13968  case eDIV:
13969  if( n->Arg<CNode*>(0)->type == eR ) {
13970  n->type = eR;
13971  } else if( n->Arg<CNode*>(1)->type == eR ) {
13972  n->type = eR;
13973  } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
13974  n->type = eS;
13975  } else if(1) {
13976  n->type = eB;
13977  }
13978  break;
13979  case ePOW:
13980  if( n->Arg<CNode*>(0)->type == eR ) {
13981  n->type = eR;
13982  } else if( n->Arg<CNode*>(1)->type == eR ) {
13983  n->type = eR;
13984  } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
13985  n->type = eS;
13986  } else if(1) {
13987  n->type = eB;
13988  }
13989  break;
13990  case eADD:
13991  if( n->Arg<CNode*>(0)->type == eR ) {
13992  n->type = eR;
13993  } else if( n->Arg<CNode*>(1)->type == eR ) {
13994  n->type = eR;
13995  } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
13996  n->type = eS;
13997  } else if(1) {
13998  n->type = eB;
13999  }
14000  break;
14001  case eLSH:
14002  if( n->Arg<CNode*>(0)->type == eS ) {
14003  n->type = eS;
14004  } else if(1) {
14005  n->type = eB;
14006  }
14007  break;
14008  case eRSH:
14009  if( n->Arg<CNode*>(0)->type == eS ) {
14010  n->type = eS;
14011  } else if(1) {
14012  n->type = eB;
14013  }
14014  break;
14015  case eLSHA:
14016  if( n->Arg<CNode*>(0)->type == eS ) {
14017  n->type = eS;
14018  } else if(1) {
14019  n->type = eB;
14020  }
14021  break;
14022  case eRSHA:
14023  if( n->Arg<CNode*>(0)->type == eS ) {
14024  n->type = eS;
14025  } else if(1) {
14026  n->type = eB;
14027  }
14028  break;
14029  case eMOD:
14030  if( n->Arg<CNode*>(0)->type == eR ) {
14031  info->error = 1;
14032  if( !suppressErrorMessages ) {
14033  error(n->GetCoord(), "Illegal expression operand" );
14034  }
14035  } else if( n->Arg<CNode*>(1)->type == eR ) {
14036  info->error = 1;
14037  if( !suppressErrorMessages ) {
14038  error(n->GetCoord(), "Illegal expression operand" );
14039  }
14040  } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
14041  n->type = eS;
14042  } else if(1) {
14043  n->type = eB;
14044  }
14045  break;
14046  case eOR:
14047  if( n->Arg<CNode*>(0)->type == eR ) {
14048  info->error = 1;
14049  if( !suppressErrorMessages ) {
14050  error(n->GetCoord(), "Illegal expression operand" );
14051  }
14052  } else if( n->Arg<CNode*>(1)->type == eR ) {
14053  info->error = 1;
14054  if( !suppressErrorMessages ) {
14055  error(n->GetCoord(), "Illegal expression operand" );
14056  }
14057  } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
14058  n->type = eS;
14059  } else if(1) {
14060  n->type = eB;
14061  }
14062  break;
14063  case eAND:
14064  if( n->Arg<CNode*>(0)->type == eR ) {
14065  info->error = 1;
14066  if( !suppressErrorMessages ) {
14067  error(n->GetCoord(), "Illegal expression operand" );
14068  }
14069  } else if( n->Arg<CNode*>(1)->type == eR ) {
14070  info->error = 1;
14071  if( !suppressErrorMessages ) {
14072  error(n->GetCoord(), "Illegal expression operand" );
14073  }
14074  } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
14075  n->type = eS;
14076  } else if(1) {
14077  n->type = eB;
14078  }
14079  break;
14080  case eANDANDAND:
14081  if( n->Arg<CNode*>(0)->type == eR ) {
14082  info->error = 1;
14083  if( !suppressErrorMessages ) {
14084  error(n->GetCoord(), "Illegal expression operand" );
14085  }
14086  } else if( n->Arg<CNode*>(1)->type == eR ) {
14087  info->error = 1;
14088  if( !suppressErrorMessages ) {
14089  error(n->GetCoord(), "Illegal expression operand" );
14090  }
14091  } else if(1) {
14092  n->type = eB;
14093  }
14094  break;
14095  case eXOR:
14096  if( n->Arg<CNode*>(0)->type == eR ) {
14097  info->error = 1;
14098  if( !suppressErrorMessages ) {
14099  error(n->GetCoord(), "Illegal expression operand" );
14100  }
14101  } else if( n->Arg<CNode*>(1)->type == eR ) {
14102  info->error = 1;
14103  if( !suppressErrorMessages ) {
14104  error(n->GetCoord(), "Illegal expression operand" );
14105  }
14106  } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
14107  n->type = eS;
14108  } else if(1) {
14109  n->type = eB;
14110  }
14111  break;
14112  case eXNOR:
14113  if( n->Arg<CNode*>(0)->type == eR ) {
14114  info->error = 1;
14115  if( !suppressErrorMessages ) {
14116  error(n->GetCoord(), "Illegal expression operand" );
14117  }
14118  } else if( n->Arg<CNode*>(1)->type == eR ) {
14119  info->error = 1;
14120  if( !suppressErrorMessages ) {
14121  error(n->GetCoord(), "Illegal expression operand" );
14122  }
14123  } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
14124  n->type = eS;
14125  } else if(1) {
14126  n->type = eB;
14127  }
14128  break;
14129  case eSYSTASK_CALL:
14130  n->type = Systask::Type(n->Arg<CSymbol*>(0),n->Arg<CNode*>(1));
14131  break;
14132  case eFUNCTION_CALL:
14133  n->type = CFunction::Type(n->Arg<CSymbol*>(0),n->Arg<CNode*>(1),n->Arg<CScope*>(2));
14134  break;
14135  case eARRAY:
14136  n->type = Array::Type(n->Arg<CNode*>(0),n->Arg<CNode*>(1));
14137  break;
14138  case eNET_REF:
14139  n->type = n->Arg<CNet*>(0)->GetNodeType();
14140  break;
14141  case eVAR_REF:
14142  n->type = n->Arg<CVar*>(0)->GetNodeType();
14143  break;
14144  case ePARAM_REF:
14145  n->type = n->Arg<CParam*>(0)->GetNodeType();
14146  break;
14147  case ePORT_REF:
14148  n->type = n->Arg<CPortDir*>(0)->GetNodeType();
14149  break;
14150  case eFWD_REF:
14151  if(1) {
14152  n->type = eB;
14153  }
14154  break;
14155  case eGENVAR_REF:
14156  n->type = n->Arg<CGenvar*>(0)->GetNodeType();
14157  break;
14158  case eENUM_REF:
14159  n->type = n->Arg<CEnum*>(0)->GetNodeType();
14160  break;
14161  case eTYPE_REF:
14162  if(1) {
14163  n->type = eS;
14164  }
14165  break;
14166  case eRANGE:
14167  if( n->Arg<CNode*>(0)->type == eR ) {
14168  info->error = 1;
14169  if( !suppressErrorMessages ) {
14170  error(n->GetCoord(), "Illegal expression operand" );
14171  }
14172  } else if( n->Arg<CNode*>(1)->type == eR ) {
14173  info->error = 1;
14174  if( !suppressErrorMessages ) {
14175  error(n->GetCoord(), "Illegal expression operand" );
14176  }
14177  } else if(1) {
14178  n->type = eB;
14179  }
14180  break;
14181  case eSLICE:
14182  if( n->Arg<CNode*>(0)->type == eR ) {
14183  info->error = 1;
14184  if( !suppressErrorMessages ) {
14185  error(n->GetCoord(), "Illegal expression operand" );
14186  }
14187  } else if( n->Arg<CNode*>(1)->type == eR ) {
14188  info->error = 1;
14189  if( !suppressErrorMessages ) {
14190  error(n->GetCoord(), "Illegal expression operand" );
14191  }
14192  } else if(1) {
14193  n->type = eB;
14194  }
14195  break;
14196  case ePSLICE:
14197  if( n->Arg<CNode*>(1)->type == eR ) {
14198  info->error = 1;
14199  if( !suppressErrorMessages ) {
14200  error(n->GetCoord(), "Illegal expression operand" );
14201  }
14202  } else if(1) {
14203  n->type = eB;
14204  }
14205  break;
14206  case eMSLICE:
14207  if( n->Arg<CNode*>(1)->type == eR ) {
14208  info->error = 1;
14209  if( !suppressErrorMessages ) {
14210  error(n->GetCoord(), "Illegal expression operand" );
14211  }
14212  } else if(1) {
14213  n->type = eB;
14214  }
14215  break;
14216  case eCVRI:
14217  if(1) {
14218  n->type = eS;
14219  }
14220  break;
14221  case eCVIR:
14222  if(1) {
14223  n->type = eR;
14224  }
14225  break;
14226  case eREP:
14227  if( n->Arg<CNode*>(0)->type == eR ) {
14228  info->error = 1;
14229  if( !suppressErrorMessages ) {
14230  error(n->GetCoord(), "Illegal expression operand" );
14231  }
14232  } else if( n->Arg<CNode*>(1)->type == eR ) {
14233  info->error = 1;
14234  if( !suppressErrorMessages ) {
14235  error(n->GetCoord(), "Illegal expression operand" );
14236  }
14237  } else if(1) {
14238  n->type = eB;
14239  }
14240  break;
14241  case eCAT:
14242  if( n->Arg<CNode*>(0)->type == eR ) {
14243  info->error = 1;
14244  if( !suppressErrorMessages ) {
14245  error(n->GetCoord(), "Illegal expression operand" );
14246  }
14247  } else if( n->Arg<CNode*>(1)->type == eR ) {
14248  info->error = 1;
14249  if( !suppressErrorMessages ) {
14250  error(n->GetCoord(), "Illegal expression operand" );
14251  }
14252  } else if(1) {
14253  n->type = eB;
14254  }
14255  break;
14256  case eUCAT:
14257  if( n->Arg<CNode*>(0)->type == eR ) {
14258  info->error = 1;
14259  if( !suppressErrorMessages ) {
14260  error(n->GetCoord(), "Illegal expression operand" );
14261  }
14262  } else if(1) {
14263  n->type = eB;
14264  }
14265  break;
14266  case eCOM:
14267  if( n->Arg<CNode*>(0)->type == eR ) {
14268  info->error = 1;
14269  if( !suppressErrorMessages ) {
14270  error(n->GetCoord(), "Illegal expression operand" );
14271  }
14272  } else if( n->Arg<CNode*>(0)->type == eS ) {
14273  n->type = eS;
14274  } else if(1) {
14275  n->type = eB;
14276  }
14277  break;
14278  case eNEG:
14279  n->type = n->Arg<CNode*>(0)->type;
14280  break;
14281  case ePLUS:
14282  n->type = n->Arg<CNode*>(0)->type;
14283  break;
14284  case eNOT:
14285  if(1) {
14286  n->type = eB;
14287  }
14288  break;
14289  case eGT:
14290  if(1) {
14291  n->type = eB;
14292  }
14293  break;
14294  case eGE:
14295  if(1) {
14296  n->type = eB;
14297  }
14298  break;
14299  case eLT:
14300  if(1) {
14301  n->type = eB;
14302  }
14303  break;
14304  case eLE:
14305  if(1) {
14306  n->type = eB;
14307  }
14308  break;
14309  case eLAND:
14310  if(1) {
14311  n->type = eB;
14312  }
14313  break;
14314  case eLOR:
14315  if(1) {
14316  n->type = eB;
14317  }
14318  break;
14319  case eCEQ:
14320  if( n->Arg<CNode*>(0)->type == eR ) {
14321  info->error = 1;
14322  if( !suppressErrorMessages ) {
14323  error(n->GetCoord(), "Illegal expression operand" );
14324  }
14325  } else if( n->Arg<CNode*>(1)->type == eR ) {
14326  info->error = 1;
14327  if( !suppressErrorMessages ) {
14328  error(n->GetCoord(), "Illegal expression operand" );
14329  }
14330  } else if(1) {
14331  n->type = eB;
14332  }
14333  break;
14334  case eCNE:
14335  if( n->Arg<CNode*>(0)->type == eR ) {
14336  info->error = 1;
14337  if( !suppressErrorMessages ) {
14338  error(n->GetCoord(), "Illegal expression operand" );
14339  }
14340  } else if( n->Arg<CNode*>(1)->type == eR ) {
14341  info->error = 1;
14342  if( !suppressErrorMessages ) {
14343  error(n->GetCoord(), "Illegal expression operand" );
14344  }
14345  } else if(1) {
14346  n->type = eB;
14347  }
14348  break;
14349  case eEQ:
14350  if(1) {
14351  n->type = eB;
14352  }
14353  break;
14354  case eNE:
14355  if(1) {
14356  n->type = eB;
14357  }
14358  break;
14359  case eRAND:
14360  if( n->Arg<CNode*>(0)->type == eR ) {
14361  info->error = 1;
14362  if( !suppressErrorMessages ) {
14363  error(n->GetCoord(), "Illegal expression operand" );
14364  }
14365  } else if(1) {
14366  n->type = eB;
14367  }
14368  break;
14369  case eRNAND:
14370  if( n->Arg<CNode*>(0)->type == eR ) {
14371  info->error = 1;
14372  if( !suppressErrorMessages ) {
14373  error(n->GetCoord(), "Illegal expression operand" );
14374  }
14375  } else if(1) {
14376  n->type = eB;
14377  }
14378  break;
14379  case eROR:
14380  if( n->Arg<CNode*>(0)->type == eR ) {
14381  info->error = 1;
14382  if( !suppressErrorMessages ) {
14383  error(n->GetCoord(), "Illegal expression operand" );
14384  }
14385  } else if(1) {
14386  n->type = eB;
14387  }
14388  break;
14389  case eRNOR:
14390  if( n->Arg<CNode*>(0)->type == eR ) {
14391  info->error = 1;
14392  if( !suppressErrorMessages ) {
14393  error(n->GetCoord(), "Illegal expression operand" );
14394  }
14395  } else if(1) {
14396  n->type = eB;
14397  }
14398  break;
14399  case eRXOR:
14400  if( n->Arg<CNode*>(0)->type == eR ) {
14401  info->error = 1;
14402  if( !suppressErrorMessages ) {
14403  error(n->GetCoord(), "Illegal expression operand" );
14404  }
14405  } else if(1) {
14406  n->type = eB;
14407  }
14408  break;
14409  case eRXNOR:
14410  if( n->Arg<CNode*>(0)->type == eR ) {
14411  info->error = 1;
14412  if( !suppressErrorMessages ) {
14413  error(n->GetCoord(), "Illegal expression operand" );
14414  }
14415  } else if(1) {
14416  n->type = eB;
14417  }
14418  break;
14419  case eHOOK:
14420  if( n->Arg<CNode*>(1)->type == eR ) {
14421  n->type = eR;
14422  } else if( n->Arg<CNode*>(2)->type == eR ) {
14423  n->type = eR;
14424  } else if( n->Arg<CNode*>(1)->type == eS && n->Arg<CNode*>(2)->type == eS ) {
14425  n->type = eS;
14426  } else if(1) {
14427  n->type = eB;
14428  }
14429  break;
14430  case ePOSEDGE:
14431  if(1) {
14432  n->type = eE;
14433  }
14434  break;
14435  case eNEGEDGE:
14436  if(1) {
14437  n->type = eE;
14438  }
14439  break;
14440  case eEVOR:
14441  if(1) {
14442  n->type = eE;
14443  }
14444  break;
14445  case eMTM:
14446  if( n->Arg<CNode*>(0)->type == eR ) {
14447  n->type = eR;
14448  } else if( n->Arg<CNode*>(1)->type == eR ) {
14449  n->type = eR;
14450  } else if( n->Arg<CNode*>(2)->type == eR ) {
14451  n->type = eR;
14452  } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS && n->Arg<CNode*>(2)->type == eS ) {
14453  n->type = eS;
14454  } else if(1) {
14455  n->type = eB;
14456  }
14457  break;
14458  case eEXTERNAL_REF:
14459  n->type = External::Type(n->Arg<CSymbol*>(0));
14460  break;
14461  case eATTRIBUTE:
14462  if(1) {
14463  n->type = eU;
14464  }
14465  break;
14466  case eMACRO_EXPR:
14467  n->type = n->Arg<CNode*>(1)->type;
14468  break;
14469  case eMEMBER:
14470  n->type = Member::Type(n->Arg<CNode*>(0),n->Arg<CSymbol*>(1));
14471  break;
14472  case ePREINC:
14473  if( n->Arg<CNode*>(0)->type == eR ) {
14474  n->type = eR;
14475  } else if( n->Arg<CNode*>(0)->type == eS ) {
14476  n->type = eS;
14477  } else if(1) {
14478  n->type = eB;
14479  }
14480  break;
14481  case ePOSTINC:
14482  if( n->Arg<CNode*>(0)->type == eR ) {
14483  n->type = eR;
14484  } else if( n->Arg<CNode*>(0)->type == eS ) {
14485  n->type = eS;
14486  } else if(1) {
14487  n->type = eB;
14488  }
14489  break;
14490  case ePREDEC:
14491  if( n->Arg<CNode*>(0)->type == eR ) {
14492  n->type = eR;
14493  } else if( n->Arg<CNode*>(0)->type == eS ) {
14494  n->type = eS;
14495  } else if(1) {
14496  n->type = eB;
14497  }
14498  break;
14499  case ePOSTDEC:
14500  if( n->Arg<CNode*>(0)->type == eR ) {
14501  n->type = eR;
14502  } else if( n->Arg<CNode*>(0)->type == eS ) {
14503  n->type = eS;
14504  } else if(1) {
14505  n->type = eB;
14506  }
14507  break;
14508  case eCAST:
14509  if(1) {
14510  n->type = eB;
14511  }
14512  break;
14513  case eASSIGNMENT_PATTERN:
14514  n->type = n->Arg<CNode*>(0)->type;
14515  break;
14516  case eDOLLAR:
14517  if(1) {
14518  n->type = eB;
14519  }
14520  break;
14521  default:
14522  MASSERT( FALSE );
14523  }
14524 
14525  /*
14526  * enforce width conventions for fixed width types
14527  */
14528  switch( n->type ) {
14529  case eU:
14530  case eE:
14531  case eR:
14532  n->width = 0;
14533  return;
14534  }
14535 
14536  /*
14537  * set node width
14538  */
14539  switch( n->GetOp() ) {
14540  case eERROR:
14541  n->width = 0;
14542  break;
14543  case eVCONSTANT:
14544  n->width = (!n->Arg<CVector*>(0)->IsWidthEvaluateable()&&suppressErrorMessages) ? 0 : n->Arg<CVector*>(0)->GetWidth();
14545  break;
14546  case eRCONSTANT:
14547  n->width = 0;
14548  break;
14549  case eELIST:
14550  n->width = cADD(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
14551  break;
14552  case eWIDTH:
14553  n->width = ((info->error |= !n->Arg<CNode*>(0)->IsEvaluateable())&&suppressErrorMessages) ? 0 : n->Arg<CNode*>(0)->EvalINT32();
14554  break;
14555  case eSUB:
14556  n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
14557  break;
14558  case eMUL:
14559  n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
14560  break;
14561  case eDIV:
14562  n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
14563  break;
14564  case ePOW:
14565  n->width = n->Arg<CNode*>(0)->width;
14566  break;
14567  case eADD:
14568  n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
14569  break;
14570  case eLSH:
14571  n->width = n->Arg<CNode*>(0)->width;
14572  break;
14573  case eRSH:
14574  n->width = n->Arg<CNode*>(0)->width;
14575  break;
14576  case eLSHA:
14577  n->width = n->Arg<CNode*>(0)->width;
14578  break;
14579  case eRSHA:
14580  n->width = n->Arg<CNode*>(0)->width;
14581  break;
14582  case eMOD:
14583  n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
14584  break;
14585  case eOR:
14586  n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
14587  break;
14588  case eAND:
14589  n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
14590  break;
14591  case eANDANDAND:
14592  n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
14593  break;
14594  case eXOR:
14595  n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
14596  break;
14597  case eXNOR:
14598  n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
14599  break;
14600  case eSYSTASK_CALL:
14601  n->width = Systask::Width(n->Arg<CSymbol*>(0),n->Arg<CNode*>(1));
14602  break;
14603  case eFUNCTION_CALL:
14604  n->width = CFunction::Width(n->Arg<CSymbol*>(0),n->Arg<CNode*>(1),n->Arg<CScope*>(2));
14605  break;
14606  case eARRAY:
14607  n->width = Array::Width(n->Arg<CNode*>(0),n->Arg<CNode*>(1));
14608  break;
14609  case eNET_REF:
14610  n->width = (!n->Arg<CNet*>(0)->IsWidthEvaluateable()&&suppressErrorMessages) ? 0 : n->Arg<CNet*>(0)->GetWidth();
14611  break;
14612  case eVAR_REF:
14613  n->width = (!n->Arg<CVar*>(0)->IsWidthEvaluateable()&&suppressErrorMessages) ? 0 : n->Arg<CVar*>(0)->GetWidth();
14614  break;
14615  case ePARAM_REF:
14616  n->width = (!n->Arg<CParam*>(0)->IsWidthEvaluateable()&&suppressErrorMessages) ? 0 : n->Arg<CParam*>(0)->GetWidth();
14617  break;
14618  case ePORT_REF:
14619  n->width = (!n->Arg<CPortDir*>(0)->IsWidthEvaluateable()&&suppressErrorMessages) ? 0 : n->Arg<CPortDir*>(0)->GetWidth();
14620  break;
14621  case eFWD_REF:
14622  n->width = (!n->Arg<CFref*>(0)->IsWidthEvaluateable()&&suppressErrorMessages) ? 0 : n->Arg<CFref*>(0)->GetWidth();
14623  break;
14624  case eGENVAR_REF:
14625  n->width = (!n->Arg<CGenvar*>(0)->IsWidthEvaluateable()&&suppressErrorMessages) ? 0 : n->Arg<CGenvar*>(0)->GetWidth();
14626  break;
14627  case eENUM_REF:
14628  n->width = (!n->Arg<CEnum*>(0)->IsWidthEvaluateable()&&suppressErrorMessages) ? 0 : n->Arg<CEnum*>(0)->GetWidth();
14629  break;
14630  case eTYPE_REF:
14631  n->width = 32;
14632  break;
14633  case eRANGE:
14634  n->width = cABSDIFFPLUS1(((info->error |= !n->Arg<CNode*>(0)->IsEvaluateable())&&suppressErrorMessages) ? 0: n->Arg<CNode*>(0)->EvalINT32(),((info->error |= !n->Arg<CNode*>(1)->IsEvaluateable())&&suppressErrorMessages) ? 0: n->Arg<CNode*>(1)->EvalINT32());
14635  break;
14636  case eSLICE:
14637  n->width = cABSDIFFPLUS1(((info->error |= !n->Arg<CNode*>(0)->IsEvaluateable())&&suppressErrorMessages) ? 0: n->Arg<CNode*>(0)->EvalINT32(),((info->error |= !n->Arg<CNode*>(1)->IsEvaluateable())&&suppressErrorMessages) ? 0: n->Arg<CNode*>(1)->EvalINT32());
14638  break;
14639  case ePSLICE:
14640  n->width = (!n->Arg<CNode*>(1)->IsEvaluateable()&&suppressErrorMessages) ? 0 : n->Arg<CNode*>(1)->EvalINT32();
14641  break;
14642  case eMSLICE:
14643  n->width = (!n->Arg<CNode*>(1)->IsEvaluateable()&&suppressErrorMessages) ? 0 : n->Arg<CNode*>(1)->EvalINT32();
14644  break;
14645  case eCVRI:
14646  n->width = 32;
14647  break;
14648  case eCVIR:
14649  n->width = 0;
14650  break;
14651  case eREP:
14652  n->width = cMUL(((info->error |= !n->Arg<CNode*>(0)->IsEvaluateable())&&suppressErrorMessages) ? 0: n->Arg<CNode*>(0)->EvalINT32(),n->Arg<CNode*>(1)->width);
14653  break;
14654  case eCAT:
14655  n->width = cADD(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
14656  break;
14657  case eUCAT:
14658  n->width = n->Arg<CNode*>(0)->width;
14659  break;
14660  case eCOM:
14661  n->width = n->Arg<CNode*>(0)->width;
14662  break;
14663  case eNEG:
14664  n->width = n->Arg<CNode*>(0)->width;
14665  break;
14666  case ePLUS:
14667  n->width = n->Arg<CNode*>(0)->width;
14668  break;
14669  case eNOT:
14670  n->width = 1;
14671  break;
14672  case eGT:
14673  n->width = 1;
14674  break;
14675  case eGE:
14676  n->width = 1;
14677  break;
14678  case eLT:
14679  n->width = 1;
14680  break;
14681  case eLE:
14682  n->width = 1;
14683  break;
14684  case eLAND:
14685  n->width = 1;
14686  break;
14687  case eLOR:
14688  n->width = 1;
14689  break;
14690  case eCEQ:
14691  n->width = 1;
14692  break;
14693  case eCNE:
14694  n->width = 1;
14695  break;
14696  case eEQ:
14697  n->width = 1;
14698  break;
14699  case eNE:
14700  n->width = 1;
14701  break;
14702  case eRAND:
14703  n->width = 1;
14704  break;
14705  case eRNAND:
14706  n->width = 1;
14707  break;
14708  case eROR:
14709  n->width = 1;
14710  break;
14711  case eRNOR:
14712  n->width = 1;
14713  break;
14714  case eRXOR:
14715  n->width = 1;
14716  break;
14717  case eRXNOR:
14718  n->width = 1;
14719  break;
14720  case eHOOK:
14721  n->width = cMAX(n->Arg<CNode*>(1)->width,n->Arg<CNode*>(2)->width);
14722  break;
14723  case eMTM:
14724  n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width,n->Arg<CNode*>(2)->width);
14725  break;
14726  case eEXTERNAL_REF:
14727  n->width = External::Width(n->Arg<CSymbol*>(0));
14728  break;
14729  case eATTRIBUTE:
14730  n->width = 0;
14731  break;
14732  case eMACRO_EXPR:
14733  n->width = n->Arg<CNode*>(1)->width;
14734  break;
14735  case eMEMBER:
14736  n->width = Member::Width(n->Arg<CNode*>(0),n->Arg<CSymbol*>(1));
14737  break;
14738  case ePREINC:
14739  n->width = n->Arg<CNode*>(0)->width;
14740  break;
14741  case ePOSTINC:
14742  n->width = n->Arg<CNode*>(0)->width;
14743  break;
14744  case ePREDEC:
14745  n->width = n->Arg<CNode*>(0)->width;
14746  break;
14747  case ePOSTDEC:
14748  n->width = n->Arg<CNode*>(0)->width;
14749  break;
14750  case eCAST:
14751  n->width = n->Arg<CNode*>(0)->width;
14752  break;
14753  case eASSIGNMENT_PATTERN:
14754  n->width = 0;
14755  break;
14756  case eDOLLAR:
14757  n->width = 0;
14758  break;
14759  }
14760 
14761  /*
14762  * deterimine if operands have differing width
14763  */
14764  n->FixedWidth(1);
14765  int operandWidth = -1;
14766  for( int i = 0; i < n->ArgCount(); i++ ) {
14767  if( ((nodeMask>>i)&1) && n->Arg<CNode*>(i) ) {
14768  int widthFixed = n->Arg<CNode*>(i)->WidthFixed() ||
14769  n->Arg<CNode*>(i)->FixedWidth();
14770 
14771  if( n->ConditionalWiden() && !widthFixed ) {
14772  n->FixedWidth( 0 );
14773  break;
14774  } else if( !widthFixed ) {
14775  n->FixedWidth( 0 );
14776  break;
14777  } else {
14778  int w = n->Arg<CNode*>(i)->width;
14779  if( operandWidth != w ) {
14780  if( operandWidth >= 0 ) {
14781  n->FixedWidth( 0 );
14782  break;
14783  }
14784  operandWidth = w;
14785  }
14786  }
14787  }
14788  }
14789  if( !conditionalWiden && nodeMask != 0 ) {
14790  n->FixedWidth( 0 );
14791  }
14792 }
14793 
14794 /************************************************
14795  FixBits
14796  - relabels node width based on destination
14797  width and type. Add type conversions
14798  and check argument types. Assumes
14799  LabelBits has already been called and
14800  no illegal operand types are present.
14801 **************************************************/
14802 
14803 CNode* CNode::FixBits( INT32 newWidth, NodeType_t newType )
14804 {
14805 
14806  int calculateMax = 0;
14807  int realOp = 0;
14808  int conditionalWiden = ConditionalWiden();
14809  unsigned nodeMask = NodeMask();
14810  unsigned scalarMask = 0;
14811  unsigned selfDeterminedMask = 0;
14812  switch( GetOp() ) {
14813  case eERROR:
14814  realOp = 0;
14815  break;
14816  case eVCONSTANT:
14817  realOp = 0;
14818  break;
14819  case eRCONSTANT:
14820  realOp = 0;
14821  break;
14822  case eCOMMENT:
14823  realOp = 0;
14824  break;
14825  case eVRQ:
14826  realOp = 0;
14827  break;
14828  case ePRAGMA:
14829  realOp = 0;
14830  break;
14831  case eELIST:
14832  realOp = 0;
14833  selfDeterminedMask = nodeMask;
14834  break;
14835  case eWIDTH:
14836  realOp = 0;
14837  selfDeterminedMask = nodeMask;
14838  break;
14839  case eNOP:
14840  realOp = 0;
14841  break;
14842  case eSUB:
14843  realOp = 1;
14844  break;
14845  case eMUL:
14846  realOp = 1;
14847  break;
14848  case eDIV:
14849  realOp = 1;
14850  break;
14851  case ePOW:
14852  realOp = 1;
14853  selfDeterminedMask = 1<<1;
14854  break;
14855  case eADD:
14856  realOp = 1;
14857  break;
14858  case eLSH:
14859  realOp = 0;
14860  selfDeterminedMask = 1<<1;
14861  break;
14862  case eRSH:
14863  realOp = 0;
14864  selfDeterminedMask = 1<<1;
14865  break;
14866  case eLSHA:
14867  realOp = 0;
14868  selfDeterminedMask = 1<<1;
14869  break;
14870  case eRSHA:
14871  realOp = 0;
14872  selfDeterminedMask = 1<<1;
14873  break;
14874  case eMOD:
14875  realOp = 0;
14876  break;
14877  case eOR:
14878  realOp = 0;
14879  break;
14880  case eAND:
14881  realOp = 0;
14882  break;
14883  case eANDANDAND:
14884  realOp = 0;
14885  break;
14886  case eXOR:
14887  realOp = 0;
14888  break;
14889  case eXNOR:
14890  realOp = 0;
14891  break;
14892  case eINSTANCE_REF:
14893  realOp = 0;
14894  break;
14895  case eGATE_REF:
14896  realOp = 0;
14897  break;
14898  case eTASK_ENABLE:
14899  realOp = 0;
14900  break;
14901  case eSYSTASK_CALL:
14902  realOp = 0;
14903  selfDeterminedMask = nodeMask;
14904  break;
14905  case eTIMING_CALL:
14906  realOp = 0;
14907  break;
14908  case eFUNCTION_CALL:
14909  realOp = 0;
14910  selfDeterminedMask = nodeMask;
14911  break;
14912  case eARRAY:
14913  realOp = 0;
14914  selfDeterminedMask = 1<<1;
14915  break;
14916  case eNET_REF:
14917  realOp = 0;
14918  break;
14919  case eVAR_REF:
14920  realOp = 0;
14921  break;
14922  case ePARAM_REF:
14923  realOp = 0;
14924  break;
14925  case ePORT_REF:
14926  realOp = 0;
14927  break;
14928  case eFWD_REF:
14929  realOp = 0;
14930  break;
14931  case eGENVAR_REF:
14932  realOp = 0;
14933  break;
14934  case eENUM_REF:
14935  realOp = 0;
14936  break;
14937  case eTYPE_REF:
14938  realOp = 0;
14939  break;
14940  case eNET_DECL:
14941  realOp = 0;
14942  break;
14943  case eVAR_DECL:
14944  realOp = 0;
14945  break;
14946  case ePARAM_DECL:
14947  realOp = 0;
14948  break;
14949  case eSPECPARAM_DECL:
14950  realOp = 0;
14951  break;
14952  case ePORT_DECL:
14953  realOp = 0;
14954  break;
14955  case eGENVAR_DECL:
14956  realOp = 0;
14957  break;
14958  case eTYPEDEF_DECL:
14959  realOp = 0;
14960  break;
14961  case eLIST:
14962  realOp = 0;
14963  break;
14964  case eRANGE:
14965  realOp = 0;
14966  selfDeterminedMask = nodeMask;
14967  break;
14968  case eSLICE:
14969  realOp = 0;
14970  selfDeterminedMask = nodeMask;
14971  break;
14972  case ePSLICE:
14973  realOp = 0;
14974  selfDeterminedMask = nodeMask;
14975  break;
14976  case eMSLICE:
14977  realOp = 0;
14978  selfDeterminedMask = nodeMask;
14979  break;
14980  case eCVRI:
14981  realOp = 0;
14982  selfDeterminedMask = nodeMask;
14983  break;
14984  case eCVIR:
14985  realOp = 0;
14986  selfDeterminedMask = nodeMask;
14987  break;
14988  case eREP:
14989  realOp = 0;
14990  selfDeterminedMask = nodeMask;
14991  break;
14992  case eCAT:
14993  realOp = 0;
14994  selfDeterminedMask = nodeMask;
14995  break;
14996  case eUCAT:
14997  realOp = 0;
14998  selfDeterminedMask = nodeMask;
14999  break;
15000  case eCOM:
15001  realOp = 0;
15002  break;
15003  case eNEG:
15004  realOp = 0;
15005  break;
15006  case ePLUS:
15007  realOp = 0;
15008  break;
15009  case eNOT:
15010  realOp = 0;
15011  scalarMask = 1;
15012  break;
15013  case eGT:
15014  realOp = 0;
15015  calculateMax = 1;
15016  break;
15017  case eGE:
15018  realOp = 0;
15019  calculateMax = 1;
15020  break;
15021  case eLT:
15022  realOp = 0;
15023  calculateMax = 1;
15024  break;
15025  case eLE:
15026  realOp = 0;
15027  calculateMax = 1;
15028  break;
15029  case eLAND:
15030  realOp = 0;
15031  scalarMask = 3;
15032  break;
15033  case eLOR:
15034  realOp = 0;
15035  scalarMask = 3;
15036  break;
15037  case eCEQ:
15038  realOp = 0;
15039  calculateMax = 1;
15040  break;
15041  case eCNE:
15042  realOp = 0;
15043  calculateMax = 1;
15044  break;
15045  case eEQ:
15046  realOp = 0;
15047  calculateMax = 1;
15048  break;
15049  case eNE:
15050  realOp = 0;
15051  calculateMax = 1;
15052  break;
15053  case eRAND:
15054  realOp = 0;
15055  selfDeterminedMask = nodeMask;
15056  break;
15057  case eRNAND:
15058  realOp = 0;
15059  selfDeterminedMask = nodeMask;
15060  break;
15061  case eROR:
15062  realOp = 0;
15063  selfDeterminedMask = nodeMask;
15064  break;
15065  case eRNOR:
15066  realOp = 0;
15067  selfDeterminedMask = nodeMask;
15068  break;
15069  case eRXOR:
15070  realOp = 0;
15071  selfDeterminedMask = nodeMask;
15072  break;
15073  case eRXNOR:
15074  realOp = 0;
15075  selfDeterminedMask = nodeMask;
15076  break;
15077  case eHOOK:
15078  realOp = 1;
15079  scalarMask = 1;
15080  break;
15081  case eINIT:
15082  realOp = 0;
15083  break;
15084  case eALWAYS:
15085  realOp = 0;
15086  break;
15087  case eALWAYS_LATCH:
15088  realOp = 0;
15089  break;
15090  case eALWAYS_FF:
15091  realOp = 0;
15092  break;
15093  case eALWAYS_COMB:
15094  realOp = 0;
15095  break;
15096  case eEVENT:
15097  realOp = 0;
15098  break;
15099  case eBLOCK_REF:
15100  realOp = 0;
15101  break;
15102  case eSPECIFY_REF:
15103  realOp = 0;
15104  break;
15105  case eASSIGN:
15106  realOp = 0;
15107  break;
15108  case eGASSIGN:
15109  realOp = 0;
15110  break;
15111  case eADD_ASSIGN:
15112  realOp = 0;
15113  break;
15114  case eSUB_ASSIGN:
15115  realOp = 0;
15116  break;
15117  case eMUL_ASSIGN:
15118  realOp = 0;
15119  break;
15120  case eDIV_ASSIGN:
15121  realOp = 0;
15122  break;
15123  case eMOD_ASSIGN:
15124  realOp = 0;
15125  break;
15126  case eAND_ASSIGN:
15127  realOp = 0;
15128  break;
15129  case eOR_ASSIGN:
15130  realOp = 0;
15131  break;
15132  case eXOR_ASSIGN:
15133  realOp = 0;
15134  break;
15135  case eLSH_ASSIGN:
15136  realOp = 0;
15137  break;
15138  case eRSH_ASSIGN:
15139  realOp = 0;
15140  break;
15141  case eLSHA_ASSIGN:
15142  realOp = 0;
15143  break;
15144  case eRSHA_ASSIGN:
15145  realOp = 0;
15146  break;
15147  case eFORCE:
15148  realOp = 0;
15149  break;
15150  case eRELEASE:
15151  realOp = 0;
15152  break;
15153  case eNBASSIGN:
15154  realOp = 0;
15155  break;
15156  case ePOSEDGE:
15157  realOp = 0;
15158  break;
15159  case eNEGEDGE:
15160  realOp = 0;
15161  break;
15162  case eEDGE:
15163  realOp = 0;
15164  break;
15165  case eEVOR:
15166  realOp = 0;
15167  break;
15168  case eDELAY:
15169  realOp = 0;
15170  break;
15171  case eMTM:
15172  realOp = 1;
15173  break;
15174  case eIF:
15175  realOp = 0;
15176  break;
15177  case eFOREVER:
15178  realOp = 0;
15179  break;
15180  case eREPEAT:
15181  realOp = 0;
15182  break;
15183  case eWHILE:
15184  realOp = 0;
15185  break;
15186  case eWAIT:
15187  realOp = 0;
15188  break;
15189  case eFOR:
15190  realOp = 0;
15191  break;
15192  case eCASE:
15193  realOp = 0;
15194  break;
15195  case eCASEX:
15196  realOp = 0;
15197  break;
15198  case eCASEZ:
15199  realOp = 0;
15200  break;
15201  case eCASEITEM:
15202  realOp = 0;
15203  break;
15204  case eCASSIGN:
15205  realOp = 0;
15206  break;
15207  case eARG:
15208  realOp = 0;
15209  break;
15210  case eIMPORT:
15211  realOp = 0;
15212  break;
15213  case eFUNCTION_DEF:
15214  realOp = 0;
15215  break;
15216  case eMODULE_DEF:
15217  realOp = 0;
15218  break;
15219  case ePACKAGE_DEF:
15220  realOp = 0;
15221  break;
15222  case eREPEAT_CONTROL:
15223  realOp = 0;
15224  break;
15225  case eDELAY_CONTROL:
15226  realOp = 0;
15227  break;
15228  case eEVENT_CONTROL:
15229  realOp = 0;
15230  break;
15231  case eEXTERNAL_REF:
15232  realOp = 0;
15233  break;
15234  case ePORT_DEF:
15235  realOp = 0;
15236  break;
15237  case eDEFPARAM:
15238  realOp = 0;
15239  break;
15240  case ePATH:
15241  realOp = 0;
15242  break;
15243  case ePATH_ASSIGN:
15244  realOp = 0;
15245  break;
15246  case eIFNONE_PATH_ASSIGN:
15247  realOp = 0;
15248  break;
15249  case eTRIGGER:
15250  realOp = 0;
15251  break;
15252  case ePASSIGN:
15253  realOp = 0;
15254  break;
15255  case eDEASSIGN:
15256  realOp = 0;
15257  break;
15258  case eDISABLE:
15259  realOp = 0;
15260  break;
15261  case eATTRIBUTE:
15262  realOp = 0;
15263  break;
15264  case eGIF:
15265  realOp = 0;
15266  break;
15267  case eGFOR:
15268  realOp = 0;
15269  break;
15270  case eGCASE:
15271  realOp = 0;
15272  break;
15273  case eTABLE:
15274  realOp = 0;
15275  break;
15276  case eTABLE_ENTRY:
15277  realOp = 0;
15278  break;
15279  case eTABLE_SYMBOL:
15280  realOp = 0;
15281  break;
15282  case ePORTLIST_END:
15283  realOp = 0;
15284  break;
15285  case eMACRO_EXPR:
15286  realOp = 0;
15287  break;
15288  case eENUM_SPEC:
15289  realOp = 0;
15290  break;
15291  case eMEMBER:
15292  realOp = 0;
15293  break;
15294  case eRETURN:
15295  realOp = 0;
15296  break;
15297  case ePREINC:
15298  realOp = 1;
15299  break;
15300  case ePOSTINC:
15301  realOp = 1;
15302  break;
15303  case ePREDEC:
15304  realOp = 1;
15305  break;
15306  case ePOSTDEC:
15307  realOp = 1;
15308  break;
15309  case eCAST:
15310  realOp = 0;
15311  selfDeterminedMask = nodeMask;
15312  break;
15313  case eASSIGNMENT_PATTERN:
15314  realOp = 0;
15315  selfDeterminedMask = nodeMask;
15316  break;
15317  case eDOLLAR:
15318  realOp = 0;
15319  selfDeterminedMask = nodeMask;
15320  break;
15321  default:
15322  MASSERT( FALSE );
15323  }
15324  /*
15325  * find location of all real args
15326  */
15327  unsigned realMask = 0;
15328  unsigned forceRealMask = 0;
15329  int widthsDiffer = 0;
15330  int originalWidth = width;
15331  for( int i = 0; i < ArgCount(); i++ ) {
15332  if( ((nodeMask>>i)&1) && Arg<CNode*>(i)->type == eR ) {
15333  realMask |= 1<<i;
15334  }
15335  if( ((nodeMask>>i)&1) &&
15336  Arg<CNode*>(i)->type != eR &&
15337  (Arg<CNode*>(i)->GetOp() != eVCONSTANT ||
15338  Arg<CNode*>(i)->width != width) ) {
15339  widthsDiffer = 1;
15340  }
15341  }
15342 
15343  /*
15344  * if new type is undetermined, use current type and width
15345  */
15346  if( newType == eU && newWidth == 0 ) {
15347  newType = type;
15348  newWidth = width;
15349  /*
15350  * increase expression width if new width is larger
15351  * and a vector
15352  */
15353  } else if( (newType == eB || newType == eS || newType == eU) &&
15354  (type == eB || type == eS) ) {
15355  if( newWidth > width ) {
15356  width = newWidth;
15357  }
15358  if( newType == eU ) {
15359  newType = type;
15360  }
15361  }
15362 
15363  MASSERT( newType != eR || newWidth == 0 );
15364  MASSERT( newType != eE || newWidth == 0 );
15365 
15366 
15367  /*
15368  * non-real operands are self determined when mixed with real
15369  */
15370  if( realMask ) {
15371  forceRealMask = (~realMask & nodeMask);
15372  }
15373 
15374  /*
15375  * special case for bit operations
15376  * Only widen if operand widths differ
15377  */
15378  int convertWidth = conditionalWiden && FixedWidth();
15379  if( convertWidth ) {
15380  width = originalWidth;
15381  }
15382  if( newType == eB && type == eS ) {
15383  type = eB;
15384  }
15385  /*
15386  * calculate max with of args if needed
15387  */
15388  int cWidth = width;
15389  NodeType_t cType = type;
15390  if( calculateMax ) {
15391  cType = eS;
15392  int max = 0;
15393  int foundReal = 0;
15394  int foundUnsigned = 0;
15395  for( int i = 0; i < ArgCount(); i++ ) {
15396  if( (nodeMask>>i)&1 ) {
15397  switch( Arg<CNode*>(i)->type ) {
15398  case eB:
15399  foundUnsigned = 1;
15400  break;
15401  case eR:
15402  foundReal = 1;
15403  break;
15404  }
15405  if( Arg<CNode*>(i)->width > max ) {
15406  max = Arg<CNode*>(i)->width;
15407  }
15408  }
15409  }
15410  if( foundReal ) {
15411  cWidth = 0;
15412  cType = eR;
15413  } else if( foundUnsigned ) {
15414  cType = eB;
15415  cWidth = max;
15416  } else {
15417  cWidth = max;
15418  }
15419  }
15420 
15421  /*
15422  * Fix each CNode* argument
15423  */
15424  for( int i = 0; i < ArgCount(); i++ ) {
15425  if( (nodeMask>>i)&1 ) {
15426  if( (scalarMask>>i)&1 ) {
15427  if( Arg<CNode*>(i)->type == eR ) {
15428  CNode* node;
15429  Arg<CNode*>(i) = cNE( Arg<CNode*>(i), cREAL(0), &loc );
15430  Arg<CNode*>(i)->LabelBits();
15431  } else if( type == eR ) {
15432  // Hack for ? operator
15433  CNode* node;
15434  Arg<CNode*>(i) = cCNE( Arg<CNode*>(i), cINT32(0), &loc );
15435  Arg<CNode*>(i)->LabelBits();
15436  }
15437  Arg<CNode*>(i) = Arg<CNode*>(i)->FixBits( 0, eU );
15438  } else if( (forceRealMask>>i)&1 ) {
15439  Arg<CNode*>(i) = Arg<CNode*>(i)->FixBits( 0, eR );
15440  } else if( (selfDeterminedMask>>i)&1 ) {
15441  Arg<CNode*>(i) = Arg<CNode*>(i)->FixBits( 0, eU );
15442  } else {
15443  Arg<CNode*>(i) = Arg<CNode*>(i)->FixBits( cWidth, cType );
15444  }
15445  }
15446  }
15447 
15448 
15449 
15450  /*
15451  * add conversions if needed
15452  */
15453  if( newType != eR && convertWidth ) {
15454  CNode* nn = cWIDTH(cINT32(newWidth), this);
15455  nn->width = newWidth;
15456  nn->type = type;
15457  return nn;
15458  }
15459  if( newType == eR && (type == eB || type == eS) ) {
15460  CNode* nn = cCVIR( this );
15461  nn->width = 0;
15462  nn->type = eR;
15463  return nn;
15464 
15465  } else if( (newType == eB || newType == eS) && type == eR ) {
15466  CNode* nn = cCVRI( this );
15467  nn->width = newWidth;
15468  nn->type = newType;
15469  return nn;
15470  }
15471 
15472  return this;
15473 }
15474 
15475 /*************************************************
15476  Dump
15477  - dump expression for debug
15478 **************************************************/
15479 void CNode::Dump( FILE* f )
15480 {
15481  switch( GetOp() ) {
15482  case eERROR:
15483  fprintf( f, "%s", "???" );
15484  break;
15485  case eVCONSTANT:
15486  fprintf( f, "%s", Arg<CVector*>(0)->GetVString() );
15487  break;
15488  case eRCONSTANT:
15489  fprintf( f, "%s", (char*)Arg<char*>(0) );
15490  break;
15491  case ePRAGMA:
15492  fprintf( f, "%s", (char*)Arg<char*>(0) );
15493  break;
15494  case eELIST:
15495  fprintf( f, "%s", "" );
15496  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15497  fprintf( f, "%s", "," );
15498  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15499  fprintf( f, "%s", "" );
15500  break;
15501  case eWIDTH:
15502  fprintf( f, "%s", "WIDTH(" );
15503  fprintf( f, "%s", type==eS ? "S" : "U" );
15504  fprintf( f, "%s", "," );
15505  fprintf( f, "%ld", width );
15506  fprintf( f, "%s", "," );
15507  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15508  fprintf( f, "%s", "," );
15509  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15510  fprintf( f, "%s", ")" );
15511  break;
15512  case eSUB:
15513  fprintf( f, "%s", "(" );
15514  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15515  fprintf( f, "%s", ")-(" );
15516  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15517  fprintf( f, "%s", ")" );
15518  break;
15519  case eMUL:
15520  fprintf( f, "%s", "(" );
15521  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15522  fprintf( f, "%s", ")*(" );
15523  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15524  fprintf( f, "%s", ")" );
15525  break;
15526  case eDIV:
15527  fprintf( f, "%s", "(" );
15528  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15529  fprintf( f, "%s", ")/(" );
15530  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15531  fprintf( f, "%s", ")" );
15532  break;
15533  case ePOW:
15534  fprintf( f, "%s", "(" );
15535  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15536  fprintf( f, "%s", ")**(" );
15537  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15538  fprintf( f, "%s", ")" );
15539  break;
15540  case eADD:
15541  fprintf( f, "%s", "(" );
15542  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15543  fprintf( f, "%s", ")+(" );
15544  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15545  fprintf( f, "%s", ")" );
15546  break;
15547  case eLSH:
15548  fprintf( f, "%s", "(" );
15549  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15550  fprintf( f, "%s", ")<<(" );
15551  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15552  fprintf( f, "%s", ")" );
15553  break;
15554  case eRSH:
15555  fprintf( f, "%s", "(" );
15556  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15557  fprintf( f, "%s", ")>>(" );
15558  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15559  fprintf( f, "%s", ")" );
15560  break;
15561  case eLSHA:
15562  fprintf( f, "%s", "(" );
15563  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15564  fprintf( f, "%s", ")<<<(" );
15565  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15566  fprintf( f, "%s", ")" );
15567  break;
15568  case eRSHA:
15569  fprintf( f, "%s", "(" );
15570  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15571  fprintf( f, "%s", ")>>>(" );
15572  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15573  fprintf( f, "%s", ")" );
15574  break;
15575  case eMOD:
15576  fprintf( f, "%s", "(" );
15577  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15578  fprintf( f, "%s", ")%%(" );
15579  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15580  fprintf( f, "%s", ")" );
15581  break;
15582  case eOR:
15583  fprintf( f, "%s", "(" );
15584  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15585  fprintf( f, "%s", ")|(" );
15586  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15587  fprintf( f, "%s", ")" );
15588  break;
15589  case eAND:
15590  fprintf( f, "%s", "(" );
15591  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15592  fprintf( f, "%s", ")&(" );
15593  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15594  fprintf( f, "%s", ")" );
15595  break;
15596  case eANDANDAND:
15597  fprintf( f, "%s", "(" );
15598  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15599  fprintf( f, "%s", ")&&&(" );
15600  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15601  fprintf( f, "%s", ")" );
15602  break;
15603  case eXOR:
15604  fprintf( f, "%s", "(" );
15605  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15606  fprintf( f, "%s", ")^(" );
15607  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15608  fprintf( f, "%s", ")" );
15609  break;
15610  case eXNOR:
15611  fprintf( f, "%s", "(" );
15612  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15613  fprintf( f, "%s", ")~^(" );
15614  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15615  fprintf( f, "%s", ")" );
15616  break;
15617  case eFUNCTION_CALL:
15618  fprintf( f, "%s", "" );
15619  fprintf( f, "%s", Arg<CSymbol*>(0)->GetName() );
15620  fprintf( f, "%s", "(" );
15621  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15622  fprintf( f, "%s", ")" );
15623  break;
15624  case eARRAY:
15625  fprintf( f, "%s", "" );
15626  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15627  fprintf( f, "%s", "[" );
15628  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15629  fprintf( f, "%s", "]" );
15630  break;
15631  case eNET_REF:
15632  fprintf( f, "%s", Arg<CNet*>(0)->GetName() );
15633  break;
15634  case eVAR_REF:
15635  fprintf( f, "%s", Arg<CVar*>(0)->GetName() );
15636  break;
15637  case ePARAM_REF:
15638  fprintf( f, "%s", Arg<CParam*>(0)->GetName() );
15639  break;
15640  case ePORT_REF:
15641  fprintf( f, "%s", Arg<CPort*>(0)->GetName() );
15642  break;
15643  case eFWD_REF:
15644  fprintf( f, "%s", Arg<CFref*>(0)->GetName() );
15645  break;
15646  case eGENVAR_REF:
15647  fprintf( f, "%s", Arg<CGenvar*>(0)->GetName() );
15648  break;
15649  case eENUM_REF:
15650  fprintf( f, "%s", Arg<CEnum*>(0)->GetName() );
15651  break;
15652  case eTYPE_REF:
15653  fprintf( f, "%s", Arg<CTypedef*>(0)->GetName() );
15654  break;
15655  case eVAR_DECL:
15656  fprintf( f, "%s", "VarDecl" );
15657  break;
15658  case eLIST:
15659  fprintf( f, "%s", "(" );
15660  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15661  fprintf( f, "%s", "," );
15662  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15663  fprintf( f, "%s", ")" );
15664  break;
15665  case eRANGE:
15666  fprintf( f, "%s", "" );
15667  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15668  fprintf( f, "%s", ":" );
15669  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15670  fprintf( f, "%s", "" );
15671  break;
15672  case eSLICE:
15673  fprintf( f, "%s", "" );
15674  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15675  fprintf( f, "%s", ":" );
15676  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15677  fprintf( f, "%s", "" );
15678  break;
15679  case ePSLICE:
15680  fprintf( f, "%s", "" );
15681  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15682  fprintf( f, "%s", "+:" );
15683  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15684  fprintf( f, "%s", "" );
15685  break;
15686  case eMSLICE:
15687  fprintf( f, "%s", "" );
15688  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15689  fprintf( f, "%s", "-:" );
15690  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15691  fprintf( f, "%s", "" );
15692  break;
15693  case eCVRI:
15694  fprintf( f, "%s", "CVRI(" );
15695  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15696  fprintf( f, "%s", ")" );
15697  break;
15698  case eCVIR:
15699  fprintf( f, "%s", "CVIR(" );
15700  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15701  fprintf( f, "%s", ")" );
15702  break;
15703  case eREP:
15704  fprintf( f, "%s", "{" );
15705  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15706  fprintf( f, "%s", "{" );
15707  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15708  fprintf( f, "%s", "}}" );
15709  break;
15710  case eCAT:
15711  fprintf( f, "%s", "{" );
15712  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15713  fprintf( f, "%s", "," );
15714  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15715  fprintf( f, "%s", "}" );
15716  break;
15717  case eUCAT:
15718  fprintf( f, "%s", "{" );
15719  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15720  fprintf( f, "%s", "}" );
15721  break;
15722  case eCOM:
15723  fprintf( f, "%s", "~(" );
15724  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15725  fprintf( f, "%s", ")" );
15726  break;
15727  case eNEG:
15728  fprintf( f, "%s", "-(" );
15729  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15730  fprintf( f, "%s", ")" );
15731  break;
15732  case ePLUS:
15733  fprintf( f, "%s", "+(" );
15734  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15735  fprintf( f, "%s", ")" );
15736  break;
15737  case eNOT:
15738  fprintf( f, "%s", "!(" );
15739  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15740  fprintf( f, "%s", ")" );
15741  break;
15742  case eGT:
15743  fprintf( f, "%s", "(" );
15744  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15745  fprintf( f, "%s", ")>(" );
15746  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15747  fprintf( f, "%s", ")" );
15748  break;
15749  case eGE:
15750  fprintf( f, "%s", "(" );
15751  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15752  fprintf( f, "%s", ")>=(" );
15753  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15754  fprintf( f, "%s", ")" );
15755  break;
15756  case eLT:
15757  fprintf( f, "%s", "(" );
15758  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15759  fprintf( f, "%s", ")<(" );
15760  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15761  fprintf( f, "%s", ")" );
15762  break;
15763  case eLE:
15764  fprintf( f, "%s", "(" );
15765  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15766  fprintf( f, "%s", ")<=(" );
15767  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15768  fprintf( f, "%s", ")" );
15769  break;
15770  case eLAND:
15771  fprintf( f, "%s", "(" );
15772  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15773  fprintf( f, "%s", ")&&(" );
15774  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15775  fprintf( f, "%s", ")" );
15776  break;
15777  case eLOR:
15778  fprintf( f, "%s", "(" );
15779  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15780  fprintf( f, "%s", ")||(" );
15781  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15782  fprintf( f, "%s", ")" );
15783  break;
15784  case eCEQ:
15785  fprintf( f, "%s", "(" );
15786  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15787  fprintf( f, "%s", ")===(" );
15788  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15789  fprintf( f, "%s", ")" );
15790  break;
15791  case eCNE:
15792  fprintf( f, "%s", "(" );
15793  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15794  fprintf( f, "%s", ")!==(" );
15795  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15796  fprintf( f, "%s", ")" );
15797  break;
15798  case eEQ:
15799  fprintf( f, "%s", "(" );
15800  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15801  fprintf( f, "%s", ")==(" );
15802  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15803  fprintf( f, "%s", ")" );
15804  break;
15805  case eNE:
15806  fprintf( f, "%s", "(" );
15807  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15808  fprintf( f, "%s", ")!=(" );
15809  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15810  fprintf( f, "%s", ")" );
15811  break;
15812  case eRAND:
15813  fprintf( f, "%s", "&(" );
15814  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15815  fprintf( f, "%s", ")" );
15816  break;
15817  case eRNAND:
15818  fprintf( f, "%s", "~&(" );
15819  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15820  fprintf( f, "%s", ")" );
15821  break;
15822  case eROR:
15823  fprintf( f, "%s", "|(" );
15824  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15825  fprintf( f, "%s", ")" );
15826  break;
15827  case eRNOR:
15828  fprintf( f, "%s", "~|(" );
15829  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15830  fprintf( f, "%s", ")" );
15831  break;
15832  case eRXOR:
15833  fprintf( f, "%s", "^(" );
15834  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15835  fprintf( f, "%s", ")" );
15836  break;
15837  case eRXNOR:
15838  fprintf( f, "%s", "~^(" );
15839  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15840  fprintf( f, "%s", ")" );
15841  break;
15842  case eHOOK:
15843  fprintf( f, "%s", "(" );
15844  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15845  fprintf( f, "%s", ")?(" );
15846  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15847  fprintf( f, "%s", "):(" );
15848  if( Arg<CNode*>(2) ) Arg<CNode*>(2)->Dump( f ); else fprintf( f, "NULL" );
15849  fprintf( f, "%s", ")" );
15850  break;
15851  case eINIT:
15852  fprintf( f, "%s", "INIT(*)" );
15853  break;
15854  case ePOSEDGE:
15855  fprintf( f, "%s", "POSEDGE(" );
15856  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15857  fprintf( f, "%s", ")" );
15858  break;
15859  case eNEGEDGE:
15860  fprintf( f, "%s", "NEGEDGE(" );
15861  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15862  fprintf( f, "%s", ")" );
15863  break;
15864  case eEDGE:
15865  fprintf( f, "%s", "EDGE(" );
15866  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15867  fprintf( f, "%s", ")" );
15868  break;
15869  case eMTM:
15870  fprintf( f, "%s", "(" );
15871  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15872  fprintf( f, "%s", ":" );
15873  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15874  fprintf( f, "%s", ":" );
15875  if( Arg<CNode*>(2) ) Arg<CNode*>(2)->Dump( f ); else fprintf( f, "NULL" );
15876  fprintf( f, "%s", ")" );
15877  break;
15878  case eMODULE_DEF:
15879  fprintf( f, "%s", "MODULE_DEF" );
15880  break;
15881  case ePACKAGE_DEF:
15882  fprintf( f, "%s", "PACKAGE_DEF" );
15883  break;
15884  case eMACRO_EXPR:
15885  fprintf( f, "%s", "" );
15886  fprintf( f, "%s", (const char*)Arg<const char*>(0) );
15887  fprintf( f, "%s", "<" );
15888  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15889  fprintf( f, "%s", ">" );
15890  break;
15891  case eMEMBER:
15892  fprintf( f, "%s", "" );
15893  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15894  fprintf( f, "%s", "." );
15895  fprintf( f, "%s", Arg<CSymbol*>(1)->GetName() );
15896  fprintf( f, "%s", "" );
15897  break;
15898  case ePREINC:
15899  fprintf( f, "%s", "++(" );
15900  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15901  fprintf( f, "%s", ")" );
15902  break;
15903  case ePOSTINC:
15904  fprintf( f, "%s", "(" );
15905  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15906  fprintf( f, "%s", ")++" );
15907  break;
15908  case ePREDEC:
15909  fprintf( f, "%s", "--(" );
15910  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15911  fprintf( f, "%s", ")" );
15912  break;
15913  case ePOSTDEC:
15914  fprintf( f, "%s", "(" );
15915  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15916  fprintf( f, "%s", ")--" );
15917  break;
15918  case eCAST:
15919  fprintf( f, "%s", "CAST(" );
15920  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15921  fprintf( f, "%s", "," );
15922  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15923  fprintf( f, "%s", ")" );
15924  break;
15925  case eASSIGNMENT_PATTERN:
15926  fprintf( f, "%s", "'" );
15927  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15928  fprintf( f, "%s", "" );
15929  break;
15930  case eDOLLAR:
15931  fprintf( f, "%s", "$" );
15932  break;
15933  case eCOMMENT:
15934  case eVRQ:
15935  case eNOP:
15936  case eINSTANCE_REF:
15937  case eGATE_REF:
15938  case eTASK_ENABLE:
15939  case eSYSTASK_CALL:
15940  case eTIMING_CALL:
15941  case eNET_DECL:
15942  case ePARAM_DECL:
15943  case eSPECPARAM_DECL:
15944  case ePORT_DECL:
15945  case eGENVAR_DECL:
15946  case eTYPEDEF_DECL:
15947  case eALWAYS:
15948  case eALWAYS_LATCH:
15949  case eALWAYS_FF:
15950  case eALWAYS_COMB:
15951  case eEVENT:
15952  case eBLOCK_REF:
15953  case eSPECIFY_REF:
15954  case eASSIGN:
15955  case eGASSIGN:
15956  case eADD_ASSIGN:
15957  case eSUB_ASSIGN:
15958  case eMUL_ASSIGN:
15959  case eDIV_ASSIGN:
15960  case eMOD_ASSIGN:
15961  case eAND_ASSIGN:
15962  case eOR_ASSIGN:
15963  case eXOR_ASSIGN:
15964  case eLSH_ASSIGN:
15965  case eRSH_ASSIGN:
15966  case eLSHA_ASSIGN:
15967  case eRSHA_ASSIGN:
15968  case eFORCE:
15969  case eRELEASE:
15970  case eNBASSIGN:
15971  case eEVOR:
15972  case eDELAY:
15973  case eIF:
15974  case eFOREVER:
15975  case eREPEAT:
15976  case eWHILE:
15977  case eWAIT:
15978  case eFOR:
15979  case eCASE:
15980  case eCASEX:
15981  case eCASEZ:
15982  case eCASEITEM:
15983  case eCASSIGN:
15984  case eARG:
15985  case eIMPORT:
15986  case eFUNCTION_DEF:
15987  case eREPEAT_CONTROL:
15988  case eDELAY_CONTROL:
15989  case eEVENT_CONTROL:
15990  case eEXTERNAL_REF:
15991  case ePORT_DEF:
15992  case eDEFPARAM:
15993  case ePATH:
15994  case ePATH_ASSIGN:
15995  case eIFNONE_PATH_ASSIGN:
15996  case eTRIGGER:
15997  case ePASSIGN:
15998  case eDEASSIGN:
15999  case eDISABLE:
16000  case eATTRIBUTE:
16001  case eGIF:
16002  case eGFOR:
16003  case eGCASE:
16004  case eTABLE:
16005  case eTABLE_ENTRY:
16006  case eTABLE_SYMBOL:
16007  case ePORTLIST_END:
16008  case eENUM_SPEC:
16009  case eRETURN:
16010  fprintf( f, "%s(%p)", nodeOpName[GetOp()],this );
16011  break;
16012  }
16013 }
16014 
16015 #endif // DEFINE_METHODS
16016 
16017 #ifdef DEFINE_TEST_HARNESS
16019 {
16020  for( int i = 0; i < 155; ++i ) {
16021  CNode* n = new(CNode::stack) CNode( NULL, (NodeOp_t)i );
16022  if( n->Precedence() != n->Precedence_1() ) {
16023  printf( "Fail %s\n", nodeOpName[i] );
16024  exit(1);
16025  }
16026  }
16027 }
16028 #endif // DEFINE_TEST_HARNESS
CNode * cDIV(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for DIV divide.
Definition: cnode_def.h:2989
Declaration object for nets.
Definition: cnet.h:46
CNode * cSUB(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for SUB subtract.
Definition: cnode_def.h:2923
static NodeType_t Type(CSymbol *symbol, CNode *args)
Determine type of systask.
Definition: systask.h:134
nonblocking assignment
Definition: cnode_def.h:1734
int declaration
Definition: cdatatype.h:52
CNode * cEDGE(CNode *a0, Edge_t a1, Coord_t *loc=NULL)
Node construction shortcut for EDGE edge qualifier.
Definition: cnode_def.h:5986
int HasAttribute(const char *name, CNode *n=NULL, int init=1)
Determine if node has the given attribute.
Definition: cnode.cc:412
CNode * cROR(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for ROR reduction or.
Definition: cnode_def.h:4909
CNode * cFOREVER(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for FOREVER forever statement.
Definition: cnode_def.h:6162
real constant
Definition: cnode_def.h:665
CNode * cMOD_ASSIGN(CNode *a0, CNode *a1, CNode *a2, Coord_t *loc=NULL)
Node construction shortcut for MOD_ASSIGN procedural assignment with mod.
Definition: cnode_def.h:5534
CNode * cDEASSIGN(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for DEASSIGN deassign statement.
Definition: cnode_def.h:7032
CNode * cMUL_ASSIGN(CNode *a0, CNode *a1, CNode *a2, Coord_t *loc=NULL)
Node construction shortcut for MUL_ASSIGN procedural assignment with mul.
Definition: cnode_def.h:5460
preincrement
Definition: cnode_def.h:2260
CNode * cASSIGN(CNode *a0, CNode *a1, CNode *a2, Coord_t *loc=NULL)
Node construction shortcut for ASSIGN procedural assignment.
Definition: cnode_def.h:5312
vector subrange with ascending index select
Definition: cnode_def.h:1164
force statement
Definition: cnode_def.h:1712
condition expression operator
Definition: cnode_def.h:1449
arithmetic right shift
Definition: cnode_def.h:826
CNode * cCASSIGN(StrengthPair_t *a0, CNode *a1, CNode *a2, CNode *a3, Coord_t *loc=NULL)
Node construction shortcut for CASSIGN continious assignment.
Definition: cnode_def.h:6478
procedural assignment with mul
Definition: cnode_def.h:1593
CNode * cSUB_ASSIGN(CNode *a0, CNode *a1, CNode *a2, Coord_t *loc=NULL)
Node construction shortcut for SUB_ASSIGN procedural assignment with subtract.
Definition: cnode_def.h:5423
sentinal at end of port list
Definition: cnode_def.h:2206
CNode * cPARAM_DECL(CParam *a0, Coord_t *loc=NULL)
Node construction shortcut for PARAM_DECL parameter declaration.
Definition: cnode_def.h:3942
static int WidthVolatile(CSymbol *symbol, CNode *args)
Determine if width of systask variable is volatile.
Definition: systask.h:100
CNode * cDELAY(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for DELAY delay statement.
Definition: cnode_def.h:6052
reduction xnor
Definition: cnode_def.h:1437
case not equal
Definition: cnode_def.h:1355
CNode * cMOD(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for MOD modulus.
Definition: cnode_def.h:3220
CNode * cWAIT(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for WAIT wait statement.
Definition: cnode_def.h:6258
no operation
Definition: cnode_def.h:727
Declaration object for genvars.
Definition: cgenvar.h:46
reduction nand
Definition: cnode_def.h:1397
CNode * cELIST(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for ELIST expression list.
Definition: cnode_def.h:2832
undefined
Definition: cdatatype.h:102
error node
Definition: cnode_def.h:645
CNode * cPORT_REF(CPortDir *a0, Coord_t *loc=NULL)
Node construction shortcut for PORT_REF reference to port.
Definition: cnode_def.h:3731
signed bit vector, includes integer
Definition: cdatatype.h:104
gate instance
Definition: cnode_def.h:912
procedural assignment with right shift
Definition: cnode_def.h:1677
static int WidthConstant(CSymbol *symbol, CNode *args)
Determine if width of systask variable is constant.
Definition: systask.h:82
Gate declaration object.
Definition: cgate.h:42
repeat control
Definition: cnode_def.h:1990
exponent
Definition: cnode_def.h:771
CNode * cFUNCTION_CALL(CSymbol *a0, CNode *a1, CScope *a2, Coord_t *loc=NULL)
Node construction shortcut for FUNCTION_CALL call to a function.
Definition: cnode_def.h:3576
static NodeType_t Type(CSymbol *symbol)
Determine type of external variable.
Definition: external.h:81
static int WidthVolatile(CSymbol *symbol)
Determine if width of external variable is volatile.
Definition: external.h:69
CNode * cCOMMENT(const char *a0, Coord_t *loc=NULL)
Node construction shortcut for COMMENT comment.
Definition: cnode_def.h:2740
statement block
Definition: cnode_def.h:1522
disable statement
Definition: cnode_def.h:2121
static int WidthEvaluateable(CSymbol *symbol, CNode *args, CBlock *block)
Determine if width of function is evaluateable.
procedural assignment with bitwise xor
Definition: cnode_def.h:1653
vector decl range specification
Definition: cnode_def.h:1142
case equal
Definition: cnode_def.h:1344
CNode * cREAL(double number)
Short cut for creating RCONSTANT node with a given double value.
Definition: cnode.h:817
negative event qualifier
Definition: cnode_def.h:1754
import item
Definition: cnode_def.h:1949
CNode * cDIV_ASSIGN(CNode *a0, CNode *a1, CNode *a2, Coord_t *loc=NULL)
Node construction shortcut for DIV_ASSIGN procedural assignment with div.
Definition: cnode_def.h:5497
initial block
Definition: cnode_def.h:1459
CNode * cPREDEC(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for PREDEC predecrement.
Definition: cnode_def.h:7532
CNode * cGIF(CNode *a0, CNode *a1, CNode *a2, Coord_t *loc=NULL)
Node construction shortcut for GIF structural if statement.
Definition: cnode_def.h:7121
CNode * cFWD_REF(CFref *a0, Coord_t *loc=NULL)
Node construction shortcut for FWD_REF reference to a forward declared variable.
Definition: cnode_def.h:3760
int IsEvaluateable()
Checks to see if expression tree can be evaluated.
Definition: cnode_def.h:12842
CNode * cPRAGMA(const char *a0, int a1, Coord_t *loc=NULL)
Node construction shortcut for PRAGMA program pragma.
Definition: cnode_def.h:2799
CNode * cCASEX(CNode *a0, CNode *a1, ConditionalType a2, Coord_t *loc=NULL)
Node construction shortcut for CASEX casex statement.
Definition: cnode_def.h:6370
bitwise and
Definition: cnode_def.h:859
CNode * cCAT(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for CAT concatenation operator.
Definition: cnode_def.h:4344
postincrement
Definition: cnode_def.h:2270
void Add(double *r, double *a, double *b)
Definition: cnode.h:682
CNode * cRXOR(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for RXOR reduction xor.
Definition: cnode_def.h:4967
Declaration object for specify blocks.
Definition: cspecify.h:47
CNode * cARG(CSymbol *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for ARG port connection.
Definition: cnode_def.h:6517
CNode * cMAX_N(CNode *first,...)
Definition: cnode.h:1266
CNode * cAND(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for AND bitwise and.
Definition: cnode_def.h:3286
instance reference
Definition: cnode_def.h:902
CNode * cTABLE_SYMBOL(char *a0, Coord_t *loc=NULL)
Node construction shortcut for TABLE_SYMBOL udp table symbol.
Definition: cnode_def.h:7288
CNode * cPOSEDGE(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for POSEDGE positive event qualifier.
Definition: cnode_def.h:5927
not equal
Definition: cnode_def.h:1377
CNode * cRSHA_ASSIGN(CNode *a0, CNode *a1, CNode *a2, Coord_t *loc=NULL)
Node construction shortcut for RSHA_ASSIGN procedural assignment with right arithmetic shift...
Definition: cnode_def.h:5793
CNode * cNOT(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for NOT logical complement.
Definition: cnode_def.h:4492
CNode * cRETURN(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for RETURN return.
Definition: cnode_def.h:7445
void Neg(double *r, double *a)
Definition: cnode.h:702
CNode * cCEQ(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for CEQ case equal.
Definition: cnode_def.h:4720
list of nodes
Definition: cnode_def.h:1131
greater than or equal
Definition: cnode_def.h:1289
CNode * cEQ(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for EQ equal.
Definition: cnode_def.h:4786
vector constant
Definition: cnode_def.h:655
procedural assignment
Definition: cnode_def.h:1545
assignment_pattern
Definition: cnode_def.h:2311
Coord_t * GetCoord()
Get node's file coordinates.
Definition: cnode.h:312
CNode * cNET_DECL(CNet *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for NET_DECL net declaration.
Definition: cnode_def.h:3877
wait statement
Definition: cnode_def.h:1855
CNode * cMUL_N(CNode *first,...)
Definition: cnode.h:1300
CNode * cIFNONE_PATH_ASSIGN(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for IFNONE_PATH_ASSIGN ifnone path assignment statement.
Definition: cnode_def.h:6938
static CObstack * CurrentHeap()
Gets pointer to current heap allocator.
Definition: cnode.h:237
CNode * cEVOR(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for EVOR event or.
Definition: cnode_def.h:6019
int IsConstant()
Checks expression tree to see if it is constant.
Definition: cnode_def.h:8183
CNode * GetWidthExp(void)
Create expression representing width of expression.
Definition: cnode_def.h:8837
reduction xor
Definition: cnode_def.h:1427
case item
Definition: cnode_def.h:1915
delay control
Definition: cnode_def.h:2000
CNode * cRAND(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for RAND reduction and.
Definition: cnode_def.h:4851
void SetWidth(INT32 newWidth)
Set width of vector in bits.
CNode * cNBASSIGN(CNode *a0, CNode *a1, CNode *a2, Coord_t *loc=NULL)
Node construction shortcut for NBASSIGN nonblocking assignment.
Definition: cnode_def.h:5892
CNode * cNEG(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for NEG negation.
Definition: cnode_def.h:4434
virtual INT32 GetWidth(void)
Get width of declaration.
Definition: cgenvar.h:70
CNode * cOR_ASSIGN(CNode *a0, CNode *a1, CNode *a2, Coord_t *loc=NULL)
Node construction shortcut for OR_ASSIGN procedural assignment with bitwise or.
Definition: cnode_def.h:5608
reduction nor
Definition: cnode_def.h:1417
CNode * cGT(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for GT greater than.
Definition: cnode_def.h:4522
CNode * cCVRI(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for CVRI convert real to integer.
Definition: cnode_def.h:4252
void PostVisit1(void(*callback)(CNode *, void *), void *data)
Walk tree invoking callback on each node after children have been visited.
Definition: cnode_def.h:10654
port connection
Definition: cnode_def.h:1939
long INT32
Short cut for signed 32 bit integer.
Definition: glue.h:38
arithmetic left shift
Definition: cnode_def.h:815
CNode * cDISABLE(CSymbol *a0, Coord_t *loc=NULL)
Node construction shortcut for DISABLE disable statement.
Definition: cnode_def.h:7061
CNode * cREPEAT_CONTROL(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for REPEAT_CONTROL repeat control.
Definition: cnode_def.h:6666
variable declaration
Definition: cnode_def.h:1070
int IsVolatile(void)
Checks to see if expression tree is volatile.
Definition: cnode_def.h:8349
CNode * cLSHA_ASSIGN(CNode *a0, CNode *a1, CNode *a2, Coord_t *loc=NULL)
Node construction shortcut for LSHA_ASSIGN procedural assignment with left arithmetic shift...
Definition: cnode_def.h:5756
path statement
Definition: cnode_def.h:2057
int Precedence()
Get the precedence of the operator represented by the node.
Definition: cnode_def.h:8011
genvar declaration
Definition: cnode_def.h:1110
CNode_sp< T > Arg(int index)
Get a node's operand.
Definition: cnode.h:549
Edge_t
Edge values.
Definition: cnode.h:72
CNode * cFOR(CNode *a0, CNode *a1, CNode *a2, CNode *a3, Coord_t *loc=NULL)
Node construction shortcut for FOR for statement.
Definition: cnode_def.h:6293
CNode * cRSH(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for RSH logical right shift.
Definition: cnode_def.h:3121
reference to port
Definition: cnode_def.h:1008
CNode * cFUNCTION_DEF(CFunction *a0, Coord_t *loc=NULL)
Node construction shortcut for FUNCTION_DEF function definition.
Definition: cnode_def.h:6578
convert integer to real
Definition: cnode_def.h:1195
logical and
Definition: cnode_def.h:1322
reduction or
Definition: cnode_def.h:1407
less than or equal
Definition: cnode_def.h:1311
edge qualifier
Definition: cnode_def.h:1765
reduction and
Definition: cnode_def.h:1387
bitwise or
Definition: cnode_def.h:848
CNode * cSLICE(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for SLICE vector subrange.
Definition: cnode_def.h:4154
virtual INT32 GetWidth(void)
Evaluate packed width of declaration.
CNode * cLE(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for LE less than or equal.
Definition: cnode_def.h:4621
reference to a forward declared variable
Definition: cnode_def.h:1018
static double EvalReal(CSymbol *symbol, CNode *args, CBlock *block)
Evaluate function as a real and return result.
CNode * cPSLICE(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for PSLICE vector subrange with ascending index select.
Definition: cnode_def.h:4187
CNode * cSPECPARAM_DECL(CParam *a0, Coord_t *loc=NULL)
Node construction shortcut for SPECPARAM_DECL specify parameter declaration.
Definition: cnode_def.h:3971
void CNodeTestHarness()
Definition: cnode_def.h:16018
comment
Definition: cnode_def.h:675
static NodeType_t Type(CSymbol *symbol, CNode *args, CBlock *block)
Determine if type of result of function.
CNode * cWHILE(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for WHILE while statement.
Definition: cnode_def.h:6225
CNode * cADD_ASSIGN(CNode *a0, CNode *a1, CNode *a2, Coord_t *loc=NULL)
Node construction shortcut for ADD_ASSIGN procedural assignment with add.
Definition: cnode_def.h:5386
bitwise xor
Definition: cnode_def.h:881
CNode * cCAST(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for CAST data type change.
Definition: cnode_def.h:7591
procedural assignment with div
Definition: cnode_def.h:1605
procedural assignment with add
Definition: cnode_def.h:1569
INT32 EvalINT32()
Evaluates expression tree and returns value as a 32 bit integer.
Definition: cnode.cc:308
CNode * cHOOK(CNode *a0, CNode *a1, CNode *a2, Coord_t *loc=NULL)
Node construction shortcut for HOOK condition expression operator.
Definition: cnode_def.h:5027
concatenation operator
Definition: cnode_def.h:1217
static void EvalVector(CVector &v, CSymbol *symbol, CNode *args, CBlock *block)
Evaluate function as a vector and return result.
procedural assignment with left shift
Definition: cnode_def.h:1665
port declaration
Definition: cnode_def.h:1100
CNode * cPACKAGE_DEF(CPackage *a0, Coord_t *loc=NULL)
Node construction shortcut for PACKAGE_DEF package definition.
Definition: cnode_def.h:6636
reference to a genvar
Definition: cnode_def.h:1028
CNode * cGFOR(CNode *a0, CNode *a1, CNode *a2, CNode *a3, Coord_t *loc=NULL)
Node construction shortcut for GFOR structural for statement.
Definition: cnode_def.h:7159
static int WidthEvaluateable(CSymbol *symbol, CNode *args)
Determine if width of systask can be evaluated.
Definition: systask.h:117
CNode * cPATH_ASSIGN(CNode *a0, CNode *a1, CNode *a2, Coord_t *loc=NULL)
Node construction shortcut for PATH_ASSIGN path assignment statement.
Definition: cnode_def.h:6902
CNode * cATTRIBUTE(CAttr *a0, Coord_t *loc=NULL)
Node construction shortcut for ATTRIBUTE attribute specification.
Definition: cnode_def.h:7090
CNode * cTABLE_ENTRY(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for TABLE_ENTRY udp table entry.
Definition: cnode_def.h:7259
convert real to integer
Definition: cnode_def.h:1185
int ArgCount(void)
Get the number of operands for the node.
Definition: cnode_def.h:7685
CNode * cGENVAR_DECL(CGenvar *a0, Coord_t *loc=NULL)
Node construction shortcut for GENVAR_DECL genvar declaration.
Definition: cnode_def.h:4029
CNode * cALWAYS(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for ALWAYS always block.
Definition: cnode_def.h:5091
CNode * cERROR(Coord_t *loc=NULL)
Node construction shortcut for ERROR error node.
Definition: cnode_def.h:2656
unsigned bit vector
Definition: cdatatype.h:106
CNode * cSYSTASK_CALL(CSymbol *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for SYSTASK_CALL call to enable a systask.
Definition: cnode_def.h:3509
static int Width(CSymbol *symbol, CNode *args, CBlock *block)
Get width of function.
CNode * cTYPE_REF(CTypedef *a0, Coord_t *loc=NULL)
Node construction shortcut for TYPE_REF reference to a type.
Definition: cnode_def.h:3847
CNode * cALWAYS_COMB(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for ALWAYS_COMB always combinational logic block.
Definition: cnode_def.h:5178
Pair of strengths.
Definition: cnode.h:108
Structure to hold file coordinates.
Definition: cdecl.h:47
Holder for character strings.
Definition: csymbol.h:44
attribute specification
Definition: cnode_def.h:2131
CNode * cRANGE(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for RANGE vector decl range specification.
Definition: cnode_def.h:4121
event statement
Definition: cnode_def.h:1510
Declaration object for module/function/task ports.
Definition: cport.h:44
generate intialize assignment
Definition: cnode_def.h:1557
divide
Definition: cnode_def.h:760
static int WidthConstant(CSymbol *symbol)
Determine if width of external variable is constant.
Definition: external.h:62
Forward reference declaration.
Definition: cfref.h:51
Bulk object allocation object.
Definition: cobstack.h:46
CNode * cABSDIFFPLUS1_N(CNode *first,...)
Definition: cnode.h:1316
delay statement
Definition: cnode_def.h:1787
negation
Definition: cnode_def.h:1247
logical right shift
Definition: cnode_def.h:804
casez statement
Definition: cnode_def.h:1904
unary concat
Definition: cnode_def.h:1227
call to a task
Definition: cnode_def.h:923
reference to net
Definition: cnode_def.h:978
void LoadReal(double d)
Load vector with integer part of real value.
int error
Definition: cnode_def.h:13891
int IsOwner(void *ptr)
Determine if pointer was allocated from this obstack.
Definition: cnode_def.h:13889
CNode * cFORCE(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for FORCE force statement.
Definition: cnode_def.h:5829
CNode * cEXTERNAL_REF(CSymbol *a0, Coord_t *loc=NULL)
Node construction shortcut for EXTERNAL_REF external reference.
Definition: cnode_def.h:6756
vrq comment
Definition: cnode_def.h:685
CNode * cLAND(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for LAND logical and.
Definition: cnode_def.h:4654
CNode * cRSHA(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for RSHA arithmetic right shift.
Definition: cnode_def.h:3187
equal
Definition: cnode_def.h:1366
unary plus
Definition: cnode_def.h:1257
Primary data structure representing parse tree nodes.
Definition: cnode.h:197
CNode * cPASSIGN(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for PASSIGN procedural assignment.
Definition: cnode_def.h:7000
CNode * cANDANDAND(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for ANDANDAND triple and.
Definition: cnode_def.h:3319
CNode * cNET_REF(CNet *a0, Coord_t *loc=NULL)
Node construction shortcut for NET_REF reference to net.
Definition: cnode_def.h:3644
integer declaration
Definition: cdatatype.h:50
NodeOp_t
Parse tree opcodes.
Definition: cnode_def.h:636
CNode * cGASSIGN(bool a0, CNode *a1, CNode *a2, Coord_t *loc=NULL)
Node construction shortcut for GASSIGN generate intialize assignment.
Definition: cnode_def.h:5349
void info(struct Coord_t *location, const char *format,...)
This routine should not be used by plugins.
program pragma
Definition: cnode_def.h:696
CNode * cCASEZ(CNode *a0, CNode *a1, ConditionalType a2, Coord_t *loc=NULL)
Node construction shortcut for CASEZ casez statement.
Definition: cnode_def.h:6407
CNode * cTRIGGER(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for TRIGGER event trigger.
Definition: cnode_def.h:6970
return
Definition: cnode_def.h:2250
CNode * cCNE(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for CNE case not equal.
Definition: cnode_def.h:4753
CNode * cVAR_REF(CVar *a0, Coord_t *loc=NULL)
Node construction shortcut for VAR_REF reference to variable.
Definition: cnode_def.h:3673
CNode * cCOM(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for COM bitwise complement.
Definition: cnode_def.h:4405
positive event qualifier
Definition: cnode_def.h:1744
CNode * cWIDTH(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for WIDTH expression width change.
Definition: cnode_def.h:2865
CNode * cEVENT(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for EVENT event statement.
Definition: cnode_def.h:5208
defparam statement
Definition: cnode_def.h:2041
int IsNonX(int integerIsNonX=0, char *exclude=NULL)
Checks expression tree to see if expression can result in an X or Z.
Definition: cnode_def.h:9451
Declaration object for module and gate instances.
Definition: cinstance.h:45
expression list
Definition: cnode_def.h:707
void EvalVector(CVector &v)
Evaluates expression tree evaluated in unconstrainted context.
Definition: cnode.cc:360
udp table symbol
Definition: cnode_def.h:2197
CNode * cEVENT_CONTROL(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for EVENT_CONTROL event control.
Definition: cnode_def.h:6727
multiply
Definition: cnode_def.h:749
CNode * cMSLICE(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for MSLICE vector subrange with descending index select.
Definition: cnode_def.h:4220
call to a function
Definition: cnode_def.h:957
queue dimension
Definition: cnode_def.h:2320
CNode * cARRAY(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for ARRAY dimensioned reference (array/bit select)
Definition: cnode_def.h:3612
CNode * cVRQ(const char *a0, Coord_t *loc=NULL)
Node construction shortcut for VRQ vrq comment.
Definition: cnode_def.h:2769
void error(struct Coord_t *location, const char *format,...)
This routine should not be used by plugins.
CNode * cPOSTINC(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for POSTINC postincrement.
Definition: cnode_def.h:7503
parameter declaration
Definition: cnode_def.h:1080
void Pow(double *r, double *a, double *b)
Definition: cnode.h:712
less than
Definition: cnode_def.h:1300
CNode * cALWAYS_FF(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for ALWAYS_FF always flip-flop block.
Definition: cnode_def.h:5149
CNode * cCASEITEM(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for CASEITEM case item.
Definition: cnode_def.h:6443
replication operator
Definition: cnode_def.h:1206
CNode(Coord_t *aLoc, NodeOp_t aOp)
Constructor for parse node.
Definition: cnode.cc:240
member reference (structure, class or external
Definition: cnode_def.h:2240
CNode * cINIT(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for INIT initial block.
Definition: cnode_def.h:5062
Definition: cmodule.h:54
void SetAttributes(CNode *attr)
Attach attributes to operation.
Definition: cnode.h:519
CNode * cPORTLIST_END(Coord_t *loc=NULL)
Node construction shortcut for PORTLIST_END sentinal at end of port list.
Definition: cnode_def.h:7316
package definition
Definition: cnode_def.h:1979
bitwise xnor
Definition: cnode_def.h:892
CNode * cMEMBER(CNode *a0, CSymbol *a1, Coord_t *loc=NULL)
Node construction shortcut for MEMBER member reference (structure, class or external.
Definition: cnode_def.h:7413
CNode * cALWAYS_LATCH(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for ALWAYS_LATCH always latch block.
Definition: cnode_def.h:5120
event control
Definition: cnode_def.h:2010
event or
Definition: cnode_def.h:1776
const char * nodeOpDescription[]
Definition: cnode_def.h:2485
CNode * PostSubVisit1(CNode *(*callback)(CNode *, void *), void *data)
Walk tree invoking callback on each node after children have been visited.
Definition: cnode_def.h:11193
procedural assignment with bitwise and
Definition: cnode_def.h:1629
CNode * cPOSTDEC(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for POSTDEC postdecrement.
Definition: cnode_def.h:7561
udp table
Definition: cnode_def.h:2177
for statement
Definition: cnode_def.h:1868
triple and
Definition: cnode_def.h:870
void Div(double *r, double *a, double *b)
Definition: cnode.h:697
CNode * cXOR(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for XOR bitwise xor.
Definition: cnode_def.h:3352
event trigger
Definition: cnode_def.h:2090
structural if statement
Definition: cnode_def.h:2143
reference to a enum
Definition: cnode_def.h:1038
int Equivalent(CNode *a, CNode *b)
Definition: cnode_def.h:12282
static int Evaluateable(CSymbol *symbol, CNode *args, CBlock *block)
Determine if function can be evaluated.
CNode * cNEGEDGE(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for NEGEDGE negative event qualifier.
Definition: cnode_def.h:5956
postdecrement
Definition: cnode_def.h:2290
module definition
Definition: cnode_def.h:1969
void Sub(double *r, double *a, double *b)
Definition: cnode.h:687
subtract
Definition: cnode_def.h:738
CNode * cRNAND(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for RNAND reduction nand.
Definition: cnode_def.h:4880
specify parameter declaration
Definition: cnode_def.h:1090
forever statement
Definition: cnode_def.h:1822
CNode * cRELEASE(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for RELEASE release statement.
Definition: cnode_def.h:5861
Declaration object for variables.
Definition: cvar.h:50
CNode * cIF(CNode *a0, CNode *a1, CNode *a2, ConditionalType a3, Coord_t *loc=NULL)
Node construction shortcut for IF if statement.
Definition: cnode_def.h:6124
external reference
Definition: cnode_def.h:2020
Declaration object for parameters.
Definition: cparam.h:46
CNode * cRNOR(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for RNOR reduction nor.
Definition: cnode_def.h:4938
CNode * cMTM(CNode *a0, CNode *a1, CNode *a2, Coord_t *loc=NULL)
Node construction shortcut for MTM min/typ/max expression.
Definition: cnode_def.h:6086
while statement
Definition: cnode_def.h:1844
CNode * cENUM_REF(CEnum *a0, Coord_t *loc=NULL)
Node construction shortcut for ENUM_REF reference to a enum.
Definition: cnode_def.h:3818
CNode * cTABLE(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for TABLE udp table.
Definition: cnode_def.h:7230
CNode * cPOW(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for POW exponent.
Definition: cnode_def.h:3022
CNode * cREPEAT(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for REPEAT repeat statement.
Definition: cnode_def.h:6192
CNode * cOR(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for OR bitwise or.
Definition: cnode_def.h:3253
Declaration object for holding lists of verilog attributes and their corresponding expressions...
Definition: cattr.h:50
procedural assignment with right arithmetic shift
Definition: cnode_def.h:1701
CNode * cINT32(INT32 i)
Short cut for creating VCONSTANT node with a given integer value.
Definition: cnode.h:798
int suppressErrorMessages
Definition: cnode_def.h:13890
CNode * cASSIGNMENT_PATTERN(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for ASSIGNMENT_PATTERN assignment_pattern.
Definition: cnode_def.h:7623
function definition
Definition: cnode_def.h:1959
CNode * cNE(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for NE not equal.
Definition: cnode_def.h:4819
static CNode * WidthExp(CSymbol *symbol, CNode *args, CBlock *block)
Get width of function as an expression.
double GetReal()
Get vector value as a real.
enum specification
Definition: cnode_def.h:2229
CNode * cGATE_REF(CGate *a0, Coord_t *loc=NULL)
Node construction shortcut for GATE_REF gate instance.
Definition: cnode_def.h:3446
CNode * cPATH(int a0, CNode *a1, int a2, int a3, CNode *a4, int a5, CNode *a6, Coord_t *loc=NULL)
Node construction shortcut for PATH path statement.
Definition: cnode_def.h:6853
int IsWidthEvaluateable(void)
Evaluates if expression width can be evaluated.
Definition: cnode_def.h:9289
CNode * cRCONSTANT(char *a0, Coord_t *loc=NULL)
Node construction shortcut for RCONSTANT real constant.
Definition: cnode_def.h:2711
static int Width(CSymbol *symbol)
Get width of external variable.
Definition: external.h:49
static CNode * WidthExp(CSymbol *symbol, CNode *args)
Get width of systask as an expression.
Definition: systask.h:64
CNode * cVAR_DECL(CVar *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for VAR_DECL variable declaration.
Definition: cnode_def.h:3910
event - have width 0
Definition: cdatatype.h:105
CNode * cPORT_DEF(CPort *a0, Coord_t *loc=NULL)
Node construction shortcut for PORT_DEF port definition.
Definition: cnode_def.h:6785
Bit vector class for implementing 4 state verilog signed and unsigned arithmetic. ...
Definition: cvector.h:58
CNode * cGE(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for GE greater than or equal.
Definition: cnode_def.h:4555
void PreVisit1(int(*callback)(CNode *, void *), void *data)
Walk tree invoking callback on each node before children have been visited.
Definition: cnode_def.h:10128
procedural assignment with mod
Definition: cnode_def.h:1617
CNode * cIMPORT(CSymbol *a0, Coord_t *loc=NULL)
Node construction shortcut for IMPORT import item.
Definition: cnode_def.h:6549
static int Width(CSymbol *symbol, CNode *args)
Get width of systask.
Definition: systask.h:48
INT32 GetWidth(void)
Evaluate width of expression.
Definition: cnode.h:494
call to a timing task
Definition: cnode_def.h:945
CNode * cLT(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for LT less than.
Definition: cnode_def.h:4588
release statement
Definition: cnode_def.h:1722
void Mul(double *r, double *a, double *b)
Definition: cnode.h:692
CNode * cLSH_ASSIGN(CNode *a0, CNode *a1, CNode *a2, Coord_t *loc=NULL)
Node construction shortcut for LSH_ASSIGN procedural assignment with left shift.
Definition: cnode_def.h:5682
structural case statement
Definition: cnode_def.h:2167
int IsWidthConstant(void)
Evaluates if expression width is constant.
Definition: cnode_def.h:8515
CNode * cREP(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for REP replication operator.
Definition: cnode_def.h:4311
CNode * cDELAY_CONTROL(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for DELAY_CONTROL delay control.
Definition: cnode_def.h:6698
CNode * cNOP(Coord_t *loc=NULL)
Node construction shortcut for NOP no operation.
Definition: cnode_def.h:2896
NodeType_t GetNodeType(void)
Get node expression type.
Definition: cnode.h:540
always block
Definition: cnode_def.h:1469
reference to a type
Definition: cnode_def.h:1048
udp table entry
Definition: cnode_def.h:2187
void Plus(double *r, double *a)
Definition: cnode.h:707
INT32 GetWidth(void)
Get vector bit width.
CNode * cDOLLAR(Coord_t *loc=NULL)
Node construction shortcut for DOLLAR queue dimension.
Definition: cnode_def.h:7651
static int WidthConstant(CSymbol *symbol, CNode *args, CBlock *block)
Determine if width of function is constant.
path assignment statement
Definition: cnode_def.h:2069
int Signed() const
Get signed attribute.
Definition: cvector.h:178
vector subrange
Definition: cnode_def.h:1153
real - have width 0
Definition: cdatatype.h:103
Declaration object for functions and tasks.
Definition: cfunction.h:50
port definition
Definition: cnode_def.h:2030
static int WidthEvaluateable(CSymbol *symbol)
Determine if width of external variable can be evaluated.
Definition: external.h:75
CNode * cLIST(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for LIST list of nodes.
Definition: cnode_def.h:4088
always flip-flop block
Definition: cnode_def.h:1489
call to enable a systask
Definition: cnode_def.h:934
procedural assignment
Definition: cnode_def.h:2101
CNode * cGCASE(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for GCASE structural case statement.
Definition: cnode_def.h:7198
procedural assignment with bitwise or
Definition: cnode_def.h:1641
unsigned Hash()
Calculate hash of tree.
Definition: cnode_def.h:11734
CNode * cTIMING_CALL(CSymbol *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for TIMING_CALL call to a timing task.
Definition: cnode_def.h:3542
CNode * cRXNOR(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for RXNOR reduction xnor.
Definition: cnode_def.h:4996
structural for statement
Definition: cnode_def.h:2156
logical complement
Definition: cnode_def.h:1267
Declaration object for input/output/inout statements.
Definition: cportdir.h:45
CNode * cMAX(CNode *n1, CNode *n2)
Short cut for creating a expression tree that calculates the maximum of two expressions.
Definition: cnode.h:895
CNode * cXNOR(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for XNOR bitwise xnor.
Definition: cnode_def.h:3385
casex statement
Definition: cnode_def.h:1892
always latch block
Definition: cnode_def.h:1479
CNode * cADD_N(CNode *first,...)
Definition: cnode.h:1284
CNode * cMACRO_EXPR(const char *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for MACRO_EXPR expression represented by a macro.
Definition: cnode_def.h:7343
addition
Definition: cnode_def.h:782
repeat statement
Definition: cnode_def.h:1833
expression represented by a macro
Definition: cnode_def.h:2217
deassign statement
Definition: cnode_def.h:2111
NodeType_t
Expression node type.
Definition: cdatatype.h:101
CNode * cSPECIFY_REF(CSpecify *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for SPECIFY_REF specify block.
Definition: cnode_def.h:5278
data type change
Definition: cnode_def.h:2301
procedural assignment with subtract
Definition: cnode_def.h:1581
CNode * cRSH_ASSIGN(CNode *a0, CNode *a1, CNode *a2, Coord_t *loc=NULL)
Node construction shortcut for RSH_ASSIGN procedural assignment with right shift. ...
Definition: cnode_def.h:5719
CNode * cCASE(CNode *a0, CNode *a1, ConditionalType a2, Coord_t *loc=NULL)
Node construction shortcut for CASE case statement.
Definition: cnode_def.h:6333
CNode * GetAttributes()
Get attributes attached to operation.
Definition: cnode.h:514
CNode * cADD(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for ADD addition.
Definition: cnode_def.h:3055
const char * nodeOpName[]
Definition: cnode_def.h:2326
predecrement
Definition: cnode_def.h:2280
CNode * cDEFPARAM(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for DEFPARAM defparam statement.
Definition: cnode_def.h:6815
dimensioned reference (array/bit select)
Definition: cnode_def.h:968
CNode * cPORT_DECL(CPortDir *a0, Coord_t *loc=NULL)
Node construction shortcut for PORT_DECL port declaration.
Definition: cnode_def.h:4000
CNode * cLOR(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for LOR logical or.
Definition: cnode_def.h:4687
CNode * cENUM_SPEC(CSymbol *a0, CNode *a1, CNode *a2, Coord_t *loc=NULL)
Node construction shortcut for ENUM_SPEC enum specification.
Definition: cnode_def.h:7377
NodeOp_t GetOp()
Return node's operation type.
Definition: cnode.h:317
CNode * cLSH(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for LSH logical left shift.
Definition: cnode_def.h:3088
int IsWidthVolatile(void)
Evaluates if expression width is volatile.
Definition: cnode_def.h:8675
type declaration
Definition: cnode_def.h:1120
CNode * cVCONSTANT(CVector *a0, Coord_t *loc=NULL)
Node construction shortcut for VCONSTANT vector constant.
Definition: cnode_def.h:2682
void Dump(FILE *f)
Print a compact representation of the parse tree.
Definition: cnode_def.h:15479
logical left shift
Definition: cnode_def.h:793
Declaration class for block constructs.
Definition: cblock.h:52
CNode * cUCAT(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for UCAT unary concat.
Definition: cnode_def.h:4376
virtual INT32 GetWidth(void) const
Evaluate packed width of declaration.
Definition: cdecl.h:263
static CNode * WidthExp(CSymbol *symbol)
Get width of external variable as an expression.
Definition: external.h:55
continious assignment
Definition: cnode_def.h:1928
CNode * cTYPEDEF_DECL(CTypedef *a0, Coord_t *loc=NULL)
Node construction shortcut for TYPEDEF_DECL type declaration.
Definition: cnode_def.h:4058
int cABSDIFFPLUS1(int a1, int a2)
Definition: cnode.h:1354
vector subrange with descending index select
Definition: cnode_def.h:1175
bitwise complement
Definition: cnode_def.h:1237
reference to parameter
Definition: cnode_def.h:998
always combinational logic block
Definition: cnode_def.h:1499
double EvalReal(void)
Evaluates expression tree evaluated in a real context.
Definition: cnode.cc:391
case statement
Definition: cnode_def.h:1880
CNode * cLSHA(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for LSHA arithmetic left shift.
Definition: cnode_def.h:3154
CNode * cPARAM_REF(CParam *a0, Coord_t *loc=NULL)
Node construction shortcut for PARAM_REF reference to parameter.
Definition: cnode_def.h:3702
greater than
Definition: cnode_def.h:1278
CNode * cMODULE_DEF(CModule *a0, Coord_t *loc=NULL)
Node construction shortcut for MODULE_DEF module definition.
Definition: cnode_def.h:6607
specify block
Definition: cnode_def.h:1533
static int WidthVolatile(CSymbol *symbol, CNode *args, CBlock *block)
Determine if width of function is volatile.
CNode * cPREINC(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for PREINC preincrement.
Definition: cnode_def.h:7474
CNode * cPLUS(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for PLUS unary plus.
Definition: cnode_def.h:4463
modulus
Definition: cnode_def.h:837
ifnone path assignment statement
Definition: cnode_def.h:2080
net declaration
Definition: cnode_def.h:1059
expression width change
Definition: cnode_def.h:718
CNode * cINSTANCE_REF(CInstance *a0, Coord_t *loc=NULL)
Node construction shortcut for INSTANCE_REF instance reference.
Definition: cnode_def.h:3417
CNode * cTASK_ENABLE(CSymbol *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for TASK_ENABLE call to a task.
Definition: cnode_def.h:3476
ConditionalType
Case/If type.
Definition: cnode.h:116
CNode * cGENVAR_REF(CGenvar *a0, Coord_t *loc=NULL)
Node construction shortcut for GENVAR_REF reference to a genvar.
Definition: cnode_def.h:3789
CNode * cMUL(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for MUL multiply.
Definition: cnode_def.h:2956
virtual INT32 GetWidth(void)
Evaluate packed width of declaration.
procedural assignment with left arithmetic shift
Definition: cnode_def.h:1689
double s2d(char *s)
Convert char string to double.
Definition: cnode.h:1093
if statement
Definition: cnode_def.h:1812
reference to variable
Definition: cnode_def.h:988
CNode * cAND_ASSIGN(CNode *a0, CNode *a1, CNode *a2, Coord_t *loc=NULL)
Node construction shortcut for AND_ASSIGN procedural assignment with bitwise and. ...
Definition: cnode_def.h:5571
CNode * cCVIR(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for CVIR convert integer to real.
Definition: cnode_def.h:4281
CNode * cXOR_ASSIGN(CNode *a0, CNode *a1, CNode *a2, Coord_t *loc=NULL)
Node construction shortcut for XOR_ASSIGN procedural assignment with bitwise xor. ...
Definition: cnode_def.h:5645
CNode * cBLOCK_REF(CBlock *a0, CNode *a1, bool a2, Coord_t *loc=NULL)
Node construction shortcut for BLOCK_REF statement block.
Definition: cnode_def.h:5242
CNode * Clone(CObstack *heap=stack)
Replicate tree.
Definition: cnode_def.h:9626
min/typ/max expression
Definition: cnode_def.h:1799
logical or
Definition: cnode_def.h:1333