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