00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00517 #ifdef DEFINE_ENUM
00518
00521 enum NodeOp_t {
00525
00526
00527
00528
00529
00530 eERROR,
00534
00535
00536
00537
00538
00539
00540 eVCONSTANT,
00544
00545
00546
00547
00548
00549
00550 eRCONSTANT,
00554
00555
00556
00557
00558
00559
00560 eCOMMENT,
00564
00565
00566
00567
00568
00569
00570 eVRQ,
00574
00575
00576
00577
00578
00579
00580 ePRAGMA,
00584
00585
00586
00587
00588
00589
00590
00591 eELIST,
00595
00596
00597
00598
00599
00600
00601
00602 eWIDTH,
00606
00607
00608
00609
00610
00611 eNOP,
00615
00616
00617
00618
00619
00620
00621
00622 eSUB,
00626
00627
00628
00629
00630
00631
00632
00633 eMUL,
00637
00638
00639
00640
00641
00642
00643
00644 eDIV,
00648
00649
00650
00651
00652
00653
00654
00655 ePOW,
00659
00660
00661
00662
00663
00664
00665
00666 eADD,
00670
00671
00672
00673
00674
00675
00676
00677 eLSH,
00681
00682
00683
00684
00685
00686
00687
00688 eRSH,
00692
00693
00694
00695
00696
00697
00698
00699 eLSHA,
00703
00704
00705
00706
00707
00708
00709
00710 eRSHA,
00714
00715
00716
00717
00718
00719
00720
00721 eMOD,
00725
00726
00727
00728
00729
00730
00731
00732 eOR,
00736
00737
00738
00739
00740
00741
00742
00743 eAND,
00747
00748
00749
00750
00751
00752
00753
00754 eANDANDAND,
00758
00759
00760
00761
00762
00763
00764
00765 eXOR,
00769
00770
00771
00772
00773
00774
00775
00776 eXNOR,
00780
00781
00782
00783
00784
00785
00786 eINSTANCE_REF,
00790
00791
00792
00793
00794
00795
00796 eGATE_REF,
00800
00801
00802
00803
00804
00805
00806
00807 eTASK_ENABLE,
00811
00812
00813
00814
00815
00816
00817
00818 eSYSTASK_CALL,
00822
00823
00824
00825
00826
00827
00828
00829 eTIMING_CALL,
00833
00834
00835
00836
00837
00838
00839
00840
00841 eFUNCTION_CALL,
00845
00846
00847
00848
00849
00850
00851
00852 eARRAY,
00856
00857
00858
00859
00860
00861
00862 eNET_REF,
00866
00867
00868
00869
00870
00871
00872 eREG_REF,
00876
00877
00878
00879
00880
00881
00882 eREAL_REF,
00886
00887
00888
00889
00890
00891
00892 ePARAM_REF,
00896
00897
00898
00899
00900
00901
00902 ePORT_REF,
00906
00907
00908
00909
00910
00911
00912 eFWD_REF,
00916
00917
00918
00919
00920
00921
00922 eEVENT_REF,
00926
00927
00928
00929
00930
00931
00932 eGENVAR_REF,
00936
00937
00938
00939
00940
00941
00942
00943 eNET_DECL,
00947
00948
00949
00950
00951
00952
00953
00954 eREG_DECL,
00958
00959
00960
00961
00962
00963
00964
00965 eREAL_DECL,
00969
00970
00971
00972
00973
00974
00975 ePARAM_DECL,
00979
00980
00981
00982
00983
00984
00985 eSPECPARAM_DECL,
00989
00990
00991
00992
00993
00994
00995 ePORT_DECL,
00999
01000
01001
01002
01003
01004
01005 eEVENT_DECL,
01009
01010
01011
01012
01013
01014
01015 eGENVAR_DECL,
01019
01020
01021
01022
01023
01024
01025
01026 eLIST,
01030
01031
01032
01033
01034
01035
01036
01037 eRANGE,
01041
01042
01043
01044
01045
01046
01047
01048 eSLICE,
01052
01053
01054
01055
01056
01057
01058
01059 ePSLICE,
01063
01064
01065
01066
01067
01068
01069
01070 eMSLICE,
01074
01075
01076
01077
01078
01079
01080 eCVRI,
01084
01085
01086
01087
01088
01089
01090 eCVIR,
01094
01095
01096
01097
01098
01099
01100
01101 eREP,
01105
01106
01107
01108
01109
01110
01111
01112 eCAT,
01116
01117
01118
01119
01120
01121
01122 eUCAT,
01126
01127
01128
01129
01130
01131
01132 eCOM,
01136
01137
01138
01139
01140
01141
01142 eNEG,
01146
01147
01148
01149
01150
01151
01152 ePLUS,
01156
01157
01158
01159
01160
01161
01162 eNOT,
01166
01167
01168
01169
01170
01171
01172
01173 eGT,
01177
01178
01179
01180
01181
01182
01183
01184 eGE,
01188
01189
01190
01191
01192
01193
01194
01195 eLT,
01199
01200
01201
01202
01203
01204
01205
01206 eLE,
01210
01211
01212
01213
01214
01215
01216
01217 eLAND,
01221
01222
01223
01224
01225
01226
01227
01228 eLOR,
01232
01233
01234
01235
01236
01237
01238
01239 eCEQ,
01243
01244
01245
01246
01247
01248
01249
01250 eCNE,
01254
01255
01256
01257
01258
01259
01260
01261 eEQ,
01265
01266
01267
01268
01269
01270
01271
01272 eNE,
01276
01277
01278
01279
01280
01281
01282 eRAND,
01286
01287
01288
01289
01290
01291
01292 eRNAND,
01296
01297
01298
01299
01300
01301
01302 eROR,
01306
01307
01308
01309
01310
01311
01312 eRNOR,
01316
01317
01318
01319
01320
01321
01322 eRXOR,
01326
01327
01328
01329
01330
01331
01332 eRXNOR,
01336
01337
01338
01339
01340
01341
01342
01343
01344 eHOOK,
01348
01349
01350
01351
01352
01353
01354 eINIT,
01358
01359
01360
01361
01362
01363
01364 eALWAYS,
01368
01369
01370
01371
01372
01373
01374
01375 eEVENT,
01379
01380
01381
01382
01383
01384
01385
01386 eBLOCK_REF,
01390
01391
01392
01393
01394
01395
01396
01397 eSPECIFY_REF,
01401
01402
01403
01404
01405
01406
01407
01408
01409 eASSIGN,
01413
01414
01415
01416
01417
01418
01419
01420 eFORCE,
01424
01425
01426
01427
01428
01429
01430 eRELEASE,
01434
01435
01436
01437
01438
01439
01440
01441
01442 eNBASSIGN,
01446
01447
01448
01449
01450
01451
01452 ePOSEDGE,
01456
01457
01458
01459
01460
01461
01462 eNEGEDGE,
01466
01467
01468
01469
01470
01471
01472
01473 eEDGE,
01477
01478
01479
01480
01481
01482
01483
01484 eEVOR,
01488
01489
01490
01491
01492
01493
01494
01495 eDELAY,
01499
01500
01501
01502
01503
01504
01505
01506
01507 eMTM,
01511
01512
01513
01514
01515
01516
01517
01518
01519 eIF,
01523
01524
01525
01526
01527
01528
01529 eFOREVER,
01533
01534
01535
01536
01537
01538
01539
01540 eREPEAT,
01544
01545
01546
01547
01548
01549
01550
01551 eWHILE,
01555
01556
01557
01558
01559
01560
01561
01562 eWAIT,
01566
01567
01568
01569
01570
01571
01572
01573
01574
01575 eFOR,
01579
01580
01581
01582
01583
01584
01585
01586 eCASE,
01590
01591
01592
01593
01594
01595
01596
01597 eCASEX,
01601
01602
01603
01604
01605
01606
01607
01608 eCASEZ,
01612
01613
01614
01615
01616
01617
01618
01619 eCASEITEM,
01623
01624
01625
01626
01627
01628
01629
01630
01631
01632 eCASSIGN,
01636
01637
01638
01639
01640
01641
01642
01643 eARG,
01647
01648
01649
01650
01651
01652
01653 eFUNCTION_DEF,
01657
01658
01659
01660
01661
01662
01663 eMODULE_DEF,
01667
01668
01669
01670
01671
01672
01673
01674 eREPEAT_CONTROL,
01678
01679
01680
01681
01682
01683
01684 eDELAY_CONTROL,
01688
01689
01690
01691
01692
01693
01694 eEVENT_CONTROL,
01698
01699
01700
01701
01702
01703
01704 eEXTERNAL_REF,
01708
01709
01710
01711
01712
01713
01714 ePORT_DEF,
01718
01719
01720
01721
01722
01723
01724
01725 eDEFPARAM,
01729
01730
01731
01732
01733
01734
01735
01736
01737
01738
01739
01740
01741 ePATH,
01745
01746
01747
01748
01749
01750
01751
01752
01753 ePATH_ASSIGN,
01757
01758
01759
01760
01761
01762
01763
01764 eIFNONE_PATH_ASSIGN,
01768
01769
01770
01771
01772
01773
01774 eTRIGGER,
01778
01779
01780
01781
01782
01783
01784
01785 ePASSIGN,
01789
01790
01791
01792
01793
01794
01795 eDEASSIGN,
01799
01800
01801
01802
01803
01804
01805 eDISABLE,
01809
01810
01811
01812
01813
01814
01815 eATTRIBUTE,
01819
01820
01821
01822
01823
01824
01825
01826
01827 eGIF,
01831
01832
01833
01834
01835
01836
01837
01838
01839
01840 eGFOR,
01844
01845
01846
01847
01848
01849
01850
01851 eGCASE,
01855
01856
01857
01858
01859
01860
01861 eTABLE,
01865
01866
01867
01868
01869
01870
01871 eTABLE_ENTRY,
01875
01876
01877
01878
01879
01880
01881 eTABLE_SYMBOL,
01885
01886
01887
01888
01889
01890 ePORTLIST_END,
01894
01895
01896
01897
01898
01899
01900
01901 eMACRO_EXPR
01902 };
01903 extern const char* nodeOpName[];
01904 #endif // DEFINE_ENUM
01905 #ifdef DEFINE_METHODS
01906 const char* nodeOpName[] = {
01907 "ERROR",
01908 "VCONSTANT",
01909 "RCONSTANT",
01910 "COMMENT",
01911 "VRQ",
01912 "PRAGMA",
01913 "ELIST",
01914 "WIDTH",
01915 "NOP",
01916 "SUB",
01917 "MUL",
01918 "DIV",
01919 "POW",
01920 "ADD",
01921 "LSH",
01922 "RSH",
01923 "LSHA",
01924 "RSHA",
01925 "MOD",
01926 "OR",
01927 "AND",
01928 "ANDANDAND",
01929 "XOR",
01930 "XNOR",
01931 "INSTANCE_REF",
01932 "GATE_REF",
01933 "TASK_ENABLE",
01934 "SYSTASK_CALL",
01935 "TIMING_CALL",
01936 "FUNCTION_CALL",
01937 "ARRAY",
01938 "NET_REF",
01939 "REG_REF",
01940 "REAL_REF",
01941 "PARAM_REF",
01942 "PORT_REF",
01943 "FWD_REF",
01944 "EVENT_REF",
01945 "GENVAR_REF",
01946 "NET_DECL",
01947 "REG_DECL",
01948 "REAL_DECL",
01949 "PARAM_DECL",
01950 "SPECPARAM_DECL",
01951 "PORT_DECL",
01952 "EVENT_DECL",
01953 "GENVAR_DECL",
01954 "LIST",
01955 "RANGE",
01956 "SLICE",
01957 "PSLICE",
01958 "MSLICE",
01959 "CVRI",
01960 "CVIR",
01961 "REP",
01962 "CAT",
01963 "UCAT",
01964 "COM",
01965 "NEG",
01966 "PLUS",
01967 "NOT",
01968 "GT",
01969 "GE",
01970 "LT",
01971 "LE",
01972 "LAND",
01973 "LOR",
01974 "CEQ",
01975 "CNE",
01976 "EQ",
01977 "NE",
01978 "RAND",
01979 "RNAND",
01980 "ROR",
01981 "RNOR",
01982 "RXOR",
01983 "RXNOR",
01984 "HOOK",
01985 "INIT",
01986 "ALWAYS",
01987 "EVENT",
01988 "BLOCK_REF",
01989 "SPECIFY_REF",
01990 "ASSIGN",
01991 "FORCE",
01992 "RELEASE",
01993 "NBASSIGN",
01994 "POSEDGE",
01995 "NEGEDGE",
01996 "EDGE",
01997 "EVOR",
01998 "DELAY",
01999 "MTM",
02000 "IF",
02001 "FOREVER",
02002 "REPEAT",
02003 "WHILE",
02004 "WAIT",
02005 "FOR",
02006 "CASE",
02007 "CASEX",
02008 "CASEZ",
02009 "CASEITEM",
02010 "CASSIGN",
02011 "ARG",
02012 "FUNCTION_DEF",
02013 "MODULE_DEF",
02014 "REPEAT_CONTROL",
02015 "DELAY_CONTROL",
02016 "EVENT_CONTROL",
02017 "EXTERNAL_REF",
02018 "PORT_DEF",
02019 "DEFPARAM",
02020 "PATH",
02021 "PATH_ASSIGN",
02022 "IFNONE_PATH_ASSIGN",
02023 "TRIGGER",
02024 "PASSIGN",
02025 "DEASSIGN",
02026 "DISABLE",
02027 "ATTRIBUTE",
02028 "GIF",
02029 "GFOR",
02030 "GCASE",
02031 "TABLE",
02032 "TABLE_ENTRY",
02033 "TABLE_SYMBOL",
02034 "PORTLIST_END",
02035 "MACRO_EXPR"
02036 };
02037 #endif // DEFINE_METHODS
02038
02039
02040 #ifdef DEFINE_CONSTRUCTOR
02041
02049 inline CNode* cERROR( Coord_t* loc=NULL )
02050 {
02051 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eERROR );
02052 return n;
02053 }
02062 inline CNode* cVCONSTANT( CVector* a0, Coord_t* loc=NULL )
02063 {
02064 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eVCONSTANT );
02065 n->Arg<CVector*>(0) = a0;
02066 return n;
02067 }
02076 inline CNode* cRCONSTANT( char* a0, Coord_t* loc=NULL )
02077 {
02078 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRCONSTANT );
02079 n->Arg<char*>(0) = a0;
02080 return n;
02081 }
02090 inline CNode* cCOMMENT( const char* a0, Coord_t* loc=NULL )
02091 {
02092 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCOMMENT );
02093 n->Arg<const char*>(0) = a0;
02094 return n;
02095 }
02104 inline CNode* cVRQ( const char* a0, Coord_t* loc=NULL )
02105 {
02106 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eVRQ );
02107 n->Arg<const char*>(0) = a0;
02108 return n;
02109 }
02118 inline CNode* cPRAGMA( const char* a0, Coord_t* loc=NULL )
02119 {
02120 CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePRAGMA );
02121 n->Arg<const char*>(0) = a0;
02122 return n;
02123 }
02133 inline CNode* cELIST( CNode* a0, CNode* a1, Coord_t* loc=NULL )
02134 {
02135 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eELIST );
02136 n->Arg<CNode*>(0) = a0;
02137 n->Arg<CNode*>(1) = a1;
02138 return n;
02139 }
02149 inline CNode* cWIDTH( CNode* a0, CNode* a1, Coord_t* loc=NULL )
02150 {
02151 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eWIDTH );
02152 n->Arg<CNode*>(0) = a0;
02153 n->Arg<CNode*>(1) = a1;
02154 return n;
02155 }
02163 inline CNode* cNOP( Coord_t* loc=NULL )
02164 {
02165 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eNOP );
02166 return n;
02167 }
02177 inline CNode* cSUB( CNode* a0, CNode* a1, Coord_t* loc=NULL )
02178 {
02179 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eSUB );
02180 n->Arg<CNode*>(0) = a0;
02181 n->Arg<CNode*>(1) = a1;
02182 return n;
02183 }
02193 inline CNode* cMUL( CNode* a0, CNode* a1, Coord_t* loc=NULL )
02194 {
02195 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eMUL );
02196 n->Arg<CNode*>(0) = a0;
02197 n->Arg<CNode*>(1) = a1;
02198 return n;
02199 }
02209 inline CNode* cDIV( CNode* a0, CNode* a1, Coord_t* loc=NULL )
02210 {
02211 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eDIV );
02212 n->Arg<CNode*>(0) = a0;
02213 n->Arg<CNode*>(1) = a1;
02214 return n;
02215 }
02225 inline CNode* cPOW( CNode* a0, CNode* a1, Coord_t* loc=NULL )
02226 {
02227 CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePOW );
02228 n->Arg<CNode*>(0) = a0;
02229 n->Arg<CNode*>(1) = a1;
02230 return n;
02231 }
02241 inline CNode* cADD( CNode* a0, CNode* a1, Coord_t* loc=NULL )
02242 {
02243 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eADD );
02244 n->Arg<CNode*>(0) = a0;
02245 n->Arg<CNode*>(1) = a1;
02246 return n;
02247 }
02257 inline CNode* cLSH( CNode* a0, CNode* a1, Coord_t* loc=NULL )
02258 {
02259 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eLSH );
02260 n->Arg<CNode*>(0) = a0;
02261 n->Arg<CNode*>(1) = a1;
02262 return n;
02263 }
02273 inline CNode* cRSH( CNode* a0, CNode* a1, Coord_t* loc=NULL )
02274 {
02275 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRSH );
02276 n->Arg<CNode*>(0) = a0;
02277 n->Arg<CNode*>(1) = a1;
02278 return n;
02279 }
02289 inline CNode* cLSHA( CNode* a0, CNode* a1, Coord_t* loc=NULL )
02290 {
02291 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eLSHA );
02292 n->Arg<CNode*>(0) = a0;
02293 n->Arg<CNode*>(1) = a1;
02294 return n;
02295 }
02305 inline CNode* cRSHA( CNode* a0, CNode* a1, Coord_t* loc=NULL )
02306 {
02307 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRSHA );
02308 n->Arg<CNode*>(0) = a0;
02309 n->Arg<CNode*>(1) = a1;
02310 return n;
02311 }
02321 inline CNode* cMOD( CNode* a0, CNode* a1, Coord_t* loc=NULL )
02322 {
02323 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eMOD );
02324 n->Arg<CNode*>(0) = a0;
02325 n->Arg<CNode*>(1) = a1;
02326 return n;
02327 }
02337 inline CNode* cOR( CNode* a0, CNode* a1, Coord_t* loc=NULL )
02338 {
02339 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eOR );
02340 n->Arg<CNode*>(0) = a0;
02341 n->Arg<CNode*>(1) = a1;
02342 return n;
02343 }
02353 inline CNode* cAND( CNode* a0, CNode* a1, Coord_t* loc=NULL )
02354 {
02355 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eAND );
02356 n->Arg<CNode*>(0) = a0;
02357 n->Arg<CNode*>(1) = a1;
02358 return n;
02359 }
02369 inline CNode* cANDANDAND( CNode* a0, CNode* a1, Coord_t* loc=NULL )
02370 {
02371 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eANDANDAND );
02372 n->Arg<CNode*>(0) = a0;
02373 n->Arg<CNode*>(1) = a1;
02374 return n;
02375 }
02385 inline CNode* cXOR( CNode* a0, CNode* a1, Coord_t* loc=NULL )
02386 {
02387 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eXOR );
02388 n->Arg<CNode*>(0) = a0;
02389 n->Arg<CNode*>(1) = a1;
02390 return n;
02391 }
02401 inline CNode* cXNOR( CNode* a0, CNode* a1, Coord_t* loc=NULL )
02402 {
02403 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eXNOR );
02404 n->Arg<CNode*>(0) = a0;
02405 n->Arg<CNode*>(1) = a1;
02406 return n;
02407 }
02416 inline CNode* cINSTANCE_REF( CInstance* a0, Coord_t* loc=NULL )
02417 {
02418 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eINSTANCE_REF );
02419 n->Arg<CInstance*>(0) = a0;
02420 return n;
02421 }
02430 inline CNode* cGATE_REF( CGate* a0, Coord_t* loc=NULL )
02431 {
02432 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eGATE_REF );
02433 n->Arg<CGate*>(0) = a0;
02434 return n;
02435 }
02445 inline CNode* cTASK_ENABLE( CSymbol* a0, CNode* a1, Coord_t* loc=NULL )
02446 {
02447 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eTASK_ENABLE );
02448 n->Arg<CSymbol*>(0) = a0;
02449 n->Arg<CNode*>(1) = a1;
02450 return n;
02451 }
02461 inline CNode* cSYSTASK_CALL( CSymbol* a0, CNode* a1, Coord_t* loc=NULL )
02462 {
02463 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eSYSTASK_CALL );
02464 n->Arg<CSymbol*>(0) = a0;
02465 n->Arg<CNode*>(1) = a1;
02466 return n;
02467 }
02477 inline CNode* cTIMING_CALL( CSymbol* a0, CNode* a1, Coord_t* loc=NULL )
02478 {
02479 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eTIMING_CALL );
02480 n->Arg<CSymbol*>(0) = a0;
02481 n->Arg<CNode*>(1) = a1;
02482 return n;
02483 }
02494 inline CNode* cFUNCTION_CALL( CSymbol* a0, CNode* a1, CScope* a2, Coord_t* loc=NULL )
02495 {
02496 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eFUNCTION_CALL );
02497 n->Arg<CSymbol*>(0) = a0;
02498 n->Arg<CNode*>(1) = a1;
02499 n->Arg<CScope*>(2) = a2;
02500 return n;
02501 }
02511 inline CNode* cARRAY( CNode* a0, CNode* a1, Coord_t* loc=NULL )
02512 {
02513 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eARRAY );
02514 n->Arg<CNode*>(0) = a0;
02515 n->Arg<CNode*>(1) = a1;
02516 return n;
02517 }
02526 inline CNode* cNET_REF( CNet* a0, Coord_t* loc=NULL )
02527 {
02528 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eNET_REF );
02529 n->Arg<CNet*>(0) = a0;
02530 return n;
02531 }
02540 inline CNode* cREG_REF( CReg* a0, Coord_t* loc=NULL )
02541 {
02542 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eREG_REF );
02543 n->Arg<CReg*>(0) = a0;
02544 return n;
02545 }
02554 inline CNode* cREAL_REF( CReal* a0, Coord_t* loc=NULL )
02555 {
02556 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eREAL_REF );
02557 n->Arg<CReal*>(0) = a0;
02558 return n;
02559 }
02568 inline CNode* cPARAM_REF( CParam* a0, Coord_t* loc=NULL )
02569 {
02570 CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePARAM_REF );
02571 n->Arg<CParam*>(0) = a0;
02572 return n;
02573 }
02582 inline CNode* cPORT_REF( CPortDir* a0, Coord_t* loc=NULL )
02583 {
02584 CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePORT_REF );
02585 n->Arg<CPortDir*>(0) = a0;
02586 return n;
02587 }
02596 inline CNode* cFWD_REF( CFref* a0, Coord_t* loc=NULL )
02597 {
02598 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eFWD_REF );
02599 n->Arg<CFref*>(0) = a0;
02600 return n;
02601 }
02610 inline CNode* cEVENT_REF( CEvent* a0, Coord_t* loc=NULL )
02611 {
02612 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eEVENT_REF );
02613 n->Arg<CEvent*>(0) = a0;
02614 return n;
02615 }
02624 inline CNode* cGENVAR_REF( CGenvar* a0, Coord_t* loc=NULL )
02625 {
02626 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eGENVAR_REF );
02627 n->Arg<CGenvar*>(0) = a0;
02628 return n;
02629 }
02639 inline CNode* cNET_DECL( CNet* a0, CNode* a1, Coord_t* loc=NULL )
02640 {
02641 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eNET_DECL );
02642 n->Arg<CNet*>(0) = a0;
02643 n->Arg<CNode*>(1) = a1;
02644 return n;
02645 }
02655 inline CNode* cREG_DECL( CReg* a0, CNode* a1, Coord_t* loc=NULL )
02656 {
02657 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eREG_DECL );
02658 n->Arg<CReg*>(0) = a0;
02659 n->Arg<CNode*>(1) = a1;
02660 return n;
02661 }
02671 inline CNode* cREAL_DECL( CReal* a0, CNode* a1, Coord_t* loc=NULL )
02672 {
02673 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eREAL_DECL );
02674 n->Arg<CReal*>(0) = a0;
02675 n->Arg<CNode*>(1) = a1;
02676 return n;
02677 }
02686 inline CNode* cPARAM_DECL( CParam* a0, Coord_t* loc=NULL )
02687 {
02688 CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePARAM_DECL );
02689 n->Arg<CParam*>(0) = a0;
02690 return n;
02691 }
02700 inline CNode* cSPECPARAM_DECL( CParam* a0, Coord_t* loc=NULL )
02701 {
02702 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eSPECPARAM_DECL );
02703 n->Arg<CParam*>(0) = a0;
02704 return n;
02705 }
02714 inline CNode* cPORT_DECL( CPortDir* a0, Coord_t* loc=NULL )
02715 {
02716 CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePORT_DECL );
02717 n->Arg<CPortDir*>(0) = a0;
02718 return n;
02719 }
02728 inline CNode* cEVENT_DECL( CEvent* a0, Coord_t* loc=NULL )
02729 {
02730 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eEVENT_DECL );
02731 n->Arg<CEvent*>(0) = a0;
02732 return n;
02733 }
02742 inline CNode* cGENVAR_DECL( CGenvar* a0, Coord_t* loc=NULL )
02743 {
02744 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eGENVAR_DECL );
02745 n->Arg<CGenvar*>(0) = a0;
02746 return n;
02747 }
02757 inline CNode* cLIST( CNode* a0, CNode* a1, Coord_t* loc=NULL )
02758 {
02759 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eLIST );
02760 n->Arg<CNode*>(0) = a0;
02761 n->Arg<CNode*>(1) = a1;
02762 return n;
02763 }
02773 inline CNode* cRANGE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
02774 {
02775 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRANGE );
02776 n->Arg<CNode*>(0) = a0;
02777 n->Arg<CNode*>(1) = a1;
02778 return n;
02779 }
02789 inline CNode* cSLICE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
02790 {
02791 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eSLICE );
02792 n->Arg<CNode*>(0) = a0;
02793 n->Arg<CNode*>(1) = a1;
02794 return n;
02795 }
02805 inline CNode* cPSLICE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
02806 {
02807 CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePSLICE );
02808 n->Arg<CNode*>(0) = a0;
02809 n->Arg<CNode*>(1) = a1;
02810 return n;
02811 }
02821 inline CNode* cMSLICE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
02822 {
02823 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eMSLICE );
02824 n->Arg<CNode*>(0) = a0;
02825 n->Arg<CNode*>(1) = a1;
02826 return n;
02827 }
02836 inline CNode* cCVRI( CNode* a0, Coord_t* loc=NULL )
02837 {
02838 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCVRI );
02839 n->Arg<CNode*>(0) = a0;
02840 return n;
02841 }
02850 inline CNode* cCVIR( CNode* a0, Coord_t* loc=NULL )
02851 {
02852 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCVIR );
02853 n->Arg<CNode*>(0) = a0;
02854 return n;
02855 }
02865 inline CNode* cREP( CNode* a0, CNode* a1, Coord_t* loc=NULL )
02866 {
02867 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eREP );
02868 n->Arg<CNode*>(0) = a0;
02869 n->Arg<CNode*>(1) = a1;
02870 return n;
02871 }
02881 inline CNode* cCAT( CNode* a0, CNode* a1, Coord_t* loc=NULL )
02882 {
02883 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCAT );
02884 n->Arg<CNode*>(0) = a0;
02885 n->Arg<CNode*>(1) = a1;
02886 return n;
02887 }
02896 inline CNode* cUCAT( CNode* a0, Coord_t* loc=NULL )
02897 {
02898 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eUCAT );
02899 n->Arg<CNode*>(0) = a0;
02900 return n;
02901 }
02910 inline CNode* cCOM( CNode* a0, Coord_t* loc=NULL )
02911 {
02912 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCOM );
02913 n->Arg<CNode*>(0) = a0;
02914 return n;
02915 }
02924 inline CNode* cNEG( CNode* a0, Coord_t* loc=NULL )
02925 {
02926 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eNEG );
02927 n->Arg<CNode*>(0) = a0;
02928 return n;
02929 }
02938 inline CNode* cPLUS( CNode* a0, Coord_t* loc=NULL )
02939 {
02940 CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePLUS );
02941 n->Arg<CNode*>(0) = a0;
02942 return n;
02943 }
02952 inline CNode* cNOT( CNode* a0, Coord_t* loc=NULL )
02953 {
02954 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eNOT );
02955 n->Arg<CNode*>(0) = a0;
02956 return n;
02957 }
02967 inline CNode* cGT( CNode* a0, CNode* a1, Coord_t* loc=NULL )
02968 {
02969 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eGT );
02970 n->Arg<CNode*>(0) = a0;
02971 n->Arg<CNode*>(1) = a1;
02972 return n;
02973 }
02983 inline CNode* cGE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
02984 {
02985 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eGE );
02986 n->Arg<CNode*>(0) = a0;
02987 n->Arg<CNode*>(1) = a1;
02988 return n;
02989 }
02999 inline CNode* cLT( CNode* a0, CNode* a1, Coord_t* loc=NULL )
03000 {
03001 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eLT );
03002 n->Arg<CNode*>(0) = a0;
03003 n->Arg<CNode*>(1) = a1;
03004 return n;
03005 }
03015 inline CNode* cLE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
03016 {
03017 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eLE );
03018 n->Arg<CNode*>(0) = a0;
03019 n->Arg<CNode*>(1) = a1;
03020 return n;
03021 }
03031 inline CNode* cLAND( CNode* a0, CNode* a1, Coord_t* loc=NULL )
03032 {
03033 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eLAND );
03034 n->Arg<CNode*>(0) = a0;
03035 n->Arg<CNode*>(1) = a1;
03036 return n;
03037 }
03047 inline CNode* cLOR( CNode* a0, CNode* a1, Coord_t* loc=NULL )
03048 {
03049 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eLOR );
03050 n->Arg<CNode*>(0) = a0;
03051 n->Arg<CNode*>(1) = a1;
03052 return n;
03053 }
03063 inline CNode* cCEQ( CNode* a0, CNode* a1, Coord_t* loc=NULL )
03064 {
03065 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCEQ );
03066 n->Arg<CNode*>(0) = a0;
03067 n->Arg<CNode*>(1) = a1;
03068 return n;
03069 }
03079 inline CNode* cCNE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
03080 {
03081 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCNE );
03082 n->Arg<CNode*>(0) = a0;
03083 n->Arg<CNode*>(1) = a1;
03084 return n;
03085 }
03095 inline CNode* cEQ( CNode* a0, CNode* a1, Coord_t* loc=NULL )
03096 {
03097 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eEQ );
03098 n->Arg<CNode*>(0) = a0;
03099 n->Arg<CNode*>(1) = a1;
03100 return n;
03101 }
03111 inline CNode* cNE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
03112 {
03113 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eNE );
03114 n->Arg<CNode*>(0) = a0;
03115 n->Arg<CNode*>(1) = a1;
03116 return n;
03117 }
03126 inline CNode* cRAND( CNode* a0, Coord_t* loc=NULL )
03127 {
03128 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRAND );
03129 n->Arg<CNode*>(0) = a0;
03130 return n;
03131 }
03140 inline CNode* cRNAND( CNode* a0, Coord_t* loc=NULL )
03141 {
03142 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRNAND );
03143 n->Arg<CNode*>(0) = a0;
03144 return n;
03145 }
03154 inline CNode* cROR( CNode* a0, Coord_t* loc=NULL )
03155 {
03156 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eROR );
03157 n->Arg<CNode*>(0) = a0;
03158 return n;
03159 }
03168 inline CNode* cRNOR( CNode* a0, Coord_t* loc=NULL )
03169 {
03170 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRNOR );
03171 n->Arg<CNode*>(0) = a0;
03172 return n;
03173 }
03182 inline CNode* cRXOR( CNode* a0, Coord_t* loc=NULL )
03183 {
03184 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRXOR );
03185 n->Arg<CNode*>(0) = a0;
03186 return n;
03187 }
03196 inline CNode* cRXNOR( CNode* a0, Coord_t* loc=NULL )
03197 {
03198 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRXNOR );
03199 n->Arg<CNode*>(0) = a0;
03200 return n;
03201 }
03212 inline CNode* cHOOK( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
03213 {
03214 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eHOOK );
03215 n->Arg<CNode*>(0) = a0;
03216 n->Arg<CNode*>(1) = a1;
03217 n->Arg<CNode*>(2) = a2;
03218 return n;
03219 }
03228 inline CNode* cINIT( CNode* a0, Coord_t* loc=NULL )
03229 {
03230 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eINIT );
03231 n->Arg<CNode*>(0) = a0;
03232 return n;
03233 }
03242 inline CNode* cALWAYS( CNode* a0, Coord_t* loc=NULL )
03243 {
03244 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eALWAYS );
03245 n->Arg<CNode*>(0) = a0;
03246 return n;
03247 }
03257 inline CNode* cEVENT( CNode* a0, CNode* a1, Coord_t* loc=NULL )
03258 {
03259 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eEVENT );
03260 n->Arg<CNode*>(0) = a0;
03261 n->Arg<CNode*>(1) = a1;
03262 return n;
03263 }
03273 inline CNode* cBLOCK_REF( CBlock* a0, CNode* a1, Coord_t* loc=NULL )
03274 {
03275 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eBLOCK_REF );
03276 n->Arg<CBlock*>(0) = a0;
03277 n->Arg<CNode*>(1) = a1;
03278 return n;
03279 }
03289 inline CNode* cSPECIFY_REF( CSpecify* a0, CNode* a1, Coord_t* loc=NULL )
03290 {
03291 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eSPECIFY_REF );
03292 n->Arg<CSpecify*>(0) = a0;
03293 n->Arg<CNode*>(1) = a1;
03294 return n;
03295 }
03306 inline CNode* cASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
03307 {
03308 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eASSIGN );
03309 n->Arg<CNode*>(0) = a0;
03310 n->Arg<CNode*>(1) = a1;
03311 n->Arg<CNode*>(2) = a2;
03312 return n;
03313 }
03323 inline CNode* cFORCE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
03324 {
03325 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eFORCE );
03326 n->Arg<CNode*>(0) = a0;
03327 n->Arg<CNode*>(1) = a1;
03328 return n;
03329 }
03338 inline CNode* cRELEASE( CNode* a0, Coord_t* loc=NULL )
03339 {
03340 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eRELEASE );
03341 n->Arg<CNode*>(0) = a0;
03342 return n;
03343 }
03354 inline CNode* cNBASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
03355 {
03356 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eNBASSIGN );
03357 n->Arg<CNode*>(0) = a0;
03358 n->Arg<CNode*>(1) = a1;
03359 n->Arg<CNode*>(2) = a2;
03360 return n;
03361 }
03370 inline CNode* cPOSEDGE( CNode* a0, Coord_t* loc=NULL )
03371 {
03372 CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePOSEDGE );
03373 n->Arg<CNode*>(0) = a0;
03374 return n;
03375 }
03384 inline CNode* cNEGEDGE( CNode* a0, Coord_t* loc=NULL )
03385 {
03386 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eNEGEDGE );
03387 n->Arg<CNode*>(0) = a0;
03388 return n;
03389 }
03399 inline CNode* cEDGE( CNode* a0, Edge_t a1, Coord_t* loc=NULL )
03400 {
03401 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eEDGE );
03402 n->Arg<CNode*>(0) = a0;
03403 n->Arg<Edge_t>(1) = a1;
03404 return n;
03405 }
03415 inline CNode* cEVOR( CNode* a0, CNode* a1, Coord_t* loc=NULL )
03416 {
03417 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eEVOR );
03418 n->Arg<CNode*>(0) = a0;
03419 n->Arg<CNode*>(1) = a1;
03420 return n;
03421 }
03431 inline CNode* cDELAY( CNode* a0, CNode* a1, Coord_t* loc=NULL )
03432 {
03433 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eDELAY );
03434 n->Arg<CNode*>(0) = a0;
03435 n->Arg<CNode*>(1) = a1;
03436 return n;
03437 }
03448 inline CNode* cMTM( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
03449 {
03450 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eMTM );
03451 n->Arg<CNode*>(0) = a0;
03452 n->Arg<CNode*>(1) = a1;
03453 n->Arg<CNode*>(2) = a2;
03454 return n;
03455 }
03466 inline CNode* cIF( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
03467 {
03468 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eIF );
03469 n->Arg<CNode*>(0) = a0;
03470 n->Arg<CNode*>(1) = a1;
03471 n->Arg<CNode*>(2) = a2;
03472 return n;
03473 }
03482 inline CNode* cFOREVER( CNode* a0, Coord_t* loc=NULL )
03483 {
03484 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eFOREVER );
03485 n->Arg<CNode*>(0) = a0;
03486 return n;
03487 }
03497 inline CNode* cREPEAT( CNode* a0, CNode* a1, Coord_t* loc=NULL )
03498 {
03499 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eREPEAT );
03500 n->Arg<CNode*>(0) = a0;
03501 n->Arg<CNode*>(1) = a1;
03502 return n;
03503 }
03513 inline CNode* cWHILE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
03514 {
03515 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eWHILE );
03516 n->Arg<CNode*>(0) = a0;
03517 n->Arg<CNode*>(1) = a1;
03518 return n;
03519 }
03529 inline CNode* cWAIT( CNode* a0, CNode* a1, Coord_t* loc=NULL )
03530 {
03531 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eWAIT );
03532 n->Arg<CNode*>(0) = a0;
03533 n->Arg<CNode*>(1) = a1;
03534 return n;
03535 }
03547 inline CNode* cFOR( CNode* a0, CNode* a1, CNode* a2, CNode* a3, Coord_t* loc=NULL )
03548 {
03549 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eFOR );
03550 n->Arg<CNode*>(0) = a0;
03551 n->Arg<CNode*>(1) = a1;
03552 n->Arg<CNode*>(2) = a2;
03553 n->Arg<CNode*>(3) = a3;
03554 return n;
03555 }
03565 inline CNode* cCASE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
03566 {
03567 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCASE );
03568 n->Arg<CNode*>(0) = a0;
03569 n->Arg<CNode*>(1) = a1;
03570 return n;
03571 }
03581 inline CNode* cCASEX( CNode* a0, CNode* a1, Coord_t* loc=NULL )
03582 {
03583 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCASEX );
03584 n->Arg<CNode*>(0) = a0;
03585 n->Arg<CNode*>(1) = a1;
03586 return n;
03587 }
03597 inline CNode* cCASEZ( CNode* a0, CNode* a1, Coord_t* loc=NULL )
03598 {
03599 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCASEZ );
03600 n->Arg<CNode*>(0) = a0;
03601 n->Arg<CNode*>(1) = a1;
03602 return n;
03603 }
03613 inline CNode* cCASEITEM( CNode* a0, CNode* a1, Coord_t* loc=NULL )
03614 {
03615 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCASEITEM );
03616 n->Arg<CNode*>(0) = a0;
03617 n->Arg<CNode*>(1) = a1;
03618 return n;
03619 }
03631 inline CNode* cCASSIGN( StrengthPair_t* a0, CNode* a1, CNode* a2, CNode* a3, Coord_t* loc=NULL )
03632 {
03633 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eCASSIGN );
03634 n->Arg<StrengthPair_t*>(0) = a0;
03635 n->Arg<CNode*>(1) = a1;
03636 n->Arg<CNode*>(2) = a2;
03637 n->Arg<CNode*>(3) = a3;
03638 return n;
03639 }
03649 inline CNode* cARG( CSymbol* a0, CNode* a1, Coord_t* loc=NULL )
03650 {
03651 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eARG );
03652 n->Arg<CSymbol*>(0) = a0;
03653 n->Arg<CNode*>(1) = a1;
03654 return n;
03655 }
03664 inline CNode* cFUNCTION_DEF( CFunction* a0, Coord_t* loc=NULL )
03665 {
03666 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eFUNCTION_DEF );
03667 n->Arg<CFunction*>(0) = a0;
03668 return n;
03669 }
03678 inline CNode* cMODULE_DEF( CModule* a0, Coord_t* loc=NULL )
03679 {
03680 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eMODULE_DEF );
03681 n->Arg<CModule*>(0) = a0;
03682 return n;
03683 }
03693 inline CNode* cREPEAT_CONTROL( CNode* a0, CNode* a1, Coord_t* loc=NULL )
03694 {
03695 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eREPEAT_CONTROL );
03696 n->Arg<CNode*>(0) = a0;
03697 n->Arg<CNode*>(1) = a1;
03698 return n;
03699 }
03708 inline CNode* cDELAY_CONTROL( CNode* a0, Coord_t* loc=NULL )
03709 {
03710 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eDELAY_CONTROL );
03711 n->Arg<CNode*>(0) = a0;
03712 return n;
03713 }
03722 inline CNode* cEVENT_CONTROL( CNode* a0, Coord_t* loc=NULL )
03723 {
03724 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eEVENT_CONTROL );
03725 n->Arg<CNode*>(0) = a0;
03726 return n;
03727 }
03736 inline CNode* cEXTERNAL_REF( CSymbol* a0, Coord_t* loc=NULL )
03737 {
03738 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eEXTERNAL_REF );
03739 n->Arg<CSymbol*>(0) = a0;
03740 return n;
03741 }
03750 inline CNode* cPORT_DEF( CPort* a0, Coord_t* loc=NULL )
03751 {
03752 CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePORT_DEF );
03753 n->Arg<CPort*>(0) = a0;
03754 return n;
03755 }
03765 inline CNode* cDEFPARAM( CNode* a0, CNode* a1, Coord_t* loc=NULL )
03766 {
03767 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eDEFPARAM );
03768 n->Arg<CNode*>(0) = a0;
03769 n->Arg<CNode*>(1) = a1;
03770 return n;
03771 }
03786 inline CNode* cPATH( int a0, CNode* a1, int a2, int a3, CNode* a4, int a5, CNode* a6, Coord_t* loc=NULL )
03787 {
03788 CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePATH );
03789 n->Arg<int>(0) = a0;
03790 n->Arg<CNode*>(1) = a1;
03791 n->Arg<int>(2) = a2;
03792 n->Arg<int>(3) = a3;
03793 n->Arg<CNode*>(4) = a4;
03794 n->Arg<int>(5) = a5;
03795 n->Arg<CNode*>(6) = a6;
03796 return n;
03797 }
03808 inline CNode* cPATH_ASSIGN( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
03809 {
03810 CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePATH_ASSIGN );
03811 n->Arg<CNode*>(0) = a0;
03812 n->Arg<CNode*>(1) = a1;
03813 n->Arg<CNode*>(2) = a2;
03814 return n;
03815 }
03825 inline CNode* cIFNONE_PATH_ASSIGN( CNode* a0, CNode* a1, Coord_t* loc=NULL )
03826 {
03827 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eIFNONE_PATH_ASSIGN );
03828 n->Arg<CNode*>(0) = a0;
03829 n->Arg<CNode*>(1) = a1;
03830 return n;
03831 }
03840 inline CNode* cTRIGGER( CNode* a0, Coord_t* loc=NULL )
03841 {
03842 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eTRIGGER );
03843 n->Arg<CNode*>(0) = a0;
03844 return n;
03845 }
03855 inline CNode* cPASSIGN( CNode* a0, CNode* a1, Coord_t* loc=NULL )
03856 {
03857 CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePASSIGN );
03858 n->Arg<CNode*>(0) = a0;
03859 n->Arg<CNode*>(1) = a1;
03860 return n;
03861 }
03870 inline CNode* cDEASSIGN( CNode* a0, Coord_t* loc=NULL )
03871 {
03872 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eDEASSIGN );
03873 n->Arg<CNode*>(0) = a0;
03874 return n;
03875 }
03884 inline CNode* cDISABLE( CSymbol* a0, Coord_t* loc=NULL )
03885 {
03886 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eDISABLE );
03887 n->Arg<CSymbol*>(0) = a0;
03888 return n;
03889 }
03898 inline CNode* cATTRIBUTE( CAttr* a0, Coord_t* loc=NULL )
03899 {
03900 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eATTRIBUTE );
03901 n->Arg<CAttr*>(0) = a0;
03902 return n;
03903 }
03914 inline CNode* cGIF( CNode* a0, CNode* a1, CNode* a2, Coord_t* loc=NULL )
03915 {
03916 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eGIF );
03917 n->Arg<CNode*>(0) = a0;
03918 n->Arg<CNode*>(1) = a1;
03919 n->Arg<CNode*>(2) = a2;
03920 return n;
03921 }
03933 inline CNode* cGFOR( CNode* a0, CNode* a1, CNode* a2, CNode* a3, Coord_t* loc=NULL )
03934 {
03935 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eGFOR );
03936 n->Arg<CNode*>(0) = a0;
03937 n->Arg<CNode*>(1) = a1;
03938 n->Arg<CNode*>(2) = a2;
03939 n->Arg<CNode*>(3) = a3;
03940 return n;
03941 }
03951 inline CNode* cGCASE( CNode* a0, CNode* a1, Coord_t* loc=NULL )
03952 {
03953 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eGCASE );
03954 n->Arg<CNode*>(0) = a0;
03955 n->Arg<CNode*>(1) = a1;
03956 return n;
03957 }
03966 inline CNode* cTABLE( CNode* a0, Coord_t* loc=NULL )
03967 {
03968 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eTABLE );
03969 n->Arg<CNode*>(0) = a0;
03970 return n;
03971 }
03980 inline CNode* cTABLE_ENTRY( CNode* a0, Coord_t* loc=NULL )
03981 {
03982 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eTABLE_ENTRY );
03983 n->Arg<CNode*>(0) = a0;
03984 return n;
03985 }
03994 inline CNode* cTABLE_SYMBOL( char* a0, Coord_t* loc=NULL )
03995 {
03996 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eTABLE_SYMBOL );
03997 n->Arg<char*>(0) = a0;
03998 return n;
03999 }
04007 inline CNode* cPORTLIST_END( Coord_t* loc=NULL )
04008 {
04009 CNode* n = new(CNode::CurrentHeap()) CNode( loc, ePORTLIST_END );
04010 return n;
04011 }
04021 inline CNode* cMACRO_EXPR( const char* a0, CNode* a1, Coord_t* loc=NULL )
04022 {
04023 CNode* n = new(CNode::CurrentHeap()) CNode( loc, eMACRO_EXPR );
04024 n->Arg<const char*>(0) = a0;
04025 n->Arg<CNode*>(1) = a1;
04026 return n;
04027 }
04028 #endif // DEFINE_CONSTUCTOR
04029
04030
04031
04032
04033
04034
04035
04036
04037
04038 #ifdef DEFINE_METHODS
04039
04040
04041
04042
04043
04044 int CNode::ArgCount()
04045 {
04046 switch( op ) {
04047 case eERROR:
04048 return 0;
04049 case eVCONSTANT:
04050 return 1;
04051 case eRCONSTANT:
04052 return 1;
04053 case eCOMMENT:
04054 return 1;
04055 case eVRQ:
04056 return 1;
04057 case ePRAGMA:
04058 return 1;
04059 case eELIST:
04060 return 2;
04061 case eWIDTH:
04062 return 2;
04063 case eNOP:
04064 return 0;
04065 case eSUB:
04066 return 2;
04067 case eMUL:
04068 return 2;
04069 case eDIV:
04070 return 2;
04071 case ePOW:
04072 return 2;
04073 case eADD:
04074 return 2;
04075 case eLSH:
04076 return 2;
04077 case eRSH:
04078 return 2;
04079 case eLSHA:
04080 return 2;
04081 case eRSHA:
04082 return 2;
04083 case eMOD:
04084 return 2;
04085 case eOR:
04086 return 2;
04087 case eAND:
04088 return 2;
04089 case eANDANDAND:
04090 return 2;
04091 case eXOR:
04092 return 2;
04093 case eXNOR:
04094 return 2;
04095 case eINSTANCE_REF:
04096 return 1;
04097 case eGATE_REF:
04098 return 1;
04099 case eTASK_ENABLE:
04100 return 2;
04101 case eSYSTASK_CALL:
04102 return 2;
04103 case eTIMING_CALL:
04104 return 2;
04105 case eFUNCTION_CALL:
04106 return 3;
04107 case eARRAY:
04108 return 2;
04109 case eNET_REF:
04110 return 1;
04111 case eREG_REF:
04112 return 1;
04113 case eREAL_REF:
04114 return 1;
04115 case ePARAM_REF:
04116 return 1;
04117 case ePORT_REF:
04118 return 1;
04119 case eFWD_REF:
04120 return 1;
04121 case eEVENT_REF:
04122 return 1;
04123 case eGENVAR_REF:
04124 return 1;
04125 case eNET_DECL:
04126 return 2;
04127 case eREG_DECL:
04128 return 2;
04129 case eREAL_DECL:
04130 return 2;
04131 case ePARAM_DECL:
04132 return 1;
04133 case eSPECPARAM_DECL:
04134 return 1;
04135 case ePORT_DECL:
04136 return 1;
04137 case eEVENT_DECL:
04138 return 1;
04139 case eGENVAR_DECL:
04140 return 1;
04141 case eLIST:
04142 return 2;
04143 case eRANGE:
04144 return 2;
04145 case eSLICE:
04146 return 2;
04147 case ePSLICE:
04148 return 2;
04149 case eMSLICE:
04150 return 2;
04151 case eCVRI:
04152 return 1;
04153 case eCVIR:
04154 return 1;
04155 case eREP:
04156 return 2;
04157 case eCAT:
04158 return 2;
04159 case eUCAT:
04160 return 1;
04161 case eCOM:
04162 return 1;
04163 case eNEG:
04164 return 1;
04165 case ePLUS:
04166 return 1;
04167 case eNOT:
04168 return 1;
04169 case eGT:
04170 return 2;
04171 case eGE:
04172 return 2;
04173 case eLT:
04174 return 2;
04175 case eLE:
04176 return 2;
04177 case eLAND:
04178 return 2;
04179 case eLOR:
04180 return 2;
04181 case eCEQ:
04182 return 2;
04183 case eCNE:
04184 return 2;
04185 case eEQ:
04186 return 2;
04187 case eNE:
04188 return 2;
04189 case eRAND:
04190 return 1;
04191 case eRNAND:
04192 return 1;
04193 case eROR:
04194 return 1;
04195 case eRNOR:
04196 return 1;
04197 case eRXOR:
04198 return 1;
04199 case eRXNOR:
04200 return 1;
04201 case eHOOK:
04202 return 3;
04203 case eINIT:
04204 return 1;
04205 case eALWAYS:
04206 return 1;
04207 case eEVENT:
04208 return 2;
04209 case eBLOCK_REF:
04210 return 2;
04211 case eSPECIFY_REF:
04212 return 2;
04213 case eASSIGN:
04214 return 3;
04215 case eFORCE:
04216 return 2;
04217 case eRELEASE:
04218 return 1;
04219 case eNBASSIGN:
04220 return 3;
04221 case ePOSEDGE:
04222 return 1;
04223 case eNEGEDGE:
04224 return 1;
04225 case eEDGE:
04226 return 2;
04227 case eEVOR:
04228 return 2;
04229 case eDELAY:
04230 return 2;
04231 case eMTM:
04232 return 3;
04233 case eIF:
04234 return 3;
04235 case eFOREVER:
04236 return 1;
04237 case eREPEAT:
04238 return 2;
04239 case eWHILE:
04240 return 2;
04241 case eWAIT:
04242 return 2;
04243 case eFOR:
04244 return 4;
04245 case eCASE:
04246 return 2;
04247 case eCASEX:
04248 return 2;
04249 case eCASEZ:
04250 return 2;
04251 case eCASEITEM:
04252 return 2;
04253 case eCASSIGN:
04254 return 4;
04255 case eARG:
04256 return 2;
04257 case eFUNCTION_DEF:
04258 return 1;
04259 case eMODULE_DEF:
04260 return 1;
04261 case eREPEAT_CONTROL:
04262 return 2;
04263 case eDELAY_CONTROL:
04264 return 1;
04265 case eEVENT_CONTROL:
04266 return 1;
04267 case eEXTERNAL_REF:
04268 return 1;
04269 case ePORT_DEF:
04270 return 1;
04271 case eDEFPARAM:
04272 return 2;
04273 case ePATH:
04274 return 7;
04275 case ePATH_ASSIGN:
04276 return 3;
04277 case eIFNONE_PATH_ASSIGN:
04278 return 2;
04279 case eTRIGGER:
04280 return 1;
04281 case ePASSIGN:
04282 return 2;
04283 case eDEASSIGN:
04284 return 1;
04285 case eDISABLE:
04286 return 1;
04287 case eATTRIBUTE:
04288 return 1;
04289 case eGIF:
04290 return 3;
04291 case eGFOR:
04292 return 4;
04293 case eGCASE:
04294 return 2;
04295 case eTABLE:
04296 return 1;
04297 case eTABLE_ENTRY:
04298 return 1;
04299 case eTABLE_SYMBOL:
04300 return 1;
04301 case ePORTLIST_END:
04302 return 0;
04303 case eMACRO_EXPR:
04304 return 2;
04305 default:
04306 MASSERT(FALSE);
04307 }
04308 return 0;
04309 }
04310
04311
04312
04313
04314
04315
04316 int CNode::Precedence()
04317 {
04318 switch( op ) {
04319 case eERROR:
04320 return 13;
04321 case eVCONSTANT:
04322 return 13;
04323 case eRCONSTANT:
04324 return 13;
04325 case eCOMMENT:
04326 return 13;
04327 case eVRQ:
04328 return 13;
04329 case ePRAGMA:
04330 return 13;
04331 case eELIST:
04332 return 13;
04333 case eWIDTH:
04334 return 13;
04335 case eSUB:
04336 return 9;
04337 case eMUL:
04338 return 10;
04339 case eDIV:
04340 return 10;
04341 case ePOW:
04342 return 11;
04343 case eADD:
04344 return 9;
04345 case eLSH:
04346 return 8;
04347 case eRSH:
04348 return 8;
04349 case eLSHA:
04350 return 8;
04351 case eRSHA:
04352 return 8;
04353 case eMOD:
04354 return 10;
04355 case eOR:
04356 return 3;
04357 case eAND:
04358 return 5;
04359 case eANDANDAND:
04360 return 0;
04361 case eXOR:
04362 return 4;
04363 case eXNOR:
04364 return 4;
04365 case eSYSTASK_CALL:
04366 return 13;
04367 case eFUNCTION_CALL:
04368 return 13;
04369 case eARRAY:
04370 return 13;
04371 case eNET_REF:
04372 return 13;
04373 case eREG_REF:
04374 return 13;
04375 case eREAL_REF:
04376 return 13;
04377 case ePARAM_REF:
04378 return 13;
04379 case ePORT_REF:
04380 return 13;
04381 case eFWD_REF:
04382 return 13;
04383 case eGENVAR_REF:
04384 return 13;
04385 case eRANGE:
04386 return 13;
04387 case eSLICE:
04388 return 13;
04389 case ePSLICE:
04390 return 13;
04391 case eMSLICE:
04392 return 13;
04393 case eCVRI:
04394 return 13;
04395 case eCVIR:
04396 return 13;
04397 case eREP:
04398 return 13;
04399 case eCAT:
04400 return 13;
04401 case eUCAT:
04402 return 13;
04403 case eCOM:
04404 return 12;
04405 case eNEG:
04406 return 12;
04407 case ePLUS:
04408 return 12;
04409 case eNOT:
04410 return 12;
04411 case eGT:
04412 return 7;
04413 case eGE:
04414 return 7;
04415 case eLT:
04416 return 7;
04417 case eLE:
04418 return 7;
04419 case eLAND:
04420 return 2;
04421 case eLOR:
04422 return 1;
04423 case eCEQ:
04424 return 6;
04425 case eCNE:
04426 return 6;
04427 case eEQ:
04428 return 6;
04429 case eNE:
04430 return 6;
04431 case eRAND:
04432 return 12;
04433 case eRNAND:
04434 return 12;
04435 case eROR:
04436 return 12;
04437 case eRNOR:
04438 return 12;
04439 case eRXOR:
04440 return 12;
04441 case eRXNOR:
04442 return 12;
04443 case eHOOK:
04444 return 0;
04445 case ePOSEDGE:
04446 return 13;
04447 case eNEGEDGE:
04448 return 13;
04449 case eEDGE:
04450 return 13;
04451 case eEVOR:
04452 return 13;
04453 case eMTM:
04454 return 13;
04455 case eEXTERNAL_REF:
04456 return 13;
04457 case eMACRO_EXPR:
04458 return 13;
04459 default:
04460 MASSERT( FALSE );
04461 return 13;
04462 }
04463 }
04464
04465
04466
04467
04468
04469
04470 int CNode::IsConstant()
04471 {
04472 switch( op ) {
04473 case eERROR:
04474 return FALSE;
04475 case eVCONSTANT:
04476 return TRUE;
04477 case eRCONSTANT:
04478 return TRUE;
04479 case eCOMMENT:
04480 return TRUE;
04481 case eVRQ:
04482 return TRUE;
04483 case ePRAGMA:
04484 return TRUE;
04485 case eELIST:
04486 return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
04487 case eWIDTH:
04488 return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
04489 case eSUB:
04490 return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
04491 case eMUL:
04492 return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
04493 case eDIV:
04494 return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
04495 case ePOW:
04496 return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
04497 case eADD:
04498 return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
04499 case eLSH:
04500 return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
04501 case eRSH:
04502 return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
04503 case eLSHA:
04504 return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
04505 case eRSHA:
04506 return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
04507 case eMOD:
04508 return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
04509 case eOR:
04510 return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
04511 case eAND:
04512 return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
04513 case eANDANDAND:
04514 return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
04515 case eXOR:
04516 return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
04517 case eXNOR:
04518 return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
04519 case eSYSTASK_CALL:
04520 return FALSE;
04521 case eFUNCTION_CALL:
04522 return Arg<CNode*>(1)->IsConstant();
04523 case eARRAY:
04524 return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
04525 case eNET_REF:
04526 return FALSE;
04527 case eREG_REF:
04528 return FALSE;
04529 case eREAL_REF:
04530 return FALSE;
04531 case ePARAM_REF:
04532 return TRUE;
04533 case ePORT_REF:
04534 return FALSE;
04535 case eFWD_REF:
04536 return FALSE;
04537 case eGENVAR_REF:
04538 return TRUE;
04539 case eRANGE:
04540 return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
04541 case eSLICE:
04542 return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
04543 case ePSLICE:
04544 return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
04545 case eMSLICE:
04546 return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
04547 case eCVRI:
04548 return Arg<CNode*>(0)->IsConstant();
04549 case eCVIR:
04550 return Arg<CNode*>(0)->IsConstant();
04551 case eREP:
04552 return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
04553 case eCAT:
04554 return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
04555 case eUCAT:
04556 return Arg<CNode*>(0)->IsConstant();
04557 case eCOM:
04558 return Arg<CNode*>(0)->IsConstant();
04559 case eNEG:
04560 return Arg<CNode*>(0)->IsConstant();
04561 case ePLUS:
04562 return Arg<CNode*>(0)->IsConstant();
04563 case eNOT:
04564 return Arg<CNode*>(0)->IsConstant();
04565 case eGT:
04566 return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
04567 case eGE:
04568 return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
04569 case eLT:
04570 return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
04571 case eLE:
04572 return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
04573 case eLAND:
04574 return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
04575 case eLOR:
04576 return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
04577 case eCEQ:
04578 return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
04579 case eCNE:
04580 return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
04581 case eEQ:
04582 return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
04583 case eNE:
04584 return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
04585 case eRAND:
04586 return Arg<CNode*>(0)->IsConstant();
04587 case eRNAND:
04588 return Arg<CNode*>(0)->IsConstant();
04589 case eROR:
04590 return Arg<CNode*>(0)->IsConstant();
04591 case eRNOR:
04592 return Arg<CNode*>(0)->IsConstant();
04593 case eRXOR:
04594 return Arg<CNode*>(0)->IsConstant();
04595 case eRXNOR:
04596 return Arg<CNode*>(0)->IsConstant();
04597 case eHOOK:
04598 return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant() && Arg<CNode*>(2)->IsConstant();
04599 case eMTM:
04600 return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant() && Arg<CNode*>(2)->IsConstant();
04601 case eEXTERNAL_REF:
04602 return FALSE;
04603 case eMACRO_EXPR:
04604 return TRUE;
04605 default:
04606 MASSERT( FALSE );
04607 }
04608
04609 return TRUE;
04610 }
04611
04612
04613
04614
04615
04616
04617
04618 int CNode::IsVolatile()
04619 {
04620 switch( op ) {
04621 case eERROR:
04622 return TRUE;
04623 case eVCONSTANT:
04624 return FALSE;
04625 case eRCONSTANT:
04626 return FALSE;
04627 case eCOMMENT:
04628 return FALSE;
04629 case eVRQ:
04630 return FALSE;
04631 case ePRAGMA:
04632 return FALSE;
04633 case eELIST:
04634 return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
04635 case eWIDTH:
04636 return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
04637 case eSUB:
04638 return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
04639 case eMUL:
04640 return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
04641 case eDIV:
04642 return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
04643 case ePOW:
04644 return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
04645 case eADD:
04646 return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
04647 case eLSH:
04648 return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
04649 case eRSH:
04650 return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
04651 case eLSHA:
04652 return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
04653 case eRSHA:
04654 return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
04655 case eMOD:
04656 return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
04657 case eOR:
04658 return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
04659 case eAND:
04660 return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
04661 case eANDANDAND:
04662 return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
04663 case eXOR:
04664 return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
04665 case eXNOR:
04666 return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
04667 case eSYSTASK_CALL:
04668 return TRUE;
04669 case eFUNCTION_CALL:
04670 return Arg<CNode*>(1)->IsVolatile();
04671 case eARRAY:
04672 return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
04673 case eNET_REF:
04674 return TRUE;
04675 case eREG_REF:
04676 return TRUE;
04677 case eREAL_REF:
04678 return TRUE;
04679 case ePARAM_REF:
04680 return TRUE;
04681 case ePORT_REF:
04682 return TRUE;
04683 case eFWD_REF:
04684 return TRUE;
04685 case eGENVAR_REF:
04686 return TRUE;
04687 case eRANGE:
04688 return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
04689 case eSLICE:
04690 return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
04691 case ePSLICE:
04692 return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
04693 case eMSLICE:
04694 return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
04695 case eCVRI:
04696 return Arg<CNode*>(0)->IsVolatile();
04697 case eCVIR:
04698 return Arg<CNode*>(0)->IsVolatile();
04699 case eREP:
04700 return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
04701 case eCAT:
04702 return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
04703 case eUCAT:
04704 return Arg<CNode*>(0)->IsVolatile();
04705 case eCOM:
04706 return Arg<CNode*>(0)->IsVolatile();
04707 case eNEG:
04708 return Arg<CNode*>(0)->IsVolatile();
04709 case ePLUS:
04710 return Arg<CNode*>(0)->IsVolatile();
04711 case eNOT:
04712 return Arg<CNode*>(0)->IsVolatile();
04713 case eGT:
04714 return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
04715 case eGE:
04716 return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
04717 case eLT:
04718 return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
04719 case eLE:
04720 return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
04721 case eLAND:
04722 return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
04723 case eLOR:
04724 return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
04725 case eCEQ:
04726 return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
04727 case eCNE:
04728 return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
04729 case eEQ:
04730 return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
04731 case eNE:
04732 return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
04733 case eRAND:
04734 return Arg<CNode*>(0)->IsVolatile();
04735 case eRNAND:
04736 return Arg<CNode*>(0)->IsVolatile();
04737 case eROR:
04738 return Arg<CNode*>(0)->IsVolatile();
04739 case eRNOR:
04740 return Arg<CNode*>(0)->IsVolatile();
04741 case eRXOR:
04742 return Arg<CNode*>(0)->IsVolatile();
04743 case eRXNOR:
04744 return Arg<CNode*>(0)->IsVolatile();
04745 case eHOOK:
04746 return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile() || Arg<CNode*>(2)->IsVolatile();
04747 case eMTM:
04748 return TRUE;
04749 case eEXTERNAL_REF:
04750 return TRUE;
04751 case eMACRO_EXPR:
04752 return Arg<CNode*>(1) ? Arg<CNode*>(1)->IsVolatile() : TRUE;
04753 default:
04754 MASSERT( FALSE );
04755 }
04756
04757 return TRUE;
04758 }
04759
04760
04761
04762
04763
04764
04765
04766 int CNode::IsWidthConstant( )
04767 {
04768 switch( GetOp() ) {
04769 case eERROR:
04770 return TRUE;
04771 case eVCONSTANT:
04772 return Arg<CVector*>(0)->IsWidthConstant();
04773 case eRCONSTANT:
04774 return TRUE;
04775 case eELIST:
04776 return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
04777 case eWIDTH:
04778 return Arg<CNode*>(0)->IsConstant();
04779 case eSUB:
04780 return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
04781 case eMUL:
04782 return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
04783 case eDIV:
04784 return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
04785 case ePOW:
04786 return Arg<CNode*>(0)->IsWidthConstant();
04787 case eADD:
04788 return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
04789 case eLSH:
04790 return Arg<CNode*>(0)->IsWidthConstant();
04791 case eRSH:
04792 return Arg<CNode*>(0)->IsWidthConstant();
04793 case eLSHA:
04794 return Arg<CNode*>(0)->IsWidthConstant();
04795 case eRSHA:
04796 return Arg<CNode*>(0)->IsWidthConstant();
04797 case eMOD:
04798 return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
04799 case eOR:
04800 return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
04801 case eAND:
04802 return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
04803 case eANDANDAND:
04804 return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
04805 case eXOR:
04806 return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
04807 case eXNOR:
04808 return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
04809 case eSYSTASK_CALL:
04810 return Systask::WidthConstant(Arg<CSymbol*>(0),Arg<CNode*>(1));
04811 case eFUNCTION_CALL:
04812 return CFunction::WidthConstant(Arg<CSymbol*>(0),Arg<CNode*>(1),Arg<CScope*>(2));
04813 case eARRAY:
04814 return Array::WidthConstant(Arg<CNode*>(0),Arg<CNode*>(1));
04815 case eNET_REF:
04816 return Arg<CNet*>(0)->IsWidthConstant();
04817 case eREG_REF:
04818 return Arg<CReg*>(0)->IsWidthConstant();
04819 case eREAL_REF:
04820 return Arg<CReal*>(0)->IsWidthConstant();
04821 case ePARAM_REF:
04822 return Arg<CParam*>(0)->IsWidthConstant();
04823 case ePORT_REF:
04824 return Arg<CPortDir*>(0)->IsWidthConstant();
04825 case eFWD_REF:
04826 return Arg<CFref*>(0)->IsWidthConstant();
04827 case eGENVAR_REF:
04828 return Arg<CGenvar*>(0)->IsWidthConstant();
04829 case eRANGE:
04830 return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
04831 case eSLICE:
04832 return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsConstant();
04833 case ePSLICE:
04834 return Arg<CNode*>(1)->IsConstant();
04835 case eMSLICE:
04836 return Arg<CNode*>(1)->IsConstant();
04837 case eCVRI:
04838 return TRUE;
04839 case eCVIR:
04840 return TRUE;
04841 case eREP:
04842 return Arg<CNode*>(0)->IsConstant() && Arg<CNode*>(1)->IsWidthConstant();
04843 case eCAT:
04844 return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant();
04845 case eUCAT:
04846 return Arg<CNode*>(0)->IsWidthConstant();
04847 case eCOM:
04848 return Arg<CNode*>(0)->IsWidthConstant();
04849 case eNEG:
04850 return Arg<CNode*>(0)->IsWidthConstant();
04851 case ePLUS:
04852 return Arg<CNode*>(0)->IsWidthConstant();
04853 case eNOT:
04854 return TRUE;
04855 case eGT:
04856 return TRUE;
04857 case eGE:
04858 return TRUE;
04859 case eLT:
04860 return TRUE;
04861 case eLE:
04862 return TRUE;
04863 case eLAND:
04864 return TRUE;
04865 case eLOR:
04866 return TRUE;
04867 case eCEQ:
04868 return TRUE;
04869 case eCNE:
04870 return TRUE;
04871 case eEQ:
04872 return TRUE;
04873 case eNE:
04874 return TRUE;
04875 case eRAND:
04876 return TRUE;
04877 case eRNAND:
04878 return TRUE;
04879 case eROR:
04880 return TRUE;
04881 case eRNOR:
04882 return TRUE;
04883 case eRXOR:
04884 return TRUE;
04885 case eRXNOR:
04886 return TRUE;
04887 case eHOOK:
04888 return Arg<CNode*>(1)->IsWidthConstant() && Arg<CNode*>(2)->IsWidthConstant();
04889 case eMTM:
04890 return Arg<CNode*>(0)->IsWidthConstant() && Arg<CNode*>(1)->IsWidthConstant() && Arg<CNode*>(2)->IsWidthConstant();
04891 case eEXTERNAL_REF:
04892 return External::WidthConstant(Arg<CSymbol*>(0));
04893 case eATTRIBUTE:
04894 return TRUE;
04895 case eMACRO_EXPR:
04896 return Arg<CNode*>(1)->IsWidthConstant();
04897 default:
04898 MASSERT( FALSE );
04899 return 0;
04900 }
04901 }
04902
04903
04904
04905
04906
04907
04908 int CNode::IsWidthVolatile( )
04909 {
04910 switch( GetOp() ) {
04911 case eERROR:
04912 return FALSE;
04913 case eVCONSTANT:
04914 return Arg<CVector*>(0)->IsWidthVolatile();
04915 case eRCONSTANT:
04916 return FALSE;
04917 case eELIST:
04918 return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
04919 case eWIDTH:
04920 return Arg<CNode*>(0)->IsVolatile();
04921 case eSUB:
04922 return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
04923 case eMUL:
04924 return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
04925 case eDIV:
04926 return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
04927 case ePOW:
04928 return Arg<CNode*>(0)->IsWidthVolatile();
04929 case eADD:
04930 return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
04931 case eLSH:
04932 return Arg<CNode*>(0)->IsWidthVolatile();
04933 case eRSH:
04934 return Arg<CNode*>(0)->IsWidthVolatile();
04935 case eLSHA:
04936 return Arg<CNode*>(0)->IsWidthVolatile();
04937 case eRSHA:
04938 return Arg<CNode*>(0)->IsWidthVolatile();
04939 case eMOD:
04940 return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
04941 case eOR:
04942 return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
04943 case eAND:
04944 return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
04945 case eANDANDAND:
04946 return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
04947 case eXOR:
04948 return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
04949 case eXNOR:
04950 return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
04951 case eSYSTASK_CALL:
04952 return Systask::WidthVolatile(Arg<CSymbol*>(0),Arg<CNode*>(1));
04953 case eFUNCTION_CALL:
04954 return CFunction::WidthVolatile(Arg<CSymbol*>(0),Arg<CNode*>(1),Arg<CScope*>(2));
04955 case eARRAY:
04956 return Array::WidthVolatile(Arg<CNode*>(0),Arg<CNode*>(1));
04957 case eNET_REF:
04958 return Arg<CNet*>(0)->IsWidthVolatile();
04959 case eREG_REF:
04960 return Arg<CReg*>(0)->IsWidthVolatile();
04961 case eREAL_REF:
04962 return Arg<CReal*>(0)->IsWidthVolatile();
04963 case ePARAM_REF:
04964 return Arg<CParam*>(0)->IsWidthVolatile();
04965 case ePORT_REF:
04966 return Arg<CPortDir*>(0)->IsWidthVolatile();
04967 case eFWD_REF:
04968 return Arg<CFref*>(0)->IsWidthVolatile();
04969 case eGENVAR_REF:
04970 return Arg<CGenvar*>(0)->IsWidthVolatile();
04971 case eRANGE:
04972 return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
04973 case eSLICE:
04974 return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
04975 case ePSLICE:
04976 return Arg<CNode*>(1)->IsVolatile();
04977 case eMSLICE:
04978 return Arg<CNode*>(1)->IsVolatile();
04979 case eCVRI:
04980 return FALSE;
04981 case eCVIR:
04982 return FALSE;
04983 case eREP:
04984 return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
04985 case eCAT:
04986 return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
04987 case eUCAT:
04988 return Arg<CNode*>(0)->IsWidthVolatile();
04989 case eCOM:
04990 return Arg<CNode*>(0)->IsWidthVolatile();
04991 case eNEG:
04992 return Arg<CNode*>(0)->IsWidthVolatile();
04993 case ePLUS:
04994 return Arg<CNode*>(0)->IsWidthVolatile();
04995 case eNOT:
04996 return FALSE;
04997 case eGT:
04998 return FALSE;
04999 case eGE:
05000 return FALSE;
05001 case eLT:
05002 return FALSE;
05003 case eLE:
05004 return FALSE;
05005 case eLAND:
05006 return FALSE;
05007 case eLOR:
05008 return FALSE;
05009 case eCEQ:
05010 return FALSE;
05011 case eCNE:
05012 return FALSE;
05013 case eEQ:
05014 return FALSE;
05015 case eNE:
05016 return FALSE;
05017 case eRAND:
05018 return FALSE;
05019 case eRNAND:
05020 return FALSE;
05021 case eROR:
05022 return FALSE;
05023 case eRNOR:
05024 return FALSE;
05025 case eRXOR:
05026 return FALSE;
05027 case eRXNOR:
05028 return FALSE;
05029 case eHOOK:
05030 return Arg<CNode*>(1)->IsWidthVolatile() || Arg<CNode*>(2)->IsWidthVolatile();
05031 case eMTM:
05032 return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile() || Arg<CNode*>(2)->IsWidthVolatile();
05033 case eEXTERNAL_REF:
05034 return External::WidthVolatile(Arg<CSymbol*>(0));
05035 case eATTRIBUTE:
05036 return FALSE;
05037 case eMACRO_EXPR:
05038 return Arg<CNode*>(1)->IsWidthVolatile();
05039 default:
05040 MASSERT( FALSE );
05041 return 0;
05042 }
05043
05044 }
05045
05046
05047
05048
05049
05050
05051
05052 CNode* CNode::GetWidthExp()
05053 {
05054 switch( GetOp() ) {
05055 case eERROR:
05056 return NULL;
05057 case eVCONSTANT:
05058 return Arg<CVector*>(0)->GetWidthExp();
05059 case eRCONSTANT:
05060 return NULL;
05061 case eELIST:
05062 return (Arg<CNode*>(0)->GetWidthExp() && Arg<CNode*>(1)->GetWidthExp()) ? cADD_N(Arg<CNode*>(0)->GetWidthExp(),Arg<CNode*>(1)->GetWidthExp(),NULL) : NULL;
05063 case eWIDTH:
05064 return cINT32(Arg<CNode*>(0)->EvalINT32());
05065 case eSUB:
05066 return (Arg<CNode*>(0)->GetWidthExp() && Arg<CNode*>(1)->GetWidthExp()) ? cMAX_N(Arg<CNode*>(0)->GetWidthExp(),Arg<CNode*>(1)->GetWidthExp(),NULL) : NULL;
05067 case eMUL:
05068 return (Arg<CNode*>(0)->GetWidthExp() && Arg<CNode*>(1)->GetWidthExp()) ? cMAX_N(Arg<CNode*>(0)->GetWidthExp(),Arg<CNode*>(1)->GetWidthExp(),NULL) : NULL;
05069 case eDIV:
05070 return (Arg<CNode*>(0)->GetWidthExp() && Arg<CNode*>(1)->GetWidthExp()) ? cMAX_N(Arg<CNode*>(0)->GetWidthExp(),Arg<CNode*>(1)->GetWidthExp(),NULL) : NULL;
05071 case ePOW:
05072 return Arg<CNode*>(0)->GetWidthExp();
05073 case eADD:
05074 return (Arg<CNode*>(0)->GetWidthExp() && Arg<CNode*>(1)->GetWidthExp()) ? cMAX_N(Arg<CNode*>(0)->GetWidthExp(),Arg<CNode*>(1)->GetWidthExp(),NULL) : NULL;
05075 case eLSH:
05076 return Arg<CNode*>(0)->GetWidthExp();
05077 case eRSH:
05078 return Arg<CNode*>(0)->GetWidthExp();
05079 case eLSHA:
05080 return Arg<CNode*>(0)->GetWidthExp();
05081 case eRSHA:
05082 return Arg<CNode*>(0)->GetWidthExp();
05083 case eMOD:
05084 return (Arg<CNode*>(0)->GetWidthExp() && Arg<CNode*>(1)->GetWidthExp()) ? cMAX_N(Arg<CNode*>(0)->GetWidthExp(),Arg<CNode*>(1)->GetWidthExp(),NULL) : NULL;
05085 case eOR:
05086 return (Arg<CNode*>(0)->GetWidthExp() && Arg<CNode*>(1)->GetWidthExp()) ? cMAX_N(Arg<CNode*>(0)->GetWidthExp(),Arg<CNode*>(1)->GetWidthExp(),NULL) : NULL;
05087 case eAND:
05088 return (Arg<CNode*>(0)->GetWidthExp() && Arg<CNode*>(1)->GetWidthExp()) ? cMAX_N(Arg<CNode*>(0)->GetWidthExp(),Arg<CNode*>(1)->GetWidthExp(),NULL) : NULL;
05089 case eANDANDAND:
05090 return (Arg<CNode*>(0)->GetWidthExp() && Arg<CNode*>(1)->GetWidthExp()) ? cMAX_N(Arg<CNode*>(0)->GetWidthExp(),Arg<CNode*>(1)->GetWidthExp(),NULL) : NULL;
05091 case eXOR:
05092 return (Arg<CNode*>(0)->GetWidthExp() && Arg<CNode*>(1)->GetWidthExp()) ? cMAX_N(Arg<CNode*>(0)->GetWidthExp(),Arg<CNode*>(1)->GetWidthExp(),NULL) : NULL;
05093 case eXNOR:
05094 return (Arg<CNode*>(0)->GetWidthExp() && Arg<CNode*>(1)->GetWidthExp()) ? cMAX_N(Arg<CNode*>(0)->GetWidthExp(),Arg<CNode*>(1)->GetWidthExp(),NULL) : NULL;
05095 case eSYSTASK_CALL:
05096 return Systask::WidthExp(Arg<CSymbol*>(0),Arg<CNode*>(1));
05097 case eFUNCTION_CALL:
05098 return CFunction::WidthExp(Arg<CSymbol*>(0),Arg<CNode*>(1),Arg<CScope*>(2));
05099 case eARRAY:
05100 return Array::WidthExp(Arg<CNode*>(0),Arg<CNode*>(1));
05101 case eNET_REF:
05102 return Arg<CNet*>(0)->GetWidthExp();
05103 case eREG_REF:
05104 return Arg<CReg*>(0)->GetWidthExp();
05105 case eREAL_REF:
05106 return Arg<CReal*>(0)->GetWidthExp();
05107 case ePARAM_REF:
05108 return Arg<CParam*>(0)->GetWidthExp();
05109 case ePORT_REF:
05110 return Arg<CPortDir*>(0)->GetWidthExp();
05111 case eFWD_REF:
05112 return Arg<CFref*>(0)->GetWidthExp();
05113 case eGENVAR_REF:
05114 return Arg<CGenvar*>(0)->GetWidthExp();
05115 case eRANGE:
05116 return (1 && 1) ? cABSDIFFPLUS1_N(Arg<CNode*>(0)->Clone(),Arg<CNode*>(1)->Clone(),NULL) : NULL;
05117 case eSLICE:
05118 return (1 && 1) ? cABSDIFFPLUS1_N(Arg<CNode*>(0)->Clone(),Arg<CNode*>(1)->Clone(),NULL) : NULL;
05119 case ePSLICE:
05120 return cINT32(Arg<CNode*>(1)->EvalINT32());
05121 case eMSLICE:
05122 return cINT32(Arg<CNode*>(1)->EvalINT32());
05123 case eCVRI:
05124 return cINT32(32);
05125 case eCVIR:
05126 return NULL;
05127 case eREP:
05128 return (1 && Arg<CNode*>(1)->GetWidthExp()) ? cMUL_N(Arg<CNode*>(0)->Clone(),Arg<CNode*>(1)->GetWidthExp(),NULL) : NULL;
05129 case eCAT:
05130 return (Arg<CNode*>(0)->GetWidthExp() && Arg<CNode*>(1)->GetWidthExp()) ? cADD_N(Arg<CNode*>(0)->GetWidthExp(),Arg<CNode*>(1)->GetWidthExp(),NULL) : NULL;
05131 case eUCAT:
05132 return Arg<CNode*>(0)->GetWidthExp();
05133 case eCOM:
05134 return Arg<CNode*>(0)->GetWidthExp();
05135 case eNEG:
05136 return Arg<CNode*>(0)->GetWidthExp();
05137 case ePLUS:
05138 return Arg<CNode*>(0)->GetWidthExp();
05139 case eNOT:
05140 return cINT32(1);
05141 case eGT:
05142 return cINT32(1);
05143 case eGE:
05144 return cINT32(1);
05145 case eLT:
05146 return cINT32(1);
05147 case eLE:
05148 return cINT32(1);
05149 case eLAND:
05150 return cINT32(1);
05151 case eLOR:
05152 return cINT32(1);
05153 case eCEQ:
05154 return cINT32(1);
05155 case eCNE:
05156 return cINT32(1);
05157 case eEQ:
05158 return cINT32(1);
05159 case eNE:
05160 return cINT32(1);
05161 case eRAND:
05162 return cINT32(1);
05163 case eRNAND:
05164 return cINT32(1);
05165 case eROR:
05166 return cINT32(1);
05167 case eRNOR:
05168 return cINT32(1);
05169 case eRXOR:
05170 return cINT32(1);
05171 case eRXNOR:
05172 return cINT32(1);
05173 case eHOOK:
05174 return (Arg<CNode*>(1)->GetWidthExp() && Arg<CNode*>(2)->GetWidthExp()) ? cMAX_N(Arg<CNode*>(1)->GetWidthExp(),Arg<CNode*>(2)->GetWidthExp(),NULL) : NULL;
05175 case eMTM:
05176 return (Arg<CNode*>(0)->GetWidthExp() && Arg<CNode*>(1)->GetWidthExp() && Arg<CNode*>(2)->GetWidthExp()) ? cMAX_N(Arg<CNode*>(0)->GetWidthExp(),Arg<CNode*>(1)->GetWidthExp(),Arg<CNode*>(2)->GetWidthExp(),NULL) : NULL;
05177 case eEXTERNAL_REF:
05178 return External::WidthExp(Arg<CSymbol*>(0));
05179 case eATTRIBUTE:
05180 return cINT32(0);
05181 case eMACRO_EXPR:
05182 return Arg<CNode*>(1)->GetWidthExp();
05183 default:
05184 MASSERT( FALSE );
05185 return NULL;
05186 }
05187 }
05188
05189
05190
05191
05192
05193
05194 int CNode::IsWidthEvaluateable( )
05195 {
05196 switch( GetOp() ) {
05197 case eERROR:
05198 return FALSE;
05199 case eVCONSTANT:
05200 return Arg<CVector*>(0)->IsWidthEvaluateable();
05201 case eRCONSTANT:
05202 return FALSE;
05203 case eELIST:
05204 return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
05205 case eWIDTH:
05206 return Arg<CNode*>(0)->IsEvaluateable();
05207 case eSUB:
05208 return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
05209 case eMUL:
05210 return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
05211 case eDIV:
05212 return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
05213 case ePOW:
05214 return Arg<CNode*>(0)->IsWidthEvaluateable();
05215 case eADD:
05216 return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
05217 case eLSH:
05218 return Arg<CNode*>(0)->IsWidthEvaluateable();
05219 case eRSH:
05220 return Arg<CNode*>(0)->IsWidthEvaluateable();
05221 case eLSHA:
05222 return Arg<CNode*>(0)->IsWidthEvaluateable();
05223 case eRSHA:
05224 return Arg<CNode*>(0)->IsWidthEvaluateable();
05225 case eMOD:
05226 return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
05227 case eOR:
05228 return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
05229 case eAND:
05230 return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
05231 case eANDANDAND:
05232 return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
05233 case eXOR:
05234 return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
05235 case eXNOR:
05236 return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
05237 case eSYSTASK_CALL:
05238 return Systask::WidthEvaluateable(Arg<CSymbol*>(0),Arg<CNode*>(1));
05239 case eFUNCTION_CALL:
05240 return CFunction::WidthEvaluateable(Arg<CSymbol*>(0),Arg<CNode*>(1),Arg<CScope*>(2));
05241 case eARRAY:
05242 return Array::WidthEvaluateable(Arg<CNode*>(0),Arg<CNode*>(1));
05243 case eNET_REF:
05244 return Arg<CNet*>(0)->IsWidthEvaluateable();
05245 case eREG_REF:
05246 return Arg<CReg*>(0)->IsWidthEvaluateable();
05247 case eREAL_REF:
05248 return Arg<CReal*>(0)->IsWidthEvaluateable();
05249 case ePARAM_REF:
05250 return Arg<CParam*>(0)->IsWidthEvaluateable();
05251 case ePORT_REF:
05252 return Arg<CPortDir*>(0)->IsWidthEvaluateable();
05253 case eFWD_REF:
05254 return Arg<CFref*>(0)->IsWidthEvaluateable();
05255 case eGENVAR_REF:
05256 return Arg<CGenvar*>(0)->IsWidthEvaluateable();
05257 case eRANGE:
05258 return Arg<CNode*>(0)->IsEvaluateable() && Arg<CNode*>(1)->IsEvaluateable();
05259 case eSLICE:
05260 return Arg<CNode*>(0)->IsEvaluateable() && Arg<CNode*>(1)->IsEvaluateable();
05261 case ePSLICE:
05262 return Arg<CNode*>(1)->IsEvaluateable();
05263 case eMSLICE:
05264 return Arg<CNode*>(1)->IsEvaluateable();
05265 case eCVRI:
05266 return TRUE;
05267 case eCVIR:
05268 return FALSE;
05269 case eREP:
05270 return Arg<CNode*>(0)->IsEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
05271 case eCAT:
05272 return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
05273 case eUCAT:
05274 return Arg<CNode*>(0)->IsWidthEvaluateable();
05275 case eCOM:
05276 return Arg<CNode*>(0)->IsWidthEvaluateable();
05277 case eNEG:
05278 return Arg<CNode*>(0)->IsWidthEvaluateable();
05279 case ePLUS:
05280 return Arg<CNode*>(0)->IsWidthEvaluateable();
05281 case eNOT:
05282 return TRUE;
05283 case eGT:
05284 return TRUE;
05285 case eGE:
05286 return TRUE;
05287 case eLT:
05288 return TRUE;
05289 case eLE:
05290 return TRUE;
05291 case eLAND:
05292 return TRUE;
05293 case eLOR:
05294 return TRUE;
05295 case eCEQ:
05296 return TRUE;
05297 case eCNE:
05298 return TRUE;
05299 case eEQ:
05300 return TRUE;
05301 case eNE:
05302 return TRUE;
05303 case eRAND:
05304 return TRUE;
05305 case eRNAND:
05306 return TRUE;
05307 case eROR:
05308 return TRUE;
05309 case eRNOR:
05310 return TRUE;
05311 case eRXOR:
05312 return TRUE;
05313 case eRXNOR:
05314 return TRUE;
05315 case eHOOK:
05316 return Arg<CNode*>(1)->IsWidthEvaluateable() && Arg<CNode*>(2)->IsWidthEvaluateable();
05317 case eMTM:
05318 return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable() && Arg<CNode*>(2)->IsWidthEvaluateable();
05319 case eEXTERNAL_REF:
05320 return External::WidthEvaluateable(Arg<CSymbol*>(0));
05321 case eATTRIBUTE:
05322 return TRUE;
05323 case eMACRO_EXPR:
05324 return Arg<CNode*>(1)->IsWidthEvaluateable();
05325 default:
05326 MASSERT( FALSE );
05327 return 0;
05328 }
05329 }
05330
05331
05332
05333
05334
05335
05336
05337
05338 int CNode::IsNonX( int integerIsNonX, char* exclude )
05339 {
05340 switch( GetOp() ) {
05341 case eERROR:
05342 return FALSE;
05343 case eVCONSTANT:
05344 return !Arg<CVector*>(0)->HasXZ();
05345 case eRCONSTANT:
05346 return TRUE;
05347 case eELIST:
05348 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05349 case eWIDTH:
05350 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05351 case eSUB:
05352 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05353 case eMUL:
05354 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05355 case eDIV:
05356 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05357 case ePOW:
05358 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05359 case eADD:
05360 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05361 case eLSH:
05362 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05363 case eRSH:
05364 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05365 case eLSHA:
05366 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05367 case eRSHA:
05368 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05369 case eMOD:
05370 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05371 case eOR:
05372 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05373 case eAND:
05374 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05375 case eANDANDAND:
05376 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05377 case eXOR:
05378 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05379 case eXNOR:
05380 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05381 case eSYSTASK_CALL:
05382 return FALSE;
05383 case eFUNCTION_CALL:
05384 return FALSE;
05385 case eARRAY:
05386 return FALSE;
05387 case eNET_REF:
05388 return Arg<CDecl*>(0)->HasAttribute( exclude ) ||
05389
05390 (integerIsNonX && Arg<CDecl*>(0)->GetType() == eINT);
05391 case eREG_REF:
05392 return Arg<CDecl*>(0)->HasAttribute( exclude ) ||
05393
05394 (integerIsNonX && Arg<CDecl*>(0)->GetType() == eINT);
05395 case eREAL_REF:
05396 return TRUE;
05397 case ePARAM_REF:
05398 return TRUE;
05399 case ePORT_REF:
05400 return Arg<CDecl*>(0)->HasAttribute( exclude ) ||
05401
05402 (integerIsNonX && Arg<CDecl*>(0)->GetType() == eINT);
05403 case eFWD_REF:
05404 return FALSE;
05405 case eEVENT_REF:
05406 return TRUE;
05407 case eGENVAR_REF:
05408 return TRUE;
05409 case eRANGE:
05410 return FALSE;
05411 case eSLICE:
05412 return FALSE;
05413 case ePSLICE:
05414 return FALSE;
05415 case eMSLICE:
05416 return FALSE;
05417 case eCVRI:
05418 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
05419 case eCVIR:
05420 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
05421 case eREP:
05422 return Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05423 case eCAT:
05424 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05425 case eUCAT:
05426 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
05427 case eCOM:
05428 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
05429 case eNEG:
05430 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
05431 case ePLUS:
05432 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
05433 case eNOT:
05434 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
05435 case eGT:
05436 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05437 case eGE:
05438 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05439 case eLT:
05440 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05441 case eLE:
05442 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05443 case eLAND:
05444 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05445 case eLOR:
05446 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05447 case eCEQ:
05448 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05449 case eCNE:
05450 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05451 case eEQ:
05452 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05453 case eNE:
05454 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05455 case eRAND:
05456 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
05457 case eRNAND:
05458 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
05459 case eROR:
05460 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
05461 case eRNOR:
05462 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
05463 case eRXOR:
05464 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
05465 case eRXNOR:
05466 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
05467 case eHOOK:
05468 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(2)->IsNonX( integerIsNonX, exclude );
05469 case ePOSEDGE:
05470 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
05471 case eNEGEDGE:
05472 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
05473 case eEVOR:
05474 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05475 case eMTM:
05476 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(2)->IsNonX( integerIsNonX, exclude );
05477 case eEXTERNAL_REF:
05478 return FALSE;
05479 case eMACRO_EXPR:
05480 return Arg<CNode*>(1) ? Arg<CNode*>(1)->IsNonX(integerIsNonX, exclude) : FALSE;
05481 default:
05482 MASSERT( FALSE );
05483 return 0;
05484 }
05485 }
05486
05487
05488
05489
05490
05491
05492
05493 CNode* CNode::Clone()
05494 {
05495 int nodeMask = 0;
05496 switch( GetOp() ) {
05497 case eERROR:
05498 nodeMask = 0;
05499 break;
05500 case eVCONSTANT:
05501 nodeMask = 0;
05502 break;
05503 case eRCONSTANT:
05504 nodeMask = 0;
05505 break;
05506 case eCOMMENT:
05507 nodeMask = 0;
05508 break;
05509 case eVRQ:
05510 nodeMask = 0;
05511 break;
05512 case ePRAGMA:
05513 nodeMask = 0;
05514 break;
05515 case eELIST:
05516 nodeMask = 3;
05517 break;
05518 case eWIDTH:
05519 nodeMask = 3;
05520 break;
05521 case eNOP:
05522 nodeMask = 0;
05523 break;
05524 case eSUB:
05525 nodeMask = 3;
05526 break;
05527 case eMUL:
05528 nodeMask = 3;
05529 break;
05530 case eDIV:
05531 nodeMask = 3;
05532 break;
05533 case ePOW:
05534 nodeMask = 3;
05535 break;
05536 case eADD:
05537 nodeMask = 3;
05538 break;
05539 case eLSH:
05540 nodeMask = 3;
05541 break;
05542 case eRSH:
05543 nodeMask = 3;
05544 break;
05545 case eLSHA:
05546 nodeMask = 3;
05547 break;
05548 case eRSHA:
05549 nodeMask = 3;
05550 break;
05551 case eMOD:
05552 nodeMask = 3;
05553 break;
05554 case eOR:
05555 nodeMask = 3;
05556 break;
05557 case eAND:
05558 nodeMask = 3;
05559 break;
05560 case eANDANDAND:
05561 nodeMask = 3;
05562 break;
05563 case eXOR:
05564 nodeMask = 3;
05565 break;
05566 case eXNOR:
05567 nodeMask = 3;
05568 break;
05569 case eINSTANCE_REF:
05570 nodeMask = 0;
05571 break;
05572 case eGATE_REF:
05573 nodeMask = 0;
05574 break;
05575 case eTASK_ENABLE:
05576 nodeMask = 2;
05577 break;
05578 case eSYSTASK_CALL:
05579 nodeMask = 2;
05580 break;
05581 case eTIMING_CALL:
05582 nodeMask = 2;
05583 break;
05584 case eFUNCTION_CALL:
05585 nodeMask = 2;
05586 break;
05587 case eARRAY:
05588 nodeMask = 3;
05589 break;
05590 case eNET_REF:
05591 nodeMask = 0;
05592 break;
05593 case eREG_REF:
05594 nodeMask = 0;
05595 break;
05596 case eREAL_REF:
05597 nodeMask = 0;
05598 break;
05599 case ePARAM_REF:
05600 nodeMask = 0;
05601 break;
05602 case ePORT_REF:
05603 nodeMask = 0;
05604 break;
05605 case eFWD_REF:
05606 nodeMask = 0;
05607 break;
05608 case eEVENT_REF:
05609 nodeMask = 0;
05610 break;
05611 case eGENVAR_REF:
05612 nodeMask = 0;
05613 break;
05614 case eNET_DECL:
05615 nodeMask = 2;
05616 break;
05617 case eREG_DECL:
05618 nodeMask = 2;
05619 break;
05620 case eREAL_DECL:
05621 nodeMask = 2;
05622 break;
05623 case ePARAM_DECL:
05624 nodeMask = 0;
05625 break;
05626 case eSPECPARAM_DECL:
05627 nodeMask = 0;
05628 break;
05629 case ePORT_DECL:
05630 nodeMask = 0;
05631 break;
05632 case eEVENT_DECL:
05633 nodeMask = 0;
05634 break;
05635 case eGENVAR_DECL:
05636 nodeMask = 0;
05637 break;
05638 case eLIST:
05639 nodeMask = 3;
05640 break;
05641 case eRANGE:
05642 nodeMask = 3;
05643 break;
05644 case eSLICE:
05645 nodeMask = 3;
05646 break;
05647 case ePSLICE:
05648 nodeMask = 3;
05649 break;
05650 case eMSLICE:
05651 nodeMask = 3;
05652 break;
05653 case eCVRI:
05654 nodeMask = 1;
05655 break;
05656 case eCVIR:
05657 nodeMask = 1;
05658 break;
05659 case eREP:
05660 nodeMask = 3;
05661 break;
05662 case eCAT:
05663 nodeMask = 3;
05664 break;
05665 case eUCAT:
05666 nodeMask = 1;
05667 break;
05668 case eCOM:
05669 nodeMask = 1;
05670 break;
05671 case eNEG:
05672 nodeMask = 1;
05673 break;
05674 case ePLUS:
05675 nodeMask = 1;
05676 break;
05677 case eNOT:
05678 nodeMask = 1;
05679 break;
05680 case eGT:
05681 nodeMask = 3;
05682 break;
05683 case eGE:
05684 nodeMask = 3;
05685 break;
05686 case eLT:
05687 nodeMask = 3;
05688 break;
05689 case eLE:
05690 nodeMask = 3;
05691 break;
05692 case eLAND:
05693 nodeMask = 3;
05694 break;
05695 case eLOR:
05696 nodeMask = 3;
05697 break;
05698 case eCEQ:
05699 nodeMask = 3;
05700 break;
05701 case eCNE:
05702 nodeMask = 3;
05703 break;
05704 case eEQ:
05705 nodeMask = 3;
05706 break;
05707 case eNE:
05708 nodeMask = 3;
05709 break;
05710 case eRAND:
05711 nodeMask = 1;
05712 break;
05713 case eRNAND:
05714 nodeMask = 1;
05715 break;
05716 case eROR:
05717 nodeMask = 1;
05718 break;
05719 case eRNOR:
05720 nodeMask = 1;
05721 break;
05722 case eRXOR:
05723 nodeMask = 1;
05724 break;
05725 case eRXNOR:
05726 nodeMask = 1;
05727 break;
05728 case eHOOK:
05729 nodeMask = 7;
05730 break;
05731 case eINIT:
05732 nodeMask = 1;
05733 break;
05734 case eALWAYS:
05735 nodeMask = 1;
05736 break;
05737 case eEVENT:
05738 nodeMask = 3;
05739 break;
05740 case eBLOCK_REF:
05741 nodeMask = 2;
05742 break;
05743 case eSPECIFY_REF:
05744 nodeMask = 2;
05745 break;
05746 case eASSIGN:
05747 nodeMask = 7;
05748 break;
05749 case eFORCE:
05750 nodeMask = 3;
05751 break;
05752 case eRELEASE:
05753 nodeMask = 1;
05754 break;
05755 case eNBASSIGN:
05756 nodeMask = 7;
05757 break;
05758 case ePOSEDGE:
05759 nodeMask = 1;
05760 break;
05761 case eNEGEDGE:
05762 nodeMask = 1;
05763 break;
05764 case eEDGE:
05765 nodeMask = 1;
05766 break;
05767 case eEVOR:
05768 nodeMask = 3;
05769 break;
05770 case eDELAY:
05771 nodeMask = 3;
05772 break;
05773 case eMTM:
05774 nodeMask = 7;
05775 break;
05776 case eIF:
05777 nodeMask = 7;
05778 break;
05779 case eFOREVER:
05780 nodeMask = 1;
05781 break;
05782 case eREPEAT:
05783 nodeMask = 3;
05784 break;
05785 case eWHILE:
05786 nodeMask = 3;
05787 break;
05788 case eWAIT:
05789 nodeMask = 3;
05790 break;
05791 case eFOR:
05792 nodeMask = 15;
05793 break;
05794 case eCASE:
05795 nodeMask = 3;
05796 break;
05797 case eCASEX:
05798 nodeMask = 3;
05799 break;
05800 case eCASEZ:
05801 nodeMask = 3;
05802 break;
05803 case eCASEITEM:
05804 nodeMask = 3;
05805 break;
05806 case eCASSIGN:
05807 nodeMask = 14;
05808 break;
05809 case eARG:
05810 nodeMask = 2;
05811 break;
05812 case eFUNCTION_DEF:
05813 nodeMask = 0;
05814 break;
05815 case eMODULE_DEF:
05816 nodeMask = 0;
05817 break;
05818 case eREPEAT_CONTROL:
05819 nodeMask = 3;
05820 break;
05821 case eDELAY_CONTROL:
05822 nodeMask = 1;
05823 break;
05824 case eEVENT_CONTROL:
05825 nodeMask = 1;
05826 break;
05827 case eEXTERNAL_REF:
05828 nodeMask = 0;
05829 break;
05830 case ePORT_DEF:
05831 nodeMask = 0;
05832 break;
05833 case eDEFPARAM:
05834 nodeMask = 3;
05835 break;
05836 case ePATH:
05837 nodeMask = 82;
05838 break;
05839 case ePATH_ASSIGN:
05840 nodeMask = 7;
05841 break;
05842 case eIFNONE_PATH_ASSIGN:
05843 nodeMask = 3;
05844 break;
05845 case eTRIGGER:
05846 nodeMask = 1;
05847 break;
05848 case ePASSIGN:
05849 nodeMask = 3;
05850 break;
05851 case eDEASSIGN:
05852 nodeMask = 1;
05853 break;
05854 case eDISABLE:
05855 nodeMask = 0;
05856 break;
05857 case eATTRIBUTE:
05858 nodeMask = 0;
05859 break;
05860 case eGIF:
05861 nodeMask = 7;
05862 break;
05863 case eGFOR:
05864 nodeMask = 15;
05865 break;
05866 case eGCASE:
05867 nodeMask = 3;
05868 break;
05869 case eTABLE:
05870 nodeMask = 1;
05871 break;
05872 case eTABLE_ENTRY:
05873 nodeMask = 1;
05874 break;
05875 case eTABLE_SYMBOL:
05876 nodeMask = 0;
05877 break;
05878 case ePORTLIST_END:
05879 nodeMask = 0;
05880 break;
05881 case eMACRO_EXPR:
05882 nodeMask = 2;
05883 break;
05884 default:
05885 MASSERT( FALSE );
05886 }
05887
05888 CNode* n = new(stack) CNode( &loc, op );
05889 n->width = width;
05890 n->type = type;
05891 n->fixedWidth = fixedWidth;
05892 if( attributes ) {
05893 n->attributes = attributes->Clone();;
05894 }
05895 for( int i = 0; i < ArgCount(); i++ ) {
05896 if( ((nodeMask>>i)&1) && Arg<CNode*>(i) ) {
05897 n->Arg<CNode*>(i) = Arg<CNode*>(i)->Clone();
05898 } else {
05899 void* tmp = Arg<void*>(i);
05900 n->Arg<void*>(i) = tmp;
05901 }
05902 }
05903 return n;
05904 }
05905
05906
05907
05908
05909
05910
05911
05912
05913
05914 void CNode::PreVisit1( int (*func)(CNode*, void*), void* data )
05915 {
05916 if( !(*func)( this, data ) ) {
05917 return;
05918 }
05919
05920 if( GetAttributes() ) {
05921 GetAttributes()->PreVisit1( func, data );
05922 }
05923
05924 int nodeMask = 0;
05925 switch( GetOp() ) {
05926 case eERROR:
05927 nodeMask = 0;
05928 break;
05929 case eVCONSTANT:
05930 nodeMask = 1;
05931 break;
05932 case eRCONSTANT:
05933 nodeMask = 1;
05934 break;
05935 case eCOMMENT:
05936 nodeMask = 1;
05937 break;
05938 case eVRQ:
05939 nodeMask = 1;
05940 break;
05941 case ePRAGMA:
05942 nodeMask = 1;
05943 break;
05944 case eELIST:
05945 nodeMask = 0;
05946 break;
05947 case eWIDTH:
05948 nodeMask = 0;
05949 break;
05950 case eNOP:
05951 nodeMask = 0;
05952 break;
05953 case eSUB:
05954 nodeMask = 0;
05955 break;
05956 case eMUL:
05957 nodeMask = 0;
05958 break;
05959 case eDIV:
05960 nodeMask = 0;
05961 break;
05962 case ePOW:
05963 nodeMask = 0;
05964 break;
05965 case eADD:
05966 nodeMask = 0;
05967 break;
05968 case eLSH:
05969 nodeMask = 0;
05970 break;
05971 case eRSH:
05972 nodeMask = 0;
05973 break;
05974 case eLSHA:
05975 nodeMask = 0;
05976 break;
05977 case eRSHA:
05978 nodeMask = 0;
05979 break;
05980 case eMOD:
05981 nodeMask = 0;
05982 break;
05983 case eOR:
05984 nodeMask = 0;
05985 break;
05986 case eAND:
05987 nodeMask = 0;
05988 break;
05989 case eANDANDAND:
05990 nodeMask = 0;
05991 break;
05992 case eXOR:
05993 nodeMask = 0;
05994 break;
05995 case eXNOR:
05996 nodeMask = 0;
05997 break;
05998 case eINSTANCE_REF:
05999 nodeMask = 1;
06000 if(Arg<CInstance*>(0)) Arg<CInstance*>(0)->PreVisit1( func, data );
06001 break;
06002 case eGATE_REF:
06003 nodeMask = 1;
06004 if(Arg<CGate*>(0)) Arg<CGate*>(0)->PreVisit1( func, data );
06005 break;
06006 case eTASK_ENABLE:
06007 nodeMask = 1;
06008 break;
06009 case eSYSTASK_CALL:
06010 nodeMask = 1;
06011 break;
06012 case eTIMING_CALL:
06013 nodeMask = 1;
06014 break;
06015 case eFUNCTION_CALL:
06016 nodeMask = 5;
06017 break;
06018 case eARRAY:
06019 nodeMask = 0;
06020 break;
06021 case eNET_REF:
06022 return;
06023 case eREG_REF:
06024 return;
06025 case eREAL_REF:
06026 return;
06027 case ePARAM_REF:
06028 return;
06029 case ePORT_REF:
06030 return;
06031 case eFWD_REF:
06032 return;
06033 case eEVENT_REF:
06034 return;
06035 case eGENVAR_REF:
06036 return;
06037 case eNET_DECL:
06038 nodeMask = 1;
06039 if(Arg<CNet*>(0)) Arg<CNet*>(0)->PreVisit1( func, data );
06040 break;
06041 case eREG_DECL:
06042 nodeMask = 1;
06043 if(Arg<CReg*>(0)) Arg<CReg*>(0)->PreVisit1( func, data );
06044 break;
06045 case eREAL_DECL:
06046 nodeMask = 1;
06047 if(Arg<CReal*>(0)) Arg<CReal*>(0)->PreVisit1( func, data );
06048 break;
06049 case ePARAM_DECL:
06050 nodeMask = 1;
06051 if(Arg<CParam*>(0)) Arg<CParam*>(0)->PreVisit1( func, data );
06052 break;
06053 case eSPECPARAM_DECL:
06054 nodeMask = 1;
06055 if(Arg<CParam*>(0)) Arg<CParam*>(0)->PreVisit1( func, data );
06056 break;
06057 case ePORT_DECL:
06058 nodeMask = 1;
06059 if(Arg<CPortDir*>(0)) Arg<CPortDir*>(0)->PreVisit1( func, data );
06060 break;
06061 case eEVENT_DECL:
06062 nodeMask = 1;
06063 if(Arg<CEvent*>(0)) Arg<CEvent*>(0)->PreVisit1( func, data );
06064 break;
06065 case eGENVAR_DECL:
06066 nodeMask = 1;
06067 if(Arg<CGenvar*>(0)) Arg<CGenvar*>(0)->PreVisit1( func, data );
06068 break;
06069 case eLIST:
06070 nodeMask = 0;
06071 break;
06072 case eRANGE:
06073 nodeMask = 0;
06074 break;
06075 case eSLICE:
06076 nodeMask = 0;
06077 break;
06078 case ePSLICE:
06079 nodeMask = 0;
06080 break;
06081 case eMSLICE:
06082 nodeMask = 0;
06083 break;
06084 case eCVRI:
06085 nodeMask = 0;
06086 break;
06087 case eCVIR:
06088 nodeMask = 0;
06089 break;
06090 case eREP:
06091 nodeMask = 0;
06092 break;
06093 case eCAT:
06094 nodeMask = 0;
06095 break;
06096 case eUCAT:
06097 nodeMask = 0;
06098 break;
06099 case eCOM:
06100 nodeMask = 0;
06101 break;
06102 case eNEG:
06103 nodeMask = 0;
06104 break;
06105 case ePLUS:
06106 nodeMask = 0;
06107 break;
06108 case eNOT:
06109 nodeMask = 0;
06110 break;
06111 case eGT:
06112 nodeMask = 0;
06113 break;
06114 case eGE:
06115 nodeMask = 0;
06116 break;
06117 case eLT:
06118 nodeMask = 0;
06119 break;
06120 case eLE:
06121 nodeMask = 0;
06122 break;
06123 case eLAND:
06124 nodeMask = 0;
06125 break;
06126 case eLOR:
06127 nodeMask = 0;
06128 break;
06129 case eCEQ:
06130 nodeMask = 0;
06131 break;
06132 case eCNE:
06133 nodeMask = 0;
06134 break;
06135 case eEQ:
06136 nodeMask = 0;
06137 break;
06138 case eNE:
06139 nodeMask = 0;
06140 break;
06141 case eRAND:
06142 nodeMask = 0;
06143 break;
06144 case eRNAND:
06145 nodeMask = 0;
06146 break;
06147 case eROR:
06148 nodeMask = 0;
06149 break;
06150 case eRNOR:
06151 nodeMask = 0;
06152 break;
06153 case eRXOR:
06154 nodeMask = 0;
06155 break;
06156 case eRXNOR:
06157 nodeMask = 0;
06158 break;
06159 case eHOOK:
06160 nodeMask = 0;
06161 break;
06162 case eINIT:
06163 nodeMask = 0;
06164 break;
06165 case eALWAYS:
06166 nodeMask = 0;
06167 break;
06168 case eEVENT:
06169 nodeMask = 0;
06170 break;
06171 case eBLOCK_REF:
06172 nodeMask = 1;
06173 if(Arg<CBlock*>(0)) Arg<CBlock*>(0)->PreVisit1( func, data );
06174 break;
06175 case eSPECIFY_REF:
06176 nodeMask = 1;
06177 if(Arg<CSpecify*>(0)) Arg<CSpecify*>(0)->PreVisit1( func, data );
06178 break;
06179 case eASSIGN:
06180 nodeMask = 0;
06181 break;
06182 case eFORCE:
06183 nodeMask = 0;
06184 break;
06185 case eRELEASE:
06186 nodeMask = 0;
06187 break;
06188 case eNBASSIGN:
06189 nodeMask = 0;
06190 break;
06191 case ePOSEDGE:
06192 nodeMask = 0;
06193 break;
06194 case eNEGEDGE:
06195 nodeMask = 0;
06196 break;
06197 case eEDGE:
06198 nodeMask = 2;
06199 break;
06200 case eEVOR:
06201 nodeMask = 0;
06202 break;
06203 case eDELAY:
06204 nodeMask = 0;
06205 break;
06206 case eMTM:
06207 nodeMask = 0;
06208 break;
06209 case eIF:
06210 nodeMask = 0;
06211 break;
06212 case eFOREVER:
06213 nodeMask = 0;
06214 break;
06215 case eREPEAT:
06216 nodeMask = 0;
06217 break;
06218 case eWHILE:
06219 nodeMask = 0;
06220 break;
06221 case eWAIT:
06222 nodeMask = 0;
06223 break;
06224 case eFOR:
06225 nodeMask = 0;
06226 break;
06227 case eCASE:
06228 nodeMask = 0;
06229 break;
06230 case eCASEX:
06231 nodeMask = 0;
06232 break;
06233 case eCASEZ:
06234 nodeMask = 0;
06235 break;
06236 case eCASEITEM:
06237 nodeMask = 0;
06238 break;
06239 case eCASSIGN:
06240 nodeMask = 1;
06241 break;
06242 case eARG:
06243 nodeMask = 1;
06244 break;
06245 case eFUNCTION_DEF:
06246 nodeMask = 1;
06247 if(Arg<CFunction*>(0)) Arg<CFunction*>(0)->PreVisit1( func, data );
06248 break;
06249 case eMODULE_DEF:
06250 nodeMask = 1;
06251 if(Arg<CModule*>(0)) Arg<CModule*>(0)->PreVisit1( func, data );
06252 break;
06253 case eREPEAT_CONTROL:
06254 nodeMask = 0;
06255 break;
06256 case eDELAY_CONTROL:
06257 nodeMask = 0;
06258 break;
06259 case eEVENT_CONTROL:
06260 nodeMask = 0;
06261 break;
06262 case eEXTERNAL_REF:
06263 nodeMask = 1;
06264 break;
06265 case ePORT_DEF:
06266 nodeMask = 1;
06267 if(Arg<CPort*>(0)) Arg<CPort*>(0)->PreVisit1( func, data );
06268 break;
06269 case eDEFPARAM:
06270 nodeMask = 0;
06271 break;
06272 case ePATH:
06273 nodeMask = 45;
06274 break;
06275 case ePATH_ASSIGN:
06276 nodeMask = 0;
06277 break;
06278 case eIFNONE_PATH_ASSIGN:
06279 nodeMask = 0;
06280 break;
06281 case eTRIGGER:
06282 nodeMask = 0;
06283 break;
06284 case ePASSIGN:
06285 nodeMask = 0;
06286 break;
06287 case eDEASSIGN:
06288 nodeMask = 0;
06289 break;
06290 case eDISABLE:
06291 nodeMask = 1;
06292 break;
06293 case eATTRIBUTE:
06294 nodeMask = 1;
06295 if(Arg<CAttr*>(0)) Arg<CAttr*>(0)->PreVisit1( func, data );
06296 break;
06297 case eGIF:
06298 nodeMask = 0;
06299 break;
06300 case eGFOR:
06301 nodeMask = 0;
06302 break;
06303 case eGCASE:
06304 nodeMask = 0;
06305 break;
06306 case eTABLE:
06307 nodeMask = 0;
06308 break;
06309 case eTABLE_ENTRY:
06310 nodeMask = 0;
06311 break;
06312 case eTABLE_SYMBOL:
06313 nodeMask = 1;
06314 break;
06315 case ePORTLIST_END:
06316 nodeMask = 0;
06317 break;
06318 case eMACRO_EXPR:
06319 nodeMask = 1;
06320 break;
06321 }
06322
06323
06324
06325
06326 if( GetOp() != eLIST ) {
06327 for( int i = 0; i < ArgCount(); i++ ) {
06328 if( Arg<CNode*>(i) && !((nodeMask>>i)&1) ) Arg<CNode*>(i)->PreVisit1( func, data );
06329 }
06330 } else {
06331 CNode* n = this;
06332 while( 1 ) {
06333 if( n->Arg<CNode*>(0) ) {
06334 n->Arg<CNode*>(0)->PreVisit1( func, data );
06335 }
06336 if( !n->Arg<CNode*>(1) || n->Arg<CNode*>(1)->GetOp() != eLIST ) {
06337 break;
06338 }
06339 n = n->Arg<CNode*>(1);
06340 if( !(*func)( n, data ) ) {
06341 return;
06342 }
06343 if( n->GetAttributes() ) {
06344 n->GetAttributes()->PreVisit1( func, data );
06345 }
06346 }
06347 if( n->Arg<CNode*>(1) ) {
06348 n->Arg<CNode*>(1)->PreVisit1( func, data );
06349 }
06350 }
06351 }
06352
06353
06354
06355
06356
06357
06358
06359 void CNode::PostVisit1( void (*func)(CNode*, void*), void* data )
06360 {
06361 if( GetAttributes() ) {
06362 GetAttributes()->PostVisit1( func, data );
06363 }
06364
06365 int nodeMask = 0;
06366 switch( GetOp() ) {
06367 case eERROR:
06368 nodeMask = 0;
06369 break;
06370 case eVCONSTANT:
06371 nodeMask = 1;
06372 break;
06373 case eRCONSTANT:
06374 nodeMask = 1;
06375 break;
06376 case eCOMMENT:
06377 nodeMask = 1;
06378 break;
06379 case eVRQ:
06380 nodeMask = 1;
06381 break;
06382 case ePRAGMA:
06383 nodeMask = 1;
06384 break;
06385 case eELIST:
06386 nodeMask = 0;
06387 break;
06388 case eWIDTH:
06389 nodeMask = 0;
06390 break;
06391 case eNOP:
06392 nodeMask = 0;
06393 break;
06394 case eSUB:
06395 nodeMask = 0;
06396 break;
06397 case eMUL:
06398 nodeMask = 0;
06399 break;
06400 case eDIV:
06401 nodeMask = 0;
06402 break;
06403 case ePOW:
06404 nodeMask = 0;
06405 break;
06406 case eADD:
06407 nodeMask = 0;
06408 break;
06409 case eLSH:
06410 nodeMask = 0;
06411 break;
06412 case eRSH:
06413 nodeMask = 0;
06414 break;
06415 case eLSHA:
06416 nodeMask = 0;
06417 break;
06418 case eRSHA:
06419 nodeMask = 0;
06420 break;
06421 case eMOD:
06422 nodeMask = 0;
06423 break;
06424 case eOR:
06425 nodeMask = 0;
06426 break;
06427 case eAND:
06428 nodeMask = 0;
06429 break;
06430 case eANDANDAND:
06431 nodeMask = 0;
06432 break;
06433 case eXOR:
06434 nodeMask = 0;
06435 break;
06436 case eXNOR:
06437 nodeMask = 0;
06438 break;
06439 case eINSTANCE_REF:
06440 nodeMask = 1;
06441 if(Arg<CInstance*>(0)) Arg<CInstance*>(0)->PostVisit1( func, data );
06442 break;
06443 case eGATE_REF:
06444 nodeMask = 1;
06445 if(Arg<CGate*>(0)) Arg<CGate*>(0)->PostVisit1( func, data );
06446 break;
06447 case eTASK_ENABLE:
06448 nodeMask = 1;
06449 break;
06450 case eSYSTASK_CALL:
06451 nodeMask = 1;
06452 break;
06453 case eTIMING_CALL:
06454 nodeMask = 1;
06455 break;
06456 case eFUNCTION_CALL:
06457 nodeMask = 5;
06458 break;
06459 case eARRAY:
06460 nodeMask = 0;
06461 break;
06462 case eNET_REF:
06463 nodeMask = ~0;
06464 break;
06465 case eREG_REF:
06466 nodeMask = ~0;
06467 break;
06468 case eREAL_REF:
06469 nodeMask = ~0;
06470 break;
06471 case ePARAM_REF:
06472 nodeMask = ~0;
06473 break;
06474 case ePORT_REF:
06475 nodeMask = ~0;
06476 break;
06477 case eFWD_REF:
06478 nodeMask = ~0;
06479 break;
06480 case eEVENT_REF:
06481 nodeMask = ~0;
06482 break;
06483 case eGENVAR_REF:
06484 nodeMask = ~0;
06485 break;
06486 case eNET_DECL:
06487 nodeMask = 1;
06488 if(Arg<CNet*>(0)) Arg<CNet*>(0)->PostVisit1( func, data );
06489 break;
06490 case eREG_DECL:
06491 nodeMask = 1;
06492 if(Arg<CReg*>(0)) Arg<CReg*>(0)->PostVisit1( func, data );
06493 break;
06494 case eREAL_DECL:
06495 nodeMask = 1;
06496 if(Arg<CReal*>(0)) Arg<CReal*>(0)->PostVisit1( func, data );
06497 break;
06498 case ePARAM_DECL:
06499 nodeMask = 1;
06500 if(Arg<CParam*>(0)) Arg<CParam*>(0)->PostVisit1( func, data );
06501 break;
06502 case eSPECPARAM_DECL:
06503 nodeMask = 1;
06504 if(Arg<CParam*>(0)) Arg<CParam*>(0)->PostVisit1( func, data );
06505 break;
06506 case ePORT_DECL:
06507 nodeMask = 1;
06508 if(Arg<CPortDir*>(0)) Arg<CPortDir*>(0)->PostVisit1( func, data );
06509 break;
06510 case eEVENT_DECL:
06511 nodeMask = 1;
06512 if(Arg<CEvent*>(0)) Arg<CEvent*>(0)->PostVisit1( func, data );
06513 break;
06514 case eGENVAR_DECL:
06515 nodeMask = 1;
06516 if(Arg<CGenvar*>(0)) Arg<CGenvar*>(0)->PostVisit1( func, data );
06517 break;
06518 case eLIST:
06519 nodeMask = 0;
06520 break;
06521 case eRANGE:
06522 nodeMask = 0;
06523 break;
06524 case eSLICE:
06525 nodeMask = 0;
06526 break;
06527 case ePSLICE:
06528 nodeMask = 0;
06529 break;
06530 case eMSLICE:
06531 nodeMask = 0;
06532 break;
06533 case eCVRI:
06534 nodeMask = 0;
06535 break;
06536 case eCVIR:
06537 nodeMask = 0;
06538 break;
06539 case eREP:
06540 nodeMask = 0;
06541 break;
06542 case eCAT:
06543 nodeMask = 0;
06544 break;
06545 case eUCAT:
06546 nodeMask = 0;
06547 break;
06548 case eCOM:
06549 nodeMask = 0;
06550 break;
06551 case eNEG:
06552 nodeMask = 0;
06553 break;
06554 case ePLUS:
06555 nodeMask = 0;
06556 break;
06557 case eNOT:
06558 nodeMask = 0;
06559 break;
06560 case eGT:
06561 nodeMask = 0;
06562 break;
06563 case eGE:
06564 nodeMask = 0;
06565 break;
06566 case eLT:
06567 nodeMask = 0;
06568 break;
06569 case eLE:
06570 nodeMask = 0;
06571 break;
06572 case eLAND:
06573 nodeMask = 0;
06574 break;
06575 case eLOR:
06576 nodeMask = 0;
06577 break;
06578 case eCEQ:
06579 nodeMask = 0;
06580 break;
06581 case eCNE:
06582 nodeMask = 0;
06583 break;
06584 case eEQ:
06585 nodeMask = 0;
06586 break;
06587 case eNE:
06588 nodeMask = 0;
06589 break;
06590 case eRAND:
06591 nodeMask = 0;
06592 break;
06593 case eRNAND:
06594 nodeMask = 0;
06595 break;
06596 case eROR:
06597 nodeMask = 0;
06598 break;
06599 case eRNOR:
06600 nodeMask = 0;
06601 break;
06602 case eRXOR:
06603 nodeMask = 0;
06604 break;
06605 case eRXNOR:
06606 nodeMask = 0;
06607 break;
06608 case eHOOK:
06609 nodeMask = 0;
06610 break;
06611 case eINIT:
06612 nodeMask = 0;
06613 break;
06614 case eALWAYS:
06615 nodeMask = 0;
06616 break;
06617 case eEVENT:
06618 nodeMask = 0;
06619 break;
06620 case eBLOCK_REF:
06621 nodeMask = 1;
06622 if(Arg<CBlock*>(0)) Arg<CBlock*>(0)->PostVisit1( func, data );
06623 break;
06624 case eSPECIFY_REF:
06625 nodeMask = 1;
06626 if(Arg<CSpecify*>(0)) Arg<CSpecify*>(0)->PostVisit1( func, data );
06627 break;
06628 case eASSIGN:
06629 nodeMask = 0;
06630 break;
06631 case eFORCE:
06632 nodeMask = 0;
06633 break;
06634 case eRELEASE:
06635 nodeMask = 0;
06636 break;
06637 case eNBASSIGN:
06638 nodeMask = 0;
06639 break;
06640 case ePOSEDGE:
06641 nodeMask = 0;
06642 break;
06643 case eNEGEDGE:
06644 nodeMask = 0;
06645 break;
06646 case eEDGE:
06647 nodeMask = 2;
06648 break;
06649 case eEVOR:
06650 nodeMask = 0;
06651 break;
06652 case eDELAY:
06653 nodeMask = 0;
06654 break;
06655 case eMTM:
06656 nodeMask = 0;
06657 break;
06658 case eIF:
06659 nodeMask = 0;
06660 break;
06661 case eFOREVER:
06662 nodeMask = 0;
06663 break;
06664 case eREPEAT:
06665 nodeMask = 0;
06666 break;
06667 case eWHILE:
06668 nodeMask = 0;
06669 break;
06670 case eWAIT:
06671 nodeMask = 0;
06672 break;
06673 case eFOR:
06674 nodeMask = 0;
06675 break;
06676 case eCASE:
06677 nodeMask = 0;
06678 break;
06679 case eCASEX:
06680 nodeMask = 0;
06681 break;
06682 case eCASEZ:
06683 nodeMask = 0;
06684 break;
06685 case eCASEITEM:
06686 nodeMask = 0;
06687 break;
06688 case eCASSIGN:
06689 nodeMask = 1;
06690 break;
06691 case eARG:
06692 nodeMask = 1;
06693 break;
06694 case eFUNCTION_DEF:
06695 nodeMask = 1;
06696 if(Arg<CFunction*>(0)) Arg<CFunction*>(0)->PostVisit1( func, data );
06697 break;
06698 case eMODULE_DEF:
06699 nodeMask = 1;
06700 if(Arg<CModule*>(0)) Arg<CModule*>(0)->PostVisit1( func, data );
06701 break;
06702 case eREPEAT_CONTROL:
06703 nodeMask = 0;
06704 break;
06705 case eDELAY_CONTROL:
06706 nodeMask = 0;
06707 break;
06708 case eEVENT_CONTROL:
06709 nodeMask = 0;
06710 break;
06711 case eEXTERNAL_REF:
06712 nodeMask = 1;
06713 break;
06714 case ePORT_DEF:
06715 nodeMask = 1;
06716 if(Arg<CPort*>(0)) Arg<CPort*>(0)->PostVisit1( func, data );
06717 break;
06718 case eDEFPARAM:
06719 nodeMask = 0;
06720 break;
06721 case ePATH:
06722 nodeMask = 45;
06723 break;
06724 case ePATH_ASSIGN:
06725 nodeMask = 0;
06726 break;
06727 case eIFNONE_PATH_ASSIGN:
06728 nodeMask = 0;
06729 break;
06730 case eTRIGGER:
06731 nodeMask = 0;
06732 break;
06733 case ePASSIGN:
06734 nodeMask = 0;
06735 break;
06736 case eDEASSIGN:
06737 nodeMask = 0;
06738 break;
06739 case eDISABLE:
06740 nodeMask = 1;
06741 break;
06742 case eATTRIBUTE:
06743 nodeMask = 1;
06744 if(Arg<CAttr*>(0)) Arg<CAttr*>(0)->PostVisit1( func, data );
06745 break;
06746 case eGIF:
06747 nodeMask = 0;
06748 break;
06749 case eGFOR:
06750 nodeMask = 0;
06751 break;
06752 case eGCASE:
06753 nodeMask = 0;
06754 break;
06755 case eTABLE:
06756 nodeMask = 0;
06757 break;
06758 case eTABLE_ENTRY:
06759 nodeMask = 0;
06760 break;
06761 case eTABLE_SYMBOL:
06762 nodeMask = 1;
06763 break;
06764 case ePORTLIST_END:
06765 nodeMask = 0;
06766 break;
06767 case eMACRO_EXPR:
06768 nodeMask = 1;
06769 break;
06770 }
06771
06772
06773
06774
06775 if( GetOp() != eLIST ) {
06776 for( int i = 0; i < ArgCount(); i++ ) {
06777 if( Arg<CNode*>(i) && !((nodeMask>>i)&1) ) Arg<CNode*>(i)->PostVisit1( func, data );
06778 }
06779 } else {
06780 std::stack<CNode*> visitLog;
06781 CNode* n = this;
06782 while( 1 ) {
06783 if( n->Arg<CNode*>(0) ) {
06784 n->Arg<CNode*>(0)-> PostVisit1( func, data );
06785 }
06786 if( !n->Arg<CNode*>(1) || n->Arg<CNode*>(1)->GetOp() != eLIST ) {
06787 break;
06788 }
06789 visitLog.push(n);
06790 n = n->Arg<CNode*>(1);
06791 if( n->GetAttributes() ) {
06792 n->GetAttributes()->PostVisit1( func, data );
06793 }
06794 }
06795 if( n->Arg<CNode*>(1) ) {
06796 n->Arg<CNode*>(1)->PostVisit1( func, data );
06797 }
06798 while( !visitLog.empty() ) {
06799 CNode* top = visitLog.top();
06800 if( top->Arg<CNode*>(1) ) {
06801 (*func)(top->Arg<CNode*>(1),data);
06802 }
06803 visitLog.pop();
06804 }
06805 }
06806
06807 (*func)( this, data );
06808 }
06809
06810
06811
06812
06813
06814
06815
06816
06817 CNode* CNode::PostSubVisit1( CNode* (*func)(CNode*, void*), void* data )
06818 {
06819 if( GetAttributes() ) {
06820 SetAttributes( GetAttributes()->PostSubVisit1( func, data ) );
06821 }
06822
06823 int nodeMask = 0;
06824 switch( GetOp() ) {
06825 case eERROR:
06826 nodeMask = 0;
06827 break;
06828 case eVCONSTANT:
06829 nodeMask = 1;
06830 break;
06831 case eRCONSTANT:
06832 nodeMask = 1;
06833 break;
06834 case eCOMMENT:
06835 nodeMask = 1;
06836 break;
06837 case eVRQ:
06838 nodeMask = 1;
06839 break;
06840 case ePRAGMA:
06841 nodeMask = 1;
06842 break;
06843 case eELIST:
06844 nodeMask = 0;
06845 break;
06846 case eWIDTH:
06847 nodeMask = 0;
06848 break;
06849 case eNOP:
06850 nodeMask = 0;
06851 break;
06852 case eSUB:
06853 nodeMask = 0;
06854 break;
06855 case eMUL:
06856 nodeMask = 0;
06857 break;
06858 case eDIV:
06859 nodeMask = 0;
06860 break;
06861 case ePOW:
06862 nodeMask = 0;
06863 break;
06864 case eADD:
06865 nodeMask = 0;
06866 break;
06867 case eLSH:
06868 nodeMask = 0;
06869 break;
06870 case eRSH:
06871 nodeMask = 0;
06872 break;
06873 case eLSHA:
06874 nodeMask = 0;
06875 break;
06876 case eRSHA:
06877 nodeMask = 0;
06878 break;
06879 case eMOD:
06880 nodeMask = 0;
06881 break;
06882 case eOR:
06883 nodeMask = 0;
06884 break;
06885 case eAND:
06886 nodeMask = 0;
06887 break;
06888 case eANDANDAND:
06889 nodeMask = 0;
06890 break;
06891 case eXOR:
06892 nodeMask = 0;
06893 break;
06894 case eXNOR:
06895 nodeMask = 0;
06896 break;
06897 case eINSTANCE_REF:
06898 nodeMask = 1;
06899 if(Arg<CInstance*>(0)) Arg<CInstance*>(0)->PostSubVisit1( func, data );
06900 break;
06901 case eGATE_REF:
06902 nodeMask = 1;
06903 if(Arg<CGate*>(0)) Arg<CGate*>(0)->PostSubVisit1( func, data );
06904 break;
06905 case eTASK_ENABLE:
06906 nodeMask = 1;
06907 break;
06908 case eSYSTASK_CALL:
06909 nodeMask = 1;
06910 break;
06911 case eTIMING_CALL:
06912 nodeMask = 1;
06913 break;
06914 case eFUNCTION_CALL:
06915 nodeMask = 5;
06916 break;
06917 case eARRAY:
06918 nodeMask = 0;
06919 break;
06920 case eNET_REF:
06921 nodeMask = ~0;
06922 break;
06923 case eREG_REF:
06924 nodeMask = ~0;
06925 break;
06926 case eREAL_REF:
06927 nodeMask = ~0;
06928 break;
06929 case ePARAM_REF:
06930 nodeMask = ~0;
06931 break;
06932 case ePORT_REF:
06933 nodeMask = ~0;
06934 break;
06935 case eFWD_REF:
06936 nodeMask = ~0;
06937 break;
06938 case eEVENT_REF:
06939 nodeMask = ~0;
06940 break;
06941 case eGENVAR_REF:
06942 nodeMask = ~0;
06943 break;
06944 case eNET_DECL:
06945 nodeMask = 1;
06946 if(Arg<CNet*>(0)) Arg<CNet*>(0)->PostSubVisit1( func, data );
06947 break;
06948 case eREG_DECL:
06949 nodeMask = 1;
06950 if(Arg<CReg*>(0)) Arg<CReg*>(0)->PostSubVisit1( func, data );
06951 break;
06952 case eREAL_DECL:
06953 nodeMask = 1;
06954 if(Arg<CReal*>(0)) Arg<CReal*>(0)->PostSubVisit1( func, data );
06955 break;
06956 case ePARAM_DECL:
06957 nodeMask = 1;
06958 if(Arg<CParam*>(0)) Arg<CParam*>(0)->PostSubVisit1( func, data );
06959 break;
06960 case eSPECPARAM_DECL:
06961 nodeMask = 1;
06962 if(Arg<CParam*>(0)) Arg<CParam*>(0)->PostSubVisit1( func, data );
06963 break;
06964 case ePORT_DECL:
06965 nodeMask = 1;
06966 if(Arg<CPortDir*>(0)) Arg<CPortDir*>(0)->PostSubVisit1( func, data );
06967 break;
06968 case eEVENT_DECL:
06969 nodeMask = 1;
06970 if(Arg<CEvent*>(0)) Arg<CEvent*>(0)->PostSubVisit1( func, data );
06971 break;
06972 case eGENVAR_DECL:
06973 nodeMask = 1;
06974 if(Arg<CGenvar*>(0)) Arg<CGenvar*>(0)->PostSubVisit1( func, data );
06975 break;
06976 case eLIST:
06977 nodeMask = 0;
06978 break;
06979 case eRANGE:
06980 nodeMask = 0;
06981 break;
06982 case eSLICE:
06983 nodeMask = 0;
06984 break;
06985 case ePSLICE:
06986 nodeMask = 0;
06987 break;
06988 case eMSLICE:
06989 nodeMask = 0;
06990 break;
06991 case eCVRI:
06992 nodeMask = 0;
06993 break;
06994 case eCVIR:
06995 nodeMask = 0;
06996 break;
06997 case eREP:
06998 nodeMask = 0;
06999 break;
07000 case eCAT:
07001 nodeMask = 0;
07002 break;
07003 case eUCAT:
07004 nodeMask = 0;
07005 break;
07006 case eCOM:
07007 nodeMask = 0;
07008 break;
07009 case eNEG:
07010 nodeMask = 0;
07011 break;
07012 case ePLUS:
07013 nodeMask = 0;
07014 break;
07015 case eNOT:
07016 nodeMask = 0;
07017 break;
07018 case eGT:
07019 nodeMask = 0;
07020 break;
07021 case eGE:
07022 nodeMask = 0;
07023 break;
07024 case eLT:
07025 nodeMask = 0;
07026 break;
07027 case eLE:
07028 nodeMask = 0;
07029 break;
07030 case eLAND:
07031 nodeMask = 0;
07032 break;
07033 case eLOR:
07034 nodeMask = 0;
07035 break;
07036 case eCEQ:
07037 nodeMask = 0;
07038 break;
07039 case eCNE:
07040 nodeMask = 0;
07041 break;
07042 case eEQ:
07043 nodeMask = 0;
07044 break;
07045 case eNE:
07046 nodeMask = 0;
07047 break;
07048 case eRAND:
07049 nodeMask = 0;
07050 break;
07051 case eRNAND:
07052 nodeMask = 0;
07053 break;
07054 case eROR:
07055 nodeMask = 0;
07056 break;
07057 case eRNOR:
07058 nodeMask = 0;
07059 break;
07060 case eRXOR:
07061 nodeMask = 0;
07062 break;
07063 case eRXNOR:
07064 nodeMask = 0;
07065 break;
07066 case eHOOK:
07067 nodeMask = 0;
07068 break;
07069 case eINIT:
07070 nodeMask = 0;
07071 break;
07072 case eALWAYS:
07073 nodeMask = 0;
07074 break;
07075 case eEVENT:
07076 nodeMask = 0;
07077 break;
07078 case eBLOCK_REF:
07079 nodeMask = 1;
07080 if(Arg<CBlock*>(0)) Arg<CBlock*>(0)->PostSubVisit1( func, data );
07081 break;
07082 case eSPECIFY_REF:
07083 nodeMask = 1;
07084 if(Arg<CSpecify*>(0)) Arg<CSpecify*>(0)->PostSubVisit1( func, data );
07085 break;
07086 case eASSIGN:
07087 nodeMask = 0;
07088 break;
07089 case eFORCE:
07090 nodeMask = 0;
07091 break;
07092 case eRELEASE:
07093 nodeMask = 0;
07094 break;
07095 case eNBASSIGN:
07096 nodeMask = 0;
07097 break;
07098 case ePOSEDGE:
07099 nodeMask = 0;
07100 break;
07101 case eNEGEDGE:
07102 nodeMask = 0;
07103 break;
07104 case eEDGE:
07105 nodeMask = 2;
07106 break;
07107 case eEVOR:
07108 nodeMask = 0;
07109 break;
07110 case eDELAY:
07111 nodeMask = 0;
07112 break;
07113 case eMTM:
07114 nodeMask = 0;
07115 break;
07116 case eIF:
07117 nodeMask = 0;
07118 break;
07119 case eFOREVER:
07120 nodeMask = 0;
07121 break;
07122 case eREPEAT:
07123 nodeMask = 0;
07124 break;
07125 case eWHILE:
07126 nodeMask = 0;
07127 break;
07128 case eWAIT:
07129 nodeMask = 0;
07130 break;
07131 case eFOR:
07132 nodeMask = 0;
07133 break;
07134 case eCASE:
07135 nodeMask = 0;
07136 break;
07137 case eCASEX:
07138 nodeMask = 0;
07139 break;
07140 case eCASEZ:
07141 nodeMask = 0;
07142 break;
07143 case eCASEITEM:
07144 nodeMask = 0;
07145 break;
07146 case eCASSIGN:
07147 nodeMask = 1;
07148 break;
07149 case eARG:
07150 nodeMask = 1;
07151 break;
07152 case eFUNCTION_DEF:
07153 nodeMask = 1;
07154 if(Arg<CFunction*>(0)) Arg<CFunction*>(0)->PostSubVisit1( func, data );
07155 break;
07156 case eMODULE_DEF:
07157 nodeMask = 1;
07158 if(Arg<CModule*>(0)) Arg<CModule*>(0)->PostSubVisit1( func, data );
07159 break;
07160 case eREPEAT_CONTROL:
07161 nodeMask = 0;
07162 break;
07163 case eDELAY_CONTROL:
07164 nodeMask = 0;
07165 break;
07166 case eEVENT_CONTROL:
07167 nodeMask = 0;
07168 break;
07169 case eEXTERNAL_REF:
07170 nodeMask = 1;
07171 break;
07172 case ePORT_DEF:
07173 nodeMask = 1;
07174 if(Arg<CPort*>(0)) Arg<CPort*>(0)->PostSubVisit1( func, data );
07175 break;
07176 case eDEFPARAM:
07177 nodeMask = 0;
07178 break;
07179 case ePATH:
07180 nodeMask = 45;
07181 break;
07182 case ePATH_ASSIGN:
07183 nodeMask = 0;
07184 break;
07185 case eIFNONE_PATH_ASSIGN:
07186 nodeMask = 0;
07187 break;
07188 case eTRIGGER:
07189 nodeMask = 0;
07190 break;
07191 case ePASSIGN:
07192 nodeMask = 0;
07193 break;
07194 case eDEASSIGN:
07195 nodeMask = 0;
07196 break;
07197 case eDISABLE:
07198 nodeMask = 1;
07199 break;
07200 case eATTRIBUTE:
07201 nodeMask = 1;
07202 if(Arg<CAttr*>(0)) Arg<CAttr*>(0)->PostSubVisit1( func, data );
07203 break;
07204 case eGIF:
07205 nodeMask = 0;
07206 break;
07207 case eGFOR:
07208 nodeMask = 0;
07209 break;
07210 case eGCASE:
07211 nodeMask = 0;
07212 break;
07213 case eTABLE:
07214 nodeMask = 0;
07215 break;
07216 case eTABLE_ENTRY:
07217 nodeMask = 0;
07218 break;
07219 case eTABLE_SYMBOL:
07220 nodeMask = 1;
07221 break;
07222 case ePORTLIST_END:
07223 nodeMask = 0;
07224 break;
07225 case eMACRO_EXPR:
07226 nodeMask = 1;
07227 break;
07228 }
07229
07230
07231
07232
07233 if( GetOp() != eLIST ) {
07234 for( int i = 0; i < ArgCount(); i++ ) {
07235 if( Arg<CNode*>(i) && !((nodeMask>>i)&1) ) Arg<CNode*>(i) = Arg<CNode*>(i)->PostSubVisit1( func, data );
07236 }
07237 } else {
07238 std::stack<CNode*> visitLog;
07239 CNode* n = this;
07240 while( 1 ) {
07241 if( n->Arg<CNode*>(0) ) {
07242 n->Arg<CNode*>(0) = n->Arg<CNode*>(0)->
07243 PostSubVisit1( func, data );
07244 }
07245 if( !n->Arg<CNode*>(1) || n->Arg<CNode*>(1)->GetOp() != eLIST ) {
07246 break;
07247 }
07248 visitLog.push(n);
07249 n = n->Arg<CNode*>(1);
07250 if( n->GetAttributes() ) {
07251 n->SetAttributes( n->GetAttributes()->PostSubVisit1( func, data ) );
07252 }
07253 }
07254 if( n->Arg<CNode*>(1) ) {
07255 n->Arg<CNode*>(1) = n->Arg<CNode*>(1)->PostSubVisit1( func, data );
07256 }
07257 while( !visitLog.empty() ) {
07258 CNode* top = visitLog.top();
07259 if( top->Arg<CNode*>(1) ) {
07260 top->Arg<CNode*>(1) = (*func)(top->Arg<CNode*>(1),data);
07261 }
07262 visitLog.pop();
07263 }
07264 }
07265
07266 return (*func)( this, data );
07267 }
07268
07269
07270
07271
07272
07273
07274
07275
07276
07277 unsigned CNode::Hash()
07278 {
07279 unsigned result = GetOp();
07280 int nodeMask = 0;
07281 switch( GetOp() ) {
07282 case eERROR:
07283 nodeMask = 0;
07284 break;
07285 case eVCONSTANT:
07286 nodeMask = 1;
07287 result ^= Arg<CVector*>(0)->Hash();
07288 break;
07289 case eRCONSTANT:
07290 nodeMask = 1;
07291 result ^= strlen(Arg<char*>(0));
07292 break;
07293 case eCOMMENT:
07294 nodeMask = 1;
07295 result ^= strlen(Arg<char*>(0));
07296 break;
07297 case eVRQ:
07298 nodeMask = 1;
07299 result ^= strlen(Arg<char*>(0));
07300 break;
07301 case ePRAGMA:
07302 nodeMask = 1;
07303 result ^= strlen(Arg<char*>(0));
07304 break;
07305 case eELIST:
07306 nodeMask = 0;
07307 break;
07308 case eWIDTH:
07309 nodeMask = 0;
07310 break;
07311 case eNOP:
07312 nodeMask = 0;
07313 break;
07314 case eSUB:
07315 nodeMask = 0;
07316 break;
07317 case eMUL:
07318 nodeMask = 0;
07319 break;
07320 case eDIV:
07321 nodeMask = 0;
07322 break;
07323 case ePOW:
07324 nodeMask = 0;
07325 break;
07326 case eADD:
07327 nodeMask = 0;
07328 break;
07329 case eLSH:
07330 nodeMask = 0;
07331 break;
07332 case eRSH:
07333 nodeMask = 0;
07334 break;
07335 case eLSHA:
07336 nodeMask = 0;
07337 break;
07338 case eRSHA:
07339 nodeMask = 0;
07340 break;
07341 case eMOD:
07342 nodeMask = 0;
07343 break;
07344 case eOR:
07345 nodeMask = 0;
07346 break;
07347 case eAND:
07348 nodeMask = 0;
07349 break;
07350 case eANDANDAND:
07351 nodeMask = 0;
07352 break;
07353 case eXOR:
07354 nodeMask = 0;
07355 break;
07356 case eXNOR:
07357 nodeMask = 0;
07358 break;
07359 case eINSTANCE_REF:
07360 nodeMask = 1;
07361 result ^= Arg<unsigned long>(0);
07362 break;
07363 case eGATE_REF:
07364 nodeMask = 1;
07365 result ^= Arg<unsigned long>(0);
07366 break;
07367 case eTASK_ENABLE:
07368 nodeMask = 1;
07369 result ^= Arg<unsigned long>(0);
07370 break;
07371 case eSYSTASK_CALL:
07372 nodeMask = 1;
07373 result ^= Arg<unsigned long>(0);
07374 break;
07375 case eTIMING_CALL:
07376 nodeMask = 1;
07377 result ^= Arg<unsigned long>(0);
07378 break;
07379 case eFUNCTION_CALL:
07380 nodeMask = 5;
07381 result ^= Arg<unsigned long>(0);
07382 result ^= Arg<unsigned long>(2);
07383 break;
07384 case eARRAY:
07385 nodeMask = 0;
07386 break;
07387 case eNET_REF:
07388 nodeMask = 1;
07389 result ^= Arg<unsigned long>(0);
07390 break;
07391 case eREG_REF:
07392 nodeMask = 1;
07393 result ^= Arg<unsigned long>(0);
07394 break;
07395 case eREAL_REF:
07396 nodeMask = 1;
07397 result ^= Arg<unsigned long>(0);
07398 break;
07399 case ePARAM_REF:
07400 nodeMask = 1;
07401 result ^= Arg<unsigned long>(0);
07402 break;
07403 case ePORT_REF:
07404 nodeMask = 1;
07405 result ^= Arg<unsigned long>(0);
07406 break;
07407 case eFWD_REF:
07408 nodeMask = 1;
07409 result ^= Arg<unsigned long>(0);
07410 break;
07411 case eEVENT_REF:
07412 nodeMask = 1;
07413 result ^= Arg<unsigned long>(0);
07414 break;
07415 case eGENVAR_REF:
07416 nodeMask = 1;
07417 result ^= Arg<unsigned long>(0);
07418 break;
07419 case eNET_DECL:
07420 nodeMask = 1;
07421 result ^= Arg<unsigned long>(0);
07422 break;
07423 case eREG_DECL:
07424 nodeMask = 1;
07425 result ^= Arg<unsigned long>(0);
07426 break;
07427 case eREAL_DECL:
07428 nodeMask = 1;
07429 result ^= Arg<unsigned long>(0);
07430 break;
07431 case ePARAM_DECL:
07432 nodeMask = 1;
07433 result ^= Arg<unsigned long>(0);
07434 break;
07435 case eSPECPARAM_DECL:
07436 nodeMask = 1;
07437 result ^= Arg<unsigned long>(0);
07438 break;
07439 case ePORT_DECL:
07440 nodeMask = 1;
07441 result ^= Arg<unsigned long>(0);
07442 break;
07443 case eEVENT_DECL:
07444 nodeMask = 1;
07445 result ^= Arg<unsigned long>(0);
07446 break;
07447 case eGENVAR_DECL:
07448 nodeMask = 1;
07449 result ^= Arg<unsigned long>(0);
07450 break;
07451 case eLIST:
07452 nodeMask = 0;
07453 break;
07454 case eRANGE:
07455 nodeMask = 0;
07456 break;
07457 case eSLICE:
07458 nodeMask = 0;
07459 break;
07460 case ePSLICE:
07461 nodeMask = 0;
07462 break;
07463 case eMSLICE:
07464 nodeMask = 0;
07465 break;
07466 case eCVRI:
07467 nodeMask = 0;
07468 break;
07469 case eCVIR:
07470 nodeMask = 0;
07471 break;
07472 case eREP:
07473 nodeMask = 0;
07474 break;
07475 case eCAT:
07476 nodeMask = 0;
07477 break;
07478 case eUCAT:
07479 nodeMask = 0;
07480 break;
07481 case eCOM:
07482 nodeMask = 0;
07483 break;
07484 case eNEG:
07485 nodeMask = 0;
07486 break;
07487 case ePLUS:
07488 nodeMask = 0;
07489 break;
07490 case eNOT:
07491 nodeMask = 0;
07492 break;
07493 case eGT:
07494 nodeMask = 0;
07495 break;
07496 case eGE:
07497 nodeMask = 0;
07498 break;
07499 case eLT:
07500 nodeMask = 0;
07501 break;
07502 case eLE:
07503 nodeMask = 0;
07504 break;
07505 case eLAND:
07506 nodeMask = 0;
07507 break;
07508 case eLOR:
07509 nodeMask = 0;
07510 break;
07511 case eCEQ:
07512 nodeMask = 0;
07513 break;
07514 case eCNE:
07515 nodeMask = 0;
07516 break;
07517 case eEQ:
07518 nodeMask = 0;
07519 break;
07520 case eNE:
07521 nodeMask = 0;
07522 break;
07523 case eRAND:
07524 nodeMask = 0;
07525 break;
07526 case eRNAND:
07527 nodeMask = 0;
07528 break;
07529 case eROR:
07530 nodeMask = 0;
07531 break;
07532 case eRNOR:
07533 nodeMask = 0;
07534 break;
07535 case eRXOR:
07536 nodeMask = 0;
07537 break;
07538 case eRXNOR:
07539 nodeMask = 0;
07540 break;
07541 case eHOOK:
07542 nodeMask = 0;
07543 break;
07544 case eINIT:
07545 nodeMask = 0;
07546 break;
07547 case eALWAYS:
07548 nodeMask = 0;
07549 break;
07550 case eEVENT:
07551 nodeMask = 0;
07552 break;
07553 case eBLOCK_REF:
07554 nodeMask = 1;
07555 result ^= Arg<unsigned long>(0);
07556 break;
07557 case eSPECIFY_REF:
07558 nodeMask = 1;
07559 result ^= Arg<unsigned long>(0);
07560 break;
07561 case eASSIGN:
07562 nodeMask = 0;
07563 break;
07564 case eFORCE:
07565 nodeMask = 0;
07566 break;
07567 case eRELEASE:
07568 nodeMask = 0;
07569 break;
07570 case eNBASSIGN:
07571 nodeMask = 0;
07572 break;
07573 case ePOSEDGE:
07574 nodeMask = 0;
07575 break;
07576 case eNEGEDGE:
07577 nodeMask = 0;
07578 break;
07579 case eEDGE:
07580 nodeMask = 2;
07581 result ^= (unsigned long)Arg<Edge_t>(1);
07582 break;
07583 case eEVOR:
07584 nodeMask = 0;
07585 break;
07586 case eDELAY:
07587 nodeMask = 0;
07588 break;
07589 case eMTM:
07590 nodeMask = 0;
07591 break;
07592 case eIF:
07593 nodeMask = 0;
07594 break;
07595 case eFOREVER:
07596 nodeMask = 0;
07597 break;
07598 case eREPEAT:
07599 nodeMask = 0;
07600 break;
07601 case eWHILE:
07602 nodeMask = 0;
07603 break;
07604 case eWAIT:
07605 nodeMask = 0;
07606 break;
07607 case eFOR:
07608 nodeMask = 0;
07609 break;
07610 case eCASE:
07611 nodeMask = 0;
07612 break;
07613 case eCASEX:
07614 nodeMask = 0;
07615 break;
07616 case eCASEZ:
07617 nodeMask = 0;
07618 break;
07619 case eCASEITEM:
07620 nodeMask = 0;
07621 break;
07622 case eCASSIGN:
07623 nodeMask = 1;
07624 result ^= Arg<unsigned long>(0);
07625 break;
07626 case eARG:
07627 nodeMask = 1;
07628 result ^= Arg<unsigned long>(0);
07629 break;
07630 case eFUNCTION_DEF:
07631 nodeMask = 1;
07632 result ^= Arg<unsigned long>(0);
07633 break;
07634 case eMODULE_DEF:
07635 nodeMask = 1;
07636 result ^= Arg<unsigned long>(0);
07637 break;
07638 case eREPEAT_CONTROL:
07639 nodeMask = 0;
07640 break;
07641 case eDELAY_CONTROL:
07642 nodeMask = 0;
07643 break;
07644 case eEVENT_CONTROL:
07645 nodeMask = 0;
07646 break;
07647 case eEXTERNAL_REF:
07648 nodeMask = 1;
07649 result ^= Arg<unsigned long>(0);
07650 break;
07651 case ePORT_DEF:
07652 nodeMask = 1;
07653 result ^= Arg<unsigned long>(0);
07654 break;
07655 case eDEFPARAM:
07656 nodeMask = 0;
07657 break;
07658 case ePATH:
07659 nodeMask = 45;
07660 result ^= Arg<int>(0);
07661 result ^= Arg<int>(2);
07662 result ^= Arg<int>(3);
07663 result ^= Arg<int>(5);
07664 break;
07665 case ePATH_ASSIGN:
07666 nodeMask = 0;
07667 break;
07668 case eIFNONE_PATH_ASSIGN:
07669 nodeMask = 0;
07670 break;
07671 case eTRIGGER:
07672 nodeMask = 0;
07673 break;
07674 case ePASSIGN:
07675 nodeMask = 0;
07676 break;
07677 case eDEASSIGN:
07678 nodeMask = 0;
07679 break;
07680 case eDISABLE:
07681 nodeMask = 1;
07682 result ^= Arg<unsigned long>(0);
07683 break;
07684 case eATTRIBUTE:
07685 nodeMask = 1;
07686 result ^= Arg<unsigned long>(0);
07687 break;
07688 case eGIF:
07689 nodeMask = 0;
07690 break;
07691 case eGFOR:
07692 nodeMask = 0;
07693 break;
07694 case eGCASE:
07695 nodeMask = 0;
07696 break;
07697 case eTABLE:
07698 nodeMask = 0;
07699 break;
07700 case eTABLE_ENTRY:
07701 nodeMask = 0;
07702 break;
07703 case eTABLE_SYMBOL:
07704 nodeMask = 1;
07705 result ^= strlen(Arg<char*>(0));
07706 break;
07707 case ePORTLIST_END:
07708 nodeMask = 0;
07709 break;
07710 case eMACRO_EXPR:
07711 nodeMask = 1;
07712 result ^= strlen(Arg<char*>(0));
07713 break;
07714 }
07715
07716 for( int i = 0; i < ArgCount(); i++ ) {
07717 if( !((nodeMask>>i)&1) ) result ^= Arg<CNode*>(i)->Hash();
07718 }
07719 return result;
07720 }
07721
07722
07723
07724
07725
07726
07727
07728
07729
07730
07731
07732
07733
07734 int Equivalent( CNode* a, CNode* b )
07735 {
07736
07737
07738
07739 if( a == b ) {
07740 return TRUE;
07741 }
07742
07743
07744
07745 if( a == NULL || b == NULL ) {
07746 return FALSE;
07747 }
07748
07749
07750
07751 if( a->GetOp() != b->GetOp() ) {
07752 return FALSE;
07753 }
07754
07755 int nodeMask = 0;
07756 switch( a->GetOp() ) {
07757 case eERROR:
07758 nodeMask = 0;
07759 break;
07760 case eVCONSTANT:
07761 nodeMask = 1;
07762 if( !(*a->Arg<CVector*>(0)==*b->Arg<CVector*>(0)) ) { return FALSE; }
07763 break;
07764 case eRCONSTANT:
07765 nodeMask = 1;
07766 if( !(!strcmp(a->Arg<char*>(0),b->Arg<char*>(0))) ) { return FALSE; }
07767 break;
07768 case eCOMMENT:
07769 nodeMask = 1;
07770 if( !(!strcmp(a->Arg<char*>(0),b->Arg<char*>(0))) ) { return FALSE; }
07771 break;
07772 case eVRQ:
07773 nodeMask = 1;
07774 if( !(!strcmp(a->Arg<char*>(0),b->Arg<char*>(0))) ) { return FALSE; }
07775 break;
07776 case ePRAGMA:
07777 nodeMask = 1;
07778 if( !(!strcmp(a->Arg<char*>(0),b->Arg<char*>(0))) ) { return FALSE; }
07779 break;
07780 case eELIST:
07781 nodeMask = 0;
07782 break;
07783 case eWIDTH:
07784 nodeMask = 0;
07785 break;
07786 case eNOP:
07787 nodeMask = 0;
07788 break;
07789 case eSUB:
07790 nodeMask = 0;
07791 break;
07792 case eMUL:
07793 nodeMask = 0;
07794 break;
07795 case eDIV:
07796 nodeMask = 0;
07797 break;
07798 case ePOW:
07799 nodeMask = 0;
07800 break;
07801 case eADD:
07802 nodeMask = 0;
07803 break;
07804 case eLSH:
07805 nodeMask = 0;
07806 break;
07807 case eRSH:
07808 nodeMask = 0;
07809 break;
07810 case eLSHA:
07811 nodeMask = 0;
07812 break;
07813 case eRSHA:
07814 nodeMask = 0;
07815 break;
07816 case eMOD:
07817 nodeMask = 0;
07818 break;
07819 case eOR:
07820 nodeMask = 0;
07821 break;
07822 case eAND:
07823 nodeMask = 0;
07824 break;
07825 case eANDANDAND:
07826 nodeMask = 0;
07827 break;
07828 case eXOR:
07829 nodeMask = 0;
07830 break;
07831 case eXNOR:
07832 nodeMask = 0;
07833 break;
07834 case eINSTANCE_REF:
07835 nodeMask = 1;
07836 if( !(a->Arg<CInstance*>(0)==b->Arg<CInstance*>(0)) ) { return FALSE; }
07837 break;
07838 case eGATE_REF:
07839 nodeMask = 1;
07840 if( !(a->Arg<CGate*>(0)==b->Arg<CGate*>(0)) ) { return FALSE; }
07841 break;
07842 case eTASK_ENABLE:
07843 nodeMask = 1;
07844 if( !(a->Arg<CSymbol*>(0)==b->Arg<CSymbol*>(0)) ) { return FALSE; }
07845 break;
07846 case eSYSTASK_CALL:
07847 nodeMask = 1;
07848 if( !(a->Arg<CSymbol*>(0)==b->Arg<CSymbol*>(0)) ) { return FALSE; }
07849 break;
07850 case eTIMING_CALL:
07851 nodeMask = 1;
07852 if( !(a->Arg<CSymbol*>(0)==b->Arg<CSymbol*>(0)) ) { return FALSE; }
07853 break;
07854 case eFUNCTION_CALL:
07855 nodeMask = 5;
07856 if( !(a->Arg<CSymbol*>(0)==b->Arg<CSymbol*>(0)) ) { return FALSE; }
07857 if( !(a->Arg<CScope*>(2)==b->Arg<CScope*>(2)) ) { return FALSE; }
07858 break;
07859 case eARRAY:
07860 nodeMask = 0;
07861 break;
07862 case eNET_REF:
07863 nodeMask = 1;
07864 if( !(a->Arg<CNet*>(0)==b->Arg<CNet*>(0)) ) { return FALSE; }
07865 break;
07866 case eREG_REF:
07867 nodeMask = 1;
07868 if( !(a->Arg<CReg*>(0)==b->Arg<CReg*>(0)) ) { return FALSE; }
07869 break;
07870 case eREAL_REF:
07871 nodeMask = 1;
07872 if( !(a->Arg<CReal*>(0)==b->Arg<CReal*>(0)) ) { return FALSE; }
07873 break;
07874 case ePARAM_REF:
07875 nodeMask = 1;
07876 if( !(a->Arg<CParam*>(0)==b->Arg<CParam*>(0)) ) { return FALSE; }
07877 break;
07878 case ePORT_REF:
07879 nodeMask = 1;
07880 if( !(a->Arg<CPortDir*>(0)==b->Arg<CPortDir*>(0)) ) { return FALSE; }
07881 break;
07882 case eFWD_REF:
07883 nodeMask = 1;
07884 if( !(a->Arg<CFref*>(0)==b->Arg<CFref*>(0)) ) { return FALSE; }
07885 break;
07886 case eEVENT_REF:
07887 nodeMask = 1;
07888 if( !(a->Arg<CEvent*>(0)==b->Arg<CEvent*>(0)) ) { return FALSE; }
07889 break;
07890 case eGENVAR_REF:
07891 nodeMask = 1;
07892 if( !(a->Arg<CGenvar*>(0)==b->Arg<CGenvar*>(0)) ) { return FALSE; }
07893 break;
07894 case eNET_DECL:
07895 nodeMask = 1;
07896 if( !(a->Arg<CNet*>(0)==b->Arg<CNet*>(0)) ) { return FALSE; }
07897 break;
07898 case eREG_DECL:
07899 nodeMask = 1;
07900 if( !(a->Arg<CReg*>(0)==b->Arg<CReg*>(0)) ) { return FALSE; }
07901 break;
07902 case eREAL_DECL:
07903 nodeMask = 1;
07904 if( !(a->Arg<CReal*>(0)==b->Arg<CReal*>(0)) ) { return FALSE; }
07905 break;
07906 case ePARAM_DECL:
07907 nodeMask = 1;
07908 if( !(a->Arg<CParam*>(0)==b->Arg<CParam*>(0)) ) { return FALSE; }
07909 break;
07910 case eSPECPARAM_DECL:
07911 nodeMask = 1;
07912 if( !(a->Arg<CParam*>(0)==b->Arg<CParam*>(0)) ) { return FALSE; }
07913 break;
07914 case ePORT_DECL:
07915 nodeMask = 1;
07916 if( !(a->Arg<CPortDir*>(0)==b->Arg<CPortDir*>(0)) ) { return FALSE; }
07917 break;
07918 case eEVENT_DECL:
07919 nodeMask = 1;
07920 if( !(a->Arg<CEvent*>(0)==b->Arg<CEvent*>(0)) ) { return FALSE; }
07921 break;
07922 case eGENVAR_DECL:
07923 nodeMask = 1;
07924 if( !(a->Arg<CGenvar*>(0)==b->Arg<CGenvar*>(0)) ) { return FALSE; }
07925 break;
07926 case eLIST:
07927 nodeMask = 0;
07928 break;
07929 case eRANGE:
07930 nodeMask = 0;
07931 break;
07932 case eSLICE:
07933 nodeMask = 0;
07934 break;
07935 case ePSLICE:
07936 nodeMask = 0;
07937 break;
07938 case eMSLICE:
07939 nodeMask = 0;
07940 break;
07941 case eCVRI:
07942 nodeMask = 0;
07943 break;
07944 case eCVIR:
07945 nodeMask = 0;
07946 break;
07947 case eREP:
07948 nodeMask = 0;
07949 break;
07950 case eCAT:
07951 nodeMask = 0;
07952 break;
07953 case eUCAT:
07954 nodeMask = 0;
07955 break;
07956 case eCOM:
07957 nodeMask = 0;
07958 break;
07959 case eNEG:
07960 nodeMask = 0;
07961 break;
07962 case ePLUS:
07963 nodeMask = 0;
07964 break;
07965 case eNOT:
07966 nodeMask = 0;
07967 break;
07968 case eGT:
07969 nodeMask = 0;
07970 break;
07971 case eGE:
07972 nodeMask = 0;
07973 break;
07974 case eLT:
07975 nodeMask = 0;
07976 break;
07977 case eLE:
07978 nodeMask = 0;
07979 break;
07980 case eLAND:
07981 nodeMask = 0;
07982 break;
07983 case eLOR:
07984 nodeMask = 0;
07985 break;
07986 case eCEQ:
07987 nodeMask = 0;
07988 break;
07989 case eCNE:
07990 nodeMask = 0;
07991 break;
07992 case eEQ:
07993 nodeMask = 0;
07994 break;
07995 case eNE:
07996 nodeMask = 0;
07997 break;
07998 case eRAND:
07999 nodeMask = 0;
08000 break;
08001 case eRNAND:
08002 nodeMask = 0;
08003 break;
08004 case eROR:
08005 nodeMask = 0;
08006 break;
08007 case eRNOR:
08008 nodeMask = 0;
08009 break;
08010 case eRXOR:
08011 nodeMask = 0;
08012 break;
08013 case eRXNOR:
08014 nodeMask = 0;
08015 break;
08016 case eHOOK:
08017 nodeMask = 0;
08018 break;
08019 case eINIT:
08020 nodeMask = 0;
08021 break;
08022 case eALWAYS:
08023 nodeMask = 0;
08024 break;
08025 case eEVENT:
08026 nodeMask = 0;
08027 break;
08028 case eBLOCK_REF:
08029 nodeMask = 1;
08030 if( !(a->Arg<CBlock*>(0)==b->Arg<CBlock*>(0)) ) { return FALSE; }
08031 break;
08032 case eSPECIFY_REF:
08033 nodeMask = 1;
08034 if( !(a->Arg<CSpecify*>(0)==b->Arg<CSpecify*>(0)) ) { return FALSE; }
08035 break;
08036 case eASSIGN:
08037 nodeMask = 0;
08038 break;
08039 case eFORCE:
08040 nodeMask = 0;
08041 break;
08042 case eRELEASE:
08043 nodeMask = 0;
08044 break;
08045 case eNBASSIGN:
08046 nodeMask = 0;
08047 break;
08048 case ePOSEDGE:
08049 nodeMask = 0;
08050 break;
08051 case eNEGEDGE:
08052 nodeMask = 0;
08053 break;
08054 case eEDGE:
08055 nodeMask = 2;
08056 if( !(a->Arg<Edge_t>(1)==b->Arg<Edge_t>(1)) ) { return FALSE; }
08057 break;
08058 case eEVOR:
08059 nodeMask = 0;
08060 break;
08061 case eDELAY:
08062 nodeMask = 0;
08063 break;
08064 case eMTM:
08065 nodeMask = 0;
08066 break;
08067 case eIF:
08068 nodeMask = 0;
08069 break;
08070 case eFOREVER:
08071 nodeMask = 0;
08072 break;
08073 case eREPEAT:
08074 nodeMask = 0;
08075 break;
08076 case eWHILE:
08077 nodeMask = 0;
08078 break;
08079 case eWAIT:
08080 nodeMask = 0;
08081 break;
08082 case eFOR:
08083 nodeMask = 0;
08084 break;
08085 case eCASE:
08086 nodeMask = 0;
08087 break;
08088 case eCASEX:
08089 nodeMask = 0;
08090 break;
08091 case eCASEZ:
08092 nodeMask = 0;
08093 break;
08094 case eCASEITEM:
08095 nodeMask = 0;
08096 break;
08097 case eCASSIGN:
08098 nodeMask = 1;
08099 if( !(a->Arg<StrengthPair_t*>(0)==b->Arg<StrengthPair_t*>(0)) ) { return FALSE; }
08100 break;
08101 case eARG:
08102 nodeMask = 1;
08103 if( !(a->Arg<CSymbol*>(0)==b->Arg<CSymbol*>(0)) ) { return FALSE; }
08104 break;
08105 case eFUNCTION_DEF:
08106 nodeMask = 1;
08107 if( !(a->Arg<CFunction*>(0)==b->Arg<CFunction*>(0)) ) { return FALSE; }
08108 break;
08109 case eMODULE_DEF:
08110 nodeMask = 1;
08111 if( !(a->Arg<CModule*>(0)==b->Arg<CModule*>(0)) ) { return FALSE; }
08112 break;
08113 case eREPEAT_CONTROL:
08114 nodeMask = 0;
08115 break;
08116 case eDELAY_CONTROL:
08117 nodeMask = 0;
08118 break;
08119 case eEVENT_CONTROL:
08120 nodeMask = 0;
08121 break;
08122 case eEXTERNAL_REF:
08123 nodeMask = 1;
08124 if( !(a->Arg<CSymbol*>(0)==b->Arg<CSymbol*>(0)) ) { return FALSE; }
08125 break;
08126 case ePORT_DEF:
08127 nodeMask = 1;
08128 if( !(a->Arg<CPort*>(0)==b->Arg<CPort*>(0)) ) { return FALSE; }
08129 break;
08130 case eDEFPARAM:
08131 nodeMask = 0;
08132 break;
08133 case ePATH:
08134 nodeMask = 45;
08135 if( !(a->Arg<int>(0)==b->Arg<int>(0)) ) { return FALSE; }
08136 if( !(a->Arg<int>(2)==b->Arg<int>(2)) ) { return FALSE; }
08137 if( !(a->Arg<int>(3)==b->Arg<int>(3)) ) { return FALSE; }
08138 if( !(a->Arg<int>(5)==b->Arg<int>(5)) ) { return FALSE; }
08139 break;
08140 case ePATH_ASSIGN:
08141 nodeMask = 0;
08142 break;
08143 case eIFNONE_PATH_ASSIGN:
08144 nodeMask = 0;
08145 break;
08146 case eTRIGGER:
08147 nodeMask = 0;
08148 break;
08149 case ePASSIGN:
08150 nodeMask = 0;
08151 break;
08152 case eDEASSIGN:
08153 nodeMask = 0;
08154 break;
08155 case eDISABLE:
08156 nodeMask = 1;
08157 if( !(a->Arg<CSymbol*>(0)==b->Arg<CSymbol*>(0)) ) { return FALSE; }
08158 break;
08159 case eATTRIBUTE:
08160 nodeMask = 1;
08161 if( !(a->Arg<CAttr*>(0)==b->Arg<CAttr*>(0)) ) { return FALSE; }
08162 break;
08163 case eGIF:
08164 nodeMask = 0;
08165 break;
08166 case eGFOR:
08167 nodeMask = 0;
08168 break;
08169 case eGCASE:
08170 nodeMask = 0;
08171 break;
08172 case eTABLE:
08173 nodeMask = 0;
08174 break;
08175 case eTABLE_ENTRY:
08176 nodeMask = 0;
08177 break;
08178 case eTABLE_SYMBOL:
08179 nodeMask = 1;
08180 if( !(!strcmp(a->Arg<char*>(0),b->Arg<char*>(0))) ) { return FALSE; }
08181 break;
08182 case ePORTLIST_END:
08183 nodeMask = 0;
08184 break;
08185 case eMACRO_EXPR:
08186 nodeMask = 1;
08187 if( !(!strcmp(a->Arg<char*>(0),b->Arg<char*>(0))) ) { return FALSE; }
08188 break;
08189 }
08190
08191 for( int i = 0; i < a->ArgCount(); i++ ) {
08192 if( !((nodeMask>>i)&1) &&
08193 !Equivalent(a->Arg<CNode*>(i),b->Arg<CNode*>(i)) ) return FALSE;
08194 }
08195 return TRUE;
08196 }
08197
08198
08199
08200
08201
08202
08203 int CNode::IsEvaluateable()
08204 {
08205
08206 switch( op ) {
08207 case eFUNCTION_CALL:
08208 return CFunction::Evaluateable(Arg<CSymbol*>(0),Arg<CNode*>(1),Arg<CBlock*>(2));;
08209 case ePARAM_REF:
08210 return Arg<CParam*>(0)->GetExpression()->IsEvaluateable();
08211 case eMACRO_EXPR:
08212 return Arg<CNode*>(1) ? Arg<CNode*>(1)->IsEvaluateable() : FALSE;
08213 case eVCONSTANT:
08214 case eRCONSTANT:
08215 return TRUE;
08216 case eWIDTH:
08217 case eSUB:
08218 case eMUL:
08219 case eDIV:
08220 case ePOW:
08221 case eADD:
08222 case eLSH:
08223 case eRSH:
08224 case eLSHA:
08225 case eRSHA:
08226 case eMOD:
08227 case eOR:
08228 case eAND:
08229 case eXOR:
08230 case eXNOR:
08231 case eCVRI:
08232 case eCVIR:
08233 case eREP:
08234 case eCAT:
08235 case eUCAT:
08236 case eCOM:
08237 case eNEG:
08238 case ePLUS:
08239 case eNOT:
08240 case eGT:
08241 case eGE:
08242 case eLT:
08243 case eLE:
08244 case eLAND:
08245 case eLOR:
08246 case eCEQ:
08247 case eCNE:
08248 case eEQ:
08249 case eNE:
08250 case eRAND:
08251 case eRNAND:
08252 case eROR:
08253 case eRNOR:
08254 case eRXOR:
08255 case eRXNOR:
08256 case eHOOK:
08257 break;
08258 case eERROR:
08259 case eCOMMENT:
08260 case eVRQ:
08261 case ePRAGMA:
08262 case eELIST:
08263 case eNOP:
08264 case eANDANDAND:
08265 case eINSTANCE_REF:
08266 case eGATE_REF:
08267 case eTASK_ENABLE:
08268 case eSYSTASK_CALL:
08269 case eTIMING_CALL:
08270 case eARRAY:
08271 case eNET_REF:
08272 case eREG_REF:
08273 case eREAL_REF:
08274 case ePORT_REF:
08275 case eFWD_REF:
08276 case eEVENT_REF:
08277 case eGENVAR_REF:
08278 case eNET_DECL:
08279 case eREG_DECL:
08280 case eREAL_DECL:
08281 case ePARAM_DECL:
08282 case eSPECPARAM_DECL:
08283 case ePORT_DECL:
08284 case eEVENT_DECL:
08285 case eGENVAR_DECL:
08286 case eLIST:
08287 case eRANGE:
08288 case eSLICE:
08289 case ePSLICE:
08290 case eMSLICE:
08291 case eINIT:
08292 case eALWAYS:
08293 case eEVENT:
08294 case eBLOCK_REF:
08295 case eSPECIFY_REF:
08296 case eASSIGN:
08297 case eFORCE:
08298 case eRELEASE:
08299 case eNBASSIGN:
08300 case ePOSEDGE:
08301 case eNEGEDGE:
08302 case eEDGE:
08303 case eEVOR:
08304 case eDELAY:
08305 case eMTM:
08306 case eIF:
08307 case eFOREVER:
08308 case eREPEAT:
08309 case eWHILE:
08310 case eWAIT:
08311 case eFOR:
08312 case eCASE:
08313 case eCASEX:
08314 case eCASEZ:
08315 case eCASEITEM:
08316 case eCASSIGN:
08317 case eARG:
08318 case eFUNCTION_DEF:
08319 case eMODULE_DEF:
08320 case eREPEAT_CONTROL:
08321 case eDELAY_CONTROL:
08322 case eEVENT_CONTROL:
08323 case eEXTERNAL_REF:
08324 case ePORT_DEF:
08325 case eDEFPARAM:
08326 case ePATH:
08327 case ePATH_ASSIGN:
08328 case eIFNONE_PATH_ASSIGN:
08329 case eTRIGGER:
08330 case ePASSIGN:
08331 case eDEASSIGN:
08332 case eDISABLE:
08333 case eATTRIBUTE:
08334 case eGIF:
08335 case eGFOR:
08336 case eGCASE:
08337 case eTABLE:
08338 case eTABLE_ENTRY:
08339 case eTABLE_SYMBOL:
08340 case ePORTLIST_END:
08341 return FALSE;
08342 default:
08343 MASSERT( FALSE );
08344 }
08345
08346 for( int i = 0; i < ArgCount(); i++ ) {
08347 if( !Arg<CNode*>(i)->IsEvaluateable() ) return FALSE;
08348 }
08349
08350 return TRUE;
08351 }
08352
08353
08354
08355
08356
08357
08358
08359
08360
08361
08362 void CNode::_EvalVector( CVector& v )
08363 {
08364 switch( op ) {
08365 case eVCONSTANT:
08366 { int width = v.GetWidth(); v.SetWidth(Arg<CVector*>(0)->GetWidth()); v = *Arg<CVector*>(0); v.SetWidth(width); };
08367 break;
08368 case eWIDTH:
08369 {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;};
08370 break;
08371 case eSUB:
08372 EVAL_VECTOR_BINARY(Sub);
08373 break;
08374 case eMUL:
08375 EVAL_VECTOR_BINARY(Mul);
08376 break;
08377 case eDIV:
08378 EVAL_VECTOR_BINARY(Div);
08379 break;
08380 case ePOW:
08381 EVAL_VECTOR_BINARY(Pow);
08382 break;
08383 case eADD:
08384 EVAL_VECTOR_BINARY(Add);
08385 break;
08386 case eLSH:
08387 EVAL_VECTOR_BINARY_SELF_RIGHT(Lsh);
08388 break;
08389 case eRSH:
08390 EVAL_VECTOR_BINARY_SELF_RIGHT(Rsh);
08391 break;
08392 case eLSHA:
08393 EVAL_VECTOR_BINARY_SELF_RIGHT(Lsha);
08394 break;
08395 case eRSHA:
08396 EVAL_VECTOR_BINARY_SELF_RIGHT(Rsha);
08397 break;
08398 case eMOD:
08399 EVAL_VECTOR_BINARY(Mod);
08400 break;
08401 case eOR:
08402 EVAL_VECTOR_BINARY(Or);
08403 break;
08404 case eAND:
08405 EVAL_VECTOR_BINARY(And);
08406 break;
08407 case eXOR:
08408 EVAL_VECTOR_BINARY(Xor);
08409 break;
08410 case eXNOR:
08411 EVAL_VECTOR_BINARY(Xnor);
08412 break;
08413 case eFUNCTION_CALL:
08414 CFunction::EvalVector(v,Arg<CSymbol*>(0),Arg<CNode*>(1),Arg<CBlock*>(2));;
08415 break;
08416 case ePARAM_REF:
08417 EVAL_VECTOR_PARAM_REF();
08418 break;
08419 case eCVRI:
08420 v.LoadReal( Arg<CNode*>(0)->_EvalReal() );
08421 break;
08422 case eREP:
08423 EVAL_VECTOR_BINARY(Rep);
08424 break;
08425 case eCAT:
08426 EVAL_VECTOR_BINARY(Cat);
08427 break;
08428 case eUCAT:
08429 { CVector vv(Arg<CNode*>(0)->width); Arg<CNode*>(0)->_EvalVector(vv); v = vv;};
08430 break;
08431 case eCOM:
08432 EVAL_VECTOR_UNARY(Com);
08433 break;
08434 case eNEG:
08435 EVAL_VECTOR_UNARY(Neg);
08436 break;
08437 case ePLUS:
08438 EVAL_VECTOR_UNARY(Plus);
08439 break;
08440 case eNOT:
08441 EVAL_VECTOR_UNARY(Not);
08442 break;
08443 case eGT:
08444 EVAL_RELATIONAL(Gt);
08445 break;
08446 case eGE:
08447 EVAL_RELATIONAL(Ge);
08448 break;
08449 case eLT:
08450 EVAL_RELATIONAL(Lt);
08451 break;
08452 case eLE:
08453 EVAL_RELATIONAL(Le);
08454 break;
08455 case eLAND:
08456 EVAL_VECTOR_BINARY(Land);
08457 break;
08458 case eLOR:
08459 EVAL_VECTOR_BINARY(Lor);
08460 break;
08461 case eCEQ:
08462 EVAL_RELATIONAL(Ceq);
08463 break;
08464 case eCNE:
08465 EVAL_RELATIONAL(Cne);
08466 break;
08467 case eEQ:
08468 EVAL_RELATIONAL(Eq);
08469 break;
08470 case eNE:
08471 EVAL_RELATIONAL(Ne);
08472 break;
08473 case eRAND:
08474 EVAL_VECTOR_UNARY_SELF(Rand);
08475 break;
08476 case eRNAND:
08477 EVAL_VECTOR_UNARY_SELF(Rnand);
08478 break;
08479 case eROR:
08480 EVAL_VECTOR_UNARY_SELF(Ror);
08481 break;
08482 case eRNOR:
08483 EVAL_VECTOR_UNARY_SELF(Rnor);
08484 break;
08485 case eRXOR:
08486 EVAL_VECTOR_UNARY_SELF(Rxor);
08487 break;
08488 case eRXNOR:
08489 EVAL_VECTOR_UNARY_SELF(Rxnor);
08490 break;
08491 case eHOOK:
08492 EVAL_VECTOR_HOOK();
08493 break;
08494 case eMACRO_EXPR:
08495 Arg<CNode*>(1)->EvalVector(v);
08496 break;
08497 default:
08498 MASSERT( FALSE );
08499 }
08500 }
08501
08502
08503
08504
08505
08506
08507
08508
08509
08510
08511 double CNode::_EvalReal()
08512 {
08513 double d;
08514 switch( op ) {
08515 case eRCONSTANT:
08516 d = s2d(Arg<char*>(0));
08517 break;
08518 case eSUB:
08519 EVAL_REAL_BINARY(Sub);
08520 break;
08521 case eMUL:
08522 EVAL_REAL_BINARY(Mul);
08523 break;
08524 case eDIV:
08525 EVAL_REAL_BINARY(Div);
08526 break;
08527 case ePOW:
08528 EVAL_REAL_BINARY(Pow);
08529 break;
08530 case eADD:
08531 EVAL_REAL_BINARY(Add);
08532 break;
08533 case eFUNCTION_CALL:
08534 d = CFunction::EvalReal(Arg<CSymbol*>(0),Arg<CNode*>(1),Arg<CBlock*>(2));;
08535 break;
08536 case ePARAM_REF:
08537 EVAL_REAL_PARAM_REF();
08538 break;
08539 case eCVIR:
08540 { CVector v(Arg<CNode*>(0)->width); v.Signed(Arg<CNode*>(0)->type == eS); Arg<CNode*>(0)->_EvalVector(v); d = v.GetReal(); };
08541 break;
08542 case eNEG:
08543 EVAL_REAL_UNARY(Neg);
08544 break;
08545 case ePLUS:
08546 EVAL_REAL_UNARY(Plus);
08547 break;
08548 case eHOOK:
08549 EVAL_REAL_HOOK();
08550 break;
08551 case eMACRO_EXPR:
08552 d = Arg<CNode*>(1)->EvalReal();
08553 break;
08554 default:
08555 MASSERT( FALSE );
08556 }
08557 return d;
08558 }
08559
08560
08561
08562
08563
08564 int CNode::ConditionalWiden()
08565 {
08566 switch( GetOp() ) {
08567 case eVCONSTANT:
08568 return 0;
08569 case eRCONSTANT:
08570 return 0;
08571 case eELIST:
08572 return 0;
08573 case eWIDTH:
08574 return 0;
08575 case eSUB:
08576 return 0;
08577 case eMUL:
08578 return 0;
08579 case eDIV:
08580 return 0;
08581 case ePOW:
08582 return 0;
08583 case eADD:
08584 return 0;
08585 case eLSH:
08586 return 0;
08587 case eRSH:
08588 return 0;
08589 case eLSHA:
08590 return 0;
08591 case eRSHA:
08592 return 0;
08593 case eMOD:
08594 return 0;
08595 case eOR:
08596 return 1;
08597 case eAND:
08598 return 1;
08599 case eANDANDAND:
08600 return 0;
08601 case eXOR:
08602 return 1;
08603 case eXNOR:
08604 return 1;
08605 case eSYSTASK_CALL:
08606 return 0;
08607 case eFUNCTION_CALL:
08608 return 0;
08609 case eARRAY:
08610 return 0;
08611 case eNET_REF:
08612 return 0;
08613 case eREG_REF:
08614 return 0;
08615 case eREAL_REF:
08616 return 0;
08617 case ePARAM_REF:
08618 return 0;
08619 case ePORT_REF:
08620 return 0;
08621 case eFWD_REF:
08622 return 0;
08623 case eEVENT_REF:
08624 return 0;
08625 case eGENVAR_REF:
08626 return 0;
08627 case eRANGE:
08628 return 0;
08629 case eSLICE:
08630 return 0;
08631 case ePSLICE:
08632 return 0;
08633 case eMSLICE:
08634 return 0;
08635 case eCVRI:
08636 return 0;
08637 case eCVIR:
08638 return 0;
08639 case eREP:
08640 return 0;
08641 case eCAT:
08642 return 0;
08643 case eUCAT:
08644 return 0;
08645 case eCOM:
08646 return 0;
08647 case eNEG:
08648 return 0;
08649 case ePLUS:
08650 return 0;
08651 case eNOT:
08652 return 0;
08653 case eGT:
08654 return 0;
08655 case eGE:
08656 return 0;
08657 case eLT:
08658 return 0;
08659 case eLE:
08660 return 0;
08661 case eLAND:
08662 return 0;
08663 case eLOR:
08664 return 0;
08665 case eCEQ:
08666 return 0;
08667 case eCNE:
08668 return 0;
08669 case eEQ:
08670 return 0;
08671 case eNE:
08672 return 0;
08673 case eRAND:
08674 return 0;
08675 case eRNAND:
08676 return 0;
08677 case eROR:
08678 return 0;
08679 case eRNOR:
08680 return 0;
08681 case eRXOR:
08682 return 0;
08683 case eRXNOR:
08684 return 0;
08685 case eHOOK:
08686 return 0;
08687 case ePOSEDGE:
08688 return 0;
08689 case eNEGEDGE:
08690 return 0;
08691 case eEVOR:
08692 return 0;
08693 case eMTM:
08694 return 0;
08695 case eEXTERNAL_REF:
08696 return 0;
08697 case eATTRIBUTE:
08698 return 0;
08699 case eMACRO_EXPR:
08700 return 0;
08701 default:
08702 MASSERT( FALSE );
08703 }
08704 return 0;
08705 }
08706
08707
08708
08709
08710
08711
08712 unsigned CNode::NodeMask()
08713 {
08714 switch( GetOp() ) {
08715 case eERROR:
08716 return 0;
08717 case eVCONSTANT:
08718 return 0;
08719 case eRCONSTANT:
08720 return 0;
08721 case eCOMMENT:
08722 return 0;
08723 case eVRQ:
08724 return 0;
08725 case ePRAGMA:
08726 return 0;
08727 case eELIST:
08728 return 3;
08729 case eWIDTH:
08730 return 3;
08731 case eNOP:
08732 return 0;
08733 case eSUB:
08734 return 3;
08735 case eMUL:
08736 return 3;
08737 case eDIV:
08738 return 3;
08739 case ePOW:
08740 return 3;
08741 case eADD:
08742 return 3;
08743 case eLSH:
08744 return 3;
08745 case eRSH:
08746 return 3;
08747 case eLSHA:
08748 return 3;
08749 case eRSHA:
08750 return 3;
08751 case eMOD:
08752 return 3;
08753 case eOR:
08754 return 3;
08755 case eAND:
08756 return 3;
08757 case eANDANDAND:
08758 return 3;
08759 case eXOR:
08760 return 3;
08761 case eXNOR:
08762 return 3;
08763 case eINSTANCE_REF:
08764 return 0;
08765 case eGATE_REF:
08766 return 0;
08767 case eTASK_ENABLE:
08768 return 2;
08769 case eSYSTASK_CALL:
08770 return 2;
08771 case eTIMING_CALL:
08772 return 2;
08773 case eFUNCTION_CALL:
08774 return 2;
08775 case eARRAY:
08776 return 3;
08777 case eNET_REF:
08778 return 0;
08779 case eREG_REF:
08780 return 0;
08781 case eREAL_REF:
08782 return 0;
08783 case ePARAM_REF:
08784 return 0;
08785 case ePORT_REF:
08786 return 0;
08787 case eFWD_REF:
08788 return 0;
08789 case eEVENT_REF:
08790 return 0;
08791 case eGENVAR_REF:
08792 return 0;
08793 case eNET_DECL:
08794 return 2;
08795 case eREG_DECL:
08796 return 2;
08797 case eREAL_DECL:
08798 return 2;
08799 case ePARAM_DECL:
08800 return 0;
08801 case eSPECPARAM_DECL:
08802 return 0;
08803 case ePORT_DECL:
08804 return 0;
08805 case eEVENT_DECL:
08806 return 0;
08807 case eGENVAR_DECL:
08808 return 0;
08809 case eLIST:
08810 return 3;
08811 case eRANGE:
08812 return 3;
08813 case eSLICE:
08814 return 3;
08815 case ePSLICE:
08816 return 3;
08817 case eMSLICE:
08818 return 3;
08819 case eCVRI:
08820 return 1;
08821 case eCVIR:
08822 return 1;
08823 case eREP:
08824 return 3;
08825 case eCAT:
08826 return 3;
08827 case eUCAT:
08828 return 1;
08829 case eCOM:
08830 return 1;
08831 case eNEG:
08832 return 1;
08833 case ePLUS:
08834 return 1;
08835 case eNOT:
08836 return 1;
08837 case eGT:
08838 return 3;
08839 case eGE:
08840 return 3;
08841 case eLT:
08842 return 3;
08843 case eLE:
08844 return 3;
08845 case eLAND:
08846 return 3;
08847 case eLOR:
08848 return 3;
08849 case eCEQ:
08850 return 3;
08851 case eCNE:
08852 return 3;
08853 case eEQ:
08854 return 3;
08855 case eNE:
08856 return 3;
08857 case eRAND:
08858 return 1;
08859 case eRNAND:
08860 return 1;
08861 case eROR:
08862 return 1;
08863 case eRNOR:
08864 return 1;
08865 case eRXOR:
08866 return 1;
08867 case eRXNOR:
08868 return 1;
08869 case eHOOK:
08870 return 7;
08871 case eINIT:
08872 return 1;
08873 case eALWAYS:
08874 return 1;
08875 case eEVENT:
08876 return 3;
08877 case eBLOCK_REF:
08878 return 2;
08879 case eSPECIFY_REF:
08880 return 2;
08881 case eASSIGN:
08882 return 7;
08883 case eFORCE:
08884 return 3;
08885 case eRELEASE:
08886 return 1;
08887 case eNBASSIGN:
08888 return 7;
08889 case ePOSEDGE:
08890 return 1;
08891 case eNEGEDGE:
08892 return 1;
08893 case eEDGE:
08894 return 1;
08895 case eEVOR:
08896 return 3;
08897 case eDELAY:
08898 return 3;
08899 case eMTM:
08900 return 7;
08901 case eIF:
08902 return 7;
08903 case eFOREVER:
08904 return 1;
08905 case eREPEAT:
08906 return 3;
08907 case eWHILE:
08908 return 3;
08909 case eWAIT:
08910 return 3;
08911 case eFOR:
08912 return 15;
08913 case eCASE:
08914 return 3;
08915 case eCASEX:
08916 return 3;
08917 case eCASEZ:
08918 return 3;
08919 case eCASEITEM:
08920 return 3;
08921 case eCASSIGN:
08922 return 14;
08923 case eARG:
08924 return 2;
08925 case eFUNCTION_DEF:
08926 return 0;
08927 case eMODULE_DEF:
08928 return 0;
08929 case eREPEAT_CONTROL:
08930 return 3;
08931 case eDELAY_CONTROL:
08932 return 1;
08933 case eEVENT_CONTROL:
08934 return 1;
08935 case eEXTERNAL_REF:
08936 return 0;
08937 case ePORT_DEF:
08938 return 0;
08939 case eDEFPARAM:
08940 return 3;
08941 case ePATH:
08942 return 82;
08943 case ePATH_ASSIGN:
08944 return 7;
08945 case eIFNONE_PATH_ASSIGN:
08946 return 3;
08947 case eTRIGGER:
08948 return 1;
08949 case ePASSIGN:
08950 return 3;
08951 case eDEASSIGN:
08952 return 1;
08953 case eDISABLE:
08954 return 0;
08955 case eATTRIBUTE:
08956 return 0;
08957 case eGIF:
08958 return 7;
08959 case eGFOR:
08960 return 15;
08961 case eGCASE:
08962 return 3;
08963 case eTABLE:
08964 return 1;
08965 case eTABLE_ENTRY:
08966 return 1;
08967 case eTABLE_SYMBOL:
08968 return 0;
08969 case ePORTLIST_END:
08970 return 0;
08971 case eMACRO_EXPR:
08972 return 2;
08973 default:
08974 MASSERT( FALSE );
08975 }
08976 return 0;
08977 }
08978
08979
08980
08981
08982
08983
08984 int CNode::WidthFixed()
08985 {
08986 switch( GetOp() ) {
08987 case eVCONSTANT:
08988 return NodeMask()==0;
08989 case eRCONSTANT:
08990 return 1;
08991 case eELIST:
08992 return NodeMask()==0;
08993 case eWIDTH:
08994 return NodeMask()==0;
08995 case eSUB:
08996 return NodeMask()==0;
08997 case eMUL:
08998 return NodeMask()==0;
08999 case eDIV:
09000 return NodeMask()==0;
09001 case ePOW:
09002 return NodeMask()==0;
09003 case eADD:
09004 return NodeMask()==0;
09005 case eLSH:
09006 return NodeMask()==0;
09007 case eRSH:
09008 return NodeMask()==0;
09009 case eLSHA:
09010 return NodeMask()==0;
09011 case eRSHA:
09012 return NodeMask()==0;
09013 case eMOD:
09014 return NodeMask()==0;
09015 case eOR:
09016 return NodeMask()==0;
09017 case eAND:
09018 return NodeMask()==0;
09019 case eANDANDAND:
09020 return NodeMask()==0;
09021 case eXOR:
09022 return NodeMask()==0;
09023 case eXNOR:
09024 return NodeMask()==0;
09025 case eSYSTASK_CALL:
09026 return NodeMask()==0;
09027 case eFUNCTION_CALL:
09028 return NodeMask()==0;
09029 case eARRAY:
09030 return NodeMask()==0;
09031 case eNET_REF:
09032 return NodeMask()==0;
09033 case eREG_REF:
09034 return NodeMask()==0;
09035 case eREAL_REF:
09036 return NodeMask()==0;
09037 case ePARAM_REF:
09038 return NodeMask()==0;
09039 case ePORT_REF:
09040 return NodeMask()==0;
09041 case eFWD_REF:
09042 return NodeMask()==0;
09043 case eEVENT_REF:
09044 return NodeMask()==0;
09045 case eGENVAR_REF:
09046 return NodeMask()==0;
09047 case eRANGE:
09048 return NodeMask()==0;
09049 case eSLICE:
09050 return NodeMask()==0;
09051 case ePSLICE:
09052 return NodeMask()==0;
09053 case eMSLICE:
09054 return NodeMask()==0;
09055 case eCVRI:
09056 return 1;
09057 case eCVIR:
09058 return 1;
09059 case eREP:
09060 return NodeMask()==0;
09061 case eCAT:
09062 return NodeMask()==0;
09063 case eUCAT:
09064 return NodeMask()==0;
09065 case eCOM:
09066 return NodeMask()==0;
09067 case eNEG:
09068 return NodeMask()==0;
09069 case ePLUS:
09070 return NodeMask()==0;
09071 case eNOT:
09072 return 1;
09073 case eGT:
09074 return 1;
09075 case eGE:
09076 return 1;
09077 case eLT:
09078 return 1;
09079 case eLE:
09080 return 1;
09081 case eLAND:
09082 return 1;
09083 case eLOR:
09084 return 1;
09085 case eCEQ:
09086 return 1;
09087 case eCNE:
09088 return 1;
09089 case eEQ:
09090 return 1;
09091 case eNE:
09092 return 1;
09093 case eRAND:
09094 return 1;
09095 case eRNAND:
09096 return 1;
09097 case eROR:
09098 return 1;
09099 case eRNOR:
09100 return 1;
09101 case eRXOR:
09102 return 1;
09103 case eRXNOR:
09104 return 1;
09105 case eHOOK:
09106 return NodeMask()==0;
09107 case ePOSEDGE:
09108 return NodeMask()==0;
09109 case eNEGEDGE:
09110 return NodeMask()==0;
09111 case eEVOR:
09112 return NodeMask()==0;
09113 case eMTM:
09114 return NodeMask()==0;
09115 case eEXTERNAL_REF:
09116 return NodeMask()==0;
09117 case eATTRIBUTE:
09118 return 1;
09119 case eMACRO_EXPR:
09120 return NodeMask()==0;
09121 default:
09122 MASSERT( FALSE );
09123 }
09124 return 0;
09125 }
09126
09127
09128
09129
09130
09131 struct LabelBitsInfo {
09132 int suppressErrorMessages;
09133 int error;
09134 };
09135
09136 void CNode::_LabelBits( CNode* n, void* arg )
09137 {
09138
09139
09140
09141
09142
09143
09144 if( labelCacheEnabled && (evalCount == 0 || !evalHeap.IsOwner(n)) ) {
09145 if( labelCache.find(n) != labelCache.end() ) {
09146 return;
09147 }
09148 labelCache[n] = 1;
09149 }
09150
09151
09152 LabelBitsInfo* info = (LabelBitsInfo*)arg;
09153 int suppressErrorMessages = info->suppressErrorMessages;
09154 unsigned nodeMask = n->NodeMask();
09155 int conditionalWiden = n->ConditionalWiden();
09156
09157 switch( n->GetOp() ) {
09158 case eVCONSTANT:
09159 n->type = n->Arg<CVector*>(0)->GetNodeType();
09160 break;
09161 case eRCONSTANT:
09162 if(1) {
09163 n->type = eR;
09164 }
09165 break;
09166 case eELIST:
09167 if( n->Arg<CNode*>(0)->type == eR ) {
09168 info->error = 1;
09169 if( !suppressErrorMessages ) {
09170 error(n->GetCoord(), "Illegal expression operand" );
09171 }
09172 } else if( n->Arg<CNode*>(1)->type == eR ) {
09173 info->error = 1;
09174 if( !suppressErrorMessages ) {
09175 error(n->GetCoord(), "Illegal expression operand" );
09176 }
09177 } else if(1) {
09178 n->type = eB;
09179 }
09180 break;
09181 case eWIDTH:
09182 if( n->Arg<CNode*>(1)->type == eS ) {
09183 n->type = eS;
09184 } else if(1) {
09185 n->type = eB;
09186 }
09187 break;
09188 case eSUB:
09189 if( n->Arg<CNode*>(0)->type == eR ) {
09190 n->type = eR;
09191 } else if( n->Arg<CNode*>(1)->type == eR ) {
09192 n->type = eR;
09193 } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
09194 n->type = eS;
09195 } else if(1) {
09196 n->type = eB;
09197 }
09198 break;
09199 case eMUL:
09200 if( n->Arg<CNode*>(0)->type == eR ) {
09201 n->type = eR;
09202 } else if( n->Arg<CNode*>(1)->type == eR ) {
09203 n->type = eR;
09204 } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
09205 n->type = eS;
09206 } else if(1) {
09207 n->type = eB;
09208 }
09209 break;
09210 case eDIV:
09211 if( n->Arg<CNode*>(0)->type == eR ) {
09212 n->type = eR;
09213 } else if( n->Arg<CNode*>(1)->type == eR ) {
09214 n->type = eR;
09215 } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
09216 n->type = eS;
09217 } else if(1) {
09218 n->type = eB;
09219 }
09220 break;
09221 case ePOW:
09222 if( n->Arg<CNode*>(0)->type == eR ) {
09223 n->type = eR;
09224 } else if( n->Arg<CNode*>(1)->type == eR ) {
09225 n->type = eR;
09226 } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
09227 n->type = eS;
09228 } else if(1) {
09229 n->type = eB;
09230 }
09231 break;
09232 case eADD:
09233 if( n->Arg<CNode*>(0)->type == eR ) {
09234 n->type = eR;
09235 } else if( n->Arg<CNode*>(1)->type == eR ) {
09236 n->type = eR;
09237 } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
09238 n->type = eS;
09239 } else if(1) {
09240 n->type = eB;
09241 }
09242 break;
09243 case eLSH:
09244 if( n->Arg<CNode*>(0)->type == eS ) {
09245 n->type = eS;
09246 } else if(1) {
09247 n->type = eB;
09248 }
09249 break;
09250 case eRSH:
09251 if( n->Arg<CNode*>(0)->type == eS ) {
09252 n->type = eS;
09253 } else if(1) {
09254 n->type = eB;
09255 }
09256 break;
09257 case eLSHA:
09258 if( n->Arg<CNode*>(0)->type == eS ) {
09259 n->type = eS;
09260 } else if(1) {
09261 n->type = eB;
09262 }
09263 break;
09264 case eRSHA:
09265 if( n->Arg<CNode*>(0)->type == eS ) {
09266 n->type = eS;
09267 } else if(1) {
09268 n->type = eB;
09269 }
09270 break;
09271 case eMOD:
09272 if( n->Arg<CNode*>(0)->type == eR ) {
09273 info->error = 1;
09274 if( !suppressErrorMessages ) {
09275 error(n->GetCoord(), "Illegal expression operand" );
09276 }
09277 } else if( n->Arg<CNode*>(1)->type == eR ) {
09278 info->error = 1;
09279 if( !suppressErrorMessages ) {
09280 error(n->GetCoord(), "Illegal expression operand" );
09281 }
09282 } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
09283 n->type = eS;
09284 } else if(1) {
09285 n->type = eB;
09286 }
09287 break;
09288 case eOR:
09289 if( n->Arg<CNode*>(0)->type == eR ) {
09290 info->error = 1;
09291 if( !suppressErrorMessages ) {
09292 error(n->GetCoord(), "Illegal expression operand" );
09293 }
09294 } else if( n->Arg<CNode*>(1)->type == eR ) {
09295 info->error = 1;
09296 if( !suppressErrorMessages ) {
09297 error(n->GetCoord(), "Illegal expression operand" );
09298 }
09299 } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
09300 n->type = eS;
09301 } else if(1) {
09302 n->type = eB;
09303 }
09304 break;
09305 case eAND:
09306 if( n->Arg<CNode*>(0)->type == eR ) {
09307 info->error = 1;
09308 if( !suppressErrorMessages ) {
09309 error(n->GetCoord(), "Illegal expression operand" );
09310 }
09311 } else if( n->Arg<CNode*>(1)->type == eR ) {
09312 info->error = 1;
09313 if( !suppressErrorMessages ) {
09314 error(n->GetCoord(), "Illegal expression operand" );
09315 }
09316 } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
09317 n->type = eS;
09318 } else if(1) {
09319 n->type = eB;
09320 }
09321 break;
09322 case eANDANDAND:
09323 if( n->Arg<CNode*>(0)->type == eR ) {
09324 info->error = 1;
09325 if( !suppressErrorMessages ) {
09326 error(n->GetCoord(), "Illegal expression operand" );
09327 }
09328 } else if( n->Arg<CNode*>(1)->type == eR ) {
09329 info->error = 1;
09330 if( !suppressErrorMessages ) {
09331 error(n->GetCoord(), "Illegal expression operand" );
09332 }
09333 } else if(1) {
09334 n->type = eB;
09335 }
09336 break;
09337 case eXOR:
09338 if( n->Arg<CNode*>(0)->type == eR ) {
09339 info->error = 1;
09340 if( !suppressErrorMessages ) {
09341 error(n->GetCoord(), "Illegal expression operand" );
09342 }
09343 } else if( n->Arg<CNode*>(1)->type == eR ) {
09344 info->error = 1;
09345 if( !suppressErrorMessages ) {
09346 error(n->GetCoord(), "Illegal expression operand" );
09347 }
09348 } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
09349 n->type = eS;
09350 } else if(1) {
09351 n->type = eB;
09352 }
09353 break;
09354 case eXNOR:
09355 if( n->Arg<CNode*>(0)->type == eR ) {
09356 info->error = 1;
09357 if( !suppressErrorMessages ) {
09358 error(n->GetCoord(), "Illegal expression operand" );
09359 }
09360 } else if( n->Arg<CNode*>(1)->type == eR ) {
09361 info->error = 1;
09362 if( !suppressErrorMessages ) {
09363 error(n->GetCoord(), "Illegal expression operand" );
09364 }
09365 } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
09366 n->type = eS;
09367 } else if(1) {
09368 n->type = eB;
09369 }
09370 break;
09371 case eSYSTASK_CALL:
09372 n->type = Systask::Type(n->Arg<CSymbol*>(0),n->Arg<CNode*>(1));
09373 break;
09374 case eFUNCTION_CALL:
09375 n->type = CFunction::Type(n->Arg<CSymbol*>(0),n->Arg<CNode*>(1),n->Arg<CScope*>(2));
09376 break;
09377 case eARRAY:
09378 n->type = Array::Type(n->Arg<CNode*>(0),n->Arg<CNode*>(1));
09379 break;
09380 case eNET_REF:
09381 n->type = n->Arg<CNet*>(0)->GetNodeType();
09382 break;
09383 case eREG_REF:
09384 n->type = n->Arg<CReg*>(0)->GetNodeType();
09385 break;
09386 case eREAL_REF:
09387 if(1) {
09388 n->type = eR;
09389 }
09390 break;
09391 case ePARAM_REF:
09392 n->type = n->Arg<CParam*>(0)->GetNodeType();
09393 break;
09394 case ePORT_REF:
09395 n->type = n->Arg<CPortDir*>(0)->GetNodeType();
09396 break;
09397 case eFWD_REF:
09398 if(1) {
09399 n->type = eB;
09400 }
09401 break;
09402 case eEVENT_REF:
09403 if(1) {
09404 n->type = eE;
09405 }
09406 break;
09407 case eGENVAR_REF:
09408 n->type = n->Arg<CGenvar*>(0)->GetNodeType();
09409 break;
09410 case eRANGE:
09411 if( n->Arg<CNode*>(0)->type == eR ) {
09412 info->error = 1;
09413 if( !suppressErrorMessages ) {
09414 error(n->GetCoord(), "Illegal expression operand" );
09415 }
09416 } else if( n->Arg<CNode*>(1)->type == eR ) {
09417 info->error = 1;
09418 if( !suppressErrorMessages ) {
09419 error(n->GetCoord(), "Illegal expression operand" );
09420 }
09421 } else if(1) {
09422 n->type = eB;
09423 }
09424 break;
09425 case eSLICE:
09426 if( n->Arg<CNode*>(0)->type == eR ) {
09427 info->error = 1;
09428 if( !suppressErrorMessages ) {
09429 error(n->GetCoord(), "Illegal expression operand" );
09430 }
09431 } else if( n->Arg<CNode*>(1)->type == eR ) {
09432 info->error = 1;
09433 if( !suppressErrorMessages ) {
09434 error(n->GetCoord(), "Illegal expression operand" );
09435 }
09436 } else if(1) {
09437 n->type = eB;
09438 }
09439 break;
09440 case ePSLICE:
09441 if( n->Arg<CNode*>(1)->type == eR ) {
09442 info->error = 1;
09443 if( !suppressErrorMessages ) {
09444 error(n->GetCoord(), "Illegal expression operand" );
09445 }
09446 } else if(1) {
09447 n->type = eB;
09448 }
09449 break;
09450 case eMSLICE:
09451 if( n->Arg<CNode*>(1)->type == eR ) {
09452 info->error = 1;
09453 if( !suppressErrorMessages ) {
09454 error(n->GetCoord(), "Illegal expression operand" );
09455 }
09456 } else if(1) {
09457 n->type = eB;
09458 }
09459 break;
09460 case eCVRI:
09461 if(1) {
09462 n->type = eS;
09463 }
09464 break;
09465 case eCVIR:
09466 if(1) {
09467 n->type = eR;
09468 }
09469 break;
09470 case eREP:
09471 if( n->Arg<CNode*>(0)->type == eR ) {
09472 info->error = 1;
09473 if( !suppressErrorMessages ) {
09474 error(n->GetCoord(), "Illegal expression operand" );
09475 }
09476 } else if( n->Arg<CNode*>(1)->type == eR ) {
09477 info->error = 1;
09478 if( !suppressErrorMessages ) {
09479 error(n->GetCoord(), "Illegal expression operand" );
09480 }
09481 } else if(1) {
09482 n->type = eB;
09483 }
09484 break;
09485 case eCAT:
09486 if( n->Arg<CNode*>(0)->type == eR ) {
09487 info->error = 1;
09488 if( !suppressErrorMessages ) {
09489 error(n->GetCoord(), "Illegal expression operand" );
09490 }
09491 } else if( n->Arg<CNode*>(1)->type == eR ) {
09492 info->error = 1;
09493 if( !suppressErrorMessages ) {
09494 error(n->GetCoord(), "Illegal expression operand" );
09495 }
09496 } else if(1) {
09497 n->type = eB;
09498 }
09499 break;
09500 case eUCAT:
09501 if( n->Arg<CNode*>(0)->type == eR ) {
09502 info->error = 1;
09503 if( !suppressErrorMessages ) {
09504 error(n->GetCoord(), "Illegal expression operand" );
09505 }
09506 } else if(1) {
09507 n->type = eB;
09508 }
09509 break;
09510 case eCOM:
09511 if( n->Arg<CNode*>(0)->type == eR ) {
09512 info->error = 1;
09513 if( !suppressErrorMessages ) {
09514 error(n->GetCoord(), "Illegal expression operand" );
09515 }
09516 } else if( n->Arg<CNode*>(0)->type == eS ) {
09517 n->type = eS;
09518 } else if(1) {
09519 n->type = eB;
09520 }
09521 break;
09522 case eNEG:
09523 n->type = n->Arg<CNode*>(0)->type;
09524 break;
09525 case ePLUS:
09526 n->type = n->Arg<CNode*>(0)->type;
09527 break;
09528 case eNOT:
09529 if(1) {
09530 n->type = eB;
09531 }
09532 break;
09533 case eGT:
09534 if(1) {
09535 n->type = eB;
09536 }
09537 break;
09538 case eGE:
09539 if(1) {
09540 n->type = eB;
09541 }
09542 break;
09543 case eLT:
09544 if(1) {
09545 n->type = eB;
09546 }
09547 break;
09548 case eLE:
09549 if(1) {
09550 n->type = eB;
09551 }
09552 break;
09553 case eLAND:
09554 if(1) {
09555 n->type = eB;
09556 }
09557 break;
09558 case eLOR:
09559 if(1) {
09560 n->type = eB;
09561 }
09562 break;
09563 case eCEQ:
09564 if( n->Arg<CNode*>(0)->type == eR ) {
09565 info->error = 1;
09566 if( !suppressErrorMessages ) {
09567 error(n->GetCoord(), "Illegal expression operand" );
09568 }
09569 } else if( n->Arg<CNode*>(1)->type == eR ) {
09570 info->error = 1;
09571 if( !suppressErrorMessages ) {
09572 error(n->GetCoord(), "Illegal expression operand" );
09573 }
09574 } else if(1) {
09575 n->type = eB;
09576 }
09577 break;
09578 case eCNE:
09579 if( n->Arg<CNode*>(0)->type == eR ) {
09580 info->error = 1;
09581 if( !suppressErrorMessages ) {
09582 error(n->GetCoord(), "Illegal expression operand" );
09583 }
09584 } else if( n->Arg<CNode*>(1)->type == eR ) {
09585 info->error = 1;
09586 if( !suppressErrorMessages ) {
09587 error(n->GetCoord(), "Illegal expression operand" );
09588 }
09589 } else if(1) {
09590 n->type = eB;
09591 }
09592 break;
09593 case eEQ:
09594 if(1) {
09595 n->type = eB;
09596 }
09597 break;
09598 case eNE:
09599 if(1) {
09600 n->type = eB;
09601 }
09602 break;
09603 case eRAND:
09604 if( n->Arg<CNode*>(0)->type == eR ) {
09605 info->error = 1;
09606 if( !suppressErrorMessages ) {
09607 error(n->GetCoord(), "Illegal expression operand" );
09608 }
09609 } else if(1) {
09610 n->type = eB;
09611 }
09612 break;
09613 case eRNAND:
09614 if( n->Arg<CNode*>(0)->type == eR ) {
09615 info->error = 1;
09616 if( !suppressErrorMessages ) {
09617 error(n->GetCoord(), "Illegal expression operand" );
09618 }
09619 } else if(1) {
09620 n->type = eB;
09621 }
09622 break;
09623 case eROR:
09624 if( n->Arg<CNode*>(0)->type == eR ) {
09625 info->error = 1;
09626 if( !suppressErrorMessages ) {
09627 error(n->GetCoord(), "Illegal expression operand" );
09628 }
09629 } else if(1) {
09630 n->type = eB;
09631 }
09632 break;
09633 case eRNOR:
09634 if( n->Arg<CNode*>(0)->type == eR ) {
09635 info->error = 1;
09636 if( !suppressErrorMessages ) {
09637 error(n->GetCoord(), "Illegal expression operand" );
09638 }
09639 } else if(1) {
09640 n->type = eB;
09641 }
09642 break;
09643 case eRXOR:
09644 if( n->Arg<CNode*>(0)->type == eR ) {
09645 info->error = 1;
09646 if( !suppressErrorMessages ) {
09647 error(n->GetCoord(), "Illegal expression operand" );
09648 }
09649 } else if(1) {
09650 n->type = eB;
09651 }
09652 break;
09653 case eRXNOR:
09654 if( n->Arg<CNode*>(0)->type == eR ) {
09655 info->error = 1;
09656 if( !suppressErrorMessages ) {
09657 error(n->GetCoord(), "Illegal expression operand" );
09658 }
09659 } else if(1) {
09660 n->type = eB;
09661 }
09662 break;
09663 case eHOOK:
09664 if( n->Arg<CNode*>(1)->type == eR ) {
09665 n->type = eR;
09666 } else if( n->Arg<CNode*>(2)->type == eR ) {
09667 n->type = eR;
09668 } else if( n->Arg<CNode*>(1)->type == eS && n->Arg<CNode*>(2)->type == eS ) {
09669 n->type = eS;
09670 } else if(1) {
09671 n->type = eB;
09672 }
09673 break;
09674 case ePOSEDGE:
09675 if(1) {
09676 n->type = eE;
09677 }
09678 break;
09679 case eNEGEDGE:
09680 if(1) {
09681 n->type = eE;
09682 }
09683 break;
09684 case eEVOR:
09685 if(1) {
09686 n->type = eE;
09687 }
09688 break;
09689 case eMTM:
09690 if( n->Arg<CNode*>(0)->type == eR ) {
09691 n->type = eR;
09692 } else if( n->Arg<CNode*>(1)->type == eR ) {
09693 n->type = eR;
09694 } else if( n->Arg<CNode*>(2)->type == eR ) {
09695 n->type = eR;
09696 } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS && n->Arg<CNode*>(2)->type == eS ) {
09697 n->type = eS;
09698 } else if(1) {
09699 n->type = eB;
09700 }
09701 break;
09702 case eEXTERNAL_REF:
09703 n->type = External::Type(n->Arg<CSymbol*>(0));
09704 break;
09705 case eATTRIBUTE:
09706 if(1) {
09707 n->type = eU;
09708 }
09709 break;
09710 case eMACRO_EXPR:
09711 n->type = n->Arg<CNode*>(1)->type;
09712 break;
09713 default:
09714 MASSERT( FALSE );
09715 }
09716
09717
09718
09719
09720 switch( n->type ) {
09721 case eE:
09722 case eR:
09723 n->width = 0;
09724 return;
09725 }
09726
09727
09728
09729
09730 switch( n->GetOp() ) {
09731 case eERROR:
09732 n->width = 0;
09733 break;
09734 case eVCONSTANT:
09735 n->width = (!n->Arg<CVector*>(0)->IsWidthEvaluateable()&&suppressErrorMessages) ? 0 : n->Arg<CVector*>(0)->GetWidth();
09736 break;
09737 case eRCONSTANT:
09738 n->width = 0;
09739 break;
09740 case eELIST:
09741 n->width = cADD(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
09742 break;
09743 case eWIDTH:
09744 n->width = ((info->error |= !n->Arg<CNode*>(0)->IsEvaluateable())&&suppressErrorMessages) ? 0 : n->Arg<CNode*>(0)->EvalINT32();
09745 break;
09746 case eSUB:
09747 n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
09748 break;
09749 case eMUL:
09750 n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
09751 break;
09752 case eDIV:
09753 n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
09754 break;
09755 case ePOW:
09756 n->width = n->Arg<CNode*>(0)->width;
09757 break;
09758 case eADD:
09759 n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
09760 break;
09761 case eLSH:
09762 n->width = n->Arg<CNode*>(0)->width;
09763 break;
09764 case eRSH:
09765 n->width = n->Arg<CNode*>(0)->width;
09766 break;
09767 case eLSHA:
09768 n->width = n->Arg<CNode*>(0)->width;
09769 break;
09770 case eRSHA:
09771 n->width = n->Arg<CNode*>(0)->width;
09772 break;
09773 case eMOD:
09774 n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
09775 break;
09776 case eOR:
09777 n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
09778 break;
09779 case eAND:
09780 n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
09781 break;
09782 case eANDANDAND:
09783 n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
09784 break;
09785 case eXOR:
09786 n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
09787 break;
09788 case eXNOR:
09789 n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
09790 break;
09791 case eSYSTASK_CALL:
09792 n->width = Systask::Width(n->Arg<CSymbol*>(0),n->Arg<CNode*>(1));
09793 break;
09794 case eFUNCTION_CALL:
09795 n->width = CFunction::Width(n->Arg<CSymbol*>(0),n->Arg<CNode*>(1),n->Arg<CScope*>(2));
09796 break;
09797 case eARRAY:
09798 n->width = Array::Width(n->Arg<CNode*>(0),n->Arg<CNode*>(1));
09799 break;
09800 case eNET_REF:
09801 n->width = (!n->Arg<CNet*>(0)->IsWidthEvaluateable()&&suppressErrorMessages) ? 0 : n->Arg<CNet*>(0)->GetWidth();
09802 break;
09803 case eREG_REF:
09804 n->width = (!n->Arg<CReg*>(0)->IsWidthEvaluateable()&&suppressErrorMessages) ? 0 : n->Arg<CReg*>(0)->GetWidth();
09805 break;
09806 case eREAL_REF:
09807 n->width = (!n->Arg<CReal*>(0)->IsWidthEvaluateable()&&suppressErrorMessages) ? 0 : n->Arg<CReal*>(0)->GetWidth();
09808 break;
09809 case ePARAM_REF:
09810 n->width = (!n->Arg<CParam*>(0)->IsWidthEvaluateable()&&suppressErrorMessages) ? 0 : n->Arg<CParam*>(0)->GetWidth();
09811 break;
09812 case ePORT_REF:
09813 n->width = (!n->Arg<CPortDir*>(0)->IsWidthEvaluateable()&&suppressErrorMessages) ? 0 : n->Arg<CPortDir*>(0)->GetWidth();
09814 break;
09815 case eFWD_REF:
09816 n->width = (!n->Arg<CFref*>(0)->IsWidthEvaluateable()&&suppressErrorMessages) ? 0 : n->Arg<CFref*>(0)->GetWidth();
09817 break;
09818 case eGENVAR_REF:
09819 n->width = (!n->Arg<CGenvar*>(0)->IsWidthEvaluateable()&&suppressErrorMessages) ? 0 : n->Arg<CGenvar*>(0)->GetWidth();
09820 break;
09821 case eRANGE:
09822 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());
09823 break;
09824 case eSLICE:
09825 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());
09826 break;
09827 case ePSLICE:
09828 n->width = ((info->error |= !n->Arg<CNode*>(1)->IsEvaluateable())&&suppressErrorMessages) ? 0 : n->Arg<CNode*>(1)->EvalINT32();
09829 break;
09830 case eMSLICE:
09831 n->width = ((info->error |= !n->Arg<CNode*>(1)->IsEvaluateable())&&suppressErrorMessages) ? 0 : n->Arg<CNode*>(1)->EvalINT32();
09832 break;
09833 case eCVRI:
09834 n->width = 32;
09835 break;
09836 case eCVIR:
09837 n->width = 0;
09838 break;
09839 case eREP:
09840 n->width = cMUL(((info->error |= !n->Arg<CNode*>(0)->IsEvaluateable())&&suppressErrorMessages) ? 0: n->Arg<CNode*>(0)->EvalINT32(),n->Arg<CNode*>(1)->width);
09841 break;
09842 case eCAT:
09843 n->width = cADD(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
09844 break;
09845 case eUCAT:
09846 n->width = n->Arg<CNode*>(0)->width;
09847 break;
09848 case eCOM:
09849 n->width = n->Arg<CNode*>(0)->width;
09850 break;
09851 case eNEG:
09852 n->width = n->Arg<CNode*>(0)->width;
09853 break;
09854 case ePLUS:
09855 n->width = n->Arg<CNode*>(0)->width;
09856 break;
09857 case eNOT:
09858 n->width = 1;
09859 break;
09860 case eGT:
09861 n->width = 1;
09862 break;
09863 case eGE:
09864 n->width = 1;
09865 break;
09866 case eLT:
09867 n->width = 1;
09868 break;
09869 case eLE:
09870 n->width = 1;
09871 break;
09872 case eLAND:
09873 n->width = 1;
09874 break;
09875 case eLOR:
09876 n->width = 1;
09877 break;
09878 case eCEQ:
09879 n->width = 1;
09880 break;
09881 case eCNE:
09882 n->width = 1;
09883 break;
09884 case eEQ:
09885 n->width = 1;
09886 break;
09887 case eNE:
09888 n->width = 1;
09889 break;
09890 case eRAND:
09891 n->width = 1;
09892 break;
09893 case eRNAND:
09894 n->width = 1;
09895 break;
09896 case eROR:
09897 n->width = 1;
09898 break;
09899 case eRNOR:
09900 n->width = 1;
09901 break;
09902 case eRXOR:
09903 n->width = 1;
09904 break;
09905 case eRXNOR:
09906 n->width = 1;
09907 break;
09908 case eHOOK:
09909 n->width = cMAX(n->Arg<CNode*>(1)->width,n->Arg<CNode*>(2)->width);
09910 break;
09911 case eMTM:
09912 n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width,n->Arg<CNode*>(2)->width);
09913 break;
09914 case eEXTERNAL_REF:
09915 n->width = External::Width(n->Arg<CSymbol*>(0));
09916 break;
09917 case eATTRIBUTE:
09918 n->width = 0;
09919 break;
09920 case eMACRO_EXPR:
09921 n->width = n->Arg<CNode*>(1)->width;
09922 break;
09923 }
09924
09925
09926
09927
09928 n->FixedWidth(1);
09929 int operandWidth = -1;
09930 for( int i = 0; i < n->ArgCount(); i++ ) {
09931 if( ((nodeMask>>i)&1) && n->Arg<CNode*>(i) ) {
09932 int widthFixed = n->Arg<CNode*>(i)->WidthFixed() ||
09933 n->Arg<CNode*>(i)->FixedWidth();
09934
09935 if( n->ConditionalWiden() && !widthFixed ) {
09936 n->FixedWidth( 0 );
09937 break;
09938 } else if( !widthFixed ) {
09939 n->FixedWidth( 0 );
09940 break;
09941 } else {
09942 int w = n->Arg<CNode*>(i)->width;
09943 if( operandWidth != w ) {
09944 if( operandWidth >= 0 ) {
09945 n->FixedWidth( 0 );
09946 break;
09947 }
09948 operandWidth = w;
09949 }
09950 }
09951 }
09952 }
09953 if( !conditionalWiden && nodeMask != 0 ) {
09954 n->FixedWidth( 0 );
09955 }
09956 }
09957
09958
09959
09960
09961
09962
09963
09964
09965
09966
09967 CNode* CNode::FixBits( INT32 newWidth, NodeType_t newType )
09968 {
09969
09970 int calculateMax = 0;
09971 int realOp = 0;
09972 int conditionalWiden = ConditionalWiden();
09973 unsigned nodeMask = NodeMask();
09974 unsigned scalarMask = 0;
09975 unsigned selfDeterminedMask = 0;
09976 switch( GetOp() ) {
09977 case eERROR:
09978 realOp = 0;
09979 break;
09980 case eVCONSTANT:
09981 realOp = 0;
09982 break;
09983 case eRCONSTANT:
09984 realOp = 0;
09985 break;
09986 case eCOMMENT:
09987 realOp = 0;
09988 break;
09989 case eVRQ:
09990 realOp = 0;
09991 break;
09992 case ePRAGMA:
09993 realOp = 0;
09994 break;
09995 case eELIST:
09996 realOp = 0;
09997 selfDeterminedMask = nodeMask;
09998 break;
09999 case eWIDTH:
10000 realOp = 0;
10001 selfDeterminedMask = nodeMask;
10002 break;
10003 case eNOP:
10004 realOp = 0;
10005 break;
10006 case eSUB:
10007 realOp = 1;
10008 break;
10009 case eMUL:
10010 realOp = 1;
10011 break;
10012 case eDIV:
10013 realOp = 1;
10014 break;
10015 case ePOW:
10016 realOp = 1;
10017 selfDeterminedMask = 1<<1;
10018 break;
10019 case eADD:
10020 realOp = 1;
10021 break;
10022 case eLSH:
10023 realOp = 0;
10024 selfDeterminedMask = 1<<1;
10025 break;
10026 case eRSH:
10027 realOp = 0;
10028 selfDeterminedMask = 1<<1;
10029 break;
10030 case eLSHA:
10031 realOp = 0;
10032 selfDeterminedMask = 1<<1;
10033 break;
10034 case eRSHA:
10035 realOp = 0;
10036 selfDeterminedMask = 1<<1;
10037 break;
10038 case eMOD:
10039 realOp = 0;
10040 break;
10041 case eOR:
10042 realOp = 0;
10043 break;
10044 case eAND:
10045 realOp = 0;
10046 break;
10047 case eANDANDAND:
10048 realOp = 0;
10049 break;
10050 case eXOR:
10051 realOp = 0;
10052 break;
10053 case eXNOR:
10054 realOp = 0;
10055 break;
10056 case eINSTANCE_REF:
10057 realOp = 0;
10058 break;
10059 case eGATE_REF:
10060 realOp = 0;
10061 break;
10062 case eTASK_ENABLE:
10063 realOp = 0;
10064 break;
10065 case eSYSTASK_CALL:
10066 realOp = 0;
10067 selfDeterminedMask = nodeMask;
10068 break;
10069 case eTIMING_CALL:
10070 realOp = 0;
10071 break;
10072 case eFUNCTION_CALL:
10073 realOp = 0;
10074 selfDeterminedMask = nodeMask;
10075 break;
10076 case eARRAY:
10077 realOp = 0;
10078 selfDeterminedMask = 1<<1;
10079 break;
10080 case eNET_REF:
10081 realOp = 0;
10082 break;
10083 case eREG_REF:
10084 realOp = 0;
10085 break;
10086 case eREAL_REF:
10087 realOp = 0;
10088 break;
10089 case ePARAM_REF:
10090 realOp = 0;
10091 break;
10092 case ePORT_REF:
10093 realOp = 0;
10094 break;
10095 case eFWD_REF:
10096 realOp = 0;
10097 break;
10098 case eEVENT_REF:
10099 realOp = 0;
10100 break;
10101 case eGENVAR_REF:
10102 realOp = 0;
10103 break;
10104 case eNET_DECL:
10105 realOp = 0;
10106 break;
10107 case eREG_DECL:
10108 realOp = 0;
10109 break;
10110 case eREAL_DECL:
10111 realOp = 0;
10112 break;
10113 case ePARAM_DECL:
10114 realOp = 0;
10115 break;
10116 case eSPECPARAM_DECL:
10117 realOp = 0;
10118 break;
10119 case ePORT_DECL:
10120 realOp = 0;
10121 break;
10122 case eEVENT_DECL:
10123 realOp = 0;
10124 break;
10125 case eGENVAR_DECL:
10126 realOp = 0;
10127 break;
10128 case eLIST:
10129 realOp = 0;
10130 break;
10131 case eRANGE:
10132 realOp = 0;
10133 selfDeterminedMask = nodeMask;
10134 break;
10135 case eSLICE:
10136 realOp = 0;
10137 selfDeterminedMask = nodeMask;
10138 break;
10139 case ePSLICE:
10140 realOp = 0;
10141 selfDeterminedMask = nodeMask;
10142 break;
10143 case eMSLICE:
10144 realOp = 0;
10145 selfDeterminedMask = nodeMask;
10146 break;
10147 case eCVRI:
10148 realOp = 0;
10149 selfDeterminedMask = nodeMask;
10150 break;
10151 case eCVIR:
10152 realOp = 0;
10153 selfDeterminedMask = nodeMask;
10154 break;
10155 case eREP:
10156 realOp = 0;
10157 selfDeterminedMask = nodeMask;
10158 break;
10159 case eCAT:
10160 realOp = 0;
10161 selfDeterminedMask = nodeMask;
10162 break;
10163 case eUCAT:
10164 realOp = 0;
10165 selfDeterminedMask = nodeMask;
10166 break;
10167 case eCOM:
10168 realOp = 0;
10169 break;
10170 case eNEG:
10171 realOp = 0;
10172 break;
10173 case ePLUS:
10174 realOp = 0;
10175 break;
10176 case eNOT:
10177 realOp = 0;
10178 scalarMask = 1;
10179 break;
10180 case eGT:
10181 realOp = 0;
10182 calculateMax = 1;
10183 break;
10184 case eGE:
10185 realOp = 0;
10186 calculateMax = 1;
10187 break;
10188 case eLT:
10189 realOp = 0;
10190 calculateMax = 1;
10191 break;
10192 case eLE:
10193 realOp = 0;
10194 calculateMax = 1;
10195 break;
10196 case eLAND:
10197 realOp = 0;
10198 scalarMask = 3;
10199 break;
10200 case eLOR:
10201 realOp = 0;
10202 scalarMask = 3;
10203 break;
10204 case eCEQ:
10205 realOp = 0;
10206 calculateMax = 1;
10207 break;
10208 case eCNE:
10209 realOp = 0;
10210 calculateMax = 1;
10211 break;
10212 case eEQ:
10213 realOp = 0;
10214 calculateMax = 1;
10215 break;
10216 case eNE:
10217 realOp = 0;
10218 calculateMax = 1;
10219 break;
10220 case eRAND:
10221 realOp = 0;
10222 selfDeterminedMask = nodeMask;
10223 break;
10224 case eRNAND:
10225 realOp = 0;
10226 selfDeterminedMask = nodeMask;
10227 break;
10228 case eROR:
10229 realOp = 0;
10230 selfDeterminedMask = nodeMask;
10231 break;
10232 case eRNOR:
10233 realOp = 0;
10234 selfDeterminedMask = nodeMask;
10235 break;
10236 case eRXOR:
10237 realOp = 0;
10238 selfDeterminedMask = nodeMask;
10239 break;
10240 case eRXNOR:
10241 realOp = 0;
10242 selfDeterminedMask = nodeMask;
10243 break;
10244 case eHOOK:
10245 realOp = 1;
10246 scalarMask = 1;
10247 break;
10248 case eINIT:
10249 realOp = 0;
10250 break;
10251 case eALWAYS:
10252 realOp = 0;
10253 break;
10254 case eEVENT:
10255 realOp = 0;
10256 break;
10257 case eBLOCK_REF:
10258 realOp = 0;
10259 break;
10260 case eSPECIFY_REF:
10261 realOp = 0;
10262 break;
10263 case eASSIGN:
10264 realOp = 0;
10265 break;
10266 case eFORCE:
10267 realOp = 0;
10268 break;
10269 case eRELEASE:
10270 realOp = 0;
10271 break;
10272 case eNBASSIGN:
10273 realOp = 0;
10274 break;
10275 case ePOSEDGE:
10276 realOp = 0;
10277 break;
10278 case eNEGEDGE:
10279 realOp = 0;
10280 break;
10281 case eEDGE:
10282 realOp = 0;
10283 break;
10284 case eEVOR:
10285 realOp = 0;
10286 break;
10287 case eDELAY:
10288 realOp = 0;
10289 break;
10290 case eMTM:
10291 realOp = 1;
10292 break;
10293 case eIF:
10294 realOp = 0;
10295 break;
10296 case eFOREVER:
10297 realOp = 0;
10298 break;
10299 case eREPEAT:
10300 realOp = 0;
10301 break;
10302 case eWHILE:
10303 realOp = 0;
10304 break;
10305 case eWAIT:
10306 realOp = 0;
10307 break;
10308 case eFOR:
10309 realOp = 0;
10310 break;
10311 case eCASE:
10312 realOp = 0;
10313 break;
10314 case eCASEX:
10315 realOp = 0;
10316 break;
10317 case eCASEZ:
10318 realOp = 0;
10319 break;
10320 case eCASEITEM:
10321 realOp = 0;
10322 break;
10323 case eCASSIGN:
10324 realOp = 0;
10325 break;
10326 case eARG:
10327 realOp = 0;
10328 break;
10329 case eFUNCTION_DEF:
10330 realOp = 0;
10331 break;
10332 case eMODULE_DEF:
10333 realOp = 0;
10334 break;
10335 case eREPEAT_CONTROL:
10336 realOp = 0;
10337 break;
10338 case eDELAY_CONTROL:
10339 realOp = 0;
10340 break;
10341 case eEVENT_CONTROL:
10342 realOp = 0;
10343 break;
10344 case eEXTERNAL_REF:
10345 realOp = 0;
10346 break;
10347 case ePORT_DEF:
10348 realOp = 0;
10349 break;
10350 case eDEFPARAM:
10351 realOp = 0;
10352 break;
10353 case ePATH:
10354 realOp = 0;
10355 break;
10356 case ePATH_ASSIGN:
10357 realOp = 0;
10358 break;
10359 case eIFNONE_PATH_ASSIGN:
10360 realOp = 0;
10361 break;
10362 case eTRIGGER:
10363 realOp = 0;
10364 break;
10365 case ePASSIGN:
10366 realOp = 0;
10367 break;
10368 case eDEASSIGN:
10369 realOp = 0;
10370 break;
10371 case eDISABLE:
10372 realOp = 0;
10373 break;
10374 case eATTRIBUTE:
10375 realOp = 0;
10376 break;
10377 case eGIF:
10378 realOp = 0;
10379 break;
10380 case eGFOR:
10381 realOp = 0;
10382 break;
10383 case eGCASE:
10384 realOp = 0;
10385 break;
10386 case eTABLE:
10387 realOp = 0;
10388 break;
10389 case eTABLE_ENTRY:
10390 realOp = 0;
10391 break;
10392 case eTABLE_SYMBOL:
10393 realOp = 0;
10394 break;
10395 case ePORTLIST_END:
10396 realOp = 0;
10397 break;
10398 case eMACRO_EXPR:
10399 realOp = 0;
10400 break;
10401 default:
10402 MASSERT( FALSE );
10403 }
10404
10405
10406
10407 unsigned realMask = 0;
10408 unsigned forceRealMask = 0;
10409 int widthsDiffer = 0;
10410 int originalWidth = width;
10411 for( int i = 0; i < ArgCount(); i++ ) {
10412 if( ((nodeMask>>i)&1) && Arg<CNode*>(i)->type == eR ) {
10413 realMask |= 1<<i;
10414 }
10415 if( ((nodeMask>>i)&1) &&
10416 Arg<CNode*>(i)->type != eR &&
10417 (Arg<CNode*>(i)->GetOp() != eVCONSTANT ||
10418 Arg<CNode*>(i)->width != width) ) {
10419 widthsDiffer = 1;
10420 }
10421 }
10422
10423
10424
10425
10426 if( newType == eU && newWidth == 0 ) {
10427 newType = type;
10428 newWidth = width;
10429
10430
10431
10432
10433 } else if( (newType == eB || newType == eS || newType == eU) &&
10434 (type == eB || type == eS) ) {
10435 if( newWidth > width ) {
10436 width = newWidth;
10437 }
10438 if( newType == eU ) {
10439 newType = type;
10440 }
10441 }
10442
10443 MASSERT( newType != eR || newWidth == 0 );
10444 MASSERT( newType != eE || newWidth == 0 );
10445
10446
10447
10448
10449
10450 if( realMask ) {
10451 forceRealMask = (~realMask & nodeMask);
10452 }
10453
10454
10455
10456
10457
10458 int convertWidth = conditionalWiden && FixedWidth();
10459 if( convertWidth ) {
10460 width = originalWidth;
10461 }
10462 if( newType == eB && type == eS ) {
10463 type = eB;
10464 }
10465
10466
10467
10468 int cWidth = width;
10469 NodeType_t cType = type;
10470 if( calculateMax ) {
10471 cType = eS;
10472 int max = 0;
10473 int foundReal = 0;
10474 int foundUnsigned = 0;
10475 for( int i = 0; i < ArgCount(); i++ ) {
10476 if( (nodeMask>>i)&1 ) {
10477 switch( Arg<CNode*>(i)->type ) {
10478 case eB:
10479 foundUnsigned = 1;
10480 break;
10481 case eR:
10482 foundReal = 1;
10483 break;
10484 }
10485 if( Arg<CNode*>(i)->width > max ) {
10486 max = Arg<CNode*>(i)->width;
10487 }
10488 }
10489 }
10490 if( foundReal ) {
10491 cWidth = 0;
10492 cType = eR;
10493 } else if( foundUnsigned ) {
10494 cType = eB;
10495 cWidth = max;
10496 } else {
10497 cWidth = max;
10498 }
10499 }
10500
10501
10502
10503
10504 for( int i = 0; i < ArgCount(); i++ ) {
10505 if( (nodeMask>>i)&1 ) {
10506 if( (scalarMask>>i)&1 ) {
10507 if( Arg<CNode*>(i)->type == eR ) {
10508 CNode* node;
10509 Arg<CNode*>(i) = cNE( Arg<CNode*>(i), cREAL(0), &loc );
10510 Arg<CNode*>(i)->LabelBits();
10511 } else if( type == eR ) {
10512
10513 CNode* node;
10514 Arg<CNode*>(i) = cCNE( Arg<CNode*>(i), cINT32(0), &loc );
10515 Arg<CNode*>(i)->LabelBits();
10516 }
10517 Arg<CNode*>(i) = Arg<CNode*>(i)->FixBits( 0, eU );
10518 } else if( (forceRealMask>>i)&1 ) {
10519 Arg<CNode*>(i) = Arg<CNode*>(i)->FixBits( 0, eR );
10520 } else if( (selfDeterminedMask>>i)&1 ) {
10521 Arg<CNode*>(i) = Arg<CNode*>(i)->FixBits( 0, eU );
10522 } else {
10523 Arg<CNode*>(i) = Arg<CNode*>(i)->FixBits( cWidth, cType );
10524 }
10525 }
10526 }
10527
10528
10529
10530
10531
10532
10533 if( newType != eR && convertWidth ) {
10534 CNode* nn = cWIDTH(cINT32(newWidth), this);
10535 nn->width = newWidth;
10536 nn->type = type;
10537 return nn;
10538 }
10539 if( newType == eR && (type == eB || type == eS) ) {
10540 CNode* nn = cCVIR( this );
10541 nn->width = 0;
10542 nn->type = eR;
10543 return nn;
10544
10545 } else if( (newType == eB || newType == eS) && type == eR ) {
10546 CNode* nn = cCVRI( this );
10547 nn->width = newWidth;
10548 nn->type = newType;
10549 return nn;
10550 }
10551
10552 return this;
10553 }
10554
10555
10556
10557
10558
10559 void CNode::Dump( FILE* f )
10560 {
10561 switch( GetOp() ) {
10562 case eERROR:
10563 fprintf( f, "???" );
10564 break;
10565 case eVCONSTANT:
10566 fprintf( f, "%s", Arg<CVector*>(0)->GetVString() );
10567 break;
10568 case eRCONSTANT:
10569 fprintf( f, "%s", (char*)Arg<char*>(0) );
10570 break;
10571 case ePRAGMA:
10572 fprintf( f, "%s", (char*)Arg<char*>(0) );
10573 break;
10574 case eELIST:
10575 fprintf( f, "" );
10576 Arg<CNode*>(0)->Dump( f );
10577 fprintf( f, "," );
10578 Arg<CNode*>(1)->Dump( f );
10579 fprintf( f, "" );
10580 break;
10581 case eWIDTH:
10582 fprintf( f, "WIDTH(" );
10583 fprintf( f, "%s", type==eS ? "S" : "U" );
10584 fprintf( f, "," );
10585 fprintf( f, "%d", width );
10586 fprintf( f, "," );
10587 Arg<CNode*>(0)->Dump( f );
10588 fprintf( f, "," );
10589 Arg<CNode*>(1)->Dump( f );
10590 fprintf( f, ")" );
10591 break;
10592 case eSUB:
10593 fprintf( f, "(" );
10594 Arg<CNode*>(0)->Dump( f );
10595 fprintf( f, ")-(" );
10596 Arg<CNode*>(1)->Dump( f );
10597 fprintf( f, ")" );
10598 break;
10599 case eMUL:
10600 fprintf( f, "(" );
10601 Arg<CNode*>(0)->Dump( f );
10602 fprintf( f, ")*(" );
10603 Arg<CNode*>(1)->Dump( f );
10604 fprintf( f, ")" );
10605 break;
10606 case eDIV:
10607 fprintf( f, "(" );
10608 Arg<CNode*>(0)->Dump( f );
10609 fprintf( f, ")/(" );
10610 Arg<CNode*>(1)->Dump( f );
10611 fprintf( f, ")" );
10612 break;
10613 case ePOW:
10614 fprintf( f, "(" );
10615 Arg<CNode*>(0)->Dump( f );
10616 fprintf( f, ")**(" );
10617 Arg<CNode*>(1)->Dump( f );
10618 fprintf( f, ")" );
10619 break;
10620 case eADD:
10621 fprintf( f, "(" );
10622 Arg<CNode*>(0)->Dump( f );
10623 fprintf( f, ")+(" );
10624 Arg<CNode*>(1)->Dump( f );
10625 fprintf( f, ")" );
10626 break;
10627 case eLSH:
10628 fprintf( f, "(" );
10629 Arg<CNode*>(0)->Dump( f );
10630 fprintf( f, ")<<(" );
10631 Arg<CNode*>(1)->Dump( f );
10632 fprintf( f, ")" );
10633 break;
10634 case eRSH:
10635 fprintf( f, "(" );
10636 Arg<CNode*>(0)->Dump( f );
10637 fprintf( f, ")>>(" );
10638 Arg<CNode*>(1)->Dump( f );
10639 fprintf( f, ")" );
10640 break;
10641 case eLSHA:
10642 fprintf( f, "(" );
10643 Arg<CNode*>(0)->Dump( f );
10644 fprintf( f, ")<<<(" );
10645 Arg<CNode*>(1)->Dump( f );
10646 fprintf( f, ")" );
10647 break;
10648 case eRSHA:
10649 fprintf( f, "(" );
10650 Arg<CNode*>(0)->Dump( f );
10651 fprintf( f, ")>>>(" );
10652 Arg<CNode*>(1)->Dump( f );
10653 fprintf( f, ")" );
10654 break;
10655 case eMOD:
10656 fprintf( f, "(" );
10657 Arg<CNode*>(0)->Dump( f );
10658 fprintf( f, ")%%(" );
10659 Arg<CNode*>(1)->Dump( f );
10660 fprintf( f, ")" );
10661 break;
10662 case eOR:
10663 fprintf( f, "(" );
10664 Arg<CNode*>(0)->Dump( f );
10665 fprintf( f, ")|(" );
10666 Arg<CNode*>(1)->Dump( f );
10667 fprintf( f, ")" );
10668 break;
10669 case eAND:
10670 fprintf( f, "(" );
10671 Arg<CNode*>(0)->Dump( f );
10672 fprintf( f, ")&(" );
10673 Arg<CNode*>(1)->Dump( f );
10674 fprintf( f, ")" );
10675 break;
10676 case eANDANDAND:
10677 fprintf( f, "(" );
10678 Arg<CNode*>(0)->Dump( f );
10679 fprintf( f, ")&&&(" );
10680 Arg<CNode*>(1)->Dump( f );
10681 fprintf( f, ")" );
10682 break;
10683 case eXOR:
10684 fprintf( f, "(" );
10685 Arg<CNode*>(0)->Dump( f );
10686 fprintf( f, ")^(" );
10687 Arg<CNode*>(1)->Dump( f );
10688 fprintf( f, ")" );
10689 break;
10690 case eXNOR:
10691 fprintf( f, "(" );
10692 Arg<CNode*>(0)->Dump( f );
10693 fprintf( f, ")~^(" );
10694 Arg<CNode*>(1)->Dump( f );
10695 fprintf( f, ")" );
10696 break;
10697 case eFUNCTION_CALL:
10698 fprintf( f, "" );
10699 fprintf( f, "%s", Arg<CSymbol*>(0)->GetName() );
10700 fprintf( f, "(" );
10701 Arg<CNode*>(1)->Dump( f );
10702 fprintf( f, ")" );
10703 break;
10704 case eARRAY:
10705 fprintf( f, "" );
10706 Arg<CNode*>(0)->Dump( f );
10707 fprintf( f, "[" );
10708 Arg<CNode*>(1)->Dump( f );
10709 fprintf( f, "]" );
10710 break;
10711 case eNET_REF:
10712 fprintf( f, "%s", Arg<CNet*>(0)->GetName() );
10713 break;
10714 case eREG_REF:
10715 fprintf( f, "%s", Arg<CReg*>(0)->GetName() );
10716 break;
10717 case eREAL_REF:
10718 fprintf( f, "%s", Arg<CReal*>(0)->GetName() );
10719 break;
10720 case ePARAM_REF:
10721 fprintf( f, "%s", Arg<CParam*>(0)->GetName() );
10722 break;
10723 case ePORT_REF:
10724 fprintf( f, "%s", Arg<CPort*>(0)->GetName() );
10725 break;
10726 case eFWD_REF:
10727 fprintf( f, "%s", Arg<CFref*>(0)->GetName() );
10728 break;
10729 case eGENVAR_REF:
10730 fprintf( f, "%s", Arg<CGenvar*>(0)->GetName() );
10731 break;
10732 case eREG_DECL:
10733 fprintf( f, "RegDecl" );
10734 break;
10735 case eLIST:
10736 fprintf( f, "(" );
10737 Arg<CNode*>(0)->Dump( f );
10738 fprintf( f, "," );
10739 Arg<CNode*>(1)->Dump( f );
10740 fprintf( f, ")" );
10741 break;
10742 case eRANGE:
10743 fprintf( f, "" );
10744 Arg<CNode*>(0)->Dump( f );
10745 fprintf( f, ":" );
10746 Arg<CNode*>(1)->Dump( f );
10747 fprintf( f, "" );
10748 break;
10749 case eSLICE:
10750 fprintf( f, "" );
10751 Arg<CNode*>(0)->Dump( f );
10752 fprintf( f, ":" );
10753 Arg<CNode*>(1)->Dump( f );
10754 fprintf( f, "" );
10755 break;
10756 case ePSLICE:
10757 fprintf( f, "" );
10758 Arg<CNode*>(0)->Dump( f );
10759 fprintf( f, "+:" );
10760 Arg<CNode*>(1)->Dump( f );
10761 fprintf( f, "" );
10762 break;
10763 case eMSLICE:
10764 fprintf( f, "" );
10765 Arg<CNode*>(0)->Dump( f );
10766 fprintf( f, "-:" );
10767 Arg<CNode*>(1)->Dump( f );
10768 fprintf( f, "" );
10769 break;
10770 case eCVRI:
10771 fprintf( f, "CVRI(" );
10772 Arg<CNode*>(0)->Dump( f );
10773 fprintf( f, ")" );
10774 break;
10775 case eCVIR:
10776 fprintf( f, "CVIR(" );
10777 Arg<CNode*>(0)->Dump( f );
10778 fprintf( f, ")" );
10779 break;
10780 case eREP:
10781 fprintf( f, "{" );
10782 Arg<CNode*>(0)->Dump( f );
10783 fprintf( f, "{" );
10784 Arg<CNode*>(1)->Dump( f );
10785 fprintf( f, "}}" );
10786 break;
10787 case eCAT:
10788 fprintf( f, "{" );
10789 Arg<CNode*>(0)->Dump( f );
10790 fprintf( f, "," );
10791 Arg<CNode*>(1)->Dump( f );
10792 fprintf( f, "}" );
10793 break;
10794 case eUCAT:
10795 fprintf( f, "{" );
10796 Arg<CNode*>(0)->Dump( f );
10797 fprintf( f, "}" );
10798 break;
10799 case eCOM:
10800 fprintf( f, "~(" );
10801 Arg<CNode*>(0)->Dump( f );
10802 fprintf( f, ")" );
10803 break;
10804 case eNEG:
10805 fprintf( f, "-(" );
10806 Arg<CNode*>(0)->Dump( f );
10807 fprintf( f, ")" );
10808 break;
10809 case ePLUS:
10810 fprintf( f, "+(" );
10811 Arg<CNode*>(0)->Dump( f );
10812 fprintf( f, ")" );
10813 break;
10814 case eNOT:
10815 fprintf( f, "!(" );
10816 Arg<CNode*>(0)->Dump( f );
10817 fprintf( f, ")" );
10818 break;
10819 case eGT:
10820 fprintf( f, "(" );
10821 Arg<CNode*>(0)->Dump( f );
10822 fprintf( f, ")>(" );
10823 Arg<CNode*>(1)->Dump( f );
10824 fprintf( f, ")" );
10825 break;
10826 case eGE:
10827 fprintf( f, "(" );
10828 Arg<CNode*>(0)->Dump( f );
10829 fprintf( f, ")>=(" );
10830 Arg<CNode*>(1)->Dump( f );
10831 fprintf( f, ")" );
10832 break;
10833 case eLT:
10834 fprintf( f, "(" );
10835 Arg<CNode*>(0)->Dump( f );
10836 fprintf( f, ")<(" );
10837 Arg<CNode*>(1)->Dump( f );
10838 fprintf( f, ")" );
10839 break;
10840 case eLE:
10841 fprintf( f, "(" );
10842 Arg<CNode*>(0)->Dump( f );
10843 fprintf( f, ")<=(" );
10844 Arg<CNode*>(1)->Dump( f );
10845 fprintf( f, ")" );
10846 break;
10847 case eLAND:
10848 fprintf( f, "(" );
10849 Arg<CNode*>(0)->Dump( f );
10850 fprintf( f, ")&&(" );
10851 Arg<CNode*>(1)->Dump( f );
10852 fprintf( f, ")" );
10853 break;
10854 case eLOR:
10855 fprintf( f, "(" );
10856 Arg<CNode*>(0)->Dump( f );
10857 fprintf( f, ")||(" );
10858 Arg<CNode*>(1)->Dump( f );
10859 fprintf( f, ")" );
10860 break;
10861 case eCEQ:
10862 fprintf( f, "(" );
10863 Arg<CNode*>(0)->Dump( f );
10864 fprintf( f, ")===(" );
10865 Arg<CNode*>(1)->Dump( f );
10866 fprintf( f, ")" );
10867 break;
10868 case eCNE:
10869 fprintf( f, "(" );
10870 Arg<CNode*>(0)->Dump( f );
10871 fprintf( f, ")!==(" );
10872 Arg<CNode*>(1)->Dump( f );
10873 fprintf( f, ")" );
10874 break;
10875 case eEQ:
10876 fprintf( f, "(" );
10877 Arg<CNode*>(0)->Dump( f );
10878 fprintf( f, ")==(" );
10879 Arg<CNode*>(1)->Dump( f );
10880 fprintf( f, ")" );
10881 break;
10882 case eNE:
10883 fprintf( f, "(" );
10884 Arg<CNode*>(0)->Dump( f );
10885 fprintf( f, ")!=(" );
10886 Arg<CNode*>(1)->Dump( f );
10887 fprintf( f, ")" );
10888 break;
10889 case eRAND:
10890 fprintf( f, "&(" );
10891 Arg<CNode*>(0)->Dump( f );
10892 fprintf( f, ")" );
10893 break;
10894 case eRNAND:
10895 fprintf( f, "~&(" );
10896 Arg<CNode*>(0)->Dump( f );
10897 fprintf( f, ")" );
10898 break;
10899 case eROR:
10900 fprintf( f, "|(" );
10901 Arg<CNode*>(0)->Dump( f );
10902 fprintf( f, ")" );
10903 break;
10904 case eRNOR:
10905 fprintf( f, "~|(" );
10906 Arg<CNode*>(0)->Dump( f );
10907 fprintf( f, ")" );
10908 break;
10909 case eRXOR:
10910 fprintf( f, "^(" );
10911 Arg<CNode*>(0)->Dump( f );
10912 fprintf( f, ")" );
10913 break;
10914 case eRXNOR:
10915 fprintf( f, "~^(" );
10916 Arg<CNode*>(0)->Dump( f );
10917 fprintf( f, ")" );
10918 break;
10919 case eHOOK:
10920 fprintf( f, "(" );
10921 Arg<CNode*>(0)->Dump( f );
10922 fprintf( f, ")?(" );
10923 Arg<CNode*>(1)->Dump( f );
10924 fprintf( f, "):(" );
10925 Arg<CNode*>(2)->Dump( f );
10926 fprintf( f, ")" );
10927 break;
10928 case eINIT:
10929 fprintf( f, "INIT(*)" );
10930 break;
10931 case ePOSEDGE:
10932 fprintf( f, "POSEDGE(" );
10933 Arg<CNode*>(0)->Dump( f );
10934 fprintf( f, ")" );
10935 break;
10936 case eNEGEDGE:
10937 fprintf( f, "NEGEDGE(" );
10938 Arg<CNode*>(0)->Dump( f );
10939 fprintf( f, ")" );
10940 break;
10941 case eEDGE:
10942 fprintf( f, "EDGE(" );
10943 Arg<CNode*>(0)->Dump( f );
10944 fprintf( f, ")" );
10945 break;
10946 case eMTM:
10947 fprintf( f, "(" );
10948 Arg<CNode*>(0)->Dump( f );
10949 fprintf( f, ":" );
10950 Arg<CNode*>(1)->Dump( f );
10951 fprintf( f, ":" );
10952 Arg<CNode*>(2)->Dump( f );
10953 fprintf( f, ")" );
10954 break;
10955 case eMODULE_DEF:
10956 fprintf( f, "MODULE_DEF" );
10957 break;
10958 case eMACRO_EXPR:
10959 fprintf( f, "" );
10960 fprintf( f, "%s", (const char*)Arg<const char*>(0) );
10961 fprintf( f, "<" );
10962 Arg<CNode*>(1)->Dump( f );
10963 fprintf( f, ">" );
10964 break;
10965 case eCOMMENT:
10966 case eVRQ:
10967 case eNOP:
10968 case eINSTANCE_REF:
10969 case eGATE_REF:
10970 case eTASK_ENABLE:
10971 case eSYSTASK_CALL:
10972 case eTIMING_CALL:
10973 case eEVENT_REF:
10974 case eNET_DECL:
10975 case eREAL_DECL:
10976 case ePARAM_DECL:
10977 case eSPECPARAM_DECL:
10978 case ePORT_DECL:
10979 case eEVENT_DECL:
10980 case eGENVAR_DECL:
10981 case eALWAYS:
10982 case eEVENT:
10983 case eBLOCK_REF:
10984 case eSPECIFY_REF:
10985 case eASSIGN:
10986 case eFORCE:
10987 case eRELEASE:
10988 case eNBASSIGN:
10989 case eEVOR:
10990 case eDELAY:
10991 case eIF:
10992 case eFOREVER:
10993 case eREPEAT:
10994 case eWHILE:
10995 case eWAIT:
10996 case eFOR:
10997 case eCASE:
10998 case eCASEX:
10999 case eCASEZ:
11000 case eCASEITEM:
11001 case eCASSIGN:
11002 case eARG:
11003 case eFUNCTION_DEF:
11004 case eREPEAT_CONTROL:
11005 case eDELAY_CONTROL:
11006 case eEVENT_CONTROL:
11007 case eEXTERNAL_REF:
11008 case ePORT_DEF:
11009 case eDEFPARAM:
11010 case ePATH:
11011 case ePATH_ASSIGN:
11012 case eIFNONE_PATH_ASSIGN:
11013 case eTRIGGER:
11014 case ePASSIGN:
11015 case eDEASSIGN:
11016 case eDISABLE:
11017 case eATTRIBUTE:
11018 case eGIF:
11019 case eGFOR:
11020 case eGCASE:
11021 case eTABLE:
11022 case eTABLE_ENTRY:
11023 case eTABLE_SYMBOL:
11024 case ePORTLIST_END:
11025 MASSERT( FALSE );
11026 break;
11027 }
11028 }
11029
11030 #endif // DEFINE_METHODS
11031
11032 #ifdef DEFINE_TEST_HARNESS
11033 void CNodeTestHarness()
11034 {
11035 for( int i = 0; i < 128; ++i ) {
11036 CNode* n = new(CNode::stack) CNode( NULL, (NodeOp_t)i );
11037 if( n->Precedence() != n->Precedence_1() ) {
11038 printf( "Fail %s\n", nodeOpName[i] );
11039 exit(1);
11040 }
11041 }
11042 }
11043 #endif // DEFINE_TEST_HARNESS