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 
621 #ifdef DEFINE_ENUM
622 
625 enum NodeOp_t {
629  /*
630  * ERROR node
631  * Description: error node
632  * Number Of Arguments: 0
633  */
638  /*
639  * VCONSTANT node
640  * Description: vector constant
641  * Number Of Arguments: 1
642  * arg0: CVector* Pointer to vector
643  */
648  /*
649  * RCONSTANT node
650  * Description: real constant
651  * Number Of Arguments: 1
652  * arg0: char* Pointer to string
653  */
658  /*
659  * COMMENT node
660  * Description: comment
661  * Number Of Arguments: 1
662  * arg0: const char* Pointer to string
663  */
668  /*
669  * VRQ node
670  * Description: vrq comment
671  * Number Of Arguments: 1
672  * arg0: const char* Pointer to string
673  */
678  /*
679  * PRAGMA node
680  * Description: program pragma
681  * Number Of Arguments: 1
682  * arg0: const char* Pointer to string
683  */
688  /*
689  * ELIST node
690  * Description: expression list
691  * Number Of Arguments: 2
692  * arg0: CNode* expression1
693  * arg1: CNode* expression2
694  */
699  /*
700  * WIDTH node
701  * Description: expression width change
702  * Number Of Arguments: 2
703  * arg0: CNode* width expression
704  * arg1: CNode* expression
705  */
710  /*
711  * NOP node
712  * Description: no operation
713  * Number Of Arguments: 0
714  */
719  /*
720  * SUB node
721  * Description: subtract
722  * Number Of Arguments: 2
723  * arg0: CNode* expression 1
724  * arg1: CNode* expression 2
725  */
730  /*
731  * MUL node
732  * Description: multiply
733  * Number Of Arguments: 2
734  * arg0: CNode* expression 1
735  * arg1: CNode* expression 2
736  */
741  /*
742  * DIV node
743  * Description: divide
744  * Number Of Arguments: 2
745  * arg0: CNode* expression 1
746  * arg1: CNode* expression 2
747  */
752  /*
753  * POW node
754  * Description: exponent
755  * Number Of Arguments: 2
756  * arg0: CNode* expression 1
757  * arg1: CNode* expression 2
758  */
763  /*
764  * ADD node
765  * Description: addition
766  * Number Of Arguments: 2
767  * arg0: CNode* expression 1
768  * arg1: CNode* expression 2
769  */
774  /*
775  * LSH node
776  * Description: logical left shift
777  * Number Of Arguments: 2
778  * arg0: CNode* expression 1
779  * arg1: CNode* expression 2
780  */
785  /*
786  * RSH node
787  * Description: logical right shift
788  * Number Of Arguments: 2
789  * arg0: CNode* expression 1
790  * arg1: CNode* expression 2
791  */
796  /*
797  * LSHA node
798  * Description: arithmetic left shift
799  * Number Of Arguments: 2
800  * arg0: CNode* expression 1
801  * arg1: CNode* expression 2
802  */
807  /*
808  * RSHA node
809  * Description: arithmetic right shift
810  * Number Of Arguments: 2
811  * arg0: CNode* expression 1
812  * arg1: CNode* expression 2
813  */
818  /*
819  * MOD node
820  * Description: modulus
821  * Number Of Arguments: 2
822  * arg0: CNode* expression 1
823  * arg1: CNode* expression 2
824  */
829  /*
830  * OR node
831  * Description: bitwise or
832  * Number Of Arguments: 2
833  * arg0: CNode* expression 1
834  * arg1: CNode* expression 2
835  */
840  /*
841  * AND node
842  * Description: bitwise and
843  * Number Of Arguments: 2
844  * arg0: CNode* expression 1
845  * arg1: CNode* expression 2
846  */
851  /*
852  * ANDANDAND node
853  * Description: triple and
854  * Number Of Arguments: 2
855  * arg0: CNode* expression 1
856  * arg1: CNode* expression 2
857  */
862  /*
863  * XOR node
864  * Description: bitwise xor
865  * Number Of Arguments: 2
866  * arg0: CNode* expression 1
867  * arg1: CNode* expression 2
868  */
873  /*
874  * XNOR node
875  * Description: bitwise xnor
876  * Number Of Arguments: 2
877  * arg0: CNode* expression 1
878  * arg1: CNode* expression 2
879  */
884  /*
885  * INSTANCE_REF node
886  * Description: instance reference
887  * Number Of Arguments: 1
888  * arg0: CInstance* Pointer to a instance
889  */
894  /*
895  * GATE_REF node
896  * Description: gate instance
897  * Number Of Arguments: 1
898  * arg0: CGate* Pointer to a gate
899  */
904  /*
905  * TASK_ENABLE node
906  * Description: call to a task
907  * Number Of Arguments: 2
908  * arg0: CSymbol* Pointer to symbol for task to call
909  * arg1: CNode* Argument expression list
910  */
915  /*
916  * SYSTASK_CALL node
917  * Description: call to enable a systask
918  * Number Of Arguments: 2
919  * arg0: CSymbol* Pointer to symbol for systask to call
920  * arg1: CNode* Argument expression list
921  */
926  /*
927  * TIMING_CALL node
928  * Description: call to a timing task
929  * Number Of Arguments: 2
930  * arg0: CSymbol* Pointer to symbol of timing task
931  * arg1: CNode* Argument expression list
932  */
937  /*
938  * FUNCTION_CALL node
939  * Description: call to a function
940  * Number Of Arguments: 3
941  * arg0: CSymbol* Pointer to symbol of the function
942  * arg1: CNode* Argument expression list
943  * arg2: CScope* Scope containing expression
944  */
949  /*
950  * ARRAY node
951  * Description: dimensioned reference (array/bit select)
952  * Number Of Arguments: 2
953  * arg0: CNode* Reference to variable
954  * arg1: CNode* List of index expressions
955  */
960  /*
961  * NET_REF node
962  * Description: reference to net
963  * Number Of Arguments: 1
964  * arg0: CNet* Pointer to net
965  */
970  /*
971  * VAR_REF node
972  * Description: reference to variable
973  * Number Of Arguments: 1
974  * arg0: CVar* Pointer to variable
975  */
980  /*
981  * PARAM_REF node
982  * Description: reference to parameter
983  * Number Of Arguments: 1
984  * arg0: CParam* Pointer to parameter
985  */
990  /*
991  * PORT_REF node
992  * Description: reference to port
993  * Number Of Arguments: 1
994  * arg0: CPortDir* Pointer to port
995  */
1000  /*
1001  * FWD_REF node
1002  * Description: reference to a forward declared variable
1003  * Number Of Arguments: 1
1004  * arg0: CFref* Pointer to forward declared variable
1005  */
1010  /*
1011  * GENVAR_REF node
1012  * Description: reference to a genvar
1013  * Number Of Arguments: 1
1014  * arg0: CGenvar* Pointer to a genvar
1015  */
1020  /*
1021  * ENUM_REF node
1022  * Description: reference to a enum
1023  * Number Of Arguments: 1
1024  * arg0: CEnum* Pointer to a enum
1025  */
1030  /*
1031  * TYPE_REF node
1032  * Description: reference to a type
1033  * Number Of Arguments: 1
1034  * arg0: CTypedef* Pointer to a typedef
1035  */
1040  /*
1041  * NET_DECL node
1042  * Description: net declaration
1043  * Number Of Arguments: 2
1044  * arg0: CNet* Pointer to a net
1045  * arg1: CNode* continous assignment (optional)
1046  */
1051  /*
1052  * VAR_DECL node
1053  * Description: variable declaration
1054  * Number Of Arguments: 2
1055  * arg0: CVar* Pointer to a variable
1056  * arg1: CNode* procedural assignment (optional)
1057  */
1062  /*
1063  * PARAM_DECL node
1064  * Description: parameter declaration
1065  * Number Of Arguments: 1
1066  * arg0: CParam* Pointer to a parameter
1067  */
1072  /*
1073  * SPECPARAM_DECL node
1074  * Description: specify parameter declaration
1075  * Number Of Arguments: 1
1076  * arg0: CParam* Pointer to a specify parameter
1077  */
1082  /*
1083  * PORT_DECL node
1084  * Description: port declaration
1085  * Number Of Arguments: 1
1086  * arg0: CPortDir* Pointer to a port
1087  */
1092  /*
1093  * GENVAR_DECL node
1094  * Description: genvar declaration
1095  * Number Of Arguments: 1
1096  * arg0: CGenvar* Pointer to a genvar
1097  */
1102  /*
1103  * TYPEDEF_DECL node
1104  * Description: type declaration
1105  * Number Of Arguments: 1
1106  * arg0: CTypedef* Pointer to a typedef
1107  */
1112  /*
1113  * LIST node
1114  * Description: list of nodes
1115  * Number Of Arguments: 2
1116  * arg0: CNode* node 1
1117  * arg1: CNode* node 2
1118  */
1123  /*
1124  * RANGE node
1125  * Description: vector decl range specification
1126  * Number Of Arguments: 2
1127  * arg0: CNode* msb expression, if lsb is null range is msb-1:0
1128  * arg1: CNode* lsb expression, if NULL range is msb-1:0
1129  */
1134  /*
1135  * SLICE node
1136  * Description: vector subrange
1137  * Number Of Arguments: 2
1138  * arg0: CNode* msb expression
1139  * arg1: CNode* lsb expression
1140  */
1145  /*
1146  * PSLICE node
1147  * Description: vector subrange with ascending index select
1148  * Number Of Arguments: 2
1149  * arg0: CNode* index expression
1150  * arg1: CNode* width expression
1151  */
1156  /*
1157  * MSLICE node
1158  * Description: vector subrange with descending index select
1159  * Number Of Arguments: 2
1160  * arg0: CNode* index expression
1161  * arg1: CNode* width expression
1162  */
1167  /*
1168  * CVRI node
1169  * Description: convert real to integer
1170  * Number Of Arguments: 1
1171  * arg0: CNode* expression
1172  */
1177  /*
1178  * CVIR node
1179  * Description: convert integer to real
1180  * Number Of Arguments: 1
1181  * arg0: CNode* expression
1182  */
1187  /*
1188  * REP node
1189  * Description: replication operator
1190  * Number Of Arguments: 2
1191  * arg0: CNode* replication expression
1192  * arg1: CNode* expression to replicate
1193  */
1198  /*
1199  * CAT node
1200  * Description: concatenation operator
1201  * Number Of Arguments: 2
1202  * arg0: CNode* expression 1
1203  * arg1: CNode* expression 2
1204  */
1209  /*
1210  * UCAT node
1211  * Description: unary concat
1212  * Number Of Arguments: 1
1213  * arg0: CNode* expression
1214  */
1219  /*
1220  * COM node
1221  * Description: bitwise complement
1222  * Number Of Arguments: 1
1223  * arg0: CNode* expression
1224  */
1229  /*
1230  * NEG node
1231  * Description: negation
1232  * Number Of Arguments: 1
1233  * arg0: CNode* expression
1234  */
1239  /*
1240  * PLUS node
1241  * Description: unary plus
1242  * Number Of Arguments: 1
1243  * arg0: CNode* expression
1244  */
1249  /*
1250  * NOT node
1251  * Description: logical complement
1252  * Number Of Arguments: 1
1253  * arg0: CNode* expression
1254  */
1259  /*
1260  * GT node
1261  * Description: greater than
1262  * Number Of Arguments: 2
1263  * arg0: CNode* expression 1
1264  * arg1: CNode* expression 2
1265  */
1270  /*
1271  * GE node
1272  * Description: greater than or equal
1273  * Number Of Arguments: 2
1274  * arg0: CNode* expression 1
1275  * arg1: CNode* expression 2
1276  */
1281  /*
1282  * LT node
1283  * Description: less than
1284  * Number Of Arguments: 2
1285  * arg0: CNode* expression 1
1286  * arg1: CNode* expression 2
1287  */
1292  /*
1293  * LE node
1294  * Description: less than or equal
1295  * Number Of Arguments: 2
1296  * arg0: CNode* expression 1
1297  * arg1: CNode* expression 2
1298  */
1303  /*
1304  * LAND node
1305  * Description: logical and
1306  * Number Of Arguments: 2
1307  * arg0: CNode* expression 1
1308  * arg1: CNode* expression 2
1309  */
1314  /*
1315  * LOR node
1316  * Description: logical or
1317  * Number Of Arguments: 2
1318  * arg0: CNode* expression 1
1319  * arg1: CNode* expression 2
1320  */
1325  /*
1326  * CEQ node
1327  * Description: case equal
1328  * Number Of Arguments: 2
1329  * arg0: CNode* expression 1
1330  * arg1: CNode* expression 2
1331  */
1336  /*
1337  * CNE node
1338  * Description: case not equal
1339  * Number Of Arguments: 2
1340  * arg0: CNode* expression 1
1341  * arg1: CNode* expression 2
1342  */
1347  /*
1348  * EQ node
1349  * Description: equal
1350  * Number Of Arguments: 2
1351  * arg0: CNode* expression 1
1352  * arg1: CNode* expression 2
1353  */
1358  /*
1359  * NE node
1360  * Description: not equal
1361  * Number Of Arguments: 2
1362  * arg0: CNode* expression 1
1363  * arg1: CNode* expression 2
1364  */
1369  /*
1370  * RAND node
1371  * Description: reduction and
1372  * Number Of Arguments: 1
1373  * arg0: CNode* expression
1374  */
1379  /*
1380  * RNAND node
1381  * Description: reduction nand
1382  * Number Of Arguments: 1
1383  * arg0: CNode* expression
1384  */
1389  /*
1390  * ROR node
1391  * Description: reduction or
1392  * Number Of Arguments: 1
1393  * arg0: CNode* expression
1394  */
1399  /*
1400  * RNOR node
1401  * Description: reduction nor
1402  * Number Of Arguments: 1
1403  * arg0: CNode* expression
1404  */
1409  /*
1410  * RXOR node
1411  * Description: reduction xor
1412  * Number Of Arguments: 1
1413  * arg0: CNode* expression
1414  */
1419  /*
1420  * RXNOR node
1421  * Description: reduction xnor
1422  * Number Of Arguments: 1
1423  * arg0: CNode* expression
1424  */
1429  /*
1430  * HOOK node
1431  * Description: condition expression operator
1432  * Number Of Arguments: 3
1433  * arg0: CNode* condition expression
1434  * arg1: CNode* true expression
1435  * arg2: CNode* false expression
1436  */
1441  /*
1442  * INIT node
1443  * Description: initial block
1444  * Number Of Arguments: 1
1445  * arg0: CNode*
1446  */
1451  /*
1452  * ALWAYS node
1453  * Description: always block
1454  * Number Of Arguments: 1
1455  * arg0: CNode*
1456  */
1461  /*
1462  * ALWAYS_LATCH node
1463  * Description: always latch block
1464  * Number Of Arguments: 1
1465  * arg0: CNode*
1466  */
1471  /*
1472  * ALWAYS_FF node
1473  * Description: always flip-flop block
1474  * Number Of Arguments: 1
1475  * arg0: CNode*
1476  */
1481  /*
1482  * ALWAYS_COMB node
1483  * Description: always combinational logic block
1484  * Number Of Arguments: 1
1485  * arg0: CNode*
1486  */
1491  /*
1492  * EVENT node
1493  * Description: event statement
1494  * Number Of Arguments: 2
1495  * arg0: CNode* event expression (NULL for @*)
1496  * arg1: CNode* statement
1497  */
1502  /*
1503  * BLOCK_REF node
1504  * Description: statement block
1505  * Number Of Arguments: 2
1506  * arg0: CBlock* pointer to block
1507  * arg1: CNode* list of statements
1508  */
1513  /*
1514  * SPECIFY_REF node
1515  * Description: specify block
1516  * Number Of Arguments: 2
1517  * arg0: CSpecify* pointer to specify structure
1518  * arg1: CNode* list of statements
1519  */
1524  /*
1525  * ASSIGN node
1526  * Description: procedural assignment
1527  * Number Of Arguments: 3
1528  * arg0: CNode* event expression
1529  * arg1: CNode* lval
1530  * arg2: CNode* rval
1531  */
1536  /*
1537  * GASSIGN node
1538  * Description: generate intialize assignment
1539  * Number Of Arguments: 3
1540  * arg0: bool declare genvar
1541  * arg1: CNode* lval
1542  * arg2: CNode* rval
1543  */
1548  /*
1549  * ADD_ASSIGN node
1550  * Description: procedural assignment with add
1551  * Number Of Arguments: 3
1552  * arg0: CNode* event expression
1553  * arg1: CNode* lval
1554  * arg2: CNode* rval
1555  */
1560  /*
1561  * SUB_ASSIGN node
1562  * Description: procedural assignment with subtract
1563  * Number Of Arguments: 3
1564  * arg0: CNode* event expression
1565  * arg1: CNode* lval
1566  * arg2: CNode* rval
1567  */
1572  /*
1573  * MUL_ASSIGN node
1574  * Description: procedural assignment with mul
1575  * Number Of Arguments: 3
1576  * arg0: CNode* event expression
1577  * arg1: CNode* lval
1578  * arg2: CNode* rval
1579  */
1584  /*
1585  * DIV_ASSIGN node
1586  * Description: procedural assignment with div
1587  * Number Of Arguments: 3
1588  * arg0: CNode* event expression
1589  * arg1: CNode* lval
1590  * arg2: CNode* rval
1591  */
1596  /*
1597  * MOD_ASSIGN node
1598  * Description: procedural assignment with mod
1599  * Number Of Arguments: 3
1600  * arg0: CNode* event expression
1601  * arg1: CNode* lval
1602  * arg2: CNode* rval
1603  */
1608  /*
1609  * AND_ASSIGN node
1610  * Description: procedural assignment with bitwise and
1611  * Number Of Arguments: 3
1612  * arg0: CNode* event expression
1613  * arg1: CNode* lval
1614  * arg2: CNode* rval
1615  */
1620  /*
1621  * OR_ASSIGN node
1622  * Description: procedural assignment with bitwise or
1623  * Number Of Arguments: 3
1624  * arg0: CNode* event expression
1625  * arg1: CNode* lval
1626  * arg2: CNode* rval
1627  */
1632  /*
1633  * XOR_ASSIGN node
1634  * Description: procedural assignment with bitwise xor
1635  * Number Of Arguments: 3
1636  * arg0: CNode* event expression
1637  * arg1: CNode* lval
1638  * arg2: CNode* rval
1639  */
1644  /*
1645  * LSH_ASSIGN node
1646  * Description: procedural assignment with left shift
1647  * Number Of Arguments: 3
1648  * arg0: CNode* event expression
1649  * arg1: CNode* lval
1650  * arg2: CNode* rval
1651  */
1656  /*
1657  * RSH_ASSIGN node
1658  * Description: procedural assignment with right shift
1659  * Number Of Arguments: 3
1660  * arg0: CNode* event expression
1661  * arg1: CNode* lval
1662  * arg2: CNode* rval
1663  */
1668  /*
1669  * LSHA_ASSIGN node
1670  * Description: procedural assignment with left arithmetic shift
1671  * Number Of Arguments: 3
1672  * arg0: CNode* event expression
1673  * arg1: CNode* lval
1674  * arg2: CNode* rval
1675  */
1680  /*
1681  * RSHA_ASSIGN node
1682  * Description: procedural assignment with right arithmetic shift
1683  * Number Of Arguments: 3
1684  * arg0: CNode* event expression
1685  * arg1: CNode* lval
1686  * arg2: CNode* rval
1687  */
1692  /*
1693  * FORCE node
1694  * Description: force statement
1695  * Number Of Arguments: 2
1696  * arg0: CNode* lval
1697  * arg1: CNode* expression
1698  */
1703  /*
1704  * RELEASE node
1705  * Description: release statement
1706  * Number Of Arguments: 1
1707  * arg0: CNode* lval
1708  */
1713  /*
1714  * NBASSIGN node
1715  * Description: nonblocking assignment
1716  * Number Of Arguments: 3
1717  * arg0: CNode* event expression
1718  * arg1: CNode* lval
1719  * arg2: CNode* rval
1720  */
1725  /*
1726  * POSEDGE node
1727  * Description: positive event qualifier
1728  * Number Of Arguments: 1
1729  * arg0: CNode* expression
1730  */
1735  /*
1736  * NEGEDGE node
1737  * Description: negative event qualifier
1738  * Number Of Arguments: 1
1739  * arg0: CNode* expression
1740  */
1745  /*
1746  * EDGE node
1747  * Description: edge qualifier
1748  * Number Of Arguments: 2
1749  * arg0: CNode*
1750  * arg1: Edge_t edge specification
1751  */
1756  /*
1757  * EVOR node
1758  * Description: event or
1759  * Number Of Arguments: 2
1760  * arg0: CNode* expression 1
1761  * arg1: CNode* expression 2
1762  */
1767  /*
1768  * DELAY node
1769  * Description: delay statement
1770  * Number Of Arguments: 2
1771  * arg0: CNode* delay expression
1772  * arg1: CNode* statements
1773  */
1778  /*
1779  * MTM node
1780  * Description: min/typ/max expression
1781  * Number Of Arguments: 3
1782  * arg0: CNode* minimum expression
1783  * arg1: CNode* typical expression
1784  * arg2: CNode* maximum expression
1785  */
1790  /*
1791  * IF node
1792  * Description: if statement
1793  * Number Of Arguments: 3
1794  * arg0: CNode* condition
1795  * arg1: CNode* true statements
1796  * arg2: CNode* false statements
1797  */
1802  /*
1803  * FOREVER node
1804  * Description: forever statement
1805  * Number Of Arguments: 1
1806  * arg0: CNode* statements
1807  */
1812  /*
1813  * REPEAT node
1814  * Description: repeat statement
1815  * Number Of Arguments: 2
1816  * arg0: CNode* condition
1817  * arg1: CNode* statements
1818  */
1823  /*
1824  * WHILE node
1825  * Description: while statement
1826  * Number Of Arguments: 2
1827  * arg0: CNode* condition
1828  * arg1: CNode* statements
1829  */
1834  /*
1835  * WAIT node
1836  * Description: wait statement
1837  * Number Of Arguments: 2
1838  * arg0: CNode* condition
1839  * arg1: CNode* statements
1840  */
1845  /*
1846  * FOR node
1847  * Description: for statement
1848  * Number Of Arguments: 4
1849  * arg0: CNode* initial statement
1850  * arg1: CNode* condition
1851  * arg2: CNode* assignment statement
1852  * arg3: CNode* statements
1853  */
1858  /*
1859  * CASE node
1860  * Description: case statement
1861  * Number Of Arguments: 2
1862  * arg0: CNode* condition
1863  * arg1: CNode* list of case items
1864  */
1869  /*
1870  * CASEX node
1871  * Description: casex statement
1872  * Number Of Arguments: 2
1873  * arg0: CNode* condition
1874  * arg1: CNode* list of case items
1875  */
1880  /*
1881  * CASEZ node
1882  * Description: casez statement
1883  * Number Of Arguments: 2
1884  * arg0: CNode* condition
1885  * arg1: CNode* list of case items
1886  */
1891  /*
1892  * CASEITEM node
1893  * Description: case item
1894  * Number Of Arguments: 2
1895  * arg0: CNode* list of expressions (NULL for default)
1896  * arg1: CNode* statement
1897  */
1902  /*
1903  * CASSIGN node
1904  * Description: continious assignment
1905  * Number Of Arguments: 4
1906  * arg0: StrengthPair_t* assignment strength
1907  * arg1: CNode* delay expression
1908  * arg2: CNode* lval
1909  * arg3: CNode* rval expression
1910  */
1915  /*
1916  * ARG node
1917  * Description: port connection
1918  * Number Of Arguments: 2
1919  * arg0: CSymbol* port name
1920  * arg1: CNode* port expression
1921  */
1926  /*
1927  * IMPORT node
1928  * Description: import item
1929  * Number Of Arguments: 1
1930  * arg0: CSymbol* package::symbol or package(for wildcard)
1931  */
1936  /*
1937  * FUNCTION_DEF node
1938  * Description: function definition
1939  * Number Of Arguments: 1
1940  * arg0: CFunction*
1941  */
1946  /*
1947  * MODULE_DEF node
1948  * Description: module definition
1949  * Number Of Arguments: 1
1950  * arg0: CModule*
1951  */
1956  /*
1957  * PACKAGE_DEF node
1958  * Description: package definition
1959  * Number Of Arguments: 1
1960  * arg0: CPackage*
1961  */
1966  /*
1967  * REPEAT_CONTROL node
1968  * Description: repeat control
1969  * Number Of Arguments: 2
1970  * arg0: CNode* expression
1971  * arg1: CNode* event control
1972  */
1977  /*
1978  * DELAY_CONTROL node
1979  * Description: delay control
1980  * Number Of Arguments: 1
1981  * arg0: CNode* expression
1982  */
1987  /*
1988  * EVENT_CONTROL node
1989  * Description: event control
1990  * Number Of Arguments: 1
1991  * arg0: CNode* event expression (NULL for @*)
1992  */
1997  /*
1998  * EXTERNAL_REF node
1999  * Description: external reference
2000  * Number Of Arguments: 1
2001  * arg0: CSymbol* pointer to symbol
2002  */
2007  /*
2008  * PORT_DEF node
2009  * Description: port definition
2010  * Number Of Arguments: 1
2011  * arg0: CPort* pointer to port
2012  */
2017  /*
2018  * DEFPARAM node
2019  * Description: defparam statement
2020  * Number Of Arguments: 2
2021  * arg0: CNode* external reference
2022  * arg1: CNode* expression
2023  */
2028  /*
2029  * PATH node
2030  * Description: path statement
2031  * Number Of Arguments: 7
2032  * arg0: int
2033  * arg1: CNode* edge int[-1,0,1]
2034  * arg2: int Input list
2035  * arg3: int Left polarity int[-1,0,1]
2036  * arg4: CNode* Operation type int [0 = *>, 1 = =>]
2037  * arg5: int Output list
2038  * arg6: CNode* Right polarity int[-1,0,1]
2039  */
2044  /*
2045  * PATH_ASSIGN node
2046  * Description: path assignment statement
2047  * Number Of Arguments: 3
2048  * arg0: CNode* condition
2049  * arg1: CNode* path
2050  * arg2: CNode* expression
2051  */
2056  /*
2057  * IFNONE_PATH_ASSIGN node
2058  * Description: ifnone path assignment statement
2059  * Number Of Arguments: 2
2060  * arg0: CNode* path
2061  * arg1: CNode* expression
2062  */
2067  /*
2068  * TRIGGER node
2069  * Description: event trigger
2070  * Number Of Arguments: 1
2071  * arg0: CNode* event reference
2072  */
2077  /*
2078  * PASSIGN node
2079  * Description: procedural assignment
2080  * Number Of Arguments: 2
2081  * arg0: CNode* lval
2082  * arg1: CNode* expression
2083  */
2088  /*
2089  * DEASSIGN node
2090  * Description: deassign statement
2091  * Number Of Arguments: 1
2092  * arg0: CNode* lval
2093  */
2098  /*
2099  * DISABLE node
2100  * Description: disable statement
2101  * Number Of Arguments: 1
2102  * arg0: CSymbol* pointer to symbol
2103  */
2108  /*
2109  * ATTRIBUTE node
2110  * Description: attribute specification
2111  * Number Of Arguments: 1
2112  * arg0: CAttr* pointer to attribute
2113  */
2118  /*
2119  * GIF node
2120  * Description: structural if statement
2121  * Number Of Arguments: 3
2122  * arg0: CNode* condition
2123  * arg1: CNode* true statement
2124  * arg2: CNode* false statement
2125  */
2130  /*
2131  * GFOR node
2132  * Description: structural for statement
2133  * Number Of Arguments: 4
2134  * arg0: CNode* initial statement
2135  * arg1: CNode* condition
2136  * arg2: CNode* assignment statement
2137  * arg3: CNode* statement
2138  */
2143  /*
2144  * GCASE node
2145  * Description: structural case statement
2146  * Number Of Arguments: 2
2147  * arg0: CNode* condition
2148  * arg1: CNode* list of case items
2149  */
2154  /*
2155  * TABLE node
2156  * Description: udp table
2157  * Number Of Arguments: 1
2158  * arg0: CNode* list of table entries
2159  */
2164  /*
2165  * TABLE_ENTRY node
2166  * Description: udp table entry
2167  * Number Of Arguments: 1
2168  * arg0: CNode* list of table symbols
2169  */
2174  /*
2175  * TABLE_SYMBOL node
2176  * Description: udp table symbol
2177  * Number Of Arguments: 1
2178  * arg0: char* string of udp characters
2179  */
2184  /*
2185  * PORTLIST_END node
2186  * Description: sentinal at end of port list
2187  * Number Of Arguments: 0
2188  */
2193  /*
2194  * MACRO_EXPR node
2195  * Description: expression represented by a macro
2196  * Number Of Arguments: 2
2197  * arg0: const char* alternate expression, may be NULL
2198  * arg1: CNode*
2199  */
2204  /*
2205  * ENUM_SPEC node
2206  * Description: enum specification
2207  * Number Of Arguments: 3
2208  * arg0: CSymbol* Pointer to enum base symbol
2209  * arg1: CNode* range expression
2210  * arg2: CNode* starting expression value
2211  */
2216  /*
2217  * MEMBER node
2218  * Description: member reference (structure, class or external
2219  * Number Of Arguments: 2
2220  * arg0: CNode* Reference to variable
2221  * arg1: CSymbol* member symbol
2222  */
2227  /*
2228  * RETURN node
2229  * Description: return
2230  * Number Of Arguments: 1
2231  * arg0: CNode*
2232  */
2237  /*
2238  * PREINC node
2239  * Description: preincrement
2240  * Number Of Arguments: 1
2241  * arg0: CNode* expression
2242  */
2247  /*
2248  * POSTINC node
2249  * Description: postincrement
2250  * Number Of Arguments: 1
2251  * arg0: CNode* expression
2252  */
2257  /*
2258  * PREDEC node
2259  * Description: predecrement
2260  * Number Of Arguments: 1
2261  * arg0: CNode* expression
2262  */
2267  /*
2268  * POSTDEC node
2269  * Description: postdecrement
2270  * Number Of Arguments: 1
2271  * arg0: CNode* expression
2272  */
2277  /*
2278  * CAST node
2279  * Description: data type change
2280  * Number Of Arguments: 2
2281  * arg0: CNode* type reference or width expression
2282  * arg1: CNode* expression
2283  */
2285 };
2286 extern const char* nodeOpName[];
2287 extern const char* nodeOpDescription[];
2288 #endif // DEFINE_ENUM
2289 #ifdef DEFINE_METHODS
2290 const char* nodeOpName[] = {
2291  "ERROR",
2292  "VCONSTANT",
2293  "RCONSTANT",
2294  "COMMENT",
2295  "VRQ",
2296  "PRAGMA",
2297  "ELIST",
2298  "WIDTH",
2299  "NOP",
2300  "SUB",
2301  "MUL",
2302  "DIV",
2303  "POW",
2304  "ADD",
2305  "LSH",
2306  "RSH",
2307  "LSHA",
2308  "RSHA",
2309  "MOD",
2310  "OR",
2311  "AND",
2312  "ANDANDAND",
2313  "XOR",
2314  "XNOR",
2315  "INSTANCE_REF",
2316  "GATE_REF",
2317  "TASK_ENABLE",
2318  "SYSTASK_CALL",
2319  "TIMING_CALL",
2320  "FUNCTION_CALL",
2321  "ARRAY",
2322  "NET_REF",
2323  "VAR_REF",
2324  "PARAM_REF",
2325  "PORT_REF",
2326  "FWD_REF",
2327  "GENVAR_REF",
2328  "ENUM_REF",
2329  "TYPE_REF",
2330  "NET_DECL",
2331  "VAR_DECL",
2332  "PARAM_DECL",
2333  "SPECPARAM_DECL",
2334  "PORT_DECL",
2335  "GENVAR_DECL",
2336  "TYPEDEF_DECL",
2337  "LIST",
2338  "RANGE",
2339  "SLICE",
2340  "PSLICE",
2341  "MSLICE",
2342  "CVRI",
2343  "CVIR",
2344  "REP",
2345  "CAT",
2346  "UCAT",
2347  "COM",
2348  "NEG",
2349  "PLUS",
2350  "NOT",
2351  "GT",
2352  "GE",
2353  "LT",
2354  "LE",
2355  "LAND",
2356  "LOR",
2357  "CEQ",
2358  "CNE",
2359  "EQ",
2360  "NE",
2361  "RAND",
2362  "RNAND",
2363  "ROR",
2364  "RNOR",
2365  "RXOR",
2366  "RXNOR",
2367  "HOOK",
2368  "INIT",
2369  "ALWAYS",
2370  "ALWAYS_LATCH",
2371  "ALWAYS_FF",
2372  "ALWAYS_COMB",
2373  "EVENT",
2374  "BLOCK_REF",
2375  "SPECIFY_REF",
2376  "ASSIGN",
2377  "GASSIGN",
2378  "ADD_ASSIGN",
2379  "SUB_ASSIGN",
2380  "MUL_ASSIGN",
2381  "DIV_ASSIGN",
2382  "MOD_ASSIGN",
2383  "AND_ASSIGN",
2384  "OR_ASSIGN",
2385  "XOR_ASSIGN",
2386  "LSH_ASSIGN",
2387  "RSH_ASSIGN",
2388  "LSHA_ASSIGN",
2389  "RSHA_ASSIGN",
2390  "FORCE",
2391  "RELEASE",
2392  "NBASSIGN",
2393  "POSEDGE",
2394  "NEGEDGE",
2395  "EDGE",
2396  "EVOR",
2397  "DELAY",
2398  "MTM",
2399  "IF",
2400  "FOREVER",
2401  "REPEAT",
2402  "WHILE",
2403  "WAIT",
2404  "FOR",
2405  "CASE",
2406  "CASEX",
2407  "CASEZ",
2408  "CASEITEM",
2409  "CASSIGN",
2410  "ARG",
2411  "IMPORT",
2412  "FUNCTION_DEF",
2413  "MODULE_DEF",
2414  "PACKAGE_DEF",
2415  "REPEAT_CONTROL",
2416  "DELAY_CONTROL",
2417  "EVENT_CONTROL",
2418  "EXTERNAL_REF",
2419  "PORT_DEF",
2420  "DEFPARAM",
2421  "PATH",
2422  "PATH_ASSIGN",
2423  "IFNONE_PATH_ASSIGN",
2424  "TRIGGER",
2425  "PASSIGN",
2426  "DEASSIGN",
2427  "DISABLE",
2428  "ATTRIBUTE",
2429  "GIF",
2430  "GFOR",
2431  "GCASE",
2432  "TABLE",
2433  "TABLE_ENTRY",
2434  "TABLE_SYMBOL",
2435  "PORTLIST_END",
2436  "MACRO_EXPR",
2437  "ENUM_SPEC",
2438  "MEMBER",
2439  "RETURN",
2440  "PREINC",
2441  "POSTINC",
2442  "PREDEC",
2443  "POSTDEC",
2444  "CAST",
2445 NULL
2446 };
2447 const char* nodeOpDescription[] = {
2448  "error node",
2449  "vector constant",
2450  "real constant",
2451  "comment",
2452  "vrq comment",
2453  "program pragma",
2454  "expression list",
2455  "expression width change",
2456  "no operation",
2457  "subtract",
2458  "multiply",
2459  "divide",
2460  "exponent",
2461  "addition",
2462  "logical left shift",
2463  "logical right shift",
2464  "arithmetic left shift",
2465  "arithmetic right shift",
2466  "modulus",
2467  "bitwise or",
2468  "bitwise and",
2469  "triple and",
2470  "bitwise xor",
2471  "bitwise xnor",
2472  "instance reference",
2473  "gate instance",
2474  "call to a task",
2475  "call to enable a systask",
2476  "call to a timing task",
2477  "call to a function",
2478  "dimensioned reference (array/bit select)",
2479  "reference to net",
2480  "reference to variable",
2481  "reference to parameter",
2482  "reference to port",
2483  "reference to a forward declared variable",
2484  "reference to a genvar",
2485  "reference to a enum",
2486  "reference to a type",
2487  "net declaration",
2488  "variable declaration",
2489  "parameter declaration",
2490  "specify parameter declaration",
2491  "port declaration",
2492  "genvar declaration",
2493  "type declaration",
2494  "list of nodes",
2495  "vector decl range specification",
2496  "vector subrange",
2497  "vector subrange with ascending index select",
2498  "vector subrange with descending index select",
2499  "convert real to integer",
2500  "convert integer to real",
2501  "replication operator",
2502  "concatenation operator",
2503  "unary concat",
2504  "bitwise complement",
2505  "negation",
2506  "unary plus",
2507  "logical complement",
2508  "greater than",
2509  "greater than or equal",
2510  "less than",
2511  "less than or equal",
2512  "logical and",
2513  "logical or",
2514  "case equal",
2515  "case not equal",
2516  "equal",
2517  "not equal",
2518  "reduction and",
2519  "reduction nand",
2520  "reduction or",
2521  "reduction nor",
2522  "reduction xor",
2523  "reduction xnor",
2524  "condition expression operator",
2525  "initial block",
2526  "always block",
2527  "always latch block",
2528  "always flip-flop block",
2529  "always combinational logic block",
2530  "event statement",
2531  "statement block",
2532  "specify block",
2533  "procedural assignment",
2534  "generate intialize assignment",
2535  "procedural assignment with add",
2536  "procedural assignment with subtract",
2537  "procedural assignment with mul",
2538  "procedural assignment with div",
2539  "procedural assignment with mod",
2540  "procedural assignment with bitwise and",
2541  "procedural assignment with bitwise or",
2542  "procedural assignment with bitwise xor",
2543  "procedural assignment with left shift",
2544  "procedural assignment with right shift",
2545  "procedural assignment with left arithmetic shift",
2546  "procedural assignment with right arithmetic shift",
2547  "force statement",
2548  "release statement",
2549  "nonblocking assignment",
2550  "positive event qualifier",
2551  "negative event qualifier",
2552  "edge qualifier",
2553  "event or",
2554  "delay statement",
2555  "min/typ/max expression",
2556  "if statement",
2557  "forever statement",
2558  "repeat statement",
2559  "while statement",
2560  "wait statement",
2561  "for statement",
2562  "case statement",
2563  "casex statement",
2564  "casez statement",
2565  "case item",
2566  "continious assignment",
2567  "port connection",
2568  "import item",
2569  "function definition",
2570  "module definition",
2571  "package definition",
2572  "repeat control",
2573  "delay control",
2574  "event control",
2575  "external reference",
2576  "port definition",
2577  "defparam statement",
2578  "path statement",
2579  "path assignment statement",
2580  "ifnone path assignment statement",
2581  "event trigger",
2582  "procedural assignment",
2583  "deassign statement",
2584  "disable statement",
2585  "attribute specification",
2586  "structural if statement",
2587  "structural for statement",
2588  "structural case statement",
2589  "udp table",
2590  "udp table entry",
2591  "udp table symbol",
2592  "sentinal at end of port list",
2593  "expression represented by a macro",
2594  "enum specification",
2595  "member reference (structure, class or external",
2596  "return",
2597  "preincrement",
2598  "postincrement",
2599  "predecrement",
2600  "postdecrement",
2601  "data type change",
2602 NULL
2603 };
2604 #endif // DEFINE_METHODS
2605 
2606 
2607 #ifdef DEFINE_CONSTRUCTOR
2608 
2616 inline CNode* cERROR( Coord_t* loc=NULL )
2617 {
2618  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eERROR );
2619  return n;
2620 }
2629 inline CNode* cERROR( CObstack* heap, Coord_t* loc=NULL )
2630 {
2631  CNode* n = new(heap) CNode( loc, eERROR );
2632  return n;
2633 }
2642 inline CNode* cVCONSTANT( CVector* a0, Coord_t* loc=NULL )
2643 {
2644  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eVCONSTANT );
2645  n->Arg<CVector*>(0) = a0;
2646  return n;
2647 }
2657 inline CNode* cVCONSTANT( CObstack* heap, CVector* a0, Coord_t* loc=NULL )
2658 {
2659  CNode* n = new(heap) CNode( loc, eVCONSTANT );
2660  n->Arg<CVector*>(0) = a0;
2661  return n;
2662 }
2671 inline CNode* cRCONSTANT( char* a0, Coord_t* loc=NULL )
2672 {
2673  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRCONSTANT );
2674  n->Arg<char*>(0) = a0;
2675  return n;
2676 }
2686 inline CNode* cRCONSTANT( CObstack* heap, char* a0, Coord_t* loc=NULL )
2687 {
2688  CNode* n = new(heap) CNode( loc, eRCONSTANT );
2689  n->Arg<char*>(0) = a0;
2690  return n;
2691 }
2700 inline CNode* cCOMMENT( const char* a0, Coord_t* loc=NULL )
2701 {
2702  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCOMMENT );
2703  n->Arg<const char*>(0) = a0;
2704  return n;
2705 }
2715 inline CNode* cCOMMENT( CObstack* heap, const char* a0, Coord_t* loc=NULL )
2716 {
2717  CNode* n = new(heap) CNode( loc, eCOMMENT );
2718  n->Arg<const char*>(0) = a0;
2719  return n;
2720 }
2729 inline CNode* cVRQ( const char* a0, Coord_t* loc=NULL )
2730 {
2731  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eVRQ );
2732  n->Arg<const char*>(0) = a0;
2733  return n;
2734 }
2744 inline CNode* cVRQ( CObstack* heap, const char* a0, Coord_t* loc=NULL )
2745 {
2746  CNode* n = new(heap) CNode( loc, eVRQ );
2747  n->Arg<const char*>(0) = a0;
2748  return n;
2749 }
2758 inline CNode* cPRAGMA( const char* a0, Coord_t* loc=NULL )
2759 {
2760  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePRAGMA );
2761  n->Arg<const char*>(0) = a0;
2762  return n;
2763 }
2773 inline CNode* cPRAGMA( CObstack* heap, const char* a0, Coord_t* loc=NULL )
2774 {
2775  CNode* n = new(heap) CNode( loc, ePRAGMA );
2776  n->Arg<const char*>(0) = a0;
2777  return n;
2778 }
2788 inline CNode* cELIST( CNode* a0, CNode* a1, Coord_t* loc=NULL )
2789 {
2790  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eELIST );
2791  n->Arg<CNode*>(0) = a0;
2792  n->Arg<CNode*>(1) = a1;
2793  return n;
2794 }
2805 inline CNode* cELIST( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
2806 {
2807  CNode* n = new(heap) CNode( loc, eELIST );
2808  n->Arg<CNode*>(0) = a0;
2809  n->Arg<CNode*>(1) = a1;
2810  return n;
2811 }
2821 inline CNode* cWIDTH( CNode* a0, CNode* a1, Coord_t* loc=NULL )
2822 {
2823  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eWIDTH );
2824  n->Arg<CNode*>(0) = a0;
2825  n->Arg<CNode*>(1) = a1;
2826  return n;
2827 }
2838 inline CNode* cWIDTH( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
2839 {
2840  CNode* n = new(heap) CNode( loc, eWIDTH );
2841  n->Arg<CNode*>(0) = a0;
2842  n->Arg<CNode*>(1) = a1;
2843  return n;
2844 }
2852 inline CNode* cNOP( Coord_t* loc=NULL )
2853 {
2854  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eNOP );
2855  return n;
2856 }
2865 inline CNode* cNOP( CObstack* heap, Coord_t* loc=NULL )
2866 {
2867  CNode* n = new(heap) CNode( loc, eNOP );
2868  return n;
2869 }
2879 inline CNode* cSUB( CNode* a0, CNode* a1, Coord_t* loc=NULL )
2880 {
2881  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eSUB );
2882  n->Arg<CNode*>(0) = a0;
2883  n->Arg<CNode*>(1) = a1;
2884  return n;
2885 }
2896 inline CNode* cSUB( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
2897 {
2898  CNode* n = new(heap) CNode( loc, eSUB );
2899  n->Arg<CNode*>(0) = a0;
2900  n->Arg<CNode*>(1) = a1;
2901  return n;
2902 }
2912 inline CNode* cMUL( CNode* a0, CNode* a1, Coord_t* loc=NULL )
2913 {
2914  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eMUL );
2915  n->Arg<CNode*>(0) = a0;
2916  n->Arg<CNode*>(1) = a1;
2917  return n;
2918 }
2929 inline CNode* cMUL( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
2930 {
2931  CNode* n = new(heap) CNode( loc, eMUL );
2932  n->Arg<CNode*>(0) = a0;
2933  n->Arg<CNode*>(1) = a1;
2934  return n;
2935 }
2945 inline CNode* cDIV( CNode* a0, CNode* a1, Coord_t* loc=NULL )
2946 {
2947  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eDIV );
2948  n->Arg<CNode*>(0) = a0;
2949  n->Arg<CNode*>(1) = a1;
2950  return n;
2951 }
2962 inline CNode* cDIV( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
2963 {
2964  CNode* n = new(heap) CNode( loc, eDIV );
2965  n->Arg<CNode*>(0) = a0;
2966  n->Arg<CNode*>(1) = a1;
2967  return n;
2968 }
2978 inline CNode* cPOW( CNode* a0, CNode* a1, Coord_t* loc=NULL )
2979 {
2980  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePOW );
2981  n->Arg<CNode*>(0) = a0;
2982  n->Arg<CNode*>(1) = a1;
2983  return n;
2984 }
2995 inline CNode* cPOW( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
2996 {
2997  CNode* n = new(heap) CNode( loc, ePOW );
2998  n->Arg<CNode*>(0) = a0;
2999  n->Arg<CNode*>(1) = a1;
3000  return n;
3001 }
3011 inline CNode* cADD( CNode* a0, CNode* a1, Coord_t* loc=NULL )
3012 {
3013  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eADD );
3014  n->Arg<CNode*>(0) = a0;
3015  n->Arg<CNode*>(1) = a1;
3016  return n;
3017 }
3028 inline CNode* cADD( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
3029 {
3030  CNode* n = new(heap) CNode( loc, eADD );
3031  n->Arg<CNode*>(0) = a0;
3032  n->Arg<CNode*>(1) = a1;
3033  return n;
3034 }
3044 inline CNode* cLSH( CNode* a0, CNode* a1, Coord_t* loc=NULL )
3045 {
3046  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eLSH );
3047  n->Arg<CNode*>(0) = a0;
3048  n->Arg<CNode*>(1) = a1;
3049  return n;
3050 }
3061 inline CNode* cLSH( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
3062 {
3063  CNode* n = new(heap) CNode( loc, eLSH );
3064  n->Arg<CNode*>(0) = a0;
3065  n->Arg<CNode*>(1) = a1;
3066  return n;
3067 }
3077 inline CNode* cRSH( CNode* a0, CNode* a1, Coord_t* loc=NULL )
3078 {
3079  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRSH );
3080  n->Arg<CNode*>(0) = a0;
3081  n->Arg<CNode*>(1) = a1;
3082  return n;
3083 }
3094 inline CNode* cRSH( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
3095 {
3096  CNode* n = new(heap) CNode( loc, eRSH );
3097  n->Arg<CNode*>(0) = a0;
3098  n->Arg<CNode*>(1) = a1;
3099  return n;
3100 }
3110 inline CNode* cLSHA( CNode* a0, CNode* a1, Coord_t* loc=NULL )
3111 {
3112  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eLSHA );
3113  n->Arg<CNode*>(0) = a0;
3114  n->Arg<CNode*>(1) = a1;
3115  return n;
3116 }
3127 inline CNode* cLSHA( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
3128 {
3129  CNode* n = new(heap) CNode( loc, eLSHA );
3130  n->Arg<CNode*>(0) = a0;
3131  n->Arg<CNode*>(1) = a1;
3132  return n;
3133 }
3143 inline CNode* cRSHA( CNode* a0, CNode* a1, Coord_t* loc=NULL )
3144 {
3145  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRSHA );
3146  n->Arg<CNode*>(0) = a0;
3147  n->Arg<CNode*>(1) = a1;
3148  return n;
3149 }
3160 inline CNode* cRSHA( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
3161 {
3162  CNode* n = new(heap) CNode( loc, eRSHA );
3163  n->Arg<CNode*>(0) = a0;
3164  n->Arg<CNode*>(1) = a1;
3165  return n;
3166 }
3176 inline CNode* cMOD( CNode* a0, CNode* a1, Coord_t* loc=NULL )
3177 {
3178  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eMOD );
3179  n->Arg<CNode*>(0) = a0;
3180  n->Arg<CNode*>(1) = a1;
3181  return n;
3182 }
3193 inline CNode* cMOD( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
3194 {
3195  CNode* n = new(heap) CNode( loc, eMOD );
3196  n->Arg<CNode*>(0) = a0;
3197  n->Arg<CNode*>(1) = a1;
3198  return n;
3199 }
3209 inline CNode* cOR( CNode* a0, CNode* a1, Coord_t* loc=NULL )
3210 {
3211  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eOR );
3212  n->Arg<CNode*>(0) = a0;
3213  n->Arg<CNode*>(1) = a1;
3214  return n;
3215 }
3226 inline CNode* cOR( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
3227 {
3228  CNode* n = new(heap) CNode( loc, eOR );
3229  n->Arg<CNode*>(0) = a0;
3230  n->Arg<CNode*>(1) = a1;
3231  return n;
3232 }
3242 inline CNode* cAND( CNode* a0, CNode* a1, Coord_t* loc=NULL )
3243 {
3244  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eAND );
3245  n->Arg<CNode*>(0) = a0;
3246  n->Arg<CNode*>(1) = a1;
3247  return n;
3248 }
3259 inline CNode* cAND( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
3260 {
3261  CNode* n = new(heap) CNode( loc, eAND );
3262  n->Arg<CNode*>(0) = a0;
3263  n->Arg<CNode*>(1) = a1;
3264  return n;
3265 }
3275 inline CNode* cANDANDAND( CNode* a0, CNode* a1, Coord_t* loc=NULL )
3276 {
3277  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eANDANDAND );
3278  n->Arg<CNode*>(0) = a0;
3279  n->Arg<CNode*>(1) = a1;
3280  return n;
3281 }
3292 inline CNode* cANDANDAND( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
3293 {
3294  CNode* n = new(heap) CNode( loc, eANDANDAND );
3295  n->Arg<CNode*>(0) = a0;
3296  n->Arg<CNode*>(1) = a1;
3297  return n;
3298 }
3308 inline CNode* cXOR( CNode* a0, CNode* a1, Coord_t* loc=NULL )
3309 {
3310  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eXOR );
3311  n->Arg<CNode*>(0) = a0;
3312  n->Arg<CNode*>(1) = a1;
3313  return n;
3314 }
3325 inline CNode* cXOR( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
3326 {
3327  CNode* n = new(heap) CNode( loc, eXOR );
3328  n->Arg<CNode*>(0) = a0;
3329  n->Arg<CNode*>(1) = a1;
3330  return n;
3331 }
3341 inline CNode* cXNOR( CNode* a0, CNode* a1, Coord_t* loc=NULL )
3342 {
3343  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eXNOR );
3344  n->Arg<CNode*>(0) = a0;
3345  n->Arg<CNode*>(1) = a1;
3346  return n;
3347 }
3358 inline CNode* cXNOR( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
3359 {
3360  CNode* n = new(heap) CNode( loc, eXNOR );
3361  n->Arg<CNode*>(0) = a0;
3362  n->Arg<CNode*>(1) = a1;
3363  return n;
3364 }
3373 inline CNode* cINSTANCE_REF( CInstance* a0, Coord_t* loc=NULL )
3374 {
3375  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eINSTANCE_REF );
3376  n->Arg<CInstance*>(0) = a0;
3377  return n;
3378 }
3388 inline CNode* cINSTANCE_REF( CObstack* heap, CInstance* a0, Coord_t* loc=NULL )
3389 {
3390  CNode* n = new(heap) CNode( loc, eINSTANCE_REF );
3391  n->Arg<CInstance*>(0) = a0;
3392  return n;
3393 }
3402 inline CNode* cGATE_REF( CGate* a0, Coord_t* loc=NULL )
3403 {
3404  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eGATE_REF );
3405  n->Arg<CGate*>(0) = a0;
3406  return n;
3407 }
3417 inline CNode* cGATE_REF( CObstack* heap, CGate* a0, Coord_t* loc=NULL )
3418 {
3419  CNode* n = new(heap) CNode( loc, eGATE_REF );
3420  n->Arg<CGate*>(0) = a0;
3421  return n;
3422 }
3432 inline CNode* cTASK_ENABLE( CSymbol* a0, CNode* a1, Coord_t* loc=NULL )
3433 {
3434  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eTASK_ENABLE );
3435  n->Arg<CSymbol*>(0) = a0;
3436  n->Arg<CNode*>(1) = a1;
3437  return n;
3438 }
3449 inline CNode* cTASK_ENABLE( CObstack* heap, CSymbol* a0, CNode* a1, Coord_t* loc=NULL )
3450 {
3451  CNode* n = new(heap) CNode( loc, eTASK_ENABLE );
3452  n->Arg<CSymbol*>(0) = a0;
3453  n->Arg<CNode*>(1) = a1;
3454  return n;
3455 }
3465 inline CNode* cSYSTASK_CALL( CSymbol* a0, CNode* a1, Coord_t* loc=NULL )
3466 {
3467  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eSYSTASK_CALL );
3468  n->Arg<CSymbol*>(0) = a0;
3469  n->Arg<CNode*>(1) = a1;
3470  return n;
3471 }
3482 inline CNode* cSYSTASK_CALL( CObstack* heap, CSymbol* a0, CNode* a1, Coord_t* loc=NULL )
3483 {
3484  CNode* n = new(heap) CNode( loc, eSYSTASK_CALL );
3485  n->Arg<CSymbol*>(0) = a0;
3486  n->Arg<CNode*>(1) = a1;
3487  return n;
3488 }
3498 inline CNode* cTIMING_CALL( CSymbol* a0, CNode* a1, Coord_t* loc=NULL )
3499 {
3500  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eTIMING_CALL );
3501  n->Arg<CSymbol*>(0) = a0;
3502  n->Arg<CNode*>(1) = a1;
3503  return n;
3504 }
3515 inline CNode* cTIMING_CALL( CObstack* heap, CSymbol* a0, CNode* a1, Coord_t* loc=NULL )
3516 {
3517  CNode* n = new(heap) CNode( loc, eTIMING_CALL );
3518  n->Arg<CSymbol*>(0) = a0;
3519  n->Arg<CNode*>(1) = a1;
3520  return n;
3521 }
3532 inline CNode* cFUNCTION_CALL( CSymbol* a0, CNode* a1, CScope* a2, Coord_t* loc=NULL )
3533 {
3534  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eFUNCTION_CALL );
3535  n->Arg<CSymbol*>(0) = a0;
3536  n->Arg<CNode*>(1) = a1;
3537  n->Arg<CScope*>(2) = a2;
3538  return n;
3539 }
3551 inline CNode* cFUNCTION_CALL( CObstack* heap, CSymbol* a0, CNode* a1, CScope* a2, Coord_t* loc=NULL )
3552 {
3553  CNode* n = new(heap) CNode( loc, eFUNCTION_CALL );
3554  n->Arg<CSymbol*>(0) = a0;
3555  n->Arg<CNode*>(1) = a1;
3556  n->Arg<CScope*>(2) = a2;
3557  return n;
3558 }
3568 inline CNode* cARRAY( CNode* a0, CNode* a1, Coord_t* loc=NULL )
3569 {
3570  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eARRAY );
3571  n->Arg<CNode*>(0) = a0;
3572  n->Arg<CNode*>(1) = a1;
3573  return n;
3574 }
3585 inline CNode* cARRAY( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
3586 {
3587  CNode* n = new(heap) CNode( loc, eARRAY );
3588  n->Arg<CNode*>(0) = a0;
3589  n->Arg<CNode*>(1) = a1;
3590  return n;
3591 }
3600 inline CNode* cNET_REF( CNet* a0, Coord_t* loc=NULL )
3601 {
3602  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eNET_REF );
3603  n->Arg<CNet*>(0) = a0;
3604  return n;
3605 }
3615 inline CNode* cNET_REF( CObstack* heap, CNet* a0, Coord_t* loc=NULL )
3616 {
3617  CNode* n = new(heap) CNode( loc, eNET_REF );
3618  n->Arg<CNet*>(0) = a0;
3619  return n;
3620 }
3629 inline CNode* cVAR_REF( CVar* a0, Coord_t* loc=NULL )
3630 {
3631  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eVAR_REF );
3632  n->Arg<CVar*>(0) = a0;
3633  return n;
3634 }
3644 inline CNode* cVAR_REF( CObstack* heap, CVar* a0, Coord_t* loc=NULL )
3645 {
3646  CNode* n = new(heap) CNode( loc, eVAR_REF );
3647  n->Arg<CVar*>(0) = a0;
3648  return n;
3649 }
3658 inline CNode* cPARAM_REF( CParam* a0, Coord_t* loc=NULL )
3659 {
3660  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePARAM_REF );
3661  n->Arg<CParam*>(0) = a0;
3662  return n;
3663 }
3673 inline CNode* cPARAM_REF( CObstack* heap, CParam* a0, Coord_t* loc=NULL )
3674 {
3675  CNode* n = new(heap) CNode( loc, ePARAM_REF );
3676  n->Arg<CParam*>(0) = a0;
3677  return n;
3678 }
3687 inline CNode* cPORT_REF( CPortDir* a0, Coord_t* loc=NULL )
3688 {
3689  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePORT_REF );
3690  n->Arg<CPortDir*>(0) = a0;
3691  return n;
3692 }
3702 inline CNode* cPORT_REF( CObstack* heap, CPortDir* a0, Coord_t* loc=NULL )
3703 {
3704  CNode* n = new(heap) CNode( loc, ePORT_REF );
3705  n->Arg<CPortDir*>(0) = a0;
3706  return n;
3707 }
3716 inline CNode* cFWD_REF( CFref* a0, Coord_t* loc=NULL )
3717 {
3718  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eFWD_REF );
3719  n->Arg<CFref*>(0) = a0;
3720  return n;
3721 }
3731 inline CNode* cFWD_REF( CObstack* heap, CFref* a0, Coord_t* loc=NULL )
3732 {
3733  CNode* n = new(heap) CNode( loc, eFWD_REF );
3734  n->Arg<CFref*>(0) = a0;
3735  return n;
3736 }
3745 inline CNode* cGENVAR_REF( CGenvar* a0, Coord_t* loc=NULL )
3746 {
3747  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eGENVAR_REF );
3748  n->Arg<CGenvar*>(0) = a0;
3749  return n;
3750 }
3760 inline CNode* cGENVAR_REF( CObstack* heap, CGenvar* a0, Coord_t* loc=NULL )
3761 {
3762  CNode* n = new(heap) CNode( loc, eGENVAR_REF );
3763  n->Arg<CGenvar*>(0) = a0;
3764  return n;
3765 }
3774 inline CNode* cENUM_REF( CEnum* a0, Coord_t* loc=NULL )
3775 {
3776  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eENUM_REF );
3777  n->Arg<CEnum*>(0) = a0;
3778  return n;
3779 }
3789 inline CNode* cENUM_REF( CObstack* heap, CEnum* a0, Coord_t* loc=NULL )
3790 {
3791  CNode* n = new(heap) CNode( loc, eENUM_REF );
3792  n->Arg<CEnum*>(0) = a0;
3793  return n;
3794 }
3803 inline CNode* cTYPE_REF( CTypedef* a0, Coord_t* loc=NULL )
3804 {
3805  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eTYPE_REF );
3806  n->Arg<CTypedef*>(0) = a0;
3807  return n;
3808 }
3818 inline CNode* cTYPE_REF( CObstack* heap, CTypedef* a0, Coord_t* loc=NULL )
3819 {
3820  CNode* n = new(heap) CNode( loc, eTYPE_REF );
3821  n->Arg<CTypedef*>(0) = a0;
3822  return n;
3823 }
3833 inline CNode* cNET_DECL( CNet* a0, CNode* a1, Coord_t* loc=NULL )
3834 {
3835  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eNET_DECL );
3836  n->Arg<CNet*>(0) = a0;
3837  n->Arg<CNode*>(1) = a1;
3838  return n;
3839 }
3850 inline CNode* cNET_DECL( CObstack* heap, CNet* a0, CNode* a1, Coord_t* loc=NULL )
3851 {
3852  CNode* n = new(heap) CNode( loc, eNET_DECL );
3853  n->Arg<CNet*>(0) = a0;
3854  n->Arg<CNode*>(1) = a1;
3855  return n;
3856 }
3866 inline CNode* cVAR_DECL( CVar* a0, CNode* a1, Coord_t* loc=NULL )
3867 {
3868  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eVAR_DECL );
3869  n->Arg<CVar*>(0) = a0;
3870  n->Arg<CNode*>(1) = a1;
3871  return n;
3872 }
3883 inline CNode* cVAR_DECL( CObstack* heap, CVar* a0, CNode* a1, Coord_t* loc=NULL )
3884 {
3885  CNode* n = new(heap) CNode( loc, eVAR_DECL );
3886  n->Arg<CVar*>(0) = a0;
3887  n->Arg<CNode*>(1) = a1;
3888  return n;
3889 }
3898 inline CNode* cPARAM_DECL( CParam* a0, Coord_t* loc=NULL )
3899 {
3900  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePARAM_DECL );
3901  n->Arg<CParam*>(0) = a0;
3902  return n;
3903 }
3913 inline CNode* cPARAM_DECL( CObstack* heap, CParam* a0, Coord_t* loc=NULL )
3914 {
3915  CNode* n = new(heap) CNode( loc, ePARAM_DECL );
3916  n->Arg<CParam*>(0) = a0;
3917  return n;
3918 }
3927 inline CNode* cSPECPARAM_DECL( CParam* a0, Coord_t* loc=NULL )
3928 {
3929  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eSPECPARAM_DECL );
3930  n->Arg<CParam*>(0) = a0;
3931  return n;
3932 }
3942 inline CNode* cSPECPARAM_DECL( CObstack* heap, CParam* a0, Coord_t* loc=NULL )
3943 {
3944  CNode* n = new(heap) CNode( loc, eSPECPARAM_DECL );
3945  n->Arg<CParam*>(0) = a0;
3946  return n;
3947 }
3956 inline CNode* cPORT_DECL( CPortDir* a0, Coord_t* loc=NULL )
3957 {
3958  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePORT_DECL );
3959  n->Arg<CPortDir*>(0) = a0;
3960  return n;
3961 }
3971 inline CNode* cPORT_DECL( CObstack* heap, CPortDir* a0, Coord_t* loc=NULL )
3972 {
3973  CNode* n = new(heap) CNode( loc, ePORT_DECL );
3974  n->Arg<CPortDir*>(0) = a0;
3975  return n;
3976 }
3985 inline CNode* cGENVAR_DECL( CGenvar* a0, Coord_t* loc=NULL )
3986 {
3987  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eGENVAR_DECL );
3988  n->Arg<CGenvar*>(0) = a0;
3989  return n;
3990 }
4000 inline CNode* cGENVAR_DECL( CObstack* heap, CGenvar* a0, Coord_t* loc=NULL )
4001 {
4002  CNode* n = new(heap) CNode( loc, eGENVAR_DECL );
4003  n->Arg<CGenvar*>(0) = a0;
4004  return n;
4005 }
4014 inline CNode* cTYPEDEF_DECL( CTypedef* a0, Coord_t* loc=NULL )
4015 {
4016  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eTYPEDEF_DECL );
4017  n->Arg<CTypedef*>(0) = a0;
4018  return n;
4019 }
4029 inline CNode* cTYPEDEF_DECL( CObstack* heap, CTypedef* a0, Coord_t* loc=NULL )
4030 {
4031  CNode* n = new(heap) CNode( loc, eTYPEDEF_DECL );
4032  n->Arg<CTypedef*>(0) = a0;
4033  return n;
4034 }
4044 inline CNode* cLIST( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4045 {
4046  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eLIST );
4047  n->Arg<CNode*>(0) = a0;
4048  n->Arg<CNode*>(1) = a1;
4049  return n;
4050 }
4061 inline CNode* cLIST( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4062 {
4063  CNode* n = new(heap) CNode( loc, eLIST );
4064  n->Arg<CNode*>(0) = a0;
4065  n->Arg<CNode*>(1) = a1;
4066  return n;
4067 }
4077 inline CNode* cRANGE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4078 {
4079  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRANGE );
4080  n->Arg<CNode*>(0) = a0;
4081  n->Arg<CNode*>(1) = a1;
4082  return n;
4083 }
4094 inline CNode* cRANGE( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4095 {
4096  CNode* n = new(heap) CNode( loc, eRANGE );
4097  n->Arg<CNode*>(0) = a0;
4098  n->Arg<CNode*>(1) = a1;
4099  return n;
4100 }
4110 inline CNode* cSLICE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4111 {
4112  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eSLICE );
4113  n->Arg<CNode*>(0) = a0;
4114  n->Arg<CNode*>(1) = a1;
4115  return n;
4116 }
4127 inline CNode* cSLICE( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4128 {
4129  CNode* n = new(heap) CNode( loc, eSLICE );
4130  n->Arg<CNode*>(0) = a0;
4131  n->Arg<CNode*>(1) = a1;
4132  return n;
4133 }
4143 inline CNode* cPSLICE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4144 {
4145  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePSLICE );
4146  n->Arg<CNode*>(0) = a0;
4147  n->Arg<CNode*>(1) = a1;
4148  return n;
4149 }
4160 inline CNode* cPSLICE( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4161 {
4162  CNode* n = new(heap) CNode( loc, ePSLICE );
4163  n->Arg<CNode*>(0) = a0;
4164  n->Arg<CNode*>(1) = a1;
4165  return n;
4166 }
4176 inline CNode* cMSLICE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4177 {
4178  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eMSLICE );
4179  n->Arg<CNode*>(0) = a0;
4180  n->Arg<CNode*>(1) = a1;
4181  return n;
4182 }
4193 inline CNode* cMSLICE( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4194 {
4195  CNode* n = new(heap) CNode( loc, eMSLICE );
4196  n->Arg<CNode*>(0) = a0;
4197  n->Arg<CNode*>(1) = a1;
4198  return n;
4199 }
4208 inline CNode* cCVRI( CNode* a0, Coord_t* loc=NULL )
4209 {
4210  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCVRI );
4211  n->Arg<CNode*>(0) = a0;
4212  return n;
4213 }
4223 inline CNode* cCVRI( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
4224 {
4225  CNode* n = new(heap) CNode( loc, eCVRI );
4226  n->Arg<CNode*>(0) = a0;
4227  return n;
4228 }
4237 inline CNode* cCVIR( CNode* a0, Coord_t* loc=NULL )
4238 {
4239  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCVIR );
4240  n->Arg<CNode*>(0) = a0;
4241  return n;
4242 }
4252 inline CNode* cCVIR( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
4253 {
4254  CNode* n = new(heap) CNode( loc, eCVIR );
4255  n->Arg<CNode*>(0) = a0;
4256  return n;
4257 }
4267 inline CNode* cREP( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4268 {
4269  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eREP );
4270  n->Arg<CNode*>(0) = a0;
4271  n->Arg<CNode*>(1) = a1;
4272  return n;
4273 }
4284 inline CNode* cREP( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4285 {
4286  CNode* n = new(heap) CNode( loc, eREP );
4287  n->Arg<CNode*>(0) = a0;
4288  n->Arg<CNode*>(1) = a1;
4289  return n;
4290 }
4300 inline CNode* cCAT( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4301 {
4302  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCAT );
4303  n->Arg<CNode*>(0) = a0;
4304  n->Arg<CNode*>(1) = a1;
4305  return n;
4306 }
4317 inline CNode* cCAT( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4318 {
4319  CNode* n = new(heap) CNode( loc, eCAT );
4320  n->Arg<CNode*>(0) = a0;
4321  n->Arg<CNode*>(1) = a1;
4322  return n;
4323 }
4332 inline CNode* cUCAT( CNode* a0, Coord_t* loc=NULL )
4333 {
4334  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eUCAT );
4335  n->Arg<CNode*>(0) = a0;
4336  return n;
4337 }
4347 inline CNode* cUCAT( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
4348 {
4349  CNode* n = new(heap) CNode( loc, eUCAT );
4350  n->Arg<CNode*>(0) = a0;
4351  return n;
4352 }
4361 inline CNode* cCOM( CNode* a0, Coord_t* loc=NULL )
4362 {
4363  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCOM );
4364  n->Arg<CNode*>(0) = a0;
4365  return n;
4366 }
4376 inline CNode* cCOM( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
4377 {
4378  CNode* n = new(heap) CNode( loc, eCOM );
4379  n->Arg<CNode*>(0) = a0;
4380  return n;
4381 }
4390 inline CNode* cNEG( CNode* a0, Coord_t* loc=NULL )
4391 {
4392  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eNEG );
4393  n->Arg<CNode*>(0) = a0;
4394  return n;
4395 }
4405 inline CNode* cNEG( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
4406 {
4407  CNode* n = new(heap) CNode( loc, eNEG );
4408  n->Arg<CNode*>(0) = a0;
4409  return n;
4410 }
4419 inline CNode* cPLUS( CNode* a0, Coord_t* loc=NULL )
4420 {
4421  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePLUS );
4422  n->Arg<CNode*>(0) = a0;
4423  return n;
4424 }
4434 inline CNode* cPLUS( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
4435 {
4436  CNode* n = new(heap) CNode( loc, ePLUS );
4437  n->Arg<CNode*>(0) = a0;
4438  return n;
4439 }
4448 inline CNode* cNOT( CNode* a0, Coord_t* loc=NULL )
4449 {
4450  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eNOT );
4451  n->Arg<CNode*>(0) = a0;
4452  return n;
4453 }
4463 inline CNode* cNOT( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
4464 {
4465  CNode* n = new(heap) CNode( loc, eNOT );
4466  n->Arg<CNode*>(0) = a0;
4467  return n;
4468 }
4478 inline CNode* cGT( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4479 {
4480  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eGT );
4481  n->Arg<CNode*>(0) = a0;
4482  n->Arg<CNode*>(1) = a1;
4483  return n;
4484 }
4495 inline CNode* cGT( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4496 {
4497  CNode* n = new(heap) CNode( loc, eGT );
4498  n->Arg<CNode*>(0) = a0;
4499  n->Arg<CNode*>(1) = a1;
4500  return n;
4501 }
4511 inline CNode* cGE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4512 {
4513  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eGE );
4514  n->Arg<CNode*>(0) = a0;
4515  n->Arg<CNode*>(1) = a1;
4516  return n;
4517 }
4528 inline CNode* cGE( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4529 {
4530  CNode* n = new(heap) CNode( loc, eGE );
4531  n->Arg<CNode*>(0) = a0;
4532  n->Arg<CNode*>(1) = a1;
4533  return n;
4534 }
4544 inline CNode* cLT( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4545 {
4546  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eLT );
4547  n->Arg<CNode*>(0) = a0;
4548  n->Arg<CNode*>(1) = a1;
4549  return n;
4550 }
4561 inline CNode* cLT( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4562 {
4563  CNode* n = new(heap) CNode( loc, eLT );
4564  n->Arg<CNode*>(0) = a0;
4565  n->Arg<CNode*>(1) = a1;
4566  return n;
4567 }
4577 inline CNode* cLE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4578 {
4579  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eLE );
4580  n->Arg<CNode*>(0) = a0;
4581  n->Arg<CNode*>(1) = a1;
4582  return n;
4583 }
4594 inline CNode* cLE( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4595 {
4596  CNode* n = new(heap) CNode( loc, eLE );
4597  n->Arg<CNode*>(0) = a0;
4598  n->Arg<CNode*>(1) = a1;
4599  return n;
4600 }
4610 inline CNode* cLAND( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4611 {
4612  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eLAND );
4613  n->Arg<CNode*>(0) = a0;
4614  n->Arg<CNode*>(1) = a1;
4615  return n;
4616 }
4627 inline CNode* cLAND( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4628 {
4629  CNode* n = new(heap) CNode( loc, eLAND );
4630  n->Arg<CNode*>(0) = a0;
4631  n->Arg<CNode*>(1) = a1;
4632  return n;
4633 }
4643 inline CNode* cLOR( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4644 {
4645  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eLOR );
4646  n->Arg<CNode*>(0) = a0;
4647  n->Arg<CNode*>(1) = a1;
4648  return n;
4649 }
4660 inline CNode* cLOR( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4661 {
4662  CNode* n = new(heap) CNode( loc, eLOR );
4663  n->Arg<CNode*>(0) = a0;
4664  n->Arg<CNode*>(1) = a1;
4665  return n;
4666 }
4676 inline CNode* cCEQ( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4677 {
4678  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCEQ );
4679  n->Arg<CNode*>(0) = a0;
4680  n->Arg<CNode*>(1) = a1;
4681  return n;
4682 }
4693 inline CNode* cCEQ( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4694 {
4695  CNode* n = new(heap) CNode( loc, eCEQ );
4696  n->Arg<CNode*>(0) = a0;
4697  n->Arg<CNode*>(1) = a1;
4698  return n;
4699 }
4709 inline CNode* cCNE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4710 {
4711  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCNE );
4712  n->Arg<CNode*>(0) = a0;
4713  n->Arg<CNode*>(1) = a1;
4714  return n;
4715 }
4726 inline CNode* cCNE( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4727 {
4728  CNode* n = new(heap) CNode( loc, eCNE );
4729  n->Arg<CNode*>(0) = a0;
4730  n->Arg<CNode*>(1) = a1;
4731  return n;
4732 }
4742 inline CNode* cEQ( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4743 {
4744  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eEQ );
4745  n->Arg<CNode*>(0) = a0;
4746  n->Arg<CNode*>(1) = a1;
4747  return n;
4748 }
4759 inline CNode* cEQ( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4760 {
4761  CNode* n = new(heap) CNode( loc, eEQ );
4762  n->Arg<CNode*>(0) = a0;
4763  n->Arg<CNode*>(1) = a1;
4764  return n;
4765 }
4775 inline CNode* cNE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4776 {
4777  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eNE );
4778  n->Arg<CNode*>(0) = a0;
4779  n->Arg<CNode*>(1) = a1;
4780  return n;
4781 }
4792 inline CNode* cNE( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4793 {
4794  CNode* n = new(heap) CNode( loc, eNE );
4795  n->Arg<CNode*>(0) = a0;
4796  n->Arg<CNode*>(1) = a1;
4797  return n;
4798 }
4807 inline CNode* cRAND( CNode* a0, Coord_t* loc=NULL )
4808 {
4809  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRAND );
4810  n->Arg<CNode*>(0) = a0;
4811  return n;
4812 }
4822 inline CNode* cRAND( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
4823 {
4824  CNode* n = new(heap) CNode( loc, eRAND );
4825  n->Arg<CNode*>(0) = a0;
4826  return n;
4827 }
4836 inline CNode* cRNAND( CNode* a0, Coord_t* loc=NULL )
4837 {
4838  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRNAND );
4839  n->Arg<CNode*>(0) = a0;
4840  return n;
4841 }
4851 inline CNode* cRNAND( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
4852 {
4853  CNode* n = new(heap) CNode( loc, eRNAND );
4854  n->Arg<CNode*>(0) = a0;
4855  return n;
4856 }
4865 inline CNode* cROR( CNode* a0, Coord_t* loc=NULL )
4866 {
4867  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eROR );
4868  n->Arg<CNode*>(0) = a0;
4869  return n;
4870 }
4880 inline CNode* cROR( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
4881 {
4882  CNode* n = new(heap) CNode( loc, eROR );
4883  n->Arg<CNode*>(0) = a0;
4884  return n;
4885 }
4894 inline CNode* cRNOR( CNode* a0, Coord_t* loc=NULL )
4895 {
4896  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRNOR );
4897  n->Arg<CNode*>(0) = a0;
4898  return n;
4899 }
4909 inline CNode* cRNOR( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
4910 {
4911  CNode* n = new(heap) CNode( loc, eRNOR );
4912  n->Arg<CNode*>(0) = a0;
4913  return n;
4914 }
4923 inline CNode* cRXOR( CNode* a0, Coord_t* loc=NULL )
4924 {
4925  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRXOR );
4926  n->Arg<CNode*>(0) = a0;
4927  return n;
4928 }
4938 inline CNode* cRXOR( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
4939 {
4940  CNode* n = new(heap) CNode( loc, eRXOR );
4941  n->Arg<CNode*>(0) = a0;
4942  return n;
4943 }
4952 inline CNode* cRXNOR( CNode* a0, Coord_t* loc=NULL )
4953 {
4954  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRXNOR );
4955  n->Arg<CNode*>(0) = a0;
4956  return n;
4957 }
4967 inline CNode* cRXNOR( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
4968 {
4969  CNode* n = new(heap) CNode( loc, eRXNOR );
4970  n->Arg<CNode*>(0) = a0;
4971  return n;
4972 }
4983 inline CNode* cHOOK( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
4984 {
4985  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eHOOK );
4986  n->Arg<CNode*>(0) = a0;
4987  n->Arg<CNode*>(1) = a1;
4988  n->Arg<CNode*>(2) = a2;
4989  return n;
4990 }
5002 inline CNode* cHOOK( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5003 {
5004  CNode* n = new(heap) CNode( loc, eHOOK );
5005  n->Arg<CNode*>(0) = a0;
5006  n->Arg<CNode*>(1) = a1;
5007  n->Arg<CNode*>(2) = a2;
5008  return n;
5009 }
5018 inline CNode* cINIT( CNode* a0, Coord_t* loc=NULL )
5019 {
5020  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eINIT );
5021  n->Arg<CNode*>(0) = a0;
5022  return n;
5023 }
5033 inline CNode* cINIT( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
5034 {
5035  CNode* n = new(heap) CNode( loc, eINIT );
5036  n->Arg<CNode*>(0) = a0;
5037  return n;
5038 }
5047 inline CNode* cALWAYS( CNode* a0, Coord_t* loc=NULL )
5048 {
5049  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eALWAYS );
5050  n->Arg<CNode*>(0) = a0;
5051  return n;
5052 }
5062 inline CNode* cALWAYS( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
5063 {
5064  CNode* n = new(heap) CNode( loc, eALWAYS );
5065  n->Arg<CNode*>(0) = a0;
5066  return n;
5067 }
5076 inline CNode* cALWAYS_LATCH( CNode* a0, Coord_t* loc=NULL )
5077 {
5078  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eALWAYS_LATCH );
5079  n->Arg<CNode*>(0) = a0;
5080  return n;
5081 }
5091 inline CNode* cALWAYS_LATCH( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
5092 {
5093  CNode* n = new(heap) CNode( loc, eALWAYS_LATCH );
5094  n->Arg<CNode*>(0) = a0;
5095  return n;
5096 }
5105 inline CNode* cALWAYS_FF( CNode* a0, Coord_t* loc=NULL )
5106 {
5107  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eALWAYS_FF );
5108  n->Arg<CNode*>(0) = a0;
5109  return n;
5110 }
5120 inline CNode* cALWAYS_FF( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
5121 {
5122  CNode* n = new(heap) CNode( loc, eALWAYS_FF );
5123  n->Arg<CNode*>(0) = a0;
5124  return n;
5125 }
5134 inline CNode* cALWAYS_COMB( CNode* a0, Coord_t* loc=NULL )
5135 {
5136  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eALWAYS_COMB );
5137  n->Arg<CNode*>(0) = a0;
5138  return n;
5139 }
5149 inline CNode* cALWAYS_COMB( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
5150 {
5151  CNode* n = new(heap) CNode( loc, eALWAYS_COMB );
5152  n->Arg<CNode*>(0) = a0;
5153  return n;
5154 }
5164 inline CNode* cEVENT( CNode* a0, CNode* a1, Coord_t* loc=NULL )
5165 {
5166  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eEVENT );
5167  n->Arg<CNode*>(0) = a0;
5168  n->Arg<CNode*>(1) = a1;
5169  return n;
5170 }
5181 inline CNode* cEVENT( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
5182 {
5183  CNode* n = new(heap) CNode( loc, eEVENT );
5184  n->Arg<CNode*>(0) = a0;
5185  n->Arg<CNode*>(1) = a1;
5186  return n;
5187 }
5197 inline CNode* cBLOCK_REF( CBlock* a0, CNode* a1, Coord_t* loc=NULL )
5198 {
5199  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eBLOCK_REF );
5200  n->Arg<CBlock*>(0) = a0;
5201  n->Arg<CNode*>(1) = a1;
5202  return n;
5203 }
5214 inline CNode* cBLOCK_REF( CObstack* heap, CBlock* a0, CNode* a1, Coord_t* loc=NULL )
5215 {
5216  CNode* n = new(heap) CNode( loc, eBLOCK_REF );
5217  n->Arg<CBlock*>(0) = a0;
5218  n->Arg<CNode*>(1) = a1;
5219  return n;
5220 }
5230 inline CNode* cSPECIFY_REF( CSpecify* a0, CNode* a1, Coord_t* loc=NULL )
5231 {
5232  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eSPECIFY_REF );
5233  n->Arg<CSpecify*>(0) = a0;
5234  n->Arg<CNode*>(1) = a1;
5235  return n;
5236 }
5247 inline CNode* cSPECIFY_REF( CObstack* heap, CSpecify* a0, CNode* a1, Coord_t* loc=NULL )
5248 {
5249  CNode* n = new(heap) CNode( loc, eSPECIFY_REF );
5250  n->Arg<CSpecify*>(0) = a0;
5251  n->Arg<CNode*>(1) = a1;
5252  return n;
5253 }
5264 inline CNode* cASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5265 {
5266  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eASSIGN );
5267  n->Arg<CNode*>(0) = a0;
5268  n->Arg<CNode*>(1) = a1;
5269  n->Arg<CNode*>(2) = a2;
5270  return n;
5271 }
5283 inline CNode* cASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5284 {
5285  CNode* n = new(heap) CNode( loc, eASSIGN );
5286  n->Arg<CNode*>(0) = a0;
5287  n->Arg<CNode*>(1) = a1;
5288  n->Arg<CNode*>(2) = a2;
5289  return n;
5290 }
5301 inline CNode* cGASSIGN( bool a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5302 {
5303  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eGASSIGN );
5304  n->Arg<bool>(0) = a0;
5305  n->Arg<CNode*>(1) = a1;
5306  n->Arg<CNode*>(2) = a2;
5307  return n;
5308 }
5320 inline CNode* cGASSIGN( CObstack* heap, bool a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5321 {
5322  CNode* n = new(heap) CNode( loc, eGASSIGN );
5323  n->Arg<bool>(0) = a0;
5324  n->Arg<CNode*>(1) = a1;
5325  n->Arg<CNode*>(2) = a2;
5326  return n;
5327 }
5338 inline CNode* cADD_ASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5339 {
5340  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eADD_ASSIGN );
5341  n->Arg<CNode*>(0) = a0;
5342  n->Arg<CNode*>(1) = a1;
5343  n->Arg<CNode*>(2) = a2;
5344  return n;
5345 }
5357 inline CNode* cADD_ASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5358 {
5359  CNode* n = new(heap) CNode( loc, eADD_ASSIGN );
5360  n->Arg<CNode*>(0) = a0;
5361  n->Arg<CNode*>(1) = a1;
5362  n->Arg<CNode*>(2) = a2;
5363  return n;
5364 }
5375 inline CNode* cSUB_ASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5376 {
5377  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eSUB_ASSIGN );
5378  n->Arg<CNode*>(0) = a0;
5379  n->Arg<CNode*>(1) = a1;
5380  n->Arg<CNode*>(2) = a2;
5381  return n;
5382 }
5394 inline CNode* cSUB_ASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5395 {
5396  CNode* n = new(heap) CNode( loc, eSUB_ASSIGN );
5397  n->Arg<CNode*>(0) = a0;
5398  n->Arg<CNode*>(1) = a1;
5399  n->Arg<CNode*>(2) = a2;
5400  return n;
5401 }
5412 inline CNode* cMUL_ASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5413 {
5414  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eMUL_ASSIGN );
5415  n->Arg<CNode*>(0) = a0;
5416  n->Arg<CNode*>(1) = a1;
5417  n->Arg<CNode*>(2) = a2;
5418  return n;
5419 }
5431 inline CNode* cMUL_ASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5432 {
5433  CNode* n = new(heap) CNode( loc, eMUL_ASSIGN );
5434  n->Arg<CNode*>(0) = a0;
5435  n->Arg<CNode*>(1) = a1;
5436  n->Arg<CNode*>(2) = a2;
5437  return n;
5438 }
5449 inline CNode* cDIV_ASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5450 {
5451  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eDIV_ASSIGN );
5452  n->Arg<CNode*>(0) = a0;
5453  n->Arg<CNode*>(1) = a1;
5454  n->Arg<CNode*>(2) = a2;
5455  return n;
5456 }
5468 inline CNode* cDIV_ASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5469 {
5470  CNode* n = new(heap) CNode( loc, eDIV_ASSIGN );
5471  n->Arg<CNode*>(0) = a0;
5472  n->Arg<CNode*>(1) = a1;
5473  n->Arg<CNode*>(2) = a2;
5474  return n;
5475 }
5486 inline CNode* cMOD_ASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5487 {
5488  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eMOD_ASSIGN );
5489  n->Arg<CNode*>(0) = a0;
5490  n->Arg<CNode*>(1) = a1;
5491  n->Arg<CNode*>(2) = a2;
5492  return n;
5493 }
5505 inline CNode* cMOD_ASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5506 {
5507  CNode* n = new(heap) CNode( loc, eMOD_ASSIGN );
5508  n->Arg<CNode*>(0) = a0;
5509  n->Arg<CNode*>(1) = a1;
5510  n->Arg<CNode*>(2) = a2;
5511  return n;
5512 }
5523 inline CNode* cAND_ASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5524 {
5525  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eAND_ASSIGN );
5526  n->Arg<CNode*>(0) = a0;
5527  n->Arg<CNode*>(1) = a1;
5528  n->Arg<CNode*>(2) = a2;
5529  return n;
5530 }
5542 inline CNode* cAND_ASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5543 {
5544  CNode* n = new(heap) CNode( loc, eAND_ASSIGN );
5545  n->Arg<CNode*>(0) = a0;
5546  n->Arg<CNode*>(1) = a1;
5547  n->Arg<CNode*>(2) = a2;
5548  return n;
5549 }
5560 inline CNode* cOR_ASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5561 {
5562  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eOR_ASSIGN );
5563  n->Arg<CNode*>(0) = a0;
5564  n->Arg<CNode*>(1) = a1;
5565  n->Arg<CNode*>(2) = a2;
5566  return n;
5567 }
5579 inline CNode* cOR_ASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5580 {
5581  CNode* n = new(heap) CNode( loc, eOR_ASSIGN );
5582  n->Arg<CNode*>(0) = a0;
5583  n->Arg<CNode*>(1) = a1;
5584  n->Arg<CNode*>(2) = a2;
5585  return n;
5586 }
5597 inline CNode* cXOR_ASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5598 {
5599  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eXOR_ASSIGN );
5600  n->Arg<CNode*>(0) = a0;
5601  n->Arg<CNode*>(1) = a1;
5602  n->Arg<CNode*>(2) = a2;
5603  return n;
5604 }
5616 inline CNode* cXOR_ASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5617 {
5618  CNode* n = new(heap) CNode( loc, eXOR_ASSIGN );
5619  n->Arg<CNode*>(0) = a0;
5620  n->Arg<CNode*>(1) = a1;
5621  n->Arg<CNode*>(2) = a2;
5622  return n;
5623 }
5634 inline CNode* cLSH_ASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5635 {
5636  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eLSH_ASSIGN );
5637  n->Arg<CNode*>(0) = a0;
5638  n->Arg<CNode*>(1) = a1;
5639  n->Arg<CNode*>(2) = a2;
5640  return n;
5641 }
5653 inline CNode* cLSH_ASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5654 {
5655  CNode* n = new(heap) CNode( loc, eLSH_ASSIGN );
5656  n->Arg<CNode*>(0) = a0;
5657  n->Arg<CNode*>(1) = a1;
5658  n->Arg<CNode*>(2) = a2;
5659  return n;
5660 }
5671 inline CNode* cRSH_ASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5672 {
5673  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRSH_ASSIGN );
5674  n->Arg<CNode*>(0) = a0;
5675  n->Arg<CNode*>(1) = a1;
5676  n->Arg<CNode*>(2) = a2;
5677  return n;
5678 }
5690 inline CNode* cRSH_ASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5691 {
5692  CNode* n = new(heap) CNode( loc, eRSH_ASSIGN );
5693  n->Arg<CNode*>(0) = a0;
5694  n->Arg<CNode*>(1) = a1;
5695  n->Arg<CNode*>(2) = a2;
5696  return n;
5697 }
5708 inline CNode* cLSHA_ASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5709 {
5710  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eLSHA_ASSIGN );
5711  n->Arg<CNode*>(0) = a0;
5712  n->Arg<CNode*>(1) = a1;
5713  n->Arg<CNode*>(2) = a2;
5714  return n;
5715 }
5727 inline CNode* cLSHA_ASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5728 {
5729  CNode* n = new(heap) CNode( loc, eLSHA_ASSIGN );
5730  n->Arg<CNode*>(0) = a0;
5731  n->Arg<CNode*>(1) = a1;
5732  n->Arg<CNode*>(2) = a2;
5733  return n;
5734 }
5745 inline CNode* cRSHA_ASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5746 {
5747  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRSHA_ASSIGN );
5748  n->Arg<CNode*>(0) = a0;
5749  n->Arg<CNode*>(1) = a1;
5750  n->Arg<CNode*>(2) = a2;
5751  return n;
5752 }
5764 inline CNode* cRSHA_ASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5765 {
5766  CNode* n = new(heap) CNode( loc, eRSHA_ASSIGN );
5767  n->Arg<CNode*>(0) = a0;
5768  n->Arg<CNode*>(1) = a1;
5769  n->Arg<CNode*>(2) = a2;
5770  return n;
5771 }
5781 inline CNode* cFORCE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
5782 {
5783  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eFORCE );
5784  n->Arg<CNode*>(0) = a0;
5785  n->Arg<CNode*>(1) = a1;
5786  return n;
5787 }
5798 inline CNode* cFORCE( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
5799 {
5800  CNode* n = new(heap) CNode( loc, eFORCE );
5801  n->Arg<CNode*>(0) = a0;
5802  n->Arg<CNode*>(1) = a1;
5803  return n;
5804 }
5813 inline CNode* cRELEASE( CNode* a0, Coord_t* loc=NULL )
5814 {
5815  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRELEASE );
5816  n->Arg<CNode*>(0) = a0;
5817  return n;
5818 }
5828 inline CNode* cRELEASE( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
5829 {
5830  CNode* n = new(heap) CNode( loc, eRELEASE );
5831  n->Arg<CNode*>(0) = a0;
5832  return n;
5833 }
5844 inline CNode* cNBASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5845 {
5846  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eNBASSIGN );
5847  n->Arg<CNode*>(0) = a0;
5848  n->Arg<CNode*>(1) = a1;
5849  n->Arg<CNode*>(2) = a2;
5850  return n;
5851 }
5863 inline CNode* cNBASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5864 {
5865  CNode* n = new(heap) CNode( loc, eNBASSIGN );
5866  n->Arg<CNode*>(0) = a0;
5867  n->Arg<CNode*>(1) = a1;
5868  n->Arg<CNode*>(2) = a2;
5869  return n;
5870 }
5879 inline CNode* cPOSEDGE( CNode* a0, Coord_t* loc=NULL )
5880 {
5881  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePOSEDGE );
5882  n->Arg<CNode*>(0) = a0;
5883  return n;
5884 }
5894 inline CNode* cPOSEDGE( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
5895 {
5896  CNode* n = new(heap) CNode( loc, ePOSEDGE );
5897  n->Arg<CNode*>(0) = a0;
5898  return n;
5899 }
5908 inline CNode* cNEGEDGE( CNode* a0, Coord_t* loc=NULL )
5909 {
5910  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eNEGEDGE );
5911  n->Arg<CNode*>(0) = a0;
5912  return n;
5913 }
5923 inline CNode* cNEGEDGE( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
5924 {
5925  CNode* n = new(heap) CNode( loc, eNEGEDGE );
5926  n->Arg<CNode*>(0) = a0;
5927  return n;
5928 }
5938 inline CNode* cEDGE( CNode* a0, Edge_t a1, Coord_t* loc=NULL )
5939 {
5940  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eEDGE );
5941  n->Arg<CNode*>(0) = a0;
5942  n->Arg<Edge_t>(1) = a1;
5943  return n;
5944 }
5955 inline CNode* cEDGE( CObstack* heap, CNode* a0, Edge_t a1, Coord_t* loc=NULL )
5956 {
5957  CNode* n = new(heap) CNode( loc, eEDGE );
5958  n->Arg<CNode*>(0) = a0;
5959  n->Arg<Edge_t>(1) = a1;
5960  return n;
5961 }
5971 inline CNode* cEVOR( CNode* a0, CNode* a1, Coord_t* loc=NULL )
5972 {
5973  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eEVOR );
5974  n->Arg<CNode*>(0) = a0;
5975  n->Arg<CNode*>(1) = a1;
5976  return n;
5977 }
5988 inline CNode* cEVOR( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
5989 {
5990  CNode* n = new(heap) CNode( loc, eEVOR );
5991  n->Arg<CNode*>(0) = a0;
5992  n->Arg<CNode*>(1) = a1;
5993  return n;
5994 }
6004 inline CNode* cDELAY( CNode* a0, CNode* a1, Coord_t* loc=NULL )
6005 {
6006  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eDELAY );
6007  n->Arg<CNode*>(0) = a0;
6008  n->Arg<CNode*>(1) = a1;
6009  return n;
6010 }
6021 inline CNode* cDELAY( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
6022 {
6023  CNode* n = new(heap) CNode( loc, eDELAY );
6024  n->Arg<CNode*>(0) = a0;
6025  n->Arg<CNode*>(1) = a1;
6026  return n;
6027 }
6038 inline CNode* cMTM( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
6039 {
6040  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eMTM );
6041  n->Arg<CNode*>(0) = a0;
6042  n->Arg<CNode*>(1) = a1;
6043  n->Arg<CNode*>(2) = a2;
6044  return n;
6045 }
6057 inline CNode* cMTM( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
6058 {
6059  CNode* n = new(heap) CNode( loc, eMTM );
6060  n->Arg<CNode*>(0) = a0;
6061  n->Arg<CNode*>(1) = a1;
6062  n->Arg<CNode*>(2) = a2;
6063  return n;
6064 }
6075 inline CNode* cIF( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
6076 {
6077  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eIF );
6078  n->Arg<CNode*>(0) = a0;
6079  n->Arg<CNode*>(1) = a1;
6080  n->Arg<CNode*>(2) = a2;
6081  return n;
6082 }
6094 inline CNode* cIF( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
6095 {
6096  CNode* n = new(heap) CNode( loc, eIF );
6097  n->Arg<CNode*>(0) = a0;
6098  n->Arg<CNode*>(1) = a1;
6099  n->Arg<CNode*>(2) = a2;
6100  return n;
6101 }
6110 inline CNode* cFOREVER( CNode* a0, Coord_t* loc=NULL )
6111 {
6112  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eFOREVER );
6113  n->Arg<CNode*>(0) = a0;
6114  return n;
6115 }
6125 inline CNode* cFOREVER( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
6126 {
6127  CNode* n = new(heap) CNode( loc, eFOREVER );
6128  n->Arg<CNode*>(0) = a0;
6129  return n;
6130 }
6140 inline CNode* cREPEAT( CNode* a0, CNode* a1, Coord_t* loc=NULL )
6141 {
6142  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eREPEAT );
6143  n->Arg<CNode*>(0) = a0;
6144  n->Arg<CNode*>(1) = a1;
6145  return n;
6146 }
6157 inline CNode* cREPEAT( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
6158 {
6159  CNode* n = new(heap) CNode( loc, eREPEAT );
6160  n->Arg<CNode*>(0) = a0;
6161  n->Arg<CNode*>(1) = a1;
6162  return n;
6163 }
6173 inline CNode* cWHILE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
6174 {
6175  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eWHILE );
6176  n->Arg<CNode*>(0) = a0;
6177  n->Arg<CNode*>(1) = a1;
6178  return n;
6179 }
6190 inline CNode* cWHILE( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
6191 {
6192  CNode* n = new(heap) CNode( loc, eWHILE );
6193  n->Arg<CNode*>(0) = a0;
6194  n->Arg<CNode*>(1) = a1;
6195  return n;
6196 }
6206 inline CNode* cWAIT( CNode* a0, CNode* a1, Coord_t* loc=NULL )
6207 {
6208  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eWAIT );
6209  n->Arg<CNode*>(0) = a0;
6210  n->Arg<CNode*>(1) = a1;
6211  return n;
6212 }
6223 inline CNode* cWAIT( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
6224 {
6225  CNode* n = new(heap) CNode( loc, eWAIT );
6226  n->Arg<CNode*>(0) = a0;
6227  n->Arg<CNode*>(1) = a1;
6228  return n;
6229 }
6241 inline CNode* cFOR( CNode* a0, CNode* a1, CNode* a2, CNode* a3, Coord_t* loc=NULL )
6242 {
6243  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eFOR );
6244  n->Arg<CNode*>(0) = a0;
6245  n->Arg<CNode*>(1) = a1;
6246  n->Arg<CNode*>(2) = a2;
6247  n->Arg<CNode*>(3) = a3;
6248  return n;
6249 }
6262 inline CNode* cFOR( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, CNode* a3, Coord_t* loc=NULL )
6263 {
6264  CNode* n = new(heap) CNode( loc, eFOR );
6265  n->Arg<CNode*>(0) = a0;
6266  n->Arg<CNode*>(1) = a1;
6267  n->Arg<CNode*>(2) = a2;
6268  n->Arg<CNode*>(3) = a3;
6269  return n;
6270 }
6280 inline CNode* cCASE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
6281 {
6282  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCASE );
6283  n->Arg<CNode*>(0) = a0;
6284  n->Arg<CNode*>(1) = a1;
6285  return n;
6286 }
6297 inline CNode* cCASE( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
6298 {
6299  CNode* n = new(heap) CNode( loc, eCASE );
6300  n->Arg<CNode*>(0) = a0;
6301  n->Arg<CNode*>(1) = a1;
6302  return n;
6303 }
6313 inline CNode* cCASEX( CNode* a0, CNode* a1, Coord_t* loc=NULL )
6314 {
6315  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCASEX );
6316  n->Arg<CNode*>(0) = a0;
6317  n->Arg<CNode*>(1) = a1;
6318  return n;
6319 }
6330 inline CNode* cCASEX( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
6331 {
6332  CNode* n = new(heap) CNode( loc, eCASEX );
6333  n->Arg<CNode*>(0) = a0;
6334  n->Arg<CNode*>(1) = a1;
6335  return n;
6336 }
6346 inline CNode* cCASEZ( CNode* a0, CNode* a1, Coord_t* loc=NULL )
6347 {
6348  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCASEZ );
6349  n->Arg<CNode*>(0) = a0;
6350  n->Arg<CNode*>(1) = a1;
6351  return n;
6352 }
6363 inline CNode* cCASEZ( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
6364 {
6365  CNode* n = new(heap) CNode( loc, eCASEZ );
6366  n->Arg<CNode*>(0) = a0;
6367  n->Arg<CNode*>(1) = a1;
6368  return n;
6369 }
6379 inline CNode* cCASEITEM( CNode* a0, CNode* a1, Coord_t* loc=NULL )
6380 {
6381  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCASEITEM );
6382  n->Arg<CNode*>(0) = a0;
6383  n->Arg<CNode*>(1) = a1;
6384  return n;
6385 }
6396 inline CNode* cCASEITEM( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
6397 {
6398  CNode* n = new(heap) CNode( loc, eCASEITEM );
6399  n->Arg<CNode*>(0) = a0;
6400  n->Arg<CNode*>(1) = a1;
6401  return n;
6402 }
6414 inline CNode* cCASSIGN( StrengthPair_t* a0, CNode* a1, CNode* a2, CNode* a3, Coord_t* loc=NULL )
6415 {
6416  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCASSIGN );
6417  n->Arg<StrengthPair_t*>(0) = a0;
6418  n->Arg<CNode*>(1) = a1;
6419  n->Arg<CNode*>(2) = a2;
6420  n->Arg<CNode*>(3) = a3;
6421  return n;
6422 }
6435 inline CNode* cCASSIGN( CObstack* heap, StrengthPair_t* a0, CNode* a1, CNode* a2, CNode* a3, Coord_t* loc=NULL )
6436 {
6437  CNode* n = new(heap) CNode( loc, eCASSIGN );
6438  n->Arg<StrengthPair_t*>(0) = a0;
6439  n->Arg<CNode*>(1) = a1;
6440  n->Arg<CNode*>(2) = a2;
6441  n->Arg<CNode*>(3) = a3;
6442  return n;
6443 }
6453 inline CNode* cARG( CSymbol* a0, CNode* a1, Coord_t* loc=NULL )
6454 {
6455  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eARG );
6456  n->Arg<CSymbol*>(0) = a0;
6457  n->Arg<CNode*>(1) = a1;
6458  return n;
6459 }
6470 inline CNode* cARG( CObstack* heap, CSymbol* a0, CNode* a1, Coord_t* loc=NULL )
6471 {
6472  CNode* n = new(heap) CNode( loc, eARG );
6473  n->Arg<CSymbol*>(0) = a0;
6474  n->Arg<CNode*>(1) = a1;
6475  return n;
6476 }
6485 inline CNode* cIMPORT( CSymbol* a0, Coord_t* loc=NULL )
6486 {
6487  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eIMPORT );
6488  n->Arg<CSymbol*>(0) = a0;
6489  return n;
6490 }
6500 inline CNode* cIMPORT( CObstack* heap, CSymbol* a0, Coord_t* loc=NULL )
6501 {
6502  CNode* n = new(heap) CNode( loc, eIMPORT );
6503  n->Arg<CSymbol*>(0) = a0;
6504  return n;
6505 }
6514 inline CNode* cFUNCTION_DEF( CFunction* a0, Coord_t* loc=NULL )
6515 {
6516  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eFUNCTION_DEF );
6517  n->Arg<CFunction*>(0) = a0;
6518  return n;
6519 }
6529 inline CNode* cFUNCTION_DEF( CObstack* heap, CFunction* a0, Coord_t* loc=NULL )
6530 {
6531  CNode* n = new(heap) CNode( loc, eFUNCTION_DEF );
6532  n->Arg<CFunction*>(0) = a0;
6533  return n;
6534 }
6543 inline CNode* cMODULE_DEF( CModule* a0, Coord_t* loc=NULL )
6544 {
6545  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eMODULE_DEF );
6546  n->Arg<CModule*>(0) = a0;
6547  return n;
6548 }
6558 inline CNode* cMODULE_DEF( CObstack* heap, CModule* a0, Coord_t* loc=NULL )
6559 {
6560  CNode* n = new(heap) CNode( loc, eMODULE_DEF );
6561  n->Arg<CModule*>(0) = a0;
6562  return n;
6563 }
6572 inline CNode* cPACKAGE_DEF( CPackage* a0, Coord_t* loc=NULL )
6573 {
6574  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePACKAGE_DEF );
6575  n->Arg<CPackage*>(0) = a0;
6576  return n;
6577 }
6587 inline CNode* cPACKAGE_DEF( CObstack* heap, CPackage* a0, Coord_t* loc=NULL )
6588 {
6589  CNode* n = new(heap) CNode( loc, ePACKAGE_DEF );
6590  n->Arg<CPackage*>(0) = a0;
6591  return n;
6592 }
6602 inline CNode* cREPEAT_CONTROL( CNode* a0, CNode* a1, Coord_t* loc=NULL )
6603 {
6604  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eREPEAT_CONTROL );
6605  n->Arg<CNode*>(0) = a0;
6606  n->Arg<CNode*>(1) = a1;
6607  return n;
6608 }
6619 inline CNode* cREPEAT_CONTROL( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
6620 {
6621  CNode* n = new(heap) CNode( loc, eREPEAT_CONTROL );
6622  n->Arg<CNode*>(0) = a0;
6623  n->Arg<CNode*>(1) = a1;
6624  return n;
6625 }
6634 inline CNode* cDELAY_CONTROL( CNode* a0, Coord_t* loc=NULL )
6635 {
6636  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eDELAY_CONTROL );
6637  n->Arg<CNode*>(0) = a0;
6638  return n;
6639 }
6649 inline CNode* cDELAY_CONTROL( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
6650 {
6651  CNode* n = new(heap) CNode( loc, eDELAY_CONTROL );
6652  n->Arg<CNode*>(0) = a0;
6653  return n;
6654 }
6663 inline CNode* cEVENT_CONTROL( CNode* a0, Coord_t* loc=NULL )
6664 {
6665  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eEVENT_CONTROL );
6666  n->Arg<CNode*>(0) = a0;
6667  return n;
6668 }
6678 inline CNode* cEVENT_CONTROL( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
6679 {
6680  CNode* n = new(heap) CNode( loc, eEVENT_CONTROL );
6681  n->Arg<CNode*>(0) = a0;
6682  return n;
6683 }
6692 inline CNode* cEXTERNAL_REF( CSymbol* a0, Coord_t* loc=NULL )
6693 {
6694  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eEXTERNAL_REF );
6695  n->Arg<CSymbol*>(0) = a0;
6696  return n;
6697 }
6707 inline CNode* cEXTERNAL_REF( CObstack* heap, CSymbol* a0, Coord_t* loc=NULL )
6708 {
6709  CNode* n = new(heap) CNode( loc, eEXTERNAL_REF );
6710  n->Arg<CSymbol*>(0) = a0;
6711  return n;
6712 }
6721 inline CNode* cPORT_DEF( CPort* a0, Coord_t* loc=NULL )
6722 {
6723  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePORT_DEF );
6724  n->Arg<CPort*>(0) = a0;
6725  return n;
6726 }
6736 inline CNode* cPORT_DEF( CObstack* heap, CPort* a0, Coord_t* loc=NULL )
6737 {
6738  CNode* n = new(heap) CNode( loc, ePORT_DEF );
6739  n->Arg<CPort*>(0) = a0;
6740  return n;
6741 }
6751 inline CNode* cDEFPARAM( CNode* a0, CNode* a1, Coord_t* loc=NULL )
6752 {
6753  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eDEFPARAM );
6754  n->Arg<CNode*>(0) = a0;
6755  n->Arg<CNode*>(1) = a1;
6756  return n;
6757 }
6768 inline CNode* cDEFPARAM( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
6769 {
6770  CNode* n = new(heap) CNode( loc, eDEFPARAM );
6771  n->Arg<CNode*>(0) = a0;
6772  n->Arg<CNode*>(1) = a1;
6773  return n;
6774 }
6789 inline CNode* cPATH( int a0, CNode* a1, int a2, int a3, CNode* a4, int a5, CNode* a6, Coord_t* loc=NULL )
6790 {
6791  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePATH );
6792  n->Arg<int>(0) = a0;
6793  n->Arg<CNode*>(1) = a1;
6794  n->Arg<int>(2) = a2;
6795  n->Arg<int>(3) = a3;
6796  n->Arg<CNode*>(4) = a4;
6797  n->Arg<int>(5) = a5;
6798  n->Arg<CNode*>(6) = a6;
6799  return n;
6800 }
6816 inline CNode* cPATH( CObstack* heap, int a0, CNode* a1, int a2, int a3, CNode* a4, int a5, CNode* a6, Coord_t* loc=NULL )
6817 {
6818  CNode* n = new(heap) CNode( loc, ePATH );
6819  n->Arg<int>(0) = a0;
6820  n->Arg<CNode*>(1) = a1;
6821  n->Arg<int>(2) = a2;
6822  n->Arg<int>(3) = a3;
6823  n->Arg<CNode*>(4) = a4;
6824  n->Arg<int>(5) = a5;
6825  n->Arg<CNode*>(6) = a6;
6826  return n;
6827 }
6838 inline CNode* cPATH_ASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
6839 {
6840  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePATH_ASSIGN );
6841  n->Arg<CNode*>(0) = a0;
6842  n->Arg<CNode*>(1) = a1;
6843  n->Arg<CNode*>(2) = a2;
6844  return n;
6845 }
6857 inline CNode* cPATH_ASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
6858 {
6859  CNode* n = new(heap) CNode( loc, ePATH_ASSIGN );
6860  n->Arg<CNode*>(0) = a0;
6861  n->Arg<CNode*>(1) = a1;
6862  n->Arg<CNode*>(2) = a2;
6863  return n;
6864 }
6874 inline CNode* cIFNONE_PATH_ASSIGN( CNode* a0, CNode* a1, Coord_t* loc=NULL )
6875 {
6876  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eIFNONE_PATH_ASSIGN );
6877  n->Arg<CNode*>(0) = a0;
6878  n->Arg<CNode*>(1) = a1;
6879  return n;
6880 }
6891 inline CNode* cIFNONE_PATH_ASSIGN( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
6892 {
6893  CNode* n = new(heap) CNode( loc, eIFNONE_PATH_ASSIGN );
6894  n->Arg<CNode*>(0) = a0;
6895  n->Arg<CNode*>(1) = a1;
6896  return n;
6897 }
6906 inline CNode* cTRIGGER( CNode* a0, Coord_t* loc=NULL )
6907 {
6908  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eTRIGGER );
6909  n->Arg<CNode*>(0) = a0;
6910  return n;
6911 }
6921 inline CNode* cTRIGGER( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
6922 {
6923  CNode* n = new(heap) CNode( loc, eTRIGGER );
6924  n->Arg<CNode*>(0) = a0;
6925  return n;
6926 }
6936 inline CNode* cPASSIGN( CNode* a0, CNode* a1, Coord_t* loc=NULL )
6937 {
6938  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePASSIGN );
6939  n->Arg<CNode*>(0) = a0;
6940  n->Arg<CNode*>(1) = a1;
6941  return n;
6942 }
6953 inline CNode* cPASSIGN( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
6954 {
6955  CNode* n = new(heap) CNode( loc, ePASSIGN );
6956  n->Arg<CNode*>(0) = a0;
6957  n->Arg<CNode*>(1) = a1;
6958  return n;
6959 }
6968 inline CNode* cDEASSIGN( CNode* a0, Coord_t* loc=NULL )
6969 {
6970  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eDEASSIGN );
6971  n->Arg<CNode*>(0) = a0;
6972  return n;
6973 }
6983 inline CNode* cDEASSIGN( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
6984 {
6985  CNode* n = new(heap) CNode( loc, eDEASSIGN );
6986  n->Arg<CNode*>(0) = a0;
6987  return n;
6988 }
6997 inline CNode* cDISABLE( CSymbol* a0, Coord_t* loc=NULL )
6998 {
6999  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eDISABLE );
7000  n->Arg<CSymbol*>(0) = a0;
7001  return n;
7002 }
7012 inline CNode* cDISABLE( CObstack* heap, CSymbol* a0, Coord_t* loc=NULL )
7013 {
7014  CNode* n = new(heap) CNode( loc, eDISABLE );
7015  n->Arg<CSymbol*>(0) = a0;
7016  return n;
7017 }
7026 inline CNode* cATTRIBUTE( CAttr* a0, Coord_t* loc=NULL )
7027 {
7028  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eATTRIBUTE );
7029  n->Arg<CAttr*>(0) = a0;
7030  return n;
7031 }
7041 inline CNode* cATTRIBUTE( CObstack* heap, CAttr* a0, Coord_t* loc=NULL )
7042 {
7043  CNode* n = new(heap) CNode( loc, eATTRIBUTE );
7044  n->Arg<CAttr*>(0) = a0;
7045  return n;
7046 }
7057 inline CNode* cGIF( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
7058 {
7059  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eGIF );
7060  n->Arg<CNode*>(0) = a0;
7061  n->Arg<CNode*>(1) = a1;
7062  n->Arg<CNode*>(2) = a2;
7063  return n;
7064 }
7076 inline CNode* cGIF( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
7077 {
7078  CNode* n = new(heap) CNode( loc, eGIF );
7079  n->Arg<CNode*>(0) = a0;
7080  n->Arg<CNode*>(1) = a1;
7081  n->Arg<CNode*>(2) = a2;
7082  return n;
7083 }
7095 inline CNode* cGFOR( CNode* a0, CNode* a1, CNode* a2, CNode* a3, Coord_t* loc=NULL )
7096 {
7097  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eGFOR );
7098  n->Arg<CNode*>(0) = a0;
7099  n->Arg<CNode*>(1) = a1;
7100  n->Arg<CNode*>(2) = a2;
7101  n->Arg<CNode*>(3) = a3;
7102  return n;
7103 }
7116 inline CNode* cGFOR( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, CNode* a3, Coord_t* loc=NULL )
7117 {
7118  CNode* n = new(heap) CNode( loc, eGFOR );
7119  n->Arg<CNode*>(0) = a0;
7120  n->Arg<CNode*>(1) = a1;
7121  n->Arg<CNode*>(2) = a2;
7122  n->Arg<CNode*>(3) = a3;
7123  return n;
7124 }
7134 inline CNode* cGCASE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
7135 {
7136  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eGCASE );
7137  n->Arg<CNode*>(0) = a0;
7138  n->Arg<CNode*>(1) = a1;
7139  return n;
7140 }
7151 inline CNode* cGCASE( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
7152 {
7153  CNode* n = new(heap) CNode( loc, eGCASE );
7154  n->Arg<CNode*>(0) = a0;
7155  n->Arg<CNode*>(1) = a1;
7156  return n;
7157 }
7166 inline CNode* cTABLE( CNode* a0, Coord_t* loc=NULL )
7167 {
7168  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eTABLE );
7169  n->Arg<CNode*>(0) = a0;
7170  return n;
7171 }
7181 inline CNode* cTABLE( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
7182 {
7183  CNode* n = new(heap) CNode( loc, eTABLE );
7184  n->Arg<CNode*>(0) = a0;
7185  return n;
7186 }
7195 inline CNode* cTABLE_ENTRY( CNode* a0, Coord_t* loc=NULL )
7196 {
7197  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eTABLE_ENTRY );
7198  n->Arg<CNode*>(0) = a0;
7199  return n;
7200 }
7210 inline CNode* cTABLE_ENTRY( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
7211 {
7212  CNode* n = new(heap) CNode( loc, eTABLE_ENTRY );
7213  n->Arg<CNode*>(0) = a0;
7214  return n;
7215 }
7224 inline CNode* cTABLE_SYMBOL( char* a0, Coord_t* loc=NULL )
7225 {
7226  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eTABLE_SYMBOL );
7227  n->Arg<char*>(0) = a0;
7228  return n;
7229 }
7239 inline CNode* cTABLE_SYMBOL( CObstack* heap, char* a0, Coord_t* loc=NULL )
7240 {
7241  CNode* n = new(heap) CNode( loc, eTABLE_SYMBOL );
7242  n->Arg<char*>(0) = a0;
7243  return n;
7244 }
7252 inline CNode* cPORTLIST_END( Coord_t* loc=NULL )
7253 {
7254  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePORTLIST_END );
7255  return n;
7256 }
7265 inline CNode* cPORTLIST_END( CObstack* heap, Coord_t* loc=NULL )
7266 {
7267  CNode* n = new(heap) CNode( loc, ePORTLIST_END );
7268  return n;
7269 }
7279 inline CNode* cMACRO_EXPR( const char* a0, CNode* a1, Coord_t* loc=NULL )
7280 {
7281  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eMACRO_EXPR );
7282  n->Arg<const char*>(0) = a0;
7283  n->Arg<CNode*>(1) = a1;
7284  return n;
7285 }
7296 inline CNode* cMACRO_EXPR( CObstack* heap, const char* a0, CNode* a1, Coord_t* loc=NULL )
7297 {
7298  CNode* n = new(heap) CNode( loc, eMACRO_EXPR );
7299  n->Arg<const char*>(0) = a0;
7300  n->Arg<CNode*>(1) = a1;
7301  return n;
7302 }
7313 inline CNode* cENUM_SPEC( CSymbol* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
7314 {
7315  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eENUM_SPEC );
7316  n->Arg<CSymbol*>(0) = a0;
7317  n->Arg<CNode*>(1) = a1;
7318  n->Arg<CNode*>(2) = a2;
7319  return n;
7320 }
7332 inline CNode* cENUM_SPEC( CObstack* heap, CSymbol* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
7333 {
7334  CNode* n = new(heap) CNode( loc, eENUM_SPEC );
7335  n->Arg<CSymbol*>(0) = a0;
7336  n->Arg<CNode*>(1) = a1;
7337  n->Arg<CNode*>(2) = a2;
7338  return n;
7339 }
7349 inline CNode* cMEMBER( CNode* a0, CSymbol* a1, Coord_t* loc=NULL )
7350 {
7351  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eMEMBER );
7352  n->Arg<CNode*>(0) = a0;
7353  n->Arg<CSymbol*>(1) = a1;
7354  return n;
7355 }
7366 inline CNode* cMEMBER( CObstack* heap, CNode* a0, CSymbol* a1, Coord_t* loc=NULL )
7367 {
7368  CNode* n = new(heap) CNode( loc, eMEMBER );
7369  n->Arg<CNode*>(0) = a0;
7370  n->Arg<CSymbol*>(1) = a1;
7371  return n;
7372 }
7381 inline CNode* cRETURN( CNode* a0, Coord_t* loc=NULL )
7382 {
7383  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRETURN );
7384  n->Arg<CNode*>(0) = a0;
7385  return n;
7386 }
7396 inline CNode* cRETURN( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
7397 {
7398  CNode* n = new(heap) CNode( loc, eRETURN );
7399  n->Arg<CNode*>(0) = a0;
7400  return n;
7401 }
7410 inline CNode* cPREINC( CNode* a0, Coord_t* loc=NULL )
7411 {
7412  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePREINC );
7413  n->Arg<CNode*>(0) = a0;
7414  return n;
7415 }
7425 inline CNode* cPREINC( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
7426 {
7427  CNode* n = new(heap) CNode( loc, ePREINC );
7428  n->Arg<CNode*>(0) = a0;
7429  return n;
7430 }
7439 inline CNode* cPOSTINC( CNode* a0, Coord_t* loc=NULL )
7440 {
7441  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePOSTINC );
7442  n->Arg<CNode*>(0) = a0;
7443  return n;
7444 }
7454 inline CNode* cPOSTINC( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
7455 {
7456  CNode* n = new(heap) CNode( loc, ePOSTINC );
7457  n->Arg<CNode*>(0) = a0;
7458  return n;
7459 }
7468 inline CNode* cPREDEC( CNode* a0, Coord_t* loc=NULL )
7469 {
7470  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePREDEC );
7471  n->Arg<CNode*>(0) = a0;
7472  return n;
7473 }
7483 inline CNode* cPREDEC( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
7484 {
7485  CNode* n = new(heap) CNode( loc, ePREDEC );
7486  n->Arg<CNode*>(0) = a0;
7487  return n;
7488 }
7497 inline CNode* cPOSTDEC( CNode* a0, Coord_t* loc=NULL )
7498 {
7499  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePOSTDEC );
7500  n->Arg<CNode*>(0) = a0;
7501  return n;
7502 }
7512 inline CNode* cPOSTDEC( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
7513 {
7514  CNode* n = new(heap) CNode( loc, ePOSTDEC );
7515  n->Arg<CNode*>(0) = a0;
7516  return n;
7517 }
7527 inline CNode* cCAST( CNode* a0, CNode* a1, Coord_t* loc=NULL )
7528 {
7529  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCAST );
7530  n->Arg<CNode*>(0) = a0;
7531  n->Arg<CNode*>(1) = a1;
7532  return n;
7533 }
7544 inline CNode* cCAST( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
7545 {
7546  CNode* n = new(heap) CNode( loc, eCAST );
7547  n->Arg<CNode*>(0) = a0;
7548  n->Arg<CNode*>(1) = a1;
7549  return n;
7550 }
7551 #endif // DEFINE_CONSTUCTOR
7552 
7553 
7554 /*********************************************************
7555  * Warning: This file is machine generate, do not edit
7556  ********************************************************/
7557 
7558 
7559 
7560 
7561 #ifdef DEFINE_METHODS
7562 
7563 /************************************
7564  * ArgCount
7565  * - return number of arguments for node
7566  ***********************************/
7568 {
7569  switch( op ) {
7570  case eERROR:
7571  return 0;
7572  case eVCONSTANT:
7573  return 1;
7574  case eRCONSTANT:
7575  return 1;
7576  case eCOMMENT:
7577  return 1;
7578  case eVRQ:
7579  return 1;
7580  case ePRAGMA:
7581  return 1;
7582  case eELIST:
7583  return 2;
7584  case eWIDTH:
7585  return 2;
7586  case eNOP:
7587  return 0;
7588  case eSUB:
7589  return 2;
7590  case eMUL:
7591  return 2;
7592  case eDIV:
7593  return 2;
7594  case ePOW:
7595  return 2;
7596  case eADD:
7597  return 2;
7598  case eLSH:
7599  return 2;
7600  case eRSH:
7601  return 2;
7602  case eLSHA:
7603  return 2;
7604  case eRSHA:
7605  return 2;
7606  case eMOD:
7607  return 2;
7608  case eOR:
7609  return 2;
7610  case eAND:
7611  return 2;
7612  case eANDANDAND:
7613  return 2;
7614  case eXOR:
7615  return 2;
7616  case eXNOR:
7617  return 2;
7618  case eINSTANCE_REF:
7619  return 1;
7620  case eGATE_REF:
7621  return 1;
7622  case eTASK_ENABLE:
7623  return 2;
7624  case eSYSTASK_CALL:
7625  return 2;
7626  case eTIMING_CALL:
7627  return 2;
7628  case eFUNCTION_CALL:
7629  return 3;
7630  case eARRAY:
7631  return 2;
7632  case eNET_REF:
7633  return 1;
7634  case eVAR_REF:
7635  return 1;
7636  case ePARAM_REF:
7637  return 1;
7638  case ePORT_REF:
7639  return 1;
7640  case eFWD_REF:
7641  return 1;
7642  case eGENVAR_REF:
7643  return 1;
7644  case eENUM_REF:
7645  return 1;
7646  case eTYPE_REF:
7647  return 1;
7648  case eNET_DECL:
7649  return 2;
7650  case eVAR_DECL:
7651  return 2;
7652  case ePARAM_DECL:
7653  return 1;
7654  case eSPECPARAM_DECL:
7655  return 1;
7656  case ePORT_DECL:
7657  return 1;
7658  case eGENVAR_DECL:
7659  return 1;
7660  case eTYPEDEF_DECL:
7661  return 1;
7662  case eLIST:
7663  return 2;
7664  case eRANGE:
7665  return 2;
7666  case eSLICE:
7667  return 2;
7668  case ePSLICE:
7669  return 2;
7670  case eMSLICE:
7671  return 2;
7672  case eCVRI:
7673  return 1;
7674  case eCVIR:
7675  return 1;
7676  case eREP:
7677  return 2;
7678  case eCAT:
7679  return 2;
7680  case eUCAT:
7681  return 1;
7682  case eCOM:
7683  return 1;
7684  case eNEG:
7685  return 1;
7686  case ePLUS:
7687  return 1;
7688  case eNOT:
7689  return 1;
7690  case eGT:
7691  return 2;
7692  case eGE:
7693  return 2;
7694  case eLT:
7695  return 2;
7696  case eLE:
7697  return 2;
7698  case eLAND:
7699  return 2;
7700  case eLOR:
7701  return 2;
7702  case eCEQ:
7703  return 2;
7704  case eCNE:
7705  return 2;
7706  case eEQ:
7707  return 2;
7708  case eNE:
7709  return 2;
7710  case eRAND:
7711  return 1;
7712  case eRNAND:
7713  return 1;
7714  case eROR:
7715  return 1;
7716  case eRNOR:
7717  return 1;
7718  case eRXOR:
7719  return 1;
7720  case eRXNOR:
7721  return 1;
7722  case eHOOK:
7723  return 3;
7724  case eINIT:
7725  return 1;
7726  case eALWAYS:
7727  return 1;
7728  case eALWAYS_LATCH:
7729  return 1;
7730  case eALWAYS_FF:
7731  return 1;
7732  case eALWAYS_COMB:
7733  return 1;
7734  case eEVENT:
7735  return 2;
7736  case eBLOCK_REF:
7737  return 2;
7738  case eSPECIFY_REF:
7739  return 2;
7740  case eASSIGN:
7741  return 3;
7742  case eGASSIGN:
7743  return 3;
7744  case eADD_ASSIGN:
7745  return 3;
7746  case eSUB_ASSIGN:
7747  return 3;
7748  case eMUL_ASSIGN:
7749  return 3;
7750  case eDIV_ASSIGN:
7751  return 3;
7752  case eMOD_ASSIGN:
7753  return 3;
7754  case eAND_ASSIGN:
7755  return 3;
7756  case eOR_ASSIGN:
7757  return 3;
7758  case eXOR_ASSIGN:
7759  return 3;
7760  case eLSH_ASSIGN:
7761  return 3;
7762  case eRSH_ASSIGN:
7763  return 3;
7764  case eLSHA_ASSIGN:
7765  return 3;
7766  case eRSHA_ASSIGN:
7767  return 3;
7768  case eFORCE:
7769  return 2;
7770  case eRELEASE:
7771  return 1;
7772  case eNBASSIGN:
7773  return 3;
7774  case ePOSEDGE:
7775  return 1;
7776  case eNEGEDGE:
7777  return 1;
7778  case eEDGE:
7779  return 2;
7780  case eEVOR:
7781  return 2;
7782  case eDELAY:
7783  return 2;
7784  case eMTM:
7785  return 3;
7786  case eIF:
7787  return 3;
7788  case eFOREVER:
7789  return 1;
7790  case eREPEAT:
7791  return 2;
7792  case eWHILE:
7793  return 2;
7794  case eWAIT:
7795  return 2;
7796  case eFOR:
7797  return 4;
7798  case eCASE:
7799  return 2;
7800  case eCASEX:
7801  return 2;
7802  case eCASEZ:
7803  return 2;
7804  case eCASEITEM:
7805  return 2;
7806  case eCASSIGN:
7807  return 4;
7808  case eARG:
7809  return 2;
7810  case eIMPORT:
7811  return 1;
7812  case eFUNCTION_DEF:
7813  return 1;
7814  case eMODULE_DEF:
7815  return 1;
7816  case ePACKAGE_DEF:
7817  return 1;
7818  case eREPEAT_CONTROL:
7819  return 2;
7820  case eDELAY_CONTROL:
7821  return 1;
7822  case eEVENT_CONTROL:
7823  return 1;
7824  case eEXTERNAL_REF:
7825  return 1;
7826  case ePORT_DEF:
7827  return 1;
7828  case eDEFPARAM:
7829  return 2;
7830  case ePATH:
7831  return 7;
7832  case ePATH_ASSIGN:
7833  return 3;
7834  case eIFNONE_PATH_ASSIGN:
7835  return 2;
7836  case eTRIGGER:
7837  return 1;
7838  case ePASSIGN:
7839  return 2;
7840  case eDEASSIGN:
7841  return 1;
7842  case eDISABLE:
7843  return 1;
7844  case eATTRIBUTE:
7845  return 1;
7846  case eGIF:
7847  return 3;
7848  case eGFOR:
7849  return 4;
7850  case eGCASE:
7851  return 2;
7852  case eTABLE:
7853  return 1;
7854  case eTABLE_ENTRY:
7855  return 1;
7856  case eTABLE_SYMBOL:
7857  return 1;
7858  case ePORTLIST_END:
7859  return 0;
7860  case eMACRO_EXPR:
7861  return 2;
7862  case eENUM_SPEC:
7863  return 3;
7864  case eMEMBER:
7865  return 2;
7866  case eRETURN:
7867  return 1;
7868  case ePREINC:
7869  return 1;
7870  case ePOSTINC:
7871  return 1;
7872  case ePREDEC:
7873  return 1;
7874  case ePOSTDEC:
7875  return 1;
7876  case eCAST:
7877  return 2;
7878  default:
7879  MASSERT(FALSE);
7880  }
7881  return 0;
7882 }
7883 
7884 /************************************
7885  * Precedence
7886  * - return precedence of operator
7887  * result 0 - 13
7888  ***********************************/
7890 {
7891  switch( op ) {
7892  case eERROR:
7893  return 13;
7894  case eVCONSTANT:
7895  return 13;
7896  case eRCONSTANT:
7897  return 13;
7898  case eCOMMENT:
7899  return 13;
7900  case eVRQ:
7901  return 13;
7902  case ePRAGMA:
7903  return 13;
7904  case eELIST:
7905  return 13;
7906  case eWIDTH:
7907  return 13;
7908  case eSUB:
7909  return 9;
7910  case eMUL:
7911  return 10;
7912  case eDIV:
7913  return 10;
7914  case ePOW:
7915  return 11;
7916  case eADD:
7917  return 9;
7918  case eLSH:
7919  return 8;
7920  case eRSH:
7921  return 8;
7922  case eLSHA:
7923  return 8;
7924  case eRSHA:
7925  return 8;
7926  case eMOD:
7927  return 10;
7928  case eOR:
7929  return 3;
7930  case eAND:
7931  return 5;
7932  case eANDANDAND:
7933  return 0;
7934  case eXOR:
7935  return 4;
7936  case eXNOR:
7937  return 4;
7938  case eSYSTASK_CALL:
7939  return 13;
7940  case eFUNCTION_CALL:
7941  return 13;
7942  case eARRAY:
7943  return 13;
7944  case eNET_REF:
7945  return 13;
7946  case eVAR_REF:
7947  return 13;
7948  case ePARAM_REF:
7949  return 13;
7950  case ePORT_REF:
7951  return 13;
7952  case eFWD_REF:
7953  return 13;
7954  case eGENVAR_REF:
7955  return 13;
7956  case eENUM_REF:
7957  return 13;
7958  case eTYPE_REF:
7959  return 13;
7960  case eRANGE:
7961  return 13;
7962  case eSLICE:
7963  return 13;
7964  case ePSLICE:
7965  return 13;
7966  case eMSLICE:
7967  return 13;
7968  case eCVRI:
7969  return 13;
7970  case eCVIR:
7971  return 13;
7972  case eREP:
7973  return 13;
7974  case eCAT:
7975  return 13;
7976  case eUCAT:
7977  return 13;
7978  case eCOM:
7979  return 12;
7980  case eNEG:
7981  return 12;
7982  case ePLUS:
7983  return 12;
7984  case eNOT:
7985  return 12;
7986  case eGT:
7987  return 7;
7988  case eGE:
7989  return 7;
7990  case eLT:
7991  return 7;
7992  case eLE:
7993  return 7;
7994  case eLAND:
7995  return 2;
7996  case eLOR:
7997  return 1;
7998  case eCEQ:
7999  return 6;
8000  case eCNE:
8001  return 6;
8002  case eEQ:
8003  return 6;
8004  case eNE:
8005  return 6;
8006  case eRAND:
8007  return 12;
8008  case eRNAND:
8009  return 12;
8010  case eROR:
8011  return 12;
8012  case eRNOR:
8013  return 12;
8014  case eRXOR:
8015  return 12;
8016  case eRXNOR:
8017  return 12;
8018  case eHOOK:
8019  return 0;
8020  case ePOSEDGE:
8021  return 13;
8022  case eNEGEDGE:
8023  return 13;
8024  case eEDGE:
8025  return 13;
8026  case eEVOR:
8027  return 13;
8028  case eMTM:
8029  return 13;
8030  case eEXTERNAL_REF:
8031  return 13;
8032  case eMACRO_EXPR:
8033  return 13;
8034  case eMEMBER:
8035  return 13;
8036  case ePREINC:
8037  return 12;
8038  case ePOSTINC:
8039  return 12;
8040  case ePREDEC:
8041  return 12;
8042  case ePOSTDEC:
8043  return 12;
8044  case eCAST:
8045  return 13;
8046  default:
8047  MASSERT( FALSE );
8048  return 13;
8049  }
8050 }
8051 
8052 /************************************************
8053  IsConstant
8054  - return true if expression is constant
8055 **************************************************/
8056 
8058 {
8059  switch( op ) {
8060  case eERROR:
8061  return FALSE;
8062  case eVCONSTANT:
8063  return TRUE;
8064  case eRCONSTANT:
8065  return TRUE;
8066  case eCOMMENT:
8067  return TRUE;
8068  case eVRQ:
8069  return TRUE;
8070  case ePRAGMA:
8071  return TRUE;
8072  case eELIST:
8073  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8074  case eWIDTH:
8075  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8076  case eSUB:
8077  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8078  case eMUL:
8079  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8080  case eDIV:
8081  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8082  case ePOW:
8083  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8084  case eADD:
8085  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8086  case eLSH:
8087  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8088  case eRSH:
8089  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8090  case eLSHA:
8091  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8092  case eRSHA:
8093  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8094  case eMOD:
8095  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8096  case eOR:
8097  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8098  case eAND:
8099  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8100  case eANDANDAND:
8101  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8102  case eXOR:
8103  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8104  case eXNOR:
8105  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8106  case eSYSTASK_CALL:
8107  return TRUE;
8108  case eFUNCTION_CALL:
8109  return Arg<CNode*>(1)->IsConstant();
8110  case eARRAY:
8111  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8112  case eNET_REF:
8113  return FALSE;
8114  case eVAR_REF:
8115  return FALSE;
8116  case ePARAM_REF:
8117  return TRUE;
8118  case ePORT_REF:
8119  return FALSE;
8120  case eFWD_REF:
8121  return FALSE;
8122  case eGENVAR_REF:
8123  return TRUE;
8124  case eENUM_REF:
8125  return TRUE;
8126  case eTYPE_REF:
8127  return TRUE;
8128  case eRANGE:
8129  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8130  case eSLICE:
8131  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8132  case ePSLICE:
8133  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8134  case eMSLICE:
8135  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8136  case eCVRI:
8137  return Arg<CNode*>(0)->IsConstant();
8138  case eCVIR:
8139  return Arg<CNode*>(0)->IsConstant();
8140  case eREP:
8141  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8142  case eCAT:
8143  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8144  case eUCAT:
8145  return Arg<CNode*>(0)->IsConstant();
8146  case eCOM:
8147  return Arg<CNode*>(0)->IsConstant();
8148  case eNEG:
8149  return Arg<CNode*>(0)->IsConstant();
8150  case ePLUS:
8151  return Arg<CNode*>(0)->IsConstant();
8152  case eNOT:
8153  return Arg<CNode*>(0)->IsConstant();
8154  case eGT:
8155  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8156  case eGE:
8157  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8158  case eLT:
8159  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8160  case eLE:
8161  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8162  case eLAND:
8163  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8164  case eLOR:
8165  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8166  case eCEQ:
8167  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8168  case eCNE:
8169  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8170  case eEQ:
8171  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8172  case eNE:
8173  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8174  case eRAND:
8175  return Arg<CNode*>(0)->IsConstant();
8176  case eRNAND:
8177  return Arg<CNode*>(0)->IsConstant();
8178  case eROR:
8179  return Arg<CNode*>(0)->IsConstant();
8180  case eRNOR:
8181  return Arg<CNode*>(0)->IsConstant();
8182  case eRXOR:
8183  return Arg<CNode*>(0)->IsConstant();
8184  case eRXNOR:
8185  return Arg<CNode*>(0)->IsConstant();
8186  case eHOOK:
8187  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant() && Arg<CNode*>(2)->IsConstant();
8188  case eMTM:
8189  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant() && Arg<CNode*>(2)->IsConstant();
8190  case eEXTERNAL_REF:
8191  return FALSE;
8192  case eMACRO_EXPR:
8193  return TRUE;
8194  case eMEMBER:
8195  return Arg<CNode*>(0)->IsConstant();
8196  case ePREINC:
8197  return Arg<CNode*>(0)->IsConstant();
8198  case ePOSTINC:
8199  return Arg<CNode*>(0)->IsConstant();
8200  case ePREDEC:
8201  return Arg<CNode*>(0)->IsConstant();
8202  case ePOSTDEC:
8203  return Arg<CNode*>(0)->IsConstant();
8204  case eCAST:
8205  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8206  default:
8207  MASSERT( FALSE );
8208  }
8209 
8210  return TRUE;
8211 }
8212 
8213 /************************************************
8214  IsVolatile
8215  - return false if expression is constant
8216  and not dependent upon parameters
8217 **************************************************/
8218 
8220 {
8221  switch( op ) {
8222  case eERROR:
8223  return TRUE;
8224  case eVCONSTANT:
8225  return FALSE;
8226  case eRCONSTANT:
8227  return FALSE;
8228  case eCOMMENT:
8229  return FALSE;
8230  case eVRQ:
8231  return FALSE;
8232  case ePRAGMA:
8233  return FALSE;
8234  case eELIST:
8235  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8236  case eWIDTH:
8237  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8238  case eSUB:
8239  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8240  case eMUL:
8241  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8242  case eDIV:
8243  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8244  case ePOW:
8245  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8246  case eADD:
8247  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8248  case eLSH:
8249  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8250  case eRSH:
8251  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8252  case eLSHA:
8253  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8254  case eRSHA:
8255  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8256  case eMOD:
8257  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8258  case eOR:
8259  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8260  case eAND:
8261  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8262  case eANDANDAND:
8263  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8264  case eXOR:
8265  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8266  case eXNOR:
8267  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8268  case eSYSTASK_CALL:
8269  return TRUE;
8270  case eFUNCTION_CALL:
8271  return Arg<CNode*>(1)->IsVolatile();
8272  case eARRAY:
8273  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8274  case eNET_REF:
8275  return TRUE;
8276  case eVAR_REF:
8277  return TRUE;
8278  case ePARAM_REF:
8279  return TRUE;
8280  case ePORT_REF:
8281  return TRUE;
8282  case eFWD_REF:
8283  return TRUE;
8284  case eGENVAR_REF:
8285  return TRUE;
8286  case eENUM_REF:
8287  return Arg<CEnum*>(0)->GetExpression()->IsVolatile();
8288  case eTYPE_REF:
8289  return FALSE;
8290  case eRANGE:
8291  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8292  case eSLICE:
8293  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8294  case ePSLICE:
8295  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8296  case eMSLICE:
8297  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8298  case eCVRI:
8299  return Arg<CNode*>(0)->IsVolatile();
8300  case eCVIR:
8301  return Arg<CNode*>(0)->IsVolatile();
8302  case eREP:
8303  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8304  case eCAT:
8305  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8306  case eUCAT:
8307  return Arg<CNode*>(0)->IsVolatile();
8308  case eCOM:
8309  return Arg<CNode*>(0)->IsVolatile();
8310  case eNEG:
8311  return Arg<CNode*>(0)->IsVolatile();
8312  case ePLUS:
8313  return Arg<CNode*>(0)->IsVolatile();
8314  case eNOT:
8315  return Arg<CNode*>(0)->IsVolatile();
8316  case eGT:
8317  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8318  case eGE:
8319  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8320  case eLT:
8321  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8322  case eLE:
8323  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8324  case eLAND:
8325  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8326  case eLOR:
8327  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8328  case eCEQ:
8329  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8330  case eCNE:
8331  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8332  case eEQ:
8333  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8334  case eNE:
8335  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8336  case eRAND:
8337  return Arg<CNode*>(0)->IsVolatile();
8338  case eRNAND:
8339  return Arg<CNode*>(0)->IsVolatile();
8340  case eROR:
8341  return Arg<CNode*>(0)->IsVolatile();
8342  case eRNOR:
8343  return Arg<CNode*>(0)->IsVolatile();
8344  case eRXOR:
8345  return Arg<CNode*>(0)->IsVolatile();
8346  case eRXNOR:
8347  return Arg<CNode*>(0)->IsVolatile();
8348  case eHOOK:
8349  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile() || Arg<CNode*>(2)->IsVolatile();
8350  case eMTM:
8351  return TRUE;
8352  case eEXTERNAL_REF:
8353  return TRUE;
8354  case eMACRO_EXPR:
8355  return Arg<CNode*>(1) ? Arg<CNode*>(1)->IsVolatile() : TRUE;
8356  case eMEMBER:
8357  return Arg<CNode*>(0)->IsVolatile();
8358  case ePREINC:
8359  return Arg<CNode*>(0)->IsVolatile();
8360  case ePOSTINC:
8361  return Arg<CNode*>(0)->IsVolatile();
8362  case ePREDEC:
8363  return Arg<CNode*>(0)->IsVolatile();
8364  case ePOSTDEC:
8365  return Arg<CNode*>(0)->IsVolatile();
8366  case eCAST:
8367  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8368  default:
8369  MASSERT( FALSE );
8370  }
8371 
8372  return TRUE;
8373 }
8374 
8375 
8376 /************************************************
8377  IsWidthConstant
8378  - return true if expression has a constant width
8379 **************************************************/
8380 
8382 {
8383  switch( GetOp() ) {
8384  case eERROR:
8385  return TRUE;
8386  case eVCONSTANT:
8387  return Arg<CVector*>(0)->IsWidthConstant();
8388  case eRCONSTANT:
8389  return TRUE;
8390  case eELIST:
8391  return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
8392  case eWIDTH:
8393  return Arg<CNode*>(0)->IsConstant();
8394  case eSUB:
8395  return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
8396  case eMUL:
8397  return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
8398  case eDIV:
8399  return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
8400  case ePOW:
8401  return Arg<CNode*>(0)->IsWidthConstant();
8402  case eADD:
8403  return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
8404  case eLSH:
8405  return Arg<CNode*>(0)->IsWidthConstant();
8406  case eRSH:
8407  return Arg<CNode*>(0)->IsWidthConstant();
8408  case eLSHA:
8409  return Arg<CNode*>(0)->IsWidthConstant();
8410  case eRSHA:
8411  return Arg<CNode*>(0)->IsWidthConstant();
8412  case eMOD:
8413  return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
8414  case eOR:
8415  return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
8416  case eAND:
8417  return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
8418  case eANDANDAND:
8419  return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
8420  case eXOR:
8421  return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
8422  case eXNOR:
8423  return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
8424  case eSYSTASK_CALL:
8425  return Systask::WidthConstant(Arg<CSymbol*>(0),Arg<CNode*>(1));
8426  case eFUNCTION_CALL:
8427  return CFunction::WidthConstant(Arg<CSymbol*>(0),Arg<CNode*>(1),Arg<CScope*>(2));
8428  case eARRAY:
8429  return Array::WidthConstant(Arg<CNode*>(0),Arg<CNode*>(1));
8430  case eNET_REF:
8431  return Arg<CNet*>(0)->IsWidthConstant();
8432  case eVAR_REF:
8433  return Arg<CVar*>(0)->IsWidthConstant();
8434  case ePARAM_REF:
8435  return Arg<CParam*>(0)->IsWidthConstant();
8436  case ePORT_REF:
8437  return Arg<CPortDir*>(0)->IsWidthConstant();
8438  case eFWD_REF:
8439  return Arg<CFref*>(0)->IsWidthConstant();
8440  case eGENVAR_REF:
8441  return Arg<CGenvar*>(0)->IsWidthConstant();
8442  case eENUM_REF:
8443  return Arg<CEnum*>(0)->IsWidthConstant();
8444  case eTYPE_REF:
8445  return TRUE;
8446  case eRANGE:
8447  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8448  case eSLICE:
8449  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8450  case ePSLICE:
8451  return Arg<CNode*>(1)->IsConstant();
8452  case eMSLICE:
8453  return Arg<CNode*>(1)->IsConstant();
8454  case eCVRI:
8455  return TRUE;
8456  case eCVIR:
8457  return TRUE;
8458  case eREP:
8459  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsWidthConstant();
8460  case eCAT:
8461  return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
8462  case eUCAT:
8463  return Arg<CNode*>(0)->IsWidthConstant();
8464  case eCOM:
8465  return Arg<CNode*>(0)->IsWidthConstant();
8466  case eNEG:
8467  return Arg<CNode*>(0)->IsWidthConstant();
8468  case ePLUS:
8469  return Arg<CNode*>(0)->IsWidthConstant();
8470  case eNOT:
8471  return TRUE;
8472  case eGT:
8473  return TRUE;
8474  case eGE:
8475  return TRUE;
8476  case eLT:
8477  return TRUE;
8478  case eLE:
8479  return TRUE;
8480  case eLAND:
8481  return TRUE;
8482  case eLOR:
8483  return TRUE;
8484  case eCEQ:
8485  return TRUE;
8486  case eCNE:
8487  return TRUE;
8488  case eEQ:
8489  return TRUE;
8490  case eNE:
8491  return TRUE;
8492  case eRAND:
8493  return TRUE;
8494  case eRNAND:
8495  return TRUE;
8496  case eROR:
8497  return TRUE;
8498  case eRNOR:
8499  return TRUE;
8500  case eRXOR:
8501  return TRUE;
8502  case eRXNOR:
8503  return TRUE;
8504  case eHOOK:
8505  return Arg<CNode*>(1)->IsWidthConstant() && Arg<CNode*>(2)->IsWidthConstant();
8506  case eMTM:
8507  return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant() && Arg<CNode*>(2)->IsWidthConstant();
8508  case eEXTERNAL_REF:
8509  return External::WidthConstant(Arg<CSymbol*>(0));
8510  case eATTRIBUTE:
8511  return TRUE;
8512  case eMACRO_EXPR:
8513  return Arg<CNode*>(1)->IsWidthConstant();
8514  case eMEMBER:
8515  return Member::WidthConstant(Arg<CNode*>(0),Arg<CSymbol*>(1));
8516  case ePREINC:
8517  return Arg<CNode*>(0)->IsWidthConstant();
8518  case ePOSTINC:
8519  return Arg<CNode*>(0)->IsWidthConstant();
8520  case ePREDEC:
8521  return Arg<CNode*>(0)->IsWidthConstant();
8522  case ePOSTDEC:
8523  return Arg<CNode*>(0)->IsWidthConstant();
8524  case eCAST:
8525  return Arg<CNode*>(0)->IsConstant();
8526  default:
8527  MASSERT( FALSE );
8528  return 0;
8529  }
8530 }
8531 
8532 /************************************************
8533  IsWidthVolatile
8534  - return true if expression has a volatile width
8535 **************************************************/
8536 
8538 {
8539  switch( GetOp() ) {
8540  case eERROR:
8541  return FALSE;
8542  case eVCONSTANT:
8543  return Arg<CVector*>(0)->IsWidthVolatile();
8544  case eRCONSTANT:
8545  return FALSE;
8546  case eELIST:
8547  return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
8548  case eWIDTH:
8549  return Arg<CNode*>(0)->IsVolatile();
8550  case eSUB:
8551  return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
8552  case eMUL:
8553  return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
8554  case eDIV:
8555  return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
8556  case ePOW:
8557  return Arg<CNode*>(0)->IsWidthVolatile();
8558  case eADD:
8559  return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
8560  case eLSH:
8561  return Arg<CNode*>(0)->IsWidthVolatile();
8562  case eRSH:
8563  return Arg<CNode*>(0)->IsWidthVolatile();
8564  case eLSHA:
8565  return Arg<CNode*>(0)->IsWidthVolatile();
8566  case eRSHA:
8567  return Arg<CNode*>(0)->IsWidthVolatile();
8568  case eMOD:
8569  return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
8570  case eOR:
8571  return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
8572  case eAND:
8573  return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
8574  case eANDANDAND:
8575  return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
8576  case eXOR:
8577  return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
8578  case eXNOR:
8579  return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
8580  case eSYSTASK_CALL:
8581  return Systask::WidthVolatile(Arg<CSymbol*>(0),Arg<CNode*>(1));
8582  case eFUNCTION_CALL:
8583  return CFunction::WidthVolatile(Arg<CSymbol*>(0),Arg<CNode*>(1),Arg<CScope*>(2));
8584  case eARRAY:
8585  return Array::WidthVolatile(Arg<CNode*>(0),Arg<CNode*>(1));
8586  case eNET_REF:
8587  return Arg<CNet*>(0)->IsWidthVolatile();
8588  case eVAR_REF:
8589  return Arg<CVar*>(0)->IsWidthVolatile();
8590  case ePARAM_REF:
8591  return Arg<CParam*>(0)->IsWidthVolatile();
8592  case ePORT_REF:
8593  return Arg<CPortDir*>(0)->IsWidthVolatile();
8594  case eFWD_REF:
8595  return Arg<CFref*>(0)->IsWidthVolatile();
8596  case eGENVAR_REF:
8597  return Arg<CGenvar*>(0)->IsWidthVolatile();
8598  case eENUM_REF:
8599  return Arg<CEnum*>(0)->IsWidthVolatile();
8600  case eTYPE_REF:
8601  return FALSE;
8602  case eRANGE:
8603  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8604  case eSLICE:
8605  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8606  case ePSLICE:
8607  return Arg<CNode*>(1)->IsVolatile();
8608  case eMSLICE:
8609  return Arg<CNode*>(1)->IsVolatile();
8610  case eCVRI:
8611  return FALSE;
8612  case eCVIR:
8613  return FALSE;
8614  case eREP:
8615  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
8616  case eCAT:
8617  return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
8618  case eUCAT:
8619  return Arg<CNode*>(0)->IsWidthVolatile();
8620  case eCOM:
8621  return Arg<CNode*>(0)->IsWidthVolatile();
8622  case eNEG:
8623  return Arg<CNode*>(0)->IsWidthVolatile();
8624  case ePLUS:
8625  return Arg<CNode*>(0)->IsWidthVolatile();
8626  case eNOT:
8627  return FALSE;
8628  case eGT:
8629  return FALSE;
8630  case eGE:
8631  return FALSE;
8632  case eLT:
8633  return FALSE;
8634  case eLE:
8635  return FALSE;
8636  case eLAND:
8637  return FALSE;
8638  case eLOR:
8639  return FALSE;
8640  case eCEQ:
8641  return FALSE;
8642  case eCNE:
8643  return FALSE;
8644  case eEQ:
8645  return FALSE;
8646  case eNE:
8647  return FALSE;
8648  case eRAND:
8649  return FALSE;
8650  case eRNAND:
8651  return FALSE;
8652  case eROR:
8653  return FALSE;
8654  case eRNOR:
8655  return FALSE;
8656  case eRXOR:
8657  return FALSE;
8658  case eRXNOR:
8659  return FALSE;
8660  case eHOOK:
8661  return Arg<CNode*>(1)->IsWidthVolatile() || Arg<CNode*>(2)->IsWidthVolatile();
8662  case eMTM:
8663  return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile() || Arg<CNode*>(2)->IsWidthVolatile();
8664  case eEXTERNAL_REF:
8665  return External::WidthVolatile(Arg<CSymbol*>(0));
8666  case eATTRIBUTE:
8667  return FALSE;
8668  case eMACRO_EXPR:
8669  return Arg<CNode*>(1)->IsWidthVolatile();
8670  case eMEMBER:
8671  return Member::WidthVolatile(Arg<CNode*>(0),Arg<CSymbol*>(1));
8672  case ePREINC:
8673  return Arg<CNode*>(0)->IsWidthVolatile();
8674  case ePOSTINC:
8675  return Arg<CNode*>(0)->IsWidthVolatile();
8676  case ePREDEC:
8677  return Arg<CNode*>(0)->IsWidthVolatile();
8678  case ePOSTDEC:
8679  return Arg<CNode*>(0)->IsWidthVolatile();
8680  case eCAST:
8681  return Arg<CNode*>(0)->IsVolatile();
8682  default:
8683  MASSERT( FALSE );
8684  return 0;
8685  }
8686 
8687 }
8688 
8689 /************************************************
8690  GetWidthExp
8691  - return expression tree for width of
8692  expression, return NULL if not-determinable
8693 **************************************************/
8694 
8696 {
8697  switch( GetOp() ) {
8698  case eERROR: {
8699  CNode* temp0;
8700  CNode* temp1;
8701  CNode* temp2;
8702  return NULL;
8703  }
8704  case eVCONSTANT: {
8705  CNode* temp0;
8706  CNode* temp1;
8707  CNode* temp2;
8708  return Arg<CVector*>(0)->GetWidthExp();
8709  }
8710  case eRCONSTANT: {
8711  CNode* temp0;
8712  CNode* temp1;
8713  CNode* temp2;
8714  return NULL;
8715  }
8716  case eELIST: {
8717  CNode* temp0;
8718  CNode* temp1;
8719  CNode* temp2;
8720  return ((temp0=Arg<CNode*>(0)->GetWidthExp()) && (temp1=Arg<CNode*>(1)->GetWidthExp())) ? cADD_N(temp0,temp1,NULL) : NULL;
8721  }
8722  case eWIDTH: {
8723  CNode* temp0;
8724  CNode* temp1;
8725  CNode* temp2;
8726  return cINT32(Arg<CNode*>(0)->EvalINT32());
8727  }
8728  case eSUB: {
8729  CNode* temp0;
8730  CNode* temp1;
8731  CNode* temp2;
8732  return ((temp0=Arg<CNode*>(0)->GetWidthExp()) && (temp1=Arg<CNode*>(1)->GetWidthExp())) ? cMAX_N(temp0,temp1,NULL) : NULL;
8733  }
8734  case eMUL: {
8735  CNode* temp0;
8736  CNode* temp1;
8737  CNode* temp2;
8738  return ((temp0=Arg<CNode*>(0)->GetWidthExp()) && (temp1=Arg<CNode*>(1)->GetWidthExp())) ? cMAX_N(temp0,temp1,NULL) : NULL;
8739  }
8740  case eDIV: {
8741  CNode* temp0;
8742  CNode* temp1;
8743  CNode* temp2;
8744  return ((temp0=Arg<CNode*>(0)->GetWidthExp()) && (temp1=Arg<CNode*>(1)->GetWidthExp())) ? cMAX_N(temp0,temp1,NULL) : NULL;
8745  }
8746  case ePOW: {
8747  CNode* temp0;
8748  CNode* temp1;
8749  CNode* temp2;
8750  return Arg<CNode*>(0)->GetWidthExp();
8751  }
8752  case eADD: {
8753  CNode* temp0;
8754  CNode* temp1;
8755  CNode* temp2;
8756  return ((temp0=Arg<CNode*>(0)->GetWidthExp()) && (temp1=Arg<CNode*>(1)->GetWidthExp())) ? cMAX_N(temp0,temp1,NULL) : NULL;
8757  }
8758  case eLSH: {
8759  CNode* temp0;
8760  CNode* temp1;
8761  CNode* temp2;
8762  return Arg<CNode*>(0)->GetWidthExp();
8763  }
8764  case eRSH: {
8765  CNode* temp0;
8766  CNode* temp1;
8767  CNode* temp2;
8768  return Arg<CNode*>(0)->GetWidthExp();
8769  }
8770  case eLSHA: {
8771  CNode* temp0;
8772  CNode* temp1;
8773  CNode* temp2;
8774  return Arg<CNode*>(0)->GetWidthExp();
8775  }
8776  case eRSHA: {
8777  CNode* temp0;
8778  CNode* temp1;
8779  CNode* temp2;
8780  return Arg<CNode*>(0)->GetWidthExp();
8781  }
8782  case eMOD: {
8783  CNode* temp0;
8784  CNode* temp1;
8785  CNode* temp2;
8786  return ((temp0=Arg<CNode*>(0)->GetWidthExp()) && (temp1=Arg<CNode*>(1)->GetWidthExp())) ? cMAX_N(temp0,temp1,NULL) : NULL;
8787  }
8788  case eOR: {
8789  CNode* temp0;
8790  CNode* temp1;
8791  CNode* temp2;
8792  return ((temp0=Arg<CNode*>(0)->GetWidthExp()) && (temp1=Arg<CNode*>(1)->GetWidthExp())) ? cMAX_N(temp0,temp1,NULL) : NULL;
8793  }
8794  case eAND: {
8795  CNode* temp0;
8796  CNode* temp1;
8797  CNode* temp2;
8798  return ((temp0=Arg<CNode*>(0)->GetWidthExp()) && (temp1=Arg<CNode*>(1)->GetWidthExp())) ? cMAX_N(temp0,temp1,NULL) : NULL;
8799  }
8800  case eANDANDAND: {
8801  CNode* temp0;
8802  CNode* temp1;
8803  CNode* temp2;
8804  return ((temp0=Arg<CNode*>(0)->GetWidthExp()) && (temp1=Arg<CNode*>(1)->GetWidthExp())) ? cMAX_N(temp0,temp1,NULL) : NULL;
8805  }
8806  case eXOR: {
8807  CNode* temp0;
8808  CNode* temp1;
8809  CNode* temp2;
8810  return ((temp0=Arg<CNode*>(0)->GetWidthExp()) && (temp1=Arg<CNode*>(1)->GetWidthExp())) ? cMAX_N(temp0,temp1,NULL) : NULL;
8811  }
8812  case eXNOR: {
8813  CNode* temp0;
8814  CNode* temp1;
8815  CNode* temp2;
8816  return ((temp0=Arg<CNode*>(0)->GetWidthExp()) && (temp1=Arg<CNode*>(1)->GetWidthExp())) ? cMAX_N(temp0,temp1,NULL) : NULL;
8817  }
8818  case eSYSTASK_CALL: {
8819  CNode* temp0;
8820  CNode* temp1;
8821  CNode* temp2;
8822  return Systask::WidthExp(Arg<CSymbol*>(0),Arg<CNode*>(1));
8823  }
8824  case eFUNCTION_CALL: {
8825  CNode* temp0;
8826  CNode* temp1;
8827  CNode* temp2;
8828  return CFunction::WidthExp(Arg<CSymbol*>(0),Arg<CNode*>(1),Arg<CScope*>(2));
8829  }
8830  case eARRAY: {
8831  CNode* temp0;
8832  CNode* temp1;
8833  CNode* temp2;
8834  return Array::WidthExp(Arg<CNode*>(0),Arg<CNode*>(1));
8835  }
8836  case eNET_REF: {
8837  CNode* temp0;
8838  CNode* temp1;
8839  CNode* temp2;
8840  return Arg<CNet*>(0)->GetWidthExp();
8841  }
8842  case eVAR_REF: {
8843  CNode* temp0;
8844  CNode* temp1;
8845  CNode* temp2;
8846  return Arg<CVar*>(0)->GetWidthExp();
8847  }
8848  case ePARAM_REF: {
8849  CNode* temp0;
8850  CNode* temp1;
8851  CNode* temp2;
8852  return Arg<CParam*>(0)->GetWidthExp();
8853  }
8854  case ePORT_REF: {
8855  CNode* temp0;
8856  CNode* temp1;
8857  CNode* temp2;
8858  return Arg<CPortDir*>(0)->GetWidthExp();
8859  }
8860  case eFWD_REF: {
8861  CNode* temp0;
8862  CNode* temp1;
8863  CNode* temp2;
8864  return Arg<CFref*>(0)->GetWidthExp();
8865  }
8866  case eGENVAR_REF: {
8867  CNode* temp0;
8868  CNode* temp1;
8869  CNode* temp2;
8870  return Arg<CGenvar*>(0)->GetWidthExp();
8871  }
8872  case eENUM_REF: {
8873  CNode* temp0;
8874  CNode* temp1;
8875  CNode* temp2;
8876  return Arg<CEnum*>(0)->GetWidthExp();
8877  }
8878  case eTYPE_REF: {
8879  CNode* temp0;
8880  CNode* temp1;
8881  CNode* temp2;
8882  return cINT32(32);
8883  }
8884  case eRANGE: {
8885  CNode* temp0;
8886  CNode* temp1;
8887  CNode* temp2;
8888  return (1 && 1) ? cABSDIFFPLUS1_N(Arg<CNode*>(0)->Clone(),Arg<CNode*>(1)->Clone(),NULL) : NULL;
8889  }
8890  case eSLICE: {
8891  CNode* temp0;
8892  CNode* temp1;
8893  CNode* temp2;
8894  return (1 && 1) ? cABSDIFFPLUS1_N(Arg<CNode*>(0)->Clone(),Arg<CNode*>(1)->Clone(),NULL) : NULL;
8895  }
8896  case ePSLICE: {
8897  CNode* temp0;
8898  CNode* temp1;
8899  CNode* temp2;
8900  return Arg<CNode*>(1);
8901  }
8902  case eMSLICE: {
8903  CNode* temp0;
8904  CNode* temp1;
8905  CNode* temp2;
8906  return Arg<CNode*>(1);
8907  }
8908  case eCVRI: {
8909  CNode* temp0;
8910  CNode* temp1;
8911  CNode* temp2;
8912  return cINT32(32);
8913  }
8914  case eCVIR: {
8915  CNode* temp0;
8916  CNode* temp1;
8917  CNode* temp2;
8918  return NULL;
8919  }
8920  case eREP: {
8921  CNode* temp0;
8922  CNode* temp1;
8923  CNode* temp2;
8924  return (1 && (temp1=Arg<CNode*>(1)->GetWidthExp())) ? cMUL_N(Arg<CNode*>(0)->Clone(),temp1,NULL) : NULL;
8925  }
8926  case eCAT: {
8927  CNode* temp0;
8928  CNode* temp1;
8929  CNode* temp2;
8930  return ((temp0=Arg<CNode*>(0)->GetWidthExp()) && (temp1=Arg<CNode*>(1)->GetWidthExp())) ? cADD_N(temp0,temp1,NULL) : NULL;
8931  }
8932  case eUCAT: {
8933  CNode* temp0;
8934  CNode* temp1;
8935  CNode* temp2;
8936  return Arg<CNode*>(0)->GetWidthExp();
8937  }
8938  case eCOM: {
8939  CNode* temp0;
8940  CNode* temp1;
8941  CNode* temp2;
8942  return Arg<CNode*>(0)->GetWidthExp();
8943  }
8944  case eNEG: {
8945  CNode* temp0;
8946  CNode* temp1;
8947  CNode* temp2;
8948  return Arg<CNode*>(0)->GetWidthExp();
8949  }
8950  case ePLUS: {
8951  CNode* temp0;
8952  CNode* temp1;
8953  CNode* temp2;
8954  return Arg<CNode*>(0)->GetWidthExp();
8955  }
8956  case eNOT: {
8957  CNode* temp0;
8958  CNode* temp1;
8959  CNode* temp2;
8960  return cINT32(1);
8961  }
8962  case eGT: {
8963  CNode* temp0;
8964  CNode* temp1;
8965  CNode* temp2;
8966  return cINT32(1);
8967  }
8968  case eGE: {
8969  CNode* temp0;
8970  CNode* temp1;
8971  CNode* temp2;
8972  return cINT32(1);
8973  }
8974  case eLT: {
8975  CNode* temp0;
8976  CNode* temp1;
8977  CNode* temp2;
8978  return cINT32(1);
8979  }
8980  case eLE: {
8981  CNode* temp0;
8982  CNode* temp1;
8983  CNode* temp2;
8984  return cINT32(1);
8985  }
8986  case eLAND: {
8987  CNode* temp0;
8988  CNode* temp1;
8989  CNode* temp2;
8990  return cINT32(1);
8991  }
8992  case eLOR: {
8993  CNode* temp0;
8994  CNode* temp1;
8995  CNode* temp2;
8996  return cINT32(1);
8997  }
8998  case eCEQ: {
8999  CNode* temp0;
9000  CNode* temp1;
9001  CNode* temp2;
9002  return cINT32(1);
9003  }
9004  case eCNE: {
9005  CNode* temp0;
9006  CNode* temp1;
9007  CNode* temp2;
9008  return cINT32(1);
9009  }
9010  case eEQ: {
9011  CNode* temp0;
9012  CNode* temp1;
9013  CNode* temp2;
9014  return cINT32(1);
9015  }
9016  case eNE: {
9017  CNode* temp0;
9018  CNode* temp1;
9019  CNode* temp2;
9020  return cINT32(1);
9021  }
9022  case eRAND: {
9023  CNode* temp0;
9024  CNode* temp1;
9025  CNode* temp2;
9026  return cINT32(1);
9027  }
9028  case eRNAND: {
9029  CNode* temp0;
9030  CNode* temp1;
9031  CNode* temp2;
9032  return cINT32(1);
9033  }
9034  case eROR: {
9035  CNode* temp0;
9036  CNode* temp1;
9037  CNode* temp2;
9038  return cINT32(1);
9039  }
9040  case eRNOR: {
9041  CNode* temp0;
9042  CNode* temp1;
9043  CNode* temp2;
9044  return cINT32(1);
9045  }
9046  case eRXOR: {
9047  CNode* temp0;
9048  CNode* temp1;
9049  CNode* temp2;
9050  return cINT32(1);
9051  }
9052  case eRXNOR: {
9053  CNode* temp0;
9054  CNode* temp1;
9055  CNode* temp2;
9056  return cINT32(1);
9057  }
9058  case eHOOK: {
9059  CNode* temp0;
9060  CNode* temp1;
9061  CNode* temp2;
9062  return ((temp1=Arg<CNode*>(1)->GetWidthExp()) && (temp2=Arg<CNode*>(2)->GetWidthExp())) ? cMAX_N(temp1,temp2,NULL) : NULL;
9063  }
9064  case eMTM: {
9065  CNode* temp0;
9066  CNode* temp1;
9067  CNode* temp2;
9068  return ((temp0=Arg<CNode*>(0)->GetWidthExp()) && (temp1=Arg<CNode*>(1)->GetWidthExp()) && (temp2=Arg<CNode*>(2)->GetWidthExp())) ? cMAX_N(temp0,temp1,temp2,NULL) : NULL;
9069  }
9070  case eEXTERNAL_REF: {
9071  CNode* temp0;
9072  CNode* temp1;
9073  CNode* temp2;
9074  return External::WidthExp(Arg<CSymbol*>(0));
9075  }
9076  case eATTRIBUTE: {
9077  CNode* temp0;
9078  CNode* temp1;
9079  CNode* temp2;
9080  return cINT32(0);
9081  }
9082  case eMACRO_EXPR: {
9083  CNode* temp0;
9084  CNode* temp1;
9085  CNode* temp2;
9086  return Arg<CNode*>(1)->GetWidthExp();
9087  }
9088  case eMEMBER: {
9089  CNode* temp0;
9090  CNode* temp1;
9091  CNode* temp2;
9092  return Member::WidthExp(Arg<CNode*>(0),Arg<CSymbol*>(1));
9093  }
9094  case ePREINC: {
9095  CNode* temp0;
9096  CNode* temp1;
9097  CNode* temp2;
9098  return Arg<CNode*>(0)->GetWidthExp();
9099  }
9100  case ePOSTINC: {
9101  CNode* temp0;
9102  CNode* temp1;
9103  CNode* temp2;
9104  return Arg<CNode*>(0)->GetWidthExp();
9105  }
9106  case ePREDEC: {
9107  CNode* temp0;
9108  CNode* temp1;
9109  CNode* temp2;
9110  return Arg<CNode*>(0)->GetWidthExp();
9111  }
9112  case ePOSTDEC: {
9113  CNode* temp0;
9114  CNode* temp1;
9115  CNode* temp2;
9116  return Arg<CNode*>(0)->GetWidthExp();
9117  }
9118  case eCAST: {
9119  CNode* temp0;
9120  CNode* temp1;
9121  CNode* temp2;
9122  return cINT32(Arg<CNode*>(0)->EvalINT32());
9123  }
9124  default:
9125  MASSERT( FALSE );
9126  return NULL;
9127  }
9128 }
9129 
9130 /************************************************
9131  IsWidthEvaluateable
9132  - return true if expression width can be evaluated
9133 **************************************************/
9134 
9136 {
9137  switch( GetOp() ) {
9138  case eERROR:
9139  return FALSE;
9140  case eVCONSTANT:
9141  return Arg<CVector*>(0)->IsWidthEvaluateable();
9142  case eRCONSTANT:
9143  return FALSE;
9144  case eELIST:
9145  return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
9146  case eWIDTH:
9147  return Arg<CNode*>(0)->IsEvaluateable();
9148  case eSUB:
9149  return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
9150  case eMUL:
9151  return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
9152  case eDIV:
9153  return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
9154  case ePOW:
9155  return Arg<CNode*>(0)->IsWidthEvaluateable();
9156  case eADD:
9157  return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
9158  case eLSH:
9159  return Arg<CNode*>(0)->IsWidthEvaluateable();
9160  case eRSH:
9161  return Arg<CNode*>(0)->IsWidthEvaluateable();
9162  case eLSHA:
9163  return Arg<CNode*>(0)->IsWidthEvaluateable();
9164  case eRSHA:
9165  return Arg<CNode*>(0)->IsWidthEvaluateable();
9166  case eMOD:
9167  return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
9168  case eOR:
9169  return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
9170  case eAND:
9171  return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
9172  case eANDANDAND:
9173  return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
9174  case eXOR:
9175  return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
9176  case eXNOR:
9177  return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
9178  case eSYSTASK_CALL:
9179  return Systask::WidthEvaluateable(Arg<CSymbol*>(0),Arg<CNode*>(1));
9180  case eFUNCTION_CALL:
9181  return CFunction::WidthEvaluateable(Arg<CSymbol*>(0),Arg<CNode*>(1),Arg<CScope*>(2));
9182  case eARRAY:
9183  return Array::WidthEvaluateable(Arg<CNode*>(0),Arg<CNode*>(1));
9184  case eNET_REF:
9185  return Arg<CNet*>(0)->IsWidthEvaluateable();
9186  case eVAR_REF:
9187  return Arg<CVar*>(0)->IsWidthEvaluateable();
9188  case ePARAM_REF:
9189  return Arg<CParam*>(0)->IsWidthEvaluateable();
9190  case ePORT_REF:
9191  return Arg<CPortDir*>(0)->IsWidthEvaluateable();
9192  case eFWD_REF:
9193  return Arg<CFref*>(0)->IsWidthEvaluateable();
9194  case eGENVAR_REF:
9195  return Arg<CGenvar*>(0)->IsWidthEvaluateable();
9196  case eENUM_REF:
9197  return Arg<CEnum*>(0)->IsWidthEvaluateable();
9198  case eTYPE_REF:
9199  return TRUE;
9200  case eRANGE:
9201  return Arg<CNode*>(0)->IsEvaluateable() && Arg<CNode*>(1)->IsEvaluateable();
9202  case eSLICE:
9203  return Arg<CNode*>(0)->IsEvaluateable() && Arg<CNode*>(1)->IsEvaluateable();
9204  case ePSLICE:
9205  return Arg<CNode*>(1)->IsEvaluateable();
9206  case eMSLICE:
9207  return Arg<CNode*>(1)->IsEvaluateable();
9208  case eCVRI:
9209  return TRUE;
9210  case eCVIR:
9211  return FALSE;
9212  case eREP:
9213  return Arg<CNode*>(0)->IsEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
9214  case eCAT:
9215  return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
9216  case eUCAT:
9217  return Arg<CNode*>(0)->IsWidthEvaluateable();
9218  case eCOM:
9219  return Arg<CNode*>(0)->IsWidthEvaluateable();
9220  case eNEG:
9221  return Arg<CNode*>(0)->IsWidthEvaluateable();
9222  case ePLUS:
9223  return Arg<CNode*>(0)->IsWidthEvaluateable();
9224  case eNOT:
9225  return TRUE;
9226  case eGT:
9227  return TRUE;
9228  case eGE:
9229  return TRUE;
9230  case eLT:
9231  return TRUE;
9232  case eLE:
9233  return TRUE;
9234  case eLAND:
9235  return TRUE;
9236  case eLOR:
9237  return TRUE;
9238  case eCEQ:
9239  return TRUE;
9240  case eCNE:
9241  return TRUE;
9242  case eEQ:
9243  return TRUE;
9244  case eNE:
9245  return TRUE;
9246  case eRAND:
9247  return TRUE;
9248  case eRNAND:
9249  return TRUE;
9250  case eROR:
9251  return TRUE;
9252  case eRNOR:
9253  return TRUE;
9254  case eRXOR:
9255  return TRUE;
9256  case eRXNOR:
9257  return TRUE;
9258  case eHOOK:
9259  return Arg<CNode*>(1)->IsWidthEvaluateable() && Arg<CNode*>(2)->IsWidthEvaluateable();
9260  case eMTM:
9261  return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable() && Arg<CNode*>(2)->IsWidthEvaluateable();
9262  case eEXTERNAL_REF:
9263  return External::WidthEvaluateable(Arg<CSymbol*>(0));
9264  case eATTRIBUTE:
9265  return TRUE;
9266  case eMACRO_EXPR:
9267  return Arg<CNode*>(1)->IsWidthEvaluateable();
9268  case eMEMBER:
9269  return Member::WidthEvaluateable(Arg<CNode*>(0),Arg<CSymbol*>(1));
9270  case ePREINC:
9271  return Arg<CNode*>(0)->IsWidthEvaluateable();
9272  case ePOSTINC:
9273  return Arg<CNode*>(0)->IsWidthEvaluateable();
9274  case ePREDEC:
9275  return Arg<CNode*>(0)->IsWidthEvaluateable();
9276  case ePOSTDEC:
9277  return Arg<CNode*>(0)->IsWidthEvaluateable();
9278  case eCAST:
9279  return Arg<CNode*>(0)->IsEvaluateable();
9280  default:
9281  MASSERT( FALSE );
9282  return 0;
9283  }
9284 }
9285 
9286 /************************************************
9287  IsNonX
9288  - return true if expression cannot be X(or Z)
9289  exclude any variable with attribute
9290  specified by exclude and optionally integers.
9291 **************************************************/
9292 
9293 int CNode::IsNonX( int integerIsNonX, char* exclude )
9294 {
9295  switch( GetOp() ) {
9296  case eERROR:
9297  return FALSE;
9298  case eVCONSTANT:
9299  return !Arg<CVector*>(0)->HasXZ();
9300  case eRCONSTANT:
9301  return TRUE;
9302  case eELIST:
9303  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9304  case eWIDTH:
9305  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9306  case eSUB:
9307  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9308  case eMUL:
9309  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9310  case eDIV:
9311  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9312  case ePOW:
9313  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9314  case eADD:
9315  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9316  case eLSH:
9317  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9318  case eRSH:
9319  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9320  case eLSHA:
9321  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9322  case eRSHA:
9323  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9324  case eMOD:
9325  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9326  case eOR:
9327  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9328  case eAND:
9329  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9330  case eANDANDAND:
9331  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9332  case eXOR:
9333  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9334  case eXNOR:
9335  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9336  case eSYSTASK_CALL:
9337  return FALSE;
9338  case eFUNCTION_CALL:
9339  return FALSE;
9340  case eARRAY:
9341  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9342  case eNET_REF:
9343  return Arg<CDecl*>(0)->HasAttribute( exclude ) ||
9344 
9345  (integerIsNonX && Arg<CDecl*>(0)->GetDataType()->GetVarDataType() == eINT);
9346  case eVAR_REF:
9347  return Arg<CDecl*>(0)->GetDataType()->GetTwoState() ||
9348 
9349  Arg<CDecl*>(0)->GetNodeType() == eR ||
9350 
9351  Arg<CDecl*>(0)->HasAttribute( exclude ) ||
9352 
9353  (integerIsNonX && Arg<CDecl*>(0)->GetDataType()->GetVarDataType() == eINTEGER);
9354  case ePARAM_REF:
9355  return TRUE;
9356  case ePORT_REF:
9357  return Arg<CDecl*>(0)->HasAttribute( exclude ) ||
9358 
9359  (integerIsNonX && Arg<CDecl*>(0)->GetDataType()->GetVarDataType() == eINT);
9360  case eFWD_REF:
9361  return FALSE;
9362  case eGENVAR_REF:
9363  return TRUE;
9364  case eENUM_REF:
9365  return Arg<CEnum*>(0)->GetExpression()->IsNonX( integerIsNonX, exclude );
9366  case eTYPE_REF:
9367  return TRUE;
9368  case eRANGE:
9369  return FALSE;
9370  case eSLICE:
9371  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9372  case ePSLICE:
9373  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9374  case eMSLICE:
9375  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9376  case eCVRI:
9377  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9378  case eCVIR:
9379  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9380  case eREP:
9381  return Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9382  case eCAT:
9383  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9384  case eUCAT:
9385  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9386  case eCOM:
9387  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9388  case eNEG:
9389  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9390  case ePLUS:
9391  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9392  case eNOT:
9393  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9394  case eGT:
9395  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9396  case eGE:
9397  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9398  case eLT:
9399  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9400  case eLE:
9401  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9402  case eLAND:
9403  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9404  case eLOR:
9405  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9406  case eCEQ:
9407  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9408  case eCNE:
9409  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9410  case eEQ:
9411  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9412  case eNE:
9413  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9414  case eRAND:
9415  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9416  case eRNAND:
9417  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9418  case eROR:
9419  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9420  case eRNOR:
9421  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9422  case eRXOR:
9423  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9424  case eRXNOR:
9425  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9426  case eHOOK:
9427  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(2)->IsNonX( integerIsNonX, exclude );
9428  case ePOSEDGE:
9429  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9430  case eNEGEDGE:
9431  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9432  case eEVOR:
9433  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9434  case eMTM:
9435  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(2)->IsNonX( integerIsNonX, exclude );
9436  case eEXTERNAL_REF:
9437  return FALSE;
9438  case eMACRO_EXPR:
9439  return Arg<CNode*>(1) ? Arg<CNode*>(1)->IsNonX(integerIsNonX, exclude) : FALSE;
9440  case eMEMBER:
9441  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9442  case ePREINC:
9443  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9444  case ePOSTINC:
9445  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9446  case ePREDEC:
9447  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9448  case ePOSTDEC:
9449  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9450  case eCAST:
9451  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9452  default:
9453  MASSERT( FALSE );
9454  return 0;
9455  }
9456 }
9457 
9458 /***********************************************
9459  Clone
9460  - clone a copy of this tree use
9461  stack)for storage
9462 ************************************************/
9463 
9465 {
9466  int nodeMask = 0;
9467  switch( GetOp() ) {
9468  case eERROR:
9469  nodeMask = 0;
9470  break;
9471  case eVCONSTANT:
9472  nodeMask = 0;
9473  break;
9474  case eRCONSTANT:
9475  nodeMask = 0;
9476  break;
9477  case eCOMMENT:
9478  nodeMask = 0;
9479  break;
9480  case eVRQ:
9481  nodeMask = 0;
9482  break;
9483  case ePRAGMA:
9484  nodeMask = 0;
9485  break;
9486  case eELIST:
9487  nodeMask = 3;
9488  break;
9489  case eWIDTH:
9490  nodeMask = 3;
9491  break;
9492  case eNOP:
9493  nodeMask = 0;
9494  break;
9495  case eSUB:
9496  nodeMask = 3;
9497  break;
9498  case eMUL:
9499  nodeMask = 3;
9500  break;
9501  case eDIV:
9502  nodeMask = 3;
9503  break;
9504  case ePOW:
9505  nodeMask = 3;
9506  break;
9507  case eADD:
9508  nodeMask = 3;
9509  break;
9510  case eLSH:
9511  nodeMask = 3;
9512  break;
9513  case eRSH:
9514  nodeMask = 3;
9515  break;
9516  case eLSHA:
9517  nodeMask = 3;
9518  break;
9519  case eRSHA:
9520  nodeMask = 3;
9521  break;
9522  case eMOD:
9523  nodeMask = 3;
9524  break;
9525  case eOR:
9526  nodeMask = 3;
9527  break;
9528  case eAND:
9529  nodeMask = 3;
9530  break;
9531  case eANDANDAND:
9532  nodeMask = 3;
9533  break;
9534  case eXOR:
9535  nodeMask = 3;
9536  break;
9537  case eXNOR:
9538  nodeMask = 3;
9539  break;
9540  case eINSTANCE_REF:
9541  nodeMask = 0;
9542  break;
9543  case eGATE_REF:
9544  nodeMask = 0;
9545  break;
9546  case eTASK_ENABLE:
9547  nodeMask = 2;
9548  break;
9549  case eSYSTASK_CALL:
9550  nodeMask = 2;
9551  break;
9552  case eTIMING_CALL:
9553  nodeMask = 2;
9554  break;
9555  case eFUNCTION_CALL:
9556  nodeMask = 2;
9557  break;
9558  case eARRAY:
9559  nodeMask = 3;
9560  break;
9561  case eNET_REF:
9562  nodeMask = 0;
9563  break;
9564  case eVAR_REF:
9565  nodeMask = 0;
9566  break;
9567  case ePARAM_REF:
9568  nodeMask = 0;
9569  break;
9570  case ePORT_REF:
9571  nodeMask = 0;
9572  break;
9573  case eFWD_REF:
9574  nodeMask = 0;
9575  break;
9576  case eGENVAR_REF:
9577  nodeMask = 0;
9578  break;
9579  case eENUM_REF:
9580  nodeMask = 0;
9581  break;
9582  case eTYPE_REF:
9583  nodeMask = 0;
9584  break;
9585  case eNET_DECL:
9586  nodeMask = 2;
9587  break;
9588  case eVAR_DECL:
9589  nodeMask = 2;
9590  break;
9591  case ePARAM_DECL:
9592  nodeMask = 0;
9593  break;
9594  case eSPECPARAM_DECL:
9595  nodeMask = 0;
9596  break;
9597  case ePORT_DECL:
9598  nodeMask = 0;
9599  break;
9600  case eGENVAR_DECL:
9601  nodeMask = 0;
9602  break;
9603  case eTYPEDEF_DECL:
9604  nodeMask = 0;
9605  break;
9606  case eLIST:
9607  nodeMask = 3;
9608  break;
9609  case eRANGE:
9610  nodeMask = 3;
9611  break;
9612  case eSLICE:
9613  nodeMask = 3;
9614  break;
9615  case ePSLICE:
9616  nodeMask = 3;
9617  break;
9618  case eMSLICE:
9619  nodeMask = 3;
9620  break;
9621  case eCVRI:
9622  nodeMask = 1;
9623  break;
9624  case eCVIR:
9625  nodeMask = 1;
9626  break;
9627  case eREP:
9628  nodeMask = 3;
9629  break;
9630  case eCAT:
9631  nodeMask = 3;
9632  break;
9633  case eUCAT:
9634  nodeMask = 1;
9635  break;
9636  case eCOM:
9637  nodeMask = 1;
9638  break;
9639  case eNEG:
9640  nodeMask = 1;
9641  break;
9642  case ePLUS:
9643  nodeMask = 1;
9644  break;
9645  case eNOT:
9646  nodeMask = 1;
9647  break;
9648  case eGT:
9649  nodeMask = 3;
9650  break;
9651  case eGE:
9652  nodeMask = 3;
9653  break;
9654  case eLT:
9655  nodeMask = 3;
9656  break;
9657  case eLE:
9658  nodeMask = 3;
9659  break;
9660  case eLAND:
9661  nodeMask = 3;
9662  break;
9663  case eLOR:
9664  nodeMask = 3;
9665  break;
9666  case eCEQ:
9667  nodeMask = 3;
9668  break;
9669  case eCNE:
9670  nodeMask = 3;
9671  break;
9672  case eEQ:
9673  nodeMask = 3;
9674  break;
9675  case eNE:
9676  nodeMask = 3;
9677  break;
9678  case eRAND:
9679  nodeMask = 1;
9680  break;
9681  case eRNAND:
9682  nodeMask = 1;
9683  break;
9684  case eROR:
9685  nodeMask = 1;
9686  break;
9687  case eRNOR:
9688  nodeMask = 1;
9689  break;
9690  case eRXOR:
9691  nodeMask = 1;
9692  break;
9693  case eRXNOR:
9694  nodeMask = 1;
9695  break;
9696  case eHOOK:
9697  nodeMask = 7;
9698  break;
9699  case eINIT:
9700  nodeMask = 1;
9701  break;
9702  case eALWAYS:
9703  nodeMask = 1;
9704  break;
9705  case eALWAYS_LATCH:
9706  nodeMask = 1;
9707  break;
9708  case eALWAYS_FF:
9709  nodeMask = 1;
9710  break;
9711  case eALWAYS_COMB:
9712  nodeMask = 1;
9713  break;
9714  case eEVENT:
9715  nodeMask = 3;
9716  break;
9717  case eBLOCK_REF:
9718  nodeMask = 2;
9719  break;
9720  case eSPECIFY_REF:
9721  nodeMask = 2;
9722  break;
9723  case eASSIGN:
9724  nodeMask = 7;
9725  break;
9726  case eGASSIGN:
9727  nodeMask = 6;
9728  break;
9729  case eADD_ASSIGN:
9730  nodeMask = 7;
9731  break;
9732  case eSUB_ASSIGN:
9733  nodeMask = 7;
9734  break;
9735  case eMUL_ASSIGN:
9736  nodeMask = 7;
9737  break;
9738  case eDIV_ASSIGN:
9739  nodeMask = 7;
9740  break;
9741  case eMOD_ASSIGN:
9742  nodeMask = 7;
9743  break;
9744  case eAND_ASSIGN:
9745  nodeMask = 7;
9746  break;
9747  case eOR_ASSIGN:
9748  nodeMask = 7;
9749  break;
9750  case eXOR_ASSIGN:
9751  nodeMask = 7;
9752  break;
9753  case eLSH_ASSIGN:
9754  nodeMask = 7;
9755  break;
9756  case eRSH_ASSIGN:
9757  nodeMask = 7;
9758  break;
9759  case eLSHA_ASSIGN:
9760  nodeMask = 7;
9761  break;
9762  case eRSHA_ASSIGN:
9763  nodeMask = 7;
9764  break;
9765  case eFORCE:
9766  nodeMask = 3;
9767  break;
9768  case eRELEASE:
9769  nodeMask = 1;
9770  break;
9771  case eNBASSIGN:
9772  nodeMask = 7;
9773  break;
9774  case ePOSEDGE:
9775  nodeMask = 1;
9776  break;
9777  case eNEGEDGE:
9778  nodeMask = 1;
9779  break;
9780  case eEDGE:
9781  nodeMask = 1;
9782  break;
9783  case eEVOR:
9784  nodeMask = 3;
9785  break;
9786  case eDELAY:
9787  nodeMask = 3;
9788  break;
9789  case eMTM:
9790  nodeMask = 7;
9791  break;
9792  case eIF:
9793  nodeMask = 7;
9794  break;
9795  case eFOREVER:
9796  nodeMask = 1;
9797  break;
9798  case eREPEAT:
9799  nodeMask = 3;
9800  break;
9801  case eWHILE:
9802  nodeMask = 3;
9803  break;
9804  case eWAIT:
9805  nodeMask = 3;
9806  break;
9807  case eFOR:
9808  nodeMask = 15;
9809  break;
9810  case eCASE:
9811  nodeMask = 3;
9812  break;
9813  case eCASEX:
9814  nodeMask = 3;
9815  break;
9816  case eCASEZ:
9817  nodeMask = 3;
9818  break;
9819  case eCASEITEM:
9820  nodeMask = 3;
9821  break;
9822  case eCASSIGN:
9823  nodeMask = 14;
9824  break;
9825  case eARG:
9826  nodeMask = 2;
9827  break;
9828  case eIMPORT:
9829  nodeMask = 0;
9830  break;
9831  case eFUNCTION_DEF:
9832  nodeMask = 0;
9833  break;
9834  case eMODULE_DEF:
9835  nodeMask = 0;
9836  break;
9837  case ePACKAGE_DEF:
9838  nodeMask = 0;
9839  break;
9840  case eREPEAT_CONTROL:
9841  nodeMask = 3;
9842  break;
9843  case eDELAY_CONTROL:
9844  nodeMask = 1;
9845  break;
9846  case eEVENT_CONTROL:
9847  nodeMask = 1;
9848  break;
9849  case eEXTERNAL_REF:
9850  nodeMask = 0;
9851  break;
9852  case ePORT_DEF:
9853  nodeMask = 0;
9854  break;
9855  case eDEFPARAM:
9856  nodeMask = 3;
9857  break;
9858  case ePATH:
9859  nodeMask = 82;
9860  break;
9861  case ePATH_ASSIGN:
9862  nodeMask = 7;
9863  break;
9864  case eIFNONE_PATH_ASSIGN:
9865  nodeMask = 3;
9866  break;
9867  case eTRIGGER:
9868  nodeMask = 1;
9869  break;
9870  case ePASSIGN:
9871  nodeMask = 3;
9872  break;
9873  case eDEASSIGN:
9874  nodeMask = 1;
9875  break;
9876  case eDISABLE:
9877  nodeMask = 0;
9878  break;
9879  case eATTRIBUTE:
9880  nodeMask = 0;
9881  break;
9882  case eGIF:
9883  nodeMask = 7;
9884  break;
9885  case eGFOR:
9886  nodeMask = 15;
9887  break;
9888  case eGCASE:
9889  nodeMask = 3;
9890  break;
9891  case eTABLE:
9892  nodeMask = 1;
9893  break;
9894  case eTABLE_ENTRY:
9895  nodeMask = 1;
9896  break;
9897  case eTABLE_SYMBOL:
9898  nodeMask = 0;
9899  break;
9900  case ePORTLIST_END:
9901  nodeMask = 0;
9902  break;
9903  case eMACRO_EXPR:
9904  nodeMask = 2;
9905  break;
9906  case eENUM_SPEC:
9907  nodeMask = 6;
9908  break;
9909  case eMEMBER:
9910  nodeMask = 1;
9911  break;
9912  case eRETURN:
9913  nodeMask = 1;
9914  break;
9915  case ePREINC:
9916  nodeMask = 1;
9917  break;
9918  case ePOSTINC:
9919  nodeMask = 1;
9920  break;
9921  case ePREDEC:
9922  nodeMask = 1;
9923  break;
9924  case ePOSTDEC:
9925  nodeMask = 1;
9926  break;
9927  case eCAST:
9928  nodeMask = 3;
9929  break;
9930  default:
9931  MASSERT( FALSE );
9932  }
9933 
9934  CNode* n = new(stack) CNode( &loc, op );
9935  n->width = width;
9936  n->type = type;
9937  n->fixedWidth = fixedWidth;
9938  if( attributes ) {
9939  n->attributes = attributes->Clone(heap);
9940  }
9941  for( int i = 0; i < ArgCount(); i++ ) {
9942  if( ((nodeMask>>i)&1) && Arg<CNode*>(i) ) {
9943  n->Arg<CNode*>(i) = Arg<CNode*>(i)->Clone(heap);
9944  } else {
9945  void* tmp = Arg<void*>(i);
9946  n->Arg<void*>(i) = tmp;
9947  }
9948  }
9949  return n;
9950 }
9951 
9952 
9953 /***********************************************
9954  PreVisit1
9955  - traverse tree, evoking
9956  parent then leaves.
9957  Callback may terminate traversal of subtree early.
9958 ************************************************/
9959 
9960 void CNode::PreVisit1( int (*func)(CNode*, void*), void* data )
9961 {
9962  if( !(*func)( this, data ) ) {
9963  return;
9964  }
9965 
9966  if( GetAttributes() ) {
9967  GetAttributes()->PreVisit1( func, data );
9968  }
9969 
9970  int nodeMask = 0;
9971  switch( GetOp() ) {
9972  case eERROR:
9973  nodeMask = 0;
9974  break;
9975  case eVCONSTANT:
9976  nodeMask = 1;
9977  break;
9978  case eRCONSTANT:
9979  nodeMask = 1;
9980  break;
9981  case eCOMMENT:
9982  nodeMask = 1;
9983  break;
9984  case eVRQ:
9985  nodeMask = 1;
9986  break;
9987  case ePRAGMA:
9988  nodeMask = 1;
9989  break;
9990  case eELIST:
9991  nodeMask = 0;
9992  break;
9993  case eWIDTH:
9994  nodeMask = 0;
9995  break;
9996  case eNOP:
9997  nodeMask = 0;
9998  break;
9999  case eSUB:
10000  nodeMask = 0;
10001  break;
10002  case eMUL:
10003  nodeMask = 0;
10004  break;
10005  case eDIV:
10006  nodeMask = 0;
10007  break;
10008  case ePOW:
10009  nodeMask = 0;
10010  break;
10011  case eADD:
10012  nodeMask = 0;
10013  break;
10014  case eLSH:
10015  nodeMask = 0;
10016  break;
10017  case eRSH:
10018  nodeMask = 0;
10019  break;
10020  case eLSHA:
10021  nodeMask = 0;
10022  break;
10023  case eRSHA:
10024  nodeMask = 0;
10025  break;
10026  case eMOD:
10027  nodeMask = 0;
10028  break;
10029  case eOR:
10030  nodeMask = 0;
10031  break;
10032  case eAND:
10033  nodeMask = 0;
10034  break;
10035  case eANDANDAND:
10036  nodeMask = 0;
10037  break;
10038  case eXOR:
10039  nodeMask = 0;
10040  break;
10041  case eXNOR:
10042  nodeMask = 0;
10043  break;
10044  case eINSTANCE_REF:
10045  nodeMask = 1;
10046  if(Arg<CInstance*>(0)) Arg<CInstance*>(0)->PreVisit1( func, data );
10047  break;
10048  case eGATE_REF:
10049  nodeMask = 1;
10050  if(Arg<CGate*>(0)) Arg<CGate*>(0)->PreVisit1( func, data );
10051  break;
10052  case eTASK_ENABLE:
10053  nodeMask = 1;
10054  break;
10055  case eSYSTASK_CALL:
10056  nodeMask = 1;
10057  break;
10058  case eTIMING_CALL:
10059  nodeMask = 1;
10060  break;
10061  case eFUNCTION_CALL:
10062  nodeMask = 5;
10063  break;
10064  case eARRAY:
10065  nodeMask = 0;
10066  break;
10067  case eNET_REF:
10068  return;
10069  case eVAR_REF:
10070  return;
10071  case ePARAM_REF:
10072  return;
10073  case ePORT_REF:
10074  return;
10075  case eFWD_REF:
10076  return;
10077  case eGENVAR_REF:
10078  return;
10079  case eENUM_REF:
10080  return;
10081  case eTYPE_REF:
10082  return;
10083  case eNET_DECL:
10084  nodeMask = 1;
10085  if(Arg<CNet*>(0)) Arg<CNet*>(0)->PreVisit1( func, data );
10086  break;
10087  case eVAR_DECL:
10088  nodeMask = 1;
10089  if(Arg<CVar*>(0)) Arg<CVar*>(0)->PreVisit1( func, data );
10090  break;
10091  case ePARAM_DECL:
10092  nodeMask = 1;
10093  if(Arg<CParam*>(0)) Arg<CParam*>(0)->PreVisit1( func, data );
10094  break;
10095  case eSPECPARAM_DECL:
10096  nodeMask = 1;
10097  if(Arg<CParam*>(0)) Arg<CParam*>(0)->PreVisit1( func, data );
10098  break;
10099  case ePORT_DECL:
10100  nodeMask = 1;
10101  if(Arg<CPortDir*>(0)) Arg<CPortDir*>(0)->PreVisit1( func, data );
10102  break;
10103  case eGENVAR_DECL:
10104  nodeMask = 1;
10105  if(Arg<CGenvar*>(0)) Arg<CGenvar*>(0)->PreVisit1( func, data );
10106  break;
10107  case eTYPEDEF_DECL:
10108  nodeMask = 1;
10109  if(Arg<CTypedef*>(0)) Arg<CTypedef*>(0)->PreVisit1( func, data );
10110  break;
10111  case eLIST:
10112  nodeMask = 0;
10113  break;
10114  case eRANGE:
10115  nodeMask = 0;
10116  break;
10117  case eSLICE:
10118  nodeMask = 0;
10119  break;
10120  case ePSLICE:
10121  nodeMask = 0;
10122  break;
10123  case eMSLICE:
10124  nodeMask = 0;
10125  break;
10126  case eCVRI:
10127  nodeMask = 0;
10128  break;
10129  case eCVIR:
10130  nodeMask = 0;
10131  break;
10132  case eREP:
10133  nodeMask = 0;
10134  break;
10135  case eCAT:
10136  nodeMask = 0;
10137  break;
10138  case eUCAT:
10139  nodeMask = 0;
10140  break;
10141  case eCOM:
10142  nodeMask = 0;
10143  break;
10144  case eNEG:
10145  nodeMask = 0;
10146  break;
10147  case ePLUS:
10148  nodeMask = 0;
10149  break;
10150  case eNOT:
10151  nodeMask = 0;
10152  break;
10153  case eGT:
10154  nodeMask = 0;
10155  break;
10156  case eGE:
10157  nodeMask = 0;
10158  break;
10159  case eLT:
10160  nodeMask = 0;
10161  break;
10162  case eLE:
10163  nodeMask = 0;
10164  break;
10165  case eLAND:
10166  nodeMask = 0;
10167  break;
10168  case eLOR:
10169  nodeMask = 0;
10170  break;
10171  case eCEQ:
10172  nodeMask = 0;
10173  break;
10174  case eCNE:
10175  nodeMask = 0;
10176  break;
10177  case eEQ:
10178  nodeMask = 0;
10179  break;
10180  case eNE:
10181  nodeMask = 0;
10182  break;
10183  case eRAND:
10184  nodeMask = 0;
10185  break;
10186  case eRNAND:
10187  nodeMask = 0;
10188  break;
10189  case eROR:
10190  nodeMask = 0;
10191  break;
10192  case eRNOR:
10193  nodeMask = 0;
10194  break;
10195  case eRXOR:
10196  nodeMask = 0;
10197  break;
10198  case eRXNOR:
10199  nodeMask = 0;
10200  break;
10201  case eHOOK:
10202  nodeMask = 0;
10203  break;
10204  case eINIT:
10205  nodeMask = 0;
10206  break;
10207  case eALWAYS:
10208  nodeMask = 0;
10209  break;
10210  case eALWAYS_LATCH:
10211  nodeMask = 0;
10212  break;
10213  case eALWAYS_FF:
10214  nodeMask = 0;
10215  break;
10216  case eALWAYS_COMB:
10217  nodeMask = 0;
10218  break;
10219  case eEVENT:
10220  nodeMask = 0;
10221  break;
10222  case eBLOCK_REF:
10223  nodeMask = 1;
10224  if(Arg<CBlock*>(0)) Arg<CBlock*>(0)->PreVisit1( func, data );
10225  break;
10226  case eSPECIFY_REF:
10227  nodeMask = 1;
10228  if(Arg<CSpecify*>(0)) Arg<CSpecify*>(0)->PreVisit1( func, data );
10229  break;
10230  case eASSIGN:
10231  nodeMask = 0;
10232  break;
10233  case eGASSIGN:
10234  nodeMask = 1;
10235  break;
10236  case eADD_ASSIGN:
10237  nodeMask = 0;
10238  break;
10239  case eSUB_ASSIGN:
10240  nodeMask = 0;
10241  break;
10242  case eMUL_ASSIGN:
10243  nodeMask = 0;
10244  break;
10245  case eDIV_ASSIGN:
10246  nodeMask = 0;
10247  break;
10248  case eMOD_ASSIGN:
10249  nodeMask = 0;
10250  break;
10251  case eAND_ASSIGN:
10252  nodeMask = 0;
10253  break;
10254  case eOR_ASSIGN:
10255  nodeMask = 0;
10256  break;
10257  case eXOR_ASSIGN:
10258  nodeMask = 0;
10259  break;
10260  case eLSH_ASSIGN:
10261  nodeMask = 0;
10262  break;
10263  case eRSH_ASSIGN:
10264  nodeMask = 0;
10265  break;
10266  case eLSHA_ASSIGN:
10267  nodeMask = 0;
10268  break;
10269  case eRSHA_ASSIGN:
10270  nodeMask = 0;
10271  break;
10272  case eFORCE:
10273  nodeMask = 0;
10274  break;
10275  case eRELEASE:
10276  nodeMask = 0;
10277  break;
10278  case eNBASSIGN:
10279  nodeMask = 0;
10280  break;
10281  case ePOSEDGE:
10282  nodeMask = 0;
10283  break;
10284  case eNEGEDGE:
10285  nodeMask = 0;
10286  break;
10287  case eEDGE:
10288  nodeMask = 2;
10289  break;
10290  case eEVOR:
10291  nodeMask = 0;
10292  break;
10293  case eDELAY:
10294  nodeMask = 0;
10295  break;
10296  case eMTM:
10297  nodeMask = 0;
10298  break;
10299  case eIF:
10300  nodeMask = 0;
10301  break;
10302  case eFOREVER:
10303  nodeMask = 0;
10304  break;
10305  case eREPEAT:
10306  nodeMask = 0;
10307  break;
10308  case eWHILE:
10309  nodeMask = 0;
10310  break;
10311  case eWAIT:
10312  nodeMask = 0;
10313  break;
10314  case eFOR:
10315  nodeMask = 0;
10316  break;
10317  case eCASE:
10318  nodeMask = 0;
10319  break;
10320  case eCASEX:
10321  nodeMask = 0;
10322  break;
10323  case eCASEZ:
10324  nodeMask = 0;
10325  break;
10326  case eCASEITEM:
10327  nodeMask = 0;
10328  break;
10329  case eCASSIGN:
10330  nodeMask = 1;
10331  break;
10332  case eARG:
10333  nodeMask = 1;
10334  break;
10335  case eIMPORT:
10336  nodeMask = 1;
10337  break;
10338  case eFUNCTION_DEF:
10339  nodeMask = 1;
10340  if(Arg<CFunction*>(0)) Arg<CFunction*>(0)->PreVisit1( func, data );
10341  break;
10342  case eMODULE_DEF:
10343  nodeMask = 1;
10344  if(Arg<CModule*>(0)) Arg<CModule*>(0)->PreVisit1( func, data );
10345  break;
10346  case ePACKAGE_DEF:
10347  nodeMask = 1;
10348  if(Arg<CPackage*>(0)) Arg<CPackage*>(0)->PreVisit1( func, data );
10349  break;
10350  case eREPEAT_CONTROL:
10351  nodeMask = 0;
10352  break;
10353  case eDELAY_CONTROL:
10354  nodeMask = 0;
10355  break;
10356  case eEVENT_CONTROL:
10357  nodeMask = 0;
10358  break;
10359  case eEXTERNAL_REF:
10360  nodeMask = 1;
10361  break;
10362  case ePORT_DEF:
10363  nodeMask = 1;
10364  if(Arg<CPort*>(0)) Arg<CPort*>(0)->PreVisit1( func, data );
10365  break;
10366  case eDEFPARAM:
10367  nodeMask = 0;
10368  break;
10369  case ePATH:
10370  nodeMask = 45;
10371  break;
10372  case ePATH_ASSIGN:
10373  nodeMask = 0;
10374  break;
10375  case eIFNONE_PATH_ASSIGN:
10376  nodeMask = 0;
10377  break;
10378  case eTRIGGER:
10379  nodeMask = 0;
10380  break;
10381  case ePASSIGN:
10382  nodeMask = 0;
10383  break;
10384  case eDEASSIGN:
10385  nodeMask = 0;
10386  break;
10387  case eDISABLE:
10388  nodeMask = 1;
10389  break;
10390  case eATTRIBUTE:
10391  nodeMask = 1;
10392  if(Arg<CAttr*>(0)) Arg<CAttr*>(0)->PreVisit1( func, data );
10393  break;
10394  case eGIF:
10395  nodeMask = 0;
10396  break;
10397  case eGFOR:
10398  nodeMask = 0;
10399  break;
10400  case eGCASE:
10401  nodeMask = 0;
10402  break;
10403  case eTABLE:
10404  nodeMask = 0;
10405  break;
10406  case eTABLE_ENTRY:
10407  nodeMask = 0;
10408  break;
10409  case eTABLE_SYMBOL:
10410  nodeMask = 1;
10411  break;
10412  case ePORTLIST_END:
10413  nodeMask = 0;
10414  break;
10415  case eMACRO_EXPR:
10416  nodeMask = 1;
10417  break;
10418  case eENUM_SPEC:
10419  nodeMask = 1;
10420  break;
10421  case eMEMBER:
10422  nodeMask = 2;
10423  break;
10424  case eRETURN:
10425  nodeMask = 0;
10426  break;
10427  case ePREINC:
10428  nodeMask = 0;
10429  break;
10430  case ePOSTINC:
10431  nodeMask = 0;
10432  break;
10433  case ePREDEC:
10434  nodeMask = 0;
10435  break;
10436  case ePOSTDEC:
10437  nodeMask = 0;
10438  break;
10439  case eCAST:
10440  nodeMask = 0;
10441  break;
10442  }
10443 
10444  /*
10445  * special case LIST nodes for tail recursion optimizations
10446  */
10447  if( GetOp() != eLIST ) {
10448  for( int i = 0; i < ArgCount(); i++ ) {
10449  if( Arg<CNode*>(i) && !((nodeMask>>i)&1) ) Arg<CNode*>(i)->PreVisit1( func, data );
10450  }
10451  } else {
10452  CNode* n = this;
10453  while( 1 ) {
10454  if( n->Arg<CNode*>(0) ) {
10455  n->Arg<CNode*>(0)->PreVisit1( func, data );
10456  }
10457  if( !n->Arg<CNode*>(1) || n->Arg<CNode*>(1)->GetOp() != eLIST ) {
10458  break;
10459  }
10460  n = n->Arg<CNode*>(1);
10461  if( !(*func)( n, data ) ) {
10462  return;
10463  }
10464  if( n->GetAttributes() ) {
10465  n->GetAttributes()->PreVisit1( func, data );
10466  }
10467  }
10468  if( n->Arg<CNode*>(1) ) {
10469  n->Arg<CNode*>(1)->PreVisit1( func, data );
10470  }
10471  }
10472 }
10473 
10474 
10475 /***********************************************
10476  PostVisit1
10477  - traverse tree, evoking
10478  leaves then parent.
10479 ************************************************/
10480 void CNode::PostVisit1( void (*func)(CNode*, void*), void* data )
10481 {
10482  if( GetAttributes() ) {
10483  GetAttributes()->PostVisit1( func, data );
10484  }
10485 
10486  int nodeMask = 0;
10487  switch( GetOp() ) {
10488  case eERROR:
10489  nodeMask = 0;
10490  break;
10491  case eVCONSTANT:
10492  nodeMask = 1;
10493  break;
10494  case eRCONSTANT:
10495  nodeMask = 1;
10496  break;
10497  case eCOMMENT:
10498  nodeMask = 1;
10499  break;
10500  case eVRQ:
10501  nodeMask = 1;
10502  break;
10503  case ePRAGMA:
10504  nodeMask = 1;
10505  break;
10506  case eELIST:
10507  nodeMask = 0;
10508  break;
10509  case eWIDTH:
10510  nodeMask = 0;
10511  break;
10512  case eNOP:
10513  nodeMask = 0;
10514  break;
10515  case eSUB:
10516  nodeMask = 0;
10517  break;
10518  case eMUL:
10519  nodeMask = 0;
10520  break;
10521  case eDIV:
10522  nodeMask = 0;
10523  break;
10524  case ePOW:
10525  nodeMask = 0;
10526  break;
10527  case eADD:
10528  nodeMask = 0;
10529  break;
10530  case eLSH:
10531  nodeMask = 0;
10532  break;
10533  case eRSH:
10534  nodeMask = 0;
10535  break;
10536  case eLSHA:
10537  nodeMask = 0;
10538  break;
10539  case eRSHA:
10540  nodeMask = 0;
10541  break;
10542  case eMOD:
10543  nodeMask = 0;
10544  break;
10545  case eOR:
10546  nodeMask = 0;
10547  break;
10548  case eAND:
10549  nodeMask = 0;
10550  break;
10551  case eANDANDAND:
10552  nodeMask = 0;
10553  break;
10554  case eXOR:
10555  nodeMask = 0;
10556  break;
10557  case eXNOR:
10558  nodeMask = 0;
10559  break;
10560  case eINSTANCE_REF:
10561  nodeMask = 1;
10562  if(Arg<CInstance*>(0)) Arg<CInstance*>(0)->PostVisit1( func, data );
10563  break;
10564  case eGATE_REF:
10565  nodeMask = 1;
10566  if(Arg<CGate*>(0)) Arg<CGate*>(0)->PostVisit1( func, data );
10567  break;
10568  case eTASK_ENABLE:
10569  nodeMask = 1;
10570  break;
10571  case eSYSTASK_CALL:
10572  nodeMask = 1;
10573  break;
10574  case eTIMING_CALL:
10575  nodeMask = 1;
10576  break;
10577  case eFUNCTION_CALL:
10578  nodeMask = 5;
10579  break;
10580  case eARRAY:
10581  nodeMask = 0;
10582  break;
10583  case eNET_REF:
10584  nodeMask = ~0;
10585  break;
10586  case eVAR_REF:
10587  nodeMask = ~0;
10588  break;
10589  case ePARAM_REF:
10590  nodeMask = ~0;
10591  break;
10592  case ePORT_REF:
10593  nodeMask = ~0;
10594  break;
10595  case eFWD_REF:
10596  nodeMask = ~0;
10597  break;
10598  case eGENVAR_REF:
10599  nodeMask = ~0;
10600  break;
10601  case eENUM_REF:
10602  nodeMask = ~0;
10603  break;
10604  case eTYPE_REF:
10605  nodeMask = ~0;
10606  break;
10607  case eNET_DECL:
10608  nodeMask = 1;
10609  if(Arg<CNet*>(0)) Arg<CNet*>(0)->PostVisit1( func, data );
10610  break;
10611  case eVAR_DECL:
10612  nodeMask = 1;
10613  if(Arg<CVar*>(0)) Arg<CVar*>(0)->PostVisit1( func, data );
10614  break;
10615  case ePARAM_DECL:
10616  nodeMask = 1;
10617  if(Arg<CParam*>(0)) Arg<CParam*>(0)->PostVisit1( func, data );
10618  break;
10619  case eSPECPARAM_DECL:
10620  nodeMask = 1;
10621  if(Arg<CParam*>(0)) Arg<CParam*>(0)->PostVisit1( func, data );
10622  break;
10623  case ePORT_DECL:
10624  nodeMask = 1;
10625  if(Arg<CPortDir*>(0)) Arg<CPortDir*>(0)->PostVisit1( func, data );
10626  break;
10627  case eGENVAR_DECL:
10628  nodeMask = 1;
10629  if(Arg<CGenvar*>(0)) Arg<CGenvar*>(0)->PostVisit1( func, data );
10630  break;
10631  case eTYPEDEF_DECL:
10632  nodeMask = 1;
10633  if(Arg<CTypedef*>(0)) Arg<CTypedef*>(0)->PostVisit1( func, data );
10634  break;
10635  case eLIST:
10636  nodeMask = 0;
10637  break;
10638  case eRANGE:
10639  nodeMask = 0;
10640  break;
10641  case eSLICE:
10642  nodeMask = 0;
10643  break;
10644  case ePSLICE:
10645  nodeMask = 0;
10646  break;
10647  case eMSLICE:
10648  nodeMask = 0;
10649  break;
10650  case eCVRI:
10651  nodeMask = 0;
10652  break;
10653  case eCVIR:
10654  nodeMask = 0;
10655  break;
10656  case eREP:
10657  nodeMask = 0;
10658  break;
10659  case eCAT:
10660  nodeMask = 0;
10661  break;
10662  case eUCAT:
10663  nodeMask = 0;
10664  break;
10665  case eCOM:
10666  nodeMask = 0;
10667  break;
10668  case eNEG:
10669  nodeMask = 0;
10670  break;
10671  case ePLUS:
10672  nodeMask = 0;
10673  break;
10674  case eNOT:
10675  nodeMask = 0;
10676  break;
10677  case eGT:
10678  nodeMask = 0;
10679  break;
10680  case eGE:
10681  nodeMask = 0;
10682  break;
10683  case eLT:
10684  nodeMask = 0;
10685  break;
10686  case eLE:
10687  nodeMask = 0;
10688  break;
10689  case eLAND:
10690  nodeMask = 0;
10691  break;
10692  case eLOR:
10693  nodeMask = 0;
10694  break;
10695  case eCEQ:
10696  nodeMask = 0;
10697  break;
10698  case eCNE:
10699  nodeMask = 0;
10700  break;
10701  case eEQ:
10702  nodeMask = 0;
10703  break;
10704  case eNE:
10705  nodeMask = 0;
10706  break;
10707  case eRAND:
10708  nodeMask = 0;
10709  break;
10710  case eRNAND:
10711  nodeMask = 0;
10712  break;
10713  case eROR:
10714  nodeMask = 0;
10715  break;
10716  case eRNOR:
10717  nodeMask = 0;
10718  break;
10719  case eRXOR:
10720  nodeMask = 0;
10721  break;
10722  case eRXNOR:
10723  nodeMask = 0;
10724  break;
10725  case eHOOK:
10726  nodeMask = 0;
10727  break;
10728  case eINIT:
10729  nodeMask = 0;
10730  break;
10731  case eALWAYS:
10732  nodeMask = 0;
10733  break;
10734  case eALWAYS_LATCH:
10735  nodeMask = 0;
10736  break;
10737  case eALWAYS_FF:
10738  nodeMask = 0;
10739  break;
10740  case eALWAYS_COMB:
10741  nodeMask = 0;
10742  break;
10743  case eEVENT:
10744  nodeMask = 0;
10745  break;
10746  case eBLOCK_REF:
10747  nodeMask = 1;
10748  if(Arg<CBlock*>(0)) Arg<CBlock*>(0)->PostVisit1( func, data );
10749  break;
10750  case eSPECIFY_REF:
10751  nodeMask = 1;
10752  if(Arg<CSpecify*>(0)) Arg<CSpecify*>(0)->PostVisit1( func, data );
10753  break;
10754  case eASSIGN:
10755  nodeMask = 0;
10756  break;
10757  case eGASSIGN:
10758  nodeMask = 1;
10759  break;
10760  case eADD_ASSIGN:
10761  nodeMask = 0;
10762  break;
10763  case eSUB_ASSIGN:
10764  nodeMask = 0;
10765  break;
10766  case eMUL_ASSIGN:
10767  nodeMask = 0;
10768  break;
10769  case eDIV_ASSIGN:
10770  nodeMask = 0;
10771  break;
10772  case eMOD_ASSIGN:
10773  nodeMask = 0;
10774  break;
10775  case eAND_ASSIGN:
10776  nodeMask = 0;
10777  break;
10778  case eOR_ASSIGN:
10779  nodeMask = 0;
10780  break;
10781  case eXOR_ASSIGN:
10782  nodeMask = 0;
10783  break;
10784  case eLSH_ASSIGN:
10785  nodeMask = 0;
10786  break;
10787  case eRSH_ASSIGN:
10788  nodeMask = 0;
10789  break;
10790  case eLSHA_ASSIGN:
10791  nodeMask = 0;
10792  break;
10793  case eRSHA_ASSIGN:
10794  nodeMask = 0;
10795  break;
10796  case eFORCE:
10797  nodeMask = 0;
10798  break;
10799  case eRELEASE:
10800  nodeMask = 0;
10801  break;
10802  case eNBASSIGN:
10803  nodeMask = 0;
10804  break;
10805  case ePOSEDGE:
10806  nodeMask = 0;
10807  break;
10808  case eNEGEDGE:
10809  nodeMask = 0;
10810  break;
10811  case eEDGE:
10812  nodeMask = 2;
10813  break;
10814  case eEVOR:
10815  nodeMask = 0;
10816  break;
10817  case eDELAY:
10818  nodeMask = 0;
10819  break;
10820  case eMTM:
10821  nodeMask = 0;
10822  break;
10823  case eIF:
10824  nodeMask = 0;
10825  break;
10826  case eFOREVER:
10827  nodeMask = 0;
10828  break;
10829  case eREPEAT:
10830  nodeMask = 0;
10831  break;
10832  case eWHILE:
10833  nodeMask = 0;
10834  break;
10835  case eWAIT:
10836  nodeMask = 0;
10837  break;
10838  case eFOR:
10839  nodeMask = 0;
10840  break;
10841  case eCASE:
10842  nodeMask = 0;
10843  break;
10844  case eCASEX:
10845  nodeMask = 0;
10846  break;
10847  case eCASEZ:
10848  nodeMask = 0;
10849  break;
10850  case eCASEITEM:
10851  nodeMask = 0;
10852  break;
10853  case eCASSIGN:
10854  nodeMask = 1;
10855  break;
10856  case eARG:
10857  nodeMask = 1;
10858  break;
10859  case eIMPORT:
10860  nodeMask = 1;
10861  break;
10862  case eFUNCTION_DEF:
10863  nodeMask = 1;
10864  if(Arg<CFunction*>(0)) Arg<CFunction*>(0)->PostVisit1( func, data );
10865  break;
10866  case eMODULE_DEF:
10867  nodeMask = 1;
10868  if(Arg<CModule*>(0)) Arg<CModule*>(0)->PostVisit1( func, data );
10869  break;
10870  case ePACKAGE_DEF:
10871  nodeMask = 1;
10872  if(Arg<CPackage*>(0)) Arg<CPackage*>(0)->PostVisit1( func, data );
10873  break;
10874  case eREPEAT_CONTROL:
10875  nodeMask = 0;
10876  break;
10877  case eDELAY_CONTROL:
10878  nodeMask = 0;
10879  break;
10880  case eEVENT_CONTROL:
10881  nodeMask = 0;
10882  break;
10883  case eEXTERNAL_REF:
10884  nodeMask = 1;
10885  break;
10886  case ePORT_DEF:
10887  nodeMask = 1;
10888  if(Arg<CPort*>(0)) Arg<CPort*>(0)->PostVisit1( func, data );
10889  break;
10890  case eDEFPARAM:
10891  nodeMask = 0;
10892  break;
10893  case ePATH:
10894  nodeMask = 45;
10895  break;
10896  case ePATH_ASSIGN:
10897  nodeMask = 0;
10898  break;
10899  case eIFNONE_PATH_ASSIGN:
10900  nodeMask = 0;
10901  break;
10902  case eTRIGGER:
10903  nodeMask = 0;
10904  break;
10905  case ePASSIGN:
10906  nodeMask = 0;
10907  break;
10908  case eDEASSIGN:
10909  nodeMask = 0;
10910  break;
10911  case eDISABLE:
10912  nodeMask = 1;
10913  break;
10914  case eATTRIBUTE:
10915  nodeMask = 1;
10916  if(Arg<CAttr*>(0)) Arg<CAttr*>(0)->PostVisit1( func, data );
10917  break;
10918  case eGIF:
10919  nodeMask = 0;
10920  break;
10921  case eGFOR:
10922  nodeMask = 0;
10923  break;
10924  case eGCASE:
10925  nodeMask = 0;
10926  break;
10927  case eTABLE:
10928  nodeMask = 0;
10929  break;
10930  case eTABLE_ENTRY:
10931  nodeMask = 0;
10932  break;
10933  case eTABLE_SYMBOL:
10934  nodeMask = 1;
10935  break;
10936  case ePORTLIST_END:
10937  nodeMask = 0;
10938  break;
10939  case eMACRO_EXPR:
10940  nodeMask = 1;
10941  break;
10942  case eENUM_SPEC:
10943  nodeMask = 1;
10944  break;
10945  case eMEMBER:
10946  nodeMask = 2;
10947  break;
10948  case eRETURN:
10949  nodeMask = 0;
10950  break;
10951  case ePREINC:
10952  nodeMask = 0;
10953  break;
10954  case ePOSTINC:
10955  nodeMask = 0;
10956  break;
10957  case ePREDEC:
10958  nodeMask = 0;
10959  break;
10960  case ePOSTDEC:
10961  nodeMask = 0;
10962  break;
10963  case eCAST:
10964  nodeMask = 0;
10965  break;
10966  }
10967 
10968  /*
10969  * special case LIST nodes for tail recursion optimizations
10970  */
10971  if( GetOp() != eLIST ) {
10972  for( int i = 0; i < ArgCount(); i++ ) {
10973  if( Arg<CNode*>(i) && !((nodeMask>>i)&1) ) Arg<CNode*>(i)->PostVisit1( func, data );
10974  }
10975  } else {
10976  std::stack<CNode*> visitLog;
10977  CNode* n = this;
10978  while( 1 ) {
10979  if( n->Arg<CNode*>(0) ) {
10980  n->Arg<CNode*>(0)-> PostVisit1( func, data );
10981  }
10982  if( !n->Arg<CNode*>(1) || n->Arg<CNode*>(1)->GetOp() != eLIST ) {
10983  break;
10984  }
10985  visitLog.push(n);
10986  n = n->Arg<CNode*>(1);
10987  if( n->GetAttributes() ) {
10988  n->GetAttributes()->PostVisit1( func, data );
10989  }
10990  }
10991  if( n->Arg<CNode*>(1) ) {
10992  n->Arg<CNode*>(1)->PostVisit1( func, data );
10993  }
10994  while( !visitLog.empty() ) {
10995  CNode* top = visitLog.top();
10996  if( top->Arg<CNode*>(1) ) {
10997  (*func)(top->Arg<CNode*>(1),data);
10998  }
10999  visitLog.pop();
11000  }
11001  }
11002 
11003  (*func)( this, data );
11004 }
11005 
11006 /***********************************************
11007  PostSubVisit1
11008  - traverse tree, evoking
11009  leaves then parents, substituting
11010  results
11011 ************************************************/
11012 
11013 CNode* CNode::PostSubVisit1( CNode* (*func)(CNode*, void*), void* data )
11014 {
11015  if( GetAttributes() ) {
11016  SetAttributes( GetAttributes()->PostSubVisit1( func, data ) );
11017  }
11018 
11019  int nodeMask = 0;
11020  switch( GetOp() ) {
11021  case eERROR:
11022  nodeMask = 0;
11023  break;
11024  case eVCONSTANT:
11025  nodeMask = 1;
11026  break;
11027  case eRCONSTANT:
11028  nodeMask = 1;
11029  break;
11030  case eCOMMENT:
11031  nodeMask = 1;
11032  break;
11033  case eVRQ:
11034  nodeMask = 1;
11035  break;
11036  case ePRAGMA:
11037  nodeMask = 1;
11038  break;
11039  case eELIST:
11040  nodeMask = 0;
11041  break;
11042  case eWIDTH:
11043  nodeMask = 0;
11044  break;
11045  case eNOP:
11046  nodeMask = 0;
11047  break;
11048  case eSUB:
11049  nodeMask = 0;
11050  break;
11051  case eMUL:
11052  nodeMask = 0;
11053  break;
11054  case eDIV:
11055  nodeMask = 0;
11056  break;
11057  case ePOW:
11058  nodeMask = 0;
11059  break;
11060  case eADD:
11061  nodeMask = 0;
11062  break;
11063  case eLSH:
11064  nodeMask = 0;
11065  break;
11066  case eRSH:
11067  nodeMask = 0;
11068  break;
11069  case eLSHA:
11070  nodeMask = 0;
11071  break;
11072  case eRSHA:
11073  nodeMask = 0;
11074  break;
11075  case eMOD:
11076  nodeMask = 0;
11077  break;
11078  case eOR:
11079  nodeMask = 0;
11080  break;
11081  case eAND:
11082  nodeMask = 0;
11083  break;
11084  case eANDANDAND:
11085  nodeMask = 0;
11086  break;
11087  case eXOR:
11088  nodeMask = 0;
11089  break;
11090  case eXNOR:
11091  nodeMask = 0;
11092  break;
11093  case eINSTANCE_REF:
11094  nodeMask = 1;
11095  if(Arg<CInstance*>(0)) Arg<CInstance*>(0)->PostSubVisit1( func, data );
11096  break;
11097  case eGATE_REF:
11098  nodeMask = 1;
11099  if(Arg<CGate*>(0)) Arg<CGate*>(0)->PostSubVisit1( func, data );
11100  break;
11101  case eTASK_ENABLE:
11102  nodeMask = 1;
11103  break;
11104  case eSYSTASK_CALL:
11105  nodeMask = 1;
11106  break;
11107  case eTIMING_CALL:
11108  nodeMask = 1;
11109  break;
11110  case eFUNCTION_CALL:
11111  nodeMask = 5;
11112  break;
11113  case eARRAY:
11114  nodeMask = 0;
11115  break;
11116  case eNET_REF:
11117  nodeMask = ~0;
11118  break;
11119  case eVAR_REF:
11120  nodeMask = ~0;
11121  break;
11122  case ePARAM_REF:
11123  nodeMask = ~0;
11124  break;
11125  case ePORT_REF:
11126  nodeMask = ~0;
11127  break;
11128  case eFWD_REF:
11129  nodeMask = ~0;
11130  break;
11131  case eGENVAR_REF:
11132  nodeMask = ~0;
11133  break;
11134  case eENUM_REF:
11135  nodeMask = ~0;
11136  break;
11137  case eTYPE_REF:
11138  nodeMask = ~0;
11139  break;
11140  case eNET_DECL:
11141  nodeMask = 1;
11142  if(Arg<CNet*>(0)) Arg<CNet*>(0)->PostSubVisit1( func, data );
11143  break;
11144  case eVAR_DECL:
11145  nodeMask = 1;
11146  if(Arg<CVar*>(0)) Arg<CVar*>(0)->PostSubVisit1( func, data );
11147  break;
11148  case ePARAM_DECL:
11149  nodeMask = 1;
11150  if(Arg<CParam*>(0)) Arg<CParam*>(0)->PostSubVisit1( func, data );
11151  break;
11152  case eSPECPARAM_DECL:
11153  nodeMask = 1;
11154  if(Arg<CParam*>(0)) Arg<CParam*>(0)->PostSubVisit1( func, data );
11155  break;
11156  case ePORT_DECL:
11157  nodeMask = 1;
11158  if(Arg<CPortDir*>(0)) Arg<CPortDir*>(0)->PostSubVisit1( func, data );
11159  break;
11160  case eGENVAR_DECL:
11161  nodeMask = 1;
11162  if(Arg<CGenvar*>(0)) Arg<CGenvar*>(0)->PostSubVisit1( func, data );
11163  break;
11164  case eTYPEDEF_DECL:
11165  nodeMask = 1;
11166  if(Arg<CTypedef*>(0)) Arg<CTypedef*>(0)->PostSubVisit1( func, data );
11167  break;
11168  case eLIST:
11169  nodeMask = 0;
11170  break;
11171  case eRANGE:
11172  nodeMask = 0;
11173  break;
11174  case eSLICE:
11175  nodeMask = 0;
11176  break;
11177  case ePSLICE:
11178  nodeMask = 0;
11179  break;
11180  case eMSLICE:
11181  nodeMask = 0;
11182  break;
11183  case eCVRI:
11184  nodeMask = 0;
11185  break;
11186  case eCVIR:
11187  nodeMask = 0;
11188  break;
11189  case eREP:
11190  nodeMask = 0;
11191  break;
11192  case eCAT:
11193  nodeMask = 0;
11194  break;
11195  case eUCAT:
11196  nodeMask = 0;
11197  break;
11198  case eCOM:
11199  nodeMask = 0;
11200  break;
11201  case eNEG:
11202  nodeMask = 0;
11203  break;
11204  case ePLUS:
11205  nodeMask = 0;
11206  break;
11207  case eNOT:
11208  nodeMask = 0;
11209  break;
11210  case eGT:
11211  nodeMask = 0;
11212  break;
11213  case eGE:
11214  nodeMask = 0;
11215  break;
11216  case eLT:
11217  nodeMask = 0;
11218  break;
11219  case eLE:
11220  nodeMask = 0;
11221  break;
11222  case eLAND:
11223  nodeMask = 0;
11224  break;
11225  case eLOR:
11226  nodeMask = 0;
11227  break;
11228  case eCEQ:
11229  nodeMask = 0;
11230  break;
11231  case eCNE:
11232  nodeMask = 0;
11233  break;
11234  case eEQ:
11235  nodeMask = 0;
11236  break;
11237  case eNE:
11238  nodeMask = 0;
11239  break;
11240  case eRAND:
11241  nodeMask = 0;
11242  break;
11243  case eRNAND:
11244  nodeMask = 0;
11245  break;
11246  case eROR:
11247  nodeMask = 0;
11248  break;
11249  case eRNOR:
11250  nodeMask = 0;
11251  break;
11252  case eRXOR:
11253  nodeMask = 0;
11254  break;
11255  case eRXNOR:
11256  nodeMask = 0;
11257  break;
11258  case eHOOK:
11259  nodeMask = 0;
11260  break;
11261  case eINIT:
11262  nodeMask = 0;
11263  break;
11264  case eALWAYS:
11265  nodeMask = 0;
11266  break;
11267  case eALWAYS_LATCH:
11268  nodeMask = 0;
11269  break;
11270  case eALWAYS_FF:
11271  nodeMask = 0;
11272  break;
11273  case eALWAYS_COMB:
11274  nodeMask = 0;
11275  break;
11276  case eEVENT:
11277  nodeMask = 0;
11278  break;
11279  case eBLOCK_REF:
11280  nodeMask = 1;
11281  if(Arg<CBlock*>(0)) Arg<CBlock*>(0)->PostSubVisit1( func, data );
11282  break;
11283  case eSPECIFY_REF:
11284  nodeMask = 1;
11285  if(Arg<CSpecify*>(0)) Arg<CSpecify*>(0)->PostSubVisit1( func, data );
11286  break;
11287  case eASSIGN:
11288  nodeMask = 0;
11289  break;
11290  case eGASSIGN:
11291  nodeMask = 1;
11292  break;
11293  case eADD_ASSIGN:
11294  nodeMask = 0;
11295  break;
11296  case eSUB_ASSIGN:
11297  nodeMask = 0;
11298  break;
11299  case eMUL_ASSIGN:
11300  nodeMask = 0;
11301  break;
11302  case eDIV_ASSIGN:
11303  nodeMask = 0;
11304  break;
11305  case eMOD_ASSIGN:
11306  nodeMask = 0;
11307  break;
11308  case eAND_ASSIGN:
11309  nodeMask = 0;
11310  break;
11311  case eOR_ASSIGN:
11312  nodeMask = 0;
11313  break;
11314  case eXOR_ASSIGN:
11315  nodeMask = 0;
11316  break;
11317  case eLSH_ASSIGN:
11318  nodeMask = 0;
11319  break;
11320  case eRSH_ASSIGN:
11321  nodeMask = 0;
11322  break;
11323  case eLSHA_ASSIGN:
11324  nodeMask = 0;
11325  break;
11326  case eRSHA_ASSIGN:
11327  nodeMask = 0;
11328  break;
11329  case eFORCE:
11330  nodeMask = 0;
11331  break;
11332  case eRELEASE:
11333  nodeMask = 0;
11334  break;
11335  case eNBASSIGN:
11336  nodeMask = 0;
11337  break;
11338  case ePOSEDGE:
11339  nodeMask = 0;
11340  break;
11341  case eNEGEDGE:
11342  nodeMask = 0;
11343  break;
11344  case eEDGE:
11345  nodeMask = 2;
11346  break;
11347  case eEVOR:
11348  nodeMask = 0;
11349  break;
11350  case eDELAY:
11351  nodeMask = 0;
11352  break;
11353  case eMTM:
11354  nodeMask = 0;
11355  break;
11356  case eIF:
11357  nodeMask = 0;
11358  break;
11359  case eFOREVER:
11360  nodeMask = 0;
11361  break;
11362  case eREPEAT:
11363  nodeMask = 0;
11364  break;
11365  case eWHILE:
11366  nodeMask = 0;
11367  break;
11368  case eWAIT:
11369  nodeMask = 0;
11370  break;
11371  case eFOR:
11372  nodeMask = 0;
11373  break;
11374  case eCASE:
11375  nodeMask = 0;
11376  break;
11377  case eCASEX:
11378  nodeMask = 0;
11379  break;
11380  case eCASEZ:
11381  nodeMask = 0;
11382  break;
11383  case eCASEITEM:
11384  nodeMask = 0;
11385  break;
11386  case eCASSIGN:
11387  nodeMask = 1;
11388  break;
11389  case eARG:
11390  nodeMask = 1;
11391  break;
11392  case eIMPORT:
11393  nodeMask = 1;
11394  break;
11395  case eFUNCTION_DEF:
11396  nodeMask = 1;
11397  if(Arg<CFunction*>(0)) Arg<CFunction*>(0)->PostSubVisit1( func, data );
11398  break;
11399  case eMODULE_DEF:
11400  nodeMask = 1;
11401  if(Arg<CModule*>(0)) Arg<CModule*>(0)->PostSubVisit1( func, data );
11402  break;
11403  case ePACKAGE_DEF:
11404  nodeMask = 1;
11405  if(Arg<CPackage*>(0)) Arg<CPackage*>(0)->PostSubVisit1( func, data );
11406  break;
11407  case eREPEAT_CONTROL:
11408  nodeMask = 0;
11409  break;
11410  case eDELAY_CONTROL:
11411  nodeMask = 0;
11412  break;
11413  case eEVENT_CONTROL:
11414  nodeMask = 0;
11415  break;
11416  case eEXTERNAL_REF:
11417  nodeMask = 1;
11418  break;
11419  case ePORT_DEF:
11420  nodeMask = 1;
11421  if(Arg<CPort*>(0)) Arg<CPort*>(0)->PostSubVisit1( func, data );
11422  break;
11423  case eDEFPARAM:
11424  nodeMask = 0;
11425  break;
11426  case ePATH:
11427  nodeMask = 45;
11428  break;
11429  case ePATH_ASSIGN:
11430  nodeMask = 0;
11431  break;
11432  case eIFNONE_PATH_ASSIGN:
11433  nodeMask = 0;
11434  break;
11435  case eTRIGGER:
11436  nodeMask = 0;
11437  break;
11438  case ePASSIGN:
11439  nodeMask = 0;
11440  break;
11441  case eDEASSIGN:
11442  nodeMask = 0;
11443  break;
11444  case eDISABLE:
11445  nodeMask = 1;
11446  break;
11447  case eATTRIBUTE:
11448  nodeMask = 1;
11449  if(Arg<CAttr*>(0)) Arg<CAttr*>(0)->PostSubVisit1( func, data );
11450  break;
11451  case eGIF:
11452  nodeMask = 0;
11453  break;
11454  case eGFOR:
11455  nodeMask = 0;
11456  break;
11457  case eGCASE:
11458  nodeMask = 0;
11459  break;
11460  case eTABLE:
11461  nodeMask = 0;
11462  break;
11463  case eTABLE_ENTRY:
11464  nodeMask = 0;
11465  break;
11466  case eTABLE_SYMBOL:
11467  nodeMask = 1;
11468  break;
11469  case ePORTLIST_END:
11470  nodeMask = 0;
11471  break;
11472  case eMACRO_EXPR:
11473  nodeMask = 1;
11474  break;
11475  case eENUM_SPEC:
11476  nodeMask = 1;
11477  break;
11478  case eMEMBER:
11479  nodeMask = 2;
11480  break;
11481  case eRETURN:
11482  nodeMask = 0;
11483  break;
11484  case ePREINC:
11485  nodeMask = 0;
11486  break;
11487  case ePOSTINC:
11488  nodeMask = 0;
11489  break;
11490  case ePREDEC:
11491  nodeMask = 0;
11492  break;
11493  case ePOSTDEC:
11494  nodeMask = 0;
11495  break;
11496  case eCAST:
11497  nodeMask = 0;
11498  break;
11499  }
11500 
11501  /*
11502  * special case LIST nodes for tail recursion optimizations
11503  */
11504  if( GetOp() != eLIST ) {
11505  for( int i = 0; i < ArgCount(); i++ ) {
11506  if( Arg<CNode*>(i) && !((nodeMask>>i)&1) ) Arg<CNode*>(i) = Arg<CNode*>(i)->PostSubVisit1( func, data );
11507  }
11508  } else {
11509  std::stack<CNode*> visitLog;
11510  CNode* n = this;
11511  while( 1 ) {
11512  if( n->Arg<CNode*>(0) ) {
11513  n->Arg<CNode*>(0) = n->Arg<CNode*>(0)->
11514  PostSubVisit1( func, data );
11515  }
11516  if( !n->Arg<CNode*>(1) || n->Arg<CNode*>(1)->GetOp() != eLIST ) {
11517  break;
11518  }
11519  visitLog.push(n);
11520  n = n->Arg<CNode*>(1);
11521  if( n->GetAttributes() ) {
11522  n->SetAttributes( n->GetAttributes()->PostSubVisit1( func, data ) );
11523  }
11524  }
11525  if( n->Arg<CNode*>(1) ) {
11526  n->Arg<CNode*>(1) = n->Arg<CNode*>(1)->PostSubVisit1( func, data );
11527  }
11528  while( !visitLog.empty() ) {
11529  CNode* top = visitLog.top();
11530  if( top->Arg<CNode*>(1) ) {
11531  top->Arg<CNode*>(1) = (*func)(top->Arg<CNode*>(1),data);
11532  }
11533  visitLog.pop();
11534  }
11535  }
11536 
11537  return (*func)( this, data );
11538 }
11539 
11540 /***********************************************
11541  Hash
11542  - returns a unique hash number
11543  representing tree
11544  The following is always true:
11545  Equivilent(n1,n2) => Hash(n1) == Hash(n2)
11546 ************************************************/
11547 
11548 unsigned CNode::Hash()
11549 {
11550  unsigned result = GetOp();
11551  int nodeMask = 0;
11552  switch( GetOp() ) {
11553  case eERROR:
11554  nodeMask = 0;
11555  break;
11556  case eVCONSTANT:
11557  nodeMask = 1;
11558  result ^= Arg<CVector*>(0)->Hash();
11559  break;
11560  case eRCONSTANT:
11561  nodeMask = 1;
11562  result ^= strlen(Arg<char*>(0));
11563  break;
11564  case eCOMMENT:
11565  nodeMask = 1;
11566  result ^= strlen(Arg<char*>(0));
11567  break;
11568  case eVRQ:
11569  nodeMask = 1;
11570  result ^= strlen(Arg<char*>(0));
11571  break;
11572  case ePRAGMA:
11573  nodeMask = 1;
11574  result ^= strlen(Arg<char*>(0));
11575  break;
11576  case eELIST:
11577  nodeMask = 0;
11578  break;
11579  case eWIDTH:
11580  nodeMask = 0;
11581  break;
11582  case eNOP:
11583  nodeMask = 0;
11584  break;
11585  case eSUB:
11586  nodeMask = 0;
11587  break;
11588  case eMUL:
11589  nodeMask = 0;
11590  break;
11591  case eDIV:
11592  nodeMask = 0;
11593  break;
11594  case ePOW:
11595  nodeMask = 0;
11596  break;
11597  case eADD:
11598  nodeMask = 0;
11599  break;
11600  case eLSH:
11601  nodeMask = 0;
11602  break;
11603  case eRSH:
11604  nodeMask = 0;
11605  break;
11606  case eLSHA:
11607  nodeMask = 0;
11608  break;
11609  case eRSHA:
11610  nodeMask = 0;
11611  break;
11612  case eMOD:
11613  nodeMask = 0;
11614  break;
11615  case eOR:
11616  nodeMask = 0;
11617  break;
11618  case eAND:
11619  nodeMask = 0;
11620  break;
11621  case eANDANDAND:
11622  nodeMask = 0;
11623  break;
11624  case eXOR:
11625  nodeMask = 0;
11626  break;
11627  case eXNOR:
11628  nodeMask = 0;
11629  break;
11630  case eINSTANCE_REF:
11631  nodeMask = 1;
11632  result ^= Arg<unsigned long>(0);
11633  break;
11634  case eGATE_REF:
11635  nodeMask = 1;
11636  result ^= Arg<unsigned long>(0);
11637  break;
11638  case eTASK_ENABLE:
11639  nodeMask = 1;
11640  result ^= Arg<unsigned long>(0);
11641  break;
11642  case eSYSTASK_CALL:
11643  nodeMask = 1;
11644  result ^= Arg<unsigned long>(0);
11645  break;
11646  case eTIMING_CALL:
11647  nodeMask = 1;
11648  result ^= Arg<unsigned long>(0);
11649  break;
11650  case eFUNCTION_CALL:
11651  nodeMask = 5;
11652  result ^= Arg<unsigned long>(0);
11653  result ^= Arg<unsigned long>(2);
11654  break;
11655  case eARRAY:
11656  nodeMask = 0;
11657  break;
11658  case eNET_REF:
11659  nodeMask = 1;
11660  result ^= Arg<unsigned long>(0);
11661  break;
11662  case eVAR_REF:
11663  nodeMask = 1;
11664  result ^= Arg<unsigned long>(0);
11665  break;
11666  case ePARAM_REF:
11667  nodeMask = 1;
11668  result ^= Arg<unsigned long>(0);
11669  break;
11670  case ePORT_REF:
11671  nodeMask = 1;
11672  result ^= Arg<unsigned long>(0);
11673  break;
11674  case eFWD_REF:
11675  nodeMask = 1;
11676  result ^= Arg<unsigned long>(0);
11677  break;
11678  case eGENVAR_REF:
11679  nodeMask = 1;
11680  result ^= Arg<unsigned long>(0);
11681  break;
11682  case eENUM_REF:
11683  nodeMask = 1;
11684  result ^= Arg<unsigned long>(0);
11685  break;
11686  case eTYPE_REF:
11687  nodeMask = 1;
11688  result ^= Arg<unsigned long>(0);
11689  break;
11690  case eNET_DECL:
11691  nodeMask = 1;
11692  result ^= Arg<unsigned long>(0);
11693  break;
11694  case eVAR_DECL:
11695  nodeMask = 1;
11696  result ^= Arg<unsigned long>(0);
11697  break;
11698  case ePARAM_DECL:
11699  nodeMask = 1;
11700  result ^= Arg<unsigned long>(0);
11701  break;
11702  case eSPECPARAM_DECL:
11703  nodeMask = 1;
11704  result ^= Arg<unsigned long>(0);
11705  break;
11706  case ePORT_DECL:
11707  nodeMask = 1;
11708  result ^= Arg<unsigned long>(0);
11709  break;
11710  case eGENVAR_DECL:
11711  nodeMask = 1;
11712  result ^= Arg<unsigned long>(0);
11713  break;
11714  case eTYPEDEF_DECL:
11715  nodeMask = 1;
11716  result ^= Arg<unsigned long>(0);
11717  break;
11718  case eLIST:
11719  nodeMask = 0;
11720  break;
11721  case eRANGE:
11722  nodeMask = 0;
11723  break;
11724  case eSLICE:
11725  nodeMask = 0;
11726  break;
11727  case ePSLICE:
11728  nodeMask = 0;
11729  break;
11730  case eMSLICE:
11731  nodeMask = 0;
11732  break;
11733  case eCVRI:
11734  nodeMask = 0;
11735  break;
11736  case eCVIR:
11737  nodeMask = 0;
11738  break;
11739  case eREP:
11740  nodeMask = 0;
11741  break;
11742  case eCAT:
11743  nodeMask = 0;
11744  break;
11745  case eUCAT:
11746  nodeMask = 0;
11747  break;
11748  case eCOM:
11749  nodeMask = 0;
11750  break;
11751  case eNEG:
11752  nodeMask = 0;
11753  break;
11754  case ePLUS:
11755  nodeMask = 0;
11756  break;
11757  case eNOT:
11758  nodeMask = 0;
11759  break;
11760  case eGT:
11761  nodeMask = 0;
11762  break;
11763  case eGE:
11764  nodeMask = 0;
11765  break;
11766  case eLT:
11767  nodeMask = 0;
11768  break;
11769  case eLE:
11770  nodeMask = 0;
11771  break;
11772  case eLAND:
11773  nodeMask = 0;
11774  break;
11775  case eLOR:
11776  nodeMask = 0;
11777  break;
11778  case eCEQ:
11779  nodeMask = 0;
11780  break;
11781  case eCNE:
11782  nodeMask = 0;
11783  break;
11784  case eEQ:
11785  nodeMask = 0;
11786  break;
11787  case eNE:
11788  nodeMask = 0;
11789  break;
11790  case eRAND:
11791  nodeMask = 0;
11792  break;
11793  case eRNAND:
11794  nodeMask = 0;
11795  break;
11796  case eROR:
11797  nodeMask = 0;
11798  break;
11799  case eRNOR:
11800  nodeMask = 0;
11801  break;
11802  case eRXOR:
11803  nodeMask = 0;
11804  break;
11805  case eRXNOR:
11806  nodeMask = 0;
11807  break;
11808  case eHOOK:
11809  nodeMask = 0;
11810  break;
11811  case eINIT:
11812  nodeMask = 0;
11813  break;
11814  case eALWAYS:
11815  nodeMask = 0;
11816  break;
11817  case eALWAYS_LATCH:
11818  nodeMask = 0;
11819  break;
11820  case eALWAYS_FF:
11821  nodeMask = 0;
11822  break;
11823  case eALWAYS_COMB:
11824  nodeMask = 0;
11825  break;
11826  case eEVENT:
11827  nodeMask = 0;
11828  break;
11829  case eBLOCK_REF:
11830  nodeMask = 1;
11831  result ^= Arg<unsigned long>(0);
11832  break;
11833  case eSPECIFY_REF:
11834  nodeMask = 1;
11835  result ^= Arg<unsigned long>(0);
11836  break;
11837  case eASSIGN:
11838  nodeMask = 0;
11839  break;
11840  case eGASSIGN:
11841  nodeMask = 1;
11842  result ^= Arg<bool>(0);
11843  break;
11844  case eADD_ASSIGN:
11845  nodeMask = 0;
11846  break;
11847  case eSUB_ASSIGN:
11848  nodeMask = 0;
11849  break;
11850  case eMUL_ASSIGN:
11851  nodeMask = 0;
11852  break;
11853  case eDIV_ASSIGN:
11854  nodeMask = 0;
11855  break;
11856  case eMOD_ASSIGN:
11857  nodeMask = 0;
11858  break;
11859  case eAND_ASSIGN:
11860  nodeMask = 0;
11861  break;
11862  case eOR_ASSIGN:
11863  nodeMask = 0;
11864  break;
11865  case eXOR_ASSIGN:
11866  nodeMask = 0;
11867  break;
11868  case eLSH_ASSIGN:
11869  nodeMask = 0;
11870  break;
11871  case eRSH_ASSIGN:
11872  nodeMask = 0;
11873  break;
11874  case eLSHA_ASSIGN:
11875  nodeMask = 0;
11876  break;
11877  case eRSHA_ASSIGN:
11878  nodeMask = 0;
11879  break;
11880  case eFORCE:
11881  nodeMask = 0;
11882  break;
11883  case eRELEASE:
11884  nodeMask = 0;
11885  break;
11886  case eNBASSIGN:
11887  nodeMask = 0;
11888  break;
11889  case ePOSEDGE:
11890  nodeMask = 0;
11891  break;
11892  case eNEGEDGE:
11893  nodeMask = 0;
11894  break;
11895  case eEDGE:
11896  nodeMask = 2;
11897  result ^= (unsigned long)Arg<Edge_t>(1);
11898  break;
11899  case eEVOR:
11900  nodeMask = 0;
11901  break;
11902  case eDELAY:
11903  nodeMask = 0;
11904  break;
11905  case eMTM:
11906  nodeMask = 0;
11907  break;
11908  case eIF:
11909  nodeMask = 0;
11910  break;
11911  case eFOREVER:
11912  nodeMask = 0;
11913  break;
11914  case eREPEAT:
11915  nodeMask = 0;
11916  break;
11917  case eWHILE:
11918  nodeMask = 0;
11919  break;
11920  case eWAIT:
11921  nodeMask = 0;
11922  break;
11923  case eFOR:
11924  nodeMask = 0;
11925  break;
11926  case eCASE:
11927  nodeMask = 0;
11928  break;
11929  case eCASEX:
11930  nodeMask = 0;
11931  break;
11932  case eCASEZ:
11933  nodeMask = 0;
11934  break;
11935  case eCASEITEM:
11936  nodeMask = 0;
11937  break;
11938  case eCASSIGN:
11939  nodeMask = 1;
11940  result ^= Arg<unsigned long>(0);
11941  break;
11942  case eARG:
11943  nodeMask = 1;
11944  result ^= Arg<unsigned long>(0);
11945  break;
11946  case eIMPORT:
11947  nodeMask = 1;
11948  result ^= Arg<unsigned long>(0);
11949  break;
11950  case eFUNCTION_DEF:
11951  nodeMask = 1;
11952  result ^= Arg<unsigned long>(0);
11953  break;
11954  case eMODULE_DEF:
11955  nodeMask = 1;
11956  result ^= Arg<unsigned long>(0);
11957  break;
11958  case ePACKAGE_DEF:
11959  nodeMask = 1;
11960  result ^= Arg<unsigned long>(0);
11961  break;
11962  case eREPEAT_CONTROL:
11963  nodeMask = 0;
11964  break;
11965  case eDELAY_CONTROL:
11966  nodeMask = 0;
11967  break;
11968  case eEVENT_CONTROL:
11969  nodeMask = 0;
11970  break;
11971  case eEXTERNAL_REF:
11972  nodeMask = 1;
11973  result ^= Arg<unsigned long>(0);
11974  break;
11975  case ePORT_DEF:
11976  nodeMask = 1;
11977  result ^= Arg<unsigned long>(0);
11978  break;
11979  case eDEFPARAM:
11980  nodeMask = 0;
11981  break;
11982  case ePATH:
11983  nodeMask = 45;
11984  result ^= Arg<int>(0);
11985  result ^= Arg<int>(2);
11986  result ^= Arg<int>(3);
11987  result ^= Arg<int>(5);
11988  break;
11989  case ePATH_ASSIGN:
11990  nodeMask = 0;
11991  break;
11992  case eIFNONE_PATH_ASSIGN:
11993  nodeMask = 0;
11994  break;
11995  case eTRIGGER:
11996  nodeMask = 0;
11997  break;
11998  case ePASSIGN:
11999  nodeMask = 0;
12000  break;
12001  case eDEASSIGN:
12002  nodeMask = 0;
12003  break;
12004  case eDISABLE:
12005  nodeMask = 1;
12006  result ^= Arg<unsigned long>(0);
12007  break;
12008  case eATTRIBUTE:
12009  nodeMask = 1;
12010  result ^= Arg<unsigned long>(0);
12011  break;
12012  case eGIF:
12013  nodeMask = 0;
12014  break;
12015  case eGFOR:
12016  nodeMask = 0;
12017  break;
12018  case eGCASE:
12019  nodeMask = 0;
12020  break;
12021  case eTABLE:
12022  nodeMask = 0;
12023  break;
12024  case eTABLE_ENTRY:
12025  nodeMask = 0;
12026  break;
12027  case eTABLE_SYMBOL:
12028  nodeMask = 1;
12029  result ^= strlen(Arg<char*>(0));
12030  break;
12031  case ePORTLIST_END:
12032  nodeMask = 0;
12033  break;
12034  case eMACRO_EXPR:
12035  nodeMask = 1;
12036  result ^= strlen(Arg<char*>(0));
12037  break;
12038  case eENUM_SPEC:
12039  nodeMask = 1;
12040  result ^= Arg<unsigned long>(0);
12041  break;
12042  case eMEMBER:
12043  nodeMask = 2;
12044  result ^= Arg<unsigned long>(1);
12045  break;
12046  case eRETURN:
12047  nodeMask = 0;
12048  break;
12049  case ePREINC:
12050  nodeMask = 0;
12051  break;
12052  case ePOSTINC:
12053  nodeMask = 0;
12054  break;
12055  case ePREDEC:
12056  nodeMask = 0;
12057  break;
12058  case ePOSTDEC:
12059  nodeMask = 0;
12060  break;
12061  case eCAST:
12062  nodeMask = 0;
12063  break;
12064  }
12065 
12066  for( int i = 0; i < ArgCount(); i++ ) {
12067  if( !((nodeMask>>i)&1) ) result ^= Arg<CNode*>(i)->Hash();
12068  }
12069  return result;
12070 }
12071 
12072 /***********************************************
12073  Equivalent
12074  - returns TRUE if both trees are equivalent
12075  Note: this currently will only match if
12076  the trees are structurally the same.
12077  It does not attempt rename and match
12078  leaf declarations.
12079  In the future this may be expanded
12080  to match if the trees are functionally
12081  equivalent.
12082 ************************************************/
12083 
12084 int Equivalent( CNode* a, CNode* b )
12085 {
12086  /*
12087  * handles NULL/NULL and trivial equivalence case
12088  */
12089  if( a == b ) {
12090  return TRUE;
12091  }
12092  /*
12093  * reject if one is NULL but not the other
12094  */
12095  if( a == NULL || b == NULL ) {
12096  return FALSE;
12097  }
12098  /*
12099  * reject if node types are different
12100  */
12101  if( a->GetOp() != b->GetOp() ) {
12102  return FALSE;
12103  }
12104 
12105  int nodeMask = 0;
12106  switch( a->GetOp() ) {
12107  case eERROR:
12108  nodeMask = 0;
12109  break;
12110  case eVCONSTANT:
12111  nodeMask = 1;
12112  if( !(*a->Arg<CVector*>(0)==*b->Arg<CVector*>(0)) ) { return FALSE; }
12113  break;
12114  case eRCONSTANT:
12115  nodeMask = 1;
12116  if( !(!strcmp(a->Arg<char*>(0),b->Arg<char*>(0))) ) { return FALSE; }
12117  break;
12118  case eCOMMENT:
12119  nodeMask = 1;
12120  if( !(!strcmp(a->Arg<char*>(0),b->Arg<char*>(0))) ) { return FALSE; }
12121  break;
12122  case eVRQ:
12123  nodeMask = 1;
12124  if( !(!strcmp(a->Arg<char*>(0),b->Arg<char*>(0))) ) { return FALSE; }
12125  break;
12126  case ePRAGMA:
12127  nodeMask = 1;
12128  if( !(!strcmp(a->Arg<char*>(0),b->Arg<char*>(0))) ) { return FALSE; }
12129  break;
12130  case eELIST:
12131  nodeMask = 0;
12132  break;
12133  case eWIDTH:
12134  nodeMask = 0;
12135  break;
12136  case eNOP:
12137  nodeMask = 0;
12138  break;
12139  case eSUB:
12140  nodeMask = 0;
12141  break;
12142  case eMUL:
12143  nodeMask = 0;
12144  break;
12145  case eDIV:
12146  nodeMask = 0;
12147  break;
12148  case ePOW:
12149  nodeMask = 0;
12150  break;
12151  case eADD:
12152  nodeMask = 0;
12153  break;
12154  case eLSH:
12155  nodeMask = 0;
12156  break;
12157  case eRSH:
12158  nodeMask = 0;
12159  break;
12160  case eLSHA:
12161  nodeMask = 0;
12162  break;
12163  case eRSHA:
12164  nodeMask = 0;
12165  break;
12166  case eMOD:
12167  nodeMask = 0;
12168  break;
12169  case eOR:
12170  nodeMask = 0;
12171  break;
12172  case eAND:
12173  nodeMask = 0;
12174  break;
12175  case eANDANDAND:
12176  nodeMask = 0;
12177  break;
12178  case eXOR:
12179  nodeMask = 0;
12180  break;
12181  case eXNOR:
12182  nodeMask = 0;
12183  break;
12184  case eINSTANCE_REF:
12185  nodeMask = 1;
12186  if( !(a->Arg<CInstance*>(0)==b->Arg<CInstance*>(0)) ) { return FALSE; }
12187  break;
12188  case eGATE_REF:
12189  nodeMask = 1;
12190  if( !(a->Arg<CGate*>(0)==b->Arg<CGate*>(0)) ) { return FALSE; }
12191  break;
12192  case eTASK_ENABLE:
12193  nodeMask = 1;
12194  if( !(a->Arg<CSymbol*>(0)==b->Arg<CSymbol*>(0)) ) { return FALSE; }
12195  break;
12196  case eSYSTASK_CALL:
12197  nodeMask = 1;
12198  if( !(a->Arg<CSymbol*>(0)==b->Arg<CSymbol*>(0)) ) { return FALSE; }
12199  break;
12200  case eTIMING_CALL:
12201  nodeMask = 1;
12202  if( !(a->Arg<CSymbol*>(0)==b->Arg<CSymbol*>(0)) ) { return FALSE; }
12203  break;
12204  case eFUNCTION_CALL:
12205  nodeMask = 5;
12206  if( !(a->Arg<CSymbol*>(0)==b->Arg<CSymbol*>(0)) ) { return FALSE; }
12207  if( !(a->Arg<CScope*>(2)==b->Arg<CScope*>(2)) ) { return FALSE; }
12208  break;
12209  case eARRAY:
12210  nodeMask = 0;
12211  break;
12212  case eNET_REF:
12213  nodeMask = 1;
12214  if( !(a->Arg<CNet*>(0)==b->Arg<CNet*>(0)) ) { return FALSE; }
12215  break;
12216  case eVAR_REF:
12217  nodeMask = 1;
12218  if( !(a->Arg<CVar*>(0)==b->Arg<CVar*>(0)) ) { return FALSE; }
12219  break;
12220  case ePARAM_REF:
12221  nodeMask = 1;
12222  if( !(a->Arg<CParam*>(0)==b->Arg<CParam*>(0)) ) { return FALSE; }
12223  break;
12224  case ePORT_REF:
12225  nodeMask = 1;
12226  if( !(a->Arg<CPortDir*>(0)==b->Arg<CPortDir*>(0)) ) { return FALSE; }
12227  break;
12228  case eFWD_REF:
12229  nodeMask = 1;
12230  if( !(a->Arg<CFref*>(0)==b->Arg<CFref*>(0)) ) { return FALSE; }
12231  break;
12232  case eGENVAR_REF:
12233  nodeMask = 1;
12234  if( !(a->Arg<CGenvar*>(0)==b->Arg<CGenvar*>(0)) ) { return FALSE; }
12235  break;
12236  case eENUM_REF:
12237  nodeMask = 1;
12238  MASSERT(FALSE); // arg0<CEnum*>
12239  break;
12240  case eTYPE_REF:
12241  nodeMask = 1;
12242  MASSERT(FALSE); // arg0<CTypedef*>
12243  break;
12244  case eNET_DECL:
12245  nodeMask = 1;
12246  if( !(a->Arg<CNet*>(0)==b->Arg<CNet*>(0)) ) { return FALSE; }
12247  break;
12248  case eVAR_DECL:
12249  nodeMask = 1;
12250  if( !(a->Arg<CVar*>(0)==b->Arg<CVar*>(0)) ) { return FALSE; }
12251  break;
12252  case ePARAM_DECL:
12253  nodeMask = 1;
12254  if( !(a->Arg<CParam*>(0)==b->Arg<CParam*>(0)) ) { return FALSE; }
12255  break;
12256  case eSPECPARAM_DECL:
12257  nodeMask = 1;
12258  if( !(a->Arg<CParam*>(0)==b->Arg<CParam*>(0)) ) { return FALSE; }
12259  break;
12260  case ePORT_DECL:
12261  nodeMask = 1;
12262  if( !(a->Arg<CPortDir*>(0)==b->Arg<CPortDir*>(0)) ) { return FALSE; }
12263  break;
12264  case eGENVAR_DECL:
12265  nodeMask = 1;
12266  if( !(a->Arg<CGenvar*>(0)==b->Arg<CGenvar*>(0)) ) { return FALSE; }
12267  break;
12268  case eTYPEDEF_DECL:
12269  nodeMask = 1;
12270  MASSERT(FALSE); // arg0<CTypedef*>
12271  break;
12272  case eLIST:
12273  nodeMask = 0;
12274  break;
12275  case eRANGE:
12276  nodeMask = 0;
12277  break;
12278  case eSLICE:
12279  nodeMask = 0;
12280  break;
12281  case ePSLICE:
12282  nodeMask = 0;
12283  break;
12284  case eMSLICE:
12285  nodeMask = 0;
12286  break;
12287  case eCVRI:
12288  nodeMask = 0;
12289  break;
12290  case eCVIR:
12291  nodeMask = 0;
12292  break;
12293  case eREP:
12294  nodeMask = 0;
12295  break;
12296  case eCAT:
12297  nodeMask = 0;
12298  break;
12299  case eUCAT:
12300  nodeMask = 0;
12301  break;
12302  case eCOM:
12303  nodeMask = 0;
12304  break;
12305  case eNEG:
12306  nodeMask = 0;
12307  break;
12308  case ePLUS:
12309  nodeMask = 0;
12310  break;
12311  case eNOT:
12312  nodeMask = 0;
12313  break;
12314  case eGT:
12315  nodeMask = 0;
12316  break;
12317  case eGE:
12318  nodeMask = 0;
12319  break;
12320  case eLT:
12321  nodeMask = 0;
12322  break;
12323  case eLE:
12324  nodeMask = 0;
12325  break;
12326  case eLAND:
12327  nodeMask = 0;
12328  break;
12329  case eLOR:
12330  nodeMask = 0;
12331  break;
12332  case eCEQ:
12333  nodeMask = 0;
12334  break;
12335  case eCNE:
12336  nodeMask = 0;
12337  break;
12338  case eEQ:
12339  nodeMask = 0;
12340  break;
12341  case eNE:
12342  nodeMask = 0;
12343  break;
12344  case eRAND:
12345  nodeMask = 0;
12346  break;
12347  case eRNAND:
12348  nodeMask = 0;
12349  break;
12350  case eROR:
12351  nodeMask = 0;
12352  break;
12353  case eRNOR:
12354  nodeMask = 0;
12355  break;
12356  case eRXOR:
12357  nodeMask = 0;
12358  break;
12359  case eRXNOR:
12360  nodeMask = 0;
12361  break;
12362  case eHOOK:
12363  nodeMask = 0;
12364  break;
12365  case eINIT:
12366  nodeMask = 0;
12367  break;
12368  case eALWAYS:
12369  nodeMask = 0;
12370  break;
12371  case eALWAYS_LATCH:
12372  nodeMask = 0;
12373  break;
12374  case eALWAYS_FF:
12375  nodeMask = 0;
12376  break;
12377  case eALWAYS_COMB:
12378  nodeMask = 0;
12379  break;
12380  case eEVENT:
12381  nodeMask = 0;
12382  break;
12383  case eBLOCK_REF:
12384  nodeMask = 1;
12385  if( !(a->Arg<CBlock*>(0)==b->Arg<CBlock*>(0)) ) { return FALSE; }
12386  break;
12387  case eSPECIFY_REF:
12388  nodeMask = 1;
12389  if( !(a->Arg<CSpecify*>(0)==b->Arg<CSpecify*>(0)) ) { return FALSE; }
12390  break;
12391  case eASSIGN:
12392  nodeMask = 0;
12393  break;
12394  case eGASSIGN:
12395  nodeMask = 1;
12396  MASSERT(FALSE); // arg0<bool>
12397  break;
12398  case eADD_ASSIGN:
12399  nodeMask = 0;
12400  break;
12401  case eSUB_ASSIGN:
12402  nodeMask = 0;
12403  break;
12404  case eMUL_ASSIGN:
12405  nodeMask = 0;
12406  break;
12407  case eDIV_ASSIGN:
12408  nodeMask = 0;
12409  break;
12410  case eMOD_ASSIGN:
12411  nodeMask = 0;
12412  break;
12413  case eAND_ASSIGN:
12414  nodeMask = 0;
12415  break;
12416  case eOR_ASSIGN:
12417  nodeMask = 0;
12418  break;
12419  case eXOR_ASSIGN:
12420  nodeMask = 0;
12421  break;
12422  case eLSH_ASSIGN:
12423  nodeMask = 0;
12424  break;
12425  case eRSH_ASSIGN:
12426  nodeMask = 0;
12427  break;
12428  case eLSHA_ASSIGN:
12429  nodeMask = 0;
12430  break;
12431  case eRSHA_ASSIGN:
12432  nodeMask = 0;
12433  break;
12434  case eFORCE:
12435  nodeMask = 0;
12436  break;
12437  case eRELEASE:
12438  nodeMask = 0;
12439  break;
12440  case eNBASSIGN:
12441  nodeMask = 0;
12442  break;
12443  case ePOSEDGE:
12444  nodeMask = 0;
12445  break;
12446  case eNEGEDGE:
12447  nodeMask = 0;
12448  break;
12449  case eEDGE:
12450  nodeMask = 2;
12451  if( !(a->Arg<Edge_t>(1)==b->Arg<Edge_t>(1)) ) { return FALSE; }
12452  break;
12453  case eEVOR:
12454  nodeMask = 0;
12455  break;
12456  case eDELAY:
12457  nodeMask = 0;
12458  break;
12459  case eMTM:
12460  nodeMask = 0;
12461  break;
12462  case eIF:
12463  nodeMask = 0;
12464  break;
12465  case eFOREVER:
12466  nodeMask = 0;
12467  break;
12468  case eREPEAT:
12469  nodeMask = 0;
12470  break;
12471  case eWHILE:
12472  nodeMask = 0;
12473  break;
12474  case eWAIT:
12475  nodeMask = 0;
12476  break;
12477  case eFOR:
12478  nodeMask = 0;
12479  break;
12480  case eCASE:
12481  nodeMask = 0;
12482  break;
12483  case eCASEX:
12484  nodeMask = 0;
12485  break;
12486  case eCASEZ:
12487  nodeMask = 0;
12488  break;
12489  case eCASEITEM:
12490  nodeMask = 0;
12491  break;
12492  case eCASSIGN:
12493  nodeMask = 1;
12494  if( !(a->Arg<StrengthPair_t*>(0)==b->Arg<StrengthPair_t*>(0)) ) { return FALSE; }
12495  break;
12496  case eARG:
12497  nodeMask = 1;
12498  if( !(a->Arg<CSymbol*>(0)==b->Arg<CSymbol*>(0)) ) { return FALSE; }
12499  break;
12500  case eIMPORT:
12501  nodeMask = 1;
12502  if( !(a->Arg<CSymbol*>(0)==b->Arg<CSymbol*>(0)) ) { return FALSE; }
12503  break;
12504  case eFUNCTION_DEF:
12505  nodeMask = 1;
12506  if( !(a->Arg<CFunction*>(0)==b->Arg<CFunction*>(0)) ) { return FALSE; }
12507  break;
12508  case eMODULE_DEF:
12509  nodeMask = 1;
12510  if( !(a->Arg<CModule*>(0)==b->Arg<CModule*>(0)) ) { return FALSE; }
12511  break;
12512  case ePACKAGE_DEF:
12513  nodeMask = 1;
12514  if( !(a->Arg<CPackage*>(0)==b->Arg<CPackage*>(0)) ) { return FALSE; }
12515  break;
12516  case eREPEAT_CONTROL:
12517  nodeMask = 0;
12518  break;
12519  case eDELAY_CONTROL:
12520  nodeMask = 0;
12521  break;
12522  case eEVENT_CONTROL:
12523  nodeMask = 0;
12524  break;
12525  case eEXTERNAL_REF:
12526  nodeMask = 1;
12527  if( !(a->Arg<CSymbol*>(0)==b->Arg<CSymbol*>(0)) ) { return FALSE; }
12528  break;
12529  case ePORT_DEF:
12530  nodeMask = 1;
12531  if( !(a->Arg<CPort*>(0)==b->Arg<CPort*>(0)) ) { return FALSE; }
12532  break;
12533  case eDEFPARAM:
12534  nodeMask = 0;
12535  break;
12536  case ePATH:
12537  nodeMask = 45;
12538  if( !(a->Arg<int>(0)==b->Arg<int>(0)) ) { return FALSE; }
12539  if( !(a->Arg<int>(2)==b->Arg<int>(2)) ) { return FALSE; }
12540  if( !(a->Arg<int>(3)==b->Arg<int>(3)) ) { return FALSE; }
12541  if( !(a->Arg<int>(5)==b->Arg<int>(5)) ) { return FALSE; }
12542  break;
12543  case ePATH_ASSIGN:
12544  nodeMask = 0;
12545  break;
12546  case eIFNONE_PATH_ASSIGN:
12547  nodeMask = 0;
12548  break;
12549  case eTRIGGER:
12550  nodeMask = 0;
12551  break;
12552  case ePASSIGN:
12553  nodeMask = 0;
12554  break;
12555  case eDEASSIGN:
12556  nodeMask = 0;
12557  break;
12558  case eDISABLE:
12559  nodeMask = 1;
12560  if( !(a->Arg<CSymbol*>(0)==b->Arg<CSymbol*>(0)) ) { return FALSE; }
12561  break;
12562  case eATTRIBUTE:
12563  nodeMask = 1;
12564  if( !(a->Arg<CAttr*>(0)==b->Arg<CAttr*>(0)) ) { return FALSE; }
12565  break;
12566  case eGIF:
12567  nodeMask = 0;
12568  break;
12569  case eGFOR:
12570  nodeMask = 0;
12571  break;
12572  case eGCASE:
12573  nodeMask = 0;
12574  break;
12575  case eTABLE:
12576  nodeMask = 0;
12577  break;
12578  case eTABLE_ENTRY:
12579  nodeMask = 0;
12580  break;
12581  case eTABLE_SYMBOL:
12582  nodeMask = 1;
12583  if( !(!strcmp(a->Arg<char*>(0),b->Arg<char*>(0))) ) { return FALSE; }
12584  break;
12585  case ePORTLIST_END:
12586  nodeMask = 0;
12587  break;
12588  case eMACRO_EXPR:
12589  nodeMask = 1;
12590  if( !(!strcmp(a->Arg<char*>(0),b->Arg<char*>(0))) ) { return FALSE; }
12591  break;
12592  case eENUM_SPEC:
12593  nodeMask = 1;
12594  if( !(a->Arg<CSymbol*>(0)==b->Arg<CSymbol*>(0)) ) { return FALSE; }
12595  break;
12596  case eMEMBER:
12597  nodeMask = 2;
12598  if( !(a->Arg<CSymbol*>(1)==b->Arg<CSymbol*>(1)) ) { return FALSE; }
12599  break;
12600  case eRETURN:
12601  nodeMask = 0;
12602  break;
12603  case ePREINC:
12604  nodeMask = 0;
12605  break;
12606  case ePOSTINC:
12607  nodeMask = 0;
12608  break;
12609  case ePREDEC:
12610  nodeMask = 0;
12611  break;
12612  case ePOSTDEC:
12613  nodeMask = 0;
12614  break;
12615  case eCAST:
12616  nodeMask = 0;
12617  break;
12618  }
12619 
12620  for( int i = 0; i < a->ArgCount(); i++ ) {
12621  if( !((nodeMask>>i)&1) &&
12622  !Equivalent(a->Arg<CNode*>(i),b->Arg<CNode*>(i)) ) return FALSE;
12623  }
12624  return TRUE;
12625 }
12626 
12627 /*************************************************
12628  IsEvaluateable
12629  - returns true if expression can be evaluated
12630 **************************************************/
12631 
12633 {
12634  switch( op ) {
12635  case eFUNCTION_CALL:
12636  return CFunction::Evaluateable(Arg<CSymbol*>(0),Arg<CNode*>(1),Arg<CBlock*>(2));;
12637  case ePARAM_REF:
12638  return Arg<CParam*>(0)->GetExpression()->IsEvaluateable();
12639  case eENUM_REF:
12640  return Arg<CParam*>(0)->GetExpression()->IsEvaluateable();
12641  case eMACRO_EXPR:
12642  return Arg<CNode*>(1) ? Arg<CNode*>(1)->IsEvaluateable() : FALSE;
12643  case eVCONSTANT:
12644  case eRCONSTANT:
12645  return TRUE;
12646  case eWIDTH:
12647  case eSUB:
12648  case eMUL:
12649  case eDIV:
12650  case ePOW:
12651  case eADD:
12652  case eLSH:
12653  case eRSH:
12654  case eLSHA:
12655  case eRSHA:
12656  case eMOD:
12657  case eOR:
12658  case eAND:
12659  case eXOR:
12660  case eXNOR:
12661  case eCVRI:
12662  case eCVIR:
12663  case eREP:
12664  case eCAT:
12665  case eUCAT:
12666  case eCOM:
12667  case eNEG:
12668  case ePLUS:
12669  case eNOT:
12670  case eGT:
12671  case eGE:
12672  case eLT:
12673  case eLE:
12674  case eLAND:
12675  case eLOR:
12676  case eCEQ:
12677  case eCNE:
12678  case eEQ:
12679  case eNE:
12680  case eRAND:
12681  case eRNAND:
12682  case eROR:
12683  case eRNOR:
12684  case eRXOR:
12685  case eRXNOR:
12686  case eHOOK:
12687  break;
12688  case eERROR:
12689  case eCOMMENT:
12690  case eVRQ:
12691  case ePRAGMA:
12692  case eELIST:
12693  case eNOP:
12694  case eANDANDAND:
12695  case eINSTANCE_REF:
12696  case eGATE_REF:
12697  case eTASK_ENABLE:
12698  case eSYSTASK_CALL:
12699  case eTIMING_CALL:
12700  case eARRAY:
12701  case eNET_REF:
12702  case eVAR_REF:
12703  case ePORT_REF:
12704  case eFWD_REF:
12705  case eGENVAR_REF:
12706  case eTYPE_REF:
12707  case eNET_DECL:
12708  case eVAR_DECL:
12709  case ePARAM_DECL:
12710  case eSPECPARAM_DECL:
12711  case ePORT_DECL:
12712  case eGENVAR_DECL:
12713  case eTYPEDEF_DECL:
12714  case eLIST:
12715  case eRANGE:
12716  case eSLICE:
12717  case ePSLICE:
12718  case eMSLICE:
12719  case eINIT:
12720  case eALWAYS:
12721  case eALWAYS_LATCH:
12722  case eALWAYS_FF:
12723  case eALWAYS_COMB:
12724  case eEVENT:
12725  case eBLOCK_REF:
12726  case eSPECIFY_REF:
12727  case eASSIGN:
12728  case eGASSIGN:
12729  case eADD_ASSIGN:
12730  case eSUB_ASSIGN:
12731  case eMUL_ASSIGN:
12732  case eDIV_ASSIGN:
12733  case eMOD_ASSIGN:
12734  case eAND_ASSIGN:
12735  case eOR_ASSIGN:
12736  case eXOR_ASSIGN:
12737  case eLSH_ASSIGN:
12738  case eRSH_ASSIGN:
12739  case eLSHA_ASSIGN:
12740  case eRSHA_ASSIGN:
12741  case eFORCE:
12742  case eRELEASE:
12743  case eNBASSIGN:
12744  case ePOSEDGE:
12745  case eNEGEDGE:
12746  case eEDGE:
12747  case eEVOR:
12748  case eDELAY:
12749  case eMTM:
12750  case eIF:
12751  case eFOREVER:
12752  case eREPEAT:
12753  case eWHILE:
12754  case eWAIT:
12755  case eFOR:
12756  case eCASE:
12757  case eCASEX:
12758  case eCASEZ:
12759  case eCASEITEM:
12760  case eCASSIGN:
12761  case eARG:
12762  case eIMPORT:
12763  case eFUNCTION_DEF:
12764  case eMODULE_DEF:
12765  case ePACKAGE_DEF:
12766  case eREPEAT_CONTROL:
12767  case eDELAY_CONTROL:
12768  case eEVENT_CONTROL:
12769  case eEXTERNAL_REF:
12770  case ePORT_DEF:
12771  case eDEFPARAM:
12772  case ePATH:
12773  case ePATH_ASSIGN:
12774  case eIFNONE_PATH_ASSIGN:
12775  case eTRIGGER:
12776  case ePASSIGN:
12777  case eDEASSIGN:
12778  case eDISABLE:
12779  case eATTRIBUTE:
12780  case eGIF:
12781  case eGFOR:
12782  case eGCASE:
12783  case eTABLE:
12784  case eTABLE_ENTRY:
12785  case eTABLE_SYMBOL:
12786  case ePORTLIST_END:
12787  case eENUM_SPEC:
12788  case eMEMBER:
12789  case eRETURN:
12790  case ePREINC:
12791  case ePOSTINC:
12792  case ePREDEC:
12793  case ePOSTDEC:
12794  case eCAST:
12795  return FALSE;
12796  default:
12797  MASSERT( FALSE );
12798  }
12799 
12800  for( int i = 0; i < ArgCount(); i++ ) {
12801  if( !Arg<CNode*>(i)->IsEvaluateable() ) return FALSE;
12802  }
12803 
12804  return TRUE;
12805 }
12806 
12807 /*************************************************
12808  _EvalVector
12809  - Helper function for EvalVector.
12810  Evaluates constant vector expression tree.
12811  Requires tree nodes to be labeled and
12812  augmented with conversion nodes.
12813 **************************************************/
12814 
12815 
12816 void CNode::_EvalVector( CVector& v )
12817 {
12818  switch( op ) {
12819  case eVCONSTANT:
12820  { int width = v.GetWidth(); v.SetWidth(Arg<CVector*>(0)->GetWidth()); v = *Arg<CVector*>(0); v.SetWidth(width); };
12821  break;
12822  case eWIDTH:
12823  {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;};
12824  break;
12825  case eSUB:
12826  EVAL_VECTOR_BINARY(Sub);
12827  break;
12828  case eMUL:
12829  EVAL_VECTOR_BINARY(Mul);
12830  break;
12831  case eDIV:
12832  EVAL_VECTOR_BINARY(Div);
12833  break;
12834  case ePOW:
12835  EVAL_VECTOR_BINARY(Pow);
12836  break;
12837  case eADD:
12838  EVAL_VECTOR_BINARY(Add);
12839  break;
12840  case eLSH:
12841  EVAL_VECTOR_BINARY_SELF_RIGHT(Lsh);
12842  break;
12843  case eRSH:
12844  EVAL_VECTOR_BINARY_SELF_RIGHT(Rsh);
12845  break;
12846  case eLSHA:
12847  EVAL_VECTOR_BINARY_SELF_RIGHT(Lsha);
12848  break;
12849  case eRSHA:
12850  EVAL_VECTOR_BINARY_SELF_RIGHT(Rsha);
12851  break;
12852  case eMOD:
12853  EVAL_VECTOR_BINARY(Mod);
12854  break;
12855  case eOR:
12856  EVAL_VECTOR_BINARY(Or);
12857  break;
12858  case eAND:
12859  EVAL_VECTOR_BINARY(And);
12860  break;
12861  case eXOR:
12862  EVAL_VECTOR_BINARY(Xor);
12863  break;
12864  case eXNOR:
12865  EVAL_VECTOR_BINARY(Xnor);
12866  break;
12867  case eFUNCTION_CALL:
12868  CFunction::EvalVector(v,Arg<CSymbol*>(0),Arg<CNode*>(1),Arg<CBlock*>(2));;
12869  break;
12870  case ePARAM_REF:
12871  EVAL_VECTOR_PARAM_REF();
12872  break;
12873  case eENUM_REF:
12874  EVAL_VECTOR_ENUM_REF();
12875  break;
12876  case eCVRI:
12877  v.LoadReal( Arg<CNode*>(0)->_EvalReal() );
12878  break;
12879  case eREP:
12880  EVAL_VECTOR_BINARY(Rep);
12881  break;
12882  case eCAT:
12883  EVAL_VECTOR_BINARY(Cat);
12884  break;
12885  case eUCAT:
12886  { CVector vv(Arg<CNode*>(0)->width); Arg<CNode*>(0)->_EvalVector(vv); v = vv;};
12887  break;
12888  case eCOM:
12889  EVAL_VECTOR_UNARY(Com);
12890  break;
12891  case eNEG:
12892  EVAL_VECTOR_UNARY(Neg);
12893  break;
12894  case ePLUS:
12895  EVAL_VECTOR_UNARY(Plus);
12896  break;
12897  case eNOT:
12898  EVAL_VECTOR_UNARY(Not);
12899  break;
12900  case eGT:
12901  EVAL_RELATIONAL(Gt);
12902  break;
12903  case eGE:
12904  EVAL_RELATIONAL(Ge);
12905  break;
12906  case eLT:
12907  EVAL_RELATIONAL(Lt);
12908  break;
12909  case eLE:
12910  EVAL_RELATIONAL(Le);
12911  break;
12912  case eLAND:
12913  EVAL_VECTOR_BINARY(Land);
12914  break;
12915  case eLOR:
12916  EVAL_VECTOR_BINARY(Lor);
12917  break;
12918  case eCEQ:
12919  EVAL_RELATIONAL(Ceq);
12920  break;
12921  case eCNE:
12922  EVAL_RELATIONAL(Cne);
12923  break;
12924  case eEQ:
12925  EVAL_RELATIONAL(Eq);
12926  break;
12927  case eNE:
12928  EVAL_RELATIONAL(Ne);
12929  break;
12930  case eRAND:
12931  EVAL_VECTOR_UNARY_SELF(Rand);
12932  break;
12933  case eRNAND:
12934  EVAL_VECTOR_UNARY_SELF(Rnand);
12935  break;
12936  case eROR:
12937  EVAL_VECTOR_UNARY_SELF(Ror);
12938  break;
12939  case eRNOR:
12940  EVAL_VECTOR_UNARY_SELF(Rnor);
12941  break;
12942  case eRXOR:
12943  EVAL_VECTOR_UNARY_SELF(Rxor);
12944  break;
12945  case eRXNOR:
12946  EVAL_VECTOR_UNARY_SELF(Rxnor);
12947  break;
12948  case eHOOK:
12949  EVAL_VECTOR_HOOK();
12950  break;
12951  case eMACRO_EXPR:
12952  Arg<CNode*>(1)->EvalVector(v);
12953  break;
12954  default:
12955  MASSERT( FALSE );
12956  }
12957 }
12958 
12959 
12960 /*************************************************
12961  _EvalReal
12962  - Helper function for EvalReal.
12963  Evaluates constant real expression tree.
12964  Requires tree nodes to be labeled and
12965  augmented with conversion nodes.
12966 **************************************************/
12967 
12968 double CNode::_EvalReal()
12969 {
12970  double d;
12971  switch( op ) {
12972  case eRCONSTANT:
12973  d = s2d(Arg<char*>(0));
12974  break;
12975  case eSUB:
12976  EVAL_REAL_BINARY(Sub);
12977  break;
12978  case eMUL:
12979  EVAL_REAL_BINARY(Mul);
12980  break;
12981  case eDIV:
12982  EVAL_REAL_BINARY(Div);
12983  break;
12984  case ePOW:
12985  EVAL_REAL_BINARY(Pow);
12986  break;
12987  case eADD:
12988  EVAL_REAL_BINARY(Add);
12989  break;
12990  case eFUNCTION_CALL:
12991  d = CFunction::EvalReal(Arg<CSymbol*>(0),Arg<CNode*>(1),Arg<CBlock*>(2));;
12992  break;
12993  case ePARAM_REF:
12994  EVAL_REAL_PARAM_REF();
12995  break;
12996  case eENUM_REF:
12997  EVAL_REAL_ENUM_REF();
12998  break;
12999  case eCVIR:
13000  { CVector v(Arg<CNode*>(0)->width); v.Signed(Arg<CNode*>(0)->type == eS); Arg<CNode*>(0)->_EvalVector(v); d = v.GetReal(); };
13001  break;
13002  case eNEG:
13003  EVAL_REAL_UNARY(Neg);
13004  break;
13005  case ePLUS:
13006  EVAL_REAL_UNARY(Plus);
13007  break;
13008  case eHOOK:
13009  EVAL_REAL_HOOK();
13010  break;
13011  case eMACRO_EXPR:
13012  d = Arg<CNode*>(1)->EvalReal();
13013  break;
13014  default:
13015  MASSERT( FALSE );
13016  }
13017  return d;
13018 }
13019 /************************************************
13020  ConditionalWiden
13021  - return non-zero if op conditionally
13022  widens operands
13023 **************************************************/
13024 int CNode::ConditionalWiden()
13025 {
13026  switch( GetOp() ) {
13027  case eVCONSTANT:
13028  return 0;
13029  case eRCONSTANT:
13030  return 0;
13031  case eELIST:
13032  return 0;
13033  case eWIDTH:
13034  return 0;
13035  case eSUB:
13036  return 0;
13037  case eMUL:
13038  return 0;
13039  case eDIV:
13040  return 0;
13041  case ePOW:
13042  return 0;
13043  case eADD:
13044  return 0;
13045  case eLSH:
13046  return 0;
13047  case eRSH:
13048  return 0;
13049  case eLSHA:
13050  return 0;
13051  case eRSHA:
13052  return 0;
13053  case eMOD:
13054  return 0;
13055  case eOR:
13056  return 1;
13057  case eAND:
13058  return 1;
13059  case eANDANDAND:
13060  return 0;
13061  case eXOR:
13062  return 1;
13063  case eXNOR:
13064  return 1;
13065  case eSYSTASK_CALL:
13066  return 0;
13067  case eFUNCTION_CALL:
13068  return 0;
13069  case eARRAY:
13070  return 0;
13071  case eNET_REF:
13072  return 0;
13073  case eVAR_REF:
13074  return 0;
13075  case ePARAM_REF:
13076  return 0;
13077  case ePORT_REF:
13078  return 0;
13079  case eFWD_REF:
13080  return 0;
13081  case eGENVAR_REF:
13082  return 0;
13083  case eENUM_REF:
13084  return 0;
13085  case eTYPE_REF:
13086  return 0;
13087  case eRANGE:
13088  return 0;
13089  case eSLICE:
13090  return 0;
13091  case ePSLICE:
13092  return 0;
13093  case eMSLICE:
13094  return 0;
13095  case eCVRI:
13096  return 0;
13097  case eCVIR:
13098  return 0;
13099  case eREP:
13100  return 0;
13101  case eCAT:
13102  return 0;
13103  case eUCAT:
13104  return 0;
13105  case eCOM:
13106  return 0;
13107  case eNEG:
13108  return 0;
13109  case ePLUS:
13110  return 0;
13111  case eNOT:
13112  return 0;
13113  case eGT:
13114  return 0;
13115  case eGE:
13116  return 0;
13117  case eLT:
13118  return 0;
13119  case eLE:
13120  return 0;
13121  case eLAND:
13122  return 0;
13123  case eLOR:
13124  return 0;
13125  case eCEQ:
13126  return 0;
13127  case eCNE:
13128  return 0;
13129  case eEQ:
13130  return 0;
13131  case eNE:
13132  return 0;
13133  case eRAND:
13134  return 0;
13135  case eRNAND:
13136  return 0;
13137  case eROR:
13138  return 0;
13139  case eRNOR:
13140  return 0;
13141  case eRXOR:
13142  return 0;
13143  case eRXNOR:
13144  return 0;
13145  case eHOOK:
13146  return 0;
13147  case ePOSEDGE:
13148  return 0;
13149  case eNEGEDGE:
13150  return 0;
13151  case eEVOR:
13152  return 0;
13153  case eMTM:
13154  return 0;
13155  case eEXTERNAL_REF:
13156  return 0;
13157  case eATTRIBUTE:
13158  return 0;
13159  case eMACRO_EXPR:
13160  return 0;
13161  case eMEMBER:
13162  return 0;
13163  case ePREINC:
13164  return 0;
13165  case ePOSTINC:
13166  return 0;
13167  case ePREDEC:
13168  return 0;
13169  case ePOSTDEC:
13170  return 0;
13171  case eCAST:
13172  return 0;
13173  default:
13174  MASSERT( FALSE );
13175  }
13176  return 0;
13177 }
13178 
13179 /************************************************
13180  NodeMask
13181  - return a bit vector with 1's where the
13182  type is CNode*
13183 **************************************************/
13184 unsigned CNode::NodeMask()
13185 {
13186  switch( GetOp() ) {
13187  case eERROR:
13188  return 0;
13189  case eVCONSTANT:
13190  return 0;
13191  case eRCONSTANT:
13192  return 0;
13193  case eCOMMENT:
13194  return 0;
13195  case eVRQ:
13196  return 0;
13197  case ePRAGMA:
13198  return 0;
13199  case eELIST:
13200  return 3;
13201  case eWIDTH:
13202  return 3;
13203  case eNOP:
13204  return 0;
13205  case eSUB:
13206  return 3;
13207  case eMUL:
13208  return 3;
13209  case eDIV:
13210  return 3;
13211  case ePOW:
13212  return 3;
13213  case eADD:
13214  return 3;
13215  case eLSH:
13216  return 3;
13217  case eRSH:
13218  return 3;
13219  case eLSHA:
13220  return 3;
13221  case eRSHA:
13222  return 3;
13223  case eMOD:
13224  return 3;
13225  case eOR:
13226  return 3;
13227  case eAND:
13228  return 3;
13229  case eANDANDAND:
13230  return 3;
13231  case eXOR:
13232  return 3;
13233  case eXNOR:
13234  return 3;
13235  case eINSTANCE_REF:
13236  return 0;
13237  case eGATE_REF:
13238  return 0;
13239  case eTASK_ENABLE:
13240  return 2;
13241  case eSYSTASK_CALL:
13242  return 2;
13243  case eTIMING_CALL:
13244  return 2;
13245  case eFUNCTION_CALL:
13246  return 2;
13247  case eARRAY:
13248  return 3;
13249  case eNET_REF:
13250  return 0;
13251  case eVAR_REF:
13252  return 0;
13253  case ePARAM_REF:
13254  return 0;
13255  case ePORT_REF:
13256  return 0;
13257  case eFWD_REF:
13258  return 0;
13259  case eGENVAR_REF:
13260  return 0;
13261  case eENUM_REF:
13262  return 0;
13263  case eTYPE_REF:
13264  return 0;
13265  case eNET_DECL:
13266  return 2;
13267  case eVAR_DECL:
13268  return 2;
13269  case ePARAM_DECL:
13270  return 0;
13271  case eSPECPARAM_DECL:
13272  return 0;
13273  case ePORT_DECL:
13274  return 0;
13275  case eGENVAR_DECL:
13276  return 0;
13277  case eTYPEDEF_DECL:
13278  return 0;
13279  case eLIST:
13280  return 3;
13281  case eRANGE:
13282  return 3;
13283  case eSLICE:
13284  return 3;
13285  case ePSLICE:
13286  return 3;
13287  case eMSLICE:
13288  return 3;
13289  case eCVRI:
13290  return 1;
13291  case eCVIR:
13292  return 1;
13293  case eREP:
13294  return 3;
13295  case eCAT:
13296  return 3;
13297  case eUCAT:
13298  return 1;
13299  case eCOM:
13300  return 1;
13301  case eNEG:
13302  return 1;
13303  case ePLUS:
13304  return 1;
13305  case eNOT:
13306  return 1;
13307  case eGT:
13308  return 3;
13309  case eGE:
13310  return 3;
13311  case eLT:
13312  return 3;
13313  case eLE:
13314  return 3;
13315  case eLAND:
13316  return 3;
13317  case eLOR:
13318  return 3;
13319  case eCEQ:
13320  return 3;
13321  case eCNE:
13322  return 3;
13323  case eEQ:
13324  return 3;
13325  case eNE:
13326  return 3;
13327  case eRAND:
13328  return 1;
13329  case eRNAND:
13330  return 1;
13331  case eROR:
13332  return 1;
13333  case eRNOR:
13334  return 1;
13335  case eRXOR:
13336  return 1;
13337  case eRXNOR:
13338  return 1;
13339  case eHOOK:
13340  return 7;
13341  case eINIT:
13342  return 1;
13343  case eALWAYS:
13344  return 1;
13345  case eALWAYS_LATCH:
13346  return 1;
13347  case eALWAYS_FF:
13348  return 1;
13349  case eALWAYS_COMB:
13350  return 1;
13351  case eEVENT:
13352  return 3;
13353  case eBLOCK_REF:
13354  return 2;
13355  case eSPECIFY_REF:
13356  return 2;
13357  case eASSIGN:
13358  return 7;
13359  case eGASSIGN:
13360  return 6;
13361  case eADD_ASSIGN:
13362  return 7;
13363  case eSUB_ASSIGN:
13364  return 7;
13365  case eMUL_ASSIGN:
13366  return 7;
13367  case eDIV_ASSIGN:
13368  return 7;
13369  case eMOD_ASSIGN:
13370  return 7;
13371  case eAND_ASSIGN:
13372  return 7;
13373  case eOR_ASSIGN:
13374  return 7;
13375  case eXOR_ASSIGN:
13376  return 7;
13377  case eLSH_ASSIGN:
13378  return 7;
13379  case eRSH_ASSIGN:
13380  return 7;
13381  case eLSHA_ASSIGN:
13382  return 7;
13383  case eRSHA_ASSIGN:
13384  return 7;
13385  case eFORCE:
13386  return 3;
13387  case eRELEASE:
13388  return 1;
13389  case eNBASSIGN:
13390  return 7;
13391  case ePOSEDGE:
13392  return 1;
13393  case eNEGEDGE:
13394  return 1;
13395  case eEDGE:
13396  return 1;
13397  case eEVOR:
13398  return 3;
13399  case eDELAY:
13400  return 3;
13401  case eMTM:
13402  return 7;
13403  case eIF:
13404  return 7;
13405  case eFOREVER:
13406  return 1;
13407  case eREPEAT:
13408  return 3;
13409  case eWHILE:
13410  return 3;
13411  case eWAIT:
13412  return 3;
13413  case eFOR:
13414  return 15;
13415  case eCASE:
13416  return 3;
13417  case eCASEX:
13418  return 3;
13419  case eCASEZ:
13420  return 3;
13421  case eCASEITEM:
13422  return 3;
13423  case eCASSIGN:
13424  return 14;
13425  case eARG:
13426  return 2;
13427  case eIMPORT:
13428  return 0;
13429  case eFUNCTION_DEF:
13430  return 0;
13431  case eMODULE_DEF:
13432  return 0;
13433  case ePACKAGE_DEF:
13434  return 0;
13435  case eREPEAT_CONTROL:
13436  return 3;
13437  case eDELAY_CONTROL:
13438  return 1;
13439  case eEVENT_CONTROL:
13440  return 1;
13441  case eEXTERNAL_REF:
13442  return 0;
13443  case ePORT_DEF:
13444  return 0;
13445  case eDEFPARAM:
13446  return 3;
13447  case ePATH:
13448  return 82;
13449  case ePATH_ASSIGN:
13450  return 7;
13451  case eIFNONE_PATH_ASSIGN:
13452  return 3;
13453  case eTRIGGER:
13454  return 1;
13455  case ePASSIGN:
13456  return 3;
13457  case eDEASSIGN:
13458  return 1;
13459  case eDISABLE:
13460  return 0;
13461  case eATTRIBUTE:
13462  return 0;
13463  case eGIF:
13464  return 7;
13465  case eGFOR:
13466  return 15;
13467  case eGCASE:
13468  return 3;
13469  case eTABLE:
13470  return 1;
13471  case eTABLE_ENTRY:
13472  return 1;
13473  case eTABLE_SYMBOL:
13474  return 0;
13475  case ePORTLIST_END:
13476  return 0;
13477  case eMACRO_EXPR:
13478  return 2;
13479  case eENUM_SPEC:
13480  return 6;
13481  case eMEMBER:
13482  return 1;
13483  case eRETURN:
13484  return 1;
13485  case ePREINC:
13486  return 1;
13487  case ePOSTINC:
13488  return 1;
13489  case ePREDEC:
13490  return 1;
13491  case ePOSTDEC:
13492  return 1;
13493  case eCAST:
13494  return 3;
13495  default:
13496  MASSERT( FALSE );
13497  }
13498  return 0;
13499 }
13500 
13501 /************************************************
13502  WidthFixed
13503  - return non-zero if op has fixed
13504  self determined width
13505 **************************************************/
13506 int CNode::WidthFixed()
13507 {
13508  switch( GetOp() ) {
13509  case eVCONSTANT:
13510  return NodeMask()==0;
13511  case eRCONSTANT:
13512  return 1;
13513  case eELIST:
13514  return NodeMask()==0;
13515  case eWIDTH:
13516  return NodeMask()==0;
13517  case eSUB:
13518  return NodeMask()==0;
13519  case eMUL:
13520  return NodeMask()==0;
13521  case eDIV:
13522  return NodeMask()==0;
13523  case ePOW:
13524  return NodeMask()==0;
13525  case eADD:
13526  return NodeMask()==0;
13527  case eLSH:
13528  return NodeMask()==0;
13529  case eRSH:
13530  return NodeMask()==0;
13531  case eLSHA:
13532  return NodeMask()==0;
13533  case eRSHA:
13534  return NodeMask()==0;
13535  case eMOD:
13536  return NodeMask()==0;
13537  case eOR:
13538  return NodeMask()==0;
13539  case eAND:
13540  return NodeMask()==0;
13541  case eANDANDAND:
13542  return NodeMask()==0;
13543  case eXOR:
13544  return NodeMask()==0;
13545  case eXNOR:
13546  return NodeMask()==0;
13547  case eSYSTASK_CALL:
13548  return NodeMask()==0;
13549  case eFUNCTION_CALL:
13550  return NodeMask()==0;
13551  case eARRAY:
13552  return NodeMask()==0;
13553  case eNET_REF:
13554  return NodeMask()==0;
13555  case eVAR_REF:
13556  return NodeMask()==0;
13557  case ePARAM_REF:
13558  return NodeMask()==0;
13559  case ePORT_REF:
13560  return NodeMask()==0;
13561  case eFWD_REF:
13562  return NodeMask()==0;
13563  case eGENVAR_REF:
13564  return NodeMask()==0;
13565  case eENUM_REF:
13566  return NodeMask()==0;
13567  case eTYPE_REF:
13568  return 1;
13569  case eRANGE:
13570  return NodeMask()==0;
13571  case eSLICE:
13572  return NodeMask()==0;
13573  case ePSLICE:
13574  return NodeMask()==0;
13575  case eMSLICE:
13576  return NodeMask()==0;
13577  case eCVRI:
13578  return 1;
13579  case eCVIR:
13580  return 1;
13581  case eREP:
13582  return NodeMask()==0;
13583  case eCAT:
13584  return NodeMask()==0;
13585  case eUCAT:
13586  return NodeMask()==0;
13587  case eCOM:
13588  return NodeMask()==0;
13589  case eNEG:
13590  return NodeMask()==0;
13591  case ePLUS:
13592  return NodeMask()==0;
13593  case eNOT:
13594  return 1;
13595  case eGT:
13596  return 1;
13597  case eGE:
13598  return 1;
13599  case eLT:
13600  return 1;
13601  case eLE:
13602  return 1;
13603  case eLAND:
13604  return 1;
13605  case eLOR:
13606  return 1;
13607  case eCEQ:
13608  return 1;
13609  case eCNE:
13610  return 1;
13611  case eEQ:
13612  return 1;
13613  case eNE:
13614  return 1;
13615  case eRAND:
13616  return 1;
13617  case eRNAND:
13618  return 1;
13619  case eROR:
13620  return 1;
13621  case eRNOR:
13622  return 1;
13623  case eRXOR:
13624  return 1;
13625  case eRXNOR:
13626  return 1;
13627  case eHOOK:
13628  return NodeMask()==0;
13629  case ePOSEDGE:
13630  return NodeMask()==0;
13631  case eNEGEDGE:
13632  return NodeMask()==0;
13633  case eEVOR:
13634  return NodeMask()==0;
13635  case eMTM:
13636  return NodeMask()==0;
13637  case eEXTERNAL_REF:
13638  return NodeMask()==0;
13639  case eATTRIBUTE:
13640  return 1;
13641  case eMACRO_EXPR:
13642  return NodeMask()==0;
13643  case eMEMBER:
13644  return NodeMask()==0;
13645  case ePREINC:
13646  return NodeMask()==0;
13647  case ePOSTINC:
13648  return NodeMask()==0;
13649  case ePREDEC:
13650  return NodeMask()==0;
13651  case ePOSTDEC:
13652  return NodeMask()==0;
13653  case eCAST:
13654  return NodeMask()==0;
13655  default:
13656  MASSERT( FALSE );
13657  }
13658  return 0;
13659 }
13660 
13661 /************************************************
13662  _LabelBits
13663  - labels type and width fields bottom up
13664 **************************************************/
13667  int error;
13668 };
13669 
13670 void CNode::_LabelBits( CNode* n, void* arg )
13671 {
13672  /*
13673  * If label caching is enabled, don't remark nodes
13674  * already visited. Also disable caching when the
13675  * the eval stack is in use and the node was allocated from
13676  * it as its pointers are temporary and will be recycled.
13677  */
13678  if( labelCacheEnabled && (evalCount == 0 || !evalHeap.IsOwner(n)) ) {
13679  if( labelCache.find(n) != labelCache.end() ) {
13680  return;
13681  }
13682  labelCache[n] = 1;
13683  }
13684 
13685 
13686  LabelBitsInfo* info = (LabelBitsInfo*)arg;
13687  int suppressErrorMessages = info->suppressErrorMessages;
13688  unsigned nodeMask = n->NodeMask();
13689  int conditionalWiden = n->ConditionalWiden();
13690 
13691  switch( n->GetOp() ) {
13692  case eVCONSTANT:
13693  n->type = n->Arg<CVector*>(0)->GetNodeType();
13694  break;
13695  case eRCONSTANT:
13696  if(1) {
13697  n->type = eR;
13698  }
13699  break;
13700  case eELIST:
13701  if( n->Arg<CNode*>(0)->type == eR ) {
13702  info->error = 1;
13703  if( !suppressErrorMessages ) {
13704  error(n->GetCoord(), "Illegal expression operand" );
13705  }
13706  } else if( n->Arg<CNode*>(1)->type == eR ) {
13707  info->error = 1;
13708  if( !suppressErrorMessages ) {
13709  error(n->GetCoord(), "Illegal expression operand" );
13710  }
13711  } else if(1) {
13712  n->type = eB;
13713  }
13714  break;
13715  case eWIDTH:
13716  if( n->Arg<CNode*>(1)->type == eS ) {
13717  n->type = eS;
13718  } else if(1) {
13719  n->type = eB;
13720  }
13721  break;
13722  case eSUB:
13723  if( n->Arg<CNode*>(0)->type == eR ) {
13724  n->type = eR;
13725  } else if( n->Arg<CNode*>(1)->type == eR ) {
13726  n->type = eR;
13727  } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
13728  n->type = eS;
13729  } else if(1) {
13730  n->type = eB;
13731  }
13732  break;
13733  case eMUL:
13734  if( n->Arg<CNode*>(0)->type == eR ) {
13735  n->type = eR;
13736  } else if( n->Arg<CNode*>(1)->type == eR ) {
13737  n->type = eR;
13738  } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
13739  n->type = eS;
13740  } else if(1) {
13741  n->type = eB;
13742  }
13743  break;
13744  case eDIV:
13745  if( n->Arg<CNode*>(0)->type == eR ) {
13746  n->type = eR;
13747  } else if( n->Arg<CNode*>(1)->type == eR ) {
13748  n->type = eR;
13749  } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
13750  n->type = eS;
13751  } else if(1) {
13752  n->type = eB;
13753  }
13754  break;
13755  case ePOW:
13756  if( n->Arg<CNode*>(0)->type == eR ) {
13757  n->type = eR;
13758  } else if( n->Arg<CNode*>(1)->type == eR ) {
13759  n->type = eR;
13760  } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
13761  n->type = eS;
13762  } else if(1) {
13763  n->type = eB;
13764  }
13765  break;
13766  case eADD:
13767  if( n->Arg<CNode*>(0)->type == eR ) {
13768  n->type = eR;
13769  } else if( n->Arg<CNode*>(1)->type == eR ) {
13770  n->type = eR;
13771  } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
13772  n->type = eS;
13773  } else if(1) {
13774  n->type = eB;
13775  }
13776  break;
13777  case eLSH:
13778  if( n->Arg<CNode*>(0)->type == eS ) {
13779  n->type = eS;
13780  } else if(1) {
13781  n->type = eB;
13782  }
13783  break;
13784  case eRSH:
13785  if( n->Arg<CNode*>(0)->type == eS ) {
13786  n->type = eS;
13787  } else if(1) {
13788  n->type = eB;
13789  }
13790  break;
13791  case eLSHA:
13792  if( n->Arg<CNode*>(0)->type == eS ) {
13793  n->type = eS;
13794  } else if(1) {
13795  n->type = eB;
13796  }
13797  break;
13798  case eRSHA:
13799  if( n->Arg<CNode*>(0)->type == eS ) {
13800  n->type = eS;
13801  } else if(1) {
13802  n->type = eB;
13803  }
13804  break;
13805  case eMOD:
13806  if( n->Arg<CNode*>(0)->type == eR ) {
13807  info->error = 1;
13808  if( !suppressErrorMessages ) {
13809  error(n->GetCoord(), "Illegal expression operand" );
13810  }
13811  } else if( n->Arg<CNode*>(1)->type == eR ) {
13812  info->error = 1;
13813  if( !suppressErrorMessages ) {
13814  error(n->GetCoord(), "Illegal expression operand" );
13815  }
13816  } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
13817  n->type = eS;
13818  } else if(1) {
13819  n->type = eB;
13820  }
13821  break;
13822  case eOR:
13823  if( n->Arg<CNode*>(0)->type == eR ) {
13824  info->error = 1;
13825  if( !suppressErrorMessages ) {
13826  error(n->GetCoord(), "Illegal expression operand" );
13827  }
13828  } else if( n->Arg<CNode*>(1)->type == eR ) {
13829  info->error = 1;
13830  if( !suppressErrorMessages ) {
13831  error(n->GetCoord(), "Illegal expression operand" );
13832  }
13833  } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
13834  n->type = eS;
13835  } else if(1) {
13836  n->type = eB;
13837  }
13838  break;
13839  case eAND:
13840  if( n->Arg<CNode*>(0)->type == eR ) {
13841  info->error = 1;
13842  if( !suppressErrorMessages ) {
13843  error(n->GetCoord(), "Illegal expression operand" );
13844  }
13845  } else if( n->Arg<CNode*>(1)->type == eR ) {
13846  info->error = 1;
13847  if( !suppressErrorMessages ) {
13848  error(n->GetCoord(), "Illegal expression operand" );
13849  }
13850  } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
13851  n->type = eS;
13852  } else if(1) {
13853  n->type = eB;
13854  }
13855  break;
13856  case eANDANDAND:
13857  if( n->Arg<CNode*>(0)->type == eR ) {
13858  info->error = 1;
13859  if( !suppressErrorMessages ) {
13860  error(n->GetCoord(), "Illegal expression operand" );
13861  }
13862  } else if( n->Arg<CNode*>(1)->type == eR ) {
13863  info->error = 1;
13864  if( !suppressErrorMessages ) {
13865  error(n->GetCoord(), "Illegal expression operand" );
13866  }
13867  } else if(1) {
13868  n->type = eB;
13869  }
13870  break;
13871  case eXOR:
13872  if( n->Arg<CNode*>(0)->type == eR ) {
13873  info->error = 1;
13874  if( !suppressErrorMessages ) {
13875  error(n->GetCoord(), "Illegal expression operand" );
13876  }
13877  } else if( n->Arg<CNode*>(1)->type == eR ) {
13878  info->error = 1;
13879  if( !suppressErrorMessages ) {
13880  error(n->GetCoord(), "Illegal expression operand" );
13881  }
13882  } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
13883  n->type = eS;
13884  } else if(1) {
13885  n->type = eB;
13886  }
13887  break;
13888  case eXNOR:
13889  if( n->Arg<CNode*>(0)->type == eR ) {
13890  info->error = 1;
13891  if( !suppressErrorMessages ) {
13892  error(n->GetCoord(), "Illegal expression operand" );
13893  }
13894  } else if( n->Arg<CNode*>(1)->type == eR ) {
13895  info->error = 1;
13896  if( !suppressErrorMessages ) {
13897  error(n->GetCoord(), "Illegal expression operand" );
13898  }
13899  } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
13900  n->type = eS;
13901  } else if(1) {
13902  n->type = eB;
13903  }
13904  break;
13905  case eSYSTASK_CALL:
13906  n->type = Systask::Type(n->Arg<CSymbol*>(0),n->Arg<CNode*>(1));
13907  break;
13908  case eFUNCTION_CALL:
13909  n->type = CFunction::Type(n->Arg<CSymbol*>(0),n->Arg<CNode*>(1),n->Arg<CScope*>(2));
13910  break;
13911  case eARRAY:
13912  n->type = Array::Type(n->Arg<CNode*>(0),n->Arg<CNode*>(1));
13913  break;
13914  case eNET_REF:
13915  n->type = n->Arg<CNet*>(0)->GetNodeType();
13916  break;
13917  case eVAR_REF:
13918  n->type = n->Arg<CVar*>(0)->GetNodeType();
13919  break;
13920  case ePARAM_REF:
13921  n->type = n->Arg<CParam*>(0)->GetNodeType();
13922  break;
13923  case ePORT_REF:
13924  n->type = n->Arg<CPortDir*>(0)->GetNodeType();
13925  break;
13926  case eFWD_REF:
13927  if(1) {
13928  n->type = eB;
13929  }
13930  break;
13931  case eGENVAR_REF:
13932  n->type = n->Arg<CGenvar*>(0)->GetNodeType();
13933  break;
13934  case eENUM_REF:
13935  n->type = n->Arg<CEnum*>(0)->GetNodeType();
13936  break;
13937  case eTYPE_REF:
13938  if(1) {
13939  n->type = eS;
13940  }
13941  break;
13942  case eRANGE:
13943  if( n->Arg<CNode*>(0)->type == eR ) {
13944  info->error = 1;
13945  if( !suppressErrorMessages ) {
13946  error(n->GetCoord(), "Illegal expression operand" );
13947  }
13948  } else if( n->Arg<CNode*>(1)->type == eR ) {
13949  info->error = 1;
13950  if( !suppressErrorMessages ) {
13951  error(n->GetCoord(), "Illegal expression operand" );
13952  }
13953  } else if(1) {
13954  n->type = eB;
13955  }
13956  break;
13957  case eSLICE:
13958  if( n->Arg<CNode*>(0)->type == eR ) {
13959  info->error = 1;
13960  if( !suppressErrorMessages ) {
13961  error(n->GetCoord(), "Illegal expression operand" );
13962  }
13963  } else if( n->Arg<CNode*>(1)->type == eR ) {
13964  info->error = 1;
13965  if( !suppressErrorMessages ) {
13966  error(n->GetCoord(), "Illegal expression operand" );
13967  }
13968  } else if(1) {
13969  n->type = eB;
13970  }
13971  break;
13972  case ePSLICE:
13973  if( n->Arg<CNode*>(1)->type == eR ) {
13974  info->error = 1;
13975  if( !suppressErrorMessages ) {
13976  error(n->GetCoord(), "Illegal expression operand" );
13977  }
13978  } else if(1) {
13979  n->type = eB;
13980  }
13981  break;
13982  case eMSLICE:
13983  if( n->Arg<CNode*>(1)->type == eR ) {
13984  info->error = 1;
13985  if( !suppressErrorMessages ) {
13986  error(n->GetCoord(), "Illegal expression operand" );
13987  }
13988  } else if(1) {
13989  n->type = eB;
13990  }
13991  break;
13992  case eCVRI:
13993  if(1) {
13994  n->type = eS;
13995  }
13996  break;
13997  case eCVIR:
13998  if(1) {
13999  n->type = eR;
14000  }
14001  break;
14002  case eREP:
14003  if( n->Arg<CNode*>(0)->type == eR ) {
14004  info->error = 1;
14005  if( !suppressErrorMessages ) {
14006  error(n->GetCoord(), "Illegal expression operand" );
14007  }
14008  } else if( n->Arg<CNode*>(1)->type == eR ) {
14009  info->error = 1;
14010  if( !suppressErrorMessages ) {
14011  error(n->GetCoord(), "Illegal expression operand" );
14012  }
14013  } else if(1) {
14014  n->type = eB;
14015  }
14016  break;
14017  case eCAT:
14018  if( n->Arg<CNode*>(0)->type == eR ) {
14019  info->error = 1;
14020  if( !suppressErrorMessages ) {
14021  error(n->GetCoord(), "Illegal expression operand" );
14022  }
14023  } else if( n->Arg<CNode*>(1)->type == eR ) {
14024  info->error = 1;
14025  if( !suppressErrorMessages ) {
14026  error(n->GetCoord(), "Illegal expression operand" );
14027  }
14028  } else if(1) {
14029  n->type = eB;
14030  }
14031  break;
14032  case eUCAT:
14033  if( n->Arg<CNode*>(0)->type == eR ) {
14034  info->error = 1;
14035  if( !suppressErrorMessages ) {
14036  error(n->GetCoord(), "Illegal expression operand" );
14037  }
14038  } else if(1) {
14039  n->type = eB;
14040  }
14041  break;
14042  case eCOM:
14043  if( n->Arg<CNode*>(0)->type == eR ) {
14044  info->error = 1;
14045  if( !suppressErrorMessages ) {
14046  error(n->GetCoord(), "Illegal expression operand" );
14047  }
14048  } else if( n->Arg<CNode*>(0)->type == eS ) {
14049  n->type = eS;
14050  } else if(1) {
14051  n->type = eB;
14052  }
14053  break;
14054  case eNEG:
14055  n->type = n->Arg<CNode*>(0)->type;
14056  break;
14057  case ePLUS:
14058  n->type = n->Arg<CNode*>(0)->type;
14059  break;
14060  case eNOT:
14061  if(1) {
14062  n->type = eB;
14063  }
14064  break;
14065  case eGT:
14066  if(1) {
14067  n->type = eB;
14068  }
14069  break;
14070  case eGE:
14071  if(1) {
14072  n->type = eB;
14073  }
14074  break;
14075  case eLT:
14076  if(1) {
14077  n->type = eB;
14078  }
14079  break;
14080  case eLE:
14081  if(1) {
14082  n->type = eB;
14083  }
14084  break;
14085  case eLAND:
14086  if(1) {
14087  n->type = eB;
14088  }
14089  break;
14090  case eLOR:
14091  if(1) {
14092  n->type = eB;
14093  }
14094  break;
14095  case eCEQ:
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(1) {
14107  n->type = eB;
14108  }
14109  break;
14110  case eCNE:
14111  if( n->Arg<CNode*>(0)->type == eR ) {
14112  info->error = 1;
14113  if( !suppressErrorMessages ) {
14114  error(n->GetCoord(), "Illegal expression operand" );
14115  }
14116  } else if( n->Arg<CNode*>(1)->type == eR ) {
14117  info->error = 1;
14118  if( !suppressErrorMessages ) {
14119  error(n->GetCoord(), "Illegal expression operand" );
14120  }
14121  } else if(1) {
14122  n->type = eB;
14123  }
14124  break;
14125  case eEQ:
14126  if(1) {
14127  n->type = eB;
14128  }
14129  break;
14130  case eNE:
14131  if(1) {
14132  n->type = eB;
14133  }
14134  break;
14135  case eRAND:
14136  if( n->Arg<CNode*>(0)->type == eR ) {
14137  info->error = 1;
14138  if( !suppressErrorMessages ) {
14139  error(n->GetCoord(), "Illegal expression operand" );
14140  }
14141  } else if(1) {
14142  n->type = eB;
14143  }
14144  break;
14145  case eRNAND:
14146  if( n->Arg<CNode*>(0)->type == eR ) {
14147  info->error = 1;
14148  if( !suppressErrorMessages ) {
14149  error(n->GetCoord(), "Illegal expression operand" );
14150  }
14151  } else if(1) {
14152  n->type = eB;
14153  }
14154  break;
14155  case eROR:
14156  if( n->Arg<CNode*>(0)->type == eR ) {
14157  info->error = 1;
14158  if( !suppressErrorMessages ) {
14159  error(n->GetCoord(), "Illegal expression operand" );
14160  }
14161  } else if(1) {
14162  n->type = eB;
14163  }
14164  break;
14165  case eRNOR:
14166  if( n->Arg<CNode*>(0)->type == eR ) {
14167  info->error = 1;
14168  if( !suppressErrorMessages ) {
14169  error(n->GetCoord(), "Illegal expression operand" );
14170  }
14171  } else if(1) {
14172  n->type = eB;
14173  }
14174  break;
14175  case eRXOR:
14176  if( n->Arg<CNode*>(0)->type == eR ) {
14177  info->error = 1;
14178  if( !suppressErrorMessages ) {
14179  error(n->GetCoord(), "Illegal expression operand" );
14180  }
14181  } else if(1) {
14182  n->type = eB;
14183  }
14184  break;
14185  case eRXNOR:
14186  if( n->Arg<CNode*>(0)->type == eR ) {
14187  info->error = 1;
14188  if( !suppressErrorMessages ) {
14189  error(n->GetCoord(), "Illegal expression operand" );
14190  }
14191  } else if(1) {
14192  n->type = eB;
14193  }
14194  break;
14195  case eHOOK:
14196  if( n->Arg<CNode*>(1)->type == eR ) {
14197  n->type = eR;
14198  } else if( n->Arg<CNode*>(2)->type == eR ) {
14199  n->type = eR;
14200  } else if( n->Arg<CNode*>(1)->type == eS && n->Arg<CNode*>(2)->type == eS ) {
14201  n->type = eS;
14202  } else if(1) {
14203  n->type = eB;
14204  }
14205  break;
14206  case ePOSEDGE:
14207  if(1) {
14208  n->type = eE;
14209  }
14210  break;
14211  case eNEGEDGE:
14212  if(1) {
14213  n->type = eE;
14214  }
14215  break;
14216  case eEVOR:
14217  if(1) {
14218  n->type = eE;
14219  }
14220  break;
14221  case eMTM:
14222  if( n->Arg<CNode*>(0)->type == eR ) {
14223  n->type = eR;
14224  } else if( n->Arg<CNode*>(1)->type == eR ) {
14225  n->type = eR;
14226  } else if( n->Arg<CNode*>(2)->type == eR ) {
14227  n->type = eR;
14228  } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS && n->Arg<CNode*>(2)->type == eS ) {
14229  n->type = eS;
14230  } else if(1) {
14231  n->type = eB;
14232  }
14233  break;
14234  case eEXTERNAL_REF:
14235  n->type = External::Type(n->Arg<CSymbol*>(0));
14236  break;
14237  case eATTRIBUTE:
14238  if(1) {
14239  n->type = eU;
14240  }
14241  break;
14242  case eMACRO_EXPR:
14243  n->type = n->Arg<CNode*>(1)->type;
14244  break;
14245  case eMEMBER:
14246  n->type = Member::Type(n->Arg<CNode*>(0),n->Arg<CSymbol*>(1));
14247  break;
14248  case ePREINC:
14249  if( n->Arg<CNode*>(0)->type == eR ) {
14250  n->type = eR;
14251  } else if( n->Arg<CNode*>(0)->type == eS ) {
14252  n->type = eS;
14253  } else if(1) {
14254  n->type = eB;
14255  }
14256  break;
14257  case ePOSTINC:
14258  if( n->Arg<CNode*>(0)->type == eR ) {
14259  n->type = eR;
14260  } else if( n->Arg<CNode*>(0)->type == eS ) {
14261  n->type = eS;
14262  } else if(1) {
14263  n->type = eB;
14264  }
14265  break;
14266  case ePREDEC:
14267  if( n->Arg<CNode*>(0)->type == eR ) {
14268  n->type = eR;
14269  } else if( n->Arg<CNode*>(0)->type == eS ) {
14270  n->type = eS;
14271  } else if(1) {
14272  n->type = eB;
14273  }
14274  break;
14275  case ePOSTDEC:
14276  if( n->Arg<CNode*>(0)->type == eR ) {
14277  n->type = eR;
14278  } else if( n->Arg<CNode*>(0)->type == eS ) {
14279  n->type = eS;
14280  } else if(1) {
14281  n->type = eB;
14282  }
14283  break;
14284  case eCAST:
14285  if(1) {
14286  n->type = eB;
14287  }
14288  break;
14289  default:
14290  MASSERT( FALSE );
14291  }
14292 
14293  /*
14294  * enforce width conventions for fixed width types
14295  */
14296  switch( n->type ) {
14297  case eU:
14298  case eE:
14299  case eR:
14300  n->width = 0;
14301  return;
14302  }
14303 
14304  /*
14305  * set node width
14306  */
14307  switch( n->GetOp() ) {
14308  case eERROR:
14309  n->width = 0;
14310  break;
14311  case eVCONSTANT:
14312  n->width = (!n->Arg<CVector*>(0)->IsWidthEvaluateable()&&suppressErrorMessages) ? 0 : n->Arg<CVector*>(0)->GetWidth();
14313  break;
14314  case eRCONSTANT:
14315  n->width = 0;
14316  break;
14317  case eELIST:
14318  n->width = cADD(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
14319  break;
14320  case eWIDTH:
14321  n->width = ((info->error |= !n->Arg<CNode*>(0)->IsEvaluateable())&&suppressErrorMessages) ? 0 : n->Arg<CNode*>(0)->EvalINT32();
14322  break;
14323  case eSUB:
14324  n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
14325  break;
14326  case eMUL:
14327  n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
14328  break;
14329  case eDIV:
14330  n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
14331  break;
14332  case ePOW:
14333  n->width = n->Arg<CNode*>(0)->width;
14334  break;
14335  case eADD:
14336  n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
14337  break;
14338  case eLSH:
14339  n->width = n->Arg<CNode*>(0)->width;
14340  break;
14341  case eRSH:
14342  n->width = n->Arg<CNode*>(0)->width;
14343  break;
14344  case eLSHA:
14345  n->width = n->Arg<CNode*>(0)->width;
14346  break;
14347  case eRSHA:
14348  n->width = n->Arg<CNode*>(0)->width;
14349  break;
14350  case eMOD:
14351  n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
14352  break;
14353  case eOR:
14354  n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
14355  break;
14356  case eAND:
14357  n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
14358  break;
14359  case eANDANDAND:
14360  n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
14361  break;
14362  case eXOR:
14363  n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
14364  break;
14365  case eXNOR:
14366  n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
14367  break;
14368  case eSYSTASK_CALL:
14369  n->width = Systask::Width(n->Arg<CSymbol*>(0),n->Arg<CNode*>(1));
14370  break;
14371  case eFUNCTION_CALL:
14372  n->width = CFunction::Width(n->Arg<CSymbol*>(0),n->Arg<CNode*>(1),n->Arg<CScope*>(2));
14373  break;
14374  case eARRAY:
14375  n->width = Array::Width(n->Arg<CNode*>(0),n->Arg<CNode*>(1));
14376  break;
14377  case eNET_REF:
14378  n->width = (!n->Arg<CNet*>(0)->IsWidthEvaluateable()&&suppressErrorMessages) ? 0 : n->Arg<CNet*>(0)->GetWidth();
14379  break;
14380  case eVAR_REF:
14381  n->width = (!n->Arg<CVar*>(0)->IsWidthEvaluateable()&&suppressErrorMessages) ? 0 : n->Arg<CVar*>(0)->GetWidth();
14382  break;
14383  case ePARAM_REF:
14384  n->width = (!n->Arg<CParam*>(0)->IsWidthEvaluateable()&&suppressErrorMessages) ? 0 : n->Arg<CParam*>(0)->GetWidth();
14385  break;
14386  case ePORT_REF:
14387  n->width = (!n->Arg<CPortDir*>(0)->IsWidthEvaluateable()&&suppressErrorMessages) ? 0 : n->Arg<CPortDir*>(0)->GetWidth();
14388  break;
14389  case eFWD_REF:
14390  n->width = (!n->Arg<CFref*>(0)->IsWidthEvaluateable()&&suppressErrorMessages) ? 0 : n->Arg<CFref*>(0)->GetWidth();
14391  break;
14392  case eGENVAR_REF:
14393  n->width = (!n->Arg<CGenvar*>(0)->IsWidthEvaluateable()&&suppressErrorMessages) ? 0 : n->Arg<CGenvar*>(0)->GetWidth();
14394  break;
14395  case eENUM_REF:
14396  n->width = (!n->Arg<CEnum*>(0)->IsWidthEvaluateable()&&suppressErrorMessages) ? 0 : n->Arg<CEnum*>(0)->GetWidth();
14397  break;
14398  case eTYPE_REF:
14399  n->width = 32;
14400  break;
14401  case eRANGE:
14402  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());
14403  break;
14404  case eSLICE:
14405  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());
14406  break;
14407  case ePSLICE:
14408  n->width = (!n->Arg<CNode*>(1)->IsEvaluateable()&&suppressErrorMessages) ? 0 : n->Arg<CNode*>(1)->EvalINT32();
14409  break;
14410  case eMSLICE:
14411  n->width = (!n->Arg<CNode*>(1)->IsEvaluateable()&&suppressErrorMessages) ? 0 : n->Arg<CNode*>(1)->EvalINT32();
14412  break;
14413  case eCVRI:
14414  n->width = 32;
14415  break;
14416  case eCVIR:
14417  n->width = 0;
14418  break;
14419  case eREP:
14420  n->width = cMUL(((info->error |= !n->Arg<CNode*>(0)->IsEvaluateable())&&suppressErrorMessages) ? 0: n->Arg<CNode*>(0)->EvalINT32(),n->Arg<CNode*>(1)->width);
14421  break;
14422  case eCAT:
14423  n->width = cADD(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
14424  break;
14425  case eUCAT:
14426  n->width = n->Arg<CNode*>(0)->width;
14427  break;
14428  case eCOM:
14429  n->width = n->Arg<CNode*>(0)->width;
14430  break;
14431  case eNEG:
14432  n->width = n->Arg<CNode*>(0)->width;
14433  break;
14434  case ePLUS:
14435  n->width = n->Arg<CNode*>(0)->width;
14436  break;
14437  case eNOT:
14438  n->width = 1;
14439  break;
14440  case eGT:
14441  n->width = 1;
14442  break;
14443  case eGE:
14444  n->width = 1;
14445  break;
14446  case eLT:
14447  n->width = 1;
14448  break;
14449  case eLE:
14450  n->width = 1;
14451  break;
14452  case eLAND:
14453  n->width = 1;
14454  break;
14455  case eLOR:
14456  n->width = 1;
14457  break;
14458  case eCEQ:
14459  n->width = 1;
14460  break;
14461  case eCNE:
14462  n->width = 1;
14463  break;
14464  case eEQ:
14465  n->width = 1;
14466  break;
14467  case eNE:
14468  n->width = 1;
14469  break;
14470  case eRAND:
14471  n->width = 1;
14472  break;
14473  case eRNAND:
14474  n->width = 1;
14475  break;
14476  case eROR:
14477  n->width = 1;
14478  break;
14479  case eRNOR:
14480  n->width = 1;
14481  break;
14482  case eRXOR:
14483  n->width = 1;
14484  break;
14485  case eRXNOR:
14486  n->width = 1;
14487  break;
14488  case eHOOK:
14489  n->width = cMAX(n->Arg<CNode*>(1)->width,n->Arg<CNode*>(2)->width);
14490  break;
14491  case eMTM:
14492  n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width,n->Arg<CNode*>(2)->width);
14493  break;
14494  case eEXTERNAL_REF:
14495  n->width = External::Width(n->Arg<CSymbol*>(0));
14496  break;
14497  case eATTRIBUTE:
14498  n->width = 0;
14499  break;
14500  case eMACRO_EXPR:
14501  n->width = n->Arg<CNode*>(1)->width;
14502  break;
14503  case eMEMBER:
14504  n->width = Member::Width(n->Arg<CNode*>(0),n->Arg<CSymbol*>(1));
14505  break;
14506  case ePREINC:
14507  n->width = n->Arg<CNode*>(0)->width;
14508  break;
14509  case ePOSTINC:
14510  n->width = n->Arg<CNode*>(0)->width;
14511  break;
14512  case ePREDEC:
14513  n->width = n->Arg<CNode*>(0)->width;
14514  break;
14515  case ePOSTDEC:
14516  n->width = n->Arg<CNode*>(0)->width;
14517  break;
14518  case eCAST:
14519  n->width = ((info->error |= !n->Arg<CNode*>(0)->IsEvaluateable())&&suppressErrorMessages) ? 0 : n->Arg<CNode*>(0)->EvalINT32();
14520  break;
14521  }
14522 
14523  /*
14524  * deterimine if operands have differing width
14525  */
14526  n->FixedWidth(1);
14527  int operandWidth = -1;
14528  for( int i = 0; i < n->ArgCount(); i++ ) {
14529  if( ((nodeMask>>i)&1) && n->Arg<CNode*>(i) ) {
14530  int widthFixed = n->Arg<CNode*>(i)->WidthFixed() ||
14531  n->Arg<CNode*>(i)->FixedWidth();
14532 
14533  if( n->ConditionalWiden() && !widthFixed ) {
14534  n->FixedWidth( 0 );
14535  break;
14536  } else if( !widthFixed ) {
14537  n->FixedWidth( 0 );
14538  break;
14539  } else {
14540  int w = n->Arg<CNode*>(i)->width;
14541  if( operandWidth != w ) {
14542  if( operandWidth >= 0 ) {
14543  n->FixedWidth( 0 );
14544  break;
14545  }
14546  operandWidth = w;
14547  }
14548  }
14549  }
14550  }
14551  if( !conditionalWiden && nodeMask != 0 ) {
14552  n->FixedWidth( 0 );
14553  }
14554 }
14555 
14556 /************************************************
14557  FixBits
14558  - relabels node width based on destination
14559  width and type. Add type conversions
14560  and check argument types. Assumes
14561  LabelBits has already been called and
14562  no illegal operand types are present.
14563 **************************************************/
14564 
14565 CNode* CNode::FixBits( INT32 newWidth, NodeType_t newType )
14566 {
14567 
14568  int calculateMax = 0;
14569  int realOp = 0;
14570  int conditionalWiden = ConditionalWiden();
14571  unsigned nodeMask = NodeMask();
14572  unsigned scalarMask = 0;
14573  unsigned selfDeterminedMask = 0;
14574  switch( GetOp() ) {
14575  case eERROR:
14576  realOp = 0;
14577  break;
14578  case eVCONSTANT:
14579  realOp = 0;
14580  break;
14581  case eRCONSTANT:
14582  realOp = 0;
14583  break;
14584  case eCOMMENT:
14585  realOp = 0;
14586  break;
14587  case eVRQ:
14588  realOp = 0;
14589  break;
14590  case ePRAGMA:
14591  realOp = 0;
14592  break;
14593  case eELIST:
14594  realOp = 0;
14595  selfDeterminedMask = nodeMask;
14596  break;
14597  case eWIDTH:
14598  realOp = 0;
14599  selfDeterminedMask = nodeMask;
14600  break;
14601  case eNOP:
14602  realOp = 0;
14603  break;
14604  case eSUB:
14605  realOp = 1;
14606  break;
14607  case eMUL:
14608  realOp = 1;
14609  break;
14610  case eDIV:
14611  realOp = 1;
14612  break;
14613  case ePOW:
14614  realOp = 1;
14615  selfDeterminedMask = 1<<1;
14616  break;
14617  case eADD:
14618  realOp = 1;
14619  break;
14620  case eLSH:
14621  realOp = 0;
14622  selfDeterminedMask = 1<<1;
14623  break;
14624  case eRSH:
14625  realOp = 0;
14626  selfDeterminedMask = 1<<1;
14627  break;
14628  case eLSHA:
14629  realOp = 0;
14630  selfDeterminedMask = 1<<1;
14631  break;
14632  case eRSHA:
14633  realOp = 0;
14634  selfDeterminedMask = 1<<1;
14635  break;
14636  case eMOD:
14637  realOp = 0;
14638  break;
14639  case eOR:
14640  realOp = 0;
14641  break;
14642  case eAND:
14643  realOp = 0;
14644  break;
14645  case eANDANDAND:
14646  realOp = 0;
14647  break;
14648  case eXOR:
14649  realOp = 0;
14650  break;
14651  case eXNOR:
14652  realOp = 0;
14653  break;
14654  case eINSTANCE_REF:
14655  realOp = 0;
14656  break;
14657  case eGATE_REF:
14658  realOp = 0;
14659  break;
14660  case eTASK_ENABLE:
14661  realOp = 0;
14662  break;
14663  case eSYSTASK_CALL:
14664  realOp = 0;
14665  selfDeterminedMask = nodeMask;
14666  break;
14667  case eTIMING_CALL:
14668  realOp = 0;
14669  break;
14670  case eFUNCTION_CALL:
14671  realOp = 0;
14672  selfDeterminedMask = nodeMask;
14673  break;
14674  case eARRAY:
14675  realOp = 0;
14676  selfDeterminedMask = 1<<1;
14677  break;
14678  case eNET_REF:
14679  realOp = 0;
14680  break;
14681  case eVAR_REF:
14682  realOp = 0;
14683  break;
14684  case ePARAM_REF:
14685  realOp = 0;
14686  break;
14687  case ePORT_REF:
14688  realOp = 0;
14689  break;
14690  case eFWD_REF:
14691  realOp = 0;
14692  break;
14693  case eGENVAR_REF:
14694  realOp = 0;
14695  break;
14696  case eENUM_REF:
14697  realOp = 0;
14698  break;
14699  case eTYPE_REF:
14700  realOp = 0;
14701  break;
14702  case eNET_DECL:
14703  realOp = 0;
14704  break;
14705  case eVAR_DECL:
14706  realOp = 0;
14707  break;
14708  case ePARAM_DECL:
14709  realOp = 0;
14710  break;
14711  case eSPECPARAM_DECL:
14712  realOp = 0;
14713  break;
14714  case ePORT_DECL:
14715  realOp = 0;
14716  break;
14717  case eGENVAR_DECL:
14718  realOp = 0;
14719  break;
14720  case eTYPEDEF_DECL:
14721  realOp = 0;
14722  break;
14723  case eLIST:
14724  realOp = 0;
14725  break;
14726  case eRANGE:
14727  realOp = 0;
14728  selfDeterminedMask = nodeMask;
14729  break;
14730  case eSLICE:
14731  realOp = 0;
14732  selfDeterminedMask = nodeMask;
14733  break;
14734  case ePSLICE:
14735  realOp = 0;
14736  selfDeterminedMask = nodeMask;
14737  break;
14738  case eMSLICE:
14739  realOp = 0;
14740  selfDeterminedMask = nodeMask;
14741  break;
14742  case eCVRI:
14743  realOp = 0;
14744  selfDeterminedMask = nodeMask;
14745  break;
14746  case eCVIR:
14747  realOp = 0;
14748  selfDeterminedMask = nodeMask;
14749  break;
14750  case eREP:
14751  realOp = 0;
14752  selfDeterminedMask = nodeMask;
14753  break;
14754  case eCAT:
14755  realOp = 0;
14756  selfDeterminedMask = nodeMask;
14757  break;
14758  case eUCAT:
14759  realOp = 0;
14760  selfDeterminedMask = nodeMask;
14761  break;
14762  case eCOM:
14763  realOp = 0;
14764  break;
14765  case eNEG:
14766  realOp = 0;
14767  break;
14768  case ePLUS:
14769  realOp = 0;
14770  break;
14771  case eNOT:
14772  realOp = 0;
14773  scalarMask = 1;
14774  break;
14775  case eGT:
14776  realOp = 0;
14777  calculateMax = 1;
14778  break;
14779  case eGE:
14780  realOp = 0;
14781  calculateMax = 1;
14782  break;
14783  case eLT:
14784  realOp = 0;
14785  calculateMax = 1;
14786  break;
14787  case eLE:
14788  realOp = 0;
14789  calculateMax = 1;
14790  break;
14791  case eLAND:
14792  realOp = 0;
14793  scalarMask = 3;
14794  break;
14795  case eLOR:
14796  realOp = 0;
14797  scalarMask = 3;
14798  break;
14799  case eCEQ:
14800  realOp = 0;
14801  calculateMax = 1;
14802  break;
14803  case eCNE:
14804  realOp = 0;
14805  calculateMax = 1;
14806  break;
14807  case eEQ:
14808  realOp = 0;
14809  calculateMax = 1;
14810  break;
14811  case eNE:
14812  realOp = 0;
14813  calculateMax = 1;
14814  break;
14815  case eRAND:
14816  realOp = 0;
14817  selfDeterminedMask = nodeMask;
14818  break;
14819  case eRNAND:
14820  realOp = 0;
14821  selfDeterminedMask = nodeMask;
14822  break;
14823  case eROR:
14824  realOp = 0;
14825  selfDeterminedMask = nodeMask;
14826  break;
14827  case eRNOR:
14828  realOp = 0;
14829  selfDeterminedMask = nodeMask;
14830  break;
14831  case eRXOR:
14832  realOp = 0;
14833  selfDeterminedMask = nodeMask;
14834  break;
14835  case eRXNOR:
14836  realOp = 0;
14837  selfDeterminedMask = nodeMask;
14838  break;
14839  case eHOOK:
14840  realOp = 1;
14841  scalarMask = 1;
14842  break;
14843  case eINIT:
14844  realOp = 0;
14845  break;
14846  case eALWAYS:
14847  realOp = 0;
14848  break;
14849  case eALWAYS_LATCH:
14850  realOp = 0;
14851  break;
14852  case eALWAYS_FF:
14853  realOp = 0;
14854  break;
14855  case eALWAYS_COMB:
14856  realOp = 0;
14857  break;
14858  case eEVENT:
14859  realOp = 0;
14860  break;
14861  case eBLOCK_REF:
14862  realOp = 0;
14863  break;
14864  case eSPECIFY_REF:
14865  realOp = 0;
14866  break;
14867  case eASSIGN:
14868  realOp = 0;
14869  break;
14870  case eGASSIGN:
14871  realOp = 0;
14872  break;
14873  case eADD_ASSIGN:
14874  realOp = 0;
14875  break;
14876  case eSUB_ASSIGN:
14877  realOp = 0;
14878  break;
14879  case eMUL_ASSIGN:
14880  realOp = 0;
14881  break;
14882  case eDIV_ASSIGN:
14883  realOp = 0;
14884  break;
14885  case eMOD_ASSIGN:
14886  realOp = 0;
14887  break;
14888  case eAND_ASSIGN:
14889  realOp = 0;
14890  break;
14891  case eOR_ASSIGN:
14892  realOp = 0;
14893  break;
14894  case eXOR_ASSIGN:
14895  realOp = 0;
14896  break;
14897  case eLSH_ASSIGN:
14898  realOp = 0;
14899  break;
14900  case eRSH_ASSIGN:
14901  realOp = 0;
14902  break;
14903  case eLSHA_ASSIGN:
14904  realOp = 0;
14905  break;
14906  case eRSHA_ASSIGN:
14907  realOp = 0;
14908  break;
14909  case eFORCE:
14910  realOp = 0;
14911  break;
14912  case eRELEASE:
14913  realOp = 0;
14914  break;
14915  case eNBASSIGN:
14916  realOp = 0;
14917  break;
14918  case ePOSEDGE:
14919  realOp = 0;
14920  break;
14921  case eNEGEDGE:
14922  realOp = 0;
14923  break;
14924  case eEDGE:
14925  realOp = 0;
14926  break;
14927  case eEVOR:
14928  realOp = 0;
14929  break;
14930  case eDELAY:
14931  realOp = 0;
14932  break;
14933  case eMTM:
14934  realOp = 1;
14935  break;
14936  case eIF:
14937  realOp = 0;
14938  break;
14939  case eFOREVER:
14940  realOp = 0;
14941  break;
14942  case eREPEAT:
14943  realOp = 0;
14944  break;
14945  case eWHILE:
14946  realOp = 0;
14947  break;
14948  case eWAIT:
14949  realOp = 0;
14950  break;
14951  case eFOR:
14952  realOp = 0;
14953  break;
14954  case eCASE:
14955  realOp = 0;
14956  break;
14957  case eCASEX:
14958  realOp = 0;
14959  break;
14960  case eCASEZ:
14961  realOp = 0;
14962  break;
14963  case eCASEITEM:
14964  realOp = 0;
14965  break;
14966  case eCASSIGN:
14967  realOp = 0;
14968  break;
14969  case eARG:
14970  realOp = 0;
14971  break;
14972  case eIMPORT:
14973  realOp = 0;
14974  break;
14975  case eFUNCTION_DEF:
14976  realOp = 0;
14977  break;
14978  case eMODULE_DEF:
14979  realOp = 0;
14980  break;
14981  case ePACKAGE_DEF:
14982  realOp = 0;
14983  break;
14984  case eREPEAT_CONTROL:
14985  realOp = 0;
14986  break;
14987  case eDELAY_CONTROL:
14988  realOp = 0;
14989  break;
14990  case eEVENT_CONTROL:
14991  realOp = 0;
14992  break;
14993  case eEXTERNAL_REF:
14994  realOp = 0;
14995  break;
14996  case ePORT_DEF:
14997  realOp = 0;
14998  break;
14999  case eDEFPARAM:
15000  realOp = 0;
15001  break;
15002  case ePATH:
15003  realOp = 0;
15004  break;
15005  case ePATH_ASSIGN:
15006  realOp = 0;
15007  break;
15008  case eIFNONE_PATH_ASSIGN:
15009  realOp = 0;
15010  break;
15011  case eTRIGGER:
15012  realOp = 0;
15013  break;
15014  case ePASSIGN:
15015  realOp = 0;
15016  break;
15017  case eDEASSIGN:
15018  realOp = 0;
15019  break;
15020  case eDISABLE:
15021  realOp = 0;
15022  break;
15023  case eATTRIBUTE:
15024  realOp = 0;
15025  break;
15026  case eGIF:
15027  realOp = 0;
15028  break;
15029  case eGFOR:
15030  realOp = 0;
15031  break;
15032  case eGCASE:
15033  realOp = 0;
15034  break;
15035  case eTABLE:
15036  realOp = 0;
15037  break;
15038  case eTABLE_ENTRY:
15039  realOp = 0;
15040  break;
15041  case eTABLE_SYMBOL:
15042  realOp = 0;
15043  break;
15044  case ePORTLIST_END:
15045  realOp = 0;
15046  break;
15047  case eMACRO_EXPR:
15048  realOp = 0;
15049  break;
15050  case eENUM_SPEC:
15051  realOp = 0;
15052  break;
15053  case eMEMBER:
15054  realOp = 0;
15055  break;
15056  case eRETURN:
15057  realOp = 0;
15058  break;
15059  case ePREINC:
15060  realOp = 1;
15061  break;
15062  case ePOSTINC:
15063  realOp = 1;
15064  break;
15065  case ePREDEC:
15066  realOp = 1;
15067  break;
15068  case ePOSTDEC:
15069  realOp = 1;
15070  break;
15071  case eCAST:
15072  realOp = 0;
15073  selfDeterminedMask = nodeMask;
15074  break;
15075  default:
15076  MASSERT( FALSE );
15077  }
15078  /*
15079  * find location of all real args
15080  */
15081  unsigned realMask = 0;
15082  unsigned forceRealMask = 0;
15083  int widthsDiffer = 0;
15084  int originalWidth = width;
15085  for( int i = 0; i < ArgCount(); i++ ) {
15086  if( ((nodeMask>>i)&1) && Arg<CNode*>(i)->type == eR ) {
15087  realMask |= 1<<i;
15088  }
15089  if( ((nodeMask>>i)&1) &&
15090  Arg<CNode*>(i)->type != eR &&
15091  (Arg<CNode*>(i)->GetOp() != eVCONSTANT ||
15092  Arg<CNode*>(i)->width != width) ) {
15093  widthsDiffer = 1;
15094  }
15095  }
15096 
15097  /*
15098  * if new type is undetermined, use current type and width
15099  */
15100  if( newType == eU && newWidth == 0 ) {
15101  newType = type;
15102  newWidth = width;
15103  /*
15104  * increase expression width if new width is larger
15105  * and a vector
15106  */
15107  } else if( (newType == eB || newType == eS || newType == eU) &&
15108  (type == eB || type == eS) ) {
15109  if( newWidth > width ) {
15110  width = newWidth;
15111  }
15112  if( newType == eU ) {
15113  newType = type;
15114  }
15115  }
15116 
15117  MASSERT( newType != eR || newWidth == 0 );
15118  MASSERT( newType != eE || newWidth == 0 );
15119 
15120 
15121  /*
15122  * non-real operands are self determined when mixed with real
15123  */
15124  if( realMask ) {
15125  forceRealMask = (~realMask & nodeMask);
15126  }
15127 
15128  /*
15129  * special case for bit operations
15130  * Only widen if operand widths differ
15131  */
15132  int convertWidth = conditionalWiden && FixedWidth();
15133  if( convertWidth ) {
15134  width = originalWidth;
15135  }
15136  if( newType == eB && type == eS ) {
15137  type = eB;
15138  }
15139  /*
15140  * calculate max with of args if needed
15141  */
15142  int cWidth = width;
15143  NodeType_t cType = type;
15144  if( calculateMax ) {
15145  cType = eS;
15146  int max = 0;
15147  int foundReal = 0;
15148  int foundUnsigned = 0;
15149  for( int i = 0; i < ArgCount(); i++ ) {
15150  if( (nodeMask>>i)&1 ) {
15151  switch( Arg<CNode*>(i)->type ) {
15152  case eB:
15153  foundUnsigned = 1;
15154  break;
15155  case eR:
15156  foundReal = 1;
15157  break;
15158  }
15159  if( Arg<CNode*>(i)->width > max ) {
15160  max = Arg<CNode*>(i)->width;
15161  }
15162  }
15163  }
15164  if( foundReal ) {
15165  cWidth = 0;
15166  cType = eR;
15167  } else if( foundUnsigned ) {
15168  cType = eB;
15169  cWidth = max;
15170  } else {
15171  cWidth = max;
15172  }
15173  }
15174 
15175  /*
15176  * Fix each CNode* argument
15177  */
15178  for( int i = 0; i < ArgCount(); i++ ) {
15179  if( (nodeMask>>i)&1 ) {
15180  if( (scalarMask>>i)&1 ) {
15181  if( Arg<CNode*>(i)->type == eR ) {
15182  CNode* node;
15183  Arg<CNode*>(i) = cNE( Arg<CNode*>(i), cREAL(0), &loc );
15184  Arg<CNode*>(i)->LabelBits();
15185  } else if( type == eR ) {
15186  // Hack for ? operator
15187  CNode* node;
15188  Arg<CNode*>(i) = cCNE( Arg<CNode*>(i), cINT32(0), &loc );
15189  Arg<CNode*>(i)->LabelBits();
15190  }
15191  Arg<CNode*>(i) = Arg<CNode*>(i)->FixBits( 0, eU );
15192  } else if( (forceRealMask>>i)&1 ) {
15193  Arg<CNode*>(i) = Arg<CNode*>(i)->FixBits( 0, eR );
15194  } else if( (selfDeterminedMask>>i)&1 ) {
15195  Arg<CNode*>(i) = Arg<CNode*>(i)->FixBits( 0, eU );
15196  } else {
15197  Arg<CNode*>(i) = Arg<CNode*>(i)->FixBits( cWidth, cType );
15198  }
15199  }
15200  }
15201 
15202 
15203 
15204  /*
15205  * add conversions if needed
15206  */
15207  if( newType != eR && convertWidth ) {
15208  CNode* nn = cWIDTH(cINT32(newWidth), this);
15209  nn->width = newWidth;
15210  nn->type = type;
15211  return nn;
15212  }
15213  if( newType == eR && (type == eB || type == eS) ) {
15214  CNode* nn = cCVIR( this );
15215  nn->width = 0;
15216  nn->type = eR;
15217  return nn;
15218 
15219  } else if( (newType == eB || newType == eS) && type == eR ) {
15220  CNode* nn = cCVRI( this );
15221  nn->width = newWidth;
15222  nn->type = newType;
15223  return nn;
15224  }
15225 
15226  return this;
15227 }
15228 
15229 /*************************************************
15230  Dump
15231  - dump expression for debug
15232 **************************************************/
15233 void CNode::Dump( FILE* f )
15234 {
15235  switch( GetOp() ) {
15236  case eERROR:
15237  fprintf( f, "%s", "???" );
15238  break;
15239  case eVCONSTANT:
15240  fprintf( f, "%s", Arg<CVector*>(0)->GetVString() );
15241  break;
15242  case eRCONSTANT:
15243  fprintf( f, "%s", (char*)Arg<char*>(0) );
15244  break;
15245  case ePRAGMA:
15246  fprintf( f, "%s", (char*)Arg<char*>(0) );
15247  break;
15248  case eELIST:
15249  fprintf( f, "%s", "" );
15250  Arg<CNode*>(0)->Dump( f );
15251  fprintf( f, "%s", "," );
15252  Arg<CNode*>(1)->Dump( f );
15253  fprintf( f, "%s", "" );
15254  break;
15255  case eWIDTH:
15256  fprintf( f, "%s", "WIDTH(" );
15257  fprintf( f, "%s", type==eS ? "S" : "U" );
15258  fprintf( f, "%s", "," );
15259  fprintf( f, "%ld", width );
15260  fprintf( f, "%s", "," );
15261  Arg<CNode*>(0)->Dump( f );
15262  fprintf( f, "%s", "," );
15263  Arg<CNode*>(1)->Dump( f );
15264  fprintf( f, "%s", ")" );
15265  break;
15266  case eSUB:
15267  fprintf( f, "%s", "(" );
15268  Arg<CNode*>(0)->Dump( f );
15269  fprintf( f, "%s", ")-(" );
15270  Arg<CNode*>(1)->Dump( f );
15271  fprintf( f, "%s", ")" );
15272  break;
15273  case eMUL:
15274  fprintf( f, "%s", "(" );
15275  Arg<CNode*>(0)->Dump( f );
15276  fprintf( f, "%s", ")*(" );
15277  Arg<CNode*>(1)->Dump( f );
15278  fprintf( f, "%s", ")" );
15279  break;
15280  case eDIV:
15281  fprintf( f, "%s", "(" );
15282  Arg<CNode*>(0)->Dump( f );
15283  fprintf( f, "%s", ")/(" );
15284  Arg<CNode*>(1)->Dump( f );
15285  fprintf( f, "%s", ")" );
15286  break;
15287  case ePOW:
15288  fprintf( f, "%s", "(" );
15289  Arg<CNode*>(0)->Dump( f );
15290  fprintf( f, "%s", ")**(" );
15291  Arg<CNode*>(1)->Dump( f );
15292  fprintf( f, "%s", ")" );
15293  break;
15294  case eADD:
15295  fprintf( f, "%s", "(" );
15296  Arg<CNode*>(0)->Dump( f );
15297  fprintf( f, "%s", ")+(" );
15298  Arg<CNode*>(1)->Dump( f );
15299  fprintf( f, "%s", ")" );
15300  break;
15301  case eLSH:
15302  fprintf( f, "%s", "(" );
15303  Arg<CNode*>(0)->Dump( f );
15304  fprintf( f, "%s", ")<<(" );
15305  Arg<CNode*>(1)->Dump( f );
15306  fprintf( f, "%s", ")" );
15307  break;
15308  case eRSH:
15309  fprintf( f, "%s", "(" );
15310  Arg<CNode*>(0)->Dump( f );
15311  fprintf( f, "%s", ")>>(" );
15312  Arg<CNode*>(1)->Dump( f );
15313  fprintf( f, "%s", ")" );
15314  break;
15315  case eLSHA:
15316  fprintf( f, "%s", "(" );
15317  Arg<CNode*>(0)->Dump( f );
15318  fprintf( f, "%s", ")<<<(" );
15319  Arg<CNode*>(1)->Dump( f );
15320  fprintf( f, "%s", ")" );
15321  break;
15322  case eRSHA:
15323  fprintf( f, "%s", "(" );
15324  Arg<CNode*>(0)->Dump( f );
15325  fprintf( f, "%s", ")>>>(" );
15326  Arg<CNode*>(1)->Dump( f );
15327  fprintf( f, "%s", ")" );
15328  break;
15329  case eMOD:
15330  fprintf( f, "%s", "(" );
15331  Arg<CNode*>(0)->Dump( f );
15332  fprintf( f, "%s", ")%%(" );
15333  Arg<CNode*>(1)->Dump( f );
15334  fprintf( f, "%s", ")" );
15335  break;
15336  case eOR:
15337  fprintf( f, "%s", "(" );
15338  Arg<CNode*>(0)->Dump( f );
15339  fprintf( f, "%s", ")|(" );
15340  Arg<CNode*>(1)->Dump( f );
15341  fprintf( f, "%s", ")" );
15342  break;
15343  case eAND:
15344  fprintf( f, "%s", "(" );
15345  Arg<CNode*>(0)->Dump( f );
15346  fprintf( f, "%s", ")&(" );
15347  Arg<CNode*>(1)->Dump( f );
15348  fprintf( f, "%s", ")" );
15349  break;
15350  case eANDANDAND:
15351  fprintf( f, "%s", "(" );
15352  Arg<CNode*>(0)->Dump( f );
15353  fprintf( f, "%s", ")&&&(" );
15354  Arg<CNode*>(1)->Dump( f );
15355  fprintf( f, "%s", ")" );
15356  break;
15357  case eXOR:
15358  fprintf( f, "%s", "(" );
15359  Arg<CNode*>(0)->Dump( f );
15360  fprintf( f, "%s", ")^(" );
15361  Arg<CNode*>(1)->Dump( f );
15362  fprintf( f, "%s", ")" );
15363  break;
15364  case eXNOR:
15365  fprintf( f, "%s", "(" );
15366  Arg<CNode*>(0)->Dump( f );
15367  fprintf( f, "%s", ")~^(" );
15368  Arg<CNode*>(1)->Dump( f );
15369  fprintf( f, "%s", ")" );
15370  break;
15371  case eFUNCTION_CALL:
15372  fprintf( f, "%s", "" );
15373  fprintf( f, "%s", Arg<CSymbol*>(0)->GetName() );
15374  fprintf( f, "%s", "(" );
15375  Arg<CNode*>(1)->Dump( f );
15376  fprintf( f, "%s", ")" );
15377  break;
15378  case eARRAY:
15379  fprintf( f, "%s", "" );
15380  Arg<CNode*>(0)->Dump( f );
15381  fprintf( f, "%s", "[" );
15382  Arg<CNode*>(1)->Dump( f );
15383  fprintf( f, "%s", "]" );
15384  break;
15385  case eNET_REF:
15386  fprintf( f, "%s", Arg<CNet*>(0)->GetName() );
15387  break;
15388  case eVAR_REF:
15389  fprintf( f, "%s", Arg<CVar*>(0)->GetName() );
15390  break;
15391  case ePARAM_REF:
15392  fprintf( f, "%s", Arg<CParam*>(0)->GetName() );
15393  break;
15394  case ePORT_REF:
15395  fprintf( f, "%s", Arg<CPort*>(0)->GetName() );
15396  break;
15397  case eFWD_REF:
15398  fprintf( f, "%s", Arg<CFref*>(0)->GetName() );
15399  break;
15400  case eGENVAR_REF:
15401  fprintf( f, "%s", Arg<CGenvar*>(0)->GetName() );
15402  break;
15403  case eENUM_REF:
15404  fprintf( f, "%s", Arg<CEnum*>(0)->GetName() );
15405  break;
15406  case eTYPE_REF:
15407  fprintf( f, "%s", Arg<CTypedef*>(0)->GetName() );
15408  break;
15409  case eVAR_DECL:
15410  fprintf( f, "%s", "VarDecl" );
15411  break;
15412  case eLIST:
15413  fprintf( f, "%s", "(" );
15414  Arg<CNode*>(0)->Dump( f );
15415  fprintf( f, "%s", "," );
15416  Arg<CNode*>(1)->Dump( f );
15417  fprintf( f, "%s", ")" );
15418  break;
15419  case eRANGE:
15420  fprintf( f, "%s", "" );
15421  Arg<CNode*>(0)->Dump( f );
15422  fprintf( f, "%s", ":" );
15423  Arg<CNode*>(1)->Dump( f );
15424  fprintf( f, "%s", "" );
15425  break;
15426  case eSLICE:
15427  fprintf( f, "%s", "" );
15428  Arg<CNode*>(0)->Dump( f );
15429  fprintf( f, "%s", ":" );
15430  Arg<CNode*>(1)->Dump( f );
15431  fprintf( f, "%s", "" );
15432  break;
15433  case ePSLICE:
15434  fprintf( f, "%s", "" );
15435  Arg<CNode*>(0)->Dump( f );
15436  fprintf( f, "%s", "+:" );
15437  Arg<CNode*>(1)->Dump( f );
15438  fprintf( f, "%s", "" );
15439  break;
15440  case eMSLICE:
15441  fprintf( f, "%s", "" );
15442  Arg<CNode*>(0)->Dump( f );
15443  fprintf( f, "%s", "-:" );
15444  Arg<CNode*>(1)->Dump( f );
15445  fprintf( f, "%s", "" );
15446  break;
15447  case eCVRI:
15448  fprintf( f, "%s", "CVRI(" );
15449  Arg<CNode*>(0)->Dump( f );
15450  fprintf( f, "%s", ")" );
15451  break;
15452  case eCVIR:
15453  fprintf( f, "%s", "CVIR(" );
15454  Arg<CNode*>(0)->Dump( f );
15455  fprintf( f, "%s", ")" );
15456  break;
15457  case eREP:
15458  fprintf( f, "%s", "{" );
15459  Arg<CNode*>(0)->Dump( f );
15460  fprintf( f, "%s", "{" );
15461  Arg<CNode*>(1)->Dump( f );
15462  fprintf( f, "%s", "}}" );
15463  break;
15464  case eCAT:
15465  fprintf( f, "%s", "{" );
15466  Arg<CNode*>(0)->Dump( f );
15467  fprintf( f, "%s", "," );
15468  Arg<CNode*>(1)->Dump( f );
15469  fprintf( f, "%s", "}" );
15470  break;
15471  case eUCAT:
15472  fprintf( f, "%s", "{" );
15473  Arg<CNode*>(0)->Dump( f );
15474  fprintf( f, "%s", "}" );
15475  break;
15476  case eCOM:
15477  fprintf( f, "%s", "~(" );
15478  Arg<CNode*>(0)->Dump( f );
15479  fprintf( f, "%s", ")" );
15480  break;
15481  case eNEG:
15482  fprintf( f, "%s", "-(" );
15483  Arg<CNode*>(0)->Dump( f );
15484  fprintf( f, "%s", ")" );
15485  break;
15486  case ePLUS:
15487  fprintf( f, "%s", "+(" );
15488  Arg<CNode*>(0)->Dump( f );
15489  fprintf( f, "%s", ")" );
15490  break;
15491  case eNOT:
15492  fprintf( f, "%s", "!(" );
15493  Arg<CNode*>(0)->Dump( f );
15494  fprintf( f, "%s", ")" );
15495  break;
15496  case eGT:
15497  fprintf( f, "%s", "(" );
15498  Arg<CNode*>(0)->Dump( f );
15499  fprintf( f, "%s", ")>(" );
15500  Arg<CNode*>(1)->Dump( f );
15501  fprintf( f, "%s", ")" );
15502  break;
15503  case eGE:
15504  fprintf( f, "%s", "(" );
15505  Arg<CNode*>(0)->Dump( f );
15506  fprintf( f, "%s", ")>=(" );
15507  Arg<CNode*>(1)->Dump( f );
15508  fprintf( f, "%s", ")" );
15509  break;
15510  case eLT:
15511  fprintf( f, "%s", "(" );
15512  Arg<CNode*>(0)->Dump( f );
15513  fprintf( f, "%s", ")<(" );
15514  Arg<CNode*>(1)->Dump( f );
15515  fprintf( f, "%s", ")" );
15516  break;
15517  case eLE:
15518  fprintf( f, "%s", "(" );
15519  Arg<CNode*>(0)->Dump( f );
15520  fprintf( f, "%s", ")<=(" );
15521  Arg<CNode*>(1)->Dump( f );
15522  fprintf( f, "%s", ")" );
15523  break;
15524  case eLAND:
15525  fprintf( f, "%s", "(" );
15526  Arg<CNode*>(0)->Dump( f );
15527  fprintf( f, "%s", ")&&(" );
15528  Arg<CNode*>(1)->Dump( f );
15529  fprintf( f, "%s", ")" );
15530  break;
15531  case eLOR:
15532  fprintf( f, "%s", "(" );
15533  Arg<CNode*>(0)->Dump( f );
15534  fprintf( f, "%s", ")||(" );
15535  Arg<CNode*>(1)->Dump( f );
15536  fprintf( f, "%s", ")" );
15537  break;
15538  case eCEQ:
15539  fprintf( f, "%s", "(" );
15540  Arg<CNode*>(0)->Dump( f );
15541  fprintf( f, "%s", ")===(" );
15542  Arg<CNode*>(1)->Dump( f );
15543  fprintf( f, "%s", ")" );
15544  break;
15545  case eCNE:
15546  fprintf( f, "%s", "(" );
15547  Arg<CNode*>(0)->Dump( f );
15548  fprintf( f, "%s", ")!==(" );
15549  Arg<CNode*>(1)->Dump( f );
15550  fprintf( f, "%s", ")" );
15551  break;
15552  case eEQ:
15553  fprintf( f, "%s", "(" );
15554  Arg<CNode*>(0)->Dump( f );
15555  fprintf( f, "%s", ")==(" );
15556  Arg<CNode*>(1)->Dump( f );
15557  fprintf( f, "%s", ")" );
15558  break;
15559  case eNE:
15560  fprintf( f, "%s", "(" );
15561  Arg<CNode*>(0)->Dump( f );
15562  fprintf( f, "%s", ")!=(" );
15563  Arg<CNode*>(1)->Dump( f );
15564  fprintf( f, "%s", ")" );
15565  break;
15566  case eRAND:
15567  fprintf( f, "%s", "&(" );
15568  Arg<CNode*>(0)->Dump( f );
15569  fprintf( f, "%s", ")" );
15570  break;
15571  case eRNAND:
15572  fprintf( f, "%s", "~&(" );
15573  Arg<CNode*>(0)->Dump( f );
15574  fprintf( f, "%s", ")" );
15575  break;
15576  case eROR:
15577  fprintf( f, "%s", "|(" );
15578  Arg<CNode*>(0)->Dump( f );
15579  fprintf( f, "%s", ")" );
15580  break;
15581  case eRNOR:
15582  fprintf( f, "%s", "~|(" );
15583  Arg<CNode*>(0)->Dump( f );
15584  fprintf( f, "%s", ")" );
15585  break;
15586  case eRXOR:
15587  fprintf( f, "%s", "^(" );
15588  Arg<CNode*>(0)->Dump( f );
15589  fprintf( f, "%s", ")" );
15590  break;
15591  case eRXNOR:
15592  fprintf( f, "%s", "~^(" );
15593  Arg<CNode*>(0)->Dump( f );
15594  fprintf( f, "%s", ")" );
15595  break;
15596  case eHOOK:
15597  fprintf( f, "%s", "(" );
15598  Arg<CNode*>(0)->Dump( f );
15599  fprintf( f, "%s", ")?(" );
15600  Arg<CNode*>(1)->Dump( f );
15601  fprintf( f, "%s", "):(" );
15602  Arg<CNode*>(2)->Dump( f );
15603  fprintf( f, "%s", ")" );
15604  break;
15605  case eINIT:
15606  fprintf( f, "%s", "INIT(*)" );
15607  break;
15608  case ePOSEDGE:
15609  fprintf( f, "%s", "POSEDGE(" );
15610  Arg<CNode*>(0)->Dump( f );
15611  fprintf( f, "%s", ")" );
15612  break;
15613  case eNEGEDGE:
15614  fprintf( f, "%s", "NEGEDGE(" );
15615  Arg<CNode*>(0)->Dump( f );
15616  fprintf( f, "%s", ")" );
15617  break;
15618  case eEDGE:
15619  fprintf( f, "%s", "EDGE(" );
15620  Arg<CNode*>(0)->Dump( f );
15621  fprintf( f, "%s", ")" );
15622  break;
15623  case eMTM:
15624  fprintf( f, "%s", "(" );
15625  Arg<CNode*>(0)->Dump( f );
15626  fprintf( f, "%s", ":" );
15627  Arg<CNode*>(1)->Dump( f );
15628  fprintf( f, "%s", ":" );
15629  Arg<CNode*>(2)->Dump( f );
15630  fprintf( f, "%s", ")" );
15631  break;
15632  case eMODULE_DEF:
15633  fprintf( f, "%s", "MODULE_DEF" );
15634  break;
15635  case ePACKAGE_DEF:
15636  fprintf( f, "%s", "PACKAGE_DEF" );
15637  break;
15638  case eMACRO_EXPR:
15639  fprintf( f, "%s", "" );
15640  fprintf( f, "%s", (const char*)Arg<const char*>(0) );
15641  fprintf( f, "%s", "<" );
15642  Arg<CNode*>(1)->Dump( f );
15643  fprintf( f, "%s", ">" );
15644  break;
15645  case eMEMBER:
15646  fprintf( f, "%s", "" );
15647  Arg<CNode*>(0)->Dump( f );
15648  fprintf( f, "%s", "." );
15649  fprintf( f, "%s", Arg<CSymbol*>(1)->GetName() );
15650  fprintf( f, "%s", "" );
15651  break;
15652  case ePREINC:
15653  fprintf( f, "%s", "++(" );
15654  Arg<CNode*>(0)->Dump( f );
15655  fprintf( f, "%s", ")" );
15656  break;
15657  case ePOSTINC:
15658  fprintf( f, "%s", "(" );
15659  Arg<CNode*>(0)->Dump( f );
15660  fprintf( f, "%s", ")++" );
15661  break;
15662  case ePREDEC:
15663  fprintf( f, "%s", "--(" );
15664  Arg<CNode*>(0)->Dump( f );
15665  fprintf( f, "%s", ")" );
15666  break;
15667  case ePOSTDEC:
15668  fprintf( f, "%s", "(" );
15669  Arg<CNode*>(0)->Dump( f );
15670  fprintf( f, "%s", ")--" );
15671  break;
15672  case eCAST:
15673  fprintf( f, "%s", "CAST(" );
15674  Arg<CNode*>(0)->Dump( f );
15675  fprintf( f, "%s", "," );
15676  Arg<CNode*>(1)->Dump( f );
15677  fprintf( f, "%s", ")" );
15678  break;
15679  case eCOMMENT:
15680  case eVRQ:
15681  case eNOP:
15682  case eINSTANCE_REF:
15683  case eGATE_REF:
15684  case eTASK_ENABLE:
15685  case eSYSTASK_CALL:
15686  case eTIMING_CALL:
15687  case eNET_DECL:
15688  case ePARAM_DECL:
15689  case eSPECPARAM_DECL:
15690  case ePORT_DECL:
15691  case eGENVAR_DECL:
15692  case eTYPEDEF_DECL:
15693  case eALWAYS:
15694  case eALWAYS_LATCH:
15695  case eALWAYS_FF:
15696  case eALWAYS_COMB:
15697  case eEVENT:
15698  case eBLOCK_REF:
15699  case eSPECIFY_REF:
15700  case eASSIGN:
15701  case eGASSIGN:
15702  case eADD_ASSIGN:
15703  case eSUB_ASSIGN:
15704  case eMUL_ASSIGN:
15705  case eDIV_ASSIGN:
15706  case eMOD_ASSIGN:
15707  case eAND_ASSIGN:
15708  case eOR_ASSIGN:
15709  case eXOR_ASSIGN:
15710  case eLSH_ASSIGN:
15711  case eRSH_ASSIGN:
15712  case eLSHA_ASSIGN:
15713  case eRSHA_ASSIGN:
15714  case eFORCE:
15715  case eRELEASE:
15716  case eNBASSIGN:
15717  case eEVOR:
15718  case eDELAY:
15719  case eIF:
15720  case eFOREVER:
15721  case eREPEAT:
15722  case eWHILE:
15723  case eWAIT:
15724  case eFOR:
15725  case eCASE:
15726  case eCASEX:
15727  case eCASEZ:
15728  case eCASEITEM:
15729  case eCASSIGN:
15730  case eARG:
15731  case eIMPORT:
15732  case eFUNCTION_DEF:
15733  case eREPEAT_CONTROL:
15734  case eDELAY_CONTROL:
15735  case eEVENT_CONTROL:
15736  case eEXTERNAL_REF:
15737  case ePORT_DEF:
15738  case eDEFPARAM:
15739  case ePATH:
15740  case ePATH_ASSIGN:
15741  case eIFNONE_PATH_ASSIGN:
15742  case eTRIGGER:
15743  case ePASSIGN:
15744  case eDEASSIGN:
15745  case eDISABLE:
15746  case eATTRIBUTE:
15747  case eGIF:
15748  case eGFOR:
15749  case eGCASE:
15750  case eTABLE:
15751  case eTABLE_ENTRY:
15752  case eTABLE_SYMBOL:
15753  case ePORTLIST_END:
15754  case eENUM_SPEC:
15755  case eRETURN:
15756  fprintf( f, "%s(%p)", nodeOpName[GetOp()],this );
15757  break;
15758  }
15759 }
15760 
15761 #endif // DEFINE_METHODS
15762 
15763 #ifdef DEFINE_TEST_HARNESS
15765 {
15766  for( int i = 0; i < 153; ++i ) {
15767  CNode* n = new(CNode::stack) CNode( NULL, (NodeOp_t)i );
15768  if( n->Precedence() != n->Precedence_1() ) {
15769  printf( "Fail %s\n", nodeOpName[i] );
15770  exit(1);
15771  }
15772  }
15773 }
15774 #endif // DEFINE_TEST_HARNESS
CNode * cDIV(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for DIV divide.
Definition: cnode_def.h:2945
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:2879
static NodeType_t Type(CSymbol *symbol, CNode *args)
Determine type of systask.
Definition: systask.h:134
nonblocking assignment
Definition: cnode_def.h:1721
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:5938
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:4865
CNode * cFOREVER(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for FOREVER forever statement.
Definition: cnode_def.h:6110
real constant
Definition: cnode_def.h:654
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:5486
CNode * cDEASSIGN(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for DEASSIGN deassign statement.
Definition: cnode_def.h:6968
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:5412
preincrement
Definition: cnode_def.h:2243
CNode * cASSIGN(CNode *a0, CNode *a1, CNode *a2, Coord_t *loc=NULL)
Node construction shortcut for ASSIGN procedural assignment.
Definition: cnode_def.h:5264
vector subrange with ascending index select
Definition: cnode_def.h:1152
force statement
Definition: cnode_def.h:1699
condition expression operator
Definition: cnode_def.h:1437
arithmetic right shift
Definition: cnode_def.h:814
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:6414
procedural assignment with mul
Definition: cnode_def.h:1580
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:5375
sentinal at end of port list
Definition: cnode_def.h:2189
CNode * cPARAM_DECL(CParam *a0, Coord_t *loc=NULL)
Node construction shortcut for PARAM_DECL parameter declaration.
Definition: cnode_def.h:3898
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:6004
reduction xnor
Definition: cnode_def.h:1425
case not equal
Definition: cnode_def.h:1343
CNode * cMOD(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for MOD modulus.
Definition: cnode_def.h:3176
CNode * cWAIT(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for WAIT wait statement.
Definition: cnode_def.h:6206
no operation
Definition: cnode_def.h:715
Declaration object for genvars.
Definition: cgenvar.h:46
reduction nand
Definition: cnode_def.h:1385
CNode * cELIST(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for ELIST expression list.
Definition: cnode_def.h:2788
undefined
Definition: cdatatype.h:100
error node
Definition: cnode_def.h:634
CNode * cPORT_REF(CPortDir *a0, Coord_t *loc=NULL)
Node construction shortcut for PORT_REF reference to port.
Definition: cnode_def.h:3687
signed bit vector, includes integer
Definition: cdatatype.h:102
gate instance
Definition: cnode_def.h:900
procedural assignment with right shift
Definition: cnode_def.h:1664
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:1973
exponent
Definition: cnode_def.h:759
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:3532
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:2700
statement block
Definition: cnode_def.h:1509
disable statement
Definition: cnode_def.h:2104
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:1640
vector decl range specification
Definition: cnode_def.h:1130
case equal
Definition: cnode_def.h:1332
CNode * cREAL(double number)
Short cut for creating RCONSTANT node with a given double value.
Definition: cnode.h:803
negative event qualifier
Definition: cnode_def.h:1741
import item
Definition: cnode_def.h:1932
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:5449
initial block
Definition: cnode_def.h:1447
CNode * cPREDEC(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for PREDEC predecrement.
Definition: cnode_def.h:7468
CNode * cGIF(CNode *a0, CNode *a1, CNode *a2, Coord_t *loc=NULL)
Node construction shortcut for GIF structural if statement.
Definition: cnode_def.h:7057
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:3716
int IsEvaluateable()
Checks to see if expression tree can be evaluated.
Definition: cnode_def.h:12632
bitwise and
Definition: cnode_def.h:847
CNode * cCAT(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for CAT concatenation operator.
Definition: cnode_def.h:4300
postincrement
Definition: cnode_def.h:2253
void Add(double *r, double *a, double *b)
Definition: cnode.h:668
CNode * cRXOR(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for RXOR reduction xor.
Definition: cnode_def.h:4923
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:6453
CNode * cMAX_N(CNode *first,...)
Definition: cnode.h:1252
CNode * cAND(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for AND bitwise and.
Definition: cnode_def.h:3242
instance reference
Definition: cnode_def.h:890
CNode * cTABLE_SYMBOL(char *a0, Coord_t *loc=NULL)
Node construction shortcut for TABLE_SYMBOL udp table symbol.
Definition: cnode_def.h:7224
CNode * cPOSEDGE(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for POSEDGE positive event qualifier.
Definition: cnode_def.h:5879
not equal
Definition: cnode_def.h:1365
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:5745
CNode * cNOT(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for NOT logical complement.
Definition: cnode_def.h:4448
CNode * cRETURN(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for RETURN return.
Definition: cnode_def.h:7381
void Neg(double *r, double *a)
Definition: cnode.h:688
CNode * cCEQ(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for CEQ case equal.
Definition: cnode_def.h:4676
list of nodes
Definition: cnode_def.h:1119
greater than or equal
Definition: cnode_def.h:1277
CNode * cEQ(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for EQ equal.
Definition: cnode_def.h:4742
vector constant
Definition: cnode_def.h:644
procedural assignment
Definition: cnode_def.h:1532
Coord_t * GetCoord()
Get node's file coordinates.
Definition: cnode.h:303
CNode * cNET_DECL(CNet *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for NET_DECL net declaration.
Definition: cnode_def.h:3833
wait statement
Definition: cnode_def.h:1841
CNode * cMUL_N(CNode *first,...)
Definition: cnode.h:1286
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:6874
static CObstack * CurrentHeap()
Gets pointer to current heap allocator.
Definition: cnode.h:228
CNode * cEVOR(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for EVOR event or.
Definition: cnode_def.h:5971
int IsConstant()
Checks expression tree to see if it is constant.
Definition: cnode_def.h:8057
CNode * GetWidthExp(void)
Create expression representing width of expression.
Definition: cnode_def.h:8695
reduction xor
Definition: cnode_def.h:1415
case item
Definition: cnode_def.h:1898
delay control
Definition: cnode_def.h:1983
CNode * cRAND(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for RAND reduction and.
Definition: cnode_def.h:4807
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:5844
CNode * cNEG(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for NEG negation.
Definition: cnode_def.h:4390
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:5560
reduction nor
Definition: cnode_def.h:1405
CNode * cGT(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for GT greater than.
Definition: cnode_def.h:4478
CNode * cCVRI(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for CVRI convert real to integer.
Definition: cnode_def.h:4208
void PostVisit1(void(*callback)(CNode *, void *), void *data)
Walk tree invoking callback on each node after children have been visited.
Definition: cnode_def.h:10480
port connection
Definition: cnode_def.h:1922
long INT32
Short cut for signed 32 bit integer.
Definition: glue.h:38
arithmetic left shift
Definition: cnode_def.h:803
CNode * cDISABLE(CSymbol *a0, Coord_t *loc=NULL)
Node construction shortcut for DISABLE disable statement.
Definition: cnode_def.h:6997
CNode * cREPEAT_CONTROL(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for REPEAT_CONTROL repeat control.
Definition: cnode_def.h:6602
variable declaration
Definition: cnode_def.h:1058
int IsVolatile(void)
Checks to see if expression tree is volatile.
Definition: cnode_def.h:8219
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:5708
path statement
Definition: cnode_def.h:2040
int Precedence()
Get the precedence of the operator represented by the node.
Definition: cnode_def.h:7889
genvar declaration
Definition: cnode_def.h:1098
CNode_sp< T > Arg(int index)
Get a node's operand.
Definition: cnode.h:535
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:6241
CNode * cRSH(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for RSH logical right shift.
Definition: cnode_def.h:3077
reference to port
Definition: cnode_def.h:996
CNode * cFUNCTION_DEF(CFunction *a0, Coord_t *loc=NULL)
Node construction shortcut for FUNCTION_DEF function definition.
Definition: cnode_def.h:6514
convert integer to real
Definition: cnode_def.h:1183
logical and
Definition: cnode_def.h:1310
reduction or
Definition: cnode_def.h:1395
less than or equal
Definition: cnode_def.h:1299
edge qualifier
Definition: cnode_def.h:1752
reduction and
Definition: cnode_def.h:1375
bitwise or
Definition: cnode_def.h:836
CNode * cSLICE(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for SLICE vector subrange.
Definition: cnode_def.h:4110
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:4577
reference to a forward declared variable
Definition: cnode_def.h:1006
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:4143
CNode * cSPECPARAM_DECL(CParam *a0, Coord_t *loc=NULL)
Node construction shortcut for SPECPARAM_DECL specify parameter declaration.
Definition: cnode_def.h:3927
void CNodeTestHarness()
Definition: cnode_def.h:15764
comment
Definition: cnode_def.h:664
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:6173
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:5338
bitwise xor
Definition: cnode_def.h:869
CNode * cCAST(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for CAST data type change.
Definition: cnode_def.h:7527
procedural assignment with div
Definition: cnode_def.h:1592
procedural assignment with add
Definition: cnode_def.h:1556
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:4983
concatenation operator
Definition: cnode_def.h:1205
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:1652
port declaration
Definition: cnode_def.h:1088
CNode * cPACKAGE_DEF(CPackage *a0, Coord_t *loc=NULL)
Node construction shortcut for PACKAGE_DEF package definition.
Definition: cnode_def.h:6572
reference to a genvar
Definition: cnode_def.h:1016
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:7095
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:6838
CNode * cATTRIBUTE(CAttr *a0, Coord_t *loc=NULL)
Node construction shortcut for ATTRIBUTE attribute specification.
Definition: cnode_def.h:7026
CNode * cTABLE_ENTRY(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for TABLE_ENTRY udp table entry.
Definition: cnode_def.h:7195
convert real to integer
Definition: cnode_def.h:1173
int ArgCount(void)
Get the number of operands for the node.
Definition: cnode_def.h:7567
CNode * cGENVAR_DECL(CGenvar *a0, Coord_t *loc=NULL)
Node construction shortcut for GENVAR_DECL genvar declaration.
Definition: cnode_def.h:3985
CNode * cALWAYS(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for ALWAYS always block.
Definition: cnode_def.h:5047
CNode * cERROR(Coord_t *loc=NULL)
Node construction shortcut for ERROR error node.
Definition: cnode_def.h:2616
CNode * cCASEX(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for CASEX casex statement.
Definition: cnode_def.h:6313
unsigned bit vector
Definition: cdatatype.h:104
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:3465
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:3803
CNode * cALWAYS_COMB(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for ALWAYS_COMB always combinational logic block.
Definition: cnode_def.h:5134
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:2114
CNode * cRANGE(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for RANGE vector decl range specification.
Definition: cnode_def.h:4077
event statement
Definition: cnode_def.h:1498
Declaration object for module/function/task ports.
Definition: cport.h:44
generate intialize assignment
Definition: cnode_def.h:1544
divide
Definition: cnode_def.h:748
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:1302
delay statement
Definition: cnode_def.h:1774
negation
Definition: cnode_def.h:1235
logical right shift
Definition: cnode_def.h:792
casez statement
Definition: cnode_def.h:1887
unary concat
Definition: cnode_def.h:1215
call to a task
Definition: cnode_def.h:911
reference to net
Definition: cnode_def.h:966
void LoadReal(double d)
Load vector with integer part of real value.
int error
Definition: cnode_def.h:13667
int IsOwner(void *ptr)
Determine if pointer was allocated from this obstack.
Definition: cnode_def.h:13665
CNode * cPRAGMA(const char *a0, Coord_t *loc=NULL)
Node construction shortcut for PRAGMA program pragma.
Definition: cnode_def.h:2758
CNode * cFORCE(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for FORCE force statement.
Definition: cnode_def.h:5781
CNode * cEXTERNAL_REF(CSymbol *a0, Coord_t *loc=NULL)
Node construction shortcut for EXTERNAL_REF external reference.
Definition: cnode_def.h:6692
vrq comment
Definition: cnode_def.h:674
CNode * cLAND(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for LAND logical and.
Definition: cnode_def.h:4610
CNode * cRSHA(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for RSHA arithmetic right shift.
Definition: cnode_def.h:3143
equal
Definition: cnode_def.h:1354
unary plus
Definition: cnode_def.h:1245
Primary data structure representing parse tree nodes.
Definition: cnode.h:188
CNode * cPASSIGN(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for PASSIGN procedural assignment.
Definition: cnode_def.h:6936
CNode * cANDANDAND(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for ANDANDAND triple and.
Definition: cnode_def.h:3275
CNode * cNET_REF(CNet *a0, Coord_t *loc=NULL)
Node construction shortcut for NET_REF reference to net.
Definition: cnode_def.h:3600
integer declaration
Definition: cdatatype.h:50
NodeOp_t
Parse tree opcodes.
Definition: cnode_def.h:625
CNode * cGASSIGN(bool a0, CNode *a1, CNode *a2, Coord_t *loc=NULL)
Node construction shortcut for GASSIGN generate intialize assignment.
Definition: cnode_def.h:5301
void info(struct Coord_t *location, const char *format,...)
This routine should not be used by plugins.
program pragma
Definition: cnode_def.h:684
CNode * cTRIGGER(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for TRIGGER event trigger.
Definition: cnode_def.h:6906
return
Definition: cnode_def.h:2233
CNode * cCNE(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for CNE case not equal.
Definition: cnode_def.h:4709
CNode * cVAR_REF(CVar *a0, Coord_t *loc=NULL)
Node construction shortcut for VAR_REF reference to variable.
Definition: cnode_def.h:3629
CNode * cCOM(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for COM bitwise complement.
Definition: cnode_def.h:4361
positive event qualifier
Definition: cnode_def.h:1731
CNode * cWIDTH(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for WIDTH expression width change.
Definition: cnode_def.h:2821
CNode * cEVENT(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for EVENT event statement.
Definition: cnode_def.h:5164
defparam statement
Definition: cnode_def.h:2024
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:9293
Declaration object for module and gate instances.
Definition: cinstance.h:45
expression list
Definition: cnode_def.h:695
void EvalVector(CVector &v)
Evaluates expression tree evaluated in unconstrainted context.
Definition: cnode.cc:360
udp table symbol
Definition: cnode_def.h:2180
CNode * cEVENT_CONTROL(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for EVENT_CONTROL event control.
Definition: cnode_def.h:6663
multiply
Definition: cnode_def.h:737
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:4176
call to a function
Definition: cnode_def.h:945
CNode * cARRAY(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for ARRAY dimensioned reference (array/bit select)
Definition: cnode_def.h:3568
CNode * cVRQ(const char *a0, Coord_t *loc=NULL)
Node construction shortcut for VRQ vrq comment.
Definition: cnode_def.h:2729
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:7439
parameter declaration
Definition: cnode_def.h:1068
void Pow(double *r, double *a, double *b)
Definition: cnode.h:698
less than
Definition: cnode_def.h:1288
CNode * cALWAYS_FF(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for ALWAYS_FF always flip-flop block.
Definition: cnode_def.h:5105
CNode * cCASEITEM(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for CASEITEM case item.
Definition: cnode_def.h:6379
replication operator
Definition: cnode_def.h:1194
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:2223
CNode * cINIT(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for INIT initial block.
Definition: cnode_def.h:5018
Definition: cmodule.h:54
void SetAttributes(CNode *attr)
Attach attributes to operation.
Definition: cnode.h:505
CNode * cPORTLIST_END(Coord_t *loc=NULL)
Node construction shortcut for PORTLIST_END sentinal at end of port list.
Definition: cnode_def.h:7252
package definition
Definition: cnode_def.h:1962
bitwise xnor
Definition: cnode_def.h:880
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:7349
CNode * cALWAYS_LATCH(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for ALWAYS_LATCH always latch block.
Definition: cnode_def.h:5076
event control
Definition: cnode_def.h:1993
event or
Definition: cnode_def.h:1763
const char * nodeOpDescription[]
Definition: cnode_def.h:2447
CNode * PostSubVisit1(CNode *(*callback)(CNode *, void *), void *data)
Walk tree invoking callback on each node after children have been visited.
Definition: cnode_def.h:11013
procedural assignment with bitwise and
Definition: cnode_def.h:1616
CNode * cPOSTDEC(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for POSTDEC postdecrement.
Definition: cnode_def.h:7497
udp table
Definition: cnode_def.h:2160
for statement
Definition: cnode_def.h:1854
triple and
Definition: cnode_def.h:858
void Div(double *r, double *a, double *b)
Definition: cnode.h:683
CNode * cXOR(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for XOR bitwise xor.
Definition: cnode_def.h:3308
event trigger
Definition: cnode_def.h:2073
structural if statement
Definition: cnode_def.h:2126
reference to a enum
Definition: cnode_def.h:1026
int Equivalent(CNode *a, CNode *b)
Definition: cnode_def.h:12084
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:5908
postdecrement
Definition: cnode_def.h:2273
module definition
Definition: cnode_def.h:1952
void Sub(double *r, double *a, double *b)
Definition: cnode.h:673
subtract
Definition: cnode_def.h:726
CNode * cRNAND(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for RNAND reduction nand.
Definition: cnode_def.h:4836
specify parameter declaration
Definition: cnode_def.h:1078
forever statement
Definition: cnode_def.h:1808
CNode * cRELEASE(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for RELEASE release statement.
Definition: cnode_def.h:5813
Declaration object for variables.
Definition: cvar.h:50
external reference
Definition: cnode_def.h:2003
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:4894
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:6038
while statement
Definition: cnode_def.h:1830
CNode * cENUM_REF(CEnum *a0, Coord_t *loc=NULL)
Node construction shortcut for ENUM_REF reference to a enum.
Definition: cnode_def.h:3774
CNode * cTABLE(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for TABLE udp table.
Definition: cnode_def.h:7166
CNode * cPOW(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for POW exponent.
Definition: cnode_def.h:2978
CNode * cREPEAT(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for REPEAT repeat statement.
Definition: cnode_def.h:6140
CNode * cOR(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for OR bitwise or.
Definition: cnode_def.h:3209
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:1688
CNode * cINT32(INT32 i)
Short cut for creating VCONSTANT node with a given integer value.
Definition: cnode.h:784
int suppressErrorMessages
Definition: cnode_def.h:13666
function definition
Definition: cnode_def.h:1942
CNode * cNE(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for NE not equal.
Definition: cnode_def.h:4775
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:2212
CNode * cGATE_REF(CGate *a0, Coord_t *loc=NULL)
Node construction shortcut for GATE_REF gate instance.
Definition: cnode_def.h:3402
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:6789
int IsWidthEvaluateable(void)
Evaluates if expression width can be evaluated.
Definition: cnode_def.h:9135
CNode * cRCONSTANT(char *a0, Coord_t *loc=NULL)
Node construction shortcut for RCONSTANT real constant.
Definition: cnode_def.h:2671
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:3866
event - have width 0
Definition: cdatatype.h:103
CNode * cPORT_DEF(CPort *a0, Coord_t *loc=NULL)
Node construction shortcut for PORT_DEF port definition.
Definition: cnode_def.h:6721
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:4511
void PreVisit1(int(*callback)(CNode *, void *), void *data)
Walk tree invoking callback on each node before children have been visited.
Definition: cnode_def.h:9960
procedural assignment with mod
Definition: cnode_def.h:1604
CNode * cIMPORT(CSymbol *a0, Coord_t *loc=NULL)
Node construction shortcut for IMPORT import item.
Definition: cnode_def.h:6485
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:480
call to a timing task
Definition: cnode_def.h:933
CNode * cLT(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for LT less than.
Definition: cnode_def.h:4544
release statement
Definition: cnode_def.h:1709
void Mul(double *r, double *a, double *b)
Definition: cnode.h:678
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:5634
structural case statement
Definition: cnode_def.h:2150
int IsWidthConstant(void)
Evaluates if expression width is constant.
Definition: cnode_def.h:8381
CNode * cREP(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for REP replication operator.
Definition: cnode_def.h:4267
CNode * cDELAY_CONTROL(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for DELAY_CONTROL delay control.
Definition: cnode_def.h:6634
CNode * cNOP(Coord_t *loc=NULL)
Node construction shortcut for NOP no operation.
Definition: cnode_def.h:2852
NodeType_t GetNodeType(void)
Get node expression type.
Definition: cnode.h:526
always block
Definition: cnode_def.h:1457
reference to a type
Definition: cnode_def.h:1036
udp table entry
Definition: cnode_def.h:2170
void Plus(double *r, double *a)
Definition: cnode.h:693
CNode * cCASEZ(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for CASEZ casez statement.
Definition: cnode_def.h:6346
INT32 GetWidth(void)
Get vector bit width.
static int WidthConstant(CSymbol *symbol, CNode *args, CBlock *block)
Determine if width of function is constant.
path assignment statement
Definition: cnode_def.h:2052
CNode * cCASE(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for CASE case statement.
Definition: cnode_def.h:6280
int Signed() const
Get signed attribute.
Definition: cvector.h:178
vector subrange
Definition: cnode_def.h:1141
real - have width 0
Definition: cdatatype.h:101
CNode * cBLOCK_REF(CBlock *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for BLOCK_REF statement block.
Definition: cnode_def.h:5197
Declaration object for functions and tasks.
Definition: cfunction.h:50
port definition
Definition: cnode_def.h:2013
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:4044
always flip-flop block
Definition: cnode_def.h:1477
call to enable a systask
Definition: cnode_def.h:922
procedural assignment
Definition: cnode_def.h:2084
CNode * cGCASE(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for GCASE structural case statement.
Definition: cnode_def.h:7134
procedural assignment with bitwise or
Definition: cnode_def.h:1628
unsigned Hash()
Calculate hash of tree.
Definition: cnode_def.h:11548
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:3498
CNode * cRXNOR(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for RXNOR reduction xnor.
Definition: cnode_def.h:4952
structural for statement
Definition: cnode_def.h:2139
logical complement
Definition: cnode_def.h:1255
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:881
CNode * cXNOR(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for XNOR bitwise xnor.
Definition: cnode_def.h:3341
casex statement
Definition: cnode_def.h:1876
always latch block
Definition: cnode_def.h:1467
CNode * cADD_N(CNode *first,...)
Definition: cnode.h:1270
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:7279
addition
Definition: cnode_def.h:770
repeat statement
Definition: cnode_def.h:1819
expression represented by a macro
Definition: cnode_def.h:2200
deassign statement
Definition: cnode_def.h:2094
NodeType_t
Expression node type.
Definition: cdatatype.h:99
CNode * cIF(CNode *a0, CNode *a1, CNode *a2, Coord_t *loc=NULL)
Node construction shortcut for IF if statement.
Definition: cnode_def.h:6075
CNode * cSPECIFY_REF(CSpecify *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for SPECIFY_REF specify block.
Definition: cnode_def.h:5230
data type change
Definition: cnode_def.h:2284
procedural assignment with subtract
Definition: cnode_def.h:1568
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:5671
CNode * GetAttributes()
Get attributes attached to operation.
Definition: cnode.h:500
CNode * cADD(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for ADD addition.
Definition: cnode_def.h:3011
const char * nodeOpName[]
Definition: cnode_def.h:2290
predecrement
Definition: cnode_def.h:2263
CNode * cDEFPARAM(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for DEFPARAM defparam statement.
Definition: cnode_def.h:6751
dimensioned reference (array/bit select)
Definition: cnode_def.h:956
CNode * cPORT_DECL(CPortDir *a0, Coord_t *loc=NULL)
Node construction shortcut for PORT_DECL port declaration.
Definition: cnode_def.h:3956
CNode * cLOR(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for LOR logical or.
Definition: cnode_def.h:4643
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:7313
NodeOp_t GetOp()
Return node's operation type.
Definition: cnode.h:308
CNode * cLSH(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for LSH logical left shift.
Definition: cnode_def.h:3044
int IsWidthVolatile(void)
Evaluates if expression width is volatile.
Definition: cnode_def.h:8537
type declaration
Definition: cnode_def.h:1108
CNode * cVCONSTANT(CVector *a0, Coord_t *loc=NULL)
Node construction shortcut for VCONSTANT vector constant.
Definition: cnode_def.h:2642
void Dump(FILE *f)
Print a compact representation of the parse tree.
Definition: cnode_def.h:15233
logical left shift
Definition: cnode_def.h:781
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:4332
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:1911
CNode * cTYPEDEF_DECL(CTypedef *a0, Coord_t *loc=NULL)
Node construction shortcut for TYPEDEF_DECL type declaration.
Definition: cnode_def.h:4014
int cABSDIFFPLUS1(int a1, int a2)
Definition: cnode.h:1340
vector subrange with descending index select
Definition: cnode_def.h:1163
bitwise complement
Definition: cnode_def.h:1225
reference to parameter
Definition: cnode_def.h:986
always combinational logic block
Definition: cnode_def.h:1487
double EvalReal(void)
Evaluates expression tree evaluated in a real context.
Definition: cnode.cc:391
case statement
Definition: cnode_def.h:1865
CNode * cLSHA(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for LSHA arithmetic left shift.
Definition: cnode_def.h:3110
CNode * cPARAM_REF(CParam *a0, Coord_t *loc=NULL)
Node construction shortcut for PARAM_REF reference to parameter.
Definition: cnode_def.h:3658
greater than
Definition: cnode_def.h:1266
CNode * cMODULE_DEF(CModule *a0, Coord_t *loc=NULL)
Node construction shortcut for MODULE_DEF module definition.
Definition: cnode_def.h:6543
specify block
Definition: cnode_def.h:1520
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:7410
CNode * cPLUS(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for PLUS unary plus.
Definition: cnode_def.h:4419
modulus
Definition: cnode_def.h:825
ifnone path assignment statement
Definition: cnode_def.h:2063
net declaration
Definition: cnode_def.h:1047
expression width change
Definition: cnode_def.h:706
CNode * cINSTANCE_REF(CInstance *a0, Coord_t *loc=NULL)
Node construction shortcut for INSTANCE_REF instance reference.
Definition: cnode_def.h:3373
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:3432
CNode * cGENVAR_REF(CGenvar *a0, Coord_t *loc=NULL)
Node construction shortcut for GENVAR_REF reference to a genvar.
Definition: cnode_def.h:3745
CNode * cMUL(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for MUL multiply.
Definition: cnode_def.h:2912
virtual INT32 GetWidth(void)
Evaluate packed width of declaration.
procedural assignment with left arithmetic shift
Definition: cnode_def.h:1676
double s2d(char *s)
Convert char string to double.
Definition: cnode.h:1079
if statement
Definition: cnode_def.h:1798
reference to variable
Definition: cnode_def.h:976
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:5523
CNode * cCVIR(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for CVIR convert integer to real.
Definition: cnode_def.h:4237
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:5597
CNode * Clone(CObstack *heap=stack)
Replicate tree.
Definition: cnode_def.h:9464
min/typ/max expression
Definition: cnode_def.h:1786
logical or
Definition: cnode_def.h:1321