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 
633 #ifdef DEFINE_ENUM
634 
637 enum NodeOp_t {
641  /*
642  * ERROR node
643  * Description: error node
644  * Number Of Arguments: 0
645  */
650  /*
651  * VCONSTANT node
652  * Description: vector constant
653  * Number Of Arguments: 1
654  * arg0: CVector* Pointer to vector
655  */
660  /*
661  * RCONSTANT node
662  * Description: real constant
663  * Number Of Arguments: 1
664  * arg0: char* Pointer to string
665  */
670  /*
671  * COMMENT node
672  * Description: comment
673  * Number Of Arguments: 1
674  * arg0: const char* Pointer to string
675  */
680  /*
681  * VRQ node
682  * Description: vrq comment
683  * Number Of Arguments: 1
684  * arg0: const char* Pointer to string
685  */
690  /*
691  * PRAGMA node
692  * Description: program pragma
693  * Number Of Arguments: 2
694  * arg0: const char* Pointer to string
695  * arg1: int Length of string
696  */
701  /*
702  * ELIST node
703  * Description: expression list
704  * Number Of Arguments: 2
705  * arg0: CNode* expression1
706  * arg1: CNode* expression2
707  */
712  /*
713  * WIDTH node
714  * Description: expression width change
715  * Number Of Arguments: 2
716  * arg0: CNode* width expression
717  * arg1: CNode* expression
718  */
723  /*
724  * NOP node
725  * Description: no operation
726  * Number Of Arguments: 0
727  */
732  /*
733  * SUB node
734  * Description: subtract
735  * Number Of Arguments: 2
736  * arg0: CNode* expression 1
737  * arg1: CNode* expression 2
738  */
743  /*
744  * MUL node
745  * Description: multiply
746  * Number Of Arguments: 2
747  * arg0: CNode* expression 1
748  * arg1: CNode* expression 2
749  */
754  /*
755  * DIV node
756  * Description: divide
757  * Number Of Arguments: 2
758  * arg0: CNode* expression 1
759  * arg1: CNode* expression 2
760  */
765  /*
766  * POW node
767  * Description: exponent
768  * Number Of Arguments: 2
769  * arg0: CNode* expression 1
770  * arg1: CNode* expression 2
771  */
776  /*
777  * ADD node
778  * Description: addition
779  * Number Of Arguments: 2
780  * arg0: CNode* expression 1
781  * arg1: CNode* expression 2
782  */
787  /*
788  * LSH node
789  * Description: logical left shift
790  * Number Of Arguments: 2
791  * arg0: CNode* expression 1
792  * arg1: CNode* expression 2
793  */
798  /*
799  * RSH node
800  * Description: logical right shift
801  * Number Of Arguments: 2
802  * arg0: CNode* expression 1
803  * arg1: CNode* expression 2
804  */
809  /*
810  * LSHA node
811  * Description: arithmetic left shift
812  * Number Of Arguments: 2
813  * arg0: CNode* expression 1
814  * arg1: CNode* expression 2
815  */
820  /*
821  * RSHA node
822  * Description: arithmetic right shift
823  * Number Of Arguments: 2
824  * arg0: CNode* expression 1
825  * arg1: CNode* expression 2
826  */
831  /*
832  * MOD node
833  * Description: modulus
834  * Number Of Arguments: 2
835  * arg0: CNode* expression 1
836  * arg1: CNode* expression 2
837  */
842  /*
843  * OR node
844  * Description: bitwise or
845  * Number Of Arguments: 2
846  * arg0: CNode* expression 1
847  * arg1: CNode* expression 2
848  */
853  /*
854  * AND node
855  * Description: bitwise and
856  * Number Of Arguments: 2
857  * arg0: CNode* expression 1
858  * arg1: CNode* expression 2
859  */
864  /*
865  * ANDANDAND node
866  * Description: triple and
867  * Number Of Arguments: 2
868  * arg0: CNode* expression 1
869  * arg1: CNode* expression 2
870  */
875  /*
876  * XOR node
877  * Description: bitwise xor
878  * Number Of Arguments: 2
879  * arg0: CNode* expression 1
880  * arg1: CNode* expression 2
881  */
886  /*
887  * XNOR node
888  * Description: bitwise xnor
889  * Number Of Arguments: 2
890  * arg0: CNode* expression 1
891  * arg1: CNode* expression 2
892  */
897  /*
898  * INSTANCE_REF node
899  * Description: instance reference
900  * Number Of Arguments: 1
901  * arg0: CInstance* Pointer to a instance
902  */
907  /*
908  * GATE_REF node
909  * Description: gate instance
910  * Number Of Arguments: 1
911  * arg0: CGate* Pointer to a gate
912  */
917  /*
918  * TASK_ENABLE node
919  * Description: call to a task
920  * Number Of Arguments: 2
921  * arg0: CSymbol* Pointer to symbol for task to call
922  * arg1: CNode* Argument expression list
923  */
928  /*
929  * SYSTASK_CALL node
930  * Description: call to enable a systask
931  * Number Of Arguments: 2
932  * arg0: CSymbol* Pointer to symbol for systask to call
933  * arg1: CNode* Argument expression list
934  */
939  /*
940  * TIMING_CALL node
941  * Description: call to a timing task
942  * Number Of Arguments: 2
943  * arg0: CSymbol* Pointer to symbol of timing task
944  * arg1: CNode* Argument expression list
945  */
950  /*
951  * FUNCTION_CALL node
952  * Description: call to a function
953  * Number Of Arguments: 3
954  * arg0: CSymbol* Pointer to symbol of the function
955  * arg1: CNode* Argument expression list
956  * arg2: CScope* Scope containing expression
957  */
962  /*
963  * ARRAY node
964  * Description: dimensioned reference (array/bit select)
965  * Number Of Arguments: 2
966  * arg0: CNode* Reference to variable
967  * arg1: CNode* List of index expressions
968  */
973  /*
974  * NET_REF node
975  * Description: reference to net
976  * Number Of Arguments: 1
977  * arg0: CNet* Pointer to net
978  */
983  /*
984  * VAR_REF node
985  * Description: reference to variable
986  * Number Of Arguments: 1
987  * arg0: CVar* Pointer to variable
988  */
993  /*
994  * PARAM_REF node
995  * Description: reference to parameter
996  * Number Of Arguments: 1
997  * arg0: CParam* Pointer to parameter
998  */
1003  /*
1004  * PORT_REF node
1005  * Description: reference to port
1006  * Number Of Arguments: 1
1007  * arg0: CPortDir* Pointer to port
1008  */
1013  /*
1014  * FWD_REF node
1015  * Description: reference to a forward declared variable
1016  * Number Of Arguments: 1
1017  * arg0: CFref* Pointer to forward declared variable
1018  */
1023  /*
1024  * GENVAR_REF node
1025  * Description: reference to a genvar
1026  * Number Of Arguments: 1
1027  * arg0: CGenvar* Pointer to a genvar
1028  */
1033  /*
1034  * ENUM_REF node
1035  * Description: reference to a enum
1036  * Number Of Arguments: 1
1037  * arg0: CEnum* Pointer to a enum
1038  */
1043  /*
1044  * TYPE_REF node
1045  * Description: reference to a type
1046  * Number Of Arguments: 1
1047  * arg0: CTypedef* Pointer to a typedef
1048  */
1053  /*
1054  * NET_DECL node
1055  * Description: net declaration
1056  * Number Of Arguments: 2
1057  * arg0: CNet* Pointer to a net
1058  * arg1: CNode* continous assignment (optional)
1059  */
1064  /*
1065  * VAR_DECL node
1066  * Description: variable declaration
1067  * Number Of Arguments: 2
1068  * arg0: CVar* Pointer to a variable
1069  * arg1: CNode* procedural assignment (optional)
1070  */
1075  /*
1076  * PARAM_DECL node
1077  * Description: parameter declaration
1078  * Number Of Arguments: 1
1079  * arg0: CParam* Pointer to a parameter
1080  */
1085  /*
1086  * SPECPARAM_DECL node
1087  * Description: specify parameter declaration
1088  * Number Of Arguments: 1
1089  * arg0: CParam* Pointer to a specify parameter
1090  */
1095  /*
1096  * PORT_DECL node
1097  * Description: port declaration
1098  * Number Of Arguments: 1
1099  * arg0: CPortDir* Pointer to a port
1100  */
1105  /*
1106  * GENVAR_DECL node
1107  * Description: genvar declaration
1108  * Number Of Arguments: 1
1109  * arg0: CGenvar* Pointer to a genvar
1110  */
1115  /*
1116  * TYPEDEF_DECL node
1117  * Description: type declaration
1118  * Number Of Arguments: 1
1119  * arg0: CTypedef* Pointer to a typedef
1120  */
1125  /*
1126  * LIST node
1127  * Description: list of nodes
1128  * Number Of Arguments: 2
1129  * arg0: CNode* node 1
1130  * arg1: CNode* node 2
1131  */
1136  /*
1137  * RANGE node
1138  * Description: vector decl range specification
1139  * Number Of Arguments: 2
1140  * arg0: CNode* msb expression, if lsb is null range is msb-1:0
1141  * arg1: CNode* lsb expression, if NULL range is msb-1:0
1142  */
1147  /*
1148  * SLICE node
1149  * Description: vector subrange
1150  * Number Of Arguments: 2
1151  * arg0: CNode* msb expression
1152  * arg1: CNode* lsb expression
1153  */
1158  /*
1159  * PSLICE node
1160  * Description: vector subrange with ascending index select
1161  * Number Of Arguments: 2
1162  * arg0: CNode* index expression
1163  * arg1: CNode* width expression
1164  */
1169  /*
1170  * MSLICE node
1171  * Description: vector subrange with descending index select
1172  * Number Of Arguments: 2
1173  * arg0: CNode* index expression
1174  * arg1: CNode* width expression
1175  */
1180  /*
1181  * CVRI node
1182  * Description: convert real to integer
1183  * Number Of Arguments: 1
1184  * arg0: CNode* expression
1185  */
1190  /*
1191  * CVIR node
1192  * Description: convert integer to real
1193  * Number Of Arguments: 1
1194  * arg0: CNode* expression
1195  */
1200  /*
1201  * REP node
1202  * Description: replication operator
1203  * Number Of Arguments: 2
1204  * arg0: CNode* replication expression
1205  * arg1: CNode* expression to replicate
1206  */
1211  /*
1212  * CAT node
1213  * Description: concatenation operator
1214  * Number Of Arguments: 2
1215  * arg0: CNode* expression 1
1216  * arg1: CNode* expression 2
1217  */
1222  /*
1223  * UCAT node
1224  * Description: unary concat
1225  * Number Of Arguments: 1
1226  * arg0: CNode* expression
1227  */
1232  /*
1233  * COM node
1234  * Description: bitwise complement
1235  * Number Of Arguments: 1
1236  * arg0: CNode* expression
1237  */
1242  /*
1243  * NEG node
1244  * Description: negation
1245  * Number Of Arguments: 1
1246  * arg0: CNode* expression
1247  */
1252  /*
1253  * PLUS node
1254  * Description: unary plus
1255  * Number Of Arguments: 1
1256  * arg0: CNode* expression
1257  */
1262  /*
1263  * NOT node
1264  * Description: logical complement
1265  * Number Of Arguments: 1
1266  * arg0: CNode* expression
1267  */
1272  /*
1273  * GT node
1274  * Description: greater than
1275  * Number Of Arguments: 2
1276  * arg0: CNode* expression 1
1277  * arg1: CNode* expression 2
1278  */
1283  /*
1284  * GE node
1285  * Description: greater than or equal
1286  * Number Of Arguments: 2
1287  * arg0: CNode* expression 1
1288  * arg1: CNode* expression 2
1289  */
1294  /*
1295  * LT node
1296  * Description: less than
1297  * Number Of Arguments: 2
1298  * arg0: CNode* expression 1
1299  * arg1: CNode* expression 2
1300  */
1305  /*
1306  * LE node
1307  * Description: less than or equal
1308  * Number Of Arguments: 2
1309  * arg0: CNode* expression 1
1310  * arg1: CNode* expression 2
1311  */
1316  /*
1317  * LAND node
1318  * Description: logical and
1319  * Number Of Arguments: 2
1320  * arg0: CNode* expression 1
1321  * arg1: CNode* expression 2
1322  */
1327  /*
1328  * LOR node
1329  * Description: logical or
1330  * Number Of Arguments: 2
1331  * arg0: CNode* expression 1
1332  * arg1: CNode* expression 2
1333  */
1338  /*
1339  * CEQ node
1340  * Description: case equal
1341  * Number Of Arguments: 2
1342  * arg0: CNode* expression 1
1343  * arg1: CNode* expression 2
1344  */
1349  /*
1350  * CNE node
1351  * Description: case not equal
1352  * Number Of Arguments: 2
1353  * arg0: CNode* expression 1
1354  * arg1: CNode* expression 2
1355  */
1360  /*
1361  * EQ node
1362  * Description: equal
1363  * Number Of Arguments: 2
1364  * arg0: CNode* expression 1
1365  * arg1: CNode* expression 2
1366  */
1371  /*
1372  * NE node
1373  * Description: not equal
1374  * Number Of Arguments: 2
1375  * arg0: CNode* expression 1
1376  * arg1: CNode* expression 2
1377  */
1382  /*
1383  * RAND node
1384  * Description: reduction and
1385  * Number Of Arguments: 1
1386  * arg0: CNode* expression
1387  */
1392  /*
1393  * RNAND node
1394  * Description: reduction nand
1395  * Number Of Arguments: 1
1396  * arg0: CNode* expression
1397  */
1402  /*
1403  * ROR node
1404  * Description: reduction or
1405  * Number Of Arguments: 1
1406  * arg0: CNode* expression
1407  */
1412  /*
1413  * RNOR node
1414  * Description: reduction nor
1415  * Number Of Arguments: 1
1416  * arg0: CNode* expression
1417  */
1422  /*
1423  * RXOR node
1424  * Description: reduction xor
1425  * Number Of Arguments: 1
1426  * arg0: CNode* expression
1427  */
1432  /*
1433  * RXNOR node
1434  * Description: reduction xnor
1435  * Number Of Arguments: 1
1436  * arg0: CNode* expression
1437  */
1442  /*
1443  * HOOK node
1444  * Description: condition expression operator
1445  * Number Of Arguments: 3
1446  * arg0: CNode* condition expression
1447  * arg1: CNode* true expression
1448  * arg2: CNode* false expression
1449  */
1454  /*
1455  * INIT node
1456  * Description: initial block
1457  * Number Of Arguments: 1
1458  * arg0: CNode*
1459  */
1464  /*
1465  * ALWAYS node
1466  * Description: always block
1467  * Number Of Arguments: 1
1468  * arg0: CNode*
1469  */
1474  /*
1475  * ALWAYS_LATCH node
1476  * Description: always latch block
1477  * Number Of Arguments: 1
1478  * arg0: CNode*
1479  */
1484  /*
1485  * ALWAYS_FF node
1486  * Description: always flip-flop block
1487  * Number Of Arguments: 1
1488  * arg0: CNode*
1489  */
1494  /*
1495  * ALWAYS_COMB node
1496  * Description: always combinational logic block
1497  * Number Of Arguments: 1
1498  * arg0: CNode*
1499  */
1504  /*
1505  * EVENT node
1506  * Description: event statement
1507  * Number Of Arguments: 2
1508  * arg0: CNode* event expression (NULL for @*)
1509  * arg1: CNode* statement
1510  */
1515  /*
1516  * BLOCK_REF node
1517  * Description: statement block
1518  * Number Of Arguments: 3
1519  * arg0: CBlock* pointer to block
1520  * arg1: CNode* list of statements
1521  * arg2: bool true if begin/end is invisible
1522  */
1527  /*
1528  * SPECIFY_REF node
1529  * Description: specify block
1530  * Number Of Arguments: 2
1531  * arg0: CSpecify* pointer to specify structure
1532  * arg1: CNode* list of statements
1533  */
1538  /*
1539  * ASSIGN node
1540  * Description: procedural assignment
1541  * Number Of Arguments: 3
1542  * arg0: CNode* event expression
1543  * arg1: CNode* lval
1544  * arg2: CNode* rval
1545  */
1550  /*
1551  * GASSIGN node
1552  * Description: generate intialize assignment
1553  * Number Of Arguments: 3
1554  * arg0: bool declare genvar
1555  * arg1: CNode* lval
1556  * arg2: CNode* rval
1557  */
1562  /*
1563  * ADD_ASSIGN node
1564  * Description: procedural assignment with add
1565  * Number Of Arguments: 3
1566  * arg0: CNode* event expression
1567  * arg1: CNode* lval
1568  * arg2: CNode* rval
1569  */
1574  /*
1575  * SUB_ASSIGN node
1576  * Description: procedural assignment with subtract
1577  * Number Of Arguments: 3
1578  * arg0: CNode* event expression
1579  * arg1: CNode* lval
1580  * arg2: CNode* rval
1581  */
1586  /*
1587  * MUL_ASSIGN node
1588  * Description: procedural assignment with mul
1589  * Number Of Arguments: 3
1590  * arg0: CNode* event expression
1591  * arg1: CNode* lval
1592  * arg2: CNode* rval
1593  */
1598  /*
1599  * DIV_ASSIGN node
1600  * Description: procedural assignment with div
1601  * Number Of Arguments: 3
1602  * arg0: CNode* event expression
1603  * arg1: CNode* lval
1604  * arg2: CNode* rval
1605  */
1610  /*
1611  * MOD_ASSIGN node
1612  * Description: procedural assignment with mod
1613  * Number Of Arguments: 3
1614  * arg0: CNode* event expression
1615  * arg1: CNode* lval
1616  * arg2: CNode* rval
1617  */
1622  /*
1623  * AND_ASSIGN node
1624  * Description: procedural assignment with bitwise and
1625  * Number Of Arguments: 3
1626  * arg0: CNode* event expression
1627  * arg1: CNode* lval
1628  * arg2: CNode* rval
1629  */
1634  /*
1635  * OR_ASSIGN node
1636  * Description: procedural assignment with bitwise or
1637  * Number Of Arguments: 3
1638  * arg0: CNode* event expression
1639  * arg1: CNode* lval
1640  * arg2: CNode* rval
1641  */
1646  /*
1647  * XOR_ASSIGN node
1648  * Description: procedural assignment with bitwise xor
1649  * Number Of Arguments: 3
1650  * arg0: CNode* event expression
1651  * arg1: CNode* lval
1652  * arg2: CNode* rval
1653  */
1658  /*
1659  * LSH_ASSIGN node
1660  * Description: procedural assignment with left shift
1661  * Number Of Arguments: 3
1662  * arg0: CNode* event expression
1663  * arg1: CNode* lval
1664  * arg2: CNode* rval
1665  */
1670  /*
1671  * RSH_ASSIGN node
1672  * Description: procedural assignment with right shift
1673  * Number Of Arguments: 3
1674  * arg0: CNode* event expression
1675  * arg1: CNode* lval
1676  * arg2: CNode* rval
1677  */
1682  /*
1683  * LSHA_ASSIGN node
1684  * Description: procedural assignment with left arithmetic shift
1685  * Number Of Arguments: 3
1686  * arg0: CNode* event expression
1687  * arg1: CNode* lval
1688  * arg2: CNode* rval
1689  */
1694  /*
1695  * RSHA_ASSIGN node
1696  * Description: procedural assignment with right arithmetic shift
1697  * Number Of Arguments: 3
1698  * arg0: CNode* event expression
1699  * arg1: CNode* lval
1700  * arg2: CNode* rval
1701  */
1706  /*
1707  * FORCE node
1708  * Description: force statement
1709  * Number Of Arguments: 2
1710  * arg0: CNode* lval
1711  * arg1: CNode* expression
1712  */
1717  /*
1718  * RELEASE node
1719  * Description: release statement
1720  * Number Of Arguments: 1
1721  * arg0: CNode* lval
1722  */
1727  /*
1728  * NBASSIGN node
1729  * Description: nonblocking assignment
1730  * Number Of Arguments: 3
1731  * arg0: CNode* event expression
1732  * arg1: CNode* lval
1733  * arg2: CNode* rval
1734  */
1739  /*
1740  * POSEDGE node
1741  * Description: positive event qualifier
1742  * Number Of Arguments: 1
1743  * arg0: CNode* expression
1744  */
1749  /*
1750  * NEGEDGE node
1751  * Description: negative event qualifier
1752  * Number Of Arguments: 1
1753  * arg0: CNode* expression
1754  */
1759  /*
1760  * EDGE node
1761  * Description: edge qualifier
1762  * Number Of Arguments: 2
1763  * arg0: CNode*
1764  * arg1: Edge_t edge specification
1765  */
1770  /*
1771  * EVOR node
1772  * Description: event or
1773  * Number Of Arguments: 2
1774  * arg0: CNode* expression 1
1775  * arg1: CNode* expression 2
1776  */
1781  /*
1782  * DELAY node
1783  * Description: delay statement
1784  * Number Of Arguments: 2
1785  * arg0: CNode* delay expression
1786  * arg1: CNode* statements
1787  */
1792  /*
1793  * MTM node
1794  * Description: min/typ/max expression
1795  * Number Of Arguments: 3
1796  * arg0: CNode* minimum expression
1797  * arg1: CNode* typical expression
1798  * arg2: CNode* maximum expression
1799  */
1804  /*
1805  * IF node
1806  * Description: if statement
1807  * Number Of Arguments: 4
1808  * arg0: CNode* condition
1809  * arg1: CNode* true statements
1810  * arg2: CNode* false statements
1811  * arg3: ConditionalType type
1812  */
1817  /*
1818  * FOREVER node
1819  * Description: forever statement
1820  * Number Of Arguments: 1
1821  * arg0: CNode* statements
1822  */
1827  /*
1828  * REPEAT node
1829  * Description: repeat statement
1830  * Number Of Arguments: 2
1831  * arg0: CNode* condition
1832  * arg1: CNode* statements
1833  */
1838  /*
1839  * WHILE node
1840  * Description: while statement
1841  * Number Of Arguments: 2
1842  * arg0: CNode* condition
1843  * arg1: CNode* statements
1844  */
1849  /*
1850  * WAIT node
1851  * Description: wait statement
1852  * Number Of Arguments: 2
1853  * arg0: CNode* condition
1854  * arg1: CNode* statements
1855  */
1860  /*
1861  * FOR node
1862  * Description: for statement
1863  * Number Of Arguments: 4
1864  * arg0: CNode* initial statement
1865  * arg1: CNode* condition
1866  * arg2: CNode* assignment statement
1867  * arg3: CNode* statements
1868  */
1873  /*
1874  * CASE node
1875  * Description: case statement
1876  * Number Of Arguments: 4
1877  * arg0: CNode* condition
1878  * arg1: CNode* list of case items
1879  * arg2: ConditionalType type
1880  * arg3: bool inner attribute
1881  */
1886  /*
1887  * CASEX node
1888  * Description: casex statement
1889  * Number Of Arguments: 3
1890  * arg0: CNode* condition
1891  * arg1: CNode* list of case items
1892  * arg2: ConditionalType type
1893  */
1898  /*
1899  * CASEZ node
1900  * Description: casez statement
1901  * Number Of Arguments: 3
1902  * arg0: CNode* condition
1903  * arg1: CNode* list of case items
1904  * arg2: ConditionalType type
1905  */
1910  /*
1911  * CASEITEM node
1912  * Description: case item
1913  * Number Of Arguments: 2
1914  * arg0: CNode* list of expressions (NULL for default)
1915  * arg1: CNode* statement
1916  */
1921  /*
1922  * CASSIGN node
1923  * Description: continious assignment
1924  * Number Of Arguments: 4
1925  * arg0: StrengthPair_t* assignment strength
1926  * arg1: CNode* delay expression
1927  * arg2: CNode* lval
1928  * arg3: CNode* rval expression
1929  */
1934  /*
1935  * ARG node
1936  * Description: port connection
1937  * Number Of Arguments: 2
1938  * arg0: CSymbol* port name
1939  * arg1: CNode* port expression
1940  */
1945  /*
1946  * IMPORT node
1947  * Description: import item
1948  * Number Of Arguments: 1
1949  * arg0: CSymbol* package::symbol or package(for wildcard)
1950  */
1955  /*
1956  * FUNCTION_DEF node
1957  * Description: function definition
1958  * Number Of Arguments: 1
1959  * arg0: CFunction*
1960  */
1965  /*
1966  * MODULE_DEF node
1967  * Description: module definition
1968  * Number Of Arguments: 1
1969  * arg0: CModule*
1970  */
1975  /*
1976  * PACKAGE_DEF node
1977  * Description: package definition
1978  * Number Of Arguments: 1
1979  * arg0: CPackage*
1980  */
1985  /*
1986  * REPEAT_CONTROL node
1987  * Description: repeat control
1988  * Number Of Arguments: 2
1989  * arg0: CNode* expression
1990  * arg1: CNode* event control
1991  */
1996  /*
1997  * DELAY_CONTROL node
1998  * Description: delay control
1999  * Number Of Arguments: 1
2000  * arg0: CNode* expression
2001  */
2006  /*
2007  * EVENT_CONTROL node
2008  * Description: event control
2009  * Number Of Arguments: 1
2010  * arg0: CNode* event expression (NULL for @*)
2011  */
2016  /*
2017  * EXTERNAL_REF node
2018  * Description: external reference
2019  * Number Of Arguments: 1
2020  * arg0: CSymbol* pointer to symbol
2021  */
2026  /*
2027  * PORT_DEF node
2028  * Description: port definition
2029  * Number Of Arguments: 1
2030  * arg0: CPort* pointer to port
2031  */
2036  /*
2037  * DEFPARAM node
2038  * Description: defparam statement
2039  * Number Of Arguments: 2
2040  * arg0: CNode* external reference
2041  * arg1: CNode* expression
2042  */
2047  /*
2048  * PATH node
2049  * Description: path statement
2050  * Number Of Arguments: 7
2051  * arg0: int
2052  * arg1: CNode* edge int[-1,0,1]
2053  * arg2: int Input list
2054  * arg3: int Left polarity int[-1,0,1]
2055  * arg4: CNode* Operation type int [0 = *>, 1 = =>]
2056  * arg5: int Output list
2057  * arg6: CNode* Right polarity int[-1,0,1]
2058  */
2063  /*
2064  * PATH_ASSIGN node
2065  * Description: path assignment statement
2066  * Number Of Arguments: 3
2067  * arg0: CNode* condition
2068  * arg1: CNode* path
2069  * arg2: CNode* expression
2070  */
2075  /*
2076  * IFNONE_PATH_ASSIGN node
2077  * Description: ifnone path assignment statement
2078  * Number Of Arguments: 2
2079  * arg0: CNode* path
2080  * arg1: CNode* expression
2081  */
2086  /*
2087  * TRIGGER node
2088  * Description: event trigger
2089  * Number Of Arguments: 1
2090  * arg0: CNode* event reference
2091  */
2096  /*
2097  * PASSIGN node
2098  * Description: procedural assignment
2099  * Number Of Arguments: 2
2100  * arg0: CNode* lval
2101  * arg1: CNode* expression
2102  */
2107  /*
2108  * DEASSIGN node
2109  * Description: deassign statement
2110  * Number Of Arguments: 1
2111  * arg0: CNode* lval
2112  */
2117  /*
2118  * DISABLE node
2119  * Description: disable statement
2120  * Number Of Arguments: 1
2121  * arg0: CSymbol* pointer to symbol
2122  */
2127  /*
2128  * ATTRIBUTE node
2129  * Description: attribute specification
2130  * Number Of Arguments: 1
2131  * arg0: CAttr* pointer to attribute
2132  */
2137  /*
2138  * GIF node
2139  * Description: structural if statement
2140  * Number Of Arguments: 3
2141  * arg0: CNode* condition
2142  * arg1: CNode* true statement
2143  * arg2: CNode* false statement
2144  */
2149  /*
2150  * GFOR node
2151  * Description: structural for statement
2152  * Number Of Arguments: 4
2153  * arg0: CNode* initial statement
2154  * arg1: CNode* condition
2155  * arg2: CNode* assignment statement
2156  * arg3: CNode* statement
2157  */
2162  /*
2163  * GCASE node
2164  * Description: structural case statement
2165  * Number Of Arguments: 2
2166  * arg0: CNode* condition
2167  * arg1: CNode* list of case items
2168  */
2173  /*
2174  * TABLE node
2175  * Description: udp table
2176  * Number Of Arguments: 1
2177  * arg0: CNode* list of table entries
2178  */
2183  /*
2184  * TABLE_ENTRY node
2185  * Description: udp table entry
2186  * Number Of Arguments: 1
2187  * arg0: CNode* list of table symbols
2188  */
2193  /*
2194  * TABLE_SYMBOL node
2195  * Description: udp table symbol
2196  * Number Of Arguments: 1
2197  * arg0: char* string of udp characters
2198  */
2203  /*
2204  * PORTLIST_END node
2205  * Description: sentinal at end of port list
2206  * Number Of Arguments: 0
2207  */
2212  /*
2213  * MACRO_EXPR node
2214  * Description: expression represented by a macro
2215  * Number Of Arguments: 2
2216  * arg0: const char* alternate expression, may be NULL
2217  * arg1: CNode*
2218  */
2223  /*
2224  * ENUM_SPEC node
2225  * Description: enum specification
2226  * Number Of Arguments: 3
2227  * arg0: CSymbol* Pointer to enum base symbol
2228  * arg1: CNode* range expression
2229  * arg2: CNode* starting expression value
2230  */
2235  /*
2236  * MEMBER node
2237  * Description: member reference (structure, class or external
2238  * Number Of Arguments: 2
2239  * arg0: CNode* Reference to variable
2240  * arg1: CSymbol* member symbol
2241  */
2246  /*
2247  * RETURN node
2248  * Description: return
2249  * Number Of Arguments: 1
2250  * arg0: CNode*
2251  */
2256  /*
2257  * PREINC node
2258  * Description: preincrement
2259  * Number Of Arguments: 1
2260  * arg0: CNode* expression
2261  */
2266  /*
2267  * POSTINC node
2268  * Description: postincrement
2269  * Number Of Arguments: 1
2270  * arg0: CNode* expression
2271  */
2276  /*
2277  * PREDEC node
2278  * Description: predecrement
2279  * Number Of Arguments: 1
2280  * arg0: CNode* expression
2281  */
2286  /*
2287  * POSTDEC node
2288  * Description: postdecrement
2289  * Number Of Arguments: 1
2290  * arg0: CNode* expression
2291  */
2296  /*
2297  * CAST node
2298  * Description: data type change
2299  * Number Of Arguments: 2
2300  * arg0: CNode* type reference or width expression
2301  * arg1: CNode* expression
2302  */
2307  /*
2308  * ASSIGNMENT_PATTERN node
2309  * Description: assignment_pattern
2310  * Number Of Arguments: 1
2311  * arg0: CNode* concatenation expression
2312  */
2317  /*
2318  * DOLLAR node
2319  * Description: queue dimension
2320  * Number Of Arguments: 0
2321  */
2323 };
2324 extern const char* nodeOpName[];
2325 extern const char* nodeOpDescription[];
2326 #endif // DEFINE_ENUM
2327 #ifdef DEFINE_METHODS
2328 const char* nodeOpName[] = {
2329  "ERROR",
2330  "VCONSTANT",
2331  "RCONSTANT",
2332  "COMMENT",
2333  "VRQ",
2334  "PRAGMA",
2335  "ELIST",
2336  "WIDTH",
2337  "NOP",
2338  "SUB",
2339  "MUL",
2340  "DIV",
2341  "POW",
2342  "ADD",
2343  "LSH",
2344  "RSH",
2345  "LSHA",
2346  "RSHA",
2347  "MOD",
2348  "OR",
2349  "AND",
2350  "ANDANDAND",
2351  "XOR",
2352  "XNOR",
2353  "INSTANCE_REF",
2354  "GATE_REF",
2355  "TASK_ENABLE",
2356  "SYSTASK_CALL",
2357  "TIMING_CALL",
2358  "FUNCTION_CALL",
2359  "ARRAY",
2360  "NET_REF",
2361  "VAR_REF",
2362  "PARAM_REF",
2363  "PORT_REF",
2364  "FWD_REF",
2365  "GENVAR_REF",
2366  "ENUM_REF",
2367  "TYPE_REF",
2368  "NET_DECL",
2369  "VAR_DECL",
2370  "PARAM_DECL",
2371  "SPECPARAM_DECL",
2372  "PORT_DECL",
2373  "GENVAR_DECL",
2374  "TYPEDEF_DECL",
2375  "LIST",
2376  "RANGE",
2377  "SLICE",
2378  "PSLICE",
2379  "MSLICE",
2380  "CVRI",
2381  "CVIR",
2382  "REP",
2383  "CAT",
2384  "UCAT",
2385  "COM",
2386  "NEG",
2387  "PLUS",
2388  "NOT",
2389  "GT",
2390  "GE",
2391  "LT",
2392  "LE",
2393  "LAND",
2394  "LOR",
2395  "CEQ",
2396  "CNE",
2397  "EQ",
2398  "NE",
2399  "RAND",
2400  "RNAND",
2401  "ROR",
2402  "RNOR",
2403  "RXOR",
2404  "RXNOR",
2405  "HOOK",
2406  "INIT",
2407  "ALWAYS",
2408  "ALWAYS_LATCH",
2409  "ALWAYS_FF",
2410  "ALWAYS_COMB",
2411  "EVENT",
2412  "BLOCK_REF",
2413  "SPECIFY_REF",
2414  "ASSIGN",
2415  "GASSIGN",
2416  "ADD_ASSIGN",
2417  "SUB_ASSIGN",
2418  "MUL_ASSIGN",
2419  "DIV_ASSIGN",
2420  "MOD_ASSIGN",
2421  "AND_ASSIGN",
2422  "OR_ASSIGN",
2423  "XOR_ASSIGN",
2424  "LSH_ASSIGN",
2425  "RSH_ASSIGN",
2426  "LSHA_ASSIGN",
2427  "RSHA_ASSIGN",
2428  "FORCE",
2429  "RELEASE",
2430  "NBASSIGN",
2431  "POSEDGE",
2432  "NEGEDGE",
2433  "EDGE",
2434  "EVOR",
2435  "DELAY",
2436  "MTM",
2437  "IF",
2438  "FOREVER",
2439  "REPEAT",
2440  "WHILE",
2441  "WAIT",
2442  "FOR",
2443  "CASE",
2444  "CASEX",
2445  "CASEZ",
2446  "CASEITEM",
2447  "CASSIGN",
2448  "ARG",
2449  "IMPORT",
2450  "FUNCTION_DEF",
2451  "MODULE_DEF",
2452  "PACKAGE_DEF",
2453  "REPEAT_CONTROL",
2454  "DELAY_CONTROL",
2455  "EVENT_CONTROL",
2456  "EXTERNAL_REF",
2457  "PORT_DEF",
2458  "DEFPARAM",
2459  "PATH",
2460  "PATH_ASSIGN",
2461  "IFNONE_PATH_ASSIGN",
2462  "TRIGGER",
2463  "PASSIGN",
2464  "DEASSIGN",
2465  "DISABLE",
2466  "ATTRIBUTE",
2467  "GIF",
2468  "GFOR",
2469  "GCASE",
2470  "TABLE",
2471  "TABLE_ENTRY",
2472  "TABLE_SYMBOL",
2473  "PORTLIST_END",
2474  "MACRO_EXPR",
2475  "ENUM_SPEC",
2476  "MEMBER",
2477  "RETURN",
2478  "PREINC",
2479  "POSTINC",
2480  "PREDEC",
2481  "POSTDEC",
2482  "CAST",
2483  "ASSIGNMENT_PATTERN",
2484  "DOLLAR",
2485 NULL
2486 };
2487 const char* nodeOpDescription[] = {
2488  "error node",
2489  "vector constant",
2490  "real constant",
2491  "comment",
2492  "vrq comment",
2493  "program pragma",
2494  "expression list",
2495  "expression width change",
2496  "no operation",
2497  "subtract",
2498  "multiply",
2499  "divide",
2500  "exponent",
2501  "addition",
2502  "logical left shift",
2503  "logical right shift",
2504  "arithmetic left shift",
2505  "arithmetic right shift",
2506  "modulus",
2507  "bitwise or",
2508  "bitwise and",
2509  "triple and",
2510  "bitwise xor",
2511  "bitwise xnor",
2512  "instance reference",
2513  "gate instance",
2514  "call to a task",
2515  "call to enable a systask",
2516  "call to a timing task",
2517  "call to a function",
2518  "dimensioned reference (array/bit select)",
2519  "reference to net",
2520  "reference to variable",
2521  "reference to parameter",
2522  "reference to port",
2523  "reference to a forward declared variable",
2524  "reference to a genvar",
2525  "reference to a enum",
2526  "reference to a type",
2527  "net declaration",
2528  "variable declaration",
2529  "parameter declaration",
2530  "specify parameter declaration",
2531  "port declaration",
2532  "genvar declaration",
2533  "type declaration",
2534  "list of nodes",
2535  "vector decl range specification",
2536  "vector subrange",
2537  "vector subrange with ascending index select",
2538  "vector subrange with descending index select",
2539  "convert real to integer",
2540  "convert integer to real",
2541  "replication operator",
2542  "concatenation operator",
2543  "unary concat",
2544  "bitwise complement",
2545  "negation",
2546  "unary plus",
2547  "logical complement",
2548  "greater than",
2549  "greater than or equal",
2550  "less than",
2551  "less than or equal",
2552  "logical and",
2553  "logical or",
2554  "case equal",
2555  "case not equal",
2556  "equal",
2557  "not equal",
2558  "reduction and",
2559  "reduction nand",
2560  "reduction or",
2561  "reduction nor",
2562  "reduction xor",
2563  "reduction xnor",
2564  "condition expression operator",
2565  "initial block",
2566  "always block",
2567  "always latch block",
2568  "always flip-flop block",
2569  "always combinational logic block",
2570  "event statement",
2571  "statement block",
2572  "specify block",
2573  "procedural assignment",
2574  "generate intialize assignment",
2575  "procedural assignment with add",
2576  "procedural assignment with subtract",
2577  "procedural assignment with mul",
2578  "procedural assignment with div",
2579  "procedural assignment with mod",
2580  "procedural assignment with bitwise and",
2581  "procedural assignment with bitwise or",
2582  "procedural assignment with bitwise xor",
2583  "procedural assignment with left shift",
2584  "procedural assignment with right shift",
2585  "procedural assignment with left arithmetic shift",
2586  "procedural assignment with right arithmetic shift",
2587  "force statement",
2588  "release statement",
2589  "nonblocking assignment",
2590  "positive event qualifier",
2591  "negative event qualifier",
2592  "edge qualifier",
2593  "event or",
2594  "delay statement",
2595  "min/typ/max expression",
2596  "if statement",
2597  "forever statement",
2598  "repeat statement",
2599  "while statement",
2600  "wait statement",
2601  "for statement",
2602  "case statement",
2603  "casex statement",
2604  "casez statement",
2605  "case item",
2606  "continious assignment",
2607  "port connection",
2608  "import item",
2609  "function definition",
2610  "module definition",
2611  "package definition",
2612  "repeat control",
2613  "delay control",
2614  "event control",
2615  "external reference",
2616  "port definition",
2617  "defparam statement",
2618  "path statement",
2619  "path assignment statement",
2620  "ifnone path assignment statement",
2621  "event trigger",
2622  "procedural assignment",
2623  "deassign statement",
2624  "disable statement",
2625  "attribute specification",
2626  "structural if statement",
2627  "structural for statement",
2628  "structural case statement",
2629  "udp table",
2630  "udp table entry",
2631  "udp table symbol",
2632  "sentinal at end of port list",
2633  "expression represented by a macro",
2634  "enum specification",
2635  "member reference (structure, class or external",
2636  "return",
2637  "preincrement",
2638  "postincrement",
2639  "predecrement",
2640  "postdecrement",
2641  "data type change",
2642  "assignment_pattern",
2643  "queue dimension",
2644 NULL
2645 };
2646 #endif // DEFINE_METHODS
2647 
2648 
2649 #ifdef DEFINE_CONSTRUCTOR
2650 
2658 inline CNode* cERROR( Coord_t* loc=NULL )
2659 {
2660  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eERROR );
2661  return n;
2662 }
2671 inline CNode* cERROR( CObstack* heap, Coord_t* loc=NULL )
2672 {
2673  CNode* n = new(heap) CNode( loc, eERROR );
2674  return n;
2675 }
2684 inline CNode* cVCONSTANT( CVector* a0, Coord_t* loc=NULL )
2685 {
2686  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eVCONSTANT );
2687  n->Arg<CVector*>(0) = a0;
2688  return n;
2689 }
2699 inline CNode* cVCONSTANT( CObstack* heap, CVector* a0, Coord_t* loc=NULL )
2700 {
2701  CNode* n = new(heap) CNode( loc, eVCONSTANT );
2702  n->Arg<CVector*>(0) = a0;
2703  return n;
2704 }
2713 inline CNode* cRCONSTANT( char* a0, Coord_t* loc=NULL )
2714 {
2715  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRCONSTANT );
2716  n->Arg<char*>(0) = a0;
2717  return n;
2718 }
2728 inline CNode* cRCONSTANT( CObstack* heap, char* a0, Coord_t* loc=NULL )
2729 {
2730  CNode* n = new(heap) CNode( loc, eRCONSTANT );
2731  n->Arg<char*>(0) = a0;
2732  return n;
2733 }
2742 inline CNode* cCOMMENT( const char* a0, Coord_t* loc=NULL )
2743 {
2744  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCOMMENT );
2745  n->Arg<const char*>(0) = a0;
2746  return n;
2747 }
2757 inline CNode* cCOMMENT( CObstack* heap, const char* a0, Coord_t* loc=NULL )
2758 {
2759  CNode* n = new(heap) CNode( loc, eCOMMENT );
2760  n->Arg<const char*>(0) = a0;
2761  return n;
2762 }
2771 inline CNode* cVRQ( const char* a0, Coord_t* loc=NULL )
2772 {
2773  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eVRQ );
2774  n->Arg<const char*>(0) = a0;
2775  return n;
2776 }
2786 inline CNode* cVRQ( CObstack* heap, const char* a0, Coord_t* loc=NULL )
2787 {
2788  CNode* n = new(heap) CNode( loc, eVRQ );
2789  n->Arg<const char*>(0) = a0;
2790  return n;
2791 }
2801 inline CNode* cPRAGMA( const char* a0, int a1, Coord_t* loc=NULL )
2802 {
2803  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePRAGMA );
2804  n->Arg<const char*>(0) = a0;
2805  n->Arg<int>(1) = a1;
2806  return n;
2807 }
2818 inline CNode* cPRAGMA( CObstack* heap, const char* a0, int a1, Coord_t* loc=NULL )
2819 {
2820  CNode* n = new(heap) CNode( loc, ePRAGMA );
2821  n->Arg<const char*>(0) = a0;
2822  n->Arg<int>(1) = a1;
2823  return n;
2824 }
2834 inline CNode* cELIST( CNode* a0, CNode* a1, Coord_t* loc=NULL )
2835 {
2836  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eELIST );
2837  n->Arg<CNode*>(0) = a0;
2838  n->Arg<CNode*>(1) = a1;
2839  return n;
2840 }
2851 inline CNode* cELIST( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
2852 {
2853  CNode* n = new(heap) CNode( loc, eELIST );
2854  n->Arg<CNode*>(0) = a0;
2855  n->Arg<CNode*>(1) = a1;
2856  return n;
2857 }
2867 inline CNode* cWIDTH( CNode* a0, CNode* a1, Coord_t* loc=NULL )
2868 {
2869  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eWIDTH );
2870  n->Arg<CNode*>(0) = a0;
2871  n->Arg<CNode*>(1) = a1;
2872  return n;
2873 }
2884 inline CNode* cWIDTH( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
2885 {
2886  CNode* n = new(heap) CNode( loc, eWIDTH );
2887  n->Arg<CNode*>(0) = a0;
2888  n->Arg<CNode*>(1) = a1;
2889  return n;
2890 }
2898 inline CNode* cNOP( Coord_t* loc=NULL )
2899 {
2900  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eNOP );
2901  return n;
2902 }
2911 inline CNode* cNOP( CObstack* heap, Coord_t* loc=NULL )
2912 {
2913  CNode* n = new(heap) CNode( loc, eNOP );
2914  return n;
2915 }
2925 inline CNode* cSUB( CNode* a0, CNode* a1, Coord_t* loc=NULL )
2926 {
2927  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eSUB );
2928  n->Arg<CNode*>(0) = a0;
2929  n->Arg<CNode*>(1) = a1;
2930  return n;
2931 }
2942 inline CNode* cSUB( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
2943 {
2944  CNode* n = new(heap) CNode( loc, eSUB );
2945  n->Arg<CNode*>(0) = a0;
2946  n->Arg<CNode*>(1) = a1;
2947  return n;
2948 }
2958 inline CNode* cMUL( CNode* a0, CNode* a1, Coord_t* loc=NULL )
2959 {
2960  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eMUL );
2961  n->Arg<CNode*>(0) = a0;
2962  n->Arg<CNode*>(1) = a1;
2963  return n;
2964 }
2975 inline CNode* cMUL( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
2976 {
2977  CNode* n = new(heap) CNode( loc, eMUL );
2978  n->Arg<CNode*>(0) = a0;
2979  n->Arg<CNode*>(1) = a1;
2980  return n;
2981 }
2991 inline CNode* cDIV( CNode* a0, CNode* a1, Coord_t* loc=NULL )
2992 {
2993  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eDIV );
2994  n->Arg<CNode*>(0) = a0;
2995  n->Arg<CNode*>(1) = a1;
2996  return n;
2997 }
3008 inline CNode* cDIV( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
3009 {
3010  CNode* n = new(heap) CNode( loc, eDIV );
3011  n->Arg<CNode*>(0) = a0;
3012  n->Arg<CNode*>(1) = a1;
3013  return n;
3014 }
3024 inline CNode* cPOW( CNode* a0, CNode* a1, Coord_t* loc=NULL )
3025 {
3026  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePOW );
3027  n->Arg<CNode*>(0) = a0;
3028  n->Arg<CNode*>(1) = a1;
3029  return n;
3030 }
3041 inline CNode* cPOW( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
3042 {
3043  CNode* n = new(heap) CNode( loc, ePOW );
3044  n->Arg<CNode*>(0) = a0;
3045  n->Arg<CNode*>(1) = a1;
3046  return n;
3047 }
3057 inline CNode* cADD( CNode* a0, CNode* a1, Coord_t* loc=NULL )
3058 {
3059  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eADD );
3060  n->Arg<CNode*>(0) = a0;
3061  n->Arg<CNode*>(1) = a1;
3062  return n;
3063 }
3074 inline CNode* cADD( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
3075 {
3076  CNode* n = new(heap) CNode( loc, eADD );
3077  n->Arg<CNode*>(0) = a0;
3078  n->Arg<CNode*>(1) = a1;
3079  return n;
3080 }
3090 inline CNode* cLSH( CNode* a0, CNode* a1, Coord_t* loc=NULL )
3091 {
3092  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eLSH );
3093  n->Arg<CNode*>(0) = a0;
3094  n->Arg<CNode*>(1) = a1;
3095  return n;
3096 }
3107 inline CNode* cLSH( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
3108 {
3109  CNode* n = new(heap) CNode( loc, eLSH );
3110  n->Arg<CNode*>(0) = a0;
3111  n->Arg<CNode*>(1) = a1;
3112  return n;
3113 }
3123 inline CNode* cRSH( CNode* a0, CNode* a1, Coord_t* loc=NULL )
3124 {
3125  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRSH );
3126  n->Arg<CNode*>(0) = a0;
3127  n->Arg<CNode*>(1) = a1;
3128  return n;
3129 }
3140 inline CNode* cRSH( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
3141 {
3142  CNode* n = new(heap) CNode( loc, eRSH );
3143  n->Arg<CNode*>(0) = a0;
3144  n->Arg<CNode*>(1) = a1;
3145  return n;
3146 }
3156 inline CNode* cLSHA( CNode* a0, CNode* a1, Coord_t* loc=NULL )
3157 {
3158  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eLSHA );
3159  n->Arg<CNode*>(0) = a0;
3160  n->Arg<CNode*>(1) = a1;
3161  return n;
3162 }
3173 inline CNode* cLSHA( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
3174 {
3175  CNode* n = new(heap) CNode( loc, eLSHA );
3176  n->Arg<CNode*>(0) = a0;
3177  n->Arg<CNode*>(1) = a1;
3178  return n;
3179 }
3189 inline CNode* cRSHA( CNode* a0, CNode* a1, Coord_t* loc=NULL )
3190 {
3191  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRSHA );
3192  n->Arg<CNode*>(0) = a0;
3193  n->Arg<CNode*>(1) = a1;
3194  return n;
3195 }
3206 inline CNode* cRSHA( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
3207 {
3208  CNode* n = new(heap) CNode( loc, eRSHA );
3209  n->Arg<CNode*>(0) = a0;
3210  n->Arg<CNode*>(1) = a1;
3211  return n;
3212 }
3222 inline CNode* cMOD( CNode* a0, CNode* a1, Coord_t* loc=NULL )
3223 {
3224  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eMOD );
3225  n->Arg<CNode*>(0) = a0;
3226  n->Arg<CNode*>(1) = a1;
3227  return n;
3228 }
3239 inline CNode* cMOD( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
3240 {
3241  CNode* n = new(heap) CNode( loc, eMOD );
3242  n->Arg<CNode*>(0) = a0;
3243  n->Arg<CNode*>(1) = a1;
3244  return n;
3245 }
3255 inline CNode* cOR( CNode* a0, CNode* a1, Coord_t* loc=NULL )
3256 {
3257  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eOR );
3258  n->Arg<CNode*>(0) = a0;
3259  n->Arg<CNode*>(1) = a1;
3260  return n;
3261 }
3272 inline CNode* cOR( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
3273 {
3274  CNode* n = new(heap) CNode( loc, eOR );
3275  n->Arg<CNode*>(0) = a0;
3276  n->Arg<CNode*>(1) = a1;
3277  return n;
3278 }
3288 inline CNode* cAND( CNode* a0, CNode* a1, Coord_t* loc=NULL )
3289 {
3290  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eAND );
3291  n->Arg<CNode*>(0) = a0;
3292  n->Arg<CNode*>(1) = a1;
3293  return n;
3294 }
3305 inline CNode* cAND( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
3306 {
3307  CNode* n = new(heap) CNode( loc, eAND );
3308  n->Arg<CNode*>(0) = a0;
3309  n->Arg<CNode*>(1) = a1;
3310  return n;
3311 }
3321 inline CNode* cANDANDAND( CNode* a0, CNode* a1, Coord_t* loc=NULL )
3322 {
3323  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eANDANDAND );
3324  n->Arg<CNode*>(0) = a0;
3325  n->Arg<CNode*>(1) = a1;
3326  return n;
3327 }
3338 inline CNode* cANDANDAND( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
3339 {
3340  CNode* n = new(heap) CNode( loc, eANDANDAND );
3341  n->Arg<CNode*>(0) = a0;
3342  n->Arg<CNode*>(1) = a1;
3343  return n;
3344 }
3354 inline CNode* cXOR( CNode* a0, CNode* a1, Coord_t* loc=NULL )
3355 {
3356  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eXOR );
3357  n->Arg<CNode*>(0) = a0;
3358  n->Arg<CNode*>(1) = a1;
3359  return n;
3360 }
3371 inline CNode* cXOR( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
3372 {
3373  CNode* n = new(heap) CNode( loc, eXOR );
3374  n->Arg<CNode*>(0) = a0;
3375  n->Arg<CNode*>(1) = a1;
3376  return n;
3377 }
3387 inline CNode* cXNOR( CNode* a0, CNode* a1, Coord_t* loc=NULL )
3388 {
3389  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eXNOR );
3390  n->Arg<CNode*>(0) = a0;
3391  n->Arg<CNode*>(1) = a1;
3392  return n;
3393 }
3404 inline CNode* cXNOR( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
3405 {
3406  CNode* n = new(heap) CNode( loc, eXNOR );
3407  n->Arg<CNode*>(0) = a0;
3408  n->Arg<CNode*>(1) = a1;
3409  return n;
3410 }
3419 inline CNode* cINSTANCE_REF( CInstance* a0, Coord_t* loc=NULL )
3420 {
3421  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eINSTANCE_REF );
3422  n->Arg<CInstance*>(0) = a0;
3423  return n;
3424 }
3434 inline CNode* cINSTANCE_REF( CObstack* heap, CInstance* a0, Coord_t* loc=NULL )
3435 {
3436  CNode* n = new(heap) CNode( loc, eINSTANCE_REF );
3437  n->Arg<CInstance*>(0) = a0;
3438  return n;
3439 }
3448 inline CNode* cGATE_REF( CGate* a0, Coord_t* loc=NULL )
3449 {
3450  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eGATE_REF );
3451  n->Arg<CGate*>(0) = a0;
3452  return n;
3453 }
3463 inline CNode* cGATE_REF( CObstack* heap, CGate* a0, Coord_t* loc=NULL )
3464 {
3465  CNode* n = new(heap) CNode( loc, eGATE_REF );
3466  n->Arg<CGate*>(0) = a0;
3467  return n;
3468 }
3478 inline CNode* cTASK_ENABLE( CSymbol* a0, CNode* a1, Coord_t* loc=NULL )
3479 {
3480  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eTASK_ENABLE );
3481  n->Arg<CSymbol*>(0) = a0;
3482  n->Arg<CNode*>(1) = a1;
3483  return n;
3484 }
3495 inline CNode* cTASK_ENABLE( CObstack* heap, CSymbol* a0, CNode* a1, Coord_t* loc=NULL )
3496 {
3497  CNode* n = new(heap) CNode( loc, eTASK_ENABLE );
3498  n->Arg<CSymbol*>(0) = a0;
3499  n->Arg<CNode*>(1) = a1;
3500  return n;
3501 }
3511 inline CNode* cSYSTASK_CALL( CSymbol* a0, CNode* a1, Coord_t* loc=NULL )
3512 {
3513  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eSYSTASK_CALL );
3514  n->Arg<CSymbol*>(0) = a0;
3515  n->Arg<CNode*>(1) = a1;
3516  return n;
3517 }
3528 inline CNode* cSYSTASK_CALL( CObstack* heap, CSymbol* a0, CNode* a1, Coord_t* loc=NULL )
3529 {
3530  CNode* n = new(heap) CNode( loc, eSYSTASK_CALL );
3531  n->Arg<CSymbol*>(0) = a0;
3532  n->Arg<CNode*>(1) = a1;
3533  return n;
3534 }
3544 inline CNode* cTIMING_CALL( CSymbol* a0, CNode* a1, Coord_t* loc=NULL )
3545 {
3546  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eTIMING_CALL );
3547  n->Arg<CSymbol*>(0) = a0;
3548  n->Arg<CNode*>(1) = a1;
3549  return n;
3550 }
3561 inline CNode* cTIMING_CALL( CObstack* heap, CSymbol* a0, CNode* a1, Coord_t* loc=NULL )
3562 {
3563  CNode* n = new(heap) CNode( loc, eTIMING_CALL );
3564  n->Arg<CSymbol*>(0) = a0;
3565  n->Arg<CNode*>(1) = a1;
3566  return n;
3567 }
3578 inline CNode* cFUNCTION_CALL( CSymbol* a0, CNode* a1, CScope* a2, Coord_t* loc=NULL )
3579 {
3580  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eFUNCTION_CALL );
3581  n->Arg<CSymbol*>(0) = a0;
3582  n->Arg<CNode*>(1) = a1;
3583  n->Arg<CScope*>(2) = a2;
3584  return n;
3585 }
3597 inline CNode* cFUNCTION_CALL( CObstack* heap, CSymbol* a0, CNode* a1, CScope* a2, Coord_t* loc=NULL )
3598 {
3599  CNode* n = new(heap) CNode( loc, eFUNCTION_CALL );
3600  n->Arg<CSymbol*>(0) = a0;
3601  n->Arg<CNode*>(1) = a1;
3602  n->Arg<CScope*>(2) = a2;
3603  return n;
3604 }
3614 inline CNode* cARRAY( CNode* a0, CNode* a1, Coord_t* loc=NULL )
3615 {
3616  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eARRAY );
3617  n->Arg<CNode*>(0) = a0;
3618  n->Arg<CNode*>(1) = a1;
3619  return n;
3620 }
3631 inline CNode* cARRAY( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
3632 {
3633  CNode* n = new(heap) CNode( loc, eARRAY );
3634  n->Arg<CNode*>(0) = a0;
3635  n->Arg<CNode*>(1) = a1;
3636  return n;
3637 }
3646 inline CNode* cNET_REF( CNet* a0, Coord_t* loc=NULL )
3647 {
3648  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eNET_REF );
3649  n->Arg<CNet*>(0) = a0;
3650  return n;
3651 }
3661 inline CNode* cNET_REF( CObstack* heap, CNet* a0, Coord_t* loc=NULL )
3662 {
3663  CNode* n = new(heap) CNode( loc, eNET_REF );
3664  n->Arg<CNet*>(0) = a0;
3665  return n;
3666 }
3675 inline CNode* cVAR_REF( CVar* a0, Coord_t* loc=NULL )
3676 {
3677  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eVAR_REF );
3678  n->Arg<CVar*>(0) = a0;
3679  return n;
3680 }
3690 inline CNode* cVAR_REF( CObstack* heap, CVar* a0, Coord_t* loc=NULL )
3691 {
3692  CNode* n = new(heap) CNode( loc, eVAR_REF );
3693  n->Arg<CVar*>(0) = a0;
3694  return n;
3695 }
3704 inline CNode* cPARAM_REF( CParam* a0, Coord_t* loc=NULL )
3705 {
3706  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePARAM_REF );
3707  n->Arg<CParam*>(0) = a0;
3708  return n;
3709 }
3719 inline CNode* cPARAM_REF( CObstack* heap, CParam* a0, Coord_t* loc=NULL )
3720 {
3721  CNode* n = new(heap) CNode( loc, ePARAM_REF );
3722  n->Arg<CParam*>(0) = a0;
3723  return n;
3724 }
3733 inline CNode* cPORT_REF( CPortDir* a0, Coord_t* loc=NULL )
3734 {
3735  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePORT_REF );
3736  n->Arg<CPortDir*>(0) = a0;
3737  return n;
3738 }
3748 inline CNode* cPORT_REF( CObstack* heap, CPortDir* a0, Coord_t* loc=NULL )
3749 {
3750  CNode* n = new(heap) CNode( loc, ePORT_REF );
3751  n->Arg<CPortDir*>(0) = a0;
3752  return n;
3753 }
3762 inline CNode* cFWD_REF( CFref* a0, Coord_t* loc=NULL )
3763 {
3764  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eFWD_REF );
3765  n->Arg<CFref*>(0) = a0;
3766  return n;
3767 }
3777 inline CNode* cFWD_REF( CObstack* heap, CFref* a0, Coord_t* loc=NULL )
3778 {
3779  CNode* n = new(heap) CNode( loc, eFWD_REF );
3780  n->Arg<CFref*>(0) = a0;
3781  return n;
3782 }
3791 inline CNode* cGENVAR_REF( CGenvar* a0, Coord_t* loc=NULL )
3792 {
3793  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eGENVAR_REF );
3794  n->Arg<CGenvar*>(0) = a0;
3795  return n;
3796 }
3806 inline CNode* cGENVAR_REF( CObstack* heap, CGenvar* a0, Coord_t* loc=NULL )
3807 {
3808  CNode* n = new(heap) CNode( loc, eGENVAR_REF );
3809  n->Arg<CGenvar*>(0) = a0;
3810  return n;
3811 }
3820 inline CNode* cENUM_REF( CEnum* a0, Coord_t* loc=NULL )
3821 {
3822  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eENUM_REF );
3823  n->Arg<CEnum*>(0) = a0;
3824  return n;
3825 }
3835 inline CNode* cENUM_REF( CObstack* heap, CEnum* a0, Coord_t* loc=NULL )
3836 {
3837  CNode* n = new(heap) CNode( loc, eENUM_REF );
3838  n->Arg<CEnum*>(0) = a0;
3839  return n;
3840 }
3849 inline CNode* cTYPE_REF( CTypedef* a0, Coord_t* loc=NULL )
3850 {
3851  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eTYPE_REF );
3852  n->Arg<CTypedef*>(0) = a0;
3853  return n;
3854 }
3864 inline CNode* cTYPE_REF( CObstack* heap, CTypedef* a0, Coord_t* loc=NULL )
3865 {
3866  CNode* n = new(heap) CNode( loc, eTYPE_REF );
3867  n->Arg<CTypedef*>(0) = a0;
3868  return n;
3869 }
3879 inline CNode* cNET_DECL( CNet* a0, CNode* a1, Coord_t* loc=NULL )
3880 {
3881  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eNET_DECL );
3882  n->Arg<CNet*>(0) = a0;
3883  n->Arg<CNode*>(1) = a1;
3884  return n;
3885 }
3896 inline CNode* cNET_DECL( CObstack* heap, CNet* a0, CNode* a1, Coord_t* loc=NULL )
3897 {
3898  CNode* n = new(heap) CNode( loc, eNET_DECL );
3899  n->Arg<CNet*>(0) = a0;
3900  n->Arg<CNode*>(1) = a1;
3901  return n;
3902 }
3912 inline CNode* cVAR_DECL( CVar* a0, CNode* a1, Coord_t* loc=NULL )
3913 {
3914  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eVAR_DECL );
3915  n->Arg<CVar*>(0) = a0;
3916  n->Arg<CNode*>(1) = a1;
3917  return n;
3918 }
3929 inline CNode* cVAR_DECL( CObstack* heap, CVar* a0, CNode* a1, Coord_t* loc=NULL )
3930 {
3931  CNode* n = new(heap) CNode( loc, eVAR_DECL );
3932  n->Arg<CVar*>(0) = a0;
3933  n->Arg<CNode*>(1) = a1;
3934  return n;
3935 }
3944 inline CNode* cPARAM_DECL( CParam* a0, Coord_t* loc=NULL )
3945 {
3946  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePARAM_DECL );
3947  n->Arg<CParam*>(0) = a0;
3948  return n;
3949 }
3959 inline CNode* cPARAM_DECL( CObstack* heap, CParam* a0, Coord_t* loc=NULL )
3960 {
3961  CNode* n = new(heap) CNode( loc, ePARAM_DECL );
3962  n->Arg<CParam*>(0) = a0;
3963  return n;
3964 }
3973 inline CNode* cSPECPARAM_DECL( CParam* a0, Coord_t* loc=NULL )
3974 {
3975  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eSPECPARAM_DECL );
3976  n->Arg<CParam*>(0) = a0;
3977  return n;
3978 }
3988 inline CNode* cSPECPARAM_DECL( CObstack* heap, CParam* a0, Coord_t* loc=NULL )
3989 {
3990  CNode* n = new(heap) CNode( loc, eSPECPARAM_DECL );
3991  n->Arg<CParam*>(0) = a0;
3992  return n;
3993 }
4002 inline CNode* cPORT_DECL( CPortDir* a0, Coord_t* loc=NULL )
4003 {
4004  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePORT_DECL );
4005  n->Arg<CPortDir*>(0) = a0;
4006  return n;
4007 }
4017 inline CNode* cPORT_DECL( CObstack* heap, CPortDir* a0, Coord_t* loc=NULL )
4018 {
4019  CNode* n = new(heap) CNode( loc, ePORT_DECL );
4020  n->Arg<CPortDir*>(0) = a0;
4021  return n;
4022 }
4031 inline CNode* cGENVAR_DECL( CGenvar* a0, Coord_t* loc=NULL )
4032 {
4033  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eGENVAR_DECL );
4034  n->Arg<CGenvar*>(0) = a0;
4035  return n;
4036 }
4046 inline CNode* cGENVAR_DECL( CObstack* heap, CGenvar* a0, Coord_t* loc=NULL )
4047 {
4048  CNode* n = new(heap) CNode( loc, eGENVAR_DECL );
4049  n->Arg<CGenvar*>(0) = a0;
4050  return n;
4051 }
4060 inline CNode* cTYPEDEF_DECL( CTypedef* a0, Coord_t* loc=NULL )
4061 {
4062  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eTYPEDEF_DECL );
4063  n->Arg<CTypedef*>(0) = a0;
4064  return n;
4065 }
4075 inline CNode* cTYPEDEF_DECL( CObstack* heap, CTypedef* a0, Coord_t* loc=NULL )
4076 {
4077  CNode* n = new(heap) CNode( loc, eTYPEDEF_DECL );
4078  n->Arg<CTypedef*>(0) = a0;
4079  return n;
4080 }
4090 inline CNode* cLIST( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4091 {
4092  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eLIST );
4093  n->Arg<CNode*>(0) = a0;
4094  n->Arg<CNode*>(1) = a1;
4095  return n;
4096 }
4107 inline CNode* cLIST( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4108 {
4109  CNode* n = new(heap) CNode( loc, eLIST );
4110  n->Arg<CNode*>(0) = a0;
4111  n->Arg<CNode*>(1) = a1;
4112  return n;
4113 }
4123 inline CNode* cRANGE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4124 {
4125  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRANGE );
4126  n->Arg<CNode*>(0) = a0;
4127  n->Arg<CNode*>(1) = a1;
4128  return n;
4129 }
4140 inline CNode* cRANGE( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4141 {
4142  CNode* n = new(heap) CNode( loc, eRANGE );
4143  n->Arg<CNode*>(0) = a0;
4144  n->Arg<CNode*>(1) = a1;
4145  return n;
4146 }
4156 inline CNode* cSLICE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4157 {
4158  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eSLICE );
4159  n->Arg<CNode*>(0) = a0;
4160  n->Arg<CNode*>(1) = a1;
4161  return n;
4162 }
4173 inline CNode* cSLICE( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4174 {
4175  CNode* n = new(heap) CNode( loc, eSLICE );
4176  n->Arg<CNode*>(0) = a0;
4177  n->Arg<CNode*>(1) = a1;
4178  return n;
4179 }
4189 inline CNode* cPSLICE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4190 {
4191  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePSLICE );
4192  n->Arg<CNode*>(0) = a0;
4193  n->Arg<CNode*>(1) = a1;
4194  return n;
4195 }
4206 inline CNode* cPSLICE( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4207 {
4208  CNode* n = new(heap) CNode( loc, ePSLICE );
4209  n->Arg<CNode*>(0) = a0;
4210  n->Arg<CNode*>(1) = a1;
4211  return n;
4212 }
4222 inline CNode* cMSLICE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4223 {
4224  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eMSLICE );
4225  n->Arg<CNode*>(0) = a0;
4226  n->Arg<CNode*>(1) = a1;
4227  return n;
4228 }
4239 inline CNode* cMSLICE( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4240 {
4241  CNode* n = new(heap) CNode( loc, eMSLICE );
4242  n->Arg<CNode*>(0) = a0;
4243  n->Arg<CNode*>(1) = a1;
4244  return n;
4245 }
4254 inline CNode* cCVRI( CNode* a0, Coord_t* loc=NULL )
4255 {
4256  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCVRI );
4257  n->Arg<CNode*>(0) = a0;
4258  return n;
4259 }
4269 inline CNode* cCVRI( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
4270 {
4271  CNode* n = new(heap) CNode( loc, eCVRI );
4272  n->Arg<CNode*>(0) = a0;
4273  return n;
4274 }
4283 inline CNode* cCVIR( CNode* a0, Coord_t* loc=NULL )
4284 {
4285  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCVIR );
4286  n->Arg<CNode*>(0) = a0;
4287  return n;
4288 }
4298 inline CNode* cCVIR( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
4299 {
4300  CNode* n = new(heap) CNode( loc, eCVIR );
4301  n->Arg<CNode*>(0) = a0;
4302  return n;
4303 }
4313 inline CNode* cREP( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4314 {
4315  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eREP );
4316  n->Arg<CNode*>(0) = a0;
4317  n->Arg<CNode*>(1) = a1;
4318  return n;
4319 }
4330 inline CNode* cREP( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4331 {
4332  CNode* n = new(heap) CNode( loc, eREP );
4333  n->Arg<CNode*>(0) = a0;
4334  n->Arg<CNode*>(1) = a1;
4335  return n;
4336 }
4346 inline CNode* cCAT( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4347 {
4348  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCAT );
4349  n->Arg<CNode*>(0) = a0;
4350  n->Arg<CNode*>(1) = a1;
4351  return n;
4352 }
4363 inline CNode* cCAT( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4364 {
4365  CNode* n = new(heap) CNode( loc, eCAT );
4366  n->Arg<CNode*>(0) = a0;
4367  n->Arg<CNode*>(1) = a1;
4368  return n;
4369 }
4378 inline CNode* cUCAT( CNode* a0, Coord_t* loc=NULL )
4379 {
4380  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eUCAT );
4381  n->Arg<CNode*>(0) = a0;
4382  return n;
4383 }
4393 inline CNode* cUCAT( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
4394 {
4395  CNode* n = new(heap) CNode( loc, eUCAT );
4396  n->Arg<CNode*>(0) = a0;
4397  return n;
4398 }
4407 inline CNode* cCOM( CNode* a0, Coord_t* loc=NULL )
4408 {
4409  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCOM );
4410  n->Arg<CNode*>(0) = a0;
4411  return n;
4412 }
4422 inline CNode* cCOM( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
4423 {
4424  CNode* n = new(heap) CNode( loc, eCOM );
4425  n->Arg<CNode*>(0) = a0;
4426  return n;
4427 }
4436 inline CNode* cNEG( CNode* a0, Coord_t* loc=NULL )
4437 {
4438  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eNEG );
4439  n->Arg<CNode*>(0) = a0;
4440  return n;
4441 }
4451 inline CNode* cNEG( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
4452 {
4453  CNode* n = new(heap) CNode( loc, eNEG );
4454  n->Arg<CNode*>(0) = a0;
4455  return n;
4456 }
4465 inline CNode* cPLUS( CNode* a0, Coord_t* loc=NULL )
4466 {
4467  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePLUS );
4468  n->Arg<CNode*>(0) = a0;
4469  return n;
4470 }
4480 inline CNode* cPLUS( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
4481 {
4482  CNode* n = new(heap) CNode( loc, ePLUS );
4483  n->Arg<CNode*>(0) = a0;
4484  return n;
4485 }
4494 inline CNode* cNOT( CNode* a0, Coord_t* loc=NULL )
4495 {
4496  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eNOT );
4497  n->Arg<CNode*>(0) = a0;
4498  return n;
4499 }
4509 inline CNode* cNOT( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
4510 {
4511  CNode* n = new(heap) CNode( loc, eNOT );
4512  n->Arg<CNode*>(0) = a0;
4513  return n;
4514 }
4524 inline CNode* cGT( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4525 {
4526  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eGT );
4527  n->Arg<CNode*>(0) = a0;
4528  n->Arg<CNode*>(1) = a1;
4529  return n;
4530 }
4541 inline CNode* cGT( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4542 {
4543  CNode* n = new(heap) CNode( loc, eGT );
4544  n->Arg<CNode*>(0) = a0;
4545  n->Arg<CNode*>(1) = a1;
4546  return n;
4547 }
4557 inline CNode* cGE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4558 {
4559  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eGE );
4560  n->Arg<CNode*>(0) = a0;
4561  n->Arg<CNode*>(1) = a1;
4562  return n;
4563 }
4574 inline CNode* cGE( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4575 {
4576  CNode* n = new(heap) CNode( loc, eGE );
4577  n->Arg<CNode*>(0) = a0;
4578  n->Arg<CNode*>(1) = a1;
4579  return n;
4580 }
4590 inline CNode* cLT( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4591 {
4592  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eLT );
4593  n->Arg<CNode*>(0) = a0;
4594  n->Arg<CNode*>(1) = a1;
4595  return n;
4596 }
4607 inline CNode* cLT( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4608 {
4609  CNode* n = new(heap) CNode( loc, eLT );
4610  n->Arg<CNode*>(0) = a0;
4611  n->Arg<CNode*>(1) = a1;
4612  return n;
4613 }
4623 inline CNode* cLE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4624 {
4625  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eLE );
4626  n->Arg<CNode*>(0) = a0;
4627  n->Arg<CNode*>(1) = a1;
4628  return n;
4629 }
4640 inline CNode* cLE( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4641 {
4642  CNode* n = new(heap) CNode( loc, eLE );
4643  n->Arg<CNode*>(0) = a0;
4644  n->Arg<CNode*>(1) = a1;
4645  return n;
4646 }
4656 inline CNode* cLAND( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4657 {
4658  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eLAND );
4659  n->Arg<CNode*>(0) = a0;
4660  n->Arg<CNode*>(1) = a1;
4661  return n;
4662 }
4673 inline CNode* cLAND( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4674 {
4675  CNode* n = new(heap) CNode( loc, eLAND );
4676  n->Arg<CNode*>(0) = a0;
4677  n->Arg<CNode*>(1) = a1;
4678  return n;
4679 }
4689 inline CNode* cLOR( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4690 {
4691  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eLOR );
4692  n->Arg<CNode*>(0) = a0;
4693  n->Arg<CNode*>(1) = a1;
4694  return n;
4695 }
4706 inline CNode* cLOR( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4707 {
4708  CNode* n = new(heap) CNode( loc, eLOR );
4709  n->Arg<CNode*>(0) = a0;
4710  n->Arg<CNode*>(1) = a1;
4711  return n;
4712 }
4722 inline CNode* cCEQ( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4723 {
4724  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCEQ );
4725  n->Arg<CNode*>(0) = a0;
4726  n->Arg<CNode*>(1) = a1;
4727  return n;
4728 }
4739 inline CNode* cCEQ( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4740 {
4741  CNode* n = new(heap) CNode( loc, eCEQ );
4742  n->Arg<CNode*>(0) = a0;
4743  n->Arg<CNode*>(1) = a1;
4744  return n;
4745 }
4755 inline CNode* cCNE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4756 {
4757  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCNE );
4758  n->Arg<CNode*>(0) = a0;
4759  n->Arg<CNode*>(1) = a1;
4760  return n;
4761 }
4772 inline CNode* cCNE( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4773 {
4774  CNode* n = new(heap) CNode( loc, eCNE );
4775  n->Arg<CNode*>(0) = a0;
4776  n->Arg<CNode*>(1) = a1;
4777  return n;
4778 }
4788 inline CNode* cEQ( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4789 {
4790  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eEQ );
4791  n->Arg<CNode*>(0) = a0;
4792  n->Arg<CNode*>(1) = a1;
4793  return n;
4794 }
4805 inline CNode* cEQ( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4806 {
4807  CNode* n = new(heap) CNode( loc, eEQ );
4808  n->Arg<CNode*>(0) = a0;
4809  n->Arg<CNode*>(1) = a1;
4810  return n;
4811 }
4821 inline CNode* cNE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4822 {
4823  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eNE );
4824  n->Arg<CNode*>(0) = a0;
4825  n->Arg<CNode*>(1) = a1;
4826  return n;
4827 }
4838 inline CNode* cNE( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4839 {
4840  CNode* n = new(heap) CNode( loc, eNE );
4841  n->Arg<CNode*>(0) = a0;
4842  n->Arg<CNode*>(1) = a1;
4843  return n;
4844 }
4853 inline CNode* cRAND( CNode* a0, Coord_t* loc=NULL )
4854 {
4855  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRAND );
4856  n->Arg<CNode*>(0) = a0;
4857  return n;
4858 }
4868 inline CNode* cRAND( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
4869 {
4870  CNode* n = new(heap) CNode( loc, eRAND );
4871  n->Arg<CNode*>(0) = a0;
4872  return n;
4873 }
4882 inline CNode* cRNAND( CNode* a0, Coord_t* loc=NULL )
4883 {
4884  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRNAND );
4885  n->Arg<CNode*>(0) = a0;
4886  return n;
4887 }
4897 inline CNode* cRNAND( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
4898 {
4899  CNode* n = new(heap) CNode( loc, eRNAND );
4900  n->Arg<CNode*>(0) = a0;
4901  return n;
4902 }
4911 inline CNode* cROR( CNode* a0, Coord_t* loc=NULL )
4912 {
4913  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eROR );
4914  n->Arg<CNode*>(0) = a0;
4915  return n;
4916 }
4926 inline CNode* cROR( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
4927 {
4928  CNode* n = new(heap) CNode( loc, eROR );
4929  n->Arg<CNode*>(0) = a0;
4930  return n;
4931 }
4940 inline CNode* cRNOR( CNode* a0, Coord_t* loc=NULL )
4941 {
4942  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRNOR );
4943  n->Arg<CNode*>(0) = a0;
4944  return n;
4945 }
4955 inline CNode* cRNOR( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
4956 {
4957  CNode* n = new(heap) CNode( loc, eRNOR );
4958  n->Arg<CNode*>(0) = a0;
4959  return n;
4960 }
4969 inline CNode* cRXOR( CNode* a0, Coord_t* loc=NULL )
4970 {
4971  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRXOR );
4972  n->Arg<CNode*>(0) = a0;
4973  return n;
4974 }
4984 inline CNode* cRXOR( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
4985 {
4986  CNode* n = new(heap) CNode( loc, eRXOR );
4987  n->Arg<CNode*>(0) = a0;
4988  return n;
4989 }
4998 inline CNode* cRXNOR( CNode* a0, Coord_t* loc=NULL )
4999 {
5000  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRXNOR );
5001  n->Arg<CNode*>(0) = a0;
5002  return n;
5003 }
5013 inline CNode* cRXNOR( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
5014 {
5015  CNode* n = new(heap) CNode( loc, eRXNOR );
5016  n->Arg<CNode*>(0) = a0;
5017  return n;
5018 }
5029 inline CNode* cHOOK( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5030 {
5031  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eHOOK );
5032  n->Arg<CNode*>(0) = a0;
5033  n->Arg<CNode*>(1) = a1;
5034  n->Arg<CNode*>(2) = a2;
5035  return n;
5036 }
5048 inline CNode* cHOOK( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5049 {
5050  CNode* n = new(heap) CNode( loc, eHOOK );
5051  n->Arg<CNode*>(0) = a0;
5052  n->Arg<CNode*>(1) = a1;
5053  n->Arg<CNode*>(2) = a2;
5054  return n;
5055 }
5064 inline CNode* cINIT( CNode* a0, Coord_t* loc=NULL )
5065 {
5066  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eINIT );
5067  n->Arg<CNode*>(0) = a0;
5068  return n;
5069 }
5079 inline CNode* cINIT( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
5080 {
5081  CNode* n = new(heap) CNode( loc, eINIT );
5082  n->Arg<CNode*>(0) = a0;
5083  return n;
5084 }
5093 inline CNode* cALWAYS( CNode* a0, Coord_t* loc=NULL )
5094 {
5095  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eALWAYS );
5096  n->Arg<CNode*>(0) = a0;
5097  return n;
5098 }
5108 inline CNode* cALWAYS( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
5109 {
5110  CNode* n = new(heap) CNode( loc, eALWAYS );
5111  n->Arg<CNode*>(0) = a0;
5112  return n;
5113 }
5122 inline CNode* cALWAYS_LATCH( CNode* a0, Coord_t* loc=NULL )
5123 {
5124  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eALWAYS_LATCH );
5125  n->Arg<CNode*>(0) = a0;
5126  return n;
5127 }
5137 inline CNode* cALWAYS_LATCH( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
5138 {
5139  CNode* n = new(heap) CNode( loc, eALWAYS_LATCH );
5140  n->Arg<CNode*>(0) = a0;
5141  return n;
5142 }
5151 inline CNode* cALWAYS_FF( CNode* a0, Coord_t* loc=NULL )
5152 {
5153  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eALWAYS_FF );
5154  n->Arg<CNode*>(0) = a0;
5155  return n;
5156 }
5166 inline CNode* cALWAYS_FF( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
5167 {
5168  CNode* n = new(heap) CNode( loc, eALWAYS_FF );
5169  n->Arg<CNode*>(0) = a0;
5170  return n;
5171 }
5180 inline CNode* cALWAYS_COMB( CNode* a0, Coord_t* loc=NULL )
5181 {
5182  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eALWAYS_COMB );
5183  n->Arg<CNode*>(0) = a0;
5184  return n;
5185 }
5195 inline CNode* cALWAYS_COMB( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
5196 {
5197  CNode* n = new(heap) CNode( loc, eALWAYS_COMB );
5198  n->Arg<CNode*>(0) = a0;
5199  return n;
5200 }
5210 inline CNode* cEVENT( CNode* a0, CNode* a1, Coord_t* loc=NULL )
5211 {
5212  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eEVENT );
5213  n->Arg<CNode*>(0) = a0;
5214  n->Arg<CNode*>(1) = a1;
5215  return n;
5216 }
5227 inline CNode* cEVENT( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
5228 {
5229  CNode* n = new(heap) CNode( loc, eEVENT );
5230  n->Arg<CNode*>(0) = a0;
5231  n->Arg<CNode*>(1) = a1;
5232  return n;
5233 }
5244 inline CNode* cBLOCK_REF( CBlock* a0, CNode* a1, bool a2, Coord_t* loc=NULL )
5245 {
5246  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eBLOCK_REF );
5247  n->Arg<CBlock*>(0) = a0;
5248  n->Arg<CNode*>(1) = a1;
5249  n->Arg<bool>(2) = a2;
5250  return n;
5251 }
5263 inline CNode* cBLOCK_REF( CObstack* heap, CBlock* a0, CNode* a1, bool a2, Coord_t* loc=NULL )
5264 {
5265  CNode* n = new(heap) CNode( loc, eBLOCK_REF );
5266  n->Arg<CBlock*>(0) = a0;
5267  n->Arg<CNode*>(1) = a1;
5268  n->Arg<bool>(2) = a2;
5269  return n;
5270 }
5280 inline CNode* cSPECIFY_REF( CSpecify* a0, CNode* a1, Coord_t* loc=NULL )
5281 {
5282  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eSPECIFY_REF );
5283  n->Arg<CSpecify*>(0) = a0;
5284  n->Arg<CNode*>(1) = a1;
5285  return n;
5286 }
5297 inline CNode* cSPECIFY_REF( CObstack* heap, CSpecify* a0, CNode* a1, Coord_t* loc=NULL )
5298 {
5299  CNode* n = new(heap) CNode( loc, eSPECIFY_REF );
5300  n->Arg<CSpecify*>(0) = a0;
5301  n->Arg<CNode*>(1) = a1;
5302  return n;
5303 }
5314 inline CNode* cASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5315 {
5316  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eASSIGN );
5317  n->Arg<CNode*>(0) = a0;
5318  n->Arg<CNode*>(1) = a1;
5319  n->Arg<CNode*>(2) = a2;
5320  return n;
5321 }
5333 inline CNode* cASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5334 {
5335  CNode* n = new(heap) CNode( loc, eASSIGN );
5336  n->Arg<CNode*>(0) = a0;
5337  n->Arg<CNode*>(1) = a1;
5338  n->Arg<CNode*>(2) = a2;
5339  return n;
5340 }
5351 inline CNode* cGASSIGN( bool a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5352 {
5353  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eGASSIGN );
5354  n->Arg<bool>(0) = a0;
5355  n->Arg<CNode*>(1) = a1;
5356  n->Arg<CNode*>(2) = a2;
5357  return n;
5358 }
5370 inline CNode* cGASSIGN( CObstack* heap, bool a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5371 {
5372  CNode* n = new(heap) CNode( loc, eGASSIGN );
5373  n->Arg<bool>(0) = a0;
5374  n->Arg<CNode*>(1) = a1;
5375  n->Arg<CNode*>(2) = a2;
5376  return n;
5377 }
5388 inline CNode* cADD_ASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5389 {
5390  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eADD_ASSIGN );
5391  n->Arg<CNode*>(0) = a0;
5392  n->Arg<CNode*>(1) = a1;
5393  n->Arg<CNode*>(2) = a2;
5394  return n;
5395 }
5407 inline CNode* cADD_ASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5408 {
5409  CNode* n = new(heap) CNode( loc, eADD_ASSIGN );
5410  n->Arg<CNode*>(0) = a0;
5411  n->Arg<CNode*>(1) = a1;
5412  n->Arg<CNode*>(2) = a2;
5413  return n;
5414 }
5425 inline CNode* cSUB_ASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5426 {
5427  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eSUB_ASSIGN );
5428  n->Arg<CNode*>(0) = a0;
5429  n->Arg<CNode*>(1) = a1;
5430  n->Arg<CNode*>(2) = a2;
5431  return n;
5432 }
5444 inline CNode* cSUB_ASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5445 {
5446  CNode* n = new(heap) CNode( loc, eSUB_ASSIGN );
5447  n->Arg<CNode*>(0) = a0;
5448  n->Arg<CNode*>(1) = a1;
5449  n->Arg<CNode*>(2) = a2;
5450  return n;
5451 }
5462 inline CNode* cMUL_ASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5463 {
5464  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eMUL_ASSIGN );
5465  n->Arg<CNode*>(0) = a0;
5466  n->Arg<CNode*>(1) = a1;
5467  n->Arg<CNode*>(2) = a2;
5468  return n;
5469 }
5481 inline CNode* cMUL_ASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5482 {
5483  CNode* n = new(heap) CNode( loc, eMUL_ASSIGN );
5484  n->Arg<CNode*>(0) = a0;
5485  n->Arg<CNode*>(1) = a1;
5486  n->Arg<CNode*>(2) = a2;
5487  return n;
5488 }
5499 inline CNode* cDIV_ASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5500 {
5501  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eDIV_ASSIGN );
5502  n->Arg<CNode*>(0) = a0;
5503  n->Arg<CNode*>(1) = a1;
5504  n->Arg<CNode*>(2) = a2;
5505  return n;
5506 }
5518 inline CNode* cDIV_ASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5519 {
5520  CNode* n = new(heap) CNode( loc, eDIV_ASSIGN );
5521  n->Arg<CNode*>(0) = a0;
5522  n->Arg<CNode*>(1) = a1;
5523  n->Arg<CNode*>(2) = a2;
5524  return n;
5525 }
5536 inline CNode* cMOD_ASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5537 {
5538  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eMOD_ASSIGN );
5539  n->Arg<CNode*>(0) = a0;
5540  n->Arg<CNode*>(1) = a1;
5541  n->Arg<CNode*>(2) = a2;
5542  return n;
5543 }
5555 inline CNode* cMOD_ASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5556 {
5557  CNode* n = new(heap) CNode( loc, eMOD_ASSIGN );
5558  n->Arg<CNode*>(0) = a0;
5559  n->Arg<CNode*>(1) = a1;
5560  n->Arg<CNode*>(2) = a2;
5561  return n;
5562 }
5573 inline CNode* cAND_ASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5574 {
5575  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eAND_ASSIGN );
5576  n->Arg<CNode*>(0) = a0;
5577  n->Arg<CNode*>(1) = a1;
5578  n->Arg<CNode*>(2) = a2;
5579  return n;
5580 }
5592 inline CNode* cAND_ASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5593 {
5594  CNode* n = new(heap) CNode( loc, eAND_ASSIGN );
5595  n->Arg<CNode*>(0) = a0;
5596  n->Arg<CNode*>(1) = a1;
5597  n->Arg<CNode*>(2) = a2;
5598  return n;
5599 }
5610 inline CNode* cOR_ASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5611 {
5612  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eOR_ASSIGN );
5613  n->Arg<CNode*>(0) = a0;
5614  n->Arg<CNode*>(1) = a1;
5615  n->Arg<CNode*>(2) = a2;
5616  return n;
5617 }
5629 inline CNode* cOR_ASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5630 {
5631  CNode* n = new(heap) CNode( loc, eOR_ASSIGN );
5632  n->Arg<CNode*>(0) = a0;
5633  n->Arg<CNode*>(1) = a1;
5634  n->Arg<CNode*>(2) = a2;
5635  return n;
5636 }
5647 inline CNode* cXOR_ASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5648 {
5649  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eXOR_ASSIGN );
5650  n->Arg<CNode*>(0) = a0;
5651  n->Arg<CNode*>(1) = a1;
5652  n->Arg<CNode*>(2) = a2;
5653  return n;
5654 }
5666 inline CNode* cXOR_ASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5667 {
5668  CNode* n = new(heap) CNode( loc, eXOR_ASSIGN );
5669  n->Arg<CNode*>(0) = a0;
5670  n->Arg<CNode*>(1) = a1;
5671  n->Arg<CNode*>(2) = a2;
5672  return n;
5673 }
5684 inline CNode* cLSH_ASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5685 {
5686  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eLSH_ASSIGN );
5687  n->Arg<CNode*>(0) = a0;
5688  n->Arg<CNode*>(1) = a1;
5689  n->Arg<CNode*>(2) = a2;
5690  return n;
5691 }
5703 inline CNode* cLSH_ASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5704 {
5705  CNode* n = new(heap) CNode( loc, eLSH_ASSIGN );
5706  n->Arg<CNode*>(0) = a0;
5707  n->Arg<CNode*>(1) = a1;
5708  n->Arg<CNode*>(2) = a2;
5709  return n;
5710 }
5721 inline CNode* cRSH_ASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5722 {
5723  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRSH_ASSIGN );
5724  n->Arg<CNode*>(0) = a0;
5725  n->Arg<CNode*>(1) = a1;
5726  n->Arg<CNode*>(2) = a2;
5727  return n;
5728 }
5740 inline CNode* cRSH_ASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5741 {
5742  CNode* n = new(heap) CNode( loc, eRSH_ASSIGN );
5743  n->Arg<CNode*>(0) = a0;
5744  n->Arg<CNode*>(1) = a1;
5745  n->Arg<CNode*>(2) = a2;
5746  return n;
5747 }
5758 inline CNode* cLSHA_ASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5759 {
5760  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eLSHA_ASSIGN );
5761  n->Arg<CNode*>(0) = a0;
5762  n->Arg<CNode*>(1) = a1;
5763  n->Arg<CNode*>(2) = a2;
5764  return n;
5765 }
5777 inline CNode* cLSHA_ASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5778 {
5779  CNode* n = new(heap) CNode( loc, eLSHA_ASSIGN );
5780  n->Arg<CNode*>(0) = a0;
5781  n->Arg<CNode*>(1) = a1;
5782  n->Arg<CNode*>(2) = a2;
5783  return n;
5784 }
5795 inline CNode* cRSHA_ASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5796 {
5797  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRSHA_ASSIGN );
5798  n->Arg<CNode*>(0) = a0;
5799  n->Arg<CNode*>(1) = a1;
5800  n->Arg<CNode*>(2) = a2;
5801  return n;
5802 }
5814 inline CNode* cRSHA_ASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5815 {
5816  CNode* n = new(heap) CNode( loc, eRSHA_ASSIGN );
5817  n->Arg<CNode*>(0) = a0;
5818  n->Arg<CNode*>(1) = a1;
5819  n->Arg<CNode*>(2) = a2;
5820  return n;
5821 }
5831 inline CNode* cFORCE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
5832 {
5833  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eFORCE );
5834  n->Arg<CNode*>(0) = a0;
5835  n->Arg<CNode*>(1) = a1;
5836  return n;
5837 }
5848 inline CNode* cFORCE( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
5849 {
5850  CNode* n = new(heap) CNode( loc, eFORCE );
5851  n->Arg<CNode*>(0) = a0;
5852  n->Arg<CNode*>(1) = a1;
5853  return n;
5854 }
5863 inline CNode* cRELEASE( CNode* a0, Coord_t* loc=NULL )
5864 {
5865  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRELEASE );
5866  n->Arg<CNode*>(0) = a0;
5867  return n;
5868 }
5878 inline CNode* cRELEASE( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
5879 {
5880  CNode* n = new(heap) CNode( loc, eRELEASE );
5881  n->Arg<CNode*>(0) = a0;
5882  return n;
5883 }
5894 inline CNode* cNBASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5895 {
5896  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eNBASSIGN );
5897  n->Arg<CNode*>(0) = a0;
5898  n->Arg<CNode*>(1) = a1;
5899  n->Arg<CNode*>(2) = a2;
5900  return n;
5901 }
5913 inline CNode* cNBASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5914 {
5915  CNode* n = new(heap) CNode( loc, eNBASSIGN );
5916  n->Arg<CNode*>(0) = a0;
5917  n->Arg<CNode*>(1) = a1;
5918  n->Arg<CNode*>(2) = a2;
5919  return n;
5920 }
5929 inline CNode* cPOSEDGE( CNode* a0, Coord_t* loc=NULL )
5930 {
5931  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePOSEDGE );
5932  n->Arg<CNode*>(0) = a0;
5933  return n;
5934 }
5944 inline CNode* cPOSEDGE( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
5945 {
5946  CNode* n = new(heap) CNode( loc, ePOSEDGE );
5947  n->Arg<CNode*>(0) = a0;
5948  return n;
5949 }
5958 inline CNode* cNEGEDGE( CNode* a0, Coord_t* loc=NULL )
5959 {
5960  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eNEGEDGE );
5961  n->Arg<CNode*>(0) = a0;
5962  return n;
5963 }
5973 inline CNode* cNEGEDGE( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
5974 {
5975  CNode* n = new(heap) CNode( loc, eNEGEDGE );
5976  n->Arg<CNode*>(0) = a0;
5977  return n;
5978 }
5988 inline CNode* cEDGE( CNode* a0, Edge_t a1, Coord_t* loc=NULL )
5989 {
5990  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eEDGE );
5991  n->Arg<CNode*>(0) = a0;
5992  n->Arg<Edge_t>(1) = a1;
5993  return n;
5994 }
6005 inline CNode* cEDGE( CObstack* heap, CNode* a0, Edge_t a1, Coord_t* loc=NULL )
6006 {
6007  CNode* n = new(heap) CNode( loc, eEDGE );
6008  n->Arg<CNode*>(0) = a0;
6009  n->Arg<Edge_t>(1) = a1;
6010  return n;
6011 }
6021 inline CNode* cEVOR( CNode* a0, CNode* a1, Coord_t* loc=NULL )
6022 {
6023  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eEVOR );
6024  n->Arg<CNode*>(0) = a0;
6025  n->Arg<CNode*>(1) = a1;
6026  return n;
6027 }
6038 inline CNode* cEVOR( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
6039 {
6040  CNode* n = new(heap) CNode( loc, eEVOR );
6041  n->Arg<CNode*>(0) = a0;
6042  n->Arg<CNode*>(1) = a1;
6043  return n;
6044 }
6054 inline CNode* cDELAY( CNode* a0, CNode* a1, Coord_t* loc=NULL )
6055 {
6056  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eDELAY );
6057  n->Arg<CNode*>(0) = a0;
6058  n->Arg<CNode*>(1) = a1;
6059  return n;
6060 }
6071 inline CNode* cDELAY( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
6072 {
6073  CNode* n = new(heap) CNode( loc, eDELAY );
6074  n->Arg<CNode*>(0) = a0;
6075  n->Arg<CNode*>(1) = a1;
6076  return n;
6077 }
6088 inline CNode* cMTM( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
6089 {
6090  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eMTM );
6091  n->Arg<CNode*>(0) = a0;
6092  n->Arg<CNode*>(1) = a1;
6093  n->Arg<CNode*>(2) = a2;
6094  return n;
6095 }
6107 inline CNode* cMTM( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
6108 {
6109  CNode* n = new(heap) CNode( loc, eMTM );
6110  n->Arg<CNode*>(0) = a0;
6111  n->Arg<CNode*>(1) = a1;
6112  n->Arg<CNode*>(2) = a2;
6113  return n;
6114 }
6126 inline CNode* cIF( CNode* a0, CNode* a1, CNode* a2, ConditionalType a3, Coord_t* loc=NULL )
6127 {
6128  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eIF );
6129  n->Arg<CNode*>(0) = a0;
6130  n->Arg<CNode*>(1) = a1;
6131  n->Arg<CNode*>(2) = a2;
6132  n->Arg<ConditionalType>(3) = a3;
6133  return n;
6134 }
6147 inline CNode* cIF( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, ConditionalType a3, Coord_t* loc=NULL )
6148 {
6149  CNode* n = new(heap) CNode( loc, eIF );
6150  n->Arg<CNode*>(0) = a0;
6151  n->Arg<CNode*>(1) = a1;
6152  n->Arg<CNode*>(2) = a2;
6153  n->Arg<ConditionalType>(3) = a3;
6154  return n;
6155 }
6164 inline CNode* cFOREVER( CNode* a0, Coord_t* loc=NULL )
6165 {
6166  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eFOREVER );
6167  n->Arg<CNode*>(0) = a0;
6168  return n;
6169 }
6179 inline CNode* cFOREVER( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
6180 {
6181  CNode* n = new(heap) CNode( loc, eFOREVER );
6182  n->Arg<CNode*>(0) = a0;
6183  return n;
6184 }
6194 inline CNode* cREPEAT( CNode* a0, CNode* a1, Coord_t* loc=NULL )
6195 {
6196  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eREPEAT );
6197  n->Arg<CNode*>(0) = a0;
6198  n->Arg<CNode*>(1) = a1;
6199  return n;
6200 }
6211 inline CNode* cREPEAT( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
6212 {
6213  CNode* n = new(heap) CNode( loc, eREPEAT );
6214  n->Arg<CNode*>(0) = a0;
6215  n->Arg<CNode*>(1) = a1;
6216  return n;
6217 }
6227 inline CNode* cWHILE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
6228 {
6229  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eWHILE );
6230  n->Arg<CNode*>(0) = a0;
6231  n->Arg<CNode*>(1) = a1;
6232  return n;
6233 }
6244 inline CNode* cWHILE( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
6245 {
6246  CNode* n = new(heap) CNode( loc, eWHILE );
6247  n->Arg<CNode*>(0) = a0;
6248  n->Arg<CNode*>(1) = a1;
6249  return n;
6250 }
6260 inline CNode* cWAIT( CNode* a0, CNode* a1, Coord_t* loc=NULL )
6261 {
6262  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eWAIT );
6263  n->Arg<CNode*>(0) = a0;
6264  n->Arg<CNode*>(1) = a1;
6265  return n;
6266 }
6277 inline CNode* cWAIT( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
6278 {
6279  CNode* n = new(heap) CNode( loc, eWAIT );
6280  n->Arg<CNode*>(0) = a0;
6281  n->Arg<CNode*>(1) = a1;
6282  return n;
6283 }
6295 inline CNode* cFOR( CNode* a0, CNode* a1, CNode* a2, CNode* a3, Coord_t* loc=NULL )
6296 {
6297  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eFOR );
6298  n->Arg<CNode*>(0) = a0;
6299  n->Arg<CNode*>(1) = a1;
6300  n->Arg<CNode*>(2) = a2;
6301  n->Arg<CNode*>(3) = a3;
6302  return n;
6303 }
6316 inline CNode* cFOR( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, CNode* a3, Coord_t* loc=NULL )
6317 {
6318  CNode* n = new(heap) CNode( loc, eFOR );
6319  n->Arg<CNode*>(0) = a0;
6320  n->Arg<CNode*>(1) = a1;
6321  n->Arg<CNode*>(2) = a2;
6322  n->Arg<CNode*>(3) = a3;
6323  return n;
6324 }
6336 inline CNode* cCASE( CNode* a0, CNode* a1, ConditionalType a2, bool a3, Coord_t* loc=NULL )
6337 {
6338  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCASE );
6339  n->Arg<CNode*>(0) = a0;
6340  n->Arg<CNode*>(1) = a1;
6341  n->Arg<ConditionalType>(2) = a2;
6342  n->Arg<bool>(3) = a3;
6343  return n;
6344 }
6357 inline CNode* cCASE( CObstack* heap, CNode* a0, CNode* a1, ConditionalType a2, bool a3, Coord_t* loc=NULL )
6358 {
6359  CNode* n = new(heap) CNode( loc, eCASE );
6360  n->Arg<CNode*>(0) = a0;
6361  n->Arg<CNode*>(1) = a1;
6362  n->Arg<ConditionalType>(2) = a2;
6363  n->Arg<bool>(3) = a3;
6364  return n;
6365 }
6376 inline CNode* cCASEX( CNode* a0, CNode* a1, ConditionalType a2, Coord_t* loc=NULL )
6377 {
6378  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCASEX );
6379  n->Arg<CNode*>(0) = a0;
6380  n->Arg<CNode*>(1) = a1;
6381  n->Arg<ConditionalType>(2) = a2;
6382  return n;
6383 }
6395 inline CNode* cCASEX( CObstack* heap, CNode* a0, CNode* a1, ConditionalType a2, Coord_t* loc=NULL )
6396 {
6397  CNode* n = new(heap) CNode( loc, eCASEX );
6398  n->Arg<CNode*>(0) = a0;
6399  n->Arg<CNode*>(1) = a1;
6400  n->Arg<ConditionalType>(2) = a2;
6401  return n;
6402 }
6413 inline CNode* cCASEZ( CNode* a0, CNode* a1, ConditionalType a2, Coord_t* loc=NULL )
6414 {
6415  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCASEZ );
6416  n->Arg<CNode*>(0) = a0;
6417  n->Arg<CNode*>(1) = a1;
6418  n->Arg<ConditionalType>(2) = a2;
6419  return n;
6420 }
6432 inline CNode* cCASEZ( CObstack* heap, CNode* a0, CNode* a1, ConditionalType a2, Coord_t* loc=NULL )
6433 {
6434  CNode* n = new(heap) CNode( loc, eCASEZ );
6435  n->Arg<CNode*>(0) = a0;
6436  n->Arg<CNode*>(1) = a1;
6437  n->Arg<ConditionalType>(2) = a2;
6438  return n;
6439 }
6449 inline CNode* cCASEITEM( CNode* a0, CNode* a1, Coord_t* loc=NULL )
6450 {
6451  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCASEITEM );
6452  n->Arg<CNode*>(0) = a0;
6453  n->Arg<CNode*>(1) = a1;
6454  return n;
6455 }
6466 inline CNode* cCASEITEM( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
6467 {
6468  CNode* n = new(heap) CNode( loc, eCASEITEM );
6469  n->Arg<CNode*>(0) = a0;
6470  n->Arg<CNode*>(1) = a1;
6471  return n;
6472 }
6484 inline CNode* cCASSIGN( StrengthPair_t* a0, CNode* a1, CNode* a2, CNode* a3, Coord_t* loc=NULL )
6485 {
6486  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCASSIGN );
6487  n->Arg<StrengthPair_t*>(0) = a0;
6488  n->Arg<CNode*>(1) = a1;
6489  n->Arg<CNode*>(2) = a2;
6490  n->Arg<CNode*>(3) = a3;
6491  return n;
6492 }
6505 inline CNode* cCASSIGN( CObstack* heap, StrengthPair_t* a0, CNode* a1, CNode* a2, CNode* a3, Coord_t* loc=NULL )
6506 {
6507  CNode* n = new(heap) CNode( loc, eCASSIGN );
6508  n->Arg<StrengthPair_t*>(0) = a0;
6509  n->Arg<CNode*>(1) = a1;
6510  n->Arg<CNode*>(2) = a2;
6511  n->Arg<CNode*>(3) = a3;
6512  return n;
6513 }
6523 inline CNode* cARG( CSymbol* a0, CNode* a1, Coord_t* loc=NULL )
6524 {
6525  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eARG );
6526  n->Arg<CSymbol*>(0) = a0;
6527  n->Arg<CNode*>(1) = a1;
6528  return n;
6529 }
6540 inline CNode* cARG( CObstack* heap, CSymbol* a0, CNode* a1, Coord_t* loc=NULL )
6541 {
6542  CNode* n = new(heap) CNode( loc, eARG );
6543  n->Arg<CSymbol*>(0) = a0;
6544  n->Arg<CNode*>(1) = a1;
6545  return n;
6546 }
6555 inline CNode* cIMPORT( CSymbol* a0, Coord_t* loc=NULL )
6556 {
6557  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eIMPORT );
6558  n->Arg<CSymbol*>(0) = a0;
6559  return n;
6560 }
6570 inline CNode* cIMPORT( CObstack* heap, CSymbol* a0, Coord_t* loc=NULL )
6571 {
6572  CNode* n = new(heap) CNode( loc, eIMPORT );
6573  n->Arg<CSymbol*>(0) = a0;
6574  return n;
6575 }
6584 inline CNode* cFUNCTION_DEF( CFunction* a0, Coord_t* loc=NULL )
6585 {
6586  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eFUNCTION_DEF );
6587  n->Arg<CFunction*>(0) = a0;
6588  return n;
6589 }
6599 inline CNode* cFUNCTION_DEF( CObstack* heap, CFunction* a0, Coord_t* loc=NULL )
6600 {
6601  CNode* n = new(heap) CNode( loc, eFUNCTION_DEF );
6602  n->Arg<CFunction*>(0) = a0;
6603  return n;
6604 }
6613 inline CNode* cMODULE_DEF( CModule* a0, Coord_t* loc=NULL )
6614 {
6615  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eMODULE_DEF );
6616  n->Arg<CModule*>(0) = a0;
6617  return n;
6618 }
6628 inline CNode* cMODULE_DEF( CObstack* heap, CModule* a0, Coord_t* loc=NULL )
6629 {
6630  CNode* n = new(heap) CNode( loc, eMODULE_DEF );
6631  n->Arg<CModule*>(0) = a0;
6632  return n;
6633 }
6642 inline CNode* cPACKAGE_DEF( CPackage* a0, Coord_t* loc=NULL )
6643 {
6644  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePACKAGE_DEF );
6645  n->Arg<CPackage*>(0) = a0;
6646  return n;
6647 }
6657 inline CNode* cPACKAGE_DEF( CObstack* heap, CPackage* a0, Coord_t* loc=NULL )
6658 {
6659  CNode* n = new(heap) CNode( loc, ePACKAGE_DEF );
6660  n->Arg<CPackage*>(0) = a0;
6661  return n;
6662 }
6672 inline CNode* cREPEAT_CONTROL( CNode* a0, CNode* a1, Coord_t* loc=NULL )
6673 {
6674  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eREPEAT_CONTROL );
6675  n->Arg<CNode*>(0) = a0;
6676  n->Arg<CNode*>(1) = a1;
6677  return n;
6678 }
6689 inline CNode* cREPEAT_CONTROL( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
6690 {
6691  CNode* n = new(heap) CNode( loc, eREPEAT_CONTROL );
6692  n->Arg<CNode*>(0) = a0;
6693  n->Arg<CNode*>(1) = a1;
6694  return n;
6695 }
6704 inline CNode* cDELAY_CONTROL( CNode* a0, Coord_t* loc=NULL )
6705 {
6706  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eDELAY_CONTROL );
6707  n->Arg<CNode*>(0) = a0;
6708  return n;
6709 }
6719 inline CNode* cDELAY_CONTROL( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
6720 {
6721  CNode* n = new(heap) CNode( loc, eDELAY_CONTROL );
6722  n->Arg<CNode*>(0) = a0;
6723  return n;
6724 }
6733 inline CNode* cEVENT_CONTROL( CNode* a0, Coord_t* loc=NULL )
6734 {
6735  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eEVENT_CONTROL );
6736  n->Arg<CNode*>(0) = a0;
6737  return n;
6738 }
6748 inline CNode* cEVENT_CONTROL( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
6749 {
6750  CNode* n = new(heap) CNode( loc, eEVENT_CONTROL );
6751  n->Arg<CNode*>(0) = a0;
6752  return n;
6753 }
6762 inline CNode* cEXTERNAL_REF( CSymbol* a0, Coord_t* loc=NULL )
6763 {
6764  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eEXTERNAL_REF );
6765  n->Arg<CSymbol*>(0) = a0;
6766  return n;
6767 }
6777 inline CNode* cEXTERNAL_REF( CObstack* heap, CSymbol* a0, Coord_t* loc=NULL )
6778 {
6779  CNode* n = new(heap) CNode( loc, eEXTERNAL_REF );
6780  n->Arg<CSymbol*>(0) = a0;
6781  return n;
6782 }
6791 inline CNode* cPORT_DEF( CPort* a0, Coord_t* loc=NULL )
6792 {
6793  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePORT_DEF );
6794  n->Arg<CPort*>(0) = a0;
6795  return n;
6796 }
6806 inline CNode* cPORT_DEF( CObstack* heap, CPort* a0, Coord_t* loc=NULL )
6807 {
6808  CNode* n = new(heap) CNode( loc, ePORT_DEF );
6809  n->Arg<CPort*>(0) = a0;
6810  return n;
6811 }
6821 inline CNode* cDEFPARAM( CNode* a0, CNode* a1, Coord_t* loc=NULL )
6822 {
6823  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eDEFPARAM );
6824  n->Arg<CNode*>(0) = a0;
6825  n->Arg<CNode*>(1) = a1;
6826  return n;
6827 }
6838 inline CNode* cDEFPARAM( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
6839 {
6840  CNode* n = new(heap) CNode( loc, eDEFPARAM );
6841  n->Arg<CNode*>(0) = a0;
6842  n->Arg<CNode*>(1) = a1;
6843  return n;
6844 }
6859 inline CNode* cPATH( int a0, CNode* a1, int a2, int a3, CNode* a4, int a5, CNode* a6, Coord_t* loc=NULL )
6860 {
6861  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePATH );
6862  n->Arg<int>(0) = a0;
6863  n->Arg<CNode*>(1) = a1;
6864  n->Arg<int>(2) = a2;
6865  n->Arg<int>(3) = a3;
6866  n->Arg<CNode*>(4) = a4;
6867  n->Arg<int>(5) = a5;
6868  n->Arg<CNode*>(6) = a6;
6869  return n;
6870 }
6886 inline CNode* cPATH( CObstack* heap, int a0, CNode* a1, int a2, int a3, CNode* a4, int a5, CNode* a6, Coord_t* loc=NULL )
6887 {
6888  CNode* n = new(heap) CNode( loc, ePATH );
6889  n->Arg<int>(0) = a0;
6890  n->Arg<CNode*>(1) = a1;
6891  n->Arg<int>(2) = a2;
6892  n->Arg<int>(3) = a3;
6893  n->Arg<CNode*>(4) = a4;
6894  n->Arg<int>(5) = a5;
6895  n->Arg<CNode*>(6) = a6;
6896  return n;
6897 }
6908 inline CNode* cPATH_ASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
6909 {
6910  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePATH_ASSIGN );
6911  n->Arg<CNode*>(0) = a0;
6912  n->Arg<CNode*>(1) = a1;
6913  n->Arg<CNode*>(2) = a2;
6914  return n;
6915 }
6927 inline CNode* cPATH_ASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
6928 {
6929  CNode* n = new(heap) CNode( loc, ePATH_ASSIGN );
6930  n->Arg<CNode*>(0) = a0;
6931  n->Arg<CNode*>(1) = a1;
6932  n->Arg<CNode*>(2) = a2;
6933  return n;
6934 }
6944 inline CNode* cIFNONE_PATH_ASSIGN( CNode* a0, CNode* a1, Coord_t* loc=NULL )
6945 {
6946  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eIFNONE_PATH_ASSIGN );
6947  n->Arg<CNode*>(0) = a0;
6948  n->Arg<CNode*>(1) = a1;
6949  return n;
6950 }
6961 inline CNode* cIFNONE_PATH_ASSIGN( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
6962 {
6963  CNode* n = new(heap) CNode( loc, eIFNONE_PATH_ASSIGN );
6964  n->Arg<CNode*>(0) = a0;
6965  n->Arg<CNode*>(1) = a1;
6966  return n;
6967 }
6976 inline CNode* cTRIGGER( CNode* a0, Coord_t* loc=NULL )
6977 {
6978  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eTRIGGER );
6979  n->Arg<CNode*>(0) = a0;
6980  return n;
6981 }
6991 inline CNode* cTRIGGER( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
6992 {
6993  CNode* n = new(heap) CNode( loc, eTRIGGER );
6994  n->Arg<CNode*>(0) = a0;
6995  return n;
6996 }
7006 inline CNode* cPASSIGN( CNode* a0, CNode* a1, Coord_t* loc=NULL )
7007 {
7008  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePASSIGN );
7009  n->Arg<CNode*>(0) = a0;
7010  n->Arg<CNode*>(1) = a1;
7011  return n;
7012 }
7023 inline CNode* cPASSIGN( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
7024 {
7025  CNode* n = new(heap) CNode( loc, ePASSIGN );
7026  n->Arg<CNode*>(0) = a0;
7027  n->Arg<CNode*>(1) = a1;
7028  return n;
7029 }
7038 inline CNode* cDEASSIGN( CNode* a0, Coord_t* loc=NULL )
7039 {
7040  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eDEASSIGN );
7041  n->Arg<CNode*>(0) = a0;
7042  return n;
7043 }
7053 inline CNode* cDEASSIGN( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
7054 {
7055  CNode* n = new(heap) CNode( loc, eDEASSIGN );
7056  n->Arg<CNode*>(0) = a0;
7057  return n;
7058 }
7067 inline CNode* cDISABLE( CSymbol* a0, Coord_t* loc=NULL )
7068 {
7069  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eDISABLE );
7070  n->Arg<CSymbol*>(0) = a0;
7071  return n;
7072 }
7082 inline CNode* cDISABLE( CObstack* heap, CSymbol* a0, Coord_t* loc=NULL )
7083 {
7084  CNode* n = new(heap) CNode( loc, eDISABLE );
7085  n->Arg<CSymbol*>(0) = a0;
7086  return n;
7087 }
7096 inline CNode* cATTRIBUTE( CAttr* a0, Coord_t* loc=NULL )
7097 {
7098  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eATTRIBUTE );
7099  n->Arg<CAttr*>(0) = a0;
7100  return n;
7101 }
7111 inline CNode* cATTRIBUTE( CObstack* heap, CAttr* a0, Coord_t* loc=NULL )
7112 {
7113  CNode* n = new(heap) CNode( loc, eATTRIBUTE );
7114  n->Arg<CAttr*>(0) = a0;
7115  return n;
7116 }
7127 inline CNode* cGIF( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
7128 {
7129  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eGIF );
7130  n->Arg<CNode*>(0) = a0;
7131  n->Arg<CNode*>(1) = a1;
7132  n->Arg<CNode*>(2) = a2;
7133  return n;
7134 }
7146 inline CNode* cGIF( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
7147 {
7148  CNode* n = new(heap) CNode( loc, eGIF );
7149  n->Arg<CNode*>(0) = a0;
7150  n->Arg<CNode*>(1) = a1;
7151  n->Arg<CNode*>(2) = a2;
7152  return n;
7153 }
7165 inline CNode* cGFOR( CNode* a0, CNode* a1, CNode* a2, CNode* a3, Coord_t* loc=NULL )
7166 {
7167  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eGFOR );
7168  n->Arg<CNode*>(0) = a0;
7169  n->Arg<CNode*>(1) = a1;
7170  n->Arg<CNode*>(2) = a2;
7171  n->Arg<CNode*>(3) = a3;
7172  return n;
7173 }
7186 inline CNode* cGFOR( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, CNode* a3, Coord_t* loc=NULL )
7187 {
7188  CNode* n = new(heap) CNode( loc, eGFOR );
7189  n->Arg<CNode*>(0) = a0;
7190  n->Arg<CNode*>(1) = a1;
7191  n->Arg<CNode*>(2) = a2;
7192  n->Arg<CNode*>(3) = a3;
7193  return n;
7194 }
7204 inline CNode* cGCASE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
7205 {
7206  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eGCASE );
7207  n->Arg<CNode*>(0) = a0;
7208  n->Arg<CNode*>(1) = a1;
7209  return n;
7210 }
7221 inline CNode* cGCASE( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
7222 {
7223  CNode* n = new(heap) CNode( loc, eGCASE );
7224  n->Arg<CNode*>(0) = a0;
7225  n->Arg<CNode*>(1) = a1;
7226  return n;
7227 }
7236 inline CNode* cTABLE( CNode* a0, Coord_t* loc=NULL )
7237 {
7238  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eTABLE );
7239  n->Arg<CNode*>(0) = a0;
7240  return n;
7241 }
7251 inline CNode* cTABLE( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
7252 {
7253  CNode* n = new(heap) CNode( loc, eTABLE );
7254  n->Arg<CNode*>(0) = a0;
7255  return n;
7256 }
7265 inline CNode* cTABLE_ENTRY( CNode* a0, Coord_t* loc=NULL )
7266 {
7267  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eTABLE_ENTRY );
7268  n->Arg<CNode*>(0) = a0;
7269  return n;
7270 }
7280 inline CNode* cTABLE_ENTRY( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
7281 {
7282  CNode* n = new(heap) CNode( loc, eTABLE_ENTRY );
7283  n->Arg<CNode*>(0) = a0;
7284  return n;
7285 }
7294 inline CNode* cTABLE_SYMBOL( char* a0, Coord_t* loc=NULL )
7295 {
7296  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eTABLE_SYMBOL );
7297  n->Arg<char*>(0) = a0;
7298  return n;
7299 }
7309 inline CNode* cTABLE_SYMBOL( CObstack* heap, char* a0, Coord_t* loc=NULL )
7310 {
7311  CNode* n = new(heap) CNode( loc, eTABLE_SYMBOL );
7312  n->Arg<char*>(0) = a0;
7313  return n;
7314 }
7322 inline CNode* cPORTLIST_END( Coord_t* loc=NULL )
7323 {
7324  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePORTLIST_END );
7325  return n;
7326 }
7335 inline CNode* cPORTLIST_END( CObstack* heap, Coord_t* loc=NULL )
7336 {
7337  CNode* n = new(heap) CNode( loc, ePORTLIST_END );
7338  return n;
7339 }
7349 inline CNode* cMACRO_EXPR( const char* a0, CNode* a1, Coord_t* loc=NULL )
7350 {
7351  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eMACRO_EXPR );
7352  n->Arg<const char*>(0) = a0;
7353  n->Arg<CNode*>(1) = a1;
7354  return n;
7355 }
7366 inline CNode* cMACRO_EXPR( CObstack* heap, const char* a0, CNode* a1, Coord_t* loc=NULL )
7367 {
7368  CNode* n = new(heap) CNode( loc, eMACRO_EXPR );
7369  n->Arg<const char*>(0) = a0;
7370  n->Arg<CNode*>(1) = a1;
7371  return n;
7372 }
7383 inline CNode* cENUM_SPEC( CSymbol* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
7384 {
7385  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eENUM_SPEC );
7386  n->Arg<CSymbol*>(0) = a0;
7387  n->Arg<CNode*>(1) = a1;
7388  n->Arg<CNode*>(2) = a2;
7389  return n;
7390 }
7402 inline CNode* cENUM_SPEC( CObstack* heap, CSymbol* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
7403 {
7404  CNode* n = new(heap) CNode( loc, eENUM_SPEC );
7405  n->Arg<CSymbol*>(0) = a0;
7406  n->Arg<CNode*>(1) = a1;
7407  n->Arg<CNode*>(2) = a2;
7408  return n;
7409 }
7419 inline CNode* cMEMBER( CNode* a0, CSymbol* a1, Coord_t* loc=NULL )
7420 {
7421  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eMEMBER );
7422  n->Arg<CNode*>(0) = a0;
7423  n->Arg<CSymbol*>(1) = a1;
7424  return n;
7425 }
7436 inline CNode* cMEMBER( CObstack* heap, CNode* a0, CSymbol* a1, Coord_t* loc=NULL )
7437 {
7438  CNode* n = new(heap) CNode( loc, eMEMBER );
7439  n->Arg<CNode*>(0) = a0;
7440  n->Arg<CSymbol*>(1) = a1;
7441  return n;
7442 }
7451 inline CNode* cRETURN( CNode* a0, Coord_t* loc=NULL )
7452 {
7453  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRETURN );
7454  n->Arg<CNode*>(0) = a0;
7455  return n;
7456 }
7466 inline CNode* cRETURN( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
7467 {
7468  CNode* n = new(heap) CNode( loc, eRETURN );
7469  n->Arg<CNode*>(0) = a0;
7470  return n;
7471 }
7480 inline CNode* cPREINC( CNode* a0, Coord_t* loc=NULL )
7481 {
7482  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePREINC );
7483  n->Arg<CNode*>(0) = a0;
7484  return n;
7485 }
7495 inline CNode* cPREINC( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
7496 {
7497  CNode* n = new(heap) CNode( loc, ePREINC );
7498  n->Arg<CNode*>(0) = a0;
7499  return n;
7500 }
7509 inline CNode* cPOSTINC( CNode* a0, Coord_t* loc=NULL )
7510 {
7511  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePOSTINC );
7512  n->Arg<CNode*>(0) = a0;
7513  return n;
7514 }
7524 inline CNode* cPOSTINC( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
7525 {
7526  CNode* n = new(heap) CNode( loc, ePOSTINC );
7527  n->Arg<CNode*>(0) = a0;
7528  return n;
7529 }
7538 inline CNode* cPREDEC( CNode* a0, Coord_t* loc=NULL )
7539 {
7540  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePREDEC );
7541  n->Arg<CNode*>(0) = a0;
7542  return n;
7543 }
7553 inline CNode* cPREDEC( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
7554 {
7555  CNode* n = new(heap) CNode( loc, ePREDEC );
7556  n->Arg<CNode*>(0) = a0;
7557  return n;
7558 }
7567 inline CNode* cPOSTDEC( CNode* a0, Coord_t* loc=NULL )
7568 {
7569  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePOSTDEC );
7570  n->Arg<CNode*>(0) = a0;
7571  return n;
7572 }
7582 inline CNode* cPOSTDEC( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
7583 {
7584  CNode* n = new(heap) CNode( loc, ePOSTDEC );
7585  n->Arg<CNode*>(0) = a0;
7586  return n;
7587 }
7597 inline CNode* cCAST( CNode* a0, CNode* a1, Coord_t* loc=NULL )
7598 {
7599  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCAST );
7600  n->Arg<CNode*>(0) = a0;
7601  n->Arg<CNode*>(1) = a1;
7602  return n;
7603 }
7614 inline CNode* cCAST( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
7615 {
7616  CNode* n = new(heap) CNode( loc, eCAST );
7617  n->Arg<CNode*>(0) = a0;
7618  n->Arg<CNode*>(1) = a1;
7619  return n;
7620 }
7629 inline CNode* cASSIGNMENT_PATTERN( CNode* a0, Coord_t* loc=NULL )
7630 {
7631  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eASSIGNMENT_PATTERN );
7632  n->Arg<CNode*>(0) = a0;
7633  return n;
7634 }
7644 inline CNode* cASSIGNMENT_PATTERN( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
7645 {
7646  CNode* n = new(heap) CNode( loc, eASSIGNMENT_PATTERN );
7647  n->Arg<CNode*>(0) = a0;
7648  return n;
7649 }
7657 inline CNode* cDOLLAR( Coord_t* loc=NULL )
7658 {
7659  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eDOLLAR );
7660  return n;
7661 }
7670 inline CNode* cDOLLAR( CObstack* heap, Coord_t* loc=NULL )
7671 {
7672  CNode* n = new(heap) CNode( loc, eDOLLAR );
7673  return n;
7674 }
7675 #endif // DEFINE_CONSTUCTOR
7676 
7677 
7678 /*********************************************************
7679  * Warning: This file is machine generate, do not edit
7680  ********************************************************/
7681 
7682 
7683 
7684 
7685 #ifdef DEFINE_METHODS
7686 
7687 /************************************
7688  * ArgCount
7689  * - return number of arguments for node
7690  ***********************************/
7692 {
7693  switch( op ) {
7694  case eERROR:
7695  return 0;
7696  case eVCONSTANT:
7697  return 1;
7698  case eRCONSTANT:
7699  return 1;
7700  case eCOMMENT:
7701  return 1;
7702  case eVRQ:
7703  return 1;
7704  case ePRAGMA:
7705  return 2;
7706  case eELIST:
7707  return 2;
7708  case eWIDTH:
7709  return 2;
7710  case eNOP:
7711  return 0;
7712  case eSUB:
7713  return 2;
7714  case eMUL:
7715  return 2;
7716  case eDIV:
7717  return 2;
7718  case ePOW:
7719  return 2;
7720  case eADD:
7721  return 2;
7722  case eLSH:
7723  return 2;
7724  case eRSH:
7725  return 2;
7726  case eLSHA:
7727  return 2;
7728  case eRSHA:
7729  return 2;
7730  case eMOD:
7731  return 2;
7732  case eOR:
7733  return 2;
7734  case eAND:
7735  return 2;
7736  case eANDANDAND:
7737  return 2;
7738  case eXOR:
7739  return 2;
7740  case eXNOR:
7741  return 2;
7742  case eINSTANCE_REF:
7743  return 1;
7744  case eGATE_REF:
7745  return 1;
7746  case eTASK_ENABLE:
7747  return 2;
7748  case eSYSTASK_CALL:
7749  return 2;
7750  case eTIMING_CALL:
7751  return 2;
7752  case eFUNCTION_CALL:
7753  return 3;
7754  case eARRAY:
7755  return 2;
7756  case eNET_REF:
7757  return 1;
7758  case eVAR_REF:
7759  return 1;
7760  case ePARAM_REF:
7761  return 1;
7762  case ePORT_REF:
7763  return 1;
7764  case eFWD_REF:
7765  return 1;
7766  case eGENVAR_REF:
7767  return 1;
7768  case eENUM_REF:
7769  return 1;
7770  case eTYPE_REF:
7771  return 1;
7772  case eNET_DECL:
7773  return 2;
7774  case eVAR_DECL:
7775  return 2;
7776  case ePARAM_DECL:
7777  return 1;
7778  case eSPECPARAM_DECL:
7779  return 1;
7780  case ePORT_DECL:
7781  return 1;
7782  case eGENVAR_DECL:
7783  return 1;
7784  case eTYPEDEF_DECL:
7785  return 1;
7786  case eLIST:
7787  return 2;
7788  case eRANGE:
7789  return 2;
7790  case eSLICE:
7791  return 2;
7792  case ePSLICE:
7793  return 2;
7794  case eMSLICE:
7795  return 2;
7796  case eCVRI:
7797  return 1;
7798  case eCVIR:
7799  return 1;
7800  case eREP:
7801  return 2;
7802  case eCAT:
7803  return 2;
7804  case eUCAT:
7805  return 1;
7806  case eCOM:
7807  return 1;
7808  case eNEG:
7809  return 1;
7810  case ePLUS:
7811  return 1;
7812  case eNOT:
7813  return 1;
7814  case eGT:
7815  return 2;
7816  case eGE:
7817  return 2;
7818  case eLT:
7819  return 2;
7820  case eLE:
7821  return 2;
7822  case eLAND:
7823  return 2;
7824  case eLOR:
7825  return 2;
7826  case eCEQ:
7827  return 2;
7828  case eCNE:
7829  return 2;
7830  case eEQ:
7831  return 2;
7832  case eNE:
7833  return 2;
7834  case eRAND:
7835  return 1;
7836  case eRNAND:
7837  return 1;
7838  case eROR:
7839  return 1;
7840  case eRNOR:
7841  return 1;
7842  case eRXOR:
7843  return 1;
7844  case eRXNOR:
7845  return 1;
7846  case eHOOK:
7847  return 3;
7848  case eINIT:
7849  return 1;
7850  case eALWAYS:
7851  return 1;
7852  case eALWAYS_LATCH:
7853  return 1;
7854  case eALWAYS_FF:
7855  return 1;
7856  case eALWAYS_COMB:
7857  return 1;
7858  case eEVENT:
7859  return 2;
7860  case eBLOCK_REF:
7861  return 3;
7862  case eSPECIFY_REF:
7863  return 2;
7864  case eASSIGN:
7865  return 3;
7866  case eGASSIGN:
7867  return 3;
7868  case eADD_ASSIGN:
7869  return 3;
7870  case eSUB_ASSIGN:
7871  return 3;
7872  case eMUL_ASSIGN:
7873  return 3;
7874  case eDIV_ASSIGN:
7875  return 3;
7876  case eMOD_ASSIGN:
7877  return 3;
7878  case eAND_ASSIGN:
7879  return 3;
7880  case eOR_ASSIGN:
7881  return 3;
7882  case eXOR_ASSIGN:
7883  return 3;
7884  case eLSH_ASSIGN:
7885  return 3;
7886  case eRSH_ASSIGN:
7887  return 3;
7888  case eLSHA_ASSIGN:
7889  return 3;
7890  case eRSHA_ASSIGN:
7891  return 3;
7892  case eFORCE:
7893  return 2;
7894  case eRELEASE:
7895  return 1;
7896  case eNBASSIGN:
7897  return 3;
7898  case ePOSEDGE:
7899  return 1;
7900  case eNEGEDGE:
7901  return 1;
7902  case eEDGE:
7903  return 2;
7904  case eEVOR:
7905  return 2;
7906  case eDELAY:
7907  return 2;
7908  case eMTM:
7909  return 3;
7910  case eIF:
7911  return 4;
7912  case eFOREVER:
7913  return 1;
7914  case eREPEAT:
7915  return 2;
7916  case eWHILE:
7917  return 2;
7918  case eWAIT:
7919  return 2;
7920  case eFOR:
7921  return 4;
7922  case eCASE:
7923  return 4;
7924  case eCASEX:
7925  return 3;
7926  case eCASEZ:
7927  return 3;
7928  case eCASEITEM:
7929  return 2;
7930  case eCASSIGN:
7931  return 4;
7932  case eARG:
7933  return 2;
7934  case eIMPORT:
7935  return 1;
7936  case eFUNCTION_DEF:
7937  return 1;
7938  case eMODULE_DEF:
7939  return 1;
7940  case ePACKAGE_DEF:
7941  return 1;
7942  case eREPEAT_CONTROL:
7943  return 2;
7944  case eDELAY_CONTROL:
7945  return 1;
7946  case eEVENT_CONTROL:
7947  return 1;
7948  case eEXTERNAL_REF:
7949  return 1;
7950  case ePORT_DEF:
7951  return 1;
7952  case eDEFPARAM:
7953  return 2;
7954  case ePATH:
7955  return 7;
7956  case ePATH_ASSIGN:
7957  return 3;
7958  case eIFNONE_PATH_ASSIGN:
7959  return 2;
7960  case eTRIGGER:
7961  return 1;
7962  case ePASSIGN:
7963  return 2;
7964  case eDEASSIGN:
7965  return 1;
7966  case eDISABLE:
7967  return 1;
7968  case eATTRIBUTE:
7969  return 1;
7970  case eGIF:
7971  return 3;
7972  case eGFOR:
7973  return 4;
7974  case eGCASE:
7975  return 2;
7976  case eTABLE:
7977  return 1;
7978  case eTABLE_ENTRY:
7979  return 1;
7980  case eTABLE_SYMBOL:
7981  return 1;
7982  case ePORTLIST_END:
7983  return 0;
7984  case eMACRO_EXPR:
7985  return 2;
7986  case eENUM_SPEC:
7987  return 3;
7988  case eMEMBER:
7989  return 2;
7990  case eRETURN:
7991  return 1;
7992  case ePREINC:
7993  return 1;
7994  case ePOSTINC:
7995  return 1;
7996  case ePREDEC:
7997  return 1;
7998  case ePOSTDEC:
7999  return 1;
8000  case eCAST:
8001  return 2;
8002  case eASSIGNMENT_PATTERN:
8003  return 1;
8004  case eDOLLAR:
8005  return 0;
8006  default:
8007  MASSERT(FALSE);
8008  }
8009  return 0;
8010 }
8011 
8012 /************************************
8013  * Precedence
8014  * - return precedence of operator
8015  * result 0 - 13
8016  ***********************************/
8018 {
8019  switch( op ) {
8020  case eERROR:
8021  return 13;
8022  case eVCONSTANT:
8023  return 13;
8024  case eRCONSTANT:
8025  return 13;
8026  case eCOMMENT:
8027  return 13;
8028  case eVRQ:
8029  return 13;
8030  case ePRAGMA:
8031  return 13;
8032  case eELIST:
8033  return 13;
8034  case eWIDTH:
8035  return 13;
8036  case eSUB:
8037  return 9;
8038  case eMUL:
8039  return 10;
8040  case eDIV:
8041  return 10;
8042  case ePOW:
8043  return 11;
8044  case eADD:
8045  return 9;
8046  case eLSH:
8047  return 8;
8048  case eRSH:
8049  return 8;
8050  case eLSHA:
8051  return 8;
8052  case eRSHA:
8053  return 8;
8054  case eMOD:
8055  return 10;
8056  case eOR:
8057  return 3;
8058  case eAND:
8059  return 5;
8060  case eANDANDAND:
8061  return 0;
8062  case eXOR:
8063  return 4;
8064  case eXNOR:
8065  return 4;
8066  case eSYSTASK_CALL:
8067  return 13;
8068  case eFUNCTION_CALL:
8069  return 13;
8070  case eARRAY:
8071  return 13;
8072  case eNET_REF:
8073  return 13;
8074  case eVAR_REF:
8075  return 13;
8076  case ePARAM_REF:
8077  return 13;
8078  case ePORT_REF:
8079  return 13;
8080  case eFWD_REF:
8081  return 13;
8082  case eGENVAR_REF:
8083  return 13;
8084  case eENUM_REF:
8085  return 13;
8086  case eTYPE_REF:
8087  return 13;
8088  case eRANGE:
8089  return 13;
8090  case eSLICE:
8091  return 13;
8092  case ePSLICE:
8093  return 13;
8094  case eMSLICE:
8095  return 13;
8096  case eCVRI:
8097  return 13;
8098  case eCVIR:
8099  return 13;
8100  case eREP:
8101  return 13;
8102  case eCAT:
8103  return 13;
8104  case eUCAT:
8105  return 13;
8106  case eCOM:
8107  return 12;
8108  case eNEG:
8109  return 12;
8110  case ePLUS:
8111  return 12;
8112  case eNOT:
8113  return 12;
8114  case eGT:
8115  return 7;
8116  case eGE:
8117  return 7;
8118  case eLT:
8119  return 7;
8120  case eLE:
8121  return 7;
8122  case eLAND:
8123  return 2;
8124  case eLOR:
8125  return 1;
8126  case eCEQ:
8127  return 6;
8128  case eCNE:
8129  return 6;
8130  case eEQ:
8131  return 6;
8132  case eNE:
8133  return 6;
8134  case eRAND:
8135  return 12;
8136  case eRNAND:
8137  return 12;
8138  case eROR:
8139  return 12;
8140  case eRNOR:
8141  return 12;
8142  case eRXOR:
8143  return 12;
8144  case eRXNOR:
8145  return 12;
8146  case eHOOK:
8147  return 0;
8148  case ePOSEDGE:
8149  return 13;
8150  case eNEGEDGE:
8151  return 13;
8152  case eEDGE:
8153  return 13;
8154  case eEVOR:
8155  return 13;
8156  case eMTM:
8157  return 13;
8158  case eEXTERNAL_REF:
8159  return 13;
8160  case eMACRO_EXPR:
8161  return 13;
8162  case eMEMBER:
8163  return 13;
8164  case ePREINC:
8165  return 12;
8166  case ePOSTINC:
8167  return 12;
8168  case ePREDEC:
8169  return 12;
8170  case ePOSTDEC:
8171  return 12;
8172  case eCAST:
8173  return 13;
8174  case eASSIGNMENT_PATTERN:
8175  return 13;
8176  case eDOLLAR:
8177  return 13;
8178  default:
8179  MASSERT( FALSE );
8180  return 13;
8181  }
8182 }
8183 
8184 /************************************************
8185  IsConstant
8186  - return true if expression is constant
8187 **************************************************/
8188 
8190 {
8191  switch( op ) {
8192  case eERROR:
8193  return FALSE;
8194  case eVCONSTANT:
8195  return TRUE;
8196  case eRCONSTANT:
8197  return TRUE;
8198  case eCOMMENT:
8199  return TRUE;
8200  case eVRQ:
8201  return TRUE;
8202  case ePRAGMA:
8203  return TRUE;
8204  case eELIST:
8205  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8206  case eWIDTH:
8207  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8208  case eSUB:
8209  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8210  case eMUL:
8211  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8212  case eDIV:
8213  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8214  case ePOW:
8215  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8216  case eADD:
8217  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8218  case eLSH:
8219  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8220  case eRSH:
8221  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8222  case eLSHA:
8223  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8224  case eRSHA:
8225  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8226  case eMOD:
8227  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8228  case eOR:
8229  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8230  case eAND:
8231  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8232  case eANDANDAND:
8233  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8234  case eXOR:
8235  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8236  case eXNOR:
8237  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8238  case eSYSTASK_CALL:
8239  return TRUE;
8240  case eFUNCTION_CALL:
8241  return Arg<CNode*>(1)->IsConstant();
8242  case eARRAY:
8243  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8244  case eNET_REF:
8245  return FALSE;
8246  case eVAR_REF:
8247  return FALSE;
8248  case ePARAM_REF:
8249  return TRUE;
8250  case ePORT_REF:
8251  return FALSE;
8252  case eFWD_REF:
8253  return FALSE;
8254  case eGENVAR_REF:
8255  return TRUE;
8256  case eENUM_REF:
8257  return TRUE;
8258  case eTYPE_REF:
8259  return TRUE;
8260  case eRANGE:
8261  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8262  case eSLICE:
8263  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8264  case ePSLICE:
8265  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8266  case eMSLICE:
8267  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8268  case eCVRI:
8269  return Arg<CNode*>(0)->IsConstant();
8270  case eCVIR:
8271  return Arg<CNode*>(0)->IsConstant();
8272  case eREP:
8273  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8274  case eCAT:
8275  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8276  case eUCAT:
8277  return Arg<CNode*>(0)->IsConstant();
8278  case eCOM:
8279  return Arg<CNode*>(0)->IsConstant();
8280  case eNEG:
8281  return Arg<CNode*>(0)->IsConstant();
8282  case ePLUS:
8283  return Arg<CNode*>(0)->IsConstant();
8284  case eNOT:
8285  return Arg<CNode*>(0)->IsConstant();
8286  case eGT:
8287  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8288  case eGE:
8289  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8290  case eLT:
8291  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8292  case eLE:
8293  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8294  case eLAND:
8295  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8296  case eLOR:
8297  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8298  case eCEQ:
8299  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8300  case eCNE:
8301  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8302  case eEQ:
8303  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8304  case eNE:
8305  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8306  case eRAND:
8307  return Arg<CNode*>(0)->IsConstant();
8308  case eRNAND:
8309  return Arg<CNode*>(0)->IsConstant();
8310  case eROR:
8311  return Arg<CNode*>(0)->IsConstant();
8312  case eRNOR:
8313  return Arg<CNode*>(0)->IsConstant();
8314  case eRXOR:
8315  return Arg<CNode*>(0)->IsConstant();
8316  case eRXNOR:
8317  return Arg<CNode*>(0)->IsConstant();
8318  case eHOOK:
8319  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant() && Arg<CNode*>(2)->IsConstant();
8320  case eMTM:
8321  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant() && Arg<CNode*>(2)->IsConstant();
8322  case eEXTERNAL_REF:
8323  return FALSE;
8324  case eMACRO_EXPR:
8325  return TRUE;
8326  case eMEMBER:
8327  return Arg<CNode*>(0)->IsConstant();
8328  case ePREINC:
8329  return Arg<CNode*>(0)->IsConstant();
8330  case ePOSTINC:
8331  return Arg<CNode*>(0)->IsConstant();
8332  case ePREDEC:
8333  return Arg<CNode*>(0)->IsConstant();
8334  case ePOSTDEC:
8335  return Arg<CNode*>(0)->IsConstant();
8336  case eCAST:
8337  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8338  case eASSIGNMENT_PATTERN:
8339  return Arg<CNode*>(0)->IsConstant();
8340  case eDOLLAR:
8341  return TRUE;
8342  default:
8343  MASSERT( FALSE );
8344  }
8345 
8346  return TRUE;
8347 }
8348 
8349 /************************************************
8350  IsVolatile
8351  - return false if expression is constant
8352  and not dependent upon parameters
8353 **************************************************/
8354 
8356 {
8357  switch( op ) {
8358  case eERROR:
8359  return TRUE;
8360  case eVCONSTANT:
8361  return FALSE;
8362  case eRCONSTANT:
8363  return FALSE;
8364  case eCOMMENT:
8365  return FALSE;
8366  case eVRQ:
8367  return FALSE;
8368  case ePRAGMA:
8369  return FALSE;
8370  case eELIST:
8371  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8372  case eWIDTH:
8373  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8374  case eSUB:
8375  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8376  case eMUL:
8377  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8378  case eDIV:
8379  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8380  case ePOW:
8381  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8382  case eADD:
8383  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8384  case eLSH:
8385  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8386  case eRSH:
8387  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8388  case eLSHA:
8389  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8390  case eRSHA:
8391  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8392  case eMOD:
8393  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8394  case eOR:
8395  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8396  case eAND:
8397  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8398  case eANDANDAND:
8399  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8400  case eXOR:
8401  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8402  case eXNOR:
8403  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8404  case eSYSTASK_CALL:
8405  return TRUE;
8406  case eFUNCTION_CALL:
8407  return Arg<CNode*>(1)->IsVolatile();
8408  case eARRAY:
8409  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8410  case eNET_REF:
8411  return TRUE;
8412  case eVAR_REF:
8413  return TRUE;
8414  case ePARAM_REF:
8415  return TRUE;
8416  case ePORT_REF:
8417  return TRUE;
8418  case eFWD_REF:
8419  return TRUE;
8420  case eGENVAR_REF:
8421  return TRUE;
8422  case eENUM_REF:
8423  return Arg<CEnum*>(0)->GetExpression()->IsVolatile();
8424  case eTYPE_REF:
8425  return FALSE;
8426  case eRANGE:
8427  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8428  case eSLICE:
8429  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8430  case ePSLICE:
8431  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8432  case eMSLICE:
8433  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8434  case eCVRI:
8435  return Arg<CNode*>(0)->IsVolatile();
8436  case eCVIR:
8437  return Arg<CNode*>(0)->IsVolatile();
8438  case eREP:
8439  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8440  case eCAT:
8441  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8442  case eUCAT:
8443  return Arg<CNode*>(0)->IsVolatile();
8444  case eCOM:
8445  return Arg<CNode*>(0)->IsVolatile();
8446  case eNEG:
8447  return Arg<CNode*>(0)->IsVolatile();
8448  case ePLUS:
8449  return Arg<CNode*>(0)->IsVolatile();
8450  case eNOT:
8451  return Arg<CNode*>(0)->IsVolatile();
8452  case eGT:
8453  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8454  case eGE:
8455  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8456  case eLT:
8457  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8458  case eLE:
8459  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8460  case eLAND:
8461  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8462  case eLOR:
8463  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8464  case eCEQ:
8465  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8466  case eCNE:
8467  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8468  case eEQ:
8469  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8470  case eNE:
8471  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8472  case eRAND:
8473  return Arg<CNode*>(0)->IsVolatile();
8474  case eRNAND:
8475  return Arg<CNode*>(0)->IsVolatile();
8476  case eROR:
8477  return Arg<CNode*>(0)->IsVolatile();
8478  case eRNOR:
8479  return Arg<CNode*>(0)->IsVolatile();
8480  case eRXOR:
8481  return Arg<CNode*>(0)->IsVolatile();
8482  case eRXNOR:
8483  return Arg<CNode*>(0)->IsVolatile();
8484  case eHOOK:
8485  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile() || Arg<CNode*>(2)->IsVolatile();
8486  case eMTM:
8487  return TRUE;
8488  case eEXTERNAL_REF:
8489  return TRUE;
8490  case eMACRO_EXPR:
8491  return Arg<CNode*>(1) ? Arg<CNode*>(1)->IsVolatile() : TRUE;
8492  case eMEMBER:
8493  return Arg<CNode*>(0)->IsVolatile();
8494  case ePREINC:
8495  return Arg<CNode*>(0)->IsVolatile();
8496  case ePOSTINC:
8497  return Arg<CNode*>(0)->IsVolatile();
8498  case ePREDEC:
8499  return Arg<CNode*>(0)->IsVolatile();
8500  case ePOSTDEC:
8501  return Arg<CNode*>(0)->IsVolatile();
8502  case eCAST:
8503  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8504  case eASSIGNMENT_PATTERN:
8505  return Arg<CNode*>(0)->IsVolatile();
8506  case eDOLLAR:
8507  return FALSE;
8508  default:
8509  MASSERT( FALSE );
8510  }
8511 
8512  return TRUE;
8513 }
8514 
8515 
8516 /************************************************
8517  IsWidthConstant
8518  - return true if expression has a constant width
8519 **************************************************/
8520 
8522 {
8523  switch( GetOp() ) {
8524  case eERROR:
8525  return TRUE;
8526  case eVCONSTANT:
8527  return Arg<CVector*>(0)->IsWidthConstant();
8528  case eRCONSTANT:
8529  return TRUE;
8530  case eELIST:
8531  return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
8532  case eWIDTH:
8533  return Arg<CNode*>(0)->IsConstant();
8534  case eSUB:
8535  return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
8536  case eMUL:
8537  return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
8538  case eDIV:
8539  return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
8540  case ePOW:
8541  return Arg<CNode*>(0)->IsWidthConstant();
8542  case eADD:
8543  return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
8544  case eLSH:
8545  return Arg<CNode*>(0)->IsWidthConstant();
8546  case eRSH:
8547  return Arg<CNode*>(0)->IsWidthConstant();
8548  case eLSHA:
8549  return Arg<CNode*>(0)->IsWidthConstant();
8550  case eRSHA:
8551  return Arg<CNode*>(0)->IsWidthConstant();
8552  case eMOD:
8553  return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
8554  case eOR:
8555  return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
8556  case eAND:
8557  return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
8558  case eANDANDAND:
8559  return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
8560  case eXOR:
8561  return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
8562  case eXNOR:
8563  return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
8564  case eSYSTASK_CALL:
8565  return Systask::WidthConstant(Arg<CSymbol*>(0),Arg<CNode*>(1));
8566  case eFUNCTION_CALL:
8567  return CFunction::WidthConstant(Arg<CSymbol*>(0),Arg<CNode*>(1),Arg<CScope*>(2));
8568  case eARRAY:
8569  return Array::WidthConstant(Arg<CNode*>(0),Arg<CNode*>(1));
8570  case eNET_REF:
8571  return Arg<CNet*>(0)->IsWidthConstant();
8572  case eVAR_REF:
8573  return Arg<CVar*>(0)->IsWidthConstant();
8574  case ePARAM_REF:
8575  return Arg<CParam*>(0)->IsWidthConstant();
8576  case ePORT_REF:
8577  return Arg<CPortDir*>(0)->IsWidthConstant();
8578  case eFWD_REF:
8579  return Arg<CFref*>(0)->IsWidthConstant();
8580  case eGENVAR_REF:
8581  return Arg<CGenvar*>(0)->IsWidthConstant();
8582  case eENUM_REF:
8583  return Arg<CEnum*>(0)->IsWidthConstant();
8584  case eTYPE_REF:
8585  return TRUE;
8586  case eRANGE:
8587  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8588  case eSLICE:
8589  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8590  case ePSLICE:
8591  return Arg<CNode*>(1)->IsConstant();
8592  case eMSLICE:
8593  return Arg<CNode*>(1)->IsConstant();
8594  case eCVRI:
8595  return TRUE;
8596  case eCVIR:
8597  return TRUE;
8598  case eREP:
8599  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsWidthConstant();
8600  case eCAT:
8601  return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
8602  case eUCAT:
8603  return Arg<CNode*>(0)->IsWidthConstant();
8604  case eCOM:
8605  return Arg<CNode*>(0)->IsWidthConstant();
8606  case eNEG:
8607  return Arg<CNode*>(0)->IsWidthConstant();
8608  case ePLUS:
8609  return Arg<CNode*>(0)->IsWidthConstant();
8610  case eNOT:
8611  return TRUE;
8612  case eGT:
8613  return TRUE;
8614  case eGE:
8615  return TRUE;
8616  case eLT:
8617  return TRUE;
8618  case eLE:
8619  return TRUE;
8620  case eLAND:
8621  return TRUE;
8622  case eLOR:
8623  return TRUE;
8624  case eCEQ:
8625  return TRUE;
8626  case eCNE:
8627  return TRUE;
8628  case eEQ:
8629  return TRUE;
8630  case eNE:
8631  return TRUE;
8632  case eRAND:
8633  return TRUE;
8634  case eRNAND:
8635  return TRUE;
8636  case eROR:
8637  return TRUE;
8638  case eRNOR:
8639  return TRUE;
8640  case eRXOR:
8641  return TRUE;
8642  case eRXNOR:
8643  return TRUE;
8644  case eHOOK:
8645  return Arg<CNode*>(1)->IsWidthConstant() && Arg<CNode*>(2)->IsWidthConstant();
8646  case eMTM:
8647  return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant() && Arg<CNode*>(2)->IsWidthConstant();
8648  case eEXTERNAL_REF:
8649  return External::WidthConstant(Arg<CSymbol*>(0));
8650  case eATTRIBUTE:
8651  return TRUE;
8652  case eMACRO_EXPR:
8653  return Arg<CNode*>(1)->IsWidthConstant();
8654  case eMEMBER:
8655  return Member::WidthConstant(Arg<CNode*>(0),Arg<CSymbol*>(1));
8656  case ePREINC:
8657  return Arg<CNode*>(0)->IsWidthConstant();
8658  case ePOSTINC:
8659  return Arg<CNode*>(0)->IsWidthConstant();
8660  case ePREDEC:
8661  return Arg<CNode*>(0)->IsWidthConstant();
8662  case ePOSTDEC:
8663  return Arg<CNode*>(0)->IsWidthConstant();
8664  case eCAST:
8665  return Arg<CNode*>(0)->IsWidthConstant();
8666  case eASSIGNMENT_PATTERN:
8667  return TRUE;
8668  case eDOLLAR:
8669  return TRUE;
8670  default:
8671  MASSERT( FALSE );
8672  return 0;
8673  }
8674 }
8675 
8676 /************************************************
8677  IsWidthVolatile
8678  - return true if expression has a volatile width
8679 **************************************************/
8680 
8682 {
8683  switch( GetOp() ) {
8684  case eERROR:
8685  return FALSE;
8686  case eVCONSTANT:
8687  return Arg<CVector*>(0)->IsWidthVolatile();
8688  case eRCONSTANT:
8689  return FALSE;
8690  case eELIST:
8691  return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
8692  case eWIDTH:
8693  return Arg<CNode*>(0)->IsVolatile();
8694  case eSUB:
8695  return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
8696  case eMUL:
8697  return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
8698  case eDIV:
8699  return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
8700  case ePOW:
8701  return Arg<CNode*>(0)->IsWidthVolatile();
8702  case eADD:
8703  return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
8704  case eLSH:
8705  return Arg<CNode*>(0)->IsWidthVolatile();
8706  case eRSH:
8707  return Arg<CNode*>(0)->IsWidthVolatile();
8708  case eLSHA:
8709  return Arg<CNode*>(0)->IsWidthVolatile();
8710  case eRSHA:
8711  return Arg<CNode*>(0)->IsWidthVolatile();
8712  case eMOD:
8713  return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
8714  case eOR:
8715  return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
8716  case eAND:
8717  return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
8718  case eANDANDAND:
8719  return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
8720  case eXOR:
8721  return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
8722  case eXNOR:
8723  return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
8724  case eSYSTASK_CALL:
8725  return Systask::WidthVolatile(Arg<CSymbol*>(0),Arg<CNode*>(1));
8726  case eFUNCTION_CALL:
8727  return CFunction::WidthVolatile(Arg<CSymbol*>(0),Arg<CNode*>(1),Arg<CScope*>(2));
8728  case eARRAY:
8729  return Array::WidthVolatile(Arg<CNode*>(0),Arg<CNode*>(1));
8730  case eNET_REF:
8731  return Arg<CNet*>(0)->IsWidthVolatile();
8732  case eVAR_REF:
8733  return Arg<CVar*>(0)->IsWidthVolatile();
8734  case ePARAM_REF:
8735  return Arg<CParam*>(0)->IsWidthVolatile();
8736  case ePORT_REF:
8737  return Arg<CPortDir*>(0)->IsWidthVolatile();
8738  case eFWD_REF:
8739  return Arg<CFref*>(0)->IsWidthVolatile();
8740  case eGENVAR_REF:
8741  return Arg<CGenvar*>(0)->IsWidthVolatile();
8742  case eENUM_REF:
8743  return Arg<CEnum*>(0)->IsWidthVolatile();
8744  case eTYPE_REF:
8745  return FALSE;
8746  case eRANGE:
8747  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8748  case eSLICE:
8749  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8750  case ePSLICE:
8751  return Arg<CNode*>(1)->IsVolatile();
8752  case eMSLICE:
8753  return Arg<CNode*>(1)->IsVolatile();
8754  case eCVRI:
8755  return FALSE;
8756  case eCVIR:
8757  return FALSE;
8758  case eREP:
8759  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
8760  case eCAT:
8761  return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
8762  case eUCAT:
8763  return Arg<CNode*>(0)->IsWidthVolatile();
8764  case eCOM:
8765  return Arg<CNode*>(0)->IsWidthVolatile();
8766  case eNEG:
8767  return Arg<CNode*>(0)->IsWidthVolatile();
8768  case ePLUS:
8769  return Arg<CNode*>(0)->IsWidthVolatile();
8770  case eNOT:
8771  return FALSE;
8772  case eGT:
8773  return FALSE;
8774  case eGE:
8775  return FALSE;
8776  case eLT:
8777  return FALSE;
8778  case eLE:
8779  return FALSE;
8780  case eLAND:
8781  return FALSE;
8782  case eLOR:
8783  return FALSE;
8784  case eCEQ:
8785  return FALSE;
8786  case eCNE:
8787  return FALSE;
8788  case eEQ:
8789  return FALSE;
8790  case eNE:
8791  return FALSE;
8792  case eRAND:
8793  return FALSE;
8794  case eRNAND:
8795  return FALSE;
8796  case eROR:
8797  return FALSE;
8798  case eRNOR:
8799  return FALSE;
8800  case eRXOR:
8801  return FALSE;
8802  case eRXNOR:
8803  return FALSE;
8804  case eHOOK:
8805  return Arg<CNode*>(1)->IsWidthVolatile() || Arg<CNode*>(2)->IsWidthVolatile();
8806  case eMTM:
8807  return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile() || Arg<CNode*>(2)->IsWidthVolatile();
8808  case eEXTERNAL_REF:
8809  return External::WidthVolatile(Arg<CSymbol*>(0));
8810  case eATTRIBUTE:
8811  return FALSE;
8812  case eMACRO_EXPR:
8813  return Arg<CNode*>(1)->IsWidthVolatile();
8814  case eMEMBER:
8815  return Member::WidthVolatile(Arg<CNode*>(0),Arg<CSymbol*>(1));
8816  case ePREINC:
8817  return Arg<CNode*>(0)->IsWidthVolatile();
8818  case ePOSTINC:
8819  return Arg<CNode*>(0)->IsWidthVolatile();
8820  case ePREDEC:
8821  return Arg<CNode*>(0)->IsWidthVolatile();
8822  case ePOSTDEC:
8823  return Arg<CNode*>(0)->IsWidthVolatile();
8824  case eCAST:
8825  return Arg<CNode*>(0)->IsWidthVolatile();
8826  case eASSIGNMENT_PATTERN:
8827  return FALSE;
8828  case eDOLLAR:
8829  return FALSE;
8830  default:
8831  MASSERT( FALSE );
8832  return 0;
8833  }
8834 
8835 }
8836 
8837 /************************************************
8838  GetWidthExp
8839  - return expression tree for width of
8840  expression, return NULL if not-determinable
8841 **************************************************/
8842 
8844 {
8845  switch( GetOp() ) {
8846  case eERROR: {
8847  CNode* temp0;
8848  CNode* temp1;
8849  CNode* temp2;
8850  return NULL;
8851  }
8852  case eVCONSTANT: {
8853  CNode* temp0;
8854  CNode* temp1;
8855  CNode* temp2;
8856  return Arg<CVector*>(0)->GetWidthExp();
8857  }
8858  case eRCONSTANT: {
8859  CNode* temp0;
8860  CNode* temp1;
8861  CNode* temp2;
8862  return NULL;
8863  }
8864  case eELIST: {
8865  CNode* temp0;
8866  CNode* temp1;
8867  CNode* temp2;
8868  return ((temp0=Arg<CNode*>(0)->GetWidthExp()) && (temp1=Arg<CNode*>(1)->GetWidthExp())) ? cADD_N(temp0,temp1,NULL) : NULL;
8869  }
8870  case eWIDTH: {
8871  CNode* temp0;
8872  CNode* temp1;
8873  CNode* temp2;
8874  return cINT32(Arg<CNode*>(0)->EvalINT32());
8875  }
8876  case eSUB: {
8877  CNode* temp0;
8878  CNode* temp1;
8879  CNode* temp2;
8880  return ((temp0=Arg<CNode*>(0)->GetWidthExp()) && (temp1=Arg<CNode*>(1)->GetWidthExp())) ? cMAX_N(temp0,temp1,NULL) : NULL;
8881  }
8882  case eMUL: {
8883  CNode* temp0;
8884  CNode* temp1;
8885  CNode* temp2;
8886  return ((temp0=Arg<CNode*>(0)->GetWidthExp()) && (temp1=Arg<CNode*>(1)->GetWidthExp())) ? cMAX_N(temp0,temp1,NULL) : NULL;
8887  }
8888  case eDIV: {
8889  CNode* temp0;
8890  CNode* temp1;
8891  CNode* temp2;
8892  return ((temp0=Arg<CNode*>(0)->GetWidthExp()) && (temp1=Arg<CNode*>(1)->GetWidthExp())) ? cMAX_N(temp0,temp1,NULL) : NULL;
8893  }
8894  case ePOW: {
8895  CNode* temp0;
8896  CNode* temp1;
8897  CNode* temp2;
8898  return Arg<CNode*>(0)->GetWidthExp();
8899  }
8900  case eADD: {
8901  CNode* temp0;
8902  CNode* temp1;
8903  CNode* temp2;
8904  return ((temp0=Arg<CNode*>(0)->GetWidthExp()) && (temp1=Arg<CNode*>(1)->GetWidthExp())) ? cMAX_N(temp0,temp1,NULL) : NULL;
8905  }
8906  case eLSH: {
8907  CNode* temp0;
8908  CNode* temp1;
8909  CNode* temp2;
8910  return Arg<CNode*>(0)->GetWidthExp();
8911  }
8912  case eRSH: {
8913  CNode* temp0;
8914  CNode* temp1;
8915  CNode* temp2;
8916  return Arg<CNode*>(0)->GetWidthExp();
8917  }
8918  case eLSHA: {
8919  CNode* temp0;
8920  CNode* temp1;
8921  CNode* temp2;
8922  return Arg<CNode*>(0)->GetWidthExp();
8923  }
8924  case eRSHA: {
8925  CNode* temp0;
8926  CNode* temp1;
8927  CNode* temp2;
8928  return Arg<CNode*>(0)->GetWidthExp();
8929  }
8930  case eMOD: {
8931  CNode* temp0;
8932  CNode* temp1;
8933  CNode* temp2;
8934  return ((temp0=Arg<CNode*>(0)->GetWidthExp()) && (temp1=Arg<CNode*>(1)->GetWidthExp())) ? cMAX_N(temp0,temp1,NULL) : NULL;
8935  }
8936  case eOR: {
8937  CNode* temp0;
8938  CNode* temp1;
8939  CNode* temp2;
8940  return ((temp0=Arg<CNode*>(0)->GetWidthExp()) && (temp1=Arg<CNode*>(1)->GetWidthExp())) ? cMAX_N(temp0,temp1,NULL) : NULL;
8941  }
8942  case eAND: {
8943  CNode* temp0;
8944  CNode* temp1;
8945  CNode* temp2;
8946  return ((temp0=Arg<CNode*>(0)->GetWidthExp()) && (temp1=Arg<CNode*>(1)->GetWidthExp())) ? cMAX_N(temp0,temp1,NULL) : NULL;
8947  }
8948  case eANDANDAND: {
8949  CNode* temp0;
8950  CNode* temp1;
8951  CNode* temp2;
8952  return ((temp0=Arg<CNode*>(0)->GetWidthExp()) && (temp1=Arg<CNode*>(1)->GetWidthExp())) ? cMAX_N(temp0,temp1,NULL) : NULL;
8953  }
8954  case eXOR: {
8955  CNode* temp0;
8956  CNode* temp1;
8957  CNode* temp2;
8958  return ((temp0=Arg<CNode*>(0)->GetWidthExp()) && (temp1=Arg<CNode*>(1)->GetWidthExp())) ? cMAX_N(temp0,temp1,NULL) : NULL;
8959  }
8960  case eXNOR: {
8961  CNode* temp0;
8962  CNode* temp1;
8963  CNode* temp2;
8964  return ((temp0=Arg<CNode*>(0)->GetWidthExp()) && (temp1=Arg<CNode*>(1)->GetWidthExp())) ? cMAX_N(temp0,temp1,NULL) : NULL;
8965  }
8966  case eSYSTASK_CALL: {
8967  CNode* temp0;
8968  CNode* temp1;
8969  CNode* temp2;
8970  return Systask::WidthExp(Arg<CSymbol*>(0),Arg<CNode*>(1));
8971  }
8972  case eFUNCTION_CALL: {
8973  CNode* temp0;
8974  CNode* temp1;
8975  CNode* temp2;
8976  return CFunction::WidthExp(Arg<CSymbol*>(0),Arg<CNode*>(1),Arg<CScope*>(2));
8977  }
8978  case eARRAY: {
8979  CNode* temp0;
8980  CNode* temp1;
8981  CNode* temp2;
8982  return Array::WidthExp(Arg<CNode*>(0),Arg<CNode*>(1));
8983  }
8984  case eNET_REF: {
8985  CNode* temp0;
8986  CNode* temp1;
8987  CNode* temp2;
8988  return Arg<CNet*>(0)->GetWidthExp();
8989  }
8990  case eVAR_REF: {
8991  CNode* temp0;
8992  CNode* temp1;
8993  CNode* temp2;
8994  return Arg<CVar*>(0)->GetWidthExp();
8995  }
8996  case ePARAM_REF: {
8997  CNode* temp0;
8998  CNode* temp1;
8999  CNode* temp2;
9000  return Arg<CParam*>(0)->GetWidthExp();
9001  }
9002  case ePORT_REF: {
9003  CNode* temp0;
9004  CNode* temp1;
9005  CNode* temp2;
9006  return Arg<CPortDir*>(0)->GetWidthExp();
9007  }
9008  case eFWD_REF: {
9009  CNode* temp0;
9010  CNode* temp1;
9011  CNode* temp2;
9012  return Arg<CFref*>(0)->GetWidthExp();
9013  }
9014  case eGENVAR_REF: {
9015  CNode* temp0;
9016  CNode* temp1;
9017  CNode* temp2;
9018  return Arg<CGenvar*>(0)->GetWidthExp();
9019  }
9020  case eENUM_REF: {
9021  CNode* temp0;
9022  CNode* temp1;
9023  CNode* temp2;
9024  return Arg<CEnum*>(0)->GetWidthExp();
9025  }
9026  case eTYPE_REF: {
9027  CNode* temp0;
9028  CNode* temp1;
9029  CNode* temp2;
9030  return cINT32(32);
9031  }
9032  case eRANGE: {
9033  CNode* temp0;
9034  CNode* temp1;
9035  CNode* temp2;
9036  return (1 && 1) ? cABSDIFFPLUS1_N(Arg<CNode*>(0)->Clone(),Arg<CNode*>(1)->Clone(),NULL) : NULL;
9037  }
9038  case eSLICE: {
9039  CNode* temp0;
9040  CNode* temp1;
9041  CNode* temp2;
9042  return (1 && 1) ? cABSDIFFPLUS1_N(Arg<CNode*>(0)->Clone(),Arg<CNode*>(1)->Clone(),NULL) : NULL;
9043  }
9044  case ePSLICE: {
9045  CNode* temp0;
9046  CNode* temp1;
9047  CNode* temp2;
9048  return Arg<CNode*>(1);
9049  }
9050  case eMSLICE: {
9051  CNode* temp0;
9052  CNode* temp1;
9053  CNode* temp2;
9054  return Arg<CNode*>(1);
9055  }
9056  case eCVRI: {
9057  CNode* temp0;
9058  CNode* temp1;
9059  CNode* temp2;
9060  return cINT32(32);
9061  }
9062  case eCVIR: {
9063  CNode* temp0;
9064  CNode* temp1;
9065  CNode* temp2;
9066  return NULL;
9067  }
9068  case eREP: {
9069  CNode* temp0;
9070  CNode* temp1;
9071  CNode* temp2;
9072  return (1 && (temp1=Arg<CNode*>(1)->GetWidthExp())) ? cMUL_N(Arg<CNode*>(0)->Clone(),temp1,NULL) : NULL;
9073  }
9074  case eCAT: {
9075  CNode* temp0;
9076  CNode* temp1;
9077  CNode* temp2;
9078  return ((temp0=Arg<CNode*>(0)->GetWidthExp()) && (temp1=Arg<CNode*>(1)->GetWidthExp())) ? cADD_N(temp0,temp1,NULL) : NULL;
9079  }
9080  case eUCAT: {
9081  CNode* temp0;
9082  CNode* temp1;
9083  CNode* temp2;
9084  return Arg<CNode*>(0)->GetWidthExp();
9085  }
9086  case eCOM: {
9087  CNode* temp0;
9088  CNode* temp1;
9089  CNode* temp2;
9090  return Arg<CNode*>(0)->GetWidthExp();
9091  }
9092  case eNEG: {
9093  CNode* temp0;
9094  CNode* temp1;
9095  CNode* temp2;
9096  return Arg<CNode*>(0)->GetWidthExp();
9097  }
9098  case ePLUS: {
9099  CNode* temp0;
9100  CNode* temp1;
9101  CNode* temp2;
9102  return Arg<CNode*>(0)->GetWidthExp();
9103  }
9104  case eNOT: {
9105  CNode* temp0;
9106  CNode* temp1;
9107  CNode* temp2;
9108  return cINT32(1);
9109  }
9110  case eGT: {
9111  CNode* temp0;
9112  CNode* temp1;
9113  CNode* temp2;
9114  return cINT32(1);
9115  }
9116  case eGE: {
9117  CNode* temp0;
9118  CNode* temp1;
9119  CNode* temp2;
9120  return cINT32(1);
9121  }
9122  case eLT: {
9123  CNode* temp0;
9124  CNode* temp1;
9125  CNode* temp2;
9126  return cINT32(1);
9127  }
9128  case eLE: {
9129  CNode* temp0;
9130  CNode* temp1;
9131  CNode* temp2;
9132  return cINT32(1);
9133  }
9134  case eLAND: {
9135  CNode* temp0;
9136  CNode* temp1;
9137  CNode* temp2;
9138  return cINT32(1);
9139  }
9140  case eLOR: {
9141  CNode* temp0;
9142  CNode* temp1;
9143  CNode* temp2;
9144  return cINT32(1);
9145  }
9146  case eCEQ: {
9147  CNode* temp0;
9148  CNode* temp1;
9149  CNode* temp2;
9150  return cINT32(1);
9151  }
9152  case eCNE: {
9153  CNode* temp0;
9154  CNode* temp1;
9155  CNode* temp2;
9156  return cINT32(1);
9157  }
9158  case eEQ: {
9159  CNode* temp0;
9160  CNode* temp1;
9161  CNode* temp2;
9162  return cINT32(1);
9163  }
9164  case eNE: {
9165  CNode* temp0;
9166  CNode* temp1;
9167  CNode* temp2;
9168  return cINT32(1);
9169  }
9170  case eRAND: {
9171  CNode* temp0;
9172  CNode* temp1;
9173  CNode* temp2;
9174  return cINT32(1);
9175  }
9176  case eRNAND: {
9177  CNode* temp0;
9178  CNode* temp1;
9179  CNode* temp2;
9180  return cINT32(1);
9181  }
9182  case eROR: {
9183  CNode* temp0;
9184  CNode* temp1;
9185  CNode* temp2;
9186  return cINT32(1);
9187  }
9188  case eRNOR: {
9189  CNode* temp0;
9190  CNode* temp1;
9191  CNode* temp2;
9192  return cINT32(1);
9193  }
9194  case eRXOR: {
9195  CNode* temp0;
9196  CNode* temp1;
9197  CNode* temp2;
9198  return cINT32(1);
9199  }
9200  case eRXNOR: {
9201  CNode* temp0;
9202  CNode* temp1;
9203  CNode* temp2;
9204  return cINT32(1);
9205  }
9206  case eHOOK: {
9207  CNode* temp0;
9208  CNode* temp1;
9209  CNode* temp2;
9210  return ((temp1=Arg<CNode*>(1)->GetWidthExp()) && (temp2=Arg<CNode*>(2)->GetWidthExp())) ? cMAX_N(temp1,temp2,NULL) : NULL;
9211  }
9212  case eMTM: {
9213  CNode* temp0;
9214  CNode* temp1;
9215  CNode* temp2;
9216  return ((temp0=Arg<CNode*>(0)->GetWidthExp()) && (temp1=Arg<CNode*>(1)->GetWidthExp()) && (temp2=Arg<CNode*>(2)->GetWidthExp())) ? cMAX_N(temp0,temp1,temp2,NULL) : NULL;
9217  }
9218  case eEXTERNAL_REF: {
9219  CNode* temp0;
9220  CNode* temp1;
9221  CNode* temp2;
9222  return External::WidthExp(Arg<CSymbol*>(0));
9223  }
9224  case eATTRIBUTE: {
9225  CNode* temp0;
9226  CNode* temp1;
9227  CNode* temp2;
9228  return cINT32(0);
9229  }
9230  case eMACRO_EXPR: {
9231  CNode* temp0;
9232  CNode* temp1;
9233  CNode* temp2;
9234  return Arg<CNode*>(1)->GetWidthExp();
9235  }
9236  case eMEMBER: {
9237  CNode* temp0;
9238  CNode* temp1;
9239  CNode* temp2;
9240  return Member::WidthExp(Arg<CNode*>(0),Arg<CSymbol*>(1));
9241  }
9242  case ePREINC: {
9243  CNode* temp0;
9244  CNode* temp1;
9245  CNode* temp2;
9246  return Arg<CNode*>(0)->GetWidthExp();
9247  }
9248  case ePOSTINC: {
9249  CNode* temp0;
9250  CNode* temp1;
9251  CNode* temp2;
9252  return Arg<CNode*>(0)->GetWidthExp();
9253  }
9254  case ePREDEC: {
9255  CNode* temp0;
9256  CNode* temp1;
9257  CNode* temp2;
9258  return Arg<CNode*>(0)->GetWidthExp();
9259  }
9260  case ePOSTDEC: {
9261  CNode* temp0;
9262  CNode* temp1;
9263  CNode* temp2;
9264  return Arg<CNode*>(0)->GetWidthExp();
9265  }
9266  case eCAST: {
9267  CNode* temp0;
9268  CNode* temp1;
9269  CNode* temp2;
9270  return Arg<CNode*>(0)->GetWidthExp();
9271  }
9272  case eASSIGNMENT_PATTERN: {
9273  CNode* temp0;
9274  CNode* temp1;
9275  CNode* temp2;
9276  return NULL;
9277  }
9278  case eDOLLAR: {
9279  CNode* temp0;
9280  CNode* temp1;
9281  CNode* temp2;
9282  return NULL;
9283  }
9284  default:
9285  MASSERT( FALSE );
9286  return NULL;
9287  }
9288 }
9289 
9290 /************************************************
9291  IsWidthEvaluateable
9292  - return true if expression width can be evaluated
9293 **************************************************/
9294 
9296 {
9297  switch( GetOp() ) {
9298  case eERROR:
9299  return FALSE;
9300  case eVCONSTANT:
9301  return Arg<CVector*>(0)->IsWidthEvaluateable();
9302  case eRCONSTANT:
9303  return FALSE;
9304  case eELIST:
9305  return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
9306  case eWIDTH:
9307  return Arg<CNode*>(0)->IsEvaluateable();
9308  case eSUB:
9309  return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
9310  case eMUL:
9311  return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
9312  case eDIV:
9313  return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
9314  case ePOW:
9315  return Arg<CNode*>(0)->IsWidthEvaluateable();
9316  case eADD:
9317  return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
9318  case eLSH:
9319  return Arg<CNode*>(0)->IsWidthEvaluateable();
9320  case eRSH:
9321  return Arg<CNode*>(0)->IsWidthEvaluateable();
9322  case eLSHA:
9323  return Arg<CNode*>(0)->IsWidthEvaluateable();
9324  case eRSHA:
9325  return Arg<CNode*>(0)->IsWidthEvaluateable();
9326  case eMOD:
9327  return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
9328  case eOR:
9329  return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
9330  case eAND:
9331  return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
9332  case eANDANDAND:
9333  return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
9334  case eXOR:
9335  return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
9336  case eXNOR:
9337  return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
9338  case eSYSTASK_CALL:
9339  return Systask::WidthEvaluateable(Arg<CSymbol*>(0),Arg<CNode*>(1));
9340  case eFUNCTION_CALL:
9341  return CFunction::WidthEvaluateable(Arg<CSymbol*>(0),Arg<CNode*>(1),Arg<CScope*>(2));
9342  case eARRAY:
9343  return Array::WidthEvaluateable(Arg<CNode*>(0),Arg<CNode*>(1));
9344  case eNET_REF:
9345  return Arg<CNet*>(0)->IsWidthEvaluateable();
9346  case eVAR_REF:
9347  return Arg<CVar*>(0)->IsWidthEvaluateable();
9348  case ePARAM_REF:
9349  return Arg<CParam*>(0)->IsWidthEvaluateable();
9350  case ePORT_REF:
9351  return Arg<CPortDir*>(0)->IsWidthEvaluateable();
9352  case eFWD_REF:
9353  return Arg<CFref*>(0)->IsWidthEvaluateable();
9354  case eGENVAR_REF:
9355  return Arg<CGenvar*>(0)->IsWidthEvaluateable();
9356  case eENUM_REF:
9357  return Arg<CEnum*>(0)->IsWidthEvaluateable();
9358  case eTYPE_REF:
9359  return TRUE;
9360  case eRANGE:
9361  return Arg<CNode*>(0)->IsEvaluateable() && Arg<CNode*>(1)->IsEvaluateable();
9362  case eSLICE:
9363  return Arg<CNode*>(0)->IsEvaluateable() && Arg<CNode*>(1)->IsEvaluateable();
9364  case ePSLICE:
9365  return Arg<CNode*>(1)->IsEvaluateable();
9366  case eMSLICE:
9367  return Arg<CNode*>(1)->IsEvaluateable();
9368  case eCVRI:
9369  return TRUE;
9370  case eCVIR:
9371  return FALSE;
9372  case eREP:
9373  return Arg<CNode*>(0)->IsEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
9374  case eCAT:
9375  return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
9376  case eUCAT:
9377  return Arg<CNode*>(0)->IsWidthEvaluateable();
9378  case eCOM:
9379  return Arg<CNode*>(0)->IsWidthEvaluateable();
9380  case eNEG:
9381  return Arg<CNode*>(0)->IsWidthEvaluateable();
9382  case ePLUS:
9383  return Arg<CNode*>(0)->IsWidthEvaluateable();
9384  case eNOT:
9385  return TRUE;
9386  case eGT:
9387  return TRUE;
9388  case eGE:
9389  return TRUE;
9390  case eLT:
9391  return TRUE;
9392  case eLE:
9393  return TRUE;
9394  case eLAND:
9395  return TRUE;
9396  case eLOR:
9397  return TRUE;
9398  case eCEQ:
9399  return TRUE;
9400  case eCNE:
9401  return TRUE;
9402  case eEQ:
9403  return TRUE;
9404  case eNE:
9405  return TRUE;
9406  case eRAND:
9407  return TRUE;
9408  case eRNAND:
9409  return TRUE;
9410  case eROR:
9411  return TRUE;
9412  case eRNOR:
9413  return TRUE;
9414  case eRXOR:
9415  return TRUE;
9416  case eRXNOR:
9417  return TRUE;
9418  case eHOOK:
9419  return Arg<CNode*>(1)->IsWidthEvaluateable() && Arg<CNode*>(2)->IsWidthEvaluateable();
9420  case eMTM:
9421  return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable() && Arg<CNode*>(2)->IsWidthEvaluateable();
9422  case eEXTERNAL_REF:
9423  return External::WidthEvaluateable(Arg<CSymbol*>(0));
9424  case eATTRIBUTE:
9425  return TRUE;
9426  case eMACRO_EXPR:
9427  return Arg<CNode*>(1)->IsWidthEvaluateable();
9428  case eMEMBER:
9429  return Member::WidthEvaluateable(Arg<CNode*>(0),Arg<CSymbol*>(1));
9430  case ePREINC:
9431  return Arg<CNode*>(0)->IsWidthEvaluateable();
9432  case ePOSTINC:
9433  return Arg<CNode*>(0)->IsWidthEvaluateable();
9434  case ePREDEC:
9435  return Arg<CNode*>(0)->IsWidthEvaluateable();
9436  case ePOSTDEC:
9437  return Arg<CNode*>(0)->IsWidthEvaluateable();
9438  case eCAST:
9439  return Arg<CNode*>(0)->IsWidthEvaluateable();
9440  case eASSIGNMENT_PATTERN:
9441  return FALSE;
9442  case eDOLLAR:
9443  return FALSE;
9444  default:
9445  MASSERT( FALSE );
9446  return 0;
9447  }
9448 }
9449 
9450 /************************************************
9451  IsNonX
9452  - return true if expression cannot be X(or Z)
9453  exclude any variable with attribute
9454  specified by exclude and optionally integers.
9455 **************************************************/
9456 
9457 int CNode::IsNonX( int integerIsNonX, char* exclude )
9458 {
9459  switch( GetOp() ) {
9460  case eERROR:
9461  return FALSE;
9462  case eVCONSTANT:
9463  return !Arg<CVector*>(0)->HasXZ();
9464  case eRCONSTANT:
9465  return TRUE;
9466  case eELIST:
9467  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9468  case eWIDTH:
9469  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9470  case eSUB:
9471  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9472  case eMUL:
9473  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9474  case eDIV:
9475  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9476  case ePOW:
9477  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9478  case eADD:
9479  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9480  case eLSH:
9481  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9482  case eRSH:
9483  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9484  case eLSHA:
9485  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9486  case eRSHA:
9487  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9488  case eMOD:
9489  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9490  case eOR:
9491  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9492  case eAND:
9493  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9494  case eANDANDAND:
9495  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9496  case eXOR:
9497  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9498  case eXNOR:
9499  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9500  case eSYSTASK_CALL:
9501  return FALSE;
9502  case eFUNCTION_CALL:
9503  return FALSE;
9504  case eARRAY:
9505  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9506  case eNET_REF:
9507  return Arg<CDecl*>(0)->HasAttribute( exclude ) ||
9508 
9509  (integerIsNonX && Arg<CDecl*>(0)->GetDataType()->GetVarDataType() == eINT);
9510  case eVAR_REF:
9511  return Arg<CDecl*>(0)->GetDataType()->GetTwoState() ||
9512 
9513  Arg<CDecl*>(0)->GetNodeType() == eR ||
9514 
9515  Arg<CDecl*>(0)->HasAttribute( exclude ) ||
9516 
9517  (integerIsNonX && Arg<CDecl*>(0)->GetDataType()->GetVarDataType() == eINTEGER);
9518  case ePARAM_REF:
9519  return TRUE;
9520  case ePORT_REF:
9521  return Arg<CDecl*>(0)->HasAttribute( exclude ) ||
9522 
9523  (integerIsNonX && Arg<CDecl*>(0)->GetDataType()->GetVarDataType() == eINT);
9524  case eFWD_REF:
9525  return FALSE;
9526  case eGENVAR_REF:
9527  return TRUE;
9528  case eENUM_REF:
9529  return Arg<CEnum*>(0)->GetExpression()->IsNonX( integerIsNonX, exclude );
9530  case eTYPE_REF:
9531  return TRUE;
9532  case eRANGE:
9533  return FALSE;
9534  case eSLICE:
9535  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9536  case ePSLICE:
9537  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9538  case eMSLICE:
9539  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9540  case eCVRI:
9541  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9542  case eCVIR:
9543  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9544  case eREP:
9545  return Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9546  case eCAT:
9547  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9548  case eUCAT:
9549  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9550  case eCOM:
9551  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9552  case eNEG:
9553  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9554  case ePLUS:
9555  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9556  case eNOT:
9557  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9558  case eGT:
9559  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9560  case eGE:
9561  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9562  case eLT:
9563  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9564  case eLE:
9565  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9566  case eLAND:
9567  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9568  case eLOR:
9569  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9570  case eCEQ:
9571  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9572  case eCNE:
9573  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9574  case eEQ:
9575  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9576  case eNE:
9577  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9578  case eRAND:
9579  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9580  case eRNAND:
9581  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9582  case eROR:
9583  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9584  case eRNOR:
9585  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9586  case eRXOR:
9587  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9588  case eRXNOR:
9589  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9590  case eHOOK:
9591  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(2)->IsNonX( integerIsNonX, exclude );
9592  case ePOSEDGE:
9593  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9594  case eNEGEDGE:
9595  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9596  case eEVOR:
9597  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9598  case eMTM:
9599  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(2)->IsNonX( integerIsNonX, exclude );
9600  case eEXTERNAL_REF:
9601  return FALSE;
9602  case eMACRO_EXPR:
9603  return Arg<CNode*>(1) ? Arg<CNode*>(1)->IsNonX(integerIsNonX, exclude) : FALSE;
9604  case eMEMBER:
9605  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9606  case ePREINC:
9607  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9608  case ePOSTINC:
9609  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9610  case ePREDEC:
9611  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9612  case ePOSTDEC:
9613  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9614  case eCAST:
9615  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9616  case eASSIGNMENT_PATTERN:
9617  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9618  case eDOLLAR:
9619  return FALSE;
9620  default:
9621  MASSERT( FALSE );
9622  return 0;
9623  }
9624 }
9625 
9626 /***********************************************
9627  Clone
9628  - clone a copy of this tree use
9629  stack)for storage
9630 ************************************************/
9631 
9633 {
9634  int nodeMask = 0;
9635  switch( GetOp() ) {
9636  case eERROR:
9637  nodeMask = 0;
9638  break;
9639  case eVCONSTANT:
9640  nodeMask = 0;
9641  break;
9642  case eRCONSTANT:
9643  nodeMask = 0;
9644  break;
9645  case eCOMMENT:
9646  nodeMask = 0;
9647  break;
9648  case eVRQ:
9649  nodeMask = 0;
9650  break;
9651  case ePRAGMA:
9652  nodeMask = 0;
9653  break;
9654  case eELIST:
9655  nodeMask = 3;
9656  break;
9657  case eWIDTH:
9658  nodeMask = 3;
9659  break;
9660  case eNOP:
9661  nodeMask = 0;
9662  break;
9663  case eSUB:
9664  nodeMask = 3;
9665  break;
9666  case eMUL:
9667  nodeMask = 3;
9668  break;
9669  case eDIV:
9670  nodeMask = 3;
9671  break;
9672  case ePOW:
9673  nodeMask = 3;
9674  break;
9675  case eADD:
9676  nodeMask = 3;
9677  break;
9678  case eLSH:
9679  nodeMask = 3;
9680  break;
9681  case eRSH:
9682  nodeMask = 3;
9683  break;
9684  case eLSHA:
9685  nodeMask = 3;
9686  break;
9687  case eRSHA:
9688  nodeMask = 3;
9689  break;
9690  case eMOD:
9691  nodeMask = 3;
9692  break;
9693  case eOR:
9694  nodeMask = 3;
9695  break;
9696  case eAND:
9697  nodeMask = 3;
9698  break;
9699  case eANDANDAND:
9700  nodeMask = 3;
9701  break;
9702  case eXOR:
9703  nodeMask = 3;
9704  break;
9705  case eXNOR:
9706  nodeMask = 3;
9707  break;
9708  case eINSTANCE_REF:
9709  nodeMask = 0;
9710  break;
9711  case eGATE_REF:
9712  nodeMask = 0;
9713  break;
9714  case eTASK_ENABLE:
9715  nodeMask = 2;
9716  break;
9717  case eSYSTASK_CALL:
9718  nodeMask = 2;
9719  break;
9720  case eTIMING_CALL:
9721  nodeMask = 2;
9722  break;
9723  case eFUNCTION_CALL:
9724  nodeMask = 2;
9725  break;
9726  case eARRAY:
9727  nodeMask = 3;
9728  break;
9729  case eNET_REF:
9730  nodeMask = 0;
9731  break;
9732  case eVAR_REF:
9733  nodeMask = 0;
9734  break;
9735  case ePARAM_REF:
9736  nodeMask = 0;
9737  break;
9738  case ePORT_REF:
9739  nodeMask = 0;
9740  break;
9741  case eFWD_REF:
9742  nodeMask = 0;
9743  break;
9744  case eGENVAR_REF:
9745  nodeMask = 0;
9746  break;
9747  case eENUM_REF:
9748  nodeMask = 0;
9749  break;
9750  case eTYPE_REF:
9751  nodeMask = 0;
9752  break;
9753  case eNET_DECL:
9754  nodeMask = 2;
9755  break;
9756  case eVAR_DECL:
9757  nodeMask = 2;
9758  break;
9759  case ePARAM_DECL:
9760  nodeMask = 0;
9761  break;
9762  case eSPECPARAM_DECL:
9763  nodeMask = 0;
9764  break;
9765  case ePORT_DECL:
9766  nodeMask = 0;
9767  break;
9768  case eGENVAR_DECL:
9769  nodeMask = 0;
9770  break;
9771  case eTYPEDEF_DECL:
9772  nodeMask = 0;
9773  break;
9774  case eLIST:
9775  nodeMask = 3;
9776  break;
9777  case eRANGE:
9778  nodeMask = 3;
9779  break;
9780  case eSLICE:
9781  nodeMask = 3;
9782  break;
9783  case ePSLICE:
9784  nodeMask = 3;
9785  break;
9786  case eMSLICE:
9787  nodeMask = 3;
9788  break;
9789  case eCVRI:
9790  nodeMask = 1;
9791  break;
9792  case eCVIR:
9793  nodeMask = 1;
9794  break;
9795  case eREP:
9796  nodeMask = 3;
9797  break;
9798  case eCAT:
9799  nodeMask = 3;
9800  break;
9801  case eUCAT:
9802  nodeMask = 1;
9803  break;
9804  case eCOM:
9805  nodeMask = 1;
9806  break;
9807  case eNEG:
9808  nodeMask = 1;
9809  break;
9810  case ePLUS:
9811  nodeMask = 1;
9812  break;
9813  case eNOT:
9814  nodeMask = 1;
9815  break;
9816  case eGT:
9817  nodeMask = 3;
9818  break;
9819  case eGE:
9820  nodeMask = 3;
9821  break;
9822  case eLT:
9823  nodeMask = 3;
9824  break;
9825  case eLE:
9826  nodeMask = 3;
9827  break;
9828  case eLAND:
9829  nodeMask = 3;
9830  break;
9831  case eLOR:
9832  nodeMask = 3;
9833  break;
9834  case eCEQ:
9835  nodeMask = 3;
9836  break;
9837  case eCNE:
9838  nodeMask = 3;
9839  break;
9840  case eEQ:
9841  nodeMask = 3;
9842  break;
9843  case eNE:
9844  nodeMask = 3;
9845  break;
9846  case eRAND:
9847  nodeMask = 1;
9848  break;
9849  case eRNAND:
9850  nodeMask = 1;
9851  break;
9852  case eROR:
9853  nodeMask = 1;
9854  break;
9855  case eRNOR:
9856  nodeMask = 1;
9857  break;
9858  case eRXOR:
9859  nodeMask = 1;
9860  break;
9861  case eRXNOR:
9862  nodeMask = 1;
9863  break;
9864  case eHOOK:
9865  nodeMask = 7;
9866  break;
9867  case eINIT:
9868  nodeMask = 1;
9869  break;
9870  case eALWAYS:
9871  nodeMask = 1;
9872  break;
9873  case eALWAYS_LATCH:
9874  nodeMask = 1;
9875  break;
9876  case eALWAYS_FF:
9877  nodeMask = 1;
9878  break;
9879  case eALWAYS_COMB:
9880  nodeMask = 1;
9881  break;
9882  case eEVENT:
9883  nodeMask = 3;
9884  break;
9885  case eBLOCK_REF:
9886  nodeMask = 2;
9887  break;
9888  case eSPECIFY_REF:
9889  nodeMask = 2;
9890  break;
9891  case eASSIGN:
9892  nodeMask = 7;
9893  break;
9894  case eGASSIGN:
9895  nodeMask = 6;
9896  break;
9897  case eADD_ASSIGN:
9898  nodeMask = 7;
9899  break;
9900  case eSUB_ASSIGN:
9901  nodeMask = 7;
9902  break;
9903  case eMUL_ASSIGN:
9904  nodeMask = 7;
9905  break;
9906  case eDIV_ASSIGN:
9907  nodeMask = 7;
9908  break;
9909  case eMOD_ASSIGN:
9910  nodeMask = 7;
9911  break;
9912  case eAND_ASSIGN:
9913  nodeMask = 7;
9914  break;
9915  case eOR_ASSIGN:
9916  nodeMask = 7;
9917  break;
9918  case eXOR_ASSIGN:
9919  nodeMask = 7;
9920  break;
9921  case eLSH_ASSIGN:
9922  nodeMask = 7;
9923  break;
9924  case eRSH_ASSIGN:
9925  nodeMask = 7;
9926  break;
9927  case eLSHA_ASSIGN:
9928  nodeMask = 7;
9929  break;
9930  case eRSHA_ASSIGN:
9931  nodeMask = 7;
9932  break;
9933  case eFORCE:
9934  nodeMask = 3;
9935  break;
9936  case eRELEASE:
9937  nodeMask = 1;
9938  break;
9939  case eNBASSIGN:
9940  nodeMask = 7;
9941  break;
9942  case ePOSEDGE:
9943  nodeMask = 1;
9944  break;
9945  case eNEGEDGE:
9946  nodeMask = 1;
9947  break;
9948  case eEDGE:
9949  nodeMask = 1;
9950  break;
9951  case eEVOR:
9952  nodeMask = 3;
9953  break;
9954  case eDELAY:
9955  nodeMask = 3;
9956  break;
9957  case eMTM:
9958  nodeMask = 7;
9959  break;
9960  case eIF:
9961  nodeMask = 7;
9962  break;
9963  case eFOREVER:
9964  nodeMask = 1;
9965  break;
9966  case eREPEAT:
9967  nodeMask = 3;
9968  break;
9969  case eWHILE:
9970  nodeMask = 3;
9971  break;
9972  case eWAIT:
9973  nodeMask = 3;
9974  break;
9975  case eFOR:
9976  nodeMask = 15;
9977  break;
9978  case eCASE:
9979  nodeMask = 3;
9980  break;
9981  case eCASEX:
9982  nodeMask = 3;
9983  break;
9984  case eCASEZ:
9985  nodeMask = 3;
9986  break;
9987  case eCASEITEM:
9988  nodeMask = 3;
9989  break;
9990  case eCASSIGN:
9991  nodeMask = 14;
9992  break;
9993  case eARG:
9994  nodeMask = 2;
9995  break;
9996  case eIMPORT:
9997  nodeMask = 0;
9998  break;
9999  case eFUNCTION_DEF:
10000  nodeMask = 0;
10001  break;
10002  case eMODULE_DEF:
10003  nodeMask = 0;
10004  break;
10005  case ePACKAGE_DEF:
10006  nodeMask = 0;
10007  break;
10008  case eREPEAT_CONTROL:
10009  nodeMask = 3;
10010  break;
10011  case eDELAY_CONTROL:
10012  nodeMask = 1;
10013  break;
10014  case eEVENT_CONTROL:
10015  nodeMask = 1;
10016  break;
10017  case eEXTERNAL_REF:
10018  nodeMask = 0;
10019  break;
10020  case ePORT_DEF:
10021  nodeMask = 0;
10022  break;
10023  case eDEFPARAM:
10024  nodeMask = 3;
10025  break;
10026  case ePATH:
10027  nodeMask = 82;
10028  break;
10029  case ePATH_ASSIGN:
10030  nodeMask = 7;
10031  break;
10032  case eIFNONE_PATH_ASSIGN:
10033  nodeMask = 3;
10034  break;
10035  case eTRIGGER:
10036  nodeMask = 1;
10037  break;
10038  case ePASSIGN:
10039  nodeMask = 3;
10040  break;
10041  case eDEASSIGN:
10042  nodeMask = 1;
10043  break;
10044  case eDISABLE:
10045  nodeMask = 0;
10046  break;
10047  case eATTRIBUTE:
10048  nodeMask = 0;
10049  break;
10050  case eGIF:
10051  nodeMask = 7;
10052  break;
10053  case eGFOR:
10054  nodeMask = 15;
10055  break;
10056  case eGCASE:
10057  nodeMask = 3;
10058  break;
10059  case eTABLE:
10060  nodeMask = 1;
10061  break;
10062  case eTABLE_ENTRY:
10063  nodeMask = 1;
10064  break;
10065  case eTABLE_SYMBOL:
10066  nodeMask = 0;
10067  break;
10068  case ePORTLIST_END:
10069  nodeMask = 0;
10070  break;
10071  case eMACRO_EXPR:
10072  nodeMask = 2;
10073  break;
10074  case eENUM_SPEC:
10075  nodeMask = 6;
10076  break;
10077  case eMEMBER:
10078  nodeMask = 1;
10079  break;
10080  case eRETURN:
10081  nodeMask = 1;
10082  break;
10083  case ePREINC:
10084  nodeMask = 1;
10085  break;
10086  case ePOSTINC:
10087  nodeMask = 1;
10088  break;
10089  case ePREDEC:
10090  nodeMask = 1;
10091  break;
10092  case ePOSTDEC:
10093  nodeMask = 1;
10094  break;
10095  case eCAST:
10096  nodeMask = 3;
10097  break;
10098  case eASSIGNMENT_PATTERN:
10099  nodeMask = 1;
10100  break;
10101  case eDOLLAR:
10102  nodeMask = 0;
10103  break;
10104  default:
10105  MASSERT( FALSE );
10106  }
10107 
10108  CNode* n = new(stack) CNode( &loc, op );
10109  n->width = width;
10110  n->type = type;
10111  n->fixedWidth = fixedWidth;
10112  if( attributes ) {
10113  n->attributes = attributes->Clone(heap);
10114  }
10115  for( int i = 0; i < ArgCount(); i++ ) {
10116  if( ((nodeMask>>i)&1) && Arg<CNode*>(i) ) {
10117  n->Arg<CNode*>(i) = Arg<CNode*>(i)->Clone(heap);
10118  } else {
10119  void* tmp = Arg<void*>(i);
10120  n->Arg<void*>(i) = tmp;
10121  }
10122  }
10123  return n;
10124 }
10125 
10126 
10127 /***********************************************
10128  PreVisit1
10129  - traverse tree, evoking
10130  parent then leaves.
10131  Callback may terminate traversal of subtree early.
10132 ************************************************/
10133 
10134 void CNode::PreVisit1( int (*func)(CNode*, void*), void* data )
10135 {
10136  if( !(*func)( this, data ) ) {
10137  return;
10138  }
10139 
10140  if( GetAttributes() ) {
10141  GetAttributes()->PreVisit1( func, data );
10142  }
10143 
10144  int nodeMask = 0;
10145  switch( GetOp() ) {
10146  case eERROR:
10147  nodeMask = 0;
10148  break;
10149  case eVCONSTANT:
10150  nodeMask = 1;
10151  break;
10152  case eRCONSTANT:
10153  nodeMask = 1;
10154  break;
10155  case eCOMMENT:
10156  nodeMask = 1;
10157  break;
10158  case eVRQ:
10159  nodeMask = 1;
10160  break;
10161  case ePRAGMA:
10162  nodeMask = 3;
10163  break;
10164  case eELIST:
10165  nodeMask = 0;
10166  break;
10167  case eWIDTH:
10168  nodeMask = 0;
10169  break;
10170  case eNOP:
10171  nodeMask = 0;
10172  break;
10173  case eSUB:
10174  nodeMask = 0;
10175  break;
10176  case eMUL:
10177  nodeMask = 0;
10178  break;
10179  case eDIV:
10180  nodeMask = 0;
10181  break;
10182  case ePOW:
10183  nodeMask = 0;
10184  break;
10185  case eADD:
10186  nodeMask = 0;
10187  break;
10188  case eLSH:
10189  nodeMask = 0;
10190  break;
10191  case eRSH:
10192  nodeMask = 0;
10193  break;
10194  case eLSHA:
10195  nodeMask = 0;
10196  break;
10197  case eRSHA:
10198  nodeMask = 0;
10199  break;
10200  case eMOD:
10201  nodeMask = 0;
10202  break;
10203  case eOR:
10204  nodeMask = 0;
10205  break;
10206  case eAND:
10207  nodeMask = 0;
10208  break;
10209  case eANDANDAND:
10210  nodeMask = 0;
10211  break;
10212  case eXOR:
10213  nodeMask = 0;
10214  break;
10215  case eXNOR:
10216  nodeMask = 0;
10217  break;
10218  case eINSTANCE_REF:
10219  nodeMask = 1;
10220  if(Arg<CInstance*>(0)) Arg<CInstance*>(0)->PreVisit1( func, data );
10221  break;
10222  case eGATE_REF:
10223  nodeMask = 1;
10224  if(Arg<CGate*>(0)) Arg<CGate*>(0)->PreVisit1( func, data );
10225  break;
10226  case eTASK_ENABLE:
10227  nodeMask = 1;
10228  break;
10229  case eSYSTASK_CALL:
10230  nodeMask = 1;
10231  break;
10232  case eTIMING_CALL:
10233  nodeMask = 1;
10234  break;
10235  case eFUNCTION_CALL:
10236  nodeMask = 5;
10237  break;
10238  case eARRAY:
10239  nodeMask = 0;
10240  break;
10241  case eNET_REF:
10242  return;
10243  case eVAR_REF:
10244  return;
10245  case ePARAM_REF:
10246  return;
10247  case ePORT_REF:
10248  return;
10249  case eFWD_REF:
10250  return;
10251  case eGENVAR_REF:
10252  return;
10253  case eENUM_REF:
10254  return;
10255  case eTYPE_REF:
10256  return;
10257  case eNET_DECL:
10258  nodeMask = 1;
10259  if(Arg<CNet*>(0)) Arg<CNet*>(0)->PreVisit1( func, data );
10260  break;
10261  case eVAR_DECL:
10262  nodeMask = 1;
10263  if(Arg<CVar*>(0)) Arg<CVar*>(0)->PreVisit1( func, data );
10264  break;
10265  case ePARAM_DECL:
10266  nodeMask = 1;
10267  if(Arg<CParam*>(0)) Arg<CParam*>(0)->PreVisit1( func, data );
10268  break;
10269  case eSPECPARAM_DECL:
10270  nodeMask = 1;
10271  if(Arg<CParam*>(0)) Arg<CParam*>(0)->PreVisit1( func, data );
10272  break;
10273  case ePORT_DECL:
10274  nodeMask = 1;
10275  if(Arg<CPortDir*>(0)) Arg<CPortDir*>(0)->PreVisit1( func, data );
10276  break;
10277  case eGENVAR_DECL:
10278  nodeMask = 1;
10279  if(Arg<CGenvar*>(0)) Arg<CGenvar*>(0)->PreVisit1( func, data );
10280  break;
10281  case eTYPEDEF_DECL:
10282  nodeMask = 1;
10283  if(Arg<CTypedef*>(0)) Arg<CTypedef*>(0)->PreVisit1( func, data );
10284  break;
10285  case eLIST:
10286  nodeMask = 0;
10287  break;
10288  case eRANGE:
10289  nodeMask = 0;
10290  break;
10291  case eSLICE:
10292  nodeMask = 0;
10293  break;
10294  case ePSLICE:
10295  nodeMask = 0;
10296  break;
10297  case eMSLICE:
10298  nodeMask = 0;
10299  break;
10300  case eCVRI:
10301  nodeMask = 0;
10302  break;
10303  case eCVIR:
10304  nodeMask = 0;
10305  break;
10306  case eREP:
10307  nodeMask = 0;
10308  break;
10309  case eCAT:
10310  nodeMask = 0;
10311  break;
10312  case eUCAT:
10313  nodeMask = 0;
10314  break;
10315  case eCOM:
10316  nodeMask = 0;
10317  break;
10318  case eNEG:
10319  nodeMask = 0;
10320  break;
10321  case ePLUS:
10322  nodeMask = 0;
10323  break;
10324  case eNOT:
10325  nodeMask = 0;
10326  break;
10327  case eGT:
10328  nodeMask = 0;
10329  break;
10330  case eGE:
10331  nodeMask = 0;
10332  break;
10333  case eLT:
10334  nodeMask = 0;
10335  break;
10336  case eLE:
10337  nodeMask = 0;
10338  break;
10339  case eLAND:
10340  nodeMask = 0;
10341  break;
10342  case eLOR:
10343  nodeMask = 0;
10344  break;
10345  case eCEQ:
10346  nodeMask = 0;
10347  break;
10348  case eCNE:
10349  nodeMask = 0;
10350  break;
10351  case eEQ:
10352  nodeMask = 0;
10353  break;
10354  case eNE:
10355  nodeMask = 0;
10356  break;
10357  case eRAND:
10358  nodeMask = 0;
10359  break;
10360  case eRNAND:
10361  nodeMask = 0;
10362  break;
10363  case eROR:
10364  nodeMask = 0;
10365  break;
10366  case eRNOR:
10367  nodeMask = 0;
10368  break;
10369  case eRXOR:
10370  nodeMask = 0;
10371  break;
10372  case eRXNOR:
10373  nodeMask = 0;
10374  break;
10375  case eHOOK:
10376  nodeMask = 0;
10377  break;
10378  case eINIT:
10379  nodeMask = 0;
10380  break;
10381  case eALWAYS:
10382  nodeMask = 0;
10383  break;
10384  case eALWAYS_LATCH:
10385  nodeMask = 0;
10386  break;
10387  case eALWAYS_FF:
10388  nodeMask = 0;
10389  break;
10390  case eALWAYS_COMB:
10391  nodeMask = 0;
10392  break;
10393  case eEVENT:
10394  nodeMask = 0;
10395  break;
10396  case eBLOCK_REF:
10397  nodeMask = 5;
10398  if(Arg<CBlock*>(0)) Arg<CBlock*>(0)->PreVisit1( func, data );
10399  break;
10400  case eSPECIFY_REF:
10401  nodeMask = 1;
10402  if(Arg<CSpecify*>(0)) Arg<CSpecify*>(0)->PreVisit1( func, data );
10403  break;
10404  case eASSIGN:
10405  nodeMask = 0;
10406  break;
10407  case eGASSIGN:
10408  nodeMask = 1;
10409  break;
10410  case eADD_ASSIGN:
10411  nodeMask = 0;
10412  break;
10413  case eSUB_ASSIGN:
10414  nodeMask = 0;
10415  break;
10416  case eMUL_ASSIGN:
10417  nodeMask = 0;
10418  break;
10419  case eDIV_ASSIGN:
10420  nodeMask = 0;
10421  break;
10422  case eMOD_ASSIGN:
10423  nodeMask = 0;
10424  break;
10425  case eAND_ASSIGN:
10426  nodeMask = 0;
10427  break;
10428  case eOR_ASSIGN:
10429  nodeMask = 0;
10430  break;
10431  case eXOR_ASSIGN:
10432  nodeMask = 0;
10433  break;
10434  case eLSH_ASSIGN:
10435  nodeMask = 0;
10436  break;
10437  case eRSH_ASSIGN:
10438  nodeMask = 0;
10439  break;
10440  case eLSHA_ASSIGN:
10441  nodeMask = 0;
10442  break;
10443  case eRSHA_ASSIGN:
10444  nodeMask = 0;
10445  break;
10446  case eFORCE:
10447  nodeMask = 0;
10448  break;
10449  case eRELEASE:
10450  nodeMask = 0;
10451  break;
10452  case eNBASSIGN:
10453  nodeMask = 0;
10454  break;
10455  case ePOSEDGE:
10456  nodeMask = 0;
10457  break;
10458  case eNEGEDGE:
10459  nodeMask = 0;
10460  break;
10461  case eEDGE:
10462  nodeMask = 2;
10463  break;
10464  case eEVOR:
10465  nodeMask = 0;
10466  break;
10467  case eDELAY:
10468  nodeMask = 0;
10469  break;
10470  case eMTM:
10471  nodeMask = 0;
10472  break;
10473  case eIF:
10474  nodeMask = 8;
10475  break;
10476  case eFOREVER:
10477  nodeMask = 0;
10478  break;
10479  case eREPEAT:
10480  nodeMask = 0;
10481  break;
10482  case eWHILE:
10483  nodeMask = 0;
10484  break;
10485  case eWAIT:
10486  nodeMask = 0;
10487  break;
10488  case eFOR:
10489  nodeMask = 0;
10490  break;
10491  case eCASE:
10492  nodeMask = 12;
10493  break;
10494  case eCASEX:
10495  nodeMask = 4;
10496  break;
10497  case eCASEZ:
10498  nodeMask = 4;
10499  break;
10500  case eCASEITEM:
10501  nodeMask = 0;
10502  break;
10503  case eCASSIGN:
10504  nodeMask = 1;
10505  break;
10506  case eARG:
10507  nodeMask = 1;
10508  break;
10509  case eIMPORT:
10510  nodeMask = 1;
10511  break;
10512  case eFUNCTION_DEF:
10513  nodeMask = 1;
10514  if(Arg<CFunction*>(0)) Arg<CFunction*>(0)->PreVisit1( func, data );
10515  break;
10516  case eMODULE_DEF:
10517  nodeMask = 1;
10518  if(Arg<CModule*>(0)) Arg<CModule*>(0)->PreVisit1( func, data );
10519  break;
10520  case ePACKAGE_DEF:
10521  nodeMask = 1;
10522  if(Arg<CPackage*>(0)) Arg<CPackage*>(0)->PreVisit1( func, data );
10523  break;
10524  case eREPEAT_CONTROL:
10525  nodeMask = 0;
10526  break;
10527  case eDELAY_CONTROL:
10528  nodeMask = 0;
10529  break;
10530  case eEVENT_CONTROL:
10531  nodeMask = 0;
10532  break;
10533  case eEXTERNAL_REF:
10534  nodeMask = 1;
10535  break;
10536  case ePORT_DEF:
10537  nodeMask = 1;
10538  if(Arg<CPort*>(0)) Arg<CPort*>(0)->PreVisit1( func, data );
10539  break;
10540  case eDEFPARAM:
10541  nodeMask = 0;
10542  break;
10543  case ePATH:
10544  nodeMask = 45;
10545  break;
10546  case ePATH_ASSIGN:
10547  nodeMask = 0;
10548  break;
10549  case eIFNONE_PATH_ASSIGN:
10550  nodeMask = 0;
10551  break;
10552  case eTRIGGER:
10553  nodeMask = 0;
10554  break;
10555  case ePASSIGN:
10556  nodeMask = 0;
10557  break;
10558  case eDEASSIGN:
10559  nodeMask = 0;
10560  break;
10561  case eDISABLE:
10562  nodeMask = 1;
10563  break;
10564  case eATTRIBUTE:
10565  nodeMask = 1;
10566  if(Arg<CAttr*>(0)) Arg<CAttr*>(0)->PreVisit1( func, data );
10567  break;
10568  case eGIF:
10569  nodeMask = 0;
10570  break;
10571  case eGFOR:
10572  nodeMask = 0;
10573  break;
10574  case eGCASE:
10575  nodeMask = 0;
10576  break;
10577  case eTABLE:
10578  nodeMask = 0;
10579  break;
10580  case eTABLE_ENTRY:
10581  nodeMask = 0;
10582  break;
10583  case eTABLE_SYMBOL:
10584  nodeMask = 1;
10585  break;
10586  case ePORTLIST_END:
10587  nodeMask = 0;
10588  break;
10589  case eMACRO_EXPR:
10590  nodeMask = 1;
10591  break;
10592  case eENUM_SPEC:
10593  nodeMask = 1;
10594  break;
10595  case eMEMBER:
10596  nodeMask = 2;
10597  break;
10598  case eRETURN:
10599  nodeMask = 0;
10600  break;
10601  case ePREINC:
10602  nodeMask = 0;
10603  break;
10604  case ePOSTINC:
10605  nodeMask = 0;
10606  break;
10607  case ePREDEC:
10608  nodeMask = 0;
10609  break;
10610  case ePOSTDEC:
10611  nodeMask = 0;
10612  break;
10613  case eCAST:
10614  nodeMask = 0;
10615  break;
10616  case eASSIGNMENT_PATTERN:
10617  nodeMask = 0;
10618  break;
10619  case eDOLLAR:
10620  nodeMask = 0;
10621  break;
10622  }
10623 
10624  /*
10625  * special case LIST nodes for tail recursion optimizations
10626  */
10627  if( GetOp() != eLIST ) {
10628  for( int i = 0; i < ArgCount(); i++ ) {
10629  if( Arg<CNode*>(i) && !((nodeMask>>i)&1) ) Arg<CNode*>(i)->PreVisit1( func, data );
10630  }
10631  } else {
10632  CNode* n = this;
10633  while( 1 ) {
10634  if( n->Arg<CNode*>(0) ) {
10635  n->Arg<CNode*>(0)->PreVisit1( func, data );
10636  }
10637  if( !n->Arg<CNode*>(1) || n->Arg<CNode*>(1)->GetOp() != eLIST ) {
10638  break;
10639  }
10640  n = n->Arg<CNode*>(1);
10641  if( !(*func)( n, data ) ) {
10642  return;
10643  }
10644  if( n->GetAttributes() ) {
10645  n->GetAttributes()->PreVisit1( func, data );
10646  }
10647  }
10648  if( n->Arg<CNode*>(1) ) {
10649  n->Arg<CNode*>(1)->PreVisit1( func, data );
10650  }
10651  }
10652 }
10653 
10654 
10655 /***********************************************
10656  PostVisit1
10657  - traverse tree, evoking
10658  leaves then parent.
10659 ************************************************/
10660 void CNode::PostVisit1( void (*func)(CNode*, void*), void* data )
10661 {
10662  if( GetAttributes() ) {
10663  GetAttributes()->PostVisit1( func, data );
10664  }
10665 
10666  int nodeMask = 0;
10667  switch( GetOp() ) {
10668  case eERROR:
10669  nodeMask = 0;
10670  break;
10671  case eVCONSTANT:
10672  nodeMask = 1;
10673  break;
10674  case eRCONSTANT:
10675  nodeMask = 1;
10676  break;
10677  case eCOMMENT:
10678  nodeMask = 1;
10679  break;
10680  case eVRQ:
10681  nodeMask = 1;
10682  break;
10683  case ePRAGMA:
10684  nodeMask = 3;
10685  break;
10686  case eELIST:
10687  nodeMask = 0;
10688  break;
10689  case eWIDTH:
10690  nodeMask = 0;
10691  break;
10692  case eNOP:
10693  nodeMask = 0;
10694  break;
10695  case eSUB:
10696  nodeMask = 0;
10697  break;
10698  case eMUL:
10699  nodeMask = 0;
10700  break;
10701  case eDIV:
10702  nodeMask = 0;
10703  break;
10704  case ePOW:
10705  nodeMask = 0;
10706  break;
10707  case eADD:
10708  nodeMask = 0;
10709  break;
10710  case eLSH:
10711  nodeMask = 0;
10712  break;
10713  case eRSH:
10714  nodeMask = 0;
10715  break;
10716  case eLSHA:
10717  nodeMask = 0;
10718  break;
10719  case eRSHA:
10720  nodeMask = 0;
10721  break;
10722  case eMOD:
10723  nodeMask = 0;
10724  break;
10725  case eOR:
10726  nodeMask = 0;
10727  break;
10728  case eAND:
10729  nodeMask = 0;
10730  break;
10731  case eANDANDAND:
10732  nodeMask = 0;
10733  break;
10734  case eXOR:
10735  nodeMask = 0;
10736  break;
10737  case eXNOR:
10738  nodeMask = 0;
10739  break;
10740  case eINSTANCE_REF:
10741  nodeMask = 1;
10742  if(Arg<CInstance*>(0)) Arg<CInstance*>(0)->PostVisit1( func, data );
10743  break;
10744  case eGATE_REF:
10745  nodeMask = 1;
10746  if(Arg<CGate*>(0)) Arg<CGate*>(0)->PostVisit1( func, data );
10747  break;
10748  case eTASK_ENABLE:
10749  nodeMask = 1;
10750  break;
10751  case eSYSTASK_CALL:
10752  nodeMask = 1;
10753  break;
10754  case eTIMING_CALL:
10755  nodeMask = 1;
10756  break;
10757  case eFUNCTION_CALL:
10758  nodeMask = 5;
10759  break;
10760  case eARRAY:
10761  nodeMask = 0;
10762  break;
10763  case eNET_REF:
10764  nodeMask = ~0;
10765  break;
10766  case eVAR_REF:
10767  nodeMask = ~0;
10768  break;
10769  case ePARAM_REF:
10770  nodeMask = ~0;
10771  break;
10772  case ePORT_REF:
10773  nodeMask = ~0;
10774  break;
10775  case eFWD_REF:
10776  nodeMask = ~0;
10777  break;
10778  case eGENVAR_REF:
10779  nodeMask = ~0;
10780  break;
10781  case eENUM_REF:
10782  nodeMask = ~0;
10783  break;
10784  case eTYPE_REF:
10785  nodeMask = ~0;
10786  break;
10787  case eNET_DECL:
10788  nodeMask = 1;
10789  if(Arg<CNet*>(0)) Arg<CNet*>(0)->PostVisit1( func, data );
10790  break;
10791  case eVAR_DECL:
10792  nodeMask = 1;
10793  if(Arg<CVar*>(0)) Arg<CVar*>(0)->PostVisit1( func, data );
10794  break;
10795  case ePARAM_DECL:
10796  nodeMask = 1;
10797  if(Arg<CParam*>(0)) Arg<CParam*>(0)->PostVisit1( func, data );
10798  break;
10799  case eSPECPARAM_DECL:
10800  nodeMask = 1;
10801  if(Arg<CParam*>(0)) Arg<CParam*>(0)->PostVisit1( func, data );
10802  break;
10803  case ePORT_DECL:
10804  nodeMask = 1;
10805  if(Arg<CPortDir*>(0)) Arg<CPortDir*>(0)->PostVisit1( func, data );
10806  break;
10807  case eGENVAR_DECL:
10808  nodeMask = 1;
10809  if(Arg<CGenvar*>(0)) Arg<CGenvar*>(0)->PostVisit1( func, data );
10810  break;
10811  case eTYPEDEF_DECL:
10812  nodeMask = 1;
10813  if(Arg<CTypedef*>(0)) Arg<CTypedef*>(0)->PostVisit1( func, data );
10814  break;
10815  case eLIST:
10816  nodeMask = 0;
10817  break;
10818  case eRANGE:
10819  nodeMask = 0;
10820  break;
10821  case eSLICE:
10822  nodeMask = 0;
10823  break;
10824  case ePSLICE:
10825  nodeMask = 0;
10826  break;
10827  case eMSLICE:
10828  nodeMask = 0;
10829  break;
10830  case eCVRI:
10831  nodeMask = 0;
10832  break;
10833  case eCVIR:
10834  nodeMask = 0;
10835  break;
10836  case eREP:
10837  nodeMask = 0;
10838  break;
10839  case eCAT:
10840  nodeMask = 0;
10841  break;
10842  case eUCAT:
10843  nodeMask = 0;
10844  break;
10845  case eCOM:
10846  nodeMask = 0;
10847  break;
10848  case eNEG:
10849  nodeMask = 0;
10850  break;
10851  case ePLUS:
10852  nodeMask = 0;
10853  break;
10854  case eNOT:
10855  nodeMask = 0;
10856  break;
10857  case eGT:
10858  nodeMask = 0;
10859  break;
10860  case eGE:
10861  nodeMask = 0;
10862  break;
10863  case eLT:
10864  nodeMask = 0;
10865  break;
10866  case eLE:
10867  nodeMask = 0;
10868  break;
10869  case eLAND:
10870  nodeMask = 0;
10871  break;
10872  case eLOR:
10873  nodeMask = 0;
10874  break;
10875  case eCEQ:
10876  nodeMask = 0;
10877  break;
10878  case eCNE:
10879  nodeMask = 0;
10880  break;
10881  case eEQ:
10882  nodeMask = 0;
10883  break;
10884  case eNE:
10885  nodeMask = 0;
10886  break;
10887  case eRAND:
10888  nodeMask = 0;
10889  break;
10890  case eRNAND:
10891  nodeMask = 0;
10892  break;
10893  case eROR:
10894  nodeMask = 0;
10895  break;
10896  case eRNOR:
10897  nodeMask = 0;
10898  break;
10899  case eRXOR:
10900  nodeMask = 0;
10901  break;
10902  case eRXNOR:
10903  nodeMask = 0;
10904  break;
10905  case eHOOK:
10906  nodeMask = 0;
10907  break;
10908  case eINIT:
10909  nodeMask = 0;
10910  break;
10911  case eALWAYS:
10912  nodeMask = 0;
10913  break;
10914  case eALWAYS_LATCH:
10915  nodeMask = 0;
10916  break;
10917  case eALWAYS_FF:
10918  nodeMask = 0;
10919  break;
10920  case eALWAYS_COMB:
10921  nodeMask = 0;
10922  break;
10923  case eEVENT:
10924  nodeMask = 0;
10925  break;
10926  case eBLOCK_REF:
10927  nodeMask = 5;
10928  if(Arg<CBlock*>(0)) Arg<CBlock*>(0)->PostVisit1( func, data );
10929  break;
10930  case eSPECIFY_REF:
10931  nodeMask = 1;
10932  if(Arg<CSpecify*>(0)) Arg<CSpecify*>(0)->PostVisit1( func, data );
10933  break;
10934  case eASSIGN:
10935  nodeMask = 0;
10936  break;
10937  case eGASSIGN:
10938  nodeMask = 1;
10939  break;
10940  case eADD_ASSIGN:
10941  nodeMask = 0;
10942  break;
10943  case eSUB_ASSIGN:
10944  nodeMask = 0;
10945  break;
10946  case eMUL_ASSIGN:
10947  nodeMask = 0;
10948  break;
10949  case eDIV_ASSIGN:
10950  nodeMask = 0;
10951  break;
10952  case eMOD_ASSIGN:
10953  nodeMask = 0;
10954  break;
10955  case eAND_ASSIGN:
10956  nodeMask = 0;
10957  break;
10958  case eOR_ASSIGN:
10959  nodeMask = 0;
10960  break;
10961  case eXOR_ASSIGN:
10962  nodeMask = 0;
10963  break;
10964  case eLSH_ASSIGN:
10965  nodeMask = 0;
10966  break;
10967  case eRSH_ASSIGN:
10968  nodeMask = 0;
10969  break;
10970  case eLSHA_ASSIGN:
10971  nodeMask = 0;
10972  break;
10973  case eRSHA_ASSIGN:
10974  nodeMask = 0;
10975  break;
10976  case eFORCE:
10977  nodeMask = 0;
10978  break;
10979  case eRELEASE:
10980  nodeMask = 0;
10981  break;
10982  case eNBASSIGN:
10983  nodeMask = 0;
10984  break;
10985  case ePOSEDGE:
10986  nodeMask = 0;
10987  break;
10988  case eNEGEDGE:
10989  nodeMask = 0;
10990  break;
10991  case eEDGE:
10992  nodeMask = 2;
10993  break;
10994  case eEVOR:
10995  nodeMask = 0;
10996  break;
10997  case eDELAY:
10998  nodeMask = 0;
10999  break;
11000  case eMTM:
11001  nodeMask = 0;
11002  break;
11003  case eIF:
11004  nodeMask = 8;
11005  break;
11006  case eFOREVER:
11007  nodeMask = 0;
11008  break;
11009  case eREPEAT:
11010  nodeMask = 0;
11011  break;
11012  case eWHILE:
11013  nodeMask = 0;
11014  break;
11015  case eWAIT:
11016  nodeMask = 0;
11017  break;
11018  case eFOR:
11019  nodeMask = 0;
11020  break;
11021  case eCASE:
11022  nodeMask = 12;
11023  break;
11024  case eCASEX:
11025  nodeMask = 4;
11026  break;
11027  case eCASEZ:
11028  nodeMask = 4;
11029  break;
11030  case eCASEITEM:
11031  nodeMask = 0;
11032  break;
11033  case eCASSIGN:
11034  nodeMask = 1;
11035  break;
11036  case eARG:
11037  nodeMask = 1;
11038  break;
11039  case eIMPORT:
11040  nodeMask = 1;
11041  break;
11042  case eFUNCTION_DEF:
11043  nodeMask = 1;
11044  if(Arg<CFunction*>(0)) Arg<CFunction*>(0)->PostVisit1( func, data );
11045  break;
11046  case eMODULE_DEF:
11047  nodeMask = 1;
11048  if(Arg<CModule*>(0)) Arg<CModule*>(0)->PostVisit1( func, data );
11049  break;
11050  case ePACKAGE_DEF:
11051  nodeMask = 1;
11052  if(Arg<CPackage*>(0)) Arg<CPackage*>(0)->PostVisit1( func, data );
11053  break;
11054  case eREPEAT_CONTROL:
11055  nodeMask = 0;
11056  break;
11057  case eDELAY_CONTROL:
11058  nodeMask = 0;
11059  break;
11060  case eEVENT_CONTROL:
11061  nodeMask = 0;
11062  break;
11063  case eEXTERNAL_REF:
11064  nodeMask = 1;
11065  break;
11066  case ePORT_DEF:
11067  nodeMask = 1;
11068  if(Arg<CPort*>(0)) Arg<CPort*>(0)->PostVisit1( func, data );
11069  break;
11070  case eDEFPARAM:
11071  nodeMask = 0;
11072  break;
11073  case ePATH:
11074  nodeMask = 45;
11075  break;
11076  case ePATH_ASSIGN:
11077  nodeMask = 0;
11078  break;
11079  case eIFNONE_PATH_ASSIGN:
11080  nodeMask = 0;
11081  break;
11082  case eTRIGGER:
11083  nodeMask = 0;
11084  break;
11085  case ePASSIGN:
11086  nodeMask = 0;
11087  break;
11088  case eDEASSIGN:
11089  nodeMask = 0;
11090  break;
11091  case eDISABLE:
11092  nodeMask = 1;
11093  break;
11094  case eATTRIBUTE:
11095  nodeMask = 1;
11096  if(Arg<CAttr*>(0)) Arg<CAttr*>(0)->PostVisit1( func, data );
11097  break;
11098  case eGIF:
11099  nodeMask = 0;
11100  break;
11101  case eGFOR:
11102  nodeMask = 0;
11103  break;
11104  case eGCASE:
11105  nodeMask = 0;
11106  break;
11107  case eTABLE:
11108  nodeMask = 0;
11109  break;
11110  case eTABLE_ENTRY:
11111  nodeMask = 0;
11112  break;
11113  case eTABLE_SYMBOL:
11114  nodeMask = 1;
11115  break;
11116  case ePORTLIST_END:
11117  nodeMask = 0;
11118  break;
11119  case eMACRO_EXPR:
11120  nodeMask = 1;
11121  break;
11122  case eENUM_SPEC:
11123  nodeMask = 1;
11124  break;
11125  case eMEMBER:
11126  nodeMask = 2;
11127  break;
11128  case eRETURN:
11129  nodeMask = 0;
11130  break;
11131  case ePREINC:
11132  nodeMask = 0;
11133  break;
11134  case ePOSTINC:
11135  nodeMask = 0;
11136  break;
11137  case ePREDEC:
11138  nodeMask = 0;
11139  break;
11140  case ePOSTDEC:
11141  nodeMask = 0;
11142  break;
11143  case eCAST:
11144  nodeMask = 0;
11145  break;
11146  case eASSIGNMENT_PATTERN:
11147  nodeMask = 0;
11148  break;
11149  case eDOLLAR:
11150  nodeMask = 0;
11151  break;
11152  }
11153 
11154  /*
11155  * special case LIST nodes for tail recursion optimizations
11156  */
11157  if( GetOp() != eLIST ) {
11158  for( int i = 0; i < ArgCount(); i++ ) {
11159  if( Arg<CNode*>(i) && !((nodeMask>>i)&1) ) Arg<CNode*>(i)->PostVisit1( func, data );
11160  }
11161  } else {
11162  std::stack<CNode*> visitLog;
11163  CNode* n = this;
11164  while( 1 ) {
11165  if( n->Arg<CNode*>(0) ) {
11166  n->Arg<CNode*>(0)-> PostVisit1( func, data );
11167  }
11168  if( !n->Arg<CNode*>(1) || n->Arg<CNode*>(1)->GetOp() != eLIST ) {
11169  break;
11170  }
11171  visitLog.push(n);
11172  n = n->Arg<CNode*>(1);
11173  if( n->GetAttributes() ) {
11174  n->GetAttributes()->PostVisit1( func, data );
11175  }
11176  }
11177  if( n->Arg<CNode*>(1) ) {
11178  n->Arg<CNode*>(1)->PostVisit1( func, data );
11179  }
11180  while( !visitLog.empty() ) {
11181  CNode* top = visitLog.top();
11182  if( top->Arg<CNode*>(1) ) {
11183  (*func)(top->Arg<CNode*>(1),data);
11184  }
11185  visitLog.pop();
11186  }
11187  }
11188 
11189  (*func)( this, data );
11190 }
11191 
11192 /***********************************************
11193  PostSubVisit1
11194  - traverse tree, evoking
11195  leaves then parents, substituting
11196  results
11197 ************************************************/
11198 
11199 CNode* CNode::PostSubVisit1( CNode* (*func)(CNode*, void*), void* data )
11200 {
11201  if( GetAttributes() ) {
11202  SetAttributes( GetAttributes()->PostSubVisit1( func, data ) );
11203  }
11204 
11205  int nodeMask = 0;
11206  switch( GetOp() ) {
11207  case eERROR:
11208  nodeMask = 0;
11209  break;
11210  case eVCONSTANT:
11211  nodeMask = 1;
11212  break;
11213  case eRCONSTANT:
11214  nodeMask = 1;
11215  break;
11216  case eCOMMENT:
11217  nodeMask = 1;
11218  break;
11219  case eVRQ:
11220  nodeMask = 1;
11221  break;
11222  case ePRAGMA:
11223  nodeMask = 3;
11224  break;
11225  case eELIST:
11226  nodeMask = 0;
11227  break;
11228  case eWIDTH:
11229  nodeMask = 0;
11230  break;
11231  case eNOP:
11232  nodeMask = 0;
11233  break;
11234  case eSUB:
11235  nodeMask = 0;
11236  break;
11237  case eMUL:
11238  nodeMask = 0;
11239  break;
11240  case eDIV:
11241  nodeMask = 0;
11242  break;
11243  case ePOW:
11244  nodeMask = 0;
11245  break;
11246  case eADD:
11247  nodeMask = 0;
11248  break;
11249  case eLSH:
11250  nodeMask = 0;
11251  break;
11252  case eRSH:
11253  nodeMask = 0;
11254  break;
11255  case eLSHA:
11256  nodeMask = 0;
11257  break;
11258  case eRSHA:
11259  nodeMask = 0;
11260  break;
11261  case eMOD:
11262  nodeMask = 0;
11263  break;
11264  case eOR:
11265  nodeMask = 0;
11266  break;
11267  case eAND:
11268  nodeMask = 0;
11269  break;
11270  case eANDANDAND:
11271  nodeMask = 0;
11272  break;
11273  case eXOR:
11274  nodeMask = 0;
11275  break;
11276  case eXNOR:
11277  nodeMask = 0;
11278  break;
11279  case eINSTANCE_REF:
11280  nodeMask = 1;
11281  if(Arg<CInstance*>(0)) Arg<CInstance*>(0)->PostSubVisit1( func, data );
11282  break;
11283  case eGATE_REF:
11284  nodeMask = 1;
11285  if(Arg<CGate*>(0)) Arg<CGate*>(0)->PostSubVisit1( func, data );
11286  break;
11287  case eTASK_ENABLE:
11288  nodeMask = 1;
11289  break;
11290  case eSYSTASK_CALL:
11291  nodeMask = 1;
11292  break;
11293  case eTIMING_CALL:
11294  nodeMask = 1;
11295  break;
11296  case eFUNCTION_CALL:
11297  nodeMask = 5;
11298  break;
11299  case eARRAY:
11300  nodeMask = 0;
11301  break;
11302  case eNET_REF:
11303  nodeMask = ~0;
11304  break;
11305  case eVAR_REF:
11306  nodeMask = ~0;
11307  break;
11308  case ePARAM_REF:
11309  nodeMask = ~0;
11310  break;
11311  case ePORT_REF:
11312  nodeMask = ~0;
11313  break;
11314  case eFWD_REF:
11315  nodeMask = ~0;
11316  break;
11317  case eGENVAR_REF:
11318  nodeMask = ~0;
11319  break;
11320  case eENUM_REF:
11321  nodeMask = ~0;
11322  break;
11323  case eTYPE_REF:
11324  nodeMask = ~0;
11325  break;
11326  case eNET_DECL:
11327  nodeMask = 1;
11328  if(Arg<CNet*>(0)) Arg<CNet*>(0)->PostSubVisit1( func, data );
11329  break;
11330  case eVAR_DECL:
11331  nodeMask = 1;
11332  if(Arg<CVar*>(0)) Arg<CVar*>(0)->PostSubVisit1( func, data );
11333  break;
11334  case ePARAM_DECL:
11335  nodeMask = 1;
11336  if(Arg<CParam*>(0)) Arg<CParam*>(0)->PostSubVisit1( func, data );
11337  break;
11338  case eSPECPARAM_DECL:
11339  nodeMask = 1;
11340  if(Arg<CParam*>(0)) Arg<CParam*>(0)->PostSubVisit1( func, data );
11341  break;
11342  case ePORT_DECL:
11343  nodeMask = 1;
11344  if(Arg<CPortDir*>(0)) Arg<CPortDir*>(0)->PostSubVisit1( func, data );
11345  break;
11346  case eGENVAR_DECL:
11347  nodeMask = 1;
11348  if(Arg<CGenvar*>(0)) Arg<CGenvar*>(0)->PostSubVisit1( func, data );
11349  break;
11350  case eTYPEDEF_DECL:
11351  nodeMask = 1;
11352  if(Arg<CTypedef*>(0)) Arg<CTypedef*>(0)->PostSubVisit1( func, data );
11353  break;
11354  case eLIST:
11355  nodeMask = 0;
11356  break;
11357  case eRANGE:
11358  nodeMask = 0;
11359  break;
11360  case eSLICE:
11361  nodeMask = 0;
11362  break;
11363  case ePSLICE:
11364  nodeMask = 0;
11365  break;
11366  case eMSLICE:
11367  nodeMask = 0;
11368  break;
11369  case eCVRI:
11370  nodeMask = 0;
11371  break;
11372  case eCVIR:
11373  nodeMask = 0;
11374  break;
11375  case eREP:
11376  nodeMask = 0;
11377  break;
11378  case eCAT:
11379  nodeMask = 0;
11380  break;
11381  case eUCAT:
11382  nodeMask = 0;
11383  break;
11384  case eCOM:
11385  nodeMask = 0;
11386  break;
11387  case eNEG:
11388  nodeMask = 0;
11389  break;
11390  case ePLUS:
11391  nodeMask = 0;
11392  break;
11393  case eNOT:
11394  nodeMask = 0;
11395  break;
11396  case eGT:
11397  nodeMask = 0;
11398  break;
11399  case eGE:
11400  nodeMask = 0;
11401  break;
11402  case eLT:
11403  nodeMask = 0;
11404  break;
11405  case eLE:
11406  nodeMask = 0;
11407  break;
11408  case eLAND:
11409  nodeMask = 0;
11410  break;
11411  case eLOR:
11412  nodeMask = 0;
11413  break;
11414  case eCEQ:
11415  nodeMask = 0;
11416  break;
11417  case eCNE:
11418  nodeMask = 0;
11419  break;
11420  case eEQ:
11421  nodeMask = 0;
11422  break;
11423  case eNE:
11424  nodeMask = 0;
11425  break;
11426  case eRAND:
11427  nodeMask = 0;
11428  break;
11429  case eRNAND:
11430  nodeMask = 0;
11431  break;
11432  case eROR:
11433  nodeMask = 0;
11434  break;
11435  case eRNOR:
11436  nodeMask = 0;
11437  break;
11438  case eRXOR:
11439  nodeMask = 0;
11440  break;
11441  case eRXNOR:
11442  nodeMask = 0;
11443  break;
11444  case eHOOK:
11445  nodeMask = 0;
11446  break;
11447  case eINIT:
11448  nodeMask = 0;
11449  break;
11450  case eALWAYS:
11451  nodeMask = 0;
11452  break;
11453  case eALWAYS_LATCH:
11454  nodeMask = 0;
11455  break;
11456  case eALWAYS_FF:
11457  nodeMask = 0;
11458  break;
11459  case eALWAYS_COMB:
11460  nodeMask = 0;
11461  break;
11462  case eEVENT:
11463  nodeMask = 0;
11464  break;
11465  case eBLOCK_REF:
11466  nodeMask = 5;
11467  if(Arg<CBlock*>(0)) Arg<CBlock*>(0)->PostSubVisit1( func, data );
11468  break;
11469  case eSPECIFY_REF:
11470  nodeMask = 1;
11471  if(Arg<CSpecify*>(0)) Arg<CSpecify*>(0)->PostSubVisit1( func, data );
11472  break;
11473  case eASSIGN:
11474  nodeMask = 0;
11475  break;
11476  case eGASSIGN:
11477  nodeMask = 1;
11478  break;
11479  case eADD_ASSIGN:
11480  nodeMask = 0;
11481  break;
11482  case eSUB_ASSIGN:
11483  nodeMask = 0;
11484  break;
11485  case eMUL_ASSIGN:
11486  nodeMask = 0;
11487  break;
11488  case eDIV_ASSIGN:
11489  nodeMask = 0;
11490  break;
11491  case eMOD_ASSIGN:
11492  nodeMask = 0;
11493  break;
11494  case eAND_ASSIGN:
11495  nodeMask = 0;
11496  break;
11497  case eOR_ASSIGN:
11498  nodeMask = 0;
11499  break;
11500  case eXOR_ASSIGN:
11501  nodeMask = 0;
11502  break;
11503  case eLSH_ASSIGN:
11504  nodeMask = 0;
11505  break;
11506  case eRSH_ASSIGN:
11507  nodeMask = 0;
11508  break;
11509  case eLSHA_ASSIGN:
11510  nodeMask = 0;
11511  break;
11512  case eRSHA_ASSIGN:
11513  nodeMask = 0;
11514  break;
11515  case eFORCE:
11516  nodeMask = 0;
11517  break;
11518  case eRELEASE:
11519  nodeMask = 0;
11520  break;
11521  case eNBASSIGN:
11522  nodeMask = 0;
11523  break;
11524  case ePOSEDGE:
11525  nodeMask = 0;
11526  break;
11527  case eNEGEDGE:
11528  nodeMask = 0;
11529  break;
11530  case eEDGE:
11531  nodeMask = 2;
11532  break;
11533  case eEVOR:
11534  nodeMask = 0;
11535  break;
11536  case eDELAY:
11537  nodeMask = 0;
11538  break;
11539  case eMTM:
11540  nodeMask = 0;
11541  break;
11542  case eIF:
11543  nodeMask = 8;
11544  break;
11545  case eFOREVER:
11546  nodeMask = 0;
11547  break;
11548  case eREPEAT:
11549  nodeMask = 0;
11550  break;
11551  case eWHILE:
11552  nodeMask = 0;
11553  break;
11554  case eWAIT:
11555  nodeMask = 0;
11556  break;
11557  case eFOR:
11558  nodeMask = 0;
11559  break;
11560  case eCASE:
11561  nodeMask = 12;
11562  break;
11563  case eCASEX:
11564  nodeMask = 4;
11565  break;
11566  case eCASEZ:
11567  nodeMask = 4;
11568  break;
11569  case eCASEITEM:
11570  nodeMask = 0;
11571  break;
11572  case eCASSIGN:
11573  nodeMask = 1;
11574  break;
11575  case eARG:
11576  nodeMask = 1;
11577  break;
11578  case eIMPORT:
11579  nodeMask = 1;
11580  break;
11581  case eFUNCTION_DEF:
11582  nodeMask = 1;
11583  if(Arg<CFunction*>(0)) Arg<CFunction*>(0)->PostSubVisit1( func, data );
11584  break;
11585  case eMODULE_DEF:
11586  nodeMask = 1;
11587  if(Arg<CModule*>(0)) Arg<CModule*>(0)->PostSubVisit1( func, data );
11588  break;
11589  case ePACKAGE_DEF:
11590  nodeMask = 1;
11591  if(Arg<CPackage*>(0)) Arg<CPackage*>(0)->PostSubVisit1( func, data );
11592  break;
11593  case eREPEAT_CONTROL:
11594  nodeMask = 0;
11595  break;
11596  case eDELAY_CONTROL:
11597  nodeMask = 0;
11598  break;
11599  case eEVENT_CONTROL:
11600  nodeMask = 0;
11601  break;
11602  case eEXTERNAL_REF:
11603  nodeMask = 1;
11604  break;
11605  case ePORT_DEF:
11606  nodeMask = 1;
11607  if(Arg<CPort*>(0)) Arg<CPort*>(0)->PostSubVisit1( func, data );
11608  break;
11609  case eDEFPARAM:
11610  nodeMask = 0;
11611  break;
11612  case ePATH:
11613  nodeMask = 45;
11614  break;
11615  case ePATH_ASSIGN:
11616  nodeMask = 0;
11617  break;
11618  case eIFNONE_PATH_ASSIGN:
11619  nodeMask = 0;
11620  break;
11621  case eTRIGGER:
11622  nodeMask = 0;
11623  break;
11624  case ePASSIGN:
11625  nodeMask = 0;
11626  break;
11627  case eDEASSIGN:
11628  nodeMask = 0;
11629  break;
11630  case eDISABLE:
11631  nodeMask = 1;
11632  break;
11633  case eATTRIBUTE:
11634  nodeMask = 1;
11635  if(Arg<CAttr*>(0)) Arg<CAttr*>(0)->PostSubVisit1( func, data );
11636  break;
11637  case eGIF:
11638  nodeMask = 0;
11639  break;
11640  case eGFOR:
11641  nodeMask = 0;
11642  break;
11643  case eGCASE:
11644  nodeMask = 0;
11645  break;
11646  case eTABLE:
11647  nodeMask = 0;
11648  break;
11649  case eTABLE_ENTRY:
11650  nodeMask = 0;
11651  break;
11652  case eTABLE_SYMBOL:
11653  nodeMask = 1;
11654  break;
11655  case ePORTLIST_END:
11656  nodeMask = 0;
11657  break;
11658  case eMACRO_EXPR:
11659  nodeMask = 1;
11660  break;
11661  case eENUM_SPEC:
11662  nodeMask = 1;
11663  break;
11664  case eMEMBER:
11665  nodeMask = 2;
11666  break;
11667  case eRETURN:
11668  nodeMask = 0;
11669  break;
11670  case ePREINC:
11671  nodeMask = 0;
11672  break;
11673  case ePOSTINC:
11674  nodeMask = 0;
11675  break;
11676  case ePREDEC:
11677  nodeMask = 0;
11678  break;
11679  case ePOSTDEC:
11680  nodeMask = 0;
11681  break;
11682  case eCAST:
11683  nodeMask = 0;
11684  break;
11685  case eASSIGNMENT_PATTERN:
11686  nodeMask = 0;
11687  break;
11688  case eDOLLAR:
11689  nodeMask = 0;
11690  break;
11691  }
11692 
11693  /*
11694  * special case LIST nodes for tail recursion optimizations
11695  */
11696  if( GetOp() != eLIST ) {
11697  for( int i = 0; i < ArgCount(); i++ ) {
11698  if( Arg<CNode*>(i) && !((nodeMask>>i)&1) ) Arg<CNode*>(i) = Arg<CNode*>(i)->PostSubVisit1( func, data );
11699  }
11700  } else {
11701  std::stack<CNode*> visitLog;
11702  CNode* n = this;
11703  while( 1 ) {
11704  if( n->Arg<CNode*>(0) ) {
11705  n->Arg<CNode*>(0) = n->Arg<CNode*>(0)->
11706  PostSubVisit1( func, data );
11707  }
11708  if( !n->Arg<CNode*>(1) || n->Arg<CNode*>(1)->GetOp() != eLIST ) {
11709  break;
11710  }
11711  visitLog.push(n);
11712  n = n->Arg<CNode*>(1);
11713  if( n->GetAttributes() ) {
11714  n->SetAttributes( n->GetAttributes()->PostSubVisit1( func, data ) );
11715  }
11716  }
11717  if( n->Arg<CNode*>(1) ) {
11718  n->Arg<CNode*>(1) = n->Arg<CNode*>(1)->PostSubVisit1( func, data );
11719  }
11720  while( !visitLog.empty() ) {
11721  CNode* top = visitLog.top();
11722  if( top->Arg<CNode*>(1) ) {
11723  top->Arg<CNode*>(1) = (*func)(top->Arg<CNode*>(1),data);
11724  }
11725  visitLog.pop();
11726  }
11727  }
11728 
11729  return (*func)( this, data );
11730 }
11731 
11732 /***********************************************
11733  Hash
11734  - returns a unique hash number
11735  representing tree
11736  The following is always true:
11737  Equivilent(n1,n2) => Hash(n1) == Hash(n2)
11738 ************************************************/
11739 
11740 unsigned CNode::Hash()
11741 {
11742  unsigned result = GetOp();
11743  int nodeMask = 0;
11744  switch( GetOp() ) {
11745  case eERROR:
11746  nodeMask = 0;
11747  break;
11748  case eVCONSTANT:
11749  nodeMask = 1;
11750  result ^= Arg<CVector*>(0)->Hash();
11751  break;
11752  case eRCONSTANT:
11753  nodeMask = 1;
11754  result ^= strlen(Arg<char*>(0));
11755  break;
11756  case eCOMMENT:
11757  nodeMask = 1;
11758  result ^= strlen(Arg<char*>(0));
11759  break;
11760  case eVRQ:
11761  nodeMask = 1;
11762  result ^= strlen(Arg<char*>(0));
11763  break;
11764  case ePRAGMA:
11765  nodeMask = 3;
11766  result ^= strlen(Arg<char*>(0));
11767  result ^= Arg<int>(1);
11768  break;
11769  case eELIST:
11770  nodeMask = 0;
11771  break;
11772  case eWIDTH:
11773  nodeMask = 0;
11774  break;
11775  case eNOP:
11776  nodeMask = 0;
11777  break;
11778  case eSUB:
11779  nodeMask = 0;
11780  break;
11781  case eMUL:
11782  nodeMask = 0;
11783  break;
11784  case eDIV:
11785  nodeMask = 0;
11786  break;
11787  case ePOW:
11788  nodeMask = 0;
11789  break;
11790  case eADD:
11791  nodeMask = 0;
11792  break;
11793  case eLSH:
11794  nodeMask = 0;
11795  break;
11796  case eRSH:
11797  nodeMask = 0;
11798  break;
11799  case eLSHA:
11800  nodeMask = 0;
11801  break;
11802  case eRSHA:
11803  nodeMask = 0;
11804  break;
11805  case eMOD:
11806  nodeMask = 0;
11807  break;
11808  case eOR:
11809  nodeMask = 0;
11810  break;
11811  case eAND:
11812  nodeMask = 0;
11813  break;
11814  case eANDANDAND:
11815  nodeMask = 0;
11816  break;
11817  case eXOR:
11818  nodeMask = 0;
11819  break;
11820  case eXNOR:
11821  nodeMask = 0;
11822  break;
11823  case eINSTANCE_REF:
11824  nodeMask = 1;
11825  result ^= Arg<unsigned long>(0);
11826  break;
11827  case eGATE_REF:
11828  nodeMask = 1;
11829  result ^= Arg<unsigned long>(0);
11830  break;
11831  case eTASK_ENABLE:
11832  nodeMask = 1;
11833  result ^= Arg<unsigned long>(0);
11834  break;
11835  case eSYSTASK_CALL:
11836  nodeMask = 1;
11837  result ^= Arg<unsigned long>(0);
11838  break;
11839  case eTIMING_CALL:
11840  nodeMask = 1;
11841  result ^= Arg<unsigned long>(0);
11842  break;
11843  case eFUNCTION_CALL:
11844  nodeMask = 5;
11845  result ^= Arg<unsigned long>(0);
11846  result ^= Arg<unsigned long>(2);
11847  break;
11848  case eARRAY:
11849  nodeMask = 0;
11850  break;
11851  case eNET_REF:
11852  nodeMask = 1;
11853  result ^= Arg<unsigned long>(0);
11854  break;
11855  case eVAR_REF:
11856  nodeMask = 1;
11857  result ^= Arg<unsigned long>(0);
11858  break;
11859  case ePARAM_REF:
11860  nodeMask = 1;
11861  result ^= Arg<unsigned long>(0);
11862  break;
11863  case ePORT_REF:
11864  nodeMask = 1;
11865  result ^= Arg<unsigned long>(0);
11866  break;
11867  case eFWD_REF:
11868  nodeMask = 1;
11869  result ^= Arg<unsigned long>(0);
11870  break;
11871  case eGENVAR_REF:
11872  nodeMask = 1;
11873  result ^= Arg<unsigned long>(0);
11874  break;
11875  case eENUM_REF:
11876  nodeMask = 1;
11877  result ^= Arg<unsigned long>(0);
11878  break;
11879  case eTYPE_REF:
11880  nodeMask = 1;
11881  result ^= Arg<unsigned long>(0);
11882  break;
11883  case eNET_DECL:
11884  nodeMask = 1;
11885  result ^= Arg<unsigned long>(0);
11886  break;
11887  case eVAR_DECL:
11888  nodeMask = 1;
11889  result ^= Arg<unsigned long>(0);
11890  break;
11891  case ePARAM_DECL:
11892  nodeMask = 1;
11893  result ^= Arg<unsigned long>(0);
11894  break;
11895  case eSPECPARAM_DECL:
11896  nodeMask = 1;
11897  result ^= Arg<unsigned long>(0);
11898  break;
11899  case ePORT_DECL:
11900  nodeMask = 1;
11901  result ^= Arg<unsigned long>(0);
11902  break;
11903  case eGENVAR_DECL:
11904  nodeMask = 1;
11905  result ^= Arg<unsigned long>(0);
11906  break;
11907  case eTYPEDEF_DECL:
11908  nodeMask = 1;
11909  result ^= Arg<unsigned long>(0);
11910  break;
11911  case eLIST:
11912  nodeMask = 0;
11913  break;
11914  case eRANGE:
11915  nodeMask = 0;
11916  break;
11917  case eSLICE:
11918  nodeMask = 0;
11919  break;
11920  case ePSLICE:
11921  nodeMask = 0;
11922  break;
11923  case eMSLICE:
11924  nodeMask = 0;
11925  break;
11926  case eCVRI:
11927  nodeMask = 0;
11928  break;
11929  case eCVIR:
11930  nodeMask = 0;
11931  break;
11932  case eREP:
11933  nodeMask = 0;
11934  break;
11935  case eCAT:
11936  nodeMask = 0;
11937  break;
11938  case eUCAT:
11939  nodeMask = 0;
11940  break;
11941  case eCOM:
11942  nodeMask = 0;
11943  break;
11944  case eNEG:
11945  nodeMask = 0;
11946  break;
11947  case ePLUS:
11948  nodeMask = 0;
11949  break;
11950  case eNOT:
11951  nodeMask = 0;
11952  break;
11953  case eGT:
11954  nodeMask = 0;
11955  break;
11956  case eGE:
11957  nodeMask = 0;
11958  break;
11959  case eLT:
11960  nodeMask = 0;
11961  break;
11962  case eLE:
11963  nodeMask = 0;
11964  break;
11965  case eLAND:
11966  nodeMask = 0;
11967  break;
11968  case eLOR:
11969  nodeMask = 0;
11970  break;
11971  case eCEQ:
11972  nodeMask = 0;
11973  break;
11974  case eCNE:
11975  nodeMask = 0;
11976  break;
11977  case eEQ:
11978  nodeMask = 0;
11979  break;
11980  case eNE:
11981  nodeMask = 0;
11982  break;
11983  case eRAND:
11984  nodeMask = 0;
11985  break;
11986  case eRNAND:
11987  nodeMask = 0;
11988  break;
11989  case eROR:
11990  nodeMask = 0;
11991  break;
11992  case eRNOR:
11993  nodeMask = 0;
11994  break;
11995  case eRXOR:
11996  nodeMask = 0;
11997  break;
11998  case eRXNOR:
11999  nodeMask = 0;
12000  break;
12001  case eHOOK:
12002  nodeMask = 0;
12003  break;
12004  case eINIT:
12005  nodeMask = 0;
12006  break;
12007  case eALWAYS:
12008  nodeMask = 0;
12009  break;
12010  case eALWAYS_LATCH:
12011  nodeMask = 0;
12012  break;
12013  case eALWAYS_FF:
12014  nodeMask = 0;
12015  break;
12016  case eALWAYS_COMB:
12017  nodeMask = 0;
12018  break;
12019  case eEVENT:
12020  nodeMask = 0;
12021  break;
12022  case eBLOCK_REF:
12023  nodeMask = 5;
12024  result ^= Arg<unsigned long>(0);
12025  result ^= Arg<bool>(2);
12026  break;
12027  case eSPECIFY_REF:
12028  nodeMask = 1;
12029  result ^= Arg<unsigned long>(0);
12030  break;
12031  case eASSIGN:
12032  nodeMask = 0;
12033  break;
12034  case eGASSIGN:
12035  nodeMask = 1;
12036  result ^= Arg<bool>(0);
12037  break;
12038  case eADD_ASSIGN:
12039  nodeMask = 0;
12040  break;
12041  case eSUB_ASSIGN:
12042  nodeMask = 0;
12043  break;
12044  case eMUL_ASSIGN:
12045  nodeMask = 0;
12046  break;
12047  case eDIV_ASSIGN:
12048  nodeMask = 0;
12049  break;
12050  case eMOD_ASSIGN:
12051  nodeMask = 0;
12052  break;
12053  case eAND_ASSIGN:
12054  nodeMask = 0;
12055  break;
12056  case eOR_ASSIGN:
12057  nodeMask = 0;
12058  break;
12059  case eXOR_ASSIGN:
12060  nodeMask = 0;
12061  break;
12062  case eLSH_ASSIGN:
12063  nodeMask = 0;
12064  break;
12065  case eRSH_ASSIGN:
12066  nodeMask = 0;
12067  break;
12068  case eLSHA_ASSIGN:
12069  nodeMask = 0;
12070  break;
12071  case eRSHA_ASSIGN:
12072  nodeMask = 0;
12073  break;
12074  case eFORCE:
12075  nodeMask = 0;
12076  break;
12077  case eRELEASE:
12078  nodeMask = 0;
12079  break;
12080  case eNBASSIGN:
12081  nodeMask = 0;
12082  break;
12083  case ePOSEDGE:
12084  nodeMask = 0;
12085  break;
12086  case eNEGEDGE:
12087  nodeMask = 0;
12088  break;
12089  case eEDGE:
12090  nodeMask = 2;
12091  result ^= (unsigned long)Arg<Edge_t>(1);
12092  break;
12093  case eEVOR:
12094  nodeMask = 0;
12095  break;
12096  case eDELAY:
12097  nodeMask = 0;
12098  break;
12099  case eMTM:
12100  nodeMask = 0;
12101  break;
12102  case eIF:
12103  nodeMask = 8;
12104  result ^= Arg<unsigned long>(3);
12105  break;
12106  case eFOREVER:
12107  nodeMask = 0;
12108  break;
12109  case eREPEAT:
12110  nodeMask = 0;
12111  break;
12112  case eWHILE:
12113  nodeMask = 0;
12114  break;
12115  case eWAIT:
12116  nodeMask = 0;
12117  break;
12118  case eFOR:
12119  nodeMask = 0;
12120  break;
12121  case eCASE:
12122  nodeMask = 12;
12123  result ^= Arg<unsigned long>(2);
12124  result ^= Arg<bool>(3);
12125  break;
12126  case eCASEX:
12127  nodeMask = 4;
12128  result ^= Arg<unsigned long>(2);
12129  break;
12130  case eCASEZ:
12131  nodeMask = 4;
12132  result ^= Arg<unsigned long>(2);
12133  break;
12134  case eCASEITEM:
12135  nodeMask = 0;
12136  break;
12137  case eCASSIGN:
12138  nodeMask = 1;
12139  result ^= Arg<unsigned long>(0);
12140  break;
12141  case eARG:
12142  nodeMask = 1;
12143  result ^= Arg<unsigned long>(0);
12144  break;
12145  case eIMPORT:
12146  nodeMask = 1;
12147  result ^= Arg<unsigned long>(0);
12148  break;
12149  case eFUNCTION_DEF:
12150  nodeMask = 1;
12151  result ^= Arg<unsigned long>(0);
12152  break;
12153  case eMODULE_DEF:
12154  nodeMask = 1;
12155  result ^= Arg<unsigned long>(0);
12156  break;
12157  case ePACKAGE_DEF:
12158  nodeMask = 1;
12159  result ^= Arg<unsigned long>(0);
12160  break;
12161  case eREPEAT_CONTROL:
12162  nodeMask = 0;
12163  break;
12164  case eDELAY_CONTROL:
12165  nodeMask = 0;
12166  break;
12167  case eEVENT_CONTROL:
12168  nodeMask = 0;
12169  break;
12170  case eEXTERNAL_REF:
12171  nodeMask = 1;
12172  result ^= Arg<unsigned long>(0);
12173  break;
12174  case ePORT_DEF:
12175  nodeMask = 1;
12176  result ^= Arg<unsigned long>(0);
12177  break;
12178  case eDEFPARAM:
12179  nodeMask = 0;
12180  break;
12181  case ePATH:
12182  nodeMask = 45;
12183  result ^= Arg<int>(0);
12184  result ^= Arg<int>(2);
12185  result ^= Arg<int>(3);
12186  result ^= Arg<int>(5);
12187  break;
12188  case ePATH_ASSIGN:
12189  nodeMask = 0;
12190  break;
12191  case eIFNONE_PATH_ASSIGN:
12192  nodeMask = 0;
12193  break;
12194  case eTRIGGER:
12195  nodeMask = 0;
12196  break;
12197  case ePASSIGN:
12198  nodeMask = 0;
12199  break;
12200  case eDEASSIGN:
12201  nodeMask = 0;
12202  break;
12203  case eDISABLE:
12204  nodeMask = 1;
12205  result ^= Arg<unsigned long>(0);
12206  break;
12207  case eATTRIBUTE:
12208  nodeMask = 1;
12209  result ^= Arg<unsigned long>(0);
12210  break;
12211  case eGIF:
12212  nodeMask = 0;
12213  break;
12214  case eGFOR:
12215  nodeMask = 0;
12216  break;
12217  case eGCASE:
12218  nodeMask = 0;
12219  break;
12220  case eTABLE:
12221  nodeMask = 0;
12222  break;
12223  case eTABLE_ENTRY:
12224  nodeMask = 0;
12225  break;
12226  case eTABLE_SYMBOL:
12227  nodeMask = 1;
12228  result ^= strlen(Arg<char*>(0));
12229  break;
12230  case ePORTLIST_END:
12231  nodeMask = 0;
12232  break;
12233  case eMACRO_EXPR:
12234  nodeMask = 1;
12235  result ^= strlen(Arg<char*>(0));
12236  break;
12237  case eENUM_SPEC:
12238  nodeMask = 1;
12239  result ^= Arg<unsigned long>(0);
12240  break;
12241  case eMEMBER:
12242  nodeMask = 2;
12243  result ^= Arg<unsigned long>(1);
12244  break;
12245  case eRETURN:
12246  nodeMask = 0;
12247  break;
12248  case ePREINC:
12249  nodeMask = 0;
12250  break;
12251  case ePOSTINC:
12252  nodeMask = 0;
12253  break;
12254  case ePREDEC:
12255  nodeMask = 0;
12256  break;
12257  case ePOSTDEC:
12258  nodeMask = 0;
12259  break;
12260  case eCAST:
12261  nodeMask = 0;
12262  break;
12263  case eASSIGNMENT_PATTERN:
12264  nodeMask = 0;
12265  break;
12266  case eDOLLAR:
12267  nodeMask = 0;
12268  break;
12269  }
12270 
12271  for( int i = 0; i < ArgCount(); i++ ) {
12272  if( !((nodeMask>>i)&1) && Arg<CNode*>(i) ) result ^= Arg<CNode*>(i)->Hash();
12273  }
12274  return result;
12275 }
12276 
12277 /***********************************************
12278  Equivalent
12279  - returns TRUE if both trees are equivalent
12280  Note: this currently will only match if
12281  the trees are structurally the same.
12282  It does not attempt rename and match
12283  leaf declarations.
12284  In the future this may be expanded
12285  to match if the trees are functionally
12286  equivalent.
12287 ************************************************/
12288 
12289 int Equivalent( CNode* a, CNode* b )
12290 {
12291  /*
12292  * handles NULL/NULL and trivial equivalence case
12293  */
12294  if( a == b ) {
12295  return TRUE;
12296  }
12297  /*
12298  * reject if one is NULL but not the other
12299  */
12300  if( a == NULL || b == NULL ) {
12301  return FALSE;
12302  }
12303  /*
12304  * reject if node types are different
12305  */
12306  if( a->GetOp() != b->GetOp() ) {
12307  return FALSE;
12308  }
12309 
12310  int nodeMask = 0;
12311  switch( a->GetOp() ) {
12312  case eERROR:
12313  nodeMask = 0;
12314  break;
12315  case eVCONSTANT:
12316  nodeMask = 1;
12317  if( !(*a->Arg<CVector*>(0)==*b->Arg<CVector*>(0)) ) { return FALSE; }
12318  break;
12319  case eRCONSTANT:
12320  nodeMask = 1;
12321  if( !(!strcmp(a->Arg<char*>(0),b->Arg<char*>(0))) ) { return FALSE; }
12322  break;
12323  case eCOMMENT:
12324  nodeMask = 1;
12325  if( !(!strcmp(a->Arg<char*>(0),b->Arg<char*>(0))) ) { return FALSE; }
12326  break;
12327  case eVRQ:
12328  nodeMask = 1;
12329  if( !(!strcmp(a->Arg<char*>(0),b->Arg<char*>(0))) ) { return FALSE; }
12330  break;
12331  case ePRAGMA:
12332  nodeMask = 3;
12333  if( !(!strcmp(a->Arg<char*>(0),b->Arg<char*>(0))) ) { return FALSE; }
12334  if( !(a->Arg<int>(1)==b->Arg<int>(1)) ) { return FALSE; }
12335  break;
12336  case eELIST:
12337  nodeMask = 0;
12338  break;
12339  case eWIDTH:
12340  nodeMask = 0;
12341  break;
12342  case eNOP:
12343  nodeMask = 0;
12344  break;
12345  case eSUB:
12346  nodeMask = 0;
12347  break;
12348  case eMUL:
12349  nodeMask = 0;
12350  break;
12351  case eDIV:
12352  nodeMask = 0;
12353  break;
12354  case ePOW:
12355  nodeMask = 0;
12356  break;
12357  case eADD:
12358  nodeMask = 0;
12359  break;
12360  case eLSH:
12361  nodeMask = 0;
12362  break;
12363  case eRSH:
12364  nodeMask = 0;
12365  break;
12366  case eLSHA:
12367  nodeMask = 0;
12368  break;
12369  case eRSHA:
12370  nodeMask = 0;
12371  break;
12372  case eMOD:
12373  nodeMask = 0;
12374  break;
12375  case eOR:
12376  nodeMask = 0;
12377  break;
12378  case eAND:
12379  nodeMask = 0;
12380  break;
12381  case eANDANDAND:
12382  nodeMask = 0;
12383  break;
12384  case eXOR:
12385  nodeMask = 0;
12386  break;
12387  case eXNOR:
12388  nodeMask = 0;
12389  break;
12390  case eINSTANCE_REF:
12391  nodeMask = 1;
12392  if( !(a->Arg<CInstance*>(0)==b->Arg<CInstance*>(0)) ) { return FALSE; }
12393  break;
12394  case eGATE_REF:
12395  nodeMask = 1;
12396  if( !(a->Arg<CGate*>(0)==b->Arg<CGate*>(0)) ) { return FALSE; }
12397  break;
12398  case eTASK_ENABLE:
12399  nodeMask = 1;
12400  if( !(a->Arg<CSymbol*>(0)==b->Arg<CSymbol*>(0)) ) { return FALSE; }
12401  break;
12402  case eSYSTASK_CALL:
12403  nodeMask = 1;
12404  if( !(a->Arg<CSymbol*>(0)==b->Arg<CSymbol*>(0)) ) { return FALSE; }
12405  break;
12406  case eTIMING_CALL:
12407  nodeMask = 1;
12408  if( !(a->Arg<CSymbol*>(0)==b->Arg<CSymbol*>(0)) ) { return FALSE; }
12409  break;
12410  case eFUNCTION_CALL:
12411  nodeMask = 5;
12412  if( !(a->Arg<CSymbol*>(0)==b->Arg<CSymbol*>(0)) ) { return FALSE; }
12413  if( !(a->Arg<CScope*>(2)==b->Arg<CScope*>(2)) ) { return FALSE; }
12414  break;
12415  case eARRAY:
12416  nodeMask = 0;
12417  break;
12418  case eNET_REF:
12419  nodeMask = 1;
12420  if( !(a->Arg<CNet*>(0)==b->Arg<CNet*>(0)) ) { return FALSE; }
12421  break;
12422  case eVAR_REF:
12423  nodeMask = 1;
12424  if( !(a->Arg<CVar*>(0)==b->Arg<CVar*>(0)) ) { return FALSE; }
12425  break;
12426  case ePARAM_REF:
12427  nodeMask = 1;
12428  if( !(a->Arg<CParam*>(0)==b->Arg<CParam*>(0)) ) { return FALSE; }
12429  break;
12430  case ePORT_REF:
12431  nodeMask = 1;
12432  if( !(a->Arg<CPortDir*>(0)==b->Arg<CPortDir*>(0)) ) { return FALSE; }
12433  break;
12434  case eFWD_REF:
12435  nodeMask = 1;
12436  if( !(a->Arg<CFref*>(0)==b->Arg<CFref*>(0)) ) { return FALSE; }
12437  break;
12438  case eGENVAR_REF:
12439  nodeMask = 1;
12440  if( !(a->Arg<CGenvar*>(0)==b->Arg<CGenvar*>(0)) ) { return FALSE; }
12441  break;
12442  case eENUM_REF:
12443  nodeMask = 1;
12444  MASSERT(FALSE); // arg0<CEnum*>
12445  break;
12446  case eTYPE_REF:
12447  nodeMask = 1;
12448  MASSERT(FALSE); // arg0<CTypedef*>
12449  break;
12450  case eNET_DECL:
12451  nodeMask = 1;
12452  if( !(a->Arg<CNet*>(0)==b->Arg<CNet*>(0)) ) { return FALSE; }
12453  break;
12454  case eVAR_DECL:
12455  nodeMask = 1;
12456  if( !(a->Arg<CVar*>(0)==b->Arg<CVar*>(0)) ) { return FALSE; }
12457  break;
12458  case ePARAM_DECL:
12459  nodeMask = 1;
12460  if( !(a->Arg<CParam*>(0)==b->Arg<CParam*>(0)) ) { return FALSE; }
12461  break;
12462  case eSPECPARAM_DECL:
12463  nodeMask = 1;
12464  if( !(a->Arg<CParam*>(0)==b->Arg<CParam*>(0)) ) { return FALSE; }
12465  break;
12466  case ePORT_DECL:
12467  nodeMask = 1;
12468  if( !(a->Arg<CPortDir*>(0)==b->Arg<CPortDir*>(0)) ) { return FALSE; }
12469  break;
12470  case eGENVAR_DECL:
12471  nodeMask = 1;
12472  if( !(a->Arg<CGenvar*>(0)==b->Arg<CGenvar*>(0)) ) { return FALSE; }
12473  break;
12474  case eTYPEDEF_DECL:
12475  nodeMask = 1;
12476  MASSERT(FALSE); // arg0<CTypedef*>
12477  break;
12478  case eLIST:
12479  nodeMask = 0;
12480  break;
12481  case eRANGE:
12482  nodeMask = 0;
12483  break;
12484  case eSLICE:
12485  nodeMask = 0;
12486  break;
12487  case ePSLICE:
12488  nodeMask = 0;
12489  break;
12490  case eMSLICE:
12491  nodeMask = 0;
12492  break;
12493  case eCVRI:
12494  nodeMask = 0;
12495  break;
12496  case eCVIR:
12497  nodeMask = 0;
12498  break;
12499  case eREP:
12500  nodeMask = 0;
12501  break;
12502  case eCAT:
12503  nodeMask = 0;
12504  break;
12505  case eUCAT:
12506  nodeMask = 0;
12507  break;
12508  case eCOM:
12509  nodeMask = 0;
12510  break;
12511  case eNEG:
12512  nodeMask = 0;
12513  break;
12514  case ePLUS:
12515  nodeMask = 0;
12516  break;
12517  case eNOT:
12518  nodeMask = 0;
12519  break;
12520  case eGT:
12521  nodeMask = 0;
12522  break;
12523  case eGE:
12524  nodeMask = 0;
12525  break;
12526  case eLT:
12527  nodeMask = 0;
12528  break;
12529  case eLE:
12530  nodeMask = 0;
12531  break;
12532  case eLAND:
12533  nodeMask = 0;
12534  break;
12535  case eLOR:
12536  nodeMask = 0;
12537  break;
12538  case eCEQ:
12539  nodeMask = 0;
12540  break;
12541  case eCNE:
12542  nodeMask = 0;
12543  break;
12544  case eEQ:
12545  nodeMask = 0;
12546  break;
12547  case eNE:
12548  nodeMask = 0;
12549  break;
12550  case eRAND:
12551  nodeMask = 0;
12552  break;
12553  case eRNAND:
12554  nodeMask = 0;
12555  break;
12556  case eROR:
12557  nodeMask = 0;
12558  break;
12559  case eRNOR:
12560  nodeMask = 0;
12561  break;
12562  case eRXOR:
12563  nodeMask = 0;
12564  break;
12565  case eRXNOR:
12566  nodeMask = 0;
12567  break;
12568  case eHOOK:
12569  nodeMask = 0;
12570  break;
12571  case eINIT:
12572  nodeMask = 0;
12573  break;
12574  case eALWAYS:
12575  nodeMask = 0;
12576  break;
12577  case eALWAYS_LATCH:
12578  nodeMask = 0;
12579  break;
12580  case eALWAYS_FF:
12581  nodeMask = 0;
12582  break;
12583  case eALWAYS_COMB:
12584  nodeMask = 0;
12585  break;
12586  case eEVENT:
12587  nodeMask = 0;
12588  break;
12589  case eBLOCK_REF:
12590  nodeMask = 5;
12591  if( !(a->Arg<CBlock*>(0)==b->Arg<CBlock*>(0)) ) { return FALSE; }
12592  MASSERT(FALSE); // arg2<bool>
12593  break;
12594  case eSPECIFY_REF:
12595  nodeMask = 1;
12596  if( !(a->Arg<CSpecify*>(0)==b->Arg<CSpecify*>(0)) ) { return FALSE; }
12597  break;
12598  case eASSIGN:
12599  nodeMask = 0;
12600  break;
12601  case eGASSIGN:
12602  nodeMask = 1;
12603  MASSERT(FALSE); // arg0<bool>
12604  break;
12605  case eADD_ASSIGN:
12606  nodeMask = 0;
12607  break;
12608  case eSUB_ASSIGN:
12609  nodeMask = 0;
12610  break;
12611  case eMUL_ASSIGN:
12612  nodeMask = 0;
12613  break;
12614  case eDIV_ASSIGN:
12615  nodeMask = 0;
12616  break;
12617  case eMOD_ASSIGN:
12618  nodeMask = 0;
12619  break;
12620  case eAND_ASSIGN:
12621  nodeMask = 0;
12622  break;
12623  case eOR_ASSIGN:
12624  nodeMask = 0;
12625  break;
12626  case eXOR_ASSIGN:
12627  nodeMask = 0;
12628  break;
12629  case eLSH_ASSIGN:
12630  nodeMask = 0;
12631  break;
12632  case eRSH_ASSIGN:
12633  nodeMask = 0;
12634  break;
12635  case eLSHA_ASSIGN:
12636  nodeMask = 0;
12637  break;
12638  case eRSHA_ASSIGN:
12639  nodeMask = 0;
12640  break;
12641  case eFORCE:
12642  nodeMask = 0;
12643  break;
12644  case eRELEASE:
12645  nodeMask = 0;
12646  break;
12647  case eNBASSIGN:
12648  nodeMask = 0;
12649  break;
12650  case ePOSEDGE:
12651  nodeMask = 0;
12652  break;
12653  case eNEGEDGE:
12654  nodeMask = 0;
12655  break;
12656  case eEDGE:
12657  nodeMask = 2;
12658  if( !(a->Arg<Edge_t>(1)==b->Arg<Edge_t>(1)) ) { return FALSE; }
12659  break;
12660  case eEVOR:
12661  nodeMask = 0;
12662  break;
12663  case eDELAY:
12664  nodeMask = 0;
12665  break;
12666  case eMTM:
12667  nodeMask = 0;
12668  break;
12669  case eIF:
12670  nodeMask = 8;
12671  MASSERT(FALSE); // arg3<ConditionalType>
12672  break;
12673  case eFOREVER:
12674  nodeMask = 0;
12675  break;
12676  case eREPEAT:
12677  nodeMask = 0;
12678  break;
12679  case eWHILE:
12680  nodeMask = 0;
12681  break;
12682  case eWAIT:
12683  nodeMask = 0;
12684  break;
12685  case eFOR:
12686  nodeMask = 0;
12687  break;
12688  case eCASE:
12689  nodeMask = 12;
12690  MASSERT(FALSE); // arg2<ConditionalType>
12691  MASSERT(FALSE); // arg3<bool>
12692  break;
12693  case eCASEX:
12694  nodeMask = 4;
12695  MASSERT(FALSE); // arg2<ConditionalType>
12696  break;
12697  case eCASEZ:
12698  nodeMask = 4;
12699  MASSERT(FALSE); // arg2<ConditionalType>
12700  break;
12701  case eCASEITEM:
12702  nodeMask = 0;
12703  break;
12704  case eCASSIGN:
12705  nodeMask = 1;
12706  if( !(a->Arg<StrengthPair_t*>(0)==b->Arg<StrengthPair_t*>(0)) ) { return FALSE; }
12707  break;
12708  case eARG:
12709  nodeMask = 1;
12710  if( !(a->Arg<CSymbol*>(0)==b->Arg<CSymbol*>(0)) ) { return FALSE; }
12711  break;
12712  case eIMPORT:
12713  nodeMask = 1;
12714  if( !(a->Arg<CSymbol*>(0)==b->Arg<CSymbol*>(0)) ) { return FALSE; }
12715  break;
12716  case eFUNCTION_DEF:
12717  nodeMask = 1;
12718  if( !(a->Arg<CFunction*>(0)==b->Arg<CFunction*>(0)) ) { return FALSE; }
12719  break;
12720  case eMODULE_DEF:
12721  nodeMask = 1;
12722  if( !(a->Arg<CModule*>(0)==b->Arg<CModule*>(0)) ) { return FALSE; }
12723  break;
12724  case ePACKAGE_DEF:
12725  nodeMask = 1;
12726  if( !(a->Arg<CPackage*>(0)==b->Arg<CPackage*>(0)) ) { return FALSE; }
12727  break;
12728  case eREPEAT_CONTROL:
12729  nodeMask = 0;
12730  break;
12731  case eDELAY_CONTROL:
12732  nodeMask = 0;
12733  break;
12734  case eEVENT_CONTROL:
12735  nodeMask = 0;
12736  break;
12737  case eEXTERNAL_REF:
12738  nodeMask = 1;
12739  if( !(a->Arg<CSymbol*>(0)==b->Arg<CSymbol*>(0)) ) { return FALSE; }
12740  break;
12741  case ePORT_DEF:
12742  nodeMask = 1;
12743  if( !(a->Arg<CPort*>(0)==b->Arg<CPort*>(0)) ) { return FALSE; }
12744  break;
12745  case eDEFPARAM:
12746  nodeMask = 0;
12747  break;
12748  case ePATH:
12749  nodeMask = 45;
12750  if( !(a->Arg<int>(0)==b->Arg<int>(0)) ) { return FALSE; }
12751  if( !(a->Arg<int>(2)==b->Arg<int>(2)) ) { return FALSE; }
12752  if( !(a->Arg<int>(3)==b->Arg<int>(3)) ) { return FALSE; }
12753  if( !(a->Arg<int>(5)==b->Arg<int>(5)) ) { return FALSE; }
12754  break;
12755  case ePATH_ASSIGN:
12756  nodeMask = 0;
12757  break;
12758  case eIFNONE_PATH_ASSIGN:
12759  nodeMask = 0;
12760  break;
12761  case eTRIGGER:
12762  nodeMask = 0;
12763  break;
12764  case ePASSIGN:
12765  nodeMask = 0;
12766  break;
12767  case eDEASSIGN:
12768  nodeMask = 0;
12769  break;
12770  case eDISABLE:
12771  nodeMask = 1;
12772  if( !(a->Arg<CSymbol*>(0)==b->Arg<CSymbol*>(0)) ) { return FALSE; }
12773  break;
12774  case eATTRIBUTE:
12775  nodeMask = 1;
12776  if( !(a->Arg<CAttr*>(0)==b->Arg<CAttr*>(0)) ) { return FALSE; }
12777  break;
12778  case eGIF:
12779  nodeMask = 0;
12780  break;
12781  case eGFOR:
12782  nodeMask = 0;
12783  break;
12784  case eGCASE:
12785  nodeMask = 0;
12786  break;
12787  case eTABLE:
12788  nodeMask = 0;
12789  break;
12790  case eTABLE_ENTRY:
12791  nodeMask = 0;
12792  break;
12793  case eTABLE_SYMBOL:
12794  nodeMask = 1;
12795  if( !(!strcmp(a->Arg<char*>(0),b->Arg<char*>(0))) ) { return FALSE; }
12796  break;
12797  case ePORTLIST_END:
12798  nodeMask = 0;
12799  break;
12800  case eMACRO_EXPR:
12801  nodeMask = 1;
12802  if( !(!strcmp(a->Arg<char*>(0),b->Arg<char*>(0))) ) { return FALSE; }
12803  break;
12804  case eENUM_SPEC:
12805  nodeMask = 1;
12806  if( !(a->Arg<CSymbol*>(0)==b->Arg<CSymbol*>(0)) ) { return FALSE; }
12807  break;
12808  case eMEMBER:
12809  nodeMask = 2;
12810  if( !(a->Arg<CSymbol*>(1)==b->Arg<CSymbol*>(1)) ) { return FALSE; }
12811  break;
12812  case eRETURN:
12813  nodeMask = 0;
12814  break;
12815  case ePREINC:
12816  nodeMask = 0;
12817  break;
12818  case ePOSTINC:
12819  nodeMask = 0;
12820  break;
12821  case ePREDEC:
12822  nodeMask = 0;
12823  break;
12824  case ePOSTDEC:
12825  nodeMask = 0;
12826  break;
12827  case eCAST:
12828  nodeMask = 0;
12829  break;
12830  case eASSIGNMENT_PATTERN:
12831  nodeMask = 0;
12832  break;
12833  case eDOLLAR:
12834  nodeMask = 0;
12835  break;
12836  }
12837 
12838  for( int i = 0; i < a->ArgCount(); i++ ) {
12839  if( !((nodeMask>>i)&1) &&
12840  !Equivalent(a->Arg<CNode*>(i),b->Arg<CNode*>(i)) ) return FALSE;
12841  }
12842  return TRUE;
12843 }
12844 
12845 /*************************************************
12846  IsEvaluateable
12847  - returns true if expression can be evaluated
12848 **************************************************/
12849 
12851 {
12852  switch( op ) {
12853  case eFUNCTION_CALL:
12854  return CFunction::Evaluateable(Arg<CSymbol*>(0),Arg<CNode*>(1),Arg<CBlock*>(2));;
12855  case ePARAM_REF:
12856  return Arg<CParam*>(0)->GetExpression()->IsEvaluateable();
12857  case eENUM_REF:
12858  return Arg<CParam*>(0)->GetExpression()->IsEvaluateable();
12859  case eMACRO_EXPR:
12860  return Arg<CNode*>(1) ? Arg<CNode*>(1)->IsEvaluateable() : FALSE;
12861  case eVCONSTANT:
12862  case eRCONSTANT:
12863  return TRUE;
12864  case eWIDTH:
12865  case eSUB:
12866  case eMUL:
12867  case eDIV:
12868  case ePOW:
12869  case eADD:
12870  case eLSH:
12871  case eRSH:
12872  case eLSHA:
12873  case eRSHA:
12874  case eMOD:
12875  case eOR:
12876  case eAND:
12877  case eXOR:
12878  case eXNOR:
12879  case eCVRI:
12880  case eCVIR:
12881  case eREP:
12882  case eCAT:
12883  case eUCAT:
12884  case eCOM:
12885  case eNEG:
12886  case ePLUS:
12887  case eNOT:
12888  case eGT:
12889  case eGE:
12890  case eLT:
12891  case eLE:
12892  case eLAND:
12893  case eLOR:
12894  case eCEQ:
12895  case eCNE:
12896  case eEQ:
12897  case eNE:
12898  case eRAND:
12899  case eRNAND:
12900  case eROR:
12901  case eRNOR:
12902  case eRXOR:
12903  case eRXNOR:
12904  case eHOOK:
12905  break;
12906  case eERROR:
12907  case eCOMMENT:
12908  case eVRQ:
12909  case ePRAGMA:
12910  case eELIST:
12911  case eNOP:
12912  case eANDANDAND:
12913  case eINSTANCE_REF:
12914  case eGATE_REF:
12915  case eTASK_ENABLE:
12916  case eSYSTASK_CALL:
12917  case eTIMING_CALL:
12918  case eARRAY:
12919  case eNET_REF:
12920  case eVAR_REF:
12921  case ePORT_REF:
12922  case eFWD_REF:
12923  case eGENVAR_REF:
12924  case eTYPE_REF:
12925  case eNET_DECL:
12926  case eVAR_DECL:
12927  case ePARAM_DECL:
12928  case eSPECPARAM_DECL:
12929  case ePORT_DECL:
12930  case eGENVAR_DECL:
12931  case eTYPEDEF_DECL:
12932  case eLIST:
12933  case eRANGE:
12934  case eSLICE:
12935  case ePSLICE:
12936  case eMSLICE:
12937  case eINIT:
12938  case eALWAYS:
12939  case eALWAYS_LATCH:
12940  case eALWAYS_FF:
12941  case eALWAYS_COMB:
12942  case eEVENT:
12943  case eBLOCK_REF:
12944  case eSPECIFY_REF:
12945  case eASSIGN:
12946  case eGASSIGN:
12947  case eADD_ASSIGN:
12948  case eSUB_ASSIGN:
12949  case eMUL_ASSIGN:
12950  case eDIV_ASSIGN:
12951  case eMOD_ASSIGN:
12952  case eAND_ASSIGN:
12953  case eOR_ASSIGN:
12954  case eXOR_ASSIGN:
12955  case eLSH_ASSIGN:
12956  case eRSH_ASSIGN:
12957  case eLSHA_ASSIGN:
12958  case eRSHA_ASSIGN:
12959  case eFORCE:
12960  case eRELEASE:
12961  case eNBASSIGN:
12962  case ePOSEDGE:
12963  case eNEGEDGE:
12964  case eEDGE:
12965  case eEVOR:
12966  case eDELAY:
12967  case eMTM:
12968  case eIF:
12969  case eFOREVER:
12970  case eREPEAT:
12971  case eWHILE:
12972  case eWAIT:
12973  case eFOR:
12974  case eCASE:
12975  case eCASEX:
12976  case eCASEZ:
12977  case eCASEITEM:
12978  case eCASSIGN:
12979  case eARG:
12980  case eIMPORT:
12981  case eFUNCTION_DEF:
12982  case eMODULE_DEF:
12983  case ePACKAGE_DEF:
12984  case eREPEAT_CONTROL:
12985  case eDELAY_CONTROL:
12986  case eEVENT_CONTROL:
12987  case eEXTERNAL_REF:
12988  case ePORT_DEF:
12989  case eDEFPARAM:
12990  case ePATH:
12991  case ePATH_ASSIGN:
12992  case eIFNONE_PATH_ASSIGN:
12993  case eTRIGGER:
12994  case ePASSIGN:
12995  case eDEASSIGN:
12996  case eDISABLE:
12997  case eATTRIBUTE:
12998  case eGIF:
12999  case eGFOR:
13000  case eGCASE:
13001  case eTABLE:
13002  case eTABLE_ENTRY:
13003  case eTABLE_SYMBOL:
13004  case ePORTLIST_END:
13005  case eENUM_SPEC:
13006  case eMEMBER:
13007  case eRETURN:
13008  case ePREINC:
13009  case ePOSTINC:
13010  case ePREDEC:
13011  case ePOSTDEC:
13012  case eCAST:
13013  case eASSIGNMENT_PATTERN:
13014  case eDOLLAR:
13015  return FALSE;
13016  default:
13017  MASSERT( FALSE );
13018  }
13019 
13020  for( int i = 0; i < ArgCount(); i++ ) {
13021  if( !Arg<CNode*>(i)->IsEvaluateable() ) return FALSE;
13022  }
13023 
13024  return TRUE;
13025 }
13026 
13027 /*************************************************
13028  _EvalVector
13029  - Helper function for EvalVector.
13030  Evaluates constant vector expression tree.
13031  Requires tree nodes to be labeled and
13032  augmented with conversion nodes.
13033 **************************************************/
13034 
13035 
13036 void CNode::_EvalVector( CVector& v )
13037 {
13038  switch( op ) {
13039  case eVCONSTANT:
13040  { int width = v.GetWidth(); v.SetWidth(Arg<CVector*>(0)->GetWidth()); v = *Arg<CVector*>(0); v.SetWidth(width); };
13041  break;
13042  case eWIDTH:
13043  {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;};
13044  break;
13045  case eSUB:
13046  EVAL_VECTOR_BINARY(Sub);
13047  break;
13048  case eMUL:
13049  EVAL_VECTOR_BINARY(Mul);
13050  break;
13051  case eDIV:
13052  EVAL_VECTOR_BINARY(Div);
13053  break;
13054  case ePOW:
13055  EVAL_VECTOR_BINARY(Pow);
13056  break;
13057  case eADD:
13058  EVAL_VECTOR_BINARY(Add);
13059  break;
13060  case eLSH:
13061  EVAL_VECTOR_BINARY_SELF_RIGHT(Lsh);
13062  break;
13063  case eRSH:
13064  EVAL_VECTOR_BINARY_SELF_RIGHT(Rsh);
13065  break;
13066  case eLSHA:
13067  EVAL_VECTOR_BINARY_SELF_RIGHT(Lsha);
13068  break;
13069  case eRSHA:
13070  EVAL_VECTOR_BINARY_SELF_RIGHT(Rsha);
13071  break;
13072  case eMOD:
13073  EVAL_VECTOR_BINARY(Mod);
13074  break;
13075  case eOR:
13076  EVAL_VECTOR_BINARY(Or);
13077  break;
13078  case eAND:
13079  EVAL_VECTOR_BINARY(And);
13080  break;
13081  case eXOR:
13082  EVAL_VECTOR_BINARY(Xor);
13083  break;
13084  case eXNOR:
13085  EVAL_VECTOR_BINARY(Xnor);
13086  break;
13087  case eFUNCTION_CALL:
13088  CFunction::EvalVector(v,Arg<CSymbol*>(0),Arg<CNode*>(1),Arg<CBlock*>(2));;
13089  break;
13090  case ePARAM_REF:
13091  EVAL_VECTOR_PARAM_REF();
13092  break;
13093  case eENUM_REF:
13094  EVAL_VECTOR_ENUM_REF();
13095  break;
13096  case eCVRI:
13097  v.LoadReal( Arg<CNode*>(0)->_EvalReal() );
13098  break;
13099  case eREP:
13100  EVAL_VECTOR_BINARY(Rep);
13101  break;
13102  case eCAT:
13103  EVAL_VECTOR_BINARY(Cat);
13104  break;
13105  case eUCAT:
13106  { CVector vv(Arg<CNode*>(0)->width); Arg<CNode*>(0)->_EvalVector(vv); v = vv;};
13107  break;
13108  case eCOM:
13109  EVAL_VECTOR_UNARY(Com);
13110  break;
13111  case eNEG:
13112  EVAL_VECTOR_UNARY(Neg);
13113  break;
13114  case ePLUS:
13115  EVAL_VECTOR_UNARY(Plus);
13116  break;
13117  case eNOT:
13118  EVAL_VECTOR_UNARY(Not);
13119  break;
13120  case eGT:
13121  EVAL_RELATIONAL(Gt);
13122  break;
13123  case eGE:
13124  EVAL_RELATIONAL(Ge);
13125  break;
13126  case eLT:
13127  EVAL_RELATIONAL(Lt);
13128  break;
13129  case eLE:
13130  EVAL_RELATIONAL(Le);
13131  break;
13132  case eLAND:
13133  EVAL_VECTOR_BINARY(Land);
13134  break;
13135  case eLOR:
13136  EVAL_VECTOR_BINARY(Lor);
13137  break;
13138  case eCEQ:
13139  EVAL_RELATIONAL(Ceq);
13140  break;
13141  case eCNE:
13142  EVAL_RELATIONAL(Cne);
13143  break;
13144  case eEQ:
13145  EVAL_RELATIONAL(Eq);
13146  break;
13147  case eNE:
13148  EVAL_RELATIONAL(Ne);
13149  break;
13150  case eRAND:
13151  EVAL_VECTOR_UNARY_SELF(Rand);
13152  break;
13153  case eRNAND:
13154  EVAL_VECTOR_UNARY_SELF(Rnand);
13155  break;
13156  case eROR:
13157  EVAL_VECTOR_UNARY_SELF(Ror);
13158  break;
13159  case eRNOR:
13160  EVAL_VECTOR_UNARY_SELF(Rnor);
13161  break;
13162  case eRXOR:
13163  EVAL_VECTOR_UNARY_SELF(Rxor);
13164  break;
13165  case eRXNOR:
13166  EVAL_VECTOR_UNARY_SELF(Rxnor);
13167  break;
13168  case eHOOK:
13169  EVAL_VECTOR_HOOK();
13170  break;
13171  case eMACRO_EXPR:
13172  Arg<CNode*>(1)->EvalVector(v);
13173  break;
13174  default:
13175  MASSERT( FALSE );
13176  }
13177 }
13178 
13179 
13180 /*************************************************
13181  _EvalReal
13182  - Helper function for EvalReal.
13183  Evaluates constant real expression tree.
13184  Requires tree nodes to be labeled and
13185  augmented with conversion nodes.
13186 **************************************************/
13187 
13188 double CNode::_EvalReal()
13189 {
13190  double d;
13191  switch( op ) {
13192  case eRCONSTANT:
13193  d = s2d(Arg<char*>(0));
13194  break;
13195  case eSUB:
13196  EVAL_REAL_BINARY(Sub);
13197  break;
13198  case eMUL:
13199  EVAL_REAL_BINARY(Mul);
13200  break;
13201  case eDIV:
13202  EVAL_REAL_BINARY(Div);
13203  break;
13204  case ePOW:
13205  EVAL_REAL_BINARY(Pow);
13206  break;
13207  case eADD:
13208  EVAL_REAL_BINARY(Add);
13209  break;
13210  case eFUNCTION_CALL:
13211  d = CFunction::EvalReal(Arg<CSymbol*>(0),Arg<CNode*>(1),Arg<CBlock*>(2));;
13212  break;
13213  case ePARAM_REF:
13214  EVAL_REAL_PARAM_REF();
13215  break;
13216  case eENUM_REF:
13217  EVAL_REAL_ENUM_REF();
13218  break;
13219  case eCVIR:
13220  { CVector v(Arg<CNode*>(0)->width); v.Signed(Arg<CNode*>(0)->type == eS); Arg<CNode*>(0)->_EvalVector(v); d = v.GetReal(); };
13221  break;
13222  case eNEG:
13223  EVAL_REAL_UNARY(Neg);
13224  break;
13225  case ePLUS:
13226  EVAL_REAL_UNARY(Plus);
13227  break;
13228  case eHOOK:
13229  EVAL_REAL_HOOK();
13230  break;
13231  case eMACRO_EXPR:
13232  d = Arg<CNode*>(1)->EvalReal();
13233  break;
13234  default:
13235  MASSERT( FALSE );
13236  }
13237  return d;
13238 }
13239 /************************************************
13240  ConditionalWiden
13241  - return non-zero if op conditionally
13242  widens operands
13243 **************************************************/
13244 int CNode::ConditionalWiden()
13245 {
13246  switch( GetOp() ) {
13247  case eVCONSTANT:
13248  return 0;
13249  case eRCONSTANT:
13250  return 0;
13251  case eELIST:
13252  return 0;
13253  case eWIDTH:
13254  return 0;
13255  case eSUB:
13256  return 0;
13257  case eMUL:
13258  return 0;
13259  case eDIV:
13260  return 0;
13261  case ePOW:
13262  return 0;
13263  case eADD:
13264  return 0;
13265  case eLSH:
13266  return 0;
13267  case eRSH:
13268  return 0;
13269  case eLSHA:
13270  return 0;
13271  case eRSHA:
13272  return 0;
13273  case eMOD:
13274  return 0;
13275  case eOR:
13276  return 1;
13277  case eAND:
13278  return 1;
13279  case eANDANDAND:
13280  return 0;
13281  case eXOR:
13282  return 1;
13283  case eXNOR:
13284  return 1;
13285  case eSYSTASK_CALL:
13286  return 0;
13287  case eFUNCTION_CALL:
13288  return 0;
13289  case eARRAY:
13290  return 0;
13291  case eNET_REF:
13292  return 0;
13293  case eVAR_REF:
13294  return 0;
13295  case ePARAM_REF:
13296  return 0;
13297  case ePORT_REF:
13298  return 0;
13299  case eFWD_REF:
13300  return 0;
13301  case eGENVAR_REF:
13302  return 0;
13303  case eENUM_REF:
13304  return 0;
13305  case eTYPE_REF:
13306  return 0;
13307  case eRANGE:
13308  return 0;
13309  case eSLICE:
13310  return 0;
13311  case ePSLICE:
13312  return 0;
13313  case eMSLICE:
13314  return 0;
13315  case eCVRI:
13316  return 0;
13317  case eCVIR:
13318  return 0;
13319  case eREP:
13320  return 0;
13321  case eCAT:
13322  return 0;
13323  case eUCAT:
13324  return 0;
13325  case eCOM:
13326  return 0;
13327  case eNEG:
13328  return 0;
13329  case ePLUS:
13330  return 0;
13331  case eNOT:
13332  return 0;
13333  case eGT:
13334  return 0;
13335  case eGE:
13336  return 0;
13337  case eLT:
13338  return 0;
13339  case eLE:
13340  return 0;
13341  case eLAND:
13342  return 0;
13343  case eLOR:
13344  return 0;
13345  case eCEQ:
13346  return 0;
13347  case eCNE:
13348  return 0;
13349  case eEQ:
13350  return 0;
13351  case eNE:
13352  return 0;
13353  case eRAND:
13354  return 0;
13355  case eRNAND:
13356  return 0;
13357  case eROR:
13358  return 0;
13359  case eRNOR:
13360  return 0;
13361  case eRXOR:
13362  return 0;
13363  case eRXNOR:
13364  return 0;
13365  case eHOOK:
13366  return 0;
13367  case ePOSEDGE:
13368  return 0;
13369  case eNEGEDGE:
13370  return 0;
13371  case eEVOR:
13372  return 0;
13373  case eMTM:
13374  return 0;
13375  case eEXTERNAL_REF:
13376  return 0;
13377  case eATTRIBUTE:
13378  return 0;
13379  case eMACRO_EXPR:
13380  return 0;
13381  case eMEMBER:
13382  return 0;
13383  case ePREINC:
13384  return 0;
13385  case ePOSTINC:
13386  return 0;
13387  case ePREDEC:
13388  return 0;
13389  case ePOSTDEC:
13390  return 0;
13391  case eCAST:
13392  return 0;
13393  case eASSIGNMENT_PATTERN:
13394  return 0;
13395  case eDOLLAR:
13396  return 0;
13397  default:
13398  MASSERT( FALSE );
13399  }
13400  return 0;
13401 }
13402 
13403 /************************************************
13404  NodeMask
13405  - return a bit vector with 1's where the
13406  type is CNode*
13407 **************************************************/
13408 unsigned CNode::NodeMask()
13409 {
13410  switch( GetOp() ) {
13411  case eERROR:
13412  return 0;
13413  case eVCONSTANT:
13414  return 0;
13415  case eRCONSTANT:
13416  return 0;
13417  case eCOMMENT:
13418  return 0;
13419  case eVRQ:
13420  return 0;
13421  case ePRAGMA:
13422  return 0;
13423  case eELIST:
13424  return 3;
13425  case eWIDTH:
13426  return 3;
13427  case eNOP:
13428  return 0;
13429  case eSUB:
13430  return 3;
13431  case eMUL:
13432  return 3;
13433  case eDIV:
13434  return 3;
13435  case ePOW:
13436  return 3;
13437  case eADD:
13438  return 3;
13439  case eLSH:
13440  return 3;
13441  case eRSH:
13442  return 3;
13443  case eLSHA:
13444  return 3;
13445  case eRSHA:
13446  return 3;
13447  case eMOD:
13448  return 3;
13449  case eOR:
13450  return 3;
13451  case eAND:
13452  return 3;
13453  case eANDANDAND:
13454  return 3;
13455  case eXOR:
13456  return 3;
13457  case eXNOR:
13458  return 3;
13459  case eINSTANCE_REF:
13460  return 0;
13461  case eGATE_REF:
13462  return 0;
13463  case eTASK_ENABLE:
13464  return 2;
13465  case eSYSTASK_CALL:
13466  return 2;
13467  case eTIMING_CALL:
13468  return 2;
13469  case eFUNCTION_CALL:
13470  return 2;
13471  case eARRAY:
13472  return 3;
13473  case eNET_REF:
13474  return 0;
13475  case eVAR_REF:
13476  return 0;
13477  case ePARAM_REF:
13478  return 0;
13479  case ePORT_REF:
13480  return 0;
13481  case eFWD_REF:
13482  return 0;
13483  case eGENVAR_REF:
13484  return 0;
13485  case eENUM_REF:
13486  return 0;
13487  case eTYPE_REF:
13488  return 0;
13489  case eNET_DECL:
13490  return 2;
13491  case eVAR_DECL:
13492  return 2;
13493  case ePARAM_DECL:
13494  return 0;
13495  case eSPECPARAM_DECL:
13496  return 0;
13497  case ePORT_DECL:
13498  return 0;
13499  case eGENVAR_DECL:
13500  return 0;
13501  case eTYPEDEF_DECL:
13502  return 0;
13503  case eLIST:
13504  return 3;
13505  case eRANGE:
13506  return 3;
13507  case eSLICE:
13508  return 3;
13509  case ePSLICE:
13510  return 3;
13511  case eMSLICE:
13512  return 3;
13513  case eCVRI:
13514  return 1;
13515  case eCVIR:
13516  return 1;
13517  case eREP:
13518  return 3;
13519  case eCAT:
13520  return 3;
13521  case eUCAT:
13522  return 1;
13523  case eCOM:
13524  return 1;
13525  case eNEG:
13526  return 1;
13527  case ePLUS:
13528  return 1;
13529  case eNOT:
13530  return 1;
13531  case eGT:
13532  return 3;
13533  case eGE:
13534  return 3;
13535  case eLT:
13536  return 3;
13537  case eLE:
13538  return 3;
13539  case eLAND:
13540  return 3;
13541  case eLOR:
13542  return 3;
13543  case eCEQ:
13544  return 3;
13545  case eCNE:
13546  return 3;
13547  case eEQ:
13548  return 3;
13549  case eNE:
13550  return 3;
13551  case eRAND:
13552  return 1;
13553  case eRNAND:
13554  return 1;
13555  case eROR:
13556  return 1;
13557  case eRNOR:
13558  return 1;
13559  case eRXOR:
13560  return 1;
13561  case eRXNOR:
13562  return 1;
13563  case eHOOK:
13564  return 7;
13565  case eINIT:
13566  return 1;
13567  case eALWAYS:
13568  return 1;
13569  case eALWAYS_LATCH:
13570  return 1;
13571  case eALWAYS_FF:
13572  return 1;
13573  case eALWAYS_COMB:
13574  return 1;
13575  case eEVENT:
13576  return 3;
13577  case eBLOCK_REF:
13578  return 2;
13579  case eSPECIFY_REF:
13580  return 2;
13581  case eASSIGN:
13582  return 7;
13583  case eGASSIGN:
13584  return 6;
13585  case eADD_ASSIGN:
13586  return 7;
13587  case eSUB_ASSIGN:
13588  return 7;
13589  case eMUL_ASSIGN:
13590  return 7;
13591  case eDIV_ASSIGN:
13592  return 7;
13593  case eMOD_ASSIGN:
13594  return 7;
13595  case eAND_ASSIGN:
13596  return 7;
13597  case eOR_ASSIGN:
13598  return 7;
13599  case eXOR_ASSIGN:
13600  return 7;
13601  case eLSH_ASSIGN:
13602  return 7;
13603  case eRSH_ASSIGN:
13604  return 7;
13605  case eLSHA_ASSIGN:
13606  return 7;
13607  case eRSHA_ASSIGN:
13608  return 7;
13609  case eFORCE:
13610  return 3;
13611  case eRELEASE:
13612  return 1;
13613  case eNBASSIGN:
13614  return 7;
13615  case ePOSEDGE:
13616  return 1;
13617  case eNEGEDGE:
13618  return 1;
13619  case eEDGE:
13620  return 1;
13621  case eEVOR:
13622  return 3;
13623  case eDELAY:
13624  return 3;
13625  case eMTM:
13626  return 7;
13627  case eIF:
13628  return 7;
13629  case eFOREVER:
13630  return 1;
13631  case eREPEAT:
13632  return 3;
13633  case eWHILE:
13634  return 3;
13635  case eWAIT:
13636  return 3;
13637  case eFOR:
13638  return 15;
13639  case eCASE:
13640  return 3;
13641  case eCASEX:
13642  return 3;
13643  case eCASEZ:
13644  return 3;
13645  case eCASEITEM:
13646  return 3;
13647  case eCASSIGN:
13648  return 14;
13649  case eARG:
13650  return 2;
13651  case eIMPORT:
13652  return 0;
13653  case eFUNCTION_DEF:
13654  return 0;
13655  case eMODULE_DEF:
13656  return 0;
13657  case ePACKAGE_DEF:
13658  return 0;
13659  case eREPEAT_CONTROL:
13660  return 3;
13661  case eDELAY_CONTROL:
13662  return 1;
13663  case eEVENT_CONTROL:
13664  return 1;
13665  case eEXTERNAL_REF:
13666  return 0;
13667  case ePORT_DEF:
13668  return 0;
13669  case eDEFPARAM:
13670  return 3;
13671  case ePATH:
13672  return 82;
13673  case ePATH_ASSIGN:
13674  return 7;
13675  case eIFNONE_PATH_ASSIGN:
13676  return 3;
13677  case eTRIGGER:
13678  return 1;
13679  case ePASSIGN:
13680  return 3;
13681  case eDEASSIGN:
13682  return 1;
13683  case eDISABLE:
13684  return 0;
13685  case eATTRIBUTE:
13686  return 0;
13687  case eGIF:
13688  return 7;
13689  case eGFOR:
13690  return 15;
13691  case eGCASE:
13692  return 3;
13693  case eTABLE:
13694  return 1;
13695  case eTABLE_ENTRY:
13696  return 1;
13697  case eTABLE_SYMBOL:
13698  return 0;
13699  case ePORTLIST_END:
13700  return 0;
13701  case eMACRO_EXPR:
13702  return 2;
13703  case eENUM_SPEC:
13704  return 6;
13705  case eMEMBER:
13706  return 1;
13707  case eRETURN:
13708  return 1;
13709  case ePREINC:
13710  return 1;
13711  case ePOSTINC:
13712  return 1;
13713  case ePREDEC:
13714  return 1;
13715  case ePOSTDEC:
13716  return 1;
13717  case eCAST:
13718  return 3;
13719  case eASSIGNMENT_PATTERN:
13720  return 1;
13721  case eDOLLAR:
13722  return 0;
13723  default:
13724  MASSERT( FALSE );
13725  }
13726  return 0;
13727 }
13728 
13729 /************************************************
13730  WidthFixed
13731  - return non-zero if op has fixed
13732  self determined width
13733 **************************************************/
13734 int CNode::WidthFixed()
13735 {
13736  switch( GetOp() ) {
13737  case eVCONSTANT:
13738  return NodeMask()==0;
13739  case eRCONSTANT:
13740  return 1;
13741  case eELIST:
13742  return NodeMask()==0;
13743  case eWIDTH:
13744  return NodeMask()==0;
13745  case eSUB:
13746  return NodeMask()==0;
13747  case eMUL:
13748  return NodeMask()==0;
13749  case eDIV:
13750  return NodeMask()==0;
13751  case ePOW:
13752  return NodeMask()==0;
13753  case eADD:
13754  return NodeMask()==0;
13755  case eLSH:
13756  return NodeMask()==0;
13757  case eRSH:
13758  return NodeMask()==0;
13759  case eLSHA:
13760  return NodeMask()==0;
13761  case eRSHA:
13762  return NodeMask()==0;
13763  case eMOD:
13764  return NodeMask()==0;
13765  case eOR:
13766  return NodeMask()==0;
13767  case eAND:
13768  return NodeMask()==0;
13769  case eANDANDAND:
13770  return NodeMask()==0;
13771  case eXOR:
13772  return NodeMask()==0;
13773  case eXNOR:
13774  return NodeMask()==0;
13775  case eSYSTASK_CALL:
13776  return NodeMask()==0;
13777  case eFUNCTION_CALL:
13778  return NodeMask()==0;
13779  case eARRAY:
13780  return NodeMask()==0;
13781  case eNET_REF:
13782  return NodeMask()==0;
13783  case eVAR_REF:
13784  return NodeMask()==0;
13785  case ePARAM_REF:
13786  return NodeMask()==0;
13787  case ePORT_REF:
13788  return NodeMask()==0;
13789  case eFWD_REF:
13790  return NodeMask()==0;
13791  case eGENVAR_REF:
13792  return NodeMask()==0;
13793  case eENUM_REF:
13794  return NodeMask()==0;
13795  case eTYPE_REF:
13796  return 1;
13797  case eRANGE:
13798  return NodeMask()==0;
13799  case eSLICE:
13800  return NodeMask()==0;
13801  case ePSLICE:
13802  return NodeMask()==0;
13803  case eMSLICE:
13804  return NodeMask()==0;
13805  case eCVRI:
13806  return 1;
13807  case eCVIR:
13808  return 1;
13809  case eREP:
13810  return NodeMask()==0;
13811  case eCAT:
13812  return NodeMask()==0;
13813  case eUCAT:
13814  return NodeMask()==0;
13815  case eCOM:
13816  return NodeMask()==0;
13817  case eNEG:
13818  return NodeMask()==0;
13819  case ePLUS:
13820  return NodeMask()==0;
13821  case eNOT:
13822  return 1;
13823  case eGT:
13824  return 1;
13825  case eGE:
13826  return 1;
13827  case eLT:
13828  return 1;
13829  case eLE:
13830  return 1;
13831  case eLAND:
13832  return 1;
13833  case eLOR:
13834  return 1;
13835  case eCEQ:
13836  return 1;
13837  case eCNE:
13838  return 1;
13839  case eEQ:
13840  return 1;
13841  case eNE:
13842  return 1;
13843  case eRAND:
13844  return 1;
13845  case eRNAND:
13846  return 1;
13847  case eROR:
13848  return 1;
13849  case eRNOR:
13850  return 1;
13851  case eRXOR:
13852  return 1;
13853  case eRXNOR:
13854  return 1;
13855  case eHOOK:
13856  return NodeMask()==0;
13857  case ePOSEDGE:
13858  return NodeMask()==0;
13859  case eNEGEDGE:
13860  return NodeMask()==0;
13861  case eEVOR:
13862  return NodeMask()==0;
13863  case eMTM:
13864  return NodeMask()==0;
13865  case eEXTERNAL_REF:
13866  return NodeMask()==0;
13867  case eATTRIBUTE:
13868  return 1;
13869  case eMACRO_EXPR:
13870  return NodeMask()==0;
13871  case eMEMBER:
13872  return NodeMask()==0;
13873  case ePREINC:
13874  return NodeMask()==0;
13875  case ePOSTINC:
13876  return NodeMask()==0;
13877  case ePREDEC:
13878  return NodeMask()==0;
13879  case ePOSTDEC:
13880  return NodeMask()==0;
13881  case eCAST:
13882  return NodeMask()==0;
13883  case eASSIGNMENT_PATTERN:
13884  return 1;
13885  case eDOLLAR:
13886  return 1;
13887  default:
13888  MASSERT( FALSE );
13889  }
13890  return 0;
13891 }
13892 
13893 /************************************************
13894  _LabelBits
13895  - labels type and width fields bottom up
13896 **************************************************/
13899  int error;
13900 };
13901 
13902 void CNode::_LabelBits( CNode* n, void* arg )
13903 {
13904  /*
13905  * If label caching is enabled, don't remark nodes
13906  * already visited. Also disable caching when the
13907  * the eval stack is in use and the node was allocated from
13908  * it as its pointers are temporary and will be recycled.
13909  */
13910  if( labelCacheEnabled && (evalCount == 0 || !evalHeap.IsOwner(n)) ) {
13911  if( labelCache.find(n) != labelCache.end() ) {
13912  return;
13913  }
13914  labelCache[n] = 1;
13915  }
13916 
13917 
13918  LabelBitsInfo* info = (LabelBitsInfo*)arg;
13919  int suppressErrorMessages = info->suppressErrorMessages;
13920  unsigned nodeMask = n->NodeMask();
13921  int conditionalWiden = n->ConditionalWiden();
13922 
13923  switch( n->GetOp() ) {
13924  case eVCONSTANT:
13925  n->type = n->Arg<CVector*>(0)->GetNodeType();
13926  break;
13927  case eRCONSTANT:
13928  if(1) {
13929  n->type = eR;
13930  }
13931  break;
13932  case eELIST:
13933  if( n->Arg<CNode*>(0)->type == eR ) {
13934  info->error = 1;
13935  if( !suppressErrorMessages ) {
13936  error(n->GetCoord(), "Illegal expression operand" );
13937  }
13938  } else if( n->Arg<CNode*>(1)->type == eR ) {
13939  info->error = 1;
13940  if( !suppressErrorMessages ) {
13941  error(n->GetCoord(), "Illegal expression operand" );
13942  }
13943  } else if(1) {
13944  n->type = eB;
13945  }
13946  break;
13947  case eWIDTH:
13948  if( n->Arg<CNode*>(1)->type == eS ) {
13949  n->type = eS;
13950  } else if(1) {
13951  n->type = eB;
13952  }
13953  break;
13954  case eSUB:
13955  if( n->Arg<CNode*>(0)->type == eR ) {
13956  n->type = eR;
13957  } else if( n->Arg<CNode*>(1)->type == eR ) {
13958  n->type = eR;
13959  } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
13960  n->type = eS;
13961  } else if(1) {
13962  n->type = eB;
13963  }
13964  break;
13965  case eMUL:
13966  if( n->Arg<CNode*>(0)->type == eR ) {
13967  n->type = eR;
13968  } else if( n->Arg<CNode*>(1)->type == eR ) {
13969  n->type = eR;
13970  } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
13971  n->type = eS;
13972  } else if(1) {
13973  n->type = eB;
13974  }
13975  break;
13976  case eDIV:
13977  if( n->Arg<CNode*>(0)->type == eR ) {
13978  n->type = eR;
13979  } else if( n->Arg<CNode*>(1)->type == eR ) {
13980  n->type = eR;
13981  } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
13982  n->type = eS;
13983  } else if(1) {
13984  n->type = eB;
13985  }
13986  break;
13987  case ePOW:
13988  if( n->Arg<CNode*>(0)->type == eR ) {
13989  n->type = eR;
13990  } else if( n->Arg<CNode*>(1)->type == eR ) {
13991  n->type = eR;
13992  } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
13993  n->type = eS;
13994  } else if(1) {
13995  n->type = eB;
13996  }
13997  break;
13998  case eADD:
13999  if( n->Arg<CNode*>(0)->type == eR ) {
14000  n->type = eR;
14001  } else if( n->Arg<CNode*>(1)->type == eR ) {
14002  n->type = eR;
14003  } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
14004  n->type = eS;
14005  } else if(1) {
14006  n->type = eB;
14007  }
14008  break;
14009  case eLSH:
14010  if( n->Arg<CNode*>(0)->type == eS ) {
14011  n->type = eS;
14012  } else if(1) {
14013  n->type = eB;
14014  }
14015  break;
14016  case eRSH:
14017  if( n->Arg<CNode*>(0)->type == eS ) {
14018  n->type = eS;
14019  } else if(1) {
14020  n->type = eB;
14021  }
14022  break;
14023  case eLSHA:
14024  if( n->Arg<CNode*>(0)->type == eS ) {
14025  n->type = eS;
14026  } else if(1) {
14027  n->type = eB;
14028  }
14029  break;
14030  case eRSHA:
14031  if( n->Arg<CNode*>(0)->type == eS ) {
14032  n->type = eS;
14033  } else if(1) {
14034  n->type = eB;
14035  }
14036  break;
14037  case eMOD:
14038  if( n->Arg<CNode*>(0)->type == eR ) {
14039  info->error = 1;
14040  if( !suppressErrorMessages ) {
14041  error(n->GetCoord(), "Illegal expression operand" );
14042  }
14043  } else if( n->Arg<CNode*>(1)->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 && n->Arg<CNode*>(1)->type == eS ) {
14049  n->type = eS;
14050  } else if(1) {
14051  n->type = eB;
14052  }
14053  break;
14054  case eOR:
14055  if( n->Arg<CNode*>(0)->type == eR ) {
14056  info->error = 1;
14057  if( !suppressErrorMessages ) {
14058  error(n->GetCoord(), "Illegal expression operand" );
14059  }
14060  } else if( n->Arg<CNode*>(1)->type == eR ) {
14061  info->error = 1;
14062  if( !suppressErrorMessages ) {
14063  error(n->GetCoord(), "Illegal expression operand" );
14064  }
14065  } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
14066  n->type = eS;
14067  } else if(1) {
14068  n->type = eB;
14069  }
14070  break;
14071  case eAND:
14072  if( n->Arg<CNode*>(0)->type == eR ) {
14073  info->error = 1;
14074  if( !suppressErrorMessages ) {
14075  error(n->GetCoord(), "Illegal expression operand" );
14076  }
14077  } else if( n->Arg<CNode*>(1)->type == eR ) {
14078  info->error = 1;
14079  if( !suppressErrorMessages ) {
14080  error(n->GetCoord(), "Illegal expression operand" );
14081  }
14082  } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
14083  n->type = eS;
14084  } else if(1) {
14085  n->type = eB;
14086  }
14087  break;
14088  case eANDANDAND:
14089  if( n->Arg<CNode*>(0)->type == eR ) {
14090  info->error = 1;
14091  if( !suppressErrorMessages ) {
14092  error(n->GetCoord(), "Illegal expression operand" );
14093  }
14094  } else if( n->Arg<CNode*>(1)->type == eR ) {
14095  info->error = 1;
14096  if( !suppressErrorMessages ) {
14097  error(n->GetCoord(), "Illegal expression operand" );
14098  }
14099  } else if(1) {
14100  n->type = eB;
14101  }
14102  break;
14103  case eXOR:
14104  if( n->Arg<CNode*>(0)->type == eR ) {
14105  info->error = 1;
14106  if( !suppressErrorMessages ) {
14107  error(n->GetCoord(), "Illegal expression operand" );
14108  }
14109  } else if( n->Arg<CNode*>(1)->type == eR ) {
14110  info->error = 1;
14111  if( !suppressErrorMessages ) {
14112  error(n->GetCoord(), "Illegal expression operand" );
14113  }
14114  } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
14115  n->type = eS;
14116  } else if(1) {
14117  n->type = eB;
14118  }
14119  break;
14120  case eXNOR:
14121  if( n->Arg<CNode*>(0)->type == eR ) {
14122  info->error = 1;
14123  if( !suppressErrorMessages ) {
14124  error(n->GetCoord(), "Illegal expression operand" );
14125  }
14126  } else if( n->Arg<CNode*>(1)->type == eR ) {
14127  info->error = 1;
14128  if( !suppressErrorMessages ) {
14129  error(n->GetCoord(), "Illegal expression operand" );
14130  }
14131  } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
14132  n->type = eS;
14133  } else if(1) {
14134  n->type = eB;
14135  }
14136  break;
14137  case eSYSTASK_CALL:
14138  n->type = Systask::Type(n->Arg<CSymbol*>(0),n->Arg<CNode*>(1));
14139  break;
14140  case eFUNCTION_CALL:
14141  n->type = CFunction::Type(n->Arg<CSymbol*>(0),n->Arg<CNode*>(1),n->Arg<CScope*>(2));
14142  break;
14143  case eARRAY:
14144  n->type = Array::Type(n->Arg<CNode*>(0),n->Arg<CNode*>(1));
14145  break;
14146  case eNET_REF:
14147  n->type = n->Arg<CNet*>(0)->GetNodeType();
14148  break;
14149  case eVAR_REF:
14150  n->type = n->Arg<CVar*>(0)->GetNodeType();
14151  break;
14152  case ePARAM_REF:
14153  n->type = n->Arg<CParam*>(0)->GetNodeType();
14154  break;
14155  case ePORT_REF:
14156  n->type = n->Arg<CPortDir*>(0)->GetNodeType();
14157  break;
14158  case eFWD_REF:
14159  if(1) {
14160  n->type = eB;
14161  }
14162  break;
14163  case eGENVAR_REF:
14164  n->type = n->Arg<CGenvar*>(0)->GetNodeType();
14165  break;
14166  case eENUM_REF:
14167  n->type = n->Arg<CEnum*>(0)->GetNodeType();
14168  break;
14169  case eTYPE_REF:
14170  if(1) {
14171  n->type = eS;
14172  }
14173  break;
14174  case eRANGE:
14175  if( n->Arg<CNode*>(0)->type == eR ) {
14176  info->error = 1;
14177  if( !suppressErrorMessages ) {
14178  error(n->GetCoord(), "Illegal expression operand" );
14179  }
14180  } else if( n->Arg<CNode*>(1)->type == eR ) {
14181  info->error = 1;
14182  if( !suppressErrorMessages ) {
14183  error(n->GetCoord(), "Illegal expression operand" );
14184  }
14185  } else if(1) {
14186  n->type = eB;
14187  }
14188  break;
14189  case eSLICE:
14190  if( n->Arg<CNode*>(0)->type == eR ) {
14191  info->error = 1;
14192  if( !suppressErrorMessages ) {
14193  error(n->GetCoord(), "Illegal expression operand" );
14194  }
14195  } else if( n->Arg<CNode*>(1)->type == eR ) {
14196  info->error = 1;
14197  if( !suppressErrorMessages ) {
14198  error(n->GetCoord(), "Illegal expression operand" );
14199  }
14200  } else if(1) {
14201  n->type = eB;
14202  }
14203  break;
14204  case ePSLICE:
14205  if( n->Arg<CNode*>(1)->type == eR ) {
14206  info->error = 1;
14207  if( !suppressErrorMessages ) {
14208  error(n->GetCoord(), "Illegal expression operand" );
14209  }
14210  } else if(1) {
14211  n->type = eB;
14212  }
14213  break;
14214  case eMSLICE:
14215  if( n->Arg<CNode*>(1)->type == eR ) {
14216  info->error = 1;
14217  if( !suppressErrorMessages ) {
14218  error(n->GetCoord(), "Illegal expression operand" );
14219  }
14220  } else if(1) {
14221  n->type = eB;
14222  }
14223  break;
14224  case eCVRI:
14225  if(1) {
14226  n->type = eS;
14227  }
14228  break;
14229  case eCVIR:
14230  if(1) {
14231  n->type = eR;
14232  }
14233  break;
14234  case eREP:
14235  if( n->Arg<CNode*>(0)->type == eR ) {
14236  info->error = 1;
14237  if( !suppressErrorMessages ) {
14238  error(n->GetCoord(), "Illegal expression operand" );
14239  }
14240  } else if( n->Arg<CNode*>(1)->type == eR ) {
14241  info->error = 1;
14242  if( !suppressErrorMessages ) {
14243  error(n->GetCoord(), "Illegal expression operand" );
14244  }
14245  } else if(1) {
14246  n->type = eB;
14247  }
14248  break;
14249  case eCAT:
14250  if( n->Arg<CNode*>(0)->type == eR ) {
14251  info->error = 1;
14252  if( !suppressErrorMessages ) {
14253  error(n->GetCoord(), "Illegal expression operand" );
14254  }
14255  } else if( n->Arg<CNode*>(1)->type == eR ) {
14256  info->error = 1;
14257  if( !suppressErrorMessages ) {
14258  error(n->GetCoord(), "Illegal expression operand" );
14259  }
14260  } else if(1) {
14261  n->type = eB;
14262  }
14263  break;
14264  case eUCAT:
14265  if( n->Arg<CNode*>(0)->type == eR ) {
14266  info->error = 1;
14267  if( !suppressErrorMessages ) {
14268  error(n->GetCoord(), "Illegal expression operand" );
14269  }
14270  } else if(1) {
14271  n->type = eB;
14272  }
14273  break;
14274  case eCOM:
14275  if( n->Arg<CNode*>(0)->type == eR ) {
14276  info->error = 1;
14277  if( !suppressErrorMessages ) {
14278  error(n->GetCoord(), "Illegal expression operand" );
14279  }
14280  } else if( n->Arg<CNode*>(0)->type == eS ) {
14281  n->type = eS;
14282  } else if(1) {
14283  n->type = eB;
14284  }
14285  break;
14286  case eNEG:
14287  n->type = n->Arg<CNode*>(0)->type;
14288  break;
14289  case ePLUS:
14290  n->type = n->Arg<CNode*>(0)->type;
14291  break;
14292  case eNOT:
14293  if(1) {
14294  n->type = eB;
14295  }
14296  break;
14297  case eGT:
14298  if(1) {
14299  n->type = eB;
14300  }
14301  break;
14302  case eGE:
14303  if(1) {
14304  n->type = eB;
14305  }
14306  break;
14307  case eLT:
14308  if(1) {
14309  n->type = eB;
14310  }
14311  break;
14312  case eLE:
14313  if(1) {
14314  n->type = eB;
14315  }
14316  break;
14317  case eLAND:
14318  if(1) {
14319  n->type = eB;
14320  }
14321  break;
14322  case eLOR:
14323  if(1) {
14324  n->type = eB;
14325  }
14326  break;
14327  case eCEQ:
14328  if( n->Arg<CNode*>(0)->type == eR ) {
14329  info->error = 1;
14330  if( !suppressErrorMessages ) {
14331  error(n->GetCoord(), "Illegal expression operand" );
14332  }
14333  } else if( n->Arg<CNode*>(1)->type == eR ) {
14334  info->error = 1;
14335  if( !suppressErrorMessages ) {
14336  error(n->GetCoord(), "Illegal expression operand" );
14337  }
14338  } else if(1) {
14339  n->type = eB;
14340  }
14341  break;
14342  case eCNE:
14343  if( n->Arg<CNode*>(0)->type == eR ) {
14344  info->error = 1;
14345  if( !suppressErrorMessages ) {
14346  error(n->GetCoord(), "Illegal expression operand" );
14347  }
14348  } else if( n->Arg<CNode*>(1)->type == eR ) {
14349  info->error = 1;
14350  if( !suppressErrorMessages ) {
14351  error(n->GetCoord(), "Illegal expression operand" );
14352  }
14353  } else if(1) {
14354  n->type = eB;
14355  }
14356  break;
14357  case eEQ:
14358  if(1) {
14359  n->type = eB;
14360  }
14361  break;
14362  case eNE:
14363  if(1) {
14364  n->type = eB;
14365  }
14366  break;
14367  case eRAND:
14368  if( n->Arg<CNode*>(0)->type == eR ) {
14369  info->error = 1;
14370  if( !suppressErrorMessages ) {
14371  error(n->GetCoord(), "Illegal expression operand" );
14372  }
14373  } else if(1) {
14374  n->type = eB;
14375  }
14376  break;
14377  case eRNAND:
14378  if( n->Arg<CNode*>(0)->type == eR ) {
14379  info->error = 1;
14380  if( !suppressErrorMessages ) {
14381  error(n->GetCoord(), "Illegal expression operand" );
14382  }
14383  } else if(1) {
14384  n->type = eB;
14385  }
14386  break;
14387  case eROR:
14388  if( n->Arg<CNode*>(0)->type == eR ) {
14389  info->error = 1;
14390  if( !suppressErrorMessages ) {
14391  error(n->GetCoord(), "Illegal expression operand" );
14392  }
14393  } else if(1) {
14394  n->type = eB;
14395  }
14396  break;
14397  case eRNOR:
14398  if( n->Arg<CNode*>(0)->type == eR ) {
14399  info->error = 1;
14400  if( !suppressErrorMessages ) {
14401  error(n->GetCoord(), "Illegal expression operand" );
14402  }
14403  } else if(1) {
14404  n->type = eB;
14405  }
14406  break;
14407  case eRXOR:
14408  if( n->Arg<CNode*>(0)->type == eR ) {
14409  info->error = 1;
14410  if( !suppressErrorMessages ) {
14411  error(n->GetCoord(), "Illegal expression operand" );
14412  }
14413  } else if(1) {
14414  n->type = eB;
14415  }
14416  break;
14417  case eRXNOR:
14418  if( n->Arg<CNode*>(0)->type == eR ) {
14419  info->error = 1;
14420  if( !suppressErrorMessages ) {
14421  error(n->GetCoord(), "Illegal expression operand" );
14422  }
14423  } else if(1) {
14424  n->type = eB;
14425  }
14426  break;
14427  case eHOOK:
14428  if( n->Arg<CNode*>(1)->type == eR ) {
14429  n->type = eR;
14430  } else if( n->Arg<CNode*>(2)->type == eR ) {
14431  n->type = eR;
14432  } else if( n->Arg<CNode*>(1)->type == eS && n->Arg<CNode*>(2)->type == eS ) {
14433  n->type = eS;
14434  } else if(1) {
14435  n->type = eB;
14436  }
14437  break;
14438  case ePOSEDGE:
14439  if(1) {
14440  n->type = eE;
14441  }
14442  break;
14443  case eNEGEDGE:
14444  if(1) {
14445  n->type = eE;
14446  }
14447  break;
14448  case eEVOR:
14449  if(1) {
14450  n->type = eE;
14451  }
14452  break;
14453  case eMTM:
14454  if( n->Arg<CNode*>(0)->type == eR ) {
14455  n->type = eR;
14456  } else if( n->Arg<CNode*>(1)->type == eR ) {
14457  n->type = eR;
14458  } else if( n->Arg<CNode*>(2)->type == eR ) {
14459  n->type = eR;
14460  } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS && n->Arg<CNode*>(2)->type == eS ) {
14461  n->type = eS;
14462  } else if(1) {
14463  n->type = eB;
14464  }
14465  break;
14466  case eEXTERNAL_REF:
14467  n->type = External::Type(n->Arg<CSymbol*>(0));
14468  break;
14469  case eATTRIBUTE:
14470  if(1) {
14471  n->type = eU;
14472  }
14473  break;
14474  case eMACRO_EXPR:
14475  n->type = n->Arg<CNode*>(1)->type;
14476  break;
14477  case eMEMBER:
14478  n->type = Member::Type(n->Arg<CNode*>(0),n->Arg<CSymbol*>(1));
14479  break;
14480  case ePREINC:
14481  if( n->Arg<CNode*>(0)->type == eR ) {
14482  n->type = eR;
14483  } else if( n->Arg<CNode*>(0)->type == eS ) {
14484  n->type = eS;
14485  } else if(1) {
14486  n->type = eB;
14487  }
14488  break;
14489  case ePOSTINC:
14490  if( n->Arg<CNode*>(0)->type == eR ) {
14491  n->type = eR;
14492  } else if( n->Arg<CNode*>(0)->type == eS ) {
14493  n->type = eS;
14494  } else if(1) {
14495  n->type = eB;
14496  }
14497  break;
14498  case ePREDEC:
14499  if( n->Arg<CNode*>(0)->type == eR ) {
14500  n->type = eR;
14501  } else if( n->Arg<CNode*>(0)->type == eS ) {
14502  n->type = eS;
14503  } else if(1) {
14504  n->type = eB;
14505  }
14506  break;
14507  case ePOSTDEC:
14508  if( n->Arg<CNode*>(0)->type == eR ) {
14509  n->type = eR;
14510  } else if( n->Arg<CNode*>(0)->type == eS ) {
14511  n->type = eS;
14512  } else if(1) {
14513  n->type = eB;
14514  }
14515  break;
14516  case eCAST:
14517  if(1) {
14518  n->type = eB;
14519  }
14520  break;
14521  case eASSIGNMENT_PATTERN:
14522  n->type = n->Arg<CNode*>(0)->type;
14523  break;
14524  case eDOLLAR:
14525  if(1) {
14526  n->type = eB;
14527  }
14528  break;
14529  default:
14530  MASSERT( FALSE );
14531  }
14532 
14533  /*
14534  * enforce width conventions for fixed width types
14535  */
14536  switch( n->type ) {
14537  case eU:
14538  case eE:
14539  case eR:
14540  n->width = 0;
14541  return;
14542  }
14543 
14544  /*
14545  * set node width
14546  */
14547  switch( n->GetOp() ) {
14548  case eERROR:
14549  n->width = 0;
14550  break;
14551  case eVCONSTANT:
14552  n->width = (!n->Arg<CVector*>(0)->IsWidthEvaluateable()&&suppressErrorMessages) ? 0 : n->Arg<CVector*>(0)->GetWidth();
14553  break;
14554  case eRCONSTANT:
14555  n->width = 0;
14556  break;
14557  case eELIST:
14558  n->width = cADD(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
14559  break;
14560  case eWIDTH:
14561  n->width = ((info->error |= !n->Arg<CNode*>(0)->IsEvaluateable())&&suppressErrorMessages) ? 0 : n->Arg<CNode*>(0)->EvalINT32();
14562  break;
14563  case eSUB:
14564  n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
14565  break;
14566  case eMUL:
14567  n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
14568  break;
14569  case eDIV:
14570  n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
14571  break;
14572  case ePOW:
14573  n->width = n->Arg<CNode*>(0)->width;
14574  break;
14575  case eADD:
14576  n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
14577  break;
14578  case eLSH:
14579  n->width = n->Arg<CNode*>(0)->width;
14580  break;
14581  case eRSH:
14582  n->width = n->Arg<CNode*>(0)->width;
14583  break;
14584  case eLSHA:
14585  n->width = n->Arg<CNode*>(0)->width;
14586  break;
14587  case eRSHA:
14588  n->width = n->Arg<CNode*>(0)->width;
14589  break;
14590  case eMOD:
14591  n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
14592  break;
14593  case eOR:
14594  n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
14595  break;
14596  case eAND:
14597  n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
14598  break;
14599  case eANDANDAND:
14600  n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
14601  break;
14602  case eXOR:
14603  n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
14604  break;
14605  case eXNOR:
14606  n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
14607  break;
14608  case eSYSTASK_CALL:
14609  n->width = Systask::Width(n->Arg<CSymbol*>(0),n->Arg<CNode*>(1));
14610  break;
14611  case eFUNCTION_CALL:
14612  n->width = CFunction::Width(n->Arg<CSymbol*>(0),n->Arg<CNode*>(1),n->Arg<CScope*>(2));
14613  break;
14614  case eARRAY:
14615  n->width = Array::Width(n->Arg<CNode*>(0),n->Arg<CNode*>(1));
14616  break;
14617  case eNET_REF:
14618  n->width = (!n->Arg<CNet*>(0)->IsWidthEvaluateable()&&suppressErrorMessages) ? 0 : n->Arg<CNet*>(0)->GetWidth();
14619  break;
14620  case eVAR_REF:
14621  n->width = (!n->Arg<CVar*>(0)->IsWidthEvaluateable()&&suppressErrorMessages) ? 0 : n->Arg<CVar*>(0)->GetWidth();
14622  break;
14623  case ePARAM_REF:
14624  n->width = (!n->Arg<CParam*>(0)->IsWidthEvaluateable()&&suppressErrorMessages) ? 0 : n->Arg<CParam*>(0)->GetWidth();
14625  break;
14626  case ePORT_REF:
14627  n->width = (!n->Arg<CPortDir*>(0)->IsWidthEvaluateable()&&suppressErrorMessages) ? 0 : n->Arg<CPortDir*>(0)->GetWidth();
14628  break;
14629  case eFWD_REF:
14630  n->width = (!n->Arg<CFref*>(0)->IsWidthEvaluateable()&&suppressErrorMessages) ? 0 : n->Arg<CFref*>(0)->GetWidth();
14631  break;
14632  case eGENVAR_REF:
14633  n->width = (!n->Arg<CGenvar*>(0)->IsWidthEvaluateable()&&suppressErrorMessages) ? 0 : n->Arg<CGenvar*>(0)->GetWidth();
14634  break;
14635  case eENUM_REF:
14636  n->width = (!n->Arg<CEnum*>(0)->IsWidthEvaluateable()&&suppressErrorMessages) ? 0 : n->Arg<CEnum*>(0)->GetWidth();
14637  break;
14638  case eTYPE_REF:
14639  n->width = 32;
14640  break;
14641  case eRANGE:
14642  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());
14643  break;
14644  case eSLICE:
14645  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());
14646  break;
14647  case ePSLICE:
14648  n->width = (!n->Arg<CNode*>(1)->IsEvaluateable()&&suppressErrorMessages) ? 0 : n->Arg<CNode*>(1)->EvalINT32();
14649  break;
14650  case eMSLICE:
14651  n->width = (!n->Arg<CNode*>(1)->IsEvaluateable()&&suppressErrorMessages) ? 0 : n->Arg<CNode*>(1)->EvalINT32();
14652  break;
14653  case eCVRI:
14654  n->width = 32;
14655  break;
14656  case eCVIR:
14657  n->width = 0;
14658  break;
14659  case eREP:
14660  n->width = cMUL(((info->error |= !n->Arg<CNode*>(0)->IsEvaluateable())&&suppressErrorMessages) ? 0: n->Arg<CNode*>(0)->EvalINT32(),n->Arg<CNode*>(1)->width);
14661  break;
14662  case eCAT:
14663  n->width = cADD(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
14664  break;
14665  case eUCAT:
14666  n->width = n->Arg<CNode*>(0)->width;
14667  break;
14668  case eCOM:
14669  n->width = n->Arg<CNode*>(0)->width;
14670  break;
14671  case eNEG:
14672  n->width = n->Arg<CNode*>(0)->width;
14673  break;
14674  case ePLUS:
14675  n->width = n->Arg<CNode*>(0)->width;
14676  break;
14677  case eNOT:
14678  n->width = 1;
14679  break;
14680  case eGT:
14681  n->width = 1;
14682  break;
14683  case eGE:
14684  n->width = 1;
14685  break;
14686  case eLT:
14687  n->width = 1;
14688  break;
14689  case eLE:
14690  n->width = 1;
14691  break;
14692  case eLAND:
14693  n->width = 1;
14694  break;
14695  case eLOR:
14696  n->width = 1;
14697  break;
14698  case eCEQ:
14699  n->width = 1;
14700  break;
14701  case eCNE:
14702  n->width = 1;
14703  break;
14704  case eEQ:
14705  n->width = 1;
14706  break;
14707  case eNE:
14708  n->width = 1;
14709  break;
14710  case eRAND:
14711  n->width = 1;
14712  break;
14713  case eRNAND:
14714  n->width = 1;
14715  break;
14716  case eROR:
14717  n->width = 1;
14718  break;
14719  case eRNOR:
14720  n->width = 1;
14721  break;
14722  case eRXOR:
14723  n->width = 1;
14724  break;
14725  case eRXNOR:
14726  n->width = 1;
14727  break;
14728  case eHOOK:
14729  n->width = cMAX(n->Arg<CNode*>(1)->width,n->Arg<CNode*>(2)->width);
14730  break;
14731  case eMTM:
14732  n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width,n->Arg<CNode*>(2)->width);
14733  break;
14734  case eEXTERNAL_REF:
14735  n->width = External::Width(n->Arg<CSymbol*>(0));
14736  break;
14737  case eATTRIBUTE:
14738  n->width = 0;
14739  break;
14740  case eMACRO_EXPR:
14741  n->width = n->Arg<CNode*>(1)->width;
14742  break;
14743  case eMEMBER:
14744  n->width = Member::Width(n->Arg<CNode*>(0),n->Arg<CSymbol*>(1));
14745  break;
14746  case ePREINC:
14747  n->width = n->Arg<CNode*>(0)->width;
14748  break;
14749  case ePOSTINC:
14750  n->width = n->Arg<CNode*>(0)->width;
14751  break;
14752  case ePREDEC:
14753  n->width = n->Arg<CNode*>(0)->width;
14754  break;
14755  case ePOSTDEC:
14756  n->width = n->Arg<CNode*>(0)->width;
14757  break;
14758  case eCAST:
14759  n->width = n->Arg<CNode*>(0)->width;
14760  break;
14761  case eASSIGNMENT_PATTERN:
14762  n->width = 0;
14763  break;
14764  case eDOLLAR:
14765  n->width = 0;
14766  break;
14767  }
14768 
14769  /*
14770  * deterimine if operands have differing width
14771  */
14772  n->FixedWidth(1);
14773  int operandWidth = -1;
14774  for( int i = 0; i < n->ArgCount(); i++ ) {
14775  if( ((nodeMask>>i)&1) && n->Arg<CNode*>(i) ) {
14776  int widthFixed = n->Arg<CNode*>(i)->WidthFixed() ||
14777  n->Arg<CNode*>(i)->FixedWidth();
14778 
14779  if( n->ConditionalWiden() && !widthFixed ) {
14780  n->FixedWidth( 0 );
14781  break;
14782  } else if( !widthFixed ) {
14783  n->FixedWidth( 0 );
14784  break;
14785  } else {
14786  int w = n->Arg<CNode*>(i)->width;
14787  if( operandWidth != w ) {
14788  if( operandWidth >= 0 ) {
14789  n->FixedWidth( 0 );
14790  break;
14791  }
14792  operandWidth = w;
14793  }
14794  }
14795  }
14796  }
14797  if( !conditionalWiden && nodeMask != 0 ) {
14798  n->FixedWidth( 0 );
14799  }
14800 }
14801 
14802 /************************************************
14803  FixBits
14804  - relabels node width based on destination
14805  width and type. Add type conversions
14806  and check argument types. Assumes
14807  LabelBits has already been called and
14808  no illegal operand types are present.
14809 **************************************************/
14810 
14811 CNode* CNode::FixBits( INT32 newWidth, NodeType_t newType )
14812 {
14813 
14814  int calculateMax = 0;
14815  int realOp = 0;
14816  int conditionalWiden = ConditionalWiden();
14817  unsigned nodeMask = NodeMask();
14818  unsigned scalarMask = 0;
14819  unsigned selfDeterminedMask = 0;
14820  switch( GetOp() ) {
14821  case eERROR:
14822  realOp = 0;
14823  break;
14824  case eVCONSTANT:
14825  realOp = 0;
14826  break;
14827  case eRCONSTANT:
14828  realOp = 0;
14829  break;
14830  case eCOMMENT:
14831  realOp = 0;
14832  break;
14833  case eVRQ:
14834  realOp = 0;
14835  break;
14836  case ePRAGMA:
14837  realOp = 0;
14838  break;
14839  case eELIST:
14840  realOp = 0;
14841  selfDeterminedMask = nodeMask;
14842  break;
14843  case eWIDTH:
14844  realOp = 0;
14845  selfDeterminedMask = nodeMask;
14846  break;
14847  case eNOP:
14848  realOp = 0;
14849  break;
14850  case eSUB:
14851  realOp = 1;
14852  break;
14853  case eMUL:
14854  realOp = 1;
14855  break;
14856  case eDIV:
14857  realOp = 1;
14858  break;
14859  case ePOW:
14860  realOp = 1;
14861  selfDeterminedMask = 1<<1;
14862  break;
14863  case eADD:
14864  realOp = 1;
14865  break;
14866  case eLSH:
14867  realOp = 0;
14868  selfDeterminedMask = 1<<1;
14869  break;
14870  case eRSH:
14871  realOp = 0;
14872  selfDeterminedMask = 1<<1;
14873  break;
14874  case eLSHA:
14875  realOp = 0;
14876  selfDeterminedMask = 1<<1;
14877  break;
14878  case eRSHA:
14879  realOp = 0;
14880  selfDeterminedMask = 1<<1;
14881  break;
14882  case eMOD:
14883  realOp = 0;
14884  break;
14885  case eOR:
14886  realOp = 0;
14887  break;
14888  case eAND:
14889  realOp = 0;
14890  break;
14891  case eANDANDAND:
14892  realOp = 0;
14893  break;
14894  case eXOR:
14895  realOp = 0;
14896  break;
14897  case eXNOR:
14898  realOp = 0;
14899  break;
14900  case eINSTANCE_REF:
14901  realOp = 0;
14902  break;
14903  case eGATE_REF:
14904  realOp = 0;
14905  break;
14906  case eTASK_ENABLE:
14907  realOp = 0;
14908  break;
14909  case eSYSTASK_CALL:
14910  realOp = 0;
14911  selfDeterminedMask = nodeMask;
14912  break;
14913  case eTIMING_CALL:
14914  realOp = 0;
14915  break;
14916  case eFUNCTION_CALL:
14917  realOp = 0;
14918  selfDeterminedMask = nodeMask;
14919  break;
14920  case eARRAY:
14921  realOp = 0;
14922  selfDeterminedMask = 1<<1;
14923  break;
14924  case eNET_REF:
14925  realOp = 0;
14926  break;
14927  case eVAR_REF:
14928  realOp = 0;
14929  break;
14930  case ePARAM_REF:
14931  realOp = 0;
14932  break;
14933  case ePORT_REF:
14934  realOp = 0;
14935  break;
14936  case eFWD_REF:
14937  realOp = 0;
14938  break;
14939  case eGENVAR_REF:
14940  realOp = 0;
14941  break;
14942  case eENUM_REF:
14943  realOp = 0;
14944  break;
14945  case eTYPE_REF:
14946  realOp = 0;
14947  break;
14948  case eNET_DECL:
14949  realOp = 0;
14950  break;
14951  case eVAR_DECL:
14952  realOp = 0;
14953  break;
14954  case ePARAM_DECL:
14955  realOp = 0;
14956  break;
14957  case eSPECPARAM_DECL:
14958  realOp = 0;
14959  break;
14960  case ePORT_DECL:
14961  realOp = 0;
14962  break;
14963  case eGENVAR_DECL:
14964  realOp = 0;
14965  break;
14966  case eTYPEDEF_DECL:
14967  realOp = 0;
14968  break;
14969  case eLIST:
14970  realOp = 0;
14971  break;
14972  case eRANGE:
14973  realOp = 0;
14974  selfDeterminedMask = nodeMask;
14975  break;
14976  case eSLICE:
14977  realOp = 0;
14978  selfDeterminedMask = nodeMask;
14979  break;
14980  case ePSLICE:
14981  realOp = 0;
14982  selfDeterminedMask = nodeMask;
14983  break;
14984  case eMSLICE:
14985  realOp = 0;
14986  selfDeterminedMask = nodeMask;
14987  break;
14988  case eCVRI:
14989  realOp = 0;
14990  selfDeterminedMask = nodeMask;
14991  break;
14992  case eCVIR:
14993  realOp = 0;
14994  selfDeterminedMask = nodeMask;
14995  break;
14996  case eREP:
14997  realOp = 0;
14998  selfDeterminedMask = nodeMask;
14999  break;
15000  case eCAT:
15001  realOp = 0;
15002  selfDeterminedMask = nodeMask;
15003  break;
15004  case eUCAT:
15005  realOp = 0;
15006  selfDeterminedMask = nodeMask;
15007  break;
15008  case eCOM:
15009  realOp = 0;
15010  break;
15011  case eNEG:
15012  realOp = 0;
15013  break;
15014  case ePLUS:
15015  realOp = 0;
15016  break;
15017  case eNOT:
15018  realOp = 0;
15019  scalarMask = 1;
15020  break;
15021  case eGT:
15022  realOp = 0;
15023  calculateMax = 1;
15024  break;
15025  case eGE:
15026  realOp = 0;
15027  calculateMax = 1;
15028  break;
15029  case eLT:
15030  realOp = 0;
15031  calculateMax = 1;
15032  break;
15033  case eLE:
15034  realOp = 0;
15035  calculateMax = 1;
15036  break;
15037  case eLAND:
15038  realOp = 0;
15039  scalarMask = 3;
15040  break;
15041  case eLOR:
15042  realOp = 0;
15043  scalarMask = 3;
15044  break;
15045  case eCEQ:
15046  realOp = 0;
15047  calculateMax = 1;
15048  break;
15049  case eCNE:
15050  realOp = 0;
15051  calculateMax = 1;
15052  break;
15053  case eEQ:
15054  realOp = 0;
15055  calculateMax = 1;
15056  break;
15057  case eNE:
15058  realOp = 0;
15059  calculateMax = 1;
15060  break;
15061  case eRAND:
15062  realOp = 0;
15063  selfDeterminedMask = nodeMask;
15064  break;
15065  case eRNAND:
15066  realOp = 0;
15067  selfDeterminedMask = nodeMask;
15068  break;
15069  case eROR:
15070  realOp = 0;
15071  selfDeterminedMask = nodeMask;
15072  break;
15073  case eRNOR:
15074  realOp = 0;
15075  selfDeterminedMask = nodeMask;
15076  break;
15077  case eRXOR:
15078  realOp = 0;
15079  selfDeterminedMask = nodeMask;
15080  break;
15081  case eRXNOR:
15082  realOp = 0;
15083  selfDeterminedMask = nodeMask;
15084  break;
15085  case eHOOK:
15086  realOp = 1;
15087  scalarMask = 1;
15088  break;
15089  case eINIT:
15090  realOp = 0;
15091  break;
15092  case eALWAYS:
15093  realOp = 0;
15094  break;
15095  case eALWAYS_LATCH:
15096  realOp = 0;
15097  break;
15098  case eALWAYS_FF:
15099  realOp = 0;
15100  break;
15101  case eALWAYS_COMB:
15102  realOp = 0;
15103  break;
15104  case eEVENT:
15105  realOp = 0;
15106  break;
15107  case eBLOCK_REF:
15108  realOp = 0;
15109  break;
15110  case eSPECIFY_REF:
15111  realOp = 0;
15112  break;
15113  case eASSIGN:
15114  realOp = 0;
15115  break;
15116  case eGASSIGN:
15117  realOp = 0;
15118  break;
15119  case eADD_ASSIGN:
15120  realOp = 0;
15121  break;
15122  case eSUB_ASSIGN:
15123  realOp = 0;
15124  break;
15125  case eMUL_ASSIGN:
15126  realOp = 0;
15127  break;
15128  case eDIV_ASSIGN:
15129  realOp = 0;
15130  break;
15131  case eMOD_ASSIGN:
15132  realOp = 0;
15133  break;
15134  case eAND_ASSIGN:
15135  realOp = 0;
15136  break;
15137  case eOR_ASSIGN:
15138  realOp = 0;
15139  break;
15140  case eXOR_ASSIGN:
15141  realOp = 0;
15142  break;
15143  case eLSH_ASSIGN:
15144  realOp = 0;
15145  break;
15146  case eRSH_ASSIGN:
15147  realOp = 0;
15148  break;
15149  case eLSHA_ASSIGN:
15150  realOp = 0;
15151  break;
15152  case eRSHA_ASSIGN:
15153  realOp = 0;
15154  break;
15155  case eFORCE:
15156  realOp = 0;
15157  break;
15158  case eRELEASE:
15159  realOp = 0;
15160  break;
15161  case eNBASSIGN:
15162  realOp = 0;
15163  break;
15164  case ePOSEDGE:
15165  realOp = 0;
15166  break;
15167  case eNEGEDGE:
15168  realOp = 0;
15169  break;
15170  case eEDGE:
15171  realOp = 0;
15172  break;
15173  case eEVOR:
15174  realOp = 0;
15175  break;
15176  case eDELAY:
15177  realOp = 0;
15178  break;
15179  case eMTM:
15180  realOp = 1;
15181  break;
15182  case eIF:
15183  realOp = 0;
15184  break;
15185  case eFOREVER:
15186  realOp = 0;
15187  break;
15188  case eREPEAT:
15189  realOp = 0;
15190  break;
15191  case eWHILE:
15192  realOp = 0;
15193  break;
15194  case eWAIT:
15195  realOp = 0;
15196  break;
15197  case eFOR:
15198  realOp = 0;
15199  break;
15200  case eCASE:
15201  realOp = 0;
15202  break;
15203  case eCASEX:
15204  realOp = 0;
15205  break;
15206  case eCASEZ:
15207  realOp = 0;
15208  break;
15209  case eCASEITEM:
15210  realOp = 0;
15211  break;
15212  case eCASSIGN:
15213  realOp = 0;
15214  break;
15215  case eARG:
15216  realOp = 0;
15217  break;
15218  case eIMPORT:
15219  realOp = 0;
15220  break;
15221  case eFUNCTION_DEF:
15222  realOp = 0;
15223  break;
15224  case eMODULE_DEF:
15225  realOp = 0;
15226  break;
15227  case ePACKAGE_DEF:
15228  realOp = 0;
15229  break;
15230  case eREPEAT_CONTROL:
15231  realOp = 0;
15232  break;
15233  case eDELAY_CONTROL:
15234  realOp = 0;
15235  break;
15236  case eEVENT_CONTROL:
15237  realOp = 0;
15238  break;
15239  case eEXTERNAL_REF:
15240  realOp = 0;
15241  break;
15242  case ePORT_DEF:
15243  realOp = 0;
15244  break;
15245  case eDEFPARAM:
15246  realOp = 0;
15247  break;
15248  case ePATH:
15249  realOp = 0;
15250  break;
15251  case ePATH_ASSIGN:
15252  realOp = 0;
15253  break;
15254  case eIFNONE_PATH_ASSIGN:
15255  realOp = 0;
15256  break;
15257  case eTRIGGER:
15258  realOp = 0;
15259  break;
15260  case ePASSIGN:
15261  realOp = 0;
15262  break;
15263  case eDEASSIGN:
15264  realOp = 0;
15265  break;
15266  case eDISABLE:
15267  realOp = 0;
15268  break;
15269  case eATTRIBUTE:
15270  realOp = 0;
15271  break;
15272  case eGIF:
15273  realOp = 0;
15274  break;
15275  case eGFOR:
15276  realOp = 0;
15277  break;
15278  case eGCASE:
15279  realOp = 0;
15280  break;
15281  case eTABLE:
15282  realOp = 0;
15283  break;
15284  case eTABLE_ENTRY:
15285  realOp = 0;
15286  break;
15287  case eTABLE_SYMBOL:
15288  realOp = 0;
15289  break;
15290  case ePORTLIST_END:
15291  realOp = 0;
15292  break;
15293  case eMACRO_EXPR:
15294  realOp = 0;
15295  break;
15296  case eENUM_SPEC:
15297  realOp = 0;
15298  break;
15299  case eMEMBER:
15300  realOp = 0;
15301  break;
15302  case eRETURN:
15303  realOp = 0;
15304  break;
15305  case ePREINC:
15306  realOp = 1;
15307  break;
15308  case ePOSTINC:
15309  realOp = 1;
15310  break;
15311  case ePREDEC:
15312  realOp = 1;
15313  break;
15314  case ePOSTDEC:
15315  realOp = 1;
15316  break;
15317  case eCAST:
15318  realOp = 0;
15319  selfDeterminedMask = nodeMask;
15320  break;
15321  case eASSIGNMENT_PATTERN:
15322  realOp = 0;
15323  selfDeterminedMask = nodeMask;
15324  break;
15325  case eDOLLAR:
15326  realOp = 0;
15327  selfDeterminedMask = nodeMask;
15328  break;
15329  default:
15330  MASSERT( FALSE );
15331  }
15332  /*
15333  * find location of all real args
15334  */
15335  unsigned realMask = 0;
15336  unsigned forceRealMask = 0;
15337  int widthsDiffer = 0;
15338  int originalWidth = width;
15339  for( int i = 0; i < ArgCount(); i++ ) {
15340  if( ((nodeMask>>i)&1) && Arg<CNode*>(i)->type == eR ) {
15341  realMask |= 1<<i;
15342  }
15343  if( ((nodeMask>>i)&1) &&
15344  Arg<CNode*>(i)->type != eR &&
15345  (Arg<CNode*>(i)->GetOp() != eVCONSTANT ||
15346  Arg<CNode*>(i)->width != width) ) {
15347  widthsDiffer = 1;
15348  }
15349  }
15350 
15351  /*
15352  * if new type is undetermined, use current type and width
15353  */
15354  if( newType == eU && newWidth == 0 ) {
15355  newType = type;
15356  newWidth = width;
15357  /*
15358  * increase expression width if new width is larger
15359  * and a vector
15360  */
15361  } else if( (newType == eB || newType == eS || newType == eU) &&
15362  (type == eB || type == eS) ) {
15363  if( newWidth > width ) {
15364  width = newWidth;
15365  }
15366  if( newType == eU ) {
15367  newType = type;
15368  }
15369  }
15370 
15371  MASSERT( newType != eR || newWidth == 0 );
15372  MASSERT( newType != eE || newWidth == 0 );
15373 
15374 
15375  /*
15376  * non-real operands are self determined when mixed with real
15377  */
15378  if( realMask ) {
15379  forceRealMask = (~realMask & nodeMask);
15380  }
15381 
15382  /*
15383  * special case for bit operations
15384  * Only widen if operand widths differ
15385  */
15386  int convertWidth = conditionalWiden && FixedWidth();
15387  if( convertWidth ) {
15388  width = originalWidth;
15389  }
15390  if( newType == eB && type == eS ) {
15391  type = eB;
15392  }
15393  /*
15394  * calculate max with of args if needed
15395  */
15396  int cWidth = width;
15397  NodeType_t cType = type;
15398  if( calculateMax ) {
15399  cType = eS;
15400  int max = 0;
15401  int foundReal = 0;
15402  int foundUnsigned = 0;
15403  for( int i = 0; i < ArgCount(); i++ ) {
15404  if( (nodeMask>>i)&1 ) {
15405  switch( Arg<CNode*>(i)->type ) {
15406  case eB:
15407  foundUnsigned = 1;
15408  break;
15409  case eR:
15410  foundReal = 1;
15411  break;
15412  }
15413  if( Arg<CNode*>(i)->width > max ) {
15414  max = Arg<CNode*>(i)->width;
15415  }
15416  }
15417  }
15418  if( foundReal ) {
15419  cWidth = 0;
15420  cType = eR;
15421  } else if( foundUnsigned ) {
15422  cType = eB;
15423  cWidth = max;
15424  } else {
15425  cWidth = max;
15426  }
15427  }
15428 
15429  /*
15430  * Fix each CNode* argument
15431  */
15432  for( int i = 0; i < ArgCount(); i++ ) {
15433  if( (nodeMask>>i)&1 ) {
15434  if( (scalarMask>>i)&1 ) {
15435  if( Arg<CNode*>(i)->type == eR ) {
15436  CNode* node;
15437  Arg<CNode*>(i) = cNE( Arg<CNode*>(i), cREAL(0), &loc );
15438  Arg<CNode*>(i)->LabelBits();
15439  } else if( type == eR ) {
15440  // Hack for ? operator
15441  CNode* node;
15442  Arg<CNode*>(i) = cCNE( Arg<CNode*>(i), cINT32(0), &loc );
15443  Arg<CNode*>(i)->LabelBits();
15444  }
15445  Arg<CNode*>(i) = Arg<CNode*>(i)->FixBits( 0, eU );
15446  } else if( (forceRealMask>>i)&1 ) {
15447  Arg<CNode*>(i) = Arg<CNode*>(i)->FixBits( 0, eR );
15448  } else if( (selfDeterminedMask>>i)&1 ) {
15449  Arg<CNode*>(i) = Arg<CNode*>(i)->FixBits( 0, eU );
15450  } else {
15451  Arg<CNode*>(i) = Arg<CNode*>(i)->FixBits( cWidth, cType );
15452  }
15453  }
15454  }
15455 
15456 
15457 
15458  /*
15459  * add conversions if needed
15460  */
15461  if( newType != eR && convertWidth ) {
15462  CNode* nn = cWIDTH(cINT32(newWidth), this);
15463  nn->width = newWidth;
15464  nn->type = type;
15465  return nn;
15466  }
15467  if( newType == eR && (type == eB || type == eS) ) {
15468  CNode* nn = cCVIR( this );
15469  nn->width = 0;
15470  nn->type = eR;
15471  return nn;
15472 
15473  } else if( (newType == eB || newType == eS) && type == eR ) {
15474  CNode* nn = cCVRI( this );
15475  nn->width = newWidth;
15476  nn->type = newType;
15477  return nn;
15478  }
15479 
15480  return this;
15481 }
15482 
15483 /*************************************************
15484  Dump
15485  - dump expression for debug
15486 **************************************************/
15487 void CNode::Dump( FILE* f )
15488 {
15489  switch( GetOp() ) {
15490  case eERROR:
15491  fprintf( f, "%s", "???" );
15492  break;
15493  case eVCONSTANT:
15494  fprintf( f, "%s", Arg<CVector*>(0)->GetVString() );
15495  break;
15496  case eRCONSTANT:
15497  fprintf( f, "%s", (char*)Arg<char*>(0) );
15498  break;
15499  case ePRAGMA:
15500  fprintf( f, "%s", (char*)Arg<char*>(0) );
15501  break;
15502  case eELIST:
15503  fprintf( f, "%s", "" );
15504  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15505  fprintf( f, "%s", "," );
15506  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15507  fprintf( f, "%s", "" );
15508  break;
15509  case eWIDTH:
15510  fprintf( f, "%s", "WIDTH(" );
15511  fprintf( f, "%s", type==eS ? "S" : "U" );
15512  fprintf( f, "%s", "," );
15513  fprintf( f, "%ld", width );
15514  fprintf( f, "%s", "," );
15515  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15516  fprintf( f, "%s", "," );
15517  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15518  fprintf( f, "%s", ")" );
15519  break;
15520  case eSUB:
15521  fprintf( f, "%s", "(" );
15522  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15523  fprintf( f, "%s", ")-(" );
15524  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15525  fprintf( f, "%s", ")" );
15526  break;
15527  case eMUL:
15528  fprintf( f, "%s", "(" );
15529  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15530  fprintf( f, "%s", ")*(" );
15531  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15532  fprintf( f, "%s", ")" );
15533  break;
15534  case eDIV:
15535  fprintf( f, "%s", "(" );
15536  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15537  fprintf( f, "%s", ")/(" );
15538  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15539  fprintf( f, "%s", ")" );
15540  break;
15541  case ePOW:
15542  fprintf( f, "%s", "(" );
15543  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15544  fprintf( f, "%s", ")**(" );
15545  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15546  fprintf( f, "%s", ")" );
15547  break;
15548  case eADD:
15549  fprintf( f, "%s", "(" );
15550  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15551  fprintf( f, "%s", ")+(" );
15552  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15553  fprintf( f, "%s", ")" );
15554  break;
15555  case eLSH:
15556  fprintf( f, "%s", "(" );
15557  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15558  fprintf( f, "%s", ")<<(" );
15559  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15560  fprintf( f, "%s", ")" );
15561  break;
15562  case eRSH:
15563  fprintf( f, "%s", "(" );
15564  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15565  fprintf( f, "%s", ")>>(" );
15566  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15567  fprintf( f, "%s", ")" );
15568  break;
15569  case eLSHA:
15570  fprintf( f, "%s", "(" );
15571  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15572  fprintf( f, "%s", ")<<<(" );
15573  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15574  fprintf( f, "%s", ")" );
15575  break;
15576  case eRSHA:
15577  fprintf( f, "%s", "(" );
15578  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15579  fprintf( f, "%s", ")>>>(" );
15580  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15581  fprintf( f, "%s", ")" );
15582  break;
15583  case eMOD:
15584  fprintf( f, "%s", "(" );
15585  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15586  fprintf( f, "%s", ")%%(" );
15587  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15588  fprintf( f, "%s", ")" );
15589  break;
15590  case eOR:
15591  fprintf( f, "%s", "(" );
15592  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15593  fprintf( f, "%s", ")|(" );
15594  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15595  fprintf( f, "%s", ")" );
15596  break;
15597  case eAND:
15598  fprintf( f, "%s", "(" );
15599  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15600  fprintf( f, "%s", ")&(" );
15601  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15602  fprintf( f, "%s", ")" );
15603  break;
15604  case eANDANDAND:
15605  fprintf( f, "%s", "(" );
15606  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15607  fprintf( f, "%s", ")&&&(" );
15608  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15609  fprintf( f, "%s", ")" );
15610  break;
15611  case eXOR:
15612  fprintf( f, "%s", "(" );
15613  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15614  fprintf( f, "%s", ")^(" );
15615  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15616  fprintf( f, "%s", ")" );
15617  break;
15618  case eXNOR:
15619  fprintf( f, "%s", "(" );
15620  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15621  fprintf( f, "%s", ")~^(" );
15622  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15623  fprintf( f, "%s", ")" );
15624  break;
15625  case eFUNCTION_CALL:
15626  fprintf( f, "%s", "" );
15627  fprintf( f, "%s", Arg<CSymbol*>(0)->GetName() );
15628  fprintf( f, "%s", "(" );
15629  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15630  fprintf( f, "%s", ")" );
15631  break;
15632  case eARRAY:
15633  fprintf( f, "%s", "" );
15634  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15635  fprintf( f, "%s", "[" );
15636  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15637  fprintf( f, "%s", "]" );
15638  break;
15639  case eNET_REF:
15640  fprintf( f, "%s", Arg<CNet*>(0)->GetName() );
15641  break;
15642  case eVAR_REF:
15643  fprintf( f, "%s", Arg<CVar*>(0)->GetName() );
15644  break;
15645  case ePARAM_REF:
15646  fprintf( f, "%s", Arg<CParam*>(0)->GetName() );
15647  break;
15648  case ePORT_REF:
15649  fprintf( f, "%s", Arg<CPort*>(0)->GetName() );
15650  break;
15651  case eFWD_REF:
15652  fprintf( f, "%s", Arg<CFref*>(0)->GetName() );
15653  break;
15654  case eGENVAR_REF:
15655  fprintf( f, "%s", Arg<CGenvar*>(0)->GetName() );
15656  break;
15657  case eENUM_REF:
15658  fprintf( f, "%s", Arg<CEnum*>(0)->GetName() );
15659  break;
15660  case eTYPE_REF:
15661  fprintf( f, "%s", Arg<CTypedef*>(0)->GetName() );
15662  break;
15663  case eVAR_DECL:
15664  fprintf( f, "%s", "VarDecl" );
15665  break;
15666  case eLIST:
15667  fprintf( f, "%s", "(" );
15668  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15669  fprintf( f, "%s", "," );
15670  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15671  fprintf( f, "%s", ")" );
15672  break;
15673  case eRANGE:
15674  fprintf( f, "%s", "" );
15675  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15676  fprintf( f, "%s", ":" );
15677  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15678  fprintf( f, "%s", "" );
15679  break;
15680  case eSLICE:
15681  fprintf( f, "%s", "" );
15682  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15683  fprintf( f, "%s", ":" );
15684  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15685  fprintf( f, "%s", "" );
15686  break;
15687  case ePSLICE:
15688  fprintf( f, "%s", "" );
15689  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15690  fprintf( f, "%s", "+:" );
15691  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15692  fprintf( f, "%s", "" );
15693  break;
15694  case eMSLICE:
15695  fprintf( f, "%s", "" );
15696  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15697  fprintf( f, "%s", "-:" );
15698  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15699  fprintf( f, "%s", "" );
15700  break;
15701  case eCVRI:
15702  fprintf( f, "%s", "CVRI(" );
15703  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15704  fprintf( f, "%s", ")" );
15705  break;
15706  case eCVIR:
15707  fprintf( f, "%s", "CVIR(" );
15708  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15709  fprintf( f, "%s", ")" );
15710  break;
15711  case eREP:
15712  fprintf( f, "%s", "{" );
15713  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15714  fprintf( f, "%s", "{" );
15715  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15716  fprintf( f, "%s", "}}" );
15717  break;
15718  case eCAT:
15719  fprintf( f, "%s", "{" );
15720  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15721  fprintf( f, "%s", "," );
15722  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15723  fprintf( f, "%s", "}" );
15724  break;
15725  case eUCAT:
15726  fprintf( f, "%s", "{" );
15727  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15728  fprintf( f, "%s", "}" );
15729  break;
15730  case eCOM:
15731  fprintf( f, "%s", "~(" );
15732  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15733  fprintf( f, "%s", ")" );
15734  break;
15735  case eNEG:
15736  fprintf( f, "%s", "-(" );
15737  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15738  fprintf( f, "%s", ")" );
15739  break;
15740  case ePLUS:
15741  fprintf( f, "%s", "+(" );
15742  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15743  fprintf( f, "%s", ")" );
15744  break;
15745  case eNOT:
15746  fprintf( f, "%s", "!(" );
15747  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15748  fprintf( f, "%s", ")" );
15749  break;
15750  case eGT:
15751  fprintf( f, "%s", "(" );
15752  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15753  fprintf( f, "%s", ")>(" );
15754  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15755  fprintf( f, "%s", ")" );
15756  break;
15757  case eGE:
15758  fprintf( f, "%s", "(" );
15759  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15760  fprintf( f, "%s", ")>=(" );
15761  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15762  fprintf( f, "%s", ")" );
15763  break;
15764  case eLT:
15765  fprintf( f, "%s", "(" );
15766  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15767  fprintf( f, "%s", ")<(" );
15768  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15769  fprintf( f, "%s", ")" );
15770  break;
15771  case eLE:
15772  fprintf( f, "%s", "(" );
15773  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15774  fprintf( f, "%s", ")<=(" );
15775  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15776  fprintf( f, "%s", ")" );
15777  break;
15778  case eLAND:
15779  fprintf( f, "%s", "(" );
15780  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15781  fprintf( f, "%s", ")&&(" );
15782  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15783  fprintf( f, "%s", ")" );
15784  break;
15785  case eLOR:
15786  fprintf( f, "%s", "(" );
15787  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15788  fprintf( f, "%s", ")||(" );
15789  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15790  fprintf( f, "%s", ")" );
15791  break;
15792  case eCEQ:
15793  fprintf( f, "%s", "(" );
15794  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15795  fprintf( f, "%s", ")===(" );
15796  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15797  fprintf( f, "%s", ")" );
15798  break;
15799  case eCNE:
15800  fprintf( f, "%s", "(" );
15801  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15802  fprintf( f, "%s", ")!==(" );
15803  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15804  fprintf( f, "%s", ")" );
15805  break;
15806  case eEQ:
15807  fprintf( f, "%s", "(" );
15808  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15809  fprintf( f, "%s", ")==(" );
15810  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15811  fprintf( f, "%s", ")" );
15812  break;
15813  case eNE:
15814  fprintf( f, "%s", "(" );
15815  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15816  fprintf( f, "%s", ")!=(" );
15817  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15818  fprintf( f, "%s", ")" );
15819  break;
15820  case eRAND:
15821  fprintf( f, "%s", "&(" );
15822  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15823  fprintf( f, "%s", ")" );
15824  break;
15825  case eRNAND:
15826  fprintf( f, "%s", "~&(" );
15827  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15828  fprintf( f, "%s", ")" );
15829  break;
15830  case eROR:
15831  fprintf( f, "%s", "|(" );
15832  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15833  fprintf( f, "%s", ")" );
15834  break;
15835  case eRNOR:
15836  fprintf( f, "%s", "~|(" );
15837  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15838  fprintf( f, "%s", ")" );
15839  break;
15840  case eRXOR:
15841  fprintf( f, "%s", "^(" );
15842  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15843  fprintf( f, "%s", ")" );
15844  break;
15845  case eRXNOR:
15846  fprintf( f, "%s", "~^(" );
15847  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15848  fprintf( f, "%s", ")" );
15849  break;
15850  case eHOOK:
15851  fprintf( f, "%s", "(" );
15852  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15853  fprintf( f, "%s", ")?(" );
15854  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15855  fprintf( f, "%s", "):(" );
15856  if( Arg<CNode*>(2) ) Arg<CNode*>(2)->Dump( f ); else fprintf( f, "NULL" );
15857  fprintf( f, "%s", ")" );
15858  break;
15859  case eINIT:
15860  fprintf( f, "%s", "INIT(*)" );
15861  break;
15862  case ePOSEDGE:
15863  fprintf( f, "%s", "POSEDGE(" );
15864  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15865  fprintf( f, "%s", ")" );
15866  break;
15867  case eNEGEDGE:
15868  fprintf( f, "%s", "NEGEDGE(" );
15869  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15870  fprintf( f, "%s", ")" );
15871  break;
15872  case eEDGE:
15873  fprintf( f, "%s", "EDGE(" );
15874  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15875  fprintf( f, "%s", ")" );
15876  break;
15877  case eMTM:
15878  fprintf( f, "%s", "(" );
15879  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15880  fprintf( f, "%s", ":" );
15881  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15882  fprintf( f, "%s", ":" );
15883  if( Arg<CNode*>(2) ) Arg<CNode*>(2)->Dump( f ); else fprintf( f, "NULL" );
15884  fprintf( f, "%s", ")" );
15885  break;
15886  case eMODULE_DEF:
15887  fprintf( f, "%s", "MODULE_DEF" );
15888  break;
15889  case ePACKAGE_DEF:
15890  fprintf( f, "%s", "PACKAGE_DEF" );
15891  break;
15892  case eMACRO_EXPR:
15893  fprintf( f, "%s", "" );
15894  fprintf( f, "%s", (const char*)Arg<const char*>(0) );
15895  fprintf( f, "%s", "<" );
15896  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15897  fprintf( f, "%s", ">" );
15898  break;
15899  case eMEMBER:
15900  fprintf( f, "%s", "" );
15901  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15902  fprintf( f, "%s", "." );
15903  fprintf( f, "%s", Arg<CSymbol*>(1)->GetName() );
15904  fprintf( f, "%s", "" );
15905  break;
15906  case ePREINC:
15907  fprintf( f, "%s", "++(" );
15908  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15909  fprintf( f, "%s", ")" );
15910  break;
15911  case ePOSTINC:
15912  fprintf( f, "%s", "(" );
15913  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15914  fprintf( f, "%s", ")++" );
15915  break;
15916  case ePREDEC:
15917  fprintf( f, "%s", "--(" );
15918  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15919  fprintf( f, "%s", ")" );
15920  break;
15921  case ePOSTDEC:
15922  fprintf( f, "%s", "(" );
15923  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15924  fprintf( f, "%s", ")--" );
15925  break;
15926  case eCAST:
15927  fprintf( f, "%s", "CAST(" );
15928  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15929  fprintf( f, "%s", "," );
15930  if( Arg<CNode*>(1) ) Arg<CNode*>(1)->Dump( f ); else fprintf( f, "NULL" );
15931  fprintf( f, "%s", ")" );
15932  break;
15933  case eASSIGNMENT_PATTERN:
15934  fprintf( f, "%s", "'" );
15935  if( Arg<CNode*>(0) ) Arg<CNode*>(0)->Dump( f ); else fprintf( f, "NULL" );
15936  fprintf( f, "%s", "" );
15937  break;
15938  case eDOLLAR:
15939  fprintf( f, "%s", "$" );
15940  break;
15941  case eCOMMENT:
15942  case eVRQ:
15943  case eNOP:
15944  case eINSTANCE_REF:
15945  case eGATE_REF:
15946  case eTASK_ENABLE:
15947  case eSYSTASK_CALL:
15948  case eTIMING_CALL:
15949  case eNET_DECL:
15950  case ePARAM_DECL:
15951  case eSPECPARAM_DECL:
15952  case ePORT_DECL:
15953  case eGENVAR_DECL:
15954  case eTYPEDEF_DECL:
15955  case eALWAYS:
15956  case eALWAYS_LATCH:
15957  case eALWAYS_FF:
15958  case eALWAYS_COMB:
15959  case eEVENT:
15960  case eBLOCK_REF:
15961  case eSPECIFY_REF:
15962  case eASSIGN:
15963  case eGASSIGN:
15964  case eADD_ASSIGN:
15965  case eSUB_ASSIGN:
15966  case eMUL_ASSIGN:
15967  case eDIV_ASSIGN:
15968  case eMOD_ASSIGN:
15969  case eAND_ASSIGN:
15970  case eOR_ASSIGN:
15971  case eXOR_ASSIGN:
15972  case eLSH_ASSIGN:
15973  case eRSH_ASSIGN:
15974  case eLSHA_ASSIGN:
15975  case eRSHA_ASSIGN:
15976  case eFORCE:
15977  case eRELEASE:
15978  case eNBASSIGN:
15979  case eEVOR:
15980  case eDELAY:
15981  case eIF:
15982  case eFOREVER:
15983  case eREPEAT:
15984  case eWHILE:
15985  case eWAIT:
15986  case eFOR:
15987  case eCASE:
15988  case eCASEX:
15989  case eCASEZ:
15990  case eCASEITEM:
15991  case eCASSIGN:
15992  case eARG:
15993  case eIMPORT:
15994  case eFUNCTION_DEF:
15995  case eREPEAT_CONTROL:
15996  case eDELAY_CONTROL:
15997  case eEVENT_CONTROL:
15998  case eEXTERNAL_REF:
15999  case ePORT_DEF:
16000  case eDEFPARAM:
16001  case ePATH:
16002  case ePATH_ASSIGN:
16003  case eIFNONE_PATH_ASSIGN:
16004  case eTRIGGER:
16005  case ePASSIGN:
16006  case eDEASSIGN:
16007  case eDISABLE:
16008  case eATTRIBUTE:
16009  case eGIF:
16010  case eGFOR:
16011  case eGCASE:
16012  case eTABLE:
16013  case eTABLE_ENTRY:
16014  case eTABLE_SYMBOL:
16015  case ePORTLIST_END:
16016  case eENUM_SPEC:
16017  case eRETURN:
16018  fprintf( f, "%s(%p)", nodeOpName[GetOp()],this );
16019  break;
16020  }
16021 }
16022 
16023 #endif // DEFINE_METHODS
16024 
16025 #ifdef DEFINE_TEST_HARNESS
16027 {
16028  for( int i = 0; i < 155; ++i ) {
16029  CNode* n = new(CNode::stack) CNode( NULL, (NodeOp_t)i );
16030  if( n->Precedence() != n->Precedence_1() ) {
16031  printf( "Fail %s\n", nodeOpName[i] );
16032  exit(1);
16033  }
16034  }
16035 }
16036 #endif // DEFINE_TEST_HARNESS
CNode * cDIV(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for DIV divide.
Definition: cnode_def.h:2991
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:2925
static NodeType_t Type(CSymbol *symbol, CNode *args)
Determine type of systask.
Definition: systask.h:134
nonblocking assignment
Definition: cnode_def.h:1735
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:5988
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:4911
CNode * cFOREVER(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for FOREVER forever statement.
Definition: cnode_def.h:6164
real constant
Definition: cnode_def.h:666
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:5536
CNode * cDEASSIGN(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for DEASSIGN deassign statement.
Definition: cnode_def.h:7038
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:5462
preincrement
Definition: cnode_def.h:2262
CNode * cASSIGN(CNode *a0, CNode *a1, CNode *a2, Coord_t *loc=NULL)
Node construction shortcut for ASSIGN procedural assignment.
Definition: cnode_def.h:5314
vector subrange with ascending index select
Definition: cnode_def.h:1165
force statement
Definition: cnode_def.h:1713
condition expression operator
Definition: cnode_def.h:1450
arithmetic right shift
Definition: cnode_def.h:827
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:6484
procedural assignment with mul
Definition: cnode_def.h:1594
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:5425
sentinal at end of port list
Definition: cnode_def.h:2208
CNode * cPARAM_DECL(CParam *a0, Coord_t *loc=NULL)
Node construction shortcut for PARAM_DECL parameter declaration.
Definition: cnode_def.h:3944
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:6054
reduction xnor
Definition: cnode_def.h:1438
case not equal
Definition: cnode_def.h:1356
CNode * cMOD(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for MOD modulus.
Definition: cnode_def.h:3222
CNode * cWAIT(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for WAIT wait statement.
Definition: cnode_def.h:6260
no operation
Definition: cnode_def.h:728
Declaration object for genvars.
Definition: cgenvar.h:46
reduction nand
Definition: cnode_def.h:1398
CNode * cELIST(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for ELIST expression list.
Definition: cnode_def.h:2834
undefined
Definition: cdatatype.h:102
error node
Definition: cnode_def.h:646
CNode * cPORT_REF(CPortDir *a0, Coord_t *loc=NULL)
Node construction shortcut for PORT_REF reference to port.
Definition: cnode_def.h:3733
signed bit vector, includes integer
Definition: cdatatype.h:104
gate instance
Definition: cnode_def.h:913
procedural assignment with right shift
Definition: cnode_def.h:1678
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:1992
exponent
Definition: cnode_def.h:772
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:3578
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:2742
statement block
Definition: cnode_def.h:1523
disable statement
Definition: cnode_def.h:2123
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:1654
vector decl range specification
Definition: cnode_def.h:1143
case equal
Definition: cnode_def.h:1345
CNode * cREAL(double number)
Short cut for creating RCONSTANT node with a given double value.
Definition: cnode.h:817
negative event qualifier
Definition: cnode_def.h:1755
import item
Definition: cnode_def.h:1951
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:5499
initial block
Definition: cnode_def.h:1460
CNode * cPREDEC(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for PREDEC predecrement.
Definition: cnode_def.h:7538
CNode * cGIF(CNode *a0, CNode *a1, CNode *a2, Coord_t *loc=NULL)
Node construction shortcut for GIF structural if statement.
Definition: cnode_def.h:7127
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:3762
int IsEvaluateable()
Checks to see if expression tree can be evaluated.
Definition: cnode_def.h:12850
CNode * cPRAGMA(const char *a0, int a1, Coord_t *loc=NULL)
Node construction shortcut for PRAGMA program pragma.
Definition: cnode_def.h:2801
CNode * cCASEX(CNode *a0, CNode *a1, ConditionalType a2, Coord_t *loc=NULL)
Node construction shortcut for CASEX casex statement.
Definition: cnode_def.h:6376
bitwise and
Definition: cnode_def.h:860
CNode * cCAT(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for CAT concatenation operator.
Definition: cnode_def.h:4346
postincrement
Definition: cnode_def.h:2272
void Add(double *r, double *a, double *b)
Definition: cnode.h:682
CNode * cRXOR(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for RXOR reduction xor.
Definition: cnode_def.h:4969
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:6523
CNode * cMAX_N(CNode *first,...)
Definition: cnode.h:1266
CNode * cAND(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for AND bitwise and.
Definition: cnode_def.h:3288
instance reference
Definition: cnode_def.h:903
CNode * cTABLE_SYMBOL(char *a0, Coord_t *loc=NULL)
Node construction shortcut for TABLE_SYMBOL udp table symbol.
Definition: cnode_def.h:7294
CNode * cPOSEDGE(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for POSEDGE positive event qualifier.
Definition: cnode_def.h:5929
not equal
Definition: cnode_def.h:1378
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:5795
CNode * cNOT(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for NOT logical complement.
Definition: cnode_def.h:4494
CNode * cRETURN(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for RETURN return.
Definition: cnode_def.h:7451
void Neg(double *r, double *a)
Definition: cnode.h:702
CNode * cCEQ(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for CEQ case equal.
Definition: cnode_def.h:4722
list of nodes
Definition: cnode_def.h:1132
greater than or equal
Definition: cnode_def.h:1290
CNode * cEQ(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for EQ equal.
Definition: cnode_def.h:4788
vector constant
Definition: cnode_def.h:656
procedural assignment
Definition: cnode_def.h:1546
assignment_pattern
Definition: cnode_def.h:2313
Coord_t * GetCoord()
Get node's file coordinates.
Definition: cnode.h:312
CNode * cNET_DECL(CNet *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for NET_DECL net declaration.
Definition: cnode_def.h:3879
wait statement
Definition: cnode_def.h:1856
CNode * cMUL_N(CNode *first,...)
Definition: cnode.h:1300
CNode * cIFNONE_PATH_ASSIGN(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for IFNONE_PATH_ASSIGN ifnone path assignment statement.
Definition: cnode_def.h:6944
static CObstack * CurrentHeap()
Gets pointer to current heap allocator.
Definition: cnode.h:237
CNode * cEVOR(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for EVOR event or.
Definition: cnode_def.h:6021
int IsConstant()
Checks expression tree to see if it is constant.
Definition: cnode_def.h:8189
CNode * GetWidthExp(void)
Create expression representing width of expression.
Definition: cnode_def.h:8843
reduction xor
Definition: cnode_def.h:1428
case item
Definition: cnode_def.h:1917
delay control
Definition: cnode_def.h:2002
CNode * cRAND(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for RAND reduction and.
Definition: cnode_def.h:4853
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:5894
CNode * cNEG(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for NEG negation.
Definition: cnode_def.h:4436
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:5610
reduction nor
Definition: cnode_def.h:1418
CNode * cGT(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for GT greater than.
Definition: cnode_def.h:4524
CNode * cCVRI(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for CVRI convert real to integer.
Definition: cnode_def.h:4254
void PostVisit1(void(*callback)(CNode *, void *), void *data)
Walk tree invoking callback on each node after children have been visited.
Definition: cnode_def.h:10660
port connection
Definition: cnode_def.h:1941
long INT32
Short cut for signed 32 bit integer.
Definition: glue.h:38
arithmetic left shift
Definition: cnode_def.h:816
CNode * cDISABLE(CSymbol *a0, Coord_t *loc=NULL)
Node construction shortcut for DISABLE disable statement.
Definition: cnode_def.h:7067
CNode * cREPEAT_CONTROL(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for REPEAT_CONTROL repeat control.
Definition: cnode_def.h:6672
variable declaration
Definition: cnode_def.h:1071
int IsVolatile(void)
Checks to see if expression tree is volatile.
Definition: cnode_def.h:8355
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:5758
path statement
Definition: cnode_def.h:2059
int Precedence()
Get the precedence of the operator represented by the node.
Definition: cnode_def.h:8017
genvar declaration
Definition: cnode_def.h:1111
CNode_sp< T > Arg(int index)
Get a node's operand.
Definition: cnode.h:549
Edge_t
Edge values.
Definition: cnode.h:72
CNode * cFOR(CNode *a0, CNode *a1, CNode *a2, CNode *a3, Coord_t *loc=NULL)
Node construction shortcut for FOR for statement.
Definition: cnode_def.h:6295
CNode * cRSH(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for RSH logical right shift.
Definition: cnode_def.h:3123
reference to port
Definition: cnode_def.h:1009
CNode * cFUNCTION_DEF(CFunction *a0, Coord_t *loc=NULL)
Node construction shortcut for FUNCTION_DEF function definition.
Definition: cnode_def.h:6584
convert integer to real
Definition: cnode_def.h:1196
logical and
Definition: cnode_def.h:1323
reduction or
Definition: cnode_def.h:1408
less than or equal
Definition: cnode_def.h:1312
edge qualifier
Definition: cnode_def.h:1766
reduction and
Definition: cnode_def.h:1388
bitwise or
Definition: cnode_def.h:849
CNode * cSLICE(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for SLICE vector subrange.
Definition: cnode_def.h:4156
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:4623
reference to a forward declared variable
Definition: cnode_def.h:1019
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:4189
CNode * cSPECPARAM_DECL(CParam *a0, Coord_t *loc=NULL)
Node construction shortcut for SPECPARAM_DECL specify parameter declaration.
Definition: cnode_def.h:3973
void CNodeTestHarness()
Definition: cnode_def.h:16026
comment
Definition: cnode_def.h:676
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:6227
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:5388
bitwise xor
Definition: cnode_def.h:882
CNode * cCAST(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for CAST data type change.
Definition: cnode_def.h:7597
procedural assignment with div
Definition: cnode_def.h:1606
procedural assignment with add
Definition: cnode_def.h:1570
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:5029
concatenation operator
Definition: cnode_def.h:1218
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:1666
port declaration
Definition: cnode_def.h:1101
CNode * cPACKAGE_DEF(CPackage *a0, Coord_t *loc=NULL)
Node construction shortcut for PACKAGE_DEF package definition.
Definition: cnode_def.h:6642
reference to a genvar
Definition: cnode_def.h:1029
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:7165
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:6908
CNode * cATTRIBUTE(CAttr *a0, Coord_t *loc=NULL)
Node construction shortcut for ATTRIBUTE attribute specification.
Definition: cnode_def.h:7096
CNode * cTABLE_ENTRY(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for TABLE_ENTRY udp table entry.
Definition: cnode_def.h:7265
convert real to integer
Definition: cnode_def.h:1186
int ArgCount(void)
Get the number of operands for the node.
Definition: cnode_def.h:7691
CNode * cGENVAR_DECL(CGenvar *a0, Coord_t *loc=NULL)
Node construction shortcut for GENVAR_DECL genvar declaration.
Definition: cnode_def.h:4031
CNode * cALWAYS(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for ALWAYS always block.
Definition: cnode_def.h:5093
CNode * cERROR(Coord_t *loc=NULL)
Node construction shortcut for ERROR error node.
Definition: cnode_def.h:2658
unsigned bit vector
Definition: cdatatype.h:106
CNode * cSYSTASK_CALL(CSymbol *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for SYSTASK_CALL call to enable a systask.
Definition: cnode_def.h:3511
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:3849
CNode * cALWAYS_COMB(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for ALWAYS_COMB always combinational logic block.
Definition: cnode_def.h:5180
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:2133
CNode * cRANGE(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for RANGE vector decl range specification.
Definition: cnode_def.h:4123
event statement
Definition: cnode_def.h:1511
Declaration object for module/function/task ports.
Definition: cport.h:44
generate intialize assignment
Definition: cnode_def.h:1558
divide
Definition: cnode_def.h:761
static int WidthConstant(CSymbol *symbol)
Determine if width of external variable is constant.
Definition: external.h:62
Forward reference declaration.
Definition: cfref.h:51
Bulk object allocation object.
Definition: cobstack.h:46
CNode * cABSDIFFPLUS1_N(CNode *first,...)
Definition: cnode.h:1316
delay statement
Definition: cnode_def.h:1788
negation
Definition: cnode_def.h:1248
logical right shift
Definition: cnode_def.h:805
casez statement
Definition: cnode_def.h:1906
unary concat
Definition: cnode_def.h:1228
call to a task
Definition: cnode_def.h:924
reference to net
Definition: cnode_def.h:979
void LoadReal(double d)
Load vector with integer part of real value.
int error
Definition: cnode_def.h:13899
int IsOwner(void *ptr)
Determine if pointer was allocated from this obstack.
Definition: cnode_def.h:13897
CNode * cFORCE(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for FORCE force statement.
Definition: cnode_def.h:5831
CNode * cEXTERNAL_REF(CSymbol *a0, Coord_t *loc=NULL)
Node construction shortcut for EXTERNAL_REF external reference.
Definition: cnode_def.h:6762
vrq comment
Definition: cnode_def.h:686
CNode * cLAND(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for LAND logical and.
Definition: cnode_def.h:4656
CNode * cRSHA(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for RSHA arithmetic right shift.
Definition: cnode_def.h:3189
equal
Definition: cnode_def.h:1367
unary plus
Definition: cnode_def.h:1258
Primary data structure representing parse tree nodes.
Definition: cnode.h:197
CNode * cPASSIGN(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for PASSIGN procedural assignment.
Definition: cnode_def.h:7006
CNode * cANDANDAND(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for ANDANDAND triple and.
Definition: cnode_def.h:3321
CNode * cNET_REF(CNet *a0, Coord_t *loc=NULL)
Node construction shortcut for NET_REF reference to net.
Definition: cnode_def.h:3646
integer declaration
Definition: cdatatype.h:50
NodeOp_t
Parse tree opcodes.
Definition: cnode_def.h:637
CNode * cGASSIGN(bool a0, CNode *a1, CNode *a2, Coord_t *loc=NULL)
Node construction shortcut for GASSIGN generate intialize assignment.
Definition: cnode_def.h:5351
void info(struct Coord_t *location, const char *format,...)
This routine should not be used by plugins.
program pragma
Definition: cnode_def.h:697
CNode * cCASEZ(CNode *a0, CNode *a1, ConditionalType a2, Coord_t *loc=NULL)
Node construction shortcut for CASEZ casez statement.
Definition: cnode_def.h:6413
CNode * cTRIGGER(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for TRIGGER event trigger.
Definition: cnode_def.h:6976
return
Definition: cnode_def.h:2252
CNode * cCNE(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for CNE case not equal.
Definition: cnode_def.h:4755
CNode * cVAR_REF(CVar *a0, Coord_t *loc=NULL)
Node construction shortcut for VAR_REF reference to variable.
Definition: cnode_def.h:3675
CNode * cCOM(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for COM bitwise complement.
Definition: cnode_def.h:4407
positive event qualifier
Definition: cnode_def.h:1745
CNode * cWIDTH(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for WIDTH expression width change.
Definition: cnode_def.h:2867
CNode * cEVENT(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for EVENT event statement.
Definition: cnode_def.h:5210
defparam statement
Definition: cnode_def.h:2043
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:9457
Declaration object for module and gate instances.
Definition: cinstance.h:45
expression list
Definition: cnode_def.h:708
void EvalVector(CVector &v)
Evaluates expression tree evaluated in unconstrainted context.
Definition: cnode.cc:360
udp table symbol
Definition: cnode_def.h:2199
CNode * cEVENT_CONTROL(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for EVENT_CONTROL event control.
Definition: cnode_def.h:6733
multiply
Definition: cnode_def.h:750
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:4222
call to a function
Definition: cnode_def.h:958
queue dimension
Definition: cnode_def.h:2322
CNode * cARRAY(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for ARRAY dimensioned reference (array/bit select)
Definition: cnode_def.h:3614
CNode * cVRQ(const char *a0, Coord_t *loc=NULL)
Node construction shortcut for VRQ vrq comment.
Definition: cnode_def.h:2771
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:7509
parameter declaration
Definition: cnode_def.h:1081
void Pow(double *r, double *a, double *b)
Definition: cnode.h:712
less than
Definition: cnode_def.h:1301
CNode * cALWAYS_FF(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for ALWAYS_FF always flip-flop block.
Definition: cnode_def.h:5151
CNode * cCASEITEM(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for CASEITEM case item.
Definition: cnode_def.h:6449
CNode * cCASE(CNode *a0, CNode *a1, ConditionalType a2, bool a3, Coord_t *loc=NULL)
Node construction shortcut for CASE case statement.
Definition: cnode_def.h:6336
replication operator
Definition: cnode_def.h:1207
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:2242
CNode * cINIT(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for INIT initial block.
Definition: cnode_def.h:5064
Definition: cmodule.h:54
void SetAttributes(CNode *attr)
Attach attributes to operation.
Definition: cnode.h:519
CNode * cPORTLIST_END(Coord_t *loc=NULL)
Node construction shortcut for PORTLIST_END sentinal at end of port list.
Definition: cnode_def.h:7322
package definition
Definition: cnode_def.h:1981
bitwise xnor
Definition: cnode_def.h:893
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:7419
CNode * cALWAYS_LATCH(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for ALWAYS_LATCH always latch block.
Definition: cnode_def.h:5122
event control
Definition: cnode_def.h:2012
event or
Definition: cnode_def.h:1777
const char * nodeOpDescription[]
Definition: cnode_def.h:2487
CNode * PostSubVisit1(CNode *(*callback)(CNode *, void *), void *data)
Walk tree invoking callback on each node after children have been visited.
Definition: cnode_def.h:11199
procedural assignment with bitwise and
Definition: cnode_def.h:1630
CNode * cPOSTDEC(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for POSTDEC postdecrement.
Definition: cnode_def.h:7567
udp table
Definition: cnode_def.h:2179
for statement
Definition: cnode_def.h:1869
triple and
Definition: cnode_def.h:871
void Div(double *r, double *a, double *b)
Definition: cnode.h:697
CNode * cXOR(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for XOR bitwise xor.
Definition: cnode_def.h:3354
event trigger
Definition: cnode_def.h:2092
structural if statement
Definition: cnode_def.h:2145
reference to a enum
Definition: cnode_def.h:1039
int Equivalent(CNode *a, CNode *b)
Definition: cnode_def.h:12289
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:5958
postdecrement
Definition: cnode_def.h:2292
module definition
Definition: cnode_def.h:1971
void Sub(double *r, double *a, double *b)
Definition: cnode.h:687
subtract
Definition: cnode_def.h:739
CNode * cRNAND(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for RNAND reduction nand.
Definition: cnode_def.h:4882
specify parameter declaration
Definition: cnode_def.h:1091
forever statement
Definition: cnode_def.h:1823
CNode * cRELEASE(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for RELEASE release statement.
Definition: cnode_def.h:5863
Declaration object for variables.
Definition: cvar.h:50
CNode * cIF(CNode *a0, CNode *a1, CNode *a2, ConditionalType a3, Coord_t *loc=NULL)
Node construction shortcut for IF if statement.
Definition: cnode_def.h:6126
external reference
Definition: cnode_def.h:2022
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:4940
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:6088
while statement
Definition: cnode_def.h:1845
CNode * cENUM_REF(CEnum *a0, Coord_t *loc=NULL)
Node construction shortcut for ENUM_REF reference to a enum.
Definition: cnode_def.h:3820
CNode * cTABLE(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for TABLE udp table.
Definition: cnode_def.h:7236
CNode * cPOW(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for POW exponent.
Definition: cnode_def.h:3024
CNode * cREPEAT(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for REPEAT repeat statement.
Definition: cnode_def.h:6194
CNode * cOR(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for OR bitwise or.
Definition: cnode_def.h:3255
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:1702
CNode * cINT32(INT32 i)
Short cut for creating VCONSTANT node with a given integer value.
Definition: cnode.h:798
int suppressErrorMessages
Definition: cnode_def.h:13898
CNode * cASSIGNMENT_PATTERN(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for ASSIGNMENT_PATTERN assignment_pattern.
Definition: cnode_def.h:7629
function definition
Definition: cnode_def.h:1961
CNode * cNE(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for NE not equal.
Definition: cnode_def.h:4821
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:2231
CNode * cGATE_REF(CGate *a0, Coord_t *loc=NULL)
Node construction shortcut for GATE_REF gate instance.
Definition: cnode_def.h:3448
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:6859
int IsWidthEvaluateable(void)
Evaluates if expression width can be evaluated.
Definition: cnode_def.h:9295
CNode * cRCONSTANT(char *a0, Coord_t *loc=NULL)
Node construction shortcut for RCONSTANT real constant.
Definition: cnode_def.h:2713
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:3912
event - have width 0
Definition: cdatatype.h:105
CNode * cPORT_DEF(CPort *a0, Coord_t *loc=NULL)
Node construction shortcut for PORT_DEF port definition.
Definition: cnode_def.h:6791
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:4557
void PreVisit1(int(*callback)(CNode *, void *), void *data)
Walk tree invoking callback on each node before children have been visited.
Definition: cnode_def.h:10134
procedural assignment with mod
Definition: cnode_def.h:1618
CNode * cIMPORT(CSymbol *a0, Coord_t *loc=NULL)
Node construction shortcut for IMPORT import item.
Definition: cnode_def.h:6555
static int Width(CSymbol *symbol, CNode *args)
Get width of systask.
Definition: systask.h:48
INT32 GetWidth(void)
Evaluate width of expression.
Definition: cnode.h:494
call to a timing task
Definition: cnode_def.h:946
CNode * cLT(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for LT less than.
Definition: cnode_def.h:4590
release statement
Definition: cnode_def.h:1723
void Mul(double *r, double *a, double *b)
Definition: cnode.h:692
CNode * cLSH_ASSIGN(CNode *a0, CNode *a1, CNode *a2, Coord_t *loc=NULL)
Node construction shortcut for LSH_ASSIGN procedural assignment with left shift.
Definition: cnode_def.h:5684
structural case statement
Definition: cnode_def.h:2169
int IsWidthConstant(void)
Evaluates if expression width is constant.
Definition: cnode_def.h:8521
CNode * cREP(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for REP replication operator.
Definition: cnode_def.h:4313
CNode * cDELAY_CONTROL(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for DELAY_CONTROL delay control.
Definition: cnode_def.h:6704
CNode * cNOP(Coord_t *loc=NULL)
Node construction shortcut for NOP no operation.
Definition: cnode_def.h:2898
NodeType_t GetNodeType(void)
Get node expression type.
Definition: cnode.h:540
always block
Definition: cnode_def.h:1470
reference to a type
Definition: cnode_def.h:1049
udp table entry
Definition: cnode_def.h:2189
void Plus(double *r, double *a)
Definition: cnode.h:707
INT32 GetWidth(void)
Get vector bit width.
CNode * cDOLLAR(Coord_t *loc=NULL)
Node construction shortcut for DOLLAR queue dimension.
Definition: cnode_def.h:7657
static int WidthConstant(CSymbol *symbol, CNode *args, CBlock *block)
Determine if width of function is constant.
path assignment statement
Definition: cnode_def.h:2071
int Signed() const
Get signed attribute.
Definition: cvector.h:178
vector subrange
Definition: cnode_def.h:1154
real - have width 0
Definition: cdatatype.h:103
Declaration object for functions and tasks.
Definition: cfunction.h:50
port definition
Definition: cnode_def.h:2032
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:4090
always flip-flop block
Definition: cnode_def.h:1490
call to enable a systask
Definition: cnode_def.h:935
procedural assignment
Definition: cnode_def.h:2103
CNode * cGCASE(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for GCASE structural case statement.
Definition: cnode_def.h:7204
procedural assignment with bitwise or
Definition: cnode_def.h:1642
unsigned Hash()
Calculate hash of tree.
Definition: cnode_def.h:11740
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:3544
CNode * cRXNOR(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for RXNOR reduction xnor.
Definition: cnode_def.h:4998
structural for statement
Definition: cnode_def.h:2158
logical complement
Definition: cnode_def.h:1268
Declaration object for input/output/inout statements.
Definition: cportdir.h:45
CNode * cMAX(CNode *n1, CNode *n2)
Short cut for creating a expression tree that calculates the maximum of two expressions.
Definition: cnode.h:895
CNode * cXNOR(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for XNOR bitwise xnor.
Definition: cnode_def.h:3387
casex statement
Definition: cnode_def.h:1894
always latch block
Definition: cnode_def.h:1480
CNode * cADD_N(CNode *first,...)
Definition: cnode.h:1284
CNode * cMACRO_EXPR(const char *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for MACRO_EXPR expression represented by a macro.
Definition: cnode_def.h:7349
addition
Definition: cnode_def.h:783
repeat statement
Definition: cnode_def.h:1834
expression represented by a macro
Definition: cnode_def.h:2219
deassign statement
Definition: cnode_def.h:2113
NodeType_t
Expression node type.
Definition: cdatatype.h:101
CNode * cSPECIFY_REF(CSpecify *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for SPECIFY_REF specify block.
Definition: cnode_def.h:5280
data type change
Definition: cnode_def.h:2303
procedural assignment with subtract
Definition: cnode_def.h:1582
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:5721
CNode * GetAttributes()
Get attributes attached to operation.
Definition: cnode.h:514
CNode * cADD(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for ADD addition.
Definition: cnode_def.h:3057
const char * nodeOpName[]
Definition: cnode_def.h:2328
predecrement
Definition: cnode_def.h:2282
CNode * cDEFPARAM(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for DEFPARAM defparam statement.
Definition: cnode_def.h:6821
dimensioned reference (array/bit select)
Definition: cnode_def.h:969
CNode * cPORT_DECL(CPortDir *a0, Coord_t *loc=NULL)
Node construction shortcut for PORT_DECL port declaration.
Definition: cnode_def.h:4002
CNode * cLOR(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for LOR logical or.
Definition: cnode_def.h:4689
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:7383
NodeOp_t GetOp()
Return node's operation type.
Definition: cnode.h:317
CNode * cLSH(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for LSH logical left shift.
Definition: cnode_def.h:3090
int IsWidthVolatile(void)
Evaluates if expression width is volatile.
Definition: cnode_def.h:8681
type declaration
Definition: cnode_def.h:1121
CNode * cVCONSTANT(CVector *a0, Coord_t *loc=NULL)
Node construction shortcut for VCONSTANT vector constant.
Definition: cnode_def.h:2684
void Dump(FILE *f)
Print a compact representation of the parse tree.
Definition: cnode_def.h:15487
logical left shift
Definition: cnode_def.h:794
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:4378
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:1930
CNode * cTYPEDEF_DECL(CTypedef *a0, Coord_t *loc=NULL)
Node construction shortcut for TYPEDEF_DECL type declaration.
Definition: cnode_def.h:4060
int cABSDIFFPLUS1(int a1, int a2)
Definition: cnode.h:1354
vector subrange with descending index select
Definition: cnode_def.h:1176
bitwise complement
Definition: cnode_def.h:1238
reference to parameter
Definition: cnode_def.h:999
always combinational logic block
Definition: cnode_def.h:1500
double EvalReal(void)
Evaluates expression tree evaluated in a real context.
Definition: cnode.cc:391
case statement
Definition: cnode_def.h:1882
CNode * cLSHA(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for LSHA arithmetic left shift.
Definition: cnode_def.h:3156
CNode * cPARAM_REF(CParam *a0, Coord_t *loc=NULL)
Node construction shortcut for PARAM_REF reference to parameter.
Definition: cnode_def.h:3704
greater than
Definition: cnode_def.h:1279
CNode * cMODULE_DEF(CModule *a0, Coord_t *loc=NULL)
Node construction shortcut for MODULE_DEF module definition.
Definition: cnode_def.h:6613
specify block
Definition: cnode_def.h:1534
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:7480
CNode * cPLUS(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for PLUS unary plus.
Definition: cnode_def.h:4465
modulus
Definition: cnode_def.h:838
ifnone path assignment statement
Definition: cnode_def.h:2082
net declaration
Definition: cnode_def.h:1060
expression width change
Definition: cnode_def.h:719
CNode * cINSTANCE_REF(CInstance *a0, Coord_t *loc=NULL)
Node construction shortcut for INSTANCE_REF instance reference.
Definition: cnode_def.h:3419
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:3478
ConditionalType
Case/If type.
Definition: cnode.h:116
CNode * cGENVAR_REF(CGenvar *a0, Coord_t *loc=NULL)
Node construction shortcut for GENVAR_REF reference to a genvar.
Definition: cnode_def.h:3791
CNode * cMUL(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for MUL multiply.
Definition: cnode_def.h:2958
virtual INT32 GetWidth(void)
Evaluate packed width of declaration.
procedural assignment with left arithmetic shift
Definition: cnode_def.h:1690
double s2d(char *s)
Convert char string to double.
Definition: cnode.h:1093
if statement
Definition: cnode_def.h:1813
reference to variable
Definition: cnode_def.h:989
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:5573
CNode * cCVIR(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for CVIR convert integer to real.
Definition: cnode_def.h:4283
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:5647
CNode * cBLOCK_REF(CBlock *a0, CNode *a1, bool a2, Coord_t *loc=NULL)
Node construction shortcut for BLOCK_REF statement block.
Definition: cnode_def.h:5244
CNode * Clone(CObstack *heap=stack)
Replicate tree.
Definition: cnode_def.h:9632
min/typ/max expression
Definition: cnode_def.h:1800
logical or
Definition: cnode_def.h:1334