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 
616 #ifdef DEFINE_ENUM
617 
620 enum NodeOp_t {
624  /*
625  * ERROR node
626  * Description: error node
627  * Number Of Arguments: 0
628  */
633  /*
634  * VCONSTANT node
635  * Description: vector constant
636  * Number Of Arguments: 1
637  * arg0: CVector* Pointer to vector
638  */
643  /*
644  * RCONSTANT node
645  * Description: real constant
646  * Number Of Arguments: 1
647  * arg0: char* Pointer to string
648  */
653  /*
654  * COMMENT node
655  * Description: comment
656  * Number Of Arguments: 1
657  * arg0: const char* Pointer to string
658  */
663  /*
664  * VRQ node
665  * Description: vrq comment
666  * Number Of Arguments: 1
667  * arg0: const char* Pointer to string
668  */
673  /*
674  * PRAGMA node
675  * Description: program pragma
676  * Number Of Arguments: 1
677  * arg0: const char* Pointer to string
678  */
683  /*
684  * ELIST node
685  * Description: expression list
686  * Number Of Arguments: 2
687  * arg0: CNode* expression1
688  * arg1: CNode* expression2
689  */
694  /*
695  * WIDTH node
696  * Description: expression width change
697  * Number Of Arguments: 2
698  * arg0: CNode* width expression
699  * arg1: CNode* expression
700  */
705  /*
706  * NOP node
707  * Description: no operation
708  * Number Of Arguments: 0
709  */
714  /*
715  * SUB node
716  * Description: subtract
717  * Number Of Arguments: 2
718  * arg0: CNode* expression 1
719  * arg1: CNode* expression 2
720  */
725  /*
726  * MUL node
727  * Description: multiply
728  * Number Of Arguments: 2
729  * arg0: CNode* expression 1
730  * arg1: CNode* expression 2
731  */
736  /*
737  * DIV node
738  * Description: divide
739  * Number Of Arguments: 2
740  * arg0: CNode* expression 1
741  * arg1: CNode* expression 2
742  */
747  /*
748  * POW node
749  * Description: exponent
750  * Number Of Arguments: 2
751  * arg0: CNode* expression 1
752  * arg1: CNode* expression 2
753  */
758  /*
759  * ADD node
760  * Description: addition
761  * Number Of Arguments: 2
762  * arg0: CNode* expression 1
763  * arg1: CNode* expression 2
764  */
769  /*
770  * LSH node
771  * Description: logical left shift
772  * Number Of Arguments: 2
773  * arg0: CNode* expression 1
774  * arg1: CNode* expression 2
775  */
780  /*
781  * RSH node
782  * Description: logical right shift
783  * Number Of Arguments: 2
784  * arg0: CNode* expression 1
785  * arg1: CNode* expression 2
786  */
791  /*
792  * LSHA node
793  * Description: arithmetic left shift
794  * Number Of Arguments: 2
795  * arg0: CNode* expression 1
796  * arg1: CNode* expression 2
797  */
802  /*
803  * RSHA node
804  * Description: arithmetic right shift
805  * Number Of Arguments: 2
806  * arg0: CNode* expression 1
807  * arg1: CNode* expression 2
808  */
813  /*
814  * MOD node
815  * Description: modulus
816  * Number Of Arguments: 2
817  * arg0: CNode* expression 1
818  * arg1: CNode* expression 2
819  */
824  /*
825  * OR node
826  * Description: bitwise or
827  * Number Of Arguments: 2
828  * arg0: CNode* expression 1
829  * arg1: CNode* expression 2
830  */
835  /*
836  * AND node
837  * Description: bitwise and
838  * Number Of Arguments: 2
839  * arg0: CNode* expression 1
840  * arg1: CNode* expression 2
841  */
846  /*
847  * ANDANDAND node
848  * Description: triple and
849  * Number Of Arguments: 2
850  * arg0: CNode* expression 1
851  * arg1: CNode* expression 2
852  */
857  /*
858  * XOR node
859  * Description: bitwise xor
860  * Number Of Arguments: 2
861  * arg0: CNode* expression 1
862  * arg1: CNode* expression 2
863  */
868  /*
869  * XNOR node
870  * Description: bitwise xnor
871  * Number Of Arguments: 2
872  * arg0: CNode* expression 1
873  * arg1: CNode* expression 2
874  */
879  /*
880  * INSTANCE_REF node
881  * Description: instance reference
882  * Number Of Arguments: 1
883  * arg0: CInstance* Pointer to a instance
884  */
889  /*
890  * GATE_REF node
891  * Description: gate instance
892  * Number Of Arguments: 1
893  * arg0: CGate* Pointer to a gate
894  */
899  /*
900  * TASK_ENABLE node
901  * Description: call to a task
902  * Number Of Arguments: 2
903  * arg0: CSymbol* Pointer to symbol for task to call
904  * arg1: CNode* Argument expression list
905  */
910  /*
911  * SYSTASK_CALL node
912  * Description: call to enable a systask
913  * Number Of Arguments: 2
914  * arg0: CSymbol* Pointer to symbol for systask to call
915  * arg1: CNode* Argument expression list
916  */
921  /*
922  * TIMING_CALL node
923  * Description: call to a timing task
924  * Number Of Arguments: 2
925  * arg0: CSymbol* Pointer to symbol of timing task
926  * arg1: CNode* Argument expression list
927  */
932  /*
933  * FUNCTION_CALL node
934  * Description: call to a function
935  * Number Of Arguments: 3
936  * arg0: CSymbol* Pointer to symbol of the function
937  * arg1: CNode* Argument expression list
938  * arg2: CScope* Scope containing expression
939  */
944  /*
945  * ARRAY node
946  * Description: dimensioned reference (array/bit select)
947  * Number Of Arguments: 2
948  * arg0: CNode* Reference to variable
949  * arg1: CNode* List of index expressions
950  */
955  /*
956  * NET_REF node
957  * Description: reference to net
958  * Number Of Arguments: 1
959  * arg0: CNet* Pointer to net
960  */
965  /*
966  * VAR_REF node
967  * Description: reference to variable
968  * Number Of Arguments: 1
969  * arg0: CVar* Pointer to variable
970  */
975  /*
976  * PARAM_REF node
977  * Description: reference to parameter
978  * Number Of Arguments: 1
979  * arg0: CParam* Pointer to parameter
980  */
985  /*
986  * PORT_REF node
987  * Description: reference to port
988  * Number Of Arguments: 1
989  * arg0: CPortDir* Pointer to port
990  */
995  /*
996  * FWD_REF node
997  * Description: reference to a forward declared variable
998  * Number Of Arguments: 1
999  * arg0: CFref* Pointer to forward declared variable
1000  */
1005  /*
1006  * GENVAR_REF node
1007  * Description: reference to a genvar
1008  * Number Of Arguments: 1
1009  * arg0: CGenvar* Pointer to a genvar
1010  */
1015  /*
1016  * ENUM_REF node
1017  * Description: reference to a enum
1018  * Number Of Arguments: 1
1019  * arg0: CEnum* Pointer to a enum
1020  */
1025  /*
1026  * TYPE_REF node
1027  * Description: reference to a type
1028  * Number Of Arguments: 1
1029  * arg0: CTypedef* Pointer to a typedef
1030  */
1035  /*
1036  * NET_DECL node
1037  * Description: net declaration
1038  * Number Of Arguments: 2
1039  * arg0: CNet* Pointer to a net
1040  * arg1: CNode* continous assignment (optional)
1041  */
1046  /*
1047  * VAR_DECL node
1048  * Description: variable declaration
1049  * Number Of Arguments: 2
1050  * arg0: CVar* Pointer to a variable
1051  * arg1: CNode* procedural assignment (optional)
1052  */
1057  /*
1058  * PARAM_DECL node
1059  * Description: parameter declaration
1060  * Number Of Arguments: 1
1061  * arg0: CParam* Pointer to a parameter
1062  */
1067  /*
1068  * SPECPARAM_DECL node
1069  * Description: specify parameter declaration
1070  * Number Of Arguments: 1
1071  * arg0: CParam* Pointer to a specify parameter
1072  */
1077  /*
1078  * PORT_DECL node
1079  * Description: port declaration
1080  * Number Of Arguments: 1
1081  * arg0: CPortDir* Pointer to a port
1082  */
1087  /*
1088  * GENVAR_DECL node
1089  * Description: genvar declaration
1090  * Number Of Arguments: 1
1091  * arg0: CGenvar* Pointer to a genvar
1092  */
1097  /*
1098  * TYPEDEF_DECL node
1099  * Description: type declaration
1100  * Number Of Arguments: 1
1101  * arg0: CTypedef* Pointer to a typedef
1102  */
1107  /*
1108  * LIST node
1109  * Description: list of nodes
1110  * Number Of Arguments: 2
1111  * arg0: CNode* node 1
1112  * arg1: CNode* node 2
1113  */
1118  /*
1119  * RANGE node
1120  * Description: vector decl range specification
1121  * Number Of Arguments: 2
1122  * arg0: CNode* msb expression, if lsb is null range is msb-1:0
1123  * arg1: CNode* lsb expression, if NULL range is msb-1:0
1124  */
1129  /*
1130  * SLICE node
1131  * Description: vector subrange
1132  * Number Of Arguments: 2
1133  * arg0: CNode* msb expression
1134  * arg1: CNode* lsb expression
1135  */
1140  /*
1141  * PSLICE node
1142  * Description: vector subrange with ascending index select
1143  * Number Of Arguments: 2
1144  * arg0: CNode* index expression
1145  * arg1: CNode* width expression
1146  */
1151  /*
1152  * MSLICE node
1153  * Description: vector subrange with descending index select
1154  * Number Of Arguments: 2
1155  * arg0: CNode* index expression
1156  * arg1: CNode* width expression
1157  */
1162  /*
1163  * CVRI node
1164  * Description: convert real to integer
1165  * Number Of Arguments: 1
1166  * arg0: CNode* expression
1167  */
1172  /*
1173  * CVIR node
1174  * Description: convert integer to real
1175  * Number Of Arguments: 1
1176  * arg0: CNode* expression
1177  */
1182  /*
1183  * REP node
1184  * Description: replication operator
1185  * Number Of Arguments: 2
1186  * arg0: CNode* replication expression
1187  * arg1: CNode* expression to replicate
1188  */
1193  /*
1194  * CAT node
1195  * Description: concatenation operator
1196  * Number Of Arguments: 2
1197  * arg0: CNode* expression 1
1198  * arg1: CNode* expression 2
1199  */
1204  /*
1205  * UCAT node
1206  * Description: unary concat
1207  * Number Of Arguments: 1
1208  * arg0: CNode* expression
1209  */
1214  /*
1215  * COM node
1216  * Description: bitwise complement
1217  * Number Of Arguments: 1
1218  * arg0: CNode* expression
1219  */
1224  /*
1225  * NEG node
1226  * Description: negation
1227  * Number Of Arguments: 1
1228  * arg0: CNode* expression
1229  */
1234  /*
1235  * PLUS node
1236  * Description: unary plus
1237  * Number Of Arguments: 1
1238  * arg0: CNode* expression
1239  */
1244  /*
1245  * NOT node
1246  * Description: logical complement
1247  * Number Of Arguments: 1
1248  * arg0: CNode* expression
1249  */
1254  /*
1255  * GT node
1256  * Description: greater than
1257  * Number Of Arguments: 2
1258  * arg0: CNode* expression 1
1259  * arg1: CNode* expression 2
1260  */
1265  /*
1266  * GE node
1267  * Description: greater than or equal
1268  * Number Of Arguments: 2
1269  * arg0: CNode* expression 1
1270  * arg1: CNode* expression 2
1271  */
1276  /*
1277  * LT node
1278  * Description: less than
1279  * Number Of Arguments: 2
1280  * arg0: CNode* expression 1
1281  * arg1: CNode* expression 2
1282  */
1287  /*
1288  * LE node
1289  * Description: less than or equal
1290  * Number Of Arguments: 2
1291  * arg0: CNode* expression 1
1292  * arg1: CNode* expression 2
1293  */
1298  /*
1299  * LAND node
1300  * Description: logical and
1301  * Number Of Arguments: 2
1302  * arg0: CNode* expression 1
1303  * arg1: CNode* expression 2
1304  */
1309  /*
1310  * LOR node
1311  * Description: logical or
1312  * Number Of Arguments: 2
1313  * arg0: CNode* expression 1
1314  * arg1: CNode* expression 2
1315  */
1320  /*
1321  * CEQ node
1322  * Description: case equal
1323  * Number Of Arguments: 2
1324  * arg0: CNode* expression 1
1325  * arg1: CNode* expression 2
1326  */
1331  /*
1332  * CNE node
1333  * Description: case not equal
1334  * Number Of Arguments: 2
1335  * arg0: CNode* expression 1
1336  * arg1: CNode* expression 2
1337  */
1342  /*
1343  * EQ node
1344  * Description: equal
1345  * Number Of Arguments: 2
1346  * arg0: CNode* expression 1
1347  * arg1: CNode* expression 2
1348  */
1353  /*
1354  * NE node
1355  * Description: not equal
1356  * Number Of Arguments: 2
1357  * arg0: CNode* expression 1
1358  * arg1: CNode* expression 2
1359  */
1364  /*
1365  * RAND node
1366  * Description: reduction and
1367  * Number Of Arguments: 1
1368  * arg0: CNode* expression
1369  */
1374  /*
1375  * RNAND node
1376  * Description: reduction nand
1377  * Number Of Arguments: 1
1378  * arg0: CNode* expression
1379  */
1384  /*
1385  * ROR node
1386  * Description: reduction or
1387  * Number Of Arguments: 1
1388  * arg0: CNode* expression
1389  */
1394  /*
1395  * RNOR node
1396  * Description: reduction nor
1397  * Number Of Arguments: 1
1398  * arg0: CNode* expression
1399  */
1404  /*
1405  * RXOR node
1406  * Description: reduction xor
1407  * Number Of Arguments: 1
1408  * arg0: CNode* expression
1409  */
1414  /*
1415  * RXNOR node
1416  * Description: reduction xnor
1417  * Number Of Arguments: 1
1418  * arg0: CNode* expression
1419  */
1424  /*
1425  * HOOK node
1426  * Description: condition expression operator
1427  * Number Of Arguments: 3
1428  * arg0: CNode* condition expression
1429  * arg1: CNode* true expression
1430  * arg2: CNode* false expression
1431  */
1436  /*
1437  * INIT node
1438  * Description: initial block
1439  * Number Of Arguments: 1
1440  * arg0: CNode*
1441  */
1446  /*
1447  * ALWAYS node
1448  * Description: always block
1449  * Number Of Arguments: 1
1450  * arg0: CNode*
1451  */
1456  /*
1457  * ALWAYS_LATCH node
1458  * Description: always latch block
1459  * Number Of Arguments: 1
1460  * arg0: CNode*
1461  */
1466  /*
1467  * ALWAYS_FF node
1468  * Description: always flip-flop block
1469  * Number Of Arguments: 1
1470  * arg0: CNode*
1471  */
1476  /*
1477  * ALWAYS_COMB node
1478  * Description: always combinational logic block
1479  * Number Of Arguments: 1
1480  * arg0: CNode*
1481  */
1486  /*
1487  * EVENT node
1488  * Description: event statement
1489  * Number Of Arguments: 2
1490  * arg0: CNode* event expression (NULL for @*)
1491  * arg1: CNode* statement
1492  */
1497  /*
1498  * BLOCK_REF node
1499  * Description: statement block
1500  * Number Of Arguments: 2
1501  * arg0: CBlock* pointer to block
1502  * arg1: CNode* list of statements
1503  */
1508  /*
1509  * SPECIFY_REF node
1510  * Description: specify block
1511  * Number Of Arguments: 2
1512  * arg0: CSpecify* pointer to specify structure
1513  * arg1: CNode* list of statements
1514  */
1519  /*
1520  * ASSIGN node
1521  * Description: procedural assignment
1522  * Number Of Arguments: 3
1523  * arg0: CNode* event expression
1524  * arg1: CNode* lval
1525  * arg2: CNode* rval
1526  */
1531  /*
1532  * ADD_ASSIGN node
1533  * Description: procedural assignment with add
1534  * Number Of Arguments: 3
1535  * arg0: CNode* event expression
1536  * arg1: CNode* lval
1537  * arg2: CNode* rval
1538  */
1543  /*
1544  * SUB_ASSIGN node
1545  * Description: procedural assignment with subtract
1546  * Number Of Arguments: 3
1547  * arg0: CNode* event expression
1548  * arg1: CNode* lval
1549  * arg2: CNode* rval
1550  */
1555  /*
1556  * MUL_ASSIGN node
1557  * Description: procedural assignment with mul
1558  * Number Of Arguments: 3
1559  * arg0: CNode* event expression
1560  * arg1: CNode* lval
1561  * arg2: CNode* rval
1562  */
1567  /*
1568  * DIV_ASSIGN node
1569  * Description: procedural assignment with div
1570  * Number Of Arguments: 3
1571  * arg0: CNode* event expression
1572  * arg1: CNode* lval
1573  * arg2: CNode* rval
1574  */
1579  /*
1580  * MOD_ASSIGN node
1581  * Description: procedural assignment with mod
1582  * Number Of Arguments: 3
1583  * arg0: CNode* event expression
1584  * arg1: CNode* lval
1585  * arg2: CNode* rval
1586  */
1591  /*
1592  * AND_ASSIGN node
1593  * Description: procedural assignment with bitwise and
1594  * Number Of Arguments: 3
1595  * arg0: CNode* event expression
1596  * arg1: CNode* lval
1597  * arg2: CNode* rval
1598  */
1603  /*
1604  * OR_ASSIGN node
1605  * Description: procedural assignment with bitwise or
1606  * Number Of Arguments: 3
1607  * arg0: CNode* event expression
1608  * arg1: CNode* lval
1609  * arg2: CNode* rval
1610  */
1615  /*
1616  * XOR_ASSIGN node
1617  * Description: procedural assignment with bitwise xor
1618  * Number Of Arguments: 3
1619  * arg0: CNode* event expression
1620  * arg1: CNode* lval
1621  * arg2: CNode* rval
1622  */
1627  /*
1628  * LSH_ASSIGN node
1629  * Description: procedural assignment with left shift
1630  * Number Of Arguments: 3
1631  * arg0: CNode* event expression
1632  * arg1: CNode* lval
1633  * arg2: CNode* rval
1634  */
1639  /*
1640  * RSH_ASSIGN node
1641  * Description: procedural assignment with right shift
1642  * Number Of Arguments: 3
1643  * arg0: CNode* event expression
1644  * arg1: CNode* lval
1645  * arg2: CNode* rval
1646  */
1651  /*
1652  * LSHA_ASSIGN node
1653  * Description: procedural assignment with left arithmetic shift
1654  * Number Of Arguments: 3
1655  * arg0: CNode* event expression
1656  * arg1: CNode* lval
1657  * arg2: CNode* rval
1658  */
1663  /*
1664  * RSHA_ASSIGN node
1665  * Description: procedural assignment with right arithmetic shift
1666  * Number Of Arguments: 3
1667  * arg0: CNode* event expression
1668  * arg1: CNode* lval
1669  * arg2: CNode* rval
1670  */
1675  /*
1676  * FORCE node
1677  * Description: force statement
1678  * Number Of Arguments: 2
1679  * arg0: CNode* lval
1680  * arg1: CNode* expression
1681  */
1686  /*
1687  * RELEASE node
1688  * Description: release statement
1689  * Number Of Arguments: 1
1690  * arg0: CNode* lval
1691  */
1696  /*
1697  * NBASSIGN node
1698  * Description: nonblocking assignment
1699  * Number Of Arguments: 3
1700  * arg0: CNode* event expression
1701  * arg1: CNode* lval
1702  * arg2: CNode* rval
1703  */
1708  /*
1709  * POSEDGE node
1710  * Description: positive event qualifier
1711  * Number Of Arguments: 1
1712  * arg0: CNode* expression
1713  */
1718  /*
1719  * NEGEDGE node
1720  * Description: negative event qualifier
1721  * Number Of Arguments: 1
1722  * arg0: CNode* expression
1723  */
1728  /*
1729  * EDGE node
1730  * Description: edge qualifier
1731  * Number Of Arguments: 2
1732  * arg0: CNode*
1733  * arg1: Edge_t edge specification
1734  */
1739  /*
1740  * EVOR node
1741  * Description: event or
1742  * Number Of Arguments: 2
1743  * arg0: CNode* expression 1
1744  * arg1: CNode* expression 2
1745  */
1750  /*
1751  * DELAY node
1752  * Description: delay statement
1753  * Number Of Arguments: 2
1754  * arg0: CNode* delay expression
1755  * arg1: CNode* statements
1756  */
1761  /*
1762  * MTM node
1763  * Description: min/typ/max expression
1764  * Number Of Arguments: 3
1765  * arg0: CNode* minimum expression
1766  * arg1: CNode* typical expression
1767  * arg2: CNode* maximum expression
1768  */
1773  /*
1774  * IF node
1775  * Description: if statement
1776  * Number Of Arguments: 3
1777  * arg0: CNode* condition
1778  * arg1: CNode* true statements
1779  * arg2: CNode* false statements
1780  */
1785  /*
1786  * FOREVER node
1787  * Description: forever statement
1788  * Number Of Arguments: 1
1789  * arg0: CNode* statements
1790  */
1795  /*
1796  * REPEAT node
1797  * Description: repeat statement
1798  * Number Of Arguments: 2
1799  * arg0: CNode* condition
1800  * arg1: CNode* statements
1801  */
1806  /*
1807  * WHILE node
1808  * Description: while statement
1809  * Number Of Arguments: 2
1810  * arg0: CNode* condition
1811  * arg1: CNode* statements
1812  */
1817  /*
1818  * WAIT node
1819  * Description: wait statement
1820  * Number Of Arguments: 2
1821  * arg0: CNode* condition
1822  * arg1: CNode* statements
1823  */
1828  /*
1829  * FOR node
1830  * Description: for statement
1831  * Number Of Arguments: 4
1832  * arg0: CNode* initial statement
1833  * arg1: CNode* condition
1834  * arg2: CNode* assignment statement
1835  * arg3: CNode* statements
1836  */
1841  /*
1842  * CASE node
1843  * Description: case statement
1844  * Number Of Arguments: 2
1845  * arg0: CNode* condition
1846  * arg1: CNode* list of case items
1847  */
1852  /*
1853  * CASEX node
1854  * Description: casex statement
1855  * Number Of Arguments: 2
1856  * arg0: CNode* condition
1857  * arg1: CNode* list of case items
1858  */
1863  /*
1864  * CASEZ node
1865  * Description: casez statement
1866  * Number Of Arguments: 2
1867  * arg0: CNode* condition
1868  * arg1: CNode* list of case items
1869  */
1874  /*
1875  * CASEITEM node
1876  * Description: case item
1877  * Number Of Arguments: 2
1878  * arg0: CNode* list of expressions (NULL for default)
1879  * arg1: CNode* statement
1880  */
1885  /*
1886  * CASSIGN node
1887  * Description: continious assignment
1888  * Number Of Arguments: 4
1889  * arg0: StrengthPair_t* assignment strength
1890  * arg1: CNode* delay expression
1891  * arg2: CNode* lval
1892  * arg3: CNode* rval expression
1893  */
1898  /*
1899  * ARG node
1900  * Description: port connection
1901  * Number Of Arguments: 2
1902  * arg0: CSymbol* port name
1903  * arg1: CNode* port expression
1904  */
1909  /*
1910  * IMPORT node
1911  * Description: import item
1912  * Number Of Arguments: 1
1913  * arg0: CSymbol* package::symbol or package(for wildcard)
1914  */
1919  /*
1920  * FUNCTION_DEF node
1921  * Description: function definition
1922  * Number Of Arguments: 1
1923  * arg0: CFunction*
1924  */
1929  /*
1930  * MODULE_DEF node
1931  * Description: module definition
1932  * Number Of Arguments: 1
1933  * arg0: CModule*
1934  */
1939  /*
1940  * PACKAGE_DEF node
1941  * Description: package definition
1942  * Number Of Arguments: 1
1943  * arg0: CPackage*
1944  */
1949  /*
1950  * REPEAT_CONTROL node
1951  * Description: repeat control
1952  * Number Of Arguments: 2
1953  * arg0: CNode* expression
1954  * arg1: CNode* event control
1955  */
1960  /*
1961  * DELAY_CONTROL node
1962  * Description: delay control
1963  * Number Of Arguments: 1
1964  * arg0: CNode* expression
1965  */
1970  /*
1971  * EVENT_CONTROL node
1972  * Description: event control
1973  * Number Of Arguments: 1
1974  * arg0: CNode* event expression (NULL for @*)
1975  */
1980  /*
1981  * EXTERNAL_REF node
1982  * Description: external reference
1983  * Number Of Arguments: 1
1984  * arg0: CSymbol* pointer to symbol
1985  */
1990  /*
1991  * PORT_DEF node
1992  * Description: port definition
1993  * Number Of Arguments: 1
1994  * arg0: CPort* pointer to port
1995  */
2000  /*
2001  * DEFPARAM node
2002  * Description: defparam statement
2003  * Number Of Arguments: 2
2004  * arg0: CNode* external reference
2005  * arg1: CNode* expression
2006  */
2011  /*
2012  * PATH node
2013  * Description: path statement
2014  * Number Of Arguments: 7
2015  * arg0: int
2016  * arg1: CNode* edge int[-1,0,1]
2017  * arg2: int Input list
2018  * arg3: int Left polarity int[-1,0,1]
2019  * arg4: CNode* Operation type int [0 = *>, 1 = =>]
2020  * arg5: int Output list
2021  * arg6: CNode* Right polarity int[-1,0,1]
2022  */
2027  /*
2028  * PATH_ASSIGN node
2029  * Description: path assignment statement
2030  * Number Of Arguments: 3
2031  * arg0: CNode* condition
2032  * arg1: CNode* path
2033  * arg2: CNode* expression
2034  */
2039  /*
2040  * IFNONE_PATH_ASSIGN node
2041  * Description: ifnone path assignment statement
2042  * Number Of Arguments: 2
2043  * arg0: CNode* path
2044  * arg1: CNode* expression
2045  */
2050  /*
2051  * TRIGGER node
2052  * Description: event trigger
2053  * Number Of Arguments: 1
2054  * arg0: CNode* event reference
2055  */
2060  /*
2061  * PASSIGN node
2062  * Description: procedural assignment
2063  * Number Of Arguments: 2
2064  * arg0: CNode* lval
2065  * arg1: CNode* expression
2066  */
2071  /*
2072  * DEASSIGN node
2073  * Description: deassign statement
2074  * Number Of Arguments: 1
2075  * arg0: CNode* lval
2076  */
2081  /*
2082  * DISABLE node
2083  * Description: disable statement
2084  * Number Of Arguments: 1
2085  * arg0: CSymbol* pointer to symbol
2086  */
2091  /*
2092  * ATTRIBUTE node
2093  * Description: attribute specification
2094  * Number Of Arguments: 1
2095  * arg0: CAttr* pointer to attribute
2096  */
2101  /*
2102  * GIF node
2103  * Description: structural if statement
2104  * Number Of Arguments: 3
2105  * arg0: CNode* condition
2106  * arg1: CNode* true statement
2107  * arg2: CNode* false statement
2108  */
2113  /*
2114  * GFOR node
2115  * Description: structural for statement
2116  * Number Of Arguments: 4
2117  * arg0: CNode* initial statement
2118  * arg1: CNode* condition
2119  * arg2: CNode* assignment statement
2120  * arg3: CNode* statement
2121  */
2126  /*
2127  * GCASE node
2128  * Description: structural case statement
2129  * Number Of Arguments: 2
2130  * arg0: CNode* condition
2131  * arg1: CNode* list of case items
2132  */
2137  /*
2138  * TABLE node
2139  * Description: udp table
2140  * Number Of Arguments: 1
2141  * arg0: CNode* list of table entries
2142  */
2147  /*
2148  * TABLE_ENTRY node
2149  * Description: udp table entry
2150  * Number Of Arguments: 1
2151  * arg0: CNode* list of table symbols
2152  */
2157  /*
2158  * TABLE_SYMBOL node
2159  * Description: udp table symbol
2160  * Number Of Arguments: 1
2161  * arg0: char* string of udp characters
2162  */
2167  /*
2168  * PORTLIST_END node
2169  * Description: sentinal at end of port list
2170  * Number Of Arguments: 0
2171  */
2176  /*
2177  * MACRO_EXPR node
2178  * Description: expression represented by a macro
2179  * Number Of Arguments: 2
2180  * arg0: const char* alternate expression, may be NULL
2181  * arg1: CNode*
2182  */
2187  /*
2188  * ENUM_SPEC node
2189  * Description: enum specification
2190  * Number Of Arguments: 3
2191  * arg0: CSymbol* Pointer to enum base symbol
2192  * arg1: CNode* range expression
2193  * arg2: CNode* starting expression value
2194  */
2199  /*
2200  * MEMBER node
2201  * Description: member reference (structure, class or external
2202  * Number Of Arguments: 2
2203  * arg0: CNode* Reference to variable
2204  * arg1: CSymbol* member symbol
2205  */
2210  /*
2211  * RETURN node
2212  * Description: return
2213  * Number Of Arguments: 1
2214  * arg0: CNode*
2215  */
2220  /*
2221  * PREINC node
2222  * Description: preincrement
2223  * Number Of Arguments: 1
2224  * arg0: CNode* expression
2225  */
2230  /*
2231  * POSTINC node
2232  * Description: postincrement
2233  * Number Of Arguments: 1
2234  * arg0: CNode* expression
2235  */
2240  /*
2241  * PREDEC node
2242  * Description: predecrement
2243  * Number Of Arguments: 1
2244  * arg0: CNode* expression
2245  */
2250  /*
2251  * POSTDEC node
2252  * Description: postdecrement
2253  * Number Of Arguments: 1
2254  * arg0: CNode* expression
2255  */
2260  /*
2261  * CAST node
2262  * Description: data type change
2263  * Number Of Arguments: 2
2264  * arg0: CNode* type reference or width expression
2265  * arg1: CNode* expression
2266  */
2268 };
2269 extern const char* nodeOpName[];
2270 extern const char* nodeOpDescription[];
2271 #endif // DEFINE_ENUM
2272 #ifdef DEFINE_METHODS
2273 const char* nodeOpName[] = {
2274  "ERROR",
2275  "VCONSTANT",
2276  "RCONSTANT",
2277  "COMMENT",
2278  "VRQ",
2279  "PRAGMA",
2280  "ELIST",
2281  "WIDTH",
2282  "NOP",
2283  "SUB",
2284  "MUL",
2285  "DIV",
2286  "POW",
2287  "ADD",
2288  "LSH",
2289  "RSH",
2290  "LSHA",
2291  "RSHA",
2292  "MOD",
2293  "OR",
2294  "AND",
2295  "ANDANDAND",
2296  "XOR",
2297  "XNOR",
2298  "INSTANCE_REF",
2299  "GATE_REF",
2300  "TASK_ENABLE",
2301  "SYSTASK_CALL",
2302  "TIMING_CALL",
2303  "FUNCTION_CALL",
2304  "ARRAY",
2305  "NET_REF",
2306  "VAR_REF",
2307  "PARAM_REF",
2308  "PORT_REF",
2309  "FWD_REF",
2310  "GENVAR_REF",
2311  "ENUM_REF",
2312  "TYPE_REF",
2313  "NET_DECL",
2314  "VAR_DECL",
2315  "PARAM_DECL",
2316  "SPECPARAM_DECL",
2317  "PORT_DECL",
2318  "GENVAR_DECL",
2319  "TYPEDEF_DECL",
2320  "LIST",
2321  "RANGE",
2322  "SLICE",
2323  "PSLICE",
2324  "MSLICE",
2325  "CVRI",
2326  "CVIR",
2327  "REP",
2328  "CAT",
2329  "UCAT",
2330  "COM",
2331  "NEG",
2332  "PLUS",
2333  "NOT",
2334  "GT",
2335  "GE",
2336  "LT",
2337  "LE",
2338  "LAND",
2339  "LOR",
2340  "CEQ",
2341  "CNE",
2342  "EQ",
2343  "NE",
2344  "RAND",
2345  "RNAND",
2346  "ROR",
2347  "RNOR",
2348  "RXOR",
2349  "RXNOR",
2350  "HOOK",
2351  "INIT",
2352  "ALWAYS",
2353  "ALWAYS_LATCH",
2354  "ALWAYS_FF",
2355  "ALWAYS_COMB",
2356  "EVENT",
2357  "BLOCK_REF",
2358  "SPECIFY_REF",
2359  "ASSIGN",
2360  "ADD_ASSIGN",
2361  "SUB_ASSIGN",
2362  "MUL_ASSIGN",
2363  "DIV_ASSIGN",
2364  "MOD_ASSIGN",
2365  "AND_ASSIGN",
2366  "OR_ASSIGN",
2367  "XOR_ASSIGN",
2368  "LSH_ASSIGN",
2369  "RSH_ASSIGN",
2370  "LSHA_ASSIGN",
2371  "RSHA_ASSIGN",
2372  "FORCE",
2373  "RELEASE",
2374  "NBASSIGN",
2375  "POSEDGE",
2376  "NEGEDGE",
2377  "EDGE",
2378  "EVOR",
2379  "DELAY",
2380  "MTM",
2381  "IF",
2382  "FOREVER",
2383  "REPEAT",
2384  "WHILE",
2385  "WAIT",
2386  "FOR",
2387  "CASE",
2388  "CASEX",
2389  "CASEZ",
2390  "CASEITEM",
2391  "CASSIGN",
2392  "ARG",
2393  "IMPORT",
2394  "FUNCTION_DEF",
2395  "MODULE_DEF",
2396  "PACKAGE_DEF",
2397  "REPEAT_CONTROL",
2398  "DELAY_CONTROL",
2399  "EVENT_CONTROL",
2400  "EXTERNAL_REF",
2401  "PORT_DEF",
2402  "DEFPARAM",
2403  "PATH",
2404  "PATH_ASSIGN",
2405  "IFNONE_PATH_ASSIGN",
2406  "TRIGGER",
2407  "PASSIGN",
2408  "DEASSIGN",
2409  "DISABLE",
2410  "ATTRIBUTE",
2411  "GIF",
2412  "GFOR",
2413  "GCASE",
2414  "TABLE",
2415  "TABLE_ENTRY",
2416  "TABLE_SYMBOL",
2417  "PORTLIST_END",
2418  "MACRO_EXPR",
2419  "ENUM_SPEC",
2420  "MEMBER",
2421  "RETURN",
2422  "PREINC",
2423  "POSTINC",
2424  "PREDEC",
2425  "POSTDEC",
2426  "CAST",
2427 NULL
2428 };
2429 const char* nodeOpDescription[] = {
2430  "error node",
2431  "vector constant",
2432  "real constant",
2433  "comment",
2434  "vrq comment",
2435  "program pragma",
2436  "expression list",
2437  "expression width change",
2438  "no operation",
2439  "subtract",
2440  "multiply",
2441  "divide",
2442  "exponent",
2443  "addition",
2444  "logical left shift",
2445  "logical right shift",
2446  "arithmetic left shift",
2447  "arithmetic right shift",
2448  "modulus",
2449  "bitwise or",
2450  "bitwise and",
2451  "triple and",
2452  "bitwise xor",
2453  "bitwise xnor",
2454  "instance reference",
2455  "gate instance",
2456  "call to a task",
2457  "call to enable a systask",
2458  "call to a timing task",
2459  "call to a function",
2460  "dimensioned reference (array/bit select)",
2461  "reference to net",
2462  "reference to variable",
2463  "reference to parameter",
2464  "reference to port",
2465  "reference to a forward declared variable",
2466  "reference to a genvar",
2467  "reference to a enum",
2468  "reference to a type",
2469  "net declaration",
2470  "variable declaration",
2471  "parameter declaration",
2472  "specify parameter declaration",
2473  "port declaration",
2474  "genvar declaration",
2475  "type declaration",
2476  "list of nodes",
2477  "vector decl range specification",
2478  "vector subrange",
2479  "vector subrange with ascending index select",
2480  "vector subrange with descending index select",
2481  "convert real to integer",
2482  "convert integer to real",
2483  "replication operator",
2484  "concatenation operator",
2485  "unary concat",
2486  "bitwise complement",
2487  "negation",
2488  "unary plus",
2489  "logical complement",
2490  "greater than",
2491  "greater than or equal",
2492  "less than",
2493  "less than or equal",
2494  "logical and",
2495  "logical or",
2496  "case equal",
2497  "case not equal",
2498  "equal",
2499  "not equal",
2500  "reduction and",
2501  "reduction nand",
2502  "reduction or",
2503  "reduction nor",
2504  "reduction xor",
2505  "reduction xnor",
2506  "condition expression operator",
2507  "initial block",
2508  "always block",
2509  "always latch block",
2510  "always flip-flop block",
2511  "always combinational logic block",
2512  "event statement",
2513  "statement block",
2514  "specify block",
2515  "procedural assignment",
2516  "procedural assignment with add",
2517  "procedural assignment with subtract",
2518  "procedural assignment with mul",
2519  "procedural assignment with div",
2520  "procedural assignment with mod",
2521  "procedural assignment with bitwise and",
2522  "procedural assignment with bitwise or",
2523  "procedural assignment with bitwise xor",
2524  "procedural assignment with left shift",
2525  "procedural assignment with right shift",
2526  "procedural assignment with left arithmetic shift",
2527  "procedural assignment with right arithmetic shift",
2528  "force statement",
2529  "release statement",
2530  "nonblocking assignment",
2531  "positive event qualifier",
2532  "negative event qualifier",
2533  "edge qualifier",
2534  "event or",
2535  "delay statement",
2536  "min/typ/max expression",
2537  "if statement",
2538  "forever statement",
2539  "repeat statement",
2540  "while statement",
2541  "wait statement",
2542  "for statement",
2543  "case statement",
2544  "casex statement",
2545  "casez statement",
2546  "case item",
2547  "continious assignment",
2548  "port connection",
2549  "import item",
2550  "function definition",
2551  "module definition",
2552  "package definition",
2553  "repeat control",
2554  "delay control",
2555  "event control",
2556  "external reference",
2557  "port definition",
2558  "defparam statement",
2559  "path statement",
2560  "path assignment statement",
2561  "ifnone path assignment statement",
2562  "event trigger",
2563  "procedural assignment",
2564  "deassign statement",
2565  "disable statement",
2566  "attribute specification",
2567  "structural if statement",
2568  "structural for statement",
2569  "structural case statement",
2570  "udp table",
2571  "udp table entry",
2572  "udp table symbol",
2573  "sentinal at end of port list",
2574  "expression represented by a macro",
2575  "enum specification",
2576  "member reference (structure, class or external",
2577  "return",
2578  "preincrement",
2579  "postincrement",
2580  "predecrement",
2581  "postdecrement",
2582  "data type change",
2583 NULL
2584 };
2585 #endif // DEFINE_METHODS
2586 
2587 
2588 #ifdef DEFINE_CONSTRUCTOR
2589 
2597 inline CNode* cERROR( Coord_t* loc=NULL )
2598 {
2599  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eERROR );
2600  return n;
2601 }
2610 inline CNode* cERROR( CObstack* heap, Coord_t* loc=NULL )
2611 {
2612  CNode* n = new(heap) CNode( loc, eERROR );
2613  return n;
2614 }
2623 inline CNode* cVCONSTANT( CVector* a0, Coord_t* loc=NULL )
2624 {
2625  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eVCONSTANT );
2626  n->Arg<CVector*>(0) = a0;
2627  return n;
2628 }
2638 inline CNode* cVCONSTANT( CObstack* heap, CVector* a0, Coord_t* loc=NULL )
2639 {
2640  CNode* n = new(heap) CNode( loc, eVCONSTANT );
2641  n->Arg<CVector*>(0) = a0;
2642  return n;
2643 }
2652 inline CNode* cRCONSTANT( char* a0, Coord_t* loc=NULL )
2653 {
2654  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRCONSTANT );
2655  n->Arg<char*>(0) = a0;
2656  return n;
2657 }
2667 inline CNode* cRCONSTANT( CObstack* heap, char* a0, Coord_t* loc=NULL )
2668 {
2669  CNode* n = new(heap) CNode( loc, eRCONSTANT );
2670  n->Arg<char*>(0) = a0;
2671  return n;
2672 }
2681 inline CNode* cCOMMENT( const char* a0, Coord_t* loc=NULL )
2682 {
2683  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCOMMENT );
2684  n->Arg<const char*>(0) = a0;
2685  return n;
2686 }
2696 inline CNode* cCOMMENT( CObstack* heap, const char* a0, Coord_t* loc=NULL )
2697 {
2698  CNode* n = new(heap) CNode( loc, eCOMMENT );
2699  n->Arg<const char*>(0) = a0;
2700  return n;
2701 }
2710 inline CNode* cVRQ( const char* a0, Coord_t* loc=NULL )
2711 {
2712  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eVRQ );
2713  n->Arg<const char*>(0) = a0;
2714  return n;
2715 }
2725 inline CNode* cVRQ( CObstack* heap, const char* a0, Coord_t* loc=NULL )
2726 {
2727  CNode* n = new(heap) CNode( loc, eVRQ );
2728  n->Arg<const char*>(0) = a0;
2729  return n;
2730 }
2739 inline CNode* cPRAGMA( const char* a0, Coord_t* loc=NULL )
2740 {
2741  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePRAGMA );
2742  n->Arg<const char*>(0) = a0;
2743  return n;
2744 }
2754 inline CNode* cPRAGMA( CObstack* heap, const char* a0, Coord_t* loc=NULL )
2755 {
2756  CNode* n = new(heap) CNode( loc, ePRAGMA );
2757  n->Arg<const char*>(0) = a0;
2758  return n;
2759 }
2769 inline CNode* cELIST( CNode* a0, CNode* a1, Coord_t* loc=NULL )
2770 {
2771  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eELIST );
2772  n->Arg<CNode*>(0) = a0;
2773  n->Arg<CNode*>(1) = a1;
2774  return n;
2775 }
2786 inline CNode* cELIST( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
2787 {
2788  CNode* n = new(heap) CNode( loc, eELIST );
2789  n->Arg<CNode*>(0) = a0;
2790  n->Arg<CNode*>(1) = a1;
2791  return n;
2792 }
2802 inline CNode* cWIDTH( CNode* a0, CNode* a1, Coord_t* loc=NULL )
2803 {
2804  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eWIDTH );
2805  n->Arg<CNode*>(0) = a0;
2806  n->Arg<CNode*>(1) = a1;
2807  return n;
2808 }
2819 inline CNode* cWIDTH( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
2820 {
2821  CNode* n = new(heap) CNode( loc, eWIDTH );
2822  n->Arg<CNode*>(0) = a0;
2823  n->Arg<CNode*>(1) = a1;
2824  return n;
2825 }
2833 inline CNode* cNOP( Coord_t* loc=NULL )
2834 {
2835  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eNOP );
2836  return n;
2837 }
2846 inline CNode* cNOP( CObstack* heap, Coord_t* loc=NULL )
2847 {
2848  CNode* n = new(heap) CNode( loc, eNOP );
2849  return n;
2850 }
2860 inline CNode* cSUB( CNode* a0, CNode* a1, Coord_t* loc=NULL )
2861 {
2862  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eSUB );
2863  n->Arg<CNode*>(0) = a0;
2864  n->Arg<CNode*>(1) = a1;
2865  return n;
2866 }
2877 inline CNode* cSUB( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
2878 {
2879  CNode* n = new(heap) CNode( loc, eSUB );
2880  n->Arg<CNode*>(0) = a0;
2881  n->Arg<CNode*>(1) = a1;
2882  return n;
2883 }
2893 inline CNode* cMUL( CNode* a0, CNode* a1, Coord_t* loc=NULL )
2894 {
2895  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eMUL );
2896  n->Arg<CNode*>(0) = a0;
2897  n->Arg<CNode*>(1) = a1;
2898  return n;
2899 }
2910 inline CNode* cMUL( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
2911 {
2912  CNode* n = new(heap) CNode( loc, eMUL );
2913  n->Arg<CNode*>(0) = a0;
2914  n->Arg<CNode*>(1) = a1;
2915  return n;
2916 }
2926 inline CNode* cDIV( CNode* a0, CNode* a1, Coord_t* loc=NULL )
2927 {
2928  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eDIV );
2929  n->Arg<CNode*>(0) = a0;
2930  n->Arg<CNode*>(1) = a1;
2931  return n;
2932 }
2943 inline CNode* cDIV( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
2944 {
2945  CNode* n = new(heap) CNode( loc, eDIV );
2946  n->Arg<CNode*>(0) = a0;
2947  n->Arg<CNode*>(1) = a1;
2948  return n;
2949 }
2959 inline CNode* cPOW( CNode* a0, CNode* a1, Coord_t* loc=NULL )
2960 {
2961  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePOW );
2962  n->Arg<CNode*>(0) = a0;
2963  n->Arg<CNode*>(1) = a1;
2964  return n;
2965 }
2976 inline CNode* cPOW( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
2977 {
2978  CNode* n = new(heap) CNode( loc, ePOW );
2979  n->Arg<CNode*>(0) = a0;
2980  n->Arg<CNode*>(1) = a1;
2981  return n;
2982 }
2992 inline CNode* cADD( CNode* a0, CNode* a1, Coord_t* loc=NULL )
2993 {
2994  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eADD );
2995  n->Arg<CNode*>(0) = a0;
2996  n->Arg<CNode*>(1) = a1;
2997  return n;
2998 }
3009 inline CNode* cADD( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
3010 {
3011  CNode* n = new(heap) CNode( loc, eADD );
3012  n->Arg<CNode*>(0) = a0;
3013  n->Arg<CNode*>(1) = a1;
3014  return n;
3015 }
3025 inline CNode* cLSH( CNode* a0, CNode* a1, Coord_t* loc=NULL )
3026 {
3027  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eLSH );
3028  n->Arg<CNode*>(0) = a0;
3029  n->Arg<CNode*>(1) = a1;
3030  return n;
3031 }
3042 inline CNode* cLSH( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
3043 {
3044  CNode* n = new(heap) CNode( loc, eLSH );
3045  n->Arg<CNode*>(0) = a0;
3046  n->Arg<CNode*>(1) = a1;
3047  return n;
3048 }
3058 inline CNode* cRSH( CNode* a0, CNode* a1, Coord_t* loc=NULL )
3059 {
3060  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRSH );
3061  n->Arg<CNode*>(0) = a0;
3062  n->Arg<CNode*>(1) = a1;
3063  return n;
3064 }
3075 inline CNode* cRSH( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
3076 {
3077  CNode* n = new(heap) CNode( loc, eRSH );
3078  n->Arg<CNode*>(0) = a0;
3079  n->Arg<CNode*>(1) = a1;
3080  return n;
3081 }
3091 inline CNode* cLSHA( CNode* a0, CNode* a1, Coord_t* loc=NULL )
3092 {
3093  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eLSHA );
3094  n->Arg<CNode*>(0) = a0;
3095  n->Arg<CNode*>(1) = a1;
3096  return n;
3097 }
3108 inline CNode* cLSHA( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
3109 {
3110  CNode* n = new(heap) CNode( loc, eLSHA );
3111  n->Arg<CNode*>(0) = a0;
3112  n->Arg<CNode*>(1) = a1;
3113  return n;
3114 }
3124 inline CNode* cRSHA( CNode* a0, CNode* a1, Coord_t* loc=NULL )
3125 {
3126  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRSHA );
3127  n->Arg<CNode*>(0) = a0;
3128  n->Arg<CNode*>(1) = a1;
3129  return n;
3130 }
3141 inline CNode* cRSHA( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
3142 {
3143  CNode* n = new(heap) CNode( loc, eRSHA );
3144  n->Arg<CNode*>(0) = a0;
3145  n->Arg<CNode*>(1) = a1;
3146  return n;
3147 }
3157 inline CNode* cMOD( CNode* a0, CNode* a1, Coord_t* loc=NULL )
3158 {
3159  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eMOD );
3160  n->Arg<CNode*>(0) = a0;
3161  n->Arg<CNode*>(1) = a1;
3162  return n;
3163 }
3174 inline CNode* cMOD( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
3175 {
3176  CNode* n = new(heap) CNode( loc, eMOD );
3177  n->Arg<CNode*>(0) = a0;
3178  n->Arg<CNode*>(1) = a1;
3179  return n;
3180 }
3190 inline CNode* cOR( CNode* a0, CNode* a1, Coord_t* loc=NULL )
3191 {
3192  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eOR );
3193  n->Arg<CNode*>(0) = a0;
3194  n->Arg<CNode*>(1) = a1;
3195  return n;
3196 }
3207 inline CNode* cOR( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
3208 {
3209  CNode* n = new(heap) CNode( loc, eOR );
3210  n->Arg<CNode*>(0) = a0;
3211  n->Arg<CNode*>(1) = a1;
3212  return n;
3213 }
3223 inline CNode* cAND( CNode* a0, CNode* a1, Coord_t* loc=NULL )
3224 {
3225  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eAND );
3226  n->Arg<CNode*>(0) = a0;
3227  n->Arg<CNode*>(1) = a1;
3228  return n;
3229 }
3240 inline CNode* cAND( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
3241 {
3242  CNode* n = new(heap) CNode( loc, eAND );
3243  n->Arg<CNode*>(0) = a0;
3244  n->Arg<CNode*>(1) = a1;
3245  return n;
3246 }
3256 inline CNode* cANDANDAND( CNode* a0, CNode* a1, Coord_t* loc=NULL )
3257 {
3258  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eANDANDAND );
3259  n->Arg<CNode*>(0) = a0;
3260  n->Arg<CNode*>(1) = a1;
3261  return n;
3262 }
3273 inline CNode* cANDANDAND( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
3274 {
3275  CNode* n = new(heap) CNode( loc, eANDANDAND );
3276  n->Arg<CNode*>(0) = a0;
3277  n->Arg<CNode*>(1) = a1;
3278  return n;
3279 }
3289 inline CNode* cXOR( CNode* a0, CNode* a1, Coord_t* loc=NULL )
3290 {
3291  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eXOR );
3292  n->Arg<CNode*>(0) = a0;
3293  n->Arg<CNode*>(1) = a1;
3294  return n;
3295 }
3306 inline CNode* cXOR( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
3307 {
3308  CNode* n = new(heap) CNode( loc, eXOR );
3309  n->Arg<CNode*>(0) = a0;
3310  n->Arg<CNode*>(1) = a1;
3311  return n;
3312 }
3322 inline CNode* cXNOR( CNode* a0, CNode* a1, Coord_t* loc=NULL )
3323 {
3324  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eXNOR );
3325  n->Arg<CNode*>(0) = a0;
3326  n->Arg<CNode*>(1) = a1;
3327  return n;
3328 }
3339 inline CNode* cXNOR( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
3340 {
3341  CNode* n = new(heap) CNode( loc, eXNOR );
3342  n->Arg<CNode*>(0) = a0;
3343  n->Arg<CNode*>(1) = a1;
3344  return n;
3345 }
3354 inline CNode* cINSTANCE_REF( CInstance* a0, Coord_t* loc=NULL )
3355 {
3356  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eINSTANCE_REF );
3357  n->Arg<CInstance*>(0) = a0;
3358  return n;
3359 }
3369 inline CNode* cINSTANCE_REF( CObstack* heap, CInstance* a0, Coord_t* loc=NULL )
3370 {
3371  CNode* n = new(heap) CNode( loc, eINSTANCE_REF );
3372  n->Arg<CInstance*>(0) = a0;
3373  return n;
3374 }
3383 inline CNode* cGATE_REF( CGate* a0, Coord_t* loc=NULL )
3384 {
3385  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eGATE_REF );
3386  n->Arg<CGate*>(0) = a0;
3387  return n;
3388 }
3398 inline CNode* cGATE_REF( CObstack* heap, CGate* a0, Coord_t* loc=NULL )
3399 {
3400  CNode* n = new(heap) CNode( loc, eGATE_REF );
3401  n->Arg<CGate*>(0) = a0;
3402  return n;
3403 }
3413 inline CNode* cTASK_ENABLE( CSymbol* a0, CNode* a1, Coord_t* loc=NULL )
3414 {
3415  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eTASK_ENABLE );
3416  n->Arg<CSymbol*>(0) = a0;
3417  n->Arg<CNode*>(1) = a1;
3418  return n;
3419 }
3430 inline CNode* cTASK_ENABLE( CObstack* heap, CSymbol* a0, CNode* a1, Coord_t* loc=NULL )
3431 {
3432  CNode* n = new(heap) CNode( loc, eTASK_ENABLE );
3433  n->Arg<CSymbol*>(0) = a0;
3434  n->Arg<CNode*>(1) = a1;
3435  return n;
3436 }
3446 inline CNode* cSYSTASK_CALL( CSymbol* a0, CNode* a1, Coord_t* loc=NULL )
3447 {
3448  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eSYSTASK_CALL );
3449  n->Arg<CSymbol*>(0) = a0;
3450  n->Arg<CNode*>(1) = a1;
3451  return n;
3452 }
3463 inline CNode* cSYSTASK_CALL( CObstack* heap, CSymbol* a0, CNode* a1, Coord_t* loc=NULL )
3464 {
3465  CNode* n = new(heap) CNode( loc, eSYSTASK_CALL );
3466  n->Arg<CSymbol*>(0) = a0;
3467  n->Arg<CNode*>(1) = a1;
3468  return n;
3469 }
3479 inline CNode* cTIMING_CALL( CSymbol* a0, CNode* a1, Coord_t* loc=NULL )
3480 {
3481  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eTIMING_CALL );
3482  n->Arg<CSymbol*>(0) = a0;
3483  n->Arg<CNode*>(1) = a1;
3484  return n;
3485 }
3496 inline CNode* cTIMING_CALL( CObstack* heap, CSymbol* a0, CNode* a1, Coord_t* loc=NULL )
3497 {
3498  CNode* n = new(heap) CNode( loc, eTIMING_CALL );
3499  n->Arg<CSymbol*>(0) = a0;
3500  n->Arg<CNode*>(1) = a1;
3501  return n;
3502 }
3513 inline CNode* cFUNCTION_CALL( CSymbol* a0, CNode* a1, CScope* a2, Coord_t* loc=NULL )
3514 {
3515  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eFUNCTION_CALL );
3516  n->Arg<CSymbol*>(0) = a0;
3517  n->Arg<CNode*>(1) = a1;
3518  n->Arg<CScope*>(2) = a2;
3519  return n;
3520 }
3532 inline CNode* cFUNCTION_CALL( CObstack* heap, CSymbol* a0, CNode* a1, CScope* a2, Coord_t* loc=NULL )
3533 {
3534  CNode* n = new(heap) CNode( loc, eFUNCTION_CALL );
3535  n->Arg<CSymbol*>(0) = a0;
3536  n->Arg<CNode*>(1) = a1;
3537  n->Arg<CScope*>(2) = a2;
3538  return n;
3539 }
3549 inline CNode* cARRAY( CNode* a0, CNode* a1, Coord_t* loc=NULL )
3550 {
3551  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eARRAY );
3552  n->Arg<CNode*>(0) = a0;
3553  n->Arg<CNode*>(1) = a1;
3554  return n;
3555 }
3566 inline CNode* cARRAY( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
3567 {
3568  CNode* n = new(heap) CNode( loc, eARRAY );
3569  n->Arg<CNode*>(0) = a0;
3570  n->Arg<CNode*>(1) = a1;
3571  return n;
3572 }
3581 inline CNode* cNET_REF( CNet* a0, Coord_t* loc=NULL )
3582 {
3583  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eNET_REF );
3584  n->Arg<CNet*>(0) = a0;
3585  return n;
3586 }
3596 inline CNode* cNET_REF( CObstack* heap, CNet* a0, Coord_t* loc=NULL )
3597 {
3598  CNode* n = new(heap) CNode( loc, eNET_REF );
3599  n->Arg<CNet*>(0) = a0;
3600  return n;
3601 }
3610 inline CNode* cVAR_REF( CVar* a0, Coord_t* loc=NULL )
3611 {
3612  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eVAR_REF );
3613  n->Arg<CVar*>(0) = a0;
3614  return n;
3615 }
3625 inline CNode* cVAR_REF( CObstack* heap, CVar* a0, Coord_t* loc=NULL )
3626 {
3627  CNode* n = new(heap) CNode( loc, eVAR_REF );
3628  n->Arg<CVar*>(0) = a0;
3629  return n;
3630 }
3639 inline CNode* cPARAM_REF( CParam* a0, Coord_t* loc=NULL )
3640 {
3641  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePARAM_REF );
3642  n->Arg<CParam*>(0) = a0;
3643  return n;
3644 }
3654 inline CNode* cPARAM_REF( CObstack* heap, CParam* a0, Coord_t* loc=NULL )
3655 {
3656  CNode* n = new(heap) CNode( loc, ePARAM_REF );
3657  n->Arg<CParam*>(0) = a0;
3658  return n;
3659 }
3668 inline CNode* cPORT_REF( CPortDir* a0, Coord_t* loc=NULL )
3669 {
3670  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePORT_REF );
3671  n->Arg<CPortDir*>(0) = a0;
3672  return n;
3673 }
3683 inline CNode* cPORT_REF( CObstack* heap, CPortDir* a0, Coord_t* loc=NULL )
3684 {
3685  CNode* n = new(heap) CNode( loc, ePORT_REF );
3686  n->Arg<CPortDir*>(0) = a0;
3687  return n;
3688 }
3697 inline CNode* cFWD_REF( CFref* a0, Coord_t* loc=NULL )
3698 {
3699  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eFWD_REF );
3700  n->Arg<CFref*>(0) = a0;
3701  return n;
3702 }
3712 inline CNode* cFWD_REF( CObstack* heap, CFref* a0, Coord_t* loc=NULL )
3713 {
3714  CNode* n = new(heap) CNode( loc, eFWD_REF );
3715  n->Arg<CFref*>(0) = a0;
3716  return n;
3717 }
3726 inline CNode* cGENVAR_REF( CGenvar* a0, Coord_t* loc=NULL )
3727 {
3728  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eGENVAR_REF );
3729  n->Arg<CGenvar*>(0) = a0;
3730  return n;
3731 }
3741 inline CNode* cGENVAR_REF( CObstack* heap, CGenvar* a0, Coord_t* loc=NULL )
3742 {
3743  CNode* n = new(heap) CNode( loc, eGENVAR_REF );
3744  n->Arg<CGenvar*>(0) = a0;
3745  return n;
3746 }
3755 inline CNode* cENUM_REF( CEnum* a0, Coord_t* loc=NULL )
3756 {
3757  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eENUM_REF );
3758  n->Arg<CEnum*>(0) = a0;
3759  return n;
3760 }
3770 inline CNode* cENUM_REF( CObstack* heap, CEnum* a0, Coord_t* loc=NULL )
3771 {
3772  CNode* n = new(heap) CNode( loc, eENUM_REF );
3773  n->Arg<CEnum*>(0) = a0;
3774  return n;
3775 }
3784 inline CNode* cTYPE_REF( CTypedef* a0, Coord_t* loc=NULL )
3785 {
3786  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eTYPE_REF );
3787  n->Arg<CTypedef*>(0) = a0;
3788  return n;
3789 }
3799 inline CNode* cTYPE_REF( CObstack* heap, CTypedef* a0, Coord_t* loc=NULL )
3800 {
3801  CNode* n = new(heap) CNode( loc, eTYPE_REF );
3802  n->Arg<CTypedef*>(0) = a0;
3803  return n;
3804 }
3814 inline CNode* cNET_DECL( CNet* a0, CNode* a1, Coord_t* loc=NULL )
3815 {
3816  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eNET_DECL );
3817  n->Arg<CNet*>(0) = a0;
3818  n->Arg<CNode*>(1) = a1;
3819  return n;
3820 }
3831 inline CNode* cNET_DECL( CObstack* heap, CNet* a0, CNode* a1, Coord_t* loc=NULL )
3832 {
3833  CNode* n = new(heap) CNode( loc, eNET_DECL );
3834  n->Arg<CNet*>(0) = a0;
3835  n->Arg<CNode*>(1) = a1;
3836  return n;
3837 }
3847 inline CNode* cVAR_DECL( CVar* a0, CNode* a1, Coord_t* loc=NULL )
3848 {
3849  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eVAR_DECL );
3850  n->Arg<CVar*>(0) = a0;
3851  n->Arg<CNode*>(1) = a1;
3852  return n;
3853 }
3864 inline CNode* cVAR_DECL( CObstack* heap, CVar* a0, CNode* a1, Coord_t* loc=NULL )
3865 {
3866  CNode* n = new(heap) CNode( loc, eVAR_DECL );
3867  n->Arg<CVar*>(0) = a0;
3868  n->Arg<CNode*>(1) = a1;
3869  return n;
3870 }
3879 inline CNode* cPARAM_DECL( CParam* a0, Coord_t* loc=NULL )
3880 {
3881  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePARAM_DECL );
3882  n->Arg<CParam*>(0) = a0;
3883  return n;
3884 }
3894 inline CNode* cPARAM_DECL( CObstack* heap, CParam* a0, Coord_t* loc=NULL )
3895 {
3896  CNode* n = new(heap) CNode( loc, ePARAM_DECL );
3897  n->Arg<CParam*>(0) = a0;
3898  return n;
3899 }
3908 inline CNode* cSPECPARAM_DECL( CParam* a0, Coord_t* loc=NULL )
3909 {
3910  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eSPECPARAM_DECL );
3911  n->Arg<CParam*>(0) = a0;
3912  return n;
3913 }
3923 inline CNode* cSPECPARAM_DECL( CObstack* heap, CParam* a0, Coord_t* loc=NULL )
3924 {
3925  CNode* n = new(heap) CNode( loc, eSPECPARAM_DECL );
3926  n->Arg<CParam*>(0) = a0;
3927  return n;
3928 }
3937 inline CNode* cPORT_DECL( CPortDir* a0, Coord_t* loc=NULL )
3938 {
3939  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePORT_DECL );
3940  n->Arg<CPortDir*>(0) = a0;
3941  return n;
3942 }
3952 inline CNode* cPORT_DECL( CObstack* heap, CPortDir* a0, Coord_t* loc=NULL )
3953 {
3954  CNode* n = new(heap) CNode( loc, ePORT_DECL );
3955  n->Arg<CPortDir*>(0) = a0;
3956  return n;
3957 }
3966 inline CNode* cGENVAR_DECL( CGenvar* a0, Coord_t* loc=NULL )
3967 {
3968  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eGENVAR_DECL );
3969  n->Arg<CGenvar*>(0) = a0;
3970  return n;
3971 }
3981 inline CNode* cGENVAR_DECL( CObstack* heap, CGenvar* a0, Coord_t* loc=NULL )
3982 {
3983  CNode* n = new(heap) CNode( loc, eGENVAR_DECL );
3984  n->Arg<CGenvar*>(0) = a0;
3985  return n;
3986 }
3995 inline CNode* cTYPEDEF_DECL( CTypedef* a0, Coord_t* loc=NULL )
3996 {
3997  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eTYPEDEF_DECL );
3998  n->Arg<CTypedef*>(0) = a0;
3999  return n;
4000 }
4010 inline CNode* cTYPEDEF_DECL( CObstack* heap, CTypedef* a0, Coord_t* loc=NULL )
4011 {
4012  CNode* n = new(heap) CNode( loc, eTYPEDEF_DECL );
4013  n->Arg<CTypedef*>(0) = a0;
4014  return n;
4015 }
4025 inline CNode* cLIST( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4026 {
4027  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eLIST );
4028  n->Arg<CNode*>(0) = a0;
4029  n->Arg<CNode*>(1) = a1;
4030  return n;
4031 }
4042 inline CNode* cLIST( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4043 {
4044  CNode* n = new(heap) CNode( loc, eLIST );
4045  n->Arg<CNode*>(0) = a0;
4046  n->Arg<CNode*>(1) = a1;
4047  return n;
4048 }
4058 inline CNode* cRANGE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4059 {
4060  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRANGE );
4061  n->Arg<CNode*>(0) = a0;
4062  n->Arg<CNode*>(1) = a1;
4063  return n;
4064 }
4075 inline CNode* cRANGE( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4076 {
4077  CNode* n = new(heap) CNode( loc, eRANGE );
4078  n->Arg<CNode*>(0) = a0;
4079  n->Arg<CNode*>(1) = a1;
4080  return n;
4081 }
4091 inline CNode* cSLICE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4092 {
4093  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eSLICE );
4094  n->Arg<CNode*>(0) = a0;
4095  n->Arg<CNode*>(1) = a1;
4096  return n;
4097 }
4108 inline CNode* cSLICE( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4109 {
4110  CNode* n = new(heap) CNode( loc, eSLICE );
4111  n->Arg<CNode*>(0) = a0;
4112  n->Arg<CNode*>(1) = a1;
4113  return n;
4114 }
4124 inline CNode* cPSLICE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4125 {
4126  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePSLICE );
4127  n->Arg<CNode*>(0) = a0;
4128  n->Arg<CNode*>(1) = a1;
4129  return n;
4130 }
4141 inline CNode* cPSLICE( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4142 {
4143  CNode* n = new(heap) CNode( loc, ePSLICE );
4144  n->Arg<CNode*>(0) = a0;
4145  n->Arg<CNode*>(1) = a1;
4146  return n;
4147 }
4157 inline CNode* cMSLICE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4158 {
4159  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eMSLICE );
4160  n->Arg<CNode*>(0) = a0;
4161  n->Arg<CNode*>(1) = a1;
4162  return n;
4163 }
4174 inline CNode* cMSLICE( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4175 {
4176  CNode* n = new(heap) CNode( loc, eMSLICE );
4177  n->Arg<CNode*>(0) = a0;
4178  n->Arg<CNode*>(1) = a1;
4179  return n;
4180 }
4189 inline CNode* cCVRI( CNode* a0, Coord_t* loc=NULL )
4190 {
4191  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCVRI );
4192  n->Arg<CNode*>(0) = a0;
4193  return n;
4194 }
4204 inline CNode* cCVRI( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
4205 {
4206  CNode* n = new(heap) CNode( loc, eCVRI );
4207  n->Arg<CNode*>(0) = a0;
4208  return n;
4209 }
4218 inline CNode* cCVIR( CNode* a0, Coord_t* loc=NULL )
4219 {
4220  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCVIR );
4221  n->Arg<CNode*>(0) = a0;
4222  return n;
4223 }
4233 inline CNode* cCVIR( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
4234 {
4235  CNode* n = new(heap) CNode( loc, eCVIR );
4236  n->Arg<CNode*>(0) = a0;
4237  return n;
4238 }
4248 inline CNode* cREP( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4249 {
4250  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eREP );
4251  n->Arg<CNode*>(0) = a0;
4252  n->Arg<CNode*>(1) = a1;
4253  return n;
4254 }
4265 inline CNode* cREP( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4266 {
4267  CNode* n = new(heap) CNode( loc, eREP );
4268  n->Arg<CNode*>(0) = a0;
4269  n->Arg<CNode*>(1) = a1;
4270  return n;
4271 }
4281 inline CNode* cCAT( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4282 {
4283  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCAT );
4284  n->Arg<CNode*>(0) = a0;
4285  n->Arg<CNode*>(1) = a1;
4286  return n;
4287 }
4298 inline CNode* cCAT( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4299 {
4300  CNode* n = new(heap) CNode( loc, eCAT );
4301  n->Arg<CNode*>(0) = a0;
4302  n->Arg<CNode*>(1) = a1;
4303  return n;
4304 }
4313 inline CNode* cUCAT( CNode* a0, Coord_t* loc=NULL )
4314 {
4315  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eUCAT );
4316  n->Arg<CNode*>(0) = a0;
4317  return n;
4318 }
4328 inline CNode* cUCAT( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
4329 {
4330  CNode* n = new(heap) CNode( loc, eUCAT );
4331  n->Arg<CNode*>(0) = a0;
4332  return n;
4333 }
4342 inline CNode* cCOM( CNode* a0, Coord_t* loc=NULL )
4343 {
4344  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCOM );
4345  n->Arg<CNode*>(0) = a0;
4346  return n;
4347 }
4357 inline CNode* cCOM( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
4358 {
4359  CNode* n = new(heap) CNode( loc, eCOM );
4360  n->Arg<CNode*>(0) = a0;
4361  return n;
4362 }
4371 inline CNode* cNEG( CNode* a0, Coord_t* loc=NULL )
4372 {
4373  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eNEG );
4374  n->Arg<CNode*>(0) = a0;
4375  return n;
4376 }
4386 inline CNode* cNEG( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
4387 {
4388  CNode* n = new(heap) CNode( loc, eNEG );
4389  n->Arg<CNode*>(0) = a0;
4390  return n;
4391 }
4400 inline CNode* cPLUS( CNode* a0, Coord_t* loc=NULL )
4401 {
4402  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePLUS );
4403  n->Arg<CNode*>(0) = a0;
4404  return n;
4405 }
4415 inline CNode* cPLUS( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
4416 {
4417  CNode* n = new(heap) CNode( loc, ePLUS );
4418  n->Arg<CNode*>(0) = a0;
4419  return n;
4420 }
4429 inline CNode* cNOT( CNode* a0, Coord_t* loc=NULL )
4430 {
4431  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eNOT );
4432  n->Arg<CNode*>(0) = a0;
4433  return n;
4434 }
4444 inline CNode* cNOT( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
4445 {
4446  CNode* n = new(heap) CNode( loc, eNOT );
4447  n->Arg<CNode*>(0) = a0;
4448  return n;
4449 }
4459 inline CNode* cGT( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4460 {
4461  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eGT );
4462  n->Arg<CNode*>(0) = a0;
4463  n->Arg<CNode*>(1) = a1;
4464  return n;
4465 }
4476 inline CNode* cGT( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4477 {
4478  CNode* n = new(heap) CNode( loc, eGT );
4479  n->Arg<CNode*>(0) = a0;
4480  n->Arg<CNode*>(1) = a1;
4481  return n;
4482 }
4492 inline CNode* cGE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4493 {
4494  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eGE );
4495  n->Arg<CNode*>(0) = a0;
4496  n->Arg<CNode*>(1) = a1;
4497  return n;
4498 }
4509 inline CNode* cGE( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4510 {
4511  CNode* n = new(heap) CNode( loc, eGE );
4512  n->Arg<CNode*>(0) = a0;
4513  n->Arg<CNode*>(1) = a1;
4514  return n;
4515 }
4525 inline CNode* cLT( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4526 {
4527  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eLT );
4528  n->Arg<CNode*>(0) = a0;
4529  n->Arg<CNode*>(1) = a1;
4530  return n;
4531 }
4542 inline CNode* cLT( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4543 {
4544  CNode* n = new(heap) CNode( loc, eLT );
4545  n->Arg<CNode*>(0) = a0;
4546  n->Arg<CNode*>(1) = a1;
4547  return n;
4548 }
4558 inline CNode* cLE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4559 {
4560  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eLE );
4561  n->Arg<CNode*>(0) = a0;
4562  n->Arg<CNode*>(1) = a1;
4563  return n;
4564 }
4575 inline CNode* cLE( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4576 {
4577  CNode* n = new(heap) CNode( loc, eLE );
4578  n->Arg<CNode*>(0) = a0;
4579  n->Arg<CNode*>(1) = a1;
4580  return n;
4581 }
4591 inline CNode* cLAND( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4592 {
4593  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eLAND );
4594  n->Arg<CNode*>(0) = a0;
4595  n->Arg<CNode*>(1) = a1;
4596  return n;
4597 }
4608 inline CNode* cLAND( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4609 {
4610  CNode* n = new(heap) CNode( loc, eLAND );
4611  n->Arg<CNode*>(0) = a0;
4612  n->Arg<CNode*>(1) = a1;
4613  return n;
4614 }
4624 inline CNode* cLOR( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4625 {
4626  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eLOR );
4627  n->Arg<CNode*>(0) = a0;
4628  n->Arg<CNode*>(1) = a1;
4629  return n;
4630 }
4641 inline CNode* cLOR( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4642 {
4643  CNode* n = new(heap) CNode( loc, eLOR );
4644  n->Arg<CNode*>(0) = a0;
4645  n->Arg<CNode*>(1) = a1;
4646  return n;
4647 }
4657 inline CNode* cCEQ( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4658 {
4659  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCEQ );
4660  n->Arg<CNode*>(0) = a0;
4661  n->Arg<CNode*>(1) = a1;
4662  return n;
4663 }
4674 inline CNode* cCEQ( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4675 {
4676  CNode* n = new(heap) CNode( loc, eCEQ );
4677  n->Arg<CNode*>(0) = a0;
4678  n->Arg<CNode*>(1) = a1;
4679  return n;
4680 }
4690 inline CNode* cCNE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4691 {
4692  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCNE );
4693  n->Arg<CNode*>(0) = a0;
4694  n->Arg<CNode*>(1) = a1;
4695  return n;
4696 }
4707 inline CNode* cCNE( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4708 {
4709  CNode* n = new(heap) CNode( loc, eCNE );
4710  n->Arg<CNode*>(0) = a0;
4711  n->Arg<CNode*>(1) = a1;
4712  return n;
4713 }
4723 inline CNode* cEQ( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4724 {
4725  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eEQ );
4726  n->Arg<CNode*>(0) = a0;
4727  n->Arg<CNode*>(1) = a1;
4728  return n;
4729 }
4740 inline CNode* cEQ( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4741 {
4742  CNode* n = new(heap) CNode( loc, eEQ );
4743  n->Arg<CNode*>(0) = a0;
4744  n->Arg<CNode*>(1) = a1;
4745  return n;
4746 }
4756 inline CNode* cNE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
4757 {
4758  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eNE );
4759  n->Arg<CNode*>(0) = a0;
4760  n->Arg<CNode*>(1) = a1;
4761  return n;
4762 }
4773 inline CNode* cNE( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
4774 {
4775  CNode* n = new(heap) CNode( loc, eNE );
4776  n->Arg<CNode*>(0) = a0;
4777  n->Arg<CNode*>(1) = a1;
4778  return n;
4779 }
4788 inline CNode* cRAND( CNode* a0, Coord_t* loc=NULL )
4789 {
4790  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRAND );
4791  n->Arg<CNode*>(0) = a0;
4792  return n;
4793 }
4803 inline CNode* cRAND( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
4804 {
4805  CNode* n = new(heap) CNode( loc, eRAND );
4806  n->Arg<CNode*>(0) = a0;
4807  return n;
4808 }
4817 inline CNode* cRNAND( CNode* a0, Coord_t* loc=NULL )
4818 {
4819  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRNAND );
4820  n->Arg<CNode*>(0) = a0;
4821  return n;
4822 }
4832 inline CNode* cRNAND( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
4833 {
4834  CNode* n = new(heap) CNode( loc, eRNAND );
4835  n->Arg<CNode*>(0) = a0;
4836  return n;
4837 }
4846 inline CNode* cROR( CNode* a0, Coord_t* loc=NULL )
4847 {
4848  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eROR );
4849  n->Arg<CNode*>(0) = a0;
4850  return n;
4851 }
4861 inline CNode* cROR( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
4862 {
4863  CNode* n = new(heap) CNode( loc, eROR );
4864  n->Arg<CNode*>(0) = a0;
4865  return n;
4866 }
4875 inline CNode* cRNOR( CNode* a0, Coord_t* loc=NULL )
4876 {
4877  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRNOR );
4878  n->Arg<CNode*>(0) = a0;
4879  return n;
4880 }
4890 inline CNode* cRNOR( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
4891 {
4892  CNode* n = new(heap) CNode( loc, eRNOR );
4893  n->Arg<CNode*>(0) = a0;
4894  return n;
4895 }
4904 inline CNode* cRXOR( CNode* a0, Coord_t* loc=NULL )
4905 {
4906  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRXOR );
4907  n->Arg<CNode*>(0) = a0;
4908  return n;
4909 }
4919 inline CNode* cRXOR( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
4920 {
4921  CNode* n = new(heap) CNode( loc, eRXOR );
4922  n->Arg<CNode*>(0) = a0;
4923  return n;
4924 }
4933 inline CNode* cRXNOR( CNode* a0, Coord_t* loc=NULL )
4934 {
4935  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRXNOR );
4936  n->Arg<CNode*>(0) = a0;
4937  return n;
4938 }
4948 inline CNode* cRXNOR( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
4949 {
4950  CNode* n = new(heap) CNode( loc, eRXNOR );
4951  n->Arg<CNode*>(0) = a0;
4952  return n;
4953 }
4964 inline CNode* cHOOK( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
4965 {
4966  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eHOOK );
4967  n->Arg<CNode*>(0) = a0;
4968  n->Arg<CNode*>(1) = a1;
4969  n->Arg<CNode*>(2) = a2;
4970  return n;
4971 }
4983 inline CNode* cHOOK( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
4984 {
4985  CNode* n = new(heap) CNode( loc, eHOOK );
4986  n->Arg<CNode*>(0) = a0;
4987  n->Arg<CNode*>(1) = a1;
4988  n->Arg<CNode*>(2) = a2;
4989  return n;
4990 }
4999 inline CNode* cINIT( CNode* a0, Coord_t* loc=NULL )
5000 {
5001  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eINIT );
5002  n->Arg<CNode*>(0) = a0;
5003  return n;
5004 }
5014 inline CNode* cINIT( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
5015 {
5016  CNode* n = new(heap) CNode( loc, eINIT );
5017  n->Arg<CNode*>(0) = a0;
5018  return n;
5019 }
5028 inline CNode* cALWAYS( CNode* a0, Coord_t* loc=NULL )
5029 {
5030  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eALWAYS );
5031  n->Arg<CNode*>(0) = a0;
5032  return n;
5033 }
5043 inline CNode* cALWAYS( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
5044 {
5045  CNode* n = new(heap) CNode( loc, eALWAYS );
5046  n->Arg<CNode*>(0) = a0;
5047  return n;
5048 }
5057 inline CNode* cALWAYS_LATCH( CNode* a0, Coord_t* loc=NULL )
5058 {
5059  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eALWAYS_LATCH );
5060  n->Arg<CNode*>(0) = a0;
5061  return n;
5062 }
5072 inline CNode* cALWAYS_LATCH( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
5073 {
5074  CNode* n = new(heap) CNode( loc, eALWAYS_LATCH );
5075  n->Arg<CNode*>(0) = a0;
5076  return n;
5077 }
5086 inline CNode* cALWAYS_FF( CNode* a0, Coord_t* loc=NULL )
5087 {
5088  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eALWAYS_FF );
5089  n->Arg<CNode*>(0) = a0;
5090  return n;
5091 }
5101 inline CNode* cALWAYS_FF( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
5102 {
5103  CNode* n = new(heap) CNode( loc, eALWAYS_FF );
5104  n->Arg<CNode*>(0) = a0;
5105  return n;
5106 }
5115 inline CNode* cALWAYS_COMB( CNode* a0, Coord_t* loc=NULL )
5116 {
5117  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eALWAYS_COMB );
5118  n->Arg<CNode*>(0) = a0;
5119  return n;
5120 }
5130 inline CNode* cALWAYS_COMB( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
5131 {
5132  CNode* n = new(heap) CNode( loc, eALWAYS_COMB );
5133  n->Arg<CNode*>(0) = a0;
5134  return n;
5135 }
5145 inline CNode* cEVENT( CNode* a0, CNode* a1, Coord_t* loc=NULL )
5146 {
5147  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eEVENT );
5148  n->Arg<CNode*>(0) = a0;
5149  n->Arg<CNode*>(1) = a1;
5150  return n;
5151 }
5162 inline CNode* cEVENT( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
5163 {
5164  CNode* n = new(heap) CNode( loc, eEVENT );
5165  n->Arg<CNode*>(0) = a0;
5166  n->Arg<CNode*>(1) = a1;
5167  return n;
5168 }
5178 inline CNode* cBLOCK_REF( CBlock* a0, CNode* a1, Coord_t* loc=NULL )
5179 {
5180  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eBLOCK_REF );
5181  n->Arg<CBlock*>(0) = a0;
5182  n->Arg<CNode*>(1) = a1;
5183  return n;
5184 }
5195 inline CNode* cBLOCK_REF( CObstack* heap, CBlock* a0, CNode* a1, Coord_t* loc=NULL )
5196 {
5197  CNode* n = new(heap) CNode( loc, eBLOCK_REF );
5198  n->Arg<CBlock*>(0) = a0;
5199  n->Arg<CNode*>(1) = a1;
5200  return n;
5201 }
5211 inline CNode* cSPECIFY_REF( CSpecify* a0, CNode* a1, Coord_t* loc=NULL )
5212 {
5213  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eSPECIFY_REF );
5214  n->Arg<CSpecify*>(0) = a0;
5215  n->Arg<CNode*>(1) = a1;
5216  return n;
5217 }
5228 inline CNode* cSPECIFY_REF( CObstack* heap, CSpecify* a0, CNode* a1, Coord_t* loc=NULL )
5229 {
5230  CNode* n = new(heap) CNode( loc, eSPECIFY_REF );
5231  n->Arg<CSpecify*>(0) = a0;
5232  n->Arg<CNode*>(1) = a1;
5233  return n;
5234 }
5245 inline CNode* cASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5246 {
5247  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eASSIGN );
5248  n->Arg<CNode*>(0) = a0;
5249  n->Arg<CNode*>(1) = a1;
5250  n->Arg<CNode*>(2) = a2;
5251  return n;
5252 }
5264 inline CNode* cASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5265 {
5266  CNode* n = new(heap) CNode( loc, eASSIGN );
5267  n->Arg<CNode*>(0) = a0;
5268  n->Arg<CNode*>(1) = a1;
5269  n->Arg<CNode*>(2) = a2;
5270  return n;
5271 }
5282 inline CNode* cADD_ASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5283 {
5284  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eADD_ASSIGN );
5285  n->Arg<CNode*>(0) = a0;
5286  n->Arg<CNode*>(1) = a1;
5287  n->Arg<CNode*>(2) = a2;
5288  return n;
5289 }
5301 inline CNode* cADD_ASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5302 {
5303  CNode* n = new(heap) CNode( loc, eADD_ASSIGN );
5304  n->Arg<CNode*>(0) = a0;
5305  n->Arg<CNode*>(1) = a1;
5306  n->Arg<CNode*>(2) = a2;
5307  return n;
5308 }
5319 inline CNode* cSUB_ASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5320 {
5321  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eSUB_ASSIGN );
5322  n->Arg<CNode*>(0) = a0;
5323  n->Arg<CNode*>(1) = a1;
5324  n->Arg<CNode*>(2) = a2;
5325  return n;
5326 }
5338 inline CNode* cSUB_ASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5339 {
5340  CNode* n = new(heap) CNode( loc, eSUB_ASSIGN );
5341  n->Arg<CNode*>(0) = a0;
5342  n->Arg<CNode*>(1) = a1;
5343  n->Arg<CNode*>(2) = a2;
5344  return n;
5345 }
5356 inline CNode* cMUL_ASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5357 {
5358  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eMUL_ASSIGN );
5359  n->Arg<CNode*>(0) = a0;
5360  n->Arg<CNode*>(1) = a1;
5361  n->Arg<CNode*>(2) = a2;
5362  return n;
5363 }
5375 inline CNode* cMUL_ASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5376 {
5377  CNode* n = new(heap) CNode( loc, eMUL_ASSIGN );
5378  n->Arg<CNode*>(0) = a0;
5379  n->Arg<CNode*>(1) = a1;
5380  n->Arg<CNode*>(2) = a2;
5381  return n;
5382 }
5393 inline CNode* cDIV_ASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5394 {
5395  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eDIV_ASSIGN );
5396  n->Arg<CNode*>(0) = a0;
5397  n->Arg<CNode*>(1) = a1;
5398  n->Arg<CNode*>(2) = a2;
5399  return n;
5400 }
5412 inline CNode* cDIV_ASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5413 {
5414  CNode* n = new(heap) CNode( loc, eDIV_ASSIGN );
5415  n->Arg<CNode*>(0) = a0;
5416  n->Arg<CNode*>(1) = a1;
5417  n->Arg<CNode*>(2) = a2;
5418  return n;
5419 }
5430 inline CNode* cMOD_ASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5431 {
5432  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eMOD_ASSIGN );
5433  n->Arg<CNode*>(0) = a0;
5434  n->Arg<CNode*>(1) = a1;
5435  n->Arg<CNode*>(2) = a2;
5436  return n;
5437 }
5449 inline CNode* cMOD_ASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5450 {
5451  CNode* n = new(heap) CNode( loc, eMOD_ASSIGN );
5452  n->Arg<CNode*>(0) = a0;
5453  n->Arg<CNode*>(1) = a1;
5454  n->Arg<CNode*>(2) = a2;
5455  return n;
5456 }
5467 inline CNode* cAND_ASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5468 {
5469  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eAND_ASSIGN );
5470  n->Arg<CNode*>(0) = a0;
5471  n->Arg<CNode*>(1) = a1;
5472  n->Arg<CNode*>(2) = a2;
5473  return n;
5474 }
5486 inline CNode* cAND_ASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5487 {
5488  CNode* n = new(heap) CNode( loc, eAND_ASSIGN );
5489  n->Arg<CNode*>(0) = a0;
5490  n->Arg<CNode*>(1) = a1;
5491  n->Arg<CNode*>(2) = a2;
5492  return n;
5493 }
5504 inline CNode* cOR_ASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5505 {
5506  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eOR_ASSIGN );
5507  n->Arg<CNode*>(0) = a0;
5508  n->Arg<CNode*>(1) = a1;
5509  n->Arg<CNode*>(2) = a2;
5510  return n;
5511 }
5523 inline CNode* cOR_ASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5524 {
5525  CNode* n = new(heap) CNode( loc, eOR_ASSIGN );
5526  n->Arg<CNode*>(0) = a0;
5527  n->Arg<CNode*>(1) = a1;
5528  n->Arg<CNode*>(2) = a2;
5529  return n;
5530 }
5541 inline CNode* cXOR_ASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5542 {
5543  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eXOR_ASSIGN );
5544  n->Arg<CNode*>(0) = a0;
5545  n->Arg<CNode*>(1) = a1;
5546  n->Arg<CNode*>(2) = a2;
5547  return n;
5548 }
5560 inline CNode* cXOR_ASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5561 {
5562  CNode* n = new(heap) CNode( loc, eXOR_ASSIGN );
5563  n->Arg<CNode*>(0) = a0;
5564  n->Arg<CNode*>(1) = a1;
5565  n->Arg<CNode*>(2) = a2;
5566  return n;
5567 }
5578 inline CNode* cLSH_ASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5579 {
5580  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eLSH_ASSIGN );
5581  n->Arg<CNode*>(0) = a0;
5582  n->Arg<CNode*>(1) = a1;
5583  n->Arg<CNode*>(2) = a2;
5584  return n;
5585 }
5597 inline CNode* cLSH_ASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5598 {
5599  CNode* n = new(heap) CNode( loc, eLSH_ASSIGN );
5600  n->Arg<CNode*>(0) = a0;
5601  n->Arg<CNode*>(1) = a1;
5602  n->Arg<CNode*>(2) = a2;
5603  return n;
5604 }
5615 inline CNode* cRSH_ASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5616 {
5617  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRSH_ASSIGN );
5618  n->Arg<CNode*>(0) = a0;
5619  n->Arg<CNode*>(1) = a1;
5620  n->Arg<CNode*>(2) = a2;
5621  return n;
5622 }
5634 inline CNode* cRSH_ASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5635 {
5636  CNode* n = new(heap) CNode( loc, eRSH_ASSIGN );
5637  n->Arg<CNode*>(0) = a0;
5638  n->Arg<CNode*>(1) = a1;
5639  n->Arg<CNode*>(2) = a2;
5640  return n;
5641 }
5652 inline CNode* cLSHA_ASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5653 {
5654  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eLSHA_ASSIGN );
5655  n->Arg<CNode*>(0) = a0;
5656  n->Arg<CNode*>(1) = a1;
5657  n->Arg<CNode*>(2) = a2;
5658  return n;
5659 }
5671 inline CNode* cLSHA_ASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5672 {
5673  CNode* n = new(heap) CNode( loc, eLSHA_ASSIGN );
5674  n->Arg<CNode*>(0) = a0;
5675  n->Arg<CNode*>(1) = a1;
5676  n->Arg<CNode*>(2) = a2;
5677  return n;
5678 }
5689 inline CNode* cRSHA_ASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5690 {
5691  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRSHA_ASSIGN );
5692  n->Arg<CNode*>(0) = a0;
5693  n->Arg<CNode*>(1) = a1;
5694  n->Arg<CNode*>(2) = a2;
5695  return n;
5696 }
5708 inline CNode* cRSHA_ASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5709 {
5710  CNode* n = new(heap) CNode( loc, eRSHA_ASSIGN );
5711  n->Arg<CNode*>(0) = a0;
5712  n->Arg<CNode*>(1) = a1;
5713  n->Arg<CNode*>(2) = a2;
5714  return n;
5715 }
5725 inline CNode* cFORCE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
5726 {
5727  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eFORCE );
5728  n->Arg<CNode*>(0) = a0;
5729  n->Arg<CNode*>(1) = a1;
5730  return n;
5731 }
5742 inline CNode* cFORCE( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
5743 {
5744  CNode* n = new(heap) CNode( loc, eFORCE );
5745  n->Arg<CNode*>(0) = a0;
5746  n->Arg<CNode*>(1) = a1;
5747  return n;
5748 }
5757 inline CNode* cRELEASE( CNode* a0, Coord_t* loc=NULL )
5758 {
5759  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRELEASE );
5760  n->Arg<CNode*>(0) = a0;
5761  return n;
5762 }
5772 inline CNode* cRELEASE( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
5773 {
5774  CNode* n = new(heap) CNode( loc, eRELEASE );
5775  n->Arg<CNode*>(0) = a0;
5776  return n;
5777 }
5788 inline CNode* cNBASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5789 {
5790  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eNBASSIGN );
5791  n->Arg<CNode*>(0) = a0;
5792  n->Arg<CNode*>(1) = a1;
5793  n->Arg<CNode*>(2) = a2;
5794  return n;
5795 }
5807 inline CNode* cNBASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5808 {
5809  CNode* n = new(heap) CNode( loc, eNBASSIGN );
5810  n->Arg<CNode*>(0) = a0;
5811  n->Arg<CNode*>(1) = a1;
5812  n->Arg<CNode*>(2) = a2;
5813  return n;
5814 }
5823 inline CNode* cPOSEDGE( CNode* a0, Coord_t* loc=NULL )
5824 {
5825  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePOSEDGE );
5826  n->Arg<CNode*>(0) = a0;
5827  return n;
5828 }
5838 inline CNode* cPOSEDGE( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
5839 {
5840  CNode* n = new(heap) CNode( loc, ePOSEDGE );
5841  n->Arg<CNode*>(0) = a0;
5842  return n;
5843 }
5852 inline CNode* cNEGEDGE( CNode* a0, Coord_t* loc=NULL )
5853 {
5854  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eNEGEDGE );
5855  n->Arg<CNode*>(0) = a0;
5856  return n;
5857 }
5867 inline CNode* cNEGEDGE( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
5868 {
5869  CNode* n = new(heap) CNode( loc, eNEGEDGE );
5870  n->Arg<CNode*>(0) = a0;
5871  return n;
5872 }
5882 inline CNode* cEDGE( CNode* a0, Edge_t a1, Coord_t* loc=NULL )
5883 {
5884  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eEDGE );
5885  n->Arg<CNode*>(0) = a0;
5886  n->Arg<Edge_t>(1) = a1;
5887  return n;
5888 }
5899 inline CNode* cEDGE( CObstack* heap, CNode* a0, Edge_t a1, Coord_t* loc=NULL )
5900 {
5901  CNode* n = new(heap) CNode( loc, eEDGE );
5902  n->Arg<CNode*>(0) = a0;
5903  n->Arg<Edge_t>(1) = a1;
5904  return n;
5905 }
5915 inline CNode* cEVOR( CNode* a0, CNode* a1, Coord_t* loc=NULL )
5916 {
5917  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eEVOR );
5918  n->Arg<CNode*>(0) = a0;
5919  n->Arg<CNode*>(1) = a1;
5920  return n;
5921 }
5932 inline CNode* cEVOR( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
5933 {
5934  CNode* n = new(heap) CNode( loc, eEVOR );
5935  n->Arg<CNode*>(0) = a0;
5936  n->Arg<CNode*>(1) = a1;
5937  return n;
5938 }
5948 inline CNode* cDELAY( CNode* a0, CNode* a1, Coord_t* loc=NULL )
5949 {
5950  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eDELAY );
5951  n->Arg<CNode*>(0) = a0;
5952  n->Arg<CNode*>(1) = a1;
5953  return n;
5954 }
5965 inline CNode* cDELAY( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
5966 {
5967  CNode* n = new(heap) CNode( loc, eDELAY );
5968  n->Arg<CNode*>(0) = a0;
5969  n->Arg<CNode*>(1) = a1;
5970  return n;
5971 }
5982 inline CNode* cMTM( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
5983 {
5984  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eMTM );
5985  n->Arg<CNode*>(0) = a0;
5986  n->Arg<CNode*>(1) = a1;
5987  n->Arg<CNode*>(2) = a2;
5988  return n;
5989 }
6001 inline CNode* cMTM( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
6002 {
6003  CNode* n = new(heap) CNode( loc, eMTM );
6004  n->Arg<CNode*>(0) = a0;
6005  n->Arg<CNode*>(1) = a1;
6006  n->Arg<CNode*>(2) = a2;
6007  return n;
6008 }
6019 inline CNode* cIF( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
6020 {
6021  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eIF );
6022  n->Arg<CNode*>(0) = a0;
6023  n->Arg<CNode*>(1) = a1;
6024  n->Arg<CNode*>(2) = a2;
6025  return n;
6026 }
6038 inline CNode* cIF( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
6039 {
6040  CNode* n = new(heap) CNode( loc, eIF );
6041  n->Arg<CNode*>(0) = a0;
6042  n->Arg<CNode*>(1) = a1;
6043  n->Arg<CNode*>(2) = a2;
6044  return n;
6045 }
6054 inline CNode* cFOREVER( CNode* a0, Coord_t* loc=NULL )
6055 {
6056  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eFOREVER );
6057  n->Arg<CNode*>(0) = a0;
6058  return n;
6059 }
6069 inline CNode* cFOREVER( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
6070 {
6071  CNode* n = new(heap) CNode( loc, eFOREVER );
6072  n->Arg<CNode*>(0) = a0;
6073  return n;
6074 }
6084 inline CNode* cREPEAT( CNode* a0, CNode* a1, Coord_t* loc=NULL )
6085 {
6086  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eREPEAT );
6087  n->Arg<CNode*>(0) = a0;
6088  n->Arg<CNode*>(1) = a1;
6089  return n;
6090 }
6101 inline CNode* cREPEAT( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
6102 {
6103  CNode* n = new(heap) CNode( loc, eREPEAT );
6104  n->Arg<CNode*>(0) = a0;
6105  n->Arg<CNode*>(1) = a1;
6106  return n;
6107 }
6117 inline CNode* cWHILE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
6118 {
6119  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eWHILE );
6120  n->Arg<CNode*>(0) = a0;
6121  n->Arg<CNode*>(1) = a1;
6122  return n;
6123 }
6134 inline CNode* cWHILE( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
6135 {
6136  CNode* n = new(heap) CNode( loc, eWHILE );
6137  n->Arg<CNode*>(0) = a0;
6138  n->Arg<CNode*>(1) = a1;
6139  return n;
6140 }
6150 inline CNode* cWAIT( CNode* a0, CNode* a1, Coord_t* loc=NULL )
6151 {
6152  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eWAIT );
6153  n->Arg<CNode*>(0) = a0;
6154  n->Arg<CNode*>(1) = a1;
6155  return n;
6156 }
6167 inline CNode* cWAIT( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
6168 {
6169  CNode* n = new(heap) CNode( loc, eWAIT );
6170  n->Arg<CNode*>(0) = a0;
6171  n->Arg<CNode*>(1) = a1;
6172  return n;
6173 }
6185 inline CNode* cFOR( CNode* a0, CNode* a1, CNode* a2, CNode* a3, Coord_t* loc=NULL )
6186 {
6187  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eFOR );
6188  n->Arg<CNode*>(0) = a0;
6189  n->Arg<CNode*>(1) = a1;
6190  n->Arg<CNode*>(2) = a2;
6191  n->Arg<CNode*>(3) = a3;
6192  return n;
6193 }
6206 inline CNode* cFOR( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, CNode* a3, Coord_t* loc=NULL )
6207 {
6208  CNode* n = new(heap) CNode( loc, eFOR );
6209  n->Arg<CNode*>(0) = a0;
6210  n->Arg<CNode*>(1) = a1;
6211  n->Arg<CNode*>(2) = a2;
6212  n->Arg<CNode*>(3) = a3;
6213  return n;
6214 }
6224 inline CNode* cCASE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
6225 {
6226  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCASE );
6227  n->Arg<CNode*>(0) = a0;
6228  n->Arg<CNode*>(1) = a1;
6229  return n;
6230 }
6241 inline CNode* cCASE( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
6242 {
6243  CNode* n = new(heap) CNode( loc, eCASE );
6244  n->Arg<CNode*>(0) = a0;
6245  n->Arg<CNode*>(1) = a1;
6246  return n;
6247 }
6257 inline CNode* cCASEX( CNode* a0, CNode* a1, Coord_t* loc=NULL )
6258 {
6259  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCASEX );
6260  n->Arg<CNode*>(0) = a0;
6261  n->Arg<CNode*>(1) = a1;
6262  return n;
6263 }
6274 inline CNode* cCASEX( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
6275 {
6276  CNode* n = new(heap) CNode( loc, eCASEX );
6277  n->Arg<CNode*>(0) = a0;
6278  n->Arg<CNode*>(1) = a1;
6279  return n;
6280 }
6290 inline CNode* cCASEZ( CNode* a0, CNode* a1, Coord_t* loc=NULL )
6291 {
6292  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCASEZ );
6293  n->Arg<CNode*>(0) = a0;
6294  n->Arg<CNode*>(1) = a1;
6295  return n;
6296 }
6307 inline CNode* cCASEZ( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
6308 {
6309  CNode* n = new(heap) CNode( loc, eCASEZ );
6310  n->Arg<CNode*>(0) = a0;
6311  n->Arg<CNode*>(1) = a1;
6312  return n;
6313 }
6323 inline CNode* cCASEITEM( CNode* a0, CNode* a1, Coord_t* loc=NULL )
6324 {
6325  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCASEITEM );
6326  n->Arg<CNode*>(0) = a0;
6327  n->Arg<CNode*>(1) = a1;
6328  return n;
6329 }
6340 inline CNode* cCASEITEM( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
6341 {
6342  CNode* n = new(heap) CNode( loc, eCASEITEM );
6343  n->Arg<CNode*>(0) = a0;
6344  n->Arg<CNode*>(1) = a1;
6345  return n;
6346 }
6358 inline CNode* cCASSIGN( StrengthPair_t* a0, CNode* a1, CNode* a2, CNode* a3, Coord_t* loc=NULL )
6359 {
6360  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCASSIGN );
6361  n->Arg<StrengthPair_t*>(0) = a0;
6362  n->Arg<CNode*>(1) = a1;
6363  n->Arg<CNode*>(2) = a2;
6364  n->Arg<CNode*>(3) = a3;
6365  return n;
6366 }
6379 inline CNode* cCASSIGN( CObstack* heap, StrengthPair_t* a0, CNode* a1, CNode* a2, CNode* a3, Coord_t* loc=NULL )
6380 {
6381  CNode* n = new(heap) CNode( loc, eCASSIGN );
6382  n->Arg<StrengthPair_t*>(0) = a0;
6383  n->Arg<CNode*>(1) = a1;
6384  n->Arg<CNode*>(2) = a2;
6385  n->Arg<CNode*>(3) = a3;
6386  return n;
6387 }
6397 inline CNode* cARG( CSymbol* a0, CNode* a1, Coord_t* loc=NULL )
6398 {
6399  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eARG );
6400  n->Arg<CSymbol*>(0) = a0;
6401  n->Arg<CNode*>(1) = a1;
6402  return n;
6403 }
6414 inline CNode* cARG( CObstack* heap, CSymbol* a0, CNode* a1, Coord_t* loc=NULL )
6415 {
6416  CNode* n = new(heap) CNode( loc, eARG );
6417  n->Arg<CSymbol*>(0) = a0;
6418  n->Arg<CNode*>(1) = a1;
6419  return n;
6420 }
6429 inline CNode* cIMPORT( CSymbol* a0, Coord_t* loc=NULL )
6430 {
6431  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eIMPORT );
6432  n->Arg<CSymbol*>(0) = a0;
6433  return n;
6434 }
6444 inline CNode* cIMPORT( CObstack* heap, CSymbol* a0, Coord_t* loc=NULL )
6445 {
6446  CNode* n = new(heap) CNode( loc, eIMPORT );
6447  n->Arg<CSymbol*>(0) = a0;
6448  return n;
6449 }
6458 inline CNode* cFUNCTION_DEF( CFunction* a0, Coord_t* loc=NULL )
6459 {
6460  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eFUNCTION_DEF );
6461  n->Arg<CFunction*>(0) = a0;
6462  return n;
6463 }
6473 inline CNode* cFUNCTION_DEF( CObstack* heap, CFunction* a0, Coord_t* loc=NULL )
6474 {
6475  CNode* n = new(heap) CNode( loc, eFUNCTION_DEF );
6476  n->Arg<CFunction*>(0) = a0;
6477  return n;
6478 }
6487 inline CNode* cMODULE_DEF( CModule* a0, Coord_t* loc=NULL )
6488 {
6489  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eMODULE_DEF );
6490  n->Arg<CModule*>(0) = a0;
6491  return n;
6492 }
6502 inline CNode* cMODULE_DEF( CObstack* heap, CModule* a0, Coord_t* loc=NULL )
6503 {
6504  CNode* n = new(heap) CNode( loc, eMODULE_DEF );
6505  n->Arg<CModule*>(0) = a0;
6506  return n;
6507 }
6516 inline CNode* cPACKAGE_DEF( CPackage* a0, Coord_t* loc=NULL )
6517 {
6518  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePACKAGE_DEF );
6519  n->Arg<CPackage*>(0) = a0;
6520  return n;
6521 }
6531 inline CNode* cPACKAGE_DEF( CObstack* heap, CPackage* a0, Coord_t* loc=NULL )
6532 {
6533  CNode* n = new(heap) CNode( loc, ePACKAGE_DEF );
6534  n->Arg<CPackage*>(0) = a0;
6535  return n;
6536 }
6546 inline CNode* cREPEAT_CONTROL( CNode* a0, CNode* a1, Coord_t* loc=NULL )
6547 {
6548  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eREPEAT_CONTROL );
6549  n->Arg<CNode*>(0) = a0;
6550  n->Arg<CNode*>(1) = a1;
6551  return n;
6552 }
6563 inline CNode* cREPEAT_CONTROL( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
6564 {
6565  CNode* n = new(heap) CNode( loc, eREPEAT_CONTROL );
6566  n->Arg<CNode*>(0) = a0;
6567  n->Arg<CNode*>(1) = a1;
6568  return n;
6569 }
6578 inline CNode* cDELAY_CONTROL( CNode* a0, Coord_t* loc=NULL )
6579 {
6580  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eDELAY_CONTROL );
6581  n->Arg<CNode*>(0) = a0;
6582  return n;
6583 }
6593 inline CNode* cDELAY_CONTROL( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
6594 {
6595  CNode* n = new(heap) CNode( loc, eDELAY_CONTROL );
6596  n->Arg<CNode*>(0) = a0;
6597  return n;
6598 }
6607 inline CNode* cEVENT_CONTROL( CNode* a0, Coord_t* loc=NULL )
6608 {
6609  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eEVENT_CONTROL );
6610  n->Arg<CNode*>(0) = a0;
6611  return n;
6612 }
6622 inline CNode* cEVENT_CONTROL( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
6623 {
6624  CNode* n = new(heap) CNode( loc, eEVENT_CONTROL );
6625  n->Arg<CNode*>(0) = a0;
6626  return n;
6627 }
6636 inline CNode* cEXTERNAL_REF( CSymbol* a0, Coord_t* loc=NULL )
6637 {
6638  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eEXTERNAL_REF );
6639  n->Arg<CSymbol*>(0) = a0;
6640  return n;
6641 }
6651 inline CNode* cEXTERNAL_REF( CObstack* heap, CSymbol* a0, Coord_t* loc=NULL )
6652 {
6653  CNode* n = new(heap) CNode( loc, eEXTERNAL_REF );
6654  n->Arg<CSymbol*>(0) = a0;
6655  return n;
6656 }
6665 inline CNode* cPORT_DEF( CPort* a0, Coord_t* loc=NULL )
6666 {
6667  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePORT_DEF );
6668  n->Arg<CPort*>(0) = a0;
6669  return n;
6670 }
6680 inline CNode* cPORT_DEF( CObstack* heap, CPort* a0, Coord_t* loc=NULL )
6681 {
6682  CNode* n = new(heap) CNode( loc, ePORT_DEF );
6683  n->Arg<CPort*>(0) = a0;
6684  return n;
6685 }
6695 inline CNode* cDEFPARAM( CNode* a0, CNode* a1, Coord_t* loc=NULL )
6696 {
6697  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eDEFPARAM );
6698  n->Arg<CNode*>(0) = a0;
6699  n->Arg<CNode*>(1) = a1;
6700  return n;
6701 }
6712 inline CNode* cDEFPARAM( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
6713 {
6714  CNode* n = new(heap) CNode( loc, eDEFPARAM );
6715  n->Arg<CNode*>(0) = a0;
6716  n->Arg<CNode*>(1) = a1;
6717  return n;
6718 }
6733 inline CNode* cPATH( int a0, CNode* a1, int a2, int a3, CNode* a4, int a5, CNode* a6, Coord_t* loc=NULL )
6734 {
6735  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePATH );
6736  n->Arg<int>(0) = a0;
6737  n->Arg<CNode*>(1) = a1;
6738  n->Arg<int>(2) = a2;
6739  n->Arg<int>(3) = a3;
6740  n->Arg<CNode*>(4) = a4;
6741  n->Arg<int>(5) = a5;
6742  n->Arg<CNode*>(6) = a6;
6743  return n;
6744 }
6760 inline CNode* cPATH( CObstack* heap, int a0, CNode* a1, int a2, int a3, CNode* a4, int a5, CNode* a6, Coord_t* loc=NULL )
6761 {
6762  CNode* n = new(heap) CNode( loc, ePATH );
6763  n->Arg<int>(0) = a0;
6764  n->Arg<CNode*>(1) = a1;
6765  n->Arg<int>(2) = a2;
6766  n->Arg<int>(3) = a3;
6767  n->Arg<CNode*>(4) = a4;
6768  n->Arg<int>(5) = a5;
6769  n->Arg<CNode*>(6) = a6;
6770  return n;
6771 }
6782 inline CNode* cPATH_ASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
6783 {
6784  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePATH_ASSIGN );
6785  n->Arg<CNode*>(0) = a0;
6786  n->Arg<CNode*>(1) = a1;
6787  n->Arg<CNode*>(2) = a2;
6788  return n;
6789 }
6801 inline CNode* cPATH_ASSIGN( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
6802 {
6803  CNode* n = new(heap) CNode( loc, ePATH_ASSIGN );
6804  n->Arg<CNode*>(0) = a0;
6805  n->Arg<CNode*>(1) = a1;
6806  n->Arg<CNode*>(2) = a2;
6807  return n;
6808 }
6818 inline CNode* cIFNONE_PATH_ASSIGN( CNode* a0, CNode* a1, Coord_t* loc=NULL )
6819 {
6820  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eIFNONE_PATH_ASSIGN );
6821  n->Arg<CNode*>(0) = a0;
6822  n->Arg<CNode*>(1) = a1;
6823  return n;
6824 }
6835 inline CNode* cIFNONE_PATH_ASSIGN( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
6836 {
6837  CNode* n = new(heap) CNode( loc, eIFNONE_PATH_ASSIGN );
6838  n->Arg<CNode*>(0) = a0;
6839  n->Arg<CNode*>(1) = a1;
6840  return n;
6841 }
6850 inline CNode* cTRIGGER( CNode* a0, Coord_t* loc=NULL )
6851 {
6852  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eTRIGGER );
6853  n->Arg<CNode*>(0) = a0;
6854  return n;
6855 }
6865 inline CNode* cTRIGGER( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
6866 {
6867  CNode* n = new(heap) CNode( loc, eTRIGGER );
6868  n->Arg<CNode*>(0) = a0;
6869  return n;
6870 }
6880 inline CNode* cPASSIGN( CNode* a0, CNode* a1, Coord_t* loc=NULL )
6881 {
6882  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePASSIGN );
6883  n->Arg<CNode*>(0) = a0;
6884  n->Arg<CNode*>(1) = a1;
6885  return n;
6886 }
6897 inline CNode* cPASSIGN( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
6898 {
6899  CNode* n = new(heap) CNode( loc, ePASSIGN );
6900  n->Arg<CNode*>(0) = a0;
6901  n->Arg<CNode*>(1) = a1;
6902  return n;
6903 }
6912 inline CNode* cDEASSIGN( CNode* a0, Coord_t* loc=NULL )
6913 {
6914  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eDEASSIGN );
6915  n->Arg<CNode*>(0) = a0;
6916  return n;
6917 }
6927 inline CNode* cDEASSIGN( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
6928 {
6929  CNode* n = new(heap) CNode( loc, eDEASSIGN );
6930  n->Arg<CNode*>(0) = a0;
6931  return n;
6932 }
6941 inline CNode* cDISABLE( CSymbol* a0, Coord_t* loc=NULL )
6942 {
6943  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eDISABLE );
6944  n->Arg<CSymbol*>(0) = a0;
6945  return n;
6946 }
6956 inline CNode* cDISABLE( CObstack* heap, CSymbol* a0, Coord_t* loc=NULL )
6957 {
6958  CNode* n = new(heap) CNode( loc, eDISABLE );
6959  n->Arg<CSymbol*>(0) = a0;
6960  return n;
6961 }
6970 inline CNode* cATTRIBUTE( CAttr* a0, Coord_t* loc=NULL )
6971 {
6972  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eATTRIBUTE );
6973  n->Arg<CAttr*>(0) = a0;
6974  return n;
6975 }
6985 inline CNode* cATTRIBUTE( CObstack* heap, CAttr* a0, Coord_t* loc=NULL )
6986 {
6987  CNode* n = new(heap) CNode( loc, eATTRIBUTE );
6988  n->Arg<CAttr*>(0) = a0;
6989  return n;
6990 }
7001 inline CNode* cGIF( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
7002 {
7003  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eGIF );
7004  n->Arg<CNode*>(0) = a0;
7005  n->Arg<CNode*>(1) = a1;
7006  n->Arg<CNode*>(2) = a2;
7007  return n;
7008 }
7020 inline CNode* cGIF( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
7021 {
7022  CNode* n = new(heap) CNode( loc, eGIF );
7023  n->Arg<CNode*>(0) = a0;
7024  n->Arg<CNode*>(1) = a1;
7025  n->Arg<CNode*>(2) = a2;
7026  return n;
7027 }
7039 inline CNode* cGFOR( CNode* a0, CNode* a1, CNode* a2, CNode* a3, Coord_t* loc=NULL )
7040 {
7041  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eGFOR );
7042  n->Arg<CNode*>(0) = a0;
7043  n->Arg<CNode*>(1) = a1;
7044  n->Arg<CNode*>(2) = a2;
7045  n->Arg<CNode*>(3) = a3;
7046  return n;
7047 }
7060 inline CNode* cGFOR( CObstack* heap, CNode* a0, CNode* a1, CNode* a2, CNode* a3, Coord_t* loc=NULL )
7061 {
7062  CNode* n = new(heap) CNode( loc, eGFOR );
7063  n->Arg<CNode*>(0) = a0;
7064  n->Arg<CNode*>(1) = a1;
7065  n->Arg<CNode*>(2) = a2;
7066  n->Arg<CNode*>(3) = a3;
7067  return n;
7068 }
7078 inline CNode* cGCASE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
7079 {
7080  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eGCASE );
7081  n->Arg<CNode*>(0) = a0;
7082  n->Arg<CNode*>(1) = a1;
7083  return n;
7084 }
7095 inline CNode* cGCASE( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
7096 {
7097  CNode* n = new(heap) CNode( loc, eGCASE );
7098  n->Arg<CNode*>(0) = a0;
7099  n->Arg<CNode*>(1) = a1;
7100  return n;
7101 }
7110 inline CNode* cTABLE( CNode* a0, Coord_t* loc=NULL )
7111 {
7112  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eTABLE );
7113  n->Arg<CNode*>(0) = a0;
7114  return n;
7115 }
7125 inline CNode* cTABLE( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
7126 {
7127  CNode* n = new(heap) CNode( loc, eTABLE );
7128  n->Arg<CNode*>(0) = a0;
7129  return n;
7130 }
7139 inline CNode* cTABLE_ENTRY( CNode* a0, Coord_t* loc=NULL )
7140 {
7141  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eTABLE_ENTRY );
7142  n->Arg<CNode*>(0) = a0;
7143  return n;
7144 }
7154 inline CNode* cTABLE_ENTRY( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
7155 {
7156  CNode* n = new(heap) CNode( loc, eTABLE_ENTRY );
7157  n->Arg<CNode*>(0) = a0;
7158  return n;
7159 }
7168 inline CNode* cTABLE_SYMBOL( char* a0, Coord_t* loc=NULL )
7169 {
7170  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eTABLE_SYMBOL );
7171  n->Arg<char*>(0) = a0;
7172  return n;
7173 }
7183 inline CNode* cTABLE_SYMBOL( CObstack* heap, char* a0, Coord_t* loc=NULL )
7184 {
7185  CNode* n = new(heap) CNode( loc, eTABLE_SYMBOL );
7186  n->Arg<char*>(0) = a0;
7187  return n;
7188 }
7196 inline CNode* cPORTLIST_END( Coord_t* loc=NULL )
7197 {
7198  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePORTLIST_END );
7199  return n;
7200 }
7209 inline CNode* cPORTLIST_END( CObstack* heap, Coord_t* loc=NULL )
7210 {
7211  CNode* n = new(heap) CNode( loc, ePORTLIST_END );
7212  return n;
7213 }
7223 inline CNode* cMACRO_EXPR( const char* a0, CNode* a1, Coord_t* loc=NULL )
7224 {
7225  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eMACRO_EXPR );
7226  n->Arg<const char*>(0) = a0;
7227  n->Arg<CNode*>(1) = a1;
7228  return n;
7229 }
7240 inline CNode* cMACRO_EXPR( CObstack* heap, const char* a0, CNode* a1, Coord_t* loc=NULL )
7241 {
7242  CNode* n = new(heap) CNode( loc, eMACRO_EXPR );
7243  n->Arg<const char*>(0) = a0;
7244  n->Arg<CNode*>(1) = a1;
7245  return n;
7246 }
7257 inline CNode* cENUM_SPEC( CSymbol* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
7258 {
7259  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eENUM_SPEC );
7260  n->Arg<CSymbol*>(0) = a0;
7261  n->Arg<CNode*>(1) = a1;
7262  n->Arg<CNode*>(2) = a2;
7263  return n;
7264 }
7276 inline CNode* cENUM_SPEC( CObstack* heap, CSymbol* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
7277 {
7278  CNode* n = new(heap) CNode( loc, eENUM_SPEC );
7279  n->Arg<CSymbol*>(0) = a0;
7280  n->Arg<CNode*>(1) = a1;
7281  n->Arg<CNode*>(2) = a2;
7282  return n;
7283 }
7293 inline CNode* cMEMBER( CNode* a0, CSymbol* a1, Coord_t* loc=NULL )
7294 {
7295  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eMEMBER );
7296  n->Arg<CNode*>(0) = a0;
7297  n->Arg<CSymbol*>(1) = a1;
7298  return n;
7299 }
7310 inline CNode* cMEMBER( CObstack* heap, CNode* a0, CSymbol* a1, Coord_t* loc=NULL )
7311 {
7312  CNode* n = new(heap) CNode( loc, eMEMBER );
7313  n->Arg<CNode*>(0) = a0;
7314  n->Arg<CSymbol*>(1) = a1;
7315  return n;
7316 }
7325 inline CNode* cRETURN( CNode* a0, Coord_t* loc=NULL )
7326 {
7327  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRETURN );
7328  n->Arg<CNode*>(0) = a0;
7329  return n;
7330 }
7340 inline CNode* cRETURN( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
7341 {
7342  CNode* n = new(heap) CNode( loc, eRETURN );
7343  n->Arg<CNode*>(0) = a0;
7344  return n;
7345 }
7354 inline CNode* cPREINC( CNode* a0, Coord_t* loc=NULL )
7355 {
7356  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePREINC );
7357  n->Arg<CNode*>(0) = a0;
7358  return n;
7359 }
7369 inline CNode* cPREINC( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
7370 {
7371  CNode* n = new(heap) CNode( loc, ePREINC );
7372  n->Arg<CNode*>(0) = a0;
7373  return n;
7374 }
7383 inline CNode* cPOSTINC( CNode* a0, Coord_t* loc=NULL )
7384 {
7385  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePOSTINC );
7386  n->Arg<CNode*>(0) = a0;
7387  return n;
7388 }
7398 inline CNode* cPOSTINC( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
7399 {
7400  CNode* n = new(heap) CNode( loc, ePOSTINC );
7401  n->Arg<CNode*>(0) = a0;
7402  return n;
7403 }
7412 inline CNode* cPREDEC( CNode* a0, Coord_t* loc=NULL )
7413 {
7414  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePREDEC );
7415  n->Arg<CNode*>(0) = a0;
7416  return n;
7417 }
7427 inline CNode* cPREDEC( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
7428 {
7429  CNode* n = new(heap) CNode( loc, ePREDEC );
7430  n->Arg<CNode*>(0) = a0;
7431  return n;
7432 }
7441 inline CNode* cPOSTDEC( CNode* a0, Coord_t* loc=NULL )
7442 {
7443  CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePOSTDEC );
7444  n->Arg<CNode*>(0) = a0;
7445  return n;
7446 }
7456 inline CNode* cPOSTDEC( CObstack* heap, CNode* a0, Coord_t* loc=NULL )
7457 {
7458  CNode* n = new(heap) CNode( loc, ePOSTDEC );
7459  n->Arg<CNode*>(0) = a0;
7460  return n;
7461 }
7471 inline CNode* cCAST( CNode* a0, CNode* a1, Coord_t* loc=NULL )
7472 {
7473  CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCAST );
7474  n->Arg<CNode*>(0) = a0;
7475  n->Arg<CNode*>(1) = a1;
7476  return n;
7477 }
7488 inline CNode* cCAST( CObstack* heap, CNode* a0, CNode* a1, Coord_t* loc=NULL )
7489 {
7490  CNode* n = new(heap) CNode( loc, eCAST );
7491  n->Arg<CNode*>(0) = a0;
7492  n->Arg<CNode*>(1) = a1;
7493  return n;
7494 }
7495 #endif // DEFINE_CONSTUCTOR
7496 
7497 
7498 /*********************************************************
7499  * Warning: This file is machine generate, do not edit
7500  ********************************************************/
7501 
7502 
7503 
7504 
7505 #ifdef DEFINE_METHODS
7506 
7507 /************************************
7508  * ArgCount
7509  * - return number of arguments for node
7510  ***********************************/
7512 {
7513  switch( op ) {
7514  case eERROR:
7515  return 0;
7516  case eVCONSTANT:
7517  return 1;
7518  case eRCONSTANT:
7519  return 1;
7520  case eCOMMENT:
7521  return 1;
7522  case eVRQ:
7523  return 1;
7524  case ePRAGMA:
7525  return 1;
7526  case eELIST:
7527  return 2;
7528  case eWIDTH:
7529  return 2;
7530  case eNOP:
7531  return 0;
7532  case eSUB:
7533  return 2;
7534  case eMUL:
7535  return 2;
7536  case eDIV:
7537  return 2;
7538  case ePOW:
7539  return 2;
7540  case eADD:
7541  return 2;
7542  case eLSH:
7543  return 2;
7544  case eRSH:
7545  return 2;
7546  case eLSHA:
7547  return 2;
7548  case eRSHA:
7549  return 2;
7550  case eMOD:
7551  return 2;
7552  case eOR:
7553  return 2;
7554  case eAND:
7555  return 2;
7556  case eANDANDAND:
7557  return 2;
7558  case eXOR:
7559  return 2;
7560  case eXNOR:
7561  return 2;
7562  case eINSTANCE_REF:
7563  return 1;
7564  case eGATE_REF:
7565  return 1;
7566  case eTASK_ENABLE:
7567  return 2;
7568  case eSYSTASK_CALL:
7569  return 2;
7570  case eTIMING_CALL:
7571  return 2;
7572  case eFUNCTION_CALL:
7573  return 3;
7574  case eARRAY:
7575  return 2;
7576  case eNET_REF:
7577  return 1;
7578  case eVAR_REF:
7579  return 1;
7580  case ePARAM_REF:
7581  return 1;
7582  case ePORT_REF:
7583  return 1;
7584  case eFWD_REF:
7585  return 1;
7586  case eGENVAR_REF:
7587  return 1;
7588  case eENUM_REF:
7589  return 1;
7590  case eTYPE_REF:
7591  return 1;
7592  case eNET_DECL:
7593  return 2;
7594  case eVAR_DECL:
7595  return 2;
7596  case ePARAM_DECL:
7597  return 1;
7598  case eSPECPARAM_DECL:
7599  return 1;
7600  case ePORT_DECL:
7601  return 1;
7602  case eGENVAR_DECL:
7603  return 1;
7604  case eTYPEDEF_DECL:
7605  return 1;
7606  case eLIST:
7607  return 2;
7608  case eRANGE:
7609  return 2;
7610  case eSLICE:
7611  return 2;
7612  case ePSLICE:
7613  return 2;
7614  case eMSLICE:
7615  return 2;
7616  case eCVRI:
7617  return 1;
7618  case eCVIR:
7619  return 1;
7620  case eREP:
7621  return 2;
7622  case eCAT:
7623  return 2;
7624  case eUCAT:
7625  return 1;
7626  case eCOM:
7627  return 1;
7628  case eNEG:
7629  return 1;
7630  case ePLUS:
7631  return 1;
7632  case eNOT:
7633  return 1;
7634  case eGT:
7635  return 2;
7636  case eGE:
7637  return 2;
7638  case eLT:
7639  return 2;
7640  case eLE:
7641  return 2;
7642  case eLAND:
7643  return 2;
7644  case eLOR:
7645  return 2;
7646  case eCEQ:
7647  return 2;
7648  case eCNE:
7649  return 2;
7650  case eEQ:
7651  return 2;
7652  case eNE:
7653  return 2;
7654  case eRAND:
7655  return 1;
7656  case eRNAND:
7657  return 1;
7658  case eROR:
7659  return 1;
7660  case eRNOR:
7661  return 1;
7662  case eRXOR:
7663  return 1;
7664  case eRXNOR:
7665  return 1;
7666  case eHOOK:
7667  return 3;
7668  case eINIT:
7669  return 1;
7670  case eALWAYS:
7671  return 1;
7672  case eALWAYS_LATCH:
7673  return 1;
7674  case eALWAYS_FF:
7675  return 1;
7676  case eALWAYS_COMB:
7677  return 1;
7678  case eEVENT:
7679  return 2;
7680  case eBLOCK_REF:
7681  return 2;
7682  case eSPECIFY_REF:
7683  return 2;
7684  case eASSIGN:
7685  return 3;
7686  case eADD_ASSIGN:
7687  return 3;
7688  case eSUB_ASSIGN:
7689  return 3;
7690  case eMUL_ASSIGN:
7691  return 3;
7692  case eDIV_ASSIGN:
7693  return 3;
7694  case eMOD_ASSIGN:
7695  return 3;
7696  case eAND_ASSIGN:
7697  return 3;
7698  case eOR_ASSIGN:
7699  return 3;
7700  case eXOR_ASSIGN:
7701  return 3;
7702  case eLSH_ASSIGN:
7703  return 3;
7704  case eRSH_ASSIGN:
7705  return 3;
7706  case eLSHA_ASSIGN:
7707  return 3;
7708  case eRSHA_ASSIGN:
7709  return 3;
7710  case eFORCE:
7711  return 2;
7712  case eRELEASE:
7713  return 1;
7714  case eNBASSIGN:
7715  return 3;
7716  case ePOSEDGE:
7717  return 1;
7718  case eNEGEDGE:
7719  return 1;
7720  case eEDGE:
7721  return 2;
7722  case eEVOR:
7723  return 2;
7724  case eDELAY:
7725  return 2;
7726  case eMTM:
7727  return 3;
7728  case eIF:
7729  return 3;
7730  case eFOREVER:
7731  return 1;
7732  case eREPEAT:
7733  return 2;
7734  case eWHILE:
7735  return 2;
7736  case eWAIT:
7737  return 2;
7738  case eFOR:
7739  return 4;
7740  case eCASE:
7741  return 2;
7742  case eCASEX:
7743  return 2;
7744  case eCASEZ:
7745  return 2;
7746  case eCASEITEM:
7747  return 2;
7748  case eCASSIGN:
7749  return 4;
7750  case eARG:
7751  return 2;
7752  case eIMPORT:
7753  return 1;
7754  case eFUNCTION_DEF:
7755  return 1;
7756  case eMODULE_DEF:
7757  return 1;
7758  case ePACKAGE_DEF:
7759  return 1;
7760  case eREPEAT_CONTROL:
7761  return 2;
7762  case eDELAY_CONTROL:
7763  return 1;
7764  case eEVENT_CONTROL:
7765  return 1;
7766  case eEXTERNAL_REF:
7767  return 1;
7768  case ePORT_DEF:
7769  return 1;
7770  case eDEFPARAM:
7771  return 2;
7772  case ePATH:
7773  return 7;
7774  case ePATH_ASSIGN:
7775  return 3;
7776  case eIFNONE_PATH_ASSIGN:
7777  return 2;
7778  case eTRIGGER:
7779  return 1;
7780  case ePASSIGN:
7781  return 2;
7782  case eDEASSIGN:
7783  return 1;
7784  case eDISABLE:
7785  return 1;
7786  case eATTRIBUTE:
7787  return 1;
7788  case eGIF:
7789  return 3;
7790  case eGFOR:
7791  return 4;
7792  case eGCASE:
7793  return 2;
7794  case eTABLE:
7795  return 1;
7796  case eTABLE_ENTRY:
7797  return 1;
7798  case eTABLE_SYMBOL:
7799  return 1;
7800  case ePORTLIST_END:
7801  return 0;
7802  case eMACRO_EXPR:
7803  return 2;
7804  case eENUM_SPEC:
7805  return 3;
7806  case eMEMBER:
7807  return 2;
7808  case eRETURN:
7809  return 1;
7810  case ePREINC:
7811  return 1;
7812  case ePOSTINC:
7813  return 1;
7814  case ePREDEC:
7815  return 1;
7816  case ePOSTDEC:
7817  return 1;
7818  case eCAST:
7819  return 2;
7820  default:
7821  MASSERT(FALSE);
7822  }
7823  return 0;
7824 }
7825 
7826 /************************************
7827  * Precedence
7828  * - return precedence of operator
7829  * result 0 - 13
7830  ***********************************/
7832 {
7833  switch( op ) {
7834  case eERROR:
7835  return 13;
7836  case eVCONSTANT:
7837  return 13;
7838  case eRCONSTANT:
7839  return 13;
7840  case eCOMMENT:
7841  return 13;
7842  case eVRQ:
7843  return 13;
7844  case ePRAGMA:
7845  return 13;
7846  case eELIST:
7847  return 13;
7848  case eWIDTH:
7849  return 13;
7850  case eSUB:
7851  return 9;
7852  case eMUL:
7853  return 10;
7854  case eDIV:
7855  return 10;
7856  case ePOW:
7857  return 11;
7858  case eADD:
7859  return 9;
7860  case eLSH:
7861  return 8;
7862  case eRSH:
7863  return 8;
7864  case eLSHA:
7865  return 8;
7866  case eRSHA:
7867  return 8;
7868  case eMOD:
7869  return 10;
7870  case eOR:
7871  return 3;
7872  case eAND:
7873  return 5;
7874  case eANDANDAND:
7875  return 0;
7876  case eXOR:
7877  return 4;
7878  case eXNOR:
7879  return 4;
7880  case eSYSTASK_CALL:
7881  return 13;
7882  case eFUNCTION_CALL:
7883  return 13;
7884  case eARRAY:
7885  return 13;
7886  case eNET_REF:
7887  return 13;
7888  case eVAR_REF:
7889  return 13;
7890  case ePARAM_REF:
7891  return 13;
7892  case ePORT_REF:
7893  return 13;
7894  case eFWD_REF:
7895  return 13;
7896  case eGENVAR_REF:
7897  return 13;
7898  case eENUM_REF:
7899  return 13;
7900  case eTYPE_REF:
7901  return 13;
7902  case eRANGE:
7903  return 13;
7904  case eSLICE:
7905  return 13;
7906  case ePSLICE:
7907  return 13;
7908  case eMSLICE:
7909  return 13;
7910  case eCVRI:
7911  return 13;
7912  case eCVIR:
7913  return 13;
7914  case eREP:
7915  return 13;
7916  case eCAT:
7917  return 13;
7918  case eUCAT:
7919  return 13;
7920  case eCOM:
7921  return 12;
7922  case eNEG:
7923  return 12;
7924  case ePLUS:
7925  return 12;
7926  case eNOT:
7927  return 12;
7928  case eGT:
7929  return 7;
7930  case eGE:
7931  return 7;
7932  case eLT:
7933  return 7;
7934  case eLE:
7935  return 7;
7936  case eLAND:
7937  return 2;
7938  case eLOR:
7939  return 1;
7940  case eCEQ:
7941  return 6;
7942  case eCNE:
7943  return 6;
7944  case eEQ:
7945  return 6;
7946  case eNE:
7947  return 6;
7948  case eRAND:
7949  return 12;
7950  case eRNAND:
7951  return 12;
7952  case eROR:
7953  return 12;
7954  case eRNOR:
7955  return 12;
7956  case eRXOR:
7957  return 12;
7958  case eRXNOR:
7959  return 12;
7960  case eHOOK:
7961  return 0;
7962  case ePOSEDGE:
7963  return 13;
7964  case eNEGEDGE:
7965  return 13;
7966  case eEDGE:
7967  return 13;
7968  case eEVOR:
7969  return 13;
7970  case eMTM:
7971  return 13;
7972  case eEXTERNAL_REF:
7973  return 13;
7974  case eMACRO_EXPR:
7975  return 13;
7976  case eMEMBER:
7977  return 13;
7978  case ePREINC:
7979  return 12;
7980  case ePOSTINC:
7981  return 12;
7982  case ePREDEC:
7983  return 12;
7984  case ePOSTDEC:
7985  return 12;
7986  case eCAST:
7987  return 13;
7988  default:
7989  MASSERT( FALSE );
7990  return 13;
7991  }
7992 }
7993 
7994 /************************************************
7995  IsConstant
7996  - return true if expression is constant
7997 **************************************************/
7998 
8000 {
8001  switch( op ) {
8002  case eERROR:
8003  return FALSE;
8004  case eVCONSTANT:
8005  return TRUE;
8006  case eRCONSTANT:
8007  return TRUE;
8008  case eCOMMENT:
8009  return TRUE;
8010  case eVRQ:
8011  return TRUE;
8012  case ePRAGMA:
8013  return TRUE;
8014  case eELIST:
8015  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8016  case eWIDTH:
8017  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8018  case eSUB:
8019  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8020  case eMUL:
8021  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8022  case eDIV:
8023  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8024  case ePOW:
8025  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8026  case eADD:
8027  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8028  case eLSH:
8029  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8030  case eRSH:
8031  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8032  case eLSHA:
8033  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8034  case eRSHA:
8035  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8036  case eMOD:
8037  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8038  case eOR:
8039  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8040  case eAND:
8041  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8042  case eANDANDAND:
8043  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8044  case eXOR:
8045  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8046  case eXNOR:
8047  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8048  case eSYSTASK_CALL:
8049  return TRUE;
8050  case eFUNCTION_CALL:
8051  return Arg<CNode*>(1)->IsConstant();
8052  case eARRAY:
8053  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8054  case eNET_REF:
8055  return FALSE;
8056  case eVAR_REF:
8057  return FALSE;
8058  case ePARAM_REF:
8059  return TRUE;
8060  case ePORT_REF:
8061  return FALSE;
8062  case eFWD_REF:
8063  return FALSE;
8064  case eGENVAR_REF:
8065  return TRUE;
8066  case eENUM_REF:
8067  return TRUE;
8068  case eTYPE_REF:
8069  return TRUE;
8070  case eRANGE:
8071  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8072  case eSLICE:
8073  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8074  case ePSLICE:
8075  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8076  case eMSLICE:
8077  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8078  case eCVRI:
8079  return Arg<CNode*>(0)->IsConstant();
8080  case eCVIR:
8081  return Arg<CNode*>(0)->IsConstant();
8082  case eREP:
8083  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8084  case eCAT:
8085  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8086  case eUCAT:
8087  return Arg<CNode*>(0)->IsConstant();
8088  case eCOM:
8089  return Arg<CNode*>(0)->IsConstant();
8090  case eNEG:
8091  return Arg<CNode*>(0)->IsConstant();
8092  case ePLUS:
8093  return Arg<CNode*>(0)->IsConstant();
8094  case eNOT:
8095  return Arg<CNode*>(0)->IsConstant();
8096  case eGT:
8097  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8098  case eGE:
8099  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8100  case eLT:
8101  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8102  case eLE:
8103  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8104  case eLAND:
8105  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8106  case eLOR:
8107  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8108  case eCEQ:
8109  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8110  case eCNE:
8111  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8112  case eEQ:
8113  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8114  case eNE:
8115  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8116  case eRAND:
8117  return Arg<CNode*>(0)->IsConstant();
8118  case eRNAND:
8119  return Arg<CNode*>(0)->IsConstant();
8120  case eROR:
8121  return Arg<CNode*>(0)->IsConstant();
8122  case eRNOR:
8123  return Arg<CNode*>(0)->IsConstant();
8124  case eRXOR:
8125  return Arg<CNode*>(0)->IsConstant();
8126  case eRXNOR:
8127  return Arg<CNode*>(0)->IsConstant();
8128  case eHOOK:
8129  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant() && Arg<CNode*>(2)->IsConstant();
8130  case eMTM:
8131  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant() && Arg<CNode*>(2)->IsConstant();
8132  case eEXTERNAL_REF:
8133  return FALSE;
8134  case eMACRO_EXPR:
8135  return TRUE;
8136  case eMEMBER:
8137  return Arg<CNode*>(0)->IsConstant();
8138  case ePREINC:
8139  return Arg<CNode*>(0)->IsConstant();
8140  case ePOSTINC:
8141  return Arg<CNode*>(0)->IsConstant();
8142  case ePREDEC:
8143  return Arg<CNode*>(0)->IsConstant();
8144  case ePOSTDEC:
8145  return Arg<CNode*>(0)->IsConstant();
8146  case eCAST:
8147  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8148  default:
8149  MASSERT( FALSE );
8150  }
8151 
8152  return TRUE;
8153 }
8154 
8155 /************************************************
8156  IsVolatile
8157  - return false if expression is constant
8158  and not dependent upon parameters
8159 **************************************************/
8160 
8162 {
8163  switch( op ) {
8164  case eERROR:
8165  return TRUE;
8166  case eVCONSTANT:
8167  return FALSE;
8168  case eRCONSTANT:
8169  return FALSE;
8170  case eCOMMENT:
8171  return FALSE;
8172  case eVRQ:
8173  return FALSE;
8174  case ePRAGMA:
8175  return FALSE;
8176  case eELIST:
8177  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8178  case eWIDTH:
8179  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8180  case eSUB:
8181  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8182  case eMUL:
8183  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8184  case eDIV:
8185  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8186  case ePOW:
8187  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8188  case eADD:
8189  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8190  case eLSH:
8191  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8192  case eRSH:
8193  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8194  case eLSHA:
8195  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8196  case eRSHA:
8197  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8198  case eMOD:
8199  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8200  case eOR:
8201  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8202  case eAND:
8203  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8204  case eANDANDAND:
8205  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8206  case eXOR:
8207  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8208  case eXNOR:
8209  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8210  case eSYSTASK_CALL:
8211  return TRUE;
8212  case eFUNCTION_CALL:
8213  return Arg<CNode*>(1)->IsVolatile();
8214  case eARRAY:
8215  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8216  case eNET_REF:
8217  return TRUE;
8218  case eVAR_REF:
8219  return TRUE;
8220  case ePARAM_REF:
8221  return TRUE;
8222  case ePORT_REF:
8223  return TRUE;
8224  case eFWD_REF:
8225  return TRUE;
8226  case eGENVAR_REF:
8227  return TRUE;
8228  case eENUM_REF:
8229  return Arg<CEnum*>(0)->GetExpression()->IsVolatile();
8230  case eTYPE_REF:
8231  return FALSE;
8232  case eRANGE:
8233  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8234  case eSLICE:
8235  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8236  case ePSLICE:
8237  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8238  case eMSLICE:
8239  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8240  case eCVRI:
8241  return Arg<CNode*>(0)->IsVolatile();
8242  case eCVIR:
8243  return Arg<CNode*>(0)->IsVolatile();
8244  case eREP:
8245  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8246  case eCAT:
8247  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8248  case eUCAT:
8249  return Arg<CNode*>(0)->IsVolatile();
8250  case eCOM:
8251  return Arg<CNode*>(0)->IsVolatile();
8252  case eNEG:
8253  return Arg<CNode*>(0)->IsVolatile();
8254  case ePLUS:
8255  return Arg<CNode*>(0)->IsVolatile();
8256  case eNOT:
8257  return Arg<CNode*>(0)->IsVolatile();
8258  case eGT:
8259  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8260  case eGE:
8261  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8262  case eLT:
8263  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8264  case eLE:
8265  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8266  case eLAND:
8267  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8268  case eLOR:
8269  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8270  case eCEQ:
8271  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8272  case eCNE:
8273  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8274  case eEQ:
8275  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8276  case eNE:
8277  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8278  case eRAND:
8279  return Arg<CNode*>(0)->IsVolatile();
8280  case eRNAND:
8281  return Arg<CNode*>(0)->IsVolatile();
8282  case eROR:
8283  return Arg<CNode*>(0)->IsVolatile();
8284  case eRNOR:
8285  return Arg<CNode*>(0)->IsVolatile();
8286  case eRXOR:
8287  return Arg<CNode*>(0)->IsVolatile();
8288  case eRXNOR:
8289  return Arg<CNode*>(0)->IsVolatile();
8290  case eHOOK:
8291  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile() || Arg<CNode*>(2)->IsVolatile();
8292  case eMTM:
8293  return TRUE;
8294  case eEXTERNAL_REF:
8295  return TRUE;
8296  case eMACRO_EXPR:
8297  return Arg<CNode*>(1) ? Arg<CNode*>(1)->IsVolatile() : TRUE;
8298  case eMEMBER:
8299  return Arg<CNode*>(0)->IsVolatile();
8300  case ePREINC:
8301  return Arg<CNode*>(0)->IsVolatile();
8302  case ePOSTINC:
8303  return Arg<CNode*>(0)->IsVolatile();
8304  case ePREDEC:
8305  return Arg<CNode*>(0)->IsVolatile();
8306  case ePOSTDEC:
8307  return Arg<CNode*>(0)->IsVolatile();
8308  case eCAST:
8309  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8310  default:
8311  MASSERT( FALSE );
8312  }
8313 
8314  return TRUE;
8315 }
8316 
8317 
8318 /************************************************
8319  IsWidthConstant
8320  - return true if expression has a constant width
8321 **************************************************/
8322 
8324 {
8325  switch( GetOp() ) {
8326  case eERROR:
8327  return TRUE;
8328  case eVCONSTANT:
8329  return Arg<CVector*>(0)->IsWidthConstant();
8330  case eRCONSTANT:
8331  return TRUE;
8332  case eELIST:
8333  return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
8334  case eWIDTH:
8335  return Arg<CNode*>(0)->IsConstant();
8336  case eSUB:
8337  return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
8338  case eMUL:
8339  return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
8340  case eDIV:
8341  return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
8342  case ePOW:
8343  return Arg<CNode*>(0)->IsWidthConstant();
8344  case eADD:
8345  return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
8346  case eLSH:
8347  return Arg<CNode*>(0)->IsWidthConstant();
8348  case eRSH:
8349  return Arg<CNode*>(0)->IsWidthConstant();
8350  case eLSHA:
8351  return Arg<CNode*>(0)->IsWidthConstant();
8352  case eRSHA:
8353  return Arg<CNode*>(0)->IsWidthConstant();
8354  case eMOD:
8355  return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
8356  case eOR:
8357  return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
8358  case eAND:
8359  return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
8360  case eANDANDAND:
8361  return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
8362  case eXOR:
8363  return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
8364  case eXNOR:
8365  return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
8366  case eSYSTASK_CALL:
8367  return Systask::WidthConstant(Arg<CSymbol*>(0),Arg<CNode*>(1));
8368  case eFUNCTION_CALL:
8369  return CFunction::WidthConstant(Arg<CSymbol*>(0),Arg<CNode*>(1),Arg<CScope*>(2));
8370  case eARRAY:
8371  return Array::WidthConstant(Arg<CNode*>(0),Arg<CNode*>(1));
8372  case eNET_REF:
8373  return Arg<CNet*>(0)->IsWidthConstant();
8374  case eVAR_REF:
8375  return Arg<CVar*>(0)->IsWidthConstant();
8376  case ePARAM_REF:
8377  return Arg<CParam*>(0)->IsWidthConstant();
8378  case ePORT_REF:
8379  return Arg<CPortDir*>(0)->IsWidthConstant();
8380  case eFWD_REF:
8381  return Arg<CFref*>(0)->IsWidthConstant();
8382  case eGENVAR_REF:
8383  return Arg<CGenvar*>(0)->IsWidthConstant();
8384  case eENUM_REF:
8385  return Arg<CEnum*>(0)->IsWidthConstant();
8386  case eTYPE_REF:
8387  return TRUE;
8388  case eRANGE:
8389  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8390  case eSLICE:
8391  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
8392  case ePSLICE:
8393  return Arg<CNode*>(1)->IsConstant();
8394  case eMSLICE:
8395  return Arg<CNode*>(1)->IsConstant();
8396  case eCVRI:
8397  return TRUE;
8398  case eCVIR:
8399  return TRUE;
8400  case eREP:
8401  return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsWidthConstant();
8402  case eCAT:
8403  return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
8404  case eUCAT:
8405  return Arg<CNode*>(0)->IsWidthConstant();
8406  case eCOM:
8407  return Arg<CNode*>(0)->IsWidthConstant();
8408  case eNEG:
8409  return Arg<CNode*>(0)->IsWidthConstant();
8410  case ePLUS:
8411  return Arg<CNode*>(0)->IsWidthConstant();
8412  case eNOT:
8413  return TRUE;
8414  case eGT:
8415  return TRUE;
8416  case eGE:
8417  return TRUE;
8418  case eLT:
8419  return TRUE;
8420  case eLE:
8421  return TRUE;
8422  case eLAND:
8423  return TRUE;
8424  case eLOR:
8425  return TRUE;
8426  case eCEQ:
8427  return TRUE;
8428  case eCNE:
8429  return TRUE;
8430  case eEQ:
8431  return TRUE;
8432  case eNE:
8433  return TRUE;
8434  case eRAND:
8435  return TRUE;
8436  case eRNAND:
8437  return TRUE;
8438  case eROR:
8439  return TRUE;
8440  case eRNOR:
8441  return TRUE;
8442  case eRXOR:
8443  return TRUE;
8444  case eRXNOR:
8445  return TRUE;
8446  case eHOOK:
8447  return Arg<CNode*>(1)->IsWidthConstant() && Arg<CNode*>(2)->IsWidthConstant();
8448  case eMTM:
8449  return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant() && Arg<CNode*>(2)->IsWidthConstant();
8450  case eEXTERNAL_REF:
8451  return External::WidthConstant(Arg<CSymbol*>(0));
8452  case eATTRIBUTE:
8453  return TRUE;
8454  case eMACRO_EXPR:
8455  return Arg<CNode*>(1)->IsWidthConstant();
8456  case eMEMBER:
8457  return Member::WidthConstant(Arg<CNode*>(0),Arg<CSymbol*>(1));
8458  case ePREINC:
8459  return Arg<CNode*>(0)->IsWidthConstant();
8460  case ePOSTINC:
8461  return Arg<CNode*>(0)->IsWidthConstant();
8462  case ePREDEC:
8463  return Arg<CNode*>(0)->IsWidthConstant();
8464  case ePOSTDEC:
8465  return Arg<CNode*>(0)->IsWidthConstant();
8466  case eCAST:
8467  return Arg<CNode*>(0)->IsConstant();
8468  default:
8469  MASSERT( FALSE );
8470  return 0;
8471  }
8472 }
8473 
8474 /************************************************
8475  IsWidthVolatile
8476  - return true if expression has a volatile width
8477 **************************************************/
8478 
8480 {
8481  switch( GetOp() ) {
8482  case eERROR:
8483  return FALSE;
8484  case eVCONSTANT:
8485  return Arg<CVector*>(0)->IsWidthVolatile();
8486  case eRCONSTANT:
8487  return FALSE;
8488  case eELIST:
8489  return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
8490  case eWIDTH:
8491  return Arg<CNode*>(0)->IsVolatile();
8492  case eSUB:
8493  return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
8494  case eMUL:
8495  return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
8496  case eDIV:
8497  return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
8498  case ePOW:
8499  return Arg<CNode*>(0)->IsWidthVolatile();
8500  case eADD:
8501  return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
8502  case eLSH:
8503  return Arg<CNode*>(0)->IsWidthVolatile();
8504  case eRSH:
8505  return Arg<CNode*>(0)->IsWidthVolatile();
8506  case eLSHA:
8507  return Arg<CNode*>(0)->IsWidthVolatile();
8508  case eRSHA:
8509  return Arg<CNode*>(0)->IsWidthVolatile();
8510  case eMOD:
8511  return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
8512  case eOR:
8513  return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
8514  case eAND:
8515  return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
8516  case eANDANDAND:
8517  return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
8518  case eXOR:
8519  return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
8520  case eXNOR:
8521  return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
8522  case eSYSTASK_CALL:
8523  return Systask::WidthVolatile(Arg<CSymbol*>(0),Arg<CNode*>(1));
8524  case eFUNCTION_CALL:
8525  return CFunction::WidthVolatile(Arg<CSymbol*>(0),Arg<CNode*>(1),Arg<CScope*>(2));
8526  case eARRAY:
8527  return Array::WidthVolatile(Arg<CNode*>(0),Arg<CNode*>(1));
8528  case eNET_REF:
8529  return Arg<CNet*>(0)->IsWidthVolatile();
8530  case eVAR_REF:
8531  return Arg<CVar*>(0)->IsWidthVolatile();
8532  case ePARAM_REF:
8533  return Arg<CParam*>(0)->IsWidthVolatile();
8534  case ePORT_REF:
8535  return Arg<CPortDir*>(0)->IsWidthVolatile();
8536  case eFWD_REF:
8537  return Arg<CFref*>(0)->IsWidthVolatile();
8538  case eGENVAR_REF:
8539  return Arg<CGenvar*>(0)->IsWidthVolatile();
8540  case eENUM_REF:
8541  return Arg<CEnum*>(0)->IsWidthVolatile();
8542  case eTYPE_REF:
8543  return FALSE;
8544  case eRANGE:
8545  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8546  case eSLICE:
8547  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
8548  case ePSLICE:
8549  return Arg<CNode*>(1)->IsVolatile();
8550  case eMSLICE:
8551  return Arg<CNode*>(1)->IsVolatile();
8552  case eCVRI:
8553  return FALSE;
8554  case eCVIR:
8555  return FALSE;
8556  case eREP:
8557  return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
8558  case eCAT:
8559  return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
8560  case eUCAT:
8561  return Arg<CNode*>(0)->IsWidthVolatile();
8562  case eCOM:
8563  return Arg<CNode*>(0)->IsWidthVolatile();
8564  case eNEG:
8565  return Arg<CNode*>(0)->IsWidthVolatile();
8566  case ePLUS:
8567  return Arg<CNode*>(0)->IsWidthVolatile();
8568  case eNOT:
8569  return FALSE;
8570  case eGT:
8571  return FALSE;
8572  case eGE:
8573  return FALSE;
8574  case eLT:
8575  return FALSE;
8576  case eLE:
8577  return FALSE;
8578  case eLAND:
8579  return FALSE;
8580  case eLOR:
8581  return FALSE;
8582  case eCEQ:
8583  return FALSE;
8584  case eCNE:
8585  return FALSE;
8586  case eEQ:
8587  return FALSE;
8588  case eNE:
8589  return FALSE;
8590  case eRAND:
8591  return FALSE;
8592  case eRNAND:
8593  return FALSE;
8594  case eROR:
8595  return FALSE;
8596  case eRNOR:
8597  return FALSE;
8598  case eRXOR:
8599  return FALSE;
8600  case eRXNOR:
8601  return FALSE;
8602  case eHOOK:
8603  return Arg<CNode*>(1)->IsWidthVolatile() || Arg<CNode*>(2)->IsWidthVolatile();
8604  case eMTM:
8605  return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile() || Arg<CNode*>(2)->IsWidthVolatile();
8606  case eEXTERNAL_REF:
8607  return External::WidthVolatile(Arg<CSymbol*>(0));
8608  case eATTRIBUTE:
8609  return FALSE;
8610  case eMACRO_EXPR:
8611  return Arg<CNode*>(1)->IsWidthVolatile();
8612  case eMEMBER:
8613  return Member::WidthVolatile(Arg<CNode*>(0),Arg<CSymbol*>(1));
8614  case ePREINC:
8615  return Arg<CNode*>(0)->IsWidthVolatile();
8616  case ePOSTINC:
8617  return Arg<CNode*>(0)->IsWidthVolatile();
8618  case ePREDEC:
8619  return Arg<CNode*>(0)->IsWidthVolatile();
8620  case ePOSTDEC:
8621  return Arg<CNode*>(0)->IsWidthVolatile();
8622  case eCAST:
8623  return Arg<CNode*>(0)->IsVolatile();
8624  default:
8625  MASSERT( FALSE );
8626  return 0;
8627  }
8628 
8629 }
8630 
8631 /************************************************
8632  GetWidthExp
8633  - return expression tree for width of
8634  expression, return NULL if not-determinable
8635 **************************************************/
8636 
8638 {
8639  switch( GetOp() ) {
8640  case eERROR: {
8641  CNode* temp0;
8642  CNode* temp1;
8643  CNode* temp2;
8644  return NULL;
8645  }
8646  case eVCONSTANT: {
8647  CNode* temp0;
8648  CNode* temp1;
8649  CNode* temp2;
8650  return Arg<CVector*>(0)->GetWidthExp();
8651  }
8652  case eRCONSTANT: {
8653  CNode* temp0;
8654  CNode* temp1;
8655  CNode* temp2;
8656  return NULL;
8657  }
8658  case eELIST: {
8659  CNode* temp0;
8660  CNode* temp1;
8661  CNode* temp2;
8662  return ((temp0=Arg<CNode*>(0)->GetWidthExp()) && (temp1=Arg<CNode*>(1)->GetWidthExp())) ? cADD_N(temp0,temp1,NULL) : NULL;
8663  }
8664  case eWIDTH: {
8665  CNode* temp0;
8666  CNode* temp1;
8667  CNode* temp2;
8668  return cINT32(Arg<CNode*>(0)->EvalINT32());
8669  }
8670  case eSUB: {
8671  CNode* temp0;
8672  CNode* temp1;
8673  CNode* temp2;
8674  return ((temp0=Arg<CNode*>(0)->GetWidthExp()) && (temp1=Arg<CNode*>(1)->GetWidthExp())) ? cMAX_N(temp0,temp1,NULL) : NULL;
8675  }
8676  case eMUL: {
8677  CNode* temp0;
8678  CNode* temp1;
8679  CNode* temp2;
8680  return ((temp0=Arg<CNode*>(0)->GetWidthExp()) && (temp1=Arg<CNode*>(1)->GetWidthExp())) ? cMAX_N(temp0,temp1,NULL) : NULL;
8681  }
8682  case eDIV: {
8683  CNode* temp0;
8684  CNode* temp1;
8685  CNode* temp2;
8686  return ((temp0=Arg<CNode*>(0)->GetWidthExp()) && (temp1=Arg<CNode*>(1)->GetWidthExp())) ? cMAX_N(temp0,temp1,NULL) : NULL;
8687  }
8688  case ePOW: {
8689  CNode* temp0;
8690  CNode* temp1;
8691  CNode* temp2;
8692  return Arg<CNode*>(0)->GetWidthExp();
8693  }
8694  case eADD: {
8695  CNode* temp0;
8696  CNode* temp1;
8697  CNode* temp2;
8698  return ((temp0=Arg<CNode*>(0)->GetWidthExp()) && (temp1=Arg<CNode*>(1)->GetWidthExp())) ? cMAX_N(temp0,temp1,NULL) : NULL;
8699  }
8700  case eLSH: {
8701  CNode* temp0;
8702  CNode* temp1;
8703  CNode* temp2;
8704  return Arg<CNode*>(0)->GetWidthExp();
8705  }
8706  case eRSH: {
8707  CNode* temp0;
8708  CNode* temp1;
8709  CNode* temp2;
8710  return Arg<CNode*>(0)->GetWidthExp();
8711  }
8712  case eLSHA: {
8713  CNode* temp0;
8714  CNode* temp1;
8715  CNode* temp2;
8716  return Arg<CNode*>(0)->GetWidthExp();
8717  }
8718  case eRSHA: {
8719  CNode* temp0;
8720  CNode* temp1;
8721  CNode* temp2;
8722  return Arg<CNode*>(0)->GetWidthExp();
8723  }
8724  case eMOD: {
8725  CNode* temp0;
8726  CNode* temp1;
8727  CNode* temp2;
8728  return ((temp0=Arg<CNode*>(0)->GetWidthExp()) && (temp1=Arg<CNode*>(1)->GetWidthExp())) ? cMAX_N(temp0,temp1,NULL) : NULL;
8729  }
8730  case eOR: {
8731  CNode* temp0;
8732  CNode* temp1;
8733  CNode* temp2;
8734  return ((temp0=Arg<CNode*>(0)->GetWidthExp()) && (temp1=Arg<CNode*>(1)->GetWidthExp())) ? cMAX_N(temp0,temp1,NULL) : NULL;
8735  }
8736  case eAND: {
8737  CNode* temp0;
8738  CNode* temp1;
8739  CNode* temp2;
8740  return ((temp0=Arg<CNode*>(0)->GetWidthExp()) && (temp1=Arg<CNode*>(1)->GetWidthExp())) ? cMAX_N(temp0,temp1,NULL) : NULL;
8741  }
8742  case eANDANDAND: {
8743  CNode* temp0;
8744  CNode* temp1;
8745  CNode* temp2;
8746  return ((temp0=Arg<CNode*>(0)->GetWidthExp()) && (temp1=Arg<CNode*>(1)->GetWidthExp())) ? cMAX_N(temp0,temp1,NULL) : NULL;
8747  }
8748  case eXOR: {
8749  CNode* temp0;
8750  CNode* temp1;
8751  CNode* temp2;
8752  return ((temp0=Arg<CNode*>(0)->GetWidthExp()) && (temp1=Arg<CNode*>(1)->GetWidthExp())) ? cMAX_N(temp0,temp1,NULL) : NULL;
8753  }
8754  case eXNOR: {
8755  CNode* temp0;
8756  CNode* temp1;
8757  CNode* temp2;
8758  return ((temp0=Arg<CNode*>(0)->GetWidthExp()) && (temp1=Arg<CNode*>(1)->GetWidthExp())) ? cMAX_N(temp0,temp1,NULL) : NULL;
8759  }
8760  case eSYSTASK_CALL: {
8761  CNode* temp0;
8762  CNode* temp1;
8763  CNode* temp2;
8764  return Systask::WidthExp(Arg<CSymbol*>(0),Arg<CNode*>(1));
8765  }
8766  case eFUNCTION_CALL: {
8767  CNode* temp0;
8768  CNode* temp1;
8769  CNode* temp2;
8770  return CFunction::WidthExp(Arg<CSymbol*>(0),Arg<CNode*>(1),Arg<CScope*>(2));
8771  }
8772  case eARRAY: {
8773  CNode* temp0;
8774  CNode* temp1;
8775  CNode* temp2;
8776  return Array::WidthExp(Arg<CNode*>(0),Arg<CNode*>(1));
8777  }
8778  case eNET_REF: {
8779  CNode* temp0;
8780  CNode* temp1;
8781  CNode* temp2;
8782  return Arg<CNet*>(0)->GetWidthExp();
8783  }
8784  case eVAR_REF: {
8785  CNode* temp0;
8786  CNode* temp1;
8787  CNode* temp2;
8788  return Arg<CVar*>(0)->GetWidthExp();
8789  }
8790  case ePARAM_REF: {
8791  CNode* temp0;
8792  CNode* temp1;
8793  CNode* temp2;
8794  return Arg<CParam*>(0)->GetWidthExp();
8795  }
8796  case ePORT_REF: {
8797  CNode* temp0;
8798  CNode* temp1;
8799  CNode* temp2;
8800  return Arg<CPortDir*>(0)->GetWidthExp();
8801  }
8802  case eFWD_REF: {
8803  CNode* temp0;
8804  CNode* temp1;
8805  CNode* temp2;
8806  return Arg<CFref*>(0)->GetWidthExp();
8807  }
8808  case eGENVAR_REF: {
8809  CNode* temp0;
8810  CNode* temp1;
8811  CNode* temp2;
8812  return Arg<CGenvar*>(0)->GetWidthExp();
8813  }
8814  case eENUM_REF: {
8815  CNode* temp0;
8816  CNode* temp1;
8817  CNode* temp2;
8818  return Arg<CEnum*>(0)->GetWidthExp();
8819  }
8820  case eTYPE_REF: {
8821  CNode* temp0;
8822  CNode* temp1;
8823  CNode* temp2;
8824  return cINT32(32);
8825  }
8826  case eRANGE: {
8827  CNode* temp0;
8828  CNode* temp1;
8829  CNode* temp2;
8830  return (1 && 1) ? cABSDIFFPLUS1_N(Arg<CNode*>(0)->Clone(),Arg<CNode*>(1)->Clone(),NULL) : NULL;
8831  }
8832  case eSLICE: {
8833  CNode* temp0;
8834  CNode* temp1;
8835  CNode* temp2;
8836  return (1 && 1) ? cABSDIFFPLUS1_N(Arg<CNode*>(0)->Clone(),Arg<CNode*>(1)->Clone(),NULL) : NULL;
8837  }
8838  case ePSLICE: {
8839  CNode* temp0;
8840  CNode* temp1;
8841  CNode* temp2;
8842  return Arg<CNode*>(1);
8843  }
8844  case eMSLICE: {
8845  CNode* temp0;
8846  CNode* temp1;
8847  CNode* temp2;
8848  return Arg<CNode*>(1);
8849  }
8850  case eCVRI: {
8851  CNode* temp0;
8852  CNode* temp1;
8853  CNode* temp2;
8854  return cINT32(32);
8855  }
8856  case eCVIR: {
8857  CNode* temp0;
8858  CNode* temp1;
8859  CNode* temp2;
8860  return NULL;
8861  }
8862  case eREP: {
8863  CNode* temp0;
8864  CNode* temp1;
8865  CNode* temp2;
8866  return (1 && (temp1=Arg<CNode*>(1)->GetWidthExp())) ? cMUL_N(Arg<CNode*>(0)->Clone(),temp1,NULL) : NULL;
8867  }
8868  case eCAT: {
8869  CNode* temp0;
8870  CNode* temp1;
8871  CNode* temp2;
8872  return ((temp0=Arg<CNode*>(0)->GetWidthExp()) && (temp1=Arg<CNode*>(1)->GetWidthExp())) ? cADD_N(temp0,temp1,NULL) : NULL;
8873  }
8874  case eUCAT: {
8875  CNode* temp0;
8876  CNode* temp1;
8877  CNode* temp2;
8878  return Arg<CNode*>(0)->GetWidthExp();
8879  }
8880  case eCOM: {
8881  CNode* temp0;
8882  CNode* temp1;
8883  CNode* temp2;
8884  return Arg<CNode*>(0)->GetWidthExp();
8885  }
8886  case eNEG: {
8887  CNode* temp0;
8888  CNode* temp1;
8889  CNode* temp2;
8890  return Arg<CNode*>(0)->GetWidthExp();
8891  }
8892  case ePLUS: {
8893  CNode* temp0;
8894  CNode* temp1;
8895  CNode* temp2;
8896  return Arg<CNode*>(0)->GetWidthExp();
8897  }
8898  case eNOT: {
8899  CNode* temp0;
8900  CNode* temp1;
8901  CNode* temp2;
8902  return cINT32(1);
8903  }
8904  case eGT: {
8905  CNode* temp0;
8906  CNode* temp1;
8907  CNode* temp2;
8908  return cINT32(1);
8909  }
8910  case eGE: {
8911  CNode* temp0;
8912  CNode* temp1;
8913  CNode* temp2;
8914  return cINT32(1);
8915  }
8916  case eLT: {
8917  CNode* temp0;
8918  CNode* temp1;
8919  CNode* temp2;
8920  return cINT32(1);
8921  }
8922  case eLE: {
8923  CNode* temp0;
8924  CNode* temp1;
8925  CNode* temp2;
8926  return cINT32(1);
8927  }
8928  case eLAND: {
8929  CNode* temp0;
8930  CNode* temp1;
8931  CNode* temp2;
8932  return cINT32(1);
8933  }
8934  case eLOR: {
8935  CNode* temp0;
8936  CNode* temp1;
8937  CNode* temp2;
8938  return cINT32(1);
8939  }
8940  case eCEQ: {
8941  CNode* temp0;
8942  CNode* temp1;
8943  CNode* temp2;
8944  return cINT32(1);
8945  }
8946  case eCNE: {
8947  CNode* temp0;
8948  CNode* temp1;
8949  CNode* temp2;
8950  return cINT32(1);
8951  }
8952  case eEQ: {
8953  CNode* temp0;
8954  CNode* temp1;
8955  CNode* temp2;
8956  return cINT32(1);
8957  }
8958  case eNE: {
8959  CNode* temp0;
8960  CNode* temp1;
8961  CNode* temp2;
8962  return cINT32(1);
8963  }
8964  case eRAND: {
8965  CNode* temp0;
8966  CNode* temp1;
8967  CNode* temp2;
8968  return cINT32(1);
8969  }
8970  case eRNAND: {
8971  CNode* temp0;
8972  CNode* temp1;
8973  CNode* temp2;
8974  return cINT32(1);
8975  }
8976  case eROR: {
8977  CNode* temp0;
8978  CNode* temp1;
8979  CNode* temp2;
8980  return cINT32(1);
8981  }
8982  case eRNOR: {
8983  CNode* temp0;
8984  CNode* temp1;
8985  CNode* temp2;
8986  return cINT32(1);
8987  }
8988  case eRXOR: {
8989  CNode* temp0;
8990  CNode* temp1;
8991  CNode* temp2;
8992  return cINT32(1);
8993  }
8994  case eRXNOR: {
8995  CNode* temp0;
8996  CNode* temp1;
8997  CNode* temp2;
8998  return cINT32(1);
8999  }
9000  case eHOOK: {
9001  CNode* temp0;
9002  CNode* temp1;
9003  CNode* temp2;
9004  return ((temp1=Arg<CNode*>(1)->GetWidthExp()) && (temp2=Arg<CNode*>(2)->GetWidthExp())) ? cMAX_N(temp1,temp2,NULL) : NULL;
9005  }
9006  case eMTM: {
9007  CNode* temp0;
9008  CNode* temp1;
9009  CNode* temp2;
9010  return ((temp0=Arg<CNode*>(0)->GetWidthExp()) && (temp1=Arg<CNode*>(1)->GetWidthExp()) && (temp2=Arg<CNode*>(2)->GetWidthExp())) ? cMAX_N(temp0,temp1,temp2,NULL) : NULL;
9011  }
9012  case eEXTERNAL_REF: {
9013  CNode* temp0;
9014  CNode* temp1;
9015  CNode* temp2;
9016  return External::WidthExp(Arg<CSymbol*>(0));
9017  }
9018  case eATTRIBUTE: {
9019  CNode* temp0;
9020  CNode* temp1;
9021  CNode* temp2;
9022  return cINT32(0);
9023  }
9024  case eMACRO_EXPR: {
9025  CNode* temp0;
9026  CNode* temp1;
9027  CNode* temp2;
9028  return Arg<CNode*>(1)->GetWidthExp();
9029  }
9030  case eMEMBER: {
9031  CNode* temp0;
9032  CNode* temp1;
9033  CNode* temp2;
9034  return Member::WidthExp(Arg<CNode*>(0),Arg<CSymbol*>(1));
9035  }
9036  case ePREINC: {
9037  CNode* temp0;
9038  CNode* temp1;
9039  CNode* temp2;
9040  return Arg<CNode*>(0)->GetWidthExp();
9041  }
9042  case ePOSTINC: {
9043  CNode* temp0;
9044  CNode* temp1;
9045  CNode* temp2;
9046  return Arg<CNode*>(0)->GetWidthExp();
9047  }
9048  case ePREDEC: {
9049  CNode* temp0;
9050  CNode* temp1;
9051  CNode* temp2;
9052  return Arg<CNode*>(0)->GetWidthExp();
9053  }
9054  case ePOSTDEC: {
9055  CNode* temp0;
9056  CNode* temp1;
9057  CNode* temp2;
9058  return Arg<CNode*>(0)->GetWidthExp();
9059  }
9060  case eCAST: {
9061  CNode* temp0;
9062  CNode* temp1;
9063  CNode* temp2;
9064  return cINT32(Arg<CNode*>(0)->EvalINT32());
9065  }
9066  default:
9067  MASSERT( FALSE );
9068  return NULL;
9069  }
9070 }
9071 
9072 /************************************************
9073  IsWidthEvaluateable
9074  - return true if expression width can be evaluated
9075 **************************************************/
9076 
9078 {
9079  switch( GetOp() ) {
9080  case eERROR:
9081  return FALSE;
9082  case eVCONSTANT:
9083  return Arg<CVector*>(0)->IsWidthEvaluateable();
9084  case eRCONSTANT:
9085  return FALSE;
9086  case eELIST:
9087  return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
9088  case eWIDTH:
9089  return Arg<CNode*>(0)->IsEvaluateable();
9090  case eSUB:
9091  return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
9092  case eMUL:
9093  return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
9094  case eDIV:
9095  return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
9096  case ePOW:
9097  return Arg<CNode*>(0)->IsWidthEvaluateable();
9098  case eADD:
9099  return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
9100  case eLSH:
9101  return Arg<CNode*>(0)->IsWidthEvaluateable();
9102  case eRSH:
9103  return Arg<CNode*>(0)->IsWidthEvaluateable();
9104  case eLSHA:
9105  return Arg<CNode*>(0)->IsWidthEvaluateable();
9106  case eRSHA:
9107  return Arg<CNode*>(0)->IsWidthEvaluateable();
9108  case eMOD:
9109  return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
9110  case eOR:
9111  return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
9112  case eAND:
9113  return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
9114  case eANDANDAND:
9115  return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
9116  case eXOR:
9117  return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
9118  case eXNOR:
9119  return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
9120  case eSYSTASK_CALL:
9121  return Systask::WidthEvaluateable(Arg<CSymbol*>(0),Arg<CNode*>(1));
9122  case eFUNCTION_CALL:
9123  return CFunction::WidthEvaluateable(Arg<CSymbol*>(0),Arg<CNode*>(1),Arg<CScope*>(2));
9124  case eARRAY:
9125  return Array::WidthEvaluateable(Arg<CNode*>(0),Arg<CNode*>(1));
9126  case eNET_REF:
9127  return Arg<CNet*>(0)->IsWidthEvaluateable();
9128  case eVAR_REF:
9129  return Arg<CVar*>(0)->IsWidthEvaluateable();
9130  case ePARAM_REF:
9131  return Arg<CParam*>(0)->IsWidthEvaluateable();
9132  case ePORT_REF:
9133  return Arg<CPortDir*>(0)->IsWidthEvaluateable();
9134  case eFWD_REF:
9135  return Arg<CFref*>(0)->IsWidthEvaluateable();
9136  case eGENVAR_REF:
9137  return Arg<CGenvar*>(0)->IsWidthEvaluateable();
9138  case eENUM_REF:
9139  return Arg<CEnum*>(0)->IsWidthEvaluateable();
9140  case eTYPE_REF:
9141  return TRUE;
9142  case eRANGE:
9143  return Arg<CNode*>(0)->IsEvaluateable() && Arg<CNode*>(1)->IsEvaluateable();
9144  case eSLICE:
9145  return Arg<CNode*>(0)->IsEvaluateable() && Arg<CNode*>(1)->IsEvaluateable();
9146  case ePSLICE:
9147  return Arg<CNode*>(1)->IsEvaluateable();
9148  case eMSLICE:
9149  return Arg<CNode*>(1)->IsEvaluateable();
9150  case eCVRI:
9151  return TRUE;
9152  case eCVIR:
9153  return FALSE;
9154  case eREP:
9155  return Arg<CNode*>(0)->IsEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
9156  case eCAT:
9157  return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
9158  case eUCAT:
9159  return Arg<CNode*>(0)->IsWidthEvaluateable();
9160  case eCOM:
9161  return Arg<CNode*>(0)->IsWidthEvaluateable();
9162  case eNEG:
9163  return Arg<CNode*>(0)->IsWidthEvaluateable();
9164  case ePLUS:
9165  return Arg<CNode*>(0)->IsWidthEvaluateable();
9166  case eNOT:
9167  return TRUE;
9168  case eGT:
9169  return TRUE;
9170  case eGE:
9171  return TRUE;
9172  case eLT:
9173  return TRUE;
9174  case eLE:
9175  return TRUE;
9176  case eLAND:
9177  return TRUE;
9178  case eLOR:
9179  return TRUE;
9180  case eCEQ:
9181  return TRUE;
9182  case eCNE:
9183  return TRUE;
9184  case eEQ:
9185  return TRUE;
9186  case eNE:
9187  return TRUE;
9188  case eRAND:
9189  return TRUE;
9190  case eRNAND:
9191  return TRUE;
9192  case eROR:
9193  return TRUE;
9194  case eRNOR:
9195  return TRUE;
9196  case eRXOR:
9197  return TRUE;
9198  case eRXNOR:
9199  return TRUE;
9200  case eHOOK:
9201  return Arg<CNode*>(1)->IsWidthEvaluateable() && Arg<CNode*>(2)->IsWidthEvaluateable();
9202  case eMTM:
9203  return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable() && Arg<CNode*>(2)->IsWidthEvaluateable();
9204  case eEXTERNAL_REF:
9205  return External::WidthEvaluateable(Arg<CSymbol*>(0));
9206  case eATTRIBUTE:
9207  return TRUE;
9208  case eMACRO_EXPR:
9209  return Arg<CNode*>(1)->IsWidthEvaluateable();
9210  case eMEMBER:
9211  return Member::WidthEvaluateable(Arg<CNode*>(0),Arg<CSymbol*>(1));
9212  case ePREINC:
9213  return Arg<CNode*>(0)->IsWidthEvaluateable();
9214  case ePOSTINC:
9215  return Arg<CNode*>(0)->IsWidthEvaluateable();
9216  case ePREDEC:
9217  return Arg<CNode*>(0)->IsWidthEvaluateable();
9218  case ePOSTDEC:
9219  return Arg<CNode*>(0)->IsWidthEvaluateable();
9220  case eCAST:
9221  return Arg<CNode*>(0)->IsEvaluateable();
9222  default:
9223  MASSERT( FALSE );
9224  return 0;
9225  }
9226 }
9227 
9228 /************************************************
9229  IsNonX
9230  - return true if expression cannot be X(or Z)
9231  exclude any variable with attribute
9232  specified by exclude and optionally integers.
9233 **************************************************/
9234 
9235 int CNode::IsNonX( int integerIsNonX, char* exclude )
9236 {
9237  switch( GetOp() ) {
9238  case eERROR:
9239  return FALSE;
9240  case eVCONSTANT:
9241  return !Arg<CVector*>(0)->HasXZ();
9242  case eRCONSTANT:
9243  return TRUE;
9244  case eELIST:
9245  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9246  case eWIDTH:
9247  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9248  case eSUB:
9249  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9250  case eMUL:
9251  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9252  case eDIV:
9253  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9254  case ePOW:
9255  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9256  case eADD:
9257  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9258  case eLSH:
9259  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9260  case eRSH:
9261  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9262  case eLSHA:
9263  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9264  case eRSHA:
9265  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9266  case eMOD:
9267  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9268  case eOR:
9269  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9270  case eAND:
9271  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9272  case eANDANDAND:
9273  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9274  case eXOR:
9275  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9276  case eXNOR:
9277  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9278  case eSYSTASK_CALL:
9279  return FALSE;
9280  case eFUNCTION_CALL:
9281  return FALSE;
9282  case eARRAY:
9283  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9284  case eNET_REF:
9285  return Arg<CDecl*>(0)->HasAttribute( exclude ) ||
9286 
9287  (integerIsNonX && Arg<CDecl*>(0)->GetDataType()->GetVarDataType() == eINT);
9288  case eVAR_REF:
9289  return Arg<CDecl*>(0)->GetDataType()->GetTwoState() ||
9290 
9291  Arg<CDecl*>(0)->GetNodeType() == eR ||
9292 
9293  Arg<CDecl*>(0)->HasAttribute( exclude ) ||
9294 
9295  (integerIsNonX && Arg<CDecl*>(0)->GetDataType()->GetVarDataType() == eINTEGER);
9296  case ePARAM_REF:
9297  return TRUE;
9298  case ePORT_REF:
9299  return Arg<CDecl*>(0)->HasAttribute( exclude ) ||
9300 
9301  (integerIsNonX && Arg<CDecl*>(0)->GetDataType()->GetVarDataType() == eINT);
9302  case eFWD_REF:
9303  return FALSE;
9304  case eGENVAR_REF:
9305  return TRUE;
9306  case eENUM_REF:
9307  return Arg<CEnum*>(0)->GetExpression()->IsNonX( integerIsNonX, exclude );
9308  case eTYPE_REF:
9309  return TRUE;
9310  case eRANGE:
9311  return FALSE;
9312  case eSLICE:
9313  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9314  case ePSLICE:
9315  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9316  case eMSLICE:
9317  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9318  case eCVRI:
9319  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9320  case eCVIR:
9321  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9322  case eREP:
9323  return Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9324  case eCAT:
9325  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9326  case eUCAT:
9327  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9328  case eCOM:
9329  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9330  case eNEG:
9331  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9332  case ePLUS:
9333  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9334  case eNOT:
9335  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9336  case eGT:
9337  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9338  case eGE:
9339  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9340  case eLT:
9341  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9342  case eLE:
9343  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9344  case eLAND:
9345  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9346  case eLOR:
9347  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9348  case eCEQ:
9349  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9350  case eCNE:
9351  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9352  case eEQ:
9353  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9354  case eNE:
9355  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9356  case eRAND:
9357  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9358  case eRNAND:
9359  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9360  case eROR:
9361  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9362  case eRNOR:
9363  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9364  case eRXOR:
9365  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9366  case eRXNOR:
9367  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9368  case eHOOK:
9369  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(2)->IsNonX( integerIsNonX, exclude );
9370  case ePOSEDGE:
9371  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9372  case eNEGEDGE:
9373  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9374  case eEVOR:
9375  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9376  case eMTM:
9377  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(2)->IsNonX( integerIsNonX, exclude );
9378  case eEXTERNAL_REF:
9379  return FALSE;
9380  case eMACRO_EXPR:
9381  return Arg<CNode*>(1) ? Arg<CNode*>(1)->IsNonX(integerIsNonX, exclude) : FALSE;
9382  case eMEMBER:
9383  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9384  case ePREINC:
9385  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9386  case ePOSTINC:
9387  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9388  case ePREDEC:
9389  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9390  case ePOSTDEC:
9391  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
9392  case eCAST:
9393  return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
9394  default:
9395  MASSERT( FALSE );
9396  return 0;
9397  }
9398 }
9399 
9400 /***********************************************
9401  Clone
9402  - clone a copy of this tree use
9403  stack)for storage
9404 ************************************************/
9405 
9407 {
9408  int nodeMask = 0;
9409  switch( GetOp() ) {
9410  case eERROR:
9411  nodeMask = 0;
9412  break;
9413  case eVCONSTANT:
9414  nodeMask = 0;
9415  break;
9416  case eRCONSTANT:
9417  nodeMask = 0;
9418  break;
9419  case eCOMMENT:
9420  nodeMask = 0;
9421  break;
9422  case eVRQ:
9423  nodeMask = 0;
9424  break;
9425  case ePRAGMA:
9426  nodeMask = 0;
9427  break;
9428  case eELIST:
9429  nodeMask = 3;
9430  break;
9431  case eWIDTH:
9432  nodeMask = 3;
9433  break;
9434  case eNOP:
9435  nodeMask = 0;
9436  break;
9437  case eSUB:
9438  nodeMask = 3;
9439  break;
9440  case eMUL:
9441  nodeMask = 3;
9442  break;
9443  case eDIV:
9444  nodeMask = 3;
9445  break;
9446  case ePOW:
9447  nodeMask = 3;
9448  break;
9449  case eADD:
9450  nodeMask = 3;
9451  break;
9452  case eLSH:
9453  nodeMask = 3;
9454  break;
9455  case eRSH:
9456  nodeMask = 3;
9457  break;
9458  case eLSHA:
9459  nodeMask = 3;
9460  break;
9461  case eRSHA:
9462  nodeMask = 3;
9463  break;
9464  case eMOD:
9465  nodeMask = 3;
9466  break;
9467  case eOR:
9468  nodeMask = 3;
9469  break;
9470  case eAND:
9471  nodeMask = 3;
9472  break;
9473  case eANDANDAND:
9474  nodeMask = 3;
9475  break;
9476  case eXOR:
9477  nodeMask = 3;
9478  break;
9479  case eXNOR:
9480  nodeMask = 3;
9481  break;
9482  case eINSTANCE_REF:
9483  nodeMask = 0;
9484  break;
9485  case eGATE_REF:
9486  nodeMask = 0;
9487  break;
9488  case eTASK_ENABLE:
9489  nodeMask = 2;
9490  break;
9491  case eSYSTASK_CALL:
9492  nodeMask = 2;
9493  break;
9494  case eTIMING_CALL:
9495  nodeMask = 2;
9496  break;
9497  case eFUNCTION_CALL:
9498  nodeMask = 2;
9499  break;
9500  case eARRAY:
9501  nodeMask = 3;
9502  break;
9503  case eNET_REF:
9504  nodeMask = 0;
9505  break;
9506  case eVAR_REF:
9507  nodeMask = 0;
9508  break;
9509  case ePARAM_REF:
9510  nodeMask = 0;
9511  break;
9512  case ePORT_REF:
9513  nodeMask = 0;
9514  break;
9515  case eFWD_REF:
9516  nodeMask = 0;
9517  break;
9518  case eGENVAR_REF:
9519  nodeMask = 0;
9520  break;
9521  case eENUM_REF:
9522  nodeMask = 0;
9523  break;
9524  case eTYPE_REF:
9525  nodeMask = 0;
9526  break;
9527  case eNET_DECL:
9528  nodeMask = 2;
9529  break;
9530  case eVAR_DECL:
9531  nodeMask = 2;
9532  break;
9533  case ePARAM_DECL:
9534  nodeMask = 0;
9535  break;
9536  case eSPECPARAM_DECL:
9537  nodeMask = 0;
9538  break;
9539  case ePORT_DECL:
9540  nodeMask = 0;
9541  break;
9542  case eGENVAR_DECL:
9543  nodeMask = 0;
9544  break;
9545  case eTYPEDEF_DECL:
9546  nodeMask = 0;
9547  break;
9548  case eLIST:
9549  nodeMask = 3;
9550  break;
9551  case eRANGE:
9552  nodeMask = 3;
9553  break;
9554  case eSLICE:
9555  nodeMask = 3;
9556  break;
9557  case ePSLICE:
9558  nodeMask = 3;
9559  break;
9560  case eMSLICE:
9561  nodeMask = 3;
9562  break;
9563  case eCVRI:
9564  nodeMask = 1;
9565  break;
9566  case eCVIR:
9567  nodeMask = 1;
9568  break;
9569  case eREP:
9570  nodeMask = 3;
9571  break;
9572  case eCAT:
9573  nodeMask = 3;
9574  break;
9575  case eUCAT:
9576  nodeMask = 1;
9577  break;
9578  case eCOM:
9579  nodeMask = 1;
9580  break;
9581  case eNEG:
9582  nodeMask = 1;
9583  break;
9584  case ePLUS:
9585  nodeMask = 1;
9586  break;
9587  case eNOT:
9588  nodeMask = 1;
9589  break;
9590  case eGT:
9591  nodeMask = 3;
9592  break;
9593  case eGE:
9594  nodeMask = 3;
9595  break;
9596  case eLT:
9597  nodeMask = 3;
9598  break;
9599  case eLE:
9600  nodeMask = 3;
9601  break;
9602  case eLAND:
9603  nodeMask = 3;
9604  break;
9605  case eLOR:
9606  nodeMask = 3;
9607  break;
9608  case eCEQ:
9609  nodeMask = 3;
9610  break;
9611  case eCNE:
9612  nodeMask = 3;
9613  break;
9614  case eEQ:
9615  nodeMask = 3;
9616  break;
9617  case eNE:
9618  nodeMask = 3;
9619  break;
9620  case eRAND:
9621  nodeMask = 1;
9622  break;
9623  case eRNAND:
9624  nodeMask = 1;
9625  break;
9626  case eROR:
9627  nodeMask = 1;
9628  break;
9629  case eRNOR:
9630  nodeMask = 1;
9631  break;
9632  case eRXOR:
9633  nodeMask = 1;
9634  break;
9635  case eRXNOR:
9636  nodeMask = 1;
9637  break;
9638  case eHOOK:
9639  nodeMask = 7;
9640  break;
9641  case eINIT:
9642  nodeMask = 1;
9643  break;
9644  case eALWAYS:
9645  nodeMask = 1;
9646  break;
9647  case eALWAYS_LATCH:
9648  nodeMask = 1;
9649  break;
9650  case eALWAYS_FF:
9651  nodeMask = 1;
9652  break;
9653  case eALWAYS_COMB:
9654  nodeMask = 1;
9655  break;
9656  case eEVENT:
9657  nodeMask = 3;
9658  break;
9659  case eBLOCK_REF:
9660  nodeMask = 2;
9661  break;
9662  case eSPECIFY_REF:
9663  nodeMask = 2;
9664  break;
9665  case eASSIGN:
9666  nodeMask = 7;
9667  break;
9668  case eADD_ASSIGN:
9669  nodeMask = 7;
9670  break;
9671  case eSUB_ASSIGN:
9672  nodeMask = 7;
9673  break;
9674  case eMUL_ASSIGN:
9675  nodeMask = 7;
9676  break;
9677  case eDIV_ASSIGN:
9678  nodeMask = 7;
9679  break;
9680  case eMOD_ASSIGN:
9681  nodeMask = 7;
9682  break;
9683  case eAND_ASSIGN:
9684  nodeMask = 7;
9685  break;
9686  case eOR_ASSIGN:
9687  nodeMask = 7;
9688  break;
9689  case eXOR_ASSIGN:
9690  nodeMask = 7;
9691  break;
9692  case eLSH_ASSIGN:
9693  nodeMask = 7;
9694  break;
9695  case eRSH_ASSIGN:
9696  nodeMask = 7;
9697  break;
9698  case eLSHA_ASSIGN:
9699  nodeMask = 7;
9700  break;
9701  case eRSHA_ASSIGN:
9702  nodeMask = 7;
9703  break;
9704  case eFORCE:
9705  nodeMask = 3;
9706  break;
9707  case eRELEASE:
9708  nodeMask = 1;
9709  break;
9710  case eNBASSIGN:
9711  nodeMask = 7;
9712  break;
9713  case ePOSEDGE:
9714  nodeMask = 1;
9715  break;
9716  case eNEGEDGE:
9717  nodeMask = 1;
9718  break;
9719  case eEDGE:
9720  nodeMask = 1;
9721  break;
9722  case eEVOR:
9723  nodeMask = 3;
9724  break;
9725  case eDELAY:
9726  nodeMask = 3;
9727  break;
9728  case eMTM:
9729  nodeMask = 7;
9730  break;
9731  case eIF:
9732  nodeMask = 7;
9733  break;
9734  case eFOREVER:
9735  nodeMask = 1;
9736  break;
9737  case eREPEAT:
9738  nodeMask = 3;
9739  break;
9740  case eWHILE:
9741  nodeMask = 3;
9742  break;
9743  case eWAIT:
9744  nodeMask = 3;
9745  break;
9746  case eFOR:
9747  nodeMask = 15;
9748  break;
9749  case eCASE:
9750  nodeMask = 3;
9751  break;
9752  case eCASEX:
9753  nodeMask = 3;
9754  break;
9755  case eCASEZ:
9756  nodeMask = 3;
9757  break;
9758  case eCASEITEM:
9759  nodeMask = 3;
9760  break;
9761  case eCASSIGN:
9762  nodeMask = 14;
9763  break;
9764  case eARG:
9765  nodeMask = 2;
9766  break;
9767  case eIMPORT:
9768  nodeMask = 0;
9769  break;
9770  case eFUNCTION_DEF:
9771  nodeMask = 0;
9772  break;
9773  case eMODULE_DEF:
9774  nodeMask = 0;
9775  break;
9776  case ePACKAGE_DEF:
9777  nodeMask = 0;
9778  break;
9779  case eREPEAT_CONTROL:
9780  nodeMask = 3;
9781  break;
9782  case eDELAY_CONTROL:
9783  nodeMask = 1;
9784  break;
9785  case eEVENT_CONTROL:
9786  nodeMask = 1;
9787  break;
9788  case eEXTERNAL_REF:
9789  nodeMask = 0;
9790  break;
9791  case ePORT_DEF:
9792  nodeMask = 0;
9793  break;
9794  case eDEFPARAM:
9795  nodeMask = 3;
9796  break;
9797  case ePATH:
9798  nodeMask = 82;
9799  break;
9800  case ePATH_ASSIGN:
9801  nodeMask = 7;
9802  break;
9803  case eIFNONE_PATH_ASSIGN:
9804  nodeMask = 3;
9805  break;
9806  case eTRIGGER:
9807  nodeMask = 1;
9808  break;
9809  case ePASSIGN:
9810  nodeMask = 3;
9811  break;
9812  case eDEASSIGN:
9813  nodeMask = 1;
9814  break;
9815  case eDISABLE:
9816  nodeMask = 0;
9817  break;
9818  case eATTRIBUTE:
9819  nodeMask = 0;
9820  break;
9821  case eGIF:
9822  nodeMask = 7;
9823  break;
9824  case eGFOR:
9825  nodeMask = 15;
9826  break;
9827  case eGCASE:
9828  nodeMask = 3;
9829  break;
9830  case eTABLE:
9831  nodeMask = 1;
9832  break;
9833  case eTABLE_ENTRY:
9834  nodeMask = 1;
9835  break;
9836  case eTABLE_SYMBOL:
9837  nodeMask = 0;
9838  break;
9839  case ePORTLIST_END:
9840  nodeMask = 0;
9841  break;
9842  case eMACRO_EXPR:
9843  nodeMask = 2;
9844  break;
9845  case eENUM_SPEC:
9846  nodeMask = 6;
9847  break;
9848  case eMEMBER:
9849  nodeMask = 1;
9850  break;
9851  case eRETURN:
9852  nodeMask = 1;
9853  break;
9854  case ePREINC:
9855  nodeMask = 1;
9856  break;
9857  case ePOSTINC:
9858  nodeMask = 1;
9859  break;
9860  case ePREDEC:
9861  nodeMask = 1;
9862  break;
9863  case ePOSTDEC:
9864  nodeMask = 1;
9865  break;
9866  case eCAST:
9867  nodeMask = 3;
9868  break;
9869  default:
9870  MASSERT( FALSE );
9871  }
9872 
9873  CNode* n = new(stack) CNode( &loc, op );
9874  n->width = width;
9875  n->type = type;
9876  n->fixedWidth = fixedWidth;
9877  if( attributes ) {
9878  n->attributes = attributes->Clone(heap);
9879  }
9880  for( int i = 0; i < ArgCount(); i++ ) {
9881  if( ((nodeMask>>i)&1) && Arg<CNode*>(i) ) {
9882  n->Arg<CNode*>(i) = Arg<CNode*>(i)->Clone(heap);
9883  } else {
9884  void* tmp = Arg<void*>(i);
9885  n->Arg<void*>(i) = tmp;
9886  }
9887  }
9888  return n;
9889 }
9890 
9891 
9892 /***********************************************
9893  PreVisit1
9894  - traverse tree, evoking
9895  parent then leaves.
9896  Callback may terminate traversal of subtree early.
9897 ************************************************/
9898 
9899 void CNode::PreVisit1( int (*func)(CNode*, void*), void* data )
9900 {
9901  if( !(*func)( this, data ) ) {
9902  return;
9903  }
9904 
9905  if( GetAttributes() ) {
9906  GetAttributes()->PreVisit1( func, data );
9907  }
9908 
9909  int nodeMask = 0;
9910  switch( GetOp() ) {
9911  case eERROR:
9912  nodeMask = 0;
9913  break;
9914  case eVCONSTANT:
9915  nodeMask = 1;
9916  break;
9917  case eRCONSTANT:
9918  nodeMask = 1;
9919  break;
9920  case eCOMMENT:
9921  nodeMask = 1;
9922  break;
9923  case eVRQ:
9924  nodeMask = 1;
9925  break;
9926  case ePRAGMA:
9927  nodeMask = 1;
9928  break;
9929  case eELIST:
9930  nodeMask = 0;
9931  break;
9932  case eWIDTH:
9933  nodeMask = 0;
9934  break;
9935  case eNOP:
9936  nodeMask = 0;
9937  break;
9938  case eSUB:
9939  nodeMask = 0;
9940  break;
9941  case eMUL:
9942  nodeMask = 0;
9943  break;
9944  case eDIV:
9945  nodeMask = 0;
9946  break;
9947  case ePOW:
9948  nodeMask = 0;
9949  break;
9950  case eADD:
9951  nodeMask = 0;
9952  break;
9953  case eLSH:
9954  nodeMask = 0;
9955  break;
9956  case eRSH:
9957  nodeMask = 0;
9958  break;
9959  case eLSHA:
9960  nodeMask = 0;
9961  break;
9962  case eRSHA:
9963  nodeMask = 0;
9964  break;
9965  case eMOD:
9966  nodeMask = 0;
9967  break;
9968  case eOR:
9969  nodeMask = 0;
9970  break;
9971  case eAND:
9972  nodeMask = 0;
9973  break;
9974  case eANDANDAND:
9975  nodeMask = 0;
9976  break;
9977  case eXOR:
9978  nodeMask = 0;
9979  break;
9980  case eXNOR:
9981  nodeMask = 0;
9982  break;
9983  case eINSTANCE_REF:
9984  nodeMask = 1;
9985  if(Arg<CInstance*>(0)) Arg<CInstance*>(0)->PreVisit1( func, data );
9986  break;
9987  case eGATE_REF:
9988  nodeMask = 1;
9989  if(Arg<CGate*>(0)) Arg<CGate*>(0)->PreVisit1( func, data );
9990  break;
9991  case eTASK_ENABLE:
9992  nodeMask = 1;
9993  break;
9994  case eSYSTASK_CALL:
9995  nodeMask = 1;
9996  break;
9997  case eTIMING_CALL:
9998  nodeMask = 1;
9999  break;
10000  case eFUNCTION_CALL:
10001  nodeMask = 5;
10002  break;
10003  case eARRAY:
10004  nodeMask = 0;
10005  break;
10006  case eNET_REF:
10007  return;
10008  case eVAR_REF:
10009  return;
10010  case ePARAM_REF:
10011  return;
10012  case ePORT_REF:
10013  return;
10014  case eFWD_REF:
10015  return;
10016  case eGENVAR_REF:
10017  return;
10018  case eENUM_REF:
10019  return;
10020  case eTYPE_REF:
10021  return;
10022  case eNET_DECL:
10023  nodeMask = 1;
10024  if(Arg<CNet*>(0)) Arg<CNet*>(0)->PreVisit1( func, data );
10025  break;
10026  case eVAR_DECL:
10027  nodeMask = 1;
10028  if(Arg<CVar*>(0)) Arg<CVar*>(0)->PreVisit1( func, data );
10029  break;
10030  case ePARAM_DECL:
10031  nodeMask = 1;
10032  if(Arg<CParam*>(0)) Arg<CParam*>(0)->PreVisit1( func, data );
10033  break;
10034  case eSPECPARAM_DECL:
10035  nodeMask = 1;
10036  if(Arg<CParam*>(0)) Arg<CParam*>(0)->PreVisit1( func, data );
10037  break;
10038  case ePORT_DECL:
10039  nodeMask = 1;
10040  if(Arg<CPortDir*>(0)) Arg<CPortDir*>(0)->PreVisit1( func, data );
10041  break;
10042  case eGENVAR_DECL:
10043  nodeMask = 1;
10044  if(Arg<CGenvar*>(0)) Arg<CGenvar*>(0)->PreVisit1( func, data );
10045  break;
10046  case eTYPEDEF_DECL:
10047  nodeMask = 1;
10048  if(Arg<CTypedef*>(0)) Arg<CTypedef*>(0)->PreVisit1( func, data );
10049  break;
10050  case eLIST:
10051  nodeMask = 0;
10052  break;
10053  case eRANGE:
10054  nodeMask = 0;
10055  break;
10056  case eSLICE:
10057  nodeMask = 0;
10058  break;
10059  case ePSLICE:
10060  nodeMask = 0;
10061  break;
10062  case eMSLICE:
10063  nodeMask = 0;
10064  break;
10065  case eCVRI:
10066  nodeMask = 0;
10067  break;
10068  case eCVIR:
10069  nodeMask = 0;
10070  break;
10071  case eREP:
10072  nodeMask = 0;
10073  break;
10074  case eCAT:
10075  nodeMask = 0;
10076  break;
10077  case eUCAT:
10078  nodeMask = 0;
10079  break;
10080  case eCOM:
10081  nodeMask = 0;
10082  break;
10083  case eNEG:
10084  nodeMask = 0;
10085  break;
10086  case ePLUS:
10087  nodeMask = 0;
10088  break;
10089  case eNOT:
10090  nodeMask = 0;
10091  break;
10092  case eGT:
10093  nodeMask = 0;
10094  break;
10095  case eGE:
10096  nodeMask = 0;
10097  break;
10098  case eLT:
10099  nodeMask = 0;
10100  break;
10101  case eLE:
10102  nodeMask = 0;
10103  break;
10104  case eLAND:
10105  nodeMask = 0;
10106  break;
10107  case eLOR:
10108  nodeMask = 0;
10109  break;
10110  case eCEQ:
10111  nodeMask = 0;
10112  break;
10113  case eCNE:
10114  nodeMask = 0;
10115  break;
10116  case eEQ:
10117  nodeMask = 0;
10118  break;
10119  case eNE:
10120  nodeMask = 0;
10121  break;
10122  case eRAND:
10123  nodeMask = 0;
10124  break;
10125  case eRNAND:
10126  nodeMask = 0;
10127  break;
10128  case eROR:
10129  nodeMask = 0;
10130  break;
10131  case eRNOR:
10132  nodeMask = 0;
10133  break;
10134  case eRXOR:
10135  nodeMask = 0;
10136  break;
10137  case eRXNOR:
10138  nodeMask = 0;
10139  break;
10140  case eHOOK:
10141  nodeMask = 0;
10142  break;
10143  case eINIT:
10144  nodeMask = 0;
10145  break;
10146  case eALWAYS:
10147  nodeMask = 0;
10148  break;
10149  case eALWAYS_LATCH:
10150  nodeMask = 0;
10151  break;
10152  case eALWAYS_FF:
10153  nodeMask = 0;
10154  break;
10155  case eALWAYS_COMB:
10156  nodeMask = 0;
10157  break;
10158  case eEVENT:
10159  nodeMask = 0;
10160  break;
10161  case eBLOCK_REF:
10162  nodeMask = 1;
10163  if(Arg<CBlock*>(0)) Arg<CBlock*>(0)->PreVisit1( func, data );
10164  break;
10165  case eSPECIFY_REF:
10166  nodeMask = 1;
10167  if(Arg<CSpecify*>(0)) Arg<CSpecify*>(0)->PreVisit1( func, data );
10168  break;
10169  case eASSIGN:
10170  nodeMask = 0;
10171  break;
10172  case eADD_ASSIGN:
10173  nodeMask = 0;
10174  break;
10175  case eSUB_ASSIGN:
10176  nodeMask = 0;
10177  break;
10178  case eMUL_ASSIGN:
10179  nodeMask = 0;
10180  break;
10181  case eDIV_ASSIGN:
10182  nodeMask = 0;
10183  break;
10184  case eMOD_ASSIGN:
10185  nodeMask = 0;
10186  break;
10187  case eAND_ASSIGN:
10188  nodeMask = 0;
10189  break;
10190  case eOR_ASSIGN:
10191  nodeMask = 0;
10192  break;
10193  case eXOR_ASSIGN:
10194  nodeMask = 0;
10195  break;
10196  case eLSH_ASSIGN:
10197  nodeMask = 0;
10198  break;
10199  case eRSH_ASSIGN:
10200  nodeMask = 0;
10201  break;
10202  case eLSHA_ASSIGN:
10203  nodeMask = 0;
10204  break;
10205  case eRSHA_ASSIGN:
10206  nodeMask = 0;
10207  break;
10208  case eFORCE:
10209  nodeMask = 0;
10210  break;
10211  case eRELEASE:
10212  nodeMask = 0;
10213  break;
10214  case eNBASSIGN:
10215  nodeMask = 0;
10216  break;
10217  case ePOSEDGE:
10218  nodeMask = 0;
10219  break;
10220  case eNEGEDGE:
10221  nodeMask = 0;
10222  break;
10223  case eEDGE:
10224  nodeMask = 2;
10225  break;
10226  case eEVOR:
10227  nodeMask = 0;
10228  break;
10229  case eDELAY:
10230  nodeMask = 0;
10231  break;
10232  case eMTM:
10233  nodeMask = 0;
10234  break;
10235  case eIF:
10236  nodeMask = 0;
10237  break;
10238  case eFOREVER:
10239  nodeMask = 0;
10240  break;
10241  case eREPEAT:
10242  nodeMask = 0;
10243  break;
10244  case eWHILE:
10245  nodeMask = 0;
10246  break;
10247  case eWAIT:
10248  nodeMask = 0;
10249  break;
10250  case eFOR:
10251  nodeMask = 0;
10252  break;
10253  case eCASE:
10254  nodeMask = 0;
10255  break;
10256  case eCASEX:
10257  nodeMask = 0;
10258  break;
10259  case eCASEZ:
10260  nodeMask = 0;
10261  break;
10262  case eCASEITEM:
10263  nodeMask = 0;
10264  break;
10265  case eCASSIGN:
10266  nodeMask = 1;
10267  break;
10268  case eARG:
10269  nodeMask = 1;
10270  break;
10271  case eIMPORT:
10272  nodeMask = 1;
10273  break;
10274  case eFUNCTION_DEF:
10275  nodeMask = 1;
10276  if(Arg<CFunction*>(0)) Arg<CFunction*>(0)->PreVisit1( func, data );
10277  break;
10278  case eMODULE_DEF:
10279  nodeMask = 1;
10280  if(Arg<CModule*>(0)) Arg<CModule*>(0)->PreVisit1( func, data );
10281  break;
10282  case ePACKAGE_DEF:
10283  nodeMask = 1;
10284  if(Arg<CPackage*>(0)) Arg<CPackage*>(0)->PreVisit1( func, data );
10285  break;
10286  case eREPEAT_CONTROL:
10287  nodeMask = 0;
10288  break;
10289  case eDELAY_CONTROL:
10290  nodeMask = 0;
10291  break;
10292  case eEVENT_CONTROL:
10293  nodeMask = 0;
10294  break;
10295  case eEXTERNAL_REF:
10296  nodeMask = 1;
10297  break;
10298  case ePORT_DEF:
10299  nodeMask = 1;
10300  if(Arg<CPort*>(0)) Arg<CPort*>(0)->PreVisit1( func, data );
10301  break;
10302  case eDEFPARAM:
10303  nodeMask = 0;
10304  break;
10305  case ePATH:
10306  nodeMask = 45;
10307  break;
10308  case ePATH_ASSIGN:
10309  nodeMask = 0;
10310  break;
10311  case eIFNONE_PATH_ASSIGN:
10312  nodeMask = 0;
10313  break;
10314  case eTRIGGER:
10315  nodeMask = 0;
10316  break;
10317  case ePASSIGN:
10318  nodeMask = 0;
10319  break;
10320  case eDEASSIGN:
10321  nodeMask = 0;
10322  break;
10323  case eDISABLE:
10324  nodeMask = 1;
10325  break;
10326  case eATTRIBUTE:
10327  nodeMask = 1;
10328  if(Arg<CAttr*>(0)) Arg<CAttr*>(0)->PreVisit1( func, data );
10329  break;
10330  case eGIF:
10331  nodeMask = 0;
10332  break;
10333  case eGFOR:
10334  nodeMask = 0;
10335  break;
10336  case eGCASE:
10337  nodeMask = 0;
10338  break;
10339  case eTABLE:
10340  nodeMask = 0;
10341  break;
10342  case eTABLE_ENTRY:
10343  nodeMask = 0;
10344  break;
10345  case eTABLE_SYMBOL:
10346  nodeMask = 1;
10347  break;
10348  case ePORTLIST_END:
10349  nodeMask = 0;
10350  break;
10351  case eMACRO_EXPR:
10352  nodeMask = 1;
10353  break;
10354  case eENUM_SPEC:
10355  nodeMask = 1;
10356  break;
10357  case eMEMBER:
10358  nodeMask = 2;
10359  break;
10360  case eRETURN:
10361  nodeMask = 0;
10362  break;
10363  case ePREINC:
10364  nodeMask = 0;
10365  break;
10366  case ePOSTINC:
10367  nodeMask = 0;
10368  break;
10369  case ePREDEC:
10370  nodeMask = 0;
10371  break;
10372  case ePOSTDEC:
10373  nodeMask = 0;
10374  break;
10375  case eCAST:
10376  nodeMask = 0;
10377  break;
10378  }
10379 
10380  /*
10381  * special case LIST nodes for tail recursion optimizations
10382  */
10383  if( GetOp() != eLIST ) {
10384  for( int i = 0; i < ArgCount(); i++ ) {
10385  if( Arg<CNode*>(i) && !((nodeMask>>i)&1) ) Arg<CNode*>(i)->PreVisit1( func, data );
10386  }
10387  } else {
10388  CNode* n = this;
10389  while( 1 ) {
10390  if( n->Arg<CNode*>(0) ) {
10391  n->Arg<CNode*>(0)->PreVisit1( func, data );
10392  }
10393  if( !n->Arg<CNode*>(1) || n->Arg<CNode*>(1)->GetOp() != eLIST ) {
10394  break;
10395  }
10396  n = n->Arg<CNode*>(1);
10397  if( !(*func)( n, data ) ) {
10398  return;
10399  }
10400  if( n->GetAttributes() ) {
10401  n->GetAttributes()->PreVisit1( func, data );
10402  }
10403  }
10404  if( n->Arg<CNode*>(1) ) {
10405  n->Arg<CNode*>(1)->PreVisit1( func, data );
10406  }
10407  }
10408 }
10409 
10410 
10411 /***********************************************
10412  PostVisit1
10413  - traverse tree, evoking
10414  leaves then parent.
10415 ************************************************/
10416 void CNode::PostVisit1( void (*func)(CNode*, void*), void* data )
10417 {
10418  if( GetAttributes() ) {
10419  GetAttributes()->PostVisit1( func, data );
10420  }
10421 
10422  int nodeMask = 0;
10423  switch( GetOp() ) {
10424  case eERROR:
10425  nodeMask = 0;
10426  break;
10427  case eVCONSTANT:
10428  nodeMask = 1;
10429  break;
10430  case eRCONSTANT:
10431  nodeMask = 1;
10432  break;
10433  case eCOMMENT:
10434  nodeMask = 1;
10435  break;
10436  case eVRQ:
10437  nodeMask = 1;
10438  break;
10439  case ePRAGMA:
10440  nodeMask = 1;
10441  break;
10442  case eELIST:
10443  nodeMask = 0;
10444  break;
10445  case eWIDTH:
10446  nodeMask = 0;
10447  break;
10448  case eNOP:
10449  nodeMask = 0;
10450  break;
10451  case eSUB:
10452  nodeMask = 0;
10453  break;
10454  case eMUL:
10455  nodeMask = 0;
10456  break;
10457  case eDIV:
10458  nodeMask = 0;
10459  break;
10460  case ePOW:
10461  nodeMask = 0;
10462  break;
10463  case eADD:
10464  nodeMask = 0;
10465  break;
10466  case eLSH:
10467  nodeMask = 0;
10468  break;
10469  case eRSH:
10470  nodeMask = 0;
10471  break;
10472  case eLSHA:
10473  nodeMask = 0;
10474  break;
10475  case eRSHA:
10476  nodeMask = 0;
10477  break;
10478  case eMOD:
10479  nodeMask = 0;
10480  break;
10481  case eOR:
10482  nodeMask = 0;
10483  break;
10484  case eAND:
10485  nodeMask = 0;
10486  break;
10487  case eANDANDAND:
10488  nodeMask = 0;
10489  break;
10490  case eXOR:
10491  nodeMask = 0;
10492  break;
10493  case eXNOR:
10494  nodeMask = 0;
10495  break;
10496  case eINSTANCE_REF:
10497  nodeMask = 1;
10498  if(Arg<CInstance*>(0)) Arg<CInstance*>(0)->PostVisit1( func, data );
10499  break;
10500  case eGATE_REF:
10501  nodeMask = 1;
10502  if(Arg<CGate*>(0)) Arg<CGate*>(0)->PostVisit1( func, data );
10503  break;
10504  case eTASK_ENABLE:
10505  nodeMask = 1;
10506  break;
10507  case eSYSTASK_CALL:
10508  nodeMask = 1;
10509  break;
10510  case eTIMING_CALL:
10511  nodeMask = 1;
10512  break;
10513  case eFUNCTION_CALL:
10514  nodeMask = 5;
10515  break;
10516  case eARRAY:
10517  nodeMask = 0;
10518  break;
10519  case eNET_REF:
10520  nodeMask = ~0;
10521  break;
10522  case eVAR_REF:
10523  nodeMask = ~0;
10524  break;
10525  case ePARAM_REF:
10526  nodeMask = ~0;
10527  break;
10528  case ePORT_REF:
10529  nodeMask = ~0;
10530  break;
10531  case eFWD_REF:
10532  nodeMask = ~0;
10533  break;
10534  case eGENVAR_REF:
10535  nodeMask = ~0;
10536  break;
10537  case eENUM_REF:
10538  nodeMask = ~0;
10539  break;
10540  case eTYPE_REF:
10541  nodeMask = ~0;
10542  break;
10543  case eNET_DECL:
10544  nodeMask = 1;
10545  if(Arg<CNet*>(0)) Arg<CNet*>(0)->PostVisit1( func, data );
10546  break;
10547  case eVAR_DECL:
10548  nodeMask = 1;
10549  if(Arg<CVar*>(0)) Arg<CVar*>(0)->PostVisit1( func, data );
10550  break;
10551  case ePARAM_DECL:
10552  nodeMask = 1;
10553  if(Arg<CParam*>(0)) Arg<CParam*>(0)->PostVisit1( func, data );
10554  break;
10555  case eSPECPARAM_DECL:
10556  nodeMask = 1;
10557  if(Arg<CParam*>(0)) Arg<CParam*>(0)->PostVisit1( func, data );
10558  break;
10559  case ePORT_DECL:
10560  nodeMask = 1;
10561  if(Arg<CPortDir*>(0)) Arg<CPortDir*>(0)->PostVisit1( func, data );
10562  break;
10563  case eGENVAR_DECL:
10564  nodeMask = 1;
10565  if(Arg<CGenvar*>(0)) Arg<CGenvar*>(0)->PostVisit1( func, data );
10566  break;
10567  case eTYPEDEF_DECL:
10568  nodeMask = 1;
10569  if(Arg<CTypedef*>(0)) Arg<CTypedef*>(0)->PostVisit1( func, data );
10570  break;
10571  case eLIST:
10572  nodeMask = 0;
10573  break;
10574  case eRANGE:
10575  nodeMask = 0;
10576  break;
10577  case eSLICE:
10578  nodeMask = 0;
10579  break;
10580  case ePSLICE:
10581  nodeMask = 0;
10582  break;
10583  case eMSLICE:
10584  nodeMask = 0;
10585  break;
10586  case eCVRI:
10587  nodeMask = 0;
10588  break;
10589  case eCVIR:
10590  nodeMask = 0;
10591  break;
10592  case eREP:
10593  nodeMask = 0;
10594  break;
10595  case eCAT:
10596  nodeMask = 0;
10597  break;
10598  case eUCAT:
10599  nodeMask = 0;
10600  break;
10601  case eCOM:
10602  nodeMask = 0;
10603  break;
10604  case eNEG:
10605  nodeMask = 0;
10606  break;
10607  case ePLUS:
10608  nodeMask = 0;
10609  break;
10610  case eNOT:
10611  nodeMask = 0;
10612  break;
10613  case eGT:
10614  nodeMask = 0;
10615  break;
10616  case eGE:
10617  nodeMask = 0;
10618  break;
10619  case eLT:
10620  nodeMask = 0;
10621  break;
10622  case eLE:
10623  nodeMask = 0;
10624  break;
10625  case eLAND:
10626  nodeMask = 0;
10627  break;
10628  case eLOR:
10629  nodeMask = 0;
10630  break;
10631  case eCEQ:
10632  nodeMask = 0;
10633  break;
10634  case eCNE:
10635  nodeMask = 0;
10636  break;
10637  case eEQ:
10638  nodeMask = 0;
10639  break;
10640  case eNE:
10641  nodeMask = 0;
10642  break;
10643  case eRAND:
10644  nodeMask = 0;
10645  break;
10646  case eRNAND:
10647  nodeMask = 0;
10648  break;
10649  case eROR:
10650  nodeMask = 0;
10651  break;
10652  case eRNOR:
10653  nodeMask = 0;
10654  break;
10655  case eRXOR:
10656  nodeMask = 0;
10657  break;
10658  case eRXNOR:
10659  nodeMask = 0;
10660  break;
10661  case eHOOK:
10662  nodeMask = 0;
10663  break;
10664  case eINIT:
10665  nodeMask = 0;
10666  break;
10667  case eALWAYS:
10668  nodeMask = 0;
10669  break;
10670  case eALWAYS_LATCH:
10671  nodeMask = 0;
10672  break;
10673  case eALWAYS_FF:
10674  nodeMask = 0;
10675  break;
10676  case eALWAYS_COMB:
10677  nodeMask = 0;
10678  break;
10679  case eEVENT:
10680  nodeMask = 0;
10681  break;
10682  case eBLOCK_REF:
10683  nodeMask = 1;
10684  if(Arg<CBlock*>(0)) Arg<CBlock*>(0)->PostVisit1( func, data );
10685  break;
10686  case eSPECIFY_REF:
10687  nodeMask = 1;
10688  if(Arg<CSpecify*>(0)) Arg<CSpecify*>(0)->PostVisit1( func, data );
10689  break;
10690  case eASSIGN:
10691  nodeMask = 0;
10692  break;
10693  case eADD_ASSIGN:
10694  nodeMask = 0;
10695  break;
10696  case eSUB_ASSIGN:
10697  nodeMask = 0;
10698  break;
10699  case eMUL_ASSIGN:
10700  nodeMask = 0;
10701  break;
10702  case eDIV_ASSIGN:
10703  nodeMask = 0;
10704  break;
10705  case eMOD_ASSIGN:
10706  nodeMask = 0;
10707  break;
10708  case eAND_ASSIGN:
10709  nodeMask = 0;
10710  break;
10711  case eOR_ASSIGN:
10712  nodeMask = 0;
10713  break;
10714  case eXOR_ASSIGN:
10715  nodeMask = 0;
10716  break;
10717  case eLSH_ASSIGN:
10718  nodeMask = 0;
10719  break;
10720  case eRSH_ASSIGN:
10721  nodeMask = 0;
10722  break;
10723  case eLSHA_ASSIGN:
10724  nodeMask = 0;
10725  break;
10726  case eRSHA_ASSIGN:
10727  nodeMask = 0;
10728  break;
10729  case eFORCE:
10730  nodeMask = 0;
10731  break;
10732  case eRELEASE:
10733  nodeMask = 0;
10734  break;
10735  case eNBASSIGN:
10736  nodeMask = 0;
10737  break;
10738  case ePOSEDGE:
10739  nodeMask = 0;
10740  break;
10741  case eNEGEDGE:
10742  nodeMask = 0;
10743  break;
10744  case eEDGE:
10745  nodeMask = 2;
10746  break;
10747  case eEVOR:
10748  nodeMask = 0;
10749  break;
10750  case eDELAY:
10751  nodeMask = 0;
10752  break;
10753  case eMTM:
10754  nodeMask = 0;
10755  break;
10756  case eIF:
10757  nodeMask = 0;
10758  break;
10759  case eFOREVER:
10760  nodeMask = 0;
10761  break;
10762  case eREPEAT:
10763  nodeMask = 0;
10764  break;
10765  case eWHILE:
10766  nodeMask = 0;
10767  break;
10768  case eWAIT:
10769  nodeMask = 0;
10770  break;
10771  case eFOR:
10772  nodeMask = 0;
10773  break;
10774  case eCASE:
10775  nodeMask = 0;
10776  break;
10777  case eCASEX:
10778  nodeMask = 0;
10779  break;
10780  case eCASEZ:
10781  nodeMask = 0;
10782  break;
10783  case eCASEITEM:
10784  nodeMask = 0;
10785  break;
10786  case eCASSIGN:
10787  nodeMask = 1;
10788  break;
10789  case eARG:
10790  nodeMask = 1;
10791  break;
10792  case eIMPORT:
10793  nodeMask = 1;
10794  break;
10795  case eFUNCTION_DEF:
10796  nodeMask = 1;
10797  if(Arg<CFunction*>(0)) Arg<CFunction*>(0)->PostVisit1( func, data );
10798  break;
10799  case eMODULE_DEF:
10800  nodeMask = 1;
10801  if(Arg<CModule*>(0)) Arg<CModule*>(0)->PostVisit1( func, data );
10802  break;
10803  case ePACKAGE_DEF:
10804  nodeMask = 1;
10805  if(Arg<CPackage*>(0)) Arg<CPackage*>(0)->PostVisit1( func, data );
10806  break;
10807  case eREPEAT_CONTROL:
10808  nodeMask = 0;
10809  break;
10810  case eDELAY_CONTROL:
10811  nodeMask = 0;
10812  break;
10813  case eEVENT_CONTROL:
10814  nodeMask = 0;
10815  break;
10816  case eEXTERNAL_REF:
10817  nodeMask = 1;
10818  break;
10819  case ePORT_DEF:
10820  nodeMask = 1;
10821  if(Arg<CPort*>(0)) Arg<CPort*>(0)->PostVisit1( func, data );
10822  break;
10823  case eDEFPARAM:
10824  nodeMask = 0;
10825  break;
10826  case ePATH:
10827  nodeMask = 45;
10828  break;
10829  case ePATH_ASSIGN:
10830  nodeMask = 0;
10831  break;
10832  case eIFNONE_PATH_ASSIGN:
10833  nodeMask = 0;
10834  break;
10835  case eTRIGGER:
10836  nodeMask = 0;
10837  break;
10838  case ePASSIGN:
10839  nodeMask = 0;
10840  break;
10841  case eDEASSIGN:
10842  nodeMask = 0;
10843  break;
10844  case eDISABLE:
10845  nodeMask = 1;
10846  break;
10847  case eATTRIBUTE:
10848  nodeMask = 1;
10849  if(Arg<CAttr*>(0)) Arg<CAttr*>(0)->PostVisit1( func, data );
10850  break;
10851  case eGIF:
10852  nodeMask = 0;
10853  break;
10854  case eGFOR:
10855  nodeMask = 0;
10856  break;
10857  case eGCASE:
10858  nodeMask = 0;
10859  break;
10860  case eTABLE:
10861  nodeMask = 0;
10862  break;
10863  case eTABLE_ENTRY:
10864  nodeMask = 0;
10865  break;
10866  case eTABLE_SYMBOL:
10867  nodeMask = 1;
10868  break;
10869  case ePORTLIST_END:
10870  nodeMask = 0;
10871  break;
10872  case eMACRO_EXPR:
10873  nodeMask = 1;
10874  break;
10875  case eENUM_SPEC:
10876  nodeMask = 1;
10877  break;
10878  case eMEMBER:
10879  nodeMask = 2;
10880  break;
10881  case eRETURN:
10882  nodeMask = 0;
10883  break;
10884  case ePREINC:
10885  nodeMask = 0;
10886  break;
10887  case ePOSTINC:
10888  nodeMask = 0;
10889  break;
10890  case ePREDEC:
10891  nodeMask = 0;
10892  break;
10893  case ePOSTDEC:
10894  nodeMask = 0;
10895  break;
10896  case eCAST:
10897  nodeMask = 0;
10898  break;
10899  }
10900 
10901  /*
10902  * special case LIST nodes for tail recursion optimizations
10903  */
10904  if( GetOp() != eLIST ) {
10905  for( int i = 0; i < ArgCount(); i++ ) {
10906  if( Arg<CNode*>(i) && !((nodeMask>>i)&1) ) Arg<CNode*>(i)->PostVisit1( func, data );
10907  }
10908  } else {
10909  std::stack<CNode*> visitLog;
10910  CNode* n = this;
10911  while( 1 ) {
10912  if( n->Arg<CNode*>(0) ) {
10913  n->Arg<CNode*>(0)-> PostVisit1( func, data );
10914  }
10915  if( !n->Arg<CNode*>(1) || n->Arg<CNode*>(1)->GetOp() != eLIST ) {
10916  break;
10917  }
10918  visitLog.push(n);
10919  n = n->Arg<CNode*>(1);
10920  if( n->GetAttributes() ) {
10921  n->GetAttributes()->PostVisit1( func, data );
10922  }
10923  }
10924  if( n->Arg<CNode*>(1) ) {
10925  n->Arg<CNode*>(1)->PostVisit1( func, data );
10926  }
10927  while( !visitLog.empty() ) {
10928  CNode* top = visitLog.top();
10929  if( top->Arg<CNode*>(1) ) {
10930  (*func)(top->Arg<CNode*>(1),data);
10931  }
10932  visitLog.pop();
10933  }
10934  }
10935 
10936  (*func)( this, data );
10937 }
10938 
10939 /***********************************************
10940  PostSubVisit1
10941  - traverse tree, evoking
10942  leaves then parents, substituting
10943  results
10944 ************************************************/
10945 
10946 CNode* CNode::PostSubVisit1( CNode* (*func)(CNode*, void*), void* data )
10947 {
10948  if( GetAttributes() ) {
10949  SetAttributes( GetAttributes()->PostSubVisit1( func, data ) );
10950  }
10951 
10952  int nodeMask = 0;
10953  switch( GetOp() ) {
10954  case eERROR:
10955  nodeMask = 0;
10956  break;
10957  case eVCONSTANT:
10958  nodeMask = 1;
10959  break;
10960  case eRCONSTANT:
10961  nodeMask = 1;
10962  break;
10963  case eCOMMENT:
10964  nodeMask = 1;
10965  break;
10966  case eVRQ:
10967  nodeMask = 1;
10968  break;
10969  case ePRAGMA:
10970  nodeMask = 1;
10971  break;
10972  case eELIST:
10973  nodeMask = 0;
10974  break;
10975  case eWIDTH:
10976  nodeMask = 0;
10977  break;
10978  case eNOP:
10979  nodeMask = 0;
10980  break;
10981  case eSUB:
10982  nodeMask = 0;
10983  break;
10984  case eMUL:
10985  nodeMask = 0;
10986  break;
10987  case eDIV:
10988  nodeMask = 0;
10989  break;
10990  case ePOW:
10991  nodeMask = 0;
10992  break;
10993  case eADD:
10994  nodeMask = 0;
10995  break;
10996  case eLSH:
10997  nodeMask = 0;
10998  break;
10999  case eRSH:
11000  nodeMask = 0;
11001  break;
11002  case eLSHA:
11003  nodeMask = 0;
11004  break;
11005  case eRSHA:
11006  nodeMask = 0;
11007  break;
11008  case eMOD:
11009  nodeMask = 0;
11010  break;
11011  case eOR:
11012  nodeMask = 0;
11013  break;
11014  case eAND:
11015  nodeMask = 0;
11016  break;
11017  case eANDANDAND:
11018  nodeMask = 0;
11019  break;
11020  case eXOR:
11021  nodeMask = 0;
11022  break;
11023  case eXNOR:
11024  nodeMask = 0;
11025  break;
11026  case eINSTANCE_REF:
11027  nodeMask = 1;
11028  if(Arg<CInstance*>(0)) Arg<CInstance*>(0)->PostSubVisit1( func, data );
11029  break;
11030  case eGATE_REF:
11031  nodeMask = 1;
11032  if(Arg<CGate*>(0)) Arg<CGate*>(0)->PostSubVisit1( func, data );
11033  break;
11034  case eTASK_ENABLE:
11035  nodeMask = 1;
11036  break;
11037  case eSYSTASK_CALL:
11038  nodeMask = 1;
11039  break;
11040  case eTIMING_CALL:
11041  nodeMask = 1;
11042  break;
11043  case eFUNCTION_CALL:
11044  nodeMask = 5;
11045  break;
11046  case eARRAY:
11047  nodeMask = 0;
11048  break;
11049  case eNET_REF:
11050  nodeMask = ~0;
11051  break;
11052  case eVAR_REF:
11053  nodeMask = ~0;
11054  break;
11055  case ePARAM_REF:
11056  nodeMask = ~0;
11057  break;
11058  case ePORT_REF:
11059  nodeMask = ~0;
11060  break;
11061  case eFWD_REF:
11062  nodeMask = ~0;
11063  break;
11064  case eGENVAR_REF:
11065  nodeMask = ~0;
11066  break;
11067  case eENUM_REF:
11068  nodeMask = ~0;
11069  break;
11070  case eTYPE_REF:
11071  nodeMask = ~0;
11072  break;
11073  case eNET_DECL:
11074  nodeMask = 1;
11075  if(Arg<CNet*>(0)) Arg<CNet*>(0)->PostSubVisit1( func, data );
11076  break;
11077  case eVAR_DECL:
11078  nodeMask = 1;
11079  if(Arg<CVar*>(0)) Arg<CVar*>(0)->PostSubVisit1( func, data );
11080  break;
11081  case ePARAM_DECL:
11082  nodeMask = 1;
11083  if(Arg<CParam*>(0)) Arg<CParam*>(0)->PostSubVisit1( func, data );
11084  break;
11085  case eSPECPARAM_DECL:
11086  nodeMask = 1;
11087  if(Arg<CParam*>(0)) Arg<CParam*>(0)->PostSubVisit1( func, data );
11088  break;
11089  case ePORT_DECL:
11090  nodeMask = 1;
11091  if(Arg<CPortDir*>(0)) Arg<CPortDir*>(0)->PostSubVisit1( func, data );
11092  break;
11093  case eGENVAR_DECL:
11094  nodeMask = 1;
11095  if(Arg<CGenvar*>(0)) Arg<CGenvar*>(0)->PostSubVisit1( func, data );
11096  break;
11097  case eTYPEDEF_DECL:
11098  nodeMask = 1;
11099  if(Arg<CTypedef*>(0)) Arg<CTypedef*>(0)->PostSubVisit1( func, data );
11100  break;
11101  case eLIST:
11102  nodeMask = 0;
11103  break;
11104  case eRANGE:
11105  nodeMask = 0;
11106  break;
11107  case eSLICE:
11108  nodeMask = 0;
11109  break;
11110  case ePSLICE:
11111  nodeMask = 0;
11112  break;
11113  case eMSLICE:
11114  nodeMask = 0;
11115  break;
11116  case eCVRI:
11117  nodeMask = 0;
11118  break;
11119  case eCVIR:
11120  nodeMask = 0;
11121  break;
11122  case eREP:
11123  nodeMask = 0;
11124  break;
11125  case eCAT:
11126  nodeMask = 0;
11127  break;
11128  case eUCAT:
11129  nodeMask = 0;
11130  break;
11131  case eCOM:
11132  nodeMask = 0;
11133  break;
11134  case eNEG:
11135  nodeMask = 0;
11136  break;
11137  case ePLUS:
11138  nodeMask = 0;
11139  break;
11140  case eNOT:
11141  nodeMask = 0;
11142  break;
11143  case eGT:
11144  nodeMask = 0;
11145  break;
11146  case eGE:
11147  nodeMask = 0;
11148  break;
11149  case eLT:
11150  nodeMask = 0;
11151  break;
11152  case eLE:
11153  nodeMask = 0;
11154  break;
11155  case eLAND:
11156  nodeMask = 0;
11157  break;
11158  case eLOR:
11159  nodeMask = 0;
11160  break;
11161  case eCEQ:
11162  nodeMask = 0;
11163  break;
11164  case eCNE:
11165  nodeMask = 0;
11166  break;
11167  case eEQ:
11168  nodeMask = 0;
11169  break;
11170  case eNE:
11171  nodeMask = 0;
11172  break;
11173  case eRAND:
11174  nodeMask = 0;
11175  break;
11176  case eRNAND:
11177  nodeMask = 0;
11178  break;
11179  case eROR:
11180  nodeMask = 0;
11181  break;
11182  case eRNOR:
11183  nodeMask = 0;
11184  break;
11185  case eRXOR:
11186  nodeMask = 0;
11187  break;
11188  case eRXNOR:
11189  nodeMask = 0;
11190  break;
11191  case eHOOK:
11192  nodeMask = 0;
11193  break;
11194  case eINIT:
11195  nodeMask = 0;
11196  break;
11197  case eALWAYS:
11198  nodeMask = 0;
11199  break;
11200  case eALWAYS_LATCH:
11201  nodeMask = 0;
11202  break;
11203  case eALWAYS_FF:
11204  nodeMask = 0;
11205  break;
11206  case eALWAYS_COMB:
11207  nodeMask = 0;
11208  break;
11209  case eEVENT:
11210  nodeMask = 0;
11211  break;
11212  case eBLOCK_REF:
11213  nodeMask = 1;
11214  if(Arg<CBlock*>(0)) Arg<CBlock*>(0)->PostSubVisit1( func, data );
11215  break;
11216  case eSPECIFY_REF:
11217  nodeMask = 1;
11218  if(Arg<CSpecify*>(0)) Arg<CSpecify*>(0)->PostSubVisit1( func, data );
11219  break;
11220  case eASSIGN:
11221  nodeMask = 0;
11222  break;
11223  case eADD_ASSIGN:
11224  nodeMask = 0;
11225  break;
11226  case eSUB_ASSIGN:
11227  nodeMask = 0;
11228  break;
11229  case eMUL_ASSIGN:
11230  nodeMask = 0;
11231  break;
11232  case eDIV_ASSIGN:
11233  nodeMask = 0;
11234  break;
11235  case eMOD_ASSIGN:
11236  nodeMask = 0;
11237  break;
11238  case eAND_ASSIGN:
11239  nodeMask = 0;
11240  break;
11241  case eOR_ASSIGN:
11242  nodeMask = 0;
11243  break;
11244  case eXOR_ASSIGN:
11245  nodeMask = 0;
11246  break;
11247  case eLSH_ASSIGN:
11248  nodeMask = 0;
11249  break;
11250  case eRSH_ASSIGN:
11251  nodeMask = 0;
11252  break;
11253  case eLSHA_ASSIGN:
11254  nodeMask = 0;
11255  break;
11256  case eRSHA_ASSIGN:
11257  nodeMask = 0;
11258  break;
11259  case eFORCE:
11260  nodeMask = 0;
11261  break;
11262  case eRELEASE:
11263  nodeMask = 0;
11264  break;
11265  case eNBASSIGN:
11266  nodeMask = 0;
11267  break;
11268  case ePOSEDGE:
11269  nodeMask = 0;
11270  break;
11271  case eNEGEDGE:
11272  nodeMask = 0;
11273  break;
11274  case eEDGE:
11275  nodeMask = 2;
11276  break;
11277  case eEVOR:
11278  nodeMask = 0;
11279  break;
11280  case eDELAY:
11281  nodeMask = 0;
11282  break;
11283  case eMTM:
11284  nodeMask = 0;
11285  break;
11286  case eIF:
11287  nodeMask = 0;
11288  break;
11289  case eFOREVER:
11290  nodeMask = 0;
11291  break;
11292  case eREPEAT:
11293  nodeMask = 0;
11294  break;
11295  case eWHILE:
11296  nodeMask = 0;
11297  break;
11298  case eWAIT:
11299  nodeMask = 0;
11300  break;
11301  case eFOR:
11302  nodeMask = 0;
11303  break;
11304  case eCASE:
11305  nodeMask = 0;
11306  break;
11307  case eCASEX:
11308  nodeMask = 0;
11309  break;
11310  case eCASEZ:
11311  nodeMask = 0;
11312  break;
11313  case eCASEITEM:
11314  nodeMask = 0;
11315  break;
11316  case eCASSIGN:
11317  nodeMask = 1;
11318  break;
11319  case eARG:
11320  nodeMask = 1;
11321  break;
11322  case eIMPORT:
11323  nodeMask = 1;
11324  break;
11325  case eFUNCTION_DEF:
11326  nodeMask = 1;
11327  if(Arg<CFunction*>(0)) Arg<CFunction*>(0)->PostSubVisit1( func, data );
11328  break;
11329  case eMODULE_DEF:
11330  nodeMask = 1;
11331  if(Arg<CModule*>(0)) Arg<CModule*>(0)->PostSubVisit1( func, data );
11332  break;
11333  case ePACKAGE_DEF:
11334  nodeMask = 1;
11335  if(Arg<CPackage*>(0)) Arg<CPackage*>(0)->PostSubVisit1( func, data );
11336  break;
11337  case eREPEAT_CONTROL:
11338  nodeMask = 0;
11339  break;
11340  case eDELAY_CONTROL:
11341  nodeMask = 0;
11342  break;
11343  case eEVENT_CONTROL:
11344  nodeMask = 0;
11345  break;
11346  case eEXTERNAL_REF:
11347  nodeMask = 1;
11348  break;
11349  case ePORT_DEF:
11350  nodeMask = 1;
11351  if(Arg<CPort*>(0)) Arg<CPort*>(0)->PostSubVisit1( func, data );
11352  break;
11353  case eDEFPARAM:
11354  nodeMask = 0;
11355  break;
11356  case ePATH:
11357  nodeMask = 45;
11358  break;
11359  case ePATH_ASSIGN:
11360  nodeMask = 0;
11361  break;
11362  case eIFNONE_PATH_ASSIGN:
11363  nodeMask = 0;
11364  break;
11365  case eTRIGGER:
11366  nodeMask = 0;
11367  break;
11368  case ePASSIGN:
11369  nodeMask = 0;
11370  break;
11371  case eDEASSIGN:
11372  nodeMask = 0;
11373  break;
11374  case eDISABLE:
11375  nodeMask = 1;
11376  break;
11377  case eATTRIBUTE:
11378  nodeMask = 1;
11379  if(Arg<CAttr*>(0)) Arg<CAttr*>(0)->PostSubVisit1( func, data );
11380  break;
11381  case eGIF:
11382  nodeMask = 0;
11383  break;
11384  case eGFOR:
11385  nodeMask = 0;
11386  break;
11387  case eGCASE:
11388  nodeMask = 0;
11389  break;
11390  case eTABLE:
11391  nodeMask = 0;
11392  break;
11393  case eTABLE_ENTRY:
11394  nodeMask = 0;
11395  break;
11396  case eTABLE_SYMBOL:
11397  nodeMask = 1;
11398  break;
11399  case ePORTLIST_END:
11400  nodeMask = 0;
11401  break;
11402  case eMACRO_EXPR:
11403  nodeMask = 1;
11404  break;
11405  case eENUM_SPEC:
11406  nodeMask = 1;
11407  break;
11408  case eMEMBER:
11409  nodeMask = 2;
11410  break;
11411  case eRETURN:
11412  nodeMask = 0;
11413  break;
11414  case ePREINC:
11415  nodeMask = 0;
11416  break;
11417  case ePOSTINC:
11418  nodeMask = 0;
11419  break;
11420  case ePREDEC:
11421  nodeMask = 0;
11422  break;
11423  case ePOSTDEC:
11424  nodeMask = 0;
11425  break;
11426  case eCAST:
11427  nodeMask = 0;
11428  break;
11429  }
11430 
11431  /*
11432  * special case LIST nodes for tail recursion optimizations
11433  */
11434  if( GetOp() != eLIST ) {
11435  for( int i = 0; i < ArgCount(); i++ ) {
11436  if( Arg<CNode*>(i) && !((nodeMask>>i)&1) ) Arg<CNode*>(i) = Arg<CNode*>(i)->PostSubVisit1( func, data );
11437  }
11438  } else {
11439  std::stack<CNode*> visitLog;
11440  CNode* n = this;
11441  while( 1 ) {
11442  if( n->Arg<CNode*>(0) ) {
11443  n->Arg<CNode*>(0) = n->Arg<CNode*>(0)->
11444  PostSubVisit1( func, data );
11445  }
11446  if( !n->Arg<CNode*>(1) || n->Arg<CNode*>(1)->GetOp() != eLIST ) {
11447  break;
11448  }
11449  visitLog.push(n);
11450  n = n->Arg<CNode*>(1);
11451  if( n->GetAttributes() ) {
11452  n->SetAttributes( n->GetAttributes()->PostSubVisit1( func, data ) );
11453  }
11454  }
11455  if( n->Arg<CNode*>(1) ) {
11456  n->Arg<CNode*>(1) = n->Arg<CNode*>(1)->PostSubVisit1( func, data );
11457  }
11458  while( !visitLog.empty() ) {
11459  CNode* top = visitLog.top();
11460  if( top->Arg<CNode*>(1) ) {
11461  top->Arg<CNode*>(1) = (*func)(top->Arg<CNode*>(1),data);
11462  }
11463  visitLog.pop();
11464  }
11465  }
11466 
11467  return (*func)( this, data );
11468 }
11469 
11470 /***********************************************
11471  Hash
11472  - returns a unique hash number
11473  representing tree
11474  The following is always true:
11475  Equivilent(n1,n2) => Hash(n1) == Hash(n2)
11476 ************************************************/
11477 
11478 unsigned CNode::Hash()
11479 {
11480  unsigned result = GetOp();
11481  int nodeMask = 0;
11482  switch( GetOp() ) {
11483  case eERROR:
11484  nodeMask = 0;
11485  break;
11486  case eVCONSTANT:
11487  nodeMask = 1;
11488  result ^= Arg<CVector*>(0)->Hash();
11489  break;
11490  case eRCONSTANT:
11491  nodeMask = 1;
11492  result ^= strlen(Arg<char*>(0));
11493  break;
11494  case eCOMMENT:
11495  nodeMask = 1;
11496  result ^= strlen(Arg<char*>(0));
11497  break;
11498  case eVRQ:
11499  nodeMask = 1;
11500  result ^= strlen(Arg<char*>(0));
11501  break;
11502  case ePRAGMA:
11503  nodeMask = 1;
11504  result ^= strlen(Arg<char*>(0));
11505  break;
11506  case eELIST:
11507  nodeMask = 0;
11508  break;
11509  case eWIDTH:
11510  nodeMask = 0;
11511  break;
11512  case eNOP:
11513  nodeMask = 0;
11514  break;
11515  case eSUB:
11516  nodeMask = 0;
11517  break;
11518  case eMUL:
11519  nodeMask = 0;
11520  break;
11521  case eDIV:
11522  nodeMask = 0;
11523  break;
11524  case ePOW:
11525  nodeMask = 0;
11526  break;
11527  case eADD:
11528  nodeMask = 0;
11529  break;
11530  case eLSH:
11531  nodeMask = 0;
11532  break;
11533  case eRSH:
11534  nodeMask = 0;
11535  break;
11536  case eLSHA:
11537  nodeMask = 0;
11538  break;
11539  case eRSHA:
11540  nodeMask = 0;
11541  break;
11542  case eMOD:
11543  nodeMask = 0;
11544  break;
11545  case eOR:
11546  nodeMask = 0;
11547  break;
11548  case eAND:
11549  nodeMask = 0;
11550  break;
11551  case eANDANDAND:
11552  nodeMask = 0;
11553  break;
11554  case eXOR:
11555  nodeMask = 0;
11556  break;
11557  case eXNOR:
11558  nodeMask = 0;
11559  break;
11560  case eINSTANCE_REF:
11561  nodeMask = 1;
11562  result ^= Arg<unsigned long>(0);
11563  break;
11564  case eGATE_REF:
11565  nodeMask = 1;
11566  result ^= Arg<unsigned long>(0);
11567  break;
11568  case eTASK_ENABLE:
11569  nodeMask = 1;
11570  result ^= Arg<unsigned long>(0);
11571  break;
11572  case eSYSTASK_CALL:
11573  nodeMask = 1;
11574  result ^= Arg<unsigned long>(0);
11575  break;
11576  case eTIMING_CALL:
11577  nodeMask = 1;
11578  result ^= Arg<unsigned long>(0);
11579  break;
11580  case eFUNCTION_CALL:
11581  nodeMask = 5;
11582  result ^= Arg<unsigned long>(0);
11583  result ^= Arg<unsigned long>(2);
11584  break;
11585  case eARRAY:
11586  nodeMask = 0;
11587  break;
11588  case eNET_REF:
11589  nodeMask = 1;
11590  result ^= Arg<unsigned long>(0);
11591  break;
11592  case eVAR_REF:
11593  nodeMask = 1;
11594  result ^= Arg<unsigned long>(0);
11595  break;
11596  case ePARAM_REF:
11597  nodeMask = 1;
11598  result ^= Arg<unsigned long>(0);
11599  break;
11600  case ePORT_REF:
11601  nodeMask = 1;
11602  result ^= Arg<unsigned long>(0);
11603  break;
11604  case eFWD_REF:
11605  nodeMask = 1;
11606  result ^= Arg<unsigned long>(0);
11607  break;
11608  case eGENVAR_REF:
11609  nodeMask = 1;
11610  result ^= Arg<unsigned long>(0);
11611  break;
11612  case eENUM_REF:
11613  nodeMask = 1;
11614  result ^= Arg<unsigned long>(0);
11615  break;
11616  case eTYPE_REF:
11617  nodeMask = 1;
11618  result ^= Arg<unsigned long>(0);
11619  break;
11620  case eNET_DECL:
11621  nodeMask = 1;
11622  result ^= Arg<unsigned long>(0);
11623  break;
11624  case eVAR_DECL:
11625  nodeMask = 1;
11626  result ^= Arg<unsigned long>(0);
11627  break;
11628  case ePARAM_DECL:
11629  nodeMask = 1;
11630  result ^= Arg<unsigned long>(0);
11631  break;
11632  case eSPECPARAM_DECL:
11633  nodeMask = 1;
11634  result ^= Arg<unsigned long>(0);
11635  break;
11636  case ePORT_DECL:
11637  nodeMask = 1;
11638  result ^= Arg<unsigned long>(0);
11639  break;
11640  case eGENVAR_DECL:
11641  nodeMask = 1;
11642  result ^= Arg<unsigned long>(0);
11643  break;
11644  case eTYPEDEF_DECL:
11645  nodeMask = 1;
11646  result ^= Arg<unsigned long>(0);
11647  break;
11648  case eLIST:
11649  nodeMask = 0;
11650  break;
11651  case eRANGE:
11652  nodeMask = 0;
11653  break;
11654  case eSLICE:
11655  nodeMask = 0;
11656  break;
11657  case ePSLICE:
11658  nodeMask = 0;
11659  break;
11660  case eMSLICE:
11661  nodeMask = 0;
11662  break;
11663  case eCVRI:
11664  nodeMask = 0;
11665  break;
11666  case eCVIR:
11667  nodeMask = 0;
11668  break;
11669  case eREP:
11670  nodeMask = 0;
11671  break;
11672  case eCAT:
11673  nodeMask = 0;
11674  break;
11675  case eUCAT:
11676  nodeMask = 0;
11677  break;
11678  case eCOM:
11679  nodeMask = 0;
11680  break;
11681  case eNEG:
11682  nodeMask = 0;
11683  break;
11684  case ePLUS:
11685  nodeMask = 0;
11686  break;
11687  case eNOT:
11688  nodeMask = 0;
11689  break;
11690  case eGT:
11691  nodeMask = 0;
11692  break;
11693  case eGE:
11694  nodeMask = 0;
11695  break;
11696  case eLT:
11697  nodeMask = 0;
11698  break;
11699  case eLE:
11700  nodeMask = 0;
11701  break;
11702  case eLAND:
11703  nodeMask = 0;
11704  break;
11705  case eLOR:
11706  nodeMask = 0;
11707  break;
11708  case eCEQ:
11709  nodeMask = 0;
11710  break;
11711  case eCNE:
11712  nodeMask = 0;
11713  break;
11714  case eEQ:
11715  nodeMask = 0;
11716  break;
11717  case eNE:
11718  nodeMask = 0;
11719  break;
11720  case eRAND:
11721  nodeMask = 0;
11722  break;
11723  case eRNAND:
11724  nodeMask = 0;
11725  break;
11726  case eROR:
11727  nodeMask = 0;
11728  break;
11729  case eRNOR:
11730  nodeMask = 0;
11731  break;
11732  case eRXOR:
11733  nodeMask = 0;
11734  break;
11735  case eRXNOR:
11736  nodeMask = 0;
11737  break;
11738  case eHOOK:
11739  nodeMask = 0;
11740  break;
11741  case eINIT:
11742  nodeMask = 0;
11743  break;
11744  case eALWAYS:
11745  nodeMask = 0;
11746  break;
11747  case eALWAYS_LATCH:
11748  nodeMask = 0;
11749  break;
11750  case eALWAYS_FF:
11751  nodeMask = 0;
11752  break;
11753  case eALWAYS_COMB:
11754  nodeMask = 0;
11755  break;
11756  case eEVENT:
11757  nodeMask = 0;
11758  break;
11759  case eBLOCK_REF:
11760  nodeMask = 1;
11761  result ^= Arg<unsigned long>(0);
11762  break;
11763  case eSPECIFY_REF:
11764  nodeMask = 1;
11765  result ^= Arg<unsigned long>(0);
11766  break;
11767  case eASSIGN:
11768  nodeMask = 0;
11769  break;
11770  case eADD_ASSIGN:
11771  nodeMask = 0;
11772  break;
11773  case eSUB_ASSIGN:
11774  nodeMask = 0;
11775  break;
11776  case eMUL_ASSIGN:
11777  nodeMask = 0;
11778  break;
11779  case eDIV_ASSIGN:
11780  nodeMask = 0;
11781  break;
11782  case eMOD_ASSIGN:
11783  nodeMask = 0;
11784  break;
11785  case eAND_ASSIGN:
11786  nodeMask = 0;
11787  break;
11788  case eOR_ASSIGN:
11789  nodeMask = 0;
11790  break;
11791  case eXOR_ASSIGN:
11792  nodeMask = 0;
11793  break;
11794  case eLSH_ASSIGN:
11795  nodeMask = 0;
11796  break;
11797  case eRSH_ASSIGN:
11798  nodeMask = 0;
11799  break;
11800  case eLSHA_ASSIGN:
11801  nodeMask = 0;
11802  break;
11803  case eRSHA_ASSIGN:
11804  nodeMask = 0;
11805  break;
11806  case eFORCE:
11807  nodeMask = 0;
11808  break;
11809  case eRELEASE:
11810  nodeMask = 0;
11811  break;
11812  case eNBASSIGN:
11813  nodeMask = 0;
11814  break;
11815  case ePOSEDGE:
11816  nodeMask = 0;
11817  break;
11818  case eNEGEDGE:
11819  nodeMask = 0;
11820  break;
11821  case eEDGE:
11822  nodeMask = 2;
11823  result ^= (unsigned long)Arg<Edge_t>(1);
11824  break;
11825  case eEVOR:
11826  nodeMask = 0;
11827  break;
11828  case eDELAY:
11829  nodeMask = 0;
11830  break;
11831  case eMTM:
11832  nodeMask = 0;
11833  break;
11834  case eIF:
11835  nodeMask = 0;
11836  break;
11837  case eFOREVER:
11838  nodeMask = 0;
11839  break;
11840  case eREPEAT:
11841  nodeMask = 0;
11842  break;
11843  case eWHILE:
11844  nodeMask = 0;
11845  break;
11846  case eWAIT:
11847  nodeMask = 0;
11848  break;
11849  case eFOR:
11850  nodeMask = 0;
11851  break;
11852  case eCASE:
11853  nodeMask = 0;
11854  break;
11855  case eCASEX:
11856  nodeMask = 0;
11857  break;
11858  case eCASEZ:
11859  nodeMask = 0;
11860  break;
11861  case eCASEITEM:
11862  nodeMask = 0;
11863  break;
11864  case eCASSIGN:
11865  nodeMask = 1;
11866  result ^= Arg<unsigned long>(0);
11867  break;
11868  case eARG:
11869  nodeMask = 1;
11870  result ^= Arg<unsigned long>(0);
11871  break;
11872  case eIMPORT:
11873  nodeMask = 1;
11874  result ^= Arg<unsigned long>(0);
11875  break;
11876  case eFUNCTION_DEF:
11877  nodeMask = 1;
11878  result ^= Arg<unsigned long>(0);
11879  break;
11880  case eMODULE_DEF:
11881  nodeMask = 1;
11882  result ^= Arg<unsigned long>(0);
11883  break;
11884  case ePACKAGE_DEF:
11885  nodeMask = 1;
11886  result ^= Arg<unsigned long>(0);
11887  break;
11888  case eREPEAT_CONTROL:
11889  nodeMask = 0;
11890  break;
11891  case eDELAY_CONTROL:
11892  nodeMask = 0;
11893  break;
11894  case eEVENT_CONTROL:
11895  nodeMask = 0;
11896  break;
11897  case eEXTERNAL_REF:
11898  nodeMask = 1;
11899  result ^= Arg<unsigned long>(0);
11900  break;
11901  case ePORT_DEF:
11902  nodeMask = 1;
11903  result ^= Arg<unsigned long>(0);
11904  break;
11905  case eDEFPARAM:
11906  nodeMask = 0;
11907  break;
11908  case ePATH:
11909  nodeMask = 45;
11910  result ^= Arg<int>(0);
11911  result ^= Arg<int>(2);
11912  result ^= Arg<int>(3);
11913  result ^= Arg<int>(5);
11914  break;
11915  case ePATH_ASSIGN:
11916  nodeMask = 0;
11917  break;
11918  case eIFNONE_PATH_ASSIGN:
11919  nodeMask = 0;
11920  break;
11921  case eTRIGGER:
11922  nodeMask = 0;
11923  break;
11924  case ePASSIGN:
11925  nodeMask = 0;
11926  break;
11927  case eDEASSIGN:
11928  nodeMask = 0;
11929  break;
11930  case eDISABLE:
11931  nodeMask = 1;
11932  result ^= Arg<unsigned long>(0);
11933  break;
11934  case eATTRIBUTE:
11935  nodeMask = 1;
11936  result ^= Arg<unsigned long>(0);
11937  break;
11938  case eGIF:
11939  nodeMask = 0;
11940  break;
11941  case eGFOR:
11942  nodeMask = 0;
11943  break;
11944  case eGCASE:
11945  nodeMask = 0;
11946  break;
11947  case eTABLE:
11948  nodeMask = 0;
11949  break;
11950  case eTABLE_ENTRY:
11951  nodeMask = 0;
11952  break;
11953  case eTABLE_SYMBOL:
11954  nodeMask = 1;
11955  result ^= strlen(Arg<char*>(0));
11956  break;
11957  case ePORTLIST_END:
11958  nodeMask = 0;
11959  break;
11960  case eMACRO_EXPR:
11961  nodeMask = 1;
11962  result ^= strlen(Arg<char*>(0));
11963  break;
11964  case eENUM_SPEC:
11965  nodeMask = 1;
11966  result ^= Arg<unsigned long>(0);
11967  break;
11968  case eMEMBER:
11969  nodeMask = 2;
11970  result ^= Arg<unsigned long>(1);
11971  break;
11972  case eRETURN:
11973  nodeMask = 0;
11974  break;
11975  case ePREINC:
11976  nodeMask = 0;
11977  break;
11978  case ePOSTINC:
11979  nodeMask = 0;
11980  break;
11981  case ePREDEC:
11982  nodeMask = 0;
11983  break;
11984  case ePOSTDEC:
11985  nodeMask = 0;
11986  break;
11987  case eCAST:
11988  nodeMask = 0;
11989  break;
11990  }
11991 
11992  for( int i = 0; i < ArgCount(); i++ ) {
11993  if( !((nodeMask>>i)&1) ) result ^= Arg<CNode*>(i)->Hash();
11994  }
11995  return result;
11996 }
11997 
11998 /***********************************************
11999  Equivalent
12000  - returns TRUE if both trees are equivalent
12001  Note: this currently will only match if
12002  the trees are structurally the same.
12003  It does not attempt rename and match
12004  leaf declarations.
12005  In the future this may be expanded
12006  to match if the trees are functionally
12007  equivalent.
12008 ************************************************/
12009 
12010 int Equivalent( CNode* a, CNode* b )
12011 {
12012  /*
12013  * handles NULL/NULL and trivial equivalence case
12014  */
12015  if( a == b ) {
12016  return TRUE;
12017  }
12018  /*
12019  * reject if one is NULL but not the other
12020  */
12021  if( a == NULL || b == NULL ) {
12022  return FALSE;
12023  }
12024  /*
12025  * reject if node types are different
12026  */
12027  if( a->GetOp() != b->GetOp() ) {
12028  return FALSE;
12029  }
12030 
12031  int nodeMask = 0;
12032  switch( a->GetOp() ) {
12033  case eERROR:
12034  nodeMask = 0;
12035  break;
12036  case eVCONSTANT:
12037  nodeMask = 1;
12038  if( !(*a->Arg<CVector*>(0)==*b->Arg<CVector*>(0)) ) { return FALSE; }
12039  break;
12040  case eRCONSTANT:
12041  nodeMask = 1;
12042  if( !(!strcmp(a->Arg<char*>(0),b->Arg<char*>(0))) ) { return FALSE; }
12043  break;
12044  case eCOMMENT:
12045  nodeMask = 1;
12046  if( !(!strcmp(a->Arg<char*>(0),b->Arg<char*>(0))) ) { return FALSE; }
12047  break;
12048  case eVRQ:
12049  nodeMask = 1;
12050  if( !(!strcmp(a->Arg<char*>(0),b->Arg<char*>(0))) ) { return FALSE; }
12051  break;
12052  case ePRAGMA:
12053  nodeMask = 1;
12054  if( !(!strcmp(a->Arg<char*>(0),b->Arg<char*>(0))) ) { return FALSE; }
12055  break;
12056  case eELIST:
12057  nodeMask = 0;
12058  break;
12059  case eWIDTH:
12060  nodeMask = 0;
12061  break;
12062  case eNOP:
12063  nodeMask = 0;
12064  break;
12065  case eSUB:
12066  nodeMask = 0;
12067  break;
12068  case eMUL:
12069  nodeMask = 0;
12070  break;
12071  case eDIV:
12072  nodeMask = 0;
12073  break;
12074  case ePOW:
12075  nodeMask = 0;
12076  break;
12077  case eADD:
12078  nodeMask = 0;
12079  break;
12080  case eLSH:
12081  nodeMask = 0;
12082  break;
12083  case eRSH:
12084  nodeMask = 0;
12085  break;
12086  case eLSHA:
12087  nodeMask = 0;
12088  break;
12089  case eRSHA:
12090  nodeMask = 0;
12091  break;
12092  case eMOD:
12093  nodeMask = 0;
12094  break;
12095  case eOR:
12096  nodeMask = 0;
12097  break;
12098  case eAND:
12099  nodeMask = 0;
12100  break;
12101  case eANDANDAND:
12102  nodeMask = 0;
12103  break;
12104  case eXOR:
12105  nodeMask = 0;
12106  break;
12107  case eXNOR:
12108  nodeMask = 0;
12109  break;
12110  case eINSTANCE_REF:
12111  nodeMask = 1;
12112  if( !(a->Arg<CInstance*>(0)==b->Arg<CInstance*>(0)) ) { return FALSE; }
12113  break;
12114  case eGATE_REF:
12115  nodeMask = 1;
12116  if( !(a->Arg<CGate*>(0)==b->Arg<CGate*>(0)) ) { return FALSE; }
12117  break;
12118  case eTASK_ENABLE:
12119  nodeMask = 1;
12120  if( !(a->Arg<CSymbol*>(0)==b->Arg<CSymbol*>(0)) ) { return FALSE; }
12121  break;
12122  case eSYSTASK_CALL:
12123  nodeMask = 1;
12124  if( !(a->Arg<CSymbol*>(0)==b->Arg<CSymbol*>(0)) ) { return FALSE; }
12125  break;
12126  case eTIMING_CALL:
12127  nodeMask = 1;
12128  if( !(a->Arg<CSymbol*>(0)==b->Arg<CSymbol*>(0)) ) { return FALSE; }
12129  break;
12130  case eFUNCTION_CALL:
12131  nodeMask = 5;
12132  if( !(a->Arg<CSymbol*>(0)==b->Arg<CSymbol*>(0)) ) { return FALSE; }
12133  if( !(a->Arg<CScope*>(2)==b->Arg<CScope*>(2)) ) { return FALSE; }
12134  break;
12135  case eARRAY:
12136  nodeMask = 0;
12137  break;
12138  case eNET_REF:
12139  nodeMask = 1;
12140  if( !(a->Arg<CNet*>(0)==b->Arg<CNet*>(0)) ) { return FALSE; }
12141  break;
12142  case eVAR_REF:
12143  nodeMask = 1;
12144  if( !(a->Arg<CVar*>(0)==b->Arg<CVar*>(0)) ) { return FALSE; }
12145  break;
12146  case ePARAM_REF:
12147  nodeMask = 1;
12148  if( !(a->Arg<CParam*>(0)==b->Arg<CParam*>(0)) ) { return FALSE; }
12149  break;
12150  case ePORT_REF:
12151  nodeMask = 1;
12152  if( !(a->Arg<CPortDir*>(0)==b->Arg<CPortDir*>(0)) ) { return FALSE; }
12153  break;
12154  case eFWD_REF:
12155  nodeMask = 1;
12156  if( !(a->Arg<CFref*>(0)==b->Arg<CFref*>(0)) ) { return FALSE; }
12157  break;
12158  case eGENVAR_REF:
12159  nodeMask = 1;
12160  if( !(a->Arg<CGenvar*>(0)==b->Arg<CGenvar*>(0)) ) { return FALSE; }
12161  break;
12162  case eENUM_REF:
12163  nodeMask = 1;
12164  MASSERT(FALSE); // arg0<CEnum*>
12165  break;
12166  case eTYPE_REF:
12167  nodeMask = 1;
12168  MASSERT(FALSE); // arg0<CTypedef*>
12169  break;
12170  case eNET_DECL:
12171  nodeMask = 1;
12172  if( !(a->Arg<CNet*>(0)==b->Arg<CNet*>(0)) ) { return FALSE; }
12173  break;
12174  case eVAR_DECL:
12175  nodeMask = 1;
12176  if( !(a->Arg<CVar*>(0)==b->Arg<CVar*>(0)) ) { return FALSE; }
12177  break;
12178  case ePARAM_DECL:
12179  nodeMask = 1;
12180  if( !(a->Arg<CParam*>(0)==b->Arg<CParam*>(0)) ) { return FALSE; }
12181  break;
12182  case eSPECPARAM_DECL:
12183  nodeMask = 1;
12184  if( !(a->Arg<CParam*>(0)==b->Arg<CParam*>(0)) ) { return FALSE; }
12185  break;
12186  case ePORT_DECL:
12187  nodeMask = 1;
12188  if( !(a->Arg<CPortDir*>(0)==b->Arg<CPortDir*>(0)) ) { return FALSE; }
12189  break;
12190  case eGENVAR_DECL:
12191  nodeMask = 1;
12192  if( !(a->Arg<CGenvar*>(0)==b->Arg<CGenvar*>(0)) ) { return FALSE; }
12193  break;
12194  case eTYPEDEF_DECL:
12195  nodeMask = 1;
12196  MASSERT(FALSE); // arg0<CTypedef*>
12197  break;
12198  case eLIST:
12199  nodeMask = 0;
12200  break;
12201  case eRANGE:
12202  nodeMask = 0;
12203  break;
12204  case eSLICE:
12205  nodeMask = 0;
12206  break;
12207  case ePSLICE:
12208  nodeMask = 0;
12209  break;
12210  case eMSLICE:
12211  nodeMask = 0;
12212  break;
12213  case eCVRI:
12214  nodeMask = 0;
12215  break;
12216  case eCVIR:
12217  nodeMask = 0;
12218  break;
12219  case eREP:
12220  nodeMask = 0;
12221  break;
12222  case eCAT:
12223  nodeMask = 0;
12224  break;
12225  case eUCAT:
12226  nodeMask = 0;
12227  break;
12228  case eCOM:
12229  nodeMask = 0;
12230  break;
12231  case eNEG:
12232  nodeMask = 0;
12233  break;
12234  case ePLUS:
12235  nodeMask = 0;
12236  break;
12237  case eNOT:
12238  nodeMask = 0;
12239  break;
12240  case eGT:
12241  nodeMask = 0;
12242  break;
12243  case eGE:
12244  nodeMask = 0;
12245  break;
12246  case eLT:
12247  nodeMask = 0;
12248  break;
12249  case eLE:
12250  nodeMask = 0;
12251  break;
12252  case eLAND:
12253  nodeMask = 0;
12254  break;
12255  case eLOR:
12256  nodeMask = 0;
12257  break;
12258  case eCEQ:
12259  nodeMask = 0;
12260  break;
12261  case eCNE:
12262  nodeMask = 0;
12263  break;
12264  case eEQ:
12265  nodeMask = 0;
12266  break;
12267  case eNE:
12268  nodeMask = 0;
12269  break;
12270  case eRAND:
12271  nodeMask = 0;
12272  break;
12273  case eRNAND:
12274  nodeMask = 0;
12275  break;
12276  case eROR:
12277  nodeMask = 0;
12278  break;
12279  case eRNOR:
12280  nodeMask = 0;
12281  break;
12282  case eRXOR:
12283  nodeMask = 0;
12284  break;
12285  case eRXNOR:
12286  nodeMask = 0;
12287  break;
12288  case eHOOK:
12289  nodeMask = 0;
12290  break;
12291  case eINIT:
12292  nodeMask = 0;
12293  break;
12294  case eALWAYS:
12295  nodeMask = 0;
12296  break;
12297  case eALWAYS_LATCH:
12298  nodeMask = 0;
12299  break;
12300  case eALWAYS_FF:
12301  nodeMask = 0;
12302  break;
12303  case eALWAYS_COMB:
12304  nodeMask = 0;
12305  break;
12306  case eEVENT:
12307  nodeMask = 0;
12308  break;
12309  case eBLOCK_REF:
12310  nodeMask = 1;
12311  if( !(a->Arg<CBlock*>(0)==b->Arg<CBlock*>(0)) ) { return FALSE; }
12312  break;
12313  case eSPECIFY_REF:
12314  nodeMask = 1;
12315  if( !(a->Arg<CSpecify*>(0)==b->Arg<CSpecify*>(0)) ) { return FALSE; }
12316  break;
12317  case eASSIGN:
12318  nodeMask = 0;
12319  break;
12320  case eADD_ASSIGN:
12321  nodeMask = 0;
12322  break;
12323  case eSUB_ASSIGN:
12324  nodeMask = 0;
12325  break;
12326  case eMUL_ASSIGN:
12327  nodeMask = 0;
12328  break;
12329  case eDIV_ASSIGN:
12330  nodeMask = 0;
12331  break;
12332  case eMOD_ASSIGN:
12333  nodeMask = 0;
12334  break;
12335  case eAND_ASSIGN:
12336  nodeMask = 0;
12337  break;
12338  case eOR_ASSIGN:
12339  nodeMask = 0;
12340  break;
12341  case eXOR_ASSIGN:
12342  nodeMask = 0;
12343  break;
12344  case eLSH_ASSIGN:
12345  nodeMask = 0;
12346  break;
12347  case eRSH_ASSIGN:
12348  nodeMask = 0;
12349  break;
12350  case eLSHA_ASSIGN:
12351  nodeMask = 0;
12352  break;
12353  case eRSHA_ASSIGN:
12354  nodeMask = 0;
12355  break;
12356  case eFORCE:
12357  nodeMask = 0;
12358  break;
12359  case eRELEASE:
12360  nodeMask = 0;
12361  break;
12362  case eNBASSIGN:
12363  nodeMask = 0;
12364  break;
12365  case ePOSEDGE:
12366  nodeMask = 0;
12367  break;
12368  case eNEGEDGE:
12369  nodeMask = 0;
12370  break;
12371  case eEDGE:
12372  nodeMask = 2;
12373  if( !(a->Arg<Edge_t>(1)==b->Arg<Edge_t>(1)) ) { return FALSE; }
12374  break;
12375  case eEVOR:
12376  nodeMask = 0;
12377  break;
12378  case eDELAY:
12379  nodeMask = 0;
12380  break;
12381  case eMTM:
12382  nodeMask = 0;
12383  break;
12384  case eIF:
12385  nodeMask = 0;
12386  break;
12387  case eFOREVER:
12388  nodeMask = 0;
12389  break;
12390  case eREPEAT:
12391  nodeMask = 0;
12392  break;
12393  case eWHILE:
12394  nodeMask = 0;
12395  break;
12396  case eWAIT:
12397  nodeMask = 0;
12398  break;
12399  case eFOR:
12400  nodeMask = 0;
12401  break;
12402  case eCASE:
12403  nodeMask = 0;
12404  break;
12405  case eCASEX:
12406  nodeMask = 0;
12407  break;
12408  case eCASEZ:
12409  nodeMask = 0;
12410  break;
12411  case eCASEITEM:
12412  nodeMask = 0;
12413  break;
12414  case eCASSIGN:
12415  nodeMask = 1;
12416  if( !(a->Arg<StrengthPair_t*>(0)==b->Arg<StrengthPair_t*>(0)) ) { return FALSE; }
12417  break;
12418  case eARG:
12419  nodeMask = 1;
12420  if( !(a->Arg<CSymbol*>(0)==b->Arg<CSymbol*>(0)) ) { return FALSE; }
12421  break;
12422  case eIMPORT:
12423  nodeMask = 1;
12424  if( !(a->Arg<CSymbol*>(0)==b->Arg<CSymbol*>(0)) ) { return FALSE; }
12425  break;
12426  case eFUNCTION_DEF:
12427  nodeMask = 1;
12428  if( !(a->Arg<CFunction*>(0)==b->Arg<CFunction*>(0)) ) { return FALSE; }
12429  break;
12430  case eMODULE_DEF:
12431  nodeMask = 1;
12432  if( !(a->Arg<CModule*>(0)==b->Arg<CModule*>(0)) ) { return FALSE; }
12433  break;
12434  case ePACKAGE_DEF:
12435  nodeMask = 1;
12436  if( !(a->Arg<CPackage*>(0)==b->Arg<CPackage*>(0)) ) { return FALSE; }
12437  break;
12438  case eREPEAT_CONTROL:
12439  nodeMask = 0;
12440  break;
12441  case eDELAY_CONTROL:
12442  nodeMask = 0;
12443  break;
12444  case eEVENT_CONTROL:
12445  nodeMask = 0;
12446  break;
12447  case eEXTERNAL_REF:
12448  nodeMask = 1;
12449  if( !(a->Arg<CSymbol*>(0)==b->Arg<CSymbol*>(0)) ) { return FALSE; }
12450  break;
12451  case ePORT_DEF:
12452  nodeMask = 1;
12453  if( !(a->Arg<CPort*>(0)==b->Arg<CPort*>(0)) ) { return FALSE; }
12454  break;
12455  case eDEFPARAM:
12456  nodeMask = 0;
12457  break;
12458  case ePATH:
12459  nodeMask = 45;
12460  if( !(a->Arg<int>(0)==b->Arg<int>(0)) ) { return FALSE; }
12461  if( !(a->Arg<int>(2)==b->Arg<int>(2)) ) { return FALSE; }
12462  if( !(a->Arg<int>(3)==b->Arg<int>(3)) ) { return FALSE; }
12463  if( !(a->Arg<int>(5)==b->Arg<int>(5)) ) { return FALSE; }
12464  break;
12465  case ePATH_ASSIGN:
12466  nodeMask = 0;
12467  break;
12468  case eIFNONE_PATH_ASSIGN:
12469  nodeMask = 0;
12470  break;
12471  case eTRIGGER:
12472  nodeMask = 0;
12473  break;
12474  case ePASSIGN:
12475  nodeMask = 0;
12476  break;
12477  case eDEASSIGN:
12478  nodeMask = 0;
12479  break;
12480  case eDISABLE:
12481  nodeMask = 1;
12482  if( !(a->Arg<CSymbol*>(0)==b->Arg<CSymbol*>(0)) ) { return FALSE; }
12483  break;
12484  case eATTRIBUTE:
12485  nodeMask = 1;
12486  if( !(a->Arg<CAttr*>(0)==b->Arg<CAttr*>(0)) ) { return FALSE; }
12487  break;
12488  case eGIF:
12489  nodeMask = 0;
12490  break;
12491  case eGFOR:
12492  nodeMask = 0;
12493  break;
12494  case eGCASE:
12495  nodeMask = 0;
12496  break;
12497  case eTABLE:
12498  nodeMask = 0;
12499  break;
12500  case eTABLE_ENTRY:
12501  nodeMask = 0;
12502  break;
12503  case eTABLE_SYMBOL:
12504  nodeMask = 1;
12505  if( !(!strcmp(a->Arg<char*>(0),b->Arg<char*>(0))) ) { return FALSE; }
12506  break;
12507  case ePORTLIST_END:
12508  nodeMask = 0;
12509  break;
12510  case eMACRO_EXPR:
12511  nodeMask = 1;
12512  if( !(!strcmp(a->Arg<char*>(0),b->Arg<char*>(0))) ) { return FALSE; }
12513  break;
12514  case eENUM_SPEC:
12515  nodeMask = 1;
12516  if( !(a->Arg<CSymbol*>(0)==b->Arg<CSymbol*>(0)) ) { return FALSE; }
12517  break;
12518  case eMEMBER:
12519  nodeMask = 2;
12520  if( !(a->Arg<CSymbol*>(1)==b->Arg<CSymbol*>(1)) ) { return FALSE; }
12521  break;
12522  case eRETURN:
12523  nodeMask = 0;
12524  break;
12525  case ePREINC:
12526  nodeMask = 0;
12527  break;
12528  case ePOSTINC:
12529  nodeMask = 0;
12530  break;
12531  case ePREDEC:
12532  nodeMask = 0;
12533  break;
12534  case ePOSTDEC:
12535  nodeMask = 0;
12536  break;
12537  case eCAST:
12538  nodeMask = 0;
12539  break;
12540  }
12541 
12542  for( int i = 0; i < a->ArgCount(); i++ ) {
12543  if( !((nodeMask>>i)&1) &&
12544  !Equivalent(a->Arg<CNode*>(i),b->Arg<CNode*>(i)) ) return FALSE;
12545  }
12546  return TRUE;
12547 }
12548 
12549 /*************************************************
12550  IsEvaluateable
12551  - returns true if expression can be evaluated
12552 **************************************************/
12553 
12555 {
12556  switch( op ) {
12557  case eFUNCTION_CALL:
12558  return CFunction::Evaluateable(Arg<CSymbol*>(0),Arg<CNode*>(1),Arg<CBlock*>(2));;
12559  case ePARAM_REF:
12560  return Arg<CParam*>(0)->GetExpression()->IsEvaluateable();
12561  case eENUM_REF:
12562  return Arg<CParam*>(0)->GetExpression()->IsEvaluateable();
12563  case eMACRO_EXPR:
12564  return Arg<CNode*>(1) ? Arg<CNode*>(1)->IsEvaluateable() : FALSE;
12565  case eVCONSTANT:
12566  case eRCONSTANT:
12567  return TRUE;
12568  case eWIDTH:
12569  case eSUB:
12570  case eMUL:
12571  case eDIV:
12572  case ePOW:
12573  case eADD:
12574  case eLSH:
12575  case eRSH:
12576  case eLSHA:
12577  case eRSHA:
12578  case eMOD:
12579  case eOR:
12580  case eAND:
12581  case eXOR:
12582  case eXNOR:
12583  case eCVRI:
12584  case eCVIR:
12585  case eREP:
12586  case eCAT:
12587  case eUCAT:
12588  case eCOM:
12589  case eNEG:
12590  case ePLUS:
12591  case eNOT:
12592  case eGT:
12593  case eGE:
12594  case eLT:
12595  case eLE:
12596  case eLAND:
12597  case eLOR:
12598  case eCEQ:
12599  case eCNE:
12600  case eEQ:
12601  case eNE:
12602  case eRAND:
12603  case eRNAND:
12604  case eROR:
12605  case eRNOR:
12606  case eRXOR:
12607  case eRXNOR:
12608  case eHOOK:
12609  break;
12610  case eERROR:
12611  case eCOMMENT:
12612  case eVRQ:
12613  case ePRAGMA:
12614  case eELIST:
12615  case eNOP:
12616  case eANDANDAND:
12617  case eINSTANCE_REF:
12618  case eGATE_REF:
12619  case eTASK_ENABLE:
12620  case eSYSTASK_CALL:
12621  case eTIMING_CALL:
12622  case eARRAY:
12623  case eNET_REF:
12624  case eVAR_REF:
12625  case ePORT_REF:
12626  case eFWD_REF:
12627  case eGENVAR_REF:
12628  case eTYPE_REF:
12629  case eNET_DECL:
12630  case eVAR_DECL:
12631  case ePARAM_DECL:
12632  case eSPECPARAM_DECL:
12633  case ePORT_DECL:
12634  case eGENVAR_DECL:
12635  case eTYPEDEF_DECL:
12636  case eLIST:
12637  case eRANGE:
12638  case eSLICE:
12639  case ePSLICE:
12640  case eMSLICE:
12641  case eINIT:
12642  case eALWAYS:
12643  case eALWAYS_LATCH:
12644  case eALWAYS_FF:
12645  case eALWAYS_COMB:
12646  case eEVENT:
12647  case eBLOCK_REF:
12648  case eSPECIFY_REF:
12649  case eASSIGN:
12650  case eADD_ASSIGN:
12651  case eSUB_ASSIGN:
12652  case eMUL_ASSIGN:
12653  case eDIV_ASSIGN:
12654  case eMOD_ASSIGN:
12655  case eAND_ASSIGN:
12656  case eOR_ASSIGN:
12657  case eXOR_ASSIGN:
12658  case eLSH_ASSIGN:
12659  case eRSH_ASSIGN:
12660  case eLSHA_ASSIGN:
12661  case eRSHA_ASSIGN:
12662  case eFORCE:
12663  case eRELEASE:
12664  case eNBASSIGN:
12665  case ePOSEDGE:
12666  case eNEGEDGE:
12667  case eEDGE:
12668  case eEVOR:
12669  case eDELAY:
12670  case eMTM:
12671  case eIF:
12672  case eFOREVER:
12673  case eREPEAT:
12674  case eWHILE:
12675  case eWAIT:
12676  case eFOR:
12677  case eCASE:
12678  case eCASEX:
12679  case eCASEZ:
12680  case eCASEITEM:
12681  case eCASSIGN:
12682  case eARG:
12683  case eIMPORT:
12684  case eFUNCTION_DEF:
12685  case eMODULE_DEF:
12686  case ePACKAGE_DEF:
12687  case eREPEAT_CONTROL:
12688  case eDELAY_CONTROL:
12689  case eEVENT_CONTROL:
12690  case eEXTERNAL_REF:
12691  case ePORT_DEF:
12692  case eDEFPARAM:
12693  case ePATH:
12694  case ePATH_ASSIGN:
12695  case eIFNONE_PATH_ASSIGN:
12696  case eTRIGGER:
12697  case ePASSIGN:
12698  case eDEASSIGN:
12699  case eDISABLE:
12700  case eATTRIBUTE:
12701  case eGIF:
12702  case eGFOR:
12703  case eGCASE:
12704  case eTABLE:
12705  case eTABLE_ENTRY:
12706  case eTABLE_SYMBOL:
12707  case ePORTLIST_END:
12708  case eENUM_SPEC:
12709  case eMEMBER:
12710  case eRETURN:
12711  case ePREINC:
12712  case ePOSTINC:
12713  case ePREDEC:
12714  case ePOSTDEC:
12715  case eCAST:
12716  return FALSE;
12717  default:
12718  MASSERT( FALSE );
12719  }
12720 
12721  for( int i = 0; i < ArgCount(); i++ ) {
12722  if( !Arg<CNode*>(i)->IsEvaluateable() ) return FALSE;
12723  }
12724 
12725  return TRUE;
12726 }
12727 
12728 /*************************************************
12729  _EvalVector
12730  - Helper function for EvalVector.
12731  Evaluates constant vector expression tree.
12732  Requires tree nodes to be labeled and
12733  augmented with conversion nodes.
12734 **************************************************/
12735 
12736 
12737 void CNode::_EvalVector( CVector& v )
12738 {
12739  switch( op ) {
12740  case eVCONSTANT:
12741  { int width = v.GetWidth(); v.SetWidth(Arg<CVector*>(0)->GetWidth()); v = *Arg<CVector*>(0); v.SetWidth(width); };
12742  break;
12743  case eWIDTH:
12744  {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;};
12745  break;
12746  case eSUB:
12747  EVAL_VECTOR_BINARY(Sub);
12748  break;
12749  case eMUL:
12750  EVAL_VECTOR_BINARY(Mul);
12751  break;
12752  case eDIV:
12753  EVAL_VECTOR_BINARY(Div);
12754  break;
12755  case ePOW:
12756  EVAL_VECTOR_BINARY(Pow);
12757  break;
12758  case eADD:
12759  EVAL_VECTOR_BINARY(Add);
12760  break;
12761  case eLSH:
12762  EVAL_VECTOR_BINARY_SELF_RIGHT(Lsh);
12763  break;
12764  case eRSH:
12765  EVAL_VECTOR_BINARY_SELF_RIGHT(Rsh);
12766  break;
12767  case eLSHA:
12768  EVAL_VECTOR_BINARY_SELF_RIGHT(Lsha);
12769  break;
12770  case eRSHA:
12771  EVAL_VECTOR_BINARY_SELF_RIGHT(Rsha);
12772  break;
12773  case eMOD:
12774  EVAL_VECTOR_BINARY(Mod);
12775  break;
12776  case eOR:
12777  EVAL_VECTOR_BINARY(Or);
12778  break;
12779  case eAND:
12780  EVAL_VECTOR_BINARY(And);
12781  break;
12782  case eXOR:
12783  EVAL_VECTOR_BINARY(Xor);
12784  break;
12785  case eXNOR:
12786  EVAL_VECTOR_BINARY(Xnor);
12787  break;
12788  case eFUNCTION_CALL:
12789  CFunction::EvalVector(v,Arg<CSymbol*>(0),Arg<CNode*>(1),Arg<CBlock*>(2));;
12790  break;
12791  case ePARAM_REF:
12792  EVAL_VECTOR_PARAM_REF();
12793  break;
12794  case eENUM_REF:
12795  EVAL_VECTOR_ENUM_REF();
12796  break;
12797  case eCVRI:
12798  v.LoadReal( Arg<CNode*>(0)->_EvalReal() );
12799  break;
12800  case eREP:
12801  EVAL_VECTOR_BINARY(Rep);
12802  break;
12803  case eCAT:
12804  EVAL_VECTOR_BINARY(Cat);
12805  break;
12806  case eUCAT:
12807  { CVector vv(Arg<CNode*>(0)->width); Arg<CNode*>(0)->_EvalVector(vv); v = vv;};
12808  break;
12809  case eCOM:
12810  EVAL_VECTOR_UNARY(Com);
12811  break;
12812  case eNEG:
12813  EVAL_VECTOR_UNARY(Neg);
12814  break;
12815  case ePLUS:
12816  EVAL_VECTOR_UNARY(Plus);
12817  break;
12818  case eNOT:
12819  EVAL_VECTOR_UNARY(Not);
12820  break;
12821  case eGT:
12822  EVAL_RELATIONAL(Gt);
12823  break;
12824  case eGE:
12825  EVAL_RELATIONAL(Ge);
12826  break;
12827  case eLT:
12828  EVAL_RELATIONAL(Lt);
12829  break;
12830  case eLE:
12831  EVAL_RELATIONAL(Le);
12832  break;
12833  case eLAND:
12834  EVAL_VECTOR_BINARY(Land);
12835  break;
12836  case eLOR:
12837  EVAL_VECTOR_BINARY(Lor);
12838  break;
12839  case eCEQ:
12840  EVAL_RELATIONAL(Ceq);
12841  break;
12842  case eCNE:
12843  EVAL_RELATIONAL(Cne);
12844  break;
12845  case eEQ:
12846  EVAL_RELATIONAL(Eq);
12847  break;
12848  case eNE:
12849  EVAL_RELATIONAL(Ne);
12850  break;
12851  case eRAND:
12852  EVAL_VECTOR_UNARY_SELF(Rand);
12853  break;
12854  case eRNAND:
12855  EVAL_VECTOR_UNARY_SELF(Rnand);
12856  break;
12857  case eROR:
12858  EVAL_VECTOR_UNARY_SELF(Ror);
12859  break;
12860  case eRNOR:
12861  EVAL_VECTOR_UNARY_SELF(Rnor);
12862  break;
12863  case eRXOR:
12864  EVAL_VECTOR_UNARY_SELF(Rxor);
12865  break;
12866  case eRXNOR:
12867  EVAL_VECTOR_UNARY_SELF(Rxnor);
12868  break;
12869  case eHOOK:
12870  EVAL_VECTOR_HOOK();
12871  break;
12872  case eMACRO_EXPR:
12873  Arg<CNode*>(1)->EvalVector(v);
12874  break;
12875  default:
12876  MASSERT( FALSE );
12877  }
12878 }
12879 
12880 
12881 /*************************************************
12882  _EvalReal
12883  - Helper function for EvalReal.
12884  Evaluates constant real expression tree.
12885  Requires tree nodes to be labeled and
12886  augmented with conversion nodes.
12887 **************************************************/
12888 
12889 double CNode::_EvalReal()
12890 {
12891  double d;
12892  switch( op ) {
12893  case eRCONSTANT:
12894  d = s2d(Arg<char*>(0));
12895  break;
12896  case eSUB:
12897  EVAL_REAL_BINARY(Sub);
12898  break;
12899  case eMUL:
12900  EVAL_REAL_BINARY(Mul);
12901  break;
12902  case eDIV:
12903  EVAL_REAL_BINARY(Div);
12904  break;
12905  case ePOW:
12906  EVAL_REAL_BINARY(Pow);
12907  break;
12908  case eADD:
12909  EVAL_REAL_BINARY(Add);
12910  break;
12911  case eFUNCTION_CALL:
12912  d = CFunction::EvalReal(Arg<CSymbol*>(0),Arg<CNode*>(1),Arg<CBlock*>(2));;
12913  break;
12914  case ePARAM_REF:
12915  EVAL_REAL_PARAM_REF();
12916  break;
12917  case eENUM_REF:
12918  EVAL_REAL_ENUM_REF();
12919  break;
12920  case eCVIR:
12921  { CVector v(Arg<CNode*>(0)->width); v.Signed(Arg<CNode*>(0)->type == eS); Arg<CNode*>(0)->_EvalVector(v); d = v.GetReal(); };
12922  break;
12923  case eNEG:
12924  EVAL_REAL_UNARY(Neg);
12925  break;
12926  case ePLUS:
12927  EVAL_REAL_UNARY(Plus);
12928  break;
12929  case eHOOK:
12930  EVAL_REAL_HOOK();
12931  break;
12932  case eMACRO_EXPR:
12933  d = Arg<CNode*>(1)->EvalReal();
12934  break;
12935  default:
12936  MASSERT( FALSE );
12937  }
12938  return d;
12939 }
12940 /************************************************
12941  ConditionalWiden
12942  - return non-zero if op conditionally
12943  widens operands
12944 **************************************************/
12945 int CNode::ConditionalWiden()
12946 {
12947  switch( GetOp() ) {
12948  case eVCONSTANT:
12949  return 0;
12950  case eRCONSTANT:
12951  return 0;
12952  case eELIST:
12953  return 0;
12954  case eWIDTH:
12955  return 0;
12956  case eSUB:
12957  return 0;
12958  case eMUL:
12959  return 0;
12960  case eDIV:
12961  return 0;
12962  case ePOW:
12963  return 0;
12964  case eADD:
12965  return 0;
12966  case eLSH:
12967  return 0;
12968  case eRSH:
12969  return 0;
12970  case eLSHA:
12971  return 0;
12972  case eRSHA:
12973  return 0;
12974  case eMOD:
12975  return 0;
12976  case eOR:
12977  return 1;
12978  case eAND:
12979  return 1;
12980  case eANDANDAND:
12981  return 0;
12982  case eXOR:
12983  return 1;
12984  case eXNOR:
12985  return 1;
12986  case eSYSTASK_CALL:
12987  return 0;
12988  case eFUNCTION_CALL:
12989  return 0;
12990  case eARRAY:
12991  return 0;
12992  case eNET_REF:
12993  return 0;
12994  case eVAR_REF:
12995  return 0;
12996  case ePARAM_REF:
12997  return 0;
12998  case ePORT_REF:
12999  return 0;
13000  case eFWD_REF:
13001  return 0;
13002  case eGENVAR_REF:
13003  return 0;
13004  case eENUM_REF:
13005  return 0;
13006  case eTYPE_REF:
13007  return 0;
13008  case eRANGE:
13009  return 0;
13010  case eSLICE:
13011  return 0;
13012  case ePSLICE:
13013  return 0;
13014  case eMSLICE:
13015  return 0;
13016  case eCVRI:
13017  return 0;
13018  case eCVIR:
13019  return 0;
13020  case eREP:
13021  return 0;
13022  case eCAT:
13023  return 0;
13024  case eUCAT:
13025  return 0;
13026  case eCOM:
13027  return 0;
13028  case eNEG:
13029  return 0;
13030  case ePLUS:
13031  return 0;
13032  case eNOT:
13033  return 0;
13034  case eGT:
13035  return 0;
13036  case eGE:
13037  return 0;
13038  case eLT:
13039  return 0;
13040  case eLE:
13041  return 0;
13042  case eLAND:
13043  return 0;
13044  case eLOR:
13045  return 0;
13046  case eCEQ:
13047  return 0;
13048  case eCNE:
13049  return 0;
13050  case eEQ:
13051  return 0;
13052  case eNE:
13053  return 0;
13054  case eRAND:
13055  return 0;
13056  case eRNAND:
13057  return 0;
13058  case eROR:
13059  return 0;
13060  case eRNOR:
13061  return 0;
13062  case eRXOR:
13063  return 0;
13064  case eRXNOR:
13065  return 0;
13066  case eHOOK:
13067  return 0;
13068  case ePOSEDGE:
13069  return 0;
13070  case eNEGEDGE:
13071  return 0;
13072  case eEVOR:
13073  return 0;
13074  case eMTM:
13075  return 0;
13076  case eEXTERNAL_REF:
13077  return 0;
13078  case eATTRIBUTE:
13079  return 0;
13080  case eMACRO_EXPR:
13081  return 0;
13082  case eMEMBER:
13083  return 0;
13084  case ePREINC:
13085  return 0;
13086  case ePOSTINC:
13087  return 0;
13088  case ePREDEC:
13089  return 0;
13090  case ePOSTDEC:
13091  return 0;
13092  case eCAST:
13093  return 0;
13094  default:
13095  MASSERT( FALSE );
13096  }
13097  return 0;
13098 }
13099 
13100 /************************************************
13101  NodeMask
13102  - return a bit vector with 1's where the
13103  type is CNode*
13104 **************************************************/
13105 unsigned CNode::NodeMask()
13106 {
13107  switch( GetOp() ) {
13108  case eERROR:
13109  return 0;
13110  case eVCONSTANT:
13111  return 0;
13112  case eRCONSTANT:
13113  return 0;
13114  case eCOMMENT:
13115  return 0;
13116  case eVRQ:
13117  return 0;
13118  case ePRAGMA:
13119  return 0;
13120  case eELIST:
13121  return 3;
13122  case eWIDTH:
13123  return 3;
13124  case eNOP:
13125  return 0;
13126  case eSUB:
13127  return 3;
13128  case eMUL:
13129  return 3;
13130  case eDIV:
13131  return 3;
13132  case ePOW:
13133  return 3;
13134  case eADD:
13135  return 3;
13136  case eLSH:
13137  return 3;
13138  case eRSH:
13139  return 3;
13140  case eLSHA:
13141  return 3;
13142  case eRSHA:
13143  return 3;
13144  case eMOD:
13145  return 3;
13146  case eOR:
13147  return 3;
13148  case eAND:
13149  return 3;
13150  case eANDANDAND:
13151  return 3;
13152  case eXOR:
13153  return 3;
13154  case eXNOR:
13155  return 3;
13156  case eINSTANCE_REF:
13157  return 0;
13158  case eGATE_REF:
13159  return 0;
13160  case eTASK_ENABLE:
13161  return 2;
13162  case eSYSTASK_CALL:
13163  return 2;
13164  case eTIMING_CALL:
13165  return 2;
13166  case eFUNCTION_CALL:
13167  return 2;
13168  case eARRAY:
13169  return 3;
13170  case eNET_REF:
13171  return 0;
13172  case eVAR_REF:
13173  return 0;
13174  case ePARAM_REF:
13175  return 0;
13176  case ePORT_REF:
13177  return 0;
13178  case eFWD_REF:
13179  return 0;
13180  case eGENVAR_REF:
13181  return 0;
13182  case eENUM_REF:
13183  return 0;
13184  case eTYPE_REF:
13185  return 0;
13186  case eNET_DECL:
13187  return 2;
13188  case eVAR_DECL:
13189  return 2;
13190  case ePARAM_DECL:
13191  return 0;
13192  case eSPECPARAM_DECL:
13193  return 0;
13194  case ePORT_DECL:
13195  return 0;
13196  case eGENVAR_DECL:
13197  return 0;
13198  case eTYPEDEF_DECL:
13199  return 0;
13200  case eLIST:
13201  return 3;
13202  case eRANGE:
13203  return 3;
13204  case eSLICE:
13205  return 3;
13206  case ePSLICE:
13207  return 3;
13208  case eMSLICE:
13209  return 3;
13210  case eCVRI:
13211  return 1;
13212  case eCVIR:
13213  return 1;
13214  case eREP:
13215  return 3;
13216  case eCAT:
13217  return 3;
13218  case eUCAT:
13219  return 1;
13220  case eCOM:
13221  return 1;
13222  case eNEG:
13223  return 1;
13224  case ePLUS:
13225  return 1;
13226  case eNOT:
13227  return 1;
13228  case eGT:
13229  return 3;
13230  case eGE:
13231  return 3;
13232  case eLT:
13233  return 3;
13234  case eLE:
13235  return 3;
13236  case eLAND:
13237  return 3;
13238  case eLOR:
13239  return 3;
13240  case eCEQ:
13241  return 3;
13242  case eCNE:
13243  return 3;
13244  case eEQ:
13245  return 3;
13246  case eNE:
13247  return 3;
13248  case eRAND:
13249  return 1;
13250  case eRNAND:
13251  return 1;
13252  case eROR:
13253  return 1;
13254  case eRNOR:
13255  return 1;
13256  case eRXOR:
13257  return 1;
13258  case eRXNOR:
13259  return 1;
13260  case eHOOK:
13261  return 7;
13262  case eINIT:
13263  return 1;
13264  case eALWAYS:
13265  return 1;
13266  case eALWAYS_LATCH:
13267  return 1;
13268  case eALWAYS_FF:
13269  return 1;
13270  case eALWAYS_COMB:
13271  return 1;
13272  case eEVENT:
13273  return 3;
13274  case eBLOCK_REF:
13275  return 2;
13276  case eSPECIFY_REF:
13277  return 2;
13278  case eASSIGN:
13279  return 7;
13280  case eADD_ASSIGN:
13281  return 7;
13282  case eSUB_ASSIGN:
13283  return 7;
13284  case eMUL_ASSIGN:
13285  return 7;
13286  case eDIV_ASSIGN:
13287  return 7;
13288  case eMOD_ASSIGN:
13289  return 7;
13290  case eAND_ASSIGN:
13291  return 7;
13292  case eOR_ASSIGN:
13293  return 7;
13294  case eXOR_ASSIGN:
13295  return 7;
13296  case eLSH_ASSIGN:
13297  return 7;
13298  case eRSH_ASSIGN:
13299  return 7;
13300  case eLSHA_ASSIGN:
13301  return 7;
13302  case eRSHA_ASSIGN:
13303  return 7;
13304  case eFORCE:
13305  return 3;
13306  case eRELEASE:
13307  return 1;
13308  case eNBASSIGN:
13309  return 7;
13310  case ePOSEDGE:
13311  return 1;
13312  case eNEGEDGE:
13313  return 1;
13314  case eEDGE:
13315  return 1;
13316  case eEVOR:
13317  return 3;
13318  case eDELAY:
13319  return 3;
13320  case eMTM:
13321  return 7;
13322  case eIF:
13323  return 7;
13324  case eFOREVER:
13325  return 1;
13326  case eREPEAT:
13327  return 3;
13328  case eWHILE:
13329  return 3;
13330  case eWAIT:
13331  return 3;
13332  case eFOR:
13333  return 15;
13334  case eCASE:
13335  return 3;
13336  case eCASEX:
13337  return 3;
13338  case eCASEZ:
13339  return 3;
13340  case eCASEITEM:
13341  return 3;
13342  case eCASSIGN:
13343  return 14;
13344  case eARG:
13345  return 2;
13346  case eIMPORT:
13347  return 0;
13348  case eFUNCTION_DEF:
13349  return 0;
13350  case eMODULE_DEF:
13351  return 0;
13352  case ePACKAGE_DEF:
13353  return 0;
13354  case eREPEAT_CONTROL:
13355  return 3;
13356  case eDELAY_CONTROL:
13357  return 1;
13358  case eEVENT_CONTROL:
13359  return 1;
13360  case eEXTERNAL_REF:
13361  return 0;
13362  case ePORT_DEF:
13363  return 0;
13364  case eDEFPARAM:
13365  return 3;
13366  case ePATH:
13367  return 82;
13368  case ePATH_ASSIGN:
13369  return 7;
13370  case eIFNONE_PATH_ASSIGN:
13371  return 3;
13372  case eTRIGGER:
13373  return 1;
13374  case ePASSIGN:
13375  return 3;
13376  case eDEASSIGN:
13377  return 1;
13378  case eDISABLE:
13379  return 0;
13380  case eATTRIBUTE:
13381  return 0;
13382  case eGIF:
13383  return 7;
13384  case eGFOR:
13385  return 15;
13386  case eGCASE:
13387  return 3;
13388  case eTABLE:
13389  return 1;
13390  case eTABLE_ENTRY:
13391  return 1;
13392  case eTABLE_SYMBOL:
13393  return 0;
13394  case ePORTLIST_END:
13395  return 0;
13396  case eMACRO_EXPR:
13397  return 2;
13398  case eENUM_SPEC:
13399  return 6;
13400  case eMEMBER:
13401  return 1;
13402  case eRETURN:
13403  return 1;
13404  case ePREINC:
13405  return 1;
13406  case ePOSTINC:
13407  return 1;
13408  case ePREDEC:
13409  return 1;
13410  case ePOSTDEC:
13411  return 1;
13412  case eCAST:
13413  return 3;
13414  default:
13415  MASSERT( FALSE );
13416  }
13417  return 0;
13418 }
13419 
13420 /************************************************
13421  WidthFixed
13422  - return non-zero if op has fixed
13423  self determined width
13424 **************************************************/
13425 int CNode::WidthFixed()
13426 {
13427  switch( GetOp() ) {
13428  case eVCONSTANT:
13429  return NodeMask()==0;
13430  case eRCONSTANT:
13431  return 1;
13432  case eELIST:
13433  return NodeMask()==0;
13434  case eWIDTH:
13435  return NodeMask()==0;
13436  case eSUB:
13437  return NodeMask()==0;
13438  case eMUL:
13439  return NodeMask()==0;
13440  case eDIV:
13441  return NodeMask()==0;
13442  case ePOW:
13443  return NodeMask()==0;
13444  case eADD:
13445  return NodeMask()==0;
13446  case eLSH:
13447  return NodeMask()==0;
13448  case eRSH:
13449  return NodeMask()==0;
13450  case eLSHA:
13451  return NodeMask()==0;
13452  case eRSHA:
13453  return NodeMask()==0;
13454  case eMOD:
13455  return NodeMask()==0;
13456  case eOR:
13457  return NodeMask()==0;
13458  case eAND:
13459  return NodeMask()==0;
13460  case eANDANDAND:
13461  return NodeMask()==0;
13462  case eXOR:
13463  return NodeMask()==0;
13464  case eXNOR:
13465  return NodeMask()==0;
13466  case eSYSTASK_CALL:
13467  return NodeMask()==0;
13468  case eFUNCTION_CALL:
13469  return NodeMask()==0;
13470  case eARRAY:
13471  return NodeMask()==0;
13472  case eNET_REF:
13473  return NodeMask()==0;
13474  case eVAR_REF:
13475  return NodeMask()==0;
13476  case ePARAM_REF:
13477  return NodeMask()==0;
13478  case ePORT_REF:
13479  return NodeMask()==0;
13480  case eFWD_REF:
13481  return NodeMask()==0;
13482  case eGENVAR_REF:
13483  return NodeMask()==0;
13484  case eENUM_REF:
13485  return NodeMask()==0;
13486  case eTYPE_REF:
13487  return 1;
13488  case eRANGE:
13489  return NodeMask()==0;
13490  case eSLICE:
13491  return NodeMask()==0;
13492  case ePSLICE:
13493  return NodeMask()==0;
13494  case eMSLICE:
13495  return NodeMask()==0;
13496  case eCVRI:
13497  return 1;
13498  case eCVIR:
13499  return 1;
13500  case eREP:
13501  return NodeMask()==0;
13502  case eCAT:
13503  return NodeMask()==0;
13504  case eUCAT:
13505  return NodeMask()==0;
13506  case eCOM:
13507  return NodeMask()==0;
13508  case eNEG:
13509  return NodeMask()==0;
13510  case ePLUS:
13511  return NodeMask()==0;
13512  case eNOT:
13513  return 1;
13514  case eGT:
13515  return 1;
13516  case eGE:
13517  return 1;
13518  case eLT:
13519  return 1;
13520  case eLE:
13521  return 1;
13522  case eLAND:
13523  return 1;
13524  case eLOR:
13525  return 1;
13526  case eCEQ:
13527  return 1;
13528  case eCNE:
13529  return 1;
13530  case eEQ:
13531  return 1;
13532  case eNE:
13533  return 1;
13534  case eRAND:
13535  return 1;
13536  case eRNAND:
13537  return 1;
13538  case eROR:
13539  return 1;
13540  case eRNOR:
13541  return 1;
13542  case eRXOR:
13543  return 1;
13544  case eRXNOR:
13545  return 1;
13546  case eHOOK:
13547  return NodeMask()==0;
13548  case ePOSEDGE:
13549  return NodeMask()==0;
13550  case eNEGEDGE:
13551  return NodeMask()==0;
13552  case eEVOR:
13553  return NodeMask()==0;
13554  case eMTM:
13555  return NodeMask()==0;
13556  case eEXTERNAL_REF:
13557  return NodeMask()==0;
13558  case eATTRIBUTE:
13559  return 1;
13560  case eMACRO_EXPR:
13561  return NodeMask()==0;
13562  case eMEMBER:
13563  return NodeMask()==0;
13564  case ePREINC:
13565  return NodeMask()==0;
13566  case ePOSTINC:
13567  return NodeMask()==0;
13568  case ePREDEC:
13569  return NodeMask()==0;
13570  case ePOSTDEC:
13571  return NodeMask()==0;
13572  case eCAST:
13573  return NodeMask()==0;
13574  default:
13575  MASSERT( FALSE );
13576  }
13577  return 0;
13578 }
13579 
13580 /************************************************
13581  _LabelBits
13582  - labels type and width fields bottom up
13583 **************************************************/
13586  int error;
13587 };
13588 
13589 void CNode::_LabelBits( CNode* n, void* arg )
13590 {
13591  /*
13592  * If label caching is enabled, don't remark nodes
13593  * already visited. Also disable caching when the
13594  * the eval stack is in use and the node was allocated from
13595  * it as its pointers are temporary and will be recycled.
13596  */
13597  if( labelCacheEnabled && (evalCount == 0 || !evalHeap.IsOwner(n)) ) {
13598  if( labelCache.find(n) != labelCache.end() ) {
13599  return;
13600  }
13601  labelCache[n] = 1;
13602  }
13603 
13604 
13605  LabelBitsInfo* info = (LabelBitsInfo*)arg;
13606  int suppressErrorMessages = info->suppressErrorMessages;
13607  unsigned nodeMask = n->NodeMask();
13608  int conditionalWiden = n->ConditionalWiden();
13609 
13610  switch( n->GetOp() ) {
13611  case eVCONSTANT:
13612  n->type = n->Arg<CVector*>(0)->GetNodeType();
13613  break;
13614  case eRCONSTANT:
13615  if(1) {
13616  n->type = eR;
13617  }
13618  break;
13619  case eELIST:
13620  if( n->Arg<CNode*>(0)->type == eR ) {
13621  info->error = 1;
13622  if( !suppressErrorMessages ) {
13623  error(n->GetCoord(), "Illegal expression operand" );
13624  }
13625  } else if( n->Arg<CNode*>(1)->type == eR ) {
13626  info->error = 1;
13627  if( !suppressErrorMessages ) {
13628  error(n->GetCoord(), "Illegal expression operand" );
13629  }
13630  } else if(1) {
13631  n->type = eB;
13632  }
13633  break;
13634  case eWIDTH:
13635  if( n->Arg<CNode*>(1)->type == eS ) {
13636  n->type = eS;
13637  } else if(1) {
13638  n->type = eB;
13639  }
13640  break;
13641  case eSUB:
13642  if( n->Arg<CNode*>(0)->type == eR ) {
13643  n->type = eR;
13644  } else if( n->Arg<CNode*>(1)->type == eR ) {
13645  n->type = eR;
13646  } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
13647  n->type = eS;
13648  } else if(1) {
13649  n->type = eB;
13650  }
13651  break;
13652  case eMUL:
13653  if( n->Arg<CNode*>(0)->type == eR ) {
13654  n->type = eR;
13655  } else if( n->Arg<CNode*>(1)->type == eR ) {
13656  n->type = eR;
13657  } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
13658  n->type = eS;
13659  } else if(1) {
13660  n->type = eB;
13661  }
13662  break;
13663  case eDIV:
13664  if( n->Arg<CNode*>(0)->type == eR ) {
13665  n->type = eR;
13666  } else if( n->Arg<CNode*>(1)->type == eR ) {
13667  n->type = eR;
13668  } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
13669  n->type = eS;
13670  } else if(1) {
13671  n->type = eB;
13672  }
13673  break;
13674  case ePOW:
13675  if( n->Arg<CNode*>(0)->type == eR ) {
13676  n->type = eR;
13677  } else if( n->Arg<CNode*>(1)->type == eR ) {
13678  n->type = eR;
13679  } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
13680  n->type = eS;
13681  } else if(1) {
13682  n->type = eB;
13683  }
13684  break;
13685  case eADD:
13686  if( n->Arg<CNode*>(0)->type == eR ) {
13687  n->type = eR;
13688  } else if( n->Arg<CNode*>(1)->type == eR ) {
13689  n->type = eR;
13690  } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
13691  n->type = eS;
13692  } else if(1) {
13693  n->type = eB;
13694  }
13695  break;
13696  case eLSH:
13697  if( n->Arg<CNode*>(0)->type == eS ) {
13698  n->type = eS;
13699  } else if(1) {
13700  n->type = eB;
13701  }
13702  break;
13703  case eRSH:
13704  if( n->Arg<CNode*>(0)->type == eS ) {
13705  n->type = eS;
13706  } else if(1) {
13707  n->type = eB;
13708  }
13709  break;
13710  case eLSHA:
13711  if( n->Arg<CNode*>(0)->type == eS ) {
13712  n->type = eS;
13713  } else if(1) {
13714  n->type = eB;
13715  }
13716  break;
13717  case eRSHA:
13718  if( n->Arg<CNode*>(0)->type == eS ) {
13719  n->type = eS;
13720  } else if(1) {
13721  n->type = eB;
13722  }
13723  break;
13724  case eMOD:
13725  if( n->Arg<CNode*>(0)->type == eR ) {
13726  info->error = 1;
13727  if( !suppressErrorMessages ) {
13728  error(n->GetCoord(), "Illegal expression operand" );
13729  }
13730  } else if( n->Arg<CNode*>(1)->type == eR ) {
13731  info->error = 1;
13732  if( !suppressErrorMessages ) {
13733  error(n->GetCoord(), "Illegal expression operand" );
13734  }
13735  } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
13736  n->type = eS;
13737  } else if(1) {
13738  n->type = eB;
13739  }
13740  break;
13741  case eOR:
13742  if( n->Arg<CNode*>(0)->type == eR ) {
13743  info->error = 1;
13744  if( !suppressErrorMessages ) {
13745  error(n->GetCoord(), "Illegal expression operand" );
13746  }
13747  } else if( n->Arg<CNode*>(1)->type == eR ) {
13748  info->error = 1;
13749  if( !suppressErrorMessages ) {
13750  error(n->GetCoord(), "Illegal expression operand" );
13751  }
13752  } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
13753  n->type = eS;
13754  } else if(1) {
13755  n->type = eB;
13756  }
13757  break;
13758  case eAND:
13759  if( n->Arg<CNode*>(0)->type == eR ) {
13760  info->error = 1;
13761  if( !suppressErrorMessages ) {
13762  error(n->GetCoord(), "Illegal expression operand" );
13763  }
13764  } else if( n->Arg<CNode*>(1)->type == eR ) {
13765  info->error = 1;
13766  if( !suppressErrorMessages ) {
13767  error(n->GetCoord(), "Illegal expression operand" );
13768  }
13769  } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
13770  n->type = eS;
13771  } else if(1) {
13772  n->type = eB;
13773  }
13774  break;
13775  case eANDANDAND:
13776  if( n->Arg<CNode*>(0)->type == eR ) {
13777  info->error = 1;
13778  if( !suppressErrorMessages ) {
13779  error(n->GetCoord(), "Illegal expression operand" );
13780  }
13781  } else if( n->Arg<CNode*>(1)->type == eR ) {
13782  info->error = 1;
13783  if( !suppressErrorMessages ) {
13784  error(n->GetCoord(), "Illegal expression operand" );
13785  }
13786  } else if(1) {
13787  n->type = eB;
13788  }
13789  break;
13790  case eXOR:
13791  if( n->Arg<CNode*>(0)->type == eR ) {
13792  info->error = 1;
13793  if( !suppressErrorMessages ) {
13794  error(n->GetCoord(), "Illegal expression operand" );
13795  }
13796  } else if( n->Arg<CNode*>(1)->type == eR ) {
13797  info->error = 1;
13798  if( !suppressErrorMessages ) {
13799  error(n->GetCoord(), "Illegal expression operand" );
13800  }
13801  } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
13802  n->type = eS;
13803  } else if(1) {
13804  n->type = eB;
13805  }
13806  break;
13807  case eXNOR:
13808  if( n->Arg<CNode*>(0)->type == eR ) {
13809  info->error = 1;
13810  if( !suppressErrorMessages ) {
13811  error(n->GetCoord(), "Illegal expression operand" );
13812  }
13813  } else if( n->Arg<CNode*>(1)->type == eR ) {
13814  info->error = 1;
13815  if( !suppressErrorMessages ) {
13816  error(n->GetCoord(), "Illegal expression operand" );
13817  }
13818  } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
13819  n->type = eS;
13820  } else if(1) {
13821  n->type = eB;
13822  }
13823  break;
13824  case eSYSTASK_CALL:
13825  n->type = Systask::Type(n->Arg<CSymbol*>(0),n->Arg<CNode*>(1));
13826  break;
13827  case eFUNCTION_CALL:
13828  n->type = CFunction::Type(n->Arg<CSymbol*>(0),n->Arg<CNode*>(1),n->Arg<CScope*>(2));
13829  break;
13830  case eARRAY:
13831  n->type = Array::Type(n->Arg<CNode*>(0),n->Arg<CNode*>(1));
13832  break;
13833  case eNET_REF:
13834  n->type = n->Arg<CNet*>(0)->GetNodeType();
13835  break;
13836  case eVAR_REF:
13837  n->type = n->Arg<CVar*>(0)->GetNodeType();
13838  break;
13839  case ePARAM_REF:
13840  n->type = n->Arg<CParam*>(0)->GetNodeType();
13841  break;
13842  case ePORT_REF:
13843  n->type = n->Arg<CPortDir*>(0)->GetNodeType();
13844  break;
13845  case eFWD_REF:
13846  if(1) {
13847  n->type = eB;
13848  }
13849  break;
13850  case eGENVAR_REF:
13851  n->type = n->Arg<CGenvar*>(0)->GetNodeType();
13852  break;
13853  case eENUM_REF:
13854  n->type = n->Arg<CEnum*>(0)->GetNodeType();
13855  break;
13856  case eTYPE_REF:
13857  if(1) {
13858  n->type = eS;
13859  }
13860  break;
13861  case eRANGE:
13862  if( n->Arg<CNode*>(0)->type == eR ) {
13863  info->error = 1;
13864  if( !suppressErrorMessages ) {
13865  error(n->GetCoord(), "Illegal expression operand" );
13866  }
13867  } else if( n->Arg<CNode*>(1)->type == eR ) {
13868  info->error = 1;
13869  if( !suppressErrorMessages ) {
13870  error(n->GetCoord(), "Illegal expression operand" );
13871  }
13872  } else if(1) {
13873  n->type = eB;
13874  }
13875  break;
13876  case eSLICE:
13877  if( n->Arg<CNode*>(0)->type == eR ) {
13878  info->error = 1;
13879  if( !suppressErrorMessages ) {
13880  error(n->GetCoord(), "Illegal expression operand" );
13881  }
13882  } else if( n->Arg<CNode*>(1)->type == eR ) {
13883  info->error = 1;
13884  if( !suppressErrorMessages ) {
13885  error(n->GetCoord(), "Illegal expression operand" );
13886  }
13887  } else if(1) {
13888  n->type = eB;
13889  }
13890  break;
13891  case ePSLICE:
13892  if( n->Arg<CNode*>(1)->type == eR ) {
13893  info->error = 1;
13894  if( !suppressErrorMessages ) {
13895  error(n->GetCoord(), "Illegal expression operand" );
13896  }
13897  } else if(1) {
13898  n->type = eB;
13899  }
13900  break;
13901  case eMSLICE:
13902  if( n->Arg<CNode*>(1)->type == eR ) {
13903  info->error = 1;
13904  if( !suppressErrorMessages ) {
13905  error(n->GetCoord(), "Illegal expression operand" );
13906  }
13907  } else if(1) {
13908  n->type = eB;
13909  }
13910  break;
13911  case eCVRI:
13912  if(1) {
13913  n->type = eS;
13914  }
13915  break;
13916  case eCVIR:
13917  if(1) {
13918  n->type = eR;
13919  }
13920  break;
13921  case eREP:
13922  if( n->Arg<CNode*>(0)->type == eR ) {
13923  info->error = 1;
13924  if( !suppressErrorMessages ) {
13925  error(n->GetCoord(), "Illegal expression operand" );
13926  }
13927  } else if( n->Arg<CNode*>(1)->type == eR ) {
13928  info->error = 1;
13929  if( !suppressErrorMessages ) {
13930  error(n->GetCoord(), "Illegal expression operand" );
13931  }
13932  } else if(1) {
13933  n->type = eB;
13934  }
13935  break;
13936  case eCAT:
13937  if( n->Arg<CNode*>(0)->type == eR ) {
13938  info->error = 1;
13939  if( !suppressErrorMessages ) {
13940  error(n->GetCoord(), "Illegal expression operand" );
13941  }
13942  } else if( n->Arg<CNode*>(1)->type == eR ) {
13943  info->error = 1;
13944  if( !suppressErrorMessages ) {
13945  error(n->GetCoord(), "Illegal expression operand" );
13946  }
13947  } else if(1) {
13948  n->type = eB;
13949  }
13950  break;
13951  case eUCAT:
13952  if( n->Arg<CNode*>(0)->type == eR ) {
13953  info->error = 1;
13954  if( !suppressErrorMessages ) {
13955  error(n->GetCoord(), "Illegal expression operand" );
13956  }
13957  } else if(1) {
13958  n->type = eB;
13959  }
13960  break;
13961  case eCOM:
13962  if( n->Arg<CNode*>(0)->type == eR ) {
13963  info->error = 1;
13964  if( !suppressErrorMessages ) {
13965  error(n->GetCoord(), "Illegal expression operand" );
13966  }
13967  } else if( n->Arg<CNode*>(0)->type == eS ) {
13968  n->type = eS;
13969  } else if(1) {
13970  n->type = eB;
13971  }
13972  break;
13973  case eNEG:
13974  n->type = n->Arg<CNode*>(0)->type;
13975  break;
13976  case ePLUS:
13977  n->type = n->Arg<CNode*>(0)->type;
13978  break;
13979  case eNOT:
13980  if(1) {
13981  n->type = eB;
13982  }
13983  break;
13984  case eGT:
13985  if(1) {
13986  n->type = eB;
13987  }
13988  break;
13989  case eGE:
13990  if(1) {
13991  n->type = eB;
13992  }
13993  break;
13994  case eLT:
13995  if(1) {
13996  n->type = eB;
13997  }
13998  break;
13999  case eLE:
14000  if(1) {
14001  n->type = eB;
14002  }
14003  break;
14004  case eLAND:
14005  if(1) {
14006  n->type = eB;
14007  }
14008  break;
14009  case eLOR:
14010  if(1) {
14011  n->type = eB;
14012  }
14013  break;
14014  case eCEQ:
14015  if( n->Arg<CNode*>(0)->type == eR ) {
14016  info->error = 1;
14017  if( !suppressErrorMessages ) {
14018  error(n->GetCoord(), "Illegal expression operand" );
14019  }
14020  } else if( n->Arg<CNode*>(1)->type == eR ) {
14021  info->error = 1;
14022  if( !suppressErrorMessages ) {
14023  error(n->GetCoord(), "Illegal expression operand" );
14024  }
14025  } else if(1) {
14026  n->type = eB;
14027  }
14028  break;
14029  case eCNE:
14030  if( n->Arg<CNode*>(0)->type == eR ) {
14031  info->error = 1;
14032  if( !suppressErrorMessages ) {
14033  error(n->GetCoord(), "Illegal expression operand" );
14034  }
14035  } else if( n->Arg<CNode*>(1)->type == eR ) {
14036  info->error = 1;
14037  if( !suppressErrorMessages ) {
14038  error(n->GetCoord(), "Illegal expression operand" );
14039  }
14040  } else if(1) {
14041  n->type = eB;
14042  }
14043  break;
14044  case eEQ:
14045  if(1) {
14046  n->type = eB;
14047  }
14048  break;
14049  case eNE:
14050  if(1) {
14051  n->type = eB;
14052  }
14053  break;
14054  case eRAND:
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(1) {
14061  n->type = eB;
14062  }
14063  break;
14064  case eRNAND:
14065  if( n->Arg<CNode*>(0)->type == eR ) {
14066  info->error = 1;
14067  if( !suppressErrorMessages ) {
14068  error(n->GetCoord(), "Illegal expression operand" );
14069  }
14070  } else if(1) {
14071  n->type = eB;
14072  }
14073  break;
14074  case eROR:
14075  if( n->Arg<CNode*>(0)->type == eR ) {
14076  info->error = 1;
14077  if( !suppressErrorMessages ) {
14078  error(n->GetCoord(), "Illegal expression operand" );
14079  }
14080  } else if(1) {
14081  n->type = eB;
14082  }
14083  break;
14084  case eRNOR:
14085  if( n->Arg<CNode*>(0)->type == eR ) {
14086  info->error = 1;
14087  if( !suppressErrorMessages ) {
14088  error(n->GetCoord(), "Illegal expression operand" );
14089  }
14090  } else if(1) {
14091  n->type = eB;
14092  }
14093  break;
14094  case eRXOR:
14095  if( n->Arg<CNode*>(0)->type == eR ) {
14096  info->error = 1;
14097  if( !suppressErrorMessages ) {
14098  error(n->GetCoord(), "Illegal expression operand" );
14099  }
14100  } else if(1) {
14101  n->type = eB;
14102  }
14103  break;
14104  case eRXNOR:
14105  if( n->Arg<CNode*>(0)->type == eR ) {
14106  info->error = 1;
14107  if( !suppressErrorMessages ) {
14108  error(n->GetCoord(), "Illegal expression operand" );
14109  }
14110  } else if(1) {
14111  n->type = eB;
14112  }
14113  break;
14114  case eHOOK:
14115  if( n->Arg<CNode*>(1)->type == eR ) {
14116  n->type = eR;
14117  } else if( n->Arg<CNode*>(2)->type == eR ) {
14118  n->type = eR;
14119  } else if( n->Arg<CNode*>(1)->type == eS && n->Arg<CNode*>(2)->type == eS ) {
14120  n->type = eS;
14121  } else if(1) {
14122  n->type = eB;
14123  }
14124  break;
14125  case ePOSEDGE:
14126  if(1) {
14127  n->type = eE;
14128  }
14129  break;
14130  case eNEGEDGE:
14131  if(1) {
14132  n->type = eE;
14133  }
14134  break;
14135  case eEVOR:
14136  if(1) {
14137  n->type = eE;
14138  }
14139  break;
14140  case eMTM:
14141  if( n->Arg<CNode*>(0)->type == eR ) {
14142  n->type = eR;
14143  } else if( n->Arg<CNode*>(1)->type == eR ) {
14144  n->type = eR;
14145  } else if( n->Arg<CNode*>(2)->type == eR ) {
14146  n->type = eR;
14147  } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS && n->Arg<CNode*>(2)->type == eS ) {
14148  n->type = eS;
14149  } else if(1) {
14150  n->type = eB;
14151  }
14152  break;
14153  case eEXTERNAL_REF:
14154  n->type = External::Type(n->Arg<CSymbol*>(0));
14155  break;
14156  case eATTRIBUTE:
14157  if(1) {
14158  n->type = eU;
14159  }
14160  break;
14161  case eMACRO_EXPR:
14162  n->type = n->Arg<CNode*>(1)->type;
14163  break;
14164  case eMEMBER:
14165  n->type = Member::Type(n->Arg<CNode*>(0),n->Arg<CSymbol*>(1));
14166  break;
14167  case ePREINC:
14168  if( n->Arg<CNode*>(0)->type == eR ) {
14169  n->type = eR;
14170  } else if( n->Arg<CNode*>(0)->type == eS ) {
14171  n->type = eS;
14172  } else if(1) {
14173  n->type = eB;
14174  }
14175  break;
14176  case ePOSTINC:
14177  if( n->Arg<CNode*>(0)->type == eR ) {
14178  n->type = eR;
14179  } else if( n->Arg<CNode*>(0)->type == eS ) {
14180  n->type = eS;
14181  } else if(1) {
14182  n->type = eB;
14183  }
14184  break;
14185  case ePREDEC:
14186  if( n->Arg<CNode*>(0)->type == eR ) {
14187  n->type = eR;
14188  } else if( n->Arg<CNode*>(0)->type == eS ) {
14189  n->type = eS;
14190  } else if(1) {
14191  n->type = eB;
14192  }
14193  break;
14194  case ePOSTDEC:
14195  if( n->Arg<CNode*>(0)->type == eR ) {
14196  n->type = eR;
14197  } else if( n->Arg<CNode*>(0)->type == eS ) {
14198  n->type = eS;
14199  } else if(1) {
14200  n->type = eB;
14201  }
14202  break;
14203  case eCAST:
14204  if(1) {
14205  n->type = eB;
14206  }
14207  break;
14208  default:
14209  MASSERT( FALSE );
14210  }
14211 
14212  /*
14213  * enforce width conventions for fixed width types
14214  */
14215  switch( n->type ) {
14216  case eU:
14217  case eE:
14218  case eR:
14219  n->width = 0;
14220  return;
14221  }
14222 
14223  /*
14224  * set node width
14225  */
14226  switch( n->GetOp() ) {
14227  case eERROR:
14228  n->width = 0;
14229  break;
14230  case eVCONSTANT:
14231  n->width = (!n->Arg<CVector*>(0)->IsWidthEvaluateable()&&suppressErrorMessages) ? 0 : n->Arg<CVector*>(0)->GetWidth();
14232  break;
14233  case eRCONSTANT:
14234  n->width = 0;
14235  break;
14236  case eELIST:
14237  n->width = cADD(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
14238  break;
14239  case eWIDTH:
14240  n->width = ((info->error |= !n->Arg<CNode*>(0)->IsEvaluateable())&&suppressErrorMessages) ? 0 : n->Arg<CNode*>(0)->EvalINT32();
14241  break;
14242  case eSUB:
14243  n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
14244  break;
14245  case eMUL:
14246  n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
14247  break;
14248  case eDIV:
14249  n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
14250  break;
14251  case ePOW:
14252  n->width = n->Arg<CNode*>(0)->width;
14253  break;
14254  case eADD:
14255  n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
14256  break;
14257  case eLSH:
14258  n->width = n->Arg<CNode*>(0)->width;
14259  break;
14260  case eRSH:
14261  n->width = n->Arg<CNode*>(0)->width;
14262  break;
14263  case eLSHA:
14264  n->width = n->Arg<CNode*>(0)->width;
14265  break;
14266  case eRSHA:
14267  n->width = n->Arg<CNode*>(0)->width;
14268  break;
14269  case eMOD:
14270  n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
14271  break;
14272  case eOR:
14273  n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
14274  break;
14275  case eAND:
14276  n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
14277  break;
14278  case eANDANDAND:
14279  n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
14280  break;
14281  case eXOR:
14282  n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
14283  break;
14284  case eXNOR:
14285  n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
14286  break;
14287  case eSYSTASK_CALL:
14288  n->width = Systask::Width(n->Arg<CSymbol*>(0),n->Arg<CNode*>(1));
14289  break;
14290  case eFUNCTION_CALL:
14291  n->width = CFunction::Width(n->Arg<CSymbol*>(0),n->Arg<CNode*>(1),n->Arg<CScope*>(2));
14292  break;
14293  case eARRAY:
14294  n->width = Array::Width(n->Arg<CNode*>(0),n->Arg<CNode*>(1));
14295  break;
14296  case eNET_REF:
14297  n->width = (!n->Arg<CNet*>(0)->IsWidthEvaluateable()&&suppressErrorMessages) ? 0 : n->Arg<CNet*>(0)->GetWidth();
14298  break;
14299  case eVAR_REF:
14300  n->width = (!n->Arg<CVar*>(0)->IsWidthEvaluateable()&&suppressErrorMessages) ? 0 : n->Arg<CVar*>(0)->GetWidth();
14301  break;
14302  case ePARAM_REF:
14303  n->width = (!n->Arg<CParam*>(0)->IsWidthEvaluateable()&&suppressErrorMessages) ? 0 : n->Arg<CParam*>(0)->GetWidth();
14304  break;
14305  case ePORT_REF:
14306  n->width = (!n->Arg<CPortDir*>(0)->IsWidthEvaluateable()&&suppressErrorMessages) ? 0 : n->Arg<CPortDir*>(0)->GetWidth();
14307  break;
14308  case eFWD_REF:
14309  n->width = (!n->Arg<CFref*>(0)->IsWidthEvaluateable()&&suppressErrorMessages) ? 0 : n->Arg<CFref*>(0)->GetWidth();
14310  break;
14311  case eGENVAR_REF:
14312  n->width = (!n->Arg<CGenvar*>(0)->IsWidthEvaluateable()&&suppressErrorMessages) ? 0 : n->Arg<CGenvar*>(0)->GetWidth();
14313  break;
14314  case eENUM_REF:
14315  n->width = (!n->Arg<CEnum*>(0)->IsWidthEvaluateable()&&suppressErrorMessages) ? 0 : n->Arg<CEnum*>(0)->GetWidth();
14316  break;
14317  case eTYPE_REF:
14318  n->width = 32;
14319  break;
14320  case eRANGE:
14321  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());
14322  break;
14323  case eSLICE:
14324  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());
14325  break;
14326  case ePSLICE:
14327  n->width = (!n->Arg<CNode*>(1)->IsEvaluateable()&&suppressErrorMessages) ? 0 : n->Arg<CNode*>(1)->EvalINT32();
14328  break;
14329  case eMSLICE:
14330  n->width = (!n->Arg<CNode*>(1)->IsEvaluateable()&&suppressErrorMessages) ? 0 : n->Arg<CNode*>(1)->EvalINT32();
14331  break;
14332  case eCVRI:
14333  n->width = 32;
14334  break;
14335  case eCVIR:
14336  n->width = 0;
14337  break;
14338  case eREP:
14339  n->width = cMUL(((info->error |= !n->Arg<CNode*>(0)->IsEvaluateable())&&suppressErrorMessages) ? 0: n->Arg<CNode*>(0)->EvalINT32(),n->Arg<CNode*>(1)->width);
14340  break;
14341  case eCAT:
14342  n->width = cADD(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
14343  break;
14344  case eUCAT:
14345  n->width = n->Arg<CNode*>(0)->width;
14346  break;
14347  case eCOM:
14348  n->width = n->Arg<CNode*>(0)->width;
14349  break;
14350  case eNEG:
14351  n->width = n->Arg<CNode*>(0)->width;
14352  break;
14353  case ePLUS:
14354  n->width = n->Arg<CNode*>(0)->width;
14355  break;
14356  case eNOT:
14357  n->width = 1;
14358  break;
14359  case eGT:
14360  n->width = 1;
14361  break;
14362  case eGE:
14363  n->width = 1;
14364  break;
14365  case eLT:
14366  n->width = 1;
14367  break;
14368  case eLE:
14369  n->width = 1;
14370  break;
14371  case eLAND:
14372  n->width = 1;
14373  break;
14374  case eLOR:
14375  n->width = 1;
14376  break;
14377  case eCEQ:
14378  n->width = 1;
14379  break;
14380  case eCNE:
14381  n->width = 1;
14382  break;
14383  case eEQ:
14384  n->width = 1;
14385  break;
14386  case eNE:
14387  n->width = 1;
14388  break;
14389  case eRAND:
14390  n->width = 1;
14391  break;
14392  case eRNAND:
14393  n->width = 1;
14394  break;
14395  case eROR:
14396  n->width = 1;
14397  break;
14398  case eRNOR:
14399  n->width = 1;
14400  break;
14401  case eRXOR:
14402  n->width = 1;
14403  break;
14404  case eRXNOR:
14405  n->width = 1;
14406  break;
14407  case eHOOK:
14408  n->width = cMAX(n->Arg<CNode*>(1)->width,n->Arg<CNode*>(2)->width);
14409  break;
14410  case eMTM:
14411  n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width,n->Arg<CNode*>(2)->width);
14412  break;
14413  case eEXTERNAL_REF:
14414  n->width = External::Width(n->Arg<CSymbol*>(0));
14415  break;
14416  case eATTRIBUTE:
14417  n->width = 0;
14418  break;
14419  case eMACRO_EXPR:
14420  n->width = n->Arg<CNode*>(1)->width;
14421  break;
14422  case eMEMBER:
14423  n->width = Member::Width(n->Arg<CNode*>(0),n->Arg<CSymbol*>(1));
14424  break;
14425  case ePREINC:
14426  n->width = n->Arg<CNode*>(0)->width;
14427  break;
14428  case ePOSTINC:
14429  n->width = n->Arg<CNode*>(0)->width;
14430  break;
14431  case ePREDEC:
14432  n->width = n->Arg<CNode*>(0)->width;
14433  break;
14434  case ePOSTDEC:
14435  n->width = n->Arg<CNode*>(0)->width;
14436  break;
14437  case eCAST:
14438  n->width = ((info->error |= !n->Arg<CNode*>(0)->IsEvaluateable())&&suppressErrorMessages) ? 0 : n->Arg<CNode*>(0)->EvalINT32();
14439  break;
14440  }
14441 
14442  /*
14443  * deterimine if operands have differing width
14444  */
14445  n->FixedWidth(1);
14446  int operandWidth = -1;
14447  for( int i = 0; i < n->ArgCount(); i++ ) {
14448  if( ((nodeMask>>i)&1) && n->Arg<CNode*>(i) ) {
14449  int widthFixed = n->Arg<CNode*>(i)->WidthFixed() ||
14450  n->Arg<CNode*>(i)->FixedWidth();
14451 
14452  if( n->ConditionalWiden() && !widthFixed ) {
14453  n->FixedWidth( 0 );
14454  break;
14455  } else if( !widthFixed ) {
14456  n->FixedWidth( 0 );
14457  break;
14458  } else {
14459  int w = n->Arg<CNode*>(i)->width;
14460  if( operandWidth != w ) {
14461  if( operandWidth >= 0 ) {
14462  n->FixedWidth( 0 );
14463  break;
14464  }
14465  operandWidth = w;
14466  }
14467  }
14468  }
14469  }
14470  if( !conditionalWiden && nodeMask != 0 ) {
14471  n->FixedWidth( 0 );
14472  }
14473 }
14474 
14475 /************************************************
14476  FixBits
14477  - relabels node width based on destination
14478  width and type. Add type conversions
14479  and check argument types. Assumes
14480  LabelBits has already been called and
14481  no illegal operand types are present.
14482 **************************************************/
14483 
14484 CNode* CNode::FixBits( INT32 newWidth, NodeType_t newType )
14485 {
14486 
14487  int calculateMax = 0;
14488  int realOp = 0;
14489  int conditionalWiden = ConditionalWiden();
14490  unsigned nodeMask = NodeMask();
14491  unsigned scalarMask = 0;
14492  unsigned selfDeterminedMask = 0;
14493  switch( GetOp() ) {
14494  case eERROR:
14495  realOp = 0;
14496  break;
14497  case eVCONSTANT:
14498  realOp = 0;
14499  break;
14500  case eRCONSTANT:
14501  realOp = 0;
14502  break;
14503  case eCOMMENT:
14504  realOp = 0;
14505  break;
14506  case eVRQ:
14507  realOp = 0;
14508  break;
14509  case ePRAGMA:
14510  realOp = 0;
14511  break;
14512  case eELIST:
14513  realOp = 0;
14514  selfDeterminedMask = nodeMask;
14515  break;
14516  case eWIDTH:
14517  realOp = 0;
14518  selfDeterminedMask = nodeMask;
14519  break;
14520  case eNOP:
14521  realOp = 0;
14522  break;
14523  case eSUB:
14524  realOp = 1;
14525  break;
14526  case eMUL:
14527  realOp = 1;
14528  break;
14529  case eDIV:
14530  realOp = 1;
14531  break;
14532  case ePOW:
14533  realOp = 1;
14534  selfDeterminedMask = 1<<1;
14535  break;
14536  case eADD:
14537  realOp = 1;
14538  break;
14539  case eLSH:
14540  realOp = 0;
14541  selfDeterminedMask = 1<<1;
14542  break;
14543  case eRSH:
14544  realOp = 0;
14545  selfDeterminedMask = 1<<1;
14546  break;
14547  case eLSHA:
14548  realOp = 0;
14549  selfDeterminedMask = 1<<1;
14550  break;
14551  case eRSHA:
14552  realOp = 0;
14553  selfDeterminedMask = 1<<1;
14554  break;
14555  case eMOD:
14556  realOp = 0;
14557  break;
14558  case eOR:
14559  realOp = 0;
14560  break;
14561  case eAND:
14562  realOp = 0;
14563  break;
14564  case eANDANDAND:
14565  realOp = 0;
14566  break;
14567  case eXOR:
14568  realOp = 0;
14569  break;
14570  case eXNOR:
14571  realOp = 0;
14572  break;
14573  case eINSTANCE_REF:
14574  realOp = 0;
14575  break;
14576  case eGATE_REF:
14577  realOp = 0;
14578  break;
14579  case eTASK_ENABLE:
14580  realOp = 0;
14581  break;
14582  case eSYSTASK_CALL:
14583  realOp = 0;
14584  selfDeterminedMask = nodeMask;
14585  break;
14586  case eTIMING_CALL:
14587  realOp = 0;
14588  break;
14589  case eFUNCTION_CALL:
14590  realOp = 0;
14591  selfDeterminedMask = nodeMask;
14592  break;
14593  case eARRAY:
14594  realOp = 0;
14595  selfDeterminedMask = 1<<1;
14596  break;
14597  case eNET_REF:
14598  realOp = 0;
14599  break;
14600  case eVAR_REF:
14601  realOp = 0;
14602  break;
14603  case ePARAM_REF:
14604  realOp = 0;
14605  break;
14606  case ePORT_REF:
14607  realOp = 0;
14608  break;
14609  case eFWD_REF:
14610  realOp = 0;
14611  break;
14612  case eGENVAR_REF:
14613  realOp = 0;
14614  break;
14615  case eENUM_REF:
14616  realOp = 0;
14617  break;
14618  case eTYPE_REF:
14619  realOp = 0;
14620  break;
14621  case eNET_DECL:
14622  realOp = 0;
14623  break;
14624  case eVAR_DECL:
14625  realOp = 0;
14626  break;
14627  case ePARAM_DECL:
14628  realOp = 0;
14629  break;
14630  case eSPECPARAM_DECL:
14631  realOp = 0;
14632  break;
14633  case ePORT_DECL:
14634  realOp = 0;
14635  break;
14636  case eGENVAR_DECL:
14637  realOp = 0;
14638  break;
14639  case eTYPEDEF_DECL:
14640  realOp = 0;
14641  break;
14642  case eLIST:
14643  realOp = 0;
14644  break;
14645  case eRANGE:
14646  realOp = 0;
14647  selfDeterminedMask = nodeMask;
14648  break;
14649  case eSLICE:
14650  realOp = 0;
14651  selfDeterminedMask = nodeMask;
14652  break;
14653  case ePSLICE:
14654  realOp = 0;
14655  selfDeterminedMask = nodeMask;
14656  break;
14657  case eMSLICE:
14658  realOp = 0;
14659  selfDeterminedMask = nodeMask;
14660  break;
14661  case eCVRI:
14662  realOp = 0;
14663  selfDeterminedMask = nodeMask;
14664  break;
14665  case eCVIR:
14666  realOp = 0;
14667  selfDeterminedMask = nodeMask;
14668  break;
14669  case eREP:
14670  realOp = 0;
14671  selfDeterminedMask = nodeMask;
14672  break;
14673  case eCAT:
14674  realOp = 0;
14675  selfDeterminedMask = nodeMask;
14676  break;
14677  case eUCAT:
14678  realOp = 0;
14679  selfDeterminedMask = nodeMask;
14680  break;
14681  case eCOM:
14682  realOp = 0;
14683  break;
14684  case eNEG:
14685  realOp = 0;
14686  break;
14687  case ePLUS:
14688  realOp = 0;
14689  break;
14690  case eNOT:
14691  realOp = 0;
14692  scalarMask = 1;
14693  break;
14694  case eGT:
14695  realOp = 0;
14696  calculateMax = 1;
14697  break;
14698  case eGE:
14699  realOp = 0;
14700  calculateMax = 1;
14701  break;
14702  case eLT:
14703  realOp = 0;
14704  calculateMax = 1;
14705  break;
14706  case eLE:
14707  realOp = 0;
14708  calculateMax = 1;
14709  break;
14710  case eLAND:
14711  realOp = 0;
14712  scalarMask = 3;
14713  break;
14714  case eLOR:
14715  realOp = 0;
14716  scalarMask = 3;
14717  break;
14718  case eCEQ:
14719  realOp = 0;
14720  calculateMax = 1;
14721  break;
14722  case eCNE:
14723  realOp = 0;
14724  calculateMax = 1;
14725  break;
14726  case eEQ:
14727  realOp = 0;
14728  calculateMax = 1;
14729  break;
14730  case eNE:
14731  realOp = 0;
14732  calculateMax = 1;
14733  break;
14734  case eRAND:
14735  realOp = 0;
14736  selfDeterminedMask = nodeMask;
14737  break;
14738  case eRNAND:
14739  realOp = 0;
14740  selfDeterminedMask = nodeMask;
14741  break;
14742  case eROR:
14743  realOp = 0;
14744  selfDeterminedMask = nodeMask;
14745  break;
14746  case eRNOR:
14747  realOp = 0;
14748  selfDeterminedMask = nodeMask;
14749  break;
14750  case eRXOR:
14751  realOp = 0;
14752  selfDeterminedMask = nodeMask;
14753  break;
14754  case eRXNOR:
14755  realOp = 0;
14756  selfDeterminedMask = nodeMask;
14757  break;
14758  case eHOOK:
14759  realOp = 1;
14760  scalarMask = 1;
14761  break;
14762  case eINIT:
14763  realOp = 0;
14764  break;
14765  case eALWAYS:
14766  realOp = 0;
14767  break;
14768  case eALWAYS_LATCH:
14769  realOp = 0;
14770  break;
14771  case eALWAYS_FF:
14772  realOp = 0;
14773  break;
14774  case eALWAYS_COMB:
14775  realOp = 0;
14776  break;
14777  case eEVENT:
14778  realOp = 0;
14779  break;
14780  case eBLOCK_REF:
14781  realOp = 0;
14782  break;
14783  case eSPECIFY_REF:
14784  realOp = 0;
14785  break;
14786  case eASSIGN:
14787  realOp = 0;
14788  break;
14789  case eADD_ASSIGN:
14790  realOp = 0;
14791  break;
14792  case eSUB_ASSIGN:
14793  realOp = 0;
14794  break;
14795  case eMUL_ASSIGN:
14796  realOp = 0;
14797  break;
14798  case eDIV_ASSIGN:
14799  realOp = 0;
14800  break;
14801  case eMOD_ASSIGN:
14802  realOp = 0;
14803  break;
14804  case eAND_ASSIGN:
14805  realOp = 0;
14806  break;
14807  case eOR_ASSIGN:
14808  realOp = 0;
14809  break;
14810  case eXOR_ASSIGN:
14811  realOp = 0;
14812  break;
14813  case eLSH_ASSIGN:
14814  realOp = 0;
14815  break;
14816  case eRSH_ASSIGN:
14817  realOp = 0;
14818  break;
14819  case eLSHA_ASSIGN:
14820  realOp = 0;
14821  break;
14822  case eRSHA_ASSIGN:
14823  realOp = 0;
14824  break;
14825  case eFORCE:
14826  realOp = 0;
14827  break;
14828  case eRELEASE:
14829  realOp = 0;
14830  break;
14831  case eNBASSIGN:
14832  realOp = 0;
14833  break;
14834  case ePOSEDGE:
14835  realOp = 0;
14836  break;
14837  case eNEGEDGE:
14838  realOp = 0;
14839  break;
14840  case eEDGE:
14841  realOp = 0;
14842  break;
14843  case eEVOR:
14844  realOp = 0;
14845  break;
14846  case eDELAY:
14847  realOp = 0;
14848  break;
14849  case eMTM:
14850  realOp = 1;
14851  break;
14852  case eIF:
14853  realOp = 0;
14854  break;
14855  case eFOREVER:
14856  realOp = 0;
14857  break;
14858  case eREPEAT:
14859  realOp = 0;
14860  break;
14861  case eWHILE:
14862  realOp = 0;
14863  break;
14864  case eWAIT:
14865  realOp = 0;
14866  break;
14867  case eFOR:
14868  realOp = 0;
14869  break;
14870  case eCASE:
14871  realOp = 0;
14872  break;
14873  case eCASEX:
14874  realOp = 0;
14875  break;
14876  case eCASEZ:
14877  realOp = 0;
14878  break;
14879  case eCASEITEM:
14880  realOp = 0;
14881  break;
14882  case eCASSIGN:
14883  realOp = 0;
14884  break;
14885  case eARG:
14886  realOp = 0;
14887  break;
14888  case eIMPORT:
14889  realOp = 0;
14890  break;
14891  case eFUNCTION_DEF:
14892  realOp = 0;
14893  break;
14894  case eMODULE_DEF:
14895  realOp = 0;
14896  break;
14897  case ePACKAGE_DEF:
14898  realOp = 0;
14899  break;
14900  case eREPEAT_CONTROL:
14901  realOp = 0;
14902  break;
14903  case eDELAY_CONTROL:
14904  realOp = 0;
14905  break;
14906  case eEVENT_CONTROL:
14907  realOp = 0;
14908  break;
14909  case eEXTERNAL_REF:
14910  realOp = 0;
14911  break;
14912  case ePORT_DEF:
14913  realOp = 0;
14914  break;
14915  case eDEFPARAM:
14916  realOp = 0;
14917  break;
14918  case ePATH:
14919  realOp = 0;
14920  break;
14921  case ePATH_ASSIGN:
14922  realOp = 0;
14923  break;
14924  case eIFNONE_PATH_ASSIGN:
14925  realOp = 0;
14926  break;
14927  case eTRIGGER:
14928  realOp = 0;
14929  break;
14930  case ePASSIGN:
14931  realOp = 0;
14932  break;
14933  case eDEASSIGN:
14934  realOp = 0;
14935  break;
14936  case eDISABLE:
14937  realOp = 0;
14938  break;
14939  case eATTRIBUTE:
14940  realOp = 0;
14941  break;
14942  case eGIF:
14943  realOp = 0;
14944  break;
14945  case eGFOR:
14946  realOp = 0;
14947  break;
14948  case eGCASE:
14949  realOp = 0;
14950  break;
14951  case eTABLE:
14952  realOp = 0;
14953  break;
14954  case eTABLE_ENTRY:
14955  realOp = 0;
14956  break;
14957  case eTABLE_SYMBOL:
14958  realOp = 0;
14959  break;
14960  case ePORTLIST_END:
14961  realOp = 0;
14962  break;
14963  case eMACRO_EXPR:
14964  realOp = 0;
14965  break;
14966  case eENUM_SPEC:
14967  realOp = 0;
14968  break;
14969  case eMEMBER:
14970  realOp = 0;
14971  break;
14972  case eRETURN:
14973  realOp = 0;
14974  break;
14975  case ePREINC:
14976  realOp = 1;
14977  break;
14978  case ePOSTINC:
14979  realOp = 1;
14980  break;
14981  case ePREDEC:
14982  realOp = 1;
14983  break;
14984  case ePOSTDEC:
14985  realOp = 1;
14986  break;
14987  case eCAST:
14988  realOp = 0;
14989  selfDeterminedMask = nodeMask;
14990  break;
14991  default:
14992  MASSERT( FALSE );
14993  }
14994  /*
14995  * find location of all real args
14996  */
14997  unsigned realMask = 0;
14998  unsigned forceRealMask = 0;
14999  int widthsDiffer = 0;
15000  int originalWidth = width;
15001  for( int i = 0; i < ArgCount(); i++ ) {
15002  if( ((nodeMask>>i)&1) && Arg<CNode*>(i)->type == eR ) {
15003  realMask |= 1<<i;
15004  }
15005  if( ((nodeMask>>i)&1) &&
15006  Arg<CNode*>(i)->type != eR &&
15007  (Arg<CNode*>(i)->GetOp() != eVCONSTANT ||
15008  Arg<CNode*>(i)->width != width) ) {
15009  widthsDiffer = 1;
15010  }
15011  }
15012 
15013  /*
15014  * if new type is undetermined, use current type and width
15015  */
15016  if( newType == eU && newWidth == 0 ) {
15017  newType = type;
15018  newWidth = width;
15019  /*
15020  * increase expression width if new width is larger
15021  * and a vector
15022  */
15023  } else if( (newType == eB || newType == eS || newType == eU) &&
15024  (type == eB || type == eS) ) {
15025  if( newWidth > width ) {
15026  width = newWidth;
15027  }
15028  if( newType == eU ) {
15029  newType = type;
15030  }
15031  }
15032 
15033  MASSERT( newType != eR || newWidth == 0 );
15034  MASSERT( newType != eE || newWidth == 0 );
15035 
15036 
15037  /*
15038  * non-real operands are self determined when mixed with real
15039  */
15040  if( realMask ) {
15041  forceRealMask = (~realMask & nodeMask);
15042  }
15043 
15044  /*
15045  * special case for bit operations
15046  * Only widen if operand widths differ
15047  */
15048  int convertWidth = conditionalWiden && FixedWidth();
15049  if( convertWidth ) {
15050  width = originalWidth;
15051  }
15052  if( newType == eB && type == eS ) {
15053  type = eB;
15054  }
15055  /*
15056  * calculate max with of args if needed
15057  */
15058  int cWidth = width;
15059  NodeType_t cType = type;
15060  if( calculateMax ) {
15061  cType = eS;
15062  int max = 0;
15063  int foundReal = 0;
15064  int foundUnsigned = 0;
15065  for( int i = 0; i < ArgCount(); i++ ) {
15066  if( (nodeMask>>i)&1 ) {
15067  switch( Arg<CNode*>(i)->type ) {
15068  case eB:
15069  foundUnsigned = 1;
15070  break;
15071  case eR:
15072  foundReal = 1;
15073  break;
15074  }
15075  if( Arg<CNode*>(i)->width > max ) {
15076  max = Arg<CNode*>(i)->width;
15077  }
15078  }
15079  }
15080  if( foundReal ) {
15081  cWidth = 0;
15082  cType = eR;
15083  } else if( foundUnsigned ) {
15084  cType = eB;
15085  cWidth = max;
15086  } else {
15087  cWidth = max;
15088  }
15089  }
15090 
15091  /*
15092  * Fix each CNode* argument
15093  */
15094  for( int i = 0; i < ArgCount(); i++ ) {
15095  if( (nodeMask>>i)&1 ) {
15096  if( (scalarMask>>i)&1 ) {
15097  if( Arg<CNode*>(i)->type == eR ) {
15098  CNode* node;
15099  Arg<CNode*>(i) = cNE( Arg<CNode*>(i), cREAL(0), &loc );
15100  Arg<CNode*>(i)->LabelBits();
15101  } else if( type == eR ) {
15102  // Hack for ? operator
15103  CNode* node;
15104  Arg<CNode*>(i) = cCNE( Arg<CNode*>(i), cINT32(0), &loc );
15105  Arg<CNode*>(i)->LabelBits();
15106  }
15107  Arg<CNode*>(i) = Arg<CNode*>(i)->FixBits( 0, eU );
15108  } else if( (forceRealMask>>i)&1 ) {
15109  Arg<CNode*>(i) = Arg<CNode*>(i)->FixBits( 0, eR );
15110  } else if( (selfDeterminedMask>>i)&1 ) {
15111  Arg<CNode*>(i) = Arg<CNode*>(i)->FixBits( 0, eU );
15112  } else {
15113  Arg<CNode*>(i) = Arg<CNode*>(i)->FixBits( cWidth, cType );
15114  }
15115  }
15116  }
15117 
15118 
15119 
15120  /*
15121  * add conversions if needed
15122  */
15123  if( newType != eR && convertWidth ) {
15124  CNode* nn = cWIDTH(cINT32(newWidth), this);
15125  nn->width = newWidth;
15126  nn->type = type;
15127  return nn;
15128  }
15129  if( newType == eR && (type == eB || type == eS) ) {
15130  CNode* nn = cCVIR( this );
15131  nn->width = 0;
15132  nn->type = eR;
15133  return nn;
15134 
15135  } else if( (newType == eB || newType == eS) && type == eR ) {
15136  CNode* nn = cCVRI( this );
15137  nn->width = newWidth;
15138  nn->type = newType;
15139  return nn;
15140  }
15141 
15142  return this;
15143 }
15144 
15145 /*************************************************
15146  Dump
15147  - dump expression for debug
15148 **************************************************/
15149 void CNode::Dump( FILE* f )
15150 {
15151  switch( GetOp() ) {
15152  case eERROR:
15153  fprintf( f, "%s", "???" );
15154  break;
15155  case eVCONSTANT:
15156  fprintf( f, "%s", Arg<CVector*>(0)->GetVString() );
15157  break;
15158  case eRCONSTANT:
15159  fprintf( f, "%s", (char*)Arg<char*>(0) );
15160  break;
15161  case ePRAGMA:
15162  fprintf( f, "%s", (char*)Arg<char*>(0) );
15163  break;
15164  case eELIST:
15165  fprintf( f, "%s", "" );
15166  Arg<CNode*>(0)->Dump( f );
15167  fprintf( f, "%s", "," );
15168  Arg<CNode*>(1)->Dump( f );
15169  fprintf( f, "%s", "" );
15170  break;
15171  case eWIDTH:
15172  fprintf( f, "%s", "WIDTH(" );
15173  fprintf( f, "%s", type==eS ? "S" : "U" );
15174  fprintf( f, "%s", "," );
15175  fprintf( f, "%ld", width );
15176  fprintf( f, "%s", "," );
15177  Arg<CNode*>(0)->Dump( f );
15178  fprintf( f, "%s", "," );
15179  Arg<CNode*>(1)->Dump( f );
15180  fprintf( f, "%s", ")" );
15181  break;
15182  case eSUB:
15183  fprintf( f, "%s", "(" );
15184  Arg<CNode*>(0)->Dump( f );
15185  fprintf( f, "%s", ")-(" );
15186  Arg<CNode*>(1)->Dump( f );
15187  fprintf( f, "%s", ")" );
15188  break;
15189  case eMUL:
15190  fprintf( f, "%s", "(" );
15191  Arg<CNode*>(0)->Dump( f );
15192  fprintf( f, "%s", ")*(" );
15193  Arg<CNode*>(1)->Dump( f );
15194  fprintf( f, "%s", ")" );
15195  break;
15196  case eDIV:
15197  fprintf( f, "%s", "(" );
15198  Arg<CNode*>(0)->Dump( f );
15199  fprintf( f, "%s", ")/(" );
15200  Arg<CNode*>(1)->Dump( f );
15201  fprintf( f, "%s", ")" );
15202  break;
15203  case ePOW:
15204  fprintf( f, "%s", "(" );
15205  Arg<CNode*>(0)->Dump( f );
15206  fprintf( f, "%s", ")**(" );
15207  Arg<CNode*>(1)->Dump( f );
15208  fprintf( f, "%s", ")" );
15209  break;
15210  case eADD:
15211  fprintf( f, "%s", "(" );
15212  Arg<CNode*>(0)->Dump( f );
15213  fprintf( f, "%s", ")+(" );
15214  Arg<CNode*>(1)->Dump( f );
15215  fprintf( f, "%s", ")" );
15216  break;
15217  case eLSH:
15218  fprintf( f, "%s", "(" );
15219  Arg<CNode*>(0)->Dump( f );
15220  fprintf( f, "%s", ")<<(" );
15221  Arg<CNode*>(1)->Dump( f );
15222  fprintf( f, "%s", ")" );
15223  break;
15224  case eRSH:
15225  fprintf( f, "%s", "(" );
15226  Arg<CNode*>(0)->Dump( f );
15227  fprintf( f, "%s", ")>>(" );
15228  Arg<CNode*>(1)->Dump( f );
15229  fprintf( f, "%s", ")" );
15230  break;
15231  case eLSHA:
15232  fprintf( f, "%s", "(" );
15233  Arg<CNode*>(0)->Dump( f );
15234  fprintf( f, "%s", ")<<<(" );
15235  Arg<CNode*>(1)->Dump( f );
15236  fprintf( f, "%s", ")" );
15237  break;
15238  case eRSHA:
15239  fprintf( f, "%s", "(" );
15240  Arg<CNode*>(0)->Dump( f );
15241  fprintf( f, "%s", ")>>>(" );
15242  Arg<CNode*>(1)->Dump( f );
15243  fprintf( f, "%s", ")" );
15244  break;
15245  case eMOD:
15246  fprintf( f, "%s", "(" );
15247  Arg<CNode*>(0)->Dump( f );
15248  fprintf( f, "%s", ")%%(" );
15249  Arg<CNode*>(1)->Dump( f );
15250  fprintf( f, "%s", ")" );
15251  break;
15252  case eOR:
15253  fprintf( f, "%s", "(" );
15254  Arg<CNode*>(0)->Dump( f );
15255  fprintf( f, "%s", ")|(" );
15256  Arg<CNode*>(1)->Dump( f );
15257  fprintf( f, "%s", ")" );
15258  break;
15259  case eAND:
15260  fprintf( f, "%s", "(" );
15261  Arg<CNode*>(0)->Dump( f );
15262  fprintf( f, "%s", ")&(" );
15263  Arg<CNode*>(1)->Dump( f );
15264  fprintf( f, "%s", ")" );
15265  break;
15266  case eANDANDAND:
15267  fprintf( f, "%s", "(" );
15268  Arg<CNode*>(0)->Dump( f );
15269  fprintf( f, "%s", ")&&&(" );
15270  Arg<CNode*>(1)->Dump( f );
15271  fprintf( f, "%s", ")" );
15272  break;
15273  case eXOR:
15274  fprintf( f, "%s", "(" );
15275  Arg<CNode*>(0)->Dump( f );
15276  fprintf( f, "%s", ")^(" );
15277  Arg<CNode*>(1)->Dump( f );
15278  fprintf( f, "%s", ")" );
15279  break;
15280  case eXNOR:
15281  fprintf( f, "%s", "(" );
15282  Arg<CNode*>(0)->Dump( f );
15283  fprintf( f, "%s", ")~^(" );
15284  Arg<CNode*>(1)->Dump( f );
15285  fprintf( f, "%s", ")" );
15286  break;
15287  case eFUNCTION_CALL:
15288  fprintf( f, "%s", "" );
15289  fprintf( f, "%s", Arg<CSymbol*>(0)->GetName() );
15290  fprintf( f, "%s", "(" );
15291  Arg<CNode*>(1)->Dump( f );
15292  fprintf( f, "%s", ")" );
15293  break;
15294  case eARRAY:
15295  fprintf( f, "%s", "" );
15296  Arg<CNode*>(0)->Dump( f );
15297  fprintf( f, "%s", "[" );
15298  Arg<CNode*>(1)->Dump( f );
15299  fprintf( f, "%s", "]" );
15300  break;
15301  case eNET_REF:
15302  fprintf( f, "%s", Arg<CNet*>(0)->GetName() );
15303  break;
15304  case eVAR_REF:
15305  fprintf( f, "%s", Arg<CVar*>(0)->GetName() );
15306  break;
15307  case ePARAM_REF:
15308  fprintf( f, "%s", Arg<CParam*>(0)->GetName() );
15309  break;
15310  case ePORT_REF:
15311  fprintf( f, "%s", Arg<CPort*>(0)->GetName() );
15312  break;
15313  case eFWD_REF:
15314  fprintf( f, "%s", Arg<CFref*>(0)->GetName() );
15315  break;
15316  case eGENVAR_REF:
15317  fprintf( f, "%s", Arg<CGenvar*>(0)->GetName() );
15318  break;
15319  case eENUM_REF:
15320  fprintf( f, "%s", Arg<CEnum*>(0)->GetName() );
15321  break;
15322  case eTYPE_REF:
15323  fprintf( f, "%s", Arg<CTypedef*>(0)->GetName() );
15324  break;
15325  case eVAR_DECL:
15326  fprintf( f, "%s", "VarDecl" );
15327  break;
15328  case eLIST:
15329  fprintf( f, "%s", "(" );
15330  Arg<CNode*>(0)->Dump( f );
15331  fprintf( f, "%s", "," );
15332  Arg<CNode*>(1)->Dump( f );
15333  fprintf( f, "%s", ")" );
15334  break;
15335  case eRANGE:
15336  fprintf( f, "%s", "" );
15337  Arg<CNode*>(0)->Dump( f );
15338  fprintf( f, "%s", ":" );
15339  Arg<CNode*>(1)->Dump( f );
15340  fprintf( f, "%s", "" );
15341  break;
15342  case eSLICE:
15343  fprintf( f, "%s", "" );
15344  Arg<CNode*>(0)->Dump( f );
15345  fprintf( f, "%s", ":" );
15346  Arg<CNode*>(1)->Dump( f );
15347  fprintf( f, "%s", "" );
15348  break;
15349  case ePSLICE:
15350  fprintf( f, "%s", "" );
15351  Arg<CNode*>(0)->Dump( f );
15352  fprintf( f, "%s", "+:" );
15353  Arg<CNode*>(1)->Dump( f );
15354  fprintf( f, "%s", "" );
15355  break;
15356  case eMSLICE:
15357  fprintf( f, "%s", "" );
15358  Arg<CNode*>(0)->Dump( f );
15359  fprintf( f, "%s", "-:" );
15360  Arg<CNode*>(1)->Dump( f );
15361  fprintf( f, "%s", "" );
15362  break;
15363  case eCVRI:
15364  fprintf( f, "%s", "CVRI(" );
15365  Arg<CNode*>(0)->Dump( f );
15366  fprintf( f, "%s", ")" );
15367  break;
15368  case eCVIR:
15369  fprintf( f, "%s", "CVIR(" );
15370  Arg<CNode*>(0)->Dump( f );
15371  fprintf( f, "%s", ")" );
15372  break;
15373  case eREP:
15374  fprintf( f, "%s", "{" );
15375  Arg<CNode*>(0)->Dump( f );
15376  fprintf( f, "%s", "{" );
15377  Arg<CNode*>(1)->Dump( f );
15378  fprintf( f, "%s", "}}" );
15379  break;
15380  case eCAT:
15381  fprintf( f, "%s", "{" );
15382  Arg<CNode*>(0)->Dump( f );
15383  fprintf( f, "%s", "," );
15384  Arg<CNode*>(1)->Dump( f );
15385  fprintf( f, "%s", "}" );
15386  break;
15387  case eUCAT:
15388  fprintf( f, "%s", "{" );
15389  Arg<CNode*>(0)->Dump( f );
15390  fprintf( f, "%s", "}" );
15391  break;
15392  case eCOM:
15393  fprintf( f, "%s", "~(" );
15394  Arg<CNode*>(0)->Dump( f );
15395  fprintf( f, "%s", ")" );
15396  break;
15397  case eNEG:
15398  fprintf( f, "%s", "-(" );
15399  Arg<CNode*>(0)->Dump( f );
15400  fprintf( f, "%s", ")" );
15401  break;
15402  case ePLUS:
15403  fprintf( f, "%s", "+(" );
15404  Arg<CNode*>(0)->Dump( f );
15405  fprintf( f, "%s", ")" );
15406  break;
15407  case eNOT:
15408  fprintf( f, "%s", "!(" );
15409  Arg<CNode*>(0)->Dump( f );
15410  fprintf( f, "%s", ")" );
15411  break;
15412  case eGT:
15413  fprintf( f, "%s", "(" );
15414  Arg<CNode*>(0)->Dump( f );
15415  fprintf( f, "%s", ")>(" );
15416  Arg<CNode*>(1)->Dump( f );
15417  fprintf( f, "%s", ")" );
15418  break;
15419  case eGE:
15420  fprintf( f, "%s", "(" );
15421  Arg<CNode*>(0)->Dump( f );
15422  fprintf( f, "%s", ")>=(" );
15423  Arg<CNode*>(1)->Dump( f );
15424  fprintf( f, "%s", ")" );
15425  break;
15426  case eLT:
15427  fprintf( f, "%s", "(" );
15428  Arg<CNode*>(0)->Dump( f );
15429  fprintf( f, "%s", ")<(" );
15430  Arg<CNode*>(1)->Dump( f );
15431  fprintf( f, "%s", ")" );
15432  break;
15433  case eLE:
15434  fprintf( f, "%s", "(" );
15435  Arg<CNode*>(0)->Dump( f );
15436  fprintf( f, "%s", ")<=(" );
15437  Arg<CNode*>(1)->Dump( f );
15438  fprintf( f, "%s", ")" );
15439  break;
15440  case eLAND:
15441  fprintf( f, "%s", "(" );
15442  Arg<CNode*>(0)->Dump( f );
15443  fprintf( f, "%s", ")&&(" );
15444  Arg<CNode*>(1)->Dump( f );
15445  fprintf( f, "%s", ")" );
15446  break;
15447  case eLOR:
15448  fprintf( f, "%s", "(" );
15449  Arg<CNode*>(0)->Dump( f );
15450  fprintf( f, "%s", ")||(" );
15451  Arg<CNode*>(1)->Dump( f );
15452  fprintf( f, "%s", ")" );
15453  break;
15454  case eCEQ:
15455  fprintf( f, "%s", "(" );
15456  Arg<CNode*>(0)->Dump( f );
15457  fprintf( f, "%s", ")===(" );
15458  Arg<CNode*>(1)->Dump( f );
15459  fprintf( f, "%s", ")" );
15460  break;
15461  case eCNE:
15462  fprintf( f, "%s", "(" );
15463  Arg<CNode*>(0)->Dump( f );
15464  fprintf( f, "%s", ")!==(" );
15465  Arg<CNode*>(1)->Dump( f );
15466  fprintf( f, "%s", ")" );
15467  break;
15468  case eEQ:
15469  fprintf( f, "%s", "(" );
15470  Arg<CNode*>(0)->Dump( f );
15471  fprintf( f, "%s", ")==(" );
15472  Arg<CNode*>(1)->Dump( f );
15473  fprintf( f, "%s", ")" );
15474  break;
15475  case eNE:
15476  fprintf( f, "%s", "(" );
15477  Arg<CNode*>(0)->Dump( f );
15478  fprintf( f, "%s", ")!=(" );
15479  Arg<CNode*>(1)->Dump( f );
15480  fprintf( f, "%s", ")" );
15481  break;
15482  case eRAND:
15483  fprintf( f, "%s", "&(" );
15484  Arg<CNode*>(0)->Dump( f );
15485  fprintf( f, "%s", ")" );
15486  break;
15487  case eRNAND:
15488  fprintf( f, "%s", "~&(" );
15489  Arg<CNode*>(0)->Dump( f );
15490  fprintf( f, "%s", ")" );
15491  break;
15492  case eROR:
15493  fprintf( f, "%s", "|(" );
15494  Arg<CNode*>(0)->Dump( f );
15495  fprintf( f, "%s", ")" );
15496  break;
15497  case eRNOR:
15498  fprintf( f, "%s", "~|(" );
15499  Arg<CNode*>(0)->Dump( f );
15500  fprintf( f, "%s", ")" );
15501  break;
15502  case eRXOR:
15503  fprintf( f, "%s", "^(" );
15504  Arg<CNode*>(0)->Dump( f );
15505  fprintf( f, "%s", ")" );
15506  break;
15507  case eRXNOR:
15508  fprintf( f, "%s", "~^(" );
15509  Arg<CNode*>(0)->Dump( f );
15510  fprintf( f, "%s", ")" );
15511  break;
15512  case eHOOK:
15513  fprintf( f, "%s", "(" );
15514  Arg<CNode*>(0)->Dump( f );
15515  fprintf( f, "%s", ")?(" );
15516  Arg<CNode*>(1)->Dump( f );
15517  fprintf( f, "%s", "):(" );
15518  Arg<CNode*>(2)->Dump( f );
15519  fprintf( f, "%s", ")" );
15520  break;
15521  case eINIT:
15522  fprintf( f, "%s", "INIT(*)" );
15523  break;
15524  case ePOSEDGE:
15525  fprintf( f, "%s", "POSEDGE(" );
15526  Arg<CNode*>(0)->Dump( f );
15527  fprintf( f, "%s", ")" );
15528  break;
15529  case eNEGEDGE:
15530  fprintf( f, "%s", "NEGEDGE(" );
15531  Arg<CNode*>(0)->Dump( f );
15532  fprintf( f, "%s", ")" );
15533  break;
15534  case eEDGE:
15535  fprintf( f, "%s", "EDGE(" );
15536  Arg<CNode*>(0)->Dump( f );
15537  fprintf( f, "%s", ")" );
15538  break;
15539  case eMTM:
15540  fprintf( f, "%s", "(" );
15541  Arg<CNode*>(0)->Dump( f );
15542  fprintf( f, "%s", ":" );
15543  Arg<CNode*>(1)->Dump( f );
15544  fprintf( f, "%s", ":" );
15545  Arg<CNode*>(2)->Dump( f );
15546  fprintf( f, "%s", ")" );
15547  break;
15548  case eMODULE_DEF:
15549  fprintf( f, "%s", "MODULE_DEF" );
15550  break;
15551  case ePACKAGE_DEF:
15552  fprintf( f, "%s", "PACKAGE_DEF" );
15553  break;
15554  case eMACRO_EXPR:
15555  fprintf( f, "%s", "" );
15556  fprintf( f, "%s", (const char*)Arg<const char*>(0) );
15557  fprintf( f, "%s", "<" );
15558  Arg<CNode*>(1)->Dump( f );
15559  fprintf( f, "%s", ">" );
15560  break;
15561  case eMEMBER:
15562  fprintf( f, "%s", "" );
15563  Arg<CNode*>(0)->Dump( f );
15564  fprintf( f, "%s", "." );
15565  fprintf( f, "%s", Arg<CSymbol*>(1)->GetName() );
15566  fprintf( f, "%s", "" );
15567  break;
15568  case ePREINC:
15569  fprintf( f, "%s", "++(" );
15570  Arg<CNode*>(0)->Dump( f );
15571  fprintf( f, "%s", ")" );
15572  break;
15573  case ePOSTINC:
15574  fprintf( f, "%s", "(" );
15575  Arg<CNode*>(0)->Dump( f );
15576  fprintf( f, "%s", ")++" );
15577  break;
15578  case ePREDEC:
15579  fprintf( f, "%s", "--(" );
15580  Arg<CNode*>(0)->Dump( f );
15581  fprintf( f, "%s", ")" );
15582  break;
15583  case ePOSTDEC:
15584  fprintf( f, "%s", "(" );
15585  Arg<CNode*>(0)->Dump( f );
15586  fprintf( f, "%s", ")--" );
15587  break;
15588  case eCAST:
15589  fprintf( f, "%s", "CAST(" );
15590  Arg<CNode*>(0)->Dump( f );
15591  fprintf( f, "%s", "," );
15592  Arg<CNode*>(1)->Dump( f );
15593  fprintf( f, "%s", ")" );
15594  break;
15595  case eCOMMENT:
15596  case eVRQ:
15597  case eNOP:
15598  case eINSTANCE_REF:
15599  case eGATE_REF:
15600  case eTASK_ENABLE:
15601  case eSYSTASK_CALL:
15602  case eTIMING_CALL:
15603  case eNET_DECL:
15604  case ePARAM_DECL:
15605  case eSPECPARAM_DECL:
15606  case ePORT_DECL:
15607  case eGENVAR_DECL:
15608  case eTYPEDEF_DECL:
15609  case eALWAYS:
15610  case eALWAYS_LATCH:
15611  case eALWAYS_FF:
15612  case eALWAYS_COMB:
15613  case eEVENT:
15614  case eBLOCK_REF:
15615  case eSPECIFY_REF:
15616  case eASSIGN:
15617  case eADD_ASSIGN:
15618  case eSUB_ASSIGN:
15619  case eMUL_ASSIGN:
15620  case eDIV_ASSIGN:
15621  case eMOD_ASSIGN:
15622  case eAND_ASSIGN:
15623  case eOR_ASSIGN:
15624  case eXOR_ASSIGN:
15625  case eLSH_ASSIGN:
15626  case eRSH_ASSIGN:
15627  case eLSHA_ASSIGN:
15628  case eRSHA_ASSIGN:
15629  case eFORCE:
15630  case eRELEASE:
15631  case eNBASSIGN:
15632  case eEVOR:
15633  case eDELAY:
15634  case eIF:
15635  case eFOREVER:
15636  case eREPEAT:
15637  case eWHILE:
15638  case eWAIT:
15639  case eFOR:
15640  case eCASE:
15641  case eCASEX:
15642  case eCASEZ:
15643  case eCASEITEM:
15644  case eCASSIGN:
15645  case eARG:
15646  case eIMPORT:
15647  case eFUNCTION_DEF:
15648  case eREPEAT_CONTROL:
15649  case eDELAY_CONTROL:
15650  case eEVENT_CONTROL:
15651  case eEXTERNAL_REF:
15652  case ePORT_DEF:
15653  case eDEFPARAM:
15654  case ePATH:
15655  case ePATH_ASSIGN:
15656  case eIFNONE_PATH_ASSIGN:
15657  case eTRIGGER:
15658  case ePASSIGN:
15659  case eDEASSIGN:
15660  case eDISABLE:
15661  case eATTRIBUTE:
15662  case eGIF:
15663  case eGFOR:
15664  case eGCASE:
15665  case eTABLE:
15666  case eTABLE_ENTRY:
15667  case eTABLE_SYMBOL:
15668  case ePORTLIST_END:
15669  case eENUM_SPEC:
15670  case eRETURN:
15671  fprintf( f, "%s(%p)", nodeOpName[GetOp()],this );
15672  break;
15673  }
15674 }
15675 
15676 #endif // DEFINE_METHODS
15677 
15678 #ifdef DEFINE_TEST_HARNESS
15680 {
15681  for( int i = 0; i < 152; ++i ) {
15682  CNode* n = new(CNode::stack) CNode( NULL, (NodeOp_t)i );
15683  if( n->Precedence() != n->Precedence_1() ) {
15684  printf( "Fail %s\n", nodeOpName[i] );
15685  exit(1);
15686  }
15687  }
15688 }
15689 #endif // DEFINE_TEST_HARNESS
CNode * cDIV(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for DIV divide.
Definition: cnode_def.h:2926
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:2860
static NodeType_t Type(CSymbol *symbol, CNode *args)
Determine type of systask.
Definition: systask.h:134
nonblocking assignment
Definition: cnode_def.h:1704
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:5882
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:4846
CNode * cFOREVER(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for FOREVER forever statement.
Definition: cnode_def.h:6054
real constant
Definition: cnode_def.h:649
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:5430
CNode * cDEASSIGN(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for DEASSIGN deassign statement.
Definition: cnode_def.h:6912
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:5356
preincrement
Definition: cnode_def.h:2226
CNode * cASSIGN(CNode *a0, CNode *a1, CNode *a2, Coord_t *loc=NULL)
Node construction shortcut for ASSIGN procedural assignment.
Definition: cnode_def.h:5245
vector subrange with ascending index select
Definition: cnode_def.h:1147
force statement
Definition: cnode_def.h:1682
condition expression operator
Definition: cnode_def.h:1432
arithmetic right shift
Definition: cnode_def.h:809
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:6358
procedural assignment with mul
Definition: cnode_def.h:1563
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:5319
sentinal at end of port list
Definition: cnode_def.h:2172
CNode * cPARAM_DECL(CParam *a0, Coord_t *loc=NULL)
Node construction shortcut for PARAM_DECL parameter declaration.
Definition: cnode_def.h:3879
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:5948
reduction xnor
Definition: cnode_def.h:1420
case not equal
Definition: cnode_def.h:1338
CNode * cMOD(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for MOD modulus.
Definition: cnode_def.h:3157
CNode * cWAIT(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for WAIT wait statement.
Definition: cnode_def.h:6150
no operation
Definition: cnode_def.h:710
Declaration object for genvars.
Definition: cgenvar.h:46
reduction nand
Definition: cnode_def.h:1380
CNode * cELIST(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for ELIST expression list.
Definition: cnode_def.h:2769
undefined
Definition: cdatatype.h:98
error node
Definition: cnode_def.h:629
CNode * cPORT_REF(CPortDir *a0, Coord_t *loc=NULL)
Node construction shortcut for PORT_REF reference to port.
Definition: cnode_def.h:3668
signed bit vector, includes integer
Definition: cdatatype.h:100
gate instance
Definition: cnode_def.h:895
procedural assignment with right shift
Definition: cnode_def.h:1647
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:1956
exponent
Definition: cnode_def.h:754
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:3513
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:2681
statement block
Definition: cnode_def.h:1504
disable statement
Definition: cnode_def.h:2087
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:1623
vector decl range specification
Definition: cnode_def.h:1125
case equal
Definition: cnode_def.h:1327
CNode * cREAL(double number)
Short cut for creating RCONSTANT node with a given double value.
Definition: cnode.h:803
negative event qualifier
Definition: cnode_def.h:1724
import item
Definition: cnode_def.h:1915
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:5393
initial block
Definition: cnode_def.h:1442
CNode * cPREDEC(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for PREDEC predecrement.
Definition: cnode_def.h:7412
CNode * cGIF(CNode *a0, CNode *a1, CNode *a2, Coord_t *loc=NULL)
Node construction shortcut for GIF structural if statement.
Definition: cnode_def.h:7001
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:3697
int IsEvaluateable()
Checks to see if expression tree can be evaluated.
Definition: cnode_def.h:12554
bitwise and
Definition: cnode_def.h:842
CNode * cCAT(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for CAT concatenation operator.
Definition: cnode_def.h:4281
postincrement
Definition: cnode_def.h:2236
void Add(double *r, double *a, double *b)
Definition: cnode.h:668
CNode * cRXOR(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for RXOR reduction xor.
Definition: cnode_def.h:4904
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:6397
CNode * cMAX_N(CNode *first,...)
Definition: cnode.h:1252
CNode * cAND(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for AND bitwise and.
Definition: cnode_def.h:3223
instance reference
Definition: cnode_def.h:885
CNode * cTABLE_SYMBOL(char *a0, Coord_t *loc=NULL)
Node construction shortcut for TABLE_SYMBOL udp table symbol.
Definition: cnode_def.h:7168
CNode * cPOSEDGE(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for POSEDGE positive event qualifier.
Definition: cnode_def.h:5823
not equal
Definition: cnode_def.h:1360
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:5689
CNode * cNOT(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for NOT logical complement.
Definition: cnode_def.h:4429
CNode * cRETURN(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for RETURN return.
Definition: cnode_def.h:7325
void Neg(double *r, double *a)
Definition: cnode.h:688
CNode * cCEQ(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for CEQ case equal.
Definition: cnode_def.h:4657
list of nodes
Definition: cnode_def.h:1114
greater than or equal
Definition: cnode_def.h:1272
CNode * cEQ(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for EQ equal.
Definition: cnode_def.h:4723
vector constant
Definition: cnode_def.h:639
procedural assignment
Definition: cnode_def.h:1527
Coord_t * GetCoord()
Get node's file coordinates.
Definition: cnode.h:303
CNode * cNET_DECL(CNet *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for NET_DECL net declaration.
Definition: cnode_def.h:3814
wait statement
Definition: cnode_def.h:1824
CNode * cMUL_N(CNode *first,...)
Definition: cnode.h:1286
CNode * cIFNONE_PATH_ASSIGN(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for IFNONE_PATH_ASSIGN ifnone path assignment statement.
Definition: cnode_def.h:6818
static CObstack * CurrentHeap()
Gets pointer to current heap allocator.
Definition: cnode.h:228
CNode * cEVOR(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for EVOR event or.
Definition: cnode_def.h:5915
int IsConstant()
Checks expression tree to see if it is constant.
Definition: cnode_def.h:7999
CNode * GetWidthExp(void)
Create expression representing width of expression.
Definition: cnode_def.h:8637
reduction xor
Definition: cnode_def.h:1410
case item
Definition: cnode_def.h:1881
delay control
Definition: cnode_def.h:1966
CNode * cRAND(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for RAND reduction and.
Definition: cnode_def.h:4788
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:5788
CNode * cNEG(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for NEG negation.
Definition: cnode_def.h:4371
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:5504
reduction nor
Definition: cnode_def.h:1400
CNode * cGT(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for GT greater than.
Definition: cnode_def.h:4459
CNode * cCVRI(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for CVRI convert real to integer.
Definition: cnode_def.h:4189
void PostVisit1(void(*callback)(CNode *, void *), void *data)
Walk tree invoking callback on each node after children have been visited.
Definition: cnode_def.h:10416
port connection
Definition: cnode_def.h:1905
long INT32
Short cut for signed 32 bit integer.
Definition: glue.h:38
arithmetic left shift
Definition: cnode_def.h:798
CNode * cDISABLE(CSymbol *a0, Coord_t *loc=NULL)
Node construction shortcut for DISABLE disable statement.
Definition: cnode_def.h:6941
CNode * cREPEAT_CONTROL(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for REPEAT_CONTROL repeat control.
Definition: cnode_def.h:6546
variable declaration
Definition: cnode_def.h:1053
int IsVolatile(void)
Checks to see if expression tree is volatile.
Definition: cnode_def.h:8161
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:5652
path statement
Definition: cnode_def.h:2023
int Precedence()
Get the precedence of the operator represented by the node.
Definition: cnode_def.h:7831
genvar declaration
Definition: cnode_def.h:1093
CNode_sp< T > Arg(int index)
Get a node's operand.
Definition: cnode.h:535
Edge_t
Edge values.
Definition: cnode.h:72
CNode * cFOR(CNode *a0, CNode *a1, CNode *a2, CNode *a3, Coord_t *loc=NULL)
Node construction shortcut for FOR for statement.
Definition: cnode_def.h:6185
CNode * cRSH(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for RSH logical right shift.
Definition: cnode_def.h:3058
reference to port
Definition: cnode_def.h:991
CNode * cFUNCTION_DEF(CFunction *a0, Coord_t *loc=NULL)
Node construction shortcut for FUNCTION_DEF function definition.
Definition: cnode_def.h:6458
convert integer to real
Definition: cnode_def.h:1178
logical and
Definition: cnode_def.h:1305
reduction or
Definition: cnode_def.h:1390
less than or equal
Definition: cnode_def.h:1294
edge qualifier
Definition: cnode_def.h:1735
reduction and
Definition: cnode_def.h:1370
bitwise or
Definition: cnode_def.h:831
CNode * cSLICE(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for SLICE vector subrange.
Definition: cnode_def.h:4091
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:4558
reference to a forward declared variable
Definition: cnode_def.h:1001
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:4124
CNode * cSPECPARAM_DECL(CParam *a0, Coord_t *loc=NULL)
Node construction shortcut for SPECPARAM_DECL specify parameter declaration.
Definition: cnode_def.h:3908
void CNodeTestHarness()
Definition: cnode_def.h:15679
comment
Definition: cnode_def.h:659
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:6117
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:5282
bitwise xor
Definition: cnode_def.h:864
CNode * cCAST(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for CAST data type change.
Definition: cnode_def.h:7471
procedural assignment with div
Definition: cnode_def.h:1575
procedural assignment with add
Definition: cnode_def.h:1539
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:4964
concatenation operator
Definition: cnode_def.h:1200
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:1635
port declaration
Definition: cnode_def.h:1083
CNode * cPACKAGE_DEF(CPackage *a0, Coord_t *loc=NULL)
Node construction shortcut for PACKAGE_DEF package definition.
Definition: cnode_def.h:6516
reference to a genvar
Definition: cnode_def.h:1011
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:7039
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:6782
CNode * cATTRIBUTE(CAttr *a0, Coord_t *loc=NULL)
Node construction shortcut for ATTRIBUTE attribute specification.
Definition: cnode_def.h:6970
CNode * cTABLE_ENTRY(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for TABLE_ENTRY udp table entry.
Definition: cnode_def.h:7139
convert real to integer
Definition: cnode_def.h:1168
int ArgCount(void)
Get the number of operands for the node.
Definition: cnode_def.h:7511
CNode * cGENVAR_DECL(CGenvar *a0, Coord_t *loc=NULL)
Node construction shortcut for GENVAR_DECL genvar declaration.
Definition: cnode_def.h:3966
CNode * cALWAYS(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for ALWAYS always block.
Definition: cnode_def.h:5028
CNode * cERROR(Coord_t *loc=NULL)
Node construction shortcut for ERROR error node.
Definition: cnode_def.h:2597
CNode * cCASEX(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for CASEX casex statement.
Definition: cnode_def.h:6257
unsigned bit vector
Definition: cdatatype.h:102
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:3446
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:3784
CNode * cALWAYS_COMB(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for ALWAYS_COMB always combinational logic block.
Definition: cnode_def.h:5115
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:2097
CNode * cRANGE(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for RANGE vector decl range specification.
Definition: cnode_def.h:4058
event statement
Definition: cnode_def.h:1493
Declaration object for module/function/task ports.
Definition: cport.h:44
divide
Definition: cnode_def.h:743
static int WidthConstant(CSymbol *symbol)
Determine if width of external variable is constant.
Definition: external.h:62
Forward reference declaration.
Definition: cfref.h:51
Bulk object allocation object.
Definition: cobstack.h:46
CNode * cABSDIFFPLUS1_N(CNode *first,...)
Definition: cnode.h:1302
delay statement
Definition: cnode_def.h:1757
negation
Definition: cnode_def.h:1230
logical right shift
Definition: cnode_def.h:787
casez statement
Definition: cnode_def.h:1870
unary concat
Definition: cnode_def.h:1210
call to a task
Definition: cnode_def.h:906
reference to net
Definition: cnode_def.h:961
void LoadReal(double d)
Load vector with integer part of real value.
int error
Definition: cnode_def.h:13586
int IsOwner(void *ptr)
Determine if pointer was allocated from this obstack.
Definition: cnode_def.h:13584
CNode * cPRAGMA(const char *a0, Coord_t *loc=NULL)
Node construction shortcut for PRAGMA program pragma.
Definition: cnode_def.h:2739
CNode * cFORCE(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for FORCE force statement.
Definition: cnode_def.h:5725
CNode * cEXTERNAL_REF(CSymbol *a0, Coord_t *loc=NULL)
Node construction shortcut for EXTERNAL_REF external reference.
Definition: cnode_def.h:6636
vrq comment
Definition: cnode_def.h:669
CNode * cLAND(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for LAND logical and.
Definition: cnode_def.h:4591
CNode * cRSHA(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for RSHA arithmetic right shift.
Definition: cnode_def.h:3124
equal
Definition: cnode_def.h:1349
unary plus
Definition: cnode_def.h:1240
Primary data structure representing parse tree nodes.
Definition: cnode.h:188
CNode * cPASSIGN(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for PASSIGN procedural assignment.
Definition: cnode_def.h:6880
CNode * cANDANDAND(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for ANDANDAND triple and.
Definition: cnode_def.h:3256
CNode * cNET_REF(CNet *a0, Coord_t *loc=NULL)
Node construction shortcut for NET_REF reference to net.
Definition: cnode_def.h:3581
integer declaration
Definition: cdatatype.h:50
NodeOp_t
Parse tree opcodes.
Definition: cnode_def.h:620
void info(struct Coord_t *location, const char *format,...)
This routine should not be used by plugins.
program pragma
Definition: cnode_def.h:679
CNode * cTRIGGER(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for TRIGGER event trigger.
Definition: cnode_def.h:6850
return
Definition: cnode_def.h:2216
CNode * cCNE(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for CNE case not equal.
Definition: cnode_def.h:4690
CNode * cVAR_REF(CVar *a0, Coord_t *loc=NULL)
Node construction shortcut for VAR_REF reference to variable.
Definition: cnode_def.h:3610
CNode * cCOM(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for COM bitwise complement.
Definition: cnode_def.h:4342
positive event qualifier
Definition: cnode_def.h:1714
CNode * cWIDTH(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for WIDTH expression width change.
Definition: cnode_def.h:2802
CNode * cEVENT(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for EVENT event statement.
Definition: cnode_def.h:5145
defparam statement
Definition: cnode_def.h:2007
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:9235
Declaration object for module and gate instances.
Definition: cinstance.h:45
expression list
Definition: cnode_def.h:690
void EvalVector(CVector &v)
Evaluates expression tree evaluated in unconstrainted context.
Definition: cnode.cc:360
udp table symbol
Definition: cnode_def.h:2163
CNode * cEVENT_CONTROL(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for EVENT_CONTROL event control.
Definition: cnode_def.h:6607
multiply
Definition: cnode_def.h:732
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:4157
call to a function
Definition: cnode_def.h:940
CNode * cARRAY(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for ARRAY dimensioned reference (array/bit select)
Definition: cnode_def.h:3549
CNode * cVRQ(const char *a0, Coord_t *loc=NULL)
Node construction shortcut for VRQ vrq comment.
Definition: cnode_def.h:2710
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:7383
parameter declaration
Definition: cnode_def.h:1063
void Pow(double *r, double *a, double *b)
Definition: cnode.h:698
less than
Definition: cnode_def.h:1283
CNode * cALWAYS_FF(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for ALWAYS_FF always flip-flop block.
Definition: cnode_def.h:5086
CNode * cCASEITEM(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for CASEITEM case item.
Definition: cnode_def.h:6323
replication operator
Definition: cnode_def.h:1189
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:2206
CNode * cINIT(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for INIT initial block.
Definition: cnode_def.h:4999
Definition: cmodule.h:54
void SetAttributes(CNode *attr)
Attach attributes to operation.
Definition: cnode.h:505
CNode * cPORTLIST_END(Coord_t *loc=NULL)
Node construction shortcut for PORTLIST_END sentinal at end of port list.
Definition: cnode_def.h:7196
package definition
Definition: cnode_def.h:1945
bitwise xnor
Definition: cnode_def.h:875
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:7293
CNode * cALWAYS_LATCH(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for ALWAYS_LATCH always latch block.
Definition: cnode_def.h:5057
event control
Definition: cnode_def.h:1976
event or
Definition: cnode_def.h:1746
const char * nodeOpDescription[]
Definition: cnode_def.h:2429
CNode * PostSubVisit1(CNode *(*callback)(CNode *, void *), void *data)
Walk tree invoking callback on each node after children have been visited.
Definition: cnode_def.h:10946
procedural assignment with bitwise and
Definition: cnode_def.h:1599
CNode * cPOSTDEC(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for POSTDEC postdecrement.
Definition: cnode_def.h:7441
udp table
Definition: cnode_def.h:2143
for statement
Definition: cnode_def.h:1837
triple and
Definition: cnode_def.h:853
void Div(double *r, double *a, double *b)
Definition: cnode.h:683
CNode * cXOR(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for XOR bitwise xor.
Definition: cnode_def.h:3289
event trigger
Definition: cnode_def.h:2056
structural if statement
Definition: cnode_def.h:2109
reference to a enum
Definition: cnode_def.h:1021
int Equivalent(CNode *a, CNode *b)
Definition: cnode_def.h:12010
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:5852
postdecrement
Definition: cnode_def.h:2256
module definition
Definition: cnode_def.h:1935
void Sub(double *r, double *a, double *b)
Definition: cnode.h:673
subtract
Definition: cnode_def.h:721
CNode * cRNAND(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for RNAND reduction nand.
Definition: cnode_def.h:4817
specify parameter declaration
Definition: cnode_def.h:1073
forever statement
Definition: cnode_def.h:1791
CNode * cRELEASE(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for RELEASE release statement.
Definition: cnode_def.h:5757
Declaration object for variables.
Definition: cvar.h:50
external reference
Definition: cnode_def.h:1986
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:4875
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:5982
while statement
Definition: cnode_def.h:1813
CNode * cENUM_REF(CEnum *a0, Coord_t *loc=NULL)
Node construction shortcut for ENUM_REF reference to a enum.
Definition: cnode_def.h:3755
CNode * cTABLE(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for TABLE udp table.
Definition: cnode_def.h:7110
CNode * cPOW(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for POW exponent.
Definition: cnode_def.h:2959
CNode * cREPEAT(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for REPEAT repeat statement.
Definition: cnode_def.h:6084
CNode * cOR(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for OR bitwise or.
Definition: cnode_def.h:3190
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:1671
CNode * cINT32(INT32 i)
Short cut for creating VCONSTANT node with a given integer value.
Definition: cnode.h:784
int suppressErrorMessages
Definition: cnode_def.h:13585
function definition
Definition: cnode_def.h:1925
CNode * cNE(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for NE not equal.
Definition: cnode_def.h:4756
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:2195
CNode * cGATE_REF(CGate *a0, Coord_t *loc=NULL)
Node construction shortcut for GATE_REF gate instance.
Definition: cnode_def.h:3383
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:6733
int IsWidthEvaluateable(void)
Evaluates if expression width can be evaluated.
Definition: cnode_def.h:9077
CNode * cRCONSTANT(char *a0, Coord_t *loc=NULL)
Node construction shortcut for RCONSTANT real constant.
Definition: cnode_def.h:2652
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:3847
event - have width 0
Definition: cdatatype.h:101
CNode * cPORT_DEF(CPort *a0, Coord_t *loc=NULL)
Node construction shortcut for PORT_DEF port definition.
Definition: cnode_def.h:6665
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:4492
void PreVisit1(int(*callback)(CNode *, void *), void *data)
Walk tree invoking callback on each node before children have been visited.
Definition: cnode_def.h:9899
procedural assignment with mod
Definition: cnode_def.h:1587
CNode * cIMPORT(CSymbol *a0, Coord_t *loc=NULL)
Node construction shortcut for IMPORT import item.
Definition: cnode_def.h:6429
static int Width(CSymbol *symbol, CNode *args)
Get width of systask.
Definition: systask.h:48
INT32 GetWidth(void)
Evaluate width of expression.
Definition: cnode.h:480
call to a timing task
Definition: cnode_def.h:928
CNode * cLT(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for LT less than.
Definition: cnode_def.h:4525
release statement
Definition: cnode_def.h:1692
void Mul(double *r, double *a, double *b)
Definition: cnode.h:678
CNode * cLSH_ASSIGN(CNode *a0, CNode *a1, CNode *a2, Coord_t *loc=NULL)
Node construction shortcut for LSH_ASSIGN procedural assignment with left shift.
Definition: cnode_def.h:5578
structural case statement
Definition: cnode_def.h:2133
int IsWidthConstant(void)
Evaluates if expression width is constant.
Definition: cnode_def.h:8323
CNode * cREP(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for REP replication operator.
Definition: cnode_def.h:4248
CNode * cDELAY_CONTROL(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for DELAY_CONTROL delay control.
Definition: cnode_def.h:6578
CNode * cNOP(Coord_t *loc=NULL)
Node construction shortcut for NOP no operation.
Definition: cnode_def.h:2833
NodeType_t GetNodeType(void)
Get node expression type.
Definition: cnode.h:526
always block
Definition: cnode_def.h:1452
reference to a type
Definition: cnode_def.h:1031
udp table entry
Definition: cnode_def.h:2153
void Plus(double *r, double *a)
Definition: cnode.h:693
CNode * cCASEZ(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for CASEZ casez statement.
Definition: cnode_def.h:6290
INT32 GetWidth(void)
Get vector bit width.
static int WidthConstant(CSymbol *symbol, CNode *args, CBlock *block)
Determine if width of function is constant.
path assignment statement
Definition: cnode_def.h:2035
CNode * cCASE(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for CASE case statement.
Definition: cnode_def.h:6224
int Signed() const
Get signed attribute.
Definition: cvector.h:178
vector subrange
Definition: cnode_def.h:1136
real - have width 0
Definition: cdatatype.h:99
CNode * cBLOCK_REF(CBlock *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for BLOCK_REF statement block.
Definition: cnode_def.h:5178
Declaration object for functions and tasks.
Definition: cfunction.h:50
port definition
Definition: cnode_def.h:1996
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:4025
always flip-flop block
Definition: cnode_def.h:1472
call to enable a systask
Definition: cnode_def.h:917
procedural assignment
Definition: cnode_def.h:2067
CNode * cGCASE(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for GCASE structural case statement.
Definition: cnode_def.h:7078
procedural assignment with bitwise or
Definition: cnode_def.h:1611
unsigned Hash()
Calculate hash of tree.
Definition: cnode_def.h:11478
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:3479
CNode * cRXNOR(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for RXNOR reduction xnor.
Definition: cnode_def.h:4933
structural for statement
Definition: cnode_def.h:2122
logical complement
Definition: cnode_def.h:1250
Declaration object for input/output/inout statements.
Definition: cportdir.h:45
CNode * cMAX(CNode *n1, CNode *n2)
Short cut for creating a expression tree that calculates the maximum of two expressions.
Definition: cnode.h:881
CNode * cXNOR(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for XNOR bitwise xnor.
Definition: cnode_def.h:3322
casex statement
Definition: cnode_def.h:1859
always latch block
Definition: cnode_def.h:1462
CNode * cADD_N(CNode *first,...)
Definition: cnode.h:1270
CNode * cMACRO_EXPR(const char *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for MACRO_EXPR expression represented by a macro.
Definition: cnode_def.h:7223
addition
Definition: cnode_def.h:765
repeat statement
Definition: cnode_def.h:1802
expression represented by a macro
Definition: cnode_def.h:2183
deassign statement
Definition: cnode_def.h:2077
NodeType_t
Expression node type.
Definition: cdatatype.h:97
CNode * cIF(CNode *a0, CNode *a1, CNode *a2, Coord_t *loc=NULL)
Node construction shortcut for IF if statement.
Definition: cnode_def.h:6019
CNode * cSPECIFY_REF(CSpecify *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for SPECIFY_REF specify block.
Definition: cnode_def.h:5211
data type change
Definition: cnode_def.h:2267
procedural assignment with subtract
Definition: cnode_def.h:1551
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:5615
CNode * GetAttributes()
Get attributes attached to operation.
Definition: cnode.h:500
CNode * cADD(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for ADD addition.
Definition: cnode_def.h:2992
const char * nodeOpName[]
Definition: cnode_def.h:2273
predecrement
Definition: cnode_def.h:2246
CNode * cDEFPARAM(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for DEFPARAM defparam statement.
Definition: cnode_def.h:6695
dimensioned reference (array/bit select)
Definition: cnode_def.h:951
CNode * cPORT_DECL(CPortDir *a0, Coord_t *loc=NULL)
Node construction shortcut for PORT_DECL port declaration.
Definition: cnode_def.h:3937
CNode * cLOR(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for LOR logical or.
Definition: cnode_def.h:4624
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:7257
NodeOp_t GetOp()
Return node's operation type.
Definition: cnode.h:308
CNode * cLSH(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for LSH logical left shift.
Definition: cnode_def.h:3025
int IsWidthVolatile(void)
Evaluates if expression width is volatile.
Definition: cnode_def.h:8479
type declaration
Definition: cnode_def.h:1103
CNode * cVCONSTANT(CVector *a0, Coord_t *loc=NULL)
Node construction shortcut for VCONSTANT vector constant.
Definition: cnode_def.h:2623
void Dump(FILE *f)
Print a compact representation of the parse tree.
Definition: cnode_def.h:15149
logical left shift
Definition: cnode_def.h:776
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:4313
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:1894
CNode * cTYPEDEF_DECL(CTypedef *a0, Coord_t *loc=NULL)
Node construction shortcut for TYPEDEF_DECL type declaration.
Definition: cnode_def.h:3995
int cABSDIFFPLUS1(int a1, int a2)
Definition: cnode.h:1340
vector subrange with descending index select
Definition: cnode_def.h:1158
bitwise complement
Definition: cnode_def.h:1220
reference to parameter
Definition: cnode_def.h:981
always combinational logic block
Definition: cnode_def.h:1482
double EvalReal(void)
Evaluates expression tree evaluated in a real context.
Definition: cnode.cc:391
case statement
Definition: cnode_def.h:1848
CNode * cLSHA(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for LSHA arithmetic left shift.
Definition: cnode_def.h:3091
CNode * cPARAM_REF(CParam *a0, Coord_t *loc=NULL)
Node construction shortcut for PARAM_REF reference to parameter.
Definition: cnode_def.h:3639
greater than
Definition: cnode_def.h:1261
CNode * cMODULE_DEF(CModule *a0, Coord_t *loc=NULL)
Node construction shortcut for MODULE_DEF module definition.
Definition: cnode_def.h:6487
specify block
Definition: cnode_def.h:1515
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:7354
CNode * cPLUS(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for PLUS unary plus.
Definition: cnode_def.h:4400
modulus
Definition: cnode_def.h:820
ifnone path assignment statement
Definition: cnode_def.h:2046
net declaration
Definition: cnode_def.h:1042
expression width change
Definition: cnode_def.h:701
CNode * cINSTANCE_REF(CInstance *a0, Coord_t *loc=NULL)
Node construction shortcut for INSTANCE_REF instance reference.
Definition: cnode_def.h:3354
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:3413
CNode * cGENVAR_REF(CGenvar *a0, Coord_t *loc=NULL)
Node construction shortcut for GENVAR_REF reference to a genvar.
Definition: cnode_def.h:3726
CNode * cMUL(CNode *a0, CNode *a1, Coord_t *loc=NULL)
Node construction shortcut for MUL multiply.
Definition: cnode_def.h:2893
virtual INT32 GetWidth(void)
Evaluate packed width of declaration.
procedural assignment with left arithmetic shift
Definition: cnode_def.h:1659
double s2d(char *s)
Convert char string to double.
Definition: cnode.h:1079
if statement
Definition: cnode_def.h:1781
reference to variable
Definition: cnode_def.h:971
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:5467
CNode * cCVIR(CNode *a0, Coord_t *loc=NULL)
Node construction shortcut for CVIR convert integer to real.
Definition: cnode_def.h:4218
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:5541
CNode * Clone(CObstack *heap=stack)
Replicate tree.
Definition: cnode_def.h:9406
min/typ/max expression
Definition: cnode_def.h:1769
logical or
Definition: cnode_def.h:1316