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